1/*
  2 *  linux/fs/hfs/attr.c
  3 *
  4 * (C) 2003 Ardis Technologies <roman@ardistech.com>
  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
 16enum hfs_xattr_type {
 17	HFS_TYPE,
 18	HFS_CREATOR,
 19};
 20
 21static int __hfs_setxattr(struct inode *inode, enum hfs_xattr_type type,
 22			  const void *value, size_t size, int flags)
 23{
 
 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
 43	switch (type) {
 44	case HFS_TYPE:
 45		if (size == 4)
 46			memcpy(&file->UsrWds.fdType, value, 4);
 47		else
 48			res = -ERANGE;
 49		break;
 50
 51	case HFS_CREATOR:
 52		if (size == 4)
 53			memcpy(&file->UsrWds.fdCreator, value, 4);
 54		else
 55			res = -ERANGE;
 56		break;
 57	}
 58
 59	if (!res)
 60		hfs_bnode_write(fd.bnode, &rec, fd.entryoffset,
 61				sizeof(struct hfs_cat_file));
 62out:
 63	hfs_find_exit(&fd);
 64	return res;
 65}
 66
 67static ssize_t __hfs_getxattr(struct inode *inode, enum hfs_xattr_type type,
 68			      void *value, size_t size)
 69{
 
 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
 91	switch (type) {
 92	case HFS_TYPE:
 93		if (size >= 4) {
 94			memcpy(value, &file->UsrWds.fdType, 4);
 95			res = 4;
 96		} else
 97			res = size ? -ERANGE : 4;
 98		break;
 99
100	case HFS_CREATOR:
101		if (size >= 4) {
102			memcpy(value, &file->UsrWds.fdCreator, 4);
103			res = 4;
104		} else
105			res = size ? -ERANGE : 4;
106		break;
107	}
108
109out:
110	if (size)
111		hfs_find_exit(&fd);
112	return res;
113}
114
115static 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)
118{
119	return __hfs_getxattr(inode, handler->flags, value, size);
120}
121
122static 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)
 
 
128		return -EOPNOTSUPP;
129
130	return __hfs_setxattr(inode, handler->flags, value, size, flags);
131}
 
 
 
 
132
133static 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
140static 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
147const struct xattr_handler *hfs_xattr_handlers[] = {
148	&hfs_creator_handler,
149	&hfs_type_handler,
150	NULL
151};

  1/*
  2 *  linux/fs/hfs/attr.c
  3 *
  4 * (C) 2003 Ardis Technologies <roman@ardistech.com>
  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
 16int hfs_setxattr(struct dentry *dentry, const char *name,
 17		 const void *value, size_t size, int flags)
 
 
 
 
 
 18{
 19	struct inode *inode = dentry->d_inode;
 20	struct hfs_find_data fd;
 21	hfs_cat_rec rec;
 22	struct hfs_cat_file *file;
 23	int res;
 24
 25	if (!S_ISREG(inode->i_mode) || HFS_IS_RSRC(inode))
 26		return -EOPNOTSUPP;
 27
 28	res = hfs_find_init(HFS_SB(inode->i_sb)->cat_tree, &fd);
 29	if (res)
 30		return res;
 31	fd.search_key->cat = HFS_I(inode)->cat_key;
 32	res = hfs_brec_find(&fd);
 33	if (res)
 34		goto out;
 35	hfs_bnode_read(fd.bnode, &rec, fd.entryoffset,
 36			sizeof(struct hfs_cat_file));
 37	file = &rec.file;
 38
 39	if (!strcmp(name, "hfs.type")) {
 
 40		if (size == 4)
 41			memcpy(&file->UsrWds.fdType, value, 4);
 42		else
 43			res = -ERANGE;
 44	} else if (!strcmp(name, "hfs.creator")) {
 
 
 45		if (size == 4)
 46			memcpy(&file->UsrWds.fdCreator, value, 4);
 47		else
 48			res = -ERANGE;
 49	} else
 50		res = -EOPNOTSUPP;
 
 51	if (!res)
 52		hfs_bnode_write(fd.bnode, &rec, fd.entryoffset,
 53				sizeof(struct hfs_cat_file));
 54out:
 55	hfs_find_exit(&fd);
 56	return res;
 57}
 58
 59ssize_t hfs_getxattr(struct dentry *dentry, const char *name,
 60			 void *value, size_t size)
 61{
 62	struct inode *inode = dentry->d_inode;
 63	struct hfs_find_data fd;
 64	hfs_cat_rec rec;
 65	struct hfs_cat_file *file;
 66	ssize_t res = 0;
 67
 68	if (!S_ISREG(inode->i_mode) || HFS_IS_RSRC(inode))
 69		return -EOPNOTSUPP;
 70
 71	if (size) {
 72		res = hfs_find_init(HFS_SB(inode->i_sb)->cat_tree, &fd);
 73		if (res)
 74			return res;
 75		fd.search_key->cat = HFS_I(inode)->cat_key;
 76		res = hfs_brec_find(&fd);
 77		if (res)
 78			goto out;
 79		hfs_bnode_read(fd.bnode, &rec, fd.entryoffset,
 80				sizeof(struct hfs_cat_file));
 81	}
 82	file = &rec.file;
 83
 84	if (!strcmp(name, "hfs.type")) {
 
 85		if (size >= 4) {
 86			memcpy(value, &file->UsrWds.fdType, 4);
 87			res = 4;
 88		} else
 89			res = size ? -ERANGE : 4;
 90	} else if (!strcmp(name, "hfs.creator")) {
 
 
 91		if (size >= 4) {
 92			memcpy(value, &file->UsrWds.fdCreator, 4);
 93			res = 4;
 94		} else
 95			res = size ? -ERANGE : 4;
 96	} else
 97		res = -ENODATA;
 
 98out:
 99	if (size)
100		hfs_find_exit(&fd);
101	return res;
102}
103
104#define HFS_ATTRLIST_SIZE (sizeof("hfs.creator")+sizeof("hfs.type"))
 
 
 
 
 
105
106ssize_t hfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
 
 
 
107{
108	struct inode *inode = dentry->d_inode;
109
110	if (!S_ISREG(inode->i_mode) || HFS_IS_RSRC(inode))
111		return -EOPNOTSUPP;
112
113	if (!buffer || !size)
114		return HFS_ATTRLIST_SIZE;
115	if (size < HFS_ATTRLIST_SIZE)
116		return -ERANGE;
117	strcpy(buffer, "hfs.type");
118	strcpy(buffer + sizeof("hfs.type"), "hfs.creator");
119
120	return HFS_ATTRLIST_SIZE;
121}