FCL/sf/mw/shortlinkconn: comparison localconnectivityservice/dun/atext/src/DunAtCmdHandler.cpp

equal deleted inserted replaced

-:7e0ecb5b116a
+:3dcb815346df
 *   Thus the ATEXT plugins don't need to check for case. The conversion to
 *   upper case form stops when carriage return or '=' character is found.
 */
 /*
+* This file has the following functionality:
+* 1) Line buffer filler:
+*    AddDataForParsing(), ManagePartialCommand(), ExtractLineFromInputBuffer(),
+*    etc. This buffer is used for parsing. These functions are used for
+*    splitter-combiner logic described below. CDunAtCmdPusher is used
+*    separately for each element in the line buffer.
+* 2) Parser and splitter-combiner to handle the separater elements (subcommands)
+*    in the line buffer. When end of line is detected, iEndIndex is used to
+*    extract the next line in iInput to the line buffer (ManageEndOfCmdHandling()
+*    and ExtractLineFromInputBuffer()).
+* 3) When end of iEndIndex is found (ExtractLineFromInputBuffer()), more data
+*    is asked from CDunUpstream.
+* Note: There is separate handling for "one character input data" and "A/"
+* command handling which should be supported only for one line based data
+* (ManagePartialCommand()).
+*/
+/*
 * The AT command handling is splitted to two parts on high level:
 * 1) Splitter: splitting the sub-commands in a command line to multiple ones
 *    for ATEXT to process.
 * 2) Combiner: combining the replies coming from ATEXT using a filter
 *    (the filter categories are explained in DunAtCmdPusher.cpp)
+*/
+/*
+* Note1: This file uses AT command parsing based on heuristics.
+* Refer to test specification if planning to change the heuristic.
+* Note2: Input buffer management (ExtractLineFromInputBuffer()) can be tested
+* with non-line based terminals such as HyperTerminal or Realterm.
 */
 #include "DunAtCmdHandler.h"
 #include "DunAtUrcHandler.h"
 #include "DunDownstream.h"
 FTRACE(FPrint( _L("CDunAtCmdHandler::AddCmdModeCallback() complete" ) ));
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
-// Parses an AT command
+// Adds data for parsing and parses if necessary
 // ---------------------------------------------------------------------------
 //
-EXPORT_C TInt CDunAtCmdHandler::ParseCommand( TDesC8& aCommand,
+EXPORT_C TInt CDunAtCmdHandler::AddDataForParsing( TDesC8& aInput,
-TBool& aPartialInput )
+TBool& aMoreNeeded )
 {
-FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand()") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::AddDataForParsing()") ));
-FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() received:") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::AddDataForParsing() received (%d bytes):"), aInput.Length() ));
-FTRACE(FPrintRaw(aCommand) );
+FTRACE(FPrintRaw(aInput) );
 TBool editorMode = iCmdPusher->EditorMode();
 if ( editorMode )
 {
-// Note: return here with "no partial input" and some error to fool
+// Note: return here with "no more data needed" and some error to fool
 // CDunUpstream into not reissuing the read request.
-iCmdPusher->IssueRequest( aCommand, EFalse );
+iCmdPusher->IssueRequest( aInput, EFalse );
-aPartialInput = EFalse;
+aMoreNeeded = EFalse;
 return KErrGeneral;
 }
-iCommand = &aCommand;  // iCommand only for normal mode
+iInput = &aInput;  // iInput only for normal mode
 // Manage partial AT command
-TBool needsCarriage = ETrue;
+TBool moreNeeded = ManagePartialCommand();
-TBool okToExit = ManagePartialCommand( aCommand, needsCarriage );
+if ( moreNeeded )
-if ( okToExit )
+{
-{
+aMoreNeeded = ETrue;
-FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() (ok to exit) complete") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::AddDataForParsing() (more partial) complete") ));
-aPartialInput = ETrue;
 return KErrNone;
 }
 if ( iHandleState != EDunStateIdle )
 {
-aPartialInput = EFalse;
+aMoreNeeded = EFalse;
-ResetParseBuffers();
+ManageEndOfCmdHandling( EFalse, EFalse );
-FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() (not ready) complete") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::AddDataForParsing() (not ready) complete") ));
 return KErrNotReady;
 }
 TBool pushStarted = HandleASlashCommand();
 if ( pushStarted )
 {
 // Note: return here with "partial input" status to fool CDunUpstream
 // into reissuing the read request. The AT command has not really
 // started yet so this is necessary.
-aPartialInput = ETrue;
+aMoreNeeded = ETrue;
-ResetParseBuffers();
+ManageEndOfCmdHandling( EFalse, EFalse );
-FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() (A/) complete") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::AddDataForParsing() (A/) complete") ));
 return KErrNone;
 }
-FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() received total:") ));
-FTRACE(FPrintRaw(iInputBuffer) );
 iHandleState = EDunStateAtCmdHandling;
-iUpstream->NotifyAtCmdHandlingStart();
 iDecodeInfo.iFirstDecode = ETrue;
 iDecodeInfo.iDecodeIndex = 0;
-HandleNextDecodedCommand();
+iDecodeInfo.iPrevExists = EFalse;
-FTRACE(FPrint( _L("CDunAtCmdHandler::ParseCommand() complete") ));
+iParseInfo.iLimit = KErrNotFound;
-aPartialInput = EFalse;
+iParseInfo.iSendBuffer.Zero();
+iEditorModeInfo.iContentFound = EFalse;
+HandleNextSubCommand();
+FTRACE(FPrint( _L("CDunAtCmdHandler::AddDataForParsing() complete") ));
+aMoreNeeded = EFalse;
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 // Manages request to abort command handling
 FTRACE(FPrint( _L("CDunAtCmdHandler::ManageAbortRequest() complete") ));
 return retVal;
 }
 // ---------------------------------------------------------------------------
-// Sets end of command line marker on for the possible series of AT commands.
-// ---------------------------------------------------------------------------
-//
-EXPORT_C void CDunAtCmdHandler::SetEndOfCmdLine( TBool aClearInput )
-{
-FTRACE(FPrint( _L("CDunAtCmdHandler::SetEndOfCmdLine()") ));
-ManageEndOfCmdHandling( EFalse, ETrue, aClearInput );
-FTRACE(FPrint( _L("CDunAtCmdHandler::SetEndOfCmdLine() complete") ));
-}
-// ---------------------------------------------------------------------------
 // Sends a character to be echoed
 // ---------------------------------------------------------------------------
 //
 EXPORT_C TInt CDunAtCmdHandler::SendEchoCharacter( const TDesC8* aInput,
 MDunAtCmdEchoer* aCallback )
 return KErrNotReady;
 }
 iCmdPusher->Stop();
 // The line below is used in the case when this function is called by
 // CDunUpstream as a result of "data mode ON" change notification.
