diff -r 000000000000 -r 33413c0669b9 vpnengine/eventviewer/src/eventviewer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vpnengine/eventviewer/src/eventviewer.cpp Thu Dec 17 09:14:51 2009 +0200 @@ -0,0 +1,653 @@ +/* +* 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: Event viewer +* +*/ + + + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "eventviewer.h" +#include "eventviewer2.h" +#include "log_eventviewer.h" + +///////////////////////////////////////////// +// Method IDs +//////////////////////////////////////////// +#define KGetMostRecentEvent 0 +#define KGetNextEvent 1 +#define KGetPreviousEvent 2 +#define KGetEventUsingEventNumber 3 + + +////////////////////////////////////////////////////////////// +// Create EventViewer object +///////////////////////////////////////////////////////////// +EXPORT_C CEventViewer* CEventViewer::NewL() + { + CEventViewer *self = new (ELeave) CEventViewer(); + CleanupStack::PushL(self); + self->ConstructL(); + LOG(Log::Printf(_L("Constructing EventViewer\n"))); + CleanupStack::Pop(); // self + return self; + } + +///////////////////////////////////////////////////////////// +// CEventViewer::CEventViewer() +// C++ default constructor +///////////////////////////////////////////////////////////// +// +// CEventViewer::CEventViewer() : iEikonEnv(*iCoeEnv) +// { +// } + +////////////////////////////////////////////////////////////// +// Phase 2 constructor +///////////////////////////////////////////////////////////// +void CEventViewer::ConstructL() + { + TInt status = iFS.Connect(); + if (status != KErrNone) + { + LOG(Log::Printf(_L("iFS.Connect failed %d\n"), status)); + User::Leave(status); + } + + status = iEventMediator.Connect(); + if (status != KErrNone) + { + LOG(Log::Printf(_L("iEventMediator.Connect failed %d\n"), status)); + User::Leave(status); + } + + status = OpenLogFile(); // Open log file and read file header + if (status != KErrNone) + { + LOG(Log::Printf(_L("OpenLogFile failed %d\n"), status)); + User::Leave(status); + } + OpenResourceFileL(); + } +////////////////////////////////////////////////////////////// +// Destructor +///////////////////////////////////////////////////////////// +CEventViewer::~CEventViewer() + { + LOG(Log::Printf(_L("Destructing EventViewer\n"))); + + delete iLogFileBuf; + iLogFileBuf = 0; + CloseLogFile(); + delete iResultBuf; + iResultBuf = 0; + iResourceFile.Close(); + iFS.Close(); + iEventMediator.Close(); + } + +////////////////////////////////////////////////////////////// +// OpenResourceFileL() +// Used in ConstructL to get resource file +////////////////////////////////////////////////////////////// +// +void CEventViewer::OpenResourceFileL() + { + //RResourceFile resourceFile; + _LIT(KResourceFile, "\\resource\\vpnlogmessages.rsc"); + + TFileName resourceFileName(KResourceFile); + TFileName dllName; + Dll::FileName(dllName); + TBuf<2> drive = dllName.Left(2); + resourceFileName.Insert(0, drive); + iResourceFile.OpenL(iFS, resourceFileName); + iResourceFile.ConfirmSignatureL(); + } + + +////////////////////////////////////////////////////////////// +// Release resources allocated for a call +///////////////////////////////////////////////////////////// +//void CEventViewer::ReleaseResourcesL() +// { + +// } + +////////////////////////////////////////////////////////////////// +// +// GetMostRecentEvent +// +///////////////////////////////////////////////////////////////// +EXPORT_C TInt CEventViewer::GetMostRecentEvent( + HBufC*& aEventText, + TEventProperties& aEventProperties) + { + TInt status = GetRequestedEvent( + aEventText, + aEventProperties, + 0, // Event number + KGetMostRecentEvent); + return status; + } +////////////////////////////////////////////////////////////////// +// +// GetNextEvent +// +///////////////////////////////////////////////////////////////// +EXPORT_C TInt CEventViewer::GetNextEvent( + HBufC*& aEventText, + TEventProperties& aEventProperties) + { + TInt status = GetRequestedEvent( + aEventText, + aEventProperties, + 0, // Event number + KGetNextEvent); + return status; + } + +////////////////////////////////////////////////////////////////// +// +// GetPrevousEvent +// +///////////////////////////////////////////////////////////////// +EXPORT_C TInt CEventViewer::GetPreviousEvent( + HBufC*& aEventText, + TEventProperties& aEventProperties) + { + TInt status = GetRequestedEvent( + aEventText, + aEventProperties, + 0, // Event number + KGetPreviousEvent); + return status; + } + +////////////////////////////////////////////////////////////////// +// +// GetEventUsingEventNumber +// +///////////////////////////////////////////////////////////////// +EXPORT_C TInt CEventViewer::GetEventUsingEventNumber( + HBufC*& aEventText, + TUint32 aEventNumber, + TEventProperties& aEventProperties) + { + TInt status = GetRequestedEvent( + aEventText, + aEventProperties, + aEventNumber, + KGetEventUsingEventNumber); + return status; + } + + +////////////////////////////////////////////////////////////////// +// +// GetRequestedEvent - Get Requested Event +// This is a common function for API calls. It searches the event +// that the API user has requested. The function returns a buffer +// containing the event text and TEventProperties structure that +// contains some parameters relating to the event. +// +///////////////////////////////////////////////////////////////// + TInt CEventViewer::GetRequestedEvent( + HBufC*& aEventText, + TEventProperties& aEventProperties, + TUint32 aEventNumber, + TInt aMethodId) + { + TInt status = 0; + TRAPD (err, status = GetRequestedEventL( + aEventText, + aEventProperties, + aEventNumber, + aMethodId)) + + if (err != KErrNone) + { + LOG(Log::Printf(_L("API request failed, status %d\n"), err)); + + status = err; + } + return status; + } + +TInt CEventViewer::GetRequestedEventL( + HBufC*& aEventText, + TEventProperties& aEventProperties, + TUint32 aEventNumber, + TInt aMethodId) + { + TInt status; + LOG(Log::Printf(_L("API request received, method = %d\n"), aMethodId)); + + // + // Store the API parameters to this object + // + iEventText = &aEventText; + iEventProperties = &aEventProperties; + // + // Produce the event number that the user is requesting + // + + switch (aMethodId) + { + case KGetMostRecentEvent: + { + + // Read the log file to memory buffer if not yet done + + if (iLogFileBuf == 0) + { + + status = ReadWholeLogFileToMemoryBuffer(); + if (status != KErrNone) + { + break; + } + TakeCopyOfFileHeader(iCurrFileHeader, iPreviousFileHeader); + } + + // Check if the log file has been modified and read the log + // file header + + else + { + status = ReadLogFileHeader(); + if (status != KErrNone) + { + break; + } + if (IsLogFileModified()) + { + TakeCopyOfFileHeader(iCurrFileHeader, iPreviousFileHeader); + } + } + iRequestedEventNumber = iCurrFileHeader.iCurrEventNumber; + break; + } + + case KGetNextEvent: + { + iRequestedEventNumber++; + break; + } + case KGetPreviousEvent: + { + iRequestedEventNumber--; + break; + } + case KGetEventUsingEventNumber: + { + iRequestedEventNumber = aEventNumber; + break; + } + default: + { + break; + } + } + // + // Check the validity of requested event number + // + + if (iRequestedEventNumber == 0 || + iRequestedEventNumber > iCurrFileHeader.iCurrEventNumber || + iLogFileBuf == 0) // Logfile not yet in memory + { + LOG(Log::Printf(_L("API request completed, requested event not found \n"))); + return KErrNotFound; + } + // + // Search the event from the memory resident log file + // + status = EventLookup(iRequestedEventNumber); + if (status != KErrNone) + { + return status; // Event not found + } + // + // Event found, copy the packed format log element parameters to an + // unpacked object + // + + CopyPackedLogElemToUnpackedObject(iPositionOfCurrLogElem); + + // + // Search the event text relating to the MsgId + // + HBufC* eventTextBuf; + eventTextBuf = SearchEventTextL(iUnpackedLogElem.iMsgId); + if (eventTextBuf == 0) + { + return KErrNoMemory; + } + + // + // Modify the event text with the descriptor data + // DescrPtr points to a list of following elements: + // TInt DataLength + // TInt8 Data + // + + TUint32 descrDataPosition = iPositionOfCurrLogElem + LOG_ELEM_HEADER_LTH; + HBufC* modifiedEventTextBuf = ModifyEventText( + eventTextBuf, + iUnpackedLogElem.iDescrCount, // Count of descriptor elements + descrDataPosition); // Descriptors: lth,lth,...data,data... + if (modifiedEventTextBuf == 0) + { + return KErrNoMemory; + } + // + // An event is available, return data to the caller + // + *iEventText = modifiedEventTextBuf; + iResultBuf = 0; + iEventProperties->iEventNumber = iUnpackedLogElem.iEventNumber; + iEventProperties->iMsgId = iUnpackedLogElem.iMsgId; + TTime tmpTime(iUnpackedLogElem.iTimeStamp); + iEventProperties->iTimeStamp = tmpTime; + iEventProperties->iSourceComponent = iUnpackedLogElem.iSourceComponent; + iEventProperties->iCategory = iUnpackedLogElem.iCategory; + LOG(Log::Printf(_L("API request completed OK \n"))); + + return KErrNone; + + } + + + ////////////////////////////////////////////////////////////////////// + // EventLookup + // This function searches an event from the log file buffer that + // matches with the requested event number. + ////////////////////////////////////////////////////////////////////// +TInt CEventViewer::EventLookup(TUint32 aEventNumber) + { + TUint32 positionOfLogElemEnd = iCurrFileHeader.iPositionOfNextFree; + TUint32 positionOfLogElem; + TInt searchGoing = ETrue; + TInt status = KErrNone; + iWrappingOccured = EFalse; + // + // Loop here until matching event found or end of elements reached + // or any error found + // + + while (searchGoing && status == KErrNone) + { + // + // Check if wrapping 1 + // + if (positionOfLogElemEnd == EVENTLOG_FILE_HEADER_LTH) + { + + + if (iCurrFileHeader.iPositionOfWrapping != 0) + { + positionOfLogElemEnd = iCurrFileHeader.iPositionOfWrapping; // Wrapping occurs + iWrappingOccured = ETrue; + } + else + { + status = KErrNotFound; + continue; + } + } + + // + // Produce the start position of an event + // + + status = GetStartPositionOfLogElem( positionOfLogElemEnd, + &positionOfLogElem); + if (status != KErrNone) + { + continue; + } + + // + // Check if requested event has been found + // + + if (iUnpackedLogElem.iEventNumber != aEventNumber) + { + positionOfLogElemEnd = positionOfLogElem; + continue; // Not found, continue + } + // + // Requested event found, stop the loop + // + status = KErrNone; + iPositionOfCurrLogElem = positionOfLogElem; + searchGoing = EFalse; + + } + + return status; + } + + +///////////////////////////////////////////////////////////////////// +// SearchEventText +// This function searches from the localization file the text string +// relating to the MsgId parameter and allocates an buffer in which +// it returns the data to the caller. +// +///////////////////////////////////////////////////////////////////// + +HBufC* CEventViewer::SearchEventTextL( TUint32 aMsgId) + { + HBufC8* resourceBuf = NULL; + HBufC* textDataBuf = NULL; + + // + // MsgId is a code defined in epoc32\include\eventviewererr.rsg + // file. It refers to a message in .rsc file. + // + TInt msgNumber = STATIC_CAST(TInt, aMsgId); + resourceBuf = iResourceFile.AllocReadL( msgNumber); + + TResourceReader resourceReader; + + resourceReader.SetBuffer(resourceBuf); + + textDataBuf = HBufC::New(resourceBuf->Length()); + if (textDataBuf) + { + TPtr textDataPtr(textDataBuf->Des()); + + resourceReader.Read((void*)textDataBuf->Ptr(), resourceBuf->Length()); + textDataPtr.SetLength(resourceBuf->Length()/2); + } + + delete resourceBuf; + return textDataBuf; + } + +///////////////////////////////////////////////////////////////////// +// ModifyEventText +// This function modifies the event text by the descriptors. +// Both the event text and descriptors are parameters of the +// function. +// +///////////////////////////////////////////////////////////////////// + +HBufC* CEventViewer::ModifyEventText( + HBufC* aEventTextSrc, + TUint32 aDescrCount, // Count of descriptor elements + TUint32 aDescrDataPosition) // Descriptors: lth data lth data.... + { + HBufC* modifiedEventText; + + // + // If descriptors exist, build pointer to the first + // length definition. The format of descriptor data + // is as follows: + // -- TUInt32 Length of parameter 1 (lth1) + // -- TUInt32 Length of parameter 2 (lth2) + // -- TUInt32 Length of parameter n (lthx) + // -- TInt8[lth1] Data 1 + // -- TInt8[lth2] Data 2 + // -- TInt8[lthx] Data n + // Variable length data, The format of + // data is defined by the conversion + // specification characters in the text string + // + + // + // No descriptors, return localisation data buffer + // + if (aDescrCount == 0) + { + return aEventTextSrc; + } + + // + // Build TPtr8 pointer for descriptor list + // + + TInt descrLth = iUnpackedLogElem.iEventLength - + LOG_ELEM_HEADER_LTH - + LOG_ELEM_TRAILER_LTH; + TPtr8 logFileBuf (iLogFileBuf->Des()); // Log file in memory + TPtr8 descrListPtr (const_cast(logFileBuf.Ptr())+ aDescrDataPosition, // Data ptr + descrLth, // Data length + descrLth); // Max length + // + // Modify the localisation data buffer with the descriptor data + // + modifiedEventText = FormatEvent( + aDescrCount, + descrListPtr, + aEventTextSrc->Des()); + + + delete aEventTextSrc; + return modifiedEventText; + } + + +///////////////////////////////////////////////////////////////////// +// GetIapName +// These functions are used to convert an IAP ID to IAP name. +// +//////////////////////////////////////////////////////////////////// +EXPORT_C TInt EventViewer::GetIapName(TUint32 aIapId, TIapName& aIapName) + { + TRAPD(err, DoGetIapNameL(aIapId, aIapName)); + return err; + } + +EXPORT_C TInt EventViewer::GetSnapName(TUint32 aSnapId, TIapName& aSnapName) + { + TRAPD(err, DoGetSnapNameL(aSnapId, aSnapName)); + return err; + } + +EXPORT_C TInt EventViewer::GetIapNames(TUint32 aIapId1, TIapName& aIapName1, + TUint32 aIapId2, TIapName& aIapName2) + { + TRAPD(err, DoGetIapNamesL(aIapId1, aIapName1, aIapId2, aIapName2)); + return err; + } + +void EventViewer::DoGetIapNameL(TUint32 aIapId, TIapName& aIapName) + { + using namespace CMManager; + + RCmManagerExt cmManagerExt; + cmManagerExt.OpenL(); + CleanupClosePushL(cmManagerExt); + + RCmConnectionMethodExt connectionMethod = cmManagerExt.ConnectionMethodL( aIapId ); + CleanupClosePushL(connectionMethod); + + HBufC* cmName = connectionMethod.GetStringAttributeL(ECmName); // Ownership passed + + aIapName.Copy(*cmName); + delete cmName; + cmName = NULL; + + CleanupStack::PopAndDestroy(&connectionMethod); + CleanupStack::PopAndDestroy(&cmManagerExt); + } + +void EventViewer::DoGetIapNamesL(TUint32 aIapId1, TIapName& aIapName1, + TUint32 aIapId2, TIapName& aIapName2) + { + using namespace CMManager; + + RCmManagerExt cmManagerExt; + cmManagerExt.OpenL(); + CleanupClosePushL(cmManagerExt); + + RCmConnectionMethodExt connectionMethod1 = cmManagerExt.ConnectionMethodL( aIapId1 ); + CleanupClosePushL(connectionMethod1); + + HBufC* cmName1 = connectionMethod1.GetStringAttributeL(ECmName); + CleanupStack::PushL(cmName1); + + aIapName1.Copy(*cmName1); + + RCmConnectionMethodExt connectionMethod2 = cmManagerExt.ConnectionMethodL( aIapId2 ); + CleanupClosePushL(connectionMethod2); + + HBufC* cmName2 = connectionMethod2.GetStringAttributeL(ECmName); // Ownership passed + + aIapName2.Copy(*cmName2); + + delete cmName2; + cmName2 = NULL; + CleanupStack::PopAndDestroy(4); + } + + +void EventViewer::DoGetSnapNameL(TUint32 aSnapId, TIapName& aSnapName) + { + RCmManagerExt cmManagerExt; + cmManagerExt.OpenL(); + CleanupClosePushL(cmManagerExt); + + RCmDestinationExt destination = cmManagerExt.DestinationL( aSnapId ); + CleanupClosePushL(destination); + + HBufC* snapName16bit = destination.NameLC(); + CnvUtfConverter::ConvertFromUnicodeToUtf8(aSnapName, *snapName16bit); + CleanupStack::PopAndDestroy(snapName16bit); + + CleanupStack::PopAndDestroy(); //destination + CleanupStack::PopAndDestroy(); //cmManagerExt + } + +///////////////////////////////////////////////////////////////////// +// DeleteLogFile +// This function deletes the eventlog.bin file +// +//////////////////////////////////////////////////////////////////// +EXPORT_C TInt CEventViewer::DeleteLogFile() + { + TRAPD(err, DoDeleteLogFileL()); + return err; + }