lsfs_16-bit/implementation/lsfs.h

#ifndef LSFS_H
#define LSFS_H
#include "../main.h"


typedef struct lsfs_file lsfs_file;
typedef struct Directory_Table Directory_Table;
typedef struct Table_Entry Table_Entry;

int lsfs_disk_getattr(find_file, path, fsci);
int lsfs_disk_read_data_from_file(file, buffer_size, data,  offset_to_next_entry);
Directory_Table* lsfs_find_directory(path, drop_filename, fsci);

typedef enum Table_Entry_Kind
{
    /* These are specific values since, is has to corrospond to the implementation in assembly*/
    ENTRY_EMPTY = 0,
    ENTRY_FILE = 1,
    ENTRY_DIRECTORY = 2,
} Table_Entry_Kind;

struct Table_Entry 
{
    char    filename[256]; 
    unsigned long    file_id[2];
    unsigned long    file_size[2];
    void*   ext_file_data_low;
    void*   ext_file_data_high;
    long    number_sector_s; /* <- Just try to remove the last undercore and compile .          */
    short   entry_kind;
    short   extra_control_bits1;
    short   extra_control_bits2;
    short   extra_control_bits3;
    long    table_entry_sector_index[2];
    long    data_pointer[NUM_DATA_POINTERS * 2]; /* if it is a directory, the first pointer will be to the next table. */
};

struct lsfs_file {
    unsigned long file_id[2];
    long table_entry_pointer[2];
    Table_Entry_Kind entry_kind;
    char* filename;
    long owner_id;
    unsigned long size[2];
    long creation_date[2]; 
    long access_time[2];
    long modification_time[2];
    long number_sector;
    long table_entry_sector_index[2];
    long data_pointer[NUM_DATA_POINTERS * 2];
};

struct Directory_Table 
{
    Table_Entry entries[DEFAULT_TABLE_SIZE];

}; 

/*typedef struct File_System_Control_Information 
{
    char filesystem_information[256];
    long master_table_index[2];
    long this_partition_offset_on_disk[2];
    long next_free_sector[2];
    long next_uniqe_id[2]; /* both files and directories gets this. 
    long next_sector_reuse_pointer[2];
    long last_sector_index_on_partition[2];
    long maximum_sectors_on_disk[2];
    long sector_size_on_disk[2];
    long not_used[48];

} FSCI;
*/

int lsfs_disk_getattr(find_file, path, fsci) 
lsfs_file* find_file; 
char *path;
FSCI *fsci;
{
    int i;
    String_Array *split_path = string_split_c(path, '/', false);
    Length_String *filename = split_path->strings[split_path->length-1]; 
    
    /* Start from the master table*/
    Directory_Table *dir_table = lsfs_find_directory(path, true, fsci);

    for (i = 0; i < DEFAULT_TABLE_SIZE; i++)
    {
    	int j;
        print(dir_table->entries[i].filename);
        print(filename->chars);
        print_newline();
        print_newline();
        print("Size of table_entry: ");
        dump_ax(sizeof(Table_Entry));
        print_newline();
        print_newline();
        if(strcmp( filename->chars, dir_table->entries[i].filename ) == 0) {
            find_file->file_id[0] = dir_table->entries[i].file_id[0];
            find_file->entry_kind = dir_table->entries[i].entry_kind;
            find_file->table_entry_pointer[0] = i;
            find_file->filename = dir_table->entries[i].filename;
            find_file->table_entry_sector_index[0] = dir_table->entries[i].table_entry_sector_index;
            find_file->owner_id = 1;
            find_file->size[0] = dir_table->entries[i].file_size[0]; /* dir_table->entries[i].data_pointer[0]; ;*/
            find_file->creation_date[0] = 0;
            find_file->access_time[0] = 0;
            find_file->modification_time[0] = 0;
            dump_ax(dir_table->entries[i].data_pointer[0]);
            /* memcpy(find_file->data_pointer, dir_table->entries[i].data_pointer, NUM_DATA_POINTERS * 8); */
            for (j = 0; j < NUM_DATA_POINTERS; j = j + 2)
            {
            	find_file->data_pointer[j] = dir_table->entries[i].data_pointer[j];
            	dump_ax(find_file->data_pointer[j]);
            }


            find_file->number_sector = 1; /* TODO: should be loaded from disk.*/
            return 1;
        }
    }
    return 0;
}

Directory_Table* lsfs_find_directory(path, drop_filename, fsci)
char *path;
short drop_filename; 
FSCI *fsci;
{
    int number_of_traversal;
    int i, j;
    String_Array *split_path;
    Directory_Table *dir_table = calloc(1, sizeof(Directory_Table));
    /* printf("Table index: %lu \n",fsci->master_table_index ); */
    dump_ax(fsci->master_table_index[0]);
    disk_service_read_data_from_disk(fsci->master_table_index[0], (long) DEFAULT_TABLE_SIZE, dir_table, 0x7e0);
    print(dir_table->entries[0].filename);
    split_path = string_split_c(path, '/', false);

    number_of_traversal = split_path->length;
	

    if (drop_filename)
    {
        number_of_traversal -= 1;
    }

    /* Start from the master table */
    for (i = 0; i < number_of_traversal; ++i)
    {
        for (j = 0; j < DEFAULT_TABLE_SIZE; ++j)
        {
        	print_newline();
        	print("New: ");
        	print(dir_table->entries[j].filename);
        	print("vs ");
        	print(split_path->strings[i]->chars);
        	print_newline(); 
            if (strcmp(dir_table->entries[j].filename, split_path->strings[i]->chars) == 0)
            {
                long index_sector = dir_table->entries[j].data_pointer[0];
                /* printf("Table index: %lu \n",index_sector ); */
				/* print(dir_table->entries[j].filename); */
                dump_ax(index_sector);
                disk_service_read_data_from_disk(index_sector, (long) DEFAULT_TABLE_SIZE, dir_table, 0x7e0);
                break;
            }
        }
    }
    return dir_table;
}

int lsfs_disk_read_data_from_file(file, buffer_size, data, offset_to_next_entry, data_segment) 
lsfs_file *file;
unsigned int buffer_size; 
char *data; 
long offset_to_next_entry;
unsigned int data_segment;
{
    unsigned int integer_file_size = file->size[0];
    unsigned int integer_offset = offset_to_next_entry;
    unsigned int integer_datapointer = 0;
    unsigned int data_length = integer_file_size - integer_offset;
    unsigned int amount_read = 0;
    unsigned int amount_to_read = 0;
    unsigned int remaining_offset = offset_to_next_entry;
    void *next_data;
    /* printf("READ: buffer_size: %d\n", buffer_size); */
    /* printf("READ: Data length: %d\n", data_length); */
    /* printf("READ: Offset length: %d\n", offset_to_next_entry); */


    int data_pointer_index = 0; /*  start at first data pointer.  */

    

    if (data_length > buffer_size)
    {
        data_length = buffer_size;
    }

    while(data_length > 0) /*  We have more to write   */
    {
        /* printf("READ: Remaing Data length: %d\n", data_length); */
        if (remaining_offset == 0)
        {
            char *tmp_buffer = calloc(DEFAULT_DATA_POINTER_SIZE, SECTOR_SIZE);
            /* assert(tmp_buffer); */

            if (data_length < (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE)) 
            {
                amount_to_read = data_length;
            }
            else 
            {
                amount_to_read = (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE);
            }
            /* disk_service_read_data_from_disk(lsfs_sector_offset index, uint32_t number_sector, void* data_buffer) */
            integer_datapointer = file->data_pointer[data_pointer_index];
            if (integer_datapointer == 0) 
            {
                break;
            }
            print_newline();
            dump_ax(file->data_pointer[data_pointer_index]);
            print_newline();
            next_data = data + amount_read;
            dump_ax(next_data);
            print_newline();
            disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], (long) DEFAULT_DATA_POINTER_SIZE, next_data, data_segment);
            
            /* memcpy((data + amount_read), data_segment, tmp_buffer, 0x7e0, amount_to_read); */
            
            data_length -= amount_to_read;
            amount_read += amount_to_read;
            data_pointer_index = data_pointer_index + 2; /* Rember that we only use 32-bit, and thats why we jump to at a time*/
            /* free(tmp_buffer); */
        }
        else if (remaining_offset < (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE)) 
        {
            char *tmp_buffer = calloc(1, (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE));
            /* assert(tmp_buffer); */

            if (data_length < ((DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE) - remaining_offset) ) 
            {
                amount_to_read = data_length;
            }
            else 
            {
                amount_to_read = ((DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE) - remaining_offset);
            }

            disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], (long) DEFAULT_DATA_POINTER_SIZE, tmp_buffer, 0x7e0);

            memcpy(data, data_segment, (tmp_buffer + remaining_offset), 0x7e0, amount_to_read);
            data_length -= amount_to_read;
            amount_read += amount_to_read;
            remaining_offset -= amount_to_read;

            data_pointer_index = data_pointer_index + 2; /* Rember that we only use 32-bit, and thats why we jump to at a time*/
            /* free(tmp_buffer); */
        }
        else 
        {
            /*  We have to skip a whole data pointer:  */
            remaining_offset -= (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE);
            data_pointer_index = data_pointer_index + 2;
        }

    }
    /*
    time_t current_time;
    time ( &current_time );
    file->access_time = current_time;
    */
    return amount_read;

}

#endif