-// In this case it is possible that HandleNextDecodedCommand() returns
+// In this case it is possible that HandleNextSubCommand() returns
-// without resetting the iInputBuffer because of the way it checks the
+// without resetting the iSendBuffer because of the way it checks the
 // iHandleState.
-ManageEndOfCmdHandling( EFalse, ETrue, ETrue );
+ManageEndOfCmdHandling( ETrue, EFalse );
 FTRACE(FPrint( _L("CDunAtCmdHandler::Stop() complete") ));
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 // Don't initialize iConnectionName here (it is set through NewL)
 iHandleState = EDunStateIdle;
 iCarriageReturn = 0;
 iLineFeed = 0;
 iBackspace = 0;
-iCommand = NULL;
+iInput = NULL;
 iDecodeInfo.iFirstDecode = ETrue;
 iDecodeInfo.iDecodeIndex = KErrNotFound;
 iDecodeInfo.iExtendedIndex = KErrNotFound;
 iDecodeInfo.iPrevChar = 0;
 iDecodeInfo.iPrevExists = EFalse;
 iDecodeInfo.iAssignFound = EFalse;
 iDecodeInfo.iInQuotes = EFalse;
 iDecodeInfo.iSpecialFound = EFalse;
+iDecodeInfo.iCmdsHandled = 0;
 iEditorModeInfo.iContentFound = EFalse;
 iCmdPusher = NULL;
 iEcomListen = NULL;
 iModeListen = NULL;
 iNvramListen = NULL;
 FTRACE(FPrint( _L("CDunAtCmdHandler::CreateSpecialCommandsL()") ));
 TInt retTemp = KErrNone;
 TBool firstSearch = ETrue;
 for ( ;; )
 {
-retTemp = iAtCmdExt.GetNextSpecialCommand( iInputBuffer, firstSearch );
+// Let's borrow iLineBuffer for this purpose
+retTemp = iAtCmdExt.GetNextSpecialCommand( iLineBuffer, firstSearch );
 if ( retTemp != KErrNone )
 {
 break;
 }
-HBufC8* specialCmd = HBufC8::NewMaxLC( iInputBuffer.Length() );
+TInt lineLength = iLineBuffer.Length();
-TPtr8 specialCmdPtr = specialCmd->Des();
+HBufC8* specialCmd = HBufC8::NewMaxLC( lineLength );
-specialCmdPtr.Copy( iInputBuffer );
+*specialCmd = iLineBuffer;
-specialCmdPtr.UpperCase();
 iSpecials.AppendL( specialCmd );
 CleanupStack::Pop( specialCmd );
 }
-iInputBuffer.Zero();
+iLineBuffer.Zero();
 FTRACE(FPrint( _L("CDunAtCmdHandler::CreateSpecialCommandsL() complete") ));
 }
 // ---------------------------------------------------------------------------
 // Recreates special command data.
 // ---------------------------------------------------------------------------
 //
 TBool CDunAtCmdHandler::RegenerateOkReply()
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateOkReply()") ));
+if ( iDownstream->IsDataInQueue(&iOkBuffer) )
+{
+FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateOkReply() (in queue!) complete") ));
+return iQuietOn;
+}
 iOkBuffer.Zero();
 if ( iQuietOn )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateOkReply() (quiet) complete") ));
 return ETrue;
 // ---------------------------------------------------------------------------
 //
 TBool CDunAtCmdHandler::RegenerateErrorReply()
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateErrorReply()") ));
+if ( iDownstream->IsDataInQueue(&iErrorBuffer) )
+{
+FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateErrorReply() (in queue!) complete") ));
+return iQuietOn;
+}
 iErrorBuffer.Zero();
 if ( iQuietOn )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::RegenerateErrorReply() (quiet) complete") ));
 return ETrue;
 // ---------------------------------------------------------------------------
 // Manages partial AT command
 // ---------------------------------------------------------------------------
 //
-TBool CDunAtCmdHandler::ManagePartialCommand( TDesC8& aCommand,
+TBool CDunAtCmdHandler::ManagePartialCommand()
-TBool& aNeedsCarriage )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand()") ));
-aNeedsCarriage = ETrue;
-// Check length of command
-if ( aCommand.Length() == 0 )
-{
-FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (length zero) complete") ));
-return ETrue;
-}
 // Check one character (or unit) based input data
-if ( aCommand.Length() == KDunChSetMaxCharLen )
+if ( iInput->Length() == KDunChSetMaxCharLen )
 {
-EchoCommand( aCommand );
+EchoCommand();
 // Handle backspace and cancel characters
-TBool found = HandleSpecialCharacters( aCommand );
+TBool found = HandleSpecialCharacters();
 if ( found )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (special) complete") ));
 return ETrue;
 }
 }
-TBool endFound = EFalse;
+TBool moreNeeded = ExtractLineFromInputBuffer();
-TBool overflow = AppendCommandToInputBuffer( aCommand, endFound );
+if ( moreNeeded )
-if ( overflow )
+{
-{
+// More data is not needed with "A/" (no carriage return), check that
-// Overflow occurred so return ETrue (consumed) to skip all the rest
+// special case here, otherwise continue processing
-// characters until carriage return is found
+if ( !IsASlashCommand() )
-FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (overflow) complete") ));
+{
-return ETrue;
+FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (more) complete") ));
+return ETrue;
+}
 }
 // If something went wrong, do nothing (return consumed)
-if ( iInputBuffer.Length() <= 0 )
+if ( iLineBuffer.Length() <= 0 )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (length) complete") ));
 return ETrue;
 }
-// If "A/", no carriage return is needed, check that now
+// For other commands, just return with consumed
-if ( IsASlashCommand() )
-{
-aNeedsCarriage = EFalse;
-FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (A/) complete") ));
-return EFalse;
-}
-// For other commands and if no end, just return with consumed
-if ( !endFound )
-{
-FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() (void) complete") ));
-return ETrue;
-}
 FTRACE(FPrint( _L("CDunAtCmdHandler::ManagePartialCommand() complete") ));
 return EFalse;
 }
 // ---------------------------------------------------------------------------
 // Echoes a command if echo is on
 // ---------------------------------------------------------------------------
 //
