/** @file

* Copyright (c) 2007 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:  CUpnpContentHandlersController

 *

*/

#include "upnpcontenthandlerscontroller.h"

#include <xml/parser.h>

#include <xml/xmlparsererrors.h>

#include <xml/matchdata.h>

#include "upnpstring.h"

#include "upnpservice.h"

#include "upnpdevice.h"

#include "upnpdeviceimplementation.h"

#include "upnpsilentdeviceimplementation.h"

#include "upnpserviceliterals.h"

#include "upnpdeviceliterals.h"

#include "upnpcontenthandler.h"

#include "upnpignorecontenthandler.h"

#include "upnpsoapcontenthandler.h"

#include "upnppropertysetcontenthandler.h"

#include "upnpservicecontenthandler.h"

#include "upnpdevicecontenthandler.h"

using namespace Xml;

// CONSTANTS

const TUint KUtfLowMax = 0x1F;

const TUint KUtfHighMin = 0x7F;

const TUint KUtfHighMax = 0xA0;

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::~CUpnpContentHandlersController

// Destructor

// -----------------------------------------------------------------------------

//

CUpnpContentHandlersController::~CUpnpContentHandlersController()

    {

    delete iParser;

    ASSERT( NULL == iStack || iStack->IsEmpty() );

    delete iStack;

    iContent.Close();

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::NewL

// Two-phased constructor

// -----------------------------------------------------------------------------

//

EXPORT_C CUpnpContentHandlersController* CUpnpContentHandlersController::NewL()

    {

    CUpnpContentHandlersController* controller =

        CUpnpContentHandlersController::NewLC();    

    CleanupStack::Pop( controller );

    return controller;

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::NewLC

// Two-phased constructor. Leaves the object on the CleanupStack

// -----------------------------------------------------------------------------

//

EXPORT_C CUpnpContentHandlersController* CUpnpContentHandlersController::NewLC()

    {

    CUpnpContentHandlersController* controller =

        new (ELeave) CUpnpContentHandlersController();

    CleanupStack::PushL( controller );

    controller->ConstructL();

    return controller;

    }

// -----------------------------------------------------------------------------

// CleanupResetAndDestroy

// Releases array, and object keapt in it.

// Used as method passed to TCleanupItem object.

// -----------------------------------------------------------------------------

//

LOCAL_C void CleanupResetAndDestroy(TAny* aRPointerArray)

    {

    reinterpret_cast<RPointerArray<CUpnpDescriptionProperty>* >(aRPointerArray)

        ->ResetAndDestroy();

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::UpdateActionWithOKResponseL

// For internal use. Update all necessary information from a SOAP-message

// that should be OK answer (e.g. received by Http 200 OK message).

// -----------------------------------------------------------------------------

//

EXPORT_C void CUpnpContentHandlersController::UpdateActionWithOKResponseL(

    CUpnpSoapMessage* aMessage, CUpnpAction* aAction )

    {

    iSoapParser.UpdateActionWithOKResponseL( aMessage, aAction );

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::UpdateActionWithErrorResponseL

// For internal use. Update all necessary information from a SOAP-message

// that should contain SOAP error (fault) message (eg. received by http

// 500 InternalServerError message.

// -----------------------------------------------------------------------------

//

EXPORT_C void CUpnpContentHandlersController::UpdateActionWithErrorResponseL(

    CUpnpSoapMessage* aMessage, CUpnpAction* aAction )

    {

    iSoapParser.UpdateActionWithErrorResponseL( aMessage, aAction );

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::UpdateActionWithRequestL

// Update action with all necessary information from

// a SOAP request message.

// -----------------------------------------------------------------------------

//

void CUpnpContentHandlersController::UpdateActionWithRequestL(

    CUpnpSoapMessage* aMessage, CUpnpAction* aAction )

    {

    iSoapParser.UpdateActionWithRequestL( aMessage, aAction );

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::AttachL

// For internal use. Attaches the information contained in a GENA buffer

// to this service. In practice, this means handling of received GENA messages.

// -----------------------------------------------------------------------------

//

EXPORT_C void CUpnpContentHandlersController::AttachL( const TDesC8& aGenaNotify,

                                                       CUpnpService& aService )

    {

    RPointerArray<CUpnpDescriptionProperty> parsedValues;

    CleanupStack::PushL( TCleanupItem( CleanupResetAndDestroy, &parsedValues ) );

    TRAPD( parseError, ParseGenaL( aGenaNotify, parsedValues ) );

    if ( KErrNone != parseError )

        {

        User::Leave( KErrGeneral );

        }

    for ( TInt i(0); i < parsedValues.Count(); ++i )

        {

        CUpnpDescriptionProperty* property = parsedValues[i];

        aService.SetStateVariableL( property->Name(), UpnpString::Trim( property->Value()) );

        }

    CleanupStack::PopAndDestroy( &parsedValues );

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ParseSoapL

// Parses a xml document and returns set objects of CUpnpDescriptionProperties

// It is used to parse action messages (soap)

// @pre description property array should be leave safe

// (there will be PopAndDestroy called on it in case of leave)

// -----------------------------------------------------------------------------

//

void CUpnpContentHandlersController::ParseSoapL(

        const TDesC8& aDescription,

        RPointerArray<CUpnpDescriptionProperty>& aParsedValues )

    {

    CUpnpSoapContentHandler* soapCH =

        CUpnpSoapContentHandler::NewL( *this, aParsedValues );

    iCorrectUri.Set( KSoapNamespaceUri );

    ParseXmlL( aDescription, soapCH );

    delete soapCH;

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ParseParseDescriptionPropertiesL

// Parses a xml document and returns set objects of CUpnpDescriptionProperties

// It is used to parse event notification

// @pre description property array should be leave safe

// (there will be PopAndDestroy called on it in case of leave)

// -----------------------------------------------------------------------------

//

void CUpnpContentHandlersController::ParseGenaL(

        const TDesC8& aDescription,

        RPointerArray<CUpnpDescriptionProperty>& aParsedValues )

    {

    CUpnpPropertysetContentHandler* propsetCH =

        CUpnpPropertysetContentHandler::NewL( *this, aParsedValues );

    iCorrectUri.Set( KEventNamespaceUri );

    ParseXmlL( aDescription, propsetCH );

    delete propsetCH;

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ParseServiceL

// Parses a xml document and returns object of CUpnpService class

// It is used for the first time the xml document is parsed

// -----------------------------------------------------------------------------

//

EXPORT_C CUpnpService* CUpnpContentHandlersController::ParseServiceL(

        const TDesC8& aDescription, CUpnpDevice* aParentDevice )

    {

    CUpnpServiceContentHandler* serviceCH =

        CUpnpServiceContentHandler::NewL( *this, aParentDevice );

    iCorrectUri.Set( KServiceNamespaceUri );

    ParseXmlL( aDescription, serviceCH );

    CUpnpService* result = serviceCH->ResultService();

    delete serviceCH;

    return result;

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ParseServiceL

// Parses an xml document

// It is used in case when CUpnpService object already exists

// -----------------------------------------------------------------------------

//

EXPORT_C void CUpnpContentHandlersController::ParseServiceL(

        const TDesC8& aDescription, CUpnpService* aService )

    {

    CUpnpServiceContentHandler* serviceCH =

        CUpnpServiceContentHandler::NewL( *this, *aService );

    iCorrectUri.Set( KServiceNamespaceUri );

    ParseXmlL(aDescription, serviceCH);

    delete serviceCH;

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ParseDeviceL

// Parses an xml document and returns instance of CUpnpDevice class

// It is used for the first time the device xml document is parsed

// -----------------------------------------------------------------------------

//

EXPORT_C CUpnpDevice* CUpnpContentHandlersController::ParseDeviceL(

    const TDesC8& aDescription )

    {

    return DoParseDeviceL( aDescription, (CUpnpDevice*)NULL );

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ParseDeviceL

// Parses an xml document and returns instance of CUpnpDevice class

// It is used in case when CUpnpDevice object already exists and update of

// device xml is required

// -----------------------------------------------------------------------------

//

EXPORT_C void CUpnpContentHandlersController::ParseDeviceL(

    const TDesC8& aDescription, CUpnpDevice* aDevice )

    {

    ASSERT( NULL != aDevice );

    DoParseDeviceL( aDescription, aDevice );

    }

template<class T> T* CUpnpContentHandlersController::DoParseDeviceL(

    const TDesC8& aDescription, T* aDevice )

    {

    CUpnpDeviceContentHandler* deviceCH = CUpnpDeviceContentHandler::NewL(

        *this, aDevice );

    iCorrectUri.Set( KDeviceNamespaceUri );

    ParseXmlL( aDescription, deviceCH );

    T* result(NULL);

    if ( !aDevice )

        {

        deviceCH->GetResultDevice( result );

        }

    delete deviceCH;

    return result;

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ParseDeviceImplL

// Parses an xml document and returns instance of CUpnpDevice class

// It is used for the first time the device xml document is parsed

// -----------------------------------------------------------------------------

//

EXPORT_C CUpnpDeviceImplementation* CUpnpContentHandlersController::ParseDeviceImplL(

    const TDesC8& aDescription )

    {

    return DoParseDeviceL( aDescription, (CUpnpDeviceImplementation*)NULL );

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ParseDeviceImplL

// Parses an xml document and returns instance of CUpnpDevice class

// It is used in case when CUpnpDeviceImplementation object already exists and

// update of device xml is required

// -----------------------------------------------------------------------------

//

EXPORT_C void CUpnpContentHandlersController::ParseDeviceImplL(

    const TDesC8& aDescription, CUpnpDeviceImplementation* aDeviceImpl )

    {

    ASSERT( NULL != aDeviceImpl );

    DoParseDeviceL( aDescription, aDeviceImpl );

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ParseSilentDeviceImplL

// Parses an xml document and returns instance of CUpnpDevice class

// It is used for the first time the device xml document is parsed

// -----------------------------------------------------------------------------

//

EXPORT_C CUpnpSilentDeviceImplementation* CUpnpContentHandlersController::ParseSilentDeviceImplL(

    const TDesC8& aDescription )

    {

    return DoParseDeviceL( aDescription, (CUpnpSilentDeviceImplementation*)NULL );

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ParseSilentDeviceImplL

// Parses an xml document and returns instance of CUpnpDevice class

// It is used in case when CUpnpSilentDeviceImplementation object already exists and

// update of device xml is required

// -----------------------------------------------------------------------------

//

EXPORT_C void CUpnpContentHandlersController::ParseSilentDeviceImplL(

    const TDesC8& aDescription, CUpnpSilentDeviceImplementation* aDeviceImpl )

    {

    ASSERT( NULL != aDeviceImpl );

    DoParseDeviceL( aDescription, aDeviceImpl );

    }

// -----------------------------------------------------------------------------

// ReleaseHandlersOnStack

// Releases all handlers that are on CStack<CUpnpContentHandler, ETrue> object

// Used as method passed to TCleanupItem object.

// -----------------------------------------------------------------------------

//

LOCAL_C void ReleaseHandlersOnStack(TAny* aStack)

    {

    reinterpret_cast<CStack<CUpnpContentHandler, ETrue>*>(aStack)->Clear();

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ParseXmlL

// Parses a xml document by passed content handler,

// there is a guarantee that aHandlerToUse will be deleted in case of leave

// precondition: iStack is empty

// postcondition: iStack is empty

// -----------------------------------------------------------------------------

//

void CUpnpContentHandlersController::ParseXmlL( const TDesC8& aDescription,

    CUpnpContentHandler* aHandlerToUse )

    {

    ASSERT( iStack->IsEmpty() );

    iCurrentContentHandler = aHandlerToUse;

    iStack->PushL( aHandlerToUse );

    CleanupStack::PushL( TCleanupItem( ReleaseHandlersOnStack, iStack ) );

    iDocStarted = EFalse;

    TRAPD( parseError, Xml::ParseL( *iParser, aDescription ) );

    if ( EXmlSyntax == parseError || EXmlInvalidToken == parseError ) 

        {

        while ( iStack->Count() > 1 )

            {

            delete iStack->Pop();

            }

        aHandlerToUse->ResetState();

        iCurrentContentHandler = aHandlerToUse;   

        iDocStarted = EFalse;

        RBuf8 fixedDes;

        fixedDes.CreateL( aDescription );

        CleanupClosePushL( fixedDes );                

        RemoveForbiddenCharacters( fixedDes );        

        TRAP( parseError, Xml::ParseL( *iParser, fixedDes ) );

        CleanupStack::PopAndDestroy( &fixedDes );

        }

    if ( EXmlJunkAfterDocElement != parseError ) 

        {

        User::LeaveIfError( parseError );

        }

    else

        {

        //EXmlJunkAfterDocElement must not be ignored when root isn't complete

        if ( !iDocStarted || iStack->Count() != 1 )

            {

            User::Leave( KErrArgument );     //no valid root element were found

            }

        }

    ASSERT( iStack->Count() == 1 );

    ASSERT( iStack->Head() == iCurrentContentHandler && iCurrentContentHandler == aHandlerToUse );

    iStack->Pop();

    CleanupStack::Pop( iStack );

    ASSERT( iStack->IsEmpty() );

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::RemoveForbiddenCharacters

// Removes forbidden characters

// -----------------------------------------------------------------------------

//

void CUpnpContentHandlersController::RemoveForbiddenCharacters( TDes8& aDescription )

    {    

    for( TInt i=0; i<aDescription.Length(); i++ )

        {

        if ( ( aDescription[i] <= KUtfLowMax ) ||

            ( aDescription[i] >= KUtfHighMin && aDescription[i] <= KUtfHighMax ) )

            {

            aDescription.Delete( i, 1 );

            i--;

            }

        }

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::CUpnpContentHandlersController

// Default C++ constructor

// -----------------------------------------------------------------------------

//

CUpnpContentHandlersController::CUpnpContentHandlersController()

    : iSoapParser( *this )

    {

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ConstructL

// 2nd phase constructor, dedicated to be used by inherited classs

// -----------------------------------------------------------------------------

//

void CUpnpContentHandlersController::ConstructL()

    {

    _LIT8( KXmlMimeType, "text/xml" );

    _LIT8( KLibxml2, "libxml2" );

    CMatchData *matchData = CMatchData::NewL();

    CleanupStack::PushL( matchData );

    matchData->SetMimeTypeL( KXmlMimeType );

    matchData->SetVariantL( KLibxml2 );

    iParser = CParser::NewL( *matchData, *this );

    CleanupStack::PopAndDestroy( matchData );

    iStack = new (ELeave) CStack<CUpnpContentHandler,ETrue>();

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::OnStartDocumentL

// This method is a callback to indicate the start of the document.

// -----------------------------------------------------------------------------

//

void CUpnpContentHandlersController::OnStartDocumentL(

    const RDocumentParameters& /*aDocParam*/, TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    iDocStarted = ETrue;

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::OnEndDocumentL

// This method is a callback to indicate the end of the document.

// -----------------------------------------------------------------------------

//

void CUpnpContentHandlersController::OnEndDocumentL( TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::OnStartElementL

// This method is a callback to indicate an element has been parsed.

// -----------------------------------------------------------------------------

//

void CUpnpContentHandlersController::OnStartElementL(

    const RTagInfo& aElement, const RAttributeArray& aAttributes,

    TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    ChunksMergingEndL();

    if ( iCurrentContentHandler->InterestedInAllNamespaces()

            || aElement.Uri().DesC().Compare( iCorrectUri ) == 0 )

        {

        iCurrentContentHandler->OnStartElementL( aElement, aAttributes );

        }

    else

        {

        SetCurrentContentHandlerL( CUpnpIgnoreContentHandler::NewL( *this ) );

        }

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::OnEndElementL

// This method is a callback to indicate the end of the element has been reached.

// -----------------------------------------------------------------------------

//

void CUpnpContentHandlersController::OnEndElementL( const RTagInfo& aElement,

    TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    ChunksMergingEndL();

    iCurrentContentHandler->OnEndElementL( aElement );

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::OnContentL

// This method is a callback that sends the content of the element.

// Not all the content may be returned in one go. The data may be sent in chunks.

// This method just append chunk to chunks previously received. When we get all

// chunks ChunksMergingEndL method pass merged chunks to current content handler.

// -----------------------------------------------------------------------------

//

void CUpnpContentHandlersController::OnContentL( const TDesC8& aBytes,

    TInt aErrorCode )

    {

    User::LeaveIfError( aErrorCode );

    const TInt newLength = iContent.Length() + aBytes.Length();

    if ( iContent.MaxLength() < newLength )

        {

        iContent.ReAllocL( newLength );

        }

    iContent.Append( aBytes );

    }

// -----------------------------------------------------------------------------

// CUpnpContentHandlersController::ChunksMergingEndL

// Method that is called when all chunks that contain current content

// were received, so we can pass merged content to current content handler

// as an argument of OnContentL method

// -----------------------------------------------------------------------------

//

void CUpnpContentHandlersController::ChunksMergingEndL()

    {

    if ( iContent.Length() > 0 )

        {

        TLex8 lex(iContent);

        lex.SkipSpace();