/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

static int ndmp_door_fildes = -1;
static char *buf;
static ndmp_door_ctx_t *dec_ctx;
static ndmp_door_ctx_t *enc_ctx;
static door_arg_t arg;
static mutex_t ndmp_lock = DEFAULTMUTEX;

static int ndmp_door_setup(int opcode);
static int ndmp_door_call(void);
static int ndmp_door_fini(void);

/* ndmp library APIs */
int
ndmp_get_devinfo(ndmp_devinfo_t **dip, size_t *size)
{
        ndmp_devinfo_t *dipptr;
        int i;
        int opcode = NDMP_DEVICES_GET_INFO;

        (void) mutex_lock(&ndmp_lock);
        if (ndmp_door_setup(opcode))
                goto err;

        if (ndmp_door_call())
                goto err;

        /* get the number of devices available */
        *size = ndmp_door_get_uint32(dec_ctx);

        *dip = malloc(sizeof (ndmp_devinfo_t) * *size);
        if (!*dip) {
                free(buf);
                ndmp_errno = ENDMP_MEM_ALLOC;
                goto err;
        }
        dipptr = *dip;
        for (i = 0; i < *size; i++, dipptr++) {
                dipptr->nd_dev_type = ndmp_door_get_int32(dec_ctx);
                dipptr->nd_name = ndmp_door_get_string(dec_ctx);
                dipptr->nd_lun = ndmp_door_get_int32(dec_ctx);
                dipptr->nd_sid = ndmp_door_get_int32(dec_ctx);
                dipptr->nd_vendor = ndmp_door_get_string(dec_ctx);
                dipptr->nd_product = ndmp_door_get_string(dec_ctx);
                dipptr->nd_revision = ndmp_door_get_string(dec_ctx);
                dipptr->nd_serial = ndmp_door_get_string(dec_ctx);
                dipptr->nd_wwn = ndmp_door_get_string(dec_ctx);
        }
        if (ndmp_door_fini()) {
                free(*dip);
                goto err;
        }
        (void) mutex_unlock(&ndmp_lock);
        return (0);
err:
        (void) mutex_unlock(&ndmp_lock);
        return (-1);
}

void
ndmp_get_devinfo_free(ndmp_devinfo_t *dip, size_t size)
{
        ndmp_devinfo_t *dipptr;
        int i;

        dipptr = dip;
        for (i = 0; i < size; i++, dipptr++) {
                free(dipptr->nd_name);
                free(dipptr->nd_vendor);
                free(dipptr->nd_product);
                free(dipptr->nd_revision);
        }
        free(dip);
}

int
ndmp_terminate_session(int session)
{
        int ret;
        int opcode = NDMP_TERMINATE_SESSION_ID;

        (void) mutex_lock(&ndmp_lock);
        if (ndmp_door_setup(opcode))
                goto err;

        ndmp_door_put_uint32(enc_ctx, session);
        if (ndmp_door_call())
                goto err;

        ret = ndmp_door_get_uint32(dec_ctx);
        if (ndmp_door_fini())
                goto err;

        (void) mutex_unlock(&ndmp_lock);
        return (ret);
err:
        (void) mutex_unlock(&ndmp_lock);
        return (-1);
}

