Erreur Dr. Memory

Version imprimable

Erreur Dr. Memory

Bonjour,

Je cherche à résoudre une erreur parmis tant d'autres, évaluées par Dr Memory.

Cette erreur ce repète plusieurs fois :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Error #4: UNINITIALIZED READ: reading register eax
# 0 UMEngx86.dll!?                           +0x0      (0x5b934266 <UMEngx86.dll+0x4266>)
# 1 KERNELBASE.dll!CreateMutexExW            +0x64     (0x77410f6f <KERNELBASE.dll+0x10f6f>)
# 2 KERNELBASE.dll!DebugBreak                +0x20d    (0x77413438 <KERNELBASE.dll+0x13438>)
# 3 KERNELBASE.dll!OutputDebugStringA        +0xb1     (0x7741354d <KERNELBASE.dll+0x1354d>)
# 4 msvcrt.dll!_invoke_watson
# 5 msvcrt.dll!fprintf   
# 6 file_open                                 [C:/Users/xxxx/Desktop/Code source/file.c:107]
# 7 __mingw_CRTStartup
# 8 ntdll.dll!RtlInitializeExceptionChain    +0x62     (0x77e69882 <ntdll.dll+0x39882>)
# 9 ntdll.dll!RtlInitializeExceptionChain    +0x35     (0x77e69855 <ntdll.dll+0x39855>)
Note: @0:00:05.318 in thread 8244
Note: instruction: movzx  0x04(%eax) -> %ecx

Voici la fonction et la ligne concernée par l'erreur susnommée :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
FILE *file_open(const char *path, const char *rights)
{
    FILE *pFile = NULL;
    if( path && rights )
    {
        errno=0;
        if ( ( !(pFile=fopen(path,rights))) )
            fprintf(logger,"\nfile.h::file_open --> The openning of the \"%s\" file has failed with rights \"%s\" [ERRNO:%s]", path, rights, strerror(errno));
    }
    else fprintf(logger,"\nfile.h::file_open --> At least, one of both arguments is NULL");
    return pFile;
}

Voici la bibliotheque de fonction pour logger, logger.h puis logger.c
logger est un FILE* déclaré en variable globale.
Je note que cette erreur est sytématique, toutes mes fonctions qui vont utiliser la variable logger dans un fprintf me génère l'erreur plus haut.

Code:

1
2
3
4
5
6
7
8
9
10
 
#ifndef LOGGER_H
#define LOGGER_H
 
FILE *logger;
 
void logger_on();
void logger_off();
void logger_read();
# endif

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
 
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
 
#include "file.h"
#include "ptrop.h"
#include "str.h"
#include "tim.h"
#include "logger.h"
 
 
void logger_on()
{
    remove("logger.txt");
    logger = NULL;
    logger = fopen("logger.txt","w");
}
 
void logger_off()
{
    if(logger)
        fclose(logger), logger = NULL;
}
 
void logger_read()
{
    char *log = NULL;
    if ( (log=file_to_string("logger.txt")) )
        if ( strcmp(log, "") != 0 )
        {
            printf("\n\n±±±±±±±±±±±±±±±±±±±±±±±±±±±±±");
            printf("\n±±         LOG FILE        ±±");
            printf("\n±±±±±±±±±±±±±±±±±±±±±±±±±±±±±\n");
            unsigned long long int i;
            for (i=0;i<str_length(log);i++)
            {
                printf("%c",log[i]);
                if(log[i]=='\n')
                    time_wait(0.25);
            }
            free(log);
            printf("\n±±±±±±±±±±±±±±±±±±±±±±±±±±±±±\n");
        }
        else remove(".\\logger.txt");
}

Voici le main :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
int main(int argc, char *argv[], char* env[])
{
    logger_on();
 
 
    binw_set_sz();
    t_uint64 sz = 0;
    t_binw *binw = NULL;
    if ( (binw=str_to_bin("test", &sz)) )
        binw_display_dyn(binw, sz, "test"), binw_destroy(binw);
 
    logger_off();
    logger_read();
    return 0;
}

