[deliverable/linux.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"

static int hfsplus_ioctl_getflags(struct file *file, int __user *user_flags)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	unsigned int flags = 0;

	if (HFSPLUS_I(inode).rootflags & HFSPLUS_FLG_IMMUTABLE)
		flags |= FS_IMMUTABLE_FL;
	if (HFSPLUS_I(inode).rootflags & HFSPLUS_FLG_APPEND)
		flags |= FS_APPEND_FL;
	if (HFSPLUS_I(inode).userflags & HFSPLUS_FLG_NODUMP)
		flags |= FS_NODUMP_FL;

	return put_user(flags, user_flags);
}

static int hfsplus_ioctl_setflags(struct file *file, int __user *user_flags)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	unsigned int flags;
	int err = 0;

	lock_kernel();
	err = mnt_want_write(file->f_path.mnt);
	if (err)
		goto out_unlock_kernel;

	if (!is_owner_or_cap(inode)) {
		err = -EACCES;
		goto out_drop_write;
	}

	if (get_user(flags, user_flags)) {
		err = -EFAULT;
		goto out_drop_write;
	}

	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 out_drop_write;
		}
	}

	/* don't silently ignore unsupported ext2 flags */
	if (flags & ~(FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NODUMP_FL)) {
		err = -EOPNOTSUPP;
		goto out_drop_write;
	}
	if (flags & FS_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) {
		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)
		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);

out_drop_write:
	mnt_drop_write(file->f_path.mnt);
out_unlock_kernel:
	unlock_kernel();
	return err;
}

long hfsplus_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	void __user *argp = (void __user *)arg;

	switch (cmd) {
	case HFSPLUS_IOC_EXT2_GETFLAGS:
		return hfsplus_ioctl_getflags(file, argp);
	case HFSPLUS_IOC_EXT2_SETFLAGS:
		return hfsplus_ioctl_setflags(file, argp);
	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
94744567	24	static int hfsplus_ioctl_getflags(struct file file, int __user user_flags)
1da177e4	25	{
94744567 CH	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;
1da177e4	42	unsigned int flags;
94744567	43	int err = 0;
1da177e4	44
94744567 CH	45	lock_kernel();
	46	err = mnt_want_write(file->f_path.mnt);
	47	if (err)
	48	goto out_unlock_kernel;
1da177e4	49
94744567 CH	50	if (!is_owner_or_cap(inode)) {
	51	err = -EACCES;
	52	goto out_drop_write;
	53	}
1da177e4	54
94744567 CH	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;
1da177e4	65	}
1da177e4	66	}
94744567 CH	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);
1da177e4 LT	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	}