lib/nwamd/door_if.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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <auth_attr.h>
#include <auth_list.h>
#include <bsm/adt.h>
#include <bsm/adt_event.h>
#include <door.h>
#include <errno.h>
#include <fcntl.h>
#include <libnwam_priv.h>
#include <libuutil.h>
#include <pthread.h>
#include <pwd.h>
#include <stdlib.h>
#include <sys/stat.h>

#include <sys/mman.h>
#include <syslog.h>
#include <unistd.h>

#include "conditions.h"
#include "events.h"
#include "ncp.h"
#include "ncu.h"
#include "objects.h"
#include "util.h"

/*
 * door_if.c
 * This file contains functions which implement the command interface to
 * nwam via the door NWAM_DOOR.  Doors provide a LPC mechanism that allows
 * for threads in one process to cause code to execute in another process.
 * Doors also provide the ability to pass data and file descriptors.  See
 * libdoor(3LIB) for more information.
 *
 * This file exports two functions, nwamd_door_initialize() (which sets up
 * the door) and nwamd_door_fini(), which removes it.
 *
 * It sets up the static routine nwamd_door_switch() to be called when a client
 * calls the door (via door_call(3C)).  The structure nwam_request_t is
 * passed as data and contains data to specify the type of action requested
 * and any data need to meet that request.  A table consisting of entries
 * for each door request, the associated authorization and the function to
 * process that request is used to handle the various requests.
 */

struct nwamd_door_req_entry
{
    int ndre_type;
    char *ndre_auth;
    nwam_error_t (*ndre_fn)(nwamd_door_arg_t *, ucred_t *, struct passwd *);
};

static nwam_error_t nwamd_door_req_event_register(nwamd_door_arg_t *,
    ucred_t *, struct passwd *);
static nwam_error_t nwamd_door_req_event_unregister(nwamd_door_arg_t *,
    ucred_t *, struct passwd *);
static nwam_error_t nwamd_door_req_wlan_scan(nwamd_door_arg_t *,
    ucred_t *, struct passwd *);
static nwam_error_t nwamd_door_req_wlan_scan_results(nwamd_door_arg_t *,
    ucred_t *, struct passwd *);
static nwam_error_t nwamd_door_req_wlan_select(nwamd_door_arg_t *,
    ucred_t *, struct passwd *);
static nwam_error_t nwamd_door_req_wlan_set_key(nwamd_door_arg_t *,
    ucred_t *, struct passwd *);
static nwam_error_t nwamd_door_req_action(nwamd_door_arg_t *,
    ucred_t *, struct passwd *);
static nwam_error_t nwamd_door_req_state(nwamd_door_arg_t *,
    ucred_t *, struct passwd *);
static nwam_error_t nwamd_door_req_priority_group(nwamd_door_arg_t *,
    ucred_t *, struct passwd *);

/*
 * This table defines the set of door commands available, the required
 * authorizations for each command, and the function that carries out
 * each command.
 */
struct nwamd_door_req_entry door_req_table[] =
{

    { NWAM_REQUEST_TYPE_EVENT_REGISTER, AUTOCONF_READ_AUTH,
    nwamd_door_req_event_register },
    { NWAM_REQUEST_TYPE_EVENT_UNREGISTER, AUTOCONF_READ_AUTH,
    nwamd_door_req_event_unregister },
    { NWAM_REQUEST_TYPE_WLAN_SCAN, AUTOCONF_WLAN_AUTH,
    nwamd_door_req_wlan_scan },
    { NWAM_REQUEST_TYPE_WLAN_SCAN_RESULTS, AUTOCONF_READ_AUTH,
    nwamd_door_req_wlan_scan_results },
    { NWAM_REQUEST_TYPE_WLAN_SELECT, AUTOCONF_WLAN_AUTH,
    nwamd_door_req_wlan_select },
    { NWAM_REQUEST_TYPE_WLAN_SET_KEY, AUTOCONF_WLAN_AUTH,
    nwamd_door_req_wlan_set_key },
    /* Requires WRITE, SELECT or WLAN auth depending on action */
    { NWAM_REQUEST_TYPE_ACTION, NULL, nwamd_door_req_action },
    { NWAM_REQUEST_TYPE_STATE, AUTOCONF_READ_AUTH,
    nwamd_door_req_state },
    { NWAM_REQUEST_TYPE_PRIORITY_GROUP, AUTOCONF_READ_AUTH,
    nwamd_door_req_priority_group },
};

