/*
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2014 Nexenta Systems, Inc.  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 <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/uio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <libinetutil.h>
#include "ndmpd.h"
#include "ndmpd_common.h"

#define NDMP_PROC_ERR   -1
#define NDMP_PROC_MSG   1
#define NDMP_PROC_REP   0
#define NDMP_PROC_REP_ERR       2

/*
 * The ndmp connection version can be set through command line. If command line
 * is not specified it will be set from the ndmp SMF version property.
 */
int ndmp_ver = 0;

/*
 * The NDMP listening port number
 */
int ndmp_port = 0;

/*
 * Restore path mechanism definition
 * 0 means partial path restore and
 * 1 means full path restore.
 * Refer to NDMP_FULL_RESTORE_PATH for partial path and full path definition.
 */
int ndmp_full_restore_path = 1;

/*
 * Do we support Direct Access Restore?
 */
int ndmp_dar_support = 0;

/*
 * ndmp_connection_t handler function
 */
static ndmpd_file_handler_func_t connection_file_handler;

extern ndmp_handler_t ndmp_msghdl_tab[];

static int ndmp_readit(void *connection_handle,
    caddr_t buf,
    int len);
static int ndmp_writeit(void *connection_handle,
    caddr_t buf,
    int len);
static int ndmp_recv_msg(ndmp_connection_t *connection);
static int ndmp_process_messages(ndmp_connection_t *connection,
    boolean_t reply_expected);
static ndmp_msg_handler_t *ndmp_get_handler(ndmp_connection_t *connection,
    ndmp_message message);
static boolean_t ndmp_check_auth_required(ndmp_message message);
static ndmp_handler_t *ndmp_get_interface(ndmp_message message);
void *ndmpd_worker(void *ptarg);

#ifdef  lint
bool_t
xdr_ndmp_header(XDR *xdrs, ndmp_header *objp)
{
        xdrs = xdrs;
        objp = objp;
        return (0);
}
#endif  /* lint */

/*
 * ndmp_create_connection
 *
 * Allocate and initialize a connection structure.
 *
 * Parameters:
 *   handler_tbl (input) - message handlers.
 *
 * Returns:
 *   NULL - error
 *   connection pointer
 *
 * Notes:
 *   The returned connection should be destroyed using
 *   ndmp_destroy_connection().
 */
ndmp_connection_t *
ndmp_create_connection(void)
{
        ndmp_connection_t *connection;

        connection = ndmp_malloc(sizeof (ndmp_connection_t));
        if (connection == NULL)
                return (NULL);

        connection->conn_sock = -1;
        connection->conn_my_sequence = 0;
        connection->conn_authorized = FALSE;
        connection->conn_eof = FALSE;
        connection->conn_msginfo.mi_body = 0;
        connection->conn_version = ndmp_ver;
        connection->conn_client_data = 0;
        (void) mutex_init(&connection->conn_lock, 0, NULL);
        connection->conn_xdrs.x_ops = 0;

        xdrrec_create(&connection->conn_xdrs, 0, 0, (caddr_t)connection,
            ndmp_readit, ndmp_writeit);

        if (connection->conn_xdrs.x_ops == 0) {
                NDMP_LOG(LOG_DEBUG, "xdrrec_create failed");
                (void) mutex_destroy(&connection->conn_lock);
                (void) close(connection->conn_sock);
                free(connection);
                return (0);
        }
        return ((ndmp_connection_t *)connection);
}

/*
 * ndmp_destroy_connection
 *
 * Shutdown a connection and release allocated resources.
 *
 * Parameters:
 *   connection_handle (Input) - connection handle.
 *
 * Returns:
 *   void
 */
void
ndmp_destroy_connection(ndmp_connection_t *connection_handle)
{
        ndmp_connection_t *connection = (ndmp_connection_t *)connection_handle;

        if (connection->conn_sock >= 0) {
                (void) mutex_destroy(&connection->conn_lock);
                (void) close(connection->conn_sock);
                connection->conn_sock = -1;
        }
        xdr_destroy(&connection->conn_xdrs);
        free(connection);
}


/*
 * ndmp_close
 *
 * Close a connection.
 *
 * Parameters:
 *   connection_handle (Input) - connection handle.
 *
 * Returns:
 *   void
 */
void
ndmp_close(ndmp_connection_t *connection_handle)
{
        ndmp_connection_t *connection = (ndmp_connection_t *)connection_handle;

        ndmpd_audit_disconnect(connection);
        if (connection->conn_sock >= 0) {
                (void) mutex_destroy(&connection->conn_lock);
                (void) close(connection->conn_sock);
                connection->conn_sock = -1;
        }
        connection->conn_eof = TRUE;

        /*
         * We should close all the tapes that are used by this connection.
         * In some cases the ndmp client opens a tape, but does not close the
         * tape and closes the connection.
         */
        ndmp_open_list_release(connection_handle);
}

/*
 * ndmp_start_worker
 *
 * Initializes and starts a ndmp_worker thread
 */
int
ndmp_start_worker(ndmpd_worker_arg_t *argp)
{
        pthread_attr_t tattr;
        int rc;

        (void) pthread_attr_init(&tattr);
        (void) pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
        rc = pthread_create(NULL, &tattr, ndmpd_worker, (void *)argp);
        (void) pthread_attr_destroy(&tattr);
        return (rc);
}

/*
 * ndmp_run
 *
 * Creates a socket for listening and accepting connections
 * from NDMP clients.
 * Accepts connections and passes each connection to the connection
 * handler.
 *
 * Parameters:
 *   port (input)   -  NDMP server port.
 *                   If 0, the port number will be retrieved from
 *                   the network service database. If not found there,
 *                   the default NDMP port number (from ndmp.x)
 *                   will be used.
 *   handler (input) - connection handler function.
 *
 * Returns:
 *   This function normally never returns unless there's error.
 *   -1 : error
 *
 * Notes:
 *   This function does not return unless encountering an error
 *   related to the listen socket.
 */
