fileprocess.h

文件管理系统

#include"block.h"

TBlock block;


class TFcb
{
public:
	TFcb();
	~TFcb();
	int Balfcb();						//分配空闲fcb,-1为分配失败
	void Brefcb(int bno);				//释放fcb	
	bool CD(char* dirname,TUser& user);//设置目录
	bool CD__(TUser& user);				//返回上一层目录
	bool CheckUser(string tempuser){return true;}		//确认用户名是否存在
	bool CheckPword(string temppw){return true;}			//确认密码是否正确
	bool CheckUW(char* tempuser,char* tempw,TUser &refuser);			//用于登陆确认
	bool CreateDir(char* dirname,TUser& user);//创建目录
	void Directory(TUser& user);//用于dir命令，用于遍历目录
	bool DelDir(char* dirname,TUser& user);//用于rd命令,删除目录
	bool DelFile(char* filename,TUser& user);//用于del命令，删除文件
	void EnterUser();					//录入用户信息
	bool FCFile(char* filename,TUser& user);			//创建新文件
	Hfcb FindFree(TUser& user);							//查找存储文件结构的空闲空间
	bool IsFirst();
	void JustWrRight(char* fname,TUser& user);//判断用户是否有权限写,如有权限则对文件进行写入
	Hfcb Namei(char* fdname,TUser& user);				//查找文件或目录结构的存储位置
	bool OpenFile(char* fdname,TUser& user);//用于open命令，打开文件
	void ReadFile(char* fname,TUser& user);//用于read命令，读文件
	void SaveDirfcb(SFcb* tfcb);							//将更改后的fcb存到硬盘中去
	void SaveFileNode();								//将创建好的文件或目录结构存到硬盘中
	void SetFile(int flag,TUser& user,char* fname);//用于set命令，设置文件属性
	void ShowUser();//用于user命令，显示当前已注册用户信息
	void WFUser(USERINFO info);			//向文件中写入用户信息
	bool Write(dir* td);				//向文件中写入内容
	

protected:
	
	bool first;	
	char* buf;
};

TFcb::TFcb()
{
	if((buf=new char[BLOCK])==NULL)
	{
		cout<<"RAM deficient!\n";
		exit(0);
	}
	first=block.IsFirst();
	for(int i=0;i<FCBMAX;i++)//初化始FCB数组
		tfcb[i].f_flag=FCBFLAG;
	
}

TFcb::~TFcb()
{
	delete[]buf;
}

int TFcb::Balfcb()//从数组tfcb中分配空闲fcb
{
	int i=0;
	for(i=0;i<FCBMAX;i++)
	{
		if(tfcb[i].f_flag==FCBFLAG)
			return i;
		else
			continue;
	}
	return -1;
}

void TFcb::Brefcb(int bno)//释放已申请fcb
{
	tfcb[bno].f_flag=FCBFLAG;
}

bool TFcb::CD(char* dirname,TUser& user)//设置文件目录
{
	Hfcb fd=Namei(dirname,user);//查找目录文件存储的位置，
	if(fd.blkno==-1)//为－1时说明，该目录不存在
	{
		cout<<"Can not find the DIR!\n";
		return false;
	}
	char* tempbuf=NULL;
	if((tempbuf=new char[BLOCK])==NULL)
	{
		cout<<"RAM deficient!\n";
		return false;
	}
	block.Bread(fd.blkno,tempbuf);
	dir* td=(dir*)(tempbuf+fd.offset);
	if(td->d_mode==IFDIR)//如果该目录存在则将user中当前目录指针，指向该目录
	{
		user.u_cdir->f_fsize=td->d_fsize;
		user.u_cdir->f_gid=td->d_gid;
		user.u_cdir->f_uid=td->d_uid;
		user.u_cdir->f_mode=td->d_mode;
		int na;
		for(na=0;na<8;na++)
			user.u_cdir->f_name[na]=td->d_name[na];
		for(int i=0;i<10;i++)
		{
			user.u_cdir->f_add[i]=td->d_add[i];
		}
		user.u_cdir->f_blkno=fd.blkno;
		user.u_cdir->f_number=fd.offset;
		delete[]tempbuf;
		return true;
	}
	else
	{
		cout<<"Can not find the DIR!\n";
		delete[]tempbuf;
		return false;
	}
}

