IPC no UNIX. Onofre Trindade Jr

Transcrição

1 IPC no UNIX Onofre Trindade Jr

2 Processo módulo módulo Comunicação entre módulos Variáveis globais Chamada de funções parâmetros resultados Comunicação Processo Único

3 Processo A Processo B Kernel Comunicação Processador Único

4 Processo A Processo B SO Distribuído / Rede Kernel Kernel Comunicação Dois Processadores

5 Sinais (Interrupções de Software) Pipes e FIFOs Filas de Mensagens Memória Compartilhada Semáforos Sockets RPC (Remote Procedure Calls) Mutex e Variáveis Condicionais IPC no UNIX

6 Interrupções de Software Uma notificação para um processo da ocorrência de um evento Sinais podem ser enviados: De um processo para outro processo Do kernel para um processo Sinais

7 Um sinal é um evento assícrono que é enviado para um processo Por assíncrono entende-se que o evento pode ocorrer em qualquer momento Não precise estar relacionado com a execução doo processo e.x. o usuário digita ctrl-c Definição

8 Name Description Default Action SIGINT Interrupt character typed terminate process SIGQUIT Quit character typed (^\) create core image SIGKILL kill -9 terminate process SIGSEGV Invalid memory reference create core image SIGPIPE Write on pipe but no reader terminate process SIGALRM alarm() clock rings terminate process SIGUSR1 user-defined signal type terminate process SIGUSR2 user-defined signal type terminate process Veja man 7 signal Tipos de Sinais(31 no POSIX)

9 Comando shell SIGKILL Driver de terminal SIGINT SIGHUP Gerenciamento de memória SIGQUIT SIGPIPE kernel Gerenciador de janelas SIGWINCH Processo SIGALRM SIGUSR1 Fonte de Sinais Outros processos do usuário

10 Usando o comando UNIX: $ kill -KILL 4481 envia o sinal SIGKILL ao processo com pid 4481 verifique se o processo morreu ps l kill não é um bom nome; send_signal seria melhor. Gerando um Sinal

11 Envia um sinal para um processo (ou a um grupo de processos). #include <signal.h> int kill( pid_t pid, int signo ); Retorna 0 se ok, -1 no caso de erro. kill()

12 pid Significado > 0 envia sinal para o processo com pid pid == 0 envia um sinal para todos os processos cujos pids de grupo sejam iguais ao pid de grupo do processo origem. P.ex., processo pai mata todos os processos filho. Alguns Valores para o pid

13 Um processo pode: Ignorar/descatar o sinal(impossível com SIGKILL ou SIGSTOP) Executar uma rotina de tratamento do sinal e depois continuar a execução ou terminar. Realizar uma ação default para o sinal A escolha é chamada pré-disposição do processo ao sinal Resposta a um Sinal

14 Especifica uma função de tratamento para lidar com um tipo de sinal. #include <signal.h> typedef void Sigfunc(int); /* my defn */ Sigfunc *signal( int signo, Sigfunc *handler ); signal returns a pointer to a function that returns an int (i.e. it returns a pointer to Sigfunc) Retorna a pré-disposição anterior ao sinal ou SIG_ERR, no caso de erro. signal()

15 O protótipo da função signal retornado pelo man é uma extensão do tipo Sigfunc: void (*signal(int signo, void(*handler)(int)))(int); No Linux: typedef void (*sighandler_t)(int); sig_handler_t signal(int signo, sighandler_t handler); Signal retorna um ponteiro para uma função que retorna um int Protótipo

16 A função sinal retorna um pointer para uma função. O tipo de retorno é o mesmo da função que é passada como entrada i.e., uma função que recebe um int e retorna um void Use the signal handling library: signal.h Then can use the signal call: #include <signal.h> O sinal, sig, pode ser tratado ou ignorado void (*signal( int sig, void (*handler)(int))) (int) ; signal returns a pointer to the PREVIOUS signal handler #include <signal.h> typedef void Sigfunc(int); /* my defn */ Sigfunc *signal( int signo, Sigfunc *handler ); Signal é uma função com 2 argumentos: sig e handler Usando Signal A função handler Recebe um int e retorna void Esta função é chamda quando o sinal é recebido A função retornada recebe um int

