/* BEGIN_ICS_COPYRIGHT7 ****************************************

Copyright (c) 2015-2023, Intel Corporation

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of Intel Corporation nor the names of its contributors
      may be used to endorse or promote products derived from this software
      without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

** END_ICS_COPYRIGHT7   ****************************************/

/* [ICS VERSION STRING: unknown] */


/*******************************************************************************
 *
 * File: ethxmlextract.c
 *
 * Description:
 *	This file implements the ethxmlextract program.  ethxmlextract takes
 *	well-formed XML as input, extracts element values as specified by user
 *	input, and outputs data as lines (records) of data in CSV format.
 *
 *	ethxmlextract uses XML Lib to parse the XML.  It uses the folowing library
 *	functions:
 *	  IXmlParseFile()
 *
 *	ethxmlextract implements the following call-backs (handlers):
 *	  IXML_START_TAG_FUNC()
 *	  IXML_END_TAG_FUNC()
 *
 *	ethxmlextract takes 2 types of element names as input from the user - elements
 *	to be extracted, and those for which extraction is to be suppressed.  Both
 *	types of elements are stored in the Element Table (tbElements[]).  As
 *	ethxmlextract processes the XML (through the call-backs), it saves the values
 *	of elements to be extracted.  ethxmlextract outputs a record containing those
 *	values under the following conditions:
 *	  1 or more elements being extracted and containing a non-null value go out
 *	    of scope (the element containing those elements is ended)
 *	  An element changes value while it is in scope
 *
 *	During operation, ethxmlextract maintains the hierarchical "level" at which
 *	it is extracting (top-most level is 1).  Each nested element increases the
 *	level by 1.  ethxmlextract performs extraction on a (specified) element
 *	regardless of the level at which the element is found.
 *
 *	When an element is specified for suppression then no extraction will be
 *	performed during the extent of that element (begin through end).
 *	Suppression is maintained for elements specified inside the suppressed
 *	element, even if those elements have extraction specified.  Suppressed
 *	elements can be nested - ethxmlextract will resume extraction after the
 *	outermost suppressed element is ended.
 *
 *	Element names for extraction or suppression can be made context sensitive
 *	with an enclosing element name using syntax 'elem1.elem2'.  elem2 will
 *	be extracted (or extraction will be suppressed) when elem2 is enclosed
 *	by elem1.  The wildcard handling capability of XML Lib allows '*' to
 *	be specified as all or part of an element name.  The following are valid:
 *	        *.elem3  -  elem3 enclosed by any sequence of elements
 *	                    (elem1.elem3 or elem1.elem2.elem3)
 *	  elem1.*.elem3  -  elem3 enclosed by elem1 with any number of (but at
 *	                    least 1) intermediate elements.
 *
 *	ethxmlextract prepends any entered element name not containing '*'
 *	(anywhere) with '*.'.
 *
 *	NOTES:
 *	ethxmlextract performs extraction using XML Lib without maintaining
 *	its own stack of elements or element values.  Therefore it has the
 *	following characteristics:
 *	  Enclosing elements cannot contain values;
 *
 *	  If an element name specification is such that the element can be
 *	  extracted at multiple levels within the same context (enclosing
 *	  element), then when the inner-most element specification ends,
 *	  the element value becomes null (it does not revert to the outer
 *	  value).
 */


/*******************************************************************************
 *
 * INCLUDES
 */

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <iba/ipublic.h>
#include <getopt.h>
#include "ixml.h"
#include "fnmatch.h"


/*******************************************************************************
 *
 * DEFINES
 */
#define ALLOW_MULTI_MATCH		1		// allow 1 tag to match mult elements
#define SUPPRESS_AND_EXTRACT	0		// allow 1 tag to suppress and extract
										// this option not fully implemented
										// procElementEnd would need more work

#define OK  0
#define ERROR (-1)

#define NAME_PROG  "ethxmlextract"		// Program name
#define MAX_PARAMS_FILE  512			// Max number of param file parameters
#define MAX_ELEMENTS  100				// Max number of elements parsable
#define MAX_LEVEL_PARSE  MAX_ELEMENTS	// Max parsing level
#define MAX_DELIMIT_CHARS  16			// Max size of delimiter string
#define MAX_INPUT_BUF  8192				// Max size of input buffer
#define MAX_PARAM_BUF  8192				// Max size of parameter file
#define MAX_FILENAME_CHARS  256			// Max size of file name
#define WHITE_SPACE  " \t\r\n"			// White space characters
#define OPTION_LEN 2			// string length of an option(eg. -P)

// Element table entry, elements selected by user and present parsed value
typedef struct 
{
	char	*pName;						// Element name
	char	*pAttrName;					// optional Attribute Name
	char	*pAttrValue;				// optional Attribute Value
	int		lenValue;					// Length of element value
										//   < 0 : pValue alloc'd but not in use
	char	*pValue;					// Element value
	int		flags;						// Flags (see ELEM_xxx below)
	int		level;						// Element nesting level (0 - not open)
} ELEMENT_TABLE_ENTRY;

// Element table flags:
#define ELEM_NAMEPREPEND  0x80			// Data prepended to element name

