[linux.git] / fs / hfs / attr.c

/*
 *  linux/fs/hfs/attr.c
 *
 * (C) 2003 Ardis Technologies <[email protected]>
 *
 * Export hfs data via xattr
 */


#include <linux/fs.h>
#include <linux/xattr.h>

#include "hfs_fs.h"
#include "btree.h"

enum hfs_xattr_type {
	HFS_TYPE,
	HFS_CREATOR,
};

static int __hfs_setxattr(struct inode *inode, enum hfs_xattr_type type,
			  const void *value, size_t size, int flags)
{
	struct hfs_find_data fd;
	hfs_cat_rec rec;
	struct hfs_cat_file *file;
	int res;

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

	res = hfs_find_init(HFS_SB(inode->i_sb)->cat_tree, &fd);
	if (res)
		return res;
	fd.search_key->cat = HFS_I(inode)->cat_key;
	res = hfs_brec_find(&fd);
	if (res)
		goto out;
	hfs_bnode_read(fd.bnode, &rec, fd.entryoffset,
			sizeof(struct hfs_cat_file));
	file = &rec.file;

	switch (type) {
	case HFS_TYPE:
		if (size == 4)
			memcpy(&file->UsrWds.fdType, value, 4);
		else
			res = -ERANGE;
		break;

	case HFS_CREATOR:
		if (size == 4)
			memcpy(&file->UsrWds.fdCreator, value, 4);
		else
			res = -ERANGE;
		break;
	}

	if (!res)
		hfs_bnode_write(fd.bnode, &rec, fd.entryoffset,
				sizeof(struct hfs_cat_file));
out:
	hfs_find_exit(&fd);
	return res;
}

static ssize_t __hfs_getxattr(struct inode *inode, enum hfs_xattr_type type,
			      void *value, size_t size)
{
	struct hfs_find_data fd;
	hfs_cat_rec rec;
	struct hfs_cat_file *file;
	ssize_t res = 0;

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

	if (size) {
		res = hfs_find_init(HFS_SB(inode->i_sb)->cat_tree, &fd);
		if (res)
			return res;
		fd.search_key->cat = HFS_I(inode)->cat_key;
		res = hfs_brec_find(&fd);
		if (res)
			goto out;
		hfs_bnode_read(fd.bnode, &rec, fd.entryoffset,
				sizeof(struct hfs_cat_file));
	}
	file = &rec.file;

	switch (type) {
	case HFS_TYPE:
		if (size >= 4) {
			memcpy(value, &file->UsrWds.fdType, 4);
			res = 4;
		} else
			res = size ? -ERANGE : 4;
		break;

	case HFS_CREATOR:
		if (size >= 4) {
			memcpy(value, &file->UsrWds.fdCreator, 4);
			res = 4;
		} else
			res = size ? -ERANGE : 4;
		break;
	}

out:
	if (size)
		hfs_find_exit(&fd);
	return res;
}

static int hfs_xattr_get(const struct xattr_handler *handler,
			 struct dentry *unused, struct inode *inode,
			 const char *name, void *value, size_t size)
{
	return __hfs_getxattr(inode, handler->flags, value, size);
}

static int hfs_xattr_set(const struct xattr_handler *handler,
			 struct dentry *unused, struct inode *inode,
			 const char *name, const void *value, size_t size,
			 int flags)
{
	if (!value)
		return -EOPNOTSUPP;

	return __hfs_setxattr(inode, handler->flags, value, size, flags);
}

static const struct xattr_handler hfs_creator_handler = {
	.name = "hfs.creator",
	.flags = HFS_CREATOR,
	.get = hfs_xattr_get,
	.set = hfs_xattr_set,
};

static const struct xattr_handler hfs_type_handler = {
	.name = "hfs.type",
	.flags = HFS_TYPE,
	.get = hfs_xattr_get,
	.set = hfs_xattr_set,
};