S'il vous faut plus d'informations, merci de me les demander.
Si vous souhaitez le code source entier, je peux vous le faire parvenir.

Merci d'avance pour votre aide.
J'avoue que mes connaissances sont trop limitées pour comprendre ce qui ne va pas.

Citation:
Envoyé par darkwall_37
Bonjour,

Je cherche à résoudre une erreur parmis tant d'autres, évaluées par Dr Memory.

Cette erreur ce repète plusieurs fois :
Voici la fonction et la ligne concernée par l'erreur susnommée :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 FILE *file_open(const char *path, const char *rights) { FILE *pFile = NULL; if( path && rights ) { errno=0; if ( ( !(pFile=fopen(path,rights))) ) fprintf(logger,"\nfile.h::file_open --> The openning of the \"%s\" file has failed with rights \"%s\" [ERRNO:%s]", path, rights, strerror(errno)); } else fprintf(logger,"\nfile.h::file_open --> At least, one of both arguments is NULL"); return pFile; }
Bonjour

A priori, je dirais que logger n'a pas été ouvert quand tu cherches à écrire dedans. Un petit printf("%s\n", logger) ici permettrait de lever le doute...

Citation:

Envoyé par darkwall_37

logger est un FILE* déclaré en variable globale.

Ouais, super idée !!! Comme ça, on ne sait pas ni par qui ni quand il est modifié !!! :zen:
Citation:
Envoyé par darkwall_37
Code:

1 2 3 4 5 6 void logger_on() { remove("logger.txt"); logger = NULL; logger = fopen("logger.txt","w"); }
Et ça ne te choque pas d'écrire var=X puis var=Y juste en dessous ??? Ca ce n'est pas une question de connaissances mais de logique !!!
Citation:
Envoyé par darkwall_37
Code:

1 2 3 4 5 6 7 void logger_read() { char *log = NULL; if ( (log=file_to_string("logger.txt")) ) ... else remove(".\\logger.txt"); }
Ce serait utile aussi de vérifier que file_to_string() alloue bien la mémoire nécessaire au stockage de la chaine sinon comportement indéterminé => donc imprévisible donc qui peut faire planter ailleurs même si cet ailleurs est correct. Bon il y a un free() plus bas qui semble indiquer que c'est le cas. Mais faut alors vérifier que log n'est pas NULL...
Accessoirement je ne sais pas ce que fait "remove" ni si c'est une fonction de ton cru mais tu as "unlink()" qui fait partie de la bibliothèque standard qui sert à effacer les fichiers...

Réponse

Bonjour,

Merci pour ta réponse !
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 char *log = NULL; if ( (log=file_to_string("logger.txt")) ) if ( strcmp(log, "") != 0 ) { printf("\n\n±±±±±±±±±±±±±±±±±±±±±±±±±±±±±"); printf("\n±± LOG FILE ±±"); printf("\n±±±±±±±±±±±±±±±±±±±±±±±±±±±±±\n"); unsigned long long int i; for (i=0;i<str_length(log);i++) { printf("%c",log[i]); if(log[i]=='\n') time_wait(0.25); } free(log); printf("\n±±±±±±±±±±±±±±±±±±±±±±±±±±±±±\n"); } else remove(".\\logger.txt");
Pour la fonction file_to_string, si elle n'alloue pas la mémoire, elle renvoie NULL donc ça s'arrête là dans le pire des cas.
Par conséquent, je ne comprends pas pourquoi je dois tester une seconde fois log sachant que je suppose qu'il est alloué si la condition if en premier lieu est vérifiée.
Je ne sais pas si ça répond à ta question. (Je n'ai pas le code de la fonction sous la main at the moment).

Concernant, le var=X, var=Y, c'est une coquille, j'ai fais quelques modifs en oubliant d'en supprimer une partie quand je faisais quelques tests. Et donc oui si si ça me dérange :p My bad.
A force d'avoir le nez dedans, on finit par devenir aveugle. Pour ma défense, ce n'est ni du manque de logique, ni de connaissances, simplement de l'étourderie suite à ce que j'expliquais. Dans le fond, cela est absurde mais ce n'est ni faux ni générateur d'erreurs ?

Concernant la variable globale logger, effectivement, ce n'est pas de gaieté de cœur que j'utilise cette "solution". Simplement, vu le nombre de fonctions que j'ai et qui l'utilise, je me voyais mal la passer en argument partout, c'est ultra lourd. ( Oui c'est de la fainéantise à défaut d'avoir mieux). Je suis ouvert à toutes suggestions.

La fonction remove, elle, fait partie de windows.h.

Je ferais le test du rajout du printf effectivement pour m'assurer de cela lundi. (Je n'ai pas le code sous la main).
Il est vrai que je ne teste pas l'ouverture de fichier. Le minimum syndical étant que je fasse au moins pop un message dans le terminal et que le programme se coupe proprement. (100 % d'accord avec cette ignominie)

