/*

* Copyright (c) 2007-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:  Stream class implementation for ISAKMP

*

*/

#include "ikev1isakmpstream.h"

#include "ikemsgheader.h"

#include "ikev1negotiation.h"

#include "ikedebug.h"

#include "ikev1trans.h"

#include "ikecalist.h"

#include "ikecaelem.h"

#include "ikepolparser.h"

#include "ikev1crypto.h"

#include "ikev1pkiservice.h"

#include "ikev1private.h"

#include "ikepkiutils.h"

#include "ikev1natdiscovery.h"

//

//  TIkev1IsakmpStream

//

TIkev1IsakmpStream::TIkev1IsakmpStream( MIkeDebug& aDebug )

 : iDebug( aDebug )

    {    

    }

void TIkev1IsakmpStream::IsakmpInit(CIkev1Negotiation *aSession)

{

    ThdrISAKMP hdr;

    iError = EFalse;

    iNegotiation = aSession;    //stores it to avoid passing it for all the functions

    DEBUG_LOG(_L("[HDR]"));

    hdr.SetCookieI(iNegotiation->iCookie_I);

    hdr.SetCookieR(iNegotiation->iCookie_R);

    hdr.SetPayload(0);  //Is set later through the pointer iNextPayload

    hdr.SetVersion(0x10);   //MAJOR=1 MINOR=0

    hdr.SetExchange(iNegotiation->iExchange);

    hdr.SetFlags(iNegotiation->iFlags);

    if ((iNegotiation->iExchange == ISAKMP_EXCHANGE_ID) || (iNegotiation->iExchange == ISAKMP_EXCHANGE_AGGR))

        hdr.SetMessageId(0);

    else //QUICK mode ,INFORMATIONAL Mode or Transaction exchange

        hdr.SetMessageId(iNegotiation->iMessageId);

    iBuf.SetLength(0);  //Set correctly when sending SendL()

    iBuf.Copy((TUint8 *)&hdr, sizeof(hdr)); //Always called the first so not Append

    iNextPayload = (TUint8 *)(iBuf.Ptr() + 16); //saves the adress. 

                                                //Will be filled by the next called function

}

void TIkev1IsakmpStream::IsakmpSa()

{

    TSAISAKMP sa;

    DEBUG_LOG(_L("[SA]"));

    sa.SetPayload(0);   //Not proposal or transform RFC. After reserved is already 0

    sa.SetDOI(iNegotiation->iDOI);  //Always the same. Otherwise should be the one contained in CIkev1Negotiation

    sa.SetSIT(IPSEC_SIT_IDENTITY_ONLY); //That means no Labeled Domain Identifier

    *iNextPayload = ISAKMP_PAYLOAD_SA;      //Fills the previous payload next field

    iNextPayload = (TUint8 *)(iBuf.Ptr() + iBuf.Length());//saves the address. 

                                            //Will be filled by the next called function

    TUint16 pos=(TUint16)iBuf.Length(); //save the position to know the total size later and insert it

    iBuf.SetLength(pos + sizeof(sa)); //leave room to insert later the proposal

                                                                    //including the SPI

    IsakmpProposal();

    sa.SetLength((TUint16)(iBuf.Length() - pos));

    TBuf8<sizeof(sa)> aux;

    aux.Append((TUint8 *)&sa, sizeof(sa));

    iBuf.Replace(pos,aux.Length(),aux);

}

//SPI not included yet.

//Sends msg stage 2. Should be used for phase 2 as well

void TIkev1IsakmpStream::IsakmpProposal()

