Probleme de socket : realisation mini msn via fenetre dos

**HaaRt** · 15/03/2007, 21h54

le probleme est le suivant :
je n'arrive pas a transmettre une phrase du serveur au client, cependant du client au serveur sa passe tres bien.

De plus, je suis obliger de faire parler les deux personnes, chacune leur tour, du fait de l'utilisation de gets().
Si quelqu'un aurai des explications, et des element de solutions, sa serai genial.
Merci bcp, je precise je suis novice en socket.

Voici le code coté 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
#include <stdio.h>
#include <string.h>
#include <winsock2.h>
 
int main()
{
    /*******************************************************************************************************************/
    //Déclaration des variables liées au socket
    /*******************************************************************************************************************/    
    WSADATA initialisation_win32;                       // Variable permettant de récupérer la structure d'information sur l'initialisation
    SOCKET socket1;                                     // Identifiant de la socket
    SOCKET socket_;
    int erreur;                                 // Variable permettant de récupérer la valeur de retour des fonctions utilisées
    struct sockaddr_in my_addr;
    SOCKADDR_IN information_sur_la_destination;         // Déclaration de la structure des informations lié au serveur
    int nombre_de_caractere;                            // Indique le nombre de caractères qui a été reçu ou envoyé
    char buffer[65535];                                 // Tampon contenant les données reçues ou envoyées
 
    // *****************************************************************************************************
    // Initialisation de Winsock || Test d'erreur d'initialisation et stockage du résultat dans une variable
    // *****************************************************************************************************
   erreur=WSAStartup(MAKEWORD(2,2),&initialisation_win32);
   if (erreur!=0)
   {
      printf("\nProbleme lie a l'initialisation de Winsock du a l'erreur : %d %d",erreur,WSAGetLastError());
   }
 
 
    /*******************************************************************************************************************/
    //Déclaration des variables liées au programme principal
    /*******************************************************************************************************************/
 
    char address[14];
    char message[100] = {'0'};
    int erreur_socket, erreur_bind, erreur_connect;
 
    /*******************************************************************************************************************/
    //Programme Principal
    /*******************************************************************************************************************/
    printf("Address Ip : ");
    gets(address);
    
 
    /*******************************************************************************************************************/
    //Création du socket et définition de sa structure associé (parametres : address, port, ..)
    /*******************************************************************************************************************/
    socket1 = socket(PF_INET, SOCK_STREAM, 0);  //Définition du socket
    
 
    // *****************************************************************************************************
    // Initialisation du socket || Test d'erreur d'initialisation et stockage du résultat dans une variable
    // *****************************************************************************************************
    if (socket1==INVALID_SOCKET)
    {
      erreur_bind = 1;
      printf("\nProbleme lie a la creation du socket du a l'erreur : %d",WSAGetLastError());
    }
 
 
    /*******************************************************************************************************************/
    //Gestion de la connection au serveur
    /*******************************************************************************************************************/
    information_sur_la_destination.sin_family=AF_INET;
    information_sur_la_destination.sin_addr.s_addr=inet_addr(address); // Adresse ip saisie par l'utilisateur
    information_sur_la_destination.sin_port=htons(6000);               // Port écouté du serveur (6000)
 
    // *****************************************************************************************************
    // Connection au serveur || Test d'erreur de connection et stockage du résultat dans une variable
    // *****************************************************************************************************
    erreur_connect = connect(socket1,(struct sockaddr*)&information_sur_la_destination,sizeof(information_sur_la_destination));
    if (erreur_connect!=0)
       printf("\nImpossible d'ouvrir la session TCP : %d %d",erreur_connect,WSAGetLastError());
    
while(strcmp(buffer,"quit") != 0)
{
    printf("Message : ");
    gets(message);

    if(strcmp(buffer,"quit") != 0)
    {
        // ********************************************************
        // Envoi des données
        // ********************************************************
        strcpy(buffer,message); // Copie la chaine de caractère dans buffer
        nombre_de_caractere=send(socket1,buffer,strlen(buffer),0);
        if (nombre_de_caractere==SOCKET_ERROR)
              printf("\nProbleme d'envoie des donnees du a l'erreur : %d",WSAGetLastError());
              
        
        // ********************************************************
        // Reception des données
        // ********************************************************
        nombre_de_caractere=recv(socket_,buffer,1515,0);
        if (nombre_de_caractere!=SOCKET_ERROR)
        {
           buffer[nombre_de_caractere]=0; // Permet de fermer le tableau après le contenu des data, car la fonction recv ne le fait pas
           printf("\nNouveau message recu : %s",buffer);
        }
    }
    if(strcmp(buffer,"quit") == 0)
        exit(1);
          
}


if(strcmp(buffer,"quit") == 0)
{
    // ********************************************************
    // Fermeture de la session TCP Correspondant à la commande connect()
    // ********************************************************
    erreur=shutdown(socket1,2); // 2 signifie socket d'émission et d'écoute
    if (erreur!=0)
          printf("\nProbleme de fermeture de la session TCP du a l'erreur : %d %d",erreur,WSAGetLastError());

 
    // ********************************************************
    // Fermeture de la socket correspondant à la commande socket()
    // ********************************************************
    erreur=closesocket(socket1);
    if (erreur!=0)
          printf("\nImpossible de liberer la socket du a l'erreur : %d %d",erreur,WSAGetLastError());


    // ********************************************************
    // Quitte proprement le winsock ouvert avec la commande WSAStartup
    // ********************************************************
    erreur=WSACleanup();
    if (erreur!=0)
          printf("\nImpossible de liberer winsock du a l'erreur : %d %d",erreur,WSAGetLastError());
}
 
 
    printf("\n");
    system("PAUSE");
}

