res_pjsip_registrar.c File Reference

#include "asterisk.h"
#include <signal.h>
#include <pjsip.h>
#include <pjsip_ua.h>
#include "asterisk/res_pjsip.h"
#include "asterisk/module.h"
#include "asterisk/paths.h"
#include "asterisk/test.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/manager.h"
#include "asterisk/named_locks.h"
#include "asterisk/res_pjproject.h"
#include "res_pjsip/include/res_pjsip_private.h"

Include dependency graph for res_pjsip_registrar.c:

Go to the source code of this file.

Data Structures
struct	aor_core_response
struct	contact_transport_monitor
struct	registrar_contact_details
	Structure used for finding contact. More...

Macros
#define	AMI_SHOW_REGISTRATION_CONTACT_STATUSES   "PJSIPShowRegistrationInboundContactStatuses"
#define	AMI_SHOW_REGISTRATIONS   "PJSIPShowRegistrationsInbound"

Enumerations
enum	contact_delete_type {   CONTACT_DELETE_ERROR, CONTACT_DELETE_EXISTING, CONTACT_DELETE_EXPIRE, CONTACT_DELETE_REQUEST,   CONTACT_DELETE_SHUTDOWN }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static int	ami_registrations_aor (void *obj, void *arg, int flags)
static int	ami_registrations_endpoint (void *obj, void *arg, int flags)
static int	ami_registrations_endpoints (void *arg)
static int	ami_show_registration_contact_statuses (struct mansession *s, const struct message *m)
static int	ami_show_registrations (struct mansession *s, const struct message *m)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_VECTOR (excess_contact_vector, struct ast_sip_contact *)
static int	build_path_data (pjsip_rx_data *rdata, struct ast_str **path_str)
static void *	check_expiration_thread (void *data)
static int	contact_transport_monitor_matcher (void *a, void *b)
static void	expiration_global_loaded (const char *object_type)
static int	expire_contact (void *obj, void *arg, int flags)
	Callback function which deletes a contact. More...
static char *	find_aor_name (const pj_str_t *pj_username, const pj_str_t *pj_domain, const char *aors)
static struct ast_sip_aor *	find_registrar_aor (struct pjsip_rx_data *rdata, struct ast_sip_endpoint *endpoint)
static int	load_module (void)
static int	match_aor (const char *aor_name, const char *id)
static int	register_aor (pjsip_rx_data *rdata, struct ast_sip_endpoint *endpoint, struct ast_sip_aor *aor, const char *aor_name)
static void	register_aor_core (pjsip_rx_data *rdata, struct ast_sip_endpoint *endpoint, struct ast_sip_aor *aor, const char *aor_name, struct ao2_container *contacts, struct aor_core_response *response)
static int	register_contact_transport_remove_cb (void *data)
static void	register_contact_transport_shutdown_cb (void *data)
static int	registrar_add_contact (void *obj, void *arg, int flags)
	Internal function which adds a contact to a response. More...
static int	registrar_add_non_permanent (void *obj, void *arg, int flags)
	Callback function which adds non-permanent contacts to a container. More...
static int	registrar_contact_delete (enum contact_delete_type type, pjsip_transport *transport, struct ast_sip_contact *contact, const char *aor_name)
static int	registrar_delete_contact (void *obj, void *arg, int flags)
	Internal function used to delete a contact from an AOR. More...
static int	registrar_find_contact (void *obj, void *arg, int flags)
	Callback function for finding a contact. More...
static unsigned int	registrar_get_expiration (const struct ast_sip_aor *aor, const pjsip_contact_hdr *contact, const pjsip_rx_data *rdata)
	Internal function which returns the expiration time for a contact. More...
static pj_bool_t	registrar_on_rx_request (struct pjsip_rx_data *rdata)
static int	registrar_validate_contacts (const pjsip_rx_data *rdata, pj_pool_t *pool, struct ao2_container *contacts, struct ast_sip_aor *aor, int permanent, int *added, int *updated, int *deleted)
	Internal function which validates provided Contact headers to confirm that they are acceptable, and returns number of contacts. More...
static int	registrar_validate_path (pjsip_rx_data *rdata, struct ast_sip_aor *aor, struct ast_str **path_str)
static void	remove_excess_contacts (struct ao2_container *contacts, struct ao2_container *response_contacts, unsigned int to_remove)
static int	sip_contact_to_str (void *acp, void *arg, int flags)
static int	unload_module (void)
static int	vec_contact_add (void *obj, void *arg, int flags)
static int	vec_contact_cmp (struct ast_sip_contact *left, struct ast_sip_contact *right)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP Registrar Support" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_CHANNEL_DEPEND - 3, .requires = "res_pjproject,res_pjsip", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static unsigned int	check_interval
	The global interval at which to check for contact expiration. More...
static pthread_t	check_thread = AST_PTHREADT_NULL
	Thread keeping things alive. More...
static struct ast_sorcery_observer	expiration_global_observer
	Observer which is used to update our interval when the global setting changes. More...
static const pj_str_t	path_hdr_name = { "Path", 4 }
static int	pj_max_hostname = PJ_MAX_HOSTNAME
static int	pjsip_max_url_size = PJSIP_MAX_URL_SIZE
static pjsip_module	registrar_module

Macro Definition Documentation

AMI_SHOW_REGISTRATION_CONTACT_STATUSES

#define AMI_SHOW_REGISTRATION_CONTACT_STATUSES   "PJSIPShowRegistrationInboundContactStatuses"

Definition at line 1225 of file res_pjsip_registrar.c.

Referenced by load_module(), and unload_module().

AMI_SHOW_REGISTRATIONS

#define AMI_SHOW_REGISTRATIONS   "PJSIPShowRegistrationsInbound"

Definition at line 1226 of file res_pjsip_registrar.c.

Referenced by load_module(), and unload_module().

Enumeration Type Documentation

contact_delete_type

enum contact_delete_type

Enumerator
CONTACT_DELETE_ERROR
CONTACT_DELETE_EXISTING
CONTACT_DELETE_EXPIRE
CONTACT_DELETE_REQUEST
CONTACT_DELETE_SHUTDOWN

