Prof. Edmundo R. M. Madeira Carlos R. Senna MC823 Laboratório de Teleprocessamento e Redes Primeiro Semestre 2007

2 Programa da Disciplina Apresentação Tecnologia de Comunicação: 1.Sockets 2.RMI 3.Web Services

3 Critério de Avaliação Apresentação Quatro projetos com relatórios de comparação (pesos iguais). Todos os projetos devem ter notas superiores ou iguais a 5. Se não, a média final é o menor valor entre 4,9 e a média dos quatro projetos.

4 Bibliografia Stevens, R. W. Unix Network Programming – Networking APIs: Sockets and XTI – Vol. 1, Second Edition, Prentice-Hall, BIMECC St47u Tutoriais sobre RMI e Web Services. Apresentação

5 Tecnologias de Comunicação Sockets

6 Outline Sockets Socket basics TCP sockets Socket details and options Socket functions Concurrent server Example: Echo Server and Echo Client Signals and Zumbies I/O Multiplexing UDP Sockets

7 Basics Sockets Copyright ©2000 The McGraw Hill Companies Leon-Garcia & Widjaja: Communication Networks Fig. 2.20

8 Basics Sockets An end-point for a IP network connection what the application layer plugs into programmer cares about Application Programming Interface (API) End point determined by two things: Host address: IP address is Network Layer Port number: is Transport Layer Two end-points determine a connection: socket pair ex: ,p ,p1500 ex: ,p ,p1499

9 Ports Sockets Numbers (vary in BSD, Solaris): reserved, must be root 1024 – (registered with IANA) – ephemeral /etc/services: ftp 21/tcp telnet 23/tcp finger 79/tcp snmp 161/udp

10 Sockets and the OS Sockets User Socket Operating System (Transport Layer) User sees descriptor, integer index like: FILE *, or file index returned by socket() call (more later)

11 Transport Layer Sockets UDP: User Datagram Protocol no acknowledgements no retransmissions out of order, duplicate possible connectionless TCP: Transmission Control Protocol reliable ( in order, all arrive, no duplicates ) flow control connection duplex

12 Socket Details Sockets Unix Network Programming, W. Richard Stevens, Second Edition, 1998, Prentice Hall, BIMECC St47u Socket address structure ( Chap. 3 ) TCP client-server ( Chap. 4-5 ) UDP client server ( Chap. 8 ) Misc stuff ( Chap. 7 ) setsockopt(), getsockopt()

13 Socket Address Structure #include struct in_addr { /* 32-bit IPv4 addresses */ in_addr_t s_addr; }; struct sock_addr_in { unit8_t sin_len; /* length of structure */ sa_family_t sin_family; /* AF_INET */ in_port_t sin_port; /* TCP/UDP Port num */ struct in_addr sin_addr; /* IPv4 address */ char sin_zero[8]; /* unused */ } Sockets

14 Tamanhos e Limitações Sockets Tamanho máximo IPv4: bytes incluindo cabeçalho Tamanho máximo IPv6 IPv6: opção Jumbo Payload – 32 bits MTU mínimo de um enlace para: IPv4: 68 bytes; IPv6: 576 bytes Path MTU Tamanho mínimo do buffer de remontagem – tamanho mínimo do datagrama que qualquer implementação deve suportar: IPv4: 576 bytes

15 TCP Client-Server Sockets socket( ) bind( ) listen( ) accept( ) socket( ) connect( ) write( ) read( ) write( ) read( ) close( ) Blocks until conection from client Process request read( ) close( ) TCP Server TCP Client Connection establishment (TCP) three-way handshake data (request) data (reply) End-of-file notification well-known port

16 socket Function Sockets family is one of AF_INET (IPv4), AF_INET6 (IPv6), AF_LOCAL (local Unix), AF_ROUTE (access to routing tables), AF_KEY (new, for encryption) type is one of SOCK_STREAM (TCP), SOCK_DGRAM (UDP) SOCK_RAW (for special IP packets, PING, etc. Must be root) protocol is 0 (used for some raw socket options) upon success returns socket descriptor like file descriptor => -1 if failure int socket(int family, int type, int protocol); Create a socket, giving access to transport layer service. Example: if (( sockfd = socket (AF_INET, SOCK_STREAM, 0)) < 0) err_sys (socket call error);

