/*

 * 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 2006 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

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

/*

 * zonecfg is a lex/yacc based command interpreter used to manage zone

 * configurations.  The lexer (see zonecfg_lex.l) builds up tokens, which

 * the grammar (see zonecfg_grammar.y) builds up into commands, some of

 * which takes resources and/or properties as arguments.  See the block

 * comments near the end of zonecfg_grammar.y for how the data structures

 * which keep track of these resources and properties are built up.

 *

 * The resource/property data structures are inserted into a command

 * structure (see zonecfg.h), which also keeps track of command names,

 * miscellaneous arguments, and function handlers.  The grammar selects

 * the appropriate function handler, each of which takes a pointer to a

 * command structure as its sole argument, and invokes it.  The grammar

 * itself is "entered" (a la the Matrix) by yyparse(), which is called

 * from read_input(), our main driving function.  That in turn is called

 * by one of do_interactive(), cmd_file() or one_command_at_a_time(), each

 * of which is called from main() depending on how the program was invoked.

 *

 * The rest of this module consists of the various function handlers and

 * their helper functions.  Some of these functions, particularly the

 * X_to_str() functions, which maps command, resource and property numbers

 * to strings, are used quite liberally, as doing so results in a better

 * program w/rt I18N, reducing the need for translation notes.

 */

#include <sys/mntent.h>

#include <sys/varargs.h>

#include <sys/sysmacros.h>

#include <errno.h>

#include <strings.h>

#include <unistd.h>

#include <ctype.h>

#include <stdlib.h>

#include <assert.h>

#include <sys/stat.h>

#include <zone.h>

#include <arpa/inet.h>

#include <netdb.h>

#include <locale.h>

#include <libintl.h>

#include <alloca.h>

#include <regex.h>

#include <signal.h>

#include <libtecla.h>

#include <libzfs.h>

#include <libzonecfg.h>

#include "zonecfg.h"

#if !defined(TEXT_DOMAIN)		/* should be defined by cc -D */

#define	TEXT_DOMAIN	"SYS_TEST"	/* Use this only if it wasn't */

#endif

#define	PAGER	"/usr/bin/more"

struct help {

	uint_t	cmd_num;

	char	*cmd_name;

	uint_t	flags;

	char	*short_usage;

};

extern int yyparse(void);

extern int lex_lineno;

#define	MAX_LINE_LEN	1024

#define	MAX_CMD_HIST	1024

/*

 * Each SHELP_ should be a simple string.

 */

#define	SHELP_ADD	"add <resource-type>\n\t(global scope)\n" \

	"add <property-name> <property-value>\n\t(resource scope)"

#define	SHELP_CANCEL	"cancel"

#define	SHELP_COMMIT	"commit"

#define	SHELP_CREATE	"create [-F] [ -a <path> | -b | -t <template> ]"

#define	SHELP_DELETE	"delete [-F]"

#define	SHELP_END	"end"

#define	SHELP_EXIT	"exit [-F]"

#define	SHELP_EXPORT	"export [-f output-file]"

#define	SHELP_HELP	"help [commands] [syntax] [usage] [<command-name>]"

#define	SHELP_INFO	"info [<resource-type> [property-name=property-value]*]"

#define	SHELP_REMOVE	"remove <resource-type> { <property-name>=<property-" \

	"value> }\n\t(global scope)\nremove <property-name> <property-value>" \

	"\n\t(resource scope)"

#define	SHELP_REVERT	"revert [-F]"

#define	SHELP_SELECT	"select <resource-type> { <property-name>=" \

	"<property-value> }"

#define	SHELP_SET	"set <property-name>=<property-value>"

#define	SHELP_VERIFY	"verify"

static struct help helptab[] = {

	{ CMD_ADD,	"add",		HELP_RES_PROPS,	SHELP_ADD, },

	{ CMD_CANCEL,	"cancel",	0,		SHELP_CANCEL, },

	{ CMD_COMMIT,	"commit",	0,		SHELP_COMMIT, },

	{ CMD_CREATE,	"create",	0,		SHELP_CREATE, },

	{ CMD_DELETE,	"delete",	0,		SHELP_DELETE, },

	{ CMD_END,	"end",		0,		SHELP_END, },

	{ CMD_EXIT,	"exit",		0,		SHELP_EXIT, },

	{ CMD_EXPORT,	"export",	0,		SHELP_EXPORT, },

	{ CMD_HELP,	"help",		0,		SHELP_HELP },

	{ CMD_INFO,	"info",		HELP_RES_PROPS,	SHELP_INFO, },

	{ CMD_REMOVE,	"remove",	HELP_RES_PROPS,	SHELP_REMOVE, },

	{ CMD_REVERT,	"revert",	0,		SHELP_REVERT, },

	{ CMD_SELECT,	"select",	HELP_RES_PROPS,	SHELP_SELECT, },