Merci pour ton retour et ton aide. En espérant que mes réponses aient un temps soit peu arrêté le saignement de tes yeux =)

08/11/2015, 08h32
Sve@r
Citation:

Envoyé par darkwall_37

Pour la fonction file_to_string, si elle n'alloue pas la mémoire, elle renvoie NULL donc ça s'arrête là dans le pire des cas.
Par conséquent, je ne comprends pas pourquoi je dois tester une seconde fois log sachant que je suppose qu'il est alloué si la condition if en premier lieu est vérifiée.
Je ne sais pas si ça répond à ta question. (Je n'ai pas le code de la fonction sous la main at the moment).

Oui c'est bon. Ce que je voulais dire, c'est qu'il fallait être certain que cette fonction fasse bien un malloc. Et effectivement si le malloc est fait et si son retour est renvoyé, alors ce que tu as écrit est suffisant pour savoir si le malloc a réussi ou pas.

Citation:

Envoyé par darkwall_37

Concernant la variable globale logger, effectivement, ce n'est pas de gaieté de cœur que j'utilise cette "solution". Simplement, vu le nombre de fonctions que j'ai et qui l'utilise, je me voyais mal la passer en argument partout, c'est ultra lourd. ( Oui c'est de la fainéantise à défaut d'avoir mieux). Je suis ouvert à toutes suggestions.

Si vraiment elle est utilisée de partout, effectivement le remède pourrait être pire. Il n'y a pas de "bonne solution". La globale c'est pas top, mais passer cette variable de partout c'est aussi pas top non plus.
Ou alors tu crées une structure "environnement". Par exemple
Code:

1 2 3 4 typedef struct { FILE *logger; ... (tous les autres trucs dont tu pourrais avoir besoin pour gérer ton environnement...) } t_env;
Et tu passes une variable de ce type "t_env" à toutes tes fonctions. Ce sera aussi lourd à écrire la première fois mais ensuite, toutes tes fonctions auront accès à l'environnement du programme (y compris à logger) et cet environnement pourra être modifié très facilement...

Citation:

Envoyé par darkwall_37

Il est vrai que je ne teste pas l'ouverture de fichier. Le minimum syndical étant que je fasse au moins pop un message dans le terminal et que le programme se coupe proprement. (100 % d'accord avec cette ignominie)

Euh on ne quitte jamais un code par une sous-fonction. Si le fichier n'est pas ouvert, tu gères soit en n'écrivant pas dedans, soit en remontant l'erreur à l'appelant qui gèrera lui-aussi et etc etc jusqu'au main...
08/11/2015, 11h17
darkwall_37

Merci pour ton retour,

Oui tout à fait, c'est bien ce que j'entendais par quitter le programme proprement =)
A mort le exit(-1) =)

Je teste ce que tu m'as gentilement proposé lundi et on sera fixé, enfin j'espère que ce sera aussi simple hihi

Re,

Du coup j'ai modfié logger.c de la sorte et plus particulièrement la fonction logger_on :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
 
