Files de messages

**Jokinou** · 03/01/2014, 04h33

Bonjour ,

je dois réaliser un mini chat serveur-client à l'aide des files de messages.

J'ai un problème lorsque le serveur récupère les messages, il récupère et affiches tous les anciens messages avant de récupérer le nouveau. Or avec le msgrcv, il devrait à chaque fois retirer les messages de la file .. Ya quelquechose que j'ai pas compris ..

voila le résultat d'un petit test :

Code :

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

1
2
3
4
5
6
7
8
9
u2 : Bonjour u1
 
u1 : Bonjour u2
 
u2 : Bonjour u1
u2 : comment ca va u1 ?
 
u1 : Bonjour u2
u1 : bien et toi u2 ?

mon fichier servchat.c :

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
//
//  servchat.c
//  
 
#include <stdio.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/msg.h>
 
 
struct msgbuf
{
  long mtype;
  char mtext[128];
  char pseudo[30];
};
 
int main (int argc, char *argv[])
{
    key_t cle;
 
    int nbmaxi; // nombre maxi de connections
    int timeout; // timeout pour la deconnection
    int read; // lecture dans la file
 
    if(argc!=5)
    {
      perror("commande : servchat [-n <nbmaxi > -t <timeout>]\n");
      exit(EXIT_FAILURE);
    }
 
    if(strcmp(argv[1],"-n")==0) // premier argument -n
    {
      nbmaxi=atoi(argv[2]);
 
      if(strcmp(argv[3],"-t")==0) // deuxième argument -t
      {
        timeout=atoi(argv[4]);
 
      }
      else
      {
        perror("commande : servchat [-n <nbmaxi > -t <timeout>]\n");
        exit(EXIT_FAILURE);
      }
    }
    else
    {
      perror("commande : servchat [-n <nbmaxi > -t <timeout>]\n");
      exit(EXIT_FAILURE);
    }
 
 
    cle=ftok("/Users/Joke/Documents/cours/M1/Système/projet/CLE",'a'); // création de la clef
 
    int msqid;
    msqid =msgget(cle,IPC_CREAT|0666);
 
 
  while(1)
  {
    struct msgbuf msgp;
    read=msgrcv(msqid,&msgp,128,0,0);
 
    if (read == -1)
    {
      perror("Erreur de lecture dans la file\n");
      exit(EXIT_FAILURE);
    }
 
 
    printf("%s\n",msgp.mtext);
 
 
  }
 
 
 
 
}

mon fichier chat.c :

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 #include <stdio.h> 
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h> 
 #include <sys/types.h> 
 #include <unistd.h>
 #include <sys/wait.h> 
 #include <fcntl.h>
 #include <sys/types.h>
 #include <sys/ipc.h> 
 #include <sys/sem.h>
 #include <sys/msg.h>
 
 
struct msgbuf { 
	long mtype; 
	char mtext[128];
 
};
/*struct connect {
	char pseudo[30];
	int pid;
}*/
 
int main(int argc, char *argv[]){
	int taille, write, msqid;
    key_t cle;
	//struct connect identite;
	struct msgbuf message;
	printf("debut client \n");
	int i;
 
	if(strcmp(argv[1],"-p")==0) // premier argument -p 
	{ 
		printf("Pseudo : %s\n",argv[2]);
	}
 
 
	cle=ftok("/Users/Joke/Documents/cours/M1/Systeme/projet/CLE",'a'); // création de la clef
	msqid =msgget(cle,0666);
	if (msqid == -1)
    {
      perror("Erreur creation de file\n");
      exit(EXIT_FAILURE);
    }
 
	//info concernant l'user
	/*identite.pseudo= argv[2];
	identite.pid=getpid();
	write= msgsnd(msqid, &identite,sizeof(identite),0);
        if (write != 0)
        {
            perror("Erreur envoi identite\n");
            exit(EXIT_FAILURE);
        }
 
        else
        {
          printf("identite send\n");
        }
	*/
 
 
	while(1){
 
		message.mtype= 1; // si = 0 ca plante -> invalid argument
    char mess[158]; // message contenant le pseudo et le message
		char mes[128];
		printf("Tapez une phrase : \n"); 
		fgets(mes, sizeof(mes), stdin);
 
    strcat(mess,argv[2]);
    strcat(mess," : ");
    strcat(mess,mes);
 
		strcpy(message.mtext,mess);
 
    write= msgsnd(msqid, &message,sizeof(message.mtext),0);
		if (write != 0)
		{
			perror("Erreur envoi message\n");
			exit(EXIT_FAILURE);
		}
 
 
	}
 
}

