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

Signaler
Messages postés
243
Date d'inscription
lundi 17 décembre 2007
Statut
Membre
Dernière intervention
5 décembre 2012
-
Messages postés
112
Date d'inscription
lundi 29 juin 2009
Statut
Membre
Dernière intervention
5 novembre 2009
-
Bonjour,
j'ai le message d'erreur suivante à la compilation :
invalid application of ‘sizeof’ to incomplete type ‘struct pam_handle’

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
A voir également:

5 réponses

Messages postés
966
Date d'inscription
samedi 3 avril 2004
Statut
Membre
Dernière intervention
4 mars 2010
4
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.
Messages postés
966
Date d'inscription
samedi 3 avril 2004
Statut
Membre
Dernière intervention
4 mars 2010
4
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.
Messages postés
243
Date d'inscription
lundi 17 décembre 2007
Statut
Membre
Dernière intervention
5 décembre 2012

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))
Messages postés
966
Date d'inscription
samedi 3 avril 2004
Statut
Membre
Dernière intervention
4 mars 2010
4
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));
Messages postés
112
Date d'inscription
lundi 29 juin 2009
Statut
Membre
Dernière intervention
5 novembre 2009

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