[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"

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));
		hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
	}
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 <[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
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;
596276c3	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;
e3494705	150	if (!res) {
1da177e4 LT	151	hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
1da177e4 LT	152	sizeof(struct hfsplus_cat_file));
e3494705 CH	153	hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);
e3494705 CH	154	}
1da177e4 LT	155	out:
	156	hfs_find_exit(&fd);
	157	return res;
	158	}
	159
	160	ssize_t hfsplus_getxattr(struct dentry dentry, const char name,
	161	void *value, size_t size)
	162	{
	163	struct inode *inode = dentry->d_inode;
	164	struct hfs_find_data fd;
	165	hfsplus_cat_entry entry;
	166	struct hfsplus_cat_file *file;
	167	ssize_t res = 0;
	168
	169	if (!S_ISREG(inode->i_mode) \|\| HFSPLUS_IS_RSRC(inode))
	170	return -EOPNOTSUPP;
	171
	172	if (size) {
dd73a01a	173	res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);
1da177e4 LT	174	if (res)
	175	return res;
	176	res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);
	177	if (res)
	178	goto out;
	179	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
	180	sizeof(struct hfsplus_cat_file));
	181	}
	182	file = &entry.file;
	183
	184	if (!strcmp(name, "hfs.type")) {
	185	if (size >= 4) {
	186	memcpy(value, &file->user_info.fdType, 4);
	187	res = 4;
	188	} else
	189	res = size ? -ERANGE : 4;
	190	} else if (!strcmp(name, "hfs.creator")) {
	191	if (size >= 4) {
	192	memcpy(value, &file->user_info.fdCreator, 4);
	193	res = 4;
	194	} else
	195	res = size ? -ERANGE : 4;
	196	} else
46bf36ec	197	res = -EOPNOTSUPP;
1da177e4 LT	198	out:
	199	if (size)
	200	hfs_find_exit(&fd);
	201	return res;
	202	}
	203
	204	#define HFSPLUS_ATTRLIST_SIZE (sizeof("hfs.creator")+sizeof("hfs.type"))
	205
	206	ssize_t hfsplus_listxattr(struct dentry dentry, char buffer, size_t size)
	207	{
	208	struct inode *inode = dentry->d_inode;
	209
	210	if (!S_ISREG(inode->i_mode) \|\| HFSPLUS_IS_RSRC(inode))
	211	return -EOPNOTSUPP;
	212
	213	if (!buffer \|\| !size)
	214	return HFSPLUS_ATTRLIST_SIZE;
	215	if (size < HFSPLUS_ATTRLIST_SIZE)
	216	return -ERANGE;
	217	strcpy(buffer, "hfs.type");
	218	strcpy(buffer + sizeof("hfs.type"), "hfs.creator");
	219
	220	return HFSPLUS_ATTRLIST_SIZE;
	221	}