Merci d'avance pour votre aide

**skeud** · 03/01/2014, 09h38

Alors personnellement, je suis très étonné que le code que tu as envoyé fonctionne, tu n'initialise pas ta chaine de caractère mess, donc normalement, tu devrais segfault sur le strcat .......

Ensuite, ce que je te conseil de faire, c'est de revoir ton "algo" d'envois, en l'écrivant à a la main en français, puis en comparant ce que tu as réellement dans ton code, tu verras tout de suite qu'il y a un petit soucis

.

**Jokinou** · 03/01/2014, 15h05

Envoyé par skeud

Alors personnellement, je suis très étonné que le code que tu as envoyé fonctionne, tu n'initialise pas ta chaine de caractère mess, donc normalement, tu devrais segfault sur le strcat .......

Ensuite, ce que je te conseil de faire, c'est de revoir ton "algo" d'envois, en l'écrivant à a la main en français, puis en comparant ce que tu as réellement dans ton code, tu verras tout de suite qu'il y a un petit soucis

.

Je l'initialise avec

Code :

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

char mess[158];

non ?

En effet j'avais un gros soucis d'algo, je concaténais sans cesse dans mess sans réinitialiser ... J'ai rajouter ca du coup dans ma boucle : mess[0] = '\0';
Du coup ca marche, merci !
Bon maintenant faut que je renvoie les messages à tous les utilisateurs ^^, si qqun à une piste d'algo ou de méthodes je veux bien