Definition at line 204 of file res_pjsip_registrar.c.

                         {
   CONTACT_DELETE_ERROR,
   CONTACT_DELETE_EXISTING,
   CONTACT_DELETE_EXPIRE,
   CONTACT_DELETE_REQUEST,
   CONTACT_DELETE_SHUTDOWN,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1375 of file res_pjsip_registrar.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1375 of file res_pjsip_registrar.c.

ami_registrations_aor()

static int ami_registrations_aor ( void *  obj, void *  arg, int  flags  )

static

Definition at line 1133 of file res_pjsip_registrar.c.

References ast_sip_ami::arg, ast_free, ast_sip_create_ami_event(), ast_sip_for_each_contact(), ast_sip_sorcery_object_to_ami(), ast_str_append(), ast_str_buffer(), astman_append(), buf, ast_sip_ami::count, RAII_VAR, ast_sip_ami::s, and sip_contact_to_str().

Referenced by ami_registrations_endpoint().

{
   struct ast_sip_aor *aor = obj;
   struct ast_sip_ami *ami = arg;
   int *count = ami->arg;
   RAII_VAR(struct ast_str *, buf,
       ast_sip_create_ami_event("InboundRegistrationDetail", ami), ast_free);

   if (!buf) {
      return -1;
   }

   ast_sip_sorcery_object_to_ami(aor, &buf);
   ast_str_append(&buf, 0, "Contacts: ");
   ast_sip_for_each_contact(aor, sip_contact_to_str, &buf);
   ast_str_append(&buf, 0, "\r\n");

   astman_append(ami->s, "%s\r\n", ast_str_buffer(buf));
   (*count)++;
   return 0;
}

ami_registrations_endpoint()

static int ami_registrations_endpoint ( void *  obj, void *  arg, int  flags  )

static

Definition at line 1155 of file res_pjsip_registrar.c.

References ami_registrations_aor(), ast_sip_endpoint::aors, and ast_sip_for_each_aor().

Referenced by ami_registrations_endpoints().

{
   struct ast_sip_endpoint *endpoint = obj;
   return ast_sip_for_each_aor(
      endpoint->aors, ami_registrations_aor, arg);
}

ami_registrations_endpoints()

static int ami_registrations_endpoints ( void *  arg )

static

Definition at line 1162 of file res_pjsip_registrar.c.

References ami_registrations_endpoint(), ao2_callback, ao2_cleanup, ast_sip_get_endpoints(), endpoints, OBJ_NODATA, and RAII_VAR.

Referenced by ami_show_registrations().

{
   RAII_VAR(struct ao2_container *, endpoints,
       ast_sip_get_endpoints(), ao2_cleanup);

   if (!endpoints) {
      return 0;
   }

   ao2_callback(endpoints, OBJ_NODATA, ami_registrations_endpoint, arg);
   return 0;
}

ami_show_registration_contact_statuses()

static int ami_show_registration_contact_statuses ( struct mansession *  s, const struct message *  m  )

static

Definition at line 1190 of file res_pjsip_registrar.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_sip_contact::aor, ast_sip_contact_wrapper::aor_id, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sip_format_contact_ami(), ast_sip_get_sorcery(), ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_fields(), astman_get_header(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), ast_sip_contact_wrapper::contact, ast_sip_contact_wrapper::contact_id, ast_sip_ami::count, ast_sip_ami::m, NULL, and ast_sip_ami::s.

Referenced by load_module().

{
   int count = 0;
   struct ast_sip_ami ami = { .s = s, .m = m, .arg = NULL, .action_id = astman_get_header(m, "ActionID"), };
   struct ao2_container *contacts = ast_sorcery_retrieve_by_fields(
      ast_sip_get_sorcery(), "contact", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
   struct ao2_iterator i;
   struct ast_sip_contact *contact;

   astman_send_listack(s, m, "Following are ContactStatusEvents for each Inbound "
             "registration", "start");

   if (contacts) {
      i = ao2_iterator_init(contacts, 0);
      while ((contact = ao2_iterator_next(&i))) {
         struct ast_sip_contact_wrapper wrapper;

         wrapper.aor_id = (char *)contact->aor;
         wrapper.contact = contact;
         wrapper.contact_id = (char *)ast_sorcery_object_get_id(contact);

         ast_sip_format_contact_ami(&wrapper, &ami, 0);
         count++;

         ao2_ref(contact, -1);
      }
      ao2_iterator_destroy(&i);
      ao2_ref(contacts, -1);
   }

   astman_send_list_complete_start(s, m, "ContactStatusDetailComplete", count);
   astman_send_list_complete_end(s);
   return 0;
}

ami_show_registrations()

static int ami_show_registrations ( struct mansession *  s, const struct message *  m  )

static

Definition at line 1175 of file res_pjsip_registrar.c.

References ami_registrations_endpoints(), astman_get_header(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), ast_sip_ami::count, ast_sip_ami::m, and ast_sip_ami::s.

Referenced by load_module().

{
   int count = 0;
   struct ast_sip_ami ami = { .s = s, .m = m, .arg = &count, .action_id = astman_get_header(m, "ActionID"), };

   astman_send_listack(s, m, "Following are Events for each Inbound registration",
      "start");

   ami_registrations_endpoints(&ami);

   astman_send_list_complete_start(s, m, "InboundRegistrationDetailComplete", count);
   astman_send_list_complete_end(s);
   return 0;
}

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 1375 of file res_pjsip_registrar.c.

AST_VECTOR()

AST_VECTOR	(	excess_contact_vector	,
		struct ast_sip_contact *
	)

Referenced by registrar_contact_delete().

build_path_data()

static int build_path_data ( pjsip_rx_data *  rdata, struct ast_str **  path_str  )

static

Definition at line 252 of file res_pjsip_registrar.c.

References ast_str_append(), ast_str_create, ast_str_set(), and NULL.

Referenced by registrar_validate_path().

{
   pjsip_generic_string_hdr *path_hdr = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &path_hdr_name, NULL);

   if (!path_hdr) {
      return 0;
   }

   *path_str = ast_str_create(64);
   if (!*path_str) {
      return -1;
   }

   ast_str_set(path_str, 0, "%.*s", (int)path_hdr->hvalue.slen, path_hdr->hvalue.ptr);

   while ((path_hdr = (pjsip_generic_string_hdr *) pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &path_hdr_name, path_hdr->next))) {
      ast_str_append(path_str, 0, ",%.*s", (int)path_hdr->hvalue.slen, path_hdr->hvalue.ptr);
   }

   return 0;
}

check_expiration_thread()

static void* check_expiration_thread ( void *  data )

static

Definition at line 1266 of file res_pjsip_registrar.c.

References ao2_callback, ao2_container_count(), ao2_ref, ast_debug, AST_RETRIEVE_FLAG_MULTIPLE, ast_sip_get_sorcery(), ast_sorcery_retrieve_by_fields(), ast_tvnow(), ast_variable_new, ast_variables_destroy(), expire_contact(), NULL, OBJ_NODATA, and var.

Referenced by expiration_global_loaded().

{
   struct ao2_container *contacts;
   struct ast_variable *var;
   char *time = alloca(64);

   while (check_interval) {
      sleep(check_interval);

      sprintf(time, "%ld", ast_tvnow().tv_sec);
      var = ast_variable_new("expiration_time <=", time, "");

      ast_debug(4, "Woke up at %s  Interval: %d\n", time, check_interval);

      contacts = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "contact",
         AST_RETRIEVE_FLAG_MULTIPLE, var);

      ast_variables_destroy(var);
      if (contacts) {
         ast_debug(3, "Expiring %d contacts\n", ao2_container_count(contacts));
         ao2_callback(contacts, OBJ_NODATA, expire_contact, NULL);
         ao2_ref(contacts, -1);
      }
   }

   return NULL;
}

contact_transport_monitor_matcher()

static int contact_transport_monitor_matcher ( void *  a, void *  b  )

static

Definition at line 321 of file res_pjsip_registrar.c.

References a, contact_transport_monitor::aor_name, b, and contact_transport_monitor::contact_name.

Referenced by register_aor_core(), and registrar_contact_delete().

{
   struct contact_transport_monitor *ma = a;
   struct contact_transport_monitor *mb = b;

   return strcmp(ma->aor_name, mb->aor_name) == 0
      && strcmp(ma->contact_name, mb->contact_name) == 0;
}

expiration_global_loaded()

static void expiration_global_loaded ( const char *  object_type )

static

Definition at line 1294 of file res_pjsip_registrar.c.

References ast_debug, ast_log, ast_pthread_create_background, AST_PTHREADT_NULL, ast_sip_get_contact_expiration_check_interval(), check_expiration_thread(), LOG_ERROR, and NULL.

{
   check_interval = ast_sip_get_contact_expiration_check_interval();

   /* Observer calls are serialized so this is safe without it's own lock */
   if (check_interval) {
      if (check_thread == AST_PTHREADT_NULL) {
         if (ast_pthread_create_background(&check_thread, NULL, check_expiration_thread, NULL)) {
            ast_log(LOG_ERROR, "Could not create thread for checking contact expiration.\n");
            return;
         }
         ast_debug(3, "Interval = %d, starting thread\n", check_interval);
      }
   } else {
      if (check_thread != AST_PTHREADT_NULL) {
         pthread_kill(check_thread, SIGURG);
         pthread_join(check_thread, NULL);
         check_thread = AST_PTHREADT_NULL;
         ast_debug(3, "Interval = 0, shutting thread down\n");
      }
   }
}

expire_contact()

static int expire_contact ( void *  obj, void *  arg, int  flags  )

static

Callback function which deletes a contact.

Definition at line 1242 of file res_pjsip_registrar.c.

References ao2_lock, ao2_unlock, ast_sip_contact::aor, ast_named_lock_get, ast_named_lock_put, AST_NAMED_LOCK_TYPE_MUTEX, ast_tvdiff_ms(), ast_tvnow(), CONTACT_DELETE_EXPIRE, ast_sip_contact::expiration_time, lock, NULL, and registrar_contact_delete().

Referenced by check_expiration_thread().

{
   struct ast_sip_contact *contact = obj;
   struct ast_named_lock *lock;

   lock = ast_named_lock_get(AST_NAMED_LOCK_TYPE_MUTEX, "aor", contact->aor);
   if (!lock) {
      return 0;
   }

   /*
    * We need to check the expiration again with the aor lock held
    * in case another thread is attempting to renew the contact.
    */
   ao2_lock(lock);
   if (ast_tvdiff_ms(ast_tvnow(), contact->expiration_time) > 0) {
      registrar_contact_delete(CONTACT_DELETE_EXPIRE, NULL, contact, contact->aor);
   }
   ao2_unlock(lock);
   ast_named_lock_put(lock);

   return 0;
}

