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

// IPSecPolicyManagerHandler.cpp - IPSec Policy Manager Handler

//

#include <es_sock.h>

#include <in_sock.h>

#include <es_ini.h>

#include "ipsecpolmanhandler.h"

#include "algorithmconf.h"

#include "ipsecpolmanserver.h"

#include "ipsecpolmansession.h"

#include "ipsecpolapi.h"

#include "ipsecpol.h"

#include "log_ipsecpol.H"

#include "ipsecpolparser.h"

#include "secpolreader.h"

#define FIRST_ARGUMENT  0

#define SECOND_ARGUMENT 1

#define THIRD_ARGUMENT  2

#define FOURTH_ARGUMENT 3

//

// Create IPSecPolicyManagerHandler object

//

CIPSecPolicyManagerHandler*

CIPSecPolicyManagerHandler::NewL(CIPSecPolicyManagerServer*)

    {

    LOG(Log::Printf(_L("Constructing IPSecPolManHandler\n")));

    CIPSecPolicyManagerHandler* self = 

        new (ELeave) CIPSecPolicyManagerHandler();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

//

// Phase 2 constructor

//

void 

CIPSecPolicyManagerHandler::ConstructL()

    {

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

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

    iActivePolicyList = new (ELeave) CActivePolicyList(1);

    iIsPreloadNeeded = EFalse;

    iPreloadPolicyHandle.iHandle = 0;

#ifdef TESTFLAG

	iStringBuf = NULL;

#endif

    ReadAlgorithmsFileL();

    iSelectorInfoArray = new (ELeave) CArrayFixFlat<TIpsecSelectorInfo> (2);

    }

//

// Destructor

//

CIPSecPolicyManagerHandler::~CIPSecPolicyManagerHandler()

    {

    LOG(Log::Printf(_L("Destructing IPSecPolManHandler\n")));

    // Unload the autoload policy if the load method is Preload,

    if (iPreloadPolicyHandle.iHandle > 0)

        {

        TRAPD(leaveCode,

              UnloadPolicyByHandleL(iPreloadPolicyHandle.iHandle, NULL));

        if (leaveCode != KErrNone)

            {

            LOG(Log::Printf(_L("Unload autoload policy failed\n")));

            }

        }

	// Corrected code

    if (iActivePolicyList)

        {

        // Deletes all the items in the list

        for (TInt i = iActivePolicyList->Count() - 1; i >= 0; i--)

            {

            if ( iActivePolicyList->At(i) != NULL ) 

            	{	

	            // Unloads still active policies

	            TRAPD(leaveCode,

	              UnloadPolicyByHandleL(iActivePolicyList->At(i)->iPolicyHandle.iHandle, NULL));

	        	if (leaveCode != KErrNone)

	            	{

	            	LOG(Log::Printf(_L("Unload autoload policy failed\n")));

            		}

            	}

            }

        delete iActivePolicyList;

        iActivePolicyList = NULL;

        }

    delete iSecpolReader6;

    iSecpolReader6 = NULL;

    delete iLastConflictInfo;

    iLastConflictInfo = NULL;

    delete iLastParsingErrorInfo;

    iLastParsingErrorInfo = NULL;

    delete iAlgorithmsHBufC8;

    iAlgorithmsHBufC8 = NULL;

    delete iPreloadPolicy;

    iPreloadPolicy = NULL;

    delete iBeforeManualLoadPolicy;

    iBeforeManualLoadPolicy = NULL;

    delete iAfterManualLoadPolicy;

    iAfterManualLoadPolicy = NULL;

    delete iBeforeScopedLoadPolicy;

    iBeforeScopedLoadPolicy = NULL;

    delete iAfterScopedLoadPolicy;

    iAfterScopedLoadPolicy = NULL;

#ifdef TESTFLAG

	delete iStringBuf;

	iStringBuf = NULL;

#endif

    // Release  scoped autoload policy array

    for (TInt i = iScopedAutoloadPolicyPairs.Count() - 1; i >= 0; i--)

        {

        delete iScopedAutoloadPolicyPairs[i];

        iScopedAutoloadPolicyPairs.Remove(i);

        }

    // Close array to avoid memory leaks

    iScopedAutoloadPolicyPairs.Close();

    ReleaseResources();

    iFs.Close();

    iSS.Close();

    delete iSelectorInfoArray;

    iSelectorInfoArray = NULL;

    }

//

// Release resources allocated for a call

//

void 

CIPSecPolicyManagerHandler::ReleaseResources()

    {

    delete iPieceData;

    iPieceData = NULL;

    delete iPieceData2;

    iPieceData2 = NULL;

    delete iSAInfo;

    iSAInfo = NULL;

    delete iSelectorInfo;

    iSelectorInfo = NULL;

    delete iPolicyHBufC8;

    iPolicyHBufC8 = NULL;

    delete iPolBfr;

    iPolBfr = NULL;

#ifdef TESTFLAG

    delete iHandles;	

    iHandles = NULL;

#endif

    if (iSecpolSocketOpen)

        {

        iSecpolSocketOpen = EFalse;

        iSock.Close();

        }

    if (iAlgorithmsFileOpen)

        {

        iAlgorithmsFileOpen = EFalse;

        iAlgFile.Close();

        }

    }

//

// ErrorHandling - Leave is trapped by server's RunError()

//

void 

CIPSecPolicyManagerHandler::ErrorHandlingL(

    TInt aMainCode,

    TInt aDetailCode)

    {

    LOG(Log::Printf(_L("ErrorHandling: main status: %d  detail status: %d\n"),

                    aMainCode, aDetailCode));

#ifndef __FLOG_ACTIVE

    (void)aDetailCode;

#endif

    User::Leave(aMainCode);

    }

//

//

// ProcessLoadPolicy - Process a LoadPolicy request issued

// by IPSecPolicyManApi

//

//

TInt 

CIPSecPolicyManagerHandler::ProcessLoadPolicyL(

    const RMessage2& aMsg,

    const CIPSecPolicyManagerSession* /* aIPSecPolicyManagerSession */,

    TPolicyType aPolType)

    {

    // Retrieve arguments

    // (1): Policy data buffer length

    TInt policyDataLth = aMsg.GetDesLengthL(FIRST_ARGUMENT);

    // (2): Policy data buffer contents

    delete iPolicyHBufC8;

    iPolicyHBufC8 = NULL;

    iPolicyHBufC8 = HBufC8::NewL(policyDataLth);

    TPtr8 policyDataDesc(iPolicyHBufC8->Des());

    aMsg.ReadL(FIRST_ARGUMENT, policyDataDesc);

    // (3): Zone info (optional)

    TZoneInfoSet zoneInfoSet;

    if (aMsg.GetDesLength(THIRD_ARGUMENT) <= 0)

        {

        zoneInfoSet = KDefaultZoneInfo;

        iFunction = 0;

        }

    else

        {

        iFunction = aMsg.Int3();

        TPckg<TZoneInfoSet>pckgZoneInfoSet(zoneInfoSet);

        aMsg.ReadL(THIRD_ARGUMENT, pckgZoneInfoSet);

        }

    iVPNNetId = 0;

    if (zoneInfoSet.iSelectorZone.iScope != KScopeNone)

        {

        iVPNNetId = zoneInfoSet.iSelectorZone.iId;

        }

    iGwNetId = 0;

    if (zoneInfoSet.iEndPointZone.iScope != KScopeNone)

        {

        iGwNetId = zoneInfoSet.iEndPointZone.iId;

        }

    LOG(Log::Printf(_L("LoadPolicy request VPN NetId: %d  GW NetId: %d\n"),

                    iVPNNetId, iGwNetId));

    // Parse the policy file from string format to the ipsecpolparser

    // class object format

    ParseCurrentPolicyL();

    // Calculate the Bypass/Drop mode of parsed policy

    TInt policyBypassDropMode(KDropMode);

    CSecurityPolicy* policy = iPieceData->Policies();

    policyBypassDropMode = CalculatePolicyBypassDropMode(*policy);

    // Check if we have a direct Bypass-everything-else Vs Drop-everything-else conflict between the active policy and 

    // the one that is attempted to be loaded. If so, return with error

    TInt activepolicyBypassDropMode; 

    //coverity[var_compare_op]

    //intentional null comparision if there is no policylist do nothing.

    if (iActivePolicyList && iActivePolicyList->Count())

        {

        //coverity[var_compare_op]   

        // It is ok to compare with the first active policy. Every subsequent policy would have been compared against the first one

        activepolicyBypassDropMode = iActivePolicyList->At(0)->iBypassOrDropMode;

        if((policyBypassDropMode == KDropMode && (( activepolicyBypassDropMode & KInboundBypass) || (activepolicyBypassDropMode & KOutboundBypass))) || 

                (((policyBypassDropMode & KInboundBypass) || (policyBypassDropMode & KOutboundBypass)) && activepolicyBypassDropMode == KDropMode )) 

            {

            ErrorHandlingL (ESelectorConflict,0);

            }

        } 

    // Add VPNNetId to CPolicySelector and GwNetId to CSecpolBundleItem objects

    UpdateSelectorsAndTunnels();

    // Check if the IP addresses in the selectors of current policy

    // file overlaps with the selectors of the policies in the active

    // policy list. Overlapping is allowed when the scope IDs differ

    // or all parameters in the selectors and corresponding SA

    // match exactly.

    CheckSelectorConflictsL();

    //  Modify the SA names to avoid conflicts caused by equal names

    //  in different policies

    MakeUniqueSANamesL();

    // Convert object format policy pieces to string format

    // and do the operations defined by the API flags

    ConvertFromObjectsToStringWithSectionsL(iFunction,

                                            policyBypassDropMode);

    // Store current policy entry to active policy list

    StorePolicyToActiveListL(aPolType, policyBypassDropMode);

    LOG(Log::Printf(_L("LoadPolicy request completed OK, handle: %d\n"),

                    iCurrentPolicyHandle.iHandle));

    // Return the current policy file handle to the API user

    ReturnPolicyFileHandleL(aMsg);

    // An API call completed

    ApiCallCompleted();

    return KErrNone;

    }

//

//

// ProcessLoadPoliciesL - Process a LoadPolicy request issued

// by IPSecPolicyManApi. This method considers autoload policies as well

//

//

TInt 

CIPSecPolicyManagerHandler::ProcessLoadPoliciesL(

    const RMessage2& aMsg,

    const CIPSecPolicyManagerSession* aSession)

    {

    // Read scope information

    TBool scopedLoad = EFalse;

    TInt preLoadHandle(0);

    TInt postLoadHandle(0);

    TInt parentPolicyHandle(0);

    TInt leaveCode(0);

    TZoneInfoSet zoneInfoSet;

    if (aMsg.GetDesLength(THIRD_ARGUMENT) <= 0)    // Use default zoneInfo

        {

        zoneInfoSet = KDefaultZoneInfo;

        // Processing flags

        iFunction = 0;

        }

    else

        {

        scopedLoad = ETrue;

        iFunction = aMsg.Int3();

        TPckg<TZoneInfoSet>pckgZoneInfoSet(zoneInfoSet);

        aMsg.ReadL(THIRD_ARGUMENT, pckgZoneInfoSet);

        }

    iVPNNetId = 0;

    if (zoneInfoSet.iSelectorZone.iScope != KScopeNone)

        {

        iVPNNetId = zoneInfoSet.iSelectorZone.iId;

        }

    iGwNetId = 0;

    if (zoneInfoSet.iEndPointZone.iScope != KScopeNone)

        {

        iGwNetId = zoneInfoSet.iEndPointZone.iId;

        }

    LOG(Log::Printf(_L("LoadPolicy request VPN NetId: %d  GW NetId: %d\n"),

                    iVPNNetId, iGwNetId));

    if (scopedLoad)

        {

        // Load BeforescopedLoadPolicies before

        if (iBeforeScopedLoadPolicy->Size() != 0)

            {

            TRAP(leaveCode,

                 AutoloadPoliciesL(zoneInfoSet,

                                   iBeforeScopedLoadPolicy,

                                   EAutoloadBeforeScopedLoad));

            if (leaveCode != KErrNone)

                {

                LOG(Log::Printf(_L("Autoload failed for parent policy: %d\n"),

                                aMsg.Int0()));

                }

            else

                {

                preLoadHandle = iCurrentPolicyHandle.iHandle;

                }

            }

        // Load the policy itself

        ProcessLoadPolicyL(aMsg, aSession, EScopedManualLoad);

        parentPolicyHandle = iCurrentPolicyHandle.iHandle;

        // Load BeforescopedLoadPolicies before

        if (iAfterScopedLoadPolicy->Size() != 0 )

            {

            TRAP(leaveCode,

                 AutoloadPoliciesL(zoneInfoSet,

                                   iAfterScopedLoadPolicy,

                                   EAutoloadAfterScopedLoad));

            if (leaveCode != KErrNone)

                {

                LOG(Log::Printf(_L("Autoload failed for parent policy: %d\n"),

                                aMsg.Int0()));

                }

            else

                {

                postLoadHandle = iCurrentPolicyHandle.iHandle;

                }

            }

        if (parentPolicyHandle != 0

            && (preLoadHandle != 0 || postLoadHandle != 0))

            {

            // Add the policy hadle pair to an 'unload list'

            AddScopedAutoloadPolicyPairL(preLoadHandle,

                                         postLoadHandle,

                                         parentPolicyHandle);

            }

        }

    else

        {

        // In case of manual load

        if (iManualAutoloadHandlePair.iManualPreloadHandle.iHandle == 0

            && iManualAutoloadHandlePair.iManualPostLoadHandle.iHandle == 0)

            {

            // Load BeforescopedLoadPolicies before

            if (iBeforeManualLoadPolicy->Size() != 0)

                {

                TRAP(leaveCode,

                     AutoloadPoliciesL(zoneInfoSet,

                                       iBeforeManualLoadPolicy,

                                       EAutoloadBeforeManualLoad));

                if (leaveCode != KErrNone)

                    {

                    LOG(Log::Printf(_L("Autoload failed for parent policy: %d\n"),

                                    aMsg.Int0() ));

                    }

                else

                    {

                    iManualAutoloadHandlePair.iManualPreloadHandle.iHandle =

                        iCurrentPolicyHandle.iHandle;

                    }

                }

            // Load the policy itself

            ProcessLoadPolicyL(aMsg, aSession, EManualLoad);

            // Load AfterManualLoadPolicies

            if (iAfterManualLoadPolicy->Size() != 0)

                {

                TRAP(leaveCode,

                     AutoloadPoliciesL(zoneInfoSet,

                                       iAfterManualLoadPolicy,

                                       EAutoloadAfterManualLoad));

                if (leaveCode != KErrNone)

                    {

                    LOG(Log::Printf(_L("Autoload failed for parent policy: %d\n"),

                                    aMsg.Int0() ));

                    }

                else

                    {

                    iManualAutoloadHandlePair.iManualPostLoadHandle.iHandle =

                        iCurrentPolicyHandle.iHandle;

                    }

                }

            }

        else

            {

            // Load the policy itself

            ProcessLoadPolicyL(aMsg, aSession, EManualLoad);

            }

        }

    return KErrNone;

    }

//

//

// ProcessActivatePolicy - Process an ActivatePolicy request issued

// by IPSecPolicyManApi

//

//

TInt 

CIPSecPolicyManagerHandler::ProcessActivatePolicyL(

    const RMessage2& aMsg,

    const CIPSecPolicyManagerSession* aIPSecPolicyManagerSession)

    {

    // Store the parameters to this object

    iSession = aIPSecPolicyManagerSession;

    iCurrentPolicyHandle.iHandle = aMsg.Int0();

    LOG(Log::Printf(_L("ActivatePolicy request, handle: %d\n"),

                    iCurrentPolicyHandle.iHandle));

    // Search from the active policy list the policy corresponding

    // to the current policy handle and activate it

    TInt ret = SearchPolicyFromListAndActivate();

    if (ret != KErrNone)

        {

        ErrorHandlingL(ret, 0 );