/** @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:  Message handler engine

 *

 */

// INCLUDE FILES

#include <commdb.h>

#include <commdbconnpref.h>

#include "upnpcons.h"

#include "upnpmessagehandlerengine.h"

#include "upnpssdpserver.h"

#ifdef RD_UPNP_REMOTE_ACCESS

#include "upnpipfiltering.h"

#include "upnpipfilteringdnsquery.h"

#endif

#include "upnpssdphandlerup.h"

#include "upnpssdphandlerbase.h"

#include "upnpssdphandlerdown.h"

#include "upnpconnectionmanagerproxy.h"

#define KLogFile _L("UpnpMessageHandler.txt")

#include "upnpcustomlog.h"

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

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

// CUpnpMessageHandlerEngine::NewLC

// Two-phased constructor.

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

//

CUpnpMessageHandlerEngine* CUpnpMessageHandlerEngine::NewL(

    MMessageHandlerEngineObserver& aObserver )

    {

    // call the default constructor

    CUpnpMessageHandlerEngine* self = new (ELeave) CUpnpMessageHandlerEngine( aObserver );

    // call the default L constructor when in cleanup stack

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    // returns new instance

    return self;

    }

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

// CUpnpMessageHandlerEngine::CUpnpMessageHandlerEngine

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

// might leave.

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

//

CUpnpMessageHandlerEngine::CUpnpMessageHandlerEngine(

    MMessageHandlerEngineObserver& aObserver ) :

    iObserver(aObserver)

    {

    }

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

// CUpnpMessageHandlerEngine::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpMessageHandlerEngine::ConstructL()

    {

    LOG_FUNC_NAME;

    // create a socket server connection

    User::LeaveIfError( iSocketServ.Connect() );

    CreateSessionIdPropertyL();

    iSsdpHandlerUp = CUpnpSsdpHandlerUp::NewL( *this );

    iSsdpHandlerDown = CUpnpSsdpHandlerDown::NewL( *this );

    iCurrentSsdpHandler = iSsdpHandlerUp;

    // device library stores information about remote and local devices

    iDeviceLibrary = CUpnpDeviceLibrary::NewL( *this, 0 );

    iConnectionManagerProxy = CUpnpConnectionManagerProxy::NewL( iSocketServ );

    iConnectionManagerProxy->SubscribeForNetworkEventsL( this );

    }

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

// CUpnpMessageHandlerEngine::CreateSessionIdPropertyL

// Create session id property and signal id semaphore

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

//

void CUpnpMessageHandlerEngine::CreateSessionIdPropertyL()

    {

    // create RProperty used as session id counter

    TInt err = RProperty::Define( KUPnPUtilsCat, EUPnPUtilsCounter,

        RProperty::EInt );

    if ( err != KErrAlreadyExists )

        {

        User::LeaveIfError( err );

        }

    // there are four global widely-used semaphores in the system

    // first two semaphores are for getting a running session id

    // first semaphore is an access semaphore

    // if it's signaled, we can have access to id semaphore

    // id semaphore holds the current session id

    //

    // the second place where these semaphores are used is CUpnpHttpMessage::NewSessionIdL()

    // 

    // basically, we want to tell the CUpnpHttpMessage class that the

    // EUPnPUtilsCounter RProperty is defined and ready to use

    TInt result =

            iAccessSemaphore.OpenGlobal( KSessionIdAccessSemaphoreName() );

    if ( result == KErrNotFound )

        {

        result = iAccessSemaphore.CreateGlobal(

            KSessionIdAccessSemaphoreName(), 0 );

        if ( result != KErrNone )

            {

            LOGS( "MESSAGEHANDLER *** Session id access semaphore creation failed" );

            }

        }

    else if ( result != KErrNone )

        {

        LOGS( "MESSAGEHANDLER *** Session id access semaphore creation failed" );

        }

    User::LeaveIfError( result );

    iAccessSemaphore.Signal();

    }

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

// CUpnpMessageHandlerEngine::~CUpnpMessageHandlerEngine

// Destructor.

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

//

CUpnpMessageHandlerEngine::~CUpnpMessageHandlerEngine()

    {

    __ASSERT_DEBUG( iCurrentSsdpHandler == iSsdpHandlerUp

            || iCurrentSsdpHandler == iSsdpHandlerDown,

            User::Panic( KMessageHandler, EMessageHandlerBadState ) );

    delete iDeviceLibrary;

    delete iSsdpHandlerUp;

    delete iSsdpHandlerDown;

    delete iConnectionManagerProxy;

#ifdef RD_UPNP_REMOTE_ACCESS    

    /*************   IPFiltering    *****************/

    delete iIPFilterRepository;

    /************************************************/

#endif

    // close socket server connection

    iSocketServ.Close();

    iAccessSemaphore.Close();

    }

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

// CUpnpMessageHandlerEngine::AdvertiseDeviceL

// Advertise device

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

