Progettazione di Applicazioni Robuste. Applicazione Echo. Schema Generale di un Server TCP Ricorsivo 1. Applicazione echo

Transcript

1 a.a. 2003/04 Applicazione Echo Prof. Vincenzo Auletta Progettazione di Applicazioni Robuste nel progettare applicazioni su rete robuste si deve tener conto di varie situazioni anomale che si potrebbero verificare chiusura normale dell applicazione da parte del client crash del client chiusura dell applicazione da parte del server crash del server Università degli studi di Salerno Laurea in Informatica 1 Applicazione echo Schema Generale di un Server TCP Ricorsivo 1 2 il server replica tutti i messaggi inviatigli dal client il client legge linee di testo dallo standard input e le invia al server il server legge linee di testo dal socket e li rimanda al client il client legge righe di testo dal socket e li invia allo standard output fgets fputs Client writen readline readline writen Server 3 #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");

2 4 Schema Generale di un Server TCP Ricorsivo 2 for ( ; ; ) { len = sizeof(cliaddr); if( (connsd = accept(listensd, (SA *) NULL, NULL)) < 0) err_sys("errore in accept"); if( (pid = fork()) == 0 ) { if( close(listensd) == -1 ) err_sys("errore in close"); str_srv_func(connsd); if( close(connsd) == -1 ) err_sys( errore in close ); exit(0); if( close(connsd) == -1 ) err_sys("errore in close"); str_srv_func svolge il lavoro specifico dell applicazione 5 Schema Generale di un Client TCP #include "basic.h" 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("errore in socket"); /* riempe la struttura servaddr */ if (connect(sockd, (SA *) &servaddr, sizeof(servaddr)) < 0 ) err_sys("errore in connect"); str_cli_func(stdin, sockd, /* altri eventuali descrittori ); exit(0); str_cli_func() svolge il lavoro specifico dell applicazione 6 Client echo void str_cli_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: il server è morto\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 7 Server echo void str_srv_echo(int sockd) { ssize_t n; char line[maxline]; for ( ; ; ) { if ( (n = readline(sockd, line, MAXLINE)) == 0) (1) return; (2) if( writen(sockd, line, n)!= n ) (3) err_sys("errore nella write"); 1. la funzione è bloccata sulla lettura sul socket si aspetta \n per uscire 2. se readline restituisce 0 allora esce il client ha chiuso la connessione e inviato l'eo 3. scrive sul socket la riga di testo letta

3 8 Analisi dell Applicazione: Creazione della Connessione quando server e client partono vengono creati tre processi che si bloccano in vari stadi server padre bloccato sull accept server figlio bloccato sulla read client bloccato su fgets home/auletta/echo> netstat -a -Ainet -n Proto Recv-Q Send-Q Local Address Foreign Address State tcp : :* LISTEN tcp : :9877 ESTABLISH tcp : :1024 ESTABLISH indirizzo del socket del client ( porta 1024) indirizzo del socket di ascolto ( porta 9877) indirizzo del socket connesso ( porta 9877) 9 Analisi dell Applicazione: Creazione della Connessione home/auletta/echo> ps lw F UID PID PPID PRI WCHAN STAT TTY TIME COMMAND rt_sig S pts/1 0:00 -csh wait_f S pts/1 0:00 echo_server rt_sig S pts/2 0:00 -csh read_c S pts/2 0:00 echo_client tcp_da S pts/1 0:00 echo_server processo > server padre generato da tcsh 1244 e nello stato wait_f processo > server figlio generato da 1286 e nello stato tcp_da processo > client generato da tcsh 1292 e nello stato read_c Output del Client Condizioni di Uscita del Programma 10 home/auletta/echo> echo_client ciao (digitato dall utente) ciao (inviato dal server) chi sei? (digitato dall utente) chi sei? (inviato dal server) non fare il pappagallo!!! (digitato dall utente) non fare il pappagallo!!! (inviato dal server) ^D (il client chiude la connessione) home/auletta/echo> esce dalla fgets quando legge \n effettua la writen e si blocca su una readline esce dalla readline quando legge \n effettua la fputs e si riblocca sulla fgets 11 Uscita normale il client chiude la connessione il server padre rimane in ascolto sul socket Chiusura della connessione da parte del client prima che il server effettui l accept Chiusura della connessione da parte del server chiusura del processo crash del sistema

4 12 Chiusura Normale L utente digita ^D la fgets() restituisce NULL str_cli_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 la readline del server figlio restituisce 0 e str_srv_echo() termina 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 13 Analisi dell Applicazione: Chiusura della Connessione lo stato dei socket dopo che è stata terminata la close è il seguente home/auletta/echo> netstat -a -Ainet -n Proto Recv-Q Send-Q Local Address Foreign Address State tcp : :* LISTEN tcp : :9877 TIME_WAIT lo stato dei processi è il seguente home/auletta/echo> ps lw F UID PID PPID PRI WCHAN STAT TTY TIME COMMAND rt_sig S pts/1 0:00 -csh wait_f S pts/1 0:00 echo_server do_exi Z pts/1 0:00 [echo_server <defunct>] il figlio del server è diventato zombie 14 Gestione dei Segnali I segnali sono utilizzati per notificare degli eventi ad un processo inviati da un processo o dal S.O. Il processo può decidere quali segnali intende gestire le notifiche che accetta per ogni segnale da gestire deve definire una funzione di gestione (handler del segnale) Ogni segnale ha un handler di default alcuni vengono sempre gestiti (es. SIGKILL) alcuni per default vengono ignorati (es. SIGCHLD) 15 Segnale SIGCHLD Quando un processo termina manda un segnale SIGCHLD al padre e diventa zombie mantenuto dal S.O. per consentire al padre di controllare il valore di uscita del processo e l utilizzo delle risorse del figlio (memoria, CPU, etc.) per default il padre ignora il segnale ed il figlio rimane zombie fino a quando non termina il padre Il processo zombie viene rimosso quando il padre effettua la wait() o la waitpid() Lasciare in vita processi zombie può provocare disfunzioni si esaurisce lo spazio nella tabella dei processi Per evitare la creazione dei processi zombie bisogna fornire un handler per SIGCHLD

5 16 wait e waitpid pid_t wait(int* statloc); pid_t waitpid(pid_t pid, int* statloc, int options); 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 di waitpid() opzione non bloccante (WNOHANG) permette di scegliere il figlio da attendere (-1 per il primo che termina) chiamato in un ciclo consente di catturare tutti i segnali 17 Handler per SIGCHLD #include <signal.h> #include <sys/wait.h> void gestisci_zombie (int segnale) { int status; int pid; while((pid = waitpid(-1, &status, WNOHANG)) > 0) printf("child %d terminato\n", pid); return; appena un figlio termina e lancia SIGCHLD waitpid() lo cattura e restituisce il pid il processo figlio può essere rimosso Attivazione dell Handler #include <signal.h> la funzione signal attiva #include <sys/wait.h> l handler prende in input il numero typedef void Sigfunc(int); del segnale e il puntatore Sigfunc* signal(int signo, Sigfunc all handler *func) { struct sigaction act, oact; utilizza la funzione sigaction() act.sa_handler = func; prende in input una struct sigemptyset(&act.sa_mask); con il puntatore act.sa_flags = 0; all handler, una maschera if (signo!= SIGALRM) di segnali da mascherare act.sa_flags = SA_RESTART; e vari flag if (sigaction(signo, &act, &oact) < 0) i segnali mascherati non vengono consegnati return(sig_err); SA_RESTART fa riavviare return(oact.sa_handler); le system call interrotte da questo segnale 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 restituisce esce con errore EINTR l applicazione termina anche se EINTR non è un vero errore Occorre tener presente questo problema l applicazione 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)

6 Server TCP con Gestione di SIGCHLD e EINTR 1 Server TCP con Gestione di SIGCHLD e EINTR 2 20 #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"); 21 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"); str_srv_func(connsd); close(connsd); exit(0); if( close(connsd) == -1 ) err_sys("errore in close"); 22 Reset della Connessione e accept Il client può chiudere la connessione inviando un RST la connessione viene chiusa immediatamente senza completare la procedura di close Il client può inviare l RST prima che il server invochi la accept La connessione è diventata ESTABLISHED ma è ancora nel BACKLOG Quando il server invoca l accept questa ritorna un codice di errore ECONNABORTED La gestione dell errore ECONNABORTED dipende dall implementazione Il server può ignorarlo e richiamare accept per la prossima connessione Terminazione del Server L interazione può essere interrotta dal server es. morte del processo figlio che gestisce la connessione il server prima di morire chiude i descrittori di socket un FIN viene spedito al client il modulo TCP del client riceve il FIN e risponde con l ACK il client non viene avvertito dell arrivo del FIN perché è bloccato sulla fgets() il problema si risolve adottando l I/O multiplexing (prossima lezione) quando la fgets() termina il client effettua una write sul socket e chiama la readline è permesso perché il client non ha chiuso il socket esce immediatamente perché legge l EOF e stampa un messaggio di errore ( server morto prematuramente ) 23 Il server risponde con un RST perché il processo non esiste più

7 SIGPIPE Cosa succede se il client ignora l errore su readline e scrive nel socket? (es. il client effettua due write consecutive prima della readline) alla prima write il server risponde con RST alla seconda write il S.O. del client invia il segnale SIGPIPE scrittura su una connessione su sui si è ricevuto un RST Per default SIGPIPE termina il processo senza segnalare nulla Possibili alternative 1. Ignorare (SIG_IGN) il segnale di SIGPIPE Gestire l errore di EPIPE sulle write 25 Crash del Server Durante l esecuzione dell applicazione il sistema potrebbe cadere il processo server non ha il tempo di inviare nessun messaggio al client (né FIN, nè RST) Il client a eseguito la write ed è bloccato sulla readline TCP ritrasmetterà i dati fino ad un certo timeout la readline ritorna un errore (dopo circa 9 minuti) ETIMEOUT EHOSTUNREACH, ENETUNREACH per ridurre il ritardo si inserisce un timeout nella readline e si utilizza l opzione SA_KEEPALIVE 26 Server Shutdown e 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 una nuova line 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 ritorna ECONNRESET 27 Formato dei Dati la comunicazione tra client e server deve tener conto della diversa rappresentazione dei dati es. interi rappresentati in big endian o little endian Due soluzioni si trasmettono solo sequenze di caratteri (usato da socket) nell esempio dell echo vengono inviate e ricevute righe di testo per trasmettere un valore numerico prima lo si converte in una sequenza di caratteri e poi lo si manda il peer sa che tipo di dati si deve aspettare e legge la stringa nel modo opportuno si definisce una rappresentazione standard dei dati (XDR per RPC, XML per SOAP, ecc.)

8 Applicazione Somma 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 Client Somma void str_cli_sum(file *fd, int sockd) { char sendline[maxline], recvline[maxline]; int 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\n"); fputs(recvline, stdout); identico al client echo 30 Server Somma void str_srv_sum(int sockd) { long arg1, arg2; ssize_t n; char line[maxline]; for ( ; ; ) { if ( (n = readline(sockd, line, MAXLINE)) == 0) (1) return; if( sscanf(line, %ld %ld, arg1, arg2) == 2 ) (2) snprintf(line, sizeof(line), arg1+arg2); (3) else snprintf(line, sizeof(line), errore nell input\n ); n = strlen(line); if( writen(sockd, line, n)!= n ) (4) err_sys("errore nella write"); 1. legge fino a quando trova \n 2. estrae dal buffer i valori input 3. calcola la funzione e scrive il risultato in una stringa 4. invia la stringa 31 Esempio di Applicazione Somma che non usa le Stringhe Client e server girano su macchine dello stesso tipo sunos5 > somma_client Client gira su una macchina Sparc Server gira su una macchina Intel bsdi > somma_client