find_aor_name()

static char* find_aor_name ( const pj_str_t *  pj_username, const pj_str_t *  pj_domain, const char *  aors  )

static

Definition at line 947 of file res_pjsip_registrar.c.

References ao2_cleanup, ast_alloca, ast_copy_pj_str(), ast_sip_get_sorcery(), ast_sorcery_retrieve_by_id(), ast_strdup, ast_strdupa, ast_strip(), ast_strlen_zero, ast_sip_domain_alias::domain, match_aor(), NULL, and strsep().

Referenced by find_registrar_aor().

{
   char *configured_aors;
   char *aors_buf;
   char *aor_name;
   char *id_domain;
   char *username, *domain;
   struct ast_sip_domain_alias *alias;

   /* Turn these into C style strings for convenience */
   username = ast_alloca(pj_strlen(pj_username) + 1);
   ast_copy_pj_str(username, pj_username, pj_strlen(pj_username) + 1);
   domain = ast_alloca(pj_strlen(pj_domain) + 1);
   ast_copy_pj_str(domain, pj_domain, pj_strlen(pj_domain) + 1);

   id_domain = ast_alloca(strlen(username) + strlen(domain) + 2);
   sprintf(id_domain, "%s@%s", username, domain);

   aors_buf = ast_strdupa(aors);

   /* Look for exact match on username@domain */
   configured_aors = aors_buf;
   while ((aor_name = ast_strip(strsep(&configured_aors, ",")))) {
      if (match_aor(aor_name, id_domain)) {
         return ast_strdup(aor_name);
      }
   }

   /* If there's a domain alias, look for exact match on username@domain_alias */
   alias = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "domain_alias", domain);
   if (alias) {
      char *id_domain_alias = ast_alloca(strlen(username) + strlen(alias->domain) + 2);

      sprintf(id_domain_alias, "%s@%s", username, alias->domain);
      ao2_cleanup(alias);

      configured_aors = strcpy(aors_buf, aors);/* Safe */
      while ((aor_name = ast_strip(strsep(&configured_aors, ",")))) {
         if (match_aor(aor_name, id_domain_alias)) {
            return ast_strdup(aor_name);
         }
      }
   }

   if (ast_strlen_zero(username)) {
      /* No username, no match */
      return NULL;
   }

   /* Look for exact match on username only */
   configured_aors = strcpy(aors_buf, aors);/* Safe */
   while ((aor_name = ast_strip(strsep(&configured_aors, ",")))) {
      if (match_aor(aor_name, username)) {
         return ast_strdup(aor_name);
      }
   }

   return NULL;
}

find_registrar_aor()

static struct ast_sip_aor* find_registrar_aor ( struct pjsip_rx_data *  rdata, struct ast_sip_endpoint *  endpoint  )

static

Definition at line 1007 of file res_pjsip_registrar.c.

References ast_sip_endpoint::aors, ast_debug, ast_free, ast_log, AST_SIP_ENDPOINT_IDENTIFY_BY_AUTH_USERNAME, AST_SIP_ENDPOINT_IDENTIFY_BY_USERNAME, ast_sip_get_ignore_uri_user_options(), ast_sip_get_pjsip_endpoint(), ast_sip_location_retrieve_aor(), ast_sip_report_req_no_support(), ast_sorcery_object_get_id(), ast_strlen_zero, AST_VECTOR_GET, AST_VECTOR_SIZE, find_aor_name(), ast_sip_endpoint::ident_method_order, LOG_WARNING, NULL, and registrar_contact_details::uri.

Referenced by registrar_on_rx_request().

{
   struct ast_sip_aor *aor = NULL;
   char *aor_name = NULL;
   int i;

   for (i = 0; i < AST_VECTOR_SIZE(&endpoint->ident_method_order); ++i) {
      pj_str_t username;
      pjsip_sip_uri *uri;
      pjsip_authorization_hdr *header = NULL;

      switch (AST_VECTOR_GET(&endpoint->ident_method_order, i)) {
      case AST_SIP_ENDPOINT_IDENTIFY_BY_USERNAME:
         uri = pjsip_uri_get_uri(rdata->msg_info.to->uri);

         pj_strassign(&username, &uri->user);

         /*
          * We may want to match without any user options getting
          * in the way.
          *
          * Logic adapted from AST_SIP_USER_OPTIONS_TRUNCATE_CHECK for pj_str_t.
          */
         if (ast_sip_get_ignore_uri_user_options()) {
            pj_ssize_t semi = pj_strcspn2(&username, ";");
            if (semi < pj_strlen(&username)) {
               username.slen = semi;
            }
         }

         aor_name = find_aor_name(&username, &uri->host, endpoint->aors);
         if (aor_name) {
            ast_debug(3, "Matched aor '%s' by To username\n", aor_name);
         }
         break;
      case AST_SIP_ENDPOINT_IDENTIFY_BY_AUTH_USERNAME:
         while ((header = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_AUTHORIZATION,
            header ? header->next : NULL))) {
            if (header && !pj_stricmp2(&header->scheme, "digest")) {
               aor_name = find_aor_name(&header->credential.digest.username,
                  &header->credential.digest.realm, endpoint->aors);
               if (aor_name) {
                  ast_debug(3, "Matched aor '%s' by Authentication username\n", aor_name);
                  break;
               }
            }
         }
         break;
      default:
         continue;
      }

      if (aor_name) {
         break;
      }
   }

   if (ast_strlen_zero(aor_name) || !(aor = ast_sip_location_retrieve_aor(aor_name))) {
      /* The provided AOR name was not found (be it within the configuration or sorcery itself) */
      pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 404, NULL, NULL, NULL);
      ast_sip_report_req_no_support(endpoint, rdata, "registrar_requested_aor_not_found");
      ast_log(LOG_WARNING, "AOR '%s' not found for endpoint '%s' (%s:%d)\n",
         aor_name ?: "", ast_sorcery_object_get_id(endpoint),
         rdata->pkt_info.src_name, rdata->pkt_info.src_port);
   }
   ast_free(aor_name);
   return aor;
}

load_module()

static int load_module ( void  )

static

Definition at line 1322 of file res_pjsip_registrar.c.

References ami_show_registration_contact_statuses(), AMI_SHOW_REGISTRATION_CONTACT_STATUSES, ami_show_registrations(), AMI_SHOW_REGISTRATIONS, ast_manager_register_xml, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_pjproject_get_buildopt(), ast_sip_get_pjsip_endpoint(), ast_sip_get_sorcery(), ast_sip_register_service(), ast_sip_unregister_service(), ast_sorcery_observer_add(), ast_sorcery_reload_object(), EVENT_FLAG_SYSTEM, NULL, pj_max_hostname, and pjsip_max_url_size.

Referenced by unload_module().

{
   const pj_str_t STR_REGISTER = { "REGISTER", 8 };

   ast_pjproject_get_buildopt("PJ_MAX_HOSTNAME", "%d", &pj_max_hostname);
   /* As of pjproject 2.4.5, PJSIP_MAX_URL_SIZE isn't exposed yet but we try anyway. */
   ast_pjproject_get_buildopt("PJSIP_MAX_URL_SIZE", "%d", &pjsip_max_url_size);

   if (ast_sip_register_service(&registrar_module)) {
      return AST_MODULE_LOAD_DECLINE;
   }

   if (pjsip_endpt_add_capability(ast_sip_get_pjsip_endpoint(), NULL, PJSIP_H_ALLOW, NULL, 1, &STR_REGISTER) != PJ_SUCCESS) {
      ast_sip_unregister_service(&registrar_module);
      return AST_MODULE_LOAD_DECLINE;
   }

   ast_manager_register_xml(AMI_SHOW_REGISTRATIONS, EVENT_FLAG_SYSTEM,
             ami_show_registrations);
   ast_manager_register_xml(AMI_SHOW_REGISTRATION_CONTACT_STATUSES, EVENT_FLAG_SYSTEM,
             ami_show_registration_contact_statuses);

   ast_sorcery_observer_add(ast_sip_get_sorcery(), "global", &expiration_global_observer);
   ast_sorcery_reload_object(ast_sip_get_sorcery(), "global");

   return AST_MODULE_LOAD_SUCCESS;
}

