1 // Copyright (c) 2010 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 // Flow / Binder |
|
15 // (data plane) |
|
16 // |
|
17 // |
|
18 // This is a 3-plane comms layer implementation example, which has been customised to be a test layer which gobbles and releases ESOCK MBUFs. |
|
19 // The MBuf gobbling functionality can be disabled by undefining the macro SYMBIAN_COMMSFW_MBUF_GOBBLER which is specified in mbufgobblerproviders.mmp. |
|
20 // When SYMBIAN_COMMSFW_MBUF_GOBBLER is undefined, the source code specified by mbufgobblerproviders.mmp becomes a pass through layer i.e. it passes the data |
|
21 // through to the layer above or below without altering it. This makes it useful as a starting point for implementing your own layers / providers; |
|
22 // useful documentation on how to customise your own passthrough layer can be found in ..\docs\MbufGobblerLayer.doc |
|
23 // |
|
24 /** |
|
25 @file |
|
26 @internalComponent |
|
27 */ |
|
28 |
|
29 #include <comms-infras/ss_activities.h> |
|
30 #include <comms-infras/ss_logext.h> |
|
31 #include <es_mbman.h> |
|
32 #include <mbufgobblerpubsub.h> |
|
33 #include "mbufgobblerflow.h" |
|
34 #include "mbufgobblerlog.h" |
|
35 |
|
36 // for panics |
|
37 _LIT(KPanicCategory, "MbufGobblerLayer"); |
|
38 enum |
|
39 { |
|
40 KPanic_DestroyReceivedBeforeUnbind = 2001 |
|
41 }; |
|
42 |
|
43 _LIT8(KNodeName, "CMbufGobblerFlow"); |
|
44 |
|
45 |
|
46 /////////////////////////// |
|
47 // class CMbufGobblerFlow // |
|
48 /////////////////////////// |
|
49 |
|
50 CMbufGobblerFlow* CMbufGobblerFlow::NewL(ESock::CSubConnectionFlowFactoryBase& aFactory, const Messages::TNodeId& aSubConnId, ESock::CProtocolIntfBase* aProtocolIntf) |
|
51 { |
|
52 CMbufGobblerFlow* inst = new(ELeave) CMbufGobblerFlow(aFactory, aSubConnId, aProtocolIntf); |
|
53 CleanupStack::PushL(inst); |
|
54 inst->ConstructL(); |
|
55 CleanupStack::Pop(inst); |
|
56 return inst; |
|
57 } |
|
58 |
|
59 CMbufGobblerFlow::CMbufGobblerFlow(ESock::CSubConnectionFlowFactoryBase& aFactory, const Messages::TNodeId& aSubConnId, ESock::CProtocolIntfBase* aProtocolIntf) |
|
60 /** |
|
61 * Constructor. |
|
62 * |
|
63 * @param aFactory Reference to the factory which created this object. |
|
64 * @param aTheLogger The logging object, ownership is passed to this object |
|
65 */ |
|
66 :ESock::CSubConnectionFlowBase(aFactory, aSubConnId, aProtocolIntf) |
|
67 { |
|
68 MBUFGOBBLER_LOG_NODE_CREATE(KMbufGobblerFlowSubTag, CMbufGobblerFlow, KNodeName, this->NodeId().Ptr()); |
|
69 } |
|
70 |
|
71 void CMbufGobblerFlow::ConstructL() |
|
72 { |
|
73 #ifdef SYMBIAN_COMMSFW_MBUF_GOBBLER |
|
74 iMBufGobbler = CMBufGobbler::NewL(); |
|
75 #endif |
|
76 } |
|
77 |
|
78 CMbufGobblerFlow::~CMbufGobblerFlow() |
|
79 { |
|
80 MBUFGOBBLER_LOG_NODE_DESTROY(KMbufGobblerFlowSubTag, CMbufGobblerFlow, KNodeName, this->NodeId().Ptr()); |
|
81 iBinders.ResetAndDestroy(); |
|
82 #ifdef SYMBIAN_COMMSFW_MBUF_GOBBLER |
|
83 delete iMBufGobbler; |
|
84 #endif |
|
85 } |
|
86 |
|
87 |
|
88 |
|
89 /////////////////////////////////////////// |
|
90 // Methods from CSubConnectionFlowBase: // |
|
91 /////////////////////////////////////////// |
|
92 |
|
93 ESock::MFlowBinderControl* CMbufGobblerFlow::DoGetBinderControlL() |
|
94 { |
|
95 return this; |
|
96 } |
|
97 |
|
98 |
|
99 // Messages::ANode |
|
100 void CMbufGobblerFlow::ReceivedL( |
|
101 const Messages::TRuntimeCtxId& aSender, |
|
102 const Messages::TNodeId& aRecipient, |
|
103 Messages::TSignatureBase& aMessage |
|
104 ) |
|
105 /** |
|
106 Method called on incoming SCPR messages |
|
107 |
|
108 @param aCFMessage message base |
|
109 */ |
|
110 { |
|
111 |
|
112 LOGMESSAGE(KMbufGobblerFlowSubTag, KNodeName, this, aSender, aRecipient, aMessage); |
|
113 //LOG_NODE_INFO(KMbufGobblerFlowSubTag, KNodeName, *this); does not compile as flow inheritance is different to other nodes |
|
114 CSubConnectionFlowBase::ReceivedL(aSender, aRecipient, aMessage); |
|
115 |
|
116 // Dispatch the message locally |
|
117 if (ESock::TCFDataClient::ERealmId == aMessage.MessageId().Realm()) |
|
118 { |
|
119 switch (aMessage.MessageId().MessageId()) |
|
120 { |
|
121 |
|
122 case ESock::TCFDataClient::TStart::EId : |
|
123 { |
|
124 iSubConnectionProvider.RNodeInterface::PostMessage( |
|
125 Id(), |
|
126 ESock::TCFDataClient::TStarted().CRef() |
|
127 ); |
|
128 } |
|
129 break; |
|
130 |
|
131 case ESock::TCFDataClient::TStop::EId : |
|
132 { |
|
133 TInt i; |
|
134 for (i=iBinders.Count()-1;i>=0;--i) |
|
135 { |
|
136 CMbufGobblerBinder* binder = iBinders[i]; |
|
137 binder->UnbindFromLowerFlow(); |
|
138 delete binder; |
|
139 iBinders.Remove(i); |
|
140 } |
|
141 iSubConnectionProvider.PostMessage(Id(), ESock::TCFDataClient::TStopped(KErrNone).CRef()); |
|
142 } |
|
143 break; |
|
144 |
|
145 case ESock::TCFDataClient::TProvisionConfig::EId : |
|
146 { |
|
147 ESock::TCFDataClient::TProvisionConfig& aMess = Messages::message_cast<ESock::TCFDataClient::TProvisionConfig>(aMessage); |
|
148 iAccessPointConfig.Close(); |
|
149 iAccessPointConfig.Open(aMess.iConfig); |
|
150 } |
|
151 break; |
|
152 |
|
153 case ESock::TCFDataClient::TBindTo::EId : |
|
154 { |
|
155 ESock::TCFDataClient::TBindTo& bindToReq = Messages::message_cast<ESock::TCFDataClient::TBindTo>(aMessage); |
|
156 if (bindToReq.iNodeId == Messages::TNodeId::NullId()) |
|
157 { |
|
158 User::Leave(KErrNotSupported); |
|
159 } |
|
160 |
|
161 const Messages::TNodeId& commsId = bindToReq.iNodeId; |
|
162 CSubConnectionFlowBase* lowerFlow = Messages::mnode_cast<CSubConnectionFlowBase>(&commsId.Node()); |
|
163 |
|
164 MFlowBinderControl* lowerBinderControl = lowerFlow->GetBinderControlL(); |
|
165 ASSERT(lowerBinderControl); |
|
166 |
|
167 TInt i; |
|
168 for (i=0;i<iBinders.Count();++i) |
|
169 { |
|
170 // binder for each protocol will request binder for same protocol from lower binder controller using this fn. |
|
171 iBinders[i]->BindToLowerFlowL(*lowerBinderControl); |
|
172 } |
|
173 ASSERT(i); // there should be some binders! |
|
174 |
|
175 Messages::RClientInterface::OpenPostMessageClose( |
|
176 Id(), |
|
177 aSender, |
|
178 ESock::TCFDataClient::TBindToComplete().CRef() |
|
179 ); |
|
180 } |
|
181 break; |
|
182 |
|
183 default: |
|
184 ASSERT(EFalse); |
|
185 } |
|
186 } |
|
187 else if (Messages::TEChild::ERealmId == aMessage.MessageId().Realm()) |
|
188 { |
|
189 switch (aMessage.MessageId().MessageId()) |
|
190 { |
|
191 case Messages::TEChild::TDestroy::EId : |
|
192 { |
|
193 TInt i; |
|
194 for (i=0;i<iBinders.Count();++i) |
|
195 { |
|
196 // ensure all binders unbound |
|
197 if (iBinders[i]->InUse()) |
|
198 { |
|
199 //__CFLOG_0(KLogTag1, KLogTag2,_L("something is sending TDestroy to CMbufGobblerFlow before unbinding.")); |
|
200 User::Panic(KPanicCategory,KPanic_DestroyReceivedBeforeUnbind); |
|
201 } |
|
202 |
|
203 // EXAMPLE CODE: cancel requests here if necessary... |
|
204 //iBinders[i]->Cancel(); |
|
205 |
|
206 } |
|
207 if (i==iBinders.Count()) // all unbound |
|
208 { |
|
209 DeleteThisFlow(); |
|
210 } |
|
211 } |
|
212 break; |
|
213 |
|
214 default: |
|
215 ASSERT(EFalse); |
|
216 } |
|
217 } |
|
218 // realm != TCFMessage::ERealmId |
|
219 else |
|
220 { |
|
221 ASSERT(EFalse); |
|
222 } |
|
223 } |
|
224 |
|
225 |
|
226 /////////////////////////////////////// |
|
227 // Methods from MFlowBinderControl: // |
|
228 /////////////////////////////////////// |
|
229 |
|
230 ESock::MLowerControl* CMbufGobblerFlow::GetControlL(const TDesC8& aProtocol) |
|
231 /** |
|
232 Create and return an MLowerControl instance of the specified binder type. |
|
233 |
|
234 Called from upper layer during binding procedure. |
|
235 |
|
236 @param aProtocol Protocol type of the binder |
|
237 @return MLowerControl instance of the protocol type |
|
238 */ |
|
239 { |
|
240 ESock::MLowerControl* lowerControl = FindOrCreateBinderL(aProtocol); |
|
241 ASSERT(lowerControl); |
|
242 return lowerControl; |
|
243 } |
|
244 |
|
245 |
|
246 ESock::MLowerDataSender* CMbufGobblerFlow::BindL(const TDesC8& aProtocol, ESock::MUpperDataReceiver* aReceiver, ESock::MUpperControl* aControl) |
|
247 { |
|
248 CMbufGobblerBinder* binder = FindOrCreateBinderL(aProtocol); |
|
249 ASSERT(binder); |
|
250 binder->BindToUpperL( *aReceiver, *aControl ); |
|
251 |
|
252 iSubConnectionProvider.RNodeInterface::PostMessage( |
|
253 Id(), |
|
254 ESock::TCFControlProvider::TActive().CRef() |
|
255 ); |
|
256 |
|
257 return binder; |
|
258 } |
|
259 |
|
260 void CMbufGobblerFlow::Unbind( ESock::MUpperDataReceiver* aReceiver, ESock::MUpperControl* aControl) |
|
261 { |
|
262 ASSERT(aReceiver); |
|
263 ASSERT(aControl); |
|
264 TInt i; |
|
265 TInt numberUnbound=0; |
|
266 for (i=0;i<iBinders.Count();++i) |
|
267 { |
|
268 numberUnbound += (iBinders[i]->UnbindFromUpper(*aReceiver,*aControl) ? 1 : 0); |
|
269 } |
|
270 ASSERT(i); // there should be some binders! |
|
271 ASSERT(numberUnbound<=1); // only 1 unbind should have happened |
|
272 |
|
273 iSubConnectionProvider.RNodeInterface::PostMessage( |
|
274 Id(), |
|
275 ESock::TCFControlProvider::TIdle().CRef() |
|
276 ); |
|
277 } |
|
278 |
|
279 ESock::CSubConnectionFlowBase* CMbufGobblerFlow::Flow() |
|
280 { |
|
281 return this; |
|
282 } |
|
283 |
|
284 |
|
285 ///////////////// |
|
286 // Own methods // |
|
287 ///////////////// |
|
288 |
|
289 CMbufGobblerBinder* CMbufGobblerFlow::FindOrCreateBinderL(const TDesC8& aProtocol) |
|
290 { |
|
291 |
|
292 // EXAMPLE CODE, should you want your: perhaps your protocol to work with IPv4 |
|
293 //if (aProtocol.Compare(KIp4ProtocolName)) |
|
294 // { // only work with IPv4 |
|
295 // User::Leave(KErrNotSupported); |
|
296 // } |
|
297 |
|
298 for (TInt i=0;i<iBinders.Count();++i) |
|
299 { |
|
300 if(iBinders[i]->ProtocolName() == aProtocol) |
|
301 { |
|
302 return iBinders[i]; |
|
303 } |
|
304 } |
|
305 // not found.. create it. |
|
306 CMbufGobblerBinder* newBinder = CMbufGobblerBinder::NewL(aProtocol); |
|
307 CleanupStack::PushL(newBinder); |
|
308 iBinders.AppendL(newBinder); |
|
309 CleanupStack::Pop(newBinder); |
|
310 return newBinder; |
|
311 } |
|
312 |
|
313 |
|
314 |
|
315 |
|
316 |
|
317 //################################################################################################## |
|
318 |
|
319 ///////////////////////////// |
|
320 // class CMbufGobblerBinder // |
|
321 ///////////////////////////// |
|
322 |
|
323 |
|
324 //////////////////// |
|
325 // My constructor // |
|
326 //////////////////// |
|
327 |
|
328 CMbufGobblerBinder::CMbufGobblerBinder(const TDesC8& aProtocolName): |
|
329 iLowerControl(NULL), |
|
330 iLowerDataSender(NULL), |
|
331 iUpperControl(NULL), |
|
332 iUpperDataReceiver(NULL), |
|
333 iProtocolName(aProtocolName) |
|
334 {} |
|
335 |
|
336 CMbufGobblerBinder* CMbufGobblerBinder::NewL(const TDesC8& aProtocolName) |
|
337 { |
|
338 CMbufGobblerBinder* inst = new(ELeave) CMbufGobblerBinder(aProtocolName); |
|
339 CleanupStack::PushL(inst); |
|
340 inst->ConstructL(); |
|
341 CleanupStack::Pop(inst); |
|
342 return inst; |
|
343 } |
|
344 |
|
345 void CMbufGobblerBinder::ConstructL() |
|
346 { |
|
347 MBUFGOBBLER_TEST_DATA_INIT |
|
348 #if 0 |
|
349 // EXAMPLE CODE - set up everything you need to in this method. |
|
350 // Perhaps you have some kind of test control interface using pub/sub.. if so you'd do something like below.. |
|
351 // Diff this file with networking/netperf/delaymeterproto/src/delaymeterflow.cpp for a full working implementation of such a control interface... |
|
352 CActiveScheduler::Add(this); |
|
353 DefinePubSubKeysL(); |
|
354 // watch for incoming commands |
|
355 User::LeaveIfError(iProperty.Attach(TUid::Uid(KDelayMeterControlLevel), KCommandToDelayMeter)); |
|
356 iProperty.Subscribe(iStatus); |
|
357 SetActive(); |
|
358 #endif |
|
359 } |
|
360 |
|
361 /*virtual*/ |
|
362 CMbufGobblerBinder::~CMbufGobblerBinder() |
|
363 { |
|
364 } |
|
365 |
|
366 |
|
367 |
|
368 //////////////////////////////////////// |
|
369 // Methods from ESock::MLowerControl: // |
|
370 //////////////////////////////////////// |
|
371 |
|
372 TInt CMbufGobblerBinder::GetName(TDes& aName) |
|
373 { |
|
374 TBuf16<10> tmp; |
|
375 tmp.Copy(ProtocolName()); |
|
376 aName.Format(_L("mbufgobbler[%S][0x%08x]"), &tmp, this); |
|
377 |
|
378 return KErrNone; |
|
379 } |
|
380 |
|
381 TInt CMbufGobblerBinder::BlockFlow(TBlockOption aOption) |
|
382 { |
|
383 if (iLowerControl==NULL) |
|
384 { |
|
385 return KErrNotReady; |
|
386 } |
|
387 return iLowerControl->BlockFlow(aOption) ; |
|
388 } |
|
389 |
|
390 TInt CMbufGobblerBinder::GetConfig(TBinderConfig& aConfig) |
|
391 { |
|
392 if (iLowerControl==NULL) |
|
393 { |
|
394 return KErrNotReady; |
|
395 } |
|
396 return iLowerControl->GetConfig(aConfig) ; |
|
397 } |
|
398 |
|
399 TInt CMbufGobblerBinder::Control(TUint aLevel, TUint aName, TDes8& aOption) |
|
400 { |
|
401 // Pass it on.. |
|
402 if (iLowerControl==NULL) |
|
403 { |
|
404 return KErrNotReady; |
|
405 } |
|
406 return iLowerControl->Control(aLevel,aName,aOption); |
|
407 } |
|
408 |
|
409 |
|
410 /////////////////////////////////////////// |
|
411 // Methods from ESock::MLowerDataSender: // |
|
412 /////////////////////////////////////////// |
|
413 |
|
414 ESock::MLowerDataSender::TSendResult CMbufGobblerBinder::Send(RMBufChain& aData) |
|
415 { |
|
416 // EXAMPLE NOTE: |
|
417 // This is where a protocol implementation will do its work on outgoing data. |
|
418 |
|
419 MBUFGOBBLER_TEST_POINT(KBinderSend,KErrNone) |
|
420 |
|
421 if (iLowerControl==NULL) |
|
422 { |
|
423 return ESendBlocked; // returning this obliges us to send an unblock later.. |
|
424 // so perhaps it'd be better to just swallow the packet? |
|
425 } |
|
426 return iLowerDataSender->Send(aData); |
|
427 } |
|
428 |
|
429 //////////////////////////////////////// |
|
430 // Methods from ESock::MUpperControl: // |
|
431 //////////////////////////////////////// |
|
432 |
|
433 /*virtual*/ |
|
434 void CMbufGobblerBinder::StartSending() |
|
435 { |
|
436 if (iUpperControl) |
|
437 { |
|
438 iUpperControl->StartSending(); |
|
439 } |
|
440 else |
|
441 { |
|
442 ASSERT(1); // to allow setting a breakpoint |
|
443 //__CFLOG_0(KLogTag1, KLogTag2,_L("CMbufGobblerBinder::StartSending: upper control not yet known!")); |
|
444 } |
|
445 } |
|
446 |
|
447 /*virtual*/ |
|
448 void CMbufGobblerBinder::Error(TInt anError) |
|
449 { |
|
450 if (iUpperControl) |
|
451 { |
|
452 iUpperControl->Error(anError); |
|
453 } |
|
454 else |
|
455 { |
|
456 ASSERT(1); // to set a breakpoint |
|
457 //__CFLOG_0(KLogTag1, KLogTag2,_L("CMbufGobblerBinder::Error: upper control not yet known!")); |
|
458 } |
|
459 } |
|
460 |
|
461 |
|
462 ///////////////////////////////////////////// |
|
463 // Methods from ESock::MUpperDataReceiver: // |
|
464 ///////////////////////////////////////////// |
|
465 |
|
466 /*virtual*/ |
|
467 void CMbufGobblerBinder::Process(RMBufChain& aData) |
|
468 { |
|
469 // EXAMPLE NOTE: |
|
470 // This is where a protocol implementation will do its work on incoming data. |
|
471 |
|
472 MBUFGOBBLER_TEST_POINT(KBinderReceive,KErrNone) |
|
473 |
|
474 if (iUpperDataReceiver == NULL) |
|
475 { |
|
476 // Why is the guy below still sending data to me when I'm not bound above? |
|
477 // Try to ignore it |
|
478 ASSERT(1); // so a breakpoint can be set if necessary |
|
479 //__CFLOG_0(KLogTag1, KLogTag2,_L("CMbufGobblerBinder::Process: incoming traffic discarded as upper data receiver not (or no longer) set")); |
|
480 return; |
|
481 } |
|
482 iUpperDataReceiver->Process(aData); |
|
483 } |
|
484 |
|
485 |
|
486 ////////////////////////// |
|
487 // and my own methods.. // |
|
488 ////////////////////////// |
|
489 |
|
490 // called by layer above calling my flow's BindL |
|
491 void CMbufGobblerBinder::BindToUpperL(MUpperDataReceiver& aUpperDataReceiver, MUpperControl& aUpperControl) |
|
492 { |
|
493 if(iUpperDataReceiver || iUpperControl) {User::Leave(KErrInUse);} |
|
494 iUpperDataReceiver=&aUpperDataReceiver; |
|
495 iUpperControl=&aUpperControl; |
|
496 MBUFGOBBLER_TEST_POINT(KBind,KErrNone) |
|
497 } |
|
498 |
|
499 // called by layer above calling my flow's Unbind. Returns ETrue if unbind happened here, EFalse otherwise |
|
500 TBool CMbufGobblerBinder::UnbindFromUpper(MUpperDataReceiver& aUpperDataReceiver, MUpperControl& aUpperControl) |
|
501 { |
|
502 if(&aUpperDataReceiver == iUpperDataReceiver && &aUpperControl == iUpperControl) |
|
503 { |
|
504 iUpperDataReceiver=0; |
|
505 iUpperControl=0; |
|
506 return ETrue; |
|
507 } |
|
508 return EFalse; |
|
509 } |
|
510 |
|
511 // called by my flow receiving a BinderRequest |
|
512 void CMbufGobblerBinder::BindToLowerFlowL(ESock::MFlowBinderControl& aLowerBinderControl) |
|
513 { |
|
514 // __CFLOG_0(KLogTag1, KLogTag2, _L("CMbufGobblerBinder::BindToLowerFlowL")); |
|
515 if(iLowerControl || iLowerDataSender) |
|
516 { |
|
517 User::Leave(KErrInUse); |
|
518 } |
|
519 |
|
520 iBinderControl = &aLowerBinderControl; |
|
521 iLowerControl = aLowerBinderControl.GetControlL(ProtocolName()); |
|
522 iLowerDataSender = aLowerBinderControl.BindL(ProtocolName(), this, this); |
|
523 } |
|
524 |
|
525 void CMbufGobblerBinder::UnbindFromLowerFlow() |
|
526 { |
|
527 if (!iBinderControl) |
|
528 return; |
|
529 |
|
530 iBinderControl->Unbind(this, this); |
|
531 iBinderControl = NULL; |
|
532 |
|
533 iLowerControl = NULL; |
|
534 iLowerDataSender = NULL; |
|
535 } |
|
536 |
|
537 const TDesC8& CMbufGobblerBinder::ProtocolName() const |
|
538 { |
|
539 return iProtocolName; |
|
540 } |
|
541 |
|
542 #ifdef SYMBIAN_COMMSFW_MBUF_GOBBLER |
|
543 |
|
544 CMBufGobbler::CMBufGobbler(): |
|
545 CActive(CActive::EPriorityStandard) |
|
546 { |
|
547 } |
|
548 |
|
549 CMBufGobbler* CMBufGobbler::NewL() |
|
550 { |
|
551 CMBufGobbler* inst = new(ELeave) CMBufGobbler; |
|
552 CleanupStack::PushL(inst); |
|
553 inst->ConstructL(); |
|
554 CleanupStack::Pop(inst); |
|
555 return inst; |
|
556 } |
|
557 |
|
558 void CMBufGobbler::ConstructL() |
|
559 { |
|
560 iChain.AllocL(128); |
|
561 |
|
562 CActiveScheduler::Add(this); |
|
563 |
|
564 TInt result = RProperty::Define(TUid::Uid(EMBufGobbler), EAdjustNumberOfMBufsRemainingInPool, RProperty::EInt); |
|
565 // Only want 1 instance of a MBufGobbler Layer, so just leave if KErrAlreadyExists returned |
|
566 User::LeaveIfError(result); |
|
567 |
|
568 // watch for incoming commands |
|
569 User::LeaveIfError(iProperty.Attach(TUid::Uid(EMBufGobbler), EAdjustNumberOfMBufsRemainingInPool)); |
|
570 |
|
571 iProperty.Subscribe(iStatus); |
|
572 SetActive(); |
|
573 } |
|
574 |
|
575 /*virtual*/ CMBufGobbler::~CMBufGobbler() |
|
576 { |
|
577 if (IsActive()) |
|
578 { |
|
579 Cancel(); |
|
580 } |
|
581 |
|
582 iChain.Free(); |
|
583 |
|
584 TInt result = RProperty::Delete(TUid::Uid(EMBufGobbler), EAdjustNumberOfMBufsRemainingInPool); |
|
585 if (result != KErrNone) |
|
586 { |
|
587 RDebug::Print(_L("CMBufGobbler::~CMBufGobbler() %d"), result); |
|
588 } |
|
589 } |
|
590 |
|
591 /*virtual*/ void CMBufGobbler::DoCancel() |
|
592 { |
|
593 iProperty.Cancel(); |
|
594 } |
|
595 |
|
596 /*virtual*/ void CMBufGobbler::RunL() |
|
597 { |
|
598 // Resubscribe to ensure that next pub/sub notification is picked up |
|
599 iProperty.Subscribe(iStatus); |
|
600 SetActive(); |
|
601 |
|
602 TInt request=EGobbleAllMBufs; |
|
603 TInt pubSubRet = iProperty.Get(request); |
|
604 if (pubSubRet == KErrNone) |
|
605 { |
|
606 switch(request) |
|
607 { |
|
608 case EGobbleAllMBufs: |
|
609 { |
|
610 RMBufAllocator allocator; |
|
611 RMBufChain chain; |
|
612 TInt size = allocator.NextMBufSize(0); |
|
613 while (size != KErrNotFound) |
|
614 { |
|
615 TInt ret = KErrNone; |
|
616 while (ret == KErrNone) |
|
617 { |
|
618 ret = chain.Alloc(size); |
|
619 if (ret==KErrNone ) |
|
620 { |
|
621 iChain.Append(chain); |
|
622 } |
|
623 } |
|
624 size = allocator.NextMBufSize(size); |
|
625 } |
|
626 TInt length = iChain.Length(); |
|
627 RDebug::Print(_L("Out of MBuf Memory... Total MBuf memory in use %d"), length); |
|
628 TInt numBufs = iChain.NumBufs(); |
|
629 RDebug::Print(_L("Out of MBuf Memory... Total MBufs in use %d"), numBufs); |
|
630 break; |
|
631 } |
|
632 case EReleaseAllMBufs: |
|
633 { |
|
634 if(!iChain.IsEmpty()) |
|
635 { |
|
636 iChain.Free(); |
|
637 ASSERT(!iChain.Length()); |
|
638 } |
|
639 break; |
|
640 } |
|
641 case EReleaseASingleMBuf: |
|
642 { |
|
643 TInt length = iChain.Length(); |
|
644 if (length != 0) |
|
645 { |
|
646 TInt trimOffset = length - iChain.Last()->Size(); |
|
647 iChain.TrimEnd(trimOffset); |
|
648 } |
|
649 |
|
650 length = iChain.Length(); |
|
651 RDebug::Print(_L("MBufMemory De-Allocated... Total MBuf memory in use %d"), length); |
|
652 break; |
|
653 } |
|
654 default: |
|
655 { |
|
656 RDebug::Print(_L("CMBufGobbler::RunL(), invalid request %d"), request); |
|
657 break; |
|
658 } |
|
659 } |
|
660 } |
|
661 else |
|
662 { |
|
663 RDebug::Print(_L("Attempt to process MBufGobbler publish/subscribe failed with value for %d"), pubSubRet); |
|
664 } |
|
665 } |
|
666 |
|
667 #endif |
|