-TBool CDunAtCmdHandler::EchoCommand( TDesC8& aDes )
+TBool CDunAtCmdHandler::EchoCommand()
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand()") ));
-if ( aDes.Length() > KDunChSetMaxCharLen )
+if ( iInput->Length() > KDunChSetMaxCharLen )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand() (wrong length) complete") ));
 return EFalse;
 }
 if ( iEchoOn )
 {
-iEchoBuffer.Copy( aDes );
+if ( iDownstream->IsDataInQueue(&iEchoBuffer) )
+{
+FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand() (in queue!) complete") ));
+return EFalse;
+}
+iEchoBuffer.Copy( *iInput );
 iDownstream->NotifyDataPushRequest( &iEchoBuffer, NULL );
 FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand() complete") ));
 return ETrue;
 }
 FTRACE(FPrint( _L("CDunAtCmdHandler::EchoCommand() (not started) complete") ));
 // ---------------------------------------------------------------------------
 // Handles backspace and cancel characters
 // ---------------------------------------------------------------------------
 //
-TBool CDunAtCmdHandler::HandleSpecialCharacters( TDesC8& aCommand )
+TBool CDunAtCmdHandler::HandleSpecialCharacters()
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters()") ));
-if ( aCommand.Length() != KDunChSetMaxCharLen )
+if ( iInput->Length() != KDunChSetMaxCharLen )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters() (wrong length) complete") ));
 return EFalse;
 }
-if ( aCommand[0] == iBackspace )
+if ( (*iInput)[0] == iBackspace )
 {
-TInt bufferLength = iInputBuffer.Length();
+TInt lineLength = iLineBuffer.Length();
-if ( bufferLength > 0 )
+if ( lineLength > 0 )
 {
-iInputBuffer.SetLength( bufferLength-1 );
+iLineBuffer.SetLength( lineLength-1 );
 }
 FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters() (backspace) complete") ));
 return ETrue;
 }
-if ( aCommand[0] == KDunCancel )
+if ( (*iInput)[0] == KDunCancel )
 {
-ResetParseBuffers();  // More processing here?
+ManageEndOfCmdHandling( EFalse, EFalse );
 FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters() (cancel) complete") ));
 return ETrue;
 }
 FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialCharacters() complete") ));
 return EFalse;
 }
 // ---------------------------------------------------------------------------
-// Appends command to parse buffer
+// Extracts line from input buffer to line buffer
 // ---------------------------------------------------------------------------
 //
