/*

 * 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.

 */

/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/

/*	  All Rights Reserved  	*/

/*

 * Portions of this source code were derived from Berkeley 4.3 BSD

 * under license from the Regents of the University of California.

 */

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

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <sys/types.h>

#include <string.h>

#include <syslog.h>

#include <sys/param.h>

#include <rpc/rpc.h>

#include <sys/stat.h>

#include <netconfig.h>

#include <netdir.h>

#include <sys/file.h>

#include <sys/time.h>

#include <sys/errno.h>

#include <rpcsvc/mount.h>

#include <sys/pathconf.h>

#include <sys/systeminfo.h>

#include <sys/utsname.h>

#include <signal.h>

#include <locale.h>

#include <unistd.h>

#include <errno.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <netdb.h>

#include <thread.h>

#include <assert.h>

#include <priv_utils.h>

#include <nfs/auth.h>

#include <nfs/nfssys.h>

#include <nfs/nfs.h>

#include <nfs/nfs_sec.h>

#include <rpcsvc/daemon_utils.h>

#include <deflt.h>

#include "../../fslib.h"

#include "../lib/sharetab.h"

#include "mountd.h"

struct sh_list *share_list;

rwlock_t sharetab_lock;		/* lock to protect the cached sharetab */

static mutex_t mnttab_lock;	/* prevent concurrent mnttab readers */

static struct share *find_lofsentry(char *, int *);

static void getclientsnames(SVCXPRT *, struct netbuf **,

					struct nd_hostservlist **);

static int getclientsflavors_old(struct share *, struct netbuf *,

	struct nd_hostservlist *, int *);

static int getclientsflavors_new(struct share *, struct netbuf *,

	struct nd_hostservlist *, int *);

static int check_client_old(struct share *, struct netbuf *,

    struct nd_hostservlist *, int);

static int check_client_new(struct share *, struct netbuf *,

	struct nd_hostservlist *, int);

static int  in_access_list(struct netbuf *, struct nd_hostservlist *, char *);

static void mnt(struct svc_req *, SVCXPRT *);

static void mnt_pathconf(struct svc_req *);

static void mount(struct svc_req *r);

static void sh_free(struct sh_list *);

static void umount(struct svc_req *);

static void umountall(struct svc_req *);

static int netmatch(struct netbuf *, char *);

static void sigexit(int);

static int newopts(char *);

static int verbose;

static int rejecting;

static int mount_vers_min = MOUNTVERS;

static int mount_vers_max = MOUNTVERS3;

thread_t	nfsauth_thread;

/* ARGSUSED */

static void *

nfsauth_svc(void *arg)

