Пример #1
0
// Changes the permissions of the file
unsigned int fs_chmod(char * filename, int perms) {
	int current_uid = current_ttyc()->uid;
	int start_inode = current_ttyc()->pwd;
	int namenode = fs_indir(filename, start_inode);
	if (namenode) {
		inode_read(namenode, &n);
		if (n.uid == current_uid || current_uid == 0) {
			n.i_file_acl = perms;
			inode_write(namenode, &n);
		} else {
			return ERR_PERMS;
		}
		return 1;
	} else {
		return ERR_NO_EXIST;
	}
}
Пример #2
0
// Returns the inode's permissions
unsigned int fs_getmod(char * filename) {
	int start_inode = current_ttyc()->pwd;
	int namenode = fs_indir(filename, start_inode);
	if (namenode) {
		inode_read(namenode, &n);
		return n.i_file_acl & 0777;
	} else {
		return ERR_NO_EXIST;
	}
}
Пример #3
0
// Changes the inode's owner
unsigned int fs_chown(char * filename, char * username) {
	int new_uid = user_exists(username);
	int current_uid = current_ttyc()->uid;
	int start_inode = current_ttyc()->pwd;
	int namenode = fs_indir(filename, start_inode);

	if (namenode && new_uid != -1) {
		inode_read(namenode, &n);
		if (n.uid == current_uid || current_uid == 0) {
			n.uid = new_uid;
			inode_write(namenode, &n);
		} else {
			return ERR_PERMS;
		}
		return 1;
	} else {
		return ERR_NO_EXIST;
	}
}
Пример #4
0
/* Opens a file descriptor and sets it's type, data and permissions*/
int fd_open_with_index (int fd, int type, void * data, int perms) {
	if(files_allocd == 0) {
		files_alloc();
	}
	if(!files[fd].used)		{
		files[fd].type = type;
		files[fd].data = data;
		files[fd].perms = perms;
		switch(files[fd].type) {
			case _FD_TTY:
			//
			break;
			case _FD_FIFO:
				files[fd].fifo_inode = (int) fs_open_fifo(data, current_ttyc()->pwd, perms);                    // Fifos are stored with their own id...
				if(files[fd].fifo_inode > 0)	{
					files[fd].data = (void *) fifo_make(files[fd].fifo_inode);
				}
			break;
			case _FD_FILE:
				files[fd].data = (void *)fs_open_reg_file(data, current_ttyc()->pwd, perms);             // Inodes are stoded with their inode number.

				if(files[fd].data > 0 && fs_is_fifo((int)files[fd].data))
				{
					files[fd].fifo_inode = (int) files[fd].data;
					files[fd].data = (void *) fifo_make(files[fd].fifo_inode);
					files[fd].type = _FD_FIFO;
				}
			break;
			default:
			return -1;
		}
	}
	
	// Errors...
	if((int)files[fd].fifo_inode < 0 && type == _FD_FIFO)	{
		return (int)files[fd].fifo_inode;
	}
	if((int)files[fd].data < 0 && type == _FD_FILE)	{
		return (int)files[fd].data;
	}
	files[fd].used++;
	return fd;
}
Пример #5
0
// Changes the directory
int	fs_cd(char * name) {
	int start_inode = current_ttyc()->pwd;
	
	int namenode = fs_indir(name, start_inode);
	if (namenode) {
		inode_read(namenode, &n);
		if(n.mode & EXT2_S_IFLNK)	{
			if (bitmap_read(bm_inodes, n.data_blocks[0] - 1))
				current_ttyc()->pwd = n.data_blocks[0];
			else {
				return ERR_NO_EXIST;
			}
			
		} else {
			current_ttyc()->pwd = namenode;
		}
		return 1;
	} else {
		return ERR_NO_EXIST;
	}
}
Пример #6
0
// Gets info from the file
void fs_finfo(char * filename, int * data) {
	int start_inode = current_ttyc()->pwd;
	int namenode = fs_indir(filename, start_inode);
	if(namenode)
	{
		inode_read(namenode, &n);	
		
		data[0] = namenode;						// Inode
		data[1] = n.blocks / 2;					// Blocks
		data[2] = n.blocks / 2 * 1024;			// Bytes
		data[3] = n.i_file_acl;					// Permissions
		data[4] = n.uid;						// UID
		data[5] = n._dir_inode;					// Directory inode
 	}
}
Пример #7
0
// Opens a link filetype
unsigned int fs_open_link(char * name, char * target_name) {
	unsigned int folder_inode = current_ttyc()->pwd;
	int target_inode = fs_indir(target_name, folder_inode);
	if(target_inode > 0)
	{
		int result = fs_open_file(name, folder_inode, O_NEW, EXT2_S_IFLNK);
		if(result > 0)	{
			inode_read(result, &n);
			n.data_blocks[0] = target_inode;
			inode_write(result, &n);	
			return 1;
		}
		else {
			return result;
		}
	} else {
		return ERR_NO_EXIST;
	}

}
Пример #8
0
// Tells the current location
char *	fs_pwd() {
	
	int j = 1023;
	int i = 0;
	
	for(; i < 1024; ++i) {
		pwd_string[i] = 0;
	}
		
	int start_inode = current_ttyc()->pwd;

	inode_read(start_inode, &n);

	while(n._dir_inode != start_inode) {
		int _old_dirnode = n._dir_inode;
		char * name = fs_iname(start_inode, n._dir_inode);
		int k = strlen(name) - 2;
		for(; k >= 0; k--, j--) {
			pwd_string[j] = name[k];
		}
		pwd_string[j] = '/';
		j--;
		start_inode = _old_dirnode;
		inode_read(start_inode, &n);
	}
	if(j == 1023)
	{
		pwd_string[j] = '/';
	} else {
		j++;
	}

	
	for(i = 0; j < 1024; i++,j++)
	{
		pwd_string[i] = pwd_string[j];
		pwd_string[j] = 0;
	}
		
	return pwd_string;
}
Пример #9
0
// Tells if the current user has permissions to make an action in the given inode
unsigned int fs_has_perms(inode * n, int for_what) {
	if (!fs_done) {
		// If the kernel's not ready then we can do anything.
		// We're like, Chuck Norris, a superroot or Chuck Testa.
		return 1;
	}
	int current_uid = current_ttyc()->uid;
	int current_gid = user_gid(current_uid);
	int file_gid = user_gid(n->uid);
	int can = 0;

	if(for_what == ACTION_READ)
	{
		if (n->uid == current_uid && (n->i_file_acl & 0400)) {
			can = 1;
		}
		if (file_gid == current_gid && (n->i_file_acl & 0040)) {
			can = 1;
		}
		if (n->i_file_acl & 0004) {
			can = 1;
		}
	} else if(for_what == ACTION_WRITE)
	{
		if (n->uid == current_uid && (n->i_file_acl & 0200)) {
			can = 1;
		}
		if (file_gid == current_gid && (n->i_file_acl & 0020)) {
			can = 1;
		}
		if (n->i_file_acl & 0002) {
			can = 1;
		}
	}
	return can;
}
Пример #10
0
// Makes a new directory
unsigned int fs_mkdir(char * name, unsigned int parent_inode) {
	unsigned int inode_id = 0;
	if ((inode_id = fs_indir(name, parent_inode))) {
		return 0;
	}
	inode_id = bitmap_first_valued(bm_inodes, FS_INODE_BITMAP_SIZE, 0) + 1;
	
	if (!parent_inode) {
		parent_inode = inode_id;
	}
	
	int log_block;
	
	if (parent_inode != inode_id) {
		inode_read(parent_inode, &n);
		
		if(!fs_has_perms(&n, ACTION_WRITE))	{
			return ERR_PERMS;
		}
		
		log_block = n.blocks / 2;
		
		block_clear(&b);
		dir_op_offset = 0;
		log_block_read(&n, &log_block);
		add_dir_entry(&n, EXT2_FT_DIR, inode_id, name, &log_block);
		log_block_write(&n, &log_block);
		
		inode_write(parent_inode, &n);	
	}
	bitmap_write(bm_inodes, inode_id - 1, 1);

	
	

	
	inode_clear(&n);
	

	if(!fs_done)
	{
		n.uid = 0;
	} else {
		n.uid = current_ttyc()->uid;
	}

	n.mode = EXT2_S_IFDIR;
	n.size = 0;
	n.blocks = 0; // Beware! This represents the SECTORS!
	
	
	log_block = n.blocks / 2;
	
	block_clear(&b);
	dir_op_offset = 0;
	
	add_dir_entry(&n, EXT2_FT_DIR, inode_id, ".", &log_block);
	add_dir_entry(&n, EXT2_FT_DIR, parent_inode, "..", &log_block);

	log_block_write(&n, &log_block);
	
	n.blocks = (log_block) * 2;
	
	n.i_file_acl = 511;
	n._dir_inode = parent_inode;
	n._last_write_offset = dir_op_offset;
	
	inode_write(inode_id, &n);	
	



	
	fs_bitmaps_write_all();
	return inode_id;
}
Пример #11
0
// Opens a file
unsigned int fs_open_file(char * name, unsigned int folder_inode, int mode, int type) {
	unsigned int inode_id = 0;

	if(strcmp(name, "/") == 0 && strlen(name) == strlen("/"))	{
		return 1; // root
	}


	if(name[0] == 0)
	{
		inode_id = current_ttyc()->pwd;
	} else {
		inode_id = fs_indir(name, folder_inode);
	}
	
	if (inode_id) {
		if (mode & O_CREAT) {
			int _rm_res = fs_rm(inode_id, 0);
			if(_rm_res < 0) {
				return _rm_res;
			}
		} else if(mode & O_NEW) {
			inode_read(inode_id, &n);
			if(n.mode == EXT2_S_IFLNK)	{
				return n.data_blocks[0];
			}
			return inode_id;
		} 
		else {
			inode_read(inode_id, &n);
			int can = 1;
			if((mode & O_RD) && !fs_has_perms(&n, ACTION_READ))	{
				can = 0;
			}
			if((mode & O_WR) && !fs_has_perms(&n, ACTION_WRITE))	{
				can = 0;
			}
			if(can || !fs_done)	{
				if(n.mode == EXT2_S_IFLNK)	{
					return n.data_blocks[0];
				}
				return inode_id;
			} else {
				return ERR_PERMS;
			}
		}
	} else if (!(mode & (O_NEW | O_CREAT))) {
		return ERR_NO_EXIST;
	}
	
	inode_id = bitmap_first_valued(bm_inodes, FS_INODE_BITMAP_SIZE, 0) + 1;
	
	if (!folder_inode) {
		folder_inode = inode_id;
	}
	
	int log_block;
	
	if (folder_inode != inode_id) {
		inode_read(folder_inode, &n);
		
		if(!fs_has_perms(&n, ACTION_WRITE))	{
			return ERR_PERMS;
		}
		
		log_block = n.blocks / 2;
		
		block_clear(&b);
		dir_op_offset = 0;
		log_block_read(&n, &log_block);
		add_dir_entry(&n, EXT2_FT_DIR, inode_id, name, &log_block);
		log_block_write(&n, &log_block);
		
		inode_write(folder_inode, &n);	
	}
	bitmap_write(bm_inodes, inode_id - 1, 1);
		
	inode_clear(&n);
	
	
	if(!fs_done)
	{
		n.uid = 0;
	} else {
		n.uid = current_ttyc()->uid;
	}
	
	n.mode =  type;
	n.size = 0;
	n.blocks = 0; // Beware! This represents the SECTORS!
	
	
	n._last_write_offset = 0;
	n.i_file_acl = 511;
	n._dir_inode = folder_inode;
	
	inode_write(inode_id, &n);	
	
	inode_clear(&n);

	if(n.mode == EXT2_S_IFLNK)	{
		return n.data_blocks[0];
	}
	
	return inode_id;
}
Пример #12
0
// INT 80h Handler, kernel entry.
void int_80() {
	if(krn)	{
		return;
	}
	
	krn++;
	int systemCall = kernel_buffer[0];
	int fd         = kernel_buffer[1];
	int buffer     = kernel_buffer[2];
	int count      = kernel_buffer[3];

	
	int i, j;
	Process * current;
	Process * p;
	int inode;
	int _fd;
	// Yeah, wanna know why we don't access an array directly? ... Because of big bugs we might have.
	switch(systemCall) {
		case READY:
			kernel_buffer[KERNEL_RETURN] = kernel_ready();
			break;
		case WRITE:
 			current = getp();
			kernel_buffer[KERNEL_RETURN] = fd_write(current->file_descriptors[fd],(char *)buffer,count);
			break;
		case READ:
			current = getp();
			kernel_buffer[KERNEL_RETURN] = fd_read(current->file_descriptors[fd],(char *)buffer,count);
			break;
		case MKFIFO:
			_fd = process_getfreefd();
			fd = fd_open(_FD_FIFO, (void *)kernel_buffer[1],kernel_buffer[2]);
			if(_fd != -1 && fd != -1)	{
				getp()->file_descriptors[_fd] = fd;
				kernel_buffer[KERNEL_RETURN] = _fd;
			}
			else {
				kernel_buffer[KERNEL_RETURN] = -1;
			}
			break;
		case OPEN:
			_fd = process_getfreefd();
			fd = fd_open(_FD_FILE, (void *) kernel_buffer[1], kernel_buffer[2]);
			if(_fd != -1 && fd >= 0)
			{
				getp()->file_descriptors[_fd] = fd;
				kernel_buffer[KERNEL_RETURN] = _fd;
			}
			else {
				kernel_buffer[KERNEL_RETURN] = fd;
			}
			break;
		case CLOSE:
			kernel_buffer[KERNEL_RETURN] = fd_close(getp()->file_descriptors[fd]);
			break;
		case PCREATE:
			kernel_buffer[KERNEL_RETURN] = sched_pcreate(kernel_buffer[1],kernel_buffer[2],kernel_buffer[3]);
			break;
		case PRUN:
			kernel_buffer[KERNEL_RETURN] = sched_prun(kernel_buffer[1]);
			break;
		case PDUP2:
			kernel_buffer[KERNEL_RETURN] = sched_pdup2(kernel_buffer[1],kernel_buffer[2],kernel_buffer[3]);
			break;
		case GETPID:
			kernel_buffer[KERNEL_RETURN] = sched_getpid();
			break;
		case WAITPID:
			kernel_buffer[KERNEL_RETURN] = sched_waitpid(kernel_buffer[1]);
			break;
		case PTICKS:
			kernel_buffer[KERNEL_RETURN] = (int) storage_index();
			break;
		case PNAME:
			p = process_getbypid(kernel_buffer[1]);
			if(p == NULL)
			{
				kernel_buffer[KERNEL_RETURN] = (int) NULL;
			} else {
				kernel_buffer[KERNEL_RETURN] = (int) p->name;
			}
			break;
		case PSTATUS:
			p = process_getbypid(kernel_buffer[1]);
			if(p == NULL)
			{
				kernel_buffer[KERNEL_RETURN] = (int) -1;
			} else {
				kernel_buffer[KERNEL_RETURN] = (int) p->state;
			}
			break;
		case PPRIORITY:
			p = process_getbypid(kernel_buffer[1]);
			if(p == NULL)
			{
				kernel_buffer[KERNEL_RETURN] = (int) -1;
			} else {
				kernel_buffer[KERNEL_RETURN] = (int) p->priority;
			}
			break;
		case PGID:
			p = process_getbypid(kernel_buffer[1]);
			if(p == NULL)
			{
				kernel_buffer[KERNEL_RETURN] = (int) -1;
			} else {
				kernel_buffer[KERNEL_RETURN] = (int) p->gid;
			}
			break;
		case PGETPID_AT:
			p = process_getbypindex(kernel_buffer[1]);
			if (p->state != -1) {
				kernel_buffer[KERNEL_RETURN] = (int) p->pid;
			} else {
				kernel_buffer[KERNEL_RETURN] = -1;
			}
			break;
		case KILL:
			kernel_buffer[KERNEL_RETURN - 1] = kernel_buffer[1];
			kernel_buffer[KERNEL_RETURN - 2] = kernel_buffer[2];
			break;
		case PSETP:
			p = process_getbypid(kernel_buffer[1]);
			if(p == NULL)	{
				kernel_buffer[KERNEL_RETURN] = (int) -1;
			} else {
				if(kernel_buffer[2] <= 4 && kernel_buffer[2] >= 0)	{
					p->priority = kernel_buffer[2];
				}
				kernel_buffer[KERNEL_RETURN] = (int) p->gid;
			}
			break;
		case SETSCHED:
			sched_set_mode(kernel_buffer[1]);
			break;
		case PWD:
			kernel_buffer[KERNEL_RETURN] = (int) fs_pwd();
			break;
		case CD:
			kernel_buffer[KERNEL_RETURN] = (int) fs_cd(kernel_buffer[1]);
			break;
		case FINFO:
			fs_finfo(kernel_buffer[1], kernel_buffer[2]);
			break;
		case MOUNT:
			fs_init();
			break;
		case MKDIR:
			kernel_buffer[KERNEL_RETURN] = (int) fs_mkdir(kernel_buffer[1],current_ttyc()->pwd);
			break;
		case RM:
			inode = fs_indir(kernel_buffer[1],current_ttyc()->pwd);
			if (inode) {
				kernel_buffer[KERNEL_RETURN] = (int) fs_rm(inode,0);
			} else {
				kernel_buffer[KERNEL_RETURN] = ERR_NO_EXIST;
			}
			break;
		case GETUID:
			if(kernel_buffer[1] == 0)
			{
				kernel_buffer[KERNEL_RETURN] = (int) current_ttyc()->uid;
			} else {
				kernel_buffer[KERNEL_RETURN] = (int) user_exists(kernel_buffer[1]);
			}
			break;
		case GETGID:
			if(kernel_buffer[1] == 0)
			{
				kernel_buffer[KERNEL_RETURN] = (int) user_gid(current_ttyc()->uid);
			} else {
				kernel_buffer[KERNEL_RETURN] = (int) user_gid(kernel_buffer[1]);
			}

			break;
		case MAKEUSER:
			kernel_buffer[KERNEL_RETURN] = user_create(kernel_buffer[1],
							kernel_buffer[2], user_gid(current_ttyc()->uid));
			break;
		case SETGID:
			kernel_buffer[KERNEL_RETURN] = user_setgid(kernel_buffer[1], 
													   kernel_buffer[2]);
			break;
		case UDELETE:
			kernel_buffer[KERNEL_RETURN] = user_delete(kernel_buffer[1]);
			break;
		case UEXISTS:
			kernel_buffer[KERNEL_RETURN] = user_exists(kernel_buffer[1]);
			break;
		case ULOGIN:
			kernel_buffer[KERNEL_RETURN] = user_login(kernel_buffer[1], 
													  kernel_buffer[2]);
			break;
		case ULOGOUT:
			kernel_buffer[KERNEL_RETURN] = user_logout();
			break;
		case CHOWN:
			kernel_buffer[KERNEL_RETURN] = fs_chown(kernel_buffer[1],
													kernel_buffer[2]);
			break;
		case CHMOD:
			kernel_buffer[KERNEL_RETURN] = fs_chmod(kernel_buffer[1],
												    kernel_buffer[2]);
			break;
		case GETOWN:
			kernel_buffer[KERNEL_RETURN] = fs_getown(kernel_buffer[1]);
			break;
		case GETMOD:
			kernel_buffer[KERNEL_RETURN] = fs_getmod(kernel_buffer[1]);
			break;
		case CP:
			kernel_buffer[KERNEL_RETURN] = fs_cp(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd, current_ttyc()->pwd);
			break;
		case MV:
			kernel_buffer[KERNEL_RETURN] = fs_mv(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd);
			break;
		case LINK:
			kernel_buffer[KERNEL_RETURN] = fs_open_link(kernel_buffer[1], kernel_buffer[2], current_ttyc()->pwd);
			break;
		case FSSTAT:
			kernel_buffer[KERNEL_RETURN] = fs_stat(kernel_buffer[1]);
			break;
		case SLEEP:
			kernel_buffer[KERNEL_RETURN] = scheduler_sleep(kernel_buffer[1]);
			break;
		default:
			break;
	}
	
	krn--;
}