Un Tchat (N client(s), 1 serveur)

**Adenora** · 09/02/2013, 11h49

Bonjour,

Je dois coder un tchat à l'aide des threads et des sockets, sauf que je n'y arrive pas du tout. J'utilise gtk pour l'interface graphique.
Ce que j'obtiens avec mon code, avec tout d'abord, un client :
- Le client se connecte avec son pseudo et envoie donc le pseudo au serveur
- Le serveur récupère ce pseudo et le stocke dans une structure
- Le client envoie son premier message au serveur
- Le serveur renvoie bien ce message
- Le client envoie son deuxième message et là, le client plante littéralement

Voici le code 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
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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
#include <stdlib.h>
#include <stdio.h>
#include <linux/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
 
typedef struct sockaddr sockaddr;
typedef struct sockaddr_in sockaddr_in;
typedef struct hostent hostent;
typedef struct servent servent;
 
char *msgs; // Pour stocker l'historique des messages
GtkWidget* entry;
pthread_t threadReception;
int socket_descriptor;
 
GtkWidget* label;
GtkWidget* scrollbar;
GtkAdjustment* vadjustment;
 
/* Réception des messages */
void* reception (void* donnee) {
	int longueur;
    int connecte = 1;
    char buffer[1024];
	gdouble upper;
    while (1) {
        if ((longueur = read(socket_descriptor, buffer, sizeof(buffer))) > 0) {
			printf("Message destinataire : \n");
			write(1, buffer, longueur);
			msgs = realloc(msgs, sizeof(char)*sizeof(buffer)*sizeof(msgs));
			strcat(msgs, buffer);
			gtk_label_set_text(GTK_LABEL(label), msgs);
			gtk_misc_set_alignment(GTK_MISC(label), 0, 1);
 
			// Ajustement de la scrollbar
			vadjustment = gtk_scrolled_window_get_vadjustment((GTK_SCROLLED_WINDOW(scrollbar)));
			upper = gtk_adjustment_get_upper(vadjustment);
			gtk_adjustment_set_value(vadjustment,upper);
			printf("\n Fin de la reception. \n");
		}
    }
}
 
void envoi (GtkWidget *widget, GtkWidget *view) {
	GtkTextBuffer* text_buffer = 0;
	GtkTextIter start;
	GtkTextIter end;
	gchar* buf = 0;
	gdouble upper;
	char msgsend[1024] = "";
	char msgrecv[1024];
	int longueur; // longueur d'un buffer utilise
 
	printf("Envoi d'un message au serveur. \n");
 
	// On récupère le buffer
	text_buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
	// On récupère l'origine du buffer
	gtk_text_buffer_get_start_iter(text_buffer, &start);
	// On récupère la fin du buffer
	gtk_text_buffer_get_end_iter(text_buffer, &end);
	// On copie le contenu du buffer dans une variable
	buf = gtk_text_buffer_get_text(text_buffer, &start, &end,TRUE);
 
	strcat(msgsend,buf);
 
	// Mise en attente du programme pour simuler un délai de transmission
	sleep(1);
 
	printf("Message envoye : %s \n", msgsend);
 
	// Envoi du message vers le serveur
	if ((write(socket_descriptor, msgsend, strlen(msgsend))) < 0) {
		perror("Erreur : impossible d'ecrire le message destine au serveur");
		exit(1);
	}
 
	// Lecture de la réponse en provenance du serveur
	if ((longueur = read(socket_descriptor, msgrecv, sizeof(msgrecv))) > 0) {
		printf("Reponse du serveur : \n");
		write(1, msgrecv, longueur);
		msgs = realloc(msgs, sizeof(char)*sizeof(msgrecv)*sizeof(msgs));
		strcat(msgs, msgrecv);
		gtk_label_set_text(GTK_LABEL(label), msgs);
 
		// Ajustement de la scrollbar du label
		vadjustment = gtk_scrolled_window_get_vadjustment((GTK_SCROLLED_WINDOW(scrollbar)));
		upper = gtk_adjustment_get_upper(vadjustment);
		gtk_adjustment_set_value(vadjustment, upper);
	}
 
	printf("Fin de la reception. \n");
 
	gtk_text_buffer_get_bounds(text_buffer, &start, &end);
	gtk_text_buffer_delete(text_buffer, &start, &end);
 
	g_free(buf);
}
 
