|
1 // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 /** |
|
17 @file |
|
18 @internalComponent |
|
19 */ |
|
20 |
|
21 #if !defined(__RSSTD_H__) |
|
22 #define __RSSTD_H__ |
|
23 |
|
24 #include <cflog.h> |
|
25 #include <cfshared.h> |
|
26 #include <commschan.h> |
|
27 #include <rscommon.h> |
|
28 #include <e32property.h> |
|
29 |
|
30 class CRootServerSession; |
|
31 class CRootServer; |
|
32 class CBindManager; |
|
33 |
|
34 NONSHARABLE_CLASS(CRSTransientModuleInfo) : public CBase |
|
35 /** Helper class/structure used by the RCFThread. |
|
36 @internalComponent |
|
37 */ |
|
38 { |
|
39 public: |
|
40 ~CRSTransientModuleInfo(); |
|
41 CRSTransientModuleInfo(const CommsFW::RCFChannel::TMsgQueues& aTxQueues, const CommsFW::RCFChannel::TMsgQueues& aRxQueues, |
|
42 RootServer::TRSHeapType aThreadHeapType, TThreadFunction aLibEntry, HBufC8* aIniDataOnRSHeap, |
|
43 TThreadPriority aPriority, TUint32 aControlFlags); |
|
44 |
|
45 static TInt ModuleThreadStartup(TAny* aArg); |
|
46 |
|
47 private: |
|
48 CommsFW::TCFModuleInfo iCFModuleInfo; |
|
49 RootServer::TRSHeapType iThreadHeapType; |
|
50 TThreadFunction iLibEntry; |
|
51 HBufC8* iIniDataOnRSHeap; |
|
52 RHeap* iHeapPtr; |
|
53 TThreadPriority iPriority; |
|
54 TUint32 iControlFlags; |
|
55 }; |
|
56 |
|
57 /** MNotifySuddenDeath is used by CModuleUndertaker to notify registered |
|
58 sessions of Sudden Death. |
|
59 @internalComponent |
|
60 */ |
|
61 class MNotifySuddenDeath |
|
62 { |
|
63 public: |
|
64 virtual void SuddenDeath(TInt aError)=0; |
|
65 }; |
|
66 |
|
67 class CNotifySuddenDeathContainer:public CBase |
|
68 { |
|
69 public: |
|
70 CNotifySuddenDeathContainer(MNotifySuddenDeath* aNotifier); |
|
71 void Dequeue(); |
|
72 void Notify(TInt aReason); |
|
73 TBool Match(MNotifySuddenDeath* aNotifier) const; |
|
74 public: |
|
75 TDblQueLink iLink; // DblQue link element |
|
76 private: |
|
77 MNotifySuddenDeath* iNotifier; // Reference to notifier |
|
78 }; |
|
79 |
|
80 /** The CModuleUnderTaker class monitors a thread for sudden death. If it happens it will call |
|
81 iNotifier->SuddenDeath(). |
|
82 @internalComponent |
|
83 */ |
|
84 NONSHARABLE_CLASS(CModuleUndertaker) : public CActive |
|
85 { |
|
86 public: |
|
87 ~CModuleUndertaker(); |
|
88 static CModuleUndertaker* NewL(MNotifySuddenDeath& iNotifier, RThread& aThread); |
|
89 void Logon(); |
|
90 protected: |
|
91 void DoCancel(); |
|
92 void RunL(); |
|
93 void LogThreadDeath(); |
|
94 private: |
|
95 CModuleUndertaker(MNotifySuddenDeath& iNotifier, RThread& aThread); |
|
96 MNotifySuddenDeath& iNotifier; |
|
97 RThread& iThread; |
|
98 }; |
|
99 |
|
100 /** This is the main module orchestrating thread creation, loading and unloading, The class |
|
101 is asynchronously activated from three active objects: its own derivative, the |
|
102 iModuleTimer * member and the iUndertaker member. The type of action taken on a particular |
|
103 input is decided by its internal state, defined by iState. |
|
104 @internalTechnology |
|
105 */ |
|
106 class CCommsProviderModule : public CActive, public MNotifySuddenDeath |
|
107 { |
|
108 public: |
|
109 IMPORT_C ~CCommsProviderModule(); |
|
110 |
|
111 TInt Load(TRequestStatus& aStatus); // Start module in new thread |
|
112 TInt CancelLoad(); |
|
113 TInt Unload(); // Unload module |
|
114 TInt CancelUnload(RootServer::TRSUnLoadType aType); |
|
115 RThread GetThread() const; |
|
116 inline const CommsFW::TCFModuleNameF& GetName() const; // Return name |
|
117 inline const TFileName& GetDll() const; // Return name of dll |
|
118 inline RootServer::TRSModuleState GetState() const; |
|
119 #ifdef __CFLOG_ACTIVE |
|
120 const TText8* GetStateName() const; |
|
121 #endif |
|
122 #if defined _DEBUG || defined __CFLOG_ACTIVE || defined SYMBIAN_TRACE_ENABLE |
|
123 static const TText8* GetUnloadTypeName(RootServer::TRSUnLoadType aType); |
|
124 #endif |
|
125 inline RHeap* GetHeapPtr() const; |
|
126 inline const CommsFW::RCFChannel& GetSendChannel() const; |
|
127 inline const CommsFW::RCFChannel& GetRecvChannel() const; |
|
128 IMPORT_C virtual void SuddenDeath(TInt aReason); // Called by iUndertaker upon thread death |
|
129 inline TBool IsSticky() const; |
|
130 inline TBool IsServer() const; |
|
131 #ifdef SYMBIAN_C32ROOT_API_V3 |
|
132 inline TUint32 ControlFlags() const; |
|
133 inline void SetControlFlags(TUint32 aFlags); |
|
134 #endif |
|
135 |
|
136 // Functions for handling Sudden Death notification |
|
137 void RegisterSuddenDeathNotifierL(MNotifySuddenDeath* aNotifier); |
|
138 void UnregisterSuddenDeathNotifier(MNotifySuddenDeath* aNotifier); |
|
139 |
|
140 // Failure to respond promptly converts it into half-dead zombie |
|
141 void Inhume(); |
|
142 void CreateThreadL(); |
|
143 public: |
|
144 TDblQueLink iLink; // DblQue link element |
|
145 |
|
146 protected: |
|
147 IMPORT_C CCommsProviderModule( RThread& aThread ); |
|
148 IMPORT_C void ConstructL(CRootServer* aRootServer, const RootServer::TRSStartModuleParams& aParams, HBufC8* aIniData); |
|
149 |
|
150 private: |
|
151 virtual TInt CreateModuleThread(const TDesC& aName, TThreadFunction aOtherThreadFunction, |
|
152 TInt aStackSize, RHeap* aHeap, TAny* aModuleArgs) = 0; |
|
153 private: |
|
154 void NotifyOfDeath( TInt aReason ); |
|
155 TBool UidMatch(const TUid& aUid) const; |
|
156 IMPORT_C void RunL(); |
|
157 void DoCancel() {}; |
|
158 RootServer::TRSModuleState iState; // Current state of module (running, starting, etc) |
|
159 |
|
160 protected: |
|
161 /** Whether RootServer should deny client shutdown requests. |
|
162 */ |
|
163 TBool iIsSticky; |
|
164 |
|
165 /** Whether module is being loaded as a server. |
|
166 */ |
|
167 TBool iIsServer; |
|
168 |
|
169 /** Additional module control flags |
|
170 @see TRSStartModuleParamContainer::TControlFlags |
|
171 */ |
|
172 TUint32 iControlFlags; |
|
173 |
|
174 /** Saved for asynchronous stuff. |
|
175 */ |
|
176 TRequestStatus* iReqStatus; |
|
177 |
|
178 /** Name of module, defined by privileged app. |
|
179 */ |
|
180 CommsFW::TCFModuleNameF iName; |
|
181 |
|
182 /** Filename of DLL containing this module. |
|
183 */ |
|
184 TFileName iDll; |
|
185 |
|
186 /** Handle on the DLL, kept open as long as the module is active. |
|
187 */ |
|
188 RLibrary iLibrary; |
|
189 HBufC8* iIniData; |
|
190 |
|
191 /** Priority of thread. |
|
192 */ |
|
193 TThreadPriority iPriority; |
|
194 |
|
195 /** Stack size of thread. |
|
196 */ |
|
197 TInt iStackSize; |
|
198 |
|
199 /** Min heap size of thread. |
|
200 */ |
|
201 TInt iMinHeapSize; |
|
202 |
|
203 /** Max heap size of thread. |
|
204 */ |
|
205 TInt iMaxHeapSize; |
|
206 |
|
207 /** Ordinal for main threadfunction in dll. |
|
208 */ |
|
209 TInt iThreadFunctionOrdinal; |
|
210 |
|
211 /** EDefaultHeap, EShareHeap(with another loaded module), ENewHeap. |
|
212 */ |
|
213 RootServer::TRSHeapType iHeapType; |
|
214 |
|
215 /** If sharing a heap, then this is the module to share with. |
|
216 */ |
|
217 CommsFW::TCFModuleNameF iShareHeapWith; |
|
218 |
|
219 /** Thread handle of running module context. |
|
220 */ |
|
221 RThread& iThread; |
|
222 |
|
223 /** Active object listening for sudden death. |
|
224 */ |
|
225 CModuleUndertaker* iUndertaker; |
|
226 |
|
227 /** Access to the root server public functions. |
|
228 */ |
|
229 CRootServer* iRootServer; |
|
230 |
|
231 /** Sending comms channel. |
|
232 */ |
|
233 CommsFW::RCFChannel iSend; |
|
234 |
|
235 /** Receiving comms channel. |
|
236 */ |
|
237 CommsFW::RCFChannel iRecv; |
|
238 |
|
239 /** Registered sudden death notifiers. |
|
240 */ |
|
241 TDblQue<CNotifySuddenDeathContainer> iNotifiers; |
|
242 |
|
243 /** Exitreason when module has exited. |
|
244 */ |
|
245 TInt iExitReason; |
|
246 CRSTransientModuleInfo* iThreadStartupInfo; |
|
247 RHeap* iHeapPtr; |
|
248 }; |
|
249 |
|
250 class CRootServer : public CPolicyServer, public MRootServerNotify |
|
251 /** The main class implementing the Rootserver. |
|
252 @internalTechnology |
|
253 */ |
|
254 { |
|
255 public: |
|
256 IMPORT_C ~CRootServer(); |
|
257 |
|
258 // Create new CRootServerSession instance |
|
259 IMPORT_C virtual CSession2* NewSessionL(const TVersion &aVersion, const RMessage2& aMessage) const; |
|
260 |
|
261 // Create comms provider module and put it in list |
|
262 CCommsProviderModule* CreateCpmL(const RootServer::TRSStartModuleParams& aParams, HBufC8* aIniData); |
|
263 |
|
264 RHeap* FindHeap( const CommsFW::TCFModuleNameF& aName ); |
|
265 |
|
266 // Retrieve Server or Provider reference by name |
|
267 CCommsProviderModule* FindCpm(const CommsFW::TCFModuleNameF& aName); |
|
268 |
|
269 // Sudden Death notification. Called by Undertaker's. Call all members of iNotifier. |
|
270 IMPORT_C void SuddenDeath(TInt aReason); |
|
271 |
|
272 // Information, module count |
|
273 IMPORT_C TInt CpmCount(); |
|
274 |
|
275 // Information, Enumeration |
|
276 TInt EnumerateModules(TInt aStartAt, CommsFW::TCFModuleNameF& aName); |
|
277 TInt EnumerateSubModules(const CommsFW::TCFModuleNameF& aModuleName, TInt aStartAt, CommsFW::TCFSubModuleNameF& aName); |
|
278 |
|
279 TInt GetModuleInfo(const CommsFW::TCFModuleNameF& aName, RootServer::TRSModuleInfo& aInfo); |
|
280 |
|
281 IMPORT_C virtual void LazyLoadL(); |
|
282 IMPORT_C virtual void ReceivedMessage(const CommsFW::TCFModuleName& aModule, |
|
283 const CommsFW::TCFMessage& aNewMsg); // Notification of messages from modules |
|
284 CBindManager* BindManager() const; // returns a pointer to the bind manager |
|
285 |
|
286 TInt Shutdown(); |
|
287 |
|
288 |
|
289 TInt Forward(const CommsFW::TCFModuleNameF& aModule, const RMessage2& aMessage); |
|
290 |
|
291 IMPORT_C virtual TBool IsCallerConfigurator(const CRootServerSession* aSession, const RMessage2& aMessage); |
|
292 IMPORT_C virtual void DisconnectSession(const CRootServerSession* aSession); |
|
293 |
|
294 TUid iDeathKey; |
|
295 TUid iLeakKey; |
|
296 TUid iProcessKey; |
|
297 |
|
298 protected: |
|
299 IMPORT_C CRootServer(TInt aPriority, const TPolicy& aPolicy); // Construction |
|
300 IMPORT_C void ConstructL(const TRootServerStartupInfo& aRootServerStartupInfo); // Second level construction |
|
301 |
|
302 protected: |
|
303 TDblQue<CCommsProviderModule> iModules; |
|
304 CBindManager* iBindMgr; |
|
305 RProperty iDeathProperty; |
|
306 TInt iDeathCount; |
|
307 |
|
308 __CFLOG_DECLARATION_MEMBER; |
|
309 |
|
310 static const TUint PolicyRangeCount; |
|
311 static const TInt PolicyRanges[]; |
|
312 static const CPolicyServer::TPolicyElement PolicyElements[]; |
|
313 static const TUint8 PolicyElementsIndex[]; |
|
314 static const CPolicyServer::TPolicy Policy; |
|
315 |
|
316 TCommsProviderModuleCtor iCommsProviderModuleCtorL; |
|
317 |
|
318 #ifdef SYMBIAN_NETWORKING_PERFMETRICS |
|
319 CPerfMetricStore* iPerfStore; |
|
320 #endif |
|
321 }; |
|
322 |
|
323 NONSHARABLE_CLASS(CSessionHandler) : public CActive, public MNotifySuddenDeath |
|
324 /** Active session response object. Used when the session makes an asynchronous request to |
|
325 e.g. Binding Manager. Has access to public members of it's CRootServerSession parent. |
|
326 @internalComponent |
|
327 */ |
|
328 { |
|
329 public: |
|
330 CSessionHandler( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage ); |
|
331 ~CSessionHandler(); |
|
332 CCommsProviderModule* GetModulePtr( const CommsFW::TCFModuleNameF& aName ) const; |
|
333 virtual TInt Start() = 0; |
|
334 |
|
335 virtual TBool CancelHandler( TBool aCompleteRequest, TBool aWaitForCompletionIfUncancelable = EFalse ) = 0; |
|
336 TDblQueLink iLink; // DblQue link element |
|
337 |
|
338 enum TSHType |
|
339 { |
|
340 ESHTypeLoadCPM = 0, |
|
341 ESHTypeUnLoadCPM = 1, |
|
342 ESHTypeBinding = 2, |
|
343 ESHTypeUnBinding = 3 |
|
344 }; |
|
345 virtual TSHType HandlerType() = 0; |
|
346 |
|
347 protected: |
|
348 virtual void CompleteClientRequest( TInt aRequest ); |
|
349 virtual void RunL()=0; |
|
350 virtual void DoCancel()=0; |
|
351 void SuddenDeath(TInt aError); |
|
352 enum TSHState |
|
353 { |
|
354 ESHIdle = 0, |
|
355 ESHStarting = 1, |
|
356 ESHLoading = 2, |
|
357 ESHUnLoading = 3, |
|
358 ESHBinding = 4, |
|
359 ESHUnBinding = 5, |
|
360 ESHKilling = 6, |
|
361 ESHCompleting = 7 |
|
362 }; |
|
363 |
|
364 TBool iRequestCompleted; |
|
365 CRootServerSession* iSession; |
|
366 CBindManager* iBindMgr; |
|
367 TSHState iState; |
|
368 RMessage2 iMessage; |
|
369 }; |
|
370 |
|
371 NONSHARABLE_CLASS(CSessionHandlerLoadCPM) : public CSessionHandler |
|
372 /** Small class to handle a pending operation for loading a module. |
|
373 @internalComponent |
|
374 */ |
|
375 { |
|
376 public: |
|
377 static CSessionHandlerLoadCPM* NewL( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage ); |
|
378 ~CSessionHandlerLoadCPM(); |
|
379 TInt Start(); |
|
380 void SetHandler( const CommsFW::TCFModuleNameF& aModule ); |
|
381 TBool CancelHandler( TBool aCompleteRequest, TBool aWaitForCompletionIfUncancelable = EFalse ); |
|
382 |
|
383 CSessionHandler* MatchPending( const CommsFW::TCFModuleNameF& aModule ); |
|
384 virtual TSHType HandlerType(); |
|
385 |
|
386 private: |
|
387 CSessionHandlerLoadCPM( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage ); |
|
388 void ConstructL(); |
|
389 void CompleteClientRequest( TInt aRequest ); |
|
390 void RunL(); |
|
391 void DoCancel(); |
|
392 void CompleteModalWaiter(); |
|
393 void SuddenDeath(TInt aError); |
|
394 private: |
|
395 CommsFW::TCFModuleNameF iName; |
|
396 CActiveSchedulerWait* iLoadCompletionNotificationWaiter; |
|
397 }; |
|
398 |
|
399 NONSHARABLE_CLASS(CSessionHandlerUnLoadCPM) : public CSessionHandler |
|
400 /** Small class to handle a pending operation for unloading a module. |
|
401 @internalComponent |
|
402 */ |
|
403 { |
|
404 public: |
|
405 static CSessionHandlerUnLoadCPM* NewL( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage ); |
|
406 ~CSessionHandlerUnLoadCPM(); |
|
407 TInt Start(); |
|
408 void SetHandler( const CommsFW::TCFModuleNameF& aModule, RootServer::TRSUnLoadType aType ); |
|
409 TBool CancelHandler( TBool aCompleteRequest, TBool aWaitForCompletionIfUncancelable = EFalse ); |
|
410 CSessionHandler* MatchPending( const CommsFW::TCFModuleNameF& aModule ); |
|
411 virtual TSHType HandlerType(); |
|
412 |
|
413 private: |
|
414 CSessionHandlerUnLoadCPM( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage ); |
|
415 void ConstructL(); |
|
416 void CompleteClientRequest( TInt aRequest ); |
|
417 void RunL(); |
|
418 void DoCancel(); |
|
419 void SuddenDeath(TInt aError); |
|
420 private: |
|
421 CommsFW::TCFModuleNameF iName; |
|
422 RootServer::TRSUnLoadType iType; |
|
423 CActiveSchedulerWait* iLoadCompletionNotificationWaiter; |
|
424 }; |
|
425 |
|
426 NONSHARABLE_CLASS(CSessionHandlerBinding) : public CSessionHandler |
|
427 /** Small class to handle a pending operation for forbinding a module. |
|
428 @internalComponent |
|
429 */ |
|
430 { |
|
431 public: |
|
432 static CSessionHandlerBinding* NewL( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage ); |
|
433 TInt Start(); |
|
434 void SetHandler(const CommsFW::TCFSubModuleAddress& aFrom, |
|
435 const CommsFW::TCFSubModuleAddress& aTo, RootServer::TRSBindType& aBindType, |
|
436 TInt aForwardQLength, TInt aReverseQLength); |
|
437 TBool CancelHandler( TBool aCompleteRequest, TBool aWaitForCompletionIfUncancelable = EFalse ); |
|
438 CSessionHandler* MatchPending( const CommsFW::TCFSubModuleAddress& aFrom, const CommsFW::TCFSubModuleAddress& aTo ); |
|
439 virtual TSHType HandlerType(); |
|
440 |
|
441 private: |
|
442 CSessionHandlerBinding( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage ); |
|
443 void RunL(); |
|
444 void DoCancel(); |
|
445 private: |
|
446 RootServer::TRSBindType iBindType; |
|
447 CommsFW::TCFSubModuleAddress iNameFrom; |
|
448 CommsFW::TCFSubModuleAddress iNameTo; |
|
449 TInt iForwardQLength; |
|
450 TInt iReverseQLength; |
|
451 }; |
|
452 |
|
453 NONSHARABLE_CLASS(CSessionHandlerUnBinding) : public CSessionHandler |
|
454 /** Small class to handle a pending operation for unloading a module |
|
455 @internalComponent */ |
|
456 { |
|
457 public: |
|
458 static CSessionHandlerUnBinding* NewL( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage ); |
|
459 TInt Start(); |
|
460 void SetHandler( const CommsFW::TCFSubModuleAddress& aFrom, const CommsFW::TCFSubModuleAddress& aTo ); |
|
461 TBool CancelHandler( TBool aCompleteRequest, TBool aWaitForCompletionIfUncancelable = EFalse ); |
|
462 CSessionHandler* MatchPending( const CommsFW::TCFSubModuleAddress& aFrom, const CommsFW::TCFSubModuleAddress& aTo ); |
|
463 |
|
464 private: |
|
465 CSessionHandlerUnBinding( CRootServerSession* aSession, CBindManager* aBindMgr, const RMessage2& aMessage ); |
|
466 void RunL(); |
|
467 void DoCancel(); |
|
468 virtual TSHType HandlerType(); |
|
469 |
|
470 private: |
|
471 CommsFW::TCFSubModuleAddress iNameFrom; |
|
472 CommsFW::TCFSubModuleAddress iNameTo; |
|
473 }; |
|
474 |
|
475 class CRootServerSession : public CSession2, public MNotifySuddenDeath |
|
476 /** Required session object as required by the client/server framework. |
|
477 Implements the "Secure IPC" API. |
|
478 @internalComponent |
|
479 */ |
|
480 { |
|
481 public: |
|
482 IMPORT_C CRootServerSession(const CRootServer* aRootServer); |
|
483 IMPORT_C virtual void ServiceL(const RMessage2& aMessage); |
|
484 IMPORT_C void SuddenDeath(TInt aError); // As required by MNotifySuddenDeath |
|
485 |
|
486 void RegisterHandler( CSessionHandler& aHandler ); |
|
487 |
|
488 void CloseSession(); |
|
489 CRootServer* RootServer(); |
|
490 |
|
491 RMessage2& GetMessage(); |
|
492 IMPORT_C virtual ~CRootServerSession(); |
|
493 |
|
494 protected: |
|
495 IMPORT_C void Disconnect(const RMessage2& aMessage); |
|
496 virtual TInt IsCallerConfigurator(const RMessage2& aMessage); |
|
497 |
|
498 TInt LoadCPML(const RMessage2& aMessage); |
|
499 TInt UnloadCPML(const RMessage2& aMessage); |
|
500 |
|
501 TInt GetModuleInfo(const RMessage2& aMessage); |
|
502 TInt EnumerateModules(const RMessage2& aMessage); |
|
503 TInt EnumerateSubModules(const RMessage2& aMessage); |
|
504 TInt CancelLoadCPM(const RMessage2& aMessage); |
|
505 TInt CancelUnloadCPM(const RMessage2& aMessage); |
|
506 |
|
507 TInt Forward(const RMessage2& aMessage); |
|
508 |
|
509 TInt EnumerateBindings(const RMessage2& aMessage); |
|
510 TInt BindL(const RMessage2& aMessage); |
|
511 TInt UnbindL(const RMessage2& aMessage); |
|
512 TInt CancelBind(const RMessage2& aMessage); |
|
513 TInt CancelUnbind(const RMessage2& aMessage); |
|
514 |
|
515 TInt Shutdown(); |
|
516 |
|
517 protected: |
|
518 CRootServer* iRootServer; |
|
519 private: |
|
520 RMessage2 iMessage; |
|
521 TBool iSuddenDeathListener; |
|
522 RMessage2 iSuddenDeathMessage; |
|
523 TBool iRequestActive; |
|
524 TDblQue<CSessionHandler> iActiveHandlers; |
|
525 |
|
526 //Enumeration |
|
527 TInt iEnumerateModulesIndex; |
|
528 TInt iEnumerateSubModulesIndex; |
|
529 TInt iEnumerateBindingsIndex; |
|
530 |
|
531 CommsFW::TCFSubModuleAddress iEnumBindings; |
|
532 CommsFW::TCFSubModuleNameF iEnumSubs; |
|
533 }; |
|
534 |
|
535 #include "rsstd.inl" |
|
536 |
|
537 #endif // __RSSTD_H__ |
|
538 |