/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright (c) 2016 by Delphix. All rights reserved.
 */

#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <stdarg.h>
#include <limits.h>
#include <ctype.h>
#include <libgen.h>
#include <sys/isa_defs.h>
#include <sys/socket.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/sysmacros.h>
#include <libinetutil.h>
#include <libdlpi.h>
#include <netinet/dhcp6.h>

#include "dhcp_symbol.h"
#include "dhcp_inittab.h"

static void             inittab_msg(const char *, ...);
static uchar_t          category_to_code(const char *);
static boolean_t        encode_number(uint8_t, uint8_t, boolean_t, uint8_t,
                            const char *, uint8_t *, int *);
static boolean_t        decode_number(uint8_t, uint8_t, boolean_t, uint8_t,
                            const uint8_t *, char *, int *);
static dhcp_symbol_t    *inittab_lookup(uchar_t, char, const char *, int32_t,
                            size_t *);
static dsym_category_t  itabcode_to_dsymcode(uchar_t);
static boolean_t        parse_entry(char *, char **);

/*
 * forward declaration of our internal inittab_table[].  too bulky to put
 * up front -- check the end of this file for its definition.
 *
 * Note: we have only an IPv4 version here.  The inittab_verify() function is
 * used by the DHCP server and manager.  We'll need a new function if the
 * server is extended to DHCPv6.
 */
static dhcp_symbol_t    inittab_table[];

/*
 * the number of fields in the inittab and names for the fields.  note that
 * this order is meaningful to parse_entry(); other functions should just
 * use them as indexes into the array returned from parse_entry().
 */
#define ITAB_FIELDS     7
enum { ITAB_NAME, ITAB_CODE, ITAB_TYPE, ITAB_GRAN, ITAB_MAX, ITAB_CONS,
    ITAB_CAT };

/*
 * the category_map_entry_t is used to map the inittab category codes to
 * the dsym codes.  the reason the codes are different is that the inittab
 * needs to have the codes be ORable such that queries can retrieve more
 * than one category at a time.  this map is also used to map the inittab
 * string representation of a category to its numerical code.
 */
typedef struct category_map_entry {
        dsym_category_t cme_dsymcode;
        char            *cme_name;
        uchar_t         cme_itabcode;
} category_map_entry_t;

static category_map_entry_t category_map[] = {
        { DSYM_STANDARD,        "STANDARD",     ITAB_CAT_STANDARD },
        { DSYM_FIELD,           "FIELD",        ITAB_CAT_FIELD },
        { DSYM_INTERNAL,        "INTERNAL",     ITAB_CAT_INTERNAL },
        { DSYM_VENDOR,          "VENDOR",       ITAB_CAT_VENDOR },
        { DSYM_SITE,            "SITE",         ITAB_CAT_SITE }
};

/*
 * inittab_load(): returns all inittab entries with the specified criteria
 *
 *   input: uchar_t: the categories the consumer is interested in
 *          char: the consumer type of the caller
 *          size_t *: set to the number of entries returned
 *  output: dhcp_symbol_t *: an array of dynamically allocated entries
 *          on success, NULL upon failure
 */

dhcp_symbol_t   *
inittab_load(uchar_t categories, char consumer, size_t *n_entries)
{
        return (inittab_lookup(categories, consumer, NULL, -1, n_entries));
}

/*
 * inittab_getbyname(): returns an inittab entry with the specified criteria
 *
 *   input: int: the categories the consumer is interested in
 *          char: the consumer type of the caller
 *          char *: the name of the inittab entry the consumer wants
 *  output: dhcp_symbol_t *: a dynamically allocated dhcp_symbol structure
 *          on success, NULL upon failure
 */

dhcp_symbol_t   *
inittab_getbyname(uchar_t categories, char consumer, const char *name)
{
        return (inittab_lookup(categories, consumer, name, -1, NULL));
}

/*
 * inittab_getbycode(): returns an inittab entry with the specified criteria
 *
 *   input: uchar_t: the categories the consumer is interested in
 *          char: the consumer type of the caller
 *          uint16_t: the code of the inittab entry the consumer wants
 *  output: dhcp_symbol_t *: a dynamically allocated dhcp_symbol structure
 *          on success, NULL upon failure
 */

dhcp_symbol_t   *
inittab_getbycode(uchar_t categories, char consumer, uint16_t code)
{
        return (inittab_lookup(categories, consumer, NULL, code, NULL));
}

/*
 * inittab_lookup(): returns inittab entries with the specified criteria
 *
 *   input: uchar_t: the categories the consumer is interested in
 *          char: the consumer type of the caller
 *          const char *: the name of the entry the caller is interested
 *              in, or NULL if the caller doesn't care
 *          int32_t: the code the caller is interested in, or -1 if the
 *              caller doesn't care
 *          size_t *: set to the number of entries returned
 *  output: dhcp_symbol_t *: dynamically allocated dhcp_symbol structures
 *          on success, NULL upon failure
 */

static dhcp_symbol_t *
inittab_lookup(uchar_t categories, char consumer, const char *name,
    int32_t code, size_t *n_entriesp)
{
        FILE                    *inittab_fp;
        dhcp_symbol_t           *new_entries, *entries = NULL;
        dhcp_symbol_t           entry;
        char                    buffer[ITAB_MAX_LINE_LEN];
        char                    *fields[ITAB_FIELDS];
        unsigned long           line = 0;
        size_t                  i, n_entries = 0;
        const char              *inittab_path;
        uchar_t                 category_code;
        dsym_cdtype_t           type;

        if (categories & ITAB_CAT_V6) {
                inittab_path = getenv("DHCP_INITTAB6_PATH");
                if (inittab_path == NULL)
                        inittab_path = ITAB_INITTAB6_PATH;
        } else {
                inittab_path = getenv("DHCP_INITTAB_PATH");
                if (inittab_path == NULL)
                        inittab_path = ITAB_INITTAB_PATH;
        }

        inittab_fp = fopen(inittab_path, "r");
        if (inittab_fp == NULL) {
                inittab_msg("inittab_lookup: fopen: %s: %s",
                    inittab_path, strerror(errno));
                return (NULL);
        }

        (void) bufsplit(",\n", 0, NULL);
        while (fgets(buffer, sizeof (buffer), inittab_fp) != NULL) {

                line++;

                /*
                 * make sure the string didn't overflow our buffer
                 */
                if (strchr(buffer, '\n') == NULL) {
                        inittab_msg("inittab_lookup: line %li: too long, "
                            "skipping", line);
                        continue;
                }

                /*
                 * skip `pure comment' lines
                 */
                for (i = 0; buffer[i] != '\0'; i++)
                        if (isspace(buffer[i]) == 0)
                                break;

                if (buffer[i] == ITAB_COMMENT_CHAR || buffer[i] == '\0')
                        continue;

                /*
                 * parse the entry out into fields.
                 */
                if (parse_entry(buffer, fields) == B_FALSE) {
                        inittab_msg("inittab_lookup: line %li: syntax error, "
                            "skipping", line);
                        continue;
                }

                /*
                 * validate the values in the entries; skip if invalid.
                 */
                if (atoi(fields[ITAB_GRAN]) > ITAB_GRAN_MAX) {
                        inittab_msg("inittab_lookup: line %li: granularity `%s'"
                            " out of range, skipping", line, fields[ITAB_GRAN]);
                        continue;
                }

                if (atoi(fields[ITAB_MAX]) > ITAB_MAX_MAX) {
                        inittab_msg("inittab_lookup: line %li: maximum `%s' "
                            "out of range, skipping", line, fields[ITAB_MAX]);
                        continue;
                }

                if (dsym_get_type_id(fields[ITAB_TYPE], &type, B_FALSE) !=
                    DSYM_SUCCESS) {
                        inittab_msg("inittab_lookup: line %li: type `%s' "
                            "is invalid, skipping", line, fields[ITAB_TYPE]);
                        continue;
                }

                /*
                 * find out whether this entry of interest to our consumer,
                 * and if so, throw it onto the set of entries we'll return.
                 * check categories last since it's the most expensive check.
                 */
                if (strchr(fields[ITAB_CONS], consumer) == NULL)
                        continue;

                if (code != -1 && atoi(fields[ITAB_CODE]) != code)
                        continue;

                if (name != NULL && strcasecmp(fields[ITAB_NAME], name) != 0)
                        continue;

                category_code = category_to_code(fields[ITAB_CAT]);
                if ((category_code & categories) == 0)
                        continue;

                /*
                 * looks like a match.  allocate an entry and fill it in
                 */
                new_entries = realloc(entries, (n_entries + 1) *
                    sizeof (dhcp_symbol_t));

                /*
                 * if we run out of memory, might as well return what we can
                 */
                if (new_entries == NULL) {
                        inittab_msg("inittab_lookup: ran out of memory "
                            "allocating dhcp_symbol_t's");
                        break;
                }

                entry.ds_max      = atoi(fields[ITAB_MAX]);
                entry.ds_code     = atoi(fields[ITAB_CODE]);
                entry.ds_type     = type;
                entry.ds_gran     = atoi(fields[ITAB_GRAN]);
                entry.ds_category = itabcode_to_dsymcode(category_code);
                entry.ds_classes.dc_cnt   = 0;
                entry.ds_classes.dc_names = NULL;
                (void) strlcpy(entry.ds_name, fields[ITAB_NAME],
                    sizeof (entry.ds_name));
                entry.ds_dhcpv6   = (categories & ITAB_CAT_V6) ? 1 : 0;

                entries = new_entries;
                entries[n_entries++] = entry;
        }

        if (ferror(inittab_fp) != 0) {
                inittab_msg("inittab_lookup: error on inittab stream");
                clearerr(inittab_fp);
        }

        (void) fclose(inittab_fp);

        if (n_entriesp != NULL)
                *n_entriesp = n_entries;

        return (entries);
}

