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

#include <commdb.h>

#include "upnpcons.h"

#include "upnphttpsession.h"

#define KLogFile _L("DLNAWebServer.txt")

#include "upnpcustomlog.h"

#include "upnphttpservertransactioncreator.h"

#ifdef RD_UPNP_REMOTE_ACCESS

#include "upnpipfiltermanager.h"

#endif

// Include for Publish and Subscribe

#include <e32math.h>

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

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

// CUpnpTcpServer::CUpnpTcpServer

// C++ default constructor

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

//

CUpnpTcpServer::CUpnpTcpServer( RSocketServ* aSocketServ,

                                TInt aPort,

                                TInt aIap )

    : CActive( EPriorityNormal )

    {

    CActiveScheduler::Add( this );

    iServerPort = aPort;

    iSocketServ = aSocketServ;

    iActiveIap = aIap;

    iServerAddress = TInetAddr( INET_ADDR(0,0,0,0), 0 );

    iRetrySocketTimer = NULL;

    iFileReadBufferSize  = KRcvBufSizeDefault;

    iFileWriteBufferSize = KServeFileSizeDefault;

    }

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

// CUpnpTcpServer::BaseConstructL

// TcpServer might-leave initialization method.

// NOTE: Must be called by extending class

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

//

void CUpnpTcpServer::BaseConstructL()

    {

    iRetrySocketTimer = CUpnpNotifyTimer::NewL( this );

    CreateConnectionManagerSessionL();

    }

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

// CUpnpTcpServer::CUpnpTcpServer

// C++ default destructor

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

//

CUpnpTcpServer::~CUpnpTcpServer()

    {

    LOG_FUNC_NAME;

    PrepareToCloseSockets();

    delete iRetrySocketTimer;

    #ifdef RD_UPNP_REMOTE_ACCESS

    delete iIPFilteringManager;

    #endif

    }

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

// CUpnpTcpServer::CreateConnectionManagerSessionL

//

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

//

void CUpnpTcpServer::CreateConnectionManagerSessionL()

    {

    if ( !iConnectionManagerProxy )

        {

        iConnectionManagerProxy = CUpnpConnectionManagerProxy::NewL( *iSocketServ );

        TInt error = iConnectionManagerProxy->EnsureStart();

        if ( error )

            {

            LOGS1H( iHandle, "CUpnpTcpServer::OpenSocketL *** Error in attaching: %d", error );

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

            // can't access network

            User::LeaveIfError( error );

            }

        }

    }

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

// CUpnpTcpServer::ListenL

// Listen incoming connections

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

//

void CUpnpTcpServer::OpenSocketL()

    {

    CreateConnectionManagerSessionL();

    SetServerAddress( iConnectionManagerProxy->LocalAddress() );

    iActiveIap = iConnectionManagerProxy->ActiveIap();

    LOGSH( iHandle, "CUpnpTcpServer::ListenL()");

    TInt error = iServerSocket.Open( *iSocketServ, KAfInet, KSockStream,

                                      KProtocolInetTcp,

                                      iConnectionManagerProxy->ConnectionL() );

    if ( error != KErrNone)

        {

        LOGSH( iHandle, "CUpnpTcpServer ListenL - Open failed.");

        User::Leave( error );

        }

    }

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

// CUpnpTcpServer::BindRandomPortL

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

//

void CUpnpTcpServer::BindRandomPortL()

    {

    LOG_FUNC_NAME;

    iServerPort = NewPortNumberL();

    TInetAddr addr =  TInetAddr(iServerPort);

    TInt error = iServerSocket.Bind( addr );

    if ( KErrNone == error )

        {

        error = StartToListenL();

        }

    // If the port is in use, then get a new port number and try again.

    else if ( KErrInUse == error )

        {

            LOGS1H( iHandle, "CUpnpTcpServer ListenL - Bind fail, trying new port: %d", iServerPort);

        while ( KErrInUse == error )

            {

            iServerPort = NewPortNumberL();

            iServerAddress.SetPort( iServerPort );

            error = iServerSocket.Bind( iServerAddress );

            if ( KErrNone == error )

                {

                error = StartToListenL();

                }

            }

        if ( KErrNone != error )

            {

                LOGS1H( iHandle, "CUpnpTcpServer ListenL Bind fail: %d", error);

            iServerSocket.Close();

            }

        }

    // Bind failed, close socket and log problem

    else

        {

        iServerSocket.Close();

            LOGS1H( iHandle, "CUpnpTcpServer ListenL -RSocket::Bind fail: %d", error);

        }

    // In case of failure, there is nothing else to do but leave.

    // Construction will fail.

    if ( KErrNone != error )

        {

        LOGSH( iHandle, "CUpnpTcpServer ListenL - Bind or listen failed.");

        User::Leave( error );

        }

    }

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

