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");
    }
}