/*

* Copyright (c) 2007-2009 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:   Controls the vpn policy import procedure.

*

*/

#include <e32std.h>

#include <apacmdln.h>

#include <bautils.h>

#include <sysutil.h>

#include <securityerr.h>

#include "policyinstaller.h"

#include "vpnnotifierdefs.h"

#include "vpnpolicyrecognizerconstants.h"

#include "zipfiledecompressor.h"

#include "policyinstaller_constants.h"

// Device lock / PKCS#12 installation

#include "vpnbundlehandler.h"

#include "cmdfileparser.h"

#include "pkcs12vpn.h"

#include "cmdfilexmltags.h"

#include "vpndevlockhandler.h"

#include "log_r6.h"

void RunServerL();

GLDEF_C TInt E32Main()

    {

    __UHEAP_MARK;

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    if (!cleanupStack)

        {

        return KErrNoMemory;

        }

    TRAP_IGNORE(RunServerL());

    delete cleanupStack;

    __UHEAP_MARKEND;

    return KErrNone;

    }

void RunServerL()

    {

    LOG_("-> VPNPolins RunServerL()");

    // Create and install the active scheduler

    LOG_(" Instantiate active scheduler()");

    CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

    CleanupStack::PushL(scheduler);

    LOG_(" Installing active scheduler()");

    CActiveScheduler::Install(scheduler);

    // Create the installer active object and issue the install request

    LOG_(" Instantiating CVpnPolicyInstaller");

    CVpnPolicyInstaller* installer = CVpnPolicyInstaller::NewL();

    CleanupStack::PushL(installer);

    LOG_(" Installing policy");

    installer->InstallPolicy();

    // Now we can start the active scheduler

    LOG_(" Starting active scheduler");

    CActiveScheduler::Start();

    LOG_(" Returning to RunServerL()");

    // We're done, so remove objects from

    // cleanup stack and destroy them

    LOG_(" Pop installer");

    CleanupStack::PopAndDestroy(installer);

    LOG_(" Pop scheduler");

    CleanupStack::PopAndDestroy(scheduler);

    LOG_("<- VPNPolins RunServerL()");

    }

/////////////////////////////////////

// CVpnPolicyInstaller class implementation

