Applicazioni distribuite. La programmazione di rete. Interfacce e protocolli. Protocollo applicativo

Transcript

1 Applicazioni distribuite Applicazione: un insieme di programmi coordinati per svolgere una data funzione applicativa. La programmazione di rete Introduzione alla programmazione di rete La connessione La trasmissione Un applicazione è distribuita se prevede più programmi (o processi) eseguiti su differenti calcolatori connessi tramite una rete. I programmi devono quindi contenere funzioni che consentono la comunicazione tramite una rete. 20 febbraio 2004 Processo: programma in esecuzione Rete: nodi collegati + servizi di rete che consentono la comunicazione Protocollo applicativo Interfacce e protocolli Le regole per la comunicazione in una applicazione distribuita sono dette protocollo applicativo. Il protocollo applicativo utilizza i servizi messi a disposizione del Sistema Operativo della macchina e i servizi di rete che consentono la comunicazione, messi a disposizione dal software di rete Es. il protocollo applicativo della navigazione Web è detto HyperText Transfer Protocol - http. Il software di rete (servizi di rete) dipende dal protocollo di comunicazione comune tra i nodi della rete Il protocollo applicativo deve essere definito opportunamente e comune a tutti i programmi dell applicazione. Es. ogni messaggio scambiato è terminato dalla stringa \0 \0 \0. Si considera il protocollo di comunicazione TCP/IP (Transfer Control Protocol/Interconnect Protocol) L insieme delle chiamate di funzioni di sistema utilizzabili dai programmi applicativi viene comunemente definito API (application program interface): le API forniscono il canale (o supporto) di comunicazione; i programmi comunicano invocando opportune funzioni dell API di rete; il protocollo applicativo rappresenta le regole di comunicazione, e considera il contenuto della comunicazione

2 Interfacce e protocolli L interfaccia socket Applicazione distribuita Obbiettivo: specificare l interfaccia tra programma applicativo e software del protocollo di comunicazione Programma applicativo P Protocollo applicativo Programma applicativo Q L API standard per TCP/IP si chiama interfaccia socket ed è stata definita a Berkley agli albori di internet (circa 1980). Sistema operativo eswdi rete Chiamate al s.o. e al software di rete (API) Sistema operativo eswdi rete Per utilizzarlo, e cioè utilizzare le funzioni di rete relative, è necessario includere un insieme di file di libreria (sys/types.h, sys/socket.h, netinet/in.h) Il socket costituisce la struttura dati che rappresenta il canale di rete Rete L interfaccia socket Connessione tra calcolatori Unix e Windows L interfaccia socket è in linguaggio C ed è per calcolatori Unix (LINUX) : per calcolatori Windows si utilizza WinSocket. Programma C Programma C Socket funziona anche per altri protocolli differenti da TCP/IP. API di Unix + socket API di Win + Winsocket TCP/IP garantisce l interoperabilità tra calcolatori anche se equipaggiati con sistemi operativi differenti. Unix e TCP/IP Windows e TCP/IP Calcolatori Unix e calcolatori Windows possono comunicare utilizzando, rispettivamente, le interfacce Socket e WinSocket. Canale di comunicazione

3 Il modello Client/Server Identificazione dei processi - Indirizzamento Il software di rete TCP/IP consente a due processi residenti su due nodi della rete di comunicare tra loro, trasferendo dati. Non definisce a priori nessuno schema o modello di cooperazione (applicativa) tra i processi (comunicazione peer-to-peer) Il modello di cooperazione tipico di un applicazione distribuita è il modello client/server processo server: offre servizi ad altri processi, accetta le richieste, esegue il servizio, fornisce un risultato. Il server viene pertanto attivato prima del client processo client: richiede dei servizi ad un server e attende risposta Siano P e Q i due processi che devono comunicare: Q (client) deve richiedere un servizio a P (server) E necessario che Q sappia come raggiungere P (per inviargli la richiesta) e che poi P sappia come raggiungere Q (per restituire quanto richiesto o segnalare il completamento dell operazione richiesta dallo stesso Q) Un processo viene identificato, e quindi indirizzato, ai fini della comunicazione specificando il calcolatore sul quale il processo è in esecuzione Generalmente un processo conserva lo stesso ruolo (è o sempre Client o sempre Server) il numero di port, che identifica il processo sul suo calcolatore ai fini della comunicazione Indirizzamento Il modello di comunicazione e la connessione Il calcolatore è specificato tramite l indirizzo IP (Internet Protocol): l indirizzo IP è composto da 4 byte (quindi 32 bit) (ad esempio ) La comunicazione TCP è connection-oriented (orientata alla connessione) perchè due processi comunichino è necessario prima stabilire una connessione, quindi scambiare i dati Il port èun valore intero che può essere specificato dal processo o assegnato automaticamente alcuni port (compresi tra 0 e 1023) sono assegnati a servizi standard e non possono essere utilizzati per sviluppare propri server L indirizzamento TCP completo è quindi specificato fornendo l indirizzo IP della macchina ed il port Es. < , 80> significa: port 80 (di solito è il port del Web server) della macchina Perchè una connessione possa essere stabilita è necessario che un processo (generalmente il server P) sia in attesa di una richiesta di connessione da parte di un altro processo (il client Q)

