// Copyright (c) 2000-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 <e32std.h>

#include <msventry.h>

#include <bsp.h>

#include <wapp.h>

#include <wappdef.h>

#include "wapperr.h"

#include <wappstr.rsg>

#include "CWappBookmark.h"

#include "IspTableData.h"

#include "IpBearerData.h"

#include "SmsBearerData.h"

#include "GprsBearerData.h"

#include <mmssettingsproxybase.h>

#include <msvstd.h>

#include <msventry.h>

#include <msvids.h>

#include <msvuids.h>

#include <mtclreg.h>

#include <ipaddr.h>

#include <barsc.h>

#include <barsread.h>

#include <bautils.h>

#include <cbioasyncwaiter.h>

#include <cmsvattachment.h>

#include <mmsvattachmentmanager.h>

#include <mmsvattachmentmanagersync.h>

#ifdef SYMBIAN_BOOKMARK_DATABASE

#include <bookmarkdatabase.h>

#include <bookmark.h>

#endif // SYMBIAN_BOOKMARK_DATABASE

#ifdef _DEBUG

const TUid KUidSmartMessageMtm = {0x10001262};

const TInt32 KUidBIOWAPAccessPointMsg = 0x10005532;

#endif

const TInt KMaxNameBufferLength = 35;

_LIT8(KCRLinefeed,			"\r\n");

_LIT8(KEBookmarkItemBegin,	"BEGIN:eBOOKMARK\r\n");		//  Precedes a Bookmark in the Bookmark file

_LIT8(KEBookmarkItemName,	"NAME:");	// Precedes a Bookmark Name

_LIT8(KEBookmarkItemURL,	"URL:");		// Precedes a Bookmark URL

_LIT8(KEBookmarkType,		"TYPE:Wap\r\n");

_LIT8(KEBookmarkItemEnd,	"END:eBOOKMARK\r\n");

_LIT(KEBookmarkExtension,	".eBM");

_LIT(KWappResourceFile, "\\resource\\messaging\\wappstr.rsc");

const TUint32 KCharsetUCS2 = 1000;

const TUint32 KCharsetUTF8 = 106;

const TUint32 KCharsetASCII = 3;

// The number of characters that are constant for an eBookmark

// file. It is the sum of the above literals.

// 

const TInt KEBookmarkConstantChars = 55;

CMsvBIOWapAccessParser::CMsvBIOWapAccessParser(CRegisteredParserDll& aRegisteredParserDll, CMsvEntry& aEntry, RFs& aFs)

: CBaseScriptParser2(aRegisteredParserDll, aEntry, aFs)

   {

   }