{

    TProposalISAKMP proposal;

    TUint16 pos = 0;

    TUint8  next_payload = ISAKMP_PAYLOAD_T; // default: more than one transform

    if (iNegotiation->iPhase == PHASE_I)

    {

        TProposal *prop;

        if (iNegotiation->iRole==INITIATOR) 

        {

            prop=&iNegotiation->iProposal_I;

        }

        else

        {

            prop=&iNegotiation->iChosenProposal_I;

        }

        proposal.SetPayload(ISAKMP_PAYLOAD_NONE);   //Only one proposal

        proposal.SetNum(prop->iProposalNum);

        proposal.SetProtocol(prop->iProtocol);

        proposal.SetSPISize(0);

        proposal.SetNumTrans(prop->iNumTransforms);

        pos=(TUint16)iBuf.Length(); //save the position to insert later

                                                                    //including the SPI

        iBuf.SetLength(pos + sizeof(proposal)); //leave room to insert later the proposal

        TAttrib *attr=prop->iAttrList;

        for (TInt i=0; i < proposal.GetNumTrans(); i++) //Adds all the transforms

        {

            if ( !attr->iNext )

               next_payload = ISAKMP_PAYLOAD_NONE; // Last trasnform    

            IsakmpTransform((TUint8 *)attr, next_payload);

            attr=attr->iNext;

        }

        proposal.SetLength((TUint16)(iBuf.Length() - pos));

        TBuf8<sizeof(proposal) + MAX_SPI_SIZE> aux;

        aux.Append((TUint8 *)&proposal, sizeof(proposal));

        //aux.Append(prop->iSPI);   //insert the SPI

        iBuf.Replace(pos,aux.Length(),aux);

        return;

    }

    //PHASE_II

    TAttrib_II *attr_II=NULL;

    CProposal_IIList *propII_List = NULL;

    CProposal_II *propII = NULL;

    TBuf8<MAX_SPI_SIZE> SPI;

    TInt i, index = 0;

    TUint32 in_spi;

    TUint8  num_transforms;

    CArrayFixFlat<TSPINode> *list = iNegotiation->iInboundSPIList;

    if (iNegotiation->iRole==INITIATOR) 

        propII_List = iNegotiation->iProposal_IIList;

    else    //RESPONDER

    {   

        for (index = 0; index < list->Count(); index++)

        {

            if (list->At(index).iPropNum == iNegotiation->iProposalNum)

                break;

        }

        propII_List = iNegotiation->iChosenProp_IIList;

    }

    TInt count = propII_List->Count();

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

    {

        propII = propII_List->At(i);

        //Choose the correct SPI

        if (iNegotiation->iRole==INITIATOR) 

            SPI = propII->iSPI;

        else    //RESPONDER

        {

            in_spi = list->At(index).iSPI;

            SPI.Copy((TUint8 *)&in_spi, sizeof(TUint32));

            index++;    

        }

        if (i == count - 1) //Last proposal

            proposal.SetPayload(ISAKMP_PAYLOAD_NONE);

        else    //There are more

            proposal.SetPayload(ISAKMP_PAYLOAD_P);

        num_transforms = propII->iNumTransforms;

        proposal.SetNum(propII->iProposalNum);

        proposal.SetProtocol(propII->iProtocol);

        proposal.SetNumTrans(num_transforms);

        proposal.SetSPISize((TUint8)SPI.Length());  //The chosen contains the inbound SPI

        pos=(TUint16)iBuf.Length(); //save the position to insert later

        iBuf.SetLength(pos + sizeof(proposal) + proposal.GetSPISize()); //leave room to insert later the proposal

                                                                //including the SPI

        for (TInt j = 0; j < num_transforms; j++)   //Adds all the transforms

        {

            attr_II = propII->iAttrList->At(j);

            if ( (num_transforms - j) == 1 )

               next_payload = ISAKMP_PAYLOAD_NONE; // Last trasnform    

            IsakmpTransform((TUint8 *)attr_II, next_payload);

        }

        proposal.SetLength((TUint16)(iBuf.Length() - pos));

        TBuf8<sizeof(proposal) + MAX_SPI_SIZE> aux;

        aux.Append((TUint8 *)&proposal, sizeof(proposal));

        aux.Append(SPI);    //insert the SPI

        iBuf.Replace(pos, aux.Length(), aux);

    }

}

//Transform data received as TUint8 to allow both TAttrib and TAttrib_II

void TIkev1IsakmpStream::IsakmpTransform(TUint8 *aTransform, TUint8 aNextPayload)

{

    TTransformISAKMP transf;

    //transf.SetNum(1);//SHOULD BE the selected transform but Linux doesn't let it use it!!!

    if (iNegotiation->iPhase == PHASE_I)

    {

        TAttrib *attr=(TAttrib *)aTransform;

        transf.SetNum(attr->iTransformNum);

        transf.SetID(attr->iTransformID);

        transf.SetPayload(aNextPayload);

    }

    else    //PHASE_II

    {

        TAttrib_II *attr_II=(TAttrib_II *)aTransform;

        transf.SetNum(attr_II->iTransformNum);

        transf.SetID(attr_II->iTransformID);

        transf.SetPayload(aNextPayload);        

    }

    TInt pos=iBuf.Length(); //save the position to insert later

    iBuf.SetLength(pos + sizeof(transf)); //leave room to insert later

    IsakmpAttrib(aTransform);

    transf.SetLength((TUint16)(iBuf.Length() - pos));

    TBuf8<sizeof(transf)> aux;

    aux.Append((TUint8 *)&transf, sizeof(transf));

    iBuf.Replace(pos,aux.Length(),aux);

}

//Creates a data payload with the desired SA attributes. either Phase I or II

void TIkev1IsakmpStream::IsakmpAttrib(TUint8 *aTransform)