int doorfd = -1;

/* ARGSUSED */
static nwam_error_t
nwamd_door_req_event_register(nwamd_door_arg_t *req, ucred_t *ucr,
    struct passwd *pwd)
{
    nwam_error_t err;

    err = nwam_event_queue_init
        (req->nwda_data.nwdad_register_info.nwdad_name);
    if (err != NWAM_SUCCESS) {
        nlog(LOG_ERR, "nwamd_door_req_event_register: "
            "could not register events for %s",
            req->nwda_data.nwdad_register_info.nwdad_name);
    }

    return (err);
}

/* ARGSUSED */
static nwam_error_t
nwamd_door_req_event_unregister(nwamd_door_arg_t *req, ucred_t *ucr,
    struct passwd *pwd)
{
    nwam_event_queue_fini(req->nwda_data.nwdad_register_info.nwdad_name);

    return (NWAM_SUCCESS);
}

/* ARGSUSED1 */
static nwam_error_t
nwamd_door_req_wlan_scan(nwamd_door_arg_t *req, ucred_t *ucr,
    struct passwd *pwd)
{
    nlog(LOG_DEBUG,
        "nwamd_door_req_wlan_scan: processing WLAN scan request: "
        "link %s", req->nwda_data.nwdad_wlan_info.nwdad_name);

    return (nwamd_wlan_scan(req->nwda_data.nwdad_wlan_info.nwdad_name));
}

/* ARGSUSED */
static nwam_error_t
nwamd_door_req_wlan_scan_results(nwamd_door_arg_t *req, ucred_t *ucr,
    struct passwd *pwd)
{
    nwamd_object_t obj;
    nwamd_ncu_t *ncu;
    nwamd_link_t *link;
    uint_t num_wlans;

    nlog(LOG_DEBUG, "nwamd_door_req_wlan_scan_results: processing WLAN "
        "scan results request: link %s",
        req->nwda_data.nwdad_wlan_info.nwdad_name);

    obj = nwamd_ncu_object_find(NWAM_NCU_TYPE_LINK,
        req->nwda_data.nwdad_wlan_info.nwdad_name);
    if (obj == NULL) {
        nlog(LOG_ERR,
            "nwamd_door_req_wlan_scan_results: link %s not found",
            req->nwda_data.nwdad_wlan_info.nwdad_name);
        return (NWAM_ENTITY_NOT_FOUND);
    }

    ncu = obj->nwamd_object_data;
    link = &ncu->ncu_link;
    num_wlans = link->nwamd_link_wifi_scan.nwamd_wifi_scan_curr_num;

    if (num_wlans > 0) {
        (void) memcpy
            (req->nwda_data.nwdad_wlan_info.nwdad_wlans,
            link->nwamd_link_wifi_scan.nwamd_wifi_scan_curr,
            num_wlans * sizeof (nwam_wlan_t));
    }
    req->nwda_data.nwdad_wlan_info.nwdad_num_wlans = num_wlans;
    nlog(LOG_DEBUG,
        "nwamd_door_req_wlan_scan_results: returning %d scan results",
        num_wlans);
    nwamd_object_release(obj);

    return (NWAM_SUCCESS);
}

/* ARGSUSED */
static nwam_error_t
nwamd_door_req_wlan_select(nwamd_door_arg_t *req, ucred_t *ucr,
    struct passwd *pwd)
{
    nlog(LOG_DEBUG,
        "nwamd_door_req_wlan_select: processing WLAN selection : "
        "link %s ESSID %s , BSSID %s",
        req->nwda_data.nwdad_wlan_info.nwdad_name,
        req->nwda_data.nwdad_wlan_info.nwdad_essid,
        req->nwda_data.nwdad_wlan_info.nwdad_bssid);
    return (nwamd_wlan_select
        (req->nwda_data.nwdad_wlan_info.nwdad_name,
        req->nwda_data.nwdad_wlan_info.nwdad_essid,
        req->nwda_data.nwdad_wlan_info.nwdad_bssid,
        req->nwda_data.nwdad_wlan_info.nwdad_security_mode,
        req->nwda_data.nwdad_wlan_info.nwdad_add_to_known_wlans));
}

