/*
 * 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.
 *
 * ADOPTING state of the client state machine.  This is used only during
 * diskless boot with IPv4.
 */

#include <sys/types.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/socket.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <sys/systeminfo.h>
#include <netinet/inetutil.h>
#include <netinet/dhcp.h>
#include <dhcpmsg.h>
#include <libdevinfo.h>

#include "agent.h"
#include "async.h"
#include "util.h"
#include "packet.h"
#include "interface.h"
#include "states.h"


typedef struct {
        char            dk_if_name[IFNAMSIZ];
        char            dk_ack[1];
} dhcp_kcache_t;

static int      get_dhcp_kcache(dhcp_kcache_t **, size_t *);

static boolean_t        get_prom_prop(const char *, const char *, uchar_t **,
                            uint_t *);

/*
 * dhcp_adopt(): adopts the interface managed by the kernel for diskless boot
 *
 *   input: void
 *  output: boolean_t: B_TRUE success, B_FALSE on failure
 */

boolean_t
dhcp_adopt(void)
{
        int             retval;
        dhcp_kcache_t   *kcache = NULL;
        size_t          kcache_size;
        PKT_LIST        *plp = NULL;
        dhcp_lif_t      *lif;
        dhcp_smach_t    *dsmp = NULL;
        uint_t          client_id_len;

        retval = get_dhcp_kcache(&kcache, &kcache_size);
        if (retval == 0 || kcache_size < sizeof (dhcp_kcache_t)) {
                dhcpmsg(MSG_CRIT, "dhcp_adopt: cannot fetch kernel cache");
                goto failure;
        }

        dhcpmsg(MSG_DEBUG, "dhcp_adopt: fetched %s kcache", kcache->dk_if_name);

        /*
         * convert the kernel's ACK into binary
         */

        plp = alloc_pkt_entry(strlen(kcache->dk_ack) / 2, B_FALSE);
        if (plp == NULL)
                goto failure;

        dhcpmsg(MSG_DEBUG, "dhcp_adopt: allocated ACK of %d bytes", plp->len);

        if (hexascii_to_octet(kcache->dk_ack, plp->len * 2, plp->pkt,
            &plp->len) != 0) {
                dhcpmsg(MSG_CRIT, "dhcp_adopt: cannot convert kernel ACK");
                goto failure;
        }

        if (dhcp_options_scan(plp, B_TRUE) != 0) {
                dhcpmsg(MSG_CRIT, "dhcp_adopt: cannot parse kernel ACK");
                goto failure;
        }

        /*
         * make an interface to represent the "cached interface" in
         * the kernel, hook up the ACK packet we made, and send out
         * the extend request (to attempt to renew the lease).
         *
         * we do a send_extend() instead of doing a dhcp_init_reboot()
         * because although dhcp_init_reboot() is more correct from a
         * protocol perspective, it introduces a window where a
         * diskless client has no IP address but may need to page in
         * more of this program.  we could mlockall(), but that's
         * going to be a mess, especially with handling malloc() and
         * stack growth, so it's easier to just renew().  the only
         * catch here is that if we are not granted a renewal, we're
         * totally hosed and can only bail out.
         */

        if ((lif = attach_lif(kcache->dk_if_name, B_FALSE, &retval)) == NULL) {
                dhcpmsg(MSG_ERROR, "dhcp_adopt: unable to attach %s: %d",
                    kcache->dk_if_name, retval);
                goto failure;
        }

        if ((dsmp = insert_smach(lif, &retval)) == NULL) {
                dhcpmsg(MSG_ERROR, "dhcp_adopt: unable to create state "
                    "machine for %s: %d", kcache->dk_if_name, retval);
                goto failure;
        }

        /*
         * If the agent is adopting a lease, then OBP is initially
         * searched for a client-id.
         */

        dhcpmsg(MSG_DEBUG, "dhcp_adopt: getting /chosen:clientid property");

        client_id_len = 0;
        if (!get_prom_prop("chosen", "client-id", &dsmp->dsm_cid,
            &client_id_len)) {
                /*
                 * a failure occurred trying to acquire the client-id
                 */

                dhcpmsg(MSG_DEBUG,
                    "dhcp_adopt: cannot allocate client id for %s",
                    dsmp->dsm_name);
                goto failure;
        } else if (dsmp->dsm_hwtype == ARPHRD_IB && dsmp->dsm_cid == NULL) {
                /*
                 * when the interface is infiniband and the agent
                 * is adopting the lease there must be an OBP
                 * client-id.
                 */

                dhcpmsg(MSG_DEBUG, "dhcp_adopt: no /chosen:clientid id for %s",
                    dsmp->dsm_name);
                goto failure;
        }

        dsmp->dsm_cidlen = client_id_len;

        if (set_lif_dhcp(lif) != DHCP_IPC_SUCCESS)
                goto failure;

        if (!set_smach_state(dsmp, ADOPTING))
                goto failure;
        dsmp->dsm_dflags = DHCP_IF_PRIMARY;

        /*
         * move to BOUND and use the information in our ACK packet.
         * adoption will continue after DAD via dhcp_adopt_complete.
         */

        if (!dhcp_bound(dsmp, plp)) {
                dhcpmsg(MSG_CRIT, "dhcp_adopt: cannot use cached packet");
                goto failure;
        }

        free(kcache);
        return (B_TRUE);

failure:
        /* Note: no need to free lif; dsmp holds reference */
        if (dsmp != NULL)
                remove_smach(dsmp);
        free(kcache);
        free_pkt_entry(plp);
        return (B_FALSE);
}

