Sujet Précédent Sujet Suivant

[C.] 2 Problèmes sur le serveur

cs_Adict Messages postés 28 Date d'inscription vendredi 1 janvier 2010 Statut Membre Dernière intervention 10 août 2010 - 2 mai 2010 à 00:43
cs_Adict Messages postés 28 Date d'inscription vendredi 1 janvier 2010 Statut Membre Dernière intervention 10 août 2010 - 13 juin 2010 à 22:57
bonsoir tout le monde.


alors ça va faire vraiment longtemps que je patine sur mon serveur. J'ai cherché et cherché pour le 2ème problème sans trouver de réponses.
Pour le 1er problème je sais qu'il faut utiliser des Thread mais je ne sais pas comment les mettre en place...

Informations:
IDE: DEV C++
OS: Windows XP
Langage: C.
Mode: Console
Projet: Réaliser un programme de tchat. Un serveur qui reçois les messages des clients et les renvoie aussitôt aux autres clients. Pour le moment seul le serveur me pose problème.

Problèmes:

1- problème plutôt connu et facile à résoudre pour certain (pas pour moi en tout cas ) Le serveur ne peut pas accepter plusieurs clients. Donc j'avais mis en place une boucle infinie du début de l'écoute jusqu'à la fermeture de la socket, mais lorsque j'ai implémenté dans le serveur une 2ème boucle infinie ça ne marché plus. En chercher j'ai vu qu'il fallait utiliser des multi-thread. Hors je ne sais pas du tout comment l'implémenter au code. Il faut qu'il y est une dizaine de connections possible en plus Où et quoi dois-je rajouter dans mon code pour la création de Thread ?

2- Vous vous souvenez de la 2ème boucle infinie dans le serveur ? c'est celle-ci qui me pose problème Elle est sensé servir à recevoir les centaine de messages et les renvoyer à tout les clients hors je n'ai jamais réussi à faire fonctionner cette boucle. Comment "faire" pour que cette boucle marche ?



Source du serveur: 

#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
            {
               while (1)
               { // début de la boucle d'écoute qui doit être remplacé par des thread 
                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[1024];
                        char chaine[5000];
                        char pseudo[30];
                        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);
                        
                      
 
 while (1) // c'est cette boucle qui doit recevoir les messages et les renvoyer (elle ne marche pas)
    {
    n = recv(s_client, buffer, sizeof(buffer) - 1, 0);

    if (n <= 0)
        break; //La close
    send(s_client, buffer, (int)strlen(buffer), 0);
                     
    }


           
                        
                
                  
                        if (n != SOCKET_ERROR)
                        {
                            buffer[n] = '\0';
                            printf("%s", buffer);
                        }
                        
                        closesocket(s_client);
                    }
                }
            }
            
            closesocket(s_server);
        }
        
        WSACleanup();
    }
      } //fin de la boucle d'écoute 
    return 0;
}


Je vous remercie d'avoir lut en espérant avoir des réponses à mes problèmes



________________________________________________________________________

j'ai 16 ans et j'aime l'informatique, surtout les programmes

3 réponses

Réponse 1 / 3
cs_Adict Messages postés 28 Date d'inscription vendredi 1 janvier 2010 Statut Membre Dernière intervention 10 août 2010
2 mai 2010 à 19:10
2ème problème pour la réception des messages réglé. Mais le 1er problème toujours d'actualité

________________________________________________________________
j'ai 16 ans et j'aime l'informatique, surtout les programmes
0
Réponse 2 / 3
cs_Adict Messages postés 28 Date d'inscription vendredi 1 janvier 2010 Statut Membre Dernière intervention 10 août 2010
14 mai 2010 à 22:26
un petit up.

J'ai fait de nombreuse recherche 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.
0
Réponse 3 / 3
cs_Adict Messages postés 28 Date d'inscription vendredi 1 janvier 2010 Statut Membre Dernière intervention 10 août 2010
13 juin 2010 à 22:57
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 

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <string.h>
#include <winsock2.h>
#include 
#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); 
   }
}



et aussi, sur le client je demande au début d'entrer un pseudo puis ensuite je part sur une autre fonction (grasse à un thread) mais la le pseudo choisi est perdu je voulais faire un pointeur de cette manière mais ça ne marchait pas 
void* message(void* data);
 
 
int main()
...
char pseudo[20];
int *Ppseudo = &pseudo;
...
 
void* message(void* data)
{
....
else if(memcmp(buff, ("%s", *Ppseudo), 3) ==0)
   {
    printf("test");
    getchar();
   }
...
}


Merci :)
0

Discussions similaires

Erreur du serveur dans l'application '/'
cs_ange_sali -
Dr_shaman -

5 réponses
Récupération nom de serveur
Ant8386 -
Ant8386 -

3 réponses
Turbo C++
cs_jrod -
cmarsc -

1 réponse
Etablir toutes les combinaisons possibles du Lotto
KBNchapal -
Mikaels35 -

6 réponses
tableau nombre de ligne ?
ronando -
edwinzap -

10 réponses
Rejoignez-nous