/*
* Copyright (c) 2002-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: 
* This file contains the class definitions for IPsec security policy.
*
*/



#ifndef _SPDB_H
#define _SPDB_H

//////////////////////////////////////////////////////////////////////////////
// INCLUDE FILES
//////////////////////////////////////////////////////////////////////////////

#include <in_sock.h>
#include "sa_spec.h"

//////////////////////////////////////////////////////////////////////////////
// FORWARD DECLARATIONS
//////////////////////////////////////////////////////////////////////////////

class CPolicySelector;
class CSecpolBundleItem;

//////////////////////////////////////////////////////////////////////////////
// ENUMERATIONS
//////////////////////////////////////////////////////////////////////////////

enum TPolicySpecType 
    { 
    EPolSpecSA,
    EPolSpecEP
    };

//////////////////////////////////////////////////////////////////////////////
// CONSTANTS
//////////////////////////////////////////////////////////////////////////////

const TUint KPolicySelector_INBOUND     = 0x1;

const TUint KPolicySelector_OUTBOUND    = 0x2;

const TUint KPolicySelector_SYMMETRIC   = 
    (KPolicySelector_INBOUND | KPolicySelector_OUTBOUND);
    
const TUint KPolicySelector_INTERFACE   = 0x4;

typedef class CArrayPtrFlat<CSecpolBundleItem> CSecPolBundleList;

//////////////////////////////////////////////////////////////////////////////
// CLASS DECLARATIONS
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
// class CPolicySpec
//  Specify requirements for a single Security Association. The same 
//  requirements can be shared by multiple policy bundles (policy actions).
//////////////////////////////////////////////////////////////////////////////
//
class CPolicySpec : public CBase
    {
    friend class CSecurityPolicy;

    public:
        HBufC8 *iName;

        // Actual storage of the Identity strings. If present, the 
        // TSecurityAssocSpec will only have constant reference to this !
        HBufC8 *iRemoteIdentity;
        HBufC8 *iLocalIdentity;
        
        IMPORT_C static CPolicySpec* NewL();

        IMPORT_C void Construct();

        IMPORT_C static CPolicySpec* NewL(TDesC &aName, 
                                          TPolicySpecType iSpectype = EPolSpecSA);

        IMPORT_C void ConstructL(TDesC &aName, 
                                 TPolicySpecType aSpectype = EPolSpecSA);

        // Used to initialize with an existing CPolicySpec
        IMPORT_C static CPolicySpec* NewL(CPolicySpec *aPolSpec);

        IMPORT_C void ConstructL(CPolicySpec *aPolSpec);
        
        IMPORT_C ~CPolicySpec();
        
        TSecurityAssocSpec iSpec;

        TEpSpec iEpSpec;

        TPolicySpecType iSpectype;

    private:
        CPolicySpec();

        TSglQueLink iNext;
    };


//////////////////////////////////////////////////////////////////////////////
// class CSecpolBundleItem
//////////////////////////////////////////////////////////////////////////////
//  
class CSecpolBundleItem : public CBase
    {
    friend class CSecurityPolicy;
    friend class CPolicySelector;

    public:
    
        ~CSecpolBundleItem();
    
        // Security Association specification
        CPolicySpec *iSpec;
        
        // Tunnel IP address     
        TInetAddr iTunnel;
              
        // Tunnel Endpoint name
        HBufC8* iTunnelEpName;
        
        HBufC* iTunnelEpFQDN;
        
        TSglQueLink iNext;
        
    };

//////////////////////////////////////////////////////////////////////////////
// class TSecpolBundle
//////////////////////////////////////////////////////////////////////////////
//  
class TSecpolBundle : public TSglQue<CSecpolBundleItem>
    {
    public:
        TSecpolBundle(): 

        TSglQue<CSecpolBundleItem>(_FOFF(CSecpolBundleItem, iNext)) {};
    };

typedef class TSglQueIter<CSecpolBundleItem> TSecpolBundleIter;

//////////////////////////////////////////////////////////////////////////////
// class CSAList
//////////////////////////////////////////////////////////////////////////////
//
class CSAList : public CArrayFixFlat<CPolicySpec *>
    {
    public:
        IMPORT_C static CSAList* NewL(TInt aGranularity);

        IMPORT_C void Construct(TInt aGranularity);

        IMPORT_C static CSAList* NewL(CSAList *aSAList);

        IMPORT_C void ConstructL(CSAList *aSAList);
    private:

        CSAList(TInt aGranularity);

        CSAList(CSAList *aSAList);
    };

//////////////////////////////////////////////////////////////////////////////
// struct TSAPairNode
//////////////////////////////////////////////////////////////////////////////
//
struct TSAPairNode
    {
    CPolicySpec *iOldSA;
    CPolicySpec *iNewSA;
    TSAPairNode *iNext;
    };

//////////////////////////////////////////////////////////////////////////////
// class CSAPairList
//  Translation table used when copying a policy
//////////////////////////////////////////////////////////////////////////////
//
class CSAPairList : public CBase
    {
    public:
        ~CSAPairList();

        void AddL(CPolicySpec *aOldSA, CPolicySpec *aNewSA);

        CPolicySpec *Translate(CPolicySpec *aOldSA);
    private:

        TSAPairNode *iList;
    };

