Création d'un chat

**AddicTion** · 04/04/2010, 15h18

salut tout le monde

alors j'ai commencé depuis peu à vouloir créer un "chat" simple.

j'utilise donc les sockets qui marchent mais j'ai 2 questions ou plutôt 2 problèmes

1) je n'arrive pas bien à comprendre comment gérer les sockets "send" et "recv"...

Je m'explique. Dans le client je doit taper une phrase et l'envoyer sur le serveur qui lui même renvoi la phrase sur touts les clients qui sont connectés,
mais je ne sais pas comment mettre ça en place

j'avais pensé à : send(s, "%s : %s ", pseudo, chaine, 0); mais ça ne marche pas

puis ensuite il faut la commande pour que le serveur reçoive et renvoi cette chaine de caractères.

2) quand je fait se connecter un client au serveur ça marche

mais discuter tout seul ça ne sera pas drôle

donc lorsque que je lance 2x le client le premier marche et le serveur dit "l'ip xxxx vient de se connecter" mais pour le 2 ème c'est un écran noir... Car à mon avis le serveur ne reste pas à l'écoute

voici la source:

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
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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <string.h>
#include <winsock2.h>
 
static void purger(void)
{
    int c;
 
    while ((c = getchar()) != '\n' && c != EOF)
    {}
}
 
static void clean (char *chaine)
{
    char *p = strchr(chaine, '\n');
 
    if (p)
    {
        *p = 0;
    }
 
    else
    {
        purger();
    }
}
 
int main(int argc, char *argv[])
{
    char chaine[500];
    char pseudo[30];
 
    printf("inserez votre pseudo\n\n"); 
 
    scanf("%s", &pseudo);
printf("\n\nBienvenu %s\n", pseudo);
getch();
 
system("CLS");
 
 
    WSADATA wsaData;
 
    if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0)
        fprintf(stderr, "La fonction WSAStartup a echoue.\n");
    else
    {
        SOCKET s;
 
        s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (s == INVALID_SOCKET)
            fprintf(stderr, "La fonction socket a echoue.\n");
        else
        {
            SOCKADDR_IN server;
 
            server.sin_family       = AF_INET;
            server.sin_addr.s_addr  = inet_addr("127.0.0.1");
            server.sin_port         = htons(5050);
            memset(&server.sin_zero, '\0', sizeof(server.sin_zero));
 
            if (connect(s, (SOCKADDR *)&server, sizeof(server)) == SOCKET_ERROR)
                fprintf(stderr, "La fonction connect a echoue.\n");
            else
            {
                char buffer[100];
 
                int n;
 
                n = recv(s, buffer, sizeof(buffer) - 1, 0); 
 
                if (n != SOCKET_ERROR)
                {
                    buffer[n] = '\0';
                    printf("%s", buffer);
 
while (1)
{
printf("\n%s : ", pseudo);
 
    fgets(chaine, sizeof chaine, stdin);
    clean(chaine);
 
    printf("%s : %s ",pseudo, chaine); // on enlevera cela pour remplacer par un "send" au serveur qui renverra le message à chaque client connecté 
 
    if  ( strcmp( chaine, "exit" ) == 0 )
    { 
 
       goto fin; // je sais goto c'est pas bien mais c'est juste pour faire les testes en attendant :p 
 
    }  
}     
           fin: 
                    send(s, "Au revoir\n", (int)strlen("Au revoir\n"), 0); 
 
 
                }
 
                shutdown(s, SD_SEND);
            }
 
            closesocket(s);
        }
 
        WSACleanup();
    }
 
    return 0;
}

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <string.h>
#include <winsock2.h>
 
static void purger(void)
{
    int c;
 
    while ((c = getchar()) != '\n' && c != EOF)
    {}
}
 
static void clean (char *chaine)
{
    char *p = strchr(chaine, '\n');
 
    if (p)
    {
        *p = 0;
    }
 
    else
    {
        purger();
    }
}
 
