sbin/dhcpagent/ipc_action.c

	ipc_action.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include <sys/types.h>
#include <sys/poll.h>
#include <dhcpmsg.h>

#include "interface.h"
#include "ipc_action.h"
#include "util.h"

static iu_tq_callback_t ipc_action_timeout;

/*
 * ipc_action_init(): initializes the ipc_action structure
 *
 *   input: struct ifslist *: the interface to initialize it for
 *  output: void
 */

void
ipc_action_init(struct ifslist *ifsp)
{
    ifsp->if_ia.ia_tid = -1;
}

/*
 * ipc_action_start(): starts an ipc_action request on an interface
 *
 *   input: struct ifslist *: the interface to start the action on
 *      dhcp_ipc_request_t *: the type of request
 *      int: the descriptor to contact the action requestor
 *  output: int: 1 if the request is started successfully, 0 otherwise
 */

int
ipc_action_start(struct ifslist *ifsp, dhcp_ipc_request_t *request, int fd)
{
    if (request->timeout == DHCP_IPC_WAIT_DEFAULT)
        request->timeout = DHCP_IPC_DEFAULT_WAIT;

    ifsp->if_ia.ia_request  = request;
    ifsp->if_ia.ia_fd   = fd;
    ifsp->if_ia.ia_cmd  = DHCP_IPC_CMD(request->message_type);

    if (request->timeout == DHCP_IPC_WAIT_FOREVER)
        ifsp->if_ia.ia_tid = -1;
    else {
        ifsp->if_ia.ia_tid = iu_schedule_timer(tq, request->timeout,
            ipc_action_timeout, ifsp);

        if (ifsp->if_ia.ia_tid == -1)
            return (0);

        hold_ifs(ifsp);
    }

    return (1);
}

/*
 * ipc_action_pending(): checks if there is a pending ipc_action request on
 *           an interface
 *
 *   input: struct ifslist *: the interface to check for a pending ipc_action on
 *  output: boolean_t: B_TRUE if there is a pending ipc_action request
 */

boolean_t
ipc_action_pending(struct ifslist *ifsp)
{
    struct pollfd       pollfd;

    if (ifsp->if_ia.ia_fd > 0) {

        pollfd.events   = POLLIN;
        pollfd.fd   = ifsp->if_ia.ia_fd;

        if (poll(&pollfd, 1, 0) == 0)
            return (B_TRUE);
    }

    return (B_FALSE);
}

/*
 * ipc_action_finish(): completes an ipc_action request on an interface
 *
 *   input: struct ifslist *: the interface to complete the action on
 *      int: the reason why the action finished (nonzero on error)
 *  output: void
 */

void
ipc_action_finish(struct ifslist *ifsp, int reason)
{
    struct ipc_action *ia = &ifsp->if_ia;

    if (ipc_action_pending(ifsp) == B_FALSE)
        return;

    if (reason == 0)
        send_ok_reply(ia->ia_request, &ia->ia_fd);
    else
        send_error_reply(ia->ia_request, reason, &ia->ia_fd);

    ipc_action_cancel_timer(ifsp);
}

/*
 * ipc_action_timeout(): times out an ipc_action on an interface (the request
 *           continues asynchronously, however)
 *
 *   input: iu_tq_t *: unused
 *      void *: the struct ifslist * the ipc_action was pending on
 *  output: void
 */

/* ARGSUSED */
static void
ipc_action_timeout(iu_tq_t *tq, void *arg)
{
    struct ifslist      *ifsp = (struct ifslist *)arg;
    struct ipc_action   *ia = &ifsp->if_ia;

    if (check_ifs(ifsp) == 0) {
        (void) release_ifs(ifsp);
        return;
    }

    dhcpmsg(MSG_VERBOSE, "ipc timeout waiting for agent to complete "
        "command %d for %s", ia->ia_cmd, ifsp->if_name);

    send_error_reply(ia->ia_request, DHCP_IPC_E_TIMEOUT, &ia->ia_fd);
    ia->ia_tid = -1;
}

/*
 * ipc_action_cancel_timer(): cancels the pending ipc_action timer for this
 *                request
 *
 *   input: struct ifslist *: the interface with a pending request to cancel
 *  output: void
 */

void
ipc_action_cancel_timer(struct ifslist *ifsp)
{
    if (ifsp->if_ia.ia_tid == -1)
        return;

    /*
     * if we can't cancel this timer, we're really in the
     * twilight zone.  however, as long as we don't drop the
     * reference to the ifsp, it shouldn't hurt us
     */

    if (iu_cancel_timer(tq, ifsp->if_ia.ia_tid, NULL) == 1) {
        ifsp->if_ia.ia_tid = -1;
        (void) release_ifs(ifsp);
    }
}