/*

* Copyright (c) 2002-2006 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: IPSec policy parser main module.

* A parser for IPsec policies. Converts textual IPsec policies into 

* in-memory data structures and vice versa. 

*

*/

#ifndef __IPSECPOLPARSER_H

#define __IPSECPOLPARSER_H

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

// INCLUDE FILES

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

#include <f32file.h>

#include <in_sock.h>

#include "spdb.h"

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

// CONSTANTS

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

#define FIRST_SEC_PARSER_VERSION    1

#define SEC_PARSER_VERSION          3

#define MAX_EALG_VALUE              255

#define MAX_INFO_SIZE               1024

#define PIECE_AVG_LENGTH            2048

#define PFKEY_INI_OUTBOUND          8

#define PFKEY_INI_INBOUND           4

#define KErrKeyParser               50

const TInt KPolicyBufferSizeIncrement = 6000;

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

// ENUMERATIONS

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

typedef enum

{

    token_string,

    token_equal,

    token_comma,

    token_brace_left,

    token_brace_right,

    token_par_left,

    token_par_right,

    token_error,

    token_eof

}

token_type;

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

// FORWARD DECLARATIONS

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

class CIpSecurityPiece;

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

// CLASS DECLARATIONS

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

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

// class TPolicyParser

//  This parser is utilized by IPsec Policy Manager to convert a given policy

//  from string format into binary object format and vice versa.

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

//

class TPolicyParser : public TLex

    {

public:

    IMPORT_C TPolicyParser(const TDesC& aPolicy);

    IMPORT_C TInt ParseL(CIpSecurityPiece* aPieceData);

    IMPORT_C static TInt Write(CSecurityPolicy* aSp,

                               HBufC8*& aPolBfr,

                               TBool aSortingOrder = EFalse);

    IMPORT_C static TInt BufferAppend(HBufC8*& aPolBfr,

                                      const TDesC8& aText);

private:

    static TInt WriteSAs(CSAList* aSAList,

                         HBufC8*& aPolBfr);

    static void TextSA(CPolicySpec* aSA, TDes8& aBuf);

    static TInt WriteSelectors(CSelectorList* aSelList,

                               HBufC8*& aPolBfr,

                               TBool aSortingOrder = EFalse);

    static TInt WriteSelectorsInSortingOrder(CSelectorList* aSelList,

            HBufC8*& aPolBfr,

            TBool aSortingOrder = ETrue);

    static void TextSel(CPolicySelector* aSel,

                        TDes8& aBuf,

                        TBool aSortingOrder = EFalse);

    TInt parse_ip_addr_and_maskL(TInetAddr& addr,

                                 TInetAddr& mask,

                                 HBufC8*& aSelEpName,

                                 HBufC8*& aMaskEpName,

                                 CSecurityPolicy* aSecPol = NULL);

    TInt parse_sa_spec_listL(TSecpolBundle& aBundle,

                             CSecurityPolicy* aSp, TInt& aFQDNCount);

    TInt parse_sa_spec_paramsL(CPolicySpec& aSpec);

    TInt parse_conn2saL(CSecurityPolicy* aSp);

    TInt parse_sa_specL(CSecurityPolicy* aSp);

    TInt parse_ep_specL(CSecurityPolicy* aSp);

    TInt parse_ep_spec_paramsL(CPolicySpec& aSpec);

    token_type NextToken();

    void SkipSpaceAndMark();

    void Error(TRefByValue <const TDesC> aFmt, ...);

public:

    int iLine;

    TBuf<200> iMsg;

    TPtrC iToken;

    };

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

// class CKeysData

//  This object contains IPsec key information.

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

//

class CKeysData : public CBase

    {

public:

    IMPORT_C CKeysData();

    IMPORT_C CKeysData(CKeysData* aKey);

public:

    TUint8 sa_type;

    TInt spi;

    TUint8 encr_alg;

    TUint8 auth_alg;

    TInt direction;

    TInt lifetime_bytes;

    TInt lifetime_sec;

    TInetAddr src_addr;

    TInetAddr dst_addr;

    TUint8 protocol;

    TBuf8<256> auth_key;

    TBuf8<256> encr_key;

    };

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

