Segmentation Fault sur un fclose

Version imprimable

Bonjour, je travaille actuellement sur un programme que je compile dans un terminal sous la version 4 de Fedora. Or j'ai un problème lorsque je lance le programme il apparait un segmentation fault au niveau d'un fclose. J'ai vu sur le net que celà pouvait être du à un pointeur null. Mais il n'en est rien, le FILE* que je tente de fermer n'est pas null.

Autre chose si je compile sous windows avec DevC++ il n'y a aucun problème. (Mais bon je dois rendre ce programme de façon à ce qu'il marche sous linux).

Pourriez-vous m'aider, voici le code du programme, ainsi que le fichier ala.pdb que je lis et que je ferme.

lect_fich_pdb.c :

Code:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define NB_MAX 10000
 
typedef struct{
	float x, y, z;
}Position3D;
 
 
int get_atom_pdb(char *nom_fichier);
 
char* sous_chaine(char *dest,char *src, int deb, int fin);	//retourne la sous chaine de ch commençant à l'indice deb et terminant à fin
 
void init_tab_pos(Position3D *tab_pos, int *tab_indice,char *nom_fichier);
 
void init_moins_un(int *tab,int nb_elem);
 
void init_graphe_zero(char **graphe, int nb_atome);
 
void remplir_graphe(char* nomfichier,int* tab_indice,char** graphe);
 
int lectPDB(char *nom_fichier,Position3D *tab_pos,char **graphe);
 
char* sous_chaine(char *dest,char *src, int deb, int fin);
 
//##########PROGRAMME PRINCIPAL##########
int main(int argc, char **argv)
{
    char nom_pdb[30];
 
	char ** molecule;
	Position3D *lesAtomes;
	int i;
 
	int nbAtomes;
 
	printf("Entrez le nom du fichier et appuyer sur entree :\n");
	scanf("%s",nom_pdb);
 
 
	molecule = (char **)calloc(NB_MAX, sizeof(char *));
	lesAtomes = (Position3D *)calloc(NB_MAX, sizeof(Position3D));
	for(i=0;i<NB_MAX; i++)
		molecule[i] = (char *)calloc(NB_MAX, sizeof(char ));
 
 
	nbAtomes = lectPDB(nom_pdb, lesAtomes,  molecule);
//desallocation
	free(lesAtomes);
	for(i=0;i<NB_MAX; i++)
		free(molecule[i]);
	free(molecule);
 
	return 0;
}
 
//###########IMPLEMENTATION DES FONCTIONS############
char* sous_chaine(char *dest,char *src, int deb, int fin){
 
	dest=strncpy(dest,src+deb,fin-deb);
	dest[fin]='\0';
	return dest;
}
 
int get_atom_pdb(char *nom_fichier){ //retourne le nombre d'atome du fichier pdb pour allocation dynamique
	char ligne[81];	//on stockera chaque ligne tour a tour dans ce tableau
	char *deb_ligne; //debut de la ligne
	FILE* fichier;
	int nb_atom=0;
 
	deb_ligne=(char*)malloc(4*sizeof(char));
	fichier=fopen(nom_fichier,"r");
 
	while(fgets(ligne,sizeof(ligne),fichier)!=NULL){ //tant qu'il reste des lignes a lire
		if(strcmp(sous_chaine(deb_ligne,ligne,0,4),"ATOM")==0 || strcmp(sous_chaine(deb_ligne,ligne,0,6),"HETATM")==0){
            		nb_atom++;
        	}
	}
 
    	fclose(fichier);
    	return nb_atom;
}
 
void init_tab_pos(Position3D *tab_pos, int *tab_indice,char *nom_fichier){
	char ligne[81];	//on stockera chaque ligne tour a tour dans ce tableau
	char *deb_ligne; //debut de la ligne
	FILE* fichier;
	int i=0;
	deb_ligne=(char*)malloc(4*sizeof(char));
	fichier=fopen(nom_fichier,"r");
	printf("init_tab_\n");
	printf("sizeofligne:%d\n",sizeof(ligne));
 
	while(fgets(ligne,sizeof(ligne),fichier)!=NULL){ //tant qu'il reste des lignes a lire
		//printf("ligne:%s",ligne);
		if(strcmp(sous_chaine(deb_ligne,ligne,0,4),"ATOM")==0 || strcmp(sous_chaine(deb_ligne,ligne,0,6),"HETATM")==0){	//si le debut de la ligne est ATOM
            		tab_indice[atoi(sous_chaine(deb_ligne,ligne,7,11))]=i;
			tab_pos[i].x=atof(sous_chaine(deb_ligne,ligne,31,38));
			tab_pos[i].y=atof(sous_chaine(deb_ligne,ligne,39,47));
			tab_pos[i].z=atof(sous_chaine(deb_ligne,ligne,47,54));
			i++;
		}
	}
	printf("putain\n");

fclose(fichier); //C'est là que ça plante

Code:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
printf("ça marche !\n");
}
 
