dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / lib / libdhcpagent / common / dhcp_hostconf.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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <net/if.h>
#include <netinet/dhcp.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include <string.h>                     /* memcpy */
#include <fcntl.h>
#include <limits.h>

#include "dhcp_hostconf.h"

static void             relativize_time(DHCP_OPT *, time_t, time_t);
static void             relativize_v6(uint32_t *, time_t, time_t);

/*
 * ifname_to_hostconf(): converts an interface name into a hostconf file for
 *                       that interface
 *
 *   input: const char *: the interface name
 *          boolean_t: B_TRUE if using DHCPv6
 *  output: char *: the hostconf filename
 *    note: uses an internal static buffer (not threadsafe)
 */

char *
ifname_to_hostconf(const char *ifname, boolean_t isv6)
{
        static char filename[sizeof (DHCP_HOSTCONF_TMPL6) + LIFNAMSIZ];

        (void) snprintf(filename, sizeof (filename), "%s%s%s",
            DHCP_HOSTCONF_PREFIX, ifname,
            isv6 ? DHCP_HOSTCONF_SUFFIX6 : DHCP_HOSTCONF_SUFFIX);

        return (filename);
}

/*
 * remove_hostconf(): removes an interface.dhc file
 *
 *   input: const char *: the interface name
 *          boolean_t: B_TRUE if using DHCPv6
 *  output: int: 0 if the file is removed, -1 if it can't be removed
 *          (errno is set)
 */

int
remove_hostconf(const char *ifname, boolean_t isv6)
{
        return (unlink(ifname_to_hostconf(ifname, isv6)));
}

/*
 * read_hostconf(): reads the contents of an <if>.dhc file into a PKT_LIST
 *
 *   input: const char *: the interface name
 *          PKT_LIST **: a pointer to a PKT_LIST * to store the info in
 *          uint_t: the length of the list of PKT_LISTs
 *          boolean_t: B_TRUE if using DHCPv6
 *  output: int: >0 if the file is read and loaded into the PKT_LIST *
 *          successfully, -1 otherwise (errno is set)
 *    note: the PKT and PKT_LISTs are dynamically allocated here
 */