// list of elements which a given tag matched and the attribute value
// which the element selected.  This is generated by the start tag handler
// and used by the end tag handler for a given "matched" tag
typedef struct
{
	int		ix;							// element table index
	int		lenAttrValue;				// length of value
	char	*pAttrValue;				// value, NULL if not outputting attr
} ELEMENT_LIST_ENTRY;

typedef struct
{
	int		numElements;			// number of entrys in list
	ELEMENT_LIST_ENTRY Elements[1];	// variable length list
} ELEMENT_LIST;


/*******************************************************************************
 *
 * LOCAL FUNCTION PROTOTYPES
 */

int delWsLead(char *pStr);
int delWsTrail(char *pStr);
void dispExtractionRecord();
void dispHeaderRecord(int argc, char ** argv);
void errUsage(void);
int findElement(int start, const char *pElement, const char **pAttrib,
				char **pValue, int *length);
int findElementDup(const ELEMENT_TABLE_ENTRY *pElement);
void getRecu_opt( int argc, char ** argv, const char *pOptShort,
	struct option tbOptLong[] );
void *procElementBeg(IXmlParserState_t *pParserState, void *pParent, const char **ppAttrib);
void procElementEnd( IXmlParserState_t *pParserState, const IXML_FIELD *pField,
	void *pObject, void *pParent, XML_Char *pContent, unsigned length,
	boolean flValid );


/*******************************************************************************
 *
 * GLOBAL VARIABLES
 */

int		g_exitstatus  = 0;
int		g_verbose  = 0;
int		g_quiet  = 0;


/*******************************************************************************
 *
 * LOCAL VARIABLES
 */

int  levelParse  = 0;					// Parse nesting level
int  numElementsTable  = 0;				// Number of elements in tbElements[]
int  numElementsExtract  = 0;			// Number of elements to extract
int  ctElementsSuppress  = 0;			// Count of suppress elements being parsed
int  flElementChangeLast = FALSE;		// tbElement[] value change flag (last line)
int  flElementChange  = FALSE;			// tbElement[] value change flag
int  flHeaderOutput  = TRUE;			// Header output flag
XML_Parser  pParser  = NULL;			// Pointer to expat parser object

FILE  * hFileInput  = NULL;				// Input file handle (default stdin)
										// Input file name (default stdin)
char  nameFileInput[MAX_FILENAME_CHARS + 1]  = "stdin";
uint32  fvDebugProg  = 0;			// Debug/Trace variable as:
										//  0MMM MMMM NNNN NNNN  SSSS 21RC SIEB SNEB

// Command line option table, each has a short and long flag name
static const char* tbShortOptions="#vHe:s:X:P:d:Z:";
struct option tbOptions[] =
{
	// Basic controls
	{ "help", no_argument, NULL, 'h' },
	{ "verbose", no_argument, NULL, 'v' },
	{ "extract", required_argument, NULL, 'e' },
	{ "suppress", required_argument, NULL, 's' },
	{ "infile", required_argument, NULL, 'X' },
	{ "pfile", required_argument, NULL, 'P' },
	{ "delimit", required_argument, NULL, 'd' },
	{ "noheader", no_argument, NULL, 'H' },
	{ "debug", required_argument, NULL, 'Z' },
	{ 0 }
};

// Element table; contains information about each element of interest.
//  Elements to be extracted are contained at the beginning of the table
//  (0 - numElementsExtract-1); elements for which extraction is suppressed
//  are contained at the end of the table
//  (numElementsExtract - numElementsTable-1).
ELEMENT_TABLE_ENTRY  tbElements[MAX_ELEMENTS + 1];

// IXML_FIELD table; contains information for the XML Lib parser.  For
// purposes of ethxmlextract, a call-back on every start tag and end tag
// is required; therefore IXML_FIELD tag is set to "*" and format to 'w'.
IXML_FIELD  tbFields[] =
{
	{tag:"*", format:'w', subfields:tbFields, start_func:procElementBeg,
		end_func:procElementEnd},
	{NULL}
};

// Delimiter string buffer
char  bfDelimit[MAX_DELIMIT_CHARS + 1] = ";";

// Input buffer
char  bfInput[MAX_INPUT_BUF];

void *mymalloc(size_t size, const char* desc)
{
	void *ret = malloc(size);
	if (! ret)
	{
		fprintf(stderr, NAME_PROG ": Unable to Allocate %s Memory\n", desc);
		exit(1);
	}
	return ret;
}

void *myrealloc(void* ptr, size_t size, const char* desc)
{
	void *ret = realloc(ptr, size);
	if (! ret)
	{
		fprintf(stderr, NAME_PROG ": Unable to Re-Allocate %s Memory\n", desc);
		exit(1);
	}
	return ret;
}

/*******************************************************************************
 *
 * delWsLead()
 *
 * Description:
 *	Delete leading white space from a string.  White space is defined by the
 *	string WHITE_SPACE.
 *
 * Inputs:
 *	   pStr - Pointer to string from which to delete leading white space
 *
 * Outputs:
 *	ERROR - pStr NULL
 *	   OK - white space deleted, no white space to delete
 */
int delWsLead(char *pStr)
{
	int		nChar;
	char	*pChar;

	if (!pStr)
		return (ERROR);

	nChar = strspn(pStr, WHITE_SPACE);
	if (nChar != 0)
	{
		pChar = pStr + nChar;
		memmove(pStr, pChar, strlen(pChar) + 1);
	}

	return (OK);

}	// End of delWsLead()


