adaptationlayer/modematadaptation/modematcontroller_exe/src/cmodematsession.cpp
changeset 9 8486d82aef45
parent 8 6295dc2169f3
equal deleted inserted replaced
8:6295dc2169f3 9:8486d82aef45
    19 #include "cmodematsrv.h"
    19 #include "cmodematsrv.h"
    20 #include "modematclientsrv.h"
    20 #include "modematclientsrv.h"
    21 #include "cmodematsession.h"
    21 #include "cmodematsession.h"
    22 #include "modemattrace.h"
    22 #include "modemattrace.h"
    23 #include "catmessage.h"
    23 #include "catmessage.h"
       
    24 #include "OstTraceDefinitions.h"
       
    25 #ifdef OST_TRACE_COMPILER_IN_USE
       
    26 #include "cmodematsessionTraces.h"
       
    27 #endif
    24 
    28 
    25 
    29 
    26 CModemAtSession* CModemAtSession::NewL( CModemAtSrv& aServer,
    30 CModemAtSession* CModemAtSession::NewL( CModemAtSrv& aServer,
    27     const TVersion& aVersion )
    31     const TVersion& aVersion )
    28     {
    32     {
       
    33     OstTrace0( TRACE_NORMAL, CMODEMATSESSION_NEWL, "CModemAtSession::NewL" );
    29     return new (ELeave) CModemAtSession( aServer, aVersion );
    34     return new (ELeave) CModemAtSession( aServer, aVersion );
    30     }
    35     }
    31 
    36 
    32 CModemAtSession::~CModemAtSession()
    37 CModemAtSession::~CModemAtSession()
    33     {
    38     {
    34     C_TRACE (( _T(">>CModemAtSession::~CModemAtSession()") ));
    39     OstTrace1( TRACE_NORMAL, CMODEMATSESSION_CMODEMATSESSION, "CModemAtSession::~CModemAtSession;this=%x", this );
       
    40     C_TRACE (( _T(">>CModemAtSession::~CModemAtSession() 0x%x"), this ));
    35 
    41 
    36     iServer.CancelFifoRequests( this );
    42     iServer.CancelFifoRequests( this );
    37 
    43 
    38     if( !iConnectReq.IsNull() )
    44     if( !iConnectReq.IsNull() )
    39         {
    45         {
       
    46         OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSESSION_CMODEMATSESSION, "CModemAtSession::~CModemAtSession - iConnectReq canceled" );
    40         C_TRACE(_L("iConnectReq canceled"));
    47         C_TRACE(_L("iConnectReq canceled"));
    41         iConnectReq.Complete( KErrCancel );
    48         iConnectReq.Complete( KErrCancel );
    42         }
    49         }
    43     if( !iUnsolicitedDataReq.IsNull() )
    50     if( !iUnsolicitedDataReq.IsNull() )
    44         {
    51         {
       
    52         OstTrace0( TRACE_NORMAL, DUP3_CMODEMATSESSION_CMODEMATSESSION, "CModemAtSession::~CModemAtSession - iUnsolicitedDataReq canceled" );
    45         C_TRACE(_L("iUnsolicitedDataReq canceled"));
    53         C_TRACE(_L("iUnsolicitedDataReq canceled"));
    46         iUnsolicitedDataReq.Complete( KErrCancel );
    54         iUnsolicitedDataReq.Complete( KErrCancel );
    47         }
    55         }
    48     if( !iSignalIndReq.IsNull() )
    56     if( !iSignalIndReq.IsNull() )
    49         {
    57         {
       
    58         OstTrace0( TRACE_NORMAL, DUP4_CMODEMATSESSION_CMODEMATSESSION, "CModemAtSession::~CModemAtSession - iSignalIndReq canceled" );
    50         C_TRACE(_L("iSignalIndReq canceled"));
    59         C_TRACE(_L("iSignalIndReq canceled"));
    51         iSignalIndReq.Complete( KErrCancel );
    60         iSignalIndReq.Complete( KErrCancel );
    52         }
    61         }
    53     if( !iCommandModeReq.IsNull() )
    62     if( !iCommandModeReq.IsNull() )
    54         {
    63         {
       
    64         OstTrace0( TRACE_NORMAL, DUP5_CMODEMATSESSION_CMODEMATSESSION, "CModemAtSession::~CModemAtSession - iCommandModeReq canceled" );
    55         C_TRACE(_L("iCommandModeReq canceled"));
    65         C_TRACE(_L("iCommandModeReq canceled"));
    56         iCommandModeReq.Complete( KErrCancel );
    66         iCommandModeReq.Complete( KErrCancel );
    57         }
    67         }
       
    68     iServer.ClientClosed(this);
       
    69 
    58     if(iClientName)
    70     if(iClientName)
    59         {
    71         {
    60         delete iClientName;
    72         delete iClientName;
    61         iClientName = NULL;
    73         iClientName = NULL;
    62         }
    74         }
    63     iServer.ClientClosed(this);
       
    64     C_TRACE (( _T("<<CModemAtSession::~CModemAtSession()") ));
    75     C_TRACE (( _T("<<CModemAtSession::~CModemAtSession()") ));
    65     }
    76     }
    66 
    77 
    67 void CModemAtSession::ServiceL( const RMessage2& aMessage )
    78 void CModemAtSession::ServiceL( const RMessage2& aMessage )
    68     {
    79     {
       
    80    OstTrace0( TRACE_NORMAL, CMODEMATSESSION_SERVICEL, "CModemAtSession::ServiceL" );
    69    C_TRACE (( _T("CModemAtSession::ServiceL()") ));
    81    C_TRACE (( _T("CModemAtSession::ServiceL()") ));
    70     if ( iVersion.iMajor==KServerMajorVersionNumber &&
    82     if ( iVersion.iMajor==KServerMajorVersionNumber &&
    71          iVersion.iMinor==KServerMinorVersionNumber &&
    83          iVersion.iMinor==KServerMinorVersionNumber &&
    72          iVersion.iBuild==KServerBuildVersionNumber )
    84          iVersion.iBuild==KServerBuildVersionNumber )
    73         {
    85         {
    74         DoServiceL( aMessage );
    86         DoServiceL( aMessage );
    75         }
    87         }
    76     else
    88     else
    77         {
    89         {
       
    90         OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSESSION_SERVICEL, "CModemAtSession::ServiceL - Complete KErrNotSupported" );
    78         C_TRACE (( _T("Complete KErrNotSupported") ));
    91         C_TRACE (( _T("Complete KErrNotSupported") ));
    79         aMessage.Complete( KErrNotSupported );
    92         aMessage.Complete( KErrNotSupported );
    80         }
    93         }
    81     }
    94     }
    82 
    95 
    83 TBool CModemAtSession::CheckAndCompleteExistingRequest( const RMessage2& aMessage )
    96 TBool CModemAtSession::CheckAndCompleteExistingRequest( const RMessage2& aMessage )
    84     {
    97     {
       
    98     OstTrace0( TRACE_NORMAL, CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest" );
    85     C_TRACE (( _T("CModemAtSession::CheckAndCompleteExistingRequest()") ));
    99     C_TRACE (( _T("CModemAtSession::CheckAndCompleteExistingRequest()") ));
    86     TBool RequestAlreadyPending = EFalse;
   100     TBool RequestAlreadyPending = EFalse;
    87     switch ( aMessage.Function() )
   101     switch ( aMessage.Function() )
    88         {     
   102         {     
    89         case EATExtSetExtensionInterface:
   103         case EATExtSetExtensionInterface:
       
   104             OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - EATExtSetExtensionInterface" );
    90             C_TRACE (( _T("EATExtSetExtensionInterface") ));
   105             C_TRACE (( _T("EATExtSetExtensionInterface") ));
    91         break;
   106         break;
    92         case EModemAtRemovePipe:
   107         case EModemAtRemovePipe:
       
   108             OstTrace0( TRACE_NORMAL, DUP3_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - EModemAtRemovePipe" );
    93             C_TRACE (( _T("EModemAtRemovePipe") ));
   109             C_TRACE (( _T("EModemAtRemovePipe") ));
    94         break;
   110         break;
    95         case EModemATHandleCommand:
   111         case EModemATHandleCommand:
       
   112             OstTrace0( TRACE_NORMAL, DUP4_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - EModemATHandleCommand" );
    96             C_TRACE (( _T("EModemATHandleCommand") ));
   113             C_TRACE (( _T("EModemATHandleCommand") ));
    97         break;
   114         break;
    98         case  EReceiveUnsolicitedResult:
   115         case  EReceiveUnsolicitedResult:
       
   116             OstTrace0( TRACE_NORMAL, DUP5_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - EReceiveUnsolicitedResult" );
    99             C_TRACE (( _T("EReceiveUnsolicitedResult") ));
   117             C_TRACE (( _T("EReceiveUnsolicitedResult") ));
   100           RequestAlreadyPending = !iUnsolicitedDataReq.IsNull(); 
   118             RequestAlreadyPending = !iUnsolicitedDataReq.IsNull(); 
   101         break;
   119         break;
   102         case EReceiveUnsolicitedResultCancel:
   120         case EReceiveUnsolicitedResultCancel:
       
   121             OstTrace0( TRACE_NORMAL, DUP6_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - EReceiveUnsolicitedResultCancel" );
   103             C_TRACE (( _T("EReceiveUnsolicitedResultCancel") ));
   122             C_TRACE (( _T("EReceiveUnsolicitedResultCancel") ));
   104             if ( iUnsolicitedDataReq.IsNull() )
   123             if ( iUnsolicitedDataReq.IsNull() )
   105                 {
   124                 {
       
   125                 OstTrace0( TRACE_NORMAL, DUP7_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - STRAY CANCEL" );
   106                 C_TRACE (( _T("STRAY CANCEL") ));
   126                 C_TRACE (( _T("STRAY CANCEL") ));
   107                 aMessage.Complete( KErrNone );
   127                 aMessage.Complete( KErrNone );
   108                 return ETrue;
   128                 return ETrue;
   109                 }  
   129                 }  
   110         break;
   130         break;
   111         case EModemATHandleCommandCancel:
   131         case EModemATHandleCommandCancel:
       
   132             OstTrace0( TRACE_NORMAL, DUP8_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - EModemATHandleCommandCancel" );
   112             C_TRACE (( _T("EModemATHandleCommandCancel") ));
   133             C_TRACE (( _T("EModemATHandleCommandCancel") ));
   113         break;
   134         break;
   114         case EModemATReceiveSignalInd:
   135         case EModemATReceiveSignalInd:
       
   136             OstTrace0( TRACE_NORMAL, DUP9_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - EModemATReceiveSignalInd" );
   115             C_TRACE (( _T("EModemATReceiveSignalInd") ));
   137             C_TRACE (( _T("EModemATReceiveSignalInd") ));
   116             RequestAlreadyPending = !iSignalIndReq.IsNull(); 
   138             RequestAlreadyPending = !iSignalIndReq.IsNull(); 
   117         break;
   139         break;
   118         case EModemATReceiveSignalIndCancel:
   140         case EModemATReceiveSignalIndCancel:
       
   141             OstTrace0( TRACE_NORMAL, DUP10_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - EModemATReceiveSignalIndCancel" );
   119             C_TRACE (( _T("EModemATReceiveSignalIndCancel") ));
   142             C_TRACE (( _T("EModemATReceiveSignalIndCancel") ));
   120             if( iSignalIndReq.IsNull() )
   143             if( iSignalIndReq.IsNull() )
   121                 {
   144                 {
       
   145                 OstTrace0( TRACE_NORMAL, DUP11_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - STRAY CANCEL" );
   122                 C_TRACE (( _T("STRAY CANCEL") ));
   146                 C_TRACE (( _T("STRAY CANCEL") ));
   123                 aMessage.Complete( KErrNone );
   147                 aMessage.Complete( KErrNone );
   124                 return ETrue;
   148                 return ETrue;
   125                 }   
   149                 }   
   126         break;
   150         break;
   127         
   151         
   128         case EModemATGetNvramStatus:            
   152         case EModemATGetNvramStatus:            
       
   153             OstTrace0( TRACE_NORMAL, DUP12_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - EModemATGetNvramStatus" );
   129             C_TRACE (( _T("EModemATGetNvramStatus") ));
   154             C_TRACE (( _T("EModemATGetNvramStatus") ));
   130         break;
   155         break;
   131         
   156         
   132         case EModemATCommandMode:
   157         case EModemATCommandMode:
       
   158             OstTrace0( TRACE_NORMAL, DUP13_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - EModemATCommandMode" );
   133             C_TRACE (( _T("EModemATCommandMode") ));
   159             C_TRACE (( _T("EModemATCommandMode") ));
   134             RequestAlreadyPending = !iCommandModeReq.IsNull(); 
   160             RequestAlreadyPending = !iCommandModeReq.IsNull(); 
   135             break;
   161             break;
   136             
   162             
   137         case EModemATCommandModeCancel:
   163         case EModemATCommandModeCancel:
       
   164             OstTrace0( TRACE_NORMAL, DUP14_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - EModemATCommandModeCancel" );
   138             C_TRACE (( _T("EModemATCommandModeCancel") ));
   165             C_TRACE (( _T("EModemATCommandModeCancel") ));
   139             if( iCommandModeReq.IsNull())
   166             if( iCommandModeReq.IsNull())
   140                 {
   167                 {
       
   168                 OstTrace0( TRACE_NORMAL, DUP15_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - STRAY CANCEL" );
   141                 C_TRACE (( _T("STRAY CANCEL") ));
   169                 C_TRACE (( _T("STRAY CANCEL") ));
   142                 aMessage.Complete(KErrNone);
   170                 aMessage.Complete(KErrNone);
   143                 return ETrue;
   171                 return ETrue;
   144                 }
   172                 }
   145             break;
   173             break;
   146 
   174 
   147         default:
   175         default:
       
   176             OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - Message not supported" );
   148             C_TRACE(_L("CModemAtSession::CheckAndCompleteExistingRequest Message not supported"));
   177             C_TRACE(_L("CModemAtSession::CheckAndCompleteExistingRequest Message not supported"));
   149             _LIT( KApplicationName, "Modematconroller.exe");
   178             _LIT( KApplicationName, "Modematconroller.exe");
   150             aMessage.Panic( KApplicationName, KErrNotSupported );
   179             aMessage.Panic( KApplicationName, KErrNotSupported );
   151             break;
   180             break;
   152         }
   181         }
   153    
   182    
   154     if( RequestAlreadyPending ) 
   183     if( RequestAlreadyPending ) 
   155         {
   184         {
       
   185         OstTrace0( TRACE_NORMAL, DUP16_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - Complete KErrAlreadyExists" );
   156         C_TRACE (( _T("Complete KErrAlreadyExists") ));
   186         C_TRACE (( _T("Complete KErrAlreadyExists") ));
   157         aMessage.Complete( KErrAlreadyExists );
   187         aMessage.Complete( KErrAlreadyExists );
   158         }
   188         }
   159             
   189             
       
   190     OstTrace1( TRACE_NORMAL, DUP17_CMODEMATSESSION_CHECKANDCOMPLETEEXISTINGREQUEST, "CModemAtSession::CheckAndCompleteExistingRequest - return;RequestAlreadyPending=%x", RequestAlreadyPending );
   160     C_TRACE (( _T("return %d"),RequestAlreadyPending ));
   191     C_TRACE (( _T("return %d"),RequestAlreadyPending ));
   161     return RequestAlreadyPending;
   192     return RequestAlreadyPending;
   162     }
   193     }
   163 
   194 
   164 void CModemAtSession::DoServiceL( const RMessage2& aMessage )
   195 void CModemAtSession::DoServiceL( const RMessage2& aMessage )
   165     {
   196     {
       
   197     OstTraceExt3( TRACE_NORMAL, CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL;aMessage.Function()=%d;aMessage=%p;aMessage.Handle()=%x", aMessage.Function(), &aMessage, (TUint)aMessage.Handle() );
   166     C_TRACE (( _T("CModemAtSession::DoServiceL() function: %d message: 0x%x handle: 0x%x"), aMessage.Function(), &aMessage, aMessage.Handle() ));
   198     C_TRACE (( _T("CModemAtSession::DoServiceL() function: %d message: 0x%x handle: 0x%x"), aMessage.Function(), &aMessage, aMessage.Handle() ));
   167 
   199 
   168     if( CheckAndCompleteExistingRequest( aMessage ) )
   200     if( CheckAndCompleteExistingRequest( aMessage ) )
   169         {
   201         {
       
   202         OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - return" );
   170         C_TRACE (( _T("CModemAtSession::DoServiceL() - return") ));
   203         C_TRACE (( _T("CModemAtSession::DoServiceL() - return") ));
   171         return;
   204         return;
   172         }
   205         }
   173 
   206 
   174     switch ( aMessage.Function() )
   207     switch ( aMessage.Function() )
   175         {
   208         {
   176         case EATExtSetExtensionInterface:
   209         case EATExtSetExtensionInterface:
       
   210             OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - EATExtSetExtensionInterface" );
   177             C_TRACE(_L("EATExtSetExtensionInterface"));
   211             C_TRACE(_L("EATExtSetExtensionInterface"));
   178             iPluginType = (TATPluginInterface)aMessage.Int0();
   212             iPluginType = (TATPluginInterface)aMessage.Int0();
   179             if(iClientName) 
   213             if(iClientName) 
   180                {
   214                {
   181                 delete iClientName;
   215                 delete iClientName;
   183                }
   217                }
   184             iClientName = HBufC8::New( aMessage.GetDesLength( KATModemResponseArgumentIndex ));
   218             iClientName = HBufC8::New( aMessage.GetDesLength( KATModemResponseArgumentIndex ));
   185             iClientNamePtr.Set( iClientName->Des() );
   219             iClientNamePtr.Set( iClientName->Des() );
   186             aMessage.Read( KATModemResponseArgumentIndex, iClientNamePtr );
   220             aMessage.Read( KATModemResponseArgumentIndex, iClientNamePtr );
   187             iConnectReq = aMessage;
   221             iConnectReq = aMessage;
   188             iServer.ConnectToModem( this, iPluginType );
   222             iServer.ConnectToModemL( this, iPluginType );
   189             break;
   223             break;
   190 
   224 
   191         case  EReceiveUnsolicitedResult:
   225         case EReceiveUnsolicitedResult:
       
   226             OstTrace0( TRACE_NORMAL, DUP3_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - EReceiveUnsolicitedResult" );
   192             C_TRACE(_L("EReceiveUnsolicitedResult"));
   227             C_TRACE(_L("EReceiveUnsolicitedResult"));
   193             iUnsolicitedDataReq = aMessage;         
   228             iUnsolicitedDataReq = aMessage;
       
   229             if( iServer.IsUnsolicitedDataInBuffer() )
       
   230                 {
       
   231                 // there is data that can be completed
       
   232                 iServer.GetUnsolicitedDataInBuffer( iTemporaryUnsolicitedData );
       
   233                 if( iTemporaryUnsolicitedData.Length() > 0 )
       
   234                     {
       
   235                     UnsolicitedData( iTemporaryUnsolicitedData );
       
   236                     iTemporaryUnsolicitedData.Zero();
       
   237                     iServer.ResetUnsolicitedDataInBuffer();
       
   238                     }
       
   239                 break;
       
   240                 }
   194             break;
   241             break;
   195 
   242 
   196         case EReceiveUnsolicitedResultCancel:
   243         case EReceiveUnsolicitedResultCancel:
       
   244             OstTrace0( TRACE_NORMAL, DUP4_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - EReceiveUnsolicitedResultCancel" );
       
   245             OstTrace0( TRACE_NORMAL, DUP5_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - Complete" );
   197             C_TRACE(_L("EReceiveUnsolicitedResultCancel"));
   246             C_TRACE(_L("EReceiveUnsolicitedResultCancel"));
   198             C_TRACE(_L("Complete"));
   247             C_TRACE(_L("Complete"));
   199             iUnsolicitedDataReq.Complete(KErrCancel);    
   248             iUnsolicitedDataReq.Complete(KErrCancel);    
   200             aMessage.Complete(KErrNone);
   249             aMessage.Complete(KErrNone);
   201             break;
   250             break;
   202 
   251 
   203         case EModemATHandleCommandCancel:
   252         case EModemATHandleCommandCancel:
       
   253             OstTrace0( TRACE_NORMAL, DUP6_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - EModemATHandleCommandCancel" );
   204             C_TRACE(_L("EModemATHandleCommandCancel"));
   254             C_TRACE(_L("EModemATHandleCommandCancel"));
   205             // actual message is canceled from  fifo
   255             // actual message is canceled from  fifo
   206             iServer.CancelFifoRequests( this );
   256             iServer.CancelFifoRequests( this );
   207             aMessage.Complete(KErrNone);
   257             aMessage.Complete(KErrNone);
   208             break;
   258             break;
   209 
   259 
   210         case EModemATCommandModeCancel:
   260         case EModemATCommandModeCancel:
       
   261             OstTrace0( TRACE_NORMAL, DUP7_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - EModemATCommandModeCancel" );
   211             C_TRACE (( _T("EModemATCommandModeCancel") ));
   262             C_TRACE (( _T("EModemATCommandModeCancel") ));
   212             iCommandModeReq.Complete(KErrCancel);
   263             iCommandModeReq.Complete(KErrCancel);
   213             aMessage.Complete(KErrNone);
   264             aMessage.Complete(KErrNone);
   214             break;
   265             break;
   215 
   266 
   216         case EModemAtRemovePipe:
   267         case EModemAtRemovePipe:
       
   268             OstTrace0( TRACE_NORMAL, DUP8_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - EModemAtRemovePipe" );
   217             C_TRACE (( _T("EModemAtRemovePipe") ));
   269             C_TRACE (( _T("EModemAtRemovePipe") ));
   218             iServer.RemovePipe();
   270             iServer.RemovePipe( iHandler );
   219             aMessage.Complete(KErrNone);
   271             aMessage.Complete(KErrNone);
   220             break;
   272             break;
   221 
   273 
   222         case EModemATReceiveSignalIndCancel:
   274         case EModemATReceiveSignalIndCancel:
       
   275             OstTrace0( TRACE_NORMAL, DUP9_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - EModemATReceiveSignalIndCancel" );
       
   276             OstTrace0( TRACE_NORMAL, DUP10_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - Complete" );
   223             C_TRACE(_L("EModemATReceiveSignalIndCancel"));
   277             C_TRACE(_L("EModemATReceiveSignalIndCancel"));
   224             C_TRACE(_L("Complete"));
   278             C_TRACE(_L("Complete"));
   225             iSignalIndReq.Complete(KErrCancel);
   279             iSignalIndReq.Complete(KErrCancel);
   226             aMessage.Complete(KErrNone);
   280             aMessage.Complete(KErrNone);
   227             break;
   281             break;
   228            
   282            
   229         case EModemATReceiveSignalInd:
   283         case EModemATReceiveSignalInd:
       
   284             OstTrace0( TRACE_NORMAL, DUP11_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - EModemATReceiveSignalInd" );
   230             C_TRACE(_L("EModemATReceiveSignalInd"));
   285             C_TRACE(_L("EModemATReceiveSignalInd"));
   231             iSignalIndReq = aMessage;           
   286             iSignalIndReq = aMessage;           
   232             break;
   287             break;
   233             
   288             
   234         case EModemATHandleCommand:
   289         case EModemATHandleCommand:
   235             {
   290             {
       
   291             OstTrace0( TRACE_NORMAL, DUP12_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - EModemATHandleCommand" );
   236             C_TRACE(_L("EModemATHandleCommand"));
   292             C_TRACE(_L("EModemATHandleCommand"));
   237             CAtMessage* message = new CAtMessage( EAtCmd, this, aMessage );
   293             CAtMessage* message = new CAtMessage( EAtCmd, this, aMessage );
   238             TRACE_ASSERT( message );
   294             TRACE_ASSERT( message );
       
   295             OstTrace0( TRACE_NORMAL, DUP13_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - iServer.AddToSendFifo EAtCmd" );
   239             C_TRACE(_L("iServer.AddToSendFifo EAtCmd"));
   296             C_TRACE(_L("iServer.AddToSendFifo EAtCmd"));
   240             iServer.AddToSendFifo( iPluginType, message  );
   297             iServer.AddToSendFifo( iPluginType, message  );
   241             }
   298             }
   242             break;
   299             break;
   243         
   300         
   244         case EModemATCommandMode:
   301         case EModemATCommandMode:
   245             {
   302             {
       
   303             OstTrace0( TRACE_NORMAL, DUP14_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - EModemATCommandMode" );
   246             C_TRACE(_L("EModemATCommandMode"));
   304             C_TRACE(_L("EModemATCommandMode"));
   247             iCommandModeReq = aMessage;    
   305             iCommandModeReq = aMessage;    
   248             }
   306             }
   249             break;
   307             break;
   250         
   308         
   251         case EModemATGetNvramStatus:
   309         case EModemATGetNvramStatus:
   252             {
   310             {
       
   311             OstTrace0( TRACE_NORMAL, DUP15_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - EModemATGetNvramStatus" );
   253             C_TRACE(_L("EModemATGetNvramStatus"));
   312             C_TRACE(_L("EModemATGetNvramStatus"));
       
   313             if( iServer.IsPipeInDataMode( iHandler ) ||
       
   314                 iServer.IsTextMessageMode( iHandler ) )
       
   315                 {
       
   316                 // AT&V should not be sent from common plugin in data or text message mode
       
   317                 aMessage.Complete( KErrGeneral );
       
   318                 break;
       
   319                 }
       
   320 
   254             CAtMessage* message = new CAtMessage( EGetNvramStatus, this, aMessage );
   321             CAtMessage* message = new CAtMessage( EGetNvramStatus, this, aMessage );
   255             TRACE_ASSERT( message );
   322             TRACE_ASSERT( message );
       
   323             OstTrace0( TRACE_NORMAL, DUP16_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - iServer.AddToSendFifo EGetNvramStatus" );
   256             C_TRACE(_L("iServer.AddToSendFifo EGetNvramStatus"));
   324             C_TRACE(_L("iServer.AddToSendFifo EGetNvramStatus"));
   257             iServer.AddToSendFifo( iPluginType, message  );
   325             iServer.AddToSendFifo( iPluginType, message  );
   258             break;
   326             break;
   259             }
   327             }
   260         default:
   328         default:
   261             {
   329             {
       
   330             OstTrace0( TRACE_NORMAL, DUP17_CMODEMATSESSION_DOSERVICEL, "CModemAtSession::DoServiceL - message not supported" );
   262             C_TRACE(_L("CModemAtSession::DoServiceL message not supported"));
   331             C_TRACE(_L("CModemAtSession::DoServiceL message not supported"));
   263             aMessage.Complete( KErrNotSupported );
   332             aMessage.Complete( KErrNotSupported );
   264             _LIT( KApplicationName, "Modematconroller.exe");
   333             _LIT( KApplicationName, "Modematconroller.exe");
   265             aMessage.Panic( KApplicationName, KErrNotSupported );
   334             aMessage.Panic( KApplicationName, KErrNotSupported );
   266             break;
   335             break;
   270 
   339 
   271 CModemAtSession::CModemAtSession( CModemAtSrv& aServer,
   340 CModemAtSession::CModemAtSession( CModemAtSrv& aServer,
   272     const TVersion& aVersion ) :
   341     const TVersion& aVersion ) :
   273     iServer( aServer ),
   342     iServer( aServer ),
   274     iVersion( aVersion ),
   343     iVersion( aVersion ),
       
   344     iDteId( 0xFF ),
   275     iClientName( NULL ),
   345     iClientName( NULL ),
   276     iClientNamePtr( NULL, 0 )
   346     iClientNamePtr( NULL, 0 ),
   277     {
   347     iHandler( NULL )
       
   348     {
       
   349     OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSESSION_CMODEMATSESSION, "CModemAtSession::CModemAtSession" );
   278     C_TRACE (( _T("CModemAtSession::CModemAtSession()") ));
   350     C_TRACE (( _T("CModemAtSession::CModemAtSession()") ));
   279     }
   351     }
   280 
   352 
   281 void CModemAtSession::UnsolicitedData( const TDesC8& aData ) 
   353 void CModemAtSession::UnsolicitedData( const TDesC8& aData ) 
   282     {
   354     {
       
   355     OstTrace0( TRACE_NORMAL, CMODEMATSESSION_UNSOLICITEDDATA, "CModemAtSession::UnsolicitedData" );
   283     C_TRACE (( _T("CModemAtSession::UnsolicitedData()") ));
   356     C_TRACE (( _T("CModemAtSession::UnsolicitedData()") ));
   284     if(!iUnsolicitedDataReq.IsNull())
   357     if(!iUnsolicitedDataReq.IsNull())
   285         {
   358         {
   286         iUnsolicitedDataReq.Write(KATModemUnsolicitedDataIndex, aData);
   359 
   287         C_TRACE (( _T("iUnsolicitedDataReq.Complete( KErrNone ) iUnsolicitedDataReq: 0x%x"), &iUnsolicitedDataReq ));
   360         TInt length = iUnsolicitedDataReq.GetDesMaxLength( KATModemUnsolicitedDataIndex );
   288         iUnsolicitedDataReq.Complete( KErrNone );
   361         OstTrace1( TRACE_NORMAL, DUP1_CMODEMATSESSION_UNSOLICITEDDATA, "CModemAtSession::UnsolicitedData - iUnsolicitedDataReq;length=%d", length );
       
   362         C_TRACE((_L("iUnsolicitedDataReq length: %d"), length ));
       
   363 
       
   364         HBufC8* unsolicitedBuffer = HBufC8::New( length );
       
   365         TPtr8 ptr = unsolicitedBuffer->Des();
       
   366         iUnsolicitedDataReq.Read( KATModemUnsolicitedDataIndex, ptr );
       
   367         unsolicitedBuffer->Des().Append( aData );
       
   368         OstTrace1( TRACE_NORMAL, DUP2_CMODEMATSESSION_UNSOLICITEDDATA, "CModemAtSession::UnsolicitedData - unsolicitedBuffer->Des() contents:;ptr=%x", &ptr );
       
   369         OstTraceExt1( TRACE_NORMAL, DUP3_CMODEMATSESSION_UNSOLICITEDDATA, "CModemAtSession::UnsolicitedData - dump;aData=%s", aData );
       
   370         C_TRACE((_L("unsolicitedBuffer->Des() contents: 0x%x"), &ptr ));
       
   371         DUMP_MESSAGE( aData );
       
   372         
       
   373         TInt err = iUnsolicitedDataReq.Write( KATModemUnsolicitedDataIndex, unsolicitedBuffer->Des() );
       
   374         delete unsolicitedBuffer;
       
   375 
       
   376         OstTrace1( TRACE_NORMAL, DUP4_CMODEMATSESSION_UNSOLICITEDDATA, "CModemAtSession::UnsolicitedData - Complete;err=%d", err );
       
   377         C_TRACE (( _T("Complete %d"),err ));
       
   378         iUnsolicitedDataReq.Complete( err );
       
   379 
   289         }
   380         }
   290     else
   381     else
   291         {
   382         {
   292         TRACE_ASSERT_ALWAYS;
   383         TRACE_ASSERT_ALWAYS;
   293         }
   384         }
   294     }
   385     }
   295 
   386 
       
   387 TUint8 CModemAtSession::GetDteId() 
       
   388     {
       
   389     OstTrace0( TRACE_NORMAL, CMODEMATSESSION_GETDTEID, "CModemAtSession::GetDteId" );
       
   390     C_TRACE (( _T("CModemAtSession::GetDteId()") ));
       
   391     return iDteId;    
       
   392     }
       
   393 
       
   394 
   296 TATPluginInterface CModemAtSession::GetPluginType()
   395 TATPluginInterface CModemAtSession::GetPluginType()
   297     {
   396     {
       
   397     OstTrace1( TRACE_NORMAL, CMODEMATSESSION_GETPLUGINTYPE, "CModemAtSession::GetPluginType;iPluginType=%d", iPluginType );
   298     C_TRACE (( _T("CCModemAtSession::GetPluginType(%d)"),iPluginType ));
   398     C_TRACE (( _T("CCModemAtSession::GetPluginType(%d)"),iPluginType ));
   299     return iPluginType;
   399     return iPluginType;
   300     }
   400     }
   301 
   401 
   302 TDesC8& CModemAtSession::GetName() 
   402 TDesC8& CModemAtSession::GetName() 
   303     {
   403     {
       
   404     OstTrace0( TRACE_NORMAL, CMODEMATSESSION_GETNAME, "CModemAtSession::GetName" );
   304     C_TRACE( _T("CModemAtSession::GetName()") ); 
   405     C_TRACE( _T("CModemAtSession::GetName()") ); 
   305     return *iClientName;
   406     return *iClientName;
   306     }
   407     }
   307 
   408 
       
   409 void CModemAtSession::SetDteId( const TUint8 aDteId ) 
       
   410     {
       
   411     OstTrace1( TRACE_NORMAL, CMODEMATSESSION_SETDTEID, "CModemAtSession::SetDteId;aDteId=%d", aDteId );
       
   412     C_TRACE(( _T("CModemAtSession::SetDteId( %d )"), aDteId ));
       
   413     iDteId = aDteId;   
       
   414     }
       
   415 
   308 void CModemAtSession::ModemConnected( const TInt aErr ) 
   416 void CModemAtSession::ModemConnected( const TInt aErr ) 
   309     {
   417     {
       
   418     OstTrace1( TRACE_NORMAL, CMODEMATSESSION_MODEMCONNECTED, "CModemAtSession::ModemConnected;aErr=%d", aErr );
   310     C_TRACE(( _T("CModemAtSession::ModemConnected( %d )"), aErr ));
   419     C_TRACE(( _T("CModemAtSession::ModemConnected( %d )"), aErr ));
   311     if( !iConnectReq.IsNull() ) 
   420     if( !iConnectReq.IsNull() ) 
   312         {
   421         {
       
   422         OstTrace1( TRACE_NORMAL, DUP1_CMODEMATSESSION_MODEMCONNECTED, "CModemAtSession::ModemConnected - Complete iConnectReq;aErr=%d", aErr );
   313         C_TRACE (( _T("Complete iConnectReq( %d )"), aErr ));
   423         C_TRACE (( _T("Complete iConnectReq( %d )"), aErr ));
   314         iConnectReq.Complete(aErr);
   424         iConnectReq.Complete(aErr);
   315         }
   425         }
   316     }
   426     }
   317 
   427 
   318 void CModemAtSession::SignalIndReceived() 
   428 void CModemAtSession::SignalIndReceived( const TInt aCompleteCode ) 
   319     {
   429     {
   320     C_TRACE(( _T("CModemAtSession::SignalIndReceived()") ));
   430     OstTrace1( TRACE_NORMAL, CMODEMATSESSION_SIGNALINDRECEIVED, "CModemAtSession::SignalIndReceived;aCompleteCode=%d", aCompleteCode );
       
   431     C_TRACE(( _T("CModemAtSession::SignalIndReceived( %d )"), aCompleteCode ));
   321     if(!iSignalIndReq.IsNull())
   432     if(!iSignalIndReq.IsNull())
   322         {
   433         {
   323         C_TRACE (( _T("Complete iSignalIndReq( KErrNone ) iSignalIndReq: 0x%x"), &iSignalIndReq ));
   434         OstTrace1( TRACE_NORMAL, DUP1_CMODEMATSESSION_SIGNALINDRECEIVED, "CModemAtSession::SignalIndReceived;iSignalIndReq=%x", &iSignalIndReq );
   324         iSignalIndReq.Complete( KErrNone );
   435         C_TRACE (( _T("Complete iSignalIndReq( %d ) iSignalIndReq: 0x%x"), aCompleteCode, &iSignalIndReq ));
       
   436         iSignalIndReq.Complete( aCompleteCode );
   325         }
   437         }
   326     }
   438     }
   327 
   439 
   328 void CModemAtSession::CommandModeChanged( TCommandMode aMode ) 
   440 void CModemAtSession::CommandModeChanged( TCommandMode aMode ) 
   329     {
   441     {
       
   442     OstTrace1( TRACE_NORMAL, CMODEMATSESSION_COMMANDMODECHANGED, "CModemAtSession::CommandModeChanged;aMode=%d", (TInt)aMode );
       
   443     OstTrace1( TRACE_NORMAL, DUP1_CMODEMATSESSION_COMMANDMODECHANGED, "CModemAtSession::CommandModeChanged - Writing mode to iCommandModeReq;aMode=%d", (TInt)aMode );
   330     C_TRACE((_L("CModemAtSession::CommandModeChanged( %d )"), (TInt) aMode ));
   444     C_TRACE((_L("CModemAtSession::CommandModeChanged( %d )"), (TInt) aMode ));
   331     C_TRACE((_L("Writing mode to iCommandModeReq %d"), (TInt) aMode ));
   445     C_TRACE((_L("Writing mode to iCommandModeReq %d"), (TInt) aMode ));
   332 
   446 
   333     if( !iCommandModeReq.IsNull() )
   447     if( !iCommandModeReq.IsNull() )
   334         {
   448         {
   335         TInt length = iCommandModeReq.GetDesMaxLength( KATModemCommandArgumentIndex );
   449         TInt length = iCommandModeReq.GetDesMaxLength( KATModemCommandArgumentIndex );
       
   450         OstTrace1( TRACE_NORMAL, DUP2_CMODEMATSESSION_COMMANDMODECHANGED, "CModemAtSession::CommandModeChanged - iCommandModeReq;length=%d", length );
   336         C_TRACE((_L("iCommandModeReq length: %d"), length ));
   451         C_TRACE((_L("iCommandModeReq length: %d"), length ));
   337 
   452 
   338         HBufC8* modeBuffer = HBufC8::New( length );
   453         HBufC8* modeBuffer = HBufC8::New( length );
   339         TPtr8 ptr = modeBuffer->Des();
   454         TPtr8 ptr = modeBuffer->Des();
   340         iCommandModeReq.Read( KATModemCommandArgumentIndex, ptr );
   455         iCommandModeReq.Read( KATModemCommandArgumentIndex, ptr );
   341         modeBuffer->Des().AppendNum( (TInt) aMode );
   456         modeBuffer->Des().AppendNum( (TInt) aMode );
       
   457         OstTrace1( TRACE_NORMAL, DUP3_CMODEMATSESSION_COMMANDMODECHANGED, "CModemAtSession::CommandModeChanged - modeBuffer->Des() contents:;ptr=%x", &ptr );
       
   458         OstTraceExt1( TRACE_NORMAL, DUP4_CMODEMATSESSION_COMMANDMODECHANGED, "CModemAtSession::CommandModeChanged - dump;ptr=%s", ptr );
   342         C_TRACE((_L("modeBuffer->Des() contents: 0x%x"), &ptr ));
   459         C_TRACE((_L("modeBuffer->Des() contents: 0x%x"), &ptr ));
   343         DUMP_MESSAGE( ptr );
   460         DUMP_MESSAGE( ptr );
   344         
   461         
   345         TInt err = iCommandModeReq.Write( KATModemCommandArgumentIndex, modeBuffer->Des() );
   462         TInt err = iCommandModeReq.Write( KATModemCommandArgumentIndex, modeBuffer->Des() );
   346         delete modeBuffer;
   463         delete modeBuffer;
   347 
   464 
       
   465         OstTrace1( TRACE_NORMAL, DUP5_CMODEMATSESSION_COMMANDMODECHANGED, "CModemAtSession::CommandModeChanged - Complete;err=%d", err );
   348         C_TRACE (( _T("Complete %d"),err ));
   466         C_TRACE (( _T("Complete %d"),err ));
   349         iCommandModeReq.Complete( err );
   467         iCommandModeReq.Complete( err );
   350         }
   468         }
   351     else
   469     else
   352         {
   470         {
       
   471         OstTrace1( TRACE_NORMAL, DUP6_CMODEMATSESSION_COMMANDMODECHANGED, "CModemAtSession::CommandModeChanged - CommandModeChanged Ignored!!!;aMode=%d", aMode );
   353         C_TRACE((_L("CommandModeChanged Ignored!!! Mode: %d"), aMode ));
   472         C_TRACE((_L("CommandModeChanged Ignored!!! Mode: %d"), aMode ));
   354         }
   473         }
   355     }
   474     }
   356 
   475 
   357 TBool CModemAtSession::IsUnsolicitedDataReqActive()
   476 TBool CModemAtSession::IsUnsolicitedDataReqActive()
   358     {
   477     {
       
   478     OstTrace1( TRACE_NORMAL, CMODEMATSESSION_ISUNSOLICITEDDATAREQACTIVE, "CModemAtSession::IsUnsolicitedDataReqActive - ret:;%d", (TInt) !iUnsolicitedDataReq.IsNull() );
   359     C_TRACE(( _T("CModemAtSession::IsUnsolicitedDataReqActive ret: %d"), (TInt) !iUnsolicitedDataReq.IsNull() ));
   479     C_TRACE(( _T("CModemAtSession::IsUnsolicitedDataReqActive ret: %d"), (TInt) !iUnsolicitedDataReq.IsNull() ));
   360     return !iUnsolicitedDataReq.IsNull();
   480     return !iUnsolicitedDataReq.IsNull();
   361     }
   481     }
   362 
   482 
   363 TBool CModemAtSession::IsSignalIndReqActive()
   483 TBool CModemAtSession::IsSignalIndReqActive()
   364     {
   484     {
       
   485     OstTrace1( TRACE_NORMAL, CMODEMATSESSION_ISSIGNALINDREQACTIVE, "CModemAtSession::IsSignalIndReqActive - ret:;%d", (TInt) !iSignalIndReq.IsNull() );
   365     C_TRACE(( _T("CModemAtSession::IsSignalIndReqActive ret: %d"), (TInt) !iSignalIndReq.IsNull() ));
   486     C_TRACE(( _T("CModemAtSession::IsSignalIndReqActive ret: %d"), (TInt) !iSignalIndReq.IsNull() ));
   366     return !iSignalIndReq.IsNull();
   487     return !iSignalIndReq.IsNull();
   367     }
   488     }
   368 
   489 
   369 TBool CModemAtSession::IsCommandModeReqActive()
   490 TBool CModemAtSession::IsCommandModeReqActive()
   370     {
   491     {
       
   492     OstTrace1( TRACE_NORMAL, CMODEMATSESSION_ISCOMMANDMODEREQACTIVE, "CModemAtSession::IsCommandModeReqActive - ret:;%d", (TInt) !iCommandModeReq.IsNull() );
   371     C_TRACE(( _T("CModemAtSession::IsCommandModeReqActive ret: %d"), (TInt) !iCommandModeReq.IsNull() ));
   493     C_TRACE(( _T("CModemAtSession::IsCommandModeReqActive ret: %d"), (TInt) !iCommandModeReq.IsNull() ));
   372     return !iCommandModeReq.IsNull();
   494     return !iCommandModeReq.IsNull();
   373     }
   495     }
   374 
   496 
   375 TBool CModemAtSession::IsConnectReqActive()
   497 TBool CModemAtSession::IsConnectReqActive()
   376     {
   498     {
       
   499     OstTrace1( TRACE_NORMAL, CMODEMATSESSION_ISCONNECTREQACTIVE, "CModemAtSession::IsConnectReqActive - ret:;%d", (TInt) !iConnectReq.IsNull() );
   377     C_TRACE(( _T("CModemAtSession::IsConnectReqActive ret: %d"), (TInt) !iConnectReq.IsNull() ));
   500     C_TRACE(( _T("CModemAtSession::IsConnectReqActive ret: %d"), (TInt) !iConnectReq.IsNull() ));
   378     return !iConnectReq.IsNull();
   501     return !iConnectReq.IsNull();
   379     }
   502     }
   380 
   503 
   381 
   504 void CModemAtSession::SetHandler( CModemAtHandler* aHandler )
       
   505     {
       
   506     OstTrace1( TRACE_NORMAL, CMODEMATSESSION_SETHANDLER, "CModemAtSession::SetHandler;aHandler=%x", aHandler );
       
   507     C_TRACE (( _T("CModemAtSession::SetHandler() 0x%x"), aHandler ));
       
   508     TRACE_ASSERT( NULL != aHandler );
       
   509     iHandler = aHandler;
       
   510     }
       
   511 
       
   512 CModemAtHandler* CModemAtSession::GetHandler()
       
   513     {
       
   514     OstTrace0( TRACE_NORMAL, CMODEMATSESSION_GETHANDLER, "CModemAtSession::GetHandler" );
       
   515     C_TRACE (( _T("CModemAtSession::GetHandler()") ));
       
   516     return iHandler;
       
   517     }
       
   518 
       
   519