exconf.c

mediastreamer2是开源的网络传输媒体流的库

              OSIP_TRACE (osip_trace
                          (__FILE__, __LINE__, OSIP_INFO3, NULL,
                           "eXosip: Skipping protocol %d\n",
                           curinfo_rtp->ai_protocol));
              continue;
            }

          sock = (int) socket (curinfo_rtp->ai_family, curinfo_rtp->ai_socktype,
                               curinfo_rtp->ai_protocol);
          if (sock < 0)
            {
              OSIP_TRACE (osip_trace
                          (__FILE__, __LINE__, OSIP_ERROR, NULL,
                           "eXosip: Cannot create socket!\n"));
              continue;
            }

          if (curinfo_rtp->ai_family == AF_INET6)
            {
#ifdef IPV6_V6ONLY
              if (setsockopt_ipv6only (sock))
                {
                  close (sock);
                  sock = -1;
                  OSIP_TRACE (osip_trace
                              (__FILE__, __LINE__, OSIP_ERROR, NULL,
                               "eXosip: Cannot set socket option!\n"));
                  continue;
                }
#endif /* IPV6_V6ONLY */
            }

          res1 = bind (sock, curinfo_rtp->ai_addr, curinfo_rtp->ai_addrlen);
          if (res1 < 0)
            {
              OSIP_TRACE (osip_trace
                          (__FILE__, __LINE__, OSIP_WARNING, NULL,
                           "eXosip: Cannot bind socket node: 0.0.0.0 family:%d\n",
                           curinfo_rtp->ai_family));
              close (sock);
              sock = -1;
              continue;
            }
          break;
        }

      eXosip_freeaddrinfo (addrinfo_rtp);

      if (sock == -1)
        {
          eXosip_freeaddrinfo (addrinfo_rtcp);
          continue;
        }

      close (sock);
      sock = -1;
      for (curinfo_rtcp = addrinfo_rtcp; curinfo_rtcp;
           curinfo_rtcp = curinfo_rtcp->ai_next)
        {
          if (curinfo_rtcp->ai_protocol && curinfo_rtcp->ai_protocol != transport)
            {
              OSIP_TRACE (osip_trace
                          (__FILE__, __LINE__, OSIP_INFO3, NULL,
                           "eXosip: Skipping protocol %d\n",
                           curinfo_rtcp->ai_protocol));
              continue;
            }

          sock = (int) socket (curinfo_rtcp->ai_family, curinfo_rtcp->ai_socktype,
                               curinfo_rtcp->ai_protocol);
          if (sock < 0)
            {
              OSIP_TRACE (osip_trace
                          (__FILE__, __LINE__, OSIP_ERROR, NULL,
                           "eXosip: Cannot create socket!\n"));
              continue;
            }

          if (curinfo_rtcp->ai_family == AF_INET6)
            {
#ifdef IPV6_V6ONLY
              if (setsockopt_ipv6only (sock))
                {
                  close (sock);
                  sock = -1;
                  OSIP_TRACE (osip_trace
                              (__FILE__, __LINE__, OSIP_ERROR, NULL,
                               "eXosip: Cannot set socket option!\n"));
                  continue;
                }
#endif /* IPV6_V6ONLY */
            }

          res1 = bind (sock, curinfo_rtcp->ai_addr, curinfo_rtcp->ai_addrlen);
          if (res1 < 0)
            {
              OSIP_TRACE (osip_trace
                          (__FILE__, __LINE__, OSIP_WARNING, NULL,
                           "eXosip: Cannot bind socket node: 0.0.0.0 family:%d\n",
                           curinfo_rtp->ai_family));
              close (sock);
              sock = -1;
              continue;
            }
          break;
        }

      eXosip_freeaddrinfo (addrinfo_rtcp);

      /* the pair must be free */
      if (sock == -1)
        continue;

      close (sock);
      sock = -1;
      return free_port + count * 2;
    }

  /* just get a free port */
  res1 = eXosip_get_addrinfo (&addrinfo_rtp, "0.0.0.0", 0, transport);
  if (res1)
    return res1;

  sock = -1;
  for (curinfo_rtp = addrinfo_rtp; curinfo_rtp; curinfo_rtp = curinfo_rtp->ai_next)
    {
      socklen_t len;
      struct sockaddr_storage ai_addr;

      if (curinfo_rtp->ai_protocol && curinfo_rtp->ai_protocol != transport)
        {
          OSIP_TRACE (osip_trace
                      (__FILE__, __LINE__, OSIP_INFO3, NULL,
                       "eXosip: Skipping protocol %d\n",
                       curinfo_rtp->ai_protocol));
          continue;
        }

      sock = (int) socket (curinfo_rtp->ai_family, curinfo_rtp->ai_socktype,
                           curinfo_rtp->ai_protocol);
      if (sock < 0)
        {
          OSIP_TRACE (osip_trace
                      (__FILE__, __LINE__, OSIP_ERROR, NULL,
                       "eXosip: Cannot create socket!\n"));
          continue;
        }

      if (curinfo_rtp->ai_family == AF_INET6)
        {
#ifdef IPV6_V6ONLY
          if (setsockopt_ipv6only (sock))
            {
              close (sock);
              sock = -1;
              OSIP_TRACE (osip_trace
                          (__FILE__, __LINE__, OSIP_ERROR, NULL,
                           "eXosip: Cannot set socket option!\n"));
              continue;
            }
#endif /* IPV6_V6ONLY */
        }

      res1 = bind (sock, curinfo_rtp->ai_addr, curinfo_rtp->ai_addrlen);
      if (res1 < 0)
        {
          OSIP_TRACE (osip_trace
                      (__FILE__, __LINE__, OSIP_WARNING, NULL,
                       "eXosip: Cannot bind socket node: 0.0.0.0 family:%d\n",
                       curinfo_rtp->ai_family));
          close (sock);
          sock = -1;
          continue;
        }

      len = sizeof (ai_addr);
      res1 = getsockname (sock, (struct sockaddr *) &ai_addr, &len);
      if (res1 != 0)
        {
          close (sock);
          sock = -1;
          continue;
        }

      close (sock);
      sock = -1;
      eXosip_freeaddrinfo (addrinfo_rtp);

      if (ipv6_enable == 0)
        return ntohs (((struct sockaddr_in *) &ai_addr)->sin_port);
      else
        return ntohs (((struct sockaddr_in6 *) &ai_addr)->sin6_port);
    }

  eXosip_freeaddrinfo (addrinfo_rtp);

  if (sock != -1)
    {
      close (sock);
      sock = -1;
    }

  return OSIP_UNDEFINED_ERROR;
}
#endif

