// Copyright (c) 2005-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:
// 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 "TfLogger.h"               // For TFLOGSTRING
#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 
        )
    {
    TFLOGSTRING("CSAT: CSatNotifyOpenChannel::NewL");
   	CSatNotifyOpenChannel* const satNotifyOpenChannel = 
        new ( ELeave ) CSatNotifyOpenChannel( aNotificationsTsy );
    CleanupStack::PushL( satNotifyOpenChannel );
    satNotifyOpenChannel->ConstructL();
    CleanupStack::Pop( satNotifyOpenChannel );
    TFLOGSTRING("CSAT: CSatNotifyOpenChannel::NewL, end of method");
    return satNotifyOpenChannel;
    }

// -----------------------------------------------------------------------------
// CSatNotifyOpenChannel::~CSatNotifyOpenChannel
// Destructor
// -----------------------------------------------------------------------------
//  
CSatNotifyOpenChannel::~CSatNotifyOpenChannel
        ( 
		// None
        )
    {
    TFLOGSTRING("CSAT: CSatNotifyOpenChannel::~CSatNotifyOpenChannel");
    }
    
// -----------------------------------------------------------------------------
// 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
        )
    {
    TFLOGSTRING("CSAT: CSatNotifyOpenChannel::ConstructL");
    }

// -----------------------------------------------------------------------------
// 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
        )
    {
    TFLOGSTRING("CSAT: CSatNotifyOpenChannel::Notify");
    // 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 
        )
    {
    TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CancelNotification");
    
    // 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                  
        )
    {
    TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CompleteNotifyL");

    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:
                    	{
                    	TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\
                    	    CompleteNotifyL, Command not supported: \
                    	    Csd Bearer");
                    	// Buffer size
            	        iBufferSize = bufferSize.GetLongInfo( 
            	            ETLV_BufferSize );
                    	// Bearer description
                    	iBearerType = RSat::ECSDBearer;
                    	iBearer = bearerDescription.GetData( 
                    	    ETLV_BearerParameters ); 
                        TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\
                            CompleteNotifyL, BipCsdBearer ");
                        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)
                    	TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\
                    	    CompleteNotifyL, Bearer not supported");
                    	// Required values missing
                    	iBearer.FillZ( 1 );
                    	iBufferSize = 0;
                    	iBearerType = static_cast<TUint8>( 
                    	    RSat::EBearerTypeNotSet );
                    	CreateTerminalRespL( pCmdNumber,  
							RSat::KCmdDataNotUnderstood, KNullDesC16 );
                    	ret = KErrCorrupt;
                    	break;
                    	}
                	}    
            	}
        	else
            	{
            	TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CompleteNotifyL,\
            	    required values missing");
            	// 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
                    	{
                    	TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\
                    	    CompleteNotifyL, Alpha ID is NULL");
                    	openChannelV2->iAlphaId.iStatus = RSat::EAlphaIdNull;
                    	}
               		}
            	// Alpha id not present
            	else
                	{
                	TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CompleteNotifyL,\
                	    Alpha ID not present");
                	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
                	{
                	TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CompleteNotifyL,\
                	    Protocol not present");
                	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:
                        	{
                        	TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\
                        	    CompleteNotifyL, Address not set");
                        	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 );
                        		    
                        		switch ( typeOfAddress )
                        		    {
                        		    case KIPV4:
                                		{
                                		openCsChannelV2.iLocalAddress.iType = 
                                		    RSat::EIPv4Address;
                                    	break;
                                		}
                        		    case KIPV6:
                                		{
                                		openCsChannelV2.iLocalAddress.iType = 
                                    		RSat::EIPv6Address;
                                    	break;
                                		}
                                	default:
                                    	{
                                    	TFLOGSTRING("CSAT:\
                                    	    CSatNotifyOpenChannel::\
                                    	    CompleteNotifyL, Address not set");
                                		openCsChannelV2.iLocalAddress.iType = 
                                    		RSat::EAddressNotSet;
                                		}
                        		    }
                        		    
                        		// Is there an address
                        		if( localAddressTlv->GetLength() - 1 )
                            		{
                            		openCsChannelV2.iLocalAddress.iAddress = 
                                		localAddressTlv->GetData( ETLV_Address );
                            		}
                       			else
                            		{
                            		TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\
                            		    CompleteNotifyL, Address not present");
                            		openCsChannelV2.iLocalAddress.iType = 
                                		RSat::EAddressNotPresent;
                            		}    
                            		
                        		break;
                        		}
                        	case KBipGprsBearer:
                            	{
                            	RSat::TOpenGprsChannelV4& openGprsChannelV4 
                            	= ( *iOpenGprsChannelV4Pckg )();
                            	openGprsChannelV4.iLocalAddress.iAddress = 
                            	localAddressTlv->GetData( ETLV_Address );
                            	TUint8 typeOfAddress = localAddressTlv->
                            	    GetShortInfo( ETLV_TypeOfAddress );
                            	
                            	switch ( typeOfAddress )
                            	    {
                            	    case KIPV4:
                                    	{
                                    	openGprsChannelV4.iLocalAddress.iType =
                                        	RSat::EIPv4Address;
                                        break;
                                    	}
                            	    case KIPV6:
                                    	{
                                    	openGprsChannelV4.iLocalAddress.iType = 
                                        	RSat::EIPv6Address;
                                        break;
                                    	}
                                    default:
                                    	{
                                    	TFLOGSTRING("CSAT: \
                                    	    CSatNotifyOpenChannel::\
                                    	    CompleteNotifyL, Address not set");
                                    	openGprsChannelV4.iLocalAddress.iType = 
                                        	RSat::EAddressNotSet;
                                    	}
                            	    }
                            	    
                            	// Is there an address
                            	if( localAddressTlv->GetLength() - 1 )
                                	{
                                	openGprsChannelV4.iLocalAddress.iAddress = 
                                    	localAddressTlv->GetData( 
                                    	    ETLV_Address );
                                	}
                            	else
                                	{
                                	TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\
                                	    CompleteNotifyL, Address not present");
                                	openGprsChannelV4.iLocalAddress.iType = 
                                    	RSat::EAddressNotPresent;
                                	}    
                            
                            	break;
                            	}
                        	default:
                            	{
                            	TFLOGSTRING("CSAT: CSatNotifyOpenChannel::\
                            	    CompleteNotifyL, Unknown Bearer type");
                            	break;
                            	}
                            	
                    		} // Switch-case
                	    } // If bearer description tag exists
            		} // if ( localAddressTlv )
            	} // if ( KErrNone == ret )
            else
                {
                TFLOGSTRING("CSAT: CSatNotifyOpenChannel::CompleteNotifyL,\
                    Error when parsing Bearer data");
                }
            } // if ( KErrNone == aErrorCode )
		else
            {
            ret = aErrorCode;
            }
                	
        iNotificationsTsy->iSatTsy->ReqCompleted( reqHandle, ret );
        } // if ( CSatTsy::ESatReqHandleUnknown != reqHandle )
    else
        {
        // Request not on, returning response immediately
        TFLOGSTRING("CSAT:  CSatNotifyOpenChannel::CompleteNotifyL, \
            Request not ongoing");
        // additional info must be provided with KMeUnableToProcessCmd 
		TBuf16<1> additionalInfo;
		additionalInfo.Append( RSat::KNoSpecificMeProblem );
        iBearer.FillZ( 1 );
        iBufferSize = 0;
        iBearerType = static_cast<TUint8>( RSat::EBearerTypeNotSet );
        CreateTerminalRespL( pCmdNumber, RSat::KMeUnableToProcessCmd,
             additionalInfo );                                       
        ret = KErrCorrupt;
        }
    return ret;    
    }
// -----------------------------------------------------------------------------
// CSatNotifyOpenChannel::TerminalResponseL
// Called by ETel server, passes terminal response to DOS
// -----------------------------------------------------------------------------
//
TInt CSatNotifyOpenChannel::TerminalResponseL
        ( 
        TDes8* aRsp 
        )
    {
    TFLOGSTRING("CSAT: CSatNotifyOpenChannel::TerminalResponseL");

    TInt ret( KErrNone );

	TBuf16<RSat::KAdditionalInfoMaxSize> additionalInfo;

    RSat::TOpenChannelRspV2Pckg* aRspPckg = 
            REINTERPRET_CAST( RSat::TOpenChannelRspV2Pckg*, aRsp);
    RSat::TOpenChannelRspV2& rspV2 = ( *aRspPckg ) ();

    TUint8 pCmdNumber( rspV2.PCmdNumber() );
    
    TFLOGSTRING2("CSAT: CSatNotifyOpenChannel::TerminalResponseL, \
        General result: %d", rspV2.iGeneralResult);

    // Check that general result value is valid
    if ( ( RSat::KSuccess != rspV2.iGeneralResult ) 
        && ( RSat::KPartialComprehension != rspV2.iGeneralResult )
        && ( RSat::KMissingInformation != rspV2.iGeneralResult )
        && ( RSat::KSuccessRequestedIconNotDisplayed != rspV2.iGeneralResult )
        && ( RSat::KPerformedWithModifications != rspV2.iGeneralResult )
        && ( RSat::KRefreshUSIMNotActive != rspV2.iGeneralResult )
        && ( RSat::KPSessionTerminatedByUser != rspV2.iGeneralResult )
        && ( RSat::KMeUnableToProcessCmd != rspV2.iGeneralResult )
        && ( RSat::KNetworkUnableToProcessCmd != rspV2.iGeneralResult )
        && ( RSat::KPCmdNotAcceptedByUser != rspV2.iGeneralResult )
        && ( RSat::KInteractionWithCCTemporaryError != rspV2.iGeneralResult )
        && ( RSat::KCmdBeyondMeCapabilities != rspV2.iGeneralResult )
        && ( RSat::KCmdTypeNotUnderstood != rspV2.iGeneralResult )
        && ( RSat::KCmdDataNotUnderstood != rspV2.iGeneralResult )
        && ( RSat::KCmdNumberNotKnown != rspV2.iGeneralResult )
        && ( RSat::KErrorRequiredValuesMissing != rspV2.iGeneralResult )
        && ( RSat::KBearerIndepProtocolError != rspV2.iGeneralResult )
        && ( RSat::KAccessTechUnableProcessCmd != rspV2.iGeneralResult )
        && ( RSat::KFramesError != rspV2.iGeneralResult ) )
        {
        TFLOGSTRING("CSAT: CSatNotifyOpenChannel::TerminalResponseL, \
            Invalid General Result");
        // Invalid general result
        ret = KErrCorrupt;
        }

    // Check for additional info type
    // - If there is ME (Mobile Equipment) error, additional info is needed
    // - Channel Status Info is sent through additional info
    if ( ( RSat::KMeProblem == rspV2.iInfoType ) || 
         ( RSat::KChannelStatusInfo == rspV2.iInfoType ) )
        {
        // Check the length of additional info
        if ( rspV2.iAdditionalInfo.Length() <= 0 )
            {
            TFLOGSTRING("CSAT: CSatNotifyOpenChannel::TerminalResponseL, \
                Invalid Additional Info");
            // Invalid additional info field
            ret = KErrCorrupt;
            }
        else
        	{
            additionalInfo.Copy(rspV2.iAdditionalInfo);
        	}   
        }
    else if ( RSat::KSatNetworkErrorInfo == rspV2.iInfoType )
    	{
        // Copy the additional info, if present
        if ( rspV2.iAdditionalInfo.Length() > 0 )
            {
            additionalInfo.Copy(rspV2.iAdditionalInfo);
            }
    	}
    else if ( RSat::KNoAdditionalInfo == rspV2.iInfoType )
	    {
	    // Do nothing
	    }
	else
        {
        TFLOGSTRING("CSAT: CSatNotifyOpenChannel::TerminalResponseL, \
                     Invalid Additional Info type");
        ret = KErrCorrupt;
        }
        
	iBearerType = static_cast<TUint8>(rspV2.iBearer.iType);
	iBearer.Copy( rspV2.iBearer.iParams );
	iBufferSize = rspV2.iBufferSize;
    // Send Terminal Response
    TInt response = CreateTerminalRespL( pCmdNumber, 
    	static_cast<TUint8>( rspV2.iGeneralResult ), additionalInfo );

    if ( KErrNone == ret )
        ret = response;

    return ret;
    }
    
