[net-next-2.6.git] / fs / hfsplus / ioctl.c

/*
 *  linux/fs/hfsplus/ioctl.c
 *
 * Copyright (C) 2003
 * Ethan Benson <erbenson@alaska.net>
 * partially derived from linux/fs/ext2/ioctl.c
 * Copyright (C) 1993, 1994, 1995
 * Remy Card (card@masi.ibp.fr)
 * Laboratoire MASI - Institut Blaise Pascal
 * Universite Pierre et Marie Curie (Paris VI)
 *
 * hfsplus ioctls
 */

#include <linux/capability.h>
#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/sched.h>
#include <linux/xattr.h>
#include <linux/smp_lock.h>
#include <asm/uaccess.h>
#include "hfsplus_fs.h"

long hfsplus_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct inode *inode = filp->f_path.dentry->d_inode;
	unsigned int flags;

	switch (cmd) {
	case HFSPLUS_IOC_EXT2_GETFLAGS:
		flags = 0;
		if (HFSPLUS_I(inode).rootflags & HFSPLUS_FLG_IMMUTABLE)
			flags |= FS_IMMUTABLE_FL; /* EXT2_IMMUTABLE_FL */
		if (HFSPLUS_I(inode).rootflags & HFSPLUS_FLG_APPEND)
			flags |= FS_APPEND_FL; /* EXT2_APPEND_FL */
		if (HFSPLUS_I(inode).userflags & HFSPLUS_FLG_NODUMP)
			flags |= FS_NODUMP_FL; /* EXT2_NODUMP_FL */
		return put_user(flags, (int __user *)arg);
	case HFSPLUS_IOC_EXT2_SETFLAGS: {
		int err = 0;

		lock_kernel();
		err = mnt_want_write(filp->f_path.mnt);
		if (err) {
			unlock_kernel();
			return err;
		}

		if (!is_owner_or_cap(inode)) {
			err = -EACCES;
			goto setflags_out;
		}
		if (get_user(flags, (int __user *)arg)) {
			err = -EFAULT;
			goto setflags_out;
		}
		if (flags & (FS_IMMUTABLE_FL|FS_APPEND_FL) ||
		    HFSPLUS_I(inode).rootflags & (HFSPLUS_FLG_IMMUTABLE|HFSPLUS_FLG_APPEND)) {
			if (!capable(CAP_LINUX_IMMUTABLE)) {
				err = -EPERM;
				goto setflags_out;
			}
		}

		/* don't silently ignore unsupported ext2 flags */
		if (flags & ~(FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NODUMP_FL)) {
			err = -EOPNOTSUPP;
			goto setflags_out;
		}
		if (flags & FS_IMMUTABLE_FL) { /* EXT2_IMMUTABLE_FL */
			inode->i_flags |= S_IMMUTABLE;
			HFSPLUS_I(inode).rootflags |= HFSPLUS_FLG_IMMUTABLE;
		} else {
			inode->i_flags &= ~S_IMMUTABLE;
			HFSPLUS_I(inode).rootflags &= ~HFSPLUS_FLG_IMMUTABLE;
		}
		if (flags & FS_APPEND_FL) { /* EXT2_APPEND_FL */
			inode->i_flags |= S_APPEND;
			HFSPLUS_I(inode).rootflags |= HFSPLUS_FLG_APPEND;
		} else {
			inode->i_flags &= ~S_APPEND;
			HFSPLUS_I(inode).rootflags &= ~HFSPLUS_FLG_APPEND;
		}
		if (flags & FS_NODUMP_FL) /* EXT2_NODUMP_FL */
			HFSPLUS_I(inode).userflags |= HFSPLUS_FLG_NODUMP;
		else
			HFSPLUS_I(inode).userflags &= ~HFSPLUS_FLG_NODUMP;

		inode->i_ctime = CURRENT_TIME_SEC;
		mark_inode_dirty(inode);
setflags_out:
		mnt_drop_write(filp->f_path.mnt);
		unlock_kernel();
		return err;
	}
	default:
		return -ENOTTY;
	}
}