/* Envoie un message en appuyant sur la touche Enter */
gboolean on_key_press (GtkWidget* widget, GdkEventKey* event, GtkWidget* view) {
	if (event->keyval == GDK_Return) {
		envoi(widget, view);
	}
	return 0;
}
 
void connexion (GtkWidget *widget, GtkWidget* window) {
	sockaddr_in adresse_locale; // adresse de socket local
	hostent* ptr_host; // info sur une machine hote
	servent* ptr_service; // info sur service
	char* host = "127.0.0.1";
	int longueur;
	GtkWidget* box;
	GtkWidget* text_view;
	GtkWidget* button;
	GtkWidget* scrollbar2;
    GtkWidget* menuBar;
    GtkWidget* menu;
    GtkWidget* menuItem;
	gchar* sUtf8;
 
	printf("Adresse du serveur : %s \n", host);
 
	if ((ptr_host = gethostbyname(host)) == NULL) {
		perror("Erreur : impossible de trouver le serveur a partir de son adresse");
		exit(1);
	}
 
	// Copie caractère par caractère des infos de ptr_host vers adresse_locale
	bcopy((char*)ptr_host->h_addr, (char*)&adresse_locale.sin_addr, ptr_host->h_length);
	adresse_locale.sin_family = AF_INET;
 
	// Utiliser un nouveau numéro de port
	adresse_locale.sin_port = htons(5254);
	printf("Numero de port pour la connexion au serveur : %d \n", ntohs(adresse_locale.sin_port));
 
	// Création de la socket
	if ((socket_descriptor = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		perror("Erreur : impossible de creer la socket de connexion avec le serveur");
		exit(1);
	}
 
	// Tentative de connexion au serveur dont les infos sont dans adresse_locale
	if ((connect(socket_descriptor, (sockaddr*)(&adresse_locale), sizeof(adresse_locale))) < 0) {
		perror("Erreur : impossible de se connecter au serveur");
		exit(1);
	}
 
	printf("Connexion etablie avec le serveur. \n");
 
	const gchar* pseudo = gtk_entry_get_text(GTK_ENTRY(entry));
 
	write(socket_descriptor, pseudo, strlen(pseudo)); // On envoie le pseudo au serveur
 
 
	vadjustment = NULL;
	msgs = malloc(sizeof(char));
 
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size(GTK_WINDOW(window), 400, 300);
	gtk_window_set_title(GTK_WINDOW(window), "Tchat");
	g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), 0);
 
	box=gtk_vbox_new(FALSE, 5);
	gtk_container_add(GTK_CONTAINER(window), box);
 
	/* Création du menu */
    menuBar = gtk_menu_bar_new();
    menu = gtk_menu_new();
 
    /* Se connecter */
    menuItem = gtk_menu_item_new_with_label("Se connecter");
    gtk_menu_append(GTK_MENU(menu), menuItem);
    gtk_signal_connect_object(GTK_OBJECT(menuItem), "activate", GTK_SIGNAL_FUNC(envoi), NULL); // A modifier
 
	/* Menu fichier */
    menuItem = gtk_menu_item_new_with_label("Fichier");
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuItem), menu);
    gtk_menu_shell_append(GTK_MENU_SHELL(menuBar), menuItem);
 
    gtk_box_pack_start(GTK_BOX(box), menuBar, FALSE, FALSE, 0);
 
    /* Scrollbar pour le label */
	scrollbar = gtk_scrolled_window_new(NULL, vadjustment);
	gtk_box_pack_start(GTK_BOX(box), scrollbar, TRUE, TRUE, 5);
 
	/* Création du label */
	sUtf8 = g_locale_to_utf8("", -1, NULL, NULL, NULL);
	label = gtk_label_new(sUtf8);
	g_free(sUtf8);
	gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); // Saut de ligne automatique (seulement visuel)
	gtk_misc_set_alignment(GTK_MISC(label), 0, 1); // Texte placé en bas à gauche
	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollbar), label);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollbar), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 
	/* Scrollbar pour le text_view */
	scrollbar2 = gtk_scrolled_window_new(NULL, NULL);
	gtk_box_pack_start(GTK_BOX(box), scrollbar2, TRUE, TRUE, 5);
 
	/* Création du text_view */
	text_view = gtk_text_view_new();
	gtk_container_add(GTK_CONTAINER(scrollbar2), text_view);
	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text_view), GTK_WRAP_CHAR); // Saut de ligne automatique (seulement visuel)
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollbar2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 
	/* Création du bouton Envoyer */
	button = gtk_button_new_with_label("Envoyer");
	gtk_box_pack_start(GTK_BOX(box),button,FALSE,FALSE,0);
	g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(on_key_press), (gpointer) text_view);
	g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(envoi), (gpointer) text_view);
 
	gtk_widget_show_all(window);
	gtk_main();
 
	// Le thread qui va recevoir les données du serveur
	pthread_create(&threadReception, NULL, reception, NULL);
 
	free(msgs);
}
 
