pjsip_resolver.c File Reference

#include "asterisk.h"
#include <pjsip.h>
#include <pjlib-util/errno.h>
#include <arpa/nameser.h>
#include "asterisk/astobj2.h"
#include "asterisk/dns_core.h"
#include "asterisk/dns_query_set.h"
#include "asterisk/dns_srv.h"
#include "asterisk/dns_naptr.h"
#include "asterisk/res_pjsip.h"
#include "include/res_pjsip_private.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/threadpool.h"

Include dependency graph for pjsip_resolver.c:

Go to the source code of this file.

Data Structures
struct	sip_resolve
	Structure which keeps track of resolution. More...
struct	sip_target
	Structure which contains transport+port information for an active query. More...

Enumerations
enum	sip_resolver_transport {   SIP_RESOLVER_TRANSPORT_UDP, SIP_RESOLVER_TRANSPORT_TCP, SIP_RESOLVER_TRANSPORT_TLS, SIP_RESOLVER_TRANSPORT_UDP6,   SIP_RESOLVER_TRANSPORT_TCP6, SIP_RESOLVER_TRANSPORT_TLS6 }
	Our own defined transports, reduces the size of sip_available_transports. More...

Functions
void	ast_sip_initialize_resolver (void)
	AST_VECTOR (targets, struct sip_target)
	The vector used for current targets. More...
static void	sip_check_transport (pj_pool_t *pool, pjsip_transport_type_e transport, const char *name)
static int	sip_replace_resolver (void *data)
static void	sip_resolve (pjsip_resolver_t *resolver, pj_pool_t *pool, const pjsip_host_info *target, void *token, pjsip_resolver_callback *cb)
static int	sip_resolve_add (struct sip_resolve *resolve, const char *name, int rr_type, int rr_class, pjsip_transport_type_e transport, int port)
static void	sip_resolve_callback (const struct ast_dns_query_set *query_set)
static void	sip_resolve_destroy (void *data)
static int	sip_resolve_get_ip_addr_ver (const pj_str_t *host)
static int	sip_resolve_handle_naptr (struct sip_resolve *resolve, const struct ast_dns_record *record, const char *service, pjsip_transport_type_e transport)
static int	sip_resolve_invoke_user_callback (void *data)
static int	sip_transport_is_available (enum pjsip_transport_type_e transport)

Variables
static pjsip_ext_resolver	ext_resolver
	External resolver implementation for PJSIP. More...
static int	sip_available_transports []
	Available transports on the system. More...

Enumeration Type Documentation

sip_resolver_transport

enum sip_resolver_transport

Our own defined transports, reduces the size of sip_available_transports.

Enumerator
SIP_RESOLVER_TRANSPORT_UDP
SIP_RESOLVER_TRANSPORT_TCP
SIP_RESOLVER_TRANSPORT_TLS
SIP_RESOLVER_TRANSPORT_UDP6
SIP_RESOLVER_TRANSPORT_TCP6
SIP_RESOLVER_TRANSPORT_TLS6

Definition at line 66 of file pjsip_resolver.c.

                            {
   SIP_RESOLVER_TRANSPORT_UDP,
   SIP_RESOLVER_TRANSPORT_TCP,
   SIP_RESOLVER_TRANSPORT_TLS,
   SIP_RESOLVER_TRANSPORT_UDP6,
   SIP_RESOLVER_TRANSPORT_TCP6,
   SIP_RESOLVER_TRANSPORT_TLS6,
};

Function Documentation

ast_sip_initialize_resolver()

void ast_sip_initialize_resolver

(

void

)

Definition at line 708 of file pjsip_resolver.c.

References ast_log, ast_sip_push_task_wait_servant(), LOG_NOTICE, NULL, and sip_replace_resolver().

Referenced by load_module().

{
   /* Replace the existing PJSIP resolver with our own implementation */
   ast_sip_push_task_wait_servant(NULL, sip_replace_resolver, NULL);
}

AST_VECTOR()

AST_VECTOR	(	targets	,
		struct sip_target
	)

The vector used for current targets.

sip_check_transport()

static void sip_check_transport ( pj_pool_t *  pool, pjsip_transport_type_e  transport, const char *  name  )

static

Definition at line 636 of file pjsip_resolver.c.

