04 Elementary. Client/Server. CEN 463 Network Programming. Dr. Mostafa Hassan Dahshan. King Saud University

Transcription

1 CEN 463 Network Programming 04 Elementary TCP Sockets Dr. Mostafa Hassan Dahshan College of Computer and Information Sciences King Saud University Elementary TCP Client/Server 2

2 socket Function First function process must call to perform network I/O #include <sys/socket.h> int socket (int family, int type,, int protocol); ) Returns: non-negative descriptor if OK, -1 on error family AF_INET AF_INET6 AF_LOCAL AF_ROUTE Description IPv4 protocols IPv6 protocols Unix domain protocols Routing sockets type SOCK_STREAM SOCK_DGRAM SOCK_SEQPACKET Description stream socket datagram socket sequenced packet socket AF_KEY Key socket kt SOCK_RAW raw socket protocol IPPROTO_TCP IPPROTO_UDP IPPROTO_SCTP Description TCP transport protocol UDP transport protocol SCTP transport protocol 3 socket Function Allowed combinations shown in table Other values/names used in some systems On success, socket returns positive int Called socket descriptor (sockfd) AF_INET AF_INET6 AF_LOCAL AF_ROUTE AF_KEY SOCK_STREAM TCP, SCTP TCP, SCTP Yes SOCK_DGRAM UDP UDP Yes SOCK_SEQPACKET SCTP SCTP Yes SOCK_RAW IPv4 IPv6 Yes Yes 4

3 connect Function Used by TCP client to establish connection with TCP server #include <sys/socket.h> int connect(int sockfd, const struct sockaddr *servaddr, socklen_ t addrlen); Returns: 0 if OK, -1 on error sockfd is socket ktdescriptor returned dby socket servaddr is a pointer to sockaddr structure addrlen is length of servaddr (since its by ref) servaddr must include server s IP and port 5 connect Function For TCP, connect initiates 3 way handshake h Move from CLOSED to SYN_SENT state Returns only if connection is established (ESTABLISHED state) error occurs (must go back to CLOSED state) Error code Reason Possible cause ETIMEOUT No response to SYN segment Server offline or turned off ECONNREFUSED server responds with RST EHOSTUNREACH ENETUNREACH ICMP "destination unreachable from intermediate router after multiple SYN requests server process not running no route to server machine, should not fail due to transient errors 6

4 bind Function Assigns a local lprotocol address to a socket kt #include <sys/socket.h> int bind (int sockfd, const struct sockaddr *myaddr, socklen_t addrlen); Returns: 0 if OK,-1 on error For IP, protocol potocoaddress is IP address + port Server have to call bind, clients don t Servers bind to their well known ports on start If not called, kernel choose ephemeral port when calling connect or listen 7 bind Function Process can bind specific IP client: assign source IP used for sent datagrams server: restrict incoming connections to that IP TCPclients normally don t bind specific IP kernel decides interface based on route If TCP server doesn t bind an IP address kernel uses dest IP in client SYN as server ss src IP Common error (errno == EADDRINUSE) address (IP + port) already in use 8

5 IP and Port Specification for bind Process Specifies IP address Port Result Wildcard (any) 0 Kernel chooses IP address and port Wildcard (any) nonzero Kernel chooses IP address, process specifies port Local IP address 0 Process specifies IP address, kernel chooses port Local IP address nonzero Process specifies IP address and port 9 Virtual Hosting one.com two.com three.com All IP addresses aliases to same interface using alias option in ifconfig command IP layer will accept datagrams to all IP addresses Each copy of HTTP server e binds to different e IP demultplexing of datagrams done by kernel Another approach, bind to wildcard address demultiplexing done by process (web server) 10

6 listen Function Converts an unconnected socket into a passive socket #include <sys/socket.h> int listen (int sockfd, int backlog); Returns: 0 if OK, -1 onerror Indicate that kernel should accept incoming connection requests to socket sockfd Move socket from CLOSED to LISTEN state Called after socket, bind and before accept backlog is max number of connections kernel can queue for this socket 11 Listening Socket Connection Queues backlog = sum of the lengths of these two queues Incomplete connection queue received SYN, awaiting completion of 3 way HS when ACK received, move to complete connection queue Complete connection queue entry for each client in ESTABLISHED state when server call accept, remove from queue 12

