Sockets : Gerer plusieurs clients

**Hamtar0** · 11/03/2017, 00h34

Bonjour, j'ai crée grâce au socket un programme qui me permet de faire une discution entre un serveur et un client. C'était pas simple mais c'est fait (même si j'ai un petit bug au niveau du nettoyage de mes buffers)

Mais la j'ai besoin de gerer la connexion de 2 clients et la possibilité de leurs répondre.
Je cherche pas compliqué :

Le client 1 envoi un truc, je lui repond
Le client 2 m'envoi un truc, je lui repond

Une discussion où c'est chacun son tour en gros.
Ce n'est pas qu'une demande d'aide, c'est aussi pour savoir comment faire, je doit faire avec des fork et des processus pere/fils mais j'ai jamais rien fait de tel et faut que j'utilise ça ...

Voici mon code (pour une discussion avec 1 client)

Serveur.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
89
90
91
92
93
 
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define Internet_Port 2074
 
// -------------------  Serveur : Envoi
 
int main(int argc, char **argv){
    int sd_recu, lon, sr;
    struct sockaddr_in adsock, adacc;
    struct hostent *hptr;
    struct servent *sptr;
    char buffer_recu[100]="";
    char buffer_env[100]="Bye";
    char *prog;
    char *host;
    prog = argv[0];
 
    printf("\n____________\n SERVEUR \n------------\n\n ");
 
    // -------------------  Acquisition des infos Host
    host="localhost";
    if((hptr=gethostbyname(host))==NULL){
        perror("Probleme Info sur le host \n gethostbyname()");
        exit(1);
    }
 
    /* Initialiser le adsock avec les infos du host pour préparer adresse d'attachement */
    adsock.sin_family=AF_INET;
    adsock.sin_addr.s_addr=htonl(INADDR_ANY);
 
    // ------------------- récupération du numéro de port
    adsock.sin_port = htons(Internet_Port);
 
    // ------------------- création du socket
    if((sd_recu=socket(AF_INET,SOCK_STREAM,0))<0){
        perror("Erreur lors de la creation du socket \n socket()");
        close(sd_recu);
        exit(1);
    }
 
    if((bind(sd_recu,&adsock,sizeof(adsock)))<0){
        close(sd_recu);
        perror("Erreur lors du bind \n ");
        exit(1);
    }
 
    listen(sd_recu,5);
    lon = sizeof(adsock);
 
    if((sd_recu=accept(sd_recu,(char *)&adsock.sin_addr,&lon))<0){
        close(sd_recu);
        perror("Erreur accept \n accept()");
        exit(1);
    }
 
    // ------------------- boucle attente connexions
    while(strcmp(buffer_env,"STOP")){
        lon=sizeof(adsock);
 
        // ------------------- Reception de données
        if(recv(sd_recu,buffer_recu,sizeof(buffer_recu)-1,0)<0){
            perror("Erreur lors de la reception \n recv()");
            exit(1);
        }else{
            printf(" (Lui) <-- %s \n ",buffer_recu);
        }
        // ------------------- Envoi de données
        printf(" (Moi) --> ");
        fgets(buffer_env, sizeof(buffer_env), stdin);
        if((send(sd_recu,buffer_env,sizeof(buffer_env),0))<0){
            perror("Erreur lors de l'ecriture \n send()");
            exit(1);
        }
 
        for (int i=0; i>strlen(buffer_recu); i++){
            buffer_env[i]='\0';
            buffer_recu[i]='\0';
        }
 
 
    }
    // ------------------- Fin Programme
    close(sd_recu);
    exit(0);
}

Client.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
 
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define Internet_Port 2074
 
// -------------------  Client : Envoi et Reception
 
