/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2001-2002 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <strings.h>
#include <string.h>
#include <fcntl.h>
#include <assert.h>
#include <libipp.h>
#include <libnvpair.h>
#include <ipp/ippctl.h>

/*
 * Debug macros
 */

#if     defined(DEBUG) && !defined(lint)
uint32_t        ipp_debug_flags =
/*
 * DBG_IO |
 */
DBG_ERR |
0;

#define DBG0(flags, fmt)                                                \
        do {                                                            \
                if (flags & ipp_debug_flags)                            \
                        fprintf(stderr, "libipp: " __FN__ ": " fmt);    \
        } while (0)

#define DBG1(flags, fmt, a)                                             \
        do {                                                            \
                if (flags & ipp_debug_flags)                            \
                        fprintf(stderr, "libipp: " __FN__ ": " fmt, a); \
        } while (0)

#define DBG2(flags, fmt, a, b)                                          \
        do {                                                            \
                if (flags & ipp_debug_flags)                            \
                        fprintf(stderr, "libipp: " __FN__ ": " fmt, a,  \
                            b);                                         \
        } while (0)

#define DBG3(flags, fmt, a, b, c)                                       \
        do {                                                            \
                if (flags & ipp_debug_flags)                            \
                        fprintf(stderr, "libipp: " __FN__ ": " fmt, a,  \
                            b, c);                                      \
        } while (0)

#else   /* defined(DEBUG) && !defined(lint) */
#define DBG0(flags, fmt)
#define DBG1(flags, fmt, a)
#define DBG2(flags, fmt, a, b)
#define DBG3(flags, fmt, a, b, c)
#endif  /* defined(DEBUG) && !defined(lint) */

/*
 * Control device node
 */

#define IPPCTL_DEVICE   "/devices/pseudo/ippctl@0:ctl"

/*
 * Structures.
 */

typedef struct array_desc_t {
        char    *name;
        char    **array;
        int     nelt;
} array_desc_t;

/*
 * Prototypes
 */

static int      nvlist_callback(nvlist_t *, void *);
static int      string_callback(nvlist_t *, void *);
static int      string_array_callback(nvlist_t *, void *);
static int      dispatch(nvlist_t **, int (*)(nvlist_t *, void *), void *);

/*
 * API functions
 */
#define __FN__  "ipp_action_create"
int
ipp_action_create(
        const char      *modname,
        const char      *aname,
        nvlist_t        **nvlpp,
        ipp_flags_t     flags)
{
        nvlist_t        *nvlp;
        int             rc;

        /*
         * Sanity check the arguments.
         */

        if (nvlpp == NULL || modname == NULL || aname == NULL) {
                DBG0(DBG_ERR, "bad argument\n");
                errno = EINVAL;
                return (-1);
        }

        /*
         * Add our data to the nvlist. (This information will be removed for
         * use by ippctl).
         */

        nvlp = *nvlpp;
        if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
            IPPCTL_OP_ACTION_CREATE)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
                goto failed;
        }

        if ((rc = nvlist_add_string(nvlp, IPPCTL_MODNAME,
            (char *)modname)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n",
                    IPPCTL_MODNAME);
                goto failed;
        }

        if ((rc = nvlist_add_string(nvlp, IPPCTL_ANAME, (char *)aname)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_ANAME);
                goto failed;
        }

        if ((rc = nvlist_add_uint32(nvlp, IPPCTL_FLAGS, flags)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_FLAGS);
                goto failed;
        }

        /*
         * Talk to the kernel.
         */

        return (dispatch(nvlpp, nvlist_callback, (void *)nvlpp));
failed:
        errno = rc;
        return (-1);
}
#undef  __FN__