bool TFcb::CD__(TUser &user)//用于cd..命令，进入上一层目录
{
	char* tempbuf=NULL;
	if((tempbuf=new char[BLOCK])==NULL)
	{
		cout<<"RAM deficient!"<<endl;
		return false;
	}
	int blk,offset;
	block.Bread(user.u_cdir->f_add[0],tempbuf);//读出存在子目录中根目录的信息
	dir* td=(dir*)(tempbuf);
	blk=td->d_add[0];
	offset=td->d_fsize;
	block.Bread(blk,tempbuf);//从真正存放根目录的地方读出跟目录信息
	td=(dir*)(tempbuf+offset);
	if(td->d_mode==IFDIR||td->d_mode==IFROOT||td->d_mode==ROOT)//确保该目录的存在
	{
		user.u_cdir->f_fsize=td->d_fsize;
		user.u_cdir->f_gid=td->d_gid;
		user.u_cdir->f_uid=td->d_uid;
		user.u_cdir->f_mode=td->d_mode;
		int na;
		for(na=0;na<8;na++)
			user.u_cdir->f_name[na]=td->d_name[na];
		for(int i=0;i<10;i++)
		{
			user.u_cdir->f_add[i]=td->d_add[i];
		}
		user.u_cdir->f_blkno=blk;
		user.u_cdir->f_number=offset;
		delete[]tempbuf;
		return true;
	}
	else
	{
		cout<<"Can not find the DIR!\n";
		delete[]tempbuf;
		return false;
	}
}


bool TFcb::CheckUW(char* tempuser,char* tempw,TUser& refuser)//用户登陆时，验证用户名和密码
{
	if(tempuser==NULL||tempw==NULL)
		return false;
	
	int i=0,basic=256,f;
	USERINFO *un=NULL;
	char* tempbuf=NULL;
	if((tempbuf=new char[512])==NULL)
	{
		cout<<"RAM deficient!\n";
		exit(0);
	}
	if((block.Bread(0,tempbuf))==false)//读出存储用户信息的块即#0块
		return false;
	
	for(i=0;i<USERNUM;i++)//USERNUM为可以创建的最大用户数
	{
		un=(USERINFO*)(tempbuf+256+sizeof(USERINFO)*i);
		if(un->d_flag==-1)//判断该位置是不是存储了用户信息
			continue;
		else
		{
			if((strcmp(tempuser,un->d_name))==0)//判断是否是该用户
			{
				if((strcmp(tempw,un->password))==0)//判断密码是否相符
				{
					//初始化根目录的fcb
					dir* tempdir=(dir*)(tempbuf+BLOCK-sizeof(dir));
					int tempnum=Balfcb();
					//初始化user
					if(tempnum==-1)
						cout<<"Can not build so many FCB's!\n";
					tfcb[tempnum].f_count=1;
					tfcb[tempnum].f_flag=FCBUSE;
					tfcb[tempnum].f_blkno=0;
					tfcb[tempnum].f_number=BLOCK-sizeof(dir);
					tfcb[tempnum].f_uid=tempdir->d_uid;
					tfcb[tempnum].f_gid=tempdir->d_gid;
					tfcb[tempnum].f_fsize=tempdir->d_fsize;
					tfcb[tempnum].f_mode=tempdir->d_mode;
					int na;
					for(na=0;na<8;na++)
						tfcb[tempnum].f_name[na]=tempdir->d_name[na];
					for(f=0;f<10;f++)
						tfcb[tempnum].f_add[f]=tempdir->d_add[f];
					//初始化用户结构
					for(na=0;na<8;na++)
						user[fun].u_name[na]=un->d_name[na];
					user[fun].u_uid=un->d_uid;
					user[fun].u_gid=un->d_gid;
					user[fun].u_cdir=&tfcb[tempnum];
					for(f=0;f<5;f++)
						user[fun].u_ofile[f]=NULL;

					delete[]tempbuf;
					return true;
				}
				else
					continue;
			}
			else
				continue;
		}
	}
	return false;
}