int main(int argc, char **argv){
    int sd_env, n;
    struct sockaddr_in adsock; // Structure d'adresse du sock
    struct hostent *hostinfo; // Structure d'infos de l'host
    char buffer_env[9999]=""; // buffer_env pour les messages
    char buffer_recu[9999]="";
    char *host;
 
    printf("\n____________\n CLIENT \n------------\n\n ");
 
 
 
    // -------------------  Création du socket
    if((sd_env=socket(AF_INET, SOCK_STREAM, 0)) < 0){
        perror("Erreur creation socket ...");
        close(sd_env);
        exit(1);
    }
 
    // -------------------  Acquisition des infos Host
    host="localhost";
    if ((hostinfo=gethostbyname(host)) == NULL){
        perror("Host inconnu ...");
        exit(1);
    }
 
    // ------------------- Initialisation struct adsock avec infos de l'host, préparation de l'adresse d'attachement
    bcopy((char *)hostinfo->h_addr,(char *)&adsock.sin_addr.s_addr,hostinfo->h_length);
    adsock.sin_family = hostinfo->h_addrtype;
 
    // -------------------  On récupère le numéro de port
    adsock.sin_port=htons(Internet_Port);
 
    // -------------------  On va établir une connexion avec le serveur
    if(connect(sd_env, (struct sockaddr *)&adsock, sizeof(adsock)) < 0){
        perror("Probleme de connexion \n connect()");
        close(sd_env);
        exit(1);
    }
    listen(sd_env,5);
    while(strcmp(buffer_env, "STOP")){
        // ------------------- Envoi de données
        printf(" (Moi) --> ");
        fgets(buffer_env, sizeof(buffer_env), stdin);
        if(send(sd_env, buffer_env, strlen(buffer_env), 0) < 0){
            perror("Erreur lors de l'envoi \n send()");
            exit(1);
        }
        // ------------------- Reception de données
        if(recv(sd_env, buffer_recu, sizeof buffer_recu - 1, 0) < 0){
            perror("Erreur lors de la reception \n recv()");
            exit(1);
        }else{
            printf(" (Lui) <-- %s \n ",buffer_recu);
        }
 
        for (int i=0; i>strlen(buffer_recu); i++){
            buffer_env[i]='\0';
            buffer_recu[i]='\0';
        }
 
    }
    // ------------------- Fin Programme
    close(sd_env);
    exit(0);
}

Merci d'avance pour votre aide à tous !

**Obsidian** · 11/03/2017, 00h53

Bonjour et bienvenue,
L'appel qu'il te faut est select().

Tu peux jeter un œil à ce fil, également.

**Hamtar0** · 11/03/2017, 01h30

Si j'ai bien compris ce que j'ai lu, le select me permet de gerer le passage d'un client à un autre ?
Mais je comprend pas trop les paramètres qu'il prend ...

Serait-ce select(n°client, socket, NULL, NULL, temps) ?

**Obsidian** · 11/03/2017, 11h19

Bonjour,

Envoyé par Hamtar0

Si j'ai bien compris ce que j'ai lu, le select me permet de gerer le passage d'un client à un autre ?

Non, select() te permet de surveiller plusieurs descripteurs en même temps. Cet appel est bloquant tant que tous les descripteurs surveillés sont eux-mêmes bloquants dans les conditions spécifiées (en lecture, en écriture, autre…) et rend la main dès qu'au moins un des descripteurs devient non-bloquant. Cela te permet de gérer à la fois les sollicitations des différents clients et les nouvelles connexions entrantes.

Pour cela, il te faut définir plusieurs « jeux de descripteurs » (fdset), un pour chaque condition, qui contienne tous les descripteurs à surveiller.

Ces jeux d'ensemble se remplissent avec les macros FD_SET, FD_ZERO, etc. décrites dans la man page. C'est nécessaire parce qu'à chaque descripteur est associé plusieurs qui vont te permettre ensuite de savoir quels sont les descripteurs qui ont débloqué l'appel (car il peut y en avoir plusieurs en même temps).

Mais je comprend pas trop les paramètres qu'il prend ...
Serait-ce select(n°client, socket, NULL, NULL, temps) ?

Le premier paramètre est le numéro du plus grand descripteur (tous jeux confondus) + 1 (pour qu'il sache jusqu'où aller) ;
Les trois suivants sont des pointeurs vers chacun des trois ensembles, respectivement, ou NULL ;
Le dernier est un pointeur vers une structure timeval indiquant une valeur de timeout, c'est-à-dire un délai maximum au delà duquel l'appel rendra la main quoi qu'il se passe. NULL aussi si tu ne veux pas que cela arrive.

**Hamtar0** · 11/03/2017, 11h45

Désolé ... mais je comprend pas du tout comment mettre en place le select dans mon code ...
Tu n'aurait pas un exemple à me montrer ? Ou une autre discussion où la personne à résolu son problème ?

**Obsidian** · 11/03/2017, 11h55

Par ici : https://www.developpez.net/forums/d1...r/#post5935973

**Hamtar0** · 11/03/2017, 12h05

J'ai lu l'exemple donné, est-ce different / plus compliqué qu'avec un système de fork ?

