/*
* Copyright (c) 2008 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:  Class that logs ike messages in pcap format
*
*/

#include <bautils.h>
#include <in_sock.h>

#include "ikepcaptrace.h"

_LIT(KLogDirectoryFormat, "c:\\logs\\%S\\");
_LIT(KTraceFileName, "ikemsg.pcap");

static const TUint KIpAndUdpHeaderLength = 28;
static const TUint KFixedHdrLength       = 28;
static const TUint KNonEspMarkerLength   = 4;
static const TInt KNatPort = 4500;

_LIT(KUnixTimeZeroDes, "19700101:000000.000000");
static const TTime KUnixTimeZero(KUnixTimeZeroDes);

#define SWAP_BYTE_ORDER32(a) ((a) >> 24) | ((a) >> 8 & 0xff00) |((a) << 8 & 0xff0000) | ((a) << 24);
#define SWAP_BYTE_ORDER16(a) ((a) >> 8 | (a) << 8)

CIkePcapTrace* CIkePcapTrace::NewL(const TDesC& aLogFolder)
    {
    CIkePcapTrace* self = new (ELeave) CIkePcapTrace();
    CleanupStack::PushL(self);
    self->ConstructL(aLogFolder);    
    CleanupStack::Pop(self);
    
    return self;
    }


CIkePcapTrace::CIkePcapTrace()
    {   
    }


void CIkePcapTrace::ConstructL(const TDesC& aLogFolder)
    {
    User::LeaveIfError(iFileServer.Connect());   
    
    TFileName* traceFileName = new (ELeave) TFileName;
    CleanupDeletePushL(traceFileName);
    traceFileName->Format(KLogDirectoryFormat, &aLogFolder);
    
    if (BaflUtils::FolderExists(iFileServer, *traceFileName))
        {
        traceFileName->Append(KTraceFileName);
        
        if (BaflUtils::FileExists(iFileServer, *traceFileName))
            {
            TInt position = 0;
            User::LeaveIfError(iPcapFile.Open(iFileServer, *traceFileName, EFileWrite));
            User::LeaveIfError(iPcapFile.Seek(ESeekEnd, position));
            }
        else
            {
            User::LeaveIfError(iPcapFile.Create(iFileServer, *traceFileName, EFileWrite));
            TInt err = WritePcapHeader();
            if (err != KErrNone)
                {
                iPcapFile.Close();
                User::LeaveIfError(iFileServer.Delete(*traceFileName));
                User::Leave(err);
                }                            
            }
        iWriteTrace = ETrue;
        }
    else
        {
        iWriteTrace = EFalse;
        }         
    CleanupStack::PopAndDestroy(traceFileName);
    }


CIkePcapTrace::~CIkePcapTrace()
    {
    iPcapFile.Close();
    iFileServer.Close();
    }

void CIkePcapTrace::TraceMessage(const TDesC8& aMessage, 
                                 const TInetAddr& aSourceAddress, 
                                 const TInetAddr& aDestinationAddress,
                                 TEncryptionType aEncryptionType)
    {
    if (iWriteTrace)
        {
        HBufC8* msgCopy = aMessage.Alloc();        
        if (msgCopy != NULL)
            {
            TPtr8 msgCopyPtr = msgCopy->Des();
            DoTraceMessage(msgCopyPtr, aSourceAddress, aDestinationAddress,
                           aEncryptionType);
            }
        delete msgCopy;
        msgCopy = NULL;
        }
    }