4 Il modello di comunicazione e la connessione Sequenza per la connessione di due processi P e Q: P e Q rappresentano i punti terminali della connessione considerata ogni punto terminale è identificato dalla coppia <indirizzo IP, numero di port> ogni connessione è quindi identificata da 4 numeri: <indirizzo IP di P, numero di port di P>, <indirizzo IP di Q, numero di port di Q> dopo la connessione, il canale di comunicazione è bidirezionale, affidabile e orientato allo stream Il modello di comunicazione e la connessione Le principali caratteristiche del canale di comunicazione sono: bidirezionale: P colloquia con Q e Q colloquia con P orientato allo stream: consente una trasmissione continua di byte (o di gruppi di byte) affidabile: se il destinatario (Q o P) non riceve un byte (o un gruppo di byte), il mittente (P o Q) se ne accorge. E la caratteristica del TCP, non presente nell IP Si noti che uno stesso processo può partecipare a diverse conessioni contemporaneamente. Le diverse connessioni sono infatti distinte dagli altri punti terminali Tipi di calcolatori e formato dei dati I calcolatori che si affacciano sulla rete (host) possono essere di tipi e con sistemi operativi differenti. I dati possono essere rappresentati in modi differenti Il TCP/IP prevede un formato di rete dei dati unico: ogni calcolatore dispone di routine per convertire i dati dal formato TCP/IP al proprio formato locale e viceversa. Indirizzi IP: u_long inet_addr(char * stringa) char * inet_ntoa(u_long addr) Port: u_short htons(u_short port) u_short ntohs(u_short port)

5 Il meccanismo accept-connect connect La creazione di una connessione tra due processi deve seguire le seguenti regole La programmazione di rete il processo P (server) si pone in attesa di richieste di connessione (apertura passiva) Si utilizza la funzione accept (bloccante) La connessione il processo Q (client) formula una richiesta a P di apertura di connessione (apertura attiva) Si utilizza la funzione connect Le richieste si attuano sull interfaccia di socket tramite le funzioni accept/connect Per stabilire una connessione è necessario, dal punto di vista programmativo, inizializzare opportune variabili che descrivono i punti terminali della connessione. Lo vedremo con degli esempi Il meccanismo accept-connect connect Un semplice client La connessione può fallire perché: il processo P (server) non esiste P esiste ma non ha eseguito la accept P esiste ma è occupato in un altra connessione e la coda dei processi che richiedono connessioni a P è già piena Q (client) non conosce gli esatti valori dell indirizzo IP del calcolatore di P e del port di P.. Le operazioni svolte dal processo Q (client) che esegue una richiesta di connessione ad un altro processo (apertura attiva) sono: definisce una opportuna variabile di tipo struct sockaddr_in per contenere le informazioni sul punto terminale che identifica il server a cui vuole connettersi (il tipo struct sockaddr_in è definito per contenere informazioni di un punto terminale) inizializza la variabile relativa con dati validi può definire una seconda variabile di tipo struct sockaddr_in per contenere le informazioni del punto terminale che rappresenta se stesso crea un socket della connessione (descrittore) esegue la connect specificando il proprio socket