// class CKeysDataArray

//  Container for storing IPsec keys.

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

//

class CKeysDataArray : public CArrayFixFlat<CKeysData *>

    {

public:

    IMPORT_C static CKeysDataArray* NewL(TInt aGranularity);

    IMPORT_C static CKeysDataArray* NewL(CKeysDataArray* aData);

    IMPORT_C void Construct(TInt aGranularity);

    IMPORT_C void ConstructL(CKeysDataArray* aData);

    IMPORT_C ~CKeysDataArray();

    IMPORT_C void CopyL(CKeysDataArray* aData);

    IMPORT_C void Empty();

private:

    CKeysDataArray(TInt aGranularity);

    CKeysDataArray(CKeysDataArray* aData);

    };

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

// class TKeyParser

//  Parses IPsec key information from string format into binary format

//  and vice versa.

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

//

class TKeyParser : public TLex

    {

public:

    IMPORT_C TKeyParser(const TDesC& aStr);

    IMPORT_C TInt ParseL(CKeysDataArray* aKeys);

    IMPORT_C static TInt Write(CKeysDataArray* aKeys, RFile& aFile);

private:

    static void TextPFKey(CKeysData* aKey, TDes8& aElem);

    void NextToken();

    TPtrC8 DeHex(const TDesC& aStr);

    int SkipSpaceAndMark();

    static TUint8 HexVal(TUint8 aChar);

    TPtrC iToken;

    // Non-zero, if next token is first in line

    TInt iFirst;

    TBuf8<256> iHex;

    };

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

// class CIpSecurityPiece

//  Contains all IPsec policy information.

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

//

class CIpSecurityPiece : public CBase

    {

public:

    // Factory methods for object creation

    IMPORT_C void ConstructL(TInt aSize = 64);

    IMPORT_C ~CIpSecurityPiece();

    //

    IMPORT_C void SetInfoL(const TDesC& aDes);

    IMPORT_C CSecPolBundleList* FQDNAddressListL();

    inline HBufC* Info() { return iInfo;}

    inline CSecurityPolicy* Policies() { return iPolicies;}

    inline void SetPolicies(CSecurityPolicy* aPolicy) {iPolicies = aPolicy;}

    inline CKeysDataArray* Keys() { return iKeys;}

    // Buffer for last error text

    TBuf<200> iErrorInfo;

private:

    // Buffer for IPsec policy information text

    HBufC* iInfo;

    // IPsec Policy data

    CSecurityPolicy* iPolicies;

    // IPsec keys data

    CKeysDataArray* iKeys;

    // List of tunnel endpoint requiring DNS lookup

    CSecPolBundleList* iPolicyList;

    };

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

// class TIpSecParser

//  Parser for IPsec policies.

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

//

class TIpSecParser : public TLex

    {

public:

    IMPORT_C TIpSecParser(const TDesC& aDes);

    IMPORT_C TInt ParseL(CIpSecurityPiece* aPiece_data);

    IMPORT_C static TInt Write(CIpSecurityPiece* aPiece_data,

                               HBufC8*& aPolBfr);

    IMPORT_C TInt ParseAndIgnoreIKEL(CIpSecurityPiece* aPiece_data);

private:

    TBool CheckVersion();

    void ParseInfoL(CIpSecurityPiece* aPiece_data);

    TInt ParsePoliciesL(CIpSecurityPiece* aPieceData);

    TInt ParseKeysL(CKeysDataArray* aKeys);

    void NextTag();

    TInt DoParseL(CIpSecurityPiece* aPiece_data, TBool aIncludeIKE);

    static TInt WriteVersion(HBufC8*& aPolBfr);

    static TInt WriteInfo(CIpSecurityPiece* aPiece_data,

                          HBufC8*& aPolBfr);

    static TInt WritePolicies(CIpSecurityPiece* aPiece_data,

                              HBufC8*& aPolBfr);

    static TInt WriteKeys(CIpSecurityPiece* aPiece_data,

                          RFile& aFile);

private:

    // IPsec policy version info

    TInt iVersion;

    };

#endif