Timeout. Socket Avanzati. Client echo UDP con alarm. Funzione alarm()

Transcript

1 Università degli studi di Salerno Laurea in Informatica a.a. 2003/04 Socket Avanzati Prof. Vincenzo Auletta 1 Timeout Abbiamo visto molte situazioni in cui è necessario fissare un su un operazione di I/O Per evitare che un applicazione si blocchi in attesa di dati che non arriveranno Ci sono tre tecniche per assegnare un ad un operazione sul socket funzione alarm() funzione select() opzioni del socket SO_RCVTIMEO e SO_SNDTIMEO Funzione alarm() Client echo UDP con alarm 2 #include <netdb.h> int alarm(unsigned int nsec); Genera un segnale SIGALRM l applicazione deve registrare un gestore per questo segnale il kernel interrompe l esecuzione della system call e chiama il gestore del segnale Il gestore restituisce il controllo all applicazione Controindicazioni L implementazione della gestione dei segnali non è standard La gestione di SIGALRM è unica in tutto il processo 3 void dg_cli_echo(file *fd, int sockd, const struct sockaddr * p_servaddr, socklen_t servlen, int ) { (1) int n; char sendline[maxline], recvline[maxline + 1]; if( signal(sigalrm, sig_) ) err_sys("errore in signal"); (2) while (fgets(sendline, MAXLINE, fd)!= NULL) { n = strlen(sendline); if( sendto(sockd, sendline, n, 0, p_servaddr, servlen)!= n ) err_sys("errore nella sendto"); alarm(); (3) if( (n = recvfrom(sockd, recvline, MAXLINE, 0, NULL, NULL)) < 0 ) if( errno == EINTR ) err_msg("socket "); (4) else err_sys("errore in recvfrom"); alarm(0); (5) recvline[n] = 0; if( fputs(recvline, stdout) == EOF ) err_sys("errore nella fputs"); 1. Prende in input il numero di secondi di 2. Registra il gestore di SIG_ALRM Il gestore non fa nulla 3. Attiva l alarm prima di leggere 4. Se recvfrom è interrotta allora è scaduto il 5. Disattiva l alarm dopo aver letto

