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	excess_contact_vector
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_UNAVAILABLE , 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)
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_add_unreachable (void *obj, void *arg, int flags)
	Internal callback function which adds any contact which is unreachable. 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, unsigned int remove_existing)
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 = AST_BUILDOPT_SUM, .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 1323 of file res_pjsip_registrar.c.

AMI_SHOW_REGISTRATIONS

#define AMI_SHOW_REGISTRATIONS   "PJSIPShowRegistrationsInbound"

Definition at line 1324 of file res_pjsip_registrar.c.

Enumeration Type Documentation

contact_delete_type

enum contact_delete_type

Enumerator
CONTACT_DELETE_ERROR
CONTACT_DELETE_EXISTING
CONTACT_DELETE_UNAVAILABLE
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_UNAVAILABLE,
    CONTACT_DELETE_EXPIRE,
    CONTACT_DELETE_REQUEST,
    CONTACT_DELETE_SHUTDOWN,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1474 of file res_pjsip_registrar.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1474 of file res_pjsip_registrar.c.

ami_registrations_aor()

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

static

Definition at line 1231 of file res_pjsip_registrar.c.

{
    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;
}

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().

ami_registrations_endpoint()

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

static

Definition at line 1253 of file res_pjsip_registrar.c.

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

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

Referenced by ami_registrations_endpoints().

ami_registrations_endpoints()

static int ami_registrations_endpoints ( void *  arg )

static

Definition at line 1260 of file res_pjsip_registrar.c.

{
    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;
}

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

Referenced by ami_show_registrations().

ami_show_registration_contact_statuses()

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

static

Definition at line 1288 of file res_pjsip_registrar.c.

{
    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;
}

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().

ami_show_registrations()

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

static

Definition at line 1273 of file res_pjsip_registrar.c.

{
    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;
}

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().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1474 of file res_pjsip_registrar.c.

build_path_data()

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

static

Definition at line 253 of file res_pjsip_registrar.c.

{
    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;
}

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

Referenced by registrar_validate_path().

check_expiration_thread()

static void * check_expiration_thread ( void *  data )

static

Definition at line 1364 of file res_pjsip_registrar.c.

{
    struct ao2_container *contacts;
    struct ast_variable *var;
    char time[AST_TIME_T_LEN];
 
    while (check_interval) {
        sleep(check_interval);
 
        ast_time_t_to_string(ast_tvnow().tv_sec, time, sizeof(time));
 
        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;
}

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

Referenced by expiration_global_loaded().

contact_transport_monitor_matcher()

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

static

Definition at line 322 of file res_pjsip_registrar.c.

{
    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;
}

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

Referenced by registrar_contact_delete().

expiration_global_loaded()

static void expiration_global_loaded ( const char *  object_type )

static

Definition at line 1393 of file res_pjsip_registrar.c.

{
    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");
        }
    }
}

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

expire_contact()

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

static

Callback function which deletes a contact.

Definition at line 1340 of file res_pjsip_registrar.c.

{
    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;
}

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().

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 1045 of file res_pjsip_registrar.c.

{
    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;
}

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().

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 1105 of file res_pjsip_registrar.c.

{
    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;
}

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, header::next, and NULL.

Referenced by registrar_on_rx_request().

load_module()

static int load_module ( void  )

static

Definition at line 1421 of file res_pjsip_registrar.c.

{
    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;
}

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, expiration_global_observer, NULL, pj_max_hostname, pjsip_max_url_size, and registrar_module.

match_aor()

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

static

Definition at line 1031 of file res_pjsip_registrar.c.

{
    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;
}

References ast_debug, and ast_strlen_zero().

Referenced by find_aor_name().

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 998 of file res_pjsip_registrar.c.

{
    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;
}

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().

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 653 of file res_pjsip_registrar.c.