void remplir_graphe(char* nom_fichier,int* tab_indice,char** graphe){
    char ligne[81];	//on stockera chaque ligne tour a tour dans ce tableau
	char *deb_ligne; //debut de la ligne
	//num_atom : numero de l'atome courant
    //atom_connect : numero de l'atome connect�a l'atome courant
	FILE* fichier;
	int j,deb,fin,num_atom,atom_connect;
	deb_ligne=(char*)malloc(6*sizeof(char));
 
    fichier=fopen(nom_fichier,"r");
 
    while(fgets(ligne,sizeof(ligne),fichier)!=NULL){ //tant qu'il reste des lignes a lire
		if(strcmp(sous_chaine(deb_ligne,ligne,0,6),"CONECT")==0){//si la ligne commence par "conect"
            deb=12; //position a laquelle on trouve les numeros d'atome connect�            fin=16;
            j=0;
            num_atom=atoi(sous_chaine(deb_ligne,ligne,7,11)); //numero de l'atome courant
            while(j<4 && atoi(sous_chaine(deb_ligne,ligne,deb,fin))){//tant qu'il y a des nombres sur la ligne connect et que leyr nombre est <4
              atom_connect=atoi(sous_chaine(deb_ligne,ligne,deb,fin));
              graphe[tab_indice[num_atom]][tab_indice[atom_connect]]=1;
              deb+=5;
              fin+=5;
              j++;
            }
        }
    }
    fclose(fichier);
}
 
void init_moins_un(int *tab,int nb_elem){
     int i;
     for(i=0;i<nb_elem;i++){
        tab[i]=-1;
     }
}
 
void init_graphe_zero(char **graphe, int nb_atome){
   int i,j;
   for(i=0;i<nb_atome;i++){
      for(j=0;j<nb_atome;j++){
         graphe[i][j]=0;
      }
   }
}
 
int lectPDB(char *nom_fichier,Position3D *tab_pos,char **graphe){
	int *tab_indice;
	int nb_atome;
 
 
    nb_atome=get_atom_pdb(nom_fichier);
	//printf("Nb d'atome du fichier %s : %d\n",nom_fichier,nb_atome);
 
    //allocation de la mémoire
    tab_indice=(int*)malloc(sizeof(int)*NB_MAX);
    //on initialise le tableau d'indice �-1
    init_moins_un(tab_indice,NB_MAX);
 
    //initialisation du tableau d'indice et du tableau de position
	init_tab_pos(tab_pos,tab_indice,nom_fichier);
	printf("Initialisation du tableau de position : OK\n");
 
   	//on initialise le graphe des conections a zero
	init_graphe_zero(graphe,NB_MAX);
	printf("Initialisation du graphe : OK\n"); 
 
    //on remplit le graphe des connection
    remplir_graphe(nom_fichier,tab_indice,graphe);
    printf("Remplissage du graphe : OK\n");
    return nb_atome;
}

Voilà le fichier ala.pdb :

HEADER AMINO ACID
COMPND ALANINE (ALA or A)
AUTHOR GENERATED BY GLACTONE
ATOM 1 N ALA 0001 -1.053 1.300 0.614
ATOM 2 CA ALA 0001 -0.304 0.032 0.746
ATOM 3 C ALA 0001 0.770 -0.014 -0.311
ATOM 4 O ALA 0001 1.952 -0.167 -0.047
ATOM 5 H ALA 0001 -1.805 1.385 1.386
ATOM 6 O ALA 0001 0.354 0.125 -1.567
ATOM 7 H ALA 0001 -1.522 1.368 -0.358
ATOM 8 H ALA 0001 0.176 0.013 1.740
ATOM 9 C ALA 0001 -1.237 -1.200 0.610
ATOM 10 H ALA 0001 -2.007 -1.183 1.397
ATOM 11 H ALA 0001 -0.655 -2.129 0.709
ATOM 12 H ALA 0001 -1.737 -1.199 -0.371
ATOM 13 H ALA 0001 1.100 0.082 -2.154
CONECT 1 2 5 7
CONECT 2 1 3 8 9
CONECT 3 2 4 4 6
CONECT 4 3 3
CONECT 5 1
CONECT 6 3 13
CONECT 7 1
CONECT 8 2
CONECT 9 2 10 11 12
CONECT 10 9
CONECT 11 9
CONECT 12 9
CONECT 13 6
END

