/** @file

* Copyright (c) 2005-2006 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:  CUpnpServiceImplementation

*

*/

// INCLUDE FILES

#include <e32def.h>

#include <e32math.h>

#include <f32file.h>

#include <s32file.h>

#include "upnpserviceimplementation.h"

#include "upnphttpmessage.h"

#include "upnpsoapmessage.h"

#include "upnpsoapmessagefactory.h"

#include "upnpgenamessage.h"

#include "upnpgenamessagefactory.h"

#include "upnpstring.h"

#include "upnpcommonupnplits.h"

#include "upnphttpmessagefactory.h"

#include "upnpdevice.h"

#include "upnpdeviceimplementationbase.h"

#include "upnpcommonstructs.h"

#include "upnplist.h"

#include "upnpfileutils.h"

#include "upnpdispatcher.h"

#include "upnpcontenthandlerscontroller.h"

#include "upnpeventcontroller.h"

#include "upnpsoapparser.h"

#define KLogFile _L("UPnPStack.txt")

#include "upnpcustomlog.h"

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

// CUpnpService::SetDispatcher

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

//

EXPORT_C void CUpnpServiceImplementation::SetDispatcher( CUpnpDispatcher* aDispatcher )

    {

    if(iDispatcher)

        {

        iDispatcher->RemoveCustomer(*this, EFalse);

        }

    iDispatcher = aDispatcher;

    }

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

// CUpnpService::SendL

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

//

EXPORT_C void CUpnpServiceImplementation::SendL( CUpnpHttpMessage *aMessage )

    {

    if ( iDispatcher )

        {

        iDispatcher->SendMessageL( aMessage, *this );

        }

    }

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

// CUpnpService::Path

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

//

EXPORT_C const TDesC8& CUpnpServiceImplementation::Path()

    {

    return *iPath;

    }

// ============================ MEMBER FUNCTIONS ===============================

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

// CUpnpServiceImplementation::CUpnpServiceImplementation

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

EXPORT_C CUpnpServiceImplementation::CUpnpServiceImplementation( CUpnpDevice& aDevice )

: CUpnpService(aDevice)

    {

    }

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

// CUpnpServiceImplementation::~CUpnpServiceImplementation

// Destructor.

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

//

EXPORT_C CUpnpServiceImplementation::~CUpnpServiceImplementation()

    {

    DeviceImpl().DetachService( this );

    iEventedVariables.Reset();

    delete iEventController;

    delete iSaxController;

    delete iSoapParser;

    }

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

// CUpnpServiceImplementation::BaseConstructL

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

//

EXPORT_C void CUpnpServiceImplementation::BaseConstructL( const TDesC& aFileName,

        const TDesC8& aServiceType )

    {

    //subscriber library initialization

    LOGS("CUpnpServiceImplementation::BaseConstructL");

    HBufC8* descr = UpnpFileUtil::ReadFileL( aFileName );

    CleanupStack::PushL(descr);

    // File ready

    this->ConstructL( *descr, aServiceType );

    CleanupStack::PopAndDestroy(descr);

    iEventController = CUpnpEventController::NewL( *this );

    // from device

    DeviceImpl().AttachServiceL( this );

    iComplete = ETrue;

    iDispatcher->AddCustomerL( *this, EFalse );

    iSaxController = CUpnpContentHandlersController::NewL();

    iSoapParser = new (ELeave) TUpnpSoapParser( *iSaxController );

    }

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

// CUpnpServiceImplementation::MessageReceivedLD

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

//

EXPORT_C void CUpnpServiceImplementation::MessageReceivedLD( CUpnpHttpMessage* aMessage )

    {

    LOGS("CUpnpServiceImplementation::MessageReceivedL(CUpnpHttpMessage*)");

    if ( !aMessage )

        {

        return;

        }

    CleanupStack::PushL( aMessage );

    if ( aMessage->IsSoap() )

        {

        // checking content type of action. Checking that content type exists.

        TPtrC8 tempHeaderValue = aMessage->GetHeaderValue( UpnpGENA::KContentType() );

        TPtrC8 headerValue;

        TInt posOfSemicolon = tempHeaderValue.Find( UpnpString::KSemiColon() );

        // checking if content type contains semicolon

        if ( posOfSemicolon != KErrNotFound )

            {

            tempHeaderValue.Set( tempHeaderValue.Left( posOfSemicolon ) );

            TPtrC8 trimmed( UpnpString::Trim( tempHeaderValue, EFalse ) );

            headerValue.Set( trimmed );

            }

        else

            {

            headerValue.Set( tempHeaderValue );

            }

        if ( headerValue.CompareC( UpnpGENA::KDefaultContentType ) != 0 )

            {

            // content type of action is not text/xml. Invalid action.

            CUpnpHttpMessage* messageOut

            = RUpnpHttpMessageFactory::HttpResponseErrorL(aMessage,

                    EHttpUnsupportedMediaType

            );

            CleanupStack::PushL( messageOut );

            SendL( messageOut );

            CleanupStack::PopAndDestroy( messageOut );

            CleanupStack::PopAndDestroy( aMessage );

            return;

            }

        TRAPD( err, HandleActionL( reinterpret_cast<CUpnpSoapMessage*>( aMessage ) ) );

        if ( err )

            {

            SendL( reinterpret_cast<CUpnpSoapMessage*>( aMessage ),

                    MapGenericErrorToUpnp( err ) );

            }

        }

    else if ( aMessage->IsGena() )

        {

        TRAPD( err, HandleActionL( reinterpret_cast<CUpnpGenaMessage*>( aMessage ) ) );

        if ( err )

            {

            // send proper errormessage

            CUpnpHttpMessage* messageOut

            = RUpnpHttpMessageFactory::UpnpResponseErrorL(aMessage,

                    EActionFailed

            );

            CleanupStack::PushL( messageOut );

            SendL( messageOut );

            CleanupStack::PopAndDestroy( messageOut );

            }

        }

    else

        {

        //should never happen        

        LOGS1( "CUpnpServiceImplementation::MessageReceivedLD msg type %d", aMessage->Type() );

        ASSERT( EFalse );       

        }

    CleanupStack::PopAndDestroy( aMessage );

    }

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

