/*
 * 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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <locale.h>
#include <sys/utsname.h>
#include <sys/systeminfo.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/signal.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/stropts.h>
#include <sys/resource.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <sys/stream.h>
#include <net/route.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/if_ether.h>
#include <netinet/ip_var.h>
#include <netinet/udp.h>
#include <netinet/udp_var.h>
#include <rpc/rpc.h>
#include <rpcsvc/bootparam_prot.h>

#define	MAXIFS	256

/* command line flags */
int		debug = 0;		/* do debug printfs */
int		echo_host = 0;		/* just echo hostname, don't set it */
int		verbose = 0;		/* do verbose printfs */
int		safe = 0;		/* don't change anything */
int		multiple = 0;		/* take multiple replies */

static ulong_t	if_netmask;

void		notsupported(), usage(), bp_whoami();
int		get_ifdata();		/* get IP addr, subnet mask from IF */
extern char	*inet_ntoa();
extern int	getopt(), setdomainname();

struct prototab {
	char *name;
	void (*func)();
} prototab[] = {
	{ "bootparams", bp_whoami },
	{ "bootp", notsupported },
	{ 0, 0 }
};



/*
 * usage: hostconfig [-p <protocol>] [-v] [-n] [-h] [<ifname>] [-f <hostname>]
 *
 * options:
 *	-d		Debug mode.
 * 	-v		Verbose mode.
 *	-n		Don't change anything.
 *	-h		Don't set hostname, just echo to standard out.
 *	-m		Wait for multiple answers (best used with the "-n"
 *			and "-v" flags).
 *	-f <hostname>	Fake mode - get bootparams for <hostname> (also
 *			best used with the "-n" and "-v" flags).
 *	<ifname>	Use IP address of <interface> in whoami request.
 *
 * If no interface name is specified, bp_whoami will cycle through the
 * interfaces, using the IP address of each in turn until an answer is
 * received.  Note that rpc_broadcast() broadcasts the RPC call on all
 * interfaces, so the <ifname> argument doesn't restrict the request
 * to that interface, it just uses that interface to determine the IP
 * address to put into the request.  If "-f <hostname>" is specified,
 * we put the IP address of <hostname> in the whoami request.  Otherwise,
 * we put the IP address of the interface in the whoami request.
 *
 */


int
main(argc, argv)
	int argc;
	char **argv;
{
	struct ifreq *reqbuf;
	struct ifreq *ifr;
	struct ifconf ifc;
	struct in_addr targetaddr;
	struct hostent *hp;
	char *targethost = NULL;
	char *cmdname;
	int c;
	int n;
	struct prototab *ptp;
	void (*protofunc)() = NULL;
	int numifs;
	unsigned bufsize;

	extern char *optarg;
	extern int optind;

	cmdname = argv[0];

	while ((c = getopt(argc, argv, "dhvnmf:p:")) != -1) {

		switch ((char)c) {
		case 'd':
			debug++;
			break;

		case 'h':
			echo_host++;
			break;
		case 'v':
			verbose++;
			break;

		case 'm':
			multiple++;
			break;

		case 'n':
			safe++;
			break;

		case 'f':
			targethost = optarg;
			break;

		case 'p':
			protofunc = NULL;
			for (ptp = &prototab[0]; ptp->func; ptp++)
				if (strcmp(optarg, ptp->name) == 0) {
					protofunc = ptp->func;
					break;
				}
			if (protofunc == NULL)
				usage(cmdname);
			break;

		case '?':
			usage(cmdname);
		}
	}

	if (protofunc == NULL)
		usage(cmdname);

	if (targethost) {
		/* we are faking it */
		if (debug)
			fprintf(stdout, "targethost = %s\n", targethost);

		if ((hp = gethostbyname(targethost)) == NULL) {
			if ((targetaddr.s_addr = inet_addr(targethost)) ==
			    (ulong_t)(-1)) {
				(void) fprintf(stderr,
					"%s: cannot get IP address for %s\n",
					cmdname, targethost);
				return (1);
			}
		} else {
			if (hp->h_length != sizeof (targetaddr)) {
				(void) fprintf(stderr,
					"%s: cannot find host entry for %s\n",
					cmdname, targethost);
				return (1);
			} else
				(void) memcpy(&targetaddr.s_addr, hp->h_addr,
				    sizeof (targetaddr));
		}
	} else
		targetaddr.s_addr = 0;

	if (optind < argc) {
		/* interface names were specified */
		for (; optind < argc; optind++) {
			if (debug)
				fprintf(stdout, "Trying arg %s\n",
					argv[optind]);
			(*protofunc)(argv[optind], targetaddr);
		}
	} else {
		/* no interface names specified - try them all */
		int ifcount = 0;	/* count of useable interfaces */
		int s;

		if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
			perror("socket");
			return (1);
		}
#ifdef SIOCGIFNUM
		if (ioctl(s, SIOCGIFNUM, (char *)&numifs) < 0) {
			numifs = MAXIFS;
		}
#else
		numifs = MAXIFS;
#endif
		bufsize = numifs * sizeof (struct ifreq);
		reqbuf = (struct ifreq *)malloc(bufsize);
		if (reqbuf == NULL) {
			fprintf(stderr, "out of memory\n");
			return (1);
		}
		ifc.ifc_buf = (caddr_t)&reqbuf[0];
		ifc.ifc_len = bufsize;
		if (ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0) {
			perror("ioctl(SIOCGIFCONF)");
			return (1);
		}
		ifr = ifc.ifc_req;
		n = ifc.ifc_len/sizeof (struct ifreq);
		for (; n > 0; n--, ifr++) {
			if (ioctl(s, SIOCGIFFLAGS, (char *)ifr) < 0) {
				perror("ioctl(SIOCGIFFLAGS)");
				return (1);
			}
			if ((ifr->ifr_flags & IFF_LOOPBACK) ||
			    !(ifr->ifr_flags & IFF_BROADCAST) ||
			    !(ifr->ifr_flags & IFF_UP) ||
			    (ifr->ifr_flags & IFF_NOARP) ||
			    (ifr->ifr_flags & IFF_POINTOPOINT)) {
				if (debug)
					fprintf(stdout, "If %s not suitable\n",
						ifr->ifr_name);
				continue;
			} else {
				if (debug)
					fprintf(stdout, "Trying device %s\n",
						ifr->ifr_name);
				(*protofunc)(ifr->ifr_name,  targetaddr);
				ifcount++;
			}
		}
		if (verbose && ifcount == 0) {
			fprintf(stderr, "No useable interfaces found.\n");
			return (1);
		}
		(void) close(s);
		(void) free((char *)reqbuf);
	}
	return (0);
}


