Fix a bug with preferences
[vlc.git] / modules / services_discovery / sap.c
1 /*****************************************************************************
2  * sap.c :  SAP interface module
3  *****************************************************************************
4  * Copyright (C) 2004 VideoLAN
5  * $Id$
6  *
7  * Authors: ClĂ©ment Stenac <zorglub@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Includes
26  *****************************************************************************/
27 #include <stdlib.h>                                      /* malloc(), free() */
28
29 #include <vlc/vlc.h>
30 #include <vlc/intf.h>
31
32 #include <vlc/input.h>
33
34 #include "network.h"
35
36 #include <errno.h>                                                 /* ENOMEM */
37
38 #ifdef HAVE_UNISTD_H
39 #    include <unistd.h>
40 #endif
41 #ifdef HAVE_SYS_TIME_H
42 #    include <sys/time.h>
43 #endif
44
45 #ifdef HAVE_ZLIB_H
46 #   include <zlib.h>
47 #endif
48
49 /************************************************************************
50  * Macros and definitions
51  ************************************************************************/
52
53 #define MAX_LINE_LENGTH 256
54
55 /* SAP is always on that port */
56 #define SAP_PORT 9875
57 #define SAP_V4_ADDRESS "224.2.127.254"
58 #define ADD_SESSION 1
59
60 #define IPV6_ADDR_1 "FF0"  /* Scope is inserted between them */
61 #define IPV6_ADDR_2 "::2:7FFE"
62
63
64 /*****************************************************************************
65  * Module descriptor
66  *****************************************************************************/
67 #define SAP_ADDR_TEXT N_( "SAP multicast address" )
68 #define SAP_ADDR_LONGTEXT N_( "Listen for SAP announces on another address" )
69 #define SAP_IPV4_TEXT N_( "IPv4-SAP listening" )
70 #define SAP_IPV4_LONGTEXT N_( \
71       "Set this if you want the SAP module to listen to IPv4 announces " \
72       "on the standard address" )
73 #define SAP_IPV6_TEXT N_( "IPv6-SAP listening" )
74 #define SAP_IPV6_LONGTEXT N_( \
75       "Set this if you want the SAP module to listen to IPv6 announces " \
76       "on the standard address" )
77 #define SAP_SCOPE_TEXT N_( "IPv6 SAP scope" )
78 #define SAP_SCOPE_LONGTEXT N_( \
79        "Sets the scope for IPv6 announces (default is 8)" )
80 #define SAP_TIMEOUT_TEXT N_( "SAP timeout (seconds)" )
81 #define SAP_TIMEOUT_LONGTEXT N_( \
82        "Sets the time before SAP items get deleted if no new announce " \
83        "is received." )
84 #define SAP_PARSE_TEXT N_( "Try to parse the SAP" )
85 #define SAP_PARSE_LONGTEXT N_( \
86        "When SAP can it will try to parse the SAP. If you don't select " \
87        "this, all announces will be parsed by the livedotcom module" )
88 #define SAP_STRICT_TEXT N_( "SAP Strict mode" )
89 #define SAP_STRICT_LONGTEXT N_( \
90        "When this is set, the SAP parser will discard some non-compliant " \
91        "announces" )
92 #define SAP_CACHE_TEXT N_("Use SAP cache")
93 #define SAP_CACHE_LONGTEXT N_( \
94        "If this option is selected, a SAP caching mechanism will be used." \
95        "This will result in lower SAP startup time, but you could end up " \
96         "with items corresponding to legacy streams." )
97
98 /* Callbacks */
99     static int  Open ( vlc_object_t * );
100     static void Close( vlc_object_t * );
101     static int  OpenDemux ( vlc_object_t * );
102     static void CloseDemux ( vlc_object_t * );
103
104 vlc_module_begin();
105     set_description( _("SAP interface") );
106     set_category( CAT_PLAYLIST );
107     set_subcategory( SUBCAT_PLAYLIST_SD );
108
109     add_string( "sap-addr", NULL, NULL,
110                 SAP_ADDR_TEXT, SAP_ADDR_LONGTEXT, VLC_TRUE );
111     add_bool( "sap-ipv4", 1 , NULL,
112                SAP_IPV4_TEXT,SAP_IPV4_LONGTEXT, VLC_TRUE );
113     add_bool( "sap-ipv6", 0 , NULL,
114               SAP_IPV6_TEXT, SAP_IPV6_LONGTEXT, VLC_TRUE );
115     add_string( "sap-ipv6-scope", "8" , NULL,
116                 SAP_SCOPE_TEXT, SAP_SCOPE_LONGTEXT, VLC_TRUE);
117     add_integer( "sap-timeout", 1800, NULL,
118                  SAP_TIMEOUT_TEXT, SAP_TIMEOUT_LONGTEXT, VLC_TRUE );
119     add_bool( "sap-parse", 1 , NULL,
120                SAP_PARSE_TEXT,SAP_PARSE_LONGTEXT, VLC_TRUE );
121     add_bool( "sap-strict", 0 , NULL,
122                SAP_STRICT_TEXT,SAP_STRICT_LONGTEXT, VLC_TRUE );
123     add_bool( "sap-cache", 0 , NULL,
124                SAP_CACHE_TEXT,SAP_CACHE_LONGTEXT, VLC_TRUE );
125
126     set_capability( "services_discovery", 0 );
127     set_callbacks( Open, Close );
128
129     add_submodule();
130         set_description( _("SDP file parser for UDP") );
131         add_shortcut( "sdp" );
132         set_capability( "demux2", 51 );
133         set_callbacks( OpenDemux, CloseDemux );
134 vlc_module_end();
135
136
137 /*****************************************************************************
138  * Local structures
139  *****************************************************************************/
140
141 typedef struct sdp_t sdp_t;
142 typedef struct attribute_t attribute_t;
143 typedef struct sap_announce_t sap_announce_t;
144
145 /* The structure that contains sdp information */
146 struct  sdp_t
147 {
148     char *psz_sdp;
149
150     /* s= field */
151     char *psz_sessionname;
152
153     /* Raw m= and c= fields */
154     char *psz_connection;
155     char *psz_media;
156
157     /* o field */
158     char *psz_username;
159     char *psz_network_type;
160     char *psz_address_type;
161     char *psz_address;
162     int64_t i_session_id;
163
164     /* "computed" URI */
165     char *psz_uri;
166
167     int         i_in; /* IP version */
168
169     int           i_media;
170     int           i_media_type;
171
172     int           i_attributes;
173     attribute_t  **pp_attributes;
174 };
175
176 struct attribute_t
177 {
178     char *psz_field;
179     char *psz_value;
180 };
181
182 struct sap_announce_t
183 {
184     mtime_t i_last;
185
186     uint16_t    i_hash;
187     uint32_t    i_source[4];
188
189     /* SAP annnounces must only contain one SDP */
190     sdp_t       *p_sdp;
191
192     playlist_item_t *p_item;
193 };
194
195 struct services_discovery_sys_t
196 {
197     /* Socket descriptors */
198     int i_fd;
199     int *pi_fd;
200
201     /* playlist node */
202     playlist_item_t *p_node;
203
204     /* Table of announces */
205     int i_announces;
206     struct sap_announce_t **pp_announces;
207
208     /* Modes */
209     vlc_bool_t  b_strict;
210     vlc_bool_t  b_parse;
211
212     int i_timeout;
213 };
214
215 struct demux_sys_t
216 {
217     sdp_t *p_sdp;
218 };
219
220 /*****************************************************************************
221  * Local prototypes
222  *****************************************************************************/
223
224
225 /* Main functions */
226     static int Demux( demux_t *p_demux );
227     static int Control( demux_t *, int, va_list );
228     static void Run    ( services_discovery_t *p_sd );
229
230 /* Main parsing functions */
231     static int ParseConnection( vlc_object_t *p_obj, sdp_t *p_sdp );
232     static int ParseSAP( services_discovery_t *p_sd, uint8_t *p_buffer, int i_read );
233     static sdp_t *  ParseSDP( vlc_object_t *p_sd, char* psz_sdp );
234     static sap_announce_t *CreateAnnounce( services_discovery_t *, uint16_t, sdp_t * );
235     static int RemoveAnnounce( services_discovery_t *p_sd, sap_announce_t *p_announce );
236
237 /* Cache */
238     static void CacheLoad( services_discovery_t *p_sd );
239     static void CacheSave( services_discovery_t *p_sd );
240 /* Helper functions */
241    static char *GetAttribute( sdp_t *p_sdp, const char *psz_search );
242    static vlc_bool_t IsSameSession( sdp_t *p_sdp1, sdp_t *p_sdp2 );
243    static int InitSocket( services_discovery_t *p_sd, char *psz_address, int i_port );
244 #ifdef HAVE_ZLIB_H
245    static int Decompress( unsigned char *psz_src, unsigned char **_dst, int i_len );
246     static void FreeSDP( sdp_t *p_sdp );
247 #endif
248
249 /* Detect multicast addresses */
250 static int  ismult( char * );
251
252 #define FREE( p ) \
253     if( p ) { free( p ); (p) = NULL; }
254 /*****************************************************************************
255  * Open: initialize and create stuff
256  *****************************************************************************/
257 static int Open( vlc_object_t *p_this )
258 {
259     services_discovery_t *p_sd = ( services_discovery_t* )p_this;
260     services_discovery_sys_t *p_sys  = (services_discovery_sys_t *)
261                                 malloc( sizeof( services_discovery_sys_t ) );
262
263     playlist_t          *p_playlist;
264     playlist_view_t     *p_view;
265     char                *psz_addr;
266     vlc_value_t         val;
267
268     p_sys->i_timeout = config_GetInt( p_sd,"sap-timeout" );
269
270     p_sd->pf_run = Run;
271     p_sd->p_sys  = p_sys;
272
273     p_sys->pi_fd = NULL;
274     p_sys->i_fd = 0;
275
276     p_sys->b_strict = config_GetInt( p_sd, "sap-strict");
277     p_sys->b_parse = config_GetInt( p_sd, "sap-parse" );
278
279     if( config_GetInt( p_sd, "sap-cache" ) )
280     {
281         CacheLoad( p_sd );
282     }
283
284     if( config_GetInt( p_sd, "sap-ipv4" ) )
285     {
286         InitSocket( p_sd, SAP_V4_ADDRESS, SAP_PORT );
287     }
288     if( config_GetInt( p_sd, "sap-ipv6" ) )
289     {
290         /* [ + 8x4+7*':' + ] */
291         char psz_address[42];
292         char c_scope;
293         char *psz_scope = config_GetPsz( p_sd, "sap-ipv6-scope" );
294
295         if( psz_scope == NULL || *psz_scope == '\0')
296         {
297             c_scope = '8';
298         }
299         else
300         {
301             c_scope = psz_scope[0];
302         }
303         snprintf( psz_address, 42, "[%s%c%s]", IPV6_ADDR_1, c_scope,
304                                                IPV6_ADDR_2 );
305         InitSocket( p_sd, psz_address, SAP_PORT );
306     }
307
308     psz_addr = config_GetPsz( p_sd, "sap-addr" );
309     if( psz_addr && *psz_addr )
310     {
311         InitSocket( p_sd, psz_addr, SAP_PORT );
312     }
313
314     if( p_sys->i_fd == 0 )
315     {
316         msg_Err( p_sd, "unable to read on any address");
317         return VLC_EGENERIC;
318     }
319
320     /* Create our playlist node */
321     p_playlist = (playlist_t *)vlc_object_find( p_sd, VLC_OBJECT_PLAYLIST,
322                                                 FIND_ANYWHERE );
323     if( !p_playlist )
324     {
325         msg_Warn( p_sd, "unable to find playlist, cancelling SAP listening");
326         return VLC_EGENERIC;
327     }
328
329     p_view = playlist_ViewFind( p_playlist, VIEW_CATEGORY );
330     p_sys->p_node = playlist_NodeCreate( p_playlist, VIEW_CATEGORY,
331                                          _("SAP"), p_view->p_root );
332     p_sys->p_node->i_flags |= PLAYLIST_RO_FLAG;
333     val.b_bool = VLC_TRUE;
334     var_Set( p_playlist, "intf-change", val );
335
336     vlc_object_release( p_playlist );
337
338     p_sys->i_announces = 0;
339     p_sys->pp_announces = NULL;
340
341     return VLC_SUCCESS;
342 }
343
344 /*****************************************************************************
345  * OpenDemux: initialize and create stuff
346  *****************************************************************************/
347 static int OpenDemux( vlc_object_t *p_this )
348 {
349     demux_t *p_demux = (demux_t *)p_this;
350     uint8_t *p_peek;
351     int i_max_sdp = 1024;
352     int i_sdp = 0;
353     char *psz_sdp = (char *)malloc( i_max_sdp );
354     sdp_t *p_sdp = NULL;
355
356     if( !psz_sdp )
357     {
358         return VLC_EGENERIC;
359     }
360
361     
362     /* Probe for SDP */
363     if( p_demux->s )
364     {
365         if( stream_Peek( p_demux->s, &p_peek, 7 ) < 7 )
366         {
367             msg_Err( p_demux, "cannot peek" );
368             return VLC_EGENERIC;
369         }
370         if( strncmp( (char*)p_peek, "v=0\r\n", 5 ) &&
371             strncmp( (char*)p_peek, "v=0\n", 4 ) &&
372             ( p_peek[0] < 'a' || p_peek[0] > 'z' || p_peek[1] != '=' ) )
373         {
374             msg_Warn( p_demux, "SDP (UDP) module discarded" );
375             return VLC_EGENERIC;
376         }
377     }
378
379     /* Gather the complete sdp file */
380     for( ;; )
381     {
382         int i_read = stream_Read( p_demux->s,
383                                   &psz_sdp[i_sdp], i_max_sdp - i_sdp - 1 );
384         
385         if( i_read < 0 )
386             
387         {
388             msg_Err( p_demux, "failed to read SDP" );
389             goto error;
390         }
391
392         i_sdp += i_read;
393
394         if( i_read < i_max_sdp - i_sdp - 1 )
395         {
396             psz_sdp[i_sdp] = '\0';
397             break;
398         }
399
400         i_max_sdp += 1000;
401         psz_sdp = (uint8_t*)realloc( psz_sdp, i_max_sdp );
402     }
403     
404     p_sdp = ParseSDP( VLC_OBJECT(p_demux), psz_sdp );
405     
406     if( !p_sdp )
407     {
408         msg_Warn( p_demux, "invalid SDP");
409         goto error;
410     }
411     
412     if( p_sdp->i_media > 1 )
413     {
414         goto error;
415     }
416     
417     if( ParseConnection( VLC_OBJECT( p_demux ), p_sdp ) )
418     {
419         p_sdp->psz_uri = NULL;
420     }
421     if( p_sdp->i_media_type != 33 && p_sdp->i_media_type != 32 && p_sdp->i_media_type != 14 )
422         goto error;
423     
424     if( p_sdp->psz_uri == NULL ) goto error;
425
426     p_demux->p_sys = (demux_sys_t *)malloc( sizeof(demux_sys_t) );
427     p_demux->p_sys->p_sdp = p_sdp;
428     p_demux->pf_control = Control;
429     p_demux->pf_demux = Demux;
430
431     free( psz_sdp );
432     if( p_sdp ) FreeSDP( p_sdp );
433     return VLC_SUCCESS;
434     
435 error:
436     free( psz_sdp );
437     if( p_sdp ) FreeSDP( p_sdp );
438     stream_Seek( p_demux->s, 0 );
439     return VLC_EGENERIC;    
440 }
441
442 /*****************************************************************************
443  * Close:
444  *****************************************************************************/
445 static void Close( vlc_object_t *p_this )
446 {
447     services_discovery_t *p_sd = ( services_discovery_t* )p_this;
448     services_discovery_sys_t    *p_sys  = p_sd->p_sys;
449
450     playlist_t *p_playlist;
451     int i;
452
453     for( i = p_sys->i_fd-1 ; i >= 0 ; i-- )
454     {
455         net_Close( p_sys->pi_fd[i] );
456     }
457
458     if( config_GetInt( p_sd, "sap-cache" ) )
459     {
460         CacheSave( p_sd );
461     }
462
463     for( i = p_sys->i_announces  - 1;  i>= 0; i-- )
464     {
465         RemoveAnnounce( p_sd, p_sys->pp_announces[i] );
466     }
467
468     p_playlist = (playlist_t *) vlc_object_find( p_sd, VLC_OBJECT_PLAYLIST,
469                                                  FIND_ANYWHERE );
470
471     if( p_playlist )
472     {
473         playlist_NodeDelete( p_playlist, p_sys->p_node, VLC_TRUE );
474         vlc_object_release( p_playlist );
475     }
476
477     free( p_sys );
478 }
479
480 /*****************************************************************************
481  * CloseDemux: Close the demuxer
482  *****************************************************************************/
483 static void CloseDemux( vlc_object_t *p_this )
484 {
485
486 }
487
488 /*****************************************************************************
489  * Run: main SAP thread
490  *****************************************************************************
491  * Listens to SAP packets, and sends them to packet_handle
492  *****************************************************************************/
493 #define MAX_SAP_BUFFER 5000
494
495 static void Run( services_discovery_t *p_sd )
496 {
497     uint8_t     *p_buffer;
498     /* Dirty hack to slow down the startup of the sap interface */
499     /* Unneeded now : our node is in no_select mode */
500     //    msleep( 500000 );
501
502     /* read SAP packets */
503     while( !p_sd->b_die )
504     {
505         int i_read;
506         p_buffer = (uint8_t *)malloc( MAX_SAP_BUFFER );
507
508         if( !p_buffer )
509         {
510             msg_Err( p_sd, "out of memory");
511             p_sd->b_die = VLC_TRUE;
512             continue;
513         }
514
515         i_read = net_Select( p_sd, p_sd->p_sys->pi_fd, NULL,
516                              p_sd->p_sys->i_fd, p_buffer,
517                              MAX_SAP_BUFFER, 500000 );
518 #if 0
519         /* Check for items that need deletion */
520         for( i = 0 ; i< p_sd->p_sys->i_announces ; i++ )
521         {
522            struct sap_announce_t *p_announce;
523            mtime_t i_timeout = ( mtime_t ) 1000000*p_sys->i_timeout;
524            if( mdate() - p_sd->p_sys->pp_announces[i]->i_last > i_timeout )
525            {
526                msg_Dbg( p_sd,"Time out for %s, deleting (%i/%i)",
527                         p_sd->p_sys->pp_announces[i]->psz_name,
528                         i , p_sd->p_sys->i_announces );
529
530              /* Remove the playlist item */
531                p_playlist = vlc_object_find( p_sd, VLC_OBJECT_PLAYLIST,
532                               FIND_ANYWHERE );
533                if( p_playlist )
534                {
535                    int i_pos = playlist_GetPositionById( p_playlist,
536                               p_sd->p_sys->pp_announces[i]->i_id );
537                    playlist_Delete( p_playlist, i_pos );
538                    vlc_object_release( p_playlist );
539                }
540
541                /* Free the p_announce */
542                p_announce =  p_sd->p_sys->pp_announces[i];
543                if( p_announce->psz_name )
544                   free(  p_announce->psz_name );
545                if( p_announce->psz_uri )
546                   free(  p_announce->psz_uri );
547
548               /* Remove the sap_announce from the array */
549               REMOVE_ELEM( p_sd->p_sys->pp_announces,
550                            p_sd->p_sys->i_announces, i );
551
552               free( p_announce );
553
554            }
555         }
556 #endif
557
558         /* Minimum length is > 6 */
559         if( i_read <= 6 )
560         {
561             if( i_read < 0 )
562             {
563                 msg_Warn( p_sd, "socket read error" );
564             }
565             free( p_buffer );
566             continue;
567         }
568
569         p_buffer[i_read] = '\0';
570
571         /* Parse the packet */
572         ParseSAP( p_sd, p_buffer, i_read );
573
574         free( p_buffer );
575     }
576 }
577
578 /**********************************************************************
579  * Demux: reads and demuxes data packets
580  * Return -1 if error, 0 if EOF, 1 else
581  **********************************************************************/
582 static int Demux( demux_t *p_demux )
583 {
584     sdp_t *p_sdp = p_demux->p_sys->p_sdp;
585     playlist_t *p_playlist;
586
587    p_playlist = (playlist_t *)vlc_object_find( p_demux, VLC_OBJECT_PLAYLIST,
588                                                FIND_ANYWHERE );
589
590    p_playlist->status.p_item->i_flags |= PLAYLIST_DEL_FLAG;
591
592    playlist_Add( p_playlist, p_sdp->psz_uri, p_sdp->psz_sessionname,
593                  PLAYLIST_APPEND, PLAYLIST_END );
594
595    vlc_object_release( p_playlist );
596
597    return VLC_SUCCESS;
598 }
599
600 static int Control( demux_t *p_demux, int i_query, va_list args )
601 {
602     return VLC_EGENERIC;
603 }
604
605 /**************************************************************
606  * Local functions
607  **************************************************************/
608
609 /* i_read is at least > 6 */
610 static int ParseSAP( services_discovery_t *p_sd, uint8_t *p_buffer, int i_read )
611 {
612     int                 i_version, i_address_type, i_hash, i;
613     uint8_t             *psz_sdp;
614     uint8_t             *psz_initial_sdp;
615     sdp_t               *p_sdp;
616     vlc_bool_t          b_compressed;
617     vlc_bool_t          b_need_delete = VLC_FALSE;
618 #ifdef HAVE_ZLIB_H
619     int                 i_decompressed_size;
620     uint8_t             *p_decompressed_buffer;
621 #endif
622     uint8_t             *psz_foo;
623
624     /* First, check the sap announce is correct */
625     i_version = p_buffer[0] >> 5;
626
627     if( i_version != 1 )
628     {
629        msg_Dbg( p_sd, "strange sap version %d found", i_version );
630     }
631
632     i_address_type = p_buffer[0] & 0x10;
633
634     if( (p_buffer[0] & 0x08) != 0 )
635     {
636         msg_Dbg( p_sd, "reserved bit incorrectly set" );
637         return VLC_EGENERIC;
638     }
639
640     if( (p_buffer[0] & 0x04) != 0 )
641     {
642         msg_Dbg( p_sd, "session deletion packet" );
643         b_need_delete = VLC_TRUE;
644     }
645
646     if( p_buffer[0] & 0x02  )
647     {
648         msg_Dbg( p_sd, "encrypted packet, unsupported" );
649         return VLC_EGENERIC;
650     }
651
652     b_compressed = p_buffer[0] & 0x01;
653
654     i_hash = ( p_buffer[2] << 8 ) + p_buffer[3];
655
656     if( p_sd->p_sys->b_strict && i_hash == 0 )
657     {
658         msg_Dbg( p_sd, "strict mode, discarding announce with null id hash");
659         return VLC_EGENERIC;
660     }
661
662     psz_sdp  = &p_buffer[4];
663     psz_initial_sdp = psz_sdp;
664
665     if( i_address_type == 0 ) /* ipv4 source address */
666     {
667         psz_sdp += 4;
668         if( i_read <= 9 )
669         {
670             msg_Warn( p_sd,"too short SAP packet\n" );
671             return VLC_EGENERIC;
672         }
673     }
674     else /* ipv6 source address */
675     {
676         psz_sdp += 16;
677         if( i_read <= 21 )
678         {
679             msg_Warn( p_sd,"too short SAP packet\n" );
680             return VLC_EGENERIC;
681         }
682     }
683
684     if( b_compressed )
685     {
686 #ifdef HAVE_ZLIB_H
687         i_decompressed_size = Decompress( psz_sdp,
688                    &p_decompressed_buffer,i_read - ( psz_sdp - p_buffer ) );
689         if( i_decompressed_size > 0 && i_decompressed_size < MAX_SAP_BUFFER )
690         {
691             memcpy( psz_sdp, p_decompressed_buffer, i_decompressed_size );
692             psz_sdp[i_decompressed_size] = '\0';
693             free( p_decompressed_buffer );
694         }
695 #else
696         msg_Warn( p_sd, "Ignoring compressed sap packet" );
697         return VLC_EGENERIC;
698 #endif
699     }
700
701     /* Add the size of authentification info */
702     if( i_read < p_buffer[1] + (psz_sdp - psz_initial_sdp ) )
703     {
704         msg_Warn( p_sd, "too short SAP packet\n");
705         return VLC_EGENERIC;
706     }
707     psz_sdp += p_buffer[1];
708     psz_foo = psz_sdp;
709
710     /* Skip payload type */
711     /* Handle announces without \0 between SAP and SDP */
712     while( *psz_sdp != '\0' && ( psz_sdp[0] != 'v' && psz_sdp[1] != '=' ) )
713     {
714         if( psz_sdp - psz_initial_sdp >= i_read - 5 )
715         {
716             msg_Warn( p_sd, "empty SDP ?");
717         }
718         psz_sdp++;
719     }
720
721     if( *psz_sdp == '\0' )
722     {
723         psz_sdp++;
724     }
725     if( psz_sdp != psz_foo && strcasecmp( psz_foo, "application/sdp" ) )
726     {
727         msg_Dbg( p_sd, "unhandled content type: %s", psz_foo );        
728     }
729     if( psz_sdp -p_buffer >= i_read )
730     {
731         msg_Warn( p_sd, "package without content" );
732         return VLC_EGENERIC;
733     }
734
735     /* Parse SDP info */
736     p_sdp = ParseSDP( VLC_OBJECT(p_sd), psz_sdp );
737
738     if( p_sdp == NULL )
739     {
740         return VLC_EGENERIC;
741     }
742
743     /* Decide whether we should add a playlist item for this SDP */
744     /* Parse connection information (c= & m= ) */
745     if( ParseConnection( VLC_OBJECT(p_sd), p_sdp ) )
746     {
747         p_sdp->psz_uri = NULL;
748     }
749
750     /* Multi-media or no-parse -> pass to LIVE.COM */
751     if( p_sdp->i_media > 1 || ( p_sdp->i_media_type != 14 &&
752                                 p_sdp->i_media_type != 32 &&
753                                 p_sdp->i_media_type != 33) ||
754         p_sd->p_sys->b_parse == VLC_FALSE )
755     {
756         if( p_sdp->psz_uri ) free( p_sdp->psz_uri );
757         asprintf( &p_sdp->psz_uri, "sdp://%s", p_sdp->psz_sdp );
758     }
759
760     if( p_sdp->psz_uri == NULL ) return VLC_EGENERIC;
761
762     for( i = 0 ; i< p_sd->p_sys->i_announces ; i++ )
763     {
764         /* FIXME: slow */
765         /* FIXME: we create a new announce each time the sdp changes */
766         if( IsSameSession( p_sd->p_sys->pp_announces[i]->p_sdp, p_sdp ) )
767         {
768             if( b_need_delete )
769             {
770                 RemoveAnnounce( p_sd, p_sd->p_sys->pp_announces[i]);
771                 return VLC_SUCCESS;
772             }
773             else
774             {
775                 p_sd->p_sys->pp_announces[i]->i_last = mdate();
776                 FreeSDP( p_sdp );
777                 return VLC_SUCCESS;
778             }
779         }
780     }
781     /* Add item */
782     if( p_sdp->i_media > 1 )
783     {
784         msg_Dbg( p_sd, "passing to LIVE.COM" );
785     }
786
787     CreateAnnounce( p_sd, i_hash, p_sdp );
788
789     return VLC_SUCCESS;
790 }
791
792 sap_announce_t *CreateAnnounce( services_discovery_t *p_sd, uint16_t i_hash,
793                                 sdp_t *p_sdp )
794 {
795     playlist_t          *p_playlist;
796     playlist_item_t     *p_item, *p_child;
797     char                *psz_value;
798     sap_announce_t *p_sap = (sap_announce_t *)malloc(
799                                         sizeof(sap_announce_t ) );
800     if( !p_sap )
801     {
802         msg_Err( p_sd, "out of memory");
803         p_sd->b_die = VLC_TRUE;
804         return NULL;
805     }
806     p_sap->i_last = mdate();
807     p_sap->i_hash = i_hash;
808     p_sap->p_sdp = p_sdp;
809     p_sap->p_item = NULL;
810
811     /* Create the playlist item here */
812     p_item = playlist_ItemNew( p_sd, p_sap->p_sdp->psz_uri,
813                                p_sap->p_sdp->psz_sessionname );
814
815     if( !p_item )
816     {
817         return NULL;
818     }
819
820     psz_value = GetAttribute( p_sap->p_sdp, "x-plgroup" );
821
822     if( psz_value == NULL )
823     {
824         psz_value = GetAttribute( p_sap->p_sdp, "plgroup" );
825     }
826
827     p_playlist = (playlist_t *)vlc_object_find( p_sd, VLC_OBJECT_PLAYLIST,
828                                                 FIND_ANYWHERE );
829     if( !p_playlist )
830     {
831         msg_Err( p_sd, "playlist not found" );
832         FREE( psz_value );
833         free( p_sap );
834         return NULL;
835     }
836
837     if( psz_value != NULL )
838     {
839         p_child = playlist_ChildSearchName( p_sd->p_sys->p_node, psz_value );
840
841         if( p_child == NULL )
842         {
843             p_child = playlist_NodeCreate( p_playlist, VIEW_CATEGORY,
844                                            psz_value, p_sd->p_sys->p_node );
845         }
846     }
847     else
848     {
849         p_child = p_sd->p_sys->p_node;
850     }
851
852     p_item->i_flags &= ~PLAYLIST_SKIP_FLAG;
853
854     playlist_NodeAddItem( p_playlist, p_item, VIEW_CATEGORY, p_child,
855                           PLAYLIST_APPEND, PLAYLIST_END );
856
857     vlc_object_release( p_playlist );
858
859     p_sap->p_item = p_item;
860
861     TAB_APPEND( p_sd->p_sys->i_announces,
862                 p_sd->p_sys->pp_announces, p_sap );
863
864     return p_sap;
865 }
866
867 static char *GetAttribute( sdp_t *p_sdp, const char *psz_search )
868 {
869     int i;
870
871     for( i = 0 ; i< p_sdp->i_attributes; i++ )
872     {
873         if( !strncmp( p_sdp->pp_attributes[i]->psz_field, psz_search,
874                       strlen( p_sdp->pp_attributes[i]->psz_field ) ) )
875         {
876             return p_sdp->pp_attributes[i]->psz_value;
877         }
878     }
879     return NULL;
880 }
881
882
883 /* Fill p_sdp->psz_uri */
884 static int ParseConnection( vlc_object_t *p_obj, sdp_t *p_sdp )
885 {
886     char *psz_eof;
887     char *psz_parse;
888     char *psz_uri = NULL;
889     char *psz_proto = NULL;
890     int i_port = 0;
891
892     /* Parse c= field */
893     if( p_sdp->psz_connection )
894     {
895         psz_parse = p_sdp->psz_connection;
896
897         psz_eof = strchr( psz_parse, ' ' );
898
899         if( psz_eof )
900         {
901             *psz_eof = '\0';
902             psz_parse = psz_eof + 1;
903         }
904         else
905         {
906             msg_Warn( p_obj, "unable to parse c field (1)");
907             return VLC_EGENERIC;
908         }
909
910         psz_eof = strchr( psz_parse, ' ' );
911
912         if( psz_eof )
913         {
914             *psz_eof = '\0';
915             if( !strncmp( psz_parse, "IP4", 3 ) )
916             {
917                 p_sdp->i_in = 4;
918             }
919             else if( !strncmp( psz_parse, "IP6", 3 ) )
920             {
921                 p_sdp->i_in = 6;
922             }
923             else
924             {
925                 p_sdp->i_in = 0;
926             }
927             psz_parse = psz_eof + 1;
928         }
929         else
930         {
931             msg_Warn( p_obj, "unable to parse c field (2)");
932             return VLC_EGENERIC;
933         }
934
935         psz_eof = strchr( psz_parse, '/' );
936
937         if( psz_eof )
938         {
939             *psz_eof = 0;
940         }
941         else
942         {
943             msg_Dbg( p_obj, "incorrect c field");
944         }
945         psz_uri = strdup( psz_parse );
946
947     }
948
949     /* Parse m= field */
950     if( p_sdp->psz_media )
951     {
952         psz_parse = p_sdp->psz_media;
953
954         psz_eof = strchr( psz_parse, ' ' );
955
956         if( psz_eof )
957         {
958             *psz_eof = '\0';
959
960             if( strncmp( psz_parse, "audio", 5 )  &&
961                 strncmp( psz_parse, "video",5 ) )
962             {
963                 msg_Warn( p_obj, "unhandled media type -%s-", psz_parse );
964                 FREE( psz_uri );
965                 return VLC_EGENERIC;
966             }
967
968             psz_parse = psz_eof + 1;
969         }
970         else
971         {
972             msg_Warn( p_obj, "unable to parse m field (1)");
973             FREE( psz_uri );
974             return VLC_EGENERIC;
975         }
976
977         psz_eof = strchr( psz_parse, ' ' );
978
979         if( psz_eof )
980         {
981             *psz_eof = '\0';
982
983             /* FIXME : multiple port ! */
984             i_port = atoi( psz_parse );
985
986             if( i_port <= 0 || i_port >= 65536 )
987             {
988                 msg_Warn( p_obj, "invalid transport port %i", i_port );
989             }
990
991             psz_parse = psz_eof + 1;
992         }
993         else
994         {
995             msg_Warn( p_obj, "unable to parse m field (2)");
996             FREE( psz_uri );
997             return VLC_EGENERIC;
998         }
999
1000         psz_eof = strchr( psz_parse, ' ' );
1001
1002         if( psz_eof )
1003         {
1004             *psz_eof = '\0';
1005             psz_proto = strdup( psz_parse );
1006
1007             psz_parse = psz_eof + 1;
1008             p_sdp->i_media_type = atoi( psz_parse );
1009             
1010         }
1011         else
1012         {
1013             msg_Dbg( p_obj, "incorrect m field");
1014             p_sdp->i_media_type = 33;
1015             psz_proto = strdup( psz_parse );
1016         }
1017     }
1018
1019     if( psz_proto && !strncmp( psz_proto, "RTP/AVP", 7 ) )
1020     {
1021         free( psz_proto );
1022         psz_proto = strdup( "rtp" );
1023     }
1024     if( psz_proto && !strncmp( psz_proto, "UDP", 3 ) )
1025     {
1026         free( psz_proto );
1027         psz_proto = strdup( "udp" );
1028     }
1029                     
1030
1031     /* FIXME: HTTP support */
1032
1033     if( i_port == 0 )
1034     {
1035         i_port = 1234;
1036     }
1037
1038     if( ismult( psz_uri ) )
1039     {
1040         asprintf( &p_sdp->psz_uri, "%s://@%s:%i", psz_proto, psz_uri, i_port );
1041     }
1042     else
1043     {
1044         asprintf( &p_sdp->psz_uri, "%s://%s:%i", psz_proto, psz_uri, i_port );
1045     }
1046     FREE( psz_uri );
1047     FREE( psz_proto );
1048     return VLC_SUCCESS;
1049 }
1050
1051 /***********************************************************************
1052  * ParseSDP : SDP parsing
1053  * *********************************************************************
1054  * Validate SDP and parse all fields
1055  ***********************************************************************/
1056 static sdp_t *  ParseSDP( vlc_object_t *p_obj, char* psz_sdp )
1057 {
1058     sdp_t *p_sdp;
1059     vlc_bool_t b_invalid = VLC_FALSE;
1060     vlc_bool_t b_end = VLC_FALSE;
1061
1062     if( psz_sdp == NULL )
1063     {
1064         return NULL;
1065     }
1066
1067     if( psz_sdp[0] != 'v' || psz_sdp[1] != '=' )
1068     {
1069         msg_Warn( p_obj, "Bad packet" );
1070         return NULL;
1071     }
1072
1073     p_sdp = (sdp_t *)malloc( sizeof( sdp_t ) );
1074
1075     p_sdp->psz_sdp = strdup( psz_sdp );
1076
1077     p_sdp->psz_sessionname = NULL;
1078     p_sdp->psz_media       = NULL;
1079     p_sdp->psz_connection  = NULL;
1080     p_sdp->psz_uri         = NULL;
1081     p_sdp->psz_address     = NULL;
1082     p_sdp->psz_address_type= NULL;
1083
1084     p_sdp->i_media         = 0;
1085     p_sdp->i_attributes    = 0;
1086     p_sdp->pp_attributes   = NULL;
1087
1088     while( *psz_sdp != '\0' && b_end == VLC_FALSE  )
1089     {
1090         char *psz_eol;
1091         char *psz_eof;
1092         char *psz_parse;
1093         char *psz_sess_id;
1094
1095         while( *psz_sdp == '\r' || *psz_sdp == '\n' ||
1096                *psz_sdp == ' ' || *psz_sdp == '\t' )
1097         {
1098             psz_sdp++;
1099         }
1100
1101         if( ( psz_eol = strchr( psz_sdp, '\n' ) ) == NULL )
1102         {
1103             psz_eol = psz_sdp + strlen( psz_sdp );
1104             b_end = VLC_TRUE;
1105         }
1106         if( psz_eol > psz_sdp && *( psz_eol - 1 ) == '\r' )
1107         {
1108             psz_eol--;
1109         }
1110
1111         if( psz_eol <= psz_sdp )
1112         {
1113             break;
1114         }
1115         *psz_eol++ = '\0';
1116
1117         /* no space allowed between fields */
1118         if( psz_sdp[1] != '=' )
1119         {
1120             msg_Warn( p_obj, "invalid packet" ) ;
1121             /* MEMLEAK ! */
1122             return NULL;
1123         }
1124
1125         /* Now parse each line */
1126         switch( psz_sdp[0] )
1127         {
1128             case( 'v' ):
1129                 break;
1130             case( 's' ):
1131                 p_sdp->psz_sessionname = strdup( &psz_sdp[2] );
1132                 break;
1133             case ( 'o' ):
1134             {
1135                 int i_field = 0;
1136                 /* o field is <username> <session id> <version>
1137                  *  <network type> <address type> <address> */
1138
1139 #define GET_FIELD( store ) \
1140                 psz_eof = strchr( psz_parse, ' ' ); \
1141                 if( psz_eof ) \
1142                 { \
1143                     *psz_eof=0; store = strdup( psz_parse ); \
1144                 } \
1145                 else \
1146                 { \
1147                     if( i_field != 5 ) \
1148                     { \
1149                         b_invalid = VLC_TRUE; break; \
1150                     } \
1151                     else \
1152                     { \
1153                         store = strdup( psz_parse ); \
1154                     } \
1155                 }; \
1156                 psz_parse = psz_eof + 1; i_field++;
1157
1158
1159                 psz_parse = &psz_sdp[2];
1160                 GET_FIELD( p_sdp->psz_username );
1161                 GET_FIELD( psz_sess_id );
1162
1163                 p_sdp->i_session_id = atoll( psz_sess_id );
1164
1165                 FREE( psz_sess_id );
1166
1167                 GET_FIELD( psz_sess_id );
1168                 FREE( psz_sess_id );
1169
1170                 GET_FIELD( p_sdp->psz_network_type );
1171                 GET_FIELD( p_sdp->psz_address_type );
1172                 GET_FIELD( p_sdp->psz_address );
1173
1174                 break;
1175             }
1176             case( 'i' ):
1177             case( 'u' ):
1178             case( 'e' ):
1179             case( 'p' ):
1180             case( 't' ):
1181             case( 'r' ):
1182                 break;
1183             case( 'a' ): /* attribute */
1184             {
1185                 char *psz_eon = strchr( &psz_sdp[2], ':' );
1186                 attribute_t *p_attr = malloc( sizeof( attribute_t ) );
1187
1188                 /* Attribute with value */
1189                 if( psz_eon )
1190                 {
1191                     *psz_eon++ = '\0';
1192
1193                     p_attr->psz_field = strdup( &psz_sdp[2] );
1194                     p_attr->psz_value = strdup( psz_eon );
1195                 }
1196                 else /* Attribute without value */
1197                 {
1198                     p_attr->psz_field = strdup( &psz_sdp[2] );
1199                     p_attr->psz_value = NULL;
1200                 }
1201
1202                 TAB_APPEND( p_sdp->i_attributes, p_sdp->pp_attributes, p_attr );
1203                 break;
1204             }
1205
1206             case( 'm' ): /* Media announcement */
1207             {
1208                 /* If we have several medias, we pass the announcement to
1209                  * LIVE.COM, so just count them */
1210                 p_sdp->i_media++;
1211                 if( p_sdp->i_media == 1 )
1212                 {
1213                     p_sdp->psz_media = strdup( &psz_sdp[2] );
1214                 }
1215                 break;
1216             }
1217
1218             case( 'c' ):
1219             {
1220                 if( p_sdp->i_media > 1 )
1221                     break;
1222
1223                 p_sdp->psz_connection = strdup( &psz_sdp[2] );
1224                 break;
1225             }
1226
1227             default:
1228                break;
1229         }
1230
1231         if( b_invalid )
1232         {
1233             FreeSDP( p_sdp );
1234             return NULL;
1235         }
1236
1237         psz_sdp = psz_eol;
1238     }
1239
1240     return p_sdp;
1241 }
1242
1243
1244 /***********************************************************************
1245  * ismult: returns true if we have a multicast address
1246  ***********************************************************************/
1247 static int ismult( char *psz_uri )
1248 {
1249     char *psz_end;
1250     int  i_value;
1251
1252     i_value = strtol( psz_uri, &psz_end, 0 );
1253
1254     /* IPv6 */
1255     if( psz_uri[0] == '[')
1256     {
1257       if( strncasecmp( &psz_uri[1], "FF0" , 3) ||
1258           strncasecmp( &psz_uri[2], "FF0" , 3))
1259             return( VLC_TRUE );
1260         else
1261             return( VLC_FALSE );
1262     }
1263
1264     if( *psz_end != '.' ) { return( VLC_FALSE ); }
1265
1266     return( i_value < 224 ? VLC_FALSE : VLC_TRUE );
1267 }
1268
1269 static int InitSocket( services_discovery_t *p_sd, char *psz_address,
1270                        int i_port )
1271 {
1272     int i_fd = net_OpenUDP( p_sd, psz_address, i_port, "", 0 );
1273
1274     if( i_fd != -1 )
1275     {
1276         INSERT_ELEM(  p_sd->p_sys->pi_fd, p_sd->p_sys->i_fd,
1277                       p_sd->p_sys->i_fd, i_fd );
1278         return VLC_SUCCESS;
1279     }
1280
1281     return VLC_EGENERIC;
1282 }
1283
1284 #ifdef HAVE_ZLIB_H
1285 static int Decompress( unsigned char *psz_src, unsigned char **_dst, int i_len )
1286 {
1287     int i_result, i_dstsize, n;
1288     unsigned char *psz_dst;
1289     z_stream d_stream;
1290
1291     d_stream.zalloc = (alloc_func)0;
1292     d_stream.zfree = (free_func)0;
1293     d_stream.opaque = (voidpf)0;
1294
1295     i_result = inflateInit(&d_stream);
1296     if( i_result != Z_OK )
1297     {
1298         printf( "inflateInit() failed. Result: %d\n", i_result );
1299         return( -1 );
1300     }
1301 #if 0
1302     p_playlist->pp_items[p_playlist->i_index]->b_autodeletion = VLC_TRUE;
1303     i_position = p_playlist->i_index;
1304
1305     /* Gather the complete sdp file */
1306     for( ;; )
1307     {
1308         int i_read = stream_Read( p_demux->s, &p_sdp[i_sdp], i_sdp_max - i_sdp - 1 );
1309 #endif
1310     d_stream.next_in = (Bytef *)psz_src;
1311     d_stream.avail_in = i_len;
1312     n = 0;
1313
1314     psz_dst = NULL;
1315
1316     do
1317     {
1318         n++;
1319         psz_dst = (unsigned char *)realloc( psz_dst, n * 1000 );
1320         d_stream.next_out = (Bytef *)&psz_dst[(n - 1) * 1000];
1321         d_stream.avail_out = 1000;
1322
1323         i_result = inflate(&d_stream, Z_NO_FLUSH);
1324         if( ( i_result != Z_OK ) && ( i_result != Z_STREAM_END ) )
1325         {
1326             printf( "Zlib decompression failed. Result: %d\n", i_result );
1327             return( -1 );
1328         }
1329     }
1330     while( ( d_stream.avail_out == 0 ) && ( d_stream.avail_in != 0 ) &&
1331            ( i_result != Z_STREAM_END ) );
1332
1333     i_dstsize = d_stream.total_out;
1334     inflateEnd( &d_stream );
1335
1336     *_dst = (unsigned char *)realloc( psz_dst, i_dstsize );
1337
1338     return i_dstsize;
1339 }
1340 #endif
1341
1342
1343 static void FreeSDP( sdp_t *p_sdp )
1344 {
1345     int i;
1346     FREE( p_sdp->psz_sdp );
1347     FREE( p_sdp->psz_sessionname );
1348     FREE( p_sdp->psz_connection );
1349     FREE( p_sdp->psz_media );
1350     FREE( p_sdp->psz_uri );
1351
1352     FREE( p_sdp->psz_address );
1353     FREE( p_sdp->psz_address_type );
1354
1355     for( i= p_sdp->i_attributes - 1; i >= 0 ; i-- )
1356     {
1357         struct attribute_t *p_attr = p_sdp->pp_attributes[i];
1358         FREE( p_sdp->pp_attributes[i]->psz_field );
1359         FREE( p_sdp->pp_attributes[i]->psz_value );
1360         REMOVE_ELEM( p_sdp->pp_attributes, p_sdp->i_attributes, i);
1361         FREE( p_attr );
1362     }
1363     free( p_sdp );
1364 }
1365
1366 static int RemoveAnnounce( services_discovery_t *p_sd,
1367                            sap_announce_t *p_announce )
1368 {
1369     int i;
1370     playlist_t *p_playlist = (playlist_t *)vlc_object_find( p_sd,
1371                                           VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
1372
1373     if( p_announce->p_sdp ) FreeSDP( p_announce->p_sdp );
1374
1375     if( !p_playlist ) return VLC_EGENERIC;
1376
1377     if( p_announce->p_item )
1378     {
1379         playlist_LockDelete( p_playlist, p_announce->p_item->input.i_id );
1380     }
1381
1382     for( i = 0; i< p_sd->p_sys->i_announces; i++)
1383     {
1384         if( p_sd->p_sys->pp_announces[i] == p_announce )
1385         {
1386             REMOVE_ELEM( p_sd->p_sys->pp_announces, p_sd->p_sys->i_announces,
1387                          i);
1388             break;
1389         }
1390     }
1391
1392     vlc_object_release( p_playlist );
1393
1394     free( p_announce );
1395
1396     return VLC_SUCCESS;
1397 }
1398
1399 static vlc_bool_t IsSameSession( sdp_t *p_sdp1, sdp_t *p_sdp2 )
1400 {
1401     /* A session is identified by
1402      * username, session_id, network type, address type and address */
1403     if( p_sdp1->psz_username && p_sdp2->psz_username &&
1404         p_sdp1->psz_network_type && p_sdp2->psz_network_type &&
1405         p_sdp1->psz_address_type && p_sdp2->psz_address_type &&
1406         p_sdp1->psz_address &&  p_sdp2->psz_address )
1407     {
1408         if(!strcmp( p_sdp1->psz_username , p_sdp2->psz_username ) &&
1409            !strcmp( p_sdp1->psz_network_type , p_sdp2->psz_network_type ) &&
1410            !strcmp( p_sdp1->psz_address_type , p_sdp2->psz_address_type ) &&
1411            !strcmp( p_sdp1->psz_address , p_sdp2->psz_address ) &&
1412            p_sdp1->i_session_id == p_sdp2->i_session_id )
1413         {
1414             return VLC_TRUE;
1415         }
1416         else
1417         {
1418             return VLC_FALSE;
1419         }
1420     }
1421     else
1422     {
1423         return VLC_FALSE;
1424     }
1425 }
1426
1427
1428 static void CacheLoad( services_discovery_t *p_sd )
1429 {
1430     msg_Warn( p_sd, "Cache not implemented") ;
1431 }
1432
1433 static void CacheSave( services_discovery_t *p_sd )
1434 {
1435     msg_Warn( p_sd, "Cache not implemented") ;
1436 }