Progetto fine al superamento del corso di Sistemi Operativi. Http server proxy Http web monitor

Transcript

1 Progetto fine al superamento del corso di Sistemi Operativi Http server proxy Http web monitor Sviluppato da: Santoro Carlo Maurizio Sviluppo terminato in Luglio/2006

2 Obiettivo: Progettare ed implementare in ambiente UNIX/ Linux, utilizzando il linguaggio C e le primitive POSIX, un proxy server che monitori il traffico generato dai browser che lo usano. Il web monitor e' un server che ascolta su una porta le richieste dai client (web browser). Alla ricezione della richiesta da parte del client, il monitor crea un altra connessione all attuale web server di destinazione e trasmette la richiesta del client. Il monitor inoltra la risposta del web server indietro al client. Il monitor dovrebbe anche fornire un opzione per il salvataggio di tutto il traffico su di un file. Nello specifico: PARTE 1 Scrivere un web monitor che prende tre argomenti: un numero di porta p, un nome di web server di destinazione e un flag verbose. Il monitor ascolta su una porta p una richiesta di connessione. Stabilita una connessione, il monitor realizza una connessione alla porta 80 del web server di destinazione. Il monitor inoltra tutti i messaggi ricevuti dal client al web server di destinazione (passato come argomento al monitor) e viceversa. Se o il client o il web server chiude una connessione, il monitor chiude la sua connessione sia al client che al server, scrivendo le informazioni di stato sullo standard error indicando il nome del client, l URL di destinazione, il numero di byte scritti ed il tempo impiegato dal momento in cui il monitor ha ricevuto la prima informazione dal client a quando la connessione è stata chiusa. Se il flag di verbose è ad 1, il monitor dovrebbe copiare tutto il traffico tra il client ed il web server su di un file. Testare il programma per accedere il monitor realizzato attraverso il proprio web browser. Supponendo di voler testare il proprio programma tramite ed il proprio numero di porta e' pari a 10355, si puo' eseguire il programma di monitor sulla macchina X come monitor informatica.uniparthenope.it 0 e nel proprio web browser eseguire lo stesso monitor tramite l URL con: Part II Modificare il monitor realizzato nella Parte I in modo che operi come un proxy e usi la redirezione HTTP per realizzare la connessione tra il client ed il server di destinazione. Non e' piu' necessario passare il web server di destinazione come argomento al monitor, ma e' necessario effettuare il parsing dell HTTP derivante dal client. Se il primo token non e' GET, chiudere tutte le connessioni e trattare la connessione come un errore. Dovrete estrarre l'indirizzo di web server della destinazione dall URL e scartare gli header proxy. Spiegare come la richiesta del cliente ad un proxy sia differente da una richiesta client ad un web server.

3 SPECIFICHE DI PROGETTO Descrizione generale: Un proxy è un programma che si interpone tra un client ed un server, inoltrando le richieste e le risposte dall'uno all'altro. Il client si collega al proxy invece che al server, e gli invia delle richieste. Il proxy a sua volta si collega al server e inoltra la richiesta del client, riceve la risposta e la inoltra al client. Un caso in cui viene spesso usato un proxy è la navigazione web (denominato proxy HTTP dal nome del protocollo usato). Per utilizzare un proxy è possibile configurare il client in modo che si colleghi al proxy invece che al server, in questo caso le connessioni HTTP vengono automaticamente indirizzate al proxy. Un proxy può essere usato per una o più delle seguenti ragioni: connettività: per permettere ad una rete privata di accedere all'esterno è possibile configurare un computer in modo che faccia da proxy tra gli altri computer e Internet, in modo da mantenere un unico computer connesso all'esterno, ma permettere a tutti di accedere. In questa situazione, solitamente il proxy viene usato anche come firewall. monitoraggio: un proxy può permettere di tenere traccia di tutte le operazioni effettuate (ad esempio, tutte le pagine web visitate), consentendo statistiche ed osservazioni dell'utilizzo della rete che possono anche violare la privacy degli utenti. controllo: un proxy può applicare regole definite dall'amministratore di sistema per determinare quali richieste inoltrare e quali rifiutare, oppure limitare l'ampiezza di banda utilizzata dai client, oppure filtrare le pagine Web in transito, ad esempio bloccando quelle il cui contenuto è ritenuto offensivo in base a determinate regole. privacy un proxy può garantire un maggiore livello di privacy mascherando il vero IP del client in modo che il server non venga a conoscenza di chi ha effettuato la richiesta. Nome del progetto Secondo il tipico stile GNU ho scelto un acronimo ricorsivo che indica la funzionalità dello stesso programma: Gisp G I S P I S I R S M O P P X L E Y Dato che è stato sviluppato tramite e per un sistema GNU\Linux. Lo stesso sorgente è stato compilato su varie distribuzioni GNU\Linux ed è risultato funzionante. Il programma accetta connessioni da ogni tipo di browser che effettui chiamate compatibili con lo standard : E risultato funzionante con Firefox, MS Internet Explorer e Netscape

4 Funzionamento del Main : Il server attende connessione da browser che inviano una richiesta di una pagina, il proxy deve rinviare le richieste al reale web-server. Il programma principale crea un socket principale atto ad attendere connessioni che resta sempre attivo per tutta la durata del programma. Dopo aver accettato la connessione si crea un processo figlio che ha al suo interno una procedura di gestione proxy o webmonitor e quando la transazione è terminata il processo figlio muore. Il tutto Segue il seguente schema: Procedura che serve le richieste La procedura riceve in input dal padre il FD del Socket_Client ed in caso di WebMonitor anche l indirizzo dove collegarsi. Crea il Socket Server che si connetterà al Web Server di riferimento e farà scambiare dati ai sue socket secondo il seguente metodo: Controllo dei File Descriptor Dato che si hanno piu' canali di comunicazione (server,client)aperti c'è il problema di controllarli contemporaneamente; Può succedere di rimanere bloccati in una operazione su un descrittore di socket non pronto mentre ce ne potrebbe essere un'altro disponibile, ritardando l'accesso a quest'ultimo e con il rischio di incorrere in un deadlock (se l'accesso al descrittore in attesa può essere sbloccato solo da qualcosa in arrivo su quello disponibile). POLLING Una soluzione abbastanza semplice sarebbe quella di rendere l'accesso ai socket non bloccante in modo che le relative funzioni ritornino subito (con errore EAGAIN) e prevedere un meccanismo ciclico di interrogazione di tutti i flussi dati verso il nostro processo. Questa soluzione, usa in modo molto inefficiente le risorse del sistema in quanto la maggior parte del tempo macchina è perso ad interrogare flussi che non hanno dati. I/O multiplexing Molto migliore è questa soluzione con la quale si controllano vari flussi contemporaneamente, permettendo di bloccare un processo quando le operazioni volute non sono possibili, e di riprenderne l'esecuzione una volta che almeno una sia disponibile. Il tutto viene realizzato con l'uso della funzione select() che ritorna il numero di file descriptor, che sono attivi, oppure -1 se c'è errore,.

5 Differenza trà WebMonitor e Proxy La fondamentale differenza è nel server dove il programma si deve collegare: WebMonitor Il WebMonitor è connesso ad un solo sito per tutta la sua durata e l indirizzo è passato come parametro Argv all atto di chiamata del programma. Proxy In questo caso non si hanno informazioni sul server di destinazione ed è necessario effettuare il parsing della richiesta HTTP che è nella forma : GET /wiki/pagina_principale HTTP/1.1 Connection: Keep-Alive User-Agent: Mozilla/5.0 (compatible; Konqueror/3.2; Linux) (KHTML, like Gecko) Accept: text/html, image/jpeg, image/png, text/*, image/*, */* Accept-Encoding: x-gzip, x-deflate, gzip, deflate, identity Accept-Charset: iso , utf-8;q=0.5, *;q=0.5 Accept-Language: en Host: it.wikipedia.org:eventuale_prota È necessario individuare ed estrarre il nome host effettuando il parsing, quando è stato trovato l indirizzo la procedura si comporta come nel caso del WebMonitor

6 MAN GISP NAME gisp proxy server and web monitor SYNOPSIS gisp [ mode] [ flag verbouse] [ port ] [address ] DESCRIPTION gisp is a low-performance proxy no caching server for web clients, no supporting FTP, gopher, and HTTPS data objects. gisp consists of a main server program that listen and serve all request, when gisp starts up, it go in listen mode, until a client make a request For details on how to configure gisp and for updates see the FAQ and the documentation at the gisp home page OPTIONS - mode You can chose between webmonitor or proxy - verbouse Enable logging to file, 1 for activate, 0 for not. - port Specify HTTP port number (range : [ ]). - address If You chose webmonitor, you must indicate the address of webserver FILES LogGispRicheste The main log file. Il the flag verbouse is on 0, it will not create. DIAGNOSTICS BUGS Normally, exit status is 0. But the exit status is 2 if an error occurred. bug reports to alanturing2@hotmail.com. Be sure to include the word "gisp" somewhere in the "Subject:" field.

7 MANUALE UTENTE Avviare il programma come Proxy Dopo aver compilato il programma con gcc gisp.c o gisp Per lanciarlo sulla porta 8080 tipica dei server proxy eseguire :./gisp proxy Terminarlo chiudendo la shell oppure con CTRL+C Avviare il programma come WebMonitor Dopo aver compilato il programma con gcc gisp.c o gisp Per lanciarlo sulla porta 8080 tipica dei server proxy e sul sito eseguire :./gisp webmonitor Terminarlo chiudendo la shell oppure con CTRL+C Con queste modalità si otterrà un file con i log, per non salvarli sostituire 1 con 0 Primo caso :./gisp proxy Secondo caso :./gisp webmonitor Impostare il client (Web Browser) Su ogni client che si collega a gisp deve essere impostato il proxy con l indirizzo IP dove è stato lanciato e la porta scelta. Per il webmonitor basta inserire come url per ottenera la pagina scelta

8 PROCEDURE AUSILIARIE E VARIABILI GLOBALI #include <arpa/inet.h> #include <netinet/in.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/socket.h> #include <unistd.h> #include <fcntl.h> #include <wait.h> #include <netdb.h> #include <errno.h> #include <ctype.h> #include <signal.h> #include <sys/types.h> #include <sys/file.h> #include <sys/ioctl.h> //VARIABILI GLOBALI int proxy=0; //Indica se il programma e' stato aperto come Proxy int webmonitor=0; //Indica se il programma e' stato aperto come Web Monitor int verbouse=0; //Indica se e' stato attivato il flag di log int porta=0; //Porta locale del server scelta dall'utente //Intercetta il segnale di fine processo figlio void elimina_zombie(int sig) {//Identifica gli zombie e li termina while(waitpid(wait_any, NULL, WNOHANG) > 0) ; return;} //Visualizza il messaggio di errore se si passano parametri errati void erroreinput(void) { printf("errore : Sintassi errata\n"); printf("uso: gisp proxy [FlagVerbouse] [porta] \n"); printf("oppure: gisp webmonitor [FlagVerbouse] [porta] [indirizzo] \n"); return; } //Restituisce l'ip nella struttura in_addr da un nomehost struct in_addr * ricava_ip_da_host(char * host) { struct hostent * a; struct in_addr add; } if(inet_aton(host,&add)) a=gethostbyaddr((char *)&add,sizeof(add),af_inet); else a=gethostbyname(host); return (struct in_addr *)a->h_addr_list[0];

