// Copyright (c) 2005-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:

// Trace Data parser

//

#include <e32svr.h>

#include <e32def.h>

#include <e32def_private.h>

#include <e32btrace.h>

#include "tracedataparser.h"

#include "testdatawriternotifier.h"

#include "tracecoreconstants.h"

#include "d32tracebuffer.h"

EXPORT_C TUint32 TTraceDataParser::Swap(TUint32 x)

    {

    return  (x>>24) | ((x<<8) & 0x00FF0000) | ((x>>8) & 0x0000FF00) | (x<<24);

    }

EXPORT_C TUint32 TTraceDataParser::ReadUint32FromBuf(TUint8*& aBuf, TBool aFromTestWriter)

    {

#ifdef __WINS__

    aFromTestWriter = EFalse;

#endif

    // reads a 4 byte integer of expected endianess

    TUint32 n;

    if (!aFromTestWriter)

        {

        n = *(aBuf+3) + (*(aBuf+2) << 8) + (*(aBuf+1) << 16) + (*aBuf << 24);

        }

    else

        {

        // endianess order is reversed for TestWriter on hw

        n = (*aBuf) + (*(aBuf+1) << 8) + (*(aBuf+2) << 16) + (*(aBuf+3) << 24);    

        }

    aBuf += sizeof(TUint32);

    return n;

    }

EXPORT_C TUint16 TTraceDataParser::ReadUint16FromBuf(TUint8*& aBuf)

    {

    // reads a 2 byte integer of expected endianess

    TUint16 n = (*aBuf << 8)+ (*(aBuf+1));

    aBuf += sizeof(TUint16);

    return n;

    }

TPtr8 TTraceDataParser::ReadTracePrintf(TUint8* aData, TInt aSize)

    {

    TPtr8 printfString(aData, aSize, aSize);

    TInt endPosition = printfString.Locate(TChar(0));

    if (endPosition >= 0)

        {

        printfString = printfString.Left(endPosition);

        }

    else

        {

        printfString.Trim();

        }

    return printfString;

    }

TBool TTraceDataParser::StringsMatch(const TDesC8& aString1, const TDesC8& aString2)

    {

    TInt compareLength = (aString1.Length() > aString2.Length()) ? aString2.Length() : aString1.Length();

    if ( (aString2.Left(compareLength).Compare(aString1) == 0) ||

         (aString1.Left(compareLength).Compare(aString2) == 0) )

        {

        return ETrue;

        }

    return EFalse;

    }

/**

 * Function to string for a number

 * @param aBuffer Trace data descriptor

 * @param aFindStringPattern Pattern that indicates where in the string the number will be, using an asterisk

 * @param aNumberFound If found, the number in the string

 * @return Symbian error code

 */

TInt TTraceDataParser::ParseStringForNumber(const TDesC8& aBuffer, const TDesC8& aFindStringPattern, TInt& aNumberFound)

    {

    TInt err = KErrNotFound;

    TInt posOfNum = aFindStringPattern.Locate('*');

    TInt lengthOfNum = 1 + aBuffer.Length() - aFindStringPattern.Length();

    if (posOfNum >= 0 && lengthOfNum >= 1)

        {

        TBuf<KMaxNumberBufferLength> numberBuffer;

        numberBuffer.Copy(aBuffer.Mid(posOfNum, lengthOfNum));

        TLex lex(numberBuffer);

        err = lex.Val(aNumberFound);

        }

    return err;

    }

/*

 * Validate the trace data in buffer

 *

 * @param aBuffer the buffer containing the trace data

 * @param aExpectedNum expected number of traces

 * @param aComponentID component ID of traces

 * @param aGroupID group ID of traces

 * @param aData first expected trace data

 * @param aTraceWord trace word of traces

 * @param aIdentical indicates that the payload of each trace packet should be identical

 * @param aBufferMode The mode of the trace buffer.. 0=straight, 1=circular.

 * @param aOrdinalData indicates whether the payload data reflects its position in the stream of trace packets

 * @param aNumTraces number of traces written to circular buffer

 * @param aMaxTraces maximum number of traces circular buffer can hold

 * @return Standard Symbian error code

 */

