Discussion :

[kolodz]

Bonjour,

Je viens de débugé une DLL écrite en C pour une application Java. Cette dll provoquait des crash (non systématique) de l'application Java lors de l'initialisation :

#
# An unexpected error has been detected by HotSpot Virtual Machine:
#
# EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x7706e3be, pid=476, tid=4880
#
# Java VM: Java HotSpot(TM) Client VM (1.5.0_13-b05 mixed mode)
# Problematic frame:
# C [ntdll.dll+0x2e3be]
#

Après un peu de temps, la cause du crash s'est rapprochée des lignes suivantes :

Code :

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

1
2
3
4
char * sChemin = NULL;
char nomIni[250]="\0"; 
sChemin = sC_GEN_AddSepToDirectory(nomFichier);
strcat(sChemin,"MONFICHIER.INI");

En sachant que :

Code :

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

1
2
3
FCT_EXP char * sC_GEN_AddSepToDirectory(char * _sChemin) {
// L'implémentation de la méthode ...
}

En comparant avec le reste du code C à ma disposition dans cette DLL, j'ai mis le code suivant :

Code :

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

1
2
3
4
char sChemin[250] = "\0";
strcpy(sChemin,sC_GEN_AddSepToDirectory(nomFichier));
printf(sChemin);
strcat(sChemin,"MONFICHIER.INI");

Après une série d'essai, je n'ai plus de crash de l'application avec la DLL corrigé.

Ma question est pourquoi la DLL provoquait un crash ?

Cordialement,
Patrick Kolodziejczyk.

[gerald3d]

Bonjour.

La fonction FCT_EXP char * sC_GEN_AddSepToDirectory(char * _sChemin) allouait-elle correctement l'espace nécessaire pour la chaîne retournée ?

[kolodz]

Que veux tu dire par "correctement " ?

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
FCT_EXP char * sC_GEN_AddSepToDirectory(char * _sChemin) 
{
	char * sChemin;
	int taille = 0;
 
	if(_sChemin == NULL) 	
	{
		_sChemin = malloc(sizeof(char));	 
		_sChemin="\0";
	}
 
	sChemin = strrchr(  _sChemin, XGN_ANTISLASH); 
	/* Il n'y a pas de sép à la fin du chemin donc on le met */
	if(!sChemin || strlen(sChemin) > 1)
	{
		taille = strlen(_sChemin);
		sChemin = malloc((taille+2)*sizeof(char));	 
		strncpy(sChemin, _sChemin, taille);
		sChemin[taille] = XGN_ANTISLASH;
		sChemin[taille+1] = '\0';
	}
	/* Il y a un sép à la fin du chemin c'est bon */
	else
	{
		sChemin =  _sChemin;
	}
 
 	return sChemin;
 }

J'ai bien le malloc pour la chaine de retour, mais je ne pense pas que c'est cela dont tu parle...

Cordialement,
Patrick Kolodziejczyk.

[Obsidian]

Bonsoir,

Que veux tu dire par "correctement " ?

Il y a une énorme erreur dans le passage suivant :

Code :

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

1
2
3
4
5
	if(_sChemin == NULL) 	
	{
		_sChemin = malloc(sizeof(char));	 
		_sChemin="\0";
	}

Tu ne déposes pas un caractère nul dans l'espace fraîchement alloué mais tu détournes le pointeur pour le faire pointer une autre chaîne, en lecture seule. Ce faisant, tu perds la valeur de retour renvoyée par malloc() et tu provoques une fuite de mémoire.

Par la suite, si ta condition est fausse, tu renvoies directement cette adresse à l'utilisateur qui, lui, pense qu'elle a été allouée. S'il essaie d'y écrire, cela plantera. S'il essaie de la libérer avec free(), cela plantera aussi.

[kolodz]

Je n'ai pas bien compris ton explication. Mais globalement, tout les appels à cette méthodes peuvent provoquer un crash.
La modification que j'ai fait n'est donc qu'une rustine...

Si je reprends ton explication :

Code :

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