// CUpnpTcpServer::BindL

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

//

void CUpnpTcpServer::BindL( const TInt aPort)

{

    LOGS1H( iHandle , "CUpnpTcpServer BindL to fixed port %d" , aPort);

    iServerPort = aPort;

    TInetAddr addr( iServerPort );

    TInt error( iServerSocket.Bind( addr ) );

    if( error == KErrNone )

        {

        User::LeaveIfError( StartToListenL() );

        }

    else

        {

        LOGSH( iHandle, "CUpnpTcpServer ListenL - open, Bind or listen failed");

        iServerSocket.Close();

        User::Leave( error ) ;

        }

}

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

// CUpnpTcpServer::StartToListenL

// Start to listen a socket.

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

//

TInt CUpnpTcpServer::StartToListenL()

    {

    TInt error = iServerSocket.Listen( UpnpSocket::KMaxConnectionsInQueue );

    if ( KErrNone == error )

        {

        // Both bind and listen ok, accept connection if OK

        LOGS1H( iHandle, "CUpnpTcpServer::StartToListenL - at port %i", ServerPort() );

        AcceptConnectionL();

        }

    // Listen failed, close socket and log problem

    else

        {

        iServerSocket.Close();

        LOGS1H( iHandle, "CUpnpTcpServer StartToListenL - fail: %d" , error);

        }

    return error;

    }

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

// CUpnpTcpServer::AcceptConnection

// Open connection

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

//

void CUpnpTcpServer::AcceptConnectionL()

    {

    LOG_FUNC_NAME;

    TInt error = 0;

    if( iSessionList.Count() >= KMaxConnectionCount )

    {

        LOGSH( iHandle, "CUpnpTcpServer::AcceptConnectionL - HTTP *** SessionList full");

        StartRetryTimer();

        return;

    }

    error = iClientSocket.Open( *iSocketServ );

    if ( error < KErrNone )

        {

        LOGS1H( iHandle, "CUpnpTcpServer::AcceptConnectionL - error to open client socket,%i", error);

        iClientSocket.Close();

        StartRetryTimer();

        }

    else

        {

        iServerSocket.Accept( iClientSocket, iStatus );

        SetActive();

        iState = EAccepting;

        LOGSH( iHandle, "CUpnpTcpServer::AcceptConnection - State = EAccepting ");

        }

    }

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

// CUpnpTcpServer::DeleteSession

// Delete sessions.

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

//

void CUpnpTcpServer::DeleteSession( CUpnpTcpSession* aSession )

    {

    LOG_FUNC_NAME;

    TInt pos = iSessionList.Find( aSession );

    if( pos != KErrNotFound )

        {

        iSessionList.Remove( pos );

        iSessionList.Compress();

        delete aSession;

        aSession = NULL;

        }

    }

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

// CUpnpTcpServer::RunL

// State machine

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

//

void CUpnpTcpServer::RunL()

    {

     switch ( iState )

        {

        case EAccepting:

            {

            if( iStatus == KErrNone )

                {

                iClientSocket.SetOpt( KSoTcpNoDelay, KSolInetTcp, 1 );

                #ifdef RD_UPNP_REMOTE_ACCESS

/**************     IPFIltering    ********************/

                TInetAddr tempAddr;

                iClientSocket.RemoteName( tempAddr );

                tempAddr.ConvertToV4();

                if( iIPFilteringManager && !iIPFilteringManager->IsAllowed( tempAddr ) )

                    {

                    iClientSocket.Close();  //mozliwe ze konieczny bedzie jeszcze

                                            //Shutdown - EImmediate; default jest ENormal

                    AcceptConnectionL()  ;

                    break;

                    }

                #if _DEBUG

                TBuf<20> addrBuf;

                tempAddr.Output( addrBuf );

                #endif

/******************* IPFiltering END *******************/

                #endif

                CUpnpTcpSession* sess = ConnectionAcceptedL( iClientSocket );

                }

            else

                {

                iClientSocket.Close();

                }

            AcceptConnectionL();

            break;

            }

        default:

            break;

        }

    }

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

// CUpnpTcpServer::RunError

// RunError is called when RunL leaves.

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

//

TInt CUpnpTcpServer::RunError( TInt aError )

    {

    LOGS1H( iHandle, "CUpnpTcpServer::RunError - Error: %d", aError);

    StartRetryTimer();

    return KErrNone;

    }

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

// CUpnpTcpServer::StopTcpServerL

// Stop session and reset the lists

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

//

void CUpnpTcpServer::StopTcpServerL()

    {

    LOG_FUNC_NAME;      

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

        {

        iSessionList[i]->NotifyTimeoutL();

        }

    PrepareToCloseSockets();     

    }

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

// CUpnpTcpServer::PrepareToCloseSockets

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

//

void CUpnpTcpServer::PrepareToCloseSockets()

    {

    iSessionList.ResetAndDestroy();

    if ( IsActive() )

        {

        Cancel();

        }

    else

        {

        CancelRetryTimer();

        CloseSockets();

        }  

    delete iConnectionManagerProxy;

    iConnectionManagerProxy = NULL;    

    }

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

// CUpnpTcpServer::DoCancel

// Cancel outstanding operations and close the connection

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

//

void CUpnpTcpServer::DoCancel()

    {

    CancelRetryTimer();

    iServerSocket.CancelAll();

    CloseSockets();

    LOGSH( iHandle, "CUpnpTcpServer::DoCancel - iState = ENotListening" );

    }

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

// CUpnpTcpServer::CloseSockets

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

//

void CUpnpTcpServer::CloseSockets()

    {

    iServerSocket.Close();

    iClientSocket.Close();

    iState = ENotListening;

    LOGSH( iHandle, "CUpnpTcpServer::CloseSockets - iState = ENotListening" );

    }

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

// CUpnpTcpServer::ServerAddress

// Return server address.

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

//

void CUpnpTcpServer::ServerAddress( TInetAddr& aAddr )

    {

    LOG_FUNC_NAME;

    aAddr = iServerAddress;

    }

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

// CUpnpTcpServer::SetServerAddress

// Set new server address.

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

//

void CUpnpTcpServer::SetServerAddress( const TInetAddr& aAddr )

    {

    iServerAddress = aAddr;

    }

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

// CUpnpTcpServer::ServerPort

// Return server port number,

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

//

TUint CUpnpTcpServer::ServerPort()

    {

    return iServerPort;

    }

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

// CUpnpTcpServer::HWAddressL

// Return hardware address.

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

//

TSockAddr* CUpnpTcpServer::HWAddressL()

    {

    LOG_FUNC_NAME;

    // Fetch IP address

    ServerAddress(iServerAddress);

    // return value is TSockAddr* because it won't work

    // correctly always with TSockAddr

    TPckgBuf<TSoInetInterfaceInfo> item;

    RSocket sock;

    TInt result = sock.Open( *iSocketServ, KAfInet, KSockStream,

        KProtocolInetTcp, iConnectionManagerProxy->ConnectionL() );

    if ( KErrNone == result )

        {

        result = sock.GetOpt( KSoInetNextInterface, KSolInetIfCtrl, item );

        // checking all interfaces. If interface has same IP address as socket, is

        // the current active interface. In this case we get that interface's

        // hardware address.

        while ( result == KErrNone )

            {

            TSoInetInterfaceInfo& ifInfo = item();

            TInetAddr ifAddr = ifInfo.iAddress;

            ifAddr.ConvertToV4();

            ifAddr.SetPort( iServerAddress.Port() );

            if ( ifAddr == iServerAddress )

                {

                sock.Close();

                TSockAddr tempAddr = ifInfo.iHwAddr;

                return new (ELeave) TSockAddr( tempAddr );

                }

            result = sock.GetOpt( KSoInetNextInterface, KSolInetIfCtrl, item );

            }

        }

    sock.Close();

    return new (ELeave) TSockAddr();

    }

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

// CUpnpTcpServer::NewPortNumberL

//

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

//

TInt CUpnpTcpServer::NewPortNumberL()

    {

    LOG_FUNC_NAME;

    TInt id( 0 );

    //get random port

    TTime now;

    now.HomeTime();

    TInt64 randSeed = now.Int64();

    id =  Math::Rand( randSeed ) % (KInetMaxAutoPort-KInetMinAutoPort+1) + KInetMinAutoPort;

    return id;

    }

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

// CUpnpTcpServer::TimerEventL

// Function is callback from iRetrySocketTimer. This timer is used

// to retry to open new server socket.

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