/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*      Loading functions for COD Handler.   

*      

*

*/

// INCLUDE FILES

#include "HttpLoader.h"

#include "CodSaver.h"

#include "HttpTcpSession.h"

#include "HttpWapSession.h"

#include "CodLogger.h"

#include "CodPanic.h"

#include "CodError.h"

#include "CodUtil.h"

#include "Connection.h"

#include "Timeout.h"

#include "CodProgress.h"

#include "CodEngbase.h"

#include <CookieFilterInterface.h>

#include <uaproffilter_interface.h>

#include <DeflateFilterInterface.h>

#include <httperr.h>

#include <bldvariant.hrh>

#include <ECom.h>

#include <es_sock.h>

#include <EscapeUtils.h>

#include <http/rhttpheaders.h>

#include <Oma2Agent.h>

#include <HttpDownloadMgrCommon.h>

#include    "HeaderField.h"

#include    "FileExt.h"

#include    "CodData.h"

_LIT8( KDRMOldContentType, "x-drm-old-content-type");           // old content type header to be added

_LIT8( KAcceptRangeHeader, "bytes");           

// ================= CONSTANTS =======================

/// Maximum user name length we support.

LOCAL_D const TInt KCodMaxAuthUserName = 50;

/// Maximum password length we support.

LOCAL_D const TInt KCodMaxAuthPassword = 50;

/// WSP protocol name.

_LIT8( KCodWspProtocol, "WSP/WSP" );

/// Accept-header value (application/vnd.wap.mms-message).

_LIT8( KCodAcceptMmsHeaderValue, "application/vnd.wap.mms-message" );

/// Accept-header value (application/vnd.wap.sic).

_LIT8( KCodAcceptSiHeaderValue, "application/vnd.wap.sic" );

/// "No activity" timeout for GET request (in microseconds), 60 sec - Updated to 60 secs as part of error fix JSIN-7JSE6H

/// Let's try to keep the same timeout for WCDMA & GPRS (???)

LOCAL_D const TInt KCodGetTimeout = 60000000;

/// "No activity" timeout for POST request (in microseconds), 10 sec.

LOCAL_D const TInt KCodPostTimeout = 10000000;

/// Install-notify timeout (in microseconds), 50 msec.

LOCAL_D const TInt KCodINTimeout = 50000;

/// Retry count for GET request timeout (1 attempt == no retry).

LOCAL_D const TInt KCodGetRetry = 1;

/// Retry count for POST request timeout (2 attempt == 1 retry).

LOCAL_D const TInt KCodPostRetry = 2;

/// Estimated data transfer for reponse headers. Needed for progress.

LOCAL_D const TInt KCodRespHdrsTraffic = 512;

/// characters which should be escaped from requested URL's

_LIT8( KUriEscChars, " ");

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

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

// CHttpLoader::NewL()

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

//

CHttpLoader* CHttpLoader::NewL

        (

        CConnection& aConnection,

        MCodLoadObserver* aCodLoadObserver,

        TCodProgress* aProgress ,

        CCodEngBase* aCodEng 

        )

    {

    CHttpLoader* loader =

        new( ELeave ) CHttpLoader( aConnection, aCodLoadObserver, aProgress, aCodEng );

    CleanupStack::PushL( loader );

    loader->ConstructL();

    CleanupStack::Pop( loader );

    return loader;

    }

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

// CHttpLoader::~CHttpLoader()

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

//

CHttpLoader::~CHttpLoader()

    {

    Cancel();

    iFeatMgr.Close();

    delete iTimeout;

    delete iSess;

    delete iNotifyBody;

    delete iUri;

    delete iINTimeout;

     if(iResponseHeaders != NULL)

    {

    iResponseHeaders->ResetAndDestroy();

    delete iResponseHeaders;

    }

    delete iDownloadInfo;

    REComSession::FinalClose();

    __ASSERT_DEBUG( !iParentStatus, CodPanic( ECodRequestPending ) );

    CLOG(( EHttpLoad, 2, _L("*** CHttpLoader::~CHttpLoader") ));

    }

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

// CHttpLoader::LoadL()

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

//

