--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/servicediscoveryandcontrol/pnp/test/upnp/Server/ServicePoint/src/upnpservicescpr.cpp Tue Feb 02 01:12:20 2010 +0200
@@ -0,0 +1,433 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// @file
+// @internalComponent
+//
+//
+
+#include <comms-infras/ss_msgintercept.h>
+#include <comms-infras/ss_log.h>
+#include <comms-infras/ss_logext.h>
+#include <inetprottextutils.h>
+#include <rmemchunk.h>
+
+#include "upnpservicescpr.h"
+#include "upnpservicescpractivities.h"
+#include "upnpsubconnevents.h"
+#include "upnpstatemachine.h"
+#include "upnpserverconstants.h"
+#include "upnplog.h"
+#include "upnpcpr.h"
+
+__FLOG_STMT(_LIT8(KComponent,"UPnPSPScpr");)
+
+
+using namespace ESock;
+
+
+CUPnPServiceSubConnectionProvider* CUPnPServiceSubConnectionProvider::NewL ( ESock::CSubConnectionProviderFactoryBase& aFactory )
+ {
+ CUPnPServiceSubConnectionProvider* provider = new ( ELeave ) CUPnPServiceSubConnectionProvider ( aFactory, UPnPServiceSCprActivities::activityMap::Self ( ) );
+ CleanupStack::PushL ( provider );
+ provider->ConstructL( );
+ CleanupStack::Pop ( provider );
+ return provider;
+ }
+
+CUPnPServiceSubConnectionProvider::~CUPnPServiceSubConnectionProvider ( )
+ {
+ iDescUrl.Close ( );
+ iControlUrl.Close ( );
+ iEventUrl.Close ( );
+ iResponseBundle.Close ();
+
+ delete iSubscribeInfoCont;
+ delete iPublishInfo;
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("Destroyed CUPnPServiceSubConnectionProvider")));
+ LOG_NODE_DESTROY ( KSubsysSPScpr, CUPnPServiceSubConnectionProvider );
+ }
+
+CUPnPServiceSubConnectionProvider::CUPnPServiceSubConnectionProvider ( ESock::CSubConnectionProviderFactoryBase& aFactory, const MeshMachine::TNodeActivityMap& aActivityMap )
+ : CUPnPSubConnectionProvider ( aFactory, aActivityMap ), iDevice ( EFalse ), iClosing ( EFalse )
+ {
+ LOG_NODE_CREATE ( KSubsysSPScpr, CUPnPServiceSubConnectionProvider );
+ }
+
+void CUPnPServiceSubConnectionProvider::ConstructL ( )
+ {
+ CCoreSubConnectionProvider::ConstructL ( );
+ iResponseBundle.CreateL ();
+ iResponseBundle.Open ();
+
+ iRequestBundle.CreateL ();
+
+ iSubscribeInfoCont = CUPnPSubscribeInfoContainer::NewL ( );
+ // set intial event data
+ iSubscribeInfoCont->SetEventDataL ( KNullDesC8 ( ) );
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("Created CUPnPServiceSubConnectionProvider")));
+ }
+
+void CUPnPServiceSubConnectionProvider::SetPublishInfo ( CUPnPPublishInfoElement* aPublishInfo )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::SetPublishInfo")));
+ iPublishInfo = aPublishInfo;
+ }
+
+CUPnPPublishInfoElement* CUPnPServiceSubConnectionProvider::PublishInfo ( )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::PublishInfo")));
+ return iPublishInfo;
+ }
+
+void CUPnPServiceSubConnectionProvider::SetKeyL ( const TDesC8& aKey )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::SetKeyL")));
+ iDescUrl.Close ( );
+ CreatePropertyUrlL ( aKey, iDescUrl );
+ }
+
+const TDesC8& CUPnPServiceSubConnectionProvider::Key ( )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::Key")));
+ return iDescUrl;
+ }
+
+void CUPnPServiceSubConnectionProvider::SetEventUrlL ( const TDesC8& aEventUrl )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::SetEventUrlL")));
+ iEventUrl.Close ( );
+ CreatePropertyUrlL ( aEventUrl, iEventUrl );
+ }
+
+const TDesC8& CUPnPServiceSubConnectionProvider::EventUrl ( )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::EventUrl")));
+ return iEventUrl;
+ }
+
+void CUPnPServiceSubConnectionProvider::SetControlUrlL ( const TDesC8& aControlUrl )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::SetControlUrlL")));
+ iControlUrl.Close ( );
+ CreatePropertyUrlL ( aControlUrl, iControlUrl );
+ }
+
+void CUPnPServiceSubConnectionProvider::CreatePropertyUrlL ( const TDesC8& aRelativeUrl, RBuf8& aTargetUrl )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::CreatePropertyUrlL")));
+ const TDesC8& rootLoc = ConnectionProvider ().RootDeviceLocation ();
+
+ aTargetUrl.CreateMaxL ( rootLoc.Length ( ) + aRelativeUrl.Length ( ) );
+ aTargetUrl.Copy ( rootLoc );
+ aTargetUrl.Append ( aRelativeUrl );
+ }
+const TDesC8& CUPnPServiceSubConnectionProvider::ControlUrl ( )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::ControlUrl")));
+ return iControlUrl;
+ }
+
+void CUPnPServiceSubConnectionProvider::SetDevice ( const TBool aIsDevice )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::SetDevice")));
+ iDevice = aIsDevice;
+ }
+
+TBool CUPnPServiceSubConnectionProvider::IsDevice ( )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::IsDevice")));
+ return iDevice;
+ }
+
+const TDesC8& CUPnPServiceSubConnectionProvider::SCPDData ( )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::SCPDData")));
+ return iPublishInfo->ServiceDescription( );
+ }
+
+CUPnPSubscribeInfoContainer* CUPnPServiceSubConnectionProvider::GetSubscribeInfoContainer ( )
+ {
+ return iSubscribeInfoCont;
+ }
+
+CUPnPServiceConnectionProvider& CUPnPServiceSubConnectionProvider::ConnectionProvider ( )
+ {
+ CUPnPConnectionProvider& cprBase = BaseConnectionProvider();
+ return static_cast<CUPnPServiceConnectionProvider&>(cprBase);
+ }
+
+void CUPnPServiceSubConnectionProvider::ReceivedL ( const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage )
+ {
+ ESOCK_DEBUG_MESSAGE_INTERCEPT ( aSender, aMessage, aRecipient );
+ TNodeContext<CUPnPServiceSubConnectionProvider> ctx(*this, aMessage, aSender, aRecipient);
+ CCoreSubConnectionProvider::ReceivedL ( aSender, aRecipient, aMessage );
+ User::LeaveIfError ( ctx.iReturn );
+ }
+
+void CUPnPServiceSubConnectionProvider::InitiateActivitiesL ( )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::InitiateActivitiesL")));
+
+ RParameterFamily paramFamily = iRequestBundle.GetFamilyAtIndex (0);
+ switch ( paramFamily.Id( ) )
+ {
+ case EUPnPClearParamSet:
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::InitiateActivitiesL - TUPnPParamSetFamily::EUPnPClearParamSet")));
+ ClearResponseParamL ( );
+ break;
+
+ case EUPnPServiceNotificationParamSet:
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::InitiateActivitiesL - TUPnPParamSetFamily::EUPnPServiceNotificationParamSet")));
+ SendNotifyToRemoteClientsL ( paramFamily );
+ break;
+
+ case EUPnPServiceRegisterParamSet:
+ case EUPnPServiceRefreshParamSet:
+ case EUPnPDeviceRegisterParamSetExt:
+ InitiateRequestL ( paramFamily );
+ break;
+
+ default:
+ break;
+ }
+ //finally delete UPnP Clear Family
+ iRequestBundle.DeleteFamilyAtIndex (0);
+ }
+
+
+void CUPnPServiceSubConnectionProvider::InitiateRequestL ( RParameterFamily& aReqFamily )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::InitiateRequestL")));
+ switch ( aReqFamily.Id ( ) )
+ {
+ case EUPnPServiceRegisterParamSet:
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPServiceRegisterParamSet")));
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPServiceRegisterParamSet - Posting message TUpnpMessage::TServiceRegistration")));
+ CSubConExtensionParameterSet* paramSet = static_cast<CSubConExtensionParameterSet*> ( aReqFamily.GetParameterSetAtIndex ( 0, RParameterFamily::ERequested ) );
+ TUpnpMessage::TServiceRegistration msg ( paramSet );
+ RClientInterface::OpenPostMessageClose ( NodeId (), TNodeCtxId ( TUpnpMessage::EActivityServiceRegistration, NodeId () ) , msg );
+ aReqFamily.ClearParameterSetPointer( 0, RParameterFamily::ERequested );
+ }
+ break;
+
+ case EUPnPDeviceRegisterParamSetExt:
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPDeviceRegisterParamSet")));
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPDeviceRegisterParamSet - Posting message TUpnpMessage::TDeviceRegistration")));
+ CUPnPDeviceRegisterParamSetExt* paramSet = static_cast<CUPnPDeviceRegisterParamSetExt*> ( aReqFamily.GetParameterSetAtIndex ( 0, RParameterFamily::ERequested ) );
+
+ CUPnPDeviceRegisterParamSet* deviceParams = CopyWithIconInfoL ( paramSet );
+
+ TUpnpMessage::TDeviceRegistration msg ( deviceParams );
+ RClientInterface::OpenPostMessageClose ( NodeId (), TNodeCtxId ( TUpnpMessage::EActivityDeviceRegistration, NodeId () ) , msg );
+ }
+ break;
+
+ case EUPnPServiceRefreshParamSet:
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPServiceRefreshParamSet")));
+ if ( IsDevice ( ) )
+ {
+ // Publish once for uuid:device-UUID
+ DoPublishL ( iPublishInfo->Uuid( ), iPublishInfo->Uuid( ), iPublishInfo->CacheControl( ) );
+ }
+
+ // Publish once for uuid:device-UUID::urn:domain-name-device:deviceType:v
+ // (or) Publish once for uuid:device-UUID::urn:domain-name-service:serviceType:v
+ DoPublishL ( iPublishInfo->SearchTarget( ), iPublishInfo->Usn( ), iPublishInfo->CacheControl( ) );
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+void CUPnPServiceSubConnectionProvider::DoPublishL ( const TDesC8& aSearchTarget, const TDesC8& aUsn, TInt aMaxAge )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::DoPublishL")));
+ RMemoryAllocator allocator = ConnectionProvider().MemoryAllocator();
+
+ RMemChunk locationBuf;
+ locationBuf.CreateL ( ConnectionProvider ().RootDeviceLocation (), allocator );
+
+ RMemChunk stBuf;
+ stBuf.CreateL ( aSearchTarget, allocator );
+ TCleanupItem item ( &UPnPStateMachine::CUPnPUtils::CleanupMBufChain, &stBuf );
+ CleanupStack::PushL ( item );
+
+ RMemChunk usnBuf;
+ usnBuf.CreateL ( aUsn, allocator );
+
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::DoPublishL - Posting message TUpnpMessage::TUPnPPublishAliveRequest")));
+ TSsdpInfo ssdpInfo ( aMaxAge, locationBuf, usnBuf, stBuf);
+ RClientInterface::OpenPostMessageClose ( NodeId (), UdpClientFlow (), TUpnpMessage::TUPnPPublishAliveRequest ( ssdpInfo ).CRef () );
+ CleanupStack::Pop ( ); // item
+ }
+
+
+// this will send notification to the clients
+void CUPnPServiceSubConnectionProvider::SendNotifyToRemoteClientsL ( RParameterFamily& aReqFamily )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::SendNotifyToRemoteClientsL")));
+ CUPnPServiceNotificationParamSet* paramSet = static_cast<CUPnPServiceNotificationParamSet* > (aReqFamily.GetParameterSetAtIndex ( 0, RParameterFamily::ERequested ) );
+ __ASSERT_DEBUG ( paramSet != NULL, User::Invariant ( ) );
+
+ // replace the existing data
+ iSubscribeInfoCont->SetEventDataL( paramSet->Notification( ) );
+ // now send it to all the subscribers
+ for ( TInt i =0; i < iSubscribeInfoCont->CountOfSubscribeInfoElementArray( ); i++ )
+ {
+ CUPnPSubscribeInfoElement* element = iSubscribeInfoCont->AtSubscribeInfoElementArray( i );
+ TInt eventKey = element->EventKey( );
+ eventKey++;
+ if(eventKey == 0)
+ {
+ eventKey++; //wrap around
+ }
+ element->SetEventKey(eventKey);
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::SendNotifyToRemoteClientsL - Posting message TUpnpMessage::TNotifyRequest")));
+ // send the message to start the activty
+ RClientInterface::OpenPostMessageClose ( NodeId (), TNodeCtxId ( TUpnpMessage::EActivityNotifyRequest, NodeId () ), TUpnpMessage::TNotifyRequest ( element ).CRef () );
+ }
+ }
+
+void CUPnPServiceSubConnectionProvider::NotifySubConnectionL ( )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::NotifySubConnectionL")));
+ CUPnPSubConnEvent* subConnEvent = CUPnPSubConnEvent::NewL ( );
+
+ TCleanupItem item ( &CUPnPSubConnEvent::CleanupSubConnEvent, subConnEvent );
+ CleanupStack::PushL ( item );
+
+ subConnEvent->SetFamily ( EUPnPPublishResponseParamSet );
+ NotifyClientsL ( *subConnEvent );
+ CleanupStack::Pop ( ); // item
+ }
+
+void CUPnPServiceSubConnectionProvider::ClearResponseParamL ( )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::ClearResponseParamL")));
+ iResponseBundle.Close (); // DEF126893 fix pending
+ }
+
+void CUPnPServiceSubConnectionProvider::AddResponseParamSetL ( TUPnPEvent aEvent )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::AddResponseParamSetL")));
+ if ( !IsClosing ( ) )
+ {
+ RParameterFamily responseFamily = iResponseBundle.CreateFamilyL ( EUPnPPublishResponseParamSet );
+ RParameterFamily family;
+ CUPnPPublishResponseParamSet* responseSet = CUPnPPublishResponseParamSet::NewL ( family );
+ responseFamily.AddParameterSetL ( responseSet, RParameterFamily::ERequested );
+
+ if ( iPublishInfo )
+ responseSet->SetUriL( iPublishInfo->SearchTarget( ) );
+ responseSet->SetUPnPEvent( aEvent );
+
+ NotifySubConnectionL ( );
+ }
+ }
+
+
+void CUPnPServiceSubConnectionProvider::DeprecateExpiredSubscriptions ( )
+ {
+ LOG(ESockLogExternal::Printf(KSubsysSPScpr, KComponent, _L8("CUPnPServiceSubConnectionProvider::DeprecateExpiredSubscriptions")));
+ TInt duration;
+ TUint count = iSubscribeInfoCont->CountOfSubscribeInfoElementArray( );
+ CUPnPSubscribeInfoElement* element = NULL;
+
+ for ( TInt i = 0; i < count; i++ )
+ {
+ element = iSubscribeInfoCont->AtSubscribeInfoElementArray( i );
+ duration = element->SubscriptionDuration( );
+ if ( --duration == 0 )
+ {
+ // timer has expired so delete this entry
+ iSubscribeInfoCont->DeleteSubscribeInfoElement( element );
+ }
+ else
+ {
+ element->SetSubscriptionDuration( duration );
+ }
+ }
+ }
+
+CUPnPDeviceRegisterParamSet* CUPnPServiceSubConnectionProvider::CopyWithIconInfoL ( CUPnPDeviceRegisterParamSetExt* aDeviceParam )
+ {
+ RParameterFamily family;
+ CUPnPDeviceRegisterParamSet* newParamSet = CUPnPDeviceRegisterParamSet::NewL ( family );
+ newParamSet->SetUriL ( aDeviceParam->Uri () );
+ newParamSet->SetCacheControlData ( aDeviceParam->CacheControlData () );
+ newParamSet->SetParentDeviceUidL ( aDeviceParam->ParentDeviceUid () );
+ newParamSet->SetFriendlyNameL ( aDeviceParam->FriendlyName () );
+ newParamSet->SetManufacturerL ( aDeviceParam->Manufacturer () );
+ newParamSet->SetManufactureUrlL ( aDeviceParam->ManufacturerUrl () );
+ newParamSet->SetModelDescL ( aDeviceParam->ModelDesc () );
+ newParamSet->SetModelNameL ( aDeviceParam->ModelName () );
+ newParamSet->SetModelNumberL ( aDeviceParam->ModelNumber () );
+ newParamSet->SetModelUriL ( aDeviceParam->ModelUri () );
+ newParamSet->SetPresentationL ( aDeviceParam->PresentationUri () );
+ newParamSet->SetSerialNumberL ( aDeviceParam->SerialNumber () );
+ newParamSet->SetUDNL ( aDeviceParam->UDN () );
+ newParamSet->SetUPCL ( aDeviceParam->UPC () );
+
+ LoadIconListL ( aDeviceParam->IconData (), newParamSet );
+
+ return newParamSet;
+ }
+
+void CUPnPServiceSubConnectionProvider::LoadIconListL ( const TDesC8& aIconData, CUPnPDeviceRegisterParamSet* aDeviceParamSet )
+ {
+ TPtrC8 buffer ( aIconData );
+ TInt count = 0;
+ ReadTInt ( buffer, count );
+
+ TInt size = 0;
+ for ( TInt i = 0; i < count; i++ )
+ {
+ CUPnPIconParams* icon = CUPnPIconParams::NewL ();
+ CleanupStack::PushL ( icon );
+
+ ReadTInt ( buffer, size );
+ icon->SetMimeTypeL ( buffer.Left ( size ) );
+ buffer.Set ( buffer.Ptr () + size, buffer.Length () - size ); //update pointer
+
+ ReadTInt ( buffer, size );
+ icon->SetUrlL ( buffer.Left ( size ) );
+ buffer.Set ( buffer.Ptr () + size, buffer.Length () - size ); //update pointer
+
+ ReadTInt ( buffer, size );
+ icon->SetWidth ( size );
+
+ ReadTInt ( buffer, size );
+ icon->SetHeight ( size );
+
+ ReadTInt ( buffer, size );
+ icon->SetDepth ( size );
+
+ aDeviceParamSet->SetIconInfoL ( icon );
+ CleanupStack::Pop (); // icon
+ }
+ }
+
+void CUPnPServiceSubConnectionProvider::ReadTInt ( TPtrC8& aBuffer, TInt& aValue )
+ {
+ TUint32 len = sizeof ( TUint32 );
+ TPtrC8 ptr ( aBuffer.Ptr (), len );
+ InetProtTextUtils::ConvertDescriptorToInt ( ptr, aValue );
+ aBuffer.Set ( aBuffer.Ptr () + len, aBuffer.Length () - len ); //update pointer
+ }
+