/*******************************************************************************
 *
 * delWsTrail()
 *
 * Description:
 *	Delete trailing white space from a string.  White space is defined by the
 *	string WHITE_SPACE.
 *
 * Inputs:
 *	   pStr - Pointer to string from which to delete trailing white space
 *
 * Outputs:
 *	ERROR - pStr NULL
 *	   OK - white space deleted, no white space to delete
 */
int delWsTrail(char *pStr)
{
	int		nChar;
	char	*pChar;

	if (!(pChar = pStr))
		return (ERROR);					// pStr is NULL

	while (TRUE)
	{
		// Find next non-white space char
		nChar = strspn(pChar, WHITE_SPACE);
		if (pChar[nChar])
		{
			// Find next white space char
			pChar += nChar;
			pChar += strcspn(pChar, WHITE_SPACE);
			if (!*pChar)
				break;				// No trailing white space
		}

		// Found first white space char after last non-white space char
		else
		{
			*pChar = 0;
			break;
		}

	}	// End of while (TRUE)

	return (OK);

}	// End of delWsTrail()


/*******************************************************************************
 *
 * dispExtractionRecord()
 *
 * Description:
 *	Display (output) 1 record of extraction data if element change flag
 *	indicates an element has changed since the last output.
 *
 * Inputs:
 *	none
 *
 * Outputs:
 *	none
 */
void dispExtractionRecord()
{
	int		ix;							// Loop index

	// Check element change flag
	if (!flElementChangeLast)
		return;

	// Output extraction record: element values
	for (ix = 0; ix < numElementsExtract; ix++)
	{
		(void)delWsTrail(tbElements[ix].pValue);

		if (ix > 0)
			printf("%s", bfDelimit);

		printf("%s", tbElements[ix].pValue ? tbElements[ix].pValue : "" );
	}
	printf("\n");
	flElementChangeLast = FALSE;

}	// End of dispExtractionRecord()

void printElement(FILE *f, ELEMENT_TABLE_ENTRY *pElement, int verbose)
{
	// Output complete name string if verbose or name not prepended
	if (verbose || !(pElement->flags & ELEM_NAMEPREPEND))
		fprintf(f, "%s", pElement->pName);
	else
		fprintf(f, "%s", &pElement->pName[2]);
	if (pElement->pAttrName)
	{
		fprintf(f, ":%s", pElement->pAttrName);
		if (pElement->pAttrValue)
			fprintf(f, ":%s", pElement->pAttrValue);
	}
}

/*******************************************************************************
 *
 * dispHeaderRecord()
 *
 * Description:
 *	Display (output) header line containing names of elements extracted.  This
 *	line preceeds the extraction data.  If verbose is set, preceed the header
 *	line with a line containing the program name and command line options.
 *
 * Inputs:
 *	argc, argv - Inputs to main()
 *
 * Outputs:
 *	none
 */
void dispHeaderRecord(int argc _UNUSED_, char ** argv _UNUSED_)
{
	int		ix;							// Loop index

	// Output header record only if output enabled
	if (flHeaderOutput)
	{
		// Output element names as a header
		for (ix = 0; ix < numElementsExtract; ix++)
		{
			if (ix > 0)
				printf("%s", bfDelimit);

			printElement(stdout,&tbElements[ix], g_verbose);
		}
		printf("\n");
	}

}	// End of dispHeaderRecord()


/*******************************************************************************
 *
 * errUsage()
 *
 * Description:
 *	Output information about program usage and parameters.
 *
 * Inputs:
 *	none
 *
 * Outputs:
 *	none
 */