/*
 * parse_entry(): parses an entry out into its constituent fields
 *
 *   input: char *: the entry
 *          char **: an array of ITAB_FIELDS length which contains
 *                   pointers into the entry on upon return
 *  output: boolean_t: B_TRUE on success, B_FALSE on failure
 */

static boolean_t
parse_entry(char *entry, char **fields)
{
        char    *category, *spacep;
        size_t  n_fields, i;

        /*
         * due to a mistake made long ago, the first and second fields of
         * each entry are not separated by a comma, but rather by
         * whitespace -- have bufsplit() treat the two fields as one, then
         * pull them apart afterwards.
         */
        n_fields = bufsplit(entry, ITAB_FIELDS - 1, fields);
        if (n_fields != (ITAB_FIELDS - 1))
                return (B_FALSE);

        /*
         * pull the first and second fields apart.  this is complicated
         * since the first field can contain embedded whitespace (so we
         * must separate the two fields by the last span of whitespace).
         *
         * first, find the initial span of whitespace.  if there isn't one,
         * then the entry is malformed.
         */
        category = strpbrk(fields[ITAB_NAME], " \t");
        if (category == NULL)
                return (B_FALSE);

        /*
         * find the last span of whitespace.
         */
        do {
                while (isspace(*category))
                        category++;

                spacep = strpbrk(category, " \t");
                if (spacep != NULL)
                        category = spacep;
        } while (spacep != NULL);

        /*
         * NUL-terminate the first byte of the last span of whitespace, so
         * that the first field doesn't have any residual trailing
         * whitespace.
         */
        spacep = category - 1;
        while (isspace(*spacep))
                spacep--;

        if (spacep <= fields[0])
                return (B_FALSE);

        *++spacep = '\0';

        /*
         * remove any whitespace from the fields.
         */
        for (i = 0; i < n_fields; i++) {
                while (isspace(*fields[i]))
                        fields[i]++;
        }
        fields[ITAB_CAT] = category;

        return (B_TRUE);
}

/*
 * inittab_verify(): verifies that a given inittab entry matches an internal
 *                   definition
 *
 *   input: dhcp_symbol_t *: the inittab entry to verify
 *          dhcp_symbol_t *: if non-NULL, a place to store the internal
 *                             inittab entry upon return
 *  output: int: ITAB_FAILURE, ITAB_SUCCESS, or ITAB_UNKNOWN
 *
 *   notes: IPv4 only
 */

int
inittab_verify(const dhcp_symbol_t *inittab_ent, dhcp_symbol_t *internal_ent)
{
        unsigned int    i;

        for (i = 0; inittab_table[i].ds_name[0] != '\0'; i++) {

                if (inittab_ent->ds_category != inittab_table[i].ds_category)
                        continue;

                if (inittab_ent->ds_code == inittab_table[i].ds_code) {
                        if (internal_ent != NULL)
                                *internal_ent = inittab_table[i];

                        if (inittab_table[i].ds_type != inittab_ent->ds_type ||
                            inittab_table[i].ds_gran != inittab_ent->ds_gran ||
                            inittab_table[i].ds_max  != inittab_ent->ds_max)
                                return (ITAB_FAILURE);

                        return (ITAB_SUCCESS);
                }
        }

        return (ITAB_UNKNOWN);
}

/*
 * get_hw_type(): interpret ",hwtype" in the input string, as part of a DUID.
 *                The hwtype string is optional, and must be 0-65535 if
 *                present.
 *
 *   input: char **: pointer to string pointer
 *          int *: error return value
 *  output: int: hardware type, or -1 for empty, or -2 for error.
 */

static int
get_hw_type(char **strp, int *ierrnop)
{
        char *str = *strp;
        ulong_t hwtype;

        if (*str++ != ',') {
                *ierrnop = ITAB_BAD_NUMBER;
                return (-2);
        }
        if (*str == ',' || *str == '\0') {
                *strp = str;
                return (-1);
        }
        hwtype = strtoul(str, strp, 0);
        if (errno != 0 || *strp == str || hwtype > 65535) {
                *ierrnop = ITAB_BAD_NUMBER;
                return (-2);
        } else {
                return ((int)hwtype);
        }
}

/*
 * get_mac_addr(): interpret ",macaddr" in the input string, as part of a DUID.
 *                 The 'macaddr' may be a hex string (in any standard format),
 *                 or the name of a physical interface.  If an interface name
 *                 is given, then the interface type is extracted as well.
 *
 *   input: const char *: input string
 *          int *: error return value
 *          uint16_t *: hardware type output (network byte order)
 *          int: hardware type input; -1 for empty
 *          uchar_t *: output buffer for MAC address
 *  output: int: length of MAC address, or -1 for error
 */

