LSFS/disk_manager_utility.c

#include <sys/stat.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include "lsfs_disk_controller.h"


static int disk_is_loaded = 0;
static char loaded_disk_name[256];
static char input_buffer[256];

int dmu_print_file(char *path) {
    
    lsfs_file *file = calloc(1, sizeof(lsfs_file)); 
    lsfs_disk_getattr(file, path);


    printf("\n|-----------------Meta Information For File-----------------|\n");
    printf("File ID: %lu\n", file->file_id);
    printf("Filename: %s\n", file->filename);
    printf("File size: %lu\n", file->size);
    printf("Entry kind: %d\n", file->entry_kind);
    printf("Index in directory table: %lu\n", file->table_entry_pointer);
    printf("Sector index on disk: %lu\n", file->table_entry_sector_index);
    printf("\nData pointers:\n");
    for (int i = 0; i < NUM_DATA_POINTERS; ++i)
    {
        printf("%lu\n", file->data_pointer[i]);
    }
    /*
    printf("\n|-------------------------File Data-------------------------|\n");
    char* file_data = calloc(MAX_NUM_ONE_LEVEL_DATA, SECTOR_SIZE);
    int size_of_data = 0; 

    size_of_data = lsfs_disk_read_data_from_file(fileID, (256*4096), file_data);
    
    if (size_of_data <= 0) {
        printf("|File has no data!\n");
    }
    for (int i = 0; i < MAX_NUM_ONE_LEVEL_DATA; ++i)
    {
        if (size_of_data <= 0) {
            break;
        }
        printf("|%s", file_data);
        size_of_data -= SECTOR_SIZE;
    }
    printf("\n|---------------------End File Data-------------------------|\n");
    */
    return 1;
}

#if 0
typedef struct sector_data
{
    char data[SECTOR_SIZE];
} sector_data;


int dmu_install_SingOS(char* disk_name) {
    disk = fopen ( disk_name , "r+b" );
    p_control.fsci = malloc(sizeof(FSCI));
    p_control.mtt_tags = malloc(sizeof(global_tag) * DEFAULT_MASTER_TAG_TABLE_SIZE);
    lsfs_disk_load_disk(disk, &p_control);
    
    lsfs_tag_id untagged     = lsfs_disk_create_tag("@untagged", false);
    lsfs_tag_id sy_files     = lsfs_disk_create_tag("@system_files", false);
    lsfs_tag_id SingOS_files = lsfs_disk_create_tag("@SingOS", false);

    /* Add files: */ 
    char* new_file_data_d = calloc(1, 4096);
    char* rtfm_file = "If you don't know the answer\nRead the F manual\n";
    sprintf(new_file_data_d, "%s", rtfm_file);
    char* l_filename = "RTFM.md";
    lsfs_sector_offset* tags     = calloc(2, sizeof(lsfs_sector_offset));
    lsfs_tag_id filename_tag     = lsfs_disk_create_tag(l_filename, true);
    tags[0] = filename_tag;
    tags[1] = sy_files;
    int rtfm_file_if = lsfs_disk_create_file(l_filename, tags, new_file_data_d );
    lsfs_disk_write_data_to_file(rtfm_file_if, strlen(rtfm_file), new_file_data_d);

    char* vip_file = "Very important file\n" ;
    sprintf(new_file_data_d, "%s", vip_file);
    l_filename       = "system_control.md";
    filename_tag     = lsfs_disk_create_tag(l_filename, true);
    tags[0] = filename_tag;
    tags[1] = sy_files;
    int vip_file_id = lsfs_disk_create_file(l_filename, tags, new_file_data_d );
    lsfs_disk_write_data_to_file(vip_file_id, strlen(vip_file), new_file_data_d);

    char* sing_os_file = "SingOS is comming\n\nWe are not ready to expose the binaries nor the source\nBut read more @ guld-berg.dk/singos\nSingOS is real\n\n- groot\n" ;
    sprintf(new_file_data_d, "%s", sing_os_file);
    l_filename = "README.md";
    filename_tag     = lsfs_disk_create_tag(l_filename, true);
    tags[0] = filename_tag;
    tags[1] = SingOS_files;
    int sing_id = lsfs_disk_create_file(l_filename, tags, new_file_data_d );
    lsfs_disk_write_data_to_file(sing_id, strlen(sing_os_file), new_file_data_d);


    free(new_file_data_d);
    free(tags);

    fclose (disk);
}
#endif

int dmu_create_file_system(char* disk_name) {
    uint64_t filesystem_size_in_MB = 0;
    char hdd_or_partition = 0; // 1: is harddisk, 2: is partition
    char input_size_file_system[64]; // in MB

    do {
        printf("Create as 1: harddrive or 2: as a single partition (enter 1 or 2): \n");
        scanf("%c", &hdd_or_partition);

    } while ((hdd_or_partition != '1') && (hdd_or_partition != '2'));

    printf("Enter size of file system in MB (as an integer number): \n");
    scanf("%s", input_size_file_system);
    
    filesystem_size_in_MB = atoi(input_size_file_system);

    printf("Create new disk img\n");
    create_file_system(disk_name, hdd_or_partition, filesystem_size_in_MB);
    printf("Disk is created as: %s\n", disk_name);

    fclose (disk);
    
    // TODO: Do you want to install SingOS: 
    //dmu_install_SingOS(disk_name);
    
    return 1;
}

int dmu_load_file_system(char* disk_name) 
{
    lsfs_disk_load_disk(disk_name);
    disk_is_loaded = 1;
    return 1; 
}

int dmu_install_bootloader(char* disk_name) 
{
    lsfs_disk_install_bootloader(disk_name);
    return 1; 
}

int dmu_install_vbr(char* disk_name) {
    lsfs_disk_install_vbr(disk_name);
    return 1; 
}

int dmu_print_mtt(char *path) {
    Directory_Table *directory_table;
    directory_table = lsfs_find_directory(path, false);

    printf("\n|------------------------ Directory -------------------------------------|\n");
    printf("\n|--------Filename------------|Not used----------------------|Entry ID----|\n");

    for (int i = 0; i < DEFAULT_TABLE_SIZE; ++i) {
        printf("|%-28s|%-30lu|%-12lu| \n", directory_table->entries[i].filename, directory_table->entries[i].file_id, directory_table->entries[i].file_id);
        printf("|----------------------------|------------------------------|------------|\n");
    
    }
    printf("\n\n\n");    
    return 1;
}


typedef struct Arguments_Settings
{
    char* load_diskname; 
    char* new_diskname;
    int new_disk_size_mb;
    char* install_vbr_path;
    char* install_bootloader_path;
    char* copy_new_kernel;


} Arguments_Settings;

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

    if (argc > 1) 
    {
        Arguments_Settings* settings = calloc(1, sizeof(Arguments_Settings));
        for (int i = 1; i < argc; i++) 
        {
            // Parse parameters for cmd usage
            switch(argv[i][1]) 
            {
                case 'd':
                {
                    // Load disk with specified name 
                    i++; // Go to next parameter which is the path/filename for the new disk 
                    if (i > argc) 
                    {
                        // Go to loop condition to exit
                        continue;
                    }
                    settings->load_diskname = argv[i];

                } break;

                case 'n':
                {
                    // Create new disk 
                    i++; // Go to next parameter which is the path/filename for the new disk 
                    if (i > argc) 
                    {
                        // Go to loop condition to exit
                        continue;
                    }
                    settings->new_diskname = argv[i];
                    printf("Creating new disk: %s \n", settings->new_diskname);

                } break;

                case 's': 
                {
                    // Specify size of new disk 
                    i++; // Go to next parameter which is the disk size 
                    if (i > argc) 
                    {
                        // Go to loop condition to exit
                        continue;
                    }
                    settings->new_disk_size_mb = atoi(argv[i]); 

                } break;

                case 'v':
                {
                    // Update Volume boot record 
                    i++; // Go to next parameter which is the path for the VBR 
                    if (i > argc) 
                    {
                        // Go to loop condition to exit
                        continue;
                    }
                    settings->install_vbr_path = argv[i];

                } break;

                case 'b':
                {
                    // Update bootloader 
                    i++; // Go to next parameter which is the path for the VBR 
                    if (i > argc) 
                    {
                        // Go to loop condition to exit
                        continue;
                    }
                    settings->install_bootloader_path = argv[i];
                } break;
            }
        }

        if (settings->new_diskname != NULL && settings->load_diskname != NULL) 
        {
            printf("-d and -n cannot be specified in the same qeury\n");
            return 1;
        }
        // Now execute the commands. 
        // First check if we should create a new disk
        if (settings->new_diskname != NULL) 
        {
            // TODO(only harddisk is supported yet)
            char hdd_or_partition = '1'; // 1 is harddrive

            if (settings->new_disk_size_mb <= 0) 
            {
                settings->new_disk_size_mb = 20; // 20MB is default size
            }

            create_file_system(settings->new_diskname, hdd_or_partition, settings->new_disk_size_mb);

            settings->load_diskname = settings->new_diskname; 
        }

        // Load the disk to complete the following instructions
        if (settings->load_diskname != NULL) 
        {
            dmu_load_file_system(settings->load_diskname);

            if (settings->install_bootloader_path != NULL) 
            {
                lsfs_disk_install_bootloader(settings->install_bootloader_path);
            }
            
            if (settings->install_vbr_path != NULL) 
            {
                lsfs_disk_install_vbr(settings->install_vbr_path);
            }

        }

    }
    else
    {
        char chose[8];
        while(strcmp(chose, "exit")) {
            if(!disk_is_loaded) {
                printf("Tag File System Utility\nMenu:\nc: Create new lsfs disk\nl: load disk\nEnter:");
            }
            else {
                printf("Tag File System Utility\n"
                       "Disk loaded: %s\nMenu:\n" 
                       "1: Print Directory table\n"
                       "2: (Not implemented) \n"
                       "3: Print File\n"
                       "4: (Not implemented)\n"
                       "5: Create New Directory\n"
                       "b: install Bootloader\n"
                       "v: install VBR\n"
                       "exit: exit program\n", loaded_disk_name);
            }

            scanf("%s", chose);

            if (strcmp(chose, "c") == 0) 
            {
                printf("\nCreate disk\nEnter filename:\n");
                scanf("%s", loaded_disk_name);
                dmu_create_file_system(loaded_disk_name);
            }
            else if(strcmp(chose, "l") == 0) 
            {
                printf("\nLoad disk\nEnter filename:\n");
                scanf("%s", loaded_disk_name);
                dmu_load_file_system(loaded_disk_name);
            }
            else if(strcmp(chose, "b") == 0) {
                printf("\nInstall Bootloader\nEnter filename:\n");
                scanf("%s", input_buffer);
                dmu_install_bootloader(input_buffer);
            }
            else if(strcmp(chose, "v") == 0) {
                printf("\nInstall VBR\nEnter filename:\n");
                scanf("%s", input_buffer);
                dmu_install_vbr(input_buffer);
            }
            else if(strcmp(chose, "1") == 0) {
                // Print Directory:
                printf("Enter Directory:\n");  
                scanf("%s", input_buffer);
                dmu_print_mtt(input_buffer);
            }
            else if(strcmp(chose, "3") == 0) {
                // Print File
                printf("Enter path:\n");
                scanf("%s", input_buffer);
                
                dmu_print_file( input_buffer );
            }
            else if(strcmp(chose, "5") == 0) {
                printf("Enter Directory:\n");  
                scanf("%s", input_buffer);
                
                lsfs_disk_create_entry(input_buffer, ENTRY_DIRECTORY );
                //lsfs_disk_write_data_to_file(new_id, strlen(new_file_data_d), new_file_data_d);

            }

            #if 0
            else if(strcmp(chose, "2") == 0) {
                // Print Master Tag Table
                printf("Enter Tag ID:\n");
                scanf("%s", input_buffer);
                
                dmu_print_tag_table( (lsfs_tag_id) atoi(input_buffer) );
            }
            else if(strcmp(chose, "4") == 0) {
                // Print Master Tag Table
                printf("Enter Tag name:\n");
                scanf("%s", input_buffer);
                lsfs_disk_create_tag(input_buffer, false);
            }


                printf("Write data:\n");  
                char* new_file_data_d = calloc(1, 4096);
                scanf("%s", new_file_data_d);


            #endif
        }

        if(disk_is_loaded) 
        {
            fclose (disk);
        }
    }
    
    
    return 0;
}