int
read_hostconf(const char *ifname, PKT_LIST **plpp, uint_t plplen,
    boolean_t isv6)
{
        PKT_LIST        *plp = NULL;
        PKT             *pkt = NULL;
        int             fd;
        time_t          orig_time, current_time = time(NULL);
        uint32_t        lease;
        uint32_t        magic;
        int             pcnt = 0;
        int             retval;

        fd = open(ifname_to_hostconf(ifname, isv6), O_RDONLY);
        if (fd == -1)
                return (-1);

        if (read(fd, &magic, sizeof (magic)) != sizeof (magic))
                goto failure;

        if (magic != (isv6 ? DHCP_HOSTCONF_MAGIC6 : DHCP_HOSTCONF_MAGIC))
                goto failure;

        if (read(fd, &orig_time, sizeof (orig_time)) != sizeof (orig_time))
                goto failure;

        /*
         * read the packet back in from disk, and for v4, run it through
         * dhcp_options_scan(). note that we use calloc() because
         * dhcp_options_scan() relies on the structure being zeroed.
         */

        for (pcnt = 0; pcnt < plplen; pcnt++) {

                plp = NULL;
                pkt = NULL;

                if ((plp = calloc(1, sizeof (PKT_LIST))) == NULL)
                        goto failure;

                retval = read(fd, &plp->len, sizeof (plp->len));
                if (retval == 0 && pcnt != 0) {
                        /*
                         * Reached end of file on a boundary, but after
                         * we've read at least one packet, so we consider
                         * this successful, allowing us to use files from
                         * older versions of the agent happily.
                         */
                        free(plp);
                        break;
                } else if (retval != sizeof (plp->len))
                        goto failure;

                if ((pkt = malloc(plp->len)) == NULL)
                        goto failure;

                if (read(fd, pkt, plp->len) != plp->len)
                        goto failure;

                plp->pkt = pkt;

                plpp[pcnt] = plp;

                if (!isv6 && dhcp_options_scan(plp, B_TRUE) != 0)
                        goto failure;

                /*
                 * First packet used to validate that we're interested,
                 * the rest are presumed to be historical reference and
                 * are not relativized
                 */
                if (pcnt == 0)
                        continue;

                if (isv6) {
                        dhcpv6_option_t d6o;
                        dhcpv6_ia_na_t  d6in;
                        dhcpv6_iaaddr_t d6ia;
                        uchar_t         *opts, *optmax, *subomax;

                        /*
                         * Loop over contents of the packet to find the address
                         * options.
                         */
                        opts = (uchar_t *)pkt + sizeof (dhcpv6_message_t);
                        optmax = (uchar_t *)pkt + plp->len;
                        while (opts + sizeof (d6o) <= optmax) {

                                /*
                                 * Extract option header and make sure option
                                 * is intact.
                                 */
                                (void) memcpy(&d6o, opts, sizeof (d6o));
                                d6o.d6o_code = ntohs(d6o.d6o_code);
                                d6o.d6o_len = ntohs(d6o.d6o_len);
                                subomax = opts + sizeof (d6o) + d6o.d6o_len;
                                if (subomax > optmax)
                                        break;

                                /*
                                 * If this isn't an option that contains
                                 * address or prefix leases, then skip over it.
                                 */
                                if (d6o.d6o_code != DHCPV6_OPT_IA_NA &&
                                    d6o.d6o_code != DHCPV6_OPT_IA_TA &&
                                    d6o.d6o_code != DHCPV6_OPT_IA_PD) {
                                        opts = subomax;
                                        continue;
                                }

                                /*
                                 * Handle the option first.
                                 */
                                if (d6o.d6o_code == DHCPV6_OPT_IA_TA) {
                                        /* no timers in this structure */
                                        opts += sizeof (dhcpv6_ia_ta_t);
                                } else {
                                        /* both na and pd */
                                        if (opts + sizeof (d6in) > subomax) {
                                                opts = subomax;
                                                continue;
                                        }
                                        (void) memcpy(&d6in, opts,
                                            sizeof (d6in));
                                        relativize_v6(&d6in.d6in_t1, orig_time,
                                            current_time);
                                        relativize_v6(&d6in.d6in_t2, orig_time,
                                            current_time);
                                        (void) memcpy(opts, &d6in,
                                            sizeof (d6in));
                                        opts += sizeof (d6in);
                                }

                                /*
                                 * Now handle each suboption (address) inside.
                                 */
                                while (opts + sizeof (d6o) <= subomax) {
                                        /*
                                         * Verify the suboption header first.
                                         */
                                        (void) memcpy(&d6o, opts,
                                            sizeof (d6o));
                                        d6o.d6o_code = ntohs(d6o.d6o_code);
                                        d6o.d6o_len = ntohs(d6o.d6o_len);
                                        if (opts + sizeof (d6o) + d6o.d6o_len >
                                            subomax)
                                                break;
                                        if (d6o.d6o_code != DHCPV6_OPT_IAADDR) {
                                                opts += sizeof (d6o) +
                                                    d6o.d6o_len;
                                                continue;
                                        }

                                        /*
                                         * Now process the contents.
                                         */
                                        if (opts + sizeof (d6ia) > subomax)
                                                break;
                                        (void) memcpy(&d6ia, opts,
                                            sizeof (d6ia));
                                        relativize_v6(&d6ia.d6ia_preflife,
                                            orig_time, current_time);
                                        relativize_v6(&d6ia.d6ia_vallife,
                                            orig_time, current_time);
                                        (void) memcpy(opts, &d6ia,
                                            sizeof (d6ia));
                                        opts += sizeof (d6o) + d6o.d6o_len;
                                }
                                opts = subomax;
                        }
                } else {

                        /*
                         * make sure the IPv4 DHCP lease is still valid.
                         */

                        if (plp->opts[CD_LEASE_TIME] != NULL &&
                            plp->opts[CD_LEASE_TIME]->len ==
                            sizeof (lease_t)) {

                                (void) memcpy(&lease,
                                    plp->opts[CD_LEASE_TIME]->value,
                                    sizeof (lease_t));

                                lease = ntohl(lease);
                                if ((lease != DHCP_PERM) &&
                                    (orig_time + lease) <= current_time)
                                        goto failure;
                        }

                        relativize_time(plp->opts[CD_T1_TIME], orig_time,
                            current_time);
                        relativize_time(plp->opts[CD_T2_TIME], orig_time,
                            current_time);
                        relativize_time(plp->opts[CD_LEASE_TIME], orig_time,
                            current_time);
                }
        }

        (void) close(fd);
        return (pcnt);

failure:
        free(pkt);
        free(plp);
        while (pcnt-- > 0) {
                free(plpp[pcnt]->pkt);
                free(plpp[pcnt]);
        }
        (void) close(fd);
        return (-1);
}

