/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 <iscapi.h>                 //For ISC

#include <iscnokiadefinitions.h>    //isc definitions

#include <pn_const.h>

#ifndef NCP_COMMON_BRIDGE_FAMILY       

#include <nsisi.h>

#endif

#include <tisi.h>                   //for isimessage

#include <pipeisi.h>                //pipe

#include <pipe_sharedisi.h>         //pipe

#include "cmodematpipecontroller.h"    

#include "cmodemathandler.h"

#include <at_modemisi.h>            //redirectreq error codes

#include "modemattrace.h"

#include "cmodematsrv.h"

const TInt KInvalidPipeHandle = -1;

#ifndef NCP_COMMON_BRIDGE_FAMILY

const TUint8 PEP_COMM_IND_ID_ESCAPE(0x07);

const TInt KInvalidDteId = -1;

const TUint8 KFiller = 0;

const TUint8 KDefaultTrId(0);

#endif

CModemAtPipeController* CModemAtPipeController::NewL( RIscApi& aIscApi,

    TUint& aObjId,

    CModemAtHandler& aHandler )

    {

    CModemAtPipeController* self = new (ELeave) CModemAtPipeController( aIscApi,aObjId, aHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

void CModemAtPipeController::ConstructL()

    {

    C_TRACE (( _T("CModemAtPipeController::ConstructL()") ));

    }

CModemAtPipeController::~CModemAtPipeController() 

     {

     C_TRACE((_L(">>CModemAtPipeController::~CModemAtPipeController()")));

     if( iSchedulerWait )

        {

        C_TRACE((_L("CModemAtPipeController::~CModemAtPipeController() iSchedulerWait->Stop")));

        iSchedulerWait->AsyncStop();

        delete iSchedulerWait;

        iSchedulerWait = NULL;

        }

     C_TRACE((_L("<<CModemAtPipeController::~CModemAtPipeController()")));

     }

CModemAtPipeController::CModemAtPipeController( RIscApi& aIscApi,

    TUint& aObjId,

    CModemAtHandler& aHandler ) : 

    iIscApi( aIscApi ),

    iModemAtObjId( aObjId ),

    iModemAtDevId( THIS_DEVICE ),

    iPipeHandle( KInvalidPipeHandle ),

    iDataportDevId( 0 ),

    iDataportObjId( 0 ),

    iAtHandler( aHandler ),

    iSchedulerWait( NULL ),

    iDteId( KInitialDteId )

    {

    C_TRACE (( _T("CModemAtPipeController::CModemAtPipeController()") ));

    }

#ifndef NCP_COMMON_BRIDGE_FAMILY

 void CModemAtPipeController::HandleNameServiceMessage( const TIsiReceiveC& aReceivedMessage )

     {

     C_TRACE (( _T("CModemAtPipeController::HandleNameServiceMessage()") ));

     switch( aReceivedMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) )

        {

        case PNS_NAME_QUERY_RESP: 

            C_TRACE(_L("PNS_NAME_QUERY_RESP"));

            HandleNameQueryResp( aReceivedMessage );

            break;

        case PNS_NAME_ADD_IND:

            C_TRACE(_L("PNS_NAME_ADD_IND"));

            HandleNameAddInd( aReceivedMessage );

            break;

        case PNS_NAME_REMOVE_IND:

            C_TRACE(_L("PNS_NAME_REMOVE_IND")); 

            HandleNameRemoveInd( aReceivedMessage );

            break;

        default:

            break;

        }

     }

 void CModemAtPipeController::HandlePipeServiceMessage( const TIsiReceiveC& aReceivedMessage)

     {

     C_TRACE (( _T("CModemAtPipeController::HandlePipeServiceMessage()") ));

     switch( aReceivedMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) )

        {

        case PNS_PIPE_CREATE_RESP:

            C_TRACE(_L("PIPE CREATE RESP"));

            HandlePipeCreateResp( aReceivedMessage );

            break;

        case PNS_PIPE_REDIRECT_RESP:

            C_TRACE(_L("PNS_PIPE_REDIRECT_RESP"));

            HandlePipeRedirectResp( aReceivedMessage );

            break;

        case PNS_PIPE_REMOVE_RESP:

            C_TRACE(_L("PNS_PIPE_REMOVE_RESP"));

            HandlePipeRemoveResp( aReceivedMessage );

            break;

        case PNS_PIPE_ENABLE_RESP:

            C_TRACE(_L("PNS_PIPE_ENABLE_RESP"));

            HandlePipeEnabledResp( aReceivedMessage );

            break;

        case PNS_PEP_STATUS_IND :

            C_TRACE(_L("PNS_PEP_STATUS_IND "));

            HandlePepStatusInd( aReceivedMessage );

            break;

        default:

            break;

        }                            

     }