int main()
{
 
    WSADATA wsaData;
 
    if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0)
        fprintf(stderr, "La fonction WSAStartup a echoue.\n");
    else
    {
        SOCKET s_server;
 
        s_server = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (s_server == INVALID_SOCKET)
            fprintf(stderr, "La fonction socket a echoue.\n");
        else
        {
            SOCKADDR_IN server;
 
            server.sin_family       = AF_INET;
            server.sin_addr.s_addr  = htonl(INADDR_ANY);
            server.sin_port         = htons(5050);
            memset(&server.sin_zero, '\0', sizeof(server.sin_zero));
 
            if (bind(s_server, (SOCKADDR *)&server, sizeof(server)) == SOCKET_ERROR)
                fprintf(stderr, "La fonction bind a echoue.\n");
            else
            {
                if (listen(s_server, 0) == SOCKET_ERROR) /* listen : commencer l'ecoute */
                    fprintf(stderr, "La fonction listen a echoue.\n");
                else
                {
                    SOCKET s_client;
                    SOCKADDR_IN client;
                    int csize = sizeof(client);
 
                    s_client = accept(s_server, (SOCKADDR *)&client, &csize);
 
                    if (s_client == INVALID_SOCKET)
                        fprintf(stderr, "La fonction accept a echoue.\n");
                    else
                    {
                        char buffer[500];
                        char chaine[500];
                        int n;
 
                        printf("Le client %s s'est connecte !\n", inet_ntoa(client.sin_addr));
 
                        strcpy(buffer, "Bonjour\n");
                        send(s_client, buffer, (int)strlen(buffer), 0);
 
                        n = recv(s_client, buffer, sizeof(buffer) - 1, 0);
 
 
 
 
 
 
                        /*
                        getch(); 
                        */
                        if (n != SOCKET_ERROR)
                        {
                            buffer[n] = '\0';
                            printf("%s", buffer);
                        }
 
                        closesocket(s_client);
                    }
                }
            }
 
            closesocket(s_server);
        }
 
        WSACleanup();
    }
 
    return 0;
}

**Ulrik18** · 05/04/2010, 11h59

Salut Addiction !

c'est une belle idée d'essayer de faire un chat simple ...

Pour ta première question, déja "send" et "recv" sont des fonctions et non des "sockets" ! Elles ont donc un prototype, à quatre paramètres pour les deux, qu'il faudrait respecter pour les utiliser... l'ajout d'un paramètre n'a donc aucune chance de marcher (parce que la fonction que tu essaies d'appeler n'existe pas)... Je te suggère de construire au niveau du serveur un tableau de Sockets clients ... chaque socket retournée par la fonction accept() occupera une case du tableau. et dès lors dès que tu reçois un message au niveau du serveur avec recv , tu utiliseras une boucle pour parcourir ton tableau et envoyer le message reçu à toutes les sockets du tableaux (donc à tous tes utilisateurs) ...

