/** @file

* Copyright (c) 2005-2008 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:  CUpnpUdpServer

*

*/

// INCLUDE FILES

#include <in_iface.h>

#include <e32math.h>

#include <commdb.h>

#include "upnpcons.h"

#include "upnpudpsendrequest.h"

#include "upnpudpserver.h"

#define KLogFile _L("upnpudpserver.txt")

#include "upnpcustomlog.h"

#include "upnpstring.h"

#include "upnplist.h"

#include "upnpconnectionmanagerproxy.h"

// CONSTANTS

const TUint32 KUdpMessageSize = 2048;

const TInt KTTLValue = 4;

const TInt KMicrosecond = 1000000;

const TInt KMXMaxValue = 120;

const TInt KInetAddrPrefixMatchLen = 16;

// ============================= LOCAL FUNCTIONS ===============================

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

// CleanupArray

// Used by TCleanupItem to clean a RPointerArray<TPtrC>

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

//

void CleanupArray( TAny* aArray )

    {

    ( reinterpret_cast<RPointerArray<TPtrC8>*>( aArray ) )->ResetAndDestroy();

    }

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

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

// CUpnpUdpServer::CUpnpUdpServer

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

// might leave.

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

//

CUpnpUdpServer::CUpnpUdpServer( RSocketServ* aSocketServ,

                        MUpnpUdpServerObserver* aObserver,

                        TInt aListeningPort )

    : CActive( EPriorityHigh ),

      iMulticastFlags( 0 ),

      iMessagePtr( NULL, 0,0 ),

      iIsStarted( EFalse )

    {

    LOGS( "SSDP *** CUpnpUdpServer::CUpnpUdpServer");

    CActiveScheduler::Add( this );

    iSocketServ = aSocketServ;

    iObserver = aObserver;

    iServerPort = aListeningPort;

    iRandomSeed = KErrNone;

    }

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

// CUpnpUdpServer::UdpConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpUdpServer::UdpConstructL()

    {

    iSendMessage = NULL;

    iPendingTimerMessages = new (ELeave) CArrayPtrSeg<CUpnpSsdpMessage>( 1 );

    // Create local timer

    User::LeaveIfError( iSendTimer.CreateLocal() );

    iConnectionManagerProxy = CUpnpConnectionManagerProxy::NewL( *iSocketServ );

    TInt error = iConnectionManagerProxy->EnsureStart();

    if ( error )

        {

        LOGS1( "CUpnpTcpServer::ListenL *** Error in attaching RConnection: error: %d",

            error );

        // Nothing else to do but leave, connection is not possible and

        // can't access network

        User::LeaveIfError( error );

        }

    iActiveIap = iConnectionManagerProxy->ActiveIap();

    iLocalInterfaceAddress = iConnectionManagerProxy->LocalAddress();

    RefreshLocalAddressInfo();

    }

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

// CUpnpUdpServer::~CUpnpUdpServer()

// Destructor.

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

//

CUpnpUdpServer::~CUpnpUdpServer()

    {

    LOGS( "SSDP *** CUpnpUdpServer::~CUpnpUdpServer");

    Cancel();

    Close();

    iSendTimer.Close();

    iSendRequestList.ResetAndDestroy();

    iSendRequestList.Close();

    delete iSendMessage;

    delete iMessage;

    if( iPendingTimerMessages )

        {

        // Go through the messages and cancel timers

        for(TInt i=0; i< iPendingTimerMessages->Count(); i++)

            {

            CUpnpSsdpMessage* arrayMsg = iPendingTimerMessages->At( i );

            if( arrayMsg )

                {

                // Cancel the timer in the message

                arrayMsg->CancelMessageTimeout();

                }

            }

        // Destroy the whole message array

        iPendingTimerMessages->ResetAndDestroy();

        delete iPendingTimerMessages;

        iPendingTimerMessages = NULL;

        }

    // close network connection

    delete iConnectionManagerProxy;

    }

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

// CUpnpUdpServer::JoinMulticastGroupL

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

//

void CUpnpUdpServer::JoinMulticastGroupL()

    {

    TIp6Mreq mreq;

    // the ipv4 multicast address that should use

    TInetAddr addr;

    addr.SetAddress( KDefaultMulticastAddress );

    addr.SetFamily( KAfInet );

    addr.ConvertToV4Mapped();

    mreq.iAddr = addr.Ip6Address();

    mreq.iInterface = 0;

    TPckgBuf< TIp6Mreq > opt( mreq );

    LOGS( "SSDP CUpnpUdpServer::JoinMulticastGroupL" );

    User::LeaveIfError( iSocket.SetOpt( KSoIp6JoinGroup, KSolInetIp, opt ) );

    }

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

// CUpnpUdpServer::ApplyMulticastSocketSettingsL

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

//

void CUpnpUdpServer::ApplyMulticastSocketSettingsL()

    {

    LOGS( "SSDP CUpnpUdpServer::ApplyMulticastSocketSettingsL" );

    User::LeaveIfError( iSocket.SetOpt( KSoIp6MulticastLoop, KProtocolInetIp, 0 ) );

    User::LeaveIfError( iSocket.SetOpt( KSoReuseAddr, KProtocolInetIp, 1 ) );

    JoinMulticastGroupL();

    }

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