void errUsage(void)
{
	fprintf(stderr, "Usage: " NAME_PROG " [-v][-H][-d delimiter][-e element][-s element]\n");
	fprintf(stderr, "                        [-X input_file] [-P param_file]\n");
	fprintf(stderr, "  -e/--extract element      - Specifies the name of an XML element to extract.\n");
	fprintf(stderr, "                              Elements can be nested in any order, but are output\n");
	fprintf(stderr, "                              in the order specified. Elements can be specified\n");
	fprintf(stderr, "                              multiple times, with a different attribute name or\n");
	fprintf(stderr, "                              attribute value. An optional attribute (or attribute\n");
	fprintf(stderr, "                              and value) can also be specified with elements:\n");
	fprintf(stderr, "                              -e element\n");
	fprintf(stderr, "                              -e element:attrName\n");
	fprintf(stderr, "                              -e element:attrName:attrValue\n\n");
	fprintf(stderr, "                              NOTES:\n");
	fprintf(stderr, "                              - Elements can be compound values separated by a dot.\n");
	fprintf(stderr, "                                For example, Switches.Node is a Node element\n");
	fprintf(stderr, "                                contained within a Switches element.\n");
	fprintf(stderr, "                              - To output the attribute value as opposed to the\n");
	fprintf(stderr, "                                element value, a specification such as\n");
	fprintf(stderr, "                                '-e NICs.Node:id' can be used. This will output\n");
	fprintf(stderr, "                                the value of the id attribute of any Node elements\n");
	fprintf(stderr, "                                within NICs element.\n");
	fprintf(stderr, "                              - If desired, a specific element can be selected by\n");
	fprintf(stderr, "                                its attribute value, such as\n");
	fprintf(stderr, "                                '-e NICs.Node.PortInfo:LinkSpeedActive:100Gb',\n");
	fprintf(stderr, "                                which will output the value of the PortInfo element\n");
	fprintf(stderr, "                                within Node element where the PortInfo element has\n");
	fprintf(stderr, "                                an attribute of LinkSpeedActive with a value of 100Gb.\n");
#if ALLOW_MULTI_MATCH
	fprintf(stderr, "                              - A given element can be specified multiple times each\n");
	fprintf(stderr, "                                with a different AttrName or attrValue.\n");
#else
	fprintf(stderr, "                              - A given element can be specified only once.\n");
#endif
	fprintf(stderr, "  -s/--suppress element     - Specifies the name of an XML element to suppress\n");
	fprintf(stderr, "                              extraction. Can be used multiple times (in any order).\n");
	fprintf(stderr, "                              Supports the same syntax as -e.\n");
	fprintf(stderr, "  -d/--delimit delimiter    - Uses single character or string as the delimiter\n");
	fprintf(stderr, "                              between element names and element values. Default is\n");
	fprintf(stderr, "                              semicolon.\n");
	fprintf(stderr, "  -X/--infile input_file    - Parses XML from input_file.\n");
	fprintf(stderr, "  -P/--pfile param_file     - Reads command parameters from param_file.\n");
	fprintf(stderr, "  -H/--noheader             - Does not output element name header record.\n");
	fprintf(stderr, "  -v/--verbose              - Produces verbose output. Includes output progress\n");
	fprintf(stderr, "                              reports during extraction and output prepended\n");
	fprintf(stderr, "                              wildcard characters on element names in output\n");
	fprintf(stderr, "                              header record.\n");
	fprintf(stderr, "  --help                    - Produces full help text.\n");

	if (hFileInput && (hFileInput != stdin))
		fclose(hFileInput);

	exit(2);
}	// End of errUsage()


/*******************************************************************************
 *
 * findElement()
 *
 * Description:
 *	Find specified element name in element table using wildcard matching.
 *	Search suppression elements first by starting search at end of table
 *	and searching toward beginning.
 *
 * Inputs:
 *	start - first element in table to check (end of table)
 *	pElement - Pointer to element name
 *	ppAttrib - attribute list from tag being processed
 *
 * Outputs:
 *	Index of element table containing element name, else
 *	ERROR - Element name not found
 *
 *	*pValue, *length - if matched a Name:attrName style specifier, the value of
 *						the attribute matched.  Otherwise NULL,0
 *						(caller must free *pValue if non-NULL)
 */
int findElement(int start, const char *pElement, const char **ppAttrib,
				char **pValue, int *length)
{
	int		ix;

	*pValue = NULL;
	*length = 0;
	for (ix = start; ix >= 0; ix--)
	{
		ELEMENT_TABLE_ENTRY *p = &tbElements[ix];
		if (!fnmatch(p->pName, pElement, 0))
	   	{
			int i;
			if (! p->pAttrName)
				return (ix);	// match only on tag name

			// search for matching attribute
			// even index in ppAttrib is name, odd is corresponding value
			for (i=0; ppAttrib[i]; i += 2)
			{
				if (!fnmatch(p->pAttrName, ppAttrib[i], 0))
				{
					if (! p->pAttrValue)
					{
						// match on Attr Name and return attr value
						*length = strlen(ppAttrib[i+1]);
						*pValue = mymalloc(*length+1, "Attribute Value");
						strcpy(*pValue, ppAttrib[i+1]);
						return (ix);
					}
					// match on attr value
					if (! fnmatch(p->pAttrValue, ppAttrib[i+1], 0))
						return (ix);
				}
			}
		}
	}

	return (ERROR);

}	// End of findElement()


/*******************************************************************************
 *
 * findElementDup()
 *
 * Description:
 *	Find specified element name in element table using duplicate (2-way)
 *	wildcard matching.  Search element table from beginning to end since
 *	there is no need to check suppression elements first.
 *
 * Inputs:
 *	pElement - Pointer to element name
 *
 * Outputs:
 *	Index of element table containing element name, else
 *	ERROR - Element name not found
 */
int findElementDup(const ELEMENT_TABLE_ENTRY *pElement)
{
	int		ix;

	for (ix = 0; ix < numElementsTable; ix++)
	{
		ELEMENT_TABLE_ENTRY *p = &tbElements[ix];
		if (0 == fnmatch(p->pName, pElement->pName, 0)
			|| 0 == fnmatch(pElement->pName, p->pName, 0))
		{
#if ALLOW_MULTI_MATCH
			if ((p->pAttrName == NULL) != (pElement->pAttrName == NULL))
				continue;
			if (p->pAttrName && pElement->pAttrName)
			{
				if ( 0 == fnmatch(p->pAttrName, pElement->pAttrName, 0) ||
						0 == fnmatch(pElement->pAttrName, p->pAttrName, 0) )
				{
					if ((p->pAttrValue == NULL) != (pElement->pAttrValue == NULL))
						continue;
					if ( p->pAttrValue && pElement->pAttrValue &&
							! ( 0 == fnmatch(p->pAttrValue, pElement->pAttrValue, 0) ||
							0 == fnmatch(pElement->pAttrValue, p->pAttrValue, 0) ) )
						continue;

					return (ix);
				}

				continue;
			}
#else
			// allow different values for same attr because won't both match
			// the same tag
			if (p->pAttrName && pElement->pAttrName
				&& (0 == fnmatch(p->pAttrName, pElement->pAttrName, 0)
					|| 0 == fnmatch(pElement->pAttrName, p->pAttrName, 0))
				&& p->pAttrValue && pElement->pAttrValue
				&& ! (0 == fnmatch(p->pAttrValue, pElement->pAttrValue, 0)
						|| 0 == fnmatch(pElement->pAttrValue, p->pAttrValue, 0)))
					continue;
#endif
			return (ix);

		}	// End of if (0 == fnmatch(p->pName, pElement->pName, 0)

	}	// End of for (ix = 0; ix < numElementsTable; ix++)

	return (ERROR);

}	// End of findElementDup()

