|
1 /** @file |
|
2 * Copyright (c) 2005-2006 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: Message handler engine |
|
15 * |
|
16 */ |
|
17 |
|
18 // INCLUDE FILES |
|
19 |
|
20 #include <s32mem.h> |
|
21 |
|
22 #include "upnpmessagehandlersession.h" |
|
23 #define KLogFile _L("UpnpMessageHandler.txt") |
|
24 #include "upnpcustomlog.h" |
|
25 |
|
26 // ================= MEMBER FUNCTIONS ======================= |
|
27 |
|
28 // ----------------------------------------------------------------------------- |
|
29 // CUpnpMessageHandlerSession::CUpnpMessageHandlerSession |
|
30 // C++ default constructor can NOT contain any code, that |
|
31 // might leave. |
|
32 // ----------------------------------------------------------------------------- |
|
33 // |
|
34 CUpnpMessageHandlerSession::CUpnpMessageHandlerSession( |
|
35 CUpnpMessageHandler& aMessageHandler, CUpnpMessageHandlerEngine& aEngine ) : |
|
36 CSession2(), iMessageHandler(aMessageHandler), iEngine(aEngine), |
|
37 iMoreNewDevices(ETrue), iOldId(KErrNotFound), iAddedDevices( 1) |
|
38 { |
|
39 LOG_FUNC_NAME; |
|
40 } |
|
41 |
|
42 // ----------------------------------------------------------------------------- |
|
43 // CUpnpMessageHandlerSession::~CUpnpMessageHandlerSession |
|
44 // Destructor. |
|
45 // ----------------------------------------------------------------------------- |
|
46 // |
|
47 CUpnpMessageHandlerSession::~CUpnpMessageHandlerSession() |
|
48 { |
|
49 delete[] iAwaitingUpdateDevices; |
|
50 delete[] iAwaitingUpdateServices; |
|
51 |
|
52 iMessageHandler.RemoveObserver( this ); |
|
53 iAddedDevices.Reset(); |
|
54 } |
|
55 |
|
56 // ----------------------------------------------------------------------------- |
|
57 // CUpnpMessageHandlerSession::ServiceL |
|
58 // Handle client requests. |
|
59 // ----------------------------------------------------------------------------- |
|
60 // |
|
61 void CUpnpMessageHandlerSession::ServiceL( const RMessage2& aMessage ) |
|
62 { |
|
63 |
|
64 if ( aMessage.Function() != EStartSsdp && aMessage.Function() |
|
65 != ECheckError && !iMessageHandler.IsSsdpStarted() ) |
|
66 { |
|
67 aMessage.Complete( KErrServerTerminated ); |
|
68 return; |
|
69 } |
|
70 |
|
71 switch ( aMessage.Function() ) |
|
72 { |
|
73 case EStartSsdp: |
|
74 { |
|
75 aMessage.Complete( EStartSsdpComplete ); |
|
76 User::LeaveIfError( EventStartSsdpL() ); |
|
77 iMessageHandler.SetSsdpStarted( ETrue ); |
|
78 break; |
|
79 } |
|
80 case EAddLocalDevice: |
|
81 { |
|
82 EventAddLocalDeviceL( aMessage ); |
|
83 aMessage.Complete( EAddLocalDeviceComplete ); |
|
84 break; |
|
85 } |
|
86 case ERemoveLocalDevice: |
|
87 { |
|
88 EventRemoveLocalDeviceL( aMessage, EFalse ); |
|
89 aMessage.Complete( ERemoveLocalDeviceComplete ); |
|
90 break; |
|
91 } |
|
92 case ERemoveSilentLocalDevice: |
|
93 { |
|
94 LOGS("CUpnpMessageHandlerSession: case ERemoveSilentLocalDevice"); |
|
95 EventRemoveLocalDeviceL( aMessage, ETrue ); |
|
96 aMessage.Complete( ERemoveSilentLocalDeviceComplete ); |
|
97 LOGS("CUpnpMessageHandlerSession: case ERemoveSilentLocalDevice passed"); |
|
98 break; |
|
99 } |
|
100 case EAddControlPointClient: |
|
101 { |
|
102 EventAddLocalControlPoint( aMessage ); |
|
103 aMessage.Complete( EAddControlPointClientComplete ); |
|
104 break; |
|
105 } |
|
106 case ERemoveControlPointClient: |
|
107 { |
|
108 EventRemoveLocalControlPoint( aMessage ); |
|
109 aMessage.Complete( ERemoveControlPointClientComplete ); |
|
110 break; |
|
111 } |
|
112 case EStopFilteringDevice: |
|
113 { |
|
114 EventStopFilteringDeviceL( aMessage ); |
|
115 aMessage.Complete( EStopFilteringDeviceComplete ); |
|
116 break; |
|
117 } |
|
118 case EGetDeviceListSize: |
|
119 { |
|
120 CopyMessage( (RMessage2&) aMessage ); |
|
121 EventGetDeviceListSizeL( aMessage ); |
|
122 break; |
|
123 } |
|
124 case EGetDeviceList: |
|
125 { |
|
126 EventGetDeviceListL( aMessage ); |
|
127 aMessage.Complete( EGetDeviceListComplete ); |
|
128 break; |
|
129 } |
|
130 case ESsdpSearch: |
|
131 { |
|
132 EventSsdpSearchL( aMessage ); |
|
133 aMessage.Complete( ESsdpSearchComplete ); |
|
134 break; |
|
135 } |
|
136 case EActiveIap: |
|
137 { |
|
138 EventActiveIapL( aMessage ); |
|
139 aMessage.Complete( EActiveIapComplete ); |
|
140 break; |
|
141 } |
|
142 case ECheckError: |
|
143 { |
|
144 EventCheckErrorL( aMessage ); |
|
145 aMessage.Complete( ECheckErrorComplete ); |
|
146 break; |
|
147 } |
|
148 case ECancelRequest: |
|
149 CompletePendingRequest(); |
|
150 aMessage.Complete( KErrNone ); |
|
151 break; |
|
152 |
|
153 #ifdef RD_UPNP_REMOTE_ACCESS |
|
154 case EAddFilterAddrByIP: |
|
155 { |
|
156 EventAddFilterAddrByIpL( aMessage ); |
|
157 aMessage.Complete( KErrNone ); |
|
158 break; |
|
159 } |
|
160 case EAddFilterAddrByHostname: |
|
161 { |
|
162 EventAddFilterAddrByHostnameL( aMessage ); |
|
163 break; |
|
164 } |
|
165 case ERemoveFilterAddrByIP: |
|
166 { |
|
167 EventRemoveFilterAddrByIpL( aMessage ); |
|
168 aMessage.Complete( KErrNone ); |
|
169 break; |
|
170 } |
|
171 case ERemoveFilterAddrByHostname: |
|
172 { |
|
173 EventRemoveFilterAddrByHostnameL( aMessage ); |
|
174 break; |
|
175 } |
|
176 case ERemoveAllIPsAddresses: |
|
177 { |
|
178 EventRemoveAllIPsAddressesL( aMessage ); |
|
179 aMessage.Complete( KErrNone ); |
|
180 break; |
|
181 } |
|
182 case EIsIPAddressAllowed: |
|
183 { |
|
184 aMessage.Complete( EventIsIPAddressAllowedL( aMessage ) ); |
|
185 break; |
|
186 } |
|
187 case ESubscribeIPListChanges: |
|
188 { |
|
189 EventSubscriveIPListChanges( const_cast<RMessage2&>( aMessage ) ); |
|
190 break; |
|
191 } |
|
192 case EGetIPFilterList: |
|
193 { |
|
194 EventGetIPFilterListL( aMessage ); |
|
195 break; |
|
196 } |
|
197 case ECancelIPLIstSubsctiption: |
|
198 { |
|
199 EventCancelIPListSubscription( aMessage ); |
|
200 aMessage.Complete( KErrNone ); |
|
201 break; |
|
202 } |
|
203 #endif |
|
204 default: |
|
205 PanicClient( aMessage, EMessageHandlerBadRequest ); |
|
206 break; |
|
207 } |
|
208 |
|
209 } |
|
210 |
|
211 // ----------------------------------------------------------------------------- |
|
212 // CUpnpMessageHandlerSession::PanicClient |
|
213 // Panic client. |
|
214 // ----------------------------------------------------------------------------- |
|
215 // |
|
216 void CUpnpMessageHandlerSession::PanicClient( const RMessage2 &aMessage, |
|
217 TInt aPanic ) const |
|
218 { |
|
219 LOG_FUNC_NAME; |
|
220 iMessageHandler.PanicClient( aMessage, aPanic ); |
|
221 } |
|
222 |
|
223 // ----------------------------------------------------------------------------- |
|
224 // CUpnpMessageHandlerSession::NewL |
|
225 // Two-phased constructor. |
|
226 // ----------------------------------------------------------------------------- |
|
227 // |
|
228 CUpnpMessageHandlerSession* CUpnpMessageHandlerSession::NewL( |
|
229 CUpnpMessageHandler& aServer, CUpnpMessageHandlerEngine& aEngine ) |
|
230 { |
|
231 CUpnpMessageHandlerSession* self = CUpnpMessageHandlerSession::NewLC( |
|
232 aServer, aEngine ); |
|
233 CleanupStack::Pop( self ); |
|
234 return self; |
|
235 } |
|
236 |
|
237 // ----------------------------------------------------------------------------- |
|
238 // CUpnpMessageHandlerSession::NewLC |
|
239 // Two-phased constructor. |
|
240 // ----------------------------------------------------------------------------- |
|
241 // |
|
242 CUpnpMessageHandlerSession* CUpnpMessageHandlerSession::NewLC( |
|
243 CUpnpMessageHandler& aServer, CUpnpMessageHandlerEngine& aEngine ) |
|
244 { |
|
245 CUpnpMessageHandlerSession* self = new (ELeave) CUpnpMessageHandlerSession( |
|
246 aServer, aEngine ); |
|
247 CleanupStack::PushL( self ); |
|
248 self->ConstructL(); |
|
249 return self; |
|
250 } |
|
251 |
|
252 // ----------------------------------------------------------------------------- |
|
253 // CUpnpMessageHandlerSession::ConstructL |
|
254 // Symbian 2nd phase constructor can leave. |
|
255 // ----------------------------------------------------------------------------- |
|
256 // |
|
257 void CUpnpMessageHandlerSession::ConstructL() |
|
258 { |
|
259 //Add session to MessageHandlers count and to the ObserverList |
|
260 iMessageHandler.AddObserverL( this ); |
|
261 } |
|
262 |
|
263 // ----------------------------------------------------------------------------- |
|
264 // CUpnpMessageHandlerSession::EventAddLocalDeviceL |
|
265 // Add local device. |
|
266 // ----------------------------------------------------------------------------- |
|
267 // |
|
268 void CUpnpMessageHandlerSession::EventAddLocalDeviceL( |
|
269 const RMessage2 &aMessage ) |
|
270 { |
|
271 LOG_FUNC_NAME; |
|
272 |
|
273 TUpnpAddLocalDevice device; |
|
274 TPtr8 ptr( reinterpret_cast<TUint8*>(&device), sizeof(device ), |
|
275 sizeof(device )); |
|
276 |
|
277 LOGS("\t MessageHandler, added a local device"); |
|
278 |
|
279 aMessage.ReadL( 0, ptr ); |
|
280 |
|
281 HBufC8* buffer = HBufC8::NewLC( device.iBufferLength ); |
|
282 buffer->Des().SetLength( 0 ); |
|
283 |
|
284 TPtr8 bufPtr = buffer->Des(); |
|
285 |
|
286 aMessage.ReadL( 1, bufPtr ); |
|
287 |
|
288 LOGS("Session::Add"); |
|
289 |
|
290 iDeviceListSizeRequested = EFalse; |
|
291 |
|
292 TPtrC8 uuid = buffer->Left( device.iUuidLength ); |
|
293 |
|
294 iAddedDevices.AppendL( uuid ); |
|
295 |
|
296 iEngine.AddLocalDeviceL( device, *buffer ); |
|
297 |
|
298 CleanupStack::PopAndDestroy( buffer ); |
|
299 } |
|
300 |
|
301 // ----------------------------------------------------------------------------- |
|
302 // CUpnpMessageHandlerSession::EventAddLocalControlPointL |
|
303 // ----------------------------------------------------------------------------- |
|
304 // |
|
305 void CUpnpMessageHandlerSession::EventAddLocalControlPoint( const RMessage2 &/*aMessage*/) |
|
306 { |
|
307 iEngine.AddLocalControlPoint(); |
|
308 } |
|
309 |
|
310 // ----------------------------------------------------------------------------- |
|
311 // CUpnpMessageHandlerEngine::RemoveLocalControlPointL |
|
312 // ----------------------------------------------------------------------------- |
|
313 // |
|
314 void CUpnpMessageHandlerSession::EventRemoveLocalControlPoint( |
|
315 const RMessage2 &/*aMessage*/) |
|
316 { |
|
317 iEngine.RemoveLocalControlPoint(); |
|
318 } |
|
319 |
|
320 // ----------------------------------------------------------------------------- |
|
321 // CUpnpMessageHandlerEngine::EventStopFilteringDeviceL |
|
322 // ----------------------------------------------------------------------------- |
|
323 // |
|
324 void CUpnpMessageHandlerSession::EventStopFilteringDeviceL( |
|
325 const RMessage2& aMessage ) |
|
326 { |
|
327 TInt lenght = aMessage.GetDesLength( 0 ); |
|
328 HBufC8* uuids = HBufC8::NewLC( lenght ); |
|
329 TPtr8 uuidsPtr = uuids->Des(); |
|
330 aMessage.ReadL( 0, uuidsPtr ); |
|
331 TLex8 uuidLex(*uuids); |
|
332 uuidLex.Mark(); |
|
333 for ( ;; ) |
|
334 { |
|
335 if ( uuidLex.Peek() == ';' ) |
|
336 { |
|
337 TPtrC8 uidPtr = uuidLex.MarkedToken(); |
|
338 iEngine.StopFilteringDeviceL( uidPtr ); |
|
339 uuidLex.Inc(); |
|
340 uuidLex.Mark(); |
|
341 } |
|
342 else if ( uuidLex.Eos() ) |
|
343 { |
|
344 TPtrC8 uidPtr = uuidLex.MarkedToken(); |
|
345 if ( uidPtr.Length() ) |
|
346 { |
|
347 iEngine.StopFilteringDeviceL( uidPtr ); |
|
348 } |
|
349 break; |
|
350 } |
|
351 else |
|
352 { |
|
353 uuidLex.Inc(); |
|
354 } |
|
355 } |
|
356 CleanupStack::PopAndDestroy( uuids ); |
|
357 } |
|
358 |
|
359 // ----------------------------------------------------------------------------- |
|
360 // CUpnpMessageHandlerSession::EventGetDeviceListSizeL |
|
361 // Get device list. |
|
362 // ----------------------------------------------------------------------------- |
|
363 // |
|
364 void CUpnpMessageHandlerSession::EventGetDeviceListSizeL( |
|
365 const RMessage2& aMessage ) |
|
366 { |
|
367 LOGS( "CUpnpMessageHandlerSession::EventGetDeviceListSizeL"); |
|
368 |
|
369 TPtr8 ptr( reinterpret_cast<TUint8*>(&iSize), sizeof(iSize ), |
|
370 sizeof(iSize )); |
|
371 |
|
372 iDeviceListSizeMessage.ReadL( 0, ptr ); |
|
373 |
|
374 if ( iSize.iUpdateId >= iOldId && iOldId != KErrNotFound ) |
|
375 { |
|
376 LOGS( "CUpnpMessageHandlerSession::GetDeviceListSize OLD=NEW"); |
|
377 iDeviceListSizeRequested = ETrue; |
|
378 } |
|
379 |
|
380 if ( iSize.iUpdateId == 0 ) |
|
381 { |
|
382 iMoreNewDevices = ETrue; |
|
383 } |
|
384 |
|
385 if ( !iDeviceListSizeRequested ) |
|
386 { |
|
387 LOGS( "CUpnpMessageHandlerSession::GetDeviceListSize OLD>NEW"); |
|
388 iDeviceListSizeRequested = ETrue; |
|
389 |
|
390 LOGS( "CUpnpMessageHandlerSession::New Devices Found"); |
|
391 |
|
392 if ( iMoreNewDevices && iDeviceListSizeMessage.Function() |
|
393 == EGetDeviceListSize ) |
|
394 { |
|
395 |
|
396 delete[] iAwaitingUpdateDevices; |
|
397 iAwaitingUpdateDevices = NULL; |
|
398 |
|
399 delete[] iAwaitingUpdateServices; |
|
400 iAwaitingUpdateServices = NULL; |
|
401 |
|
402 iEngine.DeviceLibrary()->GetUpdate( iSize.iUpdateId, iAwaitingUpdateDevices, |
|
403 iAwaitingUpdateServices, iSize.iDeviceCount, |
|
404 iSize.iServiceCount ); |
|
405 if ( iSize.iDeviceCount > 0 ) |
|
406 { |
|
407 iOldId = iSize.iUpdateId; |
|
408 |
|
409 iDeviceListSizeMessage.WriteL( 0, ptr ); |
|
410 aMessage.Complete( EGetDeviceListSizeComplete ); |
|
411 iDeviceListSizeRequested = EFalse; |
|
412 } |
|
413 } |
|
414 |
|
415 iMoreNewDevices = EFalse; |
|
416 } |
|
417 |
|
418 } |
|
419 |
|
420 // ----------------------------------------------------------------------------- |
|
421 // CUpnpMessageHandlerSession::EventGetDeviceListL |
|
422 // Get device list. |
|
423 // ----------------------------------------------------------------------------- |
|
424 // |
|
425 void CUpnpMessageHandlerSession::EventGetDeviceListL( |
|
426 const RMessage2 &aMessage ) |
|
427 { |
|
428 LOGS( "CUpnpMessageHandlerSession::EventGetDeviceListL"); |
|
429 if ( !iDeviceListSizeRequested ) |
|
430 { |
|
431 TPtr8 devPtr( reinterpret_cast<TUint8*>(iAwaitingUpdateDevices), |
|
432 sizeof(TUpnpDevice)*iSize.iDeviceCount, sizeof(TUpnpDevice) |
|
433 *iSize.iDeviceCount); |
|
434 TPtr8 servPtr( reinterpret_cast<TUint8*>(iAwaitingUpdateServices), |
|
435 sizeof(TUpnpService)*iSize.iServiceCount, sizeof(TUpnpService) |
|
436 *iSize.iServiceCount); |
|
437 |
|
438 aMessage.WriteL( 0, devPtr ); |
|
439 aMessage.WriteL( 1, servPtr ); |
|
440 |
|
441 delete[] iAwaitingUpdateDevices; |
|
442 iAwaitingUpdateDevices = NULL; |
|
443 |
|
444 delete[] iAwaitingUpdateServices; |
|
445 iAwaitingUpdateServices = NULL; |
|
446 } |
|
447 } |
|
448 |
|
449 // ----------------------------------------------------------------------------- |
|
450 // CUpnpMessageHandlerSession::EventSsdpSearchL |
|
451 // SSDP search. |
|
452 // ----------------------------------------------------------------------------- |
|
453 // |
|
454 void CUpnpMessageHandlerSession::EventSsdpSearchL( const RMessage2 &aMessage ) |
|
455 { |
|
456 LOGS( "CUpnpMessageHandlerSession::EventSsdpSearchL"); |
|
457 |
|
458 // getting search string from client. |
|
459 HBufC8* search= NULL; |
|
460 HBufC8* mx= NULL; |
|
461 |
|
462 TInt len = aMessage.GetDesLength( 0 ); |
|
463 TInt len2 = aMessage.GetDesLength( 1 ); |
|
464 |
|
465 if ( len > 0 ) |
|
466 { |
|
467 search = HBufC8::NewLC( len ); |
|
468 search->Des().Zero(); |
|
469 |
|
470 mx = HBufC8::NewLC( len2 ); |
|
471 mx->Des().Zero(); |
|
472 |
|
473 TPtr8 searchPtr = search->Des(); |
|
474 |
|
475 aMessage.ReadL( 0, searchPtr ); |
|
476 if ( len2 ) |
|
477 { |
|
478 TPtr8 mxPtr = mx->Des(); |
|
479 aMessage.ReadL( 1, mxPtr ); |
|
480 } |
|
481 |
|
482 iDeviceListSizeRequested = EFalse; |
|
483 |
|
484 iEngine.SsdpSearchL( *search, *mx ); |
|
485 |
|
486 CleanupStack::PopAndDestroy( mx ); |
|
487 CleanupStack::PopAndDestroy( search ); |
|
488 } |
|
489 else |
|
490 { |
|
491 LOGS( "CUpnpMessageHandlerSession::EventSsdpSearchL"); |
|
492 } |
|
493 } |
|
494 |
|
495 // ----------------------------------------------------------------------------- |
|
496 // CUpnpMessageHandlerSession::EventActiveIapL |
|
497 // Activate IAP. |
|
498 // ----------------------------------------------------------------------------- |
|
499 // |
|
500 void CUpnpMessageHandlerSession::EventActiveIapL( const RMessage2 &aMessage ) const |
|
501 { |
|
502 LOGS( "CUpnpMessageHandlerSession::EventActiveIapL"); |
|
503 TInt activeIap = iEngine.ActiveIap(); |
|
504 TPtr8 ptr( reinterpret_cast<TUint8*>(&activeIap), sizeof(TInt), |
|
505 sizeof(TInt)); |
|
506 |
|
507 aMessage.WriteL( 0, ptr ); |
|
508 } |
|
509 |
|
510 // ----------------------------------------------------------------------------- |
|
511 // CUpnpMessageHandlerSession::EventRemoveLocalDeviceL |
|
512 // Remove local device. |
|
513 // ----------------------------------------------------------------------------- |
|
514 // |
|
515 void CUpnpMessageHandlerSession::EventRemoveLocalDeviceL( |
|
516 const RMessage2 &aMessage, TBool aSilent ) |
|
517 { |
|
518 LOGS( "CUpnpMessageHandlerSession::EventRemoveLocalDeviceL"); |
|
519 TBuf8<KMaxUuidLength> uuid; |
|
520 |
|
521 aMessage.ReadL( 0, uuid ); |
|
522 |
|
523 TInt pos( 0); |
|
524 TInt error( 0); |
|
525 |
|
526 error = iAddedDevices.Find( uuid, pos ); |
|
527 if ( error == KErrNone ) |
|
528 { |
|
529 iAddedDevices.Delete( pos ); |
|
530 } |
|
531 |
|
532 iDeviceListSizeRequested = EFalse; |
|
533 |
|
534 iEngine.RemoveLocalDeviceL( uuid, aSilent ); |
|
535 } |
|
536 |
|
537 // ----------------------------------------------------------------------------- |
|
538 // CUpnpMessageHandlerSession::EventStartSsdp |
|
539 // Start SSPD. |
|
540 // ----------------------------------------------------------------------------- |
|
541 // |
|
542 TInt CUpnpMessageHandlerSession::EventStartSsdpL() |
|
543 { |
|
544 LOGS( "CUpnpMessageHandlerSession::EventStartSsdp"); |
|
545 return iEngine.StartSsdpL(); |
|
546 } |
|
547 |
|
548 // ----------------------------------------------------------------------------- |
|
549 // CUpnpMessageHandlerSession::EventIsSsdpStarted |
|
550 // Check SSPD. |
|
551 // ----------------------------------------------------------------------------- |
|
552 // |
|
553 void CUpnpMessageHandlerSession::EventCheckErrorL( const RMessage2 &aMessage ) |
|
554 { |
|
555 TBool isStarted; |
|
556 isStarted = iMessageHandler.IsSsdpStarted(); |
|
557 TInt error = iMessageHandler.StartingError(); |
|
558 TPckgBuf<TInt> ptr; |
|
559 |
|
560 if ( !isStarted ) |
|
561 { |
|
562 ptr = error; |
|
563 aMessage.WriteL( 0, ptr ); |
|
564 } |
|
565 else |
|
566 { |
|
567 ptr = 0; |
|
568 aMessage.WriteL( 0, ptr ); |
|
569 } |
|
570 |
|
571 } |
|
572 |
|
573 // ----------------------------------------------------------------------------- |
|
574 // CUpnpMessageHandlerSession::DeviceListChangeL |
|
575 // Device list change. |
|
576 // ----------------------------------------------------------------------------- |
|
577 // |
|
578 void CUpnpMessageHandlerSession::DeviceListChangeL() |
|
579 { |
|
580 LOGS( "CUpnpMessageHandlerSession::DeviceListChange"); |
|
581 if( iDeviceListSizeRequested && !iDeviceListSizeMessage.IsNull() ) |
|
582 { |
|
583 LOGS( "CUpnpMessageHandlerSession::New Devices Found"); |
|
584 |
|
585 TPtr8 ptr( reinterpret_cast<TUint8*>(&iSize), sizeof(iSize ), |
|
586 sizeof(iSize )); |
|
587 |
|
588 iDeviceListSizeMessage.ReadL( 0, ptr ); |
|
589 |
|
590 delete[] iAwaitingUpdateDevices; |
|
591 iAwaitingUpdateDevices = NULL; |
|
592 |
|
593 delete[] iAwaitingUpdateServices; |
|
594 iAwaitingUpdateServices = NULL; |
|
595 |
|
596 iEngine.DeviceLibrary()->GetUpdate( iSize.iUpdateId, iAwaitingUpdateDevices, |
|
597 iAwaitingUpdateServices, iSize.iDeviceCount, iSize.iServiceCount ); |
|
598 |
|
599 iOldId = iSize.iUpdateId; |
|
600 |
|
601 iDeviceListSizeMessage.WriteL( 0, ptr ); |
|
602 iDeviceListSizeMessage.Complete( EGetDeviceListSizeComplete ); |
|
603 |
|
604 iDeviceListSizeRequested = EFalse; |
|
605 } |
|
606 else |
|
607 { |
|
608 iMoreNewDevices = ETrue; |
|
609 if ( iOldId != KErrNotFound ) |
|
610 { |
|
611 iOldId++; |
|
612 } |
|
613 } |
|
614 } |
|
615 |
|
616 // ----------------------------------------------------------------------------- |
|
617 // CUpnpMessageHandlerSession::CopyMessage |
|
618 // Copy message. |
|
619 // ----------------------------------------------------------------------------- |
|
620 // |
|
621 void CUpnpMessageHandlerSession::CopyMessage( RMessage2& aMessage ) |
|
622 { |
|
623 iDeviceListSizeMessage = aMessage; |
|
624 } |
|
625 |
|
626 // ----------------------------------------------------------------------------- |
|
627 // CUpnpMessageHandlerSession::CancelPendingRequest |
|
628 // Cancel pending request. |
|
629 // ----------------------------------------------------------------------------- |
|
630 // |
|
631 void CUpnpMessageHandlerSession::CompletePendingRequest() |
|
632 { |
|
633 LOGS( "CUpnpMessageHandlerSession::CancelPendingRequest"); |
|
634 if ( iDeviceListSizeRequested && !iDeviceListSizeMessage.IsNull() ) |
|
635 { |
|
636 iDeviceListSizeMessage.Complete( EGetDeviceListSizeComplete ); |
|
637 |
|
638 iDeviceListSizeRequested = EFalse; |
|
639 } |
|
640 } |
|
641 |
|
642 #ifdef RD_UPNP_REMOTE_ACCESS |
|
643 // ----------------------------------------------------------------------------- |
|
644 // CUpnpMessageHandlerSession::EventAddFilterAddrByIpL |
|
645 // Cancel pending request. |
|
646 // ----------------------------------------------------------------------------- |
|
647 // |
|
648 void CUpnpMessageHandlerSession::EventAddFilterAddrByIpL( const RMessage2& aMessage ) |
|
649 { |
|
650 TInetAddr addr; |
|
651 TPtr8 ptr( reinterpret_cast<TUint8*>(&addr), sizeof( addr ), |
|
652 sizeof( addr ) ); |
|
653 |
|
654 aMessage.ReadL( 0, ptr ); |
|
655 |
|
656 iEngine.AddAddressL( addr ); |
|
657 } |
|
658 |
|
659 // ----------------------------------------------------------------------------- |
|
660 // CUpnpMessageHandlerSession::EventAddFilterAddrByHostnameL |
|
661 // Cancel pending request. |
|
662 // ----------------------------------------------------------------------------- |
|
663 // |
|
664 void CUpnpMessageHandlerSession::EventAddFilterAddrByHostnameL( const RMessage2& aMessage ) |
|
665 { |
|
666 TInt lenght( aMessage.GetDesLength(0) ); |
|
667 HBufC8* hostName = HBufC8::NewLC( lenght ); |
|
668 TPtr8 hostNamePtr( hostName->Des() ); |
|
669 aMessage.ReadL( 0, hostNamePtr ); |
|
670 |
|
671 iEngine.AddAddressL( aMessage, *hostName ); |
|
672 |
|
673 CleanupStack::PopAndDestroy( hostName ); |
|
674 } |
|
675 |
|
676 // ----------------------------------------------------------------------------- |
|
677 // CUpnpMessageHandlerSession::EventRemoveFilterAddrByIpL |
|
678 // Cancel pending request. |
|
679 // ----------------------------------------------------------------------------- |
|
680 // |
|
681 void CUpnpMessageHandlerSession::EventRemoveFilterAddrByIpL( const RMessage2& aMessage ) |
|
682 { |
|
683 TInetAddr addr; |
|
684 TPtr8 ptr( reinterpret_cast<TUint8*>(&addr), sizeof( addr ), |
|
685 sizeof( addr ) ); |
|
686 |
|
687 aMessage.ReadL( 0, ptr ); |
|
688 |
|
689 iEngine.RemoveAddressL( addr ); |
|
690 } |
|
691 |
|
692 // ----------------------------------------------------------------------------- |
|
693 // CUpnpMessageHandlerSession::EventRemoveFilterAddrByHostnameL |
|
694 // Cancel pending request. |
|
695 // ----------------------------------------------------------------------------- |
|
696 // |
|
697 void CUpnpMessageHandlerSession::EventRemoveFilterAddrByHostnameL( const RMessage2& aMessage ) |
|
698 { |
|
699 TInt lenght( aMessage.GetDesLength(0) ); |
|
700 HBufC8* hostName = HBufC8::NewLC( lenght ); |
|
701 TPtr8 hostNamePtr( hostName->Des() ); |
|
702 aMessage.ReadL( 0, hostNamePtr ); |
|
703 |
|
704 iEngine.RemoveAddressL( aMessage, *hostName ); |
|
705 |
|
706 CleanupStack::PopAndDestroy( hostName ); |
|
707 } |
|
708 |
|
709 // ----------------------------------------------------------------------------- |
|
710 // CUpnpMessageHandlerSession::EventRemoveAllIPsAddressesL |
|
711 // Cancel pending request. |
|
712 // ----------------------------------------------------------------------------- |
|
713 // |
|
714 void CUpnpMessageHandlerSession::EventRemoveAllIPsAddressesL( const RMessage2& /*aMessage*/) |
|
715 { |
|
716 iEngine.RemoveAll(); |
|
717 } |
|
718 |
|
719 // ----------------------------------------------------------------------------- |
|
720 // CUpnpMessageHandlerSession::EventIsIPAddressAllowedL |
|
721 // Cancel pending request. |
|
722 // ----------------------------------------------------------------------------- |
|
723 // |
|
724 TBool CUpnpMessageHandlerSession::EventIsIPAddressAllowedL( const RMessage2& aMessage) |
|
725 { |
|
726 TInetAddr addr; |
|
727 TPtr8 ptr( reinterpret_cast<TUint8*>(&addr), sizeof( addr ), |
|
728 sizeof( addr ) ); |
|
729 |
|
730 aMessage.ReadL( 0, ptr ); |
|
731 |
|
732 return iEngine.IsIPAllowed( addr ); |
|
733 } |
|
734 |
|
735 // ----------------------------------------------------------------------------- |
|
736 // CUpnpMessageHandlerSession::EventSubscriveIPListChanges |
|
737 // Cancel pending request. |
|
738 // ----------------------------------------------------------------------------- |
|
739 // |
|
740 void CUpnpMessageHandlerSession::EventSubscriveIPListChanges( RMessage2& aMessage ) |
|
741 { |
|
742 |
|
743 TPckgBuf<TInt> clientsSeqNo; |
|
744 TPckgBuf<TInt> listSizeBuff; |
|
745 |
|
746 aMessage.Read( 0 , clientsSeqNo ); |
|
747 |
|
748 if( clientsSeqNo() < iSeqNo ) |
|
749 { |
|
750 clientsSeqNo = iSeqNo; |
|
751 iEngine.IPFilteringStatus( listSizeBuff() ); |
|
752 |
|
753 aMessage.Write(0 , clientsSeqNo ); |
|
754 aMessage.Write(1 , listSizeBuff ); |
|
755 aMessage.Complete( KErrNone ); |
|
756 } |
|
757 else |
|
758 { |
|
759 iIPListSizeMessage = aMessage; |
|
760 } |
|
761 } |
|
762 |
|
763 // ----------------------------------------------------------------------------- |
|
764 // CUpnpMessageHandlerSession::EventCancelIPListSubscription |
|
765 // Cancel pending request. |
|
766 // ----------------------------------------------------------------------------- |
|
767 // |
|
768 void CUpnpMessageHandlerSession::EventCancelIPListSubscription( const RMessage2& /*aMessage*/) |
|
769 { |
|
770 if( !iIPListSizeMessage.IsNull() ) |
|
771 { |
|
772 iIPListSizeMessage.Complete( KErrCancel ); |
|
773 } |
|
774 } |
|
775 |
|
776 void CUpnpMessageHandlerSession::EventGetIPFilterListL( const RMessage2& aMessage ) |
|
777 { |
|
778 const TPtrC8 listBuf( iEngine.GetIPFilterList() ); |
|
779 |
|
780 if( listBuf.Length()> aMessage.GetDesMaxLength( 0 ) ) |
|
781 { |
|
782 aMessage.Complete( KErrOverflow ); |
|
783 return; |
|
784 } |
|
785 |
|
786 aMessage.WriteL( 0 , listBuf ); |
|
787 aMessage.Complete( KErrNone ); |
|
788 |
|
789 } |
|
790 #endif |
|
791 |
|
792 // ----------------------------------------------------------------------------- |
|
793 // CUpnpMessageHandlerSession::IPListChange |
|
794 // Cancel pending request. |
|
795 // ----------------------------------------------------------------------------- |
|
796 // |
|
797 void CUpnpMessageHandlerSession::IPListChange() |
|
798 { |
|
799 #ifdef RD_UPNP_REMOTE_ACCESS |
|
800 TPckgBuf<TInt> currentSeqNo( iSeqNo++ ); |
|
801 TPckgBuf<TInt> listSizeBuff; |
|
802 |
|
803 if( !iIPListSizeMessage.IsNull()) |
|
804 { |
|
805 iEngine.IPFilteringStatus( listSizeBuff() ); |
|
806 |
|
807 iIPListSizeMessage.Write(0 , currentSeqNo ); |
|
808 iIPListSizeMessage.Write(1 , listSizeBuff ); |
|
809 |
|
810 iIPListSizeMessage.Complete( KErrNone ); |
|
811 } |
|
812 #endif |
|
813 } |
|
814 |
|
815 // ----------------------------------------------------------------------------- |
|
816 // CUpnpMessageHandlerSession::CancelPendingRequests |
|
817 // Cancel pending request. |
|
818 // ----------------------------------------------------------------------------- |
|
819 // |
|
820 void CUpnpMessageHandlerSession::CancelPendingRequests() |
|
821 { |
|
822 if ( !iDeviceListSizeMessage.IsNull() ) |
|
823 { |
|
824 iDeviceListSizeRequested = EFalse; |
|
825 iDeviceListSizeMessage.Complete( KErrCancel ); |
|
826 } |
|
827 |
|
828 #ifdef RD_UPNP_REMOTE_ACCESS |
|
829 if ( !iIPListSizeMessage.IsNull() ) |
|
830 { |
|
831 iIPListSizeMessage.Complete( KErrCancel ); |
|
832 } |
|
833 #endif |
|
834 } |
|
835 |
|
836 // End of File |