Cliente/Servidor. Programação com Sockets. Graça Bressan. Graça Bressan/LARC

Transcrição

1 Cliente/Servidor Programação com Sockets Graça Bressan Graça Bressan/LARC

2 Interface através de Sockets Socket é uma API ( Aplication Program Interface ) para acesso aos serviços do protocolo de transporte do TCP/IP. As duas principais APIs de comunicação do Unix, para uso em C, são: Sockets da versão de Berkeley TLI ( Trasport Layer Interface ) da versão ATT. Camadas de protocolos TCP/IP Interface através de Sockets A maioria dos fabricantes, em especial os fabricantes de workstations, como Sun e DEC, adotaram o BSD Unix. Portanto, a interface Sockets tornou-se disponível em muitas máquinas e acabou sendo amplamente aceita. A interface de socket utiliza conceitos comuns às operaçòes com arquivos. Graça Bressan/LARC

3 Interface de Programação para Arquivos Operação open close read write Significado Prepara um dispositivo ou um arquivo para operações de E/S. Termina o uso do dispositivo ou arquivo previamente aberto. Obtém dados de um dispositivo ou arquivo e coloca na memória. Transmite dados da memória para dispositivo ou arquivo. Interface de Programação para Arquivos Quando um programa executa a função open para iniciar uma operação de E/S, o sistema retorna um inteiro denominado descritor de arquivos que a aplicação usa nas próximas operações de E/S. O open recebe três argumentos: Nome do arquivo ou do dispositivo a ser aberto. modo de acesso Um conjunto de bits para caso especiais Ao terminar de usar o arquivo, a aplicação chama close para liberar o descritor e os recursos a ele associados (como buffers). Exemplos: (a)abrir um arquivo de nome "nome de arquivo", com um modo que permite leitura e escrita e devolve um descritor de arquivo na variável desc: int desc; desc = open ("nome de arquivo", O_RDWR,0); (b)a aplicação pode usar a variável desc nas operações de E/S, tais como, ler 128 bytes de dados do arquivo para a área denominada buffer: Graça Bressan/LARC

4 read ( desc, buffer, 128 ); (c) Fechar o arquivo ao término das operações: close ( desc ); Interface de Programação de Sockets A API de socket foi incluída como uma extensão das operações sobre arquivos: Descritores análogos aos de arquivo serão usados para comunicação de dados por sockets. As chamadas de sistema, read e write, com descritores de sockets serão usadas para envio e recebimento de dados, de forma análoga às operações convencionais de arquivos. A aplicação deve especificar: As portas dos protocolos local e remoto. Os endereços IP local e remoto Se elas usarão TCP ou UDP Se iniciará a conexão ou irá esperar por uma conexão, isto é, se ela vai se comportar como cliente ou como servidor. Interface de Sockets Um socket armazena uma associação entre uma porta TCP e um endereço IP. Um socket pode ser Passivo ou Ativo: Socket Passivo: um socket criado para esperar conexões de outras estações. Este tipo de socket é utilizado por aplicações servidoras; Socket Ativo: um socket utilizado para iniciar uma conexão. Este tipo de socket é utilizado por aplicações clientes. Abstração de um Socket Descritores de sockets e descritores de arquivos No Unix, um aplicativo que precisa efetuar uma E/S chama a função open para criar um descritor de arquivo que será usado para acessar o dispositivo correto. Graça Bressan/LARC

5 O sistema operacional implementa descritores de arquivos em uma tabela de ponteiros para as estruturas de dados internos de cada dispositivo. Tabela de Descritores Interface de Sockets Cada processo tem uma tabela de descritores de arquivos. Quando um processo abre um arquivo, o Sistema Operacional coloca na tabela de descritores um ponteiro apontando para a estrutura de dados deste arquivo. O descritor retornado pelo open, é o índice da entrada nesta tabela. Como um arquivo, cada socket ativo é identificado por um número inteiro denominado descritor de socket. O Unix aloca o descritor de socket na mesma tabela de descritores de arquivos. O BSD Unix contém uma chamada de sistema denominado "socket" que a aplicação usa para criar um socket. A chamada da função de sistema socket retorna um descritor de socket. O descritor de socket é usado para as próximas operações relacionadas com socket, como read, write, etc. Graça Bressan/LARC

