/*

* Copyright (c) 2002-2004 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:  ?Description

*

*/

// INCLUDE FILES

#include    "HeaderField.h"

#include    "HttpDownloadManagerServerEngine.h"

#include    "HttpClientApp.h"

#include    "FileExt.h"

#include    "HttpDownload.h"

#include    "HttpStorage.h"

#include    "HttpDownloadMgrLogger.h"

#include    "bautils.h"

#include    <CommDbConnPref.h>

#include    <Uri16.h>

#include    <F32FILE.H>

#include    <EscapeUtils.h>

#include    <HttpFilterCommonStringsExt.h>

#include    <tinternetdate.h>

#include    <SysUtil.h>

#include    <MGXFileManagerFactory.h>

#include    <CMGXFileManager.h>

#include    <DcfEntry.h>

#include    <DcfRep.h>

#include    <pathinfo.h>

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

const TInt32 KDMgrInfoFileId = 0x2002;      // id to check if it's really an info file

const TInt32 KDmgrVersionNumber = 0x0301;   // version number of the info file

const TInt   KUrlFixChar = '_';

const TInt KMaxHeaderOfMultipart = 32000;

const TInt KRespSizeForRecognition = 1024;  //for THttpProgressState EHttpContTypeRecognitionAvail

const TInt KMinDataSizeToSend = (32*1024);  //for Browser Control to call NewDownloadL     

_LIT8( KHttpScheme, "http" );

_LIT8( KHttpsScheme, "https" );

_LIT8( KDefDestFilename, "content.bin" );

_LIT8( KSchemeAddon, "://" );

_LIT8( KBoundary, "boundary=" );

_LIT8( KDoubleEOL, "\r\n\r\n" );

_LIT8( KContentType, "Content-Type: " );

#ifdef __SYNCML_DM_FOTA

_LIT8( KFotaMimeType, "application/vnd.nokia.swupd.dp2");

#endif

_LIT8( KDefaultAcceptHeader, "multipart/mixed, application/java-archive, application/java, application/x-java-archive, text/vnd.sun.j2me.app-descriptor, application/vnd.oma.drm.message, application/vnd.oma.drm.content, application/vnd.wap.mms-message, text/x-co/desc, application/vnd.oma.dd+xml, text/javascript, text/javascript, application/x-javascript, text/ecmascript, */*" );

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

_LIT( KIndexString, "(%d)" );

const TInt KMaxIndexStringLength = 16;   // max size of index string "(4294967296)"

_LIT8( KCookieUsage, "CookiesEnabled" );

const TInt KStringAttribMaxLengths[][2] = {

    {EDlAttrReqUrl, KMaxUrlLength},

    {EDlAttrRedirUlr, KMaxUrlLength},

    {EDlAttrCurrentUrl, KMaxUrlLength},

    {EDlAttrName, KMaxPath},

    {EDlAttrRealm,KMaxRealmLength},

    {EDlAttrUsername, KMaxDefAttrLength},

    {EDlAttrPassword, KMaxDefAttrLength},

    {EDlAttrProxyRealm, KMaxRealmLength},

    {EDlAttrProxyUsername, KMaxDefAttrLength},

    {EDlAttrProxyPassword, KMaxDefAttrLength},

    {EDlAttrDestFilename, KMaxPath},

    {EDlAttrContentType, KMaxContentTypeLength},

    {EDlAttrMediaType, KMaxContentTypeLength},

    {0,0}

    };

const TInt KDownloadInfoIncrSize = 2*4096;     // used for DownloadInfo

_LIT( KDownloadPath, "download");

// MACROS

//#define ?macro ?macro_def

#define _OMADLOTA2_MULTI_DOWNLOAD	(iCodDlData && iCodDlData->Count()>1)

// LOCAL CONSTANTS AND MACROS

const TInt KDMHttpErrorBase = -25000;

#define GLOBAL_HTTP_ERROR( err ) ( KDMHttpErrorBase - err )

const TInt  KErrMultipeObjectDownloadFailed = -20046;  

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

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

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

// CHttpDownload::CHttpDownload

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CHttpDownload::CHttpDownload( CHttpClientApp *aClientApp,

                              TInt32 aId,

                              CHttpClientAppInstance* aClAppInstance )

    : CActive( EPriorityStandard )

    , iId( aId )

    , iClientApp( aClientApp )

    , iClAppInstance( aClAppInstance )

    , iPort( KDefaultPort )

    , iDisconnectOnPause( ETrue )

    , iDisconnectOnReset( ETrue )

    , iCodDownload( 0 )

    , iFotaPckgId( KDefaultFotaPckgId )

    , iDate( 0, EJanuary, 1, 0, 0, 0, 0 )

    , iExpires( 0, EJanuary, 1, 0, 0, 0, 0 )

    , iDlState( EHttpDlMultipleMOStarted )

    , iAction( ELaunch )

    , iRestartAction( ERestartIfExpired )

    , iPausable( ETrue )

    , iPausableDRM( ETrue )

    , iDrmContentLengthValid( ETrue )

    , iMultiPart( EFalse )

    , iDlNameChanged(EFalse)

    {

    __ASSERT_DEBUG( iClientApp, DMPanic( KErrArgument ) );

    CLOG_CREATE;

    }

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