int
ndmp_run(ulong_t port, ndmp_con_handler_func_t con_handler_func)
{
        int ns;
        int on;
        int server_socket;
        unsigned int ipaddr;
        struct sockaddr_in sin;
        ndmpd_worker_arg_t *argp;

        sin.sin_family = AF_INET;
        sin.sin_addr.s_addr = INADDR_ANY;
        sin.sin_port = htons(port);

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

        on = 1;
        (void) setsockopt(server_socket, SOL_SOCKET, SO_REUSEADDR,
            (char *)&on, sizeof (on));


        if (bind(server_socket, (struct sockaddr *)&sin, sizeof (sin)) < 0) {
                NDMP_LOG(LOG_DEBUG, "bind error: %m");
                (void) close(server_socket);
                return (-1);
        }
        if (listen(server_socket, 5) < 0) {
                NDMP_LOG(LOG_DEBUG, "listen error: %m");
                (void) close(server_socket);
                return (-1);
        }

        for (; ; ) {
                if ((ns = tcp_accept(server_socket, &ipaddr)) < 0) {
                        NDMP_LOG(LOG_DEBUG, "tcp_accept error: %m");
                        continue;
                }
                NDMP_LOG(LOG_DEBUG, "connection fd: %d", ns);
                set_socket_options(ns);

                if ((argp = ndmp_malloc(sizeof (ndmpd_worker_arg_t))) != NULL) {
                        argp->nw_sock = ns;
                        argp->nw_ipaddr = ipaddr;
                        argp->nw_con_handler_func = con_handler_func;
                        (void) ndmp_start_worker(argp);
                }
        }
}

/*
 * ndmpd_worker thread
 *
 * Parameters:
 *   argp (input) - structure containing socket and handler function
 *
 * Returns:
 *   0 - successful connection.
 *  -1 - error.
 */
void *
ndmpd_worker(void *ptarg)
{
        int sock;
        ndmp_connection_t *connection;
        ndmpd_worker_arg_t *argp = (ndmpd_worker_arg_t *)ptarg;

        if (!argp)
                return ((void *)-1);

        NS_INC(trun);
        sock = argp->nw_sock;

        if ((connection = ndmp_create_connection()) == NULL) {
                (void) close(sock);
                free(argp);
                exit(1);
        }

        /* initialize auditing session */
        if (adt_start_session(&connection->conn_ah, NULL, 0) != 0) {
                free(argp);
                return ((void *)-1);
        }

        ((ndmp_connection_t *)connection)->conn_sock = sock;
        (*argp->nw_con_handler_func)(connection);
        (void) adt_end_session(connection->conn_ah);
        ndmp_destroy_connection(connection);
        NS_DEC(trun);

        free(argp);
        return (NULL);
}

/*
 * ndmp_process_requests
 *
 * Reads the next request message into the stream buffer.
 * Processes messages until the stream buffer is empty.
 *
 * Parameters:
 *   connection_handle (input) - connection handle.
 *
 * Returns:
 *   0 - 1 or more messages successfully processed.
 *  -1 - error; connection no longer established.
 */
int
ndmp_process_requests(ndmp_connection_t *connection_handle)
{
        int rv;
        ndmp_connection_t *connection = (ndmp_connection_t *)connection_handle;

        (void) mutex_lock(&connection->conn_lock);
        rv = 0;
        if (ndmp_process_messages(connection, FALSE) < 0)
                rv = -1;

        (void) mutex_unlock(&connection->conn_lock);
        return (rv);
}


/*
 * ndmp_send_request
 *
 * Send an NDMP request message.
 *
 * Parameters:
 *   connection_handle (input) - connection pointer.
 *   message (input) - message number.
 *   err (input)  - error code to place in header.
 *   request_data (input) - message body.
 *   reply (output) - reply message. If 0, reply will be
 *                              discarded.
 *
 * Returns:
 *   0  - successful send.
 *  -1  - error.
 *   otherwise - error from reply header.
 *
 * Notes:
 *   - The reply body is only returned if the error code is NDMP_NO_ERR.
 */
int
ndmp_send_request(ndmp_connection_t *connection_handle, ndmp_message message,
    ndmp_error err, void *request_data, void **reply)
{
        ndmp_connection_t *connection = (ndmp_connection_t *)connection_handle;
        ndmp_header header;
        ndmp_msg_handler_t *handler;
        int r;
        struct timeval time;

        /* Lookup info necessary for processing this request. */
        if (!(handler = ndmp_get_handler(connection, message))) {
                NDMP_LOG(LOG_DEBUG, "Sending message 0x%x: not supported",
                    message);
                return (-1);
        }
        (void) gettimeofday(&time, 0);

        header.sequence = ++(connection->conn_my_sequence);
        header.time_stamp = time.tv_sec;
        header.message_type = NDMP_MESSAGE_REQUEST;
        header.message = message;
        header.reply_sequence = 0;
        header.error = err;

        connection->conn_xdrs.x_op = XDR_ENCODE;
        if (!xdr_ndmp_header(&connection->conn_xdrs, &header)) {
                NDMP_LOG(LOG_DEBUG,
                    "Sending message 0x%x: encoding request header", message);
                (void) xdrrec_endofrecord(&connection->conn_xdrs, 1);
                return (-1);
        }
        if (err == NDMP_NO_ERR && handler->mh_xdr_request && request_data) {
                if (!(*handler->mh_xdr_request)(&connection->conn_xdrs,
                    request_data)) {
                        NDMP_LOG(LOG_DEBUG,
                            "Sending message 0x%x: encoding request body",
                            message);
                        (void) xdrrec_endofrecord(&connection->conn_xdrs, 1);
                        return (-1);
                }
        }
        (void) xdrrec_endofrecord(&connection->conn_xdrs, 1);

        if (handler->mh_xdr_reply == 0) {
                NDMP_LOG(LOG_DEBUG, "handler->mh_xdr_reply == 0");
                return (0);
        }

        /*
         * Process messages until the reply to this request has been
         * processed.
         */
        for (; ; ) {
                r = ndmp_process_messages(connection, TRUE);

                /* connection error? */
                if (r < 0)
                        return (-1);

                /* no reply received? */
                if (r == 0)
                        continue;

                /* reply received? */
                if (r == 1) {
                        if (message !=
                            connection->conn_msginfo.mi_hdr.message) {
                                NDMP_LOG(LOG_DEBUG,
                                    "Received unexpected reply 0x%x",
                                    connection->conn_msginfo.mi_hdr.message);
                                ndmp_free_message(connection_handle);
                                return (-1);
                        }
                        if (reply != NULL)
                                *reply = connection->conn_msginfo.mi_body;
                        else
                                ndmp_free_message(connection_handle);

                        return (connection->conn_msginfo.mi_hdr.error);
                }
                /* error handling reply */

                return (-1);
        }
}


