fs_layer_2.cpp

Go to the documentation of this file.

 
#include "sfs/fs.h"
#include "sfs/sha256.h"
 
#include <algorithm>
#include <string>
#include <math.h>
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <iostream>
 
#define streq(a, b) (strcmp((a), (b)) == 0)
 
using namespace std;
 
bool FileSystem::set_password(){
    if(!mounted){return false;}
    if(MetaData.Protected) return change_password();
 
    SHA256 hasher;
    char pass[1000], line[1000];
    Block block;
 
    printf("Enter new password: ");
    if (fgets(line, BUFSIZ, stdin) == NULL) return false;
    sscanf(line, "%s", pass);
    
    MetaData.Protected = 1;
    strcpy(MetaData.PasswordHash,hasher(pass).c_str());
    
    // Write chanes back to the disk */
    block.Super = MetaData;
    fs_disk->write(0,block.Data);
    printf("New password set.\n");
    return true;
}
 
bool FileSystem::change_password(){
    if(!mounted){return false;}
 
    if(MetaData.Protected){
        char pass[1000], line[1000];
        SHA256 hasher;
 
        printf("Enter current password: ");
        if (fgets(line, BUFSIZ, stdin) == NULL) return false;
        sscanf(line, "%s", pass);
        
        if(hasher(pass) != string(MetaData.PasswordHash)){
            printf("Old password incorrect.\n");
            return false;
        }
 
        MetaData.Protected = 0;
    }
    return FileSystem::set_password();   
}
 
bool FileSystem::remove_password(){
    if(!mounted){return false;}
 
    if(MetaData.Protected){
        char pass[1000], line[1000];
        SHA256 hasher;
        Block block;
        
        printf("Enter old password: ");
        if (fgets(line, BUFSIZ, stdin) == NULL) return false;
        sscanf(line, "%s", pass);
        
        if(hasher(pass) != string(MetaData.PasswordHash)){
            printf("Old password incorrect.\n");
            return false;
        }
        
        MetaData.Protected = 0;
        
        block.Super = MetaData;
        fs_disk->write(0,block.Data);   
        printf("Password removed successfully.\n");
        
        return true;
    }
    return false;
    
}
 
FileSystem::Directory FileSystem::add_dir_entry(Directory dir, uint32_t inum, uint32_t type, char name[]){
    Directory tempdir = dir;
 
    uint32_t idx = 0;
    for(; idx < FileSystem::ENTRIES_PER_DIR; idx++){
        if(tempdir.Table[idx].valid == 0){break;}
    }
 
    if(idx == FileSystem::ENTRIES_PER_DIR){
        printf("Directory entry limit reached..exiting\n");
        tempdir.Valid = 0;
        return tempdir;
    }
 
    tempdir.Table[idx].inum = inum;
    tempdir.Table[idx].type = type;
    tempdir.Table[idx].valid = 1;
    strcpy(tempdir.Table[idx].Name,name);
 
    return tempdir;
}
 
FileSystem::Directory FileSystem::read_dir_from_offset(uint32_t offset){
    if(
        (offset < 0) ||
        (offset >= ENTRIES_PER_DIR) ||
        (curr_dir.Table[offset].valid == 0) || 
        (curr_dir.Table[offset].type != 0)
    ){Directory temp; temp.Valid=0; return temp;}
 
    uint32_t inum = curr_dir.Table[offset].inum;
    uint32_t block_idx = (inum / FileSystem::DIR_PER_BLOCK);
    uint32_t block_offset = (inum % FileSystem::DIR_PER_BLOCK);
    
    Block blk;
    fs_disk->read(MetaData.Blocks - 1 - block_idx, blk.Data);
    return (blk.Directories[block_offset]);
}
 
void FileSystem::write_dir_back(Directory dir){
    uint32_t block_idx = (dir.inum / FileSystem::DIR_PER_BLOCK) ;
    uint32_t block_offset = (dir.inum % FileSystem::DIR_PER_BLOCK);
 
    Block block;
    fs_disk->read(MetaData.Blocks - 1 - block_idx, block.Data);
    block.Directories[block_offset] = dir;
 
    fs_disk->write(MetaData.Blocks - 1 - block_idx, block.Data);
}
 
int FileSystem::dir_lookup(Directory dir,char name[]){
    uint32_t offset = 0;
    for(;offset < FileSystem::ENTRIES_PER_DIR; offset++){
        if(
            (dir.Table[offset].valid == 1) &&
            (streq(dir.Table[offset].Name,name))
        ){break;}
    }
 
    if(offset == FileSystem::ENTRIES_PER_DIR){return -1;}
 
    return offset;
}
 
bool FileSystem::ls_dir(char name[]){
    if(!mounted){return false;}
 
    int offset = dir_lookup(curr_dir,name);
    if(offset == -1){printf("No such Directory\n"); return false;}
 
    FileSystem::Directory dir = read_dir_from_offset(offset);
 
    if(dir.Valid == 0){printf("Directory Invalid\n"); return false;}
 
    printf("   inum    |       name       | type\n");
    for(uint32_t idx=0; idx<FileSystem::ENTRIES_PER_DIR; idx++){
        struct Dirent temp = dir.Table[idx];
        if(temp.valid == 1){
            if(temp.type == 1) printf("%-10u | %-16s | %-5s\n",temp.inum,temp.Name, "file");
            else printf("%-10u | %-16s | %-5s\n",temp.inum,temp.Name, "dir");
        }
    }
    return true;
}
 
bool FileSystem::mkdir(char name[FileSystem::NAMESIZE]){
    if(!mounted){return false;}
 
    uint32_t block_idx = 0;
    for(;block_idx < MetaData.DirBlocks; block_idx++)
        if(dir_counter[block_idx] < FileSystem::DIR_PER_BLOCK)
            break;
 
    if(block_idx == MetaData.DirBlocks){printf("Directory limit reached\n"); return false;}
 
    Block block;
    fs_disk->read(MetaData.Blocks - 1 - block_idx, block.Data);
 
 
    uint32_t offset=0;
    for(;offset < FileSystem::DIR_PER_BLOCK; offset++)
        if(block.Directories[offset].Valid == 0)
            break;
    
    if(offset == DIR_PER_BLOCK){printf("Error in creating directory.\n"); return false;}
 
    Directory new_dir, temp;
    memset(&new_dir,0,sizeof(Directory));
    new_dir.inum = block_idx*DIR_PER_BLOCK + offset;
    new_dir.Valid = 1;
    strcpy(new_dir.Name,name);
    
    char tstr1[] = ".", tstr2[] = "..";
    temp = new_dir;
    temp = add_dir_entry(temp,temp.inum,0,tstr1);
    temp = add_dir_entry(temp,curr_dir.inum,0,tstr2);
    if(temp.Valid == 0){printf("Error creating new directory\n"); return false;}
    new_dir = temp;
    
    temp = add_dir_entry(curr_dir,new_dir.inum,0,new_dir.Name);
    if(temp.Valid == 0){printf("Error adding new directory\n"); return false;}
    curr_dir = temp;
    
    write_dir_back(new_dir);
 
    write_dir_back(curr_dir);
 
    dir_counter[block_idx]++;
 
    return true;
    
}
 
FileSystem::Directory FileSystem::rmdir_helper(Directory parent, char name[]){
    Directory dir, temp;
    uint32_t inum, blk_idx, blk_off;
    Block blk;
 
    if(!mounted){dir.Valid = 0; return dir;}
 
    int offset = dir_lookup(parent, name);
    if(offset == -1){dir.Valid = 0; return dir;}
 
    inum = parent.Table[offset].inum;
    blk_idx = inum / DIR_PER_BLOCK;
    blk_off = inum % DIR_PER_BLOCK;
    fs_disk->read(MetaData.Blocks - 1 -blk_idx, blk.Data);
 
    dir = blk.Directories[blk_off];
    if(dir.Valid == 0){return dir;}
 
    if(streq(dir.Name,curr_dir.Name)){printf("Current Directory cannot be removed.\n"); dir.Valid=0; return dir;}
 
    for(uint32_t ii=0; ii<ENTRIES_PER_DIR; ii++){
        if((ii>1)&&(dir.Table[ii].valid == 1)){
            temp = rm_helper(dir, dir.Table[ii].Name);
            if(temp.Valid == 0) return temp;
            dir = temp;
        }
        dir.Table[ii].valid = 0;
    }
 
    fs_disk->read(MetaData.Blocks - 1 -blk_idx, blk.Data);
 
    dir.Valid = 0;
    blk.Directories[blk_off] = dir;
    fs_disk->write(MetaData.Blocks - 1-blk_idx, blk.Data);
 
    parent.Table[offset].valid = 0;
    write_dir_back(parent);
 
    dir_counter[blk_idx]--;
 
    return parent;
}
 
FileSystem::Directory FileSystem::rm_helper(Directory dir, char name[FileSystem::NAMESIZE]){
    if(!mounted){dir.Valid = 0; return dir;}
 
    int offset = dir_lookup(dir,name);
    if(offset == -1){printf("No such file/directory\n"); dir.Valid=0; return dir;}
 
    if(dir.Table[offset].type == 0){
        return rmdir_helper(dir,name);
    }
 
    uint32_t inum = dir.Table[offset].inum;
 
    printf("%u\n",inum);
 
    if(!remove(inum)){printf("Failed to remove Inode\n"); dir.Valid = 0; return dir;}
 
    dir.Table[offset].valid = 0;
 
    write_dir_back(dir);
 
    return dir;
}
 
bool FileSystem::rmdir(char name[FileSystem::NAMESIZE]){
    Directory temp = rmdir_helper(curr_dir,name);
    if(temp.Valid == 0){
        curr_dir = temp;
        return true;
    }
    return false;
}
 
bool FileSystem::touch(char name[FileSystem::NAMESIZE]){
    if(!mounted){return false;}
 
    for(uint32_t offset=0; offset<FileSystem::ENTRIES_PER_DIR; offset++){
        if(curr_dir.Table[offset].valid){
            if(streq(curr_dir.Table[offset].Name,name)){
                printf("File already exists\n");
                return false;
            }
        }
    }
    ssize_t new_node_idx = FileSystem::create();
    if(new_node_idx == -1){printf("Error creating new inode\n"); return false;}
 
    Directory temp = add_dir_entry(curr_dir,new_node_idx,1,name);
    if(temp.Valid == 0){printf("Error adding new file\n"); return false;}
    curr_dir = temp;
    
    write_dir_back(curr_dir);
 
    return true;
}
 
bool FileSystem::cd(char name[FileSystem::NAMESIZE]){
    if(!mounted){return false;}
 
    int offset = dir_lookup(curr_dir,name);
    if((offset == -1) || (curr_dir.Table[offset].type == 1)){
        printf("No such directory\n");
        return false;
    }
 
    Directory temp = read_dir_from_offset(offset);
    if(temp.Valid == 0){return false;}
    curr_dir = temp;
    return true;
}
 
bool FileSystem::ls(){
    if(!mounted){return false;}
 
    char name[] = ".";
    return ls_dir(name);
}
 
bool FileSystem::rm(char name[]){
    Directory temp = rm_helper(curr_dir,name);
    if(temp.Valid == 1){
        curr_dir = temp;
        return true;
    }
    return false;
}
 
void FileSystem::exit(){
    if(!mounted){return;}
 
    fs_disk->unmount();
    mounted = false;
    fs_disk = nullptr;
}
 
bool FileSystem::copyout(char name[],const char *path) {
    if(!mounted){return false;}
 
    int offset = dir_lookup(curr_dir,name);
    if(offset == -1){return false;}
 
    if(curr_dir.Table[offset].type == 0){return false;}
 
    uint32_t inum = curr_dir.Table[offset].inum;
 
    FILE *stream = fopen(path, "w");
    if (stream == nullptr) {
        fprintf(stderr, "Unable to open %s: %s\n", path, strerror(errno));
        return false;
    }
 
    char buffer[4*BUFSIZ] = {0};
    offset = 0;
    while (true) {
        ssize_t result = read(inum, buffer, sizeof(buffer), offset);
        if (result <= 0) {
            break;
        }
        fwrite(buffer, 1, result, stream);
        offset += result;
    }
    
    printf("%d bytes copied\n", offset);
    fclose(stream);
    return true;
}
 
bool FileSystem::copyin(const char *path, char name[]) {
    if(!mounted){return false;}
 
    touch(name);
    int offset = dir_lookup(curr_dir,name);
    if(offset == -1){return false;}
 
    if(curr_dir.Table[offset].type == 0){return false;}
 
    uint32_t inum = curr_dir.Table[offset].inum;
 
    FILE *stream = fopen(path, "r");
    if (stream == nullptr) {
        fprintf(stderr, "Unable to open %s: %s\n", path, strerror(errno));
        return false;
    }
 
    char buffer[4*BUFSIZ] = {0};
    offset = 0;
    while (true) {
        ssize_t result = fread(buffer, 1, sizeof(buffer), stream);
        if (result <= 0) {
            break;
    }
 
    ssize_t actual = write(inum, buffer, result, offset);
    if (actual < 0) {
        fprintf(stderr, "fs.write returned invalid result %ld\n", actual);
        break;
    }
 
    offset += actual;
    if (actual != result) {
        fprintf(stderr, "fs.write only wrote %ld bytes, not %ld bytes\n", actual, result);
        break;
    }
    }
    
    printf("%d bytes copied\n", offset);
    fclose(stream);
    return true;
}
 
// Directory stat ------------------------------------------------------------------
 
void FileSystem::stat() {
    if(!mounted){return;}
 
    Block blk;
    fs_disk->read(0,blk.Data);
    printf("Total Blocks : %u\n",blk.Super.Blocks);
    printf("Total Directory Blocks : %u\n",blk.Super.DirBlocks);
    printf("Total Inode Blocks : %u\n",blk.Super.InodeBlocks);
    printf("Total Inode : %u\n",blk.Super.Inodes);
    printf("Password protected : %u\n\n",blk.Super.Protected);
 
    printf("Max Directories per block : %u\n",DIR_PER_BLOCK);
    printf("Max Namsize : %u\n",NAMESIZE);
    printf("Max Inodes per block : %u\n",INODES_PER_BLOCK);
    printf("Max Entries per directory : %u\n\n",ENTRIES_PER_DIR);
 
    for(uint32_t blk_idx=0; blk_idx<MetaData.DirBlocks; blk_idx++){
        fs_disk->read(MetaData.Blocks - 1- blk_idx,blk.Data);
        printf("Block %u\n",blk_idx);
 
        for(uint32_t offset=0; offset<DIR_PER_BLOCK; offset++){
            Directory dir = blk.Directories[offset]; 
            if(dir.Valid){
                printf("    Offset %u: Directory Name - \"%s\"\n",offset,dir.Name);
 
                for(uint32_t tbl_idx=0; tbl_idx < ENTRIES_PER_DIR; tbl_idx++){
                    Dirent ent = dir.Table[tbl_idx];
                    if(ent.valid){
                        printf("        tbl_idx %u: Entry Name - \"%s\", type - %u, inum - %u\n",tbl_idx,ent.Name,ent.type,ent.inum);
                    }
                }
            }
        }
    }
}