Discussion :

[Djakisback]

Bonjour,
pourrait-on me confirmer que la continuité des données en mémoire d'une structure n'est pas garantie ? Mon idée est la suivante pour la définition d'une structure de requête de client à serveur. Mettons que pour une requête de type 0 on doive transmettre data1 et pour une requête de type 1 on doive transmettre data1 et data2 :

Code :

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

1
2
3
4
5
6
typedef struct {
	int requestType; 		
	int data1;
	char[20] data2;
	//etc...
} request;

Le client envoie toujours la même structure mais pas forcément en entier, ex :

Code :

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

1
2
3
4
5
6
7
request req;
//...
// Type 0, envoi de requestType et data1 uniquement (2 int)
ret = send(socket, (void*)&req, sizeof(int) * 2, 0);
 
// Type 1, envoi de requestType, data1 et data 2
ret = send(socket, (void*)&req, sizeof(int) * 2 + sizeof(char) * 20, 0);

Et du côté du serveur la réception se fait en fonction de requestType, ex :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
request req;
//...
// Réception du type de requête
ret = recv(socket, (void*)req->requestType, sizeOf(req.requestType), 0);
// Poursuite de la lecture des données
if(req->requestType > -1)  {
	ret = recv(socket, (void*)req->data1, sizeOf(req.data1), 0);
	if(req->requestType > 0)  {
		ret = recv(socket, (void*)req.data2, sizeOf(req.data2) * 20, 0);
	}
	//etc.
}

Pensez-vous que ce principe puisse fonctionner ? (a priori je dirais que non)
Merci d'avance.
(Je vais essayer de mon côté mais je n'ai pas de compilateur sous la main.

[orfix]

Les éléments de la structure seront adjacents, mais pour des soucis d'alignement il se pourrait qu'il y ai des trous entre ces derniers ainsi qu'à la fin de la structure, auquel cas ceci ne fonctionnerais pas :

Code Djakisback :

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

1
2
3
4
5
6
7
request req;
//...
// Type 0, envoi de requestType et data1 uniquement (2 int)
ret = send(socket, (void*)&req, sizeof(int) * 2, 0);
 
// Type 1, envoi de requestType, data1 et data 2
ret = send(socket, (void*)&req, sizeof(int) * 2 + sizeof(char) * 20, 0);

moi je procéderais en plusieurs temps comme suit :

Code :

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

1
2
3
send(socket, &req.requestType, sizeof req.requestType, 0);
send(socket, &req.data1, sizeof req.data1, 0);
/* ...et ainsi de suite */

[Djakisback]

Salut et merci pour ta réponse

Les éléments de la structure seront adjacents, mais pour des soucis d'alignement il se pourrait qu'il y ai des trous entre les derniers ainsi qu'à la fin de la structure, auquel cas ceci ne fonctionnerais pas

Effectivement je m'attendais à un truc du style ^^
Oui, donc si je fais l'envoi en plusieurs fois ça fonctionnera mais dans ce cas la structure n'a d'intérêt que pour le stockage local des données, dommage je trouvais l'idée sympa.

En gros de ce que je comprends, on a le choix entre :
- avoir plusieurs structures pour différents type de requêtes et complexifier le code serveur/client
- utiliser une structure de requête générique. Donc avoir du code simplifié mais envoyer des octets inutiles car non initialisés

[Mac LAK]

Oui, donc si je fais l'envoi en plusieurs fois ça fonctionnera mais dans ce cas la structure n'a d'intérêt que pour le stockage local des données, dommage je trouvais l'idée sympa.

En fait, tu peux avoir deux parties plus ou moins distinctes pour ta structure : la partie "commune", déterminant notamment le type de requête, et la partie variable (dont la taille reste à définir par protocole et/ou par un champ de taille dans la requête elle-même). Pour émettre la partie commune (et surtout, en avoir la taille), il te suffit de faire la différence entre l'adresse du premier champ variable et l'adresse du début de la structure : ce sera constant sur la vie du programme, donc à voir si tu initialises une globale avec cette valeur (si c'est calculé systématiquement) ou si l'optimisation permet de le faire via un #define.

En ce cas, tu effectues seulement deux envois quel que soit la requête : le premier inconditionnellement, le second au sein d'un switch conditionné par l'identifiant de requête. Par contre, cela impose de connaître et de figer l'alignement de ta structure, ainsi que les tailles des données et l'endianness afin de garantir une communication fiable entre le client et le serveur. A titre de simplification, tu peux bien sûr décider d'utiliser du little-endian, mais habituellement, en réseau, c'est plutôt du big-endian que l'on utilise.

En gros de ce que je comprends, on a le choix entre :
- avoir plusieurs structures pour différents type de requêtes et complexifier le code serveur/client
- utiliser une structure de requête générique. Donc avoir du code simplifié mais envoyer des octets inutiles car non initialisés

Non, une seule structure contenant :

• Un entête commun à toutes les requêtes (sous-structure ou envoi partiel),
• Une union de N éléments variables en fonction de la requête définie dans l'entête.

Dans tous les cas, ne pas figer l'alignement, la taille des données et l'endianness lors d'une communication réseau binaire, c'est plutôt casse-gueule...

[Djakisback]

Merci pour ces précisions
Mais à vrai dire je ne comprends pas bien, est-ce que tu aurais un exemple rapide ?
Car j'ai l'impression que d'après ce que tu dis, ce que je proposais dans mon premier exemple fonctionnerait ? Tu proposes bien d'envoyer la structure en 2 temps ? Mais le problème soulevé par ssmario2 reste le même non ?

[edit]En réalité, tu proposes d'envoyer une union de N éléments variables en fonction de la requête définie dans l'entête.[/edit] Donc si je comprends bien tu proposes d'envoyer toujours la même taille de données ?

[Mac LAK]

Donc si je comprends bien tu proposes d'envoyer toujours la même taille de données ?

La taille de l'union est certes la taille de la plus grande de ses alternatives... Mais qui a dit que tu étais obligé d'envoyer le sizeof(union), en lieu et place du sizeof() spécifique associé à la requête ?

En gros (cf. points en rouge) :

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
typedef struct {
  struct header {
    int request_type ;
    int data1 ;
    char common_data[XXX] ;
    .....
  } h ;
  union data {
    struct data_r1 {
      char xxxx ;
    } d1 ;
    struct data_r2 {
      char yyyy[10000] ;
      float zzzz ;
    } d2 ;
    ......
  } d ;
} request ;


int send_request ( int socket, request* req ) {

  int ret ;

  ret = send(socket,&(req->h),sizeof(req->h),0);
  if (ret==0)
    switch (req->h.request_type) {
      case REQUEST1 :
        ret = send(socket,&(req->d.d1),sizeof(req->d.d1),0);
        break ;

      case REQUEST2 :
        ret = send(socket,&(req->d.d2),sizeof(req->d.d2),0);
        break ;

      default :
        ret = -1 ;
        break ;
    }
    return ret ;
}

C'est plus clair ?