ndmpd/ndmp/ndmpd_util.c

	ndmpd_util.c revision 89f9eb8701145fa396cfc2ac0b468bd5c8466494
/*
 * Copyright 2009 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 <sys/types.h>
#include <sys/socket.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>
#include <time.h>
#include "ndmpd.h"
#include <bitmap.h>
#include <sys/queue.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <sys/socketvar.h>
#include <net/if.h>
#include <netdb.h>
#include <sys/filio.h>
#include <sys/mtio.h>
#include <sys/scsi/impl/uscsi.h>
#include <sys/scsi/scsi.h>
#include "tlm.h"

/*
 * Mutex to protect Nlp
 */
mutex_t nlp_mtx;

/*
 * Patchable socket buffer sizes in kilobytes.
 * ssb: send buffer size.
 * rsb: receive buffer size.
 */
int ndmp_sbs = 60;
int ndmp_rbs = 60;


/*
 * Force to backup all the intermediate directories leading to an object
 * to be backed up in 'dump' format backup.
 */
boolean_t ndmp_dump_path_node = FALSE;


/*
 * Force to backup all the intermediate directories leading to an object
 * to be backed up in 'tar' format backup.
 */
boolean_t ndmp_tar_path_node = FALSE;


/*
 * Should the 'st_ctime' be ignored during incremental level backup?
 */
boolean_t ndmp_ignore_ctime = FALSE;

/*
 * Should the 'st_lmtime' be included during incremental level backup?
 */
boolean_t ndmp_include_lmtime = FALSE;

/*
 * Force to send the file history node entries along with the file history
 * dir entries for all directories containing the changed files to the client
 * for incremental backup.
 *
 * Note: This variable is added to support Bakbone Software's Netvault DMA
 * which expects to get the FH ADD NODES for all upper directories which
 * contain the changed files in incremental backup along with the FH ADD DIRS.
 */
boolean_t ndmp_fhinode = FALSE;

/*
 * Maximum permitted sequence number in the token-based backup.  The
 * value of this variable can be changed by the administrator and is
 * saved in the NDMP configuration file.
 */
static int ndmp_max_tok_seq = NDMP_MAX_TOKSEQ;

/*
 * Force backup directories in incremental backups.  If the
 * directory is not modified itself, it's not backed up by
 * default.
 */
int ndmp_force_bk_dirs = 0;

/*
 * Keeps track of the open SCSI (including tape and robot) devices.
 * When a SCSI device is opened its name must be added to this list and
 * when it's closed its name must be removed from this list.  The main
 * purpose of this list is the robot device.  If the robot devices are not
 * attached in SASD layer, Local Backup won't see them. If they are
 * attached and we open the robot devices, then wrong commands are sent
 * to robot by SASD since it assumes that the robot is a tape (sequential
 * access) device.
 */
struct open_list {
    LIST_ENTRY(open_list) ol_q;
    int ol_nref;
    char *ol_devnm;
    int ol_sid;
    int ol_lun;
    int ol_fd;
    ndmp_connection_t *cl_conn;
};
LIST_HEAD(ol_head, open_list);


/*
 * Head of the opened SCSI devices list.
 */
static struct ol_head ol_head;

mutex_t ol_mutex = DEFAULTMUTEX;


/*
 * List of things to be exluded from backup.
 */
static char *exls[] = {
    EXCL_PROC,
    EXCL_TMP,
    NULL, /* reserved for a copy of the "backup.directory" */
    NULL
};


/*
 * The counter for creating unique names with "ndmp.%d" format.
 */
#define NDMP_RCF_BASENAME   "ndmp."
static int ndmp_job_cnt = 0;

static int scsi_test_unit_ready(int dev_id);

/*
 * ndmpd_add_file_handler
 *
 * Adds a file handler to the file handler list.
 * The file handler list is used by ndmpd_api_dispatch.
 *
 * Parameters:
 *   session (input) - session pointer.
 *   cookie  (input) - opaque data to be passed to file hander when called.
 *   fd      (input) - file descriptor.
 *   mode    (input) - bitmask of the following:
 *           1 = watch file for ready for reading
 *           2 = watch file for ready for writing
 *           4 = watch file for exception
 *   class   (input) - handler class. (HC_CLIENT, HC_MOVER, HC_MODULE)
 *   func    (input) - function to call when the file meets one of the
 *           conditions specified by mode.
 *
 * Returns:
 *   0 - success.
 *  -1 - error.
 */
int
ndmpd_add_file_handler(ndmpd_session_t *session, void *cookie, int fd,
    ulong_t mode, ulong_t class, ndmpd_file_handler_func_t *func)
{
    ndmpd_file_handler_t *new;

    new = ndmp_malloc(sizeof (ndmpd_file_handler_t));
    if (new == 0)
        return (-1);

    new->fh_cookie = cookie;
    new->fh_fd = fd;
    new->fh_mode = mode;
    new->fh_class = class;
    new->fh_func = func;
    new->fh_next = session->ns_file_handler_list;
    session->ns_file_handler_list = new;
    return (0);
}


/*
 * ndmpd_remove_file_handler
 *
 * Removes a file handler from the file handler list.
 *
 * Parameters:
 *   session (input) - session pointer.
 *   fd      (input) - file descriptor.
 *
 * Returns:
 *   0 - success.
 *  -1 - error.
 */
int
ndmpd_remove_file_handler(ndmpd_session_t *session, int fd)
{
    ndmpd_file_handler_t **last;
    ndmpd_file_handler_t *handler;

    last = &session->ns_file_handler_list;
    while (*last != 0) {
        handler = *last;

        if (handler->fh_fd == fd) {
            *last = handler->fh_next;
            (void) free(handler);
            return (1);
        }
        last = &handler->fh_next;
    }

    return (0);
}


/*
 * ndmp_connection_closed
 *
 * If the connection closed or not.
 *
 * Parameters:
 *   fd (input) : file descriptor
 *
 * Returns:
 *   0  - connection is still valid
 *   1  - connection is not valid anymore
 *   -1 - Internal kernel error
 */
int
ndmp_connection_closed(int fd)
{
    fd_set fds;
    int closed, ret;
    struct timeval timeout;

    if (fd < 0) /* We are not using the mover */
        return (-1);

    timeout.tv_sec = 0;
    timeout.tv_usec = 1000;

    FD_ZERO(&fds);
    FD_SET(fd, &fds);
    ret = select(FD_SETSIZE, &fds, NULL, NULL, &timeout);

    closed = (ret == -1 && errno == EBADF);

    return (closed);
}

/*
 * ndmp_check_mover_state
 *
 * Checks the mover connection status and sends an appropriate
 * NDMP message to client based on that.
 *
 * Parameters:
 *   ndmpd_session_t *session (input) : session pointer
 *
 * Returns:
 *   void.
 */
void
ndmp_check_mover_state(ndmpd_session_t *session)
{
    int moverfd;
    /*
     * NDMPV3 Spec (Three-way restore):
     * Once all of the files have been recovered, NDMP DATA Server closes
     * the connection to the mover on the NDMP TAPE Server. THEN
     * The NDMP client should receive an NDMP_NOTIFY_MOVER_HALTED message
     * with an NDMP_MOVER_CONNECT_CLOSED reason from the NDMP TAPE Server
     */
    moverfd = session->ns_mover.md_sock;
    /* If connection is closed by the peer */
    if (moverfd >= 0 &&
        session->ns_mover.md_mode == NDMP_MOVER_MODE_WRITE) {
        int closed, reason;

        closed = ndmp_connection_closed(moverfd);
        if (closed) {
            /* Connection closed or internal error */
            if (closed > 0) {
                NDMP_LOG(LOG_DEBUG,
                    "ndmp mover: connection closed by peer");
                reason = NDMP_MOVER_HALT_CONNECT_CLOSED;
            } else {
                NDMP_LOG(LOG_DEBUG,
                    "ndmp mover: Internal error");
                reason = NDMP_MOVER_HALT_INTERNAL_ERROR;
            }
            ndmpd_mover_error(session, reason);

        }
    }
}


/*
 * ndmpd_select
 *
 * Calls select on the the set of file descriptors from the
 * file handler list masked by the fd_class argument.
 * Calls the file handler function for each
 * file descriptor that is ready for I/O.
 *
 * Parameters:
 *   session (input) - session pointer.
 *   block   (input) - if TRUE, ndmpd_select waits until at least one
 *           file descriptor is ready for I/O. Otherwise,
 *           it returns immediately if no file descriptors are
 *           ready for I/O.
 *   class_mask (input) - bit mask of handler classes to be examined.
 *           Provides for excluding some of the handlers from
 *           being called.
 *
 * Returns:
 *  -1 - error.
 *   0 - no handlers were called.
 *   1 - at least one handler was called.
 */
