/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   Fota server update and download functionality 

*

*/

// INCLUDE FILES

#include <aknenv.h>

#include <apgtask.h>

#include <apgwgnam.h>

#include <schtime.h>

#include <csch_cli.h>

#include <e32property.h>

#include <nsmldmconst.h>

#include <cmmanager.h>

#include <cmconnectionmethod.h>

#include <DevManInternalCRKeys.h>

#include <nsmlconstants.h>

#include <centralrepository.h>

#include <sysversioninfo.h>

#include "FotaSrvApp.h"

#include "FotaServer.h"

#include "FotaSrvDebug.h"

#include "FotasrvSession.h"

#include "fotaConst.h"

#include "nsmldmtreedbclient.h"

#include "fotaserverPrivatePSKeys.h"

#include "FotaNetworkRegStatus.h"

_LIT(KSizePass, "contentsize");

#include "DevEncController.h"

#define __LEAVE_IF_ERROR(x) if(KErrNone!=x) {FLOG(_L("LEAVE in %s: %d"), __FILE__, __LINE__); User::Leave(x); }

// ============================= LOCAL FUNCTIONS =============================

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

// ToDesC16LC

// Converts to 16bit desc

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

HBufC* ToDesC16LC( const TDesC8& a )

    {

    HBufC* bf = HBufC::NewLC( a.Length() );

    bf->Des().Copy(a);

    return bf;

    }

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

// GetPredefinedNodeL

// function to get preconfigured node for FUMO

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

void GetPredefinedNodeL(TDes8& aNode)

	{

	FLOG(_L("GetPredefinedNodeL() Begin"));

    CRepository* centrep( NULL);

	aNode.Zero();

   	centrep = CRepository::NewLC( TUid::Uid(0x101F9A0A) );

    if ( centrep )

	    {

	    FLOG(_L("centralrepository found End"));

    	TFullName temp;

    	if (centrep->Get( KDevManFUMOPredefinedNodes, temp )==KErrNone && temp.Length() )

			{

			temp.Trim();

			aNode.Copy(temp);

			}

		CleanupStack::PopAndDestroy(centrep);

	    }

	FLOG(_L("GetPredefinedNodeL() End"));	    

	}

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

// DeleteFUMOTreeL

// function to get preconfigured node for FUMO

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

void DeleteFUMOTreeL ()

    {

    FLOG(_L("DeleteFUMOTreeL() Begin"));

    const TUint32 KNSmlFotaAdapterUid = 0x101F9A09;

    _LIT8( KNSmlFumoPath, "FUMO" );

    _LIT8( KNSmlFumoSeparator, "/" );

    const TInt KGranularity = 10;

    TBuf8<KMaxFullName> temp;

	GetPredefinedNodeL(temp);

    RNSmlDMCallbackSession session;

    User::LeaveIfError(session.Connect());

    CleanupClosePushL(session);

    CBufBase *emptyList = CBufFlat::NewL(0);

    CleanupStack::PushL(emptyList);

    CArrayFixFlat <TSmlDmMappingInfo>* UriSegList;

    UriSegList = new (ELeave) CArrayFixFlat <TSmlDmMappingInfo> (KGranularity);

    CleanupStack::PushL(UriSegList);

    session.GetUriSegListL(KNSmlFotaAdapterUid,KNSmlFumoPath,*UriSegList);

    for ( TUint16 i=0;i<UriSegList->Count();i++)

        {

        	if (temp.Length() && UriSegList->At(i).iURISeg.Find( temp ) != KErrNotFound)

            {

              FLOG(_L("DeleteFUMOTreeL predefined match =%S"), &temp);

              continue;

            }

       	TBuf8<KMaxFullName> tempFumo;

       	tempFumo.Append(KNSmlFumoPath);

       	tempFumo.Append(KNSmlFumoSeparator);

       	tempFumo.Append(UriSegList->At(i).iURISeg);

       	FLOG(_L("DeleteFUMOTreeL() call update mapping info for node %S"),&tempFumo);

        session.UpdateMappingInfoL(KNSmlFotaAdapterUid,tempFumo,*emptyList);

        }

    // session.UpdateMappingInfoL(KNSmlFotaAdapterUid,KNSmlFumoPath,*emptyList);

	CleanupStack::PopAndDestroy(UriSegList); 

    CleanupStack::PopAndDestroy(emptyList); 

    CleanupStack::PopAndDestroy(&session); //session

    FLOG(_L("DeleteFUMOTreeL() End"));

    }

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

