1 / 80

Network Application Programming

Network Application Programming. Introduction: issues Sockets: programming and implementation Other API’s: winsock java transport layer interface (TLI) Novell netware API. The Application Programming Interface: API.

tuari
Download Presentation

Network Application Programming

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Network Application Programming Introduction: issues Sockets: programming and implementation Other API’s: • winsock • java • transport layer interface (TLI) • Novell netware API Socket API2: Application Layer

  2. The Application Programming Interface: API • Definition : an API is the programming model, application callable services, interfaces, and abstractions provided by the network (i.e., lower layers) to the application. • does an API provide for: • naming and service location: • must application know precise location (e.g., host address and port) of service? • Can services be requested by name? • Can servers registers services? • connection management • must applications do low-level handshaking required to setup / teardown connection? Socket API2: Application Layer

  3. The API (continued) Does an API provide for: • Message transfer • application-selectable data transfer services: best-effort versus reliable? • message priorities? • multi-site atomic actions? • e.g. deliver everywhere or nowhere; all at same time;... • structured versus byte-stream communication? • Communication flexibility • can application select and/or modify protocol stacks (statically or dynamically)? • Quality of Service specification • can application specify QoS requirements to network? Socket API2: Application Layer

  4. Sockets and UNIX I/O • Standards do not specify how application will interface with the protocols. •  interface architecture is not standardized, its design is outside the scope of the protocol suite • most often interface details depend on the operating system in use • UNIX development (60’s and 70’s) has each application program execute as a user level process. • application program interacts with OS via a system call • system calls behave like other procedure calls -i.e. take arguments and return one or more results • arguments can be values or pointers to objects ( e.g.a buffer to be read or filled with characters) • UNIX I/O follows paradigm of open-read-write-close ( from MULTICS and earlier OS ) Socket API2: Application Layer

  5. UNIX I/O • Before a process performs I/O operations - • it calls open to specify the file or device to be used and obtains permission • the call to open returns a small integer file descriptor the process uses when performing the I/O operations on the opened file or device • once opened, user makes one or more calls to read or write to transfer data • both read and write take 3 arguments that specify : • file descriptor to use • address of a buffer • number of bytes to transfer • after all transfer operations are completed, the user calls close to inform the OS it is finished with the object Socket API2: Application Layer

  6. BSD UNIX and Network Protocols • BSD developers decided that the complexity of network protocols required more power and flexibility than the early I/O models provided • programmers needed to create both server code that waits passively as well as code that forms connections actively • applications sending datagrams may wish to specify destination address along with each datagram rather than binding destinations at the time they call open • To deal with these observations, they chose to abandon the traditional I/O paradigm and to add several new OS calls and new library routines to BSD UNIX • this increased the Unix I/O complexity • The basis for network I/O in BSD UNIX is centered on the abstraction known as the socket • introduced in 1981 BSD 4.1 UNIX ( Bill Joy, founder of SUN) Socket API2: Application Layer

  7. The SOCKET API • Definition :a socket is a host-local, application created/owned, OS-controlled interface into which the application process can both send and receive messages to/from another (remote or local) application process • two sockets on separate hosts ``connected'' by OS socket management routines. Application only sees local socket. Socket API2: Application Layer

  8. Sockets • think of a socket as a generalization of the UNIX file access mechanism • application programs request the OS to create a socket when one is needed • system returns a small integer that applications use to reference the newly created socket • in this case however, the OS binds a file descriptor to a specific file or device when the application calls open but it can do so without binding them to specific destination addresses • the application chooses the destination address each time it uses the socket • e.g. when sending datagrams • or it can choose to bind the destination address to the socket and avoid necessity of repeatedly specifying address • e.g. a TCP connection • can also be used for traditional read - write operations Socket API2: Application Layer

  9. The SOCKET API (cont) • sockets explicitly created, used, released by applications • based on client/server paradigm • two types of transport service via socket API: • unreliable datagram • reliable, stream-oriented • presentation, session layers missing in UNIX networking (an application concern!). Socket API2: Application Layer

  10. Sockets: conceptual view • each socket has separate send/receive buffers, port id, parameters (application queryable and setable). • socket operations implemented as system calls into OS • user/kernel boundary crossed: overhead Socket API2: Application Layer

  11. Create an endpoint for communication #include <sys/socket.h> #include <netinet/in.h> int socket (af, type, protocol) int af; int type; int protocol; where: af Address family (domain) type Type of service desired protocol Optional protocol id (usually 0) possible family values AF_UNIX local host domain AF_INET internet domain possible service type values SOCK_STREAM virtual circuit socket SOCK_DGRAM datagram socket SOCK_RAW access to internal network returns: channel number on success, or -1 Socket API2: Application Layer

  12. Create a pair of connected UNIX domain sockets #include <sys/socket.h> int socketpair (af, type, protocol, sv) int d; int type; int protocol; int sv[2]; where: af Address family (domain)of the socket, AF_UNIX type Type of service, SOCK_STREAM/ SOCK_DGRAM protocol Protocol of interest, 0 for default sv Buffer in which to return descriptors Description The socket pair call is used in the UNIX domain only to create a connected pair of sockets in the style of the pipe() call. A creator would typically fork() a child (or children) and use the channel inheritance of the offspring for full duplex IPC. Unlike a pipe, both channel descriptors are open for reading and writing with no possible crosstalk. returns: 0 on success, or -1 Socket API2: Application Layer

  13. Initiate a connection on a socket #include <sys/socket.h> #include <netinet/in.h> #include <sys/un.h> int connect (s, name, namelen) int s; const struct sockaddr * name; int namelen; where: s The file descriptor of a socket to connect name Name of peer or listening socket through which the connection will be made namelen Length of name (bytes) possible name address formats struct sockaddr_un{ short sun_family; /* AF_UNIX */ char sun_path[109]; /* UNIX file path */ }; struct sockaddr_in{ short sin_family; /* AF_INET */ u_short sin_port; /* port number */ struct in_addr sin_addr; /* inet addr */ char sin_zero[8]; } returns: 0 on success, or -1 Socket API2: Application Layer

  14. Sockets: conceptual view Socket API2: Application Layer

  15. Socket API2: Application Layer

  16. Connectionless Service • datagram service:underlying transport protocols do not guarantee delivery • no explicit identification of who is server, who is client • if initiating contact with other side, need to know • IP address • port number of process waiting to be contacted. • if waiting for contact from other side, need to declare : • port number at which you are waiting for other side to send data Socket API2: Application Layer

  17. Socket API2: Application Layer

  18. Creating a socket • Socket system call creates sockets on demand • Takes 3 integer arguments and returns an integer result : • result = socket ( pf, type, protocol ) • pf argument- specifies the protocol family to be used with the socket • i.e how to interpret addresses when supplied • type argument specifies the type of communication desired • protocol argument allows further flexibility Socket API2: Application Layer

  19. Creating a socket • same endpoint (socket) used to send/receive data • no a priori association of socket with network • must specify transport protocol family, and specific transport-level service to be used with socket: Socket API2: Application Layer

  20. Creating a socket (cont.) int socket ( int family, int service, int protocol) • family is symbolic name of protocol family • service is symbolic name of service type • protocol allows further specification of raw socket. For us, this will be 0. • return code from socket() is a socket descriptor, used in all remaining socket-related system calls Example: #include <sys/types.h> #include<sys/ socket.h> int sockfd; if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { /* handle error */ } Socket API2: Application Layer

  21. Internet Addressing • each Internet host has one or more globally-unique 32-bit IP addresses • host may have two or more addresses • address associated with each interface card • dotted decimal notation: • 4 decimal integers, each specifying one byte of IP address: host name cs.uml.edu • 32-bit address 10000001 00111111 00000001 00000111 • dotted decimal 129.63.1.6 • library procedure inet_addr() converts dotted-decimal address string to a 32-bit address • library procedure gethostbyname() converts textual name to 32 bit address. Socket API2: Application Layer

  22. The Internet Domain System Structure • hierarchical administering of names • e.g.: cs.uml.edu • leftmost name is typically a host name (has an IP address) • next leftmost name is organization administering that host (e.g., UML C.Sc. Dept.) • next leftmost name is organization administering all of subnames to the left • rightmost (highest) domain: organization, structure, country Socket API2: Application Layer

  23. DNS: Internet Domain Name System • a distributed database used by TCP/IP applications to map to/from hostnames from/to IP addresses • name servers : • user-level library routines gethostbyname() and gethostbyaddress() contact the local nameserver via port 53 • name server returns IP address of requested hostname Socket API2: Application Layer

  24. DNS: non-local names finding non-local names • no single name server has complete information table • if local name server can't resolve address, contacts root name server: • 9 redundant root nameservers world-wide • each has addresses of names servers for all level-two name servers (e.g., uml.edu, ibm.com) • contacted root server returns IP address of name server resolver should contact • contacted level-two name server may itself return a pointer to another name server • name resolution an iterative process of following name server pointers • DNS protocol specifies packet formats for exchanges with DNS servers Socket API2: Application Layer

  25. Assigning a socket a network address: bind() • each socket must be associated with a • local, • host-unique • 16-bit port number. • need to associate socket with globally unique network address (host address and port) • OS knows that incoming messages addressed to this host address and port are to be delivered to(demultiplexed to) this socket . Incoming are from a specific remote port and IP address • a return address for outgoing messages Socket API2: Application Layer

  26. Socket addressing: predefined address structures specifying socket addresses: certain data structures predefined for you: struct sockaddr_in { /* INET socket addr info */ short sin_family; /* set me to AF_INET */ u_short sin_port; /* 16 bit number, nbo */ struct in_addr sin_addr; /* 32 bit host address */ char sin_zero[8]; /* not used */ }; struct in_addr { u_long s_addr; /* 32 bit host addr.,nbo */ }; Socket API2: Application Layer

  27. The bind() system call int bind ( int sockfd, struct sockaddr *myaddr, int addresslen) • sockfdis the variable assigned socket() return value. • *myaddr:address ofsockaddr_in structure holding local address info. Must be cast to type sockaddr. • addresslenis the size of the address structure error return indicates port number already in use, out- of-range Socket API2: Application Layer

  28. The bind() system call (cont) #include <sys/types.h> #include <sys/socket.h> #include "inet.h” int sockfd; struct sockaddr_in myaddr; if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { /* handle error */ } myaddr.sin_family = AF_INET; myaddr.sin_port = htons(5100); /* > 5000 myaddr.sin_addr.s_addr = htonl(INADDR_ANY); /* INADDR lets OS determine hostid */ if ( bind(sockfd, (struct sockaddr *) &myaddr, sizeof(myaddr)) < 0) { /* handle error */ } Socket API2: Application Layer

  29. Socket bind ( cont.) Bind a name to a socket #include <sys/socket.h> #include <netinet/in.h> #include <sys/un.h> int bind (s, name, namelen) int s; const struct sockaddr * name; int namelen; where: s Socket to bind name Name to bind to socket namelen Length of name (bytes) Description This call allows a process to establish a link to an underlying TCP or UDP port (in the case of an internet socket) or a link to a path name in the file system (in the case of a UNIX domain socket). In general, a server must use this call to give herself an address, whereas a client is not required to use this call (but may if she so chooses),but is automatically allocated a source port at the time a connect() call is made. It can be seen that the call arguments are the same as those for the connect call. returns: 0 on success, or -1 Socket API2: Application Layer

  30. Listen for connections on a socket int listen (s, backlog) int s; int backlog; where: s File descriptor of socket to listen on. backlog Maximum number of waiting connections. returns: 0 on success, or -1 SYNOPSIS #include <sys/socket.h> #include <netinet/in.h> #include <sys/un.h> int accept (s, addr, addrlen) int s; struct sockaddr * addr; int * addrlen; where: s Socket channel listening for connection requests addr Structure to receive the address of connected peer addrlen On input contains the number of bytes available for the peer address; updated to indicate the number of bytes returned returns: Connected new channel number, or -1 Socket API2: Application Layer

  31. Example With Internet Sockets Client/Server example using internet sockets A "one-time" FTP client /* client.c a minimal FTP client */ /* this version works on all BSD based systems */ #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> #include <fcntl.h> #include <strings.h> #define MSG_BODY 248 #define MSG_SIZE (MSG_BODY+8) #define PORT 27439 #define SEND 1 #define RECV 2 #define DATA 100 #define END_DATA 101 typedef struct{ int mtype; int msize; char mbody[MSG_BODY]; } MSG; typedef union{ MSG m; char buf[MSG_SIZE]; } MBUF; Socket API2: Application Layer

  32. Client/Server example using internet sockets A "one-time" FTP client main(int argc, char *argv[]) { MSG msg; MBUF raw; int inet_sock, local_file; int type_val, size_val, read_val, local_size; int i,j,k; char *buffer_ptr, *token_ptr, *last_token_ptr; union type_size; struct sockaddr_in inet_telnum; struct hostent *heptr, *gethostbyname(); if((inet_sock=socket(AF_INET, SOCK_STREAM, 0)) == -1){ perror("inet_sock allocation failed: "); exit(1); } if((heptr = gethostbyname( argv[1] )) == NULL){ perror("gethostbyname failed: "); exit(1); } bcopy(heptr->h_addr, &inet_telnum.sin_addr, heptr->h_length); inet_telnum.sin_family = AF_INET; inet_telnum.sin_port = htons( (u_short)PORT ); if(connect(inet_sock, &inet_telnum, sizeof(struct sockaddr_in)) == -1){ perror("inet_sock connect failed: "); exit(2); Socket API2: Application Layer

  33. Client/Server example using internet sockets cont'd A "one-time" FTP client msg.mtype = htonl(RECV); strcpy(msg.mbody, argv[2]); local_size = strlen(argv[2]) +1; msg.msize = htonl(local_size); token_ptr = strtok(argv[2], "/"); do{ if((last_token_ptr = token_ptr) == NULL){ printf("\n *** Illegal path name, terminating\n\n"); exit(2); } } while(token_ptr = strtok(NULL, "/")); if((local_file=open(last_token_ptr, O_RDWR | O_CREAT | O_TRUNC, 0666)) == -1){ perror("local_file open failed: "); exit(3); } if(write(inet_sock, &msg, local_size + (2*sizeof(int))) == -1){ perror("inet_sock write failed: "); exit(3); Socket API2: Application Layer

  34. Client/Server example using internet sockets cont'd A "one-time" FTP client while(1){ for(i=0; i<(2*sizeof(int)); i++){ if(read(inet_sock, raw.buf+i, 1) != 1){ perror("read type_size failed: "); exit(3); } } type_val = ntohl(raw.m.mtype); size_val = ntohl(raw.m.msize); read_val = size_val; buffer_ptr = raw.buf; switch(type_val){ case DATA: while ((j = read(inet_sock, buffer_ptr, read_val)) != read_val){ switch(j){ default: read_val -= j; buffer_ptr +=j; break; case -1: perror("inet_sock read failed: "); exit(3); case 0: printf("unexpected EOF on inet_sock\n"); exit(4); } } if(write(local_file, raw.buf, size_val) == -1){ perror("local write failed: "); exit(3); } break; case END_DATA: printf("transfer of %s completed successfully, goodbye\n",argv[2]); exit(0); default: printf("unknown message type %d size of %d\n",type_val,size_val); printf("this is an unrecoverable error, goodbye\n"); exit(5); } } Socket API2: Application Layer

  35. Example: connectionless server 1 #include <stdio.h> 2 #include <sys/types.h> 3 #include <sys/socket.h> 4 #include <netinet/in.h> 5 #include <arpa/inet.h> 6 #include <errno.h> 7 #define MY_PORT_ID 6090 /* a number > 5000 */ 8 9 main() 10 { 11 int sockid, nread, addrlen; 12 struct sockaddr_in my_addr, client_addr; 13 char msg[50]; 14 Socket API2: Application Layer

  36. connectionless server, cont. 15 printf("Server: creating socket\n"); 16 if ( (sockid = socket (AF_INET, SOCK_DGRAM, 0)) < 0) { 17 printf("Server: socket error: %d\n",errno); exit(0);} 18 printf("Server: binding my local socket\n"); 19 bzero((char *) &my_addr, sizeof(my_addr)); 20 my_addr.sin_family = AF_INET; 21 my_addr.sin_addr.s_addr = htons(INADDR_ANY); 22 my_addr.sin_port = htons(MY_PORT_ID); Socket API2: Application Layer

  37. Example: connectionless server (cont) 23 if ( (bind(sockid, (struct sockaddr *) &my_addr, 24 sizeof(my_addr)) < 0) ) 25 {printf("Server: bind fail: %d\n",errno); exit(0);} 26 printf("Server: starting blocking message read\n"); 27 nread = recvfrom(sockid,msg,11,0, 28 (struct sockaddr *) &client_addr, &addrlen); 29 printf("Server: return code from read is %d\n", nread); 30 if (nread >0) printf("Server: message is: %.11s\n” ,msg); 31 close(sockid); 32 } Socket API2: Application Layer

  38. Example: connectionless client 1 #include <stdio.h> 2 #include <sys/types.h> 3 #include <sys/socket.h> 4 #include <netinet/in.h> 5 #include <arpa/inet.h> 6 #include <errno.h> 7 #define MY_PORT_ID 6089 8 #define SERVER_PORT_ID 6090 9 #define SERV_HOST_ADDR "128.119.40.186" 10 11 main() 12 { Socket API2: Application Layer

  39. connectionless client,cont.1 13 int sockid, retcode; 14 struct sockaddr_in my_addr, server_addr; 15 char msg[12]; 16 17 printf("Client: creating socket\n"); 18 if ((sockid = socket(AF_INET, SOCK_DGRAM, 0)) < 0){ 19 printf("Client: socket failed: %d\n",errno); exit(0);} 20 21 printf("Client: binding my local socket\n"); 22 bzero((char *) &my_addr, sizeof(my_addr)); 23 my_addr.sin_family = AF_INET; 24 my_addr.sin_addr.s_addr = htonl(INADDR_ANY); 25 my_addr.sin_port = htons(MY_PORT_ID); 26 if ( ( bind(sockid, (struct sockaddr *) &my_addr, 27 sizeof(my_addr)) < 0) ) 28 { printf("Client: bind fail: %d\n",errno);exit(0);} 29 Socket API2: Application Layer

  40. connectionless client , 2 30 printf("Client: creating addr structure for server\n"); 31 bzero((char *) &server_addr, sizeof(server_addr)); 32 server_addr.sin_family = AF_INET; 33 server_addr.sin_addr.s_addr = inet_addr(SERV_HOST_ADDR); 34 server_addr.sin_port = htons(SERVER_PORT_ID); 35 36 printf("Client: initializing message and sending\n"); 37 sprintf(msg, "Hello world"); 38 retcode = sendto(sockid,msg,12,0, (struct sockaddr *)&server_addr, 39 sizeof(server_addr)); 40 if (retcode <= -1){ 41 printf("client: sendto failed: %d\n",errno);exit(0);} 42 43 /* close socket */ 44 close(sockid); 45 } Socket API2: Application Layer

  41. Example: execution trace > cc udpserver.c; mv a.out udpserver > cc udpclient.c; mv a.out udpclient > udpserver & [1] 20837 > Server: creating socket Server: binding my local socket Server: starting blocking message read > udpclient Client: creating socket Client: binding my local socket Client: creating addr structure for server Client: initializing message and sending Server: return code from read is 11 Server: message is: Hello world [1] Done udpserver Socket API2: Application Layer

  42. Connection-oriented service Socket API2: Application Layer

  43. SERVER CLIENT create transport endpoint:socket() for incoming requests create transport endpoint: socket() assign trasnport endpoint an address (optional) :bind() assign address to transport endpoint:bind() announce willing to accept connections: listen() determine addr. of server msg exchange and synch. connect to server via socket: connect() block/wait for incoming conn. req.: accept()(new socket created on return) request send msg: sendto() wait for pkt:recvfrom() reply wait for reply:recvfrom() send reply (if any):sendto() release transport endpoint:close() release transport endpoint:close() Socket API2: Application Layer

  44. Connection-oriented service • client/server handshaking: • client must explicitly connect to server before sending or receiving data (unlike connectionless service case) • client will not pass connect() until server accepts client • server must explicitly accept client before sending or receiving data • server will not pass accept() until client connect()'s • connection-oriented service: underlying transport service is reliable and stream-oriented. Socket API2: Application Layer

  45. Client-to-server connection: connect() • client uses connect() to request connect to server and communication via socket • underlying transport protocol (e.g. TCP) begins connection setup protocol implementing client/server handshake • connect() returns when server explicitly accepts connection, or timeout (no server response) • typically used with reliable transport protocols, but also with datagrams Socket API2: Application Layer

  46. Client-to-server connection: connect() int connect ( int sockfd, struct sockaddr *toaddrptr, int addresslen) • sockfd:variable assigned socket() return value. Process accepts incoming connections on this socket id. • *toaddrptr is address of sockaddr_in structure holding server address info. Must be cast to type sockaddr. • addresslen is the size of address structure Socket API2: Application Layer

  47. The listen() system call • used by connection-oriented server • let network/OS know server will accept connection requests • does not block and does not wait for request! • int listen ( int sockfd, int maxwaiting) • sockfd:variable assigned socket() return value. Process accepts incoming connections on this socket id. • maxwaiting: maximum number of connection requests that can be queued, waiting for server to do anaccept().Typical value is 5. Socket API2: Application Layer

  48. Server-to-client connection: accept() • done by server, after listen(). • server will accept() connection request via specified socket, and return newly created socket for use in communicating back to accept()'ed client. • server has one socket for accepting incoming connection requests AND creates other (new) sockets for communication with clients • server can not selectively accept() connection requests • typically handled FCFS. Socket API2: Application Layer

  49. accept(), cont int accept ( int sockfd, struct sockaddr *fromaddrptr, int *addresslen) • sockfd is variable assigned socket() return value. • *fromaddrptr is address of sockaddr_in structure containing address info of socket that sent this data. A returned value.- a different socket • addresslen is size of address structure. A value-result argument (set before call, reset during call). Socket API2: Application Layer

  50. accept(), cont struct sockaddr_in other_app_addr; int sockid , newsockid, addrsize; … addrsize = sizesizeof(other_app_addr)); newsockid = accept(sockfd, (struct sockaddr *)&other_app_addr, &addrsize); /* newsockid to communicate with client, sockid to accept more connections */ Socket API2: Application Layer

More Related