// 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 "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 <charconv.h>

// #define __OUTPUT_WMLC	// Debug Stuff - uncomment to get wmlc output.

#include <wbconverter.h>

#include "WbToken.h"

#include <mwbxmlconverterobserver.h>

#include "WbEnum.h"

#include "ByteList.h"

#include <s32file.h>

// Wap specific error codes defined here

#include <wapengstd.h>

//

// Library routines

//

#ifndef EKA2

GLDEF_C TInt E32Dll(TDllReason /*aReason*/)

{

	return (KErrNone);

}

#endif

GLDEF_C void Panic (TWbxmlPanic aPanic)

{

	_LIT(KWbPanic,"WbxmlConverter");

	User::Panic(KWbPanic ,aPanic);

}

//

// class CWbxmlConverter - external API

//

const TInt KOutputBufferLength=1024;

CWbxmlConverter::CWbxmlConverter(RFs& aFs)

: iFs(aFs)

{

	__DECLARE_NAME(_S("CWbxmlConverter"));

}

EXPORT_C CWbxmlConverter* CWbxmlConverter::NewL(RFs& aFs, MWbxmlConverterObserver* aObserver)

{

	CWbxmlConverter* instance = NewLC(aFs, aObserver);

	CleanupStack::Pop();

	return instance;

}

EXPORT_C CWbxmlConverter* CWbxmlConverter::NewLC(RFs& aFs, MWbxmlConverterObserver* aObserver)

{

	CWbxmlConverter* instance = new (ELeave) CWbxmlConverter(aFs);

	CleanupStack::PushL(instance);

	instance->ConstructL(aObserver, NULL);

	return instance;

}

EXPORT_C CWbxmlConverter* CWbxmlConverter::NewL(RFs& aFs, MWbxmlConverterObserver* aObserver, const TDesC* aCharacterEncoding)

{

	CWbxmlConverter* instance = new (ELeave) CWbxmlConverter(aFs);

	CleanupStack::PushL(instance);

	instance->ConstructL(aObserver, aCharacterEncoding);

	CleanupStack::Pop();

	return instance;

}

CWbxmlConverter::~CWbxmlConverter()

{

	delete[] iStringTable;

	delete iPublicIdStr;

	delete iByteList;

	delete iCharsetConverter;

	delete iOutputBuffer;

	if( iTagStack )

	{

		iTagStack->Reset();

		delete iTagStack;

	}

	if (iTagArray)

	{

		if (iTagArray->Count())

			iTagArray->ResetAndDestroy();

		delete iTagArray;

	}

	if (iAttArray)

	{

		if (iAttArray->Count())

			iAttArray->ResetAndDestroy();

		delete iAttArray;

	}

#ifdef __OUTPUT_WMLC

	iWmlcFile.Close();

	iWmlcFs.Close();

#endif

}

void CWbxmlConverter::ConstructL(MWbxmlConverterObserver* aObserver, const TDesC* aCharacterEncoding)

{

	iObserver = aObserver;

	iState = EConvertVersion;

	iByteList = CByteList::NewL();

	iParsing = EParseTag;

	iOpenQuote = EFalse;

	iTagStack = new CArrayFixFlat<TUint16>(7);

	iOutputBuffer = HBufC8::NewL(KOutputBufferLength);

	iCharsetConverter = CCnvCharacterSetConverter::NewL();

	if( aCharacterEncoding != NULL )

	{

		HBufC8* charset = HBufC8::NewLC(aCharacterEncoding->Length());

		charset->Des().Copy(*aCharacterEncoding);

		iWbxmlCharset = iCharsetConverter->ConvertStandardNameOfCharacterSetToIdentifierL(*charset, iFs);

		CleanupStack::PopAndDestroy();

	}

#ifdef __OUTPUT_WMLC

	_LIT(KWmlcFileName, "c:\\WmlcFile.wmlc");

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

	TInt error = iWmlcFile.Replace(iWmlcFs, KWmlcFileName, EFileWrite);

	if( error != KErrNone )

		User::Leave(EWapErrAccessViolation);

#endif

}

EXPORT_C void CWbxmlConverter::ProcessDataL(HBufC8& aBuffer)