/*
 * ndmp_send_request_lock
 *
 * A wrapper for ndmp_send_request with locks.
 *
 * Parameters:
 *   connection_handle (input) - connection pointer.
 *   message (input) - message number.
 *   err (input) - error code to place in header.
 *   request_data (input) - message body.
 *   reply (output) - reply message. If 0, reply will be
 *                              discarded.
 *
 * Returns:
 *   0  - successful send.
 *  -1  - error.
 *   otherwise - error from reply header.
 *
 * Notes:
 *   - The reply body is only returned if the error code is NDMP_NO_ERR.
 */
int
ndmp_send_request_lock(ndmp_connection_t *connection_handle,
    ndmp_message message, ndmp_error err, void *request_data, void **reply)
{
        int rv;
        ndmp_connection_t *connection = (ndmp_connection_t *)connection_handle;

        (void) mutex_lock(&connection->conn_lock);

        rv = ndmp_send_request(connection_handle, message, err, request_data,
            reply);
        (void) mutex_unlock(&connection->conn_lock);
        return (rv);
}


/*
 * ndmp_send_response
 *
 * Send an NDMP reply message.
 *
 * Parameters:
 *   connection_handle  (input)  - connection pointer.
 *   err               (input)  - error code to place in header.
 *   reply           (input)  - reply message body.
 *
 * Returns:
 *   0 - successful send.
 *  -1 - error.
 *
 * Notes:
 *   - The body is only sent if the error code is NDMP_NO_ERR.
 */
int
ndmp_send_response(ndmp_connection_t *connection_handle, ndmp_error err,
    void *reply)
{
        ndmp_connection_t *connection = (ndmp_connection_t *)connection_handle;
        ndmp_header header;
        struct timeval time;

        (void) gettimeofday(&time, 0);

        header.sequence = ++(connection->conn_my_sequence);
        header.time_stamp = time.tv_sec;
        header.message_type = NDMP_MESSAGE_REPLY;
        header.message = connection->conn_msginfo.mi_hdr.message;
        header.reply_sequence = connection->conn_msginfo.mi_hdr.sequence;
        header.error = err;

        connection->conn_xdrs.x_op = XDR_ENCODE;
        if (!xdr_ndmp_header(&connection->conn_xdrs, &header)) {
                NDMP_LOG(LOG_DEBUG, "Sending message 0x%x: "
                    "encoding reply header",
                    header.message);
                (void) xdrrec_endofrecord(&connection->conn_xdrs, 1);
                return (-1);
        }
        if (err == NDMP_NO_ERR &&
            connection->conn_msginfo.mi_handler->mh_xdr_reply &&
            reply) {
                if (!(*connection->conn_msginfo.mi_handler->mh_xdr_reply)(
                    &connection->conn_xdrs, reply)) {
                        NDMP_LOG(LOG_DEBUG,
                            "Sending message 0x%x: encoding reply body",
                            header.message);
                        (void) xdrrec_endofrecord(&connection->conn_xdrs, 1);
                        return (-1);
        }
        }
        (void) xdrrec_endofrecord(&connection->conn_xdrs, 1);
        return (0);
}

/*
 * ndmp_free_message
 *
 * Free the memory of NDMP message body.
 *
 * Parameters:
 *   connection_handle  (input)  - connection pointer.
 *
 * Returns:
 *   void
 *
 */
void
ndmp_free_message(ndmp_connection_t *connection_handle)
{
        ndmp_connection_t *connection = (ndmp_connection_t *)connection_handle;

        if (connection->conn_msginfo.mi_handler == NULL ||
            connection->conn_msginfo.mi_body == NULL)
                return;

        connection->conn_xdrs.x_op = XDR_FREE;
        if (connection->conn_msginfo.mi_hdr.message_type ==
            NDMP_MESSAGE_REQUEST) {
                if (connection->conn_msginfo.mi_handler->mh_xdr_request)
                        (*connection->conn_msginfo.mi_handler->mh_xdr_request)(
                            &connection->conn_xdrs,
                            connection->conn_msginfo.mi_body);
        } else {
                if (connection->conn_msginfo.mi_handler->mh_xdr_reply)
                        (*connection->conn_msginfo.mi_handler->mh_xdr_reply)(
                            &connection->conn_xdrs,
                            connection->conn_msginfo.mi_body);
        }

        (void) free(connection->conn_msginfo.mi_body);
        connection->conn_msginfo.mi_body = 0;
}

/*
 * ndmp_get_fd
 *
 * Returns the connection file descriptor.
 *
 * Parameters:
 *   connection_handle (input) - connection handle
 *
 * Returns:
 *   >=0 - file descriptor.
 *   -1  - connection not open.
 */
int
ndmp_get_fd(ndmp_connection_t *connection_handle)
{
        return (((ndmp_connection_t *)connection_handle)->conn_sock);
}


/*
 * ndmp_set_client_data
 *
 * This function provides a means for the library client to provide
 * a pointer to some user data structure that is retrievable by
 * each message handler via ndmp_get_client_data.
 *
 * Parameters:
 *   connection_handle  (input) - connection handle.
 *   client_data        (input) - user data pointer.
 *
 * Returns:
 *   void
 */
void
ndmp_set_client_data(ndmp_connection_t *connection_handle, void *client_data)
{
        ((ndmp_connection_t *)connection_handle)->conn_client_data =
            client_data;
}


/*
 * ndmp_get_client_data
 *
 * This function provides a means for the library client to provide
 * a pointer to some user data structure that is retrievable by
 * each message handler via ndmp_get_client_data.
 *
 * Parameters:
 *   connection_handle (input) - connection handle.
 *
 * Returns:
 *   client data pointer.
 */
void *
ndmp_get_client_data(ndmp_connection_t *connection_handle)
{
        return (((ndmp_connection_t *)connection_handle)->conn_client_data);
}


