Client / serveur avec des sockets

4 pièce(s) jointe(s)

Bonsoir je dois faire un client serveur pour remettre a la fin du mois de Mai sdv;mon programme n'a pas d'erreur mais il n'est pas correctement fonctionnel.
Lors de la discussion entre le client et le serveur ou avec plusieurs clients;le message envoyé par le serveur ;le client le reçoit bien sauf qu'il ya des mots qui apparaissent en plus du messge envoyé.
Regarder ci après:
Pièce jointe 145063 Pièce jointe 145064 Pièce jointe 145065
Voilà ci dessus;il y a des captures d'écran du serveur et des deux clients.
Lorsque le serveur parle avec les deux clients en leur disant salut;il n'y a pas d'imperfection;or nous remarquons que lorsqu'il répond wi sava;les clients reçoivent bien le message;mais on constate qu'il y a des mots en plus qui ont apparut.Et aussi lorqu'un client dit aurevoir sa connexion est fermée mais le message est censé être reçu par le serveur avant la fermeture ;mais le mot aurevoir s'affiche au niveau du client.
Par contre lorsque je réexécute mon programme apès modification cela m'affiche le messge(voir dans le dernier terminal).
J'aimerais que vous me dites qu'est ce qui ne va pas dans mon code pour que cela puisse se produire;svp.
Je vous remercie d'avance.

Client.c

Code:

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
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include<sys/types.h>
int main()
{
 
    pid_t pid;
    int id;
    char msg[255];//variable qui contiendrat les messages
 
    struct sockaddr_in informations;  //structure donnant les informations sur le serveur
 
    /*initialisation du protocole, TCP  l'adresse de connection 127.0.0.1 (en local) et du port du serveur (1400)*/
    informations.sin_family = AF_INET;
    informations.sin_port = htons(2500);
    informations.sin_addr.s_addr = inet_addr("127.0.0.1");
 
    int socketID = socket(AF_INET, SOCK_STREAM, 0); // creation du socket propre au client
 
    if (socketID == -1)    //test de création du socket
    {
        perror("socket");
        exit (-1);
    }
 
    if ((connect(socketID, (struct sockaddr *) &informations, sizeof(struct sockaddr_in))) == -1)   //connexion au serveur
    {
        perror("connect");
        exit (-1);
    }
 
    if (strcmp(msg, "aurevoir") != 0)
    {
        memset(msg, 0, 255);
        recv(socketID, msg, 255, 0);
        printf ("%s\n", msg);
    }
 
    do
    {
        id+=1;
        printf ("moi : ");
        fgets(msg, 255, stdin);// le client ecrit son message
        msg[strlen(msg) - 1] = '\0';
 
        if ((send(socketID, msg, strlen(msg), 0)) == -1)
            perror("send");
        recv(socketID, msg, 255, 0);
        printf ("Phrase reçue : %s\n", msg);
 
    }
    while (strcmp(msg, "aurevoir") != 0);    // tant que le client n'envoie pas "aurevoir" la conversation n'est pas fini
 
    shutdown(socketID, SHUT_RDWR);// fermeture du socket
 
    return 0;
 
}

Serveur.c

Code:

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
#include<signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
    //structure donnant les informations sur le serveur et sur le client
    struct sockaddr_in information_server;
    struct sockaddr_in information_client;
 
    int socketID = socket(AF_INET, SOCK_STREAM, 0);
    int connexion = 0;
    int pid;
    int id;
    char msg[255];
 
    id=0;
    socklen_t len = sizeof(struct sockaddr_in); //déclaration d' une variable du type socklen_t qui contiendra la taille de la structure
 
    if (socketID == -1)
    {
        perror("socket");
        exit(-1);
    }
 
    /*initialisation du protocole, TCP  l'adresse de connection 127.0.0.1 (en local) et du port du serveur (1400)*/
    memset(&information_server, 0, sizeof(struct sockaddr_in));
    information_server.sin_port = htons(2500);
    information_server.sin_family = AF_INET;
 
    /* création de la connexion*/
    if ((bind(socketID, (struct sockaddr *) &information_server, sizeof(struct sockaddr))) == -1)
    {
        perror("bind");
        exit(-1);
    }
 
    /* le serveur écoute si un client cherche à se connecter*/
    if ((listen(socketID, 5)) == -1)
    {
        perror("listen");
        exit (-1);
    }
    while (1)
    {
 
        memset(&information_client, 0, sizeof(struct sockaddr_in));
        connexion = accept(socketID, (struct sockaddr *) &information_client, &len); //le serveur accepte la connexion
 
        if (connexion == -1)
        {
            perror("accept");
            exit(-1);
        }
        id+=1;
        /* Create child process */
        pid = fork();
 
        if (pid < 0)
        {
            perror("ERROR on fork");
            exit(1);
        }
        if (pid == 0)
        {
            /* This is the client process */
            close(socketID);
            printf ("Connexion acceptée de : client %i\n",id);
            memset(msg, 0, 255);
            sprintf(msg,"bienvenu! client %i",id);
            send(connexion, msg, strlen(msg), 0);
            do
            {
                memset(msg, 0, 255);
                recv(connexion, msg, 255, 0);
 
                if (strcmp(msg, "aurevoir") == 0)    //si le client ecrit aurevoir il est deconnecté du chat
                {
                    printf ("Connexion fermée pour le client %i\n",id);
                    shutdown(socketID, SHUT_RDWR);
                    exit (0);
                }
 
                printf ("client %d : %s\n",id,msg);
                printf ("Réponse : ");
                fgets(msg, 255, stdin);
                msg[strlen(msg) - 1] = '\0';
                send(connexion, msg, strlen(msg), 0);
 
            }
            while(1);
        }
        else
        {
            close(connexion);
 
        }
 
    }
    return 0;
 
}

Bonjour,

Chaque fois que vous allez utiliser la chaine de caractères "msg", je vous conseille de la remplir de zéro (avec memset), afin de supprimer les messages qui auraient pu être là, le tour de boucle précédent.

Code:

msg[strlen(msg) - 1] = '\0';

Cela ne rectifie pas le soucis, car strlen() se base sur le '\0' pour trouver la taille :P

Chaine = caractères + terminateur \0

Du côté récepteur, vous attendez une chaine de caractères.
Du côté emetteur, n'oubliez pas d'envoyer le caractère nul qui en marque la fin.

send (fd, buff, strlen(buf) + 1);

Réponse

Merci pour vos corrections ;je l'aplliquerai et je verrais si cela résoudra déjà un des mes problèmes cités dans ma discussion.