bool TFcb::CreateDir(char* dirname,TUser& user)//创建目录
{
	Hfcb fd;
	fd=Namei(dirname,user);//查找是否存在同名文件目录
	if(fd.blkno!=-1)
	{
		cout<<"A DIR in the name have existed!\n";
		return false;
	}
	fd=FindFree(user);//查找空闲的存储区域
	int i;
	if(fd.blkno==-1)
	{
		cout<<"Storage space deficient!\n";
		return false;
	}
	char* tempbuf=NULL;
	if((tempbuf=new char[BLOCK])==NULL)
	{
		cout<<"RAM deficient!\n";
		return false;
	}
	
	char* tempblock=NULL;
	if((tempblock=new char[BLOCK])==NULL)
	{
		cout<<"RAM deficient!\n";
		return false;
		delete[]tempbuf;
	}
	for(i=0;i<BLOCK;i++)
	{
		tempbuf[i]='\0';
		tempblock[i]='\0';
	}
	block.Bread(fd.blkno,tempbuf);//读出含有空闲区域的块
	dir* newdir=(dir*)(tempbuf+fd.offset);//指向分配的目录结构空间
	for(i=0;i<10;i++)//将新的目录结构写入
		newdir->d_add[i]=-1;
	newdir->d_gid=user.u_gid;
	newdir->d_uid=user.u_uid;
	newdir->d_mode=IFDIR;
	newdir->d_fsize=1;
	int na;
	for(na=0;na<8;na++)
		newdir->d_name[na]=dirname[na];
	if((newdir->d_add[0]=block.Balloc())==-1)//为新建的目录，分配一个空闲块
	{
		cout<<"Storage space deficient!\n";
		delete[]tempbuf;
		delete[]tempblock;
		return false;
	}
	else
	{
		block.Bread(newdir->d_add[0],tempblock);//读出当前目录结构的块
		dir* rootdir=(dir*)(tempblock);//子目录中存储上一层目录结构(类似于DOS中..目录的作用)
		for(i=0;i<10;i++)
		{
			rootdir->d_add[i]=-1;
		}
		rootdir->d_add[0]=user.u_cdir->f_blkno;//父目录所存储的块
		rootdir->d_fsize=user.u_cdir->f_number;//父目录存储在块中的偏移地址
		rootdir->d_gid=user.u_cdir->f_gid;
		rootdir->d_uid=user.u_cdir->f_uid;
		rootdir->d_mode=IFROOT;
		int na=0;
		for(na=0;na<8;na++)
			rootdir->d_name[na]=user.u_cdir->f_name[na];
		for(i=1;i<FILENUM;i++)//将未用的目录结构置空间标志
		{
			rootdir=(dir*)(tempblock+i*sizeof(dir));
			rootdir->d_mode=NONODE;
		}
		user.u_cdir->f_fsize+=1;
		TFcb::SaveDirfcb(user.u_cdir);//将修改后的父目录结构写回磁盘
		block.BWrite(fd.blkno,tempbuf);//将目录文件结构写入磁盘
		block.BWrite(newdir->d_add[0],tempblock);//将子目录下面的信息写入磁盘
		delete[]tempbuf;
		delete[]tempblock;
		return true;
	}
}

void TFcb::Directory(TUser& user)//用于dir命令
{
	char* tempbuf=NULL;
	int i=0,j,count,k;
	dir* tempdir=NULL;
	if((tempbuf=new char[BLOCK])==NULL)
	{
		cout<<"RAM deficient!\n";
		return ;
	}
	for(i=0;i<BLOCK;i++)
	{
		tempbuf[i]='\0';
	}
	for(i=0,count=0;i<10&&count<user.u_cdir->f_fsize;i++)//遍历所以有目录结构
	{
		if(user.u_cdir->f_add[i]<=0||user.u_cdir->f_add[i]>=2048)
		{
			break;
		}
		else
		{
			block.Bread(user.u_cdir->f_add[i],tempbuf);
			
			for(j=0;j<FILENUM&&count<user.u_cdir->f_fsize;j++)
			{
				tempdir=(dir*)(tempbuf+j*sizeof(dir));
				if(tempdir->d_mode!=NONODE)//说明些结构已经被使用
				{
					if(tempdir->d_mode==IFDIR||tempdir->d_mode==IFROOT)//为子目录时
					{
						if(tempdir->d_mode==IFROOT)
							cout<<".."<<"      ";
						else
						{
							for(k=0;k<8;k++)
								cout<<tempdir->d_name[k];
						}
						cout<<"         ";
						cout<<"<dir>"<<endl;
						count++;
					}
					else//为文件时
					{
						for(k=0;k<8;k++)
							cout<<tempdir->d_name[k];
						cout<<"         ";
						cout<<tempdir->d_fsize<<"B";
						cout<<"         ";
						if(tempdir->d_mode==IREAD)
							cout<<"self\"read\"\n";
						if(tempdir->d_mode==IWRITE)
							cout<<"self\"write\"\n";
						if(tempdir->d_mode==IEXEC)
							cout<<"self\"run\"\n";
						if(tempdir->d_mode==GREAD)
							cout<<"group\"read\"\n";
						if(tempdir->d_mode==GWRITE)
							cout<<"group\"write\"\n";
						if(tempdir->d_mode==GEXEC)
							cout<<"group\"run\"\n";
						if(tempdir->d_mode==OREAD)
							cout<<"other\"read\"\n";
						if(tempdir->d_mode==OWRITE)
							cout<<"other\"write\"\n";
						if(tempdir->d_mode==OEXEC)
							cout<<"other\"run\"\n";
						count++;
					}
				}
				else
					continue;
			}
		}
	}
	delete[]tempbuf;
}