// CFotaServer::GetProfileDataL

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

void CFotaServer::GetProfileDataL( RSyncMLSession* aSyncml

    ,const TSmlProfileId aProf, TInt& aIapId, TSmlServerAlertedAction& aSrvAA

    ,TBool& aUIJob, TInt& aSanVal)

	{

    FLOG(_L("CFotaServer::GetProfileDataL prof %d"),aProf);

    __ASSERT_ALWAYS( aSyncml, User::Panic(KFotaPanic, KErrArgument) );

    __ASSERT_ALWAYS( aSyncml->Handle(), User::Panic(KFotaPanic, KErrBadHandle) );

    // GET IAP FROM PROFILE ----------------------------------------------

    TSmlJobId               jobid( KErrNotFound );

    TInt                    jobidFromUI( KErrNotFound );

    RSyncMLDevManProfile    smlprof;

    RArray<TSmlTransportId> connections;

    TSmlTransportId         transport;

    RSyncMLConnection       connection;

    CleanupClosePushL(smlprof);

    CleanupClosePushL(connections);

    CleanupClosePushL(connection);

    FLOG(_L("[FotaServer]   1"));

    FLOG(_L("[FotaServer]   1.1 opening syncml \

                        profileid %d "), aProf);

    smlprof.OpenL(*aSyncml, aProf, ESmlOpenRead);

    FLOG(_L("[FotaServer]  1.1"));

    smlprof.ListConnectionsL(connections);

    FLOG(_L("[FotaServer]  1.3"));

    transport = connections[0];

    connection.OpenL(smlprof,transport);

    TBuf8<20> iapid2 = connection.GetPropertyL ( KNSmlIAPId );

    TLex8 iapid3(iapid2);

    iapid3.Val(aIapId);

    // 1. Profile's "accepted" field.

    aSrvAA = smlprof.SanUserInteraction ();

    FLOG(_L("[FotaServer]  1.4 \

                    SanUserInteraction:%d"),aSrvAA );

    // 2. Has job been started from omadmappui. That is, did user start the job

    TSmlUsageType dmusagetype(ESmlDevMan);

    aSyncml->CurrentJobL( jobid,dmusagetype );

    RProperty::Get( TUid::Uid(KOmaDMAppUid), KNsmlCurrentJobId, jobidFromUI);

    aUIJob = ( jobidFromUI == jobid && jobid!=KErrNotFound );

    aSanVal = KErrNotFound; 

    if ( aUIJob )

    	{

    	//First for not server alert or SAN not supported value is -1

    	RProperty::Get( TUid::Uid(KOmaDMAppUid), KNsmlSanUIMode, aSanVal);

    	if ( aSanVal != -1 ) //SAN Supported

    	    {

   	    	aUIJob = 0;

    	    }

    	}

    FLOG(_L("  jobidFromUI: %d jobid: %d, aUIJob: %d, aSanVal: %d"),jobidFromUI,jobid,aUIJob,aSanVal);

    CleanupStack::PopAndDestroy (&connection); 

    CleanupStack::PopAndDestroy (&connections);

    CleanupStack::PopAndDestroy (&smlprof); 

	}

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

// CreateDeviceManagementSessionL       

// Creates DM session 

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

void CFotaServer::CreateDeviceManagementSessionL( TPackageState& aState )

    {

    FLOG(_L("[cfotasever]   CreateDeviceManagementSessionL dms >> profid %d\

    %d counts left ,sml handle %d, iNetworkAvailable=%d"), aState.iProfileId, aState.iSmlTryCount 

    , iSyncMLSession.Handle(),iNetworkAvailable);

    SetStartupReason(EFotaPendingGenAlert);

	if (!iNetworkAvailable)

		{

		iRetryingGASend = ETrue;

		iStoredState = aState;

		StartNetworkMonitorL();

		}

	else 

		{

	    TBool dbAlreadyOpen = iDatabase->IsOpen();

	    TBool triesLeft( EFalse );

 		iNetworkAvailable = EFalse; // to check network again when GA is sent next time

	    if ( iSyncMLSession.Handle() )

	        {

	        User::Leave( KErrAlreadyExists );

	        }

	    if ( !dbAlreadyOpen ) iDatabase->OpenDBL();

	    // There is still tries left

	    if ( aState.iSmlTryCount > 0 )

	        {

	        triesLeft = ETrue;

	        FLOG(_L(" decrementing the retry count"));

	        aState.iSmlTryCount = aState.iSmlTryCount - 1;

	        iDatabase->SetStateL( aState, KNullDesC8, EFDBSmlTryCount );

	        }

	    // out of tries, set state to idle

	    else

	        {

	        triesLeft = EFalse;

	        FLOG(_L("   out of tries, resetting pkg state"));

	        SetStartupReason(EFotaDefault);

	        aState.iState = RFotaEngineSession::EIdle;

	        aState.iResult = KErrNotFound;

	        iDatabase->SetStateL( aState, KNullDesC8, EFDBState|EFDBResult );

	        }

	    if ( !dbAlreadyOpen ) iDatabase->CloseAndCommitDB();

	    if ( triesLeft )

	        {

	        TInt iapid;

	        TSmlServerAlertedAction tmp;

	        TBool                   tmp2;

	        TInt					tmp3;

	        iSyncMLSession.OpenL(); 

	        GetProfileDataL( &iSyncMLSession,aState.iProfileId,iapid,tmp,tmp2,tmp3);

	        FLOG(_L("Using IAP: %d to send GA"),iapid);

	        FLOG(_L("From Db Using IAP: %d to send GA"),aState.iIapId);

	        RSyncMLDevManJob    dmJob;

	        RProperty::Define(KPSUidNSmlSOSServerKey,KNSmlDMSilentJob,RProperty::EInt,KAllowAllPolicy,KWritePolicy);

	        TInt r2=RProperty::Set(KPSUidNSmlSOSServerKey,KNSmlDMSilentJob,ESilent);

			FLOG(_L("CFotaServer::CreateDeviceManagementSessionL KNSmlDMSilentJob set err %d"),r2);

	        TBuf<10> genalertap,temp;

	        genalertap.Zero();

	        temp.Zero();	  

	        genalertap.Append(KNSmlDMJobIapPrefix);

	        temp.Num(aState.iIapId);//Decimal Iap

	        if( temp.Length() <= KNSmlHalfTransportIdLength && 

	            aState.iIapId > KErrNotFound && CheckIapExistsL(aState.iIapId) )

	        	{

	        	genalertap.AppendFill('0',KNSmlHalfTransportIdLength-temp.Length());

	        	genalertap.Append(temp);

	        	TLex gavalue(genalertap);

	        	gavalue.Val(iIapId);

	        	dmJob.CreateL( iSyncMLSession, aState.iProfileId,iIapId);	

	        	iSyncMLAttempts = KSyncmlAttemptCount;

	        	}

	        else 

	        	{

	        	iSyncMLAttempts = 0;

	        	dmJob.CreateL( iSyncMLSession, aState.iProfileId);

	        	}

			// If there's no iapid defined, sml will pop up connection dialog.

			// In that case, only one connection attempt is allowed.

	        iSyncJobId   = dmJob.Identifier();

	        iSyncProfile = aState.iProfileId;

	        dmJob.Close();

	        iSyncMLSession.RequestEventL( *this ); 

	        }

	}

    FLOG(_L("[cfotasever]   CreateDeviceManagementSessionL dms << profid %d")

                            ,aState.iProfileId);

    }

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

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

// CFotaServer::CFotaServer()   

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

//

CFotaServer::CFotaServer() : iInitialized(EFalse), iNeedToClose(0), iParentApp(0)

, iDatabase(0),iDownloader(0), iUpdater(0)

 , iDownloadFinalizer(0), iUpdateFinalizer(0), iTimedExecuteResultFile(0)

 , iTimedSMLSessionClose(0), iStorage(0), iAppShutter(0), iMonitor (NULL), iSyncJobId(-1), iRetryingGASend (EFalse), iNetworkAvailable (EFalse)

 , iIapId(KErrNotFound),iSessMode(0),iUserResume(KErrNotFound), iInstallupdClient(EFalse), iDEController(NULL)

	{

    RProcess pr; TFullName fn = pr.FullName();  TUint prid = pr.Id();

	FLOG(_L( "CFotaServer::CFotaServer process(id %d)%S. this 0x%x"),prid,&fn

        ,this);

	}

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

// CFotaServer::DoExecuteResultFileL

// Interprets result of update (file update.resp)

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

//

void CFotaServer::DoExecuteResultFileL()

    {

    FLOG(_L("CFotaServer::DoExecuteResultFileL() >>"));

    if ( iTimedExecuteResultFile ) 

        {

        iTimedExecuteResultFile->Cancel();

        delete iTimedExecuteResultFile;

        iTimedExecuteResultFile = NULL;

        }

    iUpdater = CFotaUpdate::NewL(this);

    iUpdater->ExecuteUpdateResultFileL( iFs );

    FLOG(_L("CFotaServer::DoExecuteResultFileL() <<"));

    }

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

// StaticDoExecuteResultFile

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

//

static TInt StaticDoExecuteResultFile(TAny *aPtr)

    {

    FLOG(_L("[cfotaserver] StaticDoExecuteResultFile() >>"));

    __ASSERT_ALWAYS( aPtr, User::Panic(KFotaPanic, KErrBadHandle) );

    CFotaServer* srv = (CFotaServer*) aPtr;

    TRAPD( err,  srv->DoExecuteResultFileL() );

    if(err) 

        {

        FLOG(_L("[cfotaserver] StaticDoExecuteResultFile ERROR %d"),err);

        TRAP_IGNORE(srv->DoDeleteUpdateResultFileL());

        }

    FLOG(_L("[cfotaserver] StaticDoExecuteResultFile() <<"));

    return err;

    }

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

// CFotaServer::CFotaServer()   

// Constructor. Can't do all constructing since fotaserver might call itself

// recursively (via downloadmgr). 

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

//

void CFotaServer::ConstructL(const TDesC &aFixedServerName)

    {

    FLOG(_L("CFotaServer::ConstructL() >> name=%S"), &aFixedServerName);

    TBool   updated (EFalse);

    TInt    err;

    CAknAppServer::ConstructL( aFixedServerName );

    User::LeaveIfError( iFs.Connect() );

    err = iFs.CreatePrivatePath(EDriveC);

    if ( err != KErrNone && err != KErrAlreadyExists ) { User::Leave (err); }

    User::LeaveIfError( iFs.SetSessionToPrivate( EDriveC ) );

    if ( !iDatabase )

        {

        TRAPD( err,iDatabase = CFotaDB::NewL() );

        if ( err ) 

            {

            FLOG(_L("CFotaServer::  DB creationg error %d"), err);

            User::Leave( err );

            }

        }

    updated = CFotaUpdate::CheckUpdateResults( iFs );

    // Update has happened, and result file is in place

    if ( updated )

        {

        FLOG(_L("scheduling update result file execution"));

        if ( iTimedExecuteResultFile ) 

            {

            iTimedExecuteResultFile->Cancel();

            delete iTimedExecuteResultFile;

            iTimedExecuteResultFile = NULL;

            }

        iTimedExecuteResultFile = CPeriodic::NewL (EPriorityNormal) ;

        iTimedExecuteResultFile->Start (

            TTimeIntervalMicroSeconds32(KDownloadFinalizerWaitTime)

            , TTimeIntervalMicroSeconds32(KDownloadFinalizerWaitTime)

            , TCallBack(StaticDoExecuteResultFile,this) ) ;

        }

	iEikEnv = CEikonEnv::Static();

    FLOG(_L("CFotaServer::ConstructL() <<"));

    }

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

// CFotaServer::ClientAwareConstructL

// Does rest of constructing, if not done. If parent of this fotaserver 

// instance is another fotaserver, skip maintenance operations (since parent 

// takes care of them). DmHOstserver triggers cleanup for states: 20,70,80

// ,90,100 , must handle state 60 here

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

void CFotaServer::ClientAwareConstructL( const RMessage2 &aMessage )

    {

    FLOG(_L("CFotaServer::ClientAwareConstructL >>"));

    if ( iInitialized ) return;

    CFotaSrvSession::TClient client 

                    = CFotaSrvSession::CheckClientSecureIdL ( aMessage );

	// temporary fix to keep FS from polluting FSW in case it was opened from omadmappui

    if ( client == CFotaSrvSession::EOMADMAppUi || client == CFotaSrvSession::EFotaServer ||

       client == CFotaSrvSession::ESoftwareChecker || client == CFotaSrvSession::ESoftwareCheckerBackground  ) 

        {

        //Loading the storage plugin (during DM UI launch) to adjust the reserved memory accordingly.

        StoragePluginL();

        iParentApp->SetUIVisibleL ( EFalse, ETrue ); // 

        }

    // Do constructing if client is other that fotaserver

    if ( client != CFotaSrvSession::EFotaServer )

        {

        RArray<TInt>    states;

        TPackageState   state;

        CleanupClosePushL (states);

        iDatabase->OpenDBL();

        iDatabase->GetAllL ( states );

    	TBool value (EFalse);

    	if (iDownloader)

    		{

    		value = iDownloader->IsDownloadActive();

    		}

    	else

    		{

    		TInt err = RProperty::Get(TUid::Uid(KFotaServerUid), KFotaDownloadActive, value );

    		FLOG(_L("value of KFotaDownloadActive & err as %d,%d "), (TInt)value,err);

    		}

    	FLOG(_L("Download active value is:%d "), (TInt)value);

        // Loop states. 

        for(TInt i = 0; i < states.Count(); ++i ) 

            {

            TPackageState   tmp;

            TBool           toIdle(EFalse);

            tmp = iDatabase->GetStateL(  states[i]  );

            FLOG(_L("   1 got state id:%d state:%d result:%d"), tmp.iPkgId

                , tmp.iState, tmp.iResult);

             if ( tmp.iState == RFotaEngineSession::EStartingUpdate )

             {

             	TBool ispkgvalid= ETrue;

             	TRAPD(err1,ispkgvalid= CheckSWVersionL()   )

              if (!ispkgvalid && err1 == KErrNone)

              {

              StoragePluginL()->DeleteUpdatePackageL (  tmp.iPkgId );	

             	tmp.iState    = RFotaEngineSession::EUpdateFailed;

              tmp.iResult   = RFotaEngineSession::EResPackageMismatch;

              iDatabase->SetStateL( tmp,KNullDesC8, EFDBState | EFDBResult );

             }	

             }

            // Update has been started (60)

            // If there is no result file, means that update agent failed

            // to run. Must get back to 50 to allow user to try again. 

            if ( tmp.iState == RFotaEngineSession::EUpdateProgressing 

                && iTimedExecuteResultFile==NULL )

                {

                FLOG(_L("     State 60 found, UA didnt run! id %d "), tmp.iPkgId);

                tmp.iState    = RFotaEngineSession::EStartingUpdate;

                iDatabase->SetStateL( tmp,KNullDesC8, EFDBState);

                }

            // These states need must trigger generic alert! (70+ )

            if ( tmp.iState >= RFotaEngineSession::EUpdateFailed  )

                {

                if ( iSyncMLSession.Handle() == NULL )

                    {

                    iDatabase->CloseAndCommitDB();

                    CreateDeviceManagementSessionL( tmp );

                    iDatabase->OpenDBL();

                    }

                }

            if (tmp.iState == RFotaEngineSession::EDownloadComplete && tmp.iResult == RFotaEngineSession::EResSuccessful )

            	{

                CreateDeviceManagementSessionL( tmp );

            	}

            if (value != 1) //if download is not active, EStartingDownload should be reset to EDownloadFailed

            	{

            	if (tmp.iState == RFotaEngineSession::EStartingDownload ||

            			tmp.iState == RFotaEngineSession::EDownloadProgressing )

            		{

            		FLOG(_L("Resetting state %d to 20..."), tmp.iState);

            		tmp.iState = RFotaEngineSession::EDownloadFailed;

                    iDatabase->SetStateL( tmp,KNullDesC8, EFDBState ) ;

                    iDatabase->CloseAndCommitDB();

                    iDatabase->OpenDBL();

            		}

            	}

            if ( tmp.iState == RFotaEngineSession::EDownloadFailed )

                {

                StoragePluginL()->DeleteUpdatePackageL( tmp.iPkgId ); 

                tmp.iResult   = RFotaEngineSession::EResDLFailDueToNWIssues;

                iDatabase->SetStateL( tmp,KNullDesC8, EFDBResult ) ;

                iDatabase->CloseAndCommitDB();

                CreateDeviceManagementSessionL( tmp );

                iDatabase->OpenDBL();

                }

            // Reset package state to idle

            if ( toIdle )

                {

                FLOG(_L("   2 resetting state %d to idle"), tmp.iPkgId);

                tmp.iState    = RFotaEngineSession::EIdle;