//

void CUpnpMessageHandlerEngine::AdvertiseDeviceL( TInt aLive,

    CUpnpDeviceLibraryElement& aElement )

    {

    iCurrentSsdpHandler->AdvertiseDeviceL( aLive, aElement );

    }

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

// CUpnpMessageHandlerEngine::DeviceListChangedL

// Inform observer that device list changed.

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

//

void CUpnpMessageHandlerEngine::DeviceListChangedL()

    {

    LOG_FUNC_NAME;

    //Check waiting

    if ( iCurrentSsdpHandler == iSsdpHandlerUp )

        {        

        iObserver.DeviceListUpdateL();

        }

    }

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

// CUpnpMessageHandlerEngine::DeviceList

// Get device list.

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

//

RPointerArray<CUpnpDeviceLibraryElement>& CUpnpMessageHandlerEngine::DeviceList()

    {

    LOG_FUNC_NAME;

    // return device list

    return iDeviceLibrary->DeviceList();

    }

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

// CUpnpMessageHandlerEngine::AddLocalDeviceL

// Add local device to device library.

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

//

TInt CUpnpMessageHandlerEngine::AddLocalDeviceL(

    TUpnpAddLocalDevice &aDevice, TDesC8& aBuffer )

    {

    LOG_FUNC_NAME;

    iDeviceLibrary->AddInfoL( &aDevice, aBuffer, iConnectionManagerProxy->LocalAddress() );

    return KErrNone;

    }

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

// CUpnpMessageHandlerEngine::AddLocalControlPointL

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

//

TInt CUpnpMessageHandlerEngine::AddLocalControlPoint()

    {

    return iSsdpHandlerUp->AddLocalControlPoint();

    }

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

// CUpnpMessageHandlerEngine::RemoveLocalControlPointL

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

//

TInt CUpnpMessageHandlerEngine::RemoveLocalControlPoint()

    {

    return iSsdpHandlerUp->RemoveLocalControlPoint();

    }

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

// CUpnpMessageHandlerEngine::StopFilteringDeviceL

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

//

void CUpnpMessageHandlerEngine::StopFilteringDeviceL( const TDesC8& aUuid )

    {

    iDeviceLibrary->StopFilteringDeviceL( aUuid );

    }

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

// CUpnpMessageHandlerEngine::DeviceLibrary

// Get device library.

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

//

CUpnpDeviceLibrary* CUpnpMessageHandlerEngine::DeviceLibrary()

    {

    LOG_FUNC_NAME;

    return iDeviceLibrary;

    }

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

// CUpnpMessageHandlerEngine::SsdpEventL

// Callback function for received ssdp messages.

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

//

void CUpnpMessageHandlerEngine::SsdpEventL( CUpnpSsdpMessage *aMessage )

    {

    LOG_FUNC_NAME;

    // ignore messages with M-SEARCH there are serverd by SSDP Server internally

    if ( aMessage->IsSsdpMSearch() )

        {

        return;

        }

    // forward message to device library

    iDeviceLibrary->AddInfoL( aMessage );

    }

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

// CUpnpMessageHandlerEngine::SsdpSearchL

// Do ssdp searches.

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

//

void CUpnpMessageHandlerEngine::SsdpSearchL( TDesC8& aSearchString,

    TDesC8& aMX )

    {

    LOG_FUNC_NAME;

    iCurrentSsdpHandler->SsdpSearchL( aSearchString, aMX );

    }

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

// CUpnpMessageHandlerEngine::ActiveIap

// Returns the iap id (which is got in function above).

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

//

TInt CUpnpMessageHandlerEngine::ActiveIap() const

    {

    LOG_FUNC_NAME;

    return iConnectionManagerProxy->ActiveIap();

    }

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

// CUpnpMessageHandlerEngine::RemoveLocalDevice

// Removes local device from device library.

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

//

void CUpnpMessageHandlerEngine::RemoveLocalDeviceL( const TDesC8 &aUuid,

    TBool aSilent )

    {

    LOG_FUNC_NAME;

    // forward the request to device library

    if ( iCurrentSsdpHandler == iSsdpHandlerUp)

        {

        if ( !aSilent )

            {

            iDeviceLibrary->RemoveL( aUuid );

            }

        else

            {

            iDeviceLibrary->RemoveSilentL( aUuid );

            }

        }

    LOGS( "CUpnpMessageHandlerEngine::RemoveLocalDevice passed");

    }

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

// CUpnpMessageHandlerEngine::StartSsdp

// Start SSPD.

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

//