/*
 * ndmp_set_version
 *
 * Sets the NDMP protocol version to be used on the connection.
 *
 * Parameters:
 *   connection_handle  (input) - connection handle.
 *   version       (input) - protocol version.
 *
 * Returns:
 *   void
 */
void
ndmp_set_version(ndmp_connection_t *connection_handle, ushort_t version)
{
        ((ndmp_connection_t *)connection_handle)->conn_version = version;
}


/*
 * ndmp_get_version
 *
 * Gets the NDMP protocol version in use on the connection.
 *
 * Parameters:
 *   connection_handle  (input) - connection handle.
 *   version       (input) - protocol version.
 *
 * Returns:
 *   void
 */
ushort_t
ndmp_get_version(ndmp_connection_t *connection_handle)
{
        return (((ndmp_connection_t *)connection_handle)->conn_version);
}


/*
 * ndmp_set_authorized
 *
 * Mark the connection as either having been authorized or not.
 *
 * Parameters:
 *   connection_handle  (input) - connection handle.
 *   authorized (input) - TRUE or FALSE.
 *
 * Returns:
 *   void
 */
void
ndmp_set_authorized(ndmp_connection_t *connection_handle, boolean_t authorized)
{
        ((ndmp_connection_t *)connection_handle)->conn_authorized = authorized;
}


/*
 * ndmpd_main
 *
 * NDMP main function called from main().
 *
 * Parameters:
 *   void
 *
 * Returns:
 *   void
 */
void
ndmpd_main(void)
{
        char *propval;

        ndmp_load_params();

        /*
         * Find ndmp port number to be used. If ndmpd is run as command line
         * and port number is supplied, use that port number. If port number is
         * is not supplied, find out if ndmp port property is set. If ndmp
         * port property is set, use that port number otherwise use the defaule
         * port number.
         */
        if (ndmp_port == 0) {
                if ((propval = ndmpd_get_prop(NDMP_TCP_PORT)) == NULL ||
                    *propval == 0)
                        ndmp_port = NDMPPORT;
                else
                        ndmp_port = strtol(propval, 0, 0);
        }

        if (ndmp_run(ndmp_port, connection_handler) == -1)
                perror("ndmp_run ERROR");
}

/*
 * connection_handler
 *
 * NDMP connection handler.
 * Waits for, reads, and processes NDMP requests on a connection.
 *
 * Parameters:
 *   connection (input) - connection handle.
 *
 * Return:
 *   void
 */
void
connection_handler(ndmp_connection_t *connection)
{
        static int conn_id = 1;
        ndmpd_session_t session;
        ndmp_notify_connected_request req;
        int connection_fd;

        (void) memset(&session, 0, sizeof (session));
        session.ns_connection = connection;
        session.ns_eof = FALSE;
        /*
         * The 'protocol_version' must be 1 at first, since the client talks
         * to the server in version 1 then they can move to a higher
         * protocol version.
         */
        session.ns_protocol_version = ndmp_ver;

        session.ns_scsi.sd_is_open = -1;
        session.ns_scsi.sd_devid = -1;

        session.ns_scsi.sd_sid = 0;
        session.ns_scsi.sd_lun = 0;
        session.ns_scsi.sd_valid_target_set = 0;
        (void) memset(session.ns_scsi.sd_adapter_name, 0,
            sizeof (session.ns_scsi.sd_adapter_name));

        session.ns_tape.td_fd = -1;
        session.ns_tape.td_sid = 0;
        session.ns_tape.td_lun = 0;
        (void) memset(session.ns_tape.td_adapter_name, 0,
            sizeof (session.ns_tape.td_adapter_name));
        session.ns_tape.td_pos = 0;
        session.ns_tape.td_record_count = 0;
        session.ns_file_handler_list = 0;

        (void) ndmpd_data_init(&session);
        ndmpd_file_history_init(&session);
        if (ndmpd_mover_init(&session) < 0)
                return;

        if (ndmp_lbr_init(&session) < 0)
                return;

        /*
         * Setup defaults here. The init functions can not set defaults
         * since the init functions are called by the stop request handlers
         * and client set variables need to persist across data operations.
         */
        session.ns_mover.md_record_size = MAX_RECORD_SIZE;

        ndmp_set_client_data(connection, (void *)&session);

        req.reason = NDMP_CONNECTED;
        req.protocol_version = ndmp_ver;
        req.text_reason = "";

        if (ndmp_send_request_lock(connection, NDMP_NOTIFY_CONNECTION_STATUS,
            NDMP_NO_ERR, (void *)&req, 0) < 0) {
                NDMP_LOG(LOG_DEBUG, "Connection terminated");
                return;
        }
        connection_fd = ndmp_get_fd(connection);

        NDMP_LOG(LOG_DEBUG, "connection_fd: %d", connection_fd);

        /*
         * Add the handler function for the connection to the DMA.
         */
        if (ndmpd_add_file_handler(&session, (void *)&session, connection_fd,
            NDMPD_SELECT_MODE_READ, HC_CLIENT, connection_file_handler) != 0) {
                NDMP_LOG(LOG_DEBUG, "Could not register session handler.");
                return;
        }

        /*
         * Register the connection in the list of active connections.
         */
        if (ndmp_connect_list_add(connection, &conn_id) != 0) {
                NDMP_LOG(LOG_ERR,
                    "Could not register the session to the server.");
                (void) ndmpd_remove_file_handler(&session, connection_fd);
                return;
        }

        session.hardlink_q = hardlink_q_init();

        while (session.ns_eof == FALSE)
                (void) ndmpd_select(&session, TRUE, HC_ALL);

        hardlink_q_cleanup(session.hardlink_q);

        NDMP_LOG(LOG_DEBUG, "Connection terminated");

        (void) ndmpd_remove_file_handler(&session, connection_fd);

        if (session.ns_scsi.sd_is_open != -1) {
                NDMP_LOG(LOG_DEBUG, "scsi.is_open: %d",
                    session.ns_scsi.sd_is_open);
                (void) ndmp_open_list_del(session.ns_scsi.sd_adapter_name,
                    session.ns_scsi.sd_sid, session.ns_scsi.sd_lun);
        }
        if (session.ns_tape.td_fd != -1) {
                NDMP_LOG(LOG_DEBUG, "tape.fd: %d", session.ns_tape.td_fd);
                (void) close(session.ns_tape.td_fd);
                (void) ndmp_open_list_del(session.ns_tape.td_adapter_name,
                    session.ns_tape.td_sid, session.ns_tape.td_lun);
        }
        ndmpd_mover_shut_down(&session);
        ndmp_lbr_cleanup(&session);
        ndmpd_data_cleanup(&session);
        ndmpd_file_history_cleanup(&session, FALSE);
        ndmpd_mover_cleanup(&session);

        (void) ndmp_connect_list_del(connection);
}