int
ndmpd_select(ndmpd_session_t *session, boolean_t block, ulong_t class_mask)
{
    fd_set rfds;
    fd_set wfds;
    fd_set efds;
    int n;
    ndmpd_file_handler_t *handler;
    struct timeval timeout;

    nlp_event_rv_set(session, 0);

    if (session->ns_file_handler_list == 0)
        return (0);


    /*
     * If select should be blocked, then we poll every ten seconds.
     * The reason is in case of three-way restore we should be able
     * to detect if the other end closed the connection or not.
     * NDMP client(DMA) does not send any information about the connection
     * that was closed in the other end.
     */

    if (block == TRUE)
        timeout.tv_sec = 10;
    else
        timeout.tv_sec = 0;
    timeout.tv_usec = 0;

    do {
        /* Create the fd_sets for select. */
        FD_ZERO(&rfds);
        FD_ZERO(&wfds);
        FD_ZERO(&efds);

        for (handler = session->ns_file_handler_list; handler != 0;
            handler = handler->fh_next) {
            if ((handler->fh_class & class_mask) == 0)
                continue;

            if (handler->fh_mode & NDMPD_SELECT_MODE_READ)
                FD_SET(handler->fh_fd, &rfds);
            if (handler->fh_mode & NDMPD_SELECT_MODE_WRITE)
                FD_SET(handler->fh_fd, &wfds);
            if (handler->fh_mode & NDMPD_SELECT_MODE_EXCEPTION)
                FD_SET(handler->fh_fd, &efds);
        }
        ndmp_check_mover_state(session);
        n = select(FD_SETSIZE, &rfds, &wfds, &efds, &timeout);
    } while (n == 0 && block == TRUE);

    if (n < 0) {
        int connection_fd = ndmp_get_fd(session->ns_connection);

        if (errno == EINTR)
            return (0);

        NDMP_LOG(LOG_DEBUG, "Select error: %m");

        for (handler = session->ns_file_handler_list; handler != 0;
            handler = handler->fh_next) {
            if ((handler->fh_class & class_mask) == 0)
                continue;

            if (handler->fh_mode & NDMPD_SELECT_MODE_READ) {
                if (FD_ISSET(handler->fh_fd, &rfds) &&
                    connection_fd == handler->fh_fd)
                    session->ns_eof = TRUE;
            }
            if (handler->fh_mode & NDMPD_SELECT_MODE_WRITE) {
                if (FD_ISSET(handler->fh_fd, &wfds) &&
                    connection_fd == handler->fh_fd)
                    session->ns_eof = TRUE;
            }
            if (handler->fh_mode & NDMPD_SELECT_MODE_EXCEPTION) {
                if (FD_ISSET(handler->fh_fd, &efds) &&
                    connection_fd == handler->fh_fd)
                    session->ns_eof = TRUE;
            }
        }

        nlp_event_rv_set(session, -1);
        return (-1);
    }
    if (n == 0)
        return (0);

    handler = session->ns_file_handler_list;
    while (handler != 0) {
        ulong_t mode = 0;

        if ((handler->fh_class & class_mask) == 0) {
            handler = handler->fh_next;
            continue;
        }
        if (handler->fh_mode & NDMPD_SELECT_MODE_READ) {
            if (FD_ISSET(handler->fh_fd, &rfds)) {
                mode |= NDMPD_SELECT_MODE_READ;
                FD_CLR(handler->fh_fd, &rfds);
            }
        }
        if (handler->fh_mode & NDMPD_SELECT_MODE_WRITE) {
            if (FD_ISSET(handler->fh_fd, &wfds)) {
                mode |= NDMPD_SELECT_MODE_WRITE;
                FD_CLR(handler->fh_fd, &wfds);
            }
        }
        if (handler->fh_mode & NDMPD_SELECT_MODE_EXCEPTION) {
            if (FD_ISSET(handler->fh_fd, &efds)) {
                mode |= NDMPD_SELECT_MODE_EXCEPTION;
                FD_CLR(handler->fh_fd, &efds);
            }
        }
        if (mode) {
            (*handler->fh_func) (handler->fh_cookie,
                handler->fh_fd, mode);

            /*
             * K.L. The list can be modified during the execution
             * of handler->fh_func. Therefore, handler will start
             * from the beginning of the handler list after
             * each execution.
             */
            handler = session->ns_file_handler_list;

            /*
             * Release the thread which is waiting for a request
             * to be proccessed.
             */
            nlp_event_nw(session);
        } else
            handler = handler->fh_next;

    }

    nlp_event_rv_set(session, 1);
    return (1);
}


/*
 * ndmpd_save_env
 *
 * Saves a copy of the environment variable list from the data_start_backup
 * request or data_start_recover request.
 *
 * Parameters:
 *   session (input) - session pointer.
 *   env     (input) - environment variable list to be saved.
 *   envlen  (input) - length of variable array.
 *
 * Returns:
 *   error code.
 */
ndmp_error
ndmpd_save_env(ndmpd_session_t *session, ndmp_pval *env, ulong_t envlen)
{
    ulong_t i;
    char *namebuf;
    char *valbuf;

    session->ns_data.dd_env_len = 0;

    if (envlen == 0)
        return (NDMP_NO_ERR);

    session->ns_data.dd_env = ndmp_malloc(sizeof (ndmp_pval) * envlen);
    if (session->ns_data.dd_env == 0)
        return (NDMP_NO_MEM_ERR);

    for (i = 0; i < envlen; i++) {
        namebuf = strdup(env[i].name);
        if (namebuf == 0)
            return (NDMP_NO_MEM_ERR);

        valbuf = strdup(env[i].value);
        if (valbuf == 0) {
            free(namebuf);
            return (NDMP_NO_MEM_ERR);
        }

        NDMP_LOG(LOG_DEBUG, "env(%s): \"%s\"",
            namebuf, valbuf);

        (void) mutex_lock(&session->ns_lock);
        session->ns_data.dd_env[i].name = namebuf;
        session->ns_data.dd_env[i].value = valbuf;
        session->ns_data.dd_env_len++;
        (void) mutex_unlock(&session->ns_lock);
    }

    return (NDMP_NO_ERR);
}


/*
 * ndmpd_free_env
 *
 * Free the previously saved environment variable array.
 *
 * Parameters:
 *   session - NDMP session pointer.
 *
 * Returns:
 *   void.
 */
void
ndmpd_free_env(ndmpd_session_t *session)
{
    ulong_t i;
    int count = session->ns_data.dd_env_len;

    (void) mutex_lock(&session->ns_lock);
    session->ns_data.dd_env_len = 0;
    for (i = 0; i < count; i++) {
        free(session->ns_data.dd_env[i].name);
        free(session->ns_data.dd_env[i].value);
    }

    free((char *)session->ns_data.dd_env);
    session->ns_data.dd_env = 0;
    (void) mutex_unlock(&session->ns_lock);
}


/*
 * ndmpd_save_nlist_v2
 *
 * Save a copy of list of file names to be restored.
 *
 * Parameters:
 *   nlist    (input) - name list from data_start_recover request.
 *   nlistlen (input) - length of name list.
 *
 * Returns:
 *   array of file name pointers.
 *
 * Notes:
 *   free_nlist should be called to free the returned list.
 *   A null pointer indicates the end of the list.
 */
ndmp_error
ndmpd_save_nlist_v2(ndmpd_session_t *session, ndmp_name *nlist,
    ulong_t nlistlen)
{
    ulong_t i;
    char *namebuf;
    char *destbuf;

    if (nlistlen == 0)
        return (NDMP_NO_ERR);

    session->ns_data.dd_nlist_len = 0;
    session->ns_data.dd_nlist = ndmp_malloc(sizeof (ndmp_name)*nlistlen);
    if (session->ns_data.dd_nlist == 0)
        return (NDMP_NO_MEM_ERR);

    for (i = 0; i < nlistlen; i++) {
        namebuf = ndmp_malloc(strlen(nlist[i].name) + 1);
        if (namebuf == 0)
            return (NDMP_NO_MEM_ERR);

        destbuf = ndmp_malloc(strlen(nlist[i].dest) + 1);
        if (destbuf == 0) {
            free(namebuf);
            return (NDMP_NO_MEM_ERR);
        }
        (void) strlcpy(namebuf, nlist[i].name,
            strlen(nlist[i].name) + 1);
        (void) strlcpy(destbuf, nlist[i].dest,
            strlen(nlist[i].dest) + 1);

        session->ns_data.dd_nlist[i].name = namebuf;
        session->ns_data.dd_nlist[i].dest = destbuf;
        session->ns_data.dd_nlist[i].ssid = nlist[i].ssid;
        session->ns_data.dd_nlist[i].fh_info = nlist[i].fh_info;
        session->ns_data.dd_nlist_len++;
    }

    return (NDMP_NO_ERR);
}


/*
 * ndmpd_free_nlist_v2
 *
 * Free a list created by ndmpd_save_nlist_v2.
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   void
 */
void
ndmpd_free_nlist_v2(ndmpd_session_t *session)
{
    ulong_t i;

    for (i = 0; i < session->ns_data.dd_nlist_len; i++) {
        free(session->ns_data.dd_nlist[i].name);
        free(session->ns_data.dd_nlist[i].dest);
    }

    if (session->ns_data.dd_nlist != NULL)
        free((char *)session->ns_data.dd_nlist);
    session->ns_data.dd_nlist = 0;
    session->ns_data.dd_nlist_len = 0;
}


/*
 * ndmpd_free_nlist_v3
 *
 * Free a list created by ndmpd_save_nlist_v3.
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   void
 */
