8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / cmd / hotplugd / hotplugd_door.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <strings.h>
#include <alloca.h>
#include <door.h>
#include <pthread.h>
#include <synch.h>
#include <pwd.h>
#include <auth_list.h>
#include <auth_attr.h>
#include <bsm/adt.h>
#include <bsm/adt_event.h>
#include <sys/sunddi.h>
#include <sys/ddi_hp.h>
#include <libnvpair.h>
#include <libhotplug.h>
#include <libhotplug_impl.h>
#include "hotplugd_impl.h"

/*
 * Buffer management for results.
 */
typedef struct i_buffer {
        uint64_t        seqnum;
        char            *buffer;
        struct i_buffer *next;
} i_buffer_t;

static uint64_t         buffer_seqnum = 1;
static i_buffer_t       *buffer_list = NULL;
static pthread_mutex_t  buffer_lock = PTHREAD_MUTEX_INITIALIZER;

/*
 * Door file descriptor.
 */
static int      door_fd = -1;

/*
 * Function prototypes.
 */
static void     door_server(void *, char *, size_t, door_desc_t *, uint_t);
static int      check_auth(ucred_t *, const char *);
static int      cmd_getinfo(nvlist_t *, nvlist_t **);
static int      cmd_changestate(nvlist_t *, nvlist_t **);
static int      cmd_private(hp_cmd_t, nvlist_t *, nvlist_t **);
static void     add_buffer(uint64_t, char *);
static void     free_buffer(uint64_t);
static uint64_t get_seqnum(void);
static char     *state_str(int);
static int      audit_session(ucred_t *, adt_session_data_t **);
static void     audit_changestate(ucred_t *, char *, char *, char *, int, int,
                    int);
static void     audit_setprivate(ucred_t *, char *, char *, char *, char *,
                    int);

/*
 * door_server_init()
 *
 *      Create the door file, and initialize the door server.
 */