/*
 * connection_file_handler
 *
 * ndmp_connection_t file handler function.
 * Called by ndmpd_select when data is available to be read on the
 * NDMP connection.
 *
 * Parameters:
 *   cookie (input) - session pointer.
 *   fd      (input) - connection file descriptor.
 *   mode    (input) - select mode.
 *
 * Returns:
 *   void.
 */
/*ARGSUSED*/
static void
connection_file_handler(void *cookie, int fd, ulong_t mode)
{
        ndmpd_session_t *session = (ndmpd_session_t *)cookie;

        if (ndmp_process_requests(session->ns_connection) < 0)
                session->ns_eof = TRUE;
}


/* ************* private functions *************************************** */

/*
 * ndmp_readit
 *
 * Low level read routine called by the xdrrec library.
 *
 * Parameters:
 *   connection (input) - connection pointer.
 *   buf        (input) - location to store received data.
 *   len        (input) - max number of bytes to read.
 *
 * Returns:
 *   >0 - number of bytes received.
 *   -1 - error.
 */
static int
ndmp_readit(void *connection_handle, caddr_t buf, int len)
{
        ndmp_connection_t *connection = (ndmp_connection_t *)connection_handle;

        len = read(connection->conn_sock, buf, len);
        if (len <= 0) {
                /* ndmp_connection_t has been closed. */
                connection->conn_eof = TRUE;
                return (-1);
        }
        return (len);
}

/*
 * ndmp_writeit
 *
 * Low level write routine called by the xdrrec library.
 *
 * Parameters:
 *   connection (input) - connection pointer.
 *   buf        (input) - location to store received data.
 *   len        (input) - max number of bytes to read.
 *
 * Returns:
 *   >0 - number of bytes sent.
 *   -1 - error.
 */
static int
ndmp_writeit(void *connection_handle, caddr_t buf, int len)
{
        ndmp_connection_t *connection = (ndmp_connection_t *)connection_handle;
        register int n;
        register int cnt;

        for (cnt = len; cnt > 0; cnt -= n, buf += n) {
                if ((n = write(connection->conn_sock, buf, cnt)) < 0) {
                        connection->conn_eof = TRUE;
                        return (-1);
                }
        }

        return (len);
}


/*
 * ndmp_recv_msg
 *
 * Read the next message.
 *
 * Parameters:
 *   connection (input)  - connection pointer.
 *   msg        (output) - received message.
 *
 * Returns:
 *   0 - Message successfully received.
 *   error number - Message related error.
 *  -1 - Error decoding the message header.
 */
static int
ndmp_recv_msg(ndmp_connection_t *connection)
{
        bool_t(*xdr_func) (XDR *, ...) = NULL;

        /* Decode the header. */
        connection->conn_xdrs.x_op = XDR_DECODE;
        (void) xdrrec_skiprecord(&connection->conn_xdrs);
        if (!xdr_ndmp_header(&connection->conn_xdrs,
            &connection->conn_msginfo.mi_hdr))
                return (-1);

        /* Lookup info necessary for processing this message. */
        if ((connection->conn_msginfo.mi_handler = ndmp_get_handler(connection,
            connection->conn_msginfo.mi_hdr.message)) == 0) {
                NDMP_LOG(LOG_DEBUG, "Message 0x%x not supported",
                    connection->conn_msginfo.mi_hdr.message);
                return (NDMP_NOT_SUPPORTED_ERR);
        }
        connection->conn_msginfo.mi_body = 0;

        if (connection->conn_msginfo.mi_hdr.error != NDMP_NO_ERR)
                return (0);

        /* Determine body type */
        if (connection->conn_msginfo.mi_hdr.message_type ==
            NDMP_MESSAGE_REQUEST) {
                if (ndmp_check_auth_required(
                    connection->conn_msginfo.mi_hdr.message) &&
                    !connection->conn_authorized) {
                        NDMP_LOG(LOG_DEBUG,
                            "Processing request 0x%x:connection not authorized",
                            connection->conn_msginfo.mi_hdr.message);
                        return (NDMP_NOT_AUTHORIZED_ERR);
                }
                if (connection->conn_msginfo.mi_handler->mh_sizeof_request >
                    0) {
                        xdr_func =
                            connection->conn_msginfo.mi_handler->mh_xdr_request;
                        if (xdr_func == NULL) {
                                NDMP_LOG(LOG_DEBUG,
                                    "Processing request 0x%x: no xdr function "
                                    "in handler table",
                                    connection->conn_msginfo.mi_hdr.message);
                                return (NDMP_NOT_SUPPORTED_ERR);
                        }
                        connection->conn_msginfo.mi_body = ndmp_malloc(
                            connection->conn_msginfo.mi_handler->
                            mh_sizeof_request);
                        if (connection->conn_msginfo.mi_body == NULL)
                                return (NDMP_NO_MEM_ERR);

                        (void) memset(connection->conn_msginfo.mi_body, 0,
                            connection->conn_msginfo.mi_handler->
                            mh_sizeof_request);
                }
        } else {
                if (connection->conn_msginfo.mi_handler->mh_sizeof_reply > 0) {
                        xdr_func =
                            connection->conn_msginfo.mi_handler->mh_xdr_reply;
                        if (xdr_func == NULL) {
                                NDMP_LOG(LOG_DEBUG,
                                    "Processing reply 0x%x: no xdr function "
                                    "in handler table",
                                    connection->conn_msginfo.mi_hdr.message);
                                return (NDMP_NOT_SUPPORTED_ERR);
                        }
                        connection->conn_msginfo.mi_body = ndmp_malloc(
                            connection->conn_msginfo.mi_handler->
                            mh_sizeof_reply);
                        if (connection->conn_msginfo.mi_body == NULL)
                                return (NDMP_NO_MEM_ERR);

                        (void) memset(connection->conn_msginfo.mi_body, 0,
                            connection->conn_msginfo.mi_handler->
                            mh_sizeof_reply);
                }
        }

        /* Decode message arguments if needed */
        if (xdr_func) {
                if (!(*xdr_func)(&connection->conn_xdrs,
                    connection->conn_msginfo.mi_body)) {
                        NDMP_LOG(LOG_DEBUG,
                            "Processing message 0x%x: error decoding arguments",
                            connection->conn_msginfo.mi_hdr.message);
                        free(connection->conn_msginfo.mi_body);
                        connection->conn_msginfo.mi_body = 0;
                        return (NDMP_XDR_DECODE_ERR);
                }
        }
        return (0);
}