	{ CMD_SET,	"set",		HELP_PROPS,	SHELP_SET, },

	{ CMD_VERIFY,	"verify",	0,		SHELP_VERIFY, },

	{ 0 },

};

#define	MAX_RT_STRLEN	16

/* These *must* match the order of the RT_ define's from zonecfg.h */

static char *res_types[] = {

	"unknown",

	"zonename",

	"zonepath",

	"autoboot",

	"pool",

	"fs",

	"inherit-pkg-dir",

	"net",

	"device",

	"rctl",

	"attr",

	"dataset",

	"limitpriv",

	NULL

};

/* These *must* match the order of the PT_ define's from zonecfg.h */

static char *prop_types[] = {

	"unknown",

	"zonename",

	"zonepath",

	"autoboot",

	"pool",

	"dir",

	"special",

	"type",

	"options",

	"address",

	"physical",

	"name",

	"value",

	"match",

	"priv",

	"limit",

	"action",

	"raw",

	"limitpriv",

	NULL

};

/* These *must* match the order of the PROP_VAL_ define's from zonecfg.h */

static char *prop_val_types[] = {

	"simple",

	"complex",

	"list",

};

/*

 * The various _cmds[] lists below are for command tab-completion.

 */

/*

 * remove has a space afterwards because it has qualifiers; the other commands

 * that have qualifiers (add, select and set) don't need a space here because

 * they have their own _cmds[] lists below.

 */

static const char *global_scope_cmds[] = {

	"add",

	"commit",

	"create",

	"delete",

	"exit",

	"export",

	"help",

	"info",

	"remove ",

	"revert",

	"select",

	"set",

	"verify",

	NULL

};

static const char *add_cmds[] = {

	"add fs",

	"add inherit-pkg-dir",

	"add net",

	"add device",

	"add rctl",

	"add attr",

	"add dataset",

	NULL

};

static const char *select_cmds[] = {

	"select fs ",

	"select inherit-pkg-dir ",

	"select net ",

	"select device ",

	"select rctl ",

	"select attr ",

	"select dataset ",

	NULL

};

static const char *set_cmds[] = {

	"set zonename=",

	"set zonepath=",

	"set autoboot=",

	"set pool=",

	"set limitpriv=",

	NULL

};

static const char *fs_res_scope_cmds[] = {

	"add options ",

	"cancel",

	"end",

	"exit",

	"help",

	"info",

	"remove options ",

	"set dir=",

	"set raw=",

	"set special=",

	"set type=",

	NULL

};

static const char *net_res_scope_cmds[] = {

	"cancel",

	"end",

	"exit",

	"help",

	"info",

	"set address=",

	"set physical=",

	NULL

};

static const char *ipd_res_scope_cmds[] = {

	"cancel",

	"end",

	"exit",

	"help",

	"info",

	"set dir=",

	NULL

};

static const char *device_res_scope_cmds[] = {

	"cancel",

	"end",

	"exit",

	"help",

	"info",

	"set match=",

	NULL

};

static const char *attr_res_scope_cmds[] = {

	"cancel",

	"end",

	"exit",

	"help",

	"info",

	"set name=",

	"set type=",

	"set value=",

	NULL

};

static const char *rctl_res_scope_cmds[] = {

	"add value ",

	"cancel",

	"end",

	"exit",

	"help",

	"info",

	"remove value ",

	"set name=",

	NULL

};

static const char *dataset_res_scope_cmds[] = {

	"cancel",

	"end",

	"exit",

	"help",

	"info",

	"set name=",

	NULL

};

/* Global variables */

/* set early in main(), never modified thereafter, used all over the place */

static char *execname;

/* set in main(), used all over the place */

static zone_dochandle_t handle;

/* used all over the place */

static char zone[ZONENAME_MAX];

static char revert_zone[ZONENAME_MAX];

/* set in modifying functions, checked in read_input() */

static bool need_to_commit = FALSE;

bool saw_error;

/* set in yacc parser, checked in read_input() */

bool newline_terminated;

/* set in main(), checked in lex error handler */

bool cmd_file_mode;

/* set in exit_func(), checked in read_input() */

static bool time_to_exit = FALSE, force_exit = FALSE;

/* used in short_usage() and zerr() */

static char *cmd_file_name = NULL;

/* checked in read_input() and other places */

static bool ok_to_prompt = FALSE;

/* set and checked in initialize() */

static bool got_handle = FALSE;

/* initialized in do_interactive(), checked in initialize() */

static bool interactive_mode;

/* set in main(), checked in multiple places */

static bool read_only_mode;

static bool global_scope = TRUE; /* scope is outer/global or inner/resource */

static int resource_scope;	/* should be in the RT_ list from zonecfg.h */

static int end_op = -1;		/* operation on end is either add or modify */