match_aor()

static int match_aor ( const char *  aor_name, const char *  id  )

static

Definition at line 933 of file res_pjsip_registrar.c.

References ast_debug, and ast_strlen_zero.

Referenced by find_aor_name().

{
   if (ast_strlen_zero(aor_name)) {
      return 0;
   }

   if (!strcmp(aor_name, id)) {
      ast_debug(3, "Matched id '%s' to aor '%s'\n", id, aor_name);
      return 1;
   }

   return 0;
}

register_aor()

static int register_aor ( pjsip_rx_data *  rdata, struct ast_sip_endpoint *  endpoint, struct ast_sip_aor *  aor, const char *  aor_name  )

static

Definition at line 900 of file res_pjsip_registrar.c.

References ao2_cleanup, ao2_lock, ao2_unlock, ast_sip_get_pjsip_endpoint(), ast_sip_location_retrieve_aor_contacts_nolock(), ast_sip_send_stateful_response(), aor_core_response::code, NULL, register_aor_core(), and aor_core_response::tdata.

Referenced by registrar_on_rx_request().

{
   struct aor_core_response response = {
      .code = 500,
   };
   struct ao2_container *contacts = NULL;

   ao2_lock(aor);
   contacts = ast_sip_location_retrieve_aor_contacts_nolock(aor);
   if (!contacts) {
      ao2_unlock(aor);
      pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(),
         rdata, response.code, NULL, NULL, NULL);
      return PJ_TRUE;
   }

   register_aor_core(rdata, endpoint, aor, aor_name, contacts, &response);
   ao2_cleanup(contacts);
   ao2_unlock(aor);

   /* Now send the REGISTER response to the peer */
   if (response.tdata) {
      ast_sip_send_stateful_response(rdata, response.tdata, endpoint);
   } else {
      pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(),
         rdata, response.code, NULL, NULL, NULL);
   }
   return PJ_TRUE;
}

register_aor_core()

static void register_aor_core ( pjsip_rx_data *  rdata, struct ast_sip_endpoint *  endpoint, struct ast_sip_aor *  aor, const char *  aor_name, struct ao2_container *  contacts, struct aor_core_response *  response  )

static

Definition at line 584 of file res_pjsip_registrar.c.

References ao2_alloc, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_callback, ao2_cleanup, ao2_container_alloc_list, ao2_container_count(), ao2_link, ao2_ref, ao2_unlink, ast_sip_contact::aor, contact_transport_monitor::aor_name, ast_alloca, ast_config_AST_SYSTEM_NAME, ast_copy_pj_str(), ast_copy_string(), ast_debug, ast_free, ast_log, ast_samp2tv(), ast_sip_add_date_header(), ast_sip_create_response(), ast_sip_get_pjsip_endpoint(), ast_sip_get_sorcery(), ast_sip_location_create_contact(), ast_sip_location_update_contact(), ast_sip_report_failed_acl(), ast_sip_transport_monitor_register_replace(), ast_sip_will_uri_survive_restart(), ast_sorcery_copy(), ast_sorcery_object_get_id(), ast_sorcery_object_id_compare(), ast_str_buffer(), ast_string_field_set, ast_strlen_zero, ast_test_suite_event_notify, ast_tvadd(), ast_tvnow(), ast_verb, ast_sip_contact::authenticate_qualify, ast_sip_contact::call_id, CONTACT_DELETE_ERROR, CONTACT_DELETE_REQUEST, contact_transport_monitor::contact_name, contact_transport_monitor_matcher(), ast_sip_contact::endpoint, ast_sip_contact::expiration_time, LOG_ERROR, LOG_WARNING, MAX, monitor, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, ast_sip_contact::path, pjsip_max_url_size, ast_sip_contact::prune_on_boot, ast_sip_contact::qualify_frequency, RAII_VAR, ast_sip_contact::reg_server, register_contact_transport_shutdown_cb(), registrar_add_contact(), registrar_add_non_permanent(), registrar_contact_delete(), registrar_delete_contact(), registrar_find_contact(), registrar_get_expiration(), registrar_validate_contacts(), registrar_validate_path(), remove_excess_contacts(), ast_sip_contact::user_agent, ast_sip_contact::via_addr, and ast_sip_contact::via_port.

Referenced by register_aor().

