/*	$NetBSD: bootparamd.c,v 1.48 2020/04/22 23:47:02 joerg Exp $	*/

/*
 * This code is not copyright, and is placed in the public domain.
 * Feel free to use and modify. Please send modifications and/or
 * suggestions + bug fixes to Klas Heggemann <klas@nada.kth.se>
 *
 * Various small changes by Theo de Raadt <deraadt@fsa.ca>
 * Parser rewritten (adding YP support) by Roland McGrath <roland@frob.com>
 */

#include <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: bootparamd.c,v 1.48 2020/04/22 23:47:02 joerg Exp $");
#endif

#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/socket.h>

#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <err.h>
#include <fnmatch.h>
#include <netdb.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <util.h>
#include <ifaddrs.h>

#include <net/if.h>

#include <netinet/in.h>
#include <arpa/inet.h>

#include <rpc/rpc.h>
#include <rpc/pmap_clnt.h>
#include <rpcsvc/bootparam_prot.h>
#ifdef YP
#include <rpcsvc/ypclnt.h>
#endif

#include "pathnames.h"

#define MAXLEN 800

static char hostname[MAX_MACHINE_NAME];
static char askname[MAX_MACHINE_NAME];
static char domain_name[MAX_MACHINE_NAME];

extern void bootparamprog_1(struct svc_req *, SVCXPRT *);

extern int	_rpcsvcdirty;
extern int	_rpcpmstart;
int     debug = 0;
int     dolog = 0;
struct in_addr route_addr;
struct sockaddr_in my_addr;
const char *bootpfile = _PATH_BOOTPARAMS;
char   *iface = NULL;

static int	lookup_bootparam(char *, char *, char *, char **, char **);
__dead static void	usage(void);
static int get_localaddr(const char *, struct sockaddr_in *);


/*
 * ever familiar
 */
int
main(int argc, char  *argv[])
{
	SVCXPRT *transp;
	struct hostent *he;
	struct stat buf;
	int    c;

	while ((c = getopt(argc, argv, "di:sr:f:")) != -1)
		switch (c) {
		case 'd':
			debug = 1;
			break;
		case 'i':
			iface = optarg;
			break;
		case 'r':
			if (isdigit((unsigned char)*optarg)) {
				if (inet_aton(optarg, &route_addr) != 0)
					break;
			}
			he = gethostbyname(optarg);
			if (he == 0) {
				warnx("no such host: %s", optarg);
				usage();
			}
			memmove(&route_addr.s_addr, he->h_addr, he->h_length);
			break;
		case 'f':
			bootpfile = optarg;
			break;
		case 's':
			dolog = 1;
#ifndef LOG_DAEMON
			openlog("rpc.bootparamd", 0, 0);
#else
			openlog("rpc.bootparamd", 0, LOG_DAEMON);
			setlogmask(LOG_UPTO(LOG_NOTICE));
#endif
			break;
		default:
			usage();
		}

	if (stat(bootpfile, &buf))
		err(1, "%s", bootpfile);

	if (route_addr.s_addr == 0) {
		if (get_localaddr(NULL, &my_addr) != 0)
			errx(1, "router address not found");
		route_addr.s_addr = my_addr.sin_addr.s_addr;
	}
	if (!debug) {
		if (daemon(0, 0))
			err(1, "can't detach from terminal");
	}
	pidfile(NULL);

	(void) pmap_unset(BOOTPARAMPROG, BOOTPARAMVERS);

	transp = svcudp_create(RPC_ANYSOCK);
	if (transp == NULL)
		errx(1, "can't create udp service");

	if (!svc_register(transp, BOOTPARAMPROG, BOOTPARAMVERS, bootparamprog_1,
	    IPPROTO_UDP))
/*
 * Do NOT change the "%u" in the format string below to "%lu". If your
 * build fails update the "rpcgen" program and use "make cleandir" and
 * "make includes" in "src/lib/librpcsvc" afterwards.
 */
		errx(1, "unable to register BOOTPARAMPROG version %u, udp",
		    BOOTPARAMVERS);

	svc_run();
	errx(1, "svc_run returned");
}