// -----------------------------------------------------------------------------
// CSatNotifyOpenChannel::CreateTerminalRespL
// Constructs Open channel specific part of terminal response and calls 
// DOS to send the actual message.
// -----------------------------------------------------------------------------
//
TInt CSatNotifyOpenChannel::CreateTerminalRespL
        ( 
        TUint8 aPCmdNumber,         
        TUint8 aGeneralResult,      
        const TDesC16& aAdditionalInfo
		)
    {
    TFLOGSTRING("CSAT: CSatMessHandler::CreateTerminalRespL");
    // Create and append response data
    TTlv tlvSpecificData;
    // Create General Result TLV here
    tlvSpecificData.AddTag( KTlvResultTag );
    // General result
    tlvSpecificData.AddByte( aGeneralResult );

    if ( ( RSat::KSuccess == aGeneralResult )
        || ( RSat::KPartialComprehension == aGeneralResult )
        || ( RSat::KMissingInformation == aGeneralResult ) 
	    || ( RSat::KPerformedWithModifications == aGeneralResult )
	    || ( RSat::KSuccessRequestedIconNotDisplayed == aGeneralResult ) )
    	{
        // Successful result: append Channel Status using additional info.
		for ( TInt i = 1; i < aAdditionalInfo.Length(); i += 2 )
            {
	        tlvSpecificData.AddTag( KTlvChannelStatusTag );
			tlvSpecificData.AddByte( static_cast<TUint8>( aAdditionalInfo[i-1] ) );
			tlvSpecificData.AddByte( static_cast<TUint8>( aAdditionalInfo[i] ) );
            }
        }
    else
        {
        // Successful result: could/must provide an additional info byte
		if ( aAdditionalInfo.Length() > 0 )
        	{
        	TFLOGSTRING2("CSAT: CSatMessHandler::CreateTerminalRespL,\
				Unsuccessful result: aAddtionalInfo: %d", aAdditionalInfo[0]);
			tlvSpecificData.AddByte( static_cast<TUint8>( aAdditionalInfo[0] ) );
            }
        }
        
    // For any result: Append Bearer Description data
    if ( iBearer.Length() )
        {
        tlvSpecificData.AddTag( KTlvBearerDescriptionTag );
        tlvSpecificData.AddByte( iBearerType );
        tlvSpecificData.AddData( iBearer );
        }
    else
        {
        TFLOGSTRING("CSAT: CSatMessHandler::CreateTerminalRespL: \
        	No Bearer Description data available");
        }
        
    // Append Buffer Size
    tlvSpecificData.AddTag( KTlvBufferSizeTag );
    tlvSpecificData.AddByte( TUint8( ( iBufferSize & 0xFF00 ) >> 8 ) );
    tlvSpecificData.AddByte( TUint8( iBufferSize & 0x00FF ) );
    
    // Prepare data
    iNotificationsTsy->iTerminalRespData.iPCmdNumber = aPCmdNumber;
    TPtrC8 data = tlvSpecificData.GetDataWithoutTopLevelTag();

    // Pack data
    CSatDataPackage dataPackage;
	dataPackage.PackData( &iNotificationsTsy->iTerminalRespData, &data );

    // Forward request to the DOS
    return iNotificationsTsy->iSatTsy->MessageManager()->HandleRequestL( 
		ESatTerminalRsp, &dataPackage );
    }
    
// End of file