TUint CModemAtPipeController::MatchDataportName( TUint aName)

    {

    /*

    See from dataport: 

    void CDpMif::SendNameAddReqL():

        case KDpDialUpPort:

        case KDpPort4:

        case KDpPort5:

            {

            messageData.Append( aUnit );                //name

            messageData.Append( KDpPadding );           //name

            messageData.Append( PN_PEP_TYPE_COMM );     //name

            messageData.Append( PN_PIPE );              //name

            break;

    Only 3 last bytes count

    */

    TUint KDpDialUpPort = 1;

    TUint KDpPadding = 0;

    TUint dataportName(0);

    dataportName = (

    ( (TUint)PN_PIPE ) | 

    ( (TUint)PN_PEP_TYPE_COMM << 8 ) | 

    ( KDpPadding << 16) | 

    ( KDpDialUpPort << 24 ) 

    );

    if( aName == dataportName )

        {

        return ETrue;

        }

    return EFalse;

    }

void CModemAtPipeController::HandleNameAddInd( const TIsiReceiveC& aReceivedMessage )     

     {

     C_TRACE (( _T("CModemAtPipeController::HandleNameAddInd()") ));

     TUint name = 0;

         {

         C_TRACE((_L("name [%d] 0x%x"), i ,name));

             {

             iDataportDevId = aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 

             iDataportObjId = aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 

             if( iDataportDevId == THIS_DEVICE )

                {

                C_TRACE((_L("CREATE PIPE FROM DATAPORT when ATEXT plugins connect (devid %x  o-bjid %x) "),iDataportDevId,iDataportObjId));

                }

             else

                {

                C_TRACE((_L("ERROR: PIPE not Created due to unmatching DevId: 0x%x or ObjId 0x%x"),iDataportDevId, iDataportObjId ));

                TRACE_ASSERT_ALWAYS;

                }

             }

         }

     }

void CModemAtPipeController::HandleNameRemoveInd( const TIsiReceiveC& aReceivedMessage )     

    {

    C_TRACE((_L("CModemAtPipeHandler::HandleNameQueryResp")));

    TBool found = EFalse;

        {

            {

            }

        }

    }

