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

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

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#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 int		dl_info(ldi_handle_t, dl_info_ack_t *);
extern int		dl_attach(ldi_handle_t, int);
extern int		dl_bind(ldi_handle_t, uint32_t, uint32_t, uint32_t,
			    uint32_t);
extern int		dl_phys_addr(ldi_handle_t, struct ether_addr *);
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(rc, "dhcp: dlifconfig failed: %m\n");
			kmem_free(pl->pkt, pl->len);
			kmem_free(pl, sizeof (PKT_LIST));
			pl = NULL;
			(void) t_kclose(tiptr, 0);
			return (-1);
		}

		/* add routes */
		if (pl->opts[CD_ROUTER] != NULL) {
			doptp = pl->opts[CD_ROUTER];
			if ((doptp->len % sizeof (struct in_addr)) != 0) {
				pl->opts[CD_ROUTER] = NULL;
			} else {
				int nrouters;
				uchar_t *tp;

				nrouters = doptp->len / sizeof (struct in_addr);
				for (tp = doptp->value, i = 0; i < nrouters;
				    i++) {
					struct in_addr defr;
					struct rtentry	rtentry;

					bcopy(tp, &defr,
					    sizeof (struct in_addr));
					if (defr.s_addr == 0)
						continue;

					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 = defr;

					rtentry.rt_flags = RTF_GATEWAY | RTF_UP;

					if (rc = rtioctl(tiptr, SIOCADDRT,
					    &rtentry)) {
						nfs_perror(rc,
						    "dhcp: couldn't add route "
						    "to %s: %m.\n",
						    inet_ntoa(defr));
							continue;
					}
					if (dldebug) {
						printf("dhcp: added route %s\n",
						    inet_ntoa(defr));
					}
					tp += sizeof (struct in_addr);
				}
			}
		}

		(void) t_kclose(tiptr, 0);
	}

	if (dldebug)
		printf("dhcpinit: leaving\n");

	return (0);
}

/*
 * Initialize nfs mount info from properties and dhcp response.
 */
static void
cacheinit(void)
{
	char *str;
	DHCP_OPT *doptp;

	(void) ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
	    DDI_PROP_DONTPASS, BP_SERVER_PATH, &server_path_c);
	(void) ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
	    DDI_PROP_DONTPASS, BP_SERVER_NAME, &server_name_c);
	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
	    DDI_PROP_DONTPASS, BP_SERVER_ROOTOPTS, &str) == DDI_SUCCESS) {
		(void) strncpy(rootopts, str, 255);
		ddi_prop_free(str);
	}
	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
	    DDI_PROP_DONTPASS, BP_SERVER_IP, &str) == DDI_SUCCESS) {
		if (inet_aton(str, server_ip) != 0)
			cmn_err(CE_NOTE, "server_ipaddr %s is invalid\n",
			    str);
		ddi_prop_free(str);
		if (dldebug)
			printf("server ip is %s\n",
			    inet_ntoa(*(struct in_addr *)server_ip));
	}

	if (pl == NULL)
		return;

	/* extract root path in server_path */
	if (server_path_c == NULL) {
		doptp = pl->vs[VS_NFSMNT_ROOTPATH];
		if (doptp != NULL) {
			server_path_c = kmem_alloc(doptp->len + 1, KM_SLEEP);
			bcopy(doptp->value, server_path_c, doptp->len);
			server_path_c[doptp->len] = '\0';
			if (dldebug)
				printf("dhcp:  root path %s\n", server_path_c);
		} else {
			cmn_err(CE_WARN, "dhcp: root server path missing");
		}
	}

	/* set server_name */
	if (server_name_c == NULL) {
		doptp = pl->vs[VS_NFSMNT_ROOTSRVR_NAME];
		if (doptp != NULL) {
			server_name_c = kmem_alloc(doptp->len + 1, KM_SLEEP);
			bcopy(doptp->value, server_name_c, doptp->len);
			server_name_c[doptp->len] = '\0';
			if (dldebug)
				printf("dhcp: root server name %s\n",
				    server_name_c);
		} else {
			cmn_err(CE_WARN, "dhcp: root server name missing");
		}
	}

	/* set root server_address */
	if ((*(uint_t *)server_ip) == 0) {
		doptp = pl->vs[VS_NFSMNT_ROOTSRVR_IP];
		if (doptp) {
			bcopy(doptp->value, server_ip, sizeof (server_ip));
			if (dldebug) {
				printf("dhcp:  root server IP address %s\n",
				    inet_ntoa(*(struct in_addr *)server_ip));
			}
		} else {
			if (dldebug)
				cmn_err(CE_CONT,
				    "dhcp: file server ip address missing,"
				    " fallback to dhcp server as file server");
			bcopy(dhcp_server_ip, server_ip, sizeof (server_ip));
		}
	}

	/* set root file system mount options */
	if (rootopts[0] == 0) {
		doptp = pl->vs[VS_NFSMNT_ROOTOPTS];
		if (doptp != NULL && doptp->len < 255) {
			bcopy(doptp->value, rootopts, doptp->len);
			rootopts[doptp->len] = '\0';
			if (dldebug)
				printf("dhcp:  rootopts %s\n", rootopts);
		} else if (dldebug) {
			printf("dhcp:  no rootopts or too long\n");
			/* not an error */
		}
	}

	/* now we are done with pl, just free it */
	kmem_free(pl->pkt, pl->len);
	kmem_free(pl, sizeof (PKT_LIST));
	pl = NULL;
}

static int
cacheinfo(char *name, int namelen,
    struct netbuf *server_address, char *rootpath, int pathlen)
{
	static int init_done = 0;
	struct sockaddr_in *sin;

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

	/* server_path is a reliable indicator of cache availability */
	if (server_path_c == NULL)
		return (-1);

	(void) strncpy(rootpath, server_path_c, pathlen);
	if (server_name_c) {
		(void) strncpy(name, server_name_c, namelen);
	} else {
		(void) strncpy(name, "unknown", namelen);
	}

	sin = (struct sockaddr_in *)server_address->buf;
	sin->sin_family = AF_INET;
	server_address->len = sizeof (struct sockaddr_in);
	bcopy(server_ip, &sin->sin_addr, sizeof (struct in_addr));
	return (0);
}

/*
 *	Set this interface's IP address and netmask, and bring it up.
 */
static int
dlifconfig(TIUSER *tiptr, struct in_addr *myIPaddr, struct in_addr *mymask,
    struct in_addr *mybraddr, uint_t flags)
{
	int rc;
	struct netbuf sbuf;
	struct sockaddr_in sin;

	if (dldebug) {
		printf("dlifconfig:  entered\n");
		printf("dlifconfig:  addr %s\n", inet_ntoa(*myIPaddr));
		printf("dlifconfig:  mask %s\n", inet_ntoa(*mymask));
		printf("dlifconfig:  broadcast %s\n", inet_ntoa(*mybraddr));
	}