{
    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;
    struct ao2_container *unavail_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 && aor->remove_unavailable) {
        /* Get unavailable contact total */
        int unavail_count = 0;
 
        unavail_contacts = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0,
            NULL, ast_sorcery_object_id_compare);
        if (!unavail_contacts) {
            response->code = 500;
            pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), details.pool);
            return;
        }
        ao2_callback(contacts, OBJ_NODATA, registrar_add_unreachable, unavail_contacts);
        if (unavail_contacts) {
            unavail_count = ao2_container_count(unavail_contacts);
        }
 
        /* Check to see if removing unavailable contacts will help */
        if (contact_count - unavail_count <= aor->max_contacts) {
            /* Remove any unavailable contacts */
            remove_excess_contacts(unavail_contacts, contacts, contact_count - aor->max_contacts, aor->remove_existing);
            ao2_cleanup(unavail_contacts);
            /* We're only here if !aor->remove_existing so this count is correct */
            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 are unavailable or expire soonest */
            remove_excess_contacts(existing_contacts, contacts, contact_count - aor->max_contacts,
                aor->remove_existing);
        }
        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;
}

References NULL.

Referenced by register_aor().

register_contact_transport_remove_cb()

static int register_contact_transport_remove_cb ( void *  data )

static

Definition at line 331 of file res_pjsip_registrar.c.

{
    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;
}

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, NULL, registrar_contact_delete(), and contact_transport_monitor::removing.

Referenced by register_contact_transport_shutdown_cb().

register_contact_transport_shutdown_cb()

static void register_contact_transport_shutdown_cb ( void *  data )

static

Definition at line 368 of file res_pjsip_registrar.c.

{
    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);
}

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

Referenced by registrar_contact_delete(), and unload_module().

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 224 of file res_pjsip_registrar.c.

{
    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;
}

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, and ast_sip_contact::uri.

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 609 of file res_pjsip_registrar.c.

{
    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;
}

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

registrar_add_unreachable()

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

static

Internal callback function which adds any contact which is unreachable.

Definition at line 624 of file res_pjsip_registrar.c.

{
    struct ast_sip_contact *contact = obj;
    struct ao2_container *container = arg;
    struct ast_sip_contact_status *status;
    int unreachable;
 
    status = ast_sip_get_contact_status(contact);
    if (!status) {
        return 0;
    }
 
    unreachable = (status->status == UNAVAILABLE);
    ao2_ref(status, -1);
 
    if (unreachable) {
        ao2_link(container, contact);
    }
 
    return 0;
}

References ao2_link, ao2_ref, ast_sip_get_contact_status(), container, status, and UNAVAILABLE.

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 402 of file res_pjsip_registrar.c.

{
    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_UNAVAILABLE:
                reason = "remove unavailable";
                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;
}

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_verb, CONTACT_DELETE_ERROR, CONTACT_DELETE_EXISTING, CONTACT_DELETE_EXPIRE, CONTACT_DELETE_REQUEST, CONTACT_DELETE_SHUTDOWN, CONTACT_DELETE_UNAVAILABLE, contact_transport_monitor::contact_name, contact_transport_monitor_matcher(), ast_sip_contact::expiration_time, ast_sip_contact::prune_on_boot, register_contact_transport_shutdown_cb(), type, ast_sip_contact::uri, ast_sip_contact::user_agent, and VERBOSITY_ATLEAST.

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

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 217 of file res_pjsip_registrar.c.

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

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

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.

{
    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;
}

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

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.

{
    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;
}

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

registrar_on_rx_request()

static pj_bool_t registrar_on_rx_request ( struct pjsip_rx_data *  rdata )

static

Definition at line 1174 of file res_pjsip_registrar.c.

{
    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;
}

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().

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.

{
    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;
}

References NULL, and registrar_contact_details::pool.

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 275 of file res_pjsip_registrar.c.

{
    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;
}

References ast_sip_contact::aor, build_path_data(), and NULL.

remove_excess_contacts()

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

static

Definition at line 565 of file res_pjsip_registrar.c.

{
    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 are unavailable or expire the soonest */
    while (to_remove--) {
        struct ast_sip_contact *contact;
 
        contact = AST_VECTOR_GET(&contact_vec, to_remove);
 
        if (!remove_existing) {
            registrar_contact_delete(CONTACT_DELETE_UNAVAILABLE, NULL, contact, contact->aor);
        } else {
            registrar_contact_delete(CONTACT_DELETE_EXISTING, NULL, contact, contact->aor);
        }
 
        ao2_unlink(response_contacts, contact);
    }
 
    AST_VECTOR_FREE(&contact_vec);
}

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, CONTACT_DELETE_UNAVAILABLE, NULL, OBJ_MULTIPLE, OBJ_NODATA, registrar_contact_delete(), and vec_contact_add().

