df4807a78b0af07a76076027b294fa818200e173
[vlc.git] / modules / services_discovery / upnp_intel.cpp
1 /*****************************************************************************
2  * Upnp_intell.cpp :  UPnP discovery module (Intel SDK)
3  *****************************************************************************
4  * Copyright (C) 2004-2006 the VideoLAN team
5  * $Id$
6  *
7  * Authors: RĂ©mi Denis-Courmont <rem # videolan.org> (original plugin)
8  *          Christian Henz <henz # c-lab.de>
9  *
10  * UPnP Plugin using the Intel SDK (libupnp) instead of CyberLink
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25  *****************************************************************************/
26
27 /*
28   \TODO: Debug messages: "__FILE__, __LINE__" ok ???, Wrn/Err ???
29   \TODO: Change names to VLC standard ???
30   \TODO: Rewrite this using the new service discovery API (see sap.c, shout.c).
31 */
32
33
34 #include <vector>
35 #include <string>
36
37 #include <upnp/upnp.h>
38 #include <upnp/upnptools.h>
39
40 #undef PACKAGE_NAME
41 #ifdef HAVE_CONFIG_H
42 # include "config.h"
43 #endif
44
45 #include <vlc_common.h>
46 #include <vlc_plugin.h>
47 #include <vlc_playlist.h>
48
49
50 // VLC handle
51
52 struct services_discovery_sys_t
53 {
54     playlist_t *p_playlist;
55     playlist_item_t *p_node_cat;
56     playlist_item_t *p_node_one;
57 };
58
59
60 // Constants
61
62 const char* MEDIA_SERVER_DEVICE_TYPE = "urn:schemas-upnp-org:device:MediaServer:1";
63 const char* CONTENT_DIRECTORY_SERVICE_TYPE = "urn:schemas-upnp-org:service:ContentDirectory:1";
64
65
66 // Classes
67
68 class MediaServer;
69 class MediaServerList;
70 class Item;
71 class Container;
72
73 // Cookie that is passed to the callback
74
75 typedef struct
76 {
77     services_discovery_t* serviceDiscovery;
78     UpnpClient_Handle clientHandle;
79     MediaServerList* serverList;
80 } Cookie;
81
82
83 // Class definitions...
84
85 class Lockable
86 {
87 public:
88
89     Lockable( Cookie* c )
90     {
91     vlc_mutex_init( &_mutex );
92     }
93
94     ~Lockable()
95     {
96     vlc_mutex_destroy( &_mutex );
97     }
98
99     void lock() { vlc_mutex_lock( &_mutex ); }
100     void unlock() { vlc_mutex_unlock( &_mutex ); }
101
102 private:
103
104     vlc_mutex_t _mutex;
105 };
106
107
108 class Locker
109 {
110 public:
111     Locker( Lockable* l )
112     {
113     _lockable = l;
114     _lockable->lock();
115     }
116
117     ~Locker()
118     {
119     _lockable->unlock();
120     }
121
122 private:
123     Lockable* _lockable;
124 };
125
126
127 class MediaServer
128 {
129 public:
130
131     static void parseDeviceDescription( IXML_Document* doc, const char* location, Cookie* cookie );
132
133     MediaServer( const char* UDN, const char* friendlyName, Cookie* cookie );
134     ~MediaServer();
135
136     const char* getUDN() const;
137     const char* getFriendlyName() const;
138
139     void setContentDirectoryEventURL( const char* url );
140     const char* getContentDirectoryEventURL() const;
141
142     void setContentDirectoryControlURL( const char* url );
143     const char* getContentDirectoryControlURL() const;
144
145     void subscribeToContentDirectory();
146     void fetchContents();
147
148     void setPlaylistNode( playlist_item_t* node );
149
150     bool compareSID( const char* sid );
151
152 private:
153
154     bool _fetchContents( Container* parent );
155     void _buildPlaylist( Container* container );
156     IXML_Document* _browseAction( const char*, const char*, const char*, const char*, const char*, const char* );
157
158     Cookie* _cookie;
159
160     Container* _contents;
161     playlist_item_t* _playlistNode;
162
163     std::string _UDN;
164     std::string _friendlyName;
165
166     std::string _contentDirectoryEventURL;
167     std::string _contentDirectoryControlURL;
168
169     int _subscriptionTimeOut;
170     Upnp_SID _subscriptionID;
171 };
172
173
174 class MediaServerList
175 {
176 public:
177
178     MediaServerList( Cookie* cookie );
179     ~MediaServerList();
180
181     bool addServer( MediaServer* s );
182     void removeServer( const char* UDN );
183
184     MediaServer* getServer( const char* UDN );
185     MediaServer* getServerBySID( const char* );
186
187 private:
188
189     Cookie* _cookie;
190
191     std::vector<MediaServer*> _list;
192 };
193
194
195 class Item
196 {
197 public:
198
199     Item( Container* parent, const char* objectID, const char* title, const char* resource );
200
201     const char* getObjectID() const;
202     const char* getTitle() const;
203     const char* getResource() const;
204
205     void setPlaylistNode( playlist_item_t* node );
206     playlist_item_t* getPlaylistNode() const ;
207
208 private:
209
210     playlist_item_t* _playlistNode;
211
212     Container* _parent;
213     std::string _objectID;
214     std::string _title;
215     std::string _resource;
216 };
217
218
219 class Container
220 {
221 public:
222
223     Container( Container* parent, const char* objectID, const char* title );
224     ~Container();
225
226     void addItem( Item* item );
227     void addContainer( Container* container );
228
229     const char* getObjectID() const;
230     const char* getTitle() const;
231
232     unsigned int getNumItems() const;
233     unsigned int getNumContainers() const;
234
235     Item* getItem( unsigned int i ) const;
236     Container* getContainer( unsigned int i ) const;
237
238     void setPlaylistNode( playlist_item_t* node );
239     playlist_item_t* getPlaylistNode() const;
240
241 private:
242
243     playlist_item_t* _playlistNode;
244
245     Container* _parent;
246
247     std::string _objectID;
248     std::string _title;
249     std::vector<Item*> _items;
250     std::vector<Container*> _containers;
251 };
252
253
254 // VLC callback prototypes
255
256 static int Open( vlc_object_t* );
257 static void Close( vlc_object_t* );
258 static void Run( services_discovery_t *p_sd );
259 static playlist_t *pl_Get( services_discovery_t *p_sd )
260 {
261     return p_sd->p_sys->p_playlist;
262 }
263
264 // Module descriptor
265
266 vlc_module_begin();
267 set_shortname( "UPnP" );
268 set_description( N_( "Universal Plug'n'Play discovery ( Intel SDK )" ) );
269 set_category( CAT_PLAYLIST );
270 set_subcategory( SUBCAT_PLAYLIST_SD );
271 set_capability( "services_discovery", 0 );
272 set_callbacks( Open, Close );
273 vlc_module_end();
274
275
276 // More prototypes...
277
278 static Lockable* CallbackLock;
279 static int Callback( Upnp_EventType eventType, void* event, void* pCookie );
280
281 const char* xml_getChildElementValue( IXML_Element* parent, const char* tagName );
282 IXML_Document* parseBrowseResult( IXML_Document* doc );
283
284
285 // VLC callbacks...
286
287 static int Open( vlc_object_t *p_this )
288 {
289     services_discovery_t *p_sd = ( services_discovery_t* )p_this;
290     services_discovery_sys_t *p_sys  = ( services_discovery_sys_t * )
291     malloc( sizeof( services_discovery_sys_t ) );
292
293     p_sd->pf_run = Run;
294     p_sd->p_sys = p_sys;
295     p_sys->p_playlist = pl_Yield( p_sd );
296
297     /* Create our playlist node */
298     vlc_object_lock( p_sys->p_playlist );
299     playlist_NodesPairCreate( pl_Get( p_sd ), _("Devices"),
300                               &p_sys->p_node_cat, &p_sys->p_node_one,
301                               true );
302     vlc_object_unlock( p_sys->p_playlist );
303
304     return VLC_SUCCESS;
305 }
306
307 static void Close( vlc_object_t *p_this )
308 {
309     services_discovery_t *p_sd = ( services_discovery_t* )p_this;
310     services_discovery_sys_t *p_sys = p_sd->p_sys;
311
312     playlist_NodeDelete( pl_Get( p_sd ), p_sys->p_node_one, true,
313                          true );
314     playlist_NodeDelete( pl_Get( p_sd ), p_sys->p_node_cat, true,
315                          true );
316     pl_Release( p_sd );
317     free( p_sys );
318 }
319
320 static void Run( services_discovery_t* p_sd )
321 {
322     int res;
323
324     res = UpnpInit( 0, 0 );
325     if( res != UPNP_E_SUCCESS )
326     {
327         msg_Err( p_sd, "%s", UpnpGetErrorMessage( res ) );
328         return;
329     }
330
331     Cookie cookie;
332     cookie.serviceDiscovery = p_sd;
333     cookie.serverList = new MediaServerList( &cookie );
334
335     CallbackLock = new Lockable( &cookie );
336
337     res = UpnpRegisterClient( Callback, &cookie, &cookie.clientHandle );
338     if( res != UPNP_E_SUCCESS )
339     {
340         msg_Err( p_sd, "%s", UpnpGetErrorMessage( res ) );
341         goto shutDown;
342     }
343
344     res = UpnpSearchAsync( cookie.clientHandle, 5, MEDIA_SERVER_DEVICE_TYPE, &cookie );
345     if( res != UPNP_E_SUCCESS )
346     {
347         msg_Err( p_sd, "%s", UpnpGetErrorMessage( res ) );
348         goto shutDown;
349     }
350
351     msg_Dbg( p_sd, "UPnP discovery started" );
352     while( vlc_object_alive (p_sd) )
353     {
354         msleep( 500 );
355     }
356
357     msg_Dbg( p_sd, "UPnP discovery stopped" );
358
359  shutDown:
360     UpnpFinish();
361     delete cookie.serverList;
362     delete CallbackLock;
363 }
364
365
366 // XML utility functions:
367
368 // Returns the value of a child element, or 0 on error
369 const char* xml_getChildElementValue( IXML_Element* parent, const char* tagName )
370 {
371     if ( !parent ) return 0;
372     if ( !tagName ) return 0;
373
374     char* s = strdup( tagName );
375     IXML_NodeList* nodeList = ixmlElement_getElementsByTagName( parent, s );
376     free( s );
377     if ( !nodeList ) return 0;
378
379     IXML_Node* element = ixmlNodeList_item( nodeList, 0 );
380     ixmlNodeList_free( nodeList );
381     if ( !element ) return 0;
382
383     IXML_Node* textNode = ixmlNode_getFirstChild( element );
384     if ( !textNode ) return 0;
385
386     return ixmlNode_getNodeValue( textNode );
387 }
388
389 // Extracts the result document from a SOAP response
390 IXML_Document* parseBrowseResult( IXML_Document* doc )
391 {
392     if ( !doc ) return 0;
393
394     IXML_NodeList* resultList = ixmlDocument_getElementsByTagName( doc, "Result" );
395     if ( !resultList ) return 0;
396
397     IXML_Node* resultNode = ixmlNodeList_item( resultList, 0 );
398
399     ixmlNodeList_free( resultList );
400
401     if ( !resultNode ) return 0;
402
403     IXML_Node* textNode = ixmlNode_getFirstChild( resultNode );
404     if ( !textNode ) return 0;
405
406     const char* resultString = ixmlNode_getNodeValue( textNode );
407     char* resultXML = strdup( resultString );
408
409     IXML_Document* browseDoc = ixmlParseBuffer( resultXML );
410
411     free( resultXML );
412
413     return browseDoc;
414 }
415
416
417 // Handles all UPnP events
418 static int Callback( Upnp_EventType eventType, void* event, void* pCookie )
419 {
420     Locker locker( CallbackLock );
421
422     Cookie* cookie = ( Cookie* )pCookie;
423
424     switch( eventType ) {
425
426     case UPNP_DISCOVERY_ADVERTISEMENT_ALIVE:
427     case UPNP_DISCOVERY_SEARCH_RESULT:
428     {
429         struct Upnp_Discovery* discovery = ( struct Upnp_Discovery* )event;
430
431         IXML_Document *descriptionDoc = 0;
432
433         int res;
434         res = UpnpDownloadXmlDoc( discovery->Location, &descriptionDoc );
435         if ( res != UPNP_E_SUCCESS )
436         {
437           msg_Dbg( cookie->serviceDiscovery, "%s:%d: Could not download device description!", __FILE__, __LINE__ );
438           return res;
439         }
440
441         MediaServer::parseDeviceDescription( descriptionDoc, discovery->Location, cookie );
442
443         ixmlDocument_free( descriptionDoc );
444     }
445     break;
446
447     case UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE:
448     {
449         struct Upnp_Discovery* discovery = ( struct Upnp_Discovery* )event;
450
451         cookie->serverList->removeServer( discovery->DeviceId );
452     }
453     break;
454
455     case UPNP_EVENT_RECEIVED:
456     {
457         Upnp_Event* e = ( Upnp_Event* )event;
458
459         MediaServer* server = cookie->serverList->getServerBySID( e->Sid );
460         if ( server ) server->fetchContents();
461     }
462     break;
463
464     case UPNP_EVENT_AUTORENEWAL_FAILED:
465     case UPNP_EVENT_SUBSCRIPTION_EXPIRED:
466     {
467         // Re-subscribe...
468
469         Upnp_Event_Subscribe* s = ( Upnp_Event_Subscribe* )event;
470
471         MediaServer* server = cookie->serverList->getServerBySID( s->Sid );
472         if ( server ) server->subscribeToContentDirectory();
473     }
474     break;
475
476     case UPNP_EVENT_SUBSCRIBE_COMPLETE:
477         msg_Warn( cookie->serviceDiscovery, "subscription complete" );
478         break;
479  
480     case UPNP_DISCOVERY_SEARCH_TIMEOUT:
481         msg_Warn( cookie->serviceDiscovery, "search timeout" );
482         break;
483  
484     default:
485     msg_Dbg( cookie->serviceDiscovery, "%s:%d: DEBUG: UNHANDLED EVENT ( TYPE=%d )", __FILE__, __LINE__, eventType );
486     break;
487     }
488
489     return UPNP_E_SUCCESS;
490 }
491
492
493 // Class implementations...
494
495 // MediaServer...
496
497 void MediaServer::parseDeviceDescription( IXML_Document* doc, const char* location, Cookie* cookie )
498 {
499     if ( !doc ) { msg_Dbg( cookie->serviceDiscovery, "%s:%d: NULL", __FILE__, __LINE__ ); return; }
500     if ( !location ) { msg_Dbg( cookie->serviceDiscovery, "%s:%d: NULL", __FILE__, __LINE__ ); return; }
501
502     const char* baseURL = location;
503
504     // Try to extract baseURL
505
506     IXML_NodeList* urlList = ixmlDocument_getElementsByTagName( doc, "baseURL" );
507     if ( urlList )
508     {
509     if ( IXML_Node* urlNode = ixmlNodeList_item( urlList, 0 ) )
510     {
511         IXML_Node* textNode = ixmlNode_getFirstChild( urlNode );
512         if ( textNode ) baseURL = ixmlNode_getNodeValue( textNode );
513     }
514
515     ixmlNodeList_free( urlList );
516     }
517
518     // Get devices
519
520     IXML_NodeList* deviceList = ixmlDocument_getElementsByTagName( doc, "device" );
521     if ( deviceList )
522     {
523
524     for ( unsigned int i = 0; i < ixmlNodeList_length( deviceList ); i++ )
525     {
526         IXML_Element* deviceElement = ( IXML_Element* )ixmlNodeList_item( deviceList, i );
527
528         const char* deviceType = xml_getChildElementValue( deviceElement, "deviceType" );
529         if ( !deviceType ) { msg_Dbg( cookie->serviceDiscovery, "%s:%d: no deviceType!", __FILE__, __LINE__ ); continue; }
530         if ( strcmp( MEDIA_SERVER_DEVICE_TYPE, deviceType ) != 0 ) continue;
531
532         const char* UDN = xml_getChildElementValue( deviceElement, "UDN" );
533         if ( !UDN ) { msg_Dbg( cookie->serviceDiscovery, "%s:%d: no UDN!", __FILE__, __LINE__ ); continue; }
534         if ( cookie->serverList->getServer( UDN ) != 0 ) continue;
535
536         const char* friendlyName = xml_getChildElementValue( deviceElement, "friendlyName" );
537         if ( !friendlyName ) { msg_Dbg( cookie->serviceDiscovery, "%s:%d: no friendlyName!", __FILE__, __LINE__ ); continue; }
538
539         MediaServer* server = new MediaServer( UDN, friendlyName, cookie );
540         if ( !cookie->serverList->addServer( server ) ) {
541
542         delete server;
543         server = 0;
544         continue;
545         }
546
547         // Check for ContentDirectory service...
548
549         IXML_NodeList* serviceList = ixmlElement_getElementsByTagName( deviceElement, "service" );
550         if ( serviceList )
551         {
552             for ( unsigned int j = 0; j < ixmlNodeList_length( serviceList ); j++ )
553         {
554             IXML_Element* serviceElement = ( IXML_Element* )ixmlNodeList_item( serviceList, j );
555
556             const char* serviceType = xml_getChildElementValue( serviceElement, "serviceType" );
557             if ( !serviceType ) continue;
558             if ( strcmp( CONTENT_DIRECTORY_SERVICE_TYPE, serviceType ) != 0 ) continue;
559
560             const char* eventSubURL = xml_getChildElementValue( serviceElement, "eventSubURL" );
561             if ( !eventSubURL ) continue;
562
563             const char* controlURL = xml_getChildElementValue( serviceElement, "controlURL" );
564             if ( !controlURL ) continue;
565
566             // Try to subscribe to ContentDirectory service
567
568             char* url = ( char* )malloc( strlen( baseURL ) + strlen( eventSubURL ) + 1 );
569             if ( url )
570             {
571                 char* s1 = strdup( baseURL );
572                 char* s2 = strdup( eventSubURL );
573
574                 if ( UpnpResolveURL( s1, s2, url ) == UPNP_E_SUCCESS )
575                 {
576                 // msg_Dbg( cookie->serviceDiscovery, "CDS EVENT URL: %s", url );
577
578                 server->setContentDirectoryEventURL( url );
579                 server->subscribeToContentDirectory();
580                 }
581
582                 free( s1 );
583                 free( s2 );
584                 free( url );
585             }
586
587             // Try to browse content directory...
588
589             url = ( char* )malloc( strlen( baseURL ) + strlen( controlURL ) + 1 );
590             if ( url )
591             {
592             char* s1 = strdup( baseURL );
593             char* s2 = strdup( controlURL );
594
595             if ( UpnpResolveURL( s1, s2, url ) == UPNP_E_SUCCESS )
596             {
597                 // msg_Dbg( cookie->serviceDiscovery, "CDS CTRL URL: %s", url );
598
599                 server->setContentDirectoryControlURL( url );
600                 server->fetchContents();
601             }
602
603             free( s1 );
604             free( s2 );
605             free( url );
606             }
607         }
608
609         ixmlNodeList_free( serviceList );
610         }
611     }
612
613     ixmlNodeList_free( deviceList );
614     }
615 }
616
617 MediaServer::MediaServer( const char* UDN, const char* friendlyName, Cookie* cookie )
618 {
619     _cookie = cookie;
620
621     _UDN = UDN;
622     _friendlyName = friendlyName;
623
624     _contents = 0;
625     _playlistNode = 0;
626 }
627
628 MediaServer::~MediaServer()
629 {
630     if ( _contents )
631     {
632         playlist_NodeDelete( pl_Get( _cookie->serviceDiscovery ) ,
633                              _playlistNode, true, true );
634     }
635
636     delete _contents;
637 }
638
639 const char* MediaServer::getUDN() const
640 {
641   const char* s = _UDN.c_str();
642   return s;
643 }
644
645 const char* MediaServer::getFriendlyName() const
646 {
647     const char* s = _friendlyName.c_str();
648     return s;
649 }
650
651 void MediaServer::setContentDirectoryEventURL( const char* url )
652 {
653     _contentDirectoryEventURL = url;
654 }
655
656 const char* MediaServer::getContentDirectoryEventURL() const
657 {
658     const char* s =  _contentDirectoryEventURL.c_str();
659     return s;
660 }
661
662 void MediaServer::setContentDirectoryControlURL( const char* url )
663 {
664     _contentDirectoryControlURL = url;
665 }
666
667 const char* MediaServer::getContentDirectoryControlURL() const
668 {
669     return _contentDirectoryControlURL.c_str();
670 }
671
672 void MediaServer::subscribeToContentDirectory()
673 {
674     const char* url = getContentDirectoryEventURL();
675     if ( !url || strcmp( url, "" ) == 0 )
676     {
677     msg_Dbg( _cookie->serviceDiscovery, "No subscription url set!" );
678     return;
679     }
680
681     int timeOut = 1810;
682     Upnp_SID sid;
683
684     int res = UpnpSubscribe( _cookie->clientHandle, url, &timeOut, sid );
685
686     if ( res == UPNP_E_SUCCESS )
687     {
688     _subscriptionTimeOut = timeOut;
689     memcpy( _subscriptionID, sid, sizeof( Upnp_SID ) );
690     }
691     else
692     {
693     msg_Dbg( _cookie->serviceDiscovery, "%s:%d: WARNING: '%s': %s", __FILE__, __LINE__, getFriendlyName(), UpnpGetErrorMessage( res ) );
694     }
695 }
696
697 IXML_Document* MediaServer::_browseAction( const char* pObjectID, const char* pBrowseFlag, const char* pFilter,
698                        const char* pStartingIndex, const char* pRequestedCount, const char* pSortCriteria )
699 {
700     IXML_Document* action = 0;
701     IXML_Document* response = 0;
702
703     const char* url = getContentDirectoryControlURL();
704     if ( !url || strcmp( url, "" ) == 0 ) { msg_Dbg( _cookie->serviceDiscovery, "No subscription url set!" ); return 0; }
705
706     char* ObjectID = strdup( pObjectID );
707     char* BrowseFlag = strdup( pBrowseFlag );
708     char* Filter = strdup( pFilter );
709     char* StartingIndex = strdup( pStartingIndex );
710     char* RequestedCount = strdup( pRequestedCount );
711     char* SortCriteria = strdup( pSortCriteria );
712
713     char* serviceType = strdup( CONTENT_DIRECTORY_SERVICE_TYPE );
714
715     int res;
716
717     res = UpnpAddToAction( &action, "Browse", serviceType, "ObjectID", ObjectID );
718     if ( res != UPNP_E_SUCCESS ) { /* msg_Dbg( _cookie->serviceDiscovery, "%s:%d: ERROR: %s", __FILE__, __LINE__, UpnpGetErrorMessage( res ) ); */ goto browseActionCleanup; }
719
720     res = UpnpAddToAction( &action, "Browse", serviceType, "BrowseFlag", BrowseFlag );
721     if ( res != UPNP_E_SUCCESS ) { /* msg_Dbg( _cookie->serviceDiscovery, "%s:%d: ERROR: %s", __FILE__, __LINE__, UpnpGetErrorMessage( res ) ); */ goto browseActionCleanup; }
722
723     res = UpnpAddToAction( &action, "Browse", serviceType, "Filter", Filter );
724     if ( res != UPNP_E_SUCCESS ) { /* msg_Dbg( _cookie->serviceDiscovery, "%s:%d: ERROR: %s", __FILE__, __LINE__, UpnpGetErrorMessage( res ) ); */ goto browseActionCleanup; }
725
726     res = UpnpAddToAction( &action, "Browse", serviceType, "StartingIndex", StartingIndex );
727     if ( res != UPNP_E_SUCCESS ) { /* msg_Dbg( _cookie->serviceDiscovery, "%s:%d: ERROR: %s", __FILE__, __LINE__, UpnpGetErrorMessage( res ) ); */ goto browseActionCleanup; }
728
729     res = UpnpAddToAction( &action, "Browse", serviceType, "RequestedCount", RequestedCount );
730     if ( res != UPNP_E_SUCCESS ) { /* msg_Dbg( _cookie->serviceDiscovery, "%s:%d: ERROR: %s", __FILE__, __LINE__, UpnpGetErrorMessage( res ) ); */ goto browseActionCleanup; }
731
732     res = UpnpAddToAction( &action, "Browse", serviceType, "SortCriteria", SortCriteria );
733     if ( res != UPNP_E_SUCCESS ) { /* msg_Dbg( _cookie->serviceDiscovery, "%s:%d: ERROR: %s", __FILE__, __LINE__, UpnpGetErrorMessage( res ) ); */ goto browseActionCleanup; }
734
735     res = UpnpSendAction( _cookie->clientHandle,
736               url,
737               CONTENT_DIRECTORY_SERVICE_TYPE,
738               0,
739               action,
740               &response );
741     if ( res != UPNP_E_SUCCESS )
742     {
743     msg_Dbg( _cookie->serviceDiscovery, "%s:%d: ERROR: %s", __FILE__, __LINE__, UpnpGetErrorMessage( res ) );
744     ixmlDocument_free( response );
745     response = 0;
746     }
747
748  browseActionCleanup:
749
750     free( ObjectID );
751     free( BrowseFlag );
752     free( Filter );
753     free( StartingIndex );
754     free( RequestedCount );
755     free( SortCriteria );
756
757     free( serviceType );
758
759     ixmlDocument_free( action );
760     return response;
761 }
762
763 void MediaServer::fetchContents()
764 {
765     Container* root = new Container( 0, "0", getFriendlyName() );
766     playlist_t * p_playlist = pl_Get( _cookie->serviceDiscovery );
767     _fetchContents( root );
768
769     if ( _contents )
770     {
771         PL_LOCK;
772         playlist_NodeEmpty( p_playlist, _playlistNode, true );
773         PL_UNLOCK;
774         delete _contents;
775     }
776
777     _contents = root;
778     _contents->setPlaylistNode( _playlistNode );
779
780     _buildPlaylist( _contents );
781 }
782
783 bool MediaServer::_fetchContents( Container* parent )
784 {
785     if (!parent) { msg_Dbg( _cookie->serviceDiscovery, "%s:%d: parent==NULL", __FILE__, __LINE__ ); return false; }
786
787     IXML_Document* response = _browseAction( parent->getObjectID(), "BrowseDirectChildren", "*", "0", "0", "" );
788     if ( !response ) { msg_Dbg( _cookie->serviceDiscovery, "%s:%d: ERROR!", __FILE__, __LINE__ ); return false; }
789
790     IXML_Document* result = parseBrowseResult( response );
791     ixmlDocument_free( response );
792     if ( !result ) { msg_Dbg( _cookie->serviceDiscovery, "%s:%d: ERROR!", __FILE__, __LINE__ ); return false; }
793
794     IXML_NodeList* containerNodeList = ixmlDocument_getElementsByTagName( result, "container" );
795     if ( containerNodeList )
796     {
797     for ( unsigned int i = 0; i < ixmlNodeList_length( containerNodeList ); i++ )
798     {
799               IXML_Element* containerElement = ( IXML_Element* )ixmlNodeList_item( containerNodeList, i );
800
801         const char* objectID = ixmlElement_getAttribute( containerElement, "id" );
802         if ( !objectID ) continue;
803
804         const char* childCountStr = ixmlElement_getAttribute( containerElement, "childCount" );
805         if ( !childCountStr ) continue;
806         int childCount = atoi( childCountStr );
807
808         const char* title = xml_getChildElementValue( containerElement, "dc:title" );
809         if ( !title ) continue;
810
811         const char* resource = xml_getChildElementValue( containerElement, "res" );
812
813         if ( resource && childCount < 1 )
814         {
815         Item* item = new Item( parent, objectID, title, resource );
816         parent->addItem( item );
817         }
818         else
819         {
820         Container* container = new Container( parent, objectID, title );
821         parent->addContainer( container );
822
823         if ( childCount > 0 ) _fetchContents( container );
824         }
825     }
826
827     ixmlNodeList_free( containerNodeList );
828     }
829
830     IXML_NodeList* itemNodeList = ixmlDocument_getElementsByTagName( result, "item" );
831     if ( itemNodeList )
832     {
833         for ( unsigned int i = 0; i < ixmlNodeList_length( itemNodeList ); i++ )
834     {
835         IXML_Element* itemElement = ( IXML_Element* )ixmlNodeList_item( itemNodeList, i );
836
837         const char* objectID = ixmlElement_getAttribute( itemElement, "id" );
838         if ( !objectID ) continue;
839
840         const char* title = xml_getChildElementValue( itemElement, "dc:title" );
841         if ( !title ) continue;
842
843         const char* resource = xml_getChildElementValue( itemElement, "res" );
844         if ( !resource ) continue;
845
846         Item* item = new Item( parent, objectID, title, resource );
847         parent->addItem( item );
848     }
849
850     ixmlNodeList_free( itemNodeList );
851     }
852
853     ixmlDocument_free( result );
854
855     return true;
856 }
857
858 void MediaServer::_buildPlaylist( Container* parent )
859 {
860     playlist_t *p_playlist = pl_Get( _cookie->serviceDiscovery );
861     for ( unsigned int i = 0; i < parent->getNumContainers(); i++ )
862     {
863         Container* container = parent->getContainer( i );
864         playlist_item_t* parentNode = parent->getPlaylistNode();
865
866         char* title = strdup( container->getTitle() );
867         playlist_item_t* node = playlist_NodeCreate( p_playlist, title, parentNode, 0, NULL );
868         free( title );
869
870         container->setPlaylistNode( node );
871         _buildPlaylist( container );
872     }
873
874     for ( unsigned int i = 0; i < parent->getNumItems(); i++ )
875     {
876         Item* item = parent->getItem( i );
877         playlist_item_t* parentNode = parent->getPlaylistNode();
878
879         input_item_t* p_input = input_ItemNew( _cookie->serviceDiscovery,
880                                                item->getResource(),
881                                                item->getTitle() );
882         int i_cat;
883         /* FIXME: playlist_AddInput() can fail */
884         playlist_BothAddInput( p_playlist, p_input, parentNode,
885                                PLAYLIST_APPEND, PLAYLIST_END, &i_cat, NULL,
886                                pl_Unlocked );
887         vlc_gc_decref( p_input );
888         /* TODO: do this better by storing ids */
889         playlist_item_t *p_node = playlist_ItemGetById( p_playlist, i_cat, false );
890         assert( p_node );
891         item->setPlaylistNode( p_node );
892     }
893 }
894
895 void MediaServer::setPlaylistNode( playlist_item_t* playlistNode )
896 {
897     _playlistNode = playlistNode;
898 }
899
900 bool MediaServer::compareSID( const char* sid )
901 {
902     return ( strncmp( _subscriptionID, sid, sizeof( Upnp_SID ) ) == 0 );
903 }
904
905
906 // MediaServerList...
907
908 MediaServerList::MediaServerList( Cookie* cookie )
909 {
910     _cookie = cookie;
911 }
912
913 MediaServerList::~MediaServerList()
914 {
915     for ( unsigned int i = 0; i < _list.size(); i++ )
916     {
917     delete _list[i];
918     }
919 }
920
921 bool MediaServerList::addServer( MediaServer* s )
922 {
923     if ( getServer( s->getUDN() ) != 0 ) return false;
924
925     msg_Dbg( _cookie->serviceDiscovery, "Adding server '%s'", s->getFriendlyName() );
926
927     _list.push_back( s );
928
929     char* name = strdup( s->getFriendlyName() );
930     playlist_item_t* node = playlist_NodeCreate( pl_Get( _cookie->serviceDiscovery ),
931                                                  name,
932                                           _cookie->serviceDiscovery->p_sys->p_node_cat, 0, NULL );
933     free( name );
934     s->setPlaylistNode( node );
935
936     return true;
937 }
938
939 MediaServer* MediaServerList::getServer( const char* UDN )
940 {
941     MediaServer* result = 0;
942
943     for ( unsigned int i = 0; i < _list.size(); i++ )
944     {
945         if( strcmp( UDN, _list[i]->getUDN() ) == 0 )
946     {
947         result = _list[i];
948         break;
949     }
950     }
951
952     return result;
953 }
954
955 MediaServer* MediaServerList::getServerBySID( const char* sid )
956 {
957     MediaServer* server = 0;
958
959     for ( unsigned int i = 0; i < _list.size(); i++ )
960     {
961     if ( _list[i]->compareSID( sid ) )
962     {
963         server = _list[i];
964         break;
965     }
966     }
967
968     return server;
969 }
970
971 void MediaServerList::removeServer( const char* UDN )
972 {
973     MediaServer* server = getServer( UDN );
974     if ( !server ) return;
975
976     msg_Dbg( _cookie->serviceDiscovery, "Removing server '%s'", server->getFriendlyName() );
977
978     std::vector<MediaServer*>::iterator it;
979     for ( it = _list.begin(); it != _list.end(); it++ )
980     {
981         if ( *it == server )
982     {
983               _list.erase( it );
984         delete server;
985         break;
986     }
987     }
988 }
989
990
991 // Item...
992
993 Item::Item( Container* parent, const char* objectID, const char* title, const char* resource )
994 {
995     _parent = parent;
996
997     _objectID = objectID;
998     _title = title;
999     _resource = resource;
1000
1001     _playlistNode = 0;
1002 }
1003
1004 const char* Item::getObjectID() const
1005 {
1006     return _objectID.c_str();
1007 }
1008
1009 const char* Item::getTitle() const
1010 {
1011     return _title.c_str();
1012 }
1013
1014 const char* Item::getResource() const
1015 {
1016     return _resource.c_str();
1017 }
1018
1019 void Item::setPlaylistNode( playlist_item_t* node )
1020 {
1021     _playlistNode = node;
1022 }
1023
1024 playlist_item_t* Item::getPlaylistNode() const
1025 {
1026     return _playlistNode;
1027 }
1028
1029
1030 // Container...
1031
1032 Container::Container( Container* parent, const char* objectID, const char* title )
1033 {
1034     _parent = parent;
1035
1036     _objectID = objectID;
1037     _title = title;
1038
1039     _playlistNode = 0;
1040 }
1041
1042 Container::~Container()
1043 {
1044     for ( unsigned int i = 0; i < _containers.size(); i++ )
1045     {
1046     delete _containers[i];
1047     }
1048
1049     for ( unsigned int i = 0; i < _items.size(); i++ )
1050     {
1051     delete _items[i];
1052     }
1053 }
1054
1055 void Container::addItem( Item* item )
1056 {
1057     _items.push_back( item );
1058 }
1059
1060 void Container::addContainer( Container* container )
1061 {
1062     _containers.push_back( container );
1063 }
1064
1065 const char* Container::getObjectID() const
1066 {
1067     return _objectID.c_str();
1068 }
1069
1070 const char* Container::getTitle() const
1071 {
1072     return _title.c_str();
1073 }
1074
1075 unsigned int Container::getNumItems() const
1076 {
1077     return _items.size();
1078 }
1079
1080 unsigned int Container::getNumContainers() const
1081 {
1082     return _containers.size();
1083 }
1084
1085 Item* Container::getItem( unsigned int i ) const
1086 {
1087     if ( i < _items.size() ) return _items[i];
1088     return 0;
1089 }
1090
1091 Container* Container::getContainer( unsigned int i ) const
1092 {
1093     if ( i < _containers.size() ) return _containers[i];
1094     return 0;
1095 }
1096
1097 void Container::setPlaylistNode( playlist_item_t* node )
1098 {
1099     _playlistNode = node;
1100 }
1101
1102 playlist_item_t* Container::getPlaylistNode() const
1103 {
1104     return _playlistNode;
1105 }