	bcopy(myIPaddr, &sin.sin_addr, sizeof (struct in_addr));
	sin.sin_family = AF_INET;
	sbuf.buf = (caddr_t)&sin;
	sbuf.maxlen = sbuf.len = sizeof (sin);
	if (rc = ifioctl(tiptr, SIOCSIFADDR, &sbuf)) {
		nfs_perror(rc,
		    "dlifconfig: couldn't set interface net address: %m\n");
		return (rc);
	}

	if (mybraddr->s_addr != INADDR_BROADCAST) {
		bcopy(mybraddr, &sin.sin_addr, sizeof (struct in_addr));
		sin.sin_family = AF_INET;
		sbuf.buf = (caddr_t)&sin;
		sbuf.maxlen = sbuf.len = sizeof (sin);
		if (rc = ifioctl(tiptr, SIOCSIFBRDADDR, &sbuf)) {
			nfs_perror(rc,
		    "dlifconfig: couldn't set interface broadcast addr: %m\n");
			return (rc);
		}
	}

	bcopy(mymask, &sin.sin_addr, sizeof (struct in_addr));
	sin.sin_family = AF_INET;
	sbuf.buf = (caddr_t)&sin;
	sbuf.maxlen = sbuf.len = sizeof (sin);
	if (rc = ifioctl(tiptr, SIOCSIFNETMASK, &sbuf)) {
		nfs_perror(rc,
		    "dlifconfig: couldn't set interface net address: %m\n");
		return (rc);
	}

	/*
	 * Now turn on the interface.
	 */
	if (rc = setifflags(tiptr, IFF_UP | flags)) {
		nfs_perror(rc,
		    "dlifconfig: couldn't enable network interface: %m\n");
		return (rc);
	}

	if (dldebug)
		printf("dlifconfig:  returned\n");
	return (0);
}