6 Descrizione del punto terminale - struct sockaddr_in struct sockaddr_in short sin_family; u_short sin_port; struct in_addr sin_addr; char sin_zero[8]; Dove sin_family: famiglia di indirizzi AF_INET (Address Family InterNet) altre famiglie: AF_UP (Xerox), AF_APPLETALK (AppleTalk), AF_UNIX (UNIX) sin_port: numero di port, a 16 bit ( ) sin_addr: indirizzo IP, 32 bit sin_zero: non utilizzato Inizializzazione del punto terminale #include <sys/type.h> #include <sys/socket.h> #include <netinet/in.h> /* costanti utili */ #define IND_SERVER /*NB è una stringa*/ #define PORTA_SERVER struct sockaddr_in server_addr; /*punto terminale */ int server_len = sizeof (server_addr); bzero ((char *)&server_addr, server_len); /* azzera il punto terminale */ server_addr.sin_family = AF_INET; server_addr.sin_port = htons((u_short) PORTA_SERVER); /* htons: host to network conversion, short */ server_addr.sin_addr.s_addr = inet_addr(ind_server); /* inet_addr: converte da stringa a formato rete */ Funzione addr_initialize Un semplice client #include <sys/type.h> #include <sys/socket.h> #include <netinet/in.h> void addr_initialize(struct sockaddr_in *indirizzo, int port, long IPaddr) indirizzo->sin_family = AF_INET; indirizzo->sin_port = htons((u_short) port); /* htons: host to network conversion, short */ indirizzo->sin_addr.s_addr = IPaddr; inizializza il punto terminale server crea un socket tramite l istruzione sd = socket(af_inet, SOCK_STREAM, 0); esegue la richiesta di connessione error = connect(sd, (struct sockaddr*) &server_addr, sizeof(server_addr)); Tramite la funzione connect gli viene assegnato un port di cui può conoscere il valore tramite la funzione getsockname al termine, chiude il socket rilasciando il port che può essere utilizzato da altri programmi: close (sd);

7 socket( ) connect () int socket (int family, int type, int protocol) / Crea un socket e ne restituisce il descrittore, -1 = errore. Parametri: family, definisce la famiglia di protocolli (AF_INET per TCP/IP, AF_UP per Xerox,...); type, specifica il tipo di comunicazione (SOCK_STREAM per servizio di consegna affidabile TCP, SOCK_DGRAM per datagramma senza connessione UDP,...); protocol, specifica quale protocollo utilizzare se nella famiglia utilizzata ne esiste più di uno, normalmente vale 0. Nota bene: il socket da solo non è ancora il canale di rete, è soltanto una struttura dati che serve per gestire il canale di rete; per aprire un canale di rete associandolo al socket occorre chiamare la primitiva connect oppure la primitiva accept / int connect (int sd, struct sockaddr server_ep, int ep_len) / Invia una richiesta di collegamento in qualità di cliente, restituisce 0 se successo, -1 se errore. Parametri: sd, specifica il socket (che deve essere già stato creato) da associare al canale di rete; server_ep, specifica il punto terminale (endpoint) del destinatario della richiesta di collegamento, che è il server; ep_len, specifica la lunghezza in byte del punto terminale / Chiamata tipica: error = connect(sd, (sockaddr *)&server_ep, sizeof(server_ep)); Passaggio di parametri a main Listato di UClient1 (i) argc: contiene il numero dei parametri ricevuti argv: è un vettore di puntatori a stringhe, ognuna delle quali è un parametro. Per convenzione argv[0] contiene sempre il nome del programma in esecuzione #include <stdio.h> void main(int argc, char *argv[]) int i; printf( il valore di argc e %d \n \n, argc); for (i=0; i<argc; i++) printf( parametro %i = %s\n, i, argv[i]); >prova il valore di argc e 2 parametro 0 = prova1 parametro 1 = /* programma UCLIENT1 */ #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #define PORT 4000 void addr_initialize(); void main(int argc, char* argv[]) /*legge sulla linea di comando l indirizzo di IP del calcolatore dove c è il server*/ int sd; struct sockaddr_in server_addr; struct sockaddr_in mio_addr; int mio_addr_len=sizeof(mio_addr); int error;