int main (int argc, char* argv[]) {
	GtkWidget* window;
	GtkWidget* box;
	GtkWidget* labelpseudo;
	GtkWidget* button;
	gchar* sUtf8;
 
	gtk_init(&argc, &argv);
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size(GTK_WINDOW(window), 400, 300);
	gtk_window_set_title(GTK_WINDOW(window), "Tchat");
	g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), 0);
 
	box=gtk_vbox_new(FALSE, 5);
	gtk_container_add(GTK_CONTAINER(window), box);
 
	/* Création du label */
	sUtf8 = g_locale_to_utf8("Pseudo : ", -1, NULL, NULL, NULL);
	labelpseudo = gtk_label_new(sUtf8);
	g_free(sUtf8);
	gtk_misc_set_alignment(GTK_MISC(labelpseudo), 0, 1); // Texte placé en bas à gauche
	gtk_box_pack_start(GTK_BOX(box), labelpseudo, TRUE, TRUE, 5);
 
	/* Création de l'entry */
	entry = gtk_entry_new();
	gtk_box_pack_start(GTK_BOX(box), entry, TRUE, TRUE, 5);
 
	/* Création du bouton Se connecter */
	button = gtk_button_new_with_label("Se connecter");
	gtk_box_pack_start(GTK_BOX(box),button,FALSE,FALSE,0);
	g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(connexion), (gpointer) window);
 
	gtk_widget_show_all(window);
	gtk_main();
	return 0;
}

Voici le code 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
#include <stdlib.h>
#include <stdio.h>
#include <linux/types.h> /* Pour les sockets*/
#include <sys/socket.h>
#include <netdb.h> /* Pour hostent,servent*/
#include <string.h> /* Pour bcopy...*/
#include <pthread.h>
#define TAILLE_MAX_NOM 256
#define MAX_CLIENT 100 // Le nombre maximum de client qui sera autorisé par le serveur
 
struct Client {
    int sockClient;
    int connecte;
    char pseudo[50];
    pthread_t threadReception;
};
typedef struct Client Client;
 
Client client[MAX_CLIENT];
 
int serveurPlein = 0;
 
typedef struct sockaddr sockaddr;
typedef struct sockaddr_in sockaddr_in;
typedef struct hostent hostent;
typedef struct servent servent;
 
 
void *reception (void *id2) {
    int retourReception;
    int i = 0;
    int id = (int)id2;
    char buffer[1024];
    int connecte = 1;
    int longueur;
 
    if((longueur = read(client[id].sockClient, buffer, sizeof(buffer))) <= 0) {
		printf("Erreur envoi");
		return;
    }
    printf("Message lu : %s\n", buffer);
	buffer[longueur] = '\n';
    do {
		if (client[i].connecte == 1) {
			if (!write(client[i].sockClient, buffer, strlen(buffer)+1)) {
				printf("Client deconnecte\n");
				close(client[i].sockClient);
				client[i].connecte = 0;
				serveurPlein = 0;
			}	
			printf("Message envoye\n");	
        }
        i++;
    }
    while (i < MAX_CLIENT);
}
 
