Esempio 1: stampa locale di file remoto

Transcript

1 Alcuni esempi di uso di Socket Esempio 1: stampa locale di file remoto Visualizzazione locale del contenuto di un file remoto. Il client deve richiedere la creazione della connessione e successivamente inviare un messaggio contenente il nome di un file leggibile, appartenente al file system del nodo su cui risiede il server. Il client si pone in attesa della risposta, rappresentata dal contenuto del file richiesto; ogni byte ricevuto attraverso il canale viene stampato dal client sul dispositivo di standard output. Soluzione Il server, una volta eseguita la richiesta, dovrà inviare al client una sequenza di caratteri,di lunghezza non nota a priori: usiamo le socket stream, perché: garantiscono l'ordine dei messaggi trasmessi la dimensione dei messaggi non e` a priori limitata Struttura Cliente #include <arpa/inet.h> allocazione della struttura rem_indirizzo main(argc, argv) int argc; char **argv; { int sock, retval, i; char mess[10], ris[1000]; il server esegue all'indirizzo ip: struct sockaddr_in rem_indirizzo; /*per indirizzo socket remota*/ memset ((char *)&rem_indirizzo, 0, sizeof(struct sockaddr_in)); /* Preparazione indirizzo del server */ rem_indirizzo.sin_family = AF_INET; rem_indirizzo.sin_addr.s_addr=inet_addr(" "); rem_indirizzo.sin_port = 22375; il server ascolta sulla porta