8 Listato di UClient1 (ii( ii) Esecuzione di UClient1 addr_initialize(&server_addr, PORT, inet_addr(argv[1])); sd=socket(af_inet,sock_stream,0); error=connect(sd,(struct sockaddr*) &server_addr, sizeof(server_addr)); if (error==0) printf("ho eseguito la connessione\n"); getsockname(sd, &mio_addr, &mio_addr_len); printf("il mio port e': %d\n\n",ntohs(mio_addr.sin_port)); close(sd); else printf("%s","\nerrore di connect\n\n"); close(sd); Se il server non è attivo, il client riporta il fallimento della connessione: Un semplice server (i) Un semplice server (ii( ii) Le operazioni svolte dal processo P che si mette in attesa di richieste di connessione da altri processi (apertura passiva) sono analoghe a quelle svolte da Q: predispone una variabile struct sockaddr_in client_addr per memorizzare l indirizzo IP ed il port del client per potergli rispondere predispone una variabile struct sockaddr_in server_addr per inizializzare il proprio punto terminale, specificando indirizzo e numero di port. Generalmente un server specifica che intende accettare connessioni sul proprio port, indipendentemente dall indirizzo IP (del server stesso) sul quale arrivano le richieste (INADDR_ANY) crea un socket sd per accettare connessioni indica a TCP/IP che l indirizzo locale associato al socket sd è quello contenuto in server_addr tramite la funzione bind: bind(sd,(struct sockaddr*)&server_addr, sizeof(server_addr)); si pone in attesa di una richiesta di connessione tramite la funzione accept: new_sd = accept(sd, (struct sockaddr*) &client_addr, &client_len); Poichè la funzione accept è bloccante (con time-out), il programma eseguito dal server può proseguire solo quando arriva una richiesta di connessione Quando la accept è stata eseguita la connessione è associata al nuovo socket new_sd e quindi le operazioni di trasmissione e/o ricezione dati fanno riferimento a questo socket. Il socket sd può essere usato per accettare altre richieste di connessione

9 Un semplice server (iii( iii) bind( ) il server chiude la connessione con il client tramite la close(new_sd); int bind (int sd, struct sockaddr server_ep, int ep_len) In aggiunta il server: può stabilire il numero massimo di richieste di connessione che può accodare (MAXCONN), servendone però sempre una sola per volta: listen(sd, MAXCONN); La funzione listen serve anche per sincronizzare le richieste tra client e server ed elimina il problema di connect fallita nel caso in cui il server non abbia ancora eseguito l accept quando il client esegue la connect / Associa un numero di porta TCP a un socket, restituisce 0 se successo, -1 se errore. Parametri: sd, specifica il socket da associare al numero di porta TCP; server_ep, specifica il punto terminale (endpoint) contenente il numero di porta da associare (l'indirizzo ha funzione di filtro); ep_len, specifica la lunghezza in byte del punto terminale / accept( ) Listato di UServer1 (i) int accept (int sd, struct sockaddr client_ep, int ep_len) / Accetta una richiesta di collegamento in qualità di servente, restituisce un nuovo socket (sempre >= 0) se successo, -1 se errore; il nuovo socket restituito è quello su cui portare avanti il dialogo con il cliente richiedente; il vecchio socket è disponibile per ulteriori accettazioni. Parametri: sd, specifica il socket (che deve essere già stato creato) su cui ricevere la richiesta di collegamento proveniente dal cliente; client_ep, specifica la locazione in cui memorizzare il punto terminale (endpoint) del cliente; ep_len, specifica la locazione in cui memorizzare la lunghezza in byte del punto terminale / Chiamata tipica: new_sd = accept (sd, (sockaddr *)&client_ep, &ep_len); /* programma USERVER1 */ #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #define PORT 4000 #define MAXCONN 5 void addr_initialize(); void main(int argc, char * argv[]) int sd,new_sd; struct sockaddr_in server_addr; struct sockaddr_in client_addr; int client_len=sizeof(client_addr);

10 Listato di UServer1 (ii( ii) UClient1 e UServer1 in esecuzione addr_initialize(&server_addr, PORT, INADDR_ANY); sd=socket(af_inet,sock_stream,0); bind(sd,(struct sockaddr*) &server_addr,sizeof(server_addr)); listen(sd,maxconn); printf("mi pongo in attesa di richieste di connessione\n"); printf("sul mio port: %d\n", ntohs(server_addr.sin_port)); new_sd=accept(sd,(struct sockaddr*) &client_addr, &client_len); printf("\n\nho accettato una connessione\n"); printf("dal client con port: %d\n\n", ntohs(client_addr.sin_port)); close(new_sd); close(sd); Connessione lato client e lato server lato client lato server Indirizzo IP Indirizzo/i IP numero port del server socket della connessione (lato client) connect(, con chi ) socket per accettare connessioni (bind.., listen.) new_sd=accept(, da chi ) numero port del client socket della connessione accettata (lato server)

11 La trasmissione La programmazione di rete Dopo aver stabilito la connessione bidirezionale (accept/connect), i due processi possono scambiarsi dati (caratteri) attraverso tramite le funzioni send e receive La trasmissione send: spedisce dati all altro punto terminale della connessione; receive: riceve dati inviati dall altro punto terminale della connessione Trasmissione Sintassi primitive send all invocazione della funzione, i byte da trasferire, presenti nelle variabili del processo, vengono copiati in un area di sistema (buffer di sistema) e il processo può proseguire nell elaborazione anche se i dati non sono ancora arrivati a destinazione. E sospensiva per il processo che la invoca solo se il buffer di sistema è pieno receive sospensiva: all invocazione della funzione, il processo che la esegue non può proseguire nell elaborazione finchè i dati non sono stati ricevuti e copiati nel buffer di sistema del ricevente (a meno di chiusura di connessione o errore). I byte ricevuti nel buffer di sistema vengono quindi copiati nelle variabili del processo. Se sono stati ricevuti più dati di quelli copiabili nelle variabili del processo, questi rimangono disponibili nel buffer di sistema per chiamate successive int send (int sd, char message, int len, int flags) / Spedisce, attraverso il canale identificato da sd, len byte memorizzati nella stringa message. Restituisce il numero di byte effettivamente inviati, -1 se errore. Altri param.: flags, specifica funzioni speciali, di solito 0 / int recv (int sd, char message, int len, int flags) / Riceve, attraverso il canale identificato da sd, len byte e li memorizza nella stringa message. Restituisce il numero di byte effettivamente ricevuti, -1 se errore. Altri param.: flags, specifica funzioni speciali, di solito 0 /

12 Send... Esempio d uso char dati[12]="abcdefghilm"; int num; /* numero byte da inviare */ int inviati; /* numero byte trasmessi */ num = 7; inviati=send(sd,dati,num,0); Receive... # define DIM... char dati_ricevuti[dim + 1]; int ricevuti; /* numero byte ricevuti */ ricevuti=recv(sd,dati_ricevuti,dim,0); Esempio d uso 2 - Client con ricezione carattere, eco e ritrasmissione di carattere (i) #include <stdio.h> #include <sys/socket.h> void main(int argc, char* argv[]) int sd; struct sockaddr_in server; int error; char c; /* inizializzazione pto terminale del server */ server.sin_family = AF_INET; server.sin_port = htons((u_short) 4500); server.sin_addr.s_addr = inet_addr( ); sd=socket(af_inet,sock_stream,0); error=connect(sd,(struct sockaddr*) &server_addr, sizeof(server_addr)); Esempio d uso 2 - Client con ricezione carattere, eco e ritrasmissione di carattere (ii) Ancora sul funzionamento: send if (error==0) recv(sd, &c, 1, 0); printf( %c\n, c); send(sd, &c, 1, 0); printf("\n Chiudo la connessione \n"); close(sd); else printf("%s","\nerrore di connect\n\n"); close(sd); int send (int sd, char message, int len, int flags) copia in memoria di sistema del trasmittente len byte prelevati da message (variabile utente) non bloccante se memoria di sistema sufficiente a contenere i byte da spedire valore restituto: n byte effettivamente spediti (<0 se errore) /* end main */

13 Ancora sul funzionamento - receive Un esempio - UClient2 e Userver2 int recv (int sd, char message, int len, int flags) bloccante fino ad arrivo dati (o segnalazione evento chiusura connessione o errore) riceve i dati nel buffer di sistema del ricevente e copia len byte in message (variabile utente) valore restituito: - se n byte effettivamente ricevuti < = len, allora valore restituito = n byte effettivamente ricevuti UClient2 e Userver2: Invio da parte di un client di un n variabile di caratteri che vengono ricevuti da un server che li visualizza. Il numero di caratteri da inviare è specificato dall utente del client (se viene specificato 0, l applicazione deve terminare) - se n byte ricevuti > len, allora solo len copiati in message (i rimanenti disponibili per receive successive) e valore restituito = n byte copiati - se chiusura connessione valore restituito =0, se errore valore restituito < UClient2 Listato di UClient2 (i) UClient2: stabilisce la connessione con UServer2; chiede all utente di inserire il numero di caratteri che si vogliono inviare (num); preleva da un buffer (char dati[12]) tali caratteri e li invia al server; ripete la richiesta di num. Termina, se l utente ha indicato che non si vogliono spedire ulteriori caratteri (num = 0), chiudendo la connessione. #include <stdio.h> #include <sys/socket.h> #define PORT 4000 void addr_initialize(); void main(int argc, char* argv[]) int sd; struct sockaddr_in server_addr; struct sockaddr_in mio_addr; int mio_addr_len=sizeof(mio_addr); int error, num, inviati; char dati[12]="abcdefghilm"; addr_initialize(&server_addr, PORT, inet_addr(argv[1])); sd=socket(af_inet,sock_stream,0); error=connect(sd,(struct sockaddr*) &server_addr, sizeof(server_addr));

14 Listato di UClient2 (ii( ii) UServer2 if (error==0) printf("ho eseguito la connessione\n"); printf("\n inserire il numero di caratteri da trasmettere: "); scanf("%d", &num); while (num > 0) inviati=send(sd,dati,num,0); printf("inserire il numero di caratteri da trasmettere:"); scanf("%d", &num); printf("\n Chiudo la connessione \n"); close(sd); else printf("%s","\nerrore di connect\n\n"); close(sd); /* end main */ UServer2: accetta la connessione (da UClient2); riceve un numero variabile di caratteri (ric), con un limite massimo di DIMBUF; stampa a video il numero di caratteri ricevuti ed i caratteri stessi. Poi, si prepara per una nuova ricezione di caratteri dalla stessa connessione; se non ha ricevuto caratteri (ric = 0) chiude la connessione con UClient2 e si prepara per una nuova connessione da un nuovo client Listato di UServer2 (i) Listato di UServer2 (ii( ii) #include <stdio.h> #include <sys/socket.h> #define PORT 4000 #define MAXCONN 5 #define DIMBUF 6 void addr_initialize(); void main(int argc, char * argv[]) int sd,new_sd; struct sockaddr_in server_addr; struct sockaddr_in client_addr; int client_len=sizeof(client_addr); int ric, i; char buf[dimbuf]; addr_initialize(&server_addr, PORT, INADDR_ANY); sd=socket(af_inet,sock_stream,0); bind(sd,(struct sockaddr*) &server_addr,sizeof(server_addr)); listen(sd,maxconn); while (1) printf("\nmi pongo in attesa di richieste di connessione\n"); new_sd=accept(sd,(struct sockaddr*) &client_addr, &client_len); printf("ho accettato una connessione\n"); ric=1; while (ric>0) ric=recv(new_sd,buf,dimbuf,0); printf("\nho ricevuto %d caratteri: ",ric); for (i=0; i<ric;i++) printf("%c", buf[i]); close(new_sd); printf("chiudo la connessione\n"); /* fine del ciclo perenne */ /* end main*/

15 Ricezione di sequenze di caratteri da memorizzare in array La ricezione di sequenze di caratteri da memorizzare in stringhe (array di caratteri terminate da \0) deve garantire la correttezza dell operazione e cioè nell array devono venire copiati tutti e soli i caratteri della sequenza. Si deve inoltre ricordare che i buffer di sistema di mittente e destinatario di una trasmissione sono indipendenti tra loro. Ad es., in un determinato istante il buffer di sistema del destinatario può contenere byte che provengono da due send successive La ricezione può avvenire carattere per carattere, fino a completare la sequenza (più semplice) a gruppi di caratteri, fino a completare la sequenza (più veloce) Inoltre, la sequenza da ricevere può essere di lunghezza fissata di lunghezza variabile terminata da un carattere terminatore di fine_seq Sequenza di caratteri di lunghezza fissata da memorizzare in una stringa Ricezione di un singolo carattere alla volta char seq [DIM+1]; int i; Sequenza di caratteri di lunghezza fissata da memorizzare in una stringa Ricezione di più caratteri alla volta char seq [DIM+1]; int i; i=0; while (i < DIM) recv(sd, &seq[i], 1, 0); i++; seq[i]= \0 ; 0 1 DIM \0 i=0; while (i < DIM) ric = recv(sd, &seq[i], DIM - i, 0); i = i + ric; seq[i]= \0 ;

16 Sequenza di caratteri terminata da carattere terminatore da memorizzare in una stringa Ricezione di un singolo carattere alla volta char seq [MAXDIM]; char term = ; int i; Sequenza di caratteri terminata da carattere terminatore da memorizzare in una stringa Ricezione di più caratteri alla volta char seq [MAXDIM]; char term = ; int i; i=0; do recv(sd, &seq[i], 1, 0); i++; while (seq[i-1]!=term); 0 1 MaxDIM -1 \0 i=0; do ric = recv(sd, &seq[i], MAXDIM-i, 0); i=i+ric; while ((seq[i-1]!=term)&& (i<maxdim)); seq[i-1]= \0 ; seq[i-1]= \0 ;