/*

* Copyright (c) 1999-2010 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:   IKE policy parser main module

*

*/

#include <e32std.h>

#include <coeutils.h>

#include "ikepolparser.h"

//

// EXPORTed functions

//

//---------------------------------------------------------------------------

//

// IKE Policy Parsing

//

//---------------------------------------------------------------------------

//

//CIkeData -> contains the ike data

//

CIkeData::CIkeData() : iIkeVersion(1)

    {

    }

EXPORT_C CIkeData* CIkeData::NewL()

    {

    return new (ELeave) CIkeData();

    }

EXPORT_C CIkeData* CIkeData::NewL(const CIkeData *aData)

    {

    CIkeData* self = new (ELeave) CIkeData();

    CleanupStack::PushL(self);

    self->ConstructL(aData);

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C void CIkeData::ConstructL(const CIkeData *aData)

    {

    CopyL(aData);

    }

EXPORT_C CIkeData::~CIkeData()

    {

    delete iRemoteIdentity;

    delete iEAPRealmPrefix;

    delete iEAPManualRealm;

    delete iEAPManualUserName;    

    delete iCRACKLAMUserName;

    delete iCRACKLAMPassword;

    delete iClientCertType;

    delete iFQDNAddr;

    Empty();  

    }

EXPORT_C void CIkeData::CopyL(const CIkeData* aData)

    {

    if ( aData == NULL )

        {

        User::Leave( KErrNoMemory );

        }

    Empty();    //Free the previous info

    iAddr = aData->iAddr;       //Peer host address

    iMask = aData->iMask;       //Peer host mask

    if (aData->iFQDNAddr)

    	iFQDNAddr=TStringData::NewL(aData->iFQDNAddr->GetData());

    iMode = aData->iMode;

    iNotify = aData->iNotify;

    iFQDN.Copy(aData->iFQDN);

    iIdType = aData->iIdType;

    iGroupDesc_II = aData->iGroupDesc_II;

    iAcceptPartialRemoteId = aData->iAcceptPartialRemoteId;

    iIkeVersion = aData->iIkeVersion;

    iCommit = aData->iCommit;

    iIpsecExpires = aData->iIpsecExpires;

    iAlwaysSendCert = aData->iAlwaysSendCert;

    iInitialContact = aData->iInitialContact;   //INITIAL-CONTACT sending

    iResponderLifetime = aData->iResponderLifetime; //RESPONDER_LIFETIME sending

    iReplayStatus = aData->iReplayStatus;   //RESPONDER_LIFETIME sending

    iCRACKLAMType = aData->iCRACKLAMType;   //CRACK LAM type

    if (aData->iCRACKLAMUserName)

    	iCRACKLAMUserName=TStringData::NewL(aData->iCRACKLAMUserName->GetData());

    if (aData->iCRACKLAMPassword)

    	iCRACKLAMPassword=TStringData::NewL(aData->iCRACKLAMPassword->GetData());

    iUseInternalAddr = aData->iUseInternalAddr;

    iUseNatProbing   = aData->iUseNatProbing;

    iEspUdpPort      = aData->iEspUdpPort;

    iNatKeepAlive    = aData->iNatKeepAlive;

	iDscp            = aData->iDscp;

    iDPDHeartBeat    = aData->iDPDHeartBeat;

    iRekeyingThreshold = aData->iRekeyingThreshold;

    iUseXauth   = aData->iUseXauth; 

    iUseCfgMode = aData->iUseCfgMode; 

    iUseMobIke  = aData->iUseMobIke;

    iRemoteIdType      = aData->iRemoteIdType;

    iSkipRemoteIdCheck = aData->iSkipRemoteIdCheck;

    if ( aData->iRemoteIdentity )

        iRemoteIdentity = TStringData::NewL(aData->iRemoteIdentity->GetData());

    iEAPProtocol     = aData->iEAPProtocol;

    iEAPHideIdentity = aData->iEAPHideIdentity;   

    if ( aData->iEAPRealmPrefix )

        iEAPRealmPrefix = TStringData::NewL(

            aData->iEAPRealmPrefix->GetData()); 

    if ( aData->iEAPManualRealm )

        iEAPManualRealm = TStringData::NewL(

            aData->iEAPManualRealm->GetData()); 

    if ( aData->iEAPManualUserName )

        iEAPManualUserName = TStringData::NewL(

            aData->iEAPManualUserName->GetData());

    if (aData->iClientCertType)

    		iClientCertType = TStringData::NewL(aData->iClientCertType->GetData());

    iNumProp = aData->iNumProp;

    TProposalData* prop = NULL;

    TProposalData* prev = NULL;

    TProposalData* tmp_prop = aData->iPropList;

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

        {

        prop = new (ELeave) TProposalData;

        *prop = *tmp_prop;

        if (prev)

            prev->iNext = prop;

        else    //first

            iPropList = prop;

        prop->iPrev = prev;

        prev = prop;

        tmp_prop = tmp_prop->iNext;

        }

    if (prop)

        prop->iNext = NULL;

    iPresharedKey = aData->iPresharedKey;

    iCA = aData->iCA;

    iOwnCert = aData->iOwnCert;

    iPrivKey = aData->iPrivKey;

    iPeerCert = aData->iPeerCert;

    if ( aData->iCAList ) 

        {

        TInt count( aData->iCAList->Count() );

        iCAList = new (ELeave) CArrayFixFlat<TCertInfo*>(count);

        for ( TInt x(0); x < count; x++ )

            {

            TCertInfo* ca_copy = new (ELeave) TCertInfo;

            CleanupStack::PushL(ca_copy);

            *ca_copy = *(aData->iCAList->At(x));

            iCAList->AppendL(ca_copy);

            CleanupStack::Pop(ca_copy);

            }

        }

    }

void CIkeData::Empty()

    {

    TProposalData* prop = iPropList;

    TProposalData* next_prop;

    while (prop)

        {

        next_prop = prop->iNext;

        delete prop;

        prop = next_prop;

        }

    if ( iCAList ) 

        {

        for (TInt i(0); i<iCAList->Count(); ++i)

        {

            delete iCAList->At(i);

            iCAList->At(i) = NULL;

        }

        iCAList->Reset();

        delete iCAList;

        iCAList = NULL;

        }           

    }

//

//  CIkeDataArray

//

CIkeDataArray::CIkeDataArray(TInt aGranularity) 

    :CArrayFixFlat<CIkeData*>(aGranularity)

    {

    }

EXPORT_C CIkeDataArray* CIkeDataArray::NewL(TInt aGranularity)

    {

    ASSERT(aGranularity);

    return new (ELeave) CIkeDataArray(aGranularity);

    }

CIkeDataArray::CIkeDataArray(CIkeDataArray* aData)

    :CArrayFixFlat<CIkeData*>(aData ? aData->Count() : 0)

    {

    }

EXPORT_C CIkeDataArray* CIkeDataArray::NewL(CIkeDataArray* aData)

    {

    User::LeaveIfNull(aData);

    ASSERT(aData->Count()); 

    CIkeDataArray* self = new (ELeave) CIkeDataArray(aData);

    CleanupStack::PushL(self);

    self->ConstructL(aData);

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C void CIkeDataArray::ConstructL(CIkeDataArray *aData)

    {

    CopyL(aData);

    }

EXPORT_C CIkeDataArray::~CIkeDataArray()

    {

    Empty();

    }

//Constructs this from the data in aData

EXPORT_C void CIkeDataArray::CopyL(CIkeDataArray* aData)

    {

    User::LeaveIfNull(aData);

    CIkeData* ike_data(NULL);

    for (TInt i(0); i < aData->Count(); i++)

        {

        ike_data = CIkeData::NewL(aData->At(i));

        AppendL(ike_data);

        }

    iMaxLifetimeKB    = aData->iMaxLifetimeKB;

    iMaxLifetimeSec   = aData->iMaxLifetimeSec;

    iMaxRetrans       = aData->iMaxRetrans;

    iMaxTraceFileSize = aData->iMaxTraceFileSize;

    }

EXPORT_C void CIkeDataArray::Empty()

    {

    for (TInt i(0); i < Count(); i++)

        {

        delete At(i);

        }

    Reset();

    }

//

//TIKEParser  -> parses the ike data from a descriptor or writes it to a file

//

// Symbian change - start

#ifdef __VC32__

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

#endif

// Symbian change - end

EXPORT_C TIkeParser::TIkeParser() : TLex(), iVersion(0)

{

}

EXPORT_C TIkeParser::TIkeParser(const TDesC &aStr, TInt aVersion) : TLex(aStr), iVersion(aVersion)

{

}

//Parses the Main ike file

EXPORT_C void TIkeParser::MainParseL(CIkeDataArray *aIkeList)

{

    TPtrC ikeHostSeparator = IKE_HOST_SEPARATOR;

    DoMainParseL(aIkeList, ikeHostSeparator);    

}

EXPORT_C void TIkeParser::ParseIKESectionsL(CIkeDataArray *aIkeList)

{

    TPtrC ikeSeparator = IKE_SEPARATOR;

    DoMainParseL(aIkeList, ikeSeparator);

}

void TIkeParser::DoMainParseL(CIkeDataArray* aIkeList, TPtrC& aSectionName)

{

    ASSERT( aIkeList );

    TPtrC token(NULL,0);

    while (!Eos())

    {

        token.Set(NextToken());

        if (token.Compare(aSectionName)==0)

        {

            CIkeData* ike_piece = CIkeData::NewL();

            CleanupStack::PushL(ike_piece);

            ParseIkePieceL(ike_piece, SEC_PARSER_VERSION, //Always the latest because is generated by the program itself

                           aSectionName);    

            aIkeList->AppendL(ike_piece);

            CleanupStack::Pop(ike_piece);

        }

        else if (token.Compare(IKE_GENERAL_SEPARATOR)==0)

        {

            //Always the latest because is generated by the program itself

            User::LeaveIfError(ParseGeneralData(aIkeList));

        }

    }

}

//Only 2 sections of general data (max lifetimes)

TInt TIkeParser::ParseGeneralData(CIkeDataArray* aIkeList)

{

    ASSERT(aIkeList);

    TLex sub_num;   //Used for number conversion

    TInt err = KErrNone;

    TPtrC token(NULL,0);

    while (!Eos() && err==KErrNone)

    {

        Mark();

        token.Set(NextToken());

        if (token.CompareF(_L("ISAKMP_SA_MAX_LIFETIME_SEC:")) == 0) //CompareF ignores case

        {

            sub_num = NextToken();

            if (sub_num.Val(aIkeList->iMaxLifetimeSec,EDecimal)!=KErrNone)

                err = KSecParserErrMaxLifetimeSec;

        }

        else if (token.CompareF(_L("ISAKMP_SA_MAX_LIFETIME_KB:"))==0)   //CompareF ignores case

        {

            sub_num = NextToken();

            if (sub_num.Val(aIkeList->iMaxLifetimeKB,EDecimal)!=KErrNone)

                err = KSecParserErrMaxLifetimeKB;

        }

        else if (token.CompareF(_L("ISAKMP_MAX_RETRANS:"))==0)  //CompareF ignores case

        {

            sub_num = NextToken();

            if (sub_num.Val(aIkeList->iMaxRetrans)!=KErrNone)

                err = KSecParserErrMaxRetrans;

        }

        else if (token.CompareF(_L("TRACE_FILE_SIZE:"))==0) //CompareF ignores case

        {

            sub_num = NextToken();

            if (sub_num.Val(aIkeList->iMaxTraceFileSize)!=KErrNone)

                err = KSecParserErrMaxRetrans;

        }

        else if (token.Compare(IKE_HOST_SEPARATOR)==0)  //END of general section

        {

            UnGetToMark();  //Ungets the token

            return KErrNone;

        }

        else if (token.Compare(IKE_GENERAL_SEPARATOR)==0)//END of general section

        {

            UnGetToMark();  //Ungets the token

            return KErrNone;

        }

        else if (token.Compare(IKE_SEPARATOR)==0)//END of general section

        {

            UnGetToMark();  //Ungets the token

            return KErrNone;

        }

        //others ignored

    }

    return err;

}

void TIkeParser::ParseIkePieceL(CIkeData* aIkeData, TInt aVersion, TPtrC& aSectionName)

{

    TInt pos = Remainder().Find(aSectionName);

    if (pos != KErrNotFound)

    {

        TPtr ike_ptr((TUint16*)Remainder().Ptr(),pos, pos); //Until the next section

        TIkeParser parser(ike_ptr, aVersion);

        parser.ParseL(aIkeData);

        Assign(Remainder().Mid(pos));    //rest of the text to parse

    }

    else    //No more tags

    {

        TIkeParser parser(Remainder(), aVersion);

        parser.ParseL(aIkeData);

        Assign(Remainder().Mid(Remainder().Length()));   

    }

}

EXPORT_C void TIkeParser::ParseL(CIkeData* aConf)

{

    ASSERT(aConf);

    TInt err = KErrNone;

    TInt errCA= KErrNone;

    TPtrC token(NULL,0);

    TLex sub_num;   //Used for number conversion

    while (!Eos() && err==KErrNone)

    {

        //General Data

        token.Set(NextToken());

        if (token.CompareF(_L("ADDR:"))==0) //CompareF ignores case

        {

            token.Set(NextToken());

            err = aConf->iAddr.Input(token);

            if (err != KErrNone)

            {

            	err = KSecParserErrPeerAddr;

            	aConf->iFQDNAddr = TStringData::NewL(token);

            }            

            if (iVersion >= 2)  //Incorporated in version 2

            {

                token.Set(NextToken());

                err = aConf->iMask.Input(token);

                if (err != KErrNone)

                    err = KSecParserErrPeerMask;

            }

        }

        else if (token.CompareF(_L("DNS_SERVER:"))==0)

        {

            token.Set(NextToken());

            err = aConf->iDnsServer.Input(token);

            if (err != KErrNone)

            {

            	err = KSecParserErrUnknown;

            }            

        }        

        else if (token.CompareF(_L("MODE:"))==0)    //CompareF ignores case

        {

            token.Set(NextToken());

            if (token.CompareF(_L("Main"))==0)

                aConf->iMode = IKE_PARSER_MAIN;

            else if (token.CompareF(_L("Aggressive"))==0)

                aConf->iMode = IKE_PARSER_AGGRESSIVE;

            else

                err = KSecParserErrMode;

        }

        else if (token.CompareF(_L("IKE_VERSION:"))==0) //CompareF ignores case

        {

            sub_num = NextToken();          

                aConf->iIkeVersion = 1; // IKE version 1 is currently the default

        }

        else if (token.CompareF(_L("SEND_NOTIFICATION:"))==0)   //CompareF ignores case

        {

            token.Set(NextToken());

            if (token.CompareF(_L("True"))==0)

                aConf->iNotify = ETrue;

            else if (token.CompareF(_L("False"))==0)

                aConf->iNotify = EFalse;

            else

                err = KSecParserErrNotify;

        }

        else if (token.CompareF(_L("FQDN:"))==0)    //CompareF ignores case

        {

            token.Set(GetRestOfLine());

            aConf->iFQDN.Copy(token);           

        }

        else if (token.CompareF(_L("ID_TYPE:"))==0) //CompareF ignores case

        {

            // Specifies IKE Phase 1 Identity type. Integer value specified in rfc2407

            sub_num = NextToken();          

            if ( sub_num.Val(aConf->iIdType, EDecimal)!= KErrNone )

                aConf->iIdType = 0; // In error situation, set id value to reserved (= Not defined)  

        }

        else if (token.CompareF(_L("REMOTE_ID_TYPE:"))==0) //CompareF ignores case

        {

            sub_num = NextToken();          

            if ( sub_num.Val(aConf->iRemoteIdType, EDecimal)!= KErrNone )

                aConf->iRemoteIdType = 0; // In error situation, set id value to reserved (= Not defined)  

        }

        else if (token.CompareF(_L("REMOTE_IDENTITY:"))==0)    //CompareF ignores case

        {

            token.Set(GetRestOfLine());

            aConf->iRemoteIdentity = TStringData::NewL(token);

        }

        else if (token.CompareF(_L("ACCEPT_PARTIAL_REMOTE_ID:"))==0)    //CompareF ignores case

    	{

    		aConf->iAcceptPartialRemoteId = EFalse;            

    		token.Set(NextToken());

    		if (token.CompareF(_L("True"))==0)

    			aConf->iAcceptPartialRemoteId = ETrue;

    	}

        else if (token.CompareF(_L("SKIP_REMOTE_ID_CHECK:"))==0)    //CompareF ignores case

        {

            aConf->iSkipRemoteIdCheck = EFalse;            

            token.Set(NextToken());

            if (token.CompareF(_L("True"))==0)

                aConf->iSkipRemoteIdCheck = ETrue;

        }

        else if (token.CompareF(_L("GROUP_DESCRIPTION_II:"))==0)    //CompareF ignores case

        {

            token.Set(NextToken());

            if (token.CompareF(_L("MODP_768"))==0)

                aConf->iGroupDesc_II = IKE_PARSER_MODP_768;

            else if (token.CompareF(_L("MODP_1024"))==0)

                aConf->iGroupDesc_II = IKE_PARSER_MODP_1024;

            else if (token.CompareF(_L("MODP_1536"))==0)

                aConf->iGroupDesc_II = IKE_PARSER_MODP_1536;

            else if (token.CompareF(_L("MODP_2048"))==0)

                aConf->iGroupDesc_II = IKE_PARSER_MODP_2048;

            else

            {

                err = KSecParserErrGroupDesc_II;

            }

        }

        else if (token.CompareF(_L("USE_COMMIT:"))==0)  //CompareF ignores case

        {

            token.Set(NextToken());

            if (token.CompareF(_L("True"))==0)