// 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 "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:

//

/**

 @file

 @internalTechnology

*/

#include "ULP.h"

#include "suplmessagebase.h"

#include "suplpos.h"

#include "supldevloggermacros.h" 

#include "suplrrlpasn1common.h"

#include <lbssatellite.h>

#include <lbs/lbsgpsmeasurement.h>

#include <lbs/lbsnetcommon.h>

#include <lbspositioninfo.h>

#include <lbsposition.h>

#include <reent.h>

/** 

Default constructor

*/

CSuplMessageBase::CSuplMessageBase(TSuplMessageType aType, TBool aIsOutgoingMessage)

 : iSuplMessageType(aType), iIsOutgoingMessage(aIsOutgoingMessage)

	{

	}

/** 

Destructor

*/

CSuplMessageBase::~CSuplMessageBase()

	{

	SUPLLOG(ELogP1, "CSuplMessageBase::~CSuplMessageBase() Begin\n");

	delete iControl;

	delete iData;

	delete iEncodeBuffer;

	// release the STDLIB resources associated with this thread

	CloseSTDLIB();

	SUPLLOG(ELogP1, "CSuplMessageBase::~CSuplMessageBase() End\n");

	}

/** 

Second stage constructor 

Outgoing messages: constructs the data encapsulation and control objects.

Incoming message: no action

*/

void CSuplMessageBase::ConstructL()

	{

	if (iIsOutgoingMessage)

		{

		iData    = new (ELeave) ASN1T_ULP_PDU();

		ASN1Context* context = new (ELeave) ASN1Context;

		CleanupDeletePushL(context);

		iControl = new (ELeave) ASN1C_ULP_PDU(*context, *iData);

		// construction of iControl successful, pop context off the cleanup stack

		CleanupStack::Pop(context);

		// set the version parameter of the outgoing message

		iData->version.maj = 1;

		iData->version.min = 0;

		iData->version.servind = 0;

		}

	}

/** 

EncodeToL()

Encode a populated outgoing message to the specified buffer.

@param  aBuf buffer pointer 

@return error indication, KErrNone otherwise

*/

EXPORT_C TInt CSuplMessageBase::EncodeToL(TPtr8& aBuf)

	{

	SUPLLOG(ELogP1, "CSuplMessageBase::EncodeToL() Begin\n");

	__ASSERT_DEBUG(iIsOutgoingMessage, User::Invariant());

	TInt retval = KErrNone;

	// buffer pointer, fixed max length

	TUint8* msgBuf = (TUint8*)aBuf.Ptr();

	TInt maxLength = aBuf.MaxLength();

	// Log the un-encoded SUPL values

	SUPLLOG(ELogP9, "-> ENCODING SUPL MESSAGE FOR SENDING\n");

	//LogMessageContent();

	// if the message is a SUPL POS, encode the payload

	if (iData->message.t == T_UlpMessage_msSUPLPOS)

		{

		CSuplPos* suplPos = reinterpret_cast <CSuplPos*>(this);

		retval = suplPos->EncodePosPayloadL();

		if (retval != KErrNone)

			{

			SUPLLOG(ELogP1, "CSuplMessageBase::EncodeToL() Error encoding Positioning Payload\n");

			return retval;

			}

		}

	// construct the encode buffer control object

	iEncodeBuffer = new (ELeave) ASN1PEREncodeBuffer (msgBuf, (unsigned int)maxLength, FALSE, (OSRTContext*)iControl->getContext());

	// Encode the message to the buffer

	TInt stat = iControl->EncodeTo(*iEncodeBuffer);

	if (stat == 0)

		{

		// Set the length according to reported buffer length

		TInt len = iEncodeBuffer->getMsgLen ();

		iData->length = len;

		aBuf.SetLength(len);

		// clear the encoded length field

		msgBuf[0] = 0;

		msgBuf[1] = 0;

		// set the encoded length field

      	msgBuf[0] |= (TUint8)( len >> 8 );

		msgBuf[1] |= (TUint8)( len );

		}

	else

		{

		retval = ProcessAsn1Error(stat);

		}

	// finished with encode buffer object

	delete iEncodeBuffer;

	iEncodeBuffer = NULL;

	// Log the encoded ASN1	

	SUPLLOG(ELogP8, "-> ENCODED SUPL MESSAGE FOR SENDING (HEX)\n");

	SUPLLOGHEX(ELogP8, aBuf.Ptr(), aBuf.Length());

	SUPLLOG2(ELogP1, "CSuplMessageBase::EncodeToL() End (retval = %d)\n", retval);

	return retval;

	}

