/*

* Copyright (c) 1997-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: 

* Various utility functions

* INCLUDES

*

*/

#include "utils.h"

#include <stdio.h>

// ===========================================================================

// GLOBAL UTILS FUNCTIONS

// ===========================================================================

LPSTR MakeMBCSString(LPCWSTR uniStr, UINT codePage, DWORD& length)

// Convert a UNICODE string to a multi-byte string

	{

	LPSTR mbStr;

	// get num unicode chars required

	DWORD len = WideCharToMultiByte(codePage, 0, uniStr, length, NULL, 0, NULL, NULL);

	mbStr = new CHAR[len+1];

	if (!mbStr) throw ErrNotEnoughMemory;

	// convert

	WideCharToMultiByte(codePage, 0, uniStr, length, mbStr, len, NULL, NULL);

	mbStr[len]='\0';

	length=len;

	return mbStr;

	}

LPWSTR  MakeUnicodeString(LPSTR mbcsStr, UINT codePage)

// Convert a multi-byte string to a UNICODE string

{

	int retVal=0, len;

	LPWSTR uniStr;

	if(mbcsStr == NULL) return NULL;

	len = MultiByteToWideChar(codePage, 0, mbcsStr, strlen(mbcsStr)+1, NULL, 0);

	uniStr = new WCHAR[len+1];

	retVal = MultiByteToWideChar(codePage, 0, mbcsStr, strlen(mbcsStr)+1, uniStr, len);

	return uniStr;

}

void PrintError(char* aMsg, TErrType aErrType, bool aVerbose, const char* aFileName, int aLineNum)

//Print error messages in the generation of a key or certificate

{

   	if(!aMsg)

		return;

	fprintf(stderr, "\n** %s ", aMsg);

	if(aVerbose)

	{	

		if(aErrType == EOPENSSL)

		{

			fprintf(stderr, " %s:%i\n", aFileName, aLineNum);

			ERR_print_errors_fp(stderr);

		}else if(aErrType == EMSCrypto)

		{

			LPVOID lpMsgBuf = NULL;

			FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM

						   | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), 0, 

						   (LPTSTR)&lpMsgBuf, 0, NULL);

			fprintf(stderr, "%s:%i %s\n", aFileName, aLineNum, (LPCTSTR)lpMsgBuf);

			// Free the buffer.

			LocalFree( lpMsgBuf ); 

		} else

		{

			fprintf(stderr, "%s:%i\n", aFileName, aLineNum);

		}

	}

}

// ===========================================================================

// These functions format a DN string

// ===========================================================================

// ===========================================================================

// CONSTANTS

// ===========================================================================

_TCHAR TSN_commonName[]				= _T("CN");

_TCHAR TSN_countryName[]			= _T("C");

_TCHAR TSN_countryNameOld[]			= _T("CO");

_TCHAR TSN_localityName[]			= _T("L");

_TCHAR TSN_stateOrProvinceName[]	= _T("ST");

_TCHAR TSN_organizationName[]		= _T("O");

_TCHAR TSN_organizationNameOld[]	= _T("OR");

_TCHAR TSN_organizationalUnitName[]	= _T("OU");

_TCHAR TSN_email[]					= _T("EM");

void DoFormatted(_TCHAR* aDN, entry_pack** aEntPack)

//Given Distinguished Name string is parsed and filled into entry pack structure

	{

	_TCHAR* pToken  = NULL;

	_TCHAR* pLstr   = NULL;

	_TCHAR* pRstr   = NULL;

    char*   pKeyWord = NULL;

	*aEntPack = (struct entry_pack*)malloc(sizeof(struct entry_pack ));

	InitEntryPack(aEntPack);

	_TCHAR sep[] = _T("=");

	pToken = _tcstok(aDN, sep);

	if(!(pKeyWord = IsValid(pToken)))

		{

		return;

		}

	int i = 0;

	strcpy((*aEntPack)->entries[i].key, pKeyWord);

	pToken = _tcstok(NULL, sep);

	bool bMayBadParam = false;

	int  retVal		  = 0;

	while (pToken != NULL)

		{	

		if(bMayBadParam)

			{

			i = 0;

			break;

			}

		retVal = SplitString(pToken, &pLstr, &pRstr);

		if(retVal)

			{	

			_tcscpy((*aEntPack)->entries[i++].value, RemoveSpaces(pLstr));

			if(pRstr)

				{

				strcpy((*aEntPack)->entries[i].key, IsValid(pRstr));

				}

			}

		else

			{	

			_tcscpy((*aEntPack)->entries[i++].value, RemoveSpaces(pLstr));

			if(!pRstr)

				{	

				bMayBadParam = true;

				}

			}

		pToken = _tcstok(NULL, sep);

		}

		(*aEntPack)->num = i;

	}