int main (int argc, char **argv){
	pthread_t nouveau_client;
	int socket_descriptor,
		sock_temp,
	    nouv_socket_descriptor,
	    longueur_adresse_courante;
	sockaddr_in adresse_locale,	/* Structure adresse locale */
		    adresse_client_courant;
	hostent* ptr_hote; /* Les infos récupérées sur la machine hôte */
	servent* ptr_service; /* Les infos récupérées sur le service de la machine */
	char machine[TAILLE_MAX_NOM+1]; /* Nom de la machine locale */
	int i = 0;
 
	gethostname(machine,TAILLE_MAX_NOM); /* Récupération du nom de la machine */
 
	/* Récupération de la structure d'adresse en utilisant le nom */
	if((ptr_hote = gethostbyname(machine)) == NULL) {
		perror("Erreur : impossible de trouver le serveur a partir de son nom.");
		exit(1);
	}
 
	/* Initialisation de la structure adresse_locale avec les infos récupérées */
 
	/* Copie de ptr_hote vers adresse_locale */
	bcopy((char*)ptr_hote->h_addr, (char*)&adresse_locale.sin_addr, ptr_hote->h_length);
	adresse_locale.sin_family = ptr_hote->h_addrtype; /* ou AF_INET */
	adresse_locale.sin_addr.s_addr = INADDR_ANY; /* ou AF_INET */
 
	/* Définition du service à utiliser à distance */
	adresse_locale.sin_port = htons(5254);
	printf("Numero de port pour la connexion au serveur : %d \n", ntohs(adresse_locale.sin_port));
 
	/* Création de la socket */
	if ((socket_descriptor = socket(AF_INET, SOCK_STREAM, 0)) < 0){
		perror("Erreur : impossible de creer la socket a l'adresse de connexion avec le client.");
		exit(1);
	}
 
	/* Association du socket_descriptor à la structure d'adresse adress_locale */
	if ((bind(socket_descriptor, (sockaddr*)(&adresse_locale), sizeof(adresse_locale))) < 0) {
		perror("Erreur : impossible de lier la socket a l'adresse de connexion.");
		exit(1);
	}
 
	listen(socket_descriptor, 5);
 
	for(;;){
		if (client[i].connecte == 0) {
			printf("Emplacement libre trouve :%d\n", i);
 
			longueur_adresse_courante = sizeof(adresse_client_courant);
			if ((sock_temp = accept(socket_descriptor, (sockaddr*)(&adresse_client_courant), &longueur_adresse_courante)) < 0) {
				perror("Erreur : impossible d'accepter la connexion avec le client");
				exit(1);
			}
 
			char pseudo[50] = "";
 
			read(sock_temp, pseudo, sizeof(pseudo));
			//write(sock_temp, pseudo, strlen(pseudo));
 
			client[i].sockClient = sock_temp;
			client[i].connecte = 1;
			strcpy(client[i].pseudo,pseudo);
 
			printf("Client no %d connecte sous le pseudo: %s\n\n",i,client[i].pseudo);
 
			if (pthread_create(&client[i].threadReception, NULL, reception, (void*)i)) {	
				perror("Erreur pthread_create");
				exit(1);
			}
 
			i = 0;
 
			printf("Reception du message. \n");
		}
		i++;
	}
	return 0;
}

Voyez-vous des choses qui clochent ? Merci

**Joker-eph** · 09/02/2013, 20h42

Que veux-tu dire par "plante" ? Freeze ? Segfault (à quel endroit) ?

Tu as mis des printf(), quelle est la trace que tu as en sortie ?

**Bktero** · 09/02/2013, 21h18

Tu as un problème de découpage en couche de ton application. Tu as totalement lié la couche graphique avec GTK et la couche réseau avec les sockets. Tu devrais avoir des fonctions réseaux indépendantes de la couche graphique pour pouvoir mieux isoler le problème. Ici, tu ne peux pas tester la couche réseau indépendamment de la couche graphique et il est possible que l'erreur soit dans la 2e et non la seconde. Peut-être un peu tard pour cette application-ci, penses-y pour la suivante

Pour trouver ton problème, il faut déjà trouver où se produit l'erreur. Soit avec des printf(), soit avec un débogueur.

En regardant en diag ton code du client, je vois des choses comme :

Code :

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

msgs = malloc(sizeof(char));

Puis la variable n'est pas utilisée jusqu'à la fin de la fonction où elle passe au free(). Or, cette variable est une variable globale, utilisée ailleurs. Dans la réception de message comme par hasard. C'est très louche et je ferais déjà une enquête de ce côté si j'étais toi.

