/*

 * 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 2006 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*	Copyright (c) 1988 AT&T */

/*	All Rights Reserved */

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

#include <sys/utsname.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <rpc/types.h>

#include <rpc/auth.h>

#include <sys/t_lock.h>

#include <netdb.h>

#include "clnt.h"

#include <rpc/xdr.h>

#include <rpc/rpc_msg.h>

#include <rpc/rpc.h>

#include "brpc.h"

#include "auth_inet.h"

#include "pmap.h"

#include <rpcsvc/nfs_prot.h>

#include <rpcsvc/nfs4_prot.h>

#include "nfs_inet.h"

#include <rpcsvc/bootparam.h>

#include <dhcp_impl.h>

#include <rpcsvc/mount.h>

#include <sys/promif.h>

#include <sys/salib.h>

#include "socket_inet.h"

#include "ipv4.h"

#include "mac.h"

#include <sys/bootdebug.h>

#include <errno.h>

#include "dhcpv4.h"

#include <sys/mntent.h>

/* ARP timeout in milliseconds for BOOTP/RARP */

#define	ARP_INETBOOT_TIMEOUT 1000

struct nfs_file		roothandle;			/* root file handle */

static char		root_hostname[SYS_NMLN];	/* server hostname */

static char		my_hostname[MAXHOSTNAMELEN];

static char		root_pathbuf[NFS_MAXPATHLEN];	/* the root's path */

static char		root_boot_file[NFS_MAXPATHLEN];	/* optional boot file */

static struct sockaddr_in root_to;			/* server sock ip */

							/* in network order */

CLIENT			*root_CLIENT = NULL;		/* CLIENT handle */

int dontroute = FALSE;	/* In case rarp/bootparams was selected */

char			rootopts[MAX_PATH_LEN];

static gid_t		fake_gids = 1;	/* fake gids list for auth_unix */

extern void set_default_filename(char *);	/* boot.c */

/*

 * xdr routines used by mount.

 */

bool_t

xdr_fhstatus(XDR *xdrs, struct fhstatus *fhsp)

{

	if (!xdr_int(xdrs, (int *)&fhsp->fhs_status))

		return (FALSE);

	if (fhsp->fhs_status == 0) {

		return (xdr_fhandle(xdrs, fhsp->fhstatus_u.fhs_fhandle));

	}

	return (TRUE);

}

bool_t

xdr_fhandle(XDR *xdrs, fhandle fhp)

{

	return (xdr_opaque(xdrs, (char *)fhp, NFS_FHSIZE));

}

bool_t

xdr_path(XDR *xdrs, char **pathp)

{

	return (xdr_string(xdrs, pathp, MNTPATHLEN));

}

bool_t

xdr_fhandle3(XDR *xdrs, fhandle3 *objp)

{

	return (xdr_bytes(xdrs, (char **)&objp->fhandle3_val,

				(uint_t *)&objp->fhandle3_len, FHSIZE3));

}

bool_t

xdr_mountstat3(XDR *xdrs, mountstat3 *objp)

{

	return (xdr_enum(xdrs, (enum_t *)objp));

}

bool_t

xdr_mountres3_ok(XDR *xdrs, mountres3_ok *objp)

{

	if (!xdr_fhandle3(xdrs, &objp->fhandle))

		return (FALSE);

	return (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));

}

bool_t

xdr_mountres3(XDR *xdrs, mountres3 *objp)

{

	if (!xdr_mountstat3(xdrs, &objp->fhs_status))

		return (FALSE);

	if (objp->fhs_status == MNT_OK)

		return (xdr_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo));

	return (TRUE);

}

static int

nfsmountroot(char *path, struct nfs_file *filep)

