/*

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

*

*/

#include "encdec.h"

#include <sstream>

#include <errno.h>

#include <s32ucmp.h>

#include "stringconv.h"

#include <stdio.h>

#include "x509utils.h"

RDecodeReadStream::RDecodeReadStream(CFileStore *aStore, RReadStream &aReadStream)

	: iStore(aStore), iCertBaseName(), iReadStream(aReadStream), iHumanReadable(false), iToken(), 

	  iPrefetchedTokenIsValid(false), iPrefetchedToken()

{

}

RDecodeReadStream::RDecodeReadStream(const std::string &aCertBaseName, RReadStream &aReadStream)

	: iStore(0), iCertBaseName(aCertBaseName), iReadStream(aReadStream), iHumanReadable(true), iToken(), 

	  iPrefetchedTokenIsValid(false), iPrefetchedToken()

{

}

void RDecodeReadStream::RawRead(void *aPtr, TUint32 aLength)

{

	iReadStream.ReadL((TUint8 *)aPtr, aLength);

}

void RDecodeReadStream::CheckName(const std::string &aExpected)

{

	ReadNextToken();

	if(iToken != aExpected)

		{

		dbg << Log::Indent() << "Expected token '" << aExpected <<"' but got token '" << iToken << "'" << Log::Endl();

		FatalError();

		}

}

TUint32 ReadUnsignedNumber(std::string &aStr, size_t aSize)

{

	TUint32 val;

	std::istringstream ss(aStr);

	if((aStr.length() > 2) && 

	   (aStr[0] == '0') && 

	   ((aStr[1] == 'x') || (aStr[1] == 'X')))

		{

		// Hex number starting with 0x

		char ch;

		ss >> ch >> ch; // Discard the 0x

		ss >> std::hex >> val;

		}

	else

		{

		// Decimal number

		ss >> val;

		}

	// Now work out if we consumed the entire token without error

	if(ss.fail())

		{

		// Number decode failed

		dbg << Log::Indent() << "Failed to decode '" << aStr << "' as a number" << Log::Endl();

		FatalError();

		}

	// Make sure we consumed all data

	if(! ss.eof())

		{

		// Trailing chars on numeric token

		FatalError();

		}

	if(aSize != 4)

		{

		// Check range

		// nb the following check would fail if aSize==4 because x>>32 == x if sizeof(x)==4

		if((val >> (8*aSize)) != 0)

			{

			// Higher order bits are set above the size of the variable we

			// are returning into

			FatalError();

			}

		}

return val;

}

TUint32 RDecodeReadStream::ReadUnsignedNumber(size_t aSize)

{

BULLSEYE_OFF

	if((TUint32(aSize)>4))

		{

		FatalError();

		}

BULLSEYE_RESTORE

	ReadNextToken();

	return ::ReadUnsignedNumber(iToken, aSize);

}

const std::string &RDecodeReadStream::Token() const

{

	return iToken;

}

void RDecodeReadStream::ReadNextToken()

{

	if(iPrefetchedTokenIsValid)

		{

		// Copy prefetched token to current token

		iToken = iPrefetchedToken;

		iPrefetchedToken.clear();

		iPrefetchedTokenIsValid = false;

		return;

		}

	GetToken(iToken);

}

const std::string &RDecodeReadStream::PeakToken()

{

	if(!iPrefetchedTokenIsValid)

		{

		GetToken(iPrefetchedToken);

		iPrefetchedTokenIsValid = true;

		}

	return iPrefetchedToken;

}

bool RDecodeReadStream::HumanReadable() const

{

	return iHumanReadable;

}

void RDecodeReadStream::Close()

{

	iReadStream.Close();

}

void RDecodeReadStream::GetToken(std::string &aToken)

