//////////////////////////////////////////////////////////////////////////////
// Module			: parser.cpp
//
// Purpose			: Netsh Ipsec Context Parser
//
// Developers Name	: N.Surendra Sai / Vunnam Kondal Rao
//
// History			:
//
// Date	    	Author    	Comments
// 1 Aug 2001   NSS/VKR
//
//////////////////////////////////////////////////////////////////////////////

#include "nshipsec.h"
#include "parser_util.h"

extern HINSTANCE g_hModule;
extern PVOID  g_AllocPtr[MAX_ARGS];
extern PSTA_MM_AUTH_METHODS g_paRootca[MAX_ARGS];
extern PIPSEC_QM_OFFER	g_pQmsec[IPSEC_MAX_QM_OFFERS];
extern PIPSEC_MM_OFFER	g_pMmsec[IPSEC_MAX_MM_OFFERS];

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	Parser()
//
//	Date of Creation	:	21st Aug 2001
//
//	Parameters			:	IN      LPCWSTR         pwszMachine,
//							IN      LPWSTR          *ppwcArguments,
//							IN      DWORD           dwCurrentIndex,
//							IN      DWORD           dwArgCount,
//  						IN OUT  PARSER_PKT      *pParser
//
//	Return				:	ERROR_SUCCESS
//							ERROR_SHOW_USAGE
//							RETURN_NO_ERROR
//							ERROR_INVALID_ARG
//	Description			:	This is called by any Sub-Context of IPSec whenever
//							there is a Parsing requirement
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
Parser(
	IN      LPCWSTR         pwszMachine,
	IN      LPWSTR          *ppwcArguments,
	IN      DWORD           dwCurrentIndex,
	IN      DWORD           dwArgCount,
    IN OUT  PPARSER_PKT     pParser
)
{
	const TOKEN_VALUE vtokGroupCmd[] =		// Valid Groups Considered by the Parser
	{										// For determining group context
		{ GROUP_STATIC_STR,  GROUP_STATIC 	},
		{ GROUP_DYNAMIC_STR, GROUP_DYNAMIC	}
	};
	const TOKEN_VALUE vtokPriCmd[] =		// Valid Groups Considered by the Parser
	{										// For determining primary context
	 	{ PRI_ADD_STR,				PRI_ADD 			},
	 	{ PRI_SET_STR,				PRI_SET				},
	 	{ PRI_DELETE_STR,			PRI_DELETE			},
	 	{ PRI_SHOW_STR,				PRI_SHOW			},
	 	{ PRI_EXPORTPOLICY_STR,		PRI_EXPORTPOLICY	},
	 	{ PRI_IMPORTPOLICY_STR,		PRI_IMPORTPOLICY	},
	 	{ PRI_RESTOREDEFAULTS_STR,	PRI_RESTOREDEFAULTS }
	};
	const TOKEN_VALUE vtokSecCmd[] =		// Valid Groups Considered by the Parser
	{										// For determining secondary context
		{ SEC_POLICY_STR,			SEC_POLICY 			},
		{ SEC_FILTER_STR,			SEC_FILTER			},
		{ SEC_FILTERLIST_STR,		SEC_FILTERLIST		},
		{ SEC_FILTERACTION_STR,		SEC_FILTERACTION	},
		{ SEC_RULE_STR,				SEC_RULE			},
		{ SEC_ALL_STR,				SEC_ALL				},
		{ SEC_STORE_STR,			SEC_STORE			},
		{ SEC_DEFAULTRULE_STR,		SEC_DEFAULTRULE		},
		{ SEC_ASSIGNEDPOLICY_STR,	SEC_ASSIGNEDPOLICY	},
		{ SEC_INTERACTIVE_STR,		SEC_INTERACTIVE		},
		{ SEC_MMPOLICY_STR,			SEC_MMPOLICY		},
		{ SEC_QMPOLICY_STR,			SEC_QMPOLICY		},
		{ SEC_STATS_STR,			SEC_STATS			},
		{ SEC_MMSAS_STR,			SEC_MMSAS			},
		{ SEC_QMSAS_STR,			SEC_QMSAS			},
		{ SEC_MMFILTER_STR,			SEC_MMFILTER		},
		{ SEC_QMFILTER_STR,			SEC_QMFILTER		},
		{ SEC_CONFIG_STR,			SEC_CONFIG			},
		{ SEC_BATCH_STR,			SEC_BATCH			}
	};

	const DWORD GROUP_MAX = SIZEOF_TOKEN_VALUE(vtokGroupCmd);
  	const DWORD PRI_MAX	  = SIZEOF_TOKEN_VALUE(vtokPriCmd);
	const DWORD SEC_MAX	  = SIZEOF_TOKEN_VALUE(vtokSecCmd);

	_TCHAR szListTok[MAX_STR_LEN]	= {0};			// wide string
	LPTSTR *ppwcTok 				= NULL;			// pointer to array of pointers to wstr
 	LPTSTR ppwcFirstTok[MAX_ARGS]	= {0};			// pointer to array of pointers to wstr

	DWORD dwCount	= pParser->MaxCmd;				// Num of Args after removing List Tokens

	DWORD dwCommand 				= 0;			// command determines the context
	DWORD dwNumRootca			= 0;
	DWORD dwMaxArgs 				= 0;			// for loop index
	DWORD dwPreProcessCurrentIndex	= 0;			// Current Index for Preprocess Command after RemoveList
	DWORD dwPreProcessArgCount		= 0;			// Num of args input to Preprocess Command after RemoveList

	DWORD dwTagType[MAX_ARGS]		= {0};			// Return array of Preprocess Command
	DWORD dwReturn 					= ERROR_SUCCESS;		// Default Return Value implies Error Message
	DWORD dwGroupCmd,dwPriCmd,dwSecCmd;				// Context

	PTAG_TYPE    pValidCmds 	= NULL;				// pointer to array of TAG_TYPE commands
	PTOKEN_VALUE pValidTokens	= NULL;				// pointer to array of TOKEN_VALUE tokens

	BOOL bOption				= ADD_CMD;			// default is  add only.
	BOOL bPreProcessCommand		= FALSE;				// default use PreProcessCommand
	BOOL bIsRootcaRule = FALSE;

	UpdateGetLastError(NULL);						// Error Success

	InitializeGlobalPointers();

	for(dwMaxArgs=0;dwMaxArgs<MAX_ARGS;dwMaxArgs++)	// allocate storage for list commands
	{
		g_paRootca[dwMaxArgs] = NULL;
	}

	ZeroMemory(szListTok, MAX_STR_LEN*sizeof(_TCHAR));

	pValidCmds   = (PTAG_TYPE)pParser->ValidCmd;			// Input Valid Command Table
	pValidTokens = (PTOKEN_VALUE)pParser->ValidTok;			// Input Valid Non-List Commands Table

	for(dwMaxArgs = 0;dwMaxArgs <(pParser->MaxCmd);dwMaxArgs++)	// Packet Init
	{
		(pParser->Cmd)[dwMaxArgs].dwCmdToken = dwMaxArgs+1;		// Enum Starts at 1
		(pParser->Cmd)[dwMaxArgs].pArg       = NULL;			// All ptrs
		(pParser->Cmd)[dwMaxArgs].dwStatus 	 = INVALID_TOKEN;	// Status set
	}
	dwGroupCmd = dwPriCmd = dwSecCmd = 0;		// Initialize the context variables
	switch (dwCurrentIndex)						// CurrentIndex determines Context
	{
		case SEC_CMD	:
			MatchEnumTag(g_hModule,ppwcArguments[2],SEC_MAX,  vtokSecCmd,&dwSecCmd);
			// Fall Through
		case PRI_CMD	:
			// if present
			MatchEnumTag(g_hModule,ppwcArguments[1],PRI_MAX,  vtokPriCmd,&dwPriCmd);
			// Fall Through
		case GROUP_CMD 	:
			// Should be present
			MatchEnumTag(g_hModule,ppwcArguments[0],GROUP_MAX,vtokGroupCmd,&dwGroupCmd);
			break;
		default	:
			// Should Never Come Here
			break;
	}

	dwCommand = INDEX(dwGroupCmd,dwPriCmd,dwSecCmd);	// Macro to Compute Index
	switch(dwCommand)
	{													// Based on the context
		case DYNAMIC_SET_RULE			:
		case DYNAMIC_ADD_RULE			:
		case STATIC_ADD_RULE			:				// Load the List Commands
		case STATIC_SET_RULE			:
		case STATIC_SET_DEFAULTRULE		:				// Load the List Commands
			bIsRootcaRule = TRUE;
			bPreProcessCommand = TRUE;
			break;
		case STATIC_SET_POLICY			:
			dwReturn = ParseStaticSetPolicy((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case STATIC_SET_FILTERACTION	:
			dwReturn = ParseStaticSetFilterAction((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case STATIC_SET_FILTERLIST		:
			dwReturn = ParseStaticSetFilterList((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case STATIC_SHOW_POLICY			:
			dwReturn = ParseStaticShowPolicy((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case STATIC_SHOW_FILTERLIST		:
			dwReturn = ParseStaticShowFilterList((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case STATIC_SHOW_FILTERACTION	:
			dwReturn = ParseStaticShowFilterAction((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case STATIC_SHOW_RULE			:
			dwReturn = ParseStaticShowRule((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case STATIC_SHOW_ASSIGNEDPOLICY	:
			dwReturn = ParseStaticShowAssignedPolicy((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case STATIC_SET_STORE			:
			dwReturn = ParseStaticSetStore((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case STATIC_DELETE_FILTERLIST	:
		case STATIC_DELETE_FILTERACTION :
		case STATIC_DELETE_POLICY		:
			dwReturn = ParseStaticDelPolFlistFaction((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case STATIC_DELETE_RULE			:
			dwReturn = ParseStaticDelRule((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case DYNAMIC_SHOW_MMPOLICY		:
		case DYNAMIC_SHOW_FILTERACTION	:
			dwReturn = ParseDynamicShowPolFaction((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case DYNAMIC_SHOW_QMFILTER		:
			dwReturn = ParseDynamicShowQMFilter((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case DYNAMIC_SHOW_MMFILTER		:
			dwReturn = ParseDynamicShowMMFilter((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case DYNAMIC_DELETE_FILTERACTION:
		case DYNAMIC_DELETE_MMPOLICY	:
			dwReturn = ParseDynamicDelPolFaction((LPTSTR * )ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case DYNAMIC_SHOW_QMSAS			:
			dwReturn = ParseDynamicShowQMSAS((LPTSTR *)ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		case DYNAMIC_SHOW_RULE			:
			dwReturn = ParseDynamicShowRule((LPTSTR *)ppwcArguments,pParser,dwCurrentIndex,dwArgCount);
			break;
		default							:
			bPreProcessCommand = TRUE;
			break;
	}
	if ( bPreProcessCommand == FALSE )						// It was done every thing for all 'or' commands..
	{														// So back to called context
		BAIL_OUT;
	}
	if (bIsRootcaRule)
	{
		dwReturn = RemoveRootcaAuthMethods(ppwcArguments,dwArgCount,dwCurrentIndex,pParser,NULL,g_paRootca,ppwcFirstTok,&dwNumRootca,MAX_STR_LEN, &dwCount);
		if(dwReturn != ERROR_SUCCESS)
		{
			dwReturn = RETURN_NO_ERROR;
			BAIL_OUT;
		}
	}
	else
	{	// Normalize the ppcwTok to 0 Base 'for sake of consistency
		dwCount = RemoveList(ppwcArguments,dwArgCount,dwCurrentIndex,pParser,_TEXT(""),NULL,szListTok,ppwcFirstTok,MAX_STR_LEN);
	}
	ppwcTok = (LPTSTR [MAX_ARGS])ppwcFirstTok;

	if(dwCommand == STATIC_SET_RULE)
	{
		dwReturn = ParseStaticSetRule(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
	}
	else
	{
		// Initialize the output array of PreProcess Command
		for(dwMaxArgs = 0;dwMaxArgs < MAX_ARGS;dwMaxArgs++)
		{
			dwTagType[dwMaxArgs] = 0;
		}

		dwPreProcessCurrentIndex = 0;		// Current Index for Preprocess Command after RemoveList
		dwPreProcessArgCount     = dwCount;	// Num of args input to Preprocess Command after RemoveList

		if(dwCount > MAX_ARGS)				// pParser->MaxCmd
											// Check For Max Args in the Non-List Commands
		{
			dwPreProcessArgCount = MAX_ARGS;						// pParser->MaxCmd;
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_MAXARGS_CROSSED);	// Should Never Come Here
		}															// If More Truncate...
		else
		{
			dwPreProcessArgCount = dwCount;
		}

		dwReturn = PreprocessCommand(
			g_hModule,                  // This argument is not used; should be 0.
			ppwcTok,             		// Argv style array (netsh passed us this.)
			dwPreProcessCurrentIndex,   // Means ppwcArguments[dwCurrentIndex] is the first argument of interest.
										// PpwcArguments[0] is going to be the context,
										// PpwcArguments[1] is the first command
										// So ppwcARguments[2] is the first argument of interest.
			dwPreProcessArgCount,       // Total count of all the args in ppwcArguments.
			(PTAG_TYPE)pParser->ValidCmd,
			pParser->MaxCmd,			// Number of entries in the ValidCommands array.
			1,                          // Minimum number of arguments needed to be a valid command.
			MAX_ARGS,                   // Maximum number of arguments allowed to be a valid command.
			dwTagType);                 // Array of DWORD's used to indicate which command in ValidCommands.
										// The token in the command line referred to.
		if (dwReturn != ERROR_SUCCESS)
		{
			UpdateGetLastError(ERRMSG_GETLASTERROR);
			BAIL_OUT;
		}
		switch(dwCommand)
		{

			case STATIC_IMPORTPOLICY		:
				dwReturn = ParseStaticImportPolicy(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case STATIC_EXPORTPOLICY		:
				dwReturn = ParseStaticExportPolicy(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case STATIC_SET_INTERACTIVE		:			// Interactive & Batch have the same args..
			case STATIC_SET_BATCH			:
				dwReturn = ParseStaticSetInteractive(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case STATIC_ADD_POLICY			:
				dwReturn = ParseStaticAddPolicy(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case STATIC_SET_RULE			:
				// handled above
				break;
			case STATIC_ADD_RULE			:
				dwReturn = ParseStaticAddRule(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case STATIC_ADD_FILTERLIST		:
				dwReturn = ParseStaticAddFilterList(ppwcTok,szListTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case STATIC_ADD_FILTERACTION	:
				dwReturn = ParseStaticAddFilterAction(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case STATIC_SET_DEFAULTRULE		:
				dwReturn = ParseStaticSetDefaultRule(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case STATIC_ADD_FILTER			:
				dwReturn = ParseStaticAddFilter(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case STATIC_DELETE_FILTER		:
				dwReturn = ParseStaticDelFilter(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case STATIC_RESTOREDEFAULTS		:
				dwReturn = ParseStaticRestoreDefaults(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case DYNAMIC_SET_MMPOLICY		:		// Set means no need to fill default MMSec methods
				bOption	 = SET_CMD;
			case DYNAMIC_ADD_MMPOLICY		:
				dwReturn = ParseDynamicAddSetMMPolicy(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType,bOption);
				break;
			case DYNAMIC_SET_FILTERACTION	:		// Set means no need to fill default QMSec methods
				bOption	 = SET_CMD;
			case DYNAMIC_ADD_FILTERACTION	:
				dwReturn = ParseDynamicAddSetQMPolicy(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType,bOption);
				break;
			case DYNAMIC_SET_CONFIG			:
				dwReturn = ParseDynamicSetConfig(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case DYNAMIC_SHOW_STATS			:
				dwReturn = ParseDynamicShowStats(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case DYNAMIC_SHOW_ALL			:
				dwReturn = ParseDynamicShowAll(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case STATIC_SHOW_ALL			:
				dwReturn = ParseStaticAll(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case DYNAMIC_ADD_RULE			:
				dwReturn = ParseDynamicAddRule(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case DYNAMIC_SET_RULE			:
				dwReturn = ParseDynamicSetRule(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case DYNAMIC_DELETE_RULE		:
				dwReturn = ParseDynamicDelRule(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case DYNAMIC_SHOW_MMSAS			:
				dwReturn = ParseDynamicShowMMSAS(ppwcTok,pParser,dwCurrentIndex,dwCount,dwTagType);
				break;
			case STATIC_DELETE_ALL			:
				break;
			default 						:
				dwReturn = ERROR_SHOW_USAGE;
				break;
		}
	}

	if (bIsRootcaRule)
	{
		pParser->Cmd[pParser->MaxTok].dwCmdToken = CMD_TOKEN_ROOTCA;
		pParser->Cmd[pParser->MaxTok].dwStatus   = dwNumRootca;
		pParser->Cmd[pParser->MaxTok].pArg       = (void *)g_paRootca;
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	CleanUp()
//
//	Date of Creation	:	12 Aug 2001
//
//	Parameters			:	NONE
//
//	Return				:	NONE
//
//	Description			:	Free's the all Globally allocated memory.
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

VOID
CleanUp(VOID)
{
	DWORD dwCount;
	DWORD dwMaxArgs;

	for(dwCount=0;dwCount<MAX_ARGS;dwCount++)
	{
		if (g_AllocPtr[dwCount])
		{
	 		free(g_AllocPtr[dwCount]);
	 		g_AllocPtr[dwCount] = NULL;
		}
	}

	if (g_paRootca)
	{
		for(dwMaxArgs=0;dwMaxArgs<MAX_ARGS;dwMaxArgs++)
		{
			CleanupMMAuthMethod(&(g_paRootca[dwMaxArgs]), FALSE);
		}
	}
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	RemoveList()
//
//	Date of Creation	:	10th Aug 2001
//
//	Parameters			:	IN      ppwcArguments,	// Input stream
//							IN      dwArgCount,		// Input arg count
//							IN      dwCurrentIndex,	// Input current arg index
//  						IN      pParser,		// contains the MaxTok
//  						IN 		pwcListCmd,		// Compare ListCmd with this string
//  						OUT		pwcListArgs,	// string containing the list args
//  						OUT 	ppwcTok			// i/p stream stripped of list cmds
//							IN		dwInputAllocLen	// Max alloc len of pwcListArgs
//
//	Return				:	DWORD		(No.of Non list commands)
//
//	Description			:	This Function called by parser function.
//							It will separate the List and Non-List commands
//
//	History				:
//
// 	Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
RemoveList(
	IN      LPTSTR          *ppwcArguments,	// Input stream
	IN      DWORD           dwArgCount,		// Input arg count
	IN      DWORD			dwCurrentIndex,	// Input current arg index
    IN      PPARSER_PKT     pParser,		// contains the MaxTok
    IN 		LPTSTR 			pwcListCmd,		// Compare ListCmd with this string
	IN      LPTSTR          szAnotherList, 	// Another ListCmd also present ...
    OUT		LPTSTR 			pwcListArgs,	// string containing the list args		// Memory need to be pre allocated
    OUT 	LPTSTR 			*ppwcTok,		// i/p stream stripped of list cmds		// No Memory has been allocated...
    																				// Only pointer copy operation
    IN		DWORD			dwInputAllocLen	// Max alloc len of pwcListArgs
	)
{
	DWORD dwLoopCount,dwNum = 0,dwCount = 0;	// Count of the number of tokens input to PP

	BOOL bWithinList = FALSE;					// track if within list command
	BOOL bFoundList  = FALSE;					// track if list command found in stream
	BOOL bFoundAnotherList = FALSE;
	BOOL bEqualPresent = FALSE;
	_TCHAR szCmd[MAX_STR_LEN]  	= {0};
	_TCHAR szTok[MAX_STR_LEN]  	= {0};
	_TCHAR szTemp[MAX_STR_LEN] 	= {0};

 	for(dwLoopCount = dwCurrentIndex;dwLoopCount < dwArgCount;dwLoopCount++)
	{
		if (_tcslen(ppwcArguments[dwLoopCount]) < MAX_STR_LEN)
		{
			_tcsncpy(szTemp,ppwcArguments[dwLoopCount],MAX_STR_LEN-1);
			// szTemp contains the cmd=arg
		}
		else
		{
			continue;
		}

		// szCmd = cmd, szTok = arg
		bEqualPresent = SplitCmdTok(szTemp,szCmd,szTok,MAX_STR_LEN-1,MAX_STR_LEN-1);

		if (bWithinList)
		{
			dwNum = 0;
			MatchEnumTag(g_hModule,szTemp,pParser->MaxTok,pParser->ValidTok,&dwNum);

			if (szAnotherList)
			{
				bFoundAnotherList = MatchToken(szTemp,szAnotherList) && bEqualPresent;
			}

			if ( dwNum || bFoundAnotherList )					// Normal command
			{
				bWithinList = 0;
				ppwcTok[dwCount] = ppwcArguments[dwLoopCount];	// Pointer Cpy, Unallocated Mem
				dwCount++;
				continue;
			}
			else
			{	// Searching for list inside list
				bFoundList = MatchToken(szCmd,pwcListCmd) && bEqualPresent;
				if (bFoundList)
				{
					bWithinList = 1;
					_tcsncat(pwcListArgs,szTok,dwInputAllocLen-_tcslen(pwcListArgs)-1);	 				// Pre Allocated Mem
					_tcsncat(pwcListArgs,TEXT(" "),dwInputAllocLen-_tcslen(pwcListArgs)-1);
					continue;
				}
				_tcsncat(pwcListArgs,szTemp,dwInputAllocLen-_tcslen(pwcListArgs)-1);						// List token
				_tcsncat(pwcListArgs,TEXT(" "),dwInputAllocLen-_tcslen(pwcListArgs)-1);					// Pre Allocated Mem
				continue;
			}
		}
		bFoundList = MatchToken(szCmd,pwcListCmd) && bEqualPresent;
		if (bFoundList)
		{
			bWithinList = 1;
			_tcsncat(pwcListArgs,szTok,dwInputAllocLen-_tcslen(pwcListArgs)-1);							// Pre Allocated Mem
			_tcsncat(pwcListArgs,TEXT(" "),dwInputAllocLen-_tcslen(pwcListArgs)-1);						// space delimited tokens
			continue;
		}
		ppwcTok[dwCount] = ppwcArguments[dwLoopCount];			// Pointer Copy operation only
		dwCount++;
	}
	return dwCount;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadParserOutput()
//
//	Date of Creation	:	16th Aug 2001
//
//	Parameters			:	OUT 	PPARSER_PKT pParser,
//							IN 		DWORD 		dwCount,
//							OUT 	PDWORD 	    pdwUsed,
//							IN 		LPTSTR 		str,
//							IN 		DWORD  		dwTagType,
//							IN  	DWORD       dwConversionType
//
//	Return				:	ERROR_SUCESS
//							RETURN_NO_ERROR
//
//	Description			:	Validates the argument and fill's  with relevant info
//							in the Parser_Pkt Structure.
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadParserOutput(
		OUT 	PPARSER_PKT pParser,
		IN 		DWORD 		dwCount,
		OUT 	PDWORD 	    pdwUsed,
		IN 		LPTSTR 		szArg,
		IN 		DWORD  		dwTagType,
		IN  	DWORD       dwConversionType
		)
{
	DWORD dwReturn = ERROR_SUCCESS;

	BOOL bTunnel   = FALSE;
	LPTSTR szIpsec = NULL;

	pParser->Cmd[dwCount].dwCmdToken = dwTagType;
	pParser->Cmd[dwCount].dwStatus = INVALID_TOKEN;

	switch(dwConversionType)
	{
		case TYPE_STRING	:
			//
			// Loads the normal string.
			//
			dwReturn = LoadParserString(szArg,pParser,dwTagType,pdwUsed,dwCount,FALSE,NULL);
			break;

		case TYPE_BOOL		:
			//
			// Validates the yes(y) or no(n)
			//
			dwReturn = LoadBoolWithOption(szArg,pParser,dwTagType,pdwUsed,dwCount,FALSE,NULL);
			break;

		case TYPE_DWORD		:
			//
			// Loads DWORD
			//
			dwReturn = LoadDword(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_ALL		:
			//
			// First check for the boolean (yes/y/No/n)
			//
			dwReturn = LoadBoolWithOption(szArg,pParser,dwTagType,pdwUsed,dwCount,TRUE,ALL_STR);
			break;

		case TYPE_VERBOSE	:
			//
			// Check for arg 'normal' or 'verbose'
			//
			dwReturn = LoadLevel(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_CONNTYPE 	:
			//
			// Validates the connection types (all/lan/dialup)
			//
			dwReturn = LoadConnectionType(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_PROTOCOL	:
			//
			// Protocol (TCP/UDP...) validation done here
			//
			dwReturn = LoadProtocol(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_PFSGROUP 	:
			//
			// Validate and Load PFSGroup(grpmm/grp1/grp2/grp3/nopfs)
			//
			dwReturn = LoadPFSGroup(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_BOUND 	:
			//
			// Check for valid arg(permit/block/negotiate)
			//
			dwReturn = LoadQMAction(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_FORMAT	:
			//
			// Validate user show o/p format. (list/table)
			//
			dwReturn = LoadFormat(szArg,pParser,dwTagType,pdwUsed,dwCount);
 			break;

		case TYPE_MODE		:
			//
			// Validate the filtermodes..(Transport/Tunnel)
			//
			dwReturn = LoadFilterMode(szArg,pParser,dwTagType,pdwUsed,dwCount);
 			break;

		case TYPE_RELEASE	:
			//
			// Check for the release of OS type(win2k/.net)
			//
			dwReturn = LoadOSType(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_PROPERTY	:
			//
			//Registry key name
			//
			dwReturn = LoadProperty(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_PORT		:
			//
			//Port valid form 0 to 65535
			//
			dwReturn = LoadPort(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_FILTER	:
			//
			// Validate filter (Generic/specific)
			//
			dwReturn = LoadFilterType(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_STATS	:
			//
			//Ipsec or Ike
			//
			dwReturn = LoadStats(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

 		case TYPE_TUNNEL 	:
 			//
 			// Validate and convert the string into Tunnel IP
 			//
				bTunnel	 = TRUE;
		case TYPE_IP 		:
			//
			// Validate and convert the string into IP, DNS name resolves to first IP only
			//
			dwReturn = LoadIPAddrTunnel(szArg,pParser,dwTagType,pdwUsed,dwCount,bTunnel);
			break;

		case TYPE_MASK 		:
			//
			// Converts the user i/p Mask (also allows prefix )
			//
			dwReturn = LoadIPMask(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_QM_OFFER	:
			//
			// Validate Quick Mode offers here
			//
			dwReturn = LoadQMOffers(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_MM_OFFER	:
			//
			//Loads MMOffer
			//
			dwReturn = LoadMMOffers(szArg,pParser,dwTagType,pdwUsed,dwCount);
			break;

		case TYPE_DNSIP		:
			//
			//Accepts DNS name, validates IP
			//
			dwReturn = LoadDNSIPAddr(szArg,pParser,dwTagType,pdwUsed,dwCount);
	 		break;

        case TYPE_LOCATION  :
			//
			// Accepts enumeration: [local | persistent | domain]
			//
			dwReturn = LoadLocationType(szArg,pParser,dwTagType,pdwUsed,dwCount);
	 		break;

	 	case TYPE_EXPORT	:
	 		//
	 		// Checks the file name extension,if not available appends .ipsec
	 		//
			szIpsec = _tcsstr(szArg,EXPORT_IPSEC);
			if(szIpsec == NULL)
			{
				dwReturn = LoadParserString(szArg,pParser,dwTagType,pdwUsed,dwCount,TRUE,EXPORT_IPSEC);
			}
			else
			{
				dwReturn = LoadParserString(szArg,pParser,dwTagType,pdwUsed,dwCount,FALSE,NULL);
			}
			break;
		case TYPE_KERBAUTH:
			dwReturn = LoadKerbAuthInfo(szArg, pParser, dwTagType, pdwUsed, dwCount);
			break;
		case TYPE_PSKAUTH:
			dwReturn = LoadPskAuthInfo(szArg, pParser, dwTagType, pdwUsed, dwCount);
			break;
		case TYPE_ROOTCA:
			// do nothing... this is handled a different way
			break;
		default				:
			break;
	}
	if ( dwReturn == ERRCODE_ARG_INVALID )
	{
		PrintErrorMessage(IPSEC_ERR,0,ERRCODE_ARG_INVALID,szArg,pParser->ValidTok[dwTagType].pwszToken);
		dwReturn	= RETURN_NO_ERROR;
	}
	else if( dwReturn == ERROR_OUTOFMEMORY )
	{
		PrintErrorMessage(WIN32_ERR,ERROR_OUTOFMEMORY,NULL);
		dwReturn = RETURN_NO_ERROR;
	}
	else if( dwReturn == ERROR_OUT_OF_STRUCTURES )
	{
		PrintErrorMessage(WIN32_ERR,ERROR_OUT_OF_STRUCTURES,NULL);
		dwReturn = RETURN_NO_ERROR;
	}
	else if(( dwReturn != ERROR_SUCCESS ) && ( dwReturn != RETURN_NO_ERROR))
	{
		PrintErrorMessage(IPSEC_ERR,0,ERRCODE_INVALID_ARG,pParser->ValidTok[dwTagType].pwszToken);
		dwReturn = RETURN_NO_ERROR;
	}
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	SplitCmdTok()
//
//	Date of Creation	:	8th Aug 2001
//
//	Parameters			:	IN		LPTSTR szStr
//							OUT		LPTSTR szCmd
//							OUT		LPTSTR szTok
//							IN 		DWORD   dwCmdLen
//							IN		DWORD   dwTokLen
//
//	Return				:	BOOL
//
//	Description			:	This splitter  assumes
// 							1. inputs are of the type cmd = tok
// 							2. cmd & tok are allocated ptrs
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

BOOL
SplitCmdTok(
	LPTSTR szStr,
	LPTSTR szCmd,
	LPTSTR szTok,
	DWORD  dwCmdLen,
	DWORD  dwTokLen
	)
{
	LPTSTR found = NULL;
	BOOL bTest 	 = FALSE;

	found = _tcschr(szStr,_TEXT('='));		// detect =
	if ( found != NULL)						// if = found strip =
	{
		*(found) = _TEXT('\0');				// replace = with null
		_tcsncpy(szCmd,szStr,dwCmdLen);		// First part is cmd
		_tcsncpy(szTok,found+1,dwTokLen);	// Second part if tok
	}
	else
	{
		_tcsncpy(szTok,szStr,dwTokLen);
		_tcsncpy(szCmd,szStr,dwCmdLen);
	}
	if (found)
	{
		bTest = TRUE;
	}
	return bTest;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	ValidateBool()
//
//	Date of Creation	:	20th Aug 2001
//
//	Parameters			:	IN	LPTSTR ppwcTok
//
//	Return				:	BOOL
//
//	Description			:	Validates the user input (Yes/y/no/n)
//
//	History				:
//
// 	Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
ValidateBool(LPTSTR szStr)
{
	DWORD dwReturn = ERROR_SUCCESS;

	if ((_tcsicmp(szStr,YES_STR) == 0) || (_tcsicmp(szStr,Y_STR) == 0))
	{
		dwReturn = ARG_YES;
	}
	else if ((_tcsicmp(szStr,NO_STR) == 0) ||(_tcsicmp(szStr,N_STR) == 0))
	{
		dwReturn = ARG_NO;
	}

	return dwReturn;

}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	IsDnsName()
//
//	Date of Creation	:	30th Aug 2001
//
//	Parameters			:	IN	szText 		// string to check for DNS name
//
//	Return				:	DWORD
//
//	Description			:	If there is an alpha character in the string,
//			   				then we consider it as a DNS name.
//
//	History				:
//
// 	Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
IsDnsName(LPTSTR szStr)
{
	BOOL bTest = FALSE;
	if ( szStr )
	{
		for (DWORD dwCount = 0; dwCount < _tcslen(szStr); ++dwCount)
	    {
			if ( _istalpha(szStr[dwCount]) )
			{
				bTest = TRUE;
			}
		}
	}
	return bTest;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	CheckIFType()
//
//	Date of Creation	:	30th Aug 3001
//
//	Parameters			:	IN	szText			// String to be compared
//
//	Return				:	DWORD
//							INTERFACE_TYPE_ALL
//							INTERFACE_TYPE_LAN
//							INTERFACE_TYPE_DIALUP
//	Description			:	Validates the User Input for connection types
//							(ALL/LAN/DIALUP)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
CheckIFType ( LPTSTR SzText)
{
	DWORD dwReturn = PARSE_ERROR;

	if( _tcsicmp(SzText,IF_TYPE_ALL) == 0 )
	{
		dwReturn = INTERFACE_TYPE_ALL;				// Interface Type 'all'
	}
	else if( _tcsicmp(SzText,IF_TYPE_LAN) == 0 )
	{
		dwReturn = INTERFACE_TYPE_LAN;				// Interface Type 'lan'
	}
	else if( _tcsicmp(SzText,IF_TYPE_DIALUP) == 0)
	{
		dwReturn = INTERFACE_TYPE_DIALUP;			// Interface Type 'dialup'
	}

	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	CheckLocationType()
//
//	Date of Creation	:	30th Aug 3001
//
//	Parameters			:	IN	szText			// String to be compared
//
//	Return				:	the polstore provider id
//							
//	Description			:	Validates the User Input for connection types
//							(local,persistent,domain)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
CheckLocationType ( LPTSTR SzText)
{
	DWORD dwReturn = PARSE_ERROR;

	if( _tcsicmp(SzText,LOC_TYPE_PERSISTENT) == 0 )
	{
		dwReturn = IPSEC_PERSISTENT_PROVIDER;				
	}
	else if( _tcsicmp(SzText,LOC_TYPE_LOCAL) == 0 )
	{
		dwReturn = IPSEC_REGISTRY_PROVIDER;				
	}
	else if( _tcsicmp(SzText,LOC_TYPE_DOMAIN) == 0)
	{
		dwReturn = IPSEC_DIRECTORY_PROVIDER;			
	}

	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	CheckPFSGroup()
//
//	Date of Creation	:	10th Sept 2001
//
//	Parameters			:	IN	szText				// String to be compared
//
//	Return				:	DWORD
//							PFSGROUP_TYPE_P1		// 1
//							PFSGROUP_TYPE_P2		// 2
//							PFSGROUP_TYPE_MM		// 3
//
//	Description			:  	Validates the user input for PFS Groups
//							(grp1/grp2/grp3/grpmm/nopfs)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
CheckPFSGroup ( LPTSTR SzText)
{
	DWORD dwReturn = PARSE_ERROR;

	if( _tcsicmp(SzText,PFS_TYPE_P1) == 0 )
	{
		dwReturn = PFSGROUP_TYPE_P1;
	}
	else if( _tcsicmp(SzText,PFS_TYPE_P2) == 0 )
	{
		dwReturn = PFSGROUP_TYPE_P2;
	}
	else if( _tcsicmp(SzText,PFS_TYPE_P3) == 0)
	{
		dwReturn = PFSGROUP_TYPE_2048;				// PFS Group is GRP3
	}
	else if( _tcsicmp(SzText,PFS_TYPE_MM) == 0)
	{
		dwReturn = PFSGROUP_TYPE_MM;
	}
	else if(_tcsicmp(SzText,PFS_TYPE_NOPFS) == 0)
	{
		dwReturn = PFSGROUP_TYPE_NOPFS;
	}

	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	GetIpAddress()
//
//	Date of Creation	:	10th Sept 2001
//
//	Parameters			:	IN		ppwcArg		// String to be converted
//							OUT		pipAddress	// Target to be filled
//
//	Return				:	ERROR_SUCCESS
//							IP_DECODE_ERROR
//							IP_MASK_ERROR
//
//	Description			:  	Gets the ip address from the string.
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
GetIpAddress(
	IN  LPTSTR ppwcArg,
	OUT IPAddr	 *pipAddress
	)
{
    CHAR  pszIpAddr[24+1] = {0}; // ADDR_LENGTH =24
	DWORD dwStatus = 0;
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD i = 0;
	LPTSTR pszTmpPtr = NULL;

    // Make sure all characters are legal
    if (ppwcArg[ _tcsspn(ppwcArg, VALID_HEXIP) ])
    {
        dwReturn = IP_DECODE_ERROR;
        BAIL_OUT;
    }
    // make sure there are 3 and only "." (periods)
	for (i=0,pszTmpPtr=ppwcArg; ;i++)
	{
		pszTmpPtr = _tcschr(pszTmpPtr, _TEXT('.'));
		if(pszTmpPtr)
		{
			pszTmpPtr++;
		}
		else
			break;
	}
	if(i!=3)			// Invalid IPAddress is specified
	{
		dwReturn = IP_DECODE_ERROR;
        BAIL_OUT;
	}

	dwStatus = WideCharToMultiByte(CP_THREAD_ACP,0,ppwcArg,-1,pszIpAddr,24,NULL,NULL);
	if (!dwStatus)
	{
		dwReturn = IP_DECODE_ERROR;
        BAIL_OUT;
	}

    pszIpAddr[24] = '\0';

    *pipAddress = (DWORD)inet_addr(pszIpAddr);

error:
   	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	TokenToIPAddr()
//
//	Date of Creation	:	20th Sept 2001
//
//	Parameters			:	IN 		szText		// String to be converted
//							IN OUT	Address		// Target to be filled
//
//	Return				:	T2P_OK					on Success
//							T2P_NULL_STRING			on Error
//							T2P_INVALID_ADDR
//							T2P_DNSLOOKUP_FAILED
//
//	Description			:	Converts the user input string to Valid IPAddress.
//
//	History				:
//
// 	Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
TokenToIPAddr(
	IN		LPTSTR  szText,
	IN OUT	IPAddr  *pAddress,
	IN		BOOL	bTunnel,
	IN		BOOL bMask
	)
{
	DWORD  dwReturn = T2P_OK;
   	DWORD  dwAddr , dwCount;
	LPTSTR pszTmpPtr =NULL;
	int iReturn=ERROR_SUCCESS;
	char szDNSName[MAX_STR_LEN] = {0};
	struct addrinfo *pAddrInfo = NULL,*pNext=NULL;
	DWORD dwBufferSize = MAX_STR_LEN;

   	if (szText != NULL)
   	{
		if (!_tcscmp(szText,POTF_ME_TUNNEL))
		{
			*pAddress = 0;
		}
	     	else if(bTunnel)
		{
		  	dwAddr = GetIpAddress(szText,pAddress);
	       	if( (dwAddr == IP_DECODE_ERROR) || (dwAddr == IP_MASK_ERROR) )
	       	{
		 	dwReturn = T2P_INVALID_ADDR;
		}

		ADDR addr;
		addr.uIpAddr = ntohl(*pAddress);
		if (!IsValidTunnelEndpointAddress(&addr))
		{
			dwReturn = T2P_INVALID_ADDR;
		}
	}
	else if(bMask)
	{
		dwAddr = GetIpAddress(szText,pAddress);
		if(dwAddr == IP_DECODE_ERROR)
		{
			dwReturn = T2P_INVALID_ADDR;
		}
	}
	else
     	{
		if (IsDnsName(szText))
	 	{
			for ( dwCount=0,pszTmpPtr=szText; ;dwCount++)
			{
				pszTmpPtr = _tcschr(pszTmpPtr, _TEXT('x'));
				if(pszTmpPtr)
				{
					pszTmpPtr++;
				}
				else
				{
					break;
				}
			}
			if (dwCount==4)		// Old .... ip addressing format..
			{
				dwAddr = GetIpAddress(szText,pAddress);
				if (dwAddr == IP_DECODE_ERROR)
				{
					dwReturn = T2P_INVALID_ADDR;
				}
				else if (dwAddr == IP_MASK_ERROR)
				{
					dwReturn = T2P_INVALID_MASKADDR;
				}
			}
			else				// DNS name is specified
			{
				iReturn = WideCharToMultiByte(CP_THREAD_ACP, 0, szText, -1,
							  szDNSName,dwBufferSize,NULL,NULL);

				if(iReturn == 0)
				{
					//conversion failed due to some error. dont proceed . dive out of the function
					dwReturn = T2P_INVALID_ADDR;
					BAIL_OUT;
				}

				iReturn = getaddrinfo((const char*)szDNSName,NULL,NULL,&pAddrInfo);

				if (iReturn == ERROR_SUCCESS)
				{
					pNext = pAddrInfo;
					for(DWORD i=0;i< 1;i++)
					{
						memcpy(pAddress,(ULONG *) &(((sockaddr_in *)(pNext->ai_addr))->sin_addr.S_un.S_addr), sizeof(ULONG));
						pNext=pNext->ai_next;
					}
					// free pAddrInfo after usage
					if (pAddrInfo)
					{
						freeaddrinfo(pAddrInfo);
					}
				}
				else
				{
					dwReturn = T2P_DNSLOOKUP_FAILED;
				}
			}
		}
  		else  												// good old dotted notation
  		{
		  	dwAddr = GetIpAddress(szText,pAddress);
	       	if (dwAddr == IP_DECODE_ERROR)
	       	{
			 	dwReturn = T2P_INVALID_ADDR;
			}
			else if (dwAddr == IP_MASK_ERROR)
			{
				dwReturn = T2P_INVALID_MASKADDR;
			}
			}
		}
	}
	else
	{
		dwReturn = T2P_NULL_STRING;
	}
error:
   	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	TokenToProperty()
//
//	Date of Creation	:	28th Sept 2001
//
//	Parameters			:	IN 		szText
//
//	Return				:	DWORD
//	Description			:	Validates the arguments for logging
//							(ipsecdiagnostics/ikelogging/strongcrlcheck
//							/ipsecloginterval/ipsecexempt)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////
DWORD
TokenToProperty( LPTSTR SzText)
{
	DWORD dwReturn = PARSE_ERROR;

	if( _tcsicmp(SzText,PROPERTY_TYPE_ENABLEDIGNO) == 0)
	{
		dwReturn = PROPERTY_ENABLEDIGNO;
	}
	else if( _tcsicmp(SzText,PROPERTY_TYPE_IKELOG) == 0)
	{
		dwReturn = PROPERTY_IKELOG;
	}
	else if( _tcsicmp(SzText,PROPERTY_TYPE_CRLCHK) == 0)
	{
		dwReturn = PROPERTY_CRLCHK;						// It is Strongcrlchk
	}
	else if( _tcsicmp(SzText,PROPERTY_TYPE_LOGINTER) == 0)
	{
		dwReturn = PROPERTY_LOGINTER;
	}
	else if( _tcsicmp(SzText,PROPERTY_TYPE_EXEMPT) == 0)
	{
		dwReturn = PROPERTY_EXEMPT;
	}
	else if( _tcsicmp(SzText,PROPERTY_TYPE_BOOTMODE) == 0)
	{
		dwReturn = PROPERTY_BOOTMODE;
	}
	else if( _tcsicmp(SzText,PROPERTY_TYPE_BOOTEXEMP) == 0)
	{
		dwReturn = PROPERTY_BOOTEXEMP;
	}
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	CheckProtoType()
//
//	Date of Creation	:	20th Sept 2001
//
//	Parameters			:	IN 		szText
//
//	Return				:	DWORD
//
//	Description			:	Validates the Argument for the token Protocol.
//							(ANY|ICMP|TCP|UDP|RAW)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////
DWORD
CheckProtoType(
	LPWSTR SzText,
	PDWORD pdwProto
	)
{
	DWORD dwReturn = PARSE_ERROR;
	DWORD dwProto = 0;
	if( _tcsicmp(SzText,IF_TYPE_ANY) == 0)			// Do protocol type validation here
	{
		dwProto = PROT_ID_ANY;
		dwReturn = ERROR_SUCCESS;
	}
	else if( _tcsicmp(SzText,IF_TYPE_ICMP) == 0)
	{
		dwProto = PROT_ID_ICMP;
		dwReturn = ERROR_SUCCESS;
	}
	else if( _tcsicmp(SzText,IF_TYPE_TCP) == 0)
	{
		dwProto = PROT_ID_TCP;
		dwReturn = ERROR_SUCCESS;
	}
	else if( _tcsicmp(SzText,IF_TYPE_UDP) == 0)
	{
		dwProto = PROT_ID_UDP;
		dwReturn = ERROR_SUCCESS;
	}
	else if( _tcsicmp(SzText,IF_TYPE_RAW) == 0)
	{
		dwProto = PROT_ID_RAW;
		dwReturn = ERROR_SUCCESS;
	}
	else
	{
		dwReturn = ConvertStringToDword(SzText, &dwProto);
	}

	if ((dwReturn == ERROR_SUCCESS) && (dwProto < 256))
	{
		*pdwProto = dwProto;
	}
	else
	{
		dwReturn = PARSE_ERROR;
	}

	return dwReturn;
}
//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	MatchEnumTagToTagIndex()
//
//	Date of Creation	:	26th Sept 2001
//
//	Parameters			:	IN 		szText
//							IN  	*pParser
//
//	Return				: 	DWORD	( TagIndex)
//
//	Description			:	Based on Tag, Returns TagIndex (string to dword)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////
DWORD
MatchEnumTagToTagIndex(
		IN      LPWSTR     szToken,		// Input Token
		IN  	PPARSER_PKT pParser
	)

{
	DWORD dwNum = 0;
	DWORD dwIndex = PARSE_ERROR;
	DWORD dwCount;

 	MatchEnumTag(g_hModule,szToken,pParser->MaxTok,pParser->ValidTok,&dwNum);

	if (dwNum)
	{	// Convert the output of MatchEnumTag into the TagIndex
		for (dwCount =0;dwCount < pParser->MaxTok;dwCount++)
		{
			if (dwNum == pParser->ValidTok[dwCount].dwValue)
			{
				dwIndex = dwCount;
				break;
			}
		}
	}
	return dwIndex;
}
//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	CheckBound()
//
//	Date of Creation	:	04th Sept 2001
//
//	Parameters			:	IN 		szText			// String to be compared
//
//	Return				: 	DWORD
//							BOUND_TYPE_PERMIT		// 1
//							BOUND_TYPE_BLOCK		// 2
//							BOUND_TYPE_NEGOTIATE	// 3
//	Description			:	Validates the argument for the token action
//							(permit|block|negotiate)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////
DWORD
CheckBound ( LPTSTR SzText)
{
	DWORD dwReturn = PARSE_ERROR;

	if( _tcsicmp(SzText,QMSEC_PERMIT_STR) 	== 0 )
	{
		dwReturn = TOKEN_QMSEC_PERMIT;
	}
	else if( _tcsicmp(SzText,QMSEC_BLOCK_STR) == 0 )
	{
		dwReturn = TOKEN_QMSEC_BLOCK;
	}
	else if( _tcsicmp(SzText,QMSEC_NEGOTIATE_STR) == 0)
	{
		dwReturn = TOKEN_QMSEC_NEGOTIATE;
	}

	return dwReturn;
}
//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	IsWithinLimit()
//
//	Date of Creation	:	29th Sept 2001
//
//	Parameters			:	IN DWORD	data
//							IN DWORD	min
//							IN DWORD	max
//
//	Return				: 	DWORD
//							return 1 if success
//							return 0 if fail
//
//	Description			:	Checks for limits
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////
BOOL
IsWithinLimit(
	DWORD dwData,
	DWORD dwMin,
	DWORD dwMax
	)
{
	return ( (dwData >= dwMin ) && ( dwData <= dwMax ) ) ? TRUE : FALSE ;
}


//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	TokenToDNSIPAddr()
//
//	Date of Creation	:	29th Sept 2001
//
//	Parameters			:	IN 		szText		// String to be converted
//							IN OUT	Address		// Target to be filled
//
//	Return				:	DWORD
//
//	Description			:	Validates i/p String and resolves to valid IPAddress(s)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////
DWORD
TokenToDNSIPAddr(
	IN 		LPTSTR 		szText,
	IN OUT 	PDNSIPADDR  pDNSAddress,
	IN OUT 	PDWORD 		*ppdwUsed
	)
{
	DWORD  dwReturn = T2P_OK;
  	DWORD  dwCount,dwStatus,i=0,n;
	IPAddr address;

	int iReturn=ERROR_SUCCESS;
	char szDNSName[MAX_STR_LEN] = {0};
	struct addrinfo *pAddrInfo = NULL,*pNext=NULL;
	DWORD dwBufferSize = MAX_STR_LEN;

   	if (szText == NULL)
   	{
		dwReturn = T2P_NULL_STRING;
		BAIL_OUT;
	}
	if (IsDnsName(szText))									// 	Any Alpha ==> DNS name provided not (0x)
	{
		dwCount = CheckCharForOccurances(szText,_TEXT('x'));
		if (dwCount==4)
		{
			i = CheckCharForOccurances(szText,_TEXT('.'));
			if (i!=3)
			{
				dwReturn = T2P_INVALID_ADDR;
				BAIL_OUT;
			}

			dwStatus = WideCharToMultiByte(CP_THREAD_ACP,0,szText,-1,szDNSName,dwBufferSize,NULL,NULL);
			if (!dwStatus)
			{
				dwReturn = T2P_INVALID_ADDR;
				BAIL_OUT;
			}
			address = (ULONG)inet_addr(szDNSName);

			if(address == INADDR_NONE)
			{
				dwReturn = T2P_INVALID_ADDR;
				BAIL_OUT;
			}

			pDNSAddress->pszDomainName  = NULL;			// Old IPAddrs notation so dns name fill with zero
			pDNSAddress->puIpAddr 		= NULL;
			pDNSAddress->puIpAddr = (ULONG *) malloc(sizeof(ULONG));

			if(pDNSAddress->puIpAddr == NULL)
			{
				dwReturn = ERROR_OUTOFMEMORY;
				BAIL_OUT;
			}

			if (**ppdwUsed > MAX_ARGS_LIMIT)
			{
				free(pDNSAddress->puIpAddr);
				dwReturn = ERROR_OUT_OF_STRUCTURES;
				BAIL_OUT;
			}
			g_AllocPtr[**ppdwUsed] = pDNSAddress->puIpAddr ;
			(**ppdwUsed)++;
			memcpy(&(pDNSAddress->puIpAddr[0]),(ULONG *)&address, sizeof(ULONG));
			pDNSAddress->dwNumIpAddresses = 1; // only one IP sent
		}
		else
		{
			iReturn = WideCharToMultiByte(CP_THREAD_ACP, 0, szText, -1,
						  szDNSName,dwBufferSize,NULL,NULL);

			if(iReturn == 0)
			{
				//conversion failed due to some error. don't proceed, dive out of the function
				dwReturn = T2P_INVALID_ADDR;
				BAIL_OUT;
			}

			iReturn = getaddrinfo((const char*)szDNSName,NULL,NULL,&pAddrInfo);

			if (iReturn == ERROR_SUCCESS)
			{
				pDNSAddress->pszDomainName = NULL;
				pDNSAddress->pszDomainName = (TCHAR *)calloc(1,(_tcslen(szText) + 1)*sizeof(TCHAR));
				if(pDNSAddress->pszDomainName == NULL)
				{
					dwReturn = ERROR_OUTOFMEMORY;
					BAIL_OUT;
				}
				_tcsncpy(pDNSAddress->pszDomainName,szText,_tcslen(szText));

				if (**ppdwUsed > MAX_ARGS_LIMIT)
				{
					free(pDNSAddress->pszDomainName);
					dwReturn = ERROR_OUT_OF_STRUCTURES;
					BAIL_OUT;
				}
				g_AllocPtr[**ppdwUsed] = pDNSAddress->pszDomainName;
				(**ppdwUsed)++;

				pNext = pAddrInfo;
				for(n=1;pNext = pNext->ai_next;	n++);		// First count no. of IP's resolved..

				pDNSAddress->dwNumIpAddresses 	= n;		// n starts from zero
				pDNSAddress->puIpAddr 			= NULL;
				pDNSAddress->puIpAddr = (ULONG *) malloc(sizeof(ULONG)* pDNSAddress->dwNumIpAddresses);
				if(pDNSAddress->puIpAddr == NULL)
				{
					dwReturn = ERROR_OUTOFMEMORY;
					BAIL_OUT;
				}

				if (**ppdwUsed > MAX_ARGS_LIMIT)
				{
					free(pDNSAddress->puIpAddr);
					dwReturn = ERROR_OUT_OF_STRUCTURES;
					BAIL_OUT;
				}
				g_AllocPtr[**ppdwUsed] = pDNSAddress->puIpAddr ;
				(**ppdwUsed)++;

				pNext = pAddrInfo;
				for(DWORD j=0;j< n;j++)
				{
					memcpy(&(pDNSAddress->puIpAddr[j]),(ULONG *) &(((sockaddr_in *)(pNext->ai_addr))->sin_addr.S_un.S_addr), sizeof(ULONG));
					pNext=pNext->ai_next;
				}
				// free pAddrInfo after usage
				if (pAddrInfo)
				{
					freeaddrinfo(pAddrInfo);
				}
			}
			else
			{
				dwReturn = T2P_DNSLOOKUP_FAILED;
				pDNSAddress->pszDomainName = NULL;
			}
		}
	}
	else		// OLD .... notation
	{
		i = CheckCharForOccurances(szText,_TEXT('.'));
		if (i!=3)
		{
			dwReturn = T2P_INVALID_ADDR;
			BAIL_OUT;
		}

		iReturn = WideCharToMultiByte(CP_THREAD_ACP,0,szText,-1,szDNSName,dwBufferSize,NULL,NULL);
		if(iReturn == 0)
		{
			dwReturn = T2P_INVALID_ADDR;
			BAIL_OUT;
		}

		address = (ULONG)inet_addr(szDNSName);

		pDNSAddress->pszDomainName = NULL;
		pDNSAddress->puIpAddr = NULL;
		pDNSAddress->puIpAddr = (ULONG *) malloc(sizeof(ULONG));
		if(pDNSAddress->puIpAddr == NULL)
		{
			dwReturn = ERROR_OUTOFMEMORY;
			BAIL_OUT;
		}

		if (**ppdwUsed > MAX_ARGS_LIMIT)
		{
			free(pDNSAddress->puIpAddr);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}
		g_AllocPtr[**ppdwUsed] = pDNSAddress->puIpAddr ;
		(**ppdwUsed)++;
		memcpy(&(pDNSAddress->puIpAddr[0]),(ULONG *)&address, sizeof(ULONG));
		pDNSAddress->dwNumIpAddresses = 1; 					// only one IP sent
	}
error:
   	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	RemoveRootcaAuthMethods()
//
//	Date of Creation	:	22nd Aug 2001
//
//	Parameters			:	IN      LPWSTR          *ppwcArguments,	// Input stream
//							IN      DWORD           dwArgCount,		// Input arg count
//							IN      DWORD			dwCurrentIndex,	// Input current arg index
//  						IN      PPARSER_PKT     pParser,		// contains the MaxTok
//							IN      LPTSTR          szAnotherList,	// Another ListCmd also present ...
//  						OUT		PSTA_MM_AUTH_METHODS 			*paRootcaAuthMethods,	// o/p array of auth methods
//  						OUT 	LPTSTR 			*ppwcTok,		// i/p stream stripped of list cmds
//							OUT		PDWORD			pdwNumRootcaAuthMethods		// Number of the list Tokens
//							IN		DWORD			dwInputAllocLen // The max allocation for ppwcListArgs
//
//	Return				:	DWORD
//
//	Description			:	Separates the list and non list commands..
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
RemoveRootcaAuthMethods
(
	IN	LPTSTR		*ppwcArguments,	// Input stream
	IN	DWORD		dwArgCount,		// Input arg count
	IN	DWORD		dwCurrentIndex,	// Input current arg index
	IN	PPARSER_PKT	pParser,		// contains the MaxTok
	IN	LPTSTR		szAnotherList,	// Another ListCmd also present ...
	OUT	PSTA_MM_AUTH_METHODS *paRootcaAuthMethods,	// o/p stream containing the list args		// Needs Pre Allocated Mem
	OUT	LPTSTR		*ppwcTok,		// i/p stream stripped of list cmds			// No Mem allocation needed...
																					// only pointer copy
	OUT	PDWORD		pdwNumRootcaAuthMethods,	// Number of the List Tokens
	IN	DWORD		dwInputAllocLen,
	OUT PDWORD		pdwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwLoopCount	= 0;
	DWORD dwCount = 0;
	DWORD dwRootcaCount = 0;
	DWORD dwNum = 0;

	_TCHAR szCmd[MAX_STR_LEN]  		= {0};
	_TCHAR szTok[MAX_STR_LEN]  		= {0};
	_TCHAR szTemp[MAX_STR_LEN] 	= {0};
	BOOL bEqualPresent;
	BOOL bFoundRootca;

	for(dwLoopCount = dwCurrentIndex;dwLoopCount < dwArgCount;dwLoopCount++)
	{
		bFoundRootca = FALSE;
		if (_tcslen(ppwcArguments[dwLoopCount]) < MAX_STR_LEN)
		{
			_tcsncpy(szTemp,ppwcArguments[dwLoopCount],MAX_STR_LEN-1);
			// szTemp contains the cmd=arg

			bEqualPresent = SplitCmdTok(szTemp,szCmd,szTok,MAX_STR_LEN-1,MAX_STR_LEN-1);
			if (bEqualPresent)
			{
				dwNum = 0;
				MatchEnumTag(g_hModule,szTemp,pParser->MaxTok,pParser->ValidTok,&dwNum);
				if (!dwNum && (_tcsnicmp(szCmd, POTF_OAKAUTH_CERT, _tcslen(POTF_OAKAUTH_CERT)-1) == 0))
				{
					PSTA_MM_AUTH_METHODS pRootcaInfo = NULL;
					bFoundRootca = TRUE;
					if (ProcessEscapedCharacters(szTok) != ERROR_SUCCESS)
					{
						dwReturn = ERROR_INVALID_PARAMETER;
						BAIL_OUT;
					}
					dwReturn = GenerateRootcaAuthInfo(&pRootcaInfo, szTok);
					if (dwReturn != ERROR_SUCCESS)
					{
						BAIL_OUT;
					}
					pRootcaInfo->dwSequence = dwCount;
					paRootcaAuthMethods[dwRootcaCount++] = pRootcaInfo;
				}
			}
		}

		if (!bFoundRootca)
		{
			ppwcTok[dwCount++] = ppwcArguments[dwLoopCount];
		}
	}
	*pdwNumRootcaAuthMethods = dwRootcaCount;
error:
	*pdwCount = dwCount;
	return dwReturn;
}


//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	TokenToType()
//
//	Date of Creation	:	20th Aug 2001
//
//	Parameters			:	IN 		szText
//
//	Return				:	DWORD
//
//	Description			:	Validates the argument for filtertype (generic/specific)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
TokenToType( LPTSTR pszText)
{
	DWORD dwReturn = PARSE_ERROR;

	if( _tcsicmp(pszText,FILTER_TYPE_GENERIC_STR) == 0)
	{
		dwReturn = FILTER_GENERIC;
	}
	else if( _tcsicmp(pszText,FILTER_TYPE_SPECIFIC_STR) == 0)
	{
		dwReturn = FILTER_SPECIFIC;
	}

	return dwReturn;
}
//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	TokenToStats()
//
//	Date of Creation	:	29th Aug 2001
//
//	Parameters			:	IN 		szText
//
//	Return				:	DWORD
//
//	Description			:	Validates the argument to the token statistics. (all/ike/ipsec)
//
//	History				:
//
//	Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
TokenToStats( LPTSTR pszText)
{
	DWORD dwReturn = PARSE_ERROR;

	if( _tcsicmp(pszText,STATS_ALL_STR) == 0)
	{
		dwReturn = STATS_ALL;
	}
	else if( _tcsicmp(pszText,STATS_IKE_STR)	== 0)
	{
		dwReturn = STATS_IKE;
	}
	else if( _tcsicmp(pszText,STATS_IPSEC_STR) == 0)
	{
		dwReturn = STATS_IPSEC;
	}
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	PrintQMOfferError()
//
//	Date of Creation	:	20th dec 2001
//
//	Parameters			:	IN		dwStatus
//							IN		pPArser
//							IN 		dwTagType			// String to be compared
//
//	Return				:	NONE
//
//	Description			:	Prints the QMOffer error messages
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////
VOID
PrintQMOfferError(
	IN DWORD dwStatus,
	IN PPARSER_PKT pParser,
	IN DWORD dwTagType
	)
{
	switch(dwStatus)							// Print the specified QMOffer error messages.
	{
		case T2P_NULL_STRING			:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_NULL_STRING);
			break;
		case T2P_P2_SECLIFE_INVALID		:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_SECLIFE_INVALID,P2_Sec_LIFE_MIN,P2_Sec_LIFE_MAX);
			break;
		case T2P_P2_KBLIFE_INVALID		:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_KBLIFE_INVALID,P2_Kb_LIFE_MIN,P2_Kb_LIFE_MAX);
			break;
		case T2P_INVALID_P2REKEY_UNIT	:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_P2REKEY_INVALID);
			break;
		case T2P_INVALID_HASH_ALG		:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_HASH_INVALID);
			break;
		case T2P_INCOMPLETE_ESPALGS		:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_ESP_INCOMPLETE);
			break;
		case T2P_GENERAL_PARSE_ERROR	:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_QMOFFER_INVALID);
			break;
		case T2P_DUP_ALGS				:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_DUPALG_INVALID,pParser->ValidTok[dwTagType].pwszToken);
			break;
		case T2P_NONE_NONE				:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_NONE_INVALID);
			break;
		case T2P_INVALID_IPSECPROT		:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_IPSECPROT_INVALID);
			break;
		case T2P_P2_KS_INVALID			:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_KS_INVALID);
			break;
		case T2P_AHESP_INVALID			:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_AHESP_INVALID);
			break;
		default							:
			break;
	}
}
//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	ValidateSplServer()
//
//	Date of Creation	:	2nd Jan 2002
//
//	Parameters			:	IN 		szText			// String to be compared
//
//	Return				:	DWORD
//  						SERVER_WINS
//  						SERVER_DHCP
//  						SERVER_DNS
//  						SERVER_GATEWAY
//  						IP_ME
//  						IP_ANY
//
//	Description			:	Checks for the Spl server types
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////
DWORD
ValidateSplServer(IN LPTSTR pszText)
{
	DWORD dwReturn = NOT_SPLSERVER;

	if(_tcsicmp(pszText,SERVER_WINS_STR)==0)
	{										// Allow spl servers here
		dwReturn  = SERVER_WINS;
	}
	else if(_tcsicmp(pszText,SERVER_DHCP_STR)==0)
	{
		dwReturn  = SERVER_DHCP;
	}
	else if(_tcsicmp(pszText,SERVER_DNS_STR)==0)
	{
		dwReturn  = SERVER_DNS;
	}
	else if(_tcsicmp(pszText,SERVER_GATEWAY_STR)==0)
	{
		dwReturn  = SERVER_GATEWAY;
	}
	else if(_tcsicmp(pszText,IP_ME_STR)==0)		// Take care about 'me' and 'any' tokens here
	{
		dwReturn  = IP_ME;
	}
	else if(_tcsicmp(pszText,IP_ANY_STR)==0)
	{
		dwReturn  = IP_ANY;
	}
	return dwReturn;
}
//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	PrintIPError()
//
//	Date of Creation	:	20th dec 2001
//
//	Parameters			:	IN		dwStatus
//							IN 		szText			// String to be compared
//
//	Return				:	NONE
//
//	Description			:	Prints the IP validation errors
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////
VOID
PrintIPError(IN DWORD dwStatus, IN LPTSTR  pszText)
{
	switch(dwStatus)				// Print error message for IPAddress
	{
		case	T2P_DNSLOOKUP_FAILED	:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_DNSLOOKUP_FAILED,pszText);
			break;
		case	T2P_INVALID_MASKADDR	:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_INVALID_MASK,pszText);
			break;
		case	T2P_INVALID_ADDR		:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_INVALID_ADDR,pszText);
			break;
		case	T2P_NULL_STRING			:
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_INVALID_ARG);
			break;
		case	ERROR_OUTOFMEMORY		:
			PrintErrorMessage(WIN32_ERR,ERROR_OUTOFMEMORY,NULL);
			break;
		case	ERROR_OUT_OF_STRUCTURES		:
			PrintErrorMessage(WIN32_ERR,ERROR_OUT_OF_STRUCTURES,NULL);
			break;
		default							:
			PrintErrorMessage(WIN32_ERR,dwStatus,NULL);
			break;
	}
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	InitializeGlobalPointers()
//
//	Date of Creation	:	9th Jan 2002
//
//	Parameters			:
//
//	Return				:	NONE
//
//	Description			:	Initialize Global pointers to NULL
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////
VOID
InitializeGlobalPointers(
	VOID
	)
{
	DWORD dwMaxArgs = 0;

	for(dwMaxArgs=0;dwMaxArgs<IPSEC_MAX_QM_OFFERS;dwMaxArgs++)
	{
		g_pQmsec[dwMaxArgs] = NULL;			// Initialize all global pointers to NULL
	}
	for(dwMaxArgs=0;dwMaxArgs<IPSEC_MAX_MM_OFFERS;dwMaxArgs++)
	{
		g_pMmsec[dwMaxArgs] = NULL;
	}

	for(dwMaxArgs=0;dwMaxArgs<MAX_ARGS;dwMaxArgs++)
	{
		g_AllocPtr[dwMaxArgs]    = NULL;
		g_paRootca[dwMaxArgs] = NULL;
	}
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadParserString()
//
//	Date of Creation	:	8th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		szInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//							IN 	BOOL 		bAppend,
//							IN 	LPTSTR 		szAppend
//
//	Return				:	ERROR_SUCESS
//							RETURN_NO_ERROR
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the strings, If specified appends the given string
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////


DWORD
LoadParserString(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount,
	IN 	BOOL 		bAppend,
	IN 	LPTSTR 		pszAppend
	)
{
	LPTSTR pszArg = NULL;
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwInputLen = 0;

	if(_tcsicmp(pszInput,_TEXT("")) == 0)
	{
		dwReturn = ERROR_SHOW_USAGE;
	}
	else
	{
		if(!bAppend)					// Just called for load string. do it
		{
			dwInputLen = _tcslen(pszInput);
			pszArg = (LPTSTR)calloc(dwInputLen+1 ,sizeof(_TCHAR));
			if(pszArg == NULL)
			{
				dwReturn = ERROR_OUTOFMEMORY;
				BAIL_OUT;
			}
			if (*pdwUsed > MAX_ARGS_LIMIT)
			{
				free(pszArg);
				dwReturn = ERROR_OUT_OF_STRUCTURES;
				BAIL_OUT;
			}

			g_AllocPtr[(*pdwUsed)++] = pszArg;
			_tcsncpy((LPTSTR)pszArg,pszInput,dwInputLen);
		}
		else						// Here load the string and also do some appending operation
		{
			if(_tcsicmp(pszAppend,_TEXT("")) == 0)
			{
				PrintErrorMessage(IPSEC_ERR,0,ERRCODE_INVALID_ARG,pParser->ValidTok[dwTagType].pwszToken);
				dwReturn = RETURN_NO_ERROR;
			}
			else
			{
				dwInputLen = _tcslen(pszInput)+_tcslen(pszAppend);
				pszArg = (LPTSTR)calloc(dwInputLen+1,sizeof(_TCHAR));
				if(pszArg == NULL)
				{
					dwReturn = ERROR_OUTOFMEMORY;
					BAIL_OUT;
				}

				if (*pdwUsed > MAX_ARGS_LIMIT)
				{
					free(pszArg);
					dwReturn = ERROR_OUT_OF_STRUCTURES;
					BAIL_OUT;
				}

				g_AllocPtr[(*pdwUsed)++] = pszArg;
				_tcsncpy((LPTSTR)pszArg,pszInput,dwInputLen);
				_tcsncat((LPTSTR)pszArg,pszAppend,dwInputLen-_tcslen(pszArg));
			}
		}
		pParser->Cmd[dwCount].pArg = (PVOID)pszArg;
		pParser->Cmd[dwCount].dwStatus = VALID_TOKEN;
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadDword()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		szInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERROR_INVALID_OPTION_VALUE
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the input string and converts into DWORD
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadDword(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD  dwReturn = ERROR_SUCCESS;
	DWORD  dwStatus = 0;
	PDWORD pdwArg	= NULL;

	pdwArg = (PDWORD)malloc(sizeof(DWORD));
	if(pdwArg == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else				// Convert string to into DWORD and load it.
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pdwArg);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pdwArg;
		dwStatus = _stscanf(pszInput,_TEXT("%u"),pdwArg);
		if (dwStatus)
		{
			pParser->Cmd[dwCount].pArg = pdwArg;
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN;
		}
		else
		{
			dwReturn = ERROR_INVALID_OPTION_VALUE;
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadBoolWithOption()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		pszInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERROR_INVALID_OPTION_VALUE
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates Yes/No, And all checks for Keyword 'all'
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadBoolWithOption(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount,
	IN	BOOL 		bOption,
	IN	LPTSTR 		pszCheckKeyWord
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	BOOL  *pbArg = NULL;

	pbArg = (BOOL *)malloc(sizeof(BOOL));

	if(pbArg == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{// Just check for a boolean (Yes/No)

		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pbArg);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}
		g_AllocPtr[(*pdwUsed)++] = pbArg;
		dwStatus = ValidateBool(pszInput);
		if(dwStatus == ARG_NO)
		{
			*pbArg = FALSE;
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN;
		}
		else if(dwStatus == ARG_YES)
		{
			*pbArg = TRUE;
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN;
		}
		else
		{
			if(!bOption)
			{
				dwReturn = ERROR_SHOW_USAGE;
				BAIL_OUT;
			}
		}
		if(bOption)		// Not only boolean and also check for keywords like 'all'
		{
			if(_tcsicmp(pszCheckKeyWord,_TEXT("")) != 0)
			{
				if(_tcsicmp(pszCheckKeyWord,ALL_STR) == 0)		// Check for 'all' key word
				{												// If it is all then fill yes
						*pbArg = TRUE;
						pParser->Cmd[dwCount].dwStatus = VALID_TOKEN;
				}
				else
				{
					dwReturn = ERROR_SHOW_USAGE;
				}
			}
			else
			{

			}
		}
		pParser->Cmd[dwCount].pArg = (PVOID)pbArg;
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadLevel()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		szInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount
//
//	Return				:	ERROR_SUCESS
//							ERROR_INVALID_OPTION_VALUE
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the argument for token level
//							(verbose/normal)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadLevel(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	PBOOL pbLevel = NULL;

	pbLevel = (BOOL *)malloc(sizeof(BOOL));
	if(pbLevel == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		// Validate and load level=verbose/normal
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pbLevel);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pbLevel;
		if (MatchToken(pszInput,ARG_TOKEN_STR_VERBOSE) )
		{
			*pbLevel = TRUE;
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN;
		}
		else if (MatchToken(pszInput,ARG_TOKEN_STR_NORMAL))
		{
			*pbLevel = FALSE;
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN;
		}
		else
		{
			dwReturn = ERROR_SHOW_USAGE;
		}
		pParser->Cmd[dwCount].pArg = (PVOID)pbLevel;
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadConnectionType()
//
//	Date of Creation	:	08th Aug 2002
//
//	Parameters			:	IN 	LPTSTR 		pszInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERRCODE_ARG_INVALID
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the argument for token 'connection type'
//							(lan/dialup/all)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadConnectionType(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD	 	pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	PDWORD pdwConnType = NULL;

	pdwConnType = (PDWORD)malloc(sizeof(DWORD));

	if(pdwConnType == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pdwConnType);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pdwConnType;
		dwStatus = CheckIFType (pszInput);		// Check for connection type (all/lan/dialup)
		if (dwStatus == PARSE_ERROR)
		{
			dwReturn = ERRCODE_ARG_INVALID;
		}
		else
		{
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN ;
			*pdwConnType = dwStatus;
			pParser->Cmd[dwCount].pArg = (PVOID)pdwConnType;
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadLocationType()
//
//	Date of Creation	:	08th Aug 2002
//
//	Parameters			:	IN 	LPTSTR 		pszInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERRCODE_ARG_INVALID
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the argument for token 'location type'
//							(boot/local/domain)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadLocationType(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD	 	pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	PDWORD pdwLocType = NULL;

	pdwLocType = (PDWORD)malloc(sizeof(DWORD));

	if(pdwLocType == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pdwLocType);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pdwLocType;
		dwStatus = CheckLocationType (pszInput);
		if (dwStatus == PARSE_ERROR)
		{
			dwReturn = ERRCODE_ARG_INVALID;
		}
		else
		{
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN ;
			*pdwLocType = dwStatus;
			pParser->Cmd[dwCount].pArg = (PVOID)pdwLocType;
		}
	}
error:
	return dwReturn;
}



//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadProtocol()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		pszInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERRCODE_ARG_INVALID
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the argument for protocol
//							(TCP/UDP...)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadProtocol(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	PDWORD pdwProto = NULL;

	pdwProto = (PDWORD)malloc(sizeof(DWORD));

	if(pdwProto == NULL )
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pdwProto);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pdwProto;
		DWORD dwProto = 0;
		dwStatus = CheckProtoType (pszInput, &dwProto);	// Check for all valid protocols
		if (dwStatus == PARSE_ERROR)
		{
			dwReturn	= ERRCODE_ARG_INVALID;
		}
		else
		{
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN ;
			*pdwProto = dwProto;
			pParser->Cmd[dwCount].pArg = (PVOID)pdwProto;
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadPFSGroup()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		pszInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERRCODE_ARG_INVALID
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the argument for pfs group
//							(grp1/grp2/grp3/grpmm/nopfs)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadPFSGroup(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	PDWORD pdwPFSGroup = NULL;

	pdwPFSGroup = (PDWORD)malloc(sizeof(DWORD));

	if(pdwPFSGroup == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pdwPFSGroup);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pdwPFSGroup;
		dwStatus = CheckPFSGroup(pszInput);
		if (dwStatus == PARSE_ERROR)
		{
			dwReturn	= ERRCODE_ARG_INVALID;
		}
		else								// It is not valid PFSGroup
		{
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN ;
			*pdwPFSGroup = dwStatus;
			pParser->Cmd[dwCount].pArg = (PVOID)pdwPFSGroup;
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadQMAction()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		pszInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERROR_INVALID_OPTION_VALUE
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the action types.
//							(Permit/Block/Negotiate)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadQMAction(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	PDWORD pdwAction = NULL;

	pdwAction = (PDWORD )malloc(sizeof(DWORD));
	if(pdwAction == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pdwAction);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pdwAction;
		dwStatus = CheckBound(pszInput);
		if (dwStatus == PARSE_ERROR)
		{
			dwReturn	= ERRCODE_ARG_INVALID;		// permit/block/negotiate
		}
		else
		{
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN ;
			*pdwAction = dwStatus;
			pParser->Cmd[dwCount].pArg = (PVOID)pdwAction;
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadFormat()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		pszInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERRCODE_ARG_INVALID
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the argument for format. (List/Table)
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadFormat(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	PBOOL pbFormat = NULL;

	pbFormat = (PBOOL)malloc(sizeof(BOOL));
	if(pbFormat == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pbFormat);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pbFormat;
		if( _tcsicmp(pszInput,TYPE_STR_LIST) == 0 )
		{
			*pbFormat = FALSE;
			pParser->Cmd[dwCount].pArg = (PVOID)pbFormat;
			pParser->Cmd[dwCount].dwStatus  = VALID_TOKEN;
		}
		else if( _tcsicmp(pszInput,TYPE_STR_TABLE) == 0 )
		{
			*pbFormat = TRUE;
			pParser->Cmd[dwCount].pArg = (PVOID)pbFormat;
			pParser->Cmd[dwCount].dwStatus  = VALID_TOKEN;
		}
		else					// It is not a valid arg for format
		{
			dwReturn	= ERRCODE_ARG_INVALID;
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadFilterMode()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		pszInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERRCODE_ARG_INVALID
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the argument and fill's  with relevant info
//							in the Parser_Pkt Struct.
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadFilterMode(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	PDWORD pdwFilterMode = NULL;
	pdwFilterMode = (PDWORD)malloc(sizeof(DWORD));

	if(pdwFilterMode == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pdwFilterMode);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pdwFilterMode;
		if( _tcsicmp(pszInput,TYPE_STR_TRANSPORT) == 0 )	// Is it Transport filter
		{
			*pdwFilterMode = TYPE_TRANSPORT_FILTER;
			pParser->Cmd[dwCount].pArg = (PVOID)pdwFilterMode;
			pParser->Cmd[dwCount].dwStatus  = VALID_TOKEN;
		}
		else if	( _tcsicmp(pszInput,TYPE_STR_TUNNEL) == 0 )	// Is it Tunnel filter
		{
			*pdwFilterMode = TYPE_TUNNEL_FILTER;
			pParser->Cmd[dwCount].pArg = (PVOID)pdwFilterMode;
			pParser->Cmd[dwCount].dwStatus  = VALID_TOKEN;
		}
		else
		{
			dwReturn	= ERRCODE_ARG_INVALID;
		}
	}
error:
	return dwReturn;
}


//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadOSType()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		szInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERRCODE_ARG_INVALID
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the argument.(.net/win2k)
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadOSType(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn   = ERROR_SUCCESS;
	PDWORD pdwOSType = NULL;
	pdwOSType = (PDWORD)malloc(sizeof(DWORD));

	if(pdwOSType == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pdwOSType);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pdwOSType;

		if((_tcsicmp(pszInput,RELEASE_WIN2K_STR) == 0))			// Is OS is WIN2K
		{
			*pdwOSType = TOKEN_RELEASE_WIN2K;
			pParser->Cmd[dwCount].dwStatus   = VALID_TOKEN;
			pParser->Cmd[dwCount].pArg       = pdwOSType;
		}
		else if((_tcsicmp(pszInput,RELEASE_DOTNET_STR) == 0))	// Is OS is .NET
		{
			*pdwOSType = TOKEN_RELEASE_DOTNET;
			pParser->Cmd[dwCount].dwStatus   = VALID_TOKEN;
			pParser->Cmd[dwCount].pArg       = pdwOSType;
		}
		else
		{
			pParser->Cmd[dwCount].pArg       = NULL;
			dwReturn	= ERRCODE_ARG_INVALID;
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadProperty()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		szInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERRCODE_ARG_INVALID
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the argument property.
//							(ipsecdiagnostics/ikelogging/strongcrlcheck
//							/ipsecloginterval/ipsecexempt)
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadProperty(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	PDWORD pdwProperty = NULL;

	pdwProperty = (PDWORD)malloc(sizeof(DWORD));

	if(pdwProperty == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pdwProperty);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pdwProperty;
		dwStatus = TokenToProperty(pszInput);
		if (dwStatus == PARSE_ERROR)
		{
			dwReturn	= ERRCODE_ARG_INVALID;
		}
		else
		{
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN ;
			*pdwProperty = dwStatus;
			pParser->Cmd[dwCount].pArg = (PVOID)pdwProperty;
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadPort()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		szInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERROR_INVALID_OPTION_VALUE
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the port (Should be less than 64535).
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadPort(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	PDWORD pdwPort = NULL;

	pdwPort = (PDWORD)malloc(sizeof(DWORD));
	if(pdwPort == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pdwPort);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pdwPort;
		dwStatus = _stscanf(pszInput,_TEXT("%u"),pdwPort);
		if (dwStatus)		// Port should be less than 64535
		{
			if((*pdwPort) < MAX_PORT)
			{
				pParser->Cmd[dwCount].pArg = (PVOID)pdwPort;
				pParser->Cmd[dwCount].dwStatus =  VALID_TOKEN ;
			}
			else
			{
				dwReturn = RETURN_NO_ERROR;
				PrintErrorMessage(IPSEC_ERR,0,ERRCODE_PORT_INVALID,MAX_PORT);
			}
		}
		else
		{
			dwReturn = ERROR_INVALID_OPTION_VALUE;
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadFilterType()
//
//	Date of Creation	:	08th JAn 2002
//
//	Parameters			:	IN 	LPTSTR 		szInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERRCODE_ARG_INVALID
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the argument for filtertype.
//							(Generic/Specific)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadFilterType(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	PDWORD pdwFilterType = NULL;

	pdwFilterType = (PDWORD)malloc(sizeof(DWORD));

	if(pdwFilterType == NULL )
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pdwFilterType);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pdwFilterType;
		dwStatus = TokenToType(pszInput);
		if (dwStatus == PARSE_ERROR)
		{
			dwReturn	= ERRCODE_ARG_INVALID;
		}
		else
		{
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN ;
			*pdwFilterType = dwStatus;
			pParser->Cmd[dwCount].pArg = (PVOID)pdwFilterType;
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadStats()
//
//	Date of Creation	:	16th Aug 2001
//
//	Parameters			:	IN 	LPTSTR 		szInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERRCODE_ARG_INVALID
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the argument ike/ipsec/all
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadStats(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	PDWORD pdwStats = NULL;

	pdwStats = (PDWORD)malloc(sizeof(DWORD));

	if(pdwStats == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pdwStats);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pdwStats;
		dwStatus = TokenToStats(pszInput);
		if (dwStatus == PARSE_ERROR)
		{
			dwReturn	= ERRCODE_ARG_INVALID;
		}
		else
		{
			pParser->Cmd[dwCount].dwStatus = VALID_TOKEN ;
			*pdwStats = dwStatus;
			pParser->Cmd[dwCount].pArg = (PVOID)pdwStats;
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadIPAddrTunnel()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		pszInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount
//
//	Return				:	ERROR_SUCESS
//							ERROR_OUTOFMEMORY
//                          RETURN_NO_ERROR
//
//	Description			:	IPAddress validation done here. DNS Resolves to first IP only
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadIPAddrTunnel(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount,
	IN 	BOOL 		bTunnel
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	IPAddr * pIPAddr = NULL;
	IPAddr	Address;
	BOOL bMask = FALSE;				// DNS name resolves to first IP only

	pIPAddr = (IPAddr *)malloc(sizeof(IPAddr));
	if(pIPAddr == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pIPAddr);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pIPAddr;
		dwStatus = ValidateSplServer(pszInput);
		if (dwStatus == NOT_SPLSERVER)
		{
			dwStatus = TokenToIPAddr(pszInput,&Address,bTunnel,bMask);
			if( dwStatus == T2P_OK )
			{
				*pIPAddr = Address;
				pParser->Cmd[dwCount].pArg = (PVOID)pIPAddr;
				pParser->Cmd[dwCount].dwStatus  = NOT_SPLSERVER;
			}
			else
			{
				if(bTunnel)
				{
					switch(dwStatus)
					{
						case	T2P_INVALID_ADDR		:
							PrintErrorMessage(IPSEC_ERR,0,ERRCODE_INVALID_TUNNEL,pszInput);
							break;
						case	T2P_NULL_STRING			:
							PrintErrorMessage(IPSEC_ERR,0,ERRCODE_INVALID_ARG);
							break;
						default							:
							break;
					}
				}
				else
				{
					PrintIPError(dwStatus,pszInput);
				}
				dwReturn	= RETURN_NO_ERROR;
			}
		}
		else
		{
			pParser->Cmd[dwCount].pArg = NULL;
			pParser->Cmd[dwCount].dwStatus  = dwStatus;
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadIPMask()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		szInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							RETURN_NO_ERROR
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the IPMask. Also allows prefix format.
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadIPMask(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	DWORD dwPrefix = 0;
	IPAddr * pIPAddr = NULL;
	IPAddr	Address;
	BOOL bMask = TRUE;
	BOOL bTunnel = FALSE;
	LPTSTR szPrefix = NULL;

	pIPAddr = (IPAddr *)malloc(sizeof(IPAddr));
	if(pIPAddr == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pIPAddr);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pIPAddr;

		szPrefix = _tcschr(pszInput,_TEXT('.'));
		if(szPrefix != NULL)
		{
			dwStatus = TokenToIPAddr(pszInput,&Address,bTunnel,bMask);
			if( (dwStatus == T2P_OK ) || (dwStatus == T2P_INVALID_MASKADDR ) )
			{
				*pIPAddr = Address;
				pParser->Cmd[dwCount].pArg = (PVOID)pIPAddr;
				pParser->Cmd[dwCount].dwStatus  = VALID_TOKEN;
			}
			else
			{
				PrintIPError(dwStatus,pszInput);
				dwReturn	= RETURN_NO_ERROR;
			}
		}
		else				// It is Prefix
		{
			dwPrefix = 0;
			dwStatus = _stscanf(pszInput,_TEXT("%u"),&dwPrefix);
			if(dwStatus)
			{
				if( (dwPrefix > 0 ) && ( dwPrefix <33 ) )		// Construct MASK using prefix
				{
					 Address = (IPAddr)( (ULONG)(pow( 2.0 ,(double)dwPrefix ) - 1) << (32-dwPrefix));
					 *pIPAddr = htonl(Address);
					pParser->Cmd[dwCount].pArg = (PVOID)pIPAddr;
					pParser->Cmd[dwCount].dwStatus  = VALID_TOKEN;
				}
				else
				{
					PrintErrorMessage(IPSEC_ERR,0,ERRCODE_PREFIX_INVALID);
					dwReturn	= RETURN_NO_ERROR;
				}
			}
			else
			{
				PrintErrorMessage(IPSEC_ERR,0,ERRCODE_MASK_INVALID,pszInput);
				dwReturn	= RETURN_NO_ERROR;
			}
		}
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadQMOffers()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		pszInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount
//
//	Return				:	ERROR_SUCESS
//                          RETURN_NO_ERROR
//							ERROR_OUTOFMEMORY
//
//	Description			:	Validates the argument for QMSecmethods
//							(No.of offers are ' ' delimited)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadQMOffers(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	DWORD dwNum = 0;
	DWORD i=0;
	PIPSEC_QM_OFFER pIPSecQMOffer = NULL;
	LPTSTR Token = NULL;

	if (_tcscmp(pszInput,_TEXT("")) != 0)	//  First Validate I/P
	{
		for(i=0;i<IPSEC_MAX_QM_OFFERS;i++)
		{
			g_pQmsec[i] = NULL;
		};

		Token = _tcstok(pszInput,OFFER_SEPARATOR);	// Offers are ' ' delimited process them separately

		while( ( Token != NULL ) && (dwNum < IPSEC_MAX_QM_OFFERS) )
		{
			pIPSecQMOffer = (IPSEC_QM_OFFER *)calloc(1,sizeof(IPSEC_QM_OFFER));
			if(pIPSecQMOffer == NULL)
			{
				dwReturn = ERROR_OUTOFMEMORY;
				BAIL_OUT;
			}

			LoadQMOfferDefaults(*pIPSecQMOffer);

			dwStatus = ListToOffer(Token,*pIPSecQMOffer);
			if(dwStatus == T2P_OK)
			{
				if (*pdwUsed > MAX_ARGS_LIMIT)
				{
					free(pIPSecQMOffer);
					dwReturn = ERROR_OUT_OF_STRUCTURES;
					BAIL_OUT;
				}

				g_AllocPtr[*pdwUsed] = g_pQmsec[dwNum] = pIPSecQMOffer;
				dwNum++;
				(*pdwUsed)++;
				dwReturn = ERROR_SUCCESS;
			}
			else
			{
				if (pIPSecQMOffer)
				{
					free(pIPSecQMOffer);
					pIPSecQMOffer = NULL;
				}
				PrintQMOfferError(dwStatus,pParser,dwTagType);
				dwReturn = RETURN_NO_ERROR;
				BAIL_OUT;
			}
			Token = _tcstok(NULL,OFFER_SEPARATOR);	// Separate offers
		}
		if(dwNum > IPSEC_MAX_QM_OFFERS)
		{
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_MAX_OFFERS,IPSEC_MAX_QM_OFFERS);
			dwReturn = RETURN_NO_ERROR;

			pParser->Cmd[dwCount].pArg       = NULL;
			pParser->Cmd[dwCount].dwStatus   = 0;
		}
		else if((dwNum > 0) && (dwNum <= IPSEC_MAX_QM_OFFERS))
		{
			pParser->Cmd[dwCount].pArg       = (PVOID)g_pQmsec;
			pParser->Cmd[dwCount].dwStatus   = dwNum;
		}
	}
	else
	{
		dwReturn = ERROR_SHOW_USAGE;
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadMMOffers()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN 	LPTSTR 		pszInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount
//
//	Return				:	ERROR_SUCESS
//							ERROR_OUTOFMEMORY
//                          RETURN_NO_ERROR
//
//	Description			:	Validates the argument for MMSecMethods.
//							(No .of Offers are ' ' delimited)
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadMMOffers(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	DWORD dwNum = 0;
	DWORD i=0;
	PIPSEC_MM_OFFER pIPSecMMOffer = NULL;
	LPTSTR Token = NULL;

	if (_tcsicmp(pszInput,_TEXT("\0")) != 0)
	{
		Token = _tcstok(pszInput,OFFER_SEPARATOR); 	// Offers are ' ' delimited process them separately

		for(i=0;i<IPSEC_MAX_MM_OFFERS;i++)
		{
			g_pMmsec[i]=NULL;
		};

		while( ( Token != NULL  ) && (dwNum < IPSEC_MAX_MM_OFFERS) )
		{
			pIPSecMMOffer = (IPSEC_MM_OFFER *)calloc(1,sizeof(IPSEC_MM_OFFER));
			if(pIPSecMMOffer == NULL)
			{
				dwReturn = ERROR_OUTOFMEMORY;
				BAIL_OUT;
			}

			LoadSecMethodDefaults(*pIPSecMMOffer) ;

			dwStatus = ListToSecMethod(Token,*pIPSecMMOffer);
			if(dwStatus == T2P_OK)
			{
				if (*pdwUsed > MAX_ARGS_LIMIT)
				{
					free(pIPSecMMOffer);
					dwReturn = ERROR_OUT_OF_STRUCTURES;
					BAIL_OUT;
				}

				g_AllocPtr[*pdwUsed] = g_pMmsec[dwNum] = pIPSecMMOffer;
				(*pdwUsed)++;
				dwNum++;
				dwReturn = ERROR_SUCCESS;
			}
			else
			{
				switch(dwStatus)
				{
					case T2P_INVALID_P1GROUP		:
						PrintErrorMessage(IPSEC_ERR,0,ERRCODE_INVALID_P1GROUP);
						break;
					case T2P_NULL_STRING			:
						PrintErrorMessage(IPSEC_ERR,0,ERRCODE_NULL_STRING);
						break;
					case T2P_GENERAL_PARSE_ERROR	:
						PrintErrorMessage(IPSEC_ERR,0,ERRCODE_MMOFFER_INVALID);
						break;
					case T2P_DUP_ALGS				:
						PrintErrorMessage(IPSEC_ERR,0,ERRCODE_DUPALG_INVALID,pParser->ValidTok[dwTagType].pwszToken);
						break;
					case T2P_P1GROUP_MISSING		:
						PrintErrorMessage(IPSEC_ERR,0,ERRCODE_P1GROUP_MISSING);
						break;
					default 						:
						break;
				}
				if (pIPSecMMOffer)
				{
					free(pIPSecMMOffer);
					pIPSecMMOffer = NULL;
				}
				dwReturn = RETURN_NO_ERROR;
				BAIL_OUT;
			}
			Token = _tcstok(NULL,OFFER_SEPARATOR);		// Separate offers..
		}
		if(dwNum > IPSEC_MAX_MM_OFFERS)
		{
			PrintErrorMessage(IPSEC_ERR,0,ERRCODE_MAX_OFFERS,IPSEC_MAX_MM_OFFERS);
			dwReturn = RETURN_NO_ERROR;
			BAIL_OUT;
		}
		if (dwNum)
		{
			pParser->Cmd[dwCount].pArg       = (PVOID)g_pMmsec;
			pParser->Cmd[dwCount].dwStatus   = dwNum;
		}
		else
		{
			pParser->Cmd[dwCount].pArg       = NULL;
			pParser->Cmd[dwCount].dwStatus   = 0;
		}
	}
	else
	{
		dwReturn = ERROR_SHOW_USAGE;
	}
error:
	return dwReturn;
}

//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	LoadDNSIPAddr()
//
//	Date of Creation	:	08th JAn 2002
//
//	Parameters			:	IN 	LPTSTR 		pszInput,
//							OUT PPARSER_PKT pParser,
//							IN 	DWORD 		dwTagType,
//							IN 	PDWORD 		pdwUsed,
//							IN 	DWORD 		dwCount,
//
//	Return				:	ERROR_SUCESS
//							ERROR_OUTOFMEMORY
//                          RETURN_NO_ERROR
//
//	Description			:	Validates the IPAddress. DNS name resolves to all IP's
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
LoadDNSIPAddr(
	IN 	LPTSTR 		pszInput,
	OUT PPARSER_PKT pParser,
	IN 	DWORD 		dwTagType,
	IN 	PDWORD 		pdwUsed,
	IN 	DWORD 		dwCount
	)
{
	DWORD dwReturn = ERROR_SUCCESS;
	DWORD dwStatus = 0;
	PDNSIPADDR pDNSIPAddr = NULL;

	pDNSIPAddr = (DNSIPADDR *)calloc(1,sizeof(DNSIPADDR));

	if(pDNSIPAddr == NULL)
	{
		dwReturn = ERROR_OUTOFMEMORY;
	}
	else
	{
		if (*pdwUsed > MAX_ARGS_LIMIT)
		{
			free(pDNSIPAddr);
			dwReturn = ERROR_OUT_OF_STRUCTURES;
			BAIL_OUT;
		}

		g_AllocPtr[(*pdwUsed)++] = pDNSIPAddr;
		dwStatus = ValidateSplServer(pszInput);	// allow spl servers..
		if (dwStatus == NOT_SPLSERVER)
		{
			dwStatus = TokenToDNSIPAddr(pszInput,pDNSIPAddr,&pdwUsed);
			if( dwStatus == T2P_OK )
			{
				pParser->Cmd[dwCount].pArg = (PVOID)pDNSIPAddr;
				pParser->Cmd[dwCount].dwStatus  = VALID_TOKEN;
			}
			else
			{
				PrintIPError(dwStatus,pszInput);
				dwReturn	= RETURN_NO_ERROR;
			}
		}
		else
		{
			pParser->Cmd[dwCount].pArg = NULL;
			pParser->Cmd[dwCount].dwStatus  = dwStatus;
		}
	}
error:
	return dwReturn;
}


//////////////////////////////////////////////////////////////////////////////
//
//	Function			:	CheckCharForOccurances()
//
//	Date of Creation	:	08th Jan 2002
//
//	Parameters			:	IN LPTSTR szInput,
//							IN _TCHAR chData
//
//	Return				:	DWORD
//
//	Description			:
//
//
//	History				:
//
//  Date    	Author    	Comments
//
//////////////////////////////////////////////////////////////////////////////

DWORD
CheckCharForOccurances(
	IN 	LPTSTR 		pszInput,
	IN	_TCHAR		chData
	)
{
	DWORD dwCount = 0;
	LPTSTR pszTmpPtr = NULL;

	for ( dwCount=0,pszTmpPtr=pszInput; ;dwCount++)
	{
		pszTmpPtr = _tcschr(pszTmpPtr, chData);
		if(pszTmpPtr)
		{
			pszTmpPtr++;
		}
		else
		{
			break;
		}
	}
	return 	dwCount;
}


DWORD
ConvertStringToDword(
	 IN LPTSTR szInput,
	 OUT PDWORD pdwValue
	 )
{
	DWORD dwReturn = ERROR_INVALID_OPTION_VALUE;
	size_t i = 0;
	DWORD dwValue = 0;
	// our largest allowable value is 2147483647
	while ((dwValue < 2147483647) && (szInput[i] >= '0') && (szInput[i] <= '9'))
	{
		dwValue = dwValue * 10 + (szInput[i] - '0');
		++i;
	}
	if (szInput[i] == '\0')
	{
		dwReturn = ERROR_SUCCESS;
		*pdwValue = dwValue;
	}
	return dwReturn;
}