// SPDX-License-Identifier: GPL-2.0
/*
 *  linux/fs/hfs/attr.c
 *
 * (C) 2003 Ardis Technologies <roman@ardistech.com>
 *
 * 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 mnt_idmap *idmap,
                         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 * const hfs_xattr_handlers[] = {
        &hfs_creator_handler,
        &hfs_type_handler,
        NULL
};