int hfsplus_setxattr(struct dentry *dentry, const char *name,
		     const void *value, size_t size, int flags)
{
	struct inode *inode = dentry->d_inode;
	struct hfs_find_data fd;
	hfsplus_cat_entry entry;
	struct hfsplus_cat_file *file;
	int res;

	if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
		return -EOPNOTSUPP;

	res = hfs_find_init(HFSPLUS_SB(inode->i_sb).cat_tree, &fd);
	if (res)
		return res;
	res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
	if (res)
		goto out;
	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
			sizeof(struct hfsplus_cat_file));
	file = &entry.file;

	if (!strcmp(name, "hfs.type")) {
		if (size == 4)
			memcpy(&file->user_info.fdType, value, 4);
		else
			res = -ERANGE;
	} else if (!strcmp(name, "hfs.creator")) {
		if (size == 4)
			memcpy(&file->user_info.fdCreator, value, 4);
		else
			res = -ERANGE;
	} else
		res = -EOPNOTSUPP;
	if (!res)
		hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
				sizeof(struct hfsplus_cat_file));
out:
	hfs_find_exit(&fd);
	return res;
}

ssize_t hfsplus_getxattr(struct dentry *dentry, const char *name,
			 void *value, size_t size)
{
	struct inode *inode = dentry->d_inode;
	struct hfs_find_data fd;
	hfsplus_cat_entry entry;
	struct hfsplus_cat_file *file;
	ssize_t res = 0;

	if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
		return -EOPNOTSUPP;

	if (size) {
		res = hfs_find_init(HFSPLUS_SB(inode->i_sb).cat_tree, &fd);
		if (res)
			return res;
		res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
		if (res)
			goto out;
		hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
				sizeof(struct hfsplus_cat_file));
	}
	file = &entry.file;

	if (!strcmp(name, "hfs.type")) {
		if (size >= 4) {
			memcpy(value, &file->user_info.fdType, 4);
			res = 4;
		} else
			res = size ? -ERANGE : 4;
	} else if (!strcmp(name, "hfs.creator")) {
		if (size >= 4) {
			memcpy(value, &file->user_info.fdCreator, 4);
			res = 4;
		} else
			res = size ? -ERANGE : 4;
	} else
		res = -ENODATA;
out:
	if (size)
		hfs_find_exit(&fd);
	return res;
}

#define HFSPLUS_ATTRLIST_SIZE (sizeof("hfs.creator")+sizeof("hfs.type"))

ssize_t hfsplus_listxattr(struct dentry *dentry, char *buffer, size_t size)
{
	struct inode *inode = dentry->d_inode;

	if (!S_ISREG(inode->i_mode) || HFSPLUS_IS_RSRC(inode))
		return -EOPNOTSUPP;

	if (!buffer || !size)
		return HFSPLUS_ATTRLIST_SIZE;
	if (size < HFSPLUS_ATTRLIST_SIZE)
		return -ERANGE;
	strcpy(buffer, "hfs.type");
	strcpy(buffer + sizeof("hfs.type"), "hfs.creator");

	return HFSPLUS_ATTRLIST_SIZE;
}
Commit	Line	Data
1da177e4 LT	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
16f7e0fe	15	#include <linux/capability.h>
1da177e4	16	#include <linux/fs.h>
42a74f20	17	#include <linux/mount.h>
1da177e4 LT	18	#include <linux/sched.h>
1da177e4 LT	19	#include <linux/xattr.h>
7cc4bcc6	20	#include <linux/smp_lock.h>
1da177e4 LT	21	#include <asm/uaccess.h>
	22	#include "hfsplus_fs.h"
	23