/*
 * ndmp_process_messages
 *
 * Reads the next message into the stream buffer.
 * Processes messages until the stream buffer is empty.
 *
 * This function processes all data in the stream buffer before returning.
 * This allows functions like poll() to be used to determine when new
 * messages have arrived. If only some of the messages in the stream buffer
 * were processed and then poll was called, poll() could block waiting for
 * a message that had already been received and read into the stream buffer.
 *
 * This function processes both request and reply messages.
 * Request messages are dispatched using the appropriate function from the
 * message handling table.
 * Only one reply messages may be pending receipt at a time.
 * A reply message, if received, is placed in connection->conn_msginfo
 * before returning to the caller.
 * Errors are reported if a reply is received but not expected or if
 * more than one reply message is received
 *
 * Parameters:
 *   connection     (input)  - connection pointer.
 *   reply_expected (output) - TRUE  - a reply message is expected.
 *                           FALSE - no reply message is expected and
 *                           an error will be reported if a reply
 *                           is received.
 *
 * Returns:
 *   NDMP_PROC_REP_ERR - 1 or more messages successfully processed,
 *      error processing reply message.
 *   NDMP_PROC_REP_ERR - 1 or more messages successfully processed,
 *      reply seen.
 *   NDMP_PROC_REP_ERR - 1 or more messages successfully processed,
 *      no reply seen.
 *   NDMP_PROC_REP_ERR - error; connection no longer established.
 *
 * Notes:
 *   If the peer is generating a large number of requests, a caller
 *   looking for a reply will be blocked while the requests are handled.
 *   This is because this function does not return until the stream
 *   buffer is empty.
 *   Code needs to be added to allow a return if the stream buffer
 *   is not empty but there is data available on the socket. This will
 *   prevent poll() from blocking and prevent a caller looking for a reply
 *   from getting blocked by a bunch of requests.
 */
static int
ndmp_process_messages(ndmp_connection_t *connection, boolean_t reply_expected)
{
        msg_info_t reply_msginfo;
        boolean_t reply_read = FALSE;
        boolean_t reply_error = FALSE;
        int err;

        NDMP_LOG(LOG_DEBUG, "reply_expected: %s",
            reply_expected == TRUE ? "TRUE" : "FALSE");

        (void) memset((void *)&reply_msginfo, 0, sizeof (msg_info_t));

        do {
                (void) memset((void *)&connection->conn_msginfo, 0,
                    sizeof (msg_info_t));

                if ((err = ndmp_recv_msg(connection)) != NDMP_NO_ERR) {
                        if (connection->conn_eof) {
                                NDMP_LOG(LOG_DEBUG, "detected eof");
                                return (NDMP_PROC_ERR);
                        }
                        if (err < 1) {
                                NDMP_LOG(LOG_DEBUG, "error decoding header");

                                /*
                                 * Error occurred decoding the header.
                                 * Don't send a reply since we don't know
                                 * the message or if the message was even
                                 * a request message.  To be safe, assume
                                 * that the message was a reply if a reply
                                 * was expected. Need to do this to prevent
                                 * hanging ndmp_send_request() waiting for a
                                 * reply.  Don't set reply_read so that the
                                 * reply will be processed if it is received
                                 * later.
                                 */
                                if (reply_read == FALSE)
                                        reply_error = TRUE;

                                continue;
                        }
                        if (connection->conn_msginfo.mi_hdr.message_type
                            != NDMP_MESSAGE_REQUEST) {
                                NDMP_LOG(LOG_DEBUG, "received reply: 0x%x",
                                    connection->conn_msginfo.mi_hdr.message);

                                if (reply_expected == FALSE ||
                                    reply_read == TRUE)
                                        NDMP_LOG(LOG_DEBUG,
                                            "Unexpected reply message: 0x%x",
                                            connection->conn_msginfo.mi_hdr.
                                            message);

                                ndmp_free_message((ndmp_connection_t *)
                                    connection);

                                if (reply_read == FALSE) {
                                        reply_read = TRUE;
                                        reply_error = TRUE;
                                }
                                continue;
                        }
                        NDMP_LOG(LOG_DEBUG, "received request: 0x%x",
                            connection->conn_msginfo.mi_hdr.message);

                        (void) ndmp_send_response((ndmp_connection_t *)
                            connection, err, NULL);
                        ndmp_free_message((ndmp_connection_t *)connection);
                        continue;
                }
                if (connection->conn_msginfo.mi_hdr.message_type
                    != NDMP_MESSAGE_REQUEST) {
                        NDMP_LOG(LOG_DEBUG, "received reply: 0x%x",
                            connection->conn_msginfo.mi_hdr.message);

                        if (reply_expected == FALSE || reply_read == TRUE) {
                                NDMP_LOG(LOG_DEBUG,
                                    "Unexpected reply message: 0x%x",
                                    connection->conn_msginfo.mi_hdr.message);
                                ndmp_free_message((ndmp_connection_t *)
                                    connection);
                                continue;
                        }
                        reply_read = TRUE;
                        reply_msginfo = connection->conn_msginfo;
                        continue;
                }
                NDMP_LOG(LOG_DEBUG, "received request: 0x%x",
                    connection->conn_msginfo.mi_hdr.message);

                /*
                 * The following is needed to catch an improperly constructed
                 * handler table or to deal with an NDMP client that is not
                 * conforming to the negotiated protocol version.
                 */
                if (connection->conn_msginfo.mi_handler->mh_func == NULL) {
                        NDMP_LOG(LOG_DEBUG, "No handler for message 0x%x",
                            connection->conn_msginfo.mi_hdr.message);

                        (void) ndmp_send_response((ndmp_connection_t *)
                            connection, NDMP_NOT_SUPPORTED_ERR, NULL);
                        ndmp_free_message((ndmp_connection_t *)connection);
                        continue;
                }
                /*
                 * Call the handler function.
                 * The handler will send any necessary reply.
                 */
                (*connection->conn_msginfo.mi_handler->mh_func) (connection,
                    connection->conn_msginfo.mi_body);

                ndmp_free_message((ndmp_connection_t *)connection);

        } while (xdrrec_eof(&connection->conn_xdrs) == FALSE &&
            connection->conn_eof == FALSE);

        NDMP_LOG(LOG_DEBUG, "no more messages in stream buffer");

        if (connection->conn_eof == TRUE) {
                if (reply_msginfo.mi_body)
                        free(reply_msginfo.mi_body);
                return (NDMP_PROC_ERR);
        }
        if (reply_error) {
                if (reply_msginfo.mi_body)
                        free(reply_msginfo.mi_body);
                return (NDMP_PROC_REP_ERR);
        }
        if (reply_read) {
                connection->conn_msginfo = reply_msginfo;
                return (NDMP_PROC_MSG);
        }
        return (NDMP_PROC_REP);
}


