Administrace komentářů

Jste na stránce určené pro řešení chyb a problémů týkajících se diskusí a komentářů. Můžete zde našim administrátorům reportovat špatně zařazenou či duplicitní diskusi, vulgární či osočující příspěvek a podobně. Děkujeme vám za vaši pomoc, více očí více vidí, společně můžeme udržet vysokou kvalitu AbcLinuxu.cz.

Příspěvek

12.1.2014 20:11 tomes.io | skóre: 12 | blog: tomesh
Rozbalit Rozbalit vše Segfault pri strcpy v rekurzivni fci

Ahoj, prosim o pomoc s debugem fce, ktera rekurzivne monitoruje dany adresar:

void watch_dir(char *file) {
    int ret;
    struct stat buf;
    struct dirent *data;
	char *path = NULL;

    if (lstat(file, &buf))
        return;

    if (!S_ISDIR(buf.st_mode))
        return;

    DIR *dir = opendir(file);

    if (dir == NULL)
        return;

	//char *path2 = NULL;
	
    while ((data = readdir(dir)) != NULL) {
        if (strcmp(data->d_name, ".") == 0 ||
                strcmp(data->d_name, "..") == 0)
            continue;

        if (strstr(data->d_name, ".") == data->d_name)
            continue;

        path = (char *) malloc(strlen(file) + strlen(data->d_name) +1 * sizeof (path));
        asprintf(&path, "%s/%s", file, data->d_name);


        if (lstat(path, &buf))
            continue;
        //If it's a dir then launch watch_dir himself on it
        if (S_ISDIR(buf.st_mode))
            watch_dir(path);

        
    }

    closedir(dir);
    // now set watch for the argument of watch_dir
    ret = inotify_add_watch(inotify, file, IN_ALL_EVENTS);

    if (ret == -1) {
        printf("%s\n", file);
        perror("Error in watcher setting\n");
        exit(0);
    }

    strcpy(files[ret], file);
	free(path);
	path = NULL;

    return;
}

Valgrind hlasi:


==10177== Invalid write of size 1
==10177==    at 0x4A09350: strcpy (in /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so)
==10177==    by 0x4011C9: watch_dir (testclient1.c:147)
==10177==    by 0x401138: watch_dir (testclient1.c:132)
==10177==    by 0x401138: watch_dir (testclient1.c:132)
==10177==    by 0x401138: watch_dir (testclient1.c:132)
==10177==    by 0x401138: watch_dir (testclient1.c:132)
==10177==    by 0x401274: handle_event (testclient1.c:169)
==10177==    by 0x401945: main (testclient1.c:353)
==10177==  Address 0x704180 is not stack'd, malloc'd or (recently) free'd
==10177== 
==10177== 
==10177== Process terminating with default action of signal 11 (SIGSEGV)
==10177==  Access not within mapped region at address 0x704180
==10177==    at 0x4A09350: strcpy (in /usr/lib64/valgrind/vgpreload_memcheck-amd64-linux.so)
==10177==    by 0x4011C9: watch_dir (testclient1.c:147)
==10177==    by 0x401138: watch_dir (testclient1.c:132)
==10177==    by 0x401138: watch_dir (testclient1.c:132)
==10177==    by 0x401138: watch_dir (testclient1.c:132)
==10177==    by 0x401138: watch_dir (testclient1.c:132)
==10177==    by 0x401274: handle_event (testclient1.c:169)
==10177==    by 0x401945: main (testclient1.c:353)

Problem je tedy v nejake ctvrte rekurzi. Myslim, ze blbe mallocuju path, ktery se pridava do rekurzivniho volani. A pokud ho blbe nemallocuju, tak ho urcite blbe uvolnuji pomoci free. Chci vas poprosit o radu, jak to spravne osetrit.

Fce je soucasti klienta, ktery rekurzivne pomoci inotify monitoruje zadany adresar. Cely klient je zde:


int inotify;
char files[1024][1024];
struct inotify_event *event;
struct sockaddr_in serv_addr;
int sockfd;


/**
 * @brief Test if only a correct message is about to be sent
 * 
 * @param s
 * @return 
 */