Voici le code coté 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
#include <winsock2.h>
#include <stdlib.h>
#include <string.h>

 
int main ()
{
        // ********************************************************
        // Déclaration des variables
        // ********************************************************
        WSADATA initialisation_win32; // Variable permettant de récupérer la structure d'information sur l'initialisation
        int erreur; // Variable permettant de récupérer la valeur de retour des fonctions utilisées
        SOCKET socket_; // Identifiant de la socket
        SOCKET id_de_la_nouvelle_socket;
        SOCKADDR_IN information_sur_la_source; // Déclaration de la structure des informations lié à l'écoute
        SOCKADDR_IN information_sur_la_destination; // Déclaration de la structure des informations lié au serveur
        int nombre_de_caractere; // Indique le nombre de caractères qui a été reçu ou envoyé
        int nombre_de_caractere_;                            // Indique le nombre de caractères qui a été reçu ou envoyé
        char buffer[65535]; // Tampon contenant les données reçues ou envoyées

       
        // ********************************************************
        // Initialisation de Winsock
        // ********************************************************
        erreur=WSAStartup(MAKEWORD(2,2),&initialisation_win32);
        if (erreur!=0)
              printf("\nDesole, je ne peux pas initialiser Winsock du a l'erreur : %d %d",erreur,WSAGetLastError());
              
              
        // ********************************************************
        // Ouverture d'une Socket
        // ********************************************************
        socket_=socket(AF_INET,SOCK_STREAM,0);
        if (socket_==INVALID_SOCKET)
              printf("\nDesole, je ne peux pas creer la socket du a l'erreur : %d",WSAGetLastError());

    
        // ********************************************************
        // Lie la socket à une ip et un port d'écoute
        // ********************************************************
        information_sur_la_source.sin_family=AF_INET;
        information_sur_la_source.sin_addr.s_addr=INADDR_ANY; // Ecoute sur toutes les IP locales  
        information_sur_la_source.sin_port=htons(6000);       // Ecoute sur le port 6000
        erreur=bind(socket_,(struct sockaddr*)&information_sur_la_source,sizeof(information_sur_la_source));
        if (erreur!=0)
              printf("\nDesole, je ne peux pas ecouter ce port : %d %d",erreur,WSAGetLastError());


        // ********************************************************
        // Attente d'ouverture de session
        // ********************************************************
        listen(socket_,1);


        // ********************************************************
        // Acceptation de la demande d'ouverture de session
        // ********************************************************
        printf("\nEn attente de connection, veuillez patientez\n");
        int tempo;
        tempo=sizeof(information_sur_la_source); // Passe par une variable afin d'utiliser un pointeur
        id_de_la_nouvelle_socket=accept(socket_,(struct sockaddr*)&information_sur_la_source,&tempo);
        if(id_de_la_nouvelle_socket==INVALID_SOCKET)
              printf("\nDesole, je ne peux pas accepter la session TCP du a l'erreur : %d",WSAGetLastError());
 
    char message_[100] = {'0'};
    while(strcmp(buffer,"quit") != 0)
    {
                                         
        // ********************************************************
        // Reception des données
        // ********************************************************
        nombre_de_caractere=recv(id_de_la_nouvelle_socket,buffer,1515,0);
        if (nombre_de_caractere!=SOCKET_ERROR)
        {
            buffer[nombre_de_caractere]=0; // Permet de fermer le tableau après le contenu des data, car la fonction recv ne le fait pas
            
            if(strcmp(buffer,"quit") != 0)
            {
                printf("\nNouveau message recu : %s",buffer);               
                printf("\nMessage : ");
                gets(message_);
            }
            
            if(strcmp(buffer,"quit") == 0)
            {
                shutdown(socket_,2); // 2 signifie socket d'émission et d'écoute
                closesocket(socket_);
                WSACleanup(); // A appeler autant de fois qu'il a été ouvert.
                
                printf("\n\nVotre correspondant a quitter la conversation.\n");
                system("pause");
                exit(1);
            }
        }
            
            
        // ********************************************************
        // Envoi des données
        // ********************************************************
        strcpy(buffer,message_); // Copie la chaine de caractère dans buffer
        nombre_de_caractere=send(socket_,buffer,strlen(buffer),0);

    }
}

Si vous pouviez m'apportez une solution,
je vous en serez reconnaissant.
Merci d'avance.

**granquet** · 15/03/2007, 23h20

pour le probleme de "l'ordre de discussion" on ne peux pas faire ça de maniere simple et portable (helas, select ne marche pas sur STDIN_FILENO sous windows :-/)
cependant tu peux creer un thread avec la librairie pthread (google t'expliqueras tout) pour ecouter l'entrée clavier pendant que tu reçois tes messages

sinon, sache que l'utilisation de gets est interdite (depuis plus de 10 ans ptetre)
il faut utiliser fgets(...,stdin) en lieu et place.

concernant ton probléme server -> client
je n'ai pas eu le courage de lire ton code, desolé .

**HaaRt** · 16/03/2007, 00h01

Je comprends pas la, mes extraits de code sont-ils trop long?

**lun4t1k** · 24/03/2007, 18h09

je lis que tu as plusieurs clients. ton serveur est il concurrent? pour les traiter en meme temps c'est le mieux

Probleme de socket : realisation mini msn via fenetre dos

Développement

Discussions similaires

Partager

Partager