Laboratorio Reti di Calcolatori (A.A ) Delfina Malandrino.

Transcript

1 Laboratorio Reti di Calcolatori (A.A ) Delfina Malandrino Applicazione echo Il server replica un messaggio inviato dal client Il client legge una riga di testo dallo standard d input e la invia al server Il server legge la riga di testo dal socket e la rimanda al client Il client legge la riga di testo dal socket e la invia allo standard input 1

2 Echo Server #include basic.h int main(int argc, char **argv) { pid_t pid; int listensd, connsd; struct sockaddr_in servaddr, cliaddr; socklen_t clilen; if( (listensd = socket(af_inet, SOCK_STREAM, 0)) < 0) err_sys( errore in socket"); bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family sin = AF_INET; servaddr.sin_addr.s_addr = htonl(inaddr_any); servaddr.sin_port = htons(serv_port); if( (bind(listensd, (SA *) &servaddr, sizeof(servaddr))) < 0) err_sys("errore in bind"); if( listen(listensd, LISTENQ) < 0 ) err_sys( errore in listen"); Echo Server for ( ; ; ) { clilen = sizeof(cliaddr); if( (connsd = accept(listensd, (SA *) &cliaddr, &clilen)) < 0) err_sys( errore in accept"); if( (pid = fork()) == 0 ) { if( close(listensd) == -1 ) err_sys( errore in close"); server_echo(connsd); if( close(connsd) == -1 ) err_sys( errore y( in close ); exit(0); if( close(connsd) == -1 ) err_sys("errore in close"); 2

