ndmpd/ndmp/ndmpd_config.c

/*
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * BSD 3 Clause License
 *
 * Copyright (c) 2007, The Storage Networking Industry Association.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  - Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *  - Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 *  - Neither the name of The Storage Networking Industry Association (SNIA)
 *    nor the names of its contributors may be used to endorse or promote
 *    products derived from this software without specific prior written
 *    permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
/* Copyright (c) 2007, The Storage Networking Industry Association. */
/* Copyright (c) 1996, 1997 PDC, Network Appliance. All Rights Reserved */
/* Copyright 2014 Nexenta Systems, Inc.  All rights reserved. */

#include <dirent.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/mnttab.h>
#include <sys/mntent.h>
#include <sys/mntio.h>
#include <sys/statvfs.h>
#include <sys/utsname.h>
#include <sys/scsi/scsi.h>
#include <unistd.h>
#include <sys/systeminfo.h>
#include "ndmpd_common.h"
#include "ndmpd.h"

static void simple_get_attrs(ulong_t *attributes);

/*
 * Number of environment variable for the file system
 * info in V3 net_fs_info.
 */
#define V3_N_FS_ENVS    4

/*
 * Is the file system a valid one to be reported to the
 * clients?
 */
#define IS_VALID_FS(fs) (fs && ( \
    strcasecmp(fs->mnt_fstype, MNTTYPE_UFS) == 0 || \
    strcasecmp(fs->mnt_fstype, MNTTYPE_ZFS) == 0 || \
    strcasecmp(fs->mnt_fstype, MNTTYPE_NFS) == 0 || \
    strcasecmp(fs->mnt_fstype, MNTTYPE_NFS3) == 0 || \
    strcasecmp(fs->mnt_fstype, MNTTYPE_NFS4) == 0))

#define MNTTYPE_LEN 10

extern struct fs_ops sfs2_ops;
extern struct fs_ops sfs2cpv_ops;


/*
 * ************************************************************************
 * NDMP V2 HANDLERS
 * ************************************************************************
 */

/*
 * ndmpd_config_get_host_info_v2
 *
 * This handler handles the ndmp_config_get_host_info request.
 * Host specific information is returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
/*ARGSUSED*/
void
ndmpd_config_get_host_info_v2(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_host_info_reply_v2 reply;
    ndmp_auth_type auth_types[2];
    char buf[HOSTNAMELEN + 1];
    struct utsname uts;
    char hostidstr[16];
    ulong_t hostid;

    (void) memset((void*)&reply, 0, sizeof (reply));
    (void) memset(buf, 0, sizeof (buf));
    (void) gethostname(buf, sizeof (buf));

    reply.error = NDMP_NO_ERR;
    reply.hostname = buf;
    (void) uname(&uts);
    reply.os_type = uts.sysname;
    reply.os_vers = uts.release;

    if (sysinfo(SI_HW_SERIAL, hostidstr, sizeof (hostidstr)) < 0) {
        NDMP_LOG(LOG_DEBUG, "sysinfo error: %m.");
        reply.error = NDMP_UNDEFINED_ERR;
    }

    /*
     * Convert the hostid to hex. The returned string must match
     * the string returned by hostid(1).
     */
    hostid = strtoul(hostidstr, 0, 0);
    (void) snprintf(hostidstr, sizeof (hostidstr), "%lx", hostid);
    reply.hostid = hostidstr;

    auth_types[0] = NDMP_AUTH_TEXT;
    reply.auth_type.auth_type_len = 1;
    reply.auth_type.auth_type_val = auth_types;

    ndmp_send_reply(connection, (void *) &reply,
        "sending ndmp_config_get_host_info reply");
}


/*
 * ndmpd_config_get_butype_attr_v2
 *
 * This handler handles the ndmp_config_get_butype_attr request.
 * Information about the specified backup type is returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
void
ndmpd_config_get_butype_attr_v2(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_butype_attr_request *request;
    ndmp_config_get_butype_attr_reply reply;

    request = (ndmp_config_get_butype_attr_request *)body;

    reply.error = NDMP_NO_ERR;

    if (strcmp(request->name, "dump") == 0) {
        (void) simple_get_attrs(&reply.attrs);
    } else if (strcmp(request->name, "tar") == 0) {
        reply.attrs = NDMP_NO_BACKUP_FILELIST;
    } else {
        NDMP_LOG(LOG_ERR, "Invalid backup type: %s.", request->name);
        NDMP_LOG(LOG_ERR,
            "Supported backup types are 'dump' and 'tar' only.");
        reply.error = NDMP_ILLEGAL_ARGS_ERR;
    }

    ndmp_send_reply(connection, (void *) &reply,
        "sending ndmp_config_get_butype_attr reply");
}


/*
 * ndmpd_config_get_mover_type_v2
 *
 * This handler handles the ndmp_config_get_mover_type request.
 * Information about the supported mover types is returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
/*ARGSUSED*/
void
ndmpd_config_get_mover_type_v2(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_mover_type_reply reply;
    ndmp_addr_type types[2];

    types[0] = NDMP_ADDR_LOCAL;
    types[1] = NDMP_ADDR_TCP;

    reply.error = NDMP_NO_ERR;
    reply.methods.methods_len = 2;
    reply.methods.methods_val = types;

    ndmp_send_reply(connection, (void *) &reply,
        "sending ndmp_config_get_mover_type reply");
}


