#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:

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)

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 = "30ef0c93b36035ec78c9cfd712d36d9b" , .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.

Referenced by load_module().

◆ 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.

Referenced by unload_module().

◆ REGISTRATION_URI_FIELD_LEN

#define REGISTRATION_URI_FIELD_LEN 53

Referenced by cli_print_body().

◆ 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.

Referenced by handle_registration_response().

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.

254 {

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 2628 of file res_pjsip_outbound_registration.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 2628 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.

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

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

◆ 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.

References NULL.

Referenced by add_configured_supported_headers().

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

◆ ami_outbound_registration_detail()

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

static

Definition at line 2171 of file res_pjsip_outbound_registration.c.

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

Referenced by ami_show_outbound_registrations().

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

◆ ami_outbound_registration_task()

static int ami_outbound_registration_task ( void * obj )

static

Definition at line 2135 of file res_pjsip_outbound_registration.c.

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, sip_outbound_registration_client_state::client, sip_outbound_registration_state::client_state, 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, state, and sip_outbound_registration_client_state::status.

Referenced by ami_outbound_registration_detail().

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

◆ ami_register()

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

static

Definition at line 2091 of file res_pjsip_outbound_registration.c.

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

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

◆ ami_show_outbound_registrations()

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

static

Definition at line 2179 of file res_pjsip_outbound_registration.c.

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

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

◆ ami_unregister()

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

static

Definition at line 2059 of file res_pjsip_outbound_registration.c.

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

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

◆ 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 2628 of file res_pjsip_outbound_registration.c.

◆ auth_observer()

static void auth_observer ( const char * type )

static

Definition at line 2332 of file res_pjsip_outbound_registration.c.

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(), sip_outbound_registration_state::client_state, get_state(), LOG_ERROR, NULL, sip_outbound_registration_client_state::serializer, sip_outbound_registration_perform(), SIP_REGISTRATION_REJECTED_PERMANENT, state, and sip_outbound_registration_client_state::status.

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

◆ can_reuse_registration()

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

static

Definition at line 1461 of file res_pjsip_outbound_registration.c.

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

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

◆ 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.

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

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

◆ check_state()

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

static

Definition at line 2372 of file res_pjsip_outbound_registration.c.

References ao2_ref, ast_sip_get_sorcery(), ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_id(), CMP_MATCH, and sip_outbound_registration_state::registration.

Referenced by registration_loaded_observer().

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

◆ cli_complete_registration()

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

static

Definition at line 1924 of file res_pjsip_outbound_registration.c.

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

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

◆ cli_get_container()

static struct ao2_container* cli_get_container ( const char * regex )

static

Definition at line 2211 of file res_pjsip_outbound_registration.c.

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, and RAII_VAR.

Referenced by load_module().

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

◆ cli_iterator()

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

static

Definition at line 2235 of file res_pjsip_outbound_registration.c.

References ao2_callback, and OBJ_NODATA.

Referenced by load_module().

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

◆ cli_print_body()

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

static

Definition at line 2271 of file res_pjsip_outbound_registration.c.

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, sip_outbound_registration_state::client_state, context, get_state(), ast_sip_cli_context::indent_level, NULL, sip_outbound_registration::outbound_auths, ast_sip_cli_context::output_buffer, REGISTRATION_URI_FIELD_LEN, sip_outbound_registration::server_uri, ast_sip_cli_context::show_details, ast_sip_cli_context::show_details_only_level_0, sip_outbound_registration_status_str(), and sip_outbound_registration_client_state::status.

Referenced by load_module().

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

◆ cli_print_header()

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

static

Definition at line 2259 of file res_pjsip_outbound_registration.c.

References ast_assert, ast_str_append(), context, NULL, and ast_sip_cli_context::output_buffer.

Referenced by load_module().

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

◆ cli_register()

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

static

Definition at line 2011 of file res_pjsip_outbound_registration.c.

References ao2_ref, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), cli_complete_registration(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, get_state(), ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_args::pos, queue_register(), queue_unregister(), reregister_all(), state, ast_cli_entry::usage, and ast_cli_args::word.

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

◆ cli_retrieve_by_id()

static void* cli_retrieve_by_id ( const char * id )

static

Definition at line 2242 of file res_pjsip_outbound_registration.c.

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

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

◆ cli_unregister()

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

static

Definition at line 1968 of file res_pjsip_outbound_registration.c.

References ao2_ref, ast_cli_args::argc, ast_cli_args::argv, ast_cli(), cli_complete_registration(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, get_state(), ast_cli_args::line, ast_cli_args::n, NULL, ast_cli_args::pos, queue_unregister(), state, unregister_all(), ast_cli_entry::usage, and ast_cli_args::word.

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

◆ fetch_google_access_token()

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

static

Definition at line 1485 of file res_pjsip_outbound_registration.c.

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, ast_json_error::column, ast_json_error::line, LOG_ERROR, NULL, ast_sip_auth::oauth_clientid, ast_sip_auth::oauth_secret, ast_sip_auth::refresh_token, ast_json_error::text, and url.

Referenced by set_outbound_initial_authentication_credentials().

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

◆ get_registrations()

static struct ao2_container* get_registrations ( void )

static

Definition at line 481 of file res_pjsip_outbound_registration.c.

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(), and registration_loaded_observer().

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

◆ 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.

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

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

◆ 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.

References NULL.

Referenced by line_identify().

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

◆ 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.

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

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

◆ 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.

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

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

◆ handle_registration_response()

static int handle_registration_response ( void * data )

static

Callback function for handling a response to a registration attempt.

Definition at line 1056 of file res_pjsip_outbound_registration.c.

Referenced by sip_outbound_registration_response_cb().

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

◆ 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.

References ao2_callback, ao2_cleanup, ao2_global_obj_ref, ast_debug, ast_sip_get_sorcery(), ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_id(), ast_strlen_zero, get_uri_option_line(), sip_outbound_registration::line, line_identify_relationship(), NULL, and RAII_VAR.

 {
    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.

References sip_outbound_registration_state::client_state, CMP_MATCH, sip_outbound_registration::line, and sip_outbound_registration_client_state::line.

Referenced by line_identify().

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

◆ load_module()

static int load_module ( void )

static

Definition at line 2508 of file res_pjsip_outbound_registration.c.

Referenced by reload_module().

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

◆ monitor_matcher()

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

static

Definition at line 954 of file res_pjsip_outbound_registration.c.

References a, and b.

Referenced by handle_registration_response().

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

◆ 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 2306 of file res_pjsip_outbound_registration.c.

References ast_sip_cli_traverse_objects().

 {
    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 2450 of file res_pjsip_outbound_registration.c.

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

Referenced by load_module().

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

◆ outbound_auth_handler()

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

static

Definition at line 1828 of file res_pjsip_outbound_registration.c.

References ast_sip_auth_vector_init(), sip_outbound_registration::outbound_auths, and ast_variable::value.

Referenced by load_module().

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

◆ outbound_auths_to_str()

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

static

Definition at line 1835 of file res_pjsip_outbound_registration.c.

References ast_sip_auths_to_str(), and sip_outbound_registration::outbound_auths.

Referenced by load_module().

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

◆ outbound_auths_to_var_list()

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

static

Definition at line 1842 of file res_pjsip_outbound_registration.c.

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

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

◆ queue_register()

static int queue_register ( struct sip_outbound_registration_state * state )

static

Definition at line 1893 of file res_pjsip_outbound_registration.c.

References ao2_ref, ast_sip_push_task(), sip_outbound_registration_state::client_state, sip_outbound_registration_client_state::serializer, and sip_outbound_registration_perform().

Referenced by ami_register(), and cli_register().

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

◆ queue_unregister()

static int queue_unregister ( struct sip_outbound_registration_state * state )

static

Definition at line 1882 of file res_pjsip_outbound_registration.c.

References ao2_ref, ast_sip_push_task(), sip_outbound_registration_state::client_state, sip_outbound_registration_client_state::serializer, and unregister_task().

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

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

◆ 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.

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

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

◆ registration_deleted_observer()

static void registration_deleted_observer ( const void * obj )

static

Definition at line 2430 of file res_pjsip_outbound_registration.c.

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

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

◆ 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 2399 of file res_pjsip_outbound_registration.c.

References ao2_callback, ao2_cleanup, ao2_global_obj_ref, ao2_ref, check_state(), get_registrations(), NULL, OBJ_MULTIPLE, OBJ_NODATA, and OBJ_UNLINK.

 {
    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.

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

Referenced by sip_outbound_registration_response_cb().

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

◆ 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.

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

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

◆ 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.

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

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

◆ registration_transport_monitor_setup()

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

static

Definition at line 962 of file res_pjsip_outbound_registration.c.

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

Referenced by handle_registration_response().

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

◆ registration_transport_shutdown_cb()

static void registration_transport_shutdown_cb ( void * obj )

static

Definition at line 939 of file res_pjsip_outbound_registration.c.

References ao2_ref, ast_sip_push_task(), sip_outbound_registration_state::client_state, get_state(), reregister_immediately_cb(), sip_outbound_registration_client_state::serializer, and state.

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

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

◆ reload_module()

static int reload_module ( void )

static

Definition at line 2614 of file res_pjsip_outbound_registration.c.

References AST_MODFLAG_LOAD_ORDER, AST_MODPRI_APP_DEPEND, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, ast_sip_get_sorcery(), ast_sorcery_reload_object(), ASTERISK_GPL_KEY, load_module(), reload(), and unload_module().

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

◆ reregister_all()

static void reregister_all ( void )

static

Definition at line 1918 of file res_pjsip_outbound_registration.c.

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

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

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

◆ reregister_immediately_cb()

static int reregister_immediately_cb ( void * obj )

static

Definition at line 900 of file res_pjsip_outbound_registration.c.

References ao2_ref, ast_log, cancel_registration(), sip_outbound_registration_client_state::client, sip_outbound_registration_state::client_state, DEBUG_ATLEAST, handle_client_registration(), sip_to_pjsip::info(), LOG_DEBUG, SIP_REGISTRATION_REGISTERED, and sip_outbound_registration_client_state::status.

Referenced by registration_transport_shutdown_cb().

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

◆ save_response_fields_to_transport()

static void save_response_fields_to_transport ( struct registration_response * response )

static

Definition at line 986 of file res_pjsip_outbound_registration.c.

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, NULL, registration_response::rdata, sip_outbound_registration_client_state::transport_name, and value.

Referenced by handle_registration_response().

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

◆ 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.

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

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

◆ 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.

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

Referenced by handle_registration_response().

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

◆ 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 1545 of file res_pjsip_outbound_registration.c.

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

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

◆ 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 1388 of file res_pjsip_outbound_registration.c.

References ast_sip_get_pjsip_endpoint(), ast_strlen_zero, S_OR, tmp(), and type.

Referenced by sip_outbound_registration_regc_alloc().

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

◆ sip_outbound_registration_alloc()

static void* sip_outbound_registration_alloc ( const char * name )

static

Allocator function for registration information.

Definition at line 1373 of file res_pjsip_outbound_registration.c.

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

Referenced by load_module().

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

◆ 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 1744 of file res_pjsip_outbound_registration.c.

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

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

◆ 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 1297 of file res_pjsip_outbound_registration.c.

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

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

◆ sip_outbound_registration_destroy()

static void sip_outbound_registration_destroy ( void * obj )

static

Destructor function for registration information.

Definition at line 1363 of file res_pjsip_outbound_registration.c.

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

Referenced by sip_outbound_registration_alloc().

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

◆ 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.

References sip_outbound_registration_client_state::auth_rejection_permanent.

Referenced by handle_registration_response().

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

◆ sip_outbound_registration_perform()

static int sip_outbound_registration_perform ( void * data )

static

Helper function which performs a single registration.

Definition at line 1708 of file res_pjsip_outbound_registration.c.

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

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

◆ 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 1603 of file res_pjsip_outbound_registration.c.

Referenced by sip_outbound_registration_apply().

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

◆ 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 1207 of file res_pjsip_outbound_registration.c.

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

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

◆ 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 1314 of file res_pjsip_outbound_registration.c.

Referenced by sip_outbound_registration_apply().

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

◆ sip_outbound_registration_state_destroy()

static void sip_outbound_registration_state_destroy ( void * obj )

static

Destructor function for registration state.

Definition at line 1276 of file res_pjsip_outbound_registration.c.

References ao2_cleanup, ao2_ref, ast_debug, ast_log, ast_sip_push_task(), sip_outbound_registration_state::client_state, sip_outbound_registration::client_uri, handle_client_state_destruction(), LOG_WARNING, sip_outbound_registration_state::registration, sip_outbound_registration_client_state::serializer, and sip_outbound_registration::server_uri.

Referenced by sip_outbound_registration_state_alloc().

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

◆ 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.

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

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

◆ 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.

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

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

◆ unload_module()

static int unload_module ( void )

static

Definition at line 2461 of file res_pjsip_outbound_registration.c.

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(), LOG_WARNING, MAX_UNLOAD_TIMEOUT_TIME, NULL, registration_transport_shutdown_cb(), and stasis_unsubscribe_and_join().

Referenced by load_module(), and reload_module().

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

◆ unregister_all()

static void unregister_all ( void )

static

Definition at line 1904 of file res_pjsip_outbound_registration.c.

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

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

◆ unregister_task()

static int unregister_task ( void * obj )

static

Definition at line 1860 of file res_pjsip_outbound_registration.c.

References add_configured_supported_headers(), ao2_ref, ast_debug, cancel_registration(), sip_outbound_registration_client_state::client, sip_outbound_registration_state::client_state, sip_outbound_registration::client_uri, sip_to_pjsip::info(), sip_outbound_registration_state::registration, registration_client_send(), and sip_outbound_registration::server_uri.

Referenced by queue_unregister().

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

◆ 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.

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

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

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 = "30ef0c93b36035ec78c9cfd712d36d9b" , .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 2628 of file res_pjsip_outbound_registration.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2628 of file res_pjsip_outbound_registration.c.

◆ cli_formatter

struct ast_sip_cli_formatter_entry* cli_formatter

static

Definition at line 2330 of file res_pjsip_outbound_registration.c.

◆ cli_outbound_registration

struct ast_cli_entry cli_outbound_registration[]

static

Definition at line 2311 of file res_pjsip_outbound_registration.c.

◆ line_identifier

struct ast_sip_endpoint_identifier line_identifier

static

Initial value:

= {
   .identify_endpoint = line_identify,
}

Definition at line 539 of file res_pjsip_outbound_registration.c.

◆ 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.

◆ observer_callbacks_auth

const struct ast_sorcery_observer observer_callbacks_auth

static

Initial value:

= {
   .loaded = auth_observer,
}

Definition at line 2368 of file res_pjsip_outbound_registration.c.

◆ observer_callbacks_registrations

const struct ast_sorcery_instance_observer observer_callbacks_registrations

static

Initial value:

= {
   .object_type_loaded = registration_loaded_observer,
}

Definition at line 2426 of file res_pjsip_outbound_registration.c.

◆ 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 2446 of file res_pjsip_outbound_registration.c.

◆ 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.

Data Structures

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ DEFAULT_STATE_BUCKETS

◆ LINE_PARAMETER_SIZE

◆ MAX_UNLOAD_TIMEOUT_TIME

◆ REGISTRATION_URI_FIELD_LEN

◆ REREGISTER_BUFFER_TIME

Enumeration Type Documentation

◆ sip_outbound_registration_status

Function Documentation

◆ __init_register_callback_invoked()

◆ __reg_module()

◆ __unreg_module()

◆ add_configured_supported_headers()

◆ add_to_supported_header()

◆ ami_outbound_registration_detail()

◆ ami_outbound_registration_task()

◆ ami_register()

◆ ami_show_outbound_registrations()

◆ ami_unregister()

◆ AO2_GLOBAL_OBJ_STATIC()

◆ AST_MODULE_SELF_SYM()

◆ auth_observer()

◆ can_reuse_registration()

◆ cancel_registration()

◆ check_state()

◆ cli_complete_registration()

◆ cli_get_container()

◆ cli_iterator()

◆ cli_print_body()

◆ cli_print_header()

◆ cli_register()

◆ cli_retrieve_by_id()

◆ cli_unregister()

◆ fetch_google_access_token()

◆ get_registrations()

◆ get_state()

◆ get_uri_option_line()

◆ handle_client_registration()

◆ handle_client_state_destruction()

◆ handle_registration_response()

◆ line_identify()

◆ line_identify_relationship()

◆ load_module()

◆ monitor_matcher()

◆ my_cli_traverse_objects()

◆ network_change_stasis_cb()

◆ outbound_auth_handler()

◆ outbound_auths_to_str()

◆ outbound_auths_to_var_list()

◆ queue_register()

◆ queue_unregister()

◆ registration_client_send()

◆ registration_deleted_observer()

◆ registration_loaded_observer()

◆ registration_response_destroy()

◆ registration_state_cmp()

◆ registration_state_hash()

◆ registration_transport_monitor_setup()

◆ registration_transport_shutdown_cb()

◆ reload_module()

◆ reregister_all()

◆ reregister_immediately_cb()

◆ save_response_fields_to_transport()

◆ schedule_registration()

◆ schedule_retry()

◆ set_outbound_initial_authentication_credentials()

◆ sip_dialog_create_contact()

◆ sip_outbound_registration_alloc()

◆ sip_outbound_registration_apply()

◆ sip_outbound_registration_client_state_destroy()

◆ sip_outbound_registration_destroy()

◆ sip_outbound_registration_is_temporal()

◆ sip_outbound_registration_perform()

◆ sip_outbound_registration_regc_alloc()

◆ sip_outbound_registration_response_cb()