fs/namei.c

/* */
This source file includes following definitions.
permission
lookup
follow_link
dir_namei
_namei
lnamei
namei
open_namei
do_mknod
sys_mknod
sys_mkdir
sys_rmdir
sys_unlink
sys_symlink
sys_link
sys_rename
   1 /*
   2  *  linux/fs/namei.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6 
   7 /*
   8  * Some corrections by tytso.
   9  */
  10 
  11 #include <asm/segment.h>
  12 
  13 #include <linux/errno.h>
  14 #include <linux/sched.h>
  15 #include <linux/kernel.h>
  16 #include <linux/string.h>
  17 #include <linux/fcntl.h>
  18 #include <linux/stat.h>
  19 
  20 #define ACC_MODE(x) ("\000\004\002\006"[(x)&O_ACCMODE])
  21 
  22 /*
  23  * comment out this line if you want names > MINIX_NAME_LEN chars to be
  24  * truncated. Else they will be disallowed.
  25  */
  26 /* #define NO_TRUNCATE */
  27 
  28 /*
  29  *      permission()
  30  *
  31  * is used to check for read/write/execute permissions on a file.
  32  * I don't know if we should look at just the euid or both euid and
  33  * uid, but that should be easily changed.
  34  */
  35 int permission(struct inode * inode,int mask)
     /*  */
  36 {
  37         int mode = inode->i_mode;
  38 
  39 /* special case: not even root can read/write a deleted file */
  40         if (inode->i_dev && !inode->i_nlink)
  41                 return 0;
  42         else if (inode->i_op && inode->i_op->permission)
  43                 return inode->i_op->permission(inode, mask);
  44         else if (current->euid == inode->i_uid)
  45                 mode >>= 6;
  46         else if (in_group_p(inode->i_gid))
  47                 mode >>= 3;
  48         if (((mode & mask & 0007) == mask) || suser())
  49                 return 1;
  50         return 0;
  51 }
  52 
  53 /*
  54  * lookup() looks up one part of a pathname, using the fs-dependent
  55  * routines (currently minix_lookup) for it. It also checks for
  56  * fathers (pseudo-roots, mount-points)
  57  */
  58 int lookup(struct inode * dir,const char * name, int len,
     /*  */
  59         struct inode ** result)
  60 {
  61         struct super_block * sb;
  62 
  63         *result = NULL;
  64         if (len==2 && get_fs_byte(name)=='.' && get_fs_byte(name+1)=='.') {
  65                 if (dir == current->root)
  66                         len = 1;
  67                 else if ((sb = dir->i_sb) && (dir == sb->s_mounted)) {
  68                         sb = dir->i_sb;
  69                         iput(dir);
  70                         dir = sb->s_covered;
  71                         if (dir)
  72                                 dir->i_count++;
  73                 }
  74         }
  75         if (!dir)
  76                 return -ENOENT;
  77         if (!dir->i_op || !dir->i_op->lookup) {
  78                 iput(dir);
  79                 return -ENOTDIR;
  80         }
  81         if (!permission(dir,MAY_EXEC)) {
  82                 iput(dir);
  83                 return -EACCES;
  84         }
  85         if (!len) {
  86                 *result = dir;
  87                 return 0;
  88         }
  89         return dir->i_op->lookup(dir,name,len,result);
  90 }
  91 
  92 int follow_link(struct inode * dir, struct inode * inode,
     /*  */
  93         int flag, int mode, struct inode ** res_inode)
  94 {
  95         if (!dir || !inode) {
  96                 iput(dir);
  97                 iput(inode);
  98                 *res_inode = NULL;
  99                 return -ENOENT;
 100         }
 101         if (!inode->i_op || !inode->i_op->follow_link) {
 102                 iput(dir);
 103                 *res_inode = inode;
 104                 return 0;
 105         }
 106         return inode->i_op->follow_link(dir,inode,flag,mode,res_inode);
 107 }
 108 
 109 /*
 110  *      dir_namei()
 111  *
 112  * dir_namei() returns the inode of the directory of the
 113  * specified name, and the name within that directory.
 114  */
 115 static int dir_namei(const char * pathname, int * namelen, const char ** name,
     /*  */
 116         struct inode * base, struct inode ** res_inode)
 117 {
 118         char c;
 119         const char * thisname;
 120         int len,error;
 121         struct inode * inode;
 122 
 123         *res_inode = NULL;
 124         if (!base) {
 125                 base = current->pwd;
 126                 base->i_count++;
 127         }
 128         if ((c=get_fs_byte(pathname))=='/') {
 129                 iput(base);
 130                 base = current->root;
 131                 pathname++;
 132                 base->i_count++;
 133         }
 134         while (1) {
 135                 thisname = pathname;
 136                 for(len=0;(c=get_fs_byte(pathname++))&&(c!='/');len++)
 137                         /* nothing */ ;
 138                 if (!c)
 139                         break;
 140                 base->i_count++;
 141                 error = lookup(base,thisname,len,&inode);
 142                 if (error) {
 143                         iput(base);
 144                         return error;
 145                 }
 146                 error = follow_link(base,inode,0,0,&base);
 147                 if (error)
 148                         return error;
 149         }
 150         if (!base->i_op || !base->i_op->lookup) {
 151                 iput(base);
 152                 return -ENOTDIR;
 153         }
 154         *name = thisname;
 155         *namelen = len;
 156         *res_inode = base;
 157         return 0;
 158 }
 159 
 160 static int _namei(const char * pathname, struct inode * base,
     /*  */
 161         int follow_links, struct inode ** res_inode)
 162 {
 163         const char * basename;
 164         int namelen,error;
 165         struct inode * inode;
 166 
 167         *res_inode = NULL;
 168         error = dir_namei(pathname,&namelen,&basename,base,&base);
 169         if (error)
 170                 return error;
 171         base->i_count++;        /* lookup uses up base */
 172         error = lookup(base,basename,namelen,&inode);
 173         if (error) {
 174                 iput(base);
 175                 return error;
 176         }
 177         if (follow_links) {
 178                 error = follow_link(base,inode,0,0,&inode);
 179                 if (error)
 180                         return error;
 181         } else
 182                 iput(base);
 183         *res_inode = inode;
 184         return 0;
 185 }
 186 
 187 int lnamei(const char * pathname, struct inode ** res_inode)
     /*  */
 188 {
 189         return _namei(pathname,NULL,0,res_inode);
 190 }
 191 
 192 /*
 193  *      namei()
 194  *
 195  * is used by most simple commands to get the inode of a specified name.
 196  * Open, link etc use their own routines, but this is enough for things
 197  * like 'chmod' etc.
 198  */
 199 int namei(const char * pathname, struct inode ** res_inode)
     /*  */
 200 {
 201         return _namei(pathname,NULL,1,res_inode);
 202 }
 203 
 204 /*
 205  *      open_namei()
 206  *
 207  * namei for open - this is in fact almost the whole open-routine.
 208  *
 209  * Note that the low bits of "flag" aren't the same asin the open
 210  * system call - they are 00 - no permissions needed
 211  *                        01 - read permission needed
 212  *                        10 - write permission needed
 213  *                        11 - read/write permissions needed
 214  * which is a lot more logical, and also allows the "no perm" needed
 215  * for symlinks (where the permissions are checked later).
 216  */
 217 int open_namei(const char * pathname, int flag, int mode,
     /*  */
 218         struct inode ** res_inode, struct inode * base)
 219 {
 220         const char * basename;
 221         int namelen,error,i;
 222         struct inode * dir, *inode;
 223         struct task_struct ** p;
 224 
 225         mode &= 07777 & ~current->umask;
 226         mode |= S_IFREG;
 227         error = dir_namei(pathname,&namelen,&basename,base,&dir);
 228         if (error)
 229                 return error;
 230         if (!namelen) {                 /* special case: '/usr/' etc */
 231                 if (flag & 2) {
 232                         iput(dir);
 233                         return -EISDIR;
 234                 }
 235                 /* thanks to Paul Pluzhnikov for noticing this was missing.. */
 236                 if (!permission(dir,ACC_MODE(flag))) {
 237                         iput(dir);
 238                         return -EACCES;
 239                 }
 240                 *res_inode=dir;
 241                 return 0;
 242         }
 243         dir->i_count++;         /* lookup eats the dir */
 244         error = lookup(dir,basename,namelen,&inode);
 245         if (error) {
 246                 if (!(flag & O_CREAT)) {
 247                         iput(dir);
 248                         return error;
 249                 }
 250                 if (!permission(dir,MAY_WRITE)) {
 251                         iput(dir);
 252                         return -EACCES;
 253                 }
 254                 if (!dir->i_op || !dir->i_op->create) {
 255                         iput(dir);
 256                         return -EACCES;
 257                 }
 258                 if (IS_RDONLY(dir)) {
 259                         iput(dir);
 260                         return -EROFS;
 261                 }
 262                 return dir->i_op->create(dir,basename,namelen,mode,res_inode);
 263         }
 264         if (flag & O_EXCL) {
 265                 iput(dir);
 266                 iput(inode);
 267                 return -EEXIST;
 268         }
 269         error = follow_link(dir,inode,flag,mode,&inode);
 270         if (error)
 271                 return error;
 272         if (S_ISDIR(inode->i_mode) && (flag & 2)) {
 273                 iput(inode);
 274                 return -EISDIR;
 275         }
 276         if (!permission(inode,ACC_MODE(flag))) {
 277                 iput(inode);
 278                 return -EACCES;
 279         }
 280         if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
 281                 if (IS_NODEV(inode)) {
 282                         iput(inode);
 283                         return -EACCES;
 284                 }
 285         } else {
 286                 if (IS_RDONLY(inode) && (flag & 2)) {
 287                         iput(inode);
 288                         return -EROFS;
 289                 }
 290         }
 291         if ((inode->i_count > 1) && (flag & 2))
 292                 for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
 293                         if (!*p)
 294                                 continue;
 295                         if (inode == (*p)->executable) {
 296                                 iput(inode);
 297                                 return -ETXTBSY;
 298                         }
 299                         for (i=0; i < (*p)->numlibraries; i++)
 300                                 if (inode == (*p)->libraries[i].library) {
 301                                         iput(inode);
 302                                         return -ETXTBSY;
 303                                 }
 304                 }
 305         *res_inode = inode;
 306         return 0;
 307 }
 308 
 309 int do_mknod(const char * filename, int mode, dev_t dev)
     /*  */
 310 {
 311         const char * basename;
 312         int namelen, error;
 313         struct inode * dir;
 314 
 315         error = dir_namei(filename,&namelen,&basename, NULL, &dir);
 316         if (error)
 317                 return error;
 318         if (!namelen) {
 319                 iput(dir);
 320                 return -ENOENT;
 321         }
 322         if (IS_RDONLY(dir)) {
 323                 iput(dir);
 324                 return -EROFS;
 325         }
 326         if (!permission(dir,MAY_WRITE)) {
 327                 iput(dir);
 328                 return -EACCES;
 329         }
 330         if (!dir->i_op || !dir->i_op->mknod) {
 331                 iput(dir);
 332                 return -EPERM;
 333         }
 334         return dir->i_op->mknod(dir,basename,namelen,mode,dev);
 335 }
 336 
 337 int sys_mknod(const char * filename, int mode, dev_t dev)
     /*  */
 338 {
 339         if (S_ISFIFO(mode) || suser())
 340                 return do_mknod(filename,mode,dev);
 341         return -EPERM;
 342 }
 343 
 344 int sys_mkdir(const char * pathname, int mode)
     /*  */
 345 {
 346         const char * basename;
 347         int namelen, error;
 348         struct inode * dir;
 349 
 350         error = dir_namei(pathname,&namelen,&basename,NULL,&dir);
 351         if (error)
 352                 return error;
 353         if (!namelen) {
 354                 iput(dir);
 355                 return -ENOENT;
 356         }
 357         if (IS_RDONLY(dir)) {
 358                 iput(dir);
 359                 return -EROFS;
 360         }
 361         if (!permission(dir,MAY_WRITE)) {
 362                 iput(dir);
 363                 return -EACCES;
 364         }
 365         if (!dir->i_op || !dir->i_op->mkdir) {
 366                 iput(dir);
 367                 return -EPERM;
 368         }
 369         return dir->i_op->mkdir(dir,basename,namelen,mode);
 370 }
 371 
 372 int sys_rmdir(const char * name)
     /*  */
 373 {
 374         const char * basename;
 375         int namelen, error;
 376         struct inode * dir;
 377 
 378         error = dir_namei(name,&namelen,&basename,NULL,&dir);
 379         if (error)
 380                 return error;
 381         if (!namelen) {
 382                 iput(dir);
 383                 return -ENOENT;
 384         }
 385         if (IS_RDONLY(dir)) {
 386                 iput(dir);
 387                 return -EROFS;
 388         }
 389         if (!permission(dir,MAY_WRITE | MAY_EXEC)) {
 390                 iput(dir);
 391                 return -EACCES;
 392         }
 393         if (!dir->i_op || !dir->i_op->rmdir) {
 394                 iput(dir);
 395                 return -EPERM;
 396         }
 397         return dir->i_op->rmdir(dir,basename,namelen);
 398 }
 399 
 400 int sys_unlink(const char * name)
     /*  */
 401 {
 402         const char * basename;
 403         int namelen, error;
 404         struct inode * dir;
 405 
 406         error = dir_namei(name,&namelen,&basename,NULL,&dir);
 407         if (error)
 408                 return error;
 409         if (!namelen) {
 410                 iput(dir);
 411                 return -EPERM;
 412         }
 413         if (IS_RDONLY(dir)) {
 414                 iput(dir);
 415                 return -EROFS;
 416         }
 417         if (!permission(dir,MAY_WRITE | MAY_EXEC)) {
 418                 iput(dir);
 419                 return -EACCES;
 420         }
 421         if (!dir->i_op || !dir->i_op->unlink) {
 422                 iput(dir);
 423                 return -EPERM;
 424         }
 425         return dir->i_op->unlink(dir,basename,namelen);
 426 }
 427 
 428 int sys_symlink(const char * oldname, const char * newname)
     /*  */
 429 {
 430         struct inode * dir;
 431         const char * basename;
 432         int namelen, error;
 433 
 434         error = dir_namei(newname,&namelen,&basename,NULL,&dir);
 435         if (error)
 436                 return error;
 437         if (!namelen) {
 438                 iput(dir);
 439                 return -ENOENT;
 440         }
 441         if (IS_RDONLY(dir)) {
 442                 iput(dir);
 443                 return -EROFS;
 444         }
 445         if (!permission(dir,MAY_WRITE)) {
 446                 iput(dir);
 447                 return -EACCES;
 448         }
 449         if (!dir->i_op || !dir->i_op->symlink) {
 450                 iput(dir);
 451                 return -EPERM;
 452         }
 453         return dir->i_op->symlink(dir,basename,namelen,oldname);
 454 }
 455 
 456 int sys_link(const char * oldname, const char * newname)
     /*  */
 457 {
 458         struct inode * oldinode, * dir;
 459         const char * basename;
 460         int namelen, error;
 461 
 462         error = namei(oldname, &oldinode);
 463         if (error)
 464                 return error;
 465         error = dir_namei(newname,&namelen,&basename,NULL,&dir);
 466         if (error) {
 467                 iput(oldinode);
 468                 return error;
 469         }
 470         if (!namelen) {
 471                 iput(oldinode);
 472                 iput(dir);
 473                 return -EPERM;
 474         }
 475         if (IS_RDONLY(dir)) {
 476                 iput(oldinode);
 477                 iput(dir);
 478                 return -EROFS;
 479         }
 480         if (dir->i_dev != oldinode->i_dev) {
 481                 iput(dir);
 482                 iput(oldinode);
 483                 return -EXDEV;
 484         }
 485         if (!permission(dir,MAY_WRITE)) {
 486                 iput(dir);
 487                 iput(oldinode);
 488                 return -EACCES;
 489         }
 490         if (!dir->i_op || !dir->i_op->link) {
 491                 iput(dir);
 492                 iput(oldinode);
 493                 return -EPERM;
 494         }
 495         return dir->i_op->link(oldinode, dir, basename, namelen);
 496 }
 497 
 498 int sys_rename(const char * oldname, const char * newname)
     /*  */
 499 {
 500         struct inode * old_dir, * new_dir;
 501         const char * old_base, * new_base;
 502         int old_len, new_len, error;
 503 
 504         error = dir_namei(oldname,&old_len,&old_base,NULL,&old_dir);
 505         if (error)
 506                 return error;
 507         if (!permission(old_dir,MAY_WRITE)) {
 508                 iput(old_dir);
 509                 return -EACCES;
 510         }
 511         if (!old_len || (get_fs_byte(old_base) == '.' &&
 512             (old_len == 1 || (get_fs_byte(old_base+1) == '.' &&
 513              old_len == 2)))) {
 514                 iput(old_dir);
 515                 return -EPERM;
 516         }
 517         error = dir_namei(newname,&new_len,&new_base,NULL,&new_dir);
 518         if (error) {
 519                 iput(old_dir);
 520                 return error;
 521         }
 522         if (!permission(new_dir,MAY_WRITE)) {
 523                 iput(old_dir);
 524                 iput(new_dir);
 525                 return -EACCES;
 526         }
 527         if (!new_len || (get_fs_byte(new_base) == '.' &&
 528             (new_len == 1 || (get_fs_byte(new_base+1) == '.' &&
 529              new_len == 2)))) {
 530                 iput(old_dir);
 531                 iput(new_dir);
 532                 return -EPERM;
 533         }
 534         if (new_dir->i_dev != old_dir->i_dev) {
 535                 iput(old_dir);
 536                 iput(new_dir);
 537                 return -EXDEV;
 538         }
 539         if (IS_RDONLY(new_dir) || IS_RDONLY(old_dir)) {
 540                 iput(old_dir);
 541                 iput(new_dir);
 542                 return -EROFS;
 543         }
 544         if (!old_dir->i_op || !old_dir->i_op->rename) {
 545                 iput(old_dir);
 546                 iput(new_dir);
 547                 return -EPERM;
 548         }
 549         return old_dir->i_op->rename(old_dir, old_base, old_len, 
 550                 new_dir, new_base, new_len);
 551 }
/* */
root/fs/namei.c

DEFINITIONS
