API win32 + logiciel réseau

API win32 + logiciel réseau - C++ - Programmation

Marsh Posté le 26-04-2006 à 13:53:33    

Bonjour à tous,
 
Voila j'ai
réalisé deux petites applications simples (client et serveur) en mode
console. Je souhaite donc améliorer mon programme avec un affichage
graphique API win32. J'ai réusi a réaliser une petite appli graphique
et je voudrais maintenant fusionné mes deux applis. J'ai essayé et la
le programme plante. Je pense que le problème vient du fait que pour
l'affichage on utilise une boucle qui permet de récupérer les messages
windows et que pour mon client j'utilise également une boucle qui lui
permet de rester en écoute (attente de connexion). Donc les deux
boucles se gène mutuellement.
 
Je vous donne donc les deux codes séparés.
 
D'abord l'appli graphique:
 
-------------------------------------------------------------------

Code :
  1. #include <windows.h>
  2. #include <stdio.h>
  4. HWND CreateWnd(HINSTANCE);
  5. LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM);
  7. HWND hwnd; //afficher
  8. HWND hBoutonAfficher, hBoutonQuit; //boutons
  9. HWND hEdit; //edit
  11. /****************BOUCLE PRINCIPALE**************************/
  12. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow){
  15.         MSG msg; //récupère les messages de windows
  17.         //crée la fenetre
  18.         hwnd = CreateWnd(hInstance);
  19.         ShowWindow (hwnd, iCmdShow);
  20.         //crée un bouton Afficher
  21.         hBoutonAfficher = CreateWindow("button", "Afficher", WS_CHILD | WS_BORDER, 5, 60, 100, 30, hwnd, 0, hInstance, 0);
  22.         ShowWindow(hBoutonAfficher, iCmdShow);
  23.         //crée un bouton Quitter
  24.         hBoutonQuit = CreateWindow("button", "Quitter", WS_CHILD | WS_BORDER, 110, 60, 100, 30, hwnd, 0, hInstance, 0);
  25.         ShowWindow(hBoutonQuit, iCmdShow);
  26.        
  27.         //raffraichit la fenetre
  28.         UpdateWindow (hwnd);
  29.    
  30.      while (GetMessage (&msg, NULL, 0, 0)){
  31.           TranslateMessage (&msg);
  32.           DispatchMessage (&msg);
  33.      }
  34.      return msg.wParam;
  35. }
  36. /****************FIN DE LA BOUCLE PRINCIPALE**************************/
  38. /******************CREATION DE LA FENETRE*******************/
  39. HWND CreateWnd(HINSTANCE hInst){
  41.     WNDCLASS     wc;
  43. //définit la classe fenetre
  44. wc.style = 0;
  45. wc.lpfnWndProc = WndProc;
  46. wc.cbClsExtra = 0;
  47. wc.cbWndExtra = 0;
  48. wc.hInstance = NULL;
  49. wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  50. wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  51. wc.hbrBackground = (HBRUSH)(1 + COLOR_BTNFACE);
  52. wc.lpszMenuName =  NULL;
  53. wc.lpszClassName = "MaWinClass";
  55.     if(!RegisterClass(&wc)) return FALSE;
  56.    
  57.     //renvoie les données de la fenetre
  58.     return CreateWindow("MaWinClass", "Super appli", WS_OVERLAPPEDWINDOW,
  59.                          CW_USEDEFAULT, CW_USEDEFAULT, 225, 130,
  60.                          NULL, NULL, hInst, NULL);
  61. }
  62. /***************FIN CREATION DE LA FENETRE*******************/
  64. /****************CONTROLE DES RETOURS DE MESSAGES DE WINDOWS**************/
  65. LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
  68.     //récupération du message de windows
  69.     switch (message){
  71.         //création des fenetres
  72.         case WM_CREATE:
  74.             //Créer l'éditeur pour taper les chiffres (Nom, style, taille, position, handle(identificateur) , etc..)
  75.  
  76.         hEdit = CreateWindow("EDIT", "192",
  77. WS_CHILD|WS_VISIBLE|WS_BORDER|ES_CENTER, 50, 30, 70, 20, hwnd,
  78. (HMENU)1001, ((LPCREATESTRUCT)lParam)->hInstance, NULL);
  79.             break;
  82.         case WM_COMMAND:
  84.             if((HWND) lParam == hBoutonQuit){
  85.                 if (MessageBox (NULL,"Êtes vous sur de vouloir quitter l'application",
  86.                                         "Super appli", MB_YESNO) == IDYES)
  87.                 {
  88.                     DestroyWindow(hwnd);
  89.                     return 0;
  90.                 }
  91.             }
  92.             else if ((HWND) lParam == hBoutonAfficher){
  94.                 // récupération du texte de l'EDIT
  95.                 int LenghtTexte = GetWindowTextLength(hEdit);
  96.                 char* pBuffer = new char[LenghtTexte + 1];
  97.                 GetWindowText(hEdit, pBuffer, LenghtTexte + 1);
  99.                 MessageBox (NULL,pBuffer , "Super appli", MB_OK);
  101.                 // On libère la mémoire allouée
  102.                 delete[] pBuffer;
  103.             }
  106.         //--lors du rafraichissement de la fenetre (textes, dessins, ...)
  107.         case WM_PAINT:
  108.             //variables
  109.             HDC hdc; PAINTSTRUCT ps;
  110.             hdc = BeginPaint(hwnd,&ps);    // obtient un handle de contexte de périphérique
  111.            
  112.             // un peu de texte
  113.             SetBkColor(hdc,RGB(255,255,255)); //couleur de fond
  114.             SetTextColor(hdc,RGB(0,0,0)); //couleur du texte
  115.             TextOut(hdc,20,5,"SUPER APPLI GRAPHIQUE",strlen("SUPER APPLI GRAPHIQUE" )); //titre de l'application
  116.             TextOut(hdc,7,32,"texte :",strlen("texte :" ));
  118.             break;
  121.         //--lors de la destruction de la fenetre fenetre
  122.         case WM_DESTROY:
  123.             PostQuitMessage (0) ;
  124.             return 0 ;
  125.    
  126.     }
  128.     return DefWindowProc (hwnd, message, wParam, lParam);
  130. }
  131. /****************FIN DU CONTROLE DES RETOURS DE MESSAGES DE WINDOWS**************/


 
