upnp/upnpstack/messagehandler/src/upnpmessagehandlersession.cpp
changeset 0 f5a58ecadc66
equal deleted inserted replaced
-1:000000000000 0:f5a58ecadc66
       
     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