1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 * 

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 

    20 #include <e32std.h>

    21 #include <iscapi.h>

    22 #include <iscnokiadefinitions.h>

    23 #include <pn_const.h>

    24 #ifndef NCP_COMMON_BRIDGE_FAMILY       

    25 #include <nsisi.h>

    26 #endif

    27 #include <pipeisi.h>

    28 #include <pipe_sharedisi.h>

    29 #include <tisi.h>

    30 #include <at_modemisi.h>

    31 #include "cmodemathandler.h"

    32 #include "cmodematpipecontroller.h"

    33 #include "modemattrace.h"

    34 #include "cmodematsrv.h"

    35 

    36 #define KCommandBits 0x0f

    37 #define KMaxBufferLength 1024

    38 #define KTransactionIdBitsShift 4

    39 #define KFiller 0

    40 #define KIndicationOrderMsgLength 14

    41 #define KObjectIdLength 2

    42 #define KEightBits 8

    43 #define KDefaultTId 0

    44 

    45 const TInt KUnsubscribeFourEvents(4);

    46 const TInt KAlignToFourBytes(4);

    47 

    48 #ifdef __WINSCW__

    49 #define KEmulatedReplyMsgLength 50

    50 #endif

    51 

    52 CModemAtHandler* CModemAtHandler::NewL( CModemAtSrv& aServer )

    53     {

    54     CModemAtHandler* self = new (ELeave) CModemAtHandler( aServer );

    55     CleanupStack::PushL( self );

    56     self->ConstructL();

    57     CleanupStack::Pop( self );

    58     return self;

    59     }

    60 

    61 CModemAtHandler::~CModemAtHandler()

    62     {

    63     C_TRACE(( _T("CModemAtHandler::~CModemAtHandler()") ));

    64     TBuf8<KUnsubscribeFourEvents> events;

    65     events.Append( KFiller );

    66     events.Append( KFiller );  

    67     events.Append( KFiller );

    68     events.Append( KFiller );

    69 

    70     if( iIscApi )

    71         {

    72         iIscApi->CustomFunction( EIscNokiaEventSubscribe, &events );

    73         }

    74 

    75     if(iPipeController)

    76         {

    77         delete iPipeController;

    78         iPipeController = NULL;

    79         } 

    80     Cancel();

    81 

    82     if( iIscApi )

    83         {

    84         iIscApi->Close();

    85         delete iIscApi;

    86         }

    87    }

    88 

    89 CModemAtHandler::CModemAtHandler( CModemAtSrv& aServer )

    90     : CActive( EPriorityHigh ),

    91     iServer( aServer ),

    92     iIscApi( NULL ),

    93     iReceivedMessageBuffer( NULL ),

    94     iMessageBufferSize( KMaxBufferLength ),

    95     iReceivePtr( 0, 0 ),

    96     iReceiveMessageLength( 0 ),

    97     iReceivedMessage( NULL ),

    98     iPepObjId(0),

    99     iPipeController(NULL),

   100     iDisconnected( EFalse )

   101     {

   102     C_TRACE (( _T("CModemAtHandler::CModemAtHandler") ));

   103     

   104     }

   105 

   106 void CModemAtHandler::DoCancel()

   107     {

   108     C_TRACE (( _T("CModemAtHandler::DoCancel()") ));

   109     iIscApi->ReceiveCancel();

   110     

   111     }

   112 

   113 

   114 void CModemAtHandler::RunL()

   115     {

   116     C_TRACE (( _T("CModemAtHandler::RunL()") ));

   117    

   118     if( iStatus == KErrNone ) 

   119         {

   120         TIsiReceiveC receiveMessage = TIsiReceiveC( *iReceivedMessageBuffer );

   121         DUMP_MESSAGE( iReceivePtr );

   122             

   123         if( iReceivedMessageBuffer->Length() > ISI_HEADER_OFFSET_MESSAGEID )

   124             {

   125             switch(receiveMessage.Get8bit(ISI_HEADER_OFFSET_RESOURCEID))

   126                 {

   127                 case PN_AT_MODEM: //AT MODEM COMMANDS

   128                     C_TRACE(_L("PN_AT_MODEM"));

   129 

   130                     switch( receiveMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) )

   131                         {

   132                         case AT_MODEM_CONNECT_RESP: 

   133                             HandleModemConnectResp( receiveMessage );

   134                             break;

   135 

   136                         case AT_MODEM_DISCONNECT_RESP:

   137                             C_TRACE(_L("AT_MODEM_DISCONNECT_RESP"));

   138                             break;

   139 

   140                         case AT_MODEM_CMD_RESP:

   141                             HandleATResponse( receiveMessage );

   142                             break;

   143 

   144                         case AT_MODEM_SIGNAL_IND:

   145                             HandleSignalInd( receiveMessage );

   146                             break;

   147 

   148                         case AT_MODEM_UNSOLICITED_DATA_IND:

   149                             HandleUnsolicitedData( receiveMessage );

   150                             break;

   151 

   152                         case AT_MODEM_INTERMEDIATE_DATA_IND:

   153                             HandleIntermediateDataInd( receiveMessage );

   154                             break;

   155 

   156                         case AT_MODEM_DATA_REDIRECT_IND:

   157                             HandleRedirectInd( receiveMessage );

   158                             break;

   159                             

   160                         case AT_MODEM_DATA_REDIRECT_RESULT_RESP:

   161                             C_TRACE((_L("AT_MODEM_DATA_REDIRECT_RESULT_RESP")));

   162                             HandleRedirectResultResp( receiveMessage );

   163                             break;

   164 

   165                         case AT_MODEM_SIGNAL_DETECTED_RESP:

   166                             C_TRACE((_L("AT_MODEM_SIGNAL_DETECTED_RESP")));

   167                             HandleSignalDetectedResp(  receiveMessage  );

   168                             break;

   169                         default: 

   170                             C_TRACE(_L("CModemAtHandler::RunL: Not a valid message"))  ;

   171                             TRACE_ASSERT_ALWAYS;

   172                             break;

   173                          } //switch( receiveMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) )

   174                         

   175                     break;  //case PN_AT_MODEM: //AT MODEM COMMANDS

   176 

   177 #ifndef NCP_COMMON_BRIDGE_FAMILY

   178                 case PN_NAME_SERVICE: 

   179                     C_TRACE(_L("PN_NAME_SERVICE"));

   180                     iPipeController->HandleNameServiceMessage(receiveMessage);

   181                     break;

   182 

   183                 case PN_PIPE:

   184                     C_TRACE(_L("Pipe message"));

   185                     iPipeController->HandlePipeServiceMessage(receiveMessage);

   186                     break;

   187 #endif

   188                 default:  

   189                     C_TRACE((_L("Unknown resource id")));

   190                     TRACE_ASSERT_ALWAYS;

   191                     break; 

   192                 }

   193                 

   194             } //if( receiveMessageBuffer->Length() > ISI_HEADER_OFFSET_MESSAGEID )

   195         else 

   196             {

   197             C_TRACE(_L("ISI essage is too short"));

   198             TRACE_ASSERT_ALWAYS;

   199             }

   200         

   201         //Start receiving ISI messages again

   202         iReceivePtr.Set( iReceivedMessageBuffer->Des() );

   203         iIscApi->Receive( iStatus, iReceivePtr, iReceiveMessageLength );

   204         SetActive();

   205         } // if( iStatus == KErrNone )

   206     else 

   207         {

   208         TRACE_ASSERT_ALWAYS;

   209         } 

   210     }

   211 

   212 

   213 void CModemAtHandler::ConstructL()

   214     {

   215    C_TRACE (( _T("CModemAtHandler::ConstructL()") ));

   216 

   217     CActiveScheduler::Add( this );

   218     

   219     iIscApi = new ( ELeave ) RIscApi;

   220     C_TRACE(_L("RIscApi created"));

   221 

   222     //used with intermediate data ind

   223     //can be removed, when AT_MODEM_INTERMEDIATE_DATA_IND supports transactionid 

   224     for( TInt i = 0 ; i < KMaxDteIdCount ; i++) 

   225         {

   226         iLastTransactionId[i]=0;

   227         }

   228     

   229 #ifndef __WINSCW__

   230       OpenChannelL();

   231 #ifndef NCP_COMMON_BRIDGE_FAMILY

   232       iPipeController->SendTaskIdQuery();

   233 #endif

   234 #else

   235       iEmulatedValue = 0;

   236 #endif

   237     

   238     }

   239 

   240 

   241 TInt CModemAtHandler::GetMinSizeDividendByFour( TInt aSize)

   242     {

   243      C_TRACE (( _T("CModemAtHandler::GetMinSizeDividendByFour(%d)"),aSize ));

   244      aSize += aSize % KAlignToFourBytes;

   245       

   246      C_TRACE (( _T("CModemAtHandler::GetMinSizeDividendByFour return: %d"),aSize ));

   247      return aSize;

   248     }

   249 

   250 TInt CModemAtHandler::SendATCommand(const TUint8 aDteId,

   251     const TATPluginInterface aPluginType,

   252     const TUint8 aMessageType,

   253     const TDesC8& aCmd)

   254     {

   255     C_TRACE (( _T(">>CModemAtHandler::SendATCommand()") ));

   256 

   257     TInt err = KErrNone;

   258     // aMessageType contains normal AT-cmd (0) or Nvram-query (1)

   259     TUint transactionId= (aPluginType << KTransactionIdBitsShift) | aMessageType;

   260     //used with intermediate data ind

   261     //can be removed, when AT_MODEM_INTERMEDIATE_DATA_IND supports transactionid        

   262     iLastTransactionId[aDteId] = transactionId;  //messages are routed to correct plugin by transaction id

   263     C_TRACE((_L("transaction id %d, plugintype %d, aMessageType %d"), transactionId, aPluginType, aMessageType));

   264     C_TRACE((_L("iLastTransctionId[%d] = %d "),aDteId,iLastTransactionId[aDteId]));

   265 

   266     #ifdef __WINSCW__

   267     iDteId = aDteId;

   268     iChannel = aMessageType;

   269     iPluginType = aPluginType;

   270     HandleATResponse();

   271     return KErrNone;

   272     #endif

   273 

   274     TInt size = ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_CMDLINEBUFFER + aCmd.Length();

   275     

   276     TInt sizeWithFillers = GetMinSizeDividendByFour( size );

   277     C_TRACE((_L("Message length %d"), sizeWithFillers));

   278 

   279     HBufC8* message = HBufC8::New( sizeWithFillers );

   280     if( message )

   281       {

   282       TPtr8 messageptr = message->Des();

   283       TIsiSend isimessage( messageptr, sizeWithFillers );

   284       isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM );       

   285       isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_TID, transactionId );

   286       isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_MESSAGEID, AT_MODEM_CMD_REQ );

   287       isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_DTEID, aDteId );

   288       isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_FILLERBYTE1, 0 );

   289       C_TRACE((_L("AT command length: %d"), aCmd.Length()));

   290       isimessage.Set16bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_LENGTH, (TUint16) aCmd.Length() );

   291 

   292       const TUint8* ptr = aCmd.Ptr();

   293       for ( TInt i = 0; i < aCmd.Length(); i++ )

   294           {

   295           C_TRACE((_L("message %d, 0x%x '%c'"), i, ptr[i], ptr[i]));

   296           isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_CMDLINEBUFFER + i, ptr[i]);

   297           }

   298 

   299       for( TInt j = sizeWithFillers; j < size; j++ )

   300           {

   301           C_TRACE((_L("Add filler [%d]"), j));

   302           isimessage.Set8bit( j , KFiller );

   303           }

   304 

   305       isimessage.Complete();

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

   307       DUMP_MESSAGE( messageptr );

   308 

   309       err = iIscApi->Send( messageptr );

   310       TRACE_ASSERT( err == KErrNone );

   311       delete message;

   312       message = NULL;

   313       }

   314     else

   315       {

   316       C_TRACE(_L("No memory - error in sending ISI message from heap"));

   317       TRACE_ASSERT_ALWAYS;

   318       }

   319     C_TRACE (( _T("<<CModemAtHandler::SendATCommand() err: %d"), err ));

   320     return err;

   321     }

   322 

   323 void CModemAtHandler::OpenChannelL()

   324     {

   325     C_TRACE (( _T("CModemAtHandler::OpenChannelL()") ));

   326     TRequestStatus openStatus;

   327 

   328     iIscApi->Open( EIscNokiaAtController, openStatus, EOwnerThread );

   329     User::WaitForRequest( openStatus );

   330 

   331     TRACE_ASSERT( !openStatus.Int());

   332     

   333     if( iReceivedMessageBuffer )

   334         {

   335         delete iReceivedMessageBuffer;

   336         iReceivedMessageBuffer = NULL;

   337         }

   338 

   339     iReceivedMessageBuffer = HBufC8::NewL(iMessageBufferSize);

   340     TRACE_ASSERT(iReceivedMessageBuffer);

   341     iReceivePtr.Set( iReceivedMessageBuffer->Des() );

   342 

   343     C_TRACE(_L("Start receive ISI messages"));

   344     iIscApi->Receive( iStatus, iReceivePtr, iReceiveMessageLength );

   345 

   346     SetActive();

   347     

   348     C_TRACE(_L("Start receive indications"));

   349     TBuf8<KIndicationOrderMsgLength> events;

   350     events.Append( PN_AT_MODEM );

   351     events.Append( AT_MODEM_INTERMEDIATE_DATA_IND );  

   352     events.Append( PN_AT_MODEM );

   353     events.Append( AT_MODEM_SIGNAL_IND );  

   354     events.Append( PN_AT_MODEM );

   355     events.Append( AT_MODEM_UNSOLICITED_DATA_IND );  

   356     events.Append( PN_AT_MODEM );

   357     events.Append( AT_MODEM_DATA_REDIRECT_IND );  

   358     events.Append( PN_PIPE );

   359     events.Append( PNS_PEP_STATUS_IND );

   360 

   361 #ifndef NCP_COMMON_BRIDGE_FAMILY       

   362     //name add ind

   363     events.Append( PN_NAMESERVICE );

   364     events.Append( PNS_NAME_ADD_IND );  

   365     events.Append( PN_NAMESERVICE );

   366     events.Append( PNS_NAME_REMOVE_IND );

   367 #else

   368     events.Append( 0 );

   369     events.Append( 0 );  

   370     events.Append( 0 );

   371     events.Append( 0 );

   372 #endif

   373     

   374     iIscApi->CustomFunction(EIscNokiaEventSubscribe,&events);

   375     TBuf8<KObjectIdLength> objId;

   376     iIscApi->GetChannelInfo(EIscNokiaAtController, objId);

   377     

   378     iPepObjId = (((TUint16)(objId[0]))<<KEightBits) + objId[1];

   379     C_TRACE((_L("PepObjId 0x%x"),iPepObjId));

   380     iPipeController = CModemAtPipeController::NewL(*iIscApi, iPepObjId, *this); 

   381     C_TRACE((_L("iPipeController 0x%x"),iPipeController ));

   382     ASSERT_PANIC_ALWAYS( iPipeController );

   383     }

   384 

   385 

   386 void CModemAtHandler::HandleATResponse( const TIsiReceiveC& aMessage )

   387     {

   388     C_TRACE (( _T("CModemAtHandler::HandleATResponse()") ));

   389     

   390     TInt dteId = aMessage.Get8bit( ISI_HEADER_SIZE+ AT_MODEM_CMD_RESP_OFFSET_DTEID ) ;

   391     TUint transactionId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_TID );

   392     TUint8 command = transactionId & KCommandBits; //normal AT-cmd or Nvram-query

   393     TInt length = aMessage.Get16bit( ISI_HEADER_SIZE+AT_MODEM_CMD_RESP_OFFSET_LENGTH );

   394     C_TRACE(( _L("DteId: %d AT (0) or nvram command (1): %d Response length %d"), dteId, command, length ));

   395 

   396     /**

   397      * Plugintype can be read from transaction id:

   398      * TUint8 pluginType = transactionId >> KTransactionIdBitsShift;

   399      * (TATPluginInterface) pluginType

   400      *

   401      * Current implementation uses first in first out response completion

   402      * so plugintype is not needed.

   403      */

   404     C_TRACE(( _L("Plugintype: %d"), transactionId >> KTransactionIdBitsShift ));

   405     

   406     iServer.HandleATResponse( dteId,  

   407       aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_CMDLINEBUFFER, length),

   408       command );

   409     }

   410 

   411 #ifdef __WINSCW__

   412 void CModemAtHandler::HandleATResponse( )

   413     {

   414     C_TRACE (( _T("CModemAtHandler::HandleATResponse()") ));

   415     //reply back immediately

   416     const TInt KReplyLength(50);

   417     TBuf8<KReplyLength> replyEmulated = _L8("\r\nAT TEST REPLY");

   418     replyEmulated.AppendNum(iEmulatedValue++);

   419     replyEmulated.Append(_L8("\r\n"));

   420     iServer.HandleATResponse( iDteId, replyEmulated, 0 /* 0 = AT-cmd, 1 = nvram */);

   421     }

   422 #endif

   423 

   424     

   425 TInt CModemAtHandler::Connect(const TUint8 aDteId)

   426     {

   427    C_TRACE (( _T("CModemAtHandler::Connect()") ));

   428 

   429     C_TRACE((_L("Connecting with dteid:%d "), aDteId));

   430     SetDisconnected( EFalse );

   431     

   432     #ifdef __WINSCW__ //emulate, modem is connected

   433     iServer.BroadcastModemConnected( aDteId, KErrNone );

   434     iDteId = aDteId;

   435     return KErrNone;

   436     #endif

   437 #ifndef NCP_COMMON_BRIDGE_FAMILY

   438     iPipeController->LinkDteIdToPipe( aDteId );

   439 #endif

   440     TInt size = ISI_HEADER_SIZE + SIZE_AT_MODEM_CONNECT_REQ;

   441     

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

   443     TRACE_ASSERT( message );

   444     TPtr8 messageptr = message->Des();

   445     TIsiSend isimessage( messageptr, size );

   446     isimessage.Set8bit(ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM); 

   447     isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_TID, KDefaultTId);

   448     isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_MESSAGEID, AT_MODEM_CONNECT_REQ);

   449     isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_DTEID, aDteId);

   450     isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_FILLERBYTE1, KFiller);

   451     isimessage.Complete();

   452 

   453     DUMP_MESSAGE( messageptr );

   454     TInt err = iIscApi->Send( messageptr );

   455     TRACE_ASSERT( err == KErrNone );

   456     delete message;

   457     message = NULL;

   458     return err;

   459     }

   460 

   461 void CModemAtHandler::SetDisconnected( TBool aIsDisconnected )

   462     {

   463     C_TRACE (( _T("CModemAtHandler::SetDisconnected(%d)"),aIsDisconnected ));

   464     iDisconnected = aIsDisconnected;

   465     }

   466 

   467 TBool CModemAtHandler::IsDisconnected()

   468     {

   469     C_TRACE (( _T("CModemAtHandler::IsDisconnected(%d)"),iDisconnected ));

   470     return iDisconnected;

   471     }

   472 

   473 TBool CModemAtHandler::IsPluginConnected()

   474     {

   475     C_TRACE (( _T("CModemAtHandler::IsPluginConnected() sessions: %d"), iServer.SessionCount() ));

   476     return iServer.SessionCount() > 0;

   477     }

   478 

   479 void CModemAtHandler::RemovePipe( const TUint8 aDteId )

   480     {

   481     C_TRACE(( _T("CModemAtHandler::RemovePipe()")));

   482     iDisconnected = ETrue;

   483 #ifndef NCP_COMMON_BRIDGE_FAMILY

   484     iPipeController->RemovePipe( aDteId );

   485 #endif

   486     }

   487 

   488 TInt CModemAtHandler::Disconnect( const TUint8 aDteId )

   489     {

   490     C_TRACE (( _T("CModemAtHandler::Disconnect(%d)"),aDteId ));

   491     #ifdef __WINSCW__

   492     iDteId = aDteId;

   493     return KErrNone;

   494     #endif

   495  

   496     TInt size = ISI_HEADER_SIZE + SIZE_AT_MODEM_DISCONNECT_REQ;

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

   498     TRACE_ASSERT( message );

   499     TPtr8 messageptr = message->Des();

   500     TIsiSend isimessage( messageptr, size );

   501     isimessage.Set8bit(ISI_HEADER_OFFSET_RESOURCEID,PN_AT_MODEM);

   502     isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_TID, 0);

   503     isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_MESSAGEID,

   504       AT_MODEM_DISCONNECT_REQ);

   505     isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_DTEID, aDteId);

   506     isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_FILLERBYTE1, KFiller);

   507     isimessage.Complete();

   508 

   509     C_TRACE (( _T("CModemAtHandler::Disconnect Sending AT_MODEM_DISCONNECT_REQ")));

   510     TInt err = iIscApi->Send(messageptr);

   511     TRACE_ASSERT( err == KErrNone );

   512     delete message;

   513     return err;

   514     }

   515 

   516 

   517 

   518 void CModemAtHandler::HandleModemConnectResp( const TIsiReceiveC& aMessage )

   519     {

   520     C_TRACE (( _T("CModemAtHandler::HandleModemConnectResp()") ));

   521     TInt dteId= aMessage.Get8bit(ISI_HEADER_SIZE+ AT_MODEM_CONNECT_RESP_OFFSET_DTEID);

   522     TInt status = aMessage.Get8bit(ISI_HEADER_SIZE+ AT_MODEM_CONNECT_RESP_OFFSET_RESULT);

   523     TInt err = KErrGeneral;

   524     if( status == AT_MODEM_RESULT_OK )

   525         {

   526         C_TRACE(_L("Connected ok, AT_MODEM_RESULT_OK received"));

   527         err = KErrNone;

   528         }   

   529     else 

   530         {

   531         C_TRACE((_L("Connection failed, AT_MODEM_RESULT_ERROR received (%d)"),status));

   532         TRACE_ASSERT_ALWAYS;

   533         }

   534 

   535     iServer.BroadcastModemConnected( dteId, err );

   536     }

   537 

   538 

   539 void CModemAtHandler::HandleSignalInd( const TIsiReceiveC& aMessage )

   540     {

   541     C_TRACE (( _T("CModemAtHandler::HandleSignalInd()") ));

   542     TInt dteId = aMessage.Get8bit(ISI_HEADER_SIZE+ AT_MODEM_SIGNAL_IND_OFFSET_DTEID);

   543     iServer.HandleSignalInd( dteId );

   544     }

   545 

   546 void CModemAtHandler::HandleUnsolicitedData( const TIsiReceiveC& aMessage )

   547     {

   548     C_TRACE (( _T("CModemAtHandler::HandleUnsolicitedData()") ));

   549     TInt dteId = aMessage.Get8bit( ISI_HEADER_SIZE+ AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_LENGTH );

   550     TInt length = aMessage.Get16bit( ISI_HEADER_SIZE+AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_LENGTH );

   551     

   552     iServer.HandleUnsolicitedData( dteId,

   553       aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_UNSOLICITEDDATABUFFER,

   554       length ) );

   555     }

   556 

   557 

   558 void CModemAtHandler::HandleIntermediateDataInd( const TIsiReceiveC& aMessage )

   559     {

   560     C_TRACE (( _T("CModemAtHandler::HandleIntermediateDataInd()") ));

   561     TInt dteId = aMessage.Get8bit( ISI_HEADER_SIZE+ AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_DTEID );

   562     TInt length= aMessage.Get16bit( ISI_HEADER_SIZE+AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_LENGTH );

   563      

   564     TUint transactionId = aMessage.Get8bit( ISI_HEADER_SIZE+ AT_MODEM_CMD_RESP_OFFSET_TID );

   565     transactionId = iLastTransactionId[ dteId ];

   566     TUint8 command = transactionId & KCommandBits;

   567     TUint8 pluginType = transactionId >> KTransactionIdBitsShift;

   568     C_TRACE((_L("dteid %d iLastrid[dteid] = %d trid %d"), dteId, iLastTransactionId[dteId], transactionId));

   569     

   570     iServer.HandleIntermediateDataInd( dteId,

   571       (TATPluginInterface) pluginType,

   572       aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_INTERMEDIATEDATABUFFER,

   573       length),

   574       command );

   575     }

   576 

   577 

   578 void CModemAtHandler::HandleRedirectInd( const TIsiReceiveC& aMessage ) 

   579     {

   580     C_TRACE (( _T("CModemAtHandler::HandleRedirectInd()") ));

   581   

   582     TInt dteId = aMessage.Get8bit( ISI_HEADER_SIZE+  AT_MODEM_DATA_REDIRECT_IND_OFFSET_DTEID );

   583     TInt newSecondDevId = aMessage.Get8bit( ISI_HEADER_SIZE +  AT_MODEM_DATA_REDIRECT_IND_OFFSET_DEVICEID );

   584     TInt newSecondObjId = aMessage.Get16bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_IND_OFFSET_SERVERID );

   585 #ifndef NCP_COMMON_BRIDGE_FAMILY

   586     iPipeController->RedirectPipe( dteId, newSecondDevId, newSecondObjId ); 

   587 #endif

   588     }

   589 

   590 void CModemAtHandler::SendAtModemDataRedirectResultReq( const TUint8 aDteId, const TUint aResult )

   591     {

   592     C_TRACE (( _T("CModemAtHandler::SendAtModemDataRedirectResultReq()") ));

   593     HBufC8* message = HBufC8::New( ISI_HEADER_SIZE + SIZE_AT_MODEM_DATA_REDIRECT_RESULT_REQ );

   594     C_TRACE((_L("Sending AT_MODEM_DATA_REDIRECT_RESULT_REQ dteid %d result %d"), aDteId, aResult));

   595     

   596     TPtr8 messageptr = message->Des();

   597     TIsiSend isimessage( messageptr, ISI_HEADER_SIZE + SIZE_AT_MODEM_DATA_REDIRECT_RESULT_REQ );

   598     isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM);       

   599     isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_TID, 0 );

   600     isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_MESSAGEID,

   601       AT_MODEM_DATA_REDIRECT_RESULT_REQ );

   602     isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_DTEID ,aDteId );

   603     isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_RESULT ,aResult );

   604     isimessage.Complete();

   605         

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

   607     for( TInt i = 0 ; i < (ISI_HEADER_SIZE + SIZE_AT_MODEM_DATA_REDIRECT_RESULT_REQ); i++ ) 

   608         {

   609         C_TRACE((_L("[%d] 0x%x"),i ,(*message)[i]) );

   610         }

   611 

   612     TInt err = iIscApi->Send( messageptr );

   613     TRACE_ASSERT( err == KErrNone );

   614     delete message;

   615     message = NULL;

   616     }

   617 

   618 

   619 void CModemAtHandler::HandleRedirectResultResp(const TIsiReceiveC& aMessage)

   620     {

   621     C_TRACE (( _T("CModemAtHandler::HandleRedirectResultResp()") ));

   622     TInt dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_RESP_OFFSET_DTEID );

   623     TInt error = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_RESP_OFFSET_RESULT );

   624     C_TRACE((_L("CModemAtHandler::HandleRedirectResultResp() dte %d"), dteId));

   625     

   626     if( error == AT_MODEM_RESULT_ERROR ) 

   627         {

   628         C_TRACE(_L("CModemAtHandler::HandleRedirectResultResp() AT_MODEM_RESULT_ERROR received, redirect failed"));

   629         TRACE_ASSERT_ALWAYS;

   630         }

   631     else 

   632         {

   633         C_TRACE(_L("CModemAtHandler::HandleRedirectResultResp() redirect OK"));

   634         }

   635     

   636     }

   637 void CModemAtHandler::HandleCommandModeChange( TInt aDteId, TCommandMode aMode )

   638     {

   639     C_TRACE(( _T("CModemAtHandler::HandleCommandModeChange() aDteId: %d aMode: %d"),aDteId, (TInt) aMode ));

   640     iServer.HandleCommandModeChange( aDteId, aMode );

   641     }

   642 

   643 TInt CModemAtHandler::SendEscapeSignalDetection( const TUint8 aDteId )

   644     {

   645     C_TRACE((_T("CModemAtHandler::SendEscapeSignalDetection(%d)"), aDteId));

   646     #ifdef __WINSCW__

   647     iDteId = aDteId;

   648     return KErrNone;

   649     #endif

   650   

   651     TInt error( KErrGeneral );  

   652     TUint msgSize( ISI_HEADER_SIZE + SIZE_AT_MODEM_SIGNAL_DETECTED_REQ );

   653     TUint size( msgSize + SIZE_AT_MODEM_SB_SIGNAL_DETECTED ); 

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

   655     if( message )

   656       {

   657       TPtr8 messageptr = message->Des();

   658       TIsiSend isimessage( messageptr, size );

   659       isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM );

   660       isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_TID, 0x00 );

   661       isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_MESSAGEID,

   662         AT_MODEM_SIGNAL_DETECTED_REQ );

   663       isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_DTEID, aDteId );

   664       isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_NOOFSUBBLOCKS, 0x01 );

   665       isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_SUBBLOCKID,

   666         AT_MODEM_SB_SIGNAL_DETECTED );

   667       isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_SUBBLOCKLENGTH,

   668         SIZE_AT_MODEM_SB_SIGNAL_DETECTED );

   669       isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_TYPEOFSIGNALDETECTED,

   670         AT_MODEM_SIGNAL_ESCAPE_DETECTED );

   671       isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_FILLERBYTE1, 0x00 );

   672       isimessage.Complete();

   673       error = iIscApi->Send(messageptr);

   674         C_TRACE((_L("escape send result %d"), error ));

   675       delete message;

   676       message = NULL;

   677       }

   678     else

   679       {

   680       ASSERT_ALWAYS;

   681       error = KErrNoMemory;

   682       }

   683     return error; 

   684     }

   685 

   686 

   687 void CModemAtHandler::HandleSignalDetectedResp( const TIsiReceiveC& aMessage )

   688     {

   689     C_TRACE (( _T("CModemAtHandler::HandleSignalDetectedResp() escape sequence detect response received from cellmo") ));

   690     TInt dteId( aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_RESP_OFFSET_DTEID ) );

   691     TRACE_ASSERT( dteId < KMaxDteIdCount );

   692     TInt result = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_RESP_OFFSET_RESULT );

   693     C_TRACE((_L("CModemAtHandler::HandleSignalDetectedResp() dteId %d"), dteId));

   694     TRACE_ASSERT( result == AT_MODEM_RESULT_OK );

   695     }

   696