lib/libvtreefs/path.c

   1 /* VTreeFS - path.c - by Alen Stojanov and David van Moolenbroek */
   2
   3 #include "inc.h"
   4
   5 /*===========================================================================*
   6  *                              access_as_dir                                *
   7  *===========================================================================*/
   8 static int access_as_dir(struct inode *node, vfs_ucred_t *ucred)
   9 {
  10         /* Check whether the given inode may be accessed as directory.
  11          * Return OK or an appropriate error code.
  12          */
  13         mode_t mask;
  14         int i;
  15
  16         /* The inode must be a directory to begin with. */
  17         if (!S_ISDIR(node->i_stat.mode)) return ENOTDIR;
  18
  19         /* The caller must have search access to the directory.
  20          * Root always does.
  21          */
  22         if (ucred->vu_uid == SUPER_USER) return OK;
  23
  24         if (ucred->vu_uid == node->i_stat.uid) mask = S_IXUSR;
  25         else if (ucred->vu_gid == node->i_stat.gid) mask = S_IXGRP;
  26         else {
  27                 mask = S_IXOTH;
  28
  29                 for (i = 0; i < ucred->vu_ngroups; i++) {
  30                         if (ucred->vu_sgroups[i] == node->i_stat.gid) {
  31                                 mask = S_IXGRP;
  32
  33                                 break;
  34                         }
  35                 }
  36         }
  37
  38         return (node->i_stat.mode & mask) ? OK : EACCES;
  39 }
  40
  41 /*===========================================================================*
  42  *                              next_name                                    *
  43  *===========================================================================*/
  44 static int next_name(char **ptr, char **start, char name[PNAME_MAX+1])
  45 {
  46         /* Get the next path component from a path.
  47          */
  48         char *p;
  49         int i;
  50
  51         for (p = *ptr; *p == '/'; p++);
  52
  53         *start = p;
  54
  55         if (*p) {
  56                 for (i = 0; *p && *p != '/' && i <= PNAME_MAX; p++, i++)
  57                         name[i] = *p;
  58
  59                 if (i > PNAME_MAX)
  60                         return ENAMETOOLONG;
  61
  62                 name[i] = 0;
  63         } else {
  64                 strcpy(name, ".");
  65         }
  66
  67         *ptr = p;
  68         return OK;
  69 }
  70
  71 /*===========================================================================*
  72  *                              go_up                                        *
  73  *===========================================================================*/
  74 static int go_up(struct inode *node, struct inode **parent)
  75 {
  76         /* Given a directory inode, progress into the parent directory.
  77          */
  78
  79         *parent = get_parent_inode(node);
  80
  81         /* Trapped in a deleted directory? Should not be possible. */
  82         if (*parent == NULL)
  83                 return ENOENT;
  84
  85         ref_inode(*parent);
  86
  87         return OK;
  88 }
  89
  90 /*===========================================================================*
  91  *                              go_down                                      *
  92  *===========================================================================*/
  93 static int go_down(struct inode *parent, char *name, struct inode **child)
  94 {
  95         /* Given a directory inode and a name, progress into a directory entry.
  96          */
  97         int r;
  98
  99         /* Call the lookup hook, if present, before doing the actual lookup. */
 100         if (!is_inode_deleted(parent) && vtreefs_hooks->lookup_hook != NULL) {
 101                 r = vtreefs_hooks->lookup_hook(parent, name,
 102                         get_inode_cbdata(parent));
 103                 if (r != OK) return r;
 104         }
 105
 106         if ((*child = get_inode_by_name(parent, name)) == NULL)
 107                 return ENOENT;
 108
 109         ref_inode(*child);
 110
 111         return OK;
 112 }
 113
 114 /*===========================================================================*
 115  *                              resolve_link                                 *
 116  *===========================================================================*/
 117 static int resolve_link(struct inode *node, char pptr[PATH_MAX], char *tail)
 118 {
 119         /* Given a symbolic link, resolve and return the contents of the link.
 120          */
 121         char path[PATH_MAX];
 122         size_t len;
 123         int r;
 124
 125         assert(vtreefs_hooks->rdlink_hook != NULL);
 126         assert(!is_inode_deleted(node));
 127
 128         r = vtreefs_hooks->rdlink_hook(node, path, sizeof(path),
 129                 get_inode_cbdata(node));
 130         if (r != OK) return r;
 131
 132         len = strlen(path);
 133         assert(len > 0 && len < sizeof(path));
 134
 135         if (len + strlen(tail) >= sizeof(path))
 136                 return ENAMETOOLONG;
 137
 138         strlcat(path, tail, sizeof(path));
 139
 140         strlcpy(pptr, path, PATH_MAX);
 141
 142         return OK;
 143 }
 144
 145 /*===========================================================================*
 146  *                              fs_lookup                                    *
 147  *===========================================================================*/
 148 int fs_lookup(void)
 149 {
 150         /* Resolve a path string to an inode.
 151          */
 152         ino_t dir_ino_nr, root_ino_nr;
 153         struct inode *cur_ino, *next_ino, *root_ino;
 154         char path[PATH_MAX], name[PNAME_MAX+1];
 155         char *ptr, *last;
 156         vfs_ucred_t ucred;
 157         size_t len;
 158         int r, r2, symloop;
 159
 160         dir_ino_nr = fs_m_in.REQ_DIR_INO;
 161         root_ino_nr = fs_m_in.REQ_ROOT_INO;
 162         len = fs_m_in.REQ_PATH_LEN;
 163
 164         /* Fetch the path name. */
 165         if (len < 1 || len > PATH_MAX)
 166                 return EINVAL;
 167
 168         r = sys_safecopyfrom(fs_m_in.m_source, fs_m_in.REQ_GRANT, 0,
 169                 (vir_bytes) path, (phys_bytes) len);
 170         if (r != OK) return r;
 171
 172         if (path[len-1] != 0) return EINVAL;
 173
 174         /* Fetch the caller's credentials. */
 175         if (fs_m_in.REQ_FLAGS & PATH_GET_UCRED) {
 176                 assert(fs_m_in.REQ_UCRED_SIZE == sizeof(ucred));
 177
 178                 r = sys_safecopyfrom(fs_m_in.m_source, fs_m_in.REQ_GRANT2, 0,
 179                         (vir_bytes) &ucred, fs_m_in.REQ_UCRED_SIZE);
 180
 181                 if (r != OK)
 182                         return r;
 183         }
 184         else {
 185                 ucred.vu_uid = fs_m_in.REQ_UID;
 186                 ucred.vu_gid = fs_m_in.REQ_GID;
 187                 ucred.vu_ngroups = 0;
 188         }
 189
 190         /* Start the actual lookup. */
 191         if ((cur_ino = get_inode(dir_ino_nr)) == NULL)
 192                 return EINVAL;
 193
 194         /* Chroot'ed environment? */
 195         if (root_ino_nr > 0)
 196                 root_ino = find_inode(root_ino_nr);
 197         else
 198                 root_ino = NULL;
 199
 200         symloop = 0;
 201
 202         for (ptr = last = path; ptr[0] != 0; ) {
 203                 /* There is more path to process. That means that the current
 204                  * file is now being accessed as a directory. Check type and
 205                  * permissions.
 206                  */
 207                 if ((r = access_as_dir(cur_ino, &ucred)) != OK)
 208                         break;
 209
 210                 /* Get the next path component. The result is a non-empty
 211                  * string.
 212                  */
 213                 if ((r = next_name(&ptr, &last, name)) != OK)
 214                         break;
 215
 216                 if (!strcmp(name, ".") ||
 217                                 (cur_ino == root_ino && !strcmp(name, "..")))
 218                         continue;
 219
 220                 if (!strcmp(name, "..")) {
 221                         if (cur_ino == get_root_inode())
 222                                 r = ELEAVEMOUNT;
 223                         else
 224                                 r = go_up(cur_ino, &next_ino);
 225                 } else {
 226                         r = go_down(cur_ino, name, &next_ino);
 227
 228                         /* Perform symlink resolution if we have to. */
 229                         if (r == OK && S_ISLNK(next_ino->i_stat.mode) &&
 230                                 (ptr[0] != '\0' ||
 231                                 !(fs_m_in.REQ_FLAGS & PATH_RET_SYMLINK))) {
 232
 233                                 if (++symloop == SYMLOOP_MAX) {
 234                                         put_inode(next_ino);
 235
 236                                         r = ELOOP;
 237
 238                                         break;
 239                                 }
 240
 241                                 /* Resolve the symlink, and append the
 242                                  * remaining unresolved part of the path.
 243                                  */
 244                                 r = resolve_link(next_ino, path, ptr);
 245
 246                                 put_inode(next_ino);
 247
 248                                 if (r != OK)
 249                                         break;
 250
 251                                 /* If the symlink is absolute, return it to
 252                                  * VFS.
 253                                  */
 254                                 if (path[0] == '/') {
 255                                         r = ESYMLINK;
 256                                         last = path;
 257
 258                                         break;
 259                                 }
 260
 261                                 ptr = path;
 262                                 continue;
 263                         }
 264                 }
 265
 266                 if (r != OK)
 267                         break;
 268
 269                 /* We have found a new file. Continue from this file. */
 270                 assert(next_ino != NULL);
 271
 272                 put_inode(cur_ino);
 273
 274                 cur_ino = next_ino;
 275         }
 276
 277         /* If an error occurred, close the file and return error information.
 278          */
 279         if (r != OK) {
 280                 put_inode(cur_ino);
 281
 282                 /* We'd need support for this here. */
 283                 assert(r != EENTERMOUNT);
 284
 285                 /* Copy back the path if we resolved at least one symlink. */
 286                 if (symloop > 0 && (r == ELEAVEMOUNT || r == ESYMLINK)) {
 287                         r2 = sys_safecopyto(fs_m_in.m_source,
 288                                 fs_m_in.REQ_GRANT, 0, (vir_bytes) path,
 289                                 strlen(path) + 1);
 290
 291                         if (r2 != OK)
 292                                 r = r2;
 293                 }
 294
 295                 if (r == ELEAVEMOUNT || r == ESYMLINK) {
 296                         fs_m_out.RES_OFFSET = (int) (last - path);
 297                         fs_m_out.RES_SYMLOOP = symloop;
 298                 }
 299
 300                 return r;
 301         }
 302
 303         /* On success, leave the resulting file open and return its details. */
 304         fs_m_out.RES_INODE_NR = get_inode_number(cur_ino);
 305         fs_m_out.RES_MODE = cur_ino->i_stat.mode;
 306         fs_m_out.RES_FILE_SIZE_HI = 0;
 307         fs_m_out.RES_FILE_SIZE_LO = cur_ino->i_stat.size;
 308         fs_m_out.RES_UID = cur_ino->i_stat.uid;
 309         fs_m_out.RES_GID = cur_ino->i_stat.gid;
 310         fs_m_out.RES_DEV = cur_ino->i_stat.dev;
 311
 312         return OK;
 313 }