{
   static const pj_str_t USER_AGENT = { "User-Agent", 10 };

   int added = 0;
   int updated = 0;
   int deleted = 0;
   int permanent = 0;
   int contact_count;
   struct ao2_container *existing_contacts = NULL;
   pjsip_contact_hdr *contact_hdr = (pjsip_contact_hdr *)&rdata->msg_info.msg->hdr;
   struct registrar_contact_details details = { 0, };
   pjsip_tx_data *tdata;
   RAII_VAR(struct ast_str *, path_str, NULL, ast_free);
   struct ast_sip_contact *response_contact;
   char *user_agent = NULL;
   pjsip_user_agent_hdr *user_agent_hdr;
   pjsip_expires_hdr *expires_hdr;
   pjsip_via_hdr *via_hdr;
   pjsip_via_hdr *via_hdr_last;
   char *via_addr = NULL;
   int via_port = 0;
   pjsip_cid_hdr *call_id_hdr;
   char *call_id = NULL;
   size_t alloc_size;

   /* We create a single pool and use it throughout this function where we need one */
   details.pool = pjsip_endpt_create_pool(ast_sip_get_pjsip_endpoint(),
      "Contact Comparison", 1024, 256);
   if (!details.pool) {
      response->code = 500;
      return;
   }

   /* If there are any permanent contacts configured on the AOR we need to take them
    * into account when counting contacts.
    */
   if (aor->permanent_contacts) {
      permanent = ao2_container_count(aor->permanent_contacts);
   }

   if (registrar_validate_contacts(rdata, details.pool, contacts, aor, permanent, &added, &updated, &deleted)) {
      /* The provided Contact headers do not conform to the specification */
      ast_sip_report_failed_acl(endpoint, rdata, "registrar_invalid_contacts_provided");
      ast_log(LOG_WARNING, "Failed to validate contacts in REGISTER request from '%s'\n",
            ast_sorcery_object_get_id(endpoint));
      response->code = 400;
      pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), details.pool);
      return;
   }

   if (registrar_validate_path(rdata, aor, &path_str)) {
      /* Ensure that intervening proxies did not make invalid modifications to the request */
      ast_log(LOG_WARNING, "Invalid modifications made to REGISTER request from '%s' by intervening proxy\n",
            ast_sorcery_object_get_id(endpoint));
      response->code = 420;
      pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), details.pool);
      return;
   }

   if (aor->remove_existing) {
      /* Cumulative number of contacts affected by this registration */
      contact_count = MAX(updated + added - deleted,  0);

      /* We need to keep track of only existing contacts so we can later
       * remove them if need be.
       */
      existing_contacts = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0,
         NULL, ast_sorcery_object_id_compare);
      if (!existing_contacts) {
         response->code = 500;
         pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), details.pool);
         return;
      }

      ao2_callback(contacts, OBJ_NODATA, registrar_add_non_permanent, existing_contacts);
   } else {
      /* Total contacts after this registration */
      contact_count = ao2_container_count(contacts) - permanent + added - deleted;
   }
   if (contact_count > aor->max_contacts) {
      /* Enforce the maximum number of contacts */
      ast_sip_report_failed_acl(endpoint, rdata, "registrar_attempt_exceeds_maximum_configured_contacts");
      ast_log(LOG_WARNING, "Registration attempt from endpoint '%s' (%s:%d) to AOR '%s' will exceed max contacts of %u\n",
            ast_sorcery_object_get_id(endpoint), rdata->pkt_info.src_name, rdata->pkt_info.src_port,
            aor_name, aor->max_contacts);
      response->code = 403;
      pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), details.pool);
      ao2_cleanup(existing_contacts);
      return;
   }

   user_agent_hdr = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &USER_AGENT, NULL);
   if (user_agent_hdr) {
      alloc_size = pj_strlen(&user_agent_hdr->hvalue) + 1;
      user_agent = ast_alloca(alloc_size);
      ast_copy_pj_str(user_agent, &user_agent_hdr->hvalue, alloc_size);
   }

   /* Find the first Via header */
   via_hdr = via_hdr_last = (pjsip_via_hdr*) pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_VIA, NULL);
   if (via_hdr) {
      /* Find the last Via header */
      while ( (via_hdr = (pjsip_via_hdr*) pjsip_msg_find_hdr(rdata->msg_info.msg,
            PJSIP_H_VIA, via_hdr->next)) != NULL) {
         via_hdr_last = via_hdr;
      }
      alloc_size = pj_strlen(&via_hdr_last->sent_by.host) + 1;
      via_addr = ast_alloca(alloc_size);
      ast_copy_pj_str(via_addr, &via_hdr_last->sent_by.host, alloc_size);
      via_port=via_hdr_last->sent_by.port;
   }

   call_id_hdr = (pjsip_cid_hdr*) pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CALL_ID, NULL);
   if (call_id_hdr) {
      alloc_size = pj_strlen(&call_id_hdr->id) + 1;
      call_id = ast_alloca(alloc_size);
      ast_copy_pj_str(call_id, &call_id_hdr->id, alloc_size);
   }

   /* Iterate each provided Contact header and add, update, or delete */
   for (; (contact_hdr = (pjsip_contact_hdr *) pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, contact_hdr->next)); pj_pool_reset(details.pool)) {
      int expiration;
      char contact_uri[pjsip_max_url_size];
      RAII_VAR(struct ast_sip_contact *, contact, NULL, ao2_cleanup);

      if (contact_hdr->star) {
         /* A star means to unregister everything, so do so for the possible contacts */
         ao2_callback(contacts, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE,
            registrar_delete_contact, (void *)aor_name);
         /* If we are keeping track of existing contacts for removal then, well, there is
          * absolutely nothing left so no need to try to remove any.
          */
         if (existing_contacts) {
            ao2_ref(existing_contacts, -1);
            existing_contacts = NULL;
         }
         break;
      }

      if (!PJSIP_URI_SCHEME_IS_SIP(contact_hdr->uri) && !PJSIP_URI_SCHEME_IS_SIPS(contact_hdr->uri)) {
         /* This registrar only currently supports sip: and sips: URI schemes */
         continue;
      }

      expiration = registrar_get_expiration(aor, contact_hdr, rdata);
      details.uri = pjsip_uri_get_uri(contact_hdr->uri);
      pjsip_uri_print(PJSIP_URI_IN_CONTACT_HDR, details.uri, contact_uri, sizeof(contact_uri));

      contact = ao2_callback(contacts, OBJ_UNLINK, registrar_find_contact, &details);

      /* If a contact was returned and we need to keep track of existing contacts then it
       * should be removed.
       */
      if (contact && existing_contacts) {
         ao2_unlink(existing_contacts, contact);
      }

      if (!contact) {
         int prune_on_boot;

         /* If they are actually trying to delete a contact that does not exist... be forgiving */
         if (!expiration) {
            ast_verb(3, "Attempted to remove non-existent contact '%s' from AOR '%s' by request\n",
               contact_uri, aor_name);
            continue;
         }

         prune_on_boot = !ast_sip_will_uri_survive_restart(details.uri, endpoint, rdata);

         contact = ast_sip_location_create_contact(aor, contact_uri,
            ast_tvadd(ast_tvnow(), ast_samp2tv(expiration, 1)),
            path_str ? ast_str_buffer(path_str) : NULL,
            user_agent, via_addr, via_port, call_id, prune_on_boot, endpoint);
         if (!contact) {
            ast_log(LOG_ERROR, "Unable to bind contact '%s' to AOR '%s'\n",
               contact_uri, aor_name);
            continue;
         }

         if (prune_on_boot) {
            size_t contact_name_len;
            const char *contact_name;
            struct contact_transport_monitor *monitor;

            /*
             * Monitor the transport in case it gets disconnected because
             * the contact won't be valid anymore if that happens.
             */
            contact_name = ast_sorcery_object_get_id(contact);
            contact_name_len = strlen(contact_name) + 1;
            monitor = ao2_alloc(sizeof(*monitor) + 1 + strlen(aor_name)
               + contact_name_len, NULL);
            if (monitor) {
               strcpy(monitor->aor_name, aor_name);/* Safe */
               monitor->contact_name = monitor->aor_name + strlen(aor_name) + 1;
               ast_copy_string(monitor->contact_name, contact_name, contact_name_len);/* Safe */

               ast_sip_transport_monitor_register_replace(rdata->tp_info.transport,
                  register_contact_transport_shutdown_cb, monitor, contact_transport_monitor_matcher);
               ao2_ref(monitor, -1);
            }
         }

         ast_verb(3, "Added contact '%s' to AOR '%s' with expiration of %d seconds\n",
            contact_uri, aor_name, expiration);
         ast_test_suite_event_notify("AOR_CONTACT_ADDED",
               "Contact: %s\r\n"
               "AOR: %s\r\n"
               "Expiration: %d\r\n"
               "UserAgent: %s",
               contact_uri,
               aor_name,
               expiration,
               user_agent);

         ao2_link(contacts, contact);
      } else if (expiration) {
         struct ast_sip_contact *contact_update;

         contact_update = ast_sorcery_copy(ast_sip_get_sorcery(), contact);
         if (!contact_update) {
            ast_log(LOG_ERROR, "Failed to update contact '%s' expiration time to %d seconds.\n",
               contact->uri, expiration);
            continue;
         }

         contact_update->expiration_time = ast_tvadd(ast_tvnow(), ast_samp2tv(expiration, 1));
         contact_update->qualify_frequency = aor->qualify_frequency;
         contact_update->authenticate_qualify = aor->authenticate_qualify;
         if (path_str) {
            ast_string_field_set(contact_update, path, ast_str_buffer(path_str));
         }
         if (user_agent) {
            ast_string_field_set(contact_update, user_agent, user_agent);
         }
         if (!ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) {
            ast_string_field_set(contact_update, reg_server, ast_config_AST_SYSTEM_NAME);
         }

         if (ast_sip_location_update_contact(contact_update)) {
            ast_log(LOG_ERROR, "Failed to update contact '%s' expiration time to %d seconds.\n",
               contact->uri, expiration);
            registrar_contact_delete(CONTACT_DELETE_ERROR, rdata->tp_info.transport,
               contact, aor_name);
            continue;
         }
         ast_debug(3, "Refreshed contact '%s' on AOR '%s' with new expiration of %d seconds\n",
            contact_uri, aor_name, expiration);
         ast_test_suite_event_notify("AOR_CONTACT_REFRESHED",
               "Contact: %s\r\n"
               "AOR: %s\r\n"
               "Expiration: %d\r\n"
               "UserAgent: %s",
               contact_uri,
               aor_name,
               expiration,
               contact_update->user_agent);
         ao2_link(contacts, contact_update);
         ao2_cleanup(contact_update);
      } else {
         registrar_contact_delete(CONTACT_DELETE_REQUEST, rdata->tp_info.transport,
               contact, aor_name);
      }
   }

   pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), details.pool);

   /*
    * If the AOR is configured to remove any contacts over max_contacts
    * that have not been updated/added/deleted as a result of this
    * REGISTER do so.
    *
    * The existing contacts container holds all contacts that were not
    * involved in this REGISTER.
    * The contacts container holds the current contacts of the AOR.
    */
   if (aor->remove_existing && existing_contacts) {
      /* Total contacts after this registration */
      contact_count = ao2_container_count(existing_contacts) + updated + added;
      if (contact_count > aor->max_contacts) {
         /* Remove excess existing contacts that expire the soonest */
         remove_excess_contacts(existing_contacts, contacts, contact_count - aor->max_contacts);
      }
      ao2_ref(existing_contacts, -1);
   }

   response_contact = ao2_callback(contacts, 0, NULL, NULL);

   /* Send a response containing all of the contacts (including static) that are present on this AOR */
   if (ast_sip_create_response(rdata, 200, response_contact, &tdata) != PJ_SUCCESS) {
      ao2_cleanup(response_contact);
      ao2_cleanup(contacts);
      response->code = 500;
      return;
   }
   ao2_cleanup(response_contact);

   /* Add the date header to the response, some UAs use this to set their date and time */
   ast_sip_add_date_header(tdata);

   ao2_callback(contacts, 0, registrar_add_contact, tdata);

   if ((expires_hdr = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_EXPIRES, NULL))) {
      expires_hdr = pjsip_expires_hdr_create(tdata->pool, registrar_get_expiration(aor, NULL, rdata));
      pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)expires_hdr);
   }

   response->tdata = tdata;
}

