* stack smashing detected *: <unknown> terminated

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour, gcc m'indique *** stack smashing detected ***: <unknown> terminated avec cette fonction.
J'alloue surement pas assez de mémoire pour ma variable newFunction mais je ne vois pas comment améliorer tout ça (à cet heure) :).

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
/**
* affichage des informations de l'écran GL.
* @param chemin du fichier.csv
*/
void windowFunction(char* sourcesPath){
			int val;
			char *newFunction = NULL;
			char 	argument[40],
			 	description[100];
			FILE *file = NULL;
	                file = fopen(sourcesPath, "r"); /* read file */
	                if (file == NULL) 
                                 exit(1);
			else {
				do{
				fscanf(file, "%s %s", argument, description);
							newFunction = (char*)malloc(sizeof(char));
							//strcpy(newFunction, argument);
							printf("salut la new funct est %s \n", newFunction);
							sprintf(newFunction, "%s", argument);
							val = glutGet(newFunction);
							printf("%d\n", val);
				}while(!feof(file)); // tester la fin d'un fichier*/
				fclose(file); /* fermer un fichier ouvert */
			}
                        free(newFunction);
}

27/04/2019, 00h50
edgarjacobs

Hello,

Ligne 17: tu alloues 1 octet pour newFuction, que tu n'initialises pas.
Ligne 19: tu fais un printf() de newFunction, mais il n'y a peut-être de pas de \0 dans le string
Ligne 20: il n'y a sans doute pas assez de place pour copier argument dans newFunction
03/05/2019, 14h22
Médinoc

Aussi, es-tu 100% sûr que les lignes de ton fichier en dépassent pas les 40 et 100 caractères?

Bonjour, voici quelques une des lignes de mon fichiers. Les fonctions ne dépasse pas les 40 caractères enfin max 30 :
Code:

1 2 3 4 GLUT_WINDOW_ACCUM_RED_SIZE Number_of_bits_of_red_stored_in_the_current_window's_accumulation_buffer._Zero_if_the_window_is_color_index GLUT_WINDOW_ACCUM_GREEN_SIZE Number_of_bits_of_green_stored_in_the_current_window's_accumulation_buffer._Zero_if_the_window_is_color_index GLUT_WINDOW_ACCUM_BLUE_SIZE Number_of_bits_of_blue_stored_in_the_current_window's_accumulation_buffer._Zero_if_the_window_is_color_index GLUT_WINDOW_ACCUM_ALPHA_SIZE Number_of_bits_of_alpha_stored_in_the_current_window's_accumulation_buffer._Zero_if_the_window_is_color_index
J'avais complètement oublié cette partie. En fait, j'avais pas très bien compris pourquoi disais t'on que j'allouais seulement un octet ici :
Code:

1 2 3 char *newFunction = NULL; ... newFunction = (char*)malloc(sizeof(char));
J'initialise bien à NULL un pointeur vers un tableau de futur caractères.

Ok ok j'alloue à la taille d'un char, 1 mot, 1 octet ... mais je ne sais pas comment m'y prendre pour allouer à la bonne taille...

Je ne serrais pas le faire pour le moment mais je vais essayer ceci tout à l'heure
Code:

1 2 3 4 5 6 7 8 #define MAX 200 char *newFunction = NULL; ... char argument[MAX], description[MAX]; ... newFunction = (char*)malloc(MAX * sizeof(char));

03/05/2019, 14h50
Bousk

Pourquoi newFunction aurait besoin d'une allocation dynamique, à fortiori de taille fixe, quand description et argument sont statiques ? :calim2:

J'aimerais afficher toutes les valeurs d'une fonction glutGet qui prend en argument le premier string de chaque ligne d'un fichier glutGet.txt qui se présente comme tel :

Code:

1
2
3
4
5
GLUT_SCREEN_WIDTH Width_in_pixels_of_the_current_window
GLUT_SCREEN_HEIGHT1 Height_in_pixels_of_the_current_window
GLUT_WINDOW_X X_location_in_pixels_(relative_to_the_screen_origin)_of_the_current_window
GLUT_WINDOW_Y Y_location_in_pixels_(relative_to_the_screen_origin)_of_the_current_window
....

# à chaque fois deux string séparé d'un espace.

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
/**
* affichage des informations de l'écran GL.
* @param chemin du fichier.csv
*/
void windowFunction(char* sourcesPath){
			int val, argumentLen;
			char *newFunction = NULL;
			char 	argument[50],
			 	description[1000];
			FILE *file = NULL;
	    file = fopen(sourcesPath, "r"); /* read file */
	    if (file == NULL){
				   exit(1);
			}
			else {
				do{
				fscanf(file, "%s %s", argument, description);
							argumentLen = strlen(argument) + 1;
							newFunction = (char*)malloc(argumentLen * sizeof(char));
							//strcpy(newFunction, argument);
							printf("salut la new funct est %s \n", newFunction);
							sprintf(newFunction, "%s", argument);
							val = glutGet(newFunction);
							printf("%d\n", val);
				}while(!feof(file)); // tester la fin d'un fichier*/
				fclose(file); /* fermer un fichier ouvert */
			}
      free(newFunction);
}

Ici j'ai gardé le malloc mais j'ai ajouté strlen(argument) + 1 pour la ligne en cours de lecture

03/05/2019, 15h27
Médinoc

Ça ne marchera pas, GLEnum est un type entier, ce n'est pas supposé être une chaîne de caractères.
Si tu veux pouvoir appeler glutGet sur une valeur lue depuis un fichier texte, tu dois d'abord récupérer la valeur entière associée à cette chaîne.