17 int main() { signal( SIGINT, foo ); : /* do usual things until SIGINT */ return 0; } void foo( int signo ) { : /* deal with SIGINT signal */ return; /* return to program */ } Exemplo

18 #include <stdio.h> #include <unistd.h> #include <signal.h> void sig_usr( int signo ); /* handles two signals */ int main() { int i = 0; if( signal( SIGUSR1,sig_usr ) == SIG_ERR ) printf( Cannot catch SIGUSR1\n ); if( signal( SIGUSR2,sig_usr ) == SIG_ERR ) printf( Cannot catch SIGUSR2\n ); : sig_examp.c

19 } : while(1) { printf( %2d\n, I ); pause(); /* pause until signal handler * has processed signal */ i++; } return 0;

20 void sig_usr( int signo ) /* argument is signal number */ { if( signo == SIGUSR1 ) printf( Received SIGUSR1\n ); else if( signo == SIGUSR2 ) printf( Received SIGUSR2\n ); else printf( Error: received signal %d\n, signo); } return;

21 $ sig_examp & [1] $ kill -USR Received SIGUSR1 1 $ kill -USR Received SIGUSR2 2 $ kill 4720 /* send SIGTERM */ [1] + Terminated sig_examp & $ Resultado

22 Valor SIG_IGN SIG_DFL SIG_ERR Significado Ignorar / discartar o sinal Use ação default Retornado por signal() no caso de erro Valores Especiais

23 Um pipe provê um fluxo unidirecional de dados - exemplo: who sort lpr Pipe é uma estrutura de dados circular do Kernel Somente um processo pode acessar um pipe de cada vez Um pipe é criado pela system call int pipe(int* filedes); Dois descritores de arquivos são retornados - filedes[0], aberto para leitura - filedes[1], aberto para escrita - Processos que compartilham um pipe devem ter um parente em comum - Fifos têm um nome associado, permitindo a comunicação entre processos não relacionados Pipes e Fifos

24 processo do usuário writefd readfd pipe fluxo de dados kernel Pipes

25 Dois tipos de sockets no UNIX: Internet - dois processos em máquinas diferentes UNIX dois processos na mesma máquina Pipes são implementados utilizando-se sockets UNIX Implementação de Pipes no Unix

26 main() { int pipefd[2], n; char buff[100]; if (pipe(pipefd) < 0) { error ("pipe error"); } printf ("readfd = %d, writefd = %d\n", pipefd[0], pipefd[1]); if (write(pipefd[1], "hello world\n", 12)!= 12) { error ("write error"); } if ((n=read(pipefd[0], buff, sizeof[buff])) < 0) { error ("read error"); } write (1, buff, n); close(pipefd[0]); close(pipefd[1]); exit (0); } Exemplo 1

27 O tamanho de um pipe é definido, isto é, somente uma quantidade definida de bytes pode permanecer no pipe sem ser lida Se uma escrita é feita em um pipe e existe espaço suficiente, a chamada retorna imediatamente Se uma escrita é feita e não existe espaço suficiente, a execução do processo é suspensa até que um outro processo leia dados do pipe e libere o espaço necessário Tamanho típico de 512 bytes (Mínimo definido pelo POSIX) Tamanho dos Pipes

28 int count=0; main() { char c= x ; if (pipe(p) < 0) error( pipe call ); signal(sigalrm,alarm_action); for(;;) { alarm(20); write(p[1],&c,1); alarm(0); if((++count%1024)==0) printf( %d chars in pipe\n, count ); } } alarm_action() { printf( write blocked after %d chars \n, count); exit(0) } Tamanho dos Pipes - Exemplo