17 socket Options Sockets Many socket( ) options Set/lookup using setsockopt(), getsockopt() Examples: SO_LINGER SO_RCVBUF, SO_SNDBUF (modify buffer sizes) SO_RCVLOWAT, SO_SNDLOWAT SO_RCVTIMEO, SO_SNDTIMEO (Timeouts) TCP_KEEPALIVE (idle time before close (2 hours, default)) TCP_MAXRT (set timeout value) TCP_NODELAY (disable Nagle Algorithm) See man pages for details man socket on any Unix machine

18 connect Function Sockets sockfd is socket descriptor from socket() servaddr is a pointer to a structure with: Server port number and IP address must be specified (unlike bind()) addrlen is length of structure client doesnt need bind() OS will pick ephemeral port returns socket descriptor if ok, -1 on error int connect( int sockfd, const struct sockaddr *servaddr, socklen_t addrlen ); Connect to server. Example: if ( connect (sockfd, (struct sockaddr *) &servaddr, sizeof (servaddr)) != 0 ) err_sys(connect call error);

19 bind Function Sockets sockfd is socket descriptor from socket() myaddr is a pointer to address struct with: port number and IP address addrlen is length of structure returns 0 if ok, -1 on error EADDRINUSE (Address already in use) int bind( int sockfd, const struct sockaddr *myaddr, socklen_t addrlen ); Assign a local protocol address (name) to a socket. Example: if (bind ( sd, (struct sockaddr *) &servaddr, sizeof (servaddr)) != 0 ) errsys (bind call error);

20 listen Function Sockets sockfd is socket descriptor from socket() backlog is maximum number of incomplete connections historically 5 rarely above 15 on a even moderate web server! Sockets default to active (for client) int listen(int sockfd, int backlog); Announce willingness to accept connections, give queue size, change socket state for TCP server. Example: if (listen (sd, 2) != 0) errsys (listen call error);

21 listen Function Sockets

22 accept Function Sockets sockfd is socket descriptor from socket() cliaddr and addrlen return protocol address from client returns brand new descriptor, created by OS if used with fork(), can create concurrent server (more later) int accept( int sockfd, struct sockaddr cliaddr, socklen_t *addrlen ); Return next completed connection. Example: sfd = accept (s, NULL, NULL); if (sfd == -1) err_sys (accept error);

23 close Function Sockets sockfd is socket descriptor from socket() closes socket for reading/writing returns (doesnt block) attempts to send any unsent data -1 if error int close(int sockfd); Close socket for use.

24 read and write Functions Sockets Pode ler/escrever menos do que necessita devido ao tamanho restrito do buffer. É necessário chamar a função novamente. Somente o write é nonblocking Tamanho máximo IPv4: bytes incluindo cabeçalho Tamanho máximo IPv6 IPv6: opção Jumbo Payload – 32 bits MTU mínimo de um enlace para: IPv4: 68 bytes; IPv6: 576 bytes Path MTU Tamanho mínimo do buffer de remontagem – tamanho mínimo do datagrama que qualquer implementação deve suportar: IPv4: 576 bytes

25 write Function Sockets Aplicação TCP IP Fila saída Enlace Buffer da aplicação (qualquer tamanho) write Buffer de envio do socket ( SO_SNDBUF ) Processo do usuário Kernel Segmentos TCP do tamanho do MSS MSS normalmente MTU – 40 (IPv4) ou MTU – 60 (IPv6) Pacotes IPv4 ou IPv6 do tamanho da MTU Kernel copia dados do buffer da aplicação para buffer do socket. Se não há espaço, o processo é bloqueado até a transferência do último byte. Sucesso da operação write não significa que o outro lado do TCP recebeu os dados.

