exconf.c

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

  eXosip.j_socketctl_event = jpipe ();
  if (eXosip.j_socketctl_event == NULL)
    return OSIP_UNDEFINED_ERROR;
#endif

  /* To be changed in osip! */
  eXosip.j_events = (osip_fifo_t *) osip_malloc (sizeof (osip_fifo_t));
  if (eXosip.j_events == NULL)
    return OSIP_NOMEM;
  osip_fifo_init (eXosip.j_events);

  eXosip.use_rport = 1;
  eXosip.use_naptr = 1;
  eXosip.keep_alive = 17000;

  eXtl_udp.tl_init ();
  eXtl_tcp.tl_init ();
#ifdef HAVE_OPENSSL_SSL_H
#if !(OPENSSL_VERSION_NUMBER < 0x00908000L)
  eXtl_dtls.tl_init ();
#endif
  eXtl_tls.tl_init ();
#endif
  return OSIP_SUCCESS;
}


int
eXosip_execute (void)
{
  struct timeval lower_tv;
  int i;

#ifdef OSIP_MT
  osip_timers_gettimeout (eXosip.j_osip, &lower_tv);
  if (lower_tv.tv_sec > 10)
    {
      lower_tv.tv_sec = 10;
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_INFO2, NULL,
                   "eXosip: Reseting timer to 10s before waking up!\n"));
  } else
    {
      /*  add a small amount of time on windows to avoid
         waking up too early. (probably a bad time precision) */
      if (lower_tv.tv_usec < 900000)
        lower_tv.tv_usec = 100000;      /* add 10ms */
      else
        {
          lower_tv.tv_usec = 10000;     /* add 10ms */
          lower_tv.tv_sec++;
        }
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_INFO2, NULL,
                   "eXosip: timer sec:%i usec:%i!\n",
                   lower_tv.tv_sec, lower_tv.tv_usec));
    }
#else
  lower_tv.tv_sec = 0;
  lower_tv.tv_usec = 0;
#endif
  i = eXosip_read_message (1, lower_tv.tv_sec, lower_tv.tv_usec);

  if (i == -2000)
    {
      return -2000;
    }

  eXosip_lock ();
  osip_timers_ict_execute (eXosip.j_osip);
  osip_timers_nict_execute (eXosip.j_osip);
  osip_timers_ist_execute (eXosip.j_osip);
  osip_timers_nist_execute (eXosip.j_osip);

  osip_nist_execute (eXosip.j_osip);
  osip_nict_execute (eXosip.j_osip);
  osip_ist_execute (eXosip.j_osip);
  osip_ict_execute (eXosip.j_osip);

  /* free all Calls that are in the TERMINATED STATE? */
  eXosip_release_terminated_calls ();
  eXosip_release_terminated_registrations ();
  eXosip_release_terminated_publications ();
#ifndef MINISIZE
  eXosip_release_terminated_subscriptions ();
  eXosip_release_terminated_in_subscriptions ();
#endif

  eXosip_unlock ();


  if (eXosip.keep_alive > 0)
    {
      _eXosip_keep_alive ();
    }

  return OSIP_SUCCESS;
}

int
eXosip_set_option (eXosip_option opt, const void *value)
{
  int val;
  char *tmp;

  switch (opt)
    {
      case EXOSIP_OPT_ADD_ACCOUNT_INFO:
        {
          struct eXosip_account_info *ainfo;
          int i;
          ainfo = (struct eXosip_account_info *) value;
          if (ainfo == NULL || ainfo->proxy[0] == '\0')
            {
              return OSIP_BADPARAMETER;
            }
          for (i = 0; i < MAX_EXOSIP_ACCOUNT_INFO; i++)
            {
              if (eXosip.account_entries[i].proxy[0] != '\0'
                  && 0 == osip_strcasecmp (eXosip.account_entries[i].proxy,
                                           ainfo->proxy))
                {
                  /* update ainfo */
                  if (ainfo->nat_ip[0] != '\0')
                    {
                      snprintf (eXosip.account_entries[i].nat_ip,
                                sizeof (eXosip.account_entries[i].nat_ip), "%s",
                                ainfo->nat_ip);
                      eXosip.account_entries[i].nat_port = ainfo->nat_port;
                      OSIP_TRACE (osip_trace
                                  (__FILE__, __LINE__, OSIP_INFO1, NULL,
                                   "eXosip option set: account info updated:%s -> %s:%i\n",
                                   ainfo->proxy, ainfo->nat_ip, ainfo->nat_port));
                  } else
                    {
                      eXosip.account_entries[i].proxy[0] = '\0';
                      OSIP_TRACE (osip_trace
                                  (__FILE__, __LINE__, OSIP_INFO2, NULL,
                                   "eXosip option set: account info deleted :%s\n",
                                   ainfo->proxy));
                    }
                  return OSIP_SUCCESS;
                }
            }
          if (ainfo->nat_ip[0] == '\0')
            {
              return OSIP_BADPARAMETER;
            }
          /* not found case: */
          for (i = 0; i < MAX_EXOSIP_ACCOUNT_INFO; i++)
            {
              if (eXosip.account_entries[i].proxy[0] == '\0')
                {
                  /* add ainfo */
                  snprintf (eXosip.account_entries[i].proxy, sizeof (ainfo->proxy),
                            "%s", ainfo->proxy);
                  snprintf (eXosip.account_entries[i].nat_ip,
                            sizeof (ainfo->nat_ip), "%s", ainfo->nat_ip);
                  eXosip.account_entries[i].nat_port = ainfo->nat_port;
                  OSIP_TRACE (osip_trace
                              (__FILE__, __LINE__, OSIP_INFO1, NULL,
                               "eXosip option set: account info added:%s -> %s:%i\n",
                               ainfo->proxy, ainfo->nat_ip, ainfo->nat_port));
                  return OSIP_SUCCESS;
                }
            }
          return OSIP_UNDEFINED_ERROR;
        }
        break;
      case EXOSIP_OPT_ADD_DNS_CACHE:
        {
          struct eXosip_dns_cache *entry;
          int i;
          entry = (struct eXosip_dns_cache *) value;
          if (entry == NULL || entry->host[0] == '\0')
            {
              return OSIP_BADPARAMETER;
            }
          for (i = 0; i < MAX_EXOSIP_DNS_ENTRY; i++)
            {
              if (eXosip.dns_entries[i].host[0] != '\0'
                  && 0 == osip_strcasecmp (eXosip.dns_entries[i].host,
                                           entry->host))
                {
                  /* update entry */
                  if (entry->ip[0] != '\0')
                    {
                      snprintf (eXosip.dns_entries[i].ip,
                                sizeof (eXosip.dns_entries[i].ip), "%s",
                                entry->ip);
                      OSIP_TRACE (osip_trace
                                  (__FILE__, __LINE__, OSIP_INFO1, NULL,
                                   "eXosip option set: dns cache updated:%s -> %s\n",
                                   entry->host, entry->ip));
                  } else
                    {
                      eXosip.dns_entries[i].host[0] = '\0';
                      OSIP_TRACE (osip_trace
                                  (__FILE__, __LINE__, OSIP_INFO2, NULL,
                                   "eXosip option set: dns cache deleted :%s\n",
                                   entry->host));
                    }
                  return OSIP_SUCCESS;
                }
            }
          if (entry->ip[0] == '\0')
            {
              return OSIP_BADPARAMETER;
            }
          /* not found case: */
          for (i = 0; i < MAX_EXOSIP_DNS_ENTRY; i++)
            {
              if (eXosip.dns_entries[i].host[0] == '\0')
                {
                  /* add entry */
                  snprintf (eXosip.dns_entries[i].host, sizeof (entry->host), "%s",
                            entry->host);
                  snprintf (eXosip.dns_entries[i].ip, sizeof (entry->ip), "%s",
                            entry->ip);
                  OSIP_TRACE (osip_trace
                              (__FILE__, __LINE__, OSIP_INFO2, NULL,
                               "eXosip option set: dns cache added:%s -> %s\n",
                               entry->host, entry->ip));
                  return OSIP_SUCCESS;
                }
            }
          return OSIP_UNDEFINED_ERROR;
        }
        break;
      case EXOSIP_OPT_UDP_KEEP_ALIVE:
        val = *((int *) value);
        eXosip.keep_alive = val;        /* value in ms */
        break;
      case EXOSIP_OPT_UDP_LEARN_PORT:
        val = *((int *) value);
        eXosip.learn_port = val;        /* 1 to learn port */
        break;
#ifndef MINISIZE
      case EXOSIP_OPT_SET_HTTP_TUNNEL_PORT:
        val = *((int *) value);
        eXosip.http_port = val; /* value in ms */
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_INFO1, NULL,
                     "eXosip option set: http_port:%i!\n", eXosip.http_port));
        break;
      case EXOSIP_OPT_SET_HTTP_TUNNEL_PROXY:
        tmp = (char *) value;
        memset (eXosip.http_proxy, '\0', sizeof (eXosip.http_proxy));
        if (tmp != NULL && tmp[0] != '\0')
          strncpy (eXosip.http_proxy, tmp, sizeof (eXosip.http_proxy)); /* value in proxy:port */
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_INFO1, NULL,
                     "eXosip option set: http_proxy:%s!\n", eXosip.http_proxy));
        break;
      case EXOSIP_OPT_SET_HTTP_OUTBOUND_PROXY:
        tmp = (char *) value;
        memset (eXosip.http_outbound_proxy, '\0',
                sizeof (eXosip.http_outbound_proxy));
        if (tmp != NULL && tmp[0] != '\0')
          strncpy (eXosip.http_outbound_proxy, tmp, sizeof (eXosip.http_outbound_proxy));       /* value in proxy:port */
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_INFO1, NULL,
                     "eXosip option set: http_outbound_proxy:%s!\n",
                     eXosip.http_outbound_proxy));
        break;

      case EXOSIP_OPT_DONT_SEND_101:
        val = *((int *) value);
        eXosip.dontsend_101 = val;      /* 0 to disable */
        break;
