dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / cmd / smbsrv / smbd / smbd_doorsvc.c

/*
 * 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.
 */

#include <sys/list.h>
#include <assert.h>
#include <alloca.h>
#include <door.h>
#include <errno.h>
#include <syslog.h>
#include <unistd.h>
#include <stdio.h>
#include <synch.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <strings.h>
#include <note.h>
#include <smbsrv/smb_door.h>
#include <smbsrv/smb_xdr.h>
#include <smbsrv/smb_token.h>
#include <smbsrv/libmlsvc.h>
#include <smbsrv/libsmbns.h>
#include "smbd.h"

/*
 * The list contains asynchronous requests that have been initiated
 * but have not yet been collected (via smbd_dop_async_response).
 */
typedef struct smbd_doorsvc {
        mutex_t         sd_mutex;
        cond_t          sd_cv;
        list_t          sd_async_list;
        uint32_t        sd_async_count;
} smbd_doorsvc_t;

static int smbd_dop_null(smbd_arg_t *);
static int smbd_dop_async_response(smbd_arg_t *);
static int smbd_dop_user_auth_logon(smbd_arg_t *);
static int smbd_dop_user_nonauth_logon(smbd_arg_t *);
static int smbd_dop_user_auth_logoff(smbd_arg_t *);
static int smbd_dop_lookup_sid(smbd_arg_t *);
static int smbd_dop_lookup_name(smbd_arg_t *);
static int smbd_dop_join(smbd_arg_t *);
static int smbd_dop_get_dcinfo(smbd_arg_t *);
static int smbd_dop_vss_get_count(smbd_arg_t *);
static int smbd_dop_vss_get_snapshots(smbd_arg_t *);
static int smbd_dop_vss_map_gmttoken(smbd_arg_t *);
static int smbd_dop_ads_find_host(smbd_arg_t *);
static int smbd_dop_quota_query(smbd_arg_t *);
static int smbd_dop_quota_set(smbd_arg_t *);
static int smbd_dop_dfs_get_referrals(smbd_arg_t *);
static int smbd_dop_shr_hostaccess(smbd_arg_t *);
static int smbd_dop_shr_exec(smbd_arg_t *);
static int smbd_dop_notify_dc_changed(smbd_arg_t *);

typedef int (*smbd_dop_t)(smbd_arg_t *);

typedef struct smbd_doorop {
        smb_dopcode_t   opcode;
        smbd_dop_t      op;
} smbd_doorop_t;

smbd_doorop_t smbd_doorops[] = {
        { SMB_DR_NULL,                  smbd_dop_null },
        { SMB_DR_ASYNC_RESPONSE,        smbd_dop_async_response },
        { SMB_DR_USER_AUTH_LOGON,       smbd_dop_user_auth_logon },
        { SMB_DR_USER_NONAUTH_LOGON,    smbd_dop_user_nonauth_logon },
        { SMB_DR_USER_AUTH_LOGOFF,      smbd_dop_user_auth_logoff },
        { SMB_DR_LOOKUP_SID,            smbd_dop_lookup_sid },
        { SMB_DR_LOOKUP_NAME,           smbd_dop_lookup_name },
        { SMB_DR_JOIN,                  smbd_dop_join },
        { SMB_DR_GET_DCINFO,            smbd_dop_get_dcinfo },
        { SMB_DR_VSS_GET_COUNT,         smbd_dop_vss_get_count },
        { SMB_DR_VSS_GET_SNAPSHOTS,     smbd_dop_vss_get_snapshots },
        { SMB_DR_VSS_MAP_GMTTOKEN,      smbd_dop_vss_map_gmttoken },
        { SMB_DR_ADS_FIND_HOST,         smbd_dop_ads_find_host },
        { SMB_DR_QUOTA_QUERY,           smbd_dop_quota_query },
        { SMB_DR_QUOTA_SET,             smbd_dop_quota_set },
        { SMB_DR_DFS_GET_REFERRALS,     smbd_dop_dfs_get_referrals },
        { SMB_DR_SHR_HOSTACCESS,        smbd_dop_shr_hostaccess },
        { SMB_DR_SHR_EXEC,              smbd_dop_shr_exec },
        { SMB_DR_NOTIFY_DC_CHANGED,     smbd_dop_notify_dc_changed }
};

static int smbd_ndoorop = (sizeof (smbd_doorops) / sizeof (smbd_doorops[0]));

