Skip to content


Come programmare le socket in ambienti GNU/Linux (Parte 2)

Nel primo articolo abbiamo analizzato il funzionamento delle socket e di un server con rispettivo client. In questo vedremo un modo di programmare un tipico server concorrente utilizzando la funzione fork().

Prima di addentrarci nel codice del server concorrente, vediamo un po' come funziona la tecnica di forking.

Forking

Schema del forking di un'applicazione

Il forking consente di effettuare delle copie di un processo. Il processo che genera copie di se stesso si chiama processo padre, mentre la copia viene chiamata processo figlio. Fork in inglese significa “forchetta”, il termine non rispecchia altro che il comportamento di questa operazione. Infatti si può associare al manico di una forchetta il processo padre e ad ogni rebbio si può associare un processo figlio.

Bisogna fare attenzione ad usare il forking. Il processo quando genera un figlio, le variabili ed altre risorse non vengono condivise.

Qui a lato è mostrato uno schema che riassume sinteticamente il funzionamento di questa tecnica. In un certo punto del programma si effettua una chiamata alla funzione fork che divide il programma in due, tale funzione:

  • se ha esito negativo restituisce -1, in questo caso non viene generato alcun processo figlio ed errno viene settata;
  • se ha esito positivo restituisce 0 al processo figlio, mentre al processo padre viene restituito il PID (Process ID) del processo figlio.

Dato che non è scopo dell'articolo illustrare nel dettaglio la tecnica di forking, si rimanda al seguente link [in inglese] per eventuali approfondimenti.

Esempio di forking del processo

Di seguito è presente un piccolo codice che metterà in pratica il concetto di forking. Nel codice c'è una variabile che apparentemente sembra essere condivisa.

  1. #include < stdio.h >
  2. #include < stdlib.h >
  3. #include < unistd.h >    /* fork */
  4. #include < sys/types.h >    /* pid_t */
  5. int main(void) {
  6. pid_t pid; /* ID del processo figlio*/
  7. int i;
  8.  
  9. pid = fork();
  10.  
  11. if(pid == 0) { /* Processo figlio */
  12. for(i = 2; i <= 20; i+=2) {
  13. printf("Processo figlio:\t%d\n", i);
  14. sleep(1);
  15. }
  16. } else if(pid > 0) { /* Processo padre */
  17. for(i = 1; i <= 10; i++) {
  18. printf("Processo padre: %d\n", i);
  19. sleep(1);
  20. }
  21. } else { /* Errore */
  22. fprintf(stderr, "Errore nel fork\n");
  23. exit(-1);
  24. }
  25.  
  26. return 0;
  27. }

Il codice crea un processo figlio che calcola la tabellina del due, mentre il padre conta fino a 10. I due processi sono eseguiti in parallelo, per capire meglio che sono due processi distinti, nel codice, la variabile i è usata sia dal padre che dal figlio senza entrare in conflitto. Infatti nel momento che si effettua la chiamata fork i due processi sono allocati in due zone di memoria diverse, quindi ogni processo avrà la sua variabile i.

Di seguito c'è l'output del programma eseguito sul mio computer.

alessandro@debian-vm:~/Desktop$ gcc -std=c89 fork.c -o fork
alessandro@debian-vm:~/Desktop$ ./fork
Processo figlio:        2
Processo padre: 1
Processo padre: 2
Processo figlio:        4
Processo figlio:        6
Processo padre: 3
Processo figlio:        8
Processo padre: 4
Processo padre: 5
Processo figlio:        10
Processo figlio:        12
Processo padre: 6
Processo figlio:        14
Processo padre: 7
Processo padre: 8
Processo figlio:        16
Processo figlio:        18
Processo padre: 9
Processo figlio:        20
Processo padre: 10
alessandro@debian-vm:~/Desktop$

L'ordine nel quale vengono eseguiti i processi viene stabilito dallo scheduler.

Server concorrente