const struct xattr_handler *hfs_xattr_handlers[] = {
	&hfs_creator_handler,
	&hfs_type_handler,
	NULL
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/hfs/attr.c
	3	*
	4	* (C) 2003 Ardis Technologies <[email protected]>
	5	*
	6	* Export hfs data via xattr
	7	*/
	8
	9
	10	#include <linux/fs.h>
	11	#include <linux/xattr.h>
	12
	13	#include "hfs_fs.h"
	14	#include "btree.h"
	15
b8020eff AG	16	enum hfs_xattr_type {
	17	HFS_TYPE,
	18	HFS_CREATOR,
	19	};
	20
	21	static int __hfs_setxattr(struct inode *inode, enum hfs_xattr_type type,
	22	const void *value, size_t size, int flags)
1da177e4	23	{
1da177e4 LT	24	struct hfs_find_data fd;
	25	hfs_cat_rec rec;
	26	struct hfs_cat_file *file;
	27	int res;
	28
	29	if (!S_ISREG(inode->i_mode) \|\| HFS_IS_RSRC(inode))
	30	return -EOPNOTSUPP;
	31
	32	res = hfs_find_init(HFS_SB(inode->i_sb)->cat_tree, &fd);
	33	if (res)
	34	return res;
	35	fd.search_key->cat = HFS_I(inode)->cat_key;
	36	res = hfs_brec_find(&fd);
	37	if (res)
	38	goto out;
	39	hfs_bnode_read(fd.bnode, &rec, fd.entryoffset,
	40	sizeof(struct hfs_cat_file));
	41	file = &rec.file;
	42
b8020eff AG	43	switch (type) {
b8020eff AG	44	case HFS_TYPE:
1da177e4 LT	45	if (size == 4)
	46	memcpy(&file->UsrWds.fdType, value, 4);
	47	else
	48	res = -ERANGE;
b8020eff AG	49	break;
	50
	51	case HFS_CREATOR:
1da177e4 LT	52	if (size == 4)
	53	memcpy(&file->UsrWds.fdCreator, value, 4);
	54	else
	55	res = -ERANGE;
b8020eff AG	56	break;
	57	}
	58
1da177e4 LT	59	if (!res)
	60	hfs_bnode_write(fd.bnode, &rec, fd.entryoffset,
	61	sizeof(struct hfs_cat_file));
	62	out:
	63	hfs_find_exit(&fd);
	64	return res;
	65	}
	66
b8020eff AG	67	static ssize_t __hfs_getxattr(struct inode *inode, enum hfs_xattr_type type,
b8020eff AG	68	void *value, size_t size)
1da177e4	69	{
1da177e4 LT	70	struct hfs_find_data fd;
	71	hfs_cat_rec rec;
	72	struct hfs_cat_file *file;
	73	ssize_t res = 0;
	74
	75	if (!S_ISREG(inode->i_mode) \|\| HFS_IS_RSRC(inode))
	76	return -EOPNOTSUPP;
	77
	78	if (size) {
	79	res = hfs_find_init(HFS_SB(inode->i_sb)->cat_tree, &fd);
	80	if (res)
	81	return res;
	82	fd.search_key->cat = HFS_I(inode)->cat_key;
	83	res = hfs_brec_find(&fd);
	84	if (res)
	85	goto out;
	86	hfs_bnode_read(fd.bnode, &rec, fd.entryoffset,
	87	sizeof(struct hfs_cat_file));
	88	}
	89	file = &rec.file;
	90
b8020eff AG	91	switch (type) {
b8020eff AG	92	case HFS_TYPE:
1da177e4 LT	93	if (size >= 4) {
	94	memcpy(value, &file->UsrWds.fdType, 4);
	95	res = 4;
	96	} else
	97	res = size ? -ERANGE : 4;
b8020eff AG	98	break;
	99
	100	case HFS_CREATOR:
1da177e4 LT	101	if (size >= 4) {
	102	memcpy(value, &file->UsrWds.fdCreator, 4);
	103	res = 4;
	104	} else
	105	res = size ? -ERANGE : 4;
b8020eff AG	106	break;
	107	}
	108
1da177e4 LT	109	out:
	110	if (size)
	111	hfs_find_exit(&fd);
	112	return res;
	113	}
	114
b8020eff AG	115	static int hfs_xattr_get(const struct xattr_handler *handler,
	116	struct dentry unused, struct inode inode,
	117	const char name, void value, size_t size)
1da177e4	118	{
b8020eff AG	119	return __hfs_getxattr(inode, handler->flags, value, size);
b8020eff AG	120	}
1da177e4	121
b8020eff AG	122	static int hfs_xattr_set(const struct xattr_handler *handler,
	123	struct dentry unused, struct inode inode,
	124	const char name, const void value, size_t size,
	125	int flags)
	126	{
	127	if (!value)
1da177e4 LT	128	return -EOPNOTSUPP;
1da177e4 LT	129
b8020eff	130	return __hfs_setxattr(inode, handler->flags, value, size, flags);
1da177e4	131	}
b8020eff AG	132
	133	static const struct xattr_handler hfs_creator_handler = {
	134	.name = "hfs.creator",
	135	.flags = HFS_CREATOR,
	136	.get = hfs_xattr_get,
	137	.set = hfs_xattr_set,
	138	};
	139
	140	static const struct xattr_handler hfs_type_handler = {
	141	.name = "hfs.type",
	142	.flags = HFS_TYPE,
	143	.get = hfs_xattr_get,
	144	.set = hfs_xattr_set,
	145	};
	146
	147	const struct xattr_handler *hfs_xattr_handlers[] = {
	148	&hfs_creator_handler,
	149	&hfs_type_handler,
	150	NULL
	151	};