/*
 * ndmpd_config_get_auth_attr_v2
 *
 * This handler handles the ndmp_config_get_auth_attr request.
 * Authorization type specific information is returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
void
ndmpd_config_get_auth_attr_v2(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_auth_attr_request *request;
    ndmp_config_get_auth_attr_reply reply;
    ndmpd_session_t *session = ndmp_get_client_data(connection);

    request = (ndmp_config_get_auth_attr_request *)body;

    reply.error = NDMP_NO_ERR;
    reply.server_attr.auth_type = request->auth_type;

    switch (request->auth_type) {
    case NDMP_AUTH_TEXT:
        break;
    case NDMP_AUTH_MD5:
        /* Create a 64 byte random session challenge */
        randomize(session->ns_challenge, MD5_CHALLENGE_SIZE);
        (void) memcpy(reply.server_attr.ndmp_auth_attr_u.challenge,
            session->ns_challenge, MD5_CHALLENGE_SIZE);
        break;
    case NDMP_AUTH_NONE:
        /* FALL THROUGH */
    default:
        NDMP_LOG(LOG_ERR, "Invalid authentication type: %d.",
            request->auth_type);
        NDMP_LOG(LOG_ERR,
            "Supported authentication types are md5 and cleartext.");
        reply.error = NDMP_ILLEGAL_ARGS_ERR;
        break;
    }

    ndmp_send_reply(connection, (void *) &reply,
        "sending ndmp_config_get_auth_attr reply");
}


/*
 * ************************************************************************
 * NDMP V3 HANDLERS
 * ************************************************************************
 */

/*
 * ndmpd_config_get_host_info_v3
 *
 * This handler handles the ndmp_config_get_host_info request.
 * Host specific information is returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
/*ARGSUSED*/
void
ndmpd_config_get_host_info_v3(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_host_info_reply_v3 reply;
    char buf[HOSTNAMELEN+1];
    struct utsname uts;
    char hostidstr[16];
    ulong_t hostid;

    (void) memset((void*)&reply, 0, sizeof (reply));
    (void) memset(buf, 0, sizeof (buf));
    (void) gethostname(buf, sizeof (buf));


    reply.error = NDMP_NO_ERR;
    reply.hostname = buf;
    (void) uname(&uts);
    reply.os_type = uts.sysname;
    reply.os_vers = uts.release;

    if (sysinfo(SI_HW_SERIAL, hostidstr, sizeof (hostidstr)) < 0) {

        NDMP_LOG(LOG_DEBUG, "sysinfo error: %m.");
        reply.error = NDMP_UNDEFINED_ERR;
    }

    /*
     * Convert the hostid to hex. The returned string must match
     * the string returned by hostid(1).
     */
    hostid = strtoul(hostidstr, 0, 0);
    (void) snprintf(hostidstr, sizeof (hostidstr), "%lx", hostid);
    reply.hostid = hostidstr;

    ndmp_send_reply(connection, (void *) &reply,
        "sending ndmp_config_get_host_info reply");
}


/*
 * ndmpd_config_get_connection_type_v3
 *
 * This handler handles the ndmp_config_get_connection_type_request.
 * A list of supported data connection types is returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
/*ARGSUSED*/
void
ndmpd_config_get_connection_type_v3(ndmp_connection_t *connection,
    void *body)
{
    ndmp_config_get_connection_type_reply_v3 reply;
    ndmp_addr_type addr_types[2];

    (void) memset((void*)&reply, 0, sizeof (reply));

    reply.error = NDMP_NO_ERR;

    addr_types[0] = NDMP_ADDR_LOCAL;
    addr_types[1] = NDMP_ADDR_TCP;
    reply.addr_types.addr_types_len = 2;
    reply.addr_types.addr_types_val = addr_types;

    ndmp_send_reply(connection, (void *) &reply,
        "sending config_get_connection_type_v3 reply");
}


/*
 * ndmpd_config_get_auth_attr_v3
 *
 * This handler handles the ndmp_config_get_auth_attr request.
 * Authorization type specific information is returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
void
ndmpd_config_get_auth_attr_v3(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_auth_attr_request *request;
    ndmp_config_get_auth_attr_reply reply;
    ndmpd_session_t *session = ndmp_get_client_data(connection);

    request = (ndmp_config_get_auth_attr_request *)body;

    (void) memset((void*)&reply, 0, sizeof (reply));
    reply.error = NDMP_NO_ERR;
    reply.server_attr.auth_type = request->auth_type;

    switch (request->auth_type) {
    case NDMP_AUTH_TEXT:
        break;
    case NDMP_AUTH_MD5:
        /* Create a 64 bytes random session challenge */
        randomize(session->ns_challenge, MD5_CHALLENGE_SIZE);
        (void) memcpy(reply.server_attr.ndmp_auth_attr_u.challenge,
            session->ns_challenge, MD5_CHALLENGE_SIZE);
        break;
    case NDMP_AUTH_NONE:
        /* FALL THROUGH */
    default:
        NDMP_LOG(LOG_ERR, "Invalid authentication type: %d.",
            request->auth_type);
        NDMP_LOG(LOG_ERR,
            "Supported authentication types are md5 and cleartext.");
        reply.error = NDMP_ILLEGAL_ARGS_ERR;
        break;
    }

    ndmp_send_reply(connection, (void *) &reply,
        "sending ndmp_config_get_auth_attr_v3 reply");
}


/*
 * ndmpd_config_get_butype_info_v3
 *
 * This handler handles the ndmp_config_get_butype_info_request.
 * Information about all supported backup types are returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
/*ARGSUSED*/
void
ndmpd_config_get_butype_info_v3(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_butype_info_reply_v3 reply;
    ndmp_butype_info info[3];
    ndmp_pval envs[8];
    ulong_t attrs;
    ndmp_pval *envp = envs;

    ndmp_pval zfs_envs[9];
    ulong_t zfs_attrs;
    ndmp_pval *zfs_envp = zfs_envs;

    (void) memset((void*)&reply, 0, sizeof (reply));

    /*
     * Supported environment variables and their default values
     * for dump and tar.
     *
     * The environment variables for dump and tar format are the
     * same, because we use the same backup engine for both.
     */
    NDMP_SETENV(envp, "PREFIX", "");
    NDMP_SETENV(envp, "TYPE", "");
    NDMP_SETENV(envp, "DIRECT", "n");
    NDMP_SETENV(envp, "HIST", "n");
    NDMP_SETENV(envp, "FILESYSTEM", "");
    NDMP_SETENV(envp, "LEVEL", "0");
    NDMP_SETENV(envp, "UPDATE", "TRUE");
    NDMP_SETENV(envp, "BASE_DATE", "");

    attrs = NDMP_BUTYPE_BACKUP_FILE_HISTORY |
        NDMP_BUTYPE_RECOVER_FILELIST |
        NDMP_BUTYPE_BACKUP_DIRECT |
        NDMP_BUTYPE_BACKUP_INCREMENTAL |
        NDMP_BUTYPE_BACKUP_UTF8 |
        NDMP_BUTYPE_RECOVER_UTF8;

    /* If DAR supported */
    if (ndmp_dar_support)
        attrs |= NDMP_BUTYPE_RECOVER_DIRECT;

    /* tar backup type */
    info[0].butype_name = "tar";
    info[0].default_env.default_env_len = ARRAY_LEN(envs, ndmp_pval);
    info[0].default_env.default_env_val = envs;
    info[0].attrs = attrs;

    /* dump backup type */
    info[1].butype_name = "dump";
    info[1].default_env.default_env_len = ARRAY_LEN(envs, ndmp_pval);
    info[1].default_env.default_env_val = envs;
    info[1].attrs = attrs;

    /*
     * Supported environment variables and their default values
     * for type "zfs."
     */

    NDMP_SETENV(zfs_envp, "PREFIX", "");
    NDMP_SETENV(zfs_envp, "FILESYSTEM", "");
    NDMP_SETENV(zfs_envp, "TYPE", "zfs");
    NDMP_SETENV(zfs_envp, "HIST", "n");
    NDMP_SETENV(zfs_envp, "LEVEL", "0");
    NDMP_SETENV(zfs_envp, "ZFS_MODE", "recursive");
    NDMP_SETENV(zfs_envp, "ZFS_FORCE", "FALSE");
    NDMP_SETENV(zfs_envp, "UPDATE", "TRUE");
    NDMP_SETENV(zfs_envp, "DMP_NAME", "level");

    zfs_attrs = NDMP_BUTYPE_BACKUP_UTF8 |
        NDMP_BUTYPE_RECOVER_UTF8 |
        NDMP_BUTYPE_BACKUP_DIRECT |
        NDMP_BUTYPE_BACKUP_INCREMENTAL;

    /* zfs backup type */
    info[2].butype_name = "zfs";
    info[2].default_env.default_env_len = ARRAY_LEN(zfs_envs, ndmp_pval);
    info[2].default_env.default_env_val = zfs_envs;
    info[2].attrs = zfs_attrs;

    reply.error = NDMP_NO_ERR;
    reply.butype_info.butype_info_len = ARRAY_LEN(info, ndmp_butype_info);
    reply.butype_info.butype_info_val = info;

    ndmp_send_reply(connection, (void *)&reply,
        "sending ndmp_config_get_butype_info reply");
}

