/*
 * nsm_client.c -- synthetic client and lockd simulator for testing statd
 *
 * Copyright (C) 2010  Red Hat, Jeff Layton <jlayton@redhat.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 * Very loosely based on "simulator.c" in the statd directory. Original
 * copyright for that program follows:
 *
 * Copyright (C) 1995-1997, 1999 Jeffrey A. Uphoff
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <errno.h>
#include <getopt.h>
#include <netdb.h>
#include <signal.h>
#include <string.h>
#include <rpc/rpc.h>
#include <rpc/pmap_clnt.h>
#include <rpcmisc.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

#include "nfslib.h"
#include "nfsrpc.h"
#include "nsm.h"
#include "sm_inter.h"
#include "nlm_sm_inter.h"
#include "sockaddr.h"
#include "xcommon.h"

static void daemon_simulator(void);
static void sim_killer(int sig);
static int nsm_client_crash(char *);
static int nsm_client_mon(char *, char *, char *, char *, int, int);
static int nsm_client_stat(char *, char *);
static int nsm_client_notify(char *, char *, char *);
static int nsm_client_unmon(char *, char *, char *, int, int);
static int nsm_client_unmon_all(char *, char *, int, int);

extern void nlm_sm_prog_4(struct svc_req *rqstp, register SVCXPRT *transp);
extern void svc_exit(void);

/*
 * default to 15 retransmit interval, which seems to be the default for
 * UDP clients w/ legacy glibc RPC
 */
static struct timeval retrans_interval =
{
	.tv_sec = 15,
};

static struct option longopts[] =
{
	{ "help", 0, 0, 'h' },
	{ "host", 0, 0, 'H' },
	{ "name", 1, 0, 'n' },
	{ "program", 1, 0, 'P' },
	{ "version", 1, 0, 'v' },
	{ NULL, 0, 0, 0 },
};

static int
usage(char *program)
{
	printf("Usage:\n");
	printf("%s [options] <command> [arg]...\n", program);
	printf("where command is one of these with the specified args:\n");
	printf("crash\t\t\t\ttell host to simulate crash\n");
	printf("daemon\t\t\t\t\tstart up lockd daemon simulator\n");
	printf("notify <mon_name> <state>\tsend a reboot notification to host\n");
	printf("stat <mon_name>\t\t\tget status of <mon_name> on host\n");
	printf("unmon_all\t\t\ttell host to unmon everything\n");
	printf("unmon <mon_name>\t\t\ttell host to unmon <mon_name>\n");
	printf("mon <mon_name> <cookie>\t\ttell host to monitor <mon_name> with private <cookie>\n");
	return 1;
}

static int
hex2bin(char *dst, size_t dstlen, char *src)
{
	int i;
	unsigned int tmp;

	for (i = 0; *src && i < dstlen; i++) {
		if (sscanf(src, "%2x", &tmp) != 1)
			return 0;
		dst[i] = tmp;
		src++;
		if (!*src)
			break;
		src++;
	}

	return 1;
}

static void
bin2hex(char *dst, char *src, size_t srclen)
{
	int i;

	for (i = 0; i < srclen; i++)
		dst += sprintf(dst, "%02x", 0xff & src[i]);
}

int
main(int argc, char **argv)
{
	int arg, err = 0;
	int remaining_args;
	char my_name[NI_MAXHOST], host[NI_MAXHOST];
	char cookie[SM_PRIV_SIZE];
	int my_prog = NLM_SM_PROG;
	int my_vers = NLM_SM_VERS4;

	my_name[0] = '\0';
	host[0] = '\0';

	while ((arg = getopt_long(argc, argv, "hHn:P:v:", longopts,
				  NULL)) != EOF) {
		switch (arg) {
		case 'H':
			strncpy(host, optarg, sizeof(host));
		case 'n':
			strncpy(my_name, optarg, sizeof(my_name));
		case 'P':
			my_prog = atoi(optarg);
		case 'v':
			my_vers = atoi(optarg);
		}
	}

	remaining_args = argc - optind;
	if (remaining_args <= 0)
		usage(argv[0]);

	if (!my_name[0])
		gethostname(my_name, sizeof(my_name));
	if (!host[0])
		strncpy(host, "127.0.0.1", sizeof(host));

	if (!strcasecmp(argv[optind], "daemon")) {
		daemon_simulator();
	} else if (!strcasecmp(argv[optind], "crash")) {
		err = nsm_client_crash(host);
	} else if (!strcasecmp(argv[optind], "stat")) {
		if (remaining_args < 2)
			usage(argv[0]);
		err = nsm_client_stat(host, argv[optind + 2]);
	} else if (!strcasecmp(argv[optind], "unmon_all")) {
		err = nsm_client_unmon_all(host, my_name, my_prog, my_vers);
	} else if (!strcasecmp(argv[optind], "unmon")) {
		if (remaining_args < 2)
			usage(argv[0]);
		err = nsm_client_unmon(host, argv[optind + 1], my_name, my_prog,
					my_vers);
	} else if (!strcasecmp(argv[optind], "notify")) {
		if (remaining_args < 2)
			usage(argv[0]);
		err = nsm_client_notify(host, argv[optind + 1],
					argv[optind + 2]);
	} else if (!strcasecmp(argv[optind], "mon")) {
		if (remaining_args < 2)
			usage(argv[0]);

		memset(cookie, '\0', SM_PRIV_SIZE);
		if (!hex2bin(cookie, sizeof(cookie), argv[optind + 2])) {
			fprintf(stderr, "SYS:%d\n", EINVAL);
			printf("Unable to convert hex cookie %s to binary.\n",
				argv[optind + 2]);
			return 1;
		}

		err = nsm_client_mon(host, argv[optind + 1], cookie, my_name,
					my_prog, my_vers);
	} else {
		err = usage(argv[0]);
	}

	return err;
}

