Discussion :

[jbarreau-mainson]

Bonjour à tous,

J'ai un petit soucis lors du cast d'une structure, je ne vois pas comment faire

En fait je tente de faire un serveur multi-clients, le client.c s'occupe de "declarer" un nouveau client au serveur...
Ces codes ne concernent que le serveur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
/*main.c*/
       for(;;)
        {
            argc = Serveur(SERVEUR_LISTEN, 0);
            Serveur(SERVEUR_ACCEPT, &argc);
        }
//argc recupere (int)Clients[Id];
//voir client.c

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
 
 
 
/*serveur.c*/
 
int Serveur(int sc, int pa)
{
    switch(sc)
    {
    case SERVEUR_ACCEPT:
        //La fonction accepte la connection d'un socket clients sur le socket serveur
        if((((t_Clients)&pa).ClientSock = accept(serveur.ServeurSock, (SOCKADDR *)&((t_Clients)pa).ClientsSin, &((t_Clients)pa).SinSize)) == INVALID_SOCKET)
        {
            Fin("Echec de la connection du clients.\n");
        }
        else
        {
            printf("\nNouvelle connexion : %s se connecte.\n", inet_ntoa(((t_Clients)pa).ClientsSin.sin_addr));
            strcpy(*Buff, "-- Bienvenue sur le serveur");
            send(((t_Clients)pa).ClientsSock, *Buff, (int)strlen(*Buff), 0);
        }
        break;
}
}

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
 
t_Clients *Clients;
 
/*client.c*/
int Client(int sc, int pa)
{
    switch(sc)
    {
    case CLIENT_NEW:
        puts("Creation d'un nouveau client.");
        Id++;
        Clients[Id].SinSize = sizeof(Clients[Id].ClientSin);
        return (int)Clients[Id];
        break;
}
}

Mon problème se pose au niveau du serveur.c, notamment ici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 if((((t_Clients)&pa).ClientSock

[Médinoc]

J'ai l'impression que le type de pa n'est pas ce qu'il devrait être...

[jbarreau-mainson]

En fait je cast Clients[Id] en int pour ensuite le recaster en (t_clients).
Je ne vois pas en quoi d'autre il devrait etre !

[crocodilex]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Serveur(SERVEUR_ACCEPT, &argc);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int Serveur(int sc, int pa)
{

Ce n'est pas très cohérent tout ça....

[Médinoc]

En fait je cast Clients[Id] en int pour ensuite le recaster en (t_clients).
Je ne vois pas en quoi d'autre il devrait etre !

Pourquoi pas en t_clients ou t_Clients*?

Ou bien, à défaut, en intptr_t minimum. On vit à l'ère du 64 bits maintenant, et rien ne garantit qu'un int soit assez grand pour contenir un pointeur.

[jbarreau-mainson]

Pourquoi pas en t_clients ou t_Clients*?

c'est déjà en t_clients.
Si je met en t_clients * j'ai l'erreur suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

error: request for member `ClientSock' in something not a structure or union|

On vit à l'ère du 64 bits maintenant, et rien ne garantit qu'un int soit assez grand pour contenir un pointeur.

La plateforme est 32bits.

Ce n'est pas très cohérent tout ça....

J'ai enlevé le "&".

[Médinoc]

Et si tu faisais tout simplement ceci?

Code C :

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
int Serveur(int sc, clients_t *pa)
{
	switch(sc)
	{
	case SERVEUR_ACCEPT:
		/*La fonction accepte la connection d'un socket clients sur le socket serveur*/
		pa->ClientSock = accept(serveur.ServeurSock, (SOCKADDR *)&(pa->ClientsSin), &(pa->SinSize));
		if(pa->ClientSock == INVALID_SOCKET)
		{
			Fin("Echec de la connection du clients.\n");
		}
		else
		{
			printf("\nNouvelle connexion : %s se connecte.\n", inet_ntoa(pa->ClientsSin.sin_addr));
			strcpy(*Buff, "-- Bienvenue sur le serveur");
			send(pa->ClientsSock, *Buff, (int)strlen(*Buff), 0);
		}
		break;
	}
}

PS: Buff est un pointeur de pointeur?

[jbarreau-mainson]

En réponse j'ai :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 invalid type argument of `->'|

Sinon pour Buff, c'est un tampon général pour le serveur..
C'est par là que je communiquerai avec mes clients.

EDIT : en relisant mon code je ne sais d'ailleurs pas pourquoi j'ai mis un "*"Buff ...

[Médinoc]

Peux-tu poster la totalité de ton code?
Avec toutes les déclarations de structures et de variables, etc. ?

J'en ai marre de devoir deviner...

[jbarreau-mainson]

Main.c
-------

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
 
#include "appli.h"
 
int main(int argc, char *argv[])
{
        system("cls");
 
        Serveur(SERVEUR_NEW, 0);
 
        for(;;)
        {
            argc = Serveur(SERVEUR_LISTEN, 0);
            Serveur(SERVEUR_ACCEPT, argc);
        }
 
        for(;;)
        {
         //Collect(pClients, COLLECT_ENUM, SERVEUR_RECV);
        }
 
    return 0;
}

Appli.h
------

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h> //Pour les sockets
#include <fcntl.h>    //Pour open
 
#include "serveur.h"
#include "client.h"
#include "logs.h"
 
/****Constantes Microsoft****/
// INVALID_SOCKET -1
// SOCKET_ERROR -1
/****************************/

serveur.c
--------

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
#include "appli.h"
 
#define SERVEUR_STARTUP 100
#define SERVEUR_CLOSE 101
 
t_Serveur serveur;
char Buff[BUFF_SIZE];
WSADATA wsaData;
 
int Serveur(int sc, int pa)
{
    switch(sc)
    {
/******************************************************************************************************************************/
 
    case SERVEUR_NEW:
        Serveur(SERVEUR_STARTUP, 0);
        //Création de la socket serveur : Protocole IPv4, Flux de données binaires, Protocole TCP ( mode "connecté")
        if((serveur.ServeurSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
        {
            Fin("Echec lors de la création de la socket serveur.\n");
        }
 
        //Remplissage de la structure concernant les informations de la socket
        serveur.ServeurSin.sin_family       = PF_INET;              //Protocole IPv4
        serveur.ServeurSin.sin_addr.s_addr  = htonl(INADDR_ANY);    //Ecoute sur toutes les adresses IP
        serveur.ServeurSin.sin_port         = htons(PORTSQL);       //Port du serveur
 
        //Liaison de la socket serveur avec la structure sockaddr
        //La structure contenant les informations est sockaddr_in, nous faisons donc un cast
        if(bind(serveur.ServeurSock, (SOCKADDR *)&serveur.ServeurSin, sizeof(serveur.ServeurSin)) == SOCKET_ERROR)
        {
            Fin("Echec du bind.\n");
        }
        break;
 
/******************************************************************************************************************************/
 
    case SERVEUR_LISTEN:
        pa = listen(serveur.ServeurSock, 0);
        if(pa == SOCKET_ERROR)
        {
            Fin("Echec de l'écoute sur la socket.\n");
        }
        else{
            pa = Client(CLIENT_NEW, 0);  //Création d'un objet clients.
            return pa;
        }
        break;
 
/******************************************************************************************************************************/
 
    case SERVEUR_ACCEPT:
        //La fonction accepte la connection d'un socket clients sur le socket serveur
        pa->ClientSock = accept(serveur.ServeurSock, (SOCKADDR *)&(pa->ClientsSin), &(pa->SinSize));
        if(pa->ClientSock == INVALID_SOCKET)
        {
            Fin("Echec de la connection du clients.\n");
        }
        else
        {
            printf("\nNouvelle connexion : %s se connecte.\n", inet_ntoa(pa->ClientsSin.sin_addr));
            strcpy(Buff, "-- Bienvenue sur le serveur SQL");
            send(pa->ClientsSock, Buff, (int)strlen(Buff), 0);
        }
        break;
 
/******************************************************************************************************************************/
 
 /*   case SERVEUR_RECV:
        //Reception d'un message depuis une socket clients.
        if((pa = (recv(clients[Id].ClientsSock, *Buff, sizeof(*Buff) - 1, 0))) == SOCKET_ERROR)
        {
            Fin("Echec de la reception du message clients.\n");
        }
        else
        {
            printf("%s dit : %s\n", inet_ntoa(clients[Id].ClientsSin.sin_addr), Buff);
        }
        break;
 
/******************************************************************************************************************************/
 
 /*   case SERVEUR_SEND:
        //Envoie d'un message à destination d'une socket
        strcpy(Buff, "Message.\n");
        if(send(clients[Id].ClientsSock, Buff, (int)strlen(Buff), 0) < 0)
        {
            Fin("Echec de l'envoi du message au clients.\n");
        }
        break;
 
/******************************************************************************************************************************/
 
    case SERVEUR_DEL:
        closesocket(serveur.ServeurSock);   //Fermeture de la socket serveur.
        Serveur(SERVEUR_CLOSE, 0);
        break;
 
/******************************************************************************************************************************/
 
    case SERVEUR_STARTUP:
        if(WSAStartup(MAKEWORD(2, 0), &wsaData) != 0)
        {
            Fin("Initialisation DLL Wsa : Echec.\n");
        }
        if(AsyncSelect(FD_READ|FD_WRITE|FD_ACCEPT|FD_CONNECT|FD_CLOSE) == FALSE)
        {
            Fin("AsyncSelect : FALSE.");
        }
        break;
 
/******************************************************************************************************************************/
 
    case SERVEUR_CLOSE:
        WSACleanup();
        break;
 
/******************************************************************************************************************************/
 
    default:
        Fin("SERVEUR_*** : bad sc");
        break;
 
/******************************************************************************************************************************/
    }
    return 0;
}

Serveur.h
---------

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
#define SERVEUR_NEW 200
#define SERVEUR_DEL 201
 
#define SERVEUR_LISTEN 0
#define SERVEUR_ACCEPT 1
#define SERVEUR_RECV 2
#define SERVEUR_SEND 3
 
#define BUFF_SIZE 1024
#define PORTSQL 10000
 
typedef struct tt_Serveur {
    SOCKET ServeurSock;
    SOCKADDR_IN ServeurSin;
}t_Serveur;
 
int Serveur(int sc, int pa);

Client.c
------

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
#include "appli.h"
 
t_Clients *Clients;
int Id = 0;
 
int Client(int sc, int pa)
{
    switch(sc)
    {
/******************************************************************************************************************************/
 
    case CLIENT_NEW:
        puts("Creation d'un nouveau client.");
        Id++;
        Clients[Id].SinSize = sizeof(Clients[Id].ClientSin);
        return (int)Clients[Id];
        break;
 
/******************************************************************************************************************************/
 
    case CLIENT_DEL:
        closesocket(Clients[Id].ClientSock);   //Fermeture de la socket client.
        break;
 
/******************************************************************************************************************************/
 
    default:
        Fin("CLIENT_*** : bad sc");
        break;
/******************************************************************************************************************************/
    }
}

Client.h
--------

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
#define CLIENT_NEW 206
#define CLIENT_RECV 207
#define CLIENT_DEL 208
 
typedef struct tt_Clients {
    int Nbc;             //Nombre de caractères contenus dans le buffer client
    int SinSize;
    char *pBuff;         //Pointeur sur tableau de char ( buffer client )
    SOCKET ClientSock;         //Socket Client
    SOCKADDR_IN ClientSin;     //Structure Socket
}t_Clients;
 
int Client(int sc, int pa);

[Médinoc]

Merde, je n'avais pas réalisé l'étendue des dégâts.

En supposant que tu veuilles garder ta structure de "fonction unique", un intptr_t pourra résoudre une partie des dégâts, mais pas tous.

Pour faire simple, on ne peut pas convertir une structure en int ou intptr_t. Surtout si la structure en question possède une taille supérieure à celle d'un int. Mais tu peux retourner un pointeur vers une telle structure.

Et aussi, cesse de réutiliser ainsi des variables. S'il faut vraiment recycler la mémoire, un bon compilo en est capable.

[jbarreau-mainson]

Merde, je n'avais pas réalisé l'étendue des dégâts.

merci !

Pour faire simple, on ne peut pas convertir une structure en int ou intptr_t. Surtout si la structure en question possède une taille supérieure à celle d'un int. Mais tu peux retourner un pointeur vers une telle structure.

ok, comment puis-je retourner un pointeur vers une structure ? je suis un peu dans le flou là.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Et aussi, cesse de réutiliser ainsi des variables. S'il faut vraiment recycler la mémoire, un bon compilo en est capable.

C'etait dans le but d'optimiser ..

[Médinoc]

Premature Optimization is the Root Of All Evil.

Laisse le compilo optimiser les détails, il fait ça mieux que toi. Pratiquement la seule chose à optimiser soi-même, c'est les algorithmes (voir Théorie de la Complexité).

Quant à ton projet, je vais essayer de voir en détails quand j'aurai le temps. Déjà, il y a un problème: Ton tableau de clients, n'est même pas initialisé.

Mais déjà, au niveau des fichiers d'en-tête, voici le genre de corrections que tu peux apporter à Serveur.h:

Code C :

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
typedef enum ee_CommandeServeur
{
	SERVEUR_NEW = 200,
	SERVEUR_DEL,
 
	SERVEUR_LISTEN = 0,
	SERVEUR_ACCEPT,
	SERVEUR_RECV,
	SERVEUR_SEND
} e_CommandeServeur;
 
#define BUFF_SIZE 1024
#define PORTSQL 10000
 
typedef struct tt_Serveur {
    SOCKET ServeurSock;
    SOCKADDR_IN ServeurSin;
} t_Serveur;
 
intptr_t Serveur(e_CommandeServeur sc, intptr_t pa);

[jbarreau-mainson]

Bon j'ai reussi à compiler en changeant le prototype de mes fonction client et serveur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
t_Clients Serveur(int sc, t_Clients pa);
t_Clients Client(int sc, int pa);

Mais je me fait dégager direct avec un beau "erreur de l'ecoute sur la socket".
De plus j'ai l'impression que le programme s'arrete à SERVEUR_NEW, alors que que le listen se situe dans SERVEUR_LISTEN ...

[Médinoc]

Ne passe pas la structure t_Clients par valeur...

[jbarreau-mainson]

Je change un peu de direction, le vieux loup des mers m'a un peu aiguillé !

En effet, je vais faire une collection de clients, ca sera beaucoup plus simple à gérer.