EXPORT_C TInt TTraceDataParser::ValidatePayload(TDesC8&         aBuffer,

                                                TInt            aExpectedNum,

                                                TComponentId    aComponentID, 

                                                TGroupId        aGroupID, 

                                                TUint32         aData, 

                                                TUint32         aTraceWord,

                                                TBool           aIdentical, 

                                                TInt            aBufferMode, 

                                                TBool           aOrdinalData, 

                                                TInt            aNumTraces, 

                                                TInt            aMaxTraces)

    {

    if ((aBuffer.Length() == 0) && (aExpectedNum <= 0))    // size is zero and there should be no traces

        {

        return KErrNone;

        }

    if ((aBuffer.Length() == 0) && (aExpectedNum > 0))     // size is zero and there should be traces

        {

        return KErrCorrupt;

        }

    if (aBuffer.Length() != 0 && (aExpectedNum <= 0))      // size is non-zero and there should be no traces

        {

        return KErrCorrupt;

        }

    TUint32 lastData = aData;

    TBool firstInStream = ETrue;

    // get the current position on the stream of traces so we can determine what the payload value should be.

    TInt overwrites = 0;

    if (aBufferMode == RTraceBuffer::EFreeRunning)

        {

        TInt overwrittenTraces = aNumTraces; // initialise to number of traces we wrote to the buffer for circular test

        while (overwrittenTraces > aMaxTraces)

            {

            overwrittenTraces = overwrittenTraces - aMaxTraces; // aMaxTraces is the max the buffer can hold 

            overwrites++;

            }

        lastData = (aMaxTraces * (overwrites - 1)) + overwrittenTraces + 1; // get where we are in the buffer

        }

    TInt            numberOSTtraces = 0;

    TUint8*         data            = (TUint8*) aBuffer.Ptr();

    TUint8*         endOfData       = data + aBuffer.Size();    

    TUint8          testGID         = aGroupID;

    TUint32         testCID         = aComponentID;

    TUint32         testTraceWord   = 0;

    TTraceHeaderSettings  traceHeaderSettings;

    // Loop through all traces

    while (data < endOfData)

        {

        // Get trace info from header

        TInt err = ParseHeader(data, endOfData-data, traceHeaderSettings);

        if (err != KErrNone)

            {

            return err;

            }

        //check the missing flag if we expect it

        if ((firstInStream&&(overwrites>0)))

            {

            if(!(traceHeaderSettings.iHeaderFlags & BTrace::EMissingRecord))

                {

                return KErrCorrupt;

                }

            }

        if (!traceHeaderSettings.iPrintfTrace)

            {

            testTraceWord = ((TUint32) (testGID << GROUPIDSHIFT)) + 1;

            // check group ID

            if (traceHeaderSettings.iCategory != testGID)

                {

                return KErrCorrupt;

                }

            // check component ID

            if (traceHeaderSettings.iComponentID != testCID)

                {

                return KErrCorrupt;

                }

            // check trace word

            if (traceHeaderSettings.iTraceWord != testTraceWord)

                {

                return KErrCorrupt;

                }

            TBool lastTrace = EFalse;

            if ( (traceHeaderSettings.iMultiPartType == BTrace::EMultipartLast) || (!traceHeaderSettings.iMultiPartType) )

                {

                lastTrace = ETrue;

                }

            // check trace payload

            for (TInt i=0; traceHeaderSettings.iLengthOfPayload>0; i++)

                {

                TUint32 param = Swap(ReadUint32FromBuf(data, traceHeaderSettings.iFromTestWriter));

                // For circular case, we try to estimate to within +/- 2 where we are in payload

                // for straight case we should get it exactly correct.

                if ( ((param != lastData) && (aBufferMode == 0)) || 

                      ( ((param > lastData + 2) || (param < lastData - 2)) && (aBufferMode == RTraceBuffer::EFreeRunning) ) )

                    {

                    return KErrCorrupt;

                    }

                lastData = param; // in case we weren't accurate in circular case.

                traceHeaderSettings.iLengthOfPayload -= 4;

                lastData++;

                }

            lastData = (!aOrdinalData)? aData : lastData;

            if (!aOrdinalData)

                {

                lastData = (lastTrace || aIdentical) ? aData : lastData;

                }

            if (traceHeaderSettings.iMultiPartType || aIdentical || aOrdinalData)

                {

                testGID = aGroupID;

                testCID = aComponentID;

                testTraceWord = aTraceWord;

                }

            else

                {

                testGID++;

                testCID++;

                testTraceWord += (1 << GROUPIDSHIFT);

                }

            numberOSTtraces++;

            }

        else

            {

            // Go to the next trace

            data += traceHeaderSettings.iLengthOfPayload;

            }

        firstInStream = EFalse; //after this, it's defnitely not the first trace in the stream.

        }

    // Check that we're getting the correct number of traces

    //or approximate ammount (+/-1) for circular buffer because

    //the arithmetic to overwrite traces sometimes also skips one

    //extra trace

    if (numberOSTtraces != aExpectedNum)

        {

        if ((aBufferMode==RTraceBuffer::EFreeRunning)

                &&((numberOSTtraces>=aExpectedNum-1)||(numberOSTtraces<=aExpectedNum+1)))

            {

            return KErrNone;

            }

        return KErrCorrupt;

        }

    return KErrNone;

    }