/** 

SetDecodedData()

Assign decoded ASN1 data, for received messages.

Takes ownership of passed objects.

@param aData    data structure containing decoded message parameters

@param aControl control structure associated with decoded data structure.

*/

void CSuplMessageBase::SetDecodedData(ASN1T_ULP_PDU* aData, ASN1C_ULP_PDU* aControl)

	{

	SUPLLOG(ELogP1, "CSuplMessageBase::SetDecodedData() Begin\n");

	__ASSERT_DEBUG(!iIsOutgoingMessage, User::Invariant());

	iData = aData;

	iControl = aControl;

	SUPLLOG(ELogP1, "CSuplMessageBase::SetDecodedData() End\n");

	}

/** 

SetVersion()

Set the SUPL version used 

@param aVersion SUPL version in use

*/

EXPORT_C void CSuplMessageBase::SetVersion(CSuplVersion& aVersion)

	{

	SUPLLOG(ELogP1, "CSuplMessageBase::SetVersion() Begin\n");

	__ASSERT_DEBUG(iIsOutgoingMessage, User::Invariant());

	SUPLLOG2(ELogP1, "    - TInt iMaj = %d\n", aVersion.iMaj);

	SUPLLOG2(ELogP1, "    - TInt iMin = %d\n", aVersion.iMin);

	SUPLLOG2(ELogP1, "    - TInt iServind = %d\n", aVersion.iServind);

	iData->version.maj = aVersion.iMaj;

	iData->version.min = aVersion.iMin;

	iData->version.servind =  aVersion.iServind;

	SUPLLOG(ELogP1, "CSuplMessageBase::SetVersion() End\n");

	}

/** 

SetSessionId()

Set the SUPL Session ID

@param aSessionId session identifier

*/