{

	int	doorfd = -1;

	uint_t	darg;

#ifdef DEBUG

	int	dfd;

#endif

	if ((doorfd = door_create(nfsauth_func, NULL,

	    DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) {

		syslog(LOG_ERR, "Unable to create door: %m\n");

		exit(10);

	}

#ifdef DEBUG

	/*

	 * Create a file system path for the door

	 */

	if ((dfd = open(MOUNTD_DOOR, O_RDWR|O_CREAT|O_TRUNC,

	    S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) == -1) {

		syslog(LOG_ERR, "Unable to open %s: %m\n", MOUNTD_DOOR);

		(void) close(doorfd);

		exit(11);

	}

	/*

	 * Clean up any stale namespace associations

	 */

	(void) fdetach(MOUNTD_DOOR);

	/*

	 * Register in namespace to pass to the kernel to door_ki_open

	 */

	if (fattach(doorfd, MOUNTD_DOOR) == -1) {

		syslog(LOG_ERR, "Unable to fattach door: %m\n");

		(void) close(dfd);

		(void) close(doorfd);

		exit(12);

	}

	(void) close(dfd);

#endif

	/*

	 * Must pass the doorfd down to the kernel.

	 */

	darg = doorfd;

	(void) _nfssys(MOUNTD_ARGS, &darg);

	/*

	 * Wait for incoming calls

	 */

	/*CONSTCOND*/

	for (;;)

		(void) pause();

	/*NOTREACHED*/

	syslog(LOG_ERR, gettext("Door server exited"));

	return (NULL);

}

int

main(int argc, char *argv[])

{

	int	pid;

	int	c;

	int	rpc_svc_mode = RPC_SVC_MT_AUTO;

	int	maxthreads;

	int	maxrecsz = RPC_MAXDATASIZE;

	bool_t	exclbind = TRUE;

	bool_t	can_do_mlp;

	long	thr_flags = (THR_NEW_LWP|THR_DAEMON);

	/*

	 * Mountd requires uid 0 for:

	 *	/etc/rmtab updates (we could chown it to daemon)

	 *	/etc/dfs/dfstab reading (it wants to lock out share which

	 *		doesn't do any locking before first truncate;

	 *		NFS share does; should use fcntl locking instead)

	 *	Needed privileges:

	 *		auditing

	 *		nfs syscall

	 *		file dac search (so it can stat all files)

	 *	Optional privileges:

	 *		MLP

	 */

	can_do_mlp = priv_ineffect(PRIV_NET_BINDMLP);

	if (__init_daemon_priv(PU_RESETGROUPS|PU_CLEARLIMITSET, -1, -1,

	    PRIV_SYS_NFS, PRIV_PROC_AUDIT, PRIV_FILE_DAC_SEARCH,

	    can_do_mlp ? PRIV_NET_BINDMLP : NULL, NULL) == -1) {

		(void) fprintf(stderr,

			"%s must be run as with sufficient privileges\n",

			argv[0]);

		exit(1);

	}

	maxthreads = 0;

	while ((c = getopt(argc, argv, "vrm:")) != EOF) {

		switch (c) {

		case 'v':

			verbose++;

			break;

		case 'r':

			rejecting = 1;

			break;

		case 'm':

			maxthreads = atoi(optarg);

			if (maxthreads < 1) {

				(void) fprintf(stderr,

	"%s: must specify positive maximum threads count, using default\n",

						argv[0]);

				maxthreads = 0;

			}

			break;

		}

	}

	/*

	 * Read in the NFS version values from config file.

	 */

	if ((defopen(NFSADMIN)) == 0) {

		char *defval;

		int defvers;

		if ((defval = defread("NFS_SERVER_VERSMIN=")) != NULL) {

			errno = 0;

			defvers = strtol(defval, (char **)NULL, 10);

			if (errno == 0) {

				mount_vers_min = defvers;

				/*

				 * special because NFSv2 is

				 * supported by mount v1 & v2

				 */

				if (defvers == NFS_VERSION)

					mount_vers_min = MOUNTVERS;

			}

		}

		if ((defval = defread("NFS_SERVER_VERSMAX=")) != NULL) {

			errno = 0;

			defvers = strtol(defval, (char **)NULL, 10);

			if (errno == 0) {

				mount_vers_max = defvers;

			}

		}

		/* close defaults file */

		defopen(NULL);

	}

	/*

	 * Sanity check versions,

	 * even though we may get versions > MOUNTVERS3, we still need

	 * to start nfsauth service, so continue on regardless of values.

	 */

	if (mount_vers_min > mount_vers_max) {

		syslog(LOG_NOTICE, "NFS_SERVER_VERSMIN > NFS_SERVER_VERSMAX");

		mount_vers_max = mount_vers_min;

	}

	(void) setlocale(LC_ALL, "");

	(void) rwlock_init(&sharetab_lock, USYNC_THREAD, NULL);

	(void) mutex_init(&mnttab_lock, USYNC_THREAD, NULL);

	netgroup_init();

#if !defined(TEXT_DOMAIN)

#define	TEXT_DOMAIN "SYS_TEST"

#endif

	(void) textdomain(TEXT_DOMAIN);

	/* Don't drop core if the NFS module isn't loaded. */

	(void) signal(SIGSYS, SIG_IGN);

	(void) signal(SIGHUP, sigexit);

	(void) signal(SIGCLD, sigexit);

	switch (fork()) {

	case 0:		/* child */

		break;

	case -1:

		perror("mountd: can't fork");

		exit(1);

	default:	/* parent */

		for (;;)

			(void) pause();

		/* NOTREACHED */

	}

	(void) signal(SIGHUP, SIG_DFL);

	(void) signal(SIGCLD, SIG_DFL);

	/*

	 * If we coredump it'll be in /core

	 */

	if (chdir("/") < 0)

		syslog(LOG_ERR, "chdir /: %m");

	/*

	 * Close existing file descriptors, open "/dev/null" as

	 * standard input, output, and error, and detach from

	 * controlling terminal.

	 */

	closefrom(0);

	(void) open("/dev/null", O_RDONLY);

	(void) open("/dev/null", O_WRONLY);

	(void) dup(1);

	(void) setsid();

	openlog("mountd", LOG_PID, LOG_DAEMON);

	/*

	 * establish our lock on the lock file and write our pid to it.

	 * exit if some other process holds the lock, or if there's any

	 * error in writing/locking the file.

	 */

	pid = _enter_daemon_lock(MOUNTD);

	switch (pid) {

	case 0:

		break;

	case -1:

		syslog(LOG_ERR, "error locking for %s: %s", MOUNTD,

		    strerror(errno));

		exit(2);

	default:

		/* daemon was already running */

		exit(0);

	}

	audit_mountd_setup();	/* BSM */

	/*

	 * Tell RPC that we want automatic thread mode.

	 * A new thread will be spawned for each request.

	 */

	if (!rpc_control(RPC_SVC_MTMODE_SET, &rpc_svc_mode)) {

		syslog(LOG_ERR, "unable to set automatic MT mode");

		exit(1);

	}

	/*

	 * Enable non-blocking mode and maximum record size checks for

	 * connection oriented transports.

	 */

	if (!rpc_control(RPC_SVC_CONNMAXREC_SET, &maxrecsz)) {

		syslog(LOG_INFO, "unable to set RPC max record size");

	}

	/*

	 * Prevent our non-priv udp and tcp ports bound w/wildcard addr

	 * from being hijacked by a bind to a more specific addr.

	 */

	if (!rpc_control(__RPC_SVC_EXCLBIND_SET, &exclbind)) {

		syslog(LOG_INFO,  "warning: unable to set udp/tcp EXCLBIND");

	}

	/*

	 * If the -m argument was specified, then set the

	 * maximum number of threads to the value specified.

	 */

	if (maxthreads > 0 && !rpc_control(RPC_SVC_THRMAX_SET, &maxthreads)) {

		syslog(LOG_ERR, "unable to set maxthreads");

		exit(1);

	}

	/*

	 * Make sure to unregister any previous versions in case the

	 * user is reconfiguring the server in interesting ways.

	 */

	svc_unreg(MOUNTPROG, MOUNTVERS);

	svc_unreg(MOUNTPROG, MOUNTVERS_POSIX);

	svc_unreg(MOUNTPROG, MOUNTVERS3);

	/*

	 * Create the nfsauth thread with same signal disposition

	 * as the main thread. We need to create a separate thread

	 * since mountd() will be both an RPC server (for remote

	 * traffic) _and_ a doors server (for kernel upcalls).

	 */

	if (thr_create(NULL, 0, nfsauth_svc, 0, thr_flags, &nfsauth_thread)) {

		syslog(LOG_ERR, gettext("Failed to create NFSAUTH svc thread"));

		exit(2);

	}

	/*

	 * Create datagram and connection oriented services

	 */

	if (mount_vers_max >= MOUNTVERS) {

		if (svc_create(mnt, MOUNTPROG, MOUNTVERS, "datagram_v") == 0) {

			syslog(LOG_ERR,

				"couldn't register datagram_v MOUNTVERS");

			exit(1);

		}

		if (svc_create(mnt, MOUNTPROG, MOUNTVERS, "circuit_v") == 0) {

			syslog(LOG_ERR,

				"couldn't register circuit_v MOUNTVERS");

			exit(1);

		}

	}

	if (mount_vers_max >= MOUNTVERS_POSIX) {

		if (svc_create(mnt, MOUNTPROG, MOUNTVERS_POSIX,

							"datagram_v") == 0) {

			syslog(LOG_ERR,

				"couldn't register datagram_v MOUNTVERS_POSIX");

			exit(1);

		}

		if (svc_create(mnt, MOUNTPROG, MOUNTVERS_POSIX,

							"circuit_v") == 0) {

			syslog(LOG_ERR,

				"couldn't register circuit_v MOUNTVERS_POSIX");

			exit(1);

		}

	}

	if (mount_vers_max >= MOUNTVERS3) {

		if (svc_create(mnt, MOUNTPROG, MOUNTVERS3, "datagram_v") == 0) {

			syslog(LOG_ERR,

				"couldn't register datagram_v MOUNTVERS3");

			exit(1);

		}

		if (svc_create(mnt, MOUNTPROG, MOUNTVERS3, "circuit_v") == 0) {

			syslog(LOG_ERR,

				"couldn't register circuit_v MOUNTVERS3");

			exit(1);

		}

	}

	/*

	 * Start serving

	 */

	rmtab_load();

	(void) kill(getppid(), SIGHUP);

	/* Get rid of the most dangerous basic privileges. */

	__fini_daemon_priv(PRIV_PROC_EXEC, PRIV_PROC_INFO, PRIV_PROC_SESSION,

	    (char *)NULL);

	svc_run();

	syslog(LOG_ERR, "Error: svc_run shouldn't have returned");

	abort();

	/* NOTREACHED */

	return (0);

}

/*

 * Server procedure switch routine

 */

void

mnt(struct svc_req *rqstp, SVCXPRT *transp)

{

	switch (rqstp->rq_proc) {

	case NULLPROC:

		errno = 0;

		if (!svc_sendreply(transp, xdr_void, (char *)0))

			log_cant_reply(transp);

		return;

	case MOUNTPROC_MNT:

		mount(rqstp);

		return;

	case MOUNTPROC_DUMP:

		mntlist_send(transp);

		return;

	case MOUNTPROC_UMNT:

		umount(rqstp);

		return;

	case MOUNTPROC_UMNTALL:

		umountall(rqstp);

		return;

	case MOUNTPROC_EXPORT:

	case MOUNTPROC_EXPORTALL:

		export(rqstp);

		return;

	case MOUNTPROC_PATHCONF:

		if (rqstp->rq_vers == MOUNTVERS_POSIX)

			mnt_pathconf(rqstp);

		else

			svcerr_noproc(transp);

		return;

	default:

		svcerr_noproc(transp);

		return;

	}

}

/* Set up anonymous client */

struct nd_hostservlist *

anon_client(char *host)

{

	struct nd_hostservlist *anon_hsl;

	struct nd_hostserv *anon_hs;

	anon_hsl = malloc(sizeof (*anon_hsl));

	if (anon_hsl == NULL)

		return (NULL);

	anon_hs = malloc(sizeof (*anon_hs));

	if (anon_hs == NULL) {

		free(anon_hsl);

		return (NULL);

	}

	if (host == NULL)