7cc4bcc6	24	long hfsplus_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1da177e4	25	{
7cc4bcc6	26	struct inode *inode = filp->f_path.dentry->d_inode;
1da177e4 LT	27	unsigned int flags;
	28
	29	switch (cmd) {
	30	case HFSPLUS_IOC_EXT2_GETFLAGS:
	31	flags = 0;
	32	if (HFSPLUS_I(inode).rootflags & HFSPLUS_FLG_IMMUTABLE)
36695673	33	flags \|= FS_IMMUTABLE_FL; /* EXT2_IMMUTABLE_FL */
1da177e4	34	if (HFSPLUS_I(inode).rootflags & HFSPLUS_FLG_APPEND)
36695673	35	flags \|= FS_APPEND_FL; /* EXT2_APPEND_FL */
1da177e4	36	if (HFSPLUS_I(inode).userflags & HFSPLUS_FLG_NODUMP)
36695673	37	flags \|= FS_NODUMP_FL; /* EXT2_NODUMP_FL */
1da177e4 LT	38	return put_user(flags, (int __user *)arg);
1da177e4 LT	39	case HFSPLUS_IOC_EXT2_SETFLAGS: {
42a74f20	40	int err = 0;
249e6353 CH	41
249e6353 CH	42	lock_kernel();
42a74f20	43	err = mnt_want_write(filp->f_path.mnt);
7cc4bcc6 AB	44	if (err) {
7cc4bcc6 AB	45	unlock_kernel();
42a74f20	46	return err;
7cc4bcc6	47	}
1da177e4	48
42a74f20 DH	49	if (!is_owner_or_cap(inode)) {
	50	err = -EACCES;
	51	goto setflags_out;
	52	}
	53	if (get_user(flags, (int __user *)arg)) {
	54	err = -EFAULT;
	55	goto setflags_out;
	56	}
36695673	57	if (flags & (FS_IMMUTABLE_FL\|FS_APPEND_FL) \|\|
1da177e4	58	HFSPLUS_I(inode).rootflags & (HFSPLUS_FLG_IMMUTABLE\|HFSPLUS_FLG_APPEND)) {
42a74f20 DH	59	if (!capable(CAP_LINUX_IMMUTABLE)) {
	60	err = -EPERM;
	61	goto setflags_out;
	62	}
1da177e4 LT	63	}
	64
	65	/* don't silently ignore unsupported ext2 flags */
42a74f20 DH	66	if (flags & ~(FS_IMMUTABLE_FL\|FS_APPEND_FL\|FS_NODUMP_FL)) {
	67	err = -EOPNOTSUPP;
	68	goto setflags_out;
	69	}
36695673	70	if (flags & FS_IMMUTABLE_FL) { /* EXT2_IMMUTABLE_FL */
1da177e4 LT	71	inode->i_flags \|= S_IMMUTABLE;
	72	HFSPLUS_I(inode).rootflags \|= HFSPLUS_FLG_IMMUTABLE;
	73	} else {
	74	inode->i_flags &= ~S_IMMUTABLE;
	75	HFSPLUS_I(inode).rootflags &= ~HFSPLUS_FLG_IMMUTABLE;
	76	}
36695673	77	if (flags & FS_APPEND_FL) { /* EXT2_APPEND_FL */
1da177e4 LT	78	inode->i_flags \|= S_APPEND;
	79	HFSPLUS_I(inode).rootflags \|= HFSPLUS_FLG_APPEND;
	80	} else {
	81	inode->i_flags &= ~S_APPEND;
	82	HFSPLUS_I(inode).rootflags &= ~HFSPLUS_FLG_APPEND;
	83	}
36695673	84	if (flags & FS_NODUMP_FL) /* EXT2_NODUMP_FL */
1da177e4 LT	85	HFSPLUS_I(inode).userflags \|= HFSPLUS_FLG_NODUMP;
	86	else
	87	HFSPLUS_I(inode).userflags &= ~HFSPLUS_FLG_NODUMP;
	88
	89	inode->i_ctime = CURRENT_TIME_SEC;
	90	mark_inode_dirty(inode);
42a74f20 DH	91	setflags_out:
42a74f20 DH	92	mnt_drop_write(filp->f_path.mnt);
7cc4bcc6	93	unlock_kernel();
42a74f20	94	return err;
1da177e4 LT	95	}
	96	default:
	97	return -ENOTTY;
	98	}
	99	}
	100
	101	int hfsplus_setxattr(struct dentry dentry, const char name,
	102	const void *value, size_t size, int flags)
	103	{
	104	struct inode *inode = dentry->d_inode;
	105	struct hfs_find_data fd;
	106	hfsplus_cat_entry entry;
	107	struct hfsplus_cat_file *file;
	108	int res;
	109
	110	if (!S_ISREG(inode->i_mode) \|\| HFSPLUS_IS_RSRC(inode))
	111	return -EOPNOTSUPP;
	112
	113	res = hfs_find_init(HFSPLUS_SB(inode->i_sb).cat_tree, &fd);
	114	if (res)
	115	return res;
	116	res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
	117	if (res)
	118	goto out;
	119	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
	120	sizeof(struct hfsplus_cat_file));
	121	file = &entry.file;
	122
	123	if (!strcmp(name, "hfs.type")) {
	124	if (size == 4)
	125	memcpy(&file->user_info.fdType, value, 4);
	126	else
	127	res = -ERANGE;
	128	} else if (!strcmp(name, "hfs.creator")) {
	129	if (size == 4)
	130	memcpy(&file->user_info.fdCreator, value, 4);
	131	else
	132	res = -ERANGE;
	133	} else
	134	res = -EOPNOTSUPP;
	135	if (!res)
	136	hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
	137	sizeof(struct hfsplus_cat_file));
	138	out:
	139	hfs_find_exit(&fd);
	140	return res;
	141	}
	142
	143	ssize_t hfsplus_getxattr(struct dentry dentry, const char name,
	144	void *value, size_t size)
	145	{
	146	struct inode *inode = dentry->d_inode;
	147	struct hfs_find_data fd;
	148	hfsplus_cat_entry entry;
	149	struct hfsplus_cat_file *file;
	150	ssize_t res = 0;
	151
	152	if (!S_ISREG(inode->i_mode) \|\| HFSPLUS_IS_RSRC(inode))
	153	return -EOPNOTSUPP;
	154
	155	if (size) {
	156	res = hfs_find_init(HFSPLUS_SB(inode->i_sb).cat_tree, &fd);
	157	if (res)
	158	return res;
159	res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
160	if (res)
161	goto out;
162	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
163	sizeof(struct hfsplus_cat_file));
164	}
165	file = &entry.file;
166
167	if (!strcmp(name, "hfs.type")) {
168	if (size >= 4) {
169	memcpy(value, &file->user_info.fdType, 4);
170	res = 4;
171	} else
172	res = size ? -ERANGE : 4;
173	} else if (!strcmp(name, "hfs.creator")) {
174	if (size >= 4) {
175	memcpy(value, &file->user_info.fdCreator, 4);
176	res = 4;
177	} else
178	res = size ? -ERANGE : 4;
179	} else
180	res = -ENODATA;
181	out:
182	if (size)
183	hfs_find_exit(&fd);
184	return res;
185	}
186
187	#define HFSPLUS_ATTRLIST_SIZE (sizeof("hfs.creator")+sizeof("hfs.type"))
188
189	ssize_t hfsplus_listxattr(struct dentry dentry, char buffer, size_t size)
190	{
191	struct inode *inode = dentry->d_inode;
192
193	if (!S_ISREG(inode->i_mode) \|\| HFSPLUS_IS_RSRC(inode))
194	return -EOPNOTSUPP;
195
196	if (!buffer \|\| !size)
197	return HFSPLUS_ATTRLIST_SIZE;
198	if (size < HFSPLUS_ATTRLIST_SIZE)
199	return -ERANGE;
200	strcpy(buffer, "hfs.type");
201	strcpy(buffer + sizeof("hfs.type"), "hfs.creator");
202
203	return HFSPLUS_ATTRLIST_SIZE;
204	}