/*
 * ndmp_get_interface
 *
 * Return the NDMP interface (e.g. config, scsi, tape) for the
 * specific message.
 *
 * Parameters:
 *   message (input) - message number.
 *
 * Returns:
 *   NULL - message not found.
 *   pointer to handler info.
 */
static ndmp_handler_t *
ndmp_get_interface(ndmp_message message)
{
        ndmp_handler_t *ni = &ndmp_msghdl_tab[(message >> 8) % INT_MAXCMD];

        if ((message & 0xff) >= ni->hd_cnt)
                return (NULL);

        /* Sanity check */
        if (ni->hd_msgs[message & 0xff].hm_message != message)
                return (NULL);

        return (ni);
}

/*
 * ndmp_get_handler
 *
 * Return the handler info for the specified NDMP message.
 *
 * Parameters:
 *   connection (input) - connection pointer.
 *   message (input) - message number.
 *
 * Returns:
 *   NULL - message not found.
 *   pointer to handler info.
 */
static ndmp_msg_handler_t *
ndmp_get_handler(ndmp_connection_t *connection, ndmp_message message)
{
        ndmp_msg_handler_t *handler = NULL;

        ndmp_handler_t *ni = ndmp_get_interface(message);
        int ver = connection->conn_version;

        if (ni)
                handler = &ni->hd_msgs[message & 0xff].hm_msg_v[ver - 2];

        return (handler);
}

/*
 * ndmp_check_auth_required
 *
 * Check if the connection needs to be authenticated before
 * this message is being processed.
 *
 * Parameters:
 *   message (input) - message number.
 *
 * Returns:
 *   TRUE - required
 *   FALSE - not required
 */
static boolean_t
ndmp_check_auth_required(ndmp_message message)
{
        boolean_t auth_req = FALSE;
        ndmp_handler_t *ni = ndmp_get_interface(message);

        if (ni)
                auth_req = ni->hd_msgs[message & 0xff].hm_auth_required;

        return (auth_req);
}

/*
 * tcp_accept
 *
 * A wrapper around accept for retrying and getting the IP address
 *
 * Parameters:
 *   listen_sock (input) - the socket for listening
 *   inaddr_p (output) - the IP address of peer connection
 *
 * Returns:
 *   socket for the accepted connection
 *   -1: error
 */
int
tcp_accept(int listen_sock, unsigned int *inaddr_p)
{
        struct sockaddr_in      sin;
        int                     sock, i;
        int                     try;

        for (try = 0; try < 3; try++) {
                i = sizeof (sin);
                sock = accept(listen_sock, (struct sockaddr *)&sin, &i);
                if (sock < 0) {
                        continue;
                }
                *inaddr_p = sin.sin_addr.s_addr;
                return (sock);
        }
        return (-1);
}


/*
 * tcp_get_peer
 *
 * Get the peer IP address for a connection
 *
 * Parameters:
 *   sock (input) - the active socket
 *   inaddr_p (output) - the IP address of peer connection
 *   port_p (output) - the port number of peer connection
 *
 * Returns:
 *   socket for the accepted connection
 *   -1: error
 */
int
tcp_get_peer(int sock, unsigned int *inaddr_p, int *port_p)
{
        struct sockaddr_in sin;
        int i, rc;

        i = sizeof (sin);
        rc = getpeername(sock, (struct sockaddr *)&sin, &i);
        if (rc != 0)
                return (-1);

        if (inaddr_p)
                *inaddr_p = sin.sin_addr.s_addr;

        if (port_p)
                *port_p = ntohs(sin.sin_port);

        return (sock);

}

/*
 * gethostaddr
 *
 * Get the IP address string of the current host
 *
 * Parameters:
 *   void
 *
 * Returns:
 *   IP address
 *   NULL: error
 */
char *
gethostaddr(void)
{
        static char s[MAXHOSTNAMELEN];
        struct hostent *h;
        struct in_addr in;
        char *p;

        if (gethostname(s, sizeof (s)) == -1)
                return (NULL);

        if ((h = gethostbyname(s)) == NULL)
                return (NULL);

        p = h->h_addr_list[0];
        (void) memcpy(&in.s_addr, p, sizeof (in.s_addr));
        return (inet_ntoa(in));
}


/*
 * get_default_nic_addr
 *
 * Get the IP address of the default NIC
 */
char *
get_default_nic_addr(void)
{
        struct ifaddrlist *al = NULL;
        char errmsg[ERRBUFSIZE];
        struct in_addr addr;
        int nifs;

        nifs = ifaddrlist(&al, AF_INET, LIFC_EXTERNAL_SOURCE, errmsg);
        if (nifs <= 0)
                return (NULL);

        /* pick the first interface's address */
        addr = al[0].addr.addr;
        free(al);

        return (inet_ntoa(IN_ADDR(addr.s_addr)));
}


