invalid application of ‘sizeof’ to incomplete type ‘struct pam

Question

Bonjour,
j'ai le message d'erreur suivante à la compilation :
invalid application of &#8216;sizeof&#8217; to incomplete type &#8216;struct pam_handle&#8217;

dans mon fichier loginh.h j'ai defini :

typedef struct pam_handle pam_handle_t; // une structure dont la definition et le fichier qui la contient est tenu secrète.
typedef struct login_handle login_handle_t;
 
struct login_handle{
  unsigned int use_lp;
  unsigned int use_sc;
  pam_handle_t  *login_pamh;
  //pkcs11_handle_t *sc_ph; //a gerer
};

dans pam_pkcs11.c, j'inclut loginh.h, j'alloue de la mémoire avec malloc :


  login_handle_t *lh;
  lh->login_pamh = (pam_handle_t *)malloc(sizeof(pam_handle_t));
 

puis j'ai réessayé avec :

 
 login_handle_t *lh;
  lh->login_pamh = (pam_handle_t *)malloc(sizeof(struct pam_handle));
 

mais j'obtiens toujours la meme erreur.

- Que signifie cette erreur ?
- Comment je dois corriger mon programme ?

Merci d'avance pour votre aide

cs_juju12 · Answer

Tu dis, "une structure dont la definition et le fichier qui la contient est tenu secrète."
Est-ce-que tu entends par là que la structure est bien définie mais que tu ne veux pas la détailler sur le forum? Dans le cas contraire, sizeof() ne peut bien évidemment pas connaître la taille de la structure puisqu'il ne la connaît pas.

cs_juju12 · Answer

oh et accessoirement grosse faute (mais distincte du problème) : 

 login_handle_t *lh;
 lh->login_pamh = (pam_handle_t *)malloc(sizeof(struct pam_handle));


Où as-tu initialisé lh? Nulle part effectivement, donc il ne pointe sur rien et erreur de segmentation à l'exécution.

razuki · Answer

Oui. Effectivement il sait pas quelle taille fait pam_handle qui est une structure opaque ( blind structure ) la definition est tenue secrète par les developpeurs PAM. 

Ou est ce que j'ai initialisé lh ? 
Voici une partie du code :

static void *ask_for_login(void* data){
  int rv;

static void *ask_for_login(void* data){
  int rv;
  login_handle_t *lh;
  lh->login_pamh = (pam_handle_t *)malloc(sizeof(pam_handle_t));
  lh = (login_handle_t *)data;// c'est ici que je l'initialise ... Est - ce incorrecte ? Je fais pas de malloc(sizeof(login_handle_t))

cs_juju12 · Answer

non OK c'est correct, du moment que c'est dans l'autre sens...


static void *ask_for_login(void* data){
  int rv;
  login_handle_t *lh;
  lh = (login_handle_t *)data;
  lh->login_pamh = (pam_handle_t *)malloc(sizeof(pam_handle_t));

Kotomine · Answer

la definition est tenue secrète par les developpeurs PAM. 

Euh, t'y vas un peu fort là ... PAM c'est du GPL.
Ce qu'il faut comprendre, c'est que PAM c'est un système d'authentification sous linux , et que par conséquent, ça brasse des données noyeau et utilisateur.
Le noyeau t'offre une structure globale mais masque les donneés sensibles qui seront protégées par des pages non accessibles de droit.


Mais garde à l'esprit qu'un truc opaque (pointeur, structure), tu n'as PAS LE DROIT de l'allouer ou de le modifier (Car tu ne cannait rien de ce que tu manipules)

Revois ton design, tu ne dois pas a avoir à créer toi même cette structure, mais tu dois utiliser un appel quelconque à pam.

je vais t'illustrer mes propos avec un exemple tout bête:


// definition d'un message protégé opaque
struct messageOpaque{
char * message;
}

// structure réelle : non opaque
struct messageClear{
char * message;
int checksum;
}

// fonction abstraite que je ne commente pas qui réalise un checksum du
// message (un code symbolisant son contenu)
int makeChksum(const char * msg);

// fonction qui fabrique un message protégé
struct messageOpaque * createMessage(const char * message){
struct messageClear * msg = malloc(sizeof(messageClear));
msg->message=strdup(message);
msg->checksum=makeChksum(message);
return (struct messageOpaque*) msg; // hop on change le type du pointeur comme ça personne ne peut acceder au checksum
}


int isMessageTrafiqued(const struct messageOpaque *msg){
// on demasque le message
struct messageClear * realMsg= (struct messageClear) msg; 
return makeChksum(msg->message)!=msg->checksum;
}



Voici un exemple d'utilisation


struct messageOpaque * msg = createMessage("rick roll");
msg->message="pouet pouet";
if(isMessageTrafiqued()){
// on passera par la
}


En mémoire, la fonction createMessage va écrire à un endroit quelconque :
[ pointeur de  chaine "rick roll" , 456747] (le 456747 étant le checksum présumé ...)

Ici, je fais aparaitre un champ caché (checksum) qui n'aparait pas dans la version opaque de la structure.
Imagine qu'un malin face


struct messageOpaque *truc=malloc(sizeof(struct messageOpaque));
truc->message="CHEZ MOI IL PLEUT";

isMessageTrafiqued(truc);

En mémoiore, tu aura uniquement [pointeur de chaine "CHEZ MOI IL PLEUT"] [données aléatoires etinaccessibles]

la fonction isMessageTrafiqued qui lit apres le pointeur de chaine, va lire n'importe ou.

Dans la fonction truc, on va essayer d'acceder au checksum, mais e
; I'm just keeping the hopeless cross to increase the meaninglessness

Invalid application of ‘sizeof’ to incomplete type ‘struct pam

5 réponses

Votre réponse

Discussions similaires