cmds.cpp

#include "cmds.h"
#include "dirtree.h"
#include "simsys.h"
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char** str_to_vec(char *str, char split_c) {
    char** vec = (char**) malloc(sizeof(char*));
    char *next;
    int i, j, k;
    int size = 0;

    vec[0] = NULL;
    
    k = 0;
    while (1) {
        int m, n;
        char **tmp;
        
        for (m = 0, n = 0; str[k+n+m] != split_c && str[k+n+m]; n++) {
            /* Skip backslashes */
            if (str[k+n+m] == '\\'/* && str[k+n+m+1]*/)
                m++;
        }
        
        /* Make the new string */
        next = (char*) malloc((n+1) * sizeof(char));
        for (i = 0, j = 0; i < n; i++) {
            if (str[k+i+j] == '\\')
                j++;
            next[i] = str[k+i+j];
        }
        next[n] = '\0';

        vec[size] = next;

        /* Realloc */
        size++;
        tmp = (char**) realloc(vec, (size+1) * sizeof(char*));
        if (!tmp) {
            printf("Have to reallocate.\n");
            tmp = (char**) malloc((size+1) * sizeof(char*));
            memcpy(tmp, vec, size * sizeof(char*));
        }

        vec = tmp;
        vec[size] = NULL;
        
        /* Update k */
        while (str[k+m+n] == split_c)
            k++;

        if (str[k+m+n]) 
            k += n+m;
        else
            return vec;

    }

}

void free_str_vec(char **vec) {
    int i;
    for (i = 0; vec[i]; i++) {
        free(vec[i]);
        vec[i] = NULL;
    }
    free(vec);
}

void error_message(char *cmd, char *mssg) {
    printf("%s: Cannot perform operation: %s\n", cmd, mssg);
}

void printTreeNode(DirTree node, int fullpath, int details) {
    char *filename;
    char buff[32];

    int is_file;
    long filesize;

    if (!node)
        return;

    is_file = isTreeFile(node);
    filesize = treeFileSize(node, NULL);
    filename = getTreeFilename(node);
    
    if (details) {
        time_t now = time(NULL);
        struct tm* timestamp;
        int currYear;

        time_t time = getTreeTimestamp(node);
        
        timestamp = localtime(&now);
        currYear = timestamp->tm_year;

        timestamp = localtime(&time);
        
        if (currYear == timestamp->tm_year)
            strftime(buff, 32*sizeof(char), "%b %d %H:%M", timestamp);
        else
            strftime(buff, 32*sizeof(char), "%b %d %Y", timestamp);

        printf("%-15s ", buff);
        printf("%-15ld ", filesize);

    }
    
    /* Blue bold for the files */
    if (!is_file)
        printf("\033[1m\033[34m");

    if (fullpath) {
        /* Show full path */
        char **path = pathVecOfTree(node);
        int i;
        
        /* Print each file layer */
        for (i = 0; path[i]; i++)
            printf("%s%s", path[i],
                path[i+1] ? "/" : ""
        );

        free_str_vec(path);

    } else
        printf("%s", filename);
    
    if (!is_file)
            printf("/");

    printf("\033[0m\n");
 
            /*
            int is_file = isTreeFile(file);
             
            printf("%s%s%s", 
                is_file ? "" : "\033[1m\033[34m",
                getTreeFilename(file),
                "\033[0m");
            
            *//* Prints only if the child is a file *//*
            if (is_file)
                printf(" - %ldB",treeFileSize(file, NULL));

            printf("\n");
            */   
}

/**
 * Runs a command.
 *
 * argv - The command vector to execute.
 */