**Obsidian** · 11/03/2017, 15h00

Ça n'a rien à voir. C'est à la fois très différent et beaucoup plus simple qu'un système de fork, et même de threads, en réalité.

D'abord, sur le plan purement algorithmique : pendant très longtemps, les machines personnelles n'étaient pas du tout multitâches (hormis quelques hacks basés sur les interruptions du timer) et il appartient à tout programmeur de parvenir à trouver une solution qui permette de gérer ce cas de figure. Et ça se fait généralement avec l'approche que tu as fini par entrevoir, c'est-à-dire une boucle principale et un système de tickets.

Il faut ensuite identifier ce qui t'empêche de suivre ce modèle jusqu'au bout : tu peux utiliser tous les appels systèmes ordinaires jusqu'au moment où tu te retrouves à attendre une entrée extérieure. Les appels bloquants font parfaitement l'affaire mais t'empêchent par nature de te mettre en attente de plusieurs sources à la fois. C'est uniquement à ce moment-là que le système lui-même a besoin d'être mis à jour pour prendre en compte ce cas de figure et il l'a été avec l'introduction de select() (puis poll(), puis pselect() et ppoll()).

Ensuite, le système à threads est intéressant depuis que les systèmes sont capables de gérer cela proprement mais ça ne le reste qu'à partir du moment où tu as un nombre restreint de clients effectuant des tâches assez complexes. Dans le cas contraire, cela devient prohibitif en ressources pour le système : si tu as mille clients sur un serveur IRC ou assimilé, tu ne vas pas ouvrir mille threads…

select() n'est pas très difficile en fin de compte :