Deuxième question : Oui tu l'as bien compris, c'est au niveau du mécanisme écoute/acceptation de la sockets serveur ! Mais en fait, ta socket reste en écoute (vu que tu l'y as mise avec la fonction "listen") ... donc toutes les demandes de connections des clients (à partir de la fonction "connect") viennent s'aligner dans une file d'attente, mais ne sont pas acceptées tout d'un coup ! Il faut utiliser la fonction accept pour accepter chaque demande de connexion (selon leur ordre d'arrivée) !
Autrement dit, autant de client à accepter, autant d'accept et autant de socket clients retournées par accept (d'où l'idée d'utilisation du tableau plus haut) ! Donc en fait tu dois faire une boucle (peut-être infinie) sur accept pour pouvoir accepter tous tes clients et chaque socket client retournée, tu l'insères dans une cellule du tableau....

Bonne continuation

**AddicTion** · 05/04/2010, 14h21

je te remercie de cette réponse et je vais l'approfondir en espèrent y arriver car à première vu ça reste flou

mais je ferais le nécessaire pour comprendre

**AddicTion** · 15/04/2010, 18h43

bonjour

bon sa faisait un moment que je ne me suis pas re-penché sur mon sujet.

j'ai fait la boucle infinie (très simple sans faire de tableau) pour l'écoute qui marche.

Quand je veut envoyer un texte sur le serveur j'utilise donc

Code :

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

send(s, "%s : %s ", (int)strlen("%s : %s "), 0);

mais quand je veut mettre mes variables, pseudo et chaine pour les "%s" ça ne compile pas donc le serveur reçois "%s : %s"

ensuite je pense qui faudra que je fasse un boucle au serveur pour récupérer les messages et les renvoyer sur touts les clients.

c'est un peu le bazar dans ma tête la

j'avais essayé de cette manière qui ne marche pas

Code :

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

send(s, "%s : %s ", pseudo, chaine, (int)strlen("%s : %s ", pseudo, chaine), 0);

Merci à ceux qui m'aideront

**Obsidian** · 15/04/2010, 19h18

Bonjour,

Envoyé par AddicTion

Quand je veut envoyer un texte sur le serveur j'utilise donc

Code :

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

send(s, "%s : %s ", (int)strlen("%s : %s "), 0);

Tu ne peux pas procéder de cette manière car cette syntaxe n'est pas commune au C mais propre à printf() et à ses dérivées, car cette fonction sert précisément à « formatter du texte ».

Il faut donc déclarer un buffer suffisamment long, écrire dedans avec snprintf() et, enfin, envoyer le contenu de ce buffer avec send().

Bon courage.

**AddicTion** · 15/04/2010, 20h52

Il faut donc déclarer un buffer suffisamment long, écrire dedans avec snprintf() et, enfin, envoyer le contenu de ce buffer avec send().

Merci,

je vais voir si je trouve des choses sur ça

ne connaitrais-tu pas une source contenant cette technique ou un exemple

je vais déjà commencer à aller faire un tour sur

**ram-0000** · 15/04/2010, 21h38

Si tu veux utiliser la puissance des chaines formattées à la printf, tu peux faire comme cela :

Code :

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

1
2
3
char buffer[1024];
   sprintf(buffer, "%s : %s ", pseudo, chaine);
   send(s, buffer, strlen(buffer), 0);

C'est l'idée mais bien sûr, il faut avoir un buffer suffisement grand pour pourvoir accepter tous les messages sans déborder (ou alors utiliser snprintf)

**AddicTion** · 15/04/2010, 22h43

Merci j'ai réussir à compiler jusqu'à un buffer de 500 000...

comment ça se présenterais avec snprintf ?

Maintenant que la commande pour envoyer du texte sur le serveur marche, il faut trouver le moyen qu'il en reçoive en boucle et les renvoie en boucle également mais pareille ça ne marche pas comme je le veut

je voulais faire une simple boucle infini de cette manière mais ça ne marche pas

Code :

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

1
2
3
4
5
while (1)
                        {
                        n = recv(s_client, buffer, sizeof(buffer) - 1, 0);
                        send(s_client, buffer, (int)strlen(buffer), 0);
                        }

**ram-0000** · 16/04/2010, 00h03

Envoyé par AddicTion

Merci j'ai réussir à compiler jusqu'à un buffer de 500 000...

500 000 me parait un tantinet exagéré. La mémoire n'est pas chère mais quand même

.

**jabbounet** · 16/04/2010, 00h53

pour compléter tes connaissances sur les chaussettes

je te suggère d'aller faire un tour dans le tutoriel
http://broux.developpez.com/articles/c/sockets/

cela te donnera peu être des idées pour améliorer ton serveur et ton client.

**SeRiALP** · 20/04/2010, 01h32

en gros tu n'avait pas compris l'utilisation de recv et send... en plus ce sont pas des sockets mais plutôt des appels systèmes qui te permettent d'envoyer et recevoir des informations sur les sockets que tu définiras a tes dites fonctions. De plus faudrait savoir que recv et send fonction "exactement"
comme read et write, a la difference que recv et send prenne un 4e paramètre qui lui est généralement set'é à 0;

donc recv <==> read et send <==> write .

je viens de coomnecer la programmation reseau comme toi, et je ne fais qu'avec des read et write (on me l'impose...) mais send et recv sont nettement plus adaptes pour travailler sur les socekets.

voila,

**AddicTion** · 14/05/2010, 22h29

J'ai réussi depuis à régler pas mal de problèmes.
Mon problème actuel est de faire le serveur Multi-Client