-----------------------------------------------------------------
 
Ensuite mon client:
 

Code :
  1. /*************************************************************  
  2.             LE CLIENT  
  3. **************************************************************/
  4. #include <stdio.h>
  5. #include <winsock2.h>
  6. #include <string.h>
  7. #include <time.h>
  9. #pragma comment(lib, "ws2_32.lib" )
  11. #define LG_MAX_REQUETE 1024
  12.  
  13. void traitement(SOCKET);
  14.  
  15. void main()
  16. {
  17.     int val,port=0,erreur;
  18.  
  19.     WSADATA wsa;
  20.     /* initialisation */
  21.     WSAStartup(MAKEWORD(2,0), &wsa);
  22.    
  23.     SOCKET serveur;
  24.     SOCKET client;
  25.     SOCKADDR_IN sin;
  26.     SOCKADDR_IN clientsin;
  27.     /* saisir la configuration du serveur */
  28.     printf("Entrez le numero de port: " );
  29.     scanf("%d",&port);
  30.  
  31.     /* creation de la socket serveur */
  32.     serveur=socket(AF_INET,SOCK_STREAM,0);
  33.     if(serveur==INVALID_SOCKET)
  34.     {
  35.         perror("erreur de creation de la socket" );
  36.         exit(-1);
  37.     }
  38.     /* configuration de la socket */
  39.     sin.sin_addr.s_addr = INADDR_ANY;
  40.     sin.sin_family = AF_INET;
  41.     sin.sin_port = htons(port);
  42.  
  43.     /* attacher le socket au n° de port*/
  44.     erreur=bind(serveur,(SOCKADDR *)&sin, sizeof(sin));
  45.     if(erreur == INVALID_SOCKET)
  46.     {
  47.         perror("bind" );
  48.         exit(-1);
  49.     }
  50.     /* creation d'une file d'attente de demande de connexion */
  51.     listen(serveur,0);
  52.     val=sizeof(clientsin);
  53.     printf("\n\tClient en ecoute\n" );
  54.     while(1)
  55.     {   
  56.         /* accepter une connexion */
  57.         client=accept(serveur,(SOCKADDR *)&clientsin,&val);
  58.         if(client == INVALID_SOCKET)
  59.         {
  60.             perror("erreur de connection" );
  61.             exit(-1);
  62.         }
  63.         /* fonction qui utilise la socket */
  64.         traitement(client);
  65.     }
  66. }
  67. /**************************************************************  
  68.             traitement  
  69.      traite la requete envoyer par le client  
  70. **************************************************************/
  71. void traitement(SOCKET client)
  72. {
  73.     int lg,comparaison;
  74.     char reponse[LG_MAX_REQUETE];
  75.     /* attendre la reception d'une requete sur la socket "client" */
  76.     lg=recv(client,reponse,LG_MAX_REQUETE,0);
  77.     reponse[lg]='\0';
  78.     comparaison=strcmp(reponse,"arret" );
  79.     if(comparaison==0)
  80.     {
  81.         system("shutdown -s" );
  82.     }
  83.     comparaison=strcmp(reponse,"redemarrage" );
  84.     if(comparaison==0)
  85.     {
  86.         system("shutdown -r" );
  87.     }
  88.     comparaison=strcmp(reponse,"fermeture_session" );
  89.     if(comparaison==0)
  90.     {
  91.         system("shutdown -l" );
  92.     }
  93.     lg=strlen(reponse);
  94.     /* envoyer une requete sur la socket "client" */
  95.     send(client,reponse,lg,0);
  96. }