void CIkePcapTrace::DoTraceMessage(TPtr8& aMsgCopy, 
                                   const TInetAddr& aSourceAddress, 
                                   const TInetAddr& aDestinationAddress,
                                   TEncryptionType aEncryptionType)
    { 
       
    if ((aSourceAddress.Family() == KAfInet ||
         aSourceAddress.IsV4Compat() || 
         aSourceAddress.IsV4Mapped()) &&
        (aDestinationAddress.Family() == KAfInet ||  
         aDestinationAddress.IsV4Compat() || 
         aDestinationAddress.IsV4Mapped()))
        {
            TInt length = aMsgCopy.Length();
            if (aSourceAddress.Port() == KNatPort)
                {
                length+=KNonEspMarkerLength;
                }
            WriteRecordHeader(length);
            WriteIpAndUdpHeader(aMsgCopy, aSourceAddress, aDestinationAddress);
            if ( aSourceAddress.Port() == KNatPort )
                {
                WriteNonEspMarker();
                }
            WriteIkeMessage(aMsgCopy, aEncryptionType);
            iPcapFile.Flush();
        }
    }


TInt CIkePcapTrace::WriteRecordHeader(TUint32 aIkeMsgLength)
    {
    static const TUint KRecordHeaderLength = 4;
    TUint32 recordHeader[KRecordHeaderLength];
        
    TUint32 currentSeconds = 0;
    TTime currentTime;
    currentTime.HomeTime();
    
    TTimeIntervalSeconds secondsFrom;    
    if (currentTime.SecondsFrom(KUnixTimeZero, secondsFrom) == KErrNone)
        {
        currentSeconds = secondsFrom.Int();
        }
    
    TUint32 microseconds = currentTime.DateTime().MicroSecond();
    
    recordHeader[0] = currentSeconds;
    recordHeader[1] = microseconds;             
    recordHeader[2] = aIkeMsgLength + KIpAndUdpHeaderLength;
    recordHeader[3] = aIkeMsgLength + KIpAndUdpHeaderLength;
    
    TPtrC8 recordHdrPtr((TUint8*)recordHeader, KRecordHeaderLength * sizeof(TUint32));
    return iPcapFile.Write(recordHdrPtr);
    }

TInt CIkePcapTrace::WriteIpAndUdpHeader(const TDesC8& aMessage,
                                        TInetAddr aSourceAddress, 
                                        TInetAddr aDestinationAddress)
    {
    static const TUint KIpHeaderLength = 20;
    static const TUint KUdpHeaderLength = KIpAndUdpHeaderLength - KIpHeaderLength; 
        
    //Generate IP header
    aSourceAddress.ConvertToV4();
    aDestinationAddress.ConvertToV4();
    
    TUint32 source      = SWAP_BYTE_ORDER32(aSourceAddress.Address());    
    TUint32 destination = SWAP_BYTE_ORDER32(aDestinationAddress.Address()); 
    
    TUint8 ipAndUdpHeader[] = { 0x45, 0x00, 0x13, 0x88, 
                                0x00, 0x28, 0x00, 0x00, 
                                0xfe, 0x11, 0x00, 0x00,
                                0x00, 0x00, 0x00, 0x00, //source IP address
                                0x00, 0x00, 0x00, 0x00, //destination IP address
                                0x00, 0x00, 0x00, 0x00, //udp header
                                0x00, 0x00, 0x00, 0x00}; 
                          
    Mem::Copy(ipAndUdpHeader + 12, &source, sizeof(source)); //copies the source address to header
    Mem::Copy(ipAndUdpHeader + 16, &destination, sizeof(destination)); //copies the source address to header
   
    
    //Generate UDP header
    TUint16 sourcePort          = aSourceAddress.Port();
    TUint16 destinationPort     = aDestinationAddress.Port();
    TUint16 udpDatagramLength   = KUdpHeaderLength + aMessage.Length();
    if ( sourcePort == KNatPort )
        {
        udpDatagramLength += KNonEspMarkerLength; 
        }
    sourcePort          = SWAP_BYTE_ORDER16(sourcePort);
    destinationPort     = SWAP_BYTE_ORDER16(destinationPort);
    udpDatagramLength   = SWAP_BYTE_ORDER16(udpDatagramLength);
    
    TUint8* udpHeader = ipAndUdpHeader + KIpHeaderLength;
    Mem::Copy(udpHeader, &sourcePort, sizeof(sourcePort));
    Mem::Copy(udpHeader + 2, &destinationPort, sizeof(destinationPort));
    Mem::Copy(udpHeader + 4, &udpDatagramLength, sizeof(udpDatagramLength));
    
    TPtrC8 headerPtr(ipAndUdpHeader, KIpAndUdpHeaderLength);
    return iPcapFile.Write(headerPtr);
    }

