The Application Layer

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

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 BetweenClients 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 forNetwork 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. 0 16 31 ADDRESS FAMILY ADDRESS OCTETS 0-1 ADDRESS OCTETS 2-5 ADDRESS OCTETS 6-9 ADDRESS OCTETS 10-13 Binding a Socket to a Source Address (cont) • The sockaddr struct: • Address family field: determines the format of the remaining address octets

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

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 SettingSocket 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 SettingSocket Options (cont) • Values for level (from <netinet/in.h>): • SOL_SOCKET option for the socket • IPPROTO_IP option for IP • IPPROTO_ICMP option for ICMP • IPPROTO_TCP option for TCP • IPPROTO_UDP option for UDP

27. Obtaining and SettingSocket Options (cont) • Values for optionid (from <sys/socket.h>): • SO_TYPE socket type • SO_SNDBUF send buffer size • SO_RCVBUF receive buffer size • SO_DEBUG debugging info available? • SO_ACCEPTCONN socket listening enabled? • SO_BROADCAST broadcast supported? • SO_REUSEADDR address reuse allowed? • SO_KEEPALIVE keep alive after close?

28. Obtaining and SettingSocket 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 ProvideMultiple 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 ProvideMultiple 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 <netdb.h> 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 <stdio.h> #include <string.h> #include <netdb.h> 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 <netdb.h>): 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 <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <stdio.h> 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 <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> #include <stdio.h> #include <string.h> 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 offersa 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.