/*
 * ndmpd_config_get_fs_info_v3
 *
 * This handler handles the ndmp_config_get_fs_info_request.
 * Information about all mounted file systems is returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
/*ARGSUSED*/
void
ndmpd_config_get_fs_info_v3(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_fs_info_reply_v3 reply;
    ndmp_fs_info_v3 *fsip = NULL, *fsip_save = NULL; /* FS info pointer */
    int len = 0, nmnt, fd;
    int log_dev_len;
    FILE *fp = NULL;
    struct mnttab mt, *fs;
    struct statvfs64 stat_buf;
    ndmp_pval *envp, *save;

    (void) memset((void*)&reply, 0, sizeof (reply));
    reply.error = NDMP_NO_ERR;

    if ((fd = open(MNTTAB, O_RDONLY)) == -1) {
        NDMP_LOG(LOG_ERR, "File mnttab open error: %m.");
        reply.error = NDMP_UNDEFINED_ERR;
        goto send_reply;
    }

    /* nothing was found, send an empty reply */
    if (ioctl(fd, MNTIOC_NMNTS, &nmnt) != 0 || nmnt <= 0) {
        (void) close(fd);
        NDMP_LOG(LOG_ERR, "No file system found.");
        goto send_reply;
    }

    fp = fdopen(fd, "r");
    if (!fp) {
        (void) close(fd);
        NDMP_LOG(LOG_ERR, "File mnttab open error: %m.");
        reply.error = NDMP_UNDEFINED_ERR;
        goto send_reply;
    }

    fsip_save = fsip = ndmp_malloc(sizeof (ndmp_fs_info_v3) * nmnt);
    if (!fsip) {
        (void) fclose(fp);
        reply.error = NDMP_NO_MEM_ERR;
        goto send_reply;
    }

    /*
     * Re-read the directory and set up file system information.
     */
    rewind(fp);
    while (len < nmnt && (getmntent(fp, &mt) == 0))

    {
        fs = &mt;
        log_dev_len = strlen(mt.mnt_mountp)+2;
        if (!IS_VALID_FS(fs))
            continue;

        fsip->fs_logical_device = ndmp_malloc(log_dev_len);
        fsip->fs_type = ndmp_malloc(MNTTYPE_LEN);
        if (!fsip->fs_logical_device || !fsip->fs_type) {
            free(fsip->fs_logical_device);
            free(fsip->fs_type);
            reply.error = NDMP_NO_MEM_ERR;
            break;
        }
        (void) snprintf(fsip->fs_type, MNTTYPE_LEN, "%s",
            fs->mnt_fstype);
        (void) snprintf(fsip->fs_logical_device, log_dev_len, "%s",
            fs->mnt_mountp);
        fsip->invalid = 0;

        if (statvfs64(fs->mnt_mountp, &stat_buf) < 0) {
            NDMP_LOG(LOG_DEBUG,
                "statvfs(%s) error.", fs->mnt_mountp);
            fsip->fs_status =
                "statvfs error: unable to determine filesystem"
                " attributes";
        } else {
            fsip->invalid = 0;
            fsip->total_size =
                long_long_to_quad((u_longlong_t)stat_buf.f_frsize *
                (u_longlong_t)stat_buf.f_blocks);
            fsip->used_size =
                long_long_to_quad((u_longlong_t)stat_buf.f_frsize *
                (u_longlong_t)(stat_buf.f_blocks-stat_buf.f_bfree));

            fsip->avail_size =
                long_long_to_quad((u_longlong_t)stat_buf.f_frsize *
                (u_longlong_t)stat_buf.f_bfree);
            fsip->total_inodes =
                long_long_to_quad((u_longlong_t)stat_buf.f_files);
            fsip->used_inodes =
                long_long_to_quad((u_longlong_t)(stat_buf.f_files -
                stat_buf.f_ffree));
            fsip->fs_status = "";
        }
        save = envp = ndmp_malloc(sizeof (ndmp_pval) * V3_N_FS_ENVS);
        if (!envp) {
            free(fsip->fs_logical_device);
            free(fsip->fs_type);
            reply.error = NDMP_NO_MEM_ERR;
            break;
        }
        (void) memset((void*)save, 0,
            V3_N_FS_ENVS * sizeof (ndmp_pval));

        fsip->fs_env.fs_env_val = envp;
        NDMP_SETENV(envp, "LOCAL", "y");
        NDMP_SETENV(envp, "TYPE", fsip->fs_type);
        NDMP_SETENV(envp, "AVAILABLE_BACKUP", "tar,dump");

        if (FS_READONLY(fs) == 0) {
            NDMP_SETENV(envp, "AVAILABLE_RECOVERY", "tar,dump");
        }

        fsip->fs_env.fs_env_len = envp - save;
        len++;
        fsip++;
    }
    (void) fclose(fp);

send_reply:
    if (reply.error == NDMP_NO_ERR) {
        reply.fs_info.fs_info_len = len;
        reply.fs_info.fs_info_val = fsip_save;
    }
    ndmp_send_reply(connection, (void *)&reply,
        "error sending ndmp_config_get_fs_info reply");

    while (fsip > fsip_save) {
        fsip--;
        free(fsip->fs_logical_device);
        free(fsip->fs_env.fs_env_val);
        free(fsip->fs_type);
    }

    free(fsip);
}


