Examen Réseau — Rattrapage

i. Le sujet

↗ Sujet en plein écran

1. Questions de cours (5 points)

2. Exercice 1 — Fork avec wait/waitpid et code de retour (6 pts)

fork1.c — version avec wait

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(void) {
   pid_t pid = fork();

   if (pid == -1) {                       // vérification du fork
      perror("fork");
      exit(EXIT_FAILURE);
   }

   if (pid > 0) {                          // ─── PÈRE ───
      printf("Père : PID=%d PPID=%d PID_fils=%d\n",
             getpid(), getppid(), pid);
      wait(NULL);                          // attente du fils
      printf("Père : le fils est terminé.\n");
   } else {                              // ─── FILS ───
      printf("Fils : PID=%d PPID=%d\n", getpid(), getppid());
   }
   return EXIT_SUCCESS;
}

fork2.c — variante avec waitpid

if (pid > 0) {                          // PÈRE
   printf("Père : PID=%d PPID=%d PID_fils=%d\n",
          getpid(), getppid(), pid);
   waitpid(pid, NULL, 0);              // attend ce fils précis
   printf("Père : le fils %d est terminé.\n", pid);
}

Q3 — Afficher le code de retour avec WIFEXITED / WEXITSTATUS

int status;

if (pid > 0) {                          // PÈRE
   printf("Père : PID=%d PPID=%d PID_fils=%d\n",
          getpid(), getppid(), pid);
   waitpid(pid, &status, 0);

   if (WIFEXITED(status)) {              // le fils est sorti normalement
      printf("Père : code de retour du fils = %d\n",
             WEXITSTATUS(status));
   } else {
      printf("Père : le fils a été interrompu (signal, etc.)\n");
   }
} else {                              // FILS
   printf("Fils : PID=%d PPID=%d\n", getpid(), getppid());
   exit(42);                            // code arbitraire pour démo
}

3. Exercice 2 — N threads paramétriques (4 pts)

Programme qui crée n threads (n passé en argument), chacun affiche un message, le main attend la terminaison.

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

void* worker(void* arg) {
   int id = *(int*)arg;
   printf("hello world ! (thread n°%d)\n", id);
   return NULL;
}

int main(int argc, char** argv) {
   if (argc != 2) {
      fprintf(stderr, "Usage : %s <nombre_de_threads>\n", argv[0]);
      exit(EXIT_FAILURE);
   }
   int n = atoi(argv[1]);
   pthread_t* threads = malloc(n * sizeof(pthread_t));
   int* ids = malloc(n * sizeof(int));

   for (int i = 0; i < n; i++) {
      ids[i] = i;
      pthread_create(&threads[i], NULL, worker, &ids[i]);
   }

   for (int i = 0; i < n; i++) {
      pthread_join(threads[i], NULL);
   }

   free(threads);
   free(ids);
   return EXIT_SUCCESS;
}

Compilation : gcc threads.c -lpthread -o threads. Exemple : ./threads 5.

4. Exercice 3 — Client/serveur TCP (5 pts)

Q1 — Compléter le client TCP

Les zones manquantes, dans l'ordre :

// 1. socket de communication
sock = socket(AF_INET, SOCK_STREAM, 0)

// 2. famille
serveur.sin_family = AF_INET

// 3. connect
connect(sock, (struct sockaddr*)&serveur, sizeof(serveur)) < 0

// 4. write
ret = write(sock, buf_write, strlen(buf_write))

// 5. read
ret = read(sock, buf_read, sizeof(buf_read))

Q2 — Code du serveur TCP

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main(int argc, char** argv) {
   int ecoute, dialogue;
   struct sockaddr_in serveur, client;
   socklen_t len = sizeof(client);
   char buf[256];

   if (argc != 2) {
      fprintf(stderr, "Usage : %s <port>\n", argv[0]);
      exit(1);
   }

   if ((ecoute = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
      perror("socket"); exit(1);
   }

   serveur.sin_family      = AF_INET;
   serveur.sin_port        = htons(atoi(argv[1]));
   serveur.sin_addr.s_addr = INADDR_ANY;

   if (bind(ecoute, (struct sockaddr*)&serveur, sizeof(serveur)) < 0) {
      perror("bind"); exit(1);
   }
   listen(ecoute, 5);
   printf("Serveur en écoute sur le port %s...\n", argv[1]);

   while (1) {
      dialogue = accept(ecoute, (struct sockaddr*)&client, &len);
      printf("Client connecté : %s:%d\n",
              inet_ntoa(client.sin_addr), ntohs(client.sin_port));

      int n;
      while ((n = read(dialogue, buf, 255)) > 0) {
         buf[n] = '\0';
         printf("Reçu : %s\n", buf);
         write(dialogue, buf, n);              // renvoie en écho
      }
      close(dialogue);
      printf("Client déconnecté.\n");
   }
   close(ecoute);
   return 0;
}

Pour gérer plusieurs clients simultanés : fork() juste après accept (cf. annales Session Normale).

★ Notions ré-activées