9 PROCEDURA CHE SERVE UN CLIENT (1) void proxy_server(int client_socket,char *url_server) { int server_socket; //Socket server fd_set select_cli_serv; //insieme che contiene fdserver e fdclient struct timeval time_out; //Struttura contenente il time_out della select int log_richieste; //File contenente le richieste char buffer[2048]; //Buffer di R-W int size_buffer; //Size del buffer char porta_remota[10]="80"; //Porta del server web struct sockaddr_in address_c; //Struttura che contiene info sul server web //Variabili per il parsing nel proxy char *punt_inizio; //Punta all'inizio della stringa char *punt_fine; //Punta alla fine della stringa char *punt_duepunti; //Punta agli eventuali : nella richiesta char host_parsing[32]={"\0"}; //Contiene l'host dopo il parsing char nome_host[64]; //nome host provvisorio prima del controllo dei : if (verbouse){ if((log_richieste=open("loggisprichieste",o_append O_CREAT O_WRONLY,0644))<0){ printf("errore di apertura file"); exit(1);}} memset(buffer,'\0',sizeof(buffer)); //Azzera il buffer if (proxy){ memset(nome_host,'\0',sizeof(nome_host)); //Azzera la var. che conterra' l indi. dove collegarsi //Legge la prima richiesta del client in buffer if((size_buffer = read(client_socket,buffer,sizeof(buffer))) <= 0) exit(1); //Parsing richiesta FORMATO : " GET [indirizzo] \t\n\r " //Se non e' GET esce e stampa l'errore if (((buffer[0]!='g')&(buffer[1]!='e'))&(buffer[2]!='t')) { exit(0);} //Parsing richiesta HOST FORMATO : " HOST [indrizzo_host] \t\n\r " punt_inizio=strstr(buffer,"host: ");//Trova la prima occorrenza di HOST nella richiesta punt_inizio=punt_inizio+6; //Si sposta al nome_host di 4 lettere : HOST [nome_host] punt_fine=strpbrk(punt_inizio,"\t\n\r"); //punt_fine punta alla fine del nome_host //Copia il nome host contenuto in punt_inizio in nome_host memcpy(nome_host,punt_inizio,(int)(punt_fine-punt_inizio)); //Dopo HOST puo' essere nel formato "HOST [nome_host]:[porta_remota]" //Se nel nome_host non ci sono : il risultato e' lo stesso nome_host punt_duepunti=strchr(nome_host,':'); //Cerca la prima occorrenza di : if(!(punt_duepunti)) strcpy(host_parsing,nome_host); else{ memcpy(host_parsing,nome_host,(int)(punt_duepunti-nome_host)); //Copia fino al : host_parsing[(int)(punt_duepunti-nome_host)+1]='\0'; //Imposta il terminatore di stringa strcpy(porta_remota,(punt_duepunti+1));} //Dopo i : e' contenuta la porta remota (80) }//FINE parsing address_c.sin_family=af_inet; address_c.sin_port=htons(atoi(porta_remota)); if (proxy){ //host_parsing e' l'indirizzo ricavato dalla richiesta memcpy(&address_c.sin_addr,ricava_ip_da_host(host_parsing),sizeof(address_c.sin_addr));} if (webmonitor){ //Url_server viene passato alla funzione con argv[4] memcpy(&address_c.sin_addr,ricava_ip_da_host(url_server),sizeof(address_c.sin_addr));} //Crea il socket verso il webserver if((server_socket = socket(af_inet,sock_stream,0)) < 0){ printf("\nerrore: creazione socket\n"); exit(1);} //Connette il socket al webserver di indirizzo address_c if( connect(server_socket,(struct sockaddr *) &address_c, sizeof(address_c))<0){ printf("\nerrore: connessione\n"); exit(1);} //inoltra la prima richiesta del client al webserver if(webmonitor){ if((size_buffer = read(client_socket,buffer,sizeof(buffer))) <= 0) exit(1);} write(server_socket,buffer,size_buffer); //Log della prima richiesta if (verbouse){ write(log_richieste,buffer,size_buffer); //File di log close(log_richieste);}

10 } PROCEDURA CHE SERVE UN CLIENT (2) FD_ZERO(&select_cli_serv); //Inizializza l'insieme select_cli_serv FD_SET(client_socket,&select_cli_serv); //Aggiunge il client all'insieme select_cli_serv FD_SET(server_socket,&select_cli_serv); //Aggiunge il server all'insieme select_cli_serv while(1){ int conto=0; //Controlla se in un ciclo e' stata effettuata almeno una R o W time_out.tv_sec = 1; //secondi di attesa time_out.tv_usec = 0; //microsecondi di attesa //Imposta la select su select_cli_serv e il timeout if(select(fd_setsize,&select_cli_serv,null,null,&time_out) < 0){ printf("\nerrore : Select\n"); exit(1);} //Se Il client ha mandato dati li legge e li scrive al server if(fd_isset(client_socket,&select_cli_serv)){ if((size_buffer = read(client_socket,buffer,sizeof(buffer))) <= 0) exit(0); write(server_socket,buffer,size_buffer);} else conto=1; //Memorizza che non e' stato letto niente dal client //Se Il server ha mandato dati li legge e li scrive al client if(fd_isset(server_socket,&select_cli_serv)){ if((size_buffer = read(server_socket,buffer,sizeof(buffer))) <= 0) exit(0); write(client_socket,buffer,size_buffer);} else conto=conto+1;//memorizza che non e' stato letto niente dal server if (conto==2) exit(1);//termina se non ha letto niente dal client e dal server }//end while(1) //Chiude tutti i FD close(server_socket); //Server close(client_socket); //Client if (verbouse) close(log_richieste); //File di log