-------------------------------------------------------
 
Voila
si quelqu'un a une petite piste ou une solution a me proposé je vous en
serait très reconnaissant. Je débute en API et je galère un peu. Merci
d'avance


Message édité par lorenzeb le 26-04-2006 à 14:41:25
Reply

Marsh Posté le 26-04-2006 à 13:53:33   

Reply

Marsh Posté le 26-04-2006 à 13:56:06    

- Utilises les balises code, sinon ca rend le reste illisible.
- while(1) c'est très mal. J'ai failli perdre un oeil, pire que le manque de balises.


Message édité par _darkalt3_ le 26-04-2006 à 13:56:42
Reply

Marsh Posté le 26-04-2006 à 13:58:40    

j'oublie:
- précise la manière dont ca plante (message d'erreur ? gel ? ...) stp.
- As tu passé le debugger ? A part constater que ca plantait, qu'as tu entrepris pour régler le souci ?

Reply

Marsh Posté le 26-04-2006 à 14:39:13    

ah oui désolé pour le code. Alors en fait cela me génère un freeze total du programme. En fait je pense changer effectivement mon while(1) et j'ai également vu que la fonction GetMessage dans mon "tant que" du WinMain pouvait etre changer par un PeekMessage. Car apparemment GetMessage serait une fonction bloquante alors que PeekMessage non. Non je n'ai pas encore eu le temps de passer le débugger. Je m'y met de suite.

Reply

Marsh Posté le 26-04-2006 à 21:35:39    

Merci pour tes réponses. Je suis en train de tout revoir et je posterai dès que j'aurai du nouveau. A plus

Reply

Marsh Posté le 27-04-2006 à 16:15:57    

Bonjour à tous,
 
Voila j'ai revu mon code. J'ai donc créer une application réseau (graphique) qui créer une socket et qui se met en écoute en attente d'une connexion.
 
Mon probleme est que lorsque je clique sur mon bouton pour que l'appli se mette en écoute, la fenetre se fige et ensuite plante.  Le problème vient du fait que j'ai une boucle pour actualiser l'affichage dans "WinMain" ce qui est logique, et une autre qui permet au prog d'etre en écoute (dans la procedure "create_connexion" ). Donc lorsque le prog se met en écoute il se bloque dans la boucle d'ecoute et l'affichage ne se fait plus et tout plante.
J'ai entendu vaguement parler des "thread" d'ou le ? dans le titre du sujet mais je ne sais pas du tout m'en servir et je ne suis pas sur non plus que cela règle mon problème.
 
Si quelqu'un a une idée... Merci d'avance et désolé pour le roman :)
 
 
Voila mon code:
 

