res_pjsip_outbound_registration.c File Reference

#include "asterisk.h"
#include <pjsip.h>
#include <pjsip_ua.h>
#include "asterisk/res_pjsip.h"
#include "asterisk/res_pjsip_cli.h"
#include "asterisk/module.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/cli.h"
#include "asterisk/stasis_system.h"
#include "asterisk/threadstorage.h"
#include "asterisk/threadpool.h"
#include "asterisk/statsd.h"
#include "res_pjsip/include/res_pjsip_private.h"
#include "asterisk/vector.h"
#include "asterisk/pbx.h"

Include dependency graph for res_pjsip_outbound_registration.c:

Go to the source code of this file.

Data Structures
struct	registration_response
	Structure for registration response. More...
struct	sip_ami_outbound
struct	sip_outbound_registration
	Outbound registration information. More...
struct	sip_outbound_registration_client_state
	Outbound registration client state information (persists for lifetime of regc) More...
struct	sip_outbound_registration_state
	Outbound registration state information (persists for lifetime that registration should exist) More...

Macros
#define	DEFAULT_STATE_BUCKETS   53
	Default number of state container buckets. More...
#define	LINE_PARAMETER_SIZE   8
	Size of the buffer for creating a unique string for the line. More...
#define	MAX_UNLOAD_TIMEOUT_TIME   35 /* Seconds */
#define	REGISTRATION_URI_FIELD_LEN   53
#define	REREGISTER_BUFFER_TIME   10
	Amount of buffer time (in seconds) before expiration that we re-register at. More...

Enumerations
enum	sip_outbound_registration_status {   SIP_REGISTRATION_UNREGISTERED = 0 , SIP_REGISTRATION_REGISTERED , SIP_REGISTRATION_REJECTED_TEMPORARY , SIP_REGISTRATION_REJECTED_PERMANENT ,   SIP_REGISTRATION_STOPPING , SIP_REGISTRATION_STOPPED }
	Various states that an outbound registration may be in. More...

Functions
static void	__init_register_callback_invoked (void)
	Some thread local storage used to determine if the running thread invoked the callback. More...
static void	__reg_module (void)
static void	__unreg_module (void)
static int	add_configured_supported_headers (struct sip_outbound_registration_client_state *client_state, pjsip_tx_data *tdata)
	Helper function to add configured supported headers. More...
static int	add_to_supported_header (pjsip_tx_data *tdata, pj_str_t *name)
	Helper function to add string to Supported header. More...
static int	ami_outbound_registration_detail (void *obj, void *arg, int flags)
static int	ami_outbound_registration_task (void *obj)
static int	ami_register (struct mansession *s, const struct message *m)
static int	ami_show_outbound_registrations (struct mansession *s, const struct message *m)
static int	ami_unregister (struct mansession *s, const struct message *m)
static	AO2_GLOBAL_OBJ_STATIC (current_states)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static void	auth_observer (const char *type)
static int	can_reuse_registration (struct sip_outbound_registration *existing, struct sip_outbound_registration *applied)
static void	cancel_registration (struct sip_outbound_registration_client_state *client_state)
	Helper function which cancels the timer on a client. More...
static int	check_state (void *obj, void *arg, int flags)
static char *	cli_complete_registration (const char *line, const char *word, int pos, int state)
static struct ao2_container *	cli_get_container (const char *regex)
static int	cli_iterator (void *container, ao2_callback_fn callback, void *args)
static int	cli_print_body (void *obj, void *arg, int flags)
static int	cli_print_header (void *obj, void *arg, int flags)
static char *	cli_register (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void *	cli_retrieve_by_id (const char *id)
static char *	cli_unregister (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static const char *	fetch_google_access_token (const struct ast_sip_auth *auth)
	Get google oauth2 access token using refresh token. More...
static struct ao2_container *	get_registrations (void)
static struct sip_outbound_registration_state *	get_state (const char *id)
static struct pjsip_param *	get_uri_option_line (const void *uri)
static int	handle_client_registration (void *data)
	Callback function for registering. More...
static int	handle_client_state_destruction (void *data)
	Callback function for unregistering (potentially) and destroying state. More...
static int	handle_registration_response (void *data)
	Callback function for handling a response to a registration attempt. More...
static struct ast_sip_endpoint *	line_identify (pjsip_rx_data *rdata)
	Endpoint identifier which uses the 'line' parameter to establish a relationship to an outgoing registration. More...
static int	line_identify_relationship (void *obj, void *arg, int flags)
	Callback function for matching an outbound registration based on line. More...
static int	load_module (void)
static int	monitor_matcher (void *a, void *b)
static char *	my_cli_traverse_objects (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	network_change_stasis_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static int	outbound_auth_handler (const struct aco_option *opt, struct ast_variable *var, void *obj)
static int	outbound_auths_to_str (const void *obj, const intptr_t *args, char **buf)
static int	outbound_auths_to_var_list (const void *obj, struct ast_variable **fields)
static int	queue_register (struct sip_outbound_registration_state *state)
static int	queue_unregister (struct sip_outbound_registration_state *state)
static pj_status_t	registration_client_send (struct sip_outbound_registration_client_state *client_state, pjsip_tx_data *tdata)
	Helper function which sends a message and cleans up, if needed, on failure. More...
static void	registration_deleted_observer (const void *obj)
static void	registration_loaded_observer (const char *name, const struct ast_sorcery *sorcery, const char *object_type, int reloaded)
static void	registration_response_destroy (void *obj)
	Registration response structure destructor. More...
static int	registration_state_cmp (void *obj, void *arg, int flags)
	comparator function for state objects More...
static int	registration_state_hash (const void *obj, const int flags)
	hashing function for state objects More...
static void	registration_transport_monitor_setup (pjsip_transport *transport, const char *registration_name)
static void	registration_transport_shutdown_cb (void *obj)
static int	reload_module (void)
static void	reregister_all (void)
static int	reregister_immediately_cb (void *obj)
static void	save_response_fields_to_transport (struct registration_response *response)
static void	schedule_registration (struct sip_outbound_registration_client_state *client_state, unsigned int seconds)
	Helper function which sets up the timer to re-register in a specific amount of time. More...
static void	schedule_retry (struct registration_response *response, unsigned int interval, const char *server_uri, const char *client_uri)
static int	set_outbound_initial_authentication_credentials (pjsip_regc *regc, const struct ast_sip_auth_vector *auth_vector)
static int	sip_dialog_create_contact (pj_pool_t *pool, pj_str_t *contact, const char *user, const pj_str_t *target, pjsip_tpselector *selector, const char *line, const char *header_params)
	Helper function which populates a pj_str_t with a contact header. More...
static void *	sip_outbound_registration_alloc (const char *name)
	Allocator function for registration information. More...
static int	sip_outbound_registration_apply (const struct ast_sorcery *sorcery, void *obj)
	Apply function which finds or allocates a state structure. More...
static void	sip_outbound_registration_client_state_destroy (void *obj)
	Destructor function for client registration state. More...
static void	sip_outbound_registration_destroy (void *obj)
	Destructor function for registration information. More...
static int	sip_outbound_registration_is_temporal (unsigned int code, struct sip_outbound_registration_client_state *client_state)
	Helper function which determines if a response code is temporal or not. More...
static int	sip_outbound_registration_perform (void *data)
	Helper function which performs a single registration. More...
static int	sip_outbound_registration_regc_alloc (void *data)
	Helper function that allocates a pjsip registration client and configures it. More...
static void	sip_outbound_registration_response_cb (struct pjsip_regc_cbparam *param)
	Callback function for outbound registration client. More...
static struct sip_outbound_registration_state *	sip_outbound_registration_state_alloc (struct sip_outbound_registration *registration)
	Allocator function for registration state. More...
static void	sip_outbound_registration_state_destroy (void *obj)
	Destructor function for registration state. More...
static const char *	sip_outbound_registration_status_str (enum sip_outbound_registration_status state)
static void	sip_outbound_registration_timer_cb (pj_timer_heap_t *timer_heap, struct pj_timer_entry *entry)
	Timer callback function, used just for registrations. More...
static int	unload_module (void)
static void	unregister_all (void)
static int	unregister_task (void *obj)
static void	update_client_state_status (struct sip_outbound_registration_client_state *client_state, enum sip_outbound_registration_status status)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP Outbound Registration 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, .reload = reload_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND, .requires = "res_pjsip", .optional_modules = "res_statsd", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_sip_cli_formatter_entry *	cli_formatter
static struct ast_cli_entry	cli_outbound_registration []
static struct ast_sip_endpoint_identifier	line_identifier
static struct stasis_subscription *	network_change_sub
static const struct ast_sorcery_observer	observer_callbacks_auth
static const struct ast_sorcery_instance_observer	observer_callbacks_registrations
static pj_str_t	OUTBOUND_NAME = { "outbound", 8 }
static pj_str_t	PATH_NAME = { "path", 4 }
static struct ast_threadstorage	register_callback_invoked = { .once = PTHREAD_ONCE_INIT , .key_init = __init_register_callback_invoked , .custom_init = NULL , }
static const struct ast_sorcery_observer	registration_observer
static struct ast_serializer_shutdown_group *	shutdown_group

Macro Definition Documentation

DEFAULT_STATE_BUCKETS

#define DEFAULT_STATE_BUCKETS   53

Default number of state container buckets.

Definition at line 412 of file res_pjsip_outbound_registration.c.

LINE_PARAMETER_SIZE

#define LINE_PARAMETER_SIZE   8

Size of the buffer for creating a unique string for the line.

Definition at line 251 of file res_pjsip_outbound_registration.c.

MAX_UNLOAD_TIMEOUT_TIME

#define MAX_UNLOAD_TIMEOUT_TIME   35 /* Seconds */

Time needs to be long enough for a transaction to timeout if nothing replies.

Definition at line 406 of file res_pjsip_outbound_registration.c.

REGISTRATION_URI_FIELD_LEN

#define REGISTRATION_URI_FIELD_LEN   53

REREGISTER_BUFFER_TIME

#define REREGISTER_BUFFER_TIME   10

Amount of buffer time (in seconds) before expiration that we re-register at.

Definition at line 248 of file res_pjsip_outbound_registration.c.

Enumeration Type Documentation

sip_outbound_registration_status

enum sip_outbound_registration_status

Various states that an outbound registration may be in.

Enumerator
SIP_REGISTRATION_UNREGISTERED	Currently unregistered.
SIP_REGISTRATION_REGISTERED	Registered, yay!
SIP_REGISTRATION_REJECTED_TEMPORARY	Registration was rejected, but response was temporal.
SIP_REGISTRATION_REJECTED_PERMANENT	Registration was rejected, permanently.
SIP_REGISTRATION_STOPPING	Registration is stopping.
SIP_REGISTRATION_STOPPED	Registration has been stopped.

Definition at line 254 of file res_pjsip_outbound_registration.c.

                                      {
    /*! \brief Currently unregistered */
    SIP_REGISTRATION_UNREGISTERED = 0,
    /*! \brief Registered, yay! */
    SIP_REGISTRATION_REGISTERED,
    /*! \brief Registration was rejected, but response was temporal */
    SIP_REGISTRATION_REJECTED_TEMPORARY,
    /*! \brief Registration was rejected, permanently */
    SIP_REGISTRATION_REJECTED_PERMANENT,
    /*! \brief Registration is stopping. */
    SIP_REGISTRATION_STOPPING,
    /*! \brief Registration has been stopped */
    SIP_REGISTRATION_STOPPED,
};

Function Documentation

__init_register_callback_invoked()

static void __init_register_callback_invoked ( void  )

static

Some thread local storage used to determine if the running thread invoked the callback.

Definition at line 245 of file res_pjsip_outbound_registration.c.

{

__reg_module()

static void __reg_module ( void  )

static

Definition at line 2624 of file res_pjsip_outbound_registration.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 2624 of file res_pjsip_outbound_registration.c.

add_configured_supported_headers()

static int add_configured_supported_headers ( struct sip_outbound_registration_client_state *  client_state, pjsip_tx_data *  tdata  )

static

Helper function to add configured supported headers.

Definition at line 650 of file res_pjsip_outbound_registration.c.

{
    if (client_state->support_path) {
        if (!add_to_supported_header(tdata, &PATH_NAME)) {
            return 0;
        }
    }
 
    if (client_state->support_outbound) {
        if (!add_to_supported_header(tdata, &OUTBOUND_NAME)) {
            return 0;
        }
    }
 
    return 1;
}

References add_to_supported_header(), OUTBOUND_NAME, PATH_NAME, sip_outbound_registration_client_state::support_outbound, and sip_outbound_registration_client_state::support_path.

Referenced by handle_client_registration(), handle_client_state_destruction(), and unregister_task().

add_to_supported_header()

static int add_to_supported_header ( pjsip_tx_data *  tdata, pj_str_t *  name  )

static

Helper function to add string to Supported header.

Definition at line 615 of file res_pjsip_outbound_registration.c.

{
    pjsip_supported_hdr *hdr;
    int i;
 
    hdr = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_SUPPORTED, NULL);
    if (!hdr) {
        /* insert a new Supported header */
        hdr = pjsip_supported_hdr_create(tdata->pool);
        if (!hdr) {
            pjsip_tx_data_dec_ref(tdata);
            return 0;
        }
 
        pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *)hdr);
    }
 
    /* Don't add the value if it's already there */
    for (i = 0; i < hdr->count; ++i) {
        if (pj_stricmp(&hdr->values[i], name) == 0) {
            return 1;
        }
    }
 
    if (hdr->count >= PJSIP_GENERIC_ARRAY_MAX_COUNT) {
        return 0;
    }
 
    /* add on to the existing Supported header */
    pj_strassign(&hdr->values[hdr->count++], name);
 
    return 1;
}

References name, and NULL.

Referenced by add_configured_supported_headers().

ami_outbound_registration_detail()

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

static

Definition at line 2169 of file res_pjsip_outbound_registration.c.

{
    struct sip_ami_outbound *ami = arg;
 
    ami->registration = obj;
    return ast_sip_push_task_wait_servant(NULL, ami_outbound_registration_task, ami);
}

References sip_ami_outbound::ami, ami_outbound_registration_task(), ast_sip_push_task_wait_servant(), and NULL.

Referenced by ami_show_outbound_registrations().

ami_outbound_registration_task()

static int ami_outbound_registration_task ( void *  obj )

static

Definition at line 2133 of file res_pjsip_outbound_registration.c.

{
    struct sip_ami_outbound *ami = obj;
    struct ast_str *buf;
    struct sip_outbound_registration_state *state;
 
    buf = ast_sip_create_ami_event("OutboundRegistrationDetail", ami->ami);
    if (!buf) {
        return -1;
    }
 
    ast_sip_sorcery_object_to_ami(ami->registration, &buf);
 
    if ((state = get_state(ast_sorcery_object_get_id(ami->registration)))) {
        pjsip_regc_info info;
 
        if (state->client_state->status == SIP_REGISTRATION_REGISTERED) {
            ++ami->registered;
        } else {
            ++ami->not_registered;
        }
 
        ast_str_append(&buf, 0, "Status: %s\r\n",
            sip_outbound_registration_status_str(state->client_state->status));
 
        pjsip_regc_get_info(state->client_state->client, &info);
        ast_str_append(&buf, 0, "NextReg: %d\r\n", info.next_reg);
        ao2_ref(state, -1);
    }
 
    astman_append(ami->ami->s, "%s\r\n", ast_str_buffer(buf));
    ast_free(buf);
 
    return ast_sip_format_auths_ami(&ami->registration->outbound_auths, ami->ami);
}

References sip_ami_outbound::ami, ao2_ref, ast_free, ast_sip_create_ami_event(), ast_sip_format_auths_ami(), ast_sip_sorcery_object_to_ami(), ast_sorcery_object_get_id(), ast_str_append(), ast_str_buffer(), astman_append(), buf, get_state(), sip_to_pjsip::info(), sip_ami_outbound::not_registered, sip_outbound_registration::outbound_auths, sip_ami_outbound::registered, sip_ami_outbound::registration, ast_sip_ami::s, sip_outbound_registration_status_str(), SIP_REGISTRATION_REGISTERED, and state.

Referenced by ami_outbound_registration_detail().

ami_register()

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

static

Definition at line 2089 of file res_pjsip_outbound_registration.c.

{
    const char *registration_name = astman_get_header(m, "Registration");
    struct sip_outbound_registration_state *state;
 
    if (ast_strlen_zero(registration_name)) {
        astman_send_error(s, m, "Registration parameter missing.");
        return 0;
    }
 
    if (strcmp(registration_name, "*all") == 0) {
        reregister_all();
        astman_send_ack(s, m, "Reregistrations queued.");
        return 0;
    }
 
    state = get_state(registration_name);
    if (!state) {
        astman_send_error(s, m, "Unable to retrieve registration entry\n");
        return 0;
    }
 
    /* We need to serialize the unregister and register so they need
     * to be queued as separate tasks.
     */
    if (queue_unregister(state)) {
        astman_send_ack(s, m, "Failed to queue unregistration");
    } else if (queue_register(state)) {
        astman_send_ack(s, m, "Failed to queue unregistration");
    } else {
        astman_send_ack(s, m, "Reregistration sent");
    }
 
    ao2_ref(state, -1);
    return 0;
}

References ao2_ref, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), get_state(), queue_register(), queue_unregister(), reregister_all(), and state.

