global.cpp

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

#include "global.h"
#include <dos.h>
#include <conio.h>
#include <windows.h>
#include <sstream>
#include <string.h>
#include "define.h"
#include <math.h>
#include <fstream>
#include <stdarg.h>



namespace gilyou
{

/************* 读取用户名 *******************/
int  read_name(char name[])
{
    for(uint i=0;i<BUFF_SIZE;i++){
        name[i] = getchar();
        if(name[i] == '\n'){
            name[i] = '\0';
            break;
        }
    }
    if(string_equal(name,"exit"))
        exit(OK_EXIT);
    return SUCCESS;
}

/************* 读取用户密码，代替显示echo_char *******************/
int  read_passwd(char passwd[], char echo_char)
{
    char input;
    int index = 0;
    while((input = getch()) != '\r')
    {
        passwd[index++] = input;
        std::cout<<echo_char;
    }
    passwd[index] = '\0';
    std::cout<<std::endl;
    return SUCCESS;
}

/****************** 判断两字符串是否相等 **********************/
bool string_equal(char dest[],char src[])
{
    #if DEBUG
    print(string_cat(2,"dest = ",dest),INDENT | NEW_LINE);
    print(string_cat(2,"src = ",src),INDENT | NEW_LINE);
    #endif

    return strcmp(dest,src)==0?true:false;
}

/****************** 返回一个未使用的磁盘块 ************************/
uint get_inode()
{
    disk_t disks[DISK_BLOCK_SIZE];
    init_disks(disks);
    get_map(disks);
    for(uint i=0;i<DISK_BLOCK_SIZE;i++){
        //print(i);
        //print("\n  ");
        for(uint j=0;j<sizeof(disk_t)*8;j++){
            //print(j);
            //print(" ");
            if(((disks[i] >> j) & 1) != 1)
                return (i * sizeof(disk_t) * 8 + j);
        }
        //print('\n');
    }
    return INODE_EMPTY;
}

void set_inode(uint i_number,uint inode)
{
    disk_t disks[DISK_BLOCK_SIZE];
    init_disks(disks);
    get_map(disks);
    uint row = i_number / (sizeof(disk_t)*8);
    uint colum = i_number % BUFF_SIZE;
    if(inode == ALREADY_USED){
        inode <<= colum;
        disks[row] |= inode;
    }
    else{
        inode = ALREADY_USED;
        inode <<= colum;
        inode = ~inode;
        disks[row] &= inode;
    }
    set_map(disks);
    //return OK;
}

void  full_screen()
{
    typedef BOOL (WINAPI *PROCGETCONSOLEDISPLAYMODE)(LPDWORD);
    typedef BOOL (WINAPI *PROCSETCONSOLEDISPLAYMODE)(HANDLE,DWORD,LPDWORD);
    PROCGETCONSOLEDISPLAYMODE GetConsoleDisplayMode;
    PROCSETCONSOLEDISPLAYMODE SetConsoleDisplayMode;
    DWORD dwNewMode=1; DWORD dwOldMode=0;
    HMODULE hKernel32 = GetModuleHandle("kernel32");
    if (!hKernel32) return;
    GetConsoleDisplayMode = (PROCGETCONSOLEDISPLAYMODE) GetProcAddress(hKernel32,"GetConsoleDisplayMode");
    if (!GetConsoleDisplayMode) return;
    SetConsoleDisplayMode = (PROCSETCONSOLEDISPLAYMODE) GetProcAddress(hKernel32,"SetConsoleDisplayMode");
    if (!SetConsoleDisplayMode) return;
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleDisplayMode(hOut,dwNewMode,&dwOldMode);
    GetConsoleDisplayMode(&dwOldMode);
}

/****************** 权限审查 ***********************/
uchar auth_check(uint uid,uint mask)
{
    if(uid == 0x0000)
        return (AUTH_READ | AUTH_WRITE | AUTH_EXEC);
    if((uid & (mask >> MASK_BITS)) == uid)
        return ((mask & SELF_AUTH) >> (GROUP_BITS | OTHER_BITS));
    if((uid & (mask >> MASK_BITS + UID_BITS)) == uid)
        return ((mask & GROUP_AUTH) >> OTHER_BITS);
    return (mask & OTHER_AUTH);
}

int login(char name[],char passwd[],user_t &usr)
{
    user_t user;
    int result = get_usr(name,passwd,user);
    copy_usr(usr,user);
    return result;
}

void welcome()
{
    system("cls");
    print("welcome ",INDENT);
    print(current_usr.uname,GENERIC);
    print(" , last login at ",GENERIC);
    time_t atime= current_usr.atime;
    print(ctime(&atime),NEW_LINE);
}

int run()
{
    init_system();
    welcome();
    char args[BUFF_SIZE*2];
    char cmd[BUFF_SIZE];
    char command[COMMAND_SIZE];
    bool NOT_EXIT = true;
    char hint[2];
    hint[0] = current_usr.uid == 0?'#':'$';
    hint[1] = '\0';
    do{
        print(string_cat(9,"[",current_usr.uname,"@",HOST_NAME," ",current_dir.d_name,"] ",hint,":"));
        if(read_command(command) == ENTER)
            continue;
        switch(judge_command(command,cmd,args)){
            case COMMAND_EXIT:NOT_EXIT = false;break;
            case COMMAND_CD:do_cd(args);break;
            case COMMAND_CP:do_cp(args);break;
            case COMMAND_MKDIR:do_mkdir(args);break;
            case COMMAND_RMDIR:do_rmdir(args);break;
            case COMMAND_CHMOD:do_chmod(args);break;
            case COMMAND_DELUSR:do_delusr(args);break;
            case COMMAND_ADDUSR:do_addusr(args);break;
            case COMMAND_MV:do_mv(args);break;
            case COMMAND_HISTORY:history();break;
            case COMMAND_VERSION:version();break;
            case COMMAND_SYNC:sync();break;
            case COMMAND_FULLSCREEN:full_screen();break;
            case COMMAND_CLEAR:clear();break;
            case COMMAND_LS:do_ls(args);break;
            case COMMAND_LOGOUT:clear();return LOGOUT;break;
            default:print(string_cat(3,"command $",cmd,"$ not found."),INDENT | NEW_LINE);
        }
    }while(NOT_EXIT);
    return OK_EXIT;
}

int read_command(char command[])
{
    uint index = 0;
	char pre_char = ' ';
	bool NOT_EXIT = true;
	memset(command,'\0',COMMAND_SIZE);
	memset(hists[hist_ptr],'\0',BUFF_SIZE);
	for(index = 0;index<(BUFF_SIZE*2-1) && NOT_EXIT;index++){
		command[index] = std::cin.get();
		switch(command[index]){
		case '\n':
            command[index] = '\0';
			NOT_EXIT = false;
			break;
		case ' ':
			if(pre_char == ' ' || pre_char == '-' || pre_char == '/')
				index--;
			else
				pre_char = command[index];
			break;
		default:
			pre_char = command[index];
		}
	}
	if(command[0] == '!'){
	    int icom;
	    char numarray[BUFF_SIZE];
	    for(uint i=0;i<BUFF_SIZE && command[i+1] != '\0';i++){
            numarray[i] = command[i+1];
            if(!isdigit(numarray[i]))
                return COMMAND_NOT_DEFINED;
	    }
        icom = atoi(numarray);
        if(icom < 0 || icom >10)
            return COMMAND_NOT_DEFINED;
        strcpy(command,hists[icom]);
	}
    if(string_equal(command,"exit"))
        exit(OK_EXIT);
	strcpy(hists[hist_ptr],command);

	#if DEBUG
	print(string_cat(2,"hists = ",hists[hist_ptr]),INDENT | NEW_LINE);
	print(string_cat(2,"comamnd = ",command),INDENT | NEW_LINE);
	#endif

	hist_ptr = (hist_ptr + 1) % (BUFF_SIZE / 2);

	return index;
}

int judge_command(char command[],char cmd[],char args[])
{
    memset(cmd,'\0',BUFF_SIZE);
    memset(args,'\0',BUFF_SIZE);
    std::istringstream iss(command);
    iss>>cmd;
    if(string_equal(command,cmd))
        args[0] = '\0';
    else
        strcpy(args,((iss.str()).substr(strlen(cmd)+1)).c_str());

    #if DEBUG
    print(string_cat(2,"command = ",command));
    print(string_cat(2,"cmd = ",cmd));
    print(string_cat(2,"args = ",args));
    #endif

    if(string_equal(cmd,"cd"))
        return COMMAND_CD;
    if(string_equal(cmd,"cp"))
        return COMMAND_CP;
    if(string_equal(cmd,"mv"))
        return COMMAND_MV;
    if(string_equal(cmd,"addusr"))
        return COMMAND_ADDUSR;
    if(string_equal(cmd,"delusr"))
        return COMMAND_DELUSR;
    if(string_equal(cmd,"mkdir"))
        return COMMAND_MKDIR;
    if(string_equal(cmd,"rmdir"))
        return COMMAND_RMDIR;
    if(string_equal(cmd,"history"))
        return COMMAND_HISTORY;
    if(string_equal(cmd,"exit"))
        return COMMAND_EXIT;
    if(string_equal(cmd,"chmod"))
        return COMMAND_CHMOD;
    if(string_equal(cmd,"fulsen"))
        return COMMAND_FULLSCREEN;
    if(string_equal(cmd,"sync"))
        return COMMAND_SYNC;
    if(string_equal(cmd,"version"))
        return COMMAND_VERSION;
    if(string_equal(cmd,"clear"))
        return COMMAND_CLEAR;
    if(string_equal(cmd,"ls"))
        return COMMAND_LS;
    if(string_equal(cmd,"logout"))
        return COMMAND_LOGOUT;
    return COMMAND_NOT_DEFINED;
}

uint replace(char char_array[],char char_for_replace,char char_to_be_replaced)
{
	int len = strlen(char_array);
	int i;
	for(i=0;i<len;i++)
		if(char_array[i] == char_to_be_replaced)
			char_array[i] = char_for_replace;
	return i;
}

std::string string_cat(int count,char strings[]...)
{
    std::ostringstream oss;
    va_list ap;
    va_start(ap,strings);
    oss<<strings;
    for(int i=1;i<count;i++)
        oss<<va_arg(ap,char *);
    va_end(ap);
    return oss.str();
}

void init_system()
{
    print("initalizing system...");
    //delay(2000);
    print("\n");
    print("initalizing root directory...");
    //delay(2000);
    print("\n");
    init_root();
    print("initalizing current directory...");
    //delay(2000);
    print("\n");
    init_current_directory(current_usr.ihome);
    /******************************  暂时省去测试磁盘文件  ******************************/
    ulong len = static_cast<ulong>(sizeof(disk_t)*8*DISK_BLOCK_SIZE);
    system("IF NOT EXIST files MKDIR files");
    char files[18];
    char sufix[6] = ".disk";
    sufix[5] = '\0';
    char iarry[6];
    for(uint i=0;i<len;i++){
        memset(iarry,'\0',6);
        itoa(i,iarry,10);
        memset(files,'\0',18);
        strcat(files,"files\\");
        strcat(files,iarry);
        strcat(files,sufix);
        std::ifstream ifs;
        ifs.open(files,std::ios::in);
        if(ifs.fail()){
            ifs.clear();
            ifs.close();
            if(mkfile(files) == NOT_EXISTS)
                set_broken(uint(i));
        }
        ifs.close();
    }
    print("\n");
}

void delay(int msec)
{
    char amsec[BUFF_SIZE];
    itoa(msec,amsec,10);
    std::string cmd = string_cat(2,"bin\\delay.exe ",amsec);
    system(cmd.c_str());
}

uchar mkfile(char f_name[],bool alarm)
{
    std::ofstream ofs;
    ofs.open(f_name);
    if(ofs.fail()){
        if(alarm)
            print(string_cat(3,"file $",f_name,"$ not exists."),INDENT | NEW_LINE);
        ofs.close();
        return NOT_EXISTS;
    }
    if(alarm)
        print(string_cat(3,"file $",f_name,"$ already exists."),INDENT | NEW_LINE);
    ofs.close();
    return ALREADY_EXISTS;
}

void init_root()
{
    di_read(0,root_dir);
    bool mkhome = true;
    for(uint i=2;i<I_DIR_SIZE;i++)
        if(string_equal(root_dir.idir[i].name,"home")){
            mkhome = false;
            break;
        }
    if(mkhome){
        char home[2] = "/";
        mkdir(home,"home");
    }
}

void init_current_directory(uint i_number)
{
    di_read(i_number,current_dir);
}

int replace_last(char carry[],char for_place,char to_be_placed)
{
    int result = -1;
    for(int i=strlen(carry)-1;i>=0;i--)
        if(carry[i] == to_be_placed){
            carry[i] = for_place;
            result = i;
            break;
        }
    return result;
}

void init_disks(disk_t disks[])
{
    for(uint i=0;i<DISK_BLOCK_SIZE;i++)
        disks[i] = 0;
}

}