/*
 * dhcp_adopt_complete(): completes interface adoption process after kernel
 *                        duplicate address detection (DAD) is done.
 *
 *   input: dhcp_smach_t *: the state machine on which a lease is being adopted
 *  output: none
 */

void
dhcp_adopt_complete(dhcp_smach_t *dsmp)
{
        dhcpmsg(MSG_DEBUG, "dhcp_adopt_complete: completing adoption");

        if (async_start(dsmp, DHCP_EXTEND, B_FALSE) == 0) {
                dhcpmsg(MSG_CRIT, "dhcp_adopt_complete: async_start failed");
                return;
        }

        if (dhcp_extending(dsmp) == 0) {
                dhcpmsg(MSG_CRIT,
                    "dhcp_adopt_complete: cannot send renew request");
                return;
        }

        if (grandparent != (pid_t)0) {
                dhcpmsg(MSG_DEBUG, "adoption complete, signalling parent (%ld)"
                    " to exit.", grandparent);
                (void) kill(grandparent, SIGALRM);
        }
}

/*
 * get_dhcp_kcache(): fetches the DHCP ACK and interface name from the kernel
 *
 *   input: dhcp_kcache_t **: a dynamically-allocated cache packet
 *          size_t *: the length of that packet (on return)
 *  output: int: nonzero on success, zero on failure
 */

static int
get_dhcp_kcache(dhcp_kcache_t **kernel_cachep, size_t *kcache_size)
{
        char    dummy;
        long    size;

        size = sysinfo(SI_DHCP_CACHE, &dummy, sizeof (dummy));
        if (size == -1)
                return (0);

        *kcache_size   = size;
        *kernel_cachep = malloc(*kcache_size);
        if (*kernel_cachep == NULL)
                return (0);

        (void) sysinfo(SI_DHCP_CACHE, (caddr_t)*kernel_cachep, size);
        return (1);
}

/*
 * get_prom_prop(): get the value of the named property on the named node in
 *                  devinfo root.
 *
 *   input: const char *: The name of the node containing the property.
 *          const char *: The name of the property.
 *          uchar_t **: The property value, modified iff B_TRUE is returned.
 *                      If no value is found the value is set to NULL.
 *          uint_t *: The length of the property value
 *  output: boolean_t: Returns B_TRUE if successful (no problems),
 *                     otherwise B_FALSE.
 *    note: The memory allocated by this function must be freed by
 *          the caller.
 */

static boolean_t
get_prom_prop(const char *nodename, const char *propname, uchar_t **propvaluep,
    uint_t *lenp)
{
        di_node_t               root_node;
        di_node_t               node;
        di_prom_handle_t        phdl = DI_PROM_HANDLE_NIL;
        di_prom_prop_t          pp;
        uchar_t                 *value = NULL;
        unsigned int            len = 0;
        boolean_t               success = B_TRUE;

        /*
         * locate root node
         */

        if ((root_node = di_init("/", DINFOCPYALL)) == DI_NODE_NIL ||
            (phdl = di_prom_init()) == DI_PROM_HANDLE_NIL) {
                dhcpmsg(MSG_DEBUG, "get_prom_prop: property root node "
                    "not found");
                goto get_prom_prop_cleanup;
        }

        /*
         * locate nodename within '/'
         */

        for (node = di_child_node(root_node);
            node != DI_NODE_NIL;
            node = di_sibling_node(node)) {
                if (strcmp(di_node_name(node), nodename) == 0) {
                        break;
                }
        }

        if (node == DI_NODE_NIL) {
                dhcpmsg(MSG_DEBUG, "get_prom_prop: node not found");
                goto get_prom_prop_cleanup;
        }

        /*
         * scan all properties of /nodename for the 'propname' property
         */

        for (pp = di_prom_prop_next(phdl, node, DI_PROM_PROP_NIL);
            pp != DI_PROM_PROP_NIL;
            pp = di_prom_prop_next(phdl, node, pp)) {

                dhcpmsg(MSG_DEBUG, "get_prom_prop: property = %s",
                    di_prom_prop_name(pp));

                if (strcmp(propname, di_prom_prop_name(pp)) == 0) {
                        break;
                }
        }

        if (pp == DI_PROM_PROP_NIL) {
                dhcpmsg(MSG_DEBUG, "get_prom_prop: property not found");
                goto get_prom_prop_cleanup;
        }

        /*
         * get the property; allocate some memory copy it out
         */

        len = di_prom_prop_data(pp, (uchar_t **)&value);

        if (value == NULL) {
                /*
                 * property data read problems
                 */

                success = B_FALSE;
                dhcpmsg(MSG_ERR, "get_prom_prop: cannot read property data");
                goto get_prom_prop_cleanup;
        }

        if (propvaluep != NULL) {
                /*
                 * allocate somewhere to copy the property value to
                 */

                *propvaluep = calloc(len, sizeof (uchar_t));

                if (*propvaluep == NULL) {
                        /*
                         * allocation problems
                         */

                        success = B_FALSE;
                        dhcpmsg(MSG_ERR, "get_prom_prop: cannot allocate "
                            "memory for property value");
                        goto get_prom_prop_cleanup;
                }

                /*
                 * copy data out
                 */

                (void) memcpy(*propvaluep, value, len);

                /*
                 * copy out the length if a suitable pointer has
                 * been supplied
                 */

                if (lenp != NULL) {
                        *lenp = len;
                }

                dhcpmsg(MSG_DEBUG, "get_prom_prop: property value "
                    "length = %d", len);
        }

get_prom_prop_cleanup:

        if (phdl != DI_PROM_HANDLE_NIL) {
                di_prom_fini(phdl);
        }

        if (root_node != DI_NODE_NIL) {
                di_fini(root_node);
        }

        return (success);
}