main.c

UNIX模拟系统模拟得很完善！

		// 以下重写一个文件  

		// 释放原有文件的磁盘块  
		for( i = 0; i < inode->i_size / BLOCKSIZ + 1; i++ )
			bfree( inode->i_addr[i] );
		inode->i_size = 0;
		
		// 该文件已经打开  
		for( i = 0; i < SYSOPENFILE; i++ )
			if( sys_ofile[i].f_inode == inode )
			{
				sys_ofile[i].f_off = 0;
				for( j = 0; j < NOFILE; j++ )
				{
					if( user[user_id].u_ofile[j] == i )
						return j;
				}
			}

			// 该文件还没有打开  
		for( i = 0; i < NOFILE; i++ )
			if( user[user_id].u_ofile[i] == SYSOPENFILE + 1 )
			{
				user[user_id].u_uid = inode->i_uid;
				user[user_id].u_gid = inode->i_gid;
				for( j = 0; j < SYSOPENFILE; j++ )
					if( sys_ofile[j].f_count == 0 )
					{
						user[user_id].u_ofile[i] = j;
						sys_ofile[j].f_off = 0;
						sys_ofile[j].f_count = 1;
						sys_ofile[j].f_inode = inode;
						sys_ofile[j].f_flag = inode->i_mode;
					}
				return i;
			}
	}
	else													// 文件不存在,建立新文件  
	{
		pre_inode = iget( pre_dinodeid );
		if( !( access( pre_inode ) | WRITE ))				// 父目录不能写  
		{
			iput( pre_inode );
			textcolor(12);
			printf( "You have no access to creat\n" );
			textcolor(7);
			return -1;
		}
		inode = ialloc();
		inode->i_addr[0] = balloc();

		// 父目录为当前目录  
		if( pre_dinodeid == cur_path_inode->i_ino )
		{
			di_ith = iname( dir, end_path_name );
			strcpy( dir.direct[di_ith].d_name, end_path_name );
			dir.direct[di_ith].d_ino = inode->i_ino;
			dir.size++;
		}
		else			//　父目录不是当前目录  
		{
			tempdir = getdir( pre_dinodeid, " " );
			di_ith = iname( tempdir, end_path_name );
			strcpy( tempdir.direct[di_ith].d_name, end_path_name );
			tempdir.direct[di_ith].d_ino = inode->i_ino;
			tempdir.size++;
			putdir( pre_dinodeid, tempdir );
		}

		// 设置i节点信息  
		inode->i_mode = mode | DIREG;
		inode->i_uid = user[user_id].u_uid;
		inode->i_gid = user[user_id].u_gid;
		inode->i_size = 0;
		inode->i_number = 1;
		
		// 找空闲的系统打开表项  
		for( i = 0; i < SYSOPENFILE; i++ )
		{
			if( sys_ofile[i].f_count == 0 )
				break;
		}
		if( i == SYSOPENFILE )
		{
			textcolor(12);
			printf( "Can't creat file\n" );
			textcolor(7);
			return 0;
		}
		// 找空闲用户打开表项  
		for( j = 0; j < NOFILE; j++ )
		{
			if( user[user_id].u_ofile[j] == SYSOPENFILE + 1 ) 
				break;
		}
		if( j == NOFILE )
		{
			textcolor(12);
			printf( "Can't creat file\n" );
			textcolor(7);
			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;		                 // 返回文件描述符  
	}
}

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

	dinodeid = namei( filename );
	if(( dinodeid == NULL ) || ( dinodeid == -1 ))	// 找不到该文件  
	{
		textcolor(12);
		printf( "rm: %s: 文件不存在\n", filename );
		textcolor(7);
		return;
	}

	inode = iget( dinodeid );
	if( !( inode->i_mode & DIREG ))			// 不是文件  
	{
		textcolor(12);
		printf( "rm: %s: 不是文件\n", filename );
		textcolor(7);
		iput( inode );
		return;
	}
	if( !( access( inode ) & WRITE))		// 没有权限  
	{
		textcolor(12);
		printf( "bash: %s: 无此权限\n", filename );
		textcolor(7);
		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;///////////
			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;
			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 );
	}
	printf("文件删除成功！\n\n");

	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 )
	{
		textcolor(12);
		printf( "无此目录\n" );
		textcolor(7);
		return -1;
	}

	if( dinodeid == NULL )
	{
		if( openmode & O_CREAT )
			return creat( filename, openmode & ( ~ O_CREAT ));
		textcolor(12);
		printf( "文件不存在\n" );
		textcolor(7);
		return -1;
	}

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

	if( !access( inode ))
	{
		textcolor(12);
		printf( "无此权限打开文件\n" );
		textcolor(7);
		iput( inode );
		return -1;
	}

	// 分配文件表项  
	for( i = 0; i < SYSOPENFILE; i++ )
	{
		if( sys_ofile[i].f_count == 0 )
			break;
	}
	if( i == SYSOPENFILE )
	{
		textcolor(12);
		printf( "系统打开了太多文件\n" );
		textcolor(7);
		iput( inode );
		return -1;
	}

	// 分配用户文件描述表项  
	for( j = 0; j < NOFILE; j++ )
		if( user[user_id].u_ofile[j] == SYSOPENFILE + 1 )
			break;
	if( j == NOFILE )
	{
		textcolor(12);
		printf( "用户打开太多文件\n" );
		textcolor(7);
		iput( inode );
		return -1;
	}
	printf("文件打开成功！\n\n");

	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;
	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 ))
	{
		textcolor(12);
		printf( "The file is not opened for read\n" );
		textcolor(7);
		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<inode->i_size / BLOCKSIZ;i++)
		{
			fseek(fd,inode->i_addr[i + block] * BLOCKSIZ, SEEK_SET );
			fread( 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;
	int block, block_off, i, sys_ip;
	struct inode * inode;
	char * temp_buf;

	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( temp_buf, 1, BLOCKSIZ - block_off, fd );

	buf += BLOCKSIZ - block_off;

	// 所写的文件没有到末尾  
	if( nbyte + off < inode->i_size )
	{
		for( i = 0;i<inode->i_size / BLOCKSIZ;i++)
		{
			fseek(fd,inode->i_addr[i + block] * BLOCKSIZ, 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<inode->i_size / BLOCKSIZ;i++)//; )
	{
		inode->i_addr[i] = balloc();
		fseek( fd, DATASTART + inode->i_addr[i] * BLOCKSIZ, SEEK_SET );
		fwrite( temp_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 edlin( char * filename )
{	char buf[BLOCKSIZ];
	int i, fh;
	textcolor(12);
	if(( fh = open( filename, DEFAULTMODE | O_CREAT )) == -1)
		printf( "Can't creat file %s\n", filename );
	textcolor(7);
	printf( "请输入文件内容...按Ctrl+x后按回车结束\n\n" );
	for( i = 0; i < BLOCKSIZ; i++ )					// 按Ctrl+x后按回车结束  
	{
		buf[i] = getchar();
		if( buf[i] == 24 )
			break;
	}
	buf[i] = '\0';

	write( fh, buf, strlen( buf ));
	close( fh );
	buf[i] = getchar();
}

// 显示文件内容  
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 );
	}
}