void
add_default_route(router_addr)
	struct in_addr router_addr;
{
	struct rtentry route;
	struct sockaddr_in *sin;
	int s;

	(void) memset(&route, 0, sizeof (route));

	/* route destination is "default" - zero */
	/* LINTED - alignment OK (32bit) */
	sin = (struct sockaddr_in *)&route.rt_dst;
	sin->sin_family = AF_INET;

	/* LINTED - alignment OK (32bit) */
	sin = (struct sockaddr_in *)&route.rt_gateway;
	sin->sin_family = AF_INET;
	sin->sin_addr.s_addr = router_addr.s_addr;

	route.rt_flags = RTF_GATEWAY | RTF_UP;

	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		perror("socket");
		return;
	}
	if (ioctl(s, SIOCADDRT, (char *)&route) == -1) {
		perror("add default route");
		return;
	}
	(void) close(s);
}


int
bpanswer(struct bp_whoami_res *res, struct netbuf *nb)
{
	struct in_addr router_addr;
	static int set;
	int len;
	char errbuf[MAX_MACHINE_NAME + 28];
	/* MAX_MACHINE_NAME + strlen ("sysinfo(SI_SET_HOSTNAME)()") + null */

	(void) memcpy(&router_addr, &res->router_address.bp_address_u.ip_addr,
	    sizeof (router_addr));

	if (verbose) {
		struct sockaddr_in *addr;

		if (nb) {
			/* LINTED - alignment (32bit) OK */
			addr = (struct sockaddr_in *)nb->buf;
			fprintf(stdout, "From [%s]: ",
			    inet_ntoa(addr->sin_addr));
		} else {
			fprintf(stdout, "Reply:\\t\\t");
		}
		fprintf(stdout, "hostname = %s\n", res->client_name);
		fprintf(stdout, "\t\typdomain = %s\n", res->domain_name);
		fprintf(stdout, "\t\trouter = %s\n", inet_ntoa(router_addr));
	}

	if (!safe && !set) {
		/*
		 * Stuff the values from the RPC reply into the kernel.
		 * Only allow one pass through this code; There's no reason
		 * why all replies should tweak the kernel.
		 */
		set++;

		len = strlen(res->client_name);
		if (len != 0) {
			if (!echo_host) {
				if (sysinfo(SI_SET_HOSTNAME, res->client_name,
				    len) < 0) {
					(void) snprintf(errbuf, sizeof (errbuf),
					    "sysinfo(SI_SET_HOSTNAME)(%s)",
					    res->client_name);
					perror(errbuf);
				}
			} else
				(void) fprintf(stdout, "%s\n",
				    res->client_name);
		}

		len = strlen(res->domain_name);
		if (len != 0) {
			if (setdomainname(res->domain_name, len) == -1) {
				(void) snprintf(errbuf, sizeof (errbuf),
				    "setdomainname(%s)", res->domain_name);
				perror(errbuf);
			}
		}

		/* we really should validate this router value */
		if (router_addr.s_addr != 0)
			add_default_route(router_addr);
	}

	if (multiple)
		return (0);

	/* our job is done */
	exit(0);
	/* NOTREACHED */
}

