unix文件模拟系统.cpp

该模拟的UNIX文件系统应该有以下功能： 多级目录的结构

		{
			printf( "Can't creat file\n" );
			return 0;
		}
		// 找空闲用户打开表项  
		for( j = 0; j < NOFILE; j++ )
		{
			if( user[user_id].u_ofile[j] == SYSOPENFILE + 1 ) 
				break;
		}
		if( j == NOFILE )
		{
			printf( "Can't creat file\n" );
			return 0;
		}
		// 写系统打开表项信息  
		user[user_id].u_ofile[j] = i;
		sys_ofile[i].f_flag = mode;
		sys_ofile[i].f_count = 1;
		sys_ofile[i].f_off = 0;
		sys_ofile[i].f_inode = inode;

		return j;		                 // 返回文件描述符  
	}
	return  0;
}

// 删除文件  
void _delete( char * filename )
{
	unsigned int dinodeid;
	struct inode * inode;
	struct dir tempdir;
	int i;

	dinodeid = namei( filename );
	if(( dinodeid == NULL ) || ( dinodeid == -1 ))	// 找不到该文件  
	{
		printf( "rm: %s: No such file\n", filename );
		return;
	}

	inode = iget( dinodeid );
	if( !( inode->i_mode & DIREG ))			// 不是文件  
	{
		printf( "rm: %s: Not a file\n", filename );
		iput( inode );
		return;
	}
	if( !( access( inode ) & WRITE))		// 没有权限  
	{
		printf( "bash: %s: Permission denied\n", filename );
		iput( inode );
		return;
	}

	if( pre_dinodeid == cur_path_inode->i_ino )
	{
		for( i = 0; i < dir.size; i++ )
		{
			if( dir.direct[i].d_ino == dinodeid )
				break;
		}
		for( ; i < dir.size - 1; i++ )
		{
			dir.direct[i].d_ino=dir.direct[i + 1].d_ino;
			strcpy(dir.direct[i].d_name, dir.direct[i + 1].d_name);
		}
		dir.direct[i].d_ino = 0;
		strcpy( dir.direct[i].d_name, " " );
		dir.size--;
	}
	else
	{
		tempdir = getdir( pre_dinodeid, " " );

		for( i = 0; i < tempdir.size; i++ )
		{
			if( tempdir.direct[i].d_ino == dinodeid )
				break;
		}
		for( ; i < tempdir.size - 1; i++ )
		{
			tempdir.direct[i].d_ino=tempdir.direct[i + 1].d_ino;
			strcpy(tempdir.direct[i].d_name,tempdir.direct[i + 1].d_name);
		}
		tempdir.direct[i].d_ino = 0;
		strcpy( tempdir.direct[i].d_name, " " );
		tempdir.size--;

		putdir( pre_dinodeid, tempdir );
	}

	inode->i_number--;
	iput( inode );
}

// 打开文件  
int open( char * filename, unsigned short openmode )
{
	unsigned int dinodeid;
	struct inode * inode;
	int i, j;

	// 检索目录  
	dinodeid = namei( filename );
	if( dinodeid == -1 )
	{
		printf( "No such directory\n" );
		return -1;
	}

	if( dinodeid == NULL )
	{
		if( openmode & O_CREAT )
			return creat( filename, openmode & ( ~ O_CREAT ));

		printf( "File does not existed\n" );
		return -1;
	}

	// 分配内存i节点  
	inode = iget( dinodeid );

	if( !access( inode ))
	{
		printf( "File open has not access\n" );
		iput( inode );
		return -1;
	}

	// 分配文件表项  
	for( i = 0; i < SYSOPENFILE; i++ )
	{
		if( sys_ofile[i].f_count == 0 )
			break;
	}
	if( i == SYSOPENFILE )
	{
		printf( "System open file too much\n" );
		iput( inode );
		return -1;
	}

	// 分配用户文件描述表项  
	for( j = 0; j < NOFILE; j++ )
		if( user[user_id].u_ofile[j] == SYSOPENFILE + 1 )
			break;
	if( j == NOFILE )
	{
		printf( "user open file too much\n" );
		iput( inode );
		return -1;
	}

	sys_ofile[i].f_inode = inode;
	sys_ofile[i].f_flag = openmode;
	sys_ofile[i].f_count++;

	// 读/写指针置位  
	if( openmode & O_APPEND )
		sys_ofile[i].f_off = inode->i_size;		// 读/写指针置于文件尾  
	else
		sys_ofile[i].f_off = 0;					// 读/写指针置于文件开始位置  

	user[user_id].u_ofile[j] = i;

	// 将原来存在的文件清空  
	if( openmode & O_TRUNC )
	{
		for( i = 0; i < inode->i_size / BLOCKSIZ + 1; i++ )
			bfree( inode->i_addr[i] );
		inode->i_size = 0;
	}

	return j;
}