EXPORT_C CMsvBIOWapAccessParser* CMsvBIOWapAccessParser::NewL(CRegisteredParserDll& aRegisteredParserDll, CMsvEntry& aEntry, RFs& aFs)

    {

    CMsvBIOWapAccessParser* self = new (ELeave) CMsvBIOWapAccessParser(aRegisteredParserDll, aEntry, aFs);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CMsvBIOWapAccessParser::~CMsvBIOWapAccessParser()

    {

	Cancel();

	// Char Conversion

	delete iCharsetConverter;

    delete iSettings;

	delete iSmsBuf;

	delete iStringTable;

	if (iBookmarkList!=NULL)

		{

		iBookmarkList->ResetAndDestroy();

		delete iBookmarkList;

		}

	delete iModemInitString;

    if (iParsedFieldArray != NULL)

        {

        iParsedFieldArray->ResetAndDestroy();

        delete iParsedFieldArray;

        }

	delete iWapIpISPTable;

	delete iWapSmsTable;

	delete iWapGprsTable;

	delete iGsmCsdWapIpTable;

	delete iGprsWapIpTable;

	delete iDBSession;

	REComSession::FinalClose();

    }

//

//	ConstructL			- ConstructL fn - creates the Parsed Field array, 

//						  and connects the file system if unconnected

//	

void CMsvBIOWapAccessParser::ConstructL()

    {

	iParsedFieldArray = new(ELeave) CArrayPtrSeg<CParsedField>(16);	

	iDBSession = CMDBSession::NewL(CMDBSession::LatestVersion());

	iBookmarkList = new(ELeave) CArrayPtrSeg<CWappBookmark> (4);// 4 should be enough

	iGsmCsdData = EFalse;

	iGsmSmsData = EFalse;

	iGprsData	= EFalse;

	iURLData	= EFalse;

	iNameData	= EFalse;

	iIdData		= EFalse;

	iMMSURLData = EFalse;

    CActiveScheduler::Add(this);

    }

//

//	ParseL		- public method forming part of the API.  Calls ChangeState to set 

//				  state for parsing. Helper functions do the parsing

//

void CMsvBIOWapAccessParser::ParseL(TRequestStatus& aStatus, const TDesC& aSms)

    {

    TMsvEntry entry = iEntry.Entry();   //  Get the generic stuff

    iEntryId = entry.Id();              //  store the TMsvId

	// Message must be unparsed, or parsed or committed - anything else is a big error

    __ASSERT_DEBUG((   entry.MtmData3() == BIO_MSG_ENTRY_UNPARSED

					|| entry.MtmData3() == BIO_MSG_ENTRY_PARSED

					|| entry.MtmData3() == BIO_MSG_ENTRY_PROCESSED),

                            Panic(EWappErrMessageProcessed));

	// Message must not be empty 

	__ASSERT_DEBUG (aSms.Length() > 0 ,Panic( EWappEmptyBuffer));

   //  Already parsed....just return

    if(entry.MtmData3() == BIO_MSG_ENTRY_PARSED || entry.MtmData3() == BIO_MSG_ENTRY_PROCESSED)

        {

        iReport = &aStatus;

        User::RequestComplete(iReport, KErrNone);

        }

    //  not parsed so start the Parsing operation

    else if(entry.MtmData3() == BIO_MSG_ENTRY_UNPARSED)

        {

        delete iSmsBuf;

        iSettings = NULL;

        iSmsBuf = aSms.AllocL();

        ChangeStateL(EStart);		// Do do initial processing, and go Active

        aStatus = KRequestPending;

        iReport = &aStatus;

        }

    else

        {

        User::Leave(KErrNotSupported);

        }

    }

//

//  ProcessL() --   If  parsed data is not already in memory, ProcessL loads it from the store

//					created during parsing. Creates a new entry in the WAP settings CommDb tables, from the data

//

void CMsvBIOWapAccessParser::ProcessL(TRequestStatus& aStatus)

    {

	// Calls ChangeState to get State Engine going. ( DoProcess does the hard work)

	iEntryId= iEntry.Entry().Id(); //store id of Bio Msg entry 

	// Must be a smart/Bio message, of type WAP access point and not have the failure flag set

	__ASSERT_DEBUG(iEntry.Entry().iMtm==KUidSmartMessageMtm, Panic(EWappInvalidEntry));

	__ASSERT_DEBUG(iEntry.Entry().iBioType ==KUidBIOWAPAccessPointMsg, Panic(EWappInvalidEntry));

	__ASSERT_DEBUG(iEntry.Entry().Failed()== 0 , Panic(EWappInvalidEntry));

	ResetProcessVariablesL();       // Reset variables to initial state

	ChangeStateL(EProcessInitialise);   //Set the initial state

	aStatus = KRequestPending;

	iReport = &aStatus; 	

   	}

//	 DoCancel	-  Cancels the Active Object operation and returns control to the caller

//

void CMsvBIOWapAccessParser::DoCancel()

    {

	User::RequestComplete(iReport,KErrCancel);

    }

//

//	RunL()		-		Called by the Active Scheduler when it finishes its Wait Loop. 

//						Doesn't do much as ParseL and Process keep going until they are complete.

//						Returns the current status. 

//

void CMsvBIOWapAccessParser::RunL()

    {

    iCompleted = iStatus.Int();

	if (iCompleted != KErrNone)

		{

		User::RequestComplete(iReport,iCompleted);

		return;

		}

	TInt currentState = iState;

	TRAPD(error, CallChangeStateL(currentState));

	switch (currentState)

		{

		case EStart:

		case EProcessInitialise:

		case EProcessMessage:

			if (error!=KErrNone)

				User::RequestComplete(iReport, error);  // Return error code

			break;

		case EParseMessage:

		case ECompleteMessage:

			User::RequestComplete(iReport, iCompleted); // Nothing more - allow calling RunL to complete and return status

			break;

		default:

			break;

		}

    }

void CMsvBIOWapAccessParser::CallChangeStateL(TInt aState)

	{

	switch (aState)

		{

		case EStart:

			ChangeStateL(EParseMessage);

			break;

		case EProcessInitialise:

			ChangeStateL(EProcessMessage);

			break;

		case EProcessMessage:

			ChangeStateL(ECompleteMessage);  // last stage change iMtmData3 

			break;

		default:

			break;

		}

	}

//

//	ChangeStateL		-	Used to advance the state to the next level.

//							Makes most of the important calls.

//

void CMsvBIOWapAccessParser::ChangeStateL(TParseSession aState)

    {

	iState = aState;

    switch (iState)

        {                    

		case EStart:	// Check the data we've got - if OK get the Active Stuff going

			if (!iSmsBuf)			

				User::Leave(KWappErrNullValue);

			else if (iSmsBuf->Length() == 0)

				User::Leave(KWappErrContent);

			break;

        case EParseMessage:

			iSms = iSmsBuf->Des();      // initialise TLex object

			ParseMessageL();

            break;

		case EProcessInitialise:

			if (!iSmsParsed)

				RestoreParsedDataL();

			PreProcessL();  //Scan iParsedFieldArray extracting data - leaves if data is invalid

			ValidateCharacteristicsL(); // Ensures that the mix of characteristic is valid

			break;

		case EProcessMessage:

			DoProcessL(); // Do the proper processing of and committing to CommDb

			break;

		case ECompleteMessage:

			CompleteMessageL();

			break;

        default:

            break;

        }

	// Finished this step -add ourselves to Scheduler,& return error code to calling thread.

	RequestComplete(iStatus, KErrNone); 

	SetActive();

    }

//

//	ParseMessageL()		- Performs various checks, if data has been saved it restores it  

//						  else it calls DoParseL which does the hard stuff).

//

void CMsvBIOWapAccessParser::ParseMessageL()

	{

	// MUST have Bio message, of type WAP access point and no failure flag set

	__ASSERT_DEBUG(iEntry.Entry().iMtm==KUidSmartMessageMtm, Panic(EWappInvalidEntry));

	__ASSERT_DEBUG(iEntry.Entry().iBioType ==KUidBIOWAPAccessPointMsg, Panic(EWappInvalidEntry));

	__ASSERT_DEBUG(iEntry.Entry().Failed()== 0 , Panic(EWappInvalidEntry));

	// Message already parsed(includes processed).  Just restore data and return

	if (iEntry.Entry().MtmData3() == BIO_MSG_ENTRY_PARSED || 

		iEntry.Entry().MtmData3() == BIO_MSG_ENTRY_PROCESSED)

		iSmsParsed = ETrue;   // Have a store produced during parsing. 

	else 

		iSmsParsed = EFalse;

	if(iSmsParsed)  // parsed before - restore data

		{

		RestoreParsedDataL();

		return;

		}

	DoParseL();			// Does the actual parsing of the message contents

	SettingsNamePresentL(); // Check for Name Characteristic- if not found appends a default one

	StoreParsedDataL(); // Saves the parsed fields to store & sets TMSvEntry values

	iSmsParsed=ETrue;

	}

//

//  CompleteMessageL()	-	Completes the ProcessL operation, by setting the iMtmData3 

//							flag to BIO_MSG_ENTRY_PROCESSEDMessage body, and TMsvEntry's

//							iDescription and iDetails are left unchanged

//

void CMsvBIOWapAccessParser::CompleteMessageL()

    {

	TMsvEntry entry= iEntry.Entry();

	entry.SetMtmData3(BIO_MSG_ENTRY_PROCESSED);

	iEntry.ChangeL(entry);

    }

//

//	RequestComplete()	-	Completes an AO operation, and passes control back to the caller

//

void CMsvBIOWapAccessParser::RequestComplete(TRequestStatus& aStatus, TInt aError)

    {

    TRequestStatus* p = &aStatus;

    User::RequestComplete(p, aError);

    }

//

//  DoParseL()		- Parses through encoded message body extracting the fields from the characteristics

//					Uses helper functions to handle reading and storing of characteristics and parms. 

//					Parsing performed in one continuous operation.

//

void CMsvBIOWapAccessParser::DoParseL()

    {

	const TInt KDecimalSizeOfMaxInt = 10; // length of 0xFFFFFFFF in a string in decimal

	TBuf<KDecimalSizeOfMaxInt> localBuf;

	TChar thisCharacter;

	thisCharacter = GetNextMessageByteL();	// Read the first char to get XML version number

	/*

	The version byte contains the the major version minus one in the upper four bits 

	of the 8 bit integer, and the minor version in the lower four bits.

	*/

	TUint wbxmlversionbyte = thisCharacter; 

	TUint majorversion = ((wbxmlversionbyte & 0xF0) + 0x10) - 0x0F; // gives the major version, eg if wbxml spec version 1.2, it gives 1.

	TUint minorversion = wbxmlversionbyte & 0x0F; //gives the minor version, eg if wbxml spec version 1.2, it gives 2.

	iWBXMLversionX10 = (majorversion *10) + minorversion; //i.e. If actual version is 1.1 this is *10 to remove the decimal place.

	//Append this to the array

	localBuf.NumUC(iWBXMLversionX10,EDecimal);  //Format to a decimal string

	AppendDataPairL(KWappXMLversion, localBuf); // Append to array of parsed fields

	// Now need to get the 32bit int encoded over a number of bytes

	iPublicID = Read_mb_u_int32L();		// Read in a multi byte 32bit int value

	localBuf.NumUC(iPublicID, EHex);	// Format to a string as hex 

	AppendDataPairL(KWappPublicID, localBuf); 

	// WAP Binary XML version 1.1 also has additional info for the character set.

	if (iWBXMLversionX10 !=10)				// If WAP Binary XML version > 1.0

		iCharacterSet = Read_mb_u_int32L(); // Get the character set

	else

		//This is the character set MIBenum for UTF-8. 

		//According to WBXML spec version 1.1 and 1.2, this is the default which should 

		//be assumed if the charset value is not available. Value 0 must not be used. 

		iCharacterSet = 106; 

	delete iCharsetConverter;

	iCharsetConverter = NULL;

	iCharsetConverter = CWapCharsetConverter::NewL(iFs, iCharacterSet);

	localBuf.NumUC(iCharacterSet, EHex);	// Convert to string as hex 

	AppendDataPairL(KWappCharacterSet,localBuf);

	// Coded string table length - don't need this once we have string table

	// as we store copies of the strings within parsed data fields 

	TUint32 stringTableLength = Read_mb_u_int32L();

	//Read in string table if it exists, i.e. length >0 otherwise skip this step

	if (stringTableLength>0) 

		{

		iStringTable = HBufC::NewL(stringTableLength);

		iSms.Mark();					// Mark the current position

		TUint32 remaining = iSms.RemainderFromMark().Length(); //Eliminates warning about comparison in next line

		if ( remaining > stringTableLength) // Sting Table doesn't exceed end of message

			iSms.Inc(stringTableLength);	// so increment to the character following the string table

		else

			User::Leave(KWappErrEOS); // Table exceeds message length - unrecoverable error

		iStringTable->Des().Copy(iSms.MarkedToken());

		}

	thisCharacter = GetNextMessageByteL();

	//This should be a Characteristic List with content, but no attributes

	if (thisCharacter == (KWAPP_CHAR_LIST+KWAPP_TAG_CONTENT))

		{

		// Main loop - keep moving through the message, until we reach the end or error

		TBool finished = EFalse;

		while (!finished)

			{		

			// Read in characteristics, any order is accepted

			if (!iSms.Eos() && (iSms.Peek() & 0x3F) == KWAPP_CHARACTERISTIC)

				{

				// Read in characteristic, inc. its terminator tag - no terminator =error!

				ReadCharacteristicL();

				}

			else

				{

				if (iSms.Eos()) // Error end of message

					User::Leave(KWappErrEOS);

				else if ((TUint)iSms.Peek()==KWAPP_END_TAG) // END Tag - OK we've finished!

					finished = ETrue;

				else if ( (iSms.Peek()& 0x3F != KWAPP_CHARACTERISTIC) || (iSms.Peek() != KWAPP_END_TAG) )

					User::Leave(KWappErrUnexpectedValue); //Not a Characteristic or END token

				}

			}

		} // End of if (thisCharacter == (KWAPP_CHAR_LIST..... )

	else

		User::Leave(KWappErrMandatoryTagMissing);

    }

// end CMsvBIOWapAccessParser::DoParseL()

//	

//	ReadCharacteristicL()		-  Reads in a characteristic from the message.

//

void  CMsvBIOWapAccessParser::ReadCharacteristicL()

	{

	TBool hasContent;

	TInt  characteristicIndex=0; // start position in array for this characteristic

	CParsedField* parsedField = new(ELeave)CParsedField();

	CleanupStack::PushL(parsedField);		

	TChar currentCharacter = GetNextMessageByteL();

	iCurrentCharacteristic =EWappUnknown; // Reset flag for current characteristic's type

	// Use bit comparison of token with mask 0x3F to check explicitly that correct 

	// bits are set i.e. that bits 0-5 = 0x06   (NB Actual value = 0x86 or =0xC6)

	if ( ( currentCharacter & 0x3F) != KWAPP_CHARACTERISTIC ) // i.e. not or 0x06

		User::Leave(KWappErrUnexpectedValue);		

	else

		{

		if ( !(currentCharacter & KWAPP_TAG_ATTRIBUTES)) // Bit 7 must be set!

			User::Leave(KWappErrNoAttributes); 

		if (currentCharacter & KWAPP_TAG_CONTENT)  //Bit 6 is set - characteristic has content

			hasContent =ETrue;

		else

			hasContent =EFalse;

	// ***************			IMPORTANT NOTE		   ************************

	// An XML element name without a defined token is sent as an inline string or

	// string table ref. prefixed by the TYPE token 0x05 (ie "TYPE="). (True for

	// WirelessFuture web site!!) THE ONLY UNDEFINED Type tag is BOOKMARK in version

	// 1.0. Therefore if it's 0x05  - check the version. For 1.0 read next char.

	// Token must be an inline string or string table ref.Otherwise we have an error.

	// ****************************************************************************

		// Read the next byte - info on the type of our characteristic  

		currentCharacter = (TUint) GetNextMessageByteL();

		// Check if the tokens 0x05 "TYPE=" - should be for WBXML version = 1.0 

		// Read next character

		if (currentCharacter == KWAPP_TYPE)

			{

			// "TYPE=" should be followed by an inline string, or string table reference

			// So read another char & increment a place - should now 0x03 or 0x83

			currentCharacter = (TUint) GetNextMessageByteL();

			if  (	!(currentCharacter & KWAPP_STR_I) &&	// Is current character != 0x03 ?

					!(currentCharacter & KWAPP_STR_T))		// or != 0x83 

				 User::Leave(KWappErrUnexpectedValue);		// Doc is badly formed doc - leave

			}

	// NB for address characteristics, need to store position of the start, so that

	// we can search for certain fields. If they're not present we must add defaults.  

	// Could just scan from the end of the array, but if we miss our target then may

	// just increment past this characteristic, through previous ones.

		switch (currentCharacter)

			{

			case KWAPP_ADDR_TYPE:  // Token = 0x06

				{

				AppendNameFieldL(KWappCharAddress);		

				characteristicIndex = iParsedFieldArray->Count()-1; // Store index for this element

				iCurrentCharacteristic = EWappAddressCharacteristic; //General code for an address

				break;

				}

			case KWAPP_URL_TYPE:   //Token = 0x07

				{

				AppendNameFieldL(KWappCharURL);

				iCurrentCharacteristic  = EWappURLCharacteristic; // it's a URL characteristic

				break;

				}

			case KWAPP_NAME_TYPE:  // Token = 0x08

				{

				AppendNameFieldL(KWappCharName); 

				iCurrentCharacteristic = EWappNameCharacteristic;//it's a NAME characteristic

				break;

				}

			case KWAPP_STR_I:		// Token = 0x03  , Global WAP XML value

				{