static int
get_mac_addr(const char *str, int *ierrnop, uint16_t *hwret, int hwtype,
    uchar_t *outbuf)
{
        int maclen;
        int dig, val;
        dlpi_handle_t dh;
        dlpi_info_t dlinfo;
        char chr;

        if (*str != '\0') {
                if (*str++ != ',')
                        goto failed;
                if (dlpi_open(str, &dh, 0) != DLPI_SUCCESS) {
                        maclen = 0;
                        dig = val = 0;
                        /*
                         * Allow MAC addresses with separators matching regexp
                         * (:|-| *).
                         */
                        while ((chr = *str++) != '\0') {
                                if (isdigit(chr)) {
                                        val = (val << 4) + chr - '0';
                                } else if (isxdigit(chr)) {
                                        val = (val << 4) + chr -
                                            (isupper(chr) ? 'A' : 'a') + 10;
                                } else if (isspace(chr) && dig == 0) {
                                        continue;
                                } else if (chr == ':' || chr == '-' ||
                                    isspace(chr)) {
                                        dig = 1;
                                } else {
                                        goto failed;
                                }
                                if (++dig == 2) {
                                        *outbuf++ = val;
                                        maclen++;
                                        dig = val = 0;
                                }
                        }
                } else {
                        if (dlpi_bind(dh, DLPI_ANY_SAP, NULL) !=
                            DLPI_SUCCESS || dlpi_info(dh, &dlinfo, 0) !=
                            DLPI_SUCCESS) {
                                dlpi_close(dh);
                                goto failed;
                        }
                        maclen = dlinfo.di_physaddrlen;
                        (void) memcpy(outbuf, dlinfo.di_physaddr, maclen);
                        dlpi_close(dh);
                        if (hwtype == -1)
                                hwtype = dlpi_arptype(dlinfo.di_mactype);
                }
        }
        if (hwtype == -1)
                goto failed;
        *hwret = htons(hwtype);
        return (maclen);

failed:
        *ierrnop = ITAB_BAD_NUMBER;
        return (-1);
}

/*
 * inittab_encode_e(): converts a string representation of a given datatype into
 *                   binary; used for encoding ascii values into a form that
 *                   can be put in DHCP packets to be sent on the wire.
 *
 *   input: const dhcp_symbol_t *: the entry describing the value option
 *          const char *: the value to convert
 *          uint16_t *: set to the length of the binary data returned
 *          boolean_t: if false, return a full DHCP option
 *          int *: error return value
 *  output: uchar_t *: a dynamically allocated byte array with converted data
 */

