xref: /onnv-gate/usr/src/cmd/ndmpd/ndmp/ndmpd_config.c (revision 13024:9c1800b4023e)

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

#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, *fsip_save; /* FS info pointer */
	int i, 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;
		ndmp_send_reply(connection, (void *)&reply,
		    "sending ndmp_config_get_fs_info reply");
		return;
	}

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

	fp = fopen(MNTTAB, "r");
	if (!fp) {
		NDMP_LOG(LOG_ERR, "File mnttab open error: %m.");
		reply.error = NDMP_UNDEFINED_ERR;
		ndmp_send_reply(connection, (void *)&reply,
		    "sending ndmp_config_get_fs_info reply");
		return;
	}

	fsip_save = fsip = ndmp_malloc(sizeof (ndmp_fs_info_v3) * nmnt);
	if (!fsip) {
		(void) fclose(fp);
		reply.error = NDMP_NO_MEM_ERR;
		ndmp_send_reply(connection, (void *)&reply,
		    "error sending ndmp_config_get_fs_info reply");
		return;
	}

	/*
	 * Re-read the directory and set up file system information.
	 */
	i = 0;
	rewind(fp);
	while (i < 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) {
			reply.error = NDMP_NO_MEM_ERR;
			free(fsip->fs_logical_device);
			free(fsip->fs_type);
			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) {
			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;
		i++;
		fsip++;
	}
	(void) fclose(fp);
	if (reply.error == NDMP_NO_ERR) {
		reply.fs_info.fs_info_len = i;
		reply.fs_info.fs_info_val = fsip_save;
	} else {
		reply.fs_info.fs_info_len = 0;
		reply.fs_info.fs_info_val = NULL;
	}
	ndmp_send_reply(connection, (void *)&reply,
	    "error sending ndmp_config_get_fs_info reply");

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

	free(fsip_save);
}


/*
 * 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 == FALSE)
		reply.error = NDMP_EXT_DANDN_ILLEGAL_ERR;
	else
		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
 */
/*ARGSUSED*/
void
ndmpd_config_set_ext_list_v4(ndmp_connection_t *connection, void *body)
{
	ndmp_config_set_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 == TRUE) {
		reply.error = NDMP_EXT_DANDN_ILLEGAL_ERR;
	} else {
		session->ns_set_ext_list = TRUE;
		/*
		 * NOTE: for now we are not supporting any extension list,
		 * hence this error, when we start to support extensions,
		 * this should be validated
		 */

		reply.error = NDMP_VERSION_NOT_SUPPORTED_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;
}