2 Client (..continua) /* Preparazione del messaggio*/ apertura della socket del client strcpy(mess, argv[1]); /* creazione della socket */ sock=socket(af_inet, SOCK_STREAM, 0); connessione con la socket remota connect(sock, &rem_indirizzo, sizeof(struct sockaddr_in)); write(sock,mess, 10); /*oppure send*/ while (i=read(sock,ris, 1)>0) printf("%s",ris); invio del nome del file al server shutdown(sock,2); /*Codice server*/ main() { char nomefile[20], buff; int newsock, sock, lung; FILE *fp; struct sockaddr_in mio_indirizzo; Struttura del server apertura della socket di ascolto memset((char *)&mio_indirizzo, 0, sizeof(struct sockaddr_in)); sock=socket(af_inet, SOCK_STREAM, 0); /*socket d'ascolto*/ if(sock<0) {perror("apertura socket"); exit(1); mio_indirizzo.sin_family=af_inet; mio_indirizzo.sin_port=22375; server (..continua) if(bind(sock, &mio_indirizzo, sizeof(struct creazione sockaddr_in))<0) della coda {exit(1); di richieste listen(sock, 5); newsock=accept(sock, (struct sockaddr_in *) 0, 0); close(sock); read(newsock, nomefile, 20); fp=fopen(nomefile, "r"); while(fscanf(fp, "%c", &buff) write(newsock, &buff, 1); shutdown(newsock, 1); pubblicazione della socket di ascolto attesa di richieste di connessione Possibili miglioramenti della soluzione: La soluzione non tiene conto dei possibili errori nell'invocazione delle primitive: gestione delle eccezioni. Il server accetta una sola richiesta e poi termina; soluzioni piu` generali: server iterativo: : in grado di servire piu` richieste in sequenza server concorrente: : in grado di servire piu` richieste in parallelo (uso della system call fork()) ricezione del messaggio 2

3 Esempio 2: calcolatrice Applicazione Client/server che consente di effettuare le 4 operazioni tra interi in remoto. Il client invia al server un pacchetto contenente l'operazione richiesta (+,*,-,/),/) e gli operandi su cui effettuarla (op1 e op2). Il server interpreta i dati della richiesta, esegue l'operazione e invia al client un datagramma contenente il risultato. Soluzione: : Client #include <stdlib.h> /* Dichiarazione del tipo associato alla richiesta:*/ typedef struct { int op1; int op2; char tipoop; Request; int main(int argc, char **argv) { struct sockaddr_in clientaddr, servaddr; int port, sd, num1, num2, len, ris; char ok[80]; char c; Request req; clientaddr.sin_family = AF_INET; clientaddr.sin_addr.s_addr = INADDR_ANY; clientaddr.sin_port = 0; memset((char *)&servaddr, 0, sizeof(struct sockaddr_in)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr= inet_addr(" "); servaddr.sin_port = 22777; /* CREAZIONE SOCKET :*/ sd=socket(af_inet, SOCK_DGRAM, 0); /* BIND SOCKET, a una porta scelta dal sistema*/ bind(sd,(struct sockaddr *) &clientaddr, sizeof(clientaddr)); /* lettura dei dati da inviare */ printf("primo operando (intero): "); scanf("%d", &req.op1) ; printf("secondo operando (intero): "); scanf("%d", &req.op2); do{ printf("operazione (+, -, *, /): "); c = getchar(); while (c!='+' && c!='-' && c!='*' && c!='/'); req.tipoop=c; 3

4 /* richiesta operazione: */ len=sizeof(servaddr); sendto(sd, &req, sizeof(request), 0, &servaddr, len); /* ricezione del risultato */ printf("attesa del risultato...\n"); recvfrom(sd, &ris, sizeof(ris), 0, (struct sockaddr *)&servaddr, &len); printf("esito dell'operazione: %d\n", ris); /* CHIUSURA SOCKET */ close(sd); printf("\nclient: termino...\n"); exit(0); Struttura server: #include <stdlib.h> /* Dichiarazione del tipo associato alla richiesta:*/ typedef struct { int op1; int op2; char tipoop; Request; int main(int argc, char **argv) { int sd; int len, num1, num2, ris; struct sockaddr_in cliaddr, servaddr; Request* req =(Request*)malloc(sizeof(Request)); /* INIZIALIZZAZIONE INDIRIZZO SERVER: */ memset((char *)&servaddr, 0, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = INADDR_ANY; servaddr.sin_port = 22777; /* CREAZ., BIND E SET. OPZIONI SOCKET */ sd=socket(af_inet, SOCK_DGRAM, 0); bind(sd,(struct sockaddr *) &servaddr, sizeof(servaddr)); /* CICLO DI RICEZIONE RICHIESTE */ for(;;) { len=sizeof(struct sockaddr_in); recvfrom(sd, req, sizeof(request), 0, &cliaddr, &len); switch(req->tipoop) { case '+': ris= req->op1 + req->op2; break; case '-': ris= req->op1 - req->op2; break; case '*': ris= req->op1 * req->op2; break; case '/': if (req->op1!=0) ris = req->op1 / req->op2; break; default: ris=99999; /* risultato in caso di errore */ /* invio risultato:*/ sendto(sd, &ris, sizeof(ris), 0, &cliaddr, len); /* ciclo for */ 4

5 Osservazioni: La soluzione non tiene conto dei possibili errori nell'invocazione delle primitive: gestione delle eccezioni La soluzione funziona se client e server adottano le stesse convenzioni di rappresentazioni dei dati; altrimenti,, e` necessario convertire esplicitamente il formato dei dati inviati/ricevuti (v. funzioni di conversione). Le informazioni relative agli indirizzi (ip address, porta) sono rappresentate da costanti; ; come fare a recuperarle "dinamicamente"? (v. primitive per la gestione degli indirizzi) Complementi Funzioni di conversione Funzioni ausiliarie per la portabilita` delle informazioni scambiate (come nel livello di presentazione OSI): Conversione di interi Quattro funzioni di libreria per convertire da formato di rete in formato interno per interi (lunghi o corti) trasformazione di un intero da formato esterno in interno: * shortlocale = ntohs(shortrete); longlocale = ntohl(longrete); trasformazione di un intero da formato interno in esterno: shortrete = htons(shortlocale); longrete = htonl(longlocale); Funzioni di conversione Conversione di indirizzi IP: Conversione tra indirizzi IP a 32 bit e corrispondente notazione col punto decimale (ascii: " "): inet_addr() converte l'indirizzo dalla forma con punto decimale: indirizzo = inet_addr(stringa); /*stringa contiene l'indirizzo in formato punto decimale, risultato indirizzo IP a 32 bit*/ inet_ntoa() esegue la funzione inversa: stringa = inet_ntoa(indirizzo); /*indirizzo indirizzo IP a 32 bit (cioè un long integer) risultato stringa di caratteri con indirizzo in forma con punto*/ 5

6 Primitive per la gestione degli indirizzi per ottenere l'indirizzo Internet di un Host remoto a partire dal nome logico di dominio del nodo (es. "studenti.deis.unibo.it"): la primitiva gethostbyname() restituisce l'indirizzo Internet e relativa lunghezza: struct hostent * gethostbyname (name); char *name; NB: gethostbyname restituisce un puntatore a una struttura di tipo hostent, oppure NULL se fallisce. struct hostent { char * h_name; /* nome ufficiale dell'host */ char ** h_aliases; /* lista degli aliases */ int h_addrtype; /* tipo dell'indirizzo dell'host */ int h_length; /* lunghezza del'indirizzo */ char ** h_addr_list; Primitive per la gestione degli indirizzi Per ottenere il numero di porta associato ad un servizio noto: la primitiva getservbyname() struct servent *getservbyname (name,proto) char *name,*proto; restituisce il puntatore a una struttura di tipo servent. Esempio di uso: struct servent *sp; struct sockaddr_in peeraddr; sp=getservbyname("example","tcp"); peeraddr.sin_port=sp->s_port; Socket: elenco principali primitive 6