fs/hfsplus/ioctl.c

   1 /*
   2  *  linux/fs/hfsplus/ioctl.c
   3  *
   4  * Copyright (C) 2003
   5  * Ethan Benson <erbenson@alaska.net>
   6  * partially derived from linux/fs/ext2/ioctl.c
   7  * Copyright (C) 1993, 1994, 1995
   8  * Remy Card (card@masi.ibp.fr)
   9  * Laboratoire MASI - Institut Blaise Pascal
  10  * Universite Pierre et Marie Curie (Paris VI)
  11  *
  12  * hfsplus ioctls
  13  */
  14
  15 #include <linux/capability.h>
  16 #include <linux/fs.h>
  17 #include <linux/mount.h>
  18 #include <linux/sched.h>
  19 #include <linux/xattr.h>
  20 #include <asm/uaccess.h>
  21 #include "hfsplus_fs.h"
  22
  23 static int hfsplus_ioctl_getflags(struct file *file, int __user *user_flags)
  24 {
  25         struct inode *inode = file->f_path.dentry->d_inode;
  26         struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
  27         unsigned int flags = 0;
  28
  29         if (inode->i_flags & S_IMMUTABLE)
  30                 flags |= FS_IMMUTABLE_FL;
  31         if (inode->i_flags & S_APPEND)
  32                 flags |= FS_APPEND_FL;
  33         if (hip->userflags & HFSPLUS_FLG_NODUMP)
  34                 flags |= FS_NODUMP_FL;
  35
  36         return put_user(flags, user_flags);
  37 }
  38
  39 static int hfsplus_ioctl_setflags(struct file *file, int __user *user_flags)
  40 {
  41         struct inode *inode = file->f_path.dentry->d_inode;
  42         struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
  43         unsigned int flags;
  44         int err = 0;
  45
  46         err = mnt_want_write(file->f_path.mnt);
  47         if (err)
  48                 goto out;
  49
  50         if (!inode_owner_or_capable(inode)) {
  51                 err = -EACCES;
  52                 goto out_drop_write;
  53         }
  54
  55         if (get_user(flags, user_flags)) {
  56                 err = -EFAULT;
  57                 goto out_drop_write;
  58         }
  59
  60         mutex_lock(&inode->i_mutex);
  61
  62         if ((flags & (FS_IMMUTABLE_FL|FS_APPEND_FL)) ||
  63             inode->i_flags & (S_IMMUTABLE|S_APPEND)) {
  64                 if (!capable(CAP_LINUX_IMMUTABLE)) {
  65                         err = -EPERM;
  66                         goto out_unlock_inode;
  67                 }
  68         }
  69
  70         /* don't silently ignore unsupported ext2 flags */
  71         if (flags & ~(FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NODUMP_FL)) {
  72                 err = -EOPNOTSUPP;
  73                 goto out_unlock_inode;
  74         }
  75
  76         if (flags & FS_IMMUTABLE_FL)
  77                 inode->i_flags |= S_IMMUTABLE;
  78         else
  79                 inode->i_flags &= ~S_IMMUTABLE;
  80
  81         if (flags & FS_APPEND_FL)
  82                 inode->i_flags |= S_APPEND;
  83         else
  84                 inode->i_flags &= ~S_APPEND;
  85
  86         if (flags & FS_NODUMP_FL)
  87                 hip->userflags |= HFSPLUS_FLG_NODUMP;
  88         else
  89                 hip->userflags &= ~HFSPLUS_FLG_NODUMP;
  90
  91         inode->i_ctime = CURRENT_TIME_SEC;
  92         mark_inode_dirty(inode);
  93
  94 out_unlock_inode:
  95         mutex_unlock(&inode->i_mutex);
  96 out_drop_write:
  97         mnt_drop_write(file->f_path.mnt);
  98 out:
  99         return err;
 100 }
 101
 102 long hfsplus_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 103 {
 104         void __user *argp = (void __user *)arg;
 105
 106         switch (cmd) {
 107         case HFSPLUS_IOC_EXT2_GETFLAGS:
 108                 return hfsplus_ioctl_getflags(file, argp);
 109         case HFSPLUS_IOC_EXT2_SETFLAGS:
 110                 return hfsplus_ioctl_setflags(file, argp);
 111         default:
 112                 return -ENOTTY;
 113         }
 114 }
 115
 116 int hfsplus_setxattr(struct dentry *dentry, const char *name,
 117                      const void *value, size_t size, int flags)
 118 {
 119         struct inode *inode = dentry->d_inode;
 120         struct hfs_find_data fd;
 121         hfsplus_cat_entry entry;
 122         struct hfsplus_cat_file *file;
 123         int res;
 124
 125         if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
 126                 return -EOPNOTSUPP;
 127
 128         res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
 129         if (res)
 130                 return res;
 131         res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
 132         if (res)
 133                 goto out;
 134         hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
 135                         sizeof(struct hfsplus_cat_file));
 136         file = &entry.file;
 137
 138         if (!strcmp(name, "hfs.type")) {
 139                 if (size == 4)
 140                         memcpy(&file->user_info.fdType, value, 4);
 141                 else
 142                         res = -ERANGE;
 143         } else if (!strcmp(name, "hfs.creator")) {
 144                 if (size == 4)
 145                         memcpy(&file->user_info.fdCreator, value, 4);
 146                 else
 147                         res = -ERANGE;
 148         } else
 149                 res = -EOPNOTSUPP;
 150         if (!res) {
 151                 hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
 152                                 sizeof(struct hfsplus_cat_file));
 153                 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
 154         }
 155 out:
 156         hfs_find_exit(&fd);
 157         return res;
 158 }
 159
 160 ssize_t hfsplus_getxattr(struct dentry *dentry, const char *name,
 161                          void *value, size_t size)
 162 {
 163         struct inode *inode = dentry->d_inode;
 164         struct hfs_find_data fd;
 165         hfsplus_cat_entry entry;
 166         struct hfsplus_cat_file *file;
 167         ssize_t res = 0;
 168
 169         if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
 170                 return -EOPNOTSUPP;
 171
 172         if (size) {
 173                 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
 174                 if (res)
 175                         return res;
 176                 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
 177                 if (res)
 178                         goto out;
 179                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
 180                                 sizeof(struct hfsplus_cat_file));
 181         }
 182         file = &entry.file;
 183
 184         if (!strcmp(name, "hfs.type")) {
 185                 if (size >= 4) {
 186                         memcpy(value, &file->user_info.fdType, 4);
 187                         res = 4;
 188                 } else
 189                         res = size ? -ERANGE : 4;
 190         } else if (!strcmp(name, "hfs.creator")) {
 191                 if (size >= 4) {
 192                         memcpy(value, &file->user_info.fdCreator, 4);
 193                         res = 4;
 194                 } else
 195                         res = size ? -ERANGE : 4;
 196         } else
 197                 res = -EOPNOTSUPP;
 198 out:
 199         if (size)
 200                 hfs_find_exit(&fd);
 201         return res;
 202 }
 203
 204 #define HFSPLUS_ATTRLIST_SIZE (sizeof("hfs.creator")+sizeof("hfs.type"))
 205
 206 ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
 207 {
 208         struct inode *inode = dentry->d_inode;
 209
 210         if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
 211                 return -EOPNOTSUPP;
 212
 213         if (!buffer || !size)
 214                 return HFSPLUS_ATTRLIST_SIZE;
 215         if (size < HFSPLUS_ATTRLIST_SIZE)
 216                 return -ERANGE;
 217         strcpy(buffer, "hfs.type");
 218         strcpy(buffer + sizeof("hfs.type"), "hfs.creator");
 219
 220         return HFSPLUS_ATTRLIST_SIZE;
 221 }