hfsplus: split hfsplus_ioctl
[linux-2.6.git] / 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 <linux/smp_lock.h>
21 #include <asm/uaccess.h>
22 #include "hfsplus_fs.h"
23
24 static int hfsplus_ioctl_getflags(struct file *file, int __user *user_flags)
25 {
26         struct inode *inode = file->f_path.dentry->d_inode;
27         unsigned int flags = 0;
28
29         if (HFSPLUS_I(inode).rootflags & HFSPLUS_FLG_IMMUTABLE)
30                 flags |= FS_IMMUTABLE_FL;
31         if (HFSPLUS_I(inode).rootflags & HFSPLUS_FLG_APPEND)
32                 flags |= FS_APPEND_FL;
33         if (HFSPLUS_I(inode).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         unsigned int flags;
43         int err = 0;
44
45         lock_kernel();
46         err = mnt_want_write(file->f_path.mnt);
47         if (err)
48                 goto out_unlock_kernel;
49
50         if (!is_owner_or_cap(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         if (flags & (FS_IMMUTABLE_FL|FS_APPEND_FL) ||
61             HFSPLUS_I(inode).rootflags & (HFSPLUS_FLG_IMMUTABLE|HFSPLUS_FLG_APPEND)) {
62                 if (!capable(CAP_LINUX_IMMUTABLE)) {
63                         err = -EPERM;
64                         goto out_drop_write;
65                 }
66         }
67
68         /* don't silently ignore unsupported ext2 flags */
69         if (flags & ~(FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NODUMP_FL)) {
70                 err = -EOPNOTSUPP;
71                 goto out_drop_write;
72         }
73         if (flags & FS_IMMUTABLE_FL) {
74                 inode->i_flags |= S_IMMUTABLE;
75                 HFSPLUS_I(inode).rootflags |= HFSPLUS_FLG_IMMUTABLE;
76         } else {
77                 inode->i_flags &= ~S_IMMUTABLE;
78                 HFSPLUS_I(inode).rootflags &= ~HFSPLUS_FLG_IMMUTABLE;
79         }
80         if (flags & FS_APPEND_FL) {
81                 inode->i_flags |= S_APPEND;
82                 HFSPLUS_I(inode).rootflags |= HFSPLUS_FLG_APPEND;
83         } else {
84                 inode->i_flags &= ~S_APPEND;
85                 HFSPLUS_I(inode).rootflags &= ~HFSPLUS_FLG_APPEND;
86         }
87         if (flags & FS_NODUMP_FL)
88                 HFSPLUS_I(inode).userflags |= HFSPLUS_FLG_NODUMP;
89         else
90                 HFSPLUS_I(inode).userflags &= ~HFSPLUS_FLG_NODUMP;
91
92         inode->i_ctime = CURRENT_TIME_SEC;
93         mark_inode_dirty(inode);
94
95 out_drop_write:
96         mnt_drop_write(file->f_path.mnt);
97 out_unlock_kernel:
98         unlock_kernel();
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 out:
154         hfs_find_exit(&fd);
155         return res;
156 }
157
158 ssize_t hfsplus_getxattr(struct dentry *dentry, const char *name,
159                          void *value, size_t size)
160 {
161         struct inode *inode = dentry->d_inode;
162         struct hfs_find_data fd;
163         hfsplus_cat_entry entry;
164         struct hfsplus_cat_file *file;
165         ssize_t res = 0;
166
167         if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
168                 return -EOPNOTSUPP;
169
170         if (size) {
171                 res = hfs_find_init(HFSPLUS_SB(inode->i_sb).cat_tree, &fd);
172                 if (res)
173                         return res;
174                 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
175                 if (res)
176                         goto out;
177                 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
178                                 sizeof(struct hfsplus_cat_file));
179         }
180         file = &entry.file;
181
182         if (!strcmp(name, "hfs.type")) {
183                 if (size >= 4) {
184                         memcpy(value, &file->user_info.fdType, 4);
185                         res = 4;
186                 } else
187                         res = size ? -ERANGE : 4;
188         } else if (!strcmp(name, "hfs.creator")) {
189                 if (size >= 4) {
190                         memcpy(value, &file->user_info.fdCreator, 4);
191                         res = 4;
192                 } else
193                         res = size ? -ERANGE : 4;
194         } else
195                 res = -ENODATA;
196 out:
197         if (size)
198                 hfs_find_exit(&fd);
199         return res;
200 }
201
202 #define HFSPLUS_ATTRLIST_SIZE (sizeof("hfs.creator")+sizeof("hfs.type"))
203
204 ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
205 {
206         struct inode *inode = dentry->d_inode;
207
208         if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
209                 return -EOPNOTSUPP;
210
211         if (!buffer || !size)
212                 return HFSPLUS_ATTRLIST_SIZE;
213         if (size < HFSPLUS_ATTRLIST_SIZE)
214                 return -ERANGE;
215         strcpy(buffer, "hfs.type");
216         strcpy(buffer + sizeof("hfs.type"), "hfs.creator");
217
218         return HFSPLUS_ATTRLIST_SIZE;
219 }