[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 <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;
	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
	unsigned int flags = 0;

	if (inode->i_flags & S_IMMUTABLE)
		flags |= FS_IMMUTABLE_FL;
	if (inode->i_flags |= S_APPEND)
		flags |= FS_APPEND_FL;
	if (hip->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;
	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
	unsigned int flags;
	int err = 0;

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

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

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

	mutex_lock(&inode->i_mutex);

	if ((flags & (FS_IMMUTABLE_FL|FS_APPEND_FL)) ||
	    inode->i_flags & (S_IMMUTABLE|S_APPEND)) {
		if (!capable(CAP_LINUX_IMMUTABLE)) {
			err = -EPERM;
			goto out_unlock_inode;
		}
	}

	/* don't silently ignore unsupported ext2 flags */
	if (flags & ~(FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NODUMP_FL)) {
		err = -EOPNOTSUPP;
		goto out_unlock_inode;
	}

	if (flags & FS_IMMUTABLE_FL)
		inode->i_flags |= S_IMMUTABLE;
	else
		inode->i_flags &= ~S_IMMUTABLE;

	if (flags & FS_APPEND_FL)
		inode->i_flags |= S_APPEND;
	else
		inode->i_flags &= ~S_APPEND;

	if (flags & FS_NODUMP_FL)
		hip->userflags |= HFSPLUS_FLG_NODUMP;
	else
		hip->userflags &= ~HFSPLUS_FLG_NODUMP;

	inode->i_ctime = CURRENT_TIME_SEC;
	mark_inode_dirty(inode);

out_unlock_inode:
	mutex_unlock(&inode->i_mutex);
out_drop_write:
	mnt_drop_write(file->f_path.mnt);
out:
	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 = -EOPNOTSUPP;
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>
	19	#include <linux/xattr.h>
	20	#include <asm/uaccess.h>
	21	#include "hfsplus_fs.h"
	22
94744567	23	static int hfsplus_ioctl_getflags(struct file file, int __user user_flags)
1da177e4	24	{
94744567	25	struct inode *inode = file->f_path.dentry->d_inode;
6af502de	26	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
94744567 CH	27	unsigned int flags = 0;
94744567 CH	28
722c55d1	29	if (inode->i_flags & S_IMMUTABLE)
94744567	30	flags \|= FS_IMMUTABLE_FL;
722c55d1	31	if (inode->i_flags \|= S_APPEND)
94744567	32	flags \|= FS_APPEND_FL;
6af502de	33	if (hip->userflags & HFSPLUS_FLG_NODUMP)
94744567 CH	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;
6af502de	42	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
1da177e4	43	unsigned int flags;
94744567	44	int err = 0;
1da177e4	45
94744567 CH	46	err = mnt_want_write(file->f_path.mnt);
94744567 CH	47	if (err)
6333816a	48	goto out;
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
6333816a CH	60	mutex_lock(&inode->i_mutex);
6333816a CH	61
722c55d1 CH	62	if ((flags & (FS_IMMUTABLE_FL\|FS_APPEND_FL)) \|\|
722c55d1 CH	63	inode->i_flags & (S_IMMUTABLE\|S_APPEND)) {
94744567 CH	64	if (!capable(CAP_LINUX_IMMUTABLE)) {
94744567 CH	65	err = -EPERM;
6333816a	66	goto out_unlock_inode;
1da177e4	67	}
1da177e4	68	}
94744567 CH	69
	70	/* don't silently ignore unsupported ext2 flags */
	71	if (flags & ~(FS_IMMUTABLE_FL\|FS_APPEND_FL\|FS_NODUMP_FL)) {
	72	err = -EOPNOTSUPP;
6333816a	73	goto out_unlock_inode;
94744567	74	}
722c55d1 CH	75
722c55d1 CH	76	if (flags & FS_IMMUTABLE_FL)
94744567	77	inode->i_flags \|= S_IMMUTABLE;
722c55d1	78	else
94744567	79	inode->i_flags &= ~S_IMMUTABLE;
722c55d1 CH	80
722c55d1 CH	81	if (flags & FS_APPEND_FL)
94744567	82	inode->i_flags \|= S_APPEND;
722c55d1	83	else
94744567	84	inode->i_flags &= ~S_APPEND;
722c55d1	85
94744567	86	if (flags & FS_NODUMP_FL)
6af502de	87	hip->userflags \|= HFSPLUS_FLG_NODUMP;
94744567	88	else
6af502de	89	hip->userflags &= ~HFSPLUS_FLG_NODUMP;
94744567 CH	90
	91	inode->i_ctime = CURRENT_TIME_SEC;
	92	mark_inode_dirty(inode);
	93
6333816a	94	out_unlock_inode:
e50fb58b	95	mutex_unlock(&inode->i_mutex);
94744567 CH	96	out_drop_write:
94744567 CH	97	mnt_drop_write(file->f_path.mnt);
6333816a	98	out:
94744567 CH	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
dd73a01a	128	res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
1da177e4 LT	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) {
dd73a01a	171	res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
1da177e4 LT	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
46bf36ec	195	res = -EOPNOTSUPP;
1da177e4 LT	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	}