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 #include "cmodematsrv.h"

    20 #include "modematclientsrv.h"

    21 #include "cmodematsession.h"

    22 #include "modemattrace.h"

    23 #include "catmessage.h"

    24 

    25 

    26 CModemAtSession* CModemAtSession::NewL( CModemAtSrv& aServer,

    27     const TVersion& aVersion )

    28     {

    29     return new (ELeave) CModemAtSession( aServer, aVersion );

    30     }

    31 

    32 CModemAtSession::~CModemAtSession()

    33     {

    34     C_TRACE (( _T(">>CModemAtSession::~CModemAtSession()") ));

    35 

    36     iServer.CancelFifoRequests( this );

    37 

    38     if( !iConnectReq.IsNull() )

    39         {

    40         C_TRACE(_L("iConnectReq canceled"));

    41         iConnectReq.Complete( KErrCancel );

    42         }

    43     if( !iUnsolicitedDataReq.IsNull() )

    44         {

    45         C_TRACE(_L("iUnsolicitedDataReq canceled"));

    46         iUnsolicitedDataReq.Complete( KErrCancel );

    47         }

    48     if( !iSignalIndReq.IsNull() )

    49         {

    50         C_TRACE(_L("iSignalIndReq canceled"));

    51         iSignalIndReq.Complete( KErrCancel );

    52         }

    53     if( !iCommandModeReq.IsNull() )

    54         {

    55         C_TRACE(_L("iCommandModeReq canceled"));

    56         iCommandModeReq.Complete( KErrCancel );

    57         }

    58     if(iClientName)

    59         {

    60         delete iClientName;

    61         iClientName = NULL;

    62         }

    63     iServer.ClientClosed(this);

    64     C_TRACE (( _T("<<CModemAtSession::~CModemAtSession()") ));

    65     }

    66 

    67 void CModemAtSession::ServiceL( const RMessage2& aMessage )

    68     {

    69    C_TRACE (( _T("CModemAtSession::ServiceL()") ));

    70     if ( iVersion.iMajor==KServerMajorVersionNumber &&

    71          iVersion.iMinor==KServerMinorVersionNumber &&

    72          iVersion.iBuild==KServerBuildVersionNumber )

    73         {

    74         DoServiceL( aMessage );

    75         }

    76     else

    77         {

    78         C_TRACE (( _T("Complete KErrNotSupported") ));

    79         aMessage.Complete( KErrNotSupported );

    80         }

    81     }

    82 

    83 TBool CModemAtSession::CheckAndCompleteExistingRequest( const RMessage2& aMessage )

    84     {

    85     C_TRACE (( _T("CModemAtSession::CheckAndCompleteExistingRequest()") ));

    86     TBool RequestAlreadyPending = EFalse;

    87     switch ( aMessage.Function() )

    88         {     

    89         case EATExtSetExtensionInterface:

    90             C_TRACE (( _T("EATExtSetExtensionInterface") ));

    91         break;

    92         case EModemAtRemovePipe:

    93             C_TRACE (( _T("EModemAtRemovePipe") ));

    94         break;

    95         case EModemATHandleCommand:

    96             C_TRACE (( _T("EModemATHandleCommand") ));

    97         break;

    98         case  EReceiveUnsolicitedResult:

    99             C_TRACE (( _T("EReceiveUnsolicitedResult") ));

   100           RequestAlreadyPending = !iUnsolicitedDataReq.IsNull(); 

   101         break;

   102         case EReceiveUnsolicitedResultCancel:

   103             C_TRACE (( _T("EReceiveUnsolicitedResultCancel") ));

   104             if ( iUnsolicitedDataReq.IsNull() )

   105                 {

   106                 C_TRACE (( _T("STRAY CANCEL") ));

   107                 aMessage.Complete( KErrNone );

   108                 return ETrue;

   109                 }  

   110         break;

   111         case EModemATHandleCommandCancel:

   112             C_TRACE (( _T("EModemATHandleCommandCancel") ));

   113         break;

   114         case EModemATReceiveSignalInd:

   115             C_TRACE (( _T("EModemATReceiveSignalInd") ));

   116             RequestAlreadyPending = !iSignalIndReq.IsNull(); 

   117         break;

   118         case EModemATReceiveSignalIndCancel:

   119             C_TRACE (( _T("EModemATReceiveSignalIndCancel") ));

   120             if( iSignalIndReq.IsNull() )

   121                 {

   122                 C_TRACE (( _T("STRAY CANCEL") ));

   123                 aMessage.Complete( KErrNone );

   124                 return ETrue;

   125                 }   

   126         break;

   127         

   128         case EModemATGetNvramStatus:            

   129             C_TRACE (( _T("EModemATGetNvramStatus") ));

   130         break;

   131         

   132         case EModemATCommandMode:

   133             C_TRACE (( _T("EModemATCommandMode") ));

   134             RequestAlreadyPending = !iCommandModeReq.IsNull(); 

   135             break;

   136             

   137         case EModemATCommandModeCancel:

   138             C_TRACE (( _T("EModemATCommandModeCancel") ));

   139             if( iCommandModeReq.IsNull())

   140                 {

   141                 C_TRACE (( _T("STRAY CANCEL") ));

   142                 aMessage.Complete(KErrNone);

   143                 return ETrue;

   144                 }

   145             break;

   146 

   147         default:

   148             C_TRACE(_L("default"));

   149             _LIT( KPanicString, "AtServer");

   150             aMessage.Panic( KPanicString, KErrNotSupported );

   151             break;

   152         }

   153    

   154     if( RequestAlreadyPending ) 

   155         {

   156         C_TRACE (( _T("Complete KErrAlreadyExists") ));

   157         aMessage.Complete( KErrAlreadyExists );

   158         }

   159             

   160     C_TRACE (( _T("return %d"),RequestAlreadyPending ));

   161     return RequestAlreadyPending;

   162     }

   163 

   164 void CModemAtSession::DoServiceL( const RMessage2& aMessage )

   165     {

   166     C_TRACE (( _T("CModemAtSession::DoServiceL() function: %d message: 0x%x handle: 0x%x"), aMessage.Function(), &aMessage, aMessage.Handle() ));

   167 

   168     if( CheckAndCompleteExistingRequest( aMessage ) )

   169         {

   170         C_TRACE (( _T("CModemAtSession::DoServiceL() - return") ));

   171         return;

   172         }

   173 

   174     switch ( aMessage.Function() )

   175         {

   176         case EATExtSetExtensionInterface:

   177             C_TRACE(_L("EATExtSetExtensionInterface"));

   178             iPluginType=(TATPluginInterface) aMessage.Int0();

   179             if(iClientName) 

   180                {

   181                 delete iClientName;

   182                 iClientName = NULL;

   183                }

   184             iClientName = HBufC8::New( aMessage.GetDesLength( KATModemResponseArgumentIndex ));

   185             iClientNamePtr.Set( iClientName->Des() );

   186             aMessage.Read( KATModemResponseArgumentIndex, iClientNamePtr );

   187             iConnectReq = aMessage;

   188             iServer.ConnectToModem(this);

   189             break;

   190 

   191         case  EReceiveUnsolicitedResult:

   192             C_TRACE(_L("EReceiveUnsolicitedResult"));

   193             iUnsolicitedDataReq = aMessage;         

   194             break;

   195 

   196         case EReceiveUnsolicitedResultCancel:

   197             C_TRACE(_L("EReceiveUnsolicitedResultCancel"));

   198             C_TRACE(_L("Complete"));

   199             iUnsolicitedDataReq.Complete(KErrCancel);    

   200             aMessage.Complete(KErrNone);

   201             break;

   202 

   203         case EModemATHandleCommandCancel:

   204             C_TRACE(_L("EModemATHandleCommandCancel"));

   205             // actual message is canceled from  fifo

   206             iServer.CancelFifoRequests( this );

   207             aMessage.Complete(KErrNone);

   208             break;

   209 

   210         case EModemATCommandModeCancel:

   211             C_TRACE (( _T("EModemATCommandModeCancel") ));

   212             iCommandModeReq.Complete(KErrCancel);

   213             aMessage.Complete(KErrNone);

   214             break;

   215 

   216         case EModemAtRemovePipe:

   217             C_TRACE (( _T("EModemAtRemovePipe") ));

   218             iServer.RemovePipe( iDteId );

   219             aMessage.Complete(KErrNone);

   220             break;

   221 

   222         case EModemATReceiveSignalIndCancel:

   223             C_TRACE(_L("EModemATReceiveSignalIndCancel"));

   224             C_TRACE(_L("Complete"));

   225             iSignalIndReq.Complete(KErrCancel);

   226             aMessage.Complete(KErrNone);

   227             break;

   228            

   229         case EModemATReceiveSignalInd:

   230             C_TRACE(_L("EModemATReceiveSignalInd"));

   231             iSignalIndReq = aMessage;           

   232             break;

   233             

   234         case EModemATHandleCommand:

   235             {

   236             C_TRACE(_L("EModemATHandleCommand"));

   237             CAtMessage* message = new CAtMessage( EAtCmd, this, aMessage );

   238             TRACE_ASSERT( message );

   239             C_TRACE(_L("iServer.AddToSendFifo EAtCmd"));

   240             iServer.AddToSendFifo( iDteId, iPluginType, message  );

   241             }

   242             break;

   243         

   244         case EModemATCommandMode:

   245             {

   246             C_TRACE(_L("EModemATCommandMode"));

   247             iCommandModeReq = aMessage;    

   248             }

   249             break;

   250         

   251         case EModemATGetNvramStatus:

   252             {

   253             C_TRACE(_L("EModemATGetNvramStatus"));

   254             CAtMessage* message = new CAtMessage( EGetNvramStatus, this, aMessage );

   255             TRACE_ASSERT( message );

   256             C_TRACE(_L("iServer.AddToSendFifo EGetNvramStatus"));

   257             iServer.AddToSendFifo( iDteId, iPluginType, message  );

   258             break;

   259             }

   260         default:

   261             {

   262             C_TRACE(_L("CModemAtSession::DoServiceL message not supported"));

   263             aMessage.Complete( KErrNotSupported );

   264             User::Panic(_L("ATServer"),KErrNotSupported);

   265             break;

   266             }

   267         }  

   268     }

   269 

   270 CModemAtSession::CModemAtSession( CModemAtSrv& aServer,

   271     const TVersion& aVersion ) :

   272     iServer( aServer ),

   273     iVersion( aVersion ),

   274     iDteId( KInitialDteId ),

   275     iClientName( NULL ),

   276     iClientNamePtr( NULL, 0 )

   277     {

   278     C_TRACE (( _T("CModemAtSession::CModemAtSession()") ));

   279     }

   280 

   281 void CModemAtSession::UnsolicitedData( const TDesC8& aData ) 

   282     {

   283     C_TRACE (( _T("CModemAtSession::UnsolicitedData()") ));

   284     if(!iUnsolicitedDataReq.IsNull())

   285         {

   286         iUnsolicitedDataReq.Write(KATModemUnsolicitedDataIndex, aData);

   287         C_TRACE (( _T("iUnsolicitedDataReq.Complete( KErrNone ) iUnsolicitedDataReq: 0x%x"), &iUnsolicitedDataReq ));

   288         iUnsolicitedDataReq.Complete( KErrNone );

   289         }

   290     else

   291         {

   292         TRACE_ASSERT_ALWAYS;

   293         }

   294     }

   295 

   296 TUint8 CModemAtSession::GetDteId() 

   297     {

   298     C_TRACE (( _T("CModemAtSession::GetDteId()") ));

   299     return iDteId;    

   300     }

   301 

   302 

   303 TATPluginInterface CModemAtSession::GetPluginType()

   304     {

   305     C_TRACE (( _T("CCModemAtSession::GetPluginType(%d)"),iPluginType ));

   306     return iPluginType;

   307     }

   308 

   309 

   310 TDesC8& CModemAtSession::GetName() 

   311     {

   312     C_TRACE( _T("CModemAtSession::GetName()") ); 

   313     return *iClientName;

   314     }

   315 

   316 void CModemAtSession::SetDteId( const TUint8 aDteId ) 

   317     {

   318     C_TRACE(( _T("CModemAtSession::SetDteId( %d )"), aDteId ));

   319     iDteId = aDteId;   

   320     }

   321 

   322 void CModemAtSession::ModemConnected( const TInt aErr ) 

   323     {

   324     C_TRACE(( _T("CModemAtSession::ModemConnected( %d )"), aErr ));

   325     if( !iConnectReq.IsNull() ) 

   326         {

   327         C_TRACE (( _T("Complete iConnectReq( %d )"), aErr ));

   328         iConnectReq.Complete(aErr);

   329         }   

   330     }

   331 

   332 void CModemAtSession::SignalIndReceived() 

   333     {

   334     C_TRACE(( _T("CModemAtSession::SignalIndReceived()") ));

   335     if(!iSignalIndReq.IsNull())

   336         {

   337         C_TRACE (( _T("Complete iSignalIndReq( KErrNone ) iSignalIndReq: 0x%x"), &iSignalIndReq ));

   338         iSignalIndReq.Complete( KErrNone );

   339         }

   340     }

   341 

   342 void CModemAtSession::CommandModeChanged( TCommandMode aMode ) 

   343     {

   344     C_TRACE((_L("CModemAtSession::CommandModeChanged( %d )"), (TInt) aMode ));

   345     C_TRACE((_L("Writing mode to iCommandModeReq %d"), (TInt) aMode ));

   346 

   347     if( !iCommandModeReq.IsNull() )

   348         {

   349         TInt length = iCommandModeReq.GetDesMaxLength( KATModemCommandArgumentIndex );

   350         C_TRACE((_L("iCommandModeReq length: %d"), length ));

   351 

   352         HBufC8* modeBuffer = HBufC8::New( length );

   353         TPtr8 ptr = modeBuffer->Des();

   354         iCommandModeReq.Read( KATModemCommandArgumentIndex, ptr );

   355         modeBuffer->Des().AppendNum( (TInt) aMode );

   356         C_TRACE((_L("modeBuffer->Des() contents: 0x%x"), &ptr ));

   357         DUMP_MESSAGE( ptr );

   358         

   359         TInt err = iCommandModeReq.Write( KATModemCommandArgumentIndex, modeBuffer->Des() );

   360         delete modeBuffer;

   361 

   362         C_TRACE (( _T("Complete %d"),err ));

   363         iCommandModeReq.Complete( err );

   364         }

   365     else

   366         {

   367         C_TRACE((_L("CommandModeChanged Ignored!!! Mode: %d"), aMode ));

   368         }

   369     }

   370 

   371 TBool CModemAtSession::IsUnsolicitedDataReqActive()

   372     {

   373     C_TRACE(( _T("CModemAtSession::IsUnsolicitedDataReqActive ret: %d"), (TInt) !iUnsolicitedDataReq.IsNull() ));

   374     return !iUnsolicitedDataReq.IsNull();

   375     }

   376 

   377 TBool CModemAtSession::IsSignalIndReqActive()

   378     {

   379     C_TRACE(( _T("CModemAtSession::IsSignalIndReqActive ret: %d"), (TInt) !iSignalIndReq.IsNull() ));

   380     return !iSignalIndReq.IsNull();

   381     }

   382 

   383 TBool CModemAtSession::IsCommandModeReqActive()

   384     {

   385     C_TRACE(( _T("CModemAtSession::IsCommandModeReqActive ret: %d"), (TInt) !iCommandModeReq.IsNull() ));

   386     return !iCommandModeReq.IsNull();

   387     }

   388 

   389 TBool CModemAtSession::IsConnectReqActive()

   390     {

   391     C_TRACE(( _T("CModemAtSession::IsConnectReqActive ret: %d"), (TInt) !iConnectReq.IsNull() ));

   392     return !iConnectReq.IsNull();

   393     }

   394 

   395