conversion to non-scalar type requested

Version imprimable

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:

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:

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:

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:

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

01/04/2009, 11h40
Médinoc

J'ai l'impression que le type de pa n'est pas ce qu'il devrait être...
01/04/2009, 11h47
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 !
01/04/2009, 11h51
crocodilex
Code:

Serveur(SERVEUR_ACCEPT, &argc);
Code:

1 2 int Serveur(int sc, int pa) {
Ce n'est pas très cohérent tout ça....
01/04/2009, 12h18
Médinoc

Citation:

Envoyé par 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 !

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.
01/04/2009, 13h00
jbarreau-mainson

Citation:

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:

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

Citation:

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.

Citation:

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

J'ai enlevé le "&".

Et si tu faisais tout simplement ceci?

Code:

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?

01/04/2009, 14h07
jbarreau-mainson

En réponse j'ai :

Code:

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 ... :roll:
01/04/2009, 14h11
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...

Main.c
-------

Code:

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:

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:

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:

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:

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:

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);

01/04/2009, 14h20
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.
01/04/2009, 14h24
jbarreau-mainson

Citation:

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

:lol: merci !

Citation:

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:

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 ..

Citation:

Envoyé par Donald Knuth

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:

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);

02/04/2009, 09h18
jbarreau-mainson
Bon j'ai reussi à compiler en changeant le prototype de mes fonction client et serveur :
Code:

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 ...
02/04/2009, 09h55
Médinoc

Ne passe pas la structure t_Clients par valeur...
03/04/2009, 12h58
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.