/*

* Copyright (c) 2000-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:   Log file handler

*

*/

#include "eventviewer2.h"

#include "log_eventviewer.h"

//#include "logcommon.h"

///////////////////////////////////////////////////////////////////

//  OpenLogFile

//  This function checks the state of the LogFile and tries to open

//  the file if it is not yet open. It also reads the header section

//  of the file and checks that the file is a correct log file.

///////////////////////////////////////////////////////////////////

TInt CEventViewer::OpenLogFile()

    {

    TInt status = ReadLogFileHeader();

    if (status != KErrNone)

        {

        return status;

        }

    TakeCopyOfFileHeader(iCurrFileHeader, iPreviousFileHeader);   

    return KErrNone;

    }

///////////////////////////////////////////////////////////////////

//  CloseLogFile

//  This function closes the log file

///////////////////////////////////////////////////////////////////

void CEventViewer::CloseLogFile()

    {

    ;

    }

///////////////////////////////////////////////////////////////////

//  DoDeleteLogFileL

//  This function deletes the event log file

///////////////////////////////////////////////////////////////////

void CEventViewer::DoDeleteLogFileL()

    {

    CloseLogFile();

    TInt status = iEventMediator.ClearEventLog();

    LOG(Log::Printf(_L("Log cleared %d\n"), status));

    if (status != KErrNone)

        {

        User::Leave(status);

        }

    }

///////////////////////////////////////////////////////////////////

//  ReadWholeLogFileToMemoryBuffer()

//  

//  This function reads the whole log file to a memory buffer

//  and takes a new version of file header.

///////////////////////////////////////////////////////////////////

TInt CEventViewer::ReadWholeLogFileToMemoryBuffer()

    {

    TInt status;

    status = iEventMediator.GetEventLogSize(iLogFileSize);

    if (status != KErrNone)

        {

        return status;

        }

    if (iLogFileSize < EVENTLOG_FILE_HEADER_LTH)

        {

        return KErrNotFound;

        }

    delete iLogFileBuf;

    iLogFileBuf = 0;

    iLogFileBuf = HBufC8::New(iLogFileSize + 2048); // 2048: it can be bigger now

    if (iLogFileBuf == 0)

        {

        return KErrNoMemory;

        }

    TPtr8 ptr(iLogFileBuf->Des());

    status = iEventMediator.GetEventLogData(ptr);

    if (status != KErrNone)

        {

        return status;

        }

    status = CopyPackedFileHeaderToUnpackedObject(ptr);

    if (status != KErrNone) 

        {

        return status;

        }

    return KErrNone;

    }           

///////////////////////////////////////////////////////////////////

//  ReadLogFileHeader

//  This function reads the packed format file header section of the

//  event log file  and copies the contents of header to the

//  caller's unpacked object.

///////////////////////////////////////////////////////////////////

TInt CEventViewer::ReadLogFileHeader()

    {

    TBuf8<EVENTLOG_FILE_HEADER_LTH> fileHeaderBuf;

    TInt status = iEventMediator.GetEventLogHeader(fileHeaderBuf);

    if (status != KErrNone)

        {

        return status;

        }

    status = CopyPackedFileHeaderToUnpackedObject(fileHeaderBuf);

    if (status != KErrNone)

        {

        return status;

        }

    return KErrNone;

    }

///////////////////////////////////////////////////////////////////

//  TakeCopyOfFileHeader

//  This function takes a copy of the unpacked  file header.               

///////////////////////////////////////////////////////////////////

void CEventViewer::TakeCopyOfFileHeader(TUnpackedFileHeader& asrc,

                                        TUnpackedFileHeader& adest)

    {

    adest.iFileId                = asrc.iFileId;

    adest.iPositionOfNextFree    = asrc.iPositionOfNextFree;

    adest.iPositionOfWrapping    = asrc.iPositionOfWrapping;

    adest.iCurrEventNumber       = asrc.iCurrEventNumber;

    }

///////////////////////////////////////////////////////////////////

//  CopyPackedFileHeaderToUnpackedObject

//  This function copies the packet format file header to an

//  unpacked object.

///////////////////////////////////////////////////////////////////

TInt CEventViewer::CopyPackedFileHeaderToUnpackedObject( TDesC8& aFileHeader)

    {

    // Convert the TDesC8 parameter to TUint8* format

    TFileHeader* fileHeader = (TFileHeader*) aFileHeader.Ptr(); 

    // Copy the packet format header parameters to unpacked object

    iCurrFileHeader.iFileId                = fileHeader->GetFileId();

    iCurrFileHeader.iPositionOfNextFree    = fileHeader->GetPositionOfNextFree();

    iCurrFileHeader.iPositionOfWrapping    = fileHeader->GetPositionOfWrapping();

    iCurrFileHeader.iCurrEventNumber       = fileHeader->GetCurrEventNumber();

    // Check the file Id

    if (iCurrFileHeader.iFileId != LOG_FILE_ID)

       {

       return KErrNotFound;

       }

    return KErrNone;

    }

///////////////////////////////////////////////////////////////////

//  IsLogFileModified

//  Check if the logfile has been modified (file header is no more

