/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * From "tsol_tndb_parser.c     7.24    01/09/05 SMI; TSOL 2.x"
 *
 * These functions parse entries in the "thrhdb" (remote host database) file.
 * Each entry in the file has two fields, separated by a colon.  The first
 * field is the IP host or network address.  The second is the name of the
 * template to use (from tnrhtp).
 *
 * In order to help preserve sanity, we do not allow more than one unescaped
 * colon in a line.
 */

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <strings.h>
#include <libtsnet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <inet/ip.h>
#include <arpa/inet.h>
#include <nss.h>
#include <errno.h>

/*
 * This routine deals with old pre-CIDR subnet address specifications.  In the
 * bad old days, a subnet was represented as:
 *
 *      Expression      Implied Prefix
 *      10.1.1.0        /24
 *      10.1.0.0        /16
 *      10.0.0.0        /8
 *      0.0.0.0         /0
 */
static int
get_classful_prefix(in_addr_t addr)
{
        int bits;

        if (addr == 0)
                return (0);
        addr = ntohl(addr);
        for (bits = IP_ABITS; bits > 0 && (addr & 0xFF) == 0; bits -= 8)
                addr >>= 8;

        return (bits);
}

/*
 * This routine deals with old pre-CIDR network address specifications.  In the
 * bad old days, a network was represented as:
 *
 *      Expression      Implied Prefix
 *      10.1.1          /24
 *      10.1            /16
 *      10              /8
 *
 * This routine must compute the mask and left-align the address.
 */
static int
get_network_prefix(in_addr_t *addrp)
{
        int bits;
        in_addr_t addr;

        addr = ntohl(*addrp);
        for (bits = IP_ABITS; bits > 0 && addr < 0x01000000; bits -= 8)
                addr <<= 8;
        *addrp = htonl(addr);

        return (bits);
}

static boolean_t
parse_address(tsol_rhent_t *rh, const char *addrbuf)
{
        int upper_lim;
        int len;
        const uchar_t *aptr;

        if (strchr(addrbuf, ':') == NULL) {
                /* IPv4 address */
                rh->rh_address.ta_family = AF_INET;
                if (inet_pton(AF_INET, addrbuf,
                    &rh->rh_address.ta_addr_v4) > 0) {
                        if (rh->rh_prefix == -1)
                                rh->rh_prefix = get_classful_prefix(rh->
                                    rh_address.ta_addr_v4.s_addr);
                } else if ((rh->rh_address.ta_addr_v4.s_addr =
                    inet_network(addrbuf)) != (in_addr_t)-1) {
                        len = get_network_prefix(&rh->rh_address.ta_addr_v4.
                            s_addr);
                        if (rh->rh_prefix == -1)
                                rh->rh_prefix = len;
                } else {
                        return (B_FALSE);
                }
                upper_lim = IP_ABITS;
                aptr = (const uchar_t *)&rh->rh_address.ta_addr_v4;
        } else {
                /* IPv6 address */
                rh->rh_address.ta_family = AF_INET6;
                if (inet_pton(AF_INET6, addrbuf,
                    &rh->rh_address.ta_addr_v6) <= 0)
                        return (B_FALSE);
                if (rh->rh_prefix == -1)
                        rh->rh_prefix = IPV6_ABITS;
                upper_lim = IPV6_ABITS;
                aptr = (const uchar_t *)&rh->rh_address.ta_addr_v6;
        }

        if (rh->rh_prefix < 0 || rh->rh_prefix > upper_lim)
                return (B_FALSE);

        /*
         * Verify that there are no bits set in the "host" portion of the
         * IP address.
         */
        len = rh->rh_prefix;
        aptr += len / 8;
        if ((len & 7) != 0) {
                if ((*aptr++ & (0xff >> (len & 7))) != 0)
                        return (B_FALSE);
                len = (len + 7) & ~7;
        }
        while (len < upper_lim) {
                if (*aptr++ != 0)
                        return (B_FALSE);
                len += 8;
        }

        return (B_TRUE);
}

tsol_rhent_t *
rhstr_to_ent(tsol_rhstr_t *rhstrp, int *errp, char **errstrp)
{
        int             len;
        int             err = 0;
        char            *cp, *cp2, *errstr;
        char            *address = rhstrp->address;
        char            *template = rhstrp->template;
        char            addrbuf[1024];
        tsol_rhent_t    *rhentp = NULL;

        /*
         * The user can specify NULL pointers for these.  Make sure that we
         * don't have to deal with checking for NULL everywhere by just
         * pointing to our own variables if the user gives NULL.
         */
        if (errp == NULL)
                errp = &err;
        if (errstrp == NULL)
                errstrp = &errstr;
        /* The default, unless we find a more specific error locus. */
        *errstrp = address;

        if (address == NULL || *address == '#' || *address == '\n') {
                *errp = LTSNET_EMPTY;
                if (template && *template != '\0' && *template != '#' &&
                    *template != '\n')
                        *errstrp = template;
                else if (address == NULL)
                        *errstrp = "   ";
                goto err_ret;
        }
        if (*address == '\0') {
                *errp = LTSNET_NO_ADDR;
                if (template && *template != '\0' && *template != '#' &&
                    *template != '\n')
                        *errstrp = template;
                goto err_ret;
        }
        if (template == NULL || *template == '#' || *template == '\n' ||
            *template == '\0') {
                *errp = LTSNET_NO_HOSTTYPE;
                goto err_ret;
        }
        if ((rhentp = calloc(1, sizeof (*rhentp))) == NULL) {
                *errp = LTSNET_SYSERR;
                return (NULL);
        }
        if ((cp = strrchr(address, '/')) != NULL) {
                len = cp - address;
                if (len >= sizeof (addrbuf)) {
                        *errp = LTSNET_ILL_ADDR;
                        goto err_ret;
                }
                (void) memset(addrbuf, '\0', sizeof (addrbuf));
                (void) memcpy(addrbuf, address, len);
                cp++;
                errno = 0;
                rhentp->rh_prefix = strtol(cp, &cp2, 0);
                if (errno != 0) {
                        *errp = LTSNET_SYSERR;
                        *errstrp = cp2;
                        goto err_ret;
                }
                if ((isdigit(*cp) == 0)) {
                        *errp = LTSNET_ILL_ADDR;
                        *errstrp = address;
                        goto err_ret;
                }
        } else {
                rhentp->rh_prefix = -1;
                (void) strlcpy(addrbuf, address, sizeof (addrbuf));
        }
        if (strlcpy(rhentp->rh_template, template,
            sizeof (rhentp->rh_template)) >= sizeof (rhentp->rh_template)) {
                *errstrp = template;
                *errp = LTSNET_ILL_NAME;
                goto err_ret;
        }
        if (!parse_address(rhentp, addrbuf)) {
                *errp = LTSNET_ILL_ADDR;
                *errstrp = address;
                goto err_ret;
        }

#ifdef  DEBUG
        (void) fprintf(stdout, "rhstr_to_ent: %s:%s\n",
            address, rhentp->rh_template);
#endif  /* DEBUG */

        return (rhentp);

err_ret:
        err = errno;
        tsol_freerhent(rhentp);
        errno = err;
#ifdef  DEBUG
        (void) fprintf(stderr, "\nrhstr_to_ent: %s: %s\n",
            *errstrp, (char *)tsol_strerror(*errp, errno));
#endif  /* DEBUG */

        return (NULL);
}

void
tsol_freerhent(tsol_rhent_t *rh)
{
        if (rh != NULL)
                free(rh);
}