Referenced by load_module().

ami_show_outbound_registrations()

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

static

Definition at line 2177 of file res_pjsip_outbound_registration.c.

{
    struct ast_sip_ami ami = { .s = s, .m = m, .action_id = astman_get_header(m, "ActionID"), };
    struct sip_ami_outbound ami_outbound = { .ami = &ami };
    struct ao2_container *regs;
 
    regs = get_registrations();
    if (!regs) {
        astman_send_error(s, m, "Unable to retrieve "
                  "outbound registrations\n");
        return -1;
    }
 
    astman_send_listack(s, m, "Following are Events for each Outbound registration",
        "start");
 
    ao2_callback(regs, OBJ_NODATA, ami_outbound_registration_detail, &ami_outbound);
 
    astman_send_list_complete_start(s, m, "OutboundRegistrationDetailComplete",
        ami_outbound.registered + ami_outbound.not_registered);
    astman_append(s,
        "Registered: %d\r\n"
        "NotRegistered: %d\r\n",
        ami_outbound.registered,
        ami_outbound.not_registered);
    astman_send_list_complete_end(s);
 
    ao2_ref(regs, -1);
    return 0;
}

References sip_ami_outbound::ami, ami_outbound_registration_detail(), ao2_callback, ao2_ref, astman_append(), astman_get_header(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), get_registrations(), ast_sip_ami::m, sip_ami_outbound::not_registered, OBJ_NODATA, sip_ami_outbound::registered, and ast_sip_ami::s.

Referenced by load_module().

ami_unregister()

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

static

Definition at line 2057 of file res_pjsip_outbound_registration.c.

{
    const char *registration_name = astman_get_header(m, "Registration");
    struct sip_outbound_registration_state *state;
 
    if (ast_strlen_zero(registration_name)) {
        astman_send_error(s, m, "Registration parameter missing.");
        return 0;
    }
 
    if (strcmp(registration_name, "*all") == 0) {
        unregister_all();
        astman_send_ack(s, m, "Unregistrations queued.");
        return 0;
    }
 
    state = get_state(registration_name);
    if (!state) {
        astman_send_error(s, m, "Unable to retrieve registration entry\n");
        return 0;
    }
 
    if (queue_unregister(state)) {
        astman_send_ack(s, m, "Failed to queue unregistration");
    } else {
        astman_send_ack(s, m, "Unregistration sent");
    }
 
    ao2_ref(state, -1);
    return 0;
}

References ao2_ref, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), get_state(), queue_unregister(), state, and unregister_all().

Referenced by load_module().

AO2_GLOBAL_OBJ_STATIC()

static AO2_GLOBAL_OBJ_STATIC ( current_states  )

static

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 2624 of file res_pjsip_outbound_registration.c.

auth_observer()

static void auth_observer ( const char *  type )

static

Definition at line 2330 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration *registration;
    struct sip_outbound_registration_state *state;
    struct ao2_container *regs;
    const char *registration_id;
    struct ao2_iterator i;
 
    ast_debug(4, "Auths updated. Checking for any outbound registrations that are in permanent rejected state so they can be retried\n");
 
    regs = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "registration",
        AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
    if (!regs || ao2_container_count(regs) == 0) {
        ao2_cleanup(regs);
        return;
    }
 
    i = ao2_iterator_init(regs, 0);
    for (; (registration = ao2_iterator_next(&i)); ao2_ref(registration, -1)) {
        registration_id = ast_sorcery_object_get_id(registration);
        state = get_state(registration_id);
        if (state && state->client_state->status == SIP_REGISTRATION_REJECTED_PERMANENT) {
            ast_debug(4, "Trying outbound registration '%s' again\n", registration_id);
 
            if (ast_sip_push_task(state->client_state->serializer,
                          sip_outbound_registration_perform, ao2_bump(state))) {
                ast_log(LOG_ERROR, "Failed to perform outbound registration on '%s'\n", registration_id);
                ao2_ref(state, -1);
            }
        }
        ao2_cleanup(state);
    }
    ao2_iterator_destroy(&i);
    ao2_cleanup(regs);
}

References ao2_bump, ao2_cleanup, ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_debug, ast_log, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sip_get_sorcery(), ast_sip_push_task(), ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_fields(), get_state(), LOG_ERROR, NULL, sip_outbound_registration_perform(), SIP_REGISTRATION_REJECTED_PERMANENT, and state.

can_reuse_registration()

static int can_reuse_registration ( struct sip_outbound_registration *  existing, struct sip_outbound_registration *  applied  )

static

Definition at line 1459 of file res_pjsip_outbound_registration.c.

{
    int rc = 1;
    struct ast_sorcery *sorcery = ast_sip_get_sorcery();
    struct ast_variable *ve = ast_sorcery_objectset_create(sorcery, existing);
    struct ast_variable *va = ast_sorcery_objectset_create(sorcery, applied);
    struct ast_variable *vc = NULL;
 
    if (ast_sorcery_changeset_create(ve, va, &vc) || vc != NULL) {
        rc = 0;
        ast_debug(4, "Registration '%s' changed.  Can't re-use.\n", ast_sorcery_object_get_id(existing));
    } else {
        ast_debug(4, "Registration '%s' didn't change.  Can re-use\n", ast_sorcery_object_get_id(existing));
    }
 
    ast_variables_destroy(ve);
    ast_variables_destroy(va);
    ast_variables_destroy(vc);
 
    return rc;
}

References ast_debug, ast_sip_get_sorcery(), ast_sorcery_changeset_create(), ast_sorcery_object_get_id(), ast_sorcery_objectset_create, ast_variables_destroy(), NULL, and sorcery.

Referenced by sip_outbound_registration_apply().

cancel_registration()

static void cancel_registration ( struct sip_outbound_registration_client_state *  client_state )

static

Helper function which cancels the timer on a client.

Definition at line 544 of file res_pjsip_outbound_registration.c.

{
    if (pj_timer_heap_cancel_if_active(pjsip_endpt_get_timer_heap(ast_sip_get_pjsip_endpoint()),
        &client_state->timer, client_state->timer.id)) {
        /* The timer was successfully cancelled, drop the refcount of client_state */
        ao2_ref(client_state, -1);
    }
}

References ao2_ref, ast_sip_get_pjsip_endpoint(), and sip_outbound_registration_client_state::timer.

Referenced by handle_client_state_destruction(), reregister_immediately_cb(), schedule_registration(), and unregister_task().

check_state()

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

static

Definition at line 2370 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_state *state = obj;
    struct sip_outbound_registration *registration;
 
    registration = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "registration",
        ast_sorcery_object_get_id(state->registration));
    if (!registration) {
        /* This is a dead registration */
        return CMP_MATCH;
    }
 
    ao2_ref(registration, -1);
    return 0;
}

References ao2_ref, ast_sip_get_sorcery(), ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_id(), and CMP_MATCH.

cli_complete_registration()

static char* cli_complete_registration ( const char *  line, const char *  word, int  pos, int  state  )

static

Definition at line 1922 of file res_pjsip_outbound_registration.c.

{
    char *result = NULL;
    int wordlen;
    int which = 0;
    struct sip_outbound_registration *registration;
    struct ao2_container *registrations;
    struct ao2_iterator i;
 
    if (pos != 3) {
        return NULL;
    }
 
    wordlen = strlen(word);
    if (wordlen == 0 && ++which > state) {
        return ast_strdup("*all");
    }
 
    registrations = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "registration",
        AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
    if (!registrations) {
        return NULL;
    }
 
    i = ao2_iterator_init(registrations, 0);
    while ((registration = ao2_iterator_next(&i))) {
        const char *name = ast_sorcery_object_get_id(registration);
 
        if (!strncasecmp(word, name, wordlen) && ++which > state) {
            result = ast_strdup(name);
        }
 
        ao2_ref(registration, -1);
        if (result) {
            break;
        }
    }
    ao2_iterator_destroy(&i);
 
    ao2_ref(registrations, -1);
    return result;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sip_get_sorcery(), ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_fields(), ast_strdup, name, NULL, registrations, and result.

Referenced by cli_register(), and cli_unregister().

cli_get_container()

static struct ao2_container* cli_get_container ( const char *  regex )

static

Definition at line 2209 of file res_pjsip_outbound_registration.c.

{
    RAII_VAR(struct ao2_container *, container, NULL, ao2_cleanup);
    struct ao2_container *s_container;
 
    container = ast_sorcery_retrieve_by_regex(ast_sip_get_sorcery(), "registration", regex);
    if (!container) {
        return NULL;
    }
 
    s_container = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0,
        ast_sorcery_object_id_sort, ast_sorcery_object_id_compare);
    if (!s_container) {
        return NULL;
    }
 
    if (ao2_container_dup(s_container, container, 0)) {
        ao2_ref(s_container, -1);
        return NULL;
    }
 
    return s_container;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_cleanup, ao2_container_alloc_list, ao2_container_dup(), ao2_ref, ast_sip_get_sorcery(), ast_sorcery_object_id_compare(), ast_sorcery_object_id_sort(), ast_sorcery_retrieve_by_regex(), container, NULL, RAII_VAR, and regex().

Referenced by load_module().

cli_iterator()

static int cli_iterator ( void *  container, ao2_callback_fn  callback, void *  args  )

static

Definition at line 2233 of file res_pjsip_outbound_registration.c.

{
    ao2_callback(container, OBJ_NODATA, callback, args);
 
    return 0;
}

References ao2_callback, args, container, and OBJ_NODATA.

Referenced by load_module().

cli_print_body()

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

static

Definition at line 2269 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration *registration = obj;
    struct ast_sip_cli_context *context = arg;
    const char *id = ast_sorcery_object_get_id(registration);
    struct sip_outbound_registration_state *state = get_state(id);
#define REGISTRATION_URI_FIELD_LEN  53
 
    ast_assert(context->output_buffer != NULL);
 
    ast_str_append(&context->output_buffer, 0, " %-s/%-*.*s  %-16s  %-16s\n",
        id,
        (int) (REGISTRATION_URI_FIELD_LEN - strlen(id)),
        (int) (REGISTRATION_URI_FIELD_LEN - strlen(id)),
        registration->server_uri,
        AST_VECTOR_SIZE(&registration->outbound_auths)
            ? AST_VECTOR_GET(&registration->outbound_auths, 0)
            : "n/a",
        (state ? sip_outbound_registration_status_str(state->client_state->status) : "Unregistered"));
    ao2_cleanup(state);
 
    if (context->show_details
        || (context->show_details_only_level_0 && context->indent_level == 0)) {
        ast_str_append(&context->output_buffer, 0, "\n");
        ast_sip_cli_print_sorcery_objectset(registration, context, 0);
    }
 
    return 0;
}

References ao2_cleanup, ast_assert, ast_sip_cli_print_sorcery_objectset(), ast_sorcery_object_get_id(), ast_str_append(), AST_VECTOR_GET, AST_VECTOR_SIZE, context, get_state(), NULL, sip_outbound_registration::outbound_auths, sip_outbound_registration_state::registration, REGISTRATION_URI_FIELD_LEN, sip_outbound_registration::server_uri, and sip_outbound_registration_status_str().

Referenced by load_module().

cli_print_header()

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

static

Definition at line 2257 of file res_pjsip_outbound_registration.c.

{
    struct ast_sip_cli_context *context = arg;
 
    ast_assert(context->output_buffer != NULL);
 
    ast_str_append(&context->output_buffer, 0,
        " <Registration/ServerURI..............................>  <Auth..........>  <Status.......>\n");
 
    return 0;
}

References ast_assert, ast_str_append(), context, and NULL.

Referenced by load_module().

cli_register()

