Dept. of Computer Science & Engineering 1 Knowledge & Data Engineering Lab.

Transcription

1 Socket Programming Dept. of Computer Science & Engineering 1

2 Socket A socket is a communication end point. Is equivalent to a computer s network (hardware) interface. Allows a network application to plug into the network (not physically, but metaphorically). Is a network programming interface. It is used for interprocess communication over the network. Is used by a process to communicate with a remote system via a transport protocol. Needs an IP address and a port number. Sockets were first introduced in Berkeley UNIX. An extension of the UNIX abstraction of file I/O concepts. Now are commonly supported in almost all modern operating systems for inter-systems communications. Dept. of Computer Science & Engineering 2

3 Socket Computing A socket provides a two-way communication mechanism Provides two major types of services: Connection-oriented (TCP/IP) Stream Reliable Bi-directional communication Connectionless (UDP/IP) Datagram Unreliable Bi-directional communication Dept. of Computer Science & Engineering 3

4 Connection-Oriented Implemented on TCP Short for Transmission Control Protocol. An end-to-end connection is established before data exchange can happen. Similar to our phone system. Data bytes are delivered in sequence. Delivery of data is guaranteed. Connection is terminated when finished. Two modes: Iterative (synchronous) Concurrent (asynchronous) Dept. of Computer Science & Engineering 4

5 Connectionless Implemented on UDP Short for User Datagram Protocol. No connection is required before data transfer. Similar to our postal system. Data bytes may be missing or delivered out-of-order. Two modes: Iterative (synchronous) Concurrent (asynchronous) Dept. of Computer Science & Engineering 5

6 Internet Addressing IP addresses A means to identify hosts on the Internet. IP is short for Internet Protocol. Each host on the Internet is assigned a 32-bit unique address (in IPv4). An IP address is assigned to a single host only. Dotted representation Internet addresses are represented in the form of four integers separated by decimal points. For readability by human An example:» Dept. of Computer Science & Engineering 6

7 DNS The domain name system (DNS) A high-level naming scheme. A sequence of characters grouped into sections delimited by decimal points. Labeled in a meaningful way A hierarchical naming system Mapping of high-level domain names to low level IP addresses is needed for communications across the Internet. Done at system startup via a local table lookup. Going through a name server (DNS server). Dept. of Computer Science & Engineering 7

8 Port Numbers (1) A (protocol) port is an abstraction used by TCP/UDP to distinguish applications on a given host. A port is identified by a 16-bit integer known as the port number. Three ranges of port numbers: Well-known ports Registered ports Dynamic ports Well-known ports Ranging from 0 to 1,023. A set of pre-assigned port numbers for specific uses. Are controlled by IANA (Internet Assigned Numbers Authority). Dept. of Computer Science & Engineering 8

9 Port Numbers (2) Registered ports Ranging from 1,024 to 49,151. Not assigned or controlled by IANA; however their uses need to be registered with IANA to prevent duplications. Dynamic ports Ranging from 49,152 to 65,535. Neither assigned or registered. They can be used by anyone. These are ephemeral ports. Also known as private ports. Dept. of Computer Science & Engineering 9

10 Some Well-Known Ports Dept. of Computer Science & Engineering 10

