1

Programming with TCP/IP

byDr. Yingwu Zhu

2

Socket programming

Socket API introduced in BSD4.1 UNIX,

1981 explicitly created, used,

released by apps client/server paradigm two types of transport

service via socket API: unreliable datagram reliable, byte stream-

oriented

a host-local, application-created/own

ed, OS-controlled interface (a “door”) into which

application process can both send and

receive messages to/from another (remote

or local) application

process

socket

Goal: learn how to build client/server application that communicate using sockets

3

Socket-programming using TCPSocket: a door between application process and end-

end-transport protocol (UCP or TCP)TCP service: reliable transfer of bytes from one

process to another

process

TCP withbuffers,

variables

socket

controlled byapplicationdeveloper

controlled byoperating

system

host orserver

process

TCP withbuffers,

variables

socket

controlled byapplicationdevelopercontrolled byoperatingsystem

host orserver

internet

4

Client Server Computing

two application programs must participate in any communication with one application initiates communication and the one accepts it.

5

Client Server Computing In network applications, a SERVER

application waits passively for contact after informing local protocol software that a specific type of message is expected, while a CLIENT application initiates communication actively by sending a matched type of message.

6

Identifying A Particular Service Transport protocols assign each service

a unique identifier. Both client and server specify the

service identifier; protocol software uses the identifier to direct each incoming request to the correct server.

In TCP/IP, TCP uses 16-bit integer values known as protocol port numbers to identify services.

7

Concurrent Server Concurrent execution is fundamental to

servers because concurrency permits multiple clients to obtain a given service without having to wait for the server to finish previous requests.

In concurrent server designs, the server creates a new thread or process to handle each client.

Transport protocols assign an identifier to each client as well as to each service.

8

The Socket API The interface between an application

program and the communication protocols in an operating system (OS) is known as the Application Program Interface or API.

Sockets provide an implementation of the SAP (Service Access Point) abstraction at the Transport Layer in the TCP/IP protocol suite, which is part of the BSD Unix.

9

Socket A socket library can provide applications with a

socket API on an operating system that does not provide native sockets (e.g. Windows 3.1). When an application calls one of the socket procedures, control passes to a library routine that makes one or more calls to the underlying OS to implement the socket function.

A socket may be thought of as a generalization of the BSD Unix file access mechanism (open-read-write-close) that provides an end-point for communication.

10

Socket When an application creates a socket, the

application is given a small integer descriptor used to reference the socket. If a system uses the same descriptor space for sockets and other I/O, a single application can be used for network communication as well as for local data transfer.

An application must supply many details for each socket by specifying many parameters and options (e.g. an application must choose a particular protocol, provide address of remote machine, specify whether it is a client or server, etc.)

11

Functions needed Specify local and remote communication

endpoints Initiate a connection Wait for incoming connection Send and receive data Terminate a connection gracefully Error handling

12read()

connection establishment

Server(connection-oriented protocol)

blocks until connectionfrom client

Client

socket()

bind()

listen()

accept()

read()

write()

socket()

connect()

write()

process request

data (request)

data (reply)

Socket system calls for Socket system calls for connection-orientedconnection-oriented

protocolprotocol

13

Server(connectionless protocol)

socket()

blocks until datareceived from client

bind()

recvfrom()

sendto()

socket()

bind()

sendto()

revfrom()

process request

data (request)

data (reply)

Client

Socket system calls for Socket system calls for connectionless protocolconnectionless protocol

Not necessary in UDP!!

14