#include "file.h"
#include "ptrop.h"
#include "str.h"
#include "tim.h"
#include "logger.h"
 
#define TRUE 1
#define FALSE 0
 
 
unsigned short logger_on()
{
    unsigned short status = TRUE;
    remove("logger.txt");
    logger = NULL;
    if (!(logger=fopen("logger.txt","w")))
        printf("\n ##ERROR WHILE STARTING THE LOGGING FUNCTION##"), status=FALSE;
 
    return status;
}
 
void logger_off()
{
    if(logger)
        fclose(logger), logger = NULL;
}
 
void logger_read()
{
    char *log = NULL;
    if ( (log=file_to_string("logger.txt")) )
        if ( strcmp(log, "") != 0 )
        {
            printf("\n\n±±±±±±±±±±±±±±±±±±±±±±±±±±±±±");
            printf("\n±±         LOG FILE        ±±");
            printf("\n±±±±±±±±±±±±±±±±±±±±±±±±±±±±±\n");
            unsigned long long int i;
            for (i=0;i<str_length(log);i++)
            {
                printf("%c",log[i]);
                if(log[i]=='\n')
                    time_wait(0.25);
            }
            free(log);
            printf("\n±±±±±±±±±±±±±±±±±±±±±±±±±±±±±\n");
        }
        else remove(".\\logger.txt");
}

Voici les modifications dans le main :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int main(int argc, char *argv[], char* env[])
{
    if (logger_on()==TRUE)
    {
        binw_set_sz();
        t_uint64 sz = 0;
        t_binw *binw = NULL;
        if ( (binw=str_to_bin("test", &sz)) )
            binw_display_dyn(binw, sz, "test"), binw_destroy(binw);
 
        logger_off();
        logger_read();
    }
    return 0;
}

J'ai rajouté le printf dans la fonction file_open comme conseillé :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
FILE *file_open(const char *path, const char *rights)
{
    FILE *pFile = NULL;
    if( path && rights )
    {
        errno=0;
        if ( ( !(pFile=fopen(path,rights))) )
        {
            printf("\nfile.h::file_open --> The openning of the \"%s\" file has failed with rights \"%s\" [ERRNO:%s]", path, rights, strerror(errno));
            fprintf(logger,"\nfile.h::file_open --> The openning of the \"%s\" file has failed with rights \"%s\" [ERRNO:%s]", path, rights, strerror(errno));
            printf("%s",logger);
        }
    }
    else fprintf(logger,"\nfile.h::file_open --> At least, one of both arguments is NULL");
    return pFile;
}

Ce que je constate et qui n'a pas changé suite aux modifications faites :
- Le fichier logger.txt se crée bien.
- Lorsque je mets un point d'arrêt sur le (l'un des nombreux en fait) fprintf qui génère l'erreur, le debugger ne s'arrête pas => Il n'entre jamais dans le if ce qui signifie que le fichier s'ouvre bien.
- La fonction binw_set_sz dans le main écris bien une ligne de contrôle dans le fichier logger et elle est bien affichée dans la console

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
test : 0000000000000000000000000000000000000000000000000000000001110100000000000
00000000000000000000000000000000000000000000000011100110000000000000000000000000
00000000000000000000000000000000110010100000000000000000000000000000000000000000
00000000000000001110100
 
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
▒▒         LOG FILE        ▒▒
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
bin.c::binw_set_sz -> The binary word size is 8 Byte(s) long
 
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
 
Process returned 0 (0x0)   execution time : 0.339 s
Press any key to continue.

Pas très concluant =(
Ce sont des erreurs UNINITIALIZED READ dans des registres ou des plages d'adresses. Pas sur de bien comprendre à 100% ce que Dr. Memory signifie par :

UNINITIALIZED READ: reading register ebx
UNINITIALIZED READ: reading 0x0028f710-0x0028f714 4 byte(s)
NINITIALIZED READ: reading 0x0028f77c-0x0028f784 8 byte(s) within 0x0028f77c-0x0028f78c

Voilà le petit compte rendu. Qu'en penses tu ?