/** @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:  Declares ControlPoint class.

 *

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32cons.h>

#include <e32std.h>

#include <in_sock.h>

#include <charconv.h>

#include <utf.h>

#include "upnpdispatcher.h"

#include "upnphttpmessage.h"

#include "upnpsoapmessage.h"

#include "upnpicon.h"

#include "upnpdevice.h"

#include "upnpstring.h"

#include "upnphttpmessagefactory.h"

#include "upnpsoapmessagefactory.h"

#include "upnpgenamessagefactory.h"

#include "upnpserviceinfo.h"

#include "upnpcontrolpoint.h"

#include "upnpcommonupnplits.h"

#include "upnpcons.h"

#include "upnpcpbhttpmessagecontroller.h"

#include "upnpcpbcurrenthttpclient.h"

#include "upnpcpbdescriptionagent.h"

#include "upnpcpbdiscoveryagent.h"

#include "upnpcpbdevicerepository.h"

#include "upnpcpstackrequestor.h"

#include "upnpcontenthandlerscontroller.h"

#include "upnpconnectionmanagernetworkeventprovider.h"

#include "upnpcpbinitialeventretryhandler.h"

#define KLogFile _L("UPnPCP.txt")

#include "upnpcustomlog.h"

using namespace UpnpHTTP;

static const TInt KDTargetDeviceTypesGranularity = 1;

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

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

// CUpnpControlPoint::CUpnpControlPoint

// C++ default constructor

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

//

EXPORT_C CUpnpControlPoint::CUpnpControlPoint()

    : iPredefinedStackRequestor( NULL ), iPredefinedHttpRequestor( NULL )

    {

    }

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

// CUpnpControlPoint::CUpnpControlPoint

// C++ constructor for internal, automated test cases use

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

//

EXPORT_C CUpnpControlPoint::CUpnpControlPoint(

    MUpnpCpStackRequestor& aStackRequestor, MUpnpCpHttpRequestor& aHttpRequestor )

    : iPredefinedStackRequestor( &aStackRequestor ),

      iPredefinedHttpRequestor( &aHttpRequestor )

    {

    }

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

// CUpnpControlPoint::~CUpnpControlPoint

// C++ default destructor

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

//

EXPORT_C CUpnpControlPoint::~CUpnpControlPoint()

    {

    LOG_FUNC_NAME;

    delete iCpbHttpClient;

    iSubscribedServicesInfos.ResetAndDestroy();

    iActionList.ResetAndDestroy();

    if ( iTargetDeviceTypes )

        {

        iTargetDeviceTypes->Reset();

        delete iTargetDeviceTypes;

        }

    delete iDescriptionAgent;

    delete iDiscoveryAgent;

    delete iNetworkEventProvider;

    delete iSaxController;

    delete iDeviceRepository;

    delete iInitialEventRetry;

    LOGS("CUpnpControlPoint::~CUpnpControlPoint - END");

    }

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

// CUpnpControlPoint::ConstructL

// Two-phased constructor

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

//

EXPORT_C void CUpnpControlPoint::ConstructL( const CDesC8Array& aTargetDeviceTypes )

    {

    iNetworkEventProvider = CUpnpConnectionManagerNetworkEventProvider::NewL( *this );

    iCpbHttpClient =

        CUpnpCpbCurrentHttpClient::NewL(

            *this, iPredefinedHttpRequestor, iPredefinedStackRequestor );

    iTargetDeviceTypes = new( ELeave ) CDesC8ArrayFlat( KDTargetDeviceTypesGranularity );

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

        {

        iTargetDeviceTypes->AppendL( aTargetDeviceTypes[i]);

        }

    iDeviceRepository = CUpnpCpbDeviceRepository::NewL(*iTargetDeviceTypes);

    iSaxController = CUpnpContentHandlersController::NewL();

    iDiscoveryAgent = CUpnpCpbDiscoveryAgent::NewL( *iCpbHttpClient );

    iDescriptionAgent =

        CUpnpCpbDescriptionAgent::NewL(

            *this, *iCpbHttpClient, *iDeviceRepository );

    iInitialEventRetry = new( ELeave ) CUpnpCpbInitialEventRetryHandler( *this );

    }

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

// CUpnpControlPoint::ConstructL

// Two-phased constructor

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

//

EXPORT_C void CUpnpControlPoint::ConstructL( const TDesC8& aTargetDeviceType )

    {

    CDesC8ArrayFlat* targetDeviceTypes =

    new (ELeave) CDesC8ArrayFlat( KDTargetDeviceTypesGranularity );

    CleanupStack::PushL( targetDeviceTypes );

    targetDeviceTypes->AppendL( aTargetDeviceType );

    ConstructL( *targetDeviceTypes );

    CleanupStack::PopAndDestroy( targetDeviceTypes );

    }

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

// CUpnpControlPoint::SearchL

// Search intresting Device Types from network

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

//

EXPORT_C void CUpnpControlPoint::SearchL( const TDesC8& aSearchString )

    {

    if( aSearchString.Length() == 0 )

        {

        User::Leave( KErrCorrupt );

        }

    iDiscoveryAgent->SearchL( aSearchString );

    }

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

// CUpnpControlPoint::SendL

// Send an action message.

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

//

EXPORT_C void CUpnpControlPoint::SendL( CUpnpAction* aAction )

    {

    iCpbHttpClient->SendActionL( aAction );

    iActionList.AppendL( aAction );

    }

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

// CUpnpControlPoint::SendL

// Send HTTP message

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

//

EXPORT_C void CUpnpControlPoint::SendL( CUpnpHttpMessage* aHttpMessage )

    {

    iCpbHttpClient->SendFileByPostL(aHttpMessage);

    }

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

// CUpnpControlPoint::SendResponseMessageLD

// Send HTTP message and destroy it (leave safe)

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

//

void CUpnpControlPoint::SendResponseMessageLD( CUpnpHttpMessage* aHttpMessage )

    {

    CleanupStack::PushL( aHttpMessage );

    iCpbHttpClient->SendL( aHttpMessage );

    CleanupStack::PopAndDestroy( aHttpMessage );

    }

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

// CUpnpControlPoint::DeviceList

//

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

//

EXPORT_C const RPointerArray<CUpnpDevice>& CUpnpControlPoint::DeviceList() const

    {

    return iDeviceRepository->DiscoveredDeviceList();

    }

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

// CUpnpControlPoint::SubscribeL

//

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

//

EXPORT_C void CUpnpControlPoint::SubscribeL( CUpnpService* aService )

    {

    LOG_FUNC_NAME;

    if ( !aService )

        {

        return;

        }

    if( FindServiceInfoByService( aService ) )

        {

        return;

        }

    LOGS("CUpnpControlPoint::SubscribeL - Subscribing service");

    CUpnpServiceInfo* serviceInfo = CUpnpServiceInfo::NewLC( this, aService );

    iSubscribedServicesInfos.AppendL( serviceInfo );

    CleanupStack::Pop( serviceInfo );

    iCpbHttpClient->SendSubscribeL( serviceInfo );

    LOGS("CUpnpControlPoint::SubscribeL - end");

    }

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

// CUpnpControlPoint::UnsubscribeL

//

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

//

EXPORT_C void CUpnpControlPoint::UnsubscribeL( const CUpnpService* aService )

    {

    UnsubscribeL( const_cast<CUpnpService*>( aService ) , ETrue );

    }

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

// CUpnpControlPoint::UnsubscribeL

//

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

//

void CUpnpControlPoint::UnsubscribeL( CUpnpService* aService,

    TBool aSendUnsubscribeMessage )

    {

    LOG_FUNC_NAME;

    if ( !aService )

        {

        return;

        }

    CUpnpServiceInfo* subscribedServiceInfo =

            FindServiceInfoByService( aService );

    if ( !subscribedServiceInfo )

        {

        return;

        }

    LOGS("CUpnpControlPoint::UnsubscribeL - Unsubscribing service");

    RemoveFromSubscribedList( subscribedServiceInfo );

    if ( aSendUnsubscribeMessage )

        {

        CleanupStack::PushL( subscribedServiceInfo );

        iCpbHttpClient->SendUnsubscribeL( subscribedServiceInfo );

        CleanupStack::Pop( subscribedServiceInfo );

        }

    delete subscribedServiceInfo;

    LOGS("CUpnpControlPoint::UnsubscribeL - end");

    }

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

// CUpnpControlPoint::ResubscribeL

//

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

//

void CUpnpControlPoint::ResubscribeL( CUpnpServiceInfo* aServiceInfo )

    {

    iCpbHttpClient->SendResubscribeL( aServiceInfo );

    }

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

// CUpnpControlPoint::RemoveFromSubscribedList

//

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

//

void CUpnpControlPoint::RemoveFromSubscribedList(

    CUpnpServiceInfo* aServiceInfoToRemove )

    {

    const TInt idx = iSubscribedServicesInfos.Find( aServiceInfoToRemove );

    if ( KErrNotFound != idx )

        {

        iSubscribedServicesInfos.Remove( idx );

        }

    iSubscribedServicesInfos.GranularCompress();

    }

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

// CUpnpControlPoint::DeviceFoundL

//

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

//

EXPORT_C void CUpnpControlPoint::DeviceFoundL( CUpnpDevice& aDevice )

    {

    iDescriptionAgent->DeviceAliveNotificationL(&aDevice);

    }

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

// CUpnpControlPoint::DeviceLostL

// Callback function - remove device

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

//

EXPORT_C void CUpnpControlPoint::DeviceLostL( CUpnpDevice& aDevice )

    {

    LOG_FUNC_NAME;

    //device from ssdp

    CUpnpDevice* ssdpDevice =

        iDeviceRepository->RemoveIncomingDevice( aDevice.Uuid() );

    if ( ssdpDevice )

        {

        delete ssdpDevice;

        }

    CUpnpDevice* device = NULL;

    device = iDeviceRepository->FindDevice( aDevice.Uuid() );

    if ( !device )

        {

        return;

        }

    if ( aDevice.Expired() )

        {

        device->SetExpired( ETrue );

        if ( !AllDevicesExpired( device ) )

            {

            return;

            }

        }

    // always remove whole device tree

    if ( device->IsEmbeddDevice() )

        {

        CUpnpDevice* rootDevice = iDeviceRepository->FindRoot( device->Uuid() );

        // In case of error when root device is not found during discovery

        if ( rootDevice )

            {

            device = rootDevice;

            }

        }

    RemoveRootDeviceLD( device );

    }

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

// CUpnpControlPoint::AllDevicesExpired

//

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

//

TBool CUpnpControlPoint::AllDevicesExpired( CUpnpDevice* aDevice )

    {

    // notification about expiration of cache-control time of aDevice

    if ( aDevice->IsEmbeddDevice() ) // take root device

        {

        aDevice = iDeviceRepository->FindRoot( aDevice->Uuid() );

        }

    // if root device not expired then return

    if ( !aDevice || !aDevice->Expired() )

        {

        return EFalse;

        }

    RPointerArray<CUpnpDevice> devices;

    aDevice->GetAllDevices( devices ); // take all embedded devices

    for ( TInt k = 0; k < devices.Count(); k++ )

        {

        // if not all embedded devices expired then return

        if ( !devices[k]->Expired() )

            {

            devices.Close();

            return EFalse;

            }

        }

    devices.Close();

    return ETrue;

    }

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

// CUpnpControlPoint::Path

//

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

//

EXPORT_C const TDesC8& CUpnpControlPoint::Path()

    {

    return KPath();

    }

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

// CUpnpControlPoint::MessageReceived

// Callback funtion - HTTP message received

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

//

void CUpnpControlPoint::MessageReceived( CUpnpHttpMessage* aHttpMessage )

    {

    HttpResponseReceived( aHttpMessage );

    }

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

// CUpnpControlPoint::MapHttpError

//

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

//

TInt CUpnpControlPoint::MapHttpError( TInt aError )

    {

    if ( aError >= EHttpBadRequest && aError < EHttpInternalServerError )

        {

        return KErrCouldNotConnect;

        }

    else if ( aError > EHttpInternalServerError )

        {

        return KErrServerBusy;

        }

    else

        {

        return KErrUnknown;

        }

    }

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

// CUpnpControlPoint::CheckEventKey

//

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

//

TInt CUpnpControlPoint::CheckEventKey( const TDesC8& aIncomingSeq,

    TUint32 aExistingSeq )

    {

    const TUint KMaxSeq = 2146583647;

    const TUint KMinSeq = 1;

    TUint IncomingSeq;

    TInt error = KErrNone;

    TLex8 lex(aIncomingSeq);

    lex.Mark();

    error = lex.Val( IncomingSeq );

    //--- check if SEQ is a number

    if ( !error )

        {

        lex.UnGetToMark();

        for ( TInt i(0); i < aIncomingSeq.Length(); i++ )

            {

            TChar character = lex.Get();

            if ( !(character.IsDigit() ) )

                {

                error = KErrGeneral;

                break;

                }

            }

        }

    //--- check SEQ incrementing/wrapping

    if ( !error )

        {

        // when initial event appears, don't check SEQ increment

        if ( (IncomingSeq == 0 ) && (aExistingSeq == 0 ) )

            return KErrNone;

        if ( aExistingSeq < KMaxSeq )

            {

            aExistingSeq++;

            }

        else

            {

            aExistingSeq = KMinSeq;

            }

        // if 'incoming SEQ' == 'incremented existing SEQ' -> OK

        if ( IncomingSeq == aExistingSeq )

            {

            error = KErrNone;

            }

        else

            {

            error = KErrCancel;

            }

        }

    return error;

    }

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

// CUpnpControlPoint::ThrowErrorL

//

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

//

void CUpnpControlPoint::SendErrorResponseL( CUpnpHttpMessage* aHttpMessage,

    THttpStatusCode aCode )

    {

    CUpnpHttpMessage* msg = RUpnpHttpMessageFactory::HttpResponseErrorL(

        aHttpMessage, aCode );

    SendResponseMessageLD( msg );

    }

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