26 write Function (lib/writen.c) Sockets 1 #include "unp.h" 2 ssize_t /* Write "n" bytes to a descriptor. */ 3 writen(int fd, const void *vptr, size_t n) 4 { 5size_t nleft; 6 ssize_t nwritten; 7 const char *ptr; 8 ptr = vptr; 9 nleft = n; 10 while (nleft > 0) { 11 if ( (nwritten = write(fd, ptr, nleft)) <= 0) { 12 if (nwritten < 0 && errno == EINTR) 13 nwritten = 0; /* and call write() again */ 14 else 15 return (-1); /* error */ 16 } 17 nleft -= nwritten; 18 ptr += nwritten; 19 } 20 return (n); 21 }

27 read Function (lib/readn.c) Sockets 1 #include "unp.h" 2 ssize_t /* Write "n" bytes to a descriptor. */ 3 readn(int fd, void *vptr, size_t n) 4 { 5 size_t nleft; 6 ssize_t nread; 7 char *ptr; 8 ptr = vptr; 9 nleft = n; 10 while (nleft > 0) { 11 if ( (nread = read(fd, ptr, nleft)) < 0) { 12 if (errno == EINTR) 13 nread = 0; /* and call read() again */ 14 else 15 return (-1); 16 } else if (nread == 0) 17 break; /* EOF */ 18 nleft -= nread; 19 ptr += nread; 20 } 21 return (n - nleft); /* return >= 0 */ 22 }

28 Sending and Receiving Sockets Same as read() and write() but for flags flags for I/O functions (see man pages) MSG_DONTWAIT (this send non-blocking) MSG_OOB (out of band data, 1 byte sent ahead) MSG_PEEK MSG_WAITALL (dont give me less than max) MSG_DONTROUTE (bypass routing table) int recv(int sockfd, void *buff, size_t mbytes, int flags); int send(int sockfd, void *buff, size_t mbytes, int flags);

29 Servidor Concorrente Sockets - TCP Após accept e fork, o processo filho executa no CONNFD e o pai continua a escutar no LISTENFD. close decrementa contador de referências. FYN é enviado somente quando contador de referências possui valor zero.

30 Servidor Concorrente – fork Sockets - TCP fork executa uma cópia idêntica do processo. Retorna o identificador do processo filho ao pai (process ID) e o valor 0 (process ID) ao filho. Os descritores abertos antes do fork são compartilhados com os filhos. o connected socked após um accept seguido de fork é compartilhado com o filho. # include pid_t fork(void); Returns: 0 in child, process ID of child in parent, -1 on error

31 Servidor Concorrente – exec Sockets - TCP A função exec executa outro programa. #include int execl ( const char *pathname, const char *arg0,... /* (char *) 0 */ ); int execv ( const char *pathname, char *const argv[ ] ); int execle ( const char *pathname, const char *arg0,... /* (char *) 0, char *const envp[ ] */ ); int execve ( const char *pathname, char *const argv[ ], char *const envp[ ] ); int execlp ( const char *filename, const char *arg0,... /* (char *) 0 */ ); int execvp ( const char *filename, char *const argv[ ] ); All six return: -1 on error, no return on success

32 Servidor Concorrente Sockets - TCP pid_t pid; int listenfd, connfd; /* fill in sockaddr_in{ } with server's well-known port */ listenfd = socket(... ); bind(listenfd,... ); listen(listenfd, LISTENQ); for ( ; ; ) { connfd = accept (listenfd,... ); /* probably blocks */ if( (pid = fork() ) == 0) { close(listenfd); /* child closes listening socket */ doit(connfd); /* process the request */ close(connfd); /* done with this client */ exit(0); /* child terminates */ } close(connfd); /* parent closes connected socket */ }

33 Servidor Concorrente Sockets - TCP connect( ) Client listenfd Server connection request connect( ) listenfd connfd connection connect( ) listenfd connfd connection listenfd connfd fork Server (parent) Server (child) connect( ) listenfd connection connfd Server (parent) Server (child) 1234 Stevens Vol. 1 Fig a 4.17

34 Servidor Concorrente - Exemplo Sockets - TCP Questões: o que acontece... Quando o cliente e o servidor iniciam? Se o servidor terminar antes do cliente finalizar a sessão? Servidor Echo Cliente Echo

