Chamadas do Socket. Socket(int family, int type, int protocol) SOCK_STREAM SOCK_DGRAM AF_INET AF_UNIX AF_NS. sockfd = socket(af_inet, SOCK_STREAM, 0)

Transcrição

1 Chamadas do Socket Socket(int family, int type, int protocol) AF_INET AF_UNIX AF_NS SOCK_STREAM SOCK_DGRAM 0 sockfd = socket(af_inet, SOCK_STREAM, 0)

2 Chamadas do Socket bind(int sockfd, struct sockaddr *addr, int addrlen) endereço específico de protocolo tamanho da estrutura de endereço sockfd = socket(af_inet, SOCK_STREAM, 0)

3 Usos do Bind Servidor registrar seu endereço Cliente registrar seu endereço Cliente usando protocolo sem conexão solicitar ao sistema a atribuição de um endereço

4 Endereçamento O socket oferece uma estrutura diferente para cada protocolo onde o programador especifica os detalhes de endereçamento Para o protocolo TCP/IP a estrutura sockaddr_in especifica o formato de endereço struct sockaddr_in { u_short sin_family; /* tipo de endereço */ u_short sin_port; /* número da porta */ u_long sin_addr; /* endereço IP */

5 Definindo o endereço de um servidor struct sockaddr_in { u_short sin_family; /* tipo de endereço */ u_short sin_port; /* número da porta */ u_long sin_addr; /* endereço IP */ struct sockaddr_in serv_addr; bzero((char *)&serv_addr, sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = htonl (INADDR_ANY) serv_addr.sin_port = htons( 6644 )

6 Portas Formas de Processos serem associados a uma porta: o processo solicita uma porta específica (tipicamente usado por servidores) o sistema automaticamente atribui uma porta para o processo (tipicamente usado por clientes) o processo especifica porta = 0 antes de fazer a chamada ao bind. O bind atribui uma porta automaticamente

7 TCP/IP - Tabela de Portas Portas reservadas Portas automaticamente atribuídas pelo sistema

8 Funções para conversão para formato padrão u_long htonl(u_long hostlong) host network long u_short htons(u_long hostshort) host network short

9 Operações sobre Bytes Não são manipuladas por operações padrão sobre strings pois: Não terminam com nulo Podem ter bytes nulos dentro deles bcopy(char *src, char *dest, int nbytes) Move o nbytes da origem (src) para o destino bzero(char *dest, int nbytes) zera nbytes do destino int bcmp(char *ptr1, char *ptr2, int nbytes) Compara dois strings. Retorna 0 se os dois são idênticos.

10 INADDR_ANY Para máquinas com duas interfaces de rede, usa-se o INADDR_ANY para estabelecer que o servidor está escutando nas duas redes Rede A Rede B

11 I/O Assíncrono Processo informa ao kernel para notificá-lo quando um determinado descritor está pronto para I/O. Processo Kernel signal

12 I/O Assíncrono Processo usa a função signal para estabelecer um handler para o sinal SIGIO Processo usa a função fcntl para setar o ID do processo para receber sinais SIGIO. Processo habilita o I/O assíncrono usando a chamada fcntl

13 Desvantagem O processo pode ter somente um handler para um dado sinal Se o I/O assíncrono é habilitado para mais que um descritor, quando o sinal chega, o processo não sabe qual descritor está pronto para I/O

14 Select Chamada do sistema que permite que um processo instrua o kernel para observar múltiplos eventos e acorda-lo quando um dos eventos acontecer Útil para o kernel ser instruído para notificar o processo apenas quando dados estão disponíveis em um dos sockets, arquivos,... usados pelo processo => Servidores que administram vários serviços

15 Chamada Select int select(int ndesc, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); ndesc número de descritores a serem testados readfds, writefds, exceptfds descritores de arquivos observados (pronto para leitura, pronto para escrita e de exceções) timeout: - quando diferente de NULL e de zero, aponta um intervalo de tempo fixo para a chamada ficar monitorando os descritores. - igual a NULL, o select permanece indefinidamente monitorando os descritores - igual a zero, a chamada retorna imediatamente após verificar os descritores

16 Chamadas Remotas de Procedimentos (RPC) Chamada Remota de Procedimento (RPC) ou Chamada de Função ou Chamada de Subrotina Método de transferência de controle de parte de um processo para outra parte Procedimentos => permite a divisão do programas em vários pedaços Modelo de RPC é derivado da Chamada de Procedimentos Convencionais

17 O Conceito de Procedimentos main proc1 proc2 proc3 proc4 proc5 proc6 proc7 proc8 - Um programa convencional consiste de um ou mais procedimentos, geralmente organizados em uma hierarquia de chamadas. - Uma seta de um procedimento n para um procedimento m significa uma chamada de n para m

18 RPC: Programa Distribuído Computador 1 Computador 2 main proc1 proc2 proc3 proc4 proc5 proc6 proc7 proc8 - A divisão ocorre entre o programa principal e o procedimento 4. - Um protocolo de comunicação é necessário para implementar a chamada remota.

19 RPC: Modelo de Execução Programa Principal Procedimento A na máquina 1 na máquina 2 (cliente) (servidor) chamada remota proc. A Saída Resposta O processo cliente fica bloqueado durante a execução do procedimento remoto!

20 Passos de uma Chamada Remota de Procedimentos Máquina do Cliente Máquina do Servidor Cliente Empacota Parâmetros Stub do Cliente Desempacota Parâmetros Stub do Servidor Servidor Desempacota Resultado Empacota Resultados KERNEL transporte de mensagens via rede KERNEL transporte de mensagens via rede

21 RPC Objetivo: Tornar mais fácil a implementação de Aplicações Distribuídas Esconde o código de chamadas a rede em procedimentos chamados stubs Stubs -> procedimentos que contêm o código de chamadas a rede. Com stubs o RPC protege os programas de aplicação (cliente e servidor) de preocupações com detalhes como sockets. O RPC inclui uma especificação para formato padrão dos dados (visando interoperabilidade), e nos stubs acontece a conversão dos dados No RPC da Sun o padrão para a representação dos dados é o XDR (external Data Representation Standard) Os stubs são gerados automaticamente por algum compilador. Exemplo: O RPCGen da Sun

22 Chamadas Remotas de Procedimentos (RPC) Idéia do modelo é estender o conceito de chamada de procedimento convencional para ambientes distribuídos. a ênfase é em distribuição e não em concorrência! objetivo é simplificar a programação distribuída, tornandoa semelhante à programação convencional! Remote Procedure Call (RPC): subrotina chamada pode ser função ou procedimento Procedimentos => permitem a divisão do programas em vários pedaços que podem executar em máquinas arbitrárias.

23 Semântica de Chamadas Remotas Ao contrário do que acontece em chamadas convencionais, uma das máquinas envolvidas pode falhar e a outra permanecer ativa... Sistema pode garantir que a execução da rotina chamada ocorre: exatamente uma vez difícil!! no mínimo uma vez operações devem ser idempotentes! no máximo uma vez Sistema deve retornar indicações no caso de máquina servidora falhar!

24 RPC - Implementação O código das chamadas a rede é escondido em procedimentos chamados stubs Stubs -> procedimentos que contêm o código de chamadas a rede. Com stubs o RPC protege os programas de aplicação (cliente e servidor) de preocupações com detalhes como sockets. Cabe aos stubs a passagem de parâmetros entre procedimentos. Máquinas diferentes podem usar representações diferentes de dados como inteiros, caracteres, etc. O que fazer com dados complexos, como listas, etc?

25 Um exemplo de RPC: Sun-RPC Sistema originalmente criado para máquinas Sun. oferecido atualmente em diversos sistemas operacionais! A arquitetura definida inclui: uma linguagem para definição das interfaces (cabeçalhos de procedimentos, etc); a ferramenta RPCGEN, que gera os stubs cliente e servidor automaticamente; uma biblioteca RPC, que pode ser usada diretamente na construção de programas que não usem o RPCGEN; o protocolo de comunicação entre os stubs. Pode utilizar TCP ou UDP

26 Sun-RPC - Tradução de dados Tradução entre formatos de dados: utilização de uma representação padrão, XDR (external Data Representation Standard). formato origem formato padrão formato destino A conversão é especificada para um conjunto pré-definido de tipos de dados.

27 rpcgen - Funcionamento procedimentos servidores programa servidor prog_proc.c stub servidor cc prog_svc prog_svc.c especificação RPC prog.x rpcgen prog.h biblioteca RPC cliente rprog.c prog_clnt.c stub cliente cc programa cliente rprog

28 rpcgen Exemplo de arquivo de especificação: /* date.x especificação de serviços remotos de data e hora */ program DATE_PROG{ version DATE_VERS{ long BIN_DATE(void) = 1; string STR_DATE(long) = 2; = 1; = 0x ;

29 Passo 1: Construir uma Aplicaçao Convencional main proxima insere remove busca inicializar

30 Passo 2: Dividir o programa em duas partes Cliente main Chamadas a Procedimentos Remotos inicializar Programa Remoto proxima insere remove busca Banco de Dados

31 Passo 3: Criar uma Especificação Rpcgen /* rbd.x especificação rpc para um programa de banco de dados que oferece os procedimentos INSERE, REMOVE e BUSCA */ struct example { /* estrutura não usada, declarada para ilustrar como rpcgen */ int exfield1; /* constrói rotinas XDR para converter estruturas */ char exfield2; ; program RBDPROG{ /* nome do programa remoto */ version RDBVERS{ /* declaração da versão */ int INICIALIZAR(void) = 1; /* primeiro procedimento deste programa */ int INSERE(string) = 2; /* segundo procedimento deste programa */ int REMOVE(string) = 3; /* terceiro procedimento deste programa */ int BUSCA(string) = 4; /* quarto procedimento deste programa */ = 1; /* definição da versão do programa */ = 0x ; /* número do programa remoto (deve ser único) */

32 Passo 4: Rodar o Rpcgen rpcgen rbd.x rdb_svc.c rpcgen rdb.h rdb_clnt.c rdb_xdr.c

33 Rpcgen Arquivo.h /* rbd.h */ struct example { int exfield1; char exfield2; ; typedef sruct example example; bool_t xdr_example(); #define RBDPROG (u_long) 0x ) #define RDBVERS ((u_long) 1) #define INICIALIZAR ((u_long) 1) extern int *inicializar_1(); #define INSERE ((u_long) 2) extern int *insere_1(); #define REMOVE ((u_long) 3) extern int *remove_1(); #define BUSCA ((u_long) 4) extern int *busca_1();

34 Rpcgen Arquivo de Conversão XDR /* rbd_xdr.c */ #include <rpc/rpc.h> #include rbd.h bool_t xdr_example(xdrs, objp) XDR *xdrs; example *objp; { if (!xdr_int(xdrs, &objp->exfield1)) { return(false); if (!xdr_char(xdrs, &objp->exfield2) { return(false); return(true);

35 Rpcgen Stub do Cliente /* rbd_clnt.c */ #include <rpc/rpc.h> #include rbd.h int * inicializar_1(argp, clnt) void *argp; CLIENT *clnt; { static int res; bzero((char *)&res, sizeof(res)); if (clnt_call(clnt, INICIALIZAR, xdr_void, argp, xdr_int, &res, TIMEOUT)!= RPC_SUCCESS) return (NULL); return (&res); int *insere_1(argp, clnt) char **argp; CLIENT *clnt; { static int res; bzero((char *)&res, sizeof(res)); if (clnt_call(clnt, INSERE, xdr_wrapstring, argp, xdr_int, &res, TIMEOUT)!= RPC_SUCCESS) return (NULL); return (&res); int * remove_1(argp, clnt) char **argp; CLIENT *clnt; { static int res; bzero((char *)&res, sizeof(res)); if (clnt_call(clnt, REMOVE, xdr_wrapstring, argp, xdr_int, &res, TIMEOUT)!= RPC_SUCCESS) return (NULL); return (&res); int *busca_1(argp, clnt) char **argp; CLIENT *clnt; { static int res; bzero((char *)&res, sizeof(res)); if (clnt_call(clnt, BUSCA, xdr_wrapstring, argp, xdr_int, &res, TIMEOUT)!= RPC_SUCCESS) return (NULL); return (&res);

36 Rpcgen Stub do Servidor /* rbd_svc.c */ #include <rpc/rpc.h> #include rbd.h svc_run(); (void)fprintf( SVC_RUn retornado \n ); exit(1); static void rbdprog_1(); main() { SVCXPRT *transp; (void)pmap_unset(rbdprog, RBDVERS); transp = svcudp_create(rpc_anysock); if (transp == NULL) { (void) fprintf( Não pode criar serviço udp\n ); exit(1); if (!svc_register(transp, RBCPROG, RBDVERS, rbdprog_1, IPPROTO_UDP)) { (void) fprintf( Não pode registrar tal prog.\n ); exit(1); transp = svctcp_create(rpc_anysock, 0, 0); if (transp == NULL) { (void) fprintf( Não pode criar serviço TCP\n ); exit(1); if (!svc_register(transp, RBCPROG, RBDVERS, rbdprog_1, IPPROTO_TCP)) { (void) fprintf( Não pode registrar tal prog.\n ); exit(1); static void rbdprog_1(rqstp, transp) struct svc_req *rqstp; SVCXPRT *transp; { union { char *insere_1_arg; char *remove_1_arg; char *busca_1_arg; argument; char *result; bool_t (*xdr_argument) (), (*xdr_result)(); char *(*local)(); switch (rqstp->rq_proc) { case NULLPROC: ( void)svc_sendreply(transp, xdr_void,(char *) NULL); return; case INICIALIZAR: xdr_argument = xdr_void; xdr_result = xdr_int; local = (char *(*)())inicializar_1; break; case INSERE: xdr_argument = xdr_wrapstring; xdr_result = xdr_int; local = (char *(*)()) insere_1; break;

37 Rpcgen Continuação Stub do Servidor case REMOVE: xdr_argument = xdr_wrapstring; xdr_result = xdr_int; local = (char *(*)())remove_1; break; case BUSCA: xdr_argument = xdr_wrapstring; xdr_result = xdr_int; local = (char *(*)()) busca_1; break; default: svcerr_noproc(transp); return; bzero((char*)&argument, sizeof(argument)); if (!svc_getargs(transp, xdr_argument, &argument)) { svcerr_decode(transp); return; result = (*local)(&argument, rqstp); if (result!= NULL &&!svc_sendreply(transp, xdr_result, result )) { svcerr_systemerr(transp); if (!svc_freeargs(transp, xdr_argument, &argument)) { (void)fprintf( Problema nos argumentos\n ); exit(1);

38 Passo 5: Escrever procedimentos de Interface com o Stub Rotinas de Interface do Cliente /* rbd_cif.c - inicializar, insere, remove, busca */ #include <rpc/rpc.h> #include rbd.h extern CLIENT *handle; /* handle para procedimento remoto */ int inicializar() { return *inicializar_1(handle); int insere(item) char *item; { char **arg; arg = &item; return *insere_1(arg, handle); int remove(item) char *item; { char **arg; arg = &item; return *remove_1(arg, handle); int busca(item) char *item; { char **arg; arg = &item; return *busca_1(arg, handle);

39 Rotinas de Interface do Servidor /* rbd_sif.c - inicializar_1, insere_1, remove_1, busca_1 */ #include <rpc/rpc.h> #include rbd.h static int retcode; int *inicializar_1() { retcode = inicializar(); return &retcode; int *insere_1(i) char **i; { retcode = insere(*i); return &retcode; int *remove_1(i) char **i; { retcode = remove(*i); return &retcode; int *busca_1(i) char **i; { retcode = busca(*i); return &retcode;

40 Passo 6: Compilar e Linkar o Programa Cliente cc -c rbd_cif.c rbd_cif.o cc -c rbd.c rdb.o cc -o rbd rbd.o rbd_clnt.o rbd_xdr.o rbd_cif.o

41 Programa Cliente /* rbd.c - main, proxima*/ #include <rpc/rpc.h> #include rbd.h #define RMACHINE localhost /* nome da máquina remota */ CLIENT *handle; /* handle para um procedimento remoto */ int main(argc, argv) int argc; char *argv[]; { char palavra[maxword+1]; char cmd; int plvlen; /* tamanho da palavra */ /* Seta a conexão para uma chamada remota de procedimento */ handle = clnt_create(rmachine, RBDPROG, RBDVERS, tcp ); if (handle == 0) { printf( Não pode conectar programa remoto/n ); exit(1); while (1) { plvlen = proxima(&cmd, palavra); if (plvlen < 0) exit(0); switch (cmd) { case I : /*inicialize */ inicializar(); printf( BD inicializado \n ); break; case i : /*insere */ insere(palavra); printf( %s Inserida \n, palavra); break; case b : /*busca */ if (busca(palavra)) printf( %s foi encontrada \n, palavra); else printf( %s não existe \n, palavra); break; case r : /*remove */ if (remove(palavra)) printf( %s removida \n, palavra); else printf( %s não encontrada \n, palavra); break; case q : /*quit */ printf( programa encerrado \n ); exit(0); default: /* entrada ilegal */ printf( Comando inválido \n ); break;

42 Continuação Programa Cliente int proxima(cmd, palavra) char *cmd, *palavra; { int i, ch; ch = getc(stdin); while (ch == ) ch = getc(stdin); if (ch == EOF) return -1; *cmd = (char) ch; ch = getc(stdin); while (ch = ) ch = getc(stdin); if (ch == EOF) return -1; if (ch == \n ) return 0; i = 0; while ((ch!= ) && (ch!= \n )) { if (++i > MAXWORD) { printf( Erro, palavra muito longa \n ); exit(1); *palavra++ = ch; ch = getc(stdin); return i;

43 Passo 7: Compilar e Linkar o Programa Servidor cc -c rbd_sif.c rbd_sif.o cc -c rbd_srp.c rdb_srp.o cc -o rbddaemon rbd_svc.o rbd_xdr.o rbd_sif.o rbd_srp.o

44 Programa Servidor /* rbd_srp.c - inicializar, insere, remove, busca*/ #include <rpc/rpc.h> #include rbd.h /* Procedimentos remotos do servidor e dados globais */ char bd[bdsize][maxword+1] /* armazena o dicionário de palavras */ int npalavras = 0; /* número de palavras no dicionário */ int inicializar() { npalavras = 0; return 1; int insere(palavra) char *palavra; { strcpy(bd[npalavras], palavra); npalavras++; return npalavras; int remove(palavra) char *palavra; { int i; for (i=0; i<npalavras; i++) if (strcmp(palavra, bd[i]) == 0) { npalavras--; strcpy(bd[i], bd[npalavras]); return 1; return 0; int busca(palavra) char *palavra; { int i; for (i=0; i<npalavras; i++) if (strcmp(palavra, bd[i]) == 0 ) return 1; return 0;

45 Passo 8: Iniciar o Servidor e Executar o Cliente Iniciar o servidor em background: rbddaemon& Executar o Cliente: rbd