void close( int cfd )
{
	int sys_ip;
	
	// 获得指向文件表项的指针sys_ip  
	sys_ip = user[user_id].u_ofile[cfd];

	// 释放内存i节点  
	iput( sys_ofile[sys_ip].f_inode );

	// 文件表项引用计数减1  
	sys_ofile[sys_ip].f_count--;

	// 清空用户打开表  
	user[user_id].u_ofile[cfd] = SYSOPENFILE + 1;
}

// 读文件  
int read( int fh, char * buf, unsigned int nbyte )
{
	unsigned long off;
	unsigned  int block, block_off, i, sys_ip;
	struct inode * inode;

	sys_ip = user[user_id].u_ofile[fh];
	inode = sys_ofile[sys_ip].f_inode;

	if( !( sys_ofile[sys_ip].f_flag & O_RDONLY ))
	{
		printf( "The file is not opened for read\n" );
		return -1;
	}

	off = sys_ofile[sys_ip].f_off;
	block = off / BLOCKSIZ;		// 从inode->i_addr[block]号盘块读起  
	block_off = off % BLOCKSIZ;		// block_off是在block号盘块中的偏移量  

	// 读写指针在文件末尾，读出字数为0  
	if( off == inode->i_size )
		return 0;

	// 读文件不用跨越盘块，即在一盘块中就可读出nbyte字  
	if( block_off + nbyte < BLOCKSIZ )
	{
		fseek( fd, 
			DATASTART + inode->i_addr[block] * BLOCKSIZ + block_off, 
			SEEK_SET );
		fread( buf, 1, nbyte, fd );
		return nbyte;
	}

	// 读文件跨越盘块，即所读的文件有多个盘块  

	// 先读block盘块  
	fseek( fd, 
		DATASTART + inode->i_addr[block] * BLOCKSIZ + block_off, 
		SEEK_SET );
	fread( buf, 1, BLOCKSIZ - block_off, fd );
	buf += BLOCKSIZ - block_off;

	block++;
	// 所读的文件没有到末尾  
	if( nbyte + off < inode->i_size )
{for(i=0;i<(nbyte-block_off)/BLOCKSIZ;i++) 
		{
			
	      fseek( fd, DATASTART + inode->i_addr[i+block] * BLOCKSIZ + block_off, SEEK_SET );
		  fwrite( buf, 1, BLOCKSIZ, fd );
           buf += BLOCKSIZ;
		}
      fseek( fd, DATASTART + inode->i_addr[i + block] * BLOCKSIZ, SEEK_SET );
		fread( buf, 1, ( nbyte - block_off ) % BLOCKSIZ, fd );
		
		// 置文件读/写指针位置  
		sys_ofile[sys_ip].f_off += nbyte;

		return nbyte;
}
	// 所读的文件到末尾  
	for( i = block; i < inode->i_size / BLOCKSIZ; i++ )
	{
		fseek( fd, 
			DATASTART + inode->i_addr[i] * BLOCKSIZ, 
			SEEK_SET );
		fread( buf, 1, BLOCKSIZ, fd );
		buf += BLOCKSIZ;
	}
	fseek( fd, DATASTART + inode->i_addr[i] * BLOCKSIZ, SEEK_SET );
	fread( buf, 1, inode->i_size % BLOCKSIZ, fd );
	sys_ofile[sys_ip].f_off = inode->i_size;
	return ( inode->i_size - off );
}