/*
 * ndmpd_audit_backup
 *
 * Generate AUE_ndmp_backup audit record
 */
/*ARGSUSED*/
void
ndmpd_audit_backup(ndmp_connection_t *conn,
    char *path, int dest, char *local_path, int result)
{
        adt_event_data_t *event;

        if ((event = adt_alloc_event(conn->conn_ah, ADT_ndmp_backup)) == NULL) {
                NDMP_LOG(LOG_ERR, "Audit failure: %m.");
                return;
        }
        event->adt_ndmp_backup.source = path;

        if (dest == NDMP_ADDR_LOCAL) {
                event->adt_ndmp_backup.local_dest = local_path;
        } else {
                event->adt_ndmp_backup.remote_dest = conn->conn_sock;
        }

        if (result == 0) {
                if (adt_put_event(event, ADT_SUCCESS, ADT_SUCCESS) != 0)
                        NDMP_LOG(LOG_ERR, "Audit failure: %m.");
        } else {
                if (adt_put_event(event, ADT_FAILURE, result) != 0)
                        NDMP_LOG(LOG_ERR, "Audit failure: %m.");
        }

        adt_free_event(event);
}


/*
 * ndmpd_audit_restore
 *
 * Generate AUE_ndmp_restore audit record
 */
/*ARGSUSED*/
void
ndmpd_audit_restore(ndmp_connection_t *conn,
    char *path, int dest, char *local_path, int result)
{
        adt_event_data_t *event;

        if ((event = adt_alloc_event(conn->conn_ah,
            ADT_ndmp_restore)) == NULL) {
                NDMP_LOG(LOG_ERR, "Audit failure: %m.");
                return;
        }
        event->adt_ndmp_restore.destination = path;

        if (dest == NDMP_ADDR_LOCAL) {
                event->adt_ndmp_restore.local_source = local_path;
        } else {
                event->adt_ndmp_restore.remote_source = conn->conn_sock;
        }

        if (result == 0) {
                if (adt_put_event(event, ADT_SUCCESS, ADT_SUCCESS) != 0)
                        NDMP_LOG(LOG_ERR, "Audit failure: %m.");
        } else {
                if (adt_put_event(event, ADT_FAILURE, result) != 0)
                        NDMP_LOG(LOG_ERR, "Audit failure: %m.");
        }

        adt_free_event(event);
}


/*
 * ndmpd_audit_connect
 *
 * Generate AUE_ndmp_connect audit record
 */
/*ARGSUSED*/
void
ndmpd_audit_connect(ndmp_connection_t *conn, int result)
{
        adt_event_data_t *event;
        adt_termid_t *termid;

        if (adt_load_termid(conn->conn_sock, &termid) != 0) {
                NDMP_LOG(LOG_ERR, "Audit failure: %m.");
                return;
        }

        if (adt_set_user(conn->conn_ah, ADT_NO_ATTRIB, ADT_NO_ATTRIB,
            ADT_NO_ATTRIB, ADT_NO_ATTRIB, termid, ADT_NEW) != 0) {
                NDMP_LOG(LOG_ERR, "Audit failure: %m.");
                free(termid);
                return;
        }
        free(termid);

        if ((event = adt_alloc_event(conn->conn_ah,
            ADT_ndmp_connect)) == NULL) {
                NDMP_LOG(LOG_ERR, "Audit failure: %m.");
                return;
        }

        if (result == 0) {
                if (adt_put_event(event, ADT_SUCCESS, ADT_SUCCESS) != 0)
                        NDMP_LOG(LOG_ERR, "Audit failure: %m.");
        } else {
                if (adt_put_event(event, ADT_FAILURE, result) != 0)
                        NDMP_LOG(LOG_ERR, "Audit failure: %m.");
        }

        adt_free_event(event);
}


/*
 * ndmpd_audit_disconnect
 *
 * Generate AUE_ndmp_disconnect audit record
 */
/*ARGSUSED*/
void
ndmpd_audit_disconnect(ndmp_connection_t *conn)
{
        adt_event_data_t *event;

        if ((event = adt_alloc_event(conn->conn_ah,
            ADT_ndmp_disconnect)) == NULL) {
                NDMP_LOG(LOG_ERR, "Audit failure: %m.");
                return;
        }
        if (adt_put_event(event, ADT_SUCCESS, ADT_SUCCESS) != 0)
                NDMP_LOG(LOG_ERR, "Audit failure: %m.");

        adt_free_event(event);
}

void *
ndmp_malloc(size_t size)
{
        void *data;

        if ((data = calloc(1, size)) == NULL) {
                NDMP_LOG(LOG_ERR, "Out of memory.");
        }

        return (data);
}

/*
 * get_backup_path_v3
 *
 * Get the backup path from the NDMP environment variables.
 *
 * Parameters:
 *   params (input) - pointer to the parameters structure.
 *
 * Returns:
 *   The backup path: if anything is specified
 *   NULL: Otherwise
 */
char *
get_backup_path_v3(ndmpd_module_params_t *params)
{
        char *bkpath;

        bkpath = MOD_GETENV(params, "PREFIX");
        if (!bkpath)
                bkpath = MOD_GETENV(params, "FILESYSTEM");


        if (!bkpath) {
                MOD_LOGV3(params, NDMP_LOG_ERROR,
                    "Backup path not defined.\n");
        } else {
                NDMP_LOG(LOG_DEBUG, "bkpath: \"%s\"", bkpath);
        }

        return (bkpath);
}

/*
 * get_backup_path
 *
 * Find the backup path from the environment variables (v2)
 */
char *
get_backup_path_v2(ndmpd_module_params_t *params)
{
        char *bkpath;

        bkpath = MOD_GETENV(params, "PREFIX");
        if (bkpath == NULL)
                bkpath = MOD_GETENV(params, "FILESYSTEM");

        if (bkpath == NULL) {
                MOD_LOG(params, "Error: restore path not specified.\n");
                return (NULL);
        }

        if (*bkpath != '/') {
                MOD_LOG(params, "Error: relative backup path not allowed.\n");
                return (NULL);
        }

        return (bkpath);
}