void getNextField(const char *arg, int extra, char **field, const char **rest)
{
	const char *p = rest?strchr(arg, ':'):NULL;
	int len;

	if (p)
   	{
		len = (p-arg);
		*rest = p+1;
	} else {
		len = strlen(arg);
		if (rest)
			*rest = NULL;
	}
	*field = mymalloc(len+1+extra, "Name");
	strncpy(*field, arg, len);
	(*field)[len] = '\0';
}


/*******************************************************************************
 *
 * getRecu_opt()
 *
 * Description:
 *	Get command line options (recursively).  Parses command line options
 *	using short and long option (parameter) definitions.  Parameters (global
 *	variables) are updated appropriately.  The parameter '-P param_file' which
 *	takes command line options from a file is also handled.  The -P parameter
 *	can be used within a parameter file; in such cases the function will call
 *	itself recursively.
 *
 * Inputs:
 *	     argc - Number of input parameters
 *	     argv - Array of pointers to input parameters
 *	pOptShort - Pointer to string of short option definitions
 *	tbOptLong - Array of long option definitions
 * 
 * Outputs:
 *	none
 */
void getRecu_opt( int argc, char ** argv, const char *pOptShort,
	struct option tbOptLong[] )
{
	int		ix;
	int		cOpt;						// Option parsing char                         
	int		ixOpt;						// Option parsing index
	int		lenStr;						// String length
	char	*pChar;						// Pointer to char
	ELEMENT_TABLE_ENTRY *pElement1,		// Pointers to element entries
			*pElement2;
	int		argc_recu;					// Recursive argc
	char	*argv_recu[MAX_PARAMS_FILE];  // Recursive argv
	int		optind_recu;				// Recursive optind
	char	*optarg_recu;				// Recursive optarg

	int		ctCharParam;				// Parameter file char count
	FILE	*hFileParam = NULL;			// Parameter file handle
	char	nameFileParam[MAX_FILENAME_CHARS +1];  // Parameter file name
	char	bfParam[MAX_PARAM_BUF + 1];

