/*

* 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. 

*

*/

#include <e32std.h>

#include <coeutils.h>

#include "ipsecpolparser.h"

#include "logvpncommon.h"

// Policies Parsing

// Symbian change - start

#ifdef __VC32__

#pragma warning(disable : 4097) // typedef-name used as synonym for class-name

#endif

// Symbian change - end

EXPORT_C

TPolicyParser::TPolicyParser(const TDesC &aPolicy) : TLex(aPolicy)

    {}

EXPORT_C TInt

TPolicyParser::ParseL(CIpSecurityPiece* aPieceData)

    {

    LOG_("TPolicyParser::ParseL()\n");

    TInt err(KErrNone);

    iLine = 1;

    CSecurityPolicy* sp = aPieceData->Policies();

    while (!err && NextToken() == token_string)

        {

        if (iToken.Compare(_L("sa")) == 0)

            {

            err = parse_sa_specL(sp);

            }

        else if (iToken.Compare(_L("ep")) == 0)

            {

            err = parse_ep_specL(sp);

            }

        else

            {

            err = parse_conn2saL(sp);

            }

        }

    if (!err && !Eos())

        {

        // Parsing didn't detect error, but not all parsed!

        err = KErrGeneral;

        }

    if (err)

        {

        if (iMsg.Length() > 0 && iMsg.Length() < 200)

            {

            aPieceData->iErrorInfo.Copy(iMsg);

            }

        }

    return (err);

    }

EXPORT_C TInt

TPolicyParser::BufferAppend(HBufC8*& aPolBfr, const TDesC8& aText)

    {

    LOG_("TPolicyParser::BufferAppend()\n");

    TInt err(KErrNone);

    // Make sure that we have enough space for the new text

    TInt spaceLeft = aPolBfr->Des().MaxLength() - aPolBfr->Des().Length();

    if (aText.Length() > spaceLeft)

        {

        // Allocate enough space for the new text + some additional

        // free space so that allocations are not too frequent

        TInt newMaxLength = aPolBfr->Des().MaxLength()

                            + aText.Length()

                            + KPolicyBufferSizeIncrement;

        HBufC8* tempBfr = aPolBfr->ReAlloc(newMaxLength);

        if (tempBfr != NULL)

            {

            aPolBfr = tempBfr;

            }

        else

            {

            return KErrNoMemory;

            }

        }

    aPolBfr->Des().Append(aText);

    return err;

    }

EXPORT_C TInt

TPolicyParser::Write(CSecurityPolicy *aSp,

                     HBufC8*& aPolBfr,

                     TBool aSortingOrder)

    {

    LOG_("TPolicyParser::Write()\n");

    TInt err = WriteSAs(aSp->SAList(), aPolBfr);

    if (err)

        {

        return err;

        }

    if (aSortingOrder)

        {

        err = WriteSelectorsInSortingOrder(aSp->SelectorList(),

                                           aPolBfr,

                                           aSortingOrder);

        }

    else

        {

        err = WriteSelectors(aSp->SelectorList(), aPolBfr, aSortingOrder);

        }

    return err;

    }

TInt

TPolicyParser::WriteSAs(CSAList* aSAList, HBufC8*& aPolBfr)

    {

    LOG_("TPolicyParser::WriteSAs()\n");

    TBuf8<1024> aux;

    TInt err(KErrNone);

    TInt count = aSAList->Count();

    for (TInt i = 0; i < count ; i++)

        {

        TextSA(aSAList->At(i), aux);

        err = BufferAppend(aPolBfr, aux);

        if (err != KErrNone)

            {

            return err;

            }

        }

    return KErrNone;

    }

void