static char *
inet_ntoa(struct in_addr in)
{
	static char b[18];
	unsigned char *p;

	p = (unsigned char *)&in;
	(void) sprintf(b, "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
	return (b);
}

/* We only deal with a.b.c.d decimal format. ip points to 4 byte storage */
static int
inet_aton(char *ipstr, uchar_t *ip)
{
	int i = 0;
	uchar_t val[4] = {0};
	char c = *ipstr;

	for (;;) {
		if (!isdigit(c))
			return (-1);
		for (;;) {
			if (!isdigit(c))
				break;
			val[i] = val[i] * 10 + (c - '0');
			c = *++ipstr;
		}
		i++;
		if (i == 4)
			break;
		if (c != '.')
			return (-1);
		c = *++ipstr;
	}
	if (c != 0)
		return (-1);
	bcopy(val, ip, 4);
	return (0);
}

#define	MAX_ADDR_SIZE	128

/*
 * Initialize a netbuf suitable for
 * describing an address for the
 * transport defined by `tiptr'.
 */
static void
init_netbuf(struct netbuf *nbuf)
{
	nbuf->buf = kmem_zalloc(MAX_ADDR_SIZE, KM_SLEEP);
	nbuf->maxlen = MAX_ADDR_SIZE;
	nbuf->len = 0;
}

static void
free_netbuf(struct netbuf *nbuf)
{
	kmem_free(nbuf->buf, nbuf->maxlen);
	nbuf->buf = NULL;
	nbuf->maxlen = 0;
	nbuf->len = 0;
}

static int
rtioctl(TIUSER *tiptr, int cmd, struct rtentry *rtentry)
{
	struct strioctl iocb;
	int rc;
	vnode_t *vp;

	iocb.ic_cmd = cmd;
	iocb.ic_timout = 0;
	iocb.ic_len = sizeof (struct rtentry);
	iocb.ic_dp = (caddr_t)rtentry;

	vp = tiptr->fp->f_vnode;
	rc = kstr_ioctl(vp, I_STR, (intptr_t)&iocb);
	if (rc)
		nfs_perror(rc, "rtioctl: kstr_ioctl failed: %m\n");
	return (rc);
}

/*
 * Send an ioctl down the stream defined
 * by `tiptr'.
 *
 * We isolate the ifreq dependencies in here. The
 * ioctl really ought to take a netbuf and be of
 * type TRANSPARENT - one day.
 */
static int
ifioctl(TIUSER *tiptr, int cmd, struct netbuf *nbuf)
{
	struct strioctl iocb;
	int rc;
	vnode_t *vp;
	struct ifreq ifr;

	/*
	 * Now do the one requested.
	 */
	if (nbuf->len)
		ifr.ifr_addr = *(struct sockaddr *)nbuf->buf;
	(void) strncpy((caddr_t)&ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
	iocb.ic_cmd = cmd;
	iocb.ic_timout = 0;
	iocb.ic_len = sizeof (ifr);
	iocb.ic_dp = (caddr_t)&ifr;

	vp = tiptr->fp->f_vnode;
	rc = kstr_ioctl(vp, I_STR, (intptr_t)&iocb);
	if (rc) {
		nfs_perror(rc, "ifioctl: kstr_ioctl failed: %m\n");
		return (rc);
	}

	/*
	 * Set reply length.
	 */
	if (nbuf->len == 0) {
		/*
		 * GET type.
		 */
		nbuf->len = sizeof (struct sockaddr);
		*(struct sockaddr *)nbuf->buf = ifr.ifr_addr;
	}

	return (0);
}

static int
setifflags(TIUSER *tiptr, uint_t value)
{
	struct ifreq ifr;
	int rc;
	struct strioctl iocb;

	(void) strncpy((caddr_t)&ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
	iocb.ic_cmd = SIOCGIFFLAGS;
	iocb.ic_timout = 0;
	iocb.ic_len = sizeof (ifr);
	iocb.ic_dp = (caddr_t)&ifr;
	if (rc = kstr_ioctl(tiptr->fp->f_vnode, I_STR, (intptr_t)&iocb))
		return (rc);

	ifr.ifr_flags |= value;
	iocb.ic_cmd = SIOCSIFFLAGS;
	return (kstr_ioctl(tiptr->fp->f_vnode, I_STR, (intptr_t)&iocb));
}

/*
 * REVerse Address Resolution Protocol (revarp)
 * is used by a diskless client to find out its
 * IP address when all it knows is its Ethernet address.
 *
 * Open the ethernet driver, attach and bind
 * (DL_BIND_REQ) it, and then format a broadcast RARP
 * message for it to send. We pick up the reply and
 * let the caller set the interface address using SIOCSIFADDR.
 */
static int
revarp_myaddr(TIUSER *tiptr)
{
	int			rc;
	dl_info_ack_t		info;
	struct sockaddr_in	sin;
	struct netbuf		sbuf;
	ldi_handle_t		lh;
	ldi_ident_t		li;
	struct netbuf		myaddr = {0, 0, NULL};

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

	if (rc = ldi_ident_from_mod(&modlinkage, &li)) {
		nfs_perror(rc,
		    "revarp_myaddr: ldi_ident_from_mod failed: %m\n");
		return (rc);
	}

	rc = ldi_open_by_name(ndev_path, FREAD|FWRITE, CRED(), &lh, li);
	ldi_ident_release(li);
	if (rc) {
		nfs_perror(rc,
		    "revarp_myaddr: ldi_open_by_name failed: %m\n");
		return (rc);
	}

	if (rc = dl_attach(lh, ifunit)) {
		nfs_perror(rc, "revarp_myaddr: dl_attach failed: %m\n");
		(void) ldi_close(lh, FREAD|FWRITE, CRED());
		return (rc);
	}

	if (rc = dl_bind(lh, ETHERTYPE_REVARP, 0, DL_CLDLS, 0)) {
		nfs_perror(rc, "revarp_myaddr: dl_bind failed: %m\n");
		(void) ldi_close(lh, FREAD|FWRITE, CRED());
		return (rc);
	}

	if (rc = dl_info(lh, &info)) {
		nfs_perror(rc, "revarp_myaddr: dl_info failed: %m\n");
		(void) ldi_close(lh, FREAD|FWRITE, CRED());
		return (rc);
	}

	/* Initialize myaddr */
	myaddr.maxlen = info.dl_addr_length;
	myaddr.buf = kmem_alloc(myaddr.maxlen, KM_SLEEP);

	revarp_start(lh, &myaddr);

	bcopy(myaddr.buf, &sin.sin_addr, myaddr.len);
	sin.sin_family = AF_INET;

	sbuf.buf = (caddr_t)&sin;
	sbuf.maxlen = sbuf.len = sizeof (sin);
	if (rc = ifioctl(tiptr, SIOCSIFADDR, &sbuf)) {
		nfs_perror(rc,
		    "revarp_myaddr: couldn't set interface net address: %m\n");
		(void) ldi_close(lh, FREAD|FWRITE, CRED());
		kmem_free(myaddr.buf, myaddr.maxlen);
		return (rc);
	}

	/* Now turn on the interface */
	if (rc = setifflags(tiptr, IFF_UP)) {
		nfs_perror(rc,
		    "revarp_myaddr: couldn't enable network interface: %m\n");
	}

	(void) ldi_close(lh, FREAD|FWRITE, CRED());
	kmem_free(myaddr.buf, myaddr.maxlen);
	return (rc);
}

static void
revarp_start(ldi_handle_t lh, struct netbuf *myaddr)
{
	struct ether_arp *ea;
	int rc;
	dl_unitdata_req_t *dl_udata;
	mblk_t *bp;
	mblk_t *mp;
	struct dladdr *dlsap;
	static int done = 0;

	if (dl_phys_addr(lh, &myether) != 0) {
		/* Fallback using per-node address */
		(void) localetheraddr((struct ether_addr *)NULL, &myether);
		cmn_err(CE_CONT, "?DLPI failed to get Ethernet address. Using "
		    "system wide Ethernet address %s\n",
		    ether_sprintf(&myether));
	}

getreply:
	if (myaddr->len != 0) {
		cmn_err(CE_CONT, "?Found my IP address: %x (%d.%d.%d.%d)\n",
		    *(int *)myaddr->buf,
		    (uchar_t)myaddr->buf[0], (uchar_t)myaddr->buf[1],
		    (uchar_t)myaddr->buf[2], (uchar_t)myaddr->buf[3]);
		return;
	}

	if (done++ == 0)
		cmn_err(CE_CONT, "?Requesting Internet address for %s\n",
		    ether_sprintf(&myether));

	/*
	 * Send another RARP request.
	 */
	if ((mp = allocb(sizeof (dl_unitdata_req_t) + sizeof (*dlsap),
	    BPRI_HI)) == NULL) {
		cmn_err(CE_WARN, "revarp_myaddr: allocb no memory");
		return;
	}
	if ((bp = allocb(sizeof (struct ether_arp), BPRI_HI)) == NULL) {
		cmn_err(CE_WARN, "revarp_myaddr: allocb no memory");
		return;
	}

	/*
	 * Format the transmit request part.
	 */
	mp->b_datap->db_type = M_PROTO;
	dl_udata = (dl_unitdata_req_t *)mp->b_wptr;
	mp->b_wptr += sizeof (dl_unitdata_req_t) + sizeof (*dlsap);
	dl_udata->dl_primitive = DL_UNITDATA_REQ;
	dl_udata->dl_dest_addr_length = sizeof (*dlsap);
	dl_udata->dl_dest_addr_offset = sizeof (*dl_udata);
	dl_udata->dl_priority.dl_min = 0;
	dl_udata->dl_priority.dl_max = 0;

	dlsap = (struct dladdr *)(mp->b_rptr + sizeof (*dl_udata));
	bcopy(&etherbroadcastaddr, &dlsap->dl_phys,
	    sizeof (etherbroadcastaddr));
	dlsap->dl_sap = ETHERTYPE_REVARP;

	/*
	 * Format the actual REVARP request.
	 */
	bzero(bp->b_wptr, sizeof (struct ether_arp));
	ea = (struct ether_arp *)bp->b_wptr;
	bp->b_wptr += sizeof (struct ether_arp);
	ea->arp_hrd = htons(ARPHRD_ETHER);
	ea->arp_pro = htons(ETHERTYPE_IP);
	ea->arp_hln = sizeof (ea->arp_sha);	/* hardware address length */
	ea->arp_pln = sizeof (ea->arp_spa);	/* protocol address length */
	ea->arp_op = htons(REVARP_REQUEST);
	ether_copy(&myether, &ea->arp_sha);
	ether_copy(&myether, &ea->arp_tha);

	mp->b_cont = bp;

	if ((rc = ldi_putmsg(lh, mp)) != 0) {
		nfs_perror(rc, "revarp_start: ldi_putmsg failed: %m\n");
		return;
	}
	revarpinput(lh, myaddr);

	goto getreply;
}

/*
 * Client side Reverse-ARP input
 * Server side is handled by user level server
 */
static void
revarpinput(ldi_handle_t lh, struct netbuf *myaddr)
{
	struct ether_arp *ea;
	mblk_t *bp;
	mblk_t *mp;
	int rc;
	timestruc_t tv, give_up, now;

	/*
	 * Choose the time at which we will give up, and resend our
	 * request.
	 */
	gethrestime(&give_up);
	give_up.tv_sec += REVARP_TIMEO;
wait:
	/*
	 * Compute new timeout value.
	 */
	tv = give_up;
	gethrestime(&now);
	timespecsub(&tv, &now);
	/*
	 * If we don't have at least one full second remaining, give up.
	 * This means we might wait only just over 4.0 seconds, but that's
	 * okay.
	 */
	if (tv.tv_sec <= 0)
		return;
	rc = ldi_getmsg(lh, &mp, &tv);
	if (rc == ETIME) {
		goto out;
	} else if (rc != 0) {
		nfs_perror(rc, "revarpinput: ldi_getmsg failed: %m\n");
		return;
	}

	if (mp->b_cont == NULL) {
		printf("revarpinput: b_cont == NULL\n");
		goto out;
	}

	if (mp->b_datap->db_type != M_PROTO) {
		printf("revarpinput: bad header type %d\n",
		    mp->b_datap->db_type);
		goto out;
	}

	bp = mp->b_cont;

	if (bp->b_wptr - bp->b_rptr < sizeof (*ea)) {
		printf("revarpinput: bad data len %d, expect %d\n",
		    (int)(bp->b_wptr - bp->b_rptr),  (int)sizeof (*ea));
		goto out;
	}

	ea = (struct ether_arp *)bp->b_rptr;

	if ((ushort_t)ntohs(ea->arp_pro) != ETHERTYPE_IP) {
		/* We could have received another broadcast arp packet. */
		if (dldebug)
			printf("revarpinput: bad type %x\n",
			    (ushort_t)ntohs(ea->arp_pro));
		freemsg(mp);
		goto wait;
	}
	if ((ushort_t)ntohs(ea->arp_op) != REVARP_REPLY) {
		/* We could have received a broadcast arp request. */
		if (dldebug)
			printf("revarpinput: bad op %x\n",
			    (ushort_t)ntohs(ea->arp_op));
		freemsg(mp);
		goto wait;
	}

	if (!ether_cmp(&ea->arp_tha, &myether)) {
		bcopy(&ea->arp_tpa, myaddr->buf, sizeof (ea->arp_tpa));
		myaddr->len = sizeof (ea->arp_tpa);
	} else {
		/* We could have gotten a broadcast arp response. */
		if (dldebug)
			printf("revarpinput: got reply, but not my address\n");
		freemsg(mp);
		goto wait;
	}
out:
	freemsg(mp);
}

/*
 * From rpcsvc/mountxdr.c in SunOS. We can't
 * put this into the rpc directory because
 * it calls xdr_fhandle() which is in a
 * loadable module.
 */
static bool_t
myxdr_fhstatus(XDR *xdrs, struct fhstatus *fhsp)
{

	if (!xdr_int(xdrs, &fhsp->fhs_status))
		return (FALSE);
	if (fhsp->fhs_status == 0) {
		if (!myxdr_fhandle(xdrs, &fhsp->fhs_fh))
			return (FALSE);
	}
	return (TRUE);
}

/*
 * From nfs_xdr.c.
 *
 * File access handle
 * The fhandle struct is treated a opaque data on the wire
 */
static bool_t
myxdr_fhandle(XDR *xdrs, fhandle_t *fh)
{
	return (xdr_opaque(xdrs, (caddr_t)fh, NFS_FHSIZE));
}

static bool_t
myxdr_mountres3(XDR *xdrs, struct mountres3 *objp)
{
	if (!myxdr_mountstat3(xdrs, &objp->fhs_status))
		return (FALSE);
	switch (objp->fhs_status) {
	case MNT_OK:
		if (!myxdr_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo))
			return (FALSE);
		break;
	default:
		break;
	}
	return (TRUE);
}

static bool_t
myxdr_mountstat3(XDR *xdrs, enum mountstat3 *objp)
{
	return (xdr_enum(xdrs, (enum_t *)objp));
}

static bool_t
myxdr_mountres3_ok(XDR *xdrs, struct mountres3_ok *objp)
{
	if (!myxdr_fhandle3(xdrs, &objp->fhandle))
		return (FALSE);
	if (!xdr_array(xdrs, (char **)&objp->auth_flavors.auth_flavors_val,
	    (uint_t *)&objp->auth_flavors.auth_flavors_len, ~0,
	    sizeof (int), (xdrproc_t)xdr_int))
		return (FALSE);
	return (TRUE);
}

static bool_t
myxdr_fhandle3(XDR *xdrs, struct fhandle3 *objp)
{
	return (xdr_bytes(xdrs, (char **)&objp->fhandle3_val,
	    (uint_t *)&objp->fhandle3_len, FHSIZE3));
}

/*
 * From SunOS pmap_clnt.c
 *
 * Port mapper routines:
 *	pmap_kgetport() - get port number.
 *	pmap_rmt_call()  - indirect call via port mapper.
 *
 */
static enum clnt_stat
pmap_kgetport(struct knetconfig *knconf, struct netbuf *call_addr,
	rpcprog_t prog, rpcvers_t vers, rpcprot_t prot)
{
	ushort_t port;
	int tries;
	enum clnt_stat stat;
	struct pmap	pmap_parms;
	RPCB		rpcb_parms;
	char		*ua = NULL;

	port = 0;

	((struct sockaddr_in *)call_addr->buf)->sin_port = htons(PMAPPORT);

	pmap_parms.pm_prog = prog;
	pmap_parms.pm_vers = vers;
	pmap_parms.pm_prot = prot;
	pmap_parms.pm_port = 0;
	for (tries = 0; tries < 5; tries++) {
		stat = mycallrpc(knconf, call_addr,
		    PMAPPROG, PMAPVERS, PMAPPROC_GETPORT,
		    myxdr_pmap, (char *)&pmap_parms,
		    xdr_u_short, (char *)&port,
		    DEFAULT_TIMEO, DEFAULT_RETRIES);

		if (stat != RPC_TIMEDOUT)
			break;
		cmn_err(CE_WARN,
		    "pmap_kgetport: Portmapper not responding; still trying");
	}

	if (stat == RPC_PROGUNAVAIL) {
		cmn_err(CE_WARN,
		    "pmap_kgetport: Portmapper failed - trying rpcbind");

		rpcb_parms.r_prog = prog;
		rpcb_parms.r_vers = vers;
		rpcb_parms.r_netid = knconf->knc_proto;
		rpcb_parms.r_addr = rpcb_parms.r_owner = "";

		for (tries = 0; tries < 5; tries++) {
			stat = mycallrpc(knconf, call_addr,
			    RPCBPROG, RPCBVERS, RPCBPROC_GETADDR,
			    xdr_rpcb, (char *)&rpcb_parms,
			    xdr_wrapstring, (char *)&ua,
			    DEFAULT_TIMEO, DEFAULT_RETRIES);

			if (stat != RPC_TIMEDOUT)
				break;
			cmn_err(CE_WARN,
			"pmap_kgetport: rpcbind not responding; still trying");
		}

		if (stat == RPC_SUCCESS) {
			if ((ua != NULL) && (ua[0] != NULL)) {
				port = rpc_uaddr2port(AF_INET, ua);
			} else {
				/* Address unknown */
				stat = RPC_PROGUNAVAIL;
			}
		}
	}

	if (stat == RPC_SUCCESS)
		((struct sockaddr_in *)call_addr->buf)->sin_port = ntohs(port);

	return (stat);
}

/*
 * pmapper remote-call-service interface.
 * This routine is used to call the pmapper remote call service
 * which will look up a service program in the port maps, and then
 * remotely call that routine with the given parameters.  This allows
 * programs to do a lookup and call in one step. In addition to the call_addr,
 * the caller provides a boolean hint about the destination address (TRUE if
 * address is a broadcast address, FALSE otherwise).
 *
 * On return, `call addr' contains the port number for the
 * service requested, and `resp_addr' contains its IP address.
 */
static enum clnt_stat
pmap_rmt_call(struct knetconfig *knconf, struct netbuf *call_addr,
	bool_t bcast, rpcprog_t progn, rpcvers_t versn, rpcproc_t procn,
	xdrproc_t xdrargs, caddr_t argsp, xdrproc_t xdrres, caddr_t resp,
	struct timeval tout, struct netbuf *resp_addr)
{
	CLIENT *cl;
	enum clnt_stat stat;
	rpcport_t port;
	int rc;
	struct rmtcallargs	pmap_args;
	struct rmtcallres	pmap_res;
	struct rpcb_rmtcallargs	rpcb_args;
	struct rpcb_rmtcallres	rpcb_res;
	char			ua[100];	/* XXX */

	((struct sockaddr_in *)call_addr->buf)->sin_port = htons(PMAPPORT);

	rc = clnt_tli_kcreate(knconf, call_addr, PMAPPROG, PMAPVERS,
	    0, PMAP_RETRIES, CRED(), &cl);
	if (rc != 0) {
		nfs_perror(rc,
		    "pmap_rmt_call: clnt_tli_kcreate failed: %m\n");
		return (RPC_SYSTEMERROR);	/* XXX */
	}
	if (cl == (CLIENT *)NULL) {
		panic("pmap_rmt_call: clnt_tli_kcreate failed");
		/* NOTREACHED */
	}

	(void) CLNT_CONTROL(cl, CLSET_BCAST, (char *)&bcast);

	pmap_args.prog = progn;
	pmap_args.vers = versn;
	pmap_args.proc = procn;
	pmap_args.args_ptr = argsp;
	pmap_args.xdr_args = xdrargs;
	pmap_res.port_ptr = &port;
	pmap_res.results_ptr = resp;
	pmap_res.xdr_results = xdrres;
	stat = clnt_clts_kcallit_addr(cl, PMAPPROC_CALLIT,
	    myxdr_rmtcall_args, (caddr_t)&pmap_args,
	    myxdr_rmtcallres, (caddr_t)&pmap_res,
	    tout, resp_addr);

	if (stat == RPC_SUCCESS) {
		((struct sockaddr_in *)resp_addr->buf)->sin_port =
		    htons((ushort_t)port);
	}
	CLNT_DESTROY(cl);

	if (stat != RPC_PROGUNAVAIL)
		return (stat);

	cmn_err(CE_WARN, "pmap_rmt_call: Portmapper failed - trying rpcbind");

	rc = clnt_tli_kcreate(knconf, call_addr, RPCBPROG, RPCBVERS,
	    0, PMAP_RETRIES, CRED(), &cl);
	if (rc != 0) {
		nfs_perror(rc, "pmap_rmt_call: clnt_tli_kcreate failed: %m\n");
		return (RPC_SYSTEMERROR);	/* XXX */
	}

	if (cl == NULL) {
		panic("pmap_rmt_call: clnt_tli_kcreate failed");
		/* NOTREACHED */
	}

	rpcb_args.prog = progn;
	rpcb_args.vers = versn;
	rpcb_args.proc = procn;
	rpcb_args.args_ptr = argsp;
	rpcb_args.xdr_args = xdrargs;
	rpcb_res.addr_ptr = ua;
	rpcb_res.results_ptr = resp;
	rpcb_res.xdr_results = xdrres;
	stat = clnt_clts_kcallit_addr(cl, PMAPPROC_CALLIT,
	    xdr_rpcb_rmtcallargs, (caddr_t)&rpcb_args,
	    xdr_rpcb_rmtcallres, (caddr_t)&rpcb_res,
	    tout, resp_addr);

	if (stat == RPC_SUCCESS)
		((struct sockaddr_in *)resp_addr->buf)->sin_port =
		    rpc_uaddr2port(AF_INET, ua);
	CLNT_DESTROY(cl);

	return (stat);
}

/*
 * XDR remote call arguments
 * written for XDR_ENCODE direction only
 */
static bool_t
myxdr_rmtcall_args(XDR *xdrs, struct rmtcallargs *cap)
{
	uint_t lenposition;
	uint_t argposition;
	uint_t position;

	if (xdr_rpcprog(xdrs, &(cap->prog)) &&
	    xdr_rpcvers(xdrs, &(cap->vers)) &&
	    xdr_rpcproc(xdrs, &(cap->proc))) {
		lenposition = XDR_GETPOS(xdrs);
		if (!xdr_u_int(xdrs, &cap->arglen))
			return (FALSE);
		argposition = XDR_GETPOS(xdrs);
		if (!(*(cap->xdr_args))(xdrs, cap->args_ptr))
			return (FALSE);
		position = XDR_GETPOS(xdrs);
		cap->arglen = (uint_t)position - (uint_t)argposition;
		XDR_SETPOS(xdrs, lenposition);
		if (!xdr_u_int(xdrs, &cap->arglen))
			return (FALSE);
		XDR_SETPOS(xdrs, position);
		return (TRUE);
	}
	return (FALSE);
}

/*
 * XDR remote call results
 * written for XDR_DECODE direction only
 */
static bool_t
myxdr_rmtcallres(XDR *xdrs, struct rmtcallres *crp)
{
	caddr_t port_ptr;

	port_ptr = (caddr_t)crp->port_ptr;
	if (xdr_reference(xdrs, &port_ptr, sizeof (uint_t), xdr_u_int) &&
	    xdr_u_int(xdrs, &crp->resultslen)) {
		crp->port_ptr = (rpcport_t *)port_ptr;
		return ((*(crp->xdr_results))(xdrs, crp->results_ptr));
	}
	return (FALSE);
}

static bool_t
myxdr_pmap(XDR *xdrs, struct pmap *regs)
{
	if (xdr_rpcprog(xdrs, &regs->pm_prog) &&
	    xdr_rpcvers(xdrs, &regs->pm_vers) &&
	    xdr_rpcprot(xdrs, &regs->pm_prot))
		return (xdr_rpcport(xdrs, &regs->pm_port));

	return (FALSE);
}


/*
 * From SunOS callrpc.c
 */
static enum clnt_stat
mycallrpc(struct knetconfig *knconf, struct netbuf *call_addr,
	rpcprog_t prognum, rpcvers_t versnum, rpcproc_t procnum,
	xdrproc_t inproc, char *in, xdrproc_t outproc, char *out,
	int timeo, int retries)
{
	CLIENT *cl;
	struct timeval tv;
	enum clnt_stat cl_stat;
	int rc;

	rc = clnt_tli_kcreate(knconf, call_addr, prognum, versnum,
	    0, retries, CRED(), &cl);
	if (rc) {
		nfs_perror(rc, "mycallrpc: clnt_tli_kcreate failed: %m\n");
		return (RPC_SYSTEMERROR);	/* XXX */
	}
	tv.tv_sec = timeo;
	tv.tv_usec = 0;
	cl_stat = CLNT_CALL(cl, procnum, inproc, in, outproc, out, tv);
	AUTH_DESTROY(cl->cl_auth);
	CLNT_DESTROY(cl);
	return (cl_stat);
}

static int
dl_info(ldi_handle_t lh, dl_info_ack_t *info)
{
	dl_info_req_t *info_req;
	dl_error_ack_t *error_ack;
	union DL_primitives *dl_prim;
	mblk_t *mp;
	int error;

	if ((mp = allocb(sizeof (dl_info_req_t), BPRI_MED)) == NULL) {
		cmn_err(CE_WARN, "dl_info: allocb failed");
		return (ENOSR);
	}
	mp->b_datap->db_type = M_PROTO;

	info_req = (dl_info_req_t *)mp->b_wptr;
	mp->b_wptr += sizeof (dl_info_req_t);
	info_req->dl_primitive = DL_INFO_REQ;

	(void) ldi_putmsg(lh, mp);
	if ((error = ldi_getmsg(lh, &mp, (timestruc_t *)NULL)) != 0) {
		nfs_perror(error, "dl_info: ldi_getmsg failed: %m\n");
		return (error);
	}

	dl_prim = (union DL_primitives *)mp->b_rptr;
	switch (dl_prim->dl_primitive) {
	case DL_INFO_ACK:
		if ((mp->b_wptr-mp->b_rptr) < sizeof (dl_info_ack_t)) {
			printf("dl_info: DL_INFO_ACK protocol error\n");
			break;
		}
		*info = *(dl_info_ack_t *)mp->b_rptr;
		freemsg(mp);
		return (0);

	case DL_ERROR_ACK:
		if ((mp->b_wptr-mp->b_rptr) < sizeof (dl_error_ack_t)) {
			printf("dl_info: DL_ERROR_ACK protocol error\n");
			break;
		}

		error_ack = (dl_error_ack_t *)dl_prim;
		printf("dl_info: DLPI error %u\n", error_ack->dl_errno);
		break;

	default:
		printf("dl_bind: bad ACK header %u\n", dl_prim->dl_primitive);
		break;
	}

	/*
	 * Error return only.
	 */
	freemsg(mp);
	return (-1);
}

/*
 * Configure the 'default' interface based on existing boot properties.
 */
static int
bp_netconfig(void)
{
	char *str;
	struct in_addr my_ip, my_netmask, my_router, my_broadcast;
	struct sockaddr_in *sin;
	TIUSER *tiptr;
	int rc;
	struct rtentry rtentry;

	my_ip.s_addr = my_netmask.s_addr = my_router.s_addr = 0;

	/*
	 * No way of getting this right now.  Collude with dlifconfig()
	 * to let the protocol stack choose.
	 */
	my_broadcast.s_addr = INADDR_BROADCAST;

	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
	    DDI_PROP_DONTPASS, BP_HOST_IP, &str) == DDI_SUCCESS) {
		if (inet_aton(str, (uchar_t *)&my_ip) != 0)
			cmn_err(CE_NOTE, "host-ip %s is invalid\n",
			    str);
		ddi_prop_free(str);
		if (dldebug)
			printf("host ip is %s\n",
			    inet_ntoa(my_ip));
	}
	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
	    DDI_PROP_DONTPASS, BP_SUBNET_MASK, &str) == DDI_SUCCESS) {
		if (inet_aton(str, (uchar_t *)&my_netmask) != 0)
			cmn_err(CE_NOTE, "subnet-mask %s is invalid\n",
			    str);
		ddi_prop_free(str);
		if (dldebug)
			printf("subnet mask is %s\n",
			    inet_ntoa(my_netmask));
	}
	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
	    DDI_PROP_DONTPASS, BP_ROUTER_IP, &str) == DDI_SUCCESS) {
		if (inet_aton(str, (uchar_t *)&my_router) != 0)
			cmn_err(CE_NOTE, "router-ip %s is invalid\n",
			    str);
		ddi_prop_free(str);
		if (dldebug)
			printf("router ip is %s\n",
			    inet_ntoa(my_router));
	}
	(void) ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
	    DDI_PROP_DONTPASS, BP_SERVER_PATH, &server_path_c);
	(void) ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
	    DDI_PROP_DONTPASS, BP_SERVER_NAME, &server_name_c);
	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
	    DDI_PROP_DONTPASS, BP_SERVER_ROOTOPTS, &str) == DDI_SUCCESS) {
		(void) strlcpy(rootopts, str, sizeof (rootopts));
		ddi_prop_free(str);
	}
	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
	    DDI_PROP_DONTPASS, BP_SERVER_IP, &str) == DDI_SUCCESS) {
		if (inet_aton(str, server_ip) != 0)
			cmn_err(CE_NOTE, "server-ip %s is invalid\n",
			    str);
		ddi_prop_free(str);
		if (dldebug)
			printf("server ip is %s\n",
			    inet_ntoa(*(struct in_addr *)server_ip));
	}

	/*
	 * We need all of these to configure based on properties.
	 */
	if ((my_ip.s_addr == 0) ||
	    (my_netmask.s_addr == 0) ||
	    (server_path_c == NULL) ||
	    (server_name_c == NULL) ||
	    (*(uint_t *)server_ip == 0))
		return (-1);

	cmn_err(CE_CONT, "?IP address: %s\n", inet_ntoa(my_ip));
	cmn_err(CE_CONT, "?IP netmask: %s\n", inet_ntoa(my_netmask));
	if (my_router.s_addr != 0)
		cmn_err(CE_CONT, "?IP router: %s\n", inet_ntoa(my_router));
	cmn_err(CE_CONT, "?NFS server: %s (%s)\n", server_name_c,
	    inet_ntoa(*(struct in_addr *)server_ip));
	cmn_err(CE_CONT, "?NFS path: %s\n", server_path_c);

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

	if ((rc = dlifconfig(tiptr, &my_ip, &my_netmask, &my_broadcast,
	    0)) < 0) {
		nfs_perror(rc, "bp_netconfig: dlifconfig failed: %m.\n");
		(void) t_kclose(tiptr, 0);
		return (rc);
	}

	if (my_router.s_addr != 0) {
		/*
		 * Add a default route.
		 */
		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 = my_router;

		rtentry.rt_flags = RTF_GATEWAY | RTF_UP;

		if ((rc = rtioctl(tiptr, SIOCADDRT, &rtentry)) != 0) {
			nfs_perror(rc,
			    "bp_netconfig: couldn't add route: %m.\n");
			(void) t_kclose(tiptr, 0);
			return (rc);
		}
	}

	(void) t_kclose(tiptr, 0);

	return (0);
}

