lab2

#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <errno.h>
#include <time.h>

// Найти совпадающие по содержимому (сравнить побайтно) файлы в двух заданных каталогах
// (аргументы 1 и 2 командной строки) и всех их подкаталогах. Вывести на консоль и в файл
// (аргумент 3 командной строки) полный путь, размер, дату создания, права доступа, номер индексного дескриптора
// и размер файла.

const int strSize = 512;
char *dir1;
char *dir2;
char *execFileName;
char *outputFilePath;
char *outputBuffer;
const int outputBufferLength = 80;
int outputBufferIndex = 0;

void findFiles(char *, void(*callback)(char *, char *), char *);

int checkPointer(void *pointer, char *filePath, int closeProg) {
    if(pointer == NULL) {
        fprintf(stderr, "%s: %s: %s\n", execFileName, filePath, strerror(errno));
        if(closeProg) exit(errno);
        return 1;
    }
    return 0;
}

int contains(char **arr, int arrLength, char *str) {
    for (int i = 0; i < arrLength; i++) {
        if (arr[i] != NULL && strcmp(arr[i], str) == 0) return 1;
    }

    return 0;
}

void addToBlacklist(char *path) {
    static char **blacklist = NULL;
    static int blacklistIndex = 0;
    int blacklistLength = 1000;

    if (blacklist == NULL) blacklist = calloc(blacklistLength, strSize);

    if (!contains(blacklist, blacklistLength, path)) {
        blacklist[blacklistIndex] = malloc(strSize);

        if(checkPointer(blacklist[blacklistIndex], path, 0)) return;

        strcpy(blacklist[blacklistIndex], path);
        blacklistIndex = (blacklistIndex + 1) % blacklistLength;
        fprintf(stderr, "%s: %s: %s\n", execFileName, path, strerror(errno));
    }
}

struct stat getFileInfo(FILE *file) {
    struct stat buf;
    fstat(fileno(file), &buf);
    return buf;
}

char *getDate(time_t unixDate) {
    struct tm *tm = localtime(&unixDate);
    char *date = calloc(1, strSize);
    if(checkPointer(date, execFileName, 0)) return "";
    strftime(date, strSize, "%Y-%m-%d %H:%M:%S", tm);
    return date;
}

void printOutputBuffer() {
    FILE *file = fopen(outputFilePath, "a");

    if(file == NULL) {
        fprintf(stderr, "%s: %s: %s\n", execFileName, outputFilePath, strerror(errno));
    } else {
        fprintf(file, "%s", outputBuffer);
        if(fclose(file) != 0) {
            fprintf(stderr, "%s: %s: %s\n", execFileName, outputFilePath, strerror(errno));
        }
    }

    printf("%s", outputBuffer);
    outputBufferIndex = 0;
    free(outputBuffer);
    outputBuffer = calloc(outputBufferLength, strSize);
    checkPointer(outputBuffer, execFileName, 1);
}

void closeFiles(FILE *file1, FILE *file2, char *filePath1, char *filePath2) {
    if (file1 != NULL && fclose(file1) != 0) {
        fprintf(stderr, "%s: %s: %s\n", execFileName, filePath1, strerror(errno));
    }

    if (file2 != NULL && fclose(file2) != 0) {
        fprintf(stderr, "%s: %s: %s\n", execFileName, filePath2, strerror(errno));
    }
}

int filesEqual(FILE *file1, FILE *file2, char *filePath1, char *filePath2) {
    const int bufferSize = 1024 * 1024 * 50; // 50 mb
    char *buffer1 = calloc(1, bufferSize);
    char *buffer2 = calloc(1, bufferSize);
    unsigned long occupiedBytes1 = 0;
    unsigned long occupiedBytes2 = 0;

    if(checkPointer(buffer1, filePath1, 0) || checkPointer(buffer2, filePath2, 0)) return 0;

    while(1) {
        occupiedBytes1 += fread(buffer1, sizeof(char), bufferSize, file1);
        occupiedBytes2 += fread(buffer2, sizeof(char), bufferSize, file2);

        if(occupiedBytes1 != occupiedBytes2) {
            free(buffer1);
            free(buffer2);
            return 0;
        }

        if(occupiedBytes1 == bufferSize || feof(file1) != 0 && feof(file2) != 0) {
            if(memcmp(buffer1, buffer2, bufferSize) == 0) {
                free(buffer1);
                free(buffer2);

                if(feof(file1) != 0 && feof(file2) != 0) return 1;

                buffer1 = calloc(1, bufferSize);
                buffer2 = calloc(1, bufferSize);
                if(checkPointer(buffer1, filePath1, 0) || checkPointer(buffer2, filePath2, 0)) return 0;
            } else {
                free(buffer1);
                free(buffer2);
                return 0;
            }
        }
    }
}