void CHttpLoader::LoadL

        (

        const TDesC8& aUrl,

        MCodSaverFactory& aSaverFactory,

        TRequestStatus* aStatus

        )

    {

    CLOG(( EHttpLoad, 2, _L("-> CHttpLoader::LoadL") ));

    // Misuse asserts.

    __ASSERT_ALWAYS( aStatus, CodPanic( ECodInvalidArguments ) );

    __ASSERT_ALWAYS( iState == EInit, CodPanic( ECodOffState ) );

    // Internal asserts.

    __ASSERT_DEBUG( !iParentStatus, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iSaverFactory, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iSaver, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iUri, CodPanic( ECodInternal ) );

    iUri = aUrl.AllocL();

    iMethod = HTTP::EGET;

    iRetry = KCodGetRetry;

    iSaverFactory = &aSaverFactory;

    iResult = KErrNone;

    iRedirect = EFalse;

    iCodEng->LoadSubInfoFileL(iCodEng->Data().ActiveDownload() , iResponseHeaders );

    TBuf8<128> contentType;

    TRAPD( err, contentType = GetContentTypeL() );

    if(err == KErrNone)

        {

        iSaver = iSaverFactory->CreateSaverL( contentType );

        }

    iParentStatus = aStatus;

    *iParentStatus = KRequestPending;

    if( iProgress && iSaver )

        {

        iSaver->SetSourceUriL(iUri->Des() );

        TInt dlSize( 0 );

        //Current Track Downloaded Size

        dlSize += iCodEng->Data()[iCodEng->Data().ActiveDownload()]->DownloadedSize();

        if(dlSize >= 0)

            {

            iProgress->SetAmountL(dlSize);                

            }

        }

    if( iProgress )

    	{

    	iProgress->StartPhaseL(TCodProgress::ELoad);

    	}

    Continue( EStart );

    CLOG(( EHttpLoad, 2, _L("<- CHttpLoader::LoadL") ));

    }

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

// CHttpLoader::NotifyL()

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

//

void CHttpLoader::NotifyL

