J'ai eu un sujet d'interro sur ce thème :
Ecrire un programme qui réalise le traitement suivant :
- Un processus père crée successivement 2 processus fils puis se met en attente de leur terminaison. Chaque fois qu?un processus fils se termine, le père affiche sur la sortie standard e PID et le mot d?état (statut ou numéro du signal) retourné par ce fils.
- Le premier fils affiche sur la sortie standard son PID, puis se termine normalement par l?instruction « exit » en retournant un statut égal à 3.
- Le second fils affiche sur la sortie standard son PID, puis se termine anormalement en tentant une écriture en mémoire à l?adresse pointée par NULL.
Le programme source sera codé dans le fichier proc1.c et le programme exécutable sera codé dans le fichier proc1.
Et voilà ce que j'ai réalisé, ce qui me semble tout à fait juste ... jvous dit pas combien de temps il m'a fallu pour faire ça ... j'ai honte .......
\\PROGRAMME SOURCE PROCESSUS/EXERCICE1/proc1.c:
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <signal.h>
int main ()
{
// déclaration des variables
pid_t pid;
pid_t pid2;
pid_t idProc;
int rapport;
int numSig;
int statut;
// déclaration du pointeur d?adresse
int * toto = NULL;
// création d?une copie du processus père grâce à fork()
// envoi du résultat de la fonction dans la variable pid
// la fonction retourne 0 dans le processus fils et le pid du fils dans le
// processus père
pid = fork();
switch (pid)
{
// si le contenu de pid =-1 il s?est produit une erreur
case -1 :
printf("erreur\n" );
exit(-1);
break;
case 0 :
// le fils 1 affiche son pid et retourne un statut égal à 3
printf("je suis le fils1 %d\n",getpid());
exit(3);
break;
default :
// le père affiche le pid du fils et le sien
printf("je suis le processus père, j ai crée le fils %d\n",pid);
printf("et mon numéro de pid père est %d\n",getpid());
}
// création d?un second processus fils
pid2 = fork();
// comme auparavant, analyse du contenu de la variable pid2 pour
// détecter le fils2 du père
switch (pid2)
{
case -1 :
printf("erreur\n" );
exit(-2);
break;
case 0 :
// le fils2 affiche son pid et se termine anormalement en tentant d?écrire 10
// dans une adresse égale à NULL
printf("je suis le fils2 %d\n",getpid());
* toto = 10;
exit(4);
break;
default :
printf("je suis toujours le processus père, j ai crée le fils %d\n",pid2);
printf("et mon numéro de pid père est toujours %d\n",getpid());
}
// wait() va nous permettre de suspendre l?exécution du père en attendant qu?un
// de ces fils se termine, cette fonction retournera 0 si le fils s?est terminé // correctement et un signal sinon
idProc = wait(&rapport);
// Tant que les processus fils n?ont pas étés détruits on traite le signal
// envoyé par les fils
while (idProc != -1)
{
numSig = rapport % 128;
switch (numSig)
{
// cas probable du fils1
case 0: /*fin normale*/
statut=(rapport % 65536)/256;
printf("fin normale \n" );
break;
// cas probable du fils2
default: /*fin anormale*/
printf("fin anormale \n" );
break;
}
idProc=wait(&rapport);
}
}
Donc à priori ça marche .... seul pb , je dois modifier ce programme pour un TP(j'imagine le remanier à fond) pour réaliser un algo en C qui permette lors d'une déconnexion du shell d'envoyer à tous les procesus ayant l'utilisateur comme propriétaire effectif le signal SIGTERM, puis il attend qu'il se terminent tous avant de se terminer lui-même ....
Avec juste un polycop de C et quleques algos, je vois pas trop comment je peux faire ça ....
Je ne vous demande PAS de me faire le soft, j'aimerais juste savoir vers quelle solution m'orienter, en gros un algo général en français m'aiderait énormément.
Merci à tous d'avance.
[jfdsdjhfuetppo]--Message édité par 404notfound le 11-05-2002 à 14:41:08--[/jfdsdjhfuetppo]