{

	aToken.clear();

	TUint8 ch;

	do 

		{

		iReadStream >> ch;

		if(ch == '#')

			{

			// Skip comment

			++ch;

			while((ch != '\r') && (ch != '\n'))

				{

				iReadStream >> ch;

				} 

			}

		} while((ch == ' ') || (ch == '\t') || (ch == '\r') || (ch == '\n'));

	if(ch == '"')

		{

		// Read a string

		iReadStream >> ch; // read first char

		while(ch != '"')

			{

			if(ch=='\\')

				{

				// \X causes X to always be saved (even if X is ")

				iReadStream >> ch;

				}

			aToken.push_back(ch);

			iReadStream >> ch;

			}

		// At this point ch contains WS so it can be discarded.

		return;

		}

	// Read a non-string token

	while((ch != ' ') && (ch != '\t') && (ch != '\r') && (ch != '\n'))

		{

		aToken.push_back(ch);

		iReadStream >> ch;

		}

	// At this point ch contains WS so it can be discarded.

	return;

}

REncodeWriteStream::REncodeWriteStream(CFileStore *aStore, RWriteStream &aWriteStream)

	: iStore(aStore),

	  iCertBaseName(), // not used for STORE based streams

	  iWriteStream(&aWriteStream),

	  iLogStream(0), 

	  iHumanReadable(false), iPemOut(false), iVerbose(false), iIndentLevel(0)

{

}

REncodeWriteStream::REncodeWriteStream(const std::string &aCertBaseName, RWriteStream &aWriteStream)

	: iStore(0), iCertBaseName(aCertBaseName), iWriteStream(&aWriteStream),

	  iLogStream(0), 

	  iHumanReadable(true), iPemOut(false), iVerbose(false), iIndentLevel(0)

{

}

REncodeWriteStream::REncodeWriteStream(Log &aLog)

	: iStore(0), iWriteStream(0), iLogStream(&aLog.Stream()), 

	  iHumanReadable(true), iPemOut(false), iVerbose(false), iIndentLevel(aLog.IndentLevel())

{

}

void REncodeWriteStream::WriteBin(const void *aPtr, TUint32 aLength)

{

	if(iWriteStream)

		{

		iWriteStream->WriteL((TUint8 *)aPtr, aLength);

		}

	if(iLogStream)

		{

		iLogStream->write((const char *)aPtr, aLength);

		iLogStream->flush();

		}

}

void REncodeWriteStream::WriteQuotedUtf8(const void *aStr, TUint32 aLength)

{

	std::string tmp((const char *)aStr, aLength);

	// Insert a backslash before any backslash chars

	size_t pos = 0;

	while((pos = tmp.find('\\', pos)) != std::string::npos)

		{

		tmp.insert(pos, "\\", 1);

		pos += 2;

		}

	// Insert a backslash before any double quote chars

	pos = 0;

	while((pos = tmp.find('"', pos)) != std::string::npos)

		{

		tmp.insert(pos, "\\", 1);

		pos += 2;

		}

	if(iWriteStream)

		{

		iWriteStream->WriteL((TUint8 *)tmp.data(), tmp.size());

		}

	if(iLogStream)

		{

		iLogStream->write(tmp.data(), tmp.size());

		iLogStream->flush();

		}

}

void REncodeWriteStream::WriteByte(TUint8 aByte)

{

	WriteBin(&aByte, 1);

}

void REncodeWriteStream::WriteCStr(const void *aCstr)

{

	WriteBin(aCstr, strlen((const char *)aCstr));

}

void REncodeWriteStream::WriteHexNumber(TUint32 aNumber)

{

	char buf[20];

	int len = sprintf(buf, "0x%x", aNumber);

	WriteBin(buf, len);

}

void REncodeWriteStream::WriteSpace()

{

BULLSEYE_OFF

	if(!iHumanReadable) return;

BULLSEYE_RESTORE

	WriteByte(' ');

}

void REncodeWriteStream::WriteLineEnd()

{

BULLSEYE_OFF

	if(!iHumanReadable) return;

BULLSEYE_RESTORE

#ifdef linux

	WriteByte('\n');

#else

	WriteBin("\r\n", 2);

#endif

}

void REncodeWriteStream::WriteIndent()

{

BULLSEYE_OFF

	if(!iHumanReadable) return;

BULLSEYE_RESTORE

	for(int i=0; i<iIndentLevel; ++i)

		{

		WriteByte('\t');

		}

}