6 Estrutura de dados do sockets Quando uma aplicação chama socket, o sistema operacional aloca uma estrutura de dados que contém as informações necessárias para a comunicação e coloca um ponteiro para essa estrutura na tabela de descritores. Estrutura de dados do sockets Quando um socket é criado o sistema deixa muito dos campos da estrutura vazios e que devem ser preenchidos por outras chamadas de sistema. Após a criação do socket e preenchimento de seus campos, ele pode ser usado para: Esperar por uma conexão (servidor) ou Iniciar uma conexão (cliente). Conexão Uma conexão é uma associação entre dois sockets. Cada um dos sockets de uma conexão são chamados de "end-points". Um socket usado para esperar por uma conexão é denominado socket passivo. Um socket usado para iniciar uma conexão é denominado socket ativo. Graça Bressan/LARC

7 Endereço Final Os pontos extremos da comunicação são os processos de cliente e servidor, cada um rodando em um sistema. Estes processos são identificados pelos seus endereços finais. Em uma rede Internet, os 2 processos podem estar em rede diferentes, conectados por um ou mais roteadores. Consiste de 3 níveis de endereços: Endereço de rede Endereço do host conectado na rede Endereço do processo no host. O TCP/IP usa um inteiro de 32 bits para especificar a rede e o host, e tanto TCP como UDP usam números de porta de 16 bits para especificar o processo do usuário. A maioria das famílias de protocolos definem um conjunto de endereços " bem conhecidos " que são usados para identificar os serviços fornecidos pelo host. Exemplo: A implementação do TCP/IP fornece um servidor de transferência de arquivos denominado FTP que um cliente pode contactar para transferir um arquivo. A porta para FTP é definida como sendo 21. Conexão e Endereços Finais Quando um socket é criado, ele não contém os endereços finais que serão utilizados na conexão. Portanto, antes de usar um socket, o endereço final ou os endereços finais devem ser especificados. Graça Bressan/LARC

8 Conexões entre Sockets Interface de Sockets Encapsulamento de dados TCP no Ethernet Graça Bressan/LARC

9 Exemplo de Cliente/servidor usando TCP Interface através de Sockets com UDP O cliente não estabelece conexão com o servidor. Em vez disso, manda datagramas através de sendto(), que requer endereço do destino (servidor) como argumento. O servidor, por sua vez, não espera por uma conexão. Ele apenas chama recvfrom(), que espera indefinidamente até um dado chegar de algum cliente. A chamada recvfrom() retorna ao chamador, o endereço IP e de porta do processo cliente junto com o datagrama, de forma que o servidor possa enviar uma resposta ao cliente correto. Graça Bressan/LARC

10 Exemplo Cliente/servidor com usando UDP Graça Bressan/LARC

11 Interface de Sockets socket (pf, type, protocol) Cria um novo socket que pode ser usado para comunicação. Retorna um descritor de socket. Os argumentos para a chamada especificam: A família de protocolos que a aplicação vai usar ( por exemplo, PF_INET para TCP/IP). Tipo de serviço (por ex. stream ou datagram ). Protocolo ( ex. TCP ou UDP ). connect (socket, destaddr, addrlen) Depois de criar um socket, um cliente chama connect para estabelecer uma conexão com um servidor remoto. Os argumentos para a chamada são: O descritor de socket obtido com socket. Ponteiro para uma estrutura do tipo sockaddr contendo o endereço final remoto. O connect deixa o socket ligado permanentemente ao endereço destino, isto é, no estado conectado, desde que use serviço com conexão (TCP). Nos serviços sem conexão ele guarda apenas o endereço remoto. Para serviços sem conexão não é necessário usar connect, mas se usar, não será necessário especificar o endereço remoto toda vez que for fazer transferência. write (socket, buffer, length) Tanto cliente como servidor usam write para enviar dados através da conexão TCP, os clientes para enviar solicitações e servidores para enviar respostas Os argumentos para a chamada são: Graça Bressan/LARC