( const TDesC8& aUrl, const TDesC8& aNotifyBody, TRequestStatus* aStatus )

    {

    CLOG(( EHttpLoad, 2, _L("-> CHttpLoader::NotifyL") ));

    // Misuse asserts.

    __ASSERT_ALWAYS( aStatus, CodPanic( ECodInvalidArguments ) );

    __ASSERT_ALWAYS( iState == EInit, CodPanic( ECodOffState ) );

    // Internal asserts.

    __ASSERT_DEBUG( !iParentStatus, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iNotifyBody, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( !iUri, CodPanic( ECodInternal ) );

    // Allocation of two members iUri+iNotifyBody is atomic.

    HBufC8* notifyBody = aNotifyBody.AllocLC();

    iUri = aUrl.AllocL();

    iNotifyBody = notifyBody;

    CleanupStack::Pop( notifyBody );    // now member.

    iMethod = HTTP::EPOST;

    iRetry = KCodPostRetry;

    iParentStatus = aStatus;

    *iParentStatus = KRequestPending;

    iResult = KErrNone;

    Continue( EStart );

    CLOG(( EHttpLoad, 2, _L("<- CHttpLoader::NotifyL") ));

    }

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

// CHttpLoader::DoCancel()

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

//

void CHttpLoader::DoCancel()

    {

    CLOG(( EHttpLoad, 2, _L("-> CHttpLoader::DoCancel iState(%d)"), iState ));

    switch ( iState )

        {

        case EStart:

            {

            // Already completed (by self-completion).

            __ASSERT_DEBUG( iStatus != KRequestPending, \

                CodPanic( ECodInternal ) );

            SelfComplete( KErrCancel );

            break;

            }

        case EOpen:

            {

            __ASSERT_DEBUG( iSess, CodPanic( ECodInternal ) );

            // This will complete our status.

            iSess->Disconnect();

            break;

            }

        case ERequest:

            {

            CompleteTransaction( KErrCancel );

            break;

            }

        case EInit:

        default:

            {

            // No requests should be outstanding in these states.

            CLOG(( EHttpLoad, 0, _L("CHttpLoader::DoCancel: unexpected state") ));

            CodPanic( ECodInternal );

            break;

            }

        }

    iResult = KErrCancel;

    Done();

    CLOG(( EHttpLoad, 2, _L("<- CHttpLoader::DoCancel") ));

    }

void CHttpLoader::Pause()

    {

    CLOG(( EHttpLoad, 2, _L("-> CHttpLoader::Pause iState(%d)"), iState ));

    switch ( iState )

        {

        case ERequest:

            {

            CompleteTransaction( KErrCodHttpDownloadPaused );

            break;

            }

        }

    //Done();

    CLOG(( EHttpLoad, 2, _L("<- CHttpLoader::Pause") ));

    }

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

// CHttpLoader::RunL()

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

//

void CHttpLoader::RunL()

    {

    CLOG(( EHttpLoad, 2, _L("-> CHttpLoader::RunL iState(%d) iStatus(%d)"), \

        iState, iStatus.Int() ));

    User::LeaveIfError( iStatus.Int() );    // Handle errors in RunError.

    switch ( iState )

        {

        case EStart:

            {

            // Operation initiated - Open a session.

            OpenSessionL();

            break;

            }

        case EOpen:

            {

            // Session opened. Make the HTTP request.

            RequestL();

            break;

            }

        case ERequest:

            {

            // Request completed, we are done.

            Done();

            break;

            }

        case EInit:

        default:

            {

            // No requests should be outstanding in these states.

            CLOG(( ECodEng, 0, _L("CHttpLoader::RunL: unexpected state") ));

            CodPanic( ECodInternal );

            break;

            }

        }

    CLOG(( EHttpLoad, 2, _L("<- CHttpLoader::RunL") ));

    }

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

// CHttpLoader::RunError()

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

//

TInt CHttpLoader::RunError( TInt aError )

    {

    CLOG(( EHttpLoad, 2, _L("-> CHttpLoader::RunError aError(%d)"), aError ));

    iResult = aError;

    Done();

    CLOG(( EHttpLoad, 2, _L("<- CHttpLoader::RunError") ));

    return KErrNone;

    }

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

// CHttpLoader::MHFRunL()

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

//

void CHttpLoader::MHFRunL

( RHTTPTransaction DEBUG_ONLY( aTransaction ), const THTTPEvent& aEvent )

    {

    CLOG(( EHttpLoad, 0, _L("-> CHttpLoader::MHFRunL event(%d)"), \

                                                            aEvent.iStatus ));

    __ASSERT_DEBUG( aTransaction == iTrans, CodPanic( ECodInternal ) );

    __ASSERT_DEBUG( iState == ERequest, CodPanic( ECodOffState ) );

    StartTimeout();    // There was activity -> restart timeout.

    switch ( aEvent.iStatus )

        {

        case THTTPEvent::EGotResponseHeaders:

            {

            // Now we know that the request was processed by the server.

            iSuppressErrors = EFalse;

            if (iMethod == HTTP::EGET)

            {

                StoreResponseHeaderL();

                //If DD contain TYPE defined more than once, 

            	//TYPE defined in the ClntServ should match the Content-Type that we obtain in the header while content downloading 

           	    const TDesC8& ContentType = GetContentTypeL( iTrans.Response().GetHeaderCollection() );

                const CCodData& CodData = iCodEng->Data();

                for ( TInt i = 1; i < CodData[CodData.ActiveDownload()]->Types().MdcaCount(); i++ )

            		{

          			const TDataType& type( CodData[CodData.ActiveDownload()]->Types().MdcaPoint( i ) );

            		if(ContentType.Find (type.Des8()) != KErrNotFound )             

                		{

                		CodData[CodData.ActiveDownload()]->ReArrangeTypesL(i);

                		iCodEng->ContentTypeChanged();

                		break;

               			}                

            		}

                iCodEng->StoreSubInfoFileL(iResponseHeaders, iCodEng->Data().ActiveDownload() );

            }

            HandleResponseHeadersL( iTrans.Response() );

            if (iResult == KErrCodHttpBadUrl ) 

            {

            	User::Leave( KErrCodHttpBadUrl );

            } 

            else if ( iResult == KErrCodHttpBadResponse ) 

            {

            	User::Leave( KErrCodHttpBadResponse );

            }

            else 

            {

                // Increment progress a bit to make update frequent.

                IncProgressL( KCodRespHdrsTraffic );	

            }

            break;

            }

        case THTTPEvent::EGotResponseBodyData:

            {

            // Get body data and save (GET) or ignore (POST)

            TInt err( KErrNone );

            TInt size;

            MHTTPDataSupplier* body = iTrans.Response().Body();

            TPtrC8 bodyP;

            // Caution: no leaving between body->GetNextDataPart and

            // body->ReleaseData calls! Data must always be released.

#ifdef __TEST_COD_LOG

            TBool lastChunk = // ('Log-only' variable.)

#endif /* def __TEST_COD_LOG */

            body->GetNextDataPart( bodyP );     // No leave...

            size = bodyP.Size();

#ifdef __TEST_COD_LOG

            CDUMP(( EHttpLoad, 5, _S("Data: "), _S("      "), \

                bodyP.Ptr(), bodyP.Size() ));

            if ( lastChunk )

                {

                CLOG(( EHttpLoad, 5, _L("      (EOF)") ));

                }

            else

                {

                CLOG(( EHttpLoad, 5, _L("      (more data)") ));

                }

#endif /* def __TEST_COD_LOG */

            if ( iMethod == HTTP::EGET )

                {

//TODO check  if iSaver == NULL occures                __ASSERT_DEBUG( iSaver, CodPanic( ECodInternal ) );

                if (iSaver)

				{

                  err = iSaver->AppendData( bodyP );

                  iCodEng->UpdateDownloadedSize( bodyP.Size());  

				}

			}

            body->ReleaseData();                // ...until here.

            User::LeaveIfError( err );

            IncProgressL( size );

            break;

            }

        case THTTPEvent::EResponseComplete:

            {

             if(iSaver)

                 {

                 iSaver->OnComplete();

                 }

        	 break;

            }    

        case THTTPEvent::EFailed:

            {

            // Safety code: we should already have an error code.

            if ( iResult == KErrNone )

                {

                iResult = KErrCodWapConnectionDropped;

                }

            // Fall through.

            }

        case THTTPEvent::ESucceeded:

            {

            CompleteTransaction( iResult );

            break;

            }

        case THTTPEvent::ERedirectRequiresConfirmation:

            {

            // 3xx redirect response received for POST. Redirect filter is

            // cautious to redirect POST request and asks for confirmation.

            // Confirmation means that we must resubmit the transaction.

            iTrans.SubmitL();

            break;

            }

        case THTTPEvent::ERedirectedPermanently:

        	{

        	RedirectedPermanentlyL(iTrans.Request().URI().UriDes());

        	break;

        	}

        case THTTPEvent::ERedirectedTemporarily:

        	{

        	RedirectedTemporaryL(iTrans.Request().URI().UriDes());

        	break;

        	}

        default:

            {

            if( aEvent.iStatus == KErrHttpRedirectUseProxy && UseProxyL() )

                {

                // KErrHttpRedirectUseProxy is sent by redirect filter if the

                // response is 305 Use Proxy. This is not really an error;

                // error code is returned only to indicate that the redirect

                // filter cannot handle this kind of redirect automatically;

                // client action is required.

                //

                // If UseProxyL can successfully set the new proxy address,

                // this is not an error. Otherwise it is.

                ;

                }

            else if( aEvent.iStatus == KErrConnectionTerminated )

                {

                // if we get KErrConnectionTerminated during period of time

                // when install-notify timeout is active, that means that

                // connection has closed prior to timer firing and we should

                // not make content available to user, then handle the error

                // normally after that

                CLOG(( EHttpLoad, 2, _L("CHttpLoader::MHFRunL: aEvent.iStatus = KErrConnectionTerminated") ));

                if( iINTimeout && iINTimeout->IsActive() )

                    {

                    CLOG(( EHttpLoad, 2, _L(" :install-notify timeout active: set iSuppressError=EFalse") ));

                    iINTimeout->Cancel();

                    iSuppressErrors = EFalse;

                    }