[Resolu]Serveur Multi Thread en C

Serveur Multi Thread en C [Resolu] - C - Programmation

Marsh Posté le 09-06-2009 à 11:50:06    

bonjour a tous est a toute,
 
Je cherche a développer un serveur Multi Thread en C sur les plateforme windows et unix.
 
Malheureusement je ne m'en sort pas.
 
J'aurai besoin de conseils avisé sur les librairie a utiliser, ainsi que exemple si sa existe.
 
Mon serveur doit se connecter a plusieurs clients simultanément, grâce a leur adresse IP.
 
 
ps: google ne pas beaucoup aidé dans mes recherches.
 
 
Cordialement


Message édité par thanks33 le 11-06-2009 à 11:21:29
Reply

Marsh Posté le 09-06-2009 à 11:50:06   

Reply

Marsh Posté le 09-06-2009 à 12:05:18    

Les mots cles pour ta recherche sont : "network programming c"
 
Un bon tutorial sur le sujet (qui t'introduira aux socket(), connect(), etc) te parlera en meme temps du multi-threads.

Reply

Marsh Posté le 09-06-2009 à 12:06:57    

Au passage se sont les clients qui se connectent aux serveurs. Dans ton cas ce que tu appelles des clients sont en fait des serveurs qui attendent les requetes des clients (ton serveur).

Reply

Marsh Posté le 09-06-2009 à 12:12:51    

merci de ton aide.
 
bonjour, voila se qui me bloque.
 
Je doit réalisé un outil de supervision de serveur Unix.
 
En réalité mon serveur tcp ip sera aussi un client, je m'explique :
 
le programme en C ou C++ devra être capable de recevoir un ordre grâce a un site internet, puis de lancer un ordre a chacun des client.
Puis un fois que la partie cliente a finie d'exécuter les script, il devra envoyer au serveur un fichier txt.
 

Code :
  1. [COLOR="Black"]function [/COLOR]envoi_serveur($envoi)  /* Permet l'envoie de la commande au serveur*/
  2. {
  3.   $port = 10000;  /*définition du port */
  4.   $adresse = "127.0.0.1"; /*définition de l'adresse ip du serveur */
  6.   $socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);/* Cree une socket TCP/IP. */
  7.    if ($socket < 0)  /*Si le socket ne c'est pas créé */
  8.     {
  9.     echo "socket_create() a échoué : raison :  " . socket_strerror ($socket) . "<br />"; /*affiche l'erreur */
  10.     }
  12.    else /* Sinon*/
  13.     {
  15.      $resultat = socket_connect($socket, $adresse, $port); /* connexion au serveur*/
  16.      if ($resultat < 0) /*Si la connexion au serveur a échoué*/
  17.       {
  18.        echo "socket_connect() a échoué : raison : ($resultat) " . socket_strerror($resultat) . "<br />";/*affiche l'erreur */
  19.       }
  20.      else /* Sinon*/
  21.       {
  22.        socket_write($socket, $envoi, strlen($envoi)); /*envoi de la données*/
  24.       }
  26.     }
  29.   socket_close($socket); /*Fermeture du serveur*/
  30. }


 
qui envera un code qui ressemble a celui ci : 10XTOT-pprod
 
 
ma partie serveur ressemble a ceci
 