{

    if (iNegotiation->iPhase == PHASE_I)

        IsakmpAttrib1((TAttrib *)aTransform);

    else    //PHASE_II

        IsakmpAttrib2((TAttrib_II *)aTransform);

}

//Phase_I attributes

void TIkev1IsakmpStream::IsakmpAttrib1(TAttrib *aTransform)

{

    TDataISAKMP attr;

    TUint length;

    TUint16 val;

    TAttrib trans;

    trans=*aTransform;

    val=trans.iEncrAlg;

    if (val != 0)

    {

        attr.SetBasic(ETrue);

        attr.SetType(OAKLEY_ATTR_TYPE_ENCR_ALG);

        attr.SetValue(val);

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

    }

    val=trans.iHashAlg;

    if (val != 0)

    {

        attr.SetBasic(ETrue);

        attr.SetType(OAKLEY_ATTR_TYPE_HASH_ALG);

        attr.SetValue(val);

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

    }

    val=CTransNegotiation::GetAuthMethod(trans.iAuthMethod, trans.iXauthUsed, trans.iRole);           

    if (val != 0)

    {

        attr.SetBasic(ETrue);

        attr.SetType(OAKLEY_ATTR_TYPE_AUTH_METH);

        attr.SetValue(val);

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

    }

    val=trans.iGroupDesc;

    if (val != 0)

    {

        attr.SetBasic(ETrue);

        attr.SetType(OAKLEY_ATTR_TYPE_GROUP_DESC);

        attr.SetValue(val);

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

    }

    val=trans.iGroupType;

    if (val != 0)

    {

        attr.SetBasic(ETrue);

        attr.SetType(OAKLEY_ATTR_TYPE_GROUP_TYPE);

        attr.SetValue(val);

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

    }

    length=trans.iGroupPrime.Length();

    if (length!=0)

    {

        attr.SetBasic(EFalse);

        attr.SetType(OAKLEY_ATTR_TYPE_GROUP_PRIME);

        attr.SetLength((TUint16)(length));

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

        iBuf.Append(trans.iGroupPrime);

    }

    length=trans.iGroupGen1.Length();

    if (length!=0)

    {

        attr.SetBasic(EFalse);

        attr.SetType(OAKLEY_ATTR_TYPE_GROUP_GEN1);

        attr.SetLength((TUint16)(length));

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

        iBuf.Append(trans.iGroupGen1);

    }

    length=trans.iGroupGen2.Length();

    if (length!=0)

    {

        attr.SetBasic(EFalse);

        attr.SetType(OAKLEY_ATTR_TYPE_GROUP_GEN2);

        attr.SetLength((TUint16)(length));

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

        iBuf.Append(trans.iGroupGen2);

    }

    length=trans.iGroupCurveA.Length();

    if (length!=0)

    {

        attr.SetBasic(EFalse);

        attr.SetType(OAKLEY_ATTR_TYPE_GROUP_CRVA);

        attr.SetLength((TUint16)(length));

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

        iBuf.Append(trans.iGroupCurveA);

    }

    length=trans.iGroupCurveB.Length();

    if (length!=0)

    {

        attr.SetBasic(EFalse);

        attr.SetType(OAKLEY_ATTR_TYPE_GROUP_CRVB);

        attr.SetLength((TUint16)(length));

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

        iBuf.Append(trans.iGroupCurveB);

    }

    length=trans.iLifeDurationSecs.Length();

    if (length!=0)

    {

        attr.SetBasic(ETrue);

        attr.SetType(OAKLEY_ATTR_TYPE_LIFE_TYPE);

        attr.SetValue(SECONDS);

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

        attr.SetBasic(EFalse);

        attr.SetType(OAKLEY_ATTR_TYPE_LIFE_DUR);

        attr.SetLength((TUint16)(length));

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

        iBuf.Append(trans.iLifeDurationSecs);

    }

    length=trans.iLifeDurationKBytes.Length();

    if (length!=0)

    {

        attr.SetBasic(ETrue);

        attr.SetType(OAKLEY_ATTR_TYPE_LIFE_TYPE);

        attr.SetValue(KBYTES);

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

        attr.SetBasic(EFalse);

        attr.SetType(OAKLEY_ATTR_TYPE_LIFE_DUR);

        attr.SetLength((TUint16)(length));

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

        iBuf.Append(trans.iLifeDurationKBytes);

    }

    val=trans.iPRF;

    if (val != 0)

    {

        attr.SetBasic(ETrue);

        attr.SetType(OAKLEY_ATTR_TYPE_PRF);

        attr.SetValue(val);

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

    }

    val=trans.iKeyLength;

    if (val != 0)

    {

        attr.SetBasic(ETrue);

        attr.SetType(OAKLEY_ATTR_TYPE_KEY_LEN);

        attr.SetValue(val);

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

    }

    val=trans.iFieldSize;

    if (val != 0)

    {

        attr.SetBasic(ETrue);

        attr.SetType(OAKLEY_ATTR_TYPE_FIELD_SIZE);

        attr.SetValue(val);

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

    }

    length=trans.iGroupOrder.Length();

    if (length!=0)

    {

        attr.SetBasic(EFalse);

        attr.SetType(OAKLEY_ATTR_TYPE_GROUP_ORDER);

        attr.SetLength((TUint16)(sizeof(attr)+length));

        iBuf.Append((TUint8 *)&attr, sizeof(attr));

        iBuf.Append(trans.iGroupOrder);

    }

}