void
ndmpd_free_nlist_v3(ndmpd_session_t *session)
{
    ulong_t i;
    mem_ndmp_name_v3_t *tp; /* destination entry */

    tp = session->ns_data.dd_nlist_v3;
    for (i = 0; i < session->ns_data.dd_nlist_len; tp++, i++) {
        NDMP_FREE(tp->nm3_opath);
        NDMP_FREE(tp->nm3_dpath);
        NDMP_FREE(tp->nm3_newnm);
    }

    NDMP_FREE(session->ns_data.dd_nlist_v3);
    session->ns_data.dd_nlist_len = 0;
}


/*
 * ndmpd_save_nlist_v3
 *
 * Save a copy of list of file names to be restored.
 *
 * Parameters:
 *   nlist    (input) - name list from data_start_recover request.
 *   nlistlen (input) - length of name list.
 *
 * Returns:
 *   array of file name pointers.
 *
 * Notes:
 *   free_nlist should be called to free the returned list.
 *   A null pointer indicates the end of the list.
 */
ndmp_error
ndmpd_save_nlist_v3(ndmpd_session_t *session, ndmp_name_v3 *nlist,
    ulong_t nlistlen)
{
    ulong_t i;
    ndmp_error rv;
    ndmp_name_v3 *sp; /* source entry */
    mem_ndmp_name_v3_t *tp; /* destination entry */

    if (nlistlen == 0)
        return (NDMP_ILLEGAL_ARGS_ERR);

    session->ns_data.dd_nlist_len = 0;
    tp = session->ns_data.dd_nlist_v3 =
        ndmp_malloc(sizeof (mem_ndmp_name_v3_t) * nlistlen);
    if (session->ns_data.dd_nlist_v3 == 0)
        return (NDMP_NO_MEM_ERR);

    rv = NDMP_NO_ERR;
    sp = nlist;
    for (i = 0; i < nlistlen; tp++, sp++, i++) {
        tp->nm3_opath = strdup(sp->original_path);
        if (!tp->nm3_opath) {
            rv = NDMP_NO_MEM_ERR;
            break;
        }
        if (!*sp->destination_dir) {
            tp->nm3_dpath = NULL;
            /* In V4 destination dir cannot be NULL */
            if (session->ns_protocol_version == NDMPV4) {
                rv = NDMP_ILLEGAL_ARGS_ERR;
                break;
            }
        } else if (!(tp->nm3_dpath = strdup(sp->destination_dir))) {
            rv = NDMP_NO_MEM_ERR;
            break;
        }
        if (!*sp->new_name)
            tp->nm3_newnm = NULL;
        else if (!(tp->nm3_newnm = strdup(sp->new_name))) {
            rv = NDMP_NO_MEM_ERR;
            break;
        }

        tp->nm3_node = quad_to_long_long(sp->node);
        tp->nm3_fh_info = quad_to_long_long(sp->fh_info);
        tp->nm3_err = NDMP_NO_ERR;
        session->ns_data.dd_nlist_len++;

        NDMP_LOG(LOG_DEBUG, "orig \"%s\"", tp->nm3_opath);
        NDMP_LOG(LOG_DEBUG, "dest \"%s\"", NDMP_SVAL(tp->nm3_dpath));
        NDMP_LOG(LOG_DEBUG, "name \"%s\"", NDMP_SVAL(tp->nm3_newnm));
        NDMP_LOG(LOG_DEBUG, "node %lld", tp->nm3_node);
        NDMP_LOG(LOG_DEBUG, "fh_info %lld", tp->nm3_fh_info);
    }

    if (rv != NDMP_NO_ERR)
        ndmpd_free_nlist_v3(session);

    return (rv);
}


/*
 * ndmpd_free_nlist
 *
 * Free the recovery list based on the version
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   void
 */
void
ndmpd_free_nlist(ndmpd_session_t *session)
{
    switch (session->ns_protocol_version) {
    case 1:
    case 2:
        ndmpd_free_nlist_v2(session);
        break;
    case 3:
    case 4:
        ndmpd_free_nlist_v3(session);
        break;

    default:
        NDMP_LOG(LOG_DEBUG, "Unknown version %d",
            session->ns_protocol_version);
    }
}


/*
 * fh_cmpv3
 *
 * Comparison function used in sorting the Nlist based on their
 * file history info (offset of the entry on the tape)
 *
 * Parameters:
 *   p (input) - pointer to P
 *   q (input) - pointer to Q
 *
 * Returns:
 *  -1: P < Q
 *   0: P = Q
 *   1: P > Q
 */
static int
fh_cmpv3(const void *p,
        const void *q)
{
#define FH_INFOV3(p)    (((mem_ndmp_name_v3_t *)p)->nm3_fh_info)

    if (FH_INFOV3(p) < FH_INFOV3(q))
        return (-1);
    else if (FH_INFOV3(p) == FH_INFOV3(q))
        return (0);
    else
        return (1);

#undef FH_INFOV3
}


/*
 * ndmp_sort_nlist_v3
 *
 * Sort the recovery list based on their offset on the tape
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   void
 */
void
ndmp_sort_nlist_v3(ndmpd_session_t *session)
{
    if (!session || session->ns_data.dd_nlist_len == 0 ||
        !session->ns_data.dd_nlist_v3)
        return;

    (void) qsort(session->ns_data.dd_nlist_v3,
        session->ns_data.dd_nlist_len,
        sizeof (mem_ndmp_name_v3_t), fh_cmpv3);
}


/*
 * ndmp_send_reply
 *
 * Send the reply, check for error and print the msg if any error
 * occured when sending the reply.
 *
 *   Parameters:
 *     connection (input) - connection pointer.
 *
 *   Return:
 *     void
 */
void
ndmp_send_reply(ndmp_connection_t *connection, void *reply, char *msg)
{
    if (ndmp_send_response(connection, NDMP_NO_ERR, reply) < 0)
        NDMP_LOG(LOG_DEBUG, "%s", msg);
}


/*
 * ndmp_mtioctl
 *
 * Performs numerous filemark operations.
 *
 * Parameters:
 *  fd - file descriptor of the device
 *  cmd - filemark or record command
 *  count - the number of operations to be performed
 */
int
ndmp_mtioctl(int fd, int cmd, int count)
{
    struct mtop mp;

    mp.mt_op = cmd;
    mp.mt_count = count;
    if (ioctl(fd, MTIOCTOP, &mp) < 0) {
        NDMP_LOG(LOG_ERR, "Failed to send command to tape: %m.");
        return (-1);
    }

    return (0);
}


/*
 * quad_to_long_long
 *
 * Convert type quad to longlong_t
 */
u_longlong_t
quad_to_long_long(ndmp_u_quad q)
{
    u_longlong_t ull;

    ull = ((u_longlong_t)q.high << 32) + q.low;
    return (ull);
}


/*
 * long_long_to_quad
 *
 * Convert long long to quad type
 */
ndmp_u_quad
long_long_to_quad(u_longlong_t ull)
{
    ndmp_u_quad q;

    q.high = (ulong_t)(ull >> 32);
    q.low = (ulong_t)ull;
    return (q);
}


/*
 * ndmp_set_socket_nodelay
 *
 * Set the TCP socket option to nodelay mode
 */
void
ndmp_set_socket_nodelay(int sock)
{
    int flag = 1;

    (void) setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof (flag));
}


/*
 * ndmp_set_socket_snd_buf
 *
 * Set the socket send buffer size
 */
void
ndmp_set_socket_snd_buf(int sock, int size)
{
    if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &size, sizeof (size)) < 0)
        NDMP_LOG(LOG_DEBUG, "SO_SNDBUF failed errno=%d", errno);
}


/*
 * ndmp_set_socket_rcv_buf
 *
 * Set the socket receive buffer size
 */
void
ndmp_set_socket_rcv_buf(int sock, int size)
{
    if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &size, sizeof (size)) < 0)
        NDMP_LOG(LOG_DEBUG, "SO_RCVBUF failed errno=%d", errno);
}

/*
 * ndmp_get_max_tok_seq
 *
 * Get the maximum permitted token sequence for token-based
 * backups.
 *
 * Parameters:
 *   void
 *
 * Returns:
 *   ndmp_max_tok_seq
 */
int
ndmp_get_max_tok_seq(void)
{
    return (ndmp_max_tok_seq);
}

/*
 * ndmp_buffer_get_size
 *
 * Return the NDMP transfer buffer size
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   buffer size
 */
long
ndmp_buffer_get_size(ndmpd_session_t *session)
{
    long xfer_size;

    if (session == NULL)
        return (0);

    if (session->ns_data.dd_mover.addr_type == NDMP_ADDR_TCP) {
        xfer_size = atoi(ndmpd_get_prop_default(NDMP_MOVER_RECSIZE,
            "60"));
        if (xfer_size > 0)
            xfer_size *= KILOBYTE;
        else
            xfer_size = REMOTE_RECORD_SIZE;
        NDMP_LOG(LOG_DEBUG, "Remote operation: %d", xfer_size);
    } else {
        NDMP_LOG(LOG_DEBUG,
            "Local operation: %lu", session->ns_mover.md_record_size);
        if ((xfer_size = session->ns_mover.md_record_size) == 0)
            xfer_size = MAX_RECORD_SIZE;
    }

    NDMP_LOG(LOG_DEBUG, "xfer_size: %d", xfer_size);
    return (xfer_size);
}


/*
 * ndmp_lbr_init
 *
 * Initialize the LBR/NDMP backup parameters
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   0: on success
 *  -1: otherwise
 */