{

	int		rexmit;

	int		resp_wait;

	enum clnt_stat	status;

	struct fhstatus	root_tmp;			/* to pass to rpc/xdr */

	/*

	 * Wait up to 16 secs for first response, retransmitting expon.

	 */

	rexmit = 0;	/* default retransmission interval */

	resp_wait = 16;

	do {

		status = brpc_call((rpcprog_t)MOUNTPROG, (rpcvers_t)MOUNTVERS,

		    (rpcproc_t)MOUNTPROC_MNT, xdr_path, (caddr_t)&path,

		    xdr_fhstatus, (caddr_t)&(root_tmp), rexmit, resp_wait,

		    &root_to, NULL, AUTH_UNIX);

		if (status == RPC_TIMEDOUT) {

			dprintf("boot: %s:%s mount server not responding.\n",

			    root_hostname, path);

		}

		rexmit = resp_wait;

		resp_wait = 0;	/* use default wait time. */

	} while (status == RPC_TIMEDOUT);

	if ((status != RPC_SUCCESS) || (root_tmp.fhs_status != 0)) {

		nfs_error(root_tmp.fhs_status);

		root_to.sin_port = 0;

		return (-1);

	}

	/*

	 * Since the mount succeeded, we'll mark the filep's

	 * status as NFS_OK, and its type as NFDIR. If these

	 * points aren't the case, then we wouldn't be here.

	 */

	bcopy(&root_tmp.fhstatus_u.fhs_fhandle, &filep->fh.fh2, FHSIZE);

	filep->ftype.type2 = NFDIR;

	filep->version = NFS_VERSION;

	nfs_readsize = nfs_readsize <  NFS_MAXDATA ? nfs_readsize : NFS_MAXDATA;

	/*

	 * Set a reasonable lower limit on readsize

	 */

	nfs_readsize = (nfs_readsize != 0 && nfs_readsize < 512) ?

							512 : nfs_readsize;

	return (0);

}

int

setup_root_vars(void)

{

	size_t		buflen;

	uint16_t	readsize;

	/*

	 * Root server name. Required.

	 */

	buflen = sizeof (root_hostname);

	if (dhcp_getinfo(DSYM_VENDOR, VS_NFSMNT_ROOTSRVR_NAME, 0,

	    root_hostname, &buflen)) {

		root_hostname[buflen] = '\0';

	} else {

		dprintf("BOUND: Missing Root Server Name Option\n");

		errno = EINVAL;

		return (-1);

	}

	/*

	 * Root server IP. Required.

	 */

	buflen = sizeof (root_to.sin_addr);

	if (!dhcp_getinfo(DSYM_VENDOR, VS_NFSMNT_ROOTSRVR_IP, 0,

	    &root_to.sin_addr, &buflen)) {

		dprintf("BOUND: Missing Root Server IP Option\n");

		errno = EINVAL;

		return (-1);

	}

	/*

	 * Root path Required.

	 */

	buflen = sizeof (root_pathbuf);

	if (dhcp_getinfo(DSYM_VENDOR, VS_NFSMNT_ROOTPATH, 0,

	    root_pathbuf, &buflen)) {

		root_pathbuf[buflen] = '\0';

	} else {

		dprintf("BOUND: Missing Root Path Option\n");

		errno = EINVAL;

		return (-1);

	}

	/*

	 * Optional Bootfile path.

	 */

	buflen = sizeof (root_boot_file);

	if (dhcp_getinfo(DSYM_VENDOR, VS_NFSMNT_BOOTFILE, 0,

		    root_boot_file, &buflen)) {

		root_boot_file[buflen] = '\0';

		dprintf("BOUND: Optional Boot File is: %s\n", root_boot_file);

	}

	/* if we got a boot file name, use it as the default */

	if (root_boot_file[0] != '\0')

		set_default_filename(root_boot_file);

	/*

	 * Set the NFS read size. The mount code will adjust it to

	 * the maximum size.

	 */

	buflen = sizeof (readsize);

	if (dhcp_getinfo(DSYM_VENDOR, VS_BOOT_NFS_READSIZE, 0,

	    &readsize, &buflen)) {

		nfs_readsize = ntohs(readsize);

		if (boothowto & RB_VERBOSE) {

			printf("Boot NFS read size: %d\n", nfs_readsize);

		}

	}

	/*

	 * Optional rootopts.

	 */

	buflen = sizeof (rootopts);

	if (dhcp_getinfo(DSYM_VENDOR, VS_NFSMNT_ROOTOPTS, 0,

	    rootopts, &buflen)) {

		rootopts[buflen] = '\0';

		dprintf("BOUND: Optional Rootopts is: %s\n", rootopts);

	}

	return (0);

}

