7.1

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dirent.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/wait.h>

#define MAX_PATH_LENGTH 4096
#define MAX_FILENAME_LENGTH 256
#define MAX_CHILD_PROCESSES 10

typedef struct {
    char filename[MAX_FILENAME_LENGTH];
    off_t size;
} FileInfo;

int compareBySize(const void *a, const void *b) {
    return ((FileInfo *)a)->size - ((FileInfo *)b)->size;
}

int compareByName(const void *a, const void *b) {
    return strcmp(((FileInfo *)a)->filename, ((FileInfo *)b)->filename);
}

void copyFile(const char *sourcePath, const char *destPath) {
    int sourceFile = open(sourcePath, O_RDONLY);
    int destFile = open(destPath, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);

    char buffer[4096];
    ssize_t bytesRead, bytesWritten;

    while ((bytesRead = read(sourceFile, buffer, sizeof(buffer))) > 0) {
        bytesWritten = write(destFile, buffer, bytesRead);
        if (bytesWritten != bytesRead) {
            perror("Write error");
            exit(EXIT_FAILURE);
        }
    }

    close(sourceFile);
    close(destFile);
}

void sortAndCopyFiles(const char *dirPath, int sortBy, const char *destPath, int maxProcesses) {
    DIR *dir = opendir(dirPath);
    if (dir == NULL) {
        perror("Error opening directory");
        exit(EXIT_FAILURE);
    }

    struct dirent *entry;
    struct stat fileInfo;

    int numProcesses = 0;
    int numFiles = 0;
    FileInfo *files = malloc(MAX_CHILD_PROCESSES * sizeof(FileInfo));

    while ((entry = readdir(dir)) != NULL) {
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
            continue;

        char filePath[MAX_PATH_LENGTH];
        snprintf(filePath, sizeof(filePath), "%s/%s", dirPath, entry->d_name);

        if (lstat(filePath, &fileInfo) == -1) {
            perror("Error getting file info");
            exit(EXIT_FAILURE);
        }

        if (S_ISREG(fileInfo.st_mode)) {
            strncpy(files[numFiles].filename, entry->d_name, MAX_FILENAME_LENGTH - 1);
            files[numFiles].size = fileInfo.st_size;
            numFiles++;

            if (numFiles >= MAX_CHILD_PROCESSES) {
                qsort(files, numFiles, sizeof(FileInfo), (sortBy == 1) ? compareBySize : compareByName);
                for (int i = 0; i < numFiles; i++) {
                    pid_t childPid = fork();
                    if (childPid == -1) {
                        perror("Error forking process");
                        exit(EXIT_FAILURE);
                    }

                    if (childPid == 0) {  // Child process
                        printf("PID: %d, Path: %s, Filename: %s, Size: %ld bytes\n", getpid(), filePath, files[i].filename, files[i].size);

                        char destFilePath[MAX_PATH_LENGTH];
                        snprintf(destFilePath, sizeof(destFilePath), "%s/%s", destPath, files[i].filename);

                        copyFile(filePath, destFilePath);
                        exit(EXIT_SUCCESS);
                    } else {  // Parent process
                        numProcesses++;
                        if (numProcesses >= maxProcesses) {
                            wait(NULL);  // Wait for any child process to finish
                            numProcesses--;
                        }
                    }
                }

                numFiles = 0;
            }
        }
    }

    closedir(dir);
    free(files);
}

int main(int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "Usage: %s <source_directory> <sort_criteria> <destination_directory>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    const char *dirPath = argv[1];
    int sortBy = atoi(argv[2]);
    const char *destPath = argv[3];

    if (sortBy != 1 && sortBy != 2) {
        fprintf(stderr, "Invalid sort criteria. Use 1 for sorting by size or 2 for sorting by name.\n");
        exit(EXIT_FAILURE);
    }

    int maxProcesses;
    printf("Enter the maximum number of processes: ");
    scanf("%d", &maxProcesses);

    sortAndCopyFiles(dirPath, sortBy, destPath, maxProcesses);
    printf("Ready.");
    return 0;
}