Table des matières

1. Un programme, un processus (1 point)

1.1. Générateur de nombre aléatoires

• Ouvrir deux fenêtres Terminal que nous appelleront Term1 et Term2.
• Écrire dans le fichier server_11.c un programme C contenant un main() qui :
  • affiche un message avec printf()
  • puis, dans une boucle infinie :
    • affiche son id (numéro de processus, utilisez getpid()), celui de son père (getppid()), ainsi que celui de son groupe (getpgrp())
    • affiche un nombre aléatoire entre 0 et 99 obtenu avec rand()
    • se met en pause pendant une seconde grâce à sleep()
  • affiche de nouveau un message (après la boucle)
  • retourne le code EXIT_SUCCESS indiquant un fonctionnement nominal.

• Dans Term1, compiler et exécuter ce programme.
• Dans Term2, taper la commande ps aj. Identifier votre processus dans la liste, quel est son processus père ? Que constatez-vous pour les numéros de groupe ? Quel est son état (colonne STAT) ?

• Dans Term1, arrêter le programme en utilisant la combinaison de touches CTRL-C, puis vérifier dans Term2 qu'il n'apparait plus dans la liste affichée par la commande ps aj.
• Dans Term1, relancer le programme et le suspendre en utilisant la combinaison de touches CTRL-Z. Quel est l'état du processus ?
• Dans Term1, taper la commande fg. Quel est son effet ?
• Dans Term1, suspendre de nouveau le processus puis taper la commande bg. Quel est son effet ? Quel est l'état du processus ?
• Dans Term1, exécuter une seconde fois votre programme en suffixant la commande de lancement avec le caractère  & . Quel est l'effet de ce caractère ?
• Dans Term1, taper la commande fg puis CTRL-C, le refaire. Est-ce que les deux processus sont bien arrêtés ?

1.2. Non arrêt sur CTRL-C

CTRL-C a pour conséquence l'envoi d'un signal au processus. Par défaut, ce signal provoque l'arrêt du processus. Nous souhaitons changer ce comportement.

• Recopier votre programme dans le fichier server_12.c.
• Définir une fonction qui reçoit un numéro de signal (un int) et affiche un message contenant le numéro du signal reçu. Installer cette fonction, en utilisant sigaction(), pour qu'elle soit automatiquement exécutée sur réception du signal envoyé par CTRL-C. Vous utiliserez bien sûr le nom symbolique du signal.

• Dans Term1, compiler et exécuter ce programme, essayer de l'arrêter avec CTRL-C, vérifier que le message de votre fonction est affiché mais que le processus continue son exécution.
  
• Quelle est la valeur du signal envoyé par CTRL-C ?
• Dans Term2, taper kill id où id est le numéro de processus de votre programme (kill est la commande, id son argument). Quelle est la conséquence de cette commande ?
  

• Dans Term1, exécuter de nouveau votre programme ; dans Term2, utiliser la commande kill avec l'option -s INT (l'option doit être indiquée avant l'argument). Quelle est la conséquence de cette variante ?
  
• Modifier votre programme pour obtenir le même comportement (affichage d'un message et pas d'arrêt) dans les deux cas. Dans Term1, exécuter de nouveau votre programme ; comment l'arrêter ? Est-il possible d'intercepter tous les signaux de façon à ce qu'il ne soit plus possible d'arrêter un processus ?

1.3. Choix du signal pour l'arrêt

Le choix suivant est effectué : les deux signaux provoquent l'affichage d'un message via la fonction installée avec sigaction(), mais seul kill sans option stoppe le processus.

• Recopier votre programme dans le fichier server_13.c.
• Modifier votre boucle pour qu'elle ne s'exécute que tant qu'une variable booléenne globale running soit vraie (cette variable doit être vraie au démarrage de votre programme). Modifier votre fonction qui est appelée sur réception d'un signal pour réaliser le comportement souhaité.

• Dans Term1, compiler et exécuter ce programme, essayer de l'arrêter le en utilisant CTRL-C, puis arrêter le avec kill, vérifier que le message de votre fonction est affiché dans les deux cas.
  

1.4. Message de fin

• Recopier votre programme dans le fichier server_14.c.
• Ajouter dans votre programme une fonction qui affiche un message. Installer cette fonction au début de main(), en utilisant atexit(), pour qu'elle soit automatiquement exécutée à la fin du programme. Tester si cette fonction est toujours activée quelle que soit la façon dont le programme est arrêté.

2. Un programme, deux processus (1 point)

2.1. Même code