/*
 * The network device we will use to boot from is plumbed. Extract the details
 * from rootfs.
 */
static void
init_config(void)
{
	(void) strlcpy(ndev_path, rootfs.bo_devname, sizeof (ndev_path));
	(void) strlcpy(ifname, rootfs.bo_ifname, sizeof (ifname));
	ifunit = rootfs.bo_ppa;

	/*
	 * Assumes only one linkage array element.
	 */
	dl_udp_netconf.knc_rdev =
	    makedevice(clone_major, ddi_name_to_major("udp"));
	dl_tcp_netconf.knc_rdev =
	    makedevice(clone_major, ddi_name_to_major("tcp"));

	/*
	 * Now we bringup the interface.
	 * Try cached dhcp response first. If it fails, do rarp.
	 */
	if ((bp_netconfig() != 0) &&
	    (dhcpinit() != 0) &&
	    (whoami() != 0))
		cmn_err(CE_WARN,
		    "%s: no response from interface", ifname);
	else if (dldebug)
		printf("init_config: ifname %s is up\n", ifname);
}

/*
 * These options are duplicated in cmd/fs.d/nfs/mount/mount.c
 * Changes must be made to both lists.
 */
static char *optlist[] = {
#define	OPT_RO		0
	MNTOPT_RO,
#define	OPT_RW		1
	MNTOPT_RW,
#define	OPT_QUOTA	2
	MNTOPT_QUOTA,
#define	OPT_NOQUOTA	3
	MNTOPT_NOQUOTA,
#define	OPT_SOFT	4
	MNTOPT_SOFT,
#define	OPT_HARD	5
	MNTOPT_HARD,
#define	OPT_SUID	6
	MNTOPT_SUID,
#define	OPT_NOSUID	7
	MNTOPT_NOSUID,
#define	OPT_GRPID	8
	MNTOPT_GRPID,
#define	OPT_REMOUNT	9
	MNTOPT_REMOUNT,
#define	OPT_NOSUB	10
	MNTOPT_NOSUB,
#define	OPT_INTR	11
	MNTOPT_INTR,
#define	OPT_NOINTR	12
	MNTOPT_NOINTR,
#define	OPT_PORT	13
	MNTOPT_PORT,
#define	OPT_SECURE	14
	MNTOPT_SECURE,
#define	OPT_RSIZE	15
	MNTOPT_RSIZE,
#define	OPT_WSIZE	16
	MNTOPT_WSIZE,
#define	OPT_TIMEO	17
	MNTOPT_TIMEO,
#define	OPT_RETRANS	18
	MNTOPT_RETRANS,
#define	OPT_ACTIMEO	19
	MNTOPT_ACTIMEO,
#define	OPT_ACREGMIN	20
	MNTOPT_ACREGMIN,
#define	OPT_ACREGMAX	21
	MNTOPT_ACREGMAX,
#define	OPT_ACDIRMIN	22
	MNTOPT_ACDIRMIN,
#define	OPT_ACDIRMAX	23
	MNTOPT_ACDIRMAX,
#define	OPT_BG		24
	MNTOPT_BG,
#define	OPT_FG		25
	MNTOPT_FG,
#define	OPT_RETRY	26
	MNTOPT_RETRY,
#define	OPT_NOAC	27
	MNTOPT_NOAC,
#define	OPT_NOCTO	28
	MNTOPT_NOCTO,
#define	OPT_LLOCK	29
	MNTOPT_LLOCK,
#define	OPT_POSIX	30
	MNTOPT_POSIX,
#define	OPT_VERS	31
	MNTOPT_VERS,
#define	OPT_PROTO	32
	MNTOPT_PROTO,
#define	OPT_SEMISOFT	33
	MNTOPT_SEMISOFT,
#define	OPT_NOPRINT	34
	MNTOPT_NOPRINT,
#define	OPT_SEC		35
	MNTOPT_SEC,
#define	OPT_LARGEFILES	36
	MNTOPT_LARGEFILES,
#define	OPT_NOLARGEFILES	37
	MNTOPT_NOLARGEFILES,
#define	OPT_PUBLIC	38
	MNTOPT_PUBLIC,
#define	OPT_DIRECTIO	39
	MNTOPT_FORCEDIRECTIO,
#define	OPT_NODIRECTIO	40
	MNTOPT_NOFORCEDIRECTIO,
#define	OPT_XATTR	41
	MNTOPT_XATTR,
#define	OPT_NOXATTR	42
	MNTOPT_NOXATTR,
#define	OPT_DEVICES	43
	MNTOPT_DEVICES,
#define	OPT_NODEVICES	44
	MNTOPT_NODEVICES,
#define	OPT_SETUID	45
	MNTOPT_SETUID,
#define	OPT_NOSETUID	46
	MNTOPT_NOSETUID,
#define	OPT_EXEC	47
	MNTOPT_EXEC,
#define	OPT_NOEXEC	48
	MNTOPT_NOEXEC,
	NULL
};