29 O processo cria um pipe e depois utiliza fork para criar uma cópia processo pai writefd readfd fork processo filho writefd readfd pipe fluxo de dados kernel Criação de Pipes

30 Pai escreve, filho lê pai fecha o lado de leitura filho fecha o lado de escrita processo pai writefd fork processo filho readfd pipe fluxo de dados kernel Criação de Pipes

31 who sort lpr who escreve no pipe 1 sort lê do pipe 1 e escreve no pipe 2 lpr lê do pipe 2 processo who writefd processo sort readfd writefd processo lpr readfd pipe1 fluxo de dados Uso de Pipes kernel pipe2 fluxo de dados

32 pai envia nome de arquivo para filho (pipe 1) que lê o arquivo e devolve o conteúdo para o pai (pipe 2). processo pai readfd writefd processo filho fork readfd writefd pipe1 fluxo de dados pipe2 fluxo de dados kernel Uso de Pipes

33 pai cria pipe 1 e pipe 2 fork pai fecha lado de leitura do pipe 1 pai fecha lado de escrita do pipe 2 filho fecha lado de escrita do pipe 1 filho fecha lado de leitura do pipe 2 processo pai readfd writefd processo filho fork readfd writefd pipe1 fluxo de dados pipe2 fluxo de dados kernel Uso de Pipes - Bidirecional

34 #include <sys/types.h> #include <unistd.h> #include <stdio.h> #include <stdlib.h> int main(){ pid_t pid; int rv; int commpipe[2]; /* This holds the fd for the input & output of the pipe */ /* Setup communication pipeline first */ if(pipe(commpipe)){ fprintf(stderr,"pipe error!\n"); exit(1); } /* Attempt to fork and check for errors */ if( (pid=fork()) == -1){ fprintf(stderr,"fork error. Exiting.\n"); /* something went wrong */ exit(1); } Exemplo

35 if(pid){ /* A positive (non-negative) PID indicates the parent process */ dup2(commpipe[1],1); /* Replace stdout with out side of the pipe */ close(commpipe[0]); /* Close unused side of pipe (in side) */ setvbuf(stdout,(char*)null,_ionbf,0); /* Set non-buffered output on stdout */ sleep(2); printf("hello\n"); sleep(2); printf("goodbye\n"); sleep(2); printf("exit\n"); wait(&rv); /* Wait for child process to end */ fprintf(stderr,"child exited with a %d value\n",rv); } else{ /* A zero PID indicates that this is the child process */ dup2(commpipe[0],0); /* Replace stdin with the in side of the pipe */ close(commpipe[1]); /* Close unused side of pipe (out side) */ /* Replace the child fork with a new process */ if(execl("child","child",null) == -1){ fprintf(stderr,"execl Error!"); exit(1); } } Exemplo... return 0; }

36 #include <stdio.h> int main(){ char string[100]; printf("child Process\n"); printf(" \n"); do{ printf("enter Command: "); fflush(stdout); /* Must flush to see command prompt */ fgets(string,100,stdin); printf("%s\n",string); /* No flush necessary because new line flushes */ }while(!strstr(string,"exit")); return 0; } Exemplo...

37 Processos podem ler e escrever em listas de mensagens (tal como mailboxes) System calls: int msgget (key_t key, int flag) : Cria ou permite acesso à uma fila de mensagens, retorna o identificador da fila int msgsnd (int msqid, const void *msgp, size_t msgsz, int flag) : Escreve uma mensagem na fila int msgrcv (int msqid, void *msgp, size_t msgsz, long msgtype, int msgflg) : Recebe uma mensagem e a armazena em msgp. msgtype: As mensagens podem ter tipo e cada tipo define um canal de comunicação int msgctl (int msqid, int cmd, struct msqid_ds *buf) : Provê operações de controle na fila de mensagens (e.x. remoção) O processo é bloqueado se: tenta ler de uma fila vazia tenta escrever em uma fila cheia Mensagens