EXPORT_C TInt CSuplMessageBase::SetSessionId(CSuplSessionId& aSessionId)

	{

	SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() Begin\n");

	__ASSERT_DEBUG(iIsOutgoingMessage, User::Invariant());

	// local reference to context object

	OSCTXT* pctxt = iControl->getCtxtPtr();

	// populate SET Session ID, if present

	// note this should always be present as this method is for building 

	// outgoing messages.

	if (aSessionId.iSetSessionIdPresent)

		{

		iData->sessionID.m.setSessionIDPresent = 1;

		// SET Session ID / Session ID

		iData->sessionID.setSessionID.sessionId = aSessionId.iSetSessionId->iSessionId;

		// SET Session ID / SET ID

		ASN1T_SETId& setId = iData->sessionID.setSessionID.setId;

		switch (aSessionId.iSetSessionId->iSetId->iSetIdType)

			{	

		  	case ESuplSetIdTypeIPAddress:

		  		{

		  		// ID is based on IP Address

	  			setId.t =  T_SETId_iPAddress;

				setId.u.iPAddress = (ASN1T_IPAddress*)rtxMemAllocZ(pctxt, sizeof(ASN1T_IPAddress));

				if (iControl->getStatus() != 0)

					{

					SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() Error, out of memory\n");

					return KErrNoMemory;

					}				

				if (aSessionId.iSetSessionId->iSetId->iIpAddress->iIpAddressType == ESuplIpAddressTypeV6)

					{

					setId.u.iPAddress->t =  T_IPAddress_ipv6Address;

					setId.u.iPAddress->u.ipv6Address = (ASN1T_IPAddress_ipv6Address*)rtxMemAllocZ(pctxt, sizeof(ASN1T_IPAddress_ipv6Address));

					if (iControl->getStatus() != 0)

						{

						SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() Error, out of memory\n");

						return KErrNoMemory;

						}					

					TInt len = aSessionId.iSetSessionId->iSetId->iIpAddress->iIpAddress.Length();

					void* data = (void*)aSessionId.iSetSessionId->iSetId->iIpAddress->iIpAddress.Ptr();

					memcpy ((void*)setId.u.iPAddress->u.ipv6Address->data, data, len);

					setId.u.iPAddress->u.ipv6Address->numocts = len;

					}

				else

					{

					setId.u.iPAddress->t =  T_IPAddress_ipv4Address;

					setId.u.iPAddress->u.ipv4Address = (ASN1T_IPAddress_ipv4Address*)rtxMemAllocZ(pctxt, sizeof(ASN1T_IPAddress_ipv4Address));

					if (iControl->getStatus() != 0)

						{

						SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() Error, out of memory\n");

						return KErrNoMemory;

						}					

					TInt len = aSessionId.iSetSessionId->iSetId->iIpAddress->iIpAddress.Length();

					void* data = (void*)aSessionId.iSetSessionId->iSetId->iIpAddress->iIpAddress.Ptr();

					memcpy ((void*)setId.u.iPAddress->u.ipv4Address->data, data, len);

					setId.u.iPAddress->u.ipv4Address->numocts = len;

					}

				break;

		  		}

			case ESuplSetIdTypeMsisdn:

				{

				setId.t = T_SETId_msisdn;

				setId.u.msisdn = (ASN1T_SETId_msisdn*)rtxMemAllocZ(pctxt, sizeof(ASN1T_SETId_msisdn));

				if (iControl->getStatus() != 0)

					{

					SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() Error, out of memory\n");

					return KErrNoMemory;

					}				

				TInt len = aSessionId.iSetSessionId->iSetId->iSetId.Length();

				void* data = (void*)aSessionId.iSetSessionId->iSetId->iSetId.Ptr();

				memcpy ((void*)setId.u.msisdn->data, data, len);

				setId.u.msisdn->numocts = len;

				break;

				}

		  	case ESuplSetIdTypeMdn:

		  		{

				setId.t = T_SETId_mdn;

				setId.u.mdn = (ASN1T_SETId_mdn*)rtxMemAllocZ(pctxt, sizeof(ASN1T_SETId_mdn));

				if (iControl->getStatus() != 0)

					{

					SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() Error, out of memory\n");

					return KErrNoMemory;

					}				

				TInt len = aSessionId.iSetSessionId->iSetId->iSetId.Length();

				void* data = (void*)aSessionId.iSetSessionId->iSetId->iSetId.Ptr();

				memcpy ((void*)setId.u.mdn->data, data, len);

				setId.u.mdn->numocts = len;

				break;

				}

		  	case ESuplSetIdTypeMin:

		  		{

				setId.t = T_SETId_min;

				setId.u.min = (ASN1T_SETId_min*)rtxMemAllocZ(pctxt, sizeof(ASN1T_SETId_min));

				if (iControl->getStatus() != 0)

					{

					SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() Error, out of memory\n");

					return KErrNoMemory;

					}				

				TInt len = aSessionId.iSetSessionId->iSetId->iSetId.Length();

				void* data = (void*)aSessionId.iSetSessionId->iSetId->iSetId.Ptr();

				memcpy ((void*)setId.u.min->data, data, len);

				setId.u.min->numbits = len*8;

				break;

				}

		  	case ESuplSetIdTypeImsi:

		  		{

				setId.t = T_SETId_imsi;

				setId.u.imsi = (ASN1T_SETId_imsi*)rtxMemAllocZ(pctxt, sizeof(ASN1T_SETId_imsi));

				if (iControl->getStatus() != 0)

					{

					SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() Error, out of memory\n");

					return KErrNoMemory;

					}				

				TInt len = aSessionId.iSetSessionId->iSetId->iSetId.Length();

				void* data = (void*)aSessionId.iSetSessionId->iSetId->iSetId.Ptr();

				memcpy ((void*)setId.u.imsi->data, data, len);

				setId.u.imsi->numocts = len;

				break;

				}

		  	case ESuplSetIdTypeNai:

		  	default:

		  		{

		  		__ASSERT_DEBUG(0, User::Invariant());

		  		return KErrNotSupported;

		  		}

			}

		}

	// populate SLP Session ID, if present

	// note this may not be present if building an outgoing SUPL START message,

	// as it is specified by the first incoming message from the SLP.

	if (aSessionId.iSlpSessionIdPresent)

		{

		iData->sessionID.m.slpSessionIDPresent = 1;

		// SLP Session ID / Session ID

		TInt len = aSessionId.iSlpSessionId->iSessionId.Length();

		void* data = (void*)aSessionId.iSlpSessionId->iSessionId.Ptr();

		memcpy ((void*)iData->sessionID.slpSessionID.sessionID.data, data, len);

		iData->sessionID.slpSessionID.sessionID.numocts = len;

		// SLP Session ID / SLP ID

		if (aSessionId.iSlpSessionId->iSlpAddress->iSlpAddressType == ESuplSlpAddressTypeFqdn)

			{

			iData->sessionID.slpSessionID.slpId.t = T_SLPAddress_fQDN;

			TInt len = aSessionId.iSlpSessionId->iSlpAddress->iFqdn->iFqdn.Length();

			// allocate memory for the FQDN string			

			char* tmpstr = (char*) rtxMemAlloc (pctxt, len+1);

			if (tmpstr == NULL)

				{

				SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() Error, out of memory\n");

				return KErrNoMemory;

				}

			void* source = (void*)aSessionId.iSlpSessionId->iSlpAddress->iFqdn->iFqdn.Ptr();

			memcpy ((void*)tmpstr, source, len);

			tmpstr[len] = '\0';  // add null-terminator

			iData->sessionID.slpSessionID.slpId.u.fQDN = tmpstr;

			}

		else

			{

			// SLP ID is an IP address

			iData->sessionID.slpSessionID.slpId.t = T_SLPAddress_iPAddress;

			iData->sessionID.slpSessionID.slpId.u.iPAddress = (ASN1T_IPAddress*)rtxMemAllocZ(pctxt, sizeof(ASN1T_IPAddress));

			if (iControl->getStatus() != 0)

				{

				SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() Error, out of memory\n");

				return KErrNoMemory;

				}

			if (aSessionId.iSlpSessionId->iSlpAddress->iIpAddress->iIpAddressType == ESuplIpAddressTypeV6)

				{ // IPv6

				iData->sessionID.slpSessionID.slpId.u.iPAddress->t =  T_IPAddress_ipv6Address;

				iData->sessionID.slpSessionID.slpId.u.iPAddress->u.ipv6Address = (ASN1T_IPAddress_ipv6Address*)rtxMemAllocZ(pctxt, sizeof(ASN1T_IPAddress_ipv6Address));

				if (iControl->getStatus() != 0)

					{

					SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() Error, out of memory\n");

					return KErrNoMemory;

					}

				TInt len = aSessionId.iSlpSessionId->iSlpAddress->iIpAddress->iIpAddress.Length();

				void* data = (void*)aSessionId.iSlpSessionId->iSlpAddress->iIpAddress->iIpAddress.Ptr();

				memcpy ((void*)iData->sessionID.slpSessionID.slpId.u.iPAddress->u.ipv6Address->data, data, len);

				iData->sessionID.slpSessionID.slpId.u.iPAddress->u.ipv6Address->numocts = len;

				}

			else

				{ // IPv4

				iData->sessionID.slpSessionID.slpId.u.iPAddress->t =  T_IPAddress_ipv4Address;

				iData->sessionID.slpSessionID.slpId.u.iPAddress->u.ipv4Address = (ASN1T_IPAddress_ipv4Address*)rtxMemAllocZ(pctxt, sizeof(ASN1T_IPAddress_ipv4Address));

				if (iControl->getStatus() != 0)

					{

					SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() Error, out of memory\n");

					return KErrNoMemory;

					}				

				TInt len = aSessionId.iSlpSessionId->iSlpAddress->iIpAddress->iIpAddress.Length();

				void* data = (void*)aSessionId.iSlpSessionId->iSlpAddress->iIpAddress->iIpAddress.Ptr();

				memcpy ((void*)iData->sessionID.slpSessionID.slpId.u.iPAddress->u.ipv4Address->data, data, len);

				iData->sessionID.slpSessionID.slpId.u.iPAddress->u.ipv4Address->numocts = len;

				}

			}

		}

	SUPLLOG(ELogP1, "CSuplMessageBase::SetSessionId() End\n");

	return KErrNone;

	}