TInt CIkePcapTrace::WriteNonEspMarker()
    {
    TUint8 nonEspMarker[] = { 0x00, 0x00, 0x00, 0x00 };

    TPtrC8 ptr(nonEspMarker, KNonEspMarkerLength);
    return iPcapFile.Write(ptr);
    }

TInt CIkePcapTrace::WriteIkeMessage(TPtr8& aMsgCopy, TEncryptionType aEncryptionType)
    {
    const TInt KVersionPosition = 17;
    
    TInt err = KErrNone;     
    if (aMsgCopy.Length() < KFixedHdrLength)
        {
        //This is a bit too short for an IKE packet.
        //Just write the packet to log anyway. It might give some info to someone.
        err = iPcapFile.Write(aMsgCopy);
        }
    else
        {
        //Version check:
        if (aMsgCopy[KVersionPosition] == 0x10)
            {   
            err = WriteIkeV1Message(aMsgCopy);
            }
        else
            {
            err = WriteIkeV2Message(aMsgCopy, aEncryptionType);
            }
        }
    
    return err;
    }


TInt CIkePcapTrace::WriteIkeV1Message(TPtr8& aMsgCopy)
    {
    //This should already be checked by the caller.
    __ASSERT_DEBUG(aMsgCopy.Length() >= KFixedHdrLength, User::Invariant());
        
    const TUint KEncryptionBitPosition    = 19;
    const TUint KFirstNextPayloadPosition = 16;    
    const TUint KFixedPayloadHdrLength    = 4;
    
    const TUint8 KPayloadNone               = 0x00;
    const TUint8 KPayloadHash               = 0x08;
    const TUint8 KPayloadSignature          = 0x09;
    const TUint8 KPayloadReservedRangeStart = 0x0E;
    
    aMsgCopy[KEncryptionBitPosition] = aMsgCopy[KEncryptionBitPosition] & 0xFE;

    TUint8 nextPayloadId = aMsgCopy[KFirstNextPayloadPosition];
    TPtr8 msgEnd(aMsgCopy.MidTPtr(KFixedHdrLength));
    
    while(nextPayloadId != KPayloadNone && 
          msgEnd.Length() > KFixedPayloadHdrLength)
        {
        //Read the lenght of the payload
        TUint16 payloadLength = ((TUint16)msgEnd[2]) << 8 | msgEnd[3]; 
      
        if (nextPayloadId == KPayloadHash ||
            nextPayloadId == KPayloadSignature ||
            nextPayloadId >= KPayloadReservedRangeStart)
            {
            if(msgEnd.Length() >= payloadLength &&
               payloadLength >= KFixedPayloadHdrLength )
                {
                // Zero out payload data.
                TUint16 dataLength = payloadLength - KFixedPayloadHdrLength;
                TPtr8 payloadData = msgEnd.MidTPtr(KFixedPayloadHdrLength, dataLength);
                payloadData.FillZ();
                }
            else
                {
                  //There seems to be something wrong with the packet.
                  //Zero out the rest of the packet and write it to the log.
                  msgEnd.FillZ();
                  msgEnd[0] = KPayloadNone;
                }                
            }
        
        nextPayloadId = msgEnd[0];
        if (nextPayloadId != KPayloadNone && 
            msgEnd.Length() >= payloadLength)
            {
            msgEnd.Set(msgEnd.MidTPtr(payloadLength));
            }
        else
            {
            msgEnd.Set(msgEnd.MidTPtr(msgEnd.Length()));
            }        
        }
    
    return iPcapFile.Write(aMsgCopy);
    }