void cmd_exec(char *argv[]) {
    SimCmd cmd;
    char *name = argv[0];

    /* Don't need to bother with empty line */
    if (!argv || !argv[0])
        return;
    
    if (!strcmp(name, "cd"))
        cmd = cmd_cd;
    else if (!strcmp(name, "ls"))
        cmd = cmd_ls;
    else if (!strcmp(name, "mkdir"))
        cmd = cmd_mkdir;
    else if (!strcmp(name, "create"))
        cmd = cmd_create;
    else if (!strcmp(name, "append"))
        cmd = cmd_append;
    else if (!strcmp(name, "remove"))
        cmd = cmd_remove;
    else if (!strcmp(name, "delete"))
        cmd = cmd_delete;
    else if (!strcmp(name, "exit"))
        cmd = cmd_exit;
    else if (!strcmp(name, "dir"))
        cmd = cmd_dir;
    else if (!strcmp(name, "prfiles"))
        cmd = cmd_prfiles;
    else if (!strcmp(name, "cd..")) {
        char *args[3];
        args[0] = "cd";
        args[1] = "..";
        args[2] = NULL;
        cmd_exec(args);
        return;
    } else {
        printf("%s: command not found.\n", argv[0]);
        return;
    }

    cmd(argv);
}

int cmd_cd(char *argv[]) {
    char **dirtoks;
    int i = 1;
    
    if (!argv[1]) {
        /* Default is to go to root. */
        setWorkDirNode(getRootNode());
        return 0;
    } else while (argv[i]) {
        DirTree tgt;

        /* Build a token vector */
        dirtoks = str_to_vec(argv[i], '/');

        /* Get the destination */
        tgt = getRelTree(getWorkDirNode(), dirtoks);

        /* Free the vector */
        free_str_vec(dirtoks);
        
        if (!tgt) {
            printf("cd: %s: No such file or directory\n", argv[i]);
            return 1;
        } else if (isTreeFile(tgt)) {
            printf("cd: %s: Target is not a directory\n", argv[i]);
            return 1;
        } else {
            setWorkDirNode(tgt);
        }

        i++;
    }

    return 0;
}

/**
 * Lists the contents of a directory.
 */
int cmd_ls(char *argv[]) {
    DirTree tgt;
    DirTree working_dir = getWorkDirNode();

    if (argv[1]) {
        char **dirtoks = str_to_vec(argv[1], '/');

        /* Adjust the node to print */
        tgt = getRelTree(working_dir, dirtoks);

        free_str_vec(dirtoks);
    } else
        tgt = working_dir;

    if (!tgt) {
        printf("ls: cannot access '%s': No such file or directory\n", argv[1]);
        return 1;
    } else if (isTreeFile(tgt)) {
        printf("ls: cannot access '%s': Target is not a directory.\n", argv[1]);
        return 1;
    } else {
        LList files = getDirTreeChildren(tgt, 1);

        printf("total %i\n", sizeOfLL(files));
        
        /* Go through each file, removing from the list as it goes */
        while (!isEmptyLL(files)) {
            DirTree file = (DirTree) remFromLL(files, 0);

            printTreeNode(file, 0, 1);
        }
        
        /* Delete the list */
        free(files);
    }
    
    return 0;
}

/**
 * Creates a directory, or set of directories.
 */
int cmd_mkdir(char *argv[]) {
    
    if (!argv[1]) {
        printf("mkdir: missing operand");
        return 1;
    } else {
        /* Get a list of all of the files in the directory */
        int errCode = 0;

        int i = 1;
        while (argv[i]) {
            /* Build a path */
            char **path = str_to_vec(argv[i], '/');
            char *dirnm;
            int j, k;
            DirTree tgtDir;
            LList files;

            /* Check whether or not the file already exists */
            if (getRelTree(getWorkDirNode(), path)) {
                printf("mkdir: Cannot create directory '%s': Already exists\n", argv[i]);
                errCode = 1;
                i++;
                continue;
            }
            
            /* Separate the target name and its path */
            for (k = 0; path[k]; k++);
            dirnm = path[k-1];
            path[k-1] = NULL;
            
            /* Get the potential parent node */
            tgtDir = getRelTree(getWorkDirNode(), path);

            if (!tgtDir) {
                /* The containing path does not exist. */
                printf("mkdir: cannot create directory '%s': No such file or directory\n", argv[i]);
                errCode = 1;
                i++;
                continue;
            }

            files = getDirTreeChildren(tgtDir, 0);

            for (j = sizeOfLL(files) - 1; j >= 0; j--) {
                DirTree file = (DirTree) getFromLL(files, j);

                if (!strcmp(getTreeFilename(file), argv[i])) {
                    /* Don't make duplicate directories */
                    printf("mkdir: cannot create directory '%s': Already exists\n", argv[i]);
                    errCode = 1;
                    break;
                }
            }

            path[k-1] = dirnm;
            
            if (j < 0) {
                /* Add the directory */
                addDirToTree(getWorkDirNode(), path);
            }

            /* Free used memory */
            free_str_vec(path);
            while (!isEmptyLL(files))
                remFromLL(files, 0);
            free(files);

            i++;
        }

        
        return errCode;
    }

}