void
bp_whoami(device, addr)
	char *device;
	struct in_addr addr;
{
	struct bp_whoami_arg req;
	struct bp_whoami_res res;
	struct in_addr lookupaddr;
	enum clnt_stat stat;
	int val = 1;

	if (debug)
		fprintf(stdout, "bp_whoami on interface %s addr %s\n", device,
		    inet_ntoa(addr));

	if (addr.s_addr ==  0) {
		if (get_ifdata(device, &lookupaddr, &if_netmask) == -1)
			exit(1);
	} else
		(void) memcpy(&lookupaddr, &addr, sizeof (addr));

	lookupaddr.s_addr = ntohl(lookupaddr.s_addr);

	if (debug)
		fprintf(stdout, "lookup address is %s\n",
			inet_ntoa(lookupaddr));

	(void) memset(&req, 0, sizeof (req));
	(void) memset(&res, 0, sizeof (res));

	req.client_address.address_type = IP_ADDR_TYPE;
	(void) memcpy(&req.client_address.bp_address_u.ip_addr, &lookupaddr,
	    sizeof (lookupaddr));

	/*
	 * Broadcast using portmap version number 2  ONLY to
	 * prevent broadcast storm
	 */

	(void) __rpc_control(CLCR_SET_LOWVERS, &val);

	stat = rpc_broadcast(BOOTPARAMPROG, BOOTPARAMVERS, BOOTPARAMPROC_WHOAMI,
	    xdr_bp_whoami_arg, (caddr_t)&req, xdr_bp_whoami_res, (caddr_t)&res,
	    (resultproc_t)bpanswer, "udp");

	/* Now try version 3 as well */

	val = 0;
	(void) __rpc_control(CLCR_SET_LOWVERS, &val);

	stat = rpc_broadcast(BOOTPARAMPROG, BOOTPARAMVERS,
	    BOOTPARAMPROC_WHOAMI, xdr_bp_whoami_arg, (caddr_t)&req,
	    xdr_bp_whoami_res, (caddr_t)&res, (resultproc_t)bpanswer, "udp");

	if (stat != RPC_SUCCESS) {
		clnt_perrno(stat);
		exit(1);
	}
}


/*
 * Get IP address of an interface.  As long as we are looking, get the
 * netmask as well.
 */
int
get_ifdata(dev, ipp, maskp)
	char *dev;
	ulong_t *ipp, *maskp;
{
	struct ifreq ifr;
	/* LINTED - alignment OK (32bit) */
	struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
	int s;

	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		perror("socket");
		return (-1);
	}

	if (strlcpy(ifr.ifr_name, dev, sizeof (ifr.ifr_name)) >=
		sizeof (ifr.ifr_name)) {
			(void) fprintf(stderr, "Device name too long %s\n",
			    dev);
			return (-1);
	}

	if (ipp) {
		if (ioctl(s, SIOCGIFADDR, (caddr_t)&ifr) < 0) {
			perror("ioctl(SIOCGIFADDR)");
			return (-1);
		}
		*ipp = ntohl(sin->sin_addr.s_addr);

		if (debug)
			(void) fprintf(stderr, "Interface '%s' address %s\n",
			    dev, inet_ntoa(sin->sin_addr));
	}

	if (maskp) {
		if (ioctl(s, SIOCGIFNETMASK, (caddr_t)&ifr) < 0) {
			perror("SIOCGIFNETMASK");
			return (-1);
		}
		*maskp = ntohl(sin->sin_addr.s_addr);

		if (debug)
			(void) fprintf(stderr,
				"Interface '%s' subnet mask %s\n", dev,
				inet_ntoa(sin->sin_addr));
	}

	(void) close(s);
	return (0);
}

void
notsupported()
{
	fprintf(stderr, "requested protocol is not supported\n");
	exit(1);
}

void
usage(cmdname)
	char *cmdname;
{
	(void) fprintf(stderr, "usage: %s [-v] [-n] [-m] [-h] [<ifname>] "
	    "[-f <hostname>] -p bootparams|bootp\n", cmdname);
	(void) fflush(stderr);
	exit(1);
}