FCL/sf/mw/web: comparison browserutilities/downloadmgr/DownloadMgrServEng/Src/HttpDownload.cpp

equal deleted inserted replaced

-:d39add9822e2
+:5bfc169077b2
 */
 // INCLUDE FILES
-#include    <browser_platform_variant.hrh>
+//#include <platform/mw/Browser_platform_variant.hrh>
+#include    <Browser_platform_variant.hrh>
 #include    "HeaderField.h"
 #include    "HttpDownloadManagerServerEngine.h"
 #include    "HttpClientApp.h"
 #include    "FileExt.h"
 #include    "HttpDownload.h"
 #include    <CommDbConnPref.h>
 #include    <Uri16.h>
 #include    <F32FILE.H>
 #include    <EscapeUtils.h>
-#include    <httpfiltercommonstringsext.h>
+#include    <HttpFilterCommonStringsExt.h>
 #include    <tinternetdate.h>
 #include    <SysUtil.h>
+// following line is temporary: AVKON dependency removal
+#undef BRDO_APP_GALLERY_SUPPORTED_FF
 #ifdef BRDO_APP_GALLERY_SUPPORTED_FF
 #include    <MGXFileManagerFactory.h>
 #include    <CMGXFileManager.h>
 #endif
 #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
 const TInt KErrCodHttpDownloadPaused = -20045;  //Error code set by the CodHandler if the download is paused by the client
 const TInt KHttp903LossOfService = 903; //Error code set by the CodHandler if connection is lost
 const TInt KHttp954LoaderError = 954; //Error code set by the CodHandler if Loader error is found
 _LIT8( KHttpScheme, "http" );
 _LIT8( KHttpsScheme, "https" );
 #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
 ++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.
 {
 __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;
 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 )
 }
 delete iStorage;
 iStorage = NULL;
 delete iHeaderOfMultipart;
 iMoveInProgress = EFalse;
 CLOG_CLOSE;
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::Attach
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::Attach( CHttpClientAppInstance* aClientAppInstance )
 {
 LOGGER_ENTERFN( "CHttpDownload::Attach" );
 __ASSERT_DEBUG( !iPDClAppInstance, DMPanic( KErrInUse) );
 iPDClAppInstance = aClientAppInstance;
 }
 // -----------------------------------------------------------------------------
 }
 else if( iDlState == EHttpDlInprogress )
 {
 TriggerEvent( EHttpDlAlreadyRunning );
 }
 // This is the place where client already set every continue
 // download attribute
 StoreDownloadInfoL();
 return;
 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
 {
 {
 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 )
 {
 iClAppInstance = iPDClAppInstance;
 iPDClAppInstance = NULL;
 }
 if( iClAppInstance )
 {
 if( !iConnHandler )
 {
 iConnHandler = iClAppInstance->ConnHandler();
 }
 }
 iDlStartedByClient = ETrue;
 SetDownloadStatus( EHttpStarted );
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::PauseL
 // ?implementation_description
 if( iPDClAppInstance )
 {
 SetDownloadStatus( EHttpProgNone, EHttpDlDeleting );
 return;
 }
 }
 }
 }
 // Do not inform user about that we are in deleteing state
 // This won't be reenabled at the end of this function so
 // don't call delete only from outside of this class.
 ++iDontFireEvent;
 TPath folder;
 TFileName file;
 // delete info file
 iClientApp->Engine()->DownloadInfoFolder( iClientApp, folder );
 iClientApp->Engine()->CODDownloadInfoFolder( iClientApp, folder );
 file.Format( _L("%S%d"), &folder, iId );
 //delete main info file
 err = iClientApp->Engine()->Fs().Delete( file );
 CLOG_WRITE_2( "Delete info file: %S, err : %d", &file, err );
 //delete subinfo file
 CFileMan* fileMan = CFileMan::NewL(iClientApp->Engine()->Fs() );
 file.Format( _L("%S%d_*"), &folder, iId );
 fileMan->Delete( file );
 delete fileMan;
 // to make sure the CHttpStorage releases the content file
 // and deletes it.
 CHttpStorage::TFileCloseOperation closeOp = CHttpStorage::EDeleteFile;
 if( iStorage->DestFNameSet() && iDlState == EHttpDlMultipleMOCompleted )
 // Do NOT delete the file: if the destination filename was
 // set by the client and download completed.
 	        {
 	        CLOG_WRITE("Keep file");
 	        closeOp = CHttpStorage::EKeepFile;
 	        }
 	if( iStorage->RFileSetByClient())
 	    {
 	    TBool pausable;
 GetBoolAttributeL( EDlAttrPausable, pausable );
 if( iDlState == EHttpDlMultipleMOCompleted || ( iDlState == EHttpDlInprogress && pausable ) )
 {
 CLOG_WRITE("Keep file");
 	        closeOp = CHttpStorage::EKeepFile;
 }
 	    }
 if( iCodDlData )
 	    {
 	    // For User Delete when all the Downloads are moved to gallery
 	    if( EHttpDlMultipleMOCompleted == iDlState && closeOp == CHttpStorage::EDeleteFile )
 		    {
 		    for(TInt i = 1; i <= iCodDlData->Count(); i++)
 		    	{
 		    	TPtrC fullName = ((*iCodDlData)[i])->DestFilename();
 		    	ClientApp()->Engine()->Fs().Delete( fullName );
 		    	}
 		    }
 		// For User Cancel to Cancel Multiple download, Current and Queued DLs will be delete, completed ones will be kept
 		else if( EHttpDlInprogress == iDlState || EHttpDlPaused == iDlState || EHttpDlDeleting == iDlState)
 			{
 			for(TInt i = 1; i <= iCodDlData->Count(); i++)
 		    	{
 		    	if( EInProgress == ((*iCodDlData)[i])->State() || EFailed == ((*iCodDlData)[i])->State() )	// OnGoing and Queued will be deleted
 			    	{
 			    	TPtrC fullName = ((*iCodDlData)[i])->DestFilename();
 			    	if(fullName.Length())
 			    	    {
 			    	    ClientApp()->Engine()->Fs().Delete( fullName );
 			    	    }
 			    	}
 		    	//else if( ESucceeded == ((*iCodDlData)[i])->State() )
 		    	// Completed ones will be kept and moved to Gallery
 		    	else if( ESucceeded == ((*iCodDlData)[i])->State() )
 			    	{
 			    	MoveInDelete(i);
 			    	}
 		    	}
 			}
 	    }
 else
 	{
 	iStorage->CloseDestinationFile( closeOp );
 	}
 // when delete there's no store -> no leave
 //  aClAppInstance->ClientApp()->UnregisterDownload( this );
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::DeleteInfoFile
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::DeleteInfoFile( CHttpClientAppInstance* aClAppInstance )
 {
 CLOG_WRITE( "DeleteInfoFile()" );
 // This should be called only after the completion of download
 	if( ! (EHttpDlMultipleMOCompleted == iDlState &&
 		(
 		EHttpProgContentFileMoved == iProgState ||
 		EHttpProgContentFileMovedAndDestFNChanged == iProgState
 		)
 	))
 		{
 		return;
 		}
 // Do not inform user about that we are in deleteing state
 // This won't be reenabled at the end of this function so
 // don't call delete only from outside of this class.
 ++iDontFireEvent;
 TPath folder;
 TFileName file;
 // delete info file
 iClientApp->Engine()->DownloadInfoFolder( iClientApp, folder );
 // delete cod info file
 iClientApp->Engine()->CODDownloadInfoFolder( iClientApp, folder );
 file.Format( _L("%S%d"), &folder, iId );
 CLOG_WRITE_1( "Delete info file: %S", &file );
 iClientApp->Engine()->Fs().Delete( file );
 //delete subinfo file
 CFileMan* fileMan = CFileMan::NewL(iClientApp->Engine()->Fs() );
 file.Format( _L("%S%d_*"), &folder, iId );
 fileMan->Delete( file );
 delete fileMan;
 // to make sure the CHttpStorage releases the content file
 // and deletes it.
 CHttpStorage::TFileCloseOperation closeOp = CHttpStorage::EDeleteFile;
 if( iStorage->DestFNameSet() && iDlState == EHttpDlMultipleMOCompleted )
 // Do NOT delete the file: if the destination filename was
 // set by the client and download completed.
 {
 CLOG_WRITE("Keep file");
 closeOp = CHttpStorage::EKeepFile;
 }
 iStorage->CloseDestinationFile( closeOp );
 // when delete there's no store -> no leave
 aClAppInstance->ClientApp()->UnregisterDownload( this );
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::MoveL
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::MoveL()
 {
 LOGGER_ENTERFN( "MoveL" );
 if(iMoveInProgress)
 {
 	CLOG_WRITE(" return MoveL  ");
 	return;
 }
 if( iProgState == EHttpProgMovingContentFile )
 {
 User::Leave( KErrInUse );
 }
 //File is already moved. Ignore the move
 if( iProgState == EHttpProgContentFileMovedAndDestFNChanged ||
 	iProgState ==  EHttpProgContentFileMoved )
 {
 return;
 }
 __ASSERT_DEBUG( !IsActive(), DMPanic( KErrInUse ) );
 //__ASSERT_DEBUG( !iFileMan, DMPanic( KErrInUse ) );
 if(_OMADLOTA2_MULTI_DOWNLOAD)
 {
 		iMOMoved = 1;
 		SetDownloadStatus( EHttpProgMovingContentFile, iDlState );
 		MoveDownloadedMediaObjectL(iMOMoved);
 	RFs &rFs = iClientApp->Engine()->Fs();
 	if(!iFileMan)
 		{
 		iFileMan = CFileMan::NewL(rFs);
 		}
 CLOG_WRITE_1( "Src: %S", iStorage->LocalFilename() );
 CLOG_WRITE_1( "Dest: %S", iStorage->DestFilename() );
 UpdateDestFileNameL();
 do
 {
 CreateIndexedNameL(uniqueName , fileNamePtr , index);
 if( !BaflUtils::FileExists( rFs , *uniqueName ) )
 //Check if file name exist in Destination path
 //Generate Unique name if exist
 {
 bFound =ETrue;
 break;
 }
 iDlNameChanged = ETrue;
 }while( !bFound );
 CleanupStack::PopAndDestroy( fileName );
 	if( iDlNameChanged )
 	    {
 	    HBufC16* destFileName ;
 	    destFileName = iStorage->DestFilename();
 	    TPtr destFileNamePtr = destFileName->Des();
 	    destFileNamePtr.Replace(0, destFileNamePtr.Length() , *uniqueName);
 	    TInt lastSlashPos = destFileNamePtr.LocateReverse( '\\' );
 	    TPtr dlName = destFileNamePtr.MidTPtr(lastSlashPos +1 );
 TInt dotPos = iDlName->LocateReverse( '.' );
 if( dotPos == KErrNotFound )
 {
 //Remove Extension from dlName as it was not present in old iDlName
 dotPos = dlName.LocateReverse( '.' );
 if(dotPos != KErrNotFound )
 {
 dlName.Copy( dlName.Left(dotPos));
 }
 }
 	    //download name has changed
 	    ReallocateStringL( iDlName, dlName, KDownloadNameMaxSize );
 	    }
 	TInt err =iFileMan->Move( *iStorage->LocalFilename(),
 *iStorage->DestFilename(),
 CFileMan::EOverWrite,
 iStatus );
 if(err != KErrNone)
 	{
 	iMoveInProgress = EFalse;
 	CLOG_WRITE("setting iMoveInProgress false when move fails");
 	}
 User::LeaveIfError( err );
 // waiting for move to complete
 SetActive();
 SetDownloadStatus( EHttpProgMovingContentFile, iDlState );
 }
 // CHttpDownload::GetIntAttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::GetIntAttributeL( THttpDownloadAttrib aAttribute,
 							                   TInt32& aValue )
 {
 LOGGER_ENTERFN( "GetIntAttributeL" );
 CLOG_WRITE_1( "Attr(%d)", aAttribute );
 case EDlAttrMultipleMOLength:
 {
 if ( iCodDownload )
 {
 aValue = iMoLength;
 }
 else
 {
 aValue = iStorage->Length();
 }
 case EDlAttrMultipleMODownloadedSize:
 {
 if( iCodDownload )
 {
 aValue = iStorage->MoDownloadedSize();
 }
 else
 {
 aValue = iStorage->DownloadedSize();
 }
 }
 break;
 case EDlAttrLength:
 {
 aValue = iStorage->Length();
 }
 break;
 aValue = iMethod;
 }
 break;
 case EDlAttrFotaPckgId:
 {
 aValue = iFotaPckgId;
 }
 break;
 case EDlAttrNumMediaObjects:
 {
 aValue = 1;
 if(iCodDlData)
 {
 case EDlAttrActivePlayedDownload:
 {
 aValue = iActivePlayedDownload;
 }
 break;
-case EDlAttrDestRemovable:
-{
-aValue = iStorage->RemovableDest();
-}
-break;
 default:
 {
 CLOG_WRITE_1( "Unknown int attrib: %d", aAttribute );
 #ifdef __WINS__
 DMPanic( KErrArgument );
 User::Leave( KErrArgument );
 #endif
 }
 break;
 }
 iNoRealError = EFalse;
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::GetIntAttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::GetIntAttributeL( THttpDownloadAttrib aAttribute,
 							                   TInt32& aMoIndex,
 							                   TInt32& aValue )
 {
 LOGGER_ENTERFN( "GetIntAttributeL" );
 CLOG_WRITE_1( "Attr(%d)", aAttribute );
 if (!iCodDlData)
 	{
 	aValue = 0;
 	return;
 	}
 if ((aMoIndex <= KNonMoIndex) || (aMoIndex > iCodDlData->Count()))
 	{
 	User::Leave( KErrArgument );
 	}
 CMediaDataBase* mediaData = (*iCodDlData)[aMoIndex];
 iNoRealError = ETrue;
 switch( aAttribute )
 {
 	{
 	CMediaDataBase* moData = (*iCodDlData)[index+1];
 	if ((moData->State() == ESucceeded) || (moData->State() == EInProgress))
 		dlSize -= moData->DownloadedSize();
 	}
 aValue = dlSize;
 }
 break;
 case EDlAttrLength:
 	        {
 	        aValue = iStorage->Length();
 	        }
 	        break;
 break;
 case EDlAttrMethod:
 {
 aValue = mediaData->Method();
-}
-break;
-case EDlAttrDestRemovable:
-{
-aValue = mediaData->DesRemovable();
 }
 break;
 default:
 {
 User::Leave( KErrArgument );
 #endif
 }
 break;
 }
 iNoRealError = EFalse;
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::GetBoolAttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::GetBoolAttributeL( THttpDownloadAttrib aAttribute,
 								                TBool& aValue )
 {
 LOGGER_ENTERFN( "GetBoolAttributeL" );
 CLOG_WRITE_1( "Attr(%d): %d", aAttribute );
 case EDlAttrCodDownload:
 {
 aValue = iCodDownload;
 }
 break;
 case EDlAttrProgressive:
 {
 aValue = iStorage->ProgressiveMode();
 }
 break;
 case EDlAttrDestRemovable:
 {
-aValue = (KDriveAttRemovable == iStorage->RemovableDest()) ? ETrue : EFalse ;
+aValue = iStorage->RemovableDest();
 }
 break;
 case EDlAttrCodPdAvailable:
 {
 User::Leave( KErrArgument );
 #endif
 }
 break;
 }
 iNoRealError = EFalse;
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::GetBoolAttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::GetBoolAttributeL( THttpDownloadAttrib aAttribute,
 								                TInt32& aMoIndex,
 								                TBool& aValue )
 {
 LOGGER_ENTERFN( "GetBoolAttributeL" );
 CLOG_WRITE_1( "Attr(%d): %d", aAttribute );
 if (!iCodDlData)
 	{
 	aValue = 0;
 	return;
 	}
 if ((aMoIndex <= KNonMoIndex) || (aMoIndex > iCodDlData->Count()))
 	{
 	User::Leave( KErrArgument );
 	}
 CMediaDataBase* mediaData = (*iCodDlData)[aMoIndex];
 iNoRealError = ETrue;
 switch( aAttribute )
 {
 case EDlAttrProgressive:
 {
 aValue = mediaData->ProgressiveDownload();
 }
 break;
 case EDlAttrDestRemovable:
 {
-aValue = (KDriveAttRemovable == mediaData->DesRemovable()) ? ETrue : EFalse ;
+aValue = mediaData->DesRemovable();
 }
 break;
 default:
 {
 User::Leave( KErrArgument );
 #endif
 }
 break;
 }
 iNoRealError = EFalse;
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::GetStringAttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C HBufC* CHttpDownload::GetStringAttributeL( THttpDownloadAttrib aAttribute,
 TBool& aDelete )
 {
 LOGGER_ENTERFN( "GetStringAttributeL" );
 CLOG_WRITE_1( "Attr(%d): %d", aAttribute );
 case EDlAttrDDType:
 {
 attr8 = iDDType;
 }
 break;
 case EDlAttrRealm:
 {
 attr8 = iHttpRealm;
 }
 case EDlAttrLocalFileName:
 {
 attr = iStorage->LocalFilename();
 }
 break;
 case EDlAttrDdFileName:
 	{
 	attr = iStorage->DdFileName();
 	}
 	break;
 break;
 }
 }
 }
 break;
 case EDlAttrAlbumName:
 {
 if (iCodDlData && (iCodDlData->Name().Compare(KNullDesC)))
 {
 attr = iCodDlData->Name().AllocL();
 {
 attr = iDlName;
 }
 }
 break;
 default:
 {
 {
 CLOG_WRITE_1( "Unknown string8 attrib: %d", aAttribute );
 #ifdef __WINS__
 // CHttpDownload::GetStringAttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C HBufC* CHttpDownload::GetStringAttributeL( THttpDownloadAttrib aAttribute,
 TInt32& aMoIndex,
 TBool& aDelete )
 {
 LOGGER_ENTERFN( "GetStringAttributeL" );
 CLOG_WRITE_1( "Attr(%d): %d", aAttribute );
 	}
 if ((aMoIndex <= KNonMoIndex) || (aMoIndex > iCodDlData->Count()))
 	{
 	User::Leave( KErrArgument );
 	}
 CMediaDataBase* mediaData = (*iCodDlData)[aMoIndex];
 iNoRealError = ETrue;
 HBufC* attr = NULL;
 HBufC8* attr8 = NULL;
 // CHttpDownload::GetString8AttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C HBufC8* CHttpDownload::GetString8AttributeL( THttpDownloadAttrib aAttribute,
 TBool& aDelete )
 {
 LOGGER_ENTERFN( "GetString8AttributeL" );
 CLOG_WRITE_1( "Attr(%d): %d", aAttribute );
 case EDlAttrDDType:
 {
 attr = iDDType;
 }
 break;
 case EDlAttrRequestHeaderAddon:
 {
 TChar colon( KColon );
 TInt32 length( 0 );
 }
 }
 break;
 case EDlAttrHashedMsgBody:
 {
 attr = iHashedMsgBody;
 }
 break;
 case EDlAttrMediaType:
 {
 attr = iMediaType;
 }
 break;
 case EDlAttrMediaTypeBoundary:
 {
 attr = GetParamFromMediaTypeL( KBoundary() ).AllocL();
 aDelete = ETrue;
 }
 break;
 default:
 {
 {
 CLOG_WRITE_1( "Unknown string8 attrib: %d", aAttribute );
 #ifdef __WINS__
 // CHttpDownload::GetString8AttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C HBufC8* CHttpDownload::GetString8AttributeL( THttpDownloadAttrib aAttribute,
 TInt32& aMoIndex,
 TBool& aDelete )
 {
 LOGGER_ENTERFN( "GetString8AttributeL" );
 CLOG_WRITE_1( "Attr(%d): %d", aAttribute );
 	}
 if ((aMoIndex <= KNonMoIndex) || (aMoIndex > iCodDlData->Count()))
 	{
 	User::Leave( KErrArgument );
 	}
 CMediaDataBase* mediaData = (*iCodDlData)[aMoIndex];
 iNoRealError = ETrue;
 HBufC8* attr = NULL;
 HBufC* attr16 = NULL;
 {
 attr = mediaData->Type().AllocL();
 aDelete = ETrue;
 }
 break;
 default:
 {
 {
 CLOG_WRITE_1( "Unknown string8 attrib: %d", aAttribute );
 #ifdef __WINS__
 // -----------------------------------------------------------------------------
 //
 EXPORT_C RFile* CHttpDownload::GetFileHandleAttributeL()
 {
 LOGGER_ENTERFN( "GetFileHandleAttributeL" );
 if( !iStorage->File() )
 // destination file is not opened
 {
 User::Leave( KErrArgument );
 }
 // CHttpDownload::SetIntAttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::SetIntAttributeL( THttpDownloadAttrib aAttribute,
 const TInt32 aValue )
 {
 LOGGER_ENTERFN( "SetIntAttributeL" );
 CLOG_WRITE_2( "Attr(%d): %d", aAttribute, aValue );
 TBool store( ETrue );
 break;
 case EDlAttrAction:
 	{
 TBool PdSupported(EFalse);
 iAction = (THttpDownloadMgrAction)aValue;
 if(iClAppInstance)
 	{
 	TRAP_IGNORE(iClAppInstance->GetBoolAttributeL(EDlMgrProgressiveDownload, PdSupported));
 	}
 }
 break;
 case EDlAttrMultipleMOLength:
 {
 iMoLength = aValue;
 }
 break;
 case EDlAttrDownloadedSize:
 {
 if( (iCodDownload || iContinueDownload) && iDlState == EHttpDlInprogress )
 {
 iStorage->SetDownloadedSize( aValue );
 // Calculate downloaded size of current media object from
 // album downloaded size.
 TInt dlSize = iStorage->DownloadedSize();
 if( iCodDlData )
 {
 for (TInt index = 0; index < iCodDlData->Count() ; ++index)
 	{
 	if( iActiveDownload - 1 == index )
 	    {
 	    //the size of active download has already been taken into account
 	    continue;
 	    }
 	CMediaDataBase* moData = (*iCodDlData)[index+1];
 	if ((moData->State() == ESucceeded) || (moData->State() == EInProgress))
 		dlSize += moData->DownloadedSize();
 	}
 iStorage->SetMoDownloadedSize(dlSize);
 }
 if( iStorage->Length() != KDefaultContentLength &&
 iStorage->DownloadedSize() > iStorage->Length() )
 // we don't know actually how many bytes will come down.
 {
 CLOG_WRITE( "Length modified" );
 iStorage->SetLength( KDefaultContentLength );
 StoreDownloadInfoL();
 }
 TriggerEvent( EHttpDlInprogress, EHttpProgResponseBodyReceived );
 }
 store = EFalse;
 }
 break;
 case EDlAttrSucceeded:
 {
 if(!aValue)
 DownloadSucceededL();
 else
 iMoDownloadCompleted = ETrue;//Download of MO has been Completed so change State ,But PD is on
 //So MOVE will be issued by PD Client
 store = EFalse;
 }
 break;
 case EDlAttrDefaultEvent:
 {
 }
 break;
 case EDlAttrMethod:
 {
 if( iContinueDownload && iDlState == EHttpDlMultipleMOStarted &&
 ( aValue == EMethodGET ||
 aValue == EMethodPOST ||
 }
 }
 break;
 case EDlAttrFotaPckgId:
 {
 iFotaPckgId = aValue;
 store = EFalse;
 }
 break;
 case EDlAttrActiveDownload:
 {
 iActiveDownload = aValue;
 // Active MO changed. Notify clients.
 	TriggerEvent( EHttpDlCreated, EHttpProgNone );
 }
 break;
 case EDlAttrActivePlayedDownload:
 {
 iActivePlayedDownload = aValue;
 }
-break;
-case EDlAttrDestRemovable:
-{
-if( iCodDownload )
-{
-iStorage->SetRemovableDest( aValue );
-if (iCodDlData)
-{
-// Update for Active media object.
-TInt active = iActiveDownload;
-CMediaDataBase* mediaData = (*iCodDlData)[active];
-mediaData->SetDesRemovable( aValue );
-}
-}
-}
 break;
 default:
 {
 #ifdef __WINS__
 DMPanic( KErrArgument );
 }
 UpdatePausable();
 iNoRealError = EFalse;
 if( store )
 {
 StoreDownloadInfoL();
 }
 }
 // CHttpDownload::SetBoolAttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::SetBoolAttributeL( THttpDownloadAttrib aAttribute,
 								                const TBool aValue )
 {
 LOGGER_ENTERFN( "SetBoolAttributeL" );
 CLOG_WRITE_2( "Attr(%d): %d", aAttribute, aValue );
 TBool store( ETrue );
 }
 else
 {
 User::Leave( KErrInUse );
 }
 store = EFalse;
 }
 break;
 case EDlAttrHidden:
 case EDlAttrCodDownload:
 {
 SetCodFlag( aValue );
 }
 break;
 case EDlAttrProgressive:
 {
 TBool PdSupported(EFalse);
 if(iClAppInstance)
 	{
 	TRAP_IGNORE(iClAppInstance->GetBoolAttributeL(EDlMgrProgressiveDownload, PdSupported));
 	}
 if(PdSupported)
 {
 iStorage->SetProgressiveMode( aValue );
 if(!aValue)
 {
 iActivePlayedDownload = 0;
 }
 if (iCodDlData)
 	{
 	// Update for Active media object.
 	                TInt active = iActiveDownload;
 	                CMediaDataBase* mediaData = (*iCodDlData)[active];
 	                mediaData->SetProgressiveDownload( aValue );
 	}
 if( iProgState != EHttpProgMovingContentFile )
 {
 if (aValue && iDlState == EHttpDlMultipleMOCompleted )
 {
 /*
 if the file size is small, by the time the music player is launched, DMgr already triggered EHttpDlCompleted.
 So if the download state is EHttpDlMultipleMOCompleted, we need to trigger EHttpDlCompleted so that music player understands download is completed already
 This is needed to ensure backward compatibility
 */
 TriggerEvent( EHttpDlCompleted, EHttpDlProgProgressive);
 }
 else
 {
 TriggerEvent( iDlState, aValue ? EHttpDlProgProgressive : EHttpDlProgNonProgressive);
 }
 }
 }
 else
 {
 				TriggerEvent( iDlState, EHttpDlProgNonProgressive);
 				}
 }
 break;
 case EDlAttrCodDescriptorAccepted:
 {
 TriggerEvent( EHttpDlInprogress, EHttpProgCodDescriptorAccepted );
 }
 break;
 case EDlAttrCodLoadEnd:
 {
 SetDownloadStatus(EHttpProgCodLoadEnd,EHttpDlInprogress);
 }
 break;
 {
 iCodPdAvailable = aValue;
 TriggerEvent( EHttpDlInprogress, EHttpProgCodPdAvailable );
 }
 break;
 case EDlAttrDestRemovable:
 {
 if( iCodDownload )
 {
-TInt32 removableDestStatus = (aValue) ? KDriveAttRemovable : KDriveAttLocal ;
+iStorage->SetRemovableDest( aValue );
-iStorage->SetRemovableDest( removableDestStatus );
+if (iCodDlData)
-if (iCodDlData)
 	{
 	                // Update for Active media object.
 	                TInt active = iActiveDownload;
 	                CMediaDataBase* mediaData = (*iCodDlData)[active];
-	                mediaData->SetDesRemovable( removableDestStatus );
+	                mediaData->SetDesRemovable( aValue );
 	}
 }
 }
 break;
 case EDlAttrCodPausable:
 {
 iPausable = aValue;
 			// Update for Active media object.
 TInt active = iActiveDownload;
 CMediaDataBase* mediaData = (*iCodDlData)[active];
 mediaData->SetPausable( aValue );
 // inform client about change
 TriggerEvent( iPausable ? EHttpDlPausable : EHttpDlNonPausable );
 			}
 break;
 default:
 #ifdef __WINS__
 DMPanic( KErrArgument );
 #else
 User::Leave( KErrArgument );
 #endif
 break;
 }
 UpdatePausable();
 iNoRealError = EFalse;
 if( store )
 {
 StoreDownloadInfoL();
 switch( aAttribute )
 {
 case EDlAttrDestFilename:
 {
 TBool updateFName = EFalse;
 if( iDlState == EHttpDlMultipleMOStarted ||
 iDlState == EHttpDlMultipleMOCompleted ||
 iCodDownload )
 // cannot set this attribute while
 // download is in progress
 {
 if( !aValue.Length() )
 {
 updateFName = ETrue;
 {
 updateFName = ETrue;
 }
 else
 {
 User::Leave( KErrArgument );
 }
 }
 else
 // Invalid filename passed
 {
 }
 else
 {
 User::Leave( KErrInUse );
 }
 if (updateFName)
 	{
 iStorage->UpdateDestinationFilenameL( aValue, ETrue );
 if (iCodDlData)
 	{
 	            	CMediaDataBase* mediaData = (*iCodDlData)[aMOIndex];
 	            	mediaData->SetDestFilenameL( aValue );
 	            	}
 	}
 }
 break;
 }
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::SetStringAttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::SetStringAttributeL( THttpDownloadAttrib aAttribute,
 								                  const TDesC16& aValue )
 {
 LOGGER_ENTERFN( "SetStringAttributeL" );
 CLOG_WRITE_2( "Attr(%d - %d)", aAttribute, aValue.Length () );
 TBool store( ETrue );
 if( iDlState == EHttpDlInprogress )
 {
 CLOG_WRITE( "EDlAttrContentType updated" );
 ReallocateStringL( iContentType, aValue, KMaxContentTypeLength );
 TriggerEvent( EHttpDlInprogress, EHttpProgContentTypeChanged );
 // Update for Active media object.
 HBufC8* type8 = HBufC8::NewLC( aValue.Length() );
 type8->Des().Copy( aValue );
 if (iCodDlData)
 	{
 	                TInt active = iActiveDownload;
 	                CMediaDataBase* mediaData = (*iCodDlData)[active];
 	                mediaData->SetTypeL( type8->Des() );
 	                CleanupStack::PopAndDestroy( type8 );
 {
 if( iContinueDownload && iDlState == EHttpDlMultipleMOStarted )
 {
 ReallocateStringL( iHttpRealm, aValue, KMaxRealmLength );
 }
 store = EFalse;
 }
 break;
 case EDlAttrUsername:
 break;
 case EDlAttrDestFilename:
 {
 TBool updateFName = EFalse;
 if( iDlState == EHttpDlMultipleMOStarted ||
 iDlState == EHttpDlMultipleMOCompleted ||
 iCodDownload )
 // cannot set this attribute while
 // download is in progress
 {
 if( !aValue.Length() )
 {
 updateFName = ETrue;
 {
 updateFName = ETrue;
 }
 else
 {
 User::Leave( KErrArgument );
 }
 }
 else
 // Invalid filename passed
 {
 }
 else
 {
 User::Leave( KErrInUse );
 }
 if (updateFName)
 	{
 	iStorage->UpdateDestinationFilenameL( aValue, ETrue );
 if (iCodDlData)
 	{
 TInt moIndex(0);
 if( iActiveDownload != iActivePlayedDownload && iStorage->ProgressiveDownload() )
 {
 //MP has set the Destination File Name
 moIndex = iActivePlayedDownload;
 }
 else
 {
 // Update for Active media object.
 	moIndex = iActiveDownload;
 }
 	            	CMediaDataBase* mediaData = (*iCodDlData)[moIndex];
 	            	mediaData->SetDestFilenameL( aValue );
 	            	}
 	}
 if( iCodDownload )
 {
 SetDownloadNameL( aValue );
 if (iCodDlData)
 	                {
 	                // Update for Active media object.
 	            	TInt active = iActiveDownload;
 	            	CMediaDataBase* mediaData = (*iCodDlData)[active];
 	            	mediaData->SetNameL( aValue );
 	                }
 // CHttpDownload::SetStringAttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::SetStringAttributeL( THttpDownloadAttrib aAttribute,
 								                  const TDesC8& aValue )
 {
 LOGGER_ENTERFN( "SetStringAttributeL(8)" );
 CLOG_WRITE_2( "Attr(%d - %d)", aAttribute, aValue.Length () );
 TBool store( ETrue );
 ReallocateStringL( iContentType, aValue, KMaxContentTypeLength );
 TriggerEvent( EHttpDlInprogress, EHttpProgContentTypeChanged );
 }
 else if (iDlState == EHttpDlMultipleMOCompleted )//Allow to change content type even if state is completed
 {
 ReallocateStringL( iContentType, aValue, KMaxContentTypeLength );
 //No need to trigger any event
 }
 }
 break;
 case EDlAttrRealm:
 {
 case EDlAttrHashedMsgBody:
 {
 ReallocateStringL( iHashedMsgBody, aValue, KHashLength );
 }
 break;
 case EDlAttrRedirectedPermanently:
 {
 RedirectedPermanentlyL( aValue );
 if (iCodDlData)
 	            {
 	            // Update for Active media object.
 	            TInt active = iActiveDownload;
 	            CMediaDataBase* mediaData = (*iCodDlData)[active];
 	            if (!mediaData->Redirected())
 	            	mediaData->SetRedirUrlL( aValue );
 	            }
 }
 break;
 case EDlAttrRedirectedTemporary:
 {
 RedirectedTemporaryL( aValue );
 if (iCodDlData)
 	            {
 	            // Update for Active media object.
 	            TInt active = iActiveDownload;
 	            CMediaDataBase* mediaData = (*iCodDlData)[active];
 	            mediaData->SetRedirected( ETrue );
 	            }
 }
 break;
 case EDlAttrContinueBody:
 {
 iNoRealError = EFalse;
 ResponseBodyReceivedL( aValue );
 store = EFalse;
 #else
 User::Leave( KErrArgument );
 #endif
 break;
 }
 UpdatePausable();
 iNoRealError = EFalse;
 if( store )
 {
 StoreDownloadInfoL();
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::SetFileHandleAttributeL( RFile* aFile )
 {
 LOGGER_ENTERFN( "SetFileHandleAttributeL" );
 iStorage->AdoptFileHandleL( aFile );
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::SetDownloadDataAttributeL
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::SetDownloadDataAttributeL( HBufC8* dlData )
 	{
 LOGGER_ENTERFN( "SetDownloadDataAttributeL" );
 if (iCodDlData)
 {
 	delete iCodDlData;
 iCodDlData = NULL;
 }
 iCodDlData = CDownloadDataServ::NewL(*dlData);
 TInt downloadedSize = 0 ;
 TBool activeDownloadChanged = EFalse;
 iMoLength = 0 ;
 for ( TInt i = 1; i <= iCodDlData->Count() ; ++i )
 {
 downloadedSize = downloadedSize + (*iCodDlData)[i]->DownloadedSize();
 iMoLength += (*iCodDlData)[i]->Size();
 iStorage->SetDownloadedSize( (*iCodDlData)[i]->DownloadedSize() );
 iStorage->SetLength( (*iCodDlData)[i]->Size() );
 activeDownloadChanged = ETrue;
 }
 }
 iStorage->SetMoDownloadedSize( downloadedSize );
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::SetTrackDataAttributeL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CHttpDownload::SetTrackDataAttributeL( TInt aIndex, HBufC8* dlData )
 {
 LOGGER_ENTERFN( "SetTrackDataAttributeL" );
 	if (iCodDlData)
 	{
 	CMediaDataServ* updatedMediaData = CMediaDataServ::NewL(*dlData);
 	CMediaDataBase* mediaData = (*iCodDlData)[aIndex];
 	mediaData->SetNameL(updatedMediaData->Name());
 	    mediaData->SetState( updatedMediaData->State() );
 	    mediaData->SetResult( updatedMediaData->Result() );
 	    mediaData->SetDownloadedSize( updatedMediaData->DownloadedSize() );
 	    mediaData->SetDestFilenameL( updatedMediaData->DestFilename() );
 	    mediaData->SetTempFilenameL( updatedMediaData->DestFilename() );
 	mediaData->ResetTypes();
 	for (TInt type = 0; type < updatedMediaData->TypesCount(); ++type)
 	mediaData->AddTypeL( updatedMediaData->Types().MdcaPoint(type) );
 mediaData->SetStatusCode( updatedMediaData->StatusCode() );
 TInt result = updatedMediaData->Result();
 	        	    {
 	        	    iGlobalErrorId = result;
 	        	    iLastError = EGeneral;
 	           	    }
 }
 //if the client pauses the download, Codhandler sets error code to KErrCodHttpDownloadPaused. In that case, no need to trigger EHttpDlFailed Event
 if ( !( result == KErrCodHttpDownloadPaused || ( pausable && statusCode == KHttp903LossOfService ) || ( pausable && statusCode == KHttp954LoaderError ) ) )
 {
 	        TriggerEvent( EHttpDlFailed, EHttpProgNone );
 }
 }
 	}
 }
 {
 CLOG_WRITE( "No real error" );
 iNoRealError = EFalse;
 return;
 }
 if( iCodDlData && iCodDlData->Count() > 1 )
 {
 if( aDlError == KErrMultipeObjectDownloadFailed )
 {
 //Permanently failed error in CodHandler
 //Delete the download
 SetDownloadStatus( EHttpProgNone,
 EHttpDlMultipleMOFailed,
 aDlError,
 aError );
 return;
 }
 else
 {
 SetDownloadStatus( EHttpProgNone,
 EHttpDlPaused,
 aDlError,
 aError );
 return;
 }
 }
 if( iDlState < EHttpDlCreated )
 // error occured during download object construction -> nothing to do here
 }
 //For COD Downloads, the error code may be set from COD handler
 //In that case if the download is paused just set the global and download error
 if( iCodDownload && iDlState == EHttpDlPaused )
 {
 iLastError = aDlError;
 iGlobalErrorId = aError;
 TRAP_IGNORE( StoreDownloadInfoL() );
 return;
 CHttpStorage::TFileCloseOperation closeOp = CHttpStorage::EKeepFile;
 if ( !Pausable() && ( iCodDlData && iCodDlData->Count() == 1 ) )
 {
 closeOp = CHttpStorage::EReplaceFile;
 }
 iStorage->CloseDestinationFile( closeOp );
 CLOG_WRITE_1( "OnError1 : iDlState : %d ", iDlState );
 if( iDlState != EHttpDlMultipleMOFailed )
 {
 }
 }
 if( aError == KErrHttpPartialResponseReceived )
 {
 //Partial response has been received and connection has been disconnected. This error will be
 //propagated to the client only, if the HTTP:ENotifyOnDisconnect property is set with a value
 //HTTP::EEnableDisconnectNotification
 //This error code was cancelling the pausable download. This error shud be ignored to keep the
 //paused download.
 //TSW Err ID : SXUU-77SRWL
 SetDownloadStatus( EHttpProgNone,
 EHttpDlPaused,
 aDlError,
 aError );
 }
 else if( aDlError == EConnectionFailed && iPausable)
 {
 //Whenever connection error occurs and download can be paused.
 //Keep the download in paused state.
 SetDownloadStatus( EHttpProgNone,
 EHttpDlPaused,
 aDlError,
 aError );
 }
 else if ( aDlError == EMMCRemoved )
 {
 // MMC removed. Pause the download.
 SetDownloadStatus( EHttpProgNone,
 }
 else if( iPDClAppInstance == aInstance )
 {
 iPDClAppInstance = NULL;
 }
 return (iPDClAppInstance || iClAppInstance);
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::ClientApp
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::MediaRemoved( TUint aUid, TBool aDontCheckMediaUid )
 {
 LOGGER_ENTERFN( "MediaRemoved" );
 CLOG_WRITE_3( "Uid: %d, dontCheck: %d, iNoMedia: %d",
 aUid,
 aDontCheckMediaUid,
 iNoMedia );
 if( iNoMedia )
 // it is already known for us.
 {
 iNoMedia = ETrue;
 TRAP_IGNORE( InternalPauseL() );
 TriggerEvent( EHttpDlMediaRemoved );
 if( iDlState == EHttpDlInprogress )
 // it's happened during the download process
 // in case of e.g completed download it's not error
 {
 OnError( KErrGeneral, EMMCRemoved );
 }
 TRAP_IGNORE( StoreDownloadInfoL() );
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::MediaInserted
 }
 iNoMedia = EFalse;
 TriggerEvent( EHttpDlMediaInserted );
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::GetDestinationDriveID
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 TInt CHttpDownload::GetDestinationDriveID() const
 {
 return (TInt)iStorage->GetDestinationDriveId();
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::SetClientInstance
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::SetDownloadNameL( const TDesC& aNewName )
 {
 CLOG_WRITE_1( "New download name: [%S]", &aNewName );
 ReallocateStringL( iDlName, aNewName, KDownloadNameMaxSize );
 FixDownloadNameL();
 TriggerEvent( EHttpDlInprogress, EHttpProgDlNameChanged );
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::MHFRunL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::MHFRunL( RHTTPTransaction /*aTransaction*/,
 const THTTPEvent& aEvent )
 {
 switch ( aEvent.iStatus )
 {
 case THTTPEvent::EGotResponseHeaders:
 {
 CLOG_WRITE( "Response header received" );
 ResponseHeaderReceivedL();
 }
 break;
 case THTTPEvent::EGotResponseBodyData:
 {
 MHTTPDataSupplier* respBody = iTrans.Response().Body();
 respBody->GetNextDataPart( buf );
 ResponseBodyReceivedL( buf );
 respBody->ReleaseData();
 }
 break;
 case THTTPEvent::EResponseComplete:
 {
 CLOG_WRITE( "Response complete" );
 }
 break;
 case THTTPEvent::ESucceeded:
 {
 CLOG_WRITE( "Transaction succeeded" );
 DownloadSucceededL();
 }
 break;
 case THTTPEvent::EFailed:
 case THTTPEvent::EMoreDataReceivedThanExpected:
 case THTTPEvent::EUnrecoverableError:
 {
 iTrans.Close();
 iTransValid = EFalse;
 }
 iDlStartedByClient = EFalse;
 }
 break;
 case THTTPEvent::ERedirectedPermanently:
 {
 RedirectedPermanentlyL( iTrans.Request().URI().UriDes() );
 }
 break;
 case THTTPEvent::ERedirectedTemporarily:
 {
 RedirectedTemporaryL( iTrans.Request().URI().UriDes() );
 }
 break;
 default:
 {
 CLOG_WRITE_1( "Event: %d", aEvent.iStatus );
 if( aEvent.iStatus < 0 )
 // error occured -> leave will be handled in OnError()
 {
 User::Leave( aEvent.iStatus );
 }
 }
 break;
 }
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::MHFRunError
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 TInt CHttpDownload::MHFRunError( TInt aError,
 RHTTPTransaction /*aTransaction*/,
 const THTTPEvent& /*aEvent*/ )
 {
 CLOG_WRITE_1( "MHFRunError: %d", aError );
 OnError( aError, ETransactionFailed );
 TriggerEvent( EHttpDlInprogress, EHttpProgCodDownloadShouldResume );
 }
 else
 {
 RequestContentL();
 }
 }
 }
 break;
 case EHttpProgMovingContentFile:
 // Move completed
 // State remains in completed
 // and move result stored in error attribs
 {
 CLOG_WRITE_1( "Move result: %d", iStatus.Int() );
 // In case of PDL for OMA2 the MP/VP moves the file after the playback is done.
 			// So, the download status should be changed after that
 			//but we again send the progress state as EHttpProgContentFileMoved because we need to display
 			//where file is saved(saved to gallery)
 			//Change Dl State to Download Completed if not already
 		    if(_OMADLOTA2_MULTI_DOWNLOAD)
 				{
 				TPtrC fileNamePtr = ((*iCodDlData)[iMOMoved])->DestFilename();
 				NotifyMediaGalleryL(fileNamePtr);
 					MoveDownloadedMediaObjectL(iMOMoved);
 					break;
 					}
 				}
 SetDownloadStatus( iDlNameChanged ? EHttpProgContentFileMovedAndDestFNChanged : EHttpProgContentFileMoved,
 iDlState = EHttpDlMultipleMOCompleted,
 iStatus == KErrNone ? ENoError : EMoveFailed,
 iStatus.Int() );
 if(iStatus == KErrNone)
 	{
 	iMoveInProgress = EFalse;
 	CLOG_WRITE("setting iMoveInProgress false when move is completed");
 	}
 delete iFileMan; iFileMan = NULL;
 			if( !_OMADLOTA2_MULTI_DOWNLOAD)
 				{
 				TPtr fileNamePtr(iStorage->DestFilename()->Des());
 				NotifyMediaGalleryL(fileNamePtr);
 				}
 // we are not interested in this event,
 // only if the download is in progress.
 {
 return;
 }
 //Set the errors
 TRAP_IGNORE( PauseL( ETrue ) );
 iLastError = EConnectionFailed;
 iGlobalErrorId = KErrCommsLineFail;
 }
 iPausableDRM = ETrue;
 iDrmContentLengthValid = ETrue;
 // content type is unknown -> download might be pausable again
 UpdatePausable();
 if( !aOnDelete )
 {
 TRAP_IGNORE( StoreDownloadInfoL() );
 }
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::StoreDownloadInfoL()
 {
 LOGGER_ENTERFN( "StoreDownloadInfoL" );
 TInt bufSz = KDownloadInfoIncrSize +
 (iDownloadInfo ? iDownloadInfo->Length(): 0);
 HBufC8* newInfo = HBufC8::NewLC( bufSz );
 TPtr8 newInfoPtr = newInfo->Des();
 APPEND_BUF_INT( newInfoPtr, KDMgrInfoFileId );
 APPEND_BUF_INT( newInfoPtr, iExpires );
 APPEND_BUF_INT( newInfoPtr, iMaxAge );
 CLOG_WRITE("5");
 TInt size = GetHttpHeadersSize(iResponseHeaders)+ GetHttpHeadersSize(iRequestHeaders)+
 GetHttpHeadersSize(iEntityHeaders)+ GetHttpHeadersSize(iGeneralHeaders) + newInfoPtr.Size();
 if(size >= bufSz)
 {
 	User::LeaveIfError( KErrArgument );
 }
 AppendHeadersL( newInfoPtr, iResponseHeaders );
 AppendHeadersL( newInfoPtr, iRequestHeaders );
 AppendHeadersL( newInfoPtr, iEntityHeaders );
 AppendHeadersL( newInfoPtr, iGeneralHeaders );
 CLOG_WRITE("6");
 APPEND_BUF_INT( newInfoPtr, iFotaPckgId );
 CLOG_WRITE("7");
 // check if download info is unchanged from previous update
 if( iDownloadInfo && ( iDownloadInfo->Compare(*newInfo) == 0 ))
 {
 // no change
 CLOG_WRITE("DownloadInfo unchanged - no need to update");
 HBufC* fileNameBuf = HBufC::NewLC( KMaxPath );
 TPtr fileName = fileNameBuf->Des();
 iClientApp->Engine()->DownloadInfoFolder( iClientApp, folder );
 fileName.Format( _L("%S%d"), &folder, iId );
 CLOG_WRITE_1( "info: %S", &fileName );
 RFile outFile;
 CleanupClosePushL<RFile>( outFile );
 User::LeaveIfError( outFile.Replace( iClientApp->Engine()->Fs(),
 fileName,
 EFileShareExclusive |
 EFileStream |
 EFileWrite ) );
 outFile.Write( newInfoPtr );
 User::LeaveIfError( outFile.Flush() );
 CleanupStack::PopAndDestroy( 2, fileNameBuf );
 fileName.Format( _L("%S%d"), &folder, iId );
 CLOG_WRITE_1( "info: %S", &fileName );
 RFile inFile;
 User::LeaveIfError( inFile.Open( iClientApp->Engine()->Fs(),
 fileName,
 EFileShareReadersOnly |
 EFileRead ) );
 CLOG_WRITE("1");
 CleanupClosePushL<RFile>( inFile );
 	    User::Leave( KErrNotSupported );
 	   }
 ReadHBufCL( inFile, iHashedMsgBody );
 READ_INT_L( inFile, iCodDownload );
 READ_INT_L( inFile, iNoMedia );
 CLOG_WRITE("3");
 READ_INT_L( inFile, iPreferencies );
 READ_INT_L( inFile, iDisconnectOnPause );
 READ_INT_L( inFile, iDisconnectOnReset );
 LoadHeadersL( inFile, iResponseHeaders );
 LoadHeadersL( inFile, iRequestHeaders );
 LoadHeadersL( inFile, iEntityHeaders );
 LoadHeadersL( inFile, iGeneralHeaders );
 CLOG_WRITE("6");
 READ_INT_L( inFile, iFotaPckgId );
 CleanupStack::PopAndDestroy(); // inFile
 CleanupStack::PopAndDestroy( 2, folderBuf ); // also fileNameBuf
 CLOG_WRITE("9");
 UpdatePausable();
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::IsExpired
 // -----------------------------------------------------------------------------
 //
 TBool CHttpDownload::IsContentFileStorageType()
 {
 if( iCodDownload
 && iContentType->Compare( KRoapMimeType )
 && iContentType->Compare( KRoapPduMimeType )
 && iContentType->Compare( KFotaPackageDataType)  )
 {
 	 return ETrue;
 }
 return EFalse;
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::OnCompletedL
 // ?implementation_description
 {
 CLOG_WRITE( "CHttpDownload::OnCompletedL(): triggering event EHttpResponseForContentType" );
 TriggerEvent( EHttpDlInprogress, EHttpContTypeRecognitionAvail );
 iContTypeRecognitionAvailSent = ETrue;
 }
 //for correct display of string in download list for COD download we set progress state to moved
 if(IsContentFileStorageType())
 {
 // Retrieve the file name from the whole paths
 HBufC* fileName = iStorage->DestFilename();
 TInt lastSlashPos = fileName->LocateReverse( '\\' );
 namePtr.Copy( fileName->Right(fileName->Length()-lastSlashPos-1) );
 TInt findDot = iDlName->LocateReverse( '.' );
 if( findDot == KErrNotFound )
 {
 //if Name displayed does not have Extension then
 // Remove extention from retrieved name
 TInt dotInd = namePtr.LocateReverse( '.' );
 if( dotInd == KErrNotFound )
 dotInd = namePtr.Length();
 namePtr.Copy( namePtr.Left( dotInd ) );
 }
 //we never get file moved and Download complete for Cod download becuase move is inherent
 //to Install() state i.e  Download is in progress so display in download list is incorrect.
 //related to bug  HCHA-753D6G
 if(namePtr.Compare(*iDlName))
 {
 ReallocateStringL( iDlName, namePtr, KDownloadNameMaxSize );
 SetDownloadStatus( EHttpProgContentFileMovedAndDestFNChanged, EHttpDlMultipleMOCompleted );
 }
 else
 {
 SetDownloadStatus( EHttpProgContentFileMoved, EHttpDlMultipleMOCompleted );
 }
 CleanupStack::PopAndDestroy( name );
 }
 else
 {
 TriggerEvent( EHttpDlCompleted, EHttpProgNone );
 SetDownloadStatus( EHttpProgNone, EHttpDlMultipleMOCompleted );
 }
 }
 Cancel();
 Disconnect();
 iStorage->OnComplete();
 // this is a special case because transaction don't need to be
 // canceled, only deleted
 iContinueDownload = EFalse;
 if( iTransValid )
 {
 iTrans.Close();
 User::LeaveIfError( start );
 start += aAttribute.Length();
 TInt end = iMediaType->Des().Mid( start, length-start ).Locate( KSemiColon );
 TInt boundaryLength = ( KErrNotFound == end ) ? length - start : end;
 TPtrC8 ptr = iMediaType->Des().Mid( start, boundaryLength );
 return ptr;
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::ReInitializeDownload
 // ?implementation_description
 if( iContinueDownload )
 {
 TriggerEvent( EHttpDlCancelTransaction );
 }
 iContinueDownload = EFalse;
 iDlStartedByClient = EFalse;
 }
 default:
 {
 DMPanic( KErrArgument );
 }
 }
 TRAP_IGNORE( StoreDownloadInfoL() ); //saving the state
 if( !eventTriggered )
 {
 TriggerEvent( iDlState, iProgState );
 case 404:   // Not Found
 {
 OnError( KErrUnknown, EObjectNotFound );
 }
 break;
 default:
 {
 SetDownloadStatus( EHttpProgNone,
 EHttpDlFailed,
 EHttpUnhandled,
 GLOBAL_HTTP_ERROR( iStatusCode ) );
 }
 }
 }
 else
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::ResponseBodyReceivedL( const TDesC8& aBuf )
 {
 if( iMultiPart && !iCodDownload )
 {
 TBool isSupportedMultiPart( EFalse );
 // If it leaves isSupportedMultiPart remains false -> does not supported!
 TRAP_IGNORE( isSupportedMultiPart = IsMultipartSupportedL( aBuf ) );
 if( isSupportedMultiPart )
 {
 SetCodFlag( ETrue );
 TriggerEvent( EHttpDlInprogress, EHttpProgSupportedMultiPart );
 }
 }
 TBool ret(ETrue);
 if( iStorage->BufferingEnabled() )
 	{
 	// Buffering is enabled, just pass on the data
 	ret = iStorage->WriteOutNextBodyDataL(aBuf);
 	}
 else
 	{
 	// Buffering not yet enabled, see how much data we still have to write without buffering
 	TInt bytesToWrite = aBuf.Length();
 	TInt downloadedSize = iStorage->DownloadedSize();
 	if(bytesToWrite + downloadedSize < KMinDataSizeToSend)
 		{
 		// Just dump non-buffered write
 		ret = iStorage->WriteOutNextBodyDataL( aBuf );
 		}
 	else
 		{
 		// Necessary to switch to buffered writing
 		TInt leftPartSize = KMinDataSizeToSend - downloadedSize;
 		TInt rightPartSize = bytesToWrite - leftPartSize;
 		TBool ret1 = ETrue;
 		TBool ret2 = ETrue;
 		if(leftPartSize > 0)
 			{
 			// Write left side of the block to get alignment matched
 			ret1 = iStorage->WriteOutNextBodyDataL( aBuf.Left(leftPartSize) );
 			}
 		// Enable buffering
 		iStorage->EnableBufferingL();
 		// And push the rest of this data block
 		if(rightPartSize > 0)
 			{
 			ret2 = iStorage->WriteOutNextBodyDataL( aBuf.Right(rightPartSize) );
 			}
 		if(!ret1 || !ret2)
 			{
 			ret = EFalse;
 			}
 		}
 }
 if( !iContTypeRecognitionAvailSent && (iStorage->DownloadedSize() >= KRespSizeForRecognition) )
 {
 TriggerEvent( EHttpDlInprogress, EHttpContTypeRecognitionAvail );
 iContTypeRecognitionAvailSent = ETrue;
 }
 TriggerEvent( EHttpDlInprogress, EHttpProgResponseBodyReceived );
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::IsMultipartSupportedL
 // -----------------------------------------------------------------------------
 //
 TBool CHttpDownload::IsMultipartSupportedL( const TDesC8& aBuf )
 {
 TBool ret( EFalse );
 if( !iHeaderOfMultipart )
 {
 iHeaderOfMultipart = HBufC8::NewL( KMaxHeaderOfMultipart );
 }
 TInt full_length = iHeaderOfMultipart->Length() + aBuf.Length();
 else
 {
 ret = EFalse;
 return ret;
 }
 TInt pos = iHeaderOfMultipart->Des().Find( KContentType() );
 User::LeaveIfError( pos );
 pos = pos + KContentType().Length();
 TPtrC8 p = iHeaderOfMultipart->Des().Mid( pos );
 TInt temp = p.Find( KDoubleEOL() );
 TInt posEol = pos + temp;
 TPtrC8 ptr = iHeaderOfMultipart->Des().Mid( pos, ( posEol - pos ) );
 if( 0 == ptr.Find( KDdMimeType() ) ||
 0 == ptr.Find( KDd2MimeType() ) ||
 0 == ptr.Find( KCodMimeType() ))
 {
 ret = ETrue;
 delete iHeaderOfMultipart;
 iHeaderOfMultipart = NULL;
 return ret;
 }
 return ret;
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::Connect
 // ?implementation_description
 SetRequestHeaderAddOnL( aStringPool, aHeaders );
 SetCredentialsInfoL( aStringPool );
 // Find ETag in response header
 RStringF etag = aStringPool.StringF(HTTP::EETag,
 RHTTPSession::GetTable());
 TInt fieldInd = FindHeaderField( iResponseHeaders, etag.DesC() );
 if( fieldInd != KErrNotFound )
 // ETag is known. ETag identifies the content. Set If-Match to see
 // that if it's changed, or a redirection goes to another url.
 // Server will respond with 412 on error.
 {
 RStringF ifMatch = aStringPool.StringF(HTTP::EIfMatch,
 RHTTPSession::GetTable());
 aHeaders.RemoveField( ifMatch );
 aHeaders.SetRawFieldL( ifMatch,
 *(*iResponseHeaders)[fieldInd]->FieldRawData(),
 KHttpFieldSeparator );
 CLOG_WRITE8_1( "ETag: %S", (*iResponseHeaders)[fieldInd]->FieldRawData() );
 }
 if( aHeadMethod )
 RStringF field;
 if( iStorage->DownloadedSize() != iStorage->Length() )
 // download from previous point only if the content is unmodified
 {
 field = aStringPool.StringF(HTTP::EIfUnmodifiedSince,
 RHTTPSession::GetTable());
 SetExpireToFieldL( field, aStringPool, aHeaders );
 }
 }
 // CHttpFilterAuthentication::SetPropertyL
 // Set property of the transaction
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::SetPropertyL( RStringPool& aStringPool,
 RStringF aPropertyName,
 const TDesC8& aToken )
 {
 RString tokenStr = aStringPool.OpenStringL( aToken );
 THTTPHdrVal tokenVal = tokenStr;
 CleanupClosePushL( tokenStr );
 // -----------------------------------------------------------------------------
 // CHttpFilterAuthentication::SetPropertyL
 // Set property of the transaction
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::SetPropertyL( RStringF aPropertyName,
 const TInt aValue )
 {
 THTTPHdrVal tokenVal = aValue;
 iTrans.PropertySet().RemoveProperty( aPropertyName );
 {
 LOGGER_ENTERFN( "SetCredentialsInfoL" );
 if( iHttpUsername )
 {
 RStringF username = aStringPool.StringF( HTTP::EUsername,
 RHTTPSession::GetTable() );
 SetPropertyL( aStringPool, username, *iHttpUsername );
 }
 if( iHttpPassword )
 {
 RStringF password = aStringPool.StringF( HTTP::EPassword,
 RHTTPSession::GetTable() );
 SetPropertyL( aStringPool, password, *iHttpPassword );
 }
 if( iHttpRealm )
 {
 RStringF realm = aStringPool.StringF( HTTP::ERealm,
 RHTTPSession::GetTable() );
 SetPropertyL( aStringPool, realm, *iHttpRealm );
 }
 if( iHttpProxyRealm )
 {
 RStringF proxyRealmStr = aStringPool.StringF(
 HttpFilterCommonStringsExt::EProxyRealm,
 HttpFilterCommonStringsExt::GetTable() );
 SetPropertyL( aStringPool, proxyRealmStr, *iHttpProxyRealm );
 }
 if( iHttpProxyUsername )
 {
 RStringF proxyUsernameStr = aStringPool.StringF(
 HttpFilterCommonStringsExt::EProxyUsername,
 HttpFilterCommonStringsExt::GetTable() );
 SetPropertyL( aStringPool, proxyUsernameStr, *iHttpProxyUsername );
 }
 if( iHttpProxyPassword )
 {
 RStringF proxyPasswordStr = aStringPool.StringF(
 HttpFilterCommonStringsExt::EProxyPassword,
 HttpFilterCommonStringsExt::GetTable() );
 SetPropertyL( aStringPool, proxyPasswordStr, *iHttpProxyPassword );
 }
 if( iHttpNonce )
 {
 RStringF nonce = aStringPool.StringF( HTTP::ENonce,
 RHTTPSession::GetTable() );
 SetPropertyL( aStringPool, nonce, *iHttpNonce );
 }
 }
 // CHttpDownload::SetExpireToFieldL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::SetExpireToFieldL( RStringF& aField,
 RStringPool& aStringPool,
 RHTTPHeaders& aHeaders )
 {
 LOGGER_ENTERFN( "SetExpireToFieldL" );
 TInt expInd( KErrNotFound );
 TInt modInd( KErrNotFound );
 for( TInt i = 0; i < iResponseHeaders->Count(); ++i )
 // FindHeaderField, because this is double search for fieldnames
 {
 if( *(*iResponseHeaders)[i]->FieldName() == expires.DesC() )
 {
 expInd = i;
 continue;
 if( expInd != KErrNotFound )
 {
 CLOG_WRITE8_1( "Expire: %S", (*iResponseHeaders)[expInd]->FieldRawData() );
 aHeaders.RemoveField( aField );
 aHeaders.SetRawFieldL( aField,
 *(*iResponseHeaders)[expInd]->FieldRawData(),
 KHttpFieldSeparator );
 }
 else if( modInd != KErrNotFound )
 {
 CLOG_WRITE8_1( "LastMod: %S", (*iResponseHeaders)[modInd]->FieldRawData() );
 aHeaders.RemoveField( aField );
 aHeaders.SetRawFieldL( aField,
 *(*iResponseHeaders)[modInd]->FieldRawData(),
 KHttpFieldSeparator );
 }
 }
 // -----------------------------------------------------------------------------
 {
 LOGGER_ENTERFN( "ParseRequestedUrlL" );
 __ASSERT_DEBUG( iUrl->Length(), DMPanic( KErrArgument ) );
 TUriParser8 uri;
 uri.Parse( *iUrl );
 TPtrC8 scheme( uri.Extract( EUriScheme ) );
 if( scheme != KHttpScheme &&
 scheme != KHttpsScheme )
 // unsupported or no scheme in url.
 // Insert 'http://' to the beginning of it.
 {
 HBufC8* tempBuf = HBufC8::NewL( KHttpScheme().Length() +
 KSchemeAddon().Length() +
 iUrl->Length() );
 tempBuf->Des().Append( KHttpScheme );
 tempBuf->Des().Append( KSchemeAddon );
 tempBuf->Des().Append( *iUrl );
 url->SetComponentL( uri.Extract( EUriHost ), EUriHost );
 url->SetComponentL( uri.Extract( EUriPath ), EUriPath );
 url->SetComponentL( uri.Extract( EUriUserinfo ), EUriUserinfo );
 url->SetComponentL( uri.Extract( EUriQuery ), EUriQuery );
 url->SetComponentL( uri.Extract( EUriFragment ), EUriFragment );
 if( uri.IsPresent( EUriPort ) )
 {
 url->SetComponentL( uri.Extract( EUriPort ), EUriPort );
 }
 else
 LOGGER_ENTERFN( "ParseDownloadNameL" );
 // Calculate the download name from the requested URL
 HBufC8* parsedUrl = EscapeUtils::EscapeDecodeL( *iCurrentUrl );
 CleanupStack::PushL( parsedUrl );
 TUriParser8 uri;
 uri.Parse( *parsedUrl );
 TPtrC8 path;
 path.Set( uri.Extract( EUriPath ) );
 if( slash == KErrNotFound )
 {
 slash = path.LocateReverse( '\\' );
 }
 if( slash != KErrNotFound && slash != path.Length() )
 // from the last slash this is the filename
 {
 TPtrC8 temp( path.Right( path.Length() - slash - 1 ) );
 CHeaderField* field = CHeaderField::NewL( &fieldNameStr.DesC(), &rawData );
 CleanupStack::PushL( field );
 CLOG_WRITE8_2("%S:%S", &fieldNameStr.DesC(), &rawData);
 iResponseHeaders->AppendL( field );
 CleanupStack::Pop( field );
 CHeaderField* entityField = CHeaderField::NewL( &fieldNameStr.DesC(), &rawData );
 CleanupStack::PushL( entityField );
 CLOG_WRITE8_2("%S:%S", &fieldNameStr.DesC(), &rawData);
 iEntityHeaders->AppendL( entityField );
 CleanupStack::Pop( entityField );
 ++it;
 }
 ParseContentTypeL( strPool );
 ParseContentDispositionL( strPool);
 if (!iCodDownload)
 {
 		if (iUseAttachmentFileName || iUseInlineFileName)
 	        {
 }
 else
 //This is a partial response as Length is already set so save this new length as partial Length that needs to be Downloaded.
 {
 iStorage->SetPartialContentLength( value );
 }
 }
 CheckRealDRMContentType();
 if( !iDrmContentLengthValid )
 // Content was original encoded -> we don't know the actual content size.
 {
 iStorage->SetLength( KDefaultContentLength );
 }
 iMaxAge = 0;
 TInt parts( 0 );
 // this leave is trapped because we can still go on
 TRAPD( err, parts = headers.FieldPartsL( cacheControl ) );
 {
 LOGGER_ENTERFN( "CheckRealDRMContentType" );
 iPausableDRM = ETrue;
 iDrmContentLengthValid = ETrue;
 TInt index = FindHeaderField( iResponseHeaders, KDRMOldContentType );
 if( index != KErrNotFound )
 // this is an old DRM protected content
 // This transaction cannot be paused.
 {
 {
 iPausableDRM = EFalse;
 //            iDrmContentLengthValid = EFalse;
 }
 }
 UpdatePausable();
 CLOG_WRITE_2( "Pausable: [%d], Length: [%d]", iPausableDRM, iDrmContentLengthValid );
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::SaveCredentialsL
 //
 void CHttpDownload::SaveCredentialsL( RStringPool aStringPool )
 {
 LOGGER_ENTERFN( "SaveCredentialsL" );
 RStringF username = aStringPool.StringF( HTTP::EUsername,
 RHTTPSession::GetTable() );
 RStringF password = aStringPool.StringF( HTTP::EPassword,
 RHTTPSession::GetTable() );
 RStringF realm = aStringPool.StringF( HTTP::ERealm,
 RHTTPSession::GetTable() );
 RStringF nonce = aStringPool.StringF( HTTP::ENonce,
 RHTTPSession::GetTable() );
 THTTPHdrVal hdrValue;
 // Realm
 {
 ReallocateStringL( iHttpPassword, hdrValue.Str().DesC(), KMaxDefAttrLength );
 CLOG_WRITE8_1( "pwd: [%S]", iHttpPassword );
 }
 if( !iTrans.PropertySet().Property(
 aStringPool.StringF( HTTP::EBasic,
 RHTTPSession::GetTable() ),
 hdrValue ) )
 // this is a digest authentication response
 // store nonce value
 {
 if( iTrans.PropertySet().Property( nonce, hdrValue ) )
 LOGGER_ENTERFN( "RequestContentL" );
 RStringPool strPool = iConnHandler->Session().StringPool();
 RStringF method;
 TBool aHead = ETrue;
 if( (iContentType && iContentType->Length()) ||
 iNoContentTypeCheck ||
 iSilentMode )
 // we know the content type -> head is already requested or
 // every content type is welcome
 // content type check needed -> first request HEAD
 {
 method = strPool.StringF( HTTP::EHEAD,RHTTPSession::GetTable() );
 }
 TUriParser8 uri;
 uri.Parse( *iCurrentUrl );
 CLOG_WRITE8_1( "Req URL: %S", iCurrentUrl );
 CLOG_WRITE8_1( "Method: %S", &method.DesC() );
 THTTPHdrVal hdrValue;
 RStringPool strPool = iConnHandler->Session().StringPool();
 // Check authentication scheme
 TBool basic = iTrans.PropertySet().Property( strPool.StringF( HTTP::EBasic,
 RHTTPSession::GetTable() ),
 hdrValue );
 if( basic )
 // property is set -> Basic
 {
 // Check authentication scheme
 THTTPHdrVal hdrValue;
 RStringPool strPool = iConnHandler->Session().StringPool();
 TInt err = iTrans.PropertySet().Property( strPool.StringF( HTTP::EBasic,
 RHTTPSession::GetTable() ),
 hdrValue );
 if( !err )
 // property is set -> Basic
 {
 // CHttpDownload::CreateIndexedNameL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::CreateIndexedNameL( HBufC* &aUniqueName,
 TDesC& aOrgName,
 TInt& aIndex )
 {
 LOGGER_ENTERFN( "CreateIndexedNameL" );
 TPtrC left;
 {
 left.Set( aOrgName.Left( KDownloadNameMaxSize - indexStr.Length() ));
 }
 aUniqueName = HBufC::NewL( fullLength );
 aUniqueName->Des().Format( _L("%S%S%S"), &left,
 &indexStr,
 &extension );
 ++aIndex;
 }
 // CHttpDownload::ContinueDownloadStoreResponseHeaderL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::ContinueDownloadStoreResponseHeaderL(
 const TDesC8& aResponseHeader )
 {
 LOGGER_ENTERFN( "ContinueDownloadStoreResponseHeaderL" );
 TInt colon( KErrNotFound );
 CLOG_WRITE8_2("%S:%S", &fieldName, &fieldValue);
 iResponseHeaders->AppendL( newField );
 CleanupStack::Pop( newField );
 CHeaderField* newentField = CHeaderField::NewL( &fieldName, &fieldValue );
 CleanupStack::PushL( newentField );
 CLOG_WRITE8_2("%S:%S", &fieldName, &fieldValue);
 iEntityHeaders->AppendL( newentField );
 ReallocateStringL( iContentType, rawData, KMaxContentTypeLength );
 ReallocateStringL( iDDType, rawData, KMaxContentTypeLength );
 ReallocateStringL( iMediaType, mediaType, KMaxContentTypeLength );
 }
 #ifdef __SYNCML_DM_FOTA
 if( !iContentType->Des().CompareF( KFotaMimeType ) )
 {
 iStorage->SetStorageMethod( CHttpStorage::EStoreFota );
 }
 #endif
 ( 0 == iContentType->Des().Compare( KDdMimeType()  ) ) ||
 ( 0 == iContentType->Des().Compare( KDd2MimeType()  ) ) )
 {
 SetCodFlag( ETrue );
 }
 if( 0 == iContentType->Des().Compare( KMultiPartMimeType() ) )
 {
 iMultiPart = ETrue;
 }
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::ParseContentDispositionL
 // ?implementation_description
 		if( isFileNameParam && (0 == iDispositionType->Des().CompareC( KHttpDispositionTypeInline()) ) )
 			{
 			ReallocateStringL( iAttachmentFileName, fileNameParm );
 			iUseInlineFileName = ETrue;
 			}
 }
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::TriggerEvent
 // ?implementation_description
 if( !iPausableDRM )
 {
 pausable = EFalse;
 }
 if( iMethod == EMethodPOST )
 {
 pausable = EFalse;
 }
 if( pausable != iPausable )
 {
 if( !iCodDownload )
 {
 	iPausable = pausable;
 	// inform client about change
 TriggerEvent( iPausable ? EHttpDlPausable : EHttpDlNonPausable );
 TRAP_IGNORE( StoreDownloadInfoL() );
 }
 // CHttpDownload::CheckAttribMaxLengthL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::CheckAttribMaxLengthL( THttpDownloadAttrib aAttribute,
 	                                       const TDesC16& aValue )
 {
 for( TInt i = 0; KStringAttribMaxLengths[i][0]; ++i )
 {
 if( aAttribute == KStringAttribMaxLengths[i][0] )
 {
 if( aValue.Length() > KStringAttribMaxLengths[i][1] )
 {
 CLOG_WRITE_2( "Overflow length: %d, max-length: %d", aValue.Length(),
 KStringAttribMaxLengths[i][1] );
 User::Leave( KErrOverflow );
 }
 }
 }
 // CHttpDownload::CheckAttribMaxLengthL
 // ?implementation_description
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::CheckAttribMaxLengthL( THttpDownloadAttrib aAttribute,
 	                                       const TDesC8& aValue )
 {
 for( TInt i = 0; KStringAttribMaxLengths[i][0]; ++i )
 {
 if( aAttribute == KStringAttribMaxLengths[i][0] )
 {
 if( aValue.Length() > KStringAttribMaxLengths[i][1] )
 {
 CLOG_WRITE_2( "Overflow length: %d, max-length: %d", aValue.Length(),
 KStringAttribMaxLengths[i][1] );
 User::Leave( KErrOverflow );
 }
 }
 }
 // Find out if this is a native request header field, or not.
 // If not, fieldInd is KErrNotFound
 for( TInt i = 0; KRequestHeaderConvTable[i][0]; ++i )
 {
 RStringF fieldNameStr = strPool.StringF( KRequestHeaderConvTable[i][1],
 RHTTPSession::GetTable() );
 if( !fieldName.CompareF( fieldNameStr.DesC() ) )
 // this is a native header field name
 {
 // -----------------------------------------------------------------------------
 // CHttpDownload::LoadHeadersL
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::LoadHeadersL( RFile& aFile,
 CArrayPtrFlat<CHeaderField>* aHeaders )
 {
 TInt headers;
 READ_INT_L( aFile, headers );
 }
 else
 {
 CLOG_WRITE8( "Empty field" );
 }
 */
 CleanupStack::Pop( field );
 }
 }
 // -----------------------------------------------------------------------------
 TInt headers = aHeaders->Count();
 CLOG_WRITE_1("Headers: %d", headers);
 HBufC8* fieldName = NULL;
 HBufC8* fieldRawData = NULL;
 TInt size  = 0;
 for( TInt i = 0; i < headers; ++i )
 {
 fieldName = (*aHeaders)[i]->FieldName();
 fieldRawData = (*aHeaders)[i]->FieldRawData();
 size = size + fieldName->Size() +  fieldRawData->Size();
 CLOG_WRITE8_1( "Size = %d:", size );
 }
 return size;
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::AddHeaderL
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::AddHeaderL( THttpDownloadAttrib aAttribute,
 								const TDesC8& aValue,
 const TInt aConversionTable[][2],
 CArrayPtrFlat<CHeaderField>* aHeaders )
 {
 TInt index( KErrNotFound );
 // search for if this field is already in the
 for( index = 0; aConversionTable[index][0]; ++index )
 {
 if( aConversionTable[index][0] == aAttribute )
 {
 break;
 }
 __ASSERT_DEBUG( index != KErrNotFound, DMPanic( KErrCorrupt ) );
 RStringPool strPool = iClAppInstance->ConnHandler()->Session().StringPool();
 RStringF fieldName = strPool.StringF( aConversionTable[index][1],
 RHTTPSession::GetTable() );
 CleanupClosePushL( fieldName );
 // make a copy of the raw data
 HBufC8* value = HBufC8::NewLC( aValue.Length() );
 aHeaders->AppendL( newField );
 CleanupStack::Pop( 2 ); // newField, fieldName
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::RedirectedPermanentlyL
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::RedirectedPermanentlyL( const TDesC8& aNewUrl )
 ReallocateStringL( iRedirUrl, aNewUrl, KMaxUrlLength );
 ReallocateStringL( iCurrentUrl, *iRedirUrl, KMaxUrlLength );
 }
 else
 // there has already been a temporary redirection
 // this permanent is not used on next submitted request
 {
 ReallocateStringL( iCurrentUrl, aNewUrl, KMaxUrlLength );
 }
 ParseDownloadNameL();
 StoreDownloadInfoL();   // to store new url
 ParseDownloadNameL();
 StoreDownloadInfoL();   // to store iRedirect
 TriggerEvent( EHttpDlInprogress, EHttpProgRedirectedTemporarily );
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::FixDownloadNameL
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::FixDownloadNameL()
 {
 if( !iCodDownload )
 {
 TPtr name( iDlName->Des() );
 for( TInt i = 0; i < name.Length(); ++i )
 {
 TChar currChar = (*iDlName)[i];
 if( currChar.IsAlphaDigit() ||
 currChar.IsGraph() ||
 currChar == 0x20 )  // space
 {
 continue;
 }
 else
 {
 name[i] = KUrlFixChar;
 }
 }
 ConvertDownloadNameUniqueL();
 }
 }
 // -----------------------------------------------------------------------------
 //
 void CHttpDownload::SetCodFlag( TBool aValue )
 {
 if( aValue && iCodDownload )
 {
 // this case we will not overwrite
 // the value of iCodDownload. iCodDownload might be > 1
 return;
 }
 iCodDownload = aValue;
 }
 TBool needToUpdatePath( ETrue );
 CLOG_WRITE_1( " entering fileName: %S", fileName );
 #ifdef RD_MULTIPLE_DRIVE
 HBufC8* drivesDynList = iClientApp->Engine()->QueryDynDriveListLC();
 TPtrC8 drives( *drivesDynList );
 #else
 TPtrC drives( iClientApp->Engine()->iDriveLettersCenRep );
 #endif
 // drive letters are separated by semicolons
 for( TInt i = 0; i < drives.Length() && (err || !criticalSpace); i = i + 2 )
 else
 {
 TInt bytesToWrite = downloadedSize;
 if (bytesToWrite < 0)
 bytesToWrite = 0;
 TRAP( err, criticalSpace = !SysUtil::DiskSpaceBelowCriticalLevelL(
 &fs, bytesToWrite, drive ));
 }
 }
 if( needToUpdatePath )
 {
 iDlNameChanged = ETrue;
 #ifdef RD_MULTIPLE_DRIVE
 if( lastSlashPos != KErrNotFound )
 {
 fileNamePtr.Delete( 0, lastSlashPos );
 }
 }
 // Setting RootPath for new Destination file
 fileNamePtr.Insert( 0, rootPath );
 // Setting KDownloadPath
 fileNamePtr.Insert( rootPath.Length(), KDownloadPath );
 #else
 User::Leave( err );
 }
 }
 CLOG_WRITE_1( " exiting fileName: %S", fileName );
 #ifdef RD_MULTIPLE_DRIVE
 CleanupStack::PopAndDestroy( drivesDynList );
 #endif
 CleanupStack::PopAndDestroy( &fs );
 }
 // ---------------------------------------------------------
 // CHttpDownload::UpdateDCFRepositoryL()
 // Update saved file to DCFRepository
 // ---------------------------------------------------------
 //
 void CHttpDownload::UpdateDCFRepositoryL(
 const TDesC& aFileName )
 {
 LOGGER_ENTERFN( "UpdateDCFRepositoryL" );
 CLOG_WRITE_1( " :UpdateDCFRepositoryL() for: %S", &aFileName );
 CDcfEntry* dcfEntry = NULL;
 dcfEntry = CDcfEntry::NewL();
 CleanupStack::PushL( dcfEntry );
 CDcfRep* dcfRep = NULL;
 dcfRep = CDcfRep::NewL();
 CleanupStack::PushL( dcfRep );
 dcfEntry->SetLocationL( aFileName, 0 );
 CLOG_WRITE(" : SetLocationL OK");
 dcfRep->UpdateL( dcfEntry );
 CLOG_WRITE(" :UpdateL OK");
 CleanupStack::PopAndDestroy(2); // dcfEntry, dcfRep
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::MoveInDeleteL
 // ?implementation_description
 // (other items were commented in a header).
 		{
 		TRAP_IGNORE(MoveDownloadedMediaObjectSyncL(mediaObjectIndex));
 		TPtrC filenamePtr = ((*iCodDlData)[mediaObjectIndex])->DestFilename();
 		if(filenamePtr.Length())
 		{
 		TRAP_IGNORE(NotifyMediaGalleryL( filenamePtr ));
 		}
 		}
 	return err;
 	}
 {
 LOGGER_ENTERFN( "MoveDownloadedMediaObjectsL" );
 if( iDlState != EHttpDlMultipleMOCompleted && !iMoDownloadCompleted )
 {
 iStorage->SetProgressiveMode( EFalse );
 TriggerEvent( iDlState, EHttpDlProgNonProgressive);
 return;//Move will be Done by COD as MO Completed has not happened
 }
 //__ASSERT_DEBUG( !IsActive(), DMPanic( KErrInUse ) );
 //__ASSERT_DEBUG( !iFileMan, DMPanic( KErrInUse ) );
 #if 0
 #else
 HBufC* filename = HBufC::NewLC(KMaxFileName);
 	TPtr filenamePtr1 = filename->Des();
 RFs &fs = iClientApp->Engine()->Fs();
 	if(!iFileMan)
 		{
 		iFileMan = CFileMan::NewL(fs);
 		}
 TPtrC filenamePtr2 = ((*iCodDlData)[mediaObjectIndex])->DestFilename();
 if(!filenamePtr2.Length())
 	{
 CleanupStack::PopAndDestroy(filename);
 return;
 	}
 TInt firstSlashPos = filenamePtr2.Locate( '\\' );
 if(firstSlashPos < 0)
 	    {
 	    CleanupStack::PopAndDestroy(filename);
 	    return;
 	    }
 	TPtrC dlName = filenamePtr2.Left(firstSlashPos);
 TInt drive;
 User::LeaveIfError( fs.CharToDrive( dlName[0], drive ));
 // Getting RootPath for selected Drive
 TFileName rootPath;
 filenamePtr1.Append(_L("\\"));
 TInt error = fs.MkDirAll(filenamePtr1);
 if (error!=KErrNone && error!=KErrAlreadyExists)
 {
 User::Leave(error);
 }
 	if( mediaObjectIndex == iActivePlayedDownload )
 	    {
 	    iFname = ((*iCodDlData)[mediaObjectIndex])->TempFilename();
 	    }
 	else
 		{
 	    iFname = ((*iCodDlData)[mediaObjectIndex])->DestFilename();
 		}
 // Find a unique name to avoid any conflict.
 // Here iFname has full path of current location of file
 // and filename has destination path.
 FindUniqueDestinationFileNameL( iFname, filename );
 filenamePtr1 = filename->Des();
 User::LeaveIfError( iFileMan->Move( iFname, filenamePtr1, CFileMan::EOverWrite, iStatus ) );
 // waiting for move to complete
 SetActive();
 iFname = filenamePtr1;
 ((*iCodDlData)[mediaObjectIndex])->SetDestFilenameL(filenamePtr1);
 CleanupStack::PopAndDestroy(filename);
 #endif
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::MoveDownloadedMediaObjectSyncL
 //__ASSERT_DEBUG( !IsActive(), DMPanic( KErrInUse ) );
 //__ASSERT_DEBUG( !iFileMan, DMPanic( KErrInUse ) );
 	RFs &fs = iClientApp->Engine()->Fs();
 	if(!iFileMan)
 		{
 		iFileMan = CFileMan::NewL(fs);
 		}
 HBufC* filename = HBufC::NewLC(KMaxFileName);
 TPtr filenamePtr = filename->Des();
 TPtrC fileNamePtr = ((*iCodDlData)[mediaObjectIndex])->DestFilename();
 TInt firstSlashPos = fileNamePtr.Locate( '\\' );
 if(firstSlashPos < 0)
 	    {
 	    CleanupStack::PopAndDestroy(filename);
 	    return;
 	    }
 	TPtrC dlName = fileNamePtr.Left(firstSlashPos);
 TInt drive;
 User::LeaveIfError( fs.CharToDrive( dlName[0], drive ));
 // Getting RootPath for selected Drive
 TFileName rootPath;
 // Setting KDownloadPath
 rootPath.Append( KDownloadPath );
 filenamePtr.Copy(rootPath);
 filenamePtr.Append(_L("\\"));
 TInt error = fs.MkDirAll(filenamePtr);
 if (error!=KErrNone && error!=KErrAlreadyExists)
 {
 User::Leave(error);
 }
 iFname = ((*iCodDlData)[mediaObjectIndex])->DestFilename();
 // Find a unique name to avoid any conflict.
 // Here iFname has full path of current location of file
 // and filename has destination path.
 FindUniqueDestinationFileNameL( iFname, filename );
 filenamePtr = filename->Des();
 TInt err = iFileMan->Move(iFname, filenamePtr, CFileMan::EOverWrite);
 if(err != KErrNone)
 	{
 	}
 iFname = filenamePtr;
 ((*iCodDlData)[mediaObjectIndex])->SetDestFilenameL(filenamePtr);
 CleanupStack::PopAndDestroy(filename);
 }
 // -----------------------------------------------------------------------------
 // CHttpDownload::FindUniqueDestinationFileNameL
 destPath->Des().Append( *fileExtention );
 CleanupStack::PopAndDestroy( fileName );
 CleanupStack::PopAndDestroy( fileExtention );
 }
 // ---------------------------------------------------------
 // CHttpDownload::NotifyMediaGalleryL()
 // Notify media gallery about the new file.
 // ---------------------------------------------------------
 //
 void CHttpDownload::NotifyMediaGalleryL( const TDesC& aFileName )
 {
 	LOGGER_ENTERFN( "CHttpDownload::NotifyMediaGalleryL" );
 CLOG_WRITE_1(" notifying Gallery and DcfReposory about move for: %S",&aFileName);
 #ifdef BRDO_APP_GALLERY_SUPPORTED_FF
 //
 // Notify Media Gallery about new media file
 CMGXFileManager* mgFileManager = MGXFileManagerFactory::NewFileManagerL(
 iClientApp->Engine()->Fs() );
 CleanupStack::PushL( mgFileManager );
 else
 {
 TRAP_IGNORE( mgFileManager->UpdateL() );
 }
 CleanupStack::PopAndDestroy( mgFileManager );
 #endif
 //
 // Notify DCF repository
 TRAP_IGNORE( UpdateDCFRepositoryL( aFileName ) );
 	}
 // -----------------------------------------------------------------------------
 }while( bFound );
 CleanupStack::PopAndDestroy(&rFs);
 CleanupStack::PopAndDestroy(fullNameTemp);
 // This is the unique name that we were looking for.
 CleanupStack::PopAndDestroy(fileName);
 fileName = uniqueName;
 CleanupStack::PushL(fileName);
 }

changeset 65	5bfc169077b2
parent 38	6297cdf66332
child 68	92a765b5b3e7