diff -r 000000000000 -r 33413c0669b9 vpnengine/eventmediator/inc/eventmediator.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/vpnengine/eventmediator/inc/eventmediator.h Thu Dec 17 09:14:51 2009 +0200 @@ -0,0 +1,579 @@ +/* +* Copyright (c) 2003-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: This module defines event mediator and the services of it. +* +*/ + + + +/** + * @file eventmediator.h + * + * This module defines event mediator and the services of it. + * + */ + +#ifndef __EVENTMEDIATOR_H__ +#define __EVENTMEDIATOR_H__ + +// INCLUDES +#include +#include +#include "eventmediatorapi.h" +#include "eventmediatordefs.h" + +#include "sitdeathobserver.h" + +// FORWARD DECLARATIONS +class CEventMediatorSession; +class TEventContainer; +class CEventLogger; + +class CSit; + +class CListenerContainer; + +// CLASS DECLARATION + +/** +* Defines the event mediator server. +*/ +class CEventMediatorServer : public CPolicyServer, public MSitDeathListener + { + friend class CEventMediatorSession; // Friend class + + public: //Methods + + // Constructors and destructor + + /** + * Static constructor + */ + static CEventMediatorServer* NewL(void); + + /** + * Static constructor + */ + static CEventMediatorServer* NewLC(void); + + /** + * Destructor + */ + ~CEventMediatorServer(void); + + /** + * Creates a new session. + */ + CSession2* NewSessionL(const TVersion& aVersion, const RMessage2& aMessage) const; + + // Other methods + + /** + * Reports new envent to the eventmediator server. + * @param aType: type of the event. + * @param aSpec: additional info on event. + * @param aData: a descriptor containing event data. + */ + void ReportEventL(const TEventType aType, TDesC8* aSpec, + TDesC8* aData, TInt aStatus = KErrNone); + + /** + * Completes the last message in error case. + * @param aError: Cause of the call of this function. + */ + void CompleteLastMessage(TInt aError); + + /** + * Finds out whether the specified client thread is a SIT + * thread or not + */ + TBool IsClientTheSitL(const RMessage2& aMessage); + + /** + * Starts the SIT thread if it is not running + */ + void MakeSureSitIsRunningL(); + + /** + * Saves a pointer to the listening request that represents the + * task arrival observation request + */ + void SetTaskArrivalListenerL(CListenerContainer* aListener); + + /** + * Clears the pointer to the listening request that represents the + * task arrival observation request + */ + void ClearTaskArrivalListener(); + + /** + * Returns the pointer to the task arrival observation request + */ + CListenerContainer* TaskArrivalListener(); + + /** + * Notifies the server about a new task request that has arrived + */ + void TaskRequestArrivedL(CListenerContainer* aTaskRequest); + + /** + * Notifies the server about a new task arrival + * observation request that has arrived from the SIT + */ + void TaskArrivalObservationRequestArrivedL(); + + /** + * Notifies the server about a new task request event + * specification fetching request that has arrived from + * the SIT. + */ + void TaskRequestEventSpecFetchingRequestArrivedL(CListenerContainer* aFetchingRequest); + + /** + * Notifies the server about a new task cancellation + * observation request that has arrived from the SIT. + */ + void TaskCancellationObservationRequestArrivedL(CListenerContainer* aRequest); + + /** + * Completes a pending task arrival observation + * request when a new task request has arrived. + */ + void CompleteTaskArrivalObservationRequestL(TEventType aEventType, TDesC8* aSpec); + + /** + * Completes a pending task request event + * specification fetching request. + */ + void CompleteTaskRequestEventSpecFetchingRequestL(TInt aStatus, TDesC8* aEventSpec, + TDesC8* aTaskRequestEventSpec); + + /** + * Tries to find a task request that is not yet + * being fulfilled by the SIT. + */ + CListenerContainer* FindWaitingTaskRequest(); + + /** + * Retrieves the event listener object, if any, that has the + * specified event type and event specification ID. + */ + CListenerContainer* FindListener(TEventType aEventType, TInt aEventSpecId); + + /** + * Retrieves the event listener object, if any, that is using + * the SIT that has the specified thread ID and is fulfilling + * the specified event. + */ + CListenerContainer* FindListener(TEventType aEventType, const TDesC8* aEventSpec); + + /** + * Completes the listener that matches the specified search + * criteria. + */ + void CompleteListener(TEventType aEventType, const TDesC8* aEventSpec, TInt aStatus); + + /** + * Completes the listener that matches the specified search + * criteria. + */ + void CompleteListener(CListenerContainer* aListenerPtr, TInt aStatus); + + /** + * Returns the number of "normal" (non-sit) + * sessions that are present + */ + TInt NormalSessionCount(); + + /** + * Completes all task requests with the specified status + */ + void CompleteTaskRequests(TInt aStatus); + + /** + * Returns a new event specification ID. + */ + TInt NewEventSpecId(); + + TPtrC EventLogFileName(void); + + public: // From MSitDeathListener + void SitDied(); + + protected: + /** + * Process any errors + * + * @param aError the leave code reported + */ + TInt RunError(TInt aError); + + private: // Methods + + // Constructors and destructor + + /** + * Default constructor + */ + CEventMediatorServer(void); + + /** + * Perform the second phase construction of a CVpnManagerServer + * object. + * @param aServer Pointer to the server itself. + */ + void ConstructL(CEventMediatorServer* aServer); + + // Other methods + + /** + * Stops the server if the session count is zero. + */ + void StopEventMediator(void); + + /** + * Copies data describing an event to the client. + * @param aMessge: a message from client side sent by RConnection::FetchData + * @return error code, KErrNone if successfull + */ + TInt CopyEventDataL(const RMessage2& aMessage); + + /** + * Reduces listener count of a stored event by one and destroys it if count becomes zero. + * @param aIndex: the index of the stored event in the list. + */ + void MarkStoredEventListened(TInt aIndex); + + /** + * Sets the iShuttingDown flag. + */ + void SetShuttingDown(TBool aShuttingDown); + + private: //Data + // List of Events that have been reported but not handled by all listeners. + CArrayFixFlat iStoredEvents; + // Number of currently existing sessions. + TInt iSessionCount; + // Log writer + CEventLogger* iLogger; + // The next event specification ID + // (used with SIT event listening requests) + TInt iNextEventSpecId; + // The single SIT instance + CSit* iSit; + // The single task arrival listener + CListenerContainer* iTaskArrivalListener; + + // A flag that is set to true when + // the server starts going down + TBool iShuttingDown; + + TFileName iEventLogFileName; + + static const TUint iRangeCount; + static const TInt iRanges[]; + static const TUint8 iElementIndex[]; + + static const CPolicyServer::TPolicyElement iElements[]; + static const CPolicyServer::TPolicy iPolicy; + + }; + +// CLASS DECLARATION + +/** +* Defines the session to the VPN manager server. +*/ +class CEventMediatorSession : public CSession2 + { + public: //Message types + enum + { + KEventMediatorListen, + KEventMediatorListenWithSpec, + KEventMediatorCancel, + KEventMediatorCancelWithSpec, + KEventMediatorCancelAll, + KEventMediatorReportEvent, + KEventMediatorReportEventWithSpec, + KEventMediatorFetchData, + KEventMediatorReportLogEvent, + KEventMediatorNewEventSpecId, + KEventMediatorDeletePrivateFiles, + KEventMediatorGetEventLogSize, + KEventMediatorGetEventLogHeader, + KEventMediatorGetEventLogData, + KEventMediatorClearEventLog + }; + + public: // Methods + + // Constructors and destructor + + /** + * Static constructor + */ + static CEventMediatorSession* NewL(CEventMediatorServer* aServer, const RMessage2& aMessage); + + /** + * Default destructor + */ + ~CEventMediatorSession(void); + + /** + * Wrapper function which Dispatches and executes the client's service calls + * (See Message type definition). + */ + void ServiceL(const RMessage2& aMessage); + + /** + * Checks if client is listening events of the given type and completes message + * sent by clients ListenToEvent function. The length of the event data and + * the pointer to that data are written to the message. + * @param aType: type of the event. + * @param aSpec: additional info on event. + * @param aData: event data. + * @return number of listeners for the event was listened. + */ + TInt CheckEventL(const TEventType aType, const TDesC8* aSpec, const TDesC8* aData, TInt aStatus); + + /** + * Tries to find a task request that is not being fulfilled + * already + */ + CListenerContainer* FindWaitingTaskRequest(); + + /** + * Retrieves the event listener object, if any, that is using + * the SIT that is fulfilling the specified event. + */ + CListenerContainer* FindListener(TEventType aEventType, TInt aEventSpecId); + + /** + * Retrieves the event listener object, if any, that is using + * the SIT that is fulfilling the specified event. + */ + CListenerContainer* FindListener(TEventType aEventType, const TDesC8* aEventSpec); + + /** + * Completes the specified listener if it is owned by the + * session. Returns ETrue is the listener was found and + * completed, EFalse otherwise. + */ + void CompleteListener(TEventType aEventType, const TDesC8* aEventSpec, TInt aStatus); + + void CompleteTaskRequests(TInt aStatus); + + TBool IsASitSession(); + + private: //Methods + // Constructors and destructor + + /** + * Constructor + */ + CEventMediatorSession(CEventMediatorServer* aServer); + + /** + * Starts listening events of requesteed type by coping the message to iListenedEvents. + * @param aMessage: aMessage sent by clients ListenToEvent function. + * @return: error code, KErrNone if successfull. + */ + TInt ListenToEventWithSpecL(const RMessage2& aMessage); + + /** + * Starts listening events of requesteed type by coping the message to iListenedEvents. + * @param aMessage: aMessage sent by clients ListenToEvent function. + * @return: error code, KErrNone if successfull. + */ + TInt ListenToEventL(const RMessage2& aMessage); + + /** + * Reports the event contained in the message to the event mediator server. + * @param aMessage: aMessage sent by clients ReportEvent function. + * @return: error code, KErrNone if successfull. + */ + void ReportEventL(const RMessage2& aMessage); + + /** + * Reports a log event contained in the message to the event mediator server. + * @param aMessage: aMessage sent by clients ReportLogEvent function. + * @return: error code, KErrNone if successfull. + */ + void ReportLogEventL(const RMessage2& aMessage); + + /** + * Reports the event contained in the message to the event mediator server. + * @param aMessage: aMessage sent by clients ReportEvent function. + * @return: error code, KErrNone if successfull. + */ + void ReportEventWithSpecL(const RMessage2& aMessage); + + /** + * Cancels listning of one event type. + * @param aMessage: aMessage sent by clients CancelListenToEvent function. + */ + void CancelListening(const RMessage2& aMessage); + + /** + * Cancels listning of one event type. + * @param aMessage: aMessage sent by clients CancelListenToEvent function. + */ + void CancelListeningWithSpecL(const RMessage2& aMessage); + + /** + * Cancels all listening. + * @param aMessage: aMessage sent by clients CancelAllListening function. + */ + void CancelAll(); + + /** + * Copies event data from the server to the client. + * @param aMessage: aMessage sent by clients FetchData function. + * @return: error code, KErrNone if successfull. + */ + TInt FetchDataL(const RMessage2& aMessage); + + /** + * Looks up a message from iListenedEvents. + * @param aType: type of the event the message is listening to. + * @param aIndex: the position of the message in iListenedEvents. + * @return ETrue if message exists, EFalse if not. + */ + TBool FindListenerMsg(const TEventType aType,TInt& index); + + /** + * Looks up a message from iListenedEvents. + * @param aType: type of the event the message is listening to. + * @param aIndex: the position of the message in iListenedEvents. + * @return ETrue if message exists, EFalse if not. + */ + TBool FindListenerMsg(const TEventType aType,const TDesC8* aSpec,TInt& index); + + /** + * Searches for a task request type event listening request + */ + TBool FindTaskRequestListenerMsg(TInt& index); + + /** + * Reads data that was reported with the event from client. Allocates a buffer + * for data and gives ownership of that buffer to caller. + * @param aMessage: aMessage sent by clients ReportEvent function. + * @return pointer to the newly created buffer containig data. + */ + HBufC8* ReadEventDataFromClientL(const RMessage2& aMessage); + + /** + * Reads specification describing the event from client. Allocates a buffer + * for secification and gives ownership of that buffer to caller. + * @param aMessage: aMessage sent with event specification. + * @return pointer to the newly created buffer containig data. + */ + HBufC8* ReadSpecificationFromClientL(const RMessage2& aMessage); + + /** + * Completes the specified listener and deletes it from the + * listener list + */ + void CompleteListener(TInt aIndex, TInt aStatus); + + /** + * Returns to the client a new event specification ID + */ + void NewEventSpecIdL(const RMessage2& aMessage); + + TInt DeletePrivateFiles(); + void DeletePrivateFilesL(); + + TInt GetEventLogSize(const RMessage2& aMessage); + TInt GetEventLogHeader(const RMessage2& aMessage); + TInt GetEventLogData(const RMessage2& aMessage); + TInt ClearEventLog(); + + private: //Data + // List of messages listening to events + CArrayFixFlat iListenedEvents; + // Event mediator server + CEventMediatorServer* iServer; + + RFs iFs; + RFile iEventLogFile; + TBool iEventLogFileOpen; + // Is this session from a SIT or not + + public: + TBool iIsSitSession; + }; + +// CLASS DECLARATION + +/** +* Container for one reported event from witch it can be read by all listening sessions. +*/ +class TEventContainer + { + public: //Methods + // Constructors and destructor + + /** + * Inline constructor + */ + inline TEventContainer(TInt aCount, TDesC8* aData) : iData(aData), iListenerCount(aCount){}; + + public: //Data + // Data descriptor reported with the event. + TDesC8* iData; + // number of listeners that need this event + TInt iListenerCount; + }; + + +// CLASS DECLARATION + +/** +* Container for one reported event from which it can be read by all listening sessions +*/ +class CListenerContainer : public CBase + { + public: //Methods + // Constructors and destructor + CListenerContainer(const RMessage2& aMessage, TDesC8* aSpec, + CEventMediatorServer* aServer); + ~CListenerContainer(); + + inline TEventType Type() {return (TEventType) iMessage.Int0();} + inline RMessage2& Message() {return iMessage;} + inline TDesC8* Specification() {return iSpec;} + void Complete(TInt status); + + void AnalyzeRequestL(); + TBool WaitingForFulfilling(); + void MarkAsBeingFulfilled(); + TBool BeingFulfilled(); + + TBool HandlesEvent(TEventType aEventType, const TDesC8* aEventSpec); + + private: //Data + // Data descriptor reported with the event. + TDesC8* iSpec; + RMessage2 iMessage; + TEventType iEventType; + // Pointer to the event mediator server + CEventMediatorServer* iServer; + // A flag that tells whether the request + // is being fulfilled by the SIT or not + TBool iBeingFulfilledBySit; + }; + +#endif