/*
 * 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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <errno.h>
#include <unistd.h>
#include <strings.h>
#include <sys/fs_reparse.h>
#include <smbsrv/libsmb.h>

#include <syslog.h>

static int smb_reparse_init(const char *, nvlist_t **);
static void smb_reparse_free(nvlist_t *);
static int smb_reparse_set(const char *, nvlist_t *);

/*
 * Checks the status of the object specified by 'path'
 *
 * Returns 0 and fills 'stat' with the proper status on
 * success, otherwise returns an error code.
 */
int
smb_reparse_stat(const char *path, uint32_t *stat)
{
        struct stat statbuf;
        char symbuf[MAXREPARSELEN];
        int rptaglen;

        if (lstat(path, &statbuf) != 0) {
                if (errno == ENOENT) {
                        *stat = SMB_REPARSE_NOTFOUND;
                        return (0);
                }
                return (errno);
        }

        if ((statbuf.st_mode & S_IFMT) != S_IFLNK) {
                *stat = SMB_REPARSE_NOTREPARSE;
                return (0);
        }

        bzero(symbuf, MAXREPARSELEN);
        if (readlink(path, symbuf, MAXREPARSELEN) == -1)
                return (errno);

        rptaglen = strlen(FS_REPARSE_TAG_STR);
        if (strncmp(symbuf, FS_REPARSE_TAG_STR, rptaglen) != 0)
                *stat = SMB_REPARSE_NOTREPARSE;
        else
                *stat = SMB_REPARSE_ISREPARSE;

        return (0);
}

/*
 * If the reparse point specified by the path already exists
 * it is updated by given service type and its data. Update means
 * that if such service type does not already exist, it is added
 * otherwise it is overwritten by given data.
 *
 * If the reparse point does not exist, one is created with given
 * service type and its data.
 */
int
smb_reparse_svcadd(const char *path, const char *svctype, const char *svcdata)
{
        nvlist_t *nvl;
        int rc;

        if ((rc = smb_reparse_init(path, &nvl)) != 0)
                return (rc);

        if ((rc = reparse_add(nvl, svctype, svcdata)) != 0) {
                smb_reparse_free(nvl);
                return (rc);
        }

        rc = smb_reparse_set(path, nvl);
        smb_reparse_free(nvl);

        return (rc);
}

/*
 * Removes the entry for the given service type from the
 * specified reparse point. If there is no service entry
 * left, the reparse point object will be deleted.
 */
int
smb_reparse_svcdel(const char *path, const char *svctype)
{
        nvlist_t *nvl;
        int rc;

        if ((rc = smb_reparse_init(path, &nvl)) != 0)
                return (rc);

        if ((rc = reparse_remove(nvl, svctype)) != 0) {
                smb_reparse_free(nvl);
                return (rc);
        }

        if (nvlist_next_nvpair(nvl, NULL) == NULL) {
                /* list is empty remove the object */
                rc = reparse_delete(path);
                if ((rc != 0) && (rc == ENOENT))
                        rc = 0;
        } else {
                rc = smb_reparse_set(path, nvl);
        }

        smb_reparse_free(nvl);
        return (rc);
}

/*
 * Obtains data of the given service type from the specified
 * reparse point. Function allocates the memory needed to hold
 * the service data so the caller must free this memory by
 * calling free().
 *
 * If 'svcdata' is NULL, successful return means that the reparse
 * point contains a record for the given service type.
 */
int
smb_reparse_svcget(const char *path, const char *svctype, char **svcdata)
{
        nvlist_t *nvl;
        nvpair_t *nvp;
        char *stype, *sdata;
        int rc;

        if ((rc = smb_reparse_init(path, &nvl)) != 0)
                return (rc);

        rc = ENODATA;
        nvp = nvlist_next_nvpair(nvl, NULL);

        while (nvp != NULL) {
                stype = nvpair_name(nvp);

                if ((stype != NULL) && (strcasecmp(stype, svctype) == 0)) {
                        if ((rc = nvpair_value_string(nvp, &sdata)) != 0)
                                break;

                        if (svcdata != NULL) {
                                if ((*svcdata = strdup(sdata)) == NULL)
                                        rc = ENOMEM;
                        }

                        rc = 0;
                        break;
                }
                nvp = nvlist_next_nvpair(nvl, nvp);
        }

        smb_reparse_free(nvl);
        return (rc);
}

/*
 * Initializes the given nvpair list.
 *
 * This function assumes that the object specified by this path
 * is a reparse point, so it does not do any verification.
 *
 * If specified reparse point does not exist the function
 * returns successfully with an empty nvpair list.
 *
 * If the object exists and readlink is successful then nvpair
 * list is polulated with the reparse service information, otherwise
 * an error code is returned.
 */
static int
smb_reparse_init(const char *path, nvlist_t **nvl)
{
        char rp_data[MAXREPARSELEN];
        int rc;

        if ((*nvl = reparse_init()) == NULL)
                return (ENOMEM);

        bzero(rp_data, MAXREPARSELEN);
        if ((rc = readlink(path, rp_data, MAXREPARSELEN)) == -1) {
                if (errno == ENOENT)
                        return (0);

                reparse_free(*nvl);
                return (errno);
        }

        if ((rc = reparse_parse(rp_data, *nvl)) != 0) {
                reparse_free(*nvl);
                return (rc);
        }

        return (0);
}

/*
 * Frees given nvlist
 */
static void
smb_reparse_free(nvlist_t *nvl)
{
        reparse_free(nvl);
}

/*
 * Create a reparse point with given services in the passed
 * nvlist. If the reparse point already exists, it will be
 * deleted and a new one with the given data is created.
 */
static int
smb_reparse_set(const char *path, nvlist_t *nvl)
{
        char *rp_data;
        int rc;

        if ((rc = reparse_unparse(nvl, &rp_data)) != 0)
                return (rc);

        rc = reparse_delete(path);
        if ((rc != 0) && (rc != ENOENT)) {
                free(rp_data);
                return (rc);
        }

        rc = reparse_create(path, rp_data);
        free(rp_data);

        return (rc);
}