1. The Application Layer Application Services (Telnet, FTP, e-mail, WWW) Reliable Stream Transport (TCP) Connectionless Packet Delivery Service (IP) Unreliable Transport Service (UDP)

2. The Client-Server Model Commonly used model for application interaction over a TCP/IP internet –Server: a program that offers a service that can be reached over a network Examples: web server, file server –Client: a program that requests a service from a server Examples: ping, browser

3. The Client-Server Model (cont)

4. Example: UDP Echo Server Server process attaches to port 7 (echo port) While (TRUE) do –Wait for a user datagram to arrive –Swap the source and destination IP addresses and port numbers –Return the user datagram to the original sender

5. Example: UDP Echo Client Obtain an unused UDP port Create a user datagram –Source and destination IP addresses –Source and destination port numbers Send the user datagram to the echo server Await the server’s reply

6. Differences Between Clients and Servers

7. Servers - Master and Slaves Can receive multiple concurrent requests Each request can take considerable time to process Most complex servers have two parts: –A single master program that accepts new requests –A set of slaves that are responsible for handling individual requests

8. The Master-Slave Server Algorithm Master: –Open a well-known port for requests –While (TRUE) do Waits for a client request Start an independent, concurrent slave to handle the request Slave: –Process the request given by the master –Send reply to the client –Exit

9. Servers - Must be well Written! Servers are usually more complex and harder to write than clients: –Handle multiple, concurrent requests –Enforce authorization and protection –Must handle errors/malformed requests The Oracle of Bacon at Virginia The Internet worm

10. Alternatives to the Client-Server Model Consider ARP: –Follows the client-server model –Demand driven Consider NNTP (Network News Transport Protocol): –Does not follow the client-server model –Uses precollection

11. Alternatives to the Client-Server Model Precollection –Advantages Speed Mask network/hardware failures –Disadvantages Uses processor time and network bandwidth whether anyone uses the service or not

12. How Programmers use TCP/IP Example: UNIX –Application programs interact with the operating system by making system calls –Standard I/O operations: Open Read/write Close –Network I/O: has own system calls and library routines

13. Using UNIX Sockets for Network I/O Socket = abstraction of the port concept: –Application programs request that the operating system create a socket when one is needed –O.S. returns a small integer (socket descriptor) that the program uses to reference the socket –Application program can then use read and write system calls on the socket –Program closes the socket when finished using it

14. Creating a Socket The socket system call: int sd; // socket descriptor int pf; // protocol family (one of PF_INET, // PF_PUP, PF_APPLETALK, // PF_UNIX, etc.) int type;// type of service (one of SOCK_RAW, // SOCK_DGRAM, SOCK_STREAM) int protocol;// specific protocol in pf sd = socket(pf, type, protocol)// create a new socket

15. Binding a Socket to a Source Address Some programs (mainly servers) will want a specific (reserved) address Some programs (mainly clients) don’t care what address they use and will allow the O.S. to choose one Uses the bind system call

16. Binding a Socket to a Source Address (cont) The bind system call: int sd; // socket descriptor struct sockaddr addr;// structure specifying source // address int len;// length (in bytes) of // addr struct bind(sd,addr,len)// bind socket to source address

17. Binding a Socket to a Source Address (cont) The sockaddr struct: Address family field: determines the format of the remaining address octets 0 16 31 ADDRESS FAMILY ADDRESS OCTETS 0-1 ADDRESS OCTETS 2-5 ADDRESS OCTETS 6-9 ADDRESS OCTETS 10-13

18. Binding a Socket to an Internet Source Address The sockaddr_in struct for PF_INET: 0 16 31 ADDRESS FAMILY(2) PROTOCOL PORT IP ADDRESS UNUSED (ZERO)

19. Binding a Socket to an Internet Source Address (cont) The bind system call: int sd; // socket descriptor struct sockaddr_in addr;// structure specifying source // address int len;// length (in bytes) of // addr struct bind(sd,addr,len)// bind socket to source IP // address

20. Connecting a Socket to a Destination Address The connect system call: int sd; // socket descriptor struct sockaddr addr;// structure specifying dest addr int len;// length (in bytes) of // addr struct connect(sd,addr,len)// connect socket to // dest address Can also use a sockaddr_in struct for dest address

21. Sending Data Through a Socket The write system call: int sd; // socket descriptor void *buffer;// address of the data to be sent int len;// number of bytes to send write(sd,buffer,len)// send data through socket

22. Receiving Data Through a Socket The read system call: int sd; // socket descriptor void *buffer;// address in memory at which // to store the data int len;// number of bytes to receive read(sd,buffer,len)// receive data through socket

23. Closing a Socket The close system call: int sd; // socket descriptor close(sd)// close socket

24. Obtaining Local Socket Addresses The getsockname system call: int sd; // socket descriptor struct sockaddr *addr; // address structure to be filled int *len;// pointer to integer that will // contain the length of the // address getsockname(sd, addr, len); // obtain local socket address

25. Obtaining and Setting Socket Options The getsockopt system call: int sd; // socket descriptor int level; // option for socket or protocol? int optionid;// which specific option? void *optionval;// where to place the requested // value int *len; // length of the optionval getsockopt(sd, level, optionid, optionval, len); // obtain // socket opt