bp_whoami_res *
bootparamproc_whoami_1_svc(bp_whoami_arg *whoami, struct svc_req *rqstp)
{
	static bp_whoami_res res;
	struct hostent *he;
	struct in_addr haddr;
	int e;

	if (debug)
		warnx("whoami got question for %d.%d.%d.%d",
		    255 & whoami->client_address.bp_address_u.ip_addr.net,
		    255 & whoami->client_address.bp_address_u.ip_addr.host,
		    255 & whoami->client_address.bp_address_u.ip_addr.lh,
		    255 & whoami->client_address.bp_address_u.ip_addr.impno);
	if (dolog)
		syslog(LOG_NOTICE, "whoami got question for %d.%d.%d.%d",
		    255 & whoami->client_address.bp_address_u.ip_addr.net,
		    255 & whoami->client_address.bp_address_u.ip_addr.host,
		    255 & whoami->client_address.bp_address_u.ip_addr.lh,
		    255 & whoami->client_address.bp_address_u.ip_addr.impno);

	memmove((char *) &haddr,
	    (char *) &whoami->client_address.bp_address_u.ip_addr,
	    sizeof(haddr));
	he = gethostbyaddr((char *) &haddr, sizeof(haddr), AF_INET);
	if (he) {
		(void)strlcpy(askname, he->h_name, sizeof(askname));
	} else {
		(void)strlcpy(askname, inet_ntoa(haddr), sizeof(askname));
	}

	if (debug)
		warnx("This is host %s", askname);
	if (dolog)
		syslog(LOG_NOTICE, "This is host %s", askname);

	if ((e = lookup_bootparam(askname, hostname, NULL, NULL, NULL)) == 0) {
		res.client_name = hostname;
		getdomainname(domain_name, MAX_MACHINE_NAME);
		res.domain_name = domain_name;

		if (res.router_address.address_type != IP_ADDR_TYPE) {
			res.router_address.address_type = IP_ADDR_TYPE;
			memmove(&res.router_address.bp_address_u.ip_addr,
			    &route_addr.s_addr,4);
		}
		if (debug)
			warnx("Returning %s   %s    %d.%d.%d.%d",
			    res.client_name, res.domain_name,
			    255 & res.router_address.bp_address_u.ip_addr.net,
			    255 & res.router_address.bp_address_u.ip_addr.host,
			    255 & res.router_address.bp_address_u.ip_addr.lh,
			    255 &res.router_address.bp_address_u.ip_addr.impno);
		if (dolog)
			syslog(LOG_NOTICE, "Returning %s   %s    %d.%d.%d.%d",
			    res.client_name, res.domain_name,
			    255 & res.router_address.bp_address_u.ip_addr.net,
			    255 & res.router_address.bp_address_u.ip_addr.host,
			    255 & res.router_address.bp_address_u.ip_addr.lh,
			    255 &res.router_address.bp_address_u.ip_addr.impno);

		return (&res);
	}
	errno = e;
	if (debug)
		warn("whoami failed");
	if (dolog)
		syslog(LOG_NOTICE, "whoami failed %m");
	return (NULL);
}


bp_getfile_res *
bootparamproc_getfile_1_svc(bp_getfile_arg *getfile, struct svc_req *rqstp)
{
	static bp_getfile_res res;
	struct hostent *he;
	int     error;

	if (debug)
		warnx("getfile got question for \"%s\" and file \"%s\"",
		    getfile->client_name, getfile->file_id);

	if (dolog)
		syslog(LOG_NOTICE,
		    "getfile got question for \"%s\" and file \"%s\"",
		    getfile->client_name, getfile->file_id);

	he = NULL;
	he = gethostbyname(getfile->client_name);
	if (!he) {
		if (debug)
			warnx("getfile can't resolve client %s",
			    getfile->client_name);
		if (dolog)
			syslog(LOG_NOTICE, "getfile can't resolve client %s",
			    getfile->client_name);
		return (NULL);
	}

	(void)strlcpy(askname, he->h_name, sizeof(askname));
	error = lookup_bootparam(askname, NULL, getfile->file_id,
	    &res.server_name, &res.server_path);
	if (error == 0) {
		he = gethostbyname(res.server_name);
		if (!he) {
			if (debug)
				warnx("getfile can't resolve server %s for %s",
			    res.server_name, getfile->client_name);
		if (dolog)
			syslog(LOG_NOTICE,
			    "getfile can't resolve server %s for %s",
			    res.server_name, getfile->client_name);
		return (NULL);

		}
		memmove(&res.server_address.bp_address_u.ip_addr,
		    he->h_addr, 4);
		res.server_address.address_type = IP_ADDR_TYPE;
	} else if (error == ENOENT && !strcmp(getfile->file_id, "dump")) {
		/* Special for dump, answer with null strings. */
		res.server_name[0] = '\0';
		res.server_path[0] = '\0';
		memset(&res.server_address.bp_address_u.ip_addr, 0, 4);
	} else {
		if (debug)
			warnx("getfile lookup failed for %s",
			    getfile->client_name);
		if (dolog)
			syslog(LOG_NOTICE,
			    "getfile lookup failed for %s",
			    getfile->client_name);
		return (NULL);
	}

	if (debug)
		warnx(
		    "returning server:%s path:%s address: %d.%d.%d.%d",
		    res.server_name, res.server_path,
		    255 & res.server_address.bp_address_u.ip_addr.net,
		    255 & res.server_address.bp_address_u.ip_addr.host,
		    255 & res.server_address.bp_address_u.ip_addr.lh,
		    255 & res.server_address.bp_address_u.ip_addr.impno);
	if (dolog)
		syslog(LOG_NOTICE,
		    "returning server:%s path:%s address: %d.%d.%d.%d",
		    res.server_name, res.server_path,
		    255 & res.server_address.bp_address_u.ip_addr.net,
		    255 & res.server_address.bp_address_u.ip_addr.host,
		    255 & res.server_address.bp_address_u.ip_addr.lh,
		    255 & res.server_address.bp_address_u.ip_addr.impno);
	return (&res);
}


