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