11 Socket Address Structure (1) To hold address and port number information. A generic format (address family (or domain), address in the family) Generic socket address structure: struct sockaddr { sa_family_t sa_family; /* address family */ char sa_data[14]; /* socket address */ ; A popular BSD-derived implementation: struct sockaddr_in { sa_family_t sin_family; /* address family */ in_port_t sin_port; /* protocol port number */ struct in_addr sin_addr; /* IP addr in NW byte order */ char sin_zero[8]; /* unused, set to zero */ ; Dept. of Computer Science & Engineering 11

12 Socket Address Structure (2) sa_family_t sin_family usually holds the value either AF_INET or AF_UNIX. in_port_t sin_port is a 16-bit TCP or UDP port number. in_addr sin_addr contains a 32-bit IPv4 address. Structure for in_addr: struct in_addr { in_addr_t sa_s_addr; /* 32-bit IPv4 address */ ; Dept. of Computer Science & Engineering 12

13 TCP Server Example An algorithm for server STEP 1: Create a socket. STEP 2: Bind to a predefined address for the service desired. STEP 3: Start listening for incoming connections. STEP 4: Accept the next connection request from a client. STEP 5: Read a request, process the request (fork or thread), and send back the results. STEP 6: Close the connection when done with a client. STEP 7: Return to STEP 3 for next client. (After forking in STEP 5, the parent process immediately returns to STEP 4.) Dept. of Computer Science & Engineering 13

14 TCP Client Example An algorithm for client STEP 1: Create a socket. STEP 2: Connect the socket to the desired server. STEP 3: Send a request, and wait for the response. STEP 4: Repeat STEP 3 until done. STEP 5: Notify server of intention to terminate. STEP 6: Close the socket (connection). Dept. of Computer Science & Engineering 14

15 TCP System Calls Server socket() bind() listen() accept() blocks until connection from client Client socket() connect() read() process request write() write() read() close() close() Dept. of Computer Science & Engineering 15

16 UDP Server/Client Example An algorithm for server STEP 1: Create a socket. STEP 2: Bind to a predefined address for the service desired. STEP 3: Wait for a datagram to arrive from a client. STEP 4: Send response back to originating client. STEP 5: Return to STEP 3 for next client. An algorithm for client STEP 1: Create a socket. STEP 2: Send a datagram to server. STEP 3: Wait for response from server. STEP 4: Return to STEP 2 for more datagrams. STEP 5: Close the socket. Dept. of Computer Science & Engineering 16

17 UDP System Calls Server socket() bind() recvfrom() blocks until data received from a client process request data(request) Client socket() sendto() sendto() data(reply) recvfrom() close() Dept. of Computer Science & Engineering 17

18 Some Socket System Calls #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> int socket(int family, int type, int protocol); int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen); int listen(int sockfd, int backlog); int accept(int sockfd, struct sockaddr *cliaddr, socklen_t *cliaddrlen); int connect(int sockfd, struct sockaddr *servaddr, socklen_t *servaddrlen); ssize_t recvfrom(int sockfd, void *buff, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen); ssize_t sendto(int sockfd, void *msg, size_t len, int flags, struct sockaddr *to, socklen_t tolen); struct hostent *gethostbyname(const char *name); int shutdown(int sockfd, int howto); Dept. of Computer Science & Engineering 18

19 More on Sockets In a TCP connection, a write to a disconnected socket will generate SIGPIPE signal. This can be dealt with a proper signal handler. A read from socket will return 0, if the socket is closed. With a close( ) call, If the socket is of SOCK_STREAM type, The kernel will deliver all data received before terminating the connection. close( ) will block until all outstanding data delivered to the receiving process. If the socket is of SOCK_DGRAM type, The socket is closed immediately. Dept. of Computer Science & Engineering 19

20 Multiplexing on Sockets The select( ) system call It is used for handling multiple file descriptors simultaneously. It can indicate which of the specified file descriptors is ready for reading, writing, or has an error condition pending. It may block until the condition is true for at least one of the specified file descriptors. It may return immediately or wait up to a certain amount of time, depending on the timeout value specified. The types of file descriptors supported include regular files, terminal and pseudo-terminal devices, FIFOs, pipes, and sockets. Dept. of Computer Science & Engineering 20

21 Socket (1) #include <sys/types.h> #include <sys/socket.h> int socket(int domain, int type, int protocol); domain Specify address family AF_UNIX : UNIX domain AF_INET : IPv4 Internet domain AF_INET6 : IPv6 Internet domain AF_UNSPEC : unspecified type Socket types SOCK_STREAM : sequenced, reliable, connection-oriented byte streams SOCKET_DGRAM : fixed-length, connectionless, unreliable messages SOCKET_SEQPACKET : fixed-length, sequenced, reliable, connection-oriented messages SOCK_RAW : raw socket (talk to IP directly), optional in POSIX.1 Dept. of Computer Science & Engineering 21

22 Socket (2) protocol If 0, system determines (IPPROTO_TCP, IPPROTO_UDP). Return value Socket descriptor; -1 if failure. Dept. of Computer Science & Engineering 22

23 bind #include <sys/types.h> #include <sys/socket.h> int bind(int sockfd, struct sockaddr *my_addr, int addrlen); Assigning a name to a socket. sockfd: obtained from socket( ). struct sockaddr is a generic address structure. addrlen is the length of my_addr object. Need to cast the real data structures. Unix domain: struct sockaddr_un, <sys/un.h> Internet domain: struct sockaddr_in, <netinet/in.h> Dept. of Computer Science & Engineering 23

24 listen #include <sys/socket.h> int listen(int sockfd, int backlog); Create a queue for incoming connection requests. sockfd Socket descriptor backlog Maximum size of the queue Apply only to sockets of type SOCK_STREAM or SOCK_SEQPACKET. Return -1 if failure. Dept. of Computer Science & Engineering 24

25 accept #include <sys/types.h> #include <sys/socket.h> int accept(int sockfd, struct sockaddr *addr, int *addrlen); Accept a connection on a socket. Blocked if there are no pending requests. sockfd: socket descriptor addr, addrlen: client information and length of it Return new socket descriptor that can be used for reading and writing. Used by server processes. Dept. of Computer Science & Engineering 25

26 connect #include <sys/types.h> #include <sys/socket.h> int connect(int sockfd, struct sockaddr *serv_addr, int addrlen); sockfd Socket descriptor obtained from socket( ). serv_addr, addrlen Server address information A stream socket in connected only once, while a datagram socket can be connected several times. Used by client processes. Dept. of Computer Science & Engineering 26

27 Send and Receive (1) send( ), sendto( ), recv( ), recvfrom( ) system call Similar to read, write system calls but needs additional arguments. int send(int sockfd, char *buff, int nbytes, int flags); int sendto(int sockfd, char *buff, int nbytes, int flags, struct sockaddr *to, int addrlen); int recv(int sockfd, char *buff, int nbytes, int flags); int recvfrom(int sockfd, char *buff, int nbytes, int flags, struct sockaddr *from, int *addrlen); Flags Affects the way in which the data can be received or sent If flags is zero, send() and recv() are behaves just like write() and read() flags: MSG_OOB, MSG_PEEK, MSG_WAITALL, MSG_DONTROUTE Dept. of Computer Science & Engineering 27

28 Send and Receive (2) MSG_OOB : Normal data is bypassed and the process only receives out of band data, for example, an interrupt signal MSG_PEEK : let the caller look at the data that available to be read, without having the system discard the data after the recv() or recvfrom() returns MSG_WAITALL : recv() call will only return when the full amount of data is available MSG_DONTROUTE : the message will be sent ignoring any routing conditions of the underlying protocol Return values Length of the data written or read. Dept. of Computer Science & Engineering 28

29 Close/shutdown int close(int sockfd); Used to close a socket. int shutdown (int sockfd, int howto) Used to close a socket, but provide more control over full-duplex connection Howto 0 : close a sock for reading 1 : close a sock for writing 2 : close a sock for reading and writing Dept. of Computer Science & Engineering 29

30 Example #1: UNIX Domain (1) /* Server -- UNIX domain stream socket */ #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> /* as we are using UNIX protocol */ #define NAME "my_sock" int main(void) { int orig_sock; /* Original socket descriptor in server */ int new_sock; /* New socket descriptor from connect */ int clnt_len; /* Length of client address */ int i; /* Loop counter */ Dept. of Computer Science & Engineering 30

31 Example #1: UNIX Domain (2) static struct sockaddr_un clnt_adr; /* UNIX addresses of client */ static struct sockaddr_un serv_adr; /* UNIX addresses of server */ static char buf[10]; /* Buffer for messages */ void clean_up(int, char *); /* Close socket and remove it routine */ if ((orig_sock = socket(af_unix, SOCK_STREAM, 0)) < 0) { /* SOCKET */ perror("generate error"); exit(1); serv_adr.sun_family = AF_UNIX; /* Set tag appropriately */ strcpy(serv_adr.sun_path, NAME); /* Assign name (108 chars max) */ unlink(name); /* Remove old copy if present */ if (bind(orig_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr.sun_family)+strlen(serv_adr.sun_path)) < 0) { perror("bind error"); clean_up(orig_sock, NAME); exit(2); Dept. of Computer Science & Engineering 31

32 Example #1: UNIX Domain (3) listen(orig_sock, 1); /* LISTEN; create one-entry queue */ clnt_len = sizeof(clnt_adr); /* clnt_len = 110 */ if ((new_sock = accept(orig_sock, (struct sockaddr *)&clnt_adr, &clnt_len)) < 0) { perror("accept error"); clean_up(orig_sock, NAME); exit(3); for (i = 1; i <= 10; i++) { /* Process */ read(new_sock, buf, sizeof(buf)); printf("s-> %s", buf); close(new_sock); clean_up(orig_sock, NAME); exit(0); Dept. of Computer Science & Engineering 32

33 Example #1: UNIX Domain (4) void clean_up(int sd, char *the_file) { close(sd); /* close it */ unlink(the_file); /* remove it */ Dept. of Computer Science & Engineering 33

34 Example #1: UNIX Domain (5) /* Client -- UNIX domain stream socket */ #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> #define NAME "my_sock int main(void) { int orig_sock; /* Original socket descriptor in client */ int i; /* Loop counter */ static struct sockaddr_un serv_adr; /* UNIX address of the server process */ static char buf[10]; /* Buffer for messages */ Dept. of Computer Science & Engineering 34

35 Example #1: UNIX Domain (6) if ((orig_sock = socket(af_unix, SOCK_STREAM, 0)) < 0) { /* SOCKET */ perror("generate error"); exit(1); serv_adr.sun_family = AF_UNIX; /* Set tag appropriately */ strcpy(serv_adr.sun_path, NAME);/* Assign name */ if (connect(orig_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr.sun_family)+strlen(serv_adr.sun_path)) < 0) { perror("connect error"); exit(1); for (i = 1; i <= 10; i++) { /* Send msgs */ sprintf(buf, "c: %d\n", i); write(orig_sock, buf, sizeof(buf)); close(orig_sock); exit(0); Dept. of Computer Science & Engineering 35

36 Sample Run Dept. of Computer Science & Engineering 36

37 Host Name Conversion #include <netdb.h> extern int h_errno; struct hostent *gethostbyname(const char *name); name: hostname, IPv4 or IPv6 address #include <sys/socket.h> /* for AF_INET */ struct hostent *gethostbyaddr(const char *addr, int len, int type); addr, len: IP address type: AF_INET is the only valid type. void herror(const char *s); Print error message Dept. of Computer Science & Engineering 37

38 Host Entry Structure (1) The hostent structure is defined in <netdb.h> as follows: 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 */ #define h_addr h_addr_list[0] /* first address in list */ Dept. of Computer Science & Engineering 38

39 Host Entry Structure (2) The members of the hostent structure are: h_name The official name of the host. h_aliases A zero-terminated array of alternative names for the host. h_addrtype The type of address; always AF_INET at present. h_length The length of the address in bytes. h_addr_list A zero-terminated array of network addresses for the host in network byte order. h_addr The first address in h_addr_list Dept. of Computer Science & Engineering 39

40 Byte Ordering Conversion (1) htonl, htons, ntohl, ntohs Handle the potential byte order differences between different computer architectures and different network protocols So, convert values between host and network byte order On the i80x86, the host byte order is Least Significant Byte first, whereas the network byte order, as used on the Internet, is Most Significant Byte first For example, Ox4F52 Dept. of Computer Science & Engineering 40

41 Byte Ordering Conversion (2) #include <netinet/in.h> unsigned long int htonl(unsigned long int hostlong); Converts the long integer hostlong from host byte order to network byte order. unsigned short int htons(unsigned short int hostshort); unsigned long int ntohl(unsigned long int netlong); unsigned short int ntohs(unsigned short int netshort); Dept. of Computer Science & Engineering 41

42 Address Manipulation (1) inet_aton, inet_addr, inet_network, inet_ntoa : Internet address manipulation routines. #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> int inet_aton(const char *cp, struct in_addr *inp); inet_aton converts the Internet host address cp from the standard numbers-and-dots notation into binary data and stores it in the structure that inp points to. inet_aton returns nonzero if the address is valid, zero if not. Dept. of Computer Science & Engineering 42

43 Address Manipulation (2) unsigned long int inet_addr(const char *cp); Converts the Internet host address cp from numbers-and-dots notation into binary data in network byte order. unsigned long int inet_network(const char *cp); Extracts the network number in host byte order from the address cp in numbers-and-dots notation. char *inet_ntoa(struct in_addr in); Converts the Internet host address in given in network byte order to a string in standard numbers-and-dots notation (note: it returns a pointer to a static buffer!). Dept. of Computer Science & Engineering 43

44 Example #2: Internet Domain (1) /* local.h -- header file */ #include <stdio.h> #include <string.h> #include <ctype.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <netdb.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/ioctl.h> #define PORT 6969 static char buf[bufsiz]; /* Buffer for messages */ Dept. of Computer Science & Engineering 44

45 Example #2: Internet Domain (2) /* Server -- Internet domain stream socket */ #include "local.h" int main(void) { int orig_sock; /* Original socket descriptor in server */ int new_sock; /* New socket descriptor from connect */ int clnt_len; /* Length of client address */ static struct sockaddr_in clnt_adr; /* Internet address of client */ static struct sockaddr_in serv_adr; /* Internet address of server */ static char buf[bufsiz]; /* Buffer for messages */ int len, i; /* Misc counters, etc. */ if ((orig_sock = socket(af_inet, SOCK_STREAM, 0)) < 0) { /* SOCKET */ perror("generate error"); exit(1); Dept. of Computer Science & Engineering 45

46 Example #2: Internet Domain (3) memset(&serv_adr, 0, sizeof(serv_adr)); /* Clear it out */ serv_adr.sin_family = AF_INET; /* Set address type */ serv_adr.sin_addr.s_addr = htonl(inaddr_any); /* Any interface */ serv_adr.sin_port = htons(port); /* Use our fake port */ /* BIND */ if (bind(orig_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) < 0) { perror("bind error"); close(orig_sock); exit(2); /* LISTEN */ if (listen(orig_sock, 5) < 0 ) { perror("listen error"); exit(3); Dept. of Computer Science & Engineering 46

47 Example #2: Internet Domain (4) do { /* ACCEPT */ clnt_len = sizeof(clnt_adr); if ((new_sock = accept(orig_sock, (struct sockaddr *)&clnt_adr, &clnt_len)) < 0) { perror("accept error"); close(orig_sock); exit(4); if (fork() == 0) { /* In CHILD process */ while ((len = read(new_sock, buf, BUFSIZ)) > 0) { for (i = 0; i < len; ++i) /* Change the case */ buf[i] = toupper(buf[i]); write(new_sock, buf, len); /* write it back */ if (buf[0] == '.') break; /* are we done yet? */ close(new_sock); /* In CHILD process */ exit(0); else close(new_sock); /* In PARENT process */ while(1); /* FOREVER */ /* main */ Dept. of Computer Science & Engineering 47

48 Example #2: Internet Domain (5) /* Client -- Internet domain stream socket */ #include "local.h" int main(int argc, char *argv[]) { int orig_sock, len; static struct sockaddr_in serv_adr; struct hostent *host; if (argc!= 2) { fprintf(stderr, "usage: %s server\n", argv[0]); exit(1); host = gethostbyname(argv[1]); /* GET INFO */ if (host == (struct hostent *)NULL) { perror("gethostbyname "); exit(2); Dept. of Computer Science & Engineering 48

49 Example #2: Internet Domain (6) memset(&serv_adr, 0, sizeof(serv_adr)); /* Clear it out */ serv_adr.sin_family = AF_INET; memcpy(&serv_adr.sin_addr, host->h_addr, host->h_length); serv_adr.sin_port = htons(port); /* SOCKET */ if ((orig_sock = socket(af_inet, SOCK_STREAM, 0)) < 0) { perror("generate error"); exit(3); /* CONNECT */ if (connect(orig_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) < 0) { perror("connect error"); exit(4); Dept. of Computer Science & Engineering 49

50 Example #2: Internet Domain (7) do { write(fileno(stdout),"> ", 3); /* Prompt the user */ if ((len = read(fileno(stdin), buf, BUFSIZ)) > 0) { /* Get user input */ write(orig_sock, buf, len); /* Write to socket */ if ((len = read(orig_sock, buf, len)) > 0 ) /* If returned */ write(fileno(stdout), buf, len); /* display it. */ while(buf[0]!= '.'); close(orig_sock); exit(0); /* main */ Dept. of Computer Science & Engineering 50

51 Sample Run Dept. of Computer Science & Engineering 51

52 Example #3: TCP Server (1) /* echo_ser.c This program illustrates an iterative version echo server using TCP Algorithm outline a. Open a TCP socket b. Initialize server socket address structure c. Bind SER_PORT and INADDR_ANY to the open socket (SER_PORT = 49494, an arbitrary number > 49151) d. Create a queue to hold client requests e. Wait for connection request from a client f. Get data from client g. Send response back to client h. Close client connection i. Go back to e. This program also shows: a. How to zero out a structure (bzero()) b. Host to network byte order conversion short (htons()) c. Host to network byte order conversion long (htonl()) d. Use of recv(), which is read() + options Dept. of Computer Science & Engineering 52

53 Example #3: TCP Server (2) e. Use of send(), which is write() + options Be aware that recv() and send() return values of ssize_t To compile: gcc -o echo_ser echo_ser.c Command syntax: echo_ser & */ #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <unistd.h> #define LISTENQ 5 /* max concurrent client requests allowed */ #define SER_PORT /* arbitrary; official echo server port is 7 */ Dept. of Computer Science & Engineering 53

54 Example #3: TCP Server (3) int main(void) { int ser_sock, cli_sock, ser_len, cli_len; size_t nread; char buf[bufsiz]; struct sockaddr_in ser, cli; /* to open a socket */ if ((ser_sock = socket(af_inet, SOCK_STREAM, 0)) == -1) { fprintf(stderr, "Unable to create server socket\n"); exit(1); /* to initialize server sockaddr_in structure */ ser_len = sizeof(ser); /* to get ser socket struct length */ bzero((char *)&ser, ser_len); /* to zero out struct */ ser.sin_family = AF_INET; /* domain Internet */ ser.sin_port = htons(ser_port); /* echo server port */ ser.sin_addr.s_addr = htonl(inaddr_any); /* any IP address accepted */ Dept. of Computer Science & Engineering 54

55 Example #3: TCP Server (4) /* to bind open socket to an IPaddr/service port pair */ if ((bind(ser_sock, (struct sockaddr *)&ser, ser_len)) == -1) { fprintf(stderr, "Unable to bind to service port for server\n"); exit(2); /* to place the socket in passive mode */ if (listen(ser_sock, LISTENQ)) { /* to create a connection request Q */ fprintf(stderr, "Unable to create a client request queue\n"); exit(3); /* listen() does not fail frequent */ /* to wait for connection requests from clients, 1 at a time */ cli_len = sizeof(cli); Dept. of Computer Science & Engineering 55

56 Example #3: TCP Server (5) for (;;) { /* run forever till terminated manually */ cli_sock = accept(ser_sock, (struct sockaddr *)&cli, &cli_len); /* accept() blocks until a client connection request arrives */ if (cli_sock == -1) { fprintf(stderr, "accept() failed\n"); exit(4); if (fork() == 0) { nread = recv(cli_sock, buf, BUFSIZ, 0); /* read from client */ send(cli_sock, buf, nread, 0); /* write back to client */ close(cli_sock); /* close client connection */ exit(0); else close(cli_sock); close(ser_sock); /* close server socket */ return(0); /* currently not reachable */ /* main */ Dept. of Computer Science & Engineering 56

57 Example #3: TCP Client (1) /* echo_cli.c This the client program for echo_ser.c Algorithm outline: a. Open a TCP socket. b. Initialize server socket address structure c. Connect to server d. Send user input to server e. Display server response on screen f. Notify server of intent to close g. Close socket. This program also illustrates: a. Use of gethostbyname() to get some infor. on intended server. b. Use of bcopy() to copy an element into a structure. c. Use of shutdow() to notify server of closing connection. To compile: gcc -o echo_cli echo_cli.c -lsocket -lnsl Command syntax: echo_cli server_name (either DNS or IP) */ Dept. of Computer Science & Engineering 57

58 Example #3: TCP Client (2) #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> #define SER_PORT /* arbitrary; official echo server port is 7 */ int main(int argc, char *argv[]) { int cli_sock, ser_len, port_number; size_t nread; char buf[bufsiz]; struct sockaddr_in ser; struct hostent *ser_info; Dept. of Computer Science & Engineering 58

59 Example #3: TCP Client (3) /* to open a socket */ if ((cli_sock = socket(af_inet, SOCK_STREAM, 0)) == -1) { fprintf(stderr, "Unable to create socket for client\n"); exit(1); /* to initialize server sockaddr_in structure */ ser_len = sizeof(ser); /* to get ser length */ bzero((char *)&ser, ser_len); /* to zero out struct */ ser.sin_family = AF_INET; /* Internet domain */ ser.sin_port = htons(ser_port); /* echo server port number */ if ((ser_info = gethostbyname(argv[1])) == (struct hostent *)NULL) { fprintf(stderr, "unknown server\n"); exit(2); bcopy((char *)ser_info->h_addr, (char *)&ser.sin_addr, ser_info->h_length); /* to connect to server */ Dept. of Computer Science & Engineering 59

60 Example #3: TCP Client (4) if ((connect(cli_sock, (struct sockaddr *)&ser, ser_len)) == -1) { fprintf(stderr, "can't connect to server\n"); exit(3); nread = read(stdin_fileno, buf, BUFSIZ); /* get input from stdin */ send(cli_sock, buf, nread, 0); /* send data to server */ nread = recv(cli_sock, buf, BUFSIZ, 0); /* read back data */ write(stdout_fileno, buf, nread); /* display it on screen */ shutdown(cli_sock, SHUT_RDWR); /* notify server of closing */ close(cli_sock); /* main */ Dept. of Computer Science & Engineering 60

61 More Example #4: UDP Server (1) /* echo_seru.c This program illustrates an iterative version echo server using UDP Algorithm outline a. Open a UDP socket b. Initialize server socket address structure c. Bind SER_PORT and INADDR_ANY to the open socket (SER_PORT = 49495, an arbitrary number > 49151) d. Wait for a datagram from a client e. Send response back to client f. Go back to d. This program also shows: a. How to zero out a structure (bzero()) b. Host to network byte order conversion short (htons()) c. Host to network byte order conversion long (htonl()) d. Use of recv(), which is read() + options e. Use of send(), which is write() + options Be aware that recv() and send() return values of ssize_t Dept. of Computer Science & Engineering 61

62 More Example #4: UDP Server (2) */ To compile: gcc -o echo_seru echo_seru.c -lsocket Command syntax: echo_seru & #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #define SER_PORT /* arbitrary; official echo server port is 7 */ int main(void) { int ser_sock, ser_len, cli_len; ssize_t nread; char buf[bufsiz]; struct sockaddr_in ser, cli; Dept. of Computer Science & Engineering 62

63 More Example #4: UDP Server (3) /* to open a socket */ if ((ser_sock = socket(af_inet, SOCK_DGRAM, 0)) == -1) { fprintf(stderr, "Unable to create server socket\n"); exit(1); /* to initialize server sockaddr_in structure */ ser_len = sizeof(ser); /* to get ser socket struct length */ bzero((char *)&ser, ser_len); /* to zero out struct */ ser.sin_family = AF_INET; /* domain Internet */ ser.sin_port = htons(ser_port); /* echo server port */ ser.sin_addr.s_addr = htonl(inaddr_any); /* any IP address accepted */ /* to bind open socket to an IPaddr/service port pair */ if ((bind(ser_sock, (struct sockaddr *)&ser, ser_len)) == -1) { fprintf(stderr, "Unable to bind to service port for server\n"); exit(2); Dept. of Computer Science & Engineering 63

64 More Example #4: UDP Server (4) /* to wait for datagrams from clients, 1 at a time */ cli_len = sizeof(cli); for (;;) { /* run forever till terminated manually */ nread = recvfrom(ser_sock, buf, BUFSIZ, 0, /* wait for client */ (struct sockaddr *)&cli, &cli_len); if (nread == (ssize_t)-1) { fprintf(stderr, "recvfrom() failed\n"); exit(3); sendto(ser_sock, buf, (size_t)nread, 0, /* echo back to client */ (struct sockaddr *)&cli, cli_len); close(ser_sock); /* close server socket */ return(0); /* currently not reachable */ /* main */ Dept. of Computer Science & Engineering 64

65 More Example #4: UDP Client (1) /* echo_cliu.c This the client program for echo_seru.c Algorithm outline: a. Open a UDP socket. b. Initialize server socket address structure c. Send user input to server d. Display server response on screen e. Close socket. This program also illustrates: a. Use of gethostbyname() to get some infor. on intended server. b. Use of bcopy() to copy an element into a structure. To compile: gcc -o echo_cliu echo_cliu.c -lsocket -lnsl Command syntax: echo_cliu server_name (either DNS or IP) */ Dept. of Computer Science & Engineering 65

66 More Example #4: UDP Client (2) #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> #define SER_PORT /* arbitrary; official echo server port is 7 */ int main(int argc, char *argv[]) { int cli_sock, ser_len, port_number; size_t nread; char buf[bufsiz]; struct sockaddr_in ser; struct hostent *ser_info; Dept. of Computer Science & Engineering 66

67 More Example #4: UDP Client (3) /* to open a socket */ if ((cli_sock = socket(af_inet, SOCK_DGRAM, 0)) == -1) { fprintf(stderr, "Unable to create socket for client\n"); exit(1); /* to initialize server sockaddr_in structure */ ser_len = sizeof(ser); /* to get ser length */ bzero((char *)&ser, ser_len); /* to zero out struct */ ser.sin_family = AF_INET; /* Internet domain */ ser.sin_port = htons(ser_port); /* echo server port number */ if ((ser_info = gethostbyname(argv[1])) == (struct hostent *)NULL) { fprintf(stderr, "unknown server\n"); exit(2); bcopy((char *)ser_info->h_addr, (char *)&ser.sin_addr, ser_info->h_length); Dept. of Computer Science & Engineering 67

68 More Example #4: UDP Client (4) /* to send user input to server */ nread = read(stdin_fileno, buf, BUFSIZ); /* get input from stdin */ nread = sendto(cli_sock, buf, nread, 0, /* send data to server */ (struct sockaddr *)&ser, ser_len); /* to get and display server response */ nread = recvfrom(cli_sock, buf, BUFSIZ, 0, /* get server response */ (struct sockaddr *)&ser, &ser_len); write(stdout_fileno, buf, nread); /* write out to screen */ close(cli_sock); /* main */ Dept. of Computer Science & Engineering 68

69 More Example #5: UDP Server (1) /* forward_ser.c This is a simple server that forwards datagrams between two clients. Algorithm outline a. Open a UDP socket b. Initialize server socket address structure c. Bind SER_PORT and INADDR_ANY to the open socket (SER_PORT = 49499, an arbitrary number > 49151) d. Wait for a datagram from each of the two clients to set up a logical connection. e. Read a datagram from one client and send it to the other client f. go back to e. To compile: gcc -o forward_ser forward_ser.c -lsocket Command syntax: forward_ser & */ Dept. of Computer Science & Engineering 69

70 More Example #5: UDP Server (2) #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #define MAXCLI 2 /* max # of concurrent clients */ #define SER_PORT /* an arbitrary number > */ int main(void) { int i, clino, ser_sock, ser_len, cli_len, maxfdp1; ssize_t nread; char tempbuf[bufsiz], buf[maxcli][bufsiz]; struct sockaddr_in ser, tempaddr, cli[maxcli]; fd_set readset; int bclients(struct sockaddr_in, struct sockaddr_in *), clientno(struct sockaddr_in, struct sockaddr_in *); Dept. of Computer Science & Engineering 70

71 More Example #5: UDP Server (3) /* to open a socket */ if ((ser_sock = socket(af_inet, SOCK_DGRAM, 0)) == -1) { fprintf(stderr, "Unable to create server socket\n"); exit(1); /* to initialize server sockaddr_in structure */ ser_len = sizeof(ser); /* to get ser socket struct length */ bzero((char *)&ser, ser_len); /* to zero out struct */ ser.sin_family = AF_INET; /* domain Internet */ ser.sin_port = htons(ser_port); /* echo server port */ ser.sin_addr.s_addr = htonl(inaddr_any); /* any IP address accepted */ /* to bind open socket to an IPaddr/service port pair */ if ((bind(ser_sock, (struct sockaddr *)&ser, ser_len)) == -1) { fprintf(stderr, "Unable to bind to service port for server\n"); exit(2); Dept. of Computer Science & Engineering 71

72 More Example #5: UDP Server (4) /* to initialize sockaddr_in structures in the clients array */ for (i = 0; i < MAXCLI; i++) cli[i].sin_addr.s_addr = 0; /* to wait for the first datagram from each client */ cli_len = sizeof(tempaddr); while (1) { nread = recvfrom(ser_sock, tempbuf, BUFSIZ, 0, /* wait for a client */ (struct sockaddr *)&tempaddr, &cli_len); if (nread == (ssize_t)-1) { fprintf(stderr, "recvfrom() failed\n"); exit(3); clino = bclients(tempaddr, cli); strncpy(buf[clientno(tempaddr, cli)], tempbuf, (size_t)nread);/*memcpy() BUG*/ if (clino == MAXCLI) break; Dept. of Computer Science & Engineering 72

73 More Example #5: UDP Server (5) /* to forward initial datagrams between clients */ for (i = 0; i < MAXCLI; i++) { sendto(ser_sock, buf[i], strlen(buf[i]), 0, /* send to another client */ (struct sockaddr *)&cli[(i+1)%2], cli_len); /* to forward datagrams between clients - an infinite loop!! */ while (1) { for (i = 0; i < MAXCLI; i++) { nread = recvfrom(ser_sock, tempbuf, BUFSIZ, MSG_PEEK, /* peek only */ (struct sockaddr *)&tempaddr, &cli_len); if (nread > 0) { nread = recvfrom(ser_sock, tempbuf, BUFSIZ, 0, /* a real read */ (struct sockaddr *)&tempaddr, &cli_len); clino = clientno(tempaddr, cli); /* which client? */ sendto(ser_sock, tempbuf, (size_t)nread, 0, /* forwarding */ (struct sockaddr *)&cli[(clino+1)%2], cli_len); Dept. of Computer Science & Engineering 73

74 More Example #5: UDP Server (6) close(ser_sock); /* close server socket */ return(0); /* currently not reachable */ /* main */ /* bclients() is used to build an array of clients based on their IP addrs */ int bclients(struct sockaddr_in cli, struct sockaddr_in *cliary) { int i; for (i = 0; i < MAXCLI; i++) { if (cliary[i].sin_addr.s_addr!= 0) { if (cli.sin_addr.s_addr == cliary[i].sin_addr.s_addr) continue; /* skip */ else { cliary[i] = cli; /* copy cli infor over */ return(i+1); /* return no of clients */ Dept. of Computer Science & Engineering 74

75 More Example #5: UDP Server (7) return(i); /* return no of clients */ /* bclients */ /* clientno() is used to return the client number for a given IP addr */ int clientno(struct sockaddr_in cli, struct sockaddr_in *cliary) { int i; for (i = 0; i < MAXCLI; i++) { if (cli.sin_addr.s_addr == cliary[i].sin_addr.s_addr) break; return(i); /* clientno */ Dept. of Computer Science & Engineering 75

76 More Example #5: UDP Client (1) /* forward_cli.c This the client program for forward_ser.c Algorithm outline: a. Open a UDP socket. b. Initialize server socket address structure c. Get filename from user, open it for read, and send filename to server d. Wait for server to send filename from another client e. Get ready to use select() f. Use select() to see which fd is ready for read/write g. go back to f until no more fd is ready, or timeout h. Close socket. To compile: gcc -o forward_cli forward_cli.c -lsocket -lnsl Command syntax: forward_cli server_name (either DNS or IP) */ Dept. of Computer Science & Engineering 76

77 More Example #5: UDP Client (2) #include <stdio.h> #include <fcntl.h> #include <unistd.h> #include <sys/select.h> #include <sys/socket.h> #include <sys/types.h> #include <sys/time.h> #include <netinet/in.h> #include <netdb.h> #define max(a1, a2) (a1 >= a2? a1 : a2) #define SER_PORT int main(int argc, char *argv[]) { int cli_sock, ser_len, port_number; int res, rfd, maxfdp1; size_t nread; fd_set readset; Dept. of Computer Science & Engineering 77

78 More Example #5: UDP Client (3) char buf[bufsiz], filename[bufsiz]; struct sockaddr_in ser; struct hostent *ser_info; struct timeval timeout; fd_set saverset; /* to open a socket */ if ((cli_sock = socket(af_inet, SOCK_DGRAM, 0)) == -1) { fprintf(stderr, "Unable to create socket for client\n"); exit(1); /* to initialize server sockaddr_in structure */ ser_len = sizeof(ser); /* to get ser length */ bzero((char *)&ser, ser_len); /* to zero out struct */ ser.sin_family = AF_INET; /* Internet domain */ ser.sin_port = htons(ser_port); /* echo server port number */ if ((ser_info = gethostbyname(argv[1])) == (struct hostent *)NULL) { fprintf(stderr, "unknown server\n"); exit(2); Dept. of Computer Science & Engineering 78

79 More Example #5: UDP Client (4) bcopy((char *)ser_info->h_addr, (char *)&ser.sin_addr, ser_info->h_length); /* to get filename, open it, and send filename to server */ nread = read(stdin_fileno, buf, BUFSIZ); /* get filename from stdin */ strncpy(filename, buf, nread); filename[nread-1] = '\0'; /* remove '\n' & end with '\0' */ if ((rfd = open(filename, O_RDONLY)) == -1) { fprintf(stderr, "Can't open file\n"); exit(3); sendto(cli_sock, buf, nread, 0, (struct sockaddr *)&ser, ser_len); nread = recvfrom(cli_sock, buf, BUFSIZ, 0, (struct sockaddr *)&ser, &ser_len); write(stdout_fileno, buf, nread); /* write out to screen */ /* to get ready for test for read using select() */ FD_ZERO(&readset); /* clear all bits in readset */ FD_SET(rfd, &readset); /* turn on bit for rfd in readset */ FD_SET(cli_sock, &readset); /* turn on bit for cli_sock */ Dept. of Computer Science & Engineering 79

80 More Example #5: UDP Client (5) maxfdp1 = max(rfd, cli_sock) + 1; /* get the max number of fd's */ timeout.tv_sec = 60; /* max wait 60 sec */ /* to start read/send using select() */ saverset = readset; while (1) { if (res = select(maxfdp1, &readset, NULL, NULL, &timeout)) { if (res == -1) { perror("select() failed"); break; /* error */ if (FD_ISSET(cli_sock, &readset)) { /* socket is readable */ nread = recvfrom(cli_sock, buf, BUFSIZ, 0, (struct sockaddr *)&ser, &ser_len); write(stdout_fileno, buf, nread); /* write out to screen */ if (FD_ISSET(rfd, &readset)) { /* more data in file */ nread = read(rfd, buf, BUFSIZ); /* get data from file */ Dept. of Computer Science & Engineering 80

81 More Example #5: UDP Client (6) if (nread == 0) { close(rfd); /* must close */ FD_CLR(rfd, &saverset); /* remove it from read */ else sendto(cli_sock, buf, nread, 0, /* send to server */ (struct sockaddr *)&ser, ser_len); else break; /* exit infinite loop on tiemout */ readset = saverset; /* to reset it */ close(cli_sock); /* main */ Dept. of Computer Science & Engineering 81

82 Home Work #4 Write a simple file server and client using SOCK_STREAM protocol Client : request a file that it want to copy on Server : search a file and transfer the file to the client server Request a file send the file client Dept. of Computer Science & Engineering 82