uchar_t *
inittab_encode_e(const dhcp_symbol_t *ie, const char *value, uint16_t *lengthp,
    boolean_t just_payload, int *ierrnop)
{
        int             hlen = 0;
        uint16_t        length;
        uchar_t         n_entries = 0;
        const char      *valuep;
        char            *currp;
        uchar_t         *result = NULL;
        uchar_t         *optstart;
        unsigned int    i;
        uint8_t         type_size = inittab_type_to_size(ie);
        boolean_t       is_signed;
        uint_t          vallen, reslen;
        dhcpv6_option_t *d6o;
        int             type;
        char            *cp2;

        *ierrnop = 0;
        if (type_size == 0) {
                *ierrnop = ITAB_SYNTAX_ERROR;
                return (NULL);
        }

        switch (ie->ds_type) {
        case DSYM_ASCII:
                n_entries = strlen(value);              /* no NUL */
                break;

        case DSYM_OCTET:
                vallen = strlen(value);
                n_entries = vallen / 2;
                n_entries += vallen % 2;
                break;

        case DSYM_DOMAIN:
                /*
                 * Maximum (worst-case) encoded length is one byte more than
                 * the number of characters on input.
                 */
                n_entries = strlen(value) + 1;
                break;

        case DSYM_DUID:
                /* Worst case is ":::::" */
                n_entries = strlen(value);
                if (n_entries < DLPI_PHYSADDR_MAX)
                        n_entries = DLPI_PHYSADDR_MAX;
                n_entries += sizeof (duid_llt_t);
                break;

        default:
                /*
                 * figure out the number of entries by counting the spaces
                 * in the value string
                 */
                for (valuep = value; valuep++ != NULL; n_entries++)
                        valuep = strchr(valuep, ' ');
                break;
        }

        /*
         * if we're gonna return a complete option, then include the
         * option length and code in the size of the packet we allocate
         */
        if (!just_payload)
                hlen = ie->ds_dhcpv6 ? sizeof (*d6o) : 2;

        length = n_entries * type_size;
        if (hlen + length > 0)
                result = malloc(hlen + length);

        if ((optstart = result) != NULL && !just_payload)
                optstart += hlen;

        switch (ie->ds_type) {

        case DSYM_ASCII:

                if (optstart == NULL) {
                        *ierrnop = ITAB_NOMEM;
                        return (NULL);
                }

                (void) memcpy(optstart, value, length);
                break;

        case DSYM_DOMAIN:
                if (optstart == NULL) {
                        *ierrnop = ITAB_NOMEM;
                        return (NULL);
                }

                /*
                 * Note that this encoder always presents the trailing 0-octet
                 * when dealing with a list.  This means that you can't have
                 * non-fully-qualified members anywhere but at the end of a
                 * list (or as the only member of the list).
                 */
                valuep = value;
                while (*valuep != '\0') {
                        int dig, val, inchr;
                        boolean_t escape;
                        uchar_t *flen;

                        /*
                         * Skip over whitespace that delimits list members.
                         */
                        if (isascii(*valuep) && isspace(*valuep)) {
                                valuep++;
                                continue;
                        }
                        dig = val = 0;
                        escape = B_FALSE;
                        flen = optstart++;
                        while ((inchr = *valuep) != '\0') {
                                valuep++;
                                /*
                                 * Just copy non-ASCII text directly to the
                                 * output string.  This simplifies the use of
                                 * other ctype macros below, as, unlike the
                                 * special isascii function, they don't handle
                                 * non-ASCII.
                                 */
                                if (!isascii(inchr)) {
                                        escape = B_FALSE;
                                        *optstart++ = inchr;
                                        continue;
                                }
                                if (escape) {
                                        /*
                                         * Handle any of \D, \DD, or \DDD for
                                         * a digit escape.
                                         */
                                        if (isdigit(inchr)) {
                                                val = val * 10 + inchr - '0';
                                                if (++dig == 3) {
                                                        *optstart++ = val;
                                                        dig = val = 0;
                                                        escape = B_FALSE;
                                                }
                                                continue;
                                        } else if (dig > 0) {
                                                /*
                                                 * User terminated \D or \DD
                                                 * with non-digit.  An error,
                                                 * but we can assume they mean
                                                 * to treat as \00D or \0DD.
                                                 */
                                                *optstart++ = val;
                                                dig = val = 0;
                                        }
                                        /* Fall through and copy character */
                                        escape = B_FALSE;
                                } else if (inchr == '\\') {
                                        escape = B_TRUE;
                                        continue;
                                } else if (inchr == '.') {
                                        /*
                                         * End of component.  Write the length
                                         * prefix.  If the component is zero
                                         * length (i.e., ".."), the just omit
                                         * it.
                                         */
                                        *flen = (optstart - flen) - 1;
                                        if (*flen > 0)
                                                flen = optstart++;
                                        continue;
                                } else if (isspace(inchr)) {
                                        /*
                                         * Unescaped space; end of domain name
                                         * in list.
                                         */
                                        break;
                                }
                                *optstart++ = inchr;
                        }
                        /*
                         * Handle trailing escape sequence.  If string ends
                         * with \, then assume user wants \ at end of encoded
                         * string.  If it ends with \D or \DD, assume \00D or
                         * \0DD.
                         */
                        if (escape)
                                *optstart++ = dig > 0 ? val : '\\';
                        *flen = (optstart - flen) - 1;
                        /*
                         * If user specified FQDN with trailing '.', then above
                         * will result in zero for the last component length.
                         * We're done, and optstart already points to the start
                         * of the next in list.  Otherwise, we need to write a
                         * single zero byte to end the entry, if there are more
                         * entries that will be decoded.
                         */
                        while (isascii(*valuep) && isspace(*valuep))
                                valuep++;
                        if (*flen > 0 && *valuep != '\0')
                                *optstart++ = '\0';
                }
                length = (optstart - result) - hlen;
                break;

        case DSYM_DUID:
                if (optstart == NULL) {
                        *ierrnop = ITAB_NOMEM;
                        return (NULL);
                }

                errno = 0;
                type = strtoul(value, &currp, 0);
                if (errno != 0 || value == currp || type > 65535 ||
                    (*currp != ',' && *currp != '\0')) {
                        free(result);
                        *ierrnop = ITAB_BAD_NUMBER;
                        return (NULL);
                }
                switch (type) {
                case DHCPV6_DUID_LLT: {
                        duid_llt_t dllt;
                        int hwtype;
                        ulong_t tstamp;
                        int maclen;

                        if ((hwtype = get_hw_type(&currp, ierrnop)) == -2) {
                                free(result);
                                return (NULL);
                        }
                        if (*currp++ != ',') {
                                free(result);
                                *ierrnop = ITAB_BAD_NUMBER;
                                return (NULL);
                        }
                        if (*currp == ',' || *currp == '\0') {
                                tstamp = time(NULL) - DUID_TIME_BASE;
                        } else {
                                tstamp = strtoul(currp, &cp2, 0);
                                if (errno != 0 || currp == cp2) {
                                        free(result);
                                        *ierrnop = ITAB_BAD_NUMBER;
                                        return (NULL);
                                }
                                currp = cp2;
                        }
                        maclen = get_mac_addr(currp, ierrnop,
                            &dllt.dllt_hwtype, hwtype,
                            optstart + sizeof (dllt));
                        if (maclen == -1) {
                                free(result);
                                return (NULL);
                        }
                        dllt.dllt_dutype = htons(type);
                        dllt.dllt_time = htonl(tstamp);
                        (void) memcpy(optstart, &dllt, sizeof (dllt));
                        length = maclen + sizeof (dllt);
                        break;
                }
                case DHCPV6_DUID_EN: {
                        duid_en_t den;
                        ulong_t enterp;

                        if (*currp++ != ',') {
                                free(result);
                                *ierrnop = ITAB_BAD_NUMBER;
                                return (NULL);
                        }
                        enterp = strtoul(currp, &cp2, 0);
                        DHCPV6_SET_ENTNUM(&den, enterp);
                        if (errno != 0 || currp == cp2 ||
                            enterp != DHCPV6_GET_ENTNUM(&den) ||
                            (*cp2 != ',' && *cp2 != '\0')) {
                                free(result);
                                *ierrnop = ITAB_BAD_NUMBER;
                                return (NULL);
                        }
                        if (*cp2 == ',')
                                cp2++;
                        vallen = strlen(cp2);
                        reslen = (vallen + 1) / 2;
                        if (hexascii_to_octet(cp2, vallen,
                            optstart + sizeof (den), &reslen) != 0) {
                                free(result);
                                *ierrnop = ITAB_BAD_NUMBER;
                                return (NULL);
                        }
                        den.den_dutype = htons(type);
                        (void) memcpy(optstart, &den, sizeof (den));
                        length = reslen + sizeof (den);
                        break;
                }
                case DHCPV6_DUID_LL: {
                        duid_ll_t dll;
                        int hwtype;
                        int maclen;

                        if ((hwtype = get_hw_type(&currp, ierrnop)) == -2) {
                                free(result);
                                return (NULL);
                        }
                        maclen = get_mac_addr(currp, ierrnop, &dll.dll_hwtype,
                            hwtype, optstart + sizeof (dll));
                        if (maclen == -1) {
                                free(result);
                                return (NULL);
                        }
                        dll.dll_dutype = htons(type);
                        (void) memcpy(optstart, &dll, sizeof (dll));
                        length = maclen + sizeof (dll);
                        break;
                }
                default:
                        if (*currp == ',')
                                currp++;
                        vallen = strlen(currp);
                        reslen = (vallen + 1) / 2;
                        if (hexascii_to_octet(currp, vallen, optstart + 2,
                            &reslen) != 0) {
                                free(result);
                                *ierrnop = ITAB_BAD_NUMBER;
                                return (NULL);
                        }
                        optstart[0] = type >> 8;
                        optstart[1] = type;
                        length = reslen + 2;
                        break;
                }
                break;

        case DSYM_OCTET:

                if (optstart == NULL) {
                        *ierrnop = ITAB_BAD_OCTET;
                        return (NULL);
                }

                reslen = length;
                /* Call libinetutil function to decode */
                if (hexascii_to_octet(value, vallen, optstart, &reslen) != 0) {
                        free(result);
                        *ierrnop = ITAB_BAD_OCTET;
                        return (NULL);
                }
                break;

        case DSYM_IP:
        case DSYM_IPV6:

                if (optstart == NULL) {
                        *ierrnop = ITAB_BAD_IPADDR;
                        return (NULL);
                }
                if (n_entries % ie->ds_gran != 0) {
                        *ierrnop = ITAB_BAD_GRAN;
                        inittab_msg("inittab_encode: number of entries "
                            "not compatible with option granularity");
                        free(result);
                        return (NULL);
                }

                for (valuep = value, i = 0; i < n_entries; i++, valuep++) {

                        currp = strchr(valuep, ' ');
                        if (currp != NULL)
                                *currp = '\0';
                        if (inet_pton(ie->ds_type == DSYM_IP ? AF_INET :
                            AF_INET6, valuep, optstart) != 1) {
                                *ierrnop = ITAB_BAD_IPADDR;
                                inittab_msg("inittab_encode: bogus ip address");
                                free(result);
                                return (NULL);
                        }

                        valuep = currp;
                        if (valuep == NULL) {
                                if (i < (n_entries - 1)) {
                                        *ierrnop = ITAB_NOT_ENOUGH_IP;
                                        inittab_msg("inittab_encode: too few "
                                            "ip addresses");
                                        free(result);
                                        return (NULL);
                                }
                                break;
                        }
                        optstart += type_size;
                }
                break;

        case DSYM_NUMBER:                               /* FALLTHRU */
        case DSYM_UNUMBER8:                             /* FALLTHRU */
        case DSYM_SNUMBER8:                             /* FALLTHRU */
        case DSYM_UNUMBER16:                            /* FALLTHRU */
        case DSYM_SNUMBER16:                            /* FALLTHRU */
        case DSYM_UNUMBER24:                            /* FALLTHRU */
        case DSYM_UNUMBER32:                            /* FALLTHRU */
        case DSYM_SNUMBER32:                            /* FALLTHRU */
        case DSYM_UNUMBER64:                            /* FALLTHRU */
        case DSYM_SNUMBER64:

                if (optstart == NULL) {
                        *ierrnop = ITAB_BAD_NUMBER;
                        return (NULL);
                }

                is_signed = (ie->ds_type == DSYM_SNUMBER64 ||
                    ie->ds_type == DSYM_SNUMBER32 ||
                    ie->ds_type == DSYM_SNUMBER16 ||
                    ie->ds_type == DSYM_SNUMBER8);

                if (encode_number(n_entries, type_size, is_signed, 0, value,
                    optstart, ierrnop) == B_FALSE) {
                        free(result);
                        return (NULL);
                }
                break;

        default:
                if (ie->ds_type == DSYM_BOOL)
                        *ierrnop = ITAB_BAD_BOOLEAN;
                else
                        *ierrnop = ITAB_SYNTAX_ERROR;

                inittab_msg("inittab_encode: unsupported type `%d'",
                    ie->ds_type);

                free(result);
                return (NULL);
        }

        /*
         * if just_payload is false, then we need to add the option
         * code and length fields in.
         */
        if (!just_payload) {
                if (ie->ds_dhcpv6) {
                        /* LINTED: alignment */
                        d6o = (dhcpv6_option_t *)result;
                        d6o->d6o_code = htons(ie->ds_code);
                        d6o->d6o_len = htons(length);
                } else {
                        result[0] = ie->ds_code;
                        result[1] = length;
                }
        }

        if (lengthp != NULL)
                *lengthp = length + hlen;

        return (result);
}

