Administrace komentářů

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

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

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