Code :
  1. #include <cstdlib>
  2. #include <iostream>
  3. #include <fstream>
  4. using namespace std;
  5. #include <winsock2.h>
  8. int main(int argc, char *argv[])
  9. {
  10.     // Initialisation
  11.     WSADATA initialisation_win32;
  12.     int erreur=WSAStartup(MAKEWORD(2,2),&initialisation_win32);
  13.     if (erreur!=0)
  14.     {
  15.         cout << "Desole, je ne peux pas initialiser Winsock du a l'erreur : ";
  16.         cout << erreur << " " << WSAGetLastError() << "\n\n";
  17.         system("PAUSE" );
  18.         return -1;
  19.     }
  20.     else
  21.     {
  22.           cout << "WSAStartup  : OK\n";
  23.     }
  25.     // Création de la socket
  26.     SOCKET id_de_la_socket;
  27.     id_de_la_socket=socket(AF_INET,SOCK_STREAM,0);
  28.     if (id_de_la_socket==INVALID_SOCKET)
  29.     {
  30.         cout << "Desole, je ne peux pas creer la socket du a l'erreur : ";
  31.         cout << WSAGetLastError() << "\n\n";
  32.         system("PAUSE" );
  33.         return -1;
  34.     }
  35.     else
  36.     {
  37.           cout << "socket  : OK\n";
  38.     }
  40.     // Ouverture du port 47836
  41.     SOCKADDR_IN information_sur_la_source;
  42.     information_sur_la_source.sin_family=AF_INET;
  43.     information_sur_la_source.sin_addr.s_addr=INADDR_ANY;
  44.     information_sur_la_source.sin_port=htons(10000); // Le porte 47836 est écouté
  45.     erreur=bind(id_de_la_socket,(struct sockaddr*)&information_sur_la_source,
  46.     sizeof(information_sur_la_source));
  47.     if (erreur!=0)
  48.     {
  49.         cout << "Desole, je ne peux pas ecouter ce port : ";
  50.         cout << erreur << " " << WSAGetLastError() << "\n\n";
  51.         system("PAUSE" );
  52.         return -1;
  53.     }
  54.     else
  55.     {
  56.           cout << "bind  : OK\n";
  57.     }
  59.     //  Attend une demande de connection
  60.     do
  61.           erreur=listen(id_de_la_socket,1);
  62.     while(erreur!=0);
  63.     cout << "listen  : OK\n";
  65.     // On accepte la connexion
  66.     SOCKET id_de_la_nouvelle_socket;
  67.     int tempo=sizeof(information_sur_la_source);
  68.     id_de_la_nouvelle_socket=accept(id_de_la_socket,
  69.     (struct sockaddr*)&information_sur_la_source,&tempo);
  70.     if(id_de_la_nouvelle_socket==INVALID_SOCKET)
  71.     {
  72.         cout << "Desole, je ne peux pas accepter la session TCP du a l'erreur : ";
  73.         cout << WSAGetLastError() << "\n\n";
  74.         system("PAUSE" );
  75.         return -1;
  76.     }
  77.     else
  78.         cout << "accept  : OK\n";
  80.     char buffer[4096]; long buffer2;
  81.     // Reçois la taille du nom du fichier (4 octet ou 32 bits)
  82.     int nombre_de_caractere=recv(id_de_la_nouvelle_socket,(char*)&buffer2,4,0);
  83.     if (nombre_de_caractere==SOCKET_ERROR)
  84.     {
  85.         cout << "Erreur, je n'ai pas recu la taille du nom de fichier !\n\n";
  86.         system("PAUSE" );
  87.         return -1;
  88.     }
  89.     // Reçois le nom du fichier
  90.     char*nomdefichier=new char[buffer2+1];nomdefichier[0]=0;
  91.     for (int i=0;i<buffer2;i+=nombre_de_caractere)
  92.     {
  93.         nombre_de_caractere=recv(id_de_la_nouvelle_socket,buffer,(buffer2-i<4096)?buffer2-i:4096,0);
  94.         if (nombre_de_caractere==SOCKET_ERROR)
  95.         {
  96.             cout << "Erreur, je n'ai pas recu le nom du fichier !\n\n";
  97.             system("PAUSE" );
  98.             return -1;
  99.         }
  100.         else
  101.         {
  102.             for (int y=0;y<nombre_de_caractere;y++)
  103.             {
  104.                 nomdefichier[y+i]=buffer[y];
  105.                 nomdefichier[y+i+1]=0;
  106.             }
  107.         }
  108.     }
  109.     cout << "Nom du fichier a recevoir : " << nomdefichier << "\n";
  111.     ofstream fichiers(nomdefichier,ios::out|ios::binary);
  112.     if (!fichiers)
  113.     {
  114.         cout << "Erreur, impossible de créer le fichier !\n\n";
  115.         shutdown(id_de_la_socket,2);
  116.         closesocket(id_de_la_socket);
  117.         shutdown(id_de_la_nouvelle_socket,2);
  118.         closesocket(id_de_la_nouvelle_socket);
  119.         WSACleanup();
  120.         system("PAUSE" );
  121.         return -1;
  122.     }
  124.     // Reçois la taille du fichier (4 octet ou 32 bits)
  125.     nombre_de_caractere=recv(id_de_la_nouvelle_socket,(char*)&buffer2,4,0);
  126.     if (nombre_de_caractere==SOCKET_ERROR)
  127.     {
  128.         cout << "Erreur, je n'ai pas recu la taille du fichier !\n\n";
  129.         system("PAUSE" );
  130.         return -1;
  131.     }
  133.     cout << "Taille du fichier a recevoir : " << buffer2 << "\n";
  134.     // Reçois le fichier
  135.     for (int i=0;i<buffer2;i+=nombre_de_caractere)
  136.     {
  137.         nombre_de_caractere=recv(id_de_la_nouvelle_socket,buffer,
  138.         (buffer2-i<4096)?buffer2-i:4096// Si le nombre de donnée restant à reçevoir
  139.         // est plus petit que le buffer on indique ce nombre sinon la taille du buffer
  140.         ,0);
  141.         if (nombre_de_caractere==SOCKET_ERROR)
  142.         {
  143.             cout << "Erreur, je n'ai pas recu le fichier !\n\n";
  144.             system("PAUSE" );
  145.             return -1;
  146.         }
  147.         else
  148.         {
  149.             fichiers.write(buffer,nombre_de_caractere);
  150.         }
  151.     }
  153.     delete[]nomdefichier;
  154.     fichiers.close();
  155.     shutdown(id_de_la_socket,2);
  156.     closesocket(id_de_la_socket);
  157.     shutdown(id_de_la_nouvelle_socket,2);
  158.     closesocket(id_de_la_nouvelle_socket);
  159.     cout << "\nLe fichier a bien ete recu !\n\n";
  160.     system("PAUSE" );
  161.     return 0;
  162. }


 