bool TFcb::DelDir(char* dirname,TUser& user)//删除目录
{
	Hfcb fd=Namei(dirname,user);//查找该目录结构存储的位置
	if(fd.blkno==-1)
	{
		cout<<"Can not find the DIR!\n";
		return false;
	}
	char* tempbuf=NULL;
	if((tempbuf=new char[BLOCK])==NULL)
	{
		cout<<"RAM deficient!\n";
		return false;
	}
	block.Bread(fd.blkno,tempbuf);
	dir* td=(dir*)(tempbuf+fd.offset);
	if(td->d_uid==user.u_cdir->f_uid||user.u_cdir->f_uid==0)//判断该用户是否有权限删除该目录
	{
		if(td->d_fsize>1)//如果该目录下还有文件或目录（..目录除外），则不能删除
		{
			cout<<"Can not delete a not empty DIR!\n";
			return false;
		}
		int i;
		for(i=0;i<10;i++)//释放该目录所占用的磁盘块
		{
			if(td->d_add[i]>0&&td->d_add[i]<2048)
			{
				block.Brelse(td->d_add[i]);
			}
			else
				break;
		}
		td->d_mode=NONODE;//将置目录结构置为空闲状态
		user.u_cdir->f_fsize-=1;//将父目录中文件目录数量减1
		SaveDirfcb(user.u_cdir);//将父目录结构写回磁盘
		block.BWrite(fd.blkno,tempbuf);//将修改后的目录结构块写回磁盘
		delete[]tempbuf;
		return true;
	}
	else
	{
		cout<<"You have no right to delete the DIR!\n";
		return false;
	}
}
	


bool TFcb::DelFile(char* filename,TUser& user)//删除文件。用于del命令
{
	Hfcb hf;
	hf=Namei(filename,user);//查找该文件结构存储的位置
	if(hf.blkno==-1)
	{
		cout<<"Can not find the file!\n";
		return false;
	}
	char* tempbuf=NULL;
	if((tempbuf=new char[BLOCK])==NULL)
	{
		cout<<"RAM deficient!\n";
		return false;
	}
	block.Bread(hf.blkno,tempbuf);
	dir* fd=(dir*)(tempbuf+hf.offset);
	if(fd->d_mode==IFDIR)
	{
		cout<<"Can not find the file!\n";
		delete[]tempbuf;
		return false;
	}
	if(fd->d_uid==user.u_uid||user.u_uid==0)//user为文件主或超级用户
	{
		fd->d_mode=NONODE;
		for(int i=0;i<10;i++)//释放文件所占的块空间
		{
			if(fd->d_add[i]>0&&fd->d_add[i]<2048) 
			{
				//cout<<"add"<<fd->d_add[i]<<endl;
				block.Brelse(fd->d_add[i]);
			}
			else
				break;
		}
		block.BWrite(hf.blkno,tempbuf); 
		user.u_cdir->f_fsize-=1;
		SaveDirfcb(user.u_cdir);//将当前目录的fcb写回硬盘
		delete[]tempbuf;
		return true;
	}
	else
	{
		cout<<"You have no right to delete the file!\n";
		return false;
		delete[]tempbuf;
	}
}


bool TFcb::FCFile(char* filename,TUser& user)//用于create命令，创建文件
{
	if(filename==NULL)
		return false;
	Hfcb fdpos;
	dir* td=NULL;
	char* tempbuf=NULL;
	fdpos=Namei(filename,user);//查找是否存在同名目录文件
	if(fdpos.blkno!=-1)
	{
		cout<<"The file have existed!\n";
		return false;
	}
	else
	{
		fdpos=FindFree(user);//查找空闲的文件目录结构空间
		if(fdpos.blkno==-1)//未到空闲空间
		{
			cout<<"Storage space inficient, can not build a file!\n";
			return false;
		}
		else
		{
			if((tempbuf=new char[BLOCK])==NULL)
			{
				cout<<"RAM deficient!\n";
				return false;
			}
			//创建文件
			block.Bread(fdpos.blkno,tempbuf);//读出存储目录结构的块
			td=(dir*)(tempbuf+fdpos.offset);
			td->d_gid=user.u_gid;
			td->d_mode=user.u_error;
			int na=0;
			for(na=0;na<8;na++)
				td->d_name[na]=filename[na];
			td->d_uid=user.u_uid;