/* ARGSUSED */
static nwam_error_t
nwamd_door_req_wlan_set_key(nwamd_door_arg_t *req, ucred_t *ucr,
    struct passwd *pwd)
{
    nlog(LOG_DEBUG,
        "nwamd_door_req_wlan_set_key: processing WLAN key input : "
        "link %s ESSID %s BSSID %s",
        req->nwda_data.nwdad_wlan_info.nwdad_name,
        req->nwda_data.nwdad_wlan_info.nwdad_essid,
        req->nwda_data.nwdad_wlan_info.nwdad_bssid);
    return (nwamd_wlan_set_key
        (req->nwda_data.nwdad_wlan_info.nwdad_name,
        req->nwda_data.nwdad_wlan_info.nwdad_essid,
        req->nwda_data.nwdad_wlan_info.nwdad_bssid,
        req->nwda_data.nwdad_wlan_info.nwdad_security_mode,
        req->nwda_data.nwdad_wlan_info.nwdad_keyslot,
        req->nwda_data.nwdad_wlan_info.nwdad_key));
}

static nwam_error_t
nwamd_door_req_action(nwamd_door_arg_t *req, ucred_t *ucr, struct passwd *pwd)
{
    char name[NWAM_MAX_NAME_LEN];
    char parent[NWAM_MAX_NAME_LEN];
    nwam_action_t action = req->nwda_data.nwdad_object_action.nwdad_action;
    nwam_object_type_t object_type =
        req->nwda_data.nwdad_object_action.nwdad_object_type;
    char *obj_type_str  = (char *)nwam_object_type_to_string(object_type);
    nwam_error_t err;

    /* Check for name, parent overrun */
    if (strlcpy(name, req->nwda_data.nwdad_object_action.nwdad_name,
        sizeof (name)) == NWAM_MAX_NAME_LEN ||
        strlcpy(parent, req->nwda_data.nwdad_object_action.nwdad_parent,
        sizeof (parent)) == NWAM_MAX_NAME_LEN)
        return (NWAM_INVALID_ARG);

    /*
     * Check authorizations against actions.
     * - ENABLE/DISABLE requires SELECT auth
     * - ADD/DESTROY/REFRESH on Known WLANs requires WLAN auth
     * - ADD/DESTROY on other objects requires WRITE auth
     * - REFRESH on other objects requires either WRITE or SELECT auth
     */
    if (action == NWAM_ACTION_ENABLE || action == NWAM_ACTION_DISABLE) {
        if (chkauthattr(AUTOCONF_SELECT_AUTH, pwd->pw_name) == 0) {
            nwam_record_audit_event(ucr,
                action == NWAM_ACTION_ENABLE ?
                ADT_nwam_enable : ADT_nwam_disable, name,
                obj_type_str, ADT_FAILURE, ADT_FAIL_VALUE_AUTH);
            nlog(LOG_ERR, "nwamd_door_req_action: "
                "need %s for %s action", AUTOCONF_SELECT_AUTH,
                nwam_action_to_string(action));
            return (NWAM_PERMISSION_DENIED);
        }
    } else if (object_type == NWAM_OBJECT_TYPE_KNOWN_WLAN) {
        if (chkauthattr(AUTOCONF_WLAN_AUTH, pwd->pw_name) == 0) {
            nlog(LOG_ERR, "nwamd_door_req_action: "
                "need %s for %s action on Known WLAN",
                AUTOCONF_WLAN_AUTH, nwam_action_to_string(action));
            return (NWAM_PERMISSION_DENIED);
        }
    } else if (action == NWAM_ACTION_ADD || action == NWAM_ACTION_DESTROY) {
        if (chkauthattr(AUTOCONF_WRITE_AUTH, pwd->pw_name) == 0) {
            nlog(LOG_ERR, "nwamd_door_req_action: "
                "need %s for %s action", AUTOCONF_WRITE_AUTH,
                nwam_action_to_string(action));
            return (NWAM_PERMISSION_DENIED);
        }
    } else if (action == NWAM_ACTION_REFRESH) {
        if (chkauthattr(AUTOCONF_WRITE_AUTH, pwd->pw_name) == 0 &&
            chkauthattr(AUTOCONF_SELECT_AUTH, pwd->pw_name) == 0) {
            nlog(LOG_ERR, "nwamd_door_req_action: "
                "need either %s or %s for %s action",
                AUTOCONF_WRITE_AUTH, AUTOCONF_SELECT_AUTH,
                nwam_action_to_string(action));
            return (NWAM_PERMISSION_DENIED);
        }
    } else {
        nlog(LOG_ERR, "nwamd_door_req_action: received unknown "
            "action %d (%s)", action, nwam_action_to_string(action));
        return (NWAM_INVALID_ARG);
    }

    switch (action) {
    case NWAM_ACTION_ENABLE:
    case NWAM_ACTION_DISABLE:
        nwam_record_audit_event(ucr,
            action == NWAM_ACTION_ENABLE ?
            ADT_nwam_enable : ADT_nwam_disable, name,
            obj_type_str, ADT_SUCCESS, ADT_SUCCESS);

        nlog(LOG_DEBUG, "nwamd_door_req_action: %s %s",
            action == NWAM_ACTION_ENABLE ? "enabling" : "disabling",
            name);

        switch (object_type) {
        case NWAM_OBJECT_TYPE_ENM:
            err = nwamd_enm_action(name, action);
            break;
        case NWAM_OBJECT_TYPE_LOC:
            err = nwamd_loc_action(name, action);
            break;
        case NWAM_OBJECT_TYPE_NCU:
            err = nwamd_ncu_action(name, parent, action);
            break;
        case NWAM_OBJECT_TYPE_NCP:
            if (action == NWAM_ACTION_DISABLE) {
                nlog(LOG_ERR, "nwamd_door_req_action: "
                    "NCPs cannot be disabled");
                err = NWAM_INVALID_ARG;
            } else {
                err = nwamd_ncp_action(name, action);
            }
            break;
        default:
            nlog(LOG_ERR, "nwamd_door_req_action: received invalid "
                "object type %d (%s)", object_type,
                nwam_object_type_to_string(object_type));
            return (NWAM_INVALID_ARG);
        }
        break;

    case NWAM_ACTION_ADD:
    case NWAM_ACTION_REFRESH:
        /*
         * Called whenever an object is committed in the library.
         * Reread that committed object into nwamd.
         */
        nlog(LOG_DEBUG, "door_switch: refreshing %s", name);

        switch (object_type) {
        case NWAM_OBJECT_TYPE_ENM:
            err = nwamd_enm_action(name, action);
            break;
        case NWAM_OBJECT_TYPE_LOC:
            err = nwamd_loc_action(name, action);
            break;
        case NWAM_OBJECT_TYPE_KNOWN_WLAN:
            err = nwamd_known_wlan_action(name, action);
            break;
        case NWAM_OBJECT_TYPE_NCU:
            err = nwamd_ncu_action(name, parent, action);
            break;
        case NWAM_OBJECT_TYPE_NCP:
            err = nwamd_ncp_action(name, action);
            break;
        default:
            nlog(LOG_ERR, "nwamd_door_req_action: received invalid "
                "object type %d (%s)", object_type,
                nwam_object_type_to_string(object_type));
            err = NWAM_INVALID_ARG;
            break;
        }
        break;

    case NWAM_ACTION_DESTROY:
        /* Object was destroyed, remove from nwamd */
        nlog(LOG_DEBUG, "door_switch: removing %s", name);

        switch (object_type) {
        case NWAM_OBJECT_TYPE_ENM:
            err = nwamd_enm_action(name, NWAM_ACTION_DESTROY);
            break;
        case NWAM_OBJECT_TYPE_LOC:
            err = nwamd_loc_action(name, NWAM_ACTION_DESTROY);
            break;
        case NWAM_OBJECT_TYPE_KNOWN_WLAN:
            err = nwamd_known_wlan_action(name,
                NWAM_ACTION_DESTROY);
            break;
        case NWAM_OBJECT_TYPE_NCU:
            err = nwamd_ncu_action(name, parent,
                NWAM_ACTION_DESTROY);
            break;
        case NWAM_OBJECT_TYPE_NCP:
            (void) pthread_mutex_lock(&active_ncp_mutex);
            if (strcmp(name, active_ncp) == 0) {
                nlog(LOG_ERR, "nwamd_door_req_action: %s is "
                    "active, cannot destroy", parent);
                err = NWAM_ENTITY_IN_USE;
            } else {
                err = nwamd_ncp_action(name,
                    NWAM_ACTION_DESTROY);
            }
            (void) pthread_mutex_unlock(&active_ncp_mutex);
            break;
        default:
            nlog(LOG_ERR, "nwamd_door_req_action: received invalid "
                "object type %d (%s)", object_type,
                nwam_object_type_to_string(object_type));
            err = NWAM_INVALID_ARG;
            break;
        }
        break;

    default:
        nlog(LOG_ERR, "nwamd_door_req_action: received unknown "
            "action %d (%s)", action, nwam_action_to_string(action));
        err = NWAM_INVALID_ARG;
        break;
    }

    if (err == NWAM_SUCCESS) {
        /*
         * At this point, we've successfully carried out an action.
         * Configuration may have changed, so we need to recheck
         * conditions, however we want to avoid a flurry of condition
         * check events, so we enqueue a triggered condition check
         * if none is due in the next few seconds.
         */
        nwamd_create_triggered_condition_check_event(NEXT_FEW_SECONDS);
    } else {
        nlog(LOG_ERR, "nwamd_door_req_action: could not carry out "
            "%s action on %s: %s", nwam_action_to_string(action),
            name, nwam_strerror(err));
    }

    return (err);
}