References ast_sip_get_pjsip_endpoint(), ast_verb, sip_available_transports, SIP_RESOLVER_TRANSPORT_TCP, SIP_RESOLVER_TRANSPORT_TCP6, SIP_RESOLVER_TRANSPORT_TLS, SIP_RESOLVER_TRANSPORT_TLS6, SIP_RESOLVER_TRANSPORT_UDP, SIP_RESOLVER_TRANSPORT_UDP6, and sip_target::transport.

Referenced by sip_replace_resolver().

{
   pjsip_tpmgr_fla2_param prm;
   enum sip_resolver_transport resolver_transport;

   pjsip_tpmgr_fla2_param_default(&prm);
   prm.tp_type = transport;

   if (transport == PJSIP_TRANSPORT_UDP) {
      resolver_transport = SIP_RESOLVER_TRANSPORT_UDP;
   } else if (transport == PJSIP_TRANSPORT_TCP) {
      resolver_transport = SIP_RESOLVER_TRANSPORT_TCP;
   } else if (transport == PJSIP_TRANSPORT_TLS) {
      resolver_transport = SIP_RESOLVER_TRANSPORT_TLS;
   } else if (transport == PJSIP_TRANSPORT_UDP6) {
      resolver_transport = SIP_RESOLVER_TRANSPORT_UDP6;
   } else if (transport == PJSIP_TRANSPORT_TCP6) {
      resolver_transport = SIP_RESOLVER_TRANSPORT_TCP6;
   } else if (transport == PJSIP_TRANSPORT_TLS6) {
      resolver_transport = SIP_RESOLVER_TRANSPORT_TLS6;
   } else {
      ast_verb(2, "'%s' is an unsupported SIP transport\n", name);
      return;
   }

   if (pjsip_tpmgr_find_local_addr2(pjsip_endpt_get_tpmgr(ast_sip_get_pjsip_endpoint()),
      pool, &prm) == PJ_SUCCESS) {
      ast_verb(2, "'%s' is an available SIP transport\n", name);
      sip_available_transports[resolver_transport] = 1;
   } else {
      ast_verb(2, "'%s' is not an available SIP transport, disabling resolver support for it\n",
         name);
   }
}

sip_replace_resolver()

static int sip_replace_resolver ( void *  data )

static

Definition at line 683 of file pjsip_resolver.c.

References ast_sip_get_pjsip_endpoint(), ext_resolver, pool, and sip_check_transport().

Referenced by ast_sip_initialize_resolver().

{
   pj_pool_t *pool;


   pool = pjsip_endpt_create_pool(ast_sip_get_pjsip_endpoint(), "Transport Availability", 256, 256);
   if (!pool) {
      return -1;
   }

   /* Determine what transports are available on the system */
   sip_check_transport(pool, PJSIP_TRANSPORT_UDP, "UDP+IPv4");
   sip_check_transport(pool, PJSIP_TRANSPORT_TCP, "TCP+IPv4");
   sip_check_transport(pool, PJSIP_TRANSPORT_TLS, "TLS+IPv4");
   sip_check_transport(pool, PJSIP_TRANSPORT_UDP6, "UDP+IPv6");
   sip_check_transport(pool, PJSIP_TRANSPORT_TCP6, "TCP+IPv6");
   sip_check_transport(pool, PJSIP_TRANSPORT_TLS6, "TLS+IPv6");

   pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);

   /* Replace the PJSIP resolver with our own implementation */
   pjsip_endpt_set_ext_resolver(ast_sip_get_pjsip_endpoint(), &ext_resolver);
   return 0;
}

sip_resolve()

static void sip_resolve ( pjsip_resolver_t *  resolver, pj_pool_t *  pool, const pjsip_host_info *  target, void *  token, pjsip_resolver_callback *  cb  )

static

Definition at line 468 of file pjsip_resolver.c.

References sip_resolve::addresses, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ao2_ref, ast_copy_pj_str(), ast_debug, ast_dns_query_set_resolve_async(), ast_threadpool_serializer_get_current(), AST_VECTOR_INIT, sip_resolve::callback, host, NULL, sip_resolve::queries, sip_resolve::resolving, sip_resolve::serializer, sip_resolve_add(), sip_resolve_callback(), sip_resolve_destroy(), sip_resolve_get_ip_addr_ver(), sip_transport_is_available(), sip_resolve::token, and type.

