OpenSolaris_b135/cmd/ndmpd/ndmp/ndmpd_config.c
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* 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[2];
ndmp_pval envs[8];
ulong_t attrs;
ndmp_pval *envp = envs;
(void) memset((void*)&reply, 0, sizeof (reply));
/*
* Supported environment variables and their default values.
* 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;
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");
return;
}
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;
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;
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[2];
ndmp_pval envs[12];
ulong_t attrs;
ndmp_pval *envp = envs;
(void) memset((void*)&reply, 0, sizeof (reply));
/*
* Supported environment variables and their default values.
* 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;
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;
}