TInt CUpnpMessageHandlerEngine::StartSsdpL()

    {

    LOG_FUNC_NAME;

    if ( !iCurrentSsdpHandler->IsStarted() )

        {

        LOGS( "MESSAGEHANDLER *** Connecting to same access point...");        

        iCurrentSsdpHandler->StartL( iSocketServ );

#ifdef RD_UPNP_REMOTE_ACCESS    

        /**********IPFiltering*******************/

        iIPFilterRepository = CUpnpIPFiltering::NewL( iSocketServ,

                ActiveIap(),

                iObserver );

        /****************************************/

#endif

        return KErrNone;

        }

    else

        {

        // Ensure all two servers are started

        iCurrentSsdpHandler->StartL( iSocketServ );

        return KErrNone;

        }

    }

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

// CUpnpMessageHandlerEngine::InterfaceDown

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

//

void CUpnpMessageHandlerEngine::InterfaceDown()

    {

    LOG_FUNC_NAME;

    iSsdpHandlerUp->Stop();

    iCurrentSsdpHandler = iSsdpHandlerDown;

    }

#ifdef RD_UPNP_REMOTE_ACCESS

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

// CUpnpServiceInfo::AddAddressL

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

//

void CUpnpMessageHandlerEngine::AddAddressL( const TInetAddr& aAddress )

    {

    User::LeaveIfError( iIPFilterRepository->AddAddressL( aAddress ) );

    iObserver.IPListChange();

    }

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

// CUpnpServiceInfo::AddAddressL

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

//

void CUpnpMessageHandlerEngine::AddAddressL( const RMessage2& aMessage,

        const TDesC8& aRemoteName )

    {

    CUpnpIPFilteringDNSQuery* query = CUpnpIPFilteringDNSQuery::NewLC( aMessage,

            aRemoteName );

    iIPFilterRepository->AddAddressL( query );

    CleanupStack::Pop( query );

    }

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

// CUpnpServiceInfo::RemoveAddressL

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

//

void CUpnpMessageHandlerEngine::RemoveAddressL( const TInetAddr& aAddress )

    {

    if ( iIPFilterRepository->RemoveAddressL( aAddress ) >=0 )

        {

        iObserver.IPListChange();

        }

    }

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

// CUpnpServiceInfo::RemoveAddressL

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

//

void CUpnpMessageHandlerEngine::RemoveAddressL( const RMessage2& aMessage,

        const TDesC8& aRemoteName )

    {

    CUpnpIPFilteringDNSQuery* query = CUpnpIPFilteringDNSQuery::NewLC( aMessage,

            aRemoteName );

    iIPFilterRepository->RemoveAddressL( query );

    CleanupStack::Pop( query );

    }

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

// CUpnpServiceInfo::RemoveAll

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

//

void CUpnpMessageHandlerEngine::RemoveAll()

    {

    if ( iIPFilterRepository->RemoveAll() >=0 )

        {

        iObserver.IPListChange();

        }

    }

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

// CUpnpServiceInfo::IsIPAllowed

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

//

TBool CUpnpMessageHandlerEngine::IsIPAllowed( const TInetAddr& aAddress ) const

    {

    return iIPFilterRepository->IsAllowed( aAddress );

    }

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

// CUpnpServiceInfo::IPFilteringStatus

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

//

void CUpnpMessageHandlerEngine::IPFilteringStatus( TInt& aListSize ) const

    {

    aListSize = iIPFilterRepository->GetIPFilterList().Size();

    }

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

// CUpnpServiceInfo::GetIPFilterList

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

//

const TDesC8& CUpnpMessageHandlerEngine::GetIPFilterList()

    {

    return iIPFilterRepository->GetIPFilterList();

    }

#endif

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

// CUpnpMessageHandlerEngine::NetworkEventWlanLost

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

//

void CUpnpMessageHandlerEngine::NetworkEvent( CUpnpNetworkEventBase* aEvent )

    {

    LOG_FUNC_NAME;

    if ( aEvent->SubscriberError() < KErrNone && aEvent->Type() == EUnknownEvent )

        {

        LOGS( "MESSAGEHANDLER *** NetworkEvent error" );

        return;

        }

    switch ( aEvent->Type() )

        {

        case EWlanLostEvent:

            {

            InterfaceDown();

            TDblQueIter<CSession2>& sessionIter = iObserver.Sessions();

            sessionIter.SetToFirst();

            CUpnpMessageHandlerSession *session = 

                    reinterpret_cast<CUpnpMessageHandlerSession*>( sessionIter++ );

            while ( session )

                {

                session->CancelPendingRequests();

                session = reinterpret_cast<CUpnpMessageHandlerSession*>( sessionIter++ );

                }

            }

            break;

        case EAddressChangeEvent:

            {

            CUpnpNetworkEventAddressChange* networkEvent = 

                                static_cast< CUpnpNetworkEventAddressChange* >( aEvent );

            TInetAddr addr = networkEvent->Address();

            TRAPD( error, iCurrentSsdpHandler->AddressChangeL( addr ) );

            TRAP( error, iDeviceLibrary->RemoveAllDevicesL() );

            if ( error )

                {

                // only case this should happen

                ASSERT( error == KErrNoMemory );

                }

            }

            break;

        }

    }

// End of File