多用户多级目录文件系统的实现(代码+视频+报告+PPT)课程设计课程名称操作系统题目名称多用户多级目录文件

课程设计

课程名称 操作系统

题目名称 多用户多级目录文件系统的实现

学生学院 计算机学院

指导教师

年 1 月

需求分析
1. 课题要求
  本课程设计要求设计一个模拟的多用户多级目录的文件系统。通过具体的文件存储空间的管理、文件的物理结构、目录结构和文件操作的实现，加深对文件系统内部功能和实现过程的理解。
2. 设计要求
在内存中开辟一个虚拟磁盘空间作为文件存储器，在其上实现一个多用户多目录的文件系统；
文件物理结构采用隐式链接方式；
磁盘空闲空间的管理选择位示图方式；
文件目录结构采用多用户多级目录结构，每个目录项包含文件名、物理地址、长度等信息，还可以通过目录项实现对文件的读和写的保护；
设计一个较实用的用户界面，方便用户使用，提供较丰富的文件操作。
运行环境分析
本次采用macOS 10.12.系统（类Unix）进行开发，基于Xcode&Vim开发一个模拟的多用户多级目录的文件系统。
开发工具简介
Xcode 是运行在操作系统Mac OS X上的集成开发工具（IDE），由苹果公司开发。Xcode是开发OS X 和 iOS 应用程序的最快捷的方式。Xcode 具有统一的用户界面设计，编码、测试、调试都在一个简单的窗口内完成。
Vim是一个类似于Vi的著名的功能强大、高度可定制的文本编辑器，在Vi的基础上改进和增加了很多特性。VIM是自由软件。

系统设计
1. 整体设计思想
  在内存中开辟1MB的空间来模拟多用户多级目录的文件系统。第一部分存放位示图，位示图元素类型为char，第二部分存放盘块信息。
  盘块区域分2040个盘块，每块512B，一共1020KB。位示图元素个数为2040/8 = 255B = 0.25KB。

图 Chapter-1 空间分配图
系统初次运行时，首先进行系统初始化，包括申请内存空间、初始化位示图、初始化盘块文件、创建管理员账号。
首先进行登录判断，若密码正确则进入文件操作系统，若密码错误，则提示重新输入，直至密码正确。
当用户执行操作指令时，检查该操作指令是否是特殊指令，若是，则检查其用户权限，若是管理员，则执行，否则不执行。当是普通操作指令时，则不进行检查，直接执行。
普通指令操作包括文件的创建、删除、写入、打开、关闭；目录的创建、切换、显示；用户的登录、用户的退出。
特殊指令操作包括用户的注册、位示图的显示、已注册用户列表的查看。

图 Chapter-2 系统运行图

1. 数据结构设计
  依据本课程设计要求，设计一个文件系统结构体、一个用于记录用户信息的主文件目录结构体、一个目录结构体、一个文件结构体以及一个盘块结构体。
  其中文件结构体分为文件信息结构体和文件内容结构体。
  文件系统结构体
  struct SYSTEM
  {
  char *start; //该文件系统起始地址
  long size; //该文件系统容量
  int disk_block_number; //文件系统中盘块的个数
  struct DISK *disk_head; //文件系统中盘块首地址
  };
  主文件目录结构体
  struct MFD //主文件目录，包含用户名、密码、指向用户目录的指针
  {
  char username[24]; //用户名
  char password[24]; //用户密码
  char right; //用户权限,1表示管理员，0表示一般用户
  struct MFD *next; //指向同级下一个用户的指针
  struct MULU *link; //指向该用户的文件目录指针
  };
  目录结构体
  struct MULU //目录结构体
  {
  char dirname[1024]; //目录名
  struct MULU *next; //指向同级的下一个目录的指针
  struct MULU *pre; //指向目录的父目录
  struct MULU *linkDir; //指向目录的子目录
  struct FIS *linkFile; //指向目录的文件
  };
  文件信息结构体
  struct FIS //文件信息结构体 File Information structe
  {
  char fileName[1024]; //文件名
  struct FIS *next; //指向同级的下一个文件的指针
  struct FCS *fileContex; //指向文件信息
  };
  文件内容结构体
  struct FCS //文件内容结构体 File Content structe
  {
  size_t size ; //文件大小
  char context[2048]; //文件内容
  char permissions[3];// 属性，读写执行,只计前3位
  int isOpen; //文件是否被打开
  struct DISK *disk; //指向所占的盘块链
  };
  盘块结构体
  struct DISK //盘块结构体
  {
  int diskNumber; //盘块号盘块号从1开始但是数组下标从0开始
  int diskSize; //盘块容量
  char *diskAddr; //盘块空间起始地址
  struct DISK *next; //指向下一个盘块
  };
2. 系统功能设计

基于课程设计的要求，为该系统提供以下操作。其中register指令、showbp指令、who指令当且仅当以管理员身份登录才有权限执行。

