/*
* Copyright (c) 2005 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:   CXcapHttpTransport
*
*/




// INCLUDE FILES
#include <in_iface.h>
#include <xdmlogwriter.h>
#include <deflatefilterinterface.h>
#include <msgconnmanagerapi.h>
#include "XdmCredentials.h"
#include "XcapHttpReqGet.h"
#include "XcapHttpReqPut.h"
#include "XcapHttpReqMkcol.h"
#include "XcapHttpReqHead.h"
#include "XcapHttpRequest.h"
#include "XcapHttpReqDelete.h"
#include "XcapHttpTransport.h"
#include "XcapHttpAuthManager.h"

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


// ----------------------------------------------------------
// CXcapHttpTransport::CXcapHttpTransport
// 
// ----------------------------------------------------------
//
CXcapHttpTransport::CXcapHttpTransport( MMsgConnManager& aConnManager) :
                                        iCredValidity( EFalse ),
                                        iSessionClosed( ETrue ),
                                        iConnManager( aConnManager )
    { 
    }

// ----------------------------------------------------------
// CXcapHttpTransport::NewL
// 
// ----------------------------------------------------------
//
EXPORT_C CXcapHttpTransport* CXcapHttpTransport::NewL( const TDesC& aRootUri,
                                                       MMsgConnManager& aConnManager,
                                                       const TXdmCredentials& aDigestCredentials )
    {
    CXcapHttpTransport* self = new ( ELeave ) CXcapHttpTransport( aConnManager );
    CleanupStack::PushL( self );
    self->ConstructL( aRootUri, aDigestCredentials );
    CleanupStack::Pop();  //self
    return self;
    }

// ----------------------------------------------------
// CXcapHttpTransport::~CXcapHttpTransport
// 
// ----------------------------------------------------
//
CXcapHttpTransport::~CXcapHttpTransport()
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapHttpTransport::~CXcapHttpTransport()" ) );
    #endif
    delete iRootUri;
    delete iAuthManager;
    iHttpSession.Close();
    iSessionClosed = ETrue;
    delete iProxyBuffer;
    #ifdef _DEBUG
        WriteToLog( _L8( "  Destructor ends." ) );
    #endif
    delete iLogWriter;
    }

// ----------------------------------------------------------
// CXcapHttpTransport::ConstructL
// 
// ----------------------------------------------------------
//
void CXcapHttpTransport::ConstructL( const TDesC& aRootUri, const TXdmCredentials& aDigestCredentials )
    {
    #ifdef _DEBUG
        iLogWriter = CXdmLogWriter::NewL( KTransportLogFile );
        WriteToLog( _L8( "CXcapHttpTransport::ConstructL" ) );
    #endif
    SetRootUriL( aRootUri );
    InitialiseSessionL();
    iAuthManager = CXcapHttpAuthManager::NewL( iHttpSession, *this, aDigestCredentials );
    } 

// ---------------------------------------------------------
// CXcapHttpTransport::SetRootUriL
// 
// ---------------------------------------------------------
//
EXPORT_C void CXcapHttpTransport::SetRootUriL( const TDesC& aRootUri )
    {
    delete iRootUri;
    iRootUri = NULL;
    iRootUri = HBufC8::NewL( aRootUri.Length() );
    iRootUri->Des().Copy( aRootUri );
    }
         
// ----------------------------------------------------
// CXcapHttpTransport::GetL
// 
// ----------------------------------------------------
//
EXPORT_C CXcapHttpReqGet* CXcapHttpTransport::GetL( const TDesC& aRequestUri )
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapHttpTransport::GetRequestL()" ) );
    #endif
    if( !iSessionClosed )
        return CXcapHttpReqGet::NewL( aRequestUri, iHttpSession, *iAuthManager, *this );
    else
        {
        User::Leave( KErrNotReady );
        return NULL;
        }    
    }

// ----------------------------------------------------
// CXcapHttpTransport::PutL
// 
// ----------------------------------------------------
//
EXPORT_C CXcapHttpReqPut* CXcapHttpTransport::PutL( const TDesC& aRequestUri )
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapHttpTransport::PutRequestL()" ) );
    #endif
    if( !iSessionClosed )
        return CXcapHttpReqPut::NewL( aRequestUri, iHttpSession, *iAuthManager, *this );
    else
        {
        User::Leave( KErrNotReady );
        return NULL;
        }    
    }

