1 /*

     2 * Copyright (c) 2003-2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   This module defines event mediator server side session.

    15 *

    16 */

    17 

    18 #include "eventmediatorsession.h"

    19 #include "eventmediator.h"

    20 #include "eventmediatorclientservercommon.h"

    21 #include "eventlogger.h"

    22 #include "sit.h"

    23 #include "log_em.h"

    24 

    25 #define FIRST_ARGUMENT 0

    26 #define SECOND_ARGUMENT 1

    27 #define THIRD_ARGUMENT 2

    28 #define FOURTH_ARGUMENT 3

    29 

    30 

    31 // ============================= CEventMediatorSession =============================     

    32 

    33 CEventMediatorSession* CEventMediatorSession::NewL(CEventMediatorServer& aServer, 

    34                                                    TBool aIsSitSession)

    35     {

    36     LOG(Log::Printf(_L("CEventMediatorSession::NewL - begin\n")));

    37     

    38     CEventMediatorSession* self = new (ELeave) CEventMediatorSession(aServer, aIsSitSession);

    39     CleanupStack::PushL(self);

    40     self->ConstructL();

    41     CleanupStack::Pop(); // self

    42 

    43     LOG(Log::Printf(_L("CEventMediatorSession::NewL - end\n")));

    44     return self;

    45     }

    46 

    47 CEventMediatorSession::CEventMediatorSession(CEventMediatorServer& aServer, TBool aIsSitSession)

    48     : iListenedEvents(2), iServer(aServer), iIsSitSession(aIsSitSession)

    49     {

    50     }

    51 

    52 void CEventMediatorSession::ConstructL()

    53     {

    54     if ( !IsASitSession() )

    55         {

    56         User::LeaveIfError(iFs.Connect()); // For EventLog

    57         iEventLogFileOpen = EFalse;

    58         }    

    59     }

    60 

    61 

    62 CEventMediatorSession::~CEventMediatorSession(void)

    63     {

    64     LOG(Log::Printf(_L("CEventMediatorSession::~CEventMediatorSession\n")));

    65     CancelAll();

    66 

    67     // If this too is a normal session and is dying,

    68     // decrement the normal session count by one

    69     if (!IsASitSession())

    70         {

    71         iEventLogFile.Close();

    72         iEventLogFileOpen = EFalse;

    73         iFs.Close();         

    74         }

    75     iServer.SessionDeleted(IsASitSession());    

    76     }

    77 

    78 void CEventMediatorSession::ServiceL(const RMessage2& aMessage)

    79     {

    80     TInt status = 0;

    81 

    82     switch (aMessage.Function())

    83         {

    84         case KEventMediatorListen:

    85             ListenToEventL(aMessage);

    86             break;

    87 

    88         case KEventMediatorListenWithSpec:

    89             ListenToEventWithSpecL(aMessage);

    90             break;

    91 

    92         case KEventMediatorCancel:

    93             CancelListening(aMessage);        

    94             aMessage.Complete(KErrNone);

    95             break;

    96 

    97         case KEventMediatorCancelWithSpec:

    98             CancelListeningWithSpecL(aMessage);        

    99             aMessage.Complete(KErrNone);

   100             break;

   101 

   102         case KEventMediatorCancelAll:

   103             CancelAll();        

   104             aMessage.Complete(KErrNone);

   105             break;

   106 

   107         case KEventMediatorReportEvent:

   108             ReportEventL(aMessage);

   109             aMessage.Complete(KErrNone);

   110             break;

   111 

   112         case KEventMediatorReportEventWithSpec:

   113             ReportEventWithSpecL(aMessage);

   114             aMessage.Complete(KErrNone);

   115             break;

   116 

   117         case KEventMediatorFetchData:

   118             status = FetchDataL(aMessage);

   119             aMessage.Complete(status);

   120             break;

   121 

   122         case KEventMediatorReportLogEvent:

   123             ReportLogEventL(aMessage);

   124             aMessage.Complete(KErrNone);

   125             break;

   126 

   127         case KEventMediatorNewEventSpecId:

   128             NewEventSpecIdL(aMessage);

   129             aMessage.Complete(KErrNone);

   130             break;

   131         case KEventMediatorDeletePrivateFiles:

   132             status = DeletePrivateFiles();

   133             aMessage.Complete(status);

   134             break;

   135 

   136         case KEventMediatorGetEventLogSize:

   137             status = GetEventLogSize(aMessage);

   138             aMessage.Complete(status);

   139             break;

   140 

   141         case KEventMediatorGetEventLogHeader:

   142             status = GetEventLogHeader(aMessage);

   143             aMessage.Complete(status);

   144             break;

   145         case KEventMediatorGetEventLogData:

   146             status = GetEventLogData(aMessage);

   147             aMessage.Complete(status);

   148             break;

   149         case KEventMediatorClearEventLog:

   150             status = ClearEventLog();

   151             aMessage.Complete(status);

   152             break;

   153         default:

   154             aMessage.Complete(KErrGeneral);

   155             break;

   156         }

   157     }

   158 

   159 TInt CEventMediatorSession::ListenToEventL(const RMessage2& aMessage)

   160     {

   161     CListenerContainer* listener = new (ELeave) CListenerContainer(aMessage, NULL, iServer);

   162     CleanupStack::PushL(listener);

   163 

   164     iListenedEvents.AppendL(listener);

   165     CleanupStack::Pop(); // listener

   166 

   167     listener->AnalyzeRequestL();

   168 

   169     return KErrNone;

   170     }

   171 

   172 TInt CEventMediatorSession::ListenToEventWithSpecL(const RMessage2& aMessage)

   173     {

   174     HBufC8* specBuf = NULL;

   175 

   176     // Read specification

   177     specBuf = ReadSpecificationFromClientL(aMessage);

   178     CleanupStack::PushL(specBuf);

   179 

   180     // Ownership of specBuf is given to listener

   181     CListenerContainer* listener = new (ELeave) CListenerContainer(aMessage, specBuf, iServer);

   182     CleanupStack::Pop(); // specBuf

   183     CleanupStack::PushL(listener);

   184         

   185     iListenedEvents.AppendL(listener);

   186     CleanupStack::Pop(); // listener

   187 

   188     listener->AnalyzeRequestL();

   189 

   190     return KErrNone;

   191     }

   192 

   193 void CEventMediatorSession::CancelListening(const RMessage2& aMessage)

   194     {

   195     TInt index;

   196     

   197     while (FindListenerMsg((TEventType)aMessage.Int0(), index))

   198         {

   199         CompleteListener(index, KErrCancel);

   200         }

   201     }

   202 

   203 void CEventMediatorSession::CancelListeningWithSpecL(const RMessage2& aMessage)

   204     {

   205     HBufC8* specBuf = NULL;

   206     TInt index;

   207     

   208     // Read specification

   209     specBuf = ReadSpecificationFromClientL(aMessage);

   210     CleanupStack::PushL(specBuf);

   211 

   212     // Cancel listeners

   213     while (FindListenerMsg((TEventType)aMessage.Int0(), specBuf, index))

   214         {

   215         CompleteListener(index, KErrCancel);

   216         }

   217     CleanupStack::PopAndDestroy(); // specBuf

   218     }

   219 

   220 void CEventMediatorSession::CancelAll()

   221     {

   222     TInt nEvents = iListenedEvents.Count();

   223     for (TInt i = 0; i < nEvents; i++)  

   224         {

   225         iListenedEvents.At(i)->Complete(KErrCancel);

   226         delete iListenedEvents.At(i);

   227         iListenedEvents.At(i) = NULL;

   228         }

   229     iListenedEvents.Reset();

   230     }

   231 

   232 void CEventMediatorSession::ReportEventL(const RMessage2& aMessage)

   233     {

   234     TEventType eventType = (TEventType)aMessage.Int0();

   235     LOG(Log::Printf(_L("CEventMediatorSession::ReportEventL - event type = %d\n"), eventType));

   236     // Read data

   237     HBufC8* dataBuf = ReadEventDataFromClientL(aMessage);

   238     CleanupStack::PushL(dataBuf);

   239     // Report event to server

   240     iServer.ReportEventL(eventType, NULL, dataBuf);

   241     CleanupStack::Pop();

   242     }

   243 

   244 void CEventMediatorSession::ReportEventWithSpecL(const RMessage2& aMessage)

   245     {

   246     TEventType eventType=(TEventType) aMessage.Int0();

   247     LOG(Log::Printf(_L("CEventMediatorSession::ReportEventWithSpecL - event type = %d\n"), eventType));

   248     // Read data

   249     HBufC8* dataBuf = ReadEventDataFromClientL(aMessage);

   250     CleanupStack::PushL(dataBuf);

   251     // Read specification

   252     HBufC8* specBuf = ReadSpecificationFromClientL(aMessage);

   253     CleanupStack::PushL(specBuf);

   254     // Report event to server

   255     iServer.ReportEventL(eventType, specBuf, dataBuf);

   256     CleanupStack::PopAndDestroy(); // specBuf

   257     CleanupStack::Pop(); // dataBuf 

   258     }

   259 

   260 void CEventMediatorSession::ReportLogEventL(const RMessage2& aMessage)

   261     {

   262     LOG(Log::Printf(_L("CEventMediatorSession::ReportLogEventL\n")));

   263     // Read event

   264     TLogEvent event;

   265     TPckg<TLogEvent> eventPckg(event);

   266     aMessage.ReadL(FIRST_ARGUMENT, eventPckg);

   267 

   268     // Create one buffer to contain put everything in a normal buffer and

   269     TInt lengthsDesLth = event.iDesCount * sizeof(TInt);

   270     TInt position = eventPckg.Length();

   271     TInt dataLength = position + lengthsDesLth + aMessage.Int2();

   272     HBufC8* dataBuf = HBufC8::NewLC(dataLength);

   273     TPtr8 dataPtr = dataBuf->Des();

   274 

   275     // Copy event to buffer

   276     dataPtr.Append(eventPckg);

   277     // Read lengths to buffer

   278     TPtr8 tmpPtr(&dataPtr[position], 0, dataLength - position);

   279     aMessage.ReadL(SECOND_ARGUMENT, tmpPtr);

   280     // Read descriptors to the buffer

   281     position= dataPtr.Length();

   282     tmpPtr.Set(&dataPtr[position], 0, dataLength - position);

   283     aMessage.ReadL(THIRD_ARGUMENT, tmpPtr);

   284 

   285     // Report event to server

   286     iServer.ReportEventL(ELogEvent, NULL, dataBuf);

   287     CleanupStack::Pop();

   288     }

   289 

   290 TInt CEventMediatorSession::FetchDataL(const RMessage2& aMessage)

   291     {

   292     LOG(Log::Printf(_L("CEventMediatorSession::FetchDataL\n")));

   293     return iServer.CopyEventDataL(aMessage);

   294     }

   295 

   296 TInt CEventMediatorSession::CheckEventL(const TEventType aType, const TDesC8* aSpec,

   297                                         const TDesC8* aData, TInt aStatus)

   298     {

   299     TInt index;

   300     TInt listenerCount = 0;

   301     TInt dataLth = 0;

   302     // Some events don't not have data

   303     if (aData)

   304         {

   305         dataLth = aData->Length();

   306         }

   307     TPckg<TInt> lengthpckg(dataLth);

   308     TPckgC<const TAny*> ptrpckg(aData);

   309 

   310     while (FindListenerMsg(aType, aSpec, index))

   311         {

   312         RMessage2& listener = iListenedEvents.At(index)->Message();

   313 

   314         if (aStatus == KErrNone)

   315             {

   316             // Write info about data

   317             listener.WriteL(SECOND_ARGUMENT, lengthpckg);

   318             listener.WriteL(THIRD_ARGUMENT, ptrpckg);

   319 

   320             // Complete listener

   321             listener.Complete(KErrNone);

   322             }

   323         else

   324             {

   325             listener.Complete(aStatus);

   326             }

   327         

   328         delete iListenedEvents.At(index);

   329         iListenedEvents.Delete(index);

   330         listenerCount++;    

   331         }

   332 

   333     return listenerCount;

   334     }

   335 

   336 TBool CEventMediatorSession::FindListenerMsg(const TEventType aType, TInt& index)

   337     {

   338     for (TInt i = 0; i < iListenedEvents.Count(); i++)

   339         {

   340         if (iListenedEvents.At(i)->Type() == aType)

   341             {

   342             index=i;

   343             return ETrue;

   344             }

   345         }

   346     return EFalse;

   347     }

   348 

   349 TBool CEventMediatorSession::FindListenerMsg(const TEventType aType, const TDesC8* aSpec, TInt& index)

   350     {

   351     for (TInt i = 0; i < iListenedEvents.Count(); i++)

   352         {

   353         if (iListenedEvents.At(i)->HandlesEvent(aType, aSpec))

   354             {

   355             index = i;

   356             return ETrue;

   357             }

   358         }

   359     return EFalse;

   360     }

   361 

   362 TBool CEventMediatorSession::FindTaskRequestListenerMsg(TInt& index)

   363     {

   364     for (TInt i = 0; i < iListenedEvents.Count(); i++)

   365         {

   366         if (CSit::EventRequiresSit(iListenedEvents.At(i)->Type()))

   367             {

   368             index = i;

   369             return ETrue;

   370             }

   371         }

   372     return EFalse;

   373     }

   374     

   375 HBufC8* CEventMediatorSession::ReadSpecificationFromClientL(const RMessage2& aMessage)

   376     {

   377     HBufC8* specBuf;

   378     // Read specification descriptor length from client, create specification buffer

   379     const TAny* desPtr = aMessage.Ptr3();

   380     if (desPtr == NULL)

   381         {

   382         return NULL;

   383         }

   384     TInt specLength = aMessage.GetDesLength(FOURTH_ARGUMENT);

   385     // Create spcification buffer

   386     specBuf = HBufC8::NewLC(specLength);

   387     TPtr8 ptr = specBuf->Des();

   388     // Read specification

   389     aMessage.ReadL(FOURTH_ARGUMENT, ptr);

   390     CleanupStack::Pop(); // specBuf

   391     return specBuf;

   392     }

   393 

   394 HBufC8* CEventMediatorSession::ReadEventDataFromClientL(const RMessage2& aMessage)

   395     {

   396     HBufC8* dataBuf = NULL;

   397     TInt desLength = aMessage.Int1();

   398     

   399     if (desLength != 0) // Some events have no data 

   400         {

   401         dataBuf = HBufC8::NewLC(desLength);

   402         TPtr8 ptr = dataBuf->Des();

   403         aMessage.ReadL(THIRD_ARGUMENT, ptr);

   404         CleanupStack::Pop(); // dataBuf

   405         }

   406     return dataBuf;

   407     }

   408 

   409 CListenerContainer* CEventMediatorSession::FindWaitingTaskRequest()

   410     {

   411     CListenerContainer* listener = NULL;

   412     

   413     for (TInt i = 0; i < iListenedEvents.Count(); i++)

   414         {

   415         if (iListenedEvents.At(i)->WaitingForFulfilling())

   416             {

   417             listener = iListenedEvents.At(i);

   418             break;

   419             }

   420         }

   421 

   422     return listener;

   423     }

   424 

   425 CListenerContainer* CEventMediatorSession::FindListener(TEventType aEventType,

   426                                                         TInt aEventSpecId)

   427     {

   428     CListenerContainer* listener = NULL;

   429     

   430     for (TInt i = 0; i < iListenedEvents.Count(); i++)

   431         {

   432         if (iListenedEvents.At(i)->Type() == aEventType)

   433             {

   434             TEventSpec* eventSpec = (TEventSpec*)(iListenedEvents.At(i)->Specification()->Ptr());

   435 

   436             if (eventSpec->iId == aEventSpecId)

   437                 {

   438                 listener = iListenedEvents.At(i);

   439                 break;

   440                 }

   441             }

   442         }

   443 

   444     return listener;

   445     }

   446     

   447 CListenerContainer* CEventMediatorSession::FindListener(TEventType aEventType,

   448                                                         const TDesC8* aEventSpec)

   449     {

   450     CListenerContainer* listener = NULL;

   451     

   452     for (TInt i = 0; i < iListenedEvents.Count(); i++)

   453         {

   454         if (iListenedEvents.At(i)->HandlesEvent(aEventType, aEventSpec))

   455             {

   456             listener = iListenedEvents.At(i);

   457             break;

   458             }

   459         }

   460 

   461     return listener;

   462     }

   463 

   464 void CEventMediatorSession::CompleteListener(TEventType aEventType,

   465                                              const TDesC8* aEventSpec,

   466                                              TInt aStatus)

   467     {

   468     TInt index;

   469     while (FindListenerMsg(aEventType, aEventSpec, index))

   470         {

   471         CompleteListener(index, aStatus);

   472         }

   473     }

   474         

   475 void CEventMediatorSession::CompleteListener(TInt aIndex, TInt aStatus)

   476     {

   477     iListenedEvents.At(aIndex)->Complete(aStatus);

   478     delete iListenedEvents.At(aIndex);

   479     iListenedEvents.Delete(aIndex);

   480     }

   481 

   482 void CEventMediatorSession::CompleteTaskRequests(TInt aStatus)

   483     {

   484     LOG(Log::Printf(_L("CEventMediatorSession::CompleteTaskRequests\n")));

   485     TInt index;

   486     while (FindTaskRequestListenerMsg(index))

   487         {

   488         CompleteListener(index, aStatus);

   489         }

   490     }

   491 

   492 TBool CEventMediatorSession::IsASitSession()

   493     {

   494     return iIsSitSession;

   495     }

   496 

   497 void CEventMediatorSession::NewEventSpecIdL(const RMessage2& aMessage)

   498     {

   499     TInt newEventSpecId = iServer.NewEventSpecId();

   500     TPckg<TInt> newEventSpecIdDes(newEventSpecId);

   501     aMessage.WriteL(FIRST_ARGUMENT, newEventSpecIdDes);

   502     }

   503 

   504 TInt CEventMediatorSession::DeletePrivateFiles()

   505     {

   506     TRAPD(err, DeletePrivateFilesL());

   507     if ( err )

   508         {

   509         LOG(Log::Printf(_L("DeletePrivateFilesL() leave error %d\n"), err));

   510         return err;

   511         }

   512 

   513     return KErrNone;

   514     }

   515 

   516 void CEventMediatorSession::DeletePrivateFilesL()

   517     {

   518     LOG(Log::Printf(_L("DeletePrivateFilesL() called\n")));

   519 

   520     CFileMan* fileMan = CFileMan::NewL(iFs);

   521     CleanupStack::PushL(fileMan);

   522 

   523     TPath privateDir;

   524     User::LeaveIfError(iFs.PrivatePath(privateDir));

   525 

   526     TInt err = fileMan->RmDir(privateDir);

   527     if (err != KErrNone && err != KErrPathNotFound && err != KErrNotFound)

   528         {

   529         User::Leave(err);

   530         }

   531     CleanupStack::PopAndDestroy(); //fileMan

   532     }

   533 

   534 TInt CEventMediatorSession::GetEventLogSize(

   535     const RMessage2& aMessage)

   536     {

   537     if ( iEventLogFileOpen )

   538         {

   539         iEventLogFile.Close();

   540         iEventLogFileOpen = EFalse;

   541         }

   542 

   543     TInt err = iEventLogFile.Open(iFs, iServer.EventLogFileName(), EFileRead | EFileShareAny);

   544     if ( err )

   545         return err;

   546 

   547     TInt size(0);

   548     err = iEventLogFile.Size(size);

   549     if ( err )

   550         {

   551         iEventLogFile.Close();

   552         return err;

   553         }

   554     

   555     TPckg<TInt> sizePckg(size);

   556     err = aMessage.Write(FIRST_ARGUMENT, sizePckg);

   557     if ( err )

   558         {

   559         iEventLogFile.Close();

   560         return err;

   561         }

   562 

   563     iEventLogFileOpen = ETrue;

   564     

   565     return KErrNone;

   566     }

   567 

   568 TInt CEventMediatorSession::GetEventLogHeader(

   569     const RMessage2& aMessage)

   570     {

   571     TInt err(0);

   572     

   573     if ( !iEventLogFileOpen )

   574         {

   575         err = iEventLogFile.Open(iFs, iServer.EventLogFileName(), EFileRead | EFileShareAny);

   576         if ( err )

   577             return err;

   578         iEventLogFileOpen = ETrue;

   579         }

   580     

   581     TInt position = 0;

   582     err = iEventLogFile.Seek(ESeekStart, position);     

   583     if (err != KErrNone)

   584         return err;

   585 

   586     TBuf8<EVENTLOG_FILE_HEADER_LTH> fileHeaderBuf;

   587     err = iEventLogFile.Read(fileHeaderBuf, EVENTLOG_FILE_HEADER_LTH);

   588     if (err != KErrNone)

   589         return err;

   590 

   591     TRAP(err, aMessage.WriteL(FIRST_ARGUMENT, fileHeaderBuf));

   592     if ( err )

   593         return err;

   594 

   595     return KErrNone;

   596     }

   597     

   598 TInt CEventMediatorSession::GetEventLogData(

   599     const RMessage2& aMessage)

   600     {

   601     TInt err(0);

   602 

   603     if ( !iEventLogFileOpen )

   604         {

   605         err = iEventLogFile.Open(iFs, iServer.EventLogFileName(), EFileRead | EFileShareAny);

   606         if ( err )

   607             return err;

   608         iEventLogFileOpen = ETrue;

   609         }

   610     

   611     TInt size(0);

   612     err = iEventLogFile.Size(size);

   613     if ( err )

   614         return err;

   615 

   616     if ( size < EVENTLOG_FILE_HEADER_LTH )

   617         return KErrNotFound;

   618 

   619     HBufC8* eventLogFileBuf = NULL;

   620     TRAP(err, eventLogFileBuf = HBufC8::NewL(size));

   621     if ( err )

   622         {

   623         return err;

   624         }

   625     

   626     TPtr8 eventLogDataPtr(eventLogFileBuf->Des());

   627     TInt position(0);

   628     err = iEventLogFile.Seek(ESeekStart, position);

   629     if ( err )

   630         {

   631         delete eventLogFileBuf;

   632         return err;

   633         }

   634     err = iEventLogFile.Read(eventLogDataPtr); // iLogFileSize);

   635     if ( err )

   636         {

   637         delete eventLogFileBuf;

   638         return err;

   639         }

   640     

   641     TRAP( err, aMessage.WriteL(FIRST_ARGUMENT, eventLogDataPtr));

   642     if ( err )

   643         {

   644         delete eventLogFileBuf;

   645         return err;

   646         }

   647 

   648     delete eventLogFileBuf;

   649     eventLogFileBuf = NULL;

   650     

   651     return KErrNone;

   652     }

   653     

   654 TInt CEventMediatorSession::ClearEventLog()

   655     {

   656     if ( iEventLogFileOpen )

   657         {

   658         iEventLogFile.Close();

   659         iEventLogFileOpen = EFalse;

   660         }

   661 

   662     TInt err = iFs.Delete(iServer.EventLogFileName());

   663 

   664     return err;

   665     }

   666