int is_empty(const char *s) {

    char buff[1024];
    strcpy(buff,s);;
    
    buff[strlen(buff)] = '\0';

    if (buff[0] == '/' || isdigit(buff[0])){      
        return 1;
    }
   
    return 0;
}

/**
 * @brief Sends a message to the server.
 * 
 * @param message
 * @param portno
 */

void send_msg(char *message, int portno) {
    
    int n;
    char recvbuff[256];
    
    serv_addr.sin_port = htons(portno);
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    bzero(recvbuff, 256);

    if (sockfd < 0)
        perror("send_msg: ERROR opening socket");

    if (connect(sockfd, (struct sockaddr *) &serv_addr,
            sizeof (serv_addr)) < 0)
        perror("send msg: ERROR connecting");

    n = write(sockfd, message, strlen(message) +1);

    if (n < 0)
        perror("send msg: ERROR writing to socket");

    n = read(sockfd, recvbuff, 256);

    if (n < 0)
        perror(" send_msg: ERROR reading from socket");

    printf("%s\n", recvbuff);
    free(message);
	message = NULL;
    close(sockfd);
}

/**
 * @brief Recursively watches a directory.
 * 
 * @param file
 */

void watch_dir(char *file) {
    int ret;
    struct stat buf;
    struct dirent *data;
	char *path = NULL;

    if (lstat(file, &buf))
        return;

    if (!S_ISDIR(buf.st_mode))
        return;

    DIR *dir = opendir(file);

    if (dir == NULL)
        return;

	//char *path2 = NULL;
	
    while ((data = readdir(dir)) != NULL) {
        if (strcmp(data->d_name, ".") == 0 ||
                strcmp(data->d_name, "..") == 0)
            continue;

        if (strstr(data->d_name, ".") == data->d_name)
            continue;

        path = (char *) malloc(strlen(file) + strlen(data->d_name) +1 * sizeof (path));
        asprintf(&path, "%s/%s", file, data->d_name);


        if (lstat(path, &buf))
            continue;
        //If it's a dir then launch watch_dir himself on it
        if (S_ISDIR(buf.st_mode))
            watch_dir(path);

        
    }

    closedir(dir);
    // now set watch for the argument of watch_dir
    ret = inotify_add_watch(inotify, file, IN_ALL_EVENTS);

    if (ret == -1) {
        printf("%s\n", file);
        perror("Error in watcher setting\n");
        exit(0);
    }

    strcpy(files[ret], file);
	free(path);
	path = NULL;

    return;
}

/**
 * @brief Handles notified events.
 * 
 * @param path
 * @param dest
 */

void handle_event(char *path, char *dest, int portno) {
    
    char *message = (char *) malloc((strlen(path) * sizeof (message)) + 10);   

    if (event->mask & IN_CREATE) {
        if (event->mask & IN_ISDIR) {
            
            printf("The directory %s was created.\n", event->name);
            watch_dir(dest);
            
        } else {
            
            printf("The file %s was created.\n", event->name);
        }

        asprintf(&message, "%d:%d:%s", IN_CREATE,
                (int) strlen(dest), path);
        
        int j = is_empty(message);

        if (j == 1)
            send_msg(message, portno);
        
        //printf("")
    }

    else if (event->mask & IN_DELETE) {
        if (event->mask & IN_ISDIR) {
            
            printf("The directory %s was deleted.\n", event->name);
            
        } else {
            
            printf("The file %s was deleted.\n", event->name);
        }

        asprintf(&message, "%d:%d:%s", IN_DELETE,
                (int) strlen(dest), path);

        int j = is_empty(message);

        if (j == 1)
            send_msg(message, portno);
    }
    
    else 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.\n", event->name);
        }

        asprintf(&message, "%d:%d:%s", IN_MODIFY,
                (int) strlen(dest), path);

        int j = is_empty(message);

        if (j == 1)
            send_msg(message, portno);
    }

    else if (event->mask & IN_MOVED_FROM) {
        if (event->mask & IN_ISDIR) {

            printf("Directory %s with cookie %d has been "
                    "moved from the sync directory.\n",
                    event->name, event->cookie);
            
        } else {
            
            printf("Directory %s with cookie %d has been "
                    "moved from the sync directory.\n",
                    event->name, event->cookie);
        }

        asprintf(&message, "%d:%d:%s", IN_MOVED_FROM,
                (int) strlen(dest), path);
        
        int j = is_empty(message);

        if (j == 1)
            send_msg(message, portno);
    }
    else if (event->mask & IN_MOVED_TO) {
        if (event->mask & IN_ISDIR) {
            
            printf("Directory %s with cookie %d has been "
                    "moved to the sync directory.\n",
                    event->name, event->cookie);
			watch_dir(dest);
            
        } else {
            
            printf("Directory %s with cookie %d has been "
                    "moved to the sync directory.\n",
                    event->name, event->cookie);
        }

        asprintf(&message, "%d:%d:%s", IN_MOVED_TO,
                (int) strlen(dest), path);
        
        int j = is_empty(message);

        if (j == 1)
            send_msg(message, portno);
    }
    
    else {
		
		free(message);
		message = NULL;
	}
   
   free(path);
   path = NULL;
}

