lib/libsffs/lookup.c

   1 /* This file provides path-to-inode lookup functionality.
   2  *
   3  * The entry points into this file are:
   4  *   do_lookup          perform the LOOKUP file system call
   5  *
   6  * Created:
   7  *   April 2009 (D.C. van Moolenbroek)
   8  */
   9
  10 #include "inc.h"
  11
  12 static int get_mask(vfs_ucred_t *ucred);
  13 static int access_as_dir(struct inode *ino, struct sffs_attr *attr, int
  14         uid, int mask);
  15 static int next_name(char **ptr, char **start, char name[NAME_MAX+1]);
  16 static int go_up(char path[PATH_MAX], struct inode *ino, struct inode
  17         **res_ino, struct sffs_attr *attr);
  18 static int go_down(char path[PATH_MAX], struct inode *ino, char *name,
  19         struct inode **res_ino, struct sffs_attr *attr);
  20
  21 /*===========================================================================*
  22  *                              get_mask                                     *
  23  *===========================================================================*/
  24 static int get_mask(ucred)
  25 vfs_ucred_t *ucred;             /* credentials of the caller */
  26 {
  27   /* Given the caller's credentials, precompute a search access mask to test
  28    * against directory modes.
  29    */
  30   int i;
  31
  32   if (ucred->vu_uid == sffs_params->p_uid) return S_IXUSR;
  33
  34   if (ucred->vu_gid == sffs_params->p_gid) return S_IXGRP;
  35
  36   for (i = 0; i < ucred->vu_ngroups; i++)
  37         if (ucred->vu_sgroups[i] == sffs_params->p_gid) return S_IXGRP;
  38
  39   return S_IXOTH;
  40 }
  41
  42 /*===========================================================================*
  43  *                              access_as_dir                                *
  44  *===========================================================================*/
  45 static int access_as_dir(ino, attr, uid, mask)
  46 struct inode *ino;              /* the inode to test */
  47 struct sffs_attr *attr;         /* attributes of the inode */
  48 int uid;                        /* UID of the caller */
  49 int mask;                       /* search access mask of the caller */
  50 {
  51 /* Check whether the given inode may be accessed as directory.
  52  * Return OK or an appropriate error code.
  53  */
  54   mode_t mode;
  55
  56   assert(attr->a_mask & SFFS_ATTR_MODE);
  57
  58   /* The inode must be a directory to begin with. */
  59   if (!IS_DIR(ino)) return ENOTDIR;
  60
  61   /* The caller must have search access to the directory. Root always does. */
  62   if (uid == 0) return OK;
  63
  64   mode = get_mode(ino, attr->a_mode);
  65
  66   return (mode & mask) ? OK : EACCES;
  67 }
  68
  69 /*===========================================================================*
  70  *                              next_name                                    *
  71  *===========================================================================*/
  72 static int next_name(ptr, start, name)
  73 char **ptr;                     /* cursor pointer into path (in, out) */
  74 char **start;                   /* place to store start of name */
  75 char name[NAME_MAX+1];          /* place to store name */
  76 {
  77 /* Get the next path component from a path.
  78  */
  79   char *p;
  80   int i;
  81
  82   for (p = *ptr; *p == '/'; p++);
  83
  84   *start = p;
  85
  86   if (*p) {
  87         for (i = 0; *p && *p != '/' && i <= NAME_MAX; p++, i++)
  88                 name[i] = *p;
  89
  90         if (i > NAME_MAX)
  91                 return ENAMETOOLONG;
  92
  93         name[i] = 0;
  94   } else {
  95         strcpy(name, ".");
  96   }
  97
  98   *ptr = p;
  99   return OK;
 100 }
 101
 102 /*===========================================================================*
 103  *                              go_up                                        *
 104  *===========================================================================*/
 105 static int go_up(path, ino, res_ino, attr)
 106 char path[PATH_MAX];            /* path to take the last part from */
 107 struct inode *ino;              /* inode of the current directory */
 108 struct inode **res_ino;         /* place to store resulting inode */
 109 struct sffs_attr *attr;         /* place to store inode attributes */
 110 {
 111 /* Given an inode, progress into the parent directory.
 112  */
 113   struct inode *parent;
 114   int r;
 115
 116   pop_path(path);
 117
 118   parent = ino->i_parent;
 119   assert(parent != NULL);
 120
 121   if ((r = verify_path(path, parent, attr, NULL)) != OK)
 122         return r;
 123
 124   get_inode(parent);
 125
 126   *res_ino = parent;
 127
 128   return r;
 129 }
 130
 131 /*===========================================================================*
 132  *                              go_down                                      *
 133  *===========================================================================*/
 134 static int go_down(path, parent, name, res_ino, attr)
 135 char path[PATH_MAX];            /* path to add the name to */
 136 struct inode *parent;           /* inode of the current directory */
 137 char *name;                     /* name of the directory entry */
 138 struct inode **res_ino;         /* place to store resulting inode */
 139 struct sffs_attr *attr;         /* place to store inode attributes */
 140 {
 141 /* Given a directory inode and a name, progress into a directory entry.
 142  */
 143   struct inode *ino;
 144   int r, stale = 0;
 145
 146   if ((r = push_path(path, name)) != OK)
 147         return r;
 148
 149   dprintf(("%s: go_down: name '%s', path now '%s'\n", sffs_name, name, path));
 150
 151   ino = lookup_dentry(parent, name);
 152
 153   dprintf(("%s: lookup_dentry('%s') returned %p\n", sffs_name, name, ino));
 154
 155   if (ino != NULL)
 156         r = verify_path(path, ino, attr, &stale);
 157   else
 158         r = sffs_table->t_getattr(path, attr);
 159
 160   dprintf(("%s: path query returned %d\n", sffs_name, r));
 161
 162   if (r != OK) {
 163         if (ino != NULL) {
 164                 put_inode(ino);
 165
 166                 ino = NULL;
 167         }
 168
 169         if (!stale)
 170                 return r;
 171   }
 172
 173   dprintf(("%s: name '%s'\n", sffs_name, name));
 174
 175   if (ino == NULL) {
 176         if ((ino = get_free_inode()) == NULL)
 177                 return ENFILE;
 178
 179         dprintf(("%s: inode %p ref %d\n", sffs_name, ino, ino->i_ref));
 180
 181         ino->i_flags = MODE_TO_DIRFLAG(attr->a_mode);
 182
 183         add_dentry(parent, name, ino);
 184   }
 185
 186   *res_ino = ino;
 187   return OK;
 188 }
 189
 190 /*===========================================================================*
 191  *                              do_lookup                                    *
 192  *===========================================================================*/
 193 int do_lookup()
 194 {
 195 /* Resolve a path string to an inode.
 196  */
 197   ino_t dir_ino_nr, root_ino_nr;
 198   struct inode *cur_ino, *root_ino;
 199   struct inode *next_ino = NULL;
 200   struct sffs_attr attr;
 201   char buf[PATH_MAX], path[PATH_MAX];
 202   char name[NAME_MAX+1];
 203   char *ptr, *last;
 204   vfs_ucred_t ucred;
 205   mode_t mask;
 206   size_t len;
 207   int r;
 208
 209   dir_ino_nr = m_in.REQ_DIR_INO;
 210   root_ino_nr = m_in.REQ_ROOT_INO;
 211   len = m_in.REQ_PATH_LEN;
 212
 213   /* Fetch the path name. */
 214   if (len < 1 || len > PATH_MAX)
 215         return EINVAL;
 216
 217   r = sys_safecopyfrom(m_in.m_source, m_in.REQ_GRANT, 0,
 218         (vir_bytes) buf, len);
 219
 220   if (r != OK)
 221         return r;
 222
 223   if (buf[len-1] != 0) {
 224         printf("%s: VFS did not zero-terminate path!\n", sffs_name);
 225
 226         return EINVAL;
 227   }
 228
 229   /* Fetch the credentials, and generate a search access mask to test against
 230    * directory modes.
 231    */
 232   if (m_in.REQ_FLAGS & PATH_GET_UCRED) {
 233         if (m_in.REQ_UCRED_SIZE != sizeof(ucred)) {
 234                 printf("%s: bad credential structure size\n", sffs_name);
 235
 236                 return EINVAL;
 237         }
 238
 239         r = sys_safecopyfrom(m_in.m_source, m_in.REQ_GRANT2, 0,
 240                 (vir_bytes) &ucred, m_in.REQ_UCRED_SIZE);
 241
 242         if (r != OK)
 243                 return r;
 244   }
 245   else {
 246         ucred.vu_uid = m_in.REQ_UID;
 247         ucred.vu_gid = m_in.REQ_GID;
 248         ucred.vu_ngroups = 0;
 249   }
 250
 251   mask = get_mask(&ucred);
 252
 253   /* Start the actual lookup. */
 254   dprintf(("%s: lookup: got query '%s'\n", sffs_name, buf));
 255
 256   if ((cur_ino = find_inode(dir_ino_nr)) == NULL)
 257         return EINVAL;
 258
 259   attr.a_mask = SFFS_ATTR_MODE | SFFS_ATTR_SIZE;
 260
 261   if ((r = verify_inode(cur_ino, path, &attr)) != OK)
 262         return r;
 263
 264   get_inode(cur_ino);
 265
 266   if (root_ino_nr > 0)
 267         root_ino = find_inode(root_ino_nr);
 268   else
 269         root_ino = NULL;
 270
 271   /* One possible optimization would be to check a path only right before the
 272    * first ".." in a row, and at the very end (if still necessary). This would
 273    * have consequences for inode validation, though.
 274    */
 275   for (ptr = last = buf; *ptr != 0; ) {
 276         if ((r = access_as_dir(cur_ino, &attr, ucred.vu_uid, mask)) != OK)
 277                 break;
 278
 279         if ((r = next_name(&ptr, &last, name)) != OK)
 280                 break;
 281
 282         dprintf(("%s: lookup: next name '%s'\n", sffs_name, name));
 283
 284         if (!strcmp(name, ".") ||
 285                         (cur_ino == root_ino && !strcmp(name, "..")))
 286                 continue;
 287
 288         if (!strcmp(name, "..")) {
 289                 if (IS_ROOT(cur_ino))
 290                         r = ELEAVEMOUNT;
 291                 else
 292                         r = go_up(path, cur_ino, &next_ino, &attr);
 293         } else {
 294                 r = go_down(path, cur_ino, name, &next_ino, &attr);
 295         }
 296
 297         if (r != OK)
 298                 break;
 299
 300         assert(next_ino != NULL);
 301
 302         put_inode(cur_ino);
 303
 304         cur_ino = next_ino;
 305   }
 306
 307   dprintf(("%s: lookup: result %d\n", sffs_name, r));
 308
 309   if (r != OK) {
 310         put_inode(cur_ino);
 311
 312         /* We'd need support for these here. We don't have such support. */
 313         assert(r != EENTERMOUNT && r != ESYMLINK);
 314
 315         if (r == ELEAVEMOUNT) {
 316                 m_out.RES_OFFSET = (int) (last - buf);
 317                 m_out.RES_SYMLOOP = 0;
 318         }
 319
 320         return r;
 321   }
 322
 323   m_out.RES_INODE_NR = INODE_NR(cur_ino);
 324   m_out.RES_MODE = get_mode(cur_ino, attr.a_mode);
 325   m_out.RES_FILE_SIZE_HI = ex64hi(attr.a_size);
 326   m_out.RES_FILE_SIZE_LO = ex64lo(attr.a_size);
 327   m_out.RES_UID = sffs_params->p_uid;
 328   m_out.RES_GID = sffs_params->p_gid;
 329   m_out.RES_DEV = NO_DEV;
 330
 331   return OK;
 332 }