35 Servidor Echo ( main ) Sockets - TCP 1 #include "unp.h" 2 int 3 main(int argc, char **argv) 4 { 5 int listenfd, connfd; 6 pid_t childpid; 7 socklen_t clilen; 8 struct sockaddr_in cliaddr, servaddr; 9 listenfd = Socket (AF_INET, SOCK_STREAM, 0); 10 bzero(&servaddr, sizeof(servaddr)); 11 servaddr.sin_family = AF_INET; 12 servaddr.sin_addr.s_addr = htonl (INADDR_ANY); 13 servaddr.sin_port = htons (SERV_PORT); 14 Bind(listenfd, (SA *) &servaddr, sizeof(servaddr)); 15 Listen(listenfd, LISTENQ); 16 for ( ; ; ) { 17 clilen = sizeof(cliaddr); 18 connfd = Accept(listenfd, (SA *) &cliaddr, &clilen); 19 if ( (childpid = Fork()) == 0) { /* child process */ 20 Close(listenfd); /* close listening socket */ 21 str_echo(connfd); /* process the request */ 22 exit (0); 23 } 24 Close(connfd); /* parent closes connected socket */ 25 } 26 } Stevens Vol. 1 Fig. 5.2 TCP echo server

36 Servidor Echo ( str_echo ) Sockets - TCP 1 #include "unp.h" 2 3 void str_echo(int sockfd) 4 { 5 ssize_t n; 6 char buf[MAXLINE]; 7 again: 8 while ( (n = read(sockfd, buf, MAXLINE)) > 0) 9 writen(sockfd, buf, n); 10 if (n < 0 && errno == EINTR) 11 goto again; 12 else if (n < 0) 13 err_sys("str_echo: read error"); 14 }

37 Cliente Echo ( main ) Sockets - TCP 1 #include "unp.h" 2 3 int main(int argc, char **argv) 4 { 5 int sockfd; 6 struct sockaddr_in servaddr; 7 if (argc != 2) 8 err_quit("usage: tcpcli "); 9 sockfd = Socket(AF_INET, SOCK_STREAM, 0); 10 bzero(&servaddr, sizeof(servaddr)); 11 servaddr.sin_family = AF_INET; 12 servaddr.sin_port = htons(SERV_PORT); 13 Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 14 Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 15 str_cli(stdin, sockfd); /* do it all */ 16 exit(0); 17 } Stevens Vol. 1 Fig. 5.4 TCP echo client

38 Cliente Echo ( str_cli ) Sockets - TCP 1 #include "unp.h" 2 3 str_cli(FILE *fp, int sockfd) 4 { 5 char sendline[MAXLINE], recvline[MAXLINE]; 6 while (Fgets(sendline, MAXLINE, fp) != NULL) { 7 Writen(sockfd, sendline, strlen (sendline)); 8 if (Readline(sockfd, recvline, MAXLINE) == 0) 9 rr_quit("str_cli: server terminated prematurely"); 10 Fputs(recvline, stdout); 11 } 12 } Stevens Vol. 1 Fig. 5.5 str_cli function: client processing loop

39 Netstat (início normal) Sockets - TCP linux % tcpserv01 & [1] linux % netstat -a Active Internet connections (servers and established) Proto Recv-Q Send-Q Local Address Foreign Address State tcp 0 0 *:9877 *:* LISTEN linux % tcpcli linux % netstat -a Active Internet connections (servers and established) Proto Recv-Q Send-Q Local Address Foreign Address State tcp 0 0 local host:9877 localhost:42758 ESTABLISHED tcp 0 0 local host:42758 localhost:9877 ESTABLISHED tcp 0 0 *:9877 *:* LISTEN linux % ps -t pts/6 -o pid,ppid,tty,stat,args,wchan PID PPID TT STAT COMMAND WCHAN pts/6 S -bash wait pts/6 S./tcpserv01 wait_for_connect pts/6 S./tcpserv01 tcp_data_wait pts/6 S./tcpcli read_chan