{

#ifdef __OUTPUT_WMLC

	iWmlcFile.Write(aBuffer);

#endif

	iByteList->AddToListL(aBuffer);

	HandleDataL();

}

EXPORT_C void CWbxmlConverter::CWbxmlConverter_Reserved1()

{

	// Must exist for Binary Compatibility

}

EXPORT_C void CWbxmlConverter::CommitL()

{

	HandleDataL();

	// Document should be finished

	if (iState != EConvertFinished)

		User::Leave(EWapErrDocumentCorrupted);

}

EXPORT_C void MWbxmlConverterObserver::MWbxmlConverterObserver_Reserved1()

{

	// Must exist for Binary Compatibility

}

void CWbxmlConverter::SetNextStateL(TInt aResult, TConvertState aState)

{

	switch (aResult)

	{

	case KErrNone:

		iState = aState;

		break;

	case KErrNotFound:

		iByteList->RollBack();

		break;

	default:

		User::Leave(EWapErrDocumentCorrupted);

	}

	iByteList->Commit();

}

TInt CWbxmlConverter::ConvertWbxmlVersionL()

{

	if (iByteList->Byte(&iWbxmlVersion,TRUE) != KErrNone)

		return KErrNotFound;

	BufferAndOutputL(KWbXmlVersion10);

	return KErrNone;

}

TInt CWbxmlConverter::ConvertPublicIdValueL()

{

	TUint8 pubIDFirstByte = 0;

	if( iByteList->Byte(&pubIDFirstByte,EFalse) != KErrNone )

		return KErrNotFound;

	if( pubIDFirstByte == 0 )

	{

		// The public id is in string table, index follows

		iByteList->Inc(1);

		if( ExtractMultiByte(&iPublicIdIndex,0) != KErrNone )

			return KErrNotFound;

		iPublicId = 0;

	}

	else

	{

		// "Normal" publicId, a multibyte

		if (ExtractMultiByte(&iPublicId,0) != KErrNone)

			return KErrNotFound;

	}

	return KErrNone;

}

TInt CWbxmlConverter::ConvertCharsetL()

	{

	TUint32 charsetMIB = 0;

	// The chrset part of bytecode document was only introduced

	// in WML 1.1.

	if (iWbxmlVersion >= (TInt8) 0x01)

		{

		if (ExtractMultiByte(&charsetMIB,0) != KErrNone)

			return KErrNotFound;

		}

	// if the charset wasn't already provided by HTTP, we set it according

	// to the bytecode content charset

	if( !iWbxmlCharset )

		{

		if( charsetMIB != 0 )

			{

			iWbxmlCharset = iCharsetConverter->ConvertMibEnumOfCharacterSetToIdentifierL(charsetMIB, iFs);

			}

		if( iWbxmlCharset == 0 )

			{

			// Patch in the most common results

			switch(charsetMIB)

				{

				case 4:

					iWbxmlCharset = KCharacterSetIdentifierIso88591;

					break;

				case 5:

					iWbxmlCharset = KCharacterSetIdentifierIso88592;

					break;

				case 7:

					iWbxmlCharset = KCharacterSetIdentifierIso88594;

					break;

				case 8:

					iWbxmlCharset = KCharacterSetIdentifierIso88595;

					break;

				case 10:

					iWbxmlCharset = KCharacterSetIdentifierIso88597;

					break;

				case 12:

					iWbxmlCharset = KCharacterSetIdentifierIso88599;

					break;

				case 103:	// UTF7

					iWbxmlCharset = KCharacterSetIdentifierUtf7;

					break;

				case 104:

					iWbxmlCharset = KCharacterSetIdentifierImapUtf7;

					break;

				case 0:

					// Default case

				case 106:	// UTF8

					// If the charset from bytecode was 'unknown' (0) or the converter couldn't

					// match the mib number to known charset identifiers we use 

					// the default charset: UTF-8

					iWbxmlCharset = KCharacterSetIdentifierUtf8;

					break;

				default:

					return KErrNotSupported;

				}

			}

		// Now we need to inform our observer what charset we are using

		HBufC8* charSetName = iCharsetConverter->ConvertCharacterSetIdentifierToStandardNameL(iWbxmlCharset, iFs);

		CleanupStack::PushL(charSetName);

		iObserver->HandleWbxmlEncodingUpdateL(charSetName);

		CleanupStack::PopAndDestroy();		// charSetName

		}

	return KErrNone;

	}

