/*

* 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");

	endName.append(iName);

	prog << Log::Indent() << "Writing " << startName << Log::Endl();

	TUint32 arrayLength = iArray.size();

	if(aWriteStream.HumanReadable())

		{

		// Human

		aWriteStream.WriteIndent();

		aWriteStream.WriteBin(startName.data(), startName.size());

		aWriteStream.WriteLineEnd();

		}

	else

		{

		// Binary

		// Write length of array

		aWriteStream.WriteBin(&arrayLength, sizeof(arrayLength));

		}

	aWriteStream.IncIndent();

	// Write array entries

	for(TUint32 i=0; i < arrayLength; ++i)

		{

		std::ostringstream entryComment;

		entryComment << "# Entry " << i+1;

		prog << Log::Indent() << entryComment.str() << Log::Endl();

		bool bracketItem = (iArray[i]->ItemType() != 0);

		if(aWriteStream.HumanReadable())

			{

			if(bracketItem)

				{

				std::ostringstream itemStart;

				itemStart << "Start" << iArray[i]->ItemType() << " " << iArray[i]->ItemName();

				prog << Log::Indent() << itemStart.str() << Log::Endl();

				aWriteStream.WriteIndent();

				aWriteStream.WriteCStr("Start");

				aWriteStream.WriteCStr(iArray[i]->ItemType());

				aWriteStream.WriteCStr(" \"");

				aWriteStream.WriteQuotedUtf8(iArray[i]->ItemName().data(), iArray[i]->ItemName().size());

				aWriteStream.WriteCStr("\"");

				aWriteStream.WriteLineEnd();

				}

			else

				{

				aWriteStream.WriteIndent();

				aWriteStream.WriteBin(entryComment.str().data(), entryComment.str().size());

				aWriteStream.WriteLineEnd();

				}

			}

		aWriteStream.IncIndent();

		iArray[i]->Encode(aWriteStream);

		aWriteStream.DecIndent();

		if(bracketItem && aWriteStream.HumanReadable())

			{

			std::ostringstream tmp;

			tmp << "End" << iArray[i]->ItemType();

			prog << Log::Indent() << tmp.str() << Log::Endl();

			aWriteStream.WriteIndent();

			aWriteStream.WriteBin(tmp.str().data(), tmp.str().size());

			aWriteStream.WriteLineEnd();

			}

		}

	aWriteStream.DecIndent();

	if(aWriteStream.HumanReadable())

		{

		// Human

		aWriteStream.WriteIndent();

		aWriteStream.WriteCStr("End");

		aWriteStream.WriteBin(iName.data(), iName.size());

		aWriteStream.WriteLineEnd();

		}

	prog << Log::Indent() << endName << Log::Endl();

	return;

}

void EncDecContainer::Decode(RDecodeReadStream &aReadStream)

{

	// Calculate Start/End container names

	std::string startName("Start");

	startName.append(iName);

	std::string endName("End");

	endName.append(iName);

	prog << Log::Indent() << "Reading " << startName << Log::Endl();

	if(aReadStream.HumanReadable())

		{

		// Human

		// Check/consume container StartX

		aReadStream.CheckName(startName);

		prog.IncIndent();

		// Create items until we find the container EndX

		TUint32 entryNum=1;

		while(aReadStream.PeakToken() != endName)

			{

			// Progress message

			prog << Log::Indent() << "# Entry " << std::dec << entryNum++ << std::hex << Log::Endl();

			EncDecContainerItem *item = iFactory();

			bool bracketedItem = (item->ItemType() != 0);

			std::string itemName;

			if(bracketedItem && aReadStream.HumanReadable())

				{

				// Bracketed item, so read ItemType tag and ItemName

				std::string itemStart("Start");

				itemStart.append(item->ItemType());

				aReadStream.CheckName(itemStart);

				prog << Log::Indent() << itemStart;

				// Read item name

				aReadStream.ReadNextToken();

				itemName = aReadStream.Token();

				}

			prog.IncIndent();

			item->Decode(aReadStream);

			iArray.push_back(item);

			prog.DecIndent();

			if(bracketedItem && aReadStream.HumanReadable())

				{

				// Bracketed item, so read End ItemType tag

				std::string itemEnd("End");

				itemEnd.append(item->ItemType());

				aReadStream.CheckName(itemEnd);

				// and set item name

				item->SetItemName(itemName);

				}

			}

		// Check/consume container EndX

		aReadStream.CheckName(endName);

		prog.DecIndent();

		}

	else

		{

		// Binary

		// Read number of entries

		TUint32 arrayLength;

		aReadStream.RawRead(&arrayLength, sizeof(arrayLength));

		prog.IncIndent();

		for(TUint32 i=0; i < arrayLength; ++i)

			{

			EncDecContainerItem *item = iFactory();

			prog << Log::Indent() << "# Entry " << std::dec << i+1 << std::hex << Log::Endl();

			prog.IncIndent();

			item->Decode(aReadStream);

			prog.DecIndent();

			iArray.push_back(item);

			}

		prog.DecIndent();

		}

	prog << Log::Indent() << endName << Log::Endl();

}

REncodeWriteStream& operator<<(REncodeWriteStream& aStream, const EncDecContainer &aContainer)

{

	aContainer.Encode(aStream);

	return aStream;

}

RDecodeReadStream& operator>>(RDecodeReadStream& aStream,EncDecContainer &aContainer)

{

	aContainer.Decode(aStream);

	return aStream;

}

//

// TUid

//

void EncodeHuman(REncodeWriteStream& aStream,const TUid &aUid)

{

	aStream.WriteHexNumber(aUid.iUid);

}

void DecodeHuman(RDecodeReadStream& aStream,TUid &aUid)

{

	aUid.iUid = aStream.ReadUnsignedNumber(sizeof(aUid.iUid));

}

//

// TName

//

void EncodeHuman(REncodeWriteStream& aStream,const TName &aName)

{

	// Compress the internal UTF-16 to human readable UTF-8

	;

	TInt outputBytes = 0;

	TUint8 *outBuf = cstrFromUtf16(aName.Ptr(), aName.Length(), outputBytes);

	aStream.WriteByte('"');

	aStream.WriteQuotedUtf8(outBuf, outputBytes);

	aStream.WriteByte('"');

	delete [] outBuf;

}

void DecodeHuman(RDecodeReadStream& aStream,TName &aName)

{

	aStream.ReadNextToken();

	// Expand UTF-8 into internal UTF-16LE representation

	TInt outputWords = 0;

	TText *outputBuf = utf16FromUtf8((const TUint8 *)aStream.Token().data(), aStream.Token().size(), outputWords);

	memcpy((void *)aName.Ptr(), outputBuf, outputWords*2);

	aName.SetLength(outputWords);

	delete [] outputBuf;

}

void readContainer(const std::string &aFileName, bool aHuman, EncDecContainer &container)

{

	if(aHuman)

		{

		FileReadStream fileReadStream(aFileName, true);

		std::string certBaseName(aFileName);

		size_t dotLoc = certBaseName.rfind('.');

		if(dotLoc != std::string::npos)

			{

			certBaseName.erase(dotLoc);

			}

		certBaseName += '_';

		RDecodeReadStream inStream(certBaseName, fileReadStream); // human readable

		inStream >> container;

		inStream.Close();

		}

	else

		{

		RFs fs;

		User::LeaveIfError(fs.Connect());

		CleanupClosePushL(fs);

		CPermanentFileStore* store = CPermanentFileStore::OpenLC(fs, _L16(aFileName.c_str()),EFileShareAny | EFileRead);

		store->SetTypeL(KPermanentFileStoreLayoutUid);

		RStoreReadStream rootStream;

		rootStream.OpenLC(*store, store->Root());

		TUint32 dataStreamId;

		rootStream >> dataStreamId;

		CleanupStack::PopAndDestroy(&rootStream); 

		RStoreReadStream dataStream;

		dataStream.OpenLC(*store, dataStreamId);

		RDecodeReadStream readStream(store, dataStream); // binary store

		readStream >> container;

		CleanupStack::PopAndDestroy(&dataStream); 

		CleanupStack::PopAndDestroy(store); 

		CleanupStack::PopAndDestroy(&fs); 

		}

}

void writeContainer(const char *aFileName, bool aHuman, bool aPemOut, bool aVerbose, const EncDecContainer &container)

{

	prog << Log::Indent() << "Writing output file '" << aFileName << "'" << Log::Endl();

	prog.IncIndent();

	if(aHuman)

		{

		FileWriteStream fileWriteStream(aFileName);

		// Calculate based name by striping last .xx extension and appending an underscore.

		std::string certBaseName(aFileName);

		size_t dotLoc = certBaseName.rfind('.');

		if(dotLoc != std::string::npos)

			{

			certBaseName.erase(dotLoc);

			}

		certBaseName += '_';

		REncodeWriteStream outStream(certBaseName, fileWriteStream); // human readable

		outStream.PemOut() = aPemOut;

		outStream.Verbose() = aVerbose;

		outStream << container;

		outStream.Close();

		}

	else

		{

		RFs fs;

		User::LeaveIfError(fs.Connect());

		CleanupClosePushL(fs);

		CFileStore* store = CPermanentFileStore::ReplaceLC(fs,_L16(aFileName),EFileShareAny | EFileRead | EFileWrite);

		store->SetTypeL(KPermanentFileStoreLayoutUid);

		RStoreWriteStream dataStream;

		TStreamId dataStreamId = dataStream.CreateLC(*store);

		REncodeWriteStream outStream(store, dataStream); // binary

		outStream << container;

		outStream.Close();

		dataStream.CommitL();

		dataStream.Close();

		RStoreWriteStream rootStream;

		TStreamId rootId = rootStream.CreateLC(*store);

		rootStream << dataStreamId;

		rootStream.CommitL();

		rootStream.Close();

		store->SetRootL(rootId);

		store->CommitL();

		CleanupStack::PopAndDestroy(&dataStream); 

		CleanupStack::PopAndDestroy(store); 

		CleanupStack::PopAndDestroy(&fs); 

		}

	prog.DecIndent();

}

// End of file