// 写文件  
int write( int fh, char * buf, unsigned int nbyte )
{unsigned long off;
unsigned short  block, block_off, i, sys_ip;
struct inode * inode;

sys_ip = user[user_id].u_ofile[fh];
inode = sys_ofile[sys_ip].f_inode;
if( !( sys_ofile[sys_ip].f_flag & O_WRONLY ))
	{
		printf( "The file is not opened for write\n" );
		return -1;
	}

	off = sys_ofile[sys_ip].f_off;

	block = off / BLOCKSIZ;		// 从inode->i_addr[block]号盘块起开始写  
	block_off = off % BLOCKSIZ;		// block_off是在block号盘块中的偏移量  

	// 写文件不用跨越盘块，即在一盘块中就可写入nbyte字  
	if( block_off + nbyte < BLOCKSIZ )
	{
		fseek( fd, DATASTART + inode->i_addr[block] * BLOCKSIZ + block_off, SEEK_SET );
		fwrite( buf, 1, nbyte, fd );
		if( inode->i_size < nbyte )
			inode->i_size = nbyte;
		return nbyte;
	}

	// 写文件跨越盘块，即所写的文件有多个盘块  

	// 先往block盘块写入  
	fseek( fd, DATASTART + inode->i_addr[block] * BLOCKSIZ + block_off, SEEK_SET );
	fwrite(buf, 1, BLOCKSIZ - block_off, fd );
    buf += BLOCKSIZ - block_off;

	// 所写的文件没有到末尾  
	if(nbyte + off < inode->i_size )
	{
		for(i=0;i<(nbyte-block_off)/BLOCKSIZ;i++) 
			{
			inode->i_addr[block+i] = balloc();
	       fseek( fd, DATASTART + inode->i_addr[block] * BLOCKSIZ + block_off, SEEK_SET );
		  fwrite( buf, 1, BLOCKSIZ, fd );
           buf += BLOCKSIZ;
			}
		}
        fseek( fd, DATASTART + inode->i_addr[i + block] * BLOCKSIZ, SEEK_SET );
		fwrite( buf, 1, ( nbyte - block_off ) % BLOCKSIZ, fd );
		
		// 置文件读/写指针位置  
		sys_ofile[sys_ip].f_off += nbyte;

		if( inode->i_size < nbyte )
		{inode->i_size = nbyte;
         return nbyte;
		}
	// 所读的文件到末尾  

	// 写到文件尾  
	for( i = block; i < inode->i_size / BLOCKSIZ; i++ )
	{
		fseek( fd, DATASTART + inode->i_addr[i] * BLOCKSIZ, SEEK_SET );
		fwrite( buf, 1, BLOCKSIZ, fd );
		buf += BLOCKSIZ;
	}

	// 申请空间再写  
	for(i=0;i<(nbyte-block_off)/BLOCKSIZ;i++) 
	{	inode->i_addr[block+i] = balloc();
		fseek( fd, DATASTART + inode->i_addr[i] * BLOCKSIZ, SEEK_SET );
		fwrite( buf, 1, BLOCKSIZ, fd );
		buf += BLOCKSIZ;
	}

	fseek(fd, DATASTART + inode->i_addr[i] * BLOCKSIZ, SEEK_SET );
	fwrite( buf, 1, ( nbyte + off ) % BLOCKSIZ, fd );
	inode->i_size = nbyte + off;
	sys_ofile[sys_ip].f_off = inode->i_size;

	if( inode->i_size < nbyte )
			inode->i_size = nbyte;
	return nbyte;

}