//////////////////////////////////////////////////////////////////////////////
// class CSelectorList
//////////////////////////////////////////////////////////////////////////////
//
class CSelectorList : public CArrayFixFlat<CPolicySelector *>
    {
    public:
        IMPORT_C static CSelectorList* NewL(TInt aGranularity);

        IMPORT_C void Construct(TInt aGranularity);

        IMPORT_C static CSelectorList* NewL(CSelectorList* CPolicySelector, 
                                            CSAPairList* aTable);
                                            
        IMPORT_C void ConstructL(CSelectorList *CPolicySelector,
                                 CSAPairList *aTable);
                                 
    private:
        CSelectorList(TInt aGranularity);
        
        CSelectorList(CSelectorList *CPolicySelector, CSAPairList *aTable);
    };

//////////////////////////////////////////////////////////////////////////////
// class CPolicySelector
//  Map the selectors from an IP packet/connection into a bundle
//////////////////////////////////////////////////////////////////////////////
//
class CPolicySelector : public CBase
    {
    friend class CSecurityPolicy;
    friend class TParser;
    public:
        IMPORT_C static CPolicySelector* NewL();
        IMPORT_C void Construct();
        IMPORT_C static CPolicySelector* NewL(CPolicySelector *aPS);
        IMPORT_C void ConstructL(CPolicySelector *aPS);
        
        IMPORT_C ~CPolicySelector();
        
        TInt Match(const TInetAddr& aSrc, 
                   const TInetAddr& aDst,
                   TInt aProtocol, 
                   TInt aIcmpType, 
                   TInt aIcmpCode, 
                   TInt aType) const;
        
        // Checks if this policy is using this SA
        IMPORT_C TBool UseSA(CPolicySpec* aSA,
                             TInetAddr* tunnel = NULL);
        
        // Return a Copy of the aIndex element of the SA bundle
        CSecpolBundleItem* FindBundleL(TInt aIndex);
        
        // Gets the list of FQDN names requiring DNS lookup
        void GetFQDNAddressListL(CSecPolBundleList& aPolList);

    private:
        CPolicySelector();
        
    public:
        
        //
        // If the addr is to match any address, the mask must all zeroes
        // If the addr is to match as is, the mask must be all ones
        // If the selector is to match a transport connection, the
        // port numbers are stored as non-zero in iDst and iSrc,
        // and iProtocol is non-zero.
        //
        TUint iDirection;
        TInetAddr iRemote;      // including port selector, if port non-zero
        TInetAddr iRemoteMask;  // only address part used, as a mask
        TInetAddr iLocal;       // including port selector, if port non-zero
        TInetAddr iLocalMask;   // only address part used, as a mask
        HBufC8* iRemSelEpName;  //rem endpoint name
        HBufC8* iRemMaskEpName; //rem mask ep name
        HBufC8* iLocSelEpName;  //loc endpoint name
        HBufC8* iLocMaskEpName; //loc mask endpoint name
        TInt iProtocol;         // used, if non-zero
        TInt iIcmpType;         // used, if != -1
        TInt iIcmpCode;         // used, if != -1
        TInt iType;				// used, if != -1
        TBool iDropAction;       // ETrue - drop action
        TInt iSequenceNumber;   // Selector's writing sequence
        TUint32 iCompWord;      // Selector's sorting properties, see
        TBool iGlobalSelector;  //flag specifying if this is a global selector
        TBool iIsFinal;
        TBool iIsMerge;
        TSecpolBundle iBundle;
        TSglQueLink iNext;
        TBuf<20> iInterface; ///< Limited to specific interface, if non-NULL
        TInt    iFQDNCount;
    };

//////////////////////////////////////////////////////////////////////////////
// class CSecurityPolicy
//  Map the selectors from an IP packet/connection into a bundle
//////////////////////////////////////////////////////////////////////////////
//
class CSecurityPolicy : public CBase
    {
    friend class CProtocolSecpol;
    public:
        IMPORT_C CSecurityPolicy();
        IMPORT_C void ConstructL(CSecurityPolicy *aSecPol);
        IMPORT_C void ConstructL();
        ~CSecurityPolicy();

        IMPORT_C CPolicySpec *FindSpec(const TDesC8 &aName);

        TSecpolBundle *FindBundle(TUint aDirection, 
                                  const TInetAddr &aSrc, 
                                  const TInetAddr &aDst,
                                  TInt aProtocol,
                                  TInt aIcmpType,
                                  TInt aIcmpCode,
                                  TInt aType);

        TInt SearchForEPNameL(TDesC& aTokenString);   

        //
        // The following methods are really intended to be used only
        // by the Policy parser, not for generic consumption!
        //
        void GetFQDNAddressListL(CSecPolBundleList& aPolList);

        void Add(CPolicySpec *aSpec) 
            {
            iSpecs->AppendL(aSpec);
            }

        void Add(CPolicySelector *aSelector) 
            {
            iSelectors->AppendL(aSelector);
            }
        
        inline CSAList *SAList()
            {
            return iSpecs;
            }

        inline void SetSAList(CSAList *aSAList) 
            {
            delete iSpecs; 
            iSpecs = aSAList;
            }

        inline CSelectorList *SelectorList()
            {
            return iSelectors;
            }

        inline void SetSelectorList(CSelectorList *aSelList)
            {
            delete iSelectors; 
            iSelectors = aSelList;
            }
        
        inline void SetFQDNCount(const TInt& aCount) 
            {
            iFQDNCount = aCount;
            }

        inline void IncFQDNCount(const TInt& aCount = 1) 
            {
            iFQDNCount += aCount;
            }

        inline const TInt FQDNCount() const
            {
            return iFQDNCount;
            }
            
    private:

        CSAPairList* CreateTranslationTableL(CSAList* aOldSAList, 
                                             CSAList* aNewSAList);
        
    private:
        
        CSAList* iSpecs;

        CSelectorList* iSelectors;
        
        TInt        iFQDNCount;
    };
    
#endif