11 int main(int argc,char ** argv) { struct sockaddr_in Ind_Loc; //Indirizzo locale struct sockaddr_in Ind_Rem; //Indirizzo remoto int socket_primario; //Socket che resta sempre in attesa di connessioni int client_sock; //Socket dei client che richedono connessioni int riutilizza=1; //Imposta le opzioni di riutilizzo per il socket primario unsigned int SizeIndRem; //Unsigned Per non avere il warning nella accept pid_t chpid; //PID del figlio signal(sigchld, elimina_zombie); //CONTROLLO SULL'INPUT //Numero Parametri if((argc<4) (argc >5)){printf("Numero parametri errati!\n");erroreinput(); exit(0);} //Primo parametro PROXY o WEBMONITOR if(strcmp(argv[1],"proxy")==0) proxy=1; else if(strcmp(argv[1],"webmonitor")==0) webmonitor=1; else {printf("scegli la tipologia corretta!\n");erroreinput(); exit(0);} //Secondo parametro flag verbouse LogGispRichieste if(strcmp(argv[2],"1")==0) verbouse=1; else if(strcmp(argv[2],"0")==0) verbouse=0; else {printf("scegli correttamente il flag verbouse!\n");erroreinput(); exit(0);} //Terzo parametro porta range [ ] porta=atoi(argv[3]); if((porta<1) (porta >65534)){printf("Range porta errato [ ]!\n");erroreinput(); exit(0);} //OUTPUT degli input passati come parametri printf("\nattivato CORRETTAMENTE COME : "); if (webmonitor) printf("webmonitor sull'indirizzo %s \n",argv[4]); if (proxy) printf("proxy\n"); if (verbouse) printf("i log verranno salvati nel file LogGispRichieste \n"); if (!(verbouse)) printf("i log non verranno salvati \n"); printf("in ascolto sulla porta %d \n",porta); //Imposta i dati del server sul quale e' stato lanciato il proxy Ind_Loc.sin_family=AF_INET; Ind_Loc.sin_port=htons(porta); //La porta e' data in input memset(&ind_loc.sin_addr,0,sizeof(ind_loc.sin_addr)); //Crea il socket primario che attende le connessioni dai figli if((socket_primario=socket(af_inet,sock_stream,0))<0){ printf("socket error\n"); exit(1); } //imposta le opzioni generiche per il socket_primario //SOL_SOCKET permette di operare su un socket di tipo generico //SO_REUSEADDR permette di riutilizzare l'indirizzo //L'opzione e' impostata ad : i=1 setsockopt(socket_primario,sol_socket,so_reuseaddr,&riutilizza,sizeof(riutilizza)); //BIND con l'indirizzo locale if(bind(socket_primario,(struct sockaddr *)&Ind_Loc,sizeof(Ind_Loc))){ printf("errore in bind\n"); exit(1); } //LISTEN attende la connessione del primo client //Pone il server primario in attesa passiva con una coda massima di 5 client if(listen(socket_primario,5)){ printf("errore in listen\n"); exit(1); } SizeIndRem=sizeof(Ind_Rem); //Ciclo che accetta le connessioni while(1) { //ACCEPT Il client viene memorizzato su client_sock //client_sock : contiene il FD del client connesso client_sock=accept(socket_primario,(struct sockaddr *)&Ind_Rem,&SizeIndRem); if(client_sock<0 ) //Controllo errore { printf("errore : in accept \n"); exit(1); } //FORK if(!(chpid=fork())){ //CODICE DEL FIGLIO close(socket_primario); //Chiude il socket del padre proxy_server(client_sock,argv[4]); //Avvia il proxy exit(1); //Termina il figlio } close(client_sock); //chiude la connessione con il client che e' stato gia' servito } return 0; }