-TBool CDunAtCmdHandler::AppendCommandToInputBuffer( TDesC8& aCommand,
+TBool CDunAtCmdHandler::ExtractLineFromInputBuffer()
-TBool& aEndFound )
+{
-{
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer()") ));
-FTRACE(FPrint( _L("CDunAtCmdHandler::AppendCommandToInputBuffer()") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() before (%d bytes):"), iLineBuffer.Length() ));
-aEndFound = EFalse;
+FTRACE(FPrintRaw(iLineBuffer) );
-TInt cmdBufIndex = 0;
+// Case1: If no data in iLineBuffer and end-of-line character in iInputBuffer[start]:
-TInt cmdBufLim = aCommand.Length();
+//     - Skip end-of-line characters, find start-of-line condition, find end-of-line character
-while ( cmdBufIndex < cmdBufLim )
+//     - If partial line found (start-of-line condition and no end-of-line character):
-{
+//           - Save partial line to iLineBuffer
-if ( iInputBuffer.Length() == iInputBuffer.MaxLength() )
+//           - Set iEndIndex to end of iInputBuffer
-{
+//     - If full line found (start-of-line condition and end-of-line character):
-// 1) If output is full and end found from input
+//           - Save full line to iLineBuffer
-//    -> reset buffers and overflow found
+//           - Skip multiple end-of-line characters until next start-of-line
-// 2) If output is full and end not found from input
+//             condition or end of iInputBuffer -> save this position to iEndIndex
-//    -> don't reset buffers and overflow found
+// Case2: If no data in iLineBuffer and non-end-of-line character in iInputBuffer[start]:
-TInt foundIndex = FindEndOfCommand( aCommand );
+//     - Find end-of-line character
-if ( foundIndex >= 0 )
+//     - If partial line found (no end-of-line character):
-{
+//           - Save partial line to iLineBuffer
-aEndFound = ETrue;
+//           - Set iEndIndex to end of iLineBuffer
-ResetParseBuffers();
+//     - If full line found (end-of-line character):
-FTRACE(FPrint( _L("CDunAtCmdHandler::AppendCommandToInputBuffer() (reset) complete") ));
+//           - Save full line to iLineBuffer
-}
+//           - Skip multiple end-of-line characters until next start-of-line
-FTRACE(FPrint( _L("CDunAtCmdHandler::AppendCommandToInputBuffer() (overflow) complete") ));
+//             condition or end of iInputBuffer -> save this position to iEndIndex
+// Case3: If data in iLineBuffer and end-of-line character in iInputBuffer[start]:
+//     - Skip end-of-line characters
+//     - Keep string currently in iLineBuffer
+//     - Skip end-of-line characters until non-end-of-line or end of
+//       iInputBuffer -> save this position to iEndIndex
+// Case4: If data in iLineBuffer and non-end-of-line character in iInputBuffer[start]:
+//     - Processed the same way as Case1, however "Skip end-of-line characters" does
+//       not have any effect
+if ( iInput->Length() <= 0 )
+{
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() (wrong length) complete") ));
+return ETrue;
+}
+TBool moreNeeded = ETrue;
+TBool copyNeeded = EFalse;
+TInt copyLength = KErrNotFound;
+TInt lineLength = iLineBuffer.Length();
+TInt lineMaxLength = iLineBuffer.MaxLength();
+TInt freeLineSpace = lineMaxLength - lineLength;
+TInt inputLength = iInput->Length();
+TInt startIndex = ( iEndIndex>=0 ) ? iEndIndex : 0;
+if ( startIndex >= inputLength )
+{
+iEndIndex = KErrNotFound;
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() (input end) complete") ));
+return ETrue;
+}
+// Cases here:
+// Case1: If no data in iLineBuffer and end-of-line character in iInputBuffer[start]
+// Case2: If no data in iLineBuffer and non-end-of-line character in iInputBuffer[start]
+// Case3: If data in iLineBuffer and end-of-line character in iInputBuffer[start]
+// Case4: If data in iLineBuffer and non-end-of-line character in iInputBuffer[start]
+// Summary: Cases 1, 2 and 4 can be combined. Case 3 needs a separate check.
+TChar character = (*iInput)[startIndex];
+TBool endOfLine = IsEndOfLine(character);
+if ( lineLength>0 && endOfLine )
+{
+moreNeeded = HandleSpecialBufferManagement( startIndex,
+copyLength,
+copyNeeded );
+}
+else
+{
+moreNeeded = HandleGenericBufferManagement( startIndex,
+copyLength,
+copyNeeded );
+}
+if ( copyNeeded && copyLength>0 )
+{
+// Check the case copyLength does not fit to iLineBuffer
+// This case should be handled by returning "more data needed"
+// Also reset the iLineBuffer to ensure the handling doesn't stuck
+// for rest of the commands (usability case)
+if ( copyLength > freeLineSpace )
+{
+iLineBuffer.Zero();
+iEndIndex = KErrNotFound;
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() after (%d bytes):"), iLineBuffer.Length() ));
+FTRACE(FPrintRaw(iLineBuffer) );
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() (overflow) complete") ));
 return ETrue;
 }
-TChar character = aCommand[cmdBufIndex];
+iLineBuffer.Append( &(*iInput)[startIndex], copyLength );
-if ( IsEndOfCommand(character) )
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() after (%d bytes):"), iLineBuffer.Length() ));
-{
+FTRACE(FPrintRaw(iLineBuffer) );
-aEndFound = ETrue;
+}
-iEndIndex = cmdBufIndex;
+if ( moreNeeded )
+{
+iEndIndex = KErrNotFound;
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() (more needed) complete") ));
+return ETrue;
+}
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractLineFromInputBuffer() (line found) complete") ));
+return EFalse;
+}
+// ---------------------------------------------------------------------------
+// Handles generic buffer management
+// (explanation in ExtractLineFromInputBuffer())
+// ---------------------------------------------------------------------------
+//
+TBool CDunAtCmdHandler::HandleGenericBufferManagement( TInt& aStartIndex,
+TInt& aCopyLength,
+TBool& aCopyNeeded )
+{
+FTRACE(FPrint( _L("CDunAtCmdHandler::HandleGenericBufferManagement()") ));
+TInt inputLength = iInput->Length();
+TInt currentIndex = SkipEndOfLineCharacters( aStartIndex );
+if ( currentIndex >= inputLength )
+{
+// No data in iLineBuffer and only end-of-lines in new buffer
+// return with "need more data"
+iEndIndex = inputLength;
+aCopyLength = 0;
+aCopyNeeded = EFalse;
+FTRACE(FPrint( _L("CDunAtCmdHandler::HandleGenericBufferManagement() (new end for old no data) complete") ));
+return ETrue;
+}
+// No data in iLineBuffer and non-end-of-line character found
+// Try to find the first start-of-line condition
+TInt lineLength = iLineBuffer.Length();
+if ( lineLength == 0 )
+{
+currentIndex = SkipSubCommandDelimiterCharacters( aStartIndex );
+if ( currentIndex >= inputLength )
+{
+// No data in iLineBuffer and only end-of-lines+delimiter in new buffer
+// return with "need more data"
+iEndIndex = inputLength;
+aCopyLength = 0;
+aCopyNeeded = EFalse;
+FTRACE(FPrint( _L("CDunAtCmdHandler::HandleGenericBufferManagement() (new end+delim for old no data) complete") ));
+return ETrue;
+}
+}
+aStartIndex = currentIndex;
+// No data in iLineBuffer and other than end-of-line or delimiter character found
+// Variable currentIndex is now the start of new command
+// Next try to find the end of the command
+TInt endIndex = FindEndOfLine( aStartIndex );
+if ( endIndex >= inputLength )
+{
+// No data in iLineBuffer and start of command found without end
+// return with "need more data"
+iEndIndex = inputLength;
+aCopyLength = inputLength - aStartIndex;
+aCopyNeeded = ETrue;
+FTRACE(FPrint( _L("CDunAtCmdHandler::HandleGenericBufferManagement() (start but no end for old no data) complete") ));
+return ETrue;
+}
+// No data in iLineBuffer and end-of-line character found
+// Try to skip possible multiple end-of-line characters
+currentIndex = SkipEndOfLineCharacters( endIndex );
+// Variable currentIndex is now either start of next command or end of iInput
+// Note that this requires that Case 2 must skip the possible IsDelimiterCharacter()s
+iEndIndex = currentIndex;
+aCopyLength = endIndex - aStartIndex;
+aCopyNeeded = ETrue;
+FTRACE(FPrint( _L("CDunAtCmdHandler::HandleGenericBufferManagement() (line found) complete") ));
+return EFalse;
+}
+// ---------------------------------------------------------------------------
+// Handles special buffer management
+// (explanation in ExtractLineFromInputBuffer())
+// ---------------------------------------------------------------------------
+//
+TBool CDunAtCmdHandler::HandleSpecialBufferManagement( TInt aStartIndex,
+TInt& aCopyLength,
+TBool& aCopyNeeded )
+{
+FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialBufferManagement()") ));
+TInt currentIndex = SkipEndOfLineCharacters( aStartIndex );
+// Variable currentIndex is now either start of next command or end of iInput
+iEndIndex = currentIndex;
+aCopyLength = 0;
+aCopyNeeded = EFalse;
+FTRACE(FPrint( _L("CDunAtCmdHandler::HandleSpecialBufferManagement() complete") ));
+return EFalse;
+}
+// ---------------------------------------------------------------------------
+// Skips end-of-line characters
+// ---------------------------------------------------------------------------
+//
+TInt CDunAtCmdHandler::SkipEndOfLineCharacters( TInt aStartIndex )
+{
+FTRACE(FPrint( _L("CDunAtCmdHandler::SkipEndOfLineCharacters()") ));
+TInt foundIndex = iInput->Length();
+TInt inputLength = foundIndex;
+for ( TInt i=aStartIndex; i<inputLength; i++ )
+{
+TChar character = (*iInput)[i];
+if ( !IsEndOfLine(character) )
+{
+foundIndex = i;
 break;
 }
-iInputBuffer.Append( aCommand[cmdBufIndex] );
+}
-cmdBufIndex++;
+FTRACE(FPrint( _L("CDunAtCmdHandler::SkipEndOfLineCharacters() complete") ));
-}
+return foundIndex;
-FTRACE(FPrint( _L("CDunAtCmdHandler::AppendCommandToInputBuffer() complete") ));
+}
-return EFalse;
-}
+// ---------------------------------------------------------------------------
+// Skips subcommand delimiter characters
 // ---------------------------------------------------------------------------
-// Handles next decoded command from input buffer
+//
-// ---------------------------------------------------------------------------
+TInt CDunAtCmdHandler::SkipSubCommandDelimiterCharacters( TInt aStartIndex )
-//
+{
-TBool CDunAtCmdHandler::HandleNextDecodedCommand()
+FTRACE(FPrint( _L("CDunAtCmdHandler::SkipSubCommandDelimiterCharacters()") ));
-{
+TInt inputLength = iInput->Length();
-FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextDecodedCommand()") ));
+TInt foundIndex = inputLength;
+for ( TInt i=aStartIndex; i<inputLength; i++ )
+{
+TChar character = (*iInput)[i];
+if ( !IsDelimiterCharacter(character) )
+{
+foundIndex = i;
+break;
+}
+}
+FTRACE(FPrint( _L("CDunAtCmdHandler::SkipSubCommandDelimiterCharacters() complete") ));
+return foundIndex;
+}
+// ---------------------------------------------------------------------------
+// Finds the end of the line
+// ---------------------------------------------------------------------------
+//
+TInt CDunAtCmdHandler::FindEndOfLine( TInt aStartIndex )
+{
+FTRACE(FPrint( _L("CDunAtCmdHandler::FindEndOfLine()") ));
+TInt inputLength = iInput->Length();
+TInt foundIndex = inputLength;
+for ( TInt i=aStartIndex; i<inputLength; i++ )
+{
+TChar character = (*iInput)[i];
+// Checking for IsDelimiterCharacter() here needs more logic (a parser).
+// Just check with "IsEndOfLine()"
+if ( IsEndOfLine(character) )
+{
+foundIndex = i;
+break;
+}
+}
+FTRACE(FPrint( _L("CDunAtCmdHandler::FindEndOfLine() complete") ));
+return foundIndex;
+}
+// ---------------------------------------------------------------------------
+// Handles next subcommand from line buffer
+// ---------------------------------------------------------------------------
+//
+TBool CDunAtCmdHandler::HandleNextSubCommand()
+{
+FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextSubCommand()") ));
 if ( iHandleState != EDunStateAtCmdHandling )
 {
-FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextDecodedCommand() (not ready) complete") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextSubCommand() (not ready) complete") ));
-return ETrue;
+return EFalse;
 }
-TBool extracted = ExtractNextDecodedCommand();
+TBool extracted = ExtractNextSubCommand();
 if ( !extracted )
 {
-ManageEndOfCmdHandling( ETrue, ETrue, ETrue );
+ManageEndOfCmdHandling( ETrue, ETrue );
-FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextDecodedCommand() (last) complete") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextSubCommand() (last) complete") ));
-return ETrue;
+return EFalse;
 }
 // Next convert the decoded AT command to uppercase
 // Don't check for case status -> let mixed cases pass