/*
 * ndmpd_config_get_tape_info_v3
 *
 * This handler handles the ndmp_config_get_tape_info_request.
 * Information about all connected tape drives is returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
/*ARGSUSED*/
void
ndmpd_config_get_tape_info_v3(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_tape_info_reply_v3 reply;
    ndmp_device_info_v3 *tip, *tip_save = NULL; /* tape info pointer */
    ndmp_device_capability_v3 *dcp;
    ndmp_device_capability_v3 *dcp_save = NULL; /* dev capability pointer */
    int i, n, max;
    sasd_drive_t *sd;
    scsi_link_t *sl;
    ndmp_pval *envp, *envp_save = NULL;
    ndmp_pval *envp_head;

    (void) memset((void*)&reply, 0, sizeof (reply));
    max = sasd_dev_count();

    tip_save = tip = ndmp_malloc(sizeof (ndmp_device_info_v3) * max);
    dcp_save = dcp = ndmp_malloc(sizeof (ndmp_device_capability_v3) * max);
    envp_save = envp = ndmp_malloc(sizeof (ndmp_pval) * max * 3);
    if (!tip_save || !dcp_save || !envp_save) {
        free(tip_save);
        free(dcp_save);
        free(envp_save);
        reply.error = NDMP_NO_MEM_ERR;
        ndmp_send_reply(connection, (void *)&reply,
            "error sending ndmp_config_get_tape_info reply");
        return;
    }

    reply.error = NDMP_NO_ERR;

    for (i = n = 0; i < max; i++) {
        if (!(sl = sasd_dev_slink(i)) || !(sd = sasd_drive(i)))
            continue;
        if (sl->sl_type != DTYPE_SEQUENTIAL)
            continue;
        /*
         * Don't report dead links.
         */
        if ((access(sd->sd_name, F_OK) == -1) && (errno == ENOENT))
            continue;

        NDMP_LOG(LOG_DEBUG,
            "model \"%s\" dev \"%s\"", sd->sd_id, sd->sd_name);

        envp_head = envp;
        NDMP_SETENV(envp, "EXECUTE_CDB", "b");
        NDMP_SETENV(envp, "SERIAL_NUMBER", sd->sd_serial);
        NDMP_SETENV(envp, "WORLD_WIDE_NAME", sd->sd_wwn);

        tip->model = sd->sd_id; /* like "DLT7000     " */
        tip->caplist.caplist_len = 1;
        tip->caplist.caplist_val = dcp;
        dcp->device = sd->sd_name; /* like "isp1t060" */
        dcp->attr = 0;
        dcp->capability.capability_len = 3;
        dcp->capability.capability_val = envp_head;
        tip++;
        dcp++;
        n++;
    }

    NDMP_LOG(LOG_DEBUG, "n %d", n);

    /*
     * We should not receive the get_tape_info when three-way backup is
     * running and we are acting as just data, but some clients try
     * to get the Tape information anyway.
     */
    if (n == 0 || max <= 0) {
        reply.error = NDMP_NO_DEVICE_ERR;
        ndmp_send_reply(connection, (void *)&reply,
            "error sending ndmp_config_get_tape_info reply");
        free(tip_save); free(dcp_save); free(envp_save);
        return;
    }


    reply.tape_info.tape_info_len = n;
    reply.tape_info.tape_info_val = tip_save;

    ndmp_send_reply(connection, (void *)&reply,
        "error sending ndmp_config_get_tape_info reply");

    free(tip_save);
    free(dcp_save);
    free(envp_save);
}


