03 - Protocolos de Comunicação Interprocessos. 2 de novembro de 2014

Transcrição

1 03 - Protocolos de Comunicação Interprocessos 2 de novembro de 2014

2 2/46 Conteúdo Revisão sobre arquivos e criação de processos Pipes Filas de mensagens Memória compartilhada Unix Domain Sockets

3 3/46 Protocolos de Comunicação Interprocessos Pipes cat /etc/passwd grep false Filas de mensagens msgget(), msgrcv(), msgctl() Memória compartilhada POSIX Shared Memory: shm open(), mmap Unix Domain Sockets

4 4/46 Revisão sobre leitura e escrita de arquivos Padrões POSIX (Portable Operating System Interface - IEEE) Descritores de arquivos são números inteiros ls -l /proc/*/fd FILE*, fopen(), fclose(), fwrite() open(), create(), write() 0 = stdin, 1 = stdout, 2 = stderr Permissões 1 main ( ) { 2 c h a r buf [ 3 ] ; 3 r e a d ( 0, buf, 3 ) ; 4 w r i t e ( 1, buf, 3 ) ; 5 w r i t e ( 2, buf, 3 ) ; 6 }

5 5/46 Comunicação Inter Processos Unix Unix Inter Process Communication (IPC) Comunicação entre processos no mesmo computador Para uso em conjunto com fork() e similares

6 6/46 Criação de processos via fork Objetivo: criação de um processo-filho para auxiliar em tarefas paralelas Função: pid t fork(void); sys/types.h e unistd.h Se foi bem sucedido, pid t do filho é retornado para o pai ou, se erro, 1 Processo-filho será cópia duplicada do pai, com exceções de travas de arquivos e sinais No processo-filho, o valor de retorno será 0 (zero) wait() espera por 1 filho retornar (qualquer um) waitpid() espera por filho PID retornar 1 main ( ) { 2 s i g n a l (SIGCHLD, SIG IGN ) ; / now I don t have to w a i t ( )! / f o r k ( ) ; f o r k ( ) ; f o r k ( ) ; / Rabbits, r a b b i t s, r a b b i t s! /

7 1 #i n c l u d e... 2 main ( ) { 3 i n t s t a t u s ; p i d t p i d ; 4 p r i n t f ( Meu p i d é %d, do meu p a i é %d\n, g e t p i d ( ), g e t p p i d ( ) ) ; 5 6 s w i t c h ( p i d=f o r k ( ) ) { 7 c a s e 1: e x i t ( EXIT FAILURE ) ; 8 c a s e 0 : 9 p r i n t f ( Meu p i d é %d, do meu p a i é %d\n, g e t p i d ( ), g e t p p i d ( ) ) ; 10 e x i t ( EXIT SUCCESS ) ; d e f a u l t : 13 p r i n t f ( Meu p i d é %d, do meu p a i é %d\n, g e t p i d ( ), g e t p p i d ( ) ) ; 14 w a i t (& s t a t u s ) ; 15 i f (WIFEXITED( s t a t u s ) ) { 16 p r i n t f ( f i l h o bem\n ) ; e x i t ( EXIT SUCCESS ) ; 17 } e l s e { 18 p r i n t f ( f i l h o não bem\n ) ; e x i t ( EXIT FAILURE ) ; 19 } 20 } 21 } 7/46

8 8/46 Comunicação por sinais Comunica sinais ativam funções manipuladores de sinais de processos SIGSTOP pedido para parar um momento a execução SIGCONT pedido para continuar execução SIGTERM pedido para terminar execução voluntariamente SIGKILL ordem para terminar execução de um vez por todas SIGSEGV ordem para terminar devido acesso indevido a uma região de memória SIGUSR1 e SIGUSR2 configuráveis Função para lança sinal é kill() Não comunica dados Necessário Definir struct sigaction Definir função manipuladora no sigaction Cadastrar sigaction com função sigaction()

9 1 #i n c l u d e <s i g n a l. h> e o u t r o s // nomes do s i n a i s 2 v o l a t i l e s i g a t o m i c t r e c e b e u S i n a l ; 3 v o i d funcao manip ( i n t s i n a l ) { 4 r e c e b e u S i n a l = 1 ; 5 w r i t e ( 0, Um SIGINT!! nãaa.. \ n, 1 9 ) ; // async s a f e 6 } 7 main ( ) { 8 i n t s i n a l = SIGINT ; c h a r e n t r a d a [ ] ; 9 v o i d funcao manip ( i n t s i n a l ) ; // somente p r o t o t i p o 10 s t r u c t s i g a c t i o n acao ; r e c e b e u S i n a l = 0 ; acao. s a h a n d l e r = funcao manip ; // f. m a nipuladora 13 s i g e m p t y s e t (&acao. sa mask ) ; // c o n j. de s i n a i s para b l o q u e a r d u r a n t e e s t a acao 14 acao. s a f l a g s = SA RESTART ; // f l a g s p/ mudar f u n c. manip., ex. r e i n i c i a da onde parou s i g a c t i o n ( s i n a l, &acao, NULL) ; 17 p r i n t f ( (%d ) (%d ) E s c r e v a a l g o : \ n, g e t p i d ( ), r e c e b e u S i n a l ) ; 18 f g e t s ( entrada, s i z e o f entrada, s t d i n ) ; 19 p r i n t f ( (%d ) Você e s c r e v e u i s s o? %s \n, r e c e b e u S i n a l, e n t r a d a ) ; 20 } 9/46

10 10/46 Conceitos sobre pipes Pipe é um tipo de comunicação interprocessos Unnamed pipe ou anônimo é quando a comunicação existe sem criação expĺıcita do pipe Exemplo: cat /etc/hosts grep 127 Named pipe ou pipe nomeado é quando cria-se explicitamente o pipe Funcionamento similar a um arquivo Um named pipe precisa ser descartado explicitamente Criação: mkfifo <nome do pipe> Descarte: rm <nome do pipe> fildes[1] Pipe fildes[0] write() read()

11 1 main ( ) { 2 i n t f i l d e s [ 2 ], i n t BSIZE = ; c h a r buf [ BSIZE ] ; 3 p i p e ( f i l d e s ) ; // c r i a ç ã o dos d e s c r i t o r e s 4 5 s w i t c h ( f o r k ( ) ) { 6 c a s e 1: e x i t ( 1) ; // e r r o 7 c a s e 0 : / F i l h o r e c e b e do p i p e / 8 r e a d ( f i l d e s [ 0 ], buf, BSIZE ) ; / r e c e b e dados / 9 p r i n t f ( buf=\ %s \ \ nfim, buf ) ; 10 e x i t ( EXIT SUCCESS ) ; 11 d e f a u l t : / Pai e s c r e v e no p i p e / 12 w r i t e ( f i l d e s [ 1 ], H e l l o world, 12) ; / e s c r e v e / 13 c l o s e ( f i l d e s [ 1 ] ) ; / F i l h o r e c e b e EOF / 14 e x i t ( EXIT SUCCESS ) ; 15 } 16 } 11/46 Exemplos de pipes anônimos A função int pipe(int fildes[2]) em unistd.h cria um canal interprocessos fildes são descritores de arquivos: escrita em fildes[1], leitura em fildes[0]

12 12/46 int dup(int fildes); Coloca o descritor fildes no primeiro descritor padrão disponível int execlp(char *file, char *arg,...); Abre novo processo a partir do programa em *file fildes[1] pipe() fildes[0] stdin ls stdout stdin wc -l stdout dup(fildes[1]) pipe() dup(fildes[0]) stdin ls stdout stdin wc -l stdout close(1) close(0)

13 1 i n t main ( v o i d ) { 2 i n t f i l d e s [ 1 ] ; // f i l e d e s c r i p t o r s 3 p i p e ( f i l d e s ) ; 4 5 i f (! f o r k ( ) ) { 6 c l o s e ( 1 ) ; // f e c h a s a i d a padrao 7 dup ( f i l d e s [ 1 ] ) ; // poe na s a i d a d i s p o n i v e l f i l d e s [ 1 ] 8 e x e c l p ( l s, l s, NULL) ; 9 } e l s e { 10 c l o s e ( 0 ) ; // f e c h a e n t r a d a padrao 11 dup ( f i l d e s [ 0 ] ) ; // poe f i l d e s [ 0 ] na e n t r a d a padrao 12 e x e c l p ( wc, wc, l, NULL) ; 13 } 14 r e t u r n 0 ; 15 } 13/46

14 14/46 Pipes nomeados int mkfifo(char *pathname, mode t mode); em sys/stat.h Um escritor pode escrever de uma só vez no pipe até PIPE BUF bytes Escritor vai esperar (bloqueado) até alguém ler Tamanho do buffer: PIPE BUF em /usr/include/linux/limits.h (4096 bytes) Se leitor está esperando por dados e escritor fecha o pipe, leitor recebe EOF Se escritor encerra uso do pipe, dados escritos e não lidos são perdidos se não houver um leitor Principal vantagem em relação a pipes anônimos é a possibilidade de processos não relacionados fazerem comunicação interprocessos

15 15/46 Exemplos de pipes nomeados publib.boulder.ibm.com/infocenter/zvm/v6r1/index.jsp?topic=/com.ibm.zvm.v610.edclv/rtmkf.htm 1 #i n c l u d e <s y s / s t a t. h> 2 #i n c l u d e < f c n t l. h> 3 #i n c l u d e <u n i s t d. h> 4 5 main ( ) { 6 c h a r np []= temp. f i f o ; 7 c h a r out [20]= FIFO s a r e fun!, i n [ 2 0 ] ; 8 i n t r f d, wfd ; // d e s c r i t o r e s de a r q u i v o s 9 10 m k f i f o ( np, S IFIFO S IRWXU) ; // p e r m i s s o e s RWX p/ u s e r 11 r f d = open ( np, O RDONLY O NONBLOCK) ; 12 wfd = open ( np, O WRONLY) ; w r i t e ( wfd, out, s t r l e n ( out ) +1) ; 15 r e a d ( r f d, in, s i z e o f ( i n ) ) ; 16 p r i n t f ( r e a d % s from the FIFO\n, i n ) ; u n l i n k ( f n ) ; 19 }

16 1 //#i n c l u d e i n t main ( v o i d ) { // speak. c w r i t e s i n t o a FIFO 4 c h a r s [ ] ; 5 i n t num, f d ; 6 7 mknod ( named. p i p e, S IFIFO 0666, 0) ; 8 9 p r i n t f ( e s p e r a n d o por l e i t o r e s... \ n ) ; 10 f d = open (FIFO NAME, O WRONLY) ; 11 p r i n t f ( a c h e i um l e i t o r e s c r e v a a l g o \n ) ; w h i l e ( g e t s ( s ),! f e o f ( s t d i n ) ) { 14 i f ( ( num = w r i t e ( fd, s, s t r l e n ( s ) ) ) == 1) 15 p e r r o r ( w r i t e ) ; 16 e l s e 17 p r i n t f ( speak : e s c r e v e u %d b y t e s \n, num) ; 18 } r e t u r n 0 ; 21 } 16/46

17 1 #i n c l u d e... 2 #d e f i n e FIFO NAME named. p i p 3 i n t main ( v o i d ) {// t i c k. c r e a d s data from a FIFO 4 c h a r s [ ] ; 5 i n t num, f d ; 6 7 mknod ( FIFO NAME, S IFIFO 0666, 0) ; 8 9 p r i n t f ( e s p e r a por e s c r i t o r e s... \ n ) ; 10 f d = open (FIFO NAME, O RDONLY) ; 11 p r i n t f ( achou um e s c r i t o r \n ) ; do { 14 i f ( ( num = r e a d ( fd, s, 300) ) == 1) 15 p e r r o r ( r e a d ) ; 16 e l s e { 17 s [ num ] = \0 ; 18 p r i n t f ( t i c k : l e u %d b y t e s : \ %s \ \n, num, s ) ; 19 } 20 } w h i l e (num > 0) ; r e t u r n 0 ; 23 } 17/46

18 18/46 Exemplos de pipes em terminais No terminal 1 m k f i f o n p i p e 2 c a t / e t c / > n p i p e 3 c a t n p i p e

19 19/46 Conceitos sobre filas de mensagens (message queues) X/Open Systems Interfaces (XSI) da ISO Sistema tem um serviço preparado para receber mensagens Uma aplicação registra uma função para receber mensagens em uma dada fila Outras aplicações inserem mensagens na fila O sistema guarda mensagens até alguma aplicação receber

20 20/46 Conceitos sobre filas de mensagens (message queues) Similar a uma FIFO com funcionalidades extras Permite remover mensagens em ordem arbitrária Processos podem criar nova fila de mensagem ou usar uma existente Uma fila de mensagem existe mesmo sem processos usando Implementado como array de listas ligadas

21 21/46 Filas de mensagens Filas de mensagens POSIX #include <sys/msg.h> Receber número descritor de uma fila int msgget(key t key, int msgflg); Receber uma mensagem da fila msqid size t msgrcv(int msqid, void *msgp, size t msgsz, long msgtyp, int msgflg); Enviar uma mensagem na fila msqid int msgsnd(int msqid, void *msgp, size t msgsz, int msgflg); Modificar fila (mudar o dono, remover IPC RMID) int msgctl(int msqid, int cmd, struct msqid ds *buf);

22 22/46 Funções: criação de uma fila Obter ou criar (IPC CREAT) descritor de fila int msgget(key t key, int msgflg); msgget() retorna o ID da fila ou -1 se erro key t key é uma chave que processos precisam conhecer para usar a fila #include <sys/ipc.h> key t ftok(const char *pathname, int proj id); Exemplo: a chave é obtida com ftok("/algum/arquivo", 52) int msgflg representa o que deseja-se fazer com a fila Para criar (IPC CREAT) descritor de fila Passar com ou bit-a-bit as permissões (de arquivo) desejadas Exemplo: msqid = msgget(key, S IRWXU IPC CREAT);

23 23/46 Funções: envio de mensagens Uma mensagem deve ser enviada em uma estrutura similar a struct msgbuf (sys/msg.h) 1 s t r u c t msgbuf { 2 l o n g mtype ; // numero p o s i t i v o para r e c u p e r a r mensagem 3 c h a r mtext [ 1 ] ; // conteudo a s e r e n v i a d o 4 } ; Exemplo: 1 s t r u c t p i r a t a m s g b u f { 2 l o n g mtype ; // deve s e r p o s i t i v o! 3 s t r u c t i n f o p i r a t a { 4 c h a r nome [ 3 0 ] ; 5 c h a r t i p o n a v i o ; 6 i n t c r u e l d a d e ; 7 i n t n o t o r i e d a d e ; 8 } i n f o ; 9 } ;

24 24/46 Funções: envio de mensagens int msgsnd(int msqid, const void *msgp, size t msgsz, int msgflg); msqid é o id da fila const void *msgp é a struct da mensagem size t msgsz é o tamanho do conteúdo da mensagem int msgflg estabele funcionamento quando filas estiverem cheias Se 0, espera para enviar Se não 0, não envia e retorna erro 1 msgsnd ( msqid, &g o t t f r i d, s i z e m s g, 0) ;

25 25/46 Funções: recebimento de mensagens int msgrcv(int msqid, void *msgp, size t msgsz, long msgtyp, int msgflg); int msqid é o id da fila void *msgp é a estrutura que espera-se receber size t msgsz é o tamanho da estrutura que espera-se receber long msgtyp é o tipo da mensagem definida na estrutura int msgflg muda a forma de recepção zero obter próxima mensagem independentemente do tipo positivo obter próxima mensagem do tipo em msgtyp negativo obter primeira mensagem na fila cujo tipo é menor ou igual a msgtyp 1 msgrcv ( msqid, &p i r a t a a n o n, s i z e m s g, 2, 1) ;

26 1 #i n c l u d e... 2 main ( ) { 3 k e y t key = f t o k ( /tmp/ a r q f i l a, 52) ; 4 s t r u c t p i r a t a m s g b u f g o t t f r i d, p i r a t a a n o n ; 5 i n t c p i d ; 6 i n t msqid = msgget ( key, S IRWXU IPC CREAT ) ; 7 8 g o t t f r i d. mtype = 2 ; 9 s t r c p y ( g o t t f r i d. i n f o. nome, G o t t f r i d ) ; 10 g o t t f r i d. i n f o. c r u e l d a d e = 8 0 ; i n t s i z e=s i z e o f ( s t r u c t p i r a t a m s g b u f ) s i z e o f ( l o n g ) ; s w i t c h ( c p i d = f o r k ( ) ) { 15 c a s e 1: e x i t ( 1) ; 16 c a s e 0 : 17 msgrcv ( msqid, &p i r a t a a n o n, s i z e, 2, 1) ; 18 p r i n t f ( %s a v i s t a! \ n, p i r a t a a n o n. i n f o. nome ) ; 19 d e f a u l t : 20 msgsnd ( msqid, &g o t t f r i d, s i z e, 0) ; 21 w a i t p i d ( c p i d ) ; 22 } 23 } 26/46

27 27/46 Destruição da fila de mensagens No terminal ipcs, ipcrm, ipcmk Exemplo: ipcrm -msg 0 Em código 1 m s g c t l ( msqid, IPC RMID, NULL) ;

28 28/46 Resumo: filas de mensagens Similar a pipes nomeados Usa um pacote (struct) para transmitir dados Mensagens tem tipos e podem facilitar organização Ver exemplos: kirk.c e spock.c

29 29/46 Conceitos sobre memória compartilhada Processos podem compartilhar regiões de memória Ideia é ter variável que podem ser modificadas de maneira global entre processos

30 30/46 Criação da região compartilhada int shmget(key t key, size t size, int shmflg); Retorna identificador para a região compartilhada key t key mesma que para filas de mensagens com ftok() size t size tamanho da região de memória compartilhada int shmflg permissões, IPC CREAT para criar, ou padrão 0 1 key = f t o k ( /tmp/ t m p f i l e, R ) ; 2 shmid = shmget ( key, 1024, 0644 IPC CREAT ) ;

31 31/46 Obtenção de variáveis na região compartilhada void *shmat(int shmid, void *shmaddr, int shmflg); int shmid é o id da memória criada com shmget() void *shmaddr onde quer a variável, em geral 0 para SO escolher int shmflg: SHM RDONLY para indicar que a região vai ser somente leitura ou 0, caso contrário 1 data = shmat ( shmid, ( v o i d ) 0, 0) ; 2 3 i f ( data == ( c h a r ) ( 1) ) 4 p e r r o r ( shmat ) ;

32 32/46 1 #i n c l u d e... 2 main ( ) { 3 k e y t key ; i n t shmid ; c h a r t e x t o ; 4 5 key = f t o k ( /tmp/chavememsh, R ) ; 6 shmid = shmget ( key, 1024, 0644 IPC CREAT ) ; 7 t e x t o = shmat ( shmid, ( v o i d ) 0, 0) ; 8 s t r c p y ( t e x t o, P i r a t a s! ) ; 9 p r i n t f ( t = %s \n, t e x t o ) ; 10 } 1 #i n c l u d e... 2 main ( ) { 3 k e y t key ; i n t shmid ; c h a r t e x t o ; 4 5 key = f t o k ( /tmp/chavememsh, R ) ; 6 shmid = shmget ( key, 1024, 0644 IPC CREAT ) ; 7 t e x t o = shmat ( shmid, ( v o i d ) 0, 0) ; 8 p r i n t f ( t = %s \n, t e x t o ) ; 9 }

33 33/46 Encerrar memória compartilhada Quando um processo não usar mais a memória compartilhada ele deve desligar-se dela ou apagá-la Para se desligar, usar: int shmdt(void *shmaddr); void *shmaddr é o ponteiro da memória compartilhada Para apagar memória compartilhada: shmctl(shmid, IPC RMID, NULL);

34 34/46 Resumo: memória compartilhada Comunicação por compartilhamento de regiões de memória Deve haver sincronização para evitar efeitos inesperados Se nenhum processo explicitamente remover, região vai continuar na memória

35 35/46 Conceitos sobre Unix Domain Sockets Pipes e pipes nomeados funcionam em uma só direção Unix Domain Sockets funcionam nas duas direções Abstração que funciona em muitos meios (domínios), inclusive Internet Modelo cliente-servidor

36 36/46 Modelo cliente-servidor Servidor socket(), bind(), listen(), accept() Cliente socket(), connect() Comunicação send(), recv()

37 37/46 Estrutura para usar Unix sockets 1 s t r u c t s o c k a d d r u n { 2 u n s i g n e d s h o r t s u n f a m i l y ; / AF UNIX / 3 c h a r s u n p a t h [ ] ; 4 }

38 38/46 Criação de um socket 1 u n s i g n e d i n t s, s2 ; 2 s t r u c t s o c k a d d r u n l o c a l, remoto ; 3 4 s = s o c k e t ( AF UNIX, SOCK STREAM, 0) ; 5... #include <sys/socket.h> int socket(int domain, int type, int protocol); socket() retorna o identificador do socket SOCK STREAM indica que socket vai transmitir fluxos de dados

39 39/ s = s o c k e t ( AF UNIX, SOCK STREAM, 0) ; 3 l o c a l. s u n f a m i l y = AF UNIX ; // l o c a l é d e c l a r a d o a n t e s 4 5 s t r c p y ( l o c a l. sun path, /tmp/ mysocket ) ; 6 u n l i n k ( l o c a l. s u n p a t h ) ; // remove a n t e s de l i g a r 7 8 l e n = s t r l e n ( l o c a l. s u n p a t h ) +s i z e o f ( l o c a l. s u n f a m i l y ) ; 9 b i n d ( s, ( s t r u c t s o c k a d d r )&l o c a l, l e n ) ; Com socket criado, é necessário ligá-lo bind() liga o socket s com o endereço local Usa unlink() para não ter erro EINVAL len é necessário para indicar o tamanho da estrutura de endereço

40 40/46 Após ligar o endereço local com o socket s é necessário iniciar o processo de esperar por conexões 1 l i s t e n ( s, 5) ; int listen(int socket, int backlog); listen() faz o socket começar a aceitar conexões int backlog é o número de conexões que o socket vai aceitar Clientes em excesso receberão erro ECONNREFUSED

41 41/46 Aceitar conexão de cliente 1 l e n = s i z e o f ( s t r u c t s o c k a d d r u n ) ; 2 s2 = a c c e p t ( s, ( s t r u c t s o c k a d d r )&remoto, &l e n ) ; int accept(int socket, struct sockaddr *restrict address, socklen t *restrict address len); Faz processo esperar e aceitar por conexões Função retorna um novo socket para enviar dados para o cliente

42 42/46 Receber e enviar dados 1 w h i l e ( l e n = r e c v ( s2, &buf, 100, 0), l e n > 0) 2 send ( s2, &buf, len, 0) ; ssize t recv(int socket, void *buffer, size t length, int flags); ssize t send(int socket, const void *buffer, size t length, int flags); funções retornam o número de bytes lidos/escritos ou -1 (erro) int socket tem o número do socket de comunicação void *buffer contém o conteúdo enviado/recebido size t length é o número de bytes enviados/recebidos int flags determina o tipo de transmissão

43 43/46 O lado do cliente int connect(int socket, const struct sockaddr *address, socklen t address len); 1 #i n c l u d e... 2 main ( ) { 3 u n s i g n e d i n t s ; 4 s t r u c t s o c k a d d r u n remoto ; 5 6 s = s o c k e t ( AF UNIX, SOCK STREAM, 0) ; 7 remoto. s u n f a m i l y = AF UNIX ; 8 s t r c p y ( remoto. sun path, mysocket ) ; 9 10 i n t l e n = s t r l e n ( remoto. s u n p a t h ) + s i z e o f ( remoto. s u n f a m i l y ) ; 11 c o n nect ( s, ( s t r u c t s o c k a d d r )&remoto, l e n ) ; send ( s, b a r b a r o s s a, s t r l e n ( b a r b a r o s s a ), 0) ; 14 c l o s e ( s ) ; 15 }

44 Pipe bidirecional socketpair() cria um pipe bidirecional com sockets 1 main ( ) { 2 i n t sv [ 2 ] ; / the p a i r o f s o c k e t d e s c r i p t o r s / 3 c h a r buf ; / f o r data exchange between p r o c e s s e s / 4 5 s o c k e t p a i r ( AF UNIX, SOCK STREAM, 0, sv ) ; 6 7 i f (! f o r k ( ) ) { / c h i l d / 8 r e a d ( sv [ 1 ], &buf, 1) ; 9 p r i n t f ( f i l h o : l ê %c \ n, buf ) ; 10 w r i t e ( sv [ 1 ], &buf, 1) ; 11 p r i n t f ( f i l h o : e n v i a %c \ n, buf ) ; 12 } e l s e { / p a r e n t / 13 w r i t e ( sv [ 0 ], b, 1) ; 14 p r i n t f ( p a i : e n v i a b \ n ) ; 15 r e a d ( sv [ 0 ], &buf, 1) ; 16 p r i n t f ( p a i : l ê %c \ n, buf ) ; 17 w a i t (NULL) ; / w a i t f o r c h i l d to d i e / 18 } 19 r e t u r n 0 ; 44/46

45 45/46 Resumo arquivos com travas (não vimos com detalhes) sinais comunicação restrita pipes direcional, somente entre processos relacionados pipes nomeados direcionado, entre processos arbitrários filas de mensagens transmissão de pacotes, bidirecional memória compartilhada comunicação direto pela memória Unix Domain Sockets cria comunicação bidirecional: modelo-servidor

46 46/46 Referências Beej s Guide to Unix IPC