**Adenora** · 09/02/2013, 21h29

C'est un freeze.

Pour ce qui est du msgs, qui est l'historique des messages, on ne sait pas du tout comment stocker ça. Au début, on avait mis un tableau de char et on obtenait un segFault. Et vu que je m'y connais pas du tout au pointeur, ça fait des mallocs n'importe où, n'importe comment.

J'ai rajouté "via Reception" dans la fonction reception et "via Envoi" dans la fonction envoi.
Le terminal pour le client :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
Adresse du serveur : 127.0.0.1 
Numero de port pour la connexion au serveur : 5254 
Connexion etablie avec le serveur. 
Envoi d'un message au serveur. 
Message envoye : Bonjour
Message destinataire : 
Bonjour
 
Fin de la reception via Reception

Et là, le tchat freeze.
J'ai remarqué que quand je fermais le serveur, le client redevenait normal avec dans le terminal, une phrase en plus :

Code :

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

Fin de la reception via Envoi

**Joker-eph** · 09/02/2013, 22h24

Un "freeze" c'est pas un plantage, ton client est bloqué sur le "read", il ne reçoit rien en retour du serveur visiblement. Quel est l'affichage sur le serveur ?

**Joker-eph** · 09/02/2013, 22h25

Au passage : strlen() est à bannir.

**Adenora** · 09/02/2013, 22h35

Au passage : strlen() est à bannir.

Je le dirai au prof, puisque c'est lui qui nous a donné les bouts de code

Le serveur reçoit bien le pseudo, puis le premier message et ensuite rien.

La fonction reception 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
void *reception (void *id2) {
    int retourReception;
    int i = 0;
    int id = (int)id2;
    char buffer[1024];
    int connecte = 1;
    int longueur;
 
    if((longueur = read(client[id].sockClient, buffer, sizeof(buffer))) <= 0) {
		printf("Erreur envoi");
		return;
    }
    printf("Message lu : %s\n", buffer);
	buffer[longueur] = '\n';
    do {
		if (client[i].connecte == 1) {
			if (write(client[i].sockClient, buffer, strlen(buffer)+1) < 0) {
				printf("Client deconnecte\n");
				close(client[i].sockClient);
				client[i].connecte = 0;
				serveurPlein = 0;
			}	
			printf("Message envoye\n");	
			printf("%d",i); // Problème !!
        }
        i++;
    }
    while (i < MAX_CLIENT);
}

J'ai rajouté un printf après le "Message envoye". Et la valeur i ne s'affiche pas dans le terminal.

**Bktero** · 10/02/2013, 00h18

Envoyé par Joker-eph

Au passage : strlen() est à bannir.

?

**Joker-eph** · 10/02/2013, 09h30

Envoyé par Bktero

?

Dans un contexte où tu charges un buffer avec des données arbitraires (reçues sur une socket), faire un strlen() sur le buffer, et encore plus se baser sur le resultat du strlen() pour effectuer des actions me semble.... hasardeux. C'est pour ça qu'on a inventé strnlen() d'ailleurs ;-)
(ici il vaut mieux utiliser la valeur de retour de read() je pense)

**Joker-eph** · 10/02/2013, 09h31

Envoyé par Adenora

J'ai rajouté un printf après le "Message envoye". Et la valeur i ne s'affiche pas dans le terminal.

Il manque un "\n"

**Adenora** · 10/02/2013, 11h09

Ah oui, c'est mieux comme ça

Le serveur reçoit bien le pseudo, puis le premier message et ensuite rien.

Et du côté du client : le premier message est envoyé, le deuxième aussi et il attend la réponse du serveur.
Je n'arrive pas à voir si c'est un problème de read/write ou de thread.

**Bktero** · 10/02/2013, 12h10

Envoyé par Joker-eph

Dans un contexte où tu charges un buffer avec des données arbitraires (reçues sur une socket), faire un strlen() sur le buffer, et encore plus se baser sur le resultat du strlen() pour effectuer des actions me semble.... hasardeux. C'est pour ça qu'on a inventé strnlen() d'ailleurs ;-)
(ici il vaut mieux utiliser la valeur de retour de read() je pense)