int
eXosip_listen_addr (int transport, const char *addr, int port, int family,
                    int secure)
{
  int i = -1;
  struct eXtl_protocol *eXtl = NULL;

  if (eXosip.eXtl != NULL)
    {
      /* already set */
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_ERROR, NULL,
                   "eXosip: already listening somewhere\n"));
      return OSIP_WRONG_STATE;
    }

  if (transport == IPPROTO_UDP && secure == 0)
    eXtl = &eXtl_udp;
  else if (transport == IPPROTO_TCP && secure == 0)
    eXtl = &eXtl_tcp;
#ifdef HAVE_OPENSSL_SSL_H
#if !(OPENSSL_VERSION_NUMBER < 0x00908000L)
  else if (transport == IPPROTO_UDP)
    eXtl = &eXtl_dtls;
#endif
  else if (transport == IPPROTO_TCP)
    eXtl = &eXtl_tls;
#endif

  if (eXtl == NULL)
    return OSIP_BADPARAMETER;

  eXtl->proto_family = family;
  eXtl->proto_port = port;
  if (addr != NULL)
    snprintf (eXtl->proto_ifs, sizeof (eXtl->proto_ifs), "%s", addr);

#ifdef	AF_INET6
  if (family == AF_INET6 && !addr)
    snprintf (eXtl->proto_ifs, sizeof (eXtl->proto_ifs), "::0");