static CLIENT *
nsm_client_get_rpcclient(const char *node)
{
	unsigned short		port;
	struct addrinfo		*ai;
	struct addrinfo		hints = { };
	int			err;
	CLIENT			*client = NULL;

#ifndef IPV6_ENABLED
	hints.ai_family	= AF_INET;
#endif /* IPV6_ENABLED */

	/* FIXME: allow support for providing port? */
	err = getaddrinfo(node, NULL, &hints, &ai);
	if (err) {
		fprintf(stderr, "EAI:%d\n", err);
		if (err == EAI_SYSTEM)
			fprintf(stderr, "SYS:%d\n", errno);
		printf("Unable to translate host to address: %s\n",
			err == EAI_SYSTEM ? strerror(errno) :
			gai_strerror(err));
		return client;
	}

	/* FIXME: allow for TCP too? */
	port = nfs_getport(ai->ai_addr, ai->ai_addrlen, SM_PROG,
			   SM_VERS, IPPROTO_UDP);
	if (!port) {
		fprintf(stderr, "RPC:%d\n", rpc_createerr.cf_stat);
		printf("Unable to determine port for service\n");
		goto out;
	}

	nfs_set_port(ai->ai_addr, port);

	client = nfs_get_rpcclient(ai->ai_addr, ai->ai_addrlen, IPPROTO_UDP,
				   SM_PROG, SM_VERS, &retrans_interval);
	if (!client) {
		fprintf(stderr, "RPC:%d\n", rpc_createerr.cf_stat);
		printf("RPC client creation failed\n");
	}
out:
	nfs_freeaddrinfo(ai);
	return client;
}

static int
nsm_client_mon(char *calling, char *monitoring, char *cookie, char *my_name,
		int my_prog, int my_vers)
{
	CLIENT *client;
	sm_stat_res *result;
	mon mon;
	int err = 0;

	printf("Calling %s (as %s) to monitor %s\n", calling, my_name,
		monitoring);

	if ((client = nsm_client_get_rpcclient(calling)) == NULL)
		return 1;

	memcpy(mon.priv, cookie, SM_PRIV_SIZE);
	mon.mon_id.my_id.my_name = my_name;
	mon.mon_id.my_id.my_prog = my_prog;
	mon.mon_id.my_id.my_vers = my_vers;
	mon.mon_id.my_id.my_proc = NLM_SM_NOTIFY;
	mon.mon_id.mon_name = monitoring;

	if (!(result = sm_mon_1(&mon, client))) {
		fprintf(stderr, "RPC:%d\n", rpc_createerr.cf_stat);
		printf("%s\n", clnt_sperror(client, "sm_mon_1"));
		err = 1;
		goto mon_out;
	}

	printf("SM_MON request %s, state: %d\n",
		result->res_stat == stat_succ ? "successful" : "failed",
		result->state);

	if (result->res_stat != stat_succ) {
		fprintf(stderr, "RPC:%d\n", rpc_createerr.cf_stat);
		err = 1;
	}

mon_out:
	clnt_destroy(client);
	return err;
}

static int
nsm_client_unmon(char *calling, char *unmonitoring, char *my_name, int my_prog,
		int my_vers)
{
	CLIENT *client;
	sm_stat *result;
	mon_id mon_id;
	int err = 0;

	printf("Calling %s (as %s) to unmonitor %s\n", calling, my_name,
		unmonitoring);

	if ((client = nsm_client_get_rpcclient(calling)) == NULL)
		return 1;

	mon_id.my_id.my_name = my_name;
	mon_id.my_id.my_prog = my_prog;
	mon_id.my_id.my_vers = my_vers;
	mon_id.my_id.my_proc = NLM_SM_NOTIFY;
	mon_id.mon_name = unmonitoring;

	if (!(result = sm_unmon_1(&mon_id, client))) {
		fprintf(stderr, "RPC:%d\n", rpc_createerr.cf_stat);
		printf("%s\n", clnt_sperror(client, "sm_unmon_1"));
		err = 1;
		goto unmon_out;
	}

	printf("SM_UNMON state: %d\n", result->state);

unmon_out:
	clnt_destroy(client);
	return err;
}

static int
nsm_client_unmon_all(char *calling, char *my_name, int my_prog, int my_vers)
{
	CLIENT *client;
	sm_stat *result;
	my_id my_id;
	int err = 0;

	printf("Calling %s (as %s) to unmonitor all hosts\n", calling, my_name);

	if ((client = nsm_client_get_rpcclient(calling)) == NULL) {
		printf("RPC client creation failed\n");
		return 1;
	}

	my_id.my_name = my_name;
	my_id.my_prog = my_prog;
	my_id.my_vers = my_vers;
	my_id.my_proc = NLM_SM_NOTIFY;

	if (!(result = sm_unmon_all_1(&my_id, client))) {
		fprintf(stderr, "RPC:%d\n", rpc_createerr.cf_stat);
		printf("%s\n", clnt_sperror(client, "sm_unmon_all_1"));
		err = 1;
		goto unmon_all_out;
	}

	printf("SM_UNMON_ALL state: %d\n", result->state);

unmon_all_out:
	return err;
}

static int
nsm_client_crash(char *host)
{
	CLIENT *client;

	if ((client = nsm_client_get_rpcclient(host)) == NULL)
		return 1;

	if (!sm_simu_crash_1(NULL, client)) {
		fprintf(stderr, "RPC:%d\n", rpc_createerr.cf_stat);
		printf("%s\n", clnt_sperror(client, "sm_simu_crash_1"));
		return 1;
	}

	return 0;
}

static int
nsm_client_stat(char *calling, char *monitoring)
{
	CLIENT *client;
	sm_name checking;
	sm_stat_res *result;

	if ((client = nsm_client_get_rpcclient(calling)) == NULL)
		return 1;

	checking.mon_name = monitoring;

	if (!(result = sm_stat_1(&checking, client))) {
		fprintf(stderr, "RPC:%d\n", rpc_createerr.cf_stat);
		printf("%s\n", clnt_sperror(client, "sm_stat_1"));
		return 1;
	}

	if (result->res_stat != stat_succ) {
		fprintf(stderr, "RPC:%d\n", rpc_createerr.cf_stat);
		printf("stat_fail from %s for %s, state: %d\n", calling,
			monitoring, result->state);
		return 1;
	}

	printf("stat_succ from %s for %s, state: %d\n", calling,
		monitoring, result->state);

	return 0;
}

static int
nsm_client_notify(char *calling, char *mon_name, char *statestr)
{
	CLIENT *client;

	stat_chge stat_chge = { .mon_name	= mon_name };

	stat_chge.state = atoi(statestr);

	if ((client = nsm_client_get_rpcclient(calling)) == NULL)
		return 1;

	if (!sm_notify_1(&stat_chge, client)) {
		fprintf(stderr, "RPC:%d\n", rpc_createerr.cf_stat);
		printf("%s\n", clnt_sperror(client, "sm_notify_1"));
		return 1;
	}

	return 0;
}

static void sim_killer(int sig)
{
#ifdef HAVE_LIBTIRPC
	(void) rpcb_unset(NLM_SM_PROG, NLM_SM_VERS4, NULL);
#else
	(void) pmap_unset(NLM_SM_PROG, NLM_SM_VERS4);
#endif
	exit(0);
}

static void daemon_simulator(void)
{
	signal(SIGHUP, sim_killer);
	signal(SIGINT, sim_killer);
	signal(SIGTERM, sim_killer);
	/* FIXME: allow for different versions? */
	nfs_svc_create("nlmsim", NLM_SM_PROG, NLM_SM_VERS4, nlm_sm_prog_4, 0);
	svc_run();
}

void *nlm_sm_notify_4_svc(struct nlm_sm_notify *argp, struct svc_req *rqstp)
{
	static char *result;
	char	    priv[SM_PRIV_SIZE * 2 + 1];

	bin2hex(priv, argp->priv, SM_PRIV_SIZE);

	printf("state=%d:mon_name=%s:private=%s\n", argp->state,
		argp->mon_name, priv);
	return (void *) &result;
}

void *nlm_sm_notify_3_svc(struct nlm_sm_notify *argp, struct svc_req *rqstp)
{
	return nlm_sm_notify_4_svc(argp, rqstp);
}
