atext/server/src/atextmetadata.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Tue, 31 Aug 2010 16:20:16 +0300
branchRCL_3
changeset 43 5b153be919d4
parent 41 786b94c6f0a4
child 44 e9b924a62a66
permissions -rw-r--r--
Revision: 201031 Kit: 201035

/*
* Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Metadata for ATEXT
*
*/


/*
 * Here is the plugin managing logic for the AT commands and hopefully also for
 * future needs:
 *
 * Three types of support:
 * 1) Master (M): Sends to all O if support found. Panics if > 1 M.
 * 2) Partial (P): Sends to all O if support found. Replies "ERROR" if two P supports.
 * 3) Observer (O): Process the command and give or not give reply, based on
 *    the following logic:
 *
 * => [If] M found, handle command and send reply + send to N O {no reply}, stop, [else]
 * [If] P found, handle command and send reply + send to N O {no reply}, stop, [else]
 * [If] > 1 O found, send to N O {no reply}, stop, [else]
 * [If] only 1 O found, handle command and send reply, stop, [else]
 * Write "ERROR" to client, complete message with KErrNone
 *
 * When incoming reply:
 * => If reply from M, write to client, stop, [else]
 * If reply from P, write to client, stop, [else]
 * If reply from O and M, P nor other O exist, write to client, stop, [else]
 * Complete message with KErrNone and empty string
 *
 * Note: Empty string and "ERROR" string are managed already in HandleCommand()
 */

#include <ecom/ecom.h>
#include <ecom/implementationinformation.h>
#include <atextpluginbase.h>
#include "atextclientsrv.h"
#include "atextmetadata.h"
#include "atextlisten.h"
#include "utils.h"
#include "debug.h"

