Discussion :

[kleveque]

Bonjour,

Pour un de mes cours, je doit créer un chat serveur-client en langage C, sous Linux. Une fois la connection établie entre le serveur et le client, le serveur doit se comporter comme un client : lire et écrire des message grâce à la fenêtre du terminal. J'ai pensé réaliser ce chat en utilisant la fonction select(). Problème : je ne comprend pas comment cette fonction fonctionne.

Voilà comment je pensais l'utiliser : Je met select() dans une boucle while et j'utilise un file descriptor pour écouter le socket et un autre pour écouter une entrée sur le terminal. Si select() rend quelque chose supérieur à 0, j'utilise FD_ISSET pour voir quel file descriptor ai modifié.

J'arrive à utiliser select() pour le socket mais je ne comprend pas comment l'utiliser pour détecter que l'on a écrit dans le terminal. Comment changer le file descriptor quand on écrit dans le terminal ?

J'espère ne pas vous avoir trop embrouillé . Est ce que quelqu'un pourrait m'éclairer sur l'utilisation de select() ?

Merci.

[Obsidian]

Bonsoir,

En fait, le fonctionnement de select() est plus simple qu'il y paraît : cet appel surveille un ensemble de descripteurs de fichiers, qui peuvent donc être en fait ceux de fichiers ordinaires, mais également de tubes ou de sockets, il bloque tant que c'est nécessaire, et débloque dès que l'un des descripteurs surveillés devient non bloquant.

L'idée est qu'en général, c'est le système lui-même qui te bloque si tu fais un appel en lecture et qu'il n'y a rien à lire, ou si tu cherches à écrire mais que la file est pleine. Comme, ici, on cherche à surveiller plusieurs descripteurs à la fois, il a fallu introduire l'appel select().

Plus précisément, tu vas ajouter tes descripteurs à un ou plusieurs de ces trois ensembles : readfds, writefds et exceptfds. Le troisième ne se déclenche que pour MSG_OOB et quelques autres cas. Comme la majorité des programmeurs, tu ne l'utilisera probablement jamais. Dès lors, dès qu'il devient possible de faire une opération de lecture sur un descripteur de readfs sans bloquer, alors select() débloquera. Même chose s'il devient possible d'écrire sur un des descripteurs de writefds, toujours sans bloquer.

Une fois débloqué, il t'appartient bien sûr de vérifier avec FD_ISSET quels sont les descripteurs qui sont effectivement exploitables.

Pour surveiller la console de l'utilisateur en plus des connexions réseau, donc, il te suffit d'ajouter le descripteur de l'entrée standard dans readfds avec les autres.

À noter un cas de figure qui ne te concerne pas directement mais qui est récurrent : on ne peut malheureusement pas utiliser ce mécanisme pour faire un « tail -f », c'est-à-dire attendre qu'un processus tiers ajoute des choses dans un fichier. Ceci est dû au fait que lorsque l'on atteint la fin d'un fichier dans une opération en lecture, celle-ci ne bloque pas mais renvoie EOF. Comme il n'y a rien de standard pour faire cela, il faut se pencher sur les systèmes de notification propres à chaque système. Sous Linux, par exemple, on utilisera « inotify ».

[kleveque]

Merci de ta réponse détaillée. Ça m'a été d'une grande aide pour comprendre comment select() fonctionne.

J'ai donc écrit mon programme de chat, mais malheureusement ça ne fonctionne pas. (Je précise que c'est la première fois que je fait ça, mes connaissances sont donc un peu limitées). Mon buffer reste vide lorsque je l'affiche. Voici mon programme (vu le nombre de modification que j'ai faite dessus, il est un peu brouillon, désolé) :

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
 
 
#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
 
 
int main(int argc, char **argv){
 
	char buffer[512]; // The buffer
	int mySocket = -1;
	int otherSocket = -1;
 
	// need by select
	int nb;
	fd_set read_set;
 
	// Use by the Server
	struct sockaddr_in servAddr, clientAddr; // The struct for adresses
	char *message; // The text
	int servAddr_length = -1;
 
	// Use by the client
	char *serverName = argv[1];
	struct sockaddr_in serverSockAddr;
	struct hostent *serverHostEnt;
 
	// resolv the adress
	struct hostent *resolv;
	struct in_addr *addr;
 
	// server
	if(argc == 1){
 
		servAddr.sin_port = htons(30000);
		servAddr.sin_family = AF_INET;
		servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
 
		// socket creation
		if((mySocket = socket(AF_INET,SOCK_STREAM,0))== -1){
			printf("error during socket's creation\n");
	  		exit(0);
		}
 
		// server-socket binding
		bind(mySocket,(struct sockaddr *)&servAddr,sizeof(servAddr));
 
		// socket listening
		listen(mySocket,5);
 
		// connection accepting
		servAddr_length = sizeof(clientAddr);
 
		otherSocket = accept(mySocket,(struct sockaddr *)&clientAddr,&servAddr_length);
 
	 		if (otherSocket < 0){
				printf("acception error\n");
			}
			else{
				printf("connection OK\n");
	  		}
	}
	// Client
	else if( argc == 2){
		resolv = gethostbyname(serverName);
		if (resolv==NULL) {
			printf("Address not found for %s\n", argv[1]);
			exit(-1);
		}
		else {
			addr = (struct in_addr*) resolv->h_addr_list[0];
			printf("The IP address of %s is %s\n", argv[1], inet_ntoa(*addr));
		}
 
		if(((long)inet_ntoa(*addr)) != (long)-1)
	  		bcopy(resolv->h_addr,&serverSockAddr.sin_addr,resolv->h_length);
 
		serverSockAddr.sin_port = htons(30000);
		serverSockAddr.sin_family = AF_INET;
 
		/* socket's creation */
		if((mySocket = socket(AF_INET,SOCK_STREAM,0)) < 0){
	  		printf("error during client socket's creation\n");
	  		exit(0);
		}
 
		/* demand of connection to the server */
		if(connect(mySocket,(struct sockaddr *)&serverSockAddr,sizeof(serverSockAddr)) < 0 ){
			printf("connection's error\n");
	  		exit(0);
		}
 
		printf("client OK\n");
 
	}
	else{
		printf("error");
		exit(-1);
	}
 
	// The communication
	while(1){
 
		// Clean the buffer
		bzero(buffer, sizeof(buffer));
 
		FD_ZERO(&read_set);
		FD_SET(0, &read_set);
		FD_SET(mySocket, &read_set);
 
		nb = select(mySocket+1, &read_set, NULL, NULL, NULL);
 
		if(nb <= 0){
			printf("Error with the select\n");
			exit(-1);
		}
 
		if(FD_ISSET(mySocket, &read_set)){
			nb = read(mySocket, buffer, sizeof(buffer));
			if(nb == 0){printf("EOF\n");}
			printf("%s\n", buffer);
		}
 
		if(FD_ISSET(0, &read_set)){
			nb = write(0, buffer, sizeof(buffer));
		}
 
		printf("buffer : ");
		printf("%s\n", buffer);
	}
 
	shutdown(mySocket,2);
	close(mySocket);
	close(otherSocket);
	return 0;
}

J'execute le serveur et le client en local, et l'entrée standard est 0. Quand ils sont connectés, rien ne s'affiche. Dès que je tape une lettre, l'affichage devient "buffer :", à l'infini. Sais tu d'où vient le problème ?

Merci.

[Obsidian]

Le problème vient d'ici :

Code :

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

1
2
3
    if(FD_ISSET(0, &read_set)){
        nb = write(0, buffer, sizeof(buffer));
    }