Avec les explications je suis tout de suite plus d'accord ^^ Je ne connaissais pas la fonction strnlen(). Dommage que ce soit une extension GNU...

Je n'arrive pas à voir si c'est un problème de read/write ou de thread.

Je crois que tu commences à avoir beaucoup trifouillé ton code pour encore savoir d'où vient le problème. Regarde ta fonction reception() que tu as posté : tu ne te sers pas des paramètres (d'ailleurs, on ne convertit pas un void* vers un int mais vers un int*), tu ne renvois rien, tu fais de l'envoi alors que la fonction s'appelle reception(), etc.

Je te conseille sincèrement de te poser avec un stylo et une feuille de papier, et d'analyser le flot des envois et de réception, de redécouper le code de manière plus logique et en isolant plus les problèmes.

**Joker-eph** · 10/02/2013, 19h14

Envoyé par Adenora

Je n'arrive pas à voir si c'est un problème de read/write ou de thread.

Effectivement tu as 2 threads qui lisent sur la socket alors que le serveur n'envoie qu'une seul fois...

**Joker-eph** · 10/02/2013, 19h29

Envoyé par Bktero

Avec les explications je suis tout de suite plus d'accord ^^ Je ne connaissais pas la fonction strnlen(). Dommage que ce soit une extension GNU...

Je ne savais pas que ce n'était pas standard. Au passage ce n'est pas GNU mais POSIX: http://pubs.opengroup.org/onlinepubs...s/strnlen.html

**Adenora** · 10/02/2013, 19h35

En fait, dans réception, le paramètre ne sert à rien, j'ai oublié de l'enlever.
Je vais revoir le code, en enlevant tout ce qui est gtk et je reviendrai poster ici.

**Bktero** · 11/02/2013, 08h03

Envoyé par Joker-eph

Je ne savais pas que ce n'était pas standard. Au passage ce n'est pas GNU mais POSIX: http://pubs.opengroup.org/onlinepubs...s/strnlen.html

http://man.developpez.com/man3/strnlen.3.php dit que c'est une extension GNU mais la page n'a pas été mise à jour depuis 2003.
http://linux.die.net/man/3/strnlen dit que c'était une extension GNU et que c'est désormais passé dans POSIX.
Je vais envoyer un message au responsable de la section Linux pour voir si une mise à jour de la page de manuel est nécessaire.
Merci pour la précision, c'est bien plus large si c'est une extension POSIX

J'ai trouvé aussi qu'il existait une fonction standard (si je ne me trompe pas ^^) pour faire un peu la même chose : http://man.developpez.com/man3/memchr.3.php

**Adenora** · 12/02/2013, 20h37

Me revoilà.
Alors j'ai essayé de reprendre le code, mais ça ne fonctionne pas mieux :s
Le client envoie le pseudo, puis ça bloque au premier message.
J'ai mis en pièce jointe le schéma pour montrer où ça a l'air de bloquer (trait rouge).

Le 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
119
120
121
122
123
124
125
126
127
#include <stdlib.h>
#include <stdio.h>
#include <linux/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
 
typedef struct sockaddr sockaddr;
typedef struct sockaddr_in sockaddr_in;
typedef struct hostent hostent;
typedef struct servent servent;
 
char *msgs; // Pour stocker l'historique des messages
pthread_t threadReception;
int socket_descriptor;
 
/* Réception des messages */
void* reception (void* donnee) {
	int longueur;
    int connecte = 1;
    char buffer[1024];
    while (1) {
        if ((longueur = read(socket_descriptor, buffer, sizeof(buffer))) > 0) {
			printf("Message destinataire : \n");
			write(1, buffer, longueur);
			printf("Fin de la reception via Reception \n");
		}
    }
}
 
/* Envoi des messages */
void envoi () {
	char msgsend[1024] = "";
	char msgrecv[1024];
	int longueur; // Longueur d'un buffer utilise
 
	printf("Envoi d'un message au serveur. \n");
 
	printf("Votre message ?\n");
	scanf("%s",msgsend);
 
	// Mise en attente du programme pour simuler un délai de transmission
	sleep(1);
 
	printf("Message envoye : %s \n", msgsend);
 
	// Envoi du message vers le serveur
	if ((write(socket_descriptor, msgsend, strlen(msgsend))) < 0) {
		perror("Erreur : impossible d'ecrire le message destine au serveur");
		exit(1);
	}
 
	// Lecture de la réponse en provenance du serveur
	if ((longueur = read(socket_descriptor, msgrecv, sizeof(msgrecv))) > 0) {
		printf("Reponse du serveur : \n");
		write(1, msgrecv, longueur);
	}
 
	printf("Fin de la reception via Envoi. \n");
}
 
