/*

* Copyright (c) 1999-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: Key management daemon PFKEY message module.

*

*/

#include <es_sock.h>

#include <in_sock.h>

#include <eikenv.h>

#include "pfkeymsg.h"

// ======== MEMBER FUNCTIONS ========

#ifdef _DEBUG

//

//  Convert to String methods

//

//  TPfkeyBase::String

//      Convert Base Message Header to printable string

//

void TPfkeyBase::String(TDes &aStr, const TDesC &aLabel) const

    {

    if (!iMsg)

        return;

    aStr.Append(aLabel);

    aStr.AppendFormat(_L("#%d.%d "),

            (int)iMsg->sadb_msg_seq,

            (int)iMsg->sadb_msg_pid);

    switch (iMsg->sadb_msg_type)

        {

    case SADB_GETSPI:

        aStr.Append(_L("GETSPI"));

        break;

    case SADB_UPDATE:

        aStr.Append(_L("UPDATE"));

        break;

    case SADB_ADD:

        aStr.Append(_L("ADD"));

        break;

    case SADB_DELETE:

        aStr.Append(_L("DELETE"));

        break;

    case SADB_GET:

        aStr.Append(_L("GET"));

        break;

    case SADB_ACQUIRE:

        aStr.Append(_L("ACQUIRE"));

        break;

    case SADB_REGISTER:

        aStr.Append(_L("REGISTER"));

        break;

    case SADB_EXPIRE:

        aStr.Append(_L("EXPIRE"));

        break;

    case SADB_FLUSH:

        aStr.Append(_L("FLUSH"));

        break;

    case SADB_DUMP:

        aStr.Append(_L("DUMP"));

        break;

    default:

        aStr.AppendFormat(_L("UNKNOWN(%d)"),

            iMsg->sadb_msg_type);

        break;

        }

    if (iMsg->sadb_msg_version != PF_KEY_V2)

        aStr.AppendFormat(_L("(V%d)"), (int)iMsg->sadb_msg_version);

    if (iMsg->sadb_msg_errno) 

        {

        aStr.AppendFormat(_L("(Errno%d)"), (int)iMsg->sadb_msg_errno);      

        }

    else

        aStr.Append(_L("[ok] "));

    switch (iMsg->sadb_msg_satype)

        {

    case SADB_SATYPE_AH:

        aStr.Append(_L("AH"));

        break;

    case SADB_SATYPE_ESP:

        aStr.Append(_L("ESP"));

        break;

    case SADB_SATYPE_UNSPEC:

        aStr.Append('*');

        break;

    default:

        aStr.AppendFormat(_L("UNKNOWN=%d"), (int)iMsg->sadb_msg_satype);

        break;

        }

    }

void TPfkeyAssociation::String(TDes &aStr, const TDesC &aLabel) const

    {

    if (!iExt)

        return;

    aStr.Append(aLabel);

    if (iExt->sadb_sa_encrypt || iExt->sadb_sa_auth)

        {

        aStr.Append('(');

        if (iExt->sadb_sa_encrypt)

            TPfkeySupportedEncrypt::Alg2String(aStr, iExt->sadb_sa_encrypt);

        aStr.Append(',');

        if (iExt->sadb_sa_auth)

            TPfkeySupportedAuth::Alg2String(aStr, iExt->sadb_sa_auth);

        aStr.Append(')');

        }

    switch (iExt->sadb_sa_state)

        {

    case SADB_SASTATE_LARVAL:

        aStr.Append(_L(" LARVAL"));

        break;

    case SADB_SASTATE_MATURE:

        aStr.Append(_L(" MATURE"));

        break;

    case SADB_SASTATE_DYING:

        aStr.Append(_L(" DYING"));

        break;

    case SADB_SASTATE_DEAD:

        aStr.Append(_L(" DEAD"));

        break;

    default:

        aStr.AppendFormat(_L(" UNKNOWN=%d"), (int)iExt->sadb_sa_state);

        break;

        }

    aStr.AppendFormat(_L(" SPI=%x"), (int)ByteOrder::Swap32(iExt->sadb_sa_spi));

    if (iExt->sadb_sa_replay)

        aStr.AppendFormat(_L(" Replay=%d"), (int)iExt->sadb_sa_replay);

    }