/*

 * Validate the single trace data in buffer

 * 

 * @param aBuffer the buffer containing the trace data

 * @param aTracePresent determines if trace data should be present or not

 * @param aGroupID expected GID

 * @param aComponentID expected CID

 * @param aData expected trace data

 * @param aPrintfTrace determines if trace data should be printf data or not

 * @param aMissingTrace determines if trace data should indicate missing data or not

 * @param aExpectedPrintfTrace expected printf trace data

 * @return Standard Symbian error code

 */

EXPORT_C TInt TTraceDataParser::ValidatePayload(TDesC8&        aBuffer, 

                                                TBool          aTracePresent, 

                                                TGroupId       aGroupID, 

                                                TComponentId   aComponentID, 

                                                TUint32        aData,

                                                TBool          aPrintfTrace,

                                                TBool          aMissingTrace,

                                                TDesC8*        aExpectedPrintfTrace)

    {

    if ((aBuffer.Length() == 0) && (!aTracePresent))    // size is zero and there should be no traces

        {

        return KErrNone;

        }

    if ((aBuffer.Length() == 0) && (aTracePresent))     // size is zero and there should be traces

        {

        return KErrCorrupt;

        }

    if (aBuffer.Length() != 0 && (!aTracePresent))      // size is non-zero and there should be no traces

        {

        return KErrCorrupt;

        }

    TUint8*         data            = (TUint8*) aBuffer.Ptr();

    TUint8*         endOfData       = data + aBuffer.Size();    

    TTraceHeaderSettings  traceHeaderSettings;

    // Get trace info from header

    TInt err = ParseHeader(data, endOfData-data, traceHeaderSettings);

    if (err != KErrNone)

        {

        return err;

        }

    // check trace type

    if (traceHeaderSettings.iPrintfTrace != aPrintfTrace)

        {

        return KErrCorrupt;

        }

    if (!traceHeaderSettings.iPrintfTrace)

        {

        TUint32 testTraceWord = ((TUint32) (aGroupID << GROUPIDSHIFT)) + 1;

        // check group ID

        if (traceHeaderSettings.iCategory != aGroupID)

            {

            return KErrCorrupt;

            }

        // check component ID

        if (traceHeaderSettings.iComponentID != aComponentID)

            {

            return KErrCorrupt;

            }

        // check trace word

        if (traceHeaderSettings.iTraceWord != testTraceWord)

            {

            return KErrCorrupt;

            }

        if (aMissingTrace)

            {

            // check missing flag

            if (!(traceHeaderSettings.iHeaderFlags & BTrace::EMissingRecord))

                {

                return KErrCorrupt;

                }

            }

        TInt i = 0;

        while (data < endOfData)

            {

            TUint32 param = Swap(ReadUint32FromBuf(data, traceHeaderSettings.iFromTestWriter));

            if (param != aData + i)

                {

                return KErrCorrupt;

                }

            i++;

            }

        }

    else if (!aExpectedPrintfTrace)

        {

        return KErrArgument;

        }

    else

        {

        TBuf8<KExpectedPrintfMaxLength> expectedPrintf;

        // In the case of an expected dropped trace, we only check for "* Dropped Trace" because

        // the test writer has completed the request for data when it writes that bit first (right 

        // before the next trace), and when it goes to write the actual trace, it doesn't.

        // If we change this, the "* Dropped Trace" will be overwritten by the actual trace before

        // the test can check it, since the test writer doesn't buffer trace data.

        if (aMissingTrace)

            {

            // check that "* Dropped Trace" is in the buffer

            expectedPrintf = KDroppedTrace;

            }

        else

            {

            // check that "Test Printf Trace" is in the buffer"

            expectedPrintf = *aExpectedPrintfTrace;

            }

        expectedPrintf.Append(TChar(0)); // printf handler appends null at the end.

        TPtrC8 actualprintf(data, traceHeaderSettings.iLengthOfPayload);

        // Need to fix endianess for hw

#ifndef __WINS__

        TInt bufpos = 0;

        while (bufpos < (actualprintf.Length()-4))

            {

            // reads a 4 byte integer of expected endianess

            TUint32 n = actualprintf[bufpos] + (actualprintf[bufpos+1] << 8) + (actualprintf[bufpos+2] << 16) + (actualprintf[bufpos+3] << 24);

            bufpos += sizeof(TUint32);

            TUint32 tempData = Swap(n);

            memcpy((TAny*)(actualprintf.Ptr()+bufpos-4),(TAny*)&tempData, sizeof(TUint32));

            }        

#endif //__WINS__

        if (expectedPrintf.Compare(actualprintf) != 0)

            {

            return KErrCorrupt;

            }

        // Check if there is another trace to follow

        data += traceHeaderSettings.iLengthOfPayload;

        if (data != endOfData)

            {

            TPtrC8 buffer(data, endOfData - data);

            return ValidatePayload(buffer, 

                                   aTracePresent, 

                                   aGroupID, 

                                   aComponentID, 

                                   aData,

                                   aPrintfTrace,

                                   EFalse,

                                   aExpectedPrintfTrace);

            }

        }    

    return KErrNone;

    }