// 改变文件或目录权限  
void chmod( char * pathname, char * modename )
{
	struct inode * inode;
	int dinodeid;

	dinodeid = namei( pathname );
	if(( dinodeid == -1 ) || ( dinodeid == NULL ))
	{
		printf( "chmod: '%s': No such file or directory\n", pathname );
		return;
	}
	inode = iget( dinodeid );
	if( inode->i_uid - 1 != user_id )			// 该用户不是文件主  
	{
		iput( inode );
		printf( "chmod: '%s': Permission denied\n", pathname );
		return;
	}
	if(( modename[0] == '+' ) ||( modename[0] == '=' ))
	{
		switch( modename[2] )
		{
			case 'u':					// 文件主权限  
			{
				switch( modename[1] )
				{
					case 'r': inode->i_mode = inode->i_mode | UREAD; break;
					case 'w': inode->i_mode = inode->i_mode | UWRITE; break;
					case 'x': inode->i_mode = inode->i_mode | UEXE; break;
					default: printf( "chmod: '%s': No such option\n", pathname );
				}
				break;
			}
			case 'g':				// 同组用户权限  
			{
				switch( modename[1] )
				{
					case 'r': inode->i_mode = inode->i_mode | GREAD; break;
					case 'w': inode->i_mode = inode->i_mode | GWRITE; break;
					case 'x': inode->i_mode = inode->i_mode | GEXE; break;
					default: printf( "chmod: '%s': No such option\n", pathname );
				}
				break;
			}
			case 'o':				// 其它用户权限  
			{
				switch( modename[1] )
				{
					case 'r': inode->i_mode = inode->i_mode | OREAD ; break;
					case 'w': inode->i_mode = inode->i_mode | OWRITE; break;
					case 'x': inode->i_mode = inode->i_mode | OEXE; break;
					default: printf( "chmod: '%s': No such option\n", pathname );
				}
				break;
			}
			case 'a':					// 所有用户权限  
			{
				switch( modename[1] )
				{
					case 'r': inode->i_mode = inode->i_mode | UREAD | GREAD | OREAD; break;
					case 'w': inode->i_mode = inode->i_mode | UWRITE | GWRITE | OWRITE; break;
					case 'x': inode->i_mode = inode->i_mode | UEXE | GEXE | OEXE; break;
					default: printf( "chmod: '%s': No such option\n", pathname );
				}
				break;
			}
		}
	}
	else if( modename[0] == '-' )
	{
		switch( modename[2] )
		{
			case 'u':
			{
				switch( modename[1] )
				{
					case 'r': inode->i_mode = inode->i_mode & ( ~ UREAD ); break;
					case 'w': inode->i_mode = inode->i_mode & ( ~ UWRITE ); break;
					case 'x': inode->i_mode = inode->i_mode & ( ~ UEXE ); break;
					default: printf( "chmod: '%s': No such option\n", pathname );
				}
				break;
			}
			case 'g':
			{
				switch( modename[1] )
				{
					case 'r': inode->i_mode = inode->i_mode & ( ~ GREAD ); break;
					case 'w': inode->i_mode = inode->i_mode & ( ~ GWRITE ); break;
					case 'x': inode->i_mode = inode->i_mode & ( ~ GEXE ); break;
					default: printf( "chmod: '%s': No such option\n", pathname );
				}
				break;
			}
			case 'o':
			{
				switch( modename[1] )
				{
					case 'r': inode->i_mode = inode->i_mode & ( ~ OREAD ); break;
					case 'w': inode->i_mode = inode->i_mode & ( ~ OWRITE ); break;
					case 'x': inode->i_mode = inode->i_mode & ( ~ OEXE ); break;
					default: printf( "chmod: '%s': No such option\n", pathname );
				}
				break;
			}
			case 'a':
			{
				switch( modename[1] )
				{
					case 'r': inode->i_mode = inode->i_mode & ( ~ ( UREAD | GREAD | OREAD )); break;
					case 'w': inode->i_mode = inode->i_mode & ( ~ ( UWRITE | GWRITE | OWRITE )); break;
					case 'x': inode->i_mode = inode->i_mode & ( ~ ( UEXE | GEXE | OEXE )); break;
					default: printf( "chmod: '%s': No such option\n", pathname );
				}
				break;
			}
			default: printf( "chmod: '%s': No such option\n", pathname );
		}
	}
	iput( inode );
}

// 文件编辑器
void edlin( char * filename )
{	char buf[BLOCKSIZ];
	int i, fh;
	if(( fh = open(filename, DEFAULTMODE | O_CREAT )) == -1)
		printf( "Can't creat file %s\n", filename );
	printf( "输入一行字符串到文件中\n\n" );

	cin>>buf;
    i=strlen(buf);
    buf[i] = '\0';
	write(fh, buf, strlen(buf)+1);
	close( fh );

}

// 显示文件内容  
void list( char * filename )
{
	struct inode * inode;
	char * buf;
	int fh, dinodeid;

	dinodeid = namei( filename );
	inode = iget( dinodeid );
	buf = ( char * )malloc( inode->i_size );
	if(( fh = open( filename, O_RDONLY )) != -1 )
	{
		read( fh, buf, inode->i_size );
		printf( "%s\n", buf );
		close( fh );
	}
}