xref: /illumos-gate/usr/src/uts/common/fs/nfs/nfs_dlinet.c (revision ad256857)

/*
 * 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) 2018, Joyent, Inc.
 */

#include <sys/param.h>
#include <sys/types.h>
#include <sys/systm.h>
#include <sys/cred.h>
#include <sys/user.h>
#include <sys/file.h>
#include <sys/stream.h>
#include <sys/strsubr.h>
#include <sys/stropts.h>
#include <sys/strsun.h>
#include <sys/debug.h>
#include <sys/tiuser.h>
#include <sys/sockio.h>
#include <sys/socket.h>
#include <sys/t_kuser.h>
#include <sys/utsname.h>
#include <sys/systeminfo.h>
#include <sys/netconfig.h>
#include <sys/ethernet.h>
#include <sys/dlpi.h>
#include <sys/vfs.h>
#include <sys/sysmacros.h>
#include <sys/bootconf.h>
#include <sys/bootprops.h>
#include <sys/cmn_err.h>
#include <sys/promif.h>
#include <sys/mount.h>

#include <net/if.h>
#include <net/route.h>

#include <netinet/in.h>
#include <netinet/arp.h>
#include <netinet/dhcp.h>
#include <netinet/inetutil.h>
#include <dhcp_impl.h>
#include <sys/sunos_dhcp_class.h>

#include <rpc/types.h>
#include <rpc/rpc.h>
#include <rpc/xdr.h>
#include <rpc/auth.h>
#include <rpc/clnt.h>
#include <rpc/pmap_clnt.h>
#include <rpc/pmap_rmt.h>
#include <rpc/pmap_prot.h>
#include <rpc/bootparam.h>
#include <rpc/rpcb_prot.h>

#include <nfs/nfs.h>
#include <nfs/nfs4.h>
#include <nfs/nfs_clnt.h>
#include <nfs/mount.h>
#include <sys/mntent.h>

#include <sys/kstr.h>
#include <sys/sunddi.h>
#include <sys/sunldi.h>
#include <sys/esunddi.h>

#include <sys/errno.h>
#include <sys/modctl.h>

/*
 * RPC timers and retries
 */
#define	PMAP_RETRIES	5
#define	DEFAULT_RETRIES	3
#define	GETFILE_RETRIES	2

#define	DEFAULT_TIMEO	3
#define	WHOAMI_TIMEO	20
#define	REVARP_TIMEO	5
#define	GETFILE_TIMEO	1

/*
 * These are from the rpcgen'd version of mount.h XXX
 */
#define	MOUNTPROG 100005
#define	MOUNTPROC_MNT		1
#define	MOUNTVERS		1
#define	MOUNTVERS_POSIX		2
#define	MOUNTVERS3		3

struct fhstatus {
	int fhs_status;
	fhandle_t fhs_fh;
};

#define	FHSIZE3 64

struct fhandle3 {
	uint_t fhandle3_len;
	char *fhandle3_val;
};

enum mountstat3 {
	MNT_OK = 0,
	MNT3ERR_PERM = 1,
	MNT3ERR_NOENT = 2,
	MNT3ERR_IO = 5,
	MNT3ERR_ACCES = 13,
	MNT3ERR_NOTDIR = 20,
	MNT3ERR_INVAL = 22,
	MNT3ERR_NAMETOOLONG = 63,
	MNT3ERR_NOTSUPP = 10004,
	MNT3ERR_SERVERFAULT = 10006
};

struct mountres3_ok {
	struct fhandle3 fhandle;
	struct {
		uint_t auth_flavors_len;
		int *auth_flavors_val;
	} auth_flavors;
};

struct mountres3 {
	enum mountstat3 fhs_status;
	union {
		struct mountres3_ok mountinfo;
	} mountres3_u;
};

/*
 * DLPI address format.
 */
struct	dladdr {
	uchar_t		dl_phys[6];
	ushort_t	dl_sap;
};

static struct modlmisc modlmisc = {
	&mod_miscops, "Boot diskless"
};

static struct modlinkage modlinkage = {
	MODREV_1, (void *)&modlmisc, NULL
};

static int	dldebug;

int
_init(void)
{
	return (mod_install(&modlinkage));
}