static char* cli_register ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 2009 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_state *state;
    const char *registration_name;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "pjsip send register";
        e->usage =
            "Usage: pjsip send register <registration> | *all \n"
            "       Unregisters the specified (or all) outbound "
            "registration(s) then starts registration(s) and schedules re-registrations.\n";
        return NULL;
    case CLI_GENERATE:
        return cli_complete_registration(a->line, a->word, a->pos, a->n);
    }
 
    if (a->argc != 4) {
        return CLI_SHOWUSAGE;
    }
 
    registration_name = a->argv[3];
 
    if (strcmp(registration_name, "*all") == 0) {
        reregister_all();
        ast_cli(a->fd, "Re-register all queued\n");
        return CLI_SUCCESS;
    }
 
    state = get_state(registration_name);
    if (!state) {
        ast_cli(a->fd, "Unable to retrieve registration %s\n", registration_name);
        return CLI_FAILURE;
    }
 
    /* We need to serialize the unregister and register so they need
     * to be queued as separate tasks.
     */
    if (queue_unregister(state)) {
        ast_cli(a->fd, "Failed to queue unregistration\n");
    } else if (queue_register(state)) {
        ast_cli(a->fd, "Failed to queue registration\n");
    }
 
    ao2_ref(state, -1);
    return CLI_SUCCESS;
}

References a, ao2_ref, ast_cli(), cli_complete_registration(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, get_state(), NULL, queue_register(), queue_unregister(), reregister_all(), state, and ast_cli_entry::usage.

cli_retrieve_by_id()

static void* cli_retrieve_by_id ( const char *  id )

static

Definition at line 2240 of file res_pjsip_outbound_registration.c.

{
    struct ao2_container *states;
    void *obj = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "registration", id);
 
    if (!obj) {
        /* if the object no longer exists then remove its state  */
        states = ao2_global_obj_ref(current_states);
        if (states) {
            ao2_find(states, id, OBJ_SEARCH_KEY | OBJ_UNLINK | OBJ_NODATA);
            ao2_ref(states, -1);
        }
    }
 
    return obj;
}

References ao2_find, ao2_global_obj_ref, ao2_ref, ast_sip_get_sorcery(), ast_sorcery_retrieve_by_id(), OBJ_NODATA, OBJ_SEARCH_KEY, and OBJ_UNLINK.

Referenced by load_module().

cli_unregister()

static char* cli_unregister ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1966 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_state *state;
    const char *registration_name;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "pjsip send unregister";
        e->usage =
            "Usage: pjsip send unregister <registration> | *all\n"
            "       Unregisters the specified (or all) outbound registration(s) "
            "and stops future registration attempts.\n";
        return NULL;
    case CLI_GENERATE:
        return cli_complete_registration(a->line, a->word, a->pos, a->n);
    }
 
    if (a->argc != 4) {
        return CLI_SHOWUSAGE;
    }
 
    registration_name = a->argv[3];
 
    if (strcmp(registration_name, "*all") == 0) {
        unregister_all();
        ast_cli(a->fd, "Unregister all queued\n");
        return CLI_SUCCESS;
    }
 
    state = get_state(registration_name);
    if (!state) {
        ast_cli(a->fd, "Unable to retrieve registration %s\n", registration_name);
        return CLI_FAILURE;
    }
 
    if (queue_unregister(state)) {
        ast_cli(a->fd, "Failed to queue unregistration\n");
    }
 
    ao2_ref(state, -1);
    return CLI_SUCCESS;
}

References a, ao2_ref, ast_cli(), cli_complete_registration(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, get_state(), NULL, queue_unregister(), state, unregister_all(), and ast_cli_entry::usage.

fetch_google_access_token()

static const char* fetch_google_access_token ( const struct ast_sip_auth *  auth )

static

Get google oauth2 access token using refresh token.

Definition at line 1483 of file res_pjsip_outbound_registration.c.

{
    char *cmd = NULL;
    const char *token;
    const char *url = "https://www.googleapis.com/oauth2/v3/token";
    char buf[4096];
    int res;
    struct ast_json_error error;
    struct ast_json *json;
 
    /* set timeout to be shorter than default 180s (also checks func_curl is available) */
    if (ast_func_write(NULL, "CURLOPT(conntimeout)", "10")) {
        ast_log(LOG_ERROR, "CURL is unavailable. This is required for Google OAuth 2.0 authentication. Please ensure it is loaded.\n");
        return NULL;
    }
 
    res = ast_asprintf(&cmd,
        "CURL(%s,client_id=%s&client_secret=%s&refresh_token=%s&grant_type=refresh_token)",
        url, auth->oauth_clientid, auth->oauth_secret, auth->refresh_token);
    if (res < 0) {
        return NULL;
    }
 
    ast_debug(2, "Performing Google OAuth 2.0 authentication using command: %s\n", cmd);
 
    buf[0] = '\0';
    res = ast_func_read(NULL, cmd, buf, sizeof(buf));
    ast_free(cmd);
    if (res) {
        ast_log(LOG_ERROR, "Could not retrieve Google OAuth 2.0 authentication\n");
        return NULL;
    }
 
    ast_debug(2, "Google OAuth 2.0 authentication returned: %s\n", buf);
 
    json = ast_json_load_string(buf, &error);
    if (!json) {
        ast_log(LOG_ERROR, "Could not parse Google OAuth 2.0 authentication: %d(%d) %s: '%s'\n",
            error.line, error.column, error.text, buf);
        return NULL;
    }
 
    token = ast_json_string_get(ast_json_object_get(json, "access_token"));
    if (!token) {
        ast_log(LOG_ERROR, "Could not find Google OAuth 2.0 access_token in: '%s'\n",
            buf);
    }
    token = ast_strdup(token);
    ast_json_unref(json);
    return token;
}

References ast_asprintf, ast_debug, ast_free, ast_func_read(), ast_func_write(), ast_json_load_string(), ast_json_object_get(), ast_json_string_get(), ast_json_unref(), ast_log, ast_strdup, buf, error(), LOG_ERROR, NULL, ast_sip_auth::oauth_clientid, ast_sip_auth::oauth_secret, ast_sip_auth::refresh_token, and url.

Referenced by set_outbound_initial_authentication_credentials().

get_registrations()

static struct ao2_container* get_registrations ( void  )

static

Definition at line 481 of file res_pjsip_outbound_registration.c.

{
    struct ao2_container *registrations = ast_sorcery_retrieve_by_fields(
        ast_sip_get_sorcery(), "registration",
        AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
 
    return registrations;
}

References AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sip_get_sorcery(), ast_sorcery_retrieve_by_fields(), NULL, and registrations.

Referenced by ami_show_outbound_registrations().

get_state()

static struct sip_outbound_registration_state* get_state ( const char *  id )

static

Definition at line 468 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_state *state = NULL;
    struct ao2_container *states;
 
    states = ao2_global_obj_ref(current_states);
    if (states) {
        state = ao2_find(states, id, OBJ_SEARCH_KEY);
        ao2_ref(states, -1);
    }
    return state;
}

References ao2_find, ao2_global_obj_ref, ao2_ref, NULL, OBJ_SEARCH_KEY, and state.

Referenced by ami_outbound_registration_task(), ami_register(), ami_unregister(), auth_observer(), cli_print_body(), cli_register(), cli_unregister(), and registration_transport_shutdown_cb().

get_uri_option_line()

static struct pjsip_param* get_uri_option_line ( const void *  uri )

static

Definition at line 499 of file res_pjsip_outbound_registration.c.

{
    pjsip_sip_uri *pjuri;
    static const pj_str_t LINE_STR = { "line", 4 };
 
    if (!PJSIP_URI_SCHEME_IS_SIP(uri) && !PJSIP_URI_SCHEME_IS_SIPS(uri)) {
        return NULL;
    }
    pjuri = pjsip_uri_get_uri(uri);
    return pjsip_param_find(&pjuri->other_param, &LINE_STR);
}

References NULL.

handle_client_registration()

static int handle_client_registration ( void *  data )

static

Callback function for registering.

Definition at line 668 of file res_pjsip_outbound_registration.c.

{
    RAII_VAR(struct sip_outbound_registration_client_state *, client_state, data, ao2_cleanup);
    pjsip_tx_data *tdata;
 
    if (set_outbound_initial_authentication_credentials(client_state->client, &client_state->outbound_auths)) {
        ast_log(LOG_WARNING, "Failed to set initial authentication credentials\n");
    }
 
    if (client_state->status == SIP_REGISTRATION_STOPPED
        || pjsip_regc_register(client_state->client, PJ_FALSE, &tdata) != PJ_SUCCESS) {
        return 0;
    }
 
    if (DEBUG_ATLEAST(1)) {
        pjsip_regc_info info;
 
        pjsip_regc_get_info(client_state->client, &info);
        ast_log(LOG_DEBUG, "Outbound REGISTER attempt %u to '%.*s' with client '%.*s'\n",
            client_state->retries + 1,
            (int) info.server_uri.slen, info.server_uri.ptr,
            (int) info.client_uri.slen, info.client_uri.ptr);
    }
 
    if (!add_configured_supported_headers(client_state, tdata)) {
        ast_log(LOG_WARNING, "Failed to set supported headers\n");
        return -1;
    }
 
    registration_client_send(client_state, tdata);
 
    return 0;
}

References add_configured_supported_headers(), ao2_cleanup, ast_log, DEBUG_ATLEAST, sip_to_pjsip::info(), LOG_DEBUG, LOG_WARNING, RAII_VAR, registration_client_send(), set_outbound_initial_authentication_credentials(), and SIP_REGISTRATION_STOPPED.

Referenced by reregister_immediately_cb(), and sip_outbound_registration_timer_cb().

handle_client_state_destruction()

static int handle_client_state_destruction ( void *  data )

static

Callback function for unregistering (potentially) and destroying state.

Definition at line 772 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_client_state *client_state = data;
 
    cancel_registration(client_state);
 
    if (client_state->client) {
        pjsip_regc_info info;
        pjsip_tx_data *tdata;
 
        pjsip_regc_get_info(client_state->client, &info);
 
        if (info.is_busy == PJ_TRUE) {
            /* If a client transaction is in progress we defer until it is complete */
            ast_debug(1,
                "Registration transaction is busy with server '%.*s' from client '%.*s'.\n",
                (int) info.server_uri.slen, info.server_uri.ptr,
                (int) info.client_uri.slen, info.client_uri.ptr);
            client_state->destroy = 1;
            ao2_ref(client_state, -1);
            return 0;
        }
 
        switch (client_state->status) {
        case SIP_REGISTRATION_UNREGISTERED:
            break;
        case SIP_REGISTRATION_REGISTERED:
            ast_debug(1,
                "Trying to unregister with server '%.*s' from client '%.*s' before destruction.\n",
                (int) info.server_uri.slen, info.server_uri.ptr,
                (int) info.client_uri.slen, info.client_uri.ptr);
 
            update_client_state_status(client_state, SIP_REGISTRATION_STOPPING);
            client_state->destroy = 1;
            if (pjsip_regc_unregister(client_state->client, &tdata) == PJ_SUCCESS
                && add_configured_supported_headers(client_state, tdata)
                && registration_client_send(client_state, tdata) == PJ_SUCCESS) {
                ao2_ref(client_state, -1);
                return 0;
            }
            break;
        case SIP_REGISTRATION_REJECTED_TEMPORARY:
        case SIP_REGISTRATION_REJECTED_PERMANENT:
        case SIP_REGISTRATION_STOPPING:
        case SIP_REGISTRATION_STOPPED:
            break;
        }
 
        pjsip_regc_destroy(client_state->client);
        client_state->client = NULL;
    }
 
    update_client_state_status(client_state, SIP_REGISTRATION_STOPPED);
    ast_sip_auth_vector_destroy(&client_state->outbound_auths);
    ao2_ref(client_state, -1);
 
    return 0;
}

References add_configured_supported_headers(), ao2_ref, ast_debug, ast_sip_auth_vector_destroy(), cancel_registration(), sip_outbound_registration_client_state::client, sip_outbound_registration_client_state::destroy, sip_to_pjsip::info(), NULL, sip_outbound_registration_client_state::outbound_auths, registration_client_send(), SIP_REGISTRATION_REGISTERED, SIP_REGISTRATION_REJECTED_PERMANENT, SIP_REGISTRATION_REJECTED_TEMPORARY, SIP_REGISTRATION_STOPPED, SIP_REGISTRATION_STOPPING, SIP_REGISTRATION_UNREGISTERED, sip_outbound_registration_client_state::status, and update_client_state_status().

Referenced by handle_registration_response(), and sip_outbound_registration_state_destroy().

handle_registration_response()

static int handle_registration_response ( void *  data )

static

Callback function for handling a response to a registration attempt.

Definition at line 1054 of file res_pjsip_outbound_registration.c.