Et pour ça, il faudra que tu te constitues un dictionnaire (tu dois pouvoir récupérer les associations entre chaîne et nombre en examinant le fichier d'en-tête contenant GLUT_WINDOW_X, ou en contournant le problème).
03/05/2019, 15h42
Magnum8760
Oui, vous avez raison, j'obtient bien la même valeur à partir de celle que j'ai trouvé dans freeglut_std.h
Code:

1 2 3 4 int val = glutGet(GLUT_WINDOW_X); printf("%d", val); int val2 = glutGet(0x0064); printf("%d", val2);

voilà à quoi ressemble mon nouveau fichier.txt :

Code:

1
2
3
4
5
0x0066 GLUT_SCREEN_WIDTH Width_in_pixels_of_the_current_window
0x00C9 GLUT_SCREEN_HEIGHT Height_in_pixels_of_the_current_window
0x0064 GLUT_WINDOW_X X_location_in_pixels_(relative_to_the_screen_origin)_of_the_current_window
0x0065 GLUT_WINDOW_Y Y_location_in_pixels_(relative_to_the_screen_origin)_of_the_current_window
...

et la fonction :

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
 
void windowFunction(char* sourcesPath){
			int val;
			int glenum = NULL;
			//char *newFunction = NULL;
			char 	argument[50],
			 	description[1000];
			FILE *file = NULL;
	    file = fopen(sourcesPath, "r"); /* read file */
	    if (file == NULL){
				   exit(1);
			}
			else {
				do{
							fscanf(file, "%d %s %s",glenum, argument, description);
							//argumentLen = strlen(argument) + 1;
							//newFunction = (char*)malloc(argumentLen * sizeof(char));
							//strcpy(newFunction, argument);
							//printf("salut la new funct est %s \n", newFunction);
							//sprintf(newFunction, "%s", argument);
							val = glutGet(glenum);
							printf("%d\n", val);
				}while(!feof(file)); // tester la fin d'un fichier*/
				fclose(file); /* fermer un fichier ouvert */
			}
      free(newFunction);
}

Voici le message d'erreur que j'ai : Erreur de segmentation (core dumped).

03/05/2019, 16h29
Médinoc

Vu que tu as inclu le préfixe, je crois que c'est plutôt %i qu'il faut utiliser, pas %d.
06/05/2019, 11h10
pjlan

initialisation de l'entier

Tu initialise ton entier à NULL normalement cette constante (qui vaut en principe 0) n'est à utiliser que pour les pointeurs.
De plus dans ton appel à fscanf tu as oublié de donner une adresse (il manque le '&') pour les chaines de caractéres ce n'est pas nécessaire
car le nom d'un tableau (ici de caractéres) est implicitement equivalent a &tab[0].

Déjà, en indentant le code, c'est bien plus joli à regarder et facile à comprendre :

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
#include <stdlib.h>
#include <stdio.h>
 
void windowFunction(char* sourcesPath){
	int val;
	int glenum = NULL;
	//char *newFunction = NULL;
	char 	argument[50],
	description[1000];
	FILE *file = NULL;
	file = fopen(sourcesPath, "r"); /* read file */
 
	if (file == NULL){
		exit(1);
	}
	else {
		do{
			fscanf(file, "%d %s %s",glenum, argument, description);
			//argumentLen = strlen(argument) + 1;
			//newFunction = (char*)malloc(argumentLen * sizeof(char));
			//strcpy(newFunction, argument);
			//printf("salut la new funct est %s \n", newFunction);
			//sprintf(newFunction, "%s", argument);
			val = glutGet(glenum);
			printf("%d\n", val);
		}while(!feof(file)); // tester la fin d'un fichier*/
 
		fclose(file); /* fermer un fichier ouvert */
	}
 
	free(newFunction);
}

Ensuite, ce code ne compile pas correctement :

prog.cc: In function 'void windowFunction(char*)':
prog.cc:6:15: warning: converting to non-pointer type 'int' from NULL [-Wconversion-null]
    6 |  int glenum = NULL;
      |               ^~~~
prog.cc:18:19: warning: format '%d' expects argument of type 'int*', but argument 3 has type 'int' [-Wformat=]
   18 |    fscanf(file, "%d %s %s",glenum, argument, description);
      |                  ~^        ~~~~~~
      |                   |        |
      |                   int*     int
prog.cc:24:10: error: 'glutGet' was not declared in this scope
   24 |    val = glutGet(glenum);
      |          ^~~~~~~
prog.cc:31:7: error: 'newFunction' was not declared in this scope; did you mean 'windowFunction'?
   31 |  free(newFunction);
      |       ^~~~~~~~~~~
      |       windowFunction
1

Evidemment, l'erreur pour gluGet() se règle avec une déclaration au début de mon fichier (int glutGet(int);) mais quid de newFunction ?

As-tu bien activé les options de warning de ton compilateur (-Wall -Wextra pour GCC par exemple) ?

Merci je ne connaissais pas le flag -Wextra. Je l'ai ajouté à mon makefile mais mis à part quelques variables inutilisées (forcément je travaille dessus), ça n'as pas fait grand chose.

La fonction dans mon fichier main.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
/**
* affichage des informations de l'écran GL.
* @param chemin du fichier.csv
* @return les valeurs de la fonction glutGet.
* @Discussion https://www.developpez.net/forums/d1967023/c-cpp/c/stack-smashing-detected-unknown-terminated/#post10919586
*/
void windowFunction(char* sourcesPath){
			int i = 0;
			int val;
			int* newFunction = NULL;
			newFunction = (int*)malloc(50 * sizeof(int));
			char 	argument[50],
			 	description[1000];
			FILE *file = NULL;
	    file = fopen(sourcesPath, "r"); /* read file */
	    if (file == NULL){
				   exit(1);
			}
			else {
				do{
							fscanf(file, "%d %s %s",&newFunction[i], argument, description);
							val = glutGet(newFunction[i]);
							printf("%i\n", val);
							i++;
				}while(!feof(file)); // tester la fin d'un fichier*/
				fclose(file); /* fermer un fichier ouvert */
			}
      free(newFunction);
}

Fonction appelée dans la fonction main :

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
int main(int argc, char** argv) {
		//char newPlayer;
    int jeu_lance = NON;
    printf("Bonjour, voulez vous lancez le jeu ? ");
    scanf("%d", &jeu_lance);
    if(jeu_lance == OUI)
    {
	printf("Quel est votre nom de player ? ");
	scanf("%s", player);

	glutInit(&argc, argv); /* initialisation de GLUT : argc et argv sont respectivement
          * le nombre et la liste des paramètres passées en ligne de commande */

          glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
          glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);

          /* Creer un écran centré */
          unsigned int Largeur_Ecran_x = glutGet(GLUT_SCREEN_WIDTH);
          unsigned int Hauteur_Ecran_Y = glutGet(GLUT_SCREEN_HEIGHT);
          unsigned int position_centree_X = (Largeur_Ecran_x-WINDOW_WIDTH)/2;
          unsigned int position_centree_Y = (Hauteur_Ecran_Y-WINDOW_HEIGHT)/2;
          glutInitWindowPosition(position_centree_X, position_centree_Y); /* Position d'initialisation en haut à gauche du coin de mon écran. */

      	  glutCreateWindow("JUMPING_BANANA_JACQUETS_Prog2_IHDCB132"); /* créer la fenètre */

					//re_move("data/test.test");
					//readByCharacter("data/glutGet.txt");

	windowFunction("data/glutGet.txt") ;

				//int val = glutGet(GLUT_WINDOW_X);
				//printf("%d", val);
				//int val2 = glutGet(0x0064);
				//printf("%d", val2);

					// mode 2D avec glOrtho2D puis desactiver l'ecriture en ZBuffer
          init();
					/* créer les rendus */
          glutReshapeFunc(reshape);  /* précise la fonction à utiliser pour le redimensionnement */
          glutDisplayFunc(display); /* précise la fonction à utiliser pour l'affichage */
          glutIdleFunc(display);

          glutTimerFunc(TIMER, timer, 0);
          glutTimerFunc(LONG_TIMER, longTimer, 0);
          glutTimerFunc(SCORE_TIMER, longerTimer, 0);
          glutTimerFunc(ENNEMI_POP_TIMER, ennemyTimer, 0);

					/* lancer le programme à l'infini puis attendre les instructions de l'utilisateur */
          glutKeyboardFunc(keyboard);
          glutKeyboardUpFunc(keyboardUp);

          glutSpecialFunc(specialInput);
          glutSpecialUpFunc(specialInputUp);

          glutMainLoop();

	clearEndGame();
    return 0;
    }
}