//Phase_II attributes

void TIkev1IsakmpStream::IsakmpAttrib2(TAttrib_II *aTransform)

{

        TDataISAKMP attr;

        TUint length;

        TUint16 val;

        TAttrib_II trans=*aTransform;

        length=trans.iLifeDurationSecs.Length();

        if (length!=0)

        {

            attr.SetBasic(ETrue);

            attr.SetType(DOI_ATTR_TYPE_LIFE_TYPE);

            attr.SetValue(SECONDS);

            iBuf.Append((TUint8 *)&attr, sizeof(attr));

            attr.SetBasic(EFalse);

            attr.SetType(DOI_ATTR_TYPE_LIFE_DUR);

            attr.SetLength((TUint16)length);

            iBuf.Append((TUint8 *)&attr, sizeof(attr));

            iBuf.Append(trans.iLifeDurationSecs.Ptr(),trans.iLifeDurationSecs.Length());

        }   

        length=trans.iLifeDurationKBytes.Length();

        if (length!=0)

        {

            attr.SetBasic(ETrue);

            attr.SetType(DOI_ATTR_TYPE_LIFE_TYPE);

            attr.SetValue(KBYTES);

            iBuf.Append((TUint8 *)&attr, sizeof(attr));

            attr.SetBasic(EFalse);

            attr.SetType(DOI_ATTR_TYPE_LIFE_DUR);

            attr.SetLength((TUint16)length);

            iBuf.Append((TUint8 *)&attr, sizeof(attr));

            iBuf.Append(trans.iLifeDurationKBytes.Ptr(),trans.iLifeDurationKBytes.Length());

        }

        if (iNegotiation->iPFS)

        {   //Only sent if PFS in use. The same used in Phase I

            val = trans.iGroupDesc;

            if (val != 0)

            {

                attr.SetBasic(ETrue);

                attr.SetType(DOI_ATTR_TYPE_GROUP_DESC);

                attr.SetValue(val);

                iBuf.Append((TUint8 *)&attr, sizeof(attr));

            }

        }

        val=trans.iEncMode;

        if (val != 0)

        {

            //

            // If ESP UDP encapsulation required (because of NAT device in between)

            // modify encapsulation type code values

            //

            if ( iNegotiation->iNAT_D_Flags ) {

               if ( val == DOI_TUNNEL )

                    val = UDP_ENC_TUNNEL;

               else val = UDP_ENC_TRANSPORT;

            }   

            attr.SetBasic(ETrue);

            attr.SetType(DOI_ATTR_TYPE_ENC_MODE);

            attr.SetValue(val);

            iBuf.Append((TUint8 *)&attr, sizeof(attr));

        }

        val=trans.iAuthAlg;

        if (val != 0)

        {

            attr.SetBasic(ETrue);

            attr.SetType(DOI_ATTR_TYPE_AUTH_ALG);

            attr.SetValue(val);

            iBuf.Append((TUint8 *)&attr, sizeof(attr));

        }   

        val=trans.iKeyLength;

        if (val != 0)

        {

            attr.SetBasic(ETrue);

            attr.SetType(DOI_ATTR_TYPE_KEY_LEN);

            attr.SetValue(val);

            iBuf.Append((TUint8 *)&attr, sizeof(attr));

        }   

        val=trans.iKeyRounds;

        if (val != 0)

        {

            attr.SetBasic(ETrue);

            attr.SetType(DOI_ATTR_TYPE_KEY_ROUNDS);

            attr.SetValue(val);

            iBuf.Append((TUint8 *)&attr, sizeof(attr));

        }   

        val=trans.iComprDicSize;

        if (val != 0)

        {

            attr.SetBasic(ETrue);

            attr.SetType(DOI_ATTR_TYPE_COMP_DIC_SIZE);

            attr.SetValue(val);

            iBuf.Append((TUint8 *)&attr, sizeof(attr));

        }   

        length=trans.iComprPrivAlg.Length();

        if (length!=0)

        {

            attr.SetBasic(EFalse);

            attr.SetType(DOI_ATTR_TYPE_COMP_PRIV_ALG);