--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vpnengine/eventmediator/src/eventlogger.cpp Thu Dec 17 09:14:51 2009 +0200
@@ -0,0 +1,331 @@
+/*
+* Copyright (c) 2003 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: This module defines event logger.
+*
+*/
+
+
+
+#include <eikenv.h>
+#include <bautils.h>
+//#include "filesdef.h"
+#include "eventlogger.h"
+
+//
+//Class that writes logs events into a binary file
+
+CEventLogger::CEventLogger(CEventMediatorServer* aServer)
+{
+ iServer = aServer;
+ iFileMaxLength = KBYTES_TO_BYTES * LOGFILE_MAX_LTH;
+}
+
+CEventLogger* CEventLogger::NewL(CEventMediatorServer* aServer)
+ {
+ CEventLogger* server = new (ELeave) CEventLogger(aServer);
+ return server;
+ }
+
+CEventLogger::CEventLogger(TInt aFileMaxLength, CEventMediatorServer* aServer)
+{
+ iServer = aServer;
+ if ( aFileMaxLength == 0 || aFileMaxLength > LOGFILE_MAX_LTH )
+ iFileMaxLength = KBYTES_TO_BYTES * LOGFILE_MAX_LTH;
+ else iFileMaxLength = KBYTES_TO_BYTES * aFileMaxLength;
+}
+
+CEventLogger::~CEventLogger()
+{
+}
+
+
+
+void CEventLogger::LogEvent(const TDesC8& aEvent)
+{
+ TInt position;
+ TInt log_elem_lth;
+ TBuf8<EVENTLOG_FILE_HEADER_LTH> file_hdr;
+
+/*-------------------------------------------------------------------
+ * Log an event into the binary file. File format:
+ * 0 3 7 CL
+ * +--------------------+--------------------+---------------------+
+ * ! File Id (FI)! Current length (CL)! Wrapping offset (WO)!
+ * +--------------------+--------------------+---------------------+
+ *
+ * +-----------------------+
+ * ! Curr event number (EN)
+ * +-----------------------+
+ * where;
+ *
+ * FI = File Id 0x474f4c45 = ELOG
+ * CL = Current free position in file (=offset value)
+ * WO = Wrapping offset
+ * EN = Event number; events are numbered starting from 1
+ * Number of the last event to be logged
+ *
+ * Log event data format:
+ *
+ * Log event data format:
+ * 0 3 7 15 19
+ * +-----------+----------+------------+------------------+----------------+
+ * ! Length(L) ! Event ! TimeStamp) ! Source ! Catogory (EC)) !
+ * ! ! number(EN) (TS) ! Component (SC) !
+ * +-----------+----------+------------+------------------+----------------+ - - - - +
+ * 23 27 31 n n+12
+ * +-----------+----------+------------+------------------+
+ * ! MsgId ! Descriptor Descriptors! Trailer (TR) !
+ * ! (MI) ! count (DC) (DE) ! !
+ * +-----------+----------+------------+------------------+
+ * * where;
+ *
+ * L = Length of log element
+ * EN = Event number
+ * TS = Time stamp (TTime in TInt64 (two TUint32)
+ * SC = UID of source component
+ * EC = Event catogory (Info, warning, error, debug)
+ * MI = Message Id, defines a text string in localisation file
+ * DC = Descriptor count, number of lth-data pairs
+ * DE = Descriptors: lth,lth...,data,data,... These are used to modify
+ * the text avaibale in localisation file
+ * TR = Element trailer: endmark1, endmark2, length of log element
+ * same value as in (L)
+ *
+ *---------------------------------------------------------------------*/
+ if ( OpenLogFile() )
+ {
+ file_hdr.SetLength(EVENTLOG_FILE_HEADER_LTH);
+ if ( GetFileHeader(file_hdr) ) {
+ position = GetElemDataPosition(file_hdr, aEvent.Length());
+ if ( position ) {
+ log_elem_lth = WriteLogElem(position, aEvent);
+ if ( log_elem_lth ) {
+ position += log_elem_lth;
+ SaveFileHeader(position, file_hdr);
+ }
+ }
+ }
+
+ CloseLogFile();
+ }
+
+}
+
+TBool CEventLogger::OpenLogFile()
+{
+ TBool file_created = EFalse;
+ TInt position = 0;
+/*--------------------------------------------------------
+ * Open event log file
+ *--------------------------------------------------------*/
+ if(iFS.Connect()!=KErrNone)
+ return EFalse;
+ if ( iLogFile.Create(iFS, iServer->EventLogFileName(), EFileWrite|EFileShareAny) != KErrNone )
+ {
+ if (iLogFile.Open(iFS, iServer->EventLogFileName(), EFileWrite|EFileShareAny) != KErrNone)
+ {
+// DEB(iEngine->PrintText(_L("Error opening Trace file\n"));)
+ iFS.Close();
+ return EFalse;
+ }
+ }
+ else file_created = ETrue;
+
+ if ( file_created ) {
+ /*--------------------------------------------------------
+ * Write file header initial values to created file
+ * (Current_offset = First_elem_offset = 16)
+ *--------------------------------------------------------*/
+ TBuf8<EVENTLOG_FILE_HEADER_LTH> file_hdr;
+ file_hdr.SetLength(EVENTLOG_FILE_HEADER_LTH);
+ StoreFileHeaderInfo(EVENTLOG_FILE_HEADER_LTH, 0, file_hdr);
+ if ( SaveFileHeader(EVENTLOG_FILE_HEADER_LTH, file_hdr) == EFalse ) {
+// DEB(iEngine->PrintText(_L("File header creation error\n"));)
+ return EFalse;
+ }
+ iLogFile.Seek(ESeekStart, position); // return file pointer to file start
+ }
+
+ return ETrue;
+}
+
+void CEventLogger::CloseLogFile()
+{
+/*--------------------------------------------------------
+ * Close event log file
+ *--------------------------------------------------------*/
+ iLogFile.Close();
+ iFS.Close();
+}
+
+TBool CEventLogger::GetFileHeader(TDes8 &aBuf)
+{
+/*--------------------------------------------------------
+ * Read current log file length from file start
+ *--------------------------------------------------------*/
+ if ( iLogFile.Read(aBuf, EVENTLOG_FILE_HEADER_LTH) ) {
+ return EFalse;
+ }
+
+ return ETrue;
+}
+
+
+TInt CEventLogger::GetElemDataPosition(TDes8 &aFileHdr, TInt aLength)
+{
+ TInt position;
+/*---------------------------------------------------------------
+ * Get log element position value from file header
+ * If (position + aLength) > file max length, wrap file
+ *---------------------------------------------------------------*/
+ TFileHeader *file_hdr = (TFileHeader *)aFileHdr.Ptr();
+ position = file_hdr->GetPosition();
+ if ( ( position + aLength +
+ ELEM_HEADER_LTH + ELEM_TRAILER_LTH ) > iFileMaxLength )
+ {
+ position = EVENTLOG_FILE_HEADER_LTH; // Wrapping occurs
+ }
+ iEventNumber = file_hdr->GetEventNumber() + 1;
+
+ return position;
+}
+
+/*
+TUint32 CEventLogger::GetTimeStamp()
+{
+TTime tmp_time;
+TDateTime date;
+TUint32 time_stamp = 0;
+*/
+/*---------------------------------------------------------------
+ * Get time stamp for log element.
+ * Map the year-month-day-hour-minutes-seconds information to
+ * 32 bits into the following way:
+ * 3 2 1 0
+ * 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+ * Y Y Y Y M M M M D D D D D D H H H H H H M M M M M M S S S S S S
+ * where;
+ * Bits 31-28 = Current Year - 2000 (0-15)
+ * Bits 27-24 = Current Month index (0-11))
+ * Bits 23-18 = Current Day (1-31)
+ * Bits 17-12 = Current Hour (0-23)
+ * Bits 11-7 = Current Minutes (0-59)
+ * Bits 6-0 = Current Seconds (0-59)
+ *
+ *--------------------------------------------------------------- /
+ tmp_time.HomeTime();
+ date = tmp_time.DateTime();
+
+ time_stamp |= (((TUint32)(date.Year() - 2000)) << 28);
+ time_stamp |= ((TUint32)date.Month() << 24);
+ time_stamp |= ((TUint32)date.Day() << 18);
+ time_stamp |= ((TUint32)date.Hour() << 12);
+ time_stamp |= ((TUint32)date.Minute() << 6);
+ time_stamp |= (TUint32)date.Second();
+
+ return time_stamp;
+}
+*/
+
+TBool CEventLogger::SaveFileHeader(TInt aPosition, TDes8 &aBuf)
+{
+ TInt old_position;
+ TInt wrapping_offset;
+/*---------------------------------------------------------------
+ * Save event log element position value to file header
+ * If current position < position in file header, file has wrapped.
+ * Store then wrapping offset in file header, too
+ *---------------------------------------------------------------*/
+ TFileHeader *file_hdr = (TFileHeader *)aBuf.Ptr();
+ old_position = file_hdr->GetPosition();
+ wrapping_offset = file_hdr->GetWrappingOffset();
+ if ( old_position > aPosition ) {
+ wrapping_offset = old_position; /* wrapping occurred */
+ }
+ else {
+ if ( wrapping_offset && ( wrapping_offset < aPosition ) ) {
+ wrapping_offset = 0;
+ }
+ }
+
+ StoreFileHeaderInfo(aPosition, wrapping_offset, aBuf);
+
+ old_position = 0; // not old position really, just integer with value 0 needed
+ iLogFile.Seek(ESeekStart, old_position); // return file pointer to file start
+ if ( iLogFile.Write(aBuf, EVENTLOG_FILE_HEADER_LTH) )
+ return EFalse;
+
+ return ETrue;
+}
+
+
+void CEventLogger::StoreFileHeaderInfo(TInt aPosition, TInt aWrappingOffset, TDes8 &aBuf)
+{
+
+ TFileHeader *file_hdr = (TFileHeader *)aBuf.Ptr();
+ file_hdr->SetFileId();
+ file_hdr->SetPosition(aPosition);
+ file_hdr->SetWrappingOffset(aWrappingOffset);
+ file_hdr->SetEventNumber(iEventNumber);
+
+}
+
+TInt CEventLogger::WriteLogElem(TInt aPosition, const TDesC8& aEvent)
+
+//TInt CEventLogger::WriteLogElem(TInt aPosition, const TLogEvent& aEvent, const TDesC8& aData)
+{
+ TBuf8<ELEM_HEADER_LTH> header;
+ TBuf8<ELEM_TRAILER_LTH> trailer;
+// TUint32 time_stamp;
+ TInt data_lth=aEvent.Length();
+ TInt eventLength = data_lth + ELEM_HEADER_LTH + ELEM_TRAILER_LTH;
+/*---------------------------------------------------------------
+ * Write log event data into the log file
+ * Build first log element header:
+ * log elem length + iEventNumber + time stamp
+ *---------------------------------------------------------------*/
+// time_stamp = GetTimeStamp();
+ header.SetLength(ELEM_HEADER_LTH);
+
+ TElemHeader *elem_hdr = (TElemHeader *)header.Ptr();
+ elem_hdr->SetEventLength((TUint32) eventLength);
+ elem_hdr->SetEventNumber((TUint32) iEventNumber);
+
+ TTime tmpTime;
+ const TInt64* currTime;
+ tmpTime.HomeTime();
+ currTime = &tmpTime.Int64();
+ elem_hdr->SetTime(*currTime);
+
+ trailer.SetLength(ELEM_TRAILER_LTH);
+ TElemTrailer *elem_trailer = (TElemTrailer *)trailer.Ptr();
+ elem_trailer->SetLogEndMark();
+ elem_trailer->SetEventLength((TUint32) eventLength);
+ iLogFile.Seek(ESeekStart, aPosition); // Set file pointer
+/*---------------------------------------------------------------
+ * Write log event into log element
+ *---------------------------------------------------------------*/
+ if ( iLogFile.Write(header) ) //Element header
+ return 0;
+
+ if ( iLogFile.Write(aEvent)) //log event data
+ return 0;
+
+ if ( iLogFile.Write(trailer) ) //Element trailer
+ return 0;
+
+ return eventLength;
+
+}
+