/* This file provides path-to-inode lookup functionality.

*

* The entry points into this file are:

* do_lookup perform the LOOKUP file system call

*

* Created:

* April 2009 (D.C. van Moolenbroek)

*/

#include "inc.h"

static int get_mask(vfs_ucred_t *ucred);

static int access_as_dir(struct inode *ino, struct sffs_attr *attr,

int uid, int mask);

static int next_name(char **ptr, char **start, char name[NAME_MAX+1]);

static int go_up(char path[PATH_MAX], struct inode *ino,

struct inode **res_ino, struct sffs_attr *attr);

static int go_down(char path[PATH_MAX], struct inode *ino, char *name,

struct inode **res_ino, struct sffs_attr *attr);

/*===========================================================================*

* get_mask *

*===========================================================================*/

static int get_mask(

vfs_ucred_t *ucred /* credentials of the caller */

)

{

/* Given the caller's credentials, precompute a search access mask to test

* against directory modes.

*/

int i;

if (ucred->vu_uid == sffs_params->p_uid) return S_IXUSR;

if (ucred->vu_gid == sffs_params->p_gid) return S_IXGRP;

for (i = 0; i < ucred->vu_ngroups; i++)

if (ucred->vu_sgroups[i] == sffs_params->p_gid) return S_IXGRP;

return S_IXOTH;

}

/*===========================================================================*

* access_as_dir *

*===========================================================================*/

static int access_as_dir(

struct inode *ino, /* the inode to test */

struct sffs_attr *attr, /* attributes of the inode */

int uid, /* UID of the caller */

int mask /* search access mask of the caller */

)

{

/* Check whether the given inode may be accessed as directory.

* Return OK or an appropriate error code.

*/

mode_t mode;

assert(attr->a_mask & SFFS_ATTR_MODE);

/* The inode must be a directory to begin with. */

if (!IS_DIR(ino)) return ENOTDIR;

/* The caller must have search access to the directory. Root always does. */

if (uid == 0) return OK;

mode = get_mode(ino, attr->a_mode);

return (mode & mask) ? OK : EACCES;

}

/*===========================================================================*

* next_name *

*===========================================================================*/

static int next_name(

char **ptr, /* cursor pointer into path (in, out) */

char **start, /* place to store start of name */

char name[NAME_MAX+1] /* place to store name */

)