// ----------------------------------------------------
// CXcapHttpTransport::Mkcol
// 
// ----------------------------------------------------
//
EXPORT_C CXcapHttpReqMkcol* CXcapHttpTransport::MkcolL( const TDesC& aRequestUri )
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapHttpTransport::MkcolRequestL()" ) );
    #endif
    if( !iSessionClosed )
        return CXcapHttpReqMkcol::NewL( aRequestUri, iHttpSession, *iAuthManager, *this );
    else
        {
        User::Leave( KErrNotReady );
        return NULL;
        }    
    }

// ----------------------------------------------------
// CXcapHttpTransport::Head
// 
// ----------------------------------------------------
//
EXPORT_C CXcapHttpReqHead* CXcapHttpTransport::HeadL( const TDesC& aRequestUri )
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapHttpTransport::HeadRequestL()" ) );
    #endif
    if( !iSessionClosed )
        return CXcapHttpReqHead::NewL( aRequestUri, iHttpSession, *iAuthManager, *this );
    else
        {
        User::Leave( KErrNotReady );
        return NULL;
        }    
    }

// ----------------------------------------------------
// CXcapHttpTransport::DeleteL
// 
// ----------------------------------------------------
//
EXPORT_C CXcapHttpReqDelete* CXcapHttpTransport::DeleteL( const TDesC& aRequestUri )
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapHttpTransport::DeleteRequestL()" ) );
    #endif
    if( !iSessionClosed )
        return CXcapHttpReqDelete::NewL( aRequestUri, iHttpSession, *iAuthManager, *this );
    else
        {
        User::Leave( KErrNotReady );
        return NULL;
        }    
    }

// ----------------------------------------------------------
// CXcapHttpTransport::RootUri
// 
// ----------------------------------------------------------
//
EXPORT_C TPtrC8 CXcapHttpTransport::RootUri()
    {
    return iRootUri != NULL ? iRootUri->Des() : TPtrC8();
    }

// ----------------------------------------------------
// CXcapHttpTransport::InitialiseSessionL
// 
// ----------------------------------------------------
//
void CXcapHttpTransport::InitialiseSessionL()
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapHttpTransport::InitialiseSessionL()" ) );
    #endif
    iHttpSession.OpenL();
    RSocketServ& session = iConnManager.SocketSession();
    RConnection& connection = iConnManager.Connection();
    RHTTPConnectionInfo connInfo = iHttpSession.ConnectionInfo();
    RStringPool stringPool = iHttpSession.StringPool();
    TInt conn = reinterpret_cast <TInt> ( &connection );
    connInfo.SetPropertyL( stringPool.StringF( HTTP::EHttpSocketServ, RHTTPSession::GetTable() ),
                           THTTPHdrVal( session.Handle() ) );
    connInfo.SetPropertyL( stringPool.StringF( HTTP::EHttpSocketConnection, RHTTPSession::GetTable() ),
                           THTTPHdrVal( conn ) );
    connInfo.SetPropertyL( stringPool.StringF( HTTP::EHTTPVersion, RHTTPSession::GetTable() ),
                           THTTPHdrVal( stringPool.StringF( HTTP::EHttp11, RHTTPSession::GetTable() ) ) );
    connInfo.SetPropertyL( stringPool.StringF( HTTP::ESecureDialog, RHTTPSession::GetTable() ),
                           THTTPHdrVal( stringPool.StringF( HTTP::EDialogPrompt, RHTTPSession::GetTable() ) ) );
    //CHttpDeflateFilter::InstallFilterL( iHttpSession );
    iSessionClosed = EFalse;
    #ifdef _DEBUG
        WriteToLog( _L8( "InitialiseSessionL() ends." ) );
    #endif
    }

#ifdef _DEBUG              
// ----------------------------------------------------
// CXcapHttpTransport::WriteToLog
// Writes to the log, 8-bit version
// ----------------------------------------------------
//
void CXcapHttpTransport::WriteToLog( TRefByValue<const TDesC8> aFmt,... ) const
    {
    VA_LIST list;
    VA_START( list, aFmt );
    TBuf8<KLogBufferMaxSize> buf;
    buf.FormatList( aFmt, list );
    iLogWriter->WriteToLog( buf );
    }
       
// ----------------------------------------------------
// CXcapHttpTransport::WriteToLog
// Writes to the log, 16-bit version
// ----------------------------------------------------
//
void CXcapHttpTransport::WriteToLog( TRefByValue<const TDesC> aFmt,... ) const
    {
    VA_LIST list;
    VA_START( list, aFmt );
    TBuf<KLogBufferMaxSize> buf;
    buf.FormatList( aFmt, list );
    iLogWriter->WriteToLog( buf );
    }
#endif  //_DEBUG
      



// End of File