// CUpnpUdpServer::ApplyCommonSocketSettingsL

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

//

void CUpnpUdpServer::ApplyCommonSocketSettingsL()

    {

    LOGS( "SSDP CUpnpUdpServer::ApplyCommonSocketSettingsL Socket TTL" );

    User::LeaveIfError( iSocket.SetOpt( KSoIpTTL, KSolInetIp, KTTLValue ) );

    User::LeaveIfError( iSocket.SetOpt( KSoIp6MulticastHops, KSolInetIp,

                                        KTTLValue ) );

    }

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

// CUpnpUdpServer::OpenL

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

//

void CUpnpUdpServer::OpenL( )

    {

    if ( !IsStarted() )

        {

        TRAPD( error, OpenSocketAndStartReceiveL() )

        if ( error )

            {

            LOGS1( "SSDP CUpnpUdpServer::OpenL error: %d", error );

            Close();

            User::Leave( error );

            }

        else

            {

            iIsStarted = ETrue;

            }

        }

    }

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

// CUpnpUdpServer::OpenSocketAndStartReceiveL

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

//

void CUpnpUdpServer::OpenSocketAndStartReceiveL( )

    {

    LOGS( "SSDP CUpnpUdpServer::OpenSocketAndStartReceiveL");

    TInt error = iSocket.Open( *iSocketServ, KAfInet,

        KSockDatagram, KProtocolInetUdp, iConnectionManagerProxy->ConnectionL() );

    User::LeaveIfError( error );

    User::LeaveIfError( iSocket.SetLocalPort( iServerPort ) );

    // for multicast start

    if ( KDefaultMulticastPort == iServerPort )

        {

        ApplyMulticastSocketSettingsL();

        }

    ApplyCommonSocketSettingsL();

    TInetAddr bindAddr;

    error = iSocket.Bind( bindAddr ) ;

    if( KErrNone != error && KErrAlreadyExists != error )

        {

        LOGS( "SSDP CUpnpUdpServer::OpenSocketAnd.. bind error: %d");

        User::Leave( error );

        }

    ReceiveL();

    }

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

// CUpnpUdpServer::IsStarted

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

//

TBool CUpnpUdpServer::IsStarted()

    {

    return iIsStarted;

    }

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

// CUpnpUdpServer::SendL

// Send a message.

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

//

void CUpnpUdpServer::SendL( TDesC8& aBuffer, TInetAddr& anAddr )

    {

    LOGS( "SSDP *** CUpnpUdpServer::SendL");

    if ( !IsStarted() )

        {

        return;

        }

    if ( IsActive() && ( iState == ESendingTimer || iState == ESendDone ) )

        {

        CUpnpUdpSendRequest* req = CUpnpUdpSendRequest::NewL( aBuffer, anAddr );

        CleanupStack::PushL( req );

        iSendRequestList.AppendL( req );

        CleanupStack::Pop( req );

        }

    else

        {

        Cancel();

        delete iSendMessage;

        iSendMessage = NULL;

        iSendMessage = aBuffer.AllocL();

        iSenderAddress = anAddr;

        iSenderAddress.SetFamily( KAfInet );

        iSenderAddress.ConvertToV4Mapped();

        iSocket.SendTo( *iSendMessage,

                        iSenderAddress,

                        iMulticastFlags,

                        iStatus );

        iState = ESendingTimer; // in this state when RunL will be called after sending

                                // message successfuly, the delay timer will start

        SetActive();

        }

    }

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

// CUpnpUdpServer::SendDoneL

// Sending is done.

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

//

void CUpnpUdpServer::SendDoneL()

    {

    LOGS( "SSDP *** CUpnpUdpServer::SendDoneL");

    delete iSendMessage;

    iSendMessage = NULL;

    if ( iSendRequestList.Count() > 0 )

        {

        CUpnpUdpSendRequest* request = iSendRequestList[0];

        iSendRequestList.Remove(0);

        iSendRequestList.Compress();

        CleanupStack::PushL( request );

        SendL( *(request->iBuffer), request->iAddr );

        CleanupStack::PopAndDestroy( request );

        }

    else

        {

        ReceiveL();

        }

    }

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

// CUpnpUdpServer::ReceiveL

// Receive message.

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

//

void CUpnpUdpServer::ReceiveL()

    {

    LOGS( "SSDP *** CUpnpUdpServer::ReceiveL");

    if ( !IsActive() )

        {

        // If iMessage is not yet created, do it now.

        // This pointer will be used until SSDP server is closed down.

        if ( !iMessage )

            {

            iMessage = HBufC8::NewL( KUdpMessageSize );

            }

        // Set data length to zero for the next RecvFrom

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

        iMessagePtr.Set( (unsigned char*) iMessage->Ptr(), 0, KUdpMessageSize );

        iClientAddr.SetPort( iServerPort );

        iSocket.RecvFrom( iMessagePtr, iClientAddr, iMulticastFlags, iStatus );

        SetActive();

        iState = EReceiving;

        }

    }

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