38 /* Send and receive messages within a process */ #include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h> #definebuffsize 128 #defineperms 0666 #define KEY ((key_t) 7777) main() { int i, msqid; struct { long m_type; char m_text[buffsize]; } msgbuffs, msgbuffr; if ( (msqid = msgget(key, PERMS IPC_CREAT)) < 0) perror("msgget error"); msgbuffs.m_type = 1L; strcpy(msgbuffs.m_text,"a REALLY boring message"); Mensagens - Exemplo

39 if (msgsnd(msqid, &msgbuffs, BUFFSIZE, 0) < 0) perror("msgsnd error"); printf("the message sent is: %s \n", msgbuffs.m_text); if (msgrcv(msqid, &msgbuffr, BUFFSIZE, 0L, 0)!= BUFFSIZE) perror("msgrcv error"); printf("the message received is: %s \n", msgbuffr.m_text); // remove msg if (msgctl(msqid, IPC_RMID, (struct msqid_ds *) 0) < 0) perror("ipc_rmid error"); } exit(0); Mensagens - Exemplo

40 saída: the message sent is: a REALLY boring message the message received is: a REALLY boring message Mensagens - Exemplo

41 Um semáforo é um contador inteiro positivo normalmente usado para coordenar o acesso a recursos compatilhados System calls: int sema_init (sema_t *sp, unsigned int count, int type, void * arg): Inicia o semáforo apontado por sp em count. type pode ser utilizado para atribuir diferentes tipos de comportamento ao semáforo int sema_destroy (sema_t *sp); destrói qualquer estado relacionado ao semáforo apontado por sp. O espaço de memória alocado ao semáforo não é automaticamente liberado. int sema_wait (sema_t *sp): bloqueia o thread até que o contador do semáforo apontado por sp seja maior que zero, e neste caso, decrementa o contador. Semáforos

42 int sema_trywait (sema_t *sp): decrementa atomicamente o contador do semáforo apontado por sp, se o contador é maior que zero. Caso contrário, retorna um erro int sema_post (sema_t *sp); incrementa atomicamente o o contador do semáforo apontado por sp. Se existirem threads bloqueados pelo semáforo, um será desbloqueado. Semáforos

43 #include <errno.h> #define TELLERS 10 sema_t tellers; /* semaphore */ int banking_hours(), deposit_withdrawal; void *customer(), do_business(), skip_banking_today();... sema_init(&tellers, TELLERS, USYNC_THREAD, NULL); /* 10 tellers available */ while(banking_hours()) pthread_create(null, NULL, customer, deposit_withdrawal);... void * customer(int deposit_withdrawal) { int this_customer, in_a_hurry = 50; this_customer = rand() % 100; Semáforos - Exemplo