#endif

      case EXOSIP_OPT_USE_RPORT:
        val = *((int *) value);
        eXosip.use_rport = val; /* 0 to disable (for broken NAT only?) */
        break;

      case EXOSIP_OPT_SET_IPV4_FOR_GATEWAY:
        tmp = (char *) value;
        memset (eXosip.ipv4_for_gateway, '\0', sizeof (eXosip.ipv4_for_gateway));
        if (tmp != NULL && tmp[0] != '\0')
          strncpy (eXosip.ipv4_for_gateway, tmp, sizeof (eXosip.ipv4_for_gateway));
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_INFO1, NULL,
                     "eXosip option set: ipv4_for_gateway:%s!\n",
                     eXosip.ipv4_for_gateway));
        break;
#ifndef MINISIZE
      case EXOSIP_OPT_SET_IPV6_FOR_GATEWAY:
        tmp = (char *) value;
        memset (eXosip.ipv6_for_gateway, '\0', sizeof (eXosip.ipv6_for_gateway));
        if (tmp != NULL && tmp[0] != '\0')
          strncpy (eXosip.ipv6_for_gateway, tmp, sizeof (eXosip.ipv6_for_gateway));
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_INFO1, NULL,
                     "eXosip option set: ipv6_for_gateway:%s!\n",
                     eXosip.ipv6_for_gateway));
        break;
      case EXOSIP_OPT_EVENT_PACKAGE:
        tmp = (char *) value;
        memset (eXosip.event_package, '\0', sizeof (eXosip.event_package));
        if (tmp != NULL && tmp[0] != '\0')
          strncpy (eXosip.event_package, tmp, sizeof (eXosip.event_package));
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_INFO1, NULL,
                     "eXosip option set: event_package:%s!\n",
                     eXosip.event_package));
        break;
#endif
      case EXOSIP_OPT_SRV_WITH_NAPTR:
        val = *((int *) value);
        eXosip.use_naptr=val;
        break;
      default:
        return OSIP_BADPARAMETER;
    }
  return OSIP_SUCCESS;
}

static void
_eXosip_keep_alive (void)
{
  static struct timeval mtimer = { 0, 0 };

  struct timeval now;

  osip_gettimeofday (&now, NULL);

  if (mtimer.tv_sec == 0 && mtimer.tv_usec == 0)
    {
      /* first init */
      osip_gettimeofday (&mtimer, NULL);
      add_gettimeofday (&mtimer, eXosip.keep_alive);
    }

  if (osip_timercmp (&now, &mtimer, <))
    {
      return;                   /* not yet time */
    }

  OSIP_TRACE (osip_trace
              (__FILE__, __LINE__, OSIP_WARNING, NULL,
               "keep alive: %i\n", now.tv_sec - mtimer.tv_sec));

  /* reset timer */
  osip_gettimeofday (&mtimer, NULL);
  add_gettimeofday (&mtimer, eXosip.keep_alive);

  eXtl_udp.tl_keepalive ();
}

#ifdef OSIP_MT
void *
_eXosip_thread (void *arg)
{
  int i;

  while (eXosip.j_stop_ua == 0)
    {
      i = eXosip_execute ();
      if (i == -2000)
        osip_thread_exit ();
    }
  osip_thread_exit ();
  return NULL;
}

#endif