sip_contact_to_str()

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

static

Definition at line 1226 of file res_pjsip_registrar.c.

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

References ast_sip_contact_to_str().

Referenced by ami_registrations_aor().

unload_module()

static int unload_module ( void  )

static

Definition at line 1449 of file res_pjsip_registrar.c.

{
    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;
}

References AMI_SHOW_REGISTRATION_CONTACT_STATUSES, AMI_SHOW_REGISTRATIONS, ast_manager_unregister(), AST_PTHREADT_NULL, ast_sip_get_sorcery(), ast_sip_transport_monitor_unregister_all(), ast_sip_unregister_service(), ast_sorcery_observer_remove(), check_interval, check_thread, expiration_global_observer, NULL, register_contact_transport_shutdown_cb(), and registrar_module.

vec_contact_add()

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

static

Definition at line 532 of file res_pjsip_registrar.c.

{
    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;
}

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

Referenced by remove_excess_contacts().

vec_contact_cmp()

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

static

Definition at line 482 of file res_pjsip_registrar.c.

{
    struct ast_sip_contact *left_contact = left;
    struct ast_sip_contact *right_contact = right;
 
    /* Sort from soonest to expire to last to expire */
    int time_sorted = ast_tvcmp(left_contact->expiration_time, right_contact->expiration_time);
 
    struct ast_sip_aor *aor = ast_sip_location_retrieve_aor(left_contact->aor);
    struct ast_sip_contact_status *left_status;
    struct ast_sip_contact_status *right_status;
    int remove_unavailable = 0;
    int left_unreachable;
    int right_unreachable;
 
    if (aor) {
        remove_unavailable = aor->remove_unavailable;
        ao2_ref(aor, -1);
    }
 
    if (!remove_unavailable) {
        return time_sorted;
    }
 
    /* Get contact status if available */
    left_status = ast_sip_get_contact_status(left_contact);
    if (!left_status) {
        return time_sorted;
    }
 
    right_status = ast_sip_get_contact_status(right_contact);
    if (!right_status) {
        ao2_ref(left_status, -1);
        return time_sorted;
    }
 
    left_unreachable = (left_status->status == UNAVAILABLE);
    right_unreachable = (right_status->status == UNAVAILABLE);
    ao2_ref(left_status, -1);
    ao2_ref(right_status, -1);
    if (left_unreachable != right_unreachable) {
        /* Set unavailable contact to top of vector */
        if (left_unreachable) return -1;
        if (right_unreachable) return 1;
    }
 
    /* Either both available or both unavailable */
    return time_sorted;
}

References ao2_ref, ast_sip_contact::aor, ast_sip_contact_status::aor, ast_sip_get_contact_status(), ast_sip_location_retrieve_aor(), ast_tvcmp(), ast_sip_contact::expiration_time, ast_sip_contact_status::status, and UNAVAILABLE.

Referenced by vec_contact_add().

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 = AST_BUILDOPT_SUM, .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 1474 of file res_pjsip_registrar.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1474 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 1337 of file res_pjsip_registrar.c.

Referenced by check_expiration_thread(), expiration_global_loaded(), and unload_module().

check_thread

pthread_t check_thread = AST_PTHREADT_NULL

static

Thread keeping things alive.

Definition at line 1334 of file res_pjsip_registrar.c.

Referenced by expiration_global_loaded(), and unload_module().

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 1417 of file res_pjsip_registrar.c.

Referenced by load_module(), and unload_module().

path_hdr_name

const pj_str_t path_hdr_name = { "Path", 4 }

static

Definition at line 251 of file res_pjsip_registrar.c.

Referenced by build_path_data().

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().

registrar_module

pjsip_module registrar_module

static

Definition at line 1326 of file res_pjsip_registrar.c.

Referenced by load_module(), and unload_module().