const TInt  KGranularity           = 4;
const TInt8 KDefaultCarriageReturn = 13;
const TInt8 KDefaultLineFeed       = 10;
const TInt  KErrorMsgLen           = 9;  // 2+"ERROR"+2

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CATExtMetadata* CATExtMetadata::NewL( REComSession& aEComSession,
                                      CATExtListen* aListener,
                                      MATExtPluginObserver& aObserver )
    {
    CATExtMetadata* self = NewLC( aEComSession, aListener, aObserver );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CATExtMetadata* CATExtMetadata::NewLC( REComSession& aEComSession,
                                       CATExtListen* aListener,
                                       MATExtPluginObserver& aObserver )
    {
    CATExtMetadata* self = new (ELeave) CATExtMetadata( aEComSession,
                                                        aListener,
                                                        aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor.
// ---------------------------------------------------------------------------
//
CATExtMetadata::~CATExtMetadata()
    {
    ResetData();
    }

// ---------------------------------------------------------------------------
// Resets data to initial values
// ---------------------------------------------------------------------------
//
void CATExtMetadata::ResetData()
    {
    TRACE_FUNC_ENTRY
    iShutdown = ETrue;
    DestroyPlugindata();
    DestroySupportdata( iSupport );
    DestroySupportdata( iSupportAux );
    iConnectionName.Close();
    iShutdown = EFalse;
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Creates new implementation metadata based on a given interface UID and
// connection. Uses AddImplementationL() to add new implementations for the
// interface and sets connection identification name for reporting it to the
// plugins on instantiation time.
// ---------------------------------------------------------------------------
//
void CATExtMetadata::CreateImplementationMetadataL( TUid& aIfUid,
                                                    const TDesC8& aName )
    {
    TRACE_FUNC_ENTRY
    if ( iPluginData || iSupport || iSupportAux )
        {
        TRACE_FUNC_EXIT
        User::Leave( KErrGeneral );
        }
    iIfUid = aIfUid;
    iConnectionName.CreateL( aName );
    RImplInfoPtrArray implementations;
    CleanupResetDestroyClosePushL( implementations );
    iEComSession.ListImplementationsL( iIfUid, implementations );
    const TUint implCount = implementations.Count();
    TRACE_INFO((_L("Number of AT Ext: %d"), implCount))
    iSupport = new (ELeave) CArrayFixFlat<TATExtAtCmdSupport>( KGranularity );
    iSupportAux = new (ELeave) CArrayFixFlat<TATExtAtCmdSupport>( KGranularity );
    iPluginData = new (ELeave) CArrayFixFlat<TATExtPluginEntry>( KGranularity );
    // As iSupport, iSupportAux and iPluginData are needed by
    // AddImplementationL(), no ease way to use temporary variables here.
    // If error occurs here then deletion of this class is required.
    for ( TUint i=0; i<implCount; i++ )
        {
        AddImplementationL( implementations[i] );
        }
    CleanupStack::PopAndDestroy( &implementations );
#if defined(_DEBUG) && defined( PRJ_PRINT_SUPPORT_DATA )
    PrintSupportData( iSupport );
    PrintSupportData( iSupportAux );
#endif
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Adds an implementation to the metadata based on a given ECOM implementation
// information. This is used by the function CreateImplementationMetadataL()
// and also by CATExtSession when its ECOM notification listener detects an
// addition for a the same ECOM interface.
// ---------------------------------------------------------------------------
//
void CATExtMetadata::AddImplementationL( CImplementationInformation* aImplInfo )
    {
    TRACE_FUNC_ENTRY
    if ( !aImplInfo )
        {
        TRACE_FUNC_EXIT
        User::Leave( KErrGeneral );
        }
    DoAddImplementationL( aImplInfo, aImplInfo->DataType() );
    DoAddImplementationL( aImplInfo, aImplInfo->OpaqueData() );
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Removes an implementation from the support data by a given plugin UID.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::RemoveImplementation( TUid& aPluginUid,
                                           TBool aInstanceExists )
    {
    TRACE_FUNC_ENTRY
    if ( iShutdown )
        {
        TRACE_FUNC_EXIT
        return KErrNotReady;
        }
    DoRemoveImplementation( aPluginUid, iSupport );
    DoRemoveImplementation( aPluginUid, iSupportAux );
    TInt retVal = RemoveOnePlugindata( aPluginUid, aInstanceExists );
    TRACE_FUNC_EXIT
    return retVal;
    }

// ---------------------------------------------------------------------------
// Handles an AT command
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::HandleCommand( const RMessage2& aMessage,
                                    TATExtCompletionInfo& aComplInfo )
    {
    TRACE_FUNC_ENTRY
    iCmdData.iCmdMessage = aMessage;
    if ( IsCommandHandling() )
        {
        TRACE_FUNC_EXIT
        return KErrInUse;
        }
    // Next pass the entry to command reader
    TInt retTemp = ReadCommandFromMessage( aMessage );
    if ( retTemp != KErrNone )
        {
        TRACE_FUNC_EXIT
        return retTemp;
        }
    // First check if in editor mode
    if ( iCmdData.iEditorHandler )
        {
        iCmdData.iReplyExpected = EFalse;
        iCmdData.iHandler = iCmdData.iEditorHandler;
        iCmdData.iHandler->iInstance->HandleCommand( iCmdData.iCmdBuffer,
                                                     iCmdData.iCmdReplyBuffer,
                                                     EFalse );
        aComplInfo.iProcessed = ETrue;
        aComplInfo.iReplyExpected = ETrue;
        // Note: The aComplInfo.iReplyExpected is used only for normal mode and
        // is set to ETrue here to skip a check in CATExtSession::IpcHandleCommand().
        TRACE_FUNC_EXIT
        return KErrNone;
        }
    // Not in editor so handle in normal mode
    TRACE_INFO(( _L8("Received command '%S'"), &iCmdData.iCmdBuffer ));
    // Now the command exists. Load the plugins for a command and check support.
    TRAPD( retTrap, CreateAndFindSupportL(iCmdData.iCmdBuffer,
                                          aMessage,
                                          aComplInfo ) );
    TRACE_FUNC_EXIT
    return retTrap;
    }

// ---------------------------------------------------------------------------
// Cancels an active handle command operation. Uses IsCommandHandling() and
// CancelCommandOperation().
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::CancelHandleCommand()
    {
    TRACE_FUNC_ENTRY
    if ( !IsCommandHandling() )
        {
        TRACE_FUNC_EXIT
        return KErrNotReady;
        }
    CancelCommandOperation( KErrCancel, ETrue );
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Gets the next part of a reply for HandleCommand(). Length of returned reply
// must be the same as the one reported from NextReplyPartLength() for the
// current reply.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::GetNextPartOfReply( const RMessage2& aMessage )
    {
    TRACE_FUNC_ENTRY
    if ( !iCmdData.iHandler || !iCmdData.iHandler->iInstance )
        {
        TRACE_FUNC_EXIT
        return KErrNotReady;
        }
    CATExtPluginBase& plugin = *iCmdData.iHandler->iInstance;
    TInt retTemp = plugin.GetNextPartOfReply( iCmdData.iCmdReplyBuffer );
    if ( retTemp!=KErrNone || iCmdData.iCmdReplyBuffer.Length()<=0 )
        {
        iCmdData.iCmdReplyBuffer.Close();
        TRACE_FUNC_EXIT
        return retTemp;
        }
    retTemp = WriteReplyBufferToClient(
        iCmdData.iCmdReplyBuffer,
        EATExtGetNextPartOfReplyParamReply,
        aMessage,
        ETrue,
        EATExtGetNextPartOfReplyParamLength );
    if ( retTemp != KErrNone )
        {
        iCmdData.iCmdReplyBuffer.Close();
        TRACE_FUNC_EXIT
        return retTemp;
        }
    aMessage.Complete( KErrNone );
    iCmdData.iCmdReplyBuffer.Close();
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Completes an URC processing message by a given plugin UID. Completion code
// for the client message is the return code from a write with
// WriteReplyBufferToClient()
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::CompleteUrcMessage( const TDesC8& aAtCmd,
                                         CATExtPluginBase* aPlugin )
    {
    TRACE_FUNC_ENTRY
    TATExtPluginEntry* foundEntry = FindInstanceFromPlugindata( aPlugin );
    if ( !foundEntry )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    if ( !foundEntry->iUrcMessage.Handle() )
        {
        TRACE_FUNC_EXIT
        return KErrBadHandle;
        }
    TInt retVal = WriteReplyBufferToClient( aAtCmd,
                                            EATExtReceiveUrcCmdParamBuf,
                                            foundEntry->iUrcMessage );
    foundEntry->iUrcMessage.Complete( retVal );
    TRACE_FUNC_EXIT
    return retVal;
    }

// ---------------------------------------------------------------------------
// Completes an AT command handling message. Also clears internal initialized
// command hanlder data; see ClearInitializedCmdHandlerData().
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::CompleteCommandMessage( CATExtPluginBase* aPlugin,
                                             TInt aError,
                                             TBool aErrorReply,
                                             TATExtensionReplyType aReplyType,
                                             TBool aMultiPart )
    {
    TRACE_FUNC_ENTRY
    // First check if aPlugin is set (the call comes from a plugin and not from
    // ATEXT) and if it is the instance is different than the currently
    // operating one.
    if ( aPlugin && iCmdData.iHandler && iCmdData.iHandler->iInstance!=aPlugin )
        {
        TRACE_FUNC_EXIT
        return KErrInUse;
        }
    if ( !iCmdData.iCmdMessage.Handle() )
        {
        TRACE_FUNC_EXIT
        return KErrBadHandle;
        }
    TBool startOfEditor = EFalse;
    if ( aReplyType == EReplyTypeEditor)
        {
        // If completion is for editor command then set iCmdData.iEditorHandler
        // for the first time only
        if ( !iCmdData.iEditorHandler )
            {
            iCmdData.iEditorHandler = FindInstanceFromPlugindata( aPlugin );
            iCmdData.iReplyExpected = ETrue;  // reply expected when first reply in editor mode
            startOfEditor = ETrue;
            }
        }
    else
        {
        // If completion was something else than EReplyTypeEditor then just end
        // editor mode (no need to check iEditorHandler)
        if ( iCmdData.iEditorHandler )
            {
            iCmdData.iReplyExpected = ETrue;  // reply expected when last reply in editor mode
            }
        iCmdData.iEditorHandler = NULL;
        }
    // Next check if aPlugin is set (the call comes from a plugin and not from
    // ATEXT) and a reply is not needed. In this case do nothing as it is wrong
    // behavior from the plugin (a plugin must not complete messages where no
    // reply is expected; this is done by ATEXT)
    if ( aPlugin && !iCmdData.iReplyExpected && !iCmdData.iEditorHandler )
        {
        TRACE_FUNC_EXIT
        return KErrAlreadyExists;
        }
    // Finally write the data and complete the message
    TPckg<TATExtensionReplyType> replyType( aReplyType );
    TInt writeError = iCmdData.iCmdMessage.Write( EATExtHandleCmdParamReplyType,
                                                  replyType );
    TRACE_INFO(( _L("Write returned %d"), writeError ));
    if ( aError==KErrNone && writeError==KErrNone )
        {
        if ( iCmdData.iHandler )  // Can be NULL when invoked from inside ATEXT
            {
            iCmdData.iOldHandler = iCmdData.iHandler->iInstance;
            }
        if ( !aPlugin )
            {
            CreateEmptyOrErrorBuffer( iCmdData.iCmdReplyBuffer, aErrorReply );
            }
        WriteHandleCmdReplyBuffer( aMultiPart, startOfEditor );
        }
    iCmdData.iCmdStarted = EFalse;
    iCmdData.iReplyExpected = EFalse;
    iCmdData.iCmdMessage.Complete( aError );
    ClearInitializedCmdHandlerData( aMultiPart );
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Writes multipart or single part reply buffer to client for handle.
// Used for creating a reply for HandleCommand().
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::WriteHandleCmdReplyBuffer( TBool aMultiPart,
                                                TBool aStartOfEditor )
    {
    TRACE_FUNC_ENTRY
    if ( iCmdData.iEditorHandler && !aStartOfEditor )
        {
        TRACE_FUNC_EXIT
        return KErrNotReady;
        }
    if ( aMultiPart )
        {
        WriteReplyBufferToClient( iCmdData.iCmdReplyBuffer,
                                  EATExtHandleCmdParamReply,
                                  iCmdData.iCmdMessage,
                                  ETrue,
                                  EATExtHandleCmdParamLength );
        }
    else
        {
        WriteReplyBufferToClient( iCmdData.iCmdReplyBuffer,
                                  EATExtHandleCmdParamReply,
                                  iCmdData.iCmdMessage );
        }
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Clears internal initialized command handler data. This is currently used
// only by CompleteCommandMessage() and is called when the data is not needed
// anymore. It also prepares the internal data for a new HandleCommand() call.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::ClearInitializedCmdHandlerData( TBool aMultiPart )
    {
    TRACE_FUNC_ENTRY
    if ( iCmdData.iCmdStarted )
        {
        TRACE_FUNC_EXIT
        return KErrNotReady;
        }
    iCmdData.iCmdBuffer.Close();
    iCmdData.iCmdReplyBuffer.Close();
    if ( !aMultiPart )
        {
        iCmdData.iHandler = NULL;
        }
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Gets the array of supported commands.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::GetSupportedCommands( CATExtPluginBase* aPlugin,
                                           RPointerArray<HBufC8>& aCmds )
    {
    TRACE_FUNC_ENTRY
    if ( !iSupport || !iSupportAux )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    TATExtPluginEntry* foundEntry = FindInstanceFromPlugindata( aPlugin );
    if ( !foundEntry )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    // Next create the array of supported commands
    TInt retVal = KErrNone;
    TBool firstSearch = ETrue;
    TInt supportFind = KErrNotFound;
    TBool findInAux = EFalse;
    for ( ;; )
        {
        HBufC8* foundCmd = GetNextSupportedCommand( firstSearch,
                                                    supportFind,
                                                    findInAux );
        if ( !foundCmd )
            {
            break;
            }
        retVal = aCmds.Append( foundCmd );
        if ( retVal != KErrNone )
            {
            break;
            }
        }
    TRACE_FUNC_EXIT
    return retVal;
    }

// ---------------------------------------------------------------------------
// Starts URC message receiving for plugin. Note that
// MarkUrcHandlingOwnership() must be called immediately after this in order
// for the messages to receive their destination.
// ---------------------------------------------------------------------------
//
void CATExtMetadata::StartUrcReceivingL( const RMessage2& aMessage,
                                         TUid& aPluginUid )
    {
    TRACE_FUNC_ENTRY
    TATExtPluginEntry* foundEntry = FindUrcProcessingPlugin( aPluginUid );
    if ( !foundEntry )
        {
        TRACE_FUNC_EXIT
        User::Leave( KErrNotFound );
        }
    // Note: Let locked plugin pass here
    InstantiatePluginL( *foundEntry );
    foundEntry->iUrcMessage = aMessage;
    foundEntry->iInstance->ReceiveUnsolicitedResult();
    foundEntry->iUrcStarted = ETrue;
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Cancels an active URC message receiving operation by a given plugin UID.
// Uses CancelOneUrcOperation() to cancel if plugin UID found from plugin
// data.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::CancelUrcReceiving( TUid& aPluginUid )
    {
    TRACE_FUNC_ENTRY
    TInt foundIndex = KErrNotFound;
    TATExtPluginEntry* foundEntry = FindUidFromPlugindata( aPluginUid,
                                                           foundIndex );
    if ( !foundEntry )
        {
        TRACE_FUNC_EXIT
        return KErrNotFound;
        }
    CancelOneUrcOperation( *foundEntry, KErrCancel, ETrue );
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Marks URC handling ownership for a plugin entry. Call to this function must
// be done immediately after the call to StartUrcReceivingL().
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::MarkUrcHandlingOwnership( const RMessage2& aMessage )
    {
    TRACE_FUNC_ENTRY
    if ( !iPluginData )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    TInt i = 0;
    TInt count = iPluginData->Count();
    for ( i=0; i<count; i++ )
        {
        TATExtPluginEntry& entry = (*iPluginData)[i];
        if ( entry.iUrcStarted && !entry.iUrcOwned )
            {
            TPckg<TUid> pluginUid( entry.iPluginUid );
            TInt retTemp = aMessage.Write( EATExtMarkUrcHandlingOwnershipParamUid,
                                           pluginUid );
            TRACE_INFO(( _L("Write returned %d"), retTemp ));
            entry.iUrcOwned = ETrue;
            TRACE_FUNC_EXIT
            return KErrNone;
            }
        }
    TRACE_FUNC_EXIT
    return KErrNotFound;
    }

// ---------------------------------------------------------------------------
// Marks the access to a plugin data as "locked". This blocks all operations
// where plugin function calls are to be done.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::LockPluginAccess( TUid& aPluginUid )
    {
    TRACE_FUNC_ENTRY
    TInt foundIndex = KErrNotFound;
    TATExtPluginEntry* foundEntry = FindUidFromPlugindata( aPluginUid,
                                                           foundIndex );
    if ( !foundEntry )
        {
        TRACE_FUNC_EXIT
        return KErrNotFound;
        }
    if ( foundEntry == iCmdData.iHandler )
        {
        CancelCommandOperation( KErrCancel );
        }
    CancelOneUrcOperation( *foundEntry, KErrCancel );
    foundEntry->iLocked = ETrue;
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Marks the access to a plugin data as "unlocked". This enables all
// operations where plugin function call are to be done.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::UnlockPluginAccess( TUid& aPluginUid )
    {
    TRACE_FUNC_ENTRY
    TInt foundIndex = KErrNotFound;
    TATExtPluginEntry* foundEntry = FindUidFromPlugindata( aPluginUid,
                                                           foundIndex );
    if ( !foundEntry )
        {
        TRACE_FUNC_EXIT
        return KErrNotFound;
        }
    foundEntry->iLocked = EFalse;
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Searches for an instances from the support data's plugin data link and only
// marks the instance as uninitialized. Note that this doesn't try to cancel
// any of the current plugin operations and should be used only when a plugin
// destroys itself.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::RemoveImplementationInstance( CATExtPluginBase* aInstance )
    {
    TRACE_FUNC_ENTRY
    if ( !aInstance )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    TATExtPluginEntry* foundEntry = FindInstanceFromPlugindata( aInstance );
    if ( !foundEntry )
        {
        TRACE_FUNC_EXIT
        return KErrNotFound;
        }
    TInt retVal = RemoveImplementation( foundEntry->iPluginUid, EFalse );
    TRACE_FUNC_EXIT
    return retVal;
    }

// ---------------------------------------------------------------------------
// Checks if support data has been constructed from the plugin data.
// ---------------------------------------------------------------------------
//
TBool CATExtMetadata::SupportExists()
    {
    TRACE_FUNC_ENTRY
    if ( (iSupport&&iSupport->Count()>0) ||
         (iSupportAux&&iSupportAux->Count()>0) )
        {
        TRACE_FUNC_EXIT
        return ETrue;
        }
    TRACE_FUNC_EXIT
    return EFalse;
    }

// ---------------------------------------------------------------------------
// Number of plugins with AT command handling support based on the information
// in RSS files' AT command handling entries. This information is needed to
// instantiate one or more listeners by the user of the client.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::NumberOfPlugins()
    {
    TRACE_FUNC_ENTRY
    if ( !iPluginData )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    TInt pluginCount = iPluginData->Count();
    TRACE_FUNC_EXIT
    return pluginCount;
    }

// ---------------------------------------------------------------------------
// Sets the quiet mode to the required value. After this the mode is reported
// to the plugins with ReportQuietModeChange().
// ---------------------------------------------------------------------------
//
void CATExtMetadata::SetQuietMode( TBool aMode )
    {
    TRACE_FUNC_ENTRY
    iQuietMode = aMode;
    if ( iPluginData )
        {
        TInt i;
        TInt count = iPluginData->Count();
        for ( i=0; i<count; i++ )
            {
            TATExtPluginEntry& entry = (*iPluginData)[i];
            if ( entry.iLocked )
                {
                continue;
                }
            TInt retTemp = InstantiatePlugin( entry );
            if ( retTemp != KErrNone )
                {
                continue;
                }
            // Note: here two reports will be made if the plugin was not
            // instantiated but as the operatio is fast no new parameter will be
            // done to InstantiatePlugin() for instantiation reporting.
            entry.iInstance->ReportQuietModeChange( aMode );
            }
        }
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Sets the verbose mode to the required value. After this the mode is
// reported to the plugins with ReportVerboseModeChange().
// ---------------------------------------------------------------------------
//
void CATExtMetadata::SetVerboseMode( TBool aMode )
    {
    TRACE_FUNC_ENTRY
    iVerboseMode = aMode;
    if ( iPluginData )
        {
        TInt i;
        TInt count = iPluginData->Count();
        for ( i=0; i<count; i++ )
            {
            TATExtPluginEntry& entry = (*iPluginData)[i];
            if ( entry.iLocked )
                {
                continue;
                }
            TInt retTemp = InstantiatePlugin( entry );
            if ( retTemp != KErrNone )
                {
                continue;
                }
            // Note: here two reports will be made if the plugin was not
            // instantiated but as the operatio is fast no new parameter will be
            // done to InstantiatePlugin() for instantiation reporting.
            entry.iInstance->ReportVerboseModeChange( aMode );
            }
        }
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Sets new character value for a carriage return, line feed or backspace
// character. After this its type and value are report to the plugins with
// ReportCharacterChange().
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::SetCharacterValue( TATExtensionCharType aCharType,
                                        TInt8 aNewChar )
    {
    TRACE_FUNC_ENTRY
    // First pick up the needed information for ATEXT
    TInt retVal = KErrNone;
    switch ( aCharType )
        {
        case ECharTypeCarriage:
            iCarriageReturn = aNewChar;
            break;
        case ECharTypeLineFeed:
            iLineFeed = aNewChar;
            break;
        case ECharTypeBackspace:
            iBackspace = aNewChar;
            break;
        default:
            retVal = KErrNotSupported;
            break;
        }
    if ( retVal==KErrNone && iPluginData )
        {
        // Next notify about character change
        TInt i;
        TInt count = iPluginData->Count();
        for ( i=0; i<count; i++ )
            {
            TATExtPluginEntry& entry = (*iPluginData)[i];
            if ( entry.iLocked )
                {
                continue;
                }
            TInt retTemp = InstantiatePlugin( entry );
            if ( retTemp != KErrNone )
                {
                continue;
                }
            // Note: here two reports will be made if the plugin was not
            // instantiated but as the operatio is fast no new parameter will be
            // done to InstantiatePlugin() for instantiation reporting.
            entry.iInstance->ReportCharacterChange( aCharType, aNewChar );
            }
        }
    TRACE_FUNC_EXIT
    return retVal;
    }

// ---------------------------------------------------------------------------
// Extracts the NVRAM settings from a pipe-character delimited NVRAM buffer
// and sends the subsettings to all of the plugins with
// ReportNvramStatusChange().
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::BroadcastNvramStatusChange( const TDesC8& aNvram )
    {
    TRACE_FUNC_ENTRY
    if ( !iPluginData )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    HBufC8* nvramEntry = NULL;
    TRAP_IGNORE( nvramEntry=HBufC8::NewMaxL(aNvram.Length()) );
    if ( !nvramEntry )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    TInt i;
    TInt retVal = KErrNotFound;
    TInt count = iPluginData->Count();
    TPtr8 nvramEntryPtr = nvramEntry->Des();
    TInt startIndex = 0;   // Start of found subsetting
    TInt endIndex = 0;     // End of found subsetting
    while ( ExtractNextNvramSetting(aNvram,startIndex,endIndex)  )
        {
        // Report the subsetting to every plugin (and instantiate as every delta
        // change has to be signalled to every plugin).
        nvramEntryPtr.Copy( &aNvram[startIndex], endIndex-startIndex );
        for ( i=0; i<count; i++ )
            {
            TATExtPluginEntry& entry = (*iPluginData)[i];
            if ( entry.iLocked )
                {
                continue;
                }
            TInt retTemp = InstantiatePlugin( entry );
            if ( retTemp != KErrNone )
                {
                continue;
                }
            entry.iInstance->ReportNvramStatusChange( nvramEntryPtr );
            retVal = KErrNone;
            }
        }
    delete nvramEntry;
    TRACE_FUNC_EXIT
    return retVal;
    }

// ---------------------------------------------------------------------------
// Reports about external handle command error condition.
// This is for cases when for example DUN decided the reply contained an
// error condition but the plugin is still handling the command internally.
// Example: "AT+TEST;+TEST2" was given in command line; "AT+TEST" returns
// non-EReplyTypeError condition and "AT+TEST2" returns EReplyTypeError.
// As the plugin(s) returning the non-EReplyTypeError may still have some
// ongoing operation then these plugins are notified about the external
// EReplyTypeError in command line processing. It is to be noted that
// HandleCommandCancel() is not sufficient to stop the processing as the
// command handling has already finished.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::ReportExternalHandleCommandError()
    {
    TRACE_FUNC_ENTRY
    if ( !iCmdData.iOldHandler )
        {
        TRACE_FUNC_EXIT
        return KErrNotFound;
        }
    iCmdData.iOldHandler->ReportExternalHandleCommandError();
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Reports about abort condition in command handling.
// This is for cases when for example DUN decided an abort condition was
// received from DTE (ITU-T V.250 5.6.1). This API is for notifying the
// plugin that abort was requested. However the plugin currently handling
// the command may ignore the request if it doesn't support abort for the
// command or it may return the changed condition with
// HandleCommandCompleted()
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::ReportHandleCommandAbort( const RMessage2& aMessage )
    {
    TRACE_FUNC_ENTRY
    if ( !iCmdData.iHandler || !iCmdData.iHandler->iInstance )
        {
        TRACE_FUNC_EXIT
        return KErrNotReady;
        }
    // Uncomment the following line for abort API
//    CATExtPluginBase& plugin = *iCmdData.iHandler->iInstance;
    // Remove the following line for abort API
    TInt retTemp = KErrNone;
    TBool stop = EFalse;
    // Uncomment the following line for abort API
//    TInt retTemp = plugin.ReportHandleCommandAbort( stop );
    if ( retTemp != KErrNone )
        {
        TRACE_FUNC_EXIT
        return retTemp;
        }
    TPckg<TBool> stopPckg( stop );
    TInt retVal = aMessage.Write( EATExtReportHandleCommandAbortParamStop,
                                  stopPckg );
    TRACE_INFO(( _L("Write returned %d"), retVal ));
    TRACE_FUNC_EXIT
    return retVal;
    }

// ---------------------------------------------------------------------------
// Extracts the NVRAM settings from a pipe-character delimited NVRAM buffer
// and sends the subsettings to all of the plugins with
// ReportNvramStatusChange().
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::GetNextSpecialCommand( const RMessage2& aMessage,
                                            TBool aFirstSearch )
    {
    TRACE_FUNC_ENTRY
    if ( !iSupportAux )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    // If first search then start from index 0, othewise start from the
    // next index
    if ( aFirstSearch )
        {
        iSupportAuxFind = -1;
        }
    iSupportAuxFind++;
    TInt i;
    TInt count = iSupportAux->Count();
    TATExtAtCmdSupport* support = NULL;
    for ( i=iSupportAuxFind; i<count; i++ )
        {
        support = &(*iSupportAux)[i];
        if ( support->iEntries )
            {
            break;
            }
        }
    if ( i >= count )
        {
        TRACE_FUNC_EXIT
        return KErrNotFound;
        }
    TInt retTemp = WriteReplyBufferToClient( *support->iAtCmdBase,
                                             EATExtGetNextSpecialCmdParamCmd,
                                             aMessage );
    TRACE_INFO(( _L("First write returned %d"), retTemp ));
    TPckg<TBool> firstSearch( EFalse );
    retTemp = aMessage.Write( EATExtGetNextSpecialCmdParamFirst, firstSearch );
    TRACE_INFO(( _L("Second write returned %d"), retTemp ));
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CATExtMetadata::CATExtMetadata
// ---------------------------------------------------------------------------
//
CATExtMetadata::CATExtMetadata( REComSession& aEComSession,
                                CATExtListen* aListener,
                                MATExtPluginObserver& aObserver ) :
    iEComSession( aEComSession ),
    iListener( aListener ),
    iObserver( aObserver )
    {
    Initialize();
    }

// ---------------------------------------------------------------------------
// CATExtMetadata::ConstructL
// ---------------------------------------------------------------------------
//
void CATExtMetadata::ConstructL()
    {
    if ( !iListener )
        {
        User::Leave( KErrGeneral );
        }
    }

// ---------------------------------------------------------------------------
// Initializes this class
// ---------------------------------------------------------------------------
//
void CATExtMetadata::Initialize()
    {
    // Don't initialize iListener here (it is set through NewL)
    // Don't initialize iCallback here (it is set through NewL)
    iIfUid = TUid::Null();
    iSupport = NULL;
    iSupportAux = NULL;
    iPluginData = NULL;
    iCmdData.iCmdStarted = EFalse;
    iCmdData.iReplyExpected = EFalse;
    iCmdData.iHandler = NULL;
    iCmdData.iOldHandler = NULL;
    iCmdData.iEditorHandler = NULL;
    iCarriageReturn = KDefaultCarriageReturn;
    iLineFeed = KDefaultLineFeed;
    iQuietMode = EFalse;
    iVerboseMode = ETrue;
    iSupportAuxFind = 0;
    iShutdown = EFalse;
    }

// ---------------------------------------------------------------------------
// Removes one plugin data entry by plugin UID
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::RemoveOnePlugindata( TUid& aPluginUid,
                                          TBool aInstanceExists )
    {
    TRACE_FUNC_ENTRY
    TInt foundIndex = KErrNotFound;
    TATExtPluginEntry* foundEntry = FindUidFromPlugindata( aPluginUid,
                                                           foundIndex );
    if ( !foundEntry )
        {
        TRACE_FUNC_EXIT
        return KErrNotFound;
        }
    if ( !aInstanceExists )
        {
        foundEntry->iInstance = NULL;
        }
    if ( foundEntry == iCmdData.iHandler )
        {
        CancelCommandOperation( KErrCompletion );
        }
    CancelOneUrcOperation( *foundEntry, KErrCompletion );
    delete foundEntry->iInstance;
    foundEntry->iInstance = NULL;
    iPluginData->Delete( foundIndex );
    iPluginData->Compress();
    UpdateRemovedPluginLinks( iSupport, foundIndex );
    UpdateRemovedPluginLinks( iSupportAux, foundIndex );
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Updates removed plugin links
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::UpdateRemovedPluginLinks(
    CArrayFixFlat<TATExtAtCmdSupport>* aSupport,
    TInt aRemovedIndex )
    {
    TRACE_FUNC_ENTRY
    if ( !aSupport )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    TInt i;
    TInt j;
    TInt supportCount = aSupport->Count();
    for ( i=0; i<supportCount; i++ )
        {
        TATExtAtCmdSupport& support = (*aSupport)[i];
        if ( !support.iEntries )
            {
            continue;
            }
        TInt entryCount = support.iEntries->Count();
        for ( j=entryCount-1; j>=0; j-- )
            {
            TATExtOneCmdSupport& oneCmdSupport = (*support.iEntries)[j];
            TInt entryIndex = oneCmdSupport.iEntryIndex;
            if ( entryIndex > aRemovedIndex )
                {
                oneCmdSupport.iEntryIndex--;
                }
            else if ( entryIndex == aRemovedIndex )
                {
                support.iEntries->Delete( j );
                }
            }
        }
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Completes command data
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::CompleteCommandData()
    {
    TRACE_FUNC_ENTRY
    CompleteCommandMessage( NULL,
                            KErrCompletion,
                            EFalse,
                            EReplyTypeUndefined,
                            EFalse );
    // It is possible that CompleteCommandMessage() didn't complete but there
    // is still data set to non-null values. Force setting now.
    iCmdData.iCmdStarted = EFalse;
    iCmdData.iReplyExpected = EFalse;
    iCmdData.iCmdBuffer.Close();
    iCmdData.iCmdReplyBuffer.Close();
    iCmdData.iHandler = NULL;
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Adds AT commands set to metadata. Used by function AddImplementationL().
// ---------------------------------------------------------------------------
//
void CATExtMetadata::DoAddImplementationL(
    CImplementationInformation* aImplInfo,
    const TDesC8& aAtCmdSet )
    {
    TRACE_FUNC_ENTRY
    if ( !aImplInfo || !iPluginData || !iSupport || !iSupportAux )
        {
        TRACE_FUNC_EXIT
        User::Leave( KErrGeneral );
        }
    TATExtSupportType type = ESupportTypeUndefined;
    TInt start = 0;  // Start of found subcommand
    TInt end = 0;    // End of found subcommand
    HBufC8* parsedCmd = HBufC8::NewMaxLC( aAtCmdSet.Length() );
    TPtr8 parsedCmdPtr = parsedCmd->Des();
    while ( ExtractNextCommand(aAtCmdSet,start,end,type) == KErrNone )
        {
        if ( type == ESupportTypeUndefined )
            {
            continue;
            }
        parsedCmdPtr.Copy( &aAtCmdSet[start], end-start );
        TUid pluginUid = aImplInfo->ImplementationUid();
        TATExtCleanupInfo cleanupInfo;
        TRAPD( retTrap, AddEntryToMetadataL(parsedCmdPtr,pluginUid,type,
                                            cleanupInfo) );
        if ( retTrap != KErrNone )
            {
            CleanPartialMetadata( cleanupInfo );
            TRACE_FUNC_EXIT
            User::Leave( retTrap );
            }
        TInt retTemp = iListener->AddPluginUid( pluginUid );
        if ( retTemp != KErrNone )
            {
            TRACE_FUNC_EXIT
            User::Leave( retTemp );
            }
        }
    CleanupStack::PopAndDestroy( parsedCmd );
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Removes an implementation from the support data by a given plugin UID.
// Used by function RemoveImplementation().
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::DoRemoveImplementation(
    TUid& aPluginUid,
    CArrayFixFlat<TATExtAtCmdSupport>* aSupport )
    {
    TRACE_FUNC_ENTRY
    if ( !aSupport )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    // 1. Find the UID from plugindata.
    TInt foundIndex = KErrNotFound;
    TATExtPluginEntry* foundEntry = FindUidFromPlugindata( aPluginUid,
                                                           foundIndex );
    if ( !foundEntry )
        {
        TRACE_FUNC_EXIT
        return KErrNotFound;
        }
    // 2. Delete the entries from metadata which point to the found entry.
    TInt i;
    TInt j;
    TInt supportCount = aSupport->Count();
    for ( i=supportCount-1; i>=0; i-- )
        {
        TATExtAtCmdSupport& support = (*aSupport)[i];
        if ( !support.iEntries )
            {
            continue;
            }
        TInt entryCount = support.iEntries->Count();
        for ( j=entryCount-1; j>=0; j-- )
            {
            TInt entryIndex = (*support.iEntries)[j].iEntryIndex;
            if ( &(*iPluginData)[entryIndex] == foundEntry )
                {
                support.iEntries->Delete( j );
                }
            }
        support.iEntries->Compress();
        // 3. Remove the entries from metadata with zero length.
        if ( support.iEntries->Count() == 0 )
            {
            aSupport->Delete( i );
            }
        }
    aSupport->Compress();
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Checks whether AT command handling is active or not
// ---------------------------------------------------------------------------
//
TBool CATExtMetadata::IsCommandHandling()
    {
    TRACE_FUNC_ENTRY
    if ( iCmdData.iCmdStarted ||
        (iCmdData.iCmdMessage.Handle() && iCmdData.iCmdBuffer.Length()>0) ||
         iCmdData.iCmdReplyBuffer.Length()>0 )
        {
        TRACE_FUNC_EXIT
        return ETrue;
        }
    TRACE_FUNC_EXIT
    return EFalse;
    }

// ---------------------------------------------------------------------------
// Destroys data related to plugins
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::DestroyPlugindata()
    {
    TRACE_FUNC_ENTRY
    if ( !iPluginData )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    CancelCommandOperation( KErrServerTerminated );
    // First cancel the plugindata operations before delete
    TInt i;
    TInt pluginCount = iPluginData->Count();
    for ( i=0; i<pluginCount; i++ )
        {
        TATExtPluginEntry& entry = (*iPluginData)[i];
        CancelOneUrcOperation( entry, KErrServerTerminated );
        }
    // Next delete the actual data
    for ( i=0; i<pluginCount; i++ )
        {
        TATExtPluginEntry& entry = (*iPluginData)[i];
        delete entry.iInstance;
        entry.iInstance = NULL;
        }
    iPluginData->Reset();
    delete iPluginData;
    iPluginData = NULL;
    iCmdData.iHandler = NULL;
    iCmdData.iOldHandler = NULL;
    iCmdData.iEditorHandler = NULL;
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Cancels an active AT command handling operation by reinitializing internal
// data, completing the client request message and calling the plugin's
// HandleCommandCancel().
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::CancelCommandOperation( TInt aError, TBool aCheckLock )
    {
    TRACE_FUNC_ENTRY
    if ( aCheckLock && iCmdData.iHandler && iCmdData.iHandler->iLocked )
        {
        TRACE_FUNC_EXIT
        return KErrAccessDenied;
        }
    if ( iCmdData.iHandler && iCmdData.iHandler->iInstance )
        {
        iCmdData.iHandler->iInstance->HandleCommandCancel();
        iCmdData.iEditorHandler = NULL;
        }
    CompleteCommandMessage( NULL,
                            aError,
                            EFalse,
                            EReplyTypeUndefined,
                            EFalse );
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Cancels an active URC message receiving operation by a given plugin entry,
// completing the client request message and calling the plugin's
// ReceiveUnsolicitedResultCancel().
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::CancelOneUrcOperation( TATExtPluginEntry& aPluginEntry,
                                            TInt aError,
                                            TBool aCheckLock )
    {
    TRACE_FUNC_ENTRY
    if ( aCheckLock && aPluginEntry.iLocked )
        {
        TRACE_FUNC_EXIT
        return KErrAccessDenied;
        }
    aPluginEntry.iUrcStarted = EFalse;
    if ( aPluginEntry.iInstance )
        {
        aPluginEntry.iInstance->ReceiveUnsolicitedResultCancel();
        }
    if ( aPluginEntry.iUrcMessage.Handle() )
        {
        aPluginEntry.iUrcMessage.Complete( aError );
        }
    // Note: Don't touch the iUrcOwned here
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Destroys data related to AT command support
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::DestroySupportdata(
    CArrayFixFlat<TATExtAtCmdSupport>*& aSupport )
    {
    TRACE_FUNC_ENTRY
    if ( !aSupport )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    // Next just remove the entries
    TInt i;
    TInt supportCount = aSupport->Count();
    for ( i=0; i<supportCount; i++ )
        {
        TATExtAtCmdSupport& support = (*aSupport)[i];
        delete support.iAtCmdBase;
        support.iAtCmdBase = NULL;
        if ( support.iEntries )
            {
            support.iEntries->Reset();
            delete support.iEntries;
            support.iEntries = NULL;
            }
        }
    aSupport->Reset();
    delete aSupport;
    aSupport = NULL;
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Extracts one command from a pipe-character delimited command buffer (Note:
// This function is used to get the settings from a plugin RSS file)
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::ExtractNextCommand( const TDesC8& aCommands,
                                         TInt& aStartIndex,
                                         TInt& aEndIndex,
                                         TATExtSupportType& aSupportType )
    {
    TRACE_FUNC_ENTRY
    aSupportType = ESupportTypeUndefined;
    // Skip data before command
    TInt i;
    TChar character;
    TInt count = aCommands.Length();
    for ( i=aEndIndex; i<count; i++ )
        {
        character = aCommands[i];
        if ( character.IsPrint() && character!='|' )
            {
            break;
            }
        }
    if ( i >= count )
        {
        TRACE_FUNC_EXIT
        return KErrNotFound;
        }
    // Now the plugin type marker is found; check the plugin type
    switch ( character )
        {
        case 'M':  // Master plugin
        case 'm':
            aSupportType = ESupportTypeMaster;
            break;
        case 'P':  // Partial plugin
        case 'p':
            aSupportType = ESupportTypePartial;
            break;
        case 'O':  // Observer plugin
        case 'o':
            aSupportType = ESupportTypeObserver;
            break;
        default:
            _LIT( KPluginType, "PluginType" );
            User::Panic( KPluginType, EPanicCategoryType );
        }
    i++;
    if ( i >= count )
        {
        TRACE_FUNC_EXIT
        return KErrNotFound;
        }
    aStartIndex = i;
    // Start of command found, next mark the end
    while ( i < count )
        {
        character = aCommands[i];
        if ( !character.IsPrint() || character=='|' )
            {
            break;
            }
        i++;
        }
    aEndIndex = i;
    if ( aEndIndex-aStartIndex <= 0 )
        {
        TRACE_FUNC_EXIT
        return KErrNotFound;
        }
    TRACE_FUNC_EXIT
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Adds a new plugin entry to support data. If command to be added is not
// found from the support data then that command is inserted alphabetically to
// the support data. After this a search for the plugin UID is done; if the
// UID is not found then it is added to the plugin data and a new initialized
// data is created for that entry. Finally the added or new plugin entry is
// linked to the new or existing support entry.
// ---------------------------------------------------------------------------
//
void CATExtMetadata::AddEntryToMetadataL( TDes8& aAtCmdBase,
                                          TUid& aPluginUid,
                                          TATExtSupportType aSupportType,
                                          TATExtCleanupInfo& aCleanupInfo )
    {
    TRACE_FUNC_ENTRY
    if ( !iSupport || !iSupportAux || !iPluginData )
        {
        TRACE_FUNC_EXIT
        User::Leave( KErrGeneral );
        }
    // First try to find the string with binary search.
    // If found, add aUid.
    // If not found, add aAtCmdBase, aPluginUid.
    CArrayFixFlat<TATExtAtCmdSupport>* support = iSupport;
    aCleanupInfo.iSupportCreated = EFalse;
    aCleanupInfo.iSupportIndex = KErrNotFound;
    aCleanupInfo.iEntryCreated = EFalse;
    aCleanupInfo.iEntryIndex = KErrNotFound;
    aCleanupInfo.iSupport = iSupport;
    TBool findAux = EFalse;
    TInt strLength = aAtCmdBase.Length();
    if ( strLength>=3 && aAtCmdBase[strLength-1]=='*' )  // 3 for "AT*"
        {
        aAtCmdBase.SetLength( strLength-1 );
        aCleanupInfo.iSupport = iSupportAux;
        support = iSupportAux;
        findAux = ETrue;
        }
    TInt foundPos = KErrNotFound;
    TBool found = FindCommandFromMetadata( aAtCmdBase, foundPos, findAux, EFalse );
    if ( !found )
        {
        // Not found. foundPos is the position where to add the new entry
        TATExtAtCmdSupport newEntry;
        foundPos = -foundPos;  // convert to positive
        newEntry.iAtCmdBase = HBufC8::NewMaxLC( aAtCmdBase.Length() );
        newEntry.iEntries = NULL;
        TPtr8 atCmdPtr = newEntry.iAtCmdBase->Des();
        atCmdPtr.Copy( aAtCmdBase );
        support->InsertL( foundPos, newEntry );
        CleanupStack::Pop( newEntry.iAtCmdBase );
        aCleanupInfo.iSupportCreated = ETrue;
        }
    aCleanupInfo.iSupportIndex = foundPos;
    // Next try to find the plugin UID from plugin data.
    TInt foundIndex = KErrNotFound;
    TATExtPluginEntry* foundEntry = FindUidFromPlugindata( aPluginUid,
                                                           foundIndex );
    if ( !foundEntry )
        {
        // Not found. Append new initialized entry.
        TATExtPluginEntry pluginEntry;
        pluginEntry.iPluginUid = aPluginUid;
        pluginEntry.iInstance = NULL;
        pluginEntry.iLocked = EFalse;
        pluginEntry.iUrcStarted = EFalse;
        pluginEntry.iUrcOwned = EFalse;
        iPluginData->AppendL( pluginEntry );
        aCleanupInfo.iEntryCreated = ETrue;
        aCleanupInfo.iEntryIndex = iPluginData->Count() - 1;
        foundIndex = aCleanupInfo.iEntryIndex;
        foundEntry = &(*iPluginData)[foundIndex];
        }
    // Now foundEntry is either the found entry or a newly added entry.
    // Make the iSupport metadata point to this.
    TATExtAtCmdSupport& foundSupport = (*support)[foundPos];
#if defined( PRJ_OPTIMIZE_FOR_SPEED )
    AddNewMetadataEntryLinkL( foundSupport.iEntries,
                              foundIndex,
                              aSupportType,
                              foundSupport.iSearchHelper );
#else  // PRJ_OPTIMIZE_FOR_SPEED
    TATExtSearchHelper searchHelper;
    AddNewMetadataEntryLinkL( foundSupport.iEntries,
                              foundIndex,
                              aSupportType,
                              searchHelper );
#endif  // PRJ_OPTIMIZE_FOR_SPEED
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Adds new plugin entry link from plugin support entry to plugin entry
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::AddNewMetadataEntryLinkL(
    CArrayFixFlat<TATExtOneCmdSupport>*& aEntries,
    TInt aEntryIndex,
    TATExtSupportType aSupportType,
    TATExtSearchHelper& aSearchHelper )
    {
    TRACE_FUNC_ENTRY
    if ( !iPluginData || aEntryIndex<0 || aEntryIndex>=iPluginData->Count() )
        {
        TRACE_FUNC_EXIT
        User::Leave( KErrGeneral );
        }
    if ( !aEntries )
        {
        aEntries = new (ELeave) CArrayFixFlat<TATExtOneCmdSupport>( KGranularity );
        }
    TATExtOneCmdSupport oneCmdSupport;
    oneCmdSupport.iSupportType = aSupportType;
    oneCmdSupport.iEntryIndex = aEntryIndex;
    TInt retVal = KErrNotSupported;
    switch ( aSupportType )
        {
        case ESupportTypeMaster:
            {
            retVal = AddNewMasterMetadataEntryLinkL( aEntries,
                                                     aSearchHelper,
                                                     oneCmdSupport );
            }
            break;
        case ESupportTypePartial:
            {
            retVal = AddNewPartialMetadataEntryLinkL( aEntries,
                                                      aSearchHelper,
                                                      oneCmdSupport );
            }
            break;
        case ESupportTypeObserver:
            {
            retVal = AddNewObserverMetadataEntryLinkL( aEntries,
                                                       aSearchHelper,
                                                       oneCmdSupport );
            }
            break;
        default:
            {
            User::Leave( KErrNotSupported );
            }
        }
    TRACE_FUNC_EXIT
    return retVal;
    }

// ---------------------------------------------------------------------------
// Adds new master plugin entry link from plugin support entry to plugin entry
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::AddNewMasterMetadataEntryLinkL(
    CArrayFixFlat<TATExtOneCmdSupport>* aEntries,
    TATExtSearchHelper& aSearchHelper,
    TATExtOneCmdSupport& aOneCmdSupport )
    {
    TRACE_FUNC_ENTRY
    if ( aEntries->Count() > 0 )
        {
        TATExtOneCmdSupport& oneCmdSupport = (*aEntries)[0];
        if ( oneCmdSupport.iSupportType == ESupportTypePartial )
            {
            _LIT( KAddMIsP, "AddMIsP" );
            User::Panic( KAddMIsP, EPanicCategoryAddMIsP );
            }
        if ( oneCmdSupport.iSupportType == ESupportTypeMaster )
            {
            _LIT( KAddMIsM, "AddMIsM" );
            User::Panic( KAddMIsM, EPanicCategoryAddMIsM );
            }
        }
    aEntries->InsertL( 0, aOneCmdSupport );
    if ( aSearchHelper.iPartialIndex >= 0 )
       {
        aSearchHelper.iPartialIndex++;
        }
    if ( aSearchHelper.iObserverIndex >= 0 )
        {
        aSearchHelper.iObserverIndex++;
        }
    TRACE_FUNC_EXIT
    return 0;
    }

// ---------------------------------------------------------------------------
// Adds new partial plugin entry link from plugin support entry to plugin
// entry
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::AddNewPartialMetadataEntryLinkL(
    CArrayFixFlat<TATExtOneCmdSupport>* aEntries,
    TATExtSearchHelper& aSearchHelper,
    TATExtOneCmdSupport& aOneCmdSupport )
    {
    TRACE_FUNC_ENTRY
    if ( aEntries->Count() > 0 )
        {
        TATExtOneCmdSupport& oneCmdSupport = (*aEntries)[0];
        if ( oneCmdSupport.iSupportType == ESupportTypeMaster )
            {
            _LIT( KAddPIsM, "AddPIsM" );
            User::Panic( KAddPIsM, EPanicCategoryAddPIsM );
            }
        }
    TInt i = aSearchHelper.iPartialIndex;
    if ( i < 0 )
        {
        TInt count = aEntries->Count();
        for ( i=0; i<count; i++ )
            {
            TATExtOneCmdSupport& oneCmdSupport = (*aEntries)[i];
            if ( oneCmdSupport.iSupportType==ESupportTypePartial ||
                 oneCmdSupport.iSupportType==ESupportTypeObserver )
                {
                break;
                }
            }
        aSearchHelper.iPartialIndex = i;
        }
    aEntries->InsertL( i, aOneCmdSupport );
    if ( aSearchHelper.iObserverIndex >= 0 )
        {
        aSearchHelper.iObserverIndex++;
        }
    TRACE_FUNC_EXIT
    return i;
    }

// ---------------------------------------------------------------------------
// Adds new observer plugin entry link from plugin support entry to plugin
// entry. Search starts from the front as there could be multiple O plugins
// but only one or two M/P plugins.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::AddNewObserverMetadataEntryLinkL(
    CArrayFixFlat<TATExtOneCmdSupport>* aEntries,
    TATExtSearchHelper& aSearchHelper,
    TATExtOneCmdSupport& aOneCmdSupport )
    {
    TRACE_FUNC_ENTRY
    TInt i = aSearchHelper.iObserverIndex;
    if ( i < 0 )
        {
        TInt count = aEntries->Count();
        for ( i=0; i<count; i++ )
            {
            TATExtOneCmdSupport& oneCmdSupport = (*aEntries)[i];
            if ( oneCmdSupport.iSupportType == ESupportTypeObserver )
                {
                break;
                }
            }
        aSearchHelper.iObserverIndex = i;
        }
    aEntries->InsertL( i, aOneCmdSupport );
    TRACE_FUNC_EXIT
    return i;
    }

// ---------------------------------------------------------------------------
// Cleans partial created metadata based on TATExtCleanupInfo
// ---------------------------------------------------------------------------
//
void CATExtMetadata::CleanPartialMetadata( TATExtCleanupInfo& aCleanupInfo )
    {
    TRACE_FUNC_ENTRY
    TBool withinEntryLimits = EFalse;
    TBool withinSupportLimits = EFalse;
    CArrayFixFlat<TATExtAtCmdSupport>* support = aCleanupInfo.iSupport;
    if ( aCleanupInfo.iEntryIndex>=0 &&
         aCleanupInfo.iEntryIndex<support->Count() )
        {
        withinEntryLimits = ETrue;
        }
    if ( aCleanupInfo.iSupportIndex>=0 &&
         aCleanupInfo.iSupportIndex<support->Count() )
        {
        withinSupportLimits = ETrue;
        }
    if ( aCleanupInfo.iEntryCreated && withinEntryLimits )
        {
        iPluginData->Delete( aCleanupInfo.iEntryIndex );
        }
    if ( aCleanupInfo.iSupportCreated && withinSupportLimits )
        {
        TInt deleteIndex = aCleanupInfo.iSupportIndex;
        TATExtAtCmdSupport& supportData = (*support)[deleteIndex];
        delete supportData.iAtCmdBase;
        supportData.iAtCmdBase = NULL;
        delete supportData.iEntries;
        supportData.iEntries = NULL;
        support->Delete( deleteIndex );
        support->Compress();
        }
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Prints the AT command plugin entries and information about them.
// For debugging/bug hunting only
// ---------------------------------------------------------------------------
//
#if defined(_DEBUG) && defined( PRJ_PRINT_SUPPORT_DATA )
TInt CATExtMetadata::PrintSupportData(
    CArrayFixFlat<TATExtAtCmdSupport>* aSupport )
    {
    TRACE_FUNC_ENTRY
    if ( !aSupport )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    TInt i;
    TInt j;
    TInt supportCount = aSupport->Count();
    for ( i=0; i<supportCount; i++ )
        {
        TATExtAtCmdSupport& support = (*aSupport)[i];
        if ( !support.iEntries )
            {
            continue;
            }
        TInt entryCount = support.iEntries->Count();
        TRACE_INFO(( _L8("Support entry at index %d = '%S' (%d entries):"), i, &(*support.iAtCmdBase), entryCount ));
        for ( j=0; j<entryCount; j++ )
            {
            TATExtOneCmdSupport& oneCmdSupport = (*support.iEntries)[j];
            TInt entryIndex = oneCmdSupport.iEntryIndex;
            TRACE_INFO(( _L8("\tPlugin entry at index %d = Type:%d, UID:0x%08X"), j, oneCmdSupport.iSupportType, (*iPluginData)[entryIndex].iPluginUid ));
            }
        }
    TRACE_FUNC_EXIT
    return KErrNone;
    }
#endif

// ---------------------------------------------------------------------------
// Prints the found AT command plugin entries and information about them.
// For debugging/bug hunting only
// ---------------------------------------------------------------------------
//
#if defined(_DEBUG) && defined( PRJ_PRINT_SUPPORT_DATA )
TInt CATExtMetadata::PrintFoundEntries(
    CArrayFixFlat<TATExtOneCmdSupport>* aEntries )
    {
    TRACE_FUNC_ENTRY
    if ( !aEntries )
        {
        TRACE_FUNC_EXIT
        return KErrGeneral;
        }
    TInt i;
    TInt count = aEntries->Count();
    for ( i=0; i<count; i++ )
        {
        TATExtOneCmdSupport& entry = (*aEntries)[i];
        TInt entryIndex = entry.iEntryIndex;
        TRACE_INFO(( _L8("\tFound entry at index %d = Type:%d, UID:0x%08X"), i, entry.iSupportType, (*iPluginData)[entryIndex].iPluginUid ));
        }
    TRACE_FUNC_EXIT
    return KErrNone;
    }
#endif

// ---------------------------------------------------------------------------
// Does a binary search for an AT command to find the AT command from the
// support data
// ---------------------------------------------------------------------------
//
TBool CATExtMetadata::FindCommandFromMetadata( TDesC8& aAtCmdBase,
                                               TInt& aFoundIndex,
                                               TBool aFindAuxCmd,
                                               TBool aCheckAsterisk )
    {
    TRACE_FUNC_ENTRY
    if ( !iSupport || !iSupportAux || (!aFindAuxCmd&&aCheckAsterisk) )
        {
        TRACE_FUNC_EXIT
        return EFalse;
        }
    TInt result = 0;
    TInt middle = 0;
    TInt left = 0;
    CArrayFixFlat<TATExtAtCmdSupport>* support = iSupport;
    if ( aFindAuxCmd )
        {
        support = iSupportAux;
        }
    TInt right = support->Count() - 1;
    while ( left <= right )
        {
        middle = ( left + right ) / 2;
        HBufC8& compareStr = *(*support)[middle].iAtCmdBase;
        TInt strLength = compareStr.Length();
        if ( aCheckAsterisk )
            {
            TPtrC8 leftPart = aAtCmdBase.Left( strLength );
            result = compareStr.Compare( leftPart );
            }
        else
            {
            result = compareStr.Compare( aAtCmdBase );
            }
        if ( result == 0 )  // iSupport == aAtCmd
            {
            aFoundIndex = middle;
            TRACE_FUNC_EXIT
            return ETrue;
            }
        else if ( result < 0 )  // iSupport < aAtCmd
            {
            left = middle + 1;
            }
        else  // iSupport > aAtCmd
            {
            right = middle - 1;
            }
        }
    aFoundIndex = -left;
    TRACE_FUNC_EXIT
    return EFalse;
    }

// ---------------------------------------------------------------------------
// Finds the first plugin entry from a given plugin UID
// ---------------------------------------------------------------------------
//
TATExtPluginEntry* CATExtMetadata::FindUidFromPlugindata( TUid& aUid,
                                                          TInt& aFoundIndex )
    {
    TRACE_FUNC_ENTRY
    aFoundIndex = KErrNotFound;
    if ( !iPluginData )
        {
        TRACE_FUNC_EXIT
        return NULL;
        }
    TInt i;
    TInt count = iPluginData->Count();
    for ( i=0; i<count; i++ )
        {
        TATExtPluginEntry& entry = (*iPluginData)[i];
        if ( entry.iPluginUid == aUid )
            {
            TRACE_FUNC_EXIT
            aFoundIndex = i;
            return &entry;
            }
        }
    TRACE_FUNC_EXIT
    return NULL;
    }

// ---------------------------------------------------------------------------
// Find the first plugin entry from a given plugin instance
// ---------------------------------------------------------------------------
//
TATExtPluginEntry* CATExtMetadata::FindInstanceFromPlugindata(
    CATExtPluginBase* aInstance )
    {
    TRACE_FUNC_ENTRY
    if ( !iPluginData )
        {
        TRACE_FUNC_EXIT
        return NULL;
        }
    TInt i;
    TInt count = iPluginData->Count();
    for ( i=0; i<count; i++ )
        {
        TATExtPluginEntry& entry = (*iPluginData)[i];
        if ( entry.iInstance == aInstance )
            {
            TRACE_FUNC_EXIT
            return &entry;
            }
        }
    TRACE_FUNC_EXIT
    return NULL;
    }

// ---------------------------------------------------------------------------
// Finds an Urc message processing plugin. Must be used in synchronization
// with MarkUrcHandlingOwnership(). More information in aPluginUid parameter's
// explanation below.
// ---------------------------------------------------------------------------
//
TATExtPluginEntry* CATExtMetadata::FindUrcProcessingPlugin(
    TUid& aPluginUid )
    {
    TRACE_FUNC_ENTRY
    if ( !iPluginData )
        {
        TRACE_FUNC_EXIT
        return NULL;
        }
    TInt i;
    TInt count = iPluginData->Count();
    for ( i=0; i<count; i++ )
        {
        TATExtPluginEntry& entry = (*iPluginData)[i];
        if ( entry.iUrcMessage.Handle() )
            {
            continue;
            }
        // second run (after MarkUrcHandlingOwnership())
        if ( aPluginUid != TUid::Null() )
            {
            if ( entry.iUrcOwned && entry.iPluginUid==aPluginUid )
                {
                TRACE_FUNC_EXIT
                return &entry;
                }
            }
        // first run (before MarkUrcHandlingOwnership())
        else if ( !entry.iUrcStarted && !entry.iUrcOwned )
            {
            TRACE_FUNC_EXIT
            return &entry;
            }
        }
    TRACE_FUNC_EXIT
    return NULL;
    }

// ---------------------------------------------------------------------------
// Extracts the base command from a given AT command to find support with
// DoCreateAndFindSupportL()
// ---------------------------------------------------------------------------
//
void CATExtMetadata::CreateAndFindSupportL(
    TDesC8& aAtCmdFull,
    const RMessage2& aMessage,
    TATExtCompletionInfo& aComplInfo )
    {
    TRACE_FUNC_ENTRY
    // First extract the base of AT command from aAtCmdFull
    // ('=' and everything after that)
    TInt newLength = aAtCmdFull.Length();
    TInt foundPos = aAtCmdFull.Locate( '=' );
    if ( foundPos >= 2 )  // After "AT"
        {
        newLength = foundPos;
        }
    else if ( newLength >= 1 )
        {
        // There was no '=' so check if the last character is '?'.
        // If it is then remove it.
        if ( aAtCmdFull[newLength-1] == '?' )
            {
            newLength--;
            }
        }
    HBufC8* baseCmd = HBufC8::NewMaxLC( newLength );
    TPtr8 baseCmdPtr = baseCmd->Des();
    baseCmdPtr.Copy( &aAtCmdFull[0], newLength );
    // Now the baseCmd has the base command. Use it to find the support.
    DoCreateAndFindSupportL( *baseCmd,
                             aAtCmdFull,
                             aMessage,
                             aComplInfo );
    CleanupStack::PopAndDestroy( baseCmd );
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Creates AT command support and finds the given AT command from the created
// support data
// ---------------------------------------------------------------------------
//
void CATExtMetadata::DoCreateAndFindSupportL(
    TDesC8& aAtCmdBase,
    TDesC8& aAtCmdFull,
    const RMessage2& aMessage,
    TATExtCompletionInfo& aComplInfo )
    {
    TRACE_FUNC_ENTRY
    // Note: don't set iCmdData.iOldHandler to NULL here as the sequence can
    // invoke this function again before ReportExternalHandleCommandError().
    // Get array of supported plugins for the base command
    CArrayFixFlat<TATExtOneCmdSupport>* support;
    support = FindEntriesForCommandLC( aAtCmdBase );
    if ( !support )
        {
        aComplInfo.iProcessed = EFalse;
        aComplInfo.iReplyExpected = ETrue;
        CreateSelfReplyData( aMessage );
        CleanupStack::PopAndDestroy();
        TRACE_FUNC_EXIT
        return;
        }
    TATExtEntrySupport entrySupport( aAtCmdFull, aMessage, support );
    TInt i;
    aComplInfo.iProcessed = EFalse;
    TInt count = support->Count();
    for ( i=0; i<count; i++ )
        {
        TBool supported = EFalse;
        TATExtOneCmdSupport& oneCmdSupport = (*support)[i];
        entrySupport.iEntry = &(*iPluginData)[oneCmdSupport.iEntryIndex];
        if ( oneCmdSupport.iSupportType == ESupportTypeMaster )
            {
            supported = HandleMasterAndPartialPluginSupportL(
                entrySupport,
                i+1,
                aComplInfo.iReplyExpected );
            }
        else if ( oneCmdSupport.iSupportType == ESupportTypePartial )
            {
            supported = FindExclusivePartialSupportL( entrySupport );
            if ( !supported )
                {
                break;
                }
            supported = HandleMasterAndPartialPluginSupportL(
                entrySupport,
                i+1,
                aComplInfo.iReplyExpected );
            }
        else if ( oneCmdSupport.iSupportType == ESupportTypeObserver )
            {
            supported = HandleObserverPluginSupportL(
                entrySupport,
                i+1,
                aComplInfo.iReplyExpected );
            }
        if ( supported )
            {
            aComplInfo.iProcessed = ETrue;
            break;
            }
        }
    CleanupStack::PopAndDestroy( support );
    if ( !aComplInfo.iProcessed || !aComplInfo.iReplyExpected )
        {
        CreateSelfReplyData( aMessage );
        }
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Prepares internal data for completion with "" or "ERROR" messages.
// More explation in CreateEmptyOrErrorBuffer().
// ---------------------------------------------------------------------------
//
void CATExtMetadata::CreateSelfReplyData( const RMessage2& aMessage )
    {
    TRACE_FUNC_ENTRY
    // "ERROR" or "" needed; initialize
    iCmdData.iCmdStarted = ETrue;
    iCmdData.iCmdMessage = aMessage;
    iCmdData.iHandler = NULL;
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Handles support when a master or partial plugin is detected in the plugin
// data via support data's link. If a partial or master plugin is detected
// then reply is expected from that plugin. Also if one or more observer
// plugins are detected then no reply is expected from them.
// ---------------------------------------------------------------------------
//
TBool CATExtMetadata::HandleMasterAndPartialPluginSupportL(
    TATExtEntrySupport& aEntrySupport,
    TInt aStartIndex,
    TBool& aReplyExpected )
    {
    TRACE_FUNC_ENTRY
    aReplyExpected = EFalse;
    if ( !aEntrySupport.iSupportFound )
        {
        TBool supported = HandleCommandSupportL( aEntrySupport );
        if ( !supported )
            {
            TRACE_FUNC_EXIT
            return EFalse;
            }
        }
    // If HandleCommand() is implemented synchronously, the command must be
    // saved before executing as CompleteCommandMessage() closes the string
    HBufC8* atCmdFull = HBufC8::NewMaxLC( aEntrySupport.iAtCmdFull.Length() );
    TPtr8 atCmdFullPtr = atCmdFull->Des();
    atCmdFullPtr.Copy( aEntrySupport.iAtCmdFull );
    // Now execute the HandleCommand()
    iCmdData.iReplyExpected = ETrue;  // Set before HandleCommandL()
    HandleCommandL( aEntrySupport, ETrue );
    aEntrySupport.iStartIndex = aStartIndex;
    SendToMultipleObserverL( aEntrySupport, atCmdFull );
    CleanupStack::PopAndDestroy( atCmdFull );
    aReplyExpected = ETrue;
    TRACE_FUNC_EXIT
    return ETrue;
    }

// ---------------------------------------------------------------------------
// Handles support when a observer plugin is detected in the plugin data via
// support data's link. If only one observer plugin is detected then reply is
// expected from that plugin. Instead, if more than one observer plugins are
// detected then no reply is expected from them.
// ---------------------------------------------------------------------------
//
TBool CATExtMetadata::HandleObserverPluginSupportL(
    TATExtEntrySupport& aEntrySupport,
    TInt aStartIndex,
    TBool& aReplyExpected )
    {
    TRACE_FUNC_ENTRY
    aReplyExpected = EFalse;
    if ( !aEntrySupport.iSupportFound )
        {
        TBool supported = HandleCommandSupportL( aEntrySupport );
        if ( !supported )
            {
            TRACE_FUNC_EXIT
            return EFalse;
            }
        }
    TATExtEntrySupport nextSupport = aEntrySupport;
    nextSupport.iStartIndex = aStartIndex;
    TBool entryFound = FindFirstObserverSupportL( nextSupport );
    if ( entryFound )
        {
        // Entry found; send all without reply request
        // If HandleCommand() is implemented synchronously, the command must be
        // saved before executing as CompleteCommandMessage() closes the string
        HBufC8* atCmdFull = HBufC8::NewMaxLC( aEntrySupport.iAtCmdFull.Length() );
        TPtr8 atCmdFullPtr = atCmdFull->Des();
        atCmdFullPtr.Copy( aEntrySupport.iAtCmdFull );
        // Now execute the HandleCommand()
        HandleCommandL( aEntrySupport, EFalse );
        SendToMultipleObserverL( nextSupport, atCmdFull );
        CleanupStack::PopAndDestroy( atCmdFull );
        }
    else
        {
        // No entry found; send one with reply request
        iCmdData.iReplyExpected = ETrue;  // Set before HandleCommandL()
        HandleCommandL( aEntrySupport, ETrue );
        aReplyExpected = ETrue;
        }
    TRACE_FUNC_EXIT
    return ETrue;
    }

// ---------------------------------------------------------------------------
// Finds exclusive partial plugin support
// ---------------------------------------------------------------------------
//
TBool CATExtMetadata::FindExclusivePartialSupportL(
    TATExtEntrySupport& aEntrySupport )
    {
    TRACE_FUNC_ENTRY
    TInt i;
    TInt supports;
    TInt count = aEntrySupport.iSupport->Count();
    for ( i=0,supports=0; i<count; i++ )
        {
        TATExtOneCmdSupport& oneCmdSupport = (*aEntrySupport.iSupport)[i];
        if ( oneCmdSupport.iSupportType == ESupportTypePartial )
            {
            aEntrySupport.iSupportFound = EFalse;
            aEntrySupport.iEntry = &(*iPluginData)[oneCmdSupport.iEntryIndex];
            TBool supported = HandleCommandSupportL( aEntrySupport );
            if ( supported )
                {
                aEntrySupport.iSupportFound = ETrue;
                supports++;
                }
            if ( supports != 1 )
                {
                TRACE_FUNC_EXIT
                return EFalse;
                }
            }
        }
    TRACE_FUNC_EXIT
    return ETrue;
    }

// ---------------------------------------------------------------------------
// Finds support entries from support data for a given base AT command
// ---------------------------------------------------------------------------
//
CArrayFixFlat<TATExtOneCmdSupport>* CATExtMetadata::FindEntriesForCommandLC(
    TDesC8& aAtCmdBase )
    {
    TRACE_FUNC_ENTRY
    TBool found;
    TInt foundPos;
    CArrayFixFlat<TATExtOneCmdSupport>* support =
        new (ELeave) CArrayFixFlat<TATExtOneCmdSupport>( KGranularity );
    CleanupStack::PushL( support );
    // First find normal data to which to add the aux entries
    found = FindCommandFromMetadata( aAtCmdBase, foundPos, EFalse, EFalse );
    if ( found )
        {
        CArrayFixFlat<TATExtOneCmdSupport>* entries =
            (*iSupport)[foundPos].iEntries;
        support->AppendL( &(*entries)[0], entries->Count() );
        }
    // Next add the aux links
    found = FindCommandFromMetadata( aAtCmdBase, foundPos, ETrue, ETrue );
    if ( found )
        {
        CArrayFixFlat<TATExtOneCmdSupport>* entries =
            (*iSupportAux)[foundPos].iEntries;
        TATExtSearchHelper searchHelper;
        TInt i;
        TInt count = entries->Count();
        for ( i=0; i<count; i++ )
            {
            TATExtOneCmdSupport& entry = (*entries)[i];
            AddNewMetadataEntryLinkL( support,
                                      entry.iEntryIndex,
                                      entry.iSupportType,
                                      searchHelper );
            }
        }
    // Now, as the normal data was inserted *before* the auxiliary data, the
    // auxiliary data is in front of the created "support" array for each M, P
    // and O entry. This insertion is faster than the other way around as there
    // can be multiple O plugins for the same command but usually much less
    // auxiliary entries for the same command.
#if defined(_DEBUG) && defined( PRJ_PRINT_SUPPORT_DATA )
    PrintFoundEntries( support );
#endif
    if ( support->Count() > 0 )
        {
        TRACE_FUNC_EXIT
        return support;
        }
    TRACE_FUNC_EXIT
    return NULL;
    }

// ---------------------------------------------------------------------------
// Instantiates plugin support
// ---------------------------------------------------------------------------
//
void CATExtMetadata::InstantiatePluginSupportL(
    TATExtEntrySupport& aEntrySupport )
    {
    TRACE_FUNC_ENTRY
    if ( aEntrySupport.iEntry )
        {
        InstantiatePluginL( *aEntrySupport.iEntry );
        }
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Instantiates a plugin
// ---------------------------------------------------------------------------
//
void CATExtMetadata::InstantiatePluginL( TATExtPluginEntry& aPluginEntry )
    {
    TRACE_FUNC_ENTRY
    if ( !aPluginEntry.iInstance )
         {
         TUid pluginUid = aPluginEntry.iPluginUid;
         CATExtPluginBase* plugin = CATExtPluginBase::NewL( pluginUid,
                                                            iObserver,
                                                            iConnectionName );
         plugin->ReportQuietModeChange( iQuietMode );
         plugin->ReportVerboseModeChange( iVerboseMode );
         plugin->ReportCharacterChange( ECharTypeCarriage, iCarriageReturn );
         plugin->ReportCharacterChange( ECharTypeLineFeed, iLineFeed );
         plugin->ReportCharacterChange( ECharTypeBackspace, iBackspace );
         aPluginEntry.iInstance = plugin;
         }
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Instantiates a plugin
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::InstantiatePlugin( TATExtPluginEntry& aPluginEntry )
    {
    TRACE_FUNC_ENTRY
    TRAPD( retTrap, InstantiatePluginL(aPluginEntry) );
    TRACE_FUNC_EXIT
    return retTrap;
    }

// ---------------------------------------------------------------------------
// Handles an AT command support request
// ---------------------------------------------------------------------------
TBool CATExtMetadata::HandleCommandSupportL( TATExtEntrySupport& aEntrySupport,
                                             const TDesC8* aAtCmdFull )
    {
    TRACE_FUNC_ENTRY
    InstantiatePluginSupportL( aEntrySupport );
    TBool supported = EFalse;
    if ( aEntrySupport.iEntry->iLocked )
        {
        TRACE_FUNC_EXIT
        User::Leave( KErrAccessDenied );
        }
    if ( !aAtCmdFull )
        {
        supported = aEntrySupport.iEntry->iInstance->IsCommandSupported(
            aEntrySupport.iAtCmdFull );
        }
    else
        {
        supported = aEntrySupport.iEntry->iInstance->IsCommandSupported(
            *aAtCmdFull );
        }
    TRACE_FUNC_EXIT
    return supported;
    }

// ---------------------------------------------------------------------------
// Handles an AT command
// ---------------------------------------------------------------------------
void CATExtMetadata::HandleCommandL( TATExtEntrySupport& aEntrySupport,
                                     TBool aReplyNeeded,
                                     const TDesC8* aAtCmdFull )
    {
    TRACE_FUNC_ENTRY
    if ( !aEntrySupport.iEntry || !aEntrySupport.iEntry->iInstance )
        {
        TRACE_FUNC_EXIT
        User::Leave( KErrGeneral );
        }
    if ( aEntrySupport.iEntry->iLocked )
        {
        TRACE_FUNC_EXIT
        User::Leave( KErrAccessDenied );
        }
    // As HandleCommand() could complete the message synchronously, set the
    // iCmdData before the call
    if ( aReplyNeeded )
        {
        iCmdData.iCmdStarted = ETrue;
        iCmdData.iCmdMessage = aEntrySupport.iMessage;
        iCmdData.iHandler = aEntrySupport.iEntry;
        iCmdData.iEditorHandler = NULL;
        }
    // No "else" here as HandleCommandL() is used also with observer plugins
    if ( !aAtCmdFull )
        {
        TRACE_INFO(( _L8("Handling command '%S' for UID:0x%08X, aReplyNeeded=%d..."), &iCmdData.iCmdBuffer, aEntrySupport.iEntry->iPluginUid, aReplyNeeded ));
        aEntrySupport.iEntry->iInstance->HandleCommand(
            iCmdData.iCmdBuffer,
            iCmdData.iCmdReplyBuffer,
            aReplyNeeded );
        }
    else
        {
        TRACE_INFO(( _L8("Handling command '%S' for UID:0x%08X, aReplyNeeded=%d..."), &(*aAtCmdFull), aEntrySupport.iEntry->iPluginUid, aReplyNeeded ));
        aEntrySupport.iEntry->iInstance->HandleCommand(
            *aAtCmdFull,
            iCmdData.iCmdReplyBuffer,
            aReplyNeeded );
        }
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Sends an AT commands to multiple observer plugins, starting from a given
// position.
// ---------------------------------------------------------------------------
//
void CATExtMetadata::SendToMultipleObserverL(
    TATExtEntrySupport& aEntrySupport,
    const TDesC8* aAtCmdFull )
    {
    TRACE_FUNC_ENTRY
    if ( !aEntrySupport.iSupport )
        {
        TRACE_FUNC_EXIT
        User::Leave( KErrGeneral );
        }
    if ( !aEntrySupport.iSupportFound )
        {
        // No initial support found -> do nothing
        TRACE_FUNC_EXIT
        return;
        }
    TInt i;
    TInt count = aEntrySupport.iSupport->Count();
    for ( i=aEntrySupport.iStartIndex; i<count; i++ )
        {
        TATExtOneCmdSupport& oneCmdSupport = (*aEntrySupport.iSupport)[i];
        if ( oneCmdSupport.iSupportType != ESupportTypeObserver )
            {
            continue;
            }
        aEntrySupport.iEntry = &(*iPluginData)[oneCmdSupport.iEntryIndex];
        TBool supported = HandleCommandSupportL( aEntrySupport, aAtCmdFull );
        if ( supported )
            {
            HandleCommandL( aEntrySupport, EFalse, aAtCmdFull );
            aEntrySupport.iSupportFound = ETrue;
            }
        if ( i < count-1 )
            {
            aEntrySupport.iSupportFound = EFalse;
            }
        }
    TRACE_FUNC_EXIT
    }

// ---------------------------------------------------------------------------
// Finds the first observer plugin support from a given starting position
// ---------------------------------------------------------------------------
//
TBool CATExtMetadata::FindFirstObserverSupportL(
    TATExtEntrySupport& aEntrySupport )
    {
    TRACE_FUNC_ENTRY
    if ( !aEntrySupport.iSupport )
        {
        TRACE_FUNC_EXIT
        User::Leave( KErrGeneral );
        }
    TInt i;
    TInt count = aEntrySupport.iSupport->Count();
    for ( i=aEntrySupport.iStartIndex; i<count; i++ )
        {
        TATExtOneCmdSupport& oneCmdSupport = (*aEntrySupport.iSupport)[i];
        if ( oneCmdSupport.iSupportType != ESupportTypeObserver )
            {
            continue;
            }
        aEntrySupport.iSupportFound = EFalse;
        aEntrySupport.iEntry = &(*iPluginData)[oneCmdSupport.iEntryIndex];
        TBool supported = HandleCommandSupportL( aEntrySupport );
        if ( supported )
            {
            aEntrySupport.iSupportFound = ETrue;
            TRACE_FUNC_EXIT
            return ETrue;
            }
        }
    TRACE_FUNC_EXIT
    return EFalse;
    }

// ---------------------------------------------------------------------------
// Extracts one NVRAM entry from a pipe-character delimited NVRAM buffer
// ---------------------------------------------------------------------------
//
TBool CATExtMetadata::ExtractNextNvramSetting( const TDesC8& aNvram,
                                               TInt& aStartIndex,
                                               TInt& aEndIndex )
    {
    TRACE_FUNC_ENTRY
    // Skip data before command
    TInt i;
    TChar character;
    TInt count = aNvram.Length();
    for ( i=aEndIndex; i<count; i++ )
        {
        character = aNvram[i];
        if ( character.IsPrint() && character!='|' )
            {
            break;
            }
        }
    if ( i >= count )
        {
        TRACE_FUNC_EXIT
        return EFalse;
        }
    aStartIndex = i;
    // Start of command found, next mark the end
    while ( i < count )
        {
        character = aNvram[i];
        if ( !character.IsPrint() || character=='|' )
            {
            break;
            }
        i++;
        }
    aEndIndex = i;
    if ( aEndIndex-aStartIndex <= 0 )
        {
        TRACE_FUNC_EXIT
        return EFalse;
        }
    TRACE_FUNC_EXIT
    return ETrue;
    }

// ---------------------------------------------------------------------------
// Gets the next command from support or auxiliary support data.
// ---------------------------------------------------------------------------
//
HBufC8* CATExtMetadata::GetNextSupportedCommand( TBool& aFirstSearch,
                                                 TInt& aSupportFind,
                                                 TBool& aFindInAux )
    {
    TRACE_FUNC_ENTRY
    // If first search then start from index 0, othewise start from the
    // next index
    if ( aFirstSearch )
        {
        aSupportFind = -1;
        aFindInAux = EFalse;
        }
    aSupportFind++;
    aFirstSearch = EFalse;
    CArrayFixFlat<TATExtAtCmdSupport>* support = iSupport;
    if ( !aFindInAux )
        {
        if ( aSupportFind >= support->Count() )
            {
            aSupportFind = 0;
            aFindInAux = ETrue;
            support = iSupportAux;
            if ( aSupportFind >= support->Count() )
                {
                TRACE_FUNC_EXIT
                return NULL;
                }
            }
        }
    else
        {
        support = iSupportAux;
        if ( aSupportFind >= support->Count() )
            {
            TRACE_FUNC_EXIT
            return NULL;
            }
        }
    TATExtAtCmdSupport& supportEntry = (*support)[aSupportFind];
    HBufC8& atCmdBase = *supportEntry.iAtCmdBase;
    HBufC8* newBuffer = HBufC8::NewMax( atCmdBase.Length() );
    if ( newBuffer )
        {
        newBuffer->Des().Copy( atCmdBase );
        }
    TRACE_FUNC_EXIT
    return newBuffer;
    }

// ---------------------------------------------------------------------------
// Reads an AT command from a client request message and creates buffer
// locally. For HandleCommand().
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::ReadCommandFromMessage( const RMessage2& aMessage )
    {
    TRACE_FUNC_ENTRY
    // Read AT command from message, stop if error encountered
    TInt desLength = aMessage.GetDesLength( EATExtHandleCmdParamCmd );
    if ( desLength <= 0 )
        {
        TRACE_FUNC_EXIT
        return KErrArgument;
        }
    TInt retTemp = iCmdData.iCmdBuffer.Create( desLength );
    if ( retTemp != KErrNone )
        {
        TRACE_FUNC_EXIT
        return retTemp;
        }
    retTemp = aMessage.Read( EATExtHandleCmdParamCmd, iCmdData.iCmdBuffer );
    TRACE_INFO(( _L("Read returned %d"), retTemp ));
    if ( retTemp != KErrNone )
        {
        iCmdData.iCmdBuffer.Close();
        TRACE_FUNC_EXIT
        return retTemp;
        }
    TRACE_FUNC_EXIT
    return retTemp;
    }

// ---------------------------------------------------------------------------
// Creates a buffer with "ERROR" or "" string in it; needed for creating a
// reply to an unknown command (i.e. when no plugin supports the "base" part
// of a command) or to the case when plugin support exists but reply is not
// expected from them.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::CreateEmptyOrErrorBuffer( RBuf8& aBuffer,
                                               TBool aErrorReply )
    {
    TRACE_FUNC_ENTRY
    // Note: The behavior of RBuf8 is awkward. It is not possible to query
    // the "allocation status". Comparing the length to zero always returns
    // true even if RBuf8::Create() was not called. Here we should do the
    // following: If allocated and zero length, return with KErrNone. Otherwise
    // if not allocated create the buffer and return with RBuf::Create()'s
    // return code. We have to hack here so let's expect the buffer is not
    // allocated when calling this function.
    if ( !aErrorReply )
        {
        TInt retTemp = aBuffer.Create( KNullDesC8 );
        TRACE_FUNC_EXIT
        return retTemp;
        }
    TInt retVal = KErrNone;
    TBuf8<KErrorMsgLen> errorBuffer;
    if ( !iQuietMode )
        {
        if ( iVerboseMode )
            {
            _LIT8( KVerboseError, "ERROR" );
            errorBuffer.Append( iCarriageReturn );
            errorBuffer.Append( iLineFeed );
            errorBuffer.Append( KVerboseError );
            errorBuffer.Append( iCarriageReturn );
            errorBuffer.Append( iLineFeed );
            }
        else
            {
            _LIT8( KNumericError, "4" );
            errorBuffer.Append( KNumericError );
            errorBuffer.Append( iCarriageReturn );
            }
        }
    retVal = aBuffer.Create( errorBuffer );
    TRACE_FUNC_EXIT
    return retVal;
    }

// ---------------------------------------------------------------------------
// Writes specified input reply buffer to a client request message at given
// message slot number.
// ---------------------------------------------------------------------------
//
TInt CATExtMetadata::WriteReplyBufferToClient( const TDesC8& aBuffer,
                                               TInt aDataSlot,
                                               const RMessage2& aMessage,
                                               TBool aReportNextLength,
                                               TInt aLengthSlot )
    {
    TRACE_FUNC_ENTRY
    TInt maxLength = aMessage.GetDesMaxLength( aDataSlot );
    if ( aBuffer.Length() > maxLength )
        {
        TRACE_FUNC_EXIT
        return KErrTooBig;
        }
    TInt retTemp = aMessage.Write( aDataSlot, aBuffer );
    TRACE_INFO(( _L("First write returned %d"), retTemp ));
    if ( retTemp != KErrNone )
        {
        TRACE_FUNC_EXIT
        return retTemp;
        }
    if ( aReportNextLength && iCmdData.iHandler &&
         iCmdData.iHandler->iInstance )  // optional
        {
        CATExtPluginBase& plugin = *iCmdData.iHandler->iInstance;
        TInt nextPartLength = plugin.NextReplyPartLength();
        if ( nextPartLength <= 0 )
            {
            iCmdData.iHandler = NULL;
            }
        TPckg<TInt> nextPartLengthPckg( nextPartLength );
        retTemp = aMessage.Write( aLengthSlot, nextPartLengthPckg );
        TRACE_INFO(( _L("Second write returned %d"), retTemp ));
        if ( retTemp != KErrNone )
            {
            TRACE_FUNC_EXIT
            return retTemp;
            }
        }
    TRACE_FUNC_EXIT
    return KErrNone;
    }