26 #include <es_sock.h>

    29 #include "eventmediatordefs.h"

   131 // ----------------------------------------------------------------------------

   132 // CEventMediatorServer::StopEventMediator

   133 // Stops Event Mediator service if there are no sessions left.

   134 // ----------------------------------------------------------------------------

   135 //

   136 void CEventMediatorServer::StopEventMediator(void)

   137     {

   138     if (iSessionCount == 0) 

   139         {

   140         LOG(Log::Printf(_L("CEventMediatorServer::StopEventMediator - session count 0, stopping scheduler and thus the server\n")));

   141         CActiveScheduler::Stop();   

   142         }   

   143     }

   562 

   563 void CEventMediatorServer::SetShuttingDown(TBool aShuttingDown)

   564     {

   565     iShuttingDown = aShuttingDown;

   566     }

   567 

   568 // ============================= CEventMediatorSession =============================     

   569 

   570 CEventMediatorSession* CEventMediatorSession::NewL(CEventMediatorServer* aServer, const RMessage2& aMessage)

   571     {

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

   573     CEventMediatorSession* self;

   574     self = new (ELeave) CEventMediatorSession(aServer);

   575     CleanupStack::PushL(self);

   576 

   577     // Marks the session as a "SIT session"

   578     // if the client is the SIT thread

   579     self->iIsSitSession = aServer->IsClientTheSitL(aMessage);

   580 

   581     aServer->iSessionCount++;

   582 

   583     if ( !self->IsASitSession() )

   584         {

   585         User::LeaveIfError(self->iFs.Connect()); // For EventLog

   586         self->iEventLogFileOpen = EFalse;

   587         }

   588 

   589     CleanupStack::Pop(); // self

   590 

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

   592     return self;

   593     }

   594 

   595 CEventMediatorSession::CEventMediatorSession(CEventMediatorServer* aServer)

   596     : iListenedEvents(2), iServer(aServer)

   597     {

   598     }

   599 

   600 CEventMediatorSession::~CEventMediatorSession(void)

   601     {

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

   603     CancelAll();

   604     if (iServer)

   605         {        

   606         TInt normalSessionCount = iServer->NormalSessionCount();

   607 

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

   609         // decrement the normal session count by one

   610         if (!IsASitSession())

   611             {

   612             normalSessionCount--;

   613             

   614             if (iEventLogFileOpen)

   615                 {

   616                 iEventLogFile.Close();

   617                 iEventLogFileOpen = EFalse;

   618                 }

   619             iFs.Close(); // For EventLog

   620             

   621             }

   622 

   623         if (normalSessionCount == 0)

   624             {

   625             // If "normal" (non-sit) sessions are no longer present,

   626             // we complete the task arrival observation request, thus

   627             // causing the SIT to terminate and close its connection

   628             // to this server. This should be the last connection whose

   629             // closing will cause this server to terminate.

   630             // NOTE. KErrCancel cannot be used here as the Event Mediator 

   631             // does not report it to the caller

   632             LOG(Log::Printf(_L("CEventMediatorSession::~CEventMediatorSession - normal session count = 0\n")));

   633             iServer->CompleteListener(ETaskArrivedEvent, NULL, KErrAbort);

   634 

   635             // Set the server state to "shutting down". This will

   636             // cause the server to discard any new connect requests

   637             // with KErrServerTerminated.

   638             iServer->SetShuttingDown(ETrue);

   639             }

   640 

   641         if (iServer->iSessionCount)

   642             {

   643             iServer->iSessionCount--;

   644             }

   645 

   646         iServer->StopEventMediator();

   647         }

   648     }

   649 

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

   651     {

   652     TInt status = 0;

   653 

   654     switch (aMessage.Function())

   655         {

   656         case KEventMediatorListen:

   657             ListenToEventL(aMessage);

   658             break;

   659 

   660         case KEventMediatorListenWithSpec:

   661             ListenToEventWithSpecL(aMessage);

   662             break;

   663 

   664         case KEventMediatorCancel:

   665             CancelListening(aMessage);        

   666             aMessage.Complete(KErrNone);

   667             break;

   668 

   669         case KEventMediatorCancelWithSpec:

   670             CancelListeningWithSpecL(aMessage);        

   671             aMessage.Complete(KErrNone);

   672             break;

   673 

   674         case KEventMediatorCancelAll:

   675             CancelAll();        

   676             aMessage.Complete(KErrNone);

   677             break;

   678 

   679         case KEventMediatorReportEvent:

   680             ReportEventL(aMessage);

   681             aMessage.Complete(KErrNone);

   682             break;

   683 

   684         case KEventMediatorReportEventWithSpec:

   685             ReportEventWithSpecL(aMessage);

   686             aMessage.Complete(KErrNone);

   687             break;

   688 

   689         case KEventMediatorFetchData:

   690             status = FetchDataL(aMessage);

   691             aMessage.Complete(status);

   692             break;

   693 

   694         case KEventMediatorReportLogEvent:

   695             ReportLogEventL(aMessage);

   696             aMessage.Complete(KErrNone);

   697             break;

   698 

   699         case KEventMediatorNewEventSpecId:

   700             NewEventSpecIdL(aMessage);

   701             aMessage.Complete(KErrNone);

   702             break;

   703         case KEventMediatorDeletePrivateFiles:

   704             status = DeletePrivateFiles();

   705             aMessage.Complete(status);

   706             break;

   707 

   708         case KEventMediatorGetEventLogSize:

   709             status = GetEventLogSize(aMessage);

   710             aMessage.Complete(status);

   711             break;

   712 

   713         case KEventMediatorGetEventLogHeader:

   714             status = GetEventLogHeader(aMessage);

   715             aMessage.Complete(status);

   716             break;

   717         case KEventMediatorGetEventLogData:

   718             status = GetEventLogData(aMessage);

   719             aMessage.Complete(status);

   720             break;

   721         case KEventMediatorClearEventLog:

   722             status = ClearEventLog();

   723             aMessage.Complete(status);

   724             break;

   725         default:

   726             aMessage.Complete(KErrGeneral);

   727             break;

   728         }

   729     }

   730 

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

   732     {

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

   734     CleanupStack::PushL(listener);

   735 

   736     iListenedEvents.AppendL(listener);

   737     CleanupStack::Pop(); // listener

   738 

   739     listener->AnalyzeRequestL();

   740 

   741     return KErrNone;

   742     }

   743 

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

   745     {

   746     HBufC8* specBuf = NULL;

   747 

   748     // Read specification

   749     specBuf = ReadSpecificationFromClientL(aMessage);

   750     CleanupStack::PushL(specBuf);

   751 

   752     // Ownership of specBuf is given to listener

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

   754     CleanupStack::Pop(); // specBuf

   755     CleanupStack::PushL(listener);

   756         

   757     iListenedEvents.AppendL(listener);

   758     CleanupStack::Pop(); // listener

   759 

   760     listener->AnalyzeRequestL();

   761 

   762     return KErrNone;

   763     }

   764 

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

   766     {

   767     TInt index;

   768     

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

   770         {

   771         CompleteListener(index, KErrCancel);

   772         }

   773     }

   774 

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

   776     {

   777     HBufC8* specBuf = NULL;

   778     TInt index;

   779     

   780     // Read specification

   781     specBuf = ReadSpecificationFromClientL(aMessage);

   782     CleanupStack::PushL(specBuf);

   783 

   784     // Cancel listeners

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

   786         {

   787         CompleteListener(index, KErrCancel);

   788         }

   789     CleanupStack::PopAndDestroy(); // specBuf

   790     }

   791 

   792 void CEventMediatorSession::CancelAll()

   793     {

   794     TInt nEvents = iListenedEvents.Count();

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

   796         {

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

   798         delete iListenedEvents.At(i);

   799         iListenedEvents.At(i) = NULL;

   800         }

   801     iListenedEvents.Reset();

   802     }

   803 

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

   805     {

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

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

   808     // Read data

   809     HBufC8* dataBuf = ReadEventDataFromClientL(aMessage);

   810     CleanupStack::PushL(dataBuf);

   811     // Report event to server

   812     iServer->ReportEventL(eventType, NULL, dataBuf);

   813     CleanupStack::Pop();

   814     }

   815 

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

   817     {

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

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

   820     // Read data

   821     HBufC8* dataBuf = ReadEventDataFromClientL(aMessage);

   822     CleanupStack::PushL(dataBuf);

   823     // Read specification

   824     HBufC8* specBuf = ReadSpecificationFromClientL(aMessage);

   825     CleanupStack::PushL(specBuf);

   826     // Report event to server

   827     iServer->ReportEventL(eventType, specBuf, dataBuf);

   828     CleanupStack::PopAndDestroy(); // specBuf

   829     CleanupStack::Pop(); // dataBuf 

   830     }

   831 

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

   833     {

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

   835     // Read event

   836     TLogEvent event;

   837     TPckg<TLogEvent> eventPckg(event);

   838     aMessage.ReadL(FIRST_ARGUMENT, eventPckg);

   839 

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

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

   842     TInt position = eventPckg.Length();

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

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

   845     TPtr8 dataPtr = dataBuf->Des();

   846 

   847     // Copy event to buffer

   848     dataPtr.Append(eventPckg);

   849     // Read lengths to buffer

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

   851     aMessage.ReadL(SECOND_ARGUMENT, tmpPtr);

   852     // Read descriptors to the buffer

   853     position= dataPtr.Length();

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

   855     aMessage.ReadL(THIRD_ARGUMENT, tmpPtr);

   856 

   857     // Report event to server

   858     iServer->ReportEventL(ELogEvent, NULL, dataBuf);

   859     CleanupStack::Pop();

   860     }

   861 

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

   863     {

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

   865     return iServer->CopyEventDataL(aMessage);

   866     }

   867 

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

   869                                         const TDesC8* aData, TInt aStatus)

   870     {

   871     TInt index;

   872     TInt listenerCount = 0;

   873     TInt dataLth = 0;

   874     // Some events don't not have data

   875     if (aData)

   876         {

   877         dataLth = aData->Length();

   878         }

   879     TPckg<TInt> lengthpckg(dataLth);

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

   881 

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

   883         {

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

   885 

   886         if (aStatus == KErrNone)

   887             {

   888             // Write info about data

   889             listener.WriteL(SECOND_ARGUMENT, lengthpckg);

   890             listener.WriteL(THIRD_ARGUMENT, ptrpckg);

   891 

   892             // Complete listener

   893             listener.Complete(KErrNone);

   894             }

   895         else

   896             {

   897             listener.Complete(aStatus);

   898             }

   899         

   900         delete iListenedEvents.At(index);

   901         iListenedEvents.Delete(index);

   902         listenerCount++;    

   903         }

   904 

   905     return listenerCount;

   906     }

   907 

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

   909     {

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

   911         {

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

   913             {

   914             index=i;

   915             return ETrue;

   916             }

   917         }

   918     return EFalse;

   919     }

   920 

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

   922     {

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

   924         {

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

   926             {

   927             index = i;

   928             return ETrue;

   929             }

   930         }

   931     return EFalse;

   932     }

   933 

   934 TBool CEventMediatorSession::FindTaskRequestListenerMsg(TInt& index)

   935     {

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

   937         {

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

   939             {

   940             index = i;

   941             return ETrue;

   942             }

   943         }

   944     return EFalse;

   945     }

   946     

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

   948     {

   949     HBufC8* specBuf;

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

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

   952     if (desPtr == NULL)

   953         {

   954         return NULL;

   955         }

   956     TInt specLength = aMessage.GetDesLength(FOURTH_ARGUMENT);

   957     // Create spcification buffer

   958     specBuf = HBufC8::NewLC(specLength);

   959     TPtr8 ptr = specBuf->Des();

   960     // Read specification

   961     aMessage.ReadL(FOURTH_ARGUMENT, ptr);

   962     CleanupStack::Pop(); // specBuf

   963     return specBuf;

   964     }

   965 

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

   967     {

   968     HBufC8* dataBuf = NULL;

   969     TInt desLength = aMessage.Int1();

   970     

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

   972         {

   973         dataBuf = HBufC8::NewLC(desLength);

   974         TPtr8 ptr = dataBuf->Des();

   975         aMessage.ReadL(THIRD_ARGUMENT, ptr);

   976         CleanupStack::Pop(); // dataBuf

   977         }

   978     return dataBuf;

   979     }

   980 

   981 CListenerContainer* CEventMediatorSession::FindWaitingTaskRequest()

   982     {

   983     CListenerContainer* listener = NULL;

   984     

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

   986         {

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

   988             {

   989             listener = iListenedEvents.At(i);

   990             break;

   991             }

   992         }

   993 

   994     return listener;

   995     }

   996 

   997 CListenerContainer* CEventMediatorSession::FindListener(TEventType aEventType,

   998                                                         TInt aEventSpecId)

   999     {

  1000     CListenerContainer* listener = NULL;

  1001     

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

  1003         {

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

  1005             {

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

  1007 

  1008             if (eventSpec->iId == aEventSpecId)

  1009                 {

  1010                 listener = iListenedEvents.At(i);

  1011                 break;

  1012                 }

  1013             }

  1014         }

  1015 

  1016     return listener;

  1017     }

  1018     

  1019 CListenerContainer* CEventMediatorSession::FindListener(TEventType aEventType,

  1020                                                         const TDesC8* aEventSpec)

  1021     {

  1022     CListenerContainer* listener = NULL;

  1023     

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

  1025         {

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

  1027             {

  1028             listener = iListenedEvents.At(i);

  1029             break;

  1030             }

  1031         }

  1032 

  1033     return listener;

  1034     }

  1035 

  1036 void CEventMediatorSession::CompleteListener(TEventType aEventType,

  1037                                              const TDesC8* aEventSpec,

  1038                                              TInt aStatus)

  1039     {

  1040     TInt index;

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

  1042         {

  1043         CompleteListener(index, aStatus);

  1044         }

  1045     }

  1046         

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

  1048     {

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

  1050     delete iListenedEvents.At(aIndex);

  1051     iListenedEvents.Delete(aIndex);

  1052     }

  1053 

  1054 void CEventMediatorSession::CompleteTaskRequests(TInt aStatus)

  1055     {

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

  1057     TInt index;

  1058     while (FindTaskRequestListenerMsg(index))

  1059         {

  1060         CompleteListener(index, aStatus);

  1061         }

  1062     }

  1063 

  1064 TBool CEventMediatorSession::IsASitSession()

  1065     {

  1066     return iIsSitSession;

  1067     }

  1068 

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

  1070     {

  1071     TInt newEventSpecId = iServer->NewEventSpecId();

  1072     TPckg<TInt> newEventSpecIdDes(newEventSpecId);

  1073     aMessage.WriteL(FIRST_ARGUMENT, newEventSpecIdDes);

  1074     }

  1075 

  1076 TInt CEventMediatorSession::DeletePrivateFiles()

  1077     {

  1078     TRAPD(err, DeletePrivateFilesL());

  1079     if ( err )

  1080         {

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

  1082         return err;

  1083         }

  1084 

  1085     return KErrNone;

  1086     }

  1087 

  1088 void CEventMediatorSession::DeletePrivateFilesL()

  1089     {

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

  1091 

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

  1093     CleanupStack::PushL(fileMan);

  1094 

  1095     TPath privateDir;

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

  1097 

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

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

  1100         {

  1101         User::Leave(err);

  1102         }

  1103     CleanupStack::PopAndDestroy(); //fileMan

  1104     }

  1105 

  1106 TInt CEventMediatorSession::GetEventLogSize(

  1107     const RMessage2& aMessage)

  1108     {

  1109     if ( iEventLogFileOpen )

  1110         {

  1111         iEventLogFile.Close();

  1112         iEventLogFileOpen = EFalse;

  1113         }

  1114 

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

  1116     if ( err )

  1117         return err;

  1118 

  1119     TInt size(0);

  1120     err = iEventLogFile.Size(size);

  1121     if ( err )

  1122         {

  1123         iEventLogFile.Close();

  1124         return err;

  1125         }

  1126     

  1127     TPckg<TInt> sizePckg(size);

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

  1129     if ( err )

  1130         {

  1131         iEventLogFile.Close();

  1132         return err;

  1133         }

  1134 

  1135     iEventLogFileOpen = ETrue;

  1136     

  1137     return KErrNone;

  1138     }

  1139 

  1140 TInt CEventMediatorSession::GetEventLogHeader(

  1141     const RMessage2& aMessage)

  1142     {

  1143     TInt err(0);

  1144     

  1145     if ( !iEventLogFileOpen )

  1146         {

  1147         err = iEventLogFile.Open(iFs, iServer->EventLogFileName(), EFileRead | EFileShareAny);

  1148         if ( err )

  1149             return err;

  1150         iEventLogFileOpen = ETrue;

  1151         }

  1152     

  1153     TInt position = 0;

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

  1155     if (err != KErrNone)

  1156         return err;

  1157 

  1158     TBuf8<EVENTLOG_FILE_HEADER_LTH> fileHeaderBuf;

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

  1160     if (err != KErrNone)

  1161         return err;

  1162 

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

  1164     if ( err )

  1165         return err;

  1166 

  1167     return KErrNone;

  1168     }

  1169     

  1170 TInt CEventMediatorSession::GetEventLogData(

  1171     const RMessage2& aMessage)

  1172     {

  1173     TInt err(0);

  1174 

  1175     if ( !iEventLogFileOpen )

  1176         {

  1177         err = iEventLogFile.Open(iFs, iServer->EventLogFileName(), EFileRead | EFileShareAny);

  1178         if ( err )

  1179             return err;

  1180         iEventLogFileOpen = ETrue;

  1181         }

  1182     

  1183     TInt size(0);

  1184     err = iEventLogFile.Size(size);

  1185     if ( err )

  1186         return err;

  1187 

  1188     if ( size < EVENTLOG_FILE_HEADER_LTH )

  1189         return KErrNotFound;

  1190 

  1191     HBufC8* eventLogFileBuf = NULL;

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

  1193     if ( err )

  1194         {

  1195         return err;

  1196         }

  1197     

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

  1199     TInt position(0);

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

  1201     if ( err )

  1202         {

  1203         delete eventLogFileBuf;

  1204         return err;

  1205         }

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

  1207     if ( err )

  1208         {

  1209         delete eventLogFileBuf;

  1210         return err;

  1211         }

  1212     

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

  1214     if ( err )

  1215         {

  1216         delete eventLogFileBuf;

  1217         return err;

  1218         }

  1219 

  1220     delete eventLogFileBuf;

  1221     eventLogFileBuf = NULL;

  1222     

  1223     return KErrNone;

  1224     }

  1225     

  1226 TInt CEventMediatorSession::ClearEventLog()

  1227     {

  1228     if ( iEventLogFileOpen )

  1229         {

  1230         iEventLogFile.Close();

  1231         iEventLogFileOpen = EFalse;

  1232         }

  1233 

  1234     TInt err = iFs.Delete(iServer->EventLogFileName());

  1235 

  1236     return err;

  1237     }

  1238 

  1239