lib/ext2fs/namei.c

   1 /*
   2  * namei.c --- ext2fs directory lookup operations
   3  *
   4  * Copyright (C) 1993, 1994, 1994, 1995 Theodore Ts'o.
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU Library
   8  * General Public License, version 2.
   9  * %End-Header%
  10  */
  11
  12 #include "config.h"
  13 #include <stdio.h>
  14 #include <string.h>
  15 #if HAVE_UNISTD_H
  16 #include <unistd.h>
  17 #endif
  18
  19 /* #define NAMEI_DEBUG */
  20
  21 #include "ext2_fs.h"
  22 #include "ext2fs.h"
  23 #include "ext2fsP.h"
  24
  25 static errcode_t open_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t base,
  26                             const char *pathname, size_t pathlen, int follow,
  27                             int link_count, char *buf, ext2_ino_t *res_inode);
  28
  29 static errcode_t follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t dir,
  30                              ext2_ino_t inode, int link_count,
  31                              char *buf, ext2_ino_t *res_inode)
  32 {
  33         char *pathname;
  34         char *buffer = 0;
  35         errcode_t retval;
  36         struct ext2_inode ei;
  37
  38 #ifdef NAMEI_DEBUG
  39         printf("follow_link: root=%lu, dir=%lu, inode=%lu, lc=%d\n",
  40                root, dir, inode, link_count);
  41
  42 #endif
  43         retval = ext2fs_read_inode (fs, inode, &ei);
  44         if (retval) return retval;
  45         if (!LINUX_S_ISLNK (ei.i_mode)) {
  46                 *res_inode = inode;
  47                 return 0;
  48         }
  49         if (link_count++ >= EXT2FS_MAX_NESTED_LINKS)
  50                 return EXT2_ET_SYMLINK_LOOP;
  51
  52         /* FIXME-64: Actually, this is FIXME EXTENTS */
  53         if (ext2fs_inode_data_blocks(fs,&ei)) {
  54                 retval = ext2fs_get_mem(fs->blocksize, &buffer);
  55                 if (retval)
  56                         return retval;
  57                 retval = io_channel_read_blk(fs->io, ei.i_block[0], 1, buffer);
  58                 if (retval) {
  59                         ext2fs_free_mem(&buffer);
  60                         return retval;
  61                 }
  62                 pathname = buffer;
  63         } else
  64                 pathname = (char *)&(ei.i_block[0]);
  65         retval = open_namei(fs, root, dir, pathname, ei.i_size, 1,
  66                             link_count, buf, res_inode);
  67         if (buffer)
  68                 ext2fs_free_mem(&buffer);
  69         return retval;
  70 }
  71
  72 /*
  73  * This routine interprets a pathname in the context of the current
  74  * directory and the root directory, and returns the inode of the
  75  * containing directory, and a pointer to the filename of the file
  76  * (pointing into the pathname) and the length of the filename.
  77  */
  78 static errcode_t dir_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t dir,
  79                            const char *pathname, int pathlen,
  80                            int link_count, char *buf,
  81                            const char **name, int *namelen,
  82                            ext2_ino_t *res_inode)
  83 {
  84         char c;
  85         const char *thisname;
  86         int len;
  87         ext2_ino_t inode;
  88         errcode_t retval;
  89
  90         if ((c = *pathname) == '/') {
  91                 dir = root;
  92                 pathname++;
  93                 pathlen--;
  94         }
  95         while (1) {
  96                 thisname = pathname;
  97                 for (len=0; --pathlen >= 0;len++) {
  98                         c = *(pathname++);
  99                         if (c == '/')
 100                                 break;
 101                 }
 102                 if (pathlen < 0)
 103                         break;
 104                 retval = ext2fs_lookup (fs, dir, thisname, len, buf, &inode);
 105                 if (retval) return retval;
 106                 retval = follow_link (fs, root, dir, inode,
 107                                       link_count, buf, &dir);
 108                 if (retval) return retval;
 109         }
 110         *name = thisname;
 111         *namelen = len;
 112         *res_inode = dir;
 113         return 0;
 114 }
 115
 116 static errcode_t open_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t base,
 117                             const char *pathname, size_t pathlen, int follow,
 118                             int link_count, char *buf, ext2_ino_t *res_inode)
 119 {
 120         const char *base_name;
 121         int namelen;
 122         ext2_ino_t dir, inode;
 123         errcode_t retval;
 124
 125 #ifdef NAMEI_DEBUG
 126         printf("open_namei: root=%lu, dir=%lu, path=%*s, lc=%d\n",
 127                root, base, pathlen, pathname, link_count);
 128 #endif
 129         retval = dir_namei(fs, root, base, pathname, pathlen,
 130                            link_count, buf, &base_name, &namelen, &dir);
 131         if (retval) return retval;
 132         if (!namelen) {                     /* special case: '/usr/' etc */
 133                 *res_inode=dir;
 134                 return 0;
 135         }
 136         retval = ext2fs_lookup (fs, dir, base_name, namelen, buf, &inode);
 137         if (retval)
 138                 return retval;
 139         if (follow) {
 140                 retval = follow_link(fs, root, dir, inode, link_count,
 141                                      buf, &inode);
 142                 if (retval)
 143                         return retval;
 144         }
 145 #ifdef NAMEI_DEBUG
 146         printf("open_namei: (link_count=%d) returns %lu\n",
 147                link_count, inode);
 148 #endif
 149         *res_inode = inode;
 150         return 0;
 151 }
 152
 153 errcode_t ext2fs_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
 154                        const char *name, ext2_ino_t *inode)
 155 {
 156         char *buf;
 157         errcode_t retval;
 158
 159         EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 160
 161         retval = ext2fs_get_mem(fs->blocksize, &buf);
 162         if (retval)
 163                 return retval;
 164
 165         retval = open_namei(fs, root, cwd, name, strlen(name), 0, 0,
 166                             buf, inode);
 167
 168         ext2fs_free_mem(&buf);
 169         return retval;
 170 }
 171
 172 errcode_t ext2fs_namei_follow(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
 173                               const char *name, ext2_ino_t *inode)
 174 {
 175         char *buf;
 176         errcode_t retval;
 177
 178         EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 179
 180         retval = ext2fs_get_mem(fs->blocksize, &buf);
 181         if (retval)
 182                 return retval;
 183
 184         retval = open_namei(fs, root, cwd, name, strlen(name), 1, 0,
 185                             buf, inode);
 186
 187         ext2fs_free_mem(&buf);
 188         return retval;
 189 }
 190
 191 errcode_t ext2fs_follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
 192                         ext2_ino_t inode, ext2_ino_t *res_inode)
 193 {
 194         char *buf;
 195         errcode_t retval;
 196
 197         EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 198
 199         retval = ext2fs_get_mem(fs->blocksize, &buf);
 200         if (retval)
 201                 return retval;
 202
 203         retval = follow_link(fs, root, cwd, inode, 0, buf, res_inode);
 204
 205         ext2fs_free_mem(&buf);
 206         return retval;
 207 }
 208