// CUpnpServiceImplementation::MapGenericErrorToUpnp

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

//

TUpnpErrorCode CUpnpServiceImplementation::MapGenericErrorToUpnp( TInt aError )

    {

    if ( aError == KErrArgument )

        {

        return EInvalidArgs;

        }

    else

        {

        return EActionFailed;

        }

    }

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

// CUpnpServiceImplementation::HandleActionL

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

//

void CUpnpServiceImplementation::HandleActionL(CUpnpGenaMessage* aMessage)

    {

    LOGS("CUpnpServiceImplementation::HandleActionL(CUpnpGenaMessage*)");

    if ( !aMessage )

        {

        return;

        }

    TPtrC8 method = aMessage->Method();

    if (method.Compare(UpnpGENA::KGenaSubscribe) == 0)

        {

        // Subscription or renewing:

        iEventController->SubscribeL( aMessage );

        }

    else if (method.Compare(UpnpGENA::KGenaUnSubscribe) == 0)

        {

        // UnSubscription:

        iEventController->UnSubscribeL( aMessage );

        }

    }

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

// CUpnpServiceImplementation::HandleActionL

// (other items were commented in a header).

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

//

void CUpnpServiceImplementation::HandleActionL( CUpnpSoapMessage* aMessage )

    {

    LOGS("CUpnpServiceImplementation::HandleActionL(CUpnpSoapMessage*)");

    if ( !aMessage )

        {

        return;

        }

    // parse SOAP to CUpnpAction

    CUpnpAction* action = CreateActionLC( aMessage->ActionName() );

    if ( !action )

        {

        // send errormessage

        SendL( aMessage, EInvalidAction );

        }

    else

        {

        iSoapParser->UpdateActionWithRequestL( aMessage, action );

        TInt actionError( action->Error() );

        if ( ( EUpnpOk == actionError ) || ( EHttp200Ok == actionError ) )

            {

            CleanupStack::Pop( action );

            // a valid action received

            ActionReceivedLD( action );

            }

        else

            {

            TUpnpErrorCode upnpError;

            // error

            if ( actionError < 0 ) //is generic symbian error

                {

                upnpError = MapGenericErrorToUpnp( actionError );

                }

            else

                {

                upnpError = (TUpnpErrorCode) actionError;

                }

            SendL( aMessage, upnpError );

            CleanupStack::PopAndDestroy( action );

            }

        }

    }

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

// CUpnpServiceImplementation::SendL

// (other items were commented in a header).

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

//

EXPORT_C void CUpnpServiceImplementation::SendL( CUpnpAction* aAction,

        TUpnpErrorCode aError)

    {

    LOGS1("CUpnpServiceImplementation::SendL(CUpnpAction*, TUpnpErrorCode: %d)", aError);

    CUpnpHttpMessage* msg( NULL );

    if ( EHttpOk == aError )

        {

        msg = reinterpret_cast<CUpnpHttpMessage*>

        (RUpnpSoapMessageFactory::SoapResponseL( aAction ));

        }

    else

        {

        LOGS1("Error: %i", aError);

        msg = reinterpret_cast<CUpnpHttpMessage*>

        (RUpnpSoapMessageFactory::SoapResponseL( aAction, aError ));

        }

    CleanupStack::PushL( msg );

    SendL( msg );

    CleanupStack::PopAndDestroy( msg );

    }

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

// CUpnpServiceImplementation::SendL

// (other items were commented in a header).

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

//