{
    struct registration_response *response = data;
    pjsip_regc_info info;
    char server_uri[PJSIP_MAX_URL_SIZE];
    char client_uri[PJSIP_MAX_URL_SIZE];
 
    if (response->client_state->status == SIP_REGISTRATION_STOPPED) {
        ao2_ref(response, -1);
        return 0;
    }
 
    pjsip_regc_get_info(response->client_state->client, &info);
    ast_copy_pj_str(server_uri, &info.server_uri, sizeof(server_uri));
    ast_copy_pj_str(client_uri, &info.client_uri, sizeof(client_uri));
 
    ast_debug(1, "Processing REGISTER response %d from server '%s' for client '%s'\n",
            response->code, server_uri, client_uri);
 
    if (response->code == 408 || response->code == 503) {
        if ((ast_sip_failover_request(response->old_request))) {
            int res = registration_client_send(response->client_state, response->old_request);
            /* The tdata ref was stolen */
            response->old_request = NULL;
            if (res == PJ_SUCCESS) {
                ao2_ref(response, -1);
                return 0;
            }
        }
    } else if ((response->code == 401 || response->code == 407)
        && (!response->client_state->auth_attempted
            || response->rdata->msg_info.cseq->cseq != response->client_state->auth_cseq)) {
        int res;
        pjsip_cseq_hdr *cseq_hdr;
        pjsip_tx_data *tdata;
 
        if (!ast_sip_create_request_with_auth(&response->client_state->outbound_auths,
                response->rdata, response->old_request, &tdata)) {
            response->client_state->auth_attempted = 1;
            ast_debug(1, "Sending authenticated REGISTER to server '%s' from client '%s'\n",
                    server_uri, client_uri);
            pjsip_tx_data_add_ref(tdata);
            res = registration_client_send(response->client_state, tdata);
 
            /* Save the cseq that actually got sent. */
            cseq_hdr = (pjsip_cseq_hdr *) pjsip_msg_find_hdr(tdata->msg, PJSIP_H_CSEQ,
                NULL);
            response->client_state->auth_cseq = cseq_hdr->cseq;
            pjsip_tx_data_dec_ref(tdata);
            if (res == PJ_SUCCESS) {
                ao2_ref(response, -1);
                return 0;
            }
        } else {
            ast_log(LOG_WARNING, "Failed to create authenticated REGISTER request to server '%s' from client '%s'\n",
                    server_uri, client_uri);
        }
        /* Otherwise, fall through so the failure is processed appropriately */
    }
 
    response->client_state->auth_attempted = 0;
 
    if (PJSIP_IS_STATUS_IN_CLASS(response->code, 200)) {
        /* Check if this is in regards to registering or unregistering */
        if (response->expiration) {
            int next_registration_round;
 
            /* If the registration went fine simply reschedule registration for the future */
            ast_debug(1, "Outbound registration to '%s' with client '%s' successful\n", server_uri, client_uri);
            update_client_state_status(response->client_state, SIP_REGISTRATION_REGISTERED);
            response->client_state->retries = 0;
            next_registration_round = response->expiration - REREGISTER_BUFFER_TIME;
            if (next_registration_round < 0) {
                /* Re-register immediately. */
                next_registration_round = 0;
            }
            schedule_registration(response->client_state, next_registration_round);
 
            /* See if we should monitor for transport shutdown */
            registration_transport_monitor_setup(response->rdata->tp_info.transport,
                response->client_state->registration_name);
        } else {
            ast_debug(1, "Outbound unregistration to '%s' with client '%s' successful\n", server_uri, client_uri);
            update_client_state_status(response->client_state, SIP_REGISTRATION_UNREGISTERED);
            ast_sip_transport_monitor_unregister(response->rdata->tp_info.transport,
                registration_transport_shutdown_cb, response->client_state->registration_name,
                monitor_matcher);
        }
 
        save_response_fields_to_transport(response);
    } else if (response->client_state->destroy) {
        /* We need to deal with the pending destruction instead. */
    } else if (response->retry_after) {
        /* If we have been instructed to retry after a period of time, schedule it as such */
        schedule_retry(response, response->retry_after, server_uri, client_uri);
    } else if (response->client_state->retry_interval
        && sip_outbound_registration_is_temporal(response->code, response->client_state)) {
        if (response->client_state->retries == response->client_state->max_retries) {
            /* If we received enough temporal responses to exceed our maximum give up permanently */
            update_client_state_status(response->client_state, SIP_REGISTRATION_REJECTED_PERMANENT);
            ast_log(LOG_WARNING, "Maximum retries reached when attempting outbound registration to '%s' with client '%s', stopping registration attempt\n",
                server_uri, client_uri);
        } else {
            /* On the other hand if we can still try some more do so */
            response->client_state->retries++;
            schedule_retry(response, response->client_state->retry_interval, server_uri, client_uri);
        }
    } else {
        if (response->code == 403
            && response->client_state->forbidden_retry_interval
            && response->client_state->retries < response->client_state->max_retries) {
            /* A forbidden response retry interval is configured and there are retries remaining */
            update_client_state_status(response->client_state, SIP_REGISTRATION_REJECTED_TEMPORARY);
            response->client_state->retries++;
            schedule_registration(response->client_state, response->client_state->forbidden_retry_interval);
            ast_log(LOG_WARNING, "403 Forbidden fatal response received from '%s' on registration attempt to '%s', retrying in '%u' seconds\n",
                server_uri, client_uri, response->client_state->forbidden_retry_interval);
        } else if (response->client_state->fatal_retry_interval
               && response->client_state->retries < response->client_state->max_retries) {
            /* Some kind of fatal failure response received, so retry according to configured interval */
            update_client_state_status(response->client_state, SIP_REGISTRATION_REJECTED_TEMPORARY);
            response->client_state->retries++;
            schedule_registration(response->client_state, response->client_state->fatal_retry_interval);
            ast_log(LOG_WARNING, "'%d' fatal response received from '%s' on registration attempt to '%s', retrying in '%u' seconds\n",
                response->code, server_uri, client_uri, response->client_state->fatal_retry_interval);
        } else {
            /* Finally if there's no hope of registering give up */
            update_client_state_status(response->client_state, SIP_REGISTRATION_REJECTED_PERMANENT);
            if (response->rdata) {
                ast_log(LOG_WARNING, "Fatal response '%d' received from '%s' on registration attempt to '%s', stopping outbound registration\n",
                    response->code, server_uri, client_uri);
            } else {
                ast_log(LOG_WARNING, "Fatal registration attempt to '%s', stopping outbound registration\n", client_uri);
            }
        }
    }
 
    ast_system_publish_registry("PJSIP", client_uri, server_uri,
        sip_outbound_registration_status_str(response->client_state->status), NULL);
 
    if (response->client_state->destroy) {
        /* We have a pending deferred destruction to complete now. */
        ao2_ref(response->client_state, +1);
        handle_client_state_destruction(response->client_state);
    }
 
    ao2_ref(response, -1);
    return 0;
}

References ao2_ref, ast_copy_pj_str(), ast_debug, ast_log, ast_sip_create_request_with_auth(), ast_sip_failover_request(), ast_sip_transport_monitor_unregister(), ast_system_publish_registry(), sip_outbound_registration_client_state::auth_attempted, sip_outbound_registration_client_state::auth_cseq, sip_outbound_registration_client_state::client, registration_response::client_state, registration_response::code, sip_outbound_registration_client_state::destroy, registration_response::expiration, sip_outbound_registration_client_state::fatal_retry_interval, sip_outbound_registration_client_state::forbidden_retry_interval, handle_client_state_destruction(), sip_to_pjsip::info(), LOG_WARNING, sip_outbound_registration_client_state::max_retries, monitor_matcher(), NULL, registration_response::old_request, sip_outbound_registration_client_state::outbound_auths, registration_response::rdata, registration_client_send(), sip_outbound_registration_client_state::registration_name, registration_transport_monitor_setup(), registration_transport_shutdown_cb(), REREGISTER_BUFFER_TIME, sip_outbound_registration_client_state::retries, registration_response::retry_after, sip_outbound_registration_client_state::retry_interval, save_response_fields_to_transport(), schedule_registration(), schedule_retry(), server_uri, sip_outbound_registration_is_temporal(), sip_outbound_registration_status_str(), SIP_REGISTRATION_REGISTERED, SIP_REGISTRATION_REJECTED_PERMANENT, SIP_REGISTRATION_REJECTED_TEMPORARY, SIP_REGISTRATION_STOPPED, SIP_REGISTRATION_UNREGISTERED, sip_outbound_registration_client_state::status, and update_client_state_status().

Referenced by sip_outbound_registration_response_cb().

line_identify()

static struct ast_sip_endpoint* line_identify ( pjsip_rx_data *  rdata )

static

Endpoint identifier which uses the 'line' parameter to establish a relationship to an outgoing registration.

Definition at line 512 of file res_pjsip_outbound_registration.c.

{
    pjsip_param *line;
    RAII_VAR(struct ao2_container *, states, NULL, ao2_cleanup);
    RAII_VAR(struct sip_outbound_registration_state *, state, NULL, ao2_cleanup);
 
    if (!(line = get_uri_option_line(rdata->msg_info.to->uri))
        && !(line = get_uri_option_line(rdata->msg_info.msg->line.req.uri))) {
        return NULL;
    }
 
    states = ao2_global_obj_ref(current_states);
    if (!states) {
        return NULL;
    }
 
    state = ao2_callback(states, 0, line_identify_relationship, line);
    if (!state || ast_strlen_zero(state->registration->endpoint)) {
        return NULL;
    }
 
    ast_debug(3, "Determined relationship to outbound registration '%s' based on line '%s', using configured endpoint '%s'\n",
        ast_sorcery_object_get_id(state->registration), state->client_state->line, state->registration->endpoint);
 
    return ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", state->registration->endpoint);
}

line_identify_relationship()

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

static

Callback function for matching an outbound registration based on line.

Definition at line 491 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_state *state = obj;
    pjsip_param *line = arg;
 
    return !pj_strcmp2(&line->value, state->client_state->line) ? CMP_MATCH : 0;
}

References CMP_MATCH.

load_module()

static int load_module ( void  )

static

Definition at line 2504 of file res_pjsip_outbound_registration.c.