/*
 * write_hostconf(): writes the contents of a PKT_LIST into an <if>.dhc file
 *
 *   input: const char *: the interface name
 *          PKT_LIST **: a list of pointers to PKT_LIST to write
 *          uint_t: length of the list of PKT_LIST pointers
 *          time_t: a starting time to treat the relative lease times
 *                  in the first packet as relative to
 *          boolean_t: B_TRUE if using DHCPv6
 *  output: int: 0 if the file is written successfully, -1 otherwise
 *          (errno is set)
 */

int
write_hostconf(
    const char *ifname,
    PKT_LIST *pl[],
    uint_t pllen,
    time_t relative_to,
    boolean_t isv6)
{
        int             fd;
        struct iovec    iov[IOV_MAX];
        int             retval;
        uint32_t        magic;
        ssize_t         explen = 0; /* Expected length of write */
        int             i, iovlen = 0;

        fd = open(ifname_to_hostconf(ifname, isv6), O_WRONLY|O_CREAT|O_TRUNC,
            0600);
        if (fd == -1)
                return (-1);

        /*
         * first write our magic number, then the relative time of the
         * leases, then for each packet we write the length of the packet
         * followed by the packet.  we will then use the relative time in
         * read_hostconf() to recalculate the lease times for the first packet.
         */

        magic = isv6 ? DHCP_HOSTCONF_MAGIC6 : DHCP_HOSTCONF_MAGIC;
        iov[iovlen].iov_base = (caddr_t)&magic;
        explen += iov[iovlen++].iov_len  = sizeof (magic);
        iov[iovlen].iov_base = (caddr_t)&relative_to;
        explen += iov[iovlen++].iov_len  = sizeof (relative_to);
        for (i = 0; i < pllen && iovlen < (IOV_MAX - 1); i++) {
                iov[iovlen].iov_base = (caddr_t)&pl[i]->len;
                explen += iov[iovlen++].iov_len  = sizeof (pl[i]->len);
                iov[iovlen].iov_base = (caddr_t)pl[i]->pkt;
                explen += iov[iovlen++].iov_len  = pl[i]->len;
        }

        retval = writev(fd, iov, iovlen);

        (void) close(fd);

        if (retval != explen)
                return (-1);

        return (0);
}

/*
 * relativize_time(): re-relativizes a time in a DHCP option
 *
 *   input: DHCP_OPT *: the DHCP option parameter to convert
 *          time_t: the time the leases in the packet are currently relative to
 *          time_t: the current time which leases will become relative to
 *  output: void
 */

static void
relativize_time(DHCP_OPT *option, time_t orig_time, time_t current_time)
{
        uint32_t        pkt_time;
        time_t          time_diff = current_time - orig_time;

        if (option == NULL || option->len != sizeof (lease_t))
                return;

        (void) memcpy(&pkt_time, option->value, option->len);
        if (ntohl(pkt_time) != DHCP_PERM)
                pkt_time = htonl(ntohl(pkt_time) - time_diff);

        (void) memcpy(option->value, &pkt_time, option->len);
}

/*
 * relativize_v6(): re-relativizes a time in a DHCPv6 option
 *
 *   input: uint32_t *: the time value to convert
 *          time_t: the time the leases in the packet are currently relative to
 *          time_t: the current time which leases will become relative to
 *  output: void
 */

static void
relativize_v6(uint32_t *val, time_t orig_time, time_t current_time)
{
        uint32_t        hval;
        time_t          time_diff = current_time - orig_time;

        hval = ntohl(*val);
        if (hval != DHCPV6_INFTIME) {
                if (hval < time_diff)
                        *val = 0;
                else
                        *val = htonl(hval - time_diff);
        }
}