diff -r 000000000000 -r 63b37f68c1ce adaptationlayer/modematadaptation/modematcontroller_exe/src/cmodemathandler.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/adaptationlayer/modematadaptation/modematcontroller_exe/src/cmodemathandler.cpp	Fri Nov 06 17:28:23 2009 +0000
@@ -0,0 +1,696 @@
+/*
+* 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 <e32std.h>
+#include <iscapi.h>
+#include <iscnokiadefinitions.h>
+#include <pn_const.h>
+#ifndef NCP_COMMON_BRIDGE_FAMILY       
+#include <nsisi.h>
+#endif
+#include <pipeisi.h>
+#include <pipe_sharedisi.h>
+#include <tisi.h>
+#include <at_modemisi.h>
+#include "cmodemathandler.h"
+#include "cmodematpipecontroller.h"
+#include "modemattrace.h"
+#include "cmodematsrv.h"
+
+#define KCommandBits 0x0f
+#define KMaxBufferLength 1024
+#define KTransactionIdBitsShift 4
+#define KFiller 0
+#define KIndicationOrderMsgLength 14
+#define KObjectIdLength 2
+#define KEightBits 8
+#define KDefaultTId 0
+
+const TInt KUnsubscribeFourEvents(4);
+const TInt KAlignToFourBytes(4);
+
+#ifdef __WINSCW__
+#define KEmulatedReplyMsgLength 50
+#endif
+
+CModemAtHandler* CModemAtHandler::NewL( CModemAtSrv& aServer )
+    {
+    CModemAtHandler* self = new (ELeave) CModemAtHandler( aServer );
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    return self;
+    }
+
+CModemAtHandler::~CModemAtHandler()
+    {
+    C_TRACE(( _T("CModemAtHandler::~CModemAtHandler()") ));
+    TBuf8<KUnsubscribeFourEvents> events;
+    events.Append( KFiller );
+    events.Append( KFiller );  
+    events.Append( KFiller );
+    events.Append( KFiller );
+
+    if( iIscApi )
+        {
+        iIscApi->CustomFunction( EIscNokiaEventSubscribe, &events );
+        }
+
+    if(iPipeController)
+        {
+        delete iPipeController;
+        iPipeController = NULL;
+        } 
+    Cancel();
+
+    if( iIscApi )
+        {
+        iIscApi->Close();
+        delete iIscApi;
+        }
+   }
+
+CModemAtHandler::CModemAtHandler( CModemAtSrv& aServer )
+    : CActive( EPriorityHigh ),
+    iServer( aServer ),
+    iIscApi( NULL ),
+    iReceivedMessageBuffer( NULL ),
+    iMessageBufferSize( KMaxBufferLength ),
+    iReceivePtr( 0, 0 ),
+    iReceiveMessageLength( 0 ),
+    iReceivedMessage( NULL ),
+    iPepObjId(0),
+    iPipeController(NULL),
+    iDisconnected( EFalse )
+    {
+    C_TRACE (( _T("CModemAtHandler::CModemAtHandler") ));
+    
+    }
+
+void CModemAtHandler::DoCancel()
+    {
+    C_TRACE (( _T("CModemAtHandler::DoCancel()") ));
+    iIscApi->ReceiveCancel();
+    
+    }
+
+
+void CModemAtHandler::RunL()
+    {
+    C_TRACE (( _T("CModemAtHandler::RunL()") ));
+   
+    if( iStatus == KErrNone ) 
+        {
+        TIsiReceiveC receiveMessage = TIsiReceiveC( *iReceivedMessageBuffer );
+        DUMP_MESSAGE( iReceivePtr );
+            
+        if( iReceivedMessageBuffer->Length() > ISI_HEADER_OFFSET_MESSAGEID )
+            {
+            switch(receiveMessage.Get8bit(ISI_HEADER_OFFSET_RESOURCEID))
+                {
+                case PN_AT_MODEM: //AT MODEM COMMANDS
+                    C_TRACE(_L("PN_AT_MODEM"));
+
+                    switch( receiveMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) )
+                        {
+                        case AT_MODEM_CONNECT_RESP: 
+                            HandleModemConnectResp( receiveMessage );
+                            break;
+
+                        case AT_MODEM_DISCONNECT_RESP:
+                            C_TRACE(_L("AT_MODEM_DISCONNECT_RESP"));
+                            break;
+
+                        case AT_MODEM_CMD_RESP:
+                            HandleATResponse( receiveMessage );
+                            break;
+
+                        case AT_MODEM_SIGNAL_IND:
+                            HandleSignalInd( receiveMessage );
+                            break;
+
+                        case AT_MODEM_UNSOLICITED_DATA_IND:
+                            HandleUnsolicitedData( receiveMessage );
+                            break;
+
+                        case AT_MODEM_INTERMEDIATE_DATA_IND:
+                            HandleIntermediateDataInd( receiveMessage );
+                            break;
+
+                        case AT_MODEM_DATA_REDIRECT_IND:
+                            HandleRedirectInd( receiveMessage );
+                            break;
+                            
+                        case AT_MODEM_DATA_REDIRECT_RESULT_RESP:
+                            C_TRACE((_L("AT_MODEM_DATA_REDIRECT_RESULT_RESP")));
+                            HandleRedirectResultResp( receiveMessage );
+                            break;
+
+                        case AT_MODEM_SIGNAL_DETECTED_RESP:
+                            C_TRACE((_L("AT_MODEM_SIGNAL_DETECTED_RESP")));
+                            HandleSignalDetectedResp(  receiveMessage  );
+                            break;
+                        default: 
+                            C_TRACE(_L("CModemAtHandler::RunL: Not a valid message"))  ;
+                            TRACE_ASSERT_ALWAYS;
+                            break;
+                         } //switch( receiveMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) )
+                        
+                    break;  //case PN_AT_MODEM: //AT MODEM COMMANDS
+
+#ifndef NCP_COMMON_BRIDGE_FAMILY
+                case PN_NAME_SERVICE: 
+                    C_TRACE(_L("PN_NAME_SERVICE"));
+                    iPipeController->HandleNameServiceMessage(receiveMessage);
+                    break;
+
+                case PN_PIPE:
+                    C_TRACE(_L("Pipe message"));
+                    iPipeController->HandlePipeServiceMessage(receiveMessage);
+                    break;
+#endif
+                default:  
+                    C_TRACE((_L("Unknown resource id")));
+                    TRACE_ASSERT_ALWAYS;
+                    break; 
+                }
+                
+            } //if( receiveMessageBuffer->Length() > ISI_HEADER_OFFSET_MESSAGEID )
+        else 
+            {
+            C_TRACE(_L("ISI essage is too short"));
+            TRACE_ASSERT_ALWAYS;
+            }
+        
+        //Start receiving ISI messages again
+        iReceivePtr.Set( iReceivedMessageBuffer->Des() );
+        iIscApi->Receive( iStatus, iReceivePtr, iReceiveMessageLength );
+        SetActive();
+        } // if( iStatus == KErrNone )
+    else 
+        {
+        TRACE_ASSERT_ALWAYS;
+        } 
+    }
+
+
+void CModemAtHandler::ConstructL()
+    {
+   C_TRACE (( _T("CModemAtHandler::ConstructL()") ));
+
+    CActiveScheduler::Add( this );
+    
+    iIscApi = new ( ELeave ) RIscApi;
+    C_TRACE(_L("RIscApi created"));
+
+    //used with intermediate data ind
+    //can be removed, when AT_MODEM_INTERMEDIATE_DATA_IND supports transactionid 
+    for( TInt i = 0 ; i < KMaxDteIdCount ; i++) 
+        {
+        iLastTransactionId[i]=0;
+        }
+    
+#ifndef __WINSCW__
+      OpenChannelL();
+#ifndef NCP_COMMON_BRIDGE_FAMILY
+      iPipeController->SendTaskIdQuery();
+#endif
+#else
+      iEmulatedValue = 0;
+#endif
+    
+    }
+
+
+TInt CModemAtHandler::GetMinSizeDividendByFour( TInt aSize)
+    {
+     C_TRACE (( _T("CModemAtHandler::GetMinSizeDividendByFour(%d)"),aSize ));
+     aSize += aSize % KAlignToFourBytes;
+      
+     C_TRACE (( _T("CModemAtHandler::GetMinSizeDividendByFour return: %d"),aSize ));
+     return aSize;
+    }
+
+TInt CModemAtHandler::SendATCommand(const TUint8 aDteId,
+    const TATPluginInterface aPluginType,
+    const TUint8 aMessageType,
+    const TDesC8& aCmd)
+    {
+    C_TRACE (( _T(">>CModemAtHandler::SendATCommand()") ));
+
+    TInt err = KErrNone;
+    // aMessageType contains normal AT-cmd (0) or Nvram-query (1)
+    TUint transactionId= (aPluginType << KTransactionIdBitsShift) | aMessageType;
+    //used with intermediate data ind
+    //can be removed, when AT_MODEM_INTERMEDIATE_DATA_IND supports transactionid        
+    iLastTransactionId[aDteId] = transactionId;  //messages are routed to correct plugin by transaction id
+    C_TRACE((_L("transaction id %d, plugintype %d, aMessageType %d"), transactionId, aPluginType, aMessageType));
+    C_TRACE((_L("iLastTransctionId[%d] = %d "),aDteId,iLastTransactionId[aDteId]));
+
+    #ifdef __WINSCW__
+    iDteId = aDteId;
+    iChannel = aMessageType;
+    iPluginType = aPluginType;
+    HandleATResponse();
+    return KErrNone;
+    #endif
+
+    TInt size = ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_CMDLINEBUFFER + aCmd.Length();
+    
+    TInt sizeWithFillers = GetMinSizeDividendByFour( size );
+    C_TRACE((_L("Message length %d"), sizeWithFillers));
+
+    HBufC8* message = HBufC8::New( sizeWithFillers );
+    if( message )
+      {
+      TPtr8 messageptr = message->Des();
+      TIsiSend isimessage( messageptr, sizeWithFillers );
+      isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM );       
+      isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_TID, transactionId );
+      isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_MESSAGEID, AT_MODEM_CMD_REQ );
+      isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_DTEID, aDteId );
+      isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_FILLERBYTE1, 0 );
+      C_TRACE((_L("AT command length: %d"), aCmd.Length()));
+      isimessage.Set16bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_LENGTH, (TUint16) aCmd.Length() );
+
+      const TUint8* ptr = aCmd.Ptr();
+      for ( TInt i = 0; i < aCmd.Length(); i++ )
+          {
+          C_TRACE((_L("message %d, 0x%x '%c'"), i, ptr[i], ptr[i]));
+          isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_CMDLINEBUFFER + i, ptr[i]);
+          }
+
+      for( TInt j = sizeWithFillers; j < size; j++ )
+          {
+          C_TRACE((_L("Add filler [%d]"), j));
+          isimessage.Set8bit( j , KFiller );
+          }
+
+      isimessage.Complete();
+      C_TRACE(_L("Created ISI-message"));
+      DUMP_MESSAGE( messageptr );
+
+      err = iIscApi->Send( messageptr );
+      TRACE_ASSERT( err == KErrNone );
+      delete message;
+      message = NULL;
+      }
+    else
+      {
+      C_TRACE(_L("No memory - error in sending ISI message from heap"));
+      TRACE_ASSERT_ALWAYS;
+      }
+    C_TRACE (( _T("<<CModemAtHandler::SendATCommand() err: %d"), err ));
+    return err;
+    }
+
+void CModemAtHandler::OpenChannelL()
+    {
+    C_TRACE (( _T("CModemAtHandler::OpenChannelL()") ));
+    TRequestStatus openStatus;
+
+    iIscApi->Open( EIscNokiaAtController, openStatus, EOwnerThread );
+    User::WaitForRequest( openStatus );
+
+    TRACE_ASSERT( !openStatus.Int());
+    
+    if( iReceivedMessageBuffer )
+        {
+        delete iReceivedMessageBuffer;
+        iReceivedMessageBuffer = NULL;
+        }
+
+    iReceivedMessageBuffer = HBufC8::NewL(iMessageBufferSize);
+    TRACE_ASSERT(iReceivedMessageBuffer);
+    iReceivePtr.Set( iReceivedMessageBuffer->Des() );
+
+    C_TRACE(_L("Start receive ISI messages"));
+    iIscApi->Receive( iStatus, iReceivePtr, iReceiveMessageLength );
+
+    SetActive();
+    
+    C_TRACE(_L("Start receive indications"));
+    TBuf8<KIndicationOrderMsgLength> events;
+    events.Append( PN_AT_MODEM );
+    events.Append( AT_MODEM_INTERMEDIATE_DATA_IND );  
+    events.Append( PN_AT_MODEM );
+    events.Append( AT_MODEM_SIGNAL_IND );  
+    events.Append( PN_AT_MODEM );
+    events.Append( AT_MODEM_UNSOLICITED_DATA_IND );  
+    events.Append( PN_AT_MODEM );
+    events.Append( AT_MODEM_DATA_REDIRECT_IND );  
+    events.Append( PN_PIPE );
+    events.Append( PNS_PEP_STATUS_IND );
+
+#ifndef NCP_COMMON_BRIDGE_FAMILY       
+    //name add ind
+    events.Append( PN_NAMESERVICE );
+    events.Append( PNS_NAME_ADD_IND );  
+    events.Append( PN_NAMESERVICE );
+    events.Append( PNS_NAME_REMOVE_IND );
+#else
+    events.Append( 0 );
+    events.Append( 0 );  
+    events.Append( 0 );
+    events.Append( 0 );
+#endif
+    
+    iIscApi->CustomFunction(EIscNokiaEventSubscribe,&events);
+    TBuf8<KObjectIdLength> objId;
+    iIscApi->GetChannelInfo(EIscNokiaAtController, objId);
+    
+    iPepObjId = (((TUint16)(objId[0]))<<KEightBits) + objId[1];
+    C_TRACE((_L("PepObjId 0x%x"),iPepObjId));
+    iPipeController = CModemAtPipeController::NewL(*iIscApi, iPepObjId, *this); 
+    C_TRACE((_L("iPipeController 0x%x"),iPipeController ));
+    ASSERT_PANIC_ALWAYS( iPipeController );
+    }
+
+
+void CModemAtHandler::HandleATResponse( const TIsiReceiveC& aMessage )
+    {
+    C_TRACE (( _T("CModemAtHandler::HandleATResponse()") ));
+    
+    TInt dteId = aMessage.Get8bit( ISI_HEADER_SIZE+ AT_MODEM_CMD_RESP_OFFSET_DTEID ) ;
+    TUint transactionId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_TID );
+    TUint8 command = transactionId & KCommandBits; //normal AT-cmd or Nvram-query
+    TInt length = aMessage.Get16bit( ISI_HEADER_SIZE+AT_MODEM_CMD_RESP_OFFSET_LENGTH );
+    C_TRACE(( _L("DteId: %d AT (0) or nvram command (1): %d Response length %d"), dteId, command, length ));
+
+    /**
+     * Plugintype can be read from transaction id:
+     * TUint8 pluginType = transactionId >> KTransactionIdBitsShift;
+     * (TATPluginInterface) pluginType
+     *
+     * Current implementation uses first in first out response completion
+     * so plugintype is not needed.
+     */
+    C_TRACE(( _L("Plugintype: %d"), transactionId >> KTransactionIdBitsShift ));
+    
+    iServer.HandleATResponse( dteId,  
+      aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_CMDLINEBUFFER, length),
+      command );
+    }
+
+#ifdef __WINSCW__
+void CModemAtHandler::HandleATResponse( )
+    {
+    C_TRACE (( _T("CModemAtHandler::HandleATResponse()") ));
+    //reply back immediately
+    const TInt KReplyLength(50);
+    TBuf8<KReplyLength> replyEmulated = _L8("\r\nAT TEST REPLY");
+    replyEmulated.AppendNum(iEmulatedValue++);
+    replyEmulated.Append(_L8("\r\n"));
+    iServer.HandleATResponse( iDteId, replyEmulated, 0 /* 0 = AT-cmd, 1 = nvram */);
+    }
+#endif
+
+    
+TInt CModemAtHandler::Connect(const TUint8 aDteId)
+    {
+   C_TRACE (( _T("CModemAtHandler::Connect()") ));
+
+    C_TRACE((_L("Connecting with dteid:%d "), aDteId));
+    SetDisconnected( EFalse );
+    
+    #ifdef __WINSCW__ //emulate, modem is connected
+    iServer.BroadcastModemConnected( aDteId, KErrNone );
+    iDteId = aDteId;
+    return KErrNone;
+    #endif
+#ifndef NCP_COMMON_BRIDGE_FAMILY
+    iPipeController->LinkDteIdToPipe( aDteId );
+#endif
+    TInt size = ISI_HEADER_SIZE + SIZE_AT_MODEM_CONNECT_REQ;
+    
+    HBufC8* message = HBufC8::New( size );
+    TRACE_ASSERT( message );
+    TPtr8 messageptr = message->Des();
+    TIsiSend isimessage( messageptr, size );
+    isimessage.Set8bit(ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM); 
+    isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_TID, KDefaultTId);
+    isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_MESSAGEID, AT_MODEM_CONNECT_REQ);
+    isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_DTEID, aDteId);
+    isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_FILLERBYTE1, KFiller);
+    isimessage.Complete();
+
+    DUMP_MESSAGE( messageptr );
+    TInt err = iIscApi->Send( messageptr );
+    TRACE_ASSERT( err == KErrNone );
+    delete message;
+    message = NULL;
+    return err;
+    }
+
+void CModemAtHandler::SetDisconnected( TBool aIsDisconnected )
+    {
+    C_TRACE (( _T("CModemAtHandler::SetDisconnected(%d)"),aIsDisconnected ));
+    iDisconnected = aIsDisconnected;
+    }
+
+TBool CModemAtHandler::IsDisconnected()
+    {
+    C_TRACE (( _T("CModemAtHandler::IsDisconnected(%d)"),iDisconnected ));
+    return iDisconnected;
+    }
+
+TBool CModemAtHandler::IsPluginConnected()
+    {
+    C_TRACE (( _T("CModemAtHandler::IsPluginConnected() sessions: %d"), iServer.SessionCount() ));
+    return iServer.SessionCount() > 0;
+    }
+
+void CModemAtHandler::RemovePipe( const TUint8 aDteId )
+    {
+    C_TRACE(( _T("CModemAtHandler::RemovePipe()")));
+    iDisconnected = ETrue;
+#ifndef NCP_COMMON_BRIDGE_FAMILY
+    iPipeController->RemovePipe( aDteId );
+#endif
+    }
+
+TInt CModemAtHandler::Disconnect( const TUint8 aDteId )
+    {
+    C_TRACE (( _T("CModemAtHandler::Disconnect(%d)"),aDteId ));
+    #ifdef __WINSCW__
+    iDteId = aDteId;
+    return KErrNone;
+    #endif
+ 
+    TInt size = ISI_HEADER_SIZE + SIZE_AT_MODEM_DISCONNECT_REQ;
+    HBufC8* message = HBufC8::New( size );
+    TRACE_ASSERT( message );
+    TPtr8 messageptr = message->Des();
+    TIsiSend isimessage( messageptr, size );
+    isimessage.Set8bit(ISI_HEADER_OFFSET_RESOURCEID,PN_AT_MODEM);
+    isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_TID, 0);
+    isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_MESSAGEID,
+      AT_MODEM_DISCONNECT_REQ);
+    isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_DTEID, aDteId);
+    isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_FILLERBYTE1, KFiller);
+    isimessage.Complete();
+
+    C_TRACE (( _T("CModemAtHandler::Disconnect Sending AT_MODEM_DISCONNECT_REQ")));
+    TInt err = iIscApi->Send(messageptr);
+    TRACE_ASSERT( err == KErrNone );
+    delete message;
+    return err;
+    }
+
+
+
+void CModemAtHandler::HandleModemConnectResp( const TIsiReceiveC& aMessage )
+    {
+    C_TRACE (( _T("CModemAtHandler::HandleModemConnectResp()") ));
+    TInt dteId= aMessage.Get8bit(ISI_HEADER_SIZE+ AT_MODEM_CONNECT_RESP_OFFSET_DTEID);
+    TInt status = aMessage.Get8bit(ISI_HEADER_SIZE+ AT_MODEM_CONNECT_RESP_OFFSET_RESULT);
+    TInt err = KErrGeneral;
+    if( status == AT_MODEM_RESULT_OK )
+        {
+        C_TRACE(_L("Connected ok, AT_MODEM_RESULT_OK received"));
+        err = KErrNone;
+        }   
+    else 
+        {
+        C_TRACE((_L("Connection failed, AT_MODEM_RESULT_ERROR received (%d)"),status));
+        TRACE_ASSERT_ALWAYS;
+        }
+
+    iServer.BroadcastModemConnected( dteId, err );
+    }
+
+
+void CModemAtHandler::HandleSignalInd( const TIsiReceiveC& aMessage )
+    {
+    C_TRACE (( _T("CModemAtHandler::HandleSignalInd()") ));
+    TInt dteId = aMessage.Get8bit(ISI_HEADER_SIZE+ AT_MODEM_SIGNAL_IND_OFFSET_DTEID);
+    iServer.HandleSignalInd( dteId );
+    }
+
+void CModemAtHandler::HandleUnsolicitedData( const TIsiReceiveC& aMessage )
+    {
+    C_TRACE (( _T("CModemAtHandler::HandleUnsolicitedData()") ));
+    TInt dteId = aMessage.Get8bit( ISI_HEADER_SIZE+ AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_LENGTH );
+    TInt length = aMessage.Get16bit( ISI_HEADER_SIZE+AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_LENGTH );
+    
+    iServer.HandleUnsolicitedData( dteId,
+      aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_UNSOLICITEDDATABUFFER,
+      length ) );
+    }
+
+
+void CModemAtHandler::HandleIntermediateDataInd( const TIsiReceiveC& aMessage )
+    {
+    C_TRACE (( _T("CModemAtHandler::HandleIntermediateDataInd()") ));
+    TInt dteId = aMessage.Get8bit( ISI_HEADER_SIZE+ AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_DTEID );
+    TInt length= aMessage.Get16bit( ISI_HEADER_SIZE+AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_LENGTH );
+     
+    TUint transactionId = aMessage.Get8bit( ISI_HEADER_SIZE+ AT_MODEM_CMD_RESP_OFFSET_TID );
+    transactionId = iLastTransactionId[ dteId ];
+    TUint8 command = transactionId & KCommandBits;
+    TUint8 pluginType = transactionId >> KTransactionIdBitsShift;
+    C_TRACE((_L("dteid %d iLastrid[dteid] = %d trid %d"), dteId, iLastTransactionId[dteId], transactionId));
+    
+    iServer.HandleIntermediateDataInd( dteId,
+      (TATPluginInterface) pluginType,
+      aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_INTERMEDIATEDATABUFFER,
+      length),
+      command );
+    }
+
+
+void CModemAtHandler::HandleRedirectInd( const TIsiReceiveC& aMessage ) 
+    {
+    C_TRACE (( _T("CModemAtHandler::HandleRedirectInd()") ));
+  
+    TInt dteId = aMessage.Get8bit( ISI_HEADER_SIZE+  AT_MODEM_DATA_REDIRECT_IND_OFFSET_DTEID );
+    TInt newSecondDevId = aMessage.Get8bit( ISI_HEADER_SIZE +  AT_MODEM_DATA_REDIRECT_IND_OFFSET_DEVICEID );
+    TInt newSecondObjId = aMessage.Get16bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_IND_OFFSET_SERVERID );
+#ifndef NCP_COMMON_BRIDGE_FAMILY
+    iPipeController->RedirectPipe( dteId, newSecondDevId, newSecondObjId ); 
+#endif
+    }
+
+void CModemAtHandler::SendAtModemDataRedirectResultReq( const TUint8 aDteId, const TUint aResult )
+    {
+    C_TRACE (( _T("CModemAtHandler::SendAtModemDataRedirectResultReq()") ));
+    HBufC8* message = HBufC8::New( ISI_HEADER_SIZE + SIZE_AT_MODEM_DATA_REDIRECT_RESULT_REQ );
+    C_TRACE((_L("Sending AT_MODEM_DATA_REDIRECT_RESULT_REQ dteid %d result %d"), aDteId, aResult));
+    
+    TPtr8 messageptr = message->Des();
+    TIsiSend isimessage( messageptr, ISI_HEADER_SIZE + SIZE_AT_MODEM_DATA_REDIRECT_RESULT_REQ );
+    isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM);       
+    isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_TID, 0 );
+    isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_MESSAGEID,
+      AT_MODEM_DATA_REDIRECT_RESULT_REQ );
+    isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_DTEID ,aDteId );
+    isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_RESULT ,aResult );
+    isimessage.Complete();
+        
+    C_TRACE(_L("Created ISI-message"));
+    for( TInt i = 0 ; i < (ISI_HEADER_SIZE + SIZE_AT_MODEM_DATA_REDIRECT_RESULT_REQ); i++ ) 
+        {
+        C_TRACE((_L("[%d] 0x%x"),i ,(*message)[i]) );
+        }
+
+    TInt err = iIscApi->Send( messageptr );
+    TRACE_ASSERT( err == KErrNone );
+    delete message;
+    message = NULL;
+    }
+
+
+void CModemAtHandler::HandleRedirectResultResp(const TIsiReceiveC& aMessage)
+    {
+    C_TRACE (( _T("CModemAtHandler::HandleRedirectResultResp()") ));
+    TInt dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_RESP_OFFSET_DTEID );
+    TInt error = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_RESP_OFFSET_RESULT );
+    C_TRACE((_L("CModemAtHandler::HandleRedirectResultResp() dte %d"), dteId));
+    
+    if( error == AT_MODEM_RESULT_ERROR ) 
+        {
+        C_TRACE(_L("CModemAtHandler::HandleRedirectResultResp() AT_MODEM_RESULT_ERROR received, redirect failed"));
+        TRACE_ASSERT_ALWAYS;
+        }
+    else 
+        {
+        C_TRACE(_L("CModemAtHandler::HandleRedirectResultResp() redirect OK"));
+        }
+    
+    }
+void CModemAtHandler::HandleCommandModeChange( TInt aDteId, TCommandMode aMode )
+    {
+    C_TRACE(( _T("CModemAtHandler::HandleCommandModeChange() aDteId: %d aMode: %d"),aDteId, (TInt) aMode ));
+    iServer.HandleCommandModeChange( aDteId, aMode );
+    }
+
+TInt CModemAtHandler::SendEscapeSignalDetection( const TUint8 aDteId )
+    {
+    C_TRACE((_T("CModemAtHandler::SendEscapeSignalDetection(%d)"), aDteId));
+    #ifdef __WINSCW__
+    iDteId = aDteId;
+    return KErrNone;
+    #endif
+  
+    TInt error( KErrGeneral );  
+    TUint msgSize( ISI_HEADER_SIZE + SIZE_AT_MODEM_SIGNAL_DETECTED_REQ );
+    TUint size( msgSize + SIZE_AT_MODEM_SB_SIGNAL_DETECTED ); 
+    HBufC8* message = HBufC8::New( size );
+    if( message )
+      {
+      TPtr8 messageptr = message->Des();
+      TIsiSend isimessage( messageptr, size );
+      isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM );
+      isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_TID, 0x00 );
+      isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_MESSAGEID,
+        AT_MODEM_SIGNAL_DETECTED_REQ );
+      isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_DTEID, aDteId );
+      isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_NOOFSUBBLOCKS, 0x01 );
+      isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_SUBBLOCKID,
+        AT_MODEM_SB_SIGNAL_DETECTED );
+      isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_SUBBLOCKLENGTH,
+        SIZE_AT_MODEM_SB_SIGNAL_DETECTED );
+      isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_TYPEOFSIGNALDETECTED,
+        AT_MODEM_SIGNAL_ESCAPE_DETECTED );
+      isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_FILLERBYTE1, 0x00 );
+      isimessage.Complete();
+      error = iIscApi->Send(messageptr);
+        C_TRACE((_L("escape send result %d"), error ));
+      delete message;
+      message = NULL;
+      }
+    else
+      {
+      ASSERT_ALWAYS;
+      error = KErrNoMemory;
+      }
+    return error; 
+    }
+
+
+void CModemAtHandler::HandleSignalDetectedResp( const TIsiReceiveC& aMessage )
+    {
+    C_TRACE (( _T("CModemAtHandler::HandleSignalDetectedResp() escape sequence detect response received from cellmo") ));
+    TInt dteId( aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_RESP_OFFSET_DTEID ) );
+    TRACE_ASSERT( dteId < KMaxDteIdCount );
+    TInt result = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_RESP_OFFSET_RESULT );
+    C_TRACE((_L("CModemAtHandler::HandleSignalDetectedResp() dteId %d"), dteId));
+    TRACE_ASSERT( result == AT_MODEM_RESULT_OK );
+    }
+