. ( j'aimerai faire qqqch de multithread )

**skeud** · 03/01/2014, 17h20

Envoyé par Jokinou

Je l'initialise avec

Code :

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

char mess[158];

non ?

Ca c'est instancier, et non pas initialiser, je t'explique:

Code :

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

1
2
3
4
5
6
7
8
9
10
//instanciation de la variable
int i;
// à ce moment là, i vaut un peut n'importe quoi, complètement aléatoire
// initialisation de la variable
i=0;
//A ce moment là, i vaut 0 et non plus une valeur aléatoire
 
//on peut aussi faire comme ça:
int i = 0;
//La on instancie et on initialise la variable sur la meme ligne

Pour une chaine de caractère:

Code :

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

1
2
3
4
5
6
7
8
//On instancie la variable
char bobby[256];
//On initialise la variable
bzero(bobby, 256*sizeof(char));
 
// De manière général:
MonType MaVariable[256];
bzero(&MaVariable, 256*sizeof(MonType));

Tu pourras aussi voir des fois:

Code :

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

char toto[256] = {0};

Il faut comprendre qu'on demande au compilo d'initialiser toutes les case de ta chaine avec la valeur '0'.
Si tu met 'I', toute ta chaine sera initialisé avec la valeur 'I' mais ATTENTION il n'y aura pas de '\0' à la fin.

Mais je suis pas trop fan de cette méthode ^^.

**Sve@r** · 03/01/2014, 17h35

Envoyé par skeud

Pour une chaine de caractère:

Code :

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

1
2
3
4
//On instancie la variable
char bobby[256];
//On initialise la variable
bzero(bobby, 256*sizeof(char));

Bonjour
Pourquoi y mettre 256 zéros alors qu'un seul suffit ???

Code c :

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

strcpy(bobby, "");  // Ou bien bobby[0]='\0' mais c'est moins évolutif

**skeud** · 03/01/2014, 17h48

Plus gourmand en cycle mais beaucoup moins buggogène. '\0' définies la fin d'une chaine de caractère et non pas la fin du tableau.

Si on utilise cette chaine de caractère pour envoyer des message on peut très bien vouloir la découper selon un pattern:

Code :

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

titi;toto;tata\0\0\0\0\0

donnera au split:

Code :

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

1
2
3
titi
toto
tata

Par contre si le split est un peu tricky et ne s'arrete pas lorsqu'il rencontre un '\0':

Code :

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

titi;toto;tata\0o;ub4;

(donc de l'aléatoire après le '\0' que tu mets violemment en plein milieu d'un champ de mine

)
donnera au split:

Code :

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

1
2
3
4
titi
toto
tata\0o
ub4

Tu obtiens donc un tableau de taille 4 au lieu de 3 comme tu voulais. Après certes ça fonctionne très bien comme ça mais quand tu vas vouloir faire des trucs avec de l'optimisation (transmettre plusieurs message avec une seul string donc séparé par des '\0' plus des ';') tu risque de rencontrer des bugs relativement compliqué à corrigé.

D'une manière général, on initialise toujours COMPLETEMENT ses variables, du premier Bit au dernier afin de laisser le moins possible une part de hasard dans son code.

PS: j'en ai fait les frais

**Jokinou** · 04/01/2014, 18h48

Pour l'instant tout ce compile bien même si c'est bien dégueu à ce que j'ai compris. Donc je verrai ca à la fin.

J'ai un peu avancer dans mon programme et je bute sur un problème concernant les files de messages. -> Comment envoyer un message à un seul client sachant son pid ??

Je me suis un peu renseigné et il me semble que le serveur envoie un message dont le type ( attribut situé dans le buffer ) soit le pid du client et que le client reçoit un message dont le type est son pid..
Mais ca ne marche pas.

Voici mon code ( c'est mal indenté, excusez moi car je test beaucoup de choses ):

serveur :

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
//  servchat.c
//  
//
//  Created by Darin Manikkam on 02/01/2014.
//
//
 
#include <stdio.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/msg.h>
 
 
int msqid;
 
struct msgbuf
{
  long mtype;
  char mtext[128];
   pid_t pid;
};
 
void quit(int n)
{
  signal(SIGINT,quit);
  int rc;
  struct msqid_ds buf;
  rc = msgctl(msqid,IPC_RMID,&buf);
  if(rc==0) // la suppression de la file s'est bien passée
  {
    printf("Le serveur s'est déconnecté\n");
  }
 
}
 
int main (int argc, char *argv[])
{
  int write;
 
    signal(SIGINT,quit); // on intercepte le ctrl c
    key_t cle;
 
    int nbmaxi; // nombre maxi de connections
    int timeout; // timeout pour la deconnection
    int read; // lecture dans la file
    int nbco=0; // nombre de connexions courantes au serveurs
 
    if(argc!=5)
    {
      perror("commande : servchat [-n <nbmaxi > -t <timeout>]\n");
      exit(EXIT_FAILURE);
    }
 
    if(strcmp(argv[1],"-n")==0) // premier argument -n
    {
      nbmaxi=atoi(argv[2]);
 
      if(strcmp(argv[3],"-t")==0) // deuxième argument -t
      {
        timeout=atoi(argv[4]);
 
      }
      else
      {
        perror("commande : servchat [-n <nbmaxi > -t <timeout>]\n");
        exit(EXIT_FAILURE);
      }
    }
    else
    {
      perror("commande : servchat [-n <nbmaxi > -t <timeout>]\n");
      exit(EXIT_FAILURE);
    }
 
 
    cle=ftok("/Users/Joke/Documents/cours/M1/Système/projet/CLE",'a'); // création de la clef
 
 
    msqid =msgget(cle,IPC_CREAT|0666);
    if (msqid==-1)
    { 
      perror("Pb création file :");
      exit(1);
    }
 
  int tabco[nbmaxi];
  tabco[1]=2;
 
 
  while(1)
  {
    struct msgbuf msgp;
    read=msgrcv(msqid,&msgp,sizeof(struct msgbuf),0,0);
 
    if (read == -1)
    {
      perror("Erreur de lecture dans la file\n");
      exit(EXIT_FAILURE);
    }
 
 
    // On switch sur le type du message
  if(msgp.mtype==1){
        // 1 : Messages de connexion
 
      if(nbco!=nbmaxi) // si on peut encore se connecter
        {
        printf("nouvelle connexion de %d\n",msgp.pid);
        tabco[nbco]=msgp.pid;
        nbco++;
        }
 
  }
 
 
        // 2 : Messages de messages
		else if(msgp.mtype==2)
      {
			printf("%s\n",msgp.mtext);
      msgp.mtype=msgp.pid;
      printf("pid de celui a qui j'envoie: %ld",msgp.mtype);
      write= msgsnd(msqid, &msgp,sizeof(struct msgbuf),0);
      if (write != 0) // erreur dans l'envoie du message de connexion
        {
        perror("Erreur envoi message\n");
        exit(EXIT_FAILURE);
        }
      }
 
 
        // 3 : Messagesde deconnexion
		else{
      printf("pop");
    }
 
 
 
 
 
 
 
 
 
  }
 
}

client :

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
 #include <stdio.h> 
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h> 
 #include <sys/types.h> 
 #include <unistd.h>
 #include <sys/wait.h> 
 #include <fcntl.h>
 #include <sys/types.h>
 #include <sys/ipc.h> 
 #include <sys/sem.h>
 #include <sys/msg.h>
 
 
struct msgbuf { 
	long mtype;
	char mtext[128];
  pid_t pid;
 
};
/*struct connect {
	char pseudo[30];
	int pid;
}*/
 
int main(int argc, char *argv[])
{
	int taille, write, msqid,pid;
    key_t cle;
 
 
 
  pid=getpid();
	//struct connect identite;
	struct msgbuf message;
  struct msgbuf messagercv;
	printf("debut client \n");
	int i;
 
	if(strcmp(argv[1],"-p")==0) // premier argument -p 
	{ 
		printf("Pseudo : %s\n",argv[2]);
	}
 
 
	cle=ftok("/Users/Joke/Documents/cours/M1/Systeme/projet/CLE",'a'); // création de la clef
	msqid =msgget(cle,0666);
	if (msqid == -1)
    {
      perror("Erreur creation de file\n");
      exit(EXIT_FAILURE);
    }
 
    // envoie un message de connexion
  message.mtype=1;
  message.pid=getpid();
  message.mtext[0]='\0';
  write= msgsnd(msqid, &message,sizeof(struct msgbuf),0);
  if (write != 0) // erreur dans l'envoie du message de connexion
		{
    perror("Erreur envoi message\n");
    exit(EXIT_FAILURE);
		}
 
    // FORK
  pid_t pidfork=fork();
 
  if(pidfork==0) // je suis dans le fils
    {
      while(1)
        {
        int read;
        printf("lecture");
          read=msgrcv(msqid,&messagercv,sizeof(struct msgbuf),0,0);
        if (read == -1)
          {
          perror("Erreur de lecture dans la file\n");
          exit(EXIT_FAILURE);
          }
        printf("%s",messagercv.mtext);
 
        }
    }
  else // je suis dans le père
    {
 
 
 
 
	while(1){
    printf("test :%d",test);
 
		message.mtype= 2; // si = 0 ca plante -> invalid argument
    message.pid=getpid();
    char mess[158]; // message contenant le pseudo et le message
		char mes[128];
		printf("Tapez une phrase : \n"); 
		fgets(mes, sizeof(mes), stdin);
    mess[0] = '\0';
    strcat(mess,argv[2]);
    strcat(mess," : ");
    strcat(mess,mes);
 
		strcpy(message.mtext,mess);
 
    write= msgsnd(msqid, &message,sizeof(struct msgbuf),1);
		if (write != 0)
		{
			perror("Erreur envoi message\n");
			exit(EXIT_FAILURE);
		}
 
 
	}
    }
 
}

dans le client j'ai fait un fork, pour que le fils intercepte les messages qui lui son destiné... mais ca n'a pas l'air de marché .. ^^"

**Sve@r** · 04/01/2014, 18h59

Envoyé par Jokinou

J'ai un peu avancer dans mon programme et je bute sur un problème concernant les files de messages. -> Comment envoyer un message à un seul client sachant son pid ??

Ce n'est pas le but d'une msq.

Le but d'une msq est de pouvoir stocker de façon permanente (donc après la mort du processus ayant stocké) des informations qui pourront être récupérées par quiconque a la clef. La conservation des infos est assurée par le noyau Unix/Linux

Partant de là, le premier qui a la clef peut récupérer les messages qu'il veut.

Si tu veux dialoguer entre 2 processus, tu as d'autres outils bien plus adaptés comme les pipes ou les sockets.

Alors maintenant il y a toujours moyen. Par exemple le destinataire peut envoyer son pid à l'émetteur via un pipe (ou même, avec trait d'humour, via la msq elle-même).
Bref quel que soit le support, une fois que l'émetteur reçoit ce pid il peut alors l'utiliser comme type de message qu'il insère. Le client (jouant le jeu) n'aura plus qu'à récupérer les messages dont le type correspond à son pid. C'est faisable mais c'est pas super utile...

**Jokinou** · 04/01/2014, 19h10

Non il faut absolument que j'utilise les files de messages. C'est dans mon sujet. Et il me semble bien qu'on fonction des types de messages, je peux récupérer que certains messages.. Et ainsi un client peut recevoir que certains messages.

Je te donne qqque fragments de code que j'ai vu sur le net :

coté client :

Code :

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

1
2
3
4
* On attend un message dont le type est notre pid */
 
  sleep (5);    /* Pour avoir le temps de voir ce qui se passe !!!!!!!! */
  msgrcv (msg_id, &msg, sizeof(long), (long)pid, 0);

coté serveur :

Code :

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

1
2
3
4
5
6
   msg.mtype   = pid_client;
 
 /*le serveur envoie son propre pid comme "texte" */
    msg.information    = getpid();
    msgsnd (msg_id, &msg, sizeof(long), 0);
    }