/*
 * ndmpd_config_get_scsi_info_v3
 *
 * This handler handles the ndmp_config_get_tape_scsi_request.
 * Information about all connected scsi tape stacker and jukeboxes
 * is returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
/*ARGSUSED*/
void
ndmpd_config_get_scsi_info_v3(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_scsi_info_reply_v3 reply;
    ndmp_device_info_v3 *sip, *sip_save;
    ndmp_device_capability_v3 *dcp, *dcp_save;
    int i, n, max;
    sasd_drive_t *sd;
    scsi_link_t *sl;
    ndmp_pval *envp, *envp_save = NULL;
    ndmp_pval *envp_head;

    (void) memset((void*)&reply, 0, sizeof (reply));
    max = sasd_dev_count();
    sip_save = sip = ndmp_malloc(sizeof (ndmp_device_info_v3) * max);
    dcp_save = dcp = ndmp_malloc(sizeof (ndmp_device_capability_v3) * max);
    envp_save = envp = ndmp_malloc(sizeof (ndmp_pval) * max * 2);
    if (!sip_save || !dcp_save || !envp_save) {
        free(sip_save);
        free(dcp_save);
        free(envp_save);
        reply.error = NDMP_NO_MEM_ERR;
        ndmp_send_reply(connection, (void *)&reply,
            "error sending ndmp_config_get_scsi_info reply");
        return;
    }

    reply.error = NDMP_NO_ERR;
    for (i = n = 0; i < max; i++) {
        if (!(sl = sasd_dev_slink(i)) || !(sd = sasd_drive(i)))
            continue;
        if (sl->sl_type != DTYPE_CHANGER)
            continue;
        /*
         * Don't report dead links.
         */
        if ((access(sd->sd_name, F_OK) == -1) && (errno == ENOENT))
            continue;

        NDMP_LOG(LOG_DEBUG,
            "model \"%s\" dev \"%s\"", sd->sd_id, sd->sd_name);

        envp_head = envp;
        NDMP_SETENV(envp, "SERIAL_NUMBER", sd->sd_serial);
        NDMP_SETENV(envp, "WORLD_WIDE_NAME", sd->sd_wwn);

        sip->model = sd->sd_id; /* like "Powerstor L200  " */
        sip->caplist.caplist_len = 1;
        sip->caplist.caplist_val = dcp;
        dcp->device = sd->sd_name; /* like "isp1m000" */

        dcp->attr = 0;
        dcp->capability.capability_len = 2;
        dcp->capability.capability_val = envp_head;
        sip++;
        dcp++;
        n++;
    }

    NDMP_LOG(LOG_DEBUG, "n %d", n);

    reply.scsi_info.scsi_info_len = n;
    reply.scsi_info.scsi_info_val = sip_save;

    ndmp_send_reply(connection, (void *)&reply,
        "error sending ndmp_config_get_scsi_info reply");

    free(sip_save);
    free(dcp_save);
    free(envp_save);
}


