Wie behandeln “ * glibc detected * ./a: double-free oder Korruption (oben): "Fehler für Datei-handling-Funktion?

Habe ich nicht verwendet Dynamische Speicherzuweisung, und nicht freigeben von Speicher überall. Es Gaben sogar zu einem double-free-Fehler. Kann einer bitte mir helfen?

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/inotify.h>
#include <limits.h>

#define MAX_EVENTS 1024 /*Max. number of events to process at one go*/
#define LEN_NAME 16 /*Assuming that the length of the filename won't exceed 16 bytes*/
#define EVENT_SIZE  ( sizeof (struct inotify_event) ) /*size of one event*/
#define BUF_LEN     ( MAX_EVENTS * ( EVENT_SIZE + LEN_NAME )) /*buffer to store the data of events*/
#define SIZE 20000
int main( int argc, char **argv ) 
{
    int length, i = 0, wd;
    int fd;
    char buffer[BUF_LEN];

    time_t timer;
    char buffer2[25];
    char *s=NULL;
    struct tm* tm_info;

    FILE *fk;
    //char buffer[EVENT_BUF_LEN];
    char str1[] = "File has been updated at time :";
    time(&timer);
    tm_info = localtime(&timer);
    strftime(buffer2, 25, "%Y:%m:%d %H:%M:%S", tm_info);
    fk = fopen( "/home/technoworld/Desktop/file.txt" , "w" );

    /* Initialize Inotify*/
    fd = inotify_init();
    if ( fd < 0 ) {
        perror( "Couldn't initialize inotify");
    }

    /* add watch to starting directory */
    wd = inotify_add_watch(fd, argv[1], IN_MODIFY ); 

    if (wd == -1)
    {
        printf("Couldn't add listen to %s\n",argv[1]);
    }
    else
    {
        printf("Listening: %s\n",argv[1]);
    }

    /* do it forever*/
    while(1)
    {
        i = 0;
        length = read( fd, buffer, BUF_LEN );  

        if ( length < 0 ) {
            perror( "read" );
        }  

        while ( i < length ) {
            struct inotify_event *event = ( struct inotify_event * ) &buffer[ i ];
            if ( event->len ) {

                if ( event->mask & IN_MODIFY) {
                    if (event->mask & IN_ISDIR)
                        printf( "The directory %s was modified.\n", event->name );       
                    else
                    {
                        printf( "The file %s was modified at %s \n", event->name, buffer2 ); 
                        fprintf(fk,"%s %s %c",str1, buffer2, '\n');
                    }
                }

                i += EVENT_SIZE + event->len;
            }
        }
        fcloseall(fk);
    }

    /* Clean up*/
    inotify_rm_watch( fd, wd );
    close( fd );

    return 0;
}

Ich versuche mich zu hören das ändern, in Datei schreiben und die änderung in der log-Datei mit Zeitstempel.

Fehler:

Listening: /home/technoworld/Desktop/tmp/
The file .goutputstream-L3JTXW was modified at 2013:05:24 22:06:21 
The file .goutputstream-IRR4XW was modified at 2013:05:24 22:06:21 
*** glibc detected *** ./a: double free or corruption (fasttop): 0x09438008 ***
======= Backtrace: =========
/lib/i386-linux-gnu/libc.so.6(+0x75ee2)[0xb7624ee2]
./a[0x80488bb]
/lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf3)[0xb75c84d3]
./a[0x80485c1]
======= Memory map: ========
08048000-08049000 r-xp 00000000 07:00 558766     /home/technoworld/Desktop/a
08049000-0804a000 r--p 00000000 07:00 558766     /home/technoworld/Desktop/a
0804a000-0804b000 rw-p 00001000 07:00 558766     /home/technoworld/Desktop/a
09438000-09459000 rw-p 00000000 00:00 0          [heap]
b7578000-b7594000 r-xp 00000000 07:00 394123     /lib/i386-linux-gnu/libgcc_s.so.1
b7594000-b7595000 r--p 0001b000 07:00 394123     /lib/i386-linux-gnu/libgcc_s.so.1
b7595000-b7596000 rw-p 0001c000 07:00 394123     /lib/i386-linux-gnu/libgcc_s.so.1
b75ae000-b75af000 rw-p 00000000 00:00 0 
b75af000-b7752000 r-xp 00000000 07:00 394098     /lib/i386-linux-gnu/libc-2.15.so
b7752000-b7753000 ---p 001a3000 07:00 394098     /lib/i386-linux-gnu/libc-2.15.so
b7753000-b7755000 r--p 001a3000 07:00 394098     /lib/i386-linux-gnu/libc-2.15.so
b7755000-b7756000 rw-p 001a5000 07:00 394098     /lib/i386-linux-gnu/libc-2.15.so
b7756000-b7759000 rw-p 00000000 00:00 0 
b776e000-b7773000 rw-p 00000000 00:00 0 
b7773000-b7774000 r-xp 00000000 00:00 0          [vdso]
b7774000-b7794000 r-xp 00000000 07:00 394076     /lib/i386-linux-gnu/ld-2.15.so
b7794000-b7795000 r--p 0001f000 07:00 394076     /lib/i386-linux-gnu/ld-2.15.so
b7795000-b7796000 rw-p 00020000 07:00 394076     /lib/i386-linux-gnu/ld-2.15.so
bfe5d000-bfe7e000 rw-p 00000000 00:00 0          [stack]
Aborted (core dumped)

Versuchen Sie, um zu überprüfen, ob fk wird geöffnet.
Wenn ich schreiben fclose(fk) direkt nach der while (), dann ist es keine Fehler geben. Im Fall Schreibe ich es mit close(fd) dann funktioniert Es aber doent schreiben auf Datei!
Ja, sir. Es schreibt in die Datei ein mal und wenn nächste mal die Datei geändert wird, dann gibt es Fehler!

InformationsquelleAutor | 2013-05-25

c memory-management

1

fcloseall keine Argumente. (Wie haben Sie diese selbst kompilieren?)

Auch wenn die ersten fopen erfolgreich ist (so dass fk ist nicht NULL), nach der ersten Reise durch die while (1) Schleife, die Sie genannt haben fcloseall und damit die Datei geschlossen. Die fprintf zu fk damit ist Druck auf eine geschlossene Datei. Da die Datei-Operationen zuordnen und verwenden Speicher, und schließen Operationen frei, die das Gedächtnis, Sie sind daher mit freigegebenen Speicher, daher der glibc Fehler.
- Abhängig von den Optionen zur Kompilierzeit, die falschen Aufruf fcloseall() würde kompilierbar sein, da es eine implizite Deklaration der int fcloseall(). Feature-Makros konfiguriert werden, damit stdio.h zu ermöglichen, einen Prototyp für int fcloseall(void);
- Tatsache, dass Sie drängen ein parameter auf dem stack, wo die Funktion sich nicht nehmen, eine wird nicht die Ursache der segfault. AUCH er ist nicht der Definition _GNU_SOURCE so fcloseall() wird nicht einmal erklärt wird, unabhängig von der Tatsache, dass er darunter stdio.h; auch mit, dass erklärt die SIGSEG wird nicht verschwinden
- Können Sie bitte vorschlagen wo soll ich fclose(fk)??
- Ich legte fclose(fk) nach der while (1) dann hat es keine Fehler geben auf geben Sie die korrekte Ausgabe im terminal. Aber es schreibt nicht auf die Datei.
- Die Ausgabe in die Datei gepuffert ist. Hinzufügen: fflush(fk); nach der fprintf Anruf zu drücken Sie die gepufferten Daten in die Datei. (Andernfalls werden die Daten angezeigt, wenn Sie füllen einen "block"—diese Größe hängt von der Datei-system—oder beim verlassen des while (1) Schleife, je nachdem, was zuerst Eintritt. Da es keine Ausfahrt aus der Schleife, werden Sie warten, einen vollen block.)
- Übrigens, die innere Schleife, mit i < length wie seine Kontrolle, Fortschritte i wenn und nur wenn event->len ungleich null ist. Sollten Sie auf ein Ereignis mit einer null len, dass die Schleife stecken. Vermutlich i += EVENT_SIZE + event->len sollte außerhalb der if (event->len) test.
- Ich versuchte zu verwenden, befreit den Speicher. Setzen fclose(fk) nach Gebrauch zu fk abgeschlossen ist gelöst der Fehler!
InformationsquelleAutor torek
0