-iParseInfo.iSendBuffer.Copy( iDecodeInfo.iDecodeBuffer );
+TInt oldLength = iParseInfo.iSendBuffer.Length();
-TInt maxLength = iParseInfo.iSendBuffer.MaxLength();
+iParseInfo.iSendBuffer.SetLength( iParseInfo.iLimit );
-TPtr8 upperDes( &iParseInfo.iSendBuffer[0], iParseInfo.iLimit, maxLength );
+iParseInfo.iSendBuffer.UpperCase();
-upperDes.UpperCase();
+iParseInfo.iSendBuffer.SetLength( oldLength );
 // Next always send the command to ATEXT
 iCmdPusher->IssueRequest( iParseInfo.iSendBuffer );
-FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextDecodedCommand() complete") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::HandleNextSubCommand() complete") ));
-return EFalse;
+return ETrue;
-}
-// ---------------------------------------------------------------------------
-// Finds the start of the next command
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::FindStartOfNextCommand()
-{
-FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfNextCommand()") ));
-// Note: here we need to avoid internal recursion when parsing the
-// multiple IsEndOfCommand() and IsDelimiterCharacter() markers inside the
-// same upstream block.
-// Skip all the extra markers except the one we already know to exist.
-TInt i;
-TInt startVal = iEndIndex + 1;
-TInt foundIndex = KErrNotFound;
-TInt count = iCommand->Length();
-for ( i=startVal; i<count; i++ )
-{
-TChar character = (*iCommand)[i];
-if ( !(IsEndOfCommand(character)||IsDelimiterCharacter(character)) )
-{
-foundIndex = i;
-break;
-}
-}
-FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfNextCommand() complete") ));
-return foundIndex;
 }
 // ---------------------------------------------------------------------------
 // Manages end of AT command handling
 // ---------------------------------------------------------------------------
 //
-void CDunAtCmdHandler::ManageEndOfCmdHandling( TBool aNotifyExternal,
+void CDunAtCmdHandler::ManageEndOfCmdHandling( TBool aNotifyLocal,
-TBool aNotifyLocal,
+TBool aNotifyExternal )
-TBool aClearInput )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEndOfCmdHandling()") ));
-if ( iInputBuffer.Length() > 0 )
+FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEndOfCmdHandling() (loc=%d, ext=%d)"), aNotifyLocal, aNotifyExternal ));
-{
+// If iEndIndex is (>=0 && <iInput.Length()) it means more data waits in
-iLastBuffer.Copy( iInputBuffer );
+// iInput that didn't fit in iInputBuffer.
-}
+TInt cmdLength = iInput->Length();
-ResetParseBuffers( aClearInput );
+TBool subBlock = ( iEndIndex>=0&&iEndIndex<cmdLength ) ? ETrue : EFalse;
+if ( iLineBuffer.Length()>0 && !subBlock )
+{
+// Line buffer set and no partial subblock, copy to lastbuffer
+iLastBuffer.Copy( iLineBuffer );
+}
+iLineBuffer.Zero();
+iDecodeInfo.iFirstDecode = ETrue;
+iDecodeInfo.iDecodeIndex = 0;
+iDecodeInfo.iPrevExists = EFalse;
+iParseInfo.iLimit = KErrNotFound;
+iParseInfo.iSendBuffer.Zero();
+iEditorModeInfo.iContentFound = EFalse;
 iHandleState = EDunStateIdle;
 if ( aNotifyLocal )
 {
 iCmdPusher->SetEndOfCmdLine();
 }