void CModemAtPipeController::SendCreatePipeMessage( const TUint8 aDevId, const TUint8 aObjId ) 

     {

     C_TRACE (( _T("CModemAtPipeController::SendCreatePipeMessage() DevId: 0x%x ObjId: 0x%x"), aDevId, aObjId ));

     HBufC8* message = HBufC8::New( ISI_HEADER_SIZE + SIZE_PNS_PIPE_CREATE_REQ );

     TRACE_ASSERT(message);

     TPtr8 messageptr = message->Des();

     TIsiSend isimessage( messageptr, ISI_HEADER_SIZE + SIZE_PNS_PIPE_CREATE_REQ );

     isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_PIPE );

     isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_CREATE_REQ_OFFSET_UTID, 0);

     isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_CREATE_REQ_OFFSET_SUBFUNCTION, PNS_PIPE_CREATE_REQ );

     isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_CREATE_REQ_OFFSET_STATEAFTERCREATION ,PN_PIPE_DISABLE );

     isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_CREATE_REQ_OFFSET_PRIORITY ,0 );

     isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_CREATE_REQ_OFFSET_FIRSTPEPDEV, aDevId );

     isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_CREATE_REQ_OFFSET_FIRSTPEPOBJ, aObjId );

     isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_CREATE_REQ_OFFSET_FIRSTPEPTYPE, PN_PEP_TYPE_COMMON );

     isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_CREATE_REQ_OFFSET_FILLERBYTE1, KFiller );

     isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_CREATE_REQ_OFFSET_SECONDPEPDEV, THIS_DEVICE );

     isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_CREATE_REQ_OFFSET_SECONDPEPOBJ, iModemAtObjId );

     isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_CREATE_REQ_OFFSET_SECONDPEPTYPE, PN_PEP_TYPE_COMMON );

     isimessage.Complete();

     C_TRACE(_L("Created ISI-message"));

     DUMP_MESSAGE( messageptr );

     TInt retVal = iIscApi.Send( messageptr );

     delete message;

     }

 void CModemAtPipeController::HandlePipeCreateResp( const TIsiReceiveC& aReceivedMessage )

    {

    C_TRACE (( _T("CModemAtPipeController::HandlePipeCreateResp()") ));

    TInt error = aReceivedMessage.Get8bit(ISI_HEADER_SIZE +  PNS_PIPE_CREATE_RESP_OFFSET_ERRORCODE );

    C_TRACE((_L("Pipe create resp: %d"), error ));

    TRACE_ASSERT( iDteId != KInitialDteId );

    if( error == PN_PIPE_NO_ERROR)

        {

        iPipeHandle = aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 

          PNS_PIPE_CREATE_RESP_OFFSET_PIPEHANDLE );

        C_TRACE( (_L("handle %d"), iPipeHandle ));

        iPipeTable[iDteId].iHandle = iPipeHandle;

        iPipeTable[iDteId].iFirstDevId = iDataportDevId;

        iPipeTable[iDteId].iFirstObjId =  iDataportObjId; 

        iPipeTable[iDteId].iSecondDevId = THIS_DEVICE;

        iPipeTable[iDteId].iSecondObjId =  iModemAtObjId;

        ChangePipeState( iDteId, TPipeInfo::EPipeCreated );

        iPipeHandle = KInvalidPipeHandle;

        iDteId = KInitialDteId;

        }

    else

        {

        C_TRACE (( _T("iPipeHandle == KInvalidPipeHandle ")));

        iPipeTable[iDteId].iHandle = KInvalidPipeHandle;

        iPipeTable[iDteId].iFirstDevId = 0;

        iPipeTable[iDteId].iFirstObjId = 0;

        iPipeTable[iDteId].iSecondDevId = 0;

        iPipeTable[iDteId].iSecondObjId = 0;

        ChangePipeState( iDteId, TPipeInfo::EPipeNoPipe );

        ASSERT_ALWAYS;

        }

    }

 void CModemAtPipeController::LinkDteIdToPipe( const TUint8 aDteId )

    {

    C_TRACE (( _T("CModemAtPipeController::LinkDteIdToPipe(0x%x)"), aDteId ));

    TRACE_ASSERT( aDteId < KMaxDteIdCount );

    iDteId = aDteId;

    if( iDataportDevId == THIS_DEVICE )

        {

        C_TRACE((_L("CREATE PIPE FROM DATAPORT (plugins are connecting) (devid %x  o-bjid %x) "),iDataportDevId,iDataportObjId));

        SendCreatePipeMessage( iDataportDevId, iDataportObjId );

        }

    else

        {

        C_TRACE((_L("Dataport has not been created (devid %x  o-bjid %x) "), iDataportDevId, iDataportObjId ));

        C_TRACE (( _T("iPipeHandle == KInvalidPipeHandle ")));

        iPipeTable[aDteId].iHandle = KInvalidPipeHandle;

        iPipeTable[aDteId].iFirstDevId = 0;

        iPipeTable[aDteId].iFirstObjId = 0;

        iPipeTable[aDteId].iSecondDevId = 0;

        iPipeTable[aDteId].iSecondObjId = 0;

        ChangePipeState( aDteId, TPipeInfo::EPipeNoPipe );

        }

    }

void CModemAtPipeController::HandlePipeRemoveResp( const TIsiReceiveC& aReceivedMessage )

    {

    C_TRACE (( _T(">>CModemAtPipeController::HandlePipeRemoveResp()") ));

    TInt error = aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 

      PNS_PIPE_REMOVE_RESP_OFFSET_ERRORCODE );

    TInt pipehandle = aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 

      PNS_PIPE_REMOVE_RESP_OFFSET_PIPEHANDLE );

    TInt dteId = FindDteId( pipehandle );

    ChangePipeState( dteId, TPipeInfo::EPipeNoPipe );

    iPipeTable[ dteId ].iHandle = KInvalidPipeHandle; 

    if( iSchedulerWait )

        {

        C_TRACE((_L("CModemAtPipeController::HandlePipeRemoveResp() iSchedulerWait->Stop")));

        iSchedulerWait->AsyncStop();

        delete iSchedulerWait;

        iSchedulerWait = NULL;

        }

    C_TRACE((_L("<<CModemAtPipeController::HandlePipeRemoveResp()")));

    }

