dir.cpp

对linuix 文件系统的模拟,包含了若干文件命令

#include "dir.h"
#include <sstream>
#include <string>
#include <fstream>

namespace gilyou
{

dir_t root_dir;
dir_t current_dir;

/************ 根据给定的路径path读入目录文件到 dir************/
uchar read_dir(char path[],dir_t &dir)
{
    dir_t t_dir;
    init_dir(t_dir);
    if(path[0] == '/')
        copy_dir(t_dir,root_dir);
    else
        copy_dir(t_dir,current_dir);
    replace(path,' ','/');
    std::istringstream iss(path);
    char cmd[BUFF_SIZE];
    memset(cmd,'\0',BUFF_SIZE);
    while(!iss.eof()){
        iss>>cmd;
        uchar result = get_dir(cmd,t_dir);
        if(result == NOT_EXISTS){
            print(string_cat(3,"directory $",cmd,"$ not exists."),INDENT | NEW_LINE);
            return NOT_EXISTS;
        }
        else if(result == DISK_BROKEN){
            print("disk broken",INDENT | NEW_LINE);
            return NOT_EXISTS;
        }
        else if(result == AUTH_NEED){
            print("authencation needed.",INDENT | NEW_LINE);
            return NOT_EXISTS;
        }
    }
    copy_dir(dir,t_dir);
    return ALREADY_EXISTS;
}

/************* 根据给定的目录名读入目录文件到 dir ************/
uchar get_dir(char sdir[],dir_t &dir)
{
    for(uint i=0;i<I_DIR_SIZE;i++){
        if(string_equal(dir.idir[i].name,sdir) && dir.idir[i].type == DIRECT_FILE){
            if(bad_disk_block(dir.idir[i].i_number))
                return DISK_BROKEN;
            else{
                di_read(dir.idir[i].i_number,dir);
                return OK;
            }
        }
    }
    return NOT_EXISTS;
}

/******************** dir文件格式 ***************************/
/******************** d_name:creator:i_number:mask:size:ctime:atime:mtime ***************************/
/************ 从第i_number块磁盘读入目录文件到 dir ************/
uchar di_read(uint i_number,dir_t &dir)
{
    init_dir(dir);
    std::ifstream ifs;
    char d_path[18] = "files\\";
    char d_name[6];
    char sufix[6] = ".disk";
    itoa(i_number,d_name,10);
    strcat(d_path,d_name);
    strcat(d_path,sufix);
    ifs.open(d_path,std::ios::in);
    if(ifs.fail()){
        print(string_cat(3,"block $",d_name,"$ broken."),INDENT | NEW_LINE);
        set_broken(i_number);
        ifs.close();
        return READ_FILE_ERROR;
    }
    char buffs[COMMAND_SIZE];
    ifs.getline(buffs,COMMAND_SIZE);
    replace(buffs,' ',':');
    std::istringstream iss(buffs);
    iss>>dir.d_name>>dir.creator>>dir.i_number>>dir.mask>>dir.size>>dir.ctime>>dir.atime>>dir.mtime;
    for(uint i=0;i<I_DIR_SIZE;i++){
        memset(buffs,'\0',COMMAND_SIZE);
        ifs.getline(buffs,COMMAND_SIZE);
        if(buffs[0] == '\0')
            continue;
        replace(buffs,' ',':');
        iss.str(buffs);
        iss.clear();
        iss>>dir.idir[i].name>>dir.idir[i].i_number>>dir.idir[i].type;
        //iss.clear();
    }
    return OK;
}

/************************/
uchar di_write(dir_t dir)
{
    char iarry[6];
    memset(iarry,'\0',6);
    itoa(dir.i_number,iarry,10);
    char fname[18];
    memset(fname,'\0',18);
    strcat(fname,"files\\");
    strcat(fname,iarry);
    strcat(fname,".disk");
    std::ofstream ofs(fname,std::ios::in | std::ios::out | std::ios::trunc);
    if(ofs.fail()){
        set_broken(dir.i_number);
        print(string_cat(3,"disk block $",iarry,"$ broken."),INDENT | NEW_LINE);
        ofs.close();
        return DISK_BROKEN;
    }
    ofs<<dir.d_name<<":"<<dir.creator<<":"<<dir.i_number<<":"<<dir.mask<<":"<<dir.size<<":"<<dir.ctime<<":"<<dir.atime<<":"<<dir.mtime;
    for(uint i=0;i<I_DIR_SIZE - 1;i++)
        if(dir.idir[i].name[0] != '\0')
            ofs<<"\n"<<dir.idir[i].name<<":"<<dir.idir[i].i_number<<":"<<dir.idir[i].type;
    if(dir.idir[I_DIR_SIZE-1].name[0] != '\0')
        ofs<<"\n"<<dir.idir[I_DIR_SIZE-1].name<<":"<<dir.idir[I_DIR_SIZE-1].i_number<<":"<<dir.idir[I_DIR_SIZE-1].type;
    ofs.flush();
    ofs.close();
    //set_inode(dir.i_number);
    return OK;
}

uchar copy_dir(dir_t &dir,dir_t cdir)
{
    dir.atime = cdir.atime;
    dir.ctime = cdir.ctime;
    dir.mtime = cdir.mtime;
    strcpy(dir.creator,cdir.creator);
    strcpy(dir.d_name,cdir.d_name);
    dir.mask = cdir.mask;
    dir.size = cdir.size;
    dir.i_number = cdir.i_number;
    for(uint i=0;i<I_DIR_SIZE;i++)
        copy_idir(dir.idir[i],cdir.idir[i]);
    return OK;
}

void copy_idir(idir_t &idir,idir_t cidir)
{
    idir.i_number = cidir.i_number;
    idir.type = cidir.type;
    strcpy(idir.name,cidir.name);
}

/*************** 将磁盘镜像读入disks *****************/
uchar get_map(disk_t disks[])
{
    init_disks(disks);
    std::ifstream ifs;
    ifs.open("sys\\disks.map",std::ios::in | std::ios::out);
    if(ifs.fail()){
        print("open file sys\\disks.map failed.",INDENT | NEW_LINE);
        ifs.close();
        return READ_FILE_ERROR;
    }
    char buffs[COMMAND_SIZE];
    memset(buffs,'\0',COMMAND_SIZE);
    ifs.getline(buffs,COMMAND_SIZE);
    replace(buffs,' ',':');
    std::istringstream iss(buffs);
    replace(buffs,' ',':');
    for(uint i=0;i<DISK_BLOCK_SIZE;i++)
        iss >> disks[i];
    ifs.close();
    return OK;
}

uchar get_bad_map(disk_t disks[])
{
    init_disks(disks);
    std::ifstream ifs;
    ifs.open("sys\\disks.bad",std::ios::in | std::ios::out);
    if(ifs.fail()){
        print("open file sys\\disks.bad failed.",INDENT | NEW_LINE);
        ifs.close();
        return READ_FILE_ERROR;
    }
    char buffs[COMMAND_SIZE];
    memset(buffs,'\0',COMMAND_SIZE);
    ifs.getline(buffs,COMMAND_SIZE);
    replace(buffs,' ',':');
    std::istringstream iss(buffs);
    for(uint i=0;i<DISK_BLOCK_SIZE;i++)
        iss >> disks[i];
    ifs.close();
    return OK;
}

/*************** 将disks写入磁盘镜像 *****************/
void set_map(disk_t disks[])
{
    std::ofstream ofs;
    ofs.open("sys\\disks.map",std::ios::out);
    if(ofs.fail()){
        print("open file sys\\disks.map failed.",INDENT | NEW_LINE);
        ofs.close();
        return;
    }
    for(uint i=0;i<DISK_BLOCK_SIZE-1;i++)
        ofs<<disks[i]<<":";
    ofs<<disks[DISK_BLOCK_SIZE-1];
    ofs.flush();
    ofs.close();
}

void set_bad_map(disk_t disks[])
{
    std::ofstream ofs;
    ofs.open("sys\\disks.bad",std::ios::out);
    if(ofs.fail()){
        print("open file sys\\disks.bad failed.",INDENT | NEW_LINE);
        ofs.close();
        return;
    }
    for(uint i=0;i<DISK_BLOCK_SIZE-1;i++)
        ofs<<disks[i]<<":";
    ofs<<disks[DISK_BLOCK_SIZE-1];
    ofs.flush();
    ofs.close();
}

void set_broken(uint i_number)
{
    disk_t disks[DISK_BLOCK_SIZE];
    init_disks(disks);
    get_bad_map(disks);
    disk_t bad_disk = 1;
	uint row = i_number / (sizeof(disk_t)*8);
	uint colum = i_number % (sizeof(disk_t)*8);
    bad_disk = bad_disk << colum;
    disks[row] = disks[row] | bad_disk;
    set_bad_map(disks);
}

bool bad_disk_block(uint i_number)
{
    disk_t disks[DISK_BLOCK_SIZE];
    init_disks(disks);
    get_bad_map(disks);
    uint row = i_number / (sizeof(disk_t)*8);
	uint colum = i_number % (sizeof(disk_t)*8);
    disk_t disk = 1;
    disk = disk << colum;
    return (disks[row] & disk) == disk ? true : false;
}

void init_dir(dir_t &dir)
{
    dir.atime = 0;
    memset(dir.creator,'\0',BUFF_SIZE);
    memset(dir.d_name,'\0',BUFF_SIZE);
    dir.ctime = 0;
    dir.i_number = 0;
    dir.mask = 0;
    dir.mtime = 0;
    dir.size = 0;
    init_idir(dir.idir);
}

void init_idir(idir_t idir[])
{
    for(uint i=0;i<I_DIR_SIZE;i++){
        idir[i].i_number = 0;
        memset(idir[i].name,'\0',BUFF_SIZE);
        idir[i].type = DIRECT_FILE;
    }
    strcpy(idir[0].name,".");
    strcpy(idir[1].name,"..");
}

void recycle(dir_t dir,uint &count)
{
    dir_t cdir;
    init_dir(cdir);
    for(uint i=2;i<I_DIR_SIZE;i++){
        if(dir.idir[i].name[0] != '\0'){
            di_read(dir.idir[i].i_number,cdir);
            count ++;
            recycle(cdir,count);
        }
    }
    set_inode(dir.i_number,NOT_DELETED);
}


}