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

/* This file contains all the door server code */

#include <door.h>
#include <alloca.h>
#include <errno.h>
#include <note.h>
#include <libintl.h>
#include <ndmpd_door.h>
#include "ndmpd.h"

/* static variables */
static int      ndmp_door_fildes = -1;
static mutex_t  ndmp_doorsrv_mutex;

/* static routines */
static void ndmp_door_server(void *cookie, char *ptr, size_t size,
    door_desc_t *dp, uint_t n_desc);

/*
 * Statistics used in ndmpstat command
 */
ndmp_stat_t ndstat;

int
ndmp_door_init(void)
{
        int fd;

        (void) mutex_lock(&ndmp_doorsrv_mutex);

        if (ndmp_door_fildes != -1) {
                NDMP_LOG(LOG_DEBUG,
                    "ndmp_door_init: ndmpd service is already running.");
                (void) mutex_unlock(&ndmp_doorsrv_mutex);
                return (0);
        }

        if ((ndmp_door_fildes = door_create(ndmp_door_server,
            NULL, DOOR_UNREF)) < 0) {
                NDMP_LOG(LOG_DEBUG, "ndmp_door_init: Could not create door.");
                (void) mutex_unlock(&ndmp_doorsrv_mutex);
                return (-1);
        }

        (void) unlink(NDMP_DOOR_SVC);

        if ((fd = creat(NDMP_DOOR_SVC, 0444)) < 0) {
                NDMP_LOG(LOG_DEBUG, "ndmp_door_init: Can't create %s: %m.",
                    NDMP_DOOR_SVC);
                (void) door_revoke(ndmp_door_fildes);
                ndmp_door_fildes = -1;
                (void) mutex_unlock(&ndmp_doorsrv_mutex);
                return (-1);
        }

        (void) close(fd);
        (void) fdetach(NDMP_DOOR_SVC);

        if (fattach(ndmp_door_fildes, NDMP_DOOR_SVC) < 0) {
                NDMP_LOG(LOG_DEBUG, "ndmp_door_init: fattach failed %m");
                (void) door_revoke(ndmp_door_fildes);
                ndmp_door_fildes = -1;
                (void) mutex_unlock(&ndmp_doorsrv_mutex);
                return (-1);
        }

        NDMP_LOG(LOG_DEBUG, "ndmp_door_init: Door server successfully started");
        (void) mutex_unlock(&ndmp_doorsrv_mutex);
        return (0);
}

void
ndmp_door_fini(void)
{
        (void) mutex_lock(&ndmp_doorsrv_mutex);

        if (ndmp_door_fildes != -1) {
                (void) fdetach(NDMP_DOOR_SVC);
                (void) door_revoke(ndmp_door_fildes);
                ndmp_door_fildes = -1;
        }

        (void) mutex_unlock(&ndmp_doorsrv_mutex);
}

boolean_t
ndmp_door_check(void)
{
        door_info_t info;
        int door;

        if ((door = open(NDMP_DOOR_SVC, O_RDONLY)) < 0)
                return (0);

        if (door_info(door, &info) < 0) {
                (void) close(door);
                return (0);
        }

        if (info.di_target > 0) {
                NDMP_LOG(LOG_ERR,
                    "Service already running: pid %ld", info.di_target);
                (void) close(door);
                return (1);
        }

        (void) close(door);
        return (0);
}