2 4 Funzione select con La select() prende un argomento di tipo timeval Permette di registrare i numeri di secondi e microsecondi di Il si applica a tutti i descrittori controllati dalla select La select() restituisce 0 se il è scaduto e non c è nessun descrittore pronto < 0 se c è stato un errore > 0 se ci sono descrittori pronti e la struttura timeval contiene il tempo rimanente 5 Client echo UDP con select() void dg_cli_echo(file *fd, int sockd, const struct sockaddr * p_servaddr, socklen_t servlen, int ) { (1) int n; char sendline[maxline], recvline[maxline + 1]; fd_set rset; struct timeval tv; while (fgets(sendline, MAXLINE, fd)!= NULL) { /* scrive sul socket il contenuto di sendline */ FD_ZERO(&rset); FD_SET(sockd, &rset); (2) tv.tv_sec = ; (3) tv.tv_usec = 0; if( (n = select(sockd + 1, &rset, NULL, NULL, &tv)) < 0 ) (4) err_sys("errore in select"); if( n == 0 ) err_msg("socket "); (5) else /* legge dal socket e stampa su stdout */ 1. Prende in input il numero di secondi di 2. Registra il socket per la lettura 3. Setta il 4. Invoca la select 5. Se la select esce con 0 è scaduto il 6 Opzione SO_RCVTIMEO L opzione SO_RCVTIMEO fissa il sulle operazioni di lettura da un descrittore di socket Vale per tutte le operazioni di lettura da quel descrittore Utilizzabile solo per descrittori di socket Per le operazioni di scrittura si usa l opzione SO_SNDTIMEO 7 Client echo UDP con SO_RCVTIMEO void dg_cli_echo(file *fd, int sockd, const struct sockaddr * p_servaddr, socklen_t servlen, int ) { (1) int n; char sendline[maxline], recvline[maxline + 1]; struct timeval tv; tv.tv_sec = ; tv.tv_usec = 0; (2) if( (setsockopt(sockd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv))) ) err_sys("errore in setsockopt"); (3) while (fgets(sendline, MAXLINE, fd)!= NULL) { /* scrive sul socket il contenuto di sendline */ n = recvfrom(sockd, recvline, MAXLINE, 0, NULL, NULL); if( n < 0 ) { if( errno == EWOULDBLOCK ) { (4) err_msg("socket "); continue; else err_sys("errore in recvfrom"); /* legge dal socket e stampa su stdout */ 1. Prende in input il numero di secondi di 2. fissa il valore del 3. Setta l opzione del socket 4. Se la recvfrom esce con EWOULDBLOCK è scaduto il

3 8 Funzioni recv() e send() #include <sys/socket.h> ssize_t recv(int sockd, void* buff, size_t n, int flags); ssize_t send(int sockd const void* buff, size_t n, int flags); Restituiscono -1 se errore Numero di byte letti o scritti se OK Sono analoghe a read e write ma hanno un argomento in più (flags) Analogo al quarto argomento di sendto e recvfrom Definisce il comportamento della system call La variabile flags può essere usata soltanto per passare informazioni dal processo al kernel 9 Flag La variabile flags può contenere l OR logico di alcuni di questi valori MSG_DONTROUTE MSG_DONTWAIT MSG_OOB MSG_PEEK MSG_WAITALL Non legge la tabella di routing prima di spedire Operazione di lettura o scrittura eseguita in modalità non blocking Legge o invia dati fuori banda Legge i dati dal socket senza estrarli dal buffer Aspetta che tutti i dati siano pronti prima di leggere (come readn) Funzioni readv() e writev() Struttura iovec 10 #include <sys/uio.h> ssize_t readv(int fd, const struct iovec* iov, int iovcount); ssize_t writev(int fd, const struct iovec* iov, int iovcount); Restituiscono -1 se errore Numero di byte letti o scritti se OK Sono analoghe a read e write ma consentono di operare su più buffer contemporaneamente scattering (distribuzione) e gathering (raccolta) Utilizzate per evitare di inviare tanti piccoli pacchetti Con socket UDP una writev crea un unico datagram iov è un array di strutture iovec di lunghezza al più IOV_MAX Ogni struttura specifica un buffer 11 struct iovec { void* ; /* indirizzo di partenza del buffer */ int iov_len; /* lunghezza del buffer */ ; iov_len 100 Es. una readv legge 180 caratteri

4 12 Funzioni recvmsg() e sendmsg() #include <sys/socket.h> ssize_t recvmsg(int sockd, struct msghdr* msg, int flags); ssize_t sendmsg(int sockd, struct msghdr* msg, int flags); Restituiscono -1 se errore numero di byte letti o scritti se OK Sono le funzioni di I/O più generali Tutte le altre funzioni di I/O sono casi particolari di queste due Supportano Flags Lettura e scrittura da più buffer Specifica dell indirizzo Passaggio di dati ausiliari (ancillary data) Struttura msghdr struct msghdr { void* msg_name; /* indirizzo del socket */ socklen_t msg_namelen; /* lunghezza dell indirizzo */ struct iovec* msg_iov; /* array di buffer */ size_t msg_iovlen; /* lunghezza di msg_iov */ void* msg_control; /* dati ausiliari */ socklen_t msg_controllen; /* lunghezza di msg_control */ int msg_flags; /* flag restituiti da recvmsg() */ ; L argomento flags è usato solo da sendmsg() per passare flags al kernel Stessi valori di recv() msg_flags è usato solo da recvmsg() per contenere i flag ricevuti dal kernel 13 Restituisce anche MSG_BCAST, MSG_MCAST, MSG_TRUNC (messaggio troncato), MSG_CTRUNC (dati ausiliari troncati) 14 Dati Ausiliari I dati ausiliari possono essere passati o ricevuti solo utilizzando sendmsg() e recvmsg() Usati per passare informazioni da un protocollo ad un altro Es. opzioni IP_RECVSTDADDR, IP_RECVIF Passare informazioni dal processo figlio al processo padre o tra processi indipendenti (socket UNIX) Il campo msg_control è formattato come un insieme di oggetti di dati (ancillary data object) Oggetti distinti possono avere differenti lunghezze Per manipolare gli oggetti si usano macro ad hoc Ogni oggetto inizia con una struct cmsghdr 15 Struttura cmsghdr struct msghdr { socklen_t cmsg_len; /* lunghezza di un blocco */ struct iovec* cmsg_level; /* protocollo che ha prodotto i dati */ size_t cmsg_type; /* specifico del protocollo */ unsigned char cmsg_data[]; ; I dati devono essere allineati con la struct msghdr Ci possono essere caratteri di riempimento tra cmsg_type e cmsg_data

5 16 Operazioni su Dati Ausiliari #include <sys/socket.h> struct cmsghdr* CMSG_FIRSTHDR(struct msghdr* mhdrptr); /* restituisce il puntatore al primo blocco o NULL */ struct cmsghdr* CMSG_NXTHDR(struct msghdr* mhdrptr, struct cmsghdr* cmsgptr); /* restituisce il puntatore al prossimo blocco o NULL */ unsigned char* CMSG_DATA(struct cmsghdr* cmsgptr); /* restituisce un puntatore al primo byte di cmsg_data */ unsigned int CMSG_LEN(unsigned int length); /* restituisce il valore di cmsg_len */ unsigned int CMSG_SPACE(unsigned int length); /* restituisce la dimensione complessiva di un oggetto */ 17 Esempio Chiama recvmsg() su un socket UDP con opzione IP_RECVSTDADDR settata per ricevere un datagram di 170 byte inviato da :2000 all indirizzo msg_name msg_namelen 16 msg_iov msg_iovlen 3 msg_control msg_controllen20 msg_flags 0 msghdr iovec iov_len Esempio Contenuto della struttura restituita da recvmsg() msg_name msg_namelen 16 msg_iov msg_iovlen 3 msg_control msg_controllen16 msg_flags 0 msghdr sockaddr_in 16, AF_INET, cmsghdr cmsg_len cmsg_level cmsg_type iovec iov_len IPPROTO_IP IP_RECVSTDADDR Socket UNIX E un socket associato ad un file L indirizzo del socket è un path nel file system locale Consentono di realizzare comunicazione tra processi dello stesso host usando l API dei socket È molto più efficiente di un normale socket TCP Utilizzato per passare descrittori tra due processi (es. dal figlio al padre) struct sockaddr_un { uint8_t sun_len; sa_family_t sun_family; /* AF_LOCAL */ char sun_path[104]; ; sun_path contiene una stringa di lunghezza variabile la macro SUN_LEN calcola la launghezza del pathname

6 20 Funzioni su socket UNIX Alcune funzioni dell API hanno un comportamento differente quando usate su socket UNIX La bind deve essere effettuata su un pathname assoluto il file non deve essere associato ad altri descrittori La connect deve essere effettuata su un pathname associato ad un socket UNIX dello stesso tipo Il controllo dei permessi effettuato dalla connect è analogo a quello della open di un file 21 Client TCP con Socket UNIX int main(int argc, char **argv) { int sockd; struct sockaddr_un servaddr; if (argc!= 2) err_quit("utilizzo: echo_client <pathname>"); if ( (sockd = socket(af_local, SOCK_STREAM, 0)) < 0) (1) err_sys("errore in socket"); bzero(&servaddr, sizeof(servaddr)); servaddr.sun_family = AF_LOCAL; (2) strcpy(servaddr.sun_path, argv[1]); if (connect(sockd, (SA *) &servaddr, sizeof(servaddr)) < 0) err_sys("errore nella connect"); str_client(stdin, sockd); exit(0); 1.Crea un socket UNIX 2.Riempie la struttura sockaddr_un Server TCP con Socket UNIX 1 Server TCP con Socket UNIX 2 int main(int argc, char **argv) { int listend, connd; struct sockaddr_un servaddr, cliaddr; socklen_t clilen; pid_t pid; if( argc!= 2 ) err_quit("utilizzo: echo_server <pathname>"); if( (listend = socket(af_local, SOCK_STREAM, 0)) < 0) (1) err_sys("errore in socket"); unlink(argv[1]); (2) bzero(&servaddr, sizeof(servaddr)); servaddr.sun_family = AF_LOCAL; strcpy(servaddr.sun_path, argv[1]); (3) /* esegue bind(), listen() e signal() */ 1. Crea un socket UNIX 2. Scollega il pathname 3. Riempie la struttura sockaddr_un for ( ; ; ) { /* esegue la accept */ if( (pid = fork()) == 0 ) { /* chiude il socket di ascolto */ str_srv_echo(connd); exit(0); /* chiude il socket di connessione */ 22 23

7 24 Passaggio dei Descrittori UNIX consente il passaggio di descrittori tra due processi indipendenti Il processo A crea un descrittore Passa il descrittore al processo B Il processo B utilizza il descrittore I descrittori di A e B possono avere valori differenti ma sono associati alla stessa risorsa Il valore del descrittore ha significato solo locale al processo La conversione è fatta automaticamente dal kernel Il passaggio dei descrittori è effettuato utilizzando il passaggio di dati ausiliari su un socket UNIX 25 Utilizzo del Passaggio di Descrittori Utilizzato in server TCP ricorsivi per consentire la comunicazione padre-figlio dopo che è stata effettuata la fork() Es. i web server utilizzano la tecnica del preforking per ottimizzare i tempi di risposta All avvio il server genera un certo numero di figli Ogni volta che il server riceve una richiesta di connessione crea un socket di connessione e lo passa ad un figlio libero (con sendmsg) I processi figlio inattivi sono bloccati su una recvmsg in attesa di ricevere il descrittore del socket di connessione Esempio Applicazione mycat 26 L applicazione mycat legge da linea di comando il nome di un file e ne stampa su stdout il contenuto Per aprire il file invoca la funzione myopen La funzione myopen utilizza la fork(): il processo figlio apre il file e passa il descrittore al padre; il padre passa il descrittore alla mycat La comunicazione tra processo figlio e processo padre di myopen avviene attraverso un socket UNIX 27 int main(int argc, char **argv) { int fd, n; char buff[buffsize]; if (argc!= 2) err_quit("utilizzo: mycat <pathname>"); if ( (fd = my_open(argv[1], O_RDONLY)) < 0) (1) err_sys("non è possibile aprire il file %s", argv[1]); while ( (n = read(fd, buff, BUFFSIZE)) > 0) (2) if( write(fileno(stdout), buff, n)!= n ) err_sys("errore in write"); exit(0); 1.Chiama la myopen per aprire il file 2.Stampa una riga per volta

8 28 Funzione myopen 1 int my_open(const char *pathname, int mode) { int fd, sockfd[2], status; pid_t childpid; char c; if( socketpair(af_local, SOCK_STREAM, 0, sockfd) < 0 ) (1) err_sys("errore in socketpair"); if ( (childpid = fork()) == 0) { /* child process */ if( close(sockfd[0]) < 0 ) err_sys("errore in close"); if( (fd = open(pathname, O_RDONLY)) < 0 ) err_sys("errore in open"); (2) if( write_fd(sockfd[1], "", 1, fd) < 0 ) err_quit("errore in write_fd"); (3) if( close(sockfd[1]) < 0 ) err_sys("errore in close"); exit(0); 1. Crea una stream pipe 2. Il processo figlio apre il file 3. Chiama la funzione write_fd per passare il descrittore al padre 29 Funzione myopen 2 if( close(sockfd[1]) < 0 ) err_sys("errore in close"); if( waitpid(childpid, &status, 0) == -1 ) err_sys("errore in waitpid"); (4) if (WIFEXITED(status) == 0) err_quit("child non terminato"); if ( (status = WEXITSTATUS(status)) == 0) read_fd(sockfd[0], &c, 1, &fd); (5) else { errno = status; fd = -1; if( close(sockfd[0]) < 0 ) err_sys("errore in close"); return(fd); (6 4. Il processo padre aspetta che il figlio termini 5. Se il figlio è terminato correttamente chiama la read_fd per leggere il descrittore del file 6. Restituisce il descrittore al programma principale 30 Funzione write_fd ssize_t write_fd(int fd, void *ptr, size_t nbytes, int sendfd) { int n; struct msghdr msg; struct iovec iov[1]; union { struct cmsghdr cm; char control[cmsg_space(sizeof(int))]; control_un; struct cmsghdr *cmptr; msg.msg_control = control_un.control; msg.msg_controllen = sizeof(control_un.control); cmptr = CMSG_FIRSTHDR(&msg); cmptr->cmsg_len = CMSG_LEN(sizeof(int)); cmptr->cmsg_level = SOL_SOCKET; cmptr->cmsg_type = SCM_RIGHTS; *((int *) CMSG_DATA(cmptr)) = sendfd; msg.msg_name = NULL; msg.msg_namelen = 0; iov[0]. = ptr; iov[0].iov_len = nbytes; msg.msg_iov = iov; msg.msg_iovlen = 1; return(sendmsg(fd, &msg, 0)); 31 Funzione read_fd ssize_t read_fd(int fd, void *ptr, size_t nbytes, int *recvfd) { struct msghdr msg; struct iovec iov[1]; ssize_t n; int newfd; union { struct cmsghdr cm; char control[cmsg_space(sizeof(int))]; control_un; struct cmsghdr *cmptr; msg.msg_control = control_un.control; msg.msg_controllen = sizeof(control_un.control); msg.msg_name = NULL; msg.msg_namelen = 0; iov[0]. = ptr; iov[0].iov_len = nbytes; msg.msg_iov = iov; msg.msg_iovlen = 1; if ( (n = recvmsg(fd, &msg, 0)) <= 0) return(n); if ( (cmptr = CMSG_FIRSTHDR(&msg))!= NULL && cmptr->cmsg_len == CMSG_LEN(sizeof(int))) { if (cmptr->cmsg_level!= SOL_SOCKET) err_quit("control level!= SOL_SOCKET"); if (cmptr->cmsg_type!= SCM_RIGHTS) err_quit("control type!= SCM_RIGHTS"); *recvfd = *((int *) CMSG_DATA(cmptr)); else *recvfd = -1; return(n);

9 32 Socket non Bloccanti Per default i socket sono bloccanti Le operazioni sul socket si bloccano fino a quando non hanno un risultato da restituire Operazioni bloccanti: read, write, connect, accept E possibile specificare che il socket deve operare in modo non bloccante (usa fcntl o ioctl) o che una singola operazione deve essere effettuata in modo non bloccante (usa i flags) L implementazione di un client o di un server non bloccante è più complessa Bisogna gestire l eventuale assenza di dati Conviene creare due processi: uno solo per leggere dal socket e l altro solo per scrivere 33 Funzione fcntl() #include <fcntl.h> int fcntl(int fd, int cmd, ); modifica il comportamento di un descrittore Modalità non bloccante (O_NONBLOCK) Modalità signal-driven (O_ASYNC) Legge o modifica il proprietario del descrittore (F_GETOWN, F_SETOWN) Legge o modifica i flag del descrittore (F_GETFL, F_SETFL) Per rendere un socket non bloccante int flags; if( (flags = fcntl(fd, F_GETFL, 0)) < 0 ) err_sys( errore F_GETFL ); flags = O_NONBLOCK; if( fcntl(fd, F_SETFL, flags) ) < 0 ) err_sys( errore F_SETFL );