Salut

Tu alloues beaucoup d'octets et tu ne testes pas le retour de malloc, ce n'est pas une bonne chose.
D'autre part :

Code:

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
30
31
32
33
34
35
36
37
38
void init_tab_pos(Position3D *tab_pos, int *tab_indice,char *nom_fichier){
   char ligne[81];   //on stockera chaque ligne tour a tour dans ce tableau
   char *deb_ligne; //debut de la ligne
   FILE* fichier;
   int i=0;
   deb_ligne=(char*)malloc(4*sizeof(char));
   fichier=fopen(nom_fichier,"r");
   printf("init_tab_\n");
   printf("sizeofligne:%d\n",sizeof(ligne));
 
   while(fgets(ligne,sizeof(ligne),fichier)!=NULL){ //tant qu'il reste des lignes a lire
      //printf("ligne:%s",ligne);
 
 
 
 
    // sous_chaine est alloué mais tu n'as rien copié dedans donc il peut se passer n'importe quoi au moment de la comparaison.
 
 
 
     if(strcmp(sous_chaine(deb_ligne,ligne,0,4),"ATOM")==0 || strcmp(sous_chaine(deb_ligne,ligne,0,6),"HETATM")==0){   //si le debut de la ligne est ATOM
                  tab_indice[atoi(sous_chaine(deb_ligne,ligne,7,11))]=i;
         tab_pos[i].x=atof(sous_chaine(deb_ligne,ligne,31,38));
         tab_pos[i].y=atof(sous_chaine(deb_ligne,ligne,39,47));
         tab_pos[i].z=atof(sous_chaine(deb_ligne,ligne,47,54));
         i++;
      }
   }
   printf("putain\n");
 
// tu ne libères pas sous_chaine perte de mamoire.
 
 
fclose(fichier); //C'est là que ça plante
Code:
 
printf("ça marche !\n");
}

29/11/2005, 22h42
Beush
Bon j'ai réussi à le faire marcher finalement mais alors je sais pas trop pourquoi cela ne marchait pas tout ce que je peux dire c'est que les allocations dynamiques (malloc) il faut les faire après le fopen et pas avant !

Il faut faire ça :
Code:

1 2 3 4 fichier=fopen(nom_fichier,"r"); deb_ligne=(char*)malloc(4*sizeof(char));
et non :
Code:

1 2 3 4 deb_ligne=(char*)malloc(4*sizeof(char)); fichier=fopen(nom_fichier,"r");
Voilà, si quelqu'un a une explication rationnelle à proposer je souhaiterais vivement la connaitre.
Merci à toi Trap D car même si ta réponse n'était pas la solution c'est en bidouillant les truc que tu m'avais demandé que j'ai changé ces lignes de place.
29/11/2005, 22h45
Trap D