{
    struct ao2_container *new_states;
 
    shutdown_group = ast_serializer_shutdown_group_alloc();
    if (!shutdown_group) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    /* Create outbound registration states container. */
    new_states = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        DEFAULT_STATE_BUCKETS, registration_state_hash, NULL, registration_state_cmp);
    if (!new_states) {
        ast_log(LOG_ERROR, "Unable to allocate registration states container\n");
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
    ao2_global_obj_replace_unref(current_states, new_states);
    ao2_ref(new_states, -1);
 
    /*
     * Register sorcery object descriptions.
     */
    ast_sorcery_apply_config(ast_sip_get_sorcery(), "res_pjsip_outbound_registration");
    ast_sorcery_apply_default(ast_sip_get_sorcery(), "registration", "config", "pjsip.conf,criteria=type=registration");
 
    if (ast_sorcery_object_register(ast_sip_get_sorcery(), "registration", sip_outbound_registration_alloc, NULL, sip_outbound_registration_apply)) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "type", "", OPT_NOOP_T, 0, 0);
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "server_uri", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct sip_outbound_registration, server_uri));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "client_uri", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct sip_outbound_registration, client_uri));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "contact_user", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct sip_outbound_registration, contact_user));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "contact_header_params", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct sip_outbound_registration, contact_header_params));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "transport", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct sip_outbound_registration, transport));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "outbound_proxy", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct sip_outbound_registration, outbound_proxy));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "expiration", "3600", OPT_UINT_T, 0, FLDSET(struct sip_outbound_registration, expiration));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "retry_interval", "60", OPT_UINT_T, 0, FLDSET(struct sip_outbound_registration, retry_interval));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "forbidden_retry_interval", "0", OPT_UINT_T, 0, FLDSET(struct sip_outbound_registration, forbidden_retry_interval));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "fatal_retry_interval", "0", OPT_UINT_T, 0, FLDSET(struct sip_outbound_registration, fatal_retry_interval));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "max_retries", "10", OPT_UINT_T, 0, FLDSET(struct sip_outbound_registration, max_retries));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "auth_rejection_permanent", "yes", OPT_BOOL_T, 1, FLDSET(struct sip_outbound_registration, auth_rejection_permanent));
    ast_sorcery_object_field_register_custom(ast_sip_get_sorcery(), "registration", "outbound_auth", "", outbound_auth_handler, outbound_auths_to_str, outbound_auths_to_var_list, 0, 0);
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "support_path", "no", OPT_BOOL_T, 1, FLDSET(struct sip_outbound_registration, support_path));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "support_outbound", "no", OPT_YESNO_T, 1, FLDSET(struct sip_outbound_registration, support_outbound));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "line", "no", OPT_BOOL_T, 1, FLDSET(struct sip_outbound_registration, line));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "registration", "endpoint", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct sip_outbound_registration, endpoint));
 
    /*
     * Register sorcery observers.
     */
    if (ast_sorcery_instance_observer_add(ast_sip_get_sorcery(),
        &observer_callbacks_registrations)
        || ast_sorcery_observer_add(ast_sip_get_sorcery(), "auth",
            &observer_callbacks_auth)
        || ast_sorcery_observer_add(ast_sip_get_sorcery(), "registration",
            &registration_observer)) {
        ast_log(LOG_ERROR, "Unable to register observers.\n");
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    /* Register how this module identifies endpoints. */
    ast_sip_register_endpoint_identifier(&line_identifier);
 
    /* Register CLI commands. */
    cli_formatter = ao2_alloc(sizeof(struct ast_sip_cli_formatter_entry), NULL);
    if (!cli_formatter) {
        ast_log(LOG_ERROR, "Unable to allocate memory for cli formatter\n");
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
    cli_formatter->name = "registration";
    cli_formatter->print_header = cli_print_header;
    cli_formatter->print_body = cli_print_body;
    cli_formatter->get_container = cli_get_container;
    cli_formatter->iterate = cli_iterator;
    cli_formatter->get_id = ast_sorcery_object_get_id;
    cli_formatter->retrieve_by_id = cli_retrieve_by_id;
    ast_sip_register_cli_formatter(cli_formatter);
    ast_cli_register_multiple(cli_outbound_registration, ARRAY_LEN(cli_outbound_registration));
 
    /* Register AMI actions. */
    ast_manager_register_xml("PJSIPUnregister", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, ami_unregister);
    ast_manager_register_xml("PJSIPRegister", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, ami_register);
    ast_manager_register_xml("PJSIPShowRegistrationsOutbound", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING, ami_show_outbound_registrations);
 
    /* Clear any previous statsd gauges in case we weren't shutdown cleanly */
    ast_statsd_log("PJSIP.registrations.count", AST_STATSD_GAUGE, 0);
    ast_statsd_log("PJSIP.registrations.state.Registered", AST_STATSD_GAUGE, 0);
    ast_statsd_log("PJSIP.registrations.state.Unregistered", AST_STATSD_GAUGE, 0);
    ast_statsd_log("PJSIP.registrations.state.Rejected", AST_STATSD_GAUGE, 0);
 
    /* Load configuration objects */
    ast_sorcery_load_object(ast_sip_get_sorcery(), "registration");
 
    network_change_sub = stasis_subscribe(ast_system_topic(),
        network_change_stasis_cb, NULL);
    stasis_subscription_accept_message_type(network_change_sub, ast_network_change_type());
    stasis_subscription_set_filter(network_change_sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ami_register(), ami_show_outbound_registrations(), ami_unregister(), ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_global_obj_replace_unref, ao2_ref, ARRAY_LEN, ast_cli_register_multiple, ast_log, ast_manager_register_xml, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_network_change_type(), ast_serializer_shutdown_group_alloc(), ast_sip_get_sorcery(), ast_sip_register_cli_formatter(), ast_sip_register_endpoint_identifier(), ast_sorcery_apply_config, ast_sorcery_apply_default, ast_sorcery_instance_observer_add(), ast_sorcery_load_object(), ast_sorcery_object_field_register, ast_sorcery_object_field_register_custom, ast_sorcery_object_get_id(), ast_sorcery_object_register, ast_sorcery_observer_add(), AST_STATSD_GAUGE, ast_statsd_log(), ast_system_topic(), cli_formatter, cli_get_container(), cli_iterator(), cli_outbound_registration, cli_print_body(), cli_print_header(), cli_retrieve_by_id(), DEFAULT_STATE_BUCKETS, EVENT_FLAG_REPORTING, EVENT_FLAG_SYSTEM, FLDSET, ast_sip_cli_formatter_entry::get_container, ast_sip_cli_formatter_entry::get_id, ast_sip_cli_formatter_entry::iterate, line_identifier, LOG_ERROR, max_retries, ast_sip_cli_formatter_entry::name, network_change_stasis_cb(), network_change_sub, new_states, NULL, observer_callbacks_auth, observer_callbacks_registrations, OPT_BOOL_T, OPT_NOOP_T, OPT_STRINGFIELD_T, OPT_UINT_T, OPT_YESNO_T, outbound_auth_handler(), outbound_auths_to_str(), outbound_auths_to_var_list(), ast_sip_cli_formatter_entry::print_body, ast_sip_cli_formatter_entry::print_header, registration_observer, registration_state_cmp(), registration_state_hash(), ast_sip_cli_formatter_entry::retrieve_by_id, server_uri, shutdown_group, sip_outbound_registration_alloc(), sip_outbound_registration_apply(), stasis_subscribe, stasis_subscription_accept_message_type(), STASIS_SUBSCRIPTION_FILTER_SELECTIVE, stasis_subscription_set_filter(), STRFLDSET, and unload_module().

monitor_matcher()

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

static

Definition at line 952 of file res_pjsip_outbound_registration.c.

{
    char *ma = a;
    char *mb = b;
 
    return strcmp(ma, mb) == 0;
}

References a, and b.

Referenced by handle_registration_response().

my_cli_traverse_objects()

static char* my_cli_traverse_objects ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 2304 of file res_pjsip_outbound_registration.c.

{
    return ast_sip_cli_traverse_objects(e, cmd, a);
}

network_change_stasis_cb()

static void network_change_stasis_cb ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Definition at line 2446 of file res_pjsip_outbound_registration.c.

{
    /* This callback is only concerned with network change messages from the system topic. */
    if (stasis_message_type(message) != ast_network_change_type()) {
        return;
    }
    ast_debug(3, "Received network change event\n");
 
    reregister_all();
}

References ast_debug, ast_network_change_type(), reregister_all(), and stasis_message_type().

Referenced by load_module().

outbound_auth_handler()

static int outbound_auth_handler ( const struct aco_option *  opt, struct ast_variable *  var, void *  obj  )

static

Definition at line 1826 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration *registration = obj;
 
    return ast_sip_auth_vector_init(&registration->outbound_auths, var->value);
}

References ast_sip_auth_vector_init(), sip_outbound_registration::outbound_auths, and var.

Referenced by load_module().

outbound_auths_to_str()

static int outbound_auths_to_str ( const void *  obj, const intptr_t *  args, char **  buf  )

static

Definition at line 1833 of file res_pjsip_outbound_registration.c.

{
    const struct sip_outbound_registration *registration = obj;
 
    return ast_sip_auths_to_str(&registration->outbound_auths, buf);
}

References ast_sip_auths_to_str(), buf, and sip_outbound_registration::outbound_auths.

Referenced by load_module().

outbound_auths_to_var_list()

static int outbound_auths_to_var_list ( const void *  obj, struct ast_variable **  fields  )

static

Definition at line 1840 of file res_pjsip_outbound_registration.c.

{
    const struct sip_outbound_registration *registration = obj;
    int i;
    struct ast_variable *head = NULL;
 
    for (i = 0; i < AST_VECTOR_SIZE(&registration->outbound_auths) ; i++) {
        ast_variable_list_append(&head, ast_variable_new("outbound_auth",
            AST_VECTOR_GET(&registration->outbound_auths, i), ""));
    }
 
    if (head) {
        *fields = head;
    }
 
    return 0;
}

References ast_variable_list_append, ast_variable_new, AST_VECTOR_GET, AST_VECTOR_SIZE, NULL, and sip_outbound_registration::outbound_auths.

Referenced by load_module().

queue_register()

static int queue_register ( struct sip_outbound_registration_state *  state )

static

Definition at line 1891 of file res_pjsip_outbound_registration.c.

{
    ao2_ref(state, +1);
    if (ast_sip_push_task(state->client_state->serializer, sip_outbound_registration_perform, state)) {
        ao2_ref(state, -1);
        return -1;
    }
 
    return 0;
}

References ao2_ref, ast_sip_push_task(), and sip_outbound_registration_perform().

Referenced by ami_register(), and cli_register().

queue_unregister()

static int queue_unregister ( struct sip_outbound_registration_state *  state )

static

Definition at line 1880 of file res_pjsip_outbound_registration.c.

{
    ao2_ref(state, +1);
    if (ast_sip_push_task(state->client_state->serializer, unregister_task, state)) {
        ao2_ref(state, -1);
        return -1;
    }
 
    return 0;
}

References ao2_ref, ast_sip_push_task(), and unregister_task().

Referenced by ami_register(), ami_unregister(), cli_register(), and cli_unregister().

registration_client_send()

static pj_status_t registration_client_send ( struct sip_outbound_registration_client_state *  client_state, pjsip_tx_data *  tdata  )

static

Helper function which sends a message and cleans up, if needed, on failure.

Definition at line 557 of file res_pjsip_outbound_registration.c.

{
    pj_status_t status;
    int *callback_invoked;
    pjsip_tpselector selector = { .type = PJSIP_TPSELECTOR_NONE, };
 
    callback_invoked = ast_threadstorage_get(&register_callback_invoked, sizeof(int));
    if (!callback_invoked) {
        pjsip_tx_data_dec_ref(tdata);
        return PJ_ENOMEM;
    }
    *callback_invoked = 0;
 
    /* Due to the message going out the callback may now be invoked, so bump the count */
    ao2_ref(client_state, +1);
    /*
     * We also bump tdata in expectation of saving it to client_state->last_tdata.
     * We have to do it BEFORE pjsip_regc_send because if it succeeds, it decrements
     * the ref count on its own.
     */
    pjsip_tx_data_add_ref(tdata);
 
    /*
     * Set the transport in case transports were reloaded.
     * When pjproject removes the extraneous error messages produced,
     * we can check status and only set the transport and resend if there was an error
     */
    ast_sip_set_tpselector_from_transport_name(client_state->transport_name, &selector);
    pjsip_regc_set_transport(client_state->client, &selector);
    ast_sip_tpselector_unref(&selector);
 
    status = pjsip_regc_send(client_state->client, tdata);
 
    /*
     * If the attempt to send the message failed and the callback was not invoked we need to
     * drop the references we just added
     */
    if ((status != PJ_SUCCESS) && !(*callback_invoked)) {
        pjsip_tx_data_dec_ref(tdata);
        ao2_ref(client_state, -1);
        return status;
    }
 
    /*
     * Decref the old last_data before replacing it.
     * BTW, it's quite possible that last_data == tdata
     * if we're trying successive servers in an SRV set.
     */
    if (client_state->last_tdata) {
        pjsip_tx_data_dec_ref(client_state->last_tdata);
    }
    client_state->last_tdata = tdata;
 
    return status;
}

References ao2_ref, ast_sip_set_tpselector_from_transport_name(), ast_sip_tpselector_unref(), ast_threadstorage_get(), sip_outbound_registration_client_state::client, sip_outbound_registration_client_state::last_tdata, register_callback_invoked, status, and sip_outbound_registration_client_state::transport_name.

Referenced by handle_client_registration(), handle_client_state_destruction(), handle_registration_response(), and unregister_task().

registration_deleted_observer()

static void registration_deleted_observer ( const void *  obj )

static

Definition at line 2426 of file res_pjsip_outbound_registration.c.

{
    const struct sip_outbound_registration *registration = obj;
    struct ao2_container *states;
 
    states = ao2_global_obj_ref(current_states);
    if (!states) {
        /* Global container has gone.  Likely shutting down. */
        return;
    }
 
    ao2_find(states, ast_sorcery_object_get_id(registration), OBJ_UNLINK | OBJ_NODATA | OBJ_SEARCH_KEY);
 
    ao2_ref(states, -1);
}

References ao2_find, ao2_global_obj_ref, ao2_ref, ast_sorcery_object_get_id(), OBJ_NODATA, OBJ_SEARCH_KEY, and OBJ_UNLINK.

registration_loaded_observer()

static void registration_loaded_observer ( const char *  name, const struct ast_sorcery *  sorcery, const char *  object_type, int  reloaded  )

static

Definition at line 2395 of file res_pjsip_outbound_registration.c.

{
    struct ao2_container *states;
 
    if (strcmp(object_type, "registration")) {
        /* Not interested */
        return;
    }
 
    states = ao2_global_obj_ref(current_states);
    if (!states) {
        /* Global container has gone.  Likely shutting down. */
        return;
    }
 
    /*
     * Refresh the current configured registrations. We don't need to hold
     * onto the objects, as the apply handler will cause their states to
     * be created appropriately.
     */
    ao2_cleanup(get_registrations());
 
    /* Now to purge dead registrations. */
    ao2_callback(states, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, check_state, NULL);
    ao2_ref(states, -1);
}

registration_response_destroy()

static void registration_response_destroy ( void *  obj )

static

Registration response structure destructor.

Definition at line 848 of file res_pjsip_outbound_registration.c.

{
    struct registration_response *response = obj;
 
    if (response->rdata) {
        pjsip_rx_data_free_cloned(response->rdata);
    }
 
    if (response->old_request) {
        pjsip_tx_data_dec_ref(response->old_request);
    }
 
    ao2_cleanup(response->client_state);
}

References ao2_cleanup, registration_response::client_state, registration_response::old_request, and registration_response::rdata.

Referenced by sip_outbound_registration_response_cb().

registration_state_cmp()

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

static

comparator function for state objects

Definition at line 440 of file res_pjsip_outbound_registration.c.

{
    const struct sip_outbound_registration_state *object_left = obj;
    const struct sip_outbound_registration_state *object_right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = ast_sorcery_object_get_id(object_right->registration);
        /* Fall through */
    case OBJ_SEARCH_KEY:
        cmp = strcmp(ast_sorcery_object_get_id(object_left->registration), right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        /* Not supported by container. */
        ast_assert(0);
        return 0;
    default:
        cmp = 0;
        break;
    }
    if (cmp) {
        return 0;
    }
    return CMP_MATCH;
}

References ast_assert, ast_sorcery_object_get_id(), CMP_MATCH, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, and sip_outbound_registration_state::registration.

Referenced by load_module().

registration_state_hash()

static int registration_state_hash ( const void *  obj, const int  flags  )

static

hashing function for state objects

Definition at line 419 of file res_pjsip_outbound_registration.c.

{
    const struct sip_outbound_registration_state *object;
    const char *key;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_KEY:
        key = obj;
        break;
    case OBJ_SEARCH_OBJECT:
        object = obj;
        key = ast_sorcery_object_get_id(object->registration);
        break;
    default:
        ast_assert(0);
        return 0;
    }
    return ast_str_hash(key);
}

References ast_assert, ast_sorcery_object_get_id(), ast_str_hash(), OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and sip_outbound_registration_state::registration.

Referenced by load_module().

registration_transport_monitor_setup()

static void registration_transport_monitor_setup ( pjsip_transport *  transport, const char *  registration_name  )

static

Definition at line 960 of file res_pjsip_outbound_registration.c.

{
    char *monitor;
 
    if (!PJSIP_TRANSPORT_IS_RELIABLE(transport)) {
        return;
    }
    monitor = ao2_alloc_options(strlen(registration_name) + 1, NULL,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!monitor) {
        return;
    }
    strcpy(monitor, registration_name);/* Safe */
 
    /*
     * We'll ignore if the transport has already been shutdown before we
     * register the monitor.  We might get into a message spamming infinite
     * loop of registration, shutdown, reregistration...
     */
    ast_sip_transport_monitor_register(transport, registration_transport_shutdown_cb,
        monitor);
    ao2_ref(monitor, -1);
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_sip_transport_monitor_register(), NULL, and registration_transport_shutdown_cb().

Referenced by handle_registration_response().

registration_transport_shutdown_cb()

static void registration_transport_shutdown_cb ( void *  obj )

static

Definition at line 937 of file res_pjsip_outbound_registration.c.

{
    const char *registration_name = obj;
    struct sip_outbound_registration_state *state;
 
    state = get_state(registration_name);
    if (!state) {
        /* Registration no longer exists or shutting down. */
        return;
    }
    if (ast_sip_push_task(state->client_state->serializer, reregister_immediately_cb, state)) {
        ao2_ref(state, -1);
    }
}

References ao2_ref, ast_sip_push_task(), get_state(), reregister_immediately_cb(), and state.

Referenced by handle_registration_response(), registration_transport_monitor_setup(), and unload_module().

reload_module()

static int reload_module ( void  )

static

Definition at line 2610 of file res_pjsip_outbound_registration.c.

{
    ast_sorcery_reload_object(ast_sip_get_sorcery(), "registration");
    return 0;
}

reregister_all()

static void reregister_all ( void  )

static

Definition at line 1916 of file res_pjsip_outbound_registration.c.

{
    unregister_all();
    ast_sorcery_load_object(ast_sip_get_sorcery(), "registration");
}

References ast_sip_get_sorcery(), ast_sorcery_load_object(), and unregister_all().

Referenced by ami_register(), cli_register(), and network_change_stasis_cb().

reregister_immediately_cb()

static int reregister_immediately_cb ( void *  obj )

static

Definition at line 900 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_state *state = obj;
 
    if (state->client_state->status != SIP_REGISTRATION_REGISTERED) {
        ao2_ref(state, -1);
        return 0;
    }
 
    if (DEBUG_ATLEAST(1)) {
        pjsip_regc_info info;
 
        pjsip_regc_get_info(state->client_state->client, &info);
        ast_log(LOG_DEBUG,
            "Outbound registration transport to server '%.*s' from client '%.*s' shutdown\n",
            (int) info.server_uri.slen, info.server_uri.ptr,
            (int) info.client_uri.slen, info.client_uri.ptr);
    }
 
    cancel_registration(state->client_state);
 
    ao2_ref(state->client_state, +1);
    handle_client_registration(state->client_state);
 
    ao2_ref(state, -1);
    return 0;
}

References ao2_ref, ast_log, cancel_registration(), DEBUG_ATLEAST, handle_client_registration(), sip_to_pjsip::info(), LOG_DEBUG, and SIP_REGISTRATION_REGISTERED.

Referenced by registration_transport_shutdown_cb().

save_response_fields_to_transport()

static void save_response_fields_to_transport ( struct registration_response *  response )

static

Definition at line 984 of file res_pjsip_outbound_registration.c.

{
    static const pj_str_t associated_uri_str = { "P-Associated-URI", 16 };
    static const pj_str_t service_route_str = { "Service-Route", 13 };
    pjsip_hdr *header = NULL;
    pjsip_msg *msg = response->rdata->msg_info.msg;
    struct ast_sip_service_route_vector *service_routes = NULL;
 
    /* If no transport is specified then we can't update any */
    if (ast_strlen_zero(response->client_state->transport_name)) {
        return;
    }
 
    ast_sip_transport_state_set_transport(response->client_state->transport_name, response->rdata->tp_info.transport);
 
    while ((header = pjsip_msg_find_hdr_by_name(msg, &service_route_str, header ? header->next : NULL))) {
        char *service_route;
        size_t size;
 
        /* The below code takes the approach that if we can't store all service routes then we
         * store none at all. This gives a predictable failure condition instead of storing a
         * partial list and having partial route headers.
         */
        size = pj_strlen(&((pjsip_generic_string_hdr*)header)->hvalue) + 1;
        service_route = ast_malloc(size);
        if (!service_route) {
            if (service_routes) {
                ast_sip_service_route_vector_destroy(service_routes);
                service_routes = NULL;
            }
            break;
        }
 
        ast_copy_pj_str(service_route, &((pjsip_generic_string_hdr*)header)->hvalue, size);
 
        if (!service_routes) {
            service_routes = ast_sip_service_route_vector_alloc();
            if (!service_routes) {
                ast_free(service_route);
                break;
            }
        }
 
        if (AST_VECTOR_APPEND(service_routes, service_route)) {
            ast_free(service_route);
            ast_sip_service_route_vector_destroy(service_routes);
            service_routes = NULL;
            break;
        }
    }
 
    /* If any service routes were handled then store them on the transport */
    if (service_routes) {
        ast_sip_transport_state_set_service_routes(response->client_state->transport_name, service_routes);
    }
 
    /* If an associated URI is present in the response we need to use it on any outgoing
     * traffic on the transport.
     */
    header = pjsip_msg_find_hdr_by_name(msg, &associated_uri_str, NULL);
    if (header) {
        char value[pj_strlen(&((pjsip_generic_string_hdr*)header)->hvalue) + 1];
 
        ast_copy_pj_str(value, &((pjsip_generic_string_hdr*)header)->hvalue, sizeof(value));
        ast_sip_transport_state_set_preferred_identity(response->client_state->transport_name, value);
    }
}

References ast_copy_pj_str(), ast_free, ast_malloc, ast_sip_service_route_vector_alloc(), ast_sip_service_route_vector_destroy(), ast_sip_transport_state_set_preferred_identity(), ast_sip_transport_state_set_service_routes(), ast_sip_transport_state_set_transport(), ast_strlen_zero(), AST_VECTOR_APPEND, registration_response::client_state, header::next, NULL, registration_response::rdata, sip_outbound_registration_client_state::transport_name, and value.

Referenced by handle_registration_response().

schedule_registration()

static void schedule_registration ( struct sip_outbound_registration_client_state *  client_state, unsigned int  seconds  )

static

Helper function which sets up the timer to re-register in a specific amount of time.

Definition at line 721 of file res_pjsip_outbound_registration.c.

{
    pj_time_val delay = { .sec = seconds, };
    pjsip_regc_info info;
 
    cancel_registration(client_state);
 
    pjsip_regc_get_info(client_state->client, &info);
    ast_debug(1, "Scheduling outbound registration to server '%.*s' from client '%.*s' in %d seconds\n",
            (int) info.server_uri.slen, info.server_uri.ptr,
            (int) info.client_uri.slen, info.client_uri.ptr,
            seconds);
 
    ao2_ref(client_state, +1);
    if (pjsip_endpt_schedule_timer(ast_sip_get_pjsip_endpoint(), &client_state->timer, &delay) != PJ_SUCCESS) {
        ast_log(LOG_WARNING, "Failed to schedule registration to server '%.*s' from client '%.*s'\n",
                (int) info.server_uri.slen, info.server_uri.ptr,
                (int) info.client_uri.slen, info.client_uri.ptr);
        ao2_ref(client_state, -1);
    }
}

References ao2_ref, ast_debug, ast_log, ast_sip_get_pjsip_endpoint(), cancel_registration(), sip_outbound_registration_client_state::client, sip_to_pjsip::info(), LOG_WARNING, and sip_outbound_registration_client_state::timer.

Referenced by handle_registration_response(), schedule_retry(), and sip_outbound_registration_perform().

schedule_retry()

static void schedule_retry ( struct registration_response *  response, unsigned int  interval, const char *  server_uri, const char *  client_uri  )

static

Definition at line 883 of file res_pjsip_outbound_registration.c.

{
    update_client_state_status(response->client_state, SIP_REGISTRATION_REJECTED_TEMPORARY);
    schedule_registration(response->client_state, interval);
 
    if (response->rdata) {
        ast_log(LOG_WARNING, "Temporal response '%d' received from '%s' on "
            "registration attempt to '%s', retrying in '%u'\n",
            response->code, server_uri, client_uri, interval);
    } else {
        ast_log(LOG_WARNING, "No response received from '%s' on "
            "registration attempt to '%s', retrying in '%u'\n",
            server_uri, client_uri, interval);
    }
}

References ast_log, registration_response::client_state, registration_response::code, LOG_WARNING, registration_response::rdata, schedule_registration(), server_uri, SIP_REGISTRATION_REJECTED_TEMPORARY, and update_client_state_status().

Referenced by handle_registration_response().

set_outbound_initial_authentication_credentials()

static int set_outbound_initial_authentication_credentials ( pjsip_regc *  regc, const struct ast_sip_auth_vector *  auth_vector  )

static

Definition at line 1543 of file res_pjsip_outbound_registration.c.

{
    size_t auth_size = AST_VECTOR_SIZE(auth_vector);
    struct ast_sip_auth *auths[auth_size];
    const char *access_token;
    pjsip_cred_info auth_creds[1];
    pjsip_auth_clt_pref prefs;
    int res = 0;
    int idx;
 
    memset(auths, 0, sizeof(auths));
    if (ast_sip_retrieve_auths(auth_vector, auths)) {
        res = -1;
        goto cleanup;
    }
 
    for (idx = 0; idx < auth_size; ++idx) {
        switch (auths[idx]->type) {
        case AST_SIP_AUTH_TYPE_GOOGLE_OAUTH:
            pj_cstr(&auth_creds[0].username, auths[idx]->auth_user);
            pj_cstr(&auth_creds[0].scheme, "Bearer");
            pj_cstr(&auth_creds[0].realm, auths[idx]->realm);
            ast_debug(2, "Obtaining Google OAuth access token\n");
            access_token = fetch_google_access_token(auths[idx]);
            if (!access_token) {
                ast_log(LOG_WARNING, "Obtaining Google OAuth access token failed\n");
                access_token = auths[idx]->auth_pass;
                res = -1;
            }
            ast_debug(2, "Setting data to '%s'\n", access_token);
 
            pj_cstr(&auth_creds[0].data, access_token);
            auth_creds[0].data_type = PJSIP_CRED_DATA_PLAIN_PASSWD;
 
            pjsip_regc_set_credentials(regc, 1, auth_creds);
 
            /* for oauth, send auth without waiting for unauthorized response */
            prefs.initial_auth = PJ_TRUE;
            pj_cstr(&prefs.algorithm, "oauth");
            pjsip_regc_set_prefs(regc, &prefs);
 
            if (access_token != auths[idx]->auth_pass) {
                ast_free((char *) access_token);
            }
            break;
        default:
            /* other cases handled after receiving auth rejection */
            break;
        }
    }
 
cleanup:
    ast_sip_cleanup_auths(auths, auth_size);
    return res;
}

References ast_debug, ast_free, ast_log, AST_SIP_AUTH_TYPE_GOOGLE_OAUTH, ast_sip_cleanup_auths(), ast_sip_retrieve_auths(), AST_VECTOR_SIZE, ast_sip_auth::auth_pass, ast_sip_auth::auth_user, cleanup(), fetch_google_access_token(), LOG_WARNING, ast_sip_auth::realm, and type.

Referenced by handle_client_registration().

sip_dialog_create_contact()

static int sip_dialog_create_contact ( pj_pool_t *  pool, pj_str_t *  contact, const char *  user, const pj_str_t *  target, pjsip_tpselector *  selector, const char *  line, const char *  header_params  )

static

Helper function which populates a pj_str_t with a contact header.

Definition at line 1386 of file res_pjsip_outbound_registration.c.

{
    pj_str_t tmp, local_addr;
    pjsip_uri *uri;
    pjsip_sip_uri *sip_uri;
    pjsip_transport_type_e type;
    int local_port;
 
    pj_strdup_with_null(pool, &tmp, target);
 
    if (!(uri = pjsip_parse_uri(pool, tmp.ptr, tmp.slen, 0)) ||
        (!PJSIP_URI_SCHEME_IS_SIP(uri) && !PJSIP_URI_SCHEME_IS_SIPS(uri))) {
        return -1;
    }
 
    sip_uri = pjsip_uri_get_uri(uri);
 
    type = pjsip_transport_get_type_from_name(&sip_uri->transport_param);
    if (PJSIP_URI_SCHEME_IS_SIPS(sip_uri)) {
        if (type == PJSIP_TRANSPORT_UNSPECIFIED
            || !(pjsip_transport_get_flag_from_type(type) & PJSIP_TRANSPORT_SECURE)) {
            type = PJSIP_TRANSPORT_TLS;
        }
    } else if (!sip_uri->transport_param.slen) {
        type = PJSIP_TRANSPORT_UDP;
    } else if (type == PJSIP_TRANSPORT_UNSPECIFIED) {
        return -1;
    }
 
    if (pj_strchr(&sip_uri->host, ':')) {
        type |= PJSIP_TRANSPORT_IPV6;
    }
 
    if (pjsip_tpmgr_find_local_addr(pjsip_endpt_get_tpmgr(ast_sip_get_pjsip_endpoint()),
        pool, type, selector, &local_addr, &local_port) != PJ_SUCCESS) {
        return -1;
    }
 
    if (!pj_strchr(&sip_uri->host, ':') && pj_strchr(&local_addr, ':')) {
        type |= PJSIP_TRANSPORT_IPV6;
    }
 
    contact->ptr = pj_pool_alloc(pool, PJSIP_MAX_URL_SIZE);
    contact->slen = pj_ansi_snprintf(contact->ptr, PJSIP_MAX_URL_SIZE,
        "<%s:%s@%s%.*s%s:%d%s%s%s%s>%s%s",
        ((pjsip_transport_get_flag_from_type(type) & PJSIP_TRANSPORT_SECURE) && PJSIP_URI_SCHEME_IS_SIPS(uri)) ? "sips" : "sip",
        user,
        (type & PJSIP_TRANSPORT_IPV6) ? "[" : "",
        (int)local_addr.slen,
        local_addr.ptr,
        (type & PJSIP_TRANSPORT_IPV6) ? "]" : "",
        local_port,
        (type != PJSIP_TRANSPORT_UDP && type != PJSIP_TRANSPORT_UDP6) ? ";transport=" : "",
        (type != PJSIP_TRANSPORT_UDP && type != PJSIP_TRANSPORT_UDP6) ? pjsip_transport_get_type_name(type) : "",
        !ast_strlen_zero(line) ? ";line=" : "",
        S_OR(line, ""),
        !ast_strlen_zero(header_params) ? ";" : "",
        S_OR(header_params, ""));
 
    return 0;
}

References ast_sip_get_pjsip_endpoint(), ast_strlen_zero(), sip_outbound_registration::line, S_OR, tmp(), and type.

Referenced by sip_outbound_registration_regc_alloc().

sip_outbound_registration_alloc()

static void* sip_outbound_registration_alloc ( const char *  name )

static

Allocator function for registration information.

Definition at line 1371 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration *registration;
 
    registration = ast_sorcery_generic_alloc(sizeof(*registration),
        sip_outbound_registration_destroy);
    if (!registration || ast_string_field_init(registration, 256)) {
        ao2_cleanup(registration);
        return NULL;
    }
 
    return registration;
}

