/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
 * Copyright 2024 RackTop Systems, Inc.
 */

#include <sys/types.h>
#include <sys/vnode.h>
#include <sys/debug.h>

#include <attr.h>
#include <libnvpair.h>

#include "vncache.h"

static uint64_t zero_times[2];

static int
getxva_parse_nvl(xvattr_t *xvap,
    xoptattr_t *xoap, nvlist_t *nvl);

/*
 * See similar code to parse the nvlist in:
 * uts/common/fs/xattr.c : xattr_file_write()
 */
int
fop__getxvattr(vnode_t *vp, xvattr_t *xvap)
{
        nvlist_t *nvl = NULL;
        xoptattr_t *xoap = NULL;
        int fd = vncache_getfd(vp);
        int error;

        if ((xoap = xva_getxoptattr(xvap)) == NULL) {
                return (EINVAL);
        }

        error = fgetattr(fd, XATTR_VIEW_READWRITE, &nvl);
        if (error == 0) {
                error = getxva_parse_nvl(xvap, xoap, nvl);
                nvlist_free(nvl);
                nvl = NULL;
        }

        /*
         * Also get the readonly attrs, but don't fail.
         */
        if (fgetattr(fd, XATTR_VIEW_READONLY, &nvl) == 0) {
                (void) getxva_parse_nvl(xvap, xoap, nvl);
                nvlist_free(nvl);
        }

        return (error);
}

static int
getxva_parse_nvl(xvattr_t *xvap,
    xoptattr_t *xoap, nvlist_t *nvl)
{
        nvpair_t *pair = NULL;
        int error;

        while ((pair = nvlist_next_nvpair(nvl, pair)) != NULL) {
                data_type_t type;
                f_attr_t attr;
                boolean_t value = B_FALSE;
                uint64_t *times = zero_times;
                uint_t nelems = 2;

                /*
                 * Validate the name and type of each attribute.
                 * Log any unknown names and continue.  This will
                 * help if additional attributes are added later.
                 */
                type = nvpair_type(pair);
                attr = name_to_attr(nvpair_name(pair));
                if (attr == F_ATTR_INVAL)
                        continue;

                /*
                 * Verify nvlist type matches required type and view is OK
                 */

                if (type != attr_to_data_type(attr) ||
                    (attr_to_xattr_view(attr) == XATTR_VIEW_READONLY))
                        continue;

                /*
                 * For OWNERSID/GROUPSID, just skip.
                 */
                if ((attr == F_OWNERSID || attr == F_GROUPSID))
                        continue;

                /*
                 * Retrieve data from nvpair
                 */
                switch (type) {
                case DATA_TYPE_BOOLEAN_VALUE:
                        if (nvpair_value_boolean_value(pair, &value)) {
                                error = EINVAL;
                                goto out;
                        }
                        break;

                case DATA_TYPE_UINT64_ARRAY:
                        if (nvpair_value_uint64_array(pair, &times, &nelems)) {
                                error = EINVAL;
                                goto out;
                        }
                        if (nelems < 2)
                                continue;
                        break;

                case DATA_TYPE_NVLIST:
                        continue;

                case DATA_TYPE_UINT8_ARRAY:
                        continue;

                default:
                        error = EINVAL;
                        goto out;
                }

                switch (attr) {
                /*
                 * If we have several similar optional attributes to
                 * process then we should do it all together here so that
                 * xoap and the requested bitmap can be set in one place.
                 */
                case F_READONLY:
                        XVA_SET_RTN(xvap, XAT_READONLY);
                        xoap->xoa_readonly = value;
                        break;

                case F_HIDDEN:
                        XVA_SET_RTN(xvap, XAT_HIDDEN);
                        xoap->xoa_hidden = value;
                        break;

                case F_SYSTEM:
                        XVA_SET_RTN(xvap, XAT_SYSTEM);
                        xoap->xoa_system = value;
                        break;

                case F_ARCHIVE:
                        XVA_SET_RTN(xvap, XAT_ARCHIVE);
                        xoap->xoa_archive = value;
                        break;

                case F_CRTIME:
                        XVA_SET_RTN(xvap, XAT_CREATETIME);
                        xoap->xoa_createtime.tv_sec = times[0];
                        xoap->xoa_createtime.tv_nsec = times[1];
                        break;

                case F_REPARSE:
                        XVA_SET_RTN(xvap, XAT_REPARSE);
                        xoap->xoa_reparse = value;
                        break;

                case F_OFFLINE:
                        XVA_SET_RTN(xvap, XAT_OFFLINE);
                        xoap->xoa_offline = value;
                        break;

                case F_SPARSE:
                        XVA_SET_RTN(xvap, XAT_SPARSE);
                        xoap->xoa_sparse = value;
                        break;

                default:
                        break;
                }
        }
        error = 0;

out:
        return (error);
}

/*
 * See similar code to build the nvlist in:
 * uts/common/fs/xattr.c : xattr_fill_nvlist()
 */
int
fop__setxvattr(vnode_t *vp, xvattr_t *xvap)
{
        uint64_t times[2];
        nvlist_t *nvl;
        xoptattr_t *xoap;       /* Pointer to optional attributes */
        int fd = vncache_getfd(vp);
        int error;

        if ((xoap = xva_getxoptattr(xvap)) == NULL)
                return (EINVAL);

        if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP))
                return (ENOMEM);

        if (XVA_ISSET_REQ(xvap, XAT_READONLY)) {
                VERIFY(nvlist_add_boolean_value(nvl,
                    attr_to_name(F_READONLY),
                    xoap->xoa_readonly) == 0);
        }

        if (XVA_ISSET_REQ(xvap, XAT_HIDDEN)) {
                VERIFY(nvlist_add_boolean_value(nvl,
                    attr_to_name(F_HIDDEN),
                    xoap->xoa_hidden) == 0);
        }

        if (XVA_ISSET_REQ(xvap, XAT_SYSTEM)) {
                VERIFY(nvlist_add_boolean_value(nvl,
                    attr_to_name(F_SYSTEM),
                    xoap->xoa_system) == 0);
        }

        if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE)) {
                VERIFY(nvlist_add_boolean_value(nvl,
                    attr_to_name(F_ARCHIVE),
                    xoap->xoa_archive) == 0);
        }

        if (XVA_ISSET_REQ(xvap, XAT_CREATETIME)) {
                times[0] = xoap->xoa_createtime.tv_sec;
                times[1] = xoap->xoa_createtime.tv_nsec;
                VERIFY(nvlist_add_uint64_array(nvl,
                    attr_to_name(F_CRTIME),
                    times, 2) == 0);
        }

        if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) {
                VERIFY(nvlist_add_boolean_value(nvl,
                    attr_to_name(F_REPARSE),
                    xoap->xoa_reparse) == 0);
        }

        if (XVA_ISSET_REQ(xvap, XAT_OFFLINE)) {
                VERIFY(nvlist_add_boolean_value(nvl,
                    attr_to_name(F_OFFLINE),
                    xoap->xoa_offline) == 0);
        }

        if (XVA_ISSET_REQ(xvap, XAT_SPARSE)) {
                VERIFY(nvlist_add_boolean_value(nvl,
                    attr_to_name(F_SPARSE),
                    xoap->xoa_sparse) == 0);
        }

        error = fsetattr(fd, XATTR_VIEW_READWRITE, nvl);

        nvlist_free(nvl);

        return (error);
}