diff -r 000000000000 -r f5a58ecadc66 servicediscoveryandcontrol/pnp/test/upnp/Server/ServicePoint/src/upnpservicescpr.cpp --- /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 +#include +#include +#include +#include + +#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(cprBase); + } + +void CUPnPServiceSubConnectionProvider::ReceivedL ( const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage ) + { + ESOCK_DEBUG_MESSAGE_INTERCEPT ( aSender, aMessage, aRecipient ); + TNodeContext 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 ( 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 ( 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 (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 + } +