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

// Name        : CSatNotifyOpenChannel.cpp

// Part of     : Common SIM ATK TSY / commonsimatktsy

// Open channel notification functionality of Sat Tsy

// Version     : 1.0

//

//INCLUDES

#include <satcs.h>                  // Etel SAT IPC definitions

#include "CSatTsy.h"                // Tsy class header

#include "CSatNotifyOpenChannel.h"  // Class header

#include "CSatNotificationsTsy.h"   // Tsy class header

#include "CBerTlv.h"                // Ber Tlv data handling

#include "TTlv.h"					// TTlv class

#include "CSatDataPackage.h"        // Parameter packing 

#include "TSatUtility.h"            // Utilities

#include "CSatTsyReqHandleStore.h"  // Request handle class

#include "cmmmessagemanagerbase.h"  // Message manager class for forwarding req.

// -----------------------------------------------------------------------------

// CSatNotifyOpenChannel::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//  

CSatNotifyOpenChannel* CSatNotifyOpenChannel::NewL

        ( 

        CSatNotificationsTsy* aNotificationsTsy 

        )

    {

   	CSatNotifyOpenChannel* const satNotifyOpenChannel = 

        new ( ELeave ) CSatNotifyOpenChannel( aNotificationsTsy );

    CleanupStack::PushL( satNotifyOpenChannel );

    satNotifyOpenChannel->ConstructL();

    CleanupStack::Pop( satNotifyOpenChannel );

    return satNotifyOpenChannel;

    }

// -----------------------------------------------------------------------------

// CSatNotifyOpenChannel::~CSatNotifyOpenChannel

// Destructor

// -----------------------------------------------------------------------------

//  

CSatNotifyOpenChannel::~CSatNotifyOpenChannel

        ( 

		// None

        )

    {

    }

// -----------------------------------------------------------------------------

// CSatNotifyOpenChannel::CSatNotifyOpenChannel

// Default C++ constructor

// -----------------------------------------------------------------------------

//  

CSatNotifyOpenChannel::CSatNotifyOpenChannel

        ( 

        CSatNotificationsTsy* aNotificationsTsy 

        ) : iNotificationsTsy ( aNotificationsTsy ), iBearerType( 0 ),

        	iBearer( 0 ), iBufferSize( 0 )

    {

    // None

    }

// -----------------------------------------------------------------------------

// CSatNotifyOpenChannel::ConstructL

// Symbian 2nd phase constructor

// -----------------------------------------------------------------------------

//  

void CSatNotifyOpenChannel::ConstructL

        (

        // None

        )

    {

    }

// -----------------------------------------------------------------------------

// CSatNotifyOpenChannel::Notify

// This request allows a client to be notified of a OPEN CHANNEL proactive 

// command

// -----------------------------------------------------------------------------

//

