/** @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 <s32mem.h>

#include "upnpmessagehandlersession.h"

#define KLogFile _L("UpnpMessageHandler.txt")

#include "upnpcustomlog.h"

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

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

// CUpnpMessageHandlerSession::CUpnpMessageHandlerSession

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

// might leave.

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

//

CUpnpMessageHandlerSession::CUpnpMessageHandlerSession(

    CUpnpMessageHandler& aMessageHandler, CUpnpMessageHandlerEngine& aEngine ) :

    CSession2(), iMessageHandler(aMessageHandler), iEngine(aEngine),

            iMoreNewDevices(ETrue), iOldId(KErrNotFound), iAddedDevices( 1)

    {

    LOG_FUNC_NAME;

    }

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

// CUpnpMessageHandlerSession::~CUpnpMessageHandlerSession

// Destructor.

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

//

CUpnpMessageHandlerSession::~CUpnpMessageHandlerSession()

    {

    delete[] iAwaitingUpdateDevices;

    delete[] iAwaitingUpdateServices;

    iMessageHandler.RemoveObserver( this );

    iAddedDevices.Reset();

    }

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

// CUpnpMessageHandlerSession::ServiceL

// Handle client requests.

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

//

void CUpnpMessageHandlerSession::ServiceL( const RMessage2& aMessage )

    {

    if ( aMessage.Function() != EStartSsdp && aMessage.Function()

            != ECheckError && !iMessageHandler.IsSsdpStarted() )

        {

        aMessage.Complete( KErrServerTerminated );

        return;

        }

    switch ( aMessage.Function() )

        {

        case EStartSsdp:

            {

            aMessage.Complete( EStartSsdpComplete );

            User::LeaveIfError( EventStartSsdpL() );

            iMessageHandler.SetSsdpStarted( ETrue );

            break;

            }

        case EAddLocalDevice:

            {

            EventAddLocalDeviceL( aMessage );

            aMessage.Complete( EAddLocalDeviceComplete );

            break;

            }

        case ERemoveLocalDevice:

            {

            EventRemoveLocalDeviceL( aMessage, EFalse );

            aMessage.Complete( ERemoveLocalDeviceComplete );

            break;

            }

        case ERemoveSilentLocalDevice:

            {

            LOGS("CUpnpMessageHandlerSession:  case ERemoveSilentLocalDevice");

            EventRemoveLocalDeviceL( aMessage, ETrue );

            aMessage.Complete( ERemoveSilentLocalDeviceComplete );

            LOGS("CUpnpMessageHandlerSession:  case ERemoveSilentLocalDevice passed");

            break;

            }

        case EAddControlPointClient:

            {

            EventAddLocalControlPoint( aMessage );

            aMessage.Complete( EAddControlPointClientComplete );

            break;

            }

        case ERemoveControlPointClient:

            {

            EventRemoveLocalControlPoint( aMessage );

            aMessage.Complete( ERemoveControlPointClientComplete );

            break;

            }

        case EStopFilteringDevice:

            {

            EventStopFilteringDeviceL( aMessage );

            aMessage.Complete( EStopFilteringDeviceComplete );

            break;

            }

        case EGetDeviceListSize:

            {

            CopyMessage( (RMessage2&) aMessage );

            EventGetDeviceListSizeL( aMessage );

            break;

            }

        case EGetDeviceList:

            {

            EventGetDeviceListL( aMessage );

            aMessage.Complete( EGetDeviceListComplete );

            break;

            }

        case ESsdpSearch:

            {

            EventSsdpSearchL( aMessage );

            aMessage.Complete( ESsdpSearchComplete );

            break;

            }

        case EActiveIap:

            {

            EventActiveIapL( aMessage );

            aMessage.Complete( EActiveIapComplete );

            break;

            }

        case ECheckError:

            {

            EventCheckErrorL( aMessage );

            aMessage.Complete( ECheckErrorComplete );

            break;

            }

        case ECancelRequest:

            CompletePendingRequest();

            aMessage.Complete( KErrNone );

            break;

#ifdef RD_UPNP_REMOTE_ACCESS    

            case EAddFilterAddrByIP:

                {

                EventAddFilterAddrByIpL( aMessage );

                aMessage.Complete( KErrNone );

                break;

                }

            case EAddFilterAddrByHostname:

                {

                EventAddFilterAddrByHostnameL( aMessage );

                break;

                }

            case ERemoveFilterAddrByIP:

                {

                EventRemoveFilterAddrByIpL( aMessage );

                aMessage.Complete( KErrNone );

                break;

                }

            case ERemoveFilterAddrByHostname:

                {

                EventRemoveFilterAddrByHostnameL( aMessage );

                break;

                }

            case ERemoveAllIPsAddresses:

                {

                EventRemoveAllIPsAddressesL( aMessage );

                aMessage.Complete( KErrNone );

                break;

                }

            case EIsIPAddressAllowed:

                {

                aMessage.Complete( EventIsIPAddressAllowedL( aMessage ) );

                break;

                }

            case ESubscribeIPListChanges:

                {

                EventSubscriveIPListChanges( const_cast<RMessage2&>( aMessage ) );

                break;

                }

            case EGetIPFilterList:

                {

                EventGetIPFilterListL( aMessage );

                break;

                }

            case ECancelIPLIstSubsctiption:

                {

                EventCancelIPListSubscription( aMessage );

                aMessage.Complete( KErrNone );

                break;

                }

#endif    

        default:

            PanicClient( aMessage, EMessageHandlerBadRequest );

            break;

        }

    }

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

// CUpnpMessageHandlerSession::PanicClient

// Panic client.

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

//

void CUpnpMessageHandlerSession::PanicClient( const RMessage2 &aMessage,

    TInt aPanic ) const

    {

    LOG_FUNC_NAME;

    iMessageHandler.PanicClient( aMessage, aPanic );

    }

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

// CUpnpMessageHandlerSession::NewL

// Two-phased constructor.

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

//

CUpnpMessageHandlerSession* CUpnpMessageHandlerSession::NewL(

    CUpnpMessageHandler& aServer, CUpnpMessageHandlerEngine& aEngine )

    {

    CUpnpMessageHandlerSession* self = CUpnpMessageHandlerSession::NewLC(

        aServer, aEngine );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpMessageHandlerSession::NewLC

// Two-phased constructor.

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

//

CUpnpMessageHandlerSession* CUpnpMessageHandlerSession::NewLC(

    CUpnpMessageHandler& aServer, CUpnpMessageHandlerEngine& aEngine )

    {

    CUpnpMessageHandlerSession* self = new (ELeave) CUpnpMessageHandlerSession(

            aServer, aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CUpnpMessageHandlerSession::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpMessageHandlerSession::ConstructL()

    {

    //Add session to MessageHandlers count and to the ObserverList

    iMessageHandler.AddObserverL( this );

    }

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

// CUpnpMessageHandlerSession::EventAddLocalDeviceL

// Add local device.

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

//

void CUpnpMessageHandlerSession::EventAddLocalDeviceL(

    const RMessage2 &aMessage )

    {

    LOG_FUNC_NAME;

    TUpnpAddLocalDevice device;

    TPtr8 ptr( reinterpret_cast<TUint8*>(&device), sizeof(device ),

        sizeof(device ));

    LOGS("\t MessageHandler, added a local device");

    aMessage.ReadL( 0, ptr );

    HBufC8* buffer = HBufC8::NewLC( device.iBufferLength );

    buffer->Des().SetLength( 0 );

    TPtr8 bufPtr = buffer->Des();

    aMessage.ReadL( 1, bufPtr );

    LOGS("Session::Add");

    iDeviceListSizeRequested = EFalse;

    TPtrC8 uuid = buffer->Left( device.iUuidLength );

    iAddedDevices.AppendL( uuid );

    iEngine.AddLocalDeviceL( device, *buffer );

    CleanupStack::PopAndDestroy( buffer );

    }

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

// CUpnpMessageHandlerSession::EventAddLocalControlPointL

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

//

void CUpnpMessageHandlerSession::EventAddLocalControlPoint( const RMessage2 &/*aMessage*/)

    {

    iEngine.AddLocalControlPoint();

    }

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