#define __FN__  "ipp_action_destroy"
int
ipp_action_destroy(
        const char      *aname,
        ipp_flags_t     flags)
{
        nvlist_t        *nvlp;
        int             rc;

        /*
         * Sanity check the arguments.
         */

        if (aname == NULL) {
                DBG0(DBG_ERR, "bad argument\n");
                errno = EINVAL;
                return (-1);
        }

        /*
         * Create an nvlist for our data as none is passed into the function.
         */

        if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0)) != 0) {
                DBG0(DBG_ERR, "failed to allocate nvlist\n");
                nvlp = NULL;
                goto failed;
        }

        if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
            IPPCTL_OP_ACTION_DESTROY)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
                goto failed;
        }

        if ((rc = nvlist_add_string(nvlp, IPPCTL_ANAME, (char *)aname)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_ANAME);
                goto failed;
        }

        if ((rc = nvlist_add_uint32(nvlp, IPPCTL_FLAGS, flags)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_FLAGS);
                goto failed;
        }

        /*
         * Talk to the kernel.
         */

        return (dispatch(&nvlp, NULL, NULL));
failed:
        nvlist_free(nvlp);
        errno = rc;
        return (-1);
}
#undef  __FN__

#define __FN__  "ipp_action_modify"
int
ipp_action_modify(
        const char      *aname,
        nvlist_t        **nvlpp,
        ipp_flags_t     flags)
{
        nvlist_t        *nvlp;
        int             rc;

        /*
         * Sanity check the arguments.
         */

        if (nvlpp == NULL || aname == NULL) {
                DBG0(DBG_ERR, "bad argument\n");
                errno = EINVAL;
                return (-1);
        }

        /*
         * Add our data to the nvlist.
         */

        nvlp = *nvlpp;
        if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
            IPPCTL_OP_ACTION_MODIFY)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
                goto failed;
        }

        if ((rc = nvlist_add_string(nvlp, IPPCTL_ANAME, (char *)aname)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_ANAME);
                goto failed;
        }

        if ((rc = nvlist_add_uint32(nvlp, IPPCTL_FLAGS, flags)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_FLAGS);
                goto failed;
        }

        /*
         * Talk to the kernel.
         */

        return (dispatch(nvlpp, nvlist_callback, (void *)nvlpp));
failed:
        errno = rc;
        return (-1);
}
#undef  __FN__

#define __FN__  "ipp_action_info"
int
ipp_action_info(
        const char      *aname,
        int             (*fn)(nvlist_t *, void *),
        void            *arg,
        ipp_flags_t     flags)
{
        nvlist_t        *nvlp;
        int             rc;

        /*
         * Sanity check the arguments.
         */

        if (aname == NULL || fn == NULL) {
                DBG0(DBG_ERR, "bad argument\n");
                errno = EINVAL;
                return (-1);
        }

        /*
         * Create an nvlist for our data.
         */

        if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0)) != 0) {
                DBG0(DBG_ERR, "failed to allocate nvlist\n");
                nvlp = NULL;
        }

        if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
            IPPCTL_OP_ACTION_INFO)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
                goto failed;
        }

        if ((rc = nvlist_add_string(nvlp, IPPCTL_ANAME, (char *)aname)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_ANAME);
                goto failed;
        }

        if ((rc = nvlist_add_uint32(nvlp, IPPCTL_FLAGS, flags)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_FLAGS);
                goto failed;
        }

        /*
         * Talk to the kernel.
         */

        return (dispatch(&nvlp, fn, arg));
failed:
        nvlist_free(nvlp);
        errno = rc;
        return (-1);
}
#undef  __FN__

#define __FN__  "ipp_action_mod"
int
ipp_action_mod(
        const char      *aname,
        char            **modnamep)
{
        nvlist_t        *nvlp;
        int             rc;

        /*
         * Sanity check the arguments.
         */

        if (aname == NULL || modnamep == NULL) {
                DBG0(DBG_ERR, "bad argument\n");
                errno = EINVAL;
                return (-1);
        }

        /*
         * Create an nvlist for our data.
         */

        if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0)) != 0) {
                DBG0(DBG_ERR, "failed to allocate nvlist\n");
                nvlp = NULL;
                goto failed;
        }

        if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
            IPPCTL_OP_ACTION_MOD)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
                goto failed;
        }

        if ((rc = nvlist_add_string(nvlp, IPPCTL_ANAME, (char *)aname)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_ANAME);
                goto failed;
        }

        /*
         * Talk to the kernel.
         */

        return (dispatch(&nvlp, string_callback, (void *)modnamep));