static void

mnt3_error(enum mountstat3 status)

{

	if (!(boothowto & RB_DEBUG))

		return;

	switch (status) {

	case MNT_OK:

		printf("Mount: No error.\n");

		break;

	case MNT3ERR_PERM:

		printf("Mount: Not owner.\n");

		break;

	case MNT3ERR_NOENT:

		printf("Mount: No such file or directory.\n");

		break;

	case MNT3ERR_IO:

		printf("Mount: I/O error.\n");

		break;

	case MNT3ERR_ACCES:

		printf("Mount: Permission denied.\n");

		break;

	case MNT3ERR_NOTDIR:

		printf("Mount: Not a directory.\n");

		break;

	case MNT3ERR_INVAL:

		printf("Mount: Invalid argument.\n");

		break;

	case MNT3ERR_NAMETOOLONG:

		printf("Mount: File name too long.\n");

		break;

	case MNT3ERR_NOTSUPP:

		printf("Mount: Operation not supported.\n");

		break;

	case MNT3ERR_SERVERFAULT:

		printf("Mount: Server fault.\n");

		break;

	default:

		printf("Mount: unknown error.\n");

		break;

	}

}

static int

nfs3mountroot(char *path, struct nfs_file *filep)

{

	int		rexmit;

	int		resp_wait;

	struct mountres3 res3;

	enum clnt_stat	status;

	/*

	 * Wait up to 16 secs for first response, retransmitting expon.

	 */

	rexmit = 0;	/* default retransmission interval */

	resp_wait = 16;

	/*

	 * Try to mount using V3

	 */

	do {

		bzero(&res3, sizeof (struct mountres3));

		status = brpc_call((rpcprog_t)MOUNTPROG, (rpcvers_t)MOUNTVERS3,

		    (rpcproc_t)MOUNTPROC_MNT, xdr_path, (caddr_t)&path,

		    xdr_mountres3, (caddr_t)&res3, rexmit, resp_wait,

		    &root_to, NULL, AUTH_UNIX);

		if (status != RPC_TIMEDOUT)

			break;

		dprintf("boot: %s:%s mount server not responding.\n",

			    root_hostname, path);

		rexmit = resp_wait;

		resp_wait = 0;	/* use default wait time. */

		xdr_free(xdr_mountres3, (caddr_t)&res3);

	} while (status == RPC_TIMEDOUT);

	if ((status != RPC_SUCCESS) || (res3.fhs_status != MNT_OK)) {

		mnt3_error(res3.fhs_status);

		root_to.sin_port = 0;

		return (-1);

	}

	/*

	 * Since the mount succeeded, we'll mark the filep's

	 * status as NFS_OK, and its type as NF3DIR. If these

	 * points aren't the case, then we wouldn't be here.

	 */

	filep->fh.fh3.len = res3.mountres3_u.mountinfo.fhandle.fhandle3_len;

	bcopy(res3.mountres3_u.mountinfo.fhandle.fhandle3_val,

			filep->fh.fh3.data,

			filep->fh.fh3.len);

	filep->ftype.type3 = NF3DIR;

	filep->version = NFS_V3;

	/*

	 * Hardwire in a known reasonable upper limit of 32K

	 */

	nfs_readsize = nfs_readsize <  32 * 1024 ? nfs_readsize : 32 * 1024;

	/*

	 * Set a reasonable lower limit on readsize

	 */

	nfs_readsize = (nfs_readsize != 0 && nfs_readsize < 512) ?

							512 : nfs_readsize;

	xdr_free(xdr_mountres3, (caddr_t)&res3);

	return (0);

}