/* ARGSUSED */
static nwam_error_t
nwamd_door_req_state(nwamd_door_arg_t *req, ucred_t *ucr, struct passwd *pwd)
{
    char name[NWAM_MAX_NAME_LEN];
    nwamd_object_t obj;
    nwam_object_type_t object_type =
        req->nwda_data.nwdad_object_state.nwdad_object_type;
    boolean_t is_active = B_FALSE;

    /* Check for name, parent overrun */
    if (strlcpy(name, req->nwda_data.nwdad_object_state.nwdad_name,
        sizeof (name)) == NWAM_MAX_NAME_LEN)
        return (NWAM_INVALID_ARG);

    switch (object_type) {
    case NWAM_OBJECT_TYPE_NCP:
        (void) pthread_mutex_lock(&active_ncp_mutex);
        is_active = (strcmp(active_ncp, name) == 0);
        (void) pthread_mutex_unlock(&active_ncp_mutex);
        if (is_active) {
            req->nwda_data.nwdad_object_state.nwdad_state =
                NWAM_STATE_ONLINE;
            req->nwda_data.nwdad_object_state.
                nwdad_aux_state = NWAM_AUX_STATE_ACTIVE;
            nlog(LOG_DEBUG,
                "nwamd_door_req_state: NCP %s is active", name);
        } else {
            req->nwda_data.nwdad_object_state.nwdad_state =
                NWAM_STATE_DISABLED;
            req->nwda_data.nwdad_object_state.
                nwdad_aux_state =
                NWAM_AUX_STATE_MANUAL_DISABLE;
            nlog(LOG_DEBUG, "nwamd_door_req_state: "
                "NCP %s is inactive", name);
        }
        break;

    case NWAM_OBJECT_TYPE_LOC:
    case NWAM_OBJECT_TYPE_NCU:
    case NWAM_OBJECT_TYPE_ENM:
        obj = nwamd_object_find(object_type, name);
        if (obj == NULL) {
            nlog(LOG_ERR, "nwamd_door_req_state: %s %s not found",
                nwam_object_type_to_string(object_type), name);
            return (NWAM_ENTITY_NOT_FOUND);
        }
        nlog(LOG_DEBUG, "nwamd_door_req_state: %s %s is %s",
            nwam_object_type_to_string(object_type), name,
            nwam_state_to_string(obj->nwamd_object_state));
        req->nwda_data.nwdad_object_state.nwdad_state =
            obj->nwamd_object_state;
        req->nwda_data.nwdad_object_state.nwdad_aux_state =
            obj->nwamd_object_aux_state;
        nwamd_object_release(obj);
        break;

    default:
        nlog(LOG_ERR, "nwamd_door_req_state: received invalid "
            "object type %d (%s)", object_type,
            nwam_object_type_to_string(object_type));
        req->nwda_status = NWAM_REQUEST_STATUS_UNKNOWN;
        return (NWAM_INVALID_ARG);
    }

    return (NWAM_SUCCESS);
}