/*
 * inittab_decode_e(): converts a binary representation of a given datatype into
 *                   a string; used for decoding DHCP options in a packet off
 *                   the wire into ascii
 *
 *   input: dhcp_symbol_t *: the entry describing the payload option
 *          uchar_t *: the payload to convert
 *          uint16_t: the payload length (only used if just_payload is true)
 *          boolean_t: if false, payload is assumed to be a DHCP option
 *          int *: set to extended error code if error occurs.
 *  output: char *: a dynamically allocated string containing the converted data
 */

char *
inittab_decode_e(const dhcp_symbol_t *ie, const uchar_t *payload,
    uint16_t length, boolean_t just_payload, int *ierrnop)
{
        char            *resultp, *result = NULL;
        uint_t          n_entries;
        struct in_addr  in_addr;
        in6_addr_t      in6_addr;
        uint8_t         type_size = inittab_type_to_size(ie);
        boolean_t       is_signed;
        int             type;

        *ierrnop = 0;
        if (type_size == 0) {
                *ierrnop = ITAB_SYNTAX_ERROR;
                return (NULL);
        }

        if (!just_payload) {
                if (ie->ds_dhcpv6) {
                        dhcpv6_option_t d6o;

                        (void) memcpy(&d6o, payload, sizeof (d6o));
                        length = ntohs(d6o.d6o_len);
                        payload += sizeof (d6o);
                } else {
                        length = payload[1];
                        payload += 2;
                }
        }

        /*
         * figure out the number of elements to convert.  note that
         * for ds_type NUMBER, the granularity is really 1 since the
         * value of ds_gran is the number of bytes in the number.
         */
        if (ie->ds_type == DSYM_NUMBER)
                n_entries = MIN(ie->ds_max, length / type_size);
        else
                n_entries = MIN(ie->ds_max * ie->ds_gran, length / type_size);

        if (n_entries == 0)
                n_entries = length / type_size;

        if ((length % type_size) != 0) {
                inittab_msg("inittab_decode: length of string not compatible "
                    "with option type `%i'", ie->ds_type);
                *ierrnop = ITAB_BAD_STRING;
                return (NULL);
        }

        switch (ie->ds_type) {

        case DSYM_ASCII:

                result = malloc(n_entries + 1);
                if (result == NULL) {
                        *ierrnop = ITAB_NOMEM;
                        return (NULL);
                }

                (void) memcpy(result, payload, n_entries);
                result[n_entries] = '\0';
                break;

        case DSYM_DOMAIN:

                /*
                 * A valid, decoded RFC 1035 domain string or sequence of
                 * strings is always the same size as the encoded form, but we
                 * allow for RFC 1035 \DDD and \\ and \. escaping.
                 *
                 * Decoding stops at the end of the input or the first coding
                 * violation.  Coding violations result in discarding the
                 * offending list entry entirely.  Note that we ignore the 255
                 * character overall limit on domain names.
                 */
                if ((result = malloc(4 * length + 1)) == NULL) {
                        *ierrnop = ITAB_NOMEM;
                        return (NULL);
                }
                resultp = result;
                while (length > 0) {
                        char *dstart;
                        int slen;

                        dstart = resultp;
                        while (length > 0) {
                                slen = *payload++;
                                length--;
                                /* Upper two bits of length must be zero */
                                if ((slen & 0xc0) != 0 || slen > length) {
                                        length = 0;
                                        resultp = dstart;
                                        break;
                                }
                                if (resultp != dstart)
                                        *resultp++ = '.';
                                if (slen == 0)
                                        break;
                                length -= slen;
                                while (slen > 0) {
                                        if (!isascii(*payload) ||
                                            !isgraph(*payload)) {
                                                (void) snprintf(resultp, 5,
                                                    "\\%03d",
                                                    *(unsigned char *)payload);
                                                resultp += 4;
                                                payload++;
                                        } else {
                                                if (*payload == '.' ||
                                                    *payload == '\\')
                                                        *resultp++ = '\\';
                                                *resultp++ = *payload++;
                                        }
                                        slen--;
                                }
                        }
                        if (resultp != dstart && length > 0)
                                *resultp++ = ' ';
                }
                *resultp = '\0';
                break;

        case DSYM_DUID:

                /*
                 * First, determine the type of DUID.  We need at least two
                 * octets worth of data to grab the type code.  Once we have
                 * that, the number of octets required for representation
                 * depends on the type.
                 */

                if (length < 2) {
                        *ierrnop = ITAB_BAD_GRAN;
                        return (NULL);
                }
                type = (payload[0] << 8) + payload[1];
                switch (type) {
                case DHCPV6_DUID_LLT: {
                        duid_llt_t dllt;

                        if (length < sizeof (dllt)) {
                                *ierrnop = ITAB_BAD_GRAN;
                                return (NULL);
                        }
                        (void) memcpy(&dllt, payload, sizeof (dllt));
                        payload += sizeof (dllt);
                        length -= sizeof (dllt);
                        n_entries = sizeof ("1,65535,4294967295,") +
                            length * 3;
                        if ((result = malloc(n_entries)) == NULL) {
                                *ierrnop = ITAB_NOMEM;
                                return (NULL);
                        }
                        (void) snprintf(result, n_entries, "%d,%u,%u,", type,
                            ntohs(dllt.dllt_hwtype), ntohl(dllt.dllt_time));
                        break;
                }
                case DHCPV6_DUID_EN: {
                        duid_en_t den;

                        if (length < sizeof (den)) {
                                *ierrnop = ITAB_BAD_GRAN;
                                return (NULL);
                        }
                        (void) memcpy(&den, payload, sizeof (den));
                        payload += sizeof (den);
                        length -= sizeof (den);
                        n_entries = sizeof ("2,4294967295,") + length * 2;
                        if ((result = malloc(n_entries)) == NULL) {
                                *ierrnop = ITAB_NOMEM;
                                return (NULL);
                        }
                        (void) snprintf(result, n_entries, "%d,%u,", type,
                            DHCPV6_GET_ENTNUM(&den));
                        break;
                }
                case DHCPV6_DUID_LL: {
                        duid_ll_t dll;

                        if (length < sizeof (dll)) {
                                *ierrnop = ITAB_BAD_GRAN;
                                return (NULL);
                        }
                        (void) memcpy(&dll, payload, sizeof (dll));
                        payload += sizeof (dll);
                        length -= sizeof (dll);
                        n_entries = sizeof ("3,65535,") + length * 3;
                        if ((result = malloc(n_entries)) == NULL) {
                                *ierrnop = ITAB_NOMEM;
                                return (NULL);
                        }
                        (void) snprintf(result, n_entries, "%d,%u,", type,
                            ntohs(dll.dll_hwtype));
                        break;
                }
                default:
                        n_entries = sizeof ("0,") + length * 2;
                        if ((result = malloc(n_entries)) == NULL) {
                                *ierrnop = ITAB_NOMEM;
                                return (NULL);
                        }
                        (void) snprintf(result, n_entries, "%d,", type);
                        break;
                }
                resultp = result + strlen(result);
                n_entries -= strlen(result);
                if (type == DHCPV6_DUID_LLT || type == DHCPV6_DUID_LL) {
                        if (length > 0) {
                                resultp += snprintf(resultp, 3, "%02X",
                                    *payload++);
                                length--;
                        }
                        while (length-- > 0) {
                                resultp += snprintf(resultp, 4, ":%02X",
                                    *payload++);
                        }
                } else {
                        while (length-- > 0) {
                                resultp += snprintf(resultp, 3, "%02X",
                                    *payload++);
                        }
                }
                break;

        case DSYM_OCTET:

                result = malloc(n_entries * (sizeof ("0xNN") + 1));
                if (result == NULL) {
                        *ierrnop = ITAB_NOMEM;
                        return (NULL);
                }

                result[0] = '\0';
                resultp = result;
                if (n_entries > 0) {
                        resultp += sprintf(resultp, "0x%02X", *payload++);
                        n_entries--;
                }
                while (n_entries-- > 0)
                        resultp += sprintf(resultp, " 0x%02X", *payload++);

                break;

        case DSYM_IP:
        case DSYM_IPV6:
                if ((length / type_size) % ie->ds_gran != 0) {
                        *ierrnop = ITAB_BAD_GRAN;
                        inittab_msg("inittab_decode: number of entries "
                            "not compatible with option granularity");
                        return (NULL);
                }

                result = malloc(n_entries * (ie->ds_type == DSYM_IP ?
                    INET_ADDRSTRLEN : INET6_ADDRSTRLEN));
                if (result == NULL) {
                        *ierrnop = ITAB_NOMEM;
                        return (NULL);
                }

                for (resultp = result; n_entries != 0; n_entries--) {
                        if (ie->ds_type == DSYM_IP) {
                                (void) memcpy(&in_addr.s_addr, payload,
                                    sizeof (ipaddr_t));
                                (void) strcpy(resultp, inet_ntoa(in_addr));
                        } else {
                                (void) memcpy(&in6_addr, payload,
                                    sizeof (in6_addr));
                                (void) inet_ntop(AF_INET6, &in6_addr, resultp,
                                    INET6_ADDRSTRLEN);
                        }
                        resultp += strlen(resultp);
                        if (n_entries > 1)
                                *resultp++ = ' ';
                        payload += type_size;
                }
                *resultp = '\0';
                break;

        case DSYM_NUMBER:                               /* FALLTHRU */
        case DSYM_UNUMBER8:                             /* FALLTHRU */
        case DSYM_SNUMBER8:                             /* FALLTHRU */
        case DSYM_UNUMBER16:                            /* FALLTHRU */
        case DSYM_SNUMBER16:                            /* FALLTHRU */
        case DSYM_UNUMBER32:                            /* FALLTHRU */
        case DSYM_SNUMBER32:                            /* FALLTHRU */
        case DSYM_UNUMBER64:                            /* FALLTHRU */
        case DSYM_SNUMBER64:

                is_signed = (ie->ds_type == DSYM_SNUMBER64 ||
                    ie->ds_type == DSYM_SNUMBER32 ||
                    ie->ds_type == DSYM_SNUMBER16 ||
                    ie->ds_type == DSYM_SNUMBER8);

                result = malloc(n_entries * ITAB_MAX_NUMBER_LEN);
                if (result == NULL) {
                        *ierrnop = ITAB_NOMEM;
                        return (NULL);
                }

                if (decode_number(n_entries, type_size, is_signed, ie->ds_gran,
                    payload, result, ierrnop) == B_FALSE) {
                        free(result);
                        return (NULL);
                }
                break;

        default:
                inittab_msg("inittab_decode: unsupported type `%d'",
                    ie->ds_type);
                break;
        }

        return (result);
}

