usr/src/cmd/cmd-inet/sbin/ifparse/ifparse.c - illumos-gate - Gitiles

 /*
  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 /*
  * Copyright (c) 1983 Regents of the University of California.
  * All rights reserved.  The Berkeley software License Agreement
  * specifies the terms and conditions for redistribution.
  */

 /*
  * Ifparse splits up an ifconfig command line, and was written for use
  * with the networking boot scripts; see $SRC/cmd/svc/shell/net_include.sh
  *
  * Ifparse can extract selected parts of the ifconfig command line,
  * such as failover address configuration ("ifparse -f"), or everything
  * except failover address configuration ("ifparse -s").  By default,
  * all parts of the command line are extracted (equivalent to ("ifparse -fs").
  *
  * Examples:
  *
  * The command:
  *
  * 	ifparse inet 1.2.3.4 up group two addif 1.2.3.5 up addif 1.2.3.6 up
  *
  * Produces the following on standard output:
  *
  *	set 1.2.3.4 up
  *	group two
  *	addif 1.2.3.5 up
  *	addif 1.2.3.6 up
  *
  * The optional "set" and "destination" keywords are added to make the
  * output easier to process by a script or another command.
  *
  * The command:
  *
  * 	ifparse -f inet 1.2.3.4 -failover up group two addif 1.2.3.5 up
  *
  * Produces:
  *
  *	addif 1.2.3.5  up
  *
  * Only failover address configuration has been requested.  Address
  * 1.2.3.4 is a non-failover address, and so isn't output.
  *
  * The "failover" and "-failover" commands can occur several times for
  * a given logical interface.  Only the last one counts.  For example:
  *
  *	ifparse -f inet 1.2.3.4 -failover failover -failover failover up
  *
  * Produces:
  *
  *	set 1.2.3.4 -failover failover -failover failover up
  *
  * No attempt is made to clean up such "pathological" command lines, by
  * removing redundant "failover" and "-failover" commands.
  */

 #include	<sys/types.h>
 #include	<stdlib.h>
 #include	<stdio.h>
 #include	<string.h>
 #include	<assert.h>

 /*
  * Parser flags:
  *
  *	PARSEFIXED
  *		Command should only appear if non-failover commands
  *		are requested.
  *	PARSEMOVABLE
  *		Command should only appear if failover commands are
  *		requested.
  *	PARSENOW
  *		Don't buffer the command, dump it to output immediately.
  * 	PARSEADD
  *		Indicates processing has moved on to additional
  *		logical interfaces.
  *		Dump the buffer to output and clear buffer contents.
  *	PARSESET
  * 		The "set" and "destination" keywords are optional.
  * 		This flag indicates that the next address not prefixed
  *		with a keyword will be a destination address.
  *	PARSELOG0
  *		Command not valid on additional logical interfaces.
  */

 #define	PARSEFIXED	0x01
 #define	PARSEMOVABLE	0x02
 #define	PARSENOW	0x04
 #define	PARSEADD	0x08
 #define	PARSESET	0x10
 #define	PARSELOG0	0x20

 typedef enum { AF_UNSPEC, AF_INET, AF_INET6, AF_ANY } ac_t;

 #define	NEXTARG		(-1)	/* command takes an argument */
 #define	OPTARG		(-2)	/* command takes an optional argument */

 #define	END_OF_TABLE	(-1)

 /* Parsemode, the type of commands requested by the user. */
 int	parsemode = 0;

 /* Parsetype, the type of the command currently in the buffer. */
 int	parsetype = PARSEFIXED | PARSEMOVABLE;

 /* Parsebuf, pointer to the buffer. */
 char	*parsebuf = NULL;

 /* Parsebuflen, the size of the buffer area. */
 unsigned parsebuflen = 0;

 /* Parsedumplen, the amount of the buffer currently in use. */
 unsigned parsedumplen = 0;

 /*
  * Setaddr, used to decide whether an address without a keyword
  * prefix is a source or destination address.
  */
 boolean_t setaddr = _B_FALSE;

 /*
  * Some ifconfig commands are only valid on the first logical interface.
  * As soon as an "addif" command is seen, "addint" is set.
  */
 boolean_t addint = _B_FALSE;

 /*
  * The parser table is based on that in ifconfig.  A command may or
  * may not have an argument, as indicated by whether NEXTARG/OPTARG is
  * in the second column.  Some commands can only be used with certain
  * address families, as indicated in the third column.  The fourth column
  * contains flags that control parser action.
  *
  * Ifparse buffers logical interface configuration commands such as "set",
  * "netmask" and "broadcast".  This buffering continues until an "addif"
  * command is seen, at which point the buffer is emptied, and the process
  * starts again.
  *
  * Some commands do not relate to logical interface configuration and are
  * dumped to output as soon as they are seen, such as "group" and "standby".
  *
  */

 struct	cmd {
 	char	*c_name;
 	int	c_parameter;		/* NEXTARG means next argv */
 	int	c_af;			/* address family restrictions */
 	int	c_parseflags;		/* parsing flags */
 } cmds[] = {
 	{ "up",			0,		AF_ANY, 0 },
 	{ "down",		0,		AF_ANY, 0 },
 	{ "trailers",		0, 		AF_ANY, PARSENOW },
 	{ "-trailers",		0,		AF_ANY, PARSENOW },
 	{ "arp",		0,		AF_INET, PARSENOW },
 	{ "-arp",		0,		AF_INET, PARSENOW },
 	{ "private",		0,		AF_ANY, 0 },
 	{ "-private",		0,		AF_ANY, 0 },
 	{ "router",		0,		AF_ANY, PARSELOG0 },
 	{ "-router",		0,		AF_ANY, PARSELOG0 },
 	{ "xmit",		0,		AF_ANY, 0 },
 	{ "-xmit",		0,		AF_ANY, 0 },
 	{ "-nud",		0,		AF_INET6, PARSENOW },
 	{ "nud",		0,		AF_INET6, PARSENOW },
 	{ "anycast",		0,		AF_ANY, 0 },
 	{ "-anycast",		0,		AF_ANY, 0 },
 	{ "local",		0,		AF_ANY, 0 },
 	{ "-local",		0,		AF_ANY, 0 },
 	{ "deprecated",		0,		AF_ANY, 0 },
 	{ "-deprecated", 	0, 		AF_ANY, 0 },
 	{ "preferred",		0,		AF_INET6, 0 },
 	{ "-preferred",		0,		AF_INET6, 0 },
 	{ "debug",		0,		AF_ANY, PARSENOW },
 	{ "verbose",		0,		AF_ANY, PARSENOW },
 	{ "netmask",		NEXTARG,	AF_INET, 0 },
 	{ "metric",		NEXTARG,	AF_ANY, 0 },
 	{ "mtu",		NEXTARG,	AF_ANY, 0 },
 	{ "index",		NEXTARG,	AF_ANY, PARSELOG0 },
 	{ "broadcast",		NEXTARG,	AF_INET, 0 },
 	{ "auto-revarp", 	0,		AF_INET, PARSEFIXED},
 	{ "plumb",		0,		AF_ANY, PARSENOW },
 	{ "unplumb",		0,		AF_ANY, PARSENOW },
 	{ "ipmp",		0,		AF_ANY, PARSELOG0 },
 	{ "subnet",		NEXTARG,	AF_ANY, 0 },
 	{ "token",		NEXTARG,	AF_INET6, PARSELOG0 },
 	{ "tsrc",		NEXTARG,	AF_ANY, PARSELOG0 },
 	{ "tdst",		NEXTARG,	AF_ANY, PARSELOG0 },
 	{ "encr_auth_algs", 	NEXTARG,	AF_ANY, PARSELOG0 },
 	{ "encr_algs",		NEXTARG,	AF_ANY, PARSELOG0 },
 	{ "auth_algs",		NEXTARG,	AF_ANY, PARSELOG0 },
 	{ "addif",		NEXTARG,	AF_ANY, PARSEADD },
 	{ "removeif",		NEXTARG,	AF_ANY, PARSELOG0 },
 	{ "modlist",		0,		AF_ANY, PARSENOW },
 	{ "modinsert",		NEXTARG,	AF_ANY, PARSENOW },
 	{ "modremove",		NEXTARG,	AF_ANY, PARSENOW },
 	{ "failover",		0,		AF_ANY, PARSEMOVABLE },
 	{ "-failover",		0, 		AF_ANY, PARSEFIXED },
 	{ "standby",		0,		AF_ANY, PARSENOW },
 	{ "-standby",		0,		AF_ANY, PARSENOW },
 	{ "failed",		0,		AF_ANY, PARSENOW },
 	{ "-failed",		0,		AF_ANY, PARSENOW },
 	{ "group",		NEXTARG,	AF_ANY, PARSELOG0 },
 	{ "configinfo",		0,		AF_ANY, PARSENOW },
 	{ "encaplimit",		NEXTARG,	AF_ANY,	PARSELOG0 },
 	{ "-encaplimit",	0,		AF_ANY,	PARSELOG0 },
 	{ "thoplimit",		NEXTARG,	AF_ANY, PARSELOG0 },
 	{ "set",		NEXTARG,	AF_ANY, PARSESET },
 	{ "destination",	NEXTARG,	AF_ANY, 0 },
 	{ "zone",		NEXTARG,	AF_ANY, 0 },
 	{ "-zone",		0,		AF_ANY, 0 },
 	{ "all-zones",		0,		AF_ANY, 0 },
 	{ "ether",		OPTARG,		AF_ANY, PARSENOW },
 	{ "usesrc",		NEXTARG,	AF_ANY, PARSENOW },
 	{ 0 /* ether addr */,	0,		AF_UNSPEC, PARSELOG0 },
 	{ 0 /* set */,		0,		AF_ANY, PARSESET },
 	{ 0 /* destination */,	0,		AF_ANY, 0 },
 	{ 0,			END_OF_TABLE,	END_OF_TABLE, END_OF_TABLE},
 };


 /* Known address families */
 struct afswtch {
 	char *af_name;
 	short af_af;
 } afs[] = {
 	{ "inet",	AF_INET },
 	{ "ether",	AF_UNSPEC },
 	{ "inet6",	AF_INET6 },
 	{ 0,		0 }
 };

 /*
  * Append "item" to the buffer.  If there isn't enough room in the buffer,
  * expand it.
  */
 static void
 parse_append_buf(char *item)
 {
 	unsigned itemlen;
 	unsigned newdumplen;

 	if (item == NULL)
 		return;

 	itemlen = strlen(item);
 	newdumplen = parsedumplen + itemlen;

 	/* Expand dump buffer as needed */
 	if (parsebuflen < newdumplen)  {
 		if ((parsebuf = realloc(parsebuf, newdumplen)) == NULL) {
 			perror("ifparse");
 			exit(1);
 		}
 		parsebuflen = newdumplen;
 	}
 	(void) memcpy(parsebuf + parsedumplen, item, itemlen);

 	parsedumplen = newdumplen;
 }

 /*
  * Dump the buffer to output.
  */
 static void
 parse_dump_buf(void)
 {
 	/*
 	 * When parsing, a set or addif command,  we may be some way into
 	 * the command before we definitely know it is movable or fixed.
 	 * If we get to the end of the command, and haven't seen a
 	 * "failover" or "-failover" flag, the command is movable.
 	 */
 	if (!((parsemode == PARSEFIXED) && (parsetype & PARSEMOVABLE) != 0) &&
 	    (parsemode & parsetype) != 0 && parsedumplen != 0) {
 		unsigned i;

 		if (parsebuf[parsedumplen] == ' ')
 			parsedumplen--;

 		for (i = 0; i < parsedumplen; i++)
 			(void) putchar(parsebuf[i]);

 		(void) putchar('\n');
 	}
 	/* The buffer is kept in case there is more parsing to do */
 	parsedumplen = 0;
 	parsetype = PARSEFIXED | PARSEMOVABLE;
 }

 /*
  * Process a command.  The command will either be put in the buffer,
  * or dumped directly to output.  The current contents of the buffer
  * may be dumped to output.
  *
  * The buffer holds commands relating to a particular logical interface.
  * For example, "set", "destination", "failover", "broadcast", all relate
  * to a particular interface.  Such commands have to be buffered until
  * all the "failover" and "-failover" commands for that interface have
  * been seen, only then will we know whether the command is movable
  * or not.  When the "addif" command is seen, we know we are about to
  * start processing a new logical interface, we've seen all the
  * "failover" and "-failover" commands for the previous interface, and
  * can decide whether the buffer contents are movable or not.
  *
  */
 static void
 parsedump(char *cmd, int param, int flags, char *arg)
 {
 	char *cmdname;	/* Command name	*/
 	char *cmdarg;	/* Argument to command, if it takes one, or NULL */

 	/*
 	 * Is command only valid on logical interface 0?
 	 * If processing commands on an additional logical interface, ignore
 	 * the command.
 	 * If processing commands on logical interface 0, don't buffer the
 	 * command, dump it straight to output.
 	 */
 	if ((flags & PARSELOG0) != 0) {
 		if (addint)
 			return;
 		flags |= PARSENOW;
 	}

 	/*
 	 * If processing the "addif" command, a destination address may
 	 * follow without the "destination" prefix.  Add PARSESET to the
 	 * flags so that such an anonymous address is processed correctly.
 	 */
 	if ((flags & PARSEADD) != 0) {
 		flags |= PARSESET;
 		addint = _B_TRUE;
 	}

 	/*
 	 * Commands that must be dumped straight to output are always fixed
 	 * (non-movable) commands.
 	 *
 	 */
 	if ((flags & PARSENOW) != 0)
 		flags |= PARSEFIXED;

 	/*
 	 * Source and destination addresses do not have to be prefixed
 	 * with the keywords "set" or "destination".  Ifparse always
 	 * inserts the optional keyword.
 	 */
 	if (cmd == NULL) {
 		cmdarg = arg;
 		if ((flags & PARSESET) != 0)
 			cmdname = "set";
 		else if (setaddr) {
 			cmdname = "destination";
 			setaddr = _B_FALSE;
 		} else
 			cmdname = "";
 	} else {
 		cmdarg = (param == 0) ? NULL : arg;
 		cmdname = cmd;
 	}

 	/*
 	 * The next address without a prefix will be a destination
 	 * address.
 	 */
 	if ((flags & PARSESET) != 0)
 		setaddr = _B_TRUE;

 	/*
 	 * Dump the command straight to output?
 	 * Only dump the command if the parse mode specified on
 	 * the command line matches the type of the command.
 	 */
 	if ((flags & PARSENOW) != 0) {
 		if ((parsemode & flags) != 0)  {
 			(void) fputs(cmdname, stdout);
 			if (cmdarg != NULL) {
 				(void) fputc(' ', stdout);
 				(void) fputs(cmdarg, stdout);
 			}
 			(void) fputc('\n', stdout);
 		}
 		return;
 	}

 	/*
 	 * Only the commands relating to a particular logical interface
 	 * are buffered.  When an "addif" command is seen, processing is
 	 * about to start on a new logical interface, so dump the
 	 * buffer to output.
 	 */
 	if ((flags & PARSEADD) != 0)
 		parse_dump_buf();

 	/*
 	 * If the command flags indicate the command is fixed or
 	 * movable, update the type of the interface in the buffer
 	 * accordingly.  For example, "-failover" has the "PARSEFIXED"
 	 * flag, and the contents of the buffer are not movable if
 	 * "-failover" is seen.
 	 */
 	if ((flags & PARSEFIXED) != 0)
 		parsetype &= ~PARSEMOVABLE;

 	if ((flags & PARSEMOVABLE) != 0)
 		parsetype &= ~PARSEFIXED;

 	parsetype |= flags & (PARSEFIXED | PARSEMOVABLE);

 	parse_append_buf(cmdname);

 	if (cmdarg != NULL) {
 		parse_append_buf(" ");
 		parse_append_buf(cmdarg);
 	}

 	parse_append_buf(" ");
 }

 /*
  * Parse the part of the command line following the address family
  * specification, if any.
  *
  * This function is a modified version of the function "ifconfig" in
  * ifconfig.c.
  */
 static int
 ifparse(int argc, char *argv[], struct afswtch *afp)
 {
 	int af = afp->af_af;

 	if (argc == 0)
 		return (0);

 	if (strcmp(*argv, "auto-dhcp") == 0 || strcmp(*argv, "dhcp") == 0) {
 		if ((parsemode & PARSEFIXED) != NULL) {
 			while (argc) {
 				(void) fputs(*argv++, stdout);
 				if (--argc != 0)
 					(void) fputc(' ', stdout);
 				else
 					(void) fputc('\n', stdout);
 			}
 		}
 		return (0);
 	}

 	while (argc > 0) {
 		struct cmd *p;
 		boolean_t found_cmd;

 		found_cmd = _B_FALSE;
 		for (p = cmds; ; p++) {
 			assert(p->c_parseflags != END_OF_TABLE);
 			if (p->c_name) {
 				if (strcmp(*argv, p->c_name) == 0) {
 					/*
 					 * indicate that the command was
 					 * found and check to see if
 					 * the address family is valid
 					 */
 					found_cmd = _B_TRUE;
 					if (p->c_af == AF_ANY ||
 					    af == p->c_af)
 						break;
 				}
 			} else {
 				if (p->c_af == AF_ANY ||
 				    af == p->c_af)
 					break;
 			}
 		}
 		assert(p->c_parseflags != END_OF_TABLE);
 		/*
 		 * If we found the keyword, but the address family
 		 * did not match spit out an error
 		 */
 		if (found_cmd && p->c_name == 0) {
 			(void) fprintf(stderr, "ifparse: Operation %s not"
 			    " supported for %s\n", *argv, afp->af_name);
 			return (1);
 		}
 		/*
 		 * else (no keyword found), we assume it's an address
 		 * of some sort
 		 */
 		if (p->c_name == 0 && setaddr) {
 			p++;	/* got src, do dst */
 			assert(p->c_parseflags != END_OF_TABLE);
 		}

 		if (p->c_parameter == NEXTARG || p->c_parameter == OPTARG) {
 			argc--, argv++;
 			if (argc == 0 && p->c_parameter == NEXTARG) {
 				(void) fprintf(stderr,
 				    "ifparse: no argument for %s\n",
 				    p->c_name);
 				return (1);
 			}
 		}

 		/*
 		 *	Dump the command if:
 		 *
 		 *		there's no address family
 		 *		restriction
 		 *	OR
 		 *		there is a restriction AND
 		 *		the address families match
 		 */
 		if ((p->c_af == AF_ANY)	|| (af == p->c_af))
 			parsedump(p->c_name, p->c_parameter, p->c_parseflags,
 			    *argv);
 		argc--, argv++;
 	}
 	parse_dump_buf();

 	return (0);
 }

 /*
  * Print command usage on standard error.
  */
 static void
 usage(void)
 {
 	(void) fprintf(stderr,
 	    "usage: ifparse [ -fs ] <addr_family> <commands>\n");
 }

 int
 main(int argc, char *argv[])
 {
 	int c;
 	struct afswtch *afp;

 	while ((c = getopt(argc, argv, "fs")) != -1) {
 		switch ((char)c) {
 		case 'f':
 			parsemode |= PARSEMOVABLE;
 			break;
 		case 's':
 			parsemode |= PARSEFIXED;
 			break;
 		case '?':
 			usage();
 			exit(1);
 		}
 	}

 	if (parsemode == 0)
 		parsemode = PARSEFIXED | PARSEMOVABLE;

 	argc -= optind;
 	argv += optind;

 	afp = afs;
 	if (argc > 0) {
 		struct afswtch *aftp;
 		for (aftp = afs; aftp->af_name; aftp++) {
 			if (strcmp(aftp->af_name, *argv) == 0) {
 				argc--; argv++;
 				afp = aftp;
 				break;
 			}
 		}
 	}

 	return (ifparse(argc, argv, afp));
 }
	/*
	* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
	* Use is subject to license terms.
	*/
	/*
	* Copyright (c) 1983 Regents of the University of California.
	* All rights reserved. The Berkeley software License Agreement
	* specifies the terms and conditions for redistribution.
	*/

	/*
	* Ifparse splits up an ifconfig command line, and was written for use
	* with the networking boot scripts; see $SRC/cmd/svc/shell/net_include.sh
	*
	* Ifparse can extract selected parts of the ifconfig command line,
	* such as failover address configuration ("ifparse -f"), or everything
	* except failover address configuration ("ifparse -s"). By default,
	* all parts of the command line are extracted (equivalent to ("ifparse -fs").
	*
	* Examples:
	*
	* The command:
	*
	* ifparse inet 1.2.3.4 up group two addif 1.2.3.5 up addif 1.2.3.6 up
	*
	* Produces the following on standard output:
	*
	* set 1.2.3.4 up
	* group two
	* addif 1.2.3.5 up
	* addif 1.2.3.6 up
	*
	* The optional "set" and "destination" keywords are added to make the
	* output easier to process by a script or another command.
	*
	* The command:
	*
	* ifparse -f inet 1.2.3.4 -failover up group two addif 1.2.3.5 up
	*
	* Produces:
	*
	* addif 1.2.3.5 up
	*
	* Only failover address configuration has been requested. Address
	* 1.2.3.4 is a non-failover address, and so isn't output.
	*
	* The "failover" and "-failover" commands can occur several times for
	* a given logical interface. Only the last one counts. For example:
	*
	* ifparse -f inet 1.2.3.4 -failover failover -failover failover up
	*
	* Produces:
	*
	* set 1.2.3.4 -failover failover -failover failover up
	*
	* No attempt is made to clean up such "pathological" command lines, by
	* removing redundant "failover" and "-failover" commands.
	*/

	#include <sys/types.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <string.h>
	#include <assert.h>

	/*
	* Parser flags:
	*
	* PARSEFIXED
	* Command should only appear if non-failover commands
	* are requested.
	* PARSEMOVABLE
	* Command should only appear if failover commands are
	* requested.
	* PARSENOW
	* Don't buffer the command, dump it to output immediately.
	* PARSEADD
	* Indicates processing has moved on to additional
	* logical interfaces.
	* Dump the buffer to output and clear buffer contents.
	* PARSESET
	* The "set" and "destination" keywords are optional.
	* This flag indicates that the next address not prefixed
	* with a keyword will be a destination address.
	* PARSELOG0
	* Command not valid on additional logical interfaces.
	*/

	#define PARSEFIXED 0x01
	#define PARSEMOVABLE 0x02
	#define PARSENOW 0x04
	#define PARSEADD 0x08
	#define PARSESET 0x10
	#define PARSELOG0 0x20

	typedef enum { AF_UNSPEC, AF_INET, AF_INET6, AF_ANY } ac_t;

	#define NEXTARG (-1) /* command takes an argument */
	#define OPTARG (-2) /* command takes an optional argument */

	#define END_OF_TABLE (-1)

	/* Parsemode, the type of commands requested by the user. */
	int parsemode = 0;

	/* Parsetype, the type of the command currently in the buffer. */
	int parsetype = PARSEFIXED \| PARSEMOVABLE;

	/* Parsebuf, pointer to the buffer. */
	char *parsebuf = NULL;

	/* Parsebuflen, the size of the buffer area. */
	unsigned parsebuflen = 0;

	/* Parsedumplen, the amount of the buffer currently in use. */
	unsigned parsedumplen = 0;

	/*
	* Setaddr, used to decide whether an address without a keyword
	* prefix is a source or destination address.
	*/
	boolean_t setaddr = _B_FALSE;

	/*
	* Some ifconfig commands are only valid on the first logical interface.
	* As soon as an "addif" command is seen, "addint" is set.
	*/
	boolean_t addint = _B_FALSE;

	/*
	* The parser table is based on that in ifconfig. A command may or
	* may not have an argument, as indicated by whether NEXTARG/OPTARG is
	* in the second column. Some commands can only be used with certain
	* address families, as indicated in the third column. The fourth column
	* contains flags that control parser action.
	*
	* Ifparse buffers logical interface configuration commands such as "set",
	* "netmask" and "broadcast". This buffering continues until an "addif"
	* command is seen, at which point the buffer is emptied, and the process
	* starts again.
	*
	* Some commands do not relate to logical interface configuration and are
	* dumped to output as soon as they are seen, such as "group" and "standby".
	*
	*/

	struct cmd {
	char *c_name;
	int c_parameter; /* NEXTARG means next argv */
	int c_af; /* address family restrictions */
	int c_parseflags; /* parsing flags */
	} cmds[] = {
	{ "up", 0, AF_ANY, 0 },
	{ "down", 0, AF_ANY, 0 },
	{ "trailers", 0, AF_ANY, PARSENOW },
	{ "-trailers", 0, AF_ANY, PARSENOW },
	{ "arp", 0, AF_INET, PARSENOW },
	{ "-arp", 0, AF_INET, PARSENOW },
	{ "private", 0, AF_ANY, 0 },
	{ "-private", 0, AF_ANY, 0 },
	{ "router", 0, AF_ANY, PARSELOG0 },
	{ "-router", 0, AF_ANY, PARSELOG0 },
	{ "xmit", 0, AF_ANY, 0 },
	{ "-xmit", 0, AF_ANY, 0 },
	{ "-nud", 0, AF_INET6, PARSENOW },
	{ "nud", 0, AF_INET6, PARSENOW },
	{ "anycast", 0, AF_ANY, 0 },
	{ "-anycast", 0, AF_ANY, 0 },
	{ "local", 0, AF_ANY, 0 },
	{ "-local", 0, AF_ANY, 0 },
	{ "deprecated", 0, AF_ANY, 0 },
	{ "-deprecated", 0, AF_ANY, 0 },
	{ "preferred", 0, AF_INET6, 0 },
	{ "-preferred", 0, AF_INET6, 0 },
	{ "debug", 0, AF_ANY, PARSENOW },
	{ "verbose", 0, AF_ANY, PARSENOW },
	{ "netmask", NEXTARG, AF_INET, 0 },
	{ "metric", NEXTARG, AF_ANY, 0 },
	{ "mtu", NEXTARG, AF_ANY, 0 },
	{ "index", NEXTARG, AF_ANY, PARSELOG0 },
	{ "broadcast", NEXTARG, AF_INET, 0 },
	{ "auto-revarp", 0, AF_INET, PARSEFIXED},
	{ "plumb", 0, AF_ANY, PARSENOW },
	{ "unplumb", 0, AF_ANY, PARSENOW },
	{ "ipmp", 0, AF_ANY, PARSELOG0 },
	{ "subnet", NEXTARG, AF_ANY, 0 },
	{ "token", NEXTARG, AF_INET6, PARSELOG0 },
	{ "tsrc", NEXTARG, AF_ANY, PARSELOG0 },
	{ "tdst", NEXTARG, AF_ANY, PARSELOG0 },
	{ "encr_auth_algs", NEXTARG, AF_ANY, PARSELOG0 },
	{ "encr_algs", NEXTARG, AF_ANY, PARSELOG0 },
	{ "auth_algs", NEXTARG, AF_ANY, PARSELOG0 },
	{ "addif", NEXTARG, AF_ANY, PARSEADD },
	{ "removeif", NEXTARG, AF_ANY, PARSELOG0 },
	{ "modlist", 0, AF_ANY, PARSENOW },
	{ "modinsert", NEXTARG, AF_ANY, PARSENOW },
	{ "modremove", NEXTARG, AF_ANY, PARSENOW },
	{ "failover", 0, AF_ANY, PARSEMOVABLE },
	{ "-failover", 0, AF_ANY, PARSEFIXED },
	{ "standby", 0, AF_ANY, PARSENOW },
	{ "-standby", 0, AF_ANY, PARSENOW },
	{ "failed", 0, AF_ANY, PARSENOW },
	{ "-failed", 0, AF_ANY, PARSENOW },
	{ "group", NEXTARG, AF_ANY, PARSELOG0 },
	{ "configinfo", 0, AF_ANY, PARSENOW },
	{ "encaplimit", NEXTARG, AF_ANY, PARSELOG0 },
	{ "-encaplimit", 0, AF_ANY, PARSELOG0 },
	{ "thoplimit", NEXTARG, AF_ANY, PARSELOG0 },
	{ "set", NEXTARG, AF_ANY, PARSESET },
	{ "destination", NEXTARG, AF_ANY, 0 },
	{ "zone", NEXTARG, AF_ANY, 0 },
	{ "-zone", 0, AF_ANY, 0 },
	{ "all-zones", 0, AF_ANY, 0 },
	{ "ether", OPTARG, AF_ANY, PARSENOW },
	{ "usesrc", NEXTARG, AF_ANY, PARSENOW },
	{ 0 /* ether addr */, 0, AF_UNSPEC, PARSELOG0 },
	{ 0 /* set */, 0, AF_ANY, PARSESET },
	{ 0 /* destination */, 0, AF_ANY, 0 },
	{ 0, END_OF_TABLE, END_OF_TABLE, END_OF_TABLE},
	};


	/* Known address families */
	struct afswtch {
	char *af_name;
	short af_af;
	} afs[] = {
	{ "inet", AF_INET },
	{ "ether", AF_UNSPEC },
	{ "inet6", AF_INET6 },
	{ 0, 0 }
	};

	/*
	* Append "item" to the buffer. If there isn't enough room in the buffer,
	* expand it.
	*/
	static void
	parse_append_buf(char *item)
	{
	unsigned itemlen;
	unsigned newdumplen;

	if (item == NULL)
	return;

	itemlen = strlen(item);
	newdumplen = parsedumplen + itemlen;

	/* Expand dump buffer as needed */
	if (parsebuflen < newdumplen) {
	if ((parsebuf = realloc(parsebuf, newdumplen)) == NULL) {
	perror("ifparse");
	exit(1);
	}
	parsebuflen = newdumplen;
	}
	(void) memcpy(parsebuf + parsedumplen, item, itemlen);

	parsedumplen = newdumplen;
	}

	/*
	* Dump the buffer to output.
	*/
	static void
	parse_dump_buf(void)
	{
	/*
	* When parsing, a set or addif command, we may be some way into
	* the command before we definitely know it is movable or fixed.
	* If we get to the end of the command, and haven't seen a
	* "failover" or "-failover" flag, the command is movable.
	*/
	if (!((parsemode == PARSEFIXED) && (parsetype & PARSEMOVABLE) != 0) &&
	(parsemode & parsetype) != 0 && parsedumplen != 0) {
	unsigned i;

	if (parsebuf[parsedumplen] == ' ')
	parsedumplen--;

	for (i = 0; i < parsedumplen; i++)
	(void) putchar(parsebuf[i]);

	(void) putchar('\n');
	}
	/* The buffer is kept in case there is more parsing to do */
	parsedumplen = 0;
	parsetype = PARSEFIXED \| PARSEMOVABLE;
	}

	/*
	* Process a command. The command will either be put in the buffer,
	* or dumped directly to output. The current contents of the buffer
	* may be dumped to output.
	*
	* The buffer holds commands relating to a particular logical interface.
	* For example, "set", "destination", "failover", "broadcast", all relate
	* to a particular interface. Such commands have to be buffered until
	* all the "failover" and "-failover" commands for that interface have
	* been seen, only then will we know whether the command is movable
	* or not. When the "addif" command is seen, we know we are about to
	* start processing a new logical interface, we've seen all the
	* "failover" and "-failover" commands for the previous interface, and
	* can decide whether the buffer contents are movable or not.
	*
	*/
	static void
	parsedump(char cmd, int param, int flags, char arg)
	{
	char cmdname; / Command name */
	char cmdarg; / Argument to command, if it takes one, or NULL */

	/*
	* Is command only valid on logical interface 0?
	* If processing commands on an additional logical interface, ignore
	* the command.
	* If processing commands on logical interface 0, don't buffer the
	* command, dump it straight to output.
	*/
	if ((flags & PARSELOG0) != 0) {
	if (addint)
	return;
	flags \|= PARSENOW;
	}

	/*
	* If processing the "addif" command, a destination address may
	* follow without the "destination" prefix. Add PARSESET to the
	* flags so that such an anonymous address is processed correctly.
	*/
	if ((flags & PARSEADD) != 0) {
	flags \|= PARSESET;
	addint = _B_TRUE;
	}

	/*
	* Commands that must be dumped straight to output are always fixed
	* (non-movable) commands.
	*
	*/
	if ((flags & PARSENOW) != 0)
	flags \|= PARSEFIXED;

	/*
	* Source and destination addresses do not have to be prefixed
	* with the keywords "set" or "destination". Ifparse always
	* inserts the optional keyword.
	*/
	if (cmd == NULL) {
	cmdarg = arg;
	if ((flags & PARSESET) != 0)
	cmdname = "set";
	else if (setaddr) {
	cmdname = "destination";
	setaddr = _B_FALSE;
	} else
	cmdname = "";
	} else {
	cmdarg = (param == 0) ? NULL : arg;
	cmdname = cmd;
	}

	/*
	* The next address without a prefix will be a destination
	* address.
	*/
	if ((flags & PARSESET) != 0)
	setaddr = _B_TRUE;

	/*
	* Dump the command straight to output?
	* Only dump the command if the parse mode specified on
	* the command line matches the type of the command.
	*/
	if ((flags & PARSENOW) != 0) {
	if ((parsemode & flags) != 0) {
	(void) fputs(cmdname, stdout);
	if (cmdarg != NULL) {
	(void) fputc(' ', stdout);
	(void) fputs(cmdarg, stdout);
	}
	(void) fputc('\n', stdout);
	}
	return;
	}

	/*
	* Only the commands relating to a particular logical interface
	* are buffered. When an "addif" command is seen, processing is
	* about to start on a new logical interface, so dump the
	* buffer to output.
	*/
	if ((flags & PARSEADD) != 0)
	parse_dump_buf();

	/*
	* If the command flags indicate the command is fixed or
	* movable, update the type of the interface in the buffer
	* accordingly. For example, "-failover" has the "PARSEFIXED"
	* flag, and the contents of the buffer are not movable if
	* "-failover" is seen.
	*/
	if ((flags & PARSEFIXED) != 0)
	parsetype &= ~PARSEMOVABLE;

	if ((flags & PARSEMOVABLE) != 0)
	parsetype &= ~PARSEFIXED;

	parsetype \|= flags & (PARSEFIXED \| PARSEMOVABLE);

	parse_append_buf(cmdname);

	if (cmdarg != NULL) {
	parse_append_buf(" ");
	parse_append_buf(cmdarg);
	}

	parse_append_buf(" ");
	}

	/*
	* Parse the part of the command line following the address family
	* specification, if any.
	*
	* This function is a modified version of the function "ifconfig" in
	* ifconfig.c.
	*/
	static int
	ifparse(int argc, char argv[], struct afswtch afp)
	{
	int af = afp->af_af;

	if (argc == 0)
	return (0);

	if (strcmp(argv, "auto-dhcp") == 0 \|\| strcmp(argv, "dhcp") == 0) {
	if ((parsemode & PARSEFIXED) != NULL) {
	while (argc) {
	(void) fputs(*argv++, stdout);
	if (--argc != 0)
	(void) fputc(' ', stdout);
	else
	(void) fputc('\n', stdout);
	}
	}
	return (0);
	}

	while (argc > 0) {
	struct cmd *p;
	boolean_t found_cmd;

	found_cmd = _B_FALSE;
	for (p = cmds; ; p++) {
	assert(p->c_parseflags != END_OF_TABLE);
	if (p->c_name) {
	if (strcmp(*argv, p->c_name) == 0) {
	/*
	* indicate that the command was
	* found and check to see if
	* the address family is valid
	*/
	found_cmd = _B_TRUE;
	if (p->c_af == AF_ANY \|\|
	af == p->c_af)
	break;
	}
	} else {
	if (p->c_af == AF_ANY \|\|
	af == p->c_af)
	break;
	}
	}
	assert(p->c_parseflags != END_OF_TABLE);
	/*
	* If we found the keyword, but the address family
	* did not match spit out an error
	*/
	if (found_cmd && p->c_name == 0) {
	(void) fprintf(stderr, "ifparse: Operation %s not"
	" supported for %s\n", *argv, afp->af_name);
	return (1);
	}
	/*
	* else (no keyword found), we assume it's an address
	* of some sort
	*/
	if (p->c_name == 0 && setaddr) {
	p++; /* got src, do dst */
	assert(p->c_parseflags != END_OF_TABLE);
	}

	if (p->c_parameter == NEXTARG \|\| p->c_parameter == OPTARG) {
	argc--, argv++;
	if (argc == 0 && p->c_parameter == NEXTARG) {
	(void) fprintf(stderr,
	"ifparse: no argument for %s\n",
	p->c_name);
	return (1);
	}
	}

	/*
	* Dump the command if:
	*
	* there's no address family
	* restriction
	* OR
	* there is a restriction AND
	* the address families match
	*/
	if ((p->c_af == AF_ANY) \|\| (af == p->c_af))
	parsedump(p->c_name, p->c_parameter, p->c_parseflags,
	*argv);
	argc--, argv++;
	}
	parse_dump_buf();

	return (0);
	}

	/*
	* Print command usage on standard error.
	*/
	static void
	usage(void)
	{
	(void) fprintf(stderr,
	"usage: ifparse [ -fs ] <addr_family> <commands>\n");
	}

	int
	main(int argc, char *argv[])
	{
	int c;
	struct afswtch *afp;

	while ((c = getopt(argc, argv, "fs")) != -1) {
	switch ((char)c) {
	case 'f':
	parsemode \|= PARSEMOVABLE;
	break;
	case 's':
	parsemode \|= PARSEFIXED;
	break;
	case '?':
	usage();
	exit(1);
	}
	}

	if (parsemode == 0)
	parsemode = PARSEFIXED \| PARSEMOVABLE;

	argc -= optind;
	argv += optind;

	afp = afs;
	if (argc > 0) {
	struct afswtch *aftp;
	for (aftp = afs; aftp->af_name; aftp++) {
	if (strcmp(aftp->af_name, *argv) == 0) {
	argc--; argv++;
	afp = aftp;
	break;
	}
	}
	}

	return (ifparse(argc, argv, afp));
	}