register_contact_transport_remove_cb()

static int register_contact_transport_remove_cb ( void *  data )

static

Definition at line 330 of file res_pjsip_registrar.c.

References ao2_lock, ao2_ref, ao2_unlock, contact_transport_monitor::aor_name, ast_sip_location_retrieve_aor(), ast_sip_location_retrieve_contact(), CONTACT_DELETE_SHUTDOWN, contact_transport_monitor::contact_name, monitor, NULL, registrar_contact_delete(), and contact_transport_monitor::removing.

Referenced by register_contact_transport_shutdown_cb().

{
   struct contact_transport_monitor *monitor = data;
   struct ast_sip_contact *contact;
   struct ast_sip_aor *aor;

   aor = ast_sip_location_retrieve_aor(monitor->aor_name);
   if (!aor) {
      ao2_lock(monitor);
      monitor->removing = 0;
      ao2_unlock(monitor);
      ao2_ref(monitor, -1);
      return 0;
   }

   ao2_lock(aor);

   contact = ast_sip_location_retrieve_contact(monitor->contact_name);
   if (contact) {
      registrar_contact_delete(CONTACT_DELETE_SHUTDOWN, NULL, contact, monitor->aor_name);
      ao2_ref(contact, -1);
   }
   ao2_unlock(aor);
   ao2_ref(aor, -1);

   ao2_ref(monitor, -1);
   return 0;
}

register_contact_transport_shutdown_cb()

static void register_contact_transport_shutdown_cb ( void *  data )

static

Definition at line 369 of file res_pjsip_registrar.c.

References ao2_lock, ao2_ref, ao2_unlock, ast_sip_push_task(), monitor, NULL, register_contact_transport_remove_cb(), and contact_transport_monitor::removing.

Referenced by register_aor_core(), registrar_contact_delete(), and unload_module().

{
   struct contact_transport_monitor *monitor = data;

   /*
    * It's possible for this shutdown handler to get called multiple times for the
    * same monitor from different threads. Only one of the calls needs to do the
    * actual removing of the contact, so if one is currently removing then any
    * subsequent calls can skip.
    */
   ao2_lock(monitor);
   if (monitor->removing) {
      ao2_unlock(monitor);
      return;
   }

   monitor->removing = 1;

   /*
    * Push off to a default serializer.  This is in case sorcery
    * does database accesses for contacts.  Database accesses may
    * not be on this machine.  We don't want to tie up the pjsip
    * monitor thread with potentially long access times.
    */
   ao2_ref(monitor, +1);
   if (ast_sip_push_task(NULL, register_contact_transport_remove_cb, monitor)) {
      monitor->removing = 0;
      ao2_ref(monitor, -1);
   }

   ao2_unlock(monitor);
}

registrar_add_contact()

static int registrar_add_contact ( void *  obj, void *  arg, int  flags  )

static

Internal function which adds a contact to a response.

Definition at line 223 of file res_pjsip_registrar.c.

References ast_sip_contact::aor, ast_log, ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), ast_sip_contact::expiration_time, LOG_WARNING, PJSIP_EXPIRES_NOT_SPECIFIED, registrar_contact_details::uri, and ast_sip_contact::uri.

Referenced by register_aor_core().

{
   struct ast_sip_contact *contact = obj;
   pjsip_tx_data *tdata = arg;
   pj_str_t uri;
   pjsip_uri *parsed;

   pj_strdup2_with_null(tdata->pool, &uri, contact->uri);
   parsed = pjsip_parse_uri(tdata->pool, uri.ptr, uri.slen, PJSIP_PARSE_URI_AS_NAMEADDR);

   if (parsed && (PJSIP_URI_SCHEME_IS_SIP(parsed) || PJSIP_URI_SCHEME_IS_SIPS(parsed))) {
      pjsip_contact_hdr *hdr = pjsip_contact_hdr_create(tdata->pool);
      hdr->uri = parsed;
      if (!ast_tvzero(contact->expiration_time)) {
         hdr->expires = ast_tvdiff_ms(contact->expiration_time, ast_tvnow()) / 1000;
      } else {
         hdr->expires = PJSIP_EXPIRES_NOT_SPECIFIED;
      }
      pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) hdr);
   } else {
      ast_log(LOG_WARNING, "Skipping invalid Contact URI \"%.*s\" for AOR %s\n",
         (int) uri.slen, uri.ptr, contact->aor);
   }

   return 0;
}

registrar_add_non_permanent()

static int registrar_add_non_permanent ( void *  obj, void *  arg, int  flags  )

static

Callback function which adds non-permanent contacts to a container.

Definition at line 563 of file res_pjsip_registrar.c.

References ao2_link, ast_tvzero(), container, and ast_sip_contact::expiration_time.

Referenced by register_aor_core().

{
   struct ast_sip_contact *contact = obj;
   struct ao2_container *container = arg;

   if (ast_tvzero(contact->expiration_time)) {
      return 0;
   }

   ao2_link(container, contact);

   return 0;
}

registrar_contact_delete()

static int registrar_contact_delete ( enum contact_delete_type  type, pjsip_transport *  transport, struct ast_sip_contact *  contact, const char *  aor_name  )

static

Definition at line 403 of file res_pjsip_registrar.c.

References contact_transport_monitor::aor_name, ast_alloca, ast_copy_string(), ast_sip_location_delete_contact(), ast_sip_transport_monitor_unregister(), ast_sip_transport_monitor_unregister_all(), ast_sorcery_object_get_id(), ast_test_suite_event_notify, ast_tvzero(), AST_VECTOR(), ast_verb, CONTACT_DELETE_ERROR, CONTACT_DELETE_EXISTING, CONTACT_DELETE_EXPIRE, CONTACT_DELETE_REQUEST, CONTACT_DELETE_SHUTDOWN, contact_transport_monitor::contact_name, contact_transport_monitor_matcher(), ast_sip_contact::expiration_time, monitor, ast_sip_contact::prune_on_boot, register_contact_transport_shutdown_cb(), ast_sip_contact::uri, ast_sip_contact::user_agent, and VERBOSITY_ATLEAST.

Referenced by expire_contact(), register_aor_core(), register_contact_transport_remove_cb(), registrar_delete_contact(), and remove_excess_contacts().

{
   int aor_size;

   /* Permanent contacts can't be deleted */
   if (ast_tvzero(contact->expiration_time)) {
      return -1;
   }

   aor_size = aor_name ? strlen(aor_name) : 0;
   if (contact->prune_on_boot && type != CONTACT_DELETE_SHUTDOWN && aor_size) {
      const char *contact_name = ast_sorcery_object_get_id(contact);
      size_t contact_name_len = strlen(contact_name) + 1;
      struct contact_transport_monitor *monitor = ast_alloca(
         sizeof(*monitor) + 1 + aor_size + contact_name_len);

      strcpy(monitor->aor_name, aor_name); /* Safe */
      monitor->contact_name = monitor->aor_name + aor_size + 1;
      ast_copy_string(monitor->contact_name, contact_name, contact_name_len); /* Safe */

      if (transport) {
         ast_sip_transport_monitor_unregister(transport,
            register_contact_transport_shutdown_cb,   monitor,
            contact_transport_monitor_matcher);
      } else {
         /*
          * If a specific transport is not supplied then unregister the matching
          * monitor from all reliable transports.
          */
         ast_sip_transport_monitor_unregister_all(register_contact_transport_shutdown_cb,
            monitor, contact_transport_monitor_matcher);
      }
   }

   ast_sip_location_delete_contact(contact);

   if (aor_size) {
      if (VERBOSITY_ATLEAST(3)) {
         const char *reason = "none";

         switch (type) {
         case CONTACT_DELETE_ERROR:
            reason = "registration failure";
            break;
         case CONTACT_DELETE_EXISTING:
            reason = "remove existing";
            break;
         case CONTACT_DELETE_EXPIRE:
            reason = "expiration";
            break;
         case CONTACT_DELETE_REQUEST:
            reason = "request";
            break;
         case CONTACT_DELETE_SHUTDOWN:
            reason = "shutdown";
            break;
         }

         ast_verb(3, "Removed contact '%s' from AOR '%s' due to %s\n",
                contact->uri, aor_name, reason);
      }

      ast_test_suite_event_notify("AOR_CONTACT_REMOVED",
            "Contact: %s\r\n"
            "AOR: %s\r\n"
            "UserAgent: %s",
            contact->uri,
            aor_name,
            contact->user_agent);
   }

   return 0;
}