A mon avis, ton problème n'est pas résolu, car il n'y a aucune raison pour que ce soit le changement de place qui fasse que "ça marche". Regarde bien ton prog, tu peux le donner ?
Tu as corrigé ce que je signalais pour le deb_ligne ? (et non pas sous_chaine comme je l'ai écrit :oops: ).
29/11/2005, 22h56
hegros
Citation:
Envoyé par Beush

Bon j'ai réussi à le faire marcher finalement mais alors je sais pas trop pourquoi cela ne marchait pas tout ce que je peux dire c'est que les allocations dynamiques (malloc) il faut les faire après le fopen et pas avant !

Il faut faire ça :

Code:

1 2 3 4 fichier=fopen(nom_fichier,"r"); deb_ligne=(char*)malloc(4*sizeof(char));

et non :

Code:

1 2 3 4 deb_ligne=(char*)malloc(4*sizeof(char)); fichier=fopen(nom_fichier,"r");

Voilà, si quelqu'un a une explication rationnelle à proposer je souhaiterais vivement la connaitre.
Merci à toi Trap D car même si ta réponse n'était pas la solution c'est en bidouillant les truc que tu m'avais demandé que j'ai changé ces lignes de place.
je vois rien dans le fait d'inverser ces deux intructions qui peut avoir une quelconque incidence sur une erreur de segmentation. Tu devrais regarder d'un peu plus près...
29/11/2005, 23h08
gl

Dans la fonction init_tab_pos() (ainsi que dans la fonction get_atom_pdb()), tu alloues pour deb_ligne de la place pour 4 char, or quelques lignes apres tu fait sous_chaine(deb_ligne,ligne,0,4) qui utilise le 5eme char de deb_ligne (le dest[fin]='\0' de la fonction sous_chaine) et sous_chaine(deb_ligne,ligne,0,6) qui necessite pour sa part 7 char (et il y en a d'autres plus loin du mme acabit).

En fait, je vois au moins deux problemes :
* l'allocation pour deb_ligne n'a pas une taille suffisante.
* ce n'est pas dest[fin]='\0', mais dest[fin-deb]='\0' afin de gerer correctement les cas ou deb ne vaut pas 0.

De plus concernant le malloc :
* il est preferable d'utiliser sizeof(*deb_ligne) a sizeof(char) (plus facile a maintenir en cas de changement de type de deb_ligne).
* je ne vois pas l'interet d'utiliser une allocation dynamique pour une taille fixe et aussi faible que 4 byte.

Re: Segmentation Fault sur un fclose

Citation:

Envoyé par Beush

J'ai mis un peu d'ordre dans le b*rdel ambiant, c'était pas du luxe...

Sécurisation des lectures de fichiers et des allocations
J'ai réorganisé les allocations...Les allocations sont trop complexes. Il y a plusieurs tableaux de même taille. Un tableau de structures devrait suffire...
Dans remplir_graphe(), 'fin' n'est pas initialisé. J'ai mis 0, mai c'est surement faux...
Dans init_tab_pos(), j'ai instrumenté le code et j'ai detecté un débordement de tableau. (J'ai mis une rustine)
Je n'ai certainement pas tout vu...

Code:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
 
#define DBG 1
 
typedef struct
{
    float x, y, z;
}
Position3D;
 
/* retourne le nombre d'atome du fichier pdb pour allocation dynamique */
static int get_atom_pdb (char const *nom_fichier)
{
    int nb_atom = -1;
    FILE* fichier = fopen (nom_fichier, "r");
 
    if (fichier != NULL)
    {
        char ligne[81];
 
        /* tant qu'il reste des lignes a lire */
        while (fgets (ligne, sizeof ligne, fichier) != NULL)
        {
#if DBG
            printf ("%s\n", ligne);
#endif
 
            if (strncmp (ligne,"ATOM",4)==0
                    || strncmp (ligne,"HETATM",6)==0)
            {
                nb_atom++;
            }
        }
 
        fclose (fichier), fichier = NULL;
    }
#if DBG
    printf ("nb_atom = %d\n", nb_atom);
#endif
 
    assert (fichier == NULL);
    return nb_atom;
}
 
static int init_tab_pos (char const *nom_fichier
                         , Position3D *tab_pos
                         , int *tab_indice
                         , int nb_atome)
{
    int err = 0;
    FILE* fichier = fopen (nom_fichier,"r");
 
    if (fichier != NULL)
    {
        int i = 0;
        char ligne[81];   //on stockera chaque ligne tour a tour dans ce tableau
 
        /* tant qu'il reste des lignes a lire */
        while (fgets (ligne, sizeof ligne, fichier) != NULL)
        {
#if DBG
            printf("ligne:%s",ligne);
#endif
            /* si le debut de la ligne est ATOM ou HETATM */
            if (strncmp (ligne, "ATOM", 4) == 0
                    || strncmp (ligne, "HETATM", 6) == 0)
            {
 
                {
                	int ndx = atoi(ligne + 7);
 
                   assert (ndx < nb_atome);
                   tab_indice[ndx] = i;
                }
 
                if (i < nb_atome)
                {
                    assert (i < nb_atome);
                    tab_pos[i].x=atof(ligne + 31);
                    tab_pos[i].y=atof(ligne + 39);
                    tab_pos[i].z=atof(ligne + 47);
                    i++;
                }
            }
        }
 
        fclose(fichier);
    }
    else
    {
        perror(nom_fichier);
        err = 1;
    }
    return err;
}
 
static int remplir_graphe (char const * nom_fichier, int* tab_indice, char** graphe)
{
    int err = 0;
 
    FILE* fichier = fopen (nom_fichier, "r");
 
    if (fichier != NULL)
    {
        char ligne[81];
 
        /* tant qu'il reste des lignes a lire */
        while (fgets (ligne, sizeof ligne, fichier) != NULL)
        {
            /* si la ligne commence par "conect" */
            if (strncmp (ligne, "CONECT", 6) == 0)
            {
                int fin = 0;
                int deb = 12; //position a laquelle on trouve les numeros d'atome connect?            fin=16;
                int j=0;
                /* num_atom : numero de l'atome courant */
                int num_atom = atoi (ligne + 7); //numero de l'atome courant
 
                /* tant qu'il y a des nombres sur la ligne connect
                et que leur nombre est < 4 
                */
                while(j < 4 && atoi (ligne + deb))
                {
                    /* atom_connect : numero de l'atome connecte a l'atome courant */
                    int atom_connect=atoi(ligne+deb);
 
                    graphe[tab_indice[num_atom]][tab_indice[atom_connect]] = 1;
                    deb += 5;
                    fin += 5;
                    j++;
                }
            }
        }
        fclose(fichier);
    }
    else
    {
        perror(nom_fichier);
        err = 1;
    }
    return err;
}
 
static void init_moins_un (int *tab, int nb_elem)
{
    int i;
 
    for(i = 0; i < nb_elem; i++)
    {
        tab[i] = -1;
    }
}
 
static void init_graphe_zero (char **graphe, int nb_atome)
{
    int i;
 
    for(i = 0; i < nb_atome; i++)
    {
        int j;
 
        for (j = 0; j < nb_atome; j++)
        {
            graphe[i][j] = 0;
        }
    }
}
 
static void lectPDB(char *nom_fichier)
{
    int nb_atome = get_atom_pdb (nom_fichier);
    //printf("Nb d'atome du fichier %s : %d\n",nom_fichier,nb_atome);
 
    /* allocation de la memoire */
    if (nb_atome != -1)
    {
        char **graphe = malloc (nb_atome * sizeof *graphe);
 
        if (graphe != NULL)
        {
            int err = 0;
            int i;
 
            for (i = 0; i < nb_atome; i++)
            {
                graphe[i] = malloc (nb_atome * sizeof *graphe[i]);
                err = graphe[i] == NULL;
            }
 
            if (!err)
            {
                Position3D *tab_pos = malloc (nb_atome * sizeof *tab_pos);
 
                if (tab_pos != NULL)
                {
                    int *tab_indice = malloc (sizeof *tab_indice * nb_atome);
 
                    if (tab_indice != NULL)
                    {
                        /* on initialise le tableau d'indice a - 1 */
                        init_moins_un(tab_indice,nb_atome);
 
                        {
                            //initialisation du tableau d'indice et du tableau de position
                            int err = init_tab_pos(nom_fichier, tab_pos,tab_indice, nb_atome);
                            printf("Initialisation du tableau de position : %s\n", err ? "ERR" : "OK");
 
                            if (err)
                            {
                                //on initialise le graphe des conections a zero
                                init_graphe_zero(graphe,nb_atome);
                                printf("Initialisation du graphe : OK\n");
 
                                //on remplit le graphe des connection
                                err = remplir_graphe(nom_fichier,tab_indice,graphe);
                                printf("Remplissage du graphe : %s\n", err ? "ERR" : "OK");
                            }
                        }
                        free (tab_indice), tab_indice = NULL;
                    }
                    /* desallocation */
                    free (tab_pos), tab_pos=NULL;
                }
            }
            for (i = 0; i < nb_atome; i++)
            {
                free(graphe[i]);
            }
            free (graphe), graphe=NULL;
        }
    }
}
 
//##########PROGRAMME PRINCIPAL##########
int main (void)
{
    char nom_pdb[30];
 
    printf("Entrez le nom du fichier et appuyer sur entree :\n");
    scanf("%s",nom_pdb);
 
    lectPDB (nom_pdb);
    return 0;
}

29/11/2005, 23h52
Beush

C'est vrai, c'est fin-deb qu'il faut mettre je sais même pas comment ça pouvait mmarcher même sous Windows !! Merci gl. Sinon j'ai remplacé mon deb_ligne par un tableau static (c'est vrai que ça servait à rien d'allouer dynamiquement un tableau d'une si petite taille). Voilà je vais aussi essayer d'utiliser moins de mémoire. Mais bon je ne sais toujours pas pourquoi celà c'est mis à marcher subitement car je vous jure que la seule chose que j'ai changée dans mon programme c'est la place de ces lignes. En tout cas un grand merci pour tout vos conseils.
29/11/2005, 23h58
Beush

Je tiens aussi à remercier Emmanuel dont je n'ais pas vu le message avant d'écrire le précédent. Je vais potasser un peu tout ce que tu m'as conseillé de changer et j'essaierais de l'appliquer dans mes programmes dorénavant.
30/11/2005, 19h30
gl

Citation:

Envoyé par Beush

Mais bon je ne sais toujours pas pourquoi celà c'est mis à marcher subitement car je vous jure que la seule chose que j'ai changée dans mon programme c'est la place de ces lignes.

C'est la caracteristique des comportements indetermines (debordement de tableaux ou autre) : tout peu arrive meme un fonctionnement en apparence normal.
Quand une modification du code "resout" un probleme sans aucune raison logique, c'est tout simplement que le probleme est encore la.