TInt CSatNotifyOpenChannel::Notify

        (

        const TTsyReqHandle aTsyReqHandle,

        const TDataPackage& aPackage

        )

    {

    // Save data pointers to client side for completion

    iOpenBaseChannelV2Pckg = reinterpret_cast<RSat::TOpenChannelBaseV2Pckg*>( 

        aPackage.Des1n() );  

    iOpenCsChannelV2Pckg = reinterpret_cast<RSat::TOpenCsChannelV2Pckg*>( 

        aPackage.Des1n() );    

    iOpenGprsChannelV4Pckg = reinterpret_cast<RSat::TOpenGprsChannelV4Pckg*>( 

        aPackage.Des1n() );       

    iOpenLocalLinksChannelV2Pckg = reinterpret_cast<

        RSat::TOpenLocalLinksChannelV2Pckg*>( aPackage.Des1n() );     

    // Save the request handle

    iNotificationsTsy->iSatTsy->SaveReqHandle( aTsyReqHandle, 

		CSatTsy::ESatNotifyOpenChannelPCmdReqType );

    // Check if requested notification is already pending

    iNotificationsTsy->NotifySatReadyForNotification( KOpenChannel );   

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CSatNotifyOpenChannel::CancelNotification

// This method cancels an outstanding asynchronous 

// NotifyOpenChannel request.

// -----------------------------------------------------------------------------

//

TInt CSatNotifyOpenChannel::CancelNotification

        (

        const TTsyReqHandle aTsyReqHandle 

        )

    {

    // Reset the request handle

    TTsyReqHandle reqHandle = iNotificationsTsy->iSatReqHandleStore->

        ResetTsyReqHandle( CSatTsy::ESatNotifyOpenChannelPCmdReqType );

	// Reset the data pointers

	iOpenCsChannelV2Pckg = NULL;

	iOpenGprsChannelV4Pckg = NULL;

	iOpenLocalLinksChannelV2Pckg = NULL;	

    // Complete the request with KErrCancel

    iNotificationsTsy->iSatTsy->ReqCompleted( aTsyReqHandle, KErrCancel );

    return KErrNone;    

    }

// -----------------------------------------------------------------------------

// CSatNotifyOpenChannel::CompleteNotifyL

// This method completes an outstanding asynchronous 

// NotifyOpenChannel request. 

// -----------------------------------------------------------------------------

//

TInt CSatNotifyOpenChannel::CompleteNotifyL

        (

        CSatDataPackage* aDataPackage,   

        TInt aErrorCode                  

        )

    {

    TInt ret( KErrNone );	

    // Unpack parameters

    TPtrC8* data;

    aDataPackage->UnPackData( &data );

    // Reset req handle. Returns the deleted req handle

    TTsyReqHandle reqHandle = iNotificationsTsy->iSatReqHandleStore->

        ResetTsyReqHandle( CSatTsy::ESatNotifyOpenChannelPCmdReqType );

    // Get ber tlv 

    CBerTlv berTlv;

    berTlv.SetData( *data );

    // Get command details tlv

    CTlv commandDetails;

    berTlv.TlvByTagValue( &commandDetails, KTlvCommandDetailsTag );

    // Store command details tlv

    iNotificationsTsy->iTerminalRespData.iCommandDetails.Copy( 

        commandDetails.Data() );

    // Get proactive command number

    TUint8 pCmdNumber( commandDetails.GetShortInfo( ETLV_CommandNumber ) );

    // In case the request was ongoing, continue..

    if ( CSatTsy::ESatReqHandleUnknown != reqHandle )

        {

        // Complete right away if error has occured, otherwise continue..

        if ( KErrNone == aErrorCode )

            {

        	RSat::TOpenChannelBaseV2* openChannelV2 = NULL; 

            // Mandatory: Bearer Description & Buffer Size

        	CTlv bearerDescription;

        	CTlv bufferSize;

       	    if ( KErrNone == berTlv.TlvByTagValue( 

        	     &bearerDescription, KTlvBearerDescriptionTag ) && 

            	 KErrNone == berTlv.TlvByTagValue( &bufferSize, 

            	    KTlvBufferSizeTag ) )

            	{

            	// Switch according to bearer

            	switch ( bearerDescription.GetShortInfo( ETLV_BearerType ) )

                	{

                	case KBipCsdBearer:

                    	{

                    	// Buffer size

            	        iBufferSize = bufferSize.GetLongInfo( 

            	            ETLV_BufferSize );

                    	// Bearer description

                    	iBearerType = RSat::ECSDBearer;

                    	iBearer = bearerDescription.GetData( 

                    	    ETLV_BearerParameters ); 

                        CreateTerminalRespL( pCmdNumber, 

							RSat::KCmdBeyondMeCapabilities, KNullDesC16 );

                        ret = KErrCorrupt; 

        				break;

                    	}

               		case KBipGprsBearer:

                    	{

                    	// Fill in TOpenGprsChannelV4

                    	RSat::TOpenGprsChannelV4& openGprsChannelV4 

                        	= ( *iOpenGprsChannelV4Pckg )();

                    	openChannelV2 = &openGprsChannelV4;

                    	openChannelV2->iPCmdType = RSat::EGprsBearer;

                    	// Network access name (Optional)

                    	CTlv nanTlv;

                    	if ( KErrNone == berTlv.TlvByTagValue( &nanTlv, 

                        	KTlvNetworkAccessNameTag ) )

                        	{

                        	openGprsChannelV4.iAccessName =  

                            	nanTlv.GetData( ETLV_NetworkAccessName );

                        	}

                        // Text string (User Logging)

                        CTlv textStringUL;

                        TInt returnValue = berTlv.TlvByTagValue( 

                            &textStringUL, KTlvTextStringTag );

                        if ( KErrNone == returnValue )

                            {

                            // Convert and set text

                            TSatUtility::SetText( textStringUL, 

                                openGprsChannelV4.iUserLogin );

                            }

                        // Text string (User password)

                        CTlv textStringUP;

                        returnValue = berTlv.TlvByTagValue( &textStringUP, 

                            KTlvTextStringTag, 1 );

                        if ( KErrNone == returnValue )

                            {

                            // Convert and set text

                            TSatUtility::SetText( textStringUP, 

                                openGprsChannelV4.iUserPassword );

                            }

                        break;

                        }

        			case KBipDefaultBearer:

                    	{

                    	// Fill in TOpenChannelBaseV2

                    	openChannelV2 = &( *iOpenBaseChannelV2Pckg )();

                    	openChannelV2->iPCmdType = RSat::EAnyBearer;

                    	break;

                    	}

                	case KBipLocalLinkBearer:

                	default:

                    	{

                    	// Bearer not supported (RFU)

                    	// Required values missing

                    	iBearer.FillZ( 1 );

                    	iBufferSize = 0;

                    	iBearerType = static_cast<TUint8>( 

                    	    RSat::EBearerTypeNotSet );

                    	CreateTerminalRespL( pCmdNumber,  

							RSat::KCmdDataNotUnderstood, KNullDesC16 );

                    	ret = KErrCorrupt;

                    	break;

                    	}

                	}    

            	}

        	else

            	{

            	// Required values missing

            	iBearer.FillZ( 1 );

            	iBufferSize = 0;

            	iBearerType = static_cast<TUint8>( RSat::EBearerTypeNotSet );

            	CreateTerminalRespL( pCmdNumber, 

					RSat::KErrorRequiredValuesMissing, KNullDesC16 ); 

            	ret = KErrCorrupt;

            	}

        	if ( KErrNone == ret )

            	{

            	// Buffer size

            	openChannelV2->iBufferSize = bufferSize.GetLongInfo( 

            	    ETLV_BufferSize );

            	// Bearer description

            	openChannelV2->iBearer.iType = ( RSat::TBearerType ) 

            	    bearerDescription.GetShortInfo( ETLV_BearerType );

            	openChannelV2->iBearer.iParams = bearerDescription.GetData( 

            	    ETLV_BearerParameters ); 

                // Proactive command number

            	openChannelV2->SetPCmdNumber( pCmdNumber );

            	// Link Establishment, obtained from Command details Bit 1

            	// Get command qualifier

           		TUint8 cmdQualifier( commandDetails.GetShortInfo( 

                	ETLV_CommandQualifier ) );

            	if ( 0x01 & cmdQualifier )

                	{

                	openChannelV2->iLinkEst = RSat::EImmediate;

                	}

           		else

                	{

                	openChannelV2->iLinkEst = RSat::EOnDemand;

                	}

            	// Reconnection mode, obtained from Command details Bit 2 

            	if ( 0x02 & cmdQualifier )

                	{

                	openChannelV2->iReconnectionMode = 

                    	RSat::EAutomaticReconnection;

                	}

            	else

                	{

                	openChannelV2->iReconnectionMode = 

                    	RSat::ENoAutomaticReconnection;

                	}

            	// Alpha Id (Optional)

            	TPtrC8 sourceString; // Used with conversions

            	CTlv alphaIdentifier;

            	// Get alpha id tlv from berTlv

            	TInt returnValue( berTlv.TlvByTagValue( &alphaIdentifier, 

            	    KTlvAlphaIdentifierTag ) );

            	// If alpha id string exist

            	if ( KErrNone == returnValue ) 

                	{

                	if ( alphaIdentifier.GetLength() )

                    	{

                   		// 8-bit string to 16-bit string

                    	sourceString.Set( alphaIdentifier.GetData( 

                    	    ETLV_AlphaIdentifier ) );

                    	// Convert and set the alpha id

                    	TSatUtility::SetAlphaId( sourceString, 

                    	    openChannelV2->iAlphaId.iAlphaId ); 

                    	// Set alpha id status

                    	openChannelV2->iAlphaId.iStatus = RSat::EAlphaIdProvided;

                    	}

                	else

                    	{

                    	openChannelV2->iAlphaId.iStatus = RSat::EAlphaIdNull;

                    	}

               		}

            	// Alpha id not present

            	else

                	{

                	openChannelV2->iAlphaId.iStatus = RSat::EAlphaIdNotPresent;

                	}

            	// Iconid (optional)

            	TSatUtility::FillIconStructure( berTlv, 

                	openChannelV2->iIconId );

            	// SIM/ME interface transport level

            	CTlv simMeInterfaceTlv;

            	returnValue = berTlv.TlvByTagValue( &simMeInterfaceTlv, 

                	KTlvSimMeTransportLevelTag );

           		if ( KErrNone == returnValue )

                	{

                	openChannelV2->iSimMeInterface.iPrtNumber = 

                    	simMeInterfaceTlv.GetLongInfo( ETLV_PortNumber );

                	TUint8 protocol = simMeInterfaceTlv.GetShortInfo(

                    	ETLV_TransportProtocolType );

                	switch ( protocol )

                	    {

                	    case 0x01:

                        	{

                        	openChannelV2->iSimMeInterface.iTransportProto =

                            	RSat::EUdp;

                            break;

                        	}

                	    case 0x02:

                        	{

                        	openChannelV2->iSimMeInterface.iTransportProto =

                            	RSat::ETcp;

                            break;

                        	}

                	    default:

                        	{

                        	openChannelV2->iSimMeInterface.iTransportProto =

                            	RSat::EProtocolNotSet;

                        	}

                	    }

                	}

            	else

                	{

                	openChannelV2->iSimMeInterface.iTransportProto =

                    	RSat::EProtocolNotPresent;

                	}

                // Data destination address

            	// The Data Destination Address is the end point destination 

            	// address of sent data. This data destination address is 

            	// requested when a SIM/ME interface transport is present, 

            	// otherwise it is ignored

            	// Determine the number of Other Address tags, if there is one

            	// and no  SIM/ME interface then this is a Local Address

            	// But if there is one and SIM/ME interface, this is a

            	// Destination address,

            	// And if there are 2, then the last one is the destination 

            	// address.

            	CTlv* dataDestAddressTlv=NULL;

            	CTlv* localAddressTlv=NULL;

            	CTlv localAddress1;

            	CTlv localAddress2;

            	TInt ret_laddr1 = berTlv.TlvByTagValue( &localAddress1, 

            	    KTlvOtherAddressTag );

            	TInt ret_laddr2 = berTlv.TlvByTagValue( &localAddress2, 

                	KTlvOtherAddressTag, 1 );                    

            	if ( ( RSat::EProtocolNotPresent != 

                   	openChannelV2->iSimMeInterface.iTransportProto )

                 	&& ( KErrNone     == ret_laddr1 )

                 	&& ( KErrNotFound == ret_laddr2 ) )

                	{

                	// Destination Address is localAddress1, no local address

                	dataDestAddressTlv = &localAddress1;

                	}

            	else if ( ( RSat::EProtocolNotPresent != 

                   openChannelV2->iSimMeInterface.iTransportProto )

                 	&& ( KErrNone == ret_laddr1 )

                 	&& ( KErrNone == ret_laddr2 ) )

                	{

                	// Local address is localAddress1

                	localAddressTlv = &localAddress1;

                	// Destination Address is localAddress2

                	dataDestAddressTlv = &localAddress2;

                	}

            	else if ( ( RSat::EProtocolNotPresent == 

                   	openChannelV2->iSimMeInterface.iTransportProto )

                 	&& ( KErrNone == ret_laddr1 ) )

                	{

                	// There is only a local address, which is localAddress1

                	localAddressTlv = &localAddress1;

                	}

            	// Set Destination address    

            	if( dataDestAddressTlv )

                	{

                	TUint8 typeOfAddress = dataDestAddressTlv->GetShortInfo( 

                	    ETLV_TypeOfAddress );

                	switch( typeOfAddress )

                    	{

                    	case KIPV4: // IPv4

                        	{

                        	openChannelV2->iDestinationAddress.iType = 

                        	    RSat::EIPv4Address;

                        	break;

                        	}

                    	case KIPV6:  // IPv6

                        	{

                        	openChannelV2->iDestinationAddress.iType = 

                        	    RSat::EIPv6Address;

                        	break;

                        	}

                    	default:

                        	{

                        	openChannelV2->iDestinationAddress.iType = 

                        	    RSat::EAddressNotSet;

                        	break;

                        	}

                    	}

                	//Is there an address

                	if( dataDestAddressTlv->GetLength() - 1 )

                    	{

                    	openChannelV2->iDestinationAddress.iAddress = 

                        	dataDestAddressTlv->GetData( ETLV_Address );

                    	}

            		}

            	else

            		{

            		openChannelV2->iDestinationAddress.iType = 

            		    RSat::EAddressNotPresent;

            		}

            	// Set Local address (Other Address)

            	if ( localAddressTlv )

            		{

            		CTlv bearerDescription;

                	if ( KErrNone == berTlv.TlvByTagValue( &bearerDescription,

                	    KTlvBearerDescriptionTag ) )

                	    {

                		switch ( bearerDescription.GetShortInfo( 

                		    ETLV_BearerType ) )

                    		{

                    		case KBipCsdBearer:

                        		{

                        		RSat::TOpenCsChannelV2& openCsChannelV2 

                        		= ( *iOpenCsChannelV2Pckg )();

                        		openCsChannelV2.iLocalAddress.iAddress = 

                        		    localAddressTlv->GetData( ETLV_Address );

                        		TUint8 typeOfAddress = localAddressTlv->

                        		    GetShortInfo( ETLV_TypeOfAddress );