/** @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:  CUpnpCpbCurrentHttpClient
 *
*/

#include <e32base.h>
#include <e32cons.h>
#include <e32std.h>
#include <upnpsettings.h>
#include <charconv.h>
#include <utf.h>

#include "upnpcpstackrequestor.h"
#include "upnphttpmessage.h"
#include "upnpsoapmessage.h"
#include "upnpicon.h"
#include "upnpdevice.h"
#include "upnpstring.h"
#include "upnphttpmessagefactory.h"
#include "upnpsoapmessagefactory.h"
#include "upnpgenamessagefactory.h"
#include "upnpserviceinfo.h"
#include "upnpcpbhttpmessagecontroller.h"
#include "upnpcpbcurrenthttpclient.h"
#include "upnpcontrolpoint.h"
#include "upnpcommonupnplits.h"
#include "upnpcpbdevicedescription.h"
#include "upnpdevicedescriptionhttptransaction.h"
#include "upnpservicedescriptionhttptransaction.h"
#include "upnpsoapactionhttptransaction.h"
#include "upnpservicesubscriptionhttptransaction.h"
#include "upnpserviceunsubscriptionhttptransaction.h"
#include "upnpcphttprequestorimpl.h"
#include "upnpcpstackrequestorimpl.h"
#include "upnpfilesender.h"

#define KLogFile _L("UPnPControlPoint.txt")
#include <upnpcustomlog.h>

using namespace UpnpHTTP;