12 Descritor de socket. Endereço onde está o dado. Tamanho do dado em bytes. O write copia os dados a serem enviados em buffers do sistema operacional e permite que a aplicação continue a sua execução enquanto o dado é transmitido pela rede. Se o buffer estiver cheio, o write bloqueia o processo temporariamente até que TCP esvazie o buffer. A alternativa ao write para o modo não conectado é: sendto (socket, buffer, length, flags, destaddr, addrlen) read (socket, buffer, length) Tanto cliente como servidor usam read para receber dados da conexão TCP, servidores usam read para receber solicitações e os clientes para receber resposta. Os argumentos para a chamada são: Descritor de socket. Endereço de um buffer. Tamanho do buffer. O read extrai os bytes que chegam no socket e copia-os no buffer. Se não chegou nenhum dado, a chamada de read bloqueia a execução do processo. Se tiver mais dados que o tamanho do buffer, o read extrai apenas o suficiente para encher o buffer. Se vier menos, extrai todos os bytes e retorna o número de bytes. Read também pode ser usado para receber mensagens em sockets que usam UDP. Nesse caso, cada read extrai um datagrama UDP. Outra alternativa para socket não conectado é: recvfrom (socket, buffer, length, flags, destaddr, addrlen) Graça Bressan/LARC

13 close (socket) Essa chamada termina a conexão, desalocando um socket. Se vários processos estiverem compartilhando um mesmo socket, close decrementa um contador e desaloca o socket quando o contador atingir zero. O argumento para essa chamada é o descritor de socket. bind (socket, localaddr, addrlen) Uma aplicação chama bind para associar um endereço final local a um socket. É usado por servidores para especificar uma porta conhecida através da qual vai esperar por uma conexão. Os argumentos de um bind são: Descritor de socket. Ponteiro para um endereço final. Para os protocolos TCP/IP, o endereço final usa a estrutura sockaddr_in, que inclui um endereço IP e um número de porta. listen (socket, qlength) Quando um socket é criado, ele não é ativo nem passivo. Os servidores orientados a conexão, chamam listen para colocar o socket no modo passivo e deixa-lo preparado para receber conexões. O segundo parâmetro diz ao sistema operacional quantas solicitações de conexão devem ser enfileiradas para o socket. accept (socket, addr, addrlen) Após o servidor chama as funções socket para criar um socket, bind para especificar um endereço final e listen para colocar no modo passivo ele chama o accept para extrair a próxima solicitação de conexão. Um argumento do accept especifica o socket onde a conexão deve ser aceita. A chamada accept cria um novo socket para cada nova solicitação Graça Bressan/LARC

14 de conexão e retorna o descritor deste socket. Este novo socket utiliza a mesma porta do socket inicial. O servidor usa o novo socket apenas para a nova conexão e usa o socket original para aceitar novas solicitações. Uma vez aceita a nova conexão, o servidor pode transferir dados através do novo socket. Resumo de Comandos da Interface de Sockets Nome da Função socket connect write read close bind listen accept recv recvmsg recvfrom send sendmsg sendto Significado Cria um descritor para usar na comunicação Conecta a um par remoto Envia dados através da conexão Recebe dados vindos da conexão Termina comunicação e desaloca o socket Associa um endereço IP local e uma porta do protocolo a um socket Coloca o socket no modo passivo e estabelece o número de conexõestcp que devem ser enfileiradas. Aceita a próxima conexão. Recebe o próximo datagrama. Variação de recv Recebe o próximo datagrama e registra o endereço final do remetente Envia um datagrama Variação do send Envia um datagrama, normalmente a um endereço final Graça Bressan/LARC