References ao2_cleanup, ast_sorcery_generic_alloc(), ast_string_field_init, NULL, and sip_outbound_registration_destroy().

Referenced by load_module().

sip_outbound_registration_apply()

static int sip_outbound_registration_apply ( const struct ast_sorcery *  sorcery, void *  obj  )

static

Apply function which finds or allocates a state structure.

Definition at line 1742 of file res_pjsip_outbound_registration.c.

{
    RAII_VAR(struct ao2_container *, states, ao2_global_obj_ref(current_states), ao2_cleanup);
    RAII_VAR(struct sip_outbound_registration_state *, state, NULL, ao2_cleanup);
    RAII_VAR(struct sip_outbound_registration_state *, new_state, NULL, ao2_cleanup);
    struct sip_outbound_registration *applied = obj;
 
    if (!states) {
        /* Global container has gone.  Likely shutting down. */
        return -1;
    }
    state = ao2_find(states, ast_sorcery_object_get_id(applied), OBJ_SEARCH_KEY);
 
    ast_debug(4, "Applying configuration to outbound registration '%s'\n", ast_sorcery_object_get_id(applied));
 
    if (ast_strlen_zero(applied->server_uri)) {
        ast_log(LOG_ERROR, "No server URI specified on outbound registration '%s'\n",
            ast_sorcery_object_get_id(applied));
        return -1;
    } else if (ast_sip_validate_uri_length(applied->server_uri)) {
            ast_log(LOG_ERROR, "Server URI or hostname length exceeds pjproject limit or is not a sip(s) uri: '%s'\n",
                ast_sorcery_object_get_id(applied));
            return -1;
    } else if (ast_strlen_zero(applied->client_uri)) {
        ast_log(LOG_ERROR, "No client URI specified on outbound registration '%s'\n",
            ast_sorcery_object_get_id(applied));
        return -1;
    } else if (ast_sip_validate_uri_length(applied->client_uri)) {
            ast_log(LOG_ERROR, "Client URI or hostname length exceeds pjproject limit or is not a sip(s) uri: '%s'\n",
                ast_sorcery_object_get_id(applied));
            return -1;
    } else if (applied->line && ast_strlen_zero(applied->endpoint)) {
        ast_log(LOG_ERROR, "Line support has been enabled on outbound registration '%s' without providing an endpoint\n",
            ast_sorcery_object_get_id(applied));
        return -1;
    } else if (!ast_strlen_zero(applied->endpoint) && !applied->line) {
        ast_log(LOG_ERROR, "An endpoint has been specified on outbound registration '%s' without enabling line support\n",
            ast_sorcery_object_get_id(applied));
        return -1;
    }
 
    if (state && can_reuse_registration(state->registration, applied)) {
        ast_debug(4,
            "No change between old configuration and new configuration on outbound registration '%s'. Using previous state\n",
            ast_sorcery_object_get_id(applied));
 
        /*
         * This is OK to replace without relinking the state in the
         * current_states container since state->registration and
         * applied have the same key.
         */
        ao2_lock(states);
        ao2_replace(state->registration, applied);
        ao2_unlock(states);
        return 0;
    }
 
    if (!(new_state = sip_outbound_registration_state_alloc(applied))) {
        return -1;
    }
 
    if (ast_sip_push_task_wait_serializer(new_state->client_state->serializer,
        sip_outbound_registration_regc_alloc, new_state)) {
        return -1;
    }
 
    if (ast_sip_push_task(new_state->client_state->serializer,
                  sip_outbound_registration_perform, ao2_bump(new_state))) {
        ast_log(LOG_ERROR, "Failed to perform outbound registration on '%s'\n",
            ast_sorcery_object_get_id(new_state->registration));
        ao2_ref(new_state, -1);
        return -1;
    }
 
    ao2_lock(states);
    if (state) {
        ao2_unlink(states, state);
    }
    ao2_link(states, new_state);
    ao2_unlock(states);
 
    return 0;
}