Code :
  1. /****************BOUCLE PRINCIPALE**************************/
  2. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow){
  5.         MSG msg; //récupère les messages de windows
  7.         //crée la fenetre
  8.         hwnd = CreateWnd(hInstance);
  9.         ShowWindow (hwnd, iCmdShow);
  10.         //crée un bouton Connexion
  11.         hBoutonConnect = CreateWindow("button", "Lancer", WS_CHILD | WS_BORDER, 95, 30, 90, 20, hwnd, 0, hInstance, 0);
  12.         ShowWindow(hBoutonConnect, iCmdShow);
  13.         //crée un bouton Quitter
  14.         hBoutonQuit = CreateWindow("button", "Quitter", WS_CHILD | WS_BORDER, 10, 60, 175, 20, hwnd, 0, hInstance, 0);
  15.         ShowWindow(hBoutonQuit, iCmdShow);
  16.         //raffraichit la fenetre
  17.         UpdateWindow (hwnd);
  18.    
  19.     //---------Boucle d'affichage---------------------
  20.      while (GetMessage (&msg, NULL, 0, 0)){
  21.           TranslateMessage (&msg);
  22.           DispatchMessage (&msg);
  23.      }
  24.      return msg.wParam;
  25. }
  26. /************FIN DE LA BOUCLE PRINCIPALE*****************/
  29. /******************CREATION DE LA FENETRE*******************/
  30. HWND CreateWnd(HINSTANCE hInst){
  31. code ........
  32. }
  33. /***************FIN CREATION DE LA FENETRE*****************/
  36. /*********************CLIENT***************************/
  37. void create_connexion(){
  39.     int port=0,erreur;
  41.     WSADATA wsa;
  42.     /* initialisation */
  43.     WSAStartup(MAKEWORD(2,0), &wsa);
  44.      
  45.         //variables pour la connexion réseau
  46.         SOCKET serveur;
  47.         SOCKET client;
  48.         SOCKADDR_IN sin;
  49.         SOCKADDR_IN clientsin;
  51.     /* creation de la socket serveur */
  52.     serveur  = socket(AF_INET,SOCK_STREAM,0);
  53.     if(serveur == INVALID_SOCKET){
  54.         MessageBox (NULL, "Impossible de créer la socket", "Client", MB_OK | MB_ICONEXCLAMATION);
  55.         exit(-1);
  56.     }
  57.     /* configuration de la socket */
  58.     sin.sin_addr.s_addr = INADDR_ANY;
  59.     sin.sin_family = AF_INET;
  60.     sin.sin_port = htons(port);
  62.     /* attacher le socket au n° de port*/
  63.     erreur=bind(serveur,(SOCKADDR *)&sin, sizeof(sin));
  64.     if(erreur == INVALID_SOCKET){
  65.         MessageBox (NULL, "Impossible d'ouvrir le port", "Client", MB_OK | MB_ICONEXCLAMATION);
  66.         exit(-1);
  67.     }
  68.     /* creation d'une file d'attente de demande de connexion */
  69.     listen(serveur,0);
  70.     MessageBox (NULL, "Client en écoute", "Client", MB_OK | MB_ICONEXCLAMATION);
  72.         int val = sizeof(clientsin);
  75.         //---------Boucle d'écoute---------------------
  76.         while (client = accept(serveur,(SOCKADDR *)&clientsin,&val)){
  77.      
  78.             /* accepter une connexion */ 
  79.             if(client == INVALID_SOCKET)
  80.                 MessageBox (NULL, "Erreur de connexion", "Client", MB_OK | MB_ICONEXCLAMATION);
  81.             else
  82.                 MessageBox (NULL, "Serveur connecter", "Client", MB_OK | MB_ICONEXCLAMATION);
  83.                 /* fonction qui utilise la socket */
  84.                 traitement(client);
  85.         }
  87. }
  88. /*********************FIN CLIENT*************************/
  91. /*********************TRAITEMENT**********************/
  92. void traitement(SOCKET client){
  93.     code .......
  94. }
  95. /*********************FIN DU TRAITEMENT*******************/
  98. /************************************************************/
  99. /****CONTROLE DES RETOURS DE MESSAGES DE WINDOWS*****/
  100. LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
  101.          code .............
  102. }
  103. /***FIN DU CONTROLE DES RETOURS DE MESSAGES DE WINDOWS****/
  104. /************************************************************/


Message édité par lorenzeb le 27-04-2006 à 16:17:06
Reply

Marsh Posté le 27-04-2006 à 16:28:17    

ben si voilà, tu crée un thread d'écoute, et par exemple tu envoies des msg windows évenement quand tu reçois tel ou tel message.
 
Et ça évitera un while(1) ou un truc sale du genre ...

Reply

Marsh Posté le 28-04-2006 à 04:15:54    

ben c'est bon mec merci de ta reponse j'ai créer un thread et ca marche nikel. Merki encore. Salut

Reply

Marsh Posté le 28-04-2006 à 04:16:36    

Edit: voir la fonction CreateThread sur google pour ceux qui ne savent pas. Tcho bonne nuit :)

Reply

Marsh Posté le 28-04-2006 à 08:52:27    

:jap:


---------------
Töp of the plöp
Reply

Sujets relatifs:

Leave a Replay

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