Unix文件系统模拟实验报告
一．实验任务和说明
这次实验是操作系统大型实验，要完成的任务是
模拟unix操作系统中的文件系统功能。在终端界面上用户可以象unix的shell命令一样输入一些命令，如输入ls 显示文件目录，chmod改变文件权限，chown改变文件拥有者，chgrp改变文件所属组，chnam改变文件名，pwd显示当前目录，cd改变当前目录，mkdir创建目录，rmdir删除目录，mk创建文件 ,cp文件拷贝，rm删除文件，cat显示文件内容，login切换用户，passwd修改用户口令 等功能。在后台，要实现混合索引式文件结构，包括用空闲结点号栈管理空闲结点和成组链接发管理空闲盘块。
二．实验需求分析、设计思路和总体方案
1．基本思路：
用一个文件（disk.txt）模拟一个物理硬盘, 通过对该文件的一系列操作，模拟UNIX文件系统中的文件操作。
2．理磁盘块的设计：
卷盘块数等于100块，每个磁盘块512字节，磁盘块之间用/n隔开，总共是514字节。0#表示超块，1#--10#放索引结点，每个索引结点占64字节，共80个索引结点。初始化是存在根目录root，占用了0#结点和11#盘块。
3．空闲磁盘块：
采用成组链接法管理。每组10块，12#--99#分为9组，每组的最后一个磁盘块里存放下一组的磁盘号信息。最后一组只有8块，加上0作为结束标志。在超块中用一个一维数组（10个元素）作为空闲磁盘块栈。放入第一组盘块。
4．空闲I结点：
采用混合索引式文件结构。索引结点结构中文件物理地址为六项：四个直接块号，一个一次间址，一个两次间址，其中一次间址和两次间址中一个磁盘块中存放16个磁盘号 。在超块中也用一维数组（80个元素）作为空闲I结点栈，与空闲磁盘块管理不同的是这里不用采用成组链接法，这一维数组中存放所有I结点编号，而且一直保持同一大小秩序。根目录占0#索引结点，由于根目录不会删改，是一直占0#索引结点，所以我并未按实验指导所说，把它写在超块里，不过写进去也无所谓的。
5．超块，I结点和目录结构的设计
struct SUPERBLOCK//超块
{
int fistack[80];//空闲结点号栈 setw(3)*80
int fiptr;//空闲结点栈指针(还有多少个) setw(3)
int fbstack[10];//空闲盘块号栈 setw(3)*10
int fbptr;//空闲结点栈指针 setw(3)
int inum;//空闲i结点总数 setw(3)
int bnum;//空闲盘块总数 setw(3)
};
struct INODE//i结点(64B) 已保证了每两个数据之间有空格隔开
{
int fsize;//文件大小 setw(6)
int fbnum;//文件盘块数 setw(6)
int addr[4];//四个直接盘块号(0 ~ 512*4==2048) setw(3)*4
int addr1;//一个一次间址() setw(3)
int addr2;//一个两次间址() setw(3)
char owner[6];//文件拥有者 setw(6)
char group[6];//文件所属组 setw(6)
char mode[11];// 文件类别及存储权限 setw(12)
char ctime[9];//最近修改时间 setw(10)
};
struct DIR//目录项(36B)
{
char fname[14];//文件名(当前目录) setw(15) (0 ~ 14)
int index;//i结点号 setw(3) (15 ~ 17)
char parfname[14];//父目录名 setw(15) (18 ~ 32)
int parindex;//父目录i结点号 setw(3) (33 ~ 35)
};
结点结构中的文件盘块数，目录项结构中的父目录名，父目录i结点号，其实可以不要，基本是不用到或是可以不用的，但是当我意识到时，程序已编得差不多了，为了避免牵一发而动全身，只好留着！
6．用户，密码和组
我的用户组信息是存放在另一个文件(user.txt)中的。
三．各个主要功能模块(函数)的说明
1.main.cpp:
是程序的主函数模块
主函数首先会根据控制文件control.txt的头一个位（初始化确定位）来确定是否进行初始化。如果初始化，那么将只有一个根目录。因为一旦初始化后，初始化确定位就会置为0，所以系统只会在第一次进入时初始化，以后都是在前面建立的文件结构上进行操作的。如果一定要系统初始化时，可把control.txt的头一个位置为1，或者使用命令“reset”。
进入系统时，当前路径是根目录。然后是登陆请求。登陆后，超块读入内存（由一个结构对象superblock模拟），进入命令解析层，对用户的不同命令执行不同的操作。退出系统前，把内存的超块再写回disk.txt。
2.head.h:
是程序的所有全局变量、结构、函数声明的模块。也包括了所有要用到的系统库。
3.blockinodesuperblock.h:
是定义有关超块、结点、盘块、目录项的底层操作函数的模块。
1．对结点的操作：
int ialloc(void);
申请一个i结点 返回结点号 否则返回-1。
返回的是空闲结点号栈中最小的结点号，结点用完时返回-1，申请失败。
void ifree(int index);
指定一个结点号，回收一个i结点。
先清空结点，然后插入栈中合适位置（必须保持结点号的有序性）。
void readinode(int index,INODE &inode);
读指定的i结点( n#结点，读指针应定位到514+64*n (64B)+2*(n/8) )到INOE inode寄存 便于对同一结点的大量操作
void writeinode(INODE inode,int index);
把INODE inode写回指定的i结点
2．对盘块的操作；用的是成组链接法。(n#盘块 读指针应定位到514*n)
int balloc(void);
申请一个盘块 返回盘块号 否则返回-1
void bfree(int index);
指定一个盘块号，回收一个盘块
3．对超块的操作；
void readsuper(void);
读超块到内存SUPERBLOCK superblock;
void writesuper(void);
内存SUPERBLOCK superblock;写回超块
4．对目录项的操作( n#目录项读指针应定位514*index+36*n )
void readdir(INODE inode,int index,DIR &dir);
读指定目录项进临时对象DIR dir;
void writedir(INODE inode,DIR dir,int index);
目录项对象DIR dir写到指定目录项
4.initial.h:
是定义初始化函数的模块
其中包括了对用户组的初始化：定义三个用户adm,cnj和jtq,其中adm,cnj的组为adm，jtq的组为guest。用户的初始密码都为123。对超块的（0#盘块）初始化 、对根目录文件结点（0#结点）的初始化 、对数据盘块的初始化。
5.userop.h:
定义了两个功能函数：
1．登陆 bool login(void); 要求输入用户信息，并判断是否合法。
2．改变用户密码 void changepassword(void); 改变当前用户的密码。
6. file.h:
定义了有关文件操作的四个函数
1．创建文件void mk(char *dirname,char *content);
当前目录下创建一个数据文件(规定目录文件只占1 ~ 4个盘块)。虽然不要求这个函数，但我觉得很有必要。而且，因为我使用了两个参数，前一个表示文件名，后一个表示文件内容，可以在文件拷贝里使用这个函数。
2．删除文件void rm(char *filename);
当前目录下删除指定数据文件
3．文件拷贝void cp(char*string);
给定一个路径，把那个文件拷贝到当前目录下。首先要使用dir.h里面根据路径找到目标的函数（find(char*string)）找到对应文件，如果是数据文件的话，记录文件内容到一缓冲区，然后在当前目录下调用创建目录的函数，就完成了。
4．显示文件内容void cat(char *filename);
显示当前目录下指定数据文件的内容。
7. dir.h:
定义两个底层函数
1．bool havesame(char *dirname,INODE inode,int &i,int &index2)
判断对象inode指向的目录文件盘块中有无该名（dirname）的目录项存在着，有返回1无返回0。同时，有该目录项的话，则按引用调用的i为待删子目录目录项下标 index2为目录项中的待删子目录的结点号
2．bool find(char *string)
根据路径找到指定文件或目录<路径至少有一个‘/’以root开头，不以‘/’结尾>。需要注意的是，使用此函数时当前路径跟着改掉了，所以使用前必须保存当前路径。万一找不到目标的话，可以还原为当前路径。
定义了有关目录操作的四个功能函数，
1．void mkdir(char *dirname)
当前目录下创建目录(规定目录文件只占一个盘块。为了降低难度，已设定目录文件只占一个盘块。
2．void rmdir(char *dirname,int index)
当前目录下删除目录。将要删除的目录可能非空。有两种策略：一、规定只能删除空目录。二、递归地将非空目录的所有子目录删除，让后再删除自己。第一种实现较简单，我使用了第二种策略。所以参数为 (子目录名,当前结点)。如果使用第一种策略的话，参数为只要子目录名就可以了。
3．void ls(void)
显示当前结点的所有子目录
4．void cd(char *string)
改变当前目录。有四中处理过程： string为“.”切换到当前目录；为“..”
切换到父目录 ；为“/”切换到根目录；如果为一路径的话，就调用bool find(char *string) 切换到指定目录。
8. chsome.h：
定义一个底层函数：
bool havewpower(INODE inode)
判断当前用户对指定的结点有无写权限
定义四个功能函数：
1．void chmod(char *name)
改变当前目录下指定文件的文件权限
2．void chown(char *name)
改变当前目录下指定文件的文件拥有者(如拥有者在另一个组，那么组也要改掉)
3．void chgrp(char *name)
改变当前目录下指定文件的文件所属组
4．void chnam(char *name)
改变当前目录下指定文件的文件名
9.command.h:
命令解析层函数模块。接受用户命令，执行不同的操作。
四．命令格式及运行结果
一开始为登陆请求。可选用户为：adm cnj jtq 密码都是123
登陆后在根目录
1．pwd 显示当前目录
2．mksome 创建bin dev 等6个目录
这是我自己为方便添加的功能，
2．ls显示当前目录下所有子目录
3．mkdir dirname创建目录
4．mk filename创建数据文件
5．rmdir dirname删除目录
6．cd . 切换当前目录
基本没用处
cd .. 切换到父目录
cd 子目录名 切换到子目录
cd /切换到根目录
cd 绝对路径 切换到指定目录
6．cp 路径 把路径指定的文件拷贝到当前目录下
7．cat filename 显示当前目录下指定数据文件的内容
chmod name 改变当前目录下指定文件或目录的权限模式
chown name 改变当前目录下指定文件或目录的拥有者
chgrp name 改变当前目录下指定文件或目录的所属组
个人认为没用。可能是还不理解其用途。
chnam name 改变当前目录下指定文件或目录的名字
12．rm filename 删除当前目录下指定文件
13．login 当前用户注销新用户登陆
14．reset 系统重置 既是把初始化函数执行一下
15．exit 安全退出系统。
如果不是安全退出的话，超块不会写回内存。下次进入必须要系统重置
五．心得体会
这次实验是有生以来写的最长的代码。多达1700行。至少花了本人一个半星期的时间。其中还包括两次通宵，n次夜班。写完后，自己都不敢相信自己写了那么多。很有成就感。嘎嘎~~~
其实，上课认真听了的话，从理论上理解UNIX文件系统并不难，最多是多看几遍书，多查查资料，难的是用代码去解决具体问题。以前编程是有具体算法的，就算不理解都能搞定。这次就不行了，只给出问题。那么，要编好程序，除了经验，就要求非常深的本质上的理解了。
编程过程中碰到很多问题，例如文件流的操作。本来还以为对文件流懂得差不多了，这次实验又出现问题：1.单ios::out摧毁原文件的问题。2.不能同时打开两个文件流的问题。。。等！都耗了不少时间才发现并纠正的。
这次实验不仅让我大大加深了对操作系统这门课的理解，更重要的是提高了我编程序，特别是系统程序的能力！
六．C++源代码
1. main.cpp
#include "head.h"
#include "blockinodesuperblock.h"
#include "initial.h"
#include "userop.h"
#include "file.h"
#include "dir.h"
#include "command.h"
#include "chsome.h"
/////////////////////////////////////////////////////////////////////////////////////////
void main()
{
control.open("control.txt",ios::in | ios::out | ios::nocreate);
int i;
control>>i;
control.close();
if(i!=0)//不为0就初始化
{
initial();
}
control.open("control.txt",ios::in | ios::out | ios::nocreate);
control.seekp(0);
control<<0;//默认是上次基础上继续下去不用再初始化
control.close();
strcpy(curname,"root");//当前目录文件名为root
road[0]=0;//当前目录路径(存放从根目录到这里的结点号)
num=1;//最后位road[num-1]为当前目录文件i结点号
cout<<"请登陆系统\n";
while( !login() )//登陆为止
cout<<"wrong !!!\n";
cout<<" login success"<<endl;
cout<<"******Welcome "<<auser<<"******";
readsuper();
getcommand();//命令解析函数
writesuper();
}
2. blockinodesuperblock.h
/////////////////////////////////////////////////////////////////////////////////////////
int ialloc()//申请一个i结点 返回结点号 否则返回-1
{
if(superblock.fiptr>0)
{
int temp=superblock.fistack[80-superblock.fiptr];//当前可用
superblock.fistack[80-superblock.fiptr]=-1;
superblock.fiptr--;
return temp;
}
return -1;
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void ifree(int index)//指定一个结点号，回收一个i结点
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );//清空结点
disk.seekp(514+64*index+2*(index/8));
disk<<setw(64)<<' ';
disk.close();
for(int i=80-superblock.fiptr;i<80;i++)//结点号找到合适位置插入空闲结点号栈
{
if(superblock.fistack[i]<index)//小于它的前移一位
{
superblock.fistack[i-1]=superblock.fistack[i];
}
else//放在第一个大于它的结点号前面
{
superblock.fistack[i-1]=index;
break;
}
}
superblock.fiptr++;
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/*成组链接法*/
int balloc()//申请一个盘块 返回盘块号 否则返回-1
{
int temp=superblock.fbstack[10-superblock.fbptr];
if(superblock.fbptr==1)//是栈底了==>是记录盘块了
{
//是最后记录盘块最后号0（保留作栈底 分配不成功）
if(temp==0)
{
return -1;
}
superblock.fbstack[10-superblock.fbptr]=-1;
superblock.fbptr=0;
//盘块内容读入栈
for(int i=0;i<10;i++)
{
int id,num=0;
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
//先计算盘块内容个数num（最多10），最后盘块可能不到10个
disk.seekg(514*temp);
for(int i=0;i<10;i++)
{
disk>>id;
num++;
if(id==0) break;
}
disk.seekg(514*temp);//盘块内容读入栈
for(int j=10-num;j<10;j++)
{
disk>>id;
superblock.fbstack[j]=id;
}
superblock.fbptr=num;
disk.close();
}
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );//清空回收盘块
disk.seekp(514*temp);
disk<<setw(512)<<' ';
disk.close();
//盘块使用掉
return temp;
}
else//不是记录盘块==>盘块使用掉
{
superblock.fbstack[10-superblock.fbptr]=-1;
superblock.fbptr--;
return temp;
}
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void bfree(int index)//指定一个盘块号，回收一个盘块
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );//清空回收盘块
disk.seekp(514*index);
disk<<setw(512)<<' ';
disk.close();
if(superblock.fbptr==10)//栈已满栈中内容记入回收盘块 栈清空
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
disk.seekp(514*index);
for(int i=0;i<10;i++)
{
disk<<setw(3)<<superblock.fbstack[i];
superblock.fbstack[i]=-1;
}
disk.close();
superblock.fbptr=0;
}//回收盘块压栈
superblock.fbstack[10-superblock.fbptr-1]=index;
superblock.fbptr++;
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void readsuper()//读超块到内存
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate);
int i;
for(i=0;i<80;i++)//读空闲结点号栈
{
disk>>superblock.fistack[i];
}
disk>>superblock.fiptr;//空闲结点号栈指针
for(i=0;i<10;i++)//读空闲盘块号栈
{
disk>>superblock.fbstack[i];
}
disk>>superblock.fbptr;//空闲盘块号栈指针
disk>>superblock.inum;//空闲结点号总数
disk>>superblock.bnum;//空闲盘块号总数
disk.close();
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void writesuper()//内存写回超块
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate);
int i;
for(i=0;i<80;i++)//写空闲结点号栈
{
disk<<setw(3)<<superblock.fistack[i];
}
disk<<setw(3)<<superblock.fiptr;//空闲结点号栈指针
for(i=0;i<10;i++)//写空闲盘块号栈
{
disk<<setw(3)<<superblock.fbstack[i];
}
disk<<setw(3)<<superblock.fbptr;//空闲盘块号栈指针
disk<<setw(3)<<superblock.inum;//空闲结点号总数
disk<<setw(3)<<superblock.bnum;//空闲盘块号总数
disk.close();
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void readinode(int index,INODE &inode)//读指定的i结点到INOE inode寄存 便于对同一结点的大量操作
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate);
disk.seekg(514+64*index+2*(index/8));
disk>>inode.fsize;//文件大小
disk>>inode.fbnum;//文件盘块数===> 目录文件为1数据文件1~4都有
for(int i=0;i<4;i++)//四个直接盘块号
disk>>inode.addr[i];
disk>>inode.addr1;//一个一次间址()===> 不使用了
disk>>inode.addr2;//一个两次间址()===> 不使用了
disk>>inode.owner;//文件拥有者
disk>>inode.group;//文件所属组
disk>>inode.mode;// 文件类别及存储权限
disk>>inode.ctime;//最近修改时间
disk.close();
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void writeinode(INODE inode,int index)//把INODE inode写回指定的i结点
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate);
disk.seekp(514+64*index+2*(index/8));
disk<<setw(6)<<inode.fsize;//文件大小
disk<<setw(6)<<inode.fbnum;//文件盘块数===> 目录文件为1数据文件1~4都有
for(int i=0;i<4;i++)//四个直接盘块号
disk<<setw(3)<<inode.addr[i];
disk<<setw(3)<<inode.addr1;//一个一次间址()===> 不使用了
disk<<setw(3)<<inode.addr2;//一个两次间址()===> 不使用了
disk<<setw(6)<<inode.owner;//文件拥有者
disk<<setw(6)<<inode.group;//文件所属组
disk<<setw(12)<<inode.mode;// 文件类别及存储权限
disk<<setw(10)<<inode.ctime;//最近修改时间
disk.close();
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void readdir(INODE inode,int index,DIR &dir)//读指定目录项（inode的盘块,下标index）进临时对象+清空源
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
disk.seekg(514*inode.addr[0]+36*index);
disk>>dir.fname;
disk>>dir.index;
disk>>dir.parfname;
disk>>dir.parindex;
disk.seekp(514*inode.addr[0]+36*index);
disk<<setw(15)<<' ';
disk<<setw(3)<<' ';
disk<<setw(15)<<' ';
disk<<setw(3)<<' ';
disk.close();
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void writedir(INODE inode,DIR dir,int index)//目录项对象写到指定目录项
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
disk.seekp(514*inode.addr[0]+36*index);
disk<<setw(15)<<dir.fname;
disk<<setw(3)<<dir.index;
disk<<setw(15)<<dir.parfname;
disk<<setw(3)<<dir.parindex;
disk.close();
}
/////////////////////////////////////////////////////////////////////////////////////////
3.command.h
/////////////////////////////////////////////////////////////////////////////////////////
void getcommand() //命令解析函数
{
char commond[10];
bool have;
for(;;)//接受并解释命令
{
have=false;//记录命令接受否
cout<<'\n';
printroad();
cout<<">";
cin>>commond;
if( !strcmp(commond,"cd") )//改变当前目录****(文件名 切换到子目录 ..切换到父目录 /切换到根目录)须切换到目录文件
{
have=true;
char string[100];//<是路径的话 至少有一个‘/’以root开头，不以‘/’结尾>
cin>>string;
cd(string);
}
if( !strcmp(commond,"mksome") )//构建基本文件结构
{
have=true;
cout<<"bin"; mkdir("bin");
cout<<"\ndev"; mkdir("dev");
cout<<"\nlib"; mkdir("lib");
cout<<"\netc"; mkdir("etc");
cout<<"\nusr"; mkdir("usr");
cout<<"\ntmp"; mkdir("tmp");
}
/*当前目录下的操作*/
if( !strcmp(commond,"mkdir") )//创建目录****(规定目录文件只占一个盘块)当前目录下创建
{
have=true;
char dirname[14];
cin>>dirname;
mkdir(dirname);
}
if( !strcmp(commond,"rmdir") )//删除目录****当前目录下删除<1.只能删除空目录><2.提醒+删除所有子目录>
{
have=true;
char dirname[14];
cin>>dirname;
rmdir(dirname,road[num-1]);
}
if( !strcmp(commond,"mk") )//创建数据文件****(规定目录文件只占1 ~ 4个盘块)当前目录下创建
{
have=true;
char filename[14];
cin>>filename;//理论上可输入1 ~ 4盘块的内容
char content[2048];
cout<<"请先输入文件内容(1 ~ 2048位)：";
cin>>content;
mk(filename,content);
}
if( !strcmp(commond,"cp") )//文件拷贝****(把指定目录下的指定文件拷贝到当前目录下)
{
have=true;
char string[100];//<路径至少有一个‘/’以root开头，不以‘/’结尾>
cin>>string;
cp(string);
}
if( !strcmp(commond,"rm") )//数据文件删除****当前目录下删除
{
have=true;
char filename[14];
cin>>filename;
rm(filename);
}
if( !strcmp(commond,"cat") )//显示文件内容(当前目录下指定数据文件)
{
have=true;
char filename[14];
cin>>filename;
cat(filename);
}
if( !strcmp(commond,"chmod") )//改变文件权限
{
have=true;
char name[14];
cin>>name;
chmod(name);
}
if( !strcmp(commond,"chown") )//改变文件拥有者(如拥有者在另一个组，那么组也要改掉)
{
have=true;
char name[14];
cin>>name;
chown(name);
}
if( !strcmp(commond,"chgrp") )//改变文件所属组(???)
{
have=true;
char name[14];
cin>>name;
chgrp(name);
}
if( !strcmp(commond,"chnam") )//改变文件名
{
have=true;
char name[14];
cin>>name;
chnam(name);
}
/////////////////////////////////////////////////////////////////////////////////
/*对当前目录的操作*/
if( !strcmp(commond,"pwd") )//显示当前目录
{
have=true;
cout<<"您的当前目录为："<<curname;
}
if( !strcmp(commond,"ls") )//显示所有子目录(必须保证是目录文件)
{
have=true;
ls();
}
/////////////////////////////////////////////////////////////////////////////////
/*用户组操作*/
if( !strcmp(commond,"login") )//用户登陆==切换用户
{
have=true;
cout<<"帐号"<<auser<<"已注销\n";
while( !login() )
cout<<"wrong !!!\n";
cout<<"login success"<<endl;
cout<<"******Welcome "<<auser<<"******";
}
if( !strcmp(commond,"passwd") )//改变用户口令
{
have=true;
changepassword();
}
if( !strcmp(commond,"reset") )//系统重置（调用初始化函数）前有非正常退出时，一定要用
{
have=true;
initial();
cout<<"系统已重置";
}
if( !strcmp(commond,"exit") )//退出
{
have=true;
return;
}
if( have==false )//都不被接受
{
cout<<commond<<" is not a legal command!!!";
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/**/
void printroad(void)//根据结点路径，输出路径
{
cout<<"root";
INODE inode;
int nextindex;
char name[14];
for(int i=0;i+1<num;i++)
{
readinode( road[i],inode );
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
for(int j=0;j<(inode.fsize/36);j++)//遍历所有的目录项
{
disk.seekg(514*inode.addr[0]+36*j);
disk>>name;
disk>>nextindex;
if(nextindex==road[i+1])
{
cout<<'/';
cout<<name;
break;
}
}
disk.close();
}
}
/////////////////////////////////////////////////////////////////////////////////////////
/*bool isspace(char *str)//判断字符串是否全为空格
{
bool aaa=true;//检验参数有否 检验是否全空格记录在isspace中( 空格不能当参数 )
for(int i=0;str[i]!='\0';i++)
{
if(str[i]!=' ')
aaa=false;
}
return aaa;
}*/
/////////////////////////////////////////////////////////////////////////////////////////
4.chsome.h
/////////////////////////////////////////////////////////////////////////////////////////
bool havewpower(INODE inode)//判断当前用户对指定的结点有无写权限
{
if( !strcmp(auser,inode.owner) )//是文件拥有者
{
if(inode.mode[2]=='w')
return true;
return false;
}
else
{
if( !strcmp(agroup,inode.owner) )//是组内
{
if(inode.mode[5]=='w')
return true;
return false;
}
else//其他用户
{
if(inode.mode[8]=='w')
return true;
return false;
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void chmod(char *name)//改变文件权限
{
INODE inode,inode2;
readinode(road[num-1],inode);//当前结点写入结点对象
int i,index2;//i为目录项下标 index2为目录项中结点号
if( havesame(name,inode,i,index2) )
{
readinode(index2,inode2);
if( havewpower(inode2) )
{
char amode[3];
cout<<"1表示拥有者4表示组内7表示其他用户a表示-wx模式 b表示r-x模式 c表示rwx模式 \n";
cout<<"请输入修改方案(例如4c)：";
cin>>amode;
if( amode[0]=='1' || amode[0]=='4' || amode[0]=='7' )
{
//(int)amode[0]=49;强制类型转换是转成其ASCII码
if( amode[1]=='a' )
{
inode2.mode[ (int)amode[0]-48 ]='-';
inode2.mode[ (int)amode[0]+1-48 ]='w';
writeinode(inode2,index2);
cout<<"修改完毕";
}
else
{
if( amode[1]=='b' )
{
inode2.mode[ (int)amode[0]-48 ]='r';
inode2.mode[ (int)amode[0]+1-48 ]='-';
writeinode(inode2,index2);
cout<<"修改完毕";
}
else
{
if( amode[1]=='c' )
{
inode2.mode[ (int)amode[0]-48 ]='r';
inode2.mode[ (int)amode[0]+1-48 ]='w';
writeinode(inode2,index2);
cout<<"修改完毕";
}
else
{
cout<<"输入不合法!!!"; goto end;
}
}
}
}
else
{
cout<<"输入不合法!!!"; goto end;
}
}
else
{
cout<<"你无权修改该子目录或文件"; goto end;
}
}
else
{
cout<<"不存在该子目录或文件"; goto end;
}
//修改当前i结点和子结点
char tmpbuf[9];
_strtime(tmpbuf);
strcpy(inode.ctime,tmpbuf);
strcpy(inode2.ctime,tmpbuf);
writeinode(inode,road[num-1]);
writeinode(inode2,index2);
end:return;
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void chown(char *name) //改变文件拥有者(如拥有者在另一个组，那么组也要改掉)
{
INODE inode,inode2;
readinode(road[num-1],inode);//当前结点写入结点对象
int i,index2;//i为目录项下标 index2为目录项中结点号
if( havewpower(inode) )
{
if( havesame(name,inode,i,index2) )
{
readinode(index2,inode2);
if( havewpower(inode2) )
{
char owner2[6];
char auser2[6];
char group2[6];
cout<<"请输入改后的文件所有者：";
cin>>owner2;
bool is=false; //判断输入的也是合法用户名
user.open("user.txt",ios::in);
for( int n=0;n<usernum;n++ )//用户名18*n+0~18*n+5密码18*n+6~18*n+11 用户组18*n+12~18*n+17
{
user.seekg(18*n);
user>>auser2;
if( !strcmp(owner2,auser2) )
{
is=true;
user.seekg(18*n+12);
user>>group2;
break;
}
}
user.close();
if( is )
{
strcpy(inode2.owner,owner2);
strcpy(inode2.group,group2);
writeinode(inode2,index2);
cout<<"修改成功";
//修改当前i结点和子结点
char tmpbuf[9];
_strtime(tmpbuf);
strcpy(inode.ctime,tmpbuf);
strcpy(inode2.ctime,tmpbuf);
writeinode(inode,road[num-1]);
writeinode(inode2,index2);
}
else
{
cout<<"不存在该用户，修改失败";
}
}
else
{
cout<<"你没有权限";
}
}
else
{
cout<<"不存在该子目录或文件";
}
}
else
{
cout<<"你没有权限";
}
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void chgrp(char *name) //改变文件所属组
{
INODE inode,inode2;
readinode(road[num-1],inode);//当前结点写入结点对象
int i,index2;//i为目录项下标 index2为目录项中结点号
if( havewpower(inode) )
{
if( havesame(name,inode,i,index2) )
{
readinode(index2,inode2);
if( havewpower(inode2) )
{
char group2[6];
char agroup2[6];
cout<<"请输入改后的文件所所属组：";
cin>>group2;
bool is=false; //判断输入的也是合法用户名
user.open("user.txt",ios::in);
for( int n=0;n<usernum;n++ )//用户名18*n+0~18*n+5密码18*n+6~18*n+11 用户组18*n+12~18*n+17
{
user.seekg(18*n+12);
user>>agroup2;
if( !strcmp(group2,agroup2) )
{
is=true;
break;
}
}
user.close();
if( is )
{
strcpy(inode2.group,group2);
writeinode(inode2,index2);
cout<<"修改成功";
//修改当前i结点和子结点
char tmpbuf[9];
_strtime(tmpbuf);
strcpy(inode.ctime,tmpbuf);
strcpy(inode2.ctime,tmpbuf);
writeinode(inode,road[num-1]);
writeinode(inode2,index2);
}
else
{
cout<<"不存在该组，修改失败";
}
}else
{
cout<<"你没有权限";
}
}
else
{
cout<<"不存在该子目录或文件";
}
}
else
{
cout<<"你没有权限";
}
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void chnam(char *name) //改变文件名
{
INODE inode,inode2;
readinode(road[num-1],inode);//当前结点写入结点对象
int i,index2;//i为目录项下标 index2为目录项中结点号
if( havewpower(inode) )
{
if( havesame(name,inode,i,index2) )
{
readinode(index2,inode2);
if( havewpower(inode2) )
{
char name2[14];
cout<<"请输入更改后的文件名：";
cin>>name2;
disk.open( "disk.txt",ios::in | ios::out | ios::nocreate );
disk.seekp( 514*inode.addr[0]+36*i);
disk<<setw(15)<<name2;
disk.close();
//如果是目录文件，其下的所有目录项都要改parfname[14]
if(inode2.mode[0]=='d')
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
for(int i=0;i<(inode2.fsize/36);i++)//遍历所有的目录项
{
disk.seekg(514*inode2.addr[0]+36*i+18);
disk<<setw(15)<<name2;
}
disk.close();
}
cout<<"更改成功";
//修改当前i结点和子结点
char tmpbuf[9];
_strtime(tmpbuf);
strcpy(inode.ctime,tmpbuf);
strcpy(inode2.ctime,tmpbuf);
writeinode(inode,road[num-1]);
writeinode(inode2,index2);
}
else
{
cout<<"你没有权限";
}
}
else
{
cout<<"不存在该子目录或文件";
}
}
else
{
cout<<"你没有权限";
}
}
/////////////////////////////////////////////////////////////////////////////////////////
5.dir.h
/////////////////////////////////////////////////////////////////////////////////////////
/**///当前目录curname（肯定是目录文件） 当前i结点road[num-1]
void mkdir(char *dirname)//创建目录(规定目录文件只占一个盘块)当前目录下创建
{
INODE inode,inode2;
readinode( road[num-1],inode );//把当前i结点road[num-1]内容读入inode
if( havewpower(inode) )//判断权限
{
if(512-inode.fsize<36)//是否目录项已达到最多14个
{
cout<<"当前目录已满，创建子目录失败!";
}
else
{
int i,index2;
if( havesame(dirname,inode,i,index2) )//有无重名存在着
{
cout<<"该目录已存在，创建失败!";
}
else//可以创建目录
{
int iid=ialloc();//申请结点
if( iid!=-1 )
{
int bid=balloc();//申请盘块
if(bid!=-1)
{
//当前目录盘块的修改
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
disk.seekp( 514*inode.addr[0]+inode.fsize );
disk<<setw(15)<<dirname;//写目录名
disk<<setw(3)<<iid;//写结点
disk<<setw(15)<<curname;
disk<<setw(3)<<road[num-1];
disk.close();
//当前目录i结点的修改
inode.fsize+=36;
char tmpbuf[9];
_strtime(tmpbuf);
strcpy(inode.ctime,tmpbuf);
//新创目录i结点的初始化
/* */
inode2.fsize=0;//int fsize;文件大小
inode2.fbnum=1;//int fbnum;文件盘块数
inode2.addr[0]=bid;//int addr[4];四个直接盘块号(0 ~ 512*4==2048)
for(int aaa=1;aaa<4;aaa++)//指向0#表示没有指向
inode2.addr[aaa]=0;
inode2.addr1=0;//int addr1;一个一次间址()
inode2.addr2=0;//int addr2;一个两次间址()
strcpy( inode2.owner,auser );//char owner[6];文件拥有者
strcpy( inode2.group,agroup );//char group[6];文件所属组
strcpy( inode2.mode,"drwxrwxrwx" );//char mode[11]; 文件类别及存储权限(默认最高)
_strtime(tmpbuf);
strcpy( inode2.ctime,tmpbuf );//char ctime[9];最近修改时间
writeinode( inode2,iid );
/*
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
disk.seekp(514+64*iid+2*(iid/8));
disk<<setw(6)<<0; //int fsize;文件大小
disk<<setw(6)<<1; //int fbnum;文件盘块数
disk<<setw(3)<<bid; //int addr[4];四个直接盘块号(0 ~ 512*4==2048)
disk<<setw(3)<<0; //指向0#表示没有指向
disk<<setw(3)<<0;
disk<<setw(3)<<0;
disk<<setw(3)<<0; //int addr1;一个一次间址()
disk<<setw(3)<<0; //int addr2;一个两次间址()
disk<<setw(6)<<auser; //char owner[6];文件拥有者
disk<<setw(6)<<agroup; //char group[6];文件所属组
disk<<setw(12)<<"drwxrwxrwx"; //char mode[11]; 文件类别及存储权限(默认最高)
_strtime(tmpbuf);
disk<<setw(10)<<tmpbuf; //char ctime[9];最近修改时间
disk.close(); */
cout<<"目录已成功创建";
}
else
{
ifree(iid);//刚申请的结点释放掉
cout<<"盘块已用完，创建子目录失败!";
}
}
else
{
cout<<"结点已用完，创建子目录失败!";
}
}
}
}
else
{
cout<<"你没权限创建";
}
writeinode( inode,road[num-1] );//把inode写入指定结点
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
bool havesame(char *dirname,INODE inode,int &i,int &index2)//判断对象inode指向的目录文件盘块中有无该名的目录项存在着，有返回1无返回0
{//有该目录项，则按引用调用的i为待删子目录目录项下标 index2为目录项中的待删子目录的结点号
bool have=false;
char name[14];
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
for(i=0;i<(inode.fsize/36);i++)//遍历所有的目录项
{
disk.seekg(514*inode.addr[0]+36*i);
disk>>name;
if( !strcmp(dirname,name) )
{
have=true;
disk>>index2;
break;
}
}
disk.close();
return have;
}
/////////////////////////////////////////////////////////////////////////////////////////
int t=0;//记录递归重数 入口加1出口减1
/////////////////////////////////////////////////////////////////////////////////////////
void rmdir(char *dirname,int index)//删除目录 当前目录下删除 参数为 (子目录名,当前结点)
{
t++;
INODE inode,inode2;
DIR dir;
readinode(index,inode);//当前结点写入结点对象
if( havewpower(inode) )//判断权限
{
int i,index2;//i为待删子目录目录项下标 index2为目录项中的待删子目录的结点号
if( havesame(dirname,inode,i,index2) )//存在该子目录名
{
readinode(index2,inode2);//待删子目录的结点写入结点对象
if( havewpower(inode2) )//判断权限
{
if( inode2.mode[0]=='d' )//判断要删除的是目录文件而非数据文件
{
if( inode2.fsize!=0 )//判断待删子目录有无子目录==>有
{
//cout<<"该目录非空，不能删除";
char yes='y';
if(t==1)
{
cout<<"该目录非空，如果删除的话，将失去目录下所有文件，要继续吗?(y/n) ";
cin>>yes;
}
if( (yes=='y') || (yes=='Y') )
{
//遍历待删子目录(inode2)所有子目录，递归将其删除
char name[14];
int index3;
INODE inode3;
for(int i=0;i<(inode2.fsize/36);i++)//遍历所有的目录项
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
disk.seekg(inode2.addr[0]*514+36*i);
disk>>name;
disk>>index3;
disk.close();
readinode(index3,inode3);
if(inode3.mode[0]=='d')//是目录文件
{
rmdir(name,index2);
}
else//是数据文件
{
rm(name);
}
}
rmdir(dirname,index);//子目录空了后再删除自己
}
else
{
cout<<"目录删除失败";
}
}
else//空目录删除
{
//回收盘块和结点
bfree( inode2.addr[0] );
ifree( index2 );
//对当前目录盘块的修改 inode.addr[0]当前盘块号 i待删子目录目录项下标
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
disk.seekp(514*inode.addr[0]+36*i);//清空当前
disk<<setw(36)<<' ';
disk.close();
for(int j=i+1;j<(inode.fsize/36);j++)//后面的前移一位
{
readdir(inode,j,dir);//inode指向盘块读入
writedir(inode,dir,j-1);
}
//对当前目录i结点的修改
inode.fsize-=36;
char tmpbuf[9];
_strtime(tmpbuf);
strcpy( inode.ctime,tmpbuf );
}
cout<<"目录成功删除 ";
//修改当前i结点
inode.fsize-=36;
char tmpbuf[9];
_strtime(tmpbuf);
strcpy(inode.ctime,tmpbuf);
}
else
{
cout<<"数据文件应用rm命令删除";
}
}
else
{
cout<<"你没有权限";
}
}
else
{
cout<<"目录中不存在该子目录!!!";
}
}
else
{
cout<<"你没有权限";
}
writeinode(inode,index);
t--;
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void ls(void)//显示当前结点的所有子目录
{
INODE inode,inode2;
readinode( road[num-1],inode );
char name[14];
int index;
for(int i=0;i<(inode.fsize/36);i++)//遍历所有的目录项
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
disk.seekg(inode.addr[0]*514+36*i);
disk>>name;
disk>>index;
disk.close();
readinode( index,inode2 );
cout<<setw(15)<<name<<setw(6)<<inode2.fsize<<setw(6)<<inode2.owner;
cout<<setw(6)<<inode2.group<<setw(12)<<inode2.mode<<setw(10)<<inode2.ctime<<endl;
}
cout<<"显示完毕";
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
void cd(char *string)//改变当前目录****(文件名 切换到子目录 ..切换到父目录 /切换到根目录)须切换到目录文件
{
if( !strcmp(string,".") )//切换到当前目录
{
cout<<"已切换到当前目录";
return;
}
if( !strcmp(string,"/") )//切换到根目录
{
strcpy(curname,"root");
road[0]=0;
num=1;
cout<<"已切换到根目录";
return;
}
if( !strcmp(string,"..") )//切换到父目录
{
if( strcmp(curname,"root") )//当前不是根目录才可切换
{
INODE inode;
readinode(road[num-2],inode);//父目录结点号
char name[14];
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );//得到父目录名(从父目录任一目录项)
disk.seekg(inode.addr[0]*514+18);
disk>>name;
disk.close();
strcpy(curname,name);
num--;
cout<<"已切换到父目录";
return;
}
cout<<"当前已是根目录";
return;
}
char *per=strchr(string,(int)'/');
if(per==NULL) //没有‘/’给的是子目录名 切换到某一子目录
{
INODE inode,inode2;
int i,index2;
readinode(road[num-1],inode);
char name[14];
if( havesame( string,inode,i,index2) )
{
readinode(index2,inode2);
if(inode2.mode[0]=='d')
{
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
disk.seekg(514*inode.addr[0]+36*i);
disk>>name;
disk.close();
strcpy(curname,name);
road[num]=index2;
num++;
cout<<"已切换到子目录";
return;
}
cout<<"不能根据路径找到相关目录,因为 "<<string<<" 是数据文件";
}
else
{
cout<<"该子目录不存在，不能根据路径找到相关目录";
}
}
else //根据指定路径切换目录
{
char tcurname[14];//保存当前路径
int troad[20];
int tnum=num;
strcpy(tcurname,curname);
for(int i=0;i<num;i++)
{
troad[i]=road[i];
}
if( find(string) )//如果找到目标（当前路径跟着改了）
{
INODE inode;
readinode(road[num-1],inode);
if(inode.mode[0]=='d')//确定是目录文件
{
cout<<"已切换到该目录";
return;
}
}
cout<<"不能根据路径找到相关目录";//找不到目标，还原
strcpy(curname,tcurname);
num=tnum;
for(int ii=0;ii<tnum;ii++)
{
road[ii]=troad[ii];
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
bool find(char *string)//根据路径找到指定文件或目录（当前路径跟着改了）<路径至少有一个‘/’以root开头，不以‘/’结尾>
{
int ptr=0;
char name[14]=" ";
INODE inode;
//读根目录
for(int i=0 ; string[ptr]!='/' ; ptr++ ,i++)
{
if(i==15) return 0;//超过正常长度，肯定错
name[i]=string[ptr];
}
if( !strcmp(name,"root") ) //第一个应该肯定是"root"
{
strcpy(curname,"root");//初始化当前路径
road[0]=0;
num=1;
for(;;)
{
readinode(road[num-1],inode);//当前结点读入
ptr++;
char name[14]=" ";
for(int i=0; (string[ptr]!='/')&&(string[ptr]!='\0') ; ptr++ ,i++)//从string读入一个名字
{
if(i==15) return 0;//超过正常长度，肯定错
name[i]=string[ptr];
}
int ii,index2;//当前目录查找该目录项
if( havesame(name,inode,ii,index2) )
{
char tname[14];
//路径下一步
disk.open("disk.txt",ios::in | ios::out | ios::nocreate );
disk.seekg(514*inode.addr[0]+36*ii);
disk>>tname;
disk.close();
strcpy(curname,tname);
road[num]=index2;
num++;
//判断字符串结尾
if( string[ptr]=='\0' )
{
return 1;
}
}
else
{
return 0;
}
}
}
else
{
return 0;
}
}
/////////////////////////////////////////////////////////////////////////////////////////
6.file.h
/////////////////////////////////////////////////////////////////////////////////////////
void mk(char *filename,char *content)//创建数据文件(规定目录文件只占1 ~ 4个盘块)当前目录下创建
{
INODE inode,inode2;
readinode( road[num-1],inode );//把当前i结点road[num-1]内容读入inode
if( havewpower(inode) )//判断权限
{
if(512-inode.fsize<36)//是否目录项已达到最多14个
{
cout<<"当前目录已满，创建子目录失败!";
}
else
{
int i,index2;
if( havesame(filename,inode,i,index2) )//有无重名存在着
{
cout<<"该名已存在，创建失败!";
}
else//可以创建目录
{
int size=strlen(content)+1;
/*cout<<"请输入所创文件的大小(1 ~ 2048)";//最多四个盘块
cin>>size;*/
if( size>2048 )
{
cout<<"\n文件太大，创建失败!";
}
else
&