xref: /titanic_53/usr/src/cmd/idmap/nltest/nltest.c (revision b3700b074e637f8c6991b70754c88a2cfffb246b)

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
 */


#include <stdio.h>
#include <libintl.h>
#include <stdlib.h>
#include <strings.h>
#include <err.h>
#include <ads/dsgetdc.h>
#include <smb/nterror.h>
#include <uuid/uuid.h>


static void dclist_usage(void);
static int cmd_dclist(char *);
static void dcname_usage(void);
static int cmd_dcname(char *);
static void dsgetdc_usage(void);
static int cmd_dsgetdc(char *);
static void dsgetdcname_usage(void);
static int cmd_dsgetdcname(char *);
static void kick_usage(void);
static int cmd_kick(char *);
static void help(void);

typedef int cmd_fn_t (char *);
typedef void cmd_usage_t (void);


static struct commands {
	const char	*name;	/* name of subcommand */
	cmd_fn_t	*fn;	/* pointer to subcommand handler function */
	cmd_usage_t	*usage;	/* pointer to subcommand help function */
	int		optreq; /* does this have a required optval */
} commands[] = {
	{"dclist", cmd_dclist, dclist_usage, 0},
	{"dcname", cmd_dcname, dcname_usage, 0},
	{"dsgetdc", cmd_dsgetdc, dsgetdc_usage, 0},
	{"dsgetdcname", cmd_dsgetdcname, dsgetdcname_usage, 0},
	{"kick", cmd_kick, kick_usage, 0},
	{NULL, NULL, NULL, 0}
};


/*
 * lookupcmd
 */
static struct commands *
lookupcmd(const char *name)
{
	struct commands *cmd;

	for (cmd = commands; cmd->name; cmd++) {
		if (strcasecmp(cmd->name, name) == 0)
			return (cmd);
	}
	return (NULL);
}

/*
 * dclist
 */
static void
dclist_usage(void)
{
	(void) printf(gettext("usage: nltest dclist... \n"));
	exit(1);
}

/* ARGSUSED */
static int
cmd_dclist(char *optval)
{
	(void) printf("cmd_dclist() \n");
	return (0);
}

/*
 * dcname
 */
static void
dcname_usage(void)
{
	(void) printf(gettext("usage: nltest dcname... \n"));
	exit(1);
}

/* ARGSUSED */
static int
cmd_dcname(char *optval)
{
	(void) printf("cmd_dcname() \n");
	return (0);
}

/*
 * dsgetdc
 */
static void
dsgetdc_usage(void)
{
	(void) printf(gettext("usage: nltest dsgetdc... \n"));
	exit(1);
}

/* ARGSUSED */
static int
cmd_dsgetdc(char *optval)
{
	(void) printf("cmd_dsgetdc() \n");
	return (0);
}

/*
 * dsgetdcname
 */
static void
dsgetdcname_usage(void)
{
	(void) printf(gettext("usage: nltest dsgetdcname domainname \n"));
	exit(1);
}

static int
cmd_dsgetdcname(char *domname)
{
	char uuid_buf[UUID_PRINTABLE_STRING_LENGTH];
	int err = 0;
	char *atype;
	DOMAIN_CONTROLLER_INFO *dcinfo;

	if (domname != NULL)
		(void) printf("  Domain name supplied:  %s \n", domname);

	err = DsGetDcName(NULL, domname, NULL, NULL, 0, &dcinfo);

	switch (err) {
	case 0:
		break;
	case ERROR_NO_SUCH_DOMAIN:
		(void) printf("Domain controller not found.\n");
		(void) printf("See: /var/run/idmap/discovery.log\n");
		exit(1);
	default:
		(void) printf("Unexpected error %d\n", err);
		exit(1);
	}

	switch (dcinfo->DomainControllerAddressType) {
	case DS_INET_ADDRESS:
		atype = "inet";
		break;
	case DS_NETBIOS_ADDRESS:
		atype = "netbios";
		break;
	default:
		atype = "?";
		break;
	}

	uuid_unparse(dcinfo->DomainGuid, uuid_buf);

	(void) printf("Data Returned from DsGetDcName() call: \n");
	(void) printf("  DC Name:  %s \n", dcinfo->DomainControllerName);
	(void) printf("  DC Addr:  %s \n", dcinfo->DomainControllerAddress);
	(void) printf("  DC Addr Type:  %s \n", atype);
	(void) printf("  Domain Name:  %s \n", dcinfo->DomainName);
	(void) printf("  Domain GUID:  %s \n", uuid_buf);
	(void) printf("  DNS Forest Name:  %s \n", dcinfo->DnsForestName);
	(void) printf("  Flags:  0x%x \n", dcinfo->Flags);
	(void) printf("  DC Site Name:  %s \n", dcinfo->DcSiteName);
	(void) printf("  Client Site Name:  %s \n", dcinfo->ClientSiteName);

	return (0);
}

