Skip to content

V
vlc
Commit f7dfc8f1 authored by Hugo Beauzée-Luyssen's avatar Hugo Beauzée-Luyssen
Browse files
Options

UPnP: important rewrite 

This is splitting the UPnP module in 2 parts:
- A service discovery module that is solely responsible for discovering
UPnP devices on the network
- An access module that will leverage the recently introduced
pf_readdir callback to list directories.

This removes the need for recursion and handling of all the items from
within the SD module.
parent f890621c
Hide whitespace changes
Inline Side-by-side
Showing with 545 additions and 1004 deletions
modules/services_discovery/upnp.cpp
View file @ f7dfc8f1
......@@ -7,6 +7,7 @@
* Authors: Rémi Denis-Courmont <rem # videolan.org> (original plugin)
* Christian Henz <henz # c-lab.de>
* Mirsal Ennaime <mirsal dot ennaime at gmail dot com>
* Hugo Beauzée-Luyssen <hugo@beauzee.fr>
*
* UPnP Plugin using the Intel SDK (libupnp) instead of CyberLink
*
......@@ -32,13 +33,16 @@
# include "config.h"
#endif
#include "services_discovery/upnp.hpp"
#include "upnp.hpp"
#include <vlc_access.h>
#include <vlc_plugin.h>
#include <vlc_services_discovery.h>
#include <vlc_url.h>
#include <assert.h>
#include <limits.h>
#include <algorithm>
/*
* Constants
......@@ -51,138 +55,55 @@ const char* CONTENT_DIRECTORY_SERVICE_TYPE = "urn:schemas-upnp-org:service:Conte
*/
struct services_discovery_sys_t
{
UpnpClient_Handle client_handle;
MediaServerList* p_server_list;
vlc_mutex_t callback_lock;
UpnpInstanceWrapper* p_upnp;
SD::MediaServerList* p_server_list;
};
struct access_sys_t
{
UpnpInstanceWrapper* p_upnp;
};
UpnpInstanceWrapper* UpnpInstanceWrapper::s_instance;
vlc_mutex_t UpnpInstanceWrapper::s_lock = VLC_STATIC_MUTEX;
/*
* VLC callback prototypes
*/
static int Open( vlc_object_t* );
static void Close( vlc_object_t* );
namespace SD
{
static int Open( vlc_object_t* );
static void Close( vlc_object_t* );
}
namespace Access
{
static int Open( vlc_object_t* );
static void Close( vlc_object_t* );
}
VLC_SD_PROBE_HELPER( "upnp", "Universal Plug'n'Play", SD_CAT_LAN )
/*
* Module descriptor
*/
vlc_module_begin();
vlc_module_begin()
set_shortname( "UPnP" );
set_description( N_( "Universal Plug'n'Play" ) );
set_category( CAT_PLAYLIST );
set_subcategory( SUBCAT_PLAYLIST_SD );
set_capability( "services_discovery", 0 );
set_callbacks( Open, Close );
VLC_SD_PROBE_SUBMODULE
vlc_module_end();
/*
* Local prototypes
*/
static int Callback( Upnp_EventType event_type, void* p_event, void* p_user_data );
const char* xml_getChildElementValue( IXML_Element* p_parent,
const char* psz_tag_name );
const char* xml_getChildElementValue( IXML_Document* p_doc,
const char* psz_tag_name );
const char* xml_getChildElementAttributeValue( IXML_Element* p_parent,
const char* psz_tag_name,
const char* psz_attribute );
int xml_getNumber( IXML_Document* p_doc,
const char* psz_tag_name );
IXML_Document* parseBrowseResult( IXML_Document* p_doc );
/*
* Initializes UPNP instance.
*/
static int Open( vlc_object_t *p_this )
{
int i_res;
services_discovery_t *p_sd = ( services_discovery_t* )p_this;
services_discovery_sys_t *p_sys = ( services_discovery_sys_t * )
calloc( 1, sizeof( services_discovery_sys_t ) );
if( !( p_sd->p_sys = p_sys ) )
return VLC_ENOMEM;
#ifdef UPNP_ENABLE_IPV6
char* psz_miface;
psz_miface = var_InheritString( p_sd, "miface" );
msg_Info( p_sd, "Initializing libupnp on '%s' interface", psz_miface );
i_res = UpnpInit2( psz_miface, 0 );
free( psz_miface );
#else
/* If UpnpInit2 isnt available, initialize on first IPv4-capable interface */
i_res = UpnpInit( 0, 0 );
#endif
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Initialization failed: %s", UpnpGetErrorMessage( i_res ) );
free( p_sys );
return VLC_EGENERIC;
}
ixmlRelaxParser( 1 );
p_sys->p_server_list = new MediaServerList( p_sd );
vlc_mutex_init( &p_sys->callback_lock );
/* Register a control point */
i_res = UpnpRegisterClient( Callback, p_sd, &p_sys->client_handle );
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Client registration failed: %s", UpnpGetErrorMessage( i_res ) );
Close( (vlc_object_t*) p_sd );
return VLC_EGENERIC;
}
/* Search for media servers */
i_res = UpnpSearchAsync( p_sys->client_handle, 5,
MEDIA_SERVER_DEVICE_TYPE, p_sd );
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Error sending search request: %s", UpnpGetErrorMessage( i_res ) );
Close( (vlc_object_t*) p_sd );
return VLC_EGENERIC;
}
/* libupnp does not treat a maximum content length of 0 as unlimited
* until 64dedf (~ pupnp v1.6.7) and provides no sane way to discriminate
* between versions */
if( (i_res = UpnpSetMaxContentLength( INT_MAX )) != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Failed to set maximum content length: %s",
UpnpGetErrorMessage( i_res ));
Close( (vlc_object_t*) p_sd );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/*
* Releases resources.
*/
static void Close( vlc_object_t *p_this )
{
services_discovery_t *p_sd = ( services_discovery_t* )p_this;
UpnpUnRegisterClient( p_sd->p_sys->client_handle );
UpnpFinish();
set_callbacks( SD::Open, SD::Close );
delete p_sd->p_sys->p_server_list;
vlc_mutex_destroy( &p_sd->p_sys->callback_lock );
add_submodule()
set_category( CAT_INPUT )
set_subcategory( SUBCAT_INPUT_ACCESS )
set_callbacks( Access::Open, Access::Close )
set_capability( "access", 0 )
free( p_sd->p_sys );
}
VLC_SD_PROBE_SUBMODULE
vlc_module_end()
/* XML utility functions */
/*
* Returns the value of a child element, or NULL on error
......@@ -207,51 +128,6 @@ const char* xml_getChildElementValue( IXML_Element* p_parent,
return ixmlNode_getNodeValue( p_text_node );
}
/*
* Returns the value of a child element's attribute, or NULL on error
*/
const char* xml_getChildElementAttributeValue( IXML_Element* p_parent,
const char* psz_tag_name,
const char* psz_attribute )
{
assert( p_parent );
assert( psz_tag_name );
assert( psz_attribute );
IXML_NodeList* p_node_list;
p_node_list = ixmlElement_getElementsByTagName( p_parent, psz_tag_name );
if ( !p_node_list ) return NULL;
IXML_Node* p_element = ixmlNodeList_item( p_node_list, 0 );
ixmlNodeList_free( p_node_list );
if ( !p_element ) return NULL;
return ixmlElement_getAttribute( (IXML_Element*) p_element, psz_attribute );
}
/*
* Returns the value of a child element, or NULL on error
*/
const char* xml_getChildElementValue( IXML_Document* p_doc,
const char* psz_tag_name )
{
assert( p_doc );
assert( psz_tag_name );
IXML_NodeList* p_node_list;
p_node_list = ixmlDocument_getElementsByTagName( p_doc, psz_tag_name );
if ( !p_node_list ) return NULL;
IXML_Node* p_element = ixmlNodeList_item( p_node_list, 0 );
ixmlNodeList_free( p_node_list );
if ( !p_element ) return NULL;
IXML_Node* p_text_node = ixmlNode_getFirstChild( p_element );
if ( !p_text_node ) return NULL;
return ixmlNode_getNodeValue( p_text_node );
}
/*
* Extracts the result document from a SOAP response
*/
......@@ -259,7 +135,10 @@ IXML_Document* parseBrowseResult( IXML_Document* p_doc )
{
assert( p_doc );
const char* psz_raw_didl = xml_getChildElementValue( p_doc, "Result" );
// ixml*_getElementsByTagName will ultimately only case the pointer to a Node
// pointer, and pass it to a private function. Don't bother have a IXML_Document
// version of getChildElementValue
const char* psz_raw_didl = xml_getChildElementValue( (IXML_Element*)p_doc, "Result" );
if( !psz_raw_didl )
return NULL;
......@@ -302,561 +181,532 @@ IXML_Document* parseBrowseResult( IXML_Document* p_doc )
return (IXML_Document*)p_node;
}
namespace SD
{
/*
* Get the number value from a SOAP response
* Initializes UPNP instance.
*/
int xml_getNumber( IXML_Document* p_doc,
const char* psz_tag_name )
static int Open( vlc_object_t *p_this )
{
assert( p_doc );
assert( psz_tag_name );
services_discovery_t *p_sd = ( services_discovery_t* )p_this;
services_discovery_sys_t *p_sys = ( services_discovery_sys_t * )
calloc( 1, sizeof( services_discovery_sys_t ) );
const char* psz = xml_getChildElementValue( p_doc, psz_tag_name );
if( !( p_sd->p_sys = p_sys ) )
return VLC_ENOMEM;
if( !psz )
return 0;
p_sys->p_server_list = new(std::nothrow) SD::MediaServerList( p_sd );
if ( unlikely( p_sys->p_server_list == NULL ) )
{
return VLC_ENOMEM;
}
char *psz_end;
long l = strtol( psz, &psz_end, 10 );
p_sys->p_upnp = UpnpInstanceWrapper::get( p_this, SD::MediaServerList::Callback, p_sys->p_server_list );
if ( !p_sys->p_upnp )
{
Close( p_this );
return VLC_EGENERIC;
}
if( *psz_end || l < 0 || l > INT_MAX )
return 0;
/* Search for media servers */
int i_res = UpnpSearchAsync( p_sys->p_upnp->handle(), 5,
MEDIA_SERVER_DEVICE_TYPE, p_sys->p_upnp );
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Error sending search request: %s", UpnpGetErrorMessage( i_res ) );
Close( p_this );
return VLC_EGENERIC;
}
return (int)l;
return VLC_SUCCESS;
}
/*
* Handles all UPnP events
* Releases resources.
*/
static int Callback( Upnp_EventType event_type, void* p_event, void* p_user_data )
static void Close( vlc_object_t *p_this )
{
services_discovery_t* p_sd = ( services_discovery_t* ) p_user_data;
services_discovery_sys_t* p_sys = p_sd->p_sys;
vlc_mutex_locker locker( &p_sys->callback_lock );
services_discovery_t *p_sd = ( services_discovery_t* )p_this;
services_discovery_sys_t *p_sys = p_sd->p_sys;
switch( event_type )
{
case UPNP_DISCOVERY_ADVERTISEMENT_ALIVE:
case UPNP_DISCOVERY_SEARCH_RESULT:
{
struct Upnp_Discovery* p_discovery = ( struct Upnp_Discovery* )p_event;
if (p_sys->p_upnp)
p_sys->p_upnp->release( true );
delete p_sys->p_server_list;
free( p_sys );
}
IXML_Document *p_description_doc = 0;
MediaServerDesc::MediaServerDesc(const std::string& udn, const std::string& fName, const std::string& loc)
: UDN( udn )
, friendlyName( fName )
, location( loc )
, inputItem( NULL )
{
}
int i_res;
i_res = UpnpDownloadXmlDoc( p_discovery->Location, &p_description_doc );
if ( i_res != UPNP_E_SUCCESS )
{
msg_Warn( p_sd, "Could not download device description! "
"Fetching data from %s failed: %s",
p_discovery->Location, UpnpGetErrorMessage( i_res ) );
return i_res;
}
MediaServerDesc::~MediaServerDesc()
{
if (inputItem)
vlc_gc_decref( inputItem );
}
MediaServer::parseDeviceDescription( p_description_doc,
p_discovery->Location, p_sd );
/*
* MediaServerList class
*/
MediaServerList::MediaServerList( services_discovery_t* p_sd )
: p_sd_( p_sd )
{
vlc_mutex_init( &lock_ );
}
ixmlDocument_free( p_description_doc );
}
break;
MediaServerList::~MediaServerList()
{
vlc_delete_all(list_);
vlc_mutex_destroy( &lock_ );
}
case UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE:
{
struct Upnp_Discovery* p_discovery = ( struct Upnp_Discovery* )p_event;
bool MediaServerList::addServer( MediaServerDesc* desc )
{
vlc_mutex_locker lock( &lock_ );
input_item_t* p_input_item = NULL;
if ( getServer( desc->UDN ) )
return false;
p_sys->p_server_list->removeServer( p_discovery->DeviceId );
msg_Dbg( p_sd_, "Adding server '%s' with uuid '%s'", desc->friendlyName.c_str(), desc->UDN.c_str() );
}
break;
char* psz_mrl;
if( asprintf(&psz_mrl, "upnp://%s?ObjectID=%s", desc->location.c_str(), desc->UDN.c_str() ) < 0 )
return false;
case UPNP_EVENT_RECEIVED:
{
Upnp_Event* p_e = ( Upnp_Event* )p_event;
p_input_item = input_item_NewWithType( psz_mrl, desc->friendlyName.c_str(), 0,
NULL, 0, -1, ITEM_TYPE_NODE );
free( psz_mrl );
if ( !p_input_item )
return false;
desc->inputItem = p_input_item;
input_item_SetDescription( p_input_item, desc->UDN.c_str() );
services_discovery_AddItem( p_sd_, p_input_item, NULL );
list_.push_back( desc );
return true;
}
MediaServer* p_server = p_sys->p_server_list->getServerBySID( p_e->Sid );
if ( p_server ) p_server->fetchContents();
}
break;
MediaServerDesc* MediaServerList::getServer( const std::string& udn )
{
std::vector<MediaServerDesc*>::const_iterator it = list_.begin();
std::vector<MediaServerDesc*>::const_iterator ite = list_.end();
case UPNP_EVENT_AUTORENEWAL_FAILED:
case UPNP_EVENT_SUBSCRIPTION_EXPIRED:
for ( ; it != ite; ++it )
{
/* Re-subscribe. */
Upnp_Event_Subscribe* p_s = ( Upnp_Event_Subscribe* )p_event;
MediaServer* p_server = p_sys->p_server_list->getServerBySID( p_s->Sid );
if ( p_server ) p_server->subscribeToContentDirectory();
}
break;
case UPNP_EVENT_SUBSCRIBE_COMPLETE:
msg_Warn( p_sd, "subscription complete" );
break;
case UPNP_DISCOVERY_SEARCH_TIMEOUT:
msg_Warn( p_sd, "search timeout" );
break;
default:
msg_Err( p_sd, "Unhandled event, please report ( type=%d )", event_type );
break;
if( udn == (*it)->UDN )
{
return *it;
}
}
return UPNP_E_SUCCESS;
return NULL;
}
/*
* Local class implementations.
*/
/*
* MediaServer
*/
void MediaServer::parseDeviceDescription( IXML_Document* p_doc,
const char* p_location,
services_discovery_t* p_sd )
void MediaServerList::parseNewServer( IXML_Document *doc, const std::string &location )
{
if ( !p_doc )
if ( !doc )
{
msg_Err( p_sd, "Null IXML_Document" );
msg_Err( p_sd_, "Null IXML_Document" );
return;
}
if ( !p_location )
if ( location.empty() )
{
msg_Err( p_sd, "Null location" );
msg_Err( p_sd_, "Empty location" );
return;
}
const char* psz_base_url = p_location;
const char* psz_base_url = location.c_str();
/* Try to extract baseURL */
IXML_NodeList* p_url_list = ixmlDocument_getElementsByTagName( p_doc, "URLBase" );
IXML_NodeList* p_url_list = ixmlDocument_getElementsByTagName( doc, "URLBase" );
if ( p_url_list )
{
if ( IXML_Node* p_url_node = ixmlNodeList_item( p_url_list, 0 ) )
{
IXML_Node* p_text_node = ixmlNode_getFirstChild( p_url_node );
if ( p_text_node ) psz_base_url = ixmlNode_getNodeValue( p_text_node );
if ( p_text_node )
psz_base_url = ixmlNode_getNodeValue( p_text_node );
}
ixmlNodeList_free( p_url_list );
}
/* Get devices */
IXML_NodeList* p_device_list =
ixmlDocument_getElementsByTagName( p_doc, "device" );
IXML_NodeList* p_device_list = ixmlDocument_getElementsByTagName( doc, "device" );
if ( p_device_list )
if ( !p_device_list )
return;
for ( unsigned int i = 0; i < ixmlNodeList_length( p_device_list ); i++ )
{
for ( unsigned int i = 0; i < ixmlNodeList_length( p_device_list ); i++ )
IXML_Element* p_device_element = ( IXML_Element* ) ixmlNodeList_item( p_device_list, i );
if( !p_device_element )
continue;
const char* psz_device_type = xml_getChildElementValue( p_device_element, "deviceType" );
if ( !psz_device_type )
{
IXML_Element* p_device_element =
( IXML_Element* ) ixmlNodeList_item( p_device_list, i );
msg_Warn( p_sd_, "No deviceType found!" );
continue;
}
if( !p_device_element )
continue;
if ( strncmp( MEDIA_SERVER_DEVICE_TYPE, psz_device_type,
strlen( MEDIA_SERVER_DEVICE_TYPE ) - 1 ) )
continue;
const char* psz_device_type =
xml_getChildElementValue( p_device_element, "deviceType" );
const char* psz_udn = xml_getChildElementValue( p_device_element,
"UDN" );
if ( !psz_udn )
{
msg_Warn( p_sd_, "No UDN!" );
continue;
}
if ( !psz_device_type )
{
msg_Warn( p_sd, "No deviceType found!" );
continue;
}
/* Check if server is already added */
if ( p_sd_->p_sys->p_server_list->getServer( psz_udn ) )
{
msg_Warn( p_sd_, "Server with uuid '%s' already exists.", psz_udn );
continue;
}
if ( strncmp( MEDIA_SERVER_DEVICE_TYPE, psz_device_type,
strlen( MEDIA_SERVER_DEVICE_TYPE ) - 1 ) != 0 )
continue;
const char* psz_friendly_name =
xml_getChildElementValue( p_device_element,
"friendlyName" );
const char* psz_udn = xml_getChildElementValue( p_device_element,
"UDN" );
if ( !psz_udn )
{
msg_Warn( p_sd, "No UDN!" );
continue;
}
if ( !psz_friendly_name )
{
msg_Dbg( p_sd_, "No friendlyName!" );
continue;
}
/* Check if server is already added */
if ( p_sd->p_sys->p_server_list->getServer( psz_udn ) != 0 )
{
msg_Warn( p_sd, "Server with uuid '%s' already exists.", psz_udn );
continue;
}
// We now have basic info, we need to get the content browsing url
// so the access module can browse without fetching the manifest again
const char* psz_friendly_name =
xml_getChildElementValue( p_device_element,
"friendlyName" );
/* Check for ContentDirectory service. */
IXML_NodeList* p_service_list = ixmlElement_getElementsByTagName( p_device_element, "service" );
if ( !p_service_list )
continue;
for ( unsigned int j = 0; j < ixmlNodeList_length( p_service_list ); j++ )
{
IXML_Element* p_service_element = (IXML_Element*)ixmlNodeList_item( p_service_list, j );
if ( !psz_friendly_name )
const char* psz_service_type = xml_getChildElementValue( p_service_element, "serviceType" );
if ( !psz_service_type )
{
msg_Dbg( p_sd, "No friendlyName!" );
msg_Warn( p_sd_, "No service type found." );
continue;
}
MediaServer* p_server = new MediaServer( psz_udn,
psz_friendly_name, p_sd );
int k = strlen( CONTENT_DIRECTORY_SERVICE_TYPE ) - 1;
if ( strncmp( CONTENT_DIRECTORY_SERVICE_TYPE,
psz_service_type, k ) )
continue;
if ( !p_sd->p_sys->p_server_list->addServer( p_server ) )
const char* psz_control_url = xml_getChildElementValue( p_service_element,
"controlURL" );
if ( !psz_control_url )
{
delete p_server;
p_server = 0;
msg_Warn( p_sd_, "No control url found." );
continue;
}
/* Check for ContentDirectory service. */
IXML_NodeList* p_service_list =
ixmlElement_getElementsByTagName( p_device_element,
"service" );
if ( p_service_list )
/* Try to browse content directory. */
char* psz_url = ( char* ) malloc( strlen( psz_base_url ) + strlen( psz_control_url ) + 1 );
if ( psz_url )
{
for ( unsigned int j = 0;
j < ixmlNodeList_length( p_service_list ); j++ )
if ( UpnpResolveURL( psz_base_url, psz_control_url, psz_url ) == UPNP_E_SUCCESS )
{
IXML_Element* p_service_element =
( IXML_Element* ) ixmlNodeList_item( p_service_list, j );
SD::MediaServerDesc* p_server = new(std::nothrow) SD::MediaServerDesc( psz_udn,
psz_friendly_name, psz_url );
free( psz_url );
if ( unlikely( !p_server ) )
break;
const char* psz_service_type =
xml_getChildElementValue( p_service_element,
"serviceType" );
if ( !psz_service_type )
if ( !addServer( p_server ) )
{
msg_Warn( p_sd, "No service type found." );
delete p_server;
continue;
}
}
else
free( psz_url );
}
}
ixmlNodeList_free( p_service_list );
}
ixmlNodeList_free( p_device_list );
}
int k = strlen( CONTENT_DIRECTORY_SERVICE_TYPE ) - 1;
if ( strncmp( CONTENT_DIRECTORY_SERVICE_TYPE,
psz_service_type, k ) != 0 )
continue;
void MediaServerList::removeServer( const std::string& udn )
{
vlc_mutex_locker lock( &lock_ );
p_server->_i_content_directory_service_version =
psz_service_type[k];
MediaServerDesc* p_server = getServer( udn );
if ( !p_server )
return;
const char* psz_event_sub_url =
xml_getChildElementValue( p_service_element,
"eventSubURL" );
if ( !psz_event_sub_url )
{
msg_Warn( p_sd, "No event subscription url found." );
continue;
}
msg_Dbg( p_sd_, "Removing server '%s'", p_server->friendlyName.c_str() );
const char* psz_control_url =
xml_getChildElementValue( p_service_element,
"controlURL" );
if ( !psz_control_url )
{
msg_Warn( p_sd, "No control url found." );
continue;
}
assert(p_server->inputItem);
services_discovery_RemoveItem( p_sd_, p_server->inputItem );
/* Try to subscribe to ContentDirectory service */
std::vector<MediaServerDesc*>::iterator it = std::find(list_.begin(), list_.end(), p_server);
if (it != list_.end())
{
list_.erase( it );
}
delete p_server;
}
char* psz_url = ( char* ) malloc( strlen( psz_base_url ) +
strlen( psz_event_sub_url ) + 1 );
if ( psz_url )
{
if ( UpnpResolveURL( psz_base_url, psz_event_sub_url, psz_url ) ==
UPNP_E_SUCCESS )
{
p_server->setContentDirectoryEventURL( psz_url );
p_server->subscribeToContentDirectory();
}
free( psz_url );
}
/*
* Handles servers listing UPnP events
*/
int MediaServerList::Callback( Upnp_EventType event_type, void* p_event, void* p_user_data )
{
MediaServerList* self = static_cast<MediaServerList*>( p_user_data );
services_discovery_t* p_sd = self->p_sd_;
switch( event_type )
{
case UPNP_DISCOVERY_ADVERTISEMENT_ALIVE:
case UPNP_DISCOVERY_SEARCH_RESULT:
{
struct Upnp_Discovery* p_discovery = ( struct Upnp_Discovery* )p_event;
IXML_Document *p_description_doc = NULL;
int i_res;
i_res = UpnpDownloadXmlDoc( p_discovery->Location, &p_description_doc );
if ( i_res != UPNP_E_SUCCESS )
{
msg_Warn( p_sd, "Could not download device description! "
"Fetching data from %s failed: %s",
p_discovery->Location, UpnpGetErrorMessage( i_res ) );
return i_res;
}
self->parseNewServer( p_description_doc, p_discovery->Location );
ixmlDocument_free( p_description_doc );
}
break;
/* Try to browse content directory. */
case UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE:
{
struct Upnp_Discovery* p_discovery = ( struct Upnp_Discovery* )p_event;
psz_url = ( char* ) malloc( strlen( psz_base_url ) +
strlen( psz_control_url ) + 1 );
if ( psz_url )
{
if ( UpnpResolveURL( psz_base_url, psz_control_url, psz_url ) ==
UPNP_E_SUCCESS )
{
p_server->setContentDirectoryControlURL( psz_url );
p_server->fetchContents();
}
free( psz_url );
}
}
ixmlNodeList_free( p_service_list );
}
}
ixmlNodeList_free( p_device_list );
self->removeServer( p_discovery->DeviceId );
}
}
MediaServer::MediaServer( const char* psz_udn,
const char* psz_friendly_name,
services_discovery_t* p_sd )
{
_p_sd = p_sd;
break;
_UDN = psz_udn;
_friendly_name = psz_friendly_name;
case UPNP_EVENT_SUBSCRIBE_COMPLETE:
msg_Warn( p_sd, "subscription complete" );
break;
_p_contents = NULL;
_p_input_item = NULL;
_i_content_directory_service_version = 1;
}
case UPNP_DISCOVERY_SEARCH_TIMEOUT:
msg_Warn( p_sd, "search timeout" );
break;
MediaServer::~MediaServer()
{
delete _p_contents;
}
case UPNP_EVENT_RECEIVED:
case UPNP_EVENT_AUTORENEWAL_FAILED:
case UPNP_EVENT_SUBSCRIPTION_EXPIRED:
// Those are for the access part
break;
const char* MediaServer::getUDN() const
{
return _UDN.c_str();
}
default:
msg_Err( p_sd, "Unhandled event, please report ( type=%d )", event_type );
break;
}
const char* MediaServer::getFriendlyName() const
{
return _friendly_name.c_str();
return UPNP_E_SUCCESS;
}
void MediaServer::setContentDirectoryEventURL( const char* psz_url )
{
_content_directory_event_url = psz_url;
}
const char* MediaServer::getContentDirectoryEventURL() const
namespace Access
{
return _content_directory_event_url.c_str();
}
void MediaServer::setContentDirectoryControlURL( const char* psz_url )
MediaServer::MediaServer(const char *psz_url, access_t *p_access, input_item_node_t *node)
: url_( psz_url )
, access_( p_access )
, node_( node )
{
_content_directory_control_url = psz_url;
}
const char* MediaServer::getContentDirectoryControlURL() const
void MediaServer::addItem(const char *objectID, const char *title )
{
return _content_directory_control_url.c_str();
}
vlc_url_t url;
vlc_UrlParse( &url, url_.c_str(), '?' );
char* psz_url;
/**
* Subscribes current client handle to Content Directory Service.
* CDS exports the server shares to clients.
*/
void MediaServer::subscribeToContentDirectory()
{
const char* psz_url = getContentDirectoryEventURL();
if ( !psz_url )
if (asprintf( &psz_url, "upnp://%s://%s:%u%s?ObjectID=%s", url.psz_protocol,
url.psz_host, url.i_port ? url.i_port : 80, url.psz_path, objectID ) < 0 )
{
msg_Dbg( _p_sd, "No subscription url set!" );
return;
vlc_UrlClean( &url );
return ;
}
vlc_UrlClean( &url );
int i_timeout = 1810;
Upnp_SID sid;
int i_res = UpnpSubscribe( _p_sd->p_sys->client_handle, psz_url, &i_timeout, sid );
input_item_t* p_item = input_item_NewWithType( psz_url, title, 0, NULL,
0, -1, ITEM_TYPE_NODE );
free( psz_url);
if ( !p_item )
return;
input_item_CopyOptions( node_->p_item, p_item );
input_item_node_AppendItem( node_, p_item );
input_item_Release( p_item );
}
if ( i_res == UPNP_E_SUCCESS )
{
_i_subscription_timeout = i_timeout;
memcpy( _subscription_id, sid, sizeof( Upnp_SID ) );
}
else
{
msg_Dbg( _p_sd, "Subscribe failed: '%s': %s",
getFriendlyName(), UpnpGetErrorMessage( i_res ) );
}
void MediaServer::addItem(const char* title, const char*, const char*,
mtime_t duration, const char* psz_url)
{
input_item_t* p_item = input_item_NewExt( psz_url, title, 0, NULL, 0, duration );
input_item_node_AppendItem( node_, p_item );
input_item_Release( p_item );
}
/*
* Constructs UpnpAction to browse available content.
*/
/* Access part */
IXML_Document* MediaServer::_browseAction( const char* psz_object_id_,
const char* psz_browser_flag_,
const char* psz_filter_,
const char* psz_starting_index_,
const char* psz_requested_count_,
const char* psz_sort_criteria_ )
{
IXML_Document* p_action = 0;
IXML_Document* p_response = 0;
const char* psz_url = getContentDirectoryControlURL();
IXML_Document* p_action = NULL;
IXML_Document* p_response = NULL;
const char* psz_url = url_.c_str();
if ( !psz_url )
if ( url_.empty() )
{
msg_Dbg( _p_sd, "No subscription url set!" );
return 0;
msg_Dbg( access_, "No subscription url set!" );
return NULL;
}
char* psz_service_type = strdup( CONTENT_DIRECTORY_SERVICE_TYPE );
psz_service_type[strlen( psz_service_type ) - 1] =
_i_content_directory_service_version;
int i_res;
i_res = UpnpAddToAction( &p_action, "Browse",
psz_service_type, "ObjectID", psz_object_id_ );
CONTENT_DIRECTORY_SERVICE_TYPE, "ObjectID", psz_object_id_ );
if ( i_res != UPNP_E_SUCCESS )
{
msg_Dbg( _p_sd, "AddToAction 'ObjectID' failed: %s",
msg_Dbg( access_, "AddToAction 'ObjectID' failed: %s",
UpnpGetErrorMessage( i_res ) );
goto browseActionCleanup;
}
i_res = UpnpAddToAction( &p_action, "Browse",
psz_service_type, "BrowseFlag", psz_browser_flag_ );
CONTENT_DIRECTORY_SERVICE_TYPE, "StartingIndex", "0" );
if ( i_res != UPNP_E_SUCCESS )
{
msg_Dbg( _p_sd, "AddToAction 'BrowseFlag' failed: %s",
msg_Dbg( access_, "AddToAction 'StartingIndex' failed: %s",
UpnpGetErrorMessage( i_res ) );
goto browseActionCleanup;
}
i_res = UpnpAddToAction( &p_action, "Browse",
psz_service_type, "Filter", psz_filter_ );
CONTENT_DIRECTORY_SERVICE_TYPE, "BrowseFlag", psz_browser_flag_ );
if ( i_res != UPNP_E_SUCCESS )
{
msg_Dbg( _p_sd, "AddToAction 'Filter' failed: %s",
msg_Dbg( access_, "AddToAction 'BrowseFlag' failed: %s",
UpnpGetErrorMessage( i_res ) );
goto browseActionCleanup;
}
i_res = UpnpAddToAction( &p_action, "Browse",
psz_service_type, "StartingIndex", psz_starting_index_ );
CONTENT_DIRECTORY_SERVICE_TYPE, "Filter", psz_filter_ );
if ( i_res != UPNP_E_SUCCESS )
{
msg_Dbg( _p_sd, "AddToAction 'StartingIndex' failed: %s",
msg_Dbg( access_, "AddToAction 'Filter' failed: %s",
UpnpGetErrorMessage( i_res ) );
goto browseActionCleanup;
}
i_res = UpnpAddToAction( &p_action, "Browse",
psz_service_type, "RequestedCount", psz_requested_count_ );
CONTENT_DIRECTORY_SERVICE_TYPE, "RequestedCount", psz_requested_count_ );
if ( i_res != UPNP_E_SUCCESS )
{
msg_Dbg( _p_sd, "AddToAction 'RequestedCount' failed: %s",
msg_Dbg( access_, "AddToAction 'RequestedCount' failed: %s",
UpnpGetErrorMessage( i_res ) );
goto browseActionCleanup;
}
i_res = UpnpAddToAction( &p_action, "Browse",
psz_service_type, "SortCriteria", psz_sort_criteria_ );
CONTENT_DIRECTORY_SERVICE_TYPE, "SortCriteria", psz_sort_criteria_ );
if ( i_res != UPNP_E_SUCCESS )
{
msg_Dbg( _p_sd, "AddToAction 'SortCriteria' failed: %s",
msg_Dbg( access_, "AddToAction 'SortCriteria' failed: %s",
UpnpGetErrorMessage( i_res ) );
goto browseActionCleanup;
}
i_res = UpnpSendAction( _p_sd->p_sys->client_handle,
i_res = UpnpSendAction( access_->p_sys->p_upnp->handle(),
psz_url,
psz_service_type,
0, /* ignored in SDK, must be NULL */
CONTENT_DIRECTORY_SERVICE_TYPE,
NULL, /* ignored in SDK, must be NULL */
p_action,
&p_response );
if ( i_res != UPNP_E_SUCCESS )
{
msg_Err( _p_sd, "%s when trying the send() action with URL: %s",
msg_Err( access_, "%s when trying the send() action with URL: %s",
UpnpGetErrorMessage( i_res ), psz_url );
ixmlDocument_free( p_response );
p_response = 0;
p_response = NULL;
}
browseActionCleanup:
free( psz_service_type );
ixmlDocument_free( p_action );
return p_response;
}
void MediaServer::fetchContents()
{
/* Delete previous contents to prevent duplicate entries */
if ( _p_contents )
{
delete _p_contents;
services_discovery_RemoveItem( _p_sd, _p_input_item );
services_discovery_AddItem( _p_sd, _p_input_item, NULL );
}
Container* root = new Container( 0, "0", getFriendlyName() );
_fetchContents( root, 0 );
_p_contents = root;
_p_contents->setInputItem( _p_input_item );
_buildPlaylist( _p_contents, NULL );
}
/*
* Fetches and parses the UPNP response
*/
bool MediaServer::_fetchContents( Container* p_parent, int i_offset )
bool MediaServer::fetchContents()
{
if (!p_parent)
{
msg_Err( _p_sd, "No parent" );
return false;
}
const char* objectID = "";
vlc_url_t url;
vlc_UrlParse( &url, access_->psz_location, '?');
char* psz_starting_index;
if( asprintf( &psz_starting_index, "%d", i_offset ) < 0 )
if ( url.psz_option && !strncmp( url.psz_option, "ObjectID=", strlen( "ObjectID=" ) ) )
{
msg_Err( _p_sd, "asprintf error:%d", i_offset );
return false;
objectID = &url.psz_option[strlen( "ObjectID=" )];
}
IXML_Document* p_response = _browseAction( p_parent->getObjectID(),
IXML_Document* p_response = _browseAction( objectID,
"BrowseDirectChildren",
"id,dc:title,res," /* Filter */
"sec:CaptionInfo,sec:CaptionInfoEx,"
"pv:subtitlefile",
psz_starting_index, /* StartingIndex */
"0", /* RequestedCount */
"" /* SortCriteria */
);
free( psz_starting_index );
vlc_UrlClean( &url );
if ( !p_response )
{
msg_Err( _p_sd, "No response from browse() action" );
msg_Err( access_, "No response from browse() action" );
return false;
}
IXML_Document* p_result = parseBrowseResult( p_response );
int i_number_returned = xml_getNumber( p_response, "NumberReturned" );
int i_total_matches = xml_getNumber( p_response , "TotalMatches" );
#ifndef NDEBUG
msg_Dbg( _p_sd, "i_offset[%d]i_number_returned[%d]_total_matches[%d]\n",
i_offset, i_number_returned, i_total_matches );
#endif
ixmlDocument_free( p_response );
if ( !p_result )
{
msg_Err( _p_sd, "browse() response parsing failed" );
msg_Err( access_, "browse() response parsing failed" );
return false;
}
#ifndef NDEBUG
msg_Dbg( _p_sd, "Got DIDL document: %s", ixmlPrintDocument( p_result ) );
msg_Dbg( access_, "Got DIDL document: %s", ixmlPrintDocument( p_result ) );
#endif
IXML_NodeList* containerNodeList =
......@@ -864,11 +714,9 @@ bool MediaServer::_fetchContents( Container* p_parent, int i_offset )
if ( containerNodeList )
{
for ( unsigned int i = 0;
i < ixmlNodeList_length( containerNodeList ); i++ )
for ( unsigned int i = 0; i < ixmlNodeList_length( containerNodeList ); i++ )
{
IXML_Element* containerElement =
( IXML_Element* )ixmlNodeList_item( containerNodeList, i );
IXML_Element* containerElement = (IXML_Element*)ixmlNodeList_item( containerNodeList, i );
const char* objectID = ixmlElement_getAttribute( containerElement,
"id" );
......@@ -877,13 +725,9 @@ bool MediaServer::_fetchContents( Container* p_parent, int i_offset )
const char* title = xml_getChildElementValue( containerElement,
"dc:title" );
if ( !title )
continue;
Container* container = new Container( p_parent, objectID, title );
p_parent->addContainer( container );
_fetchContents( container, 0 );
addItem(objectID, title);
}
ixmlNodeList_free( containerNodeList );
}
......@@ -944,443 +788,188 @@ bool MediaServer::_fetchContents( Container* p_parent, int i_offset )
i_seconds );
}
Item* item = new Item( p_parent, objectID, title, psz_resource_url, psz_subtitles, i_duration );
p_parent->addItem( item );
addItem( title, objectID, psz_subtitles, i_duration, psz_resource_url );
}
ixmlNodeList_free( p_resource_list );
}
else continue;
else
continue;
}
ixmlNodeList_free( itemNodeList );
}
ixmlDocument_free( p_result );
if( i_offset + i_number_returned < i_total_matches )
return _fetchContents( p_parent, i_offset + i_number_returned );
return true;
}
// TODO: Create a permanent fix for the item duplication bug. The current fix
// is essentially only a small hack. Although it fixes the problem, it introduces
// annoying cosmetic issues with the playlist. For example, when the UPnP Server
// rebroadcasts it's directory structure, the VLC Client deletes the old directory
// structure, causing the user to go back to the root node of the directory. The
// directory is then rebuilt, and the user is forced to traverse through the directory
// to find the item they were looking for. Some servers may not push the directory
// structure too often, but we cannot rely on this fix.
//
// I have thought up another fix, but this would require certain features to
// be present within the VLC services discovery. Currently, services_discovery_AddItem
// does not allow the programmer to nest items. It only allows a "2 deep" scope.
// An example of the limitation is below:
//
// Root Directory
// + Item 1
// + Item 2
//
// services_discovery_AddItem will not let the programmer specify a child-node to
// insert items into, so we would not be able to do the following:
//
// Root Directory
// + Item 1
// + Sub Item 1
// + Item 2
// + Sub Item 1 of Item 2
// + Sub-Sub Item 1 of Sub Item 1
//
// This creates a HUGE limitation on what we are able to do. If we were able to do
// the above, we could simply preserve the old directory listing, and compare what items
// do not exist in the new directory listing, then remove them from the shown listing using
// services_discovery_RemoveItem. If new files were introduced within an already existing
// container, we could simply do so with services_discovery_AddItem.
/*
* Builds playlist based on available input items.
*/
void MediaServer::_buildPlaylist( Container* p_parent, input_item_node_t *p_input_node )
static int ReadDirectory( access_t *p_access, input_item_node_t* p_node )
{
bool b_send = p_input_node == NULL;
if( b_send )
p_input_node = input_item_node_Create( p_parent->getInputItem() );
for ( unsigned int i = 0; i < p_parent->getNumContainers(); i++ )
{
Container* p_container = p_parent->getContainer( i );
input_item_t* p_input_item = input_item_New( "vlc://nop",
p_container->getTitle() );
input_item_node_t *p_new_node =
input_item_node_AppendItem( p_input_node, p_input_item );
MediaServer server( p_access->psz_location, p_access, p_node );
p_container->setInputItem( p_input_item );
_buildPlaylist( p_container, p_new_node );
}
if ( !server.fetchContents() )
return VLC_EGENERIC;
return VLC_SUCCESS;
}
for ( unsigned int i = 0; i < p_parent->getNumItems(); i++ )
static int Control( access_t *, int i_query, va_list args )
{
switch ( i_query )
{
Item* p_item = p_parent->getItem( i );
char **ppsz_opts = NULL;
char *psz_input_slave = p_item->buildInputSlaveOption();
if( psz_input_slave )
{
ppsz_opts = (char**)malloc( 2 * sizeof( char* ) );
ppsz_opts[0] = psz_input_slave;
ppsz_opts[1] = p_item->buildSubTrackIdOption();
}
input_item_t* p_input_item = input_item_NewExt( p_item->getResource(),
p_item->getTitle(),
psz_input_slave ? 2 : 0,
psz_input_slave ? ppsz_opts : NULL,
VLC_INPUT_OPTION_TRUSTED, /* XXX */
p_item->getDuration() );
case ACCESS_CAN_SEEK:
case ACCESS_CAN_FASTSEEK:
case ACCESS_CAN_PAUSE:
case ACCESS_CAN_CONTROL_PACE:
*va_arg( args, bool* ) = false;
break;
assert( p_input_item );
if( ppsz_opts )
{
free( ppsz_opts[0] );
free( ppsz_opts[1] );
free( ppsz_opts );
case ACCESS_GET_SIZE:
{
*va_arg( args, uint64_t * ) = 0;
break;
}
case ACCESS_GET_PTS_DELAY:
*va_arg( args, int64_t * ) = 0;
break;
psz_input_slave = NULL;
}
case ACCESS_SET_PAUSE_STATE:
/* Nothing to do */
break;
input_item_node_AppendItem( p_input_node, p_input_item );
p_item->setInputItem( p_input_item );
default:
return VLC_EGENERIC;
}
if( b_send )
input_item_node_PostAndDelete( p_input_node );
return VLC_SUCCESS;
}
void MediaServer::setInputItem( input_item_t* p_input_item )
static int Open( vlc_object_t *p_this )
{
if( _p_input_item == p_input_item )
return;
access_t* p_access = (access_t*)p_this;
access_sys_t* p_sys = new(std::nothrow) access_sys_t;
if ( unlikely( !p_sys ) )
return VLC_ENOMEM;
if( _p_input_item )
vlc_gc_decref( _p_input_item );
p_access->p_sys = p_sys;
p_sys->p_upnp = UpnpInstanceWrapper::get( p_this, NULL, NULL );
if ( !p_sys->p_upnp )
{
delete p_sys;
return VLC_EGENERIC;
}
vlc_gc_incref( p_input_item );
_p_input_item = p_input_item;
}
p_access->pf_readdir = ReadDirectory;
ACCESS_SET_CALLBACKS( NULL, NULL, Control, NULL );
input_item_t* MediaServer::getInputItem() const
{
return _p_input_item;
return VLC_SUCCESS;
}
bool MediaServer::compareSID( const char* psz_sid )
static void Close( vlc_object_t* p_this )
{
return ( strncmp( _subscription_id, psz_sid, sizeof( Upnp_SID ) ) == 0 );
access_t* p_access = (access_t*)p_this;
p_access->p_sys->p_upnp->release( false );
delete p_access->p_sys;
}
/*
* MediaServerList class
*/
MediaServerList::MediaServerList( services_discovery_t* p_sd )
{
_p_sd = p_sd;
}
MediaServerList::~MediaServerList()
UpnpInstanceWrapper::UpnpInstanceWrapper()
: handle_( -1 )
, opaque_( NULL )
, callback_( NULL )
, refcount_( 0 )
{
for ( unsigned int i = 0; i < _list.size(); i++ )
{
delete _list[i];
}
}
bool MediaServerList::addServer( MediaServer* p_server )
UpnpInstanceWrapper::~UpnpInstanceWrapper()
{
input_item_t* p_input_item = NULL;
if ( getServer( p_server->getUDN() ) != 0 ) return false;
msg_Dbg( _p_sd, "Adding server '%s' with uuid '%s'", p_server->getFriendlyName(), p_server->getUDN() );
p_input_item = input_item_New( "vlc://nop", p_server->getFriendlyName() );
input_item_SetDescription( p_input_item, p_server->getUDN() );
p_server->setInputItem( p_input_item );
services_discovery_AddItem( _p_sd, p_input_item, NULL );
_list.push_back( p_server );
return true;
UpnpUnRegisterClient( handle_ );
UpnpFinish();
}
MediaServer* MediaServerList::getServer( const char* psz_udn )
UpnpInstanceWrapper *UpnpInstanceWrapper::get(vlc_object_t *p_obj, Upnp_FunPtr callback, SD::MediaServerList *opaque)
{
MediaServer* p_result = 0;
for ( unsigned int i = 0; i < _list.size(); i++ )
vlc_mutex_locker lock( &s_lock );
if ( s_instance == NULL )
{
if( strcmp( psz_udn, _list[i]->getUDN() ) == 0 )
UpnpInstanceWrapper* instance = new(std::nothrow) UpnpInstanceWrapper;
if ( unlikely( !instance ) )
return NULL;
#ifdef UPNP_ENABLE_IPV6
char* psz_miface = var_InheritString( p_obj, "miface" );
msg_Info( p_obj, "Initializing libupnp on '%s' interface", psz_miface );
int i_res = UpnpInit2( psz_miface, 0 );
free( psz_miface );
#else
/* If UpnpInit2 isnt available, initialize on first IPv4-capable interface */
int i_res = UpnpInit( 0, 0 );
#endif
if( i_res != UPNP_E_SUCCESS )
{
p_result = _list[i];
break;
msg_Err( p_obj, "Initialization failed: %s", UpnpGetErrorMessage( i_res ) );
delete instance;
return NULL;
}
}
return p_result;
}
MediaServer* MediaServerList::getServerBySID( const char* psz_sid )
{
MediaServer* p_server = 0;
ixmlRelaxParser( 1 );
for ( unsigned int i = 0; i < _list.size(); i++ )
{
if ( _list[i]->compareSID( psz_sid ) )
/* Register a control point */
i_res = UpnpRegisterClient( Callback, instance, &instance->handle_ );
if( i_res != UPNP_E_SUCCESS )
{
p_server = _list[i];
break;
msg_Err( p_obj, "Client registration failed: %s", UpnpGetErrorMessage( i_res ) );
delete instance;
return NULL;
}
}
return p_server;
}
void MediaServerList::removeServer( const char* psz_udn )
{
MediaServer* p_server = getServer( psz_udn );
if ( !p_server ) return;
msg_Dbg( _p_sd, "Removing server '%s'", p_server->getFriendlyName() );
services_discovery_RemoveItem( _p_sd, p_server->getInputItem() );
std::vector<MediaServer*>::iterator it;
for ( it = _list.begin(); it != _list.end(); ++it )
{
if ( *it == p_server )
/* libupnp does not treat a maximum content length of 0 as unlimited
* until 64dedf (~ pupnp v1.6.7) and provides no sane way to discriminate
* between versions */
if( (i_res = UpnpSetMaxContentLength( INT_MAX )) != UPNP_E_SUCCESS )
{
_list.erase( it );
delete p_server;
break;
msg_Err( p_obj, "Failed to set maximum content length: %s",
UpnpGetErrorMessage( i_res ));
delete instance;
return NULL;
}
s_instance = instance;
}
}
/*
* Item class
*/
Item::Item( Container* p_parent,
const char* psz_object_id, const char* psz_title,
const char* psz_resource, const char* psz_subtitles,
mtime_t i_duration )
{
_parent = p_parent;
_objectID = psz_object_id;
_title = psz_title;
_resource = psz_resource;
_subtitles = psz_subtitles ? psz_subtitles : "";
_duration = i_duration;
_p_input_item = NULL;
}
Item::~Item()
{
if( _p_input_item )
vlc_gc_decref( _p_input_item );
}
const char* Item::getObjectID() const
{
return _objectID.c_str();
}
const char* Item::getTitle() const
{
return _title.c_str();
}
const char* Item::getResource() const
{
return _resource.c_str();
}
const char* Item::getSubtitles() const
{
if( !_subtitles.size() )
return NULL;
return _subtitles.c_str();
}
mtime_t Item::getDuration() const
{
return _duration;
}
char* Item::buildInputSlaveOption() const
{
const char *psz_subtitles = getSubtitles();
const char *psz_scheme_delim = "://";
const char *psz_sub_opt_fmt = ":input-slave=%s/%s://%s";
const char *psz_demux = "subtitle";
char *psz_uri_scheme = NULL;
const char *psz_scheme_end = NULL;
const char *psz_uri_location = NULL;
char *psz_input_slave = NULL;
size_t i_scheme_len;
if( !psz_subtitles )
return NULL;
psz_scheme_end = strstr( psz_subtitles, psz_scheme_delim );
/* subtitles not being an URI would make no sense */
if( !psz_scheme_end )
return NULL;
i_scheme_len = psz_scheme_end - psz_subtitles;
psz_uri_scheme = (char*)malloc( i_scheme_len + 1 );
if( !psz_uri_scheme )
return NULL;
memcpy( psz_uri_scheme, psz_subtitles, i_scheme_len );
psz_uri_scheme[i_scheme_len] = '\0';
/* If the subtitles try to force a vlc demux,
* then something is very wrong */
if( strchr( psz_uri_scheme, '/' ) )
s_instance->refcount_++;
// This assumes a single UPNP SD instance
if (callback && opaque)
{
free( psz_uri_scheme );
return NULL;
assert(!s_instance->callback_ && !s_instance->opaque_);
s_instance->opaque_ = opaque;
s_instance->callback_ = callback;
}
psz_uri_location = psz_scheme_end + strlen( psz_scheme_delim );
if( -1 == asprintf( &psz_input_slave, psz_sub_opt_fmt,
psz_uri_scheme, psz_demux, psz_uri_location ) )
psz_input_slave = NULL;
free( psz_uri_scheme );
return psz_input_slave;
}
char* Item::buildSubTrackIdOption() const
{
return strdup( ":sub-track-id=2" );
}
void Item::setInputItem( input_item_t* p_input_item )
{
if( _p_input_item == p_input_item )
return;
if( _p_input_item )
vlc_gc_decref( _p_input_item );
vlc_gc_incref( p_input_item );
_p_input_item = p_input_item;
}
/*
* Container class
*/
Container::Container( Container* p_parent,
const char* psz_object_id,
const char* psz_title )
{
_parent = p_parent;
_objectID = psz_object_id;
_title = psz_title;
_p_input_item = NULL;
return s_instance;
}
Container::~Container()
void UpnpInstanceWrapper::release(bool isSd)
{
for ( unsigned int i = 0; i < _containers.size(); i++ )
vlc_mutex_locker lock( &s_lock );
if ( isSd )
{
delete _containers[i];
callback_ = NULL;
opaque_ = NULL;
}
for ( unsigned int i = 0; i < _items.size(); i++ )
if (--s_instance->refcount_ == 0)
{
delete _items[i];
delete s_instance;
s_instance = NULL;
}
if( _p_input_item )
vlc_gc_decref( _p_input_item );
}
void Container::addItem( Item* item )
UpnpClient_Handle UpnpInstanceWrapper::handle() const
{
_items.push_back( item );
return handle_;
}
void Container::addContainer( Container* p_container )
int UpnpInstanceWrapper::Callback(Upnp_EventType event_type, void *p_event, void *p_user_data)
{
_containers.push_back( p_container );
}
const char* Container::getObjectID() const
{
return _objectID.c_str();
}
const char* Container::getTitle() const
{
return _title.c_str();
}
unsigned int Container::getNumItems() const
{
return _items.size();
}
unsigned int Container::getNumContainers() const
{
return _containers.size();
}
Item* Container::getItem( unsigned int i_index ) const
{
if ( i_index < _items.size() ) return _items[i_index];
return 0;
}
Container* Container::getContainer( unsigned int i_index ) const
{
if ( i_index < _containers.size() ) return _containers[i_index];
UpnpInstanceWrapper* self = static_cast<UpnpInstanceWrapper*>( p_user_data );
vlc_mutex_locker lock( &self->s_lock );
if ( !self->callback_ )
return 0;
self->callback_( event_type, p_event, self->opaque_ );
return 0;
}
Container* Container::getParent()
{
return _parent;
}
void Container::setInputItem( input_item_t* p_input_item )
{
if( _p_input_item == p_input_item )
return;
if( _p_input_item )
vlc_gc_decref( _p_input_item );
vlc_gc_incref( p_input_item );
_p_input_item = p_input_item;
}
input_item_t* Container::getInputItem() const
{
return _p_input_item;
}
modules/services_discovery/upnp.hpp
View file @ f7dfc8f1
......@@ -7,6 +7,7 @@
* Authors: Rémi Denis-Courmont <rem # videolan.org> (original plugin)
* Christian Henz <henz # c-lab.de>
* Mirsal Ennaime <mirsal dot ennaime at gmail dot com>
* Hugo Beauzée-Luyssen <hugo@beauzee.fr>
*
* UPnP Plugin using the Intel SDK (libupnp) instead of CyberLink
*
......@@ -33,62 +34,55 @@
#include <vlc_common.h>
// Classes
class Container;
class MediaServer
namespace SD
{
public:
static void parseDeviceDescription( IXML_Document* p_doc,
const char* psz_location,
services_discovery_t* p_sd );
MediaServer( const char* psz_udn,
const char* psz_friendly_name,
services_discovery_t* p_sd );
~MediaServer();
const char* getUDN() const;
const char* getFriendlyName() const;
void setContentDirectoryEventURL( const char* psz_url );
const char* getContentDirectoryEventURL() const;
void setContentDirectoryControlURL( const char* psz_url );
const char* getContentDirectoryControlURL() const;
void subscribeToContentDirectory();
void fetchContents();
void setInputItem( input_item_t* p_input_item );
input_item_t* getInputItem() const;
bool compareSID( const char* psz_sid );
class MediaServerList;
}
/*
* libUpnp allows only one instance per process, so we have to share one for
* both SD & Access module
* Since the callback is bound to the UpnpClient_Handle, we have to register
* a wrapper callback, in order for the access module to be able to initialize
* libUpnp first.
* When a SD wishes to use libUpnp, it will provide its own callback, that the
* wrapper will forward.
* This way, we always have a register callback & a client handle.
*/
class UpnpInstanceWrapper
{
public:
// This increases the refcount before returning the instance
static UpnpInstanceWrapper* get(vlc_object_t* p_obj, Upnp_FunPtr callback, SD::MediaServerList *opaque);
void release(bool isSd);
UpnpClient_Handle handle() const;
private:
static int Callback( Upnp_EventType event_type, void* p_event, void* p_user_data );
bool _fetchContents( Container* p_parent, int i_starting_index );
void _buildPlaylist( Container* p_container, input_item_node_t *p_item_node );
IXML_Document* _browseAction( const char*, const char*,
const char*, const char*, const char*, const char* );
services_discovery_t* _p_sd;
Container* _p_contents;
input_item_t* _p_input_item;
UpnpInstanceWrapper();
~UpnpInstanceWrapper();
std::string _UDN;
std::string _friendly_name;
private:
static UpnpInstanceWrapper* s_instance;
static vlc_mutex_t s_lock;
UpnpClient_Handle handle_;
SD::MediaServerList* opaque_;
Upnp_FunPtr callback_;
int refcount_;
};
std::string _content_directory_event_url;
std::string _content_directory_control_url;
namespace SD
{
int _i_subscription_timeout;
int _i_content_directory_service_version;
Upnp_SID _subscription_id;
struct MediaServerDesc
{
MediaServerDesc(const std::string& udn, const std::string& fName, const std::string& loc);
~MediaServerDesc();
std::string UDN;
std::string friendlyName;
std::string location;
input_item_t* inputItem;
};
......@@ -99,87 +93,45 @@ public:
MediaServerList( services_discovery_t* p_sd );
~MediaServerList();
bool addServer( MediaServer* p_server );
void removeServer( const char* psz_udn );
MediaServer* getServer( const char* psz_udn );
MediaServer* getServerBySID( const char* psz_sid );
bool addServer(MediaServerDesc *desc );
void removeServer(const std::string &udn );
MediaServerDesc* getServer( const std::string& udn );
static int Callback( Upnp_EventType event_type, void* p_event, void* p_user_data );
private:
void parseNewServer( IXML_Document* doc, const std::string& location );
services_discovery_t* _p_sd;
std::vector<MediaServer*> _list;
private:
services_discovery_t* p_sd_;
std::vector<MediaServerDesc*> list_;
vlc_mutex_t lock_;
};
}
class Item
namespace Access
{
public:
Item( Container* parent,
const char* objectID,
const char* title,
const char* subtitles,
const char* resource,
mtime_t duration );
~Item();
const char* getObjectID() const;
const char* getTitle() const;
const char* getResource() const;
const char* getSubtitles() const;
char* buildInputSlaveOption() const;
char* buildSubTrackIdOption() const;
mtime_t getDuration() const;
void setInputItem( input_item_t* p_input_item );
private:
input_item_t* _p_input_item;
Container* _parent;
std::string _objectID;
std::string _title;
std::string _resource;
std::string _subtitles;
mtime_t _duration;
};
class Container
class MediaServer
{
public:
Container( Container* parent, const char* objectID, const char* title );
~Container();
void addItem( Item* item );
void addContainer( Container* container );
const char* getObjectID() const;
const char* getTitle() const;
unsigned int getNumItems() const;
unsigned int getNumContainers() const;
Item* getItem( unsigned int i ) const;
Container* getContainer( unsigned int i ) const;
Container* getParent();
void setInputItem( input_item_t* p_input_item );
input_item_t* getInputItem() const;
MediaServer( const char* psz_url, access_t* p_access, input_item_node_t* node );
bool fetchContents();
private:
MediaServer(const MediaServer&);
MediaServer& operator=(const MediaServer&);
input_item_t* _p_input_item;
void addItem(const char* objectID, const char* title);
void addItem(const char* title, const char* psz_objectID, const char* psz_subtitles, mtime_t duration, const char* psz_url );
Container* _parent;
IXML_Document* _browseAction(const char*, const char*,
const char*, const char*, const char* );
std::string _objectID;
std::string _title;
std::vector<Item*> _items;
std::vector<Container*> _containers;
private:
const std::string url_;
access_t* access_;
input_item_node_t* node_;
};
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment