UDP: use vlc_strerror_c()
[vlc.git] / modules / services_discovery / sap.c
1 /*****************************************************************************
2  * sap.c :  SAP interface module
3  *****************************************************************************
4  * Copyright (C) 2004-2005 the VideoLAN team
5  * Copyright © 2007 Rémi Denis-Courmont
6  * $Id$
7  *
8  * Authors: Clément Stenac <zorglub@videolan.org>
9  *          Rémi Denis-Courmont
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24  *****************************************************************************/
25
26 /*****************************************************************************
27  * Includes
28  *****************************************************************************/
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <assert.h>
36
37 #include <vlc_demux.h>
38 #include <vlc_services_discovery.h>
39
40 #include <vlc_network.h>
41 #include <vlc_charset.h>
42
43 #include <errno.h>
44 #ifdef HAVE_UNISTD_H
45 #    include <unistd.h>
46 #endif
47 #ifdef HAVE_ARPA_INET_H
48 # include <arpa/inet.h>
49 #endif
50 #ifdef HAVE_POLL
51 # include <poll.h>
52 #endif
53
54 #ifdef HAVE_ZLIB_H
55 #   include <zlib.h>
56 #endif
57
58 #ifndef _WIN32
59 #   include <net/if.h>
60 #endif
61
62 /************************************************************************
63  * Macros and definitions
64  ************************************************************************/
65
66 #define MAX_LINE_LENGTH 256
67
68 /* SAP is always on that port */
69 #define SAP_PORT 9875
70 /* Global-scope SAP address */
71 #define SAP_V4_GLOBAL_ADDRESS   "224.2.127.254"
72 /* Organization-local SAP address */
73 #define SAP_V4_ORG_ADDRESS      "239.195.255.255"
74 /* Local (smallest non-link-local scope) SAP address */
75 #define SAP_V4_LOCAL_ADDRESS    "239.255.255.255"
76 /* Link-local SAP address */
77 #define SAP_V4_LINK_ADDRESS     "224.0.0.255"
78 #define ADD_SESSION 1
79
80 /*****************************************************************************
81  * Module descriptor
82  *****************************************************************************/
83 #define SAP_ADDR_TEXT N_( "SAP multicast address" )
84 #define SAP_ADDR_LONGTEXT N_( "The SAP module normally chooses itself the " \
85                               "right addresses to listen to. However, you " \
86                               "can specify a specific address." )
87 #define SAP_TIMEOUT_TEXT N_( "SAP timeout (seconds)" )
88 #define SAP_TIMEOUT_LONGTEXT N_( \
89        "Delay after which SAP items get deleted if no new announcement " \
90        "is received." )
91 #define SAP_PARSE_TEXT N_( "Try to parse the announce" )
92 #define SAP_PARSE_LONGTEXT N_( \
93        "This enables actual parsing of the announces by the SAP module. " \
94        "Otherwise, all announcements are parsed by the \"live555\" " \
95        "(RTP/RTSP) module." )
96 #define SAP_STRICT_TEXT N_( "SAP Strict mode" )
97 #define SAP_STRICT_LONGTEXT N_( \
98        "When this is set, the SAP parser will discard some non-compliant " \
99        "announcements." )
100
101 /* Callbacks */
102     static int  Open ( vlc_object_t * );
103     static void Close( vlc_object_t * );
104     static int  OpenDemux ( vlc_object_t * );
105     static void CloseDemux ( vlc_object_t * );
106
107 VLC_SD_PROBE_HELPER("sap", "Network streams (SAP)", SD_CAT_LAN)
108
109 vlc_module_begin ()
110     set_shortname( N_("SAP"))
111     set_description( N_("Network streams (SAP)") )
112     set_category( CAT_PLAYLIST )
113     set_subcategory( SUBCAT_PLAYLIST_SD )
114
115     add_string( "sap-addr", NULL,
116                 SAP_ADDR_TEXT, SAP_ADDR_LONGTEXT, true )
117     add_obsolete_bool( "sap-ipv4" ) /* since 2.0.0 */
118     add_obsolete_bool( "sap-ipv6" ) /* since 2.0.0 */
119     add_integer( "sap-timeout", 1800,
120                  SAP_TIMEOUT_TEXT, SAP_TIMEOUT_LONGTEXT, true )
121     add_bool( "sap-parse", true,
122                SAP_PARSE_TEXT,SAP_PARSE_LONGTEXT, true )
123     add_bool( "sap-strict", false,
124                SAP_STRICT_TEXT,SAP_STRICT_LONGTEXT, true )
125     add_obsolete_bool( "sap-timeshift" ) /* Redumdant since 1.0.0 */
126
127     set_capability( "services_discovery", 0 )
128     set_callbacks( Open, Close )
129
130     VLC_SD_PROBE_SUBMODULE
131
132     add_submodule ()
133         set_description( N_("SDP Descriptions parser") )
134         add_shortcut( "sdp" )
135         set_capability( "demux", 51 )
136         set_callbacks( OpenDemux, CloseDemux )
137 vlc_module_end ()
138
139
140 /*****************************************************************************
141  * Local structures
142  *****************************************************************************/
143
144 typedef struct sdp_t sdp_t;
145 typedef struct attribute_t attribute_t;
146 typedef struct sap_announce_t sap_announce_t;
147
148
149 struct sdp_media_t
150 {
151     struct sdp_t           *parent;
152     char                   *fmt;
153     struct sockaddr_storage addr;
154     socklen_t               addrlen;
155     unsigned                n_addr;
156     int           i_attributes;
157     attribute_t  **pp_attributes;
158 };
159
160
161 /* The structure that contains sdp information */
162 struct  sdp_t
163 {
164     const char *psz_sdp;
165
166     /* o field */
167     char     username[64];
168     uint64_t session_id;
169     uint64_t session_version;
170     unsigned orig_ip_version;
171     char     orig_host[1024];
172
173     /* s= field */
174     char *psz_sessionname;
175
176     /* i= field */
177     char *psz_sessioninfo;
178
179     /* old cruft */
180     /* "computed" URI */
181     char *psz_uri;
182     int           i_media_type;
183     unsigned rtcp_port;
184
185     /* a= global attributes */
186     int           i_attributes;
187     attribute_t  **pp_attributes;
188
189     /* medias (well, we only support one atm) */
190     unsigned            mediac;
191     struct sdp_media_t *mediav;
192 };
193
194 struct attribute_t
195 {
196     const char *value;
197     char name[];
198 };
199
200 struct sap_announce_t
201 {
202     mtime_t i_last;
203     mtime_t i_period;
204     uint8_t i_period_trust;
205
206     uint16_t    i_hash;
207     uint32_t    i_source[4];
208
209     /* SAP annnounces must only contain one SDP */
210     sdp_t       *p_sdp;
211
212     input_item_t * p_item;
213 };
214
215 struct services_discovery_sys_t
216 {
217     vlc_thread_t thread;
218
219     /* Socket descriptors */
220     int i_fd;
221     int *pi_fd;
222
223     /* Table of announces */
224     int i_announces;
225     struct sap_announce_t **pp_announces;
226
227     /* Modes */
228     bool  b_strict;
229     bool  b_parse;
230
231     int i_timeout;
232 };
233
234 struct demux_sys_t
235 {
236     sdp_t *p_sdp;
237 };
238
239 /*****************************************************************************
240  * Local prototypes
241  *****************************************************************************/
242
243
244 /* Main functions */
245     static int Demux( demux_t *p_demux );
246     static int Control( demux_t *, int, va_list );
247     static void *Run  ( void *p_sd );
248
249 /* Main parsing functions */
250     static int ParseConnection( vlc_object_t *p_obj, sdp_t *p_sdp );
251     static int ParseSAP( services_discovery_t *p_sd, const uint8_t *p_buffer, size_t i_read );
252     static sdp_t *ParseSDP (vlc_object_t *p_sd, const char *psz_sdp);
253     static sap_announce_t *CreateAnnounce( services_discovery_t *, uint32_t *, uint16_t, sdp_t * );
254     static int RemoveAnnounce( services_discovery_t *p_sd, sap_announce_t *p_announce );
255
256 /* Helper functions */
257     static inline attribute_t *MakeAttribute (const char *str);
258     static const char *GetAttribute (attribute_t **tab, unsigned n, const char *name);
259     static inline void FreeAttribute (attribute_t *a);
260     static const char *FindAttribute (const sdp_t *sdp, unsigned media,
261                                       const char *name);
262
263     static bool IsSameSession( sdp_t *p_sdp1, sdp_t *p_sdp2 );
264     static int InitSocket( services_discovery_t *p_sd, const char *psz_address, int i_port );
265     static int Decompress( const unsigned char *psz_src, unsigned char **_dst, int i_len );
266     static void FreeSDP( sdp_t *p_sdp );
267
268 static inline int min_int( int a, int b )
269 {
270     return a > b ? b : a;
271 }
272
273 static bool IsWellKnownPayload (int type)
274 {
275     switch (type)
276     {   /* Should be in sync with modules/demux/rtp.c */
277         case  0: /* PCMU/8000 */
278         case  3:
279         case  8: /* PCMA/8000 */
280         case 10: /* L16/44100/2 */
281         case 11: /* L16/44100 */
282         case 12:
283         case 14: /* MPA/90000 */
284         case 32: /* MPV/90000 */
285         case 33: /* MP2/90000 */
286             return true;
287    }
288    return false;
289 }
290
291 /*****************************************************************************
292  * Open: initialize and create stuff
293  *****************************************************************************/
294 static int Open( vlc_object_t *p_this )
295 {
296     services_discovery_t *p_sd = ( services_discovery_t* )p_this;
297     services_discovery_sys_t *p_sys  = (services_discovery_sys_t *)
298                                 malloc( sizeof( services_discovery_sys_t ) );
299     if( !p_sys )
300         return VLC_ENOMEM;
301
302     p_sys->i_timeout = var_CreateGetInteger( p_sd, "sap-timeout" );
303
304     p_sd->p_sys  = p_sys;
305
306     p_sys->pi_fd = NULL;
307     p_sys->i_fd = 0;
308
309     p_sys->b_strict = var_CreateGetBool( p_sd, "sap-strict");
310     p_sys->b_parse = var_CreateGetBool( p_sd, "sap-parse" );
311
312     p_sys->i_announces = 0;
313     p_sys->pp_announces = NULL;
314     /* TODO: create sockets here, and fix racy sockets table */
315     if (vlc_clone (&p_sys->thread, Run, p_sd, VLC_THREAD_PRIORITY_LOW))
316     {
317         free (p_sys);
318         return VLC_EGENERIC;
319     }
320
321     return VLC_SUCCESS;
322 }
323
324 /*****************************************************************************
325  * OpenDemux: initialize and create stuff
326  *****************************************************************************/
327 static int OpenDemux( vlc_object_t *p_this )
328 {
329     demux_t *p_demux = (demux_t *)p_this;
330     const uint8_t *p_peek;
331     char *psz_sdp = NULL;
332     sdp_t *p_sdp = NULL;
333     int errval = VLC_EGENERIC;
334     size_t i_len;
335
336     if( !var_CreateGetBool( p_demux, "sap-parse" ) )
337     {
338         /* We want livedotcom module to parse this SDP file */
339         return VLC_EGENERIC;
340     }
341
342     assert( p_demux->s ); /* this is NOT an access_demux */
343
344     /* Probe for SDP */
345     if( stream_Peek( p_demux->s, &p_peek, 7 ) < 7 )
346         return VLC_EGENERIC;
347
348     if( memcmp( p_peek, "v=0\r\no=", 7 ) && memcmp( p_peek, "v=0\no=", 6 ) )
349         return VLC_EGENERIC;
350
351     /* Gather the complete sdp file */
352     for( i_len = 0, psz_sdp = NULL; i_len < 65536; )
353     {
354         const int i_read_max = 1024;
355         char *psz_sdp_new = realloc( psz_sdp, i_len + i_read_max + 1 );
356         size_t i_read;
357         if( psz_sdp_new == NULL )
358         {
359             errval = VLC_ENOMEM;
360             goto error;
361         }
362         psz_sdp = psz_sdp_new;
363
364         i_read = stream_Read( p_demux->s, &psz_sdp[i_len], i_read_max );
365         if( (int)i_read < 0 )
366         {
367             msg_Err( p_demux, "cannot read SDP" );
368             goto error;
369         }
370         i_len += i_read;
371
372         psz_sdp[i_len] = '\0';
373
374         if( (int)i_read < i_read_max )
375             break; // EOF
376     }
377
378     p_sdp = ParseSDP( VLC_OBJECT(p_demux), psz_sdp );
379
380     if( !p_sdp )
381     {
382         msg_Warn( p_demux, "invalid SDP");
383         goto error;
384     }
385
386     if( ParseConnection( VLC_OBJECT( p_demux ), p_sdp ) )
387     {
388         p_sdp->psz_uri = NULL;
389     }
390     if (!IsWellKnownPayload (p_sdp->i_media_type))
391         goto error;
392     if( p_sdp->psz_uri == NULL ) goto error;
393
394     p_demux->p_sys = (demux_sys_t *)malloc( sizeof(demux_sys_t) );
395     if( unlikely( !p_demux->p_sys ) )
396         goto error;
397     p_demux->p_sys->p_sdp = p_sdp;
398     p_demux->pf_control = Control;
399     p_demux->pf_demux = Demux;
400
401     FREENULL( psz_sdp );
402     return VLC_SUCCESS;
403
404 error:
405     FREENULL( psz_sdp );
406     if( p_sdp ) FreeSDP( p_sdp ); p_sdp = NULL;
407     stream_Seek( p_demux->s, 0 );
408     return errval;
409 }
410
411 /*****************************************************************************
412  * Close:
413  *****************************************************************************/
414 static void Close( vlc_object_t *p_this )
415 {
416     services_discovery_t *p_sd = ( services_discovery_t* )p_this;
417     services_discovery_sys_t    *p_sys  = p_sd->p_sys;
418     int i;
419
420     vlc_cancel (p_sys->thread);
421     vlc_join (p_sys->thread, NULL);
422
423     for( i = p_sys->i_fd-1 ; i >= 0 ; i-- )
424     {
425         net_Close( p_sys->pi_fd[i] );
426     }
427     FREENULL( p_sys->pi_fd );
428
429     for( i = p_sys->i_announces  - 1;  i>= 0; i-- )
430     {
431         RemoveAnnounce( p_sd, p_sys->pp_announces[i] );
432     }
433     FREENULL( p_sys->pp_announces );
434
435     free( p_sys );
436 }
437
438 /*****************************************************************************
439  * CloseDemux: Close the demuxer
440  *****************************************************************************/
441 static void CloseDemux( vlc_object_t *p_this )
442 {
443     demux_t *p_demux = (demux_t *)p_this;
444
445     if( p_demux->p_sys->p_sdp )
446         FreeSDP( p_demux->p_sys->p_sdp );
447     free( p_demux->p_sys );
448 }
449
450 /*****************************************************************************
451  * Run: main SAP thread
452  *****************************************************************************
453  * Listens to SAP packets, and sends them to packet_handle
454  *****************************************************************************/
455 #define MAX_SAP_BUFFER 5000
456
457 static void *Run( void *data )
458 {
459     services_discovery_t *p_sd = data;
460     char *psz_addr;
461     int i;
462     int timeout = -1;
463     int canc = vlc_savecancel ();
464
465     /* Braindead Winsock DNS resolver will get stuck over 2 seconds per failed
466      * DNS queries, even if the DNS server returns an error with milliseconds.
467      * You don't want to know why the bug (as of XP SP2) wasn't fixed since
468      * Winsock 1.1 from Windows 95, if not Windows 3.1.
469      * Anyway, to avoid a 30 seconds delay for failed IPv6 socket creation,
470      * we have to open sockets in Run() rather than Open(). */
471     InitSocket( p_sd, SAP_V4_GLOBAL_ADDRESS, SAP_PORT );
472     InitSocket( p_sd, SAP_V4_ORG_ADDRESS, SAP_PORT );
473     InitSocket( p_sd, SAP_V4_LOCAL_ADDRESS, SAP_PORT );
474     InitSocket( p_sd, SAP_V4_LINK_ADDRESS, SAP_PORT );
475
476     char psz_address[NI_MAXNUMERICHOST] = "ff02::2:7ffe%";
477 #ifndef _WIN32
478     struct if_nameindex *l = if_nameindex ();
479     if (l != NULL)
480     {
481         char *ptr = strchr (psz_address, '%') + 1;
482         for (unsigned i = 0; l[i].if_index; i++)
483         {
484             strcpy (ptr, l[i].if_name);
485             InitSocket (p_sd, psz_address, SAP_PORT);
486         }
487         if_freenameindex (l);
488     }
489 #else
490         /* this is the Winsock2 equivalant of SIOCGIFCONF on BSD stacks,
491            which if_nameindex uses internally anyway */
492
493         // first create a dummy socket to pin down the protocol family
494         SOCKET s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP);
495         if( s != INVALID_SOCKET )
496         {
497             INTERFACE_INFO ifaces[10]; // Assume there will be no more than 10 IP interfaces
498             DWORD len = sizeof(ifaces);
499
500             if( SOCKET_ERROR != WSAIoctl(s, SIO_GET_INTERFACE_LIST, NULL, 0, &ifaces, len, &len, NULL, NULL) )
501             {
502                 unsigned ifcount = len/sizeof(INTERFACE_INFO);
503                 char *ptr = strchr (psz_address, '%') + 1;
504                 for(unsigned i = 1; i<=ifcount; ++i )
505                 {
506                     // append link-local zone identifier
507                     sprintf(ptr, "%d", i);
508                 }
509             }
510             closesocket(s);
511         }
512 #endif
513     *strchr (psz_address, '%') = '\0';
514
515     static const char ipv6_scopes[] = "1456789ABCDE";
516     for (const char *c_scope = ipv6_scopes; *c_scope; c_scope++)
517     {
518         psz_address[3] = *c_scope;
519         InitSocket( p_sd, psz_address, SAP_PORT );
520     }
521
522     psz_addr = var_CreateGetString( p_sd, "sap-addr" );
523     if( psz_addr && *psz_addr )
524         InitSocket( p_sd, psz_addr, SAP_PORT );
525     free( psz_addr );
526
527     if( p_sd->p_sys->i_fd == 0 )
528     {
529         msg_Err( p_sd, "unable to listen on any address" );
530         return NULL;
531     }
532
533     /* read SAP packets */
534     for (;;)
535     {
536         vlc_restorecancel (canc);
537         unsigned n = p_sd->p_sys->i_fd;
538         struct pollfd ufd[n];
539
540         for (unsigned i = 0; i < n; i++)
541         {
542             ufd[i].fd = p_sd->p_sys->pi_fd[i];
543             ufd[i].events = POLLIN;
544             ufd[i].revents = 0;
545         }
546
547         int val = poll (ufd, n, timeout);
548         canc = vlc_savecancel ();
549         if (val > 0)
550         {
551             for (unsigned i = 0; i < n; i++)
552             {
553                 if (ufd[i].revents)
554                 {
555                     uint8_t p_buffer[MAX_SAP_BUFFER+1];
556                     ssize_t i_read;
557
558                     i_read = net_Read (p_sd, ufd[i].fd, NULL, p_buffer,
559                                        MAX_SAP_BUFFER, false);
560                     if (i_read < 0)
561                         msg_Warn (p_sd, "receive error: %s",
562                                   vlc_strerror_c(errno));
563                     if (i_read > 6)
564                     {
565                         /* Parse the packet */
566                         p_buffer[i_read] = '\0';
567                         ParseSAP (p_sd, p_buffer, i_read);
568                     }
569                 }
570             }
571         }
572
573         mtime_t now = mdate();
574
575         /* A 1 hour timeout correspond to the RFC Implicit timeout.
576          * This timeout is tuned in the following loop. */
577         timeout = 1000 * 60 * 60;
578
579         /* Check for items that need deletion */
580         for( i = 0; i < p_sd->p_sys->i_announces; i++ )
581         {
582             mtime_t i_timeout = ( mtime_t ) 1000000 * p_sd->p_sys->i_timeout;
583             sap_announce_t * p_announce = p_sd->p_sys->pp_announces[i];
584             mtime_t i_last_period = now - p_announce->i_last;
585
586             /* Remove the announcement, if the last announcement was 1 hour ago
587              * or if the last packet emitted was 3 times the average time
588              * between two packets */
589             if( ( p_announce->i_period_trust > 5 && i_last_period > 3 * p_announce->i_period ) ||
590                 i_last_period > i_timeout )
591             {
592                 RemoveAnnounce( p_sd, p_announce );
593             }
594             else
595             {
596                 /* Compute next timeout */
597                 if( p_announce->i_period_trust > 5 )
598                     timeout = min_int((3 * p_announce->i_period - i_last_period) / 1000, timeout);
599                 timeout = min_int((i_timeout - i_last_period)/1000, timeout);
600             }
601         }
602
603         if( !p_sd->p_sys->i_announces )
604             timeout = -1; /* We can safely poll indefinitely. */
605         else if( timeout < 200 )
606             timeout = 200; /* Don't wakeup too fast. */
607     }
608     assert (0);
609 }
610
611 /**********************************************************************
612  * Demux: reads and demuxes data packets
613  * Return -1 if error, 0 if EOF, 1 else
614  **********************************************************************/
615 static int Demux( demux_t *p_demux )
616 {
617     sdp_t *p_sdp = p_demux->p_sys->p_sdp;
618     input_thread_t *p_input;
619     input_item_t *p_parent_input;
620
621     p_input = demux_GetParentInput( p_demux );
622     assert( p_input );
623     if( !p_input )
624     {
625         msg_Err( p_demux, "parent input could not be found" );
626         return VLC_EGENERIC;
627     }
628
629     /* This item hasn't been held by input_GetItem
630      * don't release it */
631     p_parent_input = input_GetItem( p_input );
632
633     input_item_SetURI( p_parent_input, p_sdp->psz_uri );
634     input_item_SetName( p_parent_input, p_sdp->psz_sessionname );
635     if( p_sdp->rtcp_port )
636     {
637         char *rtcp;
638         if( asprintf( &rtcp, ":rtcp-port=%u", p_sdp->rtcp_port ) != -1 )
639         {
640             input_item_AddOption( p_parent_input, rtcp, VLC_INPUT_OPTION_TRUSTED );
641             free( rtcp );
642         }
643     }
644
645     vlc_mutex_lock( &p_parent_input->lock );
646
647     p_parent_input->i_type = ITEM_TYPE_NET;
648
649     vlc_mutex_unlock( &p_parent_input->lock );
650     vlc_object_release( p_input );
651     return VLC_SUCCESS;
652 }
653
654 static int Control( demux_t *p_demux, int i_query, va_list args )
655 {
656     VLC_UNUSED(p_demux); VLC_UNUSED(i_query); VLC_UNUSED(args);
657     return VLC_EGENERIC;
658 }
659
660 /**************************************************************
661  * Local functions
662  **************************************************************/
663
664 /* i_read is at least > 6 */
665 static int ParseSAP( services_discovery_t *p_sd, const uint8_t *buf,
666                      size_t len )
667 {
668     int i;
669     const char          *psz_sdp;
670     const uint8_t *end = buf + len;
671     sdp_t               *p_sdp;
672     uint32_t            i_source[4];
673
674     assert (buf[len] == '\0');
675
676     if (len < 4)
677         return VLC_EGENERIC;
678
679     uint8_t flags = buf[0];
680     uint8_t auth_len = buf[1];
681
682     /* First, check the sap announce is correct */
683     if ((flags >> 5) != 1)
684         return VLC_EGENERIC;
685
686     bool b_ipv6 = (flags & 0x10) != 0;
687     bool b_need_delete = (flags & 0x04) != 0;
688
689     if (flags & 0x02)
690     {
691         msg_Dbg( p_sd, "encrypted packet, unsupported" );
692         return VLC_EGENERIC;
693     }
694
695     bool b_compressed = (flags & 0x01) != 0;
696
697     uint16_t i_hash = U16_AT (buf + 2);
698
699     if( p_sd->p_sys->b_strict && i_hash == 0 )
700     {
701         msg_Dbg( p_sd, "strict mode, discarding announce with null id hash");
702         return VLC_EGENERIC;
703     }
704
705     buf += 4;
706     if( b_ipv6 )
707     {
708         for( int i = 0; i < 4; i++,buf+=4)
709             i_source[i] = U32_AT(buf);
710     }
711     else
712     {
713         memset(i_source, 0, sizeof(i_source));
714         i_source[3] = U32_AT(buf);
715         buf+=4;
716     }
717     // Skips auth data
718     buf += auth_len;
719     if (buf > end)
720         return VLC_EGENERIC;
721
722     uint8_t *decomp = NULL;
723     if( b_compressed )
724     {
725         int newsize = Decompress (buf, &decomp, end - buf);
726         if (newsize < 0)
727         {
728             msg_Dbg( p_sd, "decompression of SAP packet failed" );
729             return VLC_EGENERIC;
730         }
731
732         decomp = realloc (decomp, newsize + 1);
733         decomp[newsize] = '\0';
734         psz_sdp = (const char *)decomp;
735         len = newsize;
736     }
737     else
738     {
739         psz_sdp = (const char *)buf;
740         len = end - buf;
741     }
742
743     /* len is a strlen here here. both buf and decomp are len+1 where the 1 should be a \0 */
744     assert( psz_sdp[len] == '\0');
745
746     /* Skip payload type */
747     /* SAPv1 has implicit "application/sdp" payload type: first line is v=0 */
748     if (strncmp (psz_sdp, "v=0", 3))
749     {
750         size_t clen = strlen (psz_sdp) + 1;
751
752         if (strcmp (psz_sdp, "application/sdp"))
753         {
754             msg_Dbg (p_sd, "unsupported content type: %s", psz_sdp);
755             return VLC_EGENERIC;
756         }
757
758         // skips content type
759         if (len <= clen)
760             return VLC_EGENERIC;
761
762         len -= clen;
763         psz_sdp += clen;
764     }
765
766     /* Parse SDP info */
767     p_sdp = ParseSDP( VLC_OBJECT(p_sd), psz_sdp );
768
769     if( p_sdp == NULL )
770         return VLC_EGENERIC;
771
772     p_sdp->psz_sdp = psz_sdp;
773
774     /* Decide whether we should add a playlist item for this SDP */
775     /* Parse connection information (c= & m= ) */
776     if( ParseConnection( VLC_OBJECT(p_sd), p_sdp ) )
777         p_sdp->psz_uri = NULL;
778
779     /* Multi-media or no-parse -> pass to LIVE.COM */
780     if( !IsWellKnownPayload( p_sdp->i_media_type ) || !p_sd->p_sys->b_parse )
781     {
782         free( p_sdp->psz_uri );
783         if (asprintf( &p_sdp->psz_uri, "sdp://%s", p_sdp->psz_sdp ) == -1)
784             p_sdp->psz_uri = NULL;
785     }
786
787     if( p_sdp->psz_uri == NULL )
788     {
789         FreeSDP( p_sdp );
790         return VLC_EGENERIC;
791     }
792
793     for( i = 0 ; i< p_sd->p_sys->i_announces ; i++ )
794     {
795         sap_announce_t * p_announce = p_sd->p_sys->pp_announces[i];
796         /* FIXME: slow */
797         if( ( !i_hash && IsSameSession( p_announce->p_sdp, p_sdp ) )
798             || ( i_hash && p_announce->i_hash == i_hash
799                  && !memcmp(p_announce->i_source, i_source, sizeof(i_source)) ) )
800         {
801             /* We don't support delete announcement as they can easily
802              * Be used to highjack an announcement by a third party.
803              * Instead we cleverly implement Implicit Announcement removal.
804              *
805              * if( b_need_delete )
806              *    RemoveAnnounce( p_sd, p_sd->p_sys->pp_announces[i]);
807              * else
808              */
809
810             if( !b_need_delete )
811             {
812                 /* No need to go after six, as we start to trust the
813                  * average period at six */
814                 if( p_announce->i_period_trust <= 5 )
815                     p_announce->i_period_trust++;
816
817                 /* Compute the average period */
818                 mtime_t now = mdate();
819                 p_announce->i_period = ( p_announce->i_period * (p_announce->i_period_trust-1) + (now - p_announce->i_last) ) / p_announce->i_period_trust;
820                 p_announce->i_last = now;
821             }
822             FreeSDP( p_sdp ); p_sdp = NULL;
823             return VLC_SUCCESS;
824         }
825     }
826
827     CreateAnnounce( p_sd, i_source, i_hash, p_sdp );
828
829     FREENULL (decomp);
830     return VLC_SUCCESS;
831 }
832
833 sap_announce_t *CreateAnnounce( services_discovery_t *p_sd, uint32_t *i_source, uint16_t i_hash,
834                                 sdp_t *p_sdp )
835 {
836     input_item_t *p_input;
837     const char *psz_value;
838     sap_announce_t *p_sap = (sap_announce_t *)malloc(
839                                         sizeof(sap_announce_t ) );
840     services_discovery_sys_t *p_sys;
841     if( p_sap == NULL )
842         return NULL;
843
844     p_sys = p_sd->p_sys;
845
846     p_sap->i_last = mdate();
847     p_sap->i_period = 0;
848     p_sap->i_period_trust = 0;
849     p_sap->i_hash = i_hash;
850     memcpy (p_sap->i_source, i_source, sizeof(p_sap->i_source));
851     p_sap->p_sdp = p_sdp;
852
853     /* Released in RemoveAnnounce */
854     p_input = input_item_NewWithType( p_sap->p_sdp->psz_uri,
855                                       p_sdp->psz_sessionname,
856                                       0, NULL, 0, -1, ITEM_TYPE_NET );
857     vlc_meta_t *p_meta = vlc_meta_New();
858     vlc_meta_Set( p_meta, vlc_meta_Description, p_sdp->psz_sessioninfo );
859     p_input->p_meta = p_meta;
860     p_sap->p_item = p_input;
861     if( !p_input )
862     {
863         free( p_sap );
864         return NULL;
865     }
866
867     if( p_sdp->rtcp_port )
868     {
869         char *rtcp;
870         if( asprintf( &rtcp, ":rtcp-port=%u", p_sdp->rtcp_port ) != -1 )
871         {
872             input_item_AddOption( p_input, rtcp, VLC_INPUT_OPTION_TRUSTED );
873             free( rtcp );
874         }
875     }
876
877     psz_value = GetAttribute( p_sap->p_sdp->pp_attributes, p_sap->p_sdp->i_attributes, "tool" );
878     if( psz_value != NULL )
879     {
880         input_item_AddInfo( p_input, _("Session"), _("Tool"), "%s", psz_value );
881     }
882     if( strcmp( p_sdp->username, "-" ) )
883     {
884         input_item_AddInfo( p_input, _("Session"), _("User"), "%s",
885                            p_sdp->username );
886     }
887
888     /* Handle category */
889     psz_value = GetAttribute(p_sap->p_sdp->pp_attributes,
890                              p_sap->p_sdp->i_attributes, "cat");
891     if (psz_value != NULL)
892     {
893         /* a=cat provides a dot-separated hierarchy.
894          * For the time being only replace dots with pipe. TODO: FIXME */
895         char *str = strdup(psz_value);
896         if (likely(str != NULL))
897             for (char *p = strchr(str, '.'); p != NULL; p = strchr(p, '.'))
898                 *(p++) = '|';
899         services_discovery_AddItem(p_sd, p_input, str ? str : psz_value);
900         free(str);
901     }
902     else
903     {
904         /* backward compatibility with VLC 0.7.3-2.0.0 senders */
905         psz_value = GetAttribute(p_sap->p_sdp->pp_attributes,
906                                  p_sap->p_sdp->i_attributes, "x-plgroup");
907         services_discovery_AddItem(p_sd, p_input, psz_value);
908     }
909
910     TAB_APPEND( p_sys->i_announces, p_sys->pp_announces, p_sap );
911
912     return p_sap;
913 }
914
915
916 static const char *FindAttribute (const sdp_t *sdp, unsigned media,
917                                   const char *name)
918 {
919     /* Look for media attribute, and fallback to session */
920     const char *attr = GetAttribute (sdp->mediav[media].pp_attributes,
921                                      sdp->mediav[media].i_attributes, name);
922     if (attr == NULL)
923         attr = GetAttribute (sdp->pp_attributes, sdp->i_attributes, name);
924     return attr;
925 }
926
927
928 /* Fill p_sdp->psz_uri */
929 static int ParseConnection( vlc_object_t *p_obj, sdp_t *p_sdp )
930 {
931     if (p_sdp->mediac == 0)
932     {
933         msg_Dbg (p_obj, "Ignoring SDP with no media");
934         return VLC_EGENERIC;
935     }
936
937     for (unsigned i = 1; i < p_sdp->mediac; i++)
938     {
939         if ((p_sdp->mediav[i].n_addr != p_sdp->mediav->n_addr)
940          || (p_sdp->mediav[i].addrlen != p_sdp->mediav->addrlen)
941          || memcmp (&p_sdp->mediav[i].addr, &p_sdp->mediav->addr,
942                     p_sdp->mediav->addrlen))
943         {
944             msg_Dbg (p_obj, "Multiple media ports not supported -> live555");
945             return VLC_EGENERIC;
946         }
947     }
948
949     if (p_sdp->mediav->n_addr != 1)
950     {
951         msg_Dbg (p_obj, "Layered encoding not supported -> live555");
952         return VLC_EGENERIC;
953     }
954
955     char psz_uri[1026];
956     const char *host;
957     int port;
958
959     psz_uri[0] = '[';
960     if (vlc_getnameinfo ((struct sockaddr *)&(p_sdp->mediav->addr),
961                          p_sdp->mediav->addrlen, psz_uri + 1,
962                          sizeof (psz_uri) - 2, &port, NI_NUMERICHOST))
963         return VLC_EGENERIC;
964
965     if (strchr (psz_uri + 1, ':'))
966     {
967         host = psz_uri;
968         strcat (psz_uri, "]");
969     }
970     else
971         host = psz_uri + 1;
972
973     /* Parse m= field */
974     char *sdp_proto = strdup (p_sdp->mediav[0].fmt);
975     if (sdp_proto == NULL)
976         return VLC_ENOMEM;
977
978     char *subtype = strchr (sdp_proto, ' ');
979     if (subtype == NULL)
980     {
981         msg_Dbg (p_obj, "missing SDP media subtype: %s", sdp_proto);
982         free (sdp_proto);
983         return VLC_EGENERIC;
984     }
985     else
986     {
987         *subtype++ = '\0';
988         /* FIXME: check for multiple payload types in RTP/AVP case.
989          * FIXME: check for "mpeg" subtype in raw udp case. */
990         if (!strcasecmp (sdp_proto, "udp"))
991             p_sdp->i_media_type = 33;
992         else
993             p_sdp->i_media_type = atoi (subtype);
994     }
995
996     /* RTP protocol, nul, VLC shortcut, nul, flags byte as follow:
997      * 0x1: Connection-Oriented media. */
998     static const char proto_match[] =
999         "udp\0"             "udp\0\0"
1000         "RTP/AVP\0"         "rtp\0\0"
1001         "UDPLite/RTP/AVP\0" "udplite\0\0"
1002         "DCCP/RTP/AVP\0"    "dccp\0\1"
1003         "TCP/RTP/AVP\0"     "rtptcp\0\1"
1004         "\0";
1005
1006     const char *vlc_proto = NULL;
1007     uint8_t flags = 0;
1008     for (const char *proto = proto_match; *proto;)
1009     {
1010         if (strcasecmp (proto, sdp_proto) == 0)
1011         {
1012             vlc_proto = proto + strlen (proto) + 1;
1013             flags = vlc_proto[strlen (vlc_proto) + 1];
1014             break;
1015         }
1016         proto += strlen (proto) + 1;
1017         proto += strlen (proto) + 2;
1018     }
1019
1020     free (sdp_proto);
1021     if (vlc_proto == NULL)
1022     {
1023         msg_Dbg (p_obj, "unknown SDP media protocol: %s",
1024                  p_sdp->mediav[0].fmt);
1025         return VLC_EGENERIC;
1026     }
1027
1028     if (!strcmp (vlc_proto, "udp") || FindAttribute (p_sdp, 0, "rtcp-mux"))
1029         p_sdp->rtcp_port = 0;
1030     else
1031     {
1032         const char *rtcp = FindAttribute (p_sdp, 0, "rtcp");
1033         if (rtcp)
1034             p_sdp->rtcp_port = atoi (rtcp);
1035         else
1036         if (port & 1) /* odd port -> RTCP; next even port -> RTP */
1037             p_sdp->rtcp_port = port++;
1038         else /* even port -> RTP; next odd port -> RTCP */
1039             p_sdp->rtcp_port = port + 1;
1040     }
1041
1042     if (flags & 1)
1043     {
1044         /* Connection-oriented media */
1045         const char *setup = FindAttribute (p_sdp, 0, "setup");
1046         if (setup == NULL)
1047             setup = "active"; /* default value */
1048
1049         if (strcmp (setup, "actpass") && strcmp (setup, "passive"))
1050         {
1051             msg_Dbg (p_obj, "unsupported COMEDIA mode: %s", setup);
1052             return VLC_EGENERIC;
1053         }
1054
1055         if (asprintf (&p_sdp->psz_uri, "%s://%s:%d", vlc_proto,
1056                       host, port) == -1)
1057             return VLC_ENOMEM;
1058     }
1059     else
1060     {
1061         /* Non-connected (normally multicast) media */
1062         char psz_source[258] = "";
1063         const char *sfilter = FindAttribute (p_sdp, 0, "source-filter");
1064         if (sfilter != NULL)
1065         {
1066             char psz_source_ip[256];
1067             unsigned ipv;
1068
1069             if (sscanf (sfilter, " incl IN IP%u %*s %255s ", &ipv,
1070                         psz_source_ip) == 2)
1071             {
1072                 /* According to RFC4570, FQDNs can be used for source-filters,
1073                  * but -seriously- this is impractical */
1074                 switch (ipv)
1075                 {
1076 #ifdef AF_INET6
1077                     case 6:
1078                     {
1079                         struct in6_addr addr;
1080                         if ((inet_pton (AF_INET6, psz_source_ip, &addr) > 0)
1081                         && (inet_ntop (AF_INET6, &addr, psz_source + 1,
1082                                         sizeof (psz_source) - 2) != NULL))
1083                         {
1084                             psz_source[0] = '[';
1085                             psz_source[strlen (psz_source)] = ']';
1086                         }
1087                         break;
1088                     }
1089 #endif
1090                     case 4:
1091                     {
1092                         struct in_addr addr;
1093                         if ((inet_pton (AF_INET, psz_source_ip, &addr) > 0)
1094                         && (inet_ntop (AF_INET, &addr, psz_source,
1095                                         sizeof (psz_source)) == NULL))
1096                             *psz_source = '\0';
1097                         break;
1098                     }
1099                 }
1100             }
1101         }
1102
1103         if (asprintf (&p_sdp->psz_uri, "%s://%s@%s:%i", vlc_proto, psz_source,
1104                      host, port) == -1)
1105             return VLC_ENOMEM;
1106     }
1107
1108     return VLC_SUCCESS;
1109 }
1110
1111
1112 static int ParseSDPConnection (const char *str, struct sockaddr_storage *addr,
1113                                socklen_t *addrlen, unsigned *number)
1114 {
1115     char host[60];
1116     unsigned fam, n1, n2;
1117
1118     int res = sscanf (str, "IN IP%u %59[^/]/%u/%u", &fam, host, &n1, &n2);
1119     if (res < 2)
1120         return -1;
1121
1122     switch (fam)
1123     {
1124 #ifdef AF_INET6
1125         case 6:
1126             addr->ss_family = AF_INET6;
1127 # ifdef HAVE_SA_LEN
1128             addr->ss_len =
1129 # endif
1130            *addrlen = sizeof (struct sockaddr_in6);
1131
1132             if (inet_pton (AF_INET6, host,
1133                            &((struct sockaddr_in6 *)addr)->sin6_addr) <= 0)
1134                 return -1;
1135
1136             *number = (res >= 3) ? n1 : 1;
1137             break;
1138 #endif
1139
1140         case 4:
1141             addr->ss_family = AF_INET;
1142 # ifdef HAVE_SA_LEN
1143             addr->ss_len =
1144 # endif
1145            *addrlen = sizeof (struct sockaddr_in);
1146
1147             if (inet_pton (AF_INET, host,
1148                            &((struct sockaddr_in *)addr)->sin_addr) <= 0)
1149                 return -1;
1150
1151             *number = (res >= 4) ? n2 : 1;
1152             break;
1153
1154         default:
1155             return -1;
1156     }
1157     return 0;
1158 }
1159
1160
1161 /***********************************************************************
1162  * ParseSDP : SDP parsing
1163  * *********************************************************************
1164  * Validate SDP and parse all fields
1165  ***********************************************************************/
1166 static sdp_t *ParseSDP (vlc_object_t *p_obj, const char *psz_sdp)
1167 {
1168     if( psz_sdp == NULL )
1169         return NULL;
1170
1171     sdp_t *p_sdp = calloc (1, sizeof (*p_sdp));
1172     if (p_sdp == NULL)
1173         return NULL;
1174
1175     char expect = 'V';
1176     struct sockaddr_storage glob_addr;
1177     memset (&glob_addr, 0, sizeof (glob_addr));
1178     socklen_t glob_len = 0;
1179     unsigned glob_count = 1;
1180     int port = 0;
1181
1182     /* TODO: use iconv and charset attribute instead of EnsureUTF8 */
1183     while (*psz_sdp)
1184     {
1185         /* Extract one line */
1186         char *eol = strchr (psz_sdp, '\n');
1187         size_t linelen = eol ? (size_t)(eol - psz_sdp) : strlen (psz_sdp);
1188         char line[linelen + 1];
1189         memcpy (line, psz_sdp, linelen);
1190         line[linelen] = '\0';
1191
1192         psz_sdp += linelen + 1;
1193
1194         /* Remove carriage return if present */
1195         eol = strchr (line, '\r');
1196         if (eol != NULL)
1197         {
1198             linelen = eol - line;
1199             line[linelen] = '\0';
1200         }
1201
1202         /* Validate line */
1203         char cat = line[0], *data = line + 2;
1204         if (!cat || (strchr ("vosiuepcbtrzkam", cat) == NULL))
1205         {
1206             /* MUST ignore SDP with unknown line type */
1207             msg_Dbg (p_obj, "unknown SDP line type: 0x%02x", (int)cat);
1208             goto error;
1209         }
1210         if (line[1] != '=')
1211         {
1212             msg_Dbg (p_obj, "invalid SDP line: %s", line);
1213             goto error;
1214         }
1215
1216         assert (linelen >= 2);
1217
1218         /* SDP parsing state machine
1219          * We INTERNALLY use uppercase for session, lowercase for media
1220          */
1221         switch (expect)
1222         {
1223             /* Session description */
1224             case 'V':
1225                 expect = 'O';
1226                 if (cat != 'v')
1227                 {
1228                     msg_Dbg (p_obj, "missing SDP version");
1229                     goto error;
1230                 }
1231                 if (strcmp (data, "0"))
1232                 {
1233                     msg_Dbg (p_obj, "unknown SDP version: %s", data);
1234                     goto error;
1235                 }
1236                 break;
1237
1238             case 'O':
1239             {
1240                 expect = 'S';
1241                 if (cat != 'o')
1242                 {
1243                     msg_Dbg (p_obj, "missing SDP originator");
1244                     goto error;
1245                 }
1246
1247                 if ((sscanf (data, "%63s %"SCNu64" %"SCNu64" IN IP%u %1023s",
1248                              p_sdp->username, &p_sdp->session_id,
1249                              &p_sdp->session_version, &p_sdp->orig_ip_version,
1250                              p_sdp->orig_host) != 5)
1251                  || ((p_sdp->orig_ip_version != 4)
1252                   && (p_sdp->orig_ip_version != 6)))
1253                 {
1254                     msg_Dbg (p_obj, "SDP origin not supported: %s", data);
1255                     /* Or maybe out-of-range, but this looks suspicious */
1256                     goto error;
1257                 }
1258                 EnsureUTF8 (p_sdp->orig_host);
1259                 break;
1260             }
1261
1262             case 'S':
1263             {
1264                 expect = 'I';
1265                 if ((cat != 's') || !*data)
1266                 {
1267                     /* MUST be present AND non-empty */
1268                     msg_Dbg (p_obj, "missing SDP session name");
1269                     goto error;
1270                 }
1271                 assert (p_sdp->psz_sessionname == NULL); // no memleak here
1272                 p_sdp->psz_sessionname = strdup (data);
1273                 if (p_sdp->psz_sessionname == NULL)
1274                     goto error;
1275                 EnsureUTF8 (p_sdp->psz_sessionname);
1276                 break;
1277             }
1278
1279             case 'I':
1280             {
1281                 expect = 'U';
1282                 /* optional (and may be empty) */
1283                 if (cat == 'i')
1284                 {
1285                     assert (p_sdp->psz_sessioninfo == NULL);
1286                     p_sdp->psz_sessioninfo = strdup (data);
1287                     if (p_sdp->psz_sessioninfo == NULL)
1288                         goto error;
1289                     EnsureUTF8 (p_sdp->psz_sessioninfo);
1290                     break;
1291                 }
1292             }
1293
1294             case 'U':
1295                 expect = 'E';
1296                 if (cat == 'u')
1297                     break;
1298             case 'E':
1299                 expect = 'E';
1300                 if (cat == 'e')
1301                     break;
1302             case 'P':
1303                 expect = 'P';
1304                 if (cat == 'p')
1305                     break;
1306             case 'C':
1307                 expect = 'B';
1308                 if (cat == 'c')
1309                 {
1310                     if (ParseSDPConnection (data, &glob_addr, &glob_len,
1311                                             &glob_count))
1312                     {
1313                         msg_Dbg (p_obj, "SDP connection infos not supported: "
1314                                  "%s", data);
1315                         goto error;
1316                     }
1317                     break;
1318                 }
1319             case 'B':
1320                 assert (expect == 'B');
1321                 if (cat == 'b')
1322                     break;
1323             case 'T':
1324                 expect = 'R';
1325                 if (cat != 't')
1326                 {
1327                     msg_Dbg (p_obj, "missing SDP time description");
1328                     goto error;
1329                 }
1330                 break;
1331
1332             case 'R':
1333                 if ((cat == 't') || (cat == 'r'))
1334                     break;
1335
1336             case 'Z':
1337                 expect = 'K';
1338                 if (cat == 'z')
1339                     break;
1340             case 'K':
1341                 expect = 'A';
1342                 if (cat == 'k')
1343                     break;
1344             case 'A':
1345                 //expect = 'A';
1346                 if (cat == 'a')
1347                 {
1348                     attribute_t *p_attr = MakeAttribute (data);
1349                     TAB_APPEND( p_sdp->i_attributes, p_sdp->pp_attributes, p_attr );
1350                     break;
1351                 }
1352
1353             /* Media description */
1354             case 'm':
1355             media:
1356             {
1357                 expect = 'i';
1358                 if (cat != 'm')
1359                 {
1360                     msg_Dbg (p_obj, "missing SDP media description");
1361                     goto error;
1362                 }
1363                 struct sdp_media_t *m;
1364                 m = realloc (p_sdp->mediav, (p_sdp->mediac + 1) * sizeof (*m));
1365                 if (m == NULL)
1366                     goto error;
1367
1368                 p_sdp->mediav = m;
1369                 m += p_sdp->mediac;
1370                 p_sdp->mediac++;
1371
1372                 memset (m, 0, sizeof (*m));
1373                 memcpy (&m->addr, &glob_addr, m->addrlen = glob_len);
1374                 m->n_addr = glob_count;
1375
1376                 /* TODO: remember media type (if we need multiple medias) */
1377                 data = strchr (data, ' ');
1378                 if (data == NULL)
1379                 {
1380                     msg_Dbg (p_obj, "missing SDP media port");
1381                     goto error;
1382                 }
1383                 port = atoi (++data);
1384                 if (port <= 0 || port >= 65536)
1385                 {
1386                     msg_Dbg (p_obj, "invalid transport port %d", port);
1387                     goto error;
1388                 }
1389                 net_SetPort ((struct sockaddr *)&m->addr, htons (port));
1390
1391                 data = strchr (data, ' ');
1392                 if (data == NULL)
1393                 {
1394                     msg_Dbg (p_obj, "missing SDP media format");
1395                     goto error;
1396                 }
1397                 m->fmt = strdup (++data);
1398                 if (m->fmt == NULL)
1399                     goto error;
1400
1401                 break;
1402             }
1403             case 'i':
1404                 expect = 'c';
1405                 if (cat == 'i')
1406                     break;
1407             case 'c':
1408                 expect = 'b';
1409                 if (cat == 'c')
1410                 {
1411                     struct sdp_media_t *m = p_sdp->mediav + p_sdp->mediac - 1;
1412                     if (ParseSDPConnection (data, &m->addr, &m->addrlen,
1413                                             &m->n_addr))
1414                     {
1415                         msg_Dbg (p_obj, "SDP connection infos not supported: "
1416                                  "%s", data);
1417                         goto error;
1418                     }
1419                     net_SetPort ((struct sockaddr *)&m->addr, htons (port));
1420                     break;
1421                 }
1422             case 'b':
1423                 expect = 'b';
1424                 if (cat == 'b')
1425                     break;
1426             case 'k':
1427                 expect = 'a';
1428                 if (cat == 'k')
1429                     break;
1430             case 'a':
1431                 assert (expect == 'a');
1432                 if (cat == 'a')
1433                 {
1434                     attribute_t *p_attr = MakeAttribute (data);
1435                     if (p_attr == NULL)
1436                         goto error;
1437
1438                     TAB_APPEND (p_sdp->mediav[p_sdp->mediac - 1].i_attributes,
1439                                 p_sdp->mediav[p_sdp->mediac - 1].pp_attributes, p_attr);
1440                     break;
1441                 }
1442
1443                 if (cat == 'm')
1444                     goto media;
1445
1446                 if (cat != 'm')
1447                 {
1448                     msg_Dbg (p_obj, "unexpected SDP line: 0x%02x", (int)cat);
1449                     goto error;
1450                 }
1451                 break;
1452
1453             default:
1454                 msg_Err (p_obj, "*** BUG in SDP parser! ***");
1455                 goto error;
1456         }
1457     }
1458
1459     return p_sdp;
1460
1461 error:
1462     FreeSDP (p_sdp);
1463     return NULL;
1464 }
1465
1466 static int InitSocket( services_discovery_t *p_sd, const char *psz_address,
1467                        int i_port )
1468 {
1469     int i_fd = net_ListenUDP1 ((vlc_object_t *)p_sd, psz_address, i_port);
1470     if (i_fd == -1)
1471         return VLC_EGENERIC;
1472
1473     shutdown( i_fd, SHUT_WR );
1474     INSERT_ELEM (p_sd->p_sys->pi_fd, p_sd->p_sys->i_fd,
1475                  p_sd->p_sys->i_fd, i_fd);
1476     return VLC_SUCCESS;
1477 }
1478
1479 static int Decompress( const unsigned char *psz_src, unsigned char **_dst, int i_len )
1480 {
1481 #ifdef HAVE_ZLIB_H
1482     int i_result, i_dstsize, n = 0;
1483     unsigned char *psz_dst = NULL;
1484     z_stream d_stream;
1485
1486     memset (&d_stream, 0, sizeof (d_stream));
1487
1488     i_result = inflateInit(&d_stream);
1489     if( i_result != Z_OK )
1490         return( -1 );
1491
1492     d_stream.next_in = (Bytef *)psz_src;
1493     d_stream.avail_in = i_len;
1494
1495     do
1496     {
1497         n++;
1498         psz_dst = (unsigned char *)realloc( psz_dst, n * 1000 );
1499         d_stream.next_out = (Bytef *)&psz_dst[(n - 1) * 1000];
1500         d_stream.avail_out = 1000;
1501
1502         i_result = inflate(&d_stream, Z_NO_FLUSH);
1503         if( ( i_result != Z_OK ) && ( i_result != Z_STREAM_END ) )
1504         {
1505             inflateEnd( &d_stream );
1506             free( psz_dst );
1507             return( -1 );
1508         }
1509     }
1510     while( ( d_stream.avail_out == 0 ) && ( d_stream.avail_in != 0 ) &&
1511            ( i_result != Z_STREAM_END ) );
1512
1513     i_dstsize = d_stream.total_out;
1514     inflateEnd( &d_stream );
1515
1516     *_dst = (unsigned char *)realloc( psz_dst, i_dstsize );
1517
1518     return i_dstsize;
1519 #else
1520     (void)psz_src;
1521     (void)_dst;
1522     (void)i_len;
1523     return -1;
1524 #endif
1525 }
1526
1527
1528 static void FreeSDP( sdp_t *p_sdp )
1529 {
1530     free( p_sdp->psz_sessionname );
1531     free( p_sdp->psz_sessioninfo );
1532     free( p_sdp->psz_uri );
1533
1534     for (unsigned j = 0; j < p_sdp->mediac; j++)
1535     {
1536         free (p_sdp->mediav[j].fmt);
1537         for (int i = 0; i < p_sdp->mediav[j].i_attributes; i++)
1538             FreeAttribute (p_sdp->mediav[j].pp_attributes[i]);
1539         free (p_sdp->mediav[j].pp_attributes);
1540     }
1541     free (p_sdp->mediav);
1542
1543     for (int i = 0; i < p_sdp->i_attributes; i++)
1544         FreeAttribute (p_sdp->pp_attributes[i]);
1545
1546     free (p_sdp->pp_attributes);
1547     free (p_sdp);
1548 }
1549
1550 static int RemoveAnnounce( services_discovery_t *p_sd,
1551                            sap_announce_t *p_announce )
1552 {
1553     int i;
1554
1555     if( p_announce->p_sdp )
1556     {
1557         FreeSDP( p_announce->p_sdp );
1558         p_announce->p_sdp = NULL;
1559     }
1560
1561     if( p_announce->p_item )
1562     {
1563         services_discovery_RemoveItem( p_sd, p_announce->p_item );
1564         vlc_gc_decref( p_announce->p_item );
1565         p_announce->p_item = NULL;
1566     }
1567
1568     for( i = 0; i< p_sd->p_sys->i_announces; i++)
1569     {
1570         if( p_sd->p_sys->pp_announces[i] == p_announce )
1571         {
1572             REMOVE_ELEM( p_sd->p_sys->pp_announces, p_sd->p_sys->i_announces,
1573                          i);
1574             break;
1575         }
1576     }
1577
1578     free( p_announce );
1579
1580     return VLC_SUCCESS;
1581 }
1582
1583 /*
1584  * Compare two sessions, when hash is not set (SAP v0)
1585  */
1586 static bool IsSameSession( sdp_t *p_sdp1, sdp_t *p_sdp2 )
1587 {
1588     /* A session is identified by
1589      * - username,
1590      * - session_id,
1591      * - network type (which is always IN),
1592      * - address type (currently, this means IP version),
1593      * - and hostname.
1594      */
1595     if (strcmp (p_sdp1->username, p_sdp2->username)
1596      || (p_sdp1->session_id != p_sdp2->session_id)
1597      || (p_sdp1->orig_ip_version != p_sdp2->orig_ip_version)
1598      || strcmp (p_sdp1->orig_host, p_sdp2->orig_host))
1599         return false;
1600
1601     return true;
1602 }
1603
1604 static inline attribute_t *MakeAttribute (const char *str)
1605 {
1606     attribute_t *a = malloc (sizeof (*a) + strlen (str) + 1);
1607     if (a == NULL)
1608         return NULL;
1609
1610     strcpy (a->name, str);
1611     EnsureUTF8 (a->name);
1612     char *value = strchr (a->name, ':');
1613     if (value != NULL)
1614     {
1615         *value++ = '\0';
1616         a->value = value;
1617     }
1618     else
1619         a->value = "";
1620     return a;
1621 }
1622
1623
1624 static const char *GetAttribute (attribute_t **tab, unsigned n,
1625                                  const char *name)
1626 {
1627     for (unsigned i = 0; i < n; i++)
1628         if (strcasecmp (tab[i]->name, name) == 0)
1629             return tab[i]->value;
1630     return NULL;
1631 }
1632
1633
1634 static inline void FreeAttribute (attribute_t *a)
1635 {
1636     free (a);
1637 }