git.sesse.net Git - vlc/blob - modules/misc/sap.c

   1 /*****************************************************************************
   2  * sap.c :  SAP interface module
   3  *****************************************************************************
   4  * Copyright (C) 2001 VideoLAN
   5  * $Id: sap.c,v 1.52 2004/01/29 17:51:08 zorglub Exp $
   6  *
   7  * Authors: Arnaud Schauly <gitan@via.ecp.fr>
   8  *          Clément Stenac <zorglub@via.ecp.fr>
   9  *          Damien Lucas <nitrox@videolan.org>
  10  *          Laurent Aimar <fenrir@via.ecp.fr>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  25  *****************************************************************************/
  26
  27 /*****************************************************************************
  28  * Preamble
  29  *****************************************************************************/
  30 #include <stdlib.h>                                      /* malloc(), free() */
  31
  32 #include <vlc/vlc.h>
  33 #include <vlc/intf.h>
  34
  35 #include <errno.h>                                                 /* ENOMEM */
  36 #include <ctype.h>
  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 WIN32
  46 #   include <winsock2.h>
  47 #   include <ws2tcpip.h>
  48 #   ifndef IN_MULTICAST
  49 #       define IN_MULTICAST(a) IN_CLASSD(a)
  50 #   endif
  51 #else
  52 #   include <sys/socket.h>
  53 #   include <netinet/in.h>
  54 #   if HAVE_ARPA_INET_H
  55 #      include <arpa/inet.h>
  56 #   elif defined( SYS_BEOS )
  57 #      include <net/netdb.h>
  58 #   endif
  59 #endif
  60
  61 #ifdef UNDER_CE
  62 #   define close(a) CloseHandle(a)
  63 #elif defined( WIN32 )
  64 #   define close(a) closesocket(a)
  65 #endif
  66
  67 #include "network.h"
  68
  69 #ifdef HAVE_ZLIB_H
  70 #   include <zlib.h>
  71 #endif
  72
  73 #define MAX_LINE_LENGTH 256
  74
  75 /* SAP is always on that port */
  76 #define HELLO_PORT 9875
  77 #define HELLO_GROUP "224.2.127.254"
  78 #define ADD_SESSION 1
  79
  80 #define IPV6_ADDR_1 "FF0"  /* Scope is inserted between them */
  81 #define IPV6_ADDR_2 "::2:7FFE"
  82
  83
  84 /*****************************************************************************
  85  * Module descriptor
  86  *****************************************************************************/
  87 #define SAP_ADDR_TEXT N_("SAP multicast address")
  88 #define SAP_ADDR_LONGTEXT N_("SAP multicast address")
  89 #define SAP_IPV4_TEXT N_("IPv4-SAP listening")
  90 #define SAP_IPV4_LONGTEXT N_( \
  91       "Set this if you want the SAP module to listen to IPv4 announces")
  92 #define SAP_IPV6_TEXT N_( "IPv6-SAP listening")
  93 #define SAP_IPV6_LONGTEXT N_(\
  94       "Set this if you want the SAP module to listen to IPv6 announces")
  95 #define SAP_SCOPE_TEXT N_("IPv6 SAP scope")
  96 #define SAP_SCOPE_LONGTEXT N_( \
  97        "Sets the scope for IPv6 announces (default is 8)")
  98 #define SAP_TIMEOUT_TEXT N_("SAP timeout (seconds)")
  99 #define SAP_TIMEOUT_LONGTEXT N_( \
 100        "Sets the time before SAP items get deleted if no new announce" \
 101        "is received")
 102
 103 static int  Open ( vlc_object_t * );
 104 static void Close( vlc_object_t * );
 105
 106 vlc_module_begin();
 107     set_description( _("SAP interface") );
 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
 120     set_capability( "interface", 0 );
 121     set_callbacks( Open, Close );
 122 vlc_module_end();
 123
 124 /*****************************************************************************
 125  * Local prototypes
 126  *****************************************************************************/
 127
 128 static void Run    ( intf_thread_t *p_intf );
 129 static ssize_t NetRead( intf_thread_t *, int fd[2], uint8_t *, int );
 130
 131 typedef struct media_descr_t media_descr_t;
 132 typedef struct sess_descr_t sess_descr_t;
 133 typedef struct attr_descr_t attr_descr_t;
 134
 135 static void sess_toitem( intf_thread_t *, sess_descr_t * );
 136
 137 static sess_descr_t *  parse_sdp( intf_thread_t *, char * ) ;
 138 static void free_sd( sess_descr_t * );
 139
 140 /* Detect multicast addresses */
 141 static int  ismult( char * );
 142
 143 /* The struct that contains sdp informations */
 144 struct  sess_descr_t
 145 {
 146     int  i_version;
 147     char *psz_sessionname;
 148     char *psz_connection;
 149     char *psz_sdp;
 150
 151     int           i_media;
 152     media_descr_t **pp_media;
 153     int           i_attributes;
 154     attr_descr_t  **pp_attributes;
 155 };
 156
 157 /* All this informations are not useful yet.  */
 158 struct media_descr_t
 159 {
 160     char *psz_medianame;
 161     char *psz_mediaconnection;
 162 };
 163
 164 struct attr_descr_t
 165 {
 166     char *psz_field;
 167     char *psz_value;
 168 };
 169
 170 struct sap_announce_t
 171 {
 172     mtime_t i_last;
 173     int i_id;
 174     char *psz_name;
 175     char *psz_uri;
 176 };
 177
 178 struct intf_sys_t
 179 {
 180     /* IPV4 and IPV6 */
 181     int fd[2];
 182
 183     /* playlist group */
 184     int i_group;
 185
 186     /* Table of announces */
 187     int i_announces;
 188     struct sap_announce_t **pp_announces;
 189
 190     int i_timeout;
 191 };
 192
 193 #ifdef HAVE_ZLIB_H
 194 int do_decompress(unsigned char *src, unsigned char **_dst, int slen) {
 195   int result, dstsize, n;
 196   unsigned char *dst;
 197   z_stream d_stream;
 198
 199   d_stream.zalloc = (alloc_func)0;
 200   d_stream.zfree = (free_func)0;
 201   d_stream.opaque = (voidpf)0;
 202   result = inflateInit(&d_stream);
 203   if (result != Z_OK) {
 204     printf("inflateInit() failed. Result: %d\n", result);
 205     return(-1);
 206   }
 207
 208   d_stream.next_in = (Bytef *)src;
 209   d_stream.avail_in = slen;
 210   n = 0;
 211   dst = NULL;
 212   do {
 213     n++;
 214     dst = (unsigned char *)realloc(dst, n * 1000);
 215     d_stream.next_out = (Bytef *)&dst[(n - 1) * 1000];
 216     d_stream.avail_out = 1000;
 217     result = inflate(&d_stream, Z_NO_FLUSH);
 218     if ((result != Z_OK) && (result != Z_STREAM_END)) {
 219       printf("Zlib decompression failed. Result: %d\n", result);
 220       return(-1);
 221     }
 222   } while ((d_stream.avail_out == 0) && (d_stream.avail_in != 0) &&
 223            (result != Z_STREAM_END));
 224
 225   dstsize = d_stream.total_out;
 226   inflateEnd(&d_stream);
 227
 228   *_dst = (unsigned char *)realloc(dst, dstsize);
 229
 230   return dstsize;
 231 }
 232 #endif
 233
 234 /*****************************************************************************
 235  * Open: initialize and create stuff
 236  *****************************************************************************/
 237 static int Open( vlc_object_t *p_this )
 238 {
 239     intf_thread_t *p_intf = (intf_thread_t*)p_this;
 240     intf_sys_t    *p_sys  = malloc( sizeof( intf_sys_t ) );
 241
 242     playlist_t          *p_playlist;
 243
 244     p_sys->i_timeout = config_GetInt(p_intf,"sap-timeout");
 245     p_sys->fd[0] = -1;
 246     p_sys->fd[1] = -1;
 247     if( config_GetInt( p_intf, "sap-ipv4" ) )
 248     {
 249         char *psz_address = config_GetPsz( p_intf, "sap-addr" );
 250         network_socket_t    sock;
 251         module_t            *p_network;
 252         if( psz_address == NULL || *psz_address == '\0' )
 253         {
 254             psz_address = strdup( HELLO_GROUP );
 255         }
 256
 257         /* Prepare the network_socket_t structure */
 258         sock.i_type            = NETWORK_UDP;
 259         sock.psz_bind_addr     = psz_address;
 260         sock.i_bind_port       = HELLO_PORT;
 261         sock.psz_server_addr   = "";
 262         sock.i_server_port     = 0;
 263         sock.i_ttl             = 0;
 264         p_intf->p_private = (void*) &sock;
 265
 266         p_network = module_Need( p_intf, "network", "ipv4" );
 267         if( p_network )
 268         {
 269             p_sys->fd[0] = sock.i_handle;
 270             module_Unneed( p_intf, p_network );
 271         }
 272         else
 273         {
 274             msg_Warn( p_intf, "failed to open %s:%d", psz_address, HELLO_PORT );
 275         }
 276         free( psz_address );
 277     }
 278
 279     if( config_GetInt( p_intf, "sap-ipv6" ) )
 280     {
 281         char psz_address[100];
 282         char *psz_scope = config_GetPsz( p_intf, "sap-ipv6-scope" );
 283         network_socket_t    sock;
 284         module_t            *p_network;
 285
 286         if( psz_scope == NULL || *psz_scope == '\0' )
 287         {
 288             psz_scope = strdup( "8" );
 289         }
 290         snprintf( psz_address, 100, "[%s%c%s]",IPV6_ADDR_1,
 291                   psz_scope[0], IPV6_ADDR_2 );
 292         free( psz_scope );
 293
 294         sock.i_type            = NETWORK_UDP;
 295         sock.psz_bind_addr     = psz_address;
 296         sock.i_bind_port       = HELLO_PORT;
 297         sock.psz_server_addr   = "";
 298         sock.i_server_port     = 0;
 299         sock.i_ttl             = 0;
 300         p_intf->p_private = (void*) &sock;
 301
 302         p_network = module_Need( p_intf, "network", "ipv6" );
 303         if( p_network )
 304         {
 305             p_sys->fd[1] = sock.i_handle;
 306             module_Unneed( p_intf, p_network );
 307         }
 308         else
 309         {
 310             msg_Warn( p_intf, "failed to open %s:%d", psz_address, HELLO_PORT );
 311         }
 312     }
 313     if( p_sys->fd[0] <= 0 && p_sys->fd[1] <= 0 )
 314     {
 315         msg_Warn( p_intf, "IPV4 and IPV6 failed" );
 316         free( p_sys );
 317         return VLC_EGENERIC;
 318     }
 319
 320     /* Create our playlist group */
 321     p_playlist = (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 322                                                 FIND_ANYWHERE );
 323     if( p_playlist )
 324     {
 325         playlist_group_t *p_group = playlist_CreateGroup( p_playlist , "SAP" );
 326         p_sys->i_group = p_group->i_id;
 327         vlc_object_release( p_playlist );
 328     }
 329
 330     p_sys->i_announces = 0;
 331     p_sys->pp_announces = NULL;
 332
 333     p_intf->pf_run = Run;
 334     p_intf->p_sys  = p_sys;
 335
 336     return VLC_SUCCESS;
 337 }
 338
 339 /*****************************************************************************
 340  * Close:
 341  *****************************************************************************/
 342 static void Close( vlc_object_t *p_this )
 343 {
 344     intf_thread_t *p_intf = (intf_thread_t*)p_this;
 345     intf_sys_t    *p_sys  = p_intf->p_sys;
 346     int i;
 347
 348     if( p_sys->fd[0] > 0 )
 349     {
 350         close( p_sys->fd[0] );
 351     }
 352     if( p_sys->fd[1] > 0 )
 353     {
 354         close( p_sys->fd[1] );
 355     }
 356
 357     for( i = 0 ; i< p_sys->i_announces ; i++ )
 358     {
 359         if( p_sys->pp_announces[i]->psz_name )
 360            free( p_sys->pp_announces[i]->psz_name );
 361         if( p_sys->pp_announces[i]->psz_uri )
 362            free( p_sys->pp_announces[i]->psz_uri );
 363         free( p_sys->pp_announces[i] );
 364     }
 365
 366     free( p_sys );
 367 }
 368
 369 /*****************************************************************************
 370  * Run: sap thread
 371  *****************************************************************************
 372  * Listens to SAP packets, and sends them to packet_handle
 373  *****************************************************************************/
 374 #define MAX_SAP_BUFFER 5000
 375
 376 static void Run( intf_thread_t *p_intf )
 377 {
 378     intf_sys_t *p_sys  = p_intf->p_sys;
 379     uint8_t     buffer[MAX_SAP_BUFFER + 1];
 380     uint8_t    *p_end;
 381
 382     /* read SAP packets */
 383     while( !p_intf->b_die )
 384     {
 385         playlist_t *p_playlist= NULL;
 386         int i;
 387         int i_read = NetRead( p_intf, p_sys->fd, buffer, MAX_SAP_BUFFER );
 388         uint8_t *p_sdp;
 389         int i_version;
 390         int i_address_type;
 391         int b_reserved;
 392         int b_message_type;
 393         int b_encrypted;
 394         int b_compressed;
 395         unsigned char *p_decompressed_buffer;
 396         int i_decompressed_size;
 397
 398         /* Check for items that need deletion */
 399         for( i = 0 ; i< p_intf->p_sys->i_announces ; i++ )
 400         {
 401            struct sap_announce_t *p_announce;
 402            mtime_t i_timeout = (mtime_t)1000000*p_sys->i_timeout;
 403            if( mdate() - p_intf->p_sys->pp_announces[i]->i_last > i_timeout )
 404            {
 405                msg_Dbg(p_intf,"Time out for %s, deleting (%i/%i)",
 406                        p_intf->p_sys->pp_announces[i]->psz_name,
 407                        i , p_intf->p_sys->i_announces );
 408
 409                /* Remove the playlist item */
 410                p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 411                               FIND_ANYWHERE );
 412                if( p_playlist )
 413                {
 414                    int i_pos = playlist_GetPositionById( p_playlist,
 415                               p_intf->p_sys->pp_announces[i]->i_id );
 416                    playlist_Delete( p_playlist, i_pos );
 417                }
 418
 419                vlc_object_release( p_playlist );
 420
 421                /* Free the p_announce */
 422                p_announce =  p_intf->p_sys->pp_announces[i];
 423                if( p_announce->psz_name )
 424                   free(  p_announce->psz_name );
 425                if( p_announce->psz_uri )
 426                   free(  p_announce->psz_uri );
 427
 428               /* Remove the sap_announce from the array */
 429               REMOVE_ELEM( p_intf->p_sys->pp_announces,
 430                            p_intf->p_sys->i_announces,
 431                            i );
 432
 433               free( p_announce );
 434
 435            }
 436         }
 437
 438         /* Minimum length is > 6 */
 439         if( i_read <= 6 )
 440         {
 441             if( i_read < 0 )
 442             {
 443                 msg_Warn( p_intf, "Cannot read in the socket" );
 444             }
 445             continue;
 446         }
 447
 448         buffer[i_read] = '\0';
 449         p_end = &buffer[i_read];
 450
 451         /* Parse the SAP header */
 452         i_version = buffer[0] >> 5;
 453         if( i_version != 1 )
 454         {
 455             msg_Warn( p_intf, "strange sap version %d found", i_version );
 456         }
 457         i_address_type = buffer[0] & 0x10;
 458         b_reserved = buffer[0] & 0x08;
 459         if( b_reserved != 0 )
 460         {
 461             msg_Warn( p_intf, "reserved bit incorrectly set" );
 462         }
 463         b_message_type = buffer[0] & 0x04;
 464         if( b_message_type != 0 )
 465         {
 466             msg_Warn( p_intf, "got session deletion packet" );
 467         }
 468         b_encrypted = buffer[0] & 0x02;
 469         if( b_encrypted )
 470         {
 471             msg_Warn( p_intf, "encrypted packet" );
 472         }
 473         b_compressed = buffer[0] & 0x01;
 474         p_sdp  = &buffer[4];
 475         if( i_address_type == 0 ) /* ipv4 source address */
 476         {
 477             p_sdp += 4;
 478         }
 479         else /* ipv6 source address */
 480         {
 481             p_sdp += 16;
 482         }
 483         if( b_compressed )
 484         {
 485 #ifdef HAVE_ZLIB_H
 486             i_decompressed_size = do_decompress( p_sdp, &p_decompressed_buffer, i_read - ( p_sdp - buffer ) );
 487             if( i_decompressed_size > 0 && i_decompressed_size < MAX_SAP_BUFFER )
 488             {
 489                 memcpy( p_sdp, p_decompressed_buffer, i_decompressed_size );
 490                 p_sdp[i_decompressed_size] = '\0';
 491                 p_end = &p_sdp[i_decompressed_size];
 492                 free( p_decompressed_buffer );
 493             }
 494 #else
 495             msg_Warn( p_intf, "Ignoring compressed sap packet" );
 496 #endif
 497         }
 498         p_sdp += buffer[1]; /* size of signature */
 499         while( p_sdp < p_end - 1 && *p_sdp != '\0' && p_sdp[0] != 'v' && p_sdp[1] != '=' )
 500         {
 501             p_sdp++;
 502         }
 503         if( *p_sdp == '\0' )
 504         {
 505             p_sdp++;
 506         }
 507
 508         if( p_sdp < p_end )
 509         {
 510             sess_descr_t *p_sd = parse_sdp( p_intf, p_sdp );
 511             if( p_sd )
 512             {
 513                 sess_toitem ( p_intf, p_sd );
 514                 free_sd ( p_sd );
 515             }
 516         }
 517         else
 518         {
 519             msg_Warn( p_intf, "ditching sap packet" );
 520         }
 521
 522     }
 523 }
 524
 525 /**********************************************************************
 526  * cfield_parse
 527  *********************************************************************
 528  * put into *ppsz_uri, the the uri in the cfield, psz_cfield.
 529  *********************************************************************/
 530
 531 static void cfield_parse( char *psz_cfield, char **ppsz_uri )
 532 {
 533
 534     char *psz_pos;
 535     if( psz_cfield )
 536     {
 537         psz_pos = psz_cfield;
 538
 539         while( *psz_pos != ' ' && *psz_pos !='\0' )
 540         {
 541             psz_pos++;
 542         }
 543         psz_pos++;
 544         while( *psz_pos != ' ' && *psz_pos !='\0' )
 545         {
 546             psz_pos++;
 547         }
 548         psz_pos++;
 549         *ppsz_uri = psz_pos;
 550         while( *psz_pos != ' ' && *psz_pos !='/'
 551                         && *psz_pos != '\0' )
 552         {
 553             psz_pos++;
 554         }
 555         *psz_pos = '\0';
 556
 557     }
 558     else
 559     {
 560         ppsz_uri = NULL;
 561     }
 562
 563     return;
 564
 565 }
 566
 567 /**********************************************************************
 568  * mfield_parse
 569  *********************************************************************
 570  * put into *ppsz_proto, and *ppsz_port, the protocol and the port.
 571  *********************************************************************/
 572
 573
 574 static void mfield_parse( char *psz_mfield, char **ppsz_proto,
 575                char **ppsz_port )
 576 {
 577     char *psz_pos;
 578     char *psz_media;
 579     if( psz_mfield )
 580     {
 581         psz_pos = psz_mfield;
 582         psz_media = psz_mfield;
 583         while( *psz_pos != '\0' && *psz_pos != ' ' )
 584         {
 585             psz_pos++;
 586         }
 587         if( *psz_pos != '\0' )
 588         {
 589             *psz_pos = '\0';
 590             if( strcmp( psz_media, "video" ) && strcmp( psz_media, "audio" ) )
 591             {
 592                 *ppsz_proto = NULL;
 593                 *ppsz_port = NULL;
 594                 return;
 595             }
 596         }
 597         psz_pos++;
 598         *ppsz_port = psz_pos;
 599         while( *psz_pos != '\0' && *psz_pos !=' ' && *psz_pos!='/' )
 600         {
 601             psz_pos++;
 602         }
 603         if( *psz_pos == '/' )  // FIXME does not support multi-port
 604         {
 605             *psz_pos = '\0';
 606             psz_pos++;
 607             while( *psz_pos != '\0' && *psz_pos !=' ' )
 608             {
 609             psz_pos++;
 610             }
 611         }
 612         *psz_pos = '\0';
 613         psz_pos++;
 614         *ppsz_proto = psz_pos;
 615         while( *psz_pos!='\0' && *psz_pos !=' ' &&
 616                         *psz_pos!='/' )
 617         {
 618             *psz_pos = tolower( *psz_pos );
 619             psz_pos++;
 620         }
 621         *psz_pos = '\0';
 622     }
 623     else
 624     {
 625         *ppsz_proto = NULL;
 626         *ppsz_port = NULL;
 627     }
 628     return;
 629 }
 630
 631
 632 /*******************************************************************
 633  * sess_toitem : changes a sess_descr_t into a hurd of
 634  * playlist_item_t, which are enqueued.
 635  *******************************************************************
 636  * Note : does not support sessions that take place on consecutive
 637  * port or adresses yet.
 638  *******************************************************************/
 639
 640 static void sess_toitem( intf_thread_t * p_intf, sess_descr_t * p_sd )
 641 {
 642     struct sap_announce_t *p_announce;
 643     char *psz_uri, *psz_proto, *psz_item_uri;
 644     char *psz_port;
 645     char *psz_uri_default;
 646     int i_count , i , i_pos , i_id = 0;
 647     vlc_bool_t b_http = VLC_FALSE;
 648     char *psz_http_path = NULL;
 649     playlist_t *p_playlist = NULL;
 650     playlist_item_t *p_item;
 651
 652     psz_uri_default = NULL;
 653     if( p_sd->i_media > 1 )
 654     {
 655         asprintf( &psz_uri, "sdp://%s", p_sd->psz_sdp );
 656         /* Check if we have already added the item */
 657         for( i = 0 ; i< p_intf->p_sys->i_announces ; i++ )
 658         {
 659             if( !strcmp(p_intf->p_sys->pp_announces[i]->psz_uri,
 660                         psz_uri ) )
 661             {
 662                 p_intf->p_sys->pp_announces[i]->i_last = mdate();
 663                 free(psz_uri);
 664                 return;
 665             }
 666         }
 667         /* Add it to the playlist */
 668         p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 669                                       FIND_ANYWHERE );
 670         i_id = playlist_Add( p_playlist, psz_uri, p_sd->psz_sessionname ,
 671                       PLAYLIST_CHECK_INSERT, PLAYLIST_END );
 672         if( i_id != -1 )
 673         {
 674             playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_id );
 675             playlist_ItemSetGroup( p_item, p_intf->p_sys->i_group );
 676         }
 677
 678         /* Remember it */
 679         p_announce = (struct sap_announce_t *)malloc(
 680                       sizeof(struct sap_announce_t) );
 681         if( p_sd->psz_sessionname )
 682         {
 683             p_announce->psz_name = strdup(  p_sd->psz_sessionname );
 684         }
 685         else
 686         {
 687             p_announce->psz_name = strdup( "" );
 688         }
 689         if( psz_uri )
 690         {
 691             p_announce->psz_uri  = strdup( psz_uri );
 692         }
 693         else
 694         {
 695             p_announce->psz_uri = strdup( "" );
 696         }
 697         p_announce->i_id = i_id;
 698         p_announce->i_last = mdate();
 699
 700         INSERT_ELEM( p_intf->p_sys->pp_announces,
 701                      p_intf->p_sys->i_announces,
 702                      p_intf->p_sys->i_announces,
 703                      p_announce );
 704
 705         vlc_object_release( p_playlist );
 706         free( psz_uri );
 707         return;
 708     }
 709
 710     cfield_parse( p_sd->psz_connection, &psz_uri_default );
 711
 712     for( i_count = 0 ; i_count < p_sd->i_media ; i_count++ )
 713     {
 714         int i_group = p_intf->p_sys->i_group;
 715
 716         /* Build what we have to put in psz_item_uri, with the m and
 717          * c fields  */
 718
 719         if( !p_sd->pp_media[i_count] )
 720         {
 721             return;
 722         }
 723
 724         mfield_parse( p_sd->pp_media[i_count]->psz_medianame,
 725                         & psz_proto, & psz_port );
 726
 727         if( !psz_proto || !psz_port )
 728         {
 729             return;
 730         }
 731
 732         if( p_sd->pp_media[i_count]->psz_mediaconnection )
 733         {
 734             cfield_parse( p_sd->pp_media[i_count]->psz_mediaconnection,
 735                             & psz_uri );
 736         }
 737         else
 738         {
 739             psz_uri = psz_uri_default;
 740         }
 741
 742         if( psz_uri == NULL )
 743         {
 744             return;
 745         }
 746
 747         for( i = 0 ; i< p_sd->i_attributes ; i++ )
 748         {
 749             if(!strcasecmp( p_sd->pp_attributes[i]->psz_field , "type") &&
 750                 strstr( p_sd->pp_attributes[i]->psz_value, "http") )
 751             {
 752                 b_http = VLC_TRUE;
 753             }
 754             if(!strcasecmp( p_sd->pp_attributes[i]->psz_field , "http-path"))
 755             {
 756                 psz_http_path = strdup(  p_sd->pp_attributes[i]->psz_value );
 757             }
 758             if(!strcasecmp( p_sd->pp_attributes[i]->psz_field , "plgroup"))
 759             {
 760                 int i_group_id;
 761                 p_playlist =
 762                 (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 763                                                         FIND_ANYWHERE );
 764                 if( p_playlist == NULL )
 765                 {
 766                     return;
 767                 }
 768
 769                 i_group_id = playlist_GroupToId( p_playlist,
 770                                  p_sd->pp_attributes[i]->psz_value);
 771                 if( i_group_id != 0 )
 772                 {
 773                     i_group = i_group_id;
 774                 }
 775                 else
 776                 {
 777                     playlist_group_t *p_group =
 778                             playlist_CreateGroup( p_playlist,
 779                                        p_sd->pp_attributes[i]->psz_value);
 780                     i_group = p_group->i_id;
 781                 }
 782                 vlc_object_release( p_playlist );
 783             }
 784         }
 785
 786         /* Filling psz_uri */
 787         if( b_http == VLC_FALSE )
 788         {
 789             psz_item_uri = malloc( strlen( psz_proto ) + strlen( psz_uri ) +
 790                                  strlen( psz_port ) + 7 );
 791             if( ismult( psz_uri ) )
 792             {
 793                 sprintf( psz_item_uri, "%s://@%s:%s",
 794                          psz_proto, psz_uri, psz_port );
 795             }
 796             else
 797             {
 798                 sprintf( psz_item_uri, "%s://%s:%s",
 799                          psz_proto, psz_uri, psz_port );
 800             }
 801         }
 802         else
 803         {
 804             if( psz_http_path == NULL )
 805             {
 806                 psz_http_path = strdup( "/" );
 807             }
 808
 809             psz_item_uri = malloc( strlen( psz_proto ) + strlen( psz_uri ) +
 810                                    strlen( psz_port ) + strlen(psz_http_path) +
 811                                     5 );
 812             sprintf( psz_item_uri, "%s://%s:%s%s", psz_proto,
 813                             psz_uri, psz_port,psz_http_path );
 814
 815             if( psz_http_path )
 816             {
 817                 free( psz_http_path );
 818             }
 819         }
 820
 821         /* Check if we already know this item */
 822          for( i = 0 ; i< p_intf->p_sys->i_announces ; i++ )
 823          {
 824             if( !strcmp( p_intf->p_sys->pp_announces[i]->psz_uri,
 825                          psz_item_uri ) )
 826             {
 827                 p_intf->p_sys->pp_announces[i]->i_last = mdate();
 828
 829                 /* Check if the name changed */
 830                 if( strcmp( p_intf->p_sys->pp_announces[i]->psz_name,
 831                              p_sd->psz_sessionname ) )
 832                 {
 833                     playlist_item_t *p_item;
 834                     p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 835                                                   FIND_ANYWHERE );
 836
 837                     msg_Dbg(p_intf, "Name changed (%s -> %s) for %s",
 838                             p_intf->p_sys->pp_announces[i]->psz_name,
 839                             p_sd->psz_sessionname,
 840                             psz_item_uri );
 841
 842                     p_item = playlist_ItemGetById( p_playlist,
 843                                     p_intf->p_sys->pp_announces[i]->i_id );
 844
 845                     /* Change the name in the item */
 846                     if( p_item->psz_name )
 847                         free( p_item->psz_name );
 848                     p_item->psz_name = strdup( p_sd->psz_sessionname);
 849
 850                     /* Update the stored name */
 851                     if( p_intf->p_sys->pp_announces[i]->psz_name )
 852                         free( p_intf->p_sys->pp_announces[i]->psz_name );
 853                     p_intf->p_sys->pp_announces[i]->psz_name =
 854                                    strdup( p_sd->psz_sessionname );
 855
 856                     vlc_object_release( p_playlist );
 857                 }
 858                 return;
 859             }
 860         }
 861
 862         /* Add the item in the playlist */
 863         p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 864                                       FIND_ANYWHERE );
 865         i_id = playlist_Add ( p_playlist, psz_item_uri ,
 866                                p_sd->psz_sessionname,
 867                                PLAYLIST_CHECK_INSERT, PLAYLIST_END );
 868         p_item = playlist_ItemGetById( p_playlist, i_id );
 869         if( p_item )
 870         {
 871             vlc_mutex_lock( &p_item->lock );
 872             playlist_ItemSetGroup( p_item, i_group );
 873             vlc_mutex_unlock( &p_item->lock );
 874         }
 875
 876         /* Then remember it */
 877         p_announce = (struct sap_announce_t *)malloc(
 878                       sizeof(struct sap_announce_t) );
 879         if(  p_sd->psz_sessionname )
 880         {
 881             p_announce->psz_name = strdup(  p_sd->psz_sessionname );
 882         }
 883         else
 884         {
 885             p_announce->psz_name = strdup( "" );
 886         }
 887         if( psz_item_uri )
 888         {
 889             p_announce->psz_uri  = strdup( psz_item_uri );
 890         }
 891         else
 892         {
 893             p_announce->psz_uri = strdup( "" );
 894         }
 895         p_announce->i_id = i_id;
 896
 897         p_announce->i_last = mdate();
 898
 899         vlc_object_release( p_playlist );
 900
 901         INSERT_ELEM( p_intf->p_sys->pp_announces,
 902                      p_intf->p_sys->i_announces,
 903                      p_intf->p_sys->i_announces,
 904                      p_announce );
 905         free( psz_item_uri );
 906     }
 907 }
 908
 909 /***********************************************************************
 910  * parse_sdp : SDP parsing
 911  * *********************************************************************
 912  * Make a sess_descr_t with a psz
 913  ***********************************************************************/
 914
 915 static sess_descr_t *  parse_sdp( intf_thread_t * p_intf, char *p_packet )
 916 {
 917     sess_descr_t *  sd;
 918
 919     if( p_packet[0] != 'v' || p_packet[1] != '=' )
 920     {
 921         msg_Warn(p_intf, "bad SDP packet");
 922         return NULL;
 923     }
 924
 925     sd = malloc( sizeof( sess_descr_t ) );
 926     sd->psz_sessionname = NULL;
 927     sd->psz_connection  = NULL;
 928     sd->psz_sdp         = strdup( p_packet );
 929
 930     sd->i_media         = 0;
 931     sd->pp_media        = NULL;
 932     sd->i_attributes    = 0;
 933     sd->pp_attributes   = NULL;
 934
 935     while( *p_packet != '\0'  )
 936     {
 937         char *psz_end;
 938
 939         /* Search begin of field */
 940         while( *p_packet == '\n' || *p_packet == ' ' || *p_packet == '\t' )
 941         {
 942             p_packet++;
 943         }
 944         /* search end of line */
 945         if( ( psz_end = strchr( p_packet, '\n' ) ) == NULL )
 946         {
 947             psz_end = p_packet + strlen( p_packet );
 948         }
 949         if( psz_end > p_packet && *(psz_end - 1 ) == '\r' )
 950         {
 951             psz_end--;
 952         }
 953
 954         if( psz_end <= p_packet )
 955         {
 956             break;
 957         }
 958         *psz_end++ = '\0';
 959
 960         if( p_packet[1] != '=' )
 961         {
 962             msg_Warn( p_intf, "packet invalid" );
 963             free_sd( sd );
 964             return NULL;
 965         }
 966
 967         switch( p_packet[0] )
 968         {
 969             case( 'v' ):
 970                 sd->i_version = atoi( &p_packet[2] );
 971                 break;
 972             case( 's' ):
 973                 sd->psz_sessionname = strdup( &p_packet[2] );
 974                 break;
 975             case ( 'o' ):
 976             case( 'i' ):
 977             case( 'u' ):
 978             case( 'e' ):
 979             case( 'p' ):
 980             case( 't' ):
 981             case( 'r' ):
 982                 break;
 983             case( 'a' ):
 984             {
 985                 char *psz_eof = strchr( &p_packet[2], ':' );
 986
 987                 if( psz_eof && psz_eof[1] != '\0' )
 988                 {
 989                     attr_descr_t *attr = malloc( sizeof( attr_descr_t ) );
 990
 991                     *psz_eof++ = '\0';
 992
 993                     attr->psz_field = strdup( &p_packet[2] );
 994                     attr->psz_value = strdup( psz_eof );
 995
 996                     TAB_APPEND( sd->i_attributes, sd->pp_attributes, attr );
 997                 }
 998                 break;
 999             }
1000
1001             case( 'm' ):
1002             {
1003                 media_descr_t *media = malloc( sizeof( media_descr_t ) );
1004
1005                 media->psz_medianame = strdup( &p_packet[2] );
1006                 media->psz_mediaconnection = NULL;
1007
1008                 TAB_APPEND( sd->i_media, sd->pp_media, media );
1009                 break;
1010             }
1011
1012             case( 'c' ):
1013                 if( sd->i_media <= 0 )
1014                 {
1015                     sd->psz_connection = strdup( &p_packet[2] );
1016                 }
1017                 else
1018                 {
1019                     sd->pp_media[sd->i_media-1]->psz_mediaconnection = strdup( &p_packet[2] );
1020                 }
1021                break;
1022
1023             default:
1024                break;
1025         }
1026
1027         p_packet = psz_end;
1028     }
1029
1030     return sd;
1031 }
1032
1033 #define FREE( p ) \
1034     if( p ) { free( p ); (p) = NULL; }
1035 static void free_sd( sess_descr_t * p_sd )
1036 {
1037     int i;
1038
1039     FREE( p_sd->psz_sessionname );
1040     FREE( p_sd->psz_connection );
1041     FREE( p_sd->psz_sdp );
1042
1043     for( i = 0; i < p_sd->i_media ; i++ )
1044     {
1045         FREE( p_sd->pp_media[i]->psz_medianame );
1046         FREE( p_sd->pp_media[i]->psz_mediaconnection );
1047         FREE( p_sd->pp_media[i] );
1048     }
1049     for( i = 0; i < p_sd->i_attributes ; i++ )
1050     {
1051         FREE( p_sd->pp_attributes[i]->psz_field );
1052         FREE( p_sd->pp_attributes[i]->psz_value );
1053         FREE( p_sd->pp_attributes[i] );
1054     }
1055     FREE( p_sd->pp_attributes );
1056     FREE( p_sd->pp_media );
1057
1058     free( p_sd );
1059 }
1060
1061 /***********************************************************************
1062  * ismult: returns true if we have a multicast address
1063  ***********************************************************************/
1064
1065 static int ismult( char *psz_uri )
1066 {
1067     char *psz_end;
1068     int  i_value;
1069
1070     i_value = strtol( psz_uri, &psz_end, 0 );
1071
1072     /* IPv6 */
1073     if( psz_uri[0] == '[')
1074     {
1075       if( strncasecmp( &psz_uri[1], "FF0" , 3) ||
1076           strncasecmp( &psz_uri[2], "FF0" , 3))
1077             return( VLC_TRUE );
1078         else
1079             return( VLC_FALSE );
1080     }
1081
1082     if( *psz_end != '.' ) { return( VLC_FALSE ); }
1083
1084     return( i_value < 224 ? VLC_FALSE : VLC_TRUE );
1085 }
1086
1087
1088
1089 /*****************************************************************************
1090  * Read: read on a file descriptor, checking b_die periodically
1091  *****************************************************************************
1092  * Taken from udp.c
1093  *****************************************************************************/
1094 static ssize_t NetRead( intf_thread_t *p_intf,
1095                         int fd[2], uint8_t *p_buffer, int i_len )
1096 {
1097 #ifdef UNDER_CE
1098     return -1;
1099 #else
1100     struct timeval  timeout;
1101     fd_set          fds;
1102     int             i_ret;
1103     int             i_handle_max = __MAX( fd[0], fd[1] );
1104
1105     /* Initialize file descriptor set */
1106     FD_ZERO( &fds );
1107     if( fd[0] > 0 ) FD_SET( fd[0], &fds );
1108     if( fd[1] > 0 ) FD_SET( fd[1], &fds );
1109
1110     /* We'll wait 0.5 second if nothing happens */
1111     timeout.tv_sec = 0;
1112     timeout.tv_usec = 500000;
1113
1114     /* Find if some data is available */
1115     i_ret = select( i_handle_max + 1, &fds, NULL, NULL, &timeout );
1116
1117     if( i_ret == -1 && errno != EINTR )
1118     {
1119         msg_Err( p_intf, "network select error (%s)", strerror(errno) );
1120     }
1121     else if( i_ret > 0 )
1122     {
1123         if( fd[0] > 0 && FD_ISSET( fd[0], &fds ) )
1124         {
1125              return recv( fd[0], p_buffer, i_len, 0 );
1126         }
1127         else if( fd[1] > 0 && FD_ISSET( fd[1], &fds ) )
1128         {
1129              return recv( fd[1], p_buffer, i_len, 0 );
1130         }
1131     }
1132     return 0;
1133 #endif
1134 }