/**
 * Creates a file in the file structure.
 */
int cmd_create(char *argv[]) {
    if (!argv[1]) {
        error_message("create", "No file names provided.");
        return 1;
    } else {
        /* Get a list of all of the files in the directory */
        int errCode = 0;

        int i = 1;
        while (argv[i]) {
            /* Build a path */
            char **path = str_to_vec(argv[i], '/');
            char *filenm;
            int j, k;
            DirTree tgtDir;
            LList files;

            /* Check whether or not the file already exists */
            if (getRelTree(getWorkDirNode(), path)) {
                printf("mkdir: cannot make file '%s': Already exists\n", argv[i]);
                errCode = 1;
                i++;
                continue;
            }
            

            
            /* Separate the target name and its path */
            for (k = 0; path[k]; k++);
            filenm = path[k-1];
            path[k-1] = NULL;
            
            /* Get the potential parent node */
            tgtDir = getRelTree(getWorkDirNode(), path);

            /* Check to see if it exists */
            if (!tgtDir) {
                printf("mkdir: cannot create file '%s': No such file or directory\n", argv[i]);
                errCode = 1;
                i++;
                continue;
            }

            files = getDirTreeChildren(tgtDir, 0);


            for (j = sizeOfLL(files) - 1; j >= 0; j--) {
                DirTree file = (DirTree) getFromLL(files, j);

                if (!strcmp(getTreeFilename(file), argv[i])) {
                    /* Don't make duplicate directories */
                    printf("create: cannot create file %s: Already exists.\n", argv[i]);
                    errCode = 1;
                    break;
                }
            }

            path[k-1] = filenm;
            
            if (j < 0) {
                /* Add the directory */
                addFileToTree(getWorkDirNode(), path);
            }

            /* Free used memory */
            free_str_vec(path);
            while (!isEmptyLL(files))
                remFromLL(files, 0);
            free(files);

            i++;
        }

        
        return errCode;
    }
}

int cmd_append(char *argv[]) {
    if (!argv[1] || !argv[2]) {
        printf("append: missing operand\n");
        return 1;
    } else {
        int errCode = 0;
        
        char **path = str_to_vec(argv[1], '/');
        DirTree tgt = getRelTree(getWorkDirNode(), path);
        long request = atol(argv[2]);
        
        if (!tgt) {
            errCode = 1;
            printf("append: cannot modify '%s': No such file\n", argv[1]);
        } else if (request <= 0) {
            errCode = 1;
            printf("append: cannot append nonpositive memory\n");
        } else if (isTreeFile(tgt)) {

            /* Calculate the necessary block allocation needed */
            long fileSizeBefore;
            long fileSizeAfter;
            long blocksNeeded;

            fileSizeBefore = treeFileSize(tgt, NULL);
            fileSizeAfter = fileSizeBefore + request;

            /* Difference of ceiling divisions for old/new block size */
            blocksNeeded = fileSizeBefore 
                            ? ((fileSizeAfter - 1) / blockSize() - (fileSizeBefore - 1) / blockSize())
                            : (1 + (fileSizeAfter - 1) / blockSize());

            /* Update the file */
            if (enoughMemFor(blocksNeeded)) {

                printf("Allocating %ld bytes (needs %ld blocks)...\n", request, blocksNeeded);

                /* Allocate blocks */
                while (blocksNeeded > 0) {
                    assignMemoryBlock(tgt, allocBlock());
                    blocksNeeded--;
                }

                updateFileSize(tgt, fileSizeAfter);

                updateTimestamp(tgt);
                updateTimestamp(getTreeParent(tgt));

            } else {
                errCode = 1;
                printf("append: cannot modify '%s': Insufficient memory space to allocate %ld blocks\n", argv[1], blocksNeeded);
            }

        } else {
            errCode = 1;
            printf("append: cannot modify '%s': Not a file\n", argv[1]);
        }


        return errCode;
    }
}