failed:
        nvlist_free(nvlp);
        errno = rc;
        return (-1);
}
#undef  __FN__

#define __FN__  "ipp_list_mods"
int
ipp_list_mods(
        char            ***modname_arrayp,
        int             *neltp)
{
        nvlist_t        *nvlp;
        array_desc_t    ad;
        int             rc;

        /*
         * Sanity check the arguments.
         */

        if (modname_arrayp == NULL || neltp == NULL) {
                DBG0(DBG_ERR, "bad argument");
                errno = EINVAL;
                return (-1);
        }

        /*
         * Create an nvlist for our data.
         */

        if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0)) != 0) {
                DBG0(DBG_ERR, "failed to allocate nvlist\n");
                nvlp = NULL;
        }

        if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
            IPPCTL_OP_LIST_MODS)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
                goto failed;
        }

        /*
         * Talk to the kernel.
         */

        ad.name = IPPCTL_MODNAME_ARRAY;
        ad.array = NULL;
        ad.nelt = 0;

        if ((rc = dispatch(&nvlp, string_array_callback, (void *)&ad)) == 0) {
                *modname_arrayp = ad.array;
                *neltp = ad.nelt;
        }

        return (rc);
failed:
        nvlist_free(nvlp);
        errno = rc;
        return (-1);
}
#undef  __FN__

#define __FN__  "ipp_mod_list_actions"
int
ipp_mod_list_actions(
        const char      *modname,
        char            ***aname_arrayp,
        int             *neltp)
{
        nvlist_t        *nvlp;
        array_desc_t    ad;
        int             rc;

        /*
         * Sanity check the arguments.
         */

        if (modname == NULL || aname_arrayp == NULL || neltp == NULL) {
                DBG0(DBG_ERR, "bad argument");
                errno = EINVAL;
                return (-1);
        }

        /*
         * Create an nvlist for our data.
         */

        if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, 0)) != 0) {
                DBG0(DBG_ERR, "failed to allocate nvlist\n");
                nvlp = NULL;
        }

        if ((rc = nvlist_add_byte(nvlp, IPPCTL_OP,
            IPPCTL_OP_MOD_LIST_ACTIONS)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_OP);
                goto failed;
        }

        if ((rc = nvlist_add_string(nvlp, IPPCTL_MODNAME,
            (char *)modname)) != 0) {
                DBG1(DBG_ERR, "failed to add '%s' to nvlist\n", IPPCTL_MODNAME);
                goto failed;
        }

        /*
         * Talk to the kernel.
         */

        ad.name = IPPCTL_ANAME_ARRAY;
        ad.array = NULL;
        ad.nelt = 0;

        if ((rc = dispatch(&nvlp, string_array_callback, (void *)&ad)) == 0) {
                *aname_arrayp = ad.array;
                *neltp = ad.nelt;
        }

        return (rc);
failed:
        nvlist_free(nvlp);
        errno = rc;
        return (-1);
}
#undef  __FN__

#define __FN__  "ipp_free"
void
ipp_free(
        char    *buf)
{
        free(buf);
}
#undef  __FN__

#define __FN__  "ipp_free_array"
void
ipp_free_array(
        char    **array,
        int     nelt)
{
        int     i;

        assert(array[nelt] == NULL);

        for (i = 0; i < nelt; i++)
                free(array[i]);

        free(array);
}
#undef  __FN__

#define __FN__  "nvlist_callback"
static int
nvlist_callback(
        nvlist_t        *nvlp,
        void            *arg)
{
        nvlist_t        **nvlpp = (nvlist_t **)arg;
        int             rc;

        /*
         * Callback function used by ipp_action_create() and
         * ipp_action_modify()
         */

        DBG0(DBG_IO, "called\n");

        assert(nvlpp != NULL);
        assert(*nvlpp == NULL);

        /*
         * Duplicate the nvlist and set the given pointer to point at the new
         * copy.
         */

        if ((rc = nvlist_dup(nvlp, nvlpp, 0)) != 0) {
                DBG0(DBG_ERR, "failed to dup nvlist\n");
                errno = rc;
                return (-1);
        }

        return (0);
}
#undef  __FN__

