// 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:

// IPSecPolicyManHandler.h - IPSec Policy Manager Handler

//

/**

 @internalComponent

*/

#ifndef __IPSECPOLICYMANHANDLER__

#define __IPSECPOLICYMANHANDLER__

#include <e32base.h>

#include <e32std.h>

#include <f32file.h>

#include <es_sock.h>

#include <in_sock.h>

#include "ipsecpolapi.h"

#include "ipsecpol.h"

#include "autoloadlistitem.h"

#ifdef SYMBIAN_IPSEC_VOIP_SUPPORT

#include "spdb.h"

#endif // SYMBIAN_IPSEC_VOIP_SUPPORT

//

// Direction codes

//

//

enum direction

{

    EInbound = 1,

    EOutbound

};

//

// iBypassOrDropMode flags

//

//

const TInt KDropMode       = 0;          // Drop mode

const TInt KInboundBypass  = (1 << 0);   // Inbound bypass mode

const TInt KOutboundBypass = (1 << 1);   // Outbound bypass mode

//

// Forward declarations

//

//

class CSecpolReader;

class CIPSecPolicyManagerServer;

class CPolicySelector;

class CIPSecPolicyManagerSession;

class CSelectorList;

class CIpSecurityPiece;

class TIpsecSelectorInfo;

class TIpsecSaSpec;

class CAutoloadListItem;

class CSecurityPolicy;

class TSecurityAssocSpec;

//

// Active Policy list entry

//

struct TActivePolicyListEntry

    {

    TPolicyHandle iPolicyHandle;

    HBufC8* iPolicyBuf;

    TBool iActiveState;       // EFalse = loaded, not active; ETrue = active

    TInt iBypassOrDropMode;   // See flags below

    TPolicyType iPolicyType;

    };

typedef CArrayFixFlat<TActivePolicyListEntry*> CActivePolicyList;

//

//

//

struct TManualAutoloadHandlePair

    {

    TPolicyHandle iManualPreloadHandle;

    TPolicyHandle iManualPostLoadHandle;

    };

//

// Policy Manager Handler Class

//