static int
isdigit(int ch)
{
	return (ch >= '0' && ch <= '9');
}

#define	isspace(c)	((c) == ' ' || (c) == '\t' || (c) == '\n')
#define	bad(val)	(val == NULL || !isdigit(*val))

static int
atoi(const char *p)
{
	int n;
	int c, neg = 0;

	if (!isdigit(c = *p)) {
		while (isspace(c))
			c = *++p;
		switch (c) {
		case '-':
			neg++;
			/* FALLTHROUGH */
		case '+':
			c = *++p;
		}
		if (!isdigit(c))
			return (0);
	}
	for (n = '0' - c; isdigit(c = *++p); ) {
		n *= 10; /* two steps to avoid unnecessary overflow */
		n += '0' - c; /* accum neg to avoid surprises at MAX */
	}
	return (neg ? n : -n);
}

/*
 * Default root read tsize XXX
 */
int nfs_root_rsize = 8 * 1024;		/* conservative for dumb NICs */
int nfs4_root_rsize = 32 * 1024;	/* only runs on TCP be aggressive */

/*
 * Default flags: NFSMNT_NOCTO|NFSMNT_LLOCK|NFSMNT_INT
 */
int nfs_rootopts = NFSMNT_NOCTO|NFSMNT_LLOCK|NFSMNT_INT;

static int
init_mountopts(struct nfs_args *args, int version, struct knetconfig **dl_cf,
						int *vfsflags)
{
	char servername[SYS_NMLN];
	static int first = 0;
	struct netbuf server_address;
	char *opts, *val;
	int vers;
	struct knetconfig *cf = *dl_cf;
	char rootoptsbuf[256];

	/*
	 * Set default mount options
	 */
	args->flags = nfs_rootopts;
	args->rsize = 0;
	args->flags |= NFSMNT_ACREGMIN;
	args->acregmin = ACMINMAX;
	args->flags |= NFSMNT_ACREGMAX;
	args->acregmax = ACMAXMAX;
	args->flags |= NFSMNT_ACDIRMIN;
	args->acdirmin = ACMINMAX;
	args->flags |= NFSMNT_ACDIRMAX;
	args->acdirmax = ACMAXMAX;

	*vfsflags = 0;

	/*
	 * Only look up the rootopts the first time, we store this in
	 * a static buffer but we are guaranteed to be single threaded
	 * and not reentrant.
	 */
	if (first == 0) {
		first++;

		init_netbuf(&server_address);

		if (getfile("rootopts", servername, &server_address,
		    rootopts)) {
			rootopts[0] = '\0';
			free_netbuf(&server_address);
			goto sanity;
		}
		free_netbuf(&server_address);
	}

	if (dldebug)
		printf("rootopts = %s\n", rootopts);

	/*
	 * We have to preserve rootopts for second time.
	 */
	(void) strncpy(rootoptsbuf, rootopts, sizeof (rootoptsbuf));
	rootoptsbuf[sizeof (rootoptsbuf) - 1] = '\0';
	opts = rootoptsbuf;
	while (*opts) {
		int opt;

		switch (opt = getsubopt(&opts, optlist, &val)) {
		/*
		 * Options that are defaults or meaningless so ignored
		 */
		case OPT_QUOTA:
		case OPT_NOQUOTA:
		case OPT_SUID:
		case OPT_DEVICES:
		case OPT_SETUID:
		case OPT_BG:
		case OPT_FG:
		case OPT_RETRY:
		case OPT_POSIX:
		case OPT_LARGEFILES:
		case OPT_XATTR:
		case OPT_NOXATTR:
		case OPT_EXEC:
			break;
		case OPT_RO:
			*vfsflags |= MS_RDONLY;
			break;
		case OPT_RW:
			*vfsflags &= ~(MS_RDONLY);
			break;
		case OPT_SOFT:
			args->flags |= NFSMNT_SOFT;
			args->flags &= ~(NFSMNT_SEMISOFT);
			break;
		case OPT_SEMISOFT:
			args->flags |= NFSMNT_SOFT;
			args->flags |= NFSMNT_SEMISOFT;
			break;
		case OPT_HARD:
			args->flags &= ~(NFSMNT_SOFT);
			args->flags &= ~(NFSMNT_SEMISOFT);
			break;
		case OPT_NOSUID:
		case OPT_NODEVICES:
		case OPT_NOSETUID:
		case OPT_NOEXEC:
			cmn_err(CE_WARN,
			    "nfs_dlboot: may not set root partition %s",
			    optlist[opt]);
			break;
		case OPT_GRPID:
			args->flags |= NFSMNT_GRPID;
			break;
		case OPT_REMOUNT:
			cmn_err(CE_WARN,
			    "nfs_dlboot: may not remount root partition");
			break;
		case OPT_INTR:
			args->flags |= NFSMNT_INT;
			break;
		case OPT_NOINTR:
			args->flags &= ~(NFSMNT_INT);
			break;
		case OPT_NOAC:
			args->flags |= NFSMNT_NOAC;
			break;
		case OPT_PORT:
			cmn_err(CE_WARN,
			    "nfs_dlboot: may not change root port number");
			break;
		case OPT_SECURE:
			cmn_err(CE_WARN,
			"nfs_dlboot: root mounted auth_unix, secure ignored");
			break;
		case OPT_NOCTO:
			args->flags |= NFSMNT_NOCTO;
			break;
		case OPT_RSIZE:
			if (bad(val)) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: invalid option: rsize");
				break;
			}
			args->flags |= NFSMNT_RSIZE;
			args->rsize = atoi(val);
			break;
		case OPT_WSIZE:
			if (bad(val)) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: invalid option: wsize");
				break;
			}
			args->flags |= NFSMNT_WSIZE;
			args->wsize = atoi(val);
			break;
		case OPT_TIMEO:
			if (bad(val)) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: invalid option: timeo");
				break;
			}
			args->flags |= NFSMNT_TIMEO;
			args->timeo = atoi(val);
			break;
		case OPT_RETRANS:
			if (bad(val)) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: invalid option: retrans");
				break;
			}
			args->flags |= NFSMNT_RETRANS;
			args->retrans = atoi(val);
			break;
		case OPT_ACTIMEO:
			if (bad(val)) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: invalid option: actimeo");
				break;
			}
			args->flags |= NFSMNT_ACDIRMAX;
			args->flags |= NFSMNT_ACREGMAX;
			args->flags |= NFSMNT_ACDIRMIN;
			args->flags |= NFSMNT_ACREGMIN;
			args->acdirmin = args->acregmin = args->acdirmax =
			    args->acregmax = atoi(val);
			break;
		case OPT_ACREGMIN:
			if (bad(val)) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: invalid option: acregmin");
				break;
			}
			args->flags |= NFSMNT_ACREGMIN;
			args->acregmin = atoi(val);
			break;
		case OPT_ACREGMAX:
			if (bad(val)) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: invalid option: acregmax");
				break;
			}
			args->flags |= NFSMNT_ACREGMAX;
			args->acregmax = atoi(val);
			break;
		case OPT_ACDIRMIN:
			if (bad(val)) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: invalid option: acdirmin");
				break;
			}
			args->flags |= NFSMNT_ACDIRMIN;
			args->acdirmin = atoi(val);
			break;
		case OPT_ACDIRMAX:
			if (bad(val)) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: invalid option: acdirmax");
				break;
			}
			args->flags |= NFSMNT_ACDIRMAX;
			args->acdirmax = atoi(val);
			break;
		case OPT_LLOCK:
			args->flags |= NFSMNT_LLOCK;
			break;
		case OPT_VERS:
			if (bad(val)) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: invalid option: vers");
				break;
			}
			vers = atoi(val);
			/*
			 * If the requested version is less than what we
			 * chose, pretend the chosen version doesn't exist
			 */
			if (vers < version) {
				return (EPROTONOSUPPORT);
			}
			if (vers > version) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: version %d unavailable",
				    vers);
				return (EINVAL);
			}
			break;
		case OPT_PROTO:
			/*
			 * NFSv4 can only run over TCP, if they requested
			 * UDP pretend v4 doesn't exist, they might not have
			 * specified a version allowing a fallback to v2 or v3.
			 */
			if (version == NFS_V4 && strcmp(val, NC_UDP) == 0)
				return (EPROTONOSUPPORT);
			/*
			 * TCP is always chosen over UDP, so if the
			 * requested is the same as the chosen either
			 * they chose TCP when available or UDP on a UDP
			 * only server.
			 */
			if (strcmp(cf->knc_proto, val) == 0)
				break;
			/*
			 * If we chose UDP, they must have requested TCP
			 */
			if (strcmp(cf->knc_proto, NC_TCP) != 0) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: TCP protocol unavailable");
				return (EINVAL);
			}
			/*
			 * They can only have requested UDP
			 */
			if (strcmp(val, NC_UDP) != 0) {
				cmn_err(CE_WARN,
				    "nfs_dlboot: unknown protocol");
				return (EINVAL);
			}
			*dl_cf = &dl_udp_netconf;
			break;
		case OPT_NOPRINT:
			args->flags |= NFSMNT_NOPRINT;
			break;
		case OPT_NOLARGEFILES:
			cmn_err(CE_WARN,
			    "nfs_dlboot: NFS can't support nolargefiles");
			break;
		case OPT_SEC:
			cmn_err(CE_WARN,
			    "nfs_dlboot: root mounted auth_unix, sec ignored");
			break;

		case OPT_DIRECTIO:
			args->flags |= NFSMNT_DIRECTIO;
			break;

		case OPT_NODIRECTIO:
			args->flags &= ~(NFSMNT_DIRECTIO);
			break;

		default:
			cmn_err(CE_WARN,
			    "nfs_dlboot: ignoring invalid option \"%s\"", val);
			break;
		}
	}
sanity:
	/*
	 * Set some sane limits on read size
	 */
	if (!(args->flags & NFSMNT_RSIZE) || args->rsize == 0) {
		/*
		 * Establish defaults
		 */
		args->flags |= NFSMNT_RSIZE;
		if (version == NFS_V4)
			args->rsize = nfs4_root_rsize;
		else
			args->rsize = nfs_root_rsize;
		return (0);
	}
	/*
	 * No less than 512 bytes, otherwise it will take forever to boot
	 */
	if (args->rsize < 512)
		args->rsize = 512;
	/*
	 * If we are running over UDP, we cannot exceed 64KB, trim
	 * to 56KB to allow room for headers.
	 */
	if (*dl_cf == &dl_udp_netconf && args->rsize > (56 * 1024))
		args->rsize = 56 * 1024;
	return (0);
}