/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 1999-2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright (c) 2016 by Delphix. All rights reserved.
 */

/*
 * Subroutines that implement the bootparam services.
 */

#include <rpcsvc/bootparam_prot.h>
#include <netdb.h>
#include <nlist.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <nsswitch.h>
#include <sys/types.h>
#include <sys/file.h>
#include <sys/socket.h>
#define KERNEL          /* to get RTHASHSIZ */
#include <sys/stream.h>
#include <net/route.h>
#undef  KERNEL
#include <net/if.h>                     /* for structs ifnet and ifaddr */
#include <netinet/in.h>
#include <netinet/in_var.h>             /* for struct in_ifaddr */
#include <arpa/inet.h>

#include "bootparam_private.h"

#define LINESIZE        1024

extern int getdomainname(char *, int);
extern int bootparams_getbyname(char *, char *, int);

static char *wildcard = "*";
static char domainkey[] = "domain=";
static void getf_printres(bp_getfile_res *);
static void copydomain(char *, char *, int);

/*
 * Whoami turns a client address into a client name
 * and suggested route machine.
 */
/*ARGSUSED1*/
bp_whoami_res *
bootparamproc_whoami_1(bp_whoami_arg *argp, CLIENT *cl)
{
        static bp_whoami_res res;
        struct in_addr clnt_addr;
        struct in_addr route_addr;
        struct hostent *hp;
        static char clnt_entry[LINESIZE];
        static char domain[MAX_MACHINE_NAME];
        char *cp;

        if (argp->client_address.address_type != IP_ADDR_TYPE) {
                if (debug) {
                        msgout("Whoami failed: unknown address type %d",
                                argp->client_address.address_type);
                }
                return (NULL);
        }
        (void) memcpy(&clnt_addr, &argp->client_address.bp_address_u.ip_addr,
            sizeof (clnt_addr));
        hp = gethostbyaddr((char *)&clnt_addr, sizeof (clnt_addr), AF_INET);
        if (hp == NULL) {
                if (debug) {
                        msgout("Whoami failed: gethostbyaddr for %s.",
                                inet_ntoa(clnt_addr));
                }
                return (NULL);
        }

        /*
         * We only answer requests from clients listed in the database.
         */
        if ((bootparams_getbyname(hp->h_name, clnt_entry,
            sizeof (clnt_entry)) != __NSW_SUCCESS) &&
            (bootparams_getbyname(wildcard, clnt_entry,
            sizeof (clnt_entry)) != __NSW_SUCCESS))
                return (NULL);

        res.client_name = hp->h_name;

        /*
         * The algorithm for determining the client's domain name is:
         *      1) look for "domain=" in the client's bootparams line.
         *         If found, use its value.
         *      2) look for a "domain=" entry in the wildcard bootparams
         *         line (if any).  If found, use its value.  Otherwise,
         *      3) return the domain name of the server answering the
         *         request.
         */
        if (cp = strstr(clnt_entry, domainkey)) {
                copydomain(cp + sizeof (domainkey) - 1, domain,
                    sizeof (domain));
        } else {
                /* "domain=" not found - try for wildcard */
                if ((bootparams_getbyname(wildcard, clnt_entry,
                        sizeof (clnt_entry)) == __NSW_SUCCESS) &&
                        (cp = strstr(clnt_entry, domainkey))) {
                        copydomain(cp + sizeof (domainkey) - 1, domain,
                            sizeof (domain));
                } else {
                        (void) getdomainname(domain, sizeof (domain));
                }
        }
        res.domain_name = domain;

        res.router_address.address_type = IP_ADDR_TYPE;
        route_addr.s_addr = get_ip_route(clnt_addr);
        (void) memcpy(&res.router_address.bp_address_u.ip_addr,
            &route_addr,
            sizeof (res.router_address.bp_address_u.ip_addr));

        if (debug) {
                struct in_addr  in;

                (void) memcpy(&in.s_addr,
                    &res.router_address.bp_address_u.ip_addr,
                    sizeof (in.s_addr));
                msgout("Whoami returning name = %s, router address = %s",
                    res.client_name,
                    inet_ntoa(in));
        }
        return (&res);
}

/*
 * Getfile gets the client name and the key and returns its server
 * and the pathname for that key.
 */