_sChemin = malloc(sizeof(char));

On réalisé une allocation mémoire et place un mon pointeur de char dans la variable.

Code :

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

_sChemin="\0";

On place le pointeur du caractère null dans la variable.
Ce qui fait qu'on perd la référence de ce qu'on vient d'alloué en mémoire. (Fuite mémoire de la taille d'un char)

Cependant, pour cette partie :

Par la suite, si ta condition est fausse, tu renvoies directement cette adresse à l'utilisateur qui, lui, pense qu'elle a été allouée.

Si _sChemin a été initialé avec une caractère nul, alors sChemin sera forcément un pointeur nul. Car strrchr, il ne trouvera pas occurrence cherché.

Code :

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

sChemin = strrchr(  _sChemin, XGN_ANTISLASH);

Ce qui fait que je passe dans ce morceau de code :

Code :

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

1
2
3
4
5
taille = strlen(_sChemin);
sChemin = malloc((taille+2)*sizeof(char));	 
strncpy(sChemin, _sChemin, taille);
sChemin[taille] = XGN_ANTISLASH;
sChemin[taille+1] = '\0';

Dans ce cas là, strlen(_sChemin) retournera 0.
On aura donc sChemin ayant le contenu suivant {["\"],["\0"]} (ma synthase ressemble plus à du json que du c non ?)

Par contre, si on donne un pointeur de char non null. qui finit par un XGN_ANTISLASH et qui est en plus en read only. Là ça va crashé, non ?

Cordialement,
Patrick Kolodziejczyk.

[gerald3d]

Je ferais plutôt :

Code :

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

*_sChemin='\0';

Enfin je crois...

[kolodz]

Juste pour info : le code des poste précédent c'est du "Legacy code".

[Derek Corgan]

C'est du "Legacy code" mais c'est bien pourri si je puis me permettre.

Remarque diverses :
a - dans la fonction, sChemin n'est pas initialisé (pour le principe)
b - comme indiqué par Gérald3d l'init n'est pas correcte si chemin = NULL

Après le souci, c'est le mode d'appel depuis Java qui peut poser problème (JNI ?).

Quand au code que tu a modifié, sChemin est il alloué ?

Les ressources allouées pour sChemin sont elles libérées quelque part ?

[kolodz]

C'est du "Legacy code" mais c'est bien pourri si je puis me permettre.

Et encore... tu n'as pas vue comment ça gère les pointeurs...

Après le souci, c'est le mode d'appel depuis Java qui peut poser problème (JNI ?).

J'en doute, la partie qui pose problème, c'est l'initialisation de la DLL. Java ne fait que la déclenché. Aucun paramètre fournit et aucune résultat retourné.

Les ressources allouées pour sChemin sont elles libérées quelque part ?

Il y a une erreur dans le code que j'ai modifié (oublie) :

Code :

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

char sChemin[250] = "\0";

Dans tout les cas, il me semble que j'ai m'a réponse à ma question initial. Je tag résolu, mais si vous avez d'autres commentaire, je prends !

Cordialement,
Patrick Kolodziejczyk.

[Sve@r]

Il y a une erreur dans le code que j'ai modifié (oublie) :

Code :

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

char * sChemin[250] = "\0";

Bonjour

Tu ne peux pas placer l'adresse d'une chaine ("\0" est bien une chaine puisqu'il y a des quotes doubles) dans un tableau de 250 pointeurs (250 adresses) !!!

Sois tu écris

• char sChemin[250] = "\0"; => tu crées une chaine de 250 caractères et tu lui copies dès le départ une autre chaine
• char *sChemin = "\0"; => tu crées un pointeur et tu lui affectes l'adresse de la chaine statique "\0"
• char *sChemin[250] = {"\0"}; => tu crées un tableau de 250 pointeur et tu affectes l'adresse de la chaine statique "\0" dans le premier pointeur du tableau

[kolodz]

D'après le peu de documentation que j'ai lu, la déclaration suivante :

Code :

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

char * sChemin[250] = "\0";

Revient à cette affectation :

Code :

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

char * sChemin[250] = "";

Car :

Actually, you do not place the null character at the end of a string constant. The C compiler automatically places the '\0' at the end of the string when it initializes the array.

Or le code suivant :

Code :

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

char label[10] = "Single";

Revient à cette initialisation mémoire :

{[S][i][n][g][l][e][\0][][][]}

Ce qui fait que dans mon cas, ce la revient à :

{[\0][][][][][][][][][][][][]....}

Même si je trouve la notation particulièrement stupide ! Mais, du peu que je comprends du C cela reste valide...
Et contenu de la règle sacré concernant le Legacy Code (perso) :

Tu ne touchera point ce qui fonctionne !

Source :
https://www.cs.bu.edu/teaching/cpp/string/array-vs-ptr/
http://www.tutorialspoint.com/cprogr.../c_strings.htm

[Sve@r]

D'après le peu de documentation que j'ai lu, la déclaration suivante :

Code :

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

char * sChemin[250] = "\0";

Revient à cette affectation :

Code :

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

char * sChemin[250] = "";

Pas tout à fait. Tu vois bien que dans le premier cas tu lui affectes un caractère et pas dans le second (détails un poil plus bas)

Or le code suivant : char label[10] = "Single"; revient à cette initialisation mémoire {[S][i][n][g][l][e][\0][][][]}

Si tu veux bien je vais réécrire ça avec la notation propre du C, tu verras que ça aide: char label[10] = "Single" revient à cette initialisation mémoire: char label[10] = {'s', 'i', 'n', 'g', 'l', 'e', '\0', ..., ..., ...} (les "..." signifiant "valeurs aléatoires qui étaient dans la mémoire à ce moment là)

Donc pour en revenir à ton premier exemple, écrire char label[5] = "\0" équivaut à char label[5] = {'\0', '\0', ..., ..., ...} alors qu'écrire char label[5] = "" équivaut à char label[5] = {'\0', ..., ..., ..., ...}.
Ainsi, dans les faits, il y a une énorme différence (dans un des cas tu ne peux pas garantir la valeur du second élément du tableau). Toutefois dans l'utilisation conventionnelle d'une chaine, c'est à dire via des fonctions de manipulation classiques comme strlen(), strcpy(), printf(), toutes ces fonctions s'arrêtant au premier '\0' rencontré, il se trouve que ça ne change rien au résultat. Donc effectivement tu as le droit de simplifier en disant que c'est pareil à condition que tu gardes quand-même ce détail à l'esprit. Parce qu'ici ça ne porte pas à conséquence mais ça pourrait poser un problème dans ce cas là: char label[1] = "\0"!!!
Fort heureusement ce cas de figure ne peut pas arriver parce que l'écriture correcte char label[1] = "" ne peut pas exister (qui irait créer une chaine condamnée à être toujours vide ???). Mais puisque les deux écritures, sans être identiques, produisent un résultat qui, lui, l'est, autant rester simple et écrire char label[5] = ""...

Ce qui fait que dans mon cas, ce la revient à {[\0][][][][][][][][][][][][]....}

En théorie oui. Dans la réalité, le compilo voyant des quotes traduira ça par une possible erreur de ta part et te renverra une erreur (enfin un compilo digne de ce nom). Ainsi, chez-moi, char *x[250]={'\0'} compile mais pas char *x[250]="". Mais même la première écriture n'est pas "politiquement" correcte car on ne met pas de caractère (même égal à 0) dans un pointeur. La bonne syntaxe (c'est à dire la syntaxe qui montre à tout le monde que tu sais ce que tu fais) est celle-là: char *x[250]={NULL} ou au pire char *x[250]={0}. La preuve, dans ton premier post j'ai mal compris ce que tu cherchais à faire et pensais que tu voulais affecter une chaine

N'oublie jamais qu'un code est toujours 100 fois plus lu qu'écrit...

[fred1599]

Dans le cas formateur, c'est intéressant comme débat. Si on veut éviter cela, l'utilisation de strdup est intéressante.