class CIPSecPolicyManagerHandler : public CBase

    {

public:

    static CIPSecPolicyManagerHandler* NewL(CIPSecPolicyManagerServer* aServer);

    void ConstructL();

    ~CIPSecPolicyManagerHandler();

    //

    // Policy Manager API related methods

    //

    TInt ProcessLoadPolicyL(

        const RMessage2& aMsg,

        const CIPSecPolicyManagerSession* aIPSecPolicyManagerSession,

        TPolicyType aPolType);

    TInt ProcessLoadPoliciesL(

        const RMessage2& aMsg,

        const CIPSecPolicyManagerSession* aIPSecPolicyManagerSession);

    TInt ProcessActivatePolicyL(

        const RMessage2& aMsg,

        const CIPSecPolicyManagerSession* aIPSecPolicyManagerSession);

    TInt ProcessActivateAutoloadPolicyL(

        const CIPSecPolicyManagerSession* aIPSecPolicyManagerSession);

    TInt ProcessUnloadPolicyL(

        const RMessage2& aMsg,

        const CIPSecPolicyManagerSession* aIPSecPolicyManagerSession);

    TInt ProcessUnloadPoliciesL(

        const RMessage2& aMsg,

        const CIPSecPolicyManagerSession* aIPSecPolicyManagerSession);

    TInt UnloadPolicyByHandleL(

        TUint32 aPolicyHandle,

        const CIPSecPolicyManagerSession* aIPSecPolicyManagerSession);

    TInt GetIPSecSAInfoL(

        const RMessage2& aMsg,

        const CIPSecPolicyManagerSession* aIPSecPolicyManagerSession);

    TInt GetLastConflictInfoL(

        const RMessage2& aMsg,

        const CIPSecPolicyManagerSession* aIPSecPolicyManagerSession);

#ifdef TESTFLAG

    TInt RequestEvent(

        const RMessage2& aMsg,

        const CIPSecPolicyManagerSession* aIPSecPolicyManagerSession); 

#endif 

    void ErrorHandlingL(TInt aMainCode, TInt aDetailCode);

    void ReleaseResources();

    void ParseCurrentPolicyL();

    void UpdateSelectorsAndTunnels();

    void ConvertFromObjectsToStringWithSectionsL(TInt aFunction,

                                                 TInt aBypassDropMode);

    void ConvertFromObjectsToStringWithoutSectionsL();

    void StorePolicyToActiveListL(TPolicyType aPolType,

                                  TInt aBypassDropMode);

    void ParseAllPolicyFilesL();

    void MakeUniqueSANamesL();

    void SortSelectors();

    void ConvertFromObjectsToStringL();

    void SendAlgorithmsAndPolicyToIPSecL(const TDesC& aSocket);

    void SendNullFileToIPSecL(const TDesC& aSocket);

    void ReturnPolicyFileHandleL(const RMessage2& aMsg);

    void ApiCallCompleted();

    TInt DeletePolicyFromList();

    TInt SearchPolicyFromListAndActivate();

    TInt GetAvailableSelectors(const RMessage2& aMsg);

    TInt GetSelectorsCount(const RMessage2& aMsg);

    //

    // Miscallenious utilities related to building policy data  

    //

    TInt WriteTunnelModeIkeNegotiationStringsL(HBufC8*& aPolBfr);

    void BuildTunnelModeIkeString(

        TDes8& aString,

        TInt aDirection,

        TInt aPort,

        TInetAddr& aGWAddr);

    TInt WriteTransportModeIkeNegotiationStrings(HBufC8*& aPolBfr);

    void BuildTransportModeIkeString(

        TDes8& aString,

        TInt aPort,

        TInetAddr& aRemote,

        TInetAddr& aRemoteMask);

    TInt BuildDhcpProtocolString(HBufC8*& aPolBfr);

    TInt BuildMip4BypassSelectors(HBufC8*& aPolBfr);

    TInt BuildComparisonWord(CSelectorList* aSelList);

    TInt SetSequenceNumbers(CSelectorList* aSelList);

    TInt CalculateMaskLength(TInetAddr& aMask);

    TInt MaskLength(TUint32 aAddr);

    TInt MaskLength(const TIp6Addr &aAddr);

    void DeleteExtraInboundOutboundSelectors();

    TInt AddInboundOutboundSelectorPair();

    void InboundOutboundSelectors();

    CPolicySelector* FindMatchingSelector();

    void FillSAInfoObject(CPolicySelector* aPolicySelector, TInt aIndex);

    TBool IsBypassEverythingElse(const CPolicySelector& aPolicySelector) const;

    TBool IsDropEverythingElse(const CPolicySelector& aPolicySelector) const;

    TBool IsEqualInterface(const CPolicySelector& aP1,

                           const CPolicySelector& aP2) const;

    TBool IsEqualRemoteAddress(const CPolicySelector& aP1,

                               const CPolicySelector& aP2) const;

    TBool IsEqualLocalAddress(const CPolicySelector& aP1,

                              const CPolicySelector& aP2) const;

#ifdef SYMBIAN_IPSEC_VOIP_SUPPORT

    TBool IsEqualSaSpec(CSecpolBundleItem* aS1, 

                        CSecpolBundleItem* aS2) const;

#else

    TBool IsEqualSaSpec(TSecurityAssocSpec* aS1, 

                        TSecurityAssocSpec* aS2) const;

#endif     

    void FillSelectorInfoObject();

    //

    // Policy conflict checking related methods

    //

    TBool CalculateCombinedPolicyBypassDropMode();

    void CheckSelectorConflictsL();

    void TakeNextActivePolicyL(TInt aIndex);

    void CompareSelectorsL(CPolicySelector *aPolicySelector);

    TInt CompareSAParameters(

        CPolicySelector* aPolicySelectorNew,

        CPolicySelector* aPolicySelectorOld);

    TBool CheckAddressOverlapping(

        TUint32 aNet1IpAddress,    // Net1 low address

        TUint32 aNet1Mask,         // Net1 mask

        TUint32 aNet2IpAddress,    // Net2 low address

        TUint32 aNet2Mask);        // Net2 mask

    TInt GetRangeHighAddress(

        TUint32& aNetIpAddressHigh,

        TUint32 aNetIpAddressLow,

        TUint32 aNetMask);

    void ConflictTestForPortsAndProtocolL();

    TInt ComparePortProtocol(

        CPolicySelector *aPolicySelector1,

        CPolicySelector *aPolicySelector2);

    void BuildConflictInfoL();

    // Autoload related methods

    void ReadAutoloadConfigDataL();

    // Perform autoload policies

    void AutoloadPoliciesL(

        const TZoneInfoSet& aZoneInfoSet,

        HBufC8* aPolicyBuffer,

        TAutoloadFlags aAutoloadType = EAutoloadNone);

    // Get the autoload flag

    inline TBool IsPreloadNeeded()

        {

        return iIsPreloadNeeded;

        }

    // Set autoload flag

    inline void SetAutoloadStatus(TAutoloadFlags aAutoloadFlag)

        {

        iAutoloadFlag = aAutoloadFlag;

        }

    // Check if autoload policy is active

    TBool IsAutoloadPolicyActive();

    // Set the autoload policy flag

    void SetAutoloadPolicyActive(TBool aIsAutoloadPolicyActive);

    // Store autoload policy handle

    void StorePreloadPolicyHandle();

    // Return autoload policy handle

    TUint32 GetAutoloadPolicyHandle();

    // Find an autoload policy handle based on the parent policy handle

    CAutoloadListItem* FindScopedAutoloadPolicyPair(

        TUint32 aParentPolicyHandle);

    // Add an autoload policy handle based on the parent policy handle

    void AddScopedAutoloadPolicyPairL(

        TUint32 aPreloadPolicyHandle,

        TUint32 aPostloadPolicyHandle,

        TUint32 aParentPolicyHandle);

    //delete the scoped autoload policy pair

    void DeleteScopedAutoloadPolicyPair(TUint32 aParentPolicyHandle);

    //calculate the bypass mode

    void CalculateBypassOrDropMode(TBool aForLoadPolicy);

    //determines whether the last manual autoload policy has been unloaded

    TBool IsLastManualLoadPolicy(TUint32 aPolicyHandle);

private:

    // Read the algorithms.conf file

    void ReadAlgorithmsFileL();

    void ReadNextAutoloadPolicyL(

        HBufC8*& aAutoloadPolicyBuffer,

        TPtrC& aPolicyFileName);

    void UpdatePolicySelectorScopeId(CPolicySelector& aPolicySelector,

                                     TInt aScopeId);

    void UpdatePolicyBundleScopeId(CPolicySelector& aPolicySelector,

                                   TInt aScopeId,

                                   TInt aGwScopeId,

                                   TBool& aIsTunnelMode);

    TInt CalculatePolicyBypassDropMode(CSecurityPolicy& aSp) const;

public:

    // List containing all loaded policies

    CActivePolicyList* iActivePolicyList;

    // Handle into the Socket server

    RSocketServ iSS;

private:

    TPolicyHandle iNextPolicyHandle;

    TPolicyHandle iCurrentPolicyHandle;

    TPckg<TIpsecSaSpec>* iPckgSAInfo;

    TIpsecSaSpec* iSAInfo;

    TInt iVPNNetId;

    TInt iGwNetId;

    TInt iFunction;

    HBufC8* iPolicyHBufC8;

    HBufC8* iPolBfr;

    HBufC8* iAlgorithmsHBufC8;

    // Info section data of active policy

    HBufC8* iLastConflictInfo;

    // A string copied from ipsecpolparser

    HBufC8* iLastParsingErrorInfo;

#ifdef TESTFLAG

    HBufC* iStringBuf;

    TAutoloadHandles* iHandles;

#endif

    TIpsecSelectorInfo* iSelectorInfo;

    // Used to parse current policy

    CIpSecurityPiece* iPieceData;

    // Used to parse active policy list entries

    CIpSecurityPiece* iPieceData2;

    // Bypass/Drop mode of the combined policy

    TInt iBypassOrDropMode;

    const CIPSecPolicyManagerSession *iSession;

    CSecpolReader* iSecpolReader6;

    RSocket iSock;

    RFs iFs;

    RFile iAlgFile;

    TBool iSecpolSocketOpen;

    TBool iAlgorithmsFileOpen;

    // Autoload member variables

    TBool iIsPreloadNeeded;

    TManualAutoloadHandlePair iManualAutoloadHandlePair;

    // Autoload flag

    TAutoloadFlags iAutoloadFlag;

    TBool iIsAutoloadPolicyActive;

    HBufC8* iPreloadPolicy;

    HBufC8* iBeforeManualLoadPolicy;

    HBufC8* iAfterManualLoadPolicy;

    HBufC8* iBeforeScopedLoadPolicy;

    HBufC8* iAfterScopedLoadPolicy;

    TPolicyHandle iPreloadPolicyHandle;

    // Array storing the autoload-parent

    RPointerArray<CAutoloadListItem> iScopedAutoloadPolicyPairs;

    // Used to retrieve the gateway address passed by client in RIpsecPolicyServ::AvailableSelectors API

    TInetAddr iTunnel;

    CArrayFixFlat<TIpsecSelectorInfo>* iSelectorInfoArray;

    };

#endif