References ao2_bump, ao2_cleanup, ao2_find, ao2_global_obj_ref, ao2_link, ao2_lock, ao2_ref, ao2_replace, ao2_unlink, ao2_unlock, ast_debug, ast_log, ast_sip_push_task(), ast_sip_push_task_wait_serializer(), ast_sip_validate_uri_length(), ast_sorcery_object_get_id(), ast_strlen_zero(), can_reuse_registration(), sip_outbound_registration::client_uri, sip_outbound_registration::endpoint, sip_outbound_registration::line, LOG_ERROR, NULL, OBJ_SEARCH_KEY, RAII_VAR, sip_outbound_registration::server_uri, sip_outbound_registration_perform(), sip_outbound_registration_regc_alloc(), and sip_outbound_registration_state_alloc().

Referenced by load_module().

sip_outbound_registration_client_state_destroy()

static void sip_outbound_registration_client_state_destroy ( void *  obj )

static

Destructor function for client registration state.

Definition at line 1295 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_client_state *client_state = obj;
 
    ast_statsd_log_string("PJSIP.registrations.count", AST_STATSD_GAUGE, "-1", 1.0);
    ast_statsd_log_string_va("PJSIP.registrations.state.%s", AST_STATSD_GAUGE, "-1", 1.0,
        sip_outbound_registration_status_str(client_state->status));
 
    ast_taskprocessor_unreference(client_state->serializer);
    ast_free(client_state->transport_name);
    ast_free(client_state->registration_name);
    if (client_state->last_tdata) {
        pjsip_tx_data_dec_ref(client_state->last_tdata);
    }
}

References ast_free, AST_STATSD_GAUGE, ast_statsd_log_string(), ast_statsd_log_string_va(), ast_taskprocessor_unreference(), sip_outbound_registration_client_state::last_tdata, sip_outbound_registration_client_state::registration_name, sip_outbound_registration_client_state::serializer, sip_outbound_registration_status_str(), sip_outbound_registration_client_state::status, and sip_outbound_registration_client_state::transport_name.

Referenced by sip_outbound_registration_state_alloc().

sip_outbound_registration_destroy()

static void sip_outbound_registration_destroy ( void *  obj )

static

Destructor function for registration information.

Definition at line 1361 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration *registration = obj;
 
    ast_sip_auth_vector_destroy(&registration->outbound_auths);
 
    ast_string_field_free_memory(registration);
}

References ast_sip_auth_vector_destroy(), ast_string_field_free_memory, and sip_outbound_registration::outbound_auths.

Referenced by sip_outbound_registration_alloc().

sip_outbound_registration_is_temporal()

static int sip_outbound_registration_is_temporal ( unsigned int  code, struct sip_outbound_registration_client_state *  client_state  )

static

Helper function which determines if a response code is temporal or not.

Definition at line 864 of file res_pjsip_outbound_registration.c.

{
    /* Shamelessly taken from pjsua */
    if (code == PJSIP_SC_REQUEST_TIMEOUT ||
        code == PJSIP_SC_INTERNAL_SERVER_ERROR ||
        code == PJSIP_SC_BAD_GATEWAY ||
        code == PJSIP_SC_SERVICE_UNAVAILABLE ||
        code == PJSIP_SC_SERVER_TIMEOUT ||
        ((code == PJSIP_SC_UNAUTHORIZED ||
          code == PJSIP_SC_PROXY_AUTHENTICATION_REQUIRED) &&
         !client_state->auth_rejection_permanent) ||
        PJSIP_IS_STATUS_IN_CLASS(code, 600)) {
        return 1;
    } else {
        return 0;
    }
}

References sip_outbound_registration_client_state::auth_rejection_permanent, registration_response::client_state, and registration_response::code.

Referenced by handle_registration_response().

sip_outbound_registration_perform()

static int sip_outbound_registration_perform ( void *  data )

static

Helper function which performs a single registration.

Definition at line 1706 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_state *state = data;
    struct sip_outbound_registration *registration = ao2_bump(state->registration);
    size_t i;
 
    /* Just in case the client state is being reused for this registration, free the auth information */
    ast_sip_auth_vector_destroy(&state->client_state->outbound_auths);
 
    AST_VECTOR_INIT(&state->client_state->outbound_auths, AST_VECTOR_SIZE(&registration->outbound_auths));
    for (i = 0; i < AST_VECTOR_SIZE(&registration->outbound_auths); ++i) {
        char *name = ast_strdup(AST_VECTOR_GET(&registration->outbound_auths, i));
 
        if (name && AST_VECTOR_APPEND(&state->client_state->outbound_auths, name)) {
            ast_free(name);
        }
    }
    state->client_state->retry_interval = registration->retry_interval;
    state->client_state->forbidden_retry_interval = registration->forbidden_retry_interval;
    state->client_state->fatal_retry_interval = registration->fatal_retry_interval;
    state->client_state->max_retries = registration->max_retries;
    state->client_state->retries = 0;
    state->client_state->support_path = registration->support_path;
    state->client_state->support_outbound = registration->support_outbound;
    state->client_state->auth_rejection_permanent = registration->auth_rejection_permanent;
 
    pjsip_regc_update_expires(state->client_state->client, registration->expiration);
 
    schedule_registration(state->client_state, (ast_random() % 10) + 1);
 
    ao2_ref(registration, -1);
    ao2_ref(state, -1);
    return 0;
}

References ao2_bump, ao2_ref, ast_free, ast_random(), ast_sip_auth_vector_destroy(), ast_strdup, AST_VECTOR_APPEND, AST_VECTOR_GET, AST_VECTOR_INIT, AST_VECTOR_SIZE, sip_outbound_registration::auth_rejection_permanent, sip_outbound_registration::expiration, sip_outbound_registration::fatal_retry_interval, sip_outbound_registration::forbidden_retry_interval, sip_outbound_registration::max_retries, name, sip_outbound_registration::outbound_auths, sip_outbound_registration::retry_interval, schedule_registration(), sip_outbound_registration::support_outbound, and sip_outbound_registration::support_path.

Referenced by auth_observer(), queue_register(), and sip_outbound_registration_apply().

sip_outbound_registration_regc_alloc()

static int sip_outbound_registration_regc_alloc ( void *  data )

static

Helper function that allocates a pjsip registration client and configures it.

Definition at line 1601 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_state *state = data;
    RAII_VAR(struct sip_outbound_registration *, registration,
         ao2_bump(state->registration), ao2_cleanup);
    pj_pool_t *pool;
    pj_str_t tmp;
    pjsip_uri *uri;
    pj_str_t server_uri, client_uri, contact_uri;
    pjsip_tpselector selector = { .type = PJSIP_TPSELECTOR_NONE, };
 
    pool = pjsip_endpt_create_pool(ast_sip_get_pjsip_endpoint(), "URI Validation", 256, 256);
    if (!pool) {
        ast_log(LOG_ERROR, "Could not create pool for URI validation on outbound registration '%s'\n",
            ast_sorcery_object_get_id(registration));
        return -1;
    }
 
    pj_strdup2_with_null(pool, &tmp, registration->server_uri);
    uri = pjsip_parse_uri(pool, tmp.ptr, tmp.slen, 0);
    if (!uri) {
        ast_log(LOG_ERROR, "Invalid server URI '%s' specified on outbound registration '%s'\n",
            registration->server_uri, ast_sorcery_object_get_id(registration));
        pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
        return -1;
    }
 
    pj_strdup2_with_null(pool, &tmp, registration->client_uri);
    uri = pjsip_parse_uri(pool, tmp.ptr, tmp.slen, 0);
    if (!uri) {
        ast_log(LOG_ERROR, "Invalid client URI '%s' specified on outbound registration '%s'\n",
            registration->client_uri, ast_sorcery_object_get_id(registration));
        pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
        return -1;
    }
 
    if (!ast_strlen_zero(registration->outbound_proxy)) {
        pj_strdup2_with_null(pool, &tmp, registration->outbound_proxy);
        uri = pjsip_parse_uri(pool, tmp.ptr, tmp.slen, 0);
        if (!uri) {
            ast_log(LOG_ERROR, "Invalid outbound proxy URI '%s' specified on outbound registration '%s'\n",
                registration->outbound_proxy, ast_sorcery_object_get_id(registration));
            pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
            return -1;
        }
    }
 
    pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
 
 
    ast_assert(state->client_state->client == NULL);
    if (pjsip_regc_create(ast_sip_get_pjsip_endpoint(), state->client_state,
            sip_outbound_registration_response_cb,
            &state->client_state->client) != PJ_SUCCESS) {
        return -1;
    }
 
    ast_sip_set_tpselector_from_transport_name(registration->transport, &selector);
    pjsip_regc_set_transport(state->client_state->client, &selector);
 
    if (!ast_strlen_zero(registration->outbound_proxy)) {
        pjsip_route_hdr route_set, *route;
        static const pj_str_t ROUTE_HNAME = { "Route", 5 };
        pj_str_t tmp;
 
        pj_list_init(&route_set);
 
        pj_strdup2_with_null(pjsip_regc_get_pool(state->client_state->client), &tmp,
            registration->outbound_proxy);
        route = pjsip_parse_hdr(pjsip_regc_get_pool(state->client_state->client),
            &ROUTE_HNAME, tmp.ptr, tmp.slen, NULL);
        if (!route) {
            ast_sip_tpselector_unref(&selector);
            return -1;
        }
        pj_list_insert_nodes_before(&route_set, route);
 
        pjsip_regc_set_route_set(state->client_state->client, &route_set);
    }
 
    if (state->registration->line) {
        ast_generate_random_string(state->client_state->line, sizeof(state->client_state->line));
    }
 
    pj_cstr(&server_uri, registration->server_uri);
 
    if (sip_dialog_create_contact(pjsip_regc_get_pool(state->client_state->client),
        &contact_uri, S_OR(registration->contact_user, "s"), &server_uri, &selector,
        state->client_state->line, registration->contact_header_params)) {
        ast_sip_tpselector_unref(&selector);
        return -1;
    }
 
    ast_sip_tpselector_unref(&selector);
 
    pj_cstr(&client_uri, registration->client_uri);
    if (pjsip_regc_init(state->client_state->client, &server_uri, &client_uri,
        &client_uri, 1, &contact_uri, registration->expiration) != PJ_SUCCESS) {
        return -1;
    }
 
    return 0;
}

References ao2_bump, ao2_cleanup, ast_assert, ast_generate_random_string(), ast_log, ast_sip_get_pjsip_endpoint(), ast_sip_set_tpselector_from_transport_name(), ast_sip_tpselector_unref(), ast_sorcery_object_get_id(), ast_strlen_zero(), sip_outbound_registration::client_uri, sip_outbound_registration::contact_header_params, sip_outbound_registration::contact_user, sip_outbound_registration::expiration, LOG_ERROR, NULL, sip_outbound_registration::outbound_proxy, RAII_VAR, sip_outbound_registration_state::registration, S_OR, sip_outbound_registration::server_uri, server_uri, sip_dialog_create_contact(), sip_outbound_registration_response_cb(), tmp(), and sip_outbound_registration::transport.

Referenced by sip_outbound_registration_apply().

sip_outbound_registration_response_cb()

static void sip_outbound_registration_response_cb ( struct pjsip_regc_cbparam *  param )

static

Callback function for outbound registration client.

Definition at line 1205 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_client_state *client_state = param->token;
    struct registration_response *response;
    int *callback_invoked;
 
    callback_invoked = ast_threadstorage_get(&register_callback_invoked, sizeof(int));
 
    ast_assert(callback_invoked != NULL);
    ast_assert(client_state != NULL);
 
    *callback_invoked = 1;
 
    response = ao2_alloc(sizeof(*response), registration_response_destroy);
    if (!response) {
        ao2_ref(client_state, -1);
        return;
    }
    response->code = param->code;
    response->expiration = param->expiration;
    /*
     * Transfer client_state reference to response so the
     * nominal path will not dec the client_state ref in this
     * pjproject callback thread.
     */
    response->client_state = client_state;
 
    ast_debug(1, "Received REGISTER response %d(%.*s)\n",
        param->code, (int) param->reason.slen, param->reason.ptr);
 
    if (param->rdata) {
        struct pjsip_retry_after_hdr *retry_after;
        pjsip_transaction *tsx;
 
        retry_after = pjsip_msg_find_hdr(param->rdata->msg_info.msg, PJSIP_H_RETRY_AFTER,
            NULL);
        response->retry_after = retry_after ? retry_after->ivalue : 0;
 
        /*
         * If we got a response from the server, we have to use the tdata
         * from the transaction, not the tdata saved when we sent the
         * request.  If we use the saved tdata, we won't process responses
         * like 423 Interval Too Brief correctly and we'll wind up sending
         * the bad Expires value again.
         */
        pjsip_tx_data_dec_ref(client_state->last_tdata);
 
        tsx = pjsip_rdata_get_tsx(param->rdata);
        response->old_request = tsx->last_tx;
        pjsip_tx_data_add_ref(response->old_request);
        pjsip_rx_data_clone(param->rdata, 0, &response->rdata);
    } else {
        /* old_request steals the reference */
        response->old_request = client_state->last_tdata;
    }
    client_state->last_tdata = NULL;
 
    /*
     * Transfer response reference to serializer task so the
     * nominal path will not dec the response ref in this
     * pjproject callback thread.
     */
    if (ast_sip_push_task(client_state->serializer, handle_registration_response, response)) {
        ast_log(LOG_WARNING, "Failed to pass incoming registration response to threadpool\n");
        ao2_cleanup(response);
    }
}

References ao2_alloc, ao2_cleanup, ao2_ref, ast_assert, ast_debug, ast_log, ast_sip_push_task(), ast_threadstorage_get(), registration_response::client_state, registration_response::code, registration_response::expiration, handle_registration_response(), sip_outbound_registration_client_state::last_tdata, LOG_WARNING, NULL, registration_response::old_request, registration_response::rdata, register_callback_invoked, registration_response_destroy(), registration_response::retry_after, and sip_outbound_registration_client_state::serializer.