TInt CWbxmlConverter::ConvertStringTableL()

{

	if (iStringTable == NULL)

	{

		// Need "static" instance variable for streaming iStringTable!

		if( ExtractMultiByte(&iContinue,0) != KErrNone )

			return KErrNotFound;

		if (iContinue == 0)

			return KErrNone;

		iStringTable = HBufC8::NewL(iContinue);

	}

	if (iContinue != 0)

	{

		// Note: String table is 8bit data

		TUint8 byte = 0;

		while (iContinue)

		{

			if ((iByteList->Byte(&byte,TRUE)) != KErrNone)

			{

				iByteList->Commit();

				return KErrNotFound;

			}

			iStringTable->Des().Append(byte);

			iContinue--;

		}

	}

	// Ensure that string table is zero terminated

	TInt length = iStringTable->Length();

	if( iStringTable->Des()[length-1] != 0 )

		{

		// Make table one character bigger, and make sure last character is zero terminator

		iStringTable = iStringTable->ReAllocL(length + 1);

		iStringTable->Des().Append(0);

		}

	return KErrNone;

}

TInt CWbxmlConverter::ConvertPublicIdNameL()

{

	HBufC* fileName = NULL;

	switch (iPublicId)

	{

	case KWbxmlIdIndex:

		// Meaning: Followed by string table index for public id

		User::Leave(EWapErrUnknownDocument);

		break;

	case KWbxmlIdUnknown:

		// Meaning: unknown or missing

		// WML spec says that unknown DTD is handled as well as possible

		// so we presume it's supposed to be WML 1.1

		fileName = FindTokenFileL(KWbTokenDatabaseWml11);

		CleanupStack::PushL(fileName);

		OpenTokenFileL(*fileName);

		CleanupStack::PopAndDestroy(); // fileName

		// Waste the publicID string received from the token file

		delete iPublicIdStr;

		// ...and replace it with the one from the string table

		{

			TPtrC8 remainderFromIndex = iStringTable->Des().Mid(iPublicIdIndex);

			TInt idLen = remainderFromIndex.Locate('\0');

			// We trust that the string table is properly constructed and

			// contains the terminating null...

			if( idLen == KErrNotFound )

				return KErrNotFound;		// Ah well, Our trust was misplaced!

			TPtrC8 publicIdString = remainderFromIndex.Left(idLen);

			HBufC16* convertedBuffer = CharsetConvertDataL(publicIdString);

			CleanupStack::PushL(convertedBuffer);

			if( convertedBuffer == NULL )

			{

			// Conversion failed!!!

				CleanupStack::PopAndDestroy(); // convertedBuffer

				return KErrCorrupt;

			}

			iPublicIdStr = HBufC8::NewL(convertedBuffer->Length());

			iPublicIdStr->Des().Copy(*convertedBuffer);

			CleanupStack::PopAndDestroy(); // convertedBuffer

		}

		break;

	case KWbxmlIdWta10:

		// Meaning: "-//WAPFORUM//DTD WTA 1.0//EN" (WTA Event 1.0)

		// WTA is not supported

		User::Leave(EWapErrUnknownDocument);

		break;

	case KWbxmlIdWml11:

		// Meaning: "-//WAPFORUM//DTD WML 1.1//EN" (WML 1.1)

		fileName = FindTokenFileL(KWbTokenDatabaseWml11);

		CleanupStack::PushL(fileName);

		OpenTokenFileL(*fileName);

		CleanupStack::PopAndDestroy(); // fileName

		break;

	case KWbxmlIdWml12:

		// Meaning: "-//WAPFORUM//DTD WML 1.1//EN" (WML 1.2)

		fileName = FindTokenFileL(KWbTokenDatabaseWml12);

		CleanupStack::PushL(fileName);

		OpenTokenFileL(*fileName);

		CleanupStack::PopAndDestroy(); // fileName

		break;

	case KWbxmlIdSI:

		// Meaning: "-//WAPFORUM//DTD SI 1.0//EN" (Push Service Indication 1.0)

		fileName = FindTokenFileL(KWbTokenDatabaseSI10);

		CleanupStack::PushL(fileName);

		OpenTokenFileL(*fileName);

		CleanupStack::PopAndDestroy(); // fileName

		break;

	case KWbxmlIdSL:

		// Meaning: "-//WAPFORUM//DTD SL 1.0//EN" (Push Service Load 1.0)

		fileName = FindTokenFileL(KWbTokenDatabaseSL10);

		CleanupStack::PushL(fileName);

		OpenTokenFileL(*fileName);

		CleanupStack::PopAndDestroy(); // fileName

		break;

	default:

		// Meaning: 0x05 - 0x7F recerved

		// WML spec says that unknown DTD is handled as well as possible

		// so we presume it's supposed to be WML 1.1

		fileName = FindTokenFileL(KWbTokenDatabaseWml11);

		CleanupStack::PushL(fileName);

		OpenTokenFileL(*fileName);

		CleanupStack::PopAndDestroy(); // fileName

		break;

	}

	switch (iPublicId)

		{

	case KWbxmlIdWml11:

		BufferAndOutputL(KWbPublicIdStartWml);

		BufferAndOutputL(*iPublicIdStr); // ...you get HBufC8&

		BufferAndOutputL(KWbPublicIdEnd11);

		break;

	case KWbxmlIdSI:

		BufferAndOutputL(KWbPublicIdStartSi);

		BufferAndOutputL(*iPublicIdStr); // ...you get HBufC8&

		BufferAndOutputL(KWbPublicIdEndSI10);

		break;

	case KWbxmlIdSL:

		BufferAndOutputL(KWbPublicIdStartSl);

		BufferAndOutputL(*iPublicIdStr); // ...you get HBufC8&

		BufferAndOutputL(KWbPublicIdEndSL10);

		break;

	case KWbxmlIdWml12:

	default:

		BufferAndOutputL(KWbPublicIdStartWml);

		BufferAndOutputL(*iPublicIdStr); // ...you get HBufC8&

		BufferAndOutputL(KWbPublicIdEnd12);

		break;

		}

	return KErrNone;

}