int
_fini(void)
{
	return (mod_remove(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}


static enum clnt_stat	pmap_rmt_call(struct knetconfig *, struct netbuf *,
			    bool_t, rpcprog_t, rpcvers_t, rpcproc_t, xdrproc_t,
			    caddr_t, xdrproc_t, caddr_t, struct timeval,
			    struct netbuf *);
static bool_t		myxdr_rmtcall_args(XDR *, struct rmtcallargs *);
static bool_t		myxdr_rmtcallres(XDR *, struct rmtcallres *);
static bool_t		myxdr_pmap(XDR *, struct pmap *);
static bool_t		myxdr_fhstatus(XDR *xdrs, struct fhstatus *fhsp);
static bool_t		myxdr_fhandle(XDR *xdrs, fhandle_t *fh);
static bool_t		myxdr_mountres3(XDR *xdrs, struct mountres3 *objp);
static bool_t		myxdr_mountstat3(XDR *xdrs, enum mountstat3 *objp);
static bool_t		myxdr_mountres3_ok(XDR *xdrs,
			    struct mountres3_ok *objp);
static bool_t		myxdr_fhandle3(XDR *xdrs, struct fhandle3 *objp);
static enum clnt_stat	pmap_kgetport(struct knetconfig *, struct netbuf *,
			    rpcprog_t, rpcvers_t, rpcprot_t);
static enum clnt_stat	mycallrpc(struct knetconfig *, struct netbuf *,
			    rpcprog_t, rpcvers_t, rpcproc_t, xdrproc_t,
			    char *, xdrproc_t, char *, int, int);
static int		ifioctl(TIUSER *, int, struct netbuf *);
static int		getfile(char *, char *, struct netbuf *, char *);
static int		ping_prog(struct netbuf *, uint_t prog, uint_t vers,
			    int proto, enum clnt_stat *);
static int		mountnfs(struct netbuf *, char *, char *,
			    fhandle_t *, int *);
static int		mountnfs3(struct netbuf *, char *, char *,
			    nfs_fh3 *, int *);
static int		init_mountopts(struct nfs_args *, int,
			    struct knetconfig **, int *);
static int		revarp_myaddr(TIUSER *);
static void		revarp_start(ldi_handle_t, struct netbuf *);
static void		revarpinput(ldi_handle_t, struct netbuf *);
static void		init_netbuf(struct netbuf *);
static void		free_netbuf(struct netbuf *);
static int		rtioctl(TIUSER *, int, struct rtentry *);
static void		init_config(void);

static void		cacheinit(void);
static int		cacheinfo(char *, int, struct netbuf *, char *, int);
static int		dlifconfig(TIUSER *, struct in_addr *, struct in_addr *,
			    struct in_addr *, uint_t);
static int		setifflags(TIUSER *, uint_t);

static char		*inet_ntoa(struct in_addr);
static int		inet_aton(char *, uchar_t *);
static int		isdigit(int);

/*
 * Should be in some common
 * ethernet source file.
 */
static struct ether_addr etherbroadcastaddr = {
	0xff, 0xff, 0xff, 0xff, 0xff, 0xff
};

static struct ether_addr myether;

/*
 * "ifname" is the interface name/unit as read from the boot
 * arguments.
 * "ndev" is the major device number of the network interface
 * used to boot from.
 * "ifunit" it the physical point of attachment for the network
 * interface used to boot from.
 *
 * Both of these are initialized in "init_config()".
 */

static char	ifname[IFNAMSIZ];
static char	ndev_path[MAXPATHLEN];
static int	ifunit;

/*
 * XXX these should be shared
 */
static struct knetconfig dl_udp_netconf = {
	NC_TPI_CLTS,			/* semantics */
	NC_INET,			/* family */
	NC_UDP,				/* protocol */
	0,				/* device */
};

static struct knetconfig dl_tcp_netconf = {
	NC_TPI_COTS,			/* semantics */
	NC_INET,			/* family */
	NC_TCP,				/* protocol */
	0,				/* device */
};

/* parameters from DHCP or bootparamd */
static PKT_LIST	*pl = NULL;
static uchar_t server_ip[4];
static uchar_t dhcp_server_ip[4];
static char *server_name_c, *server_path_c;
static char rootopts[256];

/*
 * XXX Until we get the nfsmapid deadlocks all fixed, don't allow
 * XXX a v4 root mount.
 */
int nfs4_no_diskless_root_support = 1;

int
mount_root(char *name, char *path, int version, struct nfs_args *args,
    int *vfsflags)
{
	int rc;
	int proto;
	struct knetconfig *dl_cf;
	static int init_done = 0;
	enum clnt_stat stat;

	if (dldebug)
		printf("mount_root: name=%s\n", name);

	if (init_done == 0) {
		init_config();
		init_done = 1;
	}

	init_netbuf(args->addr);

	do {
		rc = getfile(name, args->hostname, args->addr, path);
	} while (rc == ETIMEDOUT);

	if (rc) {
		free_netbuf(args->addr);
		return (rc);
	}

	ASSERT(args->knconf->knc_protofmly != NULL);
	ASSERT(args->knconf->knc_proto != NULL);

	switch (version) {
	case NFS_VERSION:
		rc = mountnfs(args->addr, args->hostname, path,
		    (fhandle_t *)args->fh, &proto);
		break;
	case NFS_V3:
		rc = mountnfs3(args->addr, args->hostname, path,
		    (nfs_fh3 *)args->fh, &proto);
		break;
	case NFS_V4:
		((struct sockaddr_in *)args->addr->buf)->sin_port =
		    htons(NFS_PORT);
		if (ping_prog(args->addr, NFS_PROGRAM, NFS_V4, IPPROTO_TCP,
		    &stat)) {
			proto = IPPROTO_TCP;
			rc = 0;
		} else {
			switch (stat) {
			case RPC_PROGVERSMISMATCH:
			case RPC_XPRTFAILED:
				/*
				 * Common failures if v4 unsupported or no TCP
				 */
				rc = EPROTONOSUPPORT;
				break;
			default:
				rc = ENXIO;
			}
		}
		if (nfs4_no_diskless_root_support)
			rc = EPROTONOSUPPORT;
		break;
	default:
		rc = EPROTONOSUPPORT;
		break;
	}

	if (rc)
		goto errout;

	switch (proto) {
	case IPPROTO_TCP:
		dl_cf = &dl_tcp_netconf;
		break;
	case IPPROTO_UDP:
	default:
		dl_cf = &dl_udp_netconf;
		break;
	}

	rc = init_mountopts(args, version, &dl_cf, vfsflags);

	/*
	 * Copy knetconfig information from the template, note that the
	 * rdev field has been set by init_config above.
	 */
	args->knconf->knc_semantics = dl_cf->knc_semantics;
	args->knconf->knc_rdev = dl_cf->knc_rdev;
	(void) strcpy(args->knconf->knc_protofmly, dl_cf->knc_protofmly);
	(void) strcpy(args->knconf->knc_proto, dl_cf->knc_proto);

errout:
	if (dldebug) {
		if (rc)
			nfs_perror(rc, "mount_root: mount %s:%s failed: %m\n",
			    args->hostname, path);
		else
			printf("mount_root: leaving\n");
	}

	return (rc);
}

/*
 * Call mount daemon on server `sa' to mount path.
 * `port' is set to nfs port and fh is the fhandle
 * returned from the server.
 */
static int
mountnfs(struct netbuf *sa, char *server,
    char *path, fhandle_t *fh, int *proto)
{
	struct fhstatus fhs;
	enum clnt_stat stat;

	if (dldebug)
		printf("mountnfs: entered\n");

	/*
	 * Get the port number for the mount program.
	 * pmap_kgetport first tries a SunOS portmapper
	 * and, if no reply is received, will try a
	 * SVR4 rpcbind. Either way, `sa' is set to
	 * the correct address.
	 */
	do {
		stat = pmap_kgetport(&dl_udp_netconf, sa, (rpcprog_t)MOUNTPROG,
		    (rpcvers_t)MOUNTVERS, (rpcprot_t)IPPROTO_UDP);

		if (stat == RPC_TIMEDOUT) {
			cmn_err(CE_WARN,
			    "mountnfs: %s:%s portmap not responding",
			    server, path);
		} else if (stat != RPC_SUCCESS) {
			cmn_err(CE_WARN,
			    "mountnfs: pmap_kgetport RPC error %d (%s).",
			    stat, clnt_sperrno(stat));
			return (ENXIO);	/* XXX */
		}
	} while (stat == RPC_TIMEDOUT);

	/*
	 * The correct port number has been
	 * put into `sa' by pmap_kgetport().
	 */
	do {
		stat = mycallrpc(&dl_udp_netconf, sa, (rpcprog_t)MOUNTPROG,
		    (rpcvers_t)MOUNTVERS, (rpcproc_t)MOUNTPROC_MNT,
		    xdr_bp_path_t, (char *)&path,
		    myxdr_fhstatus, (char *)&fhs,
		    DEFAULT_TIMEO, DEFAULT_RETRIES);
		if (stat == RPC_TIMEDOUT) {
			cmn_err(CE_WARN,
			    "mountnfs: %s:%s mount server not responding",
			    server, path);
		}
	} while (stat == RPC_TIMEDOUT);

	if (stat != RPC_SUCCESS) {
		cmn_err(CE_WARN, "mountnfs: RPC failed: error %d (%s).",
		    stat, clnt_sperrno(stat));
		return (ENXIO);	/* XXX */
	}

	((struct sockaddr_in *)sa->buf)->sin_port = htons(NFS_PORT);

	*fh = fhs.fhs_fh;
	if (fhs.fhs_status != 0) {
		if (dldebug)
			printf("mountnfs: fhs_status %d\n", fhs.fhs_status);
		return (ENXIO);		/* XXX */
	}

	*proto = IPPROTO_UDP;

	if (ping_prog(sa, NFS_PROGRAM, NFS_VERSION, IPPROTO_TCP, NULL))
		*proto = IPPROTO_TCP;

	if (dldebug)
		printf("mountnfs: leaving\n");
	return (0);
}

/*
 * Call mount daemon on server `sa' to mount path.
 * `port' is set to nfs port and fh is the fhandle
 * returned from the server.
 */
static int
mountnfs3(struct netbuf *sa, char *server,
    char *path, nfs_fh3 *fh, int *proto)
{
	struct mountres3 mountres3;
	enum clnt_stat stat;
	int ret = 0;

	if (dldebug)
		printf("mountnfs3: entered\n");

	/*
	 * Get the port number for the mount program.
	 * pmap_kgetport first tries a SunOS portmapper
	 * and, if no reply is received, will try a
	 * SVR4 rpcbind. Either way, `sa' is set to
	 * the correct address.
	 */
	do {
		stat = pmap_kgetport(&dl_udp_netconf, sa, (rpcprog_t)MOUNTPROG,
		    (rpcvers_t)MOUNTVERS3, (rpcprot_t)IPPROTO_UDP);

		if (stat == RPC_PROGVERSMISMATCH) {
			if (dldebug)
				printf("mountnfs3: program/version mismatch\n");
			return (EPROTONOSUPPORT); /* XXX */
		} else if (stat == RPC_TIMEDOUT) {
			cmn_err(CE_WARN,
			    "mountnfs3: %s:%s portmap not responding",
			    server, path);
		} else if (stat != RPC_SUCCESS) {
			cmn_err(CE_WARN,
			    "mountnfs3: pmap_kgetport RPC error %d (%s).",
			    stat, clnt_sperrno(stat));
			return (ENXIO);	/* XXX */
		}
	} while (stat == RPC_TIMEDOUT);

	mountres3.mountres3_u.mountinfo.fhandle.fhandle3_val = NULL;
	mountres3.mountres3_u.mountinfo.auth_flavors.auth_flavors_val = NULL;

	/*
	 * The correct port number has been
	 * put into `sa' by pmap_kgetport().
	 */
	do {
		stat = mycallrpc(&dl_udp_netconf, sa, (rpcprog_t)MOUNTPROG,
		    (rpcvers_t)MOUNTVERS3, (rpcproc_t)MOUNTPROC_MNT,
		    xdr_bp_path_t, (char *)&path,
		    myxdr_mountres3, (char *)&mountres3,
		    DEFAULT_TIMEO, DEFAULT_RETRIES);
		if (stat == RPC_TIMEDOUT) {
			cmn_err(CE_WARN,
			    "mountnfs3: %s:%s mount server not responding",
			    server, path);
		}
	} while (stat == RPC_TIMEDOUT);

	if (stat == RPC_PROGVERSMISMATCH) {
		if (dldebug)
			printf("mountnfs3: program/version mismatch\n");
		ret = EPROTONOSUPPORT;
		goto out;
	}
	if (stat != RPC_SUCCESS) {
		cmn_err(CE_WARN, "mountnfs3: RPC failed: error %d (%s).",
		    stat, clnt_sperrno(stat));
		ret = ENXIO;	/* XXX */
		goto out;
	}

	if (mountres3.fhs_status != MNT_OK) {
		if (dldebug)
			printf("mountnfs3: fhs_status %d\n",
			    mountres3.fhs_status);
		ret = ENXIO;	/* XXX */
		goto out;
	}

	((struct sockaddr_in *)sa->buf)->sin_port = htons(NFS_PORT);

	*proto = IPPROTO_UDP;

	if (ping_prog(sa, NFS_PROGRAM, NFS_V3, IPPROTO_TCP, NULL)) {
		*proto = IPPROTO_TCP;
	}

	fh->fh3_length = mountres3.mountres3_u.mountinfo.fhandle.fhandle3_len;
	bcopy(mountres3.mountres3_u.mountinfo.fhandle.fhandle3_val,
	    fh->fh3_u.data, fh->fh3_length);

out:
	xdr_free(myxdr_mountres3, (caddr_t)&mountres3);

	if (dldebug)
		printf("mountnfs3: leaving\n");
	return (ret);
}

static int
ping_prog(struct netbuf *call_addr, uint_t prog, uint_t vers, int proto,
    enum clnt_stat *statp)
{
	struct knetconfig *knconf;
	enum clnt_stat stat;
	int retries = DEFAULT_RETRIES;

	switch (proto) {
	case IPPROTO_TCP:
		knconf = &dl_tcp_netconf;
		break;
	case IPPROTO_UDP:
		knconf = &dl_udp_netconf;
		break;
	default:
		return (0);
	}

	do {
		stat = mycallrpc(knconf, call_addr, prog, vers, NULLPROC,
		    xdr_void, NULL, xdr_void, NULL,
		    DEFAULT_TIMEO, DEFAULT_RETRIES);

		if (dldebug)
			printf("ping_prog: %d return %d (%s)\n", proto, stat,
			    clnt_sperrno(stat));
		/*
		 * Special case for TCP, it may "timeout" because it failed
		 * to establish an initial connection but it doesn't
		 * actually retry, so we do the retry.
		 * Persistence pays in diskless.
		 */
	} while (stat == RPC_TIMEDOUT && proto == IPPROTO_TCP && retries--);

	if (statp != NULL)
		*statp = stat;

	if (stat != RPC_SUCCESS)
		return (0);
	return (1);
}

static struct netbuf bootparam_addr;

/*
 * Returns after filling in the following global variables:
 *	bootparam_addr,
 *	utsname.nodename,
 *	srpc_domain.
 */
static int
whoami(void)
{
	TIUSER *tiptr;
	struct netbuf sa;
	struct netbuf req;
	struct bp_whoami_arg arg;
	struct bp_whoami_res res;
	struct timeval tv;
	enum clnt_stat stat;
	int rc;
	size_t namelen;
	int printed_waiting_msg;

	if ((rc = t_kopen((file_t *)NULL, dl_udp_netconf.knc_rdev,
	    FREAD|FWRITE, &tiptr, CRED())) != 0) {
		nfs_perror(rc, "whoami: t_kopen udp failed: %m.\n");
	}

	/*
	 * Find out our local (IP) address.
	 */
	if (rc = revarp_myaddr(tiptr)) {
		nfs_perror(rc, "whoami: revarp_myaddr failed: %m.\n");
		(void) t_kclose(tiptr, 0);
		return (rc);
	}

	/* explicitly use the limited broadcast address */
	init_netbuf(&sa);
	((struct sockaddr_in *)sa.buf)->sin_family = AF_INET;
	((struct sockaddr_in *)sa.buf)->sin_addr.s_addr =
	    htonl(INADDR_BROADCAST);
	sa.len = sizeof (struct sockaddr_in);

	/*
	 * Pick up our local (IP) address.
	 */
	init_netbuf(&req);
	if (rc = ifioctl(tiptr, SIOCGIFADDR, &req)) {
		nfs_perror(rc,
		    "whoami: couldn't get my IP address: %m.\n");
		free_netbuf(&sa);
		free_netbuf(&req);
		(void) t_kclose(tiptr, 0);
		return (rc);
	}

	/*
	 * Set up the arguments expected by bootparamd.
	 */
	arg.client_address.address_type = IP_ADDR_TYPE;
	bcopy(&((struct sockaddr_in *)req.buf)->sin_addr,
	    &arg.client_address.bp_address.ip_addr, sizeof (struct in_addr));

	free_netbuf(&req);

	init_netbuf(&bootparam_addr);

	/*
	 * Initial retransmission interval
	 */
	tv.tv_sec = DEFAULT_TIMEO;
	tv.tv_usec = 0;
	res.client_name = kmem_alloc(MAX_MACHINE_NAME + 1, KM_SLEEP);
	res.domain_name = kmem_alloc(MAX_MACHINE_NAME + 1, KM_SLEEP);

	/*
	 * Do a broadcast call to find a bootparam daemon that
	 * will tell us our hostname, domainname and any
	 * router that we have to use to talk to our NFS server.
	 */
	printed_waiting_msg = 0;
	do {
		/*
		 * pmap_rmt_call will first try the SunOS portmapper
		 * and if no reply is received will then try the SVR4
		 * rpcbind.
		 * Either way, `bootparam_addr' will be set to the
		 * correct address for the bootparamd that responds.
		 */
		stat = pmap_rmt_call(&dl_udp_netconf, &sa, TRUE, BOOTPARAMPROG,
		    BOOTPARAMVERS, BOOTPARAMPROC_WHOAMI,
		    xdr_bp_whoami_arg, (caddr_t)&arg,
		    xdr_bp_whoami_res, (caddr_t)&res,
		    tv, &bootparam_addr);
		if (stat == RPC_TIMEDOUT && !printed_waiting_msg) {
			cmn_err(CE_WARN,
			    "No bootparam server responding; still trying");
			printed_waiting_msg = 1;
		}
		/*
		 * Retransmission interval for second and subsequent tries.
		 * We expect first pmap_rmt_call to retransmit and backoff to
		 * at least this value.
		 */
		tv.tv_sec = WHOAMI_TIMEO;
		tv.tv_usec = 0;
	} while (stat == RPC_TIMEDOUT);

	if (printed_waiting_msg)
		printf("Bootparam response received\n");

	if (stat != RPC_SUCCESS) {
		/* XXX should get real error here */
		rc = ENXIO;
		cmn_err(CE_WARN,
		    "whoami: bootparam RPC failed: error %d (%s).",
		    stat, clnt_sperrno(stat));
		goto done;
	}

	namelen = strlen(res.client_name);
	if (namelen > sizeof (utsname.nodename)) {
		printf("whoami: hostname too long");
		rc = ENAMETOOLONG;
		goto done;
	}
	if (namelen != 0) {
		bcopy(res.client_name, &utsname.nodename, namelen);
		cmn_err(CE_CONT, "?hostname: %s\n", utsname.nodename);
	} else {
		printf("whoami: no host name\n");
		rc = ENXIO;
		goto done;
	}

	namelen = strlen(res.domain_name);
	if (namelen != 0) {
		if (namelen > SYS_NMLN) {
			printf("whoami: domainname too long");
			rc = ENAMETOOLONG;
			goto done;
		}
		bcopy(res.domain_name, &srpc_domain, namelen);
		cmn_err(CE_CONT, "?domainname: %s\n", srpc_domain);
	} else {
		printf("whoami: no domain name\n");
	}

	if (res.router_address.address_type == IP_ADDR_TYPE) {
		struct rtentry		rtentry;
		struct sockaddr_in	*sin;
		struct in_addr		ipaddr;

		bcopy(&res.router_address.bp_address.ip_addr, &ipaddr,
		    sizeof (struct in_addr));

		if (ipaddr.s_addr != (uint32_t)0) {
			sin = (struct sockaddr_in *)&rtentry.rt_dst;
			bzero(sin, sizeof (*sin));
			sin->sin_family = AF_INET;

			sin = (struct sockaddr_in *)&rtentry.rt_gateway;
			bzero(sin, sizeof (*sin));
			sin->sin_family = AF_INET;
			sin->sin_addr.s_addr = ipaddr.s_addr;

			rtentry.rt_flags = RTF_GATEWAY | RTF_UP;

			if (rc = rtioctl(tiptr, SIOCADDRT, &rtentry)) {
				nfs_perror(rc,
				    "whoami: couldn't add route: %m.\n");
				goto done;
			}
		}
	} else {
		printf("whoami: unknown gateway addr family %d\n",
		    res.router_address.address_type);
	}
done:
	kmem_free(res.client_name, MAX_MACHINE_NAME + 1);
	kmem_free(res.domain_name, MAX_MACHINE_NAME + 1);
	free_netbuf(&sa);
	(void) t_kclose(tiptr, 0);
	return (rc);
}

/*
 * Returns:
 *	1) The ascii form of our root servers name in `server_name'.
 *	2) Actual network address of our root server in `server_address'.
 *	3) Whatever BOOTPARAMPROC_GETFILE returns for the fileid key, in
 *	   `server_path'.  If fileid is "root", it is the pathname of our
 *	   root on the server.
 */
static int
getfile(char *fileid,
    char *server_name, struct netbuf *server_address, char *server_path)
{
	struct bp_getfile_arg arg;
	struct bp_getfile_res res;
	enum clnt_stat stat;
	int root = FALSE;
	static int using_cache = FALSE;
	struct in_addr ipaddr;
	int timeo = DEFAULT_TIMEO;
	int retries = DEFAULT_RETRIES;

	if (dldebug)
		printf("getfile: entered\n");

	/*
	 * Call cacheinfo() to see whether we can satisfy this request by using
	 * the information cached in memory by the boot program's DHCP
	 * implementation or boot properties rather than consult BOOTPARAMS,
	 * but while preserving the semantics of getfile(). We know that
	 * the server name is SYS_NMLN in length, and server_path is
	 * MAXPATHLEN (pn_alloc).
	 */
	if (strcmp(fileid, "root") == 0) {
		if (cacheinfo(server_name, SYS_NMLN, server_address,
		    server_path, MAXPATHLEN) == 0) {
			using_cache = TRUE;
			return (0);
		}
		root = TRUE;
	}

	/*
	 * If using cache, rootopts is already available.
	 */
	if (strcmp(fileid, "rootopts") == 0 && using_cache == TRUE) {
		return (rootopts[0] != 0 ? 0 : ENXIO);
	}

	if (bootparam_addr.len == 0) {
		return (ENXIO);
	}
	arg.client_name = (caddr_t)&utsname.nodename;
	arg.file_id = fileid;

	bzero(&res, sizeof (res));
	res.server_name = kmem_alloc(MAX_MACHINE_NAME + 1, KM_SLEEP);
	res.server_path = kmem_alloc(MAX_MACHINE_NAME + 1, KM_SLEEP);

	/*
	 * If we are not looking up the root file, we are looking
	 * up a non-critical option that should timeout quickly.
	 */
	if (!root) {
		timeo = GETFILE_TIMEO;
		retries = GETFILE_RETRIES;
	}

	/*
	 * bootparam_addr was filled in by the call to
	 * whoami(), so now send an rpc message to the
	 * bootparam daemon requesting our server information.
	 * Use UDP to talk to bootparms.
	 */
	stat = mycallrpc(&dl_udp_netconf, &bootparam_addr,
	    (rpcprog_t)BOOTPARAMPROG, (rpcvers_t)BOOTPARAMVERS,
	    (rpcproc_t)BOOTPARAMPROC_GETFILE,
	    xdr_bp_getfile_arg, (caddr_t)&arg,
	    xdr_bp_getfile_res, (caddr_t)&res,
	    timeo, retries);

	if (stat == RPC_SUCCESS) {
		(void) strcpy(server_name, res.server_name);
		(void) strcpy(server_path, res.server_path);
	}

	kmem_free(res.server_name, MAX_MACHINE_NAME + 1);
	kmem_free(res.server_path, MAX_MACHINE_NAME + 1);

	if (stat != RPC_SUCCESS) {
		if (root)
			cmn_err(CE_WARN, "getfile: RPC failed: error %d (%s).",
			    stat, clnt_sperrno(stat));
		return ((stat == RPC_TIMEDOUT) ? ETIMEDOUT : ENXIO); /* XXX */
	}

	if (*server_path == '\0')
		return (EINVAL);

	/*
	 * If the fileid is "root", we must get back a server name, for
	 * other parameters a server name is not required
	 */
	if (!root) {
		if (dldebug)
			printf("getfile: leaving: non-root\n");
		return (0);
	}

	if (*server_name == '\0')
		return (EINVAL);

	switch (res.server_address.address_type) {
	case IP_ADDR_TYPE:
		/*
		 * server_address is where we will get our root
		 * from.
		 */
		((struct sockaddr_in *)server_address->buf)->sin_family =
		    AF_INET;
		bcopy(&res.server_address.bp_address.ip_addr,
		    &ipaddr, sizeof (ipaddr));
		if (ipaddr.s_addr == 0)
			return (EINVAL);

		((struct sockaddr_in *)server_address->buf)->sin_addr.s_addr =
		    ipaddr.s_addr;
		server_address->len = sizeof (struct sockaddr_in);
		break;

	default:
		printf("getfile: unknown address type %d\n",
		    res.server_address.address_type);
		return (EPROTONOSUPPORT);
	}
	if (dldebug)
		printf("getfile: leaving\n");
	return (0);
}

/*
 * If the boot property "bootp-response" exists, then OBP performed a
 * successful DHCP lease acquisition for us and left the resultant ACK packet
 * encoded at that location.
 *
 * If no such property exists (or the information is incomplete or garbled),
 * the function returns -1.
 */
int
dhcpinit(void)
{
	int rc, i;
	char *p;
	struct in_addr braddr;
	struct in_addr subnet;
	DHCP_OPT *doptp;
	TIUSER *tiptr;
	struct sockaddr_in *sin;
	static int once_only = 0;

	if (once_only == 1) {
		return (0);
	}
	once_only = 1;

	if (dhcack == NULL) {
		return (-1);
	}

	if (dldebug) {
		printf("dhcp:  dhcack %p, len %d\n", (void *)dhcack,
		    dhcacklen);
	}

	pl = kmem_alloc(sizeof (PKT_LIST), KM_SLEEP);
	pl->len = dhcacklen;
	pl->pkt = kmem_alloc(pl->len, KM_SLEEP);
	bcopy(dhcack, pl->pkt, dhcacklen);

	/*
	 * For x86, ifname is not initialized
	 * in the netinstall case and dhcack interface name is
	 * set in strplumb(). So we only copy the name if ifname
	 * is set properly.
	 */
	if (ifname[0])
		(void) strlcpy(dhcifname, ifname, sizeof (dhcifname));

	/* remember the server_ip in dhcack */
	bcopy((uchar_t *)pl->pkt + 20, dhcp_server_ip, 4);
	bzero(pl->opts, (DHCP_LAST_OPT + 1) * sizeof (DHCP_OPT *));
	bzero(pl->vs, (VS_OPTION_END - VS_OPTION_START + 1) *
	    sizeof (DHCP_OPT *));

	if (dhcp_options_scan(pl, B_TRUE) != 0) {
		/* garbled packet */
		cmn_err(CE_WARN, "dhcp: DHCP packet parsing failed");
		kmem_free(pl->pkt, pl->len);
		kmem_free(pl, sizeof (PKT_LIST));
		pl = NULL;
		return (-1);
	}

	/* set node name */
	if (pl->opts[CD_HOSTNAME] != NULL) {
		doptp = pl->opts[CD_HOSTNAME];
		i = doptp->len;
		if (i >= SYS_NMLN) {
			cmn_err(CE_WARN, "dhcp: Hostname is too long");
		} else {
			bcopy(doptp->value, utsname.nodename, i);
			utsname.nodename[i] = '\0';
			if (dldebug) {
				printf("hostname is %s\n",
				    utsname.nodename);
			}
		}
	}

	/* Set NIS domain name. */
	p = NULL;
	if (pl->opts[CD_NIS_DOMAIN] != NULL) {
		doptp = pl->opts[CD_NIS_DOMAIN];
		i = doptp->len;
		p = (caddr_t)doptp->value;
	}
	if (p != NULL) {
		if (i > SYS_NMLN) {
			cmn_err(CE_WARN,
			    "dhcp: NIS domainname too long.");
		} else {
			bcopy(p, srpc_domain, i);
			srpc_domain[i] = '\0';
			if (dldebug)
				printf("dhcp: NIS domain name is %s\n",
				    srpc_domain);
		}
	}

	/* fetch netmask */
	if (pl->opts[CD_SUBNETMASK] != NULL) {
		doptp = pl->opts[CD_SUBNETMASK];
		if (doptp->len != sizeof (struct in_addr)) {
			pl->opts[CD_SUBNETMASK] = NULL;
			cmn_err(CE_WARN, "dhcp: netmask option malformed");
		} else {
			bcopy(doptp->value, &subnet, sizeof (struct in_addr));
			if (dldebug)
				printf("dhcp:  setting netmask to: %s\n",
				    inet_ntoa(subnet));
		}
	} else {
		struct in_addr myIPaddr;

		myIPaddr.s_addr = pl->pkt->yiaddr.s_addr;
		cmn_err(CE_WARN, "dhcp:  no subnet mask supplied - inferring");
		if (IN_CLASSA(ntohl(myIPaddr.s_addr)))
			subnet.s_addr = htonl(IN_CLASSA_NET);
		else if (IN_CLASSB(ntohl(myIPaddr.s_addr)))
			subnet.s_addr = htonl(IN_CLASSB_NET);
		else if (IN_CLASSC(ntohl(myIPaddr.s_addr)))
			subnet.s_addr = htonl(IN_CLASSC_NET);
		else if (IN_CLASSD(ntohl(myIPaddr.s_addr)))
			cmn_err(CE_WARN, "dhcp:  bad IP address (%s)",
			    inet_ntoa(myIPaddr));
		else
			subnet.s_addr = htonl(IN_CLASSE_NET);
	}
	/* and broadcast address */
	if (pl->opts[CD_BROADCASTADDR] != NULL) {
		doptp = pl->opts[CD_BROADCASTADDR];
		if (doptp->len != sizeof (struct in_addr)) {
			pl->opts[CD_BROADCASTADDR] = NULL;
			if (dldebug)
				printf("dhcp:  broadcast address len %d\n",
				    doptp->len);
		} else {
			bcopy(doptp->value, &braddr, sizeof (struct in_addr));
			if (dldebug)
				printf("dhcp:  setting broadcast addr to: %s\n",
				    inet_ntoa(braddr));
		}
	} else {
		if (dldebug)
			printf("dhcp:  no broadcast address supplied\n");
		braddr.s_addr = htonl(INADDR_BROADCAST);
	}
	/* and plumb and initialize interface */
	if ((rc = t_kopen((file_t *)NULL, dl_udp_netconf.knc_rdev,
	    FREAD|FWRITE, &tiptr, CRED())) == 0) {
		if (rc = dlifconfig(tiptr, &pl->pkt->yiaddr, &subnet,
		    &braddr, IFF_DHCPRUNNING)) {
			nfs_perror(