-if ( !aNotifyExternal )
+// iEndIndex must not be reset to KErrNotFound only when
-{
+// ExtractLineFromInputBuffer() found the next line
-FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEndOfCmdHandling() (no external) complete") ));
+// (when moreNeeded is EFalse)
-return;
+TBool resetIndex = ETrue;
-}
+if ( aNotifyExternal )
-TInt foundIndex = FindStartOfNextCommand();
+{
-iUpstream->NotifyAtCmdHandlingEnd( foundIndex );
+TBool moreNeeded = ExtractLineFromInputBuffer();
+if ( moreNeeded )
+{
+iUpstream->NotifyParserNeedsMoreData();
+}
+else
+{
+// AppendBlockToInputBuffer() was able to fill with known end, handle next
+iHandleState = EDunStateAtCmdHandling;
+HandleNextSubCommand();
+resetIndex = EFalse;
+}
+}
+if ( resetIndex )
+{
+iEndIndex = KErrNotFound;
+}
 FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEndOfCmdHandling() complete") ));
 }
 // ---------------------------------------------------------------------------
-// Extracts next decoded command from input buffer to decode buffer
+// Extracts next subcommand from line buffer to send buffer
 // ---------------------------------------------------------------------------
 //
-TBool CDunAtCmdHandler::ExtractNextDecodedCommand( TBool aPeek )
+TBool CDunAtCmdHandler::ExtractNextSubCommand( TBool aPeek )
 {
-FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextDecodedCommand()") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextSubCommand()") ));
+TDunDecodeInfo oldInfo = iDecodeInfo;
 iParseInfo.iLimit = KErrNotFound;
-TDunDecodeInfo oldInfo = iDecodeInfo;
+iParseInfo.iSendBuffer.Zero();
-iDecodeInfo.iDecodeBuffer.Zero();
+// Find start of subcommand from line buffer
-// Find start of decode command from input buffer
+TInt startIndex = FindStartOfSubCommand();
-TInt startIndex = iDecodeInfo.iDecodeIndex;
-startIndex = FindStartOfDecodedCommand( iInputBuffer, startIndex );
 if ( startIndex < 0 )
 {
 RestoreOldDecodeInfo( aPeek, oldInfo );
 FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextDecodedCommand() (no start) complete") ));
 return EFalse;
 }
-// Find end of decode command from input buffer
+iDecodeInfo.iDecodeIndex = startIndex;
 TBool specialCmd = EFalse;
 TInt endIndex = KErrNotFound;
-specialCmd = CheckSpecialCommand( startIndex, endIndex );
+specialCmd = CheckSpecialCommand( endIndex );
 if ( !specialCmd )
 {
-FindSubCommand( startIndex, endIndex );
+FindSubCommand( endIndex );
 }
-if ( endIndex < startIndex )
+TInt lineLength = iLineBuffer.Length();
+TBool inStartLimits = ( startIndex >= 0 && startIndex < lineLength ) ? ETrue : EFalse;
+TBool inEndLimits   = ( endIndex   >= 0 && endIndex   < lineLength ) ? ETrue : EFalse;
+if ( !inStartLimits || !inEndLimits )
 {
 RestoreOldDecodeInfo( aPeek, oldInfo );
-FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextDecodedCommand() (no end) complete") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextSubCommand() (no end) complete") ));
 return EFalse;
 }
 TInt cmdLength = endIndex - startIndex + 1;
 // If the limit was not already set then do it now
 if ( iParseInfo.iLimit < 0 )
 iParseInfo.iLimit = cmdLength;
 }
 // Next create a new command
 if ( !iDecodeInfo.iFirstDecode )
 {
-_LIT( KAtMsg, "AT" );
+_LIT( KAtPrefix, "AT" );
-iDecodeInfo.iDecodeBuffer.Append( KAtMsg );
+iParseInfo.iSendBuffer.Append( KAtPrefix );
 if ( !specialCmd )  // Already added with CheckSpecialCommand()
 {
 iParseInfo.iLimit += 2;  // Length of "AT"
 }
 // Note: The length of iDecodeBuffer is not exceeded here because "AT"
 // is added only for the second commands after that.
 }
-TPtrC8 decodedCmd = iInputBuffer.Mid( startIndex, cmdLength );
+iParseInfo.iSendBuffer.Append( &iLineBuffer[startIndex], cmdLength );
-iDecodeInfo.iDecodeBuffer.Append( decodedCmd );
+// Change settings for the next decode round
-// Set index for next round
 iDecodeInfo.iFirstDecode = EFalse;
 iDecodeInfo.iDecodeIndex = endIndex + 1;
 RestoreOldDecodeInfo( aPeek, oldInfo );
-FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextDecodedCommand() complete") ));
+if ( !aPeek )
+{
+iDecodeInfo.iCmdsHandled++;
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextSubCommand() (handled=%d)"), iDecodeInfo.iCmdsHandled ));
+}
+FTRACE(FPrint( _L("CDunAtCmdHandler::ExtractNextSubCommand() complete") ));
 return ETrue;
+}
+// ---------------------------------------------------------------------------
+// Finds the start of subcommand from line buffer
+// ---------------------------------------------------------------------------
+//
+TBool CDunAtCmdHandler::FindStartOfSubCommand()
+{
+FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfSubCommand()") ));
+TInt i;
+TInt foundIndex = KErrNotFound;
+TInt lineLength = iLineBuffer.Length();
+for ( i=iDecodeInfo.iDecodeIndex; i<lineLength; i++ )
+{
+TChar character = iLineBuffer[i];
+if ( !IsDelimiterCharacter(character) )
+{
+foundIndex = i;
+break;
+}
+}
+FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfSubCommand() complete") ));
+return foundIndex;
 }
 // ---------------------------------------------------------------------------
 // Restores old decode info. For ExtractNextDecodedCommand() when aPeeks is
 // ETrue.
 }
 FTRACE(FPrint( _L("CDunAtCmdHandler::RestoreOldDecodeInfo() complete") ));
 }
 // ---------------------------------------------------------------------------
-// Finds end of an AT command
+// Tests for end of AT command line
 // ---------------------------------------------------------------------------
 //
-TInt CDunAtCmdHandler::FindEndOfCommand( TDesC8& aDes, TInt aStartIndex )
+TBool CDunAtCmdHandler::IsEndOfLine( TChar& aCharacter )
-{
-FTRACE(FPrint( _L("CDunAtCmdHandler::FindEndOfCommand()") ));
-TInt i;
-TInt length = aDes.Length();
-for ( i=aStartIndex; i<length; i++ )
-{
-TChar character = aDes[i];
-if ( IsEndOfCommand(character) )
-{
-FTRACE(FPrint( _L("CDunAtCmdHandler::FindEndOfCommand() complete (%d)"), i ));
-return i;
-}
-}
-FTRACE(FPrint( _L("CDunAtCmdHandler::FindEndOfCommand() (not found) complete") ));
-return KErrNotFound;
-}
-// ---------------------------------------------------------------------------
-// Tests for end of AT command character
-// ---------------------------------------------------------------------------
-//
-TBool CDunAtCmdHandler::IsEndOfCommand( TChar& aCharacter )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::IsEndOfCommand()") ));
 if ( aCharacter==iCarriageReturn || aCharacter==iLineFeed )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::IsEndOfCommand() (found) complete") ));
 return ETrue;
 }
 FTRACE(FPrint( _L("CDunAtCmdHandler::IsEndOfCommand() (not found) complete") ));
 return EFalse;