// CUpnpMessageHandlerEngine::RemoveLocalControlPointL

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

//

void CUpnpMessageHandlerSession::EventRemoveLocalControlPoint(

    const RMessage2 &/*aMessage*/)

    {

    iEngine.RemoveLocalControlPoint();

    }

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

// CUpnpMessageHandlerEngine::EventStopFilteringDeviceL

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

//

void CUpnpMessageHandlerSession::EventStopFilteringDeviceL(

    const RMessage2& aMessage )

    {

    TInt lenght = aMessage.GetDesLength( 0 );

    HBufC8* uuids = HBufC8::NewLC( lenght );

    TPtr8 uuidsPtr = uuids->Des();

    aMessage.ReadL( 0, uuidsPtr );

    TLex8 uuidLex(*uuids);

    uuidLex.Mark();

    for ( ;; )

        {

        if ( uuidLex.Peek() == ';' )

            {

            TPtrC8 uidPtr = uuidLex.MarkedToken();

            iEngine.StopFilteringDeviceL( uidPtr );

            uuidLex.Inc();

            uuidLex.Mark();

            }

        else if ( uuidLex.Eos() )

            {

            TPtrC8 uidPtr = uuidLex.MarkedToken();

            if ( uidPtr.Length() )

                {

                iEngine.StopFilteringDeviceL( uidPtr );

                }

            break;

            }

        else

            {

            uuidLex.Inc();

            }

        }

    CleanupStack::PopAndDestroy( uuids );

    }

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

// CUpnpMessageHandlerSession::EventGetDeviceListSizeL

// Get device list.

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

//