{

/* 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 <= NAME_MAX; p++, i++)

name[i] = *p;

if (i > NAME_MAX)

return ENAMETOOLONG;

name[i] = 0;

} else {

strcpy(name, ".");

}

*ptr = p;

return OK;

}

/*===========================================================================*

* go_up *

*===========================================================================*/

static int go_up(

char path[PATH_MAX], /* path to take the last part from */

struct inode *ino, /* inode of the current directory */

struct inode **res_ino, /* place to store resulting inode */

struct sffs_attr *attr /* place to store inode attributes */

)

{

/* Given an inode, progress into the parent directory.

*/

struct inode *parent;

int r;

pop_path(path);

parent = ino->i_parent;

assert(parent != NULL);

if ((r = verify_path(path, parent, attr, NULL)) != OK)

return r;

get_inode(parent);

*res_ino = parent;

return r;

}

/*===========================================================================*

* go_down *

*===========================================================================*/

static int go_down(

char path[PATH_MAX], /* path to add the name to */

struct inode *parent, /* inode of the current directory */

char *name, /* name of the directory entry */

struct inode **res_ino, /* place to store resulting inode */

struct sffs_attr *attr /* place to store inode attributes */

)

{

/* Given a directory inode and a name, progress into a directory entry.

*/

struct inode *ino;

int r, stale = 0;

if ((r = push_path(path, name)) != OK)

return r;

dprintf(("%s: go_down: name '%s', path now '%s'\n", sffs_name, name, path));

ino = lookup_dentry(parent, name);

dprintf(("%s: lookup_dentry('%s') returned %p\n", sffs_name, name, ino));

if (ino != NULL)

r = verify_path(path, ino, attr, &stale);

else

r = sffs_table->t_getattr(path, attr);

dprintf(("%s: path query returned %d\n", sffs_name, r));

if (r != OK) {

if (ino != NULL) {

put_inode(ino);

ino = NULL;

}

if (!stale)

return r;

}

dprintf(("%s: name '%s'\n", sffs_name, name));

if (ino == NULL) {

if ((ino = get_free_inode()) == NULL)

return ENFILE;

dprintf(("%s: inode %p ref %d\n", sffs_name, ino, ino->i_ref));

ino->i_flags = MODE_TO_DIRFLAG(attr->a_mode);

add_dentry(parent, name, ino);

}

*res_ino = ino;

return OK;

}

/*===========================================================================*

* do_lookup *

*===========================================================================*/

int do_lookup(void)

{

/* Resolve a path string to an inode.

*/

ino_t dir_ino_nr, root_ino_nr;

struct inode *cur_ino, *root_ino;

struct inode *next_ino = NULL;

struct sffs_attr attr;

char buf[PATH_MAX], path[PATH_MAX];

char name[NAME_MAX+1];

char *ptr, *last;

vfs_ucred_t ucred;

mode_t mask;

size_t len;

int r;

dir_ino_nr = m_in.m_vfs_fs_lookup.dir_ino;

root_ino_nr = m_in.m_vfs_fs_lookup.root_ino;

len = m_in.m_vfs_fs_lookup.path_len;

/* Fetch the path name. */

if (len < 1 || len > PATH_MAX)

return EINVAL;

r = sys_safecopyfrom(m_in.m_source, m_in.m_vfs_fs_lookup.grant_path, 0,

(vir_bytes) buf, len);

if (r != OK)

return r;

if (buf[len-1] != 0) {

printf("%s: VFS did not zero-terminate path!\n", sffs_name);

return EINVAL;

}

/* Fetch the credentials, and generate a search access mask to test against

* directory modes.

*/

if (m_in.m_vfs_fs_lookup.flags & PATH_GET_UCRED) {

if (m_in.m_vfs_fs_lookup.ucred_size != sizeof(ucred)) {

printf("%s: bad credential structure size\n", sffs_name);

return EINVAL;

}

r = sys_safecopyfrom(m_in.m_source, m_in.m_vfs_fs_lookup.grant_ucred, 0,

(vir_bytes) &ucred, m_in.m_vfs_fs_lookup.ucred_size);

if (r != OK)

return r;

}

else {

ucred.vu_uid = m_in.m_vfs_fs_lookup.uid;

ucred.vu_gid = m_in.m_vfs_fs_lookup.gid;

ucred.vu_ngroups = 0;

}

mask = get_mask(&ucred);

/* Start the actual lookup. */

dprintf(("%s: lookup: got query '%s'\n", sffs_name, buf));

if ((cur_ino = find_inode(dir_ino_nr)) == NULL)

return EINVAL;

attr.a_mask = SFFS_ATTR_MODE | SFFS_ATTR_SIZE;

if ((r = verify_inode(cur_ino, path, &attr)) != OK)

return r;

get_inode(cur_ino);

if (root_ino_nr > 0)

root_ino = find_inode(root_ino_nr);

else

root_ino = NULL;

/* One possible optimization would be to check a path only right before the

* first ".." in a row, and at the very end (if still necessary). This would

* have consequences for inode validation, though.

*/

for (ptr = last = buf; *ptr != 0; ) {

if ((r = access_as_dir(cur_ino, &attr, ucred.vu_uid, mask)) != OK)

break;

if ((r = next_name(&ptr, &last, name)) != OK)

break;

dprintf(("%s: lookup: next name '%s'\n", sffs_name, name));

if (!strcmp(name, ".") ||

(cur_ino == root_ino && !strcmp(name, "..")))

continue;

if (!strcmp(name, "..")) {

if (IS_ROOT(cur_ino))

r = ELEAVEMOUNT;

else

r = go_up(path, cur_ino, &next_ino, &attr);

} else {

r = go_down(path, cur_ino, name, &next_ino, &attr);

}

if (r != OK)

break;

assert(next_ino != NULL);

put_inode(cur_ino);

cur_ino = next_ino;

}

dprintf(("%s: lookup: result %d\n", sffs_name, r));

if (r != OK) {

put_inode(cur_ino);

/* We'd need support for these here. We don't have such support. */

assert(r != EENTERMOUNT && r != ESYMLINK);

if (r == ELEAVEMOUNT) {

m_out.m_fs_vfs_lookup.offset = (last - buf);

m_out.m_fs_vfs_lookup.symloop = 0;

}

return r;

}

m_out.m_fs_vfs_lookup.inode = INODE_NR(cur_ino);

m_out.m_fs_vfs_lookup.mode = get_mode(cur_ino, attr.a_mode);

m_out.m_fs_vfs_lookup.file_size = attr.a_size;

m_out.m_fs_vfs_lookup.uid = sffs_params->p_uid;

m_out.m_fs_vfs_lookup.gid = sffs_params->p_gid;

m_out.m_fs_vfs_lookup.device = NO_DEV;

return OK;

}