/*

 * Setup v4 client for inetboot

 */

static int

nfs4init(char *path, uint16_t nfs_port)

{

	struct timeval	wait;

	int		fd = -1;

	int		error = 0;

	enum clnt_stat	rpc_stat;

	struct nfs_file	rootpath;

	wait.tv_sec = RPC_RCVWAIT_MSEC / 1000;

	wait.tv_usec = 0;

	/*

	 * If we haven't explicitly set the port number, set to the standard

	 * 2049 and don't cause a rpcbind request.

	 */

	if (nfs_port == 0)

		nfs_port = 2049;

	root_to.sin_port = htons(nfs_port);

	/*

	 * Support TCP only

	 */

	root_CLIENT = clntbtcp_create(&root_to, NFS_PROGRAM,

					NFS_V4, wait, &fd,

					NFS4BUF_SIZE, NFS4BUF_SIZE);

	if (root_CLIENT == NULL) {

		root_to.sin_port = 0;

		return (-1);

	}

	root_CLIENT->cl_auth =

			authunix_create(my_hostname, 0, 1, 1, &fake_gids);

	/*

	 * Send NULL proc the server first to see if V4 exists

	 */

	rpc_stat = CLNT_CALL(root_CLIENT, NFSPROC4_NULL, xdr_void, NULL,

				xdr_void, NULL, wait);

	if (rpc_stat != RPC_SUCCESS) {

		dprintf("boot: NULL proc failed NFSv4 service not available\n");

		AUTH_DESTROY(root_CLIENT->cl_auth);

		CLNT_DESTROY(root_CLIENT);

		root_to.sin_port = 0;

		return (-1);

	}

	/*

	 * Do a lookup to get to the root_path.  This is nice since it can

	 * handle multicomponent lookups.

	 */

	roothandle.version = NFS_V4;

	roothandle.ftype.type4 = NF4DIR;

	roothandle.fh.fh4.len = 0;		/* Force a PUTROOTFH */

	roothandle.offset = (uint_t)0;		/* it's a directory! */

	error = lookup(path, &rootpath, TRUE);

	if (error) {

		printf("boot: lookup %s failed\n", path);

		return (-1);

	}

	roothandle = rootpath;	/* structure copy */

	/*

	 * Hardwire in a known reasonable upper limit of 32K

	 */

	nfs_readsize = nfs_readsize <  32 * 1024 ? nfs_readsize : 32 * 1024;

	/*

	 * Set a reasonable lower limit on readsize

	 */

	nfs_readsize = (nfs_readsize != 0 && nfs_readsize < 512) ?

							512 : nfs_readsize;

	return (0);

}

static int

atoi(const char *p)

{

	int n;

	int c, neg = 0;

	if (!isdigit(c = *p)) {

		while (c == ' ' || c == '\t' || c == '\n')

			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);

}

/*

 * Parse suboptions from a string.

 * Same as getsubopt(3C).

 */

static int

getsubopt(char **optionsp, char * const *tokens, char **valuep)

{

	char *s = *optionsp, *p;

	int i;

	size_t optlen;

	*valuep = NULL;

	if (*s == '\0')

		return (-1);

	p = strchr(s, ',');		/* find next option */

	if (p == NULL) {

		p = s + strlen(s);

	} else {

		*p++ = '\0';		/* mark end and point to next */

	}

	*optionsp = p;			/* point to next option */

	p = strchr(s, '=');		/* find value */

	if (p == NULL) {

		optlen = strlen(s);

		*valuep = NULL;

	} else {

		optlen = p - s;

		*valuep = ++p;

	}

	for (i = 0; tokens[i] != NULL; i++) {

		if ((optlen == strlen(tokens[i])) &&

		    (strncmp(s, tokens[i], optlen) == 0))

			return (i);

	}

	/* no match, point value at option and return error */

	*valuep = s;

	return (-1);

}