TInt CIkePcapTrace::WriteIkeV2Message(TPtr8& aMsgCopy, TEncryptionType aEncryptionType)
    {
    //This should already be checked by the caller.
    __ASSERT_DEBUG(aMsgCopy.Length() >= KFixedHdrLength, User::Invariant());
    
    const TUint KFirstNextPayloadPosition        = 16;
    const TUint KFixedPayloadHdrLength           = 4;
    
    const TUint8 KPayloadNone      = 0x00;
    const TUint8 KEncryptedPayload = 0x2e;
    const TUint8 KAuthPayload      = 0x27;
    const TUint8 KEapPayload       = 0x30;    
    
    TUint8 nextPayloadId = aMsgCopy[KFirstNextPayloadPosition];
    TPtr8 msgEnd(aMsgCopy.MidTPtr(KFixedHdrLength));
    while(nextPayloadId != KPayloadNone && 
          msgEnd.Length() > KFixedPayloadHdrLength)
        {
        //Read the lenght of the payload
        TUint16 payloadLength = ((TUint16)msgEnd[2]) << 8 | msgEnd[3]; 
        
        switch(nextPayloadId)
            {
            case KEncryptedPayload:
                //change the encrypted payload length to match
                //the initialization vector length.
                msgEnd[2] = 0x00;
                switch(aEncryptionType)
                    {   
                    case EEncrDes: //falls through                    
                    case EEncrDes3:                        
                        msgEnd[3] = 0x0c;
                        break;
                    case EEncrAesCbc:                       
                        msgEnd[3] = 0x14;
                        break;
                    }
                payloadLength = msgEnd[3]; 
                break;
            case KAuthPayload:
                {
                const TUint8 KAuthPayloadHdrLength = 8;
                if (payloadLength > KAuthPayloadHdrLength && 
                    msgEnd.Length() >= payloadLength)
                    {
                    // Zero out payload data.
                    TPtr8 authData = msgEnd.MidTPtr(KAuthPayloadHdrLength, 
                                                    payloadLength - KAuthPayloadHdrLength);
                    authData.FillZ();
                    }
                }
                break;
            case KEapPayload:
                {
                const TUint8 KTotalFixEapHdrLength = 9;
                if (payloadLength > KTotalFixEapHdrLength && 
                    msgEnd.Length() >= payloadLength)
                    {
                    // Zero out payload data.
                    TPtr8 eapTypeData = msgEnd.MidTPtr(KTotalFixEapHdrLength,
                                                       payloadLength - KTotalFixEapHdrLength);
                    eapTypeData.FillZ();
                    }
                }
                break;
            }
        nextPayloadId = msgEnd[0];
        if (nextPayloadId != KPayloadNone && 
            msgEnd.Length() >= payloadLength)
            {
            msgEnd.Set(msgEnd.MidTPtr(payloadLength));
            }
        else
            {
            msgEnd.Set(msgEnd.MidTPtr(msgEnd.Length()));
            }
        }
    
    return iPcapFile.Write(aMsgCopy);
    }


TInt CIkePcapTrace::WritePcapHeader()
    {
    static const TUint KPcapHeaderLength = 24;
    TUint8 pCapHeader[] = { 0xd4, 0xc3, 0xb2, 0xa1,  // magic number
                            0x02, 0x00, 0x04, 0x00,  //major, minor version
                            0x00, 0x00, 0x00, 0x00,  //time offset
                            0x00, 0x00, 0x00, 0x00,  // accuracy of timestamps
                            0xff, 0xff, 0x00, 0x00,  // max length of captured packets, in octets 
                            0x0c, 0x00, 0x00, 0x00,  // data link type 
                           };
    
    TPtrC8 pCapHeaderPtr(pCapHeader, KPcapHeaderLength);    
    return iPcapFile.Write(pCapHeaderPtr);       
    }