void TPfkeyAddress::String(TDes &aStr, const TDesC &aLabel) const

    {

    if (!iExt)

        return;

    aStr.Append(aLabel);

    if (iAddr)

        {

        TBuf<39> addr;

        iAddr->OutputWithScope(addr);

        aStr.Append(addr);

        if (iExt->sadb_address_proto)

            aStr.AppendFormat(_L(" proto=%d"), iExt->sadb_address_proto);

        if (iAddr->Port())

            aStr.AppendFormat(_L(" port=%d"), iAddr->Port());

        }

    }

void TPfkeyKey::String(TDes &aStr, const TDesC &aLabel) const

    {

    if (iExt)

        aStr.Append(aLabel);

    }

void TPfkeyLifetime::String(TDes &aStr, const TDesC &aLabel) const

    {

    if (!iExt)

        return;

    aStr.Append(aLabel);

    aStr.Append((TChar)'(');

    aStr.AppendNum(iExt->sadb_lifetime_allocations);

    aStr.Append((TChar)',');

    aStr.AppendNum(iExt->sadb_lifetime_bytes);

    aStr.Append((TChar)',');

    aStr.AppendNum(iExt->sadb_lifetime_addtime);

    aStr.Append((TChar)',');

    aStr.AppendNum(iExt->sadb_lifetime_usetime);

    aStr.Append((TChar)')');

    }

void TPfkeySupported::String(TDes &aStr, const TDesC &aLabel) const

    {

    if (!iExt)

        return;

    aStr.Append(aLabel);

    for (int i = 0; i < iNumAlg; ++i)

        {

        AlgString(aStr, iAlg[i].sadb_alg_id);

        if (iAlg[i].sadb_alg_minbits == iAlg[i].sadb_alg_maxbits)

            aStr.AppendFormat

                (_L("(IV=%d,key=%d)"),

                (int)iAlg[i].sadb_alg_ivlen,

                (int)iAlg[i].sadb_alg_maxbits);

        else

            aStr.AppendFormat

                (_L("(IV=%d,%d<=key<=%d)"),

                (int)iAlg[i].sadb_alg_ivlen,

                (int)iAlg[i].sadb_alg_minbits,

                (int)iAlg[i].sadb_alg_maxbits);

        }

    }

void TPfkeyIdentity::String(TDes &aStr, const TDesC &aLabel) const

{

#ifdef _UNICODE

    if (iExt)

    {

        aStr.Append(aLabel);

        if (iData.Length() == 0)

            return;

        HBufC *unibuf = HBufC::New(iData.Length());

        if (!unibuf)

            return;

        unibuf->Des().Copy(iData);

        aStr.Append(unibuf->Des());

        delete unibuf;

    }

#else

    if (iExt)

    {

        aStr.Append(aLabel);

        aStr.Append(iData);

    }

#endif

}

void TPfkeySensitivity::String(TDes &aStr, const TDesC &aLabel) const

    {

    if (iExt)

        {

        aStr.Append(aLabel);

        }

    }