static smbd_doorsvc_t smbd_doorsvc;
static int smbd_door_fd = -1;
static int smbd_door_cookie = 0x534D4244;       /* SMBD */
static smbd_door_t smbd_door_sdh;
static char *smbd_door_name = NULL;

static void smbd_door_dispatch(void *, char *, size_t, door_desc_t *, uint_t);
static int smbd_door_dispatch_async(smbd_arg_t *);
static void smbd_door_release_async(smbd_arg_t *);

/*
 * Start the smbd door service.  Create and bind to a door.
 * Returns 0 on success. Otherwise, -1.
 */
int
smbd_door_start(void)
{
        int     newfd;

        (void) mutex_lock(&smbd_doorsvc.sd_mutex);

        if (smbd_door_fd != -1) {
                (void) fprintf(stderr, "smb_doorsrv_start: already started");
                (void) mutex_unlock(&smbd_doorsvc.sd_mutex);
                return (-1);
        }

        smbd_door_name = getenv("SMBD_DOOR_NAME");
        if (smbd_door_name == NULL)
                smbd_door_name = SMBD_DOOR_NAME;

        smbd_door_init(&smbd_door_sdh, "doorsrv");

        list_create(&smbd_doorsvc.sd_async_list, sizeof (smbd_arg_t),
            offsetof(smbd_arg_t, lnd));
        smbd_doorsvc.sd_async_count = 0;

        if ((smbd_door_fd = door_create(smbd_door_dispatch,
            &smbd_door_cookie, DOOR_UNREF)) < 0) {
                (void) fprintf(stderr, "smb_doorsrv_start: door_create: %s",
                    strerror(errno));
                smbd_door_fd = -1;
                (void) mutex_unlock(&smbd_doorsvc.sd_mutex);
                return (-1);
        }

        (void) unlink(smbd_door_name);

        if ((newfd = creat(smbd_door_name, 0644)) < 0) {
                (void) fprintf(stderr, "smb_doorsrv_start: open: %s",
                    strerror(errno));
                (void) door_revoke(smbd_door_fd);
                smbd_door_fd = -1;
                (void) mutex_unlock(&smbd_doorsvc.sd_mutex);
                return (-1);
        }

        (void) close(newfd);
        (void) fdetach(smbd_door_name);

        if (fattach(smbd_door_fd, smbd_door_name) < 0) {
                (void) fprintf(stderr, "smb_doorsrv_start: fattach: %s",
                    strerror(errno));
                (void) door_revoke(smbd_door_fd);
                smbd_door_fd = -1;
                (void) mutex_unlock(&smbd_doorsvc.sd_mutex);
                return (-1);
        }

        (void) mutex_unlock(&smbd_doorsvc.sd_mutex);
        return (smbd_door_fd);
}

/*
 * Stop the smbd door service.
 */
void
smbd_door_stop(void)
{
        (void) mutex_lock(&smbd_doorsvc.sd_mutex);

        smbd_door_fini(&smbd_door_sdh);

        if (smbd_door_name)
                (void) fdetach(smbd_door_name);

        if (smbd_door_fd != -1) {
                (void) door_revoke(smbd_door_fd);
                smbd_door_fd = -1;
        }

        (void) mutex_unlock(&smbd_doorsvc.sd_mutex);
}