registrar_delete_contact()

static int registrar_delete_contact ( void *  obj, void *  arg, int  flags  )

static

Internal function used to delete a contact from an AOR.

Definition at line 216 of file res_pjsip_registrar.c.

References CMP_MATCH, CONTACT_DELETE_REQUEST, NULL, and registrar_contact_delete().

Referenced by register_aor_core().

{
   return registrar_contact_delete(
      CONTACT_DELETE_REQUEST, NULL, obj, arg) ? 0 : CMP_MATCH;
}

registrar_find_contact()

static int registrar_find_contact ( void *  obj, void *  arg, int  flags  )

static

Callback function for finding a contact.

Definition at line 121 of file res_pjsip_registrar.c.

References ast_log, ast_tvzero(), CMP_MATCH, ast_sip_contact::expiration_time, LOG_WARNING, registrar_contact_details::pool, registrar_contact_details::uri, and ast_sip_contact::uri.

Referenced by register_aor_core().

{
   struct ast_sip_contact *contact = obj;
   const struct registrar_contact_details *details = arg;
   pjsip_uri *contact_uri;

   if (ast_tvzero(contact->expiration_time)) {
      return 0;
   }

   contact_uri = pjsip_parse_uri(details->pool, (char*)contact->uri, strlen(contact->uri), 0);
   if (!contact_uri) {
      ast_log(LOG_WARNING, "Unable to parse contact URI from '%s'.\n", contact->uri);
      return 0;
   }

   return (pjsip_uri_cmp(PJSIP_URI_IN_CONTACT_HDR, details->uri, contact_uri) == PJ_SUCCESS) ? CMP_MATCH : 0;
}

registrar_get_expiration()

static unsigned int registrar_get_expiration ( const struct ast_sip_aor *  aor, const pjsip_contact_hdr *  contact, const pjsip_rx_data *  rdata  )

static

Internal function which returns the expiration time for a contact.

Definition at line 84 of file res_pjsip_registrar.c.

References ast_sip_aor::default_expiration, ast_sip_aor::maximum_expiration, ast_sip_aor::minimum_expiration, NULL, and PJSIP_EXPIRES_NOT_SPECIFIED.

Referenced by register_aor_core().

{
   pjsip_expires_hdr *expires;
   unsigned int expiration = aor->default_expiration;

   if (contact && contact->expires != PJSIP_EXPIRES_NOT_SPECIFIED) {
      /* Expiration was provided with the contact itself */
      expiration = contact->expires;
   } else if ((expires = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_EXPIRES, NULL))) {
      /* Expiration was provided using the Expires header */
      expiration = expires->ivalue;
   }

   /* If the value has explicitly been set to 0, do not enforce */
   if (!expiration) {
      return expiration;
   }

   /* Enforce the range that we will allow for expiration */
   if (expiration < aor->minimum_expiration) {
      expiration = aor->minimum_expiration;
   } else if (expiration > aor->maximum_expiration) {
      expiration = aor->maximum_expiration;
   }

   return expiration;
}

registrar_on_rx_request()

static pj_bool_t registrar_on_rx_request ( struct pjsip_rx_data *  rdata )

static

Definition at line 1076 of file res_pjsip_registrar.c.

References ao2_cleanup, ao2_ref, ast_log, ast_pjsip_rdata_get_endpoint(), ast_sip_get_pjsip_endpoint(), ast_sip_report_failed_acl(), ast_sip_report_req_no_support(), ast_sorcery_object_get_id(), ast_strlen_zero, find_registrar_aor(), LOG_WARNING, ast_sip_aor::max_contacts, NULL, RAII_VAR, and register_aor().

{
   RAII_VAR(struct ast_sip_endpoint *, endpoint,
       ast_pjsip_rdata_get_endpoint(rdata), ao2_cleanup);
   struct ast_sip_aor *aor;
   const char *aor_name;

   if (pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_register_method) || !endpoint) {
      return PJ_FALSE;
   }

   if (ast_strlen_zero(endpoint->aors)) {
      /* Short circuit early if the endpoint has no AORs configured on it, which means no registration possible */
      pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 403, NULL, NULL, NULL);
      ast_sip_report_failed_acl(endpoint, rdata, "registrar_attempt_without_configured_aors");
      ast_log(LOG_WARNING, "Endpoint '%s' (%s:%d) has no configured AORs\n", ast_sorcery_object_get_id(endpoint),
         rdata->pkt_info.src_name, rdata->pkt_info.src_port);
      return PJ_TRUE;
   }

   if (!PJSIP_URI_SCHEME_IS_SIP(rdata->msg_info.to->uri) && !PJSIP_URI_SCHEME_IS_SIPS(rdata->msg_info.to->uri)) {
      pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 416, NULL, NULL, NULL);
      ast_sip_report_failed_acl(endpoint, rdata, "registrar_invalid_uri_in_to_received");
      ast_log(LOG_WARNING, "Endpoint '%s' (%s:%d) attempted to register to an AOR with a non-SIP URI\n", ast_sorcery_object_get_id(endpoint),
         rdata->pkt_info.src_name, rdata->pkt_info.src_port);
      return PJ_TRUE;
   }

   aor = find_registrar_aor(rdata, endpoint);
   if (!aor) {
      /* We've already responded about not finding an AOR. */
      return PJ_TRUE;
   }

   aor_name = ast_sorcery_object_get_id(aor);

   if (!aor->max_contacts) {
      /* Registration is not permitted for this AOR */
      pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 403, NULL, NULL, NULL);
      ast_sip_report_req_no_support(endpoint, rdata, "registrar_attempt_without_registration_permitted");
      ast_log(LOG_WARNING, "AOR '%s' has no configured max_contacts. Endpoint '%s' (%s:%d) unable to register\n",
         aor_name, ast_sorcery_object_get_id(endpoint),
         rdata->pkt_info.src_name, rdata->pkt_info.src_port);
   } else {
      register_aor(rdata, endpoint, aor, aor_name);
   }
   ao2_ref(aor, -1);
   return PJ_TRUE;
}

registrar_validate_contacts()

static int registrar_validate_contacts ( const pjsip_rx_data *  rdata, pj_pool_t *  pool, struct ao2_container *  contacts, struct ast_sip_aor *  aor, int  permanent, int *  added, int *  updated, int *  deleted  )

static

Internal function which validates provided Contact headers to confirm that they are acceptable, and returns number of contacts.

Definition at line 141 of file res_pjsip_registrar.c.

References NULL, and registrar_contact_details::pool.

Referenced by register_aor_core().

{
   pjsip_contact_hdr *previous = NULL;
   pjsip_contact_hdr *contact = (pjsip_contact_hdr *)&rdata->msg_info.msg->hdr;
   struct registrar_contact_details details = {
      .pool = pool,
   };

   for (; (contact = (pjsip_contact_hdr *) pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, contact->next)); pj_pool_reset(pool)) {
      unsigned int expiration = registrar_get_expiration(aor, contact, rdata);
      struct ast_sip_contact *existing;
      char contact_uri[pjsip_max_url_size];

      if (contact->star) {
         /* The expiration MUST be 0 when a '*' contact is used and there must be no other contact */
         if (expiration != 0 || previous) {
            return -1;
         }
         /* Count all contacts to delete */
         *deleted = ao2_container_count(contacts) - permanent;
         previous = contact;
         continue;
      } else if (previous && previous->star) {
         /* If there is a previous contact and it is a '*' this is a deal breaker */
         return -1;
      }
      previous = contact;

      if (!PJSIP_URI_SCHEME_IS_SIP(contact->uri) && !PJSIP_URI_SCHEME_IS_SIPS(contact->uri)) {
         continue;
      }

      details.uri = pjsip_uri_get_uri(contact->uri);

      /* pjsip_uri_print returns -1 if there's not enough room in the buffer */
      if (pjsip_uri_print(PJSIP_URI_IN_CONTACT_HDR, details.uri, contact_uri, sizeof(contact_uri)) < 0) {
         /* If the total length of the uri is greater than pjproject can handle, go no further */
         return -1;
      }

      if (details.uri->host.slen >= pj_max_hostname) {
         /* If the length of the hostname is greater than pjproject can handle, go no further */
         return -1;
      }

      /* Determine if this is an add, update, or delete for policy enforcement purposes */
      existing = ao2_callback(contacts, 0, registrar_find_contact, &details);
      ao2_cleanup(existing);
      if (!existing) {
         if (expiration) {
            ++*added;
         }
      } else if (expiration) {
         ++*updated;
      } else {
         ++*deleted;
      }
   }

   return 0;
}

