/*
* 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;
}