// CHttpDownload::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHttpDownload::ConstructL( const TDesC8& aUrl )

    {

    CLOG_NAME_2( _L("cl%x_d%x"), iClientApp->AppUid(), iId );

    LOGGER_ENTERFN( "ConstructL" );

    CLOG_WRITE8_1( "URL: %S", &aUrl );

    CActiveScheduler::Add( this );

    iResponseHeaders = new (ELeave) CArrayPtrFlat<CHeaderField>(2);

    iRequestHeaders = new (ELeave) CArrayPtrFlat<CHeaderField>(2);

    iEntityHeaders = new (ELeave) CArrayPtrFlat<CHeaderField>(2);

    iGeneralHeaders = new (ELeave) CArrayPtrFlat<CHeaderField>(2);

    iStorage = CHttpStorage::NewL( this );

    iActiveDownload = 1 ;

    iMoLength = 0;

    iMoDownloadCompleted = EFalse;

    CLOG_ATTACH( iStorage, this );

    iUrl = aUrl.AllocL();

    if( iUrl->Length() )

        // this is a new download

        {

        ParseRequestedUrlL();   // iCurrentUrl is initialized there

        ParseDownloadNameL();

        StoreDownloadInfoL();

        SetDownloadStatus( EHttpProgNone, EHttpDlMultipleMOStarted );

        }

    else

        {

        LoadDownloadInfoL();

        if( iDlState == EHttpDlInprogress )

            // previous crash left this download here

            // reseting download can solve the problem

            {

            ++iDontFireEvent;

            TRAPD(err, PauseL() );

            --iDontFireEvent;

            User::LeaveIfError( err );

            }

        }

    if( !iStorage->CheckContentFileIntegrityL() )

        {

        if (iStorage->ProgressiveDownload() && 

             iStorage->Length() == iStorage->DownloadedSize() ) 

            // If it was a progressive download 

            // and downloaded size = content length,

            // it means that download was not properly closed

            // in the previous session

            {

            ReInitializeDownload();

            }

        else

            {

            OnError( KErrUnknown, EContentFileIntegrity );

            }

        }

        iMoveInProgress = EFalse;          

    }

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

// CHttpDownload::NewL

// Two-phased constructor.

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

//

