sap.c
上传用户:kjfoods
上传日期:2020-07-06
资源大小:29949k
文件大小:13k
源码类别:

midi

开发平台:

Unix_Linux

  1. /*****************************************************************************
  2.  * sap.c : SAP announce handler
  3.  *****************************************************************************
  4.  * Copyright (C) 2002-2008 the VideoLAN team
  5.  * $Id: e71906114db4bb0aeca777063a9414205f0317a6 $
  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.  * Preamble
  26.  *****************************************************************************/
  27. #ifdef HAVE_CONFIG_H
  28. # include "config.h"
  29. #endif
  30. #include <vlc_common.h>
  31. #include <stdlib.h>                                                /* free() */
  32. #include <stdio.h>                                              /* sprintf() */
  33. #include <string.h>
  34. #include <ctype.h>                                  /* tolower(), isxdigit() */
  35. #include <assert.h>
  36. #include <vlc_sout.h>
  37. #include <vlc_network.h>
  38. #include "stream_output.h"
  39. #include "libvlc.h"
  40. /* SAP is always on that port */
  41. #define IPPORT_SAP 9875
  42. /* A SAP session descriptor, enqueued in the SAP handler queue */
  43. typedef struct sap_session_t
  44. {
  45.     struct sap_session_t *next;
  46.     const session_descriptor_t *p_sd;
  47.     size_t                length;
  48.     uint8_t               data[];
  49. } sap_session_t;
  50. /* A SAP announce address. For each of these, we run the
  51.  * control flow algorithm */
  52. typedef struct sap_address_t
  53. {
  54.     struct sap_address_t   *next;
  55.     vlc_thread_t            thread;
  56.     vlc_mutex_t             lock;
  57.     vlc_cond_t              wait;
  58.     char                    group[NI_MAXNUMERICHOST];
  59.     struct sockaddr_storage orig;
  60.     socklen_t               origlen;
  61.     int                     fd;
  62.     unsigned                interval;
  63.     unsigned                session_count;
  64.     sap_session_t          *first;
  65. } sap_address_t;
  66. /* The SAP handler, running in a separate thread */
  67. struct sap_handler_t
  68. {
  69.     VLC_COMMON_MEMBERS
  70.     vlc_mutex_t    lock;
  71.     sap_address_t *first;
  72. };
  73. #define SAP_MAX_BUFFER 65534
  74. #define MIN_INTERVAL 2
  75. #define MAX_INTERVAL 300
  76. /*****************************************************************************
  77.  * Local prototypes
  78.  *****************************************************************************/
  79. static void *RunThread (void *);
  80. /**
  81.  * Create the SAP handler
  82.  *
  83.  * param p_announce a VLC object
  84.  * return the newly created SAP handler or NULL on error
  85.  */
  86. sap_handler_t *SAP_Create (vlc_object_t *p_announce)
  87. {
  88.     sap_handler_t *p_sap;
  89.     p_sap = vlc_custom_create (p_announce, sizeof (*p_sap),
  90.                                VLC_OBJECT_GENERIC, "sap sender");
  91.     if (p_sap == NULL)
  92.         return NULL;
  93.     vlc_mutex_init (&p_sap->lock);
  94.     p_sap->first = NULL;
  95.     return p_sap;
  96. }
  97. void SAP_Destroy (sap_handler_t *p_sap)
  98. {
  99.     assert (p_sap->first == NULL);
  100.     vlc_mutex_destroy (&p_sap->lock);
  101.     vlc_object_release (p_sap);
  102. }
  103. static sap_address_t *AddressCreate (vlc_object_t *obj, const char *group)
  104. {
  105.     int fd = net_ConnectUDP (obj, group, IPPORT_SAP, 255);
  106.     if (fd == -1)
  107.         return NULL;
  108.     sap_address_t *addr = malloc (sizeof (*addr));
  109.     if (addr == NULL)
  110.     {
  111.         net_Close (fd);
  112.         return NULL;
  113.     }
  114.     strlcpy (addr->group, group, sizeof (addr->group));
  115.     addr->fd = fd;
  116.     addr->origlen = sizeof (addr->orig);
  117.     getsockname (fd, (struct sockaddr *)&addr->orig, &addr->origlen);
  118.     addr->interval = var_CreateGetInteger (obj, "sap-interval");
  119.     vlc_mutex_init (&addr->lock);
  120.     vlc_cond_init (&addr->wait);
  121.     addr->session_count = 0;
  122.     addr->first = NULL;
  123.     if (vlc_clone (&addr->thread, RunThread, addr, VLC_THREAD_PRIORITY_LOW))
  124.     {
  125.         msg_Err (obj, "unable to spawn SAP announce thread");
  126.         net_Close (fd);
  127.         free (addr);
  128.         return NULL;
  129.     }
  130.     return addr;
  131. }
  132. static void AddressDestroy (sap_address_t *addr)
  133. {
  134.     assert (addr->first == NULL);
  135.     vlc_cancel (addr->thread);
  136.     vlc_join (addr->thread, NULL);
  137.     vlc_cond_destroy (&addr->wait);
  138.     vlc_mutex_destroy (&addr->lock);
  139.     net_Close (addr->fd);
  140.     free (addr);
  141. }
  142. /**
  143.  * main SAP handler thread
  144.  * param p_this the SAP Handler object
  145.  * return nothing
  146.  */
  147. static void *RunThread (void *self)
  148. {
  149.     sap_address_t *addr = self;
  150.     vlc_mutex_lock (&addr->lock);
  151.     mutex_cleanup_push (&addr->lock);
  152.     for (;;)
  153.     {
  154.         sap_session_t *p_session;
  155.         mtime_t deadline;
  156.         while (addr->first == NULL)
  157.             vlc_cond_wait (&addr->wait, &addr->lock);
  158.         assert (addr->session_count > 0);
  159.         deadline = mdate ();
  160.         for (p_session = addr->first; p_session; p_session = p_session->next)
  161.         {
  162.             send (addr->fd, p_session->data, p_session->length, 0);
  163.             deadline += addr->interval * CLOCK_FREQ / addr->session_count;
  164.             if (vlc_cond_timedwait (&addr->wait, &addr->lock, deadline) == 0)
  165.                 break; /* list may have changed! */
  166.         }
  167.     }
  168.     vlc_cleanup_pop ();
  169.     assert (0);
  170. }
  171. /**
  172.  * Add a SAP announce
  173.  */
  174. int SAP_Add (sap_handler_t *p_sap, session_descriptor_t *p_session)
  175. {
  176.     int i;
  177.     char psz_addr[NI_MAXNUMERICHOST];
  178.     bool b_ipv6 = false, b_ssm = false;
  179.     sap_session_t *p_sap_session;
  180.     mtime_t i_hash;
  181.     struct sockaddr_storage addr;
  182.     socklen_t addrlen;
  183.     addrlen = p_session->addrlen;
  184.     if ((addrlen == 0) || (addrlen > sizeof (addr)))
  185.     {
  186.         msg_Err( p_sap, "No/invalid address specified for SAP announce" );
  187.         return VLC_EGENERIC;
  188.     }
  189.     /* Determine SAP multicast address automatically */
  190.     memcpy (&addr, &p_session->addr, addrlen);
  191.     switch( p_session->addr.ss_family )
  192.     {
  193. #if defined (HAVE_INET_PTON) || defined (WIN32)
  194.         case AF_INET6:
  195.         {
  196.             /* See RFC3513 for list of valid IPv6 scopes */
  197.             struct in6_addr *a6 = &((struct sockaddr_in6 *)&addr)->sin6_addr;
  198.             memcpy( a6->s6_addr + 2, "x00x00x00x00x00x00"
  199.                    "x00x00x00x00x00x02x7fxfe", 14 );
  200.             if( IN6_IS_ADDR_MULTICAST( a6 ) )
  201.             {
  202.                 /* SSM <=> ff3x::/32 */
  203.                 b_ssm = (U32_AT (a6->s6_addr) & 0xfff0ffff) == 0xff300000;
  204.                 /* force flags to zero, preserve scope */
  205.                 a6->s6_addr[1] &= 0xf;
  206.             }
  207.             else
  208.                 /* Unicast IPv6 - assume global scope */
  209.                 memcpy( a6->s6_addr, "xffx0e", 2 );
  210.             b_ipv6 = true;
  211.             break;
  212.         }
  213. #endif
  214.         case AF_INET:
  215.         {
  216.             /* See RFC2365 for IPv4 scopes */
  217.             uint32_t ipv4;
  218.             ipv4 = ntohl( ((struct sockaddr_in *)&addr)->sin_addr.s_addr );
  219.             /* 224.0.0.0/24 => 224.0.0.255 */
  220.             if ((ipv4 & 0xffffff00) == 0xe0000000)
  221.                 ipv4 =  0xe00000ff;
  222.             else
  223.             /* 239.255.0.0/16 => 239.255.255.255 */
  224.             if ((ipv4 & 0xffff0000) == 0xefff0000)
  225.                 ipv4 =  0xefffffff;
  226.             else
  227.             /* 239.192.0.0/14 => 239.195.255.255 */
  228.             if ((ipv4 & 0xfffc0000) == 0xefc00000)
  229.                 ipv4 =  0xefc3ffff;
  230.             else
  231.             if ((ipv4 & 0xff000000) == 0xef000000)
  232.                 ipv4 = 0;
  233.             else
  234.             /* other addresses => 224.2.127.254 */
  235.             {
  236.                 /* SSM: 232.0.0.0/8 */
  237.                 b_ssm = (ipv4 >> 24) == 232;
  238.                 ipv4 = 0xe0027ffe;
  239.             }
  240.             if( ipv4 == 0 )
  241.             {
  242.                 msg_Err( p_sap, "Out-of-scope multicast address "
  243.                          "not supported by SAP" );
  244.                 return VLC_EGENERIC;
  245.             }
  246.             ((struct sockaddr_in *)&addr)->sin_addr.s_addr = htonl( ipv4 );
  247.             break;
  248.         }
  249.         default:
  250.             msg_Err( p_sap, "Address family %d not supported by SAP",
  251.                      addr.ss_family );
  252.             return VLC_EGENERIC;
  253.     }
  254.     i = vlc_getnameinfo( (struct sockaddr *)&addr, addrlen,
  255.                          psz_addr, sizeof( psz_addr ), NULL, NI_NUMERICHOST );
  256.     if( i )
  257.     {
  258.         msg_Err( p_sap, "%s", vlc_gai_strerror( i ) );
  259.         return VLC_EGENERIC;
  260.     }
  261.     /* Find/create SAP address thread */
  262.     msg_Dbg( p_sap, "using SAP address: %s", psz_addr);
  263.     vlc_mutex_lock (&p_sap->lock);
  264.     sap_address_t *sap_addr;
  265.     for (sap_addr = p_sap->first; sap_addr; sap_addr = sap_addr->next)
  266.         if (!strcmp (psz_addr, sap_addr->group))
  267.             break;
  268.     if (sap_addr == NULL)
  269.     {
  270.         sap_addr = AddressCreate (VLC_OBJECT(p_sap), psz_addr);
  271.         if (sap_addr == NULL)
  272.         {
  273.             vlc_mutex_unlock (&p_sap->lock);
  274.             return VLC_EGENERIC;
  275.         }
  276.         sap_addr->next = p_sap->first;
  277.         p_sap->first = sap_addr;
  278.     }
  279.     /* Switch locks.
  280.      * NEVER take the global SAP lock when holding a SAP thread lock! */
  281.     vlc_mutex_lock (&sap_addr->lock);
  282.     vlc_mutex_unlock (&p_sap->lock);
  283.     memcpy (&p_session->orig, &sap_addr->orig, sap_addr->origlen);
  284.     p_session->origlen = sap_addr->origlen;
  285.     size_t headsize = 20, length;
  286.     switch (p_session->orig.ss_family)
  287.     {
  288. #ifdef AF_INET6
  289.         case AF_INET6:
  290.             headsize += 16;
  291.             break;
  292. #endif
  293.         case AF_INET:
  294.             headsize += 4;
  295.             break;
  296.         default:
  297.             assert (0);
  298.     }
  299.     /* XXX: Check for dupes */
  300.     length = headsize + strlen (p_session->psz_sdp);
  301.     p_sap_session = malloc (sizeof (*p_sap_session) + length + 1);
  302.     if (p_sap_session == NULL)
  303.     {
  304.         vlc_mutex_unlock (&sap_addr->lock);
  305.         return VLC_EGENERIC; /* NOTE: we should destroy the thread if left unused */
  306.     }
  307.     p_sap_session->next = sap_addr->first;
  308.     sap_addr->first = p_sap_session;
  309.     p_sap_session->p_sd = p_session;
  310.     p_sap_session->length = length;
  311.     /* Build the SAP Headers */
  312.     uint8_t *psz_head = p_sap_session->data;
  313.     /* SAPv1, not encrypted, not compressed */
  314.     psz_head[0] = 0x20;
  315.     psz_head[1] = 0x00; /* No authentification length */
  316.     i_hash = mdate();
  317.     psz_head[2] = i_hash >> 8; /* Msg id hash */
  318.     psz_head[3] = i_hash;      /* Msg id hash 2 */
  319.     headsize = 4;
  320.     switch (p_session->orig.ss_family)
  321.     {
  322. #ifdef AF_INET6
  323.         case AF_INET6:
  324.         {
  325.             struct in6_addr *a6 =
  326.                 &((struct sockaddr_in6 *)&p_session->orig)->sin6_addr;
  327.             memcpy (psz_head + headsize, a6, 16);
  328.             psz_head[0] |= 0x10; /* IPv6 flag */
  329.             headsize += 16;
  330.             break;
  331.         }
  332. #endif
  333.         case AF_INET:
  334.         {
  335.             uint32_t ipv4 =
  336.                 (((struct sockaddr_in *)&p_session->orig)->sin_addr.s_addr);
  337.             memcpy (psz_head + headsize, &ipv4, 4);
  338.             headsize += 4;
  339.             break;
  340.         }
  341.     }
  342.     memcpy (psz_head + headsize, "application/sdp", 16);
  343.     headsize += 16;
  344.     /* Build the final message */
  345.     strcpy( (char *)psz_head + headsize, p_session->psz_sdp);
  346.     sap_addr->session_count++;
  347.     vlc_cond_signal (&sap_addr->wait);
  348.     vlc_mutex_unlock (&sap_addr->lock);
  349.     return VLC_SUCCESS;
  350. }
  351. /**
  352.  * Remove a SAP Announce
  353.  */
  354. void SAP_Del (sap_handler_t *p_sap, const session_descriptor_t *p_session)
  355. {
  356.     vlc_mutex_lock (&p_sap->lock);
  357.     /* TODO: give a handle back in SAP_Add, and use that... */
  358.     sap_address_t *addr, **paddr;
  359.     sap_session_t *session, **psession;
  360.     paddr = &p_sap->first;
  361.     for (addr = p_sap->first; addr; addr = addr->next)
  362.     {
  363.         psession = &addr->first;
  364.         vlc_mutex_lock (&addr->lock);
  365.         for (session = addr->first; session; session = session->next)
  366.         {
  367.             if (session->p_sd == p_session)
  368.                 goto found;
  369.             psession = &session->next;
  370.         }
  371.         vlc_mutex_unlock (&addr->lock);
  372.         paddr = &addr->next;
  373.     }
  374.     assert (0);
  375. found:
  376.     *psession = session->next;
  377.     if (addr->first == NULL)
  378.         /* Last session for this address -> unlink the address */
  379.         *paddr = addr->next;
  380.     vlc_mutex_unlock (&p_sap->lock);
  381.     if (addr->first == NULL)
  382.     {
  383.         /* Last session for this address -> unlink the address */
  384.         vlc_mutex_unlock (&addr->lock);
  385.         AddressDestroy (addr);
  386.     }
  387.     else
  388.     {
  389.         addr->session_count--;
  390.         vlc_cond_signal (&addr->wait);
  391.         vlc_mutex_unlock (&addr->lock);
  392.     }
  393.     free (session);
  394. }