	// Input command line arguments
	while ((cOpt = getopt_long(argc, argv, pOptShort, tbOptLong, &ixOpt)) != -1)
    {
		lenStr = 0;
        switch (cOpt)
        {
		// Verbose
		case 'v':
			g_verbose = 1;
			break;

		// Extract element name specification
		case 'e':
		// Suppress element name specification
		case 's':
			// syntaxes supported:
			// Name    - match Tag with given name
			// Name:attr - select attr field of Tag with given name and attr
			// Name:attr:value - match Tag with given name and attr value
			// All three components allow "glob" style patterns
			if (numElementsTable == MAX_ELEMENTS)
			{
				fprintf(stderr, NAME_PROG ": Too many Elements\n");
				errUsage();
			}

			else if (!optarg || ! *optarg)
			{
				fprintf(stderr, NAME_PROG ": Missing Element\n");
				errUsage();
			}

			else
			{
				ELEMENT_TABLE_ENTRY *pElement = &tbElements[numElementsTable];
				const char *rest;

				// Tag Name
				getNextField(optarg, 2, &pElement->pName, &rest);
				if (! strchr(optarg, '*'))
				{
					// insert *. before string (extra 2 above allowed space)
					memmove(pElement->pName+2, pElement->pName, strlen(pElement->pName)+1);
					pElement->pName[0] = '*'; pElement->pName[1] = '.';
					pElement->flags |= ELEM_NAMEPREPEND;
				}
				if (rest) {
					// optional AttrName
					if (! *rest) // trailing colon
					{
						fprintf(stderr, NAME_PROG ": Attr Name missing: %s\n", optarg);
						errUsage();
					}
					getNextField(rest, 0, &pElement->pAttrName, &rest);
					if (rest) {
						// optional AttrValue
						if (! *rest) // trailing colon
						{
							fprintf(stderr, NAME_PROG ": Attr Value missing: %s\n", optarg);
							errUsage();
						}
						getNextField(rest, 0, &pElement->pAttrValue, NULL);
					}
				}
				if ((ix = findElementDup(&tbElements[numElementsTable])) != ERROR)
				{
					fprintf(stderr, NAME_PROG ": Duplicate (matching) Element: %s (matches: ", optarg);
					printElement(stderr, &tbElements[ix], FALSE);
					fprintf(stderr, ")\n");
					errUsage();
				}

			}

			// If suppress specification, leave at end of tbElements[]
			if (cOpt == 's')
				numElementsTable++;

			// If extraction specification w/no suppress elements, leave at
			//  end of tbElements[]
			else if ((cOpt == 'e') && (numElementsExtract == numElementsTable))
			{
				numElementsTable++;
				numElementsExtract++;
			}

			// If extraction specification w/suppress elements, move extraction
			//  to end of other extractions
			else if ((cOpt == 'e') && (numElementsExtract < numElementsTable))
			{
				// Swap last element table entry with first suppress element entry
				//  (NOTE: lenValue, pValue and level are zero, so no swap needed)
				pElement1 = &tbElements[numElementsExtract++];
				pElement2 = &tbElements[numElementsTable++];

				pChar = pElement1->pName;
				pElement1->pName = pElement2->pName;
				pElement2->pName = pChar;

				pChar = pElement1->pAttrName;
				pElement1->pAttrName = pElement2->pAttrName;
				pElement2->pAttrName = pChar;

				pChar = pElement1->pAttrValue;
				pElement1->pAttrValue = pElement2->pAttrValue;
				pElement2->pAttrValue = pChar;

				lenStr = pElement1->flags;
				pElement1->flags = pElement2->flags;
				pElement2->flags = lenStr;
			}

			break;

		// Delimiter string specification
		case 'd':
			if ( !optarg || ((lenStr = strlen(optarg)) == 0) ||
					(lenStr > MAX_DELIMIT_CHARS) )
			{
				fprintf(stderr, NAME_PROG ": Invalid delimiter size: %d\n", lenStr);
				errUsage();
			}

			strncpy(bfDelimit, optarg, sizeof(bfDelimit)-1);
			// Ensure null termination
			bfDelimit[MAX_DELIMIT_CHARS]=0;
			break;

		// Input file specification
		case 'X':
			if ( !optarg || ((lenStr = strlen(optarg)) == 0) ||
					(lenStr > MAX_FILENAME_CHARS) )
			{
				fprintf(stderr, NAME_PROG ": Missing Input File Name.\n");
				errUsage();
			}

			else if (hFileInput != stdin)
			{
				fprintf( stderr, NAME_PROG ": Multiple Input Files: %s and %s\n",
					nameFileInput, optarg );
				errUsage();
			}

			strncpy(nameFileInput, optarg, sizeof(nameFileInput)-1);
			// Ensure null termination
			nameFileInput[MAX_FILENAME_CHARS]=0;
			hFileInput = fopen(nameFileInput, "r");

			if (!hFileInput)
			{
				fprintf( stderr, NAME_PROG ": Unable to Open Input File: %s\n",
					nameFileInput );
				perror("");
				errUsage();
			}
			break;

		// Parameter file specification
		case 'P':
			if (!optarg || ((lenStr = strlen(optarg)) == 0) ||
					(lenStr > MAX_FILENAME_CHARS) )
			{
				fprintf(stderr, NAME_PROG ": Missing Parameter File Name.\n");
				errUsage();
			}

			// Open parameter file
			strncpy(nameFileParam, optarg, sizeof(nameFileParam)-1);
			// Ensure null termination
			nameFileParam[MAX_FILENAME_CHARS]=0;
			hFileParam = fopen(nameFileParam, "r");

			if (!hFileParam)
			{
				fprintf( stderr, NAME_PROG ": Unable to Open Parameter File: %s\n",
					nameFileParam );
				perror("");
				errUsage();
			}

			// Read parameter file
			if (g_verbose)
				fprintf(stderr, NAME_PROG ": Reading Param File: %s\n", nameFileParam);

			ctCharParam = (int)fread(bfParam, 1, MAX_PARAM_BUF, hFileParam);

			if (ferror(hFileParam))
			{
				fclose(hFileParam);
				fprintf(stderr, NAME_PROG ": Read Error: %s\n", nameFileParam);
				errUsage();
			}

			if ((ctCharParam == MAX_PARAM_BUF) && !feof(hFileParam))
			{
				fclose(hFileParam);
				fprintf( stderr, NAME_PROG ": Parameter file (%s) too large (> %d bytes)\n",
					nameFileParam, MAX_PARAM_BUF );
				errUsage();
			}

			// Make sure the buffer is null terminated.
			bfParam[MAX_PARAM_BUF] = 0;

			fclose(hFileParam);

			if (ctCharParam > 0)
			{
				// Parse parameter file into tokens
				argc_recu = 2;
				argv_recu[0] = nameFileParam;
			
				for (ix = 1; ; ix++, argc_recu++)
				{
					if (ix == MAX_PARAMS_FILE)
					{
						fprintf( stderr, NAME_PROG ": Parameter file (%s) has too many parameters (> %d)\n",
							nameFileParam, MAX_PARAMS_FILE );
						errUsage();
					}

					if ( (argv_recu[ix] = strtok((ix == 1) ? bfParam : NULL, WHITE_SPACE))
							== NULL )
					{
						argc_recu--;
						break;
					}

					if (!strncmp(argv_recu[ix], "-P", OPTION_LEN))
					{
						fprintf( stderr, NAME_PROG ": Parameter file (%s) cannot contain -P option\n", nameFileParam);
						errUsage();
					}

					if ( (argv_recu[ix] - bfParam + strlen(argv_recu[ix]) + 1) ==
							(long unsigned int)ctCharParam )
						break;
				}

				// Process parameter file parameters
				if (argc_recu > 1)
				{
					optind_recu = optind;	// Save optind & optarg
					optarg_recu = optarg;
					optind = 1;   			// Init optind & optarg
					optarg = NULL;
					getRecu_opt(argc_recu, argv_recu, pOptShort, tbOptLong);
					optind = optind_recu;	// Restore optind & optarg
					optarg = optarg_recu;
				}

			}	// End of if (ctCharParam > 0)

			break;

		// No Header
		case 'H':
			flHeaderOutput = FALSE;
			break;

		// Debug trace specification
		case 'Z':
			if (FSUCCESS != StringToUint32(&fvDebugProg, optarg, NULL, 0, TRUE)) {
				fprintf(stderr, NAME_PROG ": Invalid Debug Setting: %s\n", optarg);
				errUsage();
			}
			break;

		case '#':
		default:
			errUsage();
			break;

        }	// End of switch (cOpt)

    }	// End of while ( ( cOpt = getopt_long( argc, argv,