TPolicyParser::TextSA(CPolicySpec* aSA, TDes8& aBuf)

    {

    LOG_("TPolicyParser::TextSA()\n");

    if (aSA->iSpectype == EPolSpecSA)

        {

        aBuf.Format(_L8("sa "));

        // SA name

        aBuf.Append(aSA->iName->Des());

        aBuf.Append(_L8(" = {\n"));

        switch (aSA->iSpec.iType)

            {

            case SADB_SATYPE_AH:

                aBuf.Append(_L8(" ah\n"));

                break;

            case SADB_SATYPE_ESP:

                aBuf.Append(_L8(" esp\n"));

                break;

            default:        //SADB_SATYPE_UNSPEC

                aBuf.Append(_L8(" ???")); //Shouldn't happen

            }

        // Encryption Algorithm

        if (aSA->iSpec.iEalg != 0)

            {

            // Encryption Alg

            aBuf.AppendFormat(_L8(" encrypt_alg %d\n"), aSA->iSpec.iEalg);

            }

        if (aSA->iSpec.iEalgLen != 0)

            {

            aBuf.AppendFormat(_L8(" max_encrypt_bits %d\n"), aSA->iSpec.iEalgLen);

            }

        // Authentication Algorithm

        if (aSA->iSpec.iAalg != 0)

            {

            aBuf.AppendFormat(_L8(" auth_alg %d\n"), aSA->iSpec.iAalg);

            }

        if (aSA->iSpec.iAalgLen != 0)

            {

            aBuf.AppendFormat(_L8(" max_auth_bits %d\n"), aSA->iSpec.iAalgLen);

            }

        if (aSA->iSpec.iPfs != 0)

            {

            aBuf.Append(_L8(" pfs\n"));

            }

        if (aSA->iRemoteIdentity != NULL)

            {

            aBuf.Append(_L8(" identity_remote "));

            aBuf.Append(aSA->iRemoteIdentity->Des());

            aBuf.Append('\n');

            }

        if (aSA->iLocalIdentity != NULL)

            {

            aBuf.Append(_L8(" identity_local "));

            aBuf.Append(aSA->iLocalIdentity->Des());

            aBuf.Append('\n');

            }

        if (aSA->iSpec.iReplayWindowLength != 0)

            {

            aBuf.AppendFormat(_L8(" replay_win_len %d\n"),

                              aSA->iSpec.iReplayWindowLength);

            }

        if (aSA->iSpec.iMatchProtocol != 0)

            {

            aBuf.Append(_L8(" protocol_specific\n"));

            }

        if (aSA->iSpec.iMatchLocalPort != 0)

            {

            aBuf.Append(_L8(" local_port_specific\n"));

            }

        if (aSA->iSpec.iMatchRemotePort != 0)

            {

            aBuf.Append(_L8(" remote_port_specific\n"));

            }

        if (aSA->iSpec.iMatchProxy != 0)

            {

            aBuf.Append(_L8(" proxy_specific\n"));

            }

        if (aSA->iSpec.iMatchSrc != 0)

            {

            aBuf.Append(_L8(" src_specific\n"));

            }

        if (aSA->iSpec.iMatchLocal != 0)

            {

            aBuf.Append(_L8(" local_specific\n"));

            }

        if (aSA->iSpec.iMatchRemote != 0)

            {

            aBuf.Append(_L8(" remote_specific\n"));

            }

        if (aSA->iSpec.iHard.sadb_lifetime_allocations != 0)

            {

            aBuf.AppendFormat(_L8(" hard_lifetime_allocations %d\n"),

                              aSA->iSpec.iHard.sadb_lifetime_allocations);

            }

        if (aSA->iSpec.iHard.sadb_lifetime_bytes != 0)

            {

            aBuf.AppendFormat(_L8(" hard_lifetime_bytes %d\n"),

                              aSA->iSpec.iHard.sadb_lifetime_bytes);

            }

        if (aSA->iSpec.iHard.sadb_lifetime_addtime != 0)

            {

            aBuf.AppendFormat(_L8(" hard_lifetime_addtime %d\n"),

                              aSA->iSpec.iHard.sadb_lifetime_addtime);

            }

        if (aSA->iSpec.iHard.sadb_lifetime_usetime != 0)

            {

            aBuf.AppendFormat(_L8(" hard_lifetime_usetime %d\n"),

                              aSA->iSpec.iHard.sadb_lifetime_usetime);

            }

        if (aSA->iSpec.iSoft.sadb_lifetime_allocations != 0)

            {

            aBuf.AppendFormat(_L8(" soft_lifetime_allocations %d\n"),

                              aSA->iSpec.iSoft.sadb_lifetime_allocations);

            }

        if (aSA->iSpec.iSoft.sadb_lifetime_bytes != 0)

            {

            aBuf.AppendFormat(_L8(" soft_lifetime_bytes %d\n"),

                              aSA->iSpec.iSoft.sadb_lifetime_bytes);

            }

        if (aSA->iSpec.iSoft.sadb_lifetime_addtime != 0)

            {

            aBuf.AppendFormat(_L8(" soft_lifetime_addtime %d\n"),

                              aSA->iSpec.iSoft.sadb_lifetime_addtime);

            }

        if (aSA->iSpec.iSoft.sadb_lifetime_usetime != 0)

            {

            aBuf.AppendFormat(_L8(" soft_lifetime_usetime %d\n"),

                              aSA->iSpec.iSoft.sadb_lifetime_usetime);

            }

        aBuf.AppendFormat(_L8(" }\n\n"));

        }

    else

        {

        TBuf<39> addr;

        aBuf.Format(_L8("ep "));

        // EndPoint name

        aBuf.Append(aSA->iName->Des());

        aBuf.Append(_L8(" = {"));

        if (aSA->iEpSpec.iIsOptional)

            {

            aBuf.Append(_L8(" ? "));

            }

        aSA->iEpSpec.iEpAddr.OutputWithScope(addr);

        aBuf.Append(addr);

        aBuf.Append(_L8(" }\n\n"));

        }

    }

TInt