int
ndmp_lbr_init(ndmpd_session_t *session)
{
    if (session->ns_ndmp_lbr_params != NULL) {
        NDMP_LOG(LOG_DEBUG, "ndmp_lbr_params already allocated.");
        return (0);
    }

    session->ns_ndmp_lbr_params = ndmp_malloc(sizeof (ndmp_lbr_params_t));
    if (session->ns_ndmp_lbr_params == NULL)
        return (-1);

    session->ns_ndmp_lbr_params->nlp_bkmap = -1;
    session->ns_ndmp_lbr_params->nlp_session = session;
    (void) cond_init(&session->ns_ndmp_lbr_params->nlp_cv, 0, NULL);
    (void) mutex_init(&session->ns_lock, 0, NULL);
    session->ns_nref = 0;
    return (0);
}


/*
 * ndmp_lbr_cleanup
 *
 * Deallocate and cleanup all NDMP/LBR parameters
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   0: on success
 *  -1: otherwise
 */
void
ndmp_lbr_cleanup(ndmpd_session_t *session)
{
    /*
     * If in 3-way restore, the connection close is detected after
     * check in tape_read(), the reader thread of mover may wait forever
     * for the tape to be changed.  Force the reader thread to exit.
     */
    nlp_event_rv_set(session, -2);
    nlp_event_nw(session);

    ndmpd_abort_marking_v2(session);
    ndmp_stop_buffer_worker(session);
    ndmp_waitfor_op(session);
    ndmp_free_reader_writer_ipc(session);
    if (session->ns_ndmp_lbr_params) {
        if (session->ns_ndmp_lbr_params->nlp_bkmap != -1)
            (void) dbm_free(session->ns_ndmp_lbr_params->nlp_bkmap);
        tlm_release_list(session->ns_ndmp_lbr_params->nlp_exl);
        tlm_release_list(session->ns_ndmp_lbr_params->nlp_inc);
        (void) cond_destroy(&session->ns_ndmp_lbr_params->nlp_cv);
    }

    NDMP_FREE(session->ns_ndmp_lbr_params);
}


/*
 * nlp_ref_nw
 *
 * Increase the references to the NDMP/LBR parameter to prevent
 * unwanted release
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   void
 */
void
nlp_ref_nw(ndmpd_session_t *session)
{
    ndmp_lbr_params_t *nlp;

    (void) mutex_lock(&nlp_mtx);
    if ((nlp = ndmp_get_nlp(session)) != NULL) {
        nlp->nlp_nw++;
        NDMP_LOG(LOG_DEBUG, "nw: %d", nlp->nlp_nw);
    } else
        NDMP_LOG(LOG_DEBUG, "nlp == NULL");
    (void) mutex_unlock(&nlp_mtx);
}


/*
 * nlp_unref_nw
 *
 * Decrease the references to the NDMP/LBR parameter before
 * release
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   void
 */
void
nlp_unref_nw(ndmpd_session_t *session)
{
    ndmp_lbr_params_t *nlp;

    (void) mutex_lock(&nlp_mtx);
    if ((nlp = ndmp_get_nlp(session)) != NULL) {
        NDMP_LOG(LOG_DEBUG, "nw: %d", nlp->nlp_nw);
        if (nlp->nlp_nw > 0)
            nlp->nlp_nw--;
    } else
        NDMP_LOG(LOG_DEBUG, "nlp == NULL");
    (void) mutex_unlock(&nlp_mtx);
}


/*
 * nlp_wait_nw
 *
 * Wait for a NDMP/LBR parameter to get available
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   void
 */
void
nlp_wait_nw(ndmpd_session_t *session)
{
    ndmp_lbr_params_t *nlp;

    (void) mutex_lock(&nlp_mtx);
    if ((nlp = ndmp_get_nlp(session)) != NULL) {
        NDMP_LOG(LOG_DEBUG, "nw: %d", nlp->nlp_nw);
        if (nlp->nlp_nw > 0) {
            NDMP_LOG(LOG_DEBUG, "Waiting");
            while ((nlp->nlp_flag & NLP_READY) == 0)
                (void) cond_wait(&nlp->nlp_cv, &nlp_mtx);
        }
    } else
        NDMP_LOG(LOG_DEBUG, "nlp == NULL");
    (void) mutex_unlock(&nlp_mtx);
}


/*
 * nlp_event_nw
 *
 * Signal that a NDMP/LBR parameter is available to wake up the
 * threads waiting on that
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   void
 */
void
nlp_event_nw(ndmpd_session_t *session)
{
    ndmp_lbr_params_t *nlp;

    (void) mutex_lock(&nlp_mtx);
    if ((nlp = ndmp_get_nlp(session)) != NULL) {
        if (nlp->nlp_nw > 0) {
            NDMP_LOG(LOG_DEBUG, "nw: %d", nlp->nlp_nw);
            nlp->nlp_flag |= NLP_READY;
            (void) cond_signal(&nlp->nlp_cv);
        }
    } else
        NDMP_LOG(LOG_DEBUG, "nlp == NULL");
    (void) mutex_unlock(&nlp_mtx);
}


/*
 * nlp_event_rv_get
 *
 * Get the return value for each NLP
 *
 * Parameters:
 *   session (input) - session pointer.
 *
 * Returns:
 *   return value
 */
int
nlp_event_rv_get(ndmpd_session_t *session)
{
    ndmp_lbr_params_t *nlp;

    if ((nlp = ndmp_get_nlp(session)) == NULL) {
        NDMP_LOG(LOG_DEBUG, "nlp == NULL");
        return (0);
    }

    return (nlp->nlp_rv);
}


/*
 * nlp_event_rv_set
 *
 * Set the return value for an NLP
 *
 * Parameters:
 *   session (input) - session pointer.
 *   rv (input) - return value
 *
 * Returns:
 *   void
 */
void
nlp_event_rv_set(ndmpd_session_t *session,
    int rv)
{
    ndmp_lbr_params_t *nlp;

    (void) mutex_lock(&nlp_mtx);
    if (rv != 0)
        NDMP_LOG(LOG_DEBUG, "rv: %d", rv);

    if ((nlp = ndmp_get_nlp(session)) != NULL)
        nlp->nlp_rv = rv;
    else
        NDMP_LOG(LOG_DEBUG, "nlp == NULL");
    (void) mutex_unlock(&nlp_mtx);
}

/*
 * is_buffer_erroneous
 *
 * Run a sanity check on the buffer
 *
 * returns:
 *   TRUE: if the buffer seems to have error
 *   FALSE: if the buffer is full and has valid data.
 */
boolean_t
is_buffer_erroneous(tlm_buffer_t *buf)
{
    boolean_t rv;

    rv = (buf == NULL || buf->tb_eot || buf->tb_eof ||
        buf->tb_errno != 0);
    if (rv) {
        if (buf == NULL) {
            NDMP_LOG(LOG_DEBUG, "buf == NULL");
        } else {
            NDMP_LOG(LOG_DEBUG, "eot: %u, eof: %u, errno: %d",
                buf->tb_eot, buf->tb_eof, buf->tb_errno);
        }
    }

    return (rv);
}

/*
 * ndmp_execute_cdb
 *
 * Main SCSI CDB execution program, this is used by message handler
 * for the NDMP tape/SCSI execute CDB requests. This function uses
 * USCSI interface to run the CDB command and sets all the CDB parameters
 * in the SCSI query before calling the USCSI ioctl. The result of the
 * CDB is returned in two places:
 *    cmd.uscsi_status      The status of CDB execution
 *    cmd.uscsi_rqstatus    The status of sense requests
 *    reply.error       The general errno (ioctl)
 *
 * Parameters:
 *   session (input) - session pointer
 *   adapter_name (input) - name of SCSI adapter
 *   sid (input) - SCSI target ID
 *   lun (input) - LUN number
 *   request (input) - NDMP client CDB request
 *
 * Returns:
 *   void
 */
/*ARGSUSED*/
void
ndmp_execute_cdb(ndmpd_session_t *session, char *adapter_name, int sid, int lun,
    ndmp_execute_cdb_request *request)
{
    ndmp_execute_cdb_reply reply;
    struct uscsi_cmd cmd;
    int fd;
    struct open_list *olp;
    char rq_buf[255];

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

    if (request->flags == NDMP_SCSI_DATA_IN) {
        cmd.uscsi_flags = USCSI_READ | USCSI_RQENABLE;
        if ((cmd.uscsi_bufaddr =
            ndmp_malloc(request->datain_len)) == 0) {
            reply.error = NDMP_NO_MEM_ERR;
            if (ndmp_send_response(session->ns_connection,
                NDMP_NO_ERR, (void *)&reply) < 0)
                NDMP_LOG(LOG_DEBUG, "error sending"
                    " scsi_execute_cdb reply.");
            return;
        }

        cmd.uscsi_buflen = request->datain_len;
        cmd.uscsi_rqlen = sizeof (rq_buf);
        cmd.uscsi_rqbuf = rq_buf;
    } else if (request->flags == NDMP_SCSI_DATA_OUT) {
        cmd.uscsi_flags = USCSI_WRITE;
        cmd.uscsi_bufaddr = request->dataout.dataout_val;
        cmd.uscsi_buflen = request->dataout.dataout_len;
    } else {
        cmd.uscsi_flags = USCSI_RQENABLE;
        cmd.uscsi_bufaddr = 0;
        cmd.uscsi_buflen = 0;
        cmd.uscsi_rqlen = sizeof (rq_buf);
        cmd.uscsi_rqbuf = rq_buf;
    }

    cmd.uscsi_timeout = (request->timeout < 1000) ?
        1 : (request->timeout / 1000);

    cmd.uscsi_cdb = (caddr_t)request->cdb.cdb_val;
    cmd.uscsi_cdblen = request->cdb.cdb_len;

    NDMP_LOG(LOG_DEBUG, "cmd: 0x%x, len: %d, flags: %d, datain_len: %d",
        request->cdb.cdb_val[0] & 0xff, request->cdb.cdb_len,
        request->flags, request->datain_len);
    NDMP_LOG(LOG_DEBUG, "dataout_len: %d, timeout: %d",
        request->dataout.dataout_len, request->timeout);

    if (request->cdb.cdb_len > 12) {
        reply.error = NDMP_ILLEGAL_ARGS_ERR;
        ndmp_send_reply(session->ns_connection, (void *) &reply,
            "sending execute_cdb reply");
        if (request->flags == NDMP_SCSI_DATA_IN)
            free(cmd.uscsi_bufaddr);
        return;
    }

    reply.error = NDMP_NO_ERR;

    if ((olp = ndmp_open_list_find(adapter_name, sid, lun)) != NULL) {
        fd = olp->ol_fd;
    } else {
        reply.error = NDMP_DEV_NOT_OPEN_ERR;
        ndmp_send_reply(session->ns_connection, (void *) &reply,
            "sending execute_cdb reply");
        if (request->flags == NDMP_SCSI_DATA_IN)
            free(cmd.uscsi_bufaddr);
        return;
    }

    if (ioctl(fd, USCSICMD, &cmd) < 0) {
        NDMP_LOG(LOG_ERR, "Failed to send command to device: %m");
        NDMP_LOG(LOG_DEBUG, "ioctl(USCSICMD) error: %m");
        if (cmd.uscsi_status == 0)
            reply.error = NDMP_IO_ERR;
    }

    reply.status = cmd.uscsi_status;

    if (request->flags == NDMP_SCSI_DATA_IN) {
        reply.datain.datain_len = cmd.uscsi_buflen;
        reply.datain.datain_val = cmd.uscsi_bufaddr;
    } else {
        reply.dataout_len = request->dataout.dataout_len;
    }

    reply.ext_sense.ext_sense_len = cmd.uscsi_rqlen - cmd.uscsi_rqresid;
    reply.ext_sense.ext_sense_val = rq_buf;

    if (ndmp_send_response(session->ns_connection, NDMP_NO_ERR,
        (void *)&reply) < 0)
        NDMP_LOG(LOG_DEBUG, "Error sending scsi_execute_cdb reply.");

    if (request->flags == NDMP_SCSI_DATA_IN)
        free(cmd.uscsi_bufaddr);
}


/*
 * ndmp_stop_local_reader
 *
 * Stops a mover reader thread (for local backup only)
 *
 * Parameters:
 *   session (input) - session pointer
 *   cmds (input) - reader/writer command struct
 *
 * Returns:
 *   void
 */
void
ndmp_stop_local_reader(ndmpd_session_t *session, tlm_commands_t *cmds)
{
    if (session != NULL) {
        if (session->ns_data.dd_sock == -1) {
            /*
             * 2-way restore.
             */
            NDMP_LOG(LOG_DEBUG, "2-way restore");
            if (cmds != NULL && cmds->tcs_reader_count > 0) {
                nlp_event_rv_set(session, -2);
                nlp_event_nw(session);
            }
        }
    }
}


/*
 * Stops a mover reader thread (for remote backup only)
 *
 * Parameters:
 *   session (input) - session pointer
 *   cmds (input) - reader/writer command struct
 *
 * Returns:
 *   void
 */
void
ndmp_stop_remote_reader(ndmpd_session_t *session)
{
    if (session != NULL) {
        if (session->ns_data.dd_sock >= 0) {
            /*
             * 3-way restore.
             */
            NDMP_LOG(LOG_DEBUG,
                "data.sock: %d", session->ns_data.dd_sock);
            (void) close(session->ns_data.dd_sock);
            session->ns_data.dd_sock = -1;
        }
    }
}


/*
 * ndmp_wait_for_reader
 *
 * Wait for a reader until get done (busy wait)
 */
void
ndmp_wait_for_reader(tlm_commands_t *cmds)
{
    if (cmds == NULL) {
        NDMP_LOG(LOG_DEBUG, "cmds == NULL");
    } else {
        NDMP_LOG(LOG_DEBUG,
            "reader_count: %d", cmds->tcs_reader_count);

        while (cmds->tcs_reader_count > 0)
            (void) sleep(1);
    }
}


/*
 * ndmp_open_list_find
 *
 * Find a specific device in the open list
 *
 * Parameters:
 *   dev (input) - device name
 *   sid (input) - SCSI target ID
 *   lun (input) - LUN number
 *
 * Returns:
 *   pointer to the open list entry
 */
struct open_list *
ndmp_open_list_find(char *dev, int sid, int lun)
{
    struct ol_head *olhp;
    struct open_list *olp;

    if (dev == NULL || *dev == '\0') {
        NDMP_LOG(LOG_DEBUG, "Invalid argument");
        return (NULL);
    }

    (void) mutex_lock(&ol_mutex);
    olhp = &ol_head;
    for (olp = LIST_FIRST(olhp); olp != NULL; olp = LIST_NEXT(olp, ol_q))
        if (strcmp(olp->ol_devnm, dev) == 0 && olp->ol_sid == sid &&
            olp->ol_lun == lun) {
            (void) mutex_unlock(&ol_mutex);
            return (olp);
        }

    (void) mutex_unlock(&ol_mutex);
    return (NULL);
}


/*
 * ndmp_open_list_add
 *
 * Add a specific device to the open list
 *
 * Parameters:
 *   conn (input) - connection pointer
 *   dev (input) - device name
 *   sid (input) - SCSI target ID
 *   lun (input) - LUN number
 *   fd (input) - the device file descriptor
 *
 * Returns:
 *   errno
 */
int
ndmp_open_list_add(ndmp_connection_t *conn, char *dev, int sid, int lun, int fd)
{
    int err;
    struct ol_head *olhp;
    struct open_list *olp;

    if (dev == NULL || *dev == '\0') {
        NDMP_LOG(LOG_DEBUG, "Invalid argument");
        return (EINVAL);
    }
    NDMP_LOG(LOG_DEBUG,
        "conn: 0x%08x, dev: %s, sid: %d, lun: %d", conn, dev, sid, lun);

    err = 0;
    olhp = &ol_head;

    if ((olp = ndmp_open_list_find(dev, sid, lun)) != NULL) {
        NDMP_LOG(LOG_DEBUG, "already in list");
        /*
         * The adapter handle can be opened many times by the clients.
         * Only when the target is set, we must check and reject the
         * open request if the device is already being used by another
         * session.
         */
        if (sid == -1)
            olp->ol_nref++;
        else
            err = EBUSY;
    } else if ((olp = ndmp_malloc(sizeof (struct open_list))) == NULL) {
        err = ENOMEM;
    } else if ((olp->ol_devnm = strdup(dev)) == NULL) {
        NDMP_LOG(LOG_ERR, "Out of memory.");
        free(olp);
        err = ENOMEM;
    } else {
        olp->cl_conn = conn;
        olp->ol_nref = 1;
        olp->ol_sid = sid;
        olp->ol_lun = lun;
        if (fd > 0)
            olp->ol_fd = fd;
        else
            olp->ol_fd = -1;
        (void) mutex_lock(&ol_mutex);
        LIST_INSERT_HEAD(olhp, olp, ol_q);
        (void) mutex_unlock(&ol_mutex);
    }

    return (err);
}


/*
 * ndmp_open_list_del
 *
 * Delete a specific device from the open list
 *
 * Parameters:
 *   dev (input) - device name
 *   sid (input) - SCSI target ID
 *   lun (input) - LUN number
 *
 * Returns:
 *   errno
 */
int
ndmp_open_list_del(char *dev, int sid, int lun)
{
    struct open_list *olp;

    if (dev == NULL || *dev == '\0') {
        NDMP_LOG(LOG_DEBUG, "Invalid argument");
        return (EINVAL);
    }
    if ((olp = ndmp_open_list_find(dev, sid, lun)) == NULL) {
        NDMP_LOG(LOG_DEBUG, "%s not found", dev);
        return (ENOENT);
    }

    (void) mutex_lock(&ol_mutex);
    if (--olp->ol_nref <= 0) {
        NDMP_LOG(LOG_DEBUG,
            "Removed dev: %s, sid: %d, lun: %d", dev, sid, lun);
        LIST_REMOVE(olp, ol_q);
        free(olp->ol_devnm);
        free(olp);
    }
    (void) mutex_unlock(&ol_mutex);

    return (0);
}


/*
 * ndmp_open_list_release
 *
 * Close all the resources belonging to this connection.
 *
 * Parameters:
 *    ndmp_connection_t *conn : connection identifier
 *
 * Returns:
 *   void
 */