void TPfkeyProposal::String(TDes &aStr, const TDesC &aLabel) const

    {

    if (!iExt)

        return;

    aStr.Append(aLabel);

    if (iExt->sadb_prop_replay)

        aStr.AppendFormat(_L("replay=%d"), (int)iExt->sadb_prop_replay);

    for (int i = 0; i < iNumComb; i++)

        {

        aStr.AppendFormat(_L(" %d:("), i+1);

        if (iComb[i].sadb_comb_flags & SADB_SAFLAGS_PFS)

            aStr.Append(_L("PFS "));

        if (iComb[i].sadb_comb_encrypt)

            {

            TPfkeySupportedEncrypt::Alg2String(aStr, iComb[i].sadb_comb_encrypt);

            aStr.AppendFormat(_L("[%d..%d]"),

                iComb[i].sadb_comb_encrypt_minbits,

                iComb[i].sadb_comb_encrypt_maxbits);

            }

        if (iComb[i].sadb_comb_auth)

            {

            aStr.Append(',');

            TPfkeySupportedAuth::Alg2String(aStr, iComb[i].sadb_comb_auth);

            aStr.AppendFormat(_L("[%d..%d]"),

                iComb[i].sadb_comb_auth_minbits,

                iComb[i].sadb_comb_auth_maxbits);

            }

        if (iComb[i].sadb_comb_soft_allocations ||

            iComb[i].sadb_comb_soft_bytes != 0 ||

            iComb[i].sadb_comb_soft_addtime != 0||

            iComb[i].sadb_comb_soft_usetime != 0)

            {

            aStr.AppendFormat(_L(" soft=(%d,"), (int)iComb[i].sadb_comb_soft_allocations);

            aStr.AppendNum(iComb[i].sadb_comb_soft_bytes);

            aStr.Append(',');

            aStr.AppendNum(iComb[i].sadb_comb_soft_addtime);

            aStr.Append(',');

            aStr.AppendNum(iComb[i].sadb_comb_soft_usetime);

            aStr.Append(')');

            }

        if (iComb[i].sadb_comb_hard_allocations ||

            iComb[i].sadb_comb_hard_bytes != 0 ||

            iComb[i].sadb_comb_hard_addtime != 0 ||

            iComb[i].sadb_comb_hard_usetime != 0)

            {

            aStr.AppendFormat(_L(" hard=(%d,"), (int)iComb[i].sadb_comb_hard_allocations);

            aStr.AppendNum(iComb[i].sadb_comb_hard_bytes);

            aStr.Append(',');

            aStr.AppendNum(iComb[i].sadb_comb_hard_addtime);

            aStr.Append(',');

            aStr.AppendNum(iComb[i].sadb_comb_hard_usetime);

            aStr.Append(')');

            }

        aStr.Append(')');

        }

    }

void TPfkeySpirange::String(TDes &aStr,const TDesC &aLabel) const

    {

    if (iExt)

        {

        aStr.Append(aLabel);

        }

    }

void TPfkeyTs::String(TDes &aStr,const TDesC &aLabel) const

    {       

    if (iExt)

        {            

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

            {                              

            const TPfKeySelector& selector = Selector(i);

            TBuf<50> src;

            TBuf<50> dst;

            selector.iSrc.OutputWithScope(src);

            selector.iDst.OutputWithScope(dst);

            aStr.AppendFormat(_L("%S[%d] proto=%d src=%S:%d, dst=%S:%d" ), 

                              &aLabel, i, selector.sadb_x_selector_proto,

                              &src, selector.iSrc.Port(),

                              &dst, selector.iDst.Port());

            }

        }

    }

void TPFkeyPrivExt::String(TDes &aStr, const TDesC &aLabel) const

    {

    if (iExt)

        aStr.Append(aLabel);

    }

#endif   //#ifdef _DEBUG 

TPfkeyBase::TPfkeyBase()

 : iMsg( 0 )

    {    

    }

TPfkeyAssociation::TPfkeyAssociation() 

 : iExt( 0 )

     {     

     }

TPfkeyLifetime::TPfkeyLifetime()

 : iExt( 0 )

     {     

     }

TPfkeyAddress::TPfkeyAddress()

 : iExt(0), iAddr(0)

     {     

     }

EXPORT_C const TInetAddr& TPfkeyAddress::Address() const

    {

    return *iAddr;

    }

TPfkeyKey::TPfkeyKey()

 : iExt( 0 )

     {     

     }

TPfkeyIdentity::TPfkeyIdentity()

 : iExt( 0 )

     {     

     }

TPfkeySensitivity::TPfkeySensitivity()

 : iExt(0)

     {     

     }

TPfkeyProposal::TPfkeyProposal()

 : iExt( 0 ),

   iComb( 0 ),

   iNumComb( 0 )

    {    

    }

TPfkeySupported::TPfkeySupported()

 : iExt( 0 ),

   iAlg( 0 ),

   iNumAlg( 0 )

       {       

       }

void TPfkeySupportedAuth::AlgString( TDes &aStr,

                                     TUint8 aAlg ) const

       {

       Alg2String( aStr, aAlg ); 

       }