Das problem ist da, weil Sie arbeiten auf einem 64-bit system, und Sie sind nicht inklusive time.h und der Typ des Rückgabewert von localtime(&timer) wird interpretiert als 32-bit integer anstatt einer 64-bit-Zeiger (nicht deklarierten Typen default-int") ... Sie verlieren die Informationen, die implizite Deklaration.

Lackmus-test, um zu sehen, ob ich Recht habe:

deklarieren Sie die folgenden Rechte unter der umfasst:
```
#include <limits.h>
struct tm;
struct timep;
struct tm *localtime(const time_t *timep);
```
den SIGSEG verschwinden (obwohl dein code ist immer noch buggy)

Die richtige Sache zu tun ist, um #include <time.h>
- Ich habe die Zeit.h, aber keine Veränderung!
InformationsquelleAutor Ahmed Masud

Ich fclose(fk) nach der while(1) abgeschlossen ist. Es gibt keine Fehler und funktioniert einwandfrei auf dem terminal. Aber in diesem Fall nicht schreiben file.txt.

Code:

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/inotify.h>
#include <limits.h>
#include <time.h>

#define MAX_EVENTS 1024 /*Max. number of events to process at one go*/
#define LEN_NAME 16 /*Assuming that the length of the filename won't exceed 16 bytes*/
#define EVENT_SIZE  ( sizeof (struct inotify_event) ) /*size of one event*/
#define BUF_LEN     ( MAX_EVENTS * ( EVENT_SIZE + LEN_NAME )) /*buffer to store the data of events*/
#define SIZE 20000
int main( int argc, char **argv ) 
{
  int length, i = 0, wd;
  int fd;
  char buffer[BUF_LEN];


    time_t timer;
    char buffer2[25];
    char *s=NULL;
    struct tm* tm_info;

  FILE *fk;
  //char buffer[EVENT_BUF_LEN];
  char str1[] = "File has been updated at time :";
    time(&timer);
    tm_info = localtime(&timer);
    strftime(buffer2, 25, "%Y:%m:%d %H:%M:%S", tm_info);
   fk = fopen( "/home/technoworld/Desktop/file.txt" , "w" );



  /* Initialize Inotify*/
  fd = inotify_init();
  if ( fd < 0 ) {
    perror( "Couldn't initialize inotify");
  }

  /* add watch to starting directory */
  wd = inotify_add_watch(fd, argv[1], IN_MODIFY ); 

  if (wd == -1)
    {
      printf("Couldn't add listen to %s\n",argv[1]);
    }
  else
    {
      printf("Listening: %s\n",argv[1]);
    }

  /* do it forever*/
  while(1)
    {
      i = 0;
      length = read( fd, buffer, BUF_LEN );  

      if ( length < 0 ) {
        perror( "read" );
      }  

      while ( i < length ) {
        struct inotify_event *event = ( struct inotify_event * ) &buffer[ i ];
        if ( event->len ) {

          if ( event->mask & IN_MODIFY) {
            if (event->mask & IN_ISDIR)
              printf( "The directory %s was modified.\n", event->name );       
            else
        {
                    printf( "The file %s was modified at %s \n", event->name, buffer2 ); 
                    fprintf(fk,"%s %s %c",str1, buffer2, '\n');
        }
          }

            i += EVENT_SIZE + event->len;
        }
      }

    }
fclose(fk);
  /* Clean up*/
  inotify_rm_watch( fd, wd );
  close( fd );

  return 0;
}

InformationsquelleAutor

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.