7 Listening Socket Connection Queues What value to choose for backlog? old applications used 5, now inadequate instead of fixed value, can be set by env variable don t set backlog to 0 If queue is full and SYN arrives server ignores, doesn t send RST char* ptr; if ( (ptr = getenv("listenq"))!= NULL) backlog = atoi (ptr); client will retransmit, hopefully finding room when is RST sent? 13 accept Function Rt Return the next connection from the front of the completed ltdconnection queue #include <sys/socket.h> int accept (int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen); Returns: non-negative descriptor if OK, -1 on error Called by TCP server to return next connection If connection queue empty, sleep (blocking) cliaddr used to return client protocol address addrlen is value result argument passed as sizeof(cliaddr), returns actual length 14

8 accept Function On success, accept returns socket descriptor new, created by kernel (TCP connection w/ client) called connected socket (one for each connection) different from listening socket (one per process) If we don t want client address pass cliaddr and addrlen as null pointers (NULL) 15 close Function Close socket and terminate TCP connection #include <unistd.h> int close (int sockfd); Returns: 0 if OK, -1 on error Normal Unix close function Mark socket as closed, returns immediately sockfd can no longer be used for read/write TCP will attempt to send unsent queued data After this, normal TCP connection termination ti 16

9 Example 1 Simple client/server Server code ex1_srv.c c Client code ex1_cli.c Look at execution result 17 Notes Have not checked for errors (serious flaw) No concurrent server No data transfer, just connect Hard coded port numbers Address structs better zero filled before using 18

10 Reading from TCP Socket #include <sys/socket.h> ssize_t recv(int socket, void *buffer, size_t length, int flags); Return: on success, number of bytes received, 0 if no data, -1 onerror #include <unistd.h> ssize_t read(int fildes, void *buf, size_t nbyte); Return: on success, number of bytes read, -1 on error 19 Reading from TCP Socket recv used with sockets, read both files, sockets When used with SOCK_STREAMSTREAM both will block until data is available (blocking socket) return whatever data is available (even 1 byte) not guarantee to return requested length not preserve message boundaries eg e.g. you send 1000 then 1000 you may receive 200, then 600 then 400 read socket ktsame as recv with flags set to 0 20

11 size_t and ssize_t int, long, short different among platforms size_t (size type) unsigned integer suitable for sizes e.g. malloc, memcpy, memset ssize_t (signed size type) same as size_ t but signed used in read/recv and write/send 21 Writing to TCP Socket #include <sys/socket.h> ssize_t send(int socket, void *buffer, size_t length, int flags); Return: on success, number of bytes sent, -1 onerror(errno set) #include <unistd.h> ssize_t write(int fildes, void *buf, size_t nbyte); Return: on success, number of written bytes, -1 on error 22

12 Writing to TCP Socket send used with sockets, write both files, sockets write socket same as send with flags set to 0 If socket has no space to hold all data will block until space if available (blocking socket) Successful return doesn t guarantee delivery only indicates no local error 23 Example 2 Add send and receive functionality Server code ex2_srv.c c Client code ex2_cli.c 24

13 Notes recv should check if there is more data Server closes after handling one client Server can t handle simultaneous connections We ll study these other issues, next 25 fork Function #include <unistd.h> pid_t fork(void); Returns: 0 in child, process ID of child in parent, -1 on error The only way to create new process in Unix Called once, returns twice once in parent process once in child process Child can get parent proces ID: call getppid() Parent can record each child pid from fork return 26

14 fork Function Descriptors (sockets) open by parent before calling fork are shared with child after fork Parent call accept then fork Connected socket shared between parent, child Child read/write connected socket Parent close connected socket 27 fork Uses Process make copy of itself one copy can handle one operation (conn socket) other copy handles another task (listen socket) typical for network servers Execute another program use exec functions process copy replace itself with new program used with shells, inted 28