void
ndmp_open_list_release(ndmp_connection_t *conn)
{
    struct ol_head *olhp = &ol_head;
    struct open_list *olp;
    struct open_list *next;

    (void) mutex_lock(&ol_mutex);
    olp = LIST_FIRST(olhp);
    while (olp != NULL) {
        next = LIST_NEXT(olp, ol_q);
        NDMP_LOG(LOG_DEBUG, "olp->conn 0x%08x", olp->cl_conn);
        if (olp->cl_conn == conn) {
            NDMP_LOG(LOG_DEBUG,
                "Removed dev: %s, sid: %d, lun: %d",
                olp->ol_devnm, olp->ol_sid, olp->ol_lun);
            LIST_REMOVE(olp, ol_q);
            if (olp->ol_fd > 0)
                (void) close(olp->ol_fd);
            free(olp->ol_devnm);
            free(olp);
        }
        olp = next;
    }
    (void) mutex_unlock(&ol_mutex);
}


/*
 * ndmp_stop_buffer_worker
 *
 * Stop all reader and writer threads for a specific buffer.
 *
 * Parameters:
 *   session (input) - session pointer
 *
 * Returns:
 *   void
 */
void
ndmp_stop_buffer_worker(ndmpd_session_t *session)
{
    ndmp_lbr_params_t *nlp;
    tlm_commands_t *cmds;

    session->ns_tape.td_pos = 0;
    if ((nlp = ndmp_get_nlp(session)) == NULL) {
        NDMP_LOG(LOG_DEBUG, "nlp == NULL");
    } else {
        cmds = &nlp->nlp_cmds;
        if (cmds->tcs_command == NULL) {
            NDMP_LOG(LOG_DEBUG, "cmds->tcs_command == NULL");
        } else {
            cmds->tcs_reader = cmds->tcs_writer = TLM_ABORT;
            cmds->tcs_command->tc_reader = TLM_ABORT;
            cmds->tcs_command->tc_writer = TLM_ABORT;
            while (cmds->tcs_reader_count > 0 ||
                cmds->tcs_writer_count > 0) {
                NDMP_LOG(LOG_DEBUG,
                    "trying to stop buffer worker");
                (void) sleep(1);
            }
        }
    }
}


/*
 * ndmp_stop_reader_thread
 *
 * Stop only the reader threads of a specific buffer
 *
 * Parameters:
 *   session (input) - session pointer
 *
 * Returns:
 *   void
 */
void
ndmp_stop_reader_thread(ndmpd_session_t *session)
{
    ndmp_lbr_params_t *nlp;
    tlm_commands_t *cmds;

    if ((nlp = ndmp_get_nlp(session)) == NULL) {
        NDMP_LOG(LOG_DEBUG, "nlp == NULL");
    } else {
        cmds = &nlp->nlp_cmds;
        if (cmds->tcs_command == NULL) {
            NDMP_LOG(LOG_DEBUG, "cmds->tcs_command == NULL");
        } else {
            cmds->tcs_reader = TLM_ABORT;
            cmds->tcs_command->tc_reader = TLM_ABORT;
            while (cmds->tcs_reader_count > 0) {
                NDMP_LOG(LOG_DEBUG,
                    "trying to stop reader thread");
                (void) sleep(1);
            }
        }
    }
}


/*
 * ndmp_stop_reader_thread
 *
 * Stop only the writer threads of a specific buffer
 *
 * Parameters:
 *   session (input) - session pointer
 *
 * Returns:
 *   void
 */
void
ndmp_stop_writer_thread(ndmpd_session_t *session)
{
    ndmp_lbr_params_t *nlp;
    tlm_commands_t *cmds;

    if ((nlp = ndmp_get_nlp(session)) == NULL) {
        NDMP_LOG(LOG_DEBUG, "nlp == NULL");
    } else {
        cmds = &nlp->nlp_cmds;
        if (cmds->tcs_command == NULL) {
            NDMP_LOG(LOG_DEBUG, "cmds->tcs_command == NULL");
        } else {
            cmds->tcs_writer = TLM_ABORT;
            cmds->tcs_command->tc_writer = TLM_ABORT;
            while (cmds->tcs_writer_count > 0) {
                NDMP_LOG(LOG_DEBUG,
                    "trying to stop writer thread");
                (void) sleep(1);
            }
        }
    }
}


/*
 * ndmp_free_reader_writer_ipc
 *
 * Free and release the reader/writer buffers and the IPC structure
 * for reader and writer threads.
 *
 * Parameters:
 *   session (input) - session pointer
 *
 * Returns:
 *   void
 */
void
ndmp_free_reader_writer_ipc(ndmpd_session_t *session)
{
    ndmp_lbr_params_t *nlp;
    tlm_commands_t *cmds;

    if ((nlp = ndmp_get_nlp(session)) != NULL) {
        cmds = &nlp->nlp_cmds;
        if (cmds->tcs_command != NULL) {
            NDMP_LOG(LOG_DEBUG, "cmds->tcs_command->tc_ref: %d",
                cmds->tcs_command->tc_ref);
            tlm_release_reader_writer_ipc(cmds->tcs_command);
        }
    }
}


/*
 * ndmp_waitfor_op
 *
 * Wait for a session reference count to drop to zero
 *
 * Parameters:
 *   session (input) - session pointer
 *
 * Returns:
 *   void
 */
void
ndmp_waitfor_op(ndmpd_session_t *session)
{
    if (session != NULL) {
        while (session->ns_nref > 0) {
            (void) sleep(1);
            NDMP_LOG(LOG_DEBUG,
                "waiting for session nref: %d", session->ns_nref);
        }
    }
}


/*
 * ndmp_session_ref
 *
 * Increment the reference count of the session
 *
 * Parameters:
 *   session (input) - session pointer
 *
 * Returns:
 *   void
 */
void
ndmp_session_ref(ndmpd_session_t *session)
{
    (void) mutex_lock(&session->ns_lock);
    session->ns_nref++;
    (void) mutex_unlock(&session->ns_lock);
}


/*
 * ndmp_session_unref
 *
 * Decrement the reference count of the session
 *
 * Parameters:
 *   session (input) - session pointer
 *
 * Returns:
 *   void
 */
void
ndmp_session_unref(ndmpd_session_t *session)
{
    (void) mutex_lock(&session->ns_lock);
    session->ns_nref--;
    (void) mutex_unlock(&session->ns_lock);
}


/*
 * ndmp_addr2str_v3
 *
 * Convert the address type to a string
 *
 * Parameters:
 *   type (input) - address type
 *
 * Returns:
 *   type in string
 */
char *
ndmp_addr2str_v3(ndmp_addr_type type)
{
    char *rv;

    switch (type) {
    case NDMP_ADDR_LOCAL:
        rv = "Local";
        break;
    case NDMP_ADDR_TCP:
        rv = "TCP";
        break;
    case NDMP_ADDR_FC:
        rv = "FC";
        break;
    case NDMP_ADDR_IPC:
        rv = "IPC";
        break;
    default:
        rv = "Unknown";
    }

    return (rv);
}


/*
 * ndmp_valid_v3addr_type
 *
 * Make sure that the NDMP address is from any of the
 * valid types
 *
 * Parameters:
 *   type (input) - address type
 *
 * Returns:
 *   1: valid
 *   0: invalid
 */
boolean_t
ndmp_valid_v3addr_type(ndmp_addr_type type)
{
    boolean_t rv;

    switch (type) {
    case NDMP_ADDR_LOCAL:
    case NDMP_ADDR_TCP:
    case NDMP_ADDR_FC:
    case NDMP_ADDR_IPC:
        rv = TRUE;
        break;
    default:
        rv = FALSE;
    }

    return (rv);
}


/*
 * ndmp_copy_addr_v3
 *
 * Copy NDMP address from source to destination (V2 and V3 only)
 *
 * Parameters:
 *   dst (ouput) - destination address
 *   src (input) - source address
 *
 * Returns:
 *   void
 */
void
ndmp_copy_addr_v3(ndmp_addr_v3 *dst, ndmp_addr_v3 *src)
{
    dst->addr_type = src->addr_type;
    switch (src->addr_type) {
    case NDMP_ADDR_LOCAL:
        /* nothing */
        break;
    case NDMP_ADDR_TCP:
        dst->tcp_ip_v3 = htonl(src->tcp_ip_v3);
        dst->tcp_port_v3 = src->tcp_port_v3;
        break;
    case NDMP_ADDR_FC:
    case NDMP_ADDR_IPC:
    default:
        break;
    }
}


/*
 * ndmp_copy_addr_v4
 *
 * Copy NDMP address from source to destination. V4 has a extra
 * environment list inside the address too which needs to be copied.
 *
 * Parameters:
 *   dst (ouput) - destination address
 *   src (input) - source address
 *
 * Returns:
 *   void
 */