Tu écris une grosse boucle while() dans ton programme qui te sert de boucle principale. Et tu rédiges tout ce qui suit à l'intérieur ;
Dans le corps de ta boucle, donc, tu commences par déclarer une variable de type fdset. Par exemple : fdset lecture;.
Tu initialises cette instance avec FD_ZERO en passant l'adresse de ta variable : FD_ZERO(&lecture);
Tu ajoutes à ton instance tous les descripteurs que tu veux surveiller avec FD_SET. Premier paramètre : le descripteur ; second paramètre, l'adresse de ton instance, là encore : FD_SET(fd,&lecture) ;
Au besoin, tu suis la même procédure avec les descripteurs en écriture (et en leur déclarant un fdset propre) ;
Tu appelles select() en passant en argument : 1) le numéro du plus grand descripteur enregistré, tous jeux confondus, plus « 1 » ; 2) l'adresse de ton jeu de descripteurs en lecture (&lecture) ; 3) l'adresse de ton jeu de descripteurs en écriture s'il existe, ou NULL ; 4) le jeu des conditions exceptionnelles. Tu peux mettre toujours NULL ici ; 5) la valeur de timeout, ou NULL, là encore ;
select() bloque jusqu'à ce qu'il y ait quelque chose à lire ;
Tu passes en revue tous les descripteurs que tu as ajouté avant ton appel et tu utilises FD_ISSET() pour savoir s'ils sont encore dans le jeu examiné. S'ils le sont, cela veut dire qu'un appel sur ce descripteur en particulier ne sera pas bloquant, et donc qu'il y a quelque chose à traiter (c'est-à-dire à lire, à écrire, ou autre) ;
Tu traites chacun de ces descripteurs comme tu l'entends ;
Tu refermes ta boucle. Elle recommencera d'elle-même un nouveau cycle pour traiter la suite.

**Hamtar0** · 11/03/2017, 20h39

Bonsoir, donc si j'ai compris :

Le select() permet de voir quel client parle, et réceptionner ses données ?
J'ai essayé avec ça, mais je suis pas sur que j'ai bien fait ... vu que si j'ouvre 2 client ça gère pas les deux 😛 :

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
 
#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define Internet_Port 2074
 
// -------------------  Serveur : Envoi
 
int main(int argc, char **argv){
    int sd, lon;
    struct sockaddr_in adsock, adacc;
    struct hostent *hptr;
    struct servent *sptr;
    char buffer_recu[100], buffer_env[100];
    char *prog;
    char *host;
 
    prog = argv[0];
    host="localhost";
 
    printf("\n____________\n SERVEUR \n------------\n\n ");
 
    // -------------------  Acquisition des infos Host
    if((hptr=gethostbyname(host))==NULL){
        perror("Probleme Info sur le host \n gethostbyname()");
        exit(1);
    }
 
    // Initialiser le adsock avec les infos du host pour préparer adresse d'attachement
    adsock.sin_family=AF_INET;
    adsock.sin_addr.s_addr=htonl(INADDR_ANY);
 
    // ------------------- récupération du numéro de port
    adsock.sin_port = htons(Internet_Port);
 
    // ------------------- création du socket
    if((sd=socket(AF_INET,SOCK_STREAM,0))<0){
        perror("Erreur lors de la creation du socket \n socket()");
        close(sd);
        exit(1);
    }
 
    if((bind(sd,&adsock,sizeof(adsock)))<0){
        close(sd);
        perror("Erreur lors du bind \n ");
        exit(1);
    }
 
    listen(sd,5); lon = sizeof(adsock);
 
    if((sd=accept(sd,(char *)&adsock.sin_addr,&lon))<0){
        close(sd);
        perror("Erreur accept \n accept()");
        exit(1);
    }
 
    // ------------------- boucle attente connexions
    while(1){
        fd_set lecture;
        FD_ZERO(&lecture);
        FD_SET(sd,&lecture);
        select(sd+1,&lecture,NULL,NULL,NULL);
        if (FD_ISSET(sd, &lecture)){
            // ------------------- Reception de données
            if(recv(sd,buffer_recu,sizeof(buffer_recu)-1,0)<0){
                perror("Erreur lors de la reception \n recv()");
                exit(1);
            }
            printf(" <-- %s \n ",buffer_recu);
 
            // ------------------- Envoi de données
            printf(" --> ");
            fgets(buffer_env, sizeof(buffer_env), stdin);
            if((send(sd,buffer_env,sizeof(buffer_env),0))<0){
                perror("Erreur lors de l'ecriture \n send()");
                exit(1);
            }
 
            // ------------------- Nettoyage des buffers
            memset(buffer_recu, '\0', 100);
            memset(buffer_env, '\0', 100);
            printf("---------------------- \n");
        }
 
 
    }
    // ------------------- Fin Programme
    close(sd);
    exit(0);
}

Je pense que je fait n'importe nawak

**Obsidian** · 11/03/2017, 21h05

Envoyé par Hamtar0

Bonsoir, donc si j'ai compris :
Le select() permet de voir quel client parle, et réceptionner ses données ?

Pas tout-à-fait : select() permet de se mettre en attente de plusieurs descripteurs bloquants à la fois, et de rendre la main dès qu'au moins l'un d'eux devient non bloquant. Et FD_ISSET permet de savoir ensuite lequel ou lesquels sont effectivement devenus non bloquants, et que l'on peut donc traiter.

Par contre, ce n'est pas select() qui va lire les données entrantes lui-même.

Je pense que je fait n'importe nawak

Un socket est une ressource que tu peux utiliser à n'importe quoi. Quand tu crées un socket et que tu le mets à l'écoute des connexions entrantes avec listen(), ce n'est pas à travers lui que tu vas recevoir les informations en provenance de tes clients. Il va juste accueillir les connexions.

Une connexion entrante sur le port concerné va débloquer le socket en lecture (il faut donc l'ajouter à readfs comme les autres). Il faut ensuite accepter la connexion entrante à l'aide de accept(). Et cette fonction accept() va te retourner un autre socket qui, lui, correspond au canal de communication avec ton client. Tu te retrouves donc avec deux sockets : celui retourné par accept(), et celui que tu avais ouvert toi-même pour écouter le port. Celui-ci continue à exister normalement parallèlement à l'autre, et à recevoir toutes les connexions à venir. Au final, tu te retrouveras avec autant de sockets que de connexions actives (donc de clients en cours), plus le socket à l'écoute du port.

Il t'appartient d'enregistrer tous ces descripteurs de socket dans un tableau, et de tous les ajouter à ton select() à chaque tour de boucle avec FD_SET.

**Hamtar0** · 11/03/2017, 23h11

Désolé ... mais je comprend limite tout ce que tu me raconte ...
Tu m'explique comment ça marche je le voit bien, mais tout ça m'aide malheureusement à le programmer (ou je suis trop bete ..)

**Obsidian** · 11/03/2017, 23h43

Dans ce cas, reprends l'exemple en question et essaie de le compiler.

Compare ensuite ce listing avec ce que tu as écrit. Tu t'apercevras que tu as déjà fait 80% du travail.

Sockets : Gerer plusieurs clients

C

Discussions similaires

Partager

Partager