Discussion :

[poower]

Bonjour,

J'ai une structure req_list contenant :
un ssize_t
un tableau de struct requete req[]

struct requete contient un tableau char args[ARG_SIZE] et ARG_SIZE est un define valent 2048

Dans le client :

J,'initialise les champs d' une variable de type req_list j'écris cette variable dans le tube
avec write(tube, &variable, sizeof(req_list))

Dans le serveur :
Ensuite, avant de lire dans le tube je déclare une
variable dont je vais assigner celle qui a été ecrite dans le tube.

req_list var2

Quand je lit dans le tube je fais :
read(tube, &var2, sizeof(req_list))

Quand j'affiche les champs de var2
il n'y a que le ssize_t qui est bien récupéré
mais un printf de var2. req[i].args affiche des caractères spéciaux genre @ ou ?

Peut-être que le sizeof(req_list) n'est pas correct dans le read il y a assez pour le ssize_t mais pas pour les chaines args ?

Merci

[dalfab]

Bonjour,

Si la structure ne contient que des sous-structures ou des tableaux, il n'y a aucune raison pour que le sizeof ne fonctionne pas. Attention s'il y a des pointeurs, leur valeur sera transmise mais ils sont inutilisables en réception.
Les 2 codes doivent utiliser exactement les même définitions et doivent être dans des configurations identiques (p.e pas un en 32 bits et l'autre en 64 bits.), tu peux afficher les 2 sizeof des 2 programmes pour t'en assurer.
As-tu vérifié la valeur de retour de read()? Il indique combien de bytes ont été reçus. S'il est inférieur à sizeof req_list, il faut refaire un read() (en déplaçant l'adresse de réception et en diminuant la taille attendue du nombre de bytes déjà reçus.)

[poower]

Dans le client :
La variable de type req_list sizeof( vaut 8 bytes
Le write apres ecriture dans le tube a ecrit 8 bytes
(%zd)

Cote serveur :
Meme chose. sizeof(req_list) = 8 apres le read.
Et n = read, n vaut 8 apres lecture (%zd)

Pour infi quand j'affiche apres le write je fais :

Code :

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

1
2
for(int i = 0; i < req_list.n; ++i) 
  printf(''%d %s '', i, req_list. list[i]. args) ;

[dalfab]

Il y a quelque chose d'incohérent. Peux-tu donner le détail de la structure, je vois mal comment mettre autant de choses dans une structure qui n'a pas de pointeur et qui ne fait que 8 bytes!

[poower]

typedef enum type_req {
INFO_USER,
INFO_PROC,
INFO_GROUP
}

typedef struct requete {
type_req r; //type de requete
char args[ARG_SIZE] ; //la requete
i. e argv[i]
char cmd[ARG_SIZE] //vaudra '' user'' proc ou group
char shm[NAME_MAX] //shm corresppndand au pid du client
char file[NAME_MAX] //chemin acces d' un autre programme

typedef struct requete_list {
ssize_t n; //nombre requete (=taille liste des requete)
requete list[] ; //liste des requete
}

Ce que j'essaye de faire c'est recuperer la taille de la liste, pour l'envoyer au read du serveur.
C'est pour ça que j'ai une structure requete_list qui contient un ssize n
qui contiendra le nombre de requete
et dans requete list[] je le remplit avec chaque requete presente dans une autre list(memcpy). J'ai verifie et list[] est bien remplit avec les bonnes requete et leur champ, le soucis c'est que par ex pour 2 requete j'ai 16 bytes (apres le memcpy) et le read me dit qu'il en a ecrit 8 au lieu de 16...

[dalfab]

Code :

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

1
2
3
4
typedef struct requete_list {
ssize_t n; //nombre requete (=taille liste des requete) 
requete list[] ; //liste des requete
}

Cette notation crée une structure contenant seulement n + un alignement compatible pour y concaténer des requete. Il n'y a aucun tableau dans cette structure (un tableau a toujours une taille explicitement indiquée ou immédiatement calculable)!
Pour y mettre des données dans list[], il y a quelque part un malloc() pour allouer une structure qui en fait est réalité beaucoup plus grande. n permet de retrouver la taille réellement allouée.
La structure à récupérer doit elle aussi faire l'allocation pour recevoir toutes ces données (elle ne peut le faire qu'après avoir lu la valeur du champ n), ça ressemblerait à :

Code :

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

1
2
3
4
5
6
7
8
9
10
size_t n;
struct requete_list* pReqList = NULL;         // recevra le résultat
 
size_t nbLus = read( tube , &n , sizeof n );  // lecture du début
if ( nbLus == sizeof n ) {
    size_t taille = sizeof(struct requette_list) + n * sizeof(requete);
    pReqList = malloc( taille );
    pReqList->n = n;
    nbLus = read( tube , (char*)pReqList + sizeof n , taille - sizeof n );     // lecture du reste
}