/*
 * kick
 */
static void
kick_usage(void)
{
	(void) printf(gettext("usage: nltest /KICK \n"));
	exit(1);
}


static int
cmd_kick(char *domname)
{
	int flags = 0;
	int result;

	result = _DsForceRediscovery(domname, flags);

	return (result);
}

/*
 * help functions
 */

static void
help(void) {
	(void) printf("\n");
	/*
	 * TODO: We may want to revise this help text.  It's basically
	 * a copy-paste from:
	 *   http://technet.microsoft.com/en-us/library/cc731935.aspx
	 */
	(void) printf(gettext("usage: %s /subcommand\n"),
	    (char *)getexecname());
	(void) printf(gettext("where subcommands are:\n"
#if 0	/* not yet */
		" dclist        Lists all domain controllers in the domain.\n"
		" dcname        Lists the PDC or PDC emulator.\n"
		" dsgetdc       Queries DNS server for list of DCs and"
			" their IP addresses and contacts each DC to check"
			" for connectivity.\n"
#endif
		" dsgetdcname   returns the name of a domain controller in a"
			" specified domain\n"
		" help          display help on specified subcommand\n"
		" kick          trigger domain controller re-discovery\n"
		"\n"));
	exit(1);
}

int
main(int argc, char *argv[])
{
	struct commands *cmd;
	int err = 0;
	char *option_cmd = NULL;
	char *arg;
	char *p;
	char *optname;
	char *optval = NULL;
	int i;
	int optind = 1;

	/*
	 * Parse options.
	 */
	while (optind < argc) {
		arg = argv[optind];
		optname = NULL;
		optval = NULL;

		/* Is this an option? */
		if (arg[0] == '/') {
			optname = arg + 1;
			optind++;

			/*
			 * May have  /optname:value
			 */
			if ((p = strchr(optname, ':')) != NULL) {
				*p++ = '\0';
				optval = p;
			}
		} else if (arg[0] == '-' && arg[1] == '-') {
			optname = arg + 2;
			optind++;

			/*
			 * May have  --optname=value
			 */
			if ((p = strchr(optname, '=')) != NULL) {
				*p++ = '\0';
				optval = p;
			}
		} else {
			/* Not an option.  Stop parsing. */
			break;
		}

		/*
		 * Handle each optname (and maybe its optval)
		 * Might put this logic in a table of options.
		 * (including a flag for "optval required",
		 * so that check could be factored out)
		 */
		for (cmd = commands; cmd->name; cmd++) {
			if (!strcasecmp(optname, cmd->name)) {
				/* cmd->name  requires an optval */
				if (optval == NULL && optind < argc)
					optval = argv[optind++];

				if (optval == NULL && cmd->optreq > 0) {
					(void) fprintf(stderr,
					    "%s: option %s requires a value\n",
					    argv[0], optname);
					return (1);
				}
				option_cmd = optname;
			}
		}
	}

	/*
	 * Handle remaining non-option arguments
	 */
	for (i = optind; i < argc; i++) {
		(void) printf("arg: %s\n", argv[i]);
	}

	if (option_cmd == NULL)
		help();

	cmd = lookupcmd(option_cmd);
	if (cmd == NULL)
		err = 1;
	else
		err = cmd->fn(optval);

	return (err);
}