/* door server */
/*ARGSUSED*/
void
ndmp_door_server(void *cookie, char *ptr, size_t size,
    door_desc_t *dp, uint_t n_desc)
{
        NOTE(ARGUNUSED(cookie,dp,n_desc))
        int req_type;
        char *buf;
        int buflen;
        unsigned int used;
        ndmp_door_ctx_t *dec_ctx;
        ndmp_door_ctx_t *enc_ctx;
        unsigned int dec_status;
        unsigned int enc_status;

        dec_ctx = ndmp_door_decode_start(ptr, size);
        if (dec_ctx == 0)
                return;

        req_type = ndmp_door_get_uint32(dec_ctx);
        buflen = NDMP_DOOR_SIZE;

        if ((buf = alloca(buflen)) == NULL) {
                NDMP_LOG(LOG_DEBUG, "Out of memory.");
                (void) ndmp_door_decode_finish(dec_ctx);
                return;
        }

        enc_ctx = ndmp_door_encode_start(buf, buflen);
        if (enc_ctx == 0) {
                (void) ndmp_door_decode_finish(dec_ctx);
                return;
        }

        if (req_type != NDMP_GET_STAT)
                NDMP_LOG(LOG_DEBUG, "ndmp_door_server: req_type=%d", req_type);

        switch (req_type) {
        case NDMP_GET_DOOR_STATUS: {
                ndmp_door_put_int32(enc_ctx, NDMP_DOOR_SRV_SUCCESS);
                break;
                }
        case NDMP_DEVICES_GET_INFO: {
                ndmp_door_put_int32(enc_ctx, NDMP_DOOR_SRV_SUCCESS);
                ndmpd_get_devs(enc_ctx);
                break;
                }
        case NDMP_SHOW: {
                ndmp_door_put_int32(enc_ctx, NDMP_DOOR_SRV_SUCCESS);
                ndmp_connect_list_get(enc_ctx);
                break;
                }
        case NDMP_TERMINATE_SESSION_ID: {
                int status, id;
                id = ndmp_door_get_int32(dec_ctx);
                status = ndmpd_connect_kill_id(id);
                if (status == -1) /* session not found */
                        ndmp_door_put_int32(enc_ctx,
                            NDMP_DOOR_SRV_SUCCESS);
                else
                        ndmp_door_put_int32(enc_ctx,
                            NDMP_DOOR_SRV_SUCCESS);
                ndmp_door_put_int32(enc_ctx, status);
                break;
                }

        case NDMP_GET_STAT:
                ndmp_door_put_int32(enc_ctx, NDMP_DOOR_SRV_SUCCESS);
                ndmp_door_put_uint32(enc_ctx, ndstat.ns_trun);
                ndmp_door_put_uint32(enc_ctx, ndstat.ns_twait);
                ndmp_door_put_uint32(enc_ctx, ndstat.ns_nbk);
                ndmp_door_put_uint32(enc_ctx, ndstat.ns_nrs);
                ndmp_door_put_uint32(enc_ctx, ndstat.ns_rfile);
                ndmp_door_put_uint32(enc_ctx, ndstat.ns_wfile);
                ndmp_door_put_uint64(enc_ctx, ndstat.ns_rdisk);
                ndmp_door_put_uint64(enc_ctx, ndstat.ns_wdisk);
                ndmp_door_put_uint64(enc_ctx, ndstat.ns_rtape);
                ndmp_door_put_uint64(enc_ctx, ndstat.ns_wtape);
                break;

        default:
                NDMP_LOG(LOG_DEBUG,
                    "ndmp_door_server: Invalid request type 0x%x", req_type);
                goto decode_error;
        }

        if ((dec_status = ndmp_door_decode_finish(dec_ctx)) != 0)
                goto decode_error;

        if ((enc_status = ndmp_door_encode_finish(enc_ctx, &used)) != 0)
                goto encode_error;

        (void) door_return(buf, used, NULL, 0);

        return;

decode_error:
        ndmp_door_put_int32(enc_ctx, NDMP_DOOR_SRV_ERROR);
        ndmp_door_put_uint32(enc_ctx, dec_status);
        (void) ndmp_door_encode_finish(enc_ctx, &used);
        (void) door_return(buf, used, NULL, 0);
        return;

encode_error:
        enc_ctx = ndmp_door_encode_start(buf, buflen);
        ndmp_door_put_int32(enc_ctx, NDMP_DOOR_SRV_ERROR);
        ndmp_door_put_uint32(enc_ctx, enc_status);
        (void) ndmp_door_encode_finish(enc_ctx, &used);
        (void) door_return(buf, used, NULL, 0);
}