/*ARGSUSED1*/
bp_getfile_res *
bootparamproc_getfile_1(bp_getfile_arg *argp, CLIENT *cl)
{
        static bp_getfile_res res;
        static char clnt_entry[LINESIZE];
        struct hostent *hp;
        char *cp;
        char filekey[LINESIZE];
        char *server_hostname;
        char *path_on_server;
        int do_wildcard = 0;
        static char *zero_len_string = "";

        /*
         * The bootparams_getbyname() library function looks up a
         * "client entry" using using the client's hostname as the
         * key.  A client entry consists of a string of "file entries"
         * separated by white space.  Each file entry is of the form:
         *
         *      file_key=server_hostname:path_on_server
         *
         * In the getfile RPC call, the client gives us its hostname
         * and a file_key.  We lookup its client entry, then locate a
         * file entry matching that file_key.  We then parse out the
         * server_hostname and path_on_server from the file entry, map
         * the server_hostname to an IP address, and return both the
         * IP address and path_on_server back to the client.
         */

        /* make the client's file key int a string we can use for matching */
        (void) strncpy(filekey, argp->file_id, sizeof (filekey) - 2);
        filekey[sizeof (filekey) - 2] = '\0';
        (void) strcat(filekey, "=");

        if (bootparams_getbyname(argp->client_name, clnt_entry,
            sizeof (clnt_entry)) == __NSW_SUCCESS) {
                /* locate the file_key in the client's entry */
                cp = strstr(clnt_entry, filekey);
                if (cp == NULL)
                        do_wildcard++;

        } else
                do_wildcard++;

        if (do_wildcard) {
                if (bootparams_getbyname(wildcard, clnt_entry,
                    sizeof (clnt_entry)) != __NSW_SUCCESS)
                        return (NULL);

                /* locate the file_key in the client's entry */
                cp = strstr(clnt_entry, filekey);
                if (cp == NULL)
                        return (NULL);
        }

        /* locate the "data" part of file entry (r.h.s. of "=") */
        cp = strchr(cp, '=');
        if (cp == NULL)
                return (NULL);
        cp++;
        if (*cp == '\0')
                return (NULL);
        server_hostname = cp;

        /* null-terminate server_hostname and parse path_on_server */
        cp = strchr(server_hostname, ':');
        if (cp == NULL)
                return (NULL);
        *cp = '\0';
        cp++;
        /* strtok() will null-terminate path_on_server */
        path_on_server = strtok(cp, "\t\n ");
        if (path_on_server == NULL)
                path_on_server = zero_len_string;

        res.server_name = server_hostname;
        res.server_path = path_on_server;
        if (*res.server_name == 0) {
                res.server_address.address_type = IP_ADDR_TYPE;
                (void) memset(&res.server_address.bp_address_u.ip_addr, 0,
                    sizeof (res.server_address.bp_address_u.ip_addr));
        } else {
                in_addr_t addr;

                if ((hp = gethostbyname(server_hostname)) != NULL) {
                        addr = find_best_server_int(hp->h_addr_list,
                            argp->client_name);
                } else {
                        addr = inet_addr(server_hostname);
                        if (addr == INADDR_BROADCAST) {
                                if (debug) {
                                        msgout("getfile_1: gethostbyname(%s) "
                                            "failed", res.server_name);
                                }
                                return (NULL);
                        }
                }
                res.server_address.address_type = IP_ADDR_TYPE;
                (void) memcpy(&res.server_address.bp_address_u.ip_addr,
                    &addr, sizeof (res.server_address.bp_address_u.ip_addr));
        }
        if (debug) {
                getf_printres(&res);
        }
        return (&res);
}

void
getf_printres(bp_getfile_res *res)
{
        struct in_addr  in;

        (void) memcpy(&in.s_addr, &res->server_address.bp_address_u.ip_addr,
            sizeof (in.s_addr));
        msgout("getfile_1: file is \"%s\" %s \"%s\"",
            res->server_name,
            inet_ntoa(in),
            res->server_path);
}

/*
 * Used when we've found a "domain=" key, this function copies characters
 * from source to target until we come upon either a NULL or whitespace is
 * found in the source string, or we run out of room in the target.
 *
 */
void
copydomain(char *source, char *target, int len)
{
        int n;                  /* number of characters copies */;

        len--;                  /* leave room for terminating '\0' */
        if (source)
                for (n = 0; *source != '\0' && n < len; n++)
                        if (isspace((int)*source))
                                break;
                        else
                                *target++ = *source++;

        *target = '\0';
}