boolean_t
door_server_init(void)
{
        int     fd;

        /* Create the door file */
        if ((fd = open(HOTPLUGD_DOOR, O_CREAT|O_EXCL|O_RDONLY, 0644)) == -1) {
                if (errno == EEXIST) {
                        log_err("Door service is already running.\n");
                } else {
                        log_err("Cannot open door file '%s': %s\n",
                            HOTPLUGD_DOOR, strerror(errno));
                }
                return (B_FALSE);
        }
        (void) close(fd);

        /* Initialize the door service */
        if ((door_fd = door_create(door_server, NULL,
            DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) {
                log_err("Cannot create door service: %s\n", strerror(errno));
                return (B_FALSE);
        }

        /* Cleanup stale door associations */
        (void) fdetach(HOTPLUGD_DOOR);

        /* Associate door service with door file */
        if (fattach(door_fd, HOTPLUGD_DOOR) != 0) {
                log_err("Cannot attach to door file '%s': %s\n", HOTPLUGD_DOOR,
                    strerror(errno));
                (void) door_revoke(door_fd);
                (void) fdetach(HOTPLUGD_DOOR);
                door_fd = -1;
                return (B_FALSE);
        }

        return (B_TRUE);
}

/*
 * door_server_fini()
 *
 *      Terminate and cleanup the door server.
 */
void
door_server_fini(void)
{
        if (door_fd != -1) {
                (void) door_revoke(door_fd);
                (void) fdetach(HOTPLUGD_DOOR);
        }

        (void) unlink(HOTPLUGD_DOOR);
}

/*
 * door_server()
 *
 *      This routine is the handler which responds to each door call.
 *      Each incoming door call is expected to send a packed nvlist
 *      of arguments which describe the requested action.  And each
 *      response is sent back as a packed nvlist of results.
 *
 *      Results are always allocated on the heap.  A global list of
 *      allocated result buffers is managed, and each one is tracked
 *      by a unique sequence number.  The final step in the protocol
 *      is for the caller to send a short response using the sequence
 *      number when the buffer can be released.
 */
/*ARGSUSED*/
static void
door_server(void *cookie, char *argp, size_t sz, door_desc_t *dp, uint_t ndesc)
{
        nvlist_t        *args = NULL;
        nvlist_t        *results = NULL;
        hp_cmd_t        cmd;
        int             rv;

        dprintf("Door call: cookie=%p, argp=%p, sz=%d\n", cookie, (void *)argp,
            sz);

        /* Special case to free a results buffer */
        if (sz == sizeof (uint64_t)) {
                free_buffer(*(uint64_t *)(uintptr_t)argp);
                (void) door_return(NULL, 0, NULL, 0);
                return;
        }

        /* Unpack the arguments nvlist */
        if (nvlist_unpack(argp, sz, &args, 0) != 0) {
                log_err("Cannot unpack door arguments.\n");
                rv = EINVAL;
                goto fail;
        }

        /* Extract the requested command */
        if (nvlist_lookup_int32(args, HPD_CMD, (int32_t *)&cmd) != 0) {
                log_err("Cannot decode door command.\n");
                rv = EINVAL;
                goto fail;
        }

        /* Implement the command */
        switch (cmd) {
        case HP_CMD_GETINFO:
                rv = cmd_getinfo(args, &results);
                break;
        case HP_CMD_CHANGESTATE:
                rv = cmd_changestate(args, &results);
                break;
        case HP_CMD_SETPRIVATE:
        case HP_CMD_GETPRIVATE:
                rv = cmd_private(cmd, args, &results);
                break;
        default:
                rv = EINVAL;
                break;
        }

        /* The arguments nvlist is no longer needed */
        nvlist_free(args);
        args = NULL;

        /*
         * If an nvlist was constructed for the results,
         * then pack the results nvlist and return it.
         */
        if (results != NULL) {
                uint64_t        seqnum;
                char            *buf = NULL;
                size_t          len = 0;

                /* Add a sequence number to the results */
                seqnum = get_seqnum();
                if (nvlist_add_uint64(results, HPD_SEQNUM, seqnum) != 0) {
                        log_err("Cannot add sequence number.\n");
                        rv = EFAULT;
                        goto fail;
                }

                /* Pack the results nvlist */
                if (nvlist_pack(results, &buf, &len,
                    NV_ENCODE_NATIVE, 0) != 0) {
                        log_err("Cannot pack door results.\n");
                        rv = EFAULT;
                        goto fail;
                }

                /* Link results buffer into list */
                add_buffer(seqnum, buf);

                /* The results nvlist is no longer needed */
                nvlist_free(results);

                /* Return the results */
                (void) door_return(buf, len, NULL, 0);
                return;
        }

        /* Return result code (when no nvlist) */
        (void) door_return((char *)&rv, sizeof (int), NULL, 0);
        return;

fail:
        log_err("Door call failed (%s)\n", strerror(rv));
        nvlist_free(args);
        nvlist_free(results);
        (void) door_return((char *)&rv, sizeof (int), NULL, 0);
}

/*
 * check_auth()
 *
 *      Perform an RBAC authorization check.
 */
static int
check_auth(ucred_t *ucred, const char *auth)
{
        struct passwd   pwd;
        uid_t           euid;
        char            buf[MAXPATHLEN];

        euid = ucred_geteuid(ucred);

        if ((getpwuid_r(euid, &pwd, buf, sizeof (buf)) == NULL) ||
            (chkauthattr(auth, pwd.pw_name) == 0)) {
                log_info("Unauthorized door call.\n");
                return (-1);
        }

        return (0);
}

/*
 * cmd_getinfo()
 *
 *      Implements the door command to get a hotplug information snapshot.
 */
static int
cmd_getinfo(nvlist_t *args, nvlist_t **resultsp)
{
        hp_node_t       root;
        nvlist_t        *results;
        char            *path;
        char            *connection;
        char            *buf = NULL;
        size_t          len = 0;
        uint_t          flags;
        int             rv;

        dprintf("cmd_getinfo:\n");

        /* Get arguments */
        if (nvlist_lookup_string(args, HPD_PATH, &path) != 0) {
                dprintf("cmd_getinfo: invalid arguments.\n");
                return (EINVAL);
        }
        if (nvlist_lookup_string(args, HPD_CONNECTION, &connection) != 0)
                connection = NULL;
        if (nvlist_lookup_uint32(args, HPD_FLAGS, (uint32_t *)&flags) != 0)
                flags = 0;

        /* Get and pack the requested snapshot */
        if ((rv = getinfo(path, connection, flags, &root)) == 0) {
                rv = hp_pack(root, &buf, &len);
                hp_fini(root);
        }
        dprintf("cmd_getinfo: getinfo(): rv = %d, buf = %p.\n", rv,
            (void *)buf);

        /*
         * If the above failed or there is no snapshot,
         * then only return a status code.
         */
        if (rv != 0)
                return (rv);
        if (buf == NULL)
                return (EFAULT);

        /* Allocate nvlist for results */
        if (nvlist_alloc(&results, NV_UNIQUE_NAME_TYPE, 0) != 0) {
                dprintf("cmd_getinfo: nvlist_alloc() failed.\n");
                free(buf);
                return (ENOMEM);
        }

        /* Add snapshot and successful status to results */
        if ((nvlist_add_int32(results, HPD_STATUS, 0) != 0) ||
            (nvlist_add_byte_array(results, HPD_INFO,
            (uchar_t *)buf, len) != 0)) {
                dprintf("cmd_getinfo: nvlist add failure.\n");
                nvlist_free(results);
                free(buf);
                return (ENOMEM);
        }

        /* Packed snapshot no longer needed */
        free(buf);

        /* Success */
        *resultsp = results;
        return (0);
}

/*
 * cmd_changestate()
 *
 *      Implements the door command to initate a state change operation.
 *
 *      NOTE: requires 'modify' authorization.
 */
static int
cmd_changestate(nvlist_t *args, nvlist_t **resultsp)
{
        hp_node_t       root = NULL;
        nvlist_t        *results = NULL;
        char            *path, *connection;
        ucred_t         *uc = NULL;
        uint_t          flags;
        int             rv, state, old_state, status;

        dprintf("cmd_changestate:\n");

        /* Get arguments */
        if ((nvlist_lookup_string(args, HPD_PATH, &path) != 0) ||
            (nvlist_lookup_string(args, HPD_CONNECTION, &connection) != 0) ||
            (nvlist_lookup_int32(args, HPD_STATE, &state) != 0)) {
                dprintf("cmd_changestate: invalid arguments.\n");
                return (EINVAL);
        }
        if (nvlist_lookup_uint32(args, HPD_FLAGS, (uint32_t *)&flags) != 0)
                flags = 0;

        /* Get caller's credentials */
        if (door_ucred(&uc) != 0) {
                log_err("Cannot get door credentials (%s)\n", strerror(errno));
                return (EACCES);
        }

        /* Check authorization */
        if (check_auth(uc, HP_MODIFY_AUTH) != 0) {
                dprintf("cmd_changestate: access denied.\n");
                audit_changestate(uc, HP_MODIFY_AUTH, path, connection,
                    state, -1, ADT_FAIL_VALUE_AUTH);
                ucred_free(uc);
                return (EACCES);
        }

        /* Perform the state change operation */
        status = changestate(path, connection, state, flags, &old_state, &root);
        dprintf("cmd_changestate: changestate() == %d\n", status);

        /* Audit the operation */
        audit_changestate(uc, HP_MODIFY_AUTH, path, connection, state,
            old_state, status);

        /* Caller's credentials no longer needed */
        ucred_free(uc);

        /*
         * Pack the results into an nvlist if there is an error snapshot.
         *
         * If any error occurs while packing the results, the original
         * error code from changestate() above is still returned.
         */
        if (root != NULL) {
                char    *buf = NULL;
                size_t  len = 0;

                dprintf("cmd_changestate: results nvlist required.\n");

                /* Pack and discard the error snapshot */
                rv = hp_pack(root, &buf, &len);
                hp_fini(root);
                if (rv != 0) {
                        dprintf("cmd_changestate: hp_pack() failed (%s).\n",
                            strerror(rv));
                        return (status);
                }

                /* Allocate nvlist for results */
                if (nvlist_alloc(&results, NV_UNIQUE_NAME_TYPE, 0) != 0) {
                        dprintf("cmd_changestate: nvlist_alloc() failed.\n");
                        free(buf);
                        return (status);
                }

                /* Add the results into the nvlist */
                if ((nvlist_add_int32(results, HPD_STATUS, status) != 0) ||
                    (nvlist_add_byte_array(results, HPD_INFO, (uchar_t *)buf,
                    len) != 0)) {
                        dprintf("cmd_changestate: nvlist add failed.\n");
                        nvlist_free(results);
                        free(buf);
                        return (status);
                }

                *resultsp = results;
        }

        return (status);
}

/*
 * cmd_private()
 *
 *      Implementation of the door command to set or get bus private options.
 *
 *      NOTE: requires 'modify' authorization for the 'set' command.
 */
static int
cmd_private(hp_cmd_t cmd, nvlist_t *args, nvlist_t **resultsp)
{
        nvlist_t        *results = NULL;
        ucred_t         *uc = NULL;
        char            *path, *connection, *options;
        char            *values = NULL;
        int             status;

        dprintf("cmd_private:\n");

        /* Get caller's credentials */
        if ((cmd == HP_CMD_SETPRIVATE) && (door_ucred(&uc) != 0)) {
                log_err("Cannot get door credentials (%s)\n", strerror(errno));
                return (EACCES);
        }

        /* Get arguments */
        if ((nvlist_lookup_string(args, HPD_PATH, &path) != 0) ||
            (nvlist_lookup_string(args, HPD_CONNECTION, &connection) != 0) ||
            (nvlist_lookup_string(args, HPD_OPTIONS, &options) != 0)) {
                dprintf("cmd_private: invalid arguments.\n");
                return (EINVAL);
        }

        /* Check authorization */
        if ((cmd == HP_CMD_SETPRIVATE) &&
            (check_auth(uc, HP_MODIFY_AUTH) != 0)) {
                dprintf("cmd_private: access denied.\n");
                audit_setprivate(uc, HP_MODIFY_AUTH, path, connection, options,
                    ADT_FAIL_VALUE_AUTH);
                ucred_free(uc);
                return (EACCES);
        }

        /* Perform the operation */
        status = private_options(path, connection, cmd, options, &values);
        dprintf("cmd_private: private_options() == %d\n", status);

        /* Audit the operation */
        if (cmd == HP_CMD_SETPRIVATE) {
                audit_setprivate(uc, HP_MODIFY_AUTH, path, connection, options,
                    status);
                ucred_free(uc);
        }

        /* Construct an nvlist if values were returned */
        if (values != NULL) {

                /* Allocate nvlist for results */
                if (nvlist_alloc(&results, NV_UNIQUE_NAME_TYPE, 0) != 0) {
                        dprintf("cmd_private: nvlist_alloc() failed.\n");
                        free(values);
                        return (ENOMEM);
                }

                /* Add values and status to the results */
                if ((nvlist_add_int32(results, HPD_STATUS, status) != 0) ||
                    (nvlist_add_string(results, HPD_OPTIONS, values) != 0)) {
                        dprintf("cmd_private: nvlist add failed.\n");
                        nvlist_free(results);
                        free(values);
                        return (ENOMEM);
                }

                /* The values string is no longer needed */
                free(values);

                *resultsp = results;
        }

        return (status);
}

/*
 * get_seqnum()
 *
 *      Allocate the next unique sequence number for a results buffer.
 */
static uint64_t
get_seqnum(void)
{
        uint64_t seqnum;

        (void) pthread_mutex_lock(&buffer_lock);

        seqnum = buffer_seqnum++;

        (void) pthread_mutex_unlock(&buffer_lock);

        return (seqnum);
}

/*
 * add_buffer()
 *
 *      Link a results buffer into the list containing all buffers.
 */
static void
add_buffer(uint64_t seqnum, char *buf)
{
        i_buffer_t      *node;

        if ((node = (i_buffer_t *)malloc(sizeof (i_buffer_t))) == NULL) {
                /* The consequence is a memory leak. */
                log_err("Cannot allocate results buffer: %s\n",
                    strerror(errno));
                return;
        }

        node->seqnum = seqnum;
        node->buffer = buf;

        (void) pthread_mutex_lock(&buffer_lock);

        node->next = buffer_list;
        buffer_list = node;

        (void) pthread_mutex_unlock(&buffer_lock);
}

/*
 * free_buffer()
 *
 *      Remove a results buffer from the list containing all buffers.
 */
static void
free_buffer(uint64_t seqnum)
{
        i_buffer_t      *node, *prev;

        (void) pthread_mutex_lock(&buffer_lock);

        prev = NULL;
        node = buffer_list;

        while (node) {
                if (node->seqnum == seqnum) {
                        dprintf("Free buffer %lld\n", seqnum);
                        if (prev) {
                                prev->next = node->next;
                        } else {
                                buffer_list = node->next;
                        }
                        free(node->buffer);
                        free(node);
                        break;
                }
                prev = node;
                node = node->next;
        }

        (void) pthread_mutex_unlock(&buffer_lock);
}

/*
 * audit_session()
 *
 *      Initialize an audit session.
 */
static int
audit_session(ucred_t *ucred, adt_session_data_t **sessionp)
{
        adt_session_data_t      *session;

        if (adt_start_session(&session, NULL, 0) != 0) {
                log_err("Cannot start audit session.\n");
                return (-1);
        }

        if (adt_set_from_ucred(session, ucred, ADT_NEW) != 0) {
                log_err("Cannot set audit session from ucred.\n");
                (void) adt_end_session(session);
                return (-1);
        }

        *sessionp = session;
        return (0);
}

/*
 * audit_changestate()
 *
 *      Audit a 'changestate' door command.
 */
static void
audit_changestate(ucred_t *ucred, char *auth, char *path, char *connection,
    int new_state, int old_state, int result)
{
        adt_session_data_t      *session;
        adt_event_data_t        *event;
        int                     pass_fail, fail_reason;

        if (audit_session(ucred, &session) != 0)
                return;

        if ((event = adt_alloc_event(session, ADT_hotplug_state)) == NULL) {
                (void) adt_end_session(session);
                return;
        }

        if (result == 0) {
                pass_fail = ADT_SUCCESS;
                fail_reason = ADT_SUCCESS;
        } else {
                pass_fail = ADT_FAILURE;
                fail_reason = result;
        }

        event->adt_hotplug_state.auth_used = auth;
        event->adt_hotplug_state.device_path = path;
        event->adt_hotplug_state.connection = connection;
        event->adt_hotplug_state.new_state = state_str(new_state);
        event->adt_hotplug_state.old_state = state_str(old_state);

        /* Put the event */
        if (adt_put_event(event, pass_fail, fail_reason) != 0)
                log_err("Cannot put audit event.\n");

        adt_free_event(event);
        (void) adt_end_session(session);
}

/*
 * audit_setprivate()
 *
 *      Audit a 'set private' door command.
 */
static void
audit_setprivate(ucred_t *ucred, char *auth, char *path, char *connection,
    char *options, int result)
{
        adt_session_data_t      *session;
        adt_event_data_t        *event;
        int                     pass_fail, fail_reason;

        if (audit_session(ucred, &session) != 0)
                return;

        if ((event = adt_alloc_event(session, ADT_hotplug_set)) == NULL) {
                (void) adt_end_session(session);
                return;
        }

        if (result == 0) {
                pass_fail = ADT_SUCCESS;
                fail_reason = ADT_SUCCESS;
        } else {
                pass_fail = ADT_FAILURE;
                fail_reason = result;
        }

        event->adt_hotplug_set.auth_used = auth;
        event->adt_hotplug_set.device_path = path;
        event->adt_hotplug_set.connection = connection;
        event->adt_hotplug_set.options = options;

        /* Put the event */
        if (adt_put_event(event, pass_fail, fail_reason) != 0)
                log_err("Cannot put audit event.\n");

        adt_free_event(event);
        (void) adt_end_session(session);
}

/*
 * state_str()
 *
 *      Convert a state from integer to string.
 */
static char *
state_str(int state)
{
        switch (state) {
        case DDI_HP_CN_STATE_EMPTY:
                return ("EMPTY");
        case DDI_HP_CN_STATE_PRESENT:
                return ("PRESENT");
        case DDI_HP_CN_STATE_POWERED:
                return ("POWERED");
        case DDI_HP_CN_STATE_ENABLED:
                return ("ENABLED");
        case DDI_HP_CN_STATE_PORT_EMPTY:
                return ("PORT-EMPTY");
        case DDI_HP_CN_STATE_PORT_PRESENT:
                return ("PORT-PRESENT");
        case DDI_HP_CN_STATE_OFFLINE:
                return ("OFFLINE");
        case DDI_HP_CN_STATE_ATTACHED:
                return ("ATTACHED");
        case DDI_HP_CN_STATE_MAINTENANCE:
                return ("MAINTENANCE");
        case DDI_HP_CN_STATE_ONLINE:
                return ("ONLINE");
        default:
                return ("UNKNOWN");
        }
}