**Sve@r** · 04/01/2014, 20h53

Envoyé par Jokinou

Non il faut absolument que j'utilise les files de messages. C'est dans mon sujet.

Ok, c'est un TP. Donc c'est pas forcément "naturel" mais c'est normal...

Envoyé par Jokinou

Et il me semble bien qu'on fonction des types de messages, je peux récupérer que certains messages.. Et ainsi un client peut recevoir que certains messages.

Exact. C'est d'ailleurs le rôle du membre "long mtype" => faire un filtre. Si tu places dans ta msq des messages de type 1, 2 et 3 et qu'un client ne demande que des messages de type "1" le système ne lui ressortira que les messages ayant "1" dans ce membre...

Envoyé par Jokinou

Je te donne qqque fragments de code que j'ai vu sur le net :

coté client :

Code :

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

1
2
3
4
* On attend un message dont le type est notre pid */
 
  sleep (5);    /* Pour avoir le temps de voir ce qui se passe !!!!!!!! */
  msgrcv (msg_id, &msg, sizeof(long), (long)pid, 0);

coté serveur :

Code :

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

1
2
3
4
5
6
   msg.mtype   = pid_client;
 
 /*le serveur envoie son propre pid comme "texte" */
    msg.information    = getpid();
    msgsnd (msg_id, &msg, sizeof(long), 0);
    }