int
ndmp_get_session_info(ndmp_session_info_t **sinfo, size_t *size)
{
        int status;
        int i, j;
        ndmp_session_info_t *sp;
        ndmp_dt_pval_t *ep;
        ndmp_dt_name_t *np;
        ndmp_dt_name_v3_t *npv3;
        int opcode = NDMP_SHOW;

        (void) mutex_lock(&ndmp_lock);
        if (ndmp_door_setup(opcode))
                goto err;

        if (ndmp_door_call())
                goto err;

        /* number of sessions */
        *size = ndmp_door_get_int32(dec_ctx);

        *sinfo = malloc((sizeof (ndmp_session_info_t)) * *size);
        if (!*sinfo) {
                free(buf);
                ndmp_errno = ENDMP_MEM_ALLOC;
                goto err;
        }
        sp = *sinfo;
        for (i = 0; i < *size; i++, sp++) {
                status = ndmp_door_get_int32(dec_ctx);
                if (status == NDMP_SESSION_NODATA)
                        continue;

                /* connection common info */
                sp->nsi_sid = ndmp_door_get_int32(dec_ctx);
                sp->nsi_pver = ndmp_door_get_int32(dec_ctx);
                sp->nsi_auth = ndmp_door_get_int32(dec_ctx);
                sp->nsi_eof = ndmp_door_get_int32(dec_ctx);
                sp->nsi_cl_addr = ndmp_door_get_string(dec_ctx);
                /*
                 * scsi and tape data are same for all version,
                 * so keep reading
                 */
                /* connection common scsi info.   */
                sp->nsi_scsi.ns_scsi_open = ndmp_door_get_int32(dec_ctx);
                sp->nsi_scsi.ns_adapter_name = ndmp_door_get_string(dec_ctx);
                sp->nsi_scsi.ns_valid_target_set = ndmp_door_get_int32(dec_ctx);
                if (sp->nsi_scsi.ns_valid_target_set) {
                        sp->nsi_scsi.ns_scsi_id = ndmp_door_get_int32(dec_ctx);
                        sp->nsi_scsi.ns_lun = ndmp_door_get_int32(dec_ctx);
                }

                /* connection common tape info.   */
                sp->nsi_tape.nt_fd = ndmp_door_get_int32(dec_ctx);
                if (sp->nsi_tape.nt_fd != -1) {
                        sp->nsi_tape.nt_rec_count =
                            ndmp_door_get_uint64(dec_ctx);
                        sp->nsi_tape.nt_mode = ndmp_door_get_int32(dec_ctx);
                        sp->nsi_tape.nt_dev_name =
                            ndmp_door_get_string(dec_ctx);
                        sp->nsi_tape.nt_adapter_name =
                            ndmp_door_get_string(dec_ctx);
                        sp->nsi_tape.nt_sid = ndmp_door_get_int32(dec_ctx);
                        sp->nsi_tape.nt_lun = ndmp_door_get_int32(dec_ctx);
                }
                /* all the V2 mover data are same as V3/V4 */
                sp->nsi_mover.nm_state = ndmp_door_get_int32(dec_ctx);
                sp->nsi_mover.nm_mode = ndmp_door_get_int32(dec_ctx);
                sp->nsi_mover.nm_pause_reason = ndmp_door_get_int32(dec_ctx);
                sp->nsi_mover.nm_halt_reason = ndmp_door_get_int32(dec_ctx);
                sp->nsi_mover.nm_rec_size = ndmp_door_get_uint64(dec_ctx);
                sp->nsi_mover.nm_rec_num = ndmp_door_get_uint64(dec_ctx);
                sp->nsi_mover.nm_mov_pos = ndmp_door_get_uint64(dec_ctx);
                sp->nsi_mover.nm_window_offset = ndmp_door_get_uint64(dec_ctx);
                sp->nsi_mover.nm_window_length = ndmp_door_get_uint64(dec_ctx);
                sp->nsi_mover.nm_sock = ndmp_door_get_int32(dec_ctx);

                /* Read V3/V4 mover info */
                if ((sp->nsi_pver == NDMP_V3) || (sp->nsi_pver == NDMP_V4)) {
                        sp->nsi_mover.nm_listen_sock =
                            ndmp_door_get_int32(dec_ctx);
                        sp->nsi_mover.nm_addr_type =
                            ndmp_door_get_int32(dec_ctx);
                        sp->nsi_mover.nm_tcp_addr =
                            ndmp_door_get_string(dec_ctx);
                }

                /* connection common data info */
                sp->nsi_data.nd_oper = ndmp_door_get_int32(dec_ctx);
                sp->nsi_data.nd_state = ndmp_door_get_int32(dec_ctx);
                sp->nsi_data.nd_halt_reason = ndmp_door_get_int32(dec_ctx);
                sp->nsi_data.nd_sock = ndmp_door_get_int32(dec_ctx);
                sp->nsi_data.nd_addr_type = ndmp_door_get_int32(dec_ctx);
                sp->nsi_data.nd_abort = ndmp_door_get_int32(dec_ctx);
                sp->nsi_data.nd_read_offset = ndmp_door_get_uint64(dec_ctx);
                sp->nsi_data.nd_read_length = ndmp_door_get_uint64(dec_ctx);
                sp->nsi_data.nd_total_size = ndmp_door_get_uint64(dec_ctx);
                sp->nsi_data.nd_env_len = ndmp_door_get_uint64(dec_ctx);
                sp->nsi_data.nd_env =
                    malloc(sizeof (ndmp_dt_pval_t) * sp->nsi_data.nd_env_len);
                if (!sp->nsi_data.nd_env) {
                        free(buf);
                        ndmp_errno = ENDMP_MEM_ALLOC;
                        goto err;
                }
                ep = sp->nsi_data.nd_env;
                for (j = 0; j < sp->nsi_data.nd_env_len; j++, ep++) {
                        ep->np_name = ndmp_door_get_string(dec_ctx);
                        ep->np_value = ndmp_door_get_string(dec_ctx);
                }
                sp->nsi_data.nd_tcp_addr = ndmp_door_get_string(dec_ctx);

                /* Read V2 data info */
                if (sp->nsi_pver == NDMP_V2) {
                        sp->nsi_data.nld_nlist_len =
                            ndmp_door_get_int64(dec_ctx);
                        sp->nsi_data.nd_nlist.nld_nlist =
                            malloc(sizeof (ndmp_dt_name_t) *
                            sp->nsi_data.nld_nlist_len);
                        if (!sp->nsi_data.nd_nlist.nld_nlist) {
                                free(buf);
                                ndmp_errno = ENDMP_MEM_ALLOC;
                                goto err;
                        }
                        np = sp->nsi_data.nd_nlist.nld_nlist;

                        for (j = 0; j < sp->nsi_data.nld_nlist_len; j++, np++) {
                                np->nn_name = ndmp_door_get_string(dec_ctx);
                                np->nn_dest = ndmp_door_get_string(dec_ctx);
                        }
                } else if ((sp->nsi_pver == NDMP_V3) ||
                    (sp->nsi_pver == NDMP_V4)) {
                        /* Read V3/V4 data info */
                        sp->nsi_data.nd_nlist.nld_dt_v3.dv3_listen_sock =
                            ndmp_door_get_int32(dec_ctx);
                        sp->nsi_data.nd_nlist.nld_dt_v3.dv3_bytes_processed =
                            ndmp_door_get_uint64(dec_ctx);
                        sp->nsi_data.nld_nlist_len =
                            ndmp_door_get_uint64(dec_ctx);
                        sp->nsi_data.nd_nlist.nld_dt_v3.dv3_nlist =
                            malloc(sizeof (ndmp_dt_name_v3_t) *
                            sp->nsi_data.nld_nlist_len);
                        if (!sp->nsi_data.nd_nlist.nld_dt_v3.dv3_nlist) {
                                free(buf);
                                ndmp_errno = ENDMP_MEM_ALLOC;
                                goto err;
                        }
                        npv3 = sp->nsi_data.nd_nlist.nld_dt_v3.dv3_nlist;
                        for (j = 0; j < sp->nsi_data.nld_nlist_len;
                            j++, npv3++) {
                                npv3->nn3_opath = ndmp_door_get_string(dec_ctx);
                                npv3->nn3_dpath = ndmp_door_get_string(dec_ctx);
                                npv3->nn3_node = ndmp_door_get_uint64(dec_ctx);
                                npv3->nn3_fh_info =
                                    ndmp_door_get_uint64(dec_ctx);
                        }
                }
        }

        if (ndmp_door_fini())
                goto err;

        (void) mutex_unlock(&ndmp_lock);
        return (0);
err:
        (void) mutex_unlock(&ndmp_lock);
        return (-1);
}

void
ndmp_get_session_info_free(ndmp_session_info_t *sinfo, size_t size)
{
        ndmp_session_info_t *sp;
        ndmp_dt_pval_t *ep;
        ndmp_dt_name_t *np;
        ndmp_dt_name_v3_t *npv3;
        int i, j;

        sp = sinfo;
        for (i = 0; i < size; i++, sp++) {
                free(sp->nsi_cl_addr);
                free(sp->nsi_scsi.ns_adapter_name);
                if (sp->nsi_tape.nt_fd != -1) {
                        free(sp->nsi_tape.nt_dev_name);
                        free(sp->nsi_tape.nt_adapter_name);
                }
                if ((sp->nsi_pver == NDMP_V3) || (sp->nsi_pver == NDMP_V4))
                        free(sp->nsi_mover.nm_tcp_addr);

                ep = sp->nsi_data.nd_env;
                for (j = 0; j < sp->nsi_data.nd_env_len; j++, ep++) {
                        free(ep->np_name);
                        free(ep->np_value);
                }
                free(sp->nsi_data.nd_env);
                free(sp->nsi_data.nd_tcp_addr);

                if (sp->nsi_pver == NDMP_V2) {
                        np = sp->nsi_data.nd_nlist.nld_nlist;
                        for (j = 0; j < sp->nsi_data.nld_nlist_len; j++, np++) {
                                free(np->nn_name);
                                free(np->nn_dest);
                        }
                        free(sp->nsi_data.nd_nlist.nld_nlist);
                } else if ((sp->nsi_pver == NDMP_V3) ||
                    (sp->nsi_pver == NDMP_V4)) {
                        npv3 = sp->nsi_data.nd_nlist.nld_dt_v3.dv3_nlist;
                        for (j = 0; j < sp->nsi_data.nld_nlist_len;
                            j++, npv3++) {
                                free(npv3->nn3_opath);
                                free(npv3->nn3_dpath);
                        }
                        free(sp->nsi_data.nd_nlist.nld_dt_v3.dv3_nlist);
                }
        }
        free(sinfo);
}