mais malheureusement rien ne se passe.
pourtant, un client PHP reçoit bien le message alors que le client C++ ne reçoit rien.
 
Cordialement

Message cité 1 fois
Message édité par thanks33 le 09-06-2009 à 21:38:00
Reply

Marsh Posté le 11-06-2009 à 12:36:28    

thanks33 a écrit :


ma partie serveur ressemble a ceci
 

Code :
  1. //  Attend une demande de connection
  2.     do
  3.           erreur=listen(id_de_la_socket,1);
  4.     while(erreur!=0);
  5.     cout << "listen  : OK\n";




On ne fait pas de boucle sur listen(). On fait une boucle sur accept() (qui est bloquante).
 
A lire de A à Z :  
 
http://www.bien-programmer.fr/reseaux.htm
 
BUG : pour accept(), il faut fournir un sin (csin : client sin)  différent de celui du serveur (ssin : server sin).
 
Ceci devrait mieux fonctionner :

Code :
  1. #include <stdlib.h>
  2. #include <stdio.h>
  4. #include <winsock2.h>
  6. int main (void)
  7. {
  8.    int ret = EXIT_SUCCESS;
  10. /* Initialisation */
  12.    WSADATA initialisation_win32;
  13.    int erreur = WSAStartup (MAKEWORD (2, 2), &initialisation_win32);
  15.    if (erreur != 0)
  16.    {
  17.       printf
  18.          ("Desole, je ne peux pas initialiser Winsock du a l'erreur : %d %d\n",
  19.           erreur, WSAGetLastError ());
  20.       ret = EXIT_FAILURE;
  21.    }
  22.    else
  23.    {
  25. /* Création de la socket */
  27.       SOCKET ssock = socket (AF_INET, SOCK_STREAM, 0);
  29.       printf ("WSAStartup  : OK\n" );
  31.       if (ssock == INVALID_SOCKET)
  32.       {
  33.          printf
  34.             ("Desole, je ne peux pas creer la socket du a l'erreur : %d %d\n",
  35.              erreur, WSAGetLastError ());
  36.          ret = EXIT_FAILURE;
  37.       }
  38.       else
  39.       {
  40.          SOCKADDR_IN ssin;
  42.          printf ("socket  : OK\n" );
  44.          /* Ouverture du port */
  45.          ssin.sin_family = AF_INET;
  46.          ssin.sin_addr.s_addr = INADDR_ANY;
  47.          ssin.sin_port = htons (10000);
  48.          erreur = bind (ssock, (struct sockaddr *) &ssin, sizeof (ssin));
  49.          if (erreur != 0)
  50.          {
  51.             printf
  52.                ("Desole, je ne peux pas me lier a ce port : %d %d\n",
  53.                 erreur, WSAGetLastError ());
  54.             ret = EXIT_FAILURE;
  55.          }
  56.          else
  57.          {
  58.             printf ("bind  : OK\n" );
  60.             /* Le port est mis en ecoute */
  61.             erreur = listen (ssock, 1);
  63.             if (erreur == SOCKET_ERROR)
  64.             {
  65.                printf
  66.                   ("Desole, je ne peux pas ecouter ce port : %d %d\n",
  67.                    erreur, WSAGetLastError ());
  68.                ret = EXIT_FAILURE;
  69.             }
  70.             else
  71.             {
  72.                printf ("listen  : OK\n" );
  74.                /* En attente de connexion d'un client */
  75.                {
  76.                   SOCKADDR_IN csin;
  77.                   int tempo = sizeof (csin);
  78.                   SOCKET csock =
  79.                      accept (ssock, (struct sockaddr *) &csin, &tempo);
  80.                   if (csock == INVALID_SOCKET)
  81.                   {
  82.                      printf
  83.                         ("Desole, je ne peux pas accepter la session TCP du a l'erreur : %d %d\n",
  84.                          erreur, WSAGetLastError ());
  85.                      ret = EXIT_FAILURE;
  86.                   }
  87.                   else
  88.                   {
  89.                      char buffer[4096];
  90.                      long buffer2;
  92.                      /* Reçoit la longueur du nom du fichier (4 octet ou 32 bits) */
  93.                      int nombre_de_caractere;
  95.                      printf ("accept  : OK\n" );
  97.                      /* -ed- pas portable ! */
  98.                      nombre_de_caractere =
  99.                         recv (csock, (char *) &buffer2, 4, 0);
  101.                      if (nombre_de_caractere <= 0)
  102.                      {
  103.                         printf
  104.                            ("Erreur, je n'ai pas recu la longueur du nom de fichier ! \n\n" );
  105.                         ret = EXIT_FAILURE;
  106.                      }
  107.                      else
  108.                      {
  109.                         char *nomdefichier;
  110.                         printf ("la longueur du nom de fichier est %ld\n",
  111.                                 buffer2);
  113.                         /* Reçois le nom du fichier */
  114.                         nomdefichier = malloc (buffer2 + 1);
  116.                         if (nomdefichier != NULL)
  117.                         {
  118.                            /* -ed- Horriblement compliqué. Quel est le format des données ?
  120.                               Je recommande :
  121.                               (Codage des valeurs numériques :  MSB en tete)
  123.                               [Origine:longueur]
  125.                               [0:2]    LN : Longueur du nom de fichier (16-bit)
  126.                               [2:LN]   Nom de fichier (chaine de caracteres)
  127.                               [2+LN:4] LD : longueur des données (32-bit)
  128.                               [6+LN:LD]Donnees
  130.                             */
  131.                            nomdefichier[0] = 0;
  132.                            {
  133.                               int i;
  134.                               for (i = 0; i < buffer2;
  135.                                    i += nombre_de_caractere)
  136.                               {
  137.                                  nombre_de_caractere =
  138.                                     recv (csock, buffer,
  139.                                           (buffer2 - i <
  140.                                            4096) ? buffer2 - i : 4096, 0);
  141.                                  if (nombre_de_caractere == SOCKET_ERROR)
  142.                                  {
  143.                                     printf
  144.                                        ("Erreur, je n'ai pas recu le nom du fichier !\n\n" );
  145.                                     return EXIT_FAILURE;
  146.                                  }
  147.                                  else
  148.                                  {
  149.                                     int y;
  150.                                     for (y = 0; y < nombre_de_caractere; y++)
  151.                                     {
  152.                                        nomdefichier[y + i] = buffer[y];
  153.                                        nomdefichier[y + i + 1] = 0;
  154.                                     }
  155.                                  }
  156.                               }
  157.                            }
  158.                            printf ("Nom du fichier a recevoir : %s\n",
  159.                                    nomdefichier);
  160.                            {
  161.                               FILE *fichiers = fopen (nomdefichier, "rb" );
  162.                               if (fichiers == NULL)
  163.                               {
  164.                                  printf
  165.                                     ("Erreur, impossible de créer le fichier !\n\n" );
  166.                                  ret = EXIT_FAILURE;
  167.                               }
  168.                               else
  169.                               {
  170.                                  /* Reçois la taille du fichier (4 octet ou 32 bits) */
  171.                                  nombre_de_caractere =
  172.                                     recv (csock, (char *) &buffer2, 4, 0);
  173.                                  if (nombre_de_caractere <= 0)
  174.                                  {
  175.                                     printf
  176.                                        ("Erreur, je n'ai pas recu la taille du fichier !\n\n" );
  177.                                     return EXIT_FAILURE;
  178.                                  }
  180.                                  printf
  181.                                     ("Taille du fichier a recevoir : %ld\n",
  182.                                      buffer2);
  183.                                  /* Reçois le fichier */
  184.                                  {
  185.                                     int i;
  186.                                     for (i = 0; i < buffer2;
  187.                                          i += nombre_de_caractere)
  188.                                     {
  189.                                        /* Si le nombre de donnée restant à reçevoir */
  190.                                        nombre_de_caractere =
  191.                                           recv (csock, buffer,
  192.                                                 (buffer2 - i <
  193.                                                  4096) ? buffer2 - i : 4096
  194.                                                 /* est plus petit que le buffer on
  195.                                                    indique ce nombre sinon la taille
  196.                                                    du buffer */
  197.                                                 , 0);
  198.                                        if (nombre_de_caractere ==
  199.                                            SOCKET_ERROR)
  200.                                        {
  201.                                           printf
  202.                                              ("Erreur, je n'ai pas recu le fichier !\n\n" );
  203.                                           return EXIT_FAILURE;
  204.                                        }
  205.                                        else
  206.                                        {
  207.                                           fwrite (buffer, 1,
  208.                                                   nombre_de_caractere,
  209.                                                   fichiers);
  210.                                        }
  211.                                     }
  212.                                  }
  213.                                  fclose (fichiers);
  214.                               }
  215.                            }
  216.                            printf ("\nLe fichier a bien ete recu !\n\n" );
  217.                         }
  218.                         free (nomdefichier);
  219.                      }
  220.                      shutdown (csock, 2);
  221.                      closesocket (csock);
  222.                   }
  223.                }
  224.             }
  225.          }
  226.          shutdown (ssock, 2);
  227.          closesocket (ssock);
  228.       }
  229.       WSACleanup ();
  230.    }
  231.    return ret;
  232. }


Il faut quand même revoir le mécanisme de réception des données...


Message édité par Emmanuel Delahaye le 11-06-2009 à 13:47:27

---------------
Des infos sur la programmation et le langage C: http://www.bien-programmer.fr Pas de Wi-Fi à la maison : http://www.cpl-france.org/
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed