root/tarfs/tarfs.c

#include <stdlib.h>
#include <stdio.h>

#include <errno.h>
#include <fcntl.h>

#include <string.h>
#include <unistd.h>
#include <ctype.h>

#include <fuse.h>

#include "tar.h"

#define BLOCK_SIZE  512
#define HEADER_SIZE 500
#define NAME_SIZE   100
#define true        1
#define false       0
#define eprintf(...) fprintf(stderr, __VA_ARGS__)

FILE *error_log;

typedef struct posix_header posix_header;
typedef char bool;

typedef struct inode inode;

struct inode{
        inode *next;
        inode *subdir; // null if not a directory

        char file_name[NAME_SIZE];
        
        unsigned long block_offset;

        int block_length;
        int file_length;

        bool special; // if . or ..
};

FILE  *tar_file;
inode *file_tree;

inode *create_dir(inode *parent){
        inode *me=malloc(sizeof(inode));
        inode *up=malloc(sizeof(inode));
        me->special=true;
        me->file_name[0]='.';
        me->file_name[1]='\0';
        me->subdir=me;
        me->next=up;

        up->special=true;
        up->file_name[0]='.';
        up->file_name[1]='.';
        up->file_name[2]='\0';
        up->subdir=parent;
        up->next=NULL;

        return me;
}

static int tarfs_open(const char *file_path, struct fuse_file_info *fi)
{
        if((fi->flags & 3) != O_RDONLY )
        {
                return -EACCES;
        }
        return 0;
}

static int tarfs_readdir(const char *file_path, void *buffer, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi){
        char *result;
        char delims[]="/";
        inode *i=file_tree, *node;

        /* Traverse the file tree */
        result=strtok(++file_path, delims);
        while( result != NULL ){
                while(i){
                        if(!strcmp(result, i->file_name)){
                                if(i->subdir){
                                        i=i->subdir;
                                        break;
                                }
                                else{
                                        return -ENOENT;
                                }
                        }
                        i=i->next;
                }
                result=strtok(NULL, delims);
        }

        while(i){
                filler(buffer,i->file_name,NULL,0);
                i=i->next;
        }
        
        return 0;
}

static int tarfs_getattr(const char *file_path, struct stat *stbuf)
{
        char *result;
        char delims[]="/";
        inode *i=file_tree, *node;
        int res = 0;
        memset(stbuf, 0, sizeof(struct stat));
        stbuf->st_nlink = 1;

        result=strtok(++file_path, delims);
        while( result != NULL ){
                while(i){
                        if(!strcmp(result, i->file_name)){
                                if(i->subdir){
                                        i=i->subdir;
                                        break;
                                }
                                else{
                                        node=i;
                                        goto is_file;
                                }
                        }
                        i=i->next;
                }
                if(!i) return -ENOENT;
                result=strtok(NULL, delims);
        }
        
        stbuf->st_mode = S_IFDIR | 0555;
        stbuf->st_size = BLOCK_SIZE;
        return res;

is_file:
        stbuf->st_mode = S_IFREG | 0555;
        stbuf->st_size = i->file_length;
        return res;
}

static int tarfs_read(const char *file_path, char *buffer, size_t size, off_t offset, struct fuse_file_info *fi){
        char *result;
        char delims[]="/";
        inode *i=file_tree, *node;
        size_t len;

        /* Traverse the file tree */
        result=strtok(++file_path, delims);
        while( result != NULL ){
                while(i){
                        if(!strcmp(result, i->file_name)){
                                if(i->subdir){
                                        i=i->subdir;
                                        break;
                                }
                                else{
                                        node=i;
                                        goto read;
                                }
                        }
                        i=i->next;
                }
                result=strtok(NULL, delims);
        }

        return -ENOENT;

read:
        /* Get the file length */
        len=node->file_length;
        if (offset > len) return 0;


        fseek(tar_file, node->block_offset + offset, SEEK_SET);
                
        if( size + offset > len ) size=len-offset;
        
        size = fread(buffer, sizeof(char), size, tar_file);
                
        fflush(tar_file);

        return size;
}

inode *tarfs_init(FILE *file){
        char buffer[BLOCK_SIZE];
        char *result;
        char delims[]="/";
        posix_header header;
        inode *i, *last_i, *new;

        /* Create a root directory of the tree */
        file_tree=create_dir(NULL);

        while(true){
                fread(buffer, sizeof(char), BLOCK_SIZE, file);
                memcpy(&header, buffer, HEADER_SIZE);


                /* Check that the header is valid */
                if(!memcmp(header.magic,"\0\0\0\0\0",5)) break;

                if(memcmp(header.magic,"ustar",5)) return NULL;

                /* Create the next inode */
                new=malloc(sizeof(inode));      
                
                /* Traverse the file tree */
                result=strtok(header.name, delims);
                i=file_tree;
                while( result != NULL ){
                        
                        while(i){
                                if(i->subdir){
                                        if(!strcmp(i->file_name,result)){
                                                i=i->subdir;
                                                break;
                                        }
                                }
                                last_i=i;
                                i=i->next;
                        }
                        if(!i){
                                last_i->next=new;
                                break;
                        }
                        result=strtok(NULL, delims);
                }

                if( !result )
                        if( header.typeflag == '5' )
                                continue;
                        else
                                return NULL;
        /* Add inode attributes */ int name_size=strlen(result); memmove(new->file_name, result, name_size); new->file_name[name_size]='\0';
                
                switch(header.typeflag){
                case '\0':
                case '0':
                        new->subdir=NULL;
                        break;
                case '5':
                        new->subdir=create_dir(new);
                        break;
                default:
                        return NULL;
                }
                
                /* Read in the file's data */
                sscanf(header.size,"%o",&new->file_length);
                new->block_length=(new->file_length + 511 ) & ~511;
                new->next=NULL;
                new->block_offset=ftell(file);
                
                /* Jump to the next header */   
                fseek(file, new->block_length, SEEK_CUR);

        }
        fflush(file);
        return file_tree;
}

void tarfs_destroy_internal(inode *_file_tree){
        inode *i=_file_tree, *j;

        while(i){
                if(i->subdir && !i->special )
                        tarfs_destroy_internal(i->subdir);
                j=i;
                i=i->next;
                free(j);
        }
        fflush(stdout);
}

void tarfs_destroy(){
        tarfs_destroy_internal(file_tree);
}

void tarfs_print(inode *file_tree, int tab){
        inode *i=file_tree;

        int temp=tab;
        char *tabs=malloc(temp+1);
        tabs[temp]='\0';
        while(temp--) tabs[temp]=' ';
        
        while(i){
                printf("%s%s (offset=%i, length=%i)\n",tabs,i->file_name,i->block_offset,i->file_length);
                if( i->subdir && !i->special )
                        tarfs_print(i->subdir, tab+3);
                i=i->next;
        }
        free(tabs);
}

static struct fuse_operations tarfs_oper = {
        .getattr =  tarfs_getattr,
        .read = tarfs_read,
        .open = tarfs_open,
        .readdir = tarfs_readdir,
        .destroy = tarfs_destroy
};

int main(int argc, char **argv){
        /* Parse filepath and initialize the file tree */
        if( argc != 3 ){
                eprintf("Use: %s directory filepath\n", argv[0]);
                return 1;
        }

        tar_file = fopen(argv[2], "r");
        if( !tar_file ){
                eprintf("Invalid filename: %s\n", argv[2]);
                return 1;
        }
        
        file_tree=tarfs_init(tar_file);
        if( !file_tree ){
                eprintf("Invalid filetype: %s\n", argv[2]);
                return 1;
        }
        
        return fuse_main(argc-1, argv, &tarfs_oper);
}