Un server concorrente è un server che ha la possibilità di accettare più connessioni contemporanee da parte dei client. La base del funzionamento è la stessa del server sequenziale (per approfondimenti si veda l'articolo precedente), ma con una lieve modifica:

  1. Creare una socket
  2. Effettuare il binding della socket
  3. Mettere in ascolto la socket
  4. Accettare la connessione da parte del client
  5. Copia del processo tramite fork()
  6. Effettuare la comunicazione tramite le funzioni recv() e send

Il passo scritto in neretto è quello che si andrà ad analizzare più avanti in questo articolo. Il server concorrente appena accetta una connessione da parte del client si sdoppia.

Il codice

Il codice cambia rispetto a quello dell'articolo precedente in due parti:

  1. Il server è ovviamente gestito diversamente perché genera i processi figlio.
  2. Ogni client può dialogare con il server inviando più messaggi. Per disconnettere il client dal server è possibile farlo inviando la stringa EXIT.

Se si vuole mettere il server in ascolto per più client, si deve creare quindi un loop. Si può fare in questo modo:

  1. while(1) {
  2. sd_client = accept(sd_server, (struct sockaddr *)&client_addr, &address_size);
  3. if(sd_client < 0) {
  4. printf("Errore nella chiamata accept\n");
  5. exit(-1);
  6. }
  7. }

Ora c'è bisogno di dividere il processo principale, ogni processo figlio gestirà la comunicazione con il rispettivo client:

  1. pid = fork();
  2.  
  3. if(pid == 0) { /* figlio */
  4. } else if(pid > 0) { /* padre */
  5. close(sd_client);
  6. } else {
  7. printf("Errore nella creazione del figlio\n");
  8. exit(-1);
  9. }

Il server accetta la chiamata da parte del client e si divide. Al processo padre ora non serve più la socket del client, perché verrà gestita dal processo figlio. Non può mancare anche la visualizzazione di un messaggio di errore se fallisce il forking del processo. Il codice a questo punto è il seguente:

  1. while(1) {
  2. sd_client = accept(sd_server, (struct sockaddr *)&client_addr, &address_size);
  3. if(sd_client < 0) { printf("Errore nella chiamata accept\n"); exit(-1); } pid = fork(); if(pid == 0) { /* figlio */ } else if(pid > 0) { /* padre */
  4. close(sd_client);
  5. } else {
  6. printf("Errore nella creazione del figlio\n");
  7. exit(-1);
  8. }
  9. }

Si passa ora alla gestione del client, all'interno del blocco if si inseriscono le seguenti righe:

  1. if(pid == 0) { /* figlio */
  2. close(sd_server);
  3. recv(sd_client, buff, sizeof(buff), 0);
  4. printf("Dati ricevuti: %s", buff);
  5. strcpy(buff, "Tutto OK!\n");
  6. send(sd_client, buff, strlen(buff), 0);
  7. close(sd_client);
  8. exit(0);
  9. }

La socket del server è possibile chiuderla anche dopo (si ricorda che non è la stessa socket del processo padre, ma semplicemente una copia). Effettuate le operazioni di ricezione ed invio si chiude la socket del client ed il processo figlio, utilizzando exit(0).

Il server è finito, per completarlo si potrebbe rendere ciclico il dialogo con il client:

  1. if(pid == 0) { /* figlio */
  2. close(sd_server);
  3.  
  4. while(1) {
  5. memset(buff, '\0', MAX); /* si cancellano i dati ricevuti in precedenza */
  6. recv(sd_client, buff, sizeof(buff), 0);
  7. printf("Dati ricevuti: %s", buff);
  8. strcpy(buff, "Tutto OK!\n");
  9. send(sd_client, buff, strlen(buff), 0);
  10. }
  11.  
  12. close(sd_client); /* disconnessione */
  13. exit(0); /* chiude il processo */
  14. }

Bene, si hanno un client ed un server che interagiscono ciclicamente, l'unico problema è che andranno avanti fino all'infinito finché non cade la connessione o arrestando forzatamente uno dei due processi. Per rimediare a questo, basta inserire un controllo nel while:

  1. if(pid == 0) { /* figlio */
  2. close(sd_server);
  3. char tmp_string[MAX]; /* servirà per capire se chiudere o meno la connessione con il client */
  4.  
  5. while(strcmp(tmp_string, "EXIT\r\n") != 0) { /* se si riceve il comando EXIT, termina il ciclo */
  6. memset(buff, '\0', MAX); /* si cancellano i dati ricevuti in precedenza */
  7. memset(tmp_string, '\0', MAX);
  8. recv(sd_client, buff, sizeof(buff), 0);
  9. strcpy(tmp_string, buff);
  10. printf("Dati ricevuti: %s", buff);
  11. strcpy(buff, "Tutto OK!\n");
  12. send(sd_client, buff, strlen(buff), 0);
  13. }
  14.  
  15. close(sd_client); /* disconnessione */
  16. exit(0); /* chiude il processo */
  17. }

Quando al server arriva la stringa EXIT, il client viene disconnesso ed il server si mette in ascolto per un'altra connessione. Avrete notato che manca il codice del client, infatti per collegarsi al server basta eseguire da terminale il seguente comando:

telnet 127.0.0.1 1745

Provate ad aprire più connessioni con telnet e vedere come le gestisce il server. Questo è tutto, alla prossima!

Scarica il codice completo.

Be Sociable, Share!

Posted in C.


6 Responses

Stay in touch with the conversation, subscribe to the RSS feed for comments on this post.

  1. Antonio Barba says

    grande Alessandro :-)

  2. Alessandro Iezzi says

    Grazie Antonio! :D

  3. LtWorf says

    C’è un problema: non vengono menzionati i wait, e quindi un uso prolungato di un server che fa fork senza mai fare wait tenderà a riempire la tabella dei processi di zombie, con conseguente impossibilità di avviare ulteriori processi e nel caso estremo il blocco del sistema.

    Si deve ascoltare il segnale SIGCHILD che viene inviato quando un figlio termina ed eseguire una wait durante la sua gestione, per eliminare il processo zombie dalla tabella dei processi.

  4. Alessandro Iezzi says

    @LtWorf
    Ciao, so benissimo che genererà zombie fino a quando non verrà fermato il server.
    Purtroppo, non è un corso di sistemi operativi e l’articolo vuole far capire a grandi linee come funziona un server concorrente.
    Comunque può essere lo spunto per un prossimo articolo… :D

  5. LtWorf says

    Eh ma dovresti menzionare questo fatto e magari dire che approfondirai successivamente come fare per risolvere questo problema.

    • Antonio Barba says

      LtWorf hai assolutamente ragione :-)

      Per utilizzi reali questo codice non va bene. Diciamo che è un proof of concept, per illustrare i fondamenti. Il target di queste guide comunque non è il programmatore avanzato, ma l’amministratore di sistema che vuole approfondire un po’ la propria conoscenza sul funzionamento dei programmi che utilizza ogni giorno :-)



Some HTML is OK

or, reply to this post via trackback.