* stack smashing detected *: <unknown> terminated

**Magnum8760** · 26/04/2019, 21h55

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 :

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
/**
* 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);
}

**edgarjacobs** · 27/04/2019, 00h50

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

**Médinoc** · 03/05/2019, 14h22

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

**Magnum8760** · 03/05/2019, 14h36

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

Code :

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

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 :

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

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...

**Magnum8760** · 03/05/2019, 14h42

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

Code :

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

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));

**Bousk** · 03/05/2019, 14h50

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

**Magnum8760** · 03/05/2019, 15h16

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 :

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

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 :

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
/**
* 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

**Médinoc** · 03/05/2019, 15h27

Ç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).

**Magnum8760** · 03/05/2019, 15h42

Oui, vous avez raison, j'obtient bien la même valeur à partir de celle que j'ai trouvé dans freeglut_std.h

Code :

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

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

**Magnum8760** · 03/05/2019, 16h05

voilà à quoi ressemble mon nouveau fichier.txt :

Code :

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

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 :

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
 
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).

**Médinoc** · 03/05/2019, 16h29

Vu que tu as inclu le préfixe, je crois que c'est plutôt %i qu'il faut utiliser, pas %d.

**pjlan** · 06/05/2019, 11h10

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].

**Bktero** · 07/05/2019, 09h19

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

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
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) ?

**Magnum8760** · 07/05/2019, 13h36

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 :

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
/**
* 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 :

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
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 :

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

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 :

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

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

**pjlan** · 07/05/2019, 13h55

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 :

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

int newFonction[50];

**Magnum8760** · 07/05/2019, 14h08

Code :

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

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.

**Magnum8760** · 07/05/2019, 14h14

Code :

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

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.

**pjlan** · 07/05/2019, 14h25

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.

**Magnum8760** · 07/05/2019, 15h46

Code :

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

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.