Envoyé par Sve@r

...Par exemple le destinataire peut envoyer son pid à l'émetteur via un pipe (ou même, avec trait d'humour, via la msq elle-même)...

Ton fragment de code fait exactement ce que j'ai évoqué. Il y a d'abord passage du pid d'un intervenant vers l'autre via la msq elle-même avant que le serveur commence à écrire pour ledit pid...

**Jokinou** · 04/01/2014, 21h12

Ok donc pour l'instant je suis bien, j'ai bien compris le principe. J'ai réussit à savoir pourquoi mon programme ne fonctionne pas ; A cause de mon tableau qui contient les pid de mes clients : tabco.

On considère juste ce code :

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
int tabco[nbmaxi];
 
 
 
  pid_t pidfork=fork();
 
 
  if(pidfork==0) // je suis dans le fils : écoute les connexions
      {
      int nbco=0; // nombre de connexions courantes au serveurs
      while(1)
        {
      struct msgbuf msgp;
        read=msgrcv(msqid,&msgp,sizeof(struct msgbuf),1,0);
      if (read == -1)
        {
        perror("Erreur de lecture dans la file\n");
        exit(EXIT_FAILURE);
        }
      if(nbco!=nbmaxi) // si on peut encore se connecter
        {
           printf("nouvelle connexion de %d\n",msgp.pid);
        tabco[nbco]=msgp.pid;
        printf("tab check : %d",tabco[nbco]);
        nbco++;
        }
        }
      }
  else // je suis dans le père : ecoute les messages normaux
    {
 
    while(1)
      {
      struct msgbuf msgpsnd;
            struct msgbuf msgp;
      for(int i=0;i<nbmaxi;i++)
        {
        printf("tabaffich :%d",tabco[i]);
        }
 
...........................

Dans le processus fils, je remplis mon tableau à chaque fois que qqun se connecte. Et dans le le père ( le main ) dès que j'envoie un message j'affiche mon tabco, pour voir les valeurs des pid ( pour tester ) .. Or il m'affiche pas du tout les pid ... et m'affiche un 62 complètement random.. Est un problème de variable local entre le fils ou le père ? Je suis un peu perdu la .. :'(

**Jokinou** · 04/01/2014, 21h29

Ok je viens de comprendre qu'on ne peut pas avoir de variable 'globale' avec un fork. Faut passer par la mémoire partagée avec gestion des sémaphore etc .. :/
J'essaye de m'y mettre.

**Neckara** · 04/01/2014, 22h59

Bonjour,

Tu sembles compiler pour du Linux, tu peux jetter un œil aux tubes nommés avec mkfifo qui pourront t'être utile dans certains cas et qui ne nécessiteront pas de sémaphores.

**Sve@r** · 04/01/2014, 23h11

Envoyé par Neckara

Bonjour,

Tu sembles compiler pour du Linux, tu peux jetter un œil aux tubes nommés avec mkfifo qui pourront t'être utile dans certains cas et qui ne nécessiteront pas de sémaphores.

Apparemment c'est un TP imposé et il n'a droit qu'aux msq...

Envoyé par Jokinou

Ok je viens de comprendre qu'on ne peut pas avoir de variable 'globale' avec un fork.

C'est mal dit. Tu as tout à fait le droit d'avoir des globales dans ton code, et d'utiliser fork(). Mais le fork génère un nouveau processus totalement indépendant du premier. Donc dans ce nouveau processus les globales fonctionneront comme dans l'ancien (accès à la variable depuis tout le code) mais comme les processus sont indépendants, chaque processus n'aura accès qu'à ses propres globales. C'est exactement comme si tu exécutais un même programme depuis deux fenêtres différentes.

Accessoirement si on peut éviter les globales c'est plus sympa pour tout le monde (y compris pour toi).

Envoyé par Jokinou

Faut passer par la mémoire partagée avec gestion des sémaphore etc .. :/

Ou par les msq() qui font partie de la même famille et qui ont le même but => communiquer entre deux processus

Ceci dit, c'est dommage de "devoir passer par des outils de la famille des msq pour faire fonctionner un TP sur les msq"...

**Jokinou** · 05/01/2014, 05h57

J'ai bien réussit à gérer ma mémoire partagée et mes echanges de messages fonctionnent enfin

. Merci pour votre aide

J'ai deux autres petits problèmes maintenant.

Premièrement j'aimerai quitter mes processus de manière propre, c'est pourquoi je décide d'intercepter le signal SIGINT ( ctrl-c ) pour pouvoir libérer les sémaphore, files etc .. avant la fermeture du message.
J'ai donc ca au début de mon main :

Code :

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

  signal(SIGINT,quit); // on intercepte le ctrl c

et la fonction associé :

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
void quit(int n) // fonction appelé avec ctrl-c
{
 
  int dl; // delete file
  int dm; // delete shared memory
  struct msqid_ds buf;
  dl = msgctl(msqid,IPC_RMID,&buf); // suppression de la file
  kill(pidfils,9); // suppréssion du proccessus fils
  semctl(semid,0,IPC_RMID,0); // detruit le semaphpre
  struct shmid_ds buff;
  dm= shmctl (shmid,IPC_RMID,&buff); // suppression shared memory
 
  if(dm==0) // suppression shared memory bien passée
  {
    printf("suppresion de la file");
  }
 
  if(dl==0) // la suppression de la file s'est bien passée
  {
    printf("Le serveur s'est déconnecté\n");
  }
 
  exit(0);
 
}

Or lorsque je fais ctrl-c il se trouve que ma fonction n'est pas toujours exécutée. En effet de manière aléatoire elle l'est ou alors j'ai droit à : ^CKilled: 9. Je comprend pas pourquoi .. une explication ?

deuxièment , je dois réalisé un timeout. Lorsqu'un client n'a pas envoyer un message depuis timeout, je dois le kick du serveur .. Je vois pas du tout comment faire. Existe-il des outils en c pour faire ca ?

**Sve@r** · 05/01/2014, 11h19

Envoyé par Jokinou

Premièrement j'aimerai quitter mes processus de manière propre, c'est pourquoi je décide d'intercepter le signal SIGINT ( ctrl-c ) pour pouvoir libérer les sémaphore, files etc .. avant la fermeture du message.
J'ai donc ca au début de mon main :

Code :

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

  signal(SIGINT,quit); // on intercepte le ctrl c

et la fonction associé :

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
void quit(int n) // fonction appelé avec ctrl-c
{
  
  int dl; // delete file
  int dm; // delete shared memory
  struct msqid_ds buf;
  dl = msgctl(msqid,IPC_RMID,&buf); // suppression de la file
  kill(pidfils,9); // suppréssion du proccessus fils
  semctl(semid,0,IPC_RMID,0); // detruit le semaphpre
  struct shmid_ds buff;
  dm= shmctl (shmid,IPC_RMID,&buff); // suppression shared memory
  
  if(dm==0) // suppression shared memory bien passée
  {
    printf("suppresion de la file");
  }
  
  if(dl==0) // la suppression de la file s'est bien passée
  {
    printf("Le serveur s'est déconnecté\n");
  }
  
  exit(0);
  
}

Or lorsque je fais ctrl-c il se trouve que ma fonction n'est pas toujours exécutée. En effet de manière aléatoire elle l'est ou alors j'ai droit à : ^CKilled: 9. Je comprend pas pourquoi .. une explication ?

Ton message killed 9 vient probablement du fils killé par un kill(9) ce qui est d'ailleurs franchement hardcore. Tu en as plein d'autres tellement plus propres (comme le SIGTERM 15 qui indique au processus "termine-toi proprement"...). Accessoirement utiliser des macros comme kill(pid, SIGTERM) est plus indiqué qu'utiliser des nombres magiques comme kill(pid, 15) surtout que tu les connais vu que tu fais un signal(SIGINT, quit).
Ensuite, une fois que tu kill le fils, tu devrais faire un wait() pour être sûr qu'il se termine avant que tu continues tes opérations de suppression...

Envoyé par Jokinou

deuxièment , je dois réalisé un timeout. Lorsqu'un client n'a pas envoyer un message depuis timeout, je dois le kick du serveur .. Je vois pas du tout comment faire. Existe-il des outils en c pour faire ca ?

Tu as alarm(n) qui t'envoie automatiquement un kill(SIGALRM) au bout de n secondes. Te suffit de trapper via signal(SIGALRM) et le relayer à une fonction appropriée...

**Jokinou** · 06/01/2014, 02h35

Ok merci beaucoup, je vais essayer ce que tu m'a dis.

edit : j'ai essayer avec ca

Code :

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

if ((pidfork = wait(&status)) == -1) // attente des fils

et ca

Code :

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

 kill(pidfils,SIGTERM); // suppréssion du proccessus fils

Ce qui me donne comme retour quand je fais ctrl-c :
^CTerminated: 15

Donc ca fait toujours pas ce que je souhaite :/.. Comment ca se fait ?

re edit : je viens de comprendre que c'est le kill qui fait 'planter' ma fonction quit. C'est comme si le kill du fils forcer l'arrêt du père ou je sais pas quoi, je comprend pas trop.
En tout cas avec ca ( kill en commentaire ) ca marche niquel, ca me fait bien toutes les instructions avant de quitter le programme :

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
void quit(int n) // fonction appelé avec ctrl-c
{
    //kill(pidfils,SIGTERM); // suppréssion du proccessus fils
 
    //if ((pidfork = wait(&status)) == -1) // attente des fils
    //{
 
    int dl; // delete file
    int dm; // delete shared memory
    struct msqid_ds buf;
    dl = msgctl(msqid,IPC_RMID,&buf); // suppression de la file
 
    semctl(semid,0,IPC_RMID,0); // detruit le semaphpre
    struct shmid_ds buff;
    dm= shmctl (shmid,IPC_RMID,&buff); // suppression shared memory
 
    if(dm==0) // suppression shared memory bien passée
    {
      printf("suppresion de la file");
    }
 
    if(dl==0) // la suppression de la file s'est bien passée
    {
      printf("Le serveur s'est déconnecté\n");
    }
  printf("exite");
    exit(0);
    //}
 
}

J'ai vérifier grâce à un ps , aucun fils ne tourne en arrière, du coup je comprend pas comment ca se fait, vu que je l'arrête pas ^^.. Si qqun pour m'expliquer, car j'aimerai bien comprendre.

Files de messages

C

Vue hybride

Discussions similaires

Partager

Partager