/* ARGSUSED */
static nwam_error_t
nwamd_door_req_priority_group(nwamd_door_arg_t *req, ucred_t *ucr,
    struct passwd *pwd)
{
    (void) pthread_mutex_lock(&active_ncp_mutex);
    nlog(LOG_DEBUG, "nwamd_door_req_priority_group: "
        "retrieving active priority-group: %d",
        current_ncu_priority_group);
    req->nwda_data.nwdad_priority_group_info.nwdad_priority =
        current_ncu_priority_group;
    (void) pthread_mutex_unlock(&active_ncp_mutex);

    return (NWAM_SUCCESS);
}

/* ARGSUSED */
static void
nwamd_door_switch(void *cookie, char *argp, size_t arg_size, door_desc_t *dp,
    uint_t n_desc)
{
    nwamd_door_arg_t *req;
    ucred_t *ucr = NULL;
    uid_t uid;
    struct passwd *pwd = NULL;
    boolean_t found = B_FALSE;
    int i;

    /* LINTED E_BAD_PTR_CAST_ALIGN */
    req = (nwamd_door_arg_t *)argp;
    req->nwda_error = NWAM_SUCCESS;

    if (door_ucred(&ucr) != 0) {
        nlog(LOG_ERR, "nwamd_door_switch: door_ucred failed: %s",
            strerror(errno));
        req->nwda_error = NWAM_ERROR_INTERNAL;
        req->nwda_status = NWAM_REQUEST_STATUS_FAILED;
        goto done;
    }
    uid = ucred_getruid(ucr);

    if ((pwd = getpwuid(uid)) == NULL) {
        nlog(LOG_ERR, "nwamd_door_switch: getpwuid failed: %s",
            strerror(errno));
        endpwent();
        req->nwda_error = NWAM_ERROR_INTERNAL;
        req->nwda_status = NWAM_REQUEST_STATUS_FAILED;
        goto done;
    }

    /*
     * Find door request entry in table, check auths and call the function
     * handling the request.
     */
    for (i = 0;
        i < sizeof (door_req_table) / sizeof (struct nwamd_door_req_entry);
        i++) {
        if (req->nwda_type != door_req_table[i].ndre_type)
            continue;

        found = B_TRUE;

        if (door_req_table[i].ndre_auth != NULL &&
            chkauthattr(door_req_table[i].ndre_auth,
            pwd->pw_name) == 0) {
            nlog(LOG_ERR,
                "nwamd_door_switch: need %s for request type %d",
                door_req_table[i].ndre_auth, req->nwda_type);
            req->nwda_error = NWAM_PERMISSION_DENIED;
            break;
        }
        req->nwda_error = door_req_table[i].ndre_fn(req, ucr, pwd);
        break;
    }
    if (!found) {
        nlog(LOG_ERR,
            "nwamd_door_switch: received unknown request type %d",
            req->nwda_type);
        req->nwda_status = NWAM_REQUEST_STATUS_UNKNOWN;
    } else {
        if (req->nwda_error == NWAM_SUCCESS)
            req->nwda_status = NWAM_REQUEST_STATUS_OK;
        else
            req->nwda_status = NWAM_REQUEST_STATUS_FAILED;
    }

done:
    ucred_free(ucr);
    endpwent();

    if (door_return((char *)req, sizeof (nwamd_door_arg_t), NULL, 0)
        == -1) {
        nlog(LOG_ERR, "door_switch: type %d door_return failed: %s",
            req->nwda_type, strerror(errno));
    }
}

