minix/lib/libvtreefs/path.c
2012-03-25 21:58:14 +02:00

313 lines
7.3 KiB
C

/* VTreeFS - path.c - by Alen Stojanov and David van Moolenbroek */
#include "inc.h"
/*===========================================================================*
* access_as_dir *
*===========================================================================*/
static int access_as_dir(struct inode *node, vfs_ucred_t *ucred)
{
/* Check whether the given inode may be accessed as directory.
* Return OK or an appropriate error code.
*/
mode_t mask;
int i;
/* The inode must be a directory to begin with. */
if (!S_ISDIR(node->i_stat.mode)) return ENOTDIR;
/* The caller must have search access to the directory.
* Root always does.
*/
if (ucred->vu_uid == SUPER_USER) return OK;
if (ucred->vu_uid == node->i_stat.uid) mask = S_IXUSR;
else if (ucred->vu_gid == node->i_stat.gid) mask = S_IXGRP;
else {
mask = S_IXOTH;
for (i = 0; i < ucred->vu_ngroups; i++) {
if (ucred->vu_sgroups[i] == node->i_stat.gid) {
mask = S_IXGRP;
break;
}
}
}
return (node->i_stat.mode & mask) ? OK : EACCES;
}
/*===========================================================================*
* next_name *
*===========================================================================*/
static int next_name(char **ptr, char **start, char name[PNAME_MAX+1])
{
/* Get the next path component from a path.
*/
char *p;
int i;
for (p = *ptr; *p == '/'; p++);
*start = p;
if (*p) {
for (i = 0; *p && *p != '/' && i <= PNAME_MAX; p++, i++)
name[i] = *p;
if (i > PNAME_MAX)
return ENAMETOOLONG;
name[i] = 0;
} else {
strcpy(name, ".");
}
*ptr = p;
return OK;
}
/*===========================================================================*
* go_up *
*===========================================================================*/
static int go_up(struct inode *node, struct inode **parent)
{
/* Given a directory inode, progress into the parent directory.
*/
*parent = get_parent_inode(node);
/* Trapped in a deleted directory? Should not be possible. */
if (*parent == NULL)
return ENOENT;
ref_inode(*parent);
return OK;
}
/*===========================================================================*
* go_down *
*===========================================================================*/
static int go_down(struct inode *parent, char *name, struct inode **child)
{
/* Given a directory inode and a name, progress into a directory entry.
*/
int r;
/* Call the lookup hook, if present, before doing the actual lookup. */
if (!is_inode_deleted(parent) && vtreefs_hooks->lookup_hook != NULL) {
r = vtreefs_hooks->lookup_hook(parent, name,
get_inode_cbdata(parent));
if (r != OK) return r;
}
if ((*child = get_inode_by_name(parent, name)) == NULL)
return ENOENT;
ref_inode(*child);
return OK;
}
/*===========================================================================*
* resolve_link *
*===========================================================================*/
static int resolve_link(struct inode *node, char *pptr, char *tail)
{
/* Given a symbolic link, resolve and return the contents of the link.
*/
char path[PATH_MAX];
size_t len;
int r;
assert(vtreefs_hooks->rdlink_hook != NULL);
assert(!is_inode_deleted(node));
r = vtreefs_hooks->rdlink_hook(node, path, sizeof(path),
get_inode_cbdata(node));
if (r != OK) return r;
len = strlen(path);
assert(len > 0 && len < sizeof(path));
if (len + strlen(tail) >= sizeof(path))
return ENAMETOOLONG;
strcat(path, tail);
strcpy(pptr, path);
return OK;
}
/*===========================================================================*
* fs_lookup *
*===========================================================================*/
int fs_lookup(void)
{
/* Resolve a path string to an inode.
*/
ino_t dir_ino_nr, root_ino_nr;
struct inode *cur_ino, *next_ino, *root_ino;
char path[PATH_MAX], name[PNAME_MAX+1];
char *ptr, *last;
vfs_ucred_t ucred;
size_t len;
int r, r2, symloop;
dir_ino_nr = fs_m_in.REQ_DIR_INO;
root_ino_nr = fs_m_in.REQ_ROOT_INO;
len = fs_m_in.REQ_PATH_LEN;
/* Fetch the path name. */
if (len < 1 || len > PATH_MAX)
return EINVAL;
r = sys_safecopyfrom(fs_m_in.m_source, fs_m_in.REQ_GRANT, 0,
(vir_bytes) path, (phys_bytes) len, D);
if (r != OK) return r;
if (path[len-1] != 0) return EINVAL;
/* Fetch the caller's credentials. */
if (fs_m_in.REQ_FLAGS & PATH_GET_UCRED) {
assert(fs_m_in.REQ_UCRED_SIZE == sizeof(ucred));
r = sys_safecopyfrom(fs_m_in.m_source, fs_m_in.REQ_GRANT2, 0,
(vir_bytes) &ucred, fs_m_in.REQ_UCRED_SIZE, D);
if (r != OK)
return r;
}
else {
ucred.vu_uid = fs_m_in.REQ_UID;
ucred.vu_gid = fs_m_in.REQ_GID;
ucred.vu_ngroups = 0;
}
/* Start the actual lookup. */
if ((cur_ino = get_inode(dir_ino_nr)) == NULL)
return EINVAL;
/* Chroot'ed environment? */
if (root_ino_nr > 0)
root_ino = find_inode(root_ino_nr);
else
root_ino = NULL;
symloop = 0;
for (ptr = last = path; ptr[0] != 0; ) {
/* There is more path to process. That means that the current
* file is now being accessed as a directory. Check type and
* permissions.
*/
if ((r = access_as_dir(cur_ino, &ucred)) != OK)
break;
/* Get the next path component. The result is a non-empty
* string.
*/
if ((r = next_name(&ptr, &last, name)) != OK)
break;
if (!strcmp(name, ".") ||
(cur_ino == root_ino && !strcmp(name, "..")))
continue;
if (!strcmp(name, "..")) {
if (cur_ino == get_root_inode())
r = ELEAVEMOUNT;
else
r = go_up(cur_ino, &next_ino);
} else {
r = go_down(cur_ino, name, &next_ino);
/* Perform symlink resolution if we have to. */
if (r == OK && S_ISLNK(next_ino->i_stat.mode) &&
(ptr[0] != '\0' ||
!(fs_m_in.REQ_FLAGS & PATH_RET_SYMLINK))) {
if (++symloop == SYMLOOP_MAX) {
put_inode(next_ino);
r = ELOOP;
break;
}
/* Resolve the symlink, and append the
* remaining unresolved part of the path.
*/
r = resolve_link(next_ino, path, ptr);
put_inode(next_ino);
if (r != OK)
break;
/* If the symlink is absolute, return it to
* VFS.
*/
if (path[0] == '/') {
r = ESYMLINK;
last = path;
break;
}
ptr = path;
continue;
}
}
if (r != OK)
break;
/* We have found a new file. Continue from this file. */
assert(next_ino != NULL);
put_inode(cur_ino);
cur_ino = next_ino;
}
/* If an error occurred, close the file and return error information.
*/
if (r != OK) {
put_inode(cur_ino);
/* We'd need support for this here. */
assert(r != EENTERMOUNT);
/* Copy back the path if we resolved at least one symlink. */
if (symloop > 0 && (r == ELEAVEMOUNT || r == ESYMLINK)) {
r2 = sys_safecopyto(fs_m_in.m_source,
fs_m_in.REQ_GRANT, 0, (vir_bytes) path,
strlen(path) + 1, D);
if (r2 != OK)
r = r2;
}
if (r == ELEAVEMOUNT || r == ESYMLINK) {
fs_m_out.RES_OFFSET = (int) (last - path);
fs_m_out.RES_SYMLOOP = symloop;
}
return r;
}
/* On success, leave the resulting file open and return its details. */
fs_m_out.RES_INODE_NR = get_inode_number(cur_ino);
fs_m_out.RES_MODE = cur_ino->i_stat.mode;
fs_m_out.RES_FILE_SIZE_HI = 0;
fs_m_out.RES_FILE_SIZE_LO = cur_ino->i_stat.size;
fs_m_out.RES_UID = cur_ino->i_stat.uid;
fs_m_out.RES_GID = cur_ino->i_stat.gid;
fs_m_out.RES_DEV = cur_ino->i_stat.dev;
return OK;
}