int main(int agrc, char *argv[]) {

    int portno, n;
    struct hostent *server;
    char buffer[4096];
    char *dest = malloc(strlen(argv[1]) + 1);

    strcpy(dest, argv[1]);
    inotify = inotify_init();

    if (!inotify) {
        perror("Open inotify device");
        fprintf(stderr, "Are you sure your kernel supports inotify?\n");
    }
    //launch recursive watching
    watch_dir(dest);
    printf("Start monitoring!\n");
    portno = atoi(argv[2]);
    server = gethostbyname("localhost");

    if (server == NULL) {
        fprintf(stderr, "ERROR, no such host\n");
        exit(0);
    }

    bzero((char *) &serv_addr, sizeof (serv_addr));
    serv_addr.sin_family = AF_INET;
    
    bcopy((char *) server->h_addr,
            (char *) &serv_addr.sin_addr.s_addr,
            server->h_length);

    /*First connection to the server. 
     * Client sends to a server a path 
     * to client's "dropbox" folder*/
    serv_addr.sin_port = htons(portno);
    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    if (connect(sockfd, (struct sockaddr *) &serv_addr,
            sizeof (serv_addr)) < 0)
        perror("ERROR connecting");

    n = write(sockfd, dest, strlen(dest) + 1);

    if (n < 0)
        perror("ERROR writing to socket");

    close(sockfd);

    while (1) {
        int ret;
        int i = 0;
        ret = read(inotify, buffer, 4096);

        if (ret < 0)
            perror("read");

        if (ret == 0)
            sleep(1);

		char *path = NULL; 
		
        while (i < ret) {
            char *name = NULL;
            event = (struct inotify_event *) &buffer[i];

            if (event->len)
                name = &buffer[i] + sizeof (struct inotify_event);
           
            path = (char *) malloc(1024 * sizeof (path));

            asprintf(&path, "%s/%s", files[event->wd], name);                     
            handle_event(path, dest, portno);           
            i += sizeof (struct inotify_event) +event->len;
			//free(path);
			//path = NULL;
			
        }
    }

    close(sockfd);
    return 0;
}

V tomto formuláři můžete formulovat svou stížnost ohledně příspěvku. Nejprve vyberte typ akce, kterou navrhujete provést s diskusí či příspěvkem. Potom do textového pole napište důvody, proč by měli admini provést vaši žádost, problém nemusí být patrný na první pohled. Odkaz na příspěvek bude přidán automaticky.

Offtopic diskuse použijte pro diskusi mimo záběr našeho portálu (včelařství, windows), která by měla být smazána.
Duplicitní diskuse je určena pro případ, kdy uživatel odeslal svůj dotaz několikrát.
Návrh na cenzuru použijte, pokud komentář obsahuje urážky, vulgarismy nebo porušuje zákony.
Návrh na smazání komentáře je velmi neobvyklá akce používaná obvykle při nepovolené reklamě či spamu, výkřicích psychicky nemocných jedinců (ještírci) nebo pro smazání duplikátních komentářů.
Oprava formátování je žádost pro úpravu formy příspěvku, například pokud někdo píše bez odstavců nebo použije PRE pro celý komentář. Žádosti o změnu obsahu budou zamítnuty.

Vaše jméno
Váš email
Typ požadavku

Slovní popis