// CUpnpUdpServer::RunL

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

//

void CUpnpUdpServer::RunL()

    {

    if ( iStatus.Int() != KErrNone )

        {

        LOGS1( "SSDP *** CUpnpUdpServer::RunL - UDPServer error, error code: %d",

            iStatus.Int() );

        if ( iStatus.Int() != KErrCancel )

            {

            ReceiveL();

            }

        else

            {

            RestartOrContinueSendProcessingL();

            }

        }

    else

        {

        switch ( iState )

            {

            case ESendingTimer:                                // Introduce delay between sending messages to prevent from

                // Introduce delay between sending messages to prevent from

                iSendTimer.Cancel();               

                iSendTimer.After( iStatus, KSendingDelay ); // SSDP notification storm.

                iState = ESendDone;

                SetActive();

                break;

            case EReceiving:

                {

                TUint temp = iClientAddr.Address();

                TUint port = iClientAddr.Port();

                TInetAddr addr = TInetAddr( temp, port );

                addr.SetFamily( KAfInet );

#ifdef _DEBUG

                TBuf8<KAddressLength> address;

                CUpnpHttpMessage::AddrOutput(addr, address);

                TBuf<KMaxName> logBuf;

                    logBuf.Copy( address.Left( logBuf.MaxLength() ) );

                LOGS1( "SSDP *** CUpnpUdpServer::RunL - Received buffer from: %S",

                    &logBuf );

#endif //_DEBUG

                CUpnpSsdpMessage* msg = NULL;

                TRAPD( err, msg = CUpnpSsdpMessage::NewL(

                    (TDesC8&) iMessagePtr, addr ) );

                if ( err )

                    {

                    delete msg;

                    msg = NULL;

                    LOGS( "SSDP *** CUpnpUdpServer::RunL - Ssdp message parse failed. Ingoring message.");

                    RestartOrContinueProcessingL();

                    return;

                    }

                CleanupStack::PushL(msg);

                // check that given message is valid.

                TInt error = ValidateSsdpMessageL( msg );

                if( error == KErrNone )

                    {

                    // no error, message is put to receive queue, and it gets

                    // handled when the timer expires.

                    // KErrNone used for constant, because it always remains

                    // the same.

                    if( msg->IsSsdpMSearch() )

                        {

                        CleanupStack::Pop( msg );

                        AddPendingTimerMessageL( msg );

                        // no delete, message in array

                        msg = NULL;

                        }

                    else

                        {

                        //checks wether the Source IP is in same network i.e. auto-IP(169.254.X.X) or non-auto-IP range

                        TInetAddr autoIPAddr = TInetAddr( KDefaultAutoIPAddress,

                                                          KDefaultMulticastPort );

                        autoIPAddr.SetFamily( KAfInet );

                        if ( iAutoIP && autoIPAddr.Match( addr, KInetAddrPrefixMatchLen ) )

                            {

                            LOGS( "SSDP *** MESSAGE_FROM_AUTO_VERIFIED_NETWORK");

                            iObserver->UdpMessageReceivedL( msg );

                            }

                        else if ( !autoIPAddr.Match( addr, KInetAddrPrefixMatchLen ) )

                            {

                            LOGS( "SSDP *** MESSAGE_FROM_NON_AUTO_VERIFIED_NETWORK");

                            iObserver->UdpMessageReceivedL( msg );

                            }

                        CleanupStack::PopAndDestroy(msg);

                        }

                    }

                else

                    {

                    // message not valid, delete it.

                    LOGS( "SSDP *** CUpnpUdpServer::RunL - Invalid SSDP message. Ingoring message.");

                    CleanupStack::PopAndDestroy(msg);

                    }

                RestartOrContinueProcessingL();

                }

                break;

            case ESending:

                delete iSendMessage;

                iSendMessage = NULL;

                RestartOrContinueProcessingL();

                break;

            case ESendDone:

                SendDoneL();

                break;

            default:

                // message not valid, delete it.

                LOGS( "SSDP *** CUpnpUdpServer::RunL - DEFAULT CASE, NOTHING TO DO!");

                break;

            }

        }

    }

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

// CUpnpSsdpServer::RunError

// Active Object RunError called when RunL leaves.

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

//

TInt CUpnpUdpServer::RunError( TInt aError )

    {

LOGS1( "SSDP *** CUpnpUdpServer::RunError: %d", aError );

    TRAP_IGNORE( RestartOrContinueProcessingL() );

    return KErrNone;

    }

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

// CUpnpUdpServer::DoCancel

// Active object DoCancel cancels active request.

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

//

void CUpnpUdpServer::DoCancel()

    {

    iSocket.CancelAll();

    iSendTimer.Cancel();    

    }

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

// CUpnpUdpServer::CloseL

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

//

void CUpnpUdpServer::Close()

    {

    LOGS( "SSDP *** CUpnpUdpServer::Close");