void CModemAtPipeController::RemovePipe( const TUint8 aDteId )

    {

    C_TRACE (( _T("CModemAtPipeController::RemovePipe(%d, 0x%x)"), aDteId, this ));

    C_TRACE (( _T("iPipeTable[aDteId]:0x%x"), &iPipeTable[aDteId] ));

    C_TRACE (( _T("iHandle: %d"), iPipeTable[aDteId].iHandle ));

    C_TRACE (( _T("i1stDevId: %d"), iPipeTable[aDteId].iFirstDevId ));

    C_TRACE (( _T("i1stObjId: %d"), iPipeTable[aDteId].iFirstObjId )); 

    C_TRACE (( _T("i2ndDevId: %d"), iPipeTable[aDteId].iSecondDevId ));

    C_TRACE (( _T("i2ndObjId: %d"), iPipeTable[aDteId].iSecondObjId ));

    if( iPipeTable[aDteId].iHandle != KInvalidPipeHandle )   

        {

        if( ( iPipeTable[aDteId].iPipeState == TPipeInfo::EPipeRemoving ) || 

            ( iPipeTable[aDteId].iPipeState == TPipeInfo::EPipeNoPipe ) )

            {

            C_TRACE((_L("Already removing pipe or pipe is removed. Handle %d"), iPipeTable[aDteId].iHandle));

            return;

            }

        C_TRACE((_L("Remove pipe. Handle %d"), iPipeTable[aDteId].iHandle));

        ChangePipeState( aDteId, TPipeInfo::EPipeRemoving );

        SendRemovePipeReq( iPipeTable[aDteId].iHandle );

        }

    else

        {

        C_TRACE((_L("No Pipe to Remove")));

        }

    }

void CModemAtPipeController::SendRemovePipeReq( const TUint8 aPipeHandle ) 

    {

    C_TRACE (( _T(">>CModemAtPipeController::SendRemovePipeReq()") ));

    C_TRACE((_L("Remove pipe handle %d"), aPipeHandle));

    TInt size = ISI_HEADER_SIZE + SIZE_PNS_PIPE_REMOVE_REQ;

    HBufC8* message = HBufC8::New( size );

    TPtr8 messageptr = message->Des();

    TIsiSend isimessage( messageptr, size );

    isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_PIPE );

    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REMOVE_REQ_OFFSET_UTID, 0 );

    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REMOVE_REQ_OFFSET_SUBFUNCTION, 

      PNS_PIPE_REMOVE_REQ );

    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REMOVE_REQ_OFFSET_PIPEHANDLE,

      aPipeHandle ); //disabled

    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REMOVE_REQ_OFFSET_FILLERBYTE1 ,0 );

    isimessage.Complete();

    C_TRACE(_L("Created ISI-message"));

    TInt retVal = iIscApi.Send( messageptr );

    delete message;

    if( !iSchedulerWait )

        {

        C_TRACE(_L("CModemAtPipeController::SendRemovePipeReq() iSchedulerWait->Start()"));

        TRAPD(err, iSchedulerWait = new (ELeave) CActiveSchedulerWait);

        ASSERT_PANIC_ALWAYS( err == KErrNone );

        iSchedulerWait->Start();

        }

    C_TRACE (( _T("<<CModemAtPipeController::SendRemovePipeReq()") ));

    }

void CModemAtPipeController::RedirectPipe( const TUint8 aDteId,

    const TUint8 aNewDevId,

    const TUint8 aNewObjId ) 

    {

    C_TRACE (( _T("CModemAtPipeController::RedirectPipe() dteid %d"), aDteId ));

    C_TRACE((_L("CModemAtPipeController::RedirectPipe() New pep, deviceId: 0x%x objId: 0x%x "), aNewDevId, aNewObjId));