diff -r 000000000000 -r 63b37f68c1ce adaptationlayer/modematadaptation/modematcontroller_exe/src/cmodematpipecontroller.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/adaptationlayer/modematadaptation/modematcontroller_exe/src/cmodematpipecontroller.cpp	Fri Nov 06 17:28:23 2009 +0000
@@ -0,0 +1,718 @@
+/*
+* 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);
+const TUint8 KTaskIdQuerySize(20);
+#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 ),
+    iCellmoDevId( 0 ),
+    iCellmoObjId( 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:
+            ASSERT_PANIC_ALWAYS( EFalse ) ;
+            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:
+            ASSERT_PANIC_ALWAYS( EFalse );
+            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()") ));
+     TInt count = aReceivedMessage.Get16bit( ISI_HEADER_SIZE + PNS_NAME_ADD_IND_OFFSET_MATCHESINMSG );
+     
+     C_TRACE((_L("Count %d") ,count ));
+     TUint name = 0;
+    
+     for( TInt i = 1; i <= count ; i++ ) 
+         {
+         name = aReceivedMessage.Get32bit(ISI_HEADER_SIZE+PNS_NAME_ADD_IND_OFFSET_NAMEENTRYTBL * i);
+         C_TRACE((_L("name [%d] 0x%x"), i ,name));
+
+         if( MatchDataportName(name) )   
+             {
+             iDataportDevId = aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 
+               PNS_NAME_ADD_IND_OFFSET_NAMEENTRYTBL * i +  PN_NAME_SRV_ITEM_STR_OFFSET_DEV );
+             iDataportObjId = aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 
+               PNS_NAME_ADD_IND_OFFSET_NAMEENTRYTBL * i +  PN_NAME_SRV_ITEM_STR_OFFSET_OBJ);
+             
+             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 (( _T("CModemAtPipeController::HandleNameRemoveInd()") ));
+     TInt count = aReceivedMessage.Get16bit( ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_MATCHESINMSG );
+     
+     C_TRACE((_L("Count %d") ,count ));
+     TUint name = 0;
+    
+     for( TInt i = 1; i <= count ; i++ ) 
+         {
+         name = aReceivedMessage.Get32bit(ISI_HEADER_SIZE + PNS_NAME_REMOVE_IND_OFFSET_NAMEENTRYTBL * i);
+         C_TRACE((_L("name [%d] 0x%x"), i ,name));
+
+         if( MatchDataportName(name) )   
+             {
+             TUint devId = aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 
+               PNS_NAME_REMOVE_IND_OFFSET_NAMEENTRYTBL * i +  PN_NAME_SRV_ITEM_STR_OFFSET_DEV );
+             TUint objId = aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 
+               PNS_NAME_REMOVE_IND_OFFSET_NAMEENTRYTBL * i +  PN_NAME_SRV_ITEM_STR_OFFSET_OBJ);
+
+             if( iDataportDevId == devId && iDataportObjId == objId )
+                {
+                C_TRACE((_L("Dataport removed from name service (devid %x  o-bjid %x) "),iDataportDevId,iDataportObjId));
+                iDataportDevId = 0;
+                iDataportObjId = 0;
+                }
+             else
+                {
+                C_TRACE((_L("Unused dataport removed from name service. DevId: 0x%x or ObjId 0x%x"), iDataportDevId, iDataportObjId ));
+                TRACE_ASSERT_ALWAYS;
+                }
+             }
+         }
+     }
+
+
+void CModemAtPipeController::HandleNameQueryResp( const TIsiReceiveC& aReceivedMessage ) 
+    {
+    C_TRACE((_L("CModemAtPipeHandler::HandleNameQueryResp")));
+     
+    TInt count = aReceivedMessage.Get16bit( ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_MATCHESINMSG );
+    C_TRACE((_L("Count d%d"), count ));
+    TInt name = 0;
+    TBool found = EFalse;
+     
+    for( TInt i = 0; i < count ; i++ ) 
+        {
+        name = aReceivedMessage.Get32bit( ISI_HEADER_SIZE + PNS_NAME_QUERY_RESP_OFFSET_NAMEENTRYTBL * i );
+        C_TRACE((_L("name [%d]%x"),i ,name ));
+        if(name == PN_AT_MODEM) 
+            {
+            iCellmoDevId =  aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 
+              PNS_NAME_QUERY_RESP_OFFSET_NAMEENTRYTBL * i +  PN_NAME_SRV_ITEM_STR_OFFSET_DEV );
+            iCellmoObjId =  aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 
+              PNS_NAME_QUERY_RESP_OFFSET_NAMEENTRYTBL * i +  PN_NAME_SRV_ITEM_STR_OFFSET_OBJ );
+            found = ETrue;
+            C_TRACE((_L("devid %x  objid %x"),iCellmoDevId,iCellmoObjId));
+            }
+        }
+     
+    if( !found )
+        {
+        TRACE_ASSERT_ALWAYS;
+        User::Panic( _L("NO AT-MODEM"), KErrNotFound );
+        }
+    }
+
+
+
+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 );
+     ASSERT_PANIC_ALWAYS( retVal == KErrNone );
+     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 );
+    ASSERT_PANIC_ALWAYS( dteId < KMaxDteIdCount )
+    ASSERT_PANIC_ALWAYS( error == PN_PIPE_NO_ERROR )
+    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 ));
+    ASSERT_PANIC_ALWAYS( aDteId < KMaxDteIdCount );
+    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 );
+    ASSERT_PANIC_ALWAYS( message );
+
+    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 );
+    ASSERT_PANIC_ALWAYS( retVal == KErrNone );
+    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));
+    ASSERT_PANIC_ALWAYS( aDteId < KMaxDteIdCount ) 
+    ASSERT_PANIC_ALWAYS( iPipeTable[aDteId].iHandle != KInvalidPipeHandle )
+
+    if( iPipeTable[aDteId].iPipeState == TPipeInfo::EPipeRemoving || 
+        iPipeTable[aDteId].iPipeState == TPipeInfo::EPipeNoPipe ) 
+        {
+        C_TRACE(_L("CModemAtPipeController::RedirectPipe() Pipe is already removed -> cant redirect"));
+        return;
+        }
+
+    if( aNewDevId == THIS_DEVICE && aNewObjId == iModemAtObjId )
+        {
+        C_TRACE((_L("CModemAtPipeController::RedirectPipe() EPipeDisabled. iModemAtObjId: 0x%x"), iModemAtObjId));
+        ChangePipeState( aDteId, TPipeInfo::EPipeDisabled );
+        }
+    else
+        {
+        C_TRACE(_L("CModemAtPipeController::RedirectPipe() EPipeRedirected"));
+        ChangePipeState( aDteId, TPipeInfo::EPipeRedirected );
+        }
+
+    C_TRACE(_L("CModemAtPipeController::RedirectPipe() Redirecting pipe"));
+
+    HBufC8* message = HBufC8::New( ISI_HEADER_SIZE + SIZE_PNS_PIPE_REDIRECT_REQ );
+    ASSERT_PANIC_ALWAYS( message ) 
+    TPtr8 messageptr = message->Des();
+    TIsiSend isimessage( messageptr, ISI_HEADER_SIZE + SIZE_PNS_PIPE_REDIRECT_REQ );
+    isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID,PN_PIPE);
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REDIRECT_REQ_OFFSET_UTID, 0); 
+
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REDIRECT_REQ_OFFSET_SUBFUNCTION,
+      PNS_PIPE_REDIRECT_REQ );
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REDIRECT_REQ_OFFSET_PIPEHANDLE,
+      iPipeTable[aDteId].iHandle ); 
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REDIRECT_REQ_OFFSET_STATEAFTERCREATION,
+      PN_PIPE_DISABLE );
+    //old pep 
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REDIRECT_REQ_OFFSET_OLDPEPDEV,
+      iPipeTable[aDteId].iSecondDevId );
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REDIRECT_REQ_OFFSET_OLDPEPOBJ, 
+      iPipeTable[aDteId].iSecondObjId );
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REDIRECT_REQ_OFFSET_OLDPEPTYPE, PN_PEP_TYPE_COMMON); 
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REDIRECT_REQ_OFFSET_FILLERBYTE1, KFiller );
+
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REDIRECT_REQ_OFFSET_REPLACEMENTPEPDEV, aNewDevId );
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REDIRECT_REQ_OFFSET_REPLACEMENTPEPOBJ, aNewObjId );
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_REDIRECT_REQ_OFFSET_REPLACEMENTPEPTYPE, 
+      PN_PEP_TYPE_COMMON ); 
+
+    iPipeTable[aDteId].iSecondDevId = aNewDevId;
+    iPipeTable[aDteId].iSecondObjId = aNewObjId;
+
+    isimessage.Set8bit(ISI_HEADER_SIZE + PNS_PIPE_REDIRECT_REQ_OFFSET_NSB, KFiller );
+    isimessage.Complete();
+
+    C_TRACE(_L("Created ISI-message"));
+    TInt retVal = iIscApi.Send( messageptr );
+    ASSERT_PANIC_ALWAYS( retVal == KErrNone );
+    delete message;
+    }
+ 
+void CModemAtPipeController::HandlePipeRedirectResp( const TIsiReceiveC& aReceivedMessage )
+    {
+    C_TRACE (( _T("CModemAtPipeController::HandlePipeRedirectResp()") ));
+    TInt error = aReceivedMessage.Get8bit( ISI_HEADER_SIZE +
+      PNS_PIPE_REDIRECT_RESP_OFFSET_ERRORCODE );
+    TInt pipeHandle = aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 
+      PNS_PIPE_REDIRECT_RESP_OFFSET_PIPEHANDLE );
+    C_TRACE((_L("CModemAtPipeController::HandlePipeRedirectResp() pipehandle: %d"), pipeHandle ));
+    TInt dteId = FindDteId( pipeHandle );
+    
+    if( error != PN_PIPE_NO_ERROR )
+        {
+        if( dteId != KInvalidDteId )
+            {
+            C_TRACE(( _L("CModemAtPipeController::HandlePipeRedirectResp() pipe error: %d"), error ));
+            iAtHandler.SendAtModemDataRedirectResultReq( dteId, AT_MODEM_REDIRECT_RESULT_ERROR);
+            RemovePipe( dteId );
+            return;
+            }
+        else
+            {
+            C_TRACE(( _L("CModemAtPipeController::HandlePipeRedirectResp() dteId not found, pipe error: %d"), error ));
+            TRACE_ASSERT_ALWAYS;
+            return;
+            }
+        }
+
+    iAtHandler.SendAtModemDataRedirectResultReq( dteId, AT_MODEM_REDIRECT_RESULT_OK );
+
+    if( iPipeTable[ dteId ].iPipeState != TPipeInfo::EPipeDisabled )
+        {
+        SendEnablePipeReq( pipeHandle );
+        }
+
+    }
+
+void CModemAtPipeController::SendTaskIdQuery() 
+    {
+    C_TRACE (( _T("CModemAtPipeController::SendTaskIdQuery()") ));
+    HBufC8* message = HBufC8::New( KTaskIdQuerySize );
+    TRACE_ASSERT( message );
+    if( message )
+        {
+        TPtr8 messageptr = message->Des();
+        TIsiSend isimessage( messageptr, KTaskIdQuerySize );
+        isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_NAMESERVICE );       
+        isimessage.Set8bit( ISI_HEADER_SIZE + PNS_NAME_QUERY_REQ_OFFSET_UTID, KDefaultTrId );
+        isimessage.Set8bit( ISI_HEADER_SIZE + PNS_NAME_QUERY_REQ_OFFSET_SUBFUNCTION, PNS_NAME_QUERY_REQ );
+        isimessage.Set8bit( ISI_HEADER_SIZE + PNS_NAME_QUERY_REQ_OFFSET_RESERVED1, 0 );
+        isimessage.Set8bit( ISI_HEADER_SIZE + PNS_NAME_QUERY_REQ_OFFSET_RESERVED2, 0);
+        isimessage.Set32bit( ISI_HEADER_SIZE + PNS_NAME_QUERY_REQ_OFFSET_NAME, PN_AT_MODEM );
+        isimessage.Set32bit( ISI_HEADER_SIZE + PNS_NAME_QUERY_REQ_OFFSET_BITMASK, PN_AT_MODEM );
+        isimessage.Complete();
+
+        DUMP_MESSAGE( messageptr );
+        TInt retVal = iIscApi.Send( messageptr );
+        ASSERT_PANIC_ALWAYS( retVal == KErrNone );
+        delete message;
+        }
+    }
+
+void CModemAtPipeController::SendEnablePipeReq( const TUint8 aPipeHandle )
+    {
+    C_TRACE (( _T("CModemAtPipeController::SendEnablePipeReq()") ));
+    HBufC8* message = HBufC8::New( ISI_HEADER_SIZE + SIZE_PNS_PIPE_ENABLE_REQ );
+    ASSERT_PANIC_ALWAYS( message ) 
+    TPtr8 messageptr = message->Des();
+    TIsiSend isimessage( messageptr, ISI_HEADER_SIZE + SIZE_PNS_PIPE_ENABLE_REQ );
+    isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_PIPE );       
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_ENABLE_REQ_OFFSET_UTID, 0 );
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_ENABLE_REQ_OFFSET_SUBFUNCTION, PNS_PIPE_ENABLE_REQ );
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_ENABLE_REQ_OFFSET_PIPEHANDLE , aPipeHandle );
+    isimessage.Set8bit( ISI_HEADER_SIZE + PNS_PIPE_ENABLE_REQ_OFFSET_FILLERBYTE1 , 0 );
+    isimessage.Complete();
+
+    DUMP_MESSAGE( messageptr );
+    TInt retVal = iIscApi.Send( messageptr );
+    ASSERT_PANIC_ALWAYS( retVal == KErrNone );
+    delete message;
+    }
+
+ TInt CModemAtPipeController::FindDteId( const TInt aHandle )
+    {
+    C_TRACE (( _T("CModemAtPipeController::FindDteId()") ));
+    TInt dteId = KInvalidDteId;
+    for( TInt i = 0 ; i < KMaxDteIdCount ; i++ ) 
+        {
+        if( iPipeTable[i].iHandle == aHandle ) 
+            {
+            dteId = i;
+            break;
+            }
+        }
+
+    TRACE_ASSERT( dteId != KInvalidDteId );
+    C_TRACE((_L("CModemAtPipeController::FindDteId() returns dteid: %d"),dteId));
+    return dteId;
+    } 
+
+ 
+void CModemAtPipeController::HandlePipeEnabledResp( const TIsiReceiveC& aReceivedMessage )
+    {
+    C_TRACE (( _T("CModemAtPipeController::HandlePipeEnabledResp()") ));
+    TInt error = aReceivedMessage.Get8bit(ISI_HEADER_SIZE + 
+      PNS_PIPE_ENABLE_RESP_OFFSET_ERRORCODE);
+    TInt pipeHandle = aReceivedMessage.Get8bit(ISI_HEADER_SIZE + 
+      PNS_PIPE_ENABLE_RESP_OFFSET_PIPEHANDLE);
+    TInt dteId = FindDteId(pipeHandle);           
+    C_TRACE((_L("CModemAtPipeController::HandlePipeEnabledResp() pipehandle %d"), pipeHandle));
+       
+    if( error == PN_PIPE_NO_ERROR )
+        {
+        ChangePipeState( dteId, TPipeInfo::EPipeEnabled );
+        }
+    else
+        {
+        C_TRACE((_L("CModemAtPipeController::HandlePipeEnabledResp() pipe error: %d"), error));
+        TRACE_ASSERT_ALWAYS;
+        }
+    }
+
+
+void CModemAtPipeController::ChangePipeState(
+    const TInt aDteId,
+    TPipeInfo::EPipeState aState )
+    {
+    C_TRACE((_L("CModemAtPipeController::ChangePipeState(%d, %d)"), aDteId, aState));
+    C_TRACE(( _L("Was: iPipeTable[ %d ].iPipeState = %d"), aDteId, (TInt)iPipeTable[ aDteId ].iPipeState ));
+    iPipeTable[ aDteId ].iPipeState = aState;
+    if( aState == TPipeInfo::EPipeEnabled )
+        {
+        C_TRACE(( _T("DATA MODE") ));
+        iAtHandler.HandleCommandModeChange( aDteId, EDataMode );
+        }
+    else if( aState == TPipeInfo::EPipeDisabled )
+        {
+        C_TRACE(( _T("COMMAND MODE") ));
+        iAtHandler.HandleCommandModeChange( aDteId, ECommandMode );
+        }
+    }
+
+void CModemAtPipeController::HandlePepStatusInd( const TIsiReceiveC& aReceivedMessage )
+    {
+    C_TRACE(( _L("CModemAtPipeController::HandlePepStatusInd")));
+    TUint8 pepType( aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 
+      PNS_PEP_STATUS_IND_OFFSET_PEPTYPE ) );
+    if( pepType == PN_PEP_TYPE_COMM )
+        {
+        TUint8 indicationId( aReceivedMessage.Get8bit( ISI_HEADER_SIZE + 
+          PNS_PEP_STATUS_IND_OFFSET_INDICATIONID ) );
+        if( indicationId == PEP_COMM_IND_ID_ESCAPE )
+            {
+            TUint8 pipeHandle( aReceivedMessage.Get8bit( ISI_HEADER_SIZE +
+              PNS_PEP_STATUS_IND_OFFSET_PIPEHANDLE ) );
+            TInt dteId( FindDteId( pipeHandle ) );           
+            C_TRACE( (_L("CModemAtPipeController PEP_COMM_IND_ID_ESCAPE received, pipehandle %d dteid %d"), pipeHandle, dteId ));
+
+            if( dteId != KInvalidDteId )
+                {
+                C_TRACE( (_L("SendEscapeSignalDetection dteid %d"), dteId ));
+                iAtHandler.SendEscapeSignalDetection( dteId );
+                }
+            }
+        // Not know should any other indicationid from comm pep type to be handled
+        else
+            {
+            C_TRACE((_L("CModemAtPipeController Indication ignored pepType %d indicationId: %d "), pepType, indicationId));
+            }
+        }
+        // pep type comm only supported one
+     else
+        {
+        C_TRACE((_L("CModemAtPipeController Peptype ignored %d "), pepType));
+        }
+    }
+
+ #endif // NCP_COMMON_BRIDGE_FAMILY
+