J'ai fait de nombreuse recherches mais sans vraiment trouver de réponses

dans un premier temps il faut déjà que je récupère les infos du client sur le serveur (IP et port) qui ne devrait pas me poser de problème vu que des tas de tuto explique la manière de procéder. En revanche je bloque vraiment pour les threads qui permettraient la gestion de plusieurs client. Et je suppose que les infos client devront êtres stockées dans un tableau

Merci.

**AddicTion** · 04/06/2010, 21h48

j'ai fini par parvenir à faire le serveur multi-client

sauf que ...(ba oui y a toujours quelque chose pour faire chier)

quand 2 clients sont connectés ils reçoivent que leurs propre messages et pas ceux des autre

faut t-il que les clients soit stockés dans un tableau ? je ne vois pas trop comment faire

source:

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <string.h>
#include <winsock2.h>
#include <pthread.h>
#include "var.h"
 
 
void* maFonction(void* data);
 
 
int main()
{
 
    WSADATA wsaData;
 
    if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0)
        fprintf(stderr, "La fonction WSAStartup a echoue.\n");
    else
    {
        SOCKET s_server;
 
        s_server = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (s_server == INVALID_SOCKET)
            fprintf(stderr, "La fonction socket a echoue.\n");
        else
        {
            SOCKADDR_IN server;
 
            server.sin_family       = AF_INET;
            server.sin_addr.s_addr  = htonl(INADDR_ANY);
            server.sin_port         = htons(5050);
            memset(&server.sin_zero, '\0', sizeof(server.sin_zero));
 
            if (bind(s_server, (SOCKADDR *)&server, sizeof(server)) == SOCKET_ERROR)
              fprintf(stderr, "La fonction bind a echoue.\n");
 
            else
            {
 
                if (listen(s_server, 0) == SOCKET_ERROR) /* listen : commencer l'ecoute */
                    fprintf(stderr, "La fonction listen a echoue.\n");
                else
                {
                     /* Création de l'ensemble de lecture */
                    fd_set readfs;
 
 
                    while(1)
                         {
                        /* On vide l'ensemble de lecture et on lui ajoute
                        la socket serveur */
                        FD_ZERO(&readfs);
                        FD_SET(s_server, &readfs);
 
                        /* On regarde si la socket serveur contient des
                        informations à lire */
                        if(FD_ISSET(s_server, &readfs))
                        {
                            /* Ici comme c'est la socket du serveur cela signifie
                            forcement qu'un client veut se connecter au serveur.
                            Dans le cas d'une socket cliente c'est juste des
                            données qui serons reçues ici*/
 
                    SOCKET s_client;
                    SOCKADDR_IN client;
                    int csize = sizeof(client);
 
                    s_client = accept(s_server, (SOCKADDR *)&client, &csize);
 
                    if (s_client == INVALID_SOCKET)
                        fprintf(stderr, "La fonction accept a echoue.\n");
                    else
                    {
 
                        char buffer[1024];
                        char buff[1024];
                        int n;
 
                        printf("Le client %s s'est connecte !\n", inet_ntoa(client.sin_addr));
 
 
                         strcpy(buffer, "Bonjour\n");
 
                         send(s_client, buffer, (int)strlen(buffer), 0);
 
                        n = recv(s_client, buffer, sizeof(buffer) - 1, 0);
 
                        pthread_t thread;
                        pthread_create(&thread, NULL, maFonction, &s_client);
 
                        }
                         }
 
                    }
                }
            }
 
 
        }
 
        WSACleanup();
    }
 
    return 0;
}
 
 
 
void* maFonction(void* data)
{
struct vari res;
res.s_client = *(int*)data;
 
while(1)
   {
memset(res.buffer, '\0', sizeof(res.buffer));
res.n = recv(res.s_client, res.buffer, sizeof(res.buffer) - 1, 0);
printf("%s\n",res.buffer);
strcpy(res.buff, ("%s\n", res.buffer));
send(res.s_client, res.buff, (int)strlen(res.buff), 0); 
   }
}

Création d'un chat

Réseau C

Discussions similaires

Partager

Partager