Discussion :

[ikuzar]

Bonjour,
J'utilise OpenSSL pour programmer une couche sécurisée entre TCP et une application.
j'initialise la couche avec sec_initialize( ) et termine la couche avec un sec_terminate( );
1) sec_initialize( ) doit initialiser entre autres :
a) la méthode utilisée pour l'échange ( TLSv1_method( ), SSLv23_method( ), etc. )
b) et un contexte SSL : SSL_CTX
2) sec_terminate( ) doit desallouer les mémoires allouées dans sec_initialize( ). entre autre b)

J'ai crée une classe sslconfig contenant a) et b)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class sslconfig {
   SSL_method *meth;
   SSL_CTX *ctx;
   sslconfig( ){
        meth = SSL_meth( ); 
        ctx = SSL_CTX_new(meht);
   }
   ~sslconfig( ){
        SSL_free(ctx)
    }
}

Tous les membres / fonction commensant par SSL_ sont des objets d'openSSL.

dans sec_terminate( ) je dois desallouer la mémoire occupée par SSL_CTX.

Mes questions :
Q1) Est-ce que la manière de définir le destructeur dans la classe est correcte ? est ce que j'ai le droit de faire cela ? Est-ce une manière propre de desallouer la mémoire. Ou bien :
Q2) Est ce que je dois ne rien mettre dans ~sslconfig càd : ~sslconfig( ){ } ? Dans ce cas, je dois appeler explicitement SSL_free(ctx) dans sec_terminate( ) càd :
gsslconfig->SSL_free(ctx) ?

Merci d'avance.

[Seelass]

Bonjour,

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
class sslconfig 
{
   SSL_method *meth;
   SSL_CTX *ctx;
 
   sslconfig( )
  {
        meth = SSL_meth( ); 
        ctx = SSL_CTX_new(meht);
   }
   ~sslconfig( )
   {
       if(ctx != NULL) //je teste si l'allocation dynamique a réussi si c'est VRAI,
              SSL_free(ctx) //je détruits l'objet ctx
    }
}

Est-ce que la manière de définir le destructeur dans la classe est correcte ? est ce que j'ai le droit de faire cela ? Est-ce une manière propre de desallouer la mémoire

oui tu as le droit parce que dans ton constructeur tu alloues dynamiquement de la mémoire et donc il faut que tu le désalloue dans le destructeur.

Q2) Est ce que je dois ne rien mettre dans ~sslconfig càd : ~sslconfig( ){ } ? Dans ce cas, je dois appeler explicitement SSL_free(ctx) dans sec_terminate( ) càd :
gsslconfig->SSL_free(ctx) ?

le destructeur permet à la fin de l'exécution de ta classe de détruire tes objets dynamiques, et donc il faut que tu spécifies dans ton destructeur les objets à détruire sinon il existeront toujours en mémoire.

[Feriaman]

Salut,

Alors soit j'ai rien compris (ce qui m'arrive souvent), soit tu n'es vraiment pas loin d'une vraie pensée objet.

Ce que tu propose, si j'ai bien compris, c'est ceci :

Code :

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

1
2
3
4
5
methode(){
	SslConfig* maconfig = sec_initialize()
	...ici on utilise la "couche"...
	sec_terminate(maconfig);
}

Code :

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

1
2
3
4
SslConfig sec_initialize()
{
	return new SslConfig();
}

Code :

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

1
2
3
4
void sec_terminate(SslConfig* s)
{
	delete s;
}

et tu te pose la question du "bien objet".

De fait, la réponse que tu propose est bonne : c'est un très bon réflexe quand une API externe te force à faire des new et des delete, de les encapsuler dans une classe telle que tu la propose.

Par contre, ce qui est moins "objet", ce sont les méthodes que tu propose (sec_initialize et sec_terminate). Tu aurais tout intérêt à plutôt faire quelque chose comme ceci :

Code :

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

1
2
3
4
5
methode(){
	SslConfig maconfig;
	...ici on utilise la "couche"...
	// ici rien à faire, le destructeur est appelé automatiquement
}

ou, au pire si tu n'as pas le choix :

Code :

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

1
2
3
4
5
methode(){
	pointeur_intelligent<SslConfig> maconfig_ptr;
	...ici on utilise la "couche"...
	// ici rien à faire, le destructeur est appelé automatiquement
}

Tu as donc le bon réflexe : celui de vouloir mettre les new et les delete dans la même classe. Mais tu ne le pousses pas assez loin, puisque tu veux continuer à gérer ton init et ton terminate dans des méthodes externes différentes.

Tu as posté dans "débutant", je ne sais pas si tu débute vraiment, mais si c'est le cas : bravo, car tu as compris quelque chose que bien des programmeurs ont du mal à comprendre.

[3DArchi]

Salut,
anecdotique : oui le destructeur sert à libérer les ressources gérées par ta classe.
Mais :
Il n'y a pas 36 moyens de gérer correctement une ressource. Une bonne enveloppe RAII : 1 ressource par classe, une acquisition à la construction, une libération à la destruction ET une politique de copie. Ce que n'a pas sslconfig.
Cf F.A.Q : Comment gérer proprement des allocations / désallocations de ressources ? Le RAII !
Tutoriels :
Gérer ses ressources de manière robuste en C++ par Aurélien Regat-Barre

Présentation des pointeurs intelligents en C++ par Loïc Joly

[Feriaman]

ET une politique de copie.

Merci Archi pour avoir corrigé cet oubli.
Peux-tu aller plus loin et illustrer pour notre ami la notion que tu introduit ici ?
Les articles que tu propose sont très intéressants, mais je ne suis pas certain (et si je me trompe, j'en suis désolé), qu'il soit facile pour un débutant de faire le lien entre ceux-ci et l'exemple ci-dessus.

Note : je suis presque sur qu'il manque un 'l' au nom d'Aurélien Regat-Barrel.