/*

 * Verify the priming data contains all the expected values

 *

 * @param aBuffer Buffer containing the trace data

 * @param aSize Size of the trace buffer

 * @param aCategory BTrace category of the trace data

 * @param aSubCategory BTrace subcategory of the trace data

 * @param aElementsFound Parameter to hold current state of expected data found so far

 * @param aVerificationData1 Optional input value - used differently for different categories

 * @param aVerificationData2 Optional input value - used differently for different categories

 * @return Standard Symbian error code

 */

TInt TTraceDataParser::VerifyPrimingData(TUint8* aBuffer, 

                                         TInt    aSize, 

                                         TUint8  aCategory, 

                                         TUint8  aSubCategory, 

                                         TInt&   aElementsFound,

                                         TBool   aFromTestWriter, 

                                         TUint32 aVerificationData1, 

                                         TUint32 aVerificationData2)

    {

    TInt err = KErrNotSupported;

    switch(aCategory)

        {

        case BTrace::EThreadIdentification:

            err = VerifyThreadPrimingData(aBuffer, aSize, aSubCategory, aElementsFound, aFromTestWriter, aVerificationData1, aVerificationData2);

            break;

        case BTrace::EFastMutex:

            err = VerifyFastMutexPrimingData(aBuffer, aSize, aSubCategory, aElementsFound, aFromTestWriter);

            break;

        case BTrace::ECodeSegs:

            err = VerifyCodeSegsPrimingData(aBuffer, aSize, aSubCategory, aElementsFound, aFromTestWriter, aVerificationData1, aVerificationData2);

            break;

        default:

            break;

        }

    return err;    

    }

/*

 * Verify the EThreadIdentification priming data contains all the expected values

 *

 * @param aBuffer Buffer containing the trace data

 * @param aSize Size of the trace buffer

 * @param aSubCategory BTrace subcategory of the trace data

 * @param aElementsFound Parameter to hold current state of expected data found so far

 * @param aThreadAddr The address of the thread to search for

 * @param aProcessAddr The address of the process to search for

 * @return Standard Symbian error code

 */

TInt TTraceDataParser::VerifyThreadPrimingData(TUint8* aBuffer, 

                                               TInt    aSize, 

                                               TUint8  aSubCategory, 

                                               TInt&   aElementsFound,

                                               TBool   aFromTestWriter, 

                                               TUint32 aThreadAddr, 

                                               TUint32 aProcessAddr)

    {

    RThread currentThread;    

    RProcess currentProcess;

    TUint32 tempThreadAddr;

    TUint32 tempProcessAddr;

    switch(aSubCategory)

        {

        case BTrace::EProcessCreate:

            {

            tempProcessAddr = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

            if (tempProcessAddr == aProcessAddr)

                {

                aElementsFound |= 0x000000ff;

                }

            }

            break;

        case BTrace::EProcessName:

            {

            tempThreadAddr = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

            tempProcessAddr = Swap(ReadUint32FromBuf(aBuffer, aFromTestWriter));

            if ( (tempThreadAddr == aThreadAddr) && (tempProcessAddr == aProcessAddr) )

                {

                TBuf8<KMaxName> currentProcessName;

                currentProcessName.Copy(currentProcess.Name());

                TPtr8 processName(aBuffer,(aSize-8),(aSize-8)); //should be name of the process

                processName.Trim();

                if (StringsMatch(currentProcessName, processName))

                    {

                    aElementsFound |= 0x0000ff00;