registrar_validate_path()

static int registrar_validate_path ( pjsip_rx_data *  rdata, struct ast_sip_aor *  aor, struct ast_str **  path_str  )

static

Definition at line 274 of file res_pjsip_registrar.c.

References build_path_data(), NULL, and ast_sip_aor::support_path.

Referenced by register_aor_core().

{
   const pj_str_t path_supported_name = { "path", 4 };
   pjsip_supported_hdr *supported_hdr;
   int i;

   if (!aor->support_path) {
      return 0;
   }

   if (build_path_data(rdata, path_str)) {
      return -1;
   }

   if (!*path_str) {
      return 0;
   }

   supported_hdr = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_SUPPORTED, NULL);
   if (!supported_hdr) {
      return -1;
   }

   /* Find advertised path support */
   for (i = 0; i < supported_hdr->count; i++) {
      if (!pj_stricmp(&supported_hdr->values[i], &path_supported_name)) {
         return 0;
      }
   }

   /* Path header present, but support not advertised */
   return -1;
}

remove_excess_contacts()

static void remove_excess_contacts ( struct ao2_container *  contacts, struct ao2_container *  response_contacts, unsigned int  to_remove  )

static

Definition at line 523 of file res_pjsip_registrar.c.

References ao2_callback, ao2_unlink, ast_sip_contact::aor, ast_assert, AST_VECTOR_FREE, AST_VECTOR_GET, AST_VECTOR_INIT, AST_VECTOR_SIZE, CONTACT_DELETE_EXISTING, NULL, OBJ_MULTIPLE, OBJ_NODATA, registrar_contact_delete(), and vec_contact_add().

Referenced by register_aor_core().

{
   struct excess_contact_vector contact_vec;

   /*
    * Create a sorted vector to hold the to_remove soonest to
    * expire contacts.  The vector has an extra space to
    * temporarily hold the longest to expire contact that we
    * won't remove.
    */
   if (AST_VECTOR_INIT(&contact_vec, to_remove + 1)) {
      return;
   }
   ao2_callback(contacts, OBJ_NODATA | OBJ_MULTIPLE, vec_contact_add, &contact_vec);

   /*
    * The vector should always be populated with the number
    * of contacts we need to remove.  Just in case, we will
    * remove all contacts in the vector even if the contacts
    * container had fewer contacts than there should be.
    */
   ast_assert(AST_VECTOR_SIZE(&contact_vec) == to_remove);
   to_remove = AST_VECTOR_SIZE(&contact_vec);

   /* Remove the excess contacts that expire the soonest */
   while (to_remove--) {
      struct ast_sip_contact *contact;

      contact = AST_VECTOR_GET(&contact_vec, to_remove);

      registrar_contact_delete(CONTACT_DELETE_EXISTING, NULL, contact, contact->aor);

      ao2_unlink(response_contacts, contact);
   }

   AST_VECTOR_FREE(&contact_vec);
}

sip_contact_to_str()

static int sip_contact_to_str ( void *  acp, void *  arg, int  flags  )

static

Definition at line 1128 of file res_pjsip_registrar.c.

References ast_sip_contact_to_str().

Referenced by ami_registrations_aor().

{
   return ast_sip_contact_to_str(acp, arg, flags);
}

unload_module()

static int unload_module ( void  )

static

Definition at line 1350 of file res_pjsip_registrar.c.

References AMI_SHOW_REGISTRATION_CONTACT_STATUSES, AMI_SHOW_REGISTRATIONS, ast_manager_unregister(), AST_MODFLAG_LOAD_ORDER, AST_MODPRI_CHANNEL_DEPEND, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, AST_PTHREADT_NULL, ast_sip_get_sorcery(), ast_sip_transport_monitor_unregister_all(), ast_sip_unregister_service(), ast_sorcery_observer_remove(), ASTERISK_GPL_KEY, load_module(), NULL, and register_contact_transport_shutdown_cb().

{
   if (check_thread != AST_PTHREADT_NULL) {
      check_interval = 0;
      pthread_kill(check_thread, SIGURG);
      pthread_join(check_thread, NULL);

      check_thread = AST_PTHREADT_NULL;
   }

   ast_sorcery_observer_remove(ast_sip_get_sorcery(), "global", &expiration_global_observer);

   ast_manager_unregister(AMI_SHOW_REGISTRATIONS);
   ast_manager_unregister(AMI_SHOW_REGISTRATION_CONTACT_STATUSES);
   ast_sip_unregister_service(&registrar_module);
   ast_sip_transport_monitor_unregister_all(register_contact_transport_shutdown_cb, NULL, NULL);
   return 0;
}

vec_contact_add()

static int vec_contact_add ( void *  obj, void *  arg, int  flags  )

static

Definition at line 489 of file res_pjsip_registrar.c.

References AST_VECTOR_ADD_SORTED, AST_VECTOR_MAX_SIZE, AST_VECTOR_SIZE, and vec_contact_cmp().

Referenced by remove_excess_contacts().

{
   struct ast_sip_contact *contact = obj;
   struct excess_contact_vector *contact_vec = arg;

   /*
    * Performance wise, an insertion sort is fine because we
    * shouldn't need to remove more than a handful of contacts.
    * I expect we'll typically be removing only one contact.
    */
   AST_VECTOR_ADD_SORTED(contact_vec, contact, vec_contact_cmp);
   if (AST_VECTOR_SIZE(contact_vec) == AST_VECTOR_MAX_SIZE(contact_vec)) {
      /*
       * We added a contact over the number we need to remove.
       * Remove the longest to expire contact from the vector
       * which is the last element in the vector.  It may be
       * the one we just added or the one we just added pushed
       * out an earlier contact from removal consideration.
       */
      --AST_VECTOR_SIZE(contact_vec);
   }
   return 0;
}

vec_contact_cmp()

static int vec_contact_cmp ( struct ast_sip_contact *  left, struct ast_sip_contact *  right  )

static

Definition at line 480 of file res_pjsip_registrar.c.

References ast_tvcmp(), and ast_sip_contact::expiration_time.

Referenced by vec_contact_add().

{
   struct ast_sip_contact *left_contact = left;
   struct ast_sip_contact *right_contact = right;

   /* Sort from soonest to expire to last to expire */
   return ast_tvcmp(left_contact->expiration_time, right_contact->expiration_time);
}

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP Registrar Support" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_CHANNEL_DEPEND - 3, .requires = "res_pjproject,res_pjsip", }

static

Definition at line 1375 of file res_pjsip_registrar.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1375 of file res_pjsip_registrar.c.

check_interval

unsigned int check_interval

static

The global interval at which to check for contact expiration.

Definition at line 1239 of file res_pjsip_registrar.c.

check_thread

pthread_t check_thread = AST_PTHREADT_NULL

static

Thread keeping things alive.

Definition at line 1236 of file res_pjsip_registrar.c.

expiration_global_observer

struct ast_sorcery_observer expiration_global_observer

static

Initial value:

= {
   .loaded = expiration_global_loaded,
}

Observer which is used to update our interval when the global setting changes.

Definition at line 1318 of file res_pjsip_registrar.c.

path_hdr_name

const pj_str_t path_hdr_name = { "Path", 4 }

static

Definition at line 250 of file res_pjsip_registrar.c.

pj_max_hostname

int pj_max_hostname = PJ_MAX_HOSTNAME

static

Definition at line 80 of file res_pjsip_registrar.c.

Referenced by load_module().

pjsip_max_url_size

int pjsip_max_url_size = PJSIP_MAX_URL_SIZE

static

Definition at line 81 of file res_pjsip_registrar.c.

Referenced by load_module(), and register_aor_core().

registrar_module

pjsip_module registrar_module

static

Definition at line 1228 of file res_pjsip_registrar.c.