void
ndmp_copy_addr_v4(ndmp_addr_v4 *dst, ndmp_addr_v4 *src)
{
    int i;

    dst->addr_type = src->addr_type;
    dst->tcp_len_v4 = src->tcp_len_v4;
    switch (src->addr_type) {
    case NDMP_ADDR_LOCAL:
        /* nothing */
        break;
    case NDMP_ADDR_TCP:
        dst->tcp_addr_v4 = ndmp_malloc(sizeof (ndmp_tcp_addr_v4) *
            src->tcp_len_v4);
        if (dst->tcp_addr_v4 == 0)
            return;

        for (i = 0; i < src->tcp_len_v4; i++) {
            dst->tcp_ip_v4(i) = htonl(src->tcp_ip_v4(i));
            dst->tcp_port_v4(i) = src->tcp_port_v4(i);
            dst->tcp_env_v4(i).addr_env_len = 0; /* Solaris */
            dst->tcp_env_v4(i).addr_env_val = 0; /* Solaris */
        }
        break;
    case NDMP_ADDR_FC:
    case NDMP_ADDR_IPC:
    default:
        break;
    }
}


/*
 * ndmp_connect_sock_v3
 *
 * Creates a socket and connects to the specified address/port
 *
 * Parameters:
 *   addr (input) - IP address
 *   port (input) - port number
 *
 * Returns:
 *   0: on success
 *  -1: otherwise
 */
int
ndmp_connect_sock_v3(ulong_t addr, ushort_t port)
{
    int sock;
    struct sockaddr_in sin;
    int flag = 1;

    NDMP_LOG(LOG_DEBUG, "addr %s:%d", inet_ntoa(IN_ADDR(addr)), port);

    sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        NDMP_LOG(LOG_DEBUG, "Socket error: %m");
        return (-1);
    }

    (void) memset((void *) &sin, 0, sizeof (sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = htonl(addr);
    sin.sin_port = htons(port);
    if (connect(sock, (struct sockaddr *)&sin, sizeof (sin)) < 0) {
        NDMP_LOG(LOG_DEBUG, "Connect error: %m");
        (void) close(sock);
        sock = -1;
    } else {
        if (ndmp_sbs > 0)
            ndmp_set_socket_snd_buf(sock, ndmp_sbs*KILOBYTE);
        if (ndmp_rbs > 0)
            ndmp_set_socket_rcv_buf(sock, ndmp_rbs*KILOBYTE);

        ndmp_set_socket_nodelay(sock);
        (void) setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &flag,
            sizeof (flag));

        NDMP_LOG(LOG_DEBUG, "sock %d", sock);
    }

    return (sock);
}

/*
 * ndmp_create_socket
 *
 * Creates a socket for listening for accepting data connections.
 *
 * Parameters:
 *   session (input)  - session pointer.
 *   addr    (output) - location to store address of socket.
 *   port    (output) - location to store port of socket.
 *
 * Returns:
 *   0 - success.
 *  -1 - error.
 */
int
ndmp_create_socket(ulong_t *addr, ushort_t *port)
{
    char *p;
    int length;
    int sd;
    struct sockaddr_in sin;

    p = ndmpd_get_prop(NDMP_MOVER_NIC);

    if (!p || *p == 0)
        p = gethostaddr();

    if (!p) {
        NDMP_LOG(LOG_ERR, "Undetermined network port.");
        return (-1);
    }

    *addr = inet_addr(p);

    sd = socket(AF_INET, SOCK_STREAM, 0);
    if (sd < 0) {
        NDMP_LOG(LOG_DEBUG, "Socket error: %m");
        return (-1);
    }
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = INADDR_ANY;
    sin.sin_port = 0;
    length = sizeof (sin);

    if (bind(sd, (struct sockaddr *)&sin, sizeof (sin)) < 0) {
        NDMP_LOG(LOG_DEBUG, "Bind error: %m");
        (void) close(sd);
        sd = -1;
    } else if (getsockname(sd, (struct sockaddr *)&sin, &length) < 0) {
        NDMP_LOG(LOG_DEBUG, "getsockname error: %m");
        (void) close(sd);
        sd = -1;
    } else if (listen(sd, 5) < 0) {
        NDMP_LOG(LOG_DEBUG, "Listen error: %m");
        (void) close(sd);
        sd = -1;
    } else
        *port = sin.sin_port;

    return (sd);
}


/*
 * cctime
 *
 * Convert the specified time into a string.  It's like
 * ctime(), but:
 *     - chops the trailing '\n' of ctime.
 *     - and returns "the epoch" if time is 0.
 *
 * Returns:
 *     "": invalid argument.
 *     "the epoch": if time is 0.
 *     string format of the time.
 */
char *
cctime(time_t *t)
{
    char *bp, *cp;
    static char tbuf[BUFSIZ];

    if (!t)
        return ("");

    if (*t == (time_t)0)
        return ("the epoch");

    if ((bp = ctime_r(t, tbuf, BUFSIZ)) == NULL)
        return ("");

    cp = strchr(bp, '\n');
    if (cp)
        *cp = '\0';

    return (bp);
}


/*
 * ndmp_new_job_name
 *
 * Create a job name for each backup/restore to keep track
 *
 * Parameters:
 *   jname (output) - job name
 *
 * Returns:
 *   jname
 */
char *
ndmp_new_job_name(char *jname)
{
    if (jname != NULL) {
        (void) snprintf(jname, TLM_MAX_BACKUP_JOB_NAME, "%s%d",
            NDMP_RCF_BASENAME, ndmp_job_cnt++);
        NDMP_LOG(LOG_DEBUG, "jname: \"%s\"", jname);
    }

    return (jname);
}


/*
 * fs_is_valid_logvol
 *
 * Check if the log path exists
 *
 * Parameters:
 *   path (input) - log path
 *
 * Returns:
 *   FALSE: invalid
 *   TRUE: valid
 */
boolean_t
fs_is_valid_logvol(char *path)
{
    struct stat64 st;

    if (stat64(path, &st) < 0)
        return (FALSE);

    return (TRUE);
}


/*
 * ndmpd_mk_temp
 *
 * Make a temporary file using the working directory path and the
 * jobname
 *
 * Parameters:
 *   buf (output) - the temporary file name path
 *
 * Returns:
 *   buf
 */
char *
ndmpd_mk_temp(char *buf)
{
    char fname[TLM_MAX_BACKUP_JOB_NAME];
    const char *dir;
    char *rv;

    if (!buf)
        return (NULL);

    dir = ndmpd_get_prop(NDMP_DEBUG_PATH);
    if (dir == 0 || *dir == '\0') {
        NDMP_LOG(LOG_DEBUG, "NDMP work path not specified");
        return (0);
    }

    if (!fs_is_valid_logvol((char *)dir)) {
        NDMP_LOG(LOG_ERR,
            "Log file path cannot be on system volumes.");
        return (0);
    }

    dir += strspn(dir, " \t");
    if (!*dir) {
        NDMP_LOG(LOG_DEBUG, "NDMP work path not specified");
        return (0);
    }

    rv = buf;
    (void) ndmp_new_job_name(fname);
    (void) tlm_cat_path(buf, (char *)dir, fname);

    return (rv);
}


/*
 * ndmpd_make_bk_dir_path
 *
 * Make a directory path for temporary files under the NDMP
 * working directory.
 *
 * Parameters:
 *   buf (output) - result path
 *   fname (input) - the file name
 *
 * Returns:
 *   buf
 */
char *
ndmpd_make_bk_dir_path(char *buf, char *fname)
{
    const char *p;
    char *name;
    char path[PATH_MAX];

    if (!buf || !fname || !*fname)
        return (NULL);

    p = ndmpd_get_prop(NDMP_DEBUG_PATH);
    if (p == NULL || *p == '\0' || !fs_is_valid_logvol((char *)p)) {
        return (NULL);
    }

    (void) strlcpy(path, (char *)p, PATH_MAX);
    (void) trim_whitespace(path);

    if ((name = strrchr(fname, '/')) == 0)
        name = fname;

    (void) tlm_cat_path(buf, path, name);
    return (buf);
}


/*
 * ndmp_is_chkpnt_root
 *
 * Is this a root checkpoint (snapshot) directory.
 * Note: a temporary function
 */
boolean_t
ndmp_is_chkpnt_root(char *path)
{
    struct stat64 st;

    if (stat64(path, &st) != 0) {
        NDMP_LOG(LOG_DEBUG, "Couldn't stat path \"%s\"", path);
        return (TRUE);
    }
    return (FALSE);
}


/*
 * ndmpd_make_exc_list
 *
 * Make a list of files that should not be backed up.
 *
 * Parameters:
 *   void
 *
 * Returns:
 *   list - array of character strings
 */
char **
ndmpd_make_exc_list(void)
{
    char *val, **cpp;
    int i, n;

    n = sizeof (exls);
    if ((cpp = ndmp_malloc(n)) != NULL) {
        for (i = 0; exls[i] != NULL; i++)
            cpp[i] = exls[i];

        /*
         * If ndmpd_get_prop returns NULL, the array will be
         * null-terminated.
         */
        val = ndmpd_get_prop(NDMP_DEBUG_PATH);
        cpp[i] = val;
    }

    return (cpp);
}


/*
 * ndmp_get_bk_dir_ino
 *
 * Get the inode number of the backup directory
 */
int
ndmp_get_bk_dir_ino(ndmp_lbr_params_t *nlp)
{
    int rv;
    struct stat64 st;

    if (stat64(nlp->nlp_backup_path, &st) != 0) {
        rv = -1;
        NDMP_LOG(LOG_DEBUG, "Getting inode # of \"%s\"",
            nlp->nlp_backup_path);
    } else {
        rv = 0;
        nlp->nlp_bkdirino = st.st_ino;
        NDMP_LOG(LOG_DEBUG, "nlp_bkdirino: %lu",
            (uint_t)nlp->nlp_bkdirino);
    }

    return (rv);
}