#define __FN__  "string_callback"
static int
string_callback(
        nvlist_t        *nvlp,
        void            *arg)
{
        char            **namep = (char **)arg;
        char            *name;
        char            *ptr;
        int             rc;

        /*
         * Callback function used by ipp_action_mod()
         */

        DBG0(DBG_IO, "called\n");

        assert(namep != NULL);

        /*
         * Look up the module name from the nvlist.
         */

        if ((rc = nvlist_lookup_string(nvlp, IPPCTL_MODNAME, &ptr)) != 0) {
                DBG0(DBG_ERR, "failed to find string\n");
                errno = rc;
                return (-1);
        }

        /*
         * Allocate a duplicate string.
         */

        if ((name = strdup(ptr)) == NULL) {
                DBG0(DBG_ERR, "failed to duplicate string\n");
                return (-1);
        }

        /*
         * Set the given pointer to point at the string.
         */

        *namep = name;
        return (0);
}
#undef  __FN__

#define __FN__  "string_array_callback"
static int
string_array_callback(
        nvlist_t        *nvlp,
        void            *arg)
{
        array_desc_t    *adp = (array_desc_t *)arg;
        char            **dst;
        char            **src;
        uint_t          nelt;
        int             i;
        int             rc;

        /*
         * Callback function used by ipp_list_mods()
         */

        DBG0(DBG_IO, "called\n");

        assert(adp != NULL);

        /*
         * Look up the module name from the nvlist.
         */

        if ((rc = nvlist_lookup_string_array(nvlp, adp->name, &src,
            &nelt)) != 0) {
                DBG0(DBG_ERR, "failed to find array\n");
                errno = rc;
                return (-1);
        }

        /*
         * Allocate an array.
         */

        if ((dst = malloc((nelt + 1) * sizeof (char *))) == NULL) {
                DBG0(DBG_ERR, "failed to allocate new array\n");
                return (-1);
        }

        /*
         * For each string in the array, allocate a new buffer and copy
         * the string into it.
         */

        for (i = 0; i < nelt; i++) {
                if ((dst[i] = strdup(src[i])) == NULL) {
                        while (--i >= 0) {
                                free(dst[i]);
                        }
                        free(dst);
                        DBG0(DBG_ERR, "failed to duplicate array\n");
                        return (-1);
                }
        }
        dst[nelt] = NULL;

        /*
         * Set the information to be passed back.
         */

        adp->array = dst;
        adp->nelt = nelt;

        return (0);
}
#undef  __FN__