使用方式 help
文件创建 create [File] [rwx]
打开文件 open [File]
关闭文件 close [File]
删除文件 delete [File]
文件的读 read [File]
文件的写 write [File]
创建目录 mkdir [DirName]
改变当前目录 cd [DirName]
显示当前路径 pwd
列出文件目录 dir [DirName]
清除屏幕 clear
登录用户 login [userName] [passWord]
注册用户 register [userName] [passWord]
查看位示图 showbp
查看已注册的用户 who
退出 logout
用户界面设计
由于本系统是在Mac OS X下完成的，在一定程度上参考了Terminal的风格，所以用户设计界面方式为命令交互方式，命令操作方式大致与其相同。

图 Chapter-3 用户界面设计图

系统实现
1. 初始化功能
  首先进行空间内存申请，为位示图和盘块信息分配对应的空间。其次是为该系统创建一个管理员账号，拥有不同于其他普通用户的权限。

图 Chapter-4 初始化功能

1. 登录功能
  首先将指令分割，得到输入的账号密码，接着在系统中已注册的用户中进行遍历搜索，判断账号与密码是否一致。若一致，则返回成功，否则返回失败。

图 Chapter-5 用户登录功能

1. 注册功能
  首先将指令分割，得到输入的账号密码，接着在系统中已注册的用户中进行遍历搜索，判断账号是否已存在，若存在，则注册失败，否则，注册成功，将该用户插入到已注册用户链表中，并为其创建一个用户目录。

图 Chapter-6 用户注册功能

1. 创建文件功能
  首先获取需要创建的文件名，对当前目录下的文件进行遍历，若找到相同名字的文件名，则返回失败信息。
  否则检查位示图，查看是否有剩余盘块可供使用，若有剩余，则找到这个盘块地址，并设置文件相关信息，包括文件名，文件权限等。

图 Chapter-7 创建文件功能

1. 删除文件功能
  删除文件时，首先检查是否有该文件，若存在该文件，则清空文件结构体，包括文件信息结构体以及文件内容结构体，并释放空间。
  接着进行回收盘块，并置位示图对应盘块号为空闲状态，编号为0。

图 Chapter-8 删除文件功能

1. 写入文件功能
  首先，检查是否存在该文件，若存在，则打开该文件。判断写入的数据信息大小是否超过一个盘块，若超过则为其分配其他盘块，并置位示图中对应盘块编号为1。并记录文件大小信息以及文件数据信息。

图 Chapter-9 写入文件功能

1. 打开文件功能
  文件结构体中有一个isOpen的变量，当该变量为1时，则表示文件被打开；当该变量为0时，则表示文件被关闭。
  当需要打开文件时，则检查是否存在该文件，若存在，则将变量isOpen置为1状态即可。
2. 关闭文件功能
  文件结构体中有一个isOpen的变量，当该变量为1时，则表示文件被打开；当该变量为0时，则表示文件被关闭。
  当需要关闭文件时，则检查是否存在该文件，若存在，则将变量isOpen置为0状态即可。
3. 创建目录功能
  首先检查当前子目录下是否存在相同名称的目录，若不存在，则创建一个新的子目录，并将该新的子目录插入到当前目录的子目录链表中。

图 Chapter-10 创建目录功能

1. 改变目录功能
  改变目录分为多种方式，第一种是返回到上层目录，只需要将当前工作目录跳转到其父目录即可。
  第二种是返回用户根目录，此时只需要返回到用户工作目录即可。
  第三种是进入其子目录，这种情况下，要遍历其子目录，找到对应名称的目录，并将当前工作目录设置为该子目录。

图 Chapter-11 改变目录功能

1. 显示路径功能
  在每次改变目录的时候，会自动记录当前工作目录，并将当前工作目录路径赋值给一个全局变量，当用户执行显示路径pwd指令时，输出该变量内容。
2. 列出文件目录功能
  获取当前工作目录，并依次输出其子目录列表以及文件列表。对子目录列表和文件列表进行遍历查询，直到子目录指针或者文件指针为空为止。
3. 查看位示图功能
  该功能仅限于管理员才可查看。首先根据位示图的元素个数进行遍历，在子循环中，检查每个元素的每一位Bit的状态，相应地输出。

图 Chapter-12 查看位示图功能

1. 查看注册用户功能
  该功能仅限管理员可使用。该功能比较简单，只需要找到已注册文件列表，并遍历搜索并输出即可，直到遍历到最末端。
运行情况
1. 管理员登录情况

1. 注册用户情况

1. 写入文件情况

1. 删除文件情况

1. 显示路径情况

1. 显示已注册用户情况

1. 显示位示图情况