static int
lookup_bootparam(char *client, char *client_canonical, char *id,
    char **server, char **path)
{
	FILE   *f = fopen(bootpfile, "r");
#ifdef YP
	static char *ypbuf = NULL;
	static int ypbuflen = 0;
#endif
	static char buf[BUFSIZ];
	char   *canon = NULL, *bp, *word = NULL;
	size_t  idlen = id == NULL ? 0 : strlen(id);
	int     contin = 0;
	int     found = 0;

	if (f == NULL)
		return EINVAL;	/* ? */

	while (fgets(buf, sizeof buf, f)) {
		int     wascontin = contin;
		contin = buf[strlen(buf) - 2] == '\\';
		bp = buf + strspn(buf, " \t\n");

		switch (wascontin) {
		case -1:
			/* Continuation of uninteresting line */
			contin *= -1;
			continue;
		case 0:
			/* New line */
			contin *= -1;
			if (*bp == '#')
				continue;
			if ((word = strsep(&bp, " \t\n")) == NULL)
				continue;
#ifdef YP
			/* A + in the file means try YP now */
			if (!strcmp(word, "+")) {
				char   *ypdom;

				if (yp_get_default_domain(&ypdom) ||
				    yp_match(ypdom, "bootparams", client,
					strlen(client), &ypbuf, &ypbuflen))
					continue;
				bp = ypbuf;
				word = client;
				contin *= -1;
				break;
			}
#endif
			if (debug)
				warnx("match %s with %s", word, client);

#define	HASGLOB(str) \
	(strchr(str, '*') != NULL || \
	 strchr(str, '?') != NULL || \
	 strchr(str, '[') != NULL || \
	 strchr(str, ']') != NULL)

			/* See if this line's client is the one we are
			 * looking for */
			if (fnmatch(word, client, FNM_CASEFOLD) == 0) {
				/*
				 * Match.  The token may be globbed, we
				 * can't just return that as the canonical
				 * name.  Check to see if the token has any
				 * globbing characters in it (*, ?, [, ]).
				 * If so, just return the name we already
				 * have.  Otherwise, return the token.
				 */
				if (HASGLOB(word))
					canon = client;
				else
					canon = word;
			} else {
				struct hostent *hp;
				/*
				 * If it didn't match, try getting the
				 * canonical host name of the client
				 * on this line, if it's not a glob,
				 * and comparing it to the client we
				 * are looking up.
				 */
				if (HASGLOB(word)) {
					if (debug)
						warnx("Skipping non-match: %s",
						    word);
					continue;
				}
				if ((hp = gethostbyname(word)) == NULL) {
					if (debug)
						warnx(
					    "Unknown bootparams host %s",
					    word);
					if (dolog)
						syslog(LOG_NOTICE,
					    "Unknown bootparams host %s",
					    word);
					continue;
				}
				if (strcasecmp(hp->h_name, client) != 0)
					continue;
				canon = hp->h_name;
			}

#undef HASGLOB

			contin *= -1;
			break;
		case 1:
			/* Continued line we want to parse below */
			break;
		}

		assert(canon != NULL);
		if (client_canonical)
			strncpy(client_canonical, canon, MAX_MACHINE_NAME);

		/* We have found a line for CLIENT */
		if (id == NULL) {
			(void) fclose(f);
			return 0;
		}

		/* Look for a value for the parameter named by ID */
		while ((word = strsep(&bp, " \t\n")) != NULL) {
			if (!strncmp(word, id, idlen) && word[idlen] == '=') {
				/* We have found the entry we want */
				*server = &word[idlen + 1];
				*path = strchr(*server, ':');
				if (*path == NULL)
					/* Malformed entry */
					continue;
				*(*path)++ = '\0';
				(void) fclose(f);
				return 0;
			}
		}

		found = 1;
	}

	(void) fclose(f);
	return found ? ENOENT : EPERM;
}

static void
usage(void)
{
	fprintf(stderr,
	    "usage: %s [-ds] [-i interface] [-r router] [-f bootparamsfile]\n",
	    getprogname());
	exit(1);
}

static int
get_localaddr(const char *ifname, struct sockaddr_in *sin)
{
	struct ifaddrs *ifap, *ifa;

	if (getifaddrs(&ifap) != 0)
		return -1;

	for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
		if (ifname && strcmp(ifname, ifa->ifa_name) != 0)
			continue;
		if (ifa->ifa_addr->sa_family != AF_INET)
			continue;
		if (ifa->ifa_addr->sa_len != sizeof(*sin))
			continue;

		/* no loopback please */
#ifdef IFF_LOOPBACK
		if (ifa->ifa_flags & IFF_LOOPBACK)
			continue;
#else
		if (strncmp(ifa->ifa_name, "lo", 2) == 0 &&
		    (isdigit(ifa->ifa_name[2]) || ifa->ifa_name[2] == '\0'))
			continue;
#endif

		if (!iface || strcmp(ifa->ifa_name, iface) == 0)
			;
		else
			continue;

		/* candidate found */
		memcpy(sin, ifa->ifa_addr, ifa->ifa_addr->sa_len);
		freeifaddrs(ifap);
		return 0;
	}

	/* no candidate */
	freeifaddrs(ifap);
	return -1;
}