//  the same as previously)

///////////////////////////////////////////////////////////////////

TBool CEventViewer::IsLogFileModified()

    {

    if (iCurrFileHeader.iFileId == iPreviousFileHeader.iFileId

        &&

        iCurrFileHeader.iPositionOfNextFree == iPreviousFileHeader.iPositionOfNextFree)

        {

        return EFalse;

        }

    return ETrue;

    }

///////////////////////////////////////////////////////////////////

//  GetStartPositionOfLogElem

//  This function calculates the start position of a log element.

//  As input parameter it has the position of the first byte

//  after the element.

///////////////////////////////////////////////////////////////////

TInt CEventViewer::GetStartPositionOfLogElem(TUint32 aPositionOfLogElemEnd,       

                                             TUint32* aPositionOfLogElem)

    {

    // Set base for the most recent log element trailer

    TPtr8 logFileBuf (iLogFileBuf->Des()); // Log file in memory

    TUint32  logElemTrailerPos = aPositionOfLogElemEnd - LOG_ELEM_TRAILER_LTH;

    if (iWrappingOccured && logElemTrailerPos <= iCurrFileHeader.iPositionOfNextFree)

        {

        return KErrNotFound;

        }

    TPtr8 elemTrailer (const_cast<TUint8*>(logFileBuf.Ptr())+ logElemTrailerPos, // Data ptr

                       LOG_ELEM_TRAILER_LTH,    // Data length

                       LOG_ELEM_TRAILER_LTH);   // Max length

    // Convert the TPtr8 parameter to TUint8* format

    TLogElemTrailer* elemTrailerPtr = (TLogElemTrailer*) elemTrailer.Ptr(); 

    // Copy the packet format trailer parameters to unpacked object

    iLogElemTrailer.iEndMark1             = elemTrailerPtr->GetEndMark1();

    iLogElemTrailer.iEndMark2             = elemTrailerPtr->GetEndMark2();

    iLogElemTrailer.iEventLength          = elemTrailerPtr->GetEventLength();

    // Check the validity of trailer

    if (iLogElemTrailer.iEndMark1 != END_MARK_1

        ||

        iLogElemTrailer.iEndMark2 != END_MARK_2

        ||

        iLogElemTrailer.iEventLength > aPositionOfLogElemEnd +

        EVENTLOG_FILE_HEADER_LTH)

        {

        return KErrGeneral;

        }

    // Set position for the current log element

    TUint32  logElemPos = aPositionOfLogElemEnd - iLogElemTrailer.iEventLength;

    if (iWrappingOccured && logElemPos < iCurrFileHeader.iPositionOfNextFree)

        {

        return KErrNotFound;

        }

    TPtr8 logElem (const_cast<TUint8*>(logFileBuf.Ptr())+ logElemPos, // Data ptr

                   iLogElemTrailer.iEventLength,   // Data length

                   iLogElemTrailer.iEventLength);

    // Convert the TPtr8 parameter to TUint8* format

    TLogElem* logElemPtr = (TLogElem*) logElem.Ptr(); 

    // Copy the event number and event length parameters

    // from packed format log element to unpacked object

    iUnpackedLogElem.iEventLength                 = logElemPtr->GetEventLength();

    iUnpackedLogElem.iEventNumber                 = logElemPtr->GetEventNumber();

    // Verify the extracted data

    if (iUnpackedLogElem.iEventNumber > iCurrFileHeader.iCurrEventNumber

        ||

        iUnpackedLogElem.iEventLength  != iLogElemTrailer.iEventLength)

        {

        return KErrGeneral;

        }

    *aPositionOfLogElem = logElemPos;

    return KErrNone;

    }

    //

    // Event found, copy the packed format log element parameters to an

    // unpacked object

    //

///////////////////////////////////////////////////////////////////

//  CopyPackedFileHeaderToUnpackedObject

//  This function copies the packet format log file element to an

//  unpacked object.

///////////////////////////////////////////////////////////////////

void CEventViewer::CopyPackedLogElemToUnpackedObject(TUint32 aPositionOfCurrLogElem)

    {

    // Build the log element pointer

    TPtr8 logFileBuf (iLogFileBuf->Des()); // Log file in memory

    TPtr8 logElem (const_cast<TUint8*>(logFileBuf.Ptr())+ aPositionOfCurrLogElem, // Data ptr

                   iUnpackedLogElem.iEventLength,   // Data length

                   iUnpackedLogElem.iEventLength);  // Max length

    // Convert the TPtr8 parameter to TUint8* format

    TLogElem* logElemPtr = (TLogElem*) logElem.Ptr(); 

    // Copy the packet format header parameters to unpacked object

    iUnpackedLogElem.iMsgId                = logElemPtr->GetMsgId();

    iUnpackedLogElem.iTimeStamp            = logElemPtr->GetTimeStamp();

    iUnpackedLogElem.iSourceComponent      = logElemPtr->GetSourceComponent();

    iUnpackedLogElem.iCategory             = logElemPtr->GetCategory();

    iUnpackedLogElem.iDescrCount           = logElemPtr->GetDescrCount();

    }