/*
 * inittab_encode(): converts a string representation of a given datatype into
 *                   binary; used for encoding ascii values into a form that
 *                   can be put in DHCP packets to be sent on the wire.
 *
 *   input: dhcp_symbol_t *: the entry describing the value option
 *          const char *: the value to convert
 *          uint16_t *: set to the length of the binary data returned
 *          boolean_t: if false, return a full DHCP option
 *  output: uchar_t *: a dynamically allocated byte array with converted data
 */

uchar_t *
inittab_encode(const dhcp_symbol_t *ie, const char *value, uint16_t *lengthp,
    boolean_t just_payload)
{
        int ierrno;

        return (inittab_encode_e(ie, value, lengthp, just_payload, &ierrno));
}

/*
 * inittab_decode(): converts a binary representation of a given datatype into
 *                   a string; used for decoding DHCP options in a packet off
 *                   the wire into ascii
 *
 *   input: dhcp_symbol_t *: the entry describing the payload option
 *          uchar_t *: the payload to convert
 *          uint16_t: the payload length (only used if just_payload is true)
 *          boolean_t: if false, payload is assumed to be a DHCP option
 *  output: char *: a dynamically allocated string containing the converted data
 */

char *
inittab_decode(const dhcp_symbol_t *ie, const uchar_t *payload, uint16_t length,
    boolean_t just_payload)
{
        int ierrno;

        return (inittab_decode_e(ie, payload, length, just_payload, &ierrno));
}

/*
 * inittab_msg(): prints diagnostic messages if INITTAB_DEBUG is set
 *
 *          const char *: a printf-like format string
 *          ...: arguments to the format string
 *  output: void
 */

/*PRINTFLIKE1*/
static void
inittab_msg(const char *fmt, ...)
{
        enum { INITTAB_MSG_CHECK, INITTAB_MSG_RETURN, INITTAB_MSG_OUTPUT };

        va_list         ap;
        char            buf[512];
        static int      action = INITTAB_MSG_CHECK;

        /*
         * check DHCP_INITTAB_DEBUG the first time in; thereafter, use
         * the the cached result (stored in `action').
         */
        switch (action) {

        case INITTAB_MSG_CHECK:

                if (getenv("DHCP_INITTAB_DEBUG") == NULL) {
                        action = INITTAB_MSG_RETURN;
                        return;
                }

                action = INITTAB_MSG_OUTPUT;
                /* FALLTHROUGH */

        case INITTAB_MSG_OUTPUT:

                va_start(ap, fmt);

                (void) snprintf(buf, sizeof (buf), "inittab: %s\n", fmt);
                (void) vfprintf(stderr, buf, ap);

                va_end(ap);
                break;

        case INITTAB_MSG_RETURN:

                return;
        }
}

/*
 * decode_number(): decodes a sequence of numbers from binary into ascii;
 *                  binary is coming off of the network, so it is in nbo
 *
 *   input: uint8_t: the number of "granularity" numbers to decode
 *          uint8_t: the length of each number
 *          boolean_t: whether the numbers should be considered signed
 *          uint8_t: the number of numbers per granularity
 *          const uint8_t *: where to decode the numbers from
 *          char *: where to decode the numbers to
 *  output: boolean_t: true on successful conversion, false on failure
 */

