Introdução à Programação com Sockets. Fernando Jorge Silveira Filho Daniel Sadoc Menasché

Transcrição

1 Introdução à Programação com Sockets Fernando Jorge Silveira Filho Daniel Sadoc Menasché

2 Visão Geral Objetivos: Realizar comunicação entre processos. Entender como usar as funções da API sockets. Histórico da API sockets: desenvolvida na época da implementação dos protocolos TCP/IP pelo grupo da UC, Berkeley. Inicialmente iremos (re)ver alguns conceitos que serão importantes.

3 API Sockets Application Program Interface elemento de ligação entre a aplicação e um sistema de mais baixo nível. Aplicação Final Sistema Operacional (Kernel) Drivers e Hardware Aplicação Sockets Transporte Rotinas do S.O. Rede Rotinas do Driver Enlace de Dados Comandos no Hardware Física

4 Conceitos Importantes Argumentos de Valor/Resultado Descritores de Arquivo Chamadas de Sistema de E/S Byte Ordering Portas e Endereços IP Associações & Conexões Serviços de Transporte

5 Argumentos de Valor/Resultado É possível (e comum) na linguagem C, utilizar o recurso de passagem de argumentos por referência para passar valores para uma função ao mesmo tempo em que se espera um valor de retorno na mesma variável. Exemplo: imagine uma função is_prime() que retorna 1 se um número apontado por um ponteiro n é primo e 0 (zero) se composto. Neste último caso, a função também retorna o número primo mais próximo do valor passado. Este segundo valor de retorno pode ser colocado no próprio endereço de memória referenciado por n. int is_prime( int * n ) { /* verifica se (*n) é primo e em caso negativo coloca o primo mais próximo em (*n) */

6 Descritores de Arquivos Números inteiros não negativos que são ponteiros para estruturas de dados do sistema que representam os arquivos abertos por um processo. Descritores de Arquivo Imagem do Processo Estruturas do S.O. x y z z z

7 Chamadas de Sistema de E/S Operações básicas que podem ser realizadas com arquivos. open, close, read, write. #include <unistd.h> int open( const char * filename, int oflag,... ); int close( int fd ); size_t read( int fd, void * buffer, size_t n_bytes ); size_t write( int fd, void * buffer, size_t n_bytes );

8 Byte Ordering Como um valor é armazenado na memória? Exemplo: = 0x Big-Endian Little-Endian Endereço Memória Endereço Memória n 01 n 04 n+1 02 n+1 03 n+2 03 n+2 02 n+3 04 n+3 01 Para evitar conflitos entre hosts de arquiteturas diferentes é convencionado que informações de controle na rede são armazenadas em Big-Endian.

9 Endereços IP e Portas Endereços IP identificam hosts na rede TCP/IP e são formados por 4 bytes, normalmente chamado octetos por razões históricas. Portas são identificadores dos processos interessados em usar os recursos de rede em um host. Portas ocupam 2 bytes na memória. Ambos tipos de variáveis são armazenadas no byte order da rede (Big-Endian). Notação Padrão Hexadecimal A4 0A 02 9C 36

10 Associações Um processo precisa associar um socket a um endereço para avisar ao sistema operacional que deseja receber dados que chegam ao host com o endereço de destino especificado. Processos Sockets Endereço Associado : 80 Processos Sockets Endereço Associado : : : : : : 20

11 Conexões Um socket pode ser conectado a um endereço diferente do seu próprio para que pacotes possam ser enviados por ele diretamente ao processo parceiro. Processo 602 Socket 20 Endereço Associado : Endereço Conectado : 10020

12 Serviços de Transporte A camada de transporte dos protocolos TCP/IP fornece duas opções de tipos de serviço: Serviço orientado a conexão: utiliza o protocolo TCP (Transmission Control Protocol) e garante entrega e ordenação. Serviço datagrama: utiliza o protocolo UDP (User Datagram Protocol) e não faz nenhuma garantia.

13 Esquema de uma Aplicação TCP Um par de aplicações que se comunicam por TCP em Servidor geral tem a seguinte forma: socket( ) Cliente socket( ) connect( ) writen( ) readn( ) close( ) Estabelecimento da Conexão TCP bind( ) listen( ) accept( ) readn( ) writen( ) readn( ) close( )

14 Esquema de uma Aplicação TCP Um par de aplicações que se comunicam por TCP em Servidor geral tem a seguinte forma: Cliente socket( ) socket( ) bind( ) listen( ) ter telefone associar número ao telefone ligar alarme fazer chamada connect( ) Estabelecimento da Conexão TCP accept( ) responder chamada writen( ) readn( ) writen( ) readn( ) close( ) readn( ) close( )

15 Sockets - Criação Utiliza-se a chamada de sistema socket(): #include <sys/types.h> #include <sys/socket.h> int socket( int domain, int type, int protocol ); Parâmetros: domain o tipo de rede do socket. Usamos AF_INET (Address Family Internet). Outros tipos: AF_LOCAL, AF_INET6. type o tipo de serviço de transporte. Para sockets TCP usamos SOCK_STREAM, para UDP usamos SOCK_DGRAM. protocol o protocolo utilizado. Passando 0 (zero) é utilizado o padrão. A função retorna um descritor do socket criado ou 1 em caso de erro.

16 Sockets - Endereços Endereços IP e portas são armazenados em estruturas do tipo struct sockaddr_in. sin_family é o tipo do endereço. AF_INET deve ser usado. sin_port é a porta associada ao endereço. sin_addr é uma estrutura que contém o endereço IP (os 4 octetos). O endereço IP e a porta devem ser armazenados no byte order da rede (Big- Endian). #include <netinet/in.h> struct sockaddr_in { sa_family_t sin_family; in_port_t sin_port; struct in_addr sin_addr; /*... outros campos */ ; struct in_addr { in_addr_t s_addr; ; uint16 htons( uint16 data_in_host_order ); uint16 ntohs( uint16 data_in_net_order ); uint32 htonl( uint32 data_in_host_order ); uint32 ntohl( uint32 data_in_net_order );

17 Sockets - Associação Utiliza-se a chamada de sistema bind(): #include <sys/types.h> #include <sys/socket.h> int bind( int sockfd, struct sockaddr *my_addr, socklen_t addrlen ); Parâmetros: sockfd o descritor do socket. my_addr a estrutura com o endereço para ser associado. addrlen o tamanho da estrutura do endereço (sizeof). A função retorna 0 (zero) em caso de sucesso ou 1 no caso de um erro. Erro comum: EADDRINUSE ( Address already in use )

18 Sockets Traduzindo Endereços IP Para converter um endereço IP entre as formas de string e binária: #include <arpa/inet.h> int inet_aton(const char * str, struct in_addr * addrptr); char * inet_ntoa(struct in_addr addr); A função inet_aton() converte um endereço na notação do ponto ( ) para o formato binário em byte order de rede (como a struct sockaddr_in espera) e retorna 0 (zero) em caso de sucesso. A função inet_ntoa() faz a conversão oposta.

19 Sockets Resolvendo Nomes com DNS Para resolver nomes de hosts ( para endereços IP ( ) usamos as rotinas de acesso ao serviço DNS: #include <netdb.h> struct hostent * gethostbyname(const char * str); struct hostent { int h_length; /* tamanho do endereço */ char **h_addr_list; /* lista de endereços */ char *h_addr; /* primeiro endereço */ /*... outros campos */

20 Sockets TCP Sockets orientados a conexão com garantias de entrega e ordenação. É preciso estabelecer a conexão antes da troca de dados. O servidor cria um socket especial para escutar pedidos de conexão do cliente. Cada vez que o servidor aceita um pedido de conexão recebido no socket de escuta, um novo socket é criado para realizar a comunicação. Assim é possível para o servidor voltar a aceitar novos pedidos de conexão mais tarde (usando o socket de escuta).

21 Sockets TCP listen() Para por um socket em modo de escuta usamos a chamada de sistema listen(): #include <sys/socket.h> int listen( int sockfd, int backlog ); Parâmetros: sockfd o descritor do socket. backlog tamanho da fila de conexões completas. Este parâmetro é extremamente dependente da implementação do Sistema Operacional. O valor de retorno da função é 0 (zero) em caso de sucesso ou 1 caso contrário.

22 Sockets TCP accept() Esta função aceita pedidos de conexão pendentes ou fica bloqueada até a chegada de um. #include <sys/socket.h> int accept( int sockfd, struct sockaddr * cliaddr, socklen_t * addrlen ); Parâmetros: sockfd o descritor do socket. cliaddr a estrutura onde será guardado o endereço do cliente. addrlen argumento valor/resultado com o tamanho da estrutura do endereço. O valor de retorno da função é um novo descritor (não negativo) em caso de sucesso ou 1 caso contrário. Cada novo descritor retornado por accept() está associado à mesma porta do socket de escuta.

23 Sockets TCP send() Usada para enviar dados por um socket conectado. #include <sys/socket.h> int send( int sockfd, void * buffer, size_t n_bytes, int flags ); Parâmetros: sockfd o descritor do socket. buffer um ponteiro para os dados a serem enviados. n_bytes quantidade de bytes a serem enviados a partir do ponteiro buffer. flags opções para essa operação. O valor de retorno da função é a quantidade de bytes enviados em caso de sucesso ou 1 caso contrário.

24 Sockets TCP recv() Recebe dados por um descritor conectado, ou bloqueia a execução até que algum dado chegue ao socket: #include <sys/socket.h> int recv( int sockfd, void * buffer, size_t n_bytes, int flags ); Parâmetros: sockfd o descritor do socket. buffer um ponteiro para a área de memória onde devem ser armazenados os dados recebidos. n_bytes quantidade máxima de bytes a serem recebidos. flags opções para essa operação. O valor de retorno da função é a quantidade de bytes recebidos em caso de sucesso ou 1 caso contrário.

25 Atenção para uma Armadilha! As funções read, recv, recvfrom, write, send e sendto podem retornar menos bytes do que a quantidade requisitada, e nenhuma mensagem de erro é retornada neste caso! Solução: ao usar as funções recv, recvfrom, send e sendto pode-se (devese!) passar como parâmetro a flag MSG_WAITALL.

26 Exemplo Um Cliente TCP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> int main( int argc, char ** argv ) { int sockfd; char recvline[30]; struct sockaddr_in servaddr; if( argc!= 2 ) return 1; sockfd = socket( AF_INET, SOCK_STREAM, 0 ); memset( &servaddr, 0, sizeof(servaddr) ); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(12345); inet_aton( argv[1], &servaddr.sin_addr ); connect( sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr) ); readn( sockfd, recvline, 30 ); fputs( recvline, stdout ); close( sockfd ); return 0;

27 Exemplo Um Cliente TCP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> int main( int argc, char ** argv ) { int sockfd; char recvline[30]; struct sockaddr_in servaddr; memset( &servaddr, 0, sizeof(servaddr) ); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(12345); inet_aton( argv[1], &servaddr.sin_addr ); Criar um socket para rede TCP/IP (AF_INET), orientado a conexão (SOCK_STREAM), usando TCP (o protocolo padrão dado por 0). connect( sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr) ); if( argc!= 2 ) return 1; sockfd = socket( AF_INET, SOCK_STREAM, 0 ); readn( sockfd, recvline, 30 ); fputs( recvline, stdout ); close( sockfd ); return 0;

28 Exemplo Um Cliente TCP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> Inicializar a estrutura servaddr int main( int argc, char ** argv ) { com zeros. Preencher int sockfd; os campos da estrutura char recvline[30]; servaddr: struct sin_family sockaddr_in com servaddr; o tipo de endereço (AF_INET) if( argc sin_port!= 2 ) com a porta (12345) return no byte 1; order da rede. sin_addr com o endereço sockfd passado = socket( como AF_INET, argumento para o programa. SOCK_STREAM, 0 ); memset( &servaddr, 0, sizeof(servaddr) ); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(12345); inet_aton( argv[1], &servaddr.sin_addr ); connect( sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr) ); readn( sockfd, recvline, 30 ); fputs( recvline, stdout ); close( sockfd ); return 0;

29 Exemplo Um Cliente TCP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> Conecta o socket com o endereço do servidor int main( int argc, char ** argv ) (servaddr). Isto irá { int sockfd; char recvline[30]; struct sockaddr_in servaddr; estabelecer a conexão TCP entre o cliente e o servidor. if( argc!= 2 ) return 1; sockfd = socket( AF_INET, SOCK_STREAM, 0 ); memset( &servaddr, 0, sizeof(servaddr) ); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(12345); inet_aton( argv[1], &servaddr.sin_addr ); connect( sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr) ); readn( sockfd, recvline, 30 ); fputs( recvline, stdout ); close( sockfd ); return 0;

30 Exemplo Um Cliente TCP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> int main( int argc, char ** argv ) { int sockfd; char recvline[30]; struct sockaddr_in servaddr; Lê 30 bytes do socket. Esta função pode ler menos bytes se o outro lado (o servidor) fechar a conexão. if( argc!= 2 ) Imprime return 1; os dados recebidos na saída padrão. Fecha o socket. sockfd = socket( AF_INET, SOCK_STREAM, 0 ); memset( &servaddr, 0, sizeof(servaddr) ); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(12345); inet_aton( argv[1], &servaddr.sin_addr ); connect( sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr) ); readn( sockfd, recvline, 30 ); fputs( recvline, stdout ); close( sockfd ); return 0;

31 Exemplo Um Servidor TCP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> int main( int argc, char ** argv ) { int listenfd, connfd, size; struct sockaddr_in myaddr, cliaddr; listenfd = socket( AF_INET, SOCK_STREAM, 0 ); memset( &myaddr, 0, sizeof(myaddr) ); myaddr.sin_family = AF_INET; myaddr.sin_port = htons(12345); myaddr.sin_addr.s_addr = INADDR_ANY; bind( listenfd, (struct sockaddr *)&myaddr, sizeof(myaddr) ); listen( listenfd, 5 ); for( ; ; ) { memset( &cliaddr, 0, sizeof(cliaddr) ); size = sizeof( cliaddr ); connfd = accept( listenfd, (struct sockaddr *)&cliaddr, &size ); writen( connfd, Alo Mundo, 10 ); close( connfd ); return 0;

32 Exemplo Um Servidor TCP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> int main( int argc, char ** argv ) { int listenfd, connfd, size; struct sockaddr_in myaddr, cliaddr; listenfd = socket( AF_INET, SOCK_STREAM, 0 ); memset( &myaddr, 0, sizeof(myaddr) ); myaddr.sin_family = AF_INET; myaddr.sin_port = htons(12345); myaddr.sin_addr.s_addr = INADDR_ANY; bind( listenfd, (struct sockaddr *)&myaddr, Preencher sizeof(myaddr) a estrutura ); do endereço local (myaddr) para associação com o socket: listen( listenfd, 5 ); for( ; ; ) { sin_addr contém o memset( endereço &cliaddr, IP 0, pelo qual o processo sizeof(cliaddr) deseja ); size = receber sizeof( cliaddr pacotes. ); Como connfd uma = accept( máquina listenfd, pode ter (struct vários sockaddr IPs, é mais *)&cliaddr, &size ); prático especificar que writen( connfd, Alo Mundo, 10 ); se deseja receber close( connfd ); pacotes para qualquer um deles. Para isso return 0; usamos a constante INADDR_ANY.

33 Exemplo Um Servidor TCP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> Associar o endereço int main( int argc, char ** argv ) { preenchido com o int listenfd, socket, connfd, para size; informar struct sockaddr_in myaddr, cliaddr; o S.O. de que o processo deseja listenfd = socket( AF_INET, receber pacotes SOCK_STREAM, para 0 ); este endereço. memset( &myaddr, 0, sizeof(myaddr) ); myaddr.sin_family = AF_INET; myaddr.sin_port = htons(12345); myaddr.sin_addr.s_addr = INADDR_ANY; bind( listenfd, (struct sockaddr *)&myaddr, sizeof(myaddr) ); listen( listenfd, 5 ); for( ; ; ) { memset( &cliaddr, 0, sizeof(cliaddr) ); size = sizeof( cliaddr ); connfd = accept( listenfd, (struct sockaddr *)&cliaddr, &size ); writen( connfd, Alo Mundo, 10 ); close( connfd ); return 0;

34 Exemplo Um Servidor TCP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> int main( int argc, char ** argv ) { int listenfd, Colocar connfd, o socket size; em struct sockaddr_in myaddr, cliaddr; modo de escuta. Isto cria uma fila de pedidos de conexão para o socket. listenfd = socket( AF_INET, SOCK_STREAM, 0 ); memset( &myaddr, 0, sizeof(myaddr) ); myaddr.sin_family = AF_INET; myaddr.sin_port = htons(12345); myaddr.sin_addr.s_addr = INADDR_ANY; bind( listenfd, (struct sockaddr *)&myaddr, sizeof(myaddr) ); listen( listenfd, 5 ); for( ; ; ) { memset( &cliaddr, 0, sizeof(cliaddr) ); size = sizeof( cliaddr ); connfd = accept( listenfd, (struct sockaddr *)&cliaddr, &size ); writen( connfd, Alo Mundo, 10 ); close( connfd ); return 0;

35 Exemplo Um Servidor TCP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> Aguarda um pedido de int main( int argc, char ** argv ) { conexão. int listenfd, Envia connfd, uma mensagem size; struct sockaddr_in myaddr, cliaddr; de 10 bytes pelo socket. Fecha o socket da listenfd = socket( AF_INET, conexão. SOCK_STREAM, 0 ); Volta a aceitar novos memset( &myaddr, 0, sizeof(myaddr) ); pedidos. myaddr.sin_family = AF_INET; myaddr.sin_port = htons(12345); myaddr.sin_addr.s_addr = INADDR_ANY; bind( listenfd, (struct sockaddr *)&myaddr, sizeof(myaddr) ); listen( listenfd, 5 ); for( ; ; ) { memset( &cliaddr, 0, sizeof(cliaddr) ); size = sizeof( cliaddr ); connfd = accept( listenfd, (struct sockaddr *)&cliaddr, &size ); writen( connfd, Alo Mundo, 10 ); close( connfd ); return 0;

36 Servidores Concorrentes Muitas vezes é necessário para um servidor lidar com vários clientes de uma única vez. Para conseguir isso é preciso, de alguma maneira, voltar a aceitar conexões, sem esperar que um cliente seja completamente servido. Isto normalmente é feito através da criação de novas threads ou novos processos. Um servidor, após o retorno da função accept(), se divide em dois, e enquanto uma linha de execução se dedica a atender o cliente, outra volta a esperar por novos pedidos de conexão.

37 Servidores concorrentes Esquema de um Servidor Típico pid_t pid; int listenfd, confd; listenfd = socket(...); bind(listenfd,...); listen(listenfd, LISTENQ); for( ; ; ) { connfd = accept(listenfd,...); if ( ( pid = fork() ) == 0 ) { close(listenfd); dosomething(connfd); close(connfd); exit(0) close (connfd);

38 Conclusões sobre sockets TCP Um par de aplicações que se comunicam por TCP em geral tem a seguinte forma: Servidor socket( ) Cliente bind( ) socket( ) listen( ) connect( ) Estabelecimento da Conexão TCP accept( ) Servidores Concorrentes Troca de Dados close( ) close( )

39 Sockets UDP Sockets sem conexão e sem garantias de entrega ou ordenação. Só é preciso saber o endereço de destino antes de enviar dados. É possível receber dados a qualquer momento e de qualquer um. Usamos as funções sendto() e recvfrom(). Pode-se ainda usar a função connect() com sockets UDP, mas o seu significado aqui é diferente, uma vez que NÃO faz sentido falar em uma conexão UDP. Para sockets UDP, a função connect() apenas fixa o endereço conectado. Assim é possível usar as funções send() e recv() como para sockets TCP.

40 Sockets UDP sendto() Envia dados por um socket NÃO conectado. #include <sys/socket.h> int sendto( int sockfd, void * buffer, size_t n_bytes, int flags, const struct sockaddr * to, socklen_t addrlen ); Parâmetros: sockfd o descritor do socket. buffer um ponteiro para os dados a serem enviados. n_bytes quantidade de bytes a serem enviados. flags opções para essa operação. to endereço de destino dos dados. addrlen tamanho em bytes do endereço de destino. O valor de retorno da função é a quantidade de bytes enviados em caso de sucesso ou 1 caso contrário.

41 Sockets UDP recvfrom() Recebe dados por um descritor NÃO conectado, ou bloqueia a execução até que algum dado chegue: #include <sys/socket.h> int recvfrom( int sockfd, void * buffer, size_t n_bytes, int flags, struct sockaddr * from, socklen_t * addrlen ); Parâmetros: sockfd o descritor do socket. buffer um ponteiro para a área de memória onde devem ser armazenados os dados recebidos. n_bytes quantidade máxima de bytes a serem recebidos. flags opções para essa operação. from ponteiro para a estrutura onde será escrito o endereço de origem. addrlen argumento valor/resultado com o tamanho do endereço de origem. O valor de retorno da função é a quantidade de bytes recebidos em caso de sucesso ou 1 caso contrário.

42 Exemplo Um Cliente UDP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> int main( int argc, char ** argv ) { int sockfd; struct sockaddr_in servaddr; if( argc!= 2 ) return 1; sockfd = socket( AF_INET, SOCK_DGRAM, 0 ); memset( &servaddr, 0, sizeof(servaddr) ); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(12345); inet_aton( argv[1], &servaddr.sin_addr ); sendto( sockfd, Alo Servidor, 13, MSG_WAITALL, (struct sockaddr *)&servaddr, sizeof(servaddr) ); close( sockfd ); return 0;

43 Exemplo Um Cliente UDP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> int main( int argc, char ** argv ) { int sockfd; struct sockaddr_in servaddr; if( argc!= 2 ) return 1; sockfd = socket( AF_INET, SOCK_DGRAM, 0 ); memset( &servaddr, 0, sizeof(servaddr) ); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(12345); inet_aton( argv[1], &servaddr.sin_addr ); Criar um socket para rede TCP/IP (AF_INET), orientado a datagramas (SOCK_DGRAM), usando UDP (o protocolo padrão dado por 0). sendto( sockfd, Alo Servidor, 13, MSG_WAITALL, (struct sockaddr *)&servaddr, sizeof(servaddr) ); close( sockfd ); return 0;

44 Exemplo Um Cliente UDP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> Inicializar a estrutura servaddr int main( int argc, char ** argv ) { com zeros. int Preencher sockfd; os campos da struct estrutura sockaddr_in servaddr: servaddr; sin_family com o tipo de if( argc endereço!= 2 ) (AF_INET) return sin_port 1; com a porta (12345) no byte order da rede. sockfd sin_addr = socket( com AF_INET, o endereço passado como SOCK_DGRAM, argumento para o programa. 0 ); memset( &servaddr, 0, sizeof(servaddr) ); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(12345); inet_aton( argv[1], &servaddr.sin_addr ); sendto( sockfd, Alo Servidor, 13, MSG_WAITALL, (struct sockaddr *)&servaddr, sizeof(servaddr) ); close( sockfd ); return 0;

45 Exemplo Um Cliente UDP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> int main( int argc, char ** argv ) { Envia 13 bytes de int sockfd; struct sockaddr_in servaddr; dados para o servidor. if( argc!= 2 ) return 1; sockfd = socket( AF_INET, SOCK_DGRAM, 0 ); memset( &servaddr, 0, sizeof(servaddr) ); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(12345); inet_aton( argv[1], &servaddr.sin_addr ); sendto( sockfd, Alo Servidor, 13, MSG_WAITALL, (struct sockaddr *)&servaddr, sizeof(servaddr) ); close( sockfd ); return 0;

46 Exemplo Um Servidor UDP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> int main( int argc, char ** argv ) { int sockfd, size, n; struct sockaddr_in myaddr; sockfd = socket( AF_INET, SOCK_DGRAM, 0 ); memset( &myaddr, 0, sizeof(myaddr) ); myaddr.sin_family = AF_INET; myaddr.sin_port = htons(12345); myaddr.sin_addr.s_addr = INADDR_ANY; bind( sockfd, (struct sockaddr *)&myaddr, sizeof(myaddr) ); for( ; ; ) { recvfrom( sockfd, recvline, 30, MSG_WAITALL, NULL, NULL ); fputs( recvline, stdout ); return 0;

47 Exemplo Um Servidor UDP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> Associar o endereço int main( int argc, char ** argv ) { preenchido com o int sockfd, size, n; struct sockaddr_in myaddr; socket, para informar o S.O. de que o processo deseja sockfd = socket( AF_INET, receber pacotes SOCK_DGRAM, para 0 ); este endereço. memset( &myaddr, 0, sizeof(myaddr) ); myaddr.sin_family = AF_INET; myaddr.sin_port = htons(12345); myaddr.sin_addr.s_addr = INADDR_ANY; bind( sockfd, (struct sockaddr *)&myaddr, sizeof(myaddr) ); for( ; ; ) { recvfrom( sockfd, recvline, 30, MSG_WAITALL, NULL, NULL ); fputs( recvline, stdout ); return 0;

48 Exemplo Um Servidor UDP #include <sys/types.h> #include <sys/socket.h> #include <unistd.h> #include <netinet/in.h> Aguarda até 30 bytes. É possível para esta int main( função int argc, retornar char ** argv antes ) se { int sockfd, o outro size, lado n; enviar um struct datagrama sockaddr_in menor. myaddr; Imprime os dados sockfd = socket( AF_INET, recebidos na saída SOCK_DGRAM, 0 ); padrão. memset( &myaddr, 0, sizeof(myaddr) ); myaddr.sin_family = AF_INET; myaddr.sin_port = htons(12345); myaddr.sin_addr.s_addr = INADDR_ANY; bind( sockfd, (struct sockaddr *)&myaddr, sizeof(myaddr) ); for( ; ; ) { recvfrom( sockfd, recvline, 30, MSG_WAITALL, NULL, NULL ); fputs( recvline, stdout ); return 0;

49 Conclusões sobre sockets UDP Um par de aplicações que se comunicam por UDP em geral tem a seguinte forma: Cliente Servidor socket( ) socket( ) bind( ) bind( ) Troca de Dados close( ) close( )

50 Depurando: Passo 0, Exibindo mensagens de aviso Esta é a forma mais simples de depurar aplicações que envolvem sockets, threads e mais de um processo. Atenção! Deve-se gerar as mensagens de aviso em stderr (que não possui buffer) e não stdout! Inconveniente desta técnica de depuração: pode afetar o funcionamento do programa.

51 Depurando: Passo 1, A Máquina de Estados Comando chave: netstat -a

52 Depurando: Passo 1, A Máquina de Estados do TCP Comando chave: netstat -a [sadoc@copa src]$ netstat -a grep Proto Local Address Foreign Address State tcp *:32568 *:* LISTEN tcp localhost:47415 localhost:32568 ESTABLISHED tcp localhost:32568 localhost:47415 ESTABLISHED wildcard [sadoc@copa src]$ netstat -a grep tcp localhost:47415 localhost:32568 CLOSE_WAIT tcp localhost:32568 localhost:47415 FIN_WAIT2

53 Depurando: Passo 2, O comando tcpdump tcpdump -x src host_name > log_file Fonte dos pacotes Imprime o conteúdo de cada pacote, em hexadecimal Programa equivalente, com interface gráfica: ethereal

54 Lições Aprendidas

55 Bibliografia Recomendada Stevens, W. R. UNIX Network Programming: Volume I Networking APIs: Sockets and XTI Stevens, W.R. TCP/IP Illustrated vol.1 Besaw, L. BSD Sockets Reference (formato PostScript (.ps) em The Linux Programming Interface: A Linux and UNIX System