15 pré-registrado shutdown getpeername getsockopt setsockopt Termina uma conexão TCP em uma ou ambas as direções Depois que uma conexão chega, obtem o endereço final remoto Obtem as opções atuais de um socket Muda a opção de um socket Utilitários para conversão de inteiros. O TCP/IP utiliza a representação chamada "ordem de bytes da rede" (network byte order), para inteiros usados nos cabeçalhos dos protocolos. Esta representação representa números inteiros com o byte mais significativo primeiro, isto é, no endereço menor (representação big endian). Embora o software de protocolos esconda a maioria dos detalhes, os programadores devem estar cientes deste padrão porque algumas rotinas de sockets exigem que argumentos sejam armazenados na ordem de bytes da rede. Ex.: A estrutura sockaddr_in usa a ordem de bytes da rede. A interface socket possui várias funções que fazem a conversão entre ordem de bytes da rede e a do host. Estas funções são usadas mesmo sabendo que a máquina tem a mesma ordem de bytes da rede. Assim, o programa fica portável para diversas arquiteturas. As rotinas de conversão são as seguintes: htons converte 16 bits da ordem do host para rede ntohs converte 16 bits da ordem da rede para host htonl converte 32 bits da ordem do host para rede ntohl converte 32 bits da ordem da rede para host Graça Bressan/LARC

16 Exemplo de Cliente/Servidor O Exemplo a ser examinado é de um programa servidor que cada vez que é acessado retorna o valor de um contador contendo o número de acessos ao servidor. O retorno é na forma da seguinte cadeia ASCII : "Este servidor foi contatado 10 vezes." O cliente é um programa simples que contata o servidor e obtém o texto acima. A porta escolhida para o servidor é a Funções Utilizadas pelo Programa gethostbyname (domínio) Parâmetro: nome do computador no domínio ao qual pertence Retorna o endereço IP deste computador. Ex.: endip = gethostbyname("merlin.usp.br"); getprotobyname (protocolo) Parâmetro: nome do protocolo Retorna número que identifica o protocolo no sistema. Ex.: numprot = getprotobyname("tcp"); Graça Bressan/LARC

17 Estrutura do Cliente e Servidor Código do Cliente /* client.c - código do programa cliente utilizando TCP */ #ifndef unix #define WIN32 #include <windows.h> #include <winsock.h> #else #define closesocket close #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <netdb.h> #endif #include <stdio.h> #include <string.h> #define PROTOPORT 5193 /* número da port default */ Graça Bressan/LARC