/*
 * ndmpd_config_get_server_info_v3
 *
 * This handler handles the ndmp_config_get_server_info request.
 * Host specific information is returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
/*ARGSUSED*/
void
ndmpd_config_get_server_info_v3(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_server_info_reply_v3 reply;
    ndmp_auth_type auth_types[2];
    char rev_number[10];
    ndmpd_session_t *session = ndmp_get_client_data(connection);

    (void) memset((void*)&reply, 0, sizeof (reply));
    reply.error = NDMP_NO_ERR;

    if (connection->conn_authorized ||
        session->ns_protocol_version != NDMPV4) {
        reply.vendor_name = VENDOR_NAME;
        reply.product_name = PRODUCT_NAME;
        (void) snprintf(rev_number, sizeof (rev_number), "%d",
            ndmp_ver);
        reply.revision_number = rev_number;
    } else {
        reply.vendor_name = "\0";
        reply.product_name = "\0";
        reply.revision_number = "\0";
    }

    NDMP_LOG(LOG_DEBUG,
        "vendor \"%s\", product \"%s\" rev \"%s\"",
        reply.vendor_name, reply.product_name, reply.revision_number);

    auth_types[0] = NDMP_AUTH_TEXT;
    auth_types[1] = NDMP_AUTH_MD5;
    reply.auth_type.auth_type_len = ARRAY_LEN(auth_types, ndmp_auth_type);
    reply.auth_type.auth_type_val = auth_types;

    ndmp_send_reply(connection, (void *)&reply,
        "error sending ndmp_config_get_server_info reply");
}


/*
 * ************************************************************************
 * NDMP V4 HANDLERS
 * ************************************************************************
 */

/*
 * ndmpd_config_get_butype_info_v4
 *
 * This handler handles the ndmp_config_get_butype_info_request.
 * Information about all supported backup types are returned.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
/*ARGSUSED*/
void
ndmpd_config_get_butype_info_v4(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_butype_info_reply_v4 reply;
    ndmp_butype_info info[3];

    ndmp_pval envs[12];
    ulong_t attrs;
    ndmp_pval *envp = envs;

    ndmp_pval zfs_envs[11];
    ulong_t zfs_attrs;
    ndmp_pval *zfs_envp = zfs_envs;


    (void) memset((void*)&reply, 0, sizeof (reply));

    /*
     * Supported environment variables and their default values
     * for dump and tar.
     *
     * The environment variables for dump and tar format are the
     * same, because we use the same backup engine for both.
     */
    NDMP_SETENV(envp, "FILESYSTEM", "");
    NDMP_SETENV(envp, "DIRECT", "n");
    NDMP_SETENV(envp, "RECURSIVE", "n");
    NDMP_SETENV(envp, "TYPE", "");
    NDMP_SETENV(envp, "USER", "");
    NDMP_SETENV(envp, "HIST", "n");
    NDMP_SETENV(envp, "PATHNAME_SEPARATOR", "/");
    NDMP_SETENV(envp, "LEVEL", "0");
    NDMP_SETENV(envp, "EXTRACT", "y");
    NDMP_SETENV(envp, "UPDATE", "y");
    NDMP_SETENV(envp, "CMD", "");
    NDMP_SETENV(envp, "BASE_DATE", "");

    attrs = NDMP_BUTYPE_RECOVER_FILELIST |
        NDMP_BUTYPE_BACKUP_DIRECT |
        NDMP_BUTYPE_BACKUP_INCREMENTAL |
        NDMP_BUTYPE_BACKUP_UTF8 |
        NDMP_BUTYPE_RECOVER_UTF8 |
        NDMP_BUTYPE_BACKUP_FH_FILE |
        NDMP_BUTYPE_BACKUP_FH_DIR |
        NDMP_BUTYPE_RECOVER_FH_FILE |
        NDMP_BUTYPE_RECOVER_FH_DIR;

    /* If DAR supported */
    if (ndmp_dar_support)
        attrs |= NDMP_BUTYPE_RECOVER_DIRECT;

    /* tar backup type */
    info[0].butype_name = "tar";
    info[0].default_env.default_env_len = ARRAY_LEN(envs, ndmp_pval);
    info[0].default_env.default_env_val = envs;
    info[0].attrs = attrs;

    /* dump backup type */
    info[1].butype_name = "dump";
    info[1].default_env.default_env_len = ARRAY_LEN(envs, ndmp_pval);
    info[1].default_env.default_env_val = envs;
    info[1].attrs = attrs;

    /*
     * Supported environment variables and their default values
     * for type "zfs."
     */

    NDMP_SETENV(zfs_envp, "USER", "");
    NDMP_SETENV(zfs_envp, "CMD", "");
    NDMP_SETENV(zfs_envp, "FILESYSTEM", "");
    NDMP_SETENV(zfs_envp, "PATHNAME_SEPARATOR", "/");
    NDMP_SETENV(zfs_envp, "TYPE", "zfs");
    NDMP_SETENV(zfs_envp, "HIST", "n");
    NDMP_SETENV(zfs_envp, "LEVEL", "0");
    NDMP_SETENV(zfs_envp, "ZFS_MODE", "recursive");
    NDMP_SETENV(zfs_envp, "ZFS_FORCE", "n");
    NDMP_SETENV(zfs_envp, "UPDATE", "y");
    NDMP_SETENV(zfs_envp, "DMP_NAME", "level");

    zfs_attrs = NDMP_BUTYPE_BACKUP_UTF8 |
        NDMP_BUTYPE_RECOVER_UTF8 |
        NDMP_BUTYPE_BACKUP_DIRECT |
        NDMP_BUTYPE_BACKUP_INCREMENTAL;

    /* zfs backup type */
    info[2].butype_name = "zfs";
    info[2].default_env.default_env_len = ARRAY_LEN(zfs_envs, ndmp_pval);
    info[2].default_env.default_env_val = zfs_envs;
    info[2].attrs = zfs_attrs;

    reply.error = NDMP_NO_ERR;
    reply.butype_info.butype_info_len = ARRAY_LEN(info, ndmp_butype_info);
    reply.butype_info.butype_info_val = info;

    ndmp_send_reply(connection, (void *)&reply,
        "sending ndmp_config_get_butype_info reply");
}