3 Echo Server void server_echo(int sockd) { ssize_t n; char line[maxline]; for ( ; ; ) { if ( (n = readline(sockd, line, MAXLINE)) == 0) return; //connessione chiusa dal client if( writen(sockd, line, n)!= n ) err_sys( sys( write error"); Echo Client int main(int argc, char **argv) { int sockd, n; char buff[maxline], recvline[maxline + 1]; struct sockaddr_in servaddr, localaddr, peeraddr; socklen_t localaddr_len, peeraddr_len; if ((sockd = socket(af_inet, SOCK_STREAM, 0)) < 0 ) err_sys("socket error"); bzero(&servaddr, sizeof(servaddr)); servaddr.sin_addr.s_addr=inet_addr(argv[1]); [ servaddr.sin_family = AF_INET; servaddr.sin_port = htons(serv_port); if (connect(sockd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0 ) err_sys( connect error"); client_echo(stdin, sockd); exit(0); inet_pton(af_inet,argv[1],&serveraddr.sin_addr) 3

4 Echo Client void client_echo(file *fd, int sockd) { char sendline[maxline], recvline[maxline]; int n; while (fgets(sendline, MAXLINE, fd)!= NULL) { (1) if( (n = writen(sockd, sendline, strlen(sendline))) < 0) (2) err_sys("errore nella write"); if ( (n = readline(sockd, recvline, MAXLINE)) < 0) (3) err_sys("errore nella readline"); if (n == 0) (4) err_quit("str_cli_echo: server morto prematuramente\n"); fputs(recvline, stdout); (5) 1. legge da fd fino all EOF 2. invia al server la stringa letta 3. legge una riga dal socket si aspetta \n per uscire 4. se ha letto l EOF esce 5. stampa su stdout Analisi dell Applicazione: Creazione della Connessione ete (Delfina MAlandrino) 20 Quando il server parte invoca le funzioni: socket, bind, listen, accept e rimane bloccato nella accept. Il client non è ancora partito. [delmal@apollo ECHO]./echo_server [delmal@apollo ECHO] netstat -a Proto Recv-Q Send-Q Local Address Foreign Address State tcp 0 0 *:9877 *:* LISTEN Mostrato lo stato di tutti i socket nel sistema L opzione a mostrailistening socket Lo * per un IP address di 0 (INADDR_ANY) Unaportaa0 Processo padre Processo padre Indirizzo socket :9877 4

5 Analisi dell Applicazione: Creazione della Connessione Quando parte il client si hanno 3 processi nel sistema. Processo server padre bloccato sull accept Processo server figlio bloccato sulla read Il client bloccato su fgets [delmal@wonderland ECHO]./echo_client [delmal@wonderland ECHO] netstat a Proto Recv-Q Send-Q Local Address Foreign Address State tcp : :9877 ESTABLISHED indirizzo del socket del client (IP: porta 32791) Analisi dell Applicazione: Creazione della Connessione Quando parte il client si hanno 3 processi nel sistema. Processo server padre bloccato sull accept Processo server figlio bloccato sulla read Il client bloccato su fgets [delmal@apollo ECHO] netstat -a Proto Recv-Q Send-Q Local Address Foreign Address State tcp : :* LISTEN tcp : :32791 ESTABLISHED indirizzo del socket di ascolto ( porta 9877) Processo padre indirizzo del socket connesso ( : porta 9877) Processo server figlio 5

6 Analisi dell Applicazione: Creazione della Connessione ECHO] ps lw F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND schedu S pts/0 0:00./echo_server schedu S pts/0 0:00./echo_server processo > server padre processo > server figlio generato da [delmal@wonderland ~]$ ps lw F UID PID PPID PRI NI VSZ RSS WCHAN STAT TTY TIME COMMAND rt_sig S pts/7 0:00 -tcsh S pts/7 0:00./echo_client processo > client generato da tcsh Chiusura normale Quando l utente inserisce i dati tutto ciò che viene inviato al server verrà stampato su stdout. [delmal@wonderland ECHO]./echo_client Ciao D Ciao R ^D D [delmal@wonderland ECHO] [delmal@wonderland ECHO] netstat a grep 9877 tcp : :9877 TIME_WAIT Il client va in TIME_WAIT 6

7 Chiusura Normale L utente digita ^D la fgets() restituisce NULL client_echo() termina il client esegue exit() il S.O. chiude tutti i descrittori invia il FIN al server e riceve l ACK (va in FIN_WAIT_2) il server non ha ancora inviato il suo FIN ed èin CLOSE_WAIT Chiusura di una connessione 7

8 Chiusura Normale Quando il server TCP riceve il FIN Il processo figlio è bloccato sulla readline che restituisce 0 La funzione server_echo() termina Il controllo ritorna al metodo main il server figlio esegue exit() il S.O. invia il FIN al client e termina la close di TCP il client passa allo stato TIME_WAIT Chiusura di una connessione 8

9 Analisi dell Applicazione: Chiusura della Connessione Lo stato dei socket dopo che è stata terminata la close è il seguente ECHO] netstat a grep 9877 Tcp : :9877 TIME_WAIT [delmal@apollo ECHO] netstat a grep 9877 Tcp : :* LISTEN lo stato dei processi è il seguente prompt> ps lw PID PPID STAT TTY TIME COMMAND S pts/0 0:00./echo_server Z pts/0 0:00 [echo_server <defunct>] il processo figlio è diventato zombie Gestione dei segnali I segnali sono utilizzati per notificare l occorrenza di un evento ad un processo Sono inviati dai processi stessi o dal SO SIGCHLD inviato dal SO al processo padre Il processo può decidere quali segnali gestire Per ogni segnale deve definire una funzione di gestione (handler del segnale) void handler(int signo); Ogni segnale ha un handler di default Alcuni vengono sempre gestiti (SIGKILL) Alcuni per default vengono ignorati (SIGCHLD) 9

10 Gestione dei segnali In un server ricorsivo il server crea un processo figlio per gestire la connessione Quando il processo figlio termina di gestire la richiesta la connessione viene chiusa ed il processo figlio termina Il SO manda un segnale SIGCHLD al padre ed il processo figlio diventa ZOMBIE I processi ZOMBIE sono processi terminati per i quali vengono mantenuti dei dati nel SO (CPU,memoria, ecc). Il processo padre può così controllare il valore di uscita del figlio e l utilizzo delle risorse del figlio Di default il processo padre ignora questo segnale Il processo figlio rimane ZOMBIE finché il padre non termina Gestione dei segnali I processi ZOMBIE esauriscono lo spazio della tabella dei processi Per evitare la creazione di processi ZOMBIE bisogna fare in modo che il processo padre gestisca il segnale SIGCHLD Bisogna fornire un handler per il segnale SIGCHLD Il processo zombie viene rimosso quando il processo padre chiama le funzioni wait() e waitpid() 10

11 wait e waitpid pid_t wait(int* statloc); pid_t waitpid(pid_t t pid, int* statloc, intoptions); le funzioni restituiscono il pid e il valore di uscita del processo figlio che è finito consentono al processo zombie di essere rimosso caratteristiche di wait() si blocca finchè non termina un figlio non accoda i segnali ricevuti durante l esecuzione alcuni processi restano zombie caratteristiche ti di waitpid() id() opzione non bloccante (WNOHANG) Il processo non aspetta se il figlio non è terminato permette di scegliere il figlio da attendere (-1 per il primo che termina) chiamato in un ciclo consente di catturare tutti i segnali Handler per SIGCHLD #include <signal.h> #include <sys/wait.h> void gestisci_zombie (int segnale) { int status; pid_t waitpid(pid_t pid, int*status, int options) int pid; while((pid = waitpid(-1, &status, WNOHANG)) > 0) printf("child %d terminato\n", pid); return; waitpid() permette di scegliere il figlio d attendere (-1 per il primo che termina) Quando il figlio termina e lancia il segnale SIGCHLD, waitpid() lo cattura e restituisce il pid 11

12 Attivazione dell handler #include <signal.h> #include <sys/wait.h> typedef void Sigfunc(int); Sigfunc *signal(int signum, Sigfunc *func) { struct sigaction act, oact; act.sa_handler = func; sigemptyset(&act.sa_mask); act.sa_flags = 0; if (signum!= SIGALRM) act.sa_flags = SA_RESTART; if (sigaction(signum, &act, &oact) < 0) return(sig_err); return(oact.sa_handler); signal() attiva l handler: prende in ingresso il numero del segnale ed il puntatore all handler la struttura sigaction memorizza informazioni riguardanti la manipolazione del segnale insieme di segnali bloccati durante l esecuzione dell handler la funzione sigaction() prende in ingresso una struttura contenente il puntatore all handler, una maschera di segnali da mascherare e vari flag Gestione dei segnali [delmal@wonderland] ps lw PID PPID PGID WINPID TTY UID STIME COMMAND con :31:25 /usr/bin/tcsh /bi / con :31:55 /usr/bin/tcsh con :32:51 /usr/bin/tcsh con :19:17./echo_server con :20:16./echo_client con :20:16./echo_server [delmal@wonderland]>./echo_server & [1] 3076 prompt >./ echo_client Ciao Ciao ^D Child 2352 terminato 12

13 Interruzione delle system call Le system call lente possono essere bloccate dalla cattura di un segnale e l esecuzione dell handler es. accept, read, write La system call esce con errore EINTR l applicazione termina anche se EINTR non è un vero errore Occorre tener presente questo problema l applicazioneli i può gestire separatamente questo errore Alcuni S.O. fanno ripartire le system call interrotte la nostra signal() dice al S.O. di far ripartire le system call interrotte (flag SA_RESTART) Una possibile soluzione for ( ; ; ) { clilen = sizeof(cliaddr); if ( (connfd = accept(listenfd, &cliaddr, &clilen)) < 0) { if (errno = EINTR) continue; else { err_sys( accept error ); Se la chiamata ad accept ritorna EINTR accept viene richiamata Se l errore è diverso da EINTR Si gestisce l errore (nell esempio si chiama exit) 13

14 Server TCP con Gestione di SIGCHLD e EINTR #include "basic.h" int main(int argc, char **argv) { pid_t pid; int listensd, connsd; struct sockaddr_in servaddr, cliaddr; socklen_t len; if( (listensd = socket(af_inet, SOCK_STREAM, 0)) < 0) err_sys("errore in socket"); /* riempie l oggetto servaddr */ if( (bind(listensd, (SA *) &servaddr, sizeof(servaddr))) < 0) err_sys("errore in bind"); if( listen(listensd, LISTENQ) < 0 ) err_sys("errore in listen"); if( signal(sigchld, gestisci_zombie) == SIG_ERR ) err_sys("errore nella signal"); Server TCP con Gestione di SIGCHLD e EINTR for ( ; ; ) { len = sizeof(cliaddr); if( (connsd = accept(listensd, (SA *) &cliaddr, &cliaddr_len)) < 0) { if( errno == EINTR ) continue; else err_sys("errore in accept"); if( (pid = fork()) == 0 ) { if( close(listensd) == -1 ) err_sys("errore in close"); do_it(connsd); d) close(connsd); exit(0); if( close(connsd) == -1 ) err_sys("errore in close"); 14

15 Reset connessione e accept Un altro errore tipico da gestire con accept è il reset della connessione prima della chiamata ad accept La connessione è diventata ESTABLISHED ma è ancora nel BACKLOG Il client spedisce un RST Il server chiama accept Reset connessione e accept Quando il server invoca l accept questa restituisce un codice di errore ECONNABORTED La gestione dell errore ECONNABORTED dipende dall implementazione Il server può ignorarlo e richiamare accept per la prossima connessione 15

16 Terminazione del server Cosa succede se il server child termina prematuramente? I passi che avvengono sono i seguenti: Inviamo una stringa al server ed il server la restituisce correttamente Troviamo il PID del processo figlio e lo terminiamo (kill) Tutti i descrittori verranno chiusi Un FIN verrà inviato al client, il client risponde con un ACK. Il segnale SIGCHLD viene inviato al processo padre e gestito correttamente Sul client non accade nulla. Il client TCP riceve il FIN e risponde con un ACK ma PROBLEMA: Il client è bloccato sulla fgets (in attesa di una linea dal terminale) Terminazione del server [delmal@wonderland] > echo_client hello hello Ciao str_cli_echo: server morto prematuramente I Il client spedisce Ciao al server È permesso perché il client non ha chiuso il socket Il processo server ha chiuso la sua connessione e non invierà più dati Il client non sa che il processo padre è terminato Quando il server riceve altri dati dal client risponde con un RST Il client non vede l RST dal momento che è bloccato sulla readline La readline restituisce EOF a causa del FIN ricevuto dal server Non si aspetta di ricevere EOF quindi stampa il messaggio di errore e termina ( server morto prematuramente ) Tutti i descrittori verranno chiusi 16

17 SIGPIPE Cosa succede se il client ignora l errore su readline e scrive altri dati sul socket? Questo può capitare se il client deve eseguire due write consecutive prima di ricevere qualcosa La prima write fa sì che il server spedisca RST La seconda write crea il problema Quando un processo scrive su un socket che ha ricevuto un RST un segnale di SIGPIPE viene inviato al processo il processo termina se il segnale non viene catturato o ignorato Se SIGPIPE è ignorato l operazione di write genera l errore di EPIPE SIGPIPE Cosa succede con il segnale SIGPIPE: #include "unp.h" void str_cli(file *fp, int sockfd) { char sendline [MAXLINE], recvline [MAXLINE]; while (fgets(sendline, MAXLINE, fp)!= NULL) { writen(sockfd, sendline, 1); sleep(1); writen(sockfd, sendline + 1, strlen(sendline) - 1); if (readline(sockfd, ( recvline, MAXLINE) == 0) err_quit("str_cli: server terminated prematurely"); fputs(recvline, stdout); 17

18 SIGPIPE Cosa succede con il segnale SIGPIPE: > echo_client Hi there Hi there bye Broken pipe I Soluzione semplice, quando non si deve reagire all errore Ignorare (SIG_IGN) il segnale di SIGPIPE Assume che non occorre fare niente di speciale in tale circostanza Controllare l errore di EPIPE sulle write e nel caso di errore terminare (non scrivere più) Crash della macchina server Un altra possibile causa di errore è se la macchina server non risponde proprio Diverso da uccidere il processo server (in quel caso vengono spediti FIN, RST) Può dipendere dalla rete Il client è bloccato in readline TCP ritrasmetterà i dati per ricevere l ACK fino ad un certo timeout (ritrasmesso il segmento per 12 volte con tempo di attesa di 9 min circa) La funzione di lettura dal socket restituisce un errore ETIMEOUT (in caso di nessuna risposta) EHOSTUNREACH, ENETUNREACH (se un router determina che l host è unreachable e risponde con un ICMP destination unreachable ) 18

19 Server shutdown and reboot La connessione viene stabilita Il server va giù e fa il reboot senza che il client se ne accorga Non c è comunicazione durante lo shutdown (server scollegato dalla rete altrimenti spedisce FIN) Il client spedisce nuovi dati al server dopo il reboot Il server non ha più il socket aperto TCP risponde ai dati con un RST Client è in readline quando riceve RST Readline restituisce ECONNRESET Somma di 2 numeri Il client legge due interi dallo standard input e li invia al server il server li somma e restituisce il risultato al client il client stampa il risultato sullo standard output 19

20 Applicazione Somma - Server #include "basic.h" #include "somma_server.h" int main(int argc, char **argv) { pid_t pid; int listensd, connsd; struct sockaddr_in servaddr, cliaddr; socklen_t cliaddr_len; if( (listensd = socket(af_inet, SOCK_STREAM, 0)) < 0) err_sys( sys("errore in socket"); bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl(inaddr_any); servaddr.sin_port = htons(serv_port); Applicazione Somma - Server if( (bind(listensd, (struct sockaddr *) &servaddr, sizeof(servaddr))) < 0) err_sys("errore in bind"); if( listen(listensd, t LISTENQ) < 0 ) err_sys("errore in listen"); for ( ; ; ) { cliaddr_len = sizeof(cliaddr); if( (connsd = accept(listensd, (SA *) &cliaddr, &cliaddr_len)) < 0) { err_sys("errore in accept"); if( (pid = fork()) == 0 ) { if( close(listensd) == -1) err_sys("errore in close"); doit_server(connsd); if( close(connsd) == -1) err_sys("errore in close"); exit(0); if( close(connsd) == -1 ) err_sys("errore in close"); 20

21 Applicazione Somma Server #include "basic.h" void doit_server(int sockd){ int i, arg1, arg2,n; char sendline[maxline], recvline[maxline],c; for ( ; ; ) { if ( (n = readline(sockd, recvline, MAXLINE)) == 0) return; /* connessione chiusa dal client */ if( sscanf(rcvline, "%d %d", &arg1, &arg2) == 2 ) /* estrae da rcvline i due interi passati dal client */ sprintf(sendline, "%d\n", arg1 + arg2); else sprintf(sendline, "errore nell'input\n"); /* se il formato del messaggio ricevuto non è corretto*/ if( (n = writen(sockd, sendline, strlen(sendline))) < 0) /* invia la risposta al client */ err_sys("errore nella write"); Applicazione Somma Client #include "basic.h" #include "somma_client.h" int main(int argc, char **argv){ int sockd, n; struct sockaddr_in servaddr; if ( argc!= 2 ) err_quit("utilizzo: somma_client <IPaddress>"); if ( (sockd = socket(af_inet, SOCK_STREAM, 0)) < 0 ) err_sys("errore in socket"); bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port sin = htons(serv_port); if ( inet_pton(af_inet, argv[1], &servaddr.sin_addr) <= 0 ) err_quit("errore in inet_pton per %s", argv[1]); if ( connect(sockd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0 ) err_sys("errore in connect"); doit_client(stdin, sockd); exit(0); 21

22 Applicazione Somma Client #include "basic.h" void doit_client(file *fd, int sockd) { char sendline[maxline], recvline[maxline]; int n; printf("digita due interi sulla stessa linea\n"); while (fgets(sendline, MAXLINE, fd)!= NULL) { if( (n = writen(sockd, sendline, strlen(sendline))) < 0) err_sys("errore nella write"); if ( (n = readline(sockd, recvline, MAXLINE)) < 0) err_sys("errore nella readline"); if (n == 0) err_quit("str_cli_echo: il server è morto prematuramente\n"); fputs(recvline, stdout); Passaggio di strutture Strutture scambiate fra client e server Il client legge due interi dallo standard input e li invia al server il server li somma e restituisce il risultato al client il client stampa il risultato sullo standard output struct args{ long arg1; long arg2; struct result{ long sum; 22

23 doit_server #include basic.h" void doit_server(int sockfd) { ssize_t n; struct args args; struct result result; for ( ; ; ) { if ( (n = readn(sockfd, &args, sizeof(args))) == 0) return; /* connection closed by other end */ result.sum = args.arg1 + args.arg2; writen(sockfd, &result, sizeof(result)); doit_client void doit_client(file *fp, int sockfd) { char sendline[maxline]; struct args args; struct result result; while (fgets(sendline, MAXLINE, fp)!= NULL) { if (sscanf(sendline, "%ld%ld", &args.arg1, &args.arg2)!= 2) { printf("invalid input: %s", sendline); continue; writen(sockfd, &args, sizeof(args)); if (readn(sockfd, &result, sizeof(result)) == 0) err_quit("server terminato prematuramente\n"); printf("%ld\n", result.sum); 23