void handleFile2(char *filePath1, char *filePath2) {
    FILE *file1 = fopen(filePath1, "rb");
    FILE *file2 = fopen(filePath2, "rb");

    if(file1 == NULL) addToBlacklist(filePath1);
    if(file2 == NULL) addToBlacklist(filePath2);

    if (file1 == NULL || file2 == NULL) {
        closeFiles(file1, file2, filePath1, filePath2);
        return;
    }

    if(filesEqual(file1, file2, filePath1, filePath2)) {
        struct stat fileInfo1 = getFileInfo(file1);
        struct stat fileInfo2 = getFileInfo(file2);
        char *str1 = calloc(1, strSize);
        char *str2 = calloc(1, strSize);

        if(checkPointer(str1, filePath1, 0) || checkPointer(str2, filePath2, 0)) return;

        sprintf(str1, "%s %ld %s %u %lu = ", filePath1,
                fileInfo1.st_size, getDate(fileInfo1.st_ctim.tv_sec), fileInfo1.st_mode, fileInfo1.st_ino);
        strcat(outputBuffer, str1);
        sprintf(str2, "%s %ld %s %u %lu\n", filePath2,
                fileInfo2.st_size, getDate(fileInfo2.st_ctim.tv_sec), fileInfo2.st_mode, fileInfo2.st_ino);
        strcat(outputBuffer, str2);
        outputBufferIndex++;

        if (outputBufferIndex == outputBufferLength) {
            printOutputBuffer();
        }

        free(str1);
        free(str2);
    }

    if(fclose(file1) != 0) {
        fprintf(stderr, "%s: %s: %s\n", execFileName, filePath1, strerror(errno));
    }

    if(fclose(file2) != 0) {
        fprintf(stderr, "%s: %s: %s\n", execFileName, filePath2, strerror(errno));
    }
}

void handleFile1(char *filePath, char *_) {
    findFiles(dir2, handleFile2, filePath);
}

void findFiles(char *dirname, void (*callback)(char *, char *), char *cbArg) {
    DIR *dir;
    struct dirent *ent;

    if ((dir = opendir(dirname)) == NULL) {
        addToBlacklist(dirname);
        return;
    }

    errno = 0;
    while ((ent = readdir(dir)) != NULL) {
        char *temp = calloc(1, strSize);

        if(checkPointer(temp, dirname, 0)) return;

        strcpy(temp, dirname);
        strcat(temp, ent->d_name);

        if (ent->d_type == DT_REG) {
            callback(temp, cbArg);
        } else if (ent->d_type == DT_DIR && strcmp(ent->d_name, ".") != 0 && strcmp(ent->d_name, "..") != 0) {
            strcat(temp, "/");
            findFiles(temp, callback, cbArg);
        }

        free(temp);
        errno = 0;
    }

    if(errno != 0) {
        fprintf(stderr, "%s: %s: %s\n", execFileName, dirname, strerror(errno));
    }

    if(closedir(dir) == -1) {
        fprintf(stderr, "%s: %s: %s\n", execFileName, dirname, strerror(errno));
    }
}

char *addSlash(char *str) {
    int length = strlen(str);

    if (str[length - 1] != '/') {
        char *copy = malloc(strlen(str));
        strcpy(copy, str);
        strcat(copy, "/");
        return copy;
    }

    return str;
}

int isDirectory(char *str) {
    DIR *dir = opendir(str);

    if (dir != NULL) {
        closedir(dir);
        return 1;
    }

    return 0;
}

void checkForErrors(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "%s: First argument is not specified: you didn't provide first directory\n", execFileName);
        exit(1);
    }

    if (argc < 3) {
        fprintf(stderr, "%s: Second argument is not specified: you didn't provide second directory\n", execFileName);
        exit(2);
    }

    if(argc < 4) {
        fprintf(stderr, "%s: Third argument is not specified: you didn't provide output file path\n", execFileName);
        exit(3);
    }

    if (!isDirectory(argv[1])) {
        fprintf(stderr, "%s: First argument must be a valid directory\n", execFileName);
        exit(4);
    }

    if (!isDirectory(argv[2])) {
        fprintf(stderr, "%s: Second argument must be a valid directory\n", execFileName);
        exit(5);
    }
}

char *getExecFileName(char *path) {
    int lastSlashIndex = 0;
    int length = strlen(path);

    for(int i = 0; i < length; i++) {
        if(path[i] == '/') lastSlashIndex = i;
    }

    char *result = malloc(length - lastSlashIndex);
    checkPointer(result, path, 1);

    for(int i = 0; i < length - lastSlashIndex; i++) {
        result[i] = path[lastSlashIndex + i + 1];
    }

    result[length - lastSlashIndex] = '\0';
    return result;
}

int main(int argc, char **argv) {
    execFileName = getExecFileName(argv[0]);
    checkForErrors(argc, argv);
    dir1 = addSlash(argv[1]);
    dir2 = addSlash(argv[2]);
    outputFilePath = argv[3];
    outputBuffer = calloc(outputBufferLength, strSize);
    checkPointer(outputBuffer, argv[0], 1);
    findFiles(dir1, handleFile1, NULL);
    printOutputBuffer();
    free(outputBuffer);
    return 0;
}