/*ARGSUSED*/
static void
smbd_door_dispatch(void *cookie, char *argp, size_t arg_size, door_desc_t *dp,
    uint_t n_desc)
{
        smbd_arg_t      dop_arg;
        smb_doorhdr_t   *hdr;
        size_t          hdr_size;
        char            *rbuf = NULL;

        smbd_door_enter(&smbd_door_sdh);

        if (!smbd_online())
                smbd_door_return(&smbd_door_sdh, NULL, 0, NULL, 0);

        bzero(&dop_arg, sizeof (smbd_arg_t));
        hdr = &dop_arg.hdr;
        hdr_size = xdr_sizeof(smb_doorhdr_xdr, hdr);

        if ((cookie != &smbd_door_cookie) || (argp == NULL) ||
            (arg_size < hdr_size)) {
                smbd_door_return(&smbd_door_sdh, NULL, 0, NULL, 0);
        }

        if (smb_doorhdr_decode(hdr, (uint8_t *)argp, hdr_size) == -1) {
                syslog(LOG_DEBUG, "smbd_door_dispatch: header decode failed");
                smbd_door_return(&smbd_door_sdh, NULL, 0, NULL, 0);
        }

        if ((hdr->dh_magic != SMB_DOOR_HDR_MAGIC) || (hdr->dh_txid == 0)) {
                syslog(LOG_DEBUG, "smbd_door_dispatch: invalid header");
                smbd_door_return(&smbd_door_sdh, NULL, 0, NULL, 0);
        }

        dop_arg.opname = smb_doorhdr_opname(hdr->dh_op);
        dop_arg.data = argp + hdr_size;
        dop_arg.datalen = hdr->dh_datalen;

        if (hdr->dh_op == SMB_DR_ASYNC_RESPONSE) {
                /*
                 * ASYNC_RESPONSE is used to collect the response
                 * to an async call; it cannot be an async call.
                 */
                hdr->dh_flags &= ~SMB_DF_ASYNC;
        }

        if (hdr->dh_flags & SMB_DF_ASYNC) {
                if (smbd_door_dispatch_async(&dop_arg) == 0)
                        hdr->dh_door_rc = SMB_DOP_SUCCESS;
                else
                        hdr->dh_door_rc = SMB_DOP_NOT_CALLED;
        } else {
                (void) smbd_door_dispatch_op(&dop_arg);
        }

        if ((rbuf = (char *)alloca(dop_arg.rsize + hdr_size)) == NULL) {
                errno = ENOMEM;
                syslog(LOG_DEBUG, "smbd_door_dispatch[%s]: alloca %m",
                    dop_arg.opname);
                smbd_door_return(&smbd_door_sdh, NULL, 0, NULL, 0);
        }

        if (dop_arg.rbuf != NULL) {
                (void) memcpy(rbuf + hdr_size, dop_arg.rbuf, dop_arg.rsize);
                free(dop_arg.rbuf);
        }

        hdr->dh_datalen = dop_arg.rsize;
        (void) smb_doorhdr_encode(hdr, (uint8_t *)rbuf, hdr_size);
        dop_arg.rsize += hdr_size;

        smbd_door_return(&smbd_door_sdh, rbuf, dop_arg.rsize, NULL, 0);
        /*NOTREACHED*/
}

/*
 * Launch a thread to process an asynchronous door call.
 */