void REncodeWriteStream::IncIndent()

{

	prog.IncIndent();

	++iIndentLevel;

BULLSEYE_OFF

	if(iIndentLevel < 0) FatalError();

BULLSEYE_RESTORE

}

void REncodeWriteStream::DecIndent()

{

	prog.DecIndent();

	--iIndentLevel;

BULLSEYE_OFF

	if(iIndentLevel < 0) FatalError();

BULLSEYE_RESTORE

}

bool REncodeWriteStream::HumanReadable() const

{

	return iHumanReadable;

}

bool &REncodeWriteStream::PemOut()

{

	return iPemOut;

}

bool &REncodeWriteStream::Verbose()

{

	return iVerbose;

}

std::string REncodeWriteStream::CertFileName(TUint32 aFormat, TUint32 aCertNumber)

{

	std::stringstream ss;

	ss << iCertBaseName;

	ss << "cert";

	ss << aCertNumber;

	if(aFormat == EX509Certificate)

		{

		if(iPemOut)

			{

			ss << ".pem";

			}

		else

			{

			ss << ".der";

			}

		}

	else

		{

		ss << ".dat";

		}

	return ss.str();

}

void REncodeWriteStream::Close()

{

BULLSEYE_OFF

	if(iWriteStream)

BULLSEYE_RESTORE

		{

		iWriteStream->Close();

		}

}

CFileStore *REncodeWriteStream::StoreObject()

{

BULLSEYE_OFF

	if(iStore == 0) FatalError();

BULLSEYE_RESTORE

	return iStore;

}

RWriteStream &REncodeWriteStream::StoreWriteStream()

{

BULLSEYE_OFF

	if(iWriteStream == 0) FatalError();

BULLSEYE_RESTORE

	return *iWriteStream;

}

bool REncodeWriteStream::Quiet() const

{

	return iLogStream != 0;

}

TUint8 fromHex(TUint8 ch)

	/**

	   Convert a single hex char from ascii

	 */

{

	// convert to lowercase

	if((ch >= 'A') && (ch <= 'F'))

		{

		ch -= ('A' -'a');

		}

	// Handle a-f

	if((ch >= 'a') && (ch <= 'f'))

		{

		return ch - 'a' + 10;

		}

	// Handle 0-9

	if((ch >= '0') && (ch <= '9'))

		{

		return ch - '0';

		}

	// Illegal

	FatalError();

	return 0xff;

}

EncDecContainerItem::~EncDecContainerItem()

{

}

#ifdef _BullseyeCoverage

#pragma BullseyeCoverage off

#endif

std::string EncDecContainerItem::ItemName() const

{

	// Should never be called

	exit(-1);

	std::string tmp;

	return tmp;

}

void EncDecContainerItem::SetItemName(const std::string &)

{

	// Should never be called

	exit(-1);

}

#ifdef _BullseyeCoverage

#pragma BullseyeCoverage restore

#endif

EncDecContainer::EncDecContainer(const char *aContainerName, EncDecContainerItemFactoryFunc *aFactory)

	: iName(aContainerName), iFactory(aFactory), iArray()

{

}

EncDecContainer::~EncDecContainer()

{

	reset();

}

void EncDecContainer::push_back(EncDecContainerItem *aItem)

{

	iArray.push_back(aItem);

}

const EncDecContainerItem &EncDecContainer::operator[](TUint32 aIndex) const

{

	return *iArray[aIndex];

}

EncDecContainerItem &EncDecContainer::operator[](TUint32 aIndex)

{

	return *iArray[aIndex];

}

TUint32 EncDecContainer::size() const

{

	return iArray.size();

}

void EncDecContainer::reset()

{

	while(!iArray.empty())

		{

		EncDecContainerItem *p = iArray.back();

		iArray.pop_back();

		delete p;

		}

}

void EncDecContainer::Encode(REncodeWriteStream &aWriteStream) const

{

	// Calculate Start/End container names

	std::string startName("Start");

	startName.append(iName);

	std::string endName("End");