/*
 * We initialize the nwamd door here.  Failure to have this happen is critical
 * to the daemon so we log a message and pass up notice to the caller who
 * will most likely abort trying to start.  This routine is meant to only
 * be called once.
 */
void
nwamd_door_init(void)
{
    const int door_mode = 0644;
    struct stat buf;

    if ((doorfd = door_create(nwamd_door_switch, NULL,
        DOOR_NO_CANCEL | DOOR_REFUSE_DESC)) == -1)
        pfail("Unable to create door: %s", strerror(errno));

    if (stat(NWAM_DOOR, &buf) < 0) {
        int nwam_door_fd;

        if ((nwam_door_fd = creat(NWAM_DOOR, door_mode)) < 0) {
            int err = errno;
            (void) door_revoke(doorfd);
            doorfd = -1;
            pfail("Couldn't create door: %s", strerror(err));
        }
        (void) close(nwam_door_fd);
    } else {
        if (buf.st_mode != door_mode) {
            if (chmod(NWAM_DOOR, door_mode) == -1) {
                nlog(LOG_ERR, "couldn't change mode of %s: %s",
                    NWAM_DOOR, strerror(errno));
            }
        }
    }
    /* cleanup anything hanging around from a previous invocation */
    (void) fdetach(NWAM_DOOR);

    /* Place our door in the file system so that others can find us. */
    if (fattach(doorfd, NWAM_DOOR) < 0) {
        int err = errno;
        (void) door_revoke(doorfd);
        doorfd = -1;
        pfail("Couldn't attach door: %s", strerror(err));
    }
}

void
nwamd_door_fini(void)
{
    if (doorfd != -1) {
        nlog(LOG_DEBUG, "nwamd_door_fini: closing door");
        (void) door_revoke(doorfd);
        doorfd = -1;
    }
    (void) unlink(NWAM_DOOR);
}