15 Example fork1.c 29 fork1: Execution Result <main>this is main process (pid = 9079) before fork <main>i have x= 10, y = 10 <common>this part executed in all copies... <child>this a child process (pid = 9080) <child>my parent process (pid = 9079) <child>i have changed x to 15, y to 12 <child>sleeping... <common>this part executed in all copies... <parent>this the parent process (pid = 9079) <parent>i got child with (pid = 9080) <parent>i have x= 10, y = 10 <parent>waiting for child to finish... <child>waking up, finishing... <parent>child finished (returned 0), bye. 30

16 Concurrent Servers Iterative server: handle one client at a time Acceptable for simple daytime server Long service time: can t tie server to one client Concurrent server handle multiple clients at same time use fork, create child process for each client 31 client connect() server listen_fd client connect() server listen_fd conn_fd 32

17 client connect() server(parent) listen_fd conn_fd fork() server (child) listen_fd conn_fd client connect() server(parent) listen_fd server (child) conn_fd 33 pid_t pid; int listen_fd, conn_fd; Concurrent Server Outline listen_fd = socket(... ); /* fill in sockaddr_in{} with server's well-known port */ bind(listen_fd,... ); listen(listen_fd, LISTENQ); for ( ; ; ) { conn_fd = accept (listen_fd,... ); /* probably blocks */ if( (pid = fork()) == 0) { close(listen_fd); /* child closes listening socket */ doit(conn_fd); /* process the request */ close(conn_fd); /* done with this client */ exit(0); /* child terminates */ } } close(conn_ fd); /* parent closes connected socket */ 34

18 Concurrent Server Outline Connection established, accept returns Server call fork Child service client (conn _ fd) ) Parent wait for new connection (listen_fd) Parent close connected socket (conn_fd) why doesn t parent close send FIN to client? socket descriptors duplicated, reference count Child close listening socket (listen_fd) 35 getsockname Function #include <sys/socket.h> int getsockname(int sockfd, struct sockaddr *localaddr, socklen_t *addrlen); Return: 0 if OK, -1 onerror Return protocol address of local socket Usedby client after connect to get assigned IP, port after bind with port 0, get assigned port Used by server after bind, client connect, get local address must use connected, not listening socket for sockfd 36

19 getpeername Function #include <sys/socket.h> int getpeername(int sockfd, struct sockaddr *localaddr, socklen_t *addrlen); Return: 0 if OK, -1 onerror Return protocol address of remote socket Used by server execed by another process that uses accept inetd fork, then exec another server 37 Example: inetd Spawning Telnet Server inetd peer s address fork() inetd(child) peer s address conn_fd =accept( ) conn_fd exec() telnetd calls getpeername() using conn_fd to get peer s address conn_fd telnetd 38

20 Additional References Virtual Hosting p// p p / / / Why size_t matters no=1 read, recv, write and send specifications from Open Group org/onlinepubs/ /functions/recv fork, wait specifications from Open Group

21 File: /home/mostafa/netprog/sockets/ex1_cli.c Page 1 of 1 /* Client that connects and prints a message, no data transfer */ #include <stdio.h> /* printf */ #include <sys/socket.h> /* socket, connect, socklen_t */ #include <arpa/inet.h> /* sockaddr_in, inet_aton */ #define SRV_PORT 2000 /* port number of the server */ int main(int argc, char* argv[]) { int sock_fd; /* client need only one socket */ struct sockaddr_in srv_addr; /* server address structure */ } if (argc < 2) /* user entered no arguments */ { printf("usage: %s <IP address>\n", argv[0]); return -1; } /* create a client socket */ sock_fd = socket(af_inet, SOCK_STREAM, IPPROTO_TCP); srv_addr.sin_family = AF_INET; /* Internet address family */ /* convert command line argument to numeric IP */ inet_aton(argv[1], &srv_addr.sin_addr); srv_addr.sin_port = htons(srv_port); /* TCP server port*/ /* connect to server */ connect(sock_fd, (struct sockaddr*) &srv_addr, sizeof(srv_addr)); printf("connected to:%s:%d..\n",argv[1],srv_port); /* server should perform active close */ return 0;