EXPORT_C void CUpnpServiceImplementation::SendL(CUpnpSoapMessage* aMessage,

        TUpnpErrorCode aError)

    {

    LOGS1("CUpnpServiceImplementation::SendL(CUpnpSoapMessage*, TUpnpErrorCode: %d)", aError);

    CUpnpHttpMessage* msg = reinterpret_cast<CUpnpHttpMessage*>(

            RUpnpSoapMessageFactory::SoapResponseL(aMessage, aError));

    CleanupStack::PushL(msg);

    SendL(msg);

    CleanupStack::PopAndDestroy(msg);

    }

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

// CUpnpServiceImplementation::SetStateVariableL

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

//

EXPORT_C void CUpnpServiceImplementation::SetStateVariableL( const TDesC8& aName,

        const TDesC8& aValue,

        TBool aIsModerated )

    {

    LOGS("CUpnpServiceImplementation::SetStateVariableL");

    TInt totalDesLength(0);

    totalDesLength = KGenaXml().Length() + KGenaPropertysetStart().Length()+

    KGenaPropertysetEnd().Length();

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

        {

        if ( iStateVariables[i]->Eventable().CompareF(KYes) == 0 )

            {

            totalDesLength+=KGenaPropertyStart().Length();

            totalDesLength+=iStateVariables[i]->Name().Length();

            totalDesLength+=KCloseBracket().Length();

            if ( aName.Compare( iStateVariables[i]->Name() ) == 0 )

                {

                totalDesLength+=aValue.Length();

                }

            else

                {

                totalDesLength+=iStateVariables[i]->Value().Length();

                }

            totalDesLength+=KOpenBracket().Length();

            totalDesLength+=( UpnpString::KSlash )().Length();

            totalDesLength+=iStateVariables[i]->Name().Length();

            totalDesLength+=KGenaPropertyEnd().Length();

            }

        }

    if (totalDesLength<KMaxGenaMessageLength)

        {

        CUpnpStateVariable* variable = StateVariable( aName );

        if( !variable )

            {

            User::Leave( KErrBadHandle );

            }

        variable->SetValueL( aValue, aIsModerated );

        }

    else

        {

        iEventController->SendModeratedNotification();

        }

    }

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

// CUpnpServiceImplementation::StateVariableValue

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

//

EXPORT_C const TPtrC8 CUpnpServiceImplementation::StateVariableValue(

        const TDesC8& aVariableName )

    {

    CUpnpStateVariable* variable = StateVariable(aVariableName);

    if (variable)

        {

        return variable->Value();

        }

    return KNullDesC8();

    }

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

// CUpnpServiceImplementation::StateVariable

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

//

EXPORT_C CUpnpStateVariable* CUpnpServiceImplementation::StateVariable(

        const TDesC8& aVariableName )

    {

    CUpnpStateVariable* variable = NULL;

    variable = CUpnpService::StateVariable(aVariableName);

    if (variable)

        {

        variable->SetParentImplementation(*this);

        }

    return variable;

    }

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

// CUpnpServiceImplementation::AddEventVariable

// (other items were commented in a header).

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

//

EXPORT_C void CUpnpServiceImplementation::AddEventVariable

(const CUpnpStateVariable& aVariable,

        TBool aIsModerated )

    {

    LOGS("CUpnpServiceImplementation::AddEventVariable");

    if (iEventedVariables.Find(&aVariable) == KErrNotFound)

        {

        iEventedVariables.Append(&aVariable);

        }

    if (aIsModerated)

        {

        iEventController->SendModeratedNotification();

        }

    else

        {

        iEventController->SendNonModeratedNotification();

        }

    }

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

// CUpnpServiceImplementation::SetVariableMaxEventRate

// (other items were commented in a header).

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

//

EXPORT_C void CUpnpServiceImplementation::SetVariableMaxEventRate

(const TDesC8& aVariable, TInt aMaxRate)

    {

    LOGS("CUpnpServiceImplementation::SetVariableMaxEventRate");

    for(TInt i = 0; i < iEventedVariables.Count(); i++)

        {

        if(iEventedVariables[i]->Name().Compare(aVariable)==0)

            {

            iEventedVariables[i]->SetMaxEventRate(aMaxRate, KMaxEventRate);

            }

        }

    }

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

// CUpnpServiceImplementation::StateVariableEvented

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

//

EXPORT_C void CUpnpServiceImplementation::StateVariableEvented(

        const TDesC8& /*aVariableName*/)

    {

    }

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

// CUpnpServiceImplementation::SubcribersAmount

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

//

EXPORT_C TInt CUpnpServiceImplementation::SubcribersAmount()

    {

    return iEventController->SubscribersAmount();

    }

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

// CUpnpServiceImplementation::DeviceImpl

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

//

CUpnpDeviceImplementationBase& CUpnpServiceImplementation::DeviceImpl()

    {

    return (CUpnpDeviceImplementationBase&) Device();

    }

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

// CUpnpServiceImplementation::EventedStateVariables

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

//

EXPORT_C RPointerArray<CUpnpStateVariable>&

CUpnpServiceImplementation::EventedStateVariables()

    {

    return iEventedVariables;

    }

//  End of File