	// Validate command line arguments
	if (optind < argc)
	{
		fprintf(stderr, "%s: invalid argument %s\n", NAME_PROG, argv[optind]);
		errUsage();
	}

}	// End of getRecu_opt()


/*******************************************************************************
 *
 * main()
 *
 * Description:
 *	main function for program.
 *
 * Inputs:
 *	argc - Number of input parameters
 *	argv - Array of pointers to input parameters
 *
 * Outputs:
 *	Exit status 0 - no errors
 *	Exit status 2 - error (input parameter, resources, file I/O, XML parsing)
 */
int main(int argc, char ** argv)
{
	int		ix;							// Loop index

	// Initialize for extraction
	hFileInput = stdin;

	for (ix = 0; ix < MAX_ELEMENTS; ix++)
	{
		tbElements[ix].pName = NULL;
		tbElements[ix].pAttrName = NULL;
		tbElements[ix].pAttrValue = NULL;
		tbElements[ix].lenValue = 0;
		tbElements[ix].pValue = NULL;
		tbElements[ix].flags = 0;
		tbElements[ix].level = 0;
	}
	
	// Get and validate command line arguments
	getRecu_opt(argc, argv, tbShortOptions, tbOptions);

	dispHeaderRecord(argc, argv);

	// Output progress report if g_verbose
	if (g_verbose)
		fprintf(stderr, NAME_PROG ": Parsing XML buffer\n");

	if ( IXmlParseFile(hFileInput, nameFileInput, IXML_PARSER_FLAG_NONE, tbFields, NULL, NULL, NULL, NULL, NULL, NULL) !=
			FSUCCESS )
	{
		fprintf(stderr, NAME_PROG ": XML Parse error\n");
		exit(1);
	}

	if (hFileInput && (hFileInput != stdin))
		fclose(hFileInput);

	return (g_exitstatus);

}	// End of main()

void ProcessMatchedElement( ELEMENT_TABLE_ENTRY *pElement, char *pValue,
	int length, int level )
{
	if (!length)
	{
		// Existing element value being replaced by NULL
		if (pElement->lenValue > 0)
		{
			dispExtractionRecord();
			pElement->pValue[0] = 0;
			pElement->level = level;
			flElementChange = TRUE;
		}
	}
	else
	{
		// Null element value being replaced by new value
		if (!pElement->lenValue)
		{
			// Allocate block of memory x2
			pElement->pValue = mymalloc(length + length, "Value");
			strcpy(pElement->pValue, pValue);
			pElement->lenValue = length + length;
			pElement->level = level;
			flElementChange = TRUE;
		}
		else if (pElement->lenValue < 0)
		{
			if (-pElement->lenValue <= length)
			{
				// Reallocate to larger block of memory x2
				pElement->pValue =
						myrealloc(pElement->pValue, length + length, "Value");
				pElement->lenValue = -(length + length);
			}

			strcpy(pElement->pValue, pValue);
			pElement->lenValue = -pElement->lenValue;
			pElement->level = level;
			flElementChange = TRUE;
		}

		else
		{
			// Existing element value being replaced by new (non-equal) value
			if (strcmp(pElement->pValue, pValue))
			{
				dispExtractionRecord();
				if (pElement->lenValue <= length)
				{
					// Reallocate to larger block of memory x2
					pElement->pValue =
							myrealloc(pElement->pValue, length + length, "Value");
					pElement->lenValue = length + length;
				}

				strcpy(pElement->pValue, pValue);
				pElement->level = level;
				flElementChange = TRUE;

			}	// End of if (strcmp(pElement->pValue, pValue))

		}	// End of else (else if (pElement->lenValue < 0))

	}	// End of else (!length)

}	// End of ProcessMatchedElement()

/*******************************************************************************
 *
 * procElementBeg()
 *
 * Description:
 *	Process begin element specification.  Check for whether element suppresses
 *	extraction.
 *
 * Inputs:
 *	pParserState - Pointer to IXml parser state
 *	     pParent - Pointer to element parent
 *	    ppAttrib - Pointer to pointer to element attribute data
 *
 * Outputs:
 *	none
 */