26. Obtaining and Setting Socket Options (cont) Values for level (from ): –SOL_SOCKEToption for the socket –IPPROTO_IPoption for IP –IPPROTO_ICMPoption for ICMP –IPPROTO_TCPoption for TCP –IPPROTO_UDPoption for UDP

27. Obtaining and Setting Socket Options (cont) Values for optionid (from ): –SO_TYPEsocket type –SO_SNDBUFsend buffer size –SO_RCVBUFreceive buffer size –SO_DEBUGdebugging info available? –SO_ACCEPTCONNsocket listening enabled? –SO_BROADCASTbroadcast supported? –SO_REUSEADDRaddress reuse allowed? –SO_KEEPALIVEkeep alive after close?

28. Obtaining and Setting Socket Options (cont) The setsockopt system call: int sd; // socket descriptor int level; // option for socket or protocol? int optionid;// which specific option? void *optionval;// option value int *len; // length of the option value setsockopt(sd, level, optionid, optionval, len); // set option // value

29. Socket Options for Servers The listen system call: int sd; // socket descriptor int length; // length of request queue listen(sd, length)// set socket request queue // length Can only be used for SOCK_STREAM sockets

30. Servers: Accepting Connections The accept system call: int sd; // socket descriptor struct sockaddr *name;// address of client int *len; // length of address struct newsock = accept(sd, addr, len) // accept connection A new socket is created that connects to the client Server handles request, sends reply, closes newsock

31. Servers That Provide Multiple Services The select system call: int ndesc; // check descriptors 0...ndesc-1 void *indesc;// descriptors to check for input void *outdesc; // descriptors to check for output void *excdesc;// descriptors to check for exceptions int *timeout;// how long to wait for a connection nready = select(ndesc, indesc, outdesc, excdesc, timeout) // determine which descriptors are // ready for I/O

32. Servers That Provide Multiple Services (cont) The select system call: nready = select(ndesc, indesc, outdesc, excdesc, timeout) Returns the number of descriptors from the specified set that are ready for I/O A process can use select to communicate over more than one socket at a time Typically each socket provides a distinct service

33. Miscellaneous (Useful) System Calls The gethostname system call: char *name;// buffer to store name int length;// size of buffer in bytes gethostname(name, length)// get name of host Defined in include file Process can learn host it’s running on

34. Miscellaneous (Useful) System Calls (cont) The network byte order conversion routines: –Network-to-host (short), ntohs, convert a short int from network byte order to host byte order –Network-to-host (long), ntohl, convert a long int from network byte order to host byte order –Host-to-network (short), htons, convert a short int from network byte order to host byte order –Host-to-network (long), htonl, convert a long int from network byte order to host byte order

35. Miscellaneous (Useful) System Calls (cont) Testing htons: #include main(int argc, char **argv) { if (argc != 2) exit(-1); printf("%d\n",atoi(argv[1])); printf("%d\n",htons(atoi(argv[1]))); }

36. Miscellaneous (Useful) System Calls (cont) The gethostbyname system call: struct hostent *h;// hostent structure char *name;// host name h = gethostbyname(name);// fill in hostent with // info about name

37. Miscellaneous (Useful) System Calls (cont) The hostent structure (defined in ): struct hostent { char *h_name;/* official name of host */ char **h_aliases; /* alias list */ int h_addrtype; /* host address type */ int h_length; /* length of address */ char **h_addr_list; /* list of addresses from name server */

38. Datagram Socket Example: Receiver #include main() { int sock, len; struct sockaddr_in name; char buf [1024]; sock = socket(AF_INET, SOCK_DGRAM, 0); if (sock < 0) exit(-1); name.sin_family = AF_INET; name.sin_addr.s_addr = INADDR_ANY; name.sin_port = 0; if (bind(sock, (struct sockaddr *) &name, sizeof(name))) exit(-1); len = sizeof(name); if (getsockname(sock, (struct sockaddr *) &name, &len)) exit(-1); printf("Receiver listening on port %d\n",ntohs(name.sin_port)); if (read(sock, buf, 1024) < 0) exit(-1); printf("%s\n",buf); close(sock); }

39. Datagram Socket Example: Sender #include main(int argc, char **argv) { int sock; struct sockaddr_in name; struct hostent *hp, *gethostbyname(); if (argc != 3) exit(-1); sock = socket(AF_INET, SOCK_DGRAM, 0); if (sock < 0) exit(-1); hp = gethostbyname("prime.cs.ohiou.edu"); if (hp == 0) exit(-1); bcopy(hp->h_addr, &name.sin_addr, hp->h_length); name.sin_family = AF_INET; name.sin_port = htons(atoi(argv[1])); if (connect(sock, (struct sockaddr *) &name, sizeof(name))) exit(-1); if (write(sock, argv[2], (strlen(argv[2])+1)) < 0) exit(-1); close(sock); }

40. Summary The client-server model is widely-used for application interaction over a TCP/IP internet –Server: a program that offers a service that can be reached over a network Examples: web server, file server –Client: a program that requests a service from a server Examples: ping, browser Application programs typically interact with the networking software by using sockets and system calls: –Socket – create a socket –Bind – bind a socket to a port –Read/write – get/put data in a socket –Etc.