/*
 * 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 (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2012, 2016 by Delphix. All rights reserved.
 * Copyright 2017 Nexenta Systems, Inc.  All rights reserved.
 */

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

#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 <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 <limits.h>

#define	TESTPROG	987654

uint32_t test_vers_max = 2;
uint32_t test_vers_min = 1;

int debug;
int verbose;
int testd_port;

static void mysvc(struct svc_req *, SVCXPRT *);
static void bind2(void);

/*
 * This function is called for each configured network type to
 * bind and register our RPC service programs.
 *
 * On TCP or UDP, we want to bind TESTPROG on a specific port
 * (when testd_port is specified) in which case we'll use the
 * variant of svc_tp_create() that lets us pass a bind address.
 */
static void
test_svc_tp_create(struct netconfig *nconf)
{
	char port_str[8];
	struct nd_hostserv hs;
	struct nd_addrlist *al = NULL;
	SVCXPRT *xprt = NULL;
	rpcvers_t vers;

	vers = test_vers_max;

	/*
	 * If testd_port is set and this is an inet transport,
	 * bind this service on the specified port.
	 */
	if (testd_port != 0 &&
	    (strcmp(nconf->nc_protofmly, NC_INET) == 0 ||
	    strcmp(nconf->nc_protofmly, NC_INET6) == 0)) {
		int err;

		snprintf(port_str, sizeof (port_str), "%u",
		    (unsigned short)testd_port);

		hs.h_host = HOST_SELF_BIND;
		hs.h_serv = port_str;
		err = netdir_getbyname((struct netconfig *)nconf, &hs, &al);
		if (err == 0 && al != NULL) {
			xprt = svc_tp_create_addr(mysvc, TESTPROG, vers,
			    nconf, al->n_addrs);
			netdir_free(al, ND_ADDRLIST);
		}
		if (xprt == NULL) {
			printf("testd: unable to create "
			    "(TESTD,%d) on transport %s (port %d)\n",
			    (int)vers, nconf->nc_netid, testd_port);
		}
		/* fall-back to default bind */
	}
	if (xprt == NULL) {
		/*
		 * Had testd_port=0, or non-inet transport,
		 * or the bind to a specific port failed.
		 * Do a default bind.
		 */
		xprt = svc_tp_create(mysvc, TESTPROG, vers, nconf);
	}
	if (xprt == NULL) {
		printf("testd: unable to create "
		    "(TESTD,%d) on transport %s\n",
		    (int)vers, nconf->nc_netid);
		return;
	}

	/*
	 * Register additional versions on this transport.
	 */
	while (--vers >= test_vers_min) {
		if (!svc_reg(xprt, TESTPROG, vers, mysvc, nconf)) {
			printf("testd: "
			    "failed to register vers %d on %s\n",
			    (int)vers, nconf->nc_netid);
		}
	}
}

static void
test_svc_unreg(void)
{
	rpcvers_t vers;

	for (vers = test_vers_min; vers <= test_vers_max; vers++)
		svc_unreg(TESTPROG, vers);
}

int
main(int argc, char *argv[])
{
	int	c;
	bool_t	exclbind = TRUE;
	int tmp;
	struct netconfig *nconf;
	NCONF_HANDLE *nc;

	while ((c = getopt(argc, argv, "dvp:")) != EOF) {
		switch (c) {
		case 'd':
			debug++;
			break;
		case 'v':
			verbose++;
			break;
		case 'p':
			(void) sscanf(optarg, "%d", &tmp);
			if (tmp < 1 || tmp > UINT16_MAX) {
				(void) fprintf(stderr,
				    "testd: -P port invalid.\n");
				return (1);
			}
			testd_port = tmp;
			break;
		default:
			fprintf(stderr, "usage: testd [-v] [-r]\n");
			exit(1);
		}
	}

	(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	/*
	 * 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)) {
		fprintf(stderr, "warning: unable to set udp/tcp EXCLBIND\n");
	}

	if (testd_port < 0 || testd_port > UINT16_MAX) {
		fprintf(stderr, "unable to use specified port\n");
		exit(1);
	}

	/*
	 * Make sure to unregister any previous versions in case the
	 * user is reconfiguring the server in interesting ways.
	 */
	test_svc_unreg();

	/*
	 * Enumerate network transports and create service listeners
	 * as appropriate for each.
	 */
	if ((nc = setnetconfig()) == NULL) {
		perror("setnetconfig failed");
		return (-1);
	}
	while ((nconf = getnetconfig(nc)) != NULL) {
		/*
		 * Skip things like tpi_raw, invisible...
		 */
		if ((nconf->nc_flag & NC_VISIBLE) == 0)
			continue;
		if (nconf->nc_semantics != NC_TPI_CLTS &&
		    nconf->nc_semantics != NC_TPI_COTS &&
		    nconf->nc_semantics != NC_TPI_COTS_ORD)
			continue;

		test_svc_tp_create(nconf);
	}
	(void) endnetconfig(nc);

	/*
	 * XXX: Normally would call svc_run() here, but
	 * we just want to check our IP bindings.
	 */
	if (testd_port != 0)
		bind2();

	if (debug) {
		char sysbuf[100];

		snprintf(sysbuf, sizeof (sysbuf),
		    "rpcinfo -p |grep %u", TESTPROG);
		printf("x %s\n", sysbuf);
		fflush(stdout);
		system(sysbuf);

		if (testd_port) {
			snprintf(sysbuf, sizeof (sysbuf),
			    "netstat -a -f inet -P udp |grep %u", testd_port);
			printf("x %s\n", sysbuf);
			fflush(stdout);
			system(sysbuf);

			snprintf(sysbuf, sizeof (sysbuf),
			    "netstat -a -f inet -P tcp |grep %u", testd_port);
			printf("x %s\n", sysbuf);
			fflush(stdout);
			system(sysbuf);
		}
	}

	/* cleanup */
	test_svc_unreg();

	printf("%s complete\n", argv[0]);
	return (0);
}

/*
 * Server procedure switch routine
 */
static void
mysvc(struct svc_req *rq, SVCXPRT *xprt)
{

	switch (rq->rq_proc) {
	case NULLPROC:
		errno = 0;
		(void) svc_sendreply(xprt, xdr_void, (char *)0);
		return;

	default:
		svcerr_noproc(xprt);
		return;
	}
}

struct sockaddr_in addr;

/*
 * The actual test: Try doing a 2nd bind with a specific IP.
 * The exclusive wildcard bind should prvent this.
 */
static void
bind2(void)
{
	int ret;
	int sock;

	addr.sin_family = AF_INET;
	addr.sin_port = htons(testd_port);
	addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock == -1) {
		fprintf(stderr, "bind2 socket fail %s\n",
		    strerror(errno));
		exit(1);
	}

	ret = bind(sock, (struct sockaddr *)&addr, sizeof (addr));
	if (ret == -1) {
		fprintf(stderr, "bind2 bind fail %s (expected) PASS\n",
		    strerror(errno));
		close(sock);
		return;
	}

	printf("Oh no, bind2 worked! test FAILED\n");
	close(sock);
}