741 lines
15 KiB
C
741 lines
15 KiB
C
/*
|
|
* linux/fs/namei.c
|
|
*
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
*/
|
|
|
|
/*
|
|
* Some corrections by tytso.
|
|
*/
|
|
|
|
#include <asm/segment.h>
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/string.h>
|
|
#include <linux/fcntl.h>
|
|
#include <linux/stat.h>
|
|
|
|
#define ACC_MODE(x) ("\000\004\002\006"[(x)&O_ACCMODE])
|
|
|
|
/*
|
|
* In order to reduce some races, while at the same time doing additional
|
|
* checking and hopefully speeding things up, we copy filenames to the
|
|
* kernel data space before using them..
|
|
*
|
|
* POSIX.1 2.4: an empty pathname is invalid (ENOENT).
|
|
*/
|
|
int getname(const char * filename, char **result)
|
|
{
|
|
int error;
|
|
unsigned long i, page;
|
|
char * tmp, c;
|
|
|
|
i = (unsigned long) filename;
|
|
if (!i || i >= TASK_SIZE)
|
|
return -EFAULT;
|
|
i = TASK_SIZE - i;
|
|
error = -EFAULT;
|
|
if (i > PAGE_SIZE) {
|
|
i = PAGE_SIZE;
|
|
error = -ENAMETOOLONG;
|
|
}
|
|
c = get_fs_byte(filename++);
|
|
if (!c)
|
|
return -ENOENT;
|
|
if(!(page = __get_free_page(GFP_KERNEL)))
|
|
return -ENOMEM;
|
|
*result = tmp = (char *) page;
|
|
while (--i) {
|
|
*(tmp++) = c;
|
|
c = get_fs_byte(filename++);
|
|
if (!c) {
|
|
*tmp = '\0';
|
|
return 0;
|
|
}
|
|
}
|
|
free_page(page);
|
|
return error;
|
|
}
|
|
|
|
void putname(char * name)
|
|
{
|
|
free_page((unsigned long) name);
|
|
}
|
|
|
|
/*
|
|
* permission()
|
|
*
|
|
* is used to check for read/write/execute permissions on a file.
|
|
* I don't know if we should look at just the euid or both euid and
|
|
* uid, but that should be easily changed.
|
|
*/
|
|
int permission(struct inode * inode,int mask)
|
|
{
|
|
int mode = inode->i_mode;
|
|
|
|
if (inode->i_op && inode->i_op->permission)
|
|
return inode->i_op->permission(inode, mask);
|
|
else if (current->euid == inode->i_uid)
|
|
mode >>= 6;
|
|
else if (in_group_p(inode->i_gid))
|
|
mode >>= 3;
|
|
if (((mode & mask & 0007) == mask) || suser())
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* lookup() looks up one part of a pathname, using the fs-dependent
|
|
* routines (currently minix_lookup) for it. It also checks for
|
|
* fathers (pseudo-roots, mount-points)
|
|
*/
|
|
int lookup(struct inode * dir,const char * name, int len,
|
|
struct inode ** result)
|
|
{
|
|
struct super_block * sb;
|
|
int perm;
|
|
|
|
*result = NULL;
|
|
if (!dir)
|
|
return -ENOENT;
|
|
/* check permissions before traversing mount-points */
|
|
perm = permission(dir,MAY_EXEC);
|
|
if (len==2 && name[0] == '.' && name[1] == '.') {
|
|
if (dir == current->root) {
|
|
*result = dir;
|
|
return 0;
|
|
} else if ((sb = dir->i_sb) && (dir == sb->s_mounted)) {
|
|
sb = dir->i_sb;
|
|
iput(dir);
|
|
dir = sb->s_covered;
|
|
if (!dir)
|
|
return -ENOENT;
|
|
dir->i_count++;
|
|
}
|
|
}
|
|
if (!dir->i_op || !dir->i_op->lookup) {
|
|
iput(dir);
|
|
return -ENOTDIR;
|
|
}
|
|
if (!perm) {
|
|
iput(dir);
|
|
return -EACCES;
|
|
}
|
|
if (!len) {
|
|
*result = dir;
|
|
return 0;
|
|
}
|
|
return dir->i_op->lookup(dir,name,len,result);
|
|
}
|
|
|
|
int follow_link(struct inode * dir, struct inode * inode,
|
|
int flag, int mode, struct inode ** res_inode)
|
|
{
|
|
if (!dir || !inode) {
|
|
iput(dir);
|
|
iput(inode);
|
|
*res_inode = NULL;
|
|
return -ENOENT;
|
|
}
|
|
if (!inode->i_op || !inode->i_op->follow_link) {
|
|
iput(dir);
|
|
*res_inode = inode;
|
|
return 0;
|
|
}
|
|
return inode->i_op->follow_link(dir,inode,flag,mode,res_inode);
|
|
}
|
|
|
|
/*
|
|
* dir_namei()
|
|
*
|
|
* dir_namei() returns the inode of the directory of the
|
|
* specified name, and the name within that directory.
|
|
*/
|
|
static int dir_namei(const char * pathname, int * namelen, const char ** name,
|
|
struct inode * base, struct inode ** res_inode)
|
|
{
|
|
char c;
|
|
const char * thisname;
|
|
int len,error;
|
|
struct inode * inode;
|
|
|
|
*res_inode = NULL;
|
|
if (!base) {
|
|
base = current->pwd;
|
|
base->i_count++;
|
|
}
|
|
if ((c = *pathname) == '/') {
|
|
iput(base);
|
|
base = current->root;
|
|
pathname++;
|
|
base->i_count++;
|
|
}
|
|
while (1) {
|
|
thisname = pathname;
|
|
for(len=0;(c = *(pathname++))&&(c != '/');len++)
|
|
/* nothing */ ;
|
|
if (!c)
|
|
break;
|
|
base->i_count++;
|
|
error = lookup(base,thisname,len,&inode);
|
|
if (error) {
|
|
iput(base);
|
|
return error;
|
|
}
|
|
error = follow_link(base,inode,0,0,&base);
|
|
if (error)
|
|
return error;
|
|
}
|
|
if (!base->i_op || !base->i_op->lookup) {
|
|
iput(base);
|
|
return -ENOTDIR;
|
|
}
|
|
*name = thisname;
|
|
*namelen = len;
|
|
*res_inode = base;
|
|
return 0;
|
|
}
|
|
|
|
static int _namei(const char * pathname, struct inode * base,
|
|
int follow_links, struct inode ** res_inode)
|
|
{
|
|
const char * basename;
|
|
int namelen,error;
|
|
struct inode * inode;
|
|
|
|
*res_inode = NULL;
|
|
error = dir_namei(pathname,&namelen,&basename,base,&base);
|
|
if (error)
|
|
return error;
|
|
base->i_count++; /* lookup uses up base */
|
|
error = lookup(base,basename,namelen,&inode);
|
|
if (error) {
|
|
iput(base);
|
|
return error;
|
|
}
|
|
if (follow_links) {
|
|
error = follow_link(base,inode,0,0,&inode);
|
|
if (error)
|
|
return error;
|
|
} else
|
|
iput(base);
|
|
*res_inode = inode;
|
|
return 0;
|
|
}
|
|
|
|
int lnamei(const char * pathname, struct inode ** res_inode)
|
|
{
|
|
int error;
|
|
char * tmp;
|
|
|
|
error = getname(pathname,&tmp);
|
|
if (!error) {
|
|
error = _namei(tmp,NULL,0,res_inode);
|
|
putname(tmp);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
/*
|
|
* namei()
|
|
*
|
|
* is used by most simple commands to get the inode of a specified name.
|
|
* Open, link etc use their own routines, but this is enough for things
|
|
* like 'chmod' etc.
|
|
*/
|
|
int namei(const char * pathname, struct inode ** res_inode)
|
|
{
|
|
int error;
|
|
char * tmp;
|
|
|
|
error = getname(pathname,&tmp);
|
|
if (!error) {
|
|
error = _namei(tmp,NULL,1,res_inode);
|
|
putname(tmp);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
/*
|
|
* open_namei()
|
|
*
|
|
* namei for open - this is in fact almost the whole open-routine.
|
|
*
|
|
* Note that the low bits of "flag" aren't the same as in the open
|
|
* system call - they are 00 - no permissions needed
|
|
* 01 - read permission needed
|
|
* 10 - write permission needed
|
|
* 11 - read/write permissions needed
|
|
* which is a lot more logical, and also allows the "no perm" needed
|
|
* for symlinks (where the permissions are checked later).
|
|
*/
|
|
int open_namei(const char * pathname, int flag, int mode,
|
|
struct inode ** res_inode, struct inode * base)
|
|
{
|
|
const char * basename;
|
|
int namelen,error,i;
|
|
struct inode * dir, *inode;
|
|
struct task_struct ** p;
|
|
|
|
mode &= S_IALLUGO & ~current->umask;
|
|
mode |= S_IFREG;
|
|
error = dir_namei(pathname,&namelen,&basename,base,&dir);
|
|
if (error)
|
|
return error;
|
|
if (!namelen) { /* special case: '/usr/' etc */
|
|
if (flag & 2) {
|
|
iput(dir);
|
|
return -EISDIR;
|
|
}
|
|
/* thanks to Paul Pluzhnikov for noticing this was missing.. */
|
|
if (!permission(dir,ACC_MODE(flag))) {
|
|
iput(dir);
|
|
return -EACCES;
|
|
}
|
|
*res_inode=dir;
|
|
return 0;
|
|
}
|
|
for (i = 0; i < 5; i++) { /* races... */
|
|
dir->i_count++; /* lookup eats the dir */
|
|
error = lookup(dir,basename,namelen,&inode);
|
|
if (!error)
|
|
break;
|
|
if (!(flag & O_CREAT)) {
|
|
iput(dir);
|
|
return error;
|
|
}
|
|
if (!permission(dir,MAY_WRITE | MAY_EXEC)) {
|
|
iput(dir);
|
|
return -EACCES;
|
|
}
|
|
if (!dir->i_op || !dir->i_op->create) {
|
|
iput(dir);
|
|
return -EACCES;
|
|
}
|
|
if (IS_RDONLY(dir)) {
|
|
iput(dir);
|
|
return -EROFS;
|
|
}
|
|
dir->i_count++; /* create eats the dir */
|
|
error = dir->i_op->create(dir,basename,namelen,mode,res_inode);
|
|
if (error != -EEXIST) {
|
|
iput(dir);
|
|
return error;
|
|
}
|
|
}
|
|
if (error) {
|
|
iput(dir);
|
|
return error;
|
|
}
|
|
if ((flag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) {
|
|
iput(dir);
|
|
iput(inode);
|
|
return -EEXIST;
|
|
}
|
|
error = follow_link(dir,inode,flag,mode,&inode);
|
|
if (error)
|
|
return error;
|
|
if (S_ISDIR(inode->i_mode) && (flag & 2)) {
|
|
iput(inode);
|
|
return -EISDIR;
|
|
}
|
|
if (!permission(inode,ACC_MODE(flag))) {
|
|
iput(inode);
|
|
return -EACCES;
|
|
}
|
|
if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
|
|
if (IS_NODEV(inode)) {
|
|
iput(inode);
|
|
return -EACCES;
|
|
}
|
|
} else {
|
|
if (IS_RDONLY(inode) && (flag & 2)) {
|
|
iput(inode);
|
|
return -EROFS;
|
|
}
|
|
}
|
|
if ((inode->i_count > 1) && (flag & 2)) {
|
|
for (p = &LAST_TASK ; p > &FIRST_TASK ; --p) {
|
|
struct vm_area_struct * mpnt;
|
|
if (!*p)
|
|
continue;
|
|
if (inode == (*p)->executable) {
|
|
iput(inode);
|
|
return -ETXTBSY;
|
|
}
|
|
for(mpnt = (*p)->mmap; mpnt; mpnt = mpnt->vm_next) {
|
|
if (mpnt->vm_page_prot & PAGE_RW)
|
|
continue;
|
|
if (inode == mpnt->vm_inode) {
|
|
iput(inode);
|
|
return -ETXTBSY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (flag & O_TRUNC) {
|
|
inode->i_size = 0;
|
|
if (inode->i_op && inode->i_op->truncate)
|
|
inode->i_op->truncate(inode);
|
|
if ((error = notify_change(NOTIFY_SIZE, inode))) {
|
|
iput(inode);
|
|
return error;
|
|
}
|
|
inode->i_dirt = 1;
|
|
}
|
|
*res_inode = inode;
|
|
return 0;
|
|
}
|
|
|
|
int do_mknod(const char * filename, int mode, dev_t dev)
|
|
{
|
|
const char * basename;
|
|
int namelen, error;
|
|
struct inode * dir;
|
|
|
|
mode &= ~current->umask;
|
|
error = dir_namei(filename,&namelen,&basename, NULL, &dir);
|
|
if (error)
|
|
return error;
|
|
if (!namelen) {
|
|
iput(dir);
|
|
return -ENOENT;
|
|
}
|
|
if (IS_RDONLY(dir)) {
|
|
iput(dir);
|
|
return -EROFS;
|
|
}
|
|
if (!permission(dir,MAY_WRITE | MAY_EXEC)) {
|
|
iput(dir);
|
|
return -EACCES;
|
|
}
|
|
if (!dir->i_op || !dir->i_op->mknod) {
|
|
iput(dir);
|
|
return -EPERM;
|
|
}
|
|
return dir->i_op->mknod(dir,basename,namelen,mode,dev);
|
|
}
|
|
|
|
asmlinkage int sys_mknod(const char * filename, int mode, dev_t dev)
|
|
{
|
|
int error;
|
|
char * tmp;
|
|
|
|
if (S_ISDIR(mode) || (!S_ISFIFO(mode) && !suser()))
|
|
return -EPERM;
|
|
switch (mode & S_IFMT) {
|
|
case 0:
|
|
mode |= S_IFREG;
|
|
break;
|
|
case S_IFREG: case S_IFCHR: case S_IFBLK: case S_IFIFO:
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
error = getname(filename,&tmp);
|
|
if (!error) {
|
|
error = do_mknod(tmp,mode,dev);
|
|
putname(tmp);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
static int do_mkdir(const char * pathname, int mode)
|
|
{
|
|
const char * basename;
|
|
int namelen, error;
|
|
struct inode * dir;
|
|
|
|
error = dir_namei(pathname,&namelen,&basename,NULL,&dir);
|
|
if (error)
|
|
return error;
|
|
if (!namelen) {
|
|
iput(dir);
|
|
return -ENOENT;
|
|
}
|
|
if (IS_RDONLY(dir)) {
|
|
iput(dir);
|
|
return -EROFS;
|
|
}
|
|
if (!permission(dir,MAY_WRITE | MAY_EXEC)) {
|
|
iput(dir);
|
|
return -EACCES;
|
|
}
|
|
if (!dir->i_op || !dir->i_op->mkdir) {
|
|
iput(dir);
|
|
return -EPERM;
|
|
}
|
|
return dir->i_op->mkdir(dir,basename,namelen,mode);
|
|
}
|
|
|
|
asmlinkage int sys_mkdir(const char * pathname, int mode)
|
|
{
|
|
int error;
|
|
char * tmp;
|
|
|
|
error = getname(pathname,&tmp);
|
|
if (!error) {
|
|
error = do_mkdir(tmp,mode);
|
|
putname(tmp);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
static int do_rmdir(const char * name)
|
|
{
|
|
const char * basename;
|
|
int namelen, error;
|
|
struct inode * dir;
|
|
|
|
error = dir_namei(name,&namelen,&basename,NULL,&dir);
|
|
if (error)
|
|
return error;
|
|
if (!namelen) {
|
|
iput(dir);
|
|
return -ENOENT;
|
|
}
|
|
if (IS_RDONLY(dir)) {
|
|
iput(dir);
|
|
return -EROFS;
|
|
}
|
|
if (!permission(dir,MAY_WRITE | MAY_EXEC)) {
|
|
iput(dir);
|
|
return -EACCES;
|
|
}
|
|
if (!dir->i_op || !dir->i_op->rmdir) {
|
|
iput(dir);
|
|
return -EPERM;
|
|
}
|
|
return dir->i_op->rmdir(dir,basename,namelen);
|
|
}
|
|
|
|
asmlinkage int sys_rmdir(const char * pathname)
|
|
{
|
|
int error;
|
|
char * tmp;
|
|
|
|
error = getname(pathname,&tmp);
|
|
if (!error) {
|
|
error = do_rmdir(tmp);
|
|
putname(tmp);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
static int do_unlink(const char * name)
|
|
{
|
|
const char * basename;
|
|
int namelen, error;
|
|
struct inode * dir;
|
|
|
|
error = dir_namei(name,&namelen,&basename,NULL,&dir);
|
|
if (error)
|
|
return error;
|
|
if (!namelen) {
|
|
iput(dir);
|
|
return -EPERM;
|
|
}
|
|
if (IS_RDONLY(dir)) {
|
|
iput(dir);
|
|
return -EROFS;
|
|
}
|
|
if (!permission(dir,MAY_WRITE | MAY_EXEC)) {
|
|
iput(dir);
|
|
return -EACCES;
|
|
}
|
|
if (!dir->i_op || !dir->i_op->unlink) {
|
|
iput(dir);
|
|
return -EPERM;
|
|
}
|
|
return dir->i_op->unlink(dir,basename,namelen);
|
|
}
|
|
|
|
asmlinkage int sys_unlink(const char * pathname)
|
|
{
|
|
int error;
|
|
char * tmp;
|
|
|
|
error = getname(pathname,&tmp);
|
|
if (!error) {
|
|
error = do_unlink(tmp);
|
|
putname(tmp);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
static int do_symlink(const char * oldname, const char * newname)
|
|
{
|
|
struct inode * dir;
|
|
const char * basename;
|
|
int namelen, error;
|
|
|
|
error = dir_namei(newname,&namelen,&basename,NULL,&dir);
|
|
if (error)
|
|
return error;
|
|
if (!namelen) {
|
|
iput(dir);
|
|
return -ENOENT;
|
|
}
|
|
if (IS_RDONLY(dir)) {
|
|
iput(dir);
|
|
return -EROFS;
|
|
}
|
|
if (!permission(dir,MAY_WRITE | MAY_EXEC)) {
|
|
iput(dir);
|
|
return -EACCES;
|
|
}
|
|
if (!dir->i_op || !dir->i_op->symlink) {
|
|
iput(dir);
|
|
return -EPERM;
|
|
}
|
|
return dir->i_op->symlink(dir,basename,namelen,oldname);
|
|
}
|
|
|
|
asmlinkage int sys_symlink(const char * oldname, const char * newname)
|
|
{
|
|
int error;
|
|
char * from, * to;
|
|
|
|
error = getname(oldname,&from);
|
|
if (!error) {
|
|
error = getname(newname,&to);
|
|
if (!error) {
|
|
error = do_symlink(from,to);
|
|
putname(to);
|
|
}
|
|
putname(from);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
static int do_link(struct inode * oldinode, const char * newname)
|
|
{
|
|
struct inode * dir;
|
|
const char * basename;
|
|
int namelen, error;
|
|
|
|
error = dir_namei(newname,&namelen,&basename,NULL,&dir);
|
|
if (error) {
|
|
iput(oldinode);
|
|
return error;
|
|
}
|
|
if (!namelen) {
|
|
iput(oldinode);
|
|
iput(dir);
|
|
return -EPERM;
|
|
}
|
|
if (IS_RDONLY(dir)) {
|
|
iput(oldinode);
|
|
iput(dir);
|
|
return -EROFS;
|
|
}
|
|
if (dir->i_dev != oldinode->i_dev) {
|
|
iput(dir);
|
|
iput(oldinode);
|
|
return -EXDEV;
|
|
}
|
|
if (!permission(dir,MAY_WRITE | MAY_EXEC)) {
|
|
iput(dir);
|
|
iput(oldinode);
|
|
return -EACCES;
|
|
}
|
|
if (!dir->i_op || !dir->i_op->link) {
|
|
iput(dir);
|
|
iput(oldinode);
|
|
return -EPERM;
|
|
}
|
|
return dir->i_op->link(oldinode, dir, basename, namelen);
|
|
}
|
|
|
|
asmlinkage int sys_link(const char * oldname, const char * newname)
|
|
{
|
|
int error;
|
|
char * to;
|
|
struct inode * oldinode;
|
|
|
|
error = namei(oldname, &oldinode);
|
|
if (error)
|
|
return error;
|
|
error = getname(newname,&to);
|
|
if (error) {
|
|
iput(oldinode);
|
|
return error;
|
|
}
|
|
error = do_link(oldinode,to);
|
|
putname(to);
|
|
return error;
|
|
}
|
|
|
|
static int do_rename(const char * oldname, const char * newname)
|
|
{
|
|
struct inode * old_dir, * new_dir;
|
|
const char * old_base, * new_base;
|
|
int old_len, new_len, error;
|
|
|
|
error = dir_namei(oldname,&old_len,&old_base,NULL,&old_dir);
|
|
if (error)
|
|
return error;
|
|
if (!permission(old_dir,MAY_WRITE | MAY_EXEC)) {
|
|
iput(old_dir);
|
|
return -EACCES;
|
|
}
|
|
if (!old_len || (old_base[0] == '.' &&
|
|
(old_len == 1 || (old_base[1] == '.' &&
|
|
old_len == 2)))) {
|
|
iput(old_dir);
|
|
return -EPERM;
|
|
}
|
|
error = dir_namei(newname,&new_len,&new_base,NULL,&new_dir);
|
|
if (error) {
|
|
iput(old_dir);
|
|
return error;
|
|
}
|
|
if (!permission(new_dir,MAY_WRITE | MAY_EXEC)) {
|
|
iput(old_dir);
|
|
iput(new_dir);
|
|
return -EACCES;
|
|
}
|
|
if (!new_len || (new_base[0] == '.' &&
|
|
(new_len == 1 || (new_base[1] == '.' &&
|
|
new_len == 2)))) {
|
|
iput(old_dir);
|
|
iput(new_dir);
|
|
return -EPERM;
|
|
}
|
|
if (new_dir->i_dev != old_dir->i_dev) {
|
|
iput(old_dir);
|
|
iput(new_dir);
|
|
return -EXDEV;
|
|
}
|
|
if (IS_RDONLY(new_dir) || IS_RDONLY(old_dir)) {
|
|
iput(old_dir);
|
|
iput(new_dir);
|
|
return -EROFS;
|
|
}
|
|
if (!old_dir->i_op || !old_dir->i_op->rename) {
|
|
iput(old_dir);
|
|
iput(new_dir);
|
|
return -EPERM;
|
|
}
|
|
return old_dir->i_op->rename(old_dir, old_base, old_len,
|
|
new_dir, new_base, new_len);
|
|
}
|
|
|
|
asmlinkage int sys_rename(const char * oldname, const char * newname)
|
|
{
|
|
int error;
|
|
char * from, * to;
|
|
|
|
error = getname(oldname,&from);
|
|
if (!error) {
|
|
error = getname(newname,&to);
|
|
if (!error) {
|
|
error = do_rename(from,to);
|
|
putname(to);
|
|
}
|
|
putname(from);
|
|
}
|
|
return error;
|
|
}
|