static boolean_t
decode_number(uint8_t n_entries, uint8_t size, boolean_t is_signed,
    uint8_t granularity, const uint8_t *from, char *to, int *ierrnop)
{
        uint16_t        uint16;
        uint32_t        uint32;
        uint64_t        uint64;

        if (granularity != 0) {
                if ((granularity % n_entries) != 0) {
                        inittab_msg("decode_number: number of entries "
                            "not compatible with option granularity");
                        *ierrnop = ITAB_BAD_GRAN;
                        return (B_FALSE);
                }
        }

        for (; n_entries != 0; n_entries--, from += size) {

                switch (size) {

                case 1:
                        to += sprintf(to, is_signed ? "%d" : "%u", *from);
                        break;

                case 2:
                        (void) memcpy(&uint16, from, 2);
                        to += sprintf(to, is_signed ? "%hd" : "%hu",
                            ntohs(uint16));
                        break;

                case 3:
                        uint32 = 0;
                        (void) memcpy((uchar_t *)&uint32 + 1, from, 3);
                        to += sprintf(to, is_signed ? "%ld" : "%lu",
                            ntohl(uint32));
                        break;

                case 4:
                        (void) memcpy(&uint32, from, 4);
                        to += sprintf(to, is_signed ? "%ld" : "%lu",
                            ntohl(uint32));
                        break;

                case 8:
                        (void) memcpy(&uint64, from, 8);
                        to += sprintf(to, is_signed ? "%lld" : "%llu",
                            ntohll(uint64));
                        break;

                default:
                        *ierrnop = ITAB_BAD_NUMBER;
                        inittab_msg("decode_number: unknown integer size `%d'",
                            size);
                        return (B_FALSE);
                }
                if (n_entries > 0)
                        *to++ = ' ';
        }

        *to = '\0';
        return (B_TRUE);
}

/*
 * encode_number(): encodes a sequence of numbers from ascii into binary;
 *                  number will end up on the wire so it needs to be in nbo
 *
 *   input: uint8_t: the number of "granularity" numbers to encode
 *          uint8_t: the length of each number
 *          boolean_t: whether the numbers should be considered signed
 *          uint8_t: the number of numbers per granularity
 *          const uint8_t *: where to encode the numbers from
 *          char *: where to encode the numbers to
 *          int *: set to extended error code if error occurs.
 *  output: boolean_t: true on successful conversion, false on failure
 */

static boolean_t /* ARGSUSED */
encode_number(uint8_t n_entries, uint8_t size, boolean_t is_signed,
    uint8_t granularity, const char *from, uint8_t *to, int *ierrnop)
{
        uint8_t         i;
        uint16_t        uint16;
        uint32_t        uint32;
        uint64_t        uint64;
        char            *endptr;

        if (granularity != 0) {
                if ((granularity % n_entries) != 0) {
                        *ierrnop = ITAB_BAD_GRAN;
                        inittab_msg("encode_number: number of entries "
                            "not compatible with option granularity");
                        return (B_FALSE);
                }
        }

        for (i = 0; i < n_entries; i++, from++, to += size) {

                /*
                 * totally obscure c factoid: it is legal to pass a
                 * string representing a negative number to strtoul().
                 * in this case, strtoul() will return an unsigned
                 * long that if cast to a long, would represent the
                 * negative number.  we take advantage of this to
                 * cut down on code here.
                 */

                errno = 0;
                switch (size) {

                case 1:
                        *to = strtoul(from, &endptr, 0);
                        if (errno != 0 || from == endptr) {
                                goto error;
                        }
                        break;

                case 2:
                        uint16 = htons(strtoul(from, &endptr, 0));
                        if (errno != 0 || from == endptr) {
                                goto error;
                        }
                        (void) memcpy(to, &uint16, 2);
                        break;

                case 3:
                        uint32 = htonl(strtoul(from, &endptr, 0));
                        if (errno != 0 || from == endptr) {
                                goto error;
                        }
                        (void) memcpy(to, (uchar_t *)&uint32 + 1, 3);
                        break;

                case 4:
                        uint32 = htonl(strtoul(from, &endptr, 0));
                        if (errno != 0 || from == endptr) {
                                goto error;
                        }
                        (void) memcpy(to, &uint32, 4);
                        break;

                case 8:
                        uint64 = htonll(strtoull(from, &endptr, 0));
                        if (errno != 0 || from == endptr) {
                                goto error;
                        }
                        (void) memcpy(to, &uint64, 8);
                        break;

                default:
                        inittab_msg("encode_number: unsupported integer "
                            "size `%d'", size);
                        return (B_FALSE);
                }

                from = strchr(from, ' ');
                if (from == NULL)
                        break;
        }

        return (B_TRUE);

error:
        *ierrnop = ITAB_BAD_NUMBER;
        inittab_msg("encode_number: cannot convert to integer");
        return (B_FALSE);
}

/*
 * inittab_type_to_size(): given an inittab entry, returns size of one entry of
 *                    its type
 *
 *   input: dhcp_symbol_t *: an entry of the given type
 *  output: uint8_t: the size in bytes of an entry of that type
 */

uint8_t
inittab_type_to_size(const dhcp_symbol_t *ie)
{
        switch (ie->ds_type) {

        case DSYM_DUID:
        case DSYM_DOMAIN:
        case DSYM_ASCII:
        case DSYM_OCTET:
        case DSYM_SNUMBER8:
        case DSYM_UNUMBER8:

                return (1);

        case DSYM_SNUMBER16:
        case DSYM_UNUMBER16:

                return (2);

        case DSYM_UNUMBER24:

                return (3);

        case DSYM_SNUMBER32:
        case DSYM_UNUMBER32:
        case DSYM_IP:

                return (4);

        case DSYM_SNUMBER64:
        case DSYM_UNUMBER64:

                return (8);

        case DSYM_NUMBER:

                return (ie->ds_gran);

        case DSYM_IPV6:

                return (sizeof (in6_addr_t));
        }

        return (0);
}

/*
 * itabcode_to_dsymcode(): maps an inittab category code to its dsym
 *                         representation
 *
 *   input: uchar_t: the inittab category code
 *  output: dsym_category_t: the dsym category code
 */

static dsym_category_t
itabcode_to_dsymcode(uchar_t itabcode)
{

        unsigned int    i;

        for (i = 0; i < ITAB_CAT_COUNT; i++)
                if (category_map[i].cme_itabcode == itabcode)
                        return (category_map[i].cme_dsymcode);

        return (DSYM_BAD_CAT);
}

/*
 * category_to_code(): maps a category name to its numeric representation
 *
 *   input: const char *: the category name
 *  output: uchar_t: its internal code (numeric representation)
 */

static uchar_t
category_to_code(const char *category)
{
        unsigned int    i;

        for (i = 0; i < ITAB_CAT_COUNT; i++)
                if (strcasecmp(category_map[i].cme_name, category) == 0)
                        return (category_map[i].cme_itabcode);

        return (0);
}

/*
 * our internal table of DHCP option values, used by inittab_verify()
 */