int cmd_remove(char *argv[]) {
    if (!argv[1] || !argv[2]) {
        printf("remove: missing operand\n");
        return 1;
    } else {
        int errCode = 0;
        
        char **path = str_to_vec(argv[1], '/');
        DirTree tgt = getRelTree(getWorkDirNode(), path);

        long request = atol(argv[2]);
        
        if (!tgt) {
            errCode = 1;
            printf("remove: cannot modify '%s': No such file\n", argv[1]);
        } else if (request <= 0) {
            errCode = 1;
            printf("remove: cannot remove nonpositive memory\n");
        } else if (isTreeFile(tgt)) {

            /* Calculate the necessary block deallocation needed */
            long fileSizeBefore;
            long fileSizeAfter;
            long blocksNeeded;

            fileSizeBefore = treeFileSize(tgt, NULL);
            fileSizeAfter = fileSizeBefore - request;

            /* Difference of ceiling divisions for old/new block size */
            blocksNeeded = fileSizeAfter
                            ? ((fileSizeBefore - 1) / blockSize() - (fileSizeAfter - 1) / blockSize())
                            : (1 + (fileSizeBefore - 1) / blockSize());

            /* Update the file */
            if (fileSizeAfter < 0) {
                errCode = 1;
                printf("remove: cannot modify '%s': More blocks requested for deletion than exist\n", argv[1]);
            } else {
                printf("Deallocating %ld bytes (revoking %ld blocks)...\n", request, blocksNeeded);
                
                /* Deallocate the blocks */
                while (blocksNeeded > 0) {
                    freeBlock(releaseMemoryBlock(tgt));
                    blocksNeeded--;
                }

                updateFileSize(tgt, fileSizeAfter);
                updateTimestamp(tgt);
                updateTimestamp(getTreeParent(tgt));
            }

        } else {
            errCode = 1;
            printf("remove: cannot modify '%s': Not a file\n", argv[1]);
        }

        return errCode;
    }
}


int cmd_delete(char *argv[]) {
    if (!argv[1]) {
        printf("rm: missing operand\n");
        return 1;
    } else {
        int errCode = 0;
        int i = 1;
        
        while (argv[i]) {
            char **path = str_to_vec(argv[i], '/');
            DirTree tgt = getRelTree(getWorkDirNode(), path);
            
            if (tgt == getWorkDirNode()) {
                /* Don't delete directory that is currently in use. */
                errCode = 1;
                printf("delete: failed to remove '%s': Directory currently in use\n", argv[i]);
            } else if (!tgt) {
                errCode = 1;
                printf("delete: cannot delete '%s': No such file or directory\n", argv[i]);
            } else if (isTreeFile(tgt)) {
                /* The currently allocated memory blocks */
                LList blocks = getTreeFileBlocks(tgt);
                
                /* Free each used memory block one by one */
                while (!isEmptyLL(blocks)) {
                    long *blk = (long*) remFromLL(blocks, 0);
                    freeBlock(*blk);
                    free(blk);
                }
                free(blocks);
                
                /* Remove the file */
                errCode |= rmfileFromTree(tgt, NULL);

            } else {
                /* Handle directory removal. */
                LList children = getDirTreeChildren(tgt, 0);
                
                /* Allow deletion if the directory is empty */
                if (isEmptyLL(children))
                    errCode |= rmdirFromTree(tgt, NULL);
                else {
                    errCode = 1;
                    printf("delete: failed to remove '%s': Directory not empty\n", argv[i]);
                }
                
                /* Free the child list */
                while(!isEmptyLL(children))
                    remFromLL(children, 0);
                free(children);
            }

            i++;

        }

        return errCode;
    }
}


/**
 * Terminates the program.
 */
int cmd_exit(char *argv[]) {
    
    /* Cleans the filesystem. */
    flush_filesystem();
    
    if (argv[1])
        exit(atoi(argv[1]));
    else
        exit(0);

    return 1;

}