void CWbxmlConverter::HandleDataL()

{

	TInt result = KErrNone;

	do

	{

		switch (iState)

		{

		case EConvertVersion:

			result = ConvertWbxmlVersionL();

			SetNextStateL(result,EConvertPublicIdValue);

			break;

		case EConvertPublicIdValue:

			result = ConvertPublicIdValueL();

			SetNextStateL(result,EConvertCharset);

			break;

		case EConvertCharset:

			result = ConvertCharsetL();

			SetNextStateL(result,EConvertStringTable);

			break;

		case EConvertStringTable:

			result = ConvertStringTableL();

			SetNextStateL(result,EConvertPublicIdName);

			break;

		case EConvertPublicIdName:

			result = ConvertPublicIdNameL();

			SetNextStateL(result,EConvertData);

			break;

		case EConvertData:

			result = ConvertDataL();

			SetNextStateL(result,EConvertFinished);

			break;

		case EConvertFinished:

			if(iOutputBuffer!=NULL && iOutputBuffer->Length())

				{

				// Buffer still has some data : Lose ownership to the observer

				TInt returnValue = iObserver->HandleWbxmlOutputL(iOutputBuffer);	

				if( returnValue != KErrNone )

					User::Leave(returnValue);

				iOutputBuffer = NULL;

				}

			return;

		default:

			iState = EConvertError;

			return;

		}

	}

	while (result == KErrNone && iState != EConvertFinished);

}

TInt CWbxmlConverter::ConvertDataL()

{

	// Continue streaming in the middle of string

	if (iContinue != 0)

	{

		switch (iContinue)

		{

		case EGotoStreaming:

			if (ConvertDataStreamingL() != KErrNone)

				return KErrNotFound;

			break;

		case EGotoString:

			if (ConvertDataStringL() != KErrNone)

				return KErrNotFound;

			break;

		case EGotoOpaque:

			if (ConvertOpaqueDataL() != KErrNone)

				return KErrNotFound;

			break;

		}

		iContinue = 0;

	}

	TUint32 multiByte = 0;

	TUint8 byte = 0;

	FOREVER