void *procElementBeg(IXmlParserState_t *pParserState, void *pParent _UNUSED_, const char **ppAttrib)
{
	int		ix;
	char	*pNameFull;
	ELEMENT_LIST* pList = NULL;
	char *pValue;
	int length;

	if (levelParse++ > MAX_LEVEL_PARSE)
	{
		fprintf( stderr, NAME_PROG ": Max Parsing Level (%d) Exceeded\n",
			MAX_LEVEL_PARSE );
		exit(1);
	}

	pNameFull = (char *)IXmlParserGetCurrentFullTag(pParserState);
	ix = numElementsTable - 1;
	do {
		if ((ix = findElement(ix, pNameFull, ppAttrib, &pValue, &length)) >= 0)
		{
#if ! SUPPRESS_AND_EXTRACT
			if (pList && ix >= numElementsExtract) // Check for suppression Element
			{
				int i;

				// discard matched extractions; replace with this suppression (below)
				for (i=0; i<pList->numElements; i++)
				{
					if (pList->Elements[i].pAttrValue)
						free(pList->Elements[i].pAttrValue);
				}
				free(pList);
				pList=NULL;
			}
#endif
			// Process extraction of attribute value immediately so that value
			//  is available with (potential) extraction values of nested lines
			if (pValue && ix < numElementsExtract)
			{
				dispExtractionRecord();
				ProcessMatchedElement( &tbElements[ix], pValue, length,
					levelParse + 1 );
				free(pValue);
			}

			// Add to pList: extraction of element value
			//               extraction of element:attribute:value
			//               any suppression specification
			else
			{
				if (pList)
				{
					// sizeof(*pList) includes 1st element
					pList = myrealloc(pList, sizeof(*pList)
											+ pList->numElements
													* sizeof(pList->Elements[0]),
											"object list");
				}
				else
				{
					pList = mymalloc(sizeof(*pList), "object list");
					pList->numElements = 0;
				}
				// findElement has malloced pValue as needed
				pList->Elements[pList->numElements].ix = ix;
				pList->Elements[pList->numElements].lenAttrValue = length;
				pList->Elements[pList->numElements].pAttrValue = pValue;
				pList->numElements++;

				// Check for suppression Element
				if (ix >= numElementsExtract)
				{
					ctElementsSuppress++;
					break;	// no use going past 1st match of a suppressed
				}
			}

			ix--;

		}	// End of if ((ix = findElement(ix, pNameFull, ppAttrib

#if ALLOW_MULTI_MATCH
	} while (ix >= 0);
#else	/* just use 1st match, like the old code did */
	} while (0);
#endif

	// return list of elements matched (NULL if none matched)
	return (void*)pList;

}	// End of procElementBeg()


/*******************************************************************************
 *
 * procElementEnd()
 *
 * Description:
 *	Process end element specification.  Check for whether element is being
 *	extracted, whether element suppresses extraction, or neither.  If the
 *	element being ended is an extraction element and is the outermost enclosing
 *	element for a group of extraction elements, output an extraction record.
 *
 * Inputs:
 *	pParserState - Pointer to IXml parser state
 *	      pField - Pointer to field
 *	     pObject - Pointer to object
 *	     pParent - Pointer to element parent
 *	      pValue - Pointer to element value (NULL terminated)
 *	      length - Length of value
 *	    ppAttrib - Pointer to pointer to element attribute data
 *	     flValid - Valid flag
 *
 * Outputs:
 *	none
 */
void procElementEnd( IXmlParserState_t *pParserState _UNUSED_, const IXML_FIELD *pField _UNUSED_,
	void *pObject, void *pParent _UNUSED_, XML_Char *pValue, unsigned length,
	boolean flValid _UNUSED_ )
{
	int		ix;
	ELEMENT_TABLE_ENTRY *pElement = NULL;
	ELEMENT_LIST* pList = (ELEMENT_LIST*)pObject;

	if (pList)
	{
		// this tag Matched one or more elements
		int i;
		for (i=0; i<pList->numElements; i++)
		{
			ix = pList->Elements[i].ix;
			ASSERT(ix >= 0);
			pElement = &tbElements[ix];

			// Check for extracted element
			if (ix < numElementsExtract)
			{
				// Check for suppression, ignore matches within suppression
				if (ctElementsSuppress == 0)
				{
					// matched extraction element
					if (!pElement->pAttrName || pElement->pAttrValue)
					{
						// operate on element value
						ProcessMatchedElement( pElement, pValue, length,
							levelParse );
					}

				}	// End of if (ctElementsSuppress == 0)

			}	// End of if (ix < numElementsExtract)
			else
			{
				// Suppress extraction element
				ctElementsSuppress--;
			}

			if (pList->Elements[i].pAttrValue)
				free(pList->Elements[i].pAttrValue);

		}	// End of for (i=0; i<pList->numElements; i++)
		free(pList);

	}	// End of if (pList)

	// Merge current element change flag into last change flag
	if (!ctElementsSuppress)
		flElementChangeLast |= flElementChange;

	flElementChange = FALSE;

	// Check for end of element which encloses extracted element(s)
	for (ix = 0; ix < numElementsExtract; ix++)
	{
		if (tbElements[ix].level > levelParse)
		{
			dispExtractionRecord();
			tbElements[ix].lenValue = -tbElements[ix].lenValue;
			tbElements[ix].pValue[0] = 0;
		   	tbElements[ix].level = 0;
		}
	}

	levelParse--;

}	// End of procElementEnd()


// End of file