• Recopier votre programme dans le fichier server_21.c.
• Modifier le pour que le processus s'arrête maintenant aussi avec un CTRL-C.
• Dupliquer votre processus en utilisant fork(). Les 2 processus exécutent le même programme, faites en sorte que les messages précisent s'ils sont émis par le père ou par le fils (mais éviter de dupliquer du code !)
• Que constatez-vous pour les numéros de groupe ? Est-ce que les 2 processus s'arrêtent avec CTRL-C ? Pouvez-vous expliquer pourquoi ?

• Relancer votre programme. Utiliser ps aj dans Term2 pour les visualiser. Utiliser kill pour arrêter le processus fils puis ps aj de nouveau : que remarquez-vous ?
• Maintenant, tuer le père, est-ce que le fils est toujours visible ?
• Modifier votre code pour que le père s'arrète quand il détecte (via un signal) que le fils s'est arrêté.
• Relancer votre programme et commencer cette fois par tuer le père : qu'observez-vous ?
• Tuer le fils.
• Modifier votre programme pour que le père, quand il est arrêté par un signal, arrête le fils en lui envoyant un signal avec kill().

2.2. Un serveur, un client, un tube

Le père et le fils vont maintenant exécuter un code différent : au lieu d'afficher les nombres, le père va les communiquer (en tant que nombres - int -, pas sous forme de chaînes de caractères, et sans utiliser une valeur particulière pour indiquer la fin de la communication) au fils qui, lui, les affichera. La communication se fera via un « tube ».

• Recopier votre programme dans le fichier server_22.c.
• Supprimer l'arrêt du fils par le père et celui du père par le fils : les 2 processus vont maintenant communiquer par un tube, ils seront ainsi en mesure de détecter l'arrêt de l'autre.
• Créer un tube en utilisant pipe() et modifier le code pour réaliser le comportement demandé. Vous utiliserez read() pour lire et write() pour écrire dans le tube.

• Vérifier que les processus s'arrêtent avec CTRL-C, ainsi qu'avec un kill sur le fils ou sur le père.

• Comparer les messages affichés quand on arrête le père en premier, et ceux quand on arrête le fils en premier. Faire en sorte que le père affiche aussi son message de fin quand on arrête le fils en premier.

3. Deux programmes, deux processus (0,5 point)

3.1. Un serveur, un client, une fifo

Les deux processus seront maintenant des programmes différents (un serveur server_31.c qui envoie des nombres, pas des caractères, à un client client_31.c). Pour communiquer, ils utiliseront un « tube nommé » ou fifo.

• Créer une fifo nommée à l'aide de la commande shell mkfifo.
• En reprenant votre code précédent, écrire deux programmes distincts qui communiquent via la fifo. Celle-ci sera ouverte en utilisant open() (en écriture seule par le serveur, en lecture seule par le client). Dès qu'un des deux processus sera arrêté, l'autre devra s'arrêter aussi (en affichant ses messages d'arrêt).

4. Partie avancée (1,5 point)

4.1. Sécurité de la fonction installée par sigaction()

La page async-signal-safe functions nous indique que l'utilisation de printf() dans la fonction installée par sigaction() n'est pas une bonne idée.

• Recopier le programme du fichier server_13.c dans un fichier server_41.c.
• Proposer une solution pour assurer la sécurité sans changer le comportement visible.

4.2. Un serveur, un client, le réseau

Les deux processus sont toujours des programmes différents (un serveur server_42.c qui envoie des nombres à un client client_42.c), mais, pour communiquer, ils utiliseront une connexion réseau.

• En reprenant votre code de la question 3.1, écrire deux programmes distincts qui communiquent via TCP.
  • Le serveur commencera par créer une extrémité de communication avec socket() en utilisant le domaine IPv4, une communication de type flux et le protocole associé par défaut. Il ne faudra pas oublier de faire les conversions entre la représentation machine et la représentation réseau à l'aide des fonctions htonl() et htons(). En utilisant bind(), le serveur associera ce socket à une adresse IPv4 de socket sur toutes les interfaces locales et en utilisant un numéro de port non privilégié qu'il faudra choisir. Il pourra alors attendre, en utilisant listen(), la demande d'ouverture de connexion par le client, l'accepter avec accept() et enfin lui envoyer des nombres aléatoires avec write().
  • Le client créera aussi une extrémité de communication du même type. Il utilisera connect() pour se connecter au serveur sur l'adresse de loopback, et pourra ainsi recevoir les nombres générés par le serveur avec read().