int cmd_dir(char *argv[]) {
    
    DirTree root;
    LList bfs_list = makeLL();
    
    /* Get the top directory of the BFS */
    if (!argv[1])
        root = getWorkDirNode();
    else {
        char **dirtoks = str_to_vec(argv[1], '/');
        root = getRelTree(getWorkDirNode(), dirtoks);
        free_str_vec(dirtoks);
    }
    
    /* Initial value is the root */
    appendToLL(bfs_list, root);
    
    while (!isEmptyLL(bfs_list)) {
        DirTree curr = (DirTree) remFromLL(bfs_list, 0);
        
        /* Print the front file */
        printTreeNode(curr, 1, 0);
        
        if (!isTreeFile(curr)) {
            /* Is a directory; add all children */
            LList children = getDirTreeChildren(curr, 1);

            while (!isEmptyLL(children))
                appendToLL(bfs_list, remFromLL(children, 0));

            free(children);

        }

    }

    free(bfs_list);

    return 0;
    
}

/* Used for nlogn sort of longs */
void mergesort_longs(long *list, int lo, int hi) {
    if (hi - lo == 2) {
        /* Pair case */
        if (list[lo] > list[lo+1]) {
            long tmp = list[lo];
            list[lo] = list[lo+1];
            list[lo+1] = tmp;
        }
    } else if (hi - lo > 2) {
        long *tmp;

        int c = (lo + hi) / 2;

        int i = lo;
        int j = c;
        int k = 0;

        mergesort_longs(list, lo, c);
        mergesort_longs(list, c, hi);
        
        tmp = (long*) malloc((hi - lo) * sizeof(long));
        
        /* Build sorted into the temporary array */
        while (i < c && j < hi) {
            if (list[i] < list[j])
                tmp[k++] = list[i++];
            else
                tmp[k++] = list[j++];
        }
        
        while (j < hi)
            tmp[k++] = list[j++];

        while (i < c)
            tmp[k++] = list[i++];

        /* Reinsert */
        while (k--)
            list[lo+k] = tmp[k];

        free(tmp);

    }

}

int cmd_prfiles(char *argv[]) {
    DirTree root;
    LList bfs_list = makeLL();
    
    /* Get the top directory of the BFS */
    if (!argv[1])
        root = getWorkDirNode();
    else {
        char **dirtoks = str_to_vec(argv[1], '/');
        root = getRelTree(getWorkDirNode(), dirtoks);
        free_str_vec(dirtoks);
    }
    
    appendToLL(bfs_list, root);

    while (!isEmptyLL(bfs_list)) {
        DirTree curr = (DirTree) remFromLL(bfs_list, 0);
                        
        /* Breadth-first recursive definition */
        if (!isTreeFile(curr)) {
            /* Is a directory; add all children */
            LList children = getDirTreeChildren(curr, 1);

            while (!isEmptyLL(children))
                appendToLL(bfs_list, remFromLL(children, 0));

            free(children);

        } else {
            /* Get block information */
            LList blocks = getTreeFileBlocks(curr);
            int num_blks = sizeOfLL(blocks);

            /* Used as a scratch space for printing. */
            long *blks = (long*) malloc(num_blks * sizeof(long));
            int i;
            
            /* For printing */
            int contig = 0;

            /* Iterator */
            LLiter iter;
            
            /* Print basic file data */
            printTreeNode(curr, 1, 1);
            
            /* Dequeue each block number */
            iter = makeLLiter(blocks);
            for (i = 0; iterHasNextLL(iter); i++)
                blks[i] = *((long*) iterNextLL(iter));

            free(blocks);
            disposeIterLL(iter);

            printf("%i blocks%s", num_blks, num_blks ? ": " : "");
            
            /* Sort the blocks */
            mergesort_longs(blks, 0, num_blks);

            for (i = 0; i < num_blks; i++) {

                /* Format print the blocks. */
                if (i > 0 && blks[i] - 1 == blks[i-1]) {
                    if (!contig) {
                        printf("-");
                        contig = 1;
                    } 
                } else {
                    if (contig) {
                        printf("%ld %ld", blks[i-1], blks[i]);
                        contig = 0;
                    } else
                        printf(" %ld", blks[i]);
                }
            }
            
            /* Print the last value if necessary */
            if (contig)
                printf("%ld", blks[i-1]);

            printf("\n\n");

            /* Free the array */
            free(blks);


        }

    }
    
    /* Dispose of the list */
    free(bfs_list);

    return 0;

}