1 /*

     2 * Copyright (c) 2009-2010 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 "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:  AT command handler and notifier

    15 *

    16 */

    17 

    18 /*

    19  * Points to consider:

    20  * - Each of the AT commands sent to ATEXT are converted to upper case form.

    21  *   Thus the ATEXT plugins don't need to check for case. The conversion to

    22  *   upper case form stops when carriage return or '=' character is found.

    23  */

    24 

    25 /*

    26  * The AT command handling is splitted to two parts on high level:

    27  * 1) Splitter: splitting the sub-commands in a command line to multiple ones

    28  *    for ATEXT to process.

    29  * 2) Combiner: combining the replies coming from ATEXT using a filter

    30  *    (the filter categories are explained in DunAtCmdPusher.cpp)

    31  */

    32 

    33 #include "DunAtCmdHandler.h"

    34 #include "DunAtUrcHandler.h"

    35 #include "DunDownstream.h"

    36 #include "DunDebug.h"

    37 

    38 const TInt8 KDunCancel = 24;  // Used for line editing, cancel character

    39 const TInt8 KDunEscape = 27;  // Used for editor ending, escape character

    40 

    41 // ---------------------------------------------------------------------------

    42 // Two-phased constructor.

    43 // ---------------------------------------------------------------------------

    44 //

    45 EXPORT_C CDunAtCmdHandler* CDunAtCmdHandler::NewL(

    46     MDunAtCmdStatusReporter* aUpstream,

    47     MDunStreamManipulator* aDownstream,

    48     const TDesC8* aConnectionName )

    49     {

    50     CDunAtCmdHandler* self = new (ELeave) CDunAtCmdHandler(

    51         aUpstream,

    52         aDownstream,

    53         aConnectionName );

    54     CleanupStack::PushL( self );

    55     self->ConstructL();

    56     CleanupStack::Pop( self );

    57     return self;

    58     }

    59 

    60 // ---------------------------------------------------------------------------

    61 // Destructor.

    62 // ---------------------------------------------------------------------------

    63 //

    64 CDunAtCmdHandler::~CDunAtCmdHandler()

    65     {

    66     FTRACE(FPrint( _L("CDunAtCmdHandler::~CDunAtCmdHandler()") ));

    67     ResetData();

    68     FTRACE(FPrint( _L("CDunAtCmdHandler::~CDunAtCmdHandler() complete") ));

    69     }

    70 

    71 // ---------------------------------------------------------------------------

    72 // Resets data to initial values

    73 // ---------------------------------------------------------------------------

    74 //

    75 EXPORT_C void CDunAtCmdHandler::ResetData()

    76     {

    77     FTRACE(FPrint( _L("CDunAtCmdHandler::ResetData()") ));

    78     // APIs affecting this:

    79     // IssueRequest()

    80     Stop();

    81     // NewL()

    82     DeletePluginHandlers();

    83     delete iCmdEchoer;

    84     iCmdEchoer = NULL;

    85     delete iNvramListen;

    86     iNvramListen = NULL;

    87     delete iModeListen;

    88     iModeListen = NULL;

    89     delete iEcomListen;

    90     iEcomListen = NULL;

    91     delete iAtSpecialCmdHandler;

    92     iAtSpecialCmdHandler = NULL;

    93     if ( iAtCmdExtCommon.Handle() )

    94         {

    95         iAtCmdExtCommon.SynchronousClose();

    96         iAtCmdExtCommon.Close();

    97         }

    98     if ( iAtCmdExt.Handle() )

    99         {

   100         iAtCmdExt.SynchronousClose();

   101         iAtCmdExt.Close();

   102         }

   103     iSpecials.ResetAndDestroy();

   104     iSpecials.Close();

   105     // AddCmdModeCallback()

   106     iCmdCallbacks.Close();

   107     // Internal

   108     Initialize();

   109     FTRACE(FPrint( _L("CDunAtCmdHandler::ResetData() complete") ));

   110     }

   111 

   112 // ---------------------------------------------------------------------------

   113 // Adds callback for command mode notification

   114 // The callback will be called when command mode starts or ends

   115 // ---------------------------------------------------------------------------

   116 //

   117 EXPORT_C TInt CDunAtCmdHandler::AddCmdModeCallback( MDunCmdModeMonitor* aCallback )

   118     {

   119     FTRACE(FPrint( _L("CDunAtCmdHandler::AddCmdModeCallback()" ) ));

   120     if ( !aCallback )

   121         {

   122         FTRACE(FPrint( _L("CDunAtCmdHandler::AddCmdModeCallback() (aCallback) not initialized!" ) ));

   123         return KErrGeneral;

   124         }

   125     TInt retTemp = iCmdCallbacks.Find( aCallback );

   126     if ( retTemp != KErrNotFound )

   127         {

   128         FTRACE(FPrint( _L("CDunAtCmdHandler::AddCmdModeCallback() (already exists) complete" ) ));

   129         return KErrAlreadyExists;

   130         }

   131     retTemp = iCmdCallbacks.Append( aCallback );

   132     if ( retTemp != KErrNone )

   133         {

   134         FTRACE(FPrint( _L("CDunAtCmdHandler::AddCmdModeCallback() (append failed!) complete" ) ));

   135         return retTemp;

   136         }

   137     FTRACE(FPrint( _L("CDunAtCmdHandler::AddCmdModeCallback() complete" ) ));

   138     return KErrNone;

   139     }

   140 

   141 // ---------------------------------------------------------------------------

   142 // Parses an AT command

   143 // ---------------------------------------------------------------------------

   144 //

   145 EXPORT_C TInt CDunAtCmdHandler::ParseCommand( TDesC8& aCommand,

   146                                               TBool& aPartialInput )

   147     {

   148     FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand()") ));

   149     FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() received:") ));

   150     FTRACE(FPrintRaw(aCommand) );

   151     TBool editorMode = iCmdPusher->EditorMode();

   152     if ( editorMode )

   153         {

   154         // Note: return here with "no partial input" and some error to fool

   155         // CDunUpstream into not reissuing the read request.

   156         iCmdPusher->IssueRequest( aCommand, EFalse );

   157         aPartialInput = EFalse;

   158         return KErrGeneral;

   159         }

   160     iCommand = &aCommand;  // iCommand only for normal mode

   161     // Manage partial AT command

   162     TBool needsCarriage = ETrue;

   163     TBool okToExit = ManagePartialCommand( aCommand, needsCarriage );

   164     if ( okToExit )

   165         {

   166         FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() (ok to exit) complete") ));

   167         aPartialInput = ETrue;

   168         return KErrNone;

   169         }

   170     if ( iHandleState != EDunStateIdle )

   171         {

   172         aPartialInput = EFalse;

   173         ResetParseBuffers();

   174         FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() (not ready) complete") ));

   175         return KErrNotReady;

   176         }

   177     TBool pushStarted = HandleASlashCommand();

   178     if ( pushStarted )

   179         {

   180         // Note: return here with "partial input" status to fool CDunUpstream

   181         // into reissuing the read request. The AT command has not really

   182         // started yet so this is necessary.

   183         aPartialInput = ETrue;

   184         ResetParseBuffers();

   185         FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() (A/) complete") ));

   186         return KErrNone;

   187         }

   188     FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() received total:") ));

   189     FTRACE(FPrintRaw(iInputBuffer) );

   190     iHandleState = EDunStateAtCmdHandling;

   191     iUpstream->NotifyAtCmdHandlingStart();

   192     iDecodeInfo.iFirstDecode = ETrue;

   193     iDecodeInfo.iDecodeIndex = 0;

   194     HandleNextDecodedCommand();

   195     FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() complete") ));

   196     aPartialInput = EFalse;

   197     return KErrNone;

   198     }

   199 

   200 // ---------------------------------------------------------------------------

   201 // Manages request to abort command handling

   202 // ---------------------------------------------------------------------------

   203 //

   204 EXPORT_C TInt CDunAtCmdHandler::ManageAbortRequest()

   205     {

   206     FTRACE(FPrint( _L("CDunAtCmdHandler::ManageAbortRequest()") ));

   207     // Just forward the request, do no other own processing

   208     TInt retVal = iCmdPusher->ManageAbortRequest();

   209     FTRACE(FPrint( _L("CDunAtCmdHandler::ManageAbortRequest() complete") ));

   210     return retVal;

   211     }

   212 

   213 // ---------------------------------------------------------------------------

   214 // Sets end of command line marker on for the possible series of AT commands.

   215 // ---------------------------------------------------------------------------

   216 //

   217 EXPORT_C void CDunAtCmdHandler::SetEndOfCmdLine( TBool aClearInput )

   218     {

   219     FTRACE(FPrint( _L("CDunAtCmdHandler::SetEndOfCmdLine()") ));

   220     ManageEndOfCmdHandling( EFalse, ETrue, aClearInput );

   221     FTRACE(FPrint( _L("CDunAtCmdHandler::SetEndOfCmdLine() complete") ));

   222     }

   223 

   224 // ---------------------------------------------------------------------------

   225 // Sends a character to be echoed

   226 // ---------------------------------------------------------------------------

   227 //

   228 EXPORT_C TInt CDunAtCmdHandler::SendEchoCharacter( const TDesC8* aInput,

   229                                                    MDunAtCmdEchoer* aCallback )

   230     {

   231     FTRACE(FPrint( _L("CDunAtCmdHandler::SendEchoCharacter()") ));

   232     TInt retVal = iCmdEchoer->SendEchoCharacter( aInput, aCallback );

   233     FTRACE(FPrint( _L("CDunAtCmdHandler::SendEchoCharacter() complete") ));

   234     return retVal;

   235     }

   236 

   237 // ---------------------------------------------------------------------------

   238 // Stops sending of AT command from parse buffer

   239 // ---------------------------------------------------------------------------

   240 //

   241 EXPORT_C TInt CDunAtCmdHandler::Stop()

   242     {

   243     FTRACE(FPrint( _L("CDunAtCmdHandler::Stop()") ));

   244     // Only stop iCmdPusher here, not iUrcHandlers!

   245     if ( iHandleState != EDunStateAtCmdHandling )

   246         {

   247         FTRACE(FPrint( _L("CDunAtCmdHandler::Stop() (not ready) complete" )));

   248         return KErrNotReady;

   249         }

   250     iCmdPusher->Stop();

   251     // The line below is used in the case when this function is called by

   252     // CDunUpstream as a result of "data mode ON" change notification.

   253     // In this case it is possible that HandleNextDecodedCommand() returns

   254     // without resetting the iInputBuffer because of the way it checks the

   255     // iHandleState.

   256     ManageEndOfCmdHandling( EFalse, ETrue, ETrue );

   257     FTRACE(FPrint( _L("CDunAtCmdHandler::Stop() complete") ));

   258     return KErrNone;

   259     }

   260 

   261 // ---------------------------------------------------------------------------

   262 // Starts URC message handling

   263 // ---------------------------------------------------------------------------

   264 //

   265 EXPORT_C TInt CDunAtCmdHandler::StartUrc()

   266     {

   267     FTRACE(FPrint( _L("CDunAtCmdHandler::StartUrc()") ));

   268     TInt i;

   269     TInt count = iUrcHandlers.Count();

   270     for ( i=0; i<count; i++ )

   271         {

   272         TInt retTemp = iUrcHandlers[i]->IssueRequest();

   273         if ( retTemp!=KErrNone && retTemp!=KErrNotReady )

   274             {

   275             FTRACE(FPrint( _L("CDunAtCmdHandler::StartUrc() (ERROR) complete") ));

   276             return retTemp;

   277             }

   278         }

   279     FTRACE(FPrint( _L("CDunAtCmdHandler::StartUrc() complete") ));

   280     return KErrNone;

   281     }

   282 

   283 // ---------------------------------------------------------------------------

   284 // Stops URC message handling

   285 // ---------------------------------------------------------------------------

   286 //

   287 EXPORT_C TInt CDunAtCmdHandler::StopUrc()

   288     {

   289     FTRACE(FPrint( _L("CDunAtCmdHandler::StopUrc()") ));

   290     TInt i;

   291     TInt retVal = KErrNone;

   292     TInt count = iUrcHandlers.Count();

   293     for ( i=0; i<count; i++ )

   294         {

   295         retVal = iUrcHandlers[i]->Stop();

   296         }

   297     FTRACE(FPrint( _L("CDunAtCmdHandler::StopUrc() complete") ));

   298     return retVal;

   299     }

   300 

   301 // ---------------------------------------------------------------------------

   302 // CDunAtCmdHandler::CDunAtCmdHandler

   303 // ---------------------------------------------------------------------------

   304 //

   305 CDunAtCmdHandler::CDunAtCmdHandler( MDunAtCmdStatusReporter* aUpstream,

   306                                     MDunStreamManipulator* aDownstream,

   307                                     const TDesC8* aConnectionName ) :

   308     iUpstream( aUpstream ),

   309     iDownstream( aDownstream ),

   310     iConnectionName( aConnectionName )

   311     {

   312     Initialize();

   313     }

   314 

   315 // ---------------------------------------------------------------------------

   316 // CDunAtCmdHandler::ConstructL

   317 // ---------------------------------------------------------------------------

   318 //

   319 void CDunAtCmdHandler::ConstructL()

   320     {

   321     FTRACE(FPrint( _L("CDunAtCmdHandler::ConstructL()") ));

   322     if ( !iUpstream || !iDownstream || !iConnectionName )

   323         {

   324         User::Leave( KErrGeneral );

   325         }

   326     // Connect to AT command extension (must succeed)

   327     TInt retTemp = KErrNone;

   328     CleanupClosePushL( iAtCmdExt );

   329     retTemp = iAtCmdExt.Connect( EDunATExtension, *iConnectionName );

   330     if ( retTemp != KErrNone )

   331         {

   332         FTRACE(FPrint( _L("CDunAtCmdHandler::ConstructL() connect (%d)"), retTemp));

   333         User::Leave( retTemp );

   334         }

   335     CleanupClosePushL( iAtCmdExtCommon );

   336     retTemp = iAtCmdExtCommon.Connect( *iConnectionName );

   337     if ( retTemp != KErrNone )

   338         {

   339         FTRACE(FPrint( _L("CDunAtCmdHandler::ConstructL() common connect (%d)"), retTemp));

   340         User::Leave( retTemp );

   341         }

   342     // Create the array of special commands

   343     CreateSpecialCommandsL();

   344     // Create the plugin handlers

   345     CreatePluginHandlersL();

   346     // Create the echo handler

   347     iCmdEchoer = CDunAtCmdEchoer::NewL( iDownstream );

   348     // Create the listeners

   349     iEcomListen = CDunAtEcomListen::NewL( &iAtCmdExt, this );

   350     iModeListen = CDunAtModeListen::NewL( &iAtCmdExtCommon, this );

   351     iNvramListen = CDunAtNvramListen::NewL( &iAtCmdExt, &iAtCmdExtCommon );

   352     iAtSpecialCmdHandler = CDunAtSpecialCmdHandler::NewL();

   353     // Set the default modes (+report) and characters

   354     GetAndSetDefaultSettingsL();

   355     // Start listening

   356     iEcomListen->IssueRequest();

   357     iModeListen->IssueRequest();

   358     iNvramListen->IssueRequest();

   359     CleanupStack::Pop( &iAtCmdExtCommon );

   360     CleanupStack::Pop( &iAtCmdExt );

   361     FTRACE(FPrint( _L("CDunAtCmdHandler::ConstructL() complete") ));

   362     }

   363 

   364 // ---------------------------------------------------------------------------

   365 // Initializes this class

   366 // ---------------------------------------------------------------------------

   367 //

   368 void CDunAtCmdHandler::Initialize()

   369     {

   370     // Don't initialize iUpstream here (it is set through NewL)

   371     // Don't initialize iDownstream here (it is set through NewL)

   372     // Don't initialize iConnectionName here (it is set through NewL)

   373     iHandleState = EDunStateIdle;

   374     iCarriageReturn = 0;

   375     iLineFeed = 0;

   376     iBackspace = 0;

   377     iCommand = NULL;

   378     iDecodeInfo.iFirstDecode = ETrue;

   379     iDecodeInfo.iDecodeIndex = KErrNotFound;

   380     iDecodeInfo.iExtendedIndex = KErrNotFound;

   381     iDecodeInfo.iPrevChar = 0;

   382     iDecodeInfo.iPrevExists = EFalse;

   383     iDecodeInfo.iAssignFound = EFalse;

   384     iDecodeInfo.iInQuotes = EFalse;

   385     iDecodeInfo.iSpecialFound = EFalse;

   386     iEditorModeInfo.iContentFound = EFalse;

   387     iCmdPusher = NULL;

   388     iEcomListen = NULL;

   389     iModeListen = NULL;

   390     iNvramListen = NULL;

   391     iDataMode = EFalse;

   392     iEchoOn = EFalse;

   393     iQuietOn = EFalse;

   394     iVerboseOn = EFalse;

   395     iEndIndex = KErrNotFound;

   396     }

   397 

   398 // ---------------------------------------------------------------------------

   399 // Creates plugin handlers for this class

   400 // ---------------------------------------------------------------------------

   401 //

   402 void CDunAtCmdHandler::CreatePluginHandlersL()

   403     {

   404     FTRACE(FPrint( _L("CDunAtCmdHandler::CreatePluginHandlersL()") ));

   405     if ( !iAtCmdExt.Handle() )

   406         {

   407         FTRACE(FPrint( _L("CDunAtCmdHandler::CreatePluginHandlersL() complete") ));

   408         User::Leave( KErrGeneral );

   409         }

   410     // First create the command reply pusher

   411     CDunAtCmdPusher* cmdPusher = CDunAtCmdPusher::NewLC( &iAtCmdExt,

   412                                                          this,

   413                                                          iDownstream,

   414                                                          &iOkBuffer );

   415     // Next create the URC handlers

   416     TInt i;

   417     TInt numOfPlugins = iAtCmdExt.NumberOfPlugins();

   418     for ( i=0; i<numOfPlugins; i++ )

   419         {

   420         AddOneUrcHandlerL();

   421         }

   422     CleanupStack::Pop( cmdPusher );

   423     iCmdPusher = cmdPusher;

   424     FTRACE(FPrint( _L("CDunAtCmdHandler::CreatePluginHandlersL() complete") ));

   425     }

   426 

   427 // ---------------------------------------------------------------------------

   428 // Creates an array of special commands

   429 // ---------------------------------------------------------------------------

   430 //

   431 void CDunAtCmdHandler::CreateSpecialCommandsL()

   432     {

   433     FTRACE(FPrint( _L("CDunAtCmdHandler::CreateSpecialCommandsL()") ));

   434     TInt retTemp = KErrNone;

   435     TBool firstSearch = ETrue;

   436     for ( ;; )

   437         {

   438         retTemp = iAtCmdExt.GetNextSpecialCommand( iInputBuffer, firstSearch );

   439         if ( retTemp != KErrNone )

   440             {

   441             break;

   442             }

   443         HBufC8* specialCmd = HBufC8::NewMaxLC( iInputBuffer.Length() );

   444         TPtr8 specialCmdPtr = specialCmd->Des();

   445         specialCmdPtr.Copy( iInputBuffer );

   446         specialCmdPtr.UpperCase();

   447         iSpecials.AppendL( specialCmd );

   448         CleanupStack::Pop( specialCmd );

   449         }

   450     iInputBuffer.Zero();

   451     FTRACE(FPrint( _L("CDunAtCmdHandler::CreateSpecialCommandsL() complete") ));

   452     }

   453 

   454 // ---------------------------------------------------------------------------

   455 // Recreates special command data.

   456 // This is done when a plugin is installed or uninstalled.

   457 // ---------------------------------------------------------------------------

   458 //

   459 TInt CDunAtCmdHandler::RecreateSpecialCommands()

   460     {

   461     FTRACE(FPrint( _L("CDunAtCmdHandler::RecreateSpecialCommands()") ));

   462     iSpecials.ResetAndDestroy();

   463     TRAPD( retTrap, CreateSpecialCommandsL() );

   464     FTRACE(FPrint( _L("CDunAtCmdHandler::RecreateSpecialCommands() complete") ));

   465     return retTrap;

   466     }

   467 

   468 // ---------------------------------------------------------------------------

   469 // Gets default settings from RATExtCommon and sets them to RATExt

   470 // ---------------------------------------------------------------------------

   471 //

   472 void CDunAtCmdHandler::GetAndSetDefaultSettingsL()

   473     {

   474     FTRACE(FPrint( _L("CDunAtCmdHandler::GetAndSetDefaultSettingsL()") ));

   475     // Note: Let's assume command mode is off by default

   476     TUint modeSet = GetCurrentModeL( KModeEcho | KModeQuiet | KModeVerbose );

   477     iEchoOn    = ( modeSet & KEchoModeBase    ) ? ETrue : EFalse;

   478     iQuietOn   = ( modeSet & KQuietModeBase   ) ? ETrue : EFalse;

   479     iVerboseOn = ( modeSet & KVerboseModeBase ) ? ETrue : EFalse;

   480     iCarriageReturn = GetCurrentModeL( KModeCarriage );

   481     iLineFeed = GetCurrentModeL( KModeLineFeed );

   482     iBackspace = GetCurrentModeL( KModeBackspace );

   483     iAtCmdExt.ReportQuietModeChange( iQuietOn );

   484     iAtCmdExt.ReportVerboseModeChange( iVerboseOn );

   485     iAtCmdExt.ReportCharacterChange( ECharTypeCarriage, iCarriageReturn );

   486     iAtCmdExt.ReportCharacterChange( ECharTypeLineFeed, iLineFeed );

   487     iAtCmdExt.ReportCharacterChange( ECharTypeBackspace, iBackspace );

   488     RegenerateReplyStrings();

   489     FTRACE(FPrint( _L("CDunAtCmdHandler::GetAndSetDefaultSettingsL() settings: E=%d, Q=%d, V=%d"), iEchoOn, iQuietOn, iVerboseOn ));

   490     FTRACE(FPrint( _L("CDunAtCmdHandler::GetAndSetDefaultSettingsL() settings: CR=%u, LF=%u, BS=%u"), iCarriageReturn, iLineFeed, iBackspace ));

   491     FTRACE(FPrint( _L("CDunAtCmdHandler::GetAndSetDefaultSettingsL() complete") ));

   492     }

   493 

   494 // ---------------------------------------------------------------------------

   495 // Regenerates the reply strings based on settings

   496 // ---------------------------------------------------------------------------

   497 //

   498 TBool CDunAtCmdHandler::RegenerateReplyStrings()

   499     {

   500     FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateReplyStrings()") ));

   501     TBool retVal = EFalse;

   502     retVal |= RegenerateOkReply();

   503     retVal |= RegenerateErrorReply();

   504     FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateReplyStrings() complete") ));

   505     return retVal;

   506     }

   507 

   508 // ---------------------------------------------------------------------------

   509 // Regenerates the ok reply based on settings

   510 // ---------------------------------------------------------------------------

   511 //

   512 TBool CDunAtCmdHandler::RegenerateOkReply()

   513     {

   514     FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateOkReply()") ));

   515     iOkBuffer.Zero();

   516     if ( iQuietOn )

   517         {

   518         FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateOkReply() (quiet) complete") ));

   519         return ETrue;

   520         }

   521     if ( iVerboseOn )

   522         {

   523         _LIT8( KVerboseOk, "OK" );

   524         iOkBuffer.Append( iCarriageReturn );

   525         iOkBuffer.Append( iLineFeed );

   526         iOkBuffer.Append( KVerboseOk );

   527         iOkBuffer.Append( iCarriageReturn );

   528         iOkBuffer.Append( iLineFeed );

   529         }

   530     else

   531         {

   532         _LIT8( KNumericOk, "0" );

   533         iOkBuffer.Append( KNumericOk );

   534         iOkBuffer.Append( iCarriageReturn );

   535         }

   536     FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateOkReply() complete") ));

   537     return EFalse;

   538     }

   539 

   540 // ---------------------------------------------------------------------------

   541 // Regenerates the error reply based on settings

   542 // ---------------------------------------------------------------------------

   543 //

   544 TBool CDunAtCmdHandler::RegenerateErrorReply()

   545     {

   546     FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateErrorReply()") ));

   547     iErrorBuffer.Zero();

   548     if ( iQuietOn )

   549         {

   550         FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateErrorReply() (quiet) complete") ));

   551         return ETrue;

   552         }

   553     if ( iVerboseOn )

   554         {

   555         _LIT8( KVerboseError, "ERROR" );

   556         iErrorBuffer.Append( iCarriageReturn );

   557         iErrorBuffer.Append( iLineFeed );

   558         iErrorBuffer.Append( KVerboseError );

   559         iErrorBuffer.Append( iCarriageReturn );

   560         iErrorBuffer.Append( iLineFeed );

   561         }

   562     else

   563         {

   564         _LIT8( KNumericError, "4" );

   565         iErrorBuffer.Append( KNumericError );

   566         iErrorBuffer.Append( iCarriageReturn );

   567         }

   568     FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateErrorReply() complete") ));

   569     return EFalse;

   570     }

   571 

   572 // ---------------------------------------------------------------------------

   573 // Gets current mode

   574 // ---------------------------------------------------------------------------

   575 //

   576 TUint CDunAtCmdHandler::GetCurrentModeL( TUint aMask )

   577     {

   578     FTRACE(FPrint( _L("CDunAtCmdHandler::GetCurrentModeL()") ));

   579     TUint maskCheck = aMask & ( ~KSupportedModes );

   580     if ( maskCheck != 0 )

   581         {

   582         FTRACE(FPrint( _L("CDunAtCmdHandler::GetCurrentModeL() (not supported) complete") ));

   583         User::Leave( KErrNotSupported );

   584         }

   585     TUint newMode = 0;

   586     TInt retTemp = iAtCmdExtCommon.GetMode( aMask, newMode );

   587     if ( retTemp != KErrNone )

   588         {

   589         FTRACE(FPrint( _L("CDunAtCmdHandler::GetCurrentModeL() (ERROR) complete") ));

   590         User::Leave( retTemp );

   591         }

   592     FTRACE(FPrint( _L("CDunAtCmdHandler::GetCurrentModeL() complete") ));

   593     return newMode & (KModeChanged-1);

   594     }

   595 

   596 // ---------------------------------------------------------------------------

   597 // Instantiates one URC message handling class instance and adds it to the URC

   598 // message handler array

   599 // ---------------------------------------------------------------------------

   600 //

   601 CDunAtUrcHandler* CDunAtCmdHandler::AddOneUrcHandlerL()

   602     {

   603     FTRACE(FPrint( _L("CDunAtCmdHandler::AddOneUrcHandlerL()") ));

   604     CDunAtUrcHandler* urcHandler = CDunAtUrcHandler::NewLC( &iAtCmdExt,

   605                                                             iDownstream );

   606     iUrcHandlers.AppendL( urcHandler );

   607     CleanupStack::Pop( urcHandler );

   608     FTRACE(FPrint( _L("CDunAtCmdHandler::AddOneUrcHandlerL() complete") ));

   609     return urcHandler;

   610     }

   611 

   612 // ---------------------------------------------------------------------------

   613 // Deletes all instantiated URC message handlers

   614 // ---------------------------------------------------------------------------

   615 //

   616 void CDunAtCmdHandler::DeletePluginHandlers()

   617     {

   618     FTRACE(FPrint( _L("CDunAtCmdHandler::DeletePluginHandlers()") ));

   619     delete iCmdPusher;

   620     iCmdPusher = NULL;

   621     TInt i;

   622     TInt count = iUrcHandlers.Count();

   623     for ( i=0; i<count; i++ )

   624         {

   625         delete iUrcHandlers[i];

   626         iUrcHandlers[i] = NULL;

   627         }

   628     iUrcHandlers.Reset();

   629     iUrcHandlers.Close();

   630     FTRACE(FPrint( _L("CDunAtCmdHandler::DeletePluginHandlers() complete") ));

   631     }

   632 

   633 // ---------------------------------------------------------------------------

   634 // Manages partial AT command

   635 // ---------------------------------------------------------------------------

   636 //

   637 TBool CDunAtCmdHandler::ManagePartialCommand( TDesC8& aCommand,

   638                                               TBool& aNeedsCarriage )

   639     {

   640     FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand()") ));

   641     aNeedsCarriage = ETrue;

   642     // Check length of command

   643     if ( aCommand.Length() == 0 )

   644         {

   645         FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (length zero) complete") ));

   646         return ETrue;

   647         }

   648     // Check one character (or unit) based input data

   649     if ( aCommand.Length() == KDunChSetMaxCharLen )

   650         {

   651         EchoCommand( aCommand );

   652         // Handle backspace and cancel characters

   653         TBool found = HandleSpecialCharacters( aCommand );

   654         if ( found )

   655             {

   656             FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (special) complete") ));

   657             return ETrue;

   658             }

   659         }

   660     TBool endFound = EFalse;

   661     TBool overflow = AppendCommandToInputBuffer( aCommand, endFound );

   662     if ( overflow )

   663         {

   664         // Overflow occurred so return ETrue (consumed) to skip all the rest

   665         // characters until carriage return is found

   666         FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (overflow) complete") ));

   667         return ETrue;

   668         }

   669     // If something went wrong, do nothing (return consumed)

   670     if ( iInputBuffer.Length() <= 0 )

   671         {

   672         FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (length) complete") ));

   673         return ETrue;

   674         }

   675     // If "A/", no carriage return is needed, check that now

   676     if ( IsASlashCommand() )

   677         {

   678         aNeedsCarriage = EFalse;

   679         FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (A/) complete") ));

   680         return EFalse;

   681         }

   682     // For other commands and if no end, just return with consumed

   683     if ( !endFound )

   684         {

   685         FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (void) complete") ));

   686         return ETrue;

   687         }

   688     FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() complete") ));

   689     return EFalse;

   690     }

   691 

   692 // ---------------------------------------------------------------------------

   693 // Echoes a command if echo is on

   694 // ---------------------------------------------------------------------------

   695 //

   696 TBool CDunAtCmdHandler::EchoCommand( TDesC8& aDes )

   697     {

   698     FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand()") ));

   699     if ( aDes.Length() > KDunChSetMaxCharLen )

   700         {

   701         FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand() (wrong length) complete") ));

   702         return EFalse;

   703         }

   704     if ( iEchoOn )

   705         {

   706         iEchoBuffer.Copy( aDes );

   707         iDownstream->NotifyDataPushRequest( &iEchoBuffer, NULL );

   708         FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand() complete") ));

   709         return ETrue;

   710         }

   711     FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand() (not started) complete") ));

   712     return EFalse;

   713     }

   714 

   715 // ---------------------------------------------------------------------------

   716 // Handles backspace and cancel characters

   717 // ---------------------------------------------------------------------------

   718 //

   719 TBool CDunAtCmdHandler::HandleSpecialCharacters( TDesC8& aCommand )

   720     {

   721     FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters()") ));

   722     if ( aCommand.Length() != KDunChSetMaxCharLen )

   723         {

   724         FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters() (wrong length) complete") ));

   725         return EFalse;

   726         }

   727     if ( aCommand[0] == iBackspace )

   728         {

   729         TInt bufferLength = iInputBuffer.Length();

   730         if ( bufferLength > 0 )

   731             {

   732             iInputBuffer.SetLength( bufferLength-1 );

   733             }

   734         FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters() (backspace) complete") ));

   735         return ETrue;

   736         }

   737     if ( aCommand[0] == KDunCancel )

   738         {

   739         ResetParseBuffers();  // More processing here?

   740         FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters() (cancel) complete") ));

   741         return ETrue;

   742         }

   743     FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters() complete") ));

   744     return EFalse;

   745     }

   746 

   747 // ---------------------------------------------------------------------------

   748 // Appends command to parse buffer

   749 // ---------------------------------------------------------------------------

   750 //

   751 TBool CDunAtCmdHandler::AppendCommandToInputBuffer( TDesC8& aCommand,

   752                                                     TBool& aEndFound )

   753     {

   754     FTRACE(FPrint( _L("CDunAtCmdHandler::AppendCommandToInputBuffer()") ));

   755     aEndFound = EFalse;

   756     TInt cmdBufIndex = 0;

   757     TInt cmdBufLim = aCommand.Length();

   758     while ( cmdBufIndex < cmdBufLim )

   759         {

   760         if ( iInputBuffer.Length() == iInputBuffer.MaxLength() )

   761             {

   762             // 1) If output is full and end found from input

   763             //    -> reset buffers and overflow found

   764             // 2) If output is full and end not found from input

   765             //    -> don't reset buffers and overflow found

   766             TInt foundIndex = FindEndOfCommand( aCommand );

   767             if ( foundIndex >= 0 )

   768                 {

   769                 aEndFound = ETrue;

   770                 ResetParseBuffers();

   771                 FTRACE(FPrint( _L("CDunAtCmdHandler::AppendCommandToInputBuffer() (reset) complete") ));

   772                 }

   773             FTRACE(FPrint( _L("CDunAtCmdHandler::AppendCommandToInputBuffer() (overflow) complete") ));

   774             return ETrue;

   775             }

   776         TChar character = aCommand[cmdBufIndex];

   777         if ( IsEndOfCommand(character) )

   778             {

   779             aEndFound = ETrue;

   780             iEndIndex = cmdBufIndex;

   781             break;

   782             }

   783         iInputBuffer.Append( aCommand[cmdBufIndex] );

   784         cmdBufIndex++;

   785         }

   786     FTRACE(FPrint( _L("CDunAtCmdHandler::AppendCommandToInputBuffer() complete") ));

   787     return EFalse;

   788     }

   789 

   790 // ---------------------------------------------------------------------------

   791 // Handles next decoded command from input buffer

   792 // ---------------------------------------------------------------------------

   793 //

   794 TBool CDunAtCmdHandler::HandleNextDecodedCommand()

   795     {

   796     FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextDecodedCommand()") ));

   797     if ( iHandleState != EDunStateAtCmdHandling )

   798         {

   799         FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextDecodedCommand() (not ready) complete") ));

   800         return ETrue;

   801         }

   802     TBool extracted = ExtractNextDecodedCommand();

   803     if ( !extracted )

   804         {

   805         ManageEndOfCmdHandling( ETrue, ETrue, ETrue );

   806         FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextDecodedCommand() (last) complete") ));

   807         return ETrue;

   808         }

   809     // Next convert the decoded AT command to uppercase

   810     // Don't check for case status -> let mixed cases pass

   811     iParseInfo.iSendBuffer.Copy( iDecodeInfo.iDecodeBuffer );

   812     TInt maxLength = iParseInfo.iSendBuffer.MaxLength();

   813     TPtr8 upperDes( &iParseInfo.iSendBuffer[0], iParseInfo.iLimit, maxLength );

   814     upperDes.UpperCase();

   815     // Next always send the command to ATEXT

   816     iCmdPusher->IssueRequest( iParseInfo.iSendBuffer );

   817     FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextDecodedCommand() complete") ));

   818     return EFalse;

   819     }

   820 

   821 // ---------------------------------------------------------------------------

   822 // Finds the start of the next command

   823 // ---------------------------------------------------------------------------

   824 //

   825 TInt CDunAtCmdHandler::FindStartOfNextCommand()

   826     {

   827     FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfNextCommand()") ));

   828     // Note: here we need to avoid internal recursion when parsing the

   829     // multiple IsEndOfCommand() and IsDelimiterCharacter() markers inside the

   830     // same upstream block.

   831     // Skip all the extra markers except the one we already know to exist.

   832     TInt i;

   833     TInt startVal = iEndIndex + 1;

   834     TInt foundIndex = KErrNotFound;

   835     TInt count = iCommand->Length();

   836     for ( i=startVal; i<count; i++ )

   837         {

   838         TChar character = (*iCommand)[i];

   839         if ( !(IsEndOfCommand(character)||IsDelimiterCharacter(character)) )

   840             {

   841             foundIndex = i;

   842             break;

   843             }

   844         }

   845     FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfNextCommand() complete") ));

   846     return foundIndex;

   847     }

   848 

   849 // ---------------------------------------------------------------------------

   850 // Manages end of AT command handling

   851 // ---------------------------------------------------------------------------

   852 //

   853 void CDunAtCmdHandler::ManageEndOfCmdHandling( TBool aNotifyExternal,

   854                                                TBool aNotifyLocal,

   855                                                TBool aClearInput )

   856     {

   857     FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEndOfCmdHandling()") ));

   858     if ( iInputBuffer.Length() > 0 )

   859         {

   860         iLastBuffer.Copy( iInputBuffer );

   861         }

   862     ResetParseBuffers( aClearInput );

   863     iHandleState = EDunStateIdle;

   864     if ( aNotifyLocal )

   865         {

   866         iCmdPusher->SetEndOfCmdLine();

   867         }

   868     if ( !aNotifyExternal )

   869         {

   870         FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEndOfCmdHandling() (no external) complete") ));

   871         return;

   872         }

   873     TInt foundIndex = FindStartOfNextCommand();

   874     iUpstream->NotifyAtCmdHandlingEnd( foundIndex );

   875     FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEndOfCmdHandling() complete") ));

   876     }

   877 

   878 // ---------------------------------------------------------------------------

   879 // Extracts next decoded command from input buffer to decode buffer

   880 // ---------------------------------------------------------------------------

   881 //

   882 TBool CDunAtCmdHandler::ExtractNextDecodedCommand( TBool aPeek )

   883     {

   884     FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextDecodedCommand()") ));

   885     iParseInfo.iLimit = KErrNotFound;

   886     TDunDecodeInfo oldInfo = iDecodeInfo;

   887     iDecodeInfo.iDecodeBuffer.Zero();

   888     // Find start of decode command from input buffer

   889     TInt startIndex = iDecodeInfo.iDecodeIndex;

   890     startIndex = FindStartOfDecodedCommand( iInputBuffer, startIndex );

   891     if ( startIndex < 0 )

   892         {

   893         RestoreOldDecodeInfo( aPeek, oldInfo );

   894         FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextDecodedCommand() (no start) complete") ));

   895         return EFalse;

   896         }

   897     // Find end of decode command from input buffer

   898     TBool specialCmd = EFalse;

   899     TInt endIndex = KErrNotFound;

   900     specialCmd = CheckSpecialCommand( startIndex, endIndex );

   901     if ( !specialCmd )

   902         {

   903         FindSubCommand( startIndex, endIndex );

   904         }

   905     if ( endIndex < startIndex )

   906         {

   907         RestoreOldDecodeInfo( aPeek, oldInfo );

   908         FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextDecodedCommand() (no end) complete") ));

   909         return EFalse;

   910         }

   911     TInt cmdLength = endIndex - startIndex + 1;

   912     // If the limit was not already set then do it now

   913     if ( iParseInfo.iLimit < 0 )

   914         {

   915         iParseInfo.iLimit = cmdLength;

   916         }

   917     // Next create a new command

   918     if ( !iDecodeInfo.iFirstDecode && !specialCmd )

   919         {

   920         _LIT( KAtMsg, "AT" );

   921         iDecodeInfo.iDecodeBuffer.Append( KAtMsg );

   922         iParseInfo.iLimit += 2;  // Length of "AT"

   923         // Note: The length of iDecodeBuffer is not exceeded here because "AT"

   924         // is added only for the second commands after that.

   925         }

   926     TPtrC8 decodedCmd = iInputBuffer.Mid( startIndex, cmdLength );

   927     iDecodeInfo.iDecodeBuffer.Append( decodedCmd );

   928     // Set index for next round

   929     iDecodeInfo.iFirstDecode = EFalse;

   930     iDecodeInfo.iDecodeIndex = endIndex + 1;

   931     RestoreOldDecodeInfo( aPeek, oldInfo );

   932     FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextDecodedCommand() complete") ));

   933     return ETrue;

   934     }

   935 

   936 // ---------------------------------------------------------------------------

   937 // Restores old decode info. For ExtractNextDecodedCommand() when aPeeks is

   938 // ETrue.

   939 // ---------------------------------------------------------------------------

   940 //

   941 void CDunAtCmdHandler::RestoreOldDecodeInfo( TBool aPeek,

   942                                              TDunDecodeInfo& aOldInfo )

   943     {

   944     FTRACE(FPrint( _L("CDunAtCmdHandler::RestoreOldDecodeInfo()") ));

   945     if ( aPeek )

   946         {

   947         iEditorModeInfo.iPeekInfo = iDecodeInfo;

   948         iDecodeInfo = aOldInfo;

   949         }

   950     FTRACE(FPrint( _L("CDunAtCmdHandler::RestoreOldDecodeInfo() complete") ));

   951     }

   952 

   953 // ---------------------------------------------------------------------------

   954 // Finds end of an AT command

   955 // ---------------------------------------------------------------------------

   956 //

   957 TInt CDunAtCmdHandler::FindEndOfCommand( TDesC8& aDes, TInt aStartIndex )

   958     {

   959     FTRACE(FPrint( _L("CDunAtCmdHandler::FindEndOfCommand()") ));

   960     TInt i;

   961     TInt length = aDes.Length();

   962     for ( i=aStartIndex; i<length; i++ )

   963         {

   964         TChar character = aDes[i];

   965         if ( IsEndOfCommand(character) )

   966             {

   967             FTRACE(FPrint( _L("CDunAtCmdHandler::FindEndOfCommand() complete (%d)"), i ));

   968             return i;

   969             }

   970         }

   971     FTRACE(FPrint( _L("CDunAtCmdHandler::FindEndOfCommand() (not found) complete") ));

   972     return KErrNotFound;

   973     }

   974 

   975 // ---------------------------------------------------------------------------

   976 // Tests for end of AT command character

   977 // ---------------------------------------------------------------------------

   978 //

   979 TBool CDunAtCmdHandler::IsEndOfCommand( TChar& aCharacter )

   980     {

   981     FTRACE(FPrint( _L("CDunAtCmdHandler::IsEndOfCommand()") ));

   982     if ( aCharacter==iCarriageReturn || aCharacter==iLineFeed )

   983         {

   984         FTRACE(FPrint( _L("CDunAtCmdHandler::IsEndOfCommand() (found) complete") ));

   985         return ETrue;

   986         }

   987     FTRACE(FPrint( _L("CDunAtCmdHandler::IsEndOfCommand() (not found) complete") ));

   988     return EFalse;

   989     }

   990 

   991 // ---------------------------------------------------------------------------

   992 // Finds start of a decoded AT command

   993 // ---------------------------------------------------------------------------

   994 //

   995 TInt CDunAtCmdHandler::FindStartOfDecodedCommand( TDesC8& aDes,

   996                                                   TInt aStartIndex )

   997     {

   998     FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfDecodedCommand()") ));

   999     TInt i;

  1000     TInt count = aDes.Length();

  1001     for ( i=aStartIndex; i<count; i++ )

  1002         {

  1003         TChar character = aDes[i];

  1004         if ( !IsDelimiterCharacter(character) )

  1005             {

  1006             FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfDecodedCommand() complete (%d)"), i ));

  1007             return i;

  1008             }

  1009         }

  1010     FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfDecodedCommand() (not found) complete") ));

  1011     return KErrNotFound;

  1012     }

  1013 

  1014 // ---------------------------------------------------------------------------

  1015 // Checks if character is delimiter character

  1016 // ---------------------------------------------------------------------------

  1017 //

  1018 TBool CDunAtCmdHandler::IsDelimiterCharacter( TChar aCharacter )

  1019     {

  1020     FTRACE(FPrint( _L("CDunAtCmdHandler::IsDelimiterCharacter()") ));

  1021     if ( aCharacter.IsSpace() || aCharacter==';' || aCharacter==0x00 )

  1022         {

  1023         FTRACE(FPrint( _L("CDunAtCmdHandler::IsDelimiterCharacter() complete") ));

  1024         return ETrue;

  1025         }

  1026     FTRACE(FPrint( _L("CDunAtCmdHandler::IsDelimiterCharacter() (not delimiter) complete") ));

  1027     return EFalse;

  1028     }

  1029 

  1030 // ---------------------------------------------------------------------------

  1031 // Checks if character is of extended group

  1032 // ---------------------------------------------------------------------------

  1033 //

  1034 TBool CDunAtCmdHandler::IsExtendedCharacter( TChar aCharacter )

  1035     {

  1036     FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedCharacter()") ));

  1037     if ( aCharacter=='+'  || aCharacter=='&' || aCharacter=='%' ||

  1038          aCharacter=='\\' || aCharacter=='*' || aCharacter=='#' ||

  1039          aCharacter=='$'  || aCharacter=='^' )

  1040         {

  1041         FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedCharacter() complete") ));

  1042         return ETrue;

  1043         }

  1044     FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedCharacter() (not extended) complete") ));

  1045     return EFalse;

  1046     }

  1047 

  1048 // ---------------------------------------------------------------------------

  1049 // Checks special command

  1050 // ---------------------------------------------------------------------------

  1051 //

  1052 TBool CDunAtCmdHandler::CheckSpecialCommand( TInt aStartIndex,

  1053                                              TInt& aEndIndex )

  1054     {

  1055     FTRACE(FPrint( _L("CDunAtCmdHandler::CheckSpecialCommand()") ));

  1056     TBuf8<KDunInputBufLength> upperBuf;

  1057     TInt newLength = iInputBuffer.Length() - aStartIndex;

  1058     upperBuf.Copy( &iInputBuffer[aStartIndex], newLength );

  1059     upperBuf.UpperCase();

  1060     TInt i;

  1061     TInt count = iSpecials.Count();

  1062     for ( i=0; i<count; i++ )

  1063         {

  1064         HBufC8* specialCmd = iSpecials[i];

  1065         TInt specialLength = specialCmd->Length();

  1066         if ( newLength < specialLength )

  1067             {

  1068             continue;

  1069             }

  1070         TInt origLength = newLength;

  1071         if ( newLength > specialLength )

  1072             {

  1073             upperBuf.SetLength( specialLength );

  1074             }

  1075         TInt cmpResult = upperBuf.Compare( *specialCmd );

  1076         upperBuf.SetLength( origLength );

  1077         if ( cmpResult == 0 )

  1078             {

  1079             iParseInfo.iLimit = specialLength;

  1080             aEndIndex = (origLength-1) + aStartIndex;

  1081             FTRACE(FPrint( _L("CDunAtCmdHandler::CheckSpecialCommand() complete") ));

  1082             return ETrue;

  1083             }

  1084         }

  1085     FTRACE(FPrint( _L("CDunAtCmdHandler::CheckSpecialCommand() (not found) complete") ));

  1086     return EFalse;

  1087     }

  1088 

  1089 // ---------------------------------------------------------------------------

  1090 // Saves character decode state for a found character

  1091 // ---------------------------------------------------------------------------

  1092 //

  1093 void CDunAtCmdHandler::SaveFoundCharDecodeState( TChar aCharacter,

  1094                                                  TBool aAddSpecial )

  1095     {

  1096     FTRACE(FPrint( _L("CDunAtCmdHandler::SaveFoundCharDecodeState()") ));

  1097     iDecodeInfo.iPrevExists = ETrue;

  1098     iDecodeInfo.iPrevChar = aCharacter;

  1099     if ( aAddSpecial )

  1100         {

  1101         iDecodeInfo.iSpecialFound =

  1102                 iAtSpecialCmdHandler->IsCompleteSubCommand( aCharacter );

  1103         }

  1104     FTRACE(FPrint( _L("CDunAtCmdHandler::SaveFoundCharDecodeState() complete") ));

  1105     }

  1106 

  1107 // ---------------------------------------------------------------------------

  1108 // Saves character decode state for a not found character

  1109 // ---------------------------------------------------------------------------

  1110 //

  1111 void CDunAtCmdHandler::SaveNotFoundCharDecodeState()

  1112     {

  1113     FTRACE(FPrint( _L("CDunAtCmdHandler::SaveNotFoundCharDecodeState()") ));

  1114     iDecodeInfo.iPrevExists = EFalse;

  1115     // Note: don't set iAssignFound or iInQuotes here

  1116     iDecodeInfo.iSpecialFound = EFalse;

  1117     FTRACE(FPrint( _L("CDunAtCmdHandler::SaveNotFoundCharDecodeState() complete") ));

  1118     }

  1119 

  1120 // ---------------------------------------------------------------------------

  1121 // Find quotes within subcommands

  1122 // ---------------------------------------------------------------------------

  1123 //

  1124 TBool CDunAtCmdHandler::FindSubCommandQuotes( TChar aCharacter,

  1125                                               TInt aStartIndex,

  1126                                               TInt& aEndIndex )

  1127     {

  1128     FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommandQuotes()") ));

  1129     if ( aCharacter == '"' )

  1130         {

  1131         if ( iParseInfo.iLimit < 0 )  // Only first the first '"'

  1132             {

  1133             iParseInfo.iLimit = aEndIndex - aStartIndex;

  1134             }

  1135         iDecodeInfo.iInQuotes ^= ETrue;  // EFalse to ETrue or ETrue to EFalse