void TPfkeySupportedAuth::Alg2String(TDes &aStr, TUint8 aAlg)

    {

    switch (aAlg)

        {

    case SADB_AALG_MD5HMAC:

        aStr.Append(_L("md5hmac"));

        break;

    case SADB_AALG_SHA1HMAC:

        aStr.Append(_L("sha1hmac"));

        break;

    default:

        aStr.AppendFormat(_L("%d"), (int)aAlg);

        }

    }

void TPfkeySupportedEncrypt::AlgString( TDes &aStr,

                                        TUint8 aAlg ) const

       {

       Alg2String( aStr, aAlg );

       }

void TPfkeySupportedEncrypt::Alg2String(TDes &aStr, TUint8 aAlg)

    {

    switch (aAlg)

        {

    case SADB_EALG_DESCBC:

        aStr.Append(_L("descbc"));

        break;

    case SADB_EALG_3DESCBC:

        aStr.Append(_L("3descbc"));

        break;

    case SADB_EALG_NULL:

        aStr.Append(_L("null"));

        break;

    case 4:

        aStr.Append(_L("rc5"));

        break;

    case 5:

        aStr.Append(_L("idea"));

        break;

    case 6:

        aStr.Append(_L("cast"));

        break;

    case 7:

        aStr.Append(_L("blowfish"));

        break;

    case 8:

        aStr.Append(_L("3idea"));

        break;

    case 9:

        aStr.Append(_L("desiv32"));

        break;

    case 10:

        aStr.Append(_L("rc4"));

        break;

    case 12:

        aStr.Append(_L("aes"));

        break;

    default:

        aStr.AppendFormat(_L("%d"), (int)aAlg);

        }

    }

TPfkeySpirange::TPfkeySpirange()

 : iExt( 0 )

     {     

     }

TPfkeyTs::TPfkeyTs()

 : iExt(0)

     {     

     }

EXPORT_C TInt TPfkeyTs::SelectorCount() const

    {

    return (iExt != NULL) ? iExt->sadb_x_ts_numsel : 0;

    }

EXPORT_C const TPfKeySelector& TPfkeyTs::Selector(TInt aIndex) const

    {        

    __ASSERT_DEBUG(iExt != NULL, User::Invariant());

    __ASSERT_DEBUG(iExt->sadb_x_ts_numsel > aIndex, User::Invariant());

    TPfKeySelector *selector = (TPfKeySelector*)((TUint8*)iExt + sizeof(struct sadb_x_ts));

    return selector[aIndex];

    }

TPFkeyPrivExt::TPFkeyPrivExt()

 : iExt( 0 )

     {     

     }

//

//  TPfkeyMessage

//

TPfkeyMessage::TPfkeyMessage()

 : iError( KErrNone )

     {     

     }

//

//  Construct TPfkeyMesage from a PF_KEY v2 byte stream (aMsg)

//

TPfkeyMessage::TPfkeyMessage(TPfkeyRecvMsg& aMsg)

    {

	const TUint8 *p = aMsg.Ptr();

	TInt length = aMsg.Length();

	iError = KErrArgument;

	if (length < (TInt)sizeof(sadb_msg))

		return;		// EMSGSIZE (impossible message size)

	// Base Message Header

	iBase.iMsg = (struct sadb_msg *)p;

	if (iBase.iMsg->sadb_msg_version != PF_KEY_V2)

		return;		// EINVAL

	// SADB_ACQUIRE response can have sadb_msg_errno set to non-zero value  

	 if (iBase.iMsg->sadb_msg_errno && (iBase.iMsg->sadb_msg_type != SADB_ACQUIRE))

	 	return;                   // EINVAL (should be set zero by sender) 		

	if (iBase.iMsg->sadb_msg_len * 8 != length)

		return;		// EMSGSIZE (incorrect message length)

	// SADB_ACQUIRE response can have sadb_msg_reserved set to non-zero value            

	if (iBase.iMsg->sadb_msg_reserved && (iBase.iMsg->sadb_msg_type != SADB_ACQUIRE))		

		return;		// EINVAL (unused parts must be zeroed)

	p += sizeof(struct sadb_msg);

	length -= sizeof(struct sadb_msg);

	// Extension headers

	// Some general rules:

	// - only one instance of an extension type is valid