TPolicyParser::WriteSelectors(CSelectorList* aSelList,

                              HBufC8*& aPolBfr,

                              TBool /* aSortingOrder */)

    {

    LOG_("TPolicyParser::WriteSelectors()\n");

    TBuf8<1024> aux;

    TInt err(KErrNone);

    TInt count(aSelList->Count());

    for (TInt i = 0; i < count; i++)

        {

        aux.Zero();

        CPolicySelector* ps = aSelList->At(i);

        // Bypass the selector, if sequence number is 0xFFFFFFFF.

        // This sequence number indicates that the selector

        // is of type 'bypass/drop_everything_else'

        if (ps->iSequenceNumber == 0xFFFFFFFF)

            {

            continue;

            }

        // Convert selector to text format and print it into buffer 

        TextSel(ps, aux, EFalse);

        err = BufferAppend(aPolBfr, aux);

        if (err != KErrNone)

            {

            return err;

            }

        }

    // All selectors have been written

    err = BufferAppend(aPolBfr, (_L8("\n")));

    return (err);

    }

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

//  This function writes the selectors to a file according

//  to the sequence numbers available in the CPolicySelector.

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

//

TInt

TPolicyParser::WriteSelectorsInSortingOrder(

    CSelectorList* aSelList,

    HBufC8*& aPolBfr,

    TBool /* aSortingOrder */)

    {

    LOG_("TPolicyParser::WriteSelectorsInSortingOrder()\n");

    TInt err(KErrNone);

    TInt count(aSelList->Count());

    TInt currentSequenceNumber(1);

    // Loop here until all selectors have been written

    TBool found = ETrue;

    while (found)

        {

        found = EFalse;

        // Loop through the selector list and search the

        // the selector corresponding to the current sequence number

        for (TInt i = 0; i < count; i++)

            {

            TBuf8<1024> aux;

            aux.Zero();

            CPolicySelector* ps = aSelList->At(i);

            if (ps->iSequenceNumber == currentSequenceNumber)

                {

                // Build a selector output string

                TextSel(ps, aux, ETrue);

                // Write a string to the file

                err = BufferAppend(aPolBfr, aux);

                if (err != KErrNone)

                    {

                    return err;

                    }

                // Prepare for the next selector

                currentSequenceNumber++;

                found = ETrue;

                break;

                }

            }

        }

    // All selectors have been written

    err = BufferAppend(aPolBfr, (_L8("\n")));

    return (err);

    }

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

// Prints the supplied selector into a given buffer in text format

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

//

void

TPolicyParser::TextSel(CPolicySelector* aSel,

                       TDes8& aBuf,

                       TBool aOrdered)

    {

    LOG_("TPolicyParser::TextSel()\n");

    aBuf.Format(_L8(" "));

    if (aSel->iIsFinal)

        {

        aBuf.Append(_L8(" final "));

        }

    if (aSel->iIsMerge)

        {

        aBuf.Append(_L8(" merge "));

        }

    // NOTE:

    //  This is a kludge to save the global selector definition

    //  when policy is loaded/parsed and then finally cached into 

    //  a list in text format. When combined policy is build 

    //  before sending it to IPSEC6.PRT component, the selector

    //  list is ordered so this definition is then not included

    //  in the policy text that is sent into the protocol component

    if (aSel->iGlobalSelector && !aOrdered)

        {

        aBuf.Append(_L8(" scope:global "));

        }

    switch (aSel->iDirection)

        {

        default:

            break;

        case KPolicySelector_SYMMETRIC:

            break;

        case KPolicySelector_INBOUND:

            aBuf.Append(_L8(" inbound "));

            break;

        case KPolicySelector_OUTBOUND:

            aBuf.Append(_L8(" outbound "));

            break;

        case KPolicySelector_INTERFACE:

            TBuf8<20> name;

            name.Copy(aSel->iInterface);

            aBuf.Append(_L8(" if "));

            aBuf.Append(name);

            aBuf.Append(_L8(" "));

            break;

        }

    // Check if remote address exists and no interface name defined

    if (aSel->iDirection != KPolicySelector_INTERFACE 

        && aSel->iRemote.Family() != KAFUnspec)

        {

        TBuf<39> addr;

        TBuf<39> mask;

        aSel->iRemote.OutputWithScope(addr);

        aSel->iRemoteMask.OutputWithScope(mask);

        // Add remote address/mask with scope into the buffer        

        aBuf.Append(_L8(" remote "));

        aBuf.Append(addr);

        aBuf.Append(_L8(" "));

        aBuf.Append(mask);

        }

    else 

        {

        if (aSel->iRemSelEpName != NULL)

            {

            // Remote Endpoint name exists so add it into the buffer

            aBuf.Append(_L8(" remote "));

            aBuf.Append(aSel->iRemSelEpName->Des());

            }

        if (aSel->iRemMaskEpName != NULL)

            {

            aBuf.Append(_L8(" "));

            aBuf.Append(aSel->iRemMaskEpName->Des());

            }

        }

    // Check if local address exists and no interface name defined

    if (aSel->iDirection != KPolicySelector_INTERFACE 

        && aSel->iLocal.Family() != KAFUnspec)

        {

        TBuf<39> addr;

        TBuf<39> mask;

        aSel->iLocal.OutputWithScope(addr);

        aSel->iLocalMask.OutputWithScope(mask);

        // Add local address/mask with scope into the buffer        

        aBuf.Append(_L8(" local "));

        aBuf.Append(addr);

        aBuf.Append(_L8(" "));

        aBuf.Append(mask);

        }

    else