/* ARGSUSED */
int
ndmp_get_stats(ndmp_stat_t *statp)
{
        int opcode = NDMP_GET_STAT;

        (void) mutex_lock(&ndmp_lock);
        if (!statp) {
                ndmp_errno = ENDMP_INVALID_ARG;
                goto err;
        }

        if (ndmp_door_setup(opcode))
                goto err;

        if (ndmp_door_call())
                goto err;

        statp->ns_trun = ndmp_door_get_uint32(dec_ctx);
        statp->ns_twait = ndmp_door_get_uint32(dec_ctx);
        statp->ns_nbk = ndmp_door_get_uint32(dec_ctx);
        statp->ns_nrs = ndmp_door_get_uint32(dec_ctx);
        statp->ns_rfile = ndmp_door_get_uint32(dec_ctx);
        statp->ns_wfile = ndmp_door_get_uint32(dec_ctx);
        statp->ns_rdisk = ndmp_door_get_uint64(dec_ctx);
        statp->ns_wdisk = ndmp_door_get_uint64(dec_ctx);
        statp->ns_rtape = ndmp_door_get_uint64(dec_ctx);
        statp->ns_wtape = ndmp_door_get_uint64(dec_ctx);

        if (ndmp_door_fini())
                goto err;

        (void) mutex_unlock(&ndmp_lock);
        return (0);
err:
        (void) mutex_unlock(&ndmp_lock);
        return (-1);
}

int
ndmp_door_status(void)
{
        int opcode = NDMP_GET_DOOR_STATUS;

        (void) mutex_lock(&ndmp_lock);
        if (ndmp_door_setup(opcode))
                goto err;

        if (ndmp_door_call())
                goto err;

        if (ndmp_door_fini())
                goto err;

        (void) mutex_unlock(&ndmp_lock);
        return (0);
err:
        (void) mutex_unlock(&ndmp_lock);
        return (-1);
}

static int
ndmp_door_setup(int opcode)
{
        /* Open channel to NDMP service */
        if ((ndmp_door_fildes == -1) &&
            (ndmp_door_fildes = open(NDMP_DOOR_SVC, O_RDONLY)) < 0) {
                ndmp_errno = ENDMP_DOOR_OPEN;
                return (-1);
        }

        buf = malloc(NDMP_DOOR_SIZE);
        if (!buf) {
                ndmp_errno = ENDMP_MEM_ALLOC;
                return (-1);
        }

        enc_ctx = ndmp_door_encode_start(buf, NDMP_DOOR_SIZE);
        if (enc_ctx == 0) {
                free(buf);
                ndmp_errno = ENDMP_DOOR_ENCODE_START;
                return (-1);
        }
        ndmp_door_put_uint32(enc_ctx, opcode);
        return (0);
}

static int
ndmp_door_call(void)
{
        uint32_t used;
        int rc;

        if ((ndmp_door_encode_finish(enc_ctx, &used)) != 0) {
                free(buf);
                ndmp_errno = ENDMP_DOOR_ENCODE_FINISH;
                return (-1);
        }

        arg.data_ptr = buf;
        arg.data_size = used;
        arg.desc_ptr = NULL;
        arg.desc_num = 0;
        arg.rbuf = buf;
        arg.rsize = NDMP_DOOR_SIZE;

        if (door_call(ndmp_door_fildes, &arg) < 0) {
                free(buf);
                ndmp_errno = ENDMP_DOOR_SRV_TIMEOUT;
                (void) close(ndmp_door_fildes);
                ndmp_door_fildes = -1;
                return (-1);
        }

        dec_ctx = ndmp_door_decode_start(arg.data_ptr, arg.data_size);
        rc = ndmp_door_get_uint32(dec_ctx);
        if (rc != NDMP_DOOR_SRV_SUCCESS) {
                free(buf);
                ndmp_errno = ENDMP_DOOR_SRV_OPERATION;
                return (-1);
        }
        return (0);
}

static int
ndmp_door_fini(void)
{
        if ((ndmp_door_decode_finish(dec_ctx)) != 0) {
                free(buf);
                ndmp_errno = ENDMP_DOOR_DECODE_FINISH;
                return (-1);
        }
        free(buf);
        return (0);
}