static int
smbd_door_dispatch_async(smbd_arg_t *req_arg)
{
        smbd_arg_t      *arg = NULL;
        char            *data = NULL;
        pthread_attr_t  attr;
        pthread_t       tid;
        int             rc;

        if ((req_arg->hdr.dh_flags & SMB_DF_ASYNC) == 0) {
                errno = EINVAL;
                return (-1);
        }

        if ((arg = malloc(sizeof (smbd_arg_t))) == NULL) {
                syslog(LOG_DEBUG, "smbd_door_dispatch_async[%s]: %m",
                    req_arg->opname);
                return (-1);
        }

        (void) memcpy(arg, req_arg, sizeof (smbd_arg_t));
        arg->data = NULL;

        if (req_arg->datalen != 0) {
                if ((data = malloc(req_arg->datalen)) == NULL) {
                        free(arg);
                        syslog(LOG_DEBUG, "smbd_door_dispatch_async[%s]: %m",
                            req_arg->opname);
                        return (-1);
                }

                (void) memcpy(data, req_arg->data, req_arg->datalen);
                arg->data = data;
        }

        (void) mutex_lock(&smbd_doorsvc.sd_mutex);
        arg->magic = SMBD_ARG_MAGIC;
        list_insert_tail(&smbd_doorsvc.sd_async_list, arg);
        ++smbd_doorsvc.sd_async_count;
        (void) mutex_unlock(&smbd_doorsvc.sd_mutex);

        (void) pthread_attr_init(&attr);
        (void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
        rc = pthread_create(&tid, &attr, smbd_door_dispatch_op, arg);
        (void) pthread_attr_destroy(&attr);

        if (rc != 0) {
                (void) mutex_lock(&smbd_doorsvc.sd_mutex);
                smbd_door_release_async(arg);
                (void) mutex_unlock(&smbd_doorsvc.sd_mutex);
        }

        return (rc);
}

/*
 * Remove an entry from the async response pending list and free
 * the arg and associated data.
 *
 * Must only be called while holding the smbd_doorsvc mutex.
 */
static void
smbd_door_release_async(smbd_arg_t *arg)
{
        if (arg != NULL) {
                assert(arg->magic == SMBD_ARG_MAGIC);
                arg->magic = (uint32_t)~SMBD_ARG_MAGIC;

                list_remove(&smbd_doorsvc.sd_async_list, arg);
                --smbd_doorsvc.sd_async_count;
                free(arg->data);
                arg->data = NULL;
                free(arg);
        }
}

/*
 * All door calls are processed here: synchronous or asynchronous:
 * - synchronous calls are invoked by direct function call
 * - asynchronous calls are invoked from a launched thread
 *
 * If the kernel has attempted to collect a response before the op
 * has completed, the arg will have been marked as response_abort
 * and we can discard the response data and release the arg.
 *
 * We send a notification when asynchronous (ASYNC) door calls
 * from the kernel (SYSSPACE) have completed.
 */
void *
smbd_door_dispatch_op(void *thread_arg)
{
        smbd_arg_t      *arg = (smbd_arg_t *)thread_arg;
        smbd_doorop_t   *doorop;
        smb_doorhdr_t   *hdr;
        int             i;

        if ((!smbd_online()) || arg == NULL)
                return (NULL);

        hdr = &arg->hdr;
        arg->opname = smb_doorhdr_opname(hdr->dh_op);

        for (i = 0; i < smbd_ndoorop; ++i) {
                doorop = &smbd_doorops[i];

                if (hdr->dh_op == doorop->opcode) {
                        hdr->dh_door_rc = doorop->op(arg);
                        hdr->dh_status = arg->status;

                        if ((hdr->dh_flags & SMB_DF_SYSSPACE) &&
                            (hdr->dh_flags & SMB_DF_ASYNC)) {
                                assert(hdr->dh_op != SMB_DR_ASYNC_RESPONSE);

                                (void) mutex_lock(&smbd_doorsvc.sd_mutex);
                                if (arg->response_abort) {
                                        free(arg->rbuf);
                                        arg->rbuf = NULL;
                                        smbd_door_release_async(arg);
                                } else {
                                        arg->response_ready = B_TRUE;
                                }
                                (void) mutex_unlock(&smbd_doorsvc.sd_mutex);

                                (void) smb_kmod_event_notify(hdr->dh_txid);
                        }

                        return (NULL);
                }
        }

        syslog(LOG_ERR, "smbd_door_dispatch_op[%s]: invalid op %u",
            arg->opname, hdr->dh_op);
        return (NULL);
}

/*
 * Wrapper for door_return.  smbd_door_enter() increments a reference count
 * when a door call is dispatched and smbd_door_return() decrements the
 * reference count when it completes.
 *
 * The reference counting is used in smbd_door_fini() to wait for active
 * calls to complete before closing the door.
 */
void
smbd_door_init(smbd_door_t *sdh, const char *name)
{
        (void) strlcpy(sdh->sd_name, name, sizeof (sdh->sd_name));
}

void
smbd_door_enter(smbd_door_t *sdh)
{
        (void) mutex_lock(&sdh->sd_mutex);
        ++sdh->sd_ncalls;
        (void) mutex_unlock(&sdh->sd_mutex);
}

/*
 * We have two calls to door_return because the first call (with data)
 * can fail, which can leave the door call blocked here.  The second
 * call (with NULL) is guaranteed to unblock and return to the caller.
 */
void
smbd_door_return(smbd_door_t *sdh, char *data_ptr, size_t data_size,
    door_desc_t *desc_ptr, uint_t num_desc)
{
        (void) mutex_lock(&sdh->sd_mutex);

        if (sdh->sd_ncalls == 0)
                syslog(LOG_ERR, "smbd_door_return[%s]: unexpected count=0",
                    sdh->sd_name);
        else
                --sdh->sd_ncalls;

        (void) cond_broadcast(&sdh->sd_cv);
        (void) mutex_unlock(&sdh->sd_mutex);

        (void) door_return(data_ptr, data_size, desc_ptr, num_desc);
        (void) door_return(NULL, 0, NULL, 0);
        /* NOTREACHED */
}

/*
 * A door service is about to terminate.
 * Give active requests a small grace period to complete.
 */
void
smbd_door_fini(smbd_door_t *sdh)
{
        timestruc_t     delay;
        int             rc = 0;

        (void) mutex_lock(&sdh->sd_mutex);

        while (rc != ETIME && sdh->sd_ncalls != 0) {
                delay.tv_sec = 1;
                delay.tv_nsec = 0;
                rc = cond_reltimedwait(&sdh->sd_cv, &sdh->sd_mutex, &delay);
        }

        if (sdh->sd_ncalls != 0)
                syslog(LOG_NOTICE, "smbd_door_fini[%s]: %d remaining",
                    sdh->sd_name, sdh->sd_ncalls);

        (void) mutex_unlock(&sdh->sd_mutex);
}

/*
 * Null door operation: always returns success.
 * Assumes no request or response data.
 */
/*ARGSUSED*/
static int
smbd_dop_null(smbd_arg_t *arg)
{
        return (SMB_DOP_SUCCESS);
}

/*
 * Async response handler: setup the rbuf and rsize for the specified
 * transaction.  This function is used by the kernel to collect the
 * response half of an asynchronous door call.
 *
 * If a door client attempts to collect a response before the op has
 * completed (!response_ready), mark the arg as response_abort and
 * set an error.  The response will be discarded when the op completes.
 */
static int
smbd_dop_async_response(smbd_arg_t *rsp_arg)
{
        list_t          *arg_list = &smbd_doorsvc.sd_async_list;
        smbd_arg_t      *arg;

        (void) mutex_lock(&smbd_doorsvc.sd_mutex);
        arg = list_head(arg_list);

        while (arg != NULL) {
                assert(arg->magic == SMBD_ARG_MAGIC);

                if (arg->hdr.dh_txid == rsp_arg->hdr.dh_txid) {
                        if (!arg->response_ready) {
                                arg->response_abort = B_TRUE;
                                rsp_arg->hdr.dh_door_rc = SMB_DOP_NOT_CALLED;
                                syslog(LOG_NOTICE, "doorsvc[%s]: %u not ready",
                                    arg->opname, arg->hdr.dh_txid);
                                break;
                        }

                        rsp_arg->rbuf = arg->rbuf;
                        rsp_arg->rsize = arg->rsize;
                        arg->rbuf = NULL;
                        arg->rsize = 0;
                        smbd_door_release_async(arg);
                        break;
                }

                arg = list_next(arg_list, arg);
        }

        (void) mutex_unlock(&smbd_doorsvc.sd_mutex);
        return (SMB_DOP_SUCCESS);
}

static int
smbd_dop_user_nonauth_logon(smbd_arg_t *arg)
{
        uint32_t        sid = 0;

        if (smb_common_decode(arg->data, arg->datalen,
            xdr_uint32_t, &sid) != 0)
                return (SMB_DOP_DECODE_ERROR);

        smbd_user_nonauth_logon(sid);
        return (SMB_DOP_SUCCESS);
}

static int
smbd_dop_user_auth_logoff(smbd_arg_t *arg)
{
        uint32_t        sid = 0;

        if (smb_common_decode(arg->data, arg->datalen,
            xdr_uint32_t, &sid) != 0)
                return (SMB_DOP_DECODE_ERROR);

        smbd_user_auth_logoff(sid);
        return (SMB_DOP_SUCCESS);
}

/*
 * Obtains an access token on successful user authentication.
 */
static int
smbd_dop_user_auth_logon(smbd_arg_t *arg)
{
        _NOTE(ARGUNUSED(arg))

        /* No longer used */
        return (SMB_DOP_EMPTYBUF);
}

static int
smbd_dop_lookup_name(smbd_arg_t *arg)
{
        smb_domain_t    dinfo;
        smb_account_t   ainfo;
        lsa_account_t   acct;
        char            buf[MAXNAMELEN];

        bzero(&acct, sizeof (lsa_account_t));

        if (smb_common_decode(arg->data, arg->datalen,
            lsa_account_xdr, &acct) != 0)
                return (SMB_DOP_DECODE_ERROR);

        if (*acct.a_domain == '\0')
                (void) snprintf(buf, MAXNAMELEN, "%s", acct.a_name);
        else if (strchr(acct.a_domain, '.') != NULL)
                (void) snprintf(buf, MAXNAMELEN, "%s@%s", acct.a_name,
                    acct.a_domain);
        else
                (void) snprintf(buf, MAXNAMELEN, "%s\\%s", acct.a_domain,
                    acct.a_name);

        acct.a_status = lsa_lookup_name(buf, acct.a_sidtype, &ainfo);
        if (acct.a_status == NT_STATUS_SUCCESS) {
                acct.a_sidtype = ainfo.a_type;
                smb_sid_tostr(ainfo.a_sid, acct.a_sid);
                (void) strlcpy(acct.a_name, ainfo.a_name, MAXNAMELEN);

                if (smb_domain_lookup_name(ainfo.a_domain, &dinfo))
                        (void) strlcpy(acct.a_domain, dinfo.di_fqname,
                            MAXNAMELEN);
                else
                        (void) strlcpy(acct.a_domain, ainfo.a_domain,
                            MAXNAMELEN);
                smb_account_free(&ainfo);
        }

        arg->rbuf = smb_common_encode(&acct, lsa_account_xdr, &arg->rsize);

        if (arg->rbuf == NULL)
                return (SMB_DOP_ENCODE_ERROR);
        return (SMB_DOP_SUCCESS);
}

static int
smbd_dop_lookup_sid(smbd_arg_t *arg)
{
        smb_domain_t    dinfo;
        smb_account_t   ainfo;
        lsa_account_t   acct;
        smb_sid_t       *sid;

        bzero(&acct, sizeof (lsa_account_t));

        if (smb_common_decode(arg->data, arg->datalen,
            lsa_account_xdr, &acct) != 0)
                return (SMB_DOP_DECODE_ERROR);

        sid = smb_sid_fromstr(acct.a_sid);
        acct.a_status = lsa_lookup_sid(sid, &ainfo);
        smb_sid_free(sid);

        if (acct.a_status == NT_STATUS_SUCCESS) {
                acct.a_sidtype = ainfo.a_type;
                smb_sid_tostr(ainfo.a_sid, acct.a_sid);
                (void) strlcpy(acct.a_name, ainfo.a_name, MAXNAMELEN);

                if (smb_domain_lookup_name(ainfo.a_domain, &dinfo))
                        (void) strlcpy(acct.a_domain, dinfo.di_fqname,
                            MAXNAMELEN);
                else
                        (void) strlcpy(acct.a_domain, ainfo.a_domain,
                            MAXNAMELEN);

                smb_account_free(&ainfo);
        }

        arg->rbuf = smb_common_encode(&acct, lsa_account_xdr, &arg->rsize);

        if (arg->rbuf == NULL)
                return (SMB_DOP_ENCODE_ERROR);
        return (SMB_DOP_SUCCESS);
}

static int
smbd_dop_join(smbd_arg_t *arg)
{
        smb_joininfo_t  jdi;
        smb_joinres_t   jdres;

        bzero(&jdi, sizeof (smb_joininfo_t));
        bzero(&jdres, sizeof (smb_joinres_t));

        if (smb_common_decode(arg->data, arg->datalen,
            smb_joininfo_xdr, &jdi) != 0)
                return (SMB_DOP_DECODE_ERROR);

        smbd_join(&jdi, &jdres);

        arg->rbuf = smb_common_encode(&jdres, smb_joinres_xdr, &arg->rsize);

        if (arg->rbuf == NULL)
                return (SMB_DOP_ENCODE_ERROR);
        return (SMB_DOP_SUCCESS);
}

static int
smbd_dop_get_dcinfo(smbd_arg_t *arg)
{
        smb_domainex_t  dxi;

        if (!smb_domain_getinfo(&dxi))
                return (SMB_DOP_EMPTYBUF);

        arg->rbuf = smb_string_encode(dxi.d_dci.dc_name, &arg->rsize);

        if (arg->rbuf == NULL)
                return (SMB_DOP_ENCODE_ERROR);
        return (SMB_DOP_SUCCESS);
}

/*
 * Return the number of snapshots for a dataset
 */
static int
smbd_dop_vss_get_count(smbd_arg_t *arg)
{
        smb_string_t    path;
        uint32_t        count;

        bzero(&path, sizeof (smb_string_t));
        arg->rbuf = NULL;

        if (smb_string_decode(&path, arg->data, arg->datalen) != 0)
                return (SMB_DOP_DECODE_ERROR);

        if (smbd_vss_get_count(path.buf, &count) == 0)
                arg->rbuf = smb_common_encode(&count, xdr_uint32_t,
                    &arg->rsize);

        xdr_free(smb_string_xdr, (char *)&path);

        if (arg->rbuf == NULL)
                return (SMB_DOP_ENCODE_ERROR);
        return (SMB_DOP_SUCCESS);
}

/*
 * Return the count and list of snapshots.
 * The list is in @GMT token format.
 */
static int
smbd_dop_vss_get_snapshots(smbd_arg_t *arg)
{
        char                            **gmtp;
        smb_gmttoken_query_t            request;
        smb_gmttoken_response_t         reply;
        uint_t                          i;

        bzero(&request, sizeof (smb_gmttoken_query_t));
        bzero(&reply, sizeof (smb_gmttoken_response_t));

        if (smb_common_decode(arg->data, arg->datalen,
            smb_gmttoken_query_xdr, &request) != 0)
                return (SMB_DOP_DECODE_ERROR);

        reply.gtr_gmttokens.gtr_gmttokens_val = malloc(request.gtq_count *
            sizeof (char *));
        bzero(reply.gtr_gmttokens.gtr_gmttokens_val, request.gtq_count *
            sizeof (char *));

        if (reply.gtr_gmttokens.gtr_gmttokens_val == NULL) {
                xdr_free(smb_gmttoken_query_xdr, (char *)&request);
                return (SMB_DOP_EMPTYBUF);
        }

        smbd_vss_get_snapshots(request.gtq_path, request.gtq_count,
            &reply.gtr_count,
            &reply.gtr_gmttokens.gtr_gmttokens_len,
            reply.gtr_gmttokens.gtr_gmttokens_val);

        arg->rbuf = smb_common_encode(&reply, smb_gmttoken_response_xdr,
            &arg->rsize);
        if (arg->rbuf == NULL) {
                xdr_free(smb_gmttoken_query_xdr, (char *)&request);
                return (SMB_DOP_ENCODE_ERROR);
        }

        for (i = 0, gmtp = reply.gtr_gmttokens.gtr_gmttokens_val;
            (i < request.gtq_count); i++) {
                free(*gmtp);
                gmtp++;
        }

        free(reply.gtr_gmttokens.gtr_gmttokens_val);
        xdr_free(smb_gmttoken_query_xdr, (char *)&request);
        return (SMB_DOP_SUCCESS);
}

/*
 * Return the name of the snapshot that matches the dataset path
 * and @GMT token.
 */
static int
smbd_dop_vss_map_gmttoken(smbd_arg_t *arg)
{
        char                    *snapname;
        smb_gmttoken_snapname_t request;

        bzero(&request, sizeof (smb_gmttoken_snapname_t));

        if (smb_common_decode(arg->data, arg->datalen,
            smb_gmttoken_snapname_xdr, &request) != 0) {
                xdr_free(smb_gmttoken_snapname_xdr, (char *)&request);
                return (SMB_DOP_DECODE_ERROR);
        }

        if ((snapname = malloc(MAXPATHLEN)) == NULL) {
                xdr_free(smb_gmttoken_snapname_xdr, (char *)&request);
                return (0);
        }

        if ((smbd_vss_map_gmttoken(request.gts_path, request.gts_gmttoken,
            request.gts_toktime, snapname) != 0)) {
                *snapname = '\0';
        }

        arg->rbuf = smb_string_encode(snapname, &arg->rsize);
        xdr_free(smb_gmttoken_snapname_xdr, (char *)&request);
        free(snapname);

        if (arg->rbuf == NULL)
                return (SMB_DOP_ENCODE_ERROR);
        return (SMB_DOP_SUCCESS);
}

static int
smbd_dop_ads_find_host(smbd_arg_t *arg)
{
        smb_ads_host_info_t     *hinfo = NULL;
        char                    *hostname = "";
        smb_string_t            fqdn;

        bzero(&fqdn, sizeof (smb_string_t));

        if (smb_string_decode(&fqdn, arg->data, arg->datalen) != 0)
                return (SMB_DOP_DECODE_ERROR);

        if ((hinfo = smb_ads_find_host(fqdn.buf)) != NULL)
                hostname = hinfo->name;

        xdr_free(smb_string_xdr, (char *)&fqdn);

        arg->rbuf = smb_string_encode(hostname, &arg->rsize);
        free(hinfo);

        if (arg->rbuf == NULL)
                return (SMB_DOP_ENCODE_ERROR);
        return (SMB_DOP_SUCCESS);
}

/*
 * Query the list of user/group quota entries for a given filesystem.
 */
static int
smbd_dop_quota_query(smbd_arg_t *arg)
{
        smb_quota_query_t       request;
        smb_quota_response_t    reply;
        uint32_t                status;

        bzero(&request, sizeof (smb_quota_query_t));
        bzero(&reply, sizeof (smb_quota_response_t));

        if (smb_common_decode(arg->data, arg->datalen,
            smb_quota_query_xdr, &request) != 0)
                return (SMB_DOP_DECODE_ERROR);

        status = smb_quota_query(&request, &reply);
        reply.qr_status = status;

        arg->rbuf = smb_common_encode(&reply, smb_quota_response_xdr,
            &arg->rsize);

        xdr_free(smb_quota_query_xdr, (char *)&request);
        smb_quota_free(&reply);

        if (arg->rbuf == NULL)
                return (SMB_DOP_ENCODE_ERROR);
        return (SMB_DOP_SUCCESS);
}

/*
 * Set a list of user/group quota entries for a given filesystem.
 */
static int
smbd_dop_quota_set(smbd_arg_t *arg)
{
        smb_quota_set_t request;
        uint32_t        status = 0;

        bzero(&request, sizeof (smb_quota_set_t));

        if (smb_common_decode(arg->data, arg->datalen,
            smb_quota_set_xdr, &request) != 0)
                return (SMB_DOP_DECODE_ERROR);

        status = smb_quota_set(&request);

        arg->rbuf = smb_common_encode(&status, xdr_uint32_t, &arg->rsize);
        xdr_free(smb_quota_set_xdr, (char *)&request);

        if (arg->rbuf == NULL)
                return (SMB_DOP_ENCODE_ERROR);
        return (SMB_DOP_SUCCESS);
}

static int
smbd_dop_dfs_get_referrals(smbd_arg_t *arg)
{
        dfs_referral_query_t    request;
        dfs_referral_response_t reply;

        bzero(&request, sizeof (request));
        bzero(&reply, sizeof (reply));

        if (smb_common_decode(arg->data, arg->datalen,
            dfs_referral_query_xdr, &request) != 0)
                return (SMB_DOP_DECODE_ERROR);

        reply.rp_status = dfs_get_referrals((const char *)request.rq_path,
            request.rq_type, &reply.rp_referrals);

        if (reply.rp_status != ERROR_SUCCESS)
                bzero(&reply.rp_referrals, sizeof (dfs_info_t));

        arg->rbuf = smb_common_encode(&reply, dfs_referral_response_xdr,
            &arg->rsize);

        if (reply.rp_status == ERROR_SUCCESS)
                dfs_info_free(&reply.rp_referrals);

        xdr_free(dfs_referral_query_xdr, (char *)&request);

        if (arg->rbuf == NULL)
                return (SMB_DOP_ENCODE_ERROR);
        return (SMB_DOP_SUCCESS);
}

static int
smbd_dop_shr_hostaccess(smbd_arg_t *arg)
{
        smb_shr_hostaccess_query_t request;
        uint32_t reply;

        bzero(&request, sizeof (request));
        bzero(&reply, sizeof (reply));

        if (smb_common_decode(arg->data, arg->datalen,
            smb_shr_hostaccess_query_xdr, &request) != 0)
                return (SMB_DOP_DECODE_ERROR);

        reply = smb_shr_hostaccess(&request.shq_ipaddr, request.shq_none,
            request.shq_ro, request.shq_rw, request.shq_flag);

        arg->rbuf = smb_common_encode(&reply, xdr_uint32_t, &arg->rsize);

        xdr_free(smb_shr_hostaccess_query_xdr, (char *)&request);

        if (arg->rbuf == NULL)
                return (SMB_DOP_ENCODE_ERROR);
        return (SMB_DOP_SUCCESS);
}

static int
smbd_dop_shr_exec(smbd_arg_t *arg)
{
        smb_shr_execinfo_t request;
        int reply;

        bzero(&request, sizeof (request));
        bzero(&reply, sizeof (reply));

        if (smb_common_decode(arg->data, arg->datalen,
            smb_shr_execinfo_xdr, &request) != 0)
                return (SMB_DOP_DECODE_ERROR);

        reply = smb_shr_exec(&request);

        if (reply != 0)
                syslog(LOG_NOTICE, "Failed to execute %s command",
                    (request.e_type == SMB_EXEC_MAP) ? "map" : "unmap");

        arg->rbuf = smb_common_encode(&reply, xdr_int, &arg->rsize);

        xdr_free(smb_shr_execinfo_xdr, (char *)&request);

        if (arg->rbuf == NULL)
                return (SMB_DOP_ENCODE_ERROR);
        return (SMB_DOP_SUCCESS);
}

/* ARGSUSED */
static int
smbd_dop_notify_dc_changed(smbd_arg_t *arg)
{

        smbd_dc_monitor_refresh();

        return (SMB_DOP_SUCCESS);
}