Referenced by sip_outbound_registration_regc_alloc().

sip_outbound_registration_state_alloc()

static struct sip_outbound_registration_state* sip_outbound_registration_state_alloc ( struct sip_outbound_registration *  registration )

static

Allocator function for registration state.

Definition at line 1312 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_state *state;
    char tps_name[AST_TASKPROCESSOR_MAX_NAME + 1];
 
    state = ao2_alloc(sizeof(*state), sip_outbound_registration_state_destroy);
    if (!state) {
        return NULL;
    }
    state->client_state = ao2_alloc(sizeof(*state->client_state),
        sip_outbound_registration_client_state_destroy);
    if (!state->client_state) {
        ao2_cleanup(state);
        return NULL;
    }
 
    state->client_state->status = SIP_REGISTRATION_UNREGISTERED;
    pj_timer_entry_init(&state->client_state->timer, 0, state->client_state,
        sip_outbound_registration_timer_cb);
    state->client_state->transport_name = ast_strdup(registration->transport);
    state->client_state->registration_name =
        ast_strdup(ast_sorcery_object_get_id(registration));
 
    ast_statsd_log_string("PJSIP.registrations.count", AST_STATSD_GAUGE, "+1", 1.0);
    ast_statsd_log_string_va("PJSIP.registrations.state.%s", AST_STATSD_GAUGE, "+1", 1.0,
        sip_outbound_registration_status_str(state->client_state->status));
 
    if (!state->client_state->transport_name
        || !state->client_state->registration_name) {
        ao2_cleanup(state);
        return NULL;
    }
 
    /* Create name with seq number appended. */
    ast_taskprocessor_build_name(tps_name, sizeof(tps_name), "pjsip/outreg/%s",
        ast_sorcery_object_get_id(registration));
 
    state->client_state->serializer = ast_sip_create_serializer_group(tps_name,
        shutdown_group);
    if (!state->client_state->serializer) {
        ao2_cleanup(state);
        return NULL;
    }
 
    state->registration = ao2_bump(registration);
    return state;
}

References ao2_alloc, ao2_bump, ao2_cleanup, ast_sip_create_serializer_group(), ast_sorcery_object_get_id(), AST_STATSD_GAUGE, ast_statsd_log_string(), ast_statsd_log_string_va(), ast_strdup, ast_taskprocessor_build_name(), AST_TASKPROCESSOR_MAX_NAME, NULL, sip_outbound_registration_state::registration, shutdown_group, sip_outbound_registration_client_state_destroy(), sip_outbound_registration_state_destroy(), sip_outbound_registration_status_str(), sip_outbound_registration_timer_cb(), SIP_REGISTRATION_UNREGISTERED, state, and sip_outbound_registration::transport.

Referenced by sip_outbound_registration_apply().

sip_outbound_registration_state_destroy()

static void sip_outbound_registration_state_destroy ( void *  obj )

static

Destructor function for registration state.

Definition at line 1274 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_state *state = obj;
 
    ast_debug(3, "Destroying registration state for registration to server '%s' from client '%s'\n",
        state->registration ? state->registration->server_uri : "",
        state->registration ? state->registration->client_uri : "");
    ao2_cleanup(state->registration);
 
    if (!state->client_state) {
        /* Nothing to do */
    } else if (!state->client_state->serializer) {
        ao2_ref(state->client_state, -1);
    } else if (ast_sip_push_task(state->client_state->serializer,
        handle_client_state_destruction, state->client_state)) {
        ast_log(LOG_WARNING, "Failed to pass outbound registration client destruction to threadpool\n");
        ao2_ref(state->client_state, -1);
    }
}

References ao2_cleanup, ao2_ref, ast_debug, ast_log, ast_sip_push_task(), handle_client_state_destruction(), and LOG_WARNING.

Referenced by sip_outbound_registration_state_alloc().

sip_outbound_registration_status_str()

static const char* sip_outbound_registration_status_str ( enum sip_outbound_registration_status  state )

static

Definition at line 278 of file res_pjsip_outbound_registration.c.

{
    const char *str;
 
    str = "Unregistered";
    switch (state) {
    case SIP_REGISTRATION_STOPPING:
    case SIP_REGISTRATION_STOPPED:
    case SIP_REGISTRATION_UNREGISTERED:
        break;
    case SIP_REGISTRATION_REGISTERED:
        str = "Registered";
        break;
    case SIP_REGISTRATION_REJECTED_TEMPORARY:
    case SIP_REGISTRATION_REJECTED_PERMANENT:
        str = "Rejected";
        break;
    }
    return str;
}

References SIP_REGISTRATION_REGISTERED, SIP_REGISTRATION_REJECTED_PERMANENT, SIP_REGISTRATION_REJECTED_TEMPORARY, SIP_REGISTRATION_STOPPED, SIP_REGISTRATION_STOPPING, SIP_REGISTRATION_UNREGISTERED, and str.

Referenced by ami_outbound_registration_task(), cli_print_body(), handle_registration_response(), sip_outbound_registration_client_state_destroy(), sip_outbound_registration_state_alloc(), and update_client_state_status().

sip_outbound_registration_timer_cb()

static void sip_outbound_registration_timer_cb ( pj_timer_heap_t *  timer_heap, struct pj_timer_entry *  entry  )

static

Timer callback function, used just for registrations.

Definition at line 703 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_client_state *client_state = entry->user_data;
 
    entry->id = 0;
 
    /*
     * Transfer client_state reference to serializer task so the
     * nominal path will not dec the client_state ref in this
     * pjproject callback thread.
     */
    if (ast_sip_push_task(client_state->serializer, handle_client_registration, client_state)) {
        ast_log(LOG_WARNING, "Scheduled outbound registration could not be executed.\n");
        ao2_ref(client_state, -1);
    }
}

References ao2_ref, ast_log, ast_sip_push_task(), handle_client_registration(), LOG_WARNING, and sip_outbound_registration_client_state::serializer.

Referenced by sip_outbound_registration_state_alloc().

unload_module()

static int unload_module ( void  )

static

Definition at line 2457 of file res_pjsip_outbound_registration.c.

{
    int remaining;
 
    network_change_sub = stasis_unsubscribe_and_join(network_change_sub);
 
    ast_manager_unregister("PJSIPShowRegistrationsOutbound");
    ast_manager_unregister("PJSIPUnregister");
    ast_manager_unregister("PJSIPRegister");
 
    ast_cli_unregister_multiple(cli_outbound_registration, ARRAY_LEN(cli_outbound_registration));
    ast_sip_unregister_cli_formatter(cli_formatter);
    cli_formatter = NULL;
 
    ast_sip_unregister_endpoint_identifier(&line_identifier);
 
    ast_sorcery_observer_remove(ast_sip_get_sorcery(), "auth", &observer_callbacks_auth);
    ast_sorcery_instance_observer_remove(ast_sip_get_sorcery(), &observer_callbacks_registrations);
 
    ast_sorcery_object_unregister(ast_sip_get_sorcery(), "registration");
 
    ao2_global_obj_release(current_states);
 
    ast_sip_transport_monitor_unregister_all(registration_transport_shutdown_cb, NULL, NULL);
 
    /* Wait for registration serializers to get destroyed. */
    ast_debug(2, "Waiting for registration transactions to complete for unload.\n");
    remaining = ast_serializer_shutdown_group_join(shutdown_group, MAX_UNLOAD_TIMEOUT_TIME);
    if (remaining) {
        /*
         * NOTE: We probably have a sip_outbound_registration_client_state
         * ref leak if the remaining count cannot reach zero after a few
         * minutes of trying to unload.
         */
        ast_log(LOG_WARNING, "Unload incomplete.  Could not stop %d outbound registrations.  Try again later.\n",
            remaining);
        return -1;
    }
 
    ast_debug(2, "Successful shutdown.\n");
 
    ao2_cleanup(shutdown_group);
    shutdown_group = NULL;
 
    return 0;
}

References ao2_cleanup, ao2_global_obj_release, ARRAY_LEN, ast_cli_unregister_multiple(), ast_debug, ast_log, ast_manager_unregister(), ast_serializer_shutdown_group_join(), ast_sip_get_sorcery(), ast_sip_transport_monitor_unregister_all(), ast_sip_unregister_cli_formatter(), ast_sip_unregister_endpoint_identifier(), ast_sorcery_instance_observer_remove(), ast_sorcery_object_unregister(), ast_sorcery_observer_remove(), cli_formatter, cli_outbound_registration, line_identifier, LOG_WARNING, MAX_UNLOAD_TIMEOUT_TIME, network_change_sub, NULL, observer_callbacks_auth, observer_callbacks_registrations, registration_transport_shutdown_cb(), shutdown_group, and stasis_unsubscribe_and_join().

Referenced by load_module().

unregister_all()

static void unregister_all ( void  )

static

Definition at line 1902 of file res_pjsip_outbound_registration.c.

{
    struct ao2_container *states;
 
    states = ao2_global_obj_ref(current_states);
    if (!states) {
        return;
    }
 
    /* Clean out all the states and let sorcery handle recreating the registrations */
    ao2_callback(states, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, NULL, NULL);
    ao2_ref(states, -1);
}

References ao2_callback, ao2_global_obj_ref, ao2_ref, NULL, OBJ_MULTIPLE, OBJ_NODATA, and OBJ_UNLINK.

Referenced by ami_unregister(), cli_unregister(), and reregister_all().

unregister_task()

static int unregister_task ( void *  obj )

static

Definition at line 1858 of file res_pjsip_outbound_registration.c.

{
    struct sip_outbound_registration_state *state = obj;
    struct pjsip_regc *client = state->client_state->client;
    pjsip_tx_data *tdata;
    pjsip_regc_info info;
 
    pjsip_regc_get_info(client, &info);
    ast_debug(1, "Unregistering contacts with server '%s' from client '%s'\n",
        state->registration->server_uri, state->registration->client_uri);
 
    cancel_registration(state->client_state);
 
    if (pjsip_regc_unregister(client, &tdata) == PJ_SUCCESS
        && add_configured_supported_headers(state->client_state, tdata)) {
        registration_client_send(state->client_state, tdata);
    }
 
    ao2_ref(state, -1);
    return 0;
}

References add_configured_supported_headers(), ao2_ref, ast_debug, cancel_registration(), sip_to_pjsip::info(), and registration_client_send().

Referenced by queue_unregister().

update_client_state_status()

static void update_client_state_status ( struct sip_outbound_registration_client_state *  client_state, enum sip_outbound_registration_status  status  )

static

Definition at line 743 of file res_pjsip_outbound_registration.c.

{
    const char *status_old;
    const char *status_new;
 
    if (client_state->status == status) {
        /* Status state did not change at all. */
        return;
    }
 
    status_old = sip_outbound_registration_status_str(client_state->status);
    status_new = sip_outbound_registration_status_str(status);
    client_state->status = status;
 
    if (!strcmp(status_old, status_new)) {
        /*
         * The internal status state may have changed but the status
         * state we tell the world did not change at all.
         */
        return;
    }
 
    ast_statsd_log_string_va("PJSIP.registrations.state.%s", AST_STATSD_GAUGE, "-1", 1.0,
        status_old);
    ast_statsd_log_string_va("PJSIP.registrations.state.%s", AST_STATSD_GAUGE, "+1", 1.0,
        status_new);
}

References AST_STATSD_GAUGE, ast_statsd_log_string_va(), sip_outbound_registration_status_str(), status, and sip_outbound_registration_client_state::status.

Referenced by handle_client_state_destruction(), handle_registration_response(), and schedule_retry().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP Outbound Registration 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, .reload = reload_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND, .requires = "res_pjsip", .optional_modules = "res_statsd", }

static

Definition at line 2610 of file res_pjsip_outbound_registration.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2624 of file res_pjsip_outbound_registration.c.

cli_formatter

struct ast_sip_cli_formatter_entry* cli_formatter

static

Definition at line 2328 of file res_pjsip_outbound_registration.c.

Referenced by load_module(), and unload_module().

cli_outbound_registration

struct ast_cli_entry cli_outbound_registration[]

static

Definition at line 2304 of file res_pjsip_outbound_registration.c.

Referenced by load_module(), and unload_module().

line_identifier

struct ast_sip_endpoint_identifier line_identifier

static

Initial value:

= {
    .identify_endpoint = line_identify,
}

Definition at line 512 of file res_pjsip_outbound_registration.c.

Referenced by load_module(), and unload_module().

network_change_sub

struct stasis_subscription* network_change_sub

static

subscription id for network change events

Definition at line 416 of file res_pjsip_outbound_registration.c.

Referenced by load_module(), and unload_module().

observer_callbacks_auth

const struct ast_sorcery_observer observer_callbacks_auth

static

Initial value:

= {
    .loaded = auth_observer,
}

Definition at line 2330 of file res_pjsip_outbound_registration.c.

Referenced by load_module(), and unload_module().

observer_callbacks_registrations

const struct ast_sorcery_instance_observer observer_callbacks_registrations

static

Initial value:

= {
    .object_type_loaded = registration_loaded_observer,
}

Definition at line 2395 of file res_pjsip_outbound_registration.c.

Referenced by load_module(), pjsip_outbound_registration_metrics_init(), pjsip_outbound_registration_metrics_unload_cb(), and unload_module().

OUTBOUND_NAME

pj_str_t OUTBOUND_NAME = { "outbound", 8 }

static

Definition at line 554 of file res_pjsip_outbound_registration.c.

Referenced by add_configured_supported_headers().

PATH_NAME

pj_str_t PATH_NAME = { "path", 4 }

static

Definition at line 553 of file res_pjsip_outbound_registration.c.

Referenced by add_configured_supported_headers().

register_callback_invoked

struct ast_threadstorage register_callback_invoked = { .once = PTHREAD_ONCE_INIT , .key_init = __init_register_callback_invoked , .custom_init = NULL , }

static

Definition at line 245 of file res_pjsip_outbound_registration.c.

Referenced by registration_client_send(), and sip_outbound_registration_response_cb().

registration_observer

const struct ast_sorcery_observer registration_observer

static

Initial value:

= {
    .deleted = registration_deleted_observer,
}

Definition at line 2426 of file res_pjsip_outbound_registration.c.

Referenced by load_module(), pjsip_outbound_registration_metrics_init(), and pjsip_outbound_registration_metrics_unload_cb().

shutdown_group

struct ast_serializer_shutdown_group* shutdown_group

static

Shutdown group to monitor sip_outbound_registration_client_state serializers.

Definition at line 409 of file res_pjsip_outbound_registration.c.

Referenced by load_module(), sip_outbound_registration_state_alloc(), and unload_module().