使用说明
首先，打开文件名为os的可执行程序，输入管理员账号密码，默认账号密码均为root。
如果需要注册自己的普通账户，则在root账户下输入指令register 账号密码，若无提示，则说明注册成功。此时可输入logout退出root账号。
使用指令dir可以查看当前工作目录下的子目录和文件，使用指令create可以创建文件，使用指令mkdir可以创建目录，使用delete可以删除文件。
当需要读文件时，需先执行指令open 文件名，使文件为open状态，接着执行指令read，读完文件后，需要执行指令close关闭文件。
其他指令具体操作方式可通过指令help进行实时查看，这里列出各种指令的详细使用方式。
zhangxiaobai@/ root $help 使用方式 help 文件创建 create [File] [rwx] 打开文件 open [File] 关闭文件 close [File] 删除文件 delete [File] 文件的读 read [File] 文件的写 write [File] 创建目录 mkdir [DirName] 改变当前目录 cd [DirName] 显示当前路径 pwd 列出文件目录 dir [DirName] 清除屏幕 clear 登录用户 login [userName] [passWord] 注册用户 register [userName] [passWord] 查看位示图 showbp 查看已注册的用户 who 退出 logout zhangxiaobai@/ root$

体会建议
本次课程设计消耗比较长的时间，不过又学到了很多东西，使用对文件系统的原理的了解更加深刻了。同时，对C语言的应用也越来越得心应手了。
本次课程设计中，从一开始我就参考了课本部分章节的内容，看了几遍后开始着手代码的编写，写到一半时，发现遇到个别问题，就一直卡在那里了。此时，又去网上参考了许多的文献资料，理清思路后，继续编写代码。
其中有个目录组织方式使用索引节点的问题，我一开始的想法是认为目录组织方式就是文件盘块的组织方式，将文件占用的盘块放入索引节点中，但是写到一半发现好像审错题目要求了，就没继续写下去了，因为我原先使用的文件盘块组织方式是隐式链接的，要改过来的话需要较大的改动。
本次课程设计从需求分析到代码实现以及文档编写大概花了6天左右，也从中学习到了很多，希望以后能够继续享受课程设计给我带来的快乐。
参考文献
[1] 计算机操作系统（修订版），汤子瀛等，西安电子科技大学出版社
[2] 操作系统实验指导书，傅秀芬，广东工业大学（自编）
[3] 计算机操作系统教程 ( 第二版 )，张尧学、史美林，清华大学出版社
[4] 现代操作系统，A.S.Tanenbaum 著，陈向群等译机械工业出版社
源代码附件
1. main.c
//
// main.c
// os
//
// Created by 张小白 on 2018/1/3.
//
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "file.h"
#include "command.h"
char command[1024];
char username[100];
char password[100];
int user_flag = 0;
char absolute_path[1024];
char relative_path[1024];
char mesg[1024];
extern char command_str[10][1024];
extern int command_len;
extern struct MFD *user;
extern struct MULU *root;
extern struct MFD *nowMainDir;
void login_mesg(void)
{
time_t t;
struct tm *lt;
time (&t);
lt = localtime(&t);
printf("Last login: %d/%d/%d %d:%d:%d\n",lt->tm_year+1900, lt->tm_mon, lt->tm_mday, lt->tm_hour, lt->tm_min, lt->tm_sec);//输出结果
sprintf(mesg,"zhangxiaobai@%s %s$ ",relative_path,username);
printf("%s",mesg);
}
void create_mfd_user(char iusername[], char ipassword[]) //为用户分配MFD
{
user_create_mfd();
}
void login_register(void)
{
int flag = 0;
while(1)
{
printf("login:");
gets(command_str[1]);
system("stty -echo");
printf("password:");
gets(command_str[2]);
system("stty echo");
printf("\n");
if(checkAccount(command_str[1], command_str[2]) == 0)//登录成功
{
flag = 1;
}
if(flag == 1) //登录成功
{
strcpy(username,command_str[1]); //用户名
strcpy(password,command_str[2]); //密码
sprintf(absolute_path,"/"); //绝对路径
sprintf(relative_path,"/"); //相对路径
find_nowMainDir(username);
printf("login successfully.\n");
system("clear");
break;
}
else //登录失败
{
printf("login failed, account or password error.\n");
continue;
}
}
}
void creat_root(void)
{
strcpy(username,"root"); //注册的用户名
strcpy(password,"root"); //注册的密码
create_mfd_user(username,password);//为注册的用户分配MFD
}
int main(void)
{
int result;
creat_root(); //创建管理员账号
system_init(); //系统初始化
while(1)
{
login_register(); //用户登录或注册
login_mesg(); //登录信息
while(1)
{
gets(command); //等待输入命令
result = command_check(command); //解析命令
if(result == 9) //退出登录
{
system("clear");
break;
}
else if(result == -1) //无法解析命令
printf("%s: command not found\r\n",command);
else
command_execute(result); //执行命令
printf("%s",mesg);
}
}
return (0);
}
command.c
//
// command.c
// os
//
// Created by 张小白 on 2018/1/5.
//
#include "command.h"
#include "file.h"
char command_str[10][1024];
int command_len;
extern char command[1024];
extern char username[100];
extern char password[100];
extern char absolute_path[1024];
extern char mesg[1024];
extern struct MFD *nowMainDir;
extern struct MULU *nowWorkDir;
void help(void) //帮助信息
{
printf("使用方式 help\r\n");
printf("文件创建 create [File] [rwx]\r\n");
printf("打开文件 open [File]\r\n");
printf("关闭文件 close [File]\r\n");
printf("删除文件 delete [File]\r\n");
printf("文件的读 read [File]\r\n");
printf("文件的写 write [File]\r\n");
printf("创建目录 mkdir [DirName]\r\n");
printf("改变当前目录 cd [DirName]\r\n");
printf("显示当前路径 pwd\r\n");
printf("列出文件目录 dir [DirName]\r\n");
printf("清除屏幕 clear\r\n");
printf("登录用户 login [userName] [passWord]\r\n");
if(nowMainDir->right == '1') //管理员账号申请注册
{
printf("注册用户 register [userName] [passWord]\r\n");
printf("查看位示图 showbp\r\n");
printf("查看已注册的用户 who\r\n");
}
printf("退出 logout\r\n");
}
void command_execute(int result)
{
if(result == 0)
{
create_file();
}
else if(result == 1)
{
open_file();
}
else if(result == 2)
{
read_file();
}
else if(result == 3)
{
write_file();
}
else if(result == 4)
{
close_file();
}
else if(result == 5)
{
delete_file();
}
else if(result == 6)
{
mk_dir();
}
else if(result == 7)
{
cd();
}
else if(result == 8)
{
dir();
}
else if(result == 9 || result == 14)
{
system("clear");
}
else if(result == 10)
{
;
}
else if(result == 11)
{
if(nowMainDir->right == '1') //管理员账号申请注册
{
strcpy(username,command_str[1]); //注册的用户名
strcpy(password,command_str[2]); //注册的密码
create_mfd_user(command_str[1],command_str[2]);//为注册的用户分配MFD
}
else
printf("you don't have the authority to register a user.\n");
}
else if(result == 12)
{
printf("%s\n",absolute_path);
}
else if(result == 13)
{
help();
}
else if(result == 15)
{
showBitMap();
}
else if(result == 16)
{
who();
}
}
int command_check(char command[]) //命令分析
{
char *tmp;
char command_tmp[1024];
int i;
int j;
for(i=0;i<strlen(command);i++) //除去命令中多余的空格
{
if(command[i]== ' ' && command[i+1] == ' ')
{
for(j=i;j<(strlen(command)-1);j++)
{
command[j] = command[j+1];
}
command[j] = '\0';
i--;
}
}
command_len = 0;
strcpy(command_tmp, command);
tmp = strtok(command_tmp," ");//分割命令
while(tmp) //将命令各部分放入数组中
{
strcpy(command_str[command_len],tmp);
command_len++;
tmp = strtok(NULL," ");
}
// printf("command:%s str[0]:%s\n",command,command_str[0]);
if(strstr(command_str[0],"create") != NULL) //文件创建
{
return 0;
}
else if(strstr(command_str[0],"open") != NULL) //文件打开
{
return 1;
}
else if(strstr(command_str[0],"read") != NULL) //文件读
{
return 2;
}
else if(strstr(command_str[0],"write") != NULL) //文件写
{
return 3;
}
else if(strstr(command_str[0],"close") != NULL) //文件关闭
{
return 4;
}
else if(strstr(command_str[0],"delete") != NULL) //文件删除
{
return 5;
}
else if(strstr(command_str[0],"mkdir") != NULL) //建立目录
{
return 6;
}
else if(strstr(command_str[0],"cd") != NULL) //改变当前目录
{
return 7;
}
else if(strstr(command_str[0],"dir") != NULL) //列出文件目录
{
return 8;
}
else if(strstr(command_str[0],"logout") != NULL) //退出
{
return 9;
}
else if(strstr(command_str[0],"login") != NULL) //登录
{
return 10;
}
else if(strstr(command_str[0],"register") != NULL) //注册
{
return 11;
}
else if(strstr(command_str[0],"pwd") != NULL) //显示当前绝对路径
{
return 12;
}
else if(strstr(command_str[0],"help") != NULL) //帮助信息
{
return 13;
}
else if(strstr(command_str[0],"clear") != NULL) //清屏
{
return 14;
}
else if(strstr(command_str[0],"showbp") != NULL) //显示位示图
{
return 15;
}
else if(strstr(command_str[0],"who") != NULL) //查看系统用户
{
return 16;
}
else
{
return -1;
}
}
file.c
//
// file.c
// os
//
// Created by 张小白 on 2018/1/5.
//
#include "file.h"
#define getMemory(type) (type*)malloc(sizeof(type))
#define SYSTEM_SIZE (1024 * 1024) //系统容量大小，单位为字节，总大小1024KB=1MB
#define DiskMax 2040 //盘块个数
#define DiskSize 512 //每个盘块的大小为512字节
#define MAPMAX_M (2040 / 8) //位示图长度,即数组元素行数
#define MAPMAX_N 8 //每行的位数
int availableDisk = MAPMAX_M * MAPMAX_N; //可用文件块数
char *maparr = NULL; //位示图指针
extern char command[1024];
extern char username[100];
extern char password[100];
extern int user_flag;
extern char absolute_path[1024];
extern char relative_path[1024];
extern char mesg[1024];
extern char command_str[10][1024];
extern int command_len;
struct SYSTEM *sysInfo = NULL;
struct MFD *user = NULL;
struct MFD *nowMainDir = NULL;
struct MULU *nowWorkDir = NULL;
int single_bit_read(unsigned char c,int pos) //读每一位从右到左依次为0~7位
{
unsigned char b_mask=0x01;
b_mask = b_mask << pos;
if((c&b_mask)==b_mask)
return 1;
else
return 0;
}
void all_bit_read(unsigned char c,int direction) //依次输出它的每一个二进制位
{
int i;
if(direction == 1)
{
for(i = MAPMAX_N-1; i>=0; i--)
printf("%d ",single_bit_read(c, i));
}
else if(direction == 0)
{
for(i = 0; i<MAPMAX_N; i++)
printf("%d ",single_bit_read(c, i));
}
}
void single_bit_set(char* p_data, unsigned char position, int flag) //写每一位从右到左依次为1~8位
{
if(flag == 1)
{
*p_data |= (1<<(position-1));
}
else if(flag == 0)
{
*p_data &= ~(1<<(position-1));
}
}
void system_init(void)
{
int i = 0;
sysInfo = getMemory(struct SYSTEM);
//为该文件系统申请1MB内存空间
if ((sysInfo->start = (char *)malloc(SYSTEM_SIZE)) == NULL)
{
return ;
}
//该文件系统的盘块数
sysInfo->disk_block_number = DiskMax;
//该文件系统的容量大小
sysInfo->size = SYSTEM_SIZE ;
//第一部分为位示图的内存存储空间，将首地址赋值为位示图
maparr = sysInfo->start;
//初始化位示图，全部置0，表示该编号所对应的盘块为空闲状态
for (i = 0; i < MAPMAX_M; i++)
maparr[i] = 0;
//剩余的内存空间用来存储盘块
sysInfo->disk_head = create_disk_block_list( ((sysInfo->start) + MAPMAX_M),DiskSize,DiskMax);
// for (i = 0; i < MAPMAX_M; i++)
// {
// single_bit_set(&maparr[i],7,0);
// }
// for (i = 0; i < MAPMAX_M; i++)
// {
// all_bit_read(maparr[i], 0);
// printf("\n");
// }
// find_blank_file_disk(1);
}
//创建文件块链表,返回返回链表的头指针
//datahead 第一块数据的地址，blockcap 一个文件块的大小，len 链表的长度
struct DISK *create_disk_block_list(char *datahead, unsigned blockcap, unsigned len)
{
if (datahead == NULL || len == 0)
{
return NULL;
}
struct DISK *head;
struct DISK *pnew;
struct DISK *pold;
head = pold = pnew = (struct DISK *)malloc(sizeof(struct DISK));
for ( unsigned i = 0; i < len; i++)
{
pold->diskNumber = i+1; //盘块编号
pold->diskSize = DiskSize; //盘块容量
pold->diskAddr = datahead + i * blockcap; //盘块数据地址
memset(pold->diskAddr, '\0', blockcap);
if (i != len - 1)
{
pnew = (struct DISK *)malloc(sizeof(struct DISK));
}
else
{
pnew = NULL;
}
pold->next = pnew;
pold = pnew;
}
return head;
}
//返回文件块的地址
char * find_blank_file_disk(unsigned fileblockid)
{
struct DISK *fblock = sysInfo->disk_head;
while (fblock->next != NULL)
{
if (fblock->diskNumber == fileblockid)
{
return fblock->diskAddr;
}
else
{
fblock = fblock->next;
}
}
return NULL;
}
//在位示图中找到空闲的盘块
int find_blank_block_id(void)
{
int i,j;
for (i = 0; i < MAPMAX_M; i++)
{
for (j = 0; j < MAPMAX_N; j++)
{
if(single_bit_read(maparr[i], j) == 0) //第i行第j位空闲
return MAPMAX_N * i + j + 1;
}
}
return 0;
}
void clear_stdin(void) //清除输入缓冲区
{
char ch;
while((ch=getchar())!='\n'&&ch!=EOF);
}
void showMFD(void) //显示各个用户
{
struct MFD *q;
if(user)
q = user;
else
return ;
while(q)
{
// printf("username:%s password:%s right:%c\n",q->username,q->password,q->right);
q = q->next;
}
}
int checkAccount(char iusername[],char ipassword[]) //检测用户是否正确
{
struct MFD *q;
if(user)
q = user;
else
return -1;
while(q)
{
if(strcmp(q->username, iusername) == 0 && strcmp(q->password,ipassword) == 0)
return 0;
q = q->next;
}
return -1;
}
void who(void) //输出系统的所有已注册用户
{
struct MFD *q;
if(user)
q = user;
else
return ;
// printf("\n");
while(q)
{
printf("username:%s\tpassword:%s\tright:%c\t\n",q->username,q->password,q->right);
q = q->next;
}
}
//对各个用户的MFD进行链接
void linkMFD(struct MFD *p) //对用户进行链接
{
struct MFD *a,*b;
if(user==NULL)
{
p->next=user;
user=p;
}
else
{
b=user;
a=user->next;
while(a) //找到最后一个结点
{
b=a;
a=a->next;
}
b->next=p;
p->next=a;
}
showMFD();
}
//为用户创建一个MFD
void user_create_mfd(void)
{
struct MFD *p;
struct MFD *q;
q = user;
while(q && strcmp(q->username,username) != 0)//判断当前登录的用户名或者注册的用户名是否已经存在
{
q=q->next;
}
if(q!=NULL) //该用户的MFD已经存在，则无需重新创建MFD
{
printf("register failed.the accounts exist already.\n");
return ;
}
p=getMemory(struct MFD);
strcpy(p->username,username);
strcpy(p->password,password);
if(strcmp(username, "root") == 0)
p->right = '1'; //管理员
else
p->right = '0'; //普通用户
p->next=NULL;
p->link=getMemory(struct MULU);
//初始化用户的根目录
strcpy(p->link->dirname,username); //用户根目录名字
p->link->next=NULL; //用户根目录是无同级目录的
p->link->link=NULL; //子目录暂时为空
p->link->pre=NULL; //用户根目录是无父目录的
p->link->link1=NULL; //目录包含的文件暂时为空
linkMFD(p); //将新建立的用户与已存在的用户进行链接
}
//对某一目录的文件进行链接
void link_file(struct FIS *p)
{
struct MULU *b;
struct FIS *a;
b = nowWorkDir;
if(b->link1==NULL)
{
b->link1=p;
p->next=NULL;
}
else
{
a=b->link1;
while(a->next)
{
a=a->next;
}
p->next=a->next;
a->next=p;
}
}
void create_file(void)
{
struct FIS *file;
struct MULU *tmp;
struct FIS *file1;
int id = 0; //空闲盘块
char *blank; //空闲盘块内存地址
tmp = nowWorkDir;//当前工作目录
file1 = tmp->link1;//指向当前目录所包含的文件
while(file1 != NULL && strcmp(file1->fileName, command_str[1]) != 0)
file1 = file1 -> next;
if(file1 != NULL)
{
printf("create failed,this file name has been used.\n");
return ;
}
id = find_blank_block_id(); //寻找第一个空闲盘块
if(id == 0) //盘块号是从1开始的，所以当为0则说明找不到
{
printf("write failed,there is not enough disk to write\n");
return ;
}
blank = find_blank_file_disk(id); //找到这个空闲盘块指向的内存空间地址
// printf("id:%d\n",id);
if(blank == NULL)
{
printf("can't find the memory address of this disk block.\n");
return ;
}
file = getMemory(struct FIS); //文件结构体地址
file->fileContex = getMemory(struct FCS);
strcpy(file->fileName, command_str[1]);//文件名
file->fileContex->size = 0;//文件大小默认为0
// printf("str2:%s\n",command_str[2]);
strcpy(file->fileContex->permissions, command_str[2]);//文件权限,注意，只能三位
file->fileContex->isOpen = 0;//文件当前没有在运行
file->fileContex->disk = NULL;//磁盘快初始化为空
link_file(file);//将当前工作目录的文件进行链接
}
void find_nowMainDir(char *iusername)
{
nowMainDir = user;
while(nowMainDir && strcmp(nowMainDir->username, iusername))//当前用户主目录
{
nowMainDir = nowMainDir->next;
}
nowWorkDir = nowMainDir->link;//当前工作目录
// printf("用户名是%s 密码是%s 当前用户指向的根目录%s\n",nowMainDir->username,nowMainDir->password,nowWorkDir->dirname);
}
void dir(void)
{
int i=-1;
struct MULU *m;
struct FIS *r;
m=nowWorkDir->link;//指向目录所包含的子目录
r=nowWorkDir->link1;//指向目录所包含的文件
printf("dir:");
while(m) //对目录进行遍历
{
i = (i+1) % 5;
if(i == 0)
printf("\n%s\t",m->dirname);
else
printf("%s\t",m->dirname);
m = m->next;
}
i = -1;
printf("\n\nfile:");
while(r)
{
i = (i+1) % 5;
if(i == 0)
printf("\n%s\t",r->fileName);
else
printf("%s\t",r->fileName);
r = r->next;
}
printf("\n");
}
void open_file(void)
{
struct MULU *tmp;
struct FIS *file;
tmp = nowWorkDir;//当前工作目录
file = tmp->link1;//指向当前目录所包含的文件
while(file != NULL && strcmp(file->fileName, command_str[1]) != 0)
file = file -> next;
if(file == NULL)
{
printf("open failed,file does not exist.\n");
return ;
}
file->fileContex->isOpen = 1;//打开文件
}
void close_file(void)
{
struct MULU *tmp;
struct FIS *file;
tmp = nowWorkDir;//当前工作目录
file = tmp->link1;//指向当前目录所包含的文件
while(file != NULL && strcmp(file->fileName, command_str[1]) != 0)
file = file -> next;
if(file == NULL)
{
printf("open failed,file does not exist.\n");
return ;
}
file->fileContex->isOpen = 0;//关闭文件
}
void read_file(void)
{
struct MULU *tmp;
struct FIS *file;
tmp = nowWorkDir;//当前工作目录
file = tmp->link1;//指向当前目录所包含的文件
while(file != NULL && strcmp(file->fileName, command_str[1]) != 0)
file = file -> next;
if(file == NULL)
{
printf("read failed,file does not exist.\n");
return ;
}
if(file->fileContex->isOpen == 1)
printf("%s\n",file->fileContex->context); //输出内容
else
printf("please open the file first.\n");
}
void showBitMap(void)
{
int i = 0;
printf("BitMap:\n");
for (i = 0; i < MAPMAX_M; i++)
{
all_bit_read(maparr[i],0);
printf("\n");
}
}
void allocateDiskBlock(struct FIS *file,size_t len) //分配盘块
{
//盘块数组下标从0开始，盘块号从1开始算
//盘块号 = MAPMAX_N * i + j + 1
int i = 0, j = 0;
size_t nowLen = 0;
struct DISK *diskHead;
struct DISK *disk;
struct DISK *diskTmp;
diskHead = getMemory(struct DISK);
diskTmp = diskHead;
file->fileContex->disk = diskHead;//分配一个不存放盘块数据的头指针
for (i = 0; i < MAPMAX_M; i++)
{
for (j = 0 ; j < MAPMAX_N; j++)
{
if(single_bit_read(maparr[i],j) == 0)
{
if(nowLen < len)
{
nowLen++;
disk = getMemory(struct DISK);
diskTmp->next = disk;
disk->next = NULL;
disk->diskNumber = MAPMAX_N * i + j + 1;//盘块号计算公式
disk->diskSize = DiskSize; //盘块大小
single_bit_set(&maparr[i],j+1,1);
diskTmp = disk;
}
else
break;
}
}
}
// showBitMap();
}
void recycleDiskBlock(struct FIS *file) //回收盘块
{
struct DISK *tmp;
struct DISK *tmp1;
struct DISK *tmp2;
int i,j;
// i = 盘块号/MAPMAX_N
// j = 盘块号%MAPMAX_N - 1
tmp = file->fileContex->disk;//指向文件的第一个盘块，不包含盘块信息
if(tmp == NULL)//该头盘块指针不存在，说明这个文件里面没内容，所以没占用盘块
return ;
tmp1 = tmp->next;
free(tmp); //先清除时盘块头指针，因为不包含盘块数据
while(tmp1)
{
tmp2 = tmp1;
i = (int)(tmp1->diskNumber/MAPMAX_N);
j = ((tmp1->diskNumber)%MAPMAX_N) - 1;
single_bit_set(&maparr[i],j+1,0);
tmp1 = tmp1->next;
free(tmp2); //释放内存
}
}
void write_file(void)
{
char content[2048];
int i = 0;
size_t old_size = 0;
struct MULU *tmp;
struct FIS *file;
tmp = nowWorkDir;//当前工作目录
file = tmp->link1;//指向当前目录所包含的文件
while(file != NULL && strcmp(file->fileName, command_str[1]) != 0)
file = file -> next;
if(file == NULL) //文件不存在
{
printf("write failed,file does not exist.\n");
return ;
}
if(file->fileContex->permissions[1] != '1') //检测是否有写的权限
{
printf("the file is not allowed to write.\n");
return ;
}
printf("please input the content:(stop by #)");
while( (content[i] = getchar()) != '#')
i = (i + 1)%2048;
content[i] = '\0';
if(( availableDisk + (int)(file->fileContex->size) - (int)(strlen(content)) ) >= 0)
{
//可用盘块数目+文件已经占用的盘块数目-需要占用的盘块数目>= 0
open_file(); //打开文件
old_size = file->fileContex->size; //该文件原来的大小
recycleDiskBlock(file);//重新写入该文件时，应当先回收掉原来占用的盘块，并释放空间
strcpy(file->fileContex->context, content); //对文件内容赋值
file->fileContex->size = strlen(content);// 对文件大小赋值
// printf("file len:%lu\n",file->fileContex->size);
availableDisk = availableDisk - (int)(file->fileContex->size) + (int)old_size; //剩余可用盘块数
// printf("availe len:%d\n",availableDisk);
allocateDiskBlock(file,file->fileContex->size);//分配盘块,这里假设长度多大，盘块就多少个
clear_stdin(); //清除输入缓冲区
close_file(); //关闭文件
}
else
{
printf("write failed,there is not enough disk to write\n");
clear_stdin(); //清除输入缓冲区
return ;
}
}
void delete_file(void) //删除文件
{
struct MULU *tmp;
struct FIS *file;
struct FIS *tmp1;
size_t old_size = 0;
tmp = nowWorkDir;//当前工作目录
file = tmp->link1;//指向当前目录所包含的文件
while(file != NULL && strcmp(file->fileName, command_str[1]) != 0)
file = file -> next;
if(file == NULL)
{
printf("delete failed,file does not exist.\n");
return ;
}
old_size = file->fileContex->size; //文件的大小
recycleDiskBlock(file);//回收掉原来占用的盘块，并释放盘块指针空间
availableDisk = availableDisk + (int)(file->fileContex->size); //可用盘块数
if(strcmp(tmp->link1->fileName, file->fileName) == 0) //这个被删除的文件在第一个位置
{
if(tmp->link1->next) //第二个位置有文件
nowWorkDir->link1 = tmp->link1->next;
else //第二个位置没文件
nowWorkDir->link1 = NULL;
free(file);
}
else
{
tmp1 = tmp->link1;
while(strcmp(tmp1->next->fileName, file->fileName) != 0) //这个被删除的文件在不第一个位置
{
tmp1 = tmp1->next;
if(!(tmp1->next))
break;
}
tmp1->next = file->next;
free(file);
}
}
void link_dir(struct MULU *dir)//对某一目录的同级子目录进行链接
{
struct MULU *b;
struct MULU *a;
b = nowWorkDir;
if(b->link==NULL)
{
b->link=dir;
dir->next=NULL;
}
else
{
a=b->link;
while(a->next)
{
a=a->next;
}
dir->next=a->next;
a->next=dir;
}
}
void mk_dir(void) //创建目录
{
struct MULU *dir;
struct MULU *tmp;
struct MULU *dir1;
tmp = nowWorkDir;//当前工作目录
dir1 = tmp->link;//指向当前目录所包含的文件
while(dir1 != NULL && strcmp(dir1->dirname, command_str[1]) != 0)
dir1 = dir1 -> next;
if(dir1 != NULL)
{
printf("create failed,this dir name has been used.\n");
return ;
}
dir = getMemory(struct MULU);
strcpy(dir->dirname,command_str[1]); //新创建的目录名字
dir->link = NULL; //新创建的目录包含的子目录的暂时未空
dir->link1=NULL; //新创建的目录包含的文件暂时为空
dir->pre=nowWorkDir; //新创建的目录的父目录为当前工作目录
link_dir(dir); //对当前工作目录所包含的同级子目录进行链接
}
int find_son_dir(char *dirName) //寻找子目录
{
struct MULU *tmp;
tmp = nowWorkDir->link; //指向当前目录的第一个子目录
while(tmp && strcmp(tmp->dirname, dirName))
{
tmp = tmp->next;
}
if(tmp != NULL)
{
nowWorkDir = tmp; //当前工作目录为这个子目录
sprintf(absolute_path,"%s%s%c",absolute_path,dirName,'/'); //绝对路径
sprintf(relative_path,"%s",dirName); //相对路径
sprintf(mesg,"zhangxiaobai@%s %s$ ",relative_path,username);
return 0;
}
else
return -1;
}
void cut_path(char *dirname)
{
size_t len_abs = strlen(absolute_path);
size_t len_dir = strlen(dirname);
absolute_path[len_abs - 1 - len_dir] = '\0';
}
void cd(void)//切换当前目录
{
int result = -1;
if((strcmp(command, "cd") == 0) || (strcmp(command, "cd ") == 0)) //如果只输入cd 而不输入路径
return ;
else if(command_str[1][0] == '/') //判断路径是不是/ 如果是的话，那就是用户根路径
{
nowWorkDir = nowMainDir->link; //指回用户根目录
sprintf(absolute_path,"/"); //绝对路径
sprintf(relative_path,"/"); //相对路径
sprintf(mesg,"zhangxiaobai@%s %s$ ",relative_path,username);
}
else if(strstr(command_str[1],"..") != NULL) //判断是否是回到上级目录
{
if(nowWorkDir->pre) //如果不是用户根目录的话，那么他有父目录，如果是根目录，则默认不能再返回到上层了
{
nowWorkDir = nowWorkDir->pre;
if(nowWorkDir->pre)
{
cut_path(nowWorkDir->dirname); //绝对路径
sprintf(relative_path,"%s",nowWorkDir->dirname); //相对路径
sprintf(mesg,"zhangxiaobai@%s %s$ ",relative_path,username);
}
else
{
sprintf(absolute_path,"/"); //绝对路径
sprintf(relative_path,"%c",'/'); //相对路径
sprintf(mesg,"zhangxiaobai@%s %s$ ",relative_path,username);
}
}
}
else //不是回到用户根目录，也不是回到上层目录，那么只能是进入子目录中
{
result = find_son_dir(command_str[1]); //寻找子目录
if(result == -1) //找不到子目录
printf("no such a directory\n");
}
}