[linux.git] / fs / hfsplus / ioctl.c

/*
 *  linux/fs/hfsplus/ioctl.c
 *
 * Copyright (C) 2003
 * Ethan Benson <[email protected]>
 * partially derived from linux/fs/ext2/ioctl.c
 * Copyright (C) 1993, 1994, 1995
 * Remy Card ([email protected])
 * 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 <asm/uaccess.h>
#include "hfsplus_fs.h"

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