#endif

  i = eXtl->tl_open ();

  if (i != 0)
    return i;

  eXosip.eXtl = eXtl;

  if (transport == IPPROTO_UDP && secure == 0)
    snprintf (eXosip.transport, sizeof (eXosip.transport), "%s", "UDP");
  else if (transport == IPPROTO_TCP && secure == 0)
    snprintf (eXosip.transport, sizeof (eXosip.transport), "%s", "TCP");
  else if (transport == IPPROTO_UDP)
    snprintf (eXosip.transport, sizeof (eXosip.transport), "%s", "DTLS-UDP");
  else if (transport == IPPROTO_TCP)
    snprintf (eXosip.transport, sizeof (eXosip.transport), "%s", "TLS");

#ifdef OSIP_MT
  if (eXosip.j_thread == NULL)
    {
      eXosip.j_thread = (void *) osip_thread_create (20000, _eXosip_thread, NULL);
      if (eXosip.j_thread == NULL)
        {
          OSIP_TRACE (osip_trace
                      (__FILE__, __LINE__, OSIP_ERROR, NULL,
                       "eXosip: Cannot start thread!\n"));
          return OSIP_UNDEFINED_ERROR;
        }
    }
#endif

  return OSIP_SUCCESS;
}

int
eXosip_init (void)
{
  osip_t *osip;
  int i;

  memset (&eXosip, 0, sizeof (eXosip));

  snprintf (eXosip.ipv4_for_gateway, 256, "%s", "217.12.3.11");
  snprintf (eXosip.ipv6_for_gateway, 256, "%s",
            "2001:638:500:101:2e0:81ff:fe24:37c6");
#ifndef MINISIZE
  snprintf (eXosip.event_package, 256, "%s", "dialog");
#endif

#ifdef WIN32
  /* Initializing windows socket library */
  {
    WORD wVersionRequested;
    WSADATA wsaData;

    wVersionRequested = MAKEWORD (1, 1);
    i = WSAStartup (wVersionRequested, &wsaData);
    if (i != 0)
      {
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_WARNING, NULL,
                     "eXosip: Unable to initialize WINSOCK, reason: %d\n", i));
        /* return -1; It might be already initilized?? */
      }
  }
#endif

  eXosip.user_agent = osip_strdup ("eXosip/" EXOSIP_VERSION);
  if (eXosip.user_agent == NULL)
    return OSIP_NOMEM;

  eXosip.j_calls = NULL;
  eXosip.j_stop_ua = 0;
#ifdef OSIP_MT
  eXosip.j_thread = NULL;
#endif
  i = osip_list_init (&eXosip.j_transactions);
  eXosip.j_reg = NULL;

#ifdef OSIP_MT
#if !defined (_WIN32_WCE)
  eXosip.j_cond = (struct osip_cond *) osip_cond_init ();
  if (eXosip.j_cond == NULL)
    {
      osip_free (eXosip.user_agent);
      eXosip.user_agent = NULL;
      return OSIP_NOMEM;
    }
#endif

  eXosip.j_mutexlock = (struct osip_mutex *) osip_mutex_init ();
  if (eXosip.j_mutexlock == NULL)
    {
      osip_free (eXosip.user_agent);
      eXosip.user_agent = NULL;
#if !defined (_WIN32_WCE)
      osip_cond_destroy ((struct osip_cond *) eXosip.j_cond);
      eXosip.j_cond = NULL;
#endif
      return OSIP_NOMEM;
    }
#endif

  i = osip_init (&osip);
  if (i != 0)
    {
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_ERROR, NULL,
                   "eXosip: Cannot initialize osip!\n"));
      return i;
    }

  osip_set_application_context (osip, &eXosip);

  eXosip_set_callbacks (osip);

  eXosip.j_osip = osip;

#ifdef OSIP_MT
  /* open a TCP socket to wake up the application when needed. */
  eXosip.j_socketctl = jpipe ();
  if (eXosip.j_socketctl == NULL)
    return OSIP_UNDEFINED_ERROR;