22 File: /home/mostafa/netprog/sockets/ex1_srv.c Page 1 of 1 /* Server that accepts a single connection and prints a message */ #include <stdio.h> /* printf */ #include <sys/socket.h> /* socket, bind, listen, accept, socklen_t */ #include <arpa/inet.h> /* sockaddr_in, inet_aton */ #include <unistd.h> /* close */ #define SRV_PORT 2000 /* port number for the server */ #define LISTEN_ENQ 5 /* for listen backlog */ int main(int argc, char* argv[]) { int listen_fd, /* listening socket file descriptor*/ conn_fd; /* connected socket file descriptor*/ struct sockaddr_in srv_addr, /* server address structure */ cli_addr; /* client address structure */ socklen_t cli_len; /* to hold the length of cli_addr*/ srv_addr.sin_family = AF_INET; /* Internet address family */ /* listen on all interface (note the htonl) */ srv_addr.sin_addr.s_addr = htonl(inaddr_any); srv_addr.sin_port = htons(srv_port); /* specify TCP port */ /* attempt to open a socket (didn't check for error in this ex) */ listen_fd = socket(af_inet, SOCK_STREAM, IPPROTO_TCP); /* bind to created socket (serv_addr should contain all info) */ bind(listen_fd, (struct sockaddr*) &srv_addr, sizeof(srv_addr)); /* listen on the socket */ listen(listen_fd, LISTEN_ENQ); cli_len = sizeof(cli_addr); printf ("Waiting for a client to connect...\n"); /* block until some client connects */ conn_fd = accept( listen_fd, (struct sockaddr*) &cli_addr, &cli_len); /* display message when client connects */ printf("client connected from %s:%d\n", inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port)); close(conn_fd); /* close connected socket*/ close(listen_fd); /* close listening socket*/ } return 0;

23 File: /home/mostafa/netprog/sockets/ex2_cli.c Page 1 of 1 /* Client that connects, sends a constant message, recive response and quits */ #include <stdio.h> /* printf */ #include <sys/socket.h> /* socket, connect, socklen_t */ #include <arpa/inet.h> /* sockaddr_in, inet_aton */ #include <string.h> /* strlen */ #define SRV_PORT 2000 /* port number of the server */ #define MAX_RECV_BUF 256 int main(int argc, char* argv[]) { int sock_fd; /* client need only one socket */ struct sockaddr_in srv_addr; /* server address structure */ ssize_t sent_bytes, rcvd_bytes; char recv_str[max_recv_buf]; } if (argc < 2) { printf("usage: %s <IP address>\n", argv[0]); return -1; } /* create a client socket */ sock_fd = socket(af_inet, SOCK_STREAM, IPPROTO_TCP); srv_addr.sin_family = AF_INET; /* Internet address family */ /* convert command line argument to numeric IP */ inet_aton(argv[1], &srv_addr.sin_addr); srv_addr.sin_port = htons(srv_port); /* TCP server port*/ /* connect to server */ connect(sock_fd, (struct sockaddr*) &srv_addr, sizeof(srv_addr)); printf("connected to:%s:%d..\n",argv[1],srv_port); /* prepare data to be sent */ char* send_str = "This is a message from Client"; /* send the contents of send_str to server socket */ sent_bytes = send(sock_fd, send_str, strlen(send_str), 0); printf("client sent: %s (%d bytes)\n",send_str, sent_bytes); /* expect to receive one message from server */ rcvd_bytes = recv(sock_fd, recv_str, MAX_RECV_BUF, 0); printf("client received: %s (%d bytes)\n", recv_str, rcvd_bytes); /* server should perform active close */ return 0;

24 File: /home/mostafa/netprog/sockets/ex2_srv.c Page 1 of 2 /* Server that receives a message from a single clinet and sends it back */ #include <stdio.h> /* printf */ #include <sys/socket.h> /* socket, bind, listen, accept, socklen_t */ #include <arpa/inet.h> /* sockaddr_in, inet_aton */ #include <string.h> /* strlen */ #include <unistd.h> /* close */ #define SRV_PORT 2000 /* port number for the server */ #define LISTEN_ENQ 5 /* for listen backlog */ #define MAX_RECV_BUF 256 int main(int argc, char* argv[]) { int listen_fd, /* listening socket file descriptor*/ conn_fd; /* connected socket file descriptor*/ struct sockaddr_in srv_addr, /* server address structure */ cli_addr; /* client address structure */ socklen_t cli_len; /* to hold the length of cli_addr*/ ssize_t sent_bytes, rcvd_bytes; char recv_str[max_recv_buf]; srv_addr.sin_family = AF_INET; /* Internet address family */ /* listen on all interface (note the htonl) */ srv_addr.sin_addr.s_addr = htonl(inaddr_any); srv_addr.sin_port = htons(srv_port); /* specify TCP port */ /* attempt to open a socket (didn't check for error in this ex) */ listen_fd = socket(af_inet, SOCK_STREAM, IPPROTO_TCP); /* bind to created socket (serv_addr should contain all info) */ bind(listen_fd, (struct sockaddr*) &srv_addr, sizeof(srv_addr)); /* listen on the socket */ listen(listen_fd, LISTEN_ENQ); cli_len = sizeof(cli_addr); printf ("Waiting for a client to connect...\n"); /* block until some client connects */ conn_fd = accept( listen_fd, (struct sockaddr*) &cli_addr, &cli_len); /* display message when client connects */ printf("client connected from %s:%d\n", inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port)); /* prepare data to be sent */ char* send_str = "This is a message from Server"; /* expect to receive one message from server */ rcvd_bytes = recv(conn_fd, recv_str, MAX_RECV_BUF, 0); printf("server received: %s (%d bytes)\n", recv_str, rcvd_bytes); /* send the contents of send_str to connected socket */

25 File: /home/mostafa/netprog/sockets/ex2_srv.c Page 2 of 2 sent_bytes = send(conn_fd, send_str, strlen(send_str), 0); printf("server sent: %s (%d bytes)\n",send_str, sent_bytes); close(conn_fd); /* close connected socket*/ close(listen_fd); /* close listening socket*/ return 0; }

26 File: /home/mostafa/netprog/sockets/fork1.c Page 1 of 1 /* Simple fork demo */ #include <stdio.h> /* printf */ #include <unistd.h> /* fork */ #include <sys/wait.h> /* wait */ #include <stdlib.h> /* exit */ int main(void) { pid_t fork_pid; int x=10, y=10; /* to demonstrate that variables are copied to child */ int child_rv; /* child return value */ printf("<main>this is main process (pid = %d) before fork\n", getpid()); printf("<main>i have x= %d, y = %d\n", x, y); } fork_pid = fork(); if(fork_pid < 0) /* fork() failed */ { printf("fork() failed!\n"); return -1; } /* common part */ printf("<common>this part executed in all copies...\n"); /* Now begin the split */ if(fork_pid == 0) /* child part*/ { x += 5; y += 2; printf("<child>this a child process (pid = %d)\n", getpid()); printf("<child>my parent process (pid = %d)\n", getppid()); printf("<child>i have changed x to %d, y to %d\n", x, y); printf("<child>sleeping...\n"); sleep(5); /* let parent do something, to show parallel execution */ printf("<child>waking up, finishing...\n"); child_rv = 0; exit(child_rv); } else /* fork > 0 : parent part*/ { printf("<parent>this the parent process (pid = %d)\n", getpid()); printf("<parent>i got child with (pid = %d)\n", fork_pid ); printf("<parent>i have x= %d, y = %d\n", x, y); printf("<parent>waiting for child to finish...\n"); wait(&child_rv); printf("<parent>child finished (returned %d), bye.\n", child_rv); } return 0;