void CUpnpMessageHandlerSession::EventGetDeviceListSizeL(

    const RMessage2& aMessage )

    {

    LOGS( "CUpnpMessageHandlerSession::EventGetDeviceListSizeL");

    TPtr8 ptr( reinterpret_cast<TUint8*>(&iSize), sizeof(iSize ),

        sizeof(iSize ));

    iDeviceListSizeMessage.ReadL( 0, ptr );

    if ( iSize.iUpdateId >= iOldId && iOldId != KErrNotFound )

        {

        LOGS( "CUpnpMessageHandlerSession::GetDeviceListSize OLD=NEW");

        iDeviceListSizeRequested = ETrue;

        }

    if ( iSize.iUpdateId == 0 )

        {

        iMoreNewDevices = ETrue;

        }

    if ( !iDeviceListSizeRequested )

        {

        LOGS( "CUpnpMessageHandlerSession::GetDeviceListSize OLD>NEW");

        iDeviceListSizeRequested = ETrue;

        LOGS( "CUpnpMessageHandlerSession::New Devices Found");

        if ( iMoreNewDevices && iDeviceListSizeMessage.Function()

                == EGetDeviceListSize )

            {

            delete[] iAwaitingUpdateDevices;

            iAwaitingUpdateDevices = NULL;

            delete[] iAwaitingUpdateServices;

            iAwaitingUpdateServices = NULL;

            iEngine.DeviceLibrary()->GetUpdate( iSize.iUpdateId, iAwaitingUpdateDevices,

                iAwaitingUpdateServices, iSize.iDeviceCount,

                iSize.iServiceCount );

            if ( iSize.iDeviceCount > 0 )

                {

                iOldId = iSize.iUpdateId;

                iDeviceListSizeMessage.WriteL( 0, ptr );

                aMessage.Complete( EGetDeviceListSizeComplete );

                iDeviceListSizeRequested = EFalse;

                }

            }

        iMoreNewDevices = EFalse;

        }

    }

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

// CUpnpMessageHandlerSession::EventGetDeviceListL

// Get device list.

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

//

void CUpnpMessageHandlerSession::EventGetDeviceListL(

    const RMessage2 &aMessage )

    {

    LOGS( "CUpnpMessageHandlerSession::EventGetDeviceListL");

    if ( !iDeviceListSizeRequested )

        {

        TPtr8 devPtr( reinterpret_cast<TUint8*>(iAwaitingUpdateDevices),

            sizeof(TUpnpDevice)*iSize.iDeviceCount, sizeof(TUpnpDevice)

                    *iSize.iDeviceCount);

        TPtr8 servPtr( reinterpret_cast<TUint8*>(iAwaitingUpdateServices),

            sizeof(TUpnpService)*iSize.iServiceCount, sizeof(TUpnpService)

                    *iSize.iServiceCount);

        aMessage.WriteL( 0, devPtr );

        aMessage.WriteL( 1, servPtr );

        delete[] iAwaitingUpdateDevices;

        iAwaitingUpdateDevices = NULL;

        delete[] iAwaitingUpdateServices;

        iAwaitingUpdateServices = NULL;

        }

    }

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

// CUpnpMessageHandlerSession::EventSsdpSearchL

// SSDP search.

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

//

void CUpnpMessageHandlerSession::EventSsdpSearchL( const RMessage2 &aMessage )

    {

    LOGS( "CUpnpMessageHandlerSession::EventSsdpSearchL");

    // getting search string from client.

    HBufC8* search= NULL;

    HBufC8* mx= NULL;

    TInt len = aMessage.GetDesLength( 0 );

    TInt len2 = aMessage.GetDesLength( 1 );

    if ( len > 0 )

        {

        search = HBufC8::NewLC( len );

        search->Des().Zero();

        mx = HBufC8::NewLC( len2 );

        mx->Des().Zero();

        TPtr8 searchPtr = search->Des();

        aMessage.ReadL( 0, searchPtr );

        if ( len2 )

            {

            TPtr8 mxPtr = mx->Des();

            aMessage.ReadL( 1, mxPtr );

            }

        iDeviceListSizeRequested = EFalse;

        iEngine.SsdpSearchL( *search, *mx );

        CleanupStack::PopAndDestroy( mx );

        CleanupStack::PopAndDestroy( search );

        }

    else

        {

        LOGS( "CUpnpMessageHandlerSession::EventSsdpSearchL");

        }

    }

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

// CUpnpMessageHandlerSession::EventActiveIapL

// Activate IAP.

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

//

void CUpnpMessageHandlerSession::EventActiveIapL( const RMessage2 &aMessage ) const

    {

    LOGS( "CUpnpMessageHandlerSession::EventActiveIapL");

    TInt activeIap = iEngine.ActiveIap();

    TPtr8 ptr( reinterpret_cast<TUint8*>(&activeIap), sizeof(TInt),

        sizeof(TInt));

    aMessage.WriteL( 0, ptr );

    }

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

// CUpnpMessageHandlerSession::EventRemoveLocalDeviceL

// Remove local device.

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

//

void CUpnpMessageHandlerSession::EventRemoveLocalDeviceL(

    const RMessage2 &aMessage, TBool aSilent )

    {

    LOGS( "CUpnpMessageHandlerSession::EventRemoveLocalDeviceL");

    TBuf8<KMaxUuidLength> uuid;

    aMessage.ReadL( 0, uuid );

    TInt pos( 0);

    TInt error( 0);

    error = iAddedDevices.Find( uuid, pos );

    if ( error == KErrNone )

        {

        iAddedDevices.Delete( pos );