static dhcp_symbol_t inittab_table[] =
{
{ DSYM_INTERNAL,        1024,   "Hostname",     DSYM_BOOL,      0,      0 },
{ DSYM_INTERNAL,        1025,   "LeaseNeg",     DSYM_BOOL,      0,      0 },
{ DSYM_INTERNAL,        1026,   "EchoVC",       DSYM_BOOL,      0,      0 },
{ DSYM_INTERNAL,        1027,   "BootPath",     DSYM_ASCII,     1,      128 },
{ DSYM_FIELD,           0,      "Opcode",       DSYM_UNUMBER8,  1,      1 },
{ DSYM_FIELD,           1,      "Htype",        DSYM_UNUMBER8,  1,      1 },
{ DSYM_FIELD,           2,      "HLen",         DSYM_UNUMBER8,  1,      1 },
{ DSYM_FIELD,           3,      "Hops",         DSYM_UNUMBER8,  1,      1 },
{ DSYM_FIELD,           4,      "Xid",          DSYM_UNUMBER32, 1,      1 },
{ DSYM_FIELD,           8,      "Secs",         DSYM_UNUMBER16, 1,      1 },
{ DSYM_FIELD,           10,     "Flags",        DSYM_OCTET,     1,      2 },
{ DSYM_FIELD,           12,     "Ciaddr",       DSYM_IP,        1,      1 },
{ DSYM_FIELD,           16,     "Yiaddr",       DSYM_IP,        1,      1 },
{ DSYM_FIELD,           20,     "BootSrvA",     DSYM_IP,        1,      1 },
{ DSYM_FIELD,           24,     "Giaddr",       DSYM_IP,        1,      1 },
{ DSYM_FIELD,           28,     "Chaddr",       DSYM_OCTET,     1,      16 },
{ DSYM_FIELD,           44,     "BootSrvN",     DSYM_ASCII,     1,      64 },
{ DSYM_FIELD,           108,    "BootFile",     DSYM_ASCII,     1,      128 },
{ DSYM_FIELD,           236,    "Magic",        DSYM_OCTET,     1,      4 },
{ DSYM_FIELD,           240,    "Options",      DSYM_OCTET,     1,      60 },
{ DSYM_STANDARD,        1,      "Subnet",       DSYM_IP,        1,      1 },
{ DSYM_STANDARD,        2,      "UTCoffst",     DSYM_SNUMBER32, 1,      1 },
{ DSYM_STANDARD,        3,      "Router",       DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        4,      "Timeserv",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        5,      "IEN116ns",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        6,      "DNSserv",      DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        7,      "Logserv",      DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        8,      "Cookie",       DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        9,      "Lprserv",      DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        10,     "Impress",      DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        11,     "Resource",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        12,     "Hostname",     DSYM_ASCII,     1,      0 },
{ DSYM_STANDARD,        13,     "Bootsize",     DSYM_UNUMBER16, 1,      1 },
{ DSYM_STANDARD,        14,     "Dumpfile",     DSYM_ASCII,     1,      0 },
{ DSYM_STANDARD,        15,     "DNSdmain",     DSYM_ASCII,     1,      0 },
{ DSYM_STANDARD,        16,     "Swapserv",     DSYM_IP,        1,      1 },
{ DSYM_STANDARD,        17,     "Rootpath",     DSYM_ASCII,     1,      0 },
{ DSYM_STANDARD,        18,     "ExtendP",      DSYM_ASCII,     1,      0 },
{ DSYM_STANDARD,        19,     "IpFwdF",       DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        20,     "NLrouteF",     DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        21,     "PFilter",      DSYM_IP,        2,      0 },
{ DSYM_STANDARD,        22,     "MaxIpSiz",     DSYM_UNUMBER16, 1,      1 },
{ DSYM_STANDARD,        23,     "IpTTL",        DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        24,     "PathTO",       DSYM_UNUMBER32, 1,      1 },
{ DSYM_STANDARD,        25,     "PathTbl",      DSYM_UNUMBER16, 1,      0 },
{ DSYM_STANDARD,        26,     "MTU",          DSYM_UNUMBER16, 1,      1 },
{ DSYM_STANDARD,        27,     "SameMtuF",     DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        28,     "Broadcst",     DSYM_IP,        1,      1 },
{ DSYM_STANDARD,        29,     "MaskDscF",     DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        30,     "MaskSupF",     DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        31,     "RDiscvyF",     DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        32,     "RSolictS",     DSYM_IP,        1,      1 },
{ DSYM_STANDARD,        33,     "StaticRt",     DSYM_IP,        2,      0 },
{ DSYM_STANDARD,        34,     "TrailerF",     DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        35,     "ArpTimeO",     DSYM_UNUMBER32, 1,      1 },
{ DSYM_STANDARD,        36,     "EthEncap",     DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        37,     "TcpTTL",       DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        38,     "TcpKaInt",     DSYM_UNUMBER32, 1,      1 },
{ DSYM_STANDARD,        39,     "TcpKaGbF",     DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        40,     "NISdmain",     DSYM_ASCII,     1,      0 },
{ DSYM_STANDARD,        41,     "NISservs",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        42,     "NTPservs",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        43,     "Vendor",       DSYM_OCTET,     1,      0 },
{ DSYM_STANDARD,        44,     "NetBNms",      DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        45,     "NetBDsts",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        46,     "NetBNdT",      DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        47,     "NetBScop",     DSYM_ASCII,     1,      0 },
{ DSYM_STANDARD,        48,     "XFontSrv",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        49,     "XDispMgr",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        50,     "ReqIP",        DSYM_IP,        1,      1 },
{ DSYM_STANDARD,        51,     "LeaseTim",     DSYM_UNUMBER32, 1,      1 },
{ DSYM_STANDARD,        52,     "OptOvrld",     DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        53,     "DHCPType",     DSYM_UNUMBER8,  1,      1 },
{ DSYM_STANDARD,        54,     "ServerID",     DSYM_IP,        1,      1 },
{ DSYM_STANDARD,        55,     "ReqList",      DSYM_OCTET,     1,      0 },
{ DSYM_STANDARD,        56,     "Message",      DSYM_ASCII,     1,      0 },
{ DSYM_STANDARD,        57,     "DHCP_MTU",     DSYM_UNUMBER16, 1,      1 },
{ DSYM_STANDARD,        58,     "T1Time",       DSYM_UNUMBER32, 1,      1 },
{ DSYM_STANDARD,        59,     "T2Time",       DSYM_UNUMBER32, 1,      1 },
{ DSYM_STANDARD,        60,     "ClassID",      DSYM_ASCII,     1,      0 },
{ DSYM_STANDARD,        61,     "ClientID",     DSYM_OCTET,     1,      0 },
{ DSYM_STANDARD,        62,     "NW_dmain",     DSYM_ASCII,     1,      0 },
{ DSYM_STANDARD,        63,     "NWIPOpts",     DSYM_OCTET,     1,      128 },
{ DSYM_STANDARD,        64,     "NIS+dom",      DSYM_ASCII,     1,      0 },
{ DSYM_STANDARD,        65,     "NIS+serv",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        66,     "TFTPsrvN",     DSYM_ASCII,     1,      64 },
{ DSYM_STANDARD,        67,     "OptBootF",     DSYM_ASCII,     1,      128 },
{ DSYM_STANDARD,        68,     "MblIPAgt",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        69,     "SMTPserv",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        70,     "POP3serv",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        71,     "NNTPserv",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        72,     "WWWservs",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        73,     "Fingersv",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        74,     "IRCservs",     DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        75,     "STservs",      DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        76,     "STDAservs",    DSYM_IP,        1,      0 },
{ DSYM_STANDARD,        77,     "UserClas",     DSYM_ASCII,     1,      0 },
{ DSYM_STANDARD,        78,     "SLP_DA",       DSYM_OCTET,     1,      0 },
{ DSYM_STANDARD,        79,     "SLP_SS",       DSYM_OCTET,     1,      0 },
{ DSYM_STANDARD,        82,     "AgentOpt",     DSYM_OCTET,     1,      0 },
{ DSYM_STANDARD,        89,     "FQDN",         DSYM_OCTET,     1,      0 },
{ 0,                    0,      "",             0,              0,      0 }
};