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

#include "daemon.h"
#include "drivewatcher.h"
#include "SWInstDebug.h"
#include "securitypolicy.h"

//#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
#include <e32property.h>
#include <connect/sbdefs.h>
#include "../../../../installationservices/swtransactionservices/inc/stsrecovery.h"
#include "swiobserverclient.h"
//#else
//#include "sisregistrysession.h"
//#endif // SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

namespace Swi
{
// CDaemon

// -----------------------------------------------------------------------
//
// -----------------------------------------------------------------------
//     
/*static*/ CDaemon* CDaemon::NewL(MDaemonBehaviour& aBehaviour)
    {
    CDaemon* self=NewLC(aBehaviour);
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------
//
// -----------------------------------------------------------------------
//     
/*static*/ CDaemon* CDaemon::NewLC(MDaemonBehaviour& aBehaviour)
    {
    CDaemon* self=new(ELeave) CDaemon(aBehaviour);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------
//
// -----------------------------------------------------------------------
//       
CDaemon::~CDaemon()
    { 
    iPolicyLockFile.Close();
  
    iWatchers.ResetAndDestroy();
    iFs.Close();
    }

// -----------------------------------------------------------------------
//
// -----------------------------------------------------------------------
//     
CDaemon::CDaemon(MDaemonBehaviour& aBehaviour)
    : iBehaviour(aBehaviour)
    {
    }

// -----------------------------------------------------------------------
//
// -----------------------------------------------------------------------
//     
void CDaemon::ConstructL()
    {
    User::LeaveIfError(iFs.Connect());
  
    LockSensitiveFiles();
    StartRecoveryL();
  
    iBehaviour.StartupL();
    StartWatchersL();
    }

// -----------------------------------------------------------------------
//
// -----------------------------------------------------------------------
//     
void CDaemon::StartWatchersL()
    {
    FLOG( _L("Daemon: Start watchers") );        
    RFs fs;
    User::LeaveIfError(fs.Connect());
    CleanupClosePushL(fs);
    User::LeaveIfError(fs.ShareProtected());
  
    TDriveList driveList;
  
    User::LeaveIfError(fs.DriveList(driveList));

    for (TInt drive=0; drive < KMaxDrives; ++drive)
        {
        if (driveList[drive] == 0)
            {
            continue;
            }
        TDriveInfo info;
        FLOG_1( _L("Daemon: Checking drive %d"), drive );                
        // Ignore errors since the next drive might work
        if (KErrNone != fs.Drive(info, drive))
            {
            FLOG_1( _L("Daemon: drive error = %d"), fs.Drive(info, drive) );  
            /// @todo, log error
            continue;
            }
        
        FLOG_1( _L("Daemon: info.iDriveAtt %d"), info.iDriveAtt );      
        FLOG_1( _L("Daemon: iDriveAtt & KDriveAttRemovable %d"), 
            (info.iDriveAtt & KDriveAttRemovable) );        
        FLOG_1( _L("Daemon: iDriveAtt & KDriveAttLogicallyRemovable %d"), 
            info.iDriveAtt & KDriveAttLogicallyRemovable );
    
        if (info.iDriveAtt & KDriveAttRemovable || 
            info.iDriveAtt & KDriveAttLogicallyRemovable )
            {   
            FLOG( _L("Daemon: Ok Drive is Removable or LogicallyRemovable") );                
            CDriveWatcher* driveWatcher=CDriveWatcher::NewLC(iFs, drive, iBehaviour);
            User::LeaveIfError(iWatchers.Append(driveWatcher));
            CleanupStack::Pop(driveWatcher);
            }

      
#ifdef __WINS__
        // If drive is not seen as removable in wins env., check if 
        // there is Daemon folder and start watcher if needed.        
        if ( ! ( info.iDriveAtt & KDriveAttRemovable || 
                info.iDriveAtt & KDriveAttLogicallyRemovable) )
            {
            // Watcher is not needed for C.
            if ( drive == 2 )
                {
                continue;
                }
                
            FLOG( _L("Daemon: Drive found. Check private folder") );                      
            _LIT( KDaemonPrivateFolder,":\\private\\10202dce\\" );                                   
            TChar driveLetter;
            User::LeaveIfError( fs.DriveToChar( drive, driveLetter ) );
                                                          
            CDir* list = NULL;        
            HBufC* path = HBufC::NewLC( KMaxFileName );
            TPtr pathPtr = path->Des();
            pathPtr.Append( driveLetter );
            pathPtr.Append( KDaemonPrivateFolder );          
                                
            // Check if folder exists in this drive.                       
            if ( KErrNone == iFs.GetDir( pathPtr, KEntryAttNormal, ESortNone, list ) )
                {     
                FLOG_1( _L("Daemon: Private folder found from drive %d."), drive );        
                
                CDriveWatcher* driveWatcher = 
                    CDriveWatcher::NewLC( iFs, drive, iBehaviour );
                
                User::LeaveIfError( iWatchers.Append( driveWatcher ) );                
                CleanupStack::Pop( driveWatcher );                
                }

            CleanupStack::Pop( path );                                              
            }
#endif  //__WINS__  
      
        }
    CleanupStack::PopAndDestroy(&fs);
    } // StartWatchersL()


// -----------------------------------------------------------------------
//
// -----------------------------------------------------------------------
//     
void CDaemon::LockSensitiveFiles()
    {
    TInt err = iPolicyLockFile.Open( 
        iFs, 
        KSwisPolicyFile, 
        EFileShareReadersOnly | EFileRead);
  
    FLOG_1( _L("Daemon: Policy file lock error = %d."), err );  
    }

//#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

// -----------------------------------------------------------------------
//
// -----------------------------------------------------------------------
//     
void CDaemon::StartRecoveryL()
    {
    FLOG( _L("Daemon: StartRecoveryL: Check to see if a recovery is needed.") );

    // Check to see if a backup is in progress...
    TInt backup = 0;
    User::LeaveIfError( RProperty::Get( KUidSystemCategory, conn::KUidBackupRestoreKey,backup ) );

    // if no backup or restore is in progress...
    if( backup == conn::EBURUnset || ( backup == ( conn::EBURNormal | conn::ENoBackup ) ) )
        {
        // no recovery attempt is made during backup/restore as recovery may seriously affect
        // the file system, which might impact backup/restore, recovery will be made at next bootup
        Usif::RStsRecoverySession stsRecoverySession;
        // A recovery failure should not affect Daemon start up.
        TRAPD( err, stsRecoverySession.RollbackAllPendingL() );
        if( err != KErrNone )
            {
            FLOG_1( _L("CDaemon::StartRecoveryL() - STS server failed to recover transactions. Error code: %d"), err );
            }
        // Start SWI Observer so that it can process the log files left from the previous session.
        RSwiObserverSession swiObserver;
        swiObserver.ProcessLogsL( iFs );
        swiObserver.Close();
        }
    }

/*
//#else
  
void CDaemon::StartRecoveryL()
    { 
    FLOG( _L("Daemon: StartRecoveryL: Check to see if a recovery is needed.") );  
    RSisRegistrySession registrySession;
    User::LeaveIfError( registrySession.Connect() );
    CleanupClosePushL( registrySession );
  
    // A recovery failure should not affect SWI Daemon start up.
    TRAP_IGNORE( registrySession.RecoverL() );
  
    CleanupStack::PopAndDestroy( &registrySession );
  
    FLOG( _L("Daemon: StartRecoveryL: Recovery check finished.") ); 
    } // StartRecoveryL()

#endif  // SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
*/

} // namespace Swi