static const TInt KMessageTimeout( 10000000 );
static const TInt KActionTimeout( 35000000 );

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

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::CUpnpCurrentHttpClient
// C++ default constructor
// -----------------------------------------------------------------------------
//
CUpnpCpbCurrentHttpClient::CUpnpCpbCurrentHttpClient( CUpnpControlPoint& aControlPoint,
        MUpnpCpHttpRequestor* aHttpRequestor, MUpnpCpStackRequestor* aStackRequestor )
    : iControlPoint( aControlPoint ),
    iHttpRequestor( aHttpRequestor ), iStackRequestor( aStackRequestor )
    {
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::~CUpnpCpbCurrentHttpClient
// Destructor
// -----------------------------------------------------------------------------
//
CUpnpCpbCurrentHttpClient::~CUpnpCpbCurrentHttpClient()
    {
    if ( iStackRequestor )
        {
        iStackRequestor->RemoveCustomer( *this );
        }
    iPendingHttpMessages.ResetAndDestroy();
    iPendingTransactions.ResetAndDestroy();
    delete iUserAgent;
    delete iHttpRequestorDefaultImpl;
    delete iStackRequestorDefaultImpl;
    delete iFileSender;
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::NewL
//
// -----------------------------------------------------------------------------
//
CUpnpCpbCurrentHttpClient* CUpnpCpbCurrentHttpClient::NewL(
    CUpnpControlPoint& aControlPoint,
    MUpnpCpHttpRequestor* aHttpRequestor, MUpnpCpStackRequestor* aStackRequestor)
    {
    LOG_FUNC_NAME;
    CUpnpCpbCurrentHttpClient* self =
        new (ELeave) CUpnpCpbCurrentHttpClient( aControlPoint, aHttpRequestor, aStackRequestor );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::ConstructL
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::ConstructL()
    {
    iFileSender = CUpnpFileSender::NewL( iControlPoint );
    
    if ( !iHttpRequestor )
        {
        iHttpRequestorDefaultImpl = CUpnpCpHttpRequestorImpl::NewL();
        iHttpRequestor = iHttpRequestorDefaultImpl;
        }
    iHttpRequestor->InitialiseL( *this, CUpnpSettings::GetIapL() );

    if ( !iStackRequestor )
        {
        iStackRequestorDefaultImpl = CUpnpCpStackRequestorImpl::NewL( iControlPoint );
        iStackRequestor = iStackRequestorDefaultImpl;
        }
    iStackRequestor->AddCustomerL( *this );
    ASSERT( iHttpRequestor && iStackRequestor ); //ensure correct initialisation
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::SendActionL
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::SendActionL( CUpnpAction* aAction )
    {
    if( !aAction )
        {
        User::Leave( KErrArgument );
        }

    CUpnpHttpMessage* msg = RUpnpSoapMessageFactory::SoapRequestL( aAction );
    CleanupStack::PushL( msg );

    // 7.2.32.1 UPnP action requests (sent by a control point) must include a
    // DLNA-CP-version in a USER-AGENT HTTP header value.
    if ( !iUserAgent )
        {
        HBufC8* userAgent = CUpnpSettings::GetUserAgentL();
        CleanupStack::PushL( userAgent );

        iUserAgent = HBufC8::NewL( userAgent->Length() );
        iUserAgent->Des().Append( *userAgent );

        CleanupStack::PopAndDestroy( userAgent );
        }

    msg->AddPairL( UpnpHTTP::KHdrUserAgent, *iUserAgent );

    msg->SetTcpTimeout( KActionTimeout );
    
    CleanupStack::Pop( msg );//ownership passed to Transaction and is safe
    CUpnpHttpTransaction* soapTransaction = 
         CUpnpSoapActionHttpTransaction::NewLC( msg, aAction->SessionId(), iControlPoint );
                    
    iPendingTransactions.AppendL( soapTransaction );
    CleanupStack::Pop( soapTransaction );
    iHttpRequestor->SendL( *soapTransaction );
    
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::SendSubscribeL
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::SendSubscribeL( CUpnpServiceInfo* aServiceInfo )
    {
    const TDesC8& path = Path();

    TInetAddr addr = iStackRequestor->HttpServerAddress();
    HBufC8* longPath = aServiceInfo->ConstructSubscribtionPathLC( path , addr ); 
    CUpnpGenaMessage* gena = aServiceInfo->CreateSubscriptionMessageL(
                                   *longPath,
                                   ESubscription );
    
    gena->SetTcpTimeout( KMessageTimeout );
    CUpnpServiceSubscriptionHttpTransaction* transaction =
        CUpnpServiceSubscriptionHttpTransaction::NewLC( gena, iControlPoint );
    iPendingTransactions.AppendL( transaction );
    CleanupStack::Pop( transaction );
    iHttpRequestor->SendL( *transaction );
    CleanupStack::PopAndDestroy( longPath );
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::SendUnsubscribeL
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::SendUnsubscribeL( CUpnpServiceInfo* aServiceInfo )
    {
    if ( aServiceInfo->Sid() != KNullDesC8 ) 
        {
        CUpnpGenaMessage* gena = aServiceInfo->CreateSubscriptionMessageL( EUnSubscription );
        gena->SetTcpTimeout( KMessageTimeout );
        CUpnpServiceUnsubscriptionHttpTransaction* transaction = 
            CUpnpServiceUnsubscriptionHttpTransaction::NewLC( gena, iControlPoint) ;
        iPendingTransactions.AppendL( transaction );
        CleanupStack::Pop( transaction );
        iHttpRequestor->SendL( *transaction );
        }
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::SendResubscribeL
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::SendResubscribeL( CUpnpServiceInfo* aServiceInfo )
    {
    CUpnpGenaMessage* gena = aServiceInfo->CreateSubscriptionMessageL( EResubscription );
    gena->SetTcpTimeout( KMessageTimeout );
    CUpnpServiceSubscriptionHttpTransaction* transaction =
         CUpnpServiceSubscriptionHttpTransaction::NewLC( gena, iControlPoint );
    iPendingTransactions.AppendL( transaction );
    CleanupStack::Pop( transaction );
    iHttpRequestor->SendL( *transaction );
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::GetServiceDescriptionL
//
// -----------------------------------------------------------------------------
//
TInt CUpnpCpbCurrentHttpClient::GetServiceDescriptionL( CUpnpDevice* aDevice,
    const TDesC8& aUrl )
    {
    CUpnpHttpMessage* result( NULL );
    TPtrC8 urlBase( aDevice->UrlBase() );

    if ( aUrl.Find( KHttp ) == 0 )
        {
        result = RUpnpHttpMessageFactory::HttpGetL( aUrl );
        }
    else
        {
        TInetAddr addr = aDevice->Address();
        if ( urlBase.Length() > 0 )
            {
            HBufC8* url = aDevice->ConcatWithUrlBaseL( aUrl );
            CleanupStack::PushL( url );

            if ( url->Find( KHttp ) )
                {
                result = RUpnpHttpMessageFactory::HttpGetL( addr, *url,
                    KNullDesC8 );
                }
            else
                {
                result = RUpnpHttpMessageFactory::HttpGetL( *url );
                }

            CleanupStack::PopAndDestroy( url );
            }
        else
            {
            result = RUpnpHttpMessageFactory::HttpGetL( addr,
                aDevice->DescriptionUrlPath(), aUrl );
            }
        }
    result->SetTcpTimeout( KMessageTimeout );

    CUpnpServiceDescriptionHttpTransaction* transaction =
        CUpnpServiceDescriptionHttpTransaction::NewLC( result, iControlPoint );

    iPendingTransactions.AppendL( transaction );
    CleanupStack::Pop( transaction );
    iHttpRequestor->SendL( *transaction );
    return result->SessionId();
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::GetDeviceDescriptionL
//
// -----------------------------------------------------------------------------
//
TInt CUpnpCpbCurrentHttpClient::GetDeviceDescriptionL( CUpnpDevice* aDevice )
    {
    TInetAddr addr = aDevice->DescriptionUrlAddressL();
    addr.SetPort( aDevice->DescriptionUrlPort() );

    CUpnpHttpMessage* message = RUpnpHttpMessageFactory::HttpGetL( addr,
        aDevice->DescriptionUrlPath() );
    message->SetTcpTimeout( KMessageTimeout );

    CUpnpDeviceDescriptionHttpTransaction* transaction =
        CUpnpDeviceDescriptionHttpTransaction::NewLC( message, iControlPoint );

    iPendingTransactions.AppendL( transaction );
    CleanupStack::Pop( transaction );
    iHttpRequestor->SendL( *transaction );

    return message->SessionId();
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::MessageReceivedLD
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::MessageReceivedLD( CUpnpHttpMessage* aHttpMessage )
    {
    if ( !aHttpMessage )
        {
        User::Leave( KErrArgument );
        }
    // match arrived response to pending request

    TIdentityRelation<CUpnpHttpMessage> matcher( CUpnpHttpMessage::SessionIdMatch );
    TInt idx = iPendingHttpMessages.Find ( aHttpMessage, matcher );

    CleanupStack::PushL( aHttpMessage );

    if ( aHttpMessage->IsGena() )
        {
        CleanupStack::Pop( aHttpMessage );
        iControlPoint.NotifyReceivedL( *aHttpMessage );
        }
    else
        {
        iControlPoint.MessageReceived( aHttpMessage );
        iPendingHttpMessages.Compress();
        CleanupStack::PopAndDestroy( aHttpMessage );
        }
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::Path
//
// -----------------------------------------------------------------------------
//
const TDesC8& CUpnpCpbCurrentHttpClient::Path()
    {
    return KPath();
    }

// ----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::StopIgnoringL
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::StopIgnoringL( CUpnpDevice* aDevice )
    {
    iStackRequestor->StopIgnoringL( aDevice->Uuid() );
    StopIgnoringEmbeddedL( aDevice );
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::StopIgnoringEmbeddedL
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::StopIgnoringEmbeddedL( CUpnpDevice* aRoot )
    {
    RPointerArray<CUpnpDevice> devicesAll;
    aRoot->GetAllDevices( devicesAll );
    CleanupClosePushL( devicesAll );
    for ( TInt k = 0; k < devicesAll.Count(); k++ )
        {
        iStackRequestor->StopIgnoringL( devicesAll[k]->Uuid() );
        }
    CleanupStack::PopAndDestroy( &devicesAll );
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::StopIgnoringUuidL
// Send stop ignoring message to MH
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::StopIgnoringUuidL( const TDesC8& aUuids )
    {
    iStackRequestor->StopIgnoringL( aUuids );
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::StartIPFilteringL
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::StartIPFilteringL()
    {
    iStackRequestor->StartIPFilteringL();
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::StopIPFiltering
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::StopIPFiltering()
    {
    iStackRequestor->StopIPFiltering();
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::SendL
// Send response HTTP message
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::SendL( CUpnpHttpMessage* aHttpMessage )
    {
    const TInt KUnused(0);
    iStackRequestor->SendMessageL( aHttpMessage, *this, KUnused );
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::SendFileByPostL
// Send HTTP message
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::SendFileByPostL( CUpnpHttpMessage* aHttpMessage )
    {
    if ( !aHttpMessage )
        {
        User::Leave( KErrArgument );
        }
    iFileSender->SendL( *aHttpMessage );
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::SearchL
// Sends a SSDP Search with 8-bit search string.
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::SearchL( const TDesC8& aSearchString )
    {
    iStackRequestor->SearchL( aSearchString );
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::ClientResponseRecivedLD
// Callback indicating that response was received within transaction.
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::ClientResponseRecivedLD(
    CUpnpHttpTransaction& aCompletedTrasaction )
    {
    TInt idx( iPendingTransactions.Find( &aCompletedTrasaction ) );
    //it should never happen that we received transaction that wasn't sent by us
    ASSERT( idx >= 0 );
    aCompletedTrasaction.ProcessResponseL();
    iPendingTransactions.Remove( idx );
    delete ( &aCompletedTrasaction );
    }

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::WlanLostOccurs
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::WlanLostOccurs()
    {
    iStackRequestor->StopHttpServer();
    TRAP_IGNORE( SetNullRequestorsL() );
    }
    
// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::AddressChanged
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::AddressChangedL()
    {
    iStackRequestor->StopHttpServer();
    iStackRequestor->StartHttpServerL();
    }    

// -----------------------------------------------------------------------------
// CUpnpCpbCurrentHttpClient::SetNullRequestorsL
//
// -----------------------------------------------------------------------------
//
void CUpnpCpbCurrentHttpClient::SetNullRequestorsL()
    {
    CUpnpCpHttpRequestorImplBase* httpReq = new ( ELeave ) CUpnpCpHttpRequestorImplBase();
    delete iHttpRequestorDefaultImpl;
    iHttpRequestorDefaultImpl = NULL;
    iHttpRequestorDefaultImpl = httpReq;
    iHttpRequestor = iHttpRequestorDefaultImpl;

    CUpnpCpStackRequestorImplBase* stackReq = new ( ELeave ) CUpnpCpStackRequestorImplBase();
    delete iStackRequestorDefaultImpl;
    iStackRequestorDefaultImpl = NULL;
    iStackRequestorDefaultImpl = stackReq;
    iStackRequestor = iStackRequestorDefaultImpl;
    }

//  End of File