44 if (this_customer == in_a_hurry) { if (sema_trywait(&tellers)!= 0) if (errno == EAGAIN) { /* no teller available */ { skip_banking_today(this_customer); return; } /* else go immediately to available teller and decrement tellers */... else { /* wait for next teller, then proceed, and decrement tellers */ sema_wait(&tellers); do_business(deposit_withdrawal); /* increment tellers; this_customer's teller is now available */ sema_post(&tellers); } Semáforos - Exemplo

45 Processos podem compartilhar o mesmo segmento de memória quando ele é mapeado no espaço de endereçamento dos dois processos Comunicação mais rápida System calls: int shmget (key_t key, size_t size, int shmflg) : cria uma nova região de memória compartilhada ou retorna uma existente void *shmat (int shmid, const void *shmaddr, int shmflg) : agrupa uma região de memória compartilhada ao espaço de endereçamento do processo int shmdt (char *shmaddr): desagrupa uma região de memória compartilhada As regiões de memória compartilhada devem ser acessadas por um processo de cada vez (exclusão mútua) Memória Compartilhada

46 // IPC communication between a child and a parent process using // shared memory : the parent puts messages into the shared memory // the child reads the shared memory and prints the messages #include <stdio.h> #include <string.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h> #define SHMSIZE 15 #define MESGNUM 2 // maximum number of bytes in a message //number of messages void cleanup (int shm_id, char *addr); // cleanup procedure int shm_id; // ID of shared memory int main (int argc, char *argv[]) { char message [SHMSIZE]; // the message to send/receive int i; int number_of_messages; // number to be sent int nbytes; // number of bytes in a message Memória Compartilhada - Exemplo

47 int number_of_messages; // number to be sent int nbytes; // number of bytes in a message int status; char *addr = (char *) malloc (SHMSIZE * sizeof (char)); number_of_messages = MESGNUM; nbytes = SHMSIZE; // set up shared memory segment using PID as the key if ((shm_id = shmget ((key_t) getpid(), SHMSIZE, 0666 IPC_CREAT)) == -1 ) { printf ("Error in shared memory region setup.\n"); exit (2); } // if shared memory get failed // attach the shared memory segment addr = (char *) shmat (shm_id, (char *) 0, 0); Memória Compartilhada - Exemplo

48 if (fork ()) { // true if in parent process // create message of required length for (i=0; i < nbytes; i++) message [i] = i % 26 + 'a'; message [nbytes] = '\0'; // send message using the shared memory segment for (i = 0; i < number_of_messages; i++) { if (memcpy (addr, message, nbytes+1) == NULL) { puts ("Error in memory copy"); cleanup (shm_id, addr); exit (3); } // end if error in memory copy } // end for as many messages as requested wait (&status); // wait for child to return // get the message sent by the child strcpy (message, addr); printf ("Parent - message from child: \n %s\n", message); Memória Compartilhada - Exemplo

49 strcpy (message, addr); printf ("Parent - message from child: \n %s\n", message); cleanup (shm_id, addr); exit(0); } // end parent process // in child process puts ("Child - messages from parent:"); for (i = 0; i < number_of_messages; i++) { if (memcpy (message, addr, nbytes+1) == NULL) { puts ("Error in memcpy"); cleanup (shm_id, addr); exit (5); } // end if error in shared memory get else puts (message); } // end for each message sent strcpy (addr, "I have received your messages!"); Memória Compartilhada - Exemplo

50 exit (0); } // end main program // remove shared memory segment void cleanup (int shm_id, char *addr) { shmdt (addr); shmctl (shm_id, IPC_RMID, 0); } // end cleanup function Memória Compartilhada - Exemplo

51 Saída: Child - messages from parent: abcdefghijklmno abcdefghijklmno Parent - message from child: I have received your messages! Memória Compartilhada - Exemplo

52 Sockets são uma forma de IPC ( InterProcess Communication ) definida no 4.3 BSD que fornecem comunicação entre processos residentes em sistema único ou processos residentes em sistemas remotos. Sockets criados por diferentes programas usam nomes para se referenciarem. Esses nomes geralmente devem ser traduzidos em endereços. Sockets - Conceitos Básicos

53 STREAM SOCKET - Provê sequenciamento e fluxo bidirecional. No domínio UNIX, o SOCKET_STREAM trabalha igual a um pipe, no domínio INTERNET este tipo de socket é implementado sobre TCP/IP. Tipos de Sockets

54 SOCK_DGRAM - Suporta fluxo de dados bidirecional mas não oferece um serviço confiável como STREAM_SOCKET. Mensagens duplicadas e em ordem diferente são problemas que podem aparecer neste tipo de socket. Tipos de Sockets

55 RAW_SOCKET - permite o acesso a interface de protocolos de rede. Disponível para usuários avançados e que possuam autoridade de usuário root permite que uma aplicação acesse diretamente protocolos de comunicação de baixo nível permite a construção de novos protocolos sobre os protocolos de baixo nível já existentes Tipos de Sockets

56 O socket é criado sem nome É necessário um nome para para a sua utilização Os processos são ligados por uma associação Associação: <protocolo, end. máquina local, porta local, end. máquina remota, porta remota> Associação

57 O espaço no qual o endereço é especificado é chamado de domínio Domínios básicos: INTERNET - AF_INET - os endereços consistem do end. de rede da máquina e da identificação do no. da porta, o que permite a comunicação entre processos de sistemas diferentes Unix: AF_UNIX - os processos se comunicam referenciando um pathname, dentro do espaço de nomes do sistema de arquivos Domínios e Protocolos

58 Domínio Internet Implementação Unix do protocolo TCP/UDP/IP Consiste de: end. de rede da máquina identificação do no. da porta Permite a comunicação entre máquinas diferentes Conexões sob a forma de sockets do tipo stream e do tipo datagramas Domínios e Protocolos

59 Processo A Processo B TCP UDP IP Protocolos TCP/IP Interface hardware

60 Definida por: Um protocolo: TCP ou UDP Endereço IP local Porta local Endereço IP remoto Porta distante Associação

61 Servidor Cliente 1 socket socket kernel kernel conexão Comunicação por sockets rede

62 Cria um socket com - Família (ou domínio): UNIX, Internet, XNS - Tipo: stream, datagrama, raw - Protocolo: TCP, UDP Servidor socket ( ) sockfd = (int) socket (int family, int type, int protocol) Comunicação TCP

63 Servidor socket ( ) Atribui ao socket - Endereço Internet (pode ser any ) - Porta de comunicação bind ( ) ret = (int) bind (int sockfd, struct sockaddr *myaddr, int addrlen) Comunicação TCP

64 Servidor socket ( ) Declara - Que está pronto para receber conexões - Até quantas devem ser enfileiradas bind ( ) listen ( ) ret = (int) listen (int sockfd, int backlog) Comunicação TCP

65 Servidor socket ( ) bind ( ) listen ( ) Bloqueia até que haja pedido de conexão Quando houver algum, aceita accept ( ) newsock = (int) accept (int sockfd, struct sockaddr *peer, int *addrlen) Comunicação TCP

66 Servidor socket ( ) Cria um socket idêntico ao do servidor (mesma família e tipo) bind ( ) listen ( ) Cliente socket ( ) accept ( ) sockfd = (int) socket (int family, int type, int protocol) Comunicação TCP

67 Servidor socket ( ) bind ( ) listen ( ) Pede uma conexão ao servidor Fica bloqueado ou retorna erro Se aceito, fecha a conexão Cliente socket ( ) accept ( ) estabelecimento de conexão connect ( ) ret = (int) connect (int sockfd, struct sockaddr *servaddr, int addrlen) Comunicação TCP

68 Servidor socket ( ) Envia uma seqüência de bytes pela conexão bind ( ) listen ( ) Cliente socket ( ) accept ( ) estabelecimento de conexão connect ( ) send ( ) nbytes = (int) send (int sockfd, char *buf, int nbytes, int flags) Comunicação TCP

69 Servidor socket ( ) Recebe (parte da ) msg enviada por send ( ) bind ( ) listen ( ) Cliente socket ( ) accept ( ) estabelecimento de conexão connect ( ) recv ( ) solicitação send ( ) nbytes = (int) recv (int sockfd, char *buf, int nbytes, int flags) Comunicação TCP

70 Servidor socket ( ) bind ( ) listen ( ) Transmite ou confirma msgs faltantes Encerra a conexão Fecha o socket ret = (int) close (int sockfd) Cliente socket ( ) accept ( ) estabelecimento de conexão connect ( ) recv ( ) send ( ) processamento solicitação resposta send ( ) recv ( ) close ( ) close ( ) Comunicação TCP

71 Servidor socket ( ) bind ( ) Diagrama completo listen ( ) Cliente socket ( ) accept ( ) estabelecimento de conexão connect ( ) recv ( ) send ( ) processamento solicitação resposta send ( ) recv ( ) close ( ) close ( ) Comunicação TCP

72 Cliente e servidor criam seus sockets Família = Internet, tipo = datagrama Servidor Cliente socket ( ) socket ( ) Comunicação UDP

73 Cliente e servidor definem endereços Servidor socket ( ) Cliente socket ( ) bind ( ) bind ( ) Comunicação UDP

74 Recebe pacote enviado do endereço informado Se não houver nada, bloqueia Servidor socket ( ) Cliente socket ( ) bind ( ) bind ( ) recvfrom ( ) nbytes = (int) recvfrom (int sockfd, char *buf, int nbytes, int flags, struct sockaddr *from, int *addrlen) Comunicação UDP

75 Envia pacote para o endereço informado Servidor socket ( ) socket ( ) bind ( ) bind ( ) recvfrom ( ) solicitação sendto ( ) nbytes = (int) recvfrom (int sockfd, char *buf, int nbytes, int flags, struct sockaddr *from, int *addrlen) Comunicação UDP

76 Diagrama completo Servidor socket ( ) Cliente socket ( ) bind ( ) bind ( ) recvfrom ( ) sendto ( ) processamento solicitação resposta sendto ( ) recvfrom ( ) close ( ) close ( ) Comunicação UDP

77 A chamada de procedimentos remotos utiliza a mesma semântica da chamada de procedimentos locais para fazer a comunicação de processos localizados em máquinas diferentes em um sistema distribuído RPC Remote Procedure Call

78 xdr.x (Escrever) rpcgen (Compilador Protocolo) client.c (Escrever) *_clnt.c (Stub Cliente) xdr.h (header comum) *_svc.c (Stub Servidor) impl_proc.c (Escrever) client executable server executable O Processo

79 Cliente (Escrever) Servidor (Escrever) *_clnt.c Stub Cliente (rpcgen) *_svc.c Stub Servidor (rpcgen) Rede Rede Sequência de Chamada

80 Chamada de Procedimentos Remotos SUN Protocolo UDP é usado para iniciar um procedimento remoto A comunicação é baseada em mensagens Quando um servidor inicia, ele registra a porta na qual ele receberá conexões associada com um número PROGRAM e um número VERSION no servidor portmapper (daemon que atende a porta 111) Quando um cliente incia, ele contata o portmapper para saber como encontrar o procedimento remoto identificado PROGRAM eversion. O portmapper retorna o endereço e o cliente acessa o servidor diretamente. RPC Sun

81 Este arquivo XDR (somefile.x): program NUMPROG { version NUMVERS { int READNUM(int) = 1; /* version 1 */ } = 1; /* version of functions */ } = 0x ; /* PROGRAM number */ É tranformado neste arquivo pelo rpcgen (somefile.h): #define NUMPROG 0x #define NUMVERS 1 #if defined( STDC ) defined( cplusplus) #define READNUM 1 extern int * readnum_1(int *, CLIENT *); extern int * readnum_1_svc(int *, struct svc_req *); Arquivo de definição de protocolo(.x)

82 O RPC é importante porque ele gerencia diversos aspectos da comunicação Rede Ordem dos Bytes (Big Endian, Little Endian) Alinhamento dos dados na memória Alinhamento em 2/4 Bytes Terminadores e códigos alfanuméricos utilizaos em strings Detalhes do RPC

83 XDR Provê Transparência em relação à rede Big-Endian Alinhamento de 4-Bytes XDR comunica os dados na rede como um fluxo de bytes Filtros RPC external Data Representation

84 Integer: int (4 bytes) Unsigned Integer: unsigned int (4 bytes) Char: int (4 byte signed integer) Double: double (8 bytes IEEE754 FP) Float: float (4 bytes IEEE754 FP) int week[7] int orders <50> (variable length array) opaque data<1000> any data Filtros XDR