-}
-// ---------------------------------------------------------------------------
-// Finds start of a decoded AT command
-// ---------------------------------------------------------------------------
-//
-TInt CDunAtCmdHandler::FindStartOfDecodedCommand( TDesC8& aDes,
-TInt aStartIndex )
-{
-FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfDecodedCommand()") ));
-TInt i;
-TInt count = aDes.Length();
-for ( i=aStartIndex; i<count; i++ )
-{
-TChar character = aDes[i];
-if ( !IsDelimiterCharacter(character) )
-{
-FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfDecodedCommand() complete (%d)"), i ));
-return i;
-}
-}
-FTRACE(FPrint( _L("CDunAtCmdHandler::FindStartOfDecodedCommand() (not found) complete") ));
-return KErrNotFound;
 }
 // ---------------------------------------------------------------------------
 // Checks if character is delimiter character
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // Checks special command
 // ---------------------------------------------------------------------------
 //
-TBool CDunAtCmdHandler::CheckSpecialCommand( TInt aStartIndex,
+TBool CDunAtCmdHandler::CheckSpecialCommand( TInt& aEndIndex )
-TInt& aEndIndex )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::CheckSpecialCommand()") ));
-TInt atMsgLen = 0;
+TInt atPrefixLen = 0;
-TInt newLength = iInputBuffer.Length() - aStartIndex;
+TInt startIndex = iDecodeInfo.iDecodeIndex;
-TBuf8<KDunInputBufLength> upperBuf;
+TInt newLength = iLineBuffer.Length() - startIndex;
+TBuf8<KDunLineBufLength> upperBuf;
 if ( !iDecodeInfo.iFirstDecode )
 {
 // For cases such as "ATM1L3DT*99#" "DT" must have "AT"
-_LIT8( KATMsg, "AT" );
+_LIT8( KAtPrefix, "AT" );
-upperBuf.Copy( KATMsg );
+upperBuf.Copy( KAtPrefix );
-atMsgLen = 2;  // "AT"
+atPrefixLen = 2;  // "AT"
-newLength += atMsgLen;
+newLength += atPrefixLen;
 }
-upperBuf.Append( &iInputBuffer[aStartIndex], newLength );
+upperBuf.Append( &iLineBuffer[startIndex], newLength );
 upperBuf.UpperCase();
 TInt i;
 TInt count = iSpecials.Count();
 for ( i=0; i<count; i++ )
 {
 TInt cmpResult = upperBuf.Compare( *specialCmd );
 upperBuf.SetLength( origLength );
 if ( cmpResult == 0 )
 {
 iParseInfo.iLimit = specialLength;
-aEndIndex = (origLength-1) + aStartIndex - atMsgLen;
+aEndIndex = (origLength-1) + startIndex - atPrefixLen;
 FTRACE(FPrint( _L("CDunAtCmdHandler::CheckSpecialCommand() complete") ));
 return ETrue;
 }
 }
 FTRACE(FPrint( _L("CDunAtCmdHandler::CheckSpecialCommand() (not found) complete") ));
 }
 if ( extendedIndex == expectedIndex )
 {
 iDecodeInfo.iExtendedIndex = aEndIndex;
 SaveFoundCharDecodeState( aCharacter );
-FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedBorder() (no border) complete") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedBorder() (no border normal) complete") ));
 return EFalse;
+}
+// Now suspect border found so peek the next character after the suspected
+// extended character. If it is not alphabetical character, return with EFalse.
+// This case is to detect the cases such as "AT+VTS={*,3000}", where '*' would
+// be the start of the next command in normal cases.
+TInt peekIndex = aEndIndex + 1;
+TInt lineLength = iLineBuffer.Length();
+if ( peekIndex < lineLength )
+{
+TChar nextCharacter = iLineBuffer[peekIndex];
+if ( !nextCharacter.IsAlpha() )
+{
+SaveFoundCharDecodeState( aCharacter );
+FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedBorder() (no border special) complete") ));
+return EFalse;
+}
 }
 aEndIndex--;
 FTRACE(FPrint( _L("CDunAtCmdHandler::IsExtendedBorder() (border) complete") ));
 return ETrue;
 }
 // ---------------------------------------------------------------------------
 // Finds subcommand
 // ---------------------------------------------------------------------------
 //
-TInt CDunAtCmdHandler::FindSubCommand( TInt aStartIndex, TInt& aEndIndex )
+TInt CDunAtCmdHandler::FindSubCommand( TInt& aEndIndex )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommand()") ));
-aEndIndex = aStartIndex;
+TInt startIndex = iDecodeInfo.iDecodeIndex;
+aEndIndex = startIndex;
 TBool found = EFalse;
-TInt length = iInputBuffer.Length();
+TInt lineLength = iLineBuffer.Length();
 iDecodeInfo.iAssignFound = EFalse;
 iDecodeInfo.iInQuotes = EFalse;
 iDecodeInfo.iExtendedIndex = KErrNotFound;
 SaveNotFoundCharDecodeState();
 iAtSpecialCmdHandler->ResetComparisonBuffer();  // just to be sure
-for ( ; aEndIndex<length; aEndIndex++ )
+for ( ; aEndIndex<lineLength; aEndIndex++ )
 {
-TChar character = iInputBuffer[aEndIndex];
+TChar character = iLineBuffer[aEndIndex];
-found = FindSubCommandQuotes( character, aStartIndex, aEndIndex );
+found = FindSubCommandQuotes( character, startIndex, aEndIndex );
 if ( found )
 {
 continue;
 }
 if ( character == '?' )
 // The check below detects the following type of cases:
 // ATCMD+CMD [first + as delimiter]
 // AT+CMD+CMD [second + as delimiter]
 if ( IsExtendedCharacter(character) )
 {
-found = IsExtendedBorder( character, aStartIndex, aEndIndex );
+found = IsExtendedBorder( character, startIndex, aEndIndex );
 if ( !found )
 {
 continue;
 }
 FTRACE(FPrint( _L("CDunAtCmdHandler::FindSubCommand() (extended) complete") ));
 // ---------------------------------------------------------------------------
 //
 TBool CDunAtCmdHandler::IsASlashCommand()
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::IsASlashCommand()") ));
-if ( iInputBuffer.Length() == 2 )
+if ( iLineBuffer.Length() == 2 )
 {
-if ( iInputBuffer[1] == '/' &&
+if ( iLineBuffer[1] == '/' &&
-(iInputBuffer[0] == 'A' || iInputBuffer[0] == 'a') )
+(iLineBuffer[0] == 'A' || iLineBuffer[0] == 'a') )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::IsASlashCommand() (found) complete") ));
 return ETrue;
 }
 }
 if ( !IsASlashCommand() )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::HandleASlashCommand() (no push) complete") ));
 return EFalse;
 }