CVpnPolicyInstaller* CVpnPolicyInstaller::NewL()

    {

    CVpnPolicyInstaller* self = new (ELeave) CVpnPolicyInstaller();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CVpnPolicyInstaller::CVpnPolicyInstaller() : CActive(EPriorityStandard)

    {

    }

void CVpnPolicyInstaller::ConstructL()

    {

    LOG_("-> CVpnPolicyInstaller::ConstructL()");

    CActiveScheduler::Add(this);

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

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

    TInt err =

        CApaCommandLine::GetCommandLineFromProcessEnvironment(iCommandLine);        

    User::LeaveIfError(err);        

    if (iCommandLine->DocumentName().Length() == 0)

        {

        User::Leave(KErrArgument);

        }

    #ifdef ATS_BUILD

    	_LIT(KPassword, "password");

    	iP12Password = HBufC::NewL(KPassword().Length());

    	iP12Password->Des().Copy(KPassword);

    #endif

    LOG_("<- CVpnPolicyInstaller::ConstructL()");

    }

CVpnPolicyInstaller::~CVpnPolicyInstaller()

    {

    LOG_("-> CVpnPolicyInstaller::~CVpnPolicyInstaller()");

    Cancel();        

    delete iDecompressor;

    delete iDriveAndPath;

    delete iCommandLine;

    delete iFormat;

    delete iFileName;

    delete iP12Password;

    delete iWaitNoteHandler;

    iFileServer.Close();    

    iNotifier.Close();

    iVpnServ.Close();

    LOG_("<- CVpnPolicyInstaller::~CVpnPolicyInstaller()");

    }

void CVpnPolicyInstaller::InstallPolicy()

    {

    LOG_("-> CVpnPolicyInstaller::InstallPolicy()");

    TRAPD(err, InstallPolicyL());

    if (err != KErrNone)

        {

        LOG_1(" Policy installation terminated with error code %d", err);

        // Show the error note before completing.

        ShowImportErrorNote(err);

        }

    LOG_("<- CVpnPolicyInstaller::InstallPolicy()");

    }

void CVpnPolicyInstaller::InstallPolicyL()

    {

    LOG_("-> CVpnPolicyInstaller::InstallPolicyL()");

    __ASSERT_ALWAYS(iCommandLine, User::Invariant());

    // Disk space criticality check before attempting

    // to install

    if (SysUtil::FFSSpaceBelowCriticalLevelL(0, 0)) 

        {

        User::Leave(KErrDiskFull);

        }

    // Parse the filename that is to be operated on,

    // and deduce its type (ZIP, PIN etc)

    HBufC* document = iCommandLine->DocumentName().AllocLC();        

    TPtr documentPtr(document->Des());

    TParsePtr parse(documentPtr);

    TPtrC extension = parse.Ext();

    iFormat = extension.AllocL();

    iFileName = HBufC8::NewL(parse.NameAndExt().Length());

    TPtr8 des = iFileName->Des();

    des.Copy(parse.NameAndExt());

    if (extension.CompareF(KVpnZipPolicyFileExtension) == 0)

        {                

        LOG_(" Policy is in a VPN zip file");

        ContinueInstallPolicyL();

        }

    else if (extension.CompareF(KVpnPinPolicyFileExtension) == 0)

        {        

        LOG_(" Policy is unpacked pol/pin file");

        iDriveAndPath = parse.DriveAndPath().AllocL();

        ContinueInstallPolicyL();

        }

    else

        {

        LOG_(" Policy is in an unknown format, leaving");

        LOG_("<- CVpnPolicyInstaller::InstallPolicyL() (leave)");

        User::Leave(KErrArgument);

        }        

    CleanupStack::PopAndDestroy(document);        

    LOG_("<- CVpnPolicyInstaller::InstallPolicyL()");

    }

void CVpnPolicyInstaller::ContinueInstallPolicyL() 

    {

    LOG_("-> CVpnPolicyInstaller::ContinueInstallPolicyL()");

    if (iFormat->CompareF(KVpnZipPolicyFileExtension) == 0)

        {

        DeflateZippedPolicyL();

        }

    else if (iFormat->CompareF(KVpnPinPolicyFileExtension) == 0)

        {        

        InstallPinPolicyL(*iDriveAndPath);

        }

    else

        {

        LOG_("<- CVpnPolicyInstaller::ContinueInstallPolicyL() (leave)");

        User::Leave(KErrArgument);

        }

    LOG_("<- CVpnPolicyInstaller::ContinueInstallPolicyL()");

    }

void CVpnPolicyInstaller::InstallPinPolicyL(const TDesC& aFileDirectory)

    {

    LOG_("-> CVpnPolicyInstaller::InstallPinPolicy()");

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

    iVpnServ.ImportPolicy(aFileDirectory, iStatus);

    iOngoingTask = ETaskImportPinPolicies;

    SetActive();

    LOG_("<- CVpnPolicyInstaller::InstallPinPolicy()");

    }

void CVpnPolicyInstaller::DeflateZippedPolicyL()

    {   

    LOG_("-> CVpnPolicyInstaller::DeflateZippedPolicyL()");

    LOG_(" Showing wait note");

    ShowWaitNoteL(TVpnDialog::EGenericProgress);

    __ASSERT_ALWAYS(!iDecompressor, User::Invariant());  

    iOngoingTask = ETaskImportZippedPolicies;

    iDriveAndPath = KTempDirectory().AllocL();

    iOngoingTask = ETaskImportZippedPolicies;

    //Makes sure the temp dir is empty

    if (BaflUtils::FolderExists(iFileServer, KTempDirectory))

        {

        EmtpyTempDirL();

        }

    iDecompressor = CZipFileDecompressor::NewL();              

    RFile file;

    iCommandLine->GetFileByHandleL(file);

    if (file.SubSessionHandle())

        {        

        iDecompressor->DecompressZipFile(file, KTempDirectory, iStatus);

        }

    else

        {

        iDecompressor->DecompressZipFile(iCommandLine->DocumentName(), KTempDirectory, iStatus);

        }

    SetActive();

    LOG_("<- CVpnPolicyInstaller::DeflateZippedPolicyL()");

    }

void CVpnPolicyInstaller::EmtpyTempDirL()

    {

    LOG_("-> CVpnPolicyInstaller::EmtpyTempDirL()");

    CDir* dir = NULL;

    User::LeaveIfError(iFileServer.GetDir(KTempDirectory, KEntryAttNormal, ESortByName, dir));

    CleanupStack::PushL(dir);

    TFileName* fileName = new (ELeave) TFileName;

    CleanupStack::PushL(fileName);

    for (TInt i = 0; i < dir->Count(); ++i)

        {

        const TEntry& entry = (*dir)[i];

        *fileName = KTempDirectory;

        fileName->Append(entry.iName);

        User::LeaveIfError(iFileServer.Delete(*fileName));        

        }

    CleanupStack::PopAndDestroy(fileName);

    CleanupStack::PopAndDestroy(dir);

    LOG_("<- CVpnPolicyInstaller::EmtpyTempDirL()");

    }

void CVpnPolicyInstaller::DoCancel()

    {

    LOG_("-> CVpnPolicyInstaller::DoCancel()");

    CancelWaitNote();

    switch(iOngoingTask)

        {

        case ETaskImportZippedPolicies:

            LOG_(" case ETaskImportZippedPolicies");

            if (iDecompressor) 

                {

                iDecompressor->Cancel();

                delete iDecompressor;

                iDecompressor = NULL;

                }

            break;

        case ETaskImportPinPolicies:

            LOG_(" case ETaskImportPinPolicies");

            iVpnServ.CancelImport();

            delete iDriveAndPath;

            iDriveAndPath = NULL;

            break;

        case ETaskShowImportErrorNote:

            LOG_(" case ETaskShowImportErrorNote");

            LOG_1(" (IMPERR) Terminating dialog, iStatus: %d", iStatus.Int());

            iNotifier.CancelNotifier(KUidVpnDialogNotifier);

            break;

        default:

            LOG_(" case default");

            User::Invariant();

            break;            

        } 

    TRAP_IGNORE(EmtpyTempDirL());

    LOG_("<- CVpnPolicyInstaller::DoCancel()");

    }

TInt CVpnPolicyInstaller::RunError(TInt aError)

    {

    LOG_1("-> CVpnPolicyInstaller::RunError() code: %d", aError);

    CancelWaitNote();

    switch(iOngoingTask)

        {

        case ETaskImportZippedPolicies:

            LOG_(" case ETaskImportZippedPolicies");

            if (iDecompressor) 

                {

                LOG_("  Found decompressor, terminating");

                iDecompressor->Cancel();

                delete iDecompressor;

                iDecompressor = NULL;

                }

            LOG_("  case handled");

            break;

        case ETaskImportPinPolicies:

            LOG_(" case ETaskImportPinPolicies");

            iVpnServ.CancelImport();

            delete iDriveAndPath;

            iDriveAndPath = NULL;

            break;

        case ETaskShowImportErrorNote:

            LOG_(" case ETaskShowImportErrorNote");

            LOG_1("  (IMPERR) Terminating dialog, iStatus: %d", iStatus.Int());

            iNotifier.CancelNotifier(KUidVpnDialogNotifier);

            break;

        default:

            LOG_(" case default");

            User::Invariant();

            break;

        }

    TRAP_IGNORE(EmtpyTempDirL());

    // Show error note unless the operation was cancelled

    // (in which case we will just exit silently)

    if (aError != KErrCancel && aError != KErrBadPassphrase) 

        {

        ShowImportErrorNote(aError);

        }

	CActiveScheduler::Stop();

    LOG_("<- CVpnPolicyInstaller::RunError()");

    return KErrNone;

    }

void CVpnPolicyInstaller::RunL()

    {

    LOG_("-> CVpnPolicyInstaller::RunL()");

    TInt status = iStatus.Int();

    TBool finished(EFalse);

    switch(iOngoingTask)

        {

        case ETaskImportZippedPolicies:

            LOG_(" Case ETaskImportZippedPolicies");

            delete iDecompressor;

            iDecompressor = NULL;

        	if (status == KErrNone)

            	{            	

                LOG_(" Status: KErrNone, continuing installation");

                ProcessBundleContentsL();

                // Wait note has been cancelled in ProcessBundleContentsL

                ShowWaitNoteL();

            	InstallPinPolicyL(*iDriveAndPath);

            	}

        	else

            	{

                LOG_1(" Status: %d, aborting installation", status);

    			// Installation FAILED

    			// Policy import failed, so show an error note

                // (asynchronous call, RunL called again on completion)

    			iOngoingTask = ETaskShowImportErrorNote;

            	ShowImportErrorNote();

                finished = ETrue;

            	}        

            break;

        case ETaskImportPinPolicies:

            LOG_(" Case ETaskImportPinPolicies");

            // We're finished, so clean up and terminate

            TRAP_IGNORE(EmtpyTempDirL());

            if (status == KErrNone) 

                {

                // Finally, only apply devlock settings

                // if we've come this far without errors

                TRAP(status, ApplyDevLockSettingsL());

                }

            CancelWaitNote();

            delete iDriveAndPath;

            iDriveAndPath = NULL;

            LOG_1(" Status: %d", status);

        	if (status == KErrNone)

            	{

                // Everything went OK. Show completion note and finish.

                LOG_(" Completing");

            	iOngoingTask = ETaskNone;

                TVpnDialogInfo dialogInfo(TNoteDialog::EInfo, 

                                          TVpnNoteDialog::EVpnPolicyInstalled);

                iDialogInfoDes() = dialogInfo;

                LOG_(" Starting 'finished' dialog");

                iNotifier.StartNotifierAndGetResponse(iStatus, 

                                                      KUidVpnDialogNotifier,

                                                      iDialogInfoDes, 

                                                      iDialogResponseDes);

                User::WaitForRequest(iStatus);

                LOG_(" Request complete, terminating");

             	// We're done, so cancel the completion note, and terminate

                iNotifier.CancelNotifier(KUidVpnDialogNotifier);

                finished = ETrue;

            	}

        	else if (status != KErrCancel)

            	{

    			// Policy import failed, so show an error note

    			// and terminate

                LOG_(" Installation failed, showing import error note");

    			iOngoingTask = ETaskShowImportErrorNote;

            	ShowImportErrorNote();

                finished = ETrue;

            	}

            else 

                {

                LOG_(" Installation was cancelled, silent exit");

                finished = ETrue;

                }

            break;

        case ETaskShowImportErrorNote:

            LOG_(" Case ETaskShowImportErrorNote");

            // Cancel

            LOG_1(" (imperr) Terminating dialog, status: %d", status);

            iNotifier.CancelNotifier(KUidVpnDialogNotifier);

            iOngoingTask = ETaskNone;

            // We're done, so terminate

            finished = ETrue;