/*
 * ndmpd_config_get_ext_list_v4
 *
 * This handler handles the ndmpd_config_get_ext_list_v4 request.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
/*ARGSUSED*/
void
ndmpd_config_get_ext_list_v4(ndmp_connection_t *connection, void *body)
{
    ndmp_config_get_ext_list_reply_v4 reply;
    ndmpd_session_t *session = ndmp_get_client_data(connection);

    (void) memset((void*)&reply, 0, sizeof (reply));

    if (session->ns_set_ext_list) {
        /*
         * Illegal request if extensions have already been selected.
         */
        NDMP_LOG(LOG_ERR, "Extensions have already been selected.");
        reply.error = NDMP_EXT_DANDN_ILLEGAL_ERR;
    } else {
        /*
         * Reply with an empty set of extensions.
         */
        session->ns_get_ext_list = B_TRUE;
        reply.error = NDMP_NO_ERR;
    }

    reply.class_list.class_list_val = NULL;
    reply.class_list.class_list_len = 0;

    ndmp_send_reply(connection, (void *)&reply,
        "error sending ndmp_config_get_ext_list reply");
}

/*
 * ndmpd_config_set_ext_list_v4
 *
 * This handler handles the ndmpd_config_get_ext_list_v4 request.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *   body       (input) - request message body.
 *
 * Returns:
 *   void
 */
void
ndmpd_config_set_ext_list_v4(ndmp_connection_t *connection, void *body)
{
    ndmp_config_set_ext_list_reply_v4 reply;
    ndmp_config_set_ext_list_request_v4 *request;
    ndmpd_session_t *session = ndmp_get_client_data(connection);

    request = (ndmp_config_set_ext_list_request_v4 *)body;

    (void) memset((void*)&reply, 0, sizeof (reply));

    if (!session->ns_get_ext_list) {
        /*
         * The DMA is required to issue a NDMP_GET_EXT_LIST request
         * prior sending a NDMP_SET_EXT_LIST request.
         */
        NDMP_LOG(LOG_ERR, "No prior ndmp_config_get_ext_list issued.");
        reply.error = NDMP_PRECONDITION_ERR;
    } else if (session->ns_set_ext_list) {
        /*
         * Illegal request if extensions have already been selected.
         */
        NDMP_LOG(LOG_ERR, "Extensions have already been selected.");
        reply.error = NDMP_EXT_DANDN_ILLEGAL_ERR;
    } else {
        /*
         * We currently do not support any extensions, but the DMA
         * may test NDMP_CONFIG_SET_EXT_LIST with an empty list.
         */
        if (request->ndmp_selected_ext.ndmp_selected_ext_len != 0) {
            reply.error = NDMP_CLASS_NOT_SUPPORTED_ERR;
        } else {
            session->ns_set_ext_list = B_TRUE;
            reply.error = NDMP_NO_ERR;
        }
    }

    ndmp_send_reply(connection, (void *)&reply,
        "error sending ndmp_config_set_ext_list reply");
}


/*
 * ************************************************************************
 * LOCALS
 * ************************************************************************
 */

/*
 * simple_get_attrs
 *
 * Set the default attrs for dump mode
 *
 * Parameters:
 *   attributes (output) - the attributes for dump mode
 *
 * Returns:
 *   void
 */
static void
simple_get_attrs(ulong_t *attributes)
{
    *attributes = NDMP_NO_RECOVER_FHINFO;
}