+iEndIndex = iInput->Length();  // Causes skipping of last '/' in ManageEndOfCmdHandling()
 // If "A/" command and last buffer exist, set the last buffer as the current buffer
 if ( iLastBuffer.Length() > 0 )
 {
-iInputBuffer.Copy( iLastBuffer );
+iLineBuffer.Copy( iLastBuffer );
 FTRACE(FPrint( _L("CDunAtCmdHandler::HandleASlashCommand() (copy) complete") ));
 return EFalse;
 }
-// Last buffer not set so return "ERROR" if quiet mode not on
+// Last buffer not set so return "ERROR"
-if ( iQuietOn )
-{
-FTRACE(FPrint( _L("CDunAtCmdHandler::HandleASlashCommand() (quiet) complete") ));
-return EFalse;
-}
 iDownstream->NotifyDataPushRequest( &iErrorBuffer, NULL );
 FTRACE(FPrint( _L("CDunAtCmdHandler::HandleASlashCommand() complete") ));
 return ETrue;
-}
-// ---------------------------------------------------------------------------
-// Resets parse buffers
-// ---------------------------------------------------------------------------
-//
-void CDunAtCmdHandler::ResetParseBuffers( TBool aClearInput )
-{
-FTRACE(FPrint( _L("CDunAtCmdHandler::ResetParseBuffers()") ));
-if ( aClearInput )
-{
-iInputBuffer.Zero();
-}
-iDecodeInfo.iFirstDecode = ETrue;
-iDecodeInfo.iDecodeIndex = 0;
-iDecodeInfo.iPrevExists = EFalse;
-iDecodeInfo.iDecodeBuffer.Zero();
-FTRACE(FPrint( _L("CDunAtCmdHandler::ResetParseBuffers() complete") ));
 }
 // ---------------------------------------------------------------------------
 // Manages command mode change
 // ---------------------------------------------------------------------------
 // When end of input notify CDunUpstream to reissue the read request.
 TBool nextContentFound = FindNextContent( aStart );
 if ( !nextContentFound )
 {
 iUpstream->NotifyEditorModeReply( aStart );
-FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyEditorModeReply() complete") ));
+FTRACE(FPrint( _L("CDunAtCmdHandler::ManageEditorModeReply() complete") ));
 return KErrNone;
 }
 // In block mode end the block mode by sending <ESC> and hope it works.
 iEscapeBuffer.Zero();
 iEscapeBuffer.Append( KDunEscape );
 if ( !aStart )
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::FindNextContent() (skip) complete" ) ));
 return iEditorModeInfo.iContentFound;
 }
-iEditorModeInfo.iContentFound = EFalse;
+// If iEndIndex is (>=0 && <iInput.Length()) it means more data waits in
-TInt foundCmdIndex = KErrNotFound;
+// iInput that didn't fit in iInputBuffer. Only check FindStartOfCommand()
-TBool nextContentFound = ExtractNextDecodedCommand( ETrue );  // peek
+// if iEndIndex < 0, meaning more data is needed from CDunUpstream.
-if ( !nextContentFound )
+TBool contentFound = EFalse;
-{
+TInt cmdLength = iInput->Length();
-// Check the next subblock
+TBool subBlock = ( iEndIndex>=0&&iEndIndex<cmdLength ) ? ETrue : EFalse;
-foundCmdIndex = FindStartOfNextCommand();
+if ( subBlock )
-}
+{
-if ( !nextContentFound && foundCmdIndex<0 )
+contentFound = ETrue;
-{
+}
-FTRACE(FPrint( _L("CDunAtCmdHandler::FindNextContent() (not found) complete") ));
+if ( !contentFound )
-return EFalse;
+{
-}
+contentFound = ExtractNextSubCommand( ETrue );  // peek
-iEditorModeInfo.iContentFound = ETrue;
+}
+iEditorModeInfo.iContentFound = contentFound;
 FTRACE(FPrint( _L("CDunAtCmdHandler::FindNextContent() complete" ) ));
-return ETrue;
+return contentFound;
 }
 // ---------------------------------------------------------------------------
 // From class MDunAtCmdPusher.
 // Notifies about end of AT command processing. This is after all reply data
 {
 ManageEditorModeReply( ETrue );
 FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyEndOfProcessing() (editor) complete" ) ));
 return KErrNone;
 }
-HandleNextDecodedCommand();
+HandleNextSubCommand();
 FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyEndOfProcessing() complete" ) ));
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 // From class MDunAtCmdPusher.
 // Notifies about request to stop AT command handling for the rest of the
 // command line data
 // ---------------------------------------------------------------------------
 //
-TInt CDunAtCmdHandler::NotifyEndOfCmdLineProcessing()
+void CDunAtCmdHandler::NotifyEndOfCmdLineProcessing()
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyEndOfCmdLineProcessing()" ) ));
-TInt retVal = Stop();
+ManageEndOfCmdHandling( ETrue, ETrue );
-ManageEndOfCmdHandling( ETrue, EFalse, ETrue );
 FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyEndOfCmdLineProcessing() complete" ) ));
-return retVal;
 }
 // ---------------------------------------------------------------------------
 // From class MDunAtCmdPusher.
 // Notifies about request to peek for the next command
 // ---------------------------------------------------------------------------
 //
 TBool CDunAtCmdHandler::NotifyNextCommandPeekRequest()
 {
 FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyNextCommandPeekRequest()") ));
-TBool extracted = ExtractNextDecodedCommand( ETrue );
+TBool extracted = ExtractNextSubCommand( ETrue );
 FTRACE(FPrint( _L("CDunAtCmdHandler::NotifyNextCommandPeekRequest() complete") ));
 return extracted;
 }
 // ---------------------------------------------------------------------------

branch	RCL_3
changeset 38	3dcb815346df
parent 37	7e0ecb5b116a