Discussion :

[nioney]

Bonjour tout le monde ,
je suis nouveau dans la programmation C sous Linux .
j'ai un petit problème , je veux écrire un programme ou un père crée un processus fils , le père traite une chaine de caractère de 0 et 1 , il envoi SIGUSR1 a son fils s'il rencontre un 0 et SIGUSR2 s'il rencontre 1 et le fils s'il reçoit SIGUSR1 il affiche bit0 reçu sinon il affiche bit1 reçu .
j'ai essayé avec ce programme mais ça ne marche pas . aidez moi s'il vous plait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<signal.h>
#include<unistd.h>
 
void trait_sig(int numero) {
    switch (numero) {
    case SIGUSR1 :
        printf("bit0 recu ");break;
    case SIGUSR2 :
        printf("bit1 recu ");break;
    default :
        printf ("signal %d recu ",numero);break;
    }
}
 
int main () {
    int i;
    char ch[64];
    int p;
    int nb_sig;
    p==fork();
 
    if (p) { /* le pere */
        printf("entrer une chaine de caracteres ");
        gets(ch);
        for (i=0;ch[i];i++)
            if  (ch[i]=='0'){
                kill(p,SIGUSR1);
            }
            else {
                kill(p,SIGUSR2) ;
            }
    }
    else { /* le fils */
        for (nb_sig=1;nb_sig<NSIG;nb_sig++)
            signal(nb_sig, trait_sig);
        while(1);
    }
}

[imperio]

C'est un peu degueulasse de vouloir utiliser les signaux pour ca, tu voudrais pas plutot regarder du cote des pipes ?

Si tu tiens absolument a le faire via des signaux (ce qui, je le repete, est une mauvaise idee), commences par verifier si t'as bien recupere le pid du processus fils (c'est la valeur superieure a 0 renvoyee par fork). Apres ca, teste le retour de kill pour verifier que tu envoies bien le signal. Enfin, verifies que du cote du fils le signal ne va pas tuer ton processus (la fonction signal permet de faire ca notamment).

[nioney]

merci beaucoup pour ta réponse. Et c'est que je vais aller tester avec les tubes. merci encore une fois

[imperio]

J'y pense, tu pourrais utiliser des sockets en local aussi.

[Dliw0]

Salut,

Bien que je ne sois pas spécialiste des signaux voici quelques pistes pouvant t'aider à faire cet exercice (je suppose que c'est un exercice car en effet les signaux ne sont pas adaptés pour ce problème).

Tout d'abord il faut à tout prit être sûr que le processus fils a bien initialisé son gestionnaire de signaux avant que le père ne fasse appel à kill car sinon le fils s'arrêtera à la réception du premier signal.

Ensuite autre problème il faut utiliser des mécanismes de synchronisation pour laisser le temps au fils de traiter un signal avant que son père ne lui en envoie un autre. Pour cela tu peux utiliser diverses choses comme des sémaphores ou encore un signal venant du fils pour prévenir le père qu'il a traité le précédent signal.

Je te donne un petit exemple où je n'utilise que des signaux, avec les fonctions POSIX :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
 
 
int can_read ; /* Si = 0 alors on se met en attente de signaux */
 
 
/* Gestionnaire de signaux.
   En fonction du signal reçu on affiche un message
   ou on incrémente la variable permettant au père de lire le buffer */
void handler (int sig) {
  if (sig == SIGUSR1) printf ("Signal USR1\n") ;
  else if (sig == SIGUSR2) printf ("Signal USR2\n") ;
  can_read ++ ;
}
 
 
/* Code du processus fils.
   Prévient le père qu'il est disponible puis
   attend la réception d'un signal USR1 ou USR2 */
void processus_fils () {
  sigset_t mask ;
  sigemptyset (&mask) ;
 
  while (1) {
    kill (getppid (), SIGCONT) ; /* Prévient le père qu'on peut lire un réceptionner un signal */
    if(! can_read) sigsuspend (&mask) ; /* Attente non active d'un signal */
    can_read -- ;
  }
}
 
 
int main (int argc, char** argv) {
  struct sigaction sa ;
  int i ;
  pid_t fils ;
  char buf[] = {"101001"} ;
  can_read = 0 ;
 
  /* Initialisation du gestionnaire de signaux */
  sa.sa_handler = handler ;
  sa.sa_flags = 0 ;
  sigemptyset (&sa.sa_mask) ;
  sigaction (SIGUSR1, &sa, 0) ;
  sigaction (SIGUSR2, &sa, 0) ;
  sigaction (SIGCONT, &sa, 0) ;
 
  if (! (fils = fork ())) processus_fils () ;
 
  for (i = 0 ; buf[i] != '\0' ; i++) {
    if (! can_read) sigsuspend (&sa.sa_mask) ; /* Si le signal n'est pas encore arrivé on se met en attente */
    if (buf[i] == '1') kill (fils, SIGUSR2) ;
    else kill (fils, SIGUSR1) ;
    can_read -- ;
  }
 
  return 0 ;
}

[Obsidian]

Bonjour tout le monde ,
je suis nouveau dans la programmation C sous Linux .

Bonjour et bienvenue.

j'ai un petit problème , je veux écrire un programme ou un père crée un processus fils , le père traite une chaine de caractère de 0 et 1 , il envoi SIGUSR1 a son fils s'il rencontre un 0 et SIGUSR2 s'il rencontre 1 et le fils s'il reçoit SIGUSR1 il affiche bit0 reçu sinon il affiche bit1 reçu . j'ai essayé avec ce programme mais ça ne marche pas . aidez moi s'il vous plait

C'est un peu degueulasse de vouloir utiliser les signaux pour ca, tu voudrais pas plutot regarder du cote des pipes ?

C'est effectivement très sale mais, apparemment, c'est un sujet scolaire qui revient depuis plusieurs années :

http://www.developpez.net/forums/d70...envoi-signaux/
http://www.developpez.net/forums/d13.../signaux-en-c/

merci beaucoup pour ta réponse. Et c'est que je vais aller tester avec les tubes. merci encore une fois

Vérifie que ton énoncé te permet bien de le faire, mais c'est effectivement de cette façon qu'il faut procéder.

[nioney]

merci beaucoup pour toutes vos réponses , c'est plus clair maintenant pour moi.
( c'est un cas scolaire et pas un cas réel )
merci encore une fois .