Discussion :

[JBouchard]

Bonjour à tous,
J'ai un problème avec mon programme. Je suis sensé faire un programme qui transmet de l'information d'un client vers un serveur. Jusque là tout va bien. Le client se connecte au serveur, le serveur est capable de lire toute l'information qui lui est envoyé par une structure qui contient une ligne d'instruction et le numéro de processus.

Mon problème, est que je ne suis pas capable d'envoyer un accusé de réception de mon serveur à mon client. J'ouvre le fifo vers mon client en écriture, de mon client j'ouvre le fifo en lecture, mais le client se bloque sur la lecture. Je ne sais pas si c'est le client qui ne lit rien ou si mon serveur n'envoie rien. Je joint les principales parties du code pour ne pas surcharger le post.

Tout aide est la bienvenue ... ça fait plus d'une semaine que je cherche mais je ne trouve malheureusement pas la solution ... je suis nouveau en programmation et en C ...

Merci d'avance !

Code du 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
#include "client.h"
#include <ctype.h>
#include <string.h>
 
int main()
{
	int server_fifo_fd, client_fifo_fd;
	struct Info_FIFO_Transaction my_data;
	int *sp;
	char client_fifo[256];
 
	server_fifo_fd = open(SERVER_FIFO_NAME, O_WRONLY);
	if (server_fifo_fd == -1) {
		fprintf(stderr, "Désolé, le serveur ne répond pas.\nParti prendre un café avec les développeurs de Java.\n");
        	exit(EXIT_FAILURE);
    	}
 
 
 
  	my_data.pid_client = getpid();
	sprintf(client_fifo, CLIENT_FIFO_NAME, my_data.pid_client);
	if (mkfifo(client_fifo, 0777) == -1) {
		fprintf(stderr, "Sorry, can't make %s\n", client_fifo);
        	exit(EXIT_FAILURE);
	}
 
 
	char chaine[200];
	do{
		fgets(chaine, sizeof chaine, stdin);
		strcpy(my_data.transaction, chaine);
		printf("%d sent %s, ", my_data.pid_client, my_data.transaction);
		write(server_fifo_fd, &my_data, sizeof(my_data));
 
	client_fifo_fd = open(client_fifo, O_RDONLY);
        if (client_fifo_fd != -1) {
            if (read(client_fifo_fd, &my_data, sizeof(my_data)) > 0) {
                printf("received: %s\n", my_data.transaction);
            }
            close(client_fifo_fd);
	}
 
 
 
		do{
			printf("Autre transaction ? (o / n)");
			fgets(chaine, sizeof chaine, stdin);
		}while(chaine[0] != 'o' && chaine[0] != 'n');
	}while(chaine[0] == 'o');
 
 
	close(server_fifo_fd);
	unlink(CLIENT_FIFO_NAME);
	exit(EXIT_SUCCESS);
 
}

Code du 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
#include "gestionListeChaineeCVS.h"
#include <ctype.h>
#include <pthread.h>
 
 
//Pointeur de tête de liste
struct noeud* head;
 
struct noeud* queue;
 
int main()
{
	int server_fifo_fd, client_fifo_fd;
	struct Message Msge;
	int read_res;
	char client_fifo[256];
	char *tmp_char_ptr;
	int cr;
	char message[3] = "OK.";
 
 
 
	printf("Création de la fifo\n");
 
 
	mkfifo(SERVER_FIFO_NAME, 0777);
	server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONLY);
	if (server_fifo_fd == -1) {
		fprintf(stderr, "Erreur FIFO coté serveur. \n");
		exit(EXIT_FAILURE);
	}
 
	do {
		struct Info_FIFO_Transaction * my_data = (struct Info_FIFO_Transaction *)malloc(sizeof(struct Info_FIFO_Transaction));	
		read_res = read(server_fifo_fd, my_data, sizeof(struct Info_FIFO_Transaction));
		if (read_res > 0) {
 
 
			printf("Pid client : %d\n transaction : %s", my_data->pid_client, my_data->transaction);
			readTrans(my_data);
 
 
			client_fifo_fd = open(client_fifo, O_WRONLY);
			if (client_fifo_fd != -1) {			
				write(client_fifo_fd, &Msge.msg, sizeof(struct Message));
				close(client_fifo_fd);
 
			}
		}
 
	} while (read_res > 0);
 
	close(server_fifo_fd);
	unlink(SERVER_FIFO_NAME);
	exit(EXIT_SUCCESS);
}

[ternel]

Bonjour,

J'imagine qu'il te faut deux fifos: une écrite par le serveur et lue par le client, l'autre utilisée dans l'autre sens.

Un fifo est comme un fichier qui est lu à un bout, et écrit à l'autre.
Tant que tout ce qui doit être lu n'a pas été écrit, le lecteur est bloqué.

Et puis:

[JBouchard]

Bonjour,

Merci pour la réponse. J'ai effectivement deux fifo. Une ouverte par le client en lecture (de serveur vers client) et une en écriture (de client vers serveur) . Je n'ai pas de debugger pour pouvoir voir si le serveur envoie vraiment ce qu'il est supposé envoyer vers le client, mais aussitôt que le client essaie de lire sur le fifo, le client arrête..... ça ressemble beaucoup à ce que vous dites à la fin...

Est-ce qu'il y aurait un moyen de pouvoir tracer ce que le serveur envoie... J'ai essayé de faire des printf mais sans grand succès.

Merci encore !

P.S. Merci aussi pour la balise Code ... je ne connaissais pas .. je suis aussi nouveau ici ! :-)

[ternel]

Dans ton serveur, ton write me parait étrange:
write(client_fifo_fd, &Msge.msg, sizeof (Msge.msg));Pour moi, write prend en argument: la destination, le contenu et la taille du contenu.