{
   int ip_addr_ver;
   pjsip_transport_type_e type = target->type;
   struct sip_resolve *resolve;
   char host[NI_MAXHOST];
   int res = 0;

   ast_copy_pj_str(host, &target->addr.host, sizeof(host));

   ast_debug(2, "Performing SIP DNS resolution of target '%s'\n", host);

   /* If the provided target is already an address don't bother resolving */
   ip_addr_ver = sip_resolve_get_ip_addr_ver(&target->addr.host);

   /* Determine the transport to use if none has been explicitly specified */
   if (type == PJSIP_TRANSPORT_UNSPECIFIED) {
      /* If we've been told to use a secure or reliable transport restrict ourselves to that */
#if PJ_HAS_TCP
      if (target->flag & PJSIP_TRANSPORT_SECURE) {
         type = PJSIP_TRANSPORT_TLS;
      } else if (target->flag & PJSIP_TRANSPORT_RELIABLE) {
         type = PJSIP_TRANSPORT_TCP;
      } else
#endif
      /* According to the RFC otherwise if an explicit IP address OR an explicit port is specified
       * we use UDP
       */
      if (ip_addr_ver || target->addr.port) {
         type = PJSIP_TRANSPORT_UDP;
      }

      if (ip_addr_ver == 6) {
         type = (pjsip_transport_type_e)((int) type | PJSIP_TRANSPORT_IPV6);
      }
   }

   ast_debug(2, "Transport type for target '%s' is '%s'\n", host, pjsip_transport_get_type_desc(type));

   /* If it's already an address call the callback immediately */
   if (ip_addr_ver) {
      pjsip_server_addresses addresses = {
         .entry[0].type = type,
         .count = 1,
      };

      if (ip_addr_ver == 4) {
         addresses.entry[0].addr_len = sizeof(pj_sockaddr_in);
         pj_sockaddr_init(pj_AF_INET(), &addresses.entry[0].addr, NULL, 0);
         pj_inet_aton(&target->addr.host, &addresses.entry[0].addr.ipv4.sin_addr);
      } else {
         addresses.entry[0].addr_len = sizeof(pj_sockaddr_in6);
         pj_sockaddr_init(pj_AF_INET6(), &addresses.entry[0].addr, NULL, 0);
         pj_inet_pton(pj_AF_INET6(), &target->addr.host, &addresses.entry[0].addr.ipv6.sin6_addr);
      }

      pj_sockaddr_set_port(&addresses.entry[0].addr, !target->addr.port ? pjsip_transport_get_default_port_for_type(type) : target->addr.port);

      ast_debug(2, "Target '%s' is an IP address, skipping resolution\n", host);

      cb(PJ_SUCCESS, token, &addresses);

      return;
   }

   resolve = ao2_alloc_options(sizeof(*resolve), sip_resolve_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
   if (!resolve) {
      cb(PJ_ENOMEM, token, NULL);
      return;
   }

   resolve->callback = cb;
   resolve->token = token;

   if (AST_VECTOR_INIT(&resolve->resolving, 4)) {
      ao2_ref(resolve, -1);
      cb(PJ_ENOMEM, token, NULL);
      return;
   }

   ast_debug(2, "[%p] Created resolution tracking for target '%s'\n", resolve, host);

   /* If no port has been specified we can do NAPTR + SRV */
   if (!target->addr.port) {
      char srv[NI_MAXHOST];

      /* When resolving addresses PJSIP can request an explicit transport type. It will explicitly
       * request an IPv6 transport if a message has been tagged to use an explicitly IPv6 transport.
       * For other cases it can be left unspecified OR an explicit non-IPv6 transport can be requested.
       * In the case where a non-IPv6 transport is requested there is no way to differentiate between
       * a transport being requested as part of a SIP URI (sip:test.com;transport=tcp) and a message
       * being tagged with a specific IPv4 transport. In this case we look for both IPv4 and IPv6 addresses.
       * If a message has been tagged with a specific IPv4 transport the IPv6 addresses will simply
       * be discarded. The code below and elsewhere handles the case where we know they requested IPv6
       * explicitly and only looks for IPv6 records.
       */

      res |= sip_resolve_add(resolve, host, T_NAPTR, C_IN, type, 0);

      if (type == PJSIP_TRANSPORT_UNSPECIFIED ||
         (type == PJSIP_TRANSPORT_TLS && sip_transport_is_available(PJSIP_TRANSPORT_TLS)) ||
         (type == PJSIP_TRANSPORT_TLS6 && sip_transport_is_available(PJSIP_TRANSPORT_TLS6))) {
         if (snprintf(srv, sizeof(srv), "_sips._tcp.%s", host) < NI_MAXHOST) {
            res |= sip_resolve_add(resolve, srv, T_SRV, C_IN,
               type == PJSIP_TRANSPORT_UNSPECIFIED ? PJSIP_TRANSPORT_TLS : type, 0);
         }
      }
      if (type == PJSIP_TRANSPORT_UNSPECIFIED ||
         (type == PJSIP_TRANSPORT_TCP && sip_transport_is_available(PJSIP_TRANSPORT_TCP)) ||
         (type == PJSIP_TRANSPORT_TCP6 && sip_transport_is_available(PJSIP_TRANSPORT_TCP6))) {
         if (snprintf(srv, sizeof(srv), "_sip._tcp.%s", host) < NI_MAXHOST) {
            res |= sip_resolve_add(resolve, srv, T_SRV, C_IN,
               type == PJSIP_TRANSPORT_UNSPECIFIED ? PJSIP_TRANSPORT_TCP : type, 0);
         }
      }
      if (type == PJSIP_TRANSPORT_UNSPECIFIED ||
         (type == PJSIP_TRANSPORT_UDP && sip_transport_is_available(PJSIP_TRANSPORT_UDP)) ||
         (type == PJSIP_TRANSPORT_UDP6 && sip_transport_is_available(PJSIP_TRANSPORT_UDP6))) {
         if (snprintf(srv, sizeof(srv), "_sip._udp.%s", host) < NI_MAXHOST) {
            res |= sip_resolve_add(resolve, srv, T_SRV, C_IN,
               type == PJSIP_TRANSPORT_UNSPECIFIED ? PJSIP_TRANSPORT_UDP : type, 0);
         }
      }
   }

   if ((type == PJSIP_TRANSPORT_UNSPECIFIED && sip_transport_is_available(PJSIP_TRANSPORT_UDP6)) ||
      ((type & PJSIP_TRANSPORT_IPV6) && sip_transport_is_available(type))) {
      res |= sip_resolve_add(resolve, host, T_AAAA, C_IN, (type == PJSIP_TRANSPORT_UNSPECIFIED ? PJSIP_TRANSPORT_UDP6 : type), target->addr.port);
   } else if (!(type & PJSIP_TRANSPORT_IPV6) && sip_transport_is_available(type | PJSIP_TRANSPORT_IPV6)) {
      res |= sip_resolve_add(resolve, host, T_AAAA, C_IN, type | PJSIP_TRANSPORT_IPV6, target->addr.port);
   }

   if ((type == PJSIP_TRANSPORT_UNSPECIFIED && sip_transport_is_available(PJSIP_TRANSPORT_UDP)) ||
      (!(type & PJSIP_TRANSPORT_IPV6) && sip_transport_is_available(type))) {
      res |= sip_resolve_add(resolve, host, T_A, C_IN, (type == PJSIP_TRANSPORT_UNSPECIFIED ? PJSIP_TRANSPORT_UDP : type), target->addr.port);
   }

   if (res) {
      ao2_ref(resolve, -1);
      cb(PJ_ENOMEM, token, NULL);
      return;
   }
   if (!resolve->queries) {
      ast_debug(2, "[%p] No resolution queries for target '%s'\n", resolve, host);
      ao2_ref(resolve, -1);
      cb(PJLIB_UTIL_EDNSNOANSWERREC, token, NULL);
      return;
   }

   resolve->serializer = ao2_bump(ast_threadpool_serializer_get_current());

   ast_debug(2, "[%p] Starting initial resolution using parallel queries for target '%s'\n", resolve, host);
   ast_dns_query_set_resolve_async(resolve->queries, sip_resolve_callback, resolve);

   ao2_ref(resolve, -1);
}

sip_resolve_add()

static int sip_resolve_add ( struct sip_resolve *  resolve, const char *  name, int  rr_type, int  rr_class, pjsip_transport_type_e  transport, int  port  )

static

Definition at line 154 of file pjsip_resolver.c.

References ast_debug, ast_dns_query_set_add(), ast_dns_query_set_create(), AST_VECTOR_APPEND, sip_target::port, sip_resolve::queries, sip_resolve::resolving, and sip_target::transport.

Referenced by sip_resolve(), sip_resolve_callback(), and sip_resolve_handle_naptr().

{
   struct sip_target target = {
      .transport = transport,
      .port = port,
   };

   if (!resolve->queries) {
      resolve->queries = ast_dns_query_set_create();
      if (!resolve->queries) {
         return -1;
      }
   }

   if (!port) {
      target.port = pjsip_transport_get_default_port_for_type(transport);
   }

   if (AST_VECTOR_APPEND(&resolve->resolving, target)) {
      return -1;
   }

   ast_debug(2, "[%p] Added target '%s' with record type '%d', transport '%s', and port '%d'\n",
      resolve, name, rr_type, pjsip_transport_get_type_desc(transport), target.port);

   return ast_dns_query_set_add(resolve->queries, name, rr_type, rr_class);
}

sip_resolve_callback()

static void sip_resolve_callback ( const struct ast_dns_query_set *  query_set )

static

Definition at line 268 of file pjsip_resolver.c.

References sip_resolve::addresses, ao2_ref, ast_debug, ast_dns_naptr_get_order(), ast_dns_query_get_name(), ast_dns_query_get_result(), ast_dns_query_get_rr_type(), ast_dns_query_set_get(), ast_dns_query_set_get_data(), ast_dns_query_set_num_queries(), ast_dns_query_set_resolve_async(), ast_dns_record_get_data(), ast_dns_record_get_data_size(), ast_dns_record_get_next(), ast_dns_record_get_rr_type(), ast_dns_result_get_records(), ast_dns_srv_get_host(), ast_dns_srv_get_port(), ast_sip_push_task(), AST_VECTOR_FREE, AST_VECTOR_GET_ADDR, AST_VECTOR_INIT, NULL, order, sip_target::port, sip_resolve::queries, sip_resolve::resolving, result, sip_resolve::serializer, sip_resolve_add(), sip_resolve_handle_naptr(), sip_resolve_invoke_user_callback(), sip_transport_is_available(), and sip_target::transport.

Referenced by sip_resolve().

{
   struct sip_resolve *resolve = ast_dns_query_set_get_data(query_set);
   struct ast_dns_query_set *queries = resolve->queries;
   struct targets resolving;
   int idx, address_count = 0, have_naptr = 0, have_srv = 0;
   unsigned short order = 0;
   int strict_order = 0;

   ast_debug(2, "[%p] All parallel queries completed\n", resolve);

   resolve->queries = NULL;

   /* This purposely steals the resolving list so we can add entries to the new one in
    * the same loop and also have access to the old.
    */
   resolving = resolve->resolving;
   AST_VECTOR_INIT(&resolve->resolving, 0);

   /* The order of queries is what defines the preference order for the records within
    * this specific query set. The preference order overall is defined as a result of
    * drilling down from other records. Each completed query set replaces the results
    * of the last.
    */
   for (idx = 0; idx < ast_dns_query_set_num_queries(queries); ++idx) {
      struct ast_dns_query *query = ast_dns_query_set_get(queries, idx);
      struct ast_dns_result *result = ast_dns_query_get_result(query);
      struct sip_target *target;
      const struct ast_dns_record *record;

      if (!result) {
         ast_debug(2, "[%p] No result information for target '%s' of type '%d'\n", resolve,
            ast_dns_query_get_name(query), ast_dns_query_get_rr_type(query));
         continue;
      }

      target = AST_VECTOR_GET_ADDR(&resolving, idx);
      for (record = ast_dns_result_get_records(result); record; record = ast_dns_record_get_next(record)) {

         if (ast_dns_record_get_rr_type(record) == T_A ||
            ast_dns_record_get_rr_type(record) == T_AAAA) {
            /* If NAPTR or SRV records exist the subsequent results from them take preference */
            if (have_naptr || have_srv) {
               ast_debug(2, "[%p] %s record being skipped on target '%s' because NAPTR or SRV record exists\n",
                  resolve, ast_dns_record_get_rr_type(record) == T_A ? "A" : "AAAA",
                  ast_dns_query_get_name(query));
               continue;
            }

            /* PJSIP has a fixed maximum number of addresses that can exist, so limit ourselves to that */
            if (address_count == PJSIP_MAX_RESOLVED_ADDRESSES) {
               break;
            }

            resolve->addresses.entry[address_count].type = target->transport;

            /* Populate address information for the new address entry */
            if (ast_dns_record_get_rr_type(record) == T_A) {
               ast_debug(2, "[%p] A record received on target '%s'\n", resolve, ast_dns_query_get_name(query));
               resolve->addresses.entry[address_count].addr_len = sizeof(pj_sockaddr_in);
               pj_sockaddr_init(pj_AF_INET(), &resolve->addresses.entry[address_count].addr, NULL,
                  target->port);
               resolve->addresses.entry[address_count].addr.ipv4.sin_addr = *(pj_in_addr *) ast_dns_record_get_data(record);
            } else {
               ast_debug(2, "[%p] AAAA record received on target '%s'\n", resolve, ast_dns_query_get_name(query));
               resolve->addresses.entry[address_count].addr_len = sizeof(pj_sockaddr_in6);
               pj_sockaddr_init(pj_AF_INET6(), &resolve->addresses.entry[address_count].addr, NULL,
                  target->port);
               pj_memcpy(&resolve->addresses.entry[address_count].addr.ipv6.sin6_addr, ast_dns_record_get_data(record),
                  ast_dns_record_get_data_size(record));
            }

            address_count++;
         } else if (ast_dns_record_get_rr_type(record) == T_SRV) {
            if (have_naptr) {
               ast_debug(2, "[%p] SRV record being skipped on target '%s' because NAPTR record exists\n",
                  resolve, ast_dns_query_get_name(query));
               continue;
            }

            /* SRV records just create new queries for AAAA+A, nothing fancy */
            ast_debug(2, "[%p] SRV record received on target '%s'\n", resolve, ast_dns_query_get_name(query));

            /* If an explicit IPv6 target transport has been requested look for only AAAA records */
            if ((target->transport & PJSIP_TRANSPORT_IPV6) &&
               sip_transport_is_available(target->transport)) {
               sip_resolve_add(resolve, ast_dns_srv_get_host(record), T_AAAA, C_IN, target->transport,
                  ast_dns_srv_get_port(record));
               have_srv = 1;
            } else if (!(target->transport & PJSIP_TRANSPORT_IPV6) &&
               sip_transport_is_available(target->transport | PJSIP_TRANSPORT_IPV6)) {
               sip_resolve_add(resolve, ast_dns_srv_get_host(record), T_AAAA, C_IN, target->transport | PJSIP_TRANSPORT_IPV6,
                  ast_dns_srv_get_port(record));
               have_srv = 1;
            }

            if (!(target->transport & PJSIP_TRANSPORT_IPV6) &&
               sip_transport_is_available(target->transport)) {
               sip_resolve_add(resolve, ast_dns_srv_get_host(record), T_A, C_IN, target->transport,
                  ast_dns_srv_get_port(record));
               have_srv = 1;
            }
         } else if (ast_dns_record_get_rr_type(record) == T_NAPTR) {
            int added = -1;

            ast_debug(2, "[%p] NAPTR record received on target '%s'\n", resolve, ast_dns_query_get_name(query));

            if (strict_order && (ast_dns_naptr_get_order(record) != order)) {
               ast_debug(2, "[%p] NAPTR record skipped because order '%hu' does not match strict order '%hu'\n",
                  resolve, ast_dns_naptr_get_order(record), order);
               continue;
            }

            if (target->transport == PJSIP_TRANSPORT_UNSPECIFIED || target->transport == PJSIP_TRANSPORT_UDP ||
               target->transport == PJSIP_TRANSPORT_UDP6) {
               added = sip_resolve_handle_naptr(resolve, record, "sip+d2u",
                  target->transport == PJSIP_TRANSPORT_UNSPECIFIED ? PJSIP_TRANSPORT_UDP : target->transport);
            }
            if (target->transport == PJSIP_TRANSPORT_UNSPECIFIED || target->transport == PJSIP_TRANSPORT_TCP ||
               target->transport == PJSIP_TRANSPORT_TCP6) {
               added = sip_resolve_handle_naptr(resolve, record, "sip+d2t",
                  target->transport == PJSIP_TRANSPORT_UNSPECIFIED ? PJSIP_TRANSPORT_TCP : target->transport);
            }
            if (target->transport == PJSIP_TRANSPORT_UNSPECIFIED || target->transport == PJSIP_TRANSPORT_TLS ||
               target->transport == PJSIP_TRANSPORT_TLS6) {
               added = sip_resolve_handle_naptr(resolve, record, "sips+d2t",
                  target->transport == PJSIP_TRANSPORT_UNSPECIFIED ? PJSIP_TRANSPORT_TLS : target->transport);
            }

            /* If this record was successfully handled then we need to limit ourselves to this order */
            if (!added) {
               have_naptr = 1;
               strict_order = 1;
               order = ast_dns_naptr_get_order(record);
            }
         }
      }
   }

   /* Update the server addresses count, this is not limited as it can never exceed the max allowed */
   resolve->addresses.count = address_count;

   /* Free the vector we stole as we are responsible for it */
   AST_VECTOR_FREE(&resolving);

   /* If additional queries were added start the resolution process again */
   if (resolve->queries) {
      ast_debug(2, "[%p] New queries added, performing parallel resolution again\n", resolve);
      ast_dns_query_set_resolve_async(resolve->queries, sip_resolve_callback, resolve);
      ao2_ref(queries, -1);
      return;
   }

   ast_debug(2, "[%p] Resolution completed - %d viable targets\n", resolve, resolve->addresses.count);

   /* Push a task to invoke the callback, we do this so it is guaranteed to run in a PJSIP thread */
   ao2_ref(resolve, +1);
   if (ast_sip_push_task(resolve->serializer, sip_resolve_invoke_user_callback, resolve)) {
      ao2_ref(resolve, -1);
   }

   ao2_ref(queries, -1);
}

sip_resolve_destroy()

static void sip_resolve_destroy ( void *  data )

static

Definition at line 98 of file pjsip_resolver.c.

References ao2_cleanup, ast_taskprocessor_unreference(), AST_VECTOR_FREE, sip_resolve::queries, sip_resolve::resolving, and sip_resolve::serializer.

Referenced by sip_resolve().

{
   struct sip_resolve *resolve = data;

   AST_VECTOR_FREE(&resolve->resolving);
   ao2_cleanup(resolve->queries);
   ast_taskprocessor_unreference(resolve->serializer);
}

sip_resolve_get_ip_addr_ver()

static int sip_resolve_get_ip_addr_ver ( const pj_str_t *  host )

static

Definition at line 442 of file pjsip_resolver.c.

References dummy().

Referenced by sip_resolve().

{
   pj_in_addr dummy;
   pj_in6_addr dummy6;

   if (pj_inet_aton(host, &dummy) > 0) {
      return 4;
   }

   if (pj_inet_pton(pj_AF_INET6(), host, &dummy6) == PJ_SUCCESS) {
      return 6;
   }

   return 0;
}

sip_resolve_handle_naptr()

static int sip_resolve_handle_naptr ( struct sip_resolve *  resolve, const struct ast_dns_record *  record, const char *  service, pjsip_transport_type_e  transport  )

static

Definition at line 227 of file pjsip_resolver.c.

References ast_debug, ast_dns_naptr_get_flags(), ast_dns_naptr_get_replacement(), ast_dns_naptr_get_service(), ast_strlen_zero, sip_resolve_add(), and sip_transport_is_available().

Referenced by sip_resolve_callback().

{
   if (strcasecmp(ast_dns_naptr_get_service(record), service)) {
      return -1;
   }

   /* It is possible for us to receive an explicit transport that is already IPv6, in that case
    * we can't turn it into an IPv6 transport and check. If it's not IPv6 though we need to check
    * for both IPv4 and IPv6 as PJSIP does not provide enough differentiation to know that we
    * want only IPv4.
    */
   if (!sip_transport_is_available(transport) &&
      (!(transport & PJSIP_TRANSPORT_IPV6) && !sip_transport_is_available(transport | PJSIP_TRANSPORT_IPV6))) {
      ast_debug(2, "[%p] NAPTR service %s skipped as transport is unavailable\n",
         resolve, service);
      return -1;
   }

   if (strcasecmp(ast_dns_naptr_get_flags(record), "s")) {
      ast_debug(2, "[%p] NAPTR service %s received with unsupported flags '%s'\n",
         resolve, service, ast_dns_naptr_get_flags(record));
      return -1;
   }

   if (ast_strlen_zero(ast_dns_naptr_get_replacement(record))) {
      return -1;
   }

   return sip_resolve_add(resolve, ast_dns_naptr_get_replacement(record), T_SRV, C_IN,
      transport, 0);
}

sip_resolve_invoke_user_callback()

static int sip_resolve_invoke_user_callback ( void *  data )

static

Definition at line 190 of file pjsip_resolver.c.

References sip_resolve::addresses, ao2_ref, ast_debug, ast_log, sip_resolve::callback, DEBUG_ATLEAST, LOG_DEBUG, and sip_resolve::token.

Referenced by sip_resolve_callback().

{
   struct sip_resolve *resolve = data;

   if (DEBUG_ATLEAST(2)) {
      /* This includes space for the IP address, [, ], :, and the port */
      char addr[PJ_INET6_ADDRSTRLEN + 10];
      int idx;

      for (idx = 0; idx < resolve->addresses.count; ++idx) {
         pj_sockaddr_print(&resolve->addresses.entry[idx].addr, addr, sizeof(addr), 3);
         ast_log(LOG_DEBUG, "[%p] Address '%d' is %s with transport '%s'\n",
            resolve, idx, addr,
            pjsip_transport_get_type_desc(resolve->addresses.entry[idx].type));
      }
   }

   ast_debug(2, "[%p] Invoking user callback with '%d' addresses\n", resolve, resolve->addresses.count);
   resolve->callback(resolve->addresses.count ? PJ_SUCCESS : PJLIB_UTIL_EDNSNOANSWERREC, resolve->token, &resolve->addresses);

   ao2_ref(resolve, -1);

   return 0;
}

sip_transport_is_available()

static int sip_transport_is_available ( enum pjsip_transport_type_e  transport )

static

Definition at line 116 of file pjsip_resolver.c.

References sip_available_transports, SIP_RESOLVER_TRANSPORT_TCP, SIP_RESOLVER_TRANSPORT_TCP6, SIP_RESOLVER_TRANSPORT_TLS, SIP_RESOLVER_TRANSPORT_TLS6, SIP_RESOLVER_TRANSPORT_UDP, and SIP_RESOLVER_TRANSPORT_UDP6.

Referenced by sip_resolve(), sip_resolve_callback(), and sip_resolve_handle_naptr().

{
   enum sip_resolver_transport resolver_transport;

   if (transport == PJSIP_TRANSPORT_UDP) {
      resolver_transport = SIP_RESOLVER_TRANSPORT_UDP;
   } else if (transport == PJSIP_TRANSPORT_TCP) {
      resolver_transport = SIP_RESOLVER_TRANSPORT_TCP;
   } else if (transport == PJSIP_TRANSPORT_TLS) {
      resolver_transport = SIP_RESOLVER_TRANSPORT_TLS;
   } else if (transport == PJSIP_TRANSPORT_UDP6) {
      resolver_transport = SIP_RESOLVER_TRANSPORT_UDP6;
   } else if (transport == PJSIP_TRANSPORT_TCP6) {
      resolver_transport = SIP_RESOLVER_TRANSPORT_TCP6;
   } else if (transport == PJSIP_TRANSPORT_TLS6) {
      resolver_transport = SIP_RESOLVER_TRANSPORT_TLS6;
   } else {
      return 0;
   }

   return sip_available_transports[resolver_transport];
}

Variable Documentation

ext_resolver

pjsip_ext_resolver ext_resolver

static

Initial value:

= {
   .resolve = sip_resolve,
}

External resolver implementation for PJSIP.

Definition at line 672 of file pjsip_resolver.c.

Referenced by sip_replace_resolver().

sip_available_transports

int sip_available_transports[]

static

Available transports on the system.

Definition at line 76 of file pjsip_resolver.c.

Referenced by sip_check_transport(), and sip_transport_is_available().