40 Netstat (finalização normal) Sockets - TCP linux % netstat -a | grep 9877 tcp 0 0 *:9877 *:* LISTEN tcp 0 0 localhost:42758 localhost:9877 TIME_WAIT linux % ps -t pts/6 -o pid,ppid,tty,stat,args,wchan PID PPID TT STAT COMMAND WCHAN pts/6 S -bash read_chan pts/6 S./tcpserv01 wait_for_connect pts/6 Z [tcpserv01 <defu do_exit

41 Finalização Normal Sockets - TCP Ao digitar EOF, fget retorna um ponteiro nulo e a função str_cli retorna; O cliente executa exit; Descriptors no cliente são fechados e um FYN é enviado ao servidor. Servidor no estado CLOSE_WAIT e cliente FIN_WAIT-2; O filho servidor estava bloqueado em readline (str_echo) e retorna para main servidor. Filho servidor termina executando exit; Todos os descritores do filho servidor são fechados, um FIN do servidor é enviado e um ACK do cliente; Conexão terminada; e Sinal SIGCHLD é enviado.

42 signal Function Sockets - TCP Sigfunc *signal(int signo, Sigfunc *func); signo is a signal number. *func is a pointer to a signal handling function, as well as the return value from the function. A signal is a notification to a process that ana event has ocurred. Are sometimes called software interrupts. Usually occur asynchronously. Signals can be sent: By one process to another process (or to itself), or By the Kernel to a process.

43 signal Function Sockets - TCP 1 #include "unp.h" 2 3 Sigfunc *signal (int signo, Sigfunc *func) 4 { 5 struct sigaction act, oact; 6 act.sa_handler = func; 7 sigemptyset (&act.sa_mask); 8 act.sa_flags = 0; 9 if (signo == SIGALRM) { 10 #ifdef SA_INTERRUPT 11 act.sa_flags |= SA_INTERRUPT; /* SunOS 4.x */ 12 #endif 13 } else { 14 #ifdef SA_RESTART 15 act.sa_flags |= SA_RESTART; /* SVR4, 4.4BSD */ 16 #endif 17 } 18 if (sigaction (signo, &act, &oact) < 0) 19 return (SIG_ERR); 20 return (oact.sa_handler); 21 } Stevens Vol. 1 Fig. 5.6 signal function

44 Handling SIGCHLD Signals and Zombies Sockets - TCP The purpose of the zombies state is to maintain information about the child for the parent to fetch at some later time. The information includes: The process ID of the child; Its termination status, and Information on the resource utilization of the child (CPU Time, memory, etc). If a process terminates, and the process has children in the zombie state, the parent process ID of all the zombie children is set to 1 (the init process), which will inherit the children and clean them up. Whenever we fork children, we must wait for them to prevent them from becoming zombies.

45 Handling SIGCHLD Signals and Zombies Sockets - TCP Signal (SIGCHLD, sig_chld);... 1 #include unp.h 2 3 void sig_chld( int signo ) 4 { 5 pid_t pid; 6 int stat; 7 pid = wait(&stat); 8 printf(child %d terminated\n, pid); 9 return; 10 }

46 wait and waitpid Functions #include pid_t wait (int *statloc); pid_t waitpid (pid_t pid, int *statloc, int options); Both return: process ID if OK, 0 or–1 on error Sockets - TCP Stevens Vol. 1 Fig Client terminates, closing all five connections, terminating all five children. Server parent Server child #1 Server child #2 Server child #3 Server child #4 Server child # client exit FIN SIGCHLD

47 wait and waitpid Functions waitpid fetching the status of any of our children that have terminated. WNOHANG option specify waitpid not to block. Sockets - TCP Stevens Vol. 1 Fig #include "unp.h" 2 3 void sig_chld(int signo) 4 { 5 pid_t pid; 6 int stat; 7 while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0) 8 printf("child %d terminated\n", pid); 9 return; 10 }

48 TCP server that handles na error of EINTR Sockets - TCP Stevens Vol. 1 Fig #include "unp.h" 3 int main(int argc, char **argv) 4 { 5 int listenfd, connfd; 6 pid_t childpid; 7 socklen_t clilen; 8 struct sockaddr_in cliaddr, servaddr; 9 void sig_chld(int); 10 listenfd = Socket (AF_INET, SOCK_STREAM, 0); 11 bzero (&servaddr, sizeof(servaddr)); 12 servaddr.sin_family = AF_INET; 13 servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 14 servaddr.sin_port = htons(SERV_PORT); 15 Bind(listenfd, (SA *) &servaddr, sizeof(servaddr)); 16 Listen(listenfd, LISTENQ); 17 Signal (SIGCHLD, sig_chld); /* must call waitpid() */ 18 for ( ; ; ) { 19 clilen = sizeof(cliaddr); 20 if ( (connfd = accept (listenfd, (SA *) &cliaddr, &clilen)) < 0) { 21 if (errno == EINTR) 22 continue; /* back to for() */ 23 else 24 err_sys("accept error"); 25 } 26 if ( (childpid = Fork()) == 0) { /* child process */ 27 Close(listenfd); /* close listening socket */ 28 str_echo(connfd); /* process the request */ 29 exit(0); 30 } 31 Close (connfd); /*parent closes connected socket*/ 32 } 33 }

49 Tecnologias de Comunicação Sockets Multiplexação de E/S

50 Introdução Multiplexação de E/S Capacidade de avisar Núcleo que se deseja ser notificado quando condições de E/S estejam válidas. Ex: dados para leitura estão disponíveis. Funções relacionadas: select poll shutdown

51 Quando usar Multiplexação de E/S Quando cliente está manipulando vários descritores. Ex: descritor do socket é de entrada interativa. Quando o cliente manipula vários sockets ao mesmo tempo. Quando TCP manipula listening sockets e outros sockets conectados Quando o servidor trabalha com TCP e com UDP simultaneamente. Quando o servidor manipula vários protocolos e serviços simultaneamente.

52 Tipos e Operações Multiplexação de E/S Tipos: E/S bloqueante; E/S não bloqueante ; Multiplexação de E/S; E/S orientada a sinal; e E/S assíncrona. Operações em duas fases: Espera para dados estarem disponíveis e Cópia dos dados do Kernel para o processo.

53 Modelo Multiplexação de E/S Stevens Vol. 1 Fig. 6.3

54 select Function Multiplexação de E/S #include struct timeval { long tv_sec; /* seconds */ long tv_usec;/* microseconds */ }; int select ( int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, const struct timeval *timeout); Return: positive count of ready descriptors, 0 on timeout and –1 on error.

55 select Function Multiplexação de E/S Instrui o núcleo para acordar o processo quando: Um conjunto de eventos ocorrer ou Um certo intervalo de tempo tiver ocorrido. Pode especificar o descritor: Reading, writing ou exception. Três possibilidades de espera: Espera até condição ser verdadeira – null pointer; Espera por um valor máximo de intervalo; e Não espera. Retorna após verificar os descritores (polling). Os valores de temporização em timeout devem ser zero.

56 poll Function Multiplexação de E/S #include struct pollfd { int fd; /* descriptor to check */ short events;/* events of interest on fd */ short revents;/* events that occurred on fd */ }; int poll ( struct pollfd *fdarray, unsigned long nfds, int timeout); Return: -1 if an error occurred, 0 if no descriptors are ready before the timer expires, Otherwise it is the number of descriptors that have a nonzero revents member.

57 shutdown Function Multiplexação de E/S #include int shutdown(int sockfd, int howto); Return: 0 if OK or -1 on error. Argumento howto: SHUT_RD – fecha para leitura (read-halt). Conteúdo do buffer e futuras recepções são descartadas. SHUT_WR – qualquer dado no buffer de escrita será enviado. Não pode mais escrever. SHUT_RDWR – efeito de fazer SHUT_WR após o SHUT_RD.

58 shutdown Function Multiplexação de E/S Stevens Vol. 1 Fig. 6.12

59 Tecnologias de Comunicação MC823 Sockets UDP