/*
 * ndmp_check_utf8magic
 *
 * Check if the magic string for exists in the tar header. This
 * magic string (which also indicates that the file names are in
 * UTF8 format) is used as a crest to indetify our own tapes.
 * This checking is always done before all restores except DAR
 * restores.
 */
boolean_t
ndmp_check_utf8magic(tlm_cmd_t *cmd)
{
    char *cp;
    int err, len, actual_size;

    if (cmd == NULL) {
        NDMP_LOG(LOG_DEBUG, "cmd == NULL");
        return (FALSE);
    }
    if (cmd->tc_buffers == NULL) {
        NDMP_LOG(LOG_DEBUG, "cmd->tc_buffers == NULL");
        return (FALSE);
    }

    /* wait until the first buffer gets full. */
    tlm_buffer_in_buf_wait(cmd->tc_buffers);

    err = actual_size = 0;
    cp = tlm_get_read_buffer(RECORDSIZE, &err, cmd->tc_buffers,
        &actual_size);
    if (cp == NULL) {
        NDMP_LOG(LOG_DEBUG, "Can't read from buffers, err: %d", err);
        return (FALSE);
    }
    len = strlen(NDMPUTF8MAGIC);
    if (actual_size < len) {
        NDMP_LOG(LOG_DEBUG, "Not enough data in the buffers");
        return (FALSE);
    }

    return ((strncmp(cp, NDMPUTF8MAGIC, len) == 0) ? TRUE : FALSE);
}


/*
 * ndmp_get_cur_bk_time
 *
 * Get the backup checkpoint time.
 */
int
ndmp_get_cur_bk_time(ndmp_lbr_params_t *nlp, time_t *tp, char *jname)
{
    int err;

    if (!nlp || !nlp->nlp_backup_path || !tp) {
        NDMP_LOG(LOG_DEBUG, "Invalid argument");
        return (-1);
    }

    if (!fs_is_chkpnt_enabled(nlp->nlp_backup_path)) {
        NDMP_LOG(LOG_DEBUG, "Not a chkpnt volume %s",
            nlp->nlp_backup_path);
        *tp = time(NULL);
        return (0);
    }

    err = tlm_get_chkpnt_time(nlp->nlp_backup_path, !NLP_ISCHKPNTED(nlp),
        tp, jname);
    if (err != 0) {
        NDMP_LOG(LOG_DEBUG, "Can't checkpoint time");
    } else {
        NDMP_LOG(LOG_DEBUG, "%s", cctime(tp));
    }

    return (err);
}


/*
 * get_relative_path
 */
char *
ndmp_get_relative_path(char *base, char *fullpath)
{
    char *p = fullpath;

    if (!base || !*base)
        return (fullpath);

    while (*base) {
        if (*base != *p)
            break;
        p++; base++;
    }

    if (*p == '/')
        p++;

    return ((*base) ? fullpath : p);
}


/*
 * ndmp_get_nlp
 *
 * Get NDMP local backup parameters
 *
 * Parameter:
 *   session cooke
 *
 * Returns:
 *   LBR structure
 */
ndmp_lbr_params_t *
ndmp_get_nlp(void *cookie)
{
    if (cookie == NULL)
        return (NULL);

    return (((ndmpd_session_t *)cookie)->ns_ndmp_lbr_params);
}


/*
 * is_tape_unit_ready
 *
 * Check if the tape device is ready or not
 */
boolean_t
is_tape_unit_ready(char *adptnm, int dev_id)
{
    int try;
    int fd = 0;

    try = TUR_MAX_TRY;
    if (dev_id <= 0) {
        if ((fd = open(adptnm, O_RDONLY | O_NDELAY)) < 0)
            return (FALSE);
    } else {
        fd = dev_id;
    }
    do {
        if (scsi_test_unit_ready(fd) >= 0) {
            NDMP_LOG(LOG_DEBUG, "Unit is ready");

            if (dev_id <= 0)
                (void) close(fd);

            return (TRUE);
        }

        NDMP_LOG(LOG_DEBUG, "Unit not ready");
        (void) usleep(TUR_WAIT);

    } while (--try > 0);

    if (dev_id <= 0)
        (void) close(fd);

    NDMP_LOG(LOG_DEBUG, "Unit didn't get ready");
    return (FALSE);
}


/*
 * scsi_test_unit_ready
 *
 * This is for Test Unit Read, without this function, the only
 * impact is getting EBUSY's before each operation which we have
 * busy waiting loops checking EBUSY error code.
 */
static int
scsi_test_unit_ready(int dev_id)
{
    struct uscsi_cmd ucmd;
    union scsi_cdb cdb;
    int retval;

    (void) memset(&ucmd, 0, sizeof (struct uscsi_cmd));
    (void) memset(&cdb, 0, sizeof (union scsi_cdb));
    cdb.scc_cmd = SCMD_TEST_UNIT_READY;
    ucmd.uscsi_cdb = (caddr_t)&cdb;
    ucmd.uscsi_cdblen = CDB_GROUP0;
    ucmd.uscsi_flags |= USCSI_SILENT;
    ucmd.uscsi_timeout = 60;    /* Allow maximum 1 min */

    retval = ioctl(dev_id, USCSICMD, &ucmd);

    if (retval != 0 && errno != EIO) {
        NDMP_LOG(LOG_ERR,
            "Failed to send inquiry request to device: %m.");
        NDMP_LOG(LOG_DEBUG, "Inquiry request failed for"
            " dev_id:%d err=%d -%m", dev_id, errno);
        retval = -errno;
    } else
        retval = -(ucmd.uscsi_status);

    return (retval);
}


/*
 * ndmp_load_params
 *
 * Load the parameters.
 *
 * Parameter:
 *   void
 *
 * Returns:
 *   void
 */
void
ndmp_load_params(void)
{
    ndmp_dump_path_node = ndmpd_get_prop_yorn(NDMP_DUMP_PATHNODE_ENV) ?
        TRUE : FALSE;
    ndmp_tar_path_node = ndmpd_get_prop_yorn(NDMP_TAR_PATHNODE_ENV) ?
        TRUE : FALSE;
    ndmp_ignore_ctime =
        ndmpd_get_prop_yorn(NDMP_IGNCTIME_ENV) ? TRUE : FALSE;
    ndmp_include_lmtime = ndmpd_get_prop_yorn(NDMP_INCLMTIME_ENV) ?
        TRUE : FALSE;
    ndmp_max_tok_seq = atoi(ndmpd_get_prop_default(NDMP_MAXSEQ_ENV, "9"));

    ndmp_full_restore_path = ndmpd_get_prop_yorn(NDMP_FULL_RESTORE_PATH) ?
        TRUE : FALSE;

    ndmp_fhinode = ndmpd_get_prop_yorn(NDMP_FHIST_INCR_ENV) ? TRUE : FALSE;

    /* Get the value from ndmp SMF property. */
    ndmp_dar_support = ndmpd_get_prop_yorn(NDMP_DAR_SUPPORT);

    if ((ndmp_ver = atoi(ndmpd_get_prop(NDMP_VERSION_ENV))) == 0)
        ndmp_ver = NDMPVER;
}

/*
 * randomize
 *
 * Randomize the contents of a buffer
 *
 * Parameter:
 *   buffer (output) - destination buffer
 *   size (input) - buffer size
 *
 * Returns:
 *   void
 */
void
randomize(unsigned char *buffer, int size)
{
    /* LINTED improper alignment */
    unsigned int *p = (unsigned int *)buffer;
    unsigned int dwlen = size / sizeof (unsigned int);
    unsigned int remlen = size % sizeof (unsigned int);
    unsigned int tmp;
    unsigned int i;

    for (i = 0; i < dwlen; i++)
        *p++ = random();

    if (remlen) {
        tmp = random();
        (void) memcpy(p, &tmp, remlen);
    }
}

/*
 * ndmpd_get_file_entry_type
 *
 * Converts the mode to the NDMP file type
 *
 * Parameter:
 *   mode (input) - file mode
 *   ftype (output) - file type
 *
 * Returns:
 *   void
 */
void
ndmpd_get_file_entry_type(int mode, ndmp_file_type *ftype)
{
    switch (mode & S_IFMT) {
    case S_IFIFO:
        *ftype = NDMP_FILE_FIFO;
        break;
    case S_IFCHR:
        *ftype = NDMP_FILE_CSPEC;
        break;
    case S_IFDIR:
        *ftype = NDMP_FILE_DIR;
        break;
    case S_IFBLK:
        *ftype = NDMP_FILE_BSPEC;
        break;
    case S_IFREG:
        *ftype = NDMP_FILE_REG;
        break;
    case S_IFLNK:
        *ftype = NDMP_FILE_SLINK;
        break;
    default:
        *ftype = NDMP_FILE_SOCK;
        break;
    }
}

/*
 * Set a private data in the plugin context
 */
void
ndmp_context_set_specific(ndmp_context_t *nctx, void *ptr)
{
    nctx->nc_pldata = ptr;
}

/*
 * Get a private data in the plugin context
 */
void *
ndmp_context_get_specific(ndmp_context_t *nctx)
{
    return (nctx->nc_pldata);
}