le fichier glutGet.txt :

Code:

1
2
3
4
5
0x0066 GLUT_SCREEN_WIDTH Width_in_pixels_of_the_current_window
0x00C9 GLUT_SCREEN_HEIGHT Height_in_pixels_of_the_current_window
0x0064 GLUT_WINDOW_X X_location_in_pixels_(relative_to_the_screen_origin)_of_the_current_window
0x0065 GLUT_WINDOW_Y Y_location_in_pixels_(relative_to_the_screen_origin)_of_the_current_window
....

Utilisation de make avec CFLAGS = -std=c99 -lglut -lGL -lGLU -lpng -Wall -Wextra -g
Le message d'erreur est le suivant :

Code:

1
2
3
freeglut (./jb): glutGet(): missing enum handle 0
-1
Erreur de segmentation (core dumped)

Je présume qu'en le plaçant à l'heure de maintenant dans la main; ça fait planter le programme. Malheureusement, cette fonction ne m'est plus trop utile pour le moment. J'en avait besoin au début que je construisais mon jeux mais l'échéance est dans une semaine donc je vais me concentrer sur autre chose. Si vous constatez une erreur qui m'as échappée. N'hésitez pas à me le signaler. Merci d'avance

07/05/2019, 13h55
pjlan

Pour lire des valeurs hexadécimales il faut utiliser '%x' par contre je ne me souvient plus s'il faut enlever dans ton fichier texte le 0x en préfixe mais c'est bien possible.
Il y a sans doute d'autre problèmes vu qu'il y a une erreur de segmentation mais tu peux commencer par ça.
Ta variable newFonction n'a pas besoin d'être alloué dynamiquement vu que tu connais la taille à l'exécution.
Utilises plutôt

Code:

int newFonction[50];
07/05/2019, 14h08
Magnum8760
Code:

1 2 -1 freeglut (./jb): glutGet(): missing enum handle 6449711
Merci de ta réponse, l'erreur de segmentation vient de cette fonction. Avec %x, je constate que le valeur après missing enum handle est différente de 0.
07/05/2019, 14h14
Magnum8760
Code:

1 2 3 4 -1 freeglut (./jb): glutGet(): missing enum handle 6449711 ... Erreur de segmentation (core dumped)
Même chose lorsque j'enlève tous les 0x devant puis que je remplace par %x.
07/05/2019, 14h25
pjlan

Ton programme ne fait rien du tout et plante directe ?

PS : peux-tu afficher newFunction[i] en hexa (avec '%x') avant l'appel à gluget s'il te plait.
07/05/2019, 15h46
Magnum8760
Code:

1 2 3 4 int val = glutGet(GLUT_WINDOW_X); printf("%d", val); int val2 = glutGet(0x0064); printf("%d", val2);
la réponse est 183 pixels pour les deux.

Le programme fonctionne très bien sans cette fonction. Bon tant pis, je reviendrais dessus plus tard.

Merci, ce topic ext résolu bien que je ne comprend pas ce qui cloche avec cette fonction.

En fait, cela fonctionne avec %d et %x, avec ou sans 0x. :D
07/05/2019, 21h02
Bousk

Si tu lis un 0x154 avec %d, tu liras un joli 0. x n'est pas un chiffre.

Citation:

Ta variable newFonction n'a pas besoin d'être alloué dynamiquement vu que tu connais la taille à l'exécution.

newFunction n'a même pas lieu d'être un tableau tout court. L'entrée i est utilisée une unique fois dans la boucle.

Voir 40 message(s) de cette discussion en une page