/** 

MessageType()

Returns the message type 

@return message type (set at construction)

*/

EXPORT_C CSuplMessageBase::TSuplMessageType CSuplMessageBase::MessageType()

	{

	SUPLLOG(ELogP1, "CSuplMessageBase::MessageType() Begin\n");

	SUPLLOG2(ELogP1, "CSuplMessageBase::MessageType() End (message type = %d)\n", iSuplMessageType);

	return iSuplMessageType;

	}

/** 

GetVersion()

Populates aVersion with the SUPL version

@param aVersion on return, populated with version of received SUPL message

*/

EXPORT_C TInt CSuplMessageBase::GetVersion(CSuplVersion& aVersion)

	{

	SUPLLOG(ELogP1, "CSuplMessageBase::Version() Begin\n");

	__ASSERT_DEBUG(!iIsOutgoingMessage, User::Invariant());

	aVersion.iMaj = iData->version.maj;

	aVersion.iMin = iData->version.min;

	aVersion.iServind = iData->version.servind;

	SUPLLOG(ELogP1, "CSuplMessageBase::Version() End\n");

	return KErrNone;

	}

/** 

GetSessionId()

Populates aSessionId with the SUPL Session ID

@param aSessionId on return, populated with session ID of received SUPL message

*/

EXPORT_C TInt CSuplMessageBase::GetSessionId(CSuplSessionId& aSessionId)

	{

	SUPLLOG(ELogP1, "CSuplMessageBase::SessionId() Begin\n");

	__ASSERT_DEBUG(!iIsOutgoingMessage, User::Invariant());

	// populate SET Session ID, if present

	// note in the case of a received SUPL INIT message, the 

	// SET Session ID is not present.

	if (iData->sessionID.m.setSessionIDPresent != 0)

		{

		aSessionId.iSetSessionIdPresent = ETrue;

		aSessionId.iSetSessionId->iSessionId = iData->sessionID.setSessionID.sessionId;

		ASN1T_SETId& setId = iData->sessionID.setSessionID.setId;

		switch (setId.t)

			{

			case T_SETId_iPAddress:

				{

				aSessionId.iSetSessionId->iSetId->iSetIdType = ESuplSetIdTypeIPAddress;

				// Pointer to the address data buffer

				TBuf8<16>& ipAddress = aSessionId.iSetSessionId->iSetId->iIpAddress->iIpAddress;

				// IPv4 or IPv6 address?

				if (setId.u.iPAddress->t == T_IPAddress_ipv6Address)

					{

					aSessionId.iSetSessionId->iSetId->iIpAddress->iIpAddressType = ESuplIpAddressTypeV6;

					TInt len = setId.u.iPAddress->u.ipv6Address->numocts;

					TUint8* data = setId.u.iPAddress->u.ipv6Address->data;

					ipAddress.Copy(data, len);

					}

				else

					{

					aSessionId.iSetSessionId->iSetId->iIpAddress->iIpAddressType = ESuplIpAddressTypeV4;

					TInt len = setId.u.iPAddress->u.ipv4Address->numocts;

					TUint8* data = setId.u.iPAddress->u.ipv4Address->data;

					ipAddress.Copy(data, len);

					}

				break;

				}

			case T_SETId_msisdn:

				{

				aSessionId.iSetSessionId->iSetId->iSetIdType = ESuplSetIdTypeMsisdn;

				TBuf8<16>& targetSetId = aSessionId.iSetSessionId->iSetId->iSetId;

				TInt len = setId.u.msisdn->numocts;

				TUint8* data = setId.u.msisdn->data;

				targetSetId.Copy(data, len);

				break;

				}

			case T_SETId_mdn:

				{

				aSessionId.iSetSessionId->iSetId->iSetIdType = ESuplSetIdTypeMdn;

				TBuf8<16>& targetSetId = aSessionId.iSetSessionId->iSetId->iSetId;

				TInt len = setId.u.mdn->numocts;

				TUint8* data = setId.u.mdn->data;

				targetSetId.Copy(data, len);

				break;

				}

			case T_SETId_min:

				{

				aSessionId.iSetSessionId->iSetId->iSetIdType = ESuplSetIdTypeMin;

				TBuf8<16>& targetSetId = aSessionId.iSetSessionId->iSetId->iSetId;

				TInt len = 5; // min is limited to 5 bytes (34 bits). Copy it all.

				TUint8* data = setId.u.min->data;

				targetSetId.Copy(data, len);

				break;

				}

			case T_SETId_imsi:

				{

				aSessionId.iSetSessionId->iSetId->iSetIdType = ESuplSetIdTypeImsi;

				TBuf8<16>& targetSetId = aSessionId.iSetSessionId->iSetId->iSetId;

				TInt len = setId.u.imsi->numocts;

				TUint8* data = setId.u.imsi->data;