Merge commit 'origin/base'
[vlc.git] / src / stream_output / sap.c
1 /*****************************************************************************
2  * sap.c : SAP announce handler
3  *****************************************************************************
4  * Copyright (C) 2002-2008 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Clément Stenac <zorglub@videolan.org>
8  *          Rémi Denis-Courmont <rem # videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34
35 #include <stdlib.h>                                                /* free() */
36 #include <stdio.h>                                              /* sprintf() */
37 #include <string.h>
38 #include <ctype.h>                                  /* tolower(), isxdigit() */
39 #include <assert.h>
40
41 #include <vlc_sout.h>
42 #include <vlc_network.h>
43
44 #include "stream_output.h"
45 #include "libvlc.h"
46
47 /* SAP is always on that port */
48 #define IPPORT_SAP 9875
49
50 /* A SAP session descriptor, enqueued in the SAP handler queue */
51 typedef struct sap_session_t
52 {
53     struct sap_session_t *next;
54     const session_descriptor_t *p_sd;
55     size_t                length;
56     uint8_t               data[];
57 } sap_session_t;
58
59 /* A SAP announce address. For each of these, we run the
60  * control flow algorithm */
61 typedef struct sap_address_t
62 {
63     struct sap_address_t   *next;
64
65     vlc_thread_t            thread;
66     vlc_mutex_t             lock;
67     vlc_cond_t              wait;
68
69     char                    group[NI_MAXNUMERICHOST];
70     struct sockaddr_storage orig;
71     socklen_t               origlen;
72     int                     fd;
73     unsigned                interval;
74
75     unsigned                session_count;
76     sap_session_t          *first;
77 } sap_address_t;
78
79 /* The SAP handler, running in a separate thread */
80 struct sap_handler_t
81 {
82     VLC_COMMON_MEMBERS
83
84     vlc_mutex_t    lock;
85     sap_address_t *first;
86 };
87
88 #define SAP_MAX_BUFFER 65534
89 #define MIN_INTERVAL 2
90 #define MAX_INTERVAL 300
91
92 /*****************************************************************************
93  * Local prototypes
94  *****************************************************************************/
95 static void *RunThread (void *);
96
97 /**
98  * Create the SAP handler
99  *
100  * \param p_announce a VLC object
101  * \return the newly created SAP handler or NULL on error
102  */
103 sap_handler_t *SAP_Create (vlc_object_t *p_announce)
104 {
105     sap_handler_t *p_sap;
106
107     p_sap = vlc_custom_create (p_announce, sizeof (*p_sap),
108                                VLC_OBJECT_GENERIC, "sap sender");
109     if (p_sap == NULL)
110         return NULL;
111
112     vlc_mutex_init (&p_sap->lock);
113     p_sap->first = NULL;
114     return p_sap;
115 }
116
117 void SAP_Destroy (sap_handler_t *p_sap)
118 {
119     assert (p_sap->first == NULL);
120     vlc_mutex_destroy (&p_sap->lock);
121     vlc_object_release (p_sap);
122 }
123
124 static sap_address_t *AddressCreate (vlc_object_t *obj, const char *group)
125 {
126     int fd = net_ConnectUDP (obj, group, IPPORT_SAP, 255);
127     if (fd == -1)
128         return NULL;
129
130     sap_address_t *addr = malloc (sizeof (*addr));
131     if (addr == NULL)
132     {
133         net_Close (fd);
134         return NULL;
135     }
136
137     strlcpy (addr->group, group, sizeof (addr->group));
138     addr->fd = fd;
139     addr->origlen = sizeof (addr->orig);
140     getsockname (fd, (struct sockaddr *)&addr->orig, &addr->origlen);
141
142     addr->interval = var_CreateGetInteger (obj, "sap-interval");
143     vlc_mutex_init (&addr->lock);
144     vlc_cond_init (&addr->wait);
145     addr->session_count = 0;
146     addr->first = NULL;
147
148     if (vlc_clone (&addr->thread, RunThread, addr, VLC_THREAD_PRIORITY_LOW))
149     {
150         msg_Err (obj, "unable to spawn SAP announce thread");
151         net_Close (fd);
152         free (addr);
153         return NULL;
154     }
155     return addr;
156 }
157
158 static void AddressDestroy (sap_address_t *addr)
159 {
160     assert (addr->first == NULL);
161
162     vlc_cancel (addr->thread);
163     vlc_join (addr->thread, NULL);
164     vlc_cond_destroy (&addr->wait);
165     vlc_mutex_destroy (&addr->lock);
166     net_Close (addr->fd);
167     free (addr);
168 }
169
170 /**
171  * main SAP handler thread
172  * \param p_this the SAP Handler object
173  * \return nothing
174  */
175 static void *RunThread (void *self)
176 {
177     sap_address_t *addr = self;
178
179     vlc_mutex_lock (&addr->lock);
180     mutex_cleanup_push (&addr->lock);
181
182     for (;;)
183     {
184         sap_session_t *p_session;
185         mtime_t deadline;
186
187         while (addr->first == NULL)
188             vlc_cond_wait (&addr->wait, &addr->lock);
189
190         assert (addr->session_count > 0);
191
192         deadline = mdate ();
193         for (p_session = addr->first; p_session; p_session = p_session->next)
194         {
195             send (addr->fd, p_session->data, p_session->length, 0);
196             deadline += addr->interval * CLOCK_FREQ / addr->session_count;
197
198             if (vlc_cond_timedwait (&addr->wait, &addr->lock, deadline) == 0)
199                 break; /* list may have changed! */
200         }
201     }
202
203     vlc_cleanup_pop ();
204     assert (0);
205 }
206
207 /**
208  * Add a SAP announce
209  */
210 int SAP_Add (sap_handler_t *p_sap, session_descriptor_t *p_session)
211 {
212     int i;
213     char psz_addr[NI_MAXNUMERICHOST];
214     bool b_ipv6 = false, b_ssm = false;
215     sap_session_t *p_sap_session;
216     mtime_t i_hash;
217     union
218     {
219         struct sockaddr     a;
220         struct sockaddr_in  in;
221         struct sockaddr_in6 in6;
222     } addr;
223     socklen_t addrlen;
224
225     addrlen = p_session->addrlen;
226     if ((addrlen == 0) || (addrlen > sizeof (addr)))
227     {
228         msg_Err( p_sap, "No/invalid address specified for SAP announce" );
229         return VLC_EGENERIC;
230     }
231
232     /* Determine SAP multicast address automatically */
233     memcpy (&addr, &p_session->addr, addrlen);
234
235     switch (addr.a.sa_family)
236     {
237 #if defined (HAVE_INET_PTON) || defined (WIN32)
238         case AF_INET6:
239         {
240             /* See RFC3513 for list of valid IPv6 scopes */
241             struct in6_addr *a6 = &addr.in6.sin6_addr;
242
243             memcpy( a6->s6_addr + 2, "\x00\x00\x00\x00\x00\x00"
244                    "\x00\x00\x00\x00\x00\x02\x7f\xfe", 14 );
245             if( IN6_IS_ADDR_MULTICAST( a6 ) )
246             {
247                 /* SSM <=> ff3x::/32 */
248                 b_ssm = (U32_AT (a6->s6_addr) & 0xfff0ffff) == 0xff300000;
249
250                 /* force flags to zero, preserve scope */
251                 a6->s6_addr[1] &= 0xf;
252             }
253             else
254                 /* Unicast IPv6 - assume global scope */
255                 memcpy( a6->s6_addr, "\xff\x0e", 2 );
256
257             b_ipv6 = true;
258             break;
259         }
260 #endif
261
262         case AF_INET:
263         {
264             /* See RFC2365 for IPv4 scopes */
265             uint32_t ipv4 = addr.in.sin_addr.s_addr;
266
267             /* 224.0.0.0/24 => 224.0.0.255 */
268             if ((ipv4 & htonl (0xffffff00)) == htonl (0xe0000000))
269                 ipv4 =  htonl (0xe00000ff);
270             else
271             /* 239.255.0.0/16 => 239.255.255.255 */
272             if ((ipv4 & htonl (0xffff0000)) == htonl (0xefff0000))
273                 ipv4 =  htonl (0xefffffff);
274             else
275             /* 239.192.0.0/14 => 239.195.255.255 */
276             if ((ipv4 & htonl (0xfffc0000)) == htonl (0xefc00000))
277                 ipv4 =  htonl (0xefc3ffff);
278             else
279             if ((ipv4 & htonl (0xff000000)) == htonl (0xef000000))
280                 ipv4 = 0;
281             else
282             /* other addresses => 224.2.127.254 */
283             {
284                 /* SSM: 232.0.0.0/8 */
285                 b_ssm = (ipv4 & htonl (255 << 24)) == htonl (232 << 24);
286                 ipv4 = htonl (0xe0027ffe);
287             }
288
289             if( ipv4 == 0 )
290             {
291                 msg_Err( p_sap, "Out-of-scope multicast address "
292                          "not supported by SAP" );
293                 return VLC_EGENERIC;
294             }
295
296             addr.in.sin_addr.s_addr = ipv4;
297             break;
298         }
299
300         default:
301             msg_Err( p_sap, "Address family %d not supported by SAP",
302                      addr.a.sa_family );
303             return VLC_EGENERIC;
304     }
305
306     i = vlc_getnameinfo( &addr.a, addrlen,
307                          psz_addr, sizeof( psz_addr ), NULL, NI_NUMERICHOST );
308
309     if( i )
310     {
311         msg_Err( p_sap, "%s", vlc_gai_strerror( i ) );
312         return VLC_EGENERIC;
313     }
314
315     /* Find/create SAP address thread */
316     msg_Dbg( p_sap, "using SAP address: %s", psz_addr);
317
318     vlc_mutex_lock (&p_sap->lock);
319     sap_address_t *sap_addr;
320     for (sap_addr = p_sap->first; sap_addr; sap_addr = sap_addr->next)
321         if (!strcmp (psz_addr, sap_addr->group))
322             break;
323
324     if (sap_addr == NULL)
325     {
326         sap_addr = AddressCreate (VLC_OBJECT(p_sap), psz_addr);
327         if (sap_addr == NULL)
328         {
329             vlc_mutex_unlock (&p_sap->lock);
330             return VLC_EGENERIC;
331         }
332         sap_addr->next = p_sap->first;
333         p_sap->first = sap_addr;
334     }
335     /* Switch locks.
336      * NEVER take the global SAP lock when holding a SAP thread lock! */
337     vlc_mutex_lock (&sap_addr->lock);
338     vlc_mutex_unlock (&p_sap->lock);
339
340     memcpy (&p_session->orig, &sap_addr->orig, sap_addr->origlen);
341     p_session->origlen = sap_addr->origlen;
342
343     size_t headsize = 20, length;
344     switch (p_session->orig.ss_family)
345     {
346 #ifdef AF_INET6
347         case AF_INET6:
348             headsize += 16;
349             break;
350 #endif
351         case AF_INET:
352             headsize += 4;
353             break;
354         default:
355             assert (0);
356     }
357
358     /* XXX: Check for dupes */
359     length = headsize + strlen (p_session->psz_sdp);
360     p_sap_session = malloc (sizeof (*p_sap_session) + length + 1);
361     if (p_sap_session == NULL)
362     {
363         vlc_mutex_unlock (&sap_addr->lock);
364         return VLC_EGENERIC; /* NOTE: we should destroy the thread if left unused */
365     }
366     p_sap_session->next = sap_addr->first;
367     sap_addr->first = p_sap_session;
368     p_sap_session->p_sd = p_session;
369     p_sap_session->length = length;
370
371     /* Build the SAP Headers */
372     uint8_t *psz_head = p_sap_session->data;
373
374     /* SAPv1, not encrypted, not compressed */
375     psz_head[0] = 0x20;
376     psz_head[1] = 0x00; /* No authentification length */
377
378     i_hash = mdate();
379     psz_head[2] = i_hash >> 8; /* Msg id hash */
380     psz_head[3] = i_hash;      /* Msg id hash 2 */
381
382     headsize = 4;
383     switch (p_session->orig.ss_family)
384     {
385 #ifdef AF_INET6
386         case AF_INET6:
387         {
388             struct in6_addr *a6 =
389                 &((struct sockaddr_in6 *)&p_session->orig)->sin6_addr;
390             memcpy (psz_head + headsize, a6, 16);
391             psz_head[0] |= 0x10; /* IPv6 flag */
392             headsize += 16;
393             break;
394         }
395 #endif
396         case AF_INET:
397         {
398             uint32_t ipv4 =
399                 (((struct sockaddr_in *)&p_session->orig)->sin_addr.s_addr);
400             memcpy (psz_head + headsize, &ipv4, 4);
401             headsize += 4;
402             break;
403         }
404
405     }
406
407     memcpy (psz_head + headsize, "application/sdp", 16);
408     headsize += 16;
409
410     /* Build the final message */
411     strcpy( (char *)psz_head + headsize, p_session->psz_sdp);
412
413     sap_addr->session_count++;
414     vlc_cond_signal (&sap_addr->wait);
415     vlc_mutex_unlock (&sap_addr->lock);
416     return VLC_SUCCESS;
417 }
418
419 /**
420  * Remove a SAP Announce
421  */
422 void SAP_Del (sap_handler_t *p_sap, const session_descriptor_t *p_session)
423 {
424     vlc_mutex_lock (&p_sap->lock);
425
426     /* TODO: give a handle back in SAP_Add, and use that... */
427     sap_address_t *addr, **paddr;
428     sap_session_t *session, **psession;
429
430     paddr = &p_sap->first;
431     for (addr = p_sap->first; addr; addr = addr->next)
432     {
433         psession = &addr->first;
434         vlc_mutex_lock (&addr->lock);
435         for (session = addr->first; session; session = session->next)
436         {
437             if (session->p_sd == p_session)
438                 goto found;
439             psession = &session->next;
440         }
441         vlc_mutex_unlock (&addr->lock);
442         paddr = &addr->next;
443     }
444     assert (0);
445
446 found:
447     *psession = session->next;
448
449     if (addr->first == NULL)
450         /* Last session for this address -> unlink the address */
451         *paddr = addr->next;
452     vlc_mutex_unlock (&p_sap->lock);
453
454     if (addr->first == NULL)
455     {
456         /* Last session for this address -> unlink the address */
457         vlc_mutex_unlock (&addr->lock);
458         AddressDestroy (addr);
459     }
460     else
461     {
462         addr->session_count--;
463         vlc_cond_signal (&addr->wait);
464         vlc_mutex_unlock (&addr->lock);
465     }
466
467     free (session);
468 }