/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright 2023 MNX Cloud, Inc.
 */

#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/param.h>
#include <libintl.h>
#include <locale.h>
#include <rpc/rpc.h>
#include <rpcsvc/nlm_prot.h>

#include <sys/systeminfo.h>
#include <netdb.h>
#include <nss_dbdefs.h>

#include <nfs/nfs.h>
#include <nfs/export.h>
#include <nfs/nfssys.h>

extern char *optarg;
extern int optind;
extern int _nfssys(enum nfssys_op, void *);

static int share_zap(char *, char *);

/*
 * Clear locks and v4 related state held by
 * 'client'.
 */
static int
nfs4_clr_state(char *client)
{
	int   he_error;
	char  he_buf[NSS_BUFLEN_HOSTS];
	struct hostent host_ent, *he;
	char **ap;
	struct nfs4clrst_args arg;

	if ((he = gethostbyname_r(client, &host_ent, he_buf, sizeof (he_buf),
	    &he_error)) == NULL) {
		(void) fprintf(stderr,
		    gettext("client name '%s' can not be resolved\n"), client);
		return (1);
	}

	if (he_error) {
		perror("gethostbyname");
		return (1);
	}

	/*
	 * The NFS4 clear state interface is
	 * versioned in case we need to pass
	 * more information in the future.
	 */
	arg.vers = NFS4_CLRST_VERSION;
	arg.addr_type = he->h_addrtype;

	/*
	 * Iterate over IP Addresses clear
	 * state for each.
	 */
	for (ap = he->h_addr_list; *ap; ap++) {
		arg.ap = *ap;
		if (_nfssys(NFS4_CLR_STATE, &arg) != 0) {
			perror("nfssys(NFS4_CLR_STATE)");
			return (1);
		}
	}
	return (0);
}

int
main(int argc, char *argv[])
{
	int i, c, ret;
	int sflag = 0;
	int errflg = 0;
	char myhostname[MAXHOSTNAMELEN];

	if (geteuid() != (uid_t)0) {
		(void) fprintf(stderr, gettext("clear_locks: must be root\n"));
		exit(1);
	}

	(void) setlocale(LC_ALL, "");

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

	/*
	 * Get the official hostname for this host
	 */
	sysinfo(SI_HOSTNAME, myhostname, sizeof (myhostname));

	while ((c = getopt(argc, argv, "s")) != EOF) {
		switch (c) {
		case 's':
			sflag++;
			break;
		case '?':
			errflg++;
		}
	}

	i = argc - optind;
	if (errflg || i != 1) {
		(void) fprintf(stderr,
		    gettext("Usage: clear_locks [-s] hostname\n"));
		exit(2);
	}

	if (sflag) {
		(void) fprintf(stdout, gettext(
		    "Clearing locks held for NFS client %s on server %s\n"),
		    myhostname, argv[optind]);
		ret = share_zap(myhostname, argv[optind]);
	} else {
		(void) fprintf(stdout, gettext(
		    "Clearing locks held for NFS client %s on server %s\n"),
		    argv[optind], myhostname);
		ret = share_zap(argv[optind], myhostname);
		ret += nfs4_clr_state(argv[optind]);
	}

	return (ret);
}


/*
 * Request that host 'server' free all locks held by
 * host 'client'.
 */
static int
share_zap(char *client, char *server)
{
	struct nlm_notify notify;
	enum clnt_stat rslt;

	notify.state = 0;
	notify.name = client;
	rslt = rpc_call(server, NLM_PROG, NLM_VERSX, NLM_FREE_ALL,
	    xdr_nlm_notify, (char *)&notify, xdr_void, 0, NULL);
	if (rslt != RPC_SUCCESS) {
		clnt_perrno(rslt);
		return (3);
	}
	(void) fprintf(stderr,
	    gettext("clear of locks held for %s on %s returned success\n"),
	    client, server);
	return (0);
}