_TCHAR* RemoveSpaces(_TCHAR* aStr)

//Removes unnecessary spaces from a given string

	{

	LPCTSTR lpszTargetList = _T(" ");

	LPTSTR  lpsz = aStr;

	LPTSTR  lpszLast = NULL;

	//Trim Left

	while (*lpsz != '\0')

		{

		if (_tcschr(lpszTargetList, *lpsz) == NULL)

			break;

		lpsz = _tcsinc(lpsz);

		}

	if (lpsz != aStr)

		{

		int nDataLength = _tcslen(aStr) - (lpsz - aStr);

		wmemmove(aStr, lpsz, (nDataLength+1)*sizeof(TCHAR));

		}

	lpsz = aStr;

	lpszLast = NULL;

	//Trim Right

	while (*lpsz != '\0')

		{

		if (_tcschr(lpszTargetList, *lpsz) != NULL)

			{

			if (lpszLast == NULL)

				lpszLast = lpsz;

			}

		else

			lpszLast = NULL;

		lpsz = _tcsinc(lpsz);

		}

	if (lpszLast != NULL)

		{

		// truncate at left-most matching character

		*lpszLast = '\0';

		}

	return aStr;

	}

char* IsValid(_TCHAR* aTk)

//Checks whether a found string is a valid distinguished name key

	{

	if(!aTk)

		return NULL;

	if(!_tcscmp(aTk, TSN_commonName))

		{

		return LN_commonName;

		}

	else if(!_tcscmp(aTk, TSN_countryName) || !_tcscmp(aTk, TSN_countryNameOld))

		{

		return LN_countryName;

		}

	else if(!_tcscmp(aTk, TSN_localityName))

		{

		return LN_localityName;

		}

	else if(!_tcscmp(aTk, TSN_stateOrProvinceName))

		{

		return LN_stateOrProvinceName;

		}

	else if(!_tcscmp(aTk, TSN_organizationName) || !_tcscmp(aTk, TSN_organizationNameOld))

		{

		return LN_organizationName;

		}

	else if(!_tcscmp(aTk, TSN_organizationalUnitName))

		{

		return LN_organizationalUnitName;

		}

	else if(!_tcscmp(aTk, TSN_email))

		{

		return LN_pkcs9_emailAddress;

		}

	else

		{

		return NULL;

		} 

	}

int SplitString(_TCHAR* aToken, _TCHAR** aStrFirst, _TCHAR** aStrSecond)

//A given string is divided in two parts if applicable. First part is DN value

//second part is key value.

	{

	int i = 0;

	_TCHAR *pTmp = NULL;

	pTmp = aToken;

	pTmp = pTmp + (_tcslen(pTmp)-2);

	if(IsValid(pTmp) && (aToken[(pTmp - aToken)-1] == 32))

		{

		*aStrFirst = aToken;

		aToken[_tcslen(aToken)-3] = '\0';

		*aStrSecond = pTmp;

		} 

	else 

		{

		pTmp = aToken;

		pTmp = pTmp + (_tcslen(pTmp)-1);

		if(IsValid(pTmp) && (aToken[(pTmp - aToken)-1] == 32))

			{

			*aStrFirst = aToken;

			aToken[_tcslen(aToken)-2] = '\0';

			*aStrSecond = pTmp;

			} 

		else

			{

			*aStrFirst = aToken;

			*aStrSecond = NULL;

			return 0;

			}

		}

	return 1;

	}

void InitEntryPack(struct entry_pack** aEntPack)

//Initialize an entry pack structure pointer

	{

	memset(*aEntPack,0, sizeof(struct entry_pack));

	(*aEntPack)->num = 0;

	}