18 extern int errno; char localhost[] = "localhost"; /* nome default do host */ /* * Programa: cliente * * Objetivo: alocar um socket, conectar ao servidor e imprimir * todas saídas. * Sintaxe: cliente [ host [porta] ] * host - nome do computador no qual o servidor * está executando. * porta - número da porta que o servidor está * utilizando. * Nota: Os argumentos são opcionais. Se o host não for * informado o cliente utiliza "localhost"; se nenhuma * porta de for especificada, o cliente utiliza a porta * default dada por PROTOPORT. * */ main(argc, argv) int argc; char *argv[]; { struct hostent *ptrh; /* ponteiro entrada tabela de host */ struct protoent *ptrp; /* ponteiro entrada tab. protocolo */ struct sockaddr_in sad;/* estrutura para end. do servidor */ int sd; /* descritor de socket */ int port; /* número da porta */ char *host; /* ponteiro para o nome do host */ int n; /* número de caracteres para leitura */ char buf[1000]; /* buffer para os dados do servidor */ #ifdef WIN32 WSADATA wsadata; Graça Bressan/LARC

19 WSAStartup(0x0101, &wsadata); #endif memset((char *)&sad,0,sizeof(sad)); /* limpa sockaddr */ sad.sin_family = AF_INET; /* seta familia Internet*/ /* analisa a linha de comando e obtem o nome do host e o número da porta caso tenham sido especificados. */ if (argc > 2) /* Verifica se a porta é especificada */ port = atoi(argv[2]); /* obtem a porta e conv. binário*/ else port = PROTOPORT; /* usa o número da porta default*/ if (port > 0) /* testa se o valor é válido */ sad.sin_port = htons ((u_short) port); else { fprintf(stderr,"numero de porta incorreta:%s\n",argv[2]); exit(1); if (argc > 1) /* Verifica o parâmetro que define o host */ host = argv[1]; /* se o host foi especificado */ else host = localhost; /* Converte nome de host no endereço IP equivalente */ ptrh = gethostbyname(host); if (((char *) ptrh) == NULL ) { fprintf(stderr,"host invalido: %s\n", host); exit (1); memcpy(&sad.sin_addr, ptrh->h_addr, ptrh->h_length); /* Obtem o número do protocolo de transporte TCP */ if (((int) (ptrp = getprotobyname("tcp"))) == 0){ fprintf(stderr,"nao pode mapear \"tcp\" \n"); exit (1); /* Cria o Socket */ Graça Bressan/LARC

20 sd = socket(pf_inet, SOCK_STREAM, ptrp->p_proto); if (sd < 0) { fprintf(stderr,"falha na criacao do socket\n"); exit(1); /* Conecta o socket ao servidor especificado */ if (connect(sd,(struct sockaddr*)&sad,sizeof(sad)) < 0) { fprintf(stderr,"falha na conexao\n"); exit(1); /* Le repetidamente dados do socket e escreve na tela */ n = recv(sd, buf, sizeof(buf), 0); while (n > 0) { write(1, buf, n); n = recv(sd, buf, sizeof(buf), 0); /* fecha o socket */ closesocket(sd); /* Termina o programa cliente */ exit(0); Código do Servidor /* servidor.c - código do programa servidor utilizando TCP */ #ifndef unix #define WIN32 #include <windows.h> #include <winsock.h> #else #define closesocket close #include <sys/types.h> #include <sys/socket.h> Graça Bressan/LARC

21 #include <netinet/in.h> #include <arpa/inet.h> #include <netdb.h> #endif #include <stdio.h> #include <string.h> #define PROTOPORT 5193 /* número da port default */ #define QLEN 6 /* tamanho da fila de requisicoes*/ int visitas = 0; /* cont. de conexões de clientes */ /* * Programa: servidor * * Objetivo: aloca um socket, e repetidamente executa: * (1) espera a proxima conexão de cliente (2) envia uma mensagem curta ao cliente (3) fecha a conexão (d) volta ao passo (1) * Sintaxe: servidor [porta] * * porta - número da porta que o servidor deverá utilizar * Nota: O número da porta é opcional. Se nenhuma porta for * especificada, o servidor utiliza a porta default dada * por PROTOPORT. * */ main(argc, argv) int argc; char *argv[]; { struct hostent *ptrh; /* ponteiro entrada tabela de host */ struct protoent *ptrp; /* ponteiro entrada tab. protocolo */ struct sockaddr_in sad;/* estrutura para end. do servidor */ Graça Bressan/LARC

22 struct sockaddr_in cad;/* estrutura para end. do cliente */ int sd, sd2; /* descritores de socket */ int port; /* número da porta */ char *host; /* ponteiro para o nome do host */ int alen; /* comprimento do endereço */ char buf[1000]; /* buffer para os dados do servidor */ #ifdef WIN32 WSADATA wsadata; WSAStartup(0x0101, &wsadata); #endif menset((char *)&sad,0,sizeof(sad)); /* limpa sockaddr */ sad.sin_family = AF_INET; /* seta familia Internet*/ sad.sin_addr.s_addr = INADDR_ANY; /* seta IP local */ /* analisa a linha de comando e obtem o nome o número da porta caso tenha sido especificado. */ if (argc > 1) /* se a porta é especificada */ port = atoi(argv[2]); /* obtem a porta e conv. binário*/ else port = PROTOPORT; /* usa o número da porta default*/ if (port > 0) /* testa se o valor é válido */ sad.sin_port = htons ((u_short) port); else { fprintf(stderr,"numero de porta incorreta:%s\n",argv[2]); exit(1); /* Obtem o número do protocolo de transporte TCP */ if (((int) (ptrp = getprotobyname("tcp"))) == 0){ fprintf(stderr,"nao pode mapear \"tcp\" \n"); exit (1); /* Cria o Socket */ sd = socket(pf_inet, SOCK_STREAM, ptrp->p_proto); Graça Bressan/LARC

23 if (sd < 0) { fprintf(stderr,"falha na criacao do socket\n"); exit(1); /* Faz o Bind do endereço local com o socket */ if (bind(sd,(struct sockaddr*)&sad,sizeof(sad)) < 0) { fprintf(stderr,"falha no bind\n"); exit(1); /* Coloca o soket no estado passivo, define fila de espera */ if (listen(sd,qlen) < 0) { fprintf(stderr,"falha no listen\n"); exit(1); /* Loop principal do servidor:aceita requisições de conexão*/ while (1) { alen = sizeof(cad); if ((sd2=accept(sd,(struct sockaddr*)&cad, &alen)) < 0) { fprintf(stderr,"falha no accept\n"); exit(1); visitas++; sprintf(buf,"este servidor foi contatado %d vez%e\n", visitas, visitas==1?".":"es."); send(sd2, buf, strlen(buf), 0); closesocket(sd2); Graça Bressan/LARC

24 Utilizando o Cliente com outro Servidor O cliente do exemplo é um programa genérico que realiza uma conexão TCP para obter uma seqüência de caracteres ASCII. Além de ser utilizado com o servidor do exemplo, também pode ser utilizado com outros servidores com operem de forma similar. Este é o caso do servidor DAYTIME disponível nos sistemas e que utiliza a porta 13. As chamadas a seguir retornam a data e hora de diferentes computadores. $cliente localhost 13 Mon May 12 10:20: $cliente xx.lcs.mit.edu 13 Mon May 12 09:23: Utilizando outro Cliente com o Servidor Outro cliente pode ser utilizado para testar o servidor do exemplo, como no caso do telnet que utiliza os mesmos parâmetros: nome do computador e número da porta do servidor. Exemplo de chamada: $telnet xx.yy.provedor.com 5193 Trying Connected to xx.yy.provedor.com 5193 Escape character is ^]. Este servidor foi contatado 4 vezes. Connection closed by foreign host. Serviço Stream No exemplo, o servidor executa apenas um send e o cliente realiza vários recv para obter o mesmo dado do send. A iteração termina quando o cliente obtém a condição de fim de arquivo, isto é, contador de bytes recebidos igual a zero. O TCP não garante que os dados sejam enviados em um único segmento por esta razão o cliente deve executar vários recv. Graça Bressan/LARC

25 Bloqueio nos Procedimentos de Sockets Muitos dos procedimentos de sockets causam o bloqueio do processo que executou o procedimento. No accept, por exemplo, o programa fica bloqueado até receber um pedido de conexão. No recv e read, de forma análoga, o programa ficará bloqueado até a chegada de dados. Existe tratamento assíncrono no TCP, que não bloqueia o programa quando este está a espera de algum dado ou conexão através de um socket. O tratamento assíncrono utiliza o comando select. Muita chamadas de sockets causam o bloqueio do processo que a executou. No accept, por exemplo, o programa fica bloqueado até receber um pedido de conexão. No recv e read, de forma análoga, o programa ficará bloqueado até a chegada de dados. Fim do módulo Programação com Socket Graça Bressan/LARC