void connexion (char pseudo[]) {
	sockaddr_in adresse_locale; // adresse de socket local
	hostent* ptr_host; // info sur une machine hote
	servent* ptr_service; // info sur service
	char* host = "127.0.0.1";
	int longueur;
	char msgrecv[1024];
 
	printf("Adresse du serveur : %s \n", host);
 
	if ((ptr_host = gethostbyname(host)) == NULL) {
		perror("Erreur : impossible de trouver le serveur a partir de son adresse");
		exit(1);
	}
 
	// Copie caractère par caractère des infos de ptr_host vers adresse_locale
	bcopy((char*)ptr_host->h_addr, (char*)&adresse_locale.sin_addr, ptr_host->h_length);
	adresse_locale.sin_family = AF_INET;
 
	// Utiliser un nouveau numéro de port
	adresse_locale.sin_port = htons(5254);
	printf("Numero de port pour la connexion au serveur : %d \n", ntohs(adresse_locale.sin_port));
 
	// Création de la socket
	if ((socket_descriptor = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		perror("Erreur : impossible de creer la socket de connexion avec le serveur");
		exit(1);
	}
 
	// Tentative de connexion au serveur dont les infos sont dans adresse_locale
	if ((connect(socket_descriptor, (sockaddr*)(&adresse_locale), sizeof(adresse_locale))) < 0) {
		perror("Erreur : impossible de se connecter au serveur");
		exit(1);
	}
 
	printf("Connexion etablie avec le serveur. \n");
 
	printf("Envoi du pseudo.\n");
 
	// Envoi du message vers le serveur
	if ((write(socket_descriptor, pseudo, strlen(pseudo))) < 0) {
		perror("Erreur : impossible d'ecrire le message destine au serveur");
		exit(1);
	}
 
	// Lecture de la réponse en provenance du serveur
	if ((longueur = read(socket_descriptor, msgrecv, sizeof(msgrecv))) > 0) {
		printf("Reponse du serveur : \n");
		write(1, msgrecv, longueur);
	}
 
}
 
int main (int argc, char* argv[]) {
	char pseudo[50];
	printf("Choisissez votre pseudo\n");
	scanf("%s",pseudo);
 
	connexion(pseudo);
 
	while (1) {
		envoi();
	}
 
	return 0;
}

Le 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
#include <stdlib.h>
#include <stdio.h>
#include <linux/types.h> /* Pour les sockets*/
#include <sys/socket.h>
#include <netdb.h> /* Pour hostent,servent*/
#include <string.h> /* Pour bcopy...*/
#include <pthread.h>
#define TAILLE_MAX_NOM 256
#define MAX_CLIENT 100 // Le nombre maximum de client qui sera autorisé par le serveur
 
struct Client {
    int sockClient;
    int connecte;
    char pseudo[50];
    pthread_t threadReception;
};
typedef struct Client Client;
 
Client client[MAX_CLIENT];
 
int serveurPlein = 0;
 
typedef struct sockaddr sockaddr;
typedef struct sockaddr_in sockaddr_in;
typedef struct hostent hostent;
typedef struct servent servent;
 
 
void *receptionEnvoi (void* id2) {
    int i = 0;
    char buffer[1024];
    int connecte = 1;
    int longueur;
    int id = (int) id2;
 
	// Lecture du message
    if((longueur = read(client[id].sockClient, buffer, sizeof(buffer))) <= 0) {
		printf("Erreur envoi");
		return;
    }
    printf("Message lu : %s\n", buffer);
	buffer[longueur] = '\n';
	// A faire !! Ajouter le pseudo au début du message
 
	// Envoi du message à tout les clients
    do {
		if (client[i].connecte == 1) {
			if (write(client[i].sockClient, buffer, strlen(buffer)+1) < 0) {
				printf("Client deconnecte\n");
				close(client[i].sockClient);
				client[i].connecte = 0;
				serveurPlein = 0;
			}	
			printf("Message envoye\n");	
        }
        i++;
    }
    while (i < MAX_CLIENT);
}
 
int main (int argc, char **argv){
	pthread_t nouveau_client;
	int socket_descriptor,
		sock_temp,
	    nouv_socket_descriptor,
	    longueur_adresse_courante;
	sockaddr_in adresse_locale,	/* Structure adresse locale */
		    adresse_client_courant;
	hostent* ptr_hote; /* Les infos récupérées sur la machine hôte */
	servent* ptr_service; /* Les infos récupérées sur le service de la machine */
	char machine[TAILLE_MAX_NOM+1]; /* Nom de la machine locale */
	int i = 0;
	int longueur;
 
	gethostname(machine,TAILLE_MAX_NOM); /* Récupération du nom de la machine */
 
	/* Récupération de la structure d'adresse en utilisant le nom */
	if((ptr_hote = gethostbyname(machine)) == NULL) {
		perror("Erreur : impossible de trouver le serveur a partir de son nom.");
		exit(1);
	}
 
	/* Initialisation de la structure adresse_locale avec les infos récupérées */
 
	/* Copie de ptr_hote vers adresse_locale */
	bcopy((char*)ptr_hote->h_addr, (char*)&adresse_locale.sin_addr, ptr_hote->h_length);
	adresse_locale.sin_family = ptr_hote->h_addrtype; /* ou AF_INET */
	adresse_locale.sin_addr.s_addr = INADDR_ANY; /* ou AF_INET */
 
	/* Définition du service à utiliser à distance */
	adresse_locale.sin_port = htons(5254);
	printf("Numero de port pour la connexion au serveur : %d \n", ntohs(adresse_locale.sin_port));
 
	/* Création de la socket */
	if ((socket_descriptor = socket(AF_INET, SOCK_STREAM, 0)) < 0){
		perror("Erreur : impossible de creer la socket a l'adresse de connexion avec le client.");
		exit(1);
	}
 
	/* Association du socket_descriptor à la structure d'adresse adress_locale */
	if ((bind(socket_descriptor, (sockaddr*)(&adresse_locale), sizeof(adresse_locale))) < 0) {
		perror("Erreur : impossible de lier la socket a l'adresse de connexion.");
		exit(1);
	}
 
	listen(socket_descriptor, 5);
 
	for(;;){
		if (client[i].connecte == 0) {
			printf("Emplacement libre trouve :%d\n", i);
 
			longueur_adresse_courante = sizeof(adresse_client_courant);
			if ((sock_temp = accept(socket_descriptor, (sockaddr*)(&adresse_client_courant), &longueur_adresse_courante)) < 0) {
				perror("Erreur : impossible d'accepter la connexion avec le client");
				exit(1);
			}
 
			char pseudo[50] = "";
 
			// Lecture du pseudo
			if ((longueur = read(sock_temp, pseudo, sizeof(pseudo))) > 0) {
				write(sock_temp, "Connecte\n", 9);
 
				client[i].sockClient = sock_temp;
				client[i].connecte = 1;
				strcpy(client[i].pseudo,pseudo);
 
				printf("Client no %d connecte sous le pseudo: %s\n\n", i, client[i].pseudo);
 
				if (pthread_create(&client[i].threadReception, NULL, receptionEnvoi, (void*)i)) {	
					perror("Erreur pthread_create");
					exit(1);
				}
 
				i = 0;
 
				printf("Reception du message. \n");
			}
		}
		i++;
	}
	return 0;
}

Edit : J'avais oublié de mettre un "while(1)" dans la fonction receptionEnvoi du serveur. Donc effectivement, ça ne pouvait que bloquer. Je m'en veux d'avoir fait une erreur aussi bête.
Je vais maintenant essayer d'intégrer ce code dans l'interface.
Encore merci pour votre aide, je vais prendre en compte vos remarques.

**Joker-eph** · 15/02/2013, 03h49

La fonction receptionEnvoi() côté serveur est exécutée par un thread mais il manque une boucle. Elle recevra un message du client puis quittera (entraînant la terminaison du thread).

Un Tchat (N client(s), 1 serveur)

Réseau C

Discussions similaires

Partager

Partager