#define __FN__  "dispatch"
static int
dispatch(
        nvlist_t        **nvlpp,
        int             (*fn)(nvlist_t *, void *),
        void            *arg)
{
        char            *cbuf = NULL;
        char            *dbuf = NULL;
        size_t          cbuflen = 0;
        size_t          dbuflen = 0;
        size_t          thisbuflen = 0;
        size_t          nextbuflen = 0;
        int             rc;
        ippctl_ioctl_t  iioc;
        int             fd;
        nvlist_t        *cnvlp;
        nvlist_t        *dnvlp = NULL;
        int             count;
        int             rval;

        /*
         * Sanity check the 'command' nvlist.
         */

        cnvlp = *nvlpp;
        if (cnvlp == NULL) {
                rc = EINVAL;
                return (-1);
        }

        /*
         * Pack the nvlist and then free the original.
         */

        if ((rc = nvlist_pack(cnvlp, &cbuf, &cbuflen, NV_ENCODE_NATIVE,
            0)) != 0) {
                DBG0(DBG_ERR, "failed to pack nvlist\n");
                nvlist_free(cnvlp);
                errno = rc;
                return (-1);
        }
        nvlist_free(cnvlp);
        *nvlpp = NULL;

        /*
         * Open the control device node.
         */

        DBG1(DBG_IO, "opening %s\n", IPPCTL_DEVICE);
        if ((fd = open(IPPCTL_DEVICE, O_RDWR | O_NOCTTY)) == -1) {
                DBG1(DBG_ERR, "failed to open %s\n", IPPCTL_DEVICE);
                goto command_failed;
        }

        /*
         * Set up an ioctl structure to point at the packed nvlist.
         */

        iioc.ii_buf = cbuf;
        iioc.ii_buflen = cbuflen;

        /*
         * Issue a command ioctl, passing the ioctl structure.
         */

        DBG0(DBG_IO, "command\n");
        if ((rc = ioctl(fd, IPPCTL_CMD, &iioc)) < 0) {
                DBG0(DBG_ERR, "command ioctl failed\n");
                goto command_failed;
        }

        /*
         * Get back the length of the first data buffer.
         */

        if ((nextbuflen = (size_t)rc) == 0) {
                DBG0(DBG_ERR, "no data buffer\n");
                errno = EPROTO;
                goto command_failed;
        }

        /*
         * Try to re-use the command buffer as the first data buffer.
         */

        dbuf = cbuf;
        thisbuflen = cbuflen;

        count = 0;
        while (nextbuflen != 0) {
                dbuflen = nextbuflen;

                /*
                 * Check whether the buffer we have is long enough for the
                 * next lot of data. If it isn't, allocate a new one of
                 * the appropriate length.
                 */

                if (nextbuflen > thisbuflen) {
                        if ((dbuf = realloc(dbuf, nextbuflen)) == NULL) {
                                DBG0(DBG_ERR,
                                    "failed to allocate data buffer\n");
                                goto data_failed;
                        }
                        thisbuflen = nextbuflen;
                }

                /*
                 * Set up an ioctl structure to point at the data buffer.
                 */

                iioc.ii_buf = dbuf;
                iioc.ii_buflen = dbuflen;

                /*
                 * Issue a data ioctl, passing the ioctl structure.
                 */

                DBG2(DBG_IO, "data[%d]: length = %d\n", count, dbuflen);
                if ((rc = ioctl(fd, IPPCTL_DATA, &iioc)) < 0) {
                        DBG0(DBG_ERR, "data ioctl failed\n");
                        goto data_failed;
                }

                /*
                 * Get the length of the *next* data buffer, if there is
                 * one.
                 */

                nextbuflen = (size_t)rc;
                DBG1(DBG_IO, "nextbuflen = %d\n", nextbuflen);

                /*
                 * Unpack the nvlist that the current data buffer should
                 * now contain.
                 */

                if ((rc = nvlist_unpack(dbuf, dbuflen, &dnvlp, 0)) != 0) {
                        DBG0(DBG_ERR, "failed to unpack nvlist\n");
                        errno = rc;
                        goto data_failed;
                }

                /*
                 * The first data buffer should contain the kernel function's
                 * return code. Subsequent buffers contain nvlists which
                 * should be passed to the given callback function.
                 */

                if (count == 0) {
                        if ((rc = nvlist_lookup_int32(dnvlp, IPPCTL_RC,
                            &rval)) != 0) {
                                DBG0(DBG_ERR, "failed to find return code\n");
                                nvlist_free(dnvlp);
                                errno = rc;
                                goto data_failed;
                        }
                } else {
                        if (fn != NULL)
                                if (fn(dnvlp, arg) != 0) {

                                        /*
                                         * The callback function returned
                                         * a non-zero value. Abort any further
                                         * data collection.
                                         */

                                        nvlist_free(dnvlp);
                                        free(dbuf);
                                }
                }

                /*
                 * Free the nvlist now that we have extracted the return
                 * code or called the callback function.
                 */

                nvlist_free(dnvlp);
                dnvlp = NULL;

                count++;
        }

        /*
         * Free the data buffer as data collection is now complete.
         */

        free(dbuf);

        /*
         * Close the control device.
         */

        (void) close(fd);

        /*
         * If the kernel returned an error, we should return an error.
         * and set errno.
         */

        if (rval != 0) {
                DBG1(DBG_IO, "kernel return code = %d\n", rval);
                errno = rval;
                return (-1);
        }

        return (0);

command_failed:
        free(cbuf);
        if (fd != -1)
                (void) close(fd);
        return (-1);

data_failed:
        if (dbuf != NULL)
                free(dbuf);
        (void) close(fd);
        return (-1);
}
#undef  __FN__