/*
* Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
* handles parsing of makekeys command line args
* INCLUDES
*
*/


#include <windows.h>
#include <tchar.h>

#include "ParseCMD.h"
#include "openssllicense.h"

//#include <winCertificateGenerator.h>

// ===========================================================================
// CParseCmd
// Responsable for processing and maintaining the command line options
// ===========================================================================

CParseCmd::CParseCmd()
:m_dwOptions(0L),
m_fShowSyntax(FALSE)
	{
	m_dwKeyLen = DEFAULTKEYLEN;
	m_dwCertExpiryInDays = DEFAULTCERTEXPIRYDAYS;
	m_bPassword = FALSE;
	m_CMDKey = EDSACipher;
	m_bVerbose = FALSE;
	}

BOOL CParseCmd::ParseCommandLine(const int argc, const _TCHAR *argv[], Mode* aApp)
// Purpose  : Proceses the command line, and options
// Inputs   : argc, argv - command line as passed to the process
	{

	// Test the number of arguments
	if(argc < 2) throw ErrInsufficientArgs;
	
	int wCount = 1;
	int dname = 0;
	int founddname = 0;
	int command_count = 0;
	
	int MBCSstrlen;	//used to store the length of MBCS strings 
	
	// walk through the argv[] list, picking out -parameters and parameter strings.
	// Also sets mode of operation of the app
	while(wCount < argc)
		{

		//check we don't have a NULL string here
		if(argv[wCount][1] == '\0')
			throw ErrBadCommandFlag;


		/* Uncomment below for standalone key generation support
		//parse command list for operational parameters
		if (_tcscmp("-keys", argv[wCount]) == 0)	
			{
			*aApp = EKeys;
			//wcscpy(m_privateKeyFile, argv[argc - 2]);
			wcscpy(m_privateKeyFile, argv[argc - 1]);
			}
			
		else
		*/
		
		//display OpenSSL copyright notice.
		if (_tcsicmp(_T("-i"), argv[wCount]) == 0)
			{
			for (int index = 0; index < (sizeof(openSSLLicenseString)/sizeof(openSSLLicenseString[0])); ++index)
				{
				std::cout << openSSLLicenseString [index] << std::endl ;
				}
			break;
			}

		if (_tcsicmp(_T("-cert"), argv[wCount]) == 0)
			{
			if ((*aApp == ECert) || (*aApp == EReq))
				{
				throw ErrMalformedCommand;
				}
			else
				{
				*aApp = ECert;
				}
				
			if (argc < MIN_CERT_ARGS) throw ErrInsufficientArgs;
			
			}

			else if (_tcsicmp(_T("-req"), argv[wCount]) == 0)
				{
				if ((*aApp == ECert) || (*aApp == EReq))
					{
					throw ErrMalformedCommand;
					}
				else
					{
					*aApp = EReq;
					}
						
				if (argc < MIN_REQ_ARGS) throw ErrBadReqCommand;
			
				founddname = 1;							
			}

#ifdef OPTIONAL
			else if (_tcsicmp(_T("-chain"), argv[wCount]) == 0)
				{
				*aApp = EChain;
				command_count++;
				}
#endif
			else if (_tcsicmp(_T("-view"), argv[wCount]) == 0)
				{
				
				if (argc == MIN_VIEW_ARGS)
					{
					CCertificateGenerator* pView = new CCertificateGenerator;
					if (!pView) throw ErrCantViewCertificate;

					pView->View(argv[wCount + 1]);

					delete pView;
					}
					else
						throw ErrMalformedCommand;

				}

			else if (_tcsicmp(_T("-password"), argv[wCount]) == 0)
				{
				m_bPassword = true;
				command_count+=2;
				
				if (wCount < argc - 1)
					{
					_tcscpy(m_password, argv[wCount + 1]);
					if(!(_tcslen(m_password) >=4) )
						{
						_tprintf(_T("Error: Invalid Password\n"));
						throw ErrInvalidPassword;
						}
					}
				else
					throw ErrInsufficientArgs;
				
				}

#ifndef NORSA
			else if (_tcsicmp(_T("-rsa"), argv[wCount]) == 0)
				{
				m_CMDKey = ERSACipher;
				command_count++;
				}
#endif
		
			else if (_tcsicmp(_T("-dsa"), argv[wCount]) == 0)
				{
				m_CMDKey = EDSACipher;
				command_count++;
				}
		
			else if(_tcsicmp(_T("-dname"), argv[wCount]) == 0)
				{
				if(wCount < argc - 1)
					{
					//handle MBCS correctly (we are assuming that the parameter after -dname IS the dname string
					MBCSstrlen = _tcslen(argv[wCount + 1]) * sizeof(TCHAR);
					_tcscpy(m_dname, argv[wCount + 1]);
					dname = 1;
					}
					else
						throw ErrInsufficientArgs;
				}
			else if(_tcsicmp(_T("-len"), argv[wCount]) == 0)
				{
				//handle MBCS correctly
				if(wCount < argc - 1)
					{
					_tcscpy(m_KeyLenStr, argv[wCount + 1]);
					_stscanf(m_KeyLenStr, _T("%d"), &m_dwKeyLen);
				
					command_count+=2;	//len takes an additional parameter, so bump by 2
			
					if (m_dwKeyLen < 512 || m_dwKeyLen > 4096)
						{
						_tprintf(_T("Error: key length should be between 512 and 4096\n"));
						throw ErrInsufficientArgs;
						}
					}
				else
					throw ErrInsufficientArgs;
				}

			else if (_tcsicmp(_T("-expdays") , argv[wCount]) == 0 )
			{
			if(wCount < argc - 1)
				{
				_tcscpy(m_CertExpiryInDaysStr, argv[wCount + 1]);
				_stscanf(m_CertExpiryInDaysStr, _T("%d"), &m_dwCertExpiryInDays);

				command_count+=2;	//expiry days takes an additional parameter, so command_count+2
				}

			else
				{
				throw ErrInsufficientArgs;
				}
			}

			else if(_tcsicmp(_T("-v"), argv[wCount]) == 0)
				{
				SetVerbose(TRUE);
				command_count++;	//-v does not take args, so bump by 1
				}
			else if(argv[wCount][0] == '-')
			//if we get here we can't parse the option chosen
				{
				_tprintf(_T("Error: unknown command option %s\n"), argv[wCount]);
				throw ErrUnknownCommandFlag;		
				}

			wCount++;
		}

	//distinguished names are not optional, so throw up a message
	if (!dname && founddname)
		{
		_tprintf(_T("Error: Missing \"-dname\" command\n"));
		throw ErrInsufficientArgs;
		}


	//check to see if all the optional commands have the correct number of arguments
	if (((command_count + MIN_REQ_ARGS > argc) && (*aApp == EReq)) ||
		((command_count + MIN_CERT_ARGS > argc) && (*aApp == ECert)))

		{
		printf("Error: Command Line malformed - too few arguements\n");
		throw ErrInsufficientArgs;
		}

	if (*aApp == EReq)
		{
 		_tcscpy(m_privateKeyFile, argv[command_count + 4]);
 		_tcscpy(m_publicKeyFile, argv[command_count + 5]);
 		_tcscpy(m_requestFile, argv[command_count + 6]);
		

		if (wCount >= (command_count+2) + MIN_REQ_ARGS - 1)
			{
			printf("Error: Too many arguments for -req command\n");
			throw ErrTooManyArgs;
			}
		}

	if (*aApp == ECert)
		{
		_tcscpy(m_privateKeyFile, argv[command_count + 4]);
		_tcscpy(m_publicKeyFile, argv[command_count + 5]);
		
		if (wCount >= (command_count+2) + MIN_CERT_ARGS - 1)
			{
			_tprintf(_T("Error: too many arguments for -cert command\n"));
			throw ErrTooManyArgs;
			}
		}
	}

int CParseCmd::GetCMDKeyLen()
	{
	return m_dwKeyLen;
	}

int CParseCmd::GetCMDCertExpiryInDays()
	{
	return m_dwCertExpiryInDays;
	}

_TCHAR* CParseCmd::GetPrivateName()
	{
	return m_privateKeyFile;
	}

_TCHAR* CParseCmd::GetPublicName()
	{
	return m_publicKeyFile;
	}

_TCHAR* CParseCmd::GetRequestName()
	{
	return m_requestFile;
	}

_TCHAR* CParseCmd::GetDNameString()
	{
	return m_dname;
	}




_TCHAR* CParseCmd::GetPassword()
	{
	return m_password;
	}

TKeyType CParseCmd::GetKeyType()
	{
	return m_CMDKey;
	}

bool CParseCmd::GetPasswordEnabled()
	{
	return m_bPassword;	
	}

void CParseCmd::SetVerbose(const bool bVerbose)
	{
	m_bVerbose = bVerbose; 

	}

bool CParseCmd::GetVerbose()
	{
	return m_bVerbose; 

	}