CHttpDownload* CHttpDownload::NewL( const TDesC8& aUrl,

                                    CHttpClientApp *aClientApp,

                                    TInt32 aId,

                                    CHttpClientAppInstance* aClAppInstance )

    {

    __ASSERT_DEBUG( aId, DMPanic( KErrArgument ) );

    CHttpDownload* self = new( ELeave ) CHttpDownload( aClientApp,

                                                       aId,

                                                       aClAppInstance );

    CleanupStack::PushL( self );

    self->ConstructL( aUrl );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CHttpDownload::~CHttpDownload()

    {

    ++iDontFireEvent;

    Cancel();

    delete iUrl;

    delete iRedirUrl;

    delete iCurrentUrl;

    delete iHttpRealm;

    delete iHttpNonce;

    delete iHttpUsername;

    delete iHttpPassword;

    delete iHttpProxyRealm;

    delete iHttpProxyUsername;

    delete iHttpProxyPassword;

    delete iContentType;

    delete iDDType;    

    delete iMediaType;

    delete iDlName;

	delete iDispositionType;

    delete iFileMan;

    delete iHashedMsgBody;

    delete iDownloadInfo;

    delete iAttachmentFileName;

    if( iTransValid )

        {

        iTrans.Close();

        }

    if( iResponseHeaders )

        {

        iResponseHeaders->ResetAndDestroy();

        delete iResponseHeaders;

        }

    if( iRequestHeaders )

        {

        iRequestHeaders->ResetAndDestroy();

        delete iRequestHeaders;

        }

    if( iEntityHeaders )

        {

        iEntityHeaders->ResetAndDestroy();

        delete iEntityHeaders;

        }

    if( iGeneralHeaders )

        {

        iGeneralHeaders->ResetAndDestroy();

        delete iGeneralHeaders;

        }

    delete iStorage;

    iStorage = NULL;

    delete iHeaderOfMultipart;

    iMoveInProgress = EFalse;

    CLOG_CLOSE;

    }

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

// CHttpDownload::Attach

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C void CHttpDownload::Attach( CHttpClientAppInstance* aClientAppInstance )

    {

    LOGGER_ENTERFN( "CHttpDownload::Attach" );

    __ASSERT_DEBUG( !iPDClAppInstance, DMPanic( KErrInUse) );

    iPDClAppInstance = aClientAppInstance;

    }

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

// CHttpDownload::StartL

// ?implementation_description

// (other items were commented in a header).

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

//

EXPORT_C void CHttpDownload::StartL()

    {

    LOGGER_ENTERFN( "StartL" );

    __ASSERT_DEBUG( !iNoMedia, DMPanic( KErrAbort ) );

    if( iNoMedia )

        // nomedia download cannot be started

        {

        SetDownloadStatus( EHttpProgNone, EHttpDlFailed, EInternal );

        return;

        }

    if( iContinueDownload )

        // Don't do anything until user accepts the given content

        // to be downloaded.

        {

        CLOG_WRITE( "Continue download" );

        if( !iConnHandler )

            // assign download to the connhandler

            // connection is surely up because it was created from client side

            // iClAppInstance also must be valid because it's a continue download

            {

            iConnHandler = iClAppInstance->ConnHandler();

            }

        if( iDlState == EHttpDlMultipleMOStarted )

            // do it only if EHttpDlCreated, anyway ignore Start request

            {

            iStorage->CreateDestinationFileL();

            SetDownloadStatus( EHttpProgResponseHeaderReceived );

            }

        else if( iDlState == EHttpDlInprogress )

            {

            TriggerEvent( EHttpDlAlreadyRunning );

            }

        // This is the place where client already set every continue

        // download attribute

        StoreDownloadInfoL();

        return;

        }

    if( iCodDownload )

        {

        if(iDlState == EHttpDlPaused)

            {

            if( !iConnHandler )

                {

                iConnHandler = iClAppInstance->ConnHandler();

                }

            SetDownloadStatus( EHttpStarted );

            //TriggerEvent( EHttpDlInprogress, EHttpProgCodDownloadShouldResume );

            }

        else

            {

            TriggerEvent( EHttpDlInprogress, EHttpProgCodDownloadStarted );

            }

        return;

        }

    switch( iDlState )

        {

        case EHttpDlMultipleMOStarted:

            // normal start from the beginning

            break;

        case EHttpDlInprogress:

            if( iUpdatedDDUriSet )

                {

                ReInitializeDownload();

                iStorage->UpdateDestinationFilenameL( KNullDesC, EFalse );

                ParseRequestedUrlL();   // iCurrentUrl is initialized there

                ParseDownloadNameL();

                StoreDownloadInfoL();

                SetDownloadStatus( EHttpStarted );

               if( !iConnHandler )

                    // assign download to the connhandler

                    // connection is surely up because it was created from client side

                    // iClAppInstance also must be valid because it's a continue download

                    {

                    iConnHandler = iClAppInstance->ConnHandler();

                    }

                }

            else

                {

                TriggerEvent( EHttpDlAlreadyRunning );

                }

            return;

        case EHttpDlPaused:

            {

            if( IsExpired() || !iPausable )

                // cannot be resume:

                // expired

                // non-pauseable

                {

                ForcedRestartL();

                }

            }

            break;

        case EHttpDlMultipleMOCompleted:

            {

            if( iRestartAction == ERestartNoIfCompleted )

                // nothing to do because content is downloaded

                // and update check is not interested

                {

                TriggerEvent( EHttpDlMultipleMOCompleted );

                return;

                }

            else if( iRestartAction == ERestartForced )

                // doesn't matter what we have. 

                // Download must be restarted from the very beginning

                {

                ForcedRestartL();

                }

            else if( iRestartAction == ERestartIfExpired )

                // First check that content is expired

                // If so, check for update on the server

                {

                if( !IsExpired() )

                    // content is still valid -> no need to download again

                    // Client has to use ERestartForced or Reset() to

                    // be able to download it again

                    {

                    TriggerEvent( EHttpDlMultipleMOCompleted );

                    return;

                    }

                }

            }

            break;

        case EHttpDlFailed:

            {

            if( NoMedia() )

                // we can't restart because original media is not present.

                // need a reset.

                {

                TriggerEvent( EHttpDlMediaRemoved );

                }

            else if( iRestartAction == ERestartNoIfCompleted )

                {

                if( iLastError == EContentExpired )

                    // Can't download content because it's expired.

                    // Use ERestartIfExpired, ERestartForced or Reset()

                    {

                    OnError( KErrUnknown, EContentExpired );

                    return;

                    }

                }

            }

            break;

        default:

            break;

        }

    if( iRedirect )

        // Requested url has to be restored, because of a previous redirection

        {

        ReallocateStringL( iCurrentUrl, *iRedirUrl, KMaxUrlLength );

        iRedirect = EFalse;

        }

    __ASSERT_DEBUG( iClAppInstance || iPDClAppInstance, DMPanic( KErrCorrupt ) );

    if (iPDClAppInstance && !iClAppInstance )

    //this is the case when browser is the main client and we  exit browser

    //in this case the PD client has to be made the main client.

        {

        iClAppInstance = iPDClAppInstance;

        iPDClAppInstance = NULL;

        }

    if( iClAppInstance )

        {        

        if( !iConnHandler )

            {

            iConnHandler = iClAppInstance->ConnHandler();

            }

        iUseCookies = iClAppInstance->Cookies();

        }

    iDlStartedByClient = ETrue;

    SetDownloadStatus( EHttpStarted );

    }