/** @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 HttpServer class.
*
*/


// INCLUDE FILES
#include <e32std.h>
#include <upnpsettings.h>

#include "upnphttpserver.h"
#include "upnphttpsession.h"
#include "upnphttpfileaccess.h"
#include "upnpstring.h"
#include "upnpcommonupnplits.h"
#define KLogFile _L("DLNAWebServer.txt")
#include "upnpcustomlog.h"
#include "upnpcons.h"
#include "upnphttpmessagefactory.h"
#include "upnphttpservertransactioncreator.h"
#ifdef RD_UPNP_REMOTE_ACCESS
#include "upnpipfiltermanager.h"
#endif

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

// -----------------------------------------------------------------------------
// CUpnpHttpServer::CUpnpHttpServer
// C++ default constructor
// -----------------------------------------------------------------------------
//
CUpnpHttpServer::CUpnpHttpServer( MUpnpHttpServerObserver* aObserver,
                                  MUpnpHttpServerTransactionCreator* aCreator,
                                  RSocketServ* aSocketServ,
                                  TInt aActiveIap )
    : CUpnpTcpServer( aSocketServ, KDefaultHttpPort, aActiveIap )
    {
    iObserver = aObserver;
    iTransactionCreator = aCreator;
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::~CUpnpHttpServer
// C++ default destructor
// -----------------------------------------------------------------------------
//
CUpnpHttpServer::~CUpnpHttpServer()
    {
    delete iServerDescription;
    iFs.Close();
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::NewL
// Two-phased constructor
// -----------------------------------------------------------------------------
//
CUpnpHttpServer* CUpnpHttpServer::NewL( MUpnpHttpServerObserver* aObserver,
                                                 RSocketServ* aSocketServ,
                                                 TInt aActiveIap )
    {
    LOG_FUNC_NAME;
       
    CUpnpHttpServer* self = new (ELeave) CUpnpHttpServer( aObserver, NULL,           
            aSocketServ, aActiveIap );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }


// -----------------------------------------------------------------------------
// CUpnpHttpServer::ConstructL
// Two-phased constructor
// -----------------------------------------------------------------------------
//
void CUpnpHttpServer::ConstructL()
    {
    BaseConstructL();
    User::LeaveIfError(iFs.Connect());
    iServerDescription =  CUpnpSettings::GetServerHeaderL();
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::StartL
// Start tcp server
// -----------------------------------------------------------------------------
//
void CUpnpHttpServer::StartL( const TInt aPort )
    {
    LOG_FUNC_NAME;
    OpenSocketL();
    if ( aPort )
        {
        BindL( aPort );
        }
        else
        {
        BindRandomPortL();
        }
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::Stop
// Stop tcp server
// -----------------------------------------------------------------------------
//
void CUpnpHttpServer::Stop()
    {
    LOG_FUNC_NAME;
    TRAP_IGNORE( StopTcpServerL() );
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::ToReceiveStackD
//
// -----------------------------------------------------------------------------
//
void CUpnpHttpServer::ToReceiveStackD( CUpnpHttpMessage* aMsg )
    {
    LOG_FUNC_NAME;
    //to indicate that the upper layer can give a response for it is acting as a host in this session
    if ( !aMsg )
        {
        return;
        }
	aMsg->SetClientRequest(ETrue);
	//for redirection codes

    #ifdef _DEBUG
        TInt err;
        TRAP( err, iObserver->HttpEventLD( aMsg ) );
        LOGS1H( iHandle, "CUpnpHttpServer::ToReceiveStack() Error %i", err );

    #else
        TRAP_IGNORE(  iObserver->HttpEventLD( aMsg ) );
    #endif
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::SendMessageL
// Send HTTP message
// -----------------------------------------------------------------------------
//
TInt CUpnpHttpServer::SendMessageL( CUpnpHttpMessage* aMessage )
    {
    LOG_FUNC_NAME;

    if (!aMessage)
		{
		LOGS("CUpnpHttpServer::SendMessageL - Tried to send Null");
		return KErrNotFound;
		}

    TInt trapError( KErrNone );
    TInt sessId( KErrNone );

    TRAP(trapError, sessId = TrapSendMessageL( aMessage ) );

    if( trapError < KErrNone )
        {
        LOGS1( "HTTP *** Sending of message failed. Error: %i", trapError );
        // HttpSession errors that cannot be forwarded to upper layers
        if( -trapError >= EHttpBadRequest && -trapError <= EHttpExpectationFailed )
            {
            CUpnpHttpMessage* notify = NULL;
            notify = RUpnpHttpMessageFactory::HttpResponseErrorL( aMessage, -trapError );
            CUpnpHttpSession* sess = GetSession( aMessage->SessionId() );
            sess->DeleteThisSessionL( sess );

            ToReceiveStackD( notify ); //Upper layer takes care about cleanup
            }
        else
            {
            User::Leave(trapError);
            }
        }
    // nobody use the value
    return sessId;
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::TrapSendMessageL
// Send HTTP message
// -----------------------------------------------------------------------------
//
TInt CUpnpHttpServer::TrapSendMessageL( CUpnpHttpMessage* aMessage )
    {
    CUpnpHttpSession* sess = GetSession( aMessage->SessionId() );
    if( sess )
        {
        sess->SendL( aMessage );
        return sess->Id();
        }
    else
        {
        // If running out of memory, there is nothing else to do but leave
        if ( KErrNoMemory == aMessage->SessionId() )
            {
            LOGS("CUpnpHttpServer::TrapSendMessageL - OUT OF MEMORY");
            User::Leave( KErrNoMemory );
            }        
        }
    return KErrNotFound;
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::GetSession
//
// -----------------------------------------------------------------------------
//
CUpnpHttpSession* CUpnpHttpServer::GetSession( TInt aSessionId )
    {
    CUpnpHttpSession* sess = NULL;

    for ( TInt i=0; i < iSessionList.Count(); i++ )
        {
        if ( ( (CUpnpHttpSession*) iSessionList[i] )->Id() == aSessionId )
            {
            sess = (CUpnpHttpSession*) iSessionList[i];
            return sess;
            }
        }

    return sess;
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::ServerDescription
// Returns server's description
// -----------------------------------------------------------------------------
//
TDesC8& CUpnpHttpServer::ServerDescription()
    {
    return *iServerDescription;
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::ConnectionAcceptedL
//
// -----------------------------------------------------------------------------
//
CUpnpTcpSession* CUpnpHttpServer::ConnectionAcceptedL( RSocket aSocket )
    {
    LOG_FUNC_NAME;

    #ifdef _DEBUG
    TInetAddr tempAddr;
    aSocket.RemoteName( tempAddr );
    tempAddr.ConvertToV4();

    const TInt KMaxAdressLength = 20;
    TBuf<KMaxAdressLength> addrBuf;
    tempAddr.Output( addrBuf );

    HBufC8* addrBuf8 = UpnpString::FromUnicodeL( addrBuf );
    CleanupStack::PushL( addrBuf8 );

    LOGS( "CUpnpHttpServer::ConnectionAcceptedL - Remote socket connected" );
    LOGT( addrBuf8->Des() );

    LOGS1("CUpnpHttpServer::ConnectionAcceptedL - Creating a new Http session. Session count: %i", iSessionList.Count());

    CleanupStack::PopAndDestroy(addrBuf8);
    #endif //_DEBUG
    CUpnpHttpSession* sess = CUpnpHttpSession::NewL( aSocket, this,
        CUpnpHttpMessage::NewSessionIdL(), EPriorityNormal );

    return sess;
    }


// -----------------------------------------------------------------------------
// CUpnpHttpServer::SetCdDataFinder
//
// -----------------------------------------------------------------------------
//
void CUpnpHttpServer::SetTransactionCreator( 
                                 MUpnpHttpServerTransactionCreator* aTransactionCreator )
    {
    iTransactionCreator = aTransactionCreator;
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::HttpFilter
//
// -----------------------------------------------------------------------------
//
MUpnpHttpServerTransactionCreator* CUpnpHttpServer::TransactionCreator()
    {
    //ASSERT( iHttpFilter ) set in constructor defaultHttpFilter to ensure not null
    return iTransactionCreator;
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::FileSession
// -----------------------------------------------------------------------------
//
RFs& CUpnpHttpServer::FileSession()
    {
    return iFs;
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::ConnectionL
// -----------------------------------------------------------------------------
//
RConnection& CUpnpHttpServer::ConnectionL()
    {
    return iConnectionManagerProxy->ConnectionL();
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::StartIPFilteringL
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpHttpServer::StartIPFilteringL()
    {
    #ifdef RD_UPNP_REMOTE_ACCESS
    if( !iIPFilteringManager )
    {
    iIPFilteringManager = CUpnpIPFilterManager::NewL();
    }
    #endif
    }

// -----------------------------------------------------------------------------
// CUpnpHttpServer::StopIPFiltering
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpHttpServer::StopIPFiltering()
    {
    #ifdef RD_UPNP_REMOTE_ACCESS
    delete iIPFilteringManager;
    iIPFilteringManager = NULL;
    #endif
    }

//  End of File