Data communication between two hosts on the Internet require the five components of what is called an association to be initialized: {protocol,local-addr, local-process/port #, remote-addr, remote-process/port#}

The different system calls for sockets provides values for one or more of these components.

15

Socket system call The first system call any process wishing to do

network I/O has to call is the socket system call. int sockfd = socket (int family, int type, int

protocol) Examples of Family include:

AF_UNIX AF_INET

Examples of Type include SOCK_STREAM SOCK_DGRAM SOCK_RAW

16

Socket system call The protocol argument is typically zero,

but may be specified to request an actual protocol like UDP, TCP, ICMP, etc.

The socket system call just fills in one element of the five-tuple we’ve looked at - the protocol. The remaining are filled in by the other calls as shown in the figure.

17

Connection-Oriented Server

Connection-oriented Client

Connectionless Server

Connectionless Client

socket()

socket()socket()socket()

bind()

bind()

bind()

accept()

connect()

recvfrom()

sendto()

local_addr, local_process

foreign_addr, foreign_process

Socket system call

protocol

18

Specifying an Endpoint Address Remember that the sockets API is generic There must be a generic way to specify endpoint

addresses TCP/IP requires an IP address and a port number for each

endpoint address. Other protocol suites(families) may use other schemes. Generic socket addresses (The C function that make up the sockets API expect structures of type

sockaddr.) :struct sockaddr {

unsigned short sa_family; //specifies the address type char sa_data[14]; //specifies the address value

};

19

AF_INET--TCP/IP address For AF_INET we need:

16 bit port number 32 bit IP address (IPv4 only)

struct sockaddr_in{short sin_family; unsigned short sin_port; struct in_addr sin_addr; char sin_zero[8];

}; how these fields to be set and interpreted?

20

Network Byte Order FunctionsExample:struct sockaddr_in sin;sin.sin_family = AF_INET;sin.sin_port = htons(9999);sin.sin_addr.s_addr = inet_addr;unsigned short htons(unsigned short);unsigned short ntohs(unsigned short);unsigned long htonl(unsigned long);unsigned long ntohl(unsigned long);

21

Bind System Call

The bind system call assigns an address to an unnamed socket. Example:

int bind(int sockfd, struct sockaddr_in

*myaddr, int addrlen)

22

Bind System Call What is bind used for ?

Servers (both connection oriented and connectionless) NEED to register their well-known address to be able to accept connection requests.

A client can register a specific address for itself.

A connectionless client NEEDS to assure that it is bound to some unique address, so that the server has a valid return address to send its responses to – However, it does not have to bind to a particular port! WHY?

23

The bind system call provides the values for the local_addr and local_process/port # elements in the five_tuple in an association.

An address for the Internet domain sockets is a combination of a hostname and a port number, as shown below:

struct sockaddr_in {short sin_family ; /*typically AF_INET*/u_short sin_port; /* 16 bit port number, network byte ordered */struct in_addr sin_addr ; /* 32 bit netid/hostid, network byte

ordered */char sin_zero[8]; /* unused*/}

24

Connect/Listen/Accept System Calls Connect

A client process connects a socket descriptor after a socket system call to establish a connection with the server.

int connect(int sockfd, struct sockaddr_in *servaddr, int addrlen)

For a connection-oriented client, the connect (along with an accept at the server side) assigns all four addresses and process components of the association.

25

Listen Listen

The listen system call is used by a connection-oriented server to indicate it is willing to receive connections.

int listen(int socket, int qlength) allows servers to prepare a socket for incoming

connections puts the socket in a passive mode ready to accept

connections informs the OS that the protocol software should enqueue

multiple simultaneous requests that arrive at the socket applies only to sockets that have selected reliable stream

delivery service

26

Accept Accept

After the connection-oriented server executes a listen, it waits for connection requests from client(s) in the accept system call, e.g., newsockfd = accept(sockfd, peer, addrlen)

needs to wait for a connection blocks until a connection request arrives addrlen is a pointer to an integer;

• when a request arrives , the system fills in argument addr with the address of the client that has placed the request and sets addrlen to the length of the address.

• system creates a new socket, returns the new socket descriptor

27

Accept accept returns a new socket descriptor,

which has all five components of the association specified - three (protocol, local addr, local_process) are inherited from the existing sockfd (which however has its foreign address and process components unspecified, and hence can be re-used to accept another request. This scenario is typical for concurrent servers.

28

Sending and Receiving Data Here’s how you might read from a socket:

num_read = read(sockfd, buff_ptr, num_bytes) And here’s how you read from an open file

descriptor in Unix: num_read = read(fildes, buff_ptr, num_bytes)

There are other ways (with different parameters) to send and receive data: read, readv, recv, recvfrom, recvmsg to receive data through a socket; and write, writev, send, sendto, sendmsg to send data through a socket.

29

sendto()--UDP Sockets int sendto(int socket, char *buffer, int

length, int flags, struct sockaddr *destination_address, int address_size);

For example:struct sockaddr_in sin;sin.sin_family = AF_INET;sin.sin_port = htons(12345);sin.sin_addr.s_addr = inet_addr("128.227.22.43");char *msg = "Hello, World";sendto(s, msg, strlen(msg)+1, 0, (struct sockaddr *)sin,

sizeof(sin));

30

recvfrom()--UDP Sockets Int recvfrom(int socket, char *buffer, int

length, int flags, struct sockaddr *sender_address, int

*address_size)

For example:struct sockaddr_in sin;char msg[10000];int ret;int sin_length;sin_length = sizeof(sin);ret = recvfrom(s, msg, 10000, 0, (struct sockaddr *)sin,

&sin_length);printf("%d bytes received from %s (port %d)\n", ret,

inet_ntoa(sin.sin_addr), sin.sin_port);

31

send() and recv() -- TCP Sockets

int send(int s, const char *msg, int len, int flags) connected socket argument flags controls the transmission.

• allows the sender to specify that the message should be sent out-of- band messages correspond to TCP’s urgent data

• allows the caller to request that the message be sent without using local routine tables (take control of routine)

int recv(int s, char *buf, int len, int flags) connected socket argument flags allow the caller to control the reception

• look ahead by extracting a copy of the next incoming message without removing the message from the socket

32

close() and shutdown() close(int socket)

For UDP sockets, this will release the ownership on the local port that is bound to this socket

For TCP, this will initiate a two-way shutdown between both hosts before giving up port ownership.

shutdown(int socket, int how) f the how field is 0, this will disallow further

reading (recv) from the socket. If the how field is 1, subsequent writes (send) will

be disallowed. The socket will still need to be passed to close.

33

Relationship Between Sockets and File Descriptors

Socket handles are integer values. In UNIX, socket handles can be passed to most of the low-level POSIX I/O functions. read(s, buffer, buff_length); //s could be a file

descriptor too write(s, buffer, buff_length) ;

34

Utility Functions unsigned int inet_addr(char *str)

str represents an IP address(dotted-quad notation); inet_addr will return it's equivalent 32-bit value in network byte order.

This value can be passed into the sin_addr.s_addr field of a socketaddr_in structure

-1 is returned if the string can not be interpreted char *inet_ntoa(struct in_addr ip)

Converts the 32-bit value which is assumed to be in network byte order and contained in ip to a string

The pointer returned by inet_ntoa contains this string. However, subsequent calls to inet_ntoa will always return the same pointer, so copying the string to another buffer is recommended before calling again.

35

Utility Functions ( cont’d ) int gethostname(char *name, int length)

Copies the name (up to length bytes) of the hostname of the local computer into the character array pointed to by name

struct hostent *gethostbyname(char *strHost)

int select (int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timeval *timeout) – later!!!

36

Others Include files

#include <sys/types.h>; #include <sys/socket.h>; #include <netinet/in.h>; #include <arpa/inet.h>; #include <netdb.h>; #include <unistd.h>; #include <signal.h>; #include <stdio.h>; #include <fcntl.h>; #include <errno.h; #include <sys/time.h>; #include <stdlib.h>;#include <memory.h>;

Compiling and Linking Under most versions of UNIX (Linux, BSD, SunOS, IRIX)

compiling is done as usual:• gcc my_socket_program.c -o my_socket_program

Solaris:• cc my_socket_program.c -o my_socket_program -lsocket -lnsl

Programming tips always check the return value for each function call consult the UNIX on-line manual pages ("man") for a complete description

37

Example: Socket programming with TCP

Example client-server app: client reads line from

standard input, sends to server via socket server reads line from socket

server converts line to uppercase, sends back to client

client reads, prints modified line from socket

Input stream: sequence of bytes into process

Output stream: sequence of bytes out of process

client socket

inFromUser outTo Server

iinFr omServer

38

Client/server socket interaction: TCP

wait for incomingconnection requestint cs =accept(s,….)

create socket,port=x, forincoming request:

int s = socket(…); bind(s,…) listen(s,5);

create socket,connect to hostid, port=x

int cli_socket = socket(..);connect(s,…);

closecs

read reply fromcli_socket

closecli_socket

Server (running on hostid) Client

send request usingcli_socketread request from

cs

write reply tocs

TCP connection setup

39

Example: C++ client (TCP)#include <stdio.h> /* Basic I/O routines */#include <sys/types.h> /* standard system types */#include <netinet/in.h> /* Internet address structures */#include <sys/socket.h> /* socket interface functions */#include <netdb.h> /* host to IP resolution */

int main(int argc, char *argv[]) { /* Address resolution stage */ struct hostent* hen = gethostbyname(argv[1]); if (!hen) { perror("couldn't resolve host name"); } struct sockaddr_in sa; memset(&sa, 0, sizeof(sa); sa.sin_family = AF_INET; sa.sin_port = htons(PORT); //server port number memcpy(&sa.sin_addr.s_addr, hen->h_addr_list[0], hen->h_length);

int cli_socket = socket(AF_INET, SOCK_STREAM, 0); assert(cli_socket >= 0); //I am just lazy here!! connect(s, (struct sockaddr *)&sa, sizeof(sa)); write(s, argv[2], strlen(argv[2])); //send it to server char buf[BUFLEN]; int rc; memset(buf, 0, BUFLEN); char* pc = buf; while(rc = read(cli_socket, pc, BUFLEN – (pc - buf))) pc += rc; write(1, buf, strlen(buf)); close(cli_socket);}

Create client socket,

connect to server

40

Example: C++ server (TCP)//include header files #define PORT 6789int main(int argc, char* argv[]) { struct sockaddr_in sa, csa; memset(&sa, 0, sizeof(sa); sa.sin_family = AF_INET; sa.sin_port = htons(PORT); sa.sin_addr.s_addr = INADDR_ANY; //any IP addr. Is accepted int s = socket(AF_INET,SOCK_STREAM, 0); assert( s>=0); int rc = bind(s, (struct sockaddr *)& sa, sizeof(sa)); //hook s with port rc = listen(s, 5); int cs_socket = accept(s, (struct sockaddr*)&csa, sizeof(csa)); char buf[BUFLEN]; memset(buf, 0, BUFLEN); char* pc = buf; while(rc = read(cs_socket, pc, BUFLEN – (pc - buf))) pc += rc; upper_case(buf); // covert it into upper case write(cs_socket, buf, strlen(buf)); close(cs_socket); close(s);}

41

Multi-Clients Servers Two main approaches to designing such servers. Approach 1. The first approach is using one process that awaits new

connections, and one more process (or thread) for each Client already connected. This approach makes design quite easy, cause then the main process does not need to differ between servers, and the sub-processes are each a single-Client server process, hence, easier to implement.

However, this approach wastes too many system resources (if child processes are used), and complicates inter-Client communication: If one Client wants to send a message to another through the server, this will require communication between two processes on the server, or locking mechanisms, if using multiple threads.

See tutor for details!

42

Socket programming with UDPUDP: no “connection”

between client and server

no handshaking sender explicitly attaches

IP address and port of destination

server must extract IP address, port of sender from received datagram

UDP: transmitted data may be received out of order, or lost

application viewpointUDP provides unreliable transfer

of groups of bytes (“datagrams”) between client and server

43

Summary

Network Application Programming Interface (API)

TCP/IP basic UNIX/C Sockets

socket() ; bind() ; connect() ; listen() ; accept() ; sendto() ; recvfrom(); send() ; recv() ; read() ; write();

some utility functions