int num_prop_vals;		/* for grammar */

/*

 * These are for keeping track of resources as they are specified as part of

 * the multi-step process.  They should be initialized by add_resource() or

 * select_func() and filled in by add_property() or set_func().

 */

static struct zone_fstab	old_fstab, in_progress_fstab;

static struct zone_fstab	old_ipdtab, in_progress_ipdtab;

static struct zone_nwiftab	old_nwiftab, in_progress_nwiftab;

static struct zone_devtab	old_devtab, in_progress_devtab;

static struct zone_rctltab	old_rctltab, in_progress_rctltab;

static struct zone_attrtab	old_attrtab, in_progress_attrtab;

static struct zone_dstab	old_dstab, in_progress_dstab;

static GetLine *gl;	/* The gl_get_line() resource object */

/* Functions begin here */

static bool

initial_match(const char *line1, const char *line2, int word_end)

{

	if (word_end <= 0)

		return (TRUE);

	return (strncmp(line1, line2, word_end) == 0);

}

static int

add_stuff(WordCompletion *cpl, const char *line1, const char **list,

    int word_end)

{

	int i, err;

	for (i = 0; list[i] != NULL; i++) {

		if (initial_match(line1, list[i], word_end)) {

			err = cpl_add_completion(cpl, line1, 0, word_end,

			    list[i] + word_end, "", "");

			if (err != 0)

				return (err);

		}

	}

	return (0);

}

static

/* ARGSUSED */

CPL_MATCH_FN(cmd_cpl_fn)

{

	if (global_scope) {

		/*

		 * The MAX/MIN tests below are to make sure we have at least

		 * enough characters to distinguish from other prefixes (MAX)

		 * but only check MIN(what we have, what we're checking).

		 */

		if (strncmp(line, "add ", MAX(MIN(word_end, 4), 1)) == 0)

			return (add_stuff(cpl, line, add_cmds, word_end));

		if (strncmp(line, "select ", MAX(MIN(word_end, 7), 3)) == 0)

			return (add_stuff(cpl, line, select_cmds, word_end));

		if (strncmp(line, "set ", MAX(MIN(word_end, 4), 3)) == 0)

			return (add_stuff(cpl, line, set_cmds, word_end));

		return (add_stuff(cpl, line, global_scope_cmds, word_end));

	}

	switch (resource_scope) {

	case RT_FS:

		return (add_stuff(cpl, line, fs_res_scope_cmds, word_end));

	case RT_IPD:

		return (add_stuff(cpl, line, ipd_res_scope_cmds, word_end));

	case RT_NET:

		return (add_stuff(cpl, line, net_res_scope_cmds, word_end));

	case RT_DEVICE:

		return (add_stuff(cpl, line, device_res_scope_cmds, word_end));

	case RT_RCTL:

		return (add_stuff(cpl, line, rctl_res_scope_cmds, word_end));

	case RT_ATTR:

		return (add_stuff(cpl, line, attr_res_scope_cmds, word_end));

	case RT_DATASET:

		return (add_stuff(cpl, line, dataset_res_scope_cmds, word_end));

	}

	return (0);

}

/*

 * For the main CMD_func() functions below, several of them call getopt()

 * then check optind against argc to make sure an extra parameter was not

 * passed in.  The reason this is not caught in the grammar is that the

 * grammar just checks for a miscellaneous TOKEN, which is *expected* to

 * be "-F" (for example), but could be anything.  So (for example) this

 * check will prevent "create bogus".

 */

cmd_t *

alloc_cmd(void)

{

	return (calloc(1, sizeof (cmd_t)));

}

void

free_cmd(cmd_t *cmd)

{

	int i;

	for (i = 0; i < MAX_EQ_PROP_PAIRS; i++)

		if (cmd->cmd_property_ptr[i] != NULL) {

			property_value_ptr_t pp = cmd->cmd_property_ptr[i];

			switch (pp->pv_type) {

			case PROP_VAL_SIMPLE:

				free(pp->pv_simple);

				break;

			case PROP_VAL_COMPLEX:

				free_complex(pp->pv_complex);

				break;

			case PROP_VAL_LIST:

				free_list(pp->pv_list);

				break;

			}

		}

	for (i = 0; i < cmd->cmd_argc; i++)

		free(cmd->cmd_argv[i]);

	free(cmd);

}

complex_property_ptr_t

alloc_complex(void)

{

	return (calloc(1, sizeof (complex_property_t)));

}

void

free_complex(complex_property_ptr_t complex)

{

	if (complex == NULL)

		return;

	free_complex(complex->cp_next);

	if (complex->cp_value != NULL)

		free(complex->cp_value);

	free(complex);

}

list_property_ptr_t

alloc_list(void)

{

	return (calloc(1, sizeof (list_property_t)));

}

void

free_list(list_property_ptr_t list)