pjsip_options.c File Reference

#include "asterisk.h"
#include <pjsip.h>
#include <pjsip_ua.h>
#include <pjlib.h>
#include "asterisk/res_pjsip.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/astobj2.h"
#include "asterisk/cli.h"
#include "asterisk/time.h"
#include "asterisk/test.h"
#include "asterisk/statsd.h"
#include "include/res_pjsip_private.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/taskpool.h"

Include dependency graph for pjsip_options.c:

Go to the source code of this file.

Data Structures
struct	sip_options_aor
	Structure which contains an AOR and contacts for qualifying purposes. More...
struct	sip_options_contact_callback_data
	Structure used to contain information for an OPTIONS callback. More...
struct	sip_options_contact_observer_task_data
	Task details for adding an AOR to an endpoint state compositor. More...
struct	sip_options_endpoint_aor_status
	Structure which contains status information for an AOR feeding an endpoint state compositor. More...
struct	sip_options_endpoint_compositor_task_data
	Task details for adding an AOR to an endpoint state compositor. More...
struct	sip_options_endpoint_state_compositor
	Structure which contains composites information for endpoint state. More...
struct	sip_options_qualify_resolve_task_data
struct	sip_options_synchronize_aor_task_data
	Task data for AOR creation or updating. More...
struct	sip_options_synchronize_task_data
	Structure which contains information required to synchronize. More...
struct	sip_options_target_result
	Result of qualifying an individual address belonging to a contact resolved from an A, AAAA or SRV record. More...

Macros
#define	AOR_BUCKETS   1567
	These are the number of buckets to store AORs in.
#define	AOR_STATUS_BUCKETS   3
	These are the number of buckets (per endpoint state compositor) to use to store AOR statuses.
#define	CONTACT_BUCKETS   13
	These are the number of buckets (per AOR) to use to store contacts.
#define	CONTACT_STATUS_BUCKETS   1567
	These are the number of contact status buckets.
#define	DEFAULT_ENCODING   "identity"
#define	DEFAULT_LANGUAGE   "en"
#define	ENDPOINT_STATE_COMPOSITOR_BUCKETS   13
	These are the number of buckets to store endpoint state compositors.
#define	ENDPOINT_STATE_COMPOSITOR_INITIAL_SIZE   1
	The initial vector size for the endpoint state compositors on an AOR.
#define	MAX_UNLOAD_TIMEOUT_TIME   10 /* Seconds */
	Maximum wait time to join the below shutdown group.

Functions
static int	ami_show_contacts (struct mansession *s, const struct message *m)
static int	ami_sip_qualify (struct mansession *s, const struct message *m)
	AO2_STRING_FIELD_CMP_FN (ast_sip_contact_status, name)
	Comparator function for contact statuses.
	AO2_STRING_FIELD_CMP_FN (sip_options_aor, name)
	Comparator function for SIP OPTIONS AORs.
	AO2_STRING_FIELD_CMP_FN (sip_options_endpoint_aor_status, name)
	Comparator function for endpoint AOR status.
	AO2_STRING_FIELD_CMP_FN (sip_options_endpoint_state_compositor, name)
	Comparator function for endpoint state compositors.
	AO2_STRING_FIELD_HASH_FN (ast_sip_contact_status, name)
	Hashing function for contact statuses.
	AO2_STRING_FIELD_HASH_FN (sip_options_aor, name)
	Hashing function for OPTIONS AORs.
	AO2_STRING_FIELD_HASH_FN (sip_options_endpoint_aor_status, name)
	Hashing function for endpoint AOR status.
	AO2_STRING_FIELD_HASH_FN (sip_options_endpoint_state_compositor, name)
	Hashing function for endpoint state compositors.
	AO2_STRING_FIELD_SORT_FN (ast_sip_contact_status, name)
	Sort function for contact statuses.
static void	aor_observer_deleted (const void *obj)
	Observer callback invoked on AOR deletion.
static void	aor_observer_modified (const void *obj)
	Observer callback invoked on AOR creation or modification.
void	ast_res_pjsip_cleanup_options_handling (void)
struct ast_sip_contact_status *	ast_res_pjsip_find_or_create_contact_status (const struct ast_sip_contact *contact)
int	ast_res_pjsip_init_options_handling (int reload)
int	ast_res_pjsip_preinit_options_handling (void)
int	ast_sip_format_contact_ami (void *obj, void *arg, int flags)
	Formats the contact and sends over AMI.
const char *	ast_sip_get_contact_short_status_label (const enum ast_sip_contact_status_type status)
struct ast_sip_contact_status *	ast_sip_get_contact_status (const struct ast_sip_contact *contact)
	Retrieve the current status for a contact.
const char *	ast_sip_get_contact_status_label (const enum ast_sip_contact_status_type status)
	translate ast_sip_contact_status_type to character string.
static char *	cli_qualify (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	cli_reload_qualify_aor (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	cli_reload_qualify_endpoint (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	cli_show_qualify_aor (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	cli_show_qualify_endpoint (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	contact_observer_created (const void *obj)
	Observer callback invoked on contact creation.
static void	contact_observer_deleted (const void *obj)
	Observer callback invoked on contact deletion.
static void	contact_observer_updated (const void *obj)
	Observer callback invoked on contact update.
static int	contact_status_publish_update_task (void *obj)
	Task to notify endpoints of a contact status change.
static void	endpoint_observer_deleted (const void *obj)
	Observer callback invoked on endpoint deletion.
static void	endpoint_observer_modified (const void *obj)
	Observer callback invoked on endpoint creation or modification.
static int	format_ami_contact_status (const struct ast_sip_endpoint *endpoint, struct ast_sip_ami *ami)
static int	format_ami_contactlist_handler (void *obj, void *arg, int flags)
static int	format_contact_status_for_aor (void *obj, void *arg, int flags)
static struct ao2_container *	get_all_contacts (void)
static int	has_qualify_changed (const struct ast_sip_contact *contact, const struct sip_options_aor *aor_options)
	Check if the contact qualify options are different than local aor qualify options.
static pj_bool_t	options_on_rx_request (pjsip_rx_data *rdata)
static void	qualify_contact_cb (void *token, pjsip_event *e)
	Callback for an OPTIONS response, timeout, or transport error.
static pj_status_t	send_options_response (pjsip_rx_data *rdata, int code)
static struct ast_sip_contact_status *	sip_contact_status_alloc (const char *name)
static struct ast_sip_contact_status *	sip_contact_status_copy (const struct ast_sip_contact_status *src)
static void	sip_contact_status_dtor (void *obj)
	Destructor for contact statuses.
static int	sip_contact_to_ami (const struct ast_sip_contact *contact, struct ast_str **buf)
static struct sip_options_aor *	sip_options_aor_alloc (struct ast_sip_aor *aor)
	Allocator for AOR OPTIONS.
static void	sip_options_aor_dtor (void *obj)
	Destructor function for SIP OPTIONS AORs.
static int	sip_options_aor_observer_deleted_task (void *obj)
	Task to delete an AOR from the known universe.
static int	sip_options_aor_observer_modified_task (void *obj)
	Task to synchronize the AOR.
static int	sip_options_aor_remove_task (void *obj)
	Task which removes an AOR from all of the ESCs it is reporting to.
static void	sip_options_apply_aor_configuration (struct sip_options_aor *aor_options, struct ast_sip_aor *aor, int is_new)
	Function which applies configuration to an AOR options structure.
static pj_status_t	sip_options_apply_transport_to_destination (const pjsip_tx_data *tdata, pjsip_host_info *destination)
	Apply a request's transport selector to its DNS destination.
static void	sip_options_cancel_target_transactions (struct sip_options_contact_callback_data *batch)
	Terminate all in-flight target transactions for a batch.
static int	sip_options_cleanup_aor_task (void *obj)
	Management task to clean up an AOR.
static int	sip_options_cleanup_task (void *obj)
	Management task to clean up the environment.
static int	sip_options_contact_add_management_task (void *obj)
	Task to add a dynamic contact to an AOR in its serializer.
static int	sip_options_contact_add_task (void *obj)
	Task which adds a dynamic contact to an AOR.
static struct sip_options_contact_callback_data *	sip_options_contact_callback_data_alloc (struct ast_sip_contact *contact, struct sip_options_aor *aor_options, struct ast_sip_endpoint *endpoint, pjsip_tx_data *resolve_tdata)
	Contact callback data allocator.
static void	sip_options_contact_callback_data_dtor (void *obj)
	Destructor for contact callback data.
static int	sip_options_contact_delete_management_task (void *obj)
	Task to delete a contact from an AOR in its serializer.
static int	sip_options_contact_delete_task (void *obj)
	Task which deletes a dynamic contact from an AOR.
static int	sip_options_contact_status_available_count (void *obj, void *arg, int flags)
	Count AVAILABLE qualified contacts.
static int	sip_options_contact_status_notify_task (void *obj)
	Task to notify an AOR of a contact status change.
static void	sip_options_contact_status_update (struct ast_sip_contact_status *contact_status)
static struct ao2_container *	sip_options_contact_statuses_alloc (void)
	Helper function to allocate a contact statuses container.
static int	sip_options_contact_update_task (void *obj)
	Task which updates a dynamic contact to an AOR.
static int	sip_options_determine_initial_qualify_time (int qualify_frequency)
	Determine an initial time for scheduling AOR qualifying.
static int	sip_options_endpoint_compositor_add_task (void *obj)
	Task which adds an AOR to an endpoint state compositor.
static int	sip_options_endpoint_compositor_remove_task (void *obj)
	Task which adds removes an AOR from an endpoint state compositor.
static int	sip_options_endpoint_observer_deleted_task (void *obj)
	Task to delete an endpoint from the known universe.
static int	sip_options_endpoint_observer_modified_task (void *obj)
	Task to synchronize the endpoint.
static void	sip_options_endpoint_state_compositor_dtor (void *obj)
	Destructor for endpoint state compositors.
static struct sip_options_endpoint_state_compositor *	sip_options_endpoint_state_compositor_find_or_alloc (const struct ast_sip_endpoint *endpoint)
	Find (or create) an endpoint state compositor.
static void	sip_options_endpoint_unlink_aor_feeders (struct ast_sip_endpoint *endpoint, struct sip_options_endpoint_state_compositor *endpoint_state_compositor)
	Unlink AORs feeding the endpoint status compositor.
static enum ast_endpoint_state	sip_options_get_endpoint_state_compositor_state (const struct sip_options_endpoint_state_compositor *endpoint_state_compositor)
	Return the current state of an endpoint state compositor.
static int	sip_options_init_task (void *mgmt_serializer)
	Management task to finish setting up the environment.
static void	sip_options_notify_endpoint_state_compositors (struct sip_options_aor *aor_options, enum ast_sip_contact_status_type status)
	Function which notifies endpoint state compositors of a state change of an AOR.
static void	sip_options_publish_contact_state (const struct sip_options_aor *aor_options, const struct ast_sip_contact_status *contact_status)
	Function which publishes a contact status update to all interested endpoints.
static int	sip_options_qualify_aor (void *obj)
	Task to qualify contacts of an AOR.
static int	sip_options_qualify_contact (void *obj, void *arg, int flags)
	Send a SIP OPTIONS request for a contact.
static void	sip_options_qualify_resolve_cb (pj_status_t status, void *token, const pjsip_server_addresses *addresses)
	DNS callback used to fan out a qualify to every resolved target.
static int	sip_options_qualify_resolve_task (void *obj)
	Process a DNS resolution result on the AOR serializer.
static void	sip_options_qualify_resolve_task_dtor (void *obj)
static void	sip_options_queue_target_result (struct sip_options_contact_callback_data *batch, enum ast_sip_contact_status_type status)
	Queue a resolved target's qualification result to be combined with the other targets.
static int	sip_options_remove_contact (void *obj, void *arg, int flags)
	Forward declaration of this helpful function.
static void	sip_options_remove_contact_status (struct sip_options_aor *aor_options, struct ast_sip_contact *contact)
	Remove contact status for a hint.
static void	sip_options_set_contact_status (struct ast_sip_contact_status *contact_status, enum ast_sip_contact_status_type status)
	Set the contact status for a contact.
static int	sip_options_set_contact_status_qualified (void *obj, void *arg, int flags)
	Transition the contact status to qualified mode.
static int	sip_options_set_contact_status_unqualified (void *obj, void *arg, int flags)
	Transition the contact status to unqualified mode.
static void	sip_options_synchronize (int reload)
	Synchronize our local container of AORs and endpoint state compositors with the current configuration.
static int	sip_options_synchronize_aor (void *obj, void *arg, int flags)
	Synchronize an AOR with our local state.
static int	sip_options_synchronize_aor_task (void *obj)
	Task to synchronize an AOR with our local state.
static int	sip_options_synchronize_endpoint (void *obj, void *arg, int flags)
	Synchronize an endpoint with our local state.
static int	sip_options_synchronize_task (void *obj)
	Task to synchronize our local container of AORs and endpoint state compositors with the current configuration.
static void	sip_options_target_result_dtor (void *obj)
	Destructor for a resolved target's qualification result.
static int	sip_options_target_result_task (void *obj)
	Combine the result of one resolved target with the other targets.
static void	sip_options_transaction_free (pjsip_transaction *tsx)
static int	sip_options_unused_aor (void *obj, void *arg, int flags)
	Callback which removes any unused AORs that remained after reloading.
static int	sip_options_unused_endpoint_state_compositor (void *obj, void *arg, int flags)
	Callback function used to unlink and remove event state compositors that have no AORs feeding them.
static int	sip_options_update_aor_task (void *obj)
	Task to synchronize an AOR with our local state.
static void	sip_options_update_endpoint_state_compositor_aor (struct sip_options_endpoint_state_compositor *endpoint_state_compositor, const char *name, enum ast_sip_contact_status_type status)
	Update the AOR status on an endpoint state compositor.

Variables
static const struct ast_sorcery_observer	aor_observer_callbacks
	Observer callbacks for AORs.
static struct ast_cli_entry	cli_options []
static const struct ast_sorcery_observer	contact_observer_callbacks
	Observer callbacks for contacts.
static struct ast_sip_endpoint_formatter	contact_status_formatter
static const struct ast_sorcery_observer	endpoint_observer_callbacks
	Observer callbacks for endpoints.
static struct ast_taskprocessor *	management_serializer
static pjsip_module	options_module
static const char *	short_status_map []
static struct ao2_container *	sip_options_aors
static struct ao2_container *	sip_options_contact_statuses
static struct ao2_container *	sip_options_endpoint_state_compositors
static const char *	status_map []

Macro Definition Documentation

AOR_BUCKETS

#define AOR_BUCKETS   1567

These are the number of buckets to store AORs in.

Definition at line 103 of file pjsip_options.c.

AOR_STATUS_BUCKETS

#define AOR_STATUS_BUCKETS   3

These are the number of buckets (per endpoint state compositor) to use to store AOR statuses.

Definition at line 123 of file pjsip_options.c.

CONTACT_BUCKETS

#define CONTACT_BUCKETS   13

These are the number of buckets (per AOR) to use to store contacts.

Definition at line 114 of file pjsip_options.c.

CONTACT_STATUS_BUCKETS

#define CONTACT_STATUS_BUCKETS   1567

These are the number of contact status buckets.

Definition at line 110 of file pjsip_options.c.

DEFAULT_ENCODING

#define DEFAULT_ENCODING   "identity"

Definition at line 97 of file pjsip_options.c.

DEFAULT_LANGUAGE

#define DEFAULT_LANGUAGE   "en"

Definition at line 96 of file pjsip_options.c.

ENDPOINT_STATE_COMPOSITOR_BUCKETS

#define ENDPOINT_STATE_COMPOSITOR_BUCKETS   13

These are the number of buckets to store endpoint state compositors.

Definition at line 117 of file pjsip_options.c.

ENDPOINT_STATE_COMPOSITOR_INITIAL_SIZE

#define ENDPOINT_STATE_COMPOSITOR_INITIAL_SIZE   1

The initial vector size for the endpoint state compositors on an AOR.

Definition at line 120 of file pjsip_options.c.

MAX_UNLOAD_TIMEOUT_TIME

#define MAX_UNLOAD_TIMEOUT_TIME   10 /* Seconds */

Maximum wait time to join the below shutdown group.

Definition at line 126 of file pjsip_options.c.

Function Documentation

ami_show_contacts()

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

static

Definition at line 2859 of file pjsip_options.c.

{
    struct ast_sip_ami ami = { .s = s, .m = m, .action_id = astman_get_header(m, "ActionID"), };
    struct ao2_container *contacts;
 
    contacts = get_all_contacts();
    if (!contacts) {
        astman_send_error(s, m, "Could not get Contacts\n");
        return 0;
    }
 
    if (!ao2_container_count(contacts)) {
        astman_send_error(s, m, "No Contacts found\n");
        ao2_ref(contacts, -1);
        return 0;
    }
 
    astman_send_listack(s, m, "A listing of Contacts follows, presented as ContactList events",
            "start");
 
    ao2_callback(contacts, OBJ_NODATA, format_ami_contactlist_handler, &ami);
 
    astman_send_list_complete_start(s, m, "ContactListComplete", ami.count);
    astman_send_list_complete_end(s);
 
    ao2_ref(contacts, -1);
 
    return 0;
}

References ao2_callback, ao2_container_count(), ao2_ref, astman_get_header(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), ast_sip_ami::count, format_ami_contactlist_handler(), get_all_contacts(), ast_sip_ami::m, OBJ_NODATA, and ast_sip_ami::s.

Referenced by ast_res_pjsip_init_options_handling().

ami_sip_qualify()

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

static

Definition at line 3074 of file pjsip_options.c.

{
    const char *endpoint_name = astman_get_header(m, "Endpoint");
    RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
    char *aors;
    char *aor_name;
 
    if (ast_strlen_zero(endpoint_name)) {
        astman_send_error(s, m, "Endpoint parameter missing.");
        return 0;
    }
 
    endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
        endpoint_name);
    if (!endpoint) {
        astman_send_error(s, m, "Unable to retrieve endpoint\n");
        return 0;
    }
 
    /* send a qualify for all contacts registered with the endpoint */
    if (ast_strlen_zero(endpoint->aors)) {
        astman_send_error(s, m, "No AoRs configured for endpoint\n");
        return 0;
    }
 
    aors = ast_strdupa(endpoint->aors);
    while ((aor_name = ast_strip(strsep(&aors, ",")))) {
        struct sip_options_aor *aor_options;
 
        aor_options = ao2_find(sip_options_aors, aor_name, OBJ_SEARCH_KEY);
        if (!aor_options) {
            continue;
        }
 
        ast_sip_push_task_wait_serializer(aor_options->serializer, sip_options_qualify_aor,
            aor_options);
        ao2_ref(aor_options, -1);
    }
 
    astman_send_ack(s, m, "Endpoint found, will qualify");
    return 0;
}

References ao2_cleanup, ao2_find, ao2_ref, ast_sip_get_sorcery(), ast_sip_push_task_wait_serializer, ast_sorcery_retrieve_by_id(), ast_strdupa, ast_strip(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), NULL, OBJ_SEARCH_KEY, RAII_VAR, sip_options_aor::serializer, sip_options_aors, sip_options_qualify_aor(), and strsep().

Referenced by ast_res_pjsip_init_options_handling().

AO2_STRING_FIELD_CMP_FN() [1/4]

AO2_STRING_FIELD_CMP_FN	(	ast_sip_contact_status	,
		name
	)

Comparator function for contact statuses.

AO2_STRING_FIELD_CMP_FN() [2/4]

AO2_STRING_FIELD_CMP_FN	(	sip_options_aor	,
		name
	)

Comparator function for SIP OPTIONS AORs.

AO2_STRING_FIELD_CMP_FN() [3/4]

AO2_STRING_FIELD_CMP_FN	(	sip_options_endpoint_aor_status	,
		name
	)

Comparator function for endpoint AOR status.

AO2_STRING_FIELD_CMP_FN() [4/4]

AO2_STRING_FIELD_CMP_FN	(	sip_options_endpoint_state_compositor	,
		name
	)

Comparator function for endpoint state compositors.

AO2_STRING_FIELD_HASH_FN() [1/4]

AO2_STRING_FIELD_HASH_FN	(	ast_sip_contact_status	,
		name
	)

Hashing function for contact statuses.

AO2_STRING_FIELD_HASH_FN() [2/4]

AO2_STRING_FIELD_HASH_FN	(	sip_options_aor	,
		name
	)

Hashing function for OPTIONS AORs.

AO2_STRING_FIELD_HASH_FN() [3/4]

AO2_STRING_FIELD_HASH_FN	(	sip_options_endpoint_aor_status	,
		name
	)

Hashing function for endpoint AOR status.

AO2_STRING_FIELD_HASH_FN() [4/4]

AO2_STRING_FIELD_HASH_FN	(	sip_options_endpoint_state_compositor	,
		name
	)

Hashing function for endpoint state compositors.

AO2_STRING_FIELD_SORT_FN()

AO2_STRING_FIELD_SORT_FN	(	ast_sip_contact_status	,
		name
	)

Sort function for contact statuses.

aor_observer_deleted()

static void aor_observer_deleted ( const void *  obj )

static

Observer callback invoked on AOR deletion.

Definition at line 2451 of file pjsip_options.c.

{
    ast_sip_push_task_wait_serializer(management_serializer,
        sip_options_aor_observer_deleted_task, (void *) obj);
}

References ast_sip_push_task_wait_serializer, management_serializer, and sip_options_aor_observer_deleted_task().

aor_observer_modified()

static void aor_observer_modified ( const void *  obj )

static

Observer callback invoked on AOR creation or modification.

Definition at line 2420 of file pjsip_options.c.

{
    ast_sip_push_task_wait_serializer(management_serializer,
        sip_options_aor_observer_modified_task, (void *) obj);
}

References ast_sip_push_task_wait_serializer, management_serializer, and sip_options_aor_observer_modified_task().

ast_res_pjsip_cleanup_options_handling()

void ast_res_pjsip_cleanup_options_handling

(

void

)

Definition at line 3246 of file pjsip_options.c.

{
    struct ast_taskprocessor *mgmt_serializer;
 
    ast_cli_unregister_multiple(cli_options, ARRAY_LEN(cli_options));
    ast_manager_unregister("PJSIPQualify");
    ast_manager_unregister("PJSIPShowContacts");
    ast_sip_unregister_endpoint_formatter(&contact_status_formatter);
 
    ast_sorcery_observer_remove(ast_sip_get_sorcery(), "contact",
        &contact_observer_callbacks);
    ast_sorcery_observer_remove(ast_sip_get_sorcery(), "aor",
        &aor_observer_callbacks);
    ast_sorcery_observer_remove(ast_sip_get_sorcery(), "endpoint",
        &endpoint_observer_callbacks);
 
    mgmt_serializer = management_serializer;
    management_serializer = NULL;
    if (mgmt_serializer) {
        ast_sip_push_task_wait_serializer(mgmt_serializer, sip_options_cleanup_task, NULL);
        ast_taskprocessor_unreference(mgmt_serializer);
    }
 
    ao2_cleanup(sip_options_aors);
    sip_options_aors = NULL;
    ao2_cleanup(sip_options_contact_statuses);
    sip_options_contact_statuses = NULL;
    ao2_cleanup(sip_options_endpoint_state_compositors);
    sip_options_endpoint_state_compositors = NULL;
 
    pjsip_endpt_unregister_module(ast_sip_get_pjsip_endpoint(), &options_module);
}

References ao2_cleanup, aor_observer_callbacks, ARRAY_LEN, ast_cli_unregister_multiple(), ast_manager_unregister(), ast_sip_get_pjsip_endpoint(), ast_sip_get_sorcery(), ast_sip_push_task_wait_serializer, ast_sip_unregister_endpoint_formatter(), ast_sorcery_observer_remove(), ast_taskprocessor_unreference(), cli_options, contact_observer_callbacks, contact_status_formatter, endpoint_observer_callbacks, management_serializer, NULL, options_module, sip_options_aors, sip_options_cleanup_task(), sip_options_contact_statuses, and sip_options_endpoint_state_compositors.

Referenced by ast_res_pjsip_init_options_handling(), and unload_pjsip().

ast_res_pjsip_find_or_create_contact_status()

struct ast_sip_contact_status * ast_res_pjsip_find_or_create_contact_status

(

const struct ast_sip_contact *

contact

)

Definition at line 463 of file pjsip_options.c.

{
    struct ast_sip_contact_status *contact_status;
    int res;
 
    /*
     * At startup a contact status can be retrieved when static contacts
     * are themselves being setup.  This happens before we are fully setup.
     * Since we don't actually trigger qualify or anything as a result it
     * is safe to do so.  They'll just get back a contact status that will
     * be updated later.  At this time they only care that the contact
     * status gets created for the static contact anyway.
     */
    if (!sip_options_contact_statuses) {
        /*
         * We haven't been pre-initialized or we are shutting down.
         * Neither situation should happen.
         */
        ast_assert(0);
        return NULL;
    }
 
    ao2_lock(sip_options_contact_statuses);
 
    /* If contact status for this contact already exists just return it */
    contact_status = ao2_find(sip_options_contact_statuses,
        ast_sorcery_object_get_id(contact), OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (contact_status) {
        ao2_unlock(sip_options_contact_statuses);
        return contact_status;
    }
 
    /* Otherwise we have to create and store a new contact status */
    contact_status = sip_contact_status_alloc(ast_sorcery_object_get_id(contact));
    if (!contact_status) {
        ao2_unlock(sip_options_contact_statuses);
        return NULL;
    }
 
    contact_status->rtt = 0;
    contact_status->status = CREATED;
    contact_status->last_status = CREATED;
    res = ast_string_field_set(contact_status, uri, contact->uri);
    res |= ast_string_field_set(contact_status, aor, contact->aor);
    if (res) {
        ao2_unlock(sip_options_contact_statuses);
        ao2_ref(contact_status, -1);
        return NULL;
    }
 
    ao2_link_flags(sip_options_contact_statuses, contact_status, OBJ_NOLOCK);
    ao2_unlock(sip_options_contact_statuses);
 
    ast_statsd_log_string_va("PJSIP.contacts.states.%s", AST_STATSD_GAUGE,
        "+1", 1.0, ast_sip_get_contact_status_label(contact_status->status));
 
    sip_options_contact_status_update(contact_status);
 
    return contact_status;
}

References ao2_find, ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, ast_sip_contact::aor, ast_sip_contact_status::aor, ast_assert, ast_sip_get_contact_status_label(), ast_sorcery_object_get_id(), AST_STATSD_GAUGE, ast_statsd_log_string_va(), ast_string_field_set, CREATED, ast_sip_contact_status::last_status, NULL, OBJ_NOLOCK, OBJ_SEARCH_KEY, ast_sip_contact_status::rtt, sip_contact_status_alloc(), sip_options_contact_status_update(), sip_options_contact_statuses, ast_sip_contact_status::status, ast_sip_contact::uri, and ast_sip_contact_status::uri.

Referenced by contact_apply_handler(), permanent_uri_handler(), sip_options_contact_add_task(), sip_options_contact_status_available_count(), sip_options_qualify_contact(), sip_options_set_contact_status_qualified(), and sip_options_set_contact_status_unqualified().

ast_res_pjsip_init_options_handling()

int ast_res_pjsip_init_options_handling

(

int

reload

)

Definition at line 3311 of file pjsip_options.c.

{
    struct ast_taskprocessor *mgmt_serializer;
 
    static const pj_str_t STR_OPTIONS = { "OPTIONS", 7 };
 
    if (reload) {
        sip_options_synchronize(1);
        return 0;
    }
 
    if (pjsip_endpt_register_module(ast_sip_get_pjsip_endpoint(), &options_module)
        != PJ_SUCCESS) {
        return -1;
    }
 
    if (pjsip_endpt_add_capability(ast_sip_get_pjsip_endpoint(), NULL, PJSIP_H_ALLOW,
        NULL, 1, &STR_OPTIONS) != PJ_SUCCESS) {
        ast_res_pjsip_cleanup_options_handling();
        return -1;
    }
 
    sip_options_aors = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_RWLOCK, 0, AOR_BUCKETS,
        sip_options_aor_hash_fn, NULL, sip_options_aor_cmp_fn);
    if (!sip_options_aors) {
        ast_res_pjsip_cleanup_options_handling();
        return -1;
    }
    sip_options_endpoint_state_compositors =
        ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_RWLOCK, 0,
            ENDPOINT_STATE_COMPOSITOR_BUCKETS,
            sip_options_endpoint_state_compositor_hash_fn, NULL,
            sip_options_endpoint_state_compositor_cmp_fn);
    if (!sip_options_endpoint_state_compositors) {
        ast_res_pjsip_cleanup_options_handling();
        return -1;
    }
 
    mgmt_serializer = ast_sip_create_serializer("pjsip/options/manage");
    if (!mgmt_serializer) {
        ast_res_pjsip_cleanup_options_handling();
        return -1;
    }
 
    /*
     * Set the water mark levels high because we can get a flood of
     * contact status updates from sip_options_synchronize() that
     * quickly clears on initial load or reload.
     */
    ast_taskprocessor_alert_set_levels(mgmt_serializer, -1,
        10 * AST_TASKPROCESSOR_HIGH_WATER_LEVEL);
 
    /*
     * We make sure that the environment is completely setup before we allow
     * any other threads to post contact_status updates to the
     * management_serializer.
     */
    if (ast_sip_push_task_wait_serializer(mgmt_serializer, sip_options_init_task,
        mgmt_serializer)) {
        /* Set management_serializer in case pushing the task actually failed. */
        management_serializer = mgmt_serializer;
        ast_res_pjsip_cleanup_options_handling();
        return -1;
    }
 
    ast_sip_register_endpoint_formatter(&contact_status_formatter);
    ast_manager_register_xml("PJSIPQualify", EVENT_FLAG_SYSTEM | EVENT_FLAG_REPORTING,
        ami_sip_qualify);
    ast_manager_register_xml("PJSIPShowContacts", EVENT_FLAG_SYSTEM, ami_show_contacts);
    ast_cli_register_multiple(cli_options, ARRAY_LEN(cli_options));
 
    return 0;
}

References ami_show_contacts(), ami_sip_qualify(), AO2_ALLOC_OPT_LOCK_RWLOCK, ao2_container_alloc_hash, AOR_BUCKETS, ARRAY_LEN, ast_cli_register_multiple, ast_manager_register_xml, ast_res_pjsip_cleanup_options_handling(), ast_sip_create_serializer(), ast_sip_get_pjsip_endpoint(), ast_sip_push_task_wait_serializer, ast_sip_register_endpoint_formatter(), ast_taskprocessor_alert_set_levels(), AST_TASKPROCESSOR_HIGH_WATER_LEVEL, cli_options, contact_status_formatter, ENDPOINT_STATE_COMPOSITOR_BUCKETS, EVENT_FLAG_REPORTING, EVENT_FLAG_SYSTEM, management_serializer, NULL, options_module, reload(), sip_options_aors, sip_options_endpoint_state_compositors, sip_options_init_task(), and sip_options_synchronize().

Referenced by load_module(), and reload_configuration_task().

ast_res_pjsip_preinit_options_handling()

int ast_res_pjsip_preinit_options_handling

(

void

)

Definition at line 3305 of file pjsip_options.c.

{
    sip_options_contact_statuses = sip_options_contact_statuses_alloc();
    return sip_options_contact_statuses ? 0 : -1;
}

References sip_options_contact_statuses, and sip_options_contact_statuses_alloc().

Referenced by load_module().

ast_sip_format_contact_ami()

int ast_sip_format_contact_ami	(	void *	obj,
		void *	arg,
		int	flags
	)

Formats the contact and sends over AMI.

Parameters

obj	a pointer an ast_sip_contact_wrapper structure
arg	a pointer to an ast_sip_ami structure
flags	ignored

Return values

0	Success, otherwise non-zero on error

Definition at line 3125 of file pjsip_options.c.

{
    struct ast_sip_contact_wrapper *wrapper = obj;
    struct ast_sip_contact *contact = wrapper->contact;
    struct ast_sip_ami *ami = arg;
    struct ast_sip_contact_status *status;
    struct ast_str *buf;
    const struct ast_sip_endpoint *endpoint = ami->arg;
    char secs[AST_TIME_T_LEN];
 
    buf = ast_sip_create_ami_event("ContactStatusDetail", ami);
    if (!buf) {
        return -1;
    }
 
    status = ast_sip_get_contact_status(contact);
 
    ast_str_append(&buf, 0, "AOR: %s\r\n", wrapper->aor_id);
    ast_str_append(&buf, 0, "URI: %s\r\n", contact->uri);
    ast_str_append(&buf, 0, "UserAgent: %s\r\n", contact->user_agent);
    ast_time_t_to_string(contact->expiration_time.tv_sec, secs, sizeof(secs));
    ast_str_append(&buf, 0, "RegExpire: %s\r\n", secs);
    if (!ast_strlen_zero(contact->via_addr)) {
        ast_str_append(&buf, 0, "ViaAddress: %s", contact->via_addr);
        if (contact->via_port) {
            ast_str_append(&buf, 0, ":%d", contact->via_port);
        }
        ast_str_append(&buf, 0, "\r\n");
    }
    if (!ast_strlen_zero(contact->call_id)) {
        ast_str_append(&buf, 0, "CallID: %s\r\n", contact->call_id);
    }
    ast_str_append(&buf, 0, "Status: %s\r\n",
        ast_sip_get_contact_status_label(status ? status->status : UNKNOWN));
    if (!status || status->status != AVAILABLE) {
        ast_str_append(&buf, 0, "RoundtripUsec: N/A\r\n");
    } else {
        ast_str_append(&buf, 0, "RoundtripUsec: %" PRId64 "\r\n", status->rtt);
    }
    ast_str_append(&buf, 0, "EndpointName: %s\r\n",
        endpoint ? ast_sorcery_object_get_id(endpoint) : S_OR(contact->endpoint_name, ""));
 
    ast_str_append(&buf, 0, "ID: %s\r\n", ast_sorcery_object_get_id(contact));
    ast_str_append(&buf, 0, "AuthenticateQualify: %d\r\n", contact->authenticate_qualify);
    ast_str_append(&buf, 0, "OutboundProxy: %s\r\n", contact->outbound_proxy);
    ast_str_append(&buf, 0, "Path: %s\r\n", contact->path);
    ast_str_append(&buf, 0, "QualifyFrequency: %u\r\n", contact->qualify_frequency);
    ast_str_append(&buf, 0, "QualifyTimeout: %.3f\r\n", contact->qualify_timeout);
    ast_str_append(&buf, 0, "Qualify2xxOnly: %d\r\n", contact->qualify_2xx_only);
 
    astman_append(ami->s, "%s\r\n", ast_str_buffer(buf));
    ami->count++;
 
    ast_free(buf);
    ao2_cleanup(status);
    return 0;
}

References ao2_cleanup, ast_sip_contact_wrapper::aor_id, ast_sip_ami::arg, ast_free, ast_sip_create_ami_event(), ast_sip_get_contact_status(), ast_sip_get_contact_status_label(), ast_sorcery_object_get_id(), ast_str_append(), ast_str_buffer(), ast_strlen_zero(), AST_TIME_T_LEN, ast_time_t_to_string(), astman_append(), ast_sip_contact::authenticate_qualify, AVAILABLE, buf, ast_sip_contact::call_id, ast_sip_contact_wrapper::contact, ast_sip_ami::count, ast_sip_contact::endpoint_name, ast_sip_contact::expiration_time, ast_sip_contact::outbound_proxy, ast_sip_contact::path, ast_sip_contact::qualify_2xx_only, ast_sip_contact::qualify_frequency, ast_sip_contact::qualify_timeout, ast_sip_ami::s, S_OR, status, UNKNOWN, ast_sip_contact::uri, ast_sip_contact::user_agent, ast_sip_contact::via_addr, and ast_sip_contact::via_port.

Referenced by ami_show_registration_contact_statuses(), and format_contact_status_for_aor().

ast_sip_get_contact_short_status_label()

const char * ast_sip_get_contact_short_status_label

(

const enum ast_sip_contact_status_type

status

)

Definition at line 338 of file pjsip_options.c.

{
    ast_assert(0 <= status && status < ARRAY_LEN(short_status_map));
    return short_status_map[status];
}

References ARRAY_LEN, ast_assert, short_status_map, and status.

Referenced by cli_contact_print_body().

ast_sip_get_contact_status()

struct ast_sip_contact_status * ast_sip_get_contact_status

(

const struct ast_sip_contact *

contact

)

Retrieve the current status for a contact.

Parameters

contact

The contact.

Return values

non-NULL	Success
NULL	Status information not found

Note

The returned contact status object is immutable.

Definition at line 524 of file pjsip_options.c.

{
    return ao2_find(sip_options_contact_statuses, ast_sorcery_object_get_id(contact),
        OBJ_SEARCH_KEY);
}

References ao2_find, ast_sorcery_object_get_id(), OBJ_SEARCH_KEY, and sip_options_contact_statuses.

Referenced by add_outgoing_request_headers(), ast_sip_format_contact_ami(), cli_contact_print_body(), contact_add_security_headers_to_status(), contact_has_security_mechanisms(), contact_remove_unreachable(), format_ami_contactlist_handler(), pjsip_contact_function_read(), registrar_add_unreachable(), rfc3329_incoming_response(), sip_options_contact_update_task(), and vec_contact_cmp().

ast_sip_get_contact_status_label()

const char * ast_sip_get_contact_status_label

(

const enum ast_sip_contact_status_type

status

)

translate ast_sip_contact_status_type to character string.

Return values

the	character string equivalent.

Definition at line 332 of file pjsip_options.c.

{
    ast_assert(0 <= status && status < ARRAY_LEN(status_map));
    return status_map[status];
}

References ARRAY_LEN, ast_assert, and status.

Referenced by ast_res_pjsip_find_or_create_contact_status(), ast_sip_format_contact_ami(), ast_sip_initialize_sorcery_location(), ast_sip_persistent_endpoint_publish_contact_state(), format_ami_contactlist_handler(), pjsip_contact_function_read(), sip_options_contact_status_notify_task(), sip_options_remove_contact_status(), and sip_options_set_contact_status().

cli_qualify()

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

static

Definition at line 2752 of file pjsip_options.c.

{
    RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
    const char *endpoint_name;
    char *aors;
    char *aor_name;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "pjsip qualify";
        e->usage =
            "Usage: pjsip qualify <endpoint>\n"
            "       Send a SIP OPTIONS request to all contacts on the endpoint.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 3) {
        return CLI_SHOWUSAGE;
    }
 
    endpoint_name = a->argv[2];
 
    endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
        endpoint_name);
    if (!endpoint) {
        ast_cli(a->fd, "Unable to retrieve endpoint %s\n", endpoint_name);
        return CLI_FAILURE;
    }
 
    if (ast_strlen_zero(endpoint->aors)) {
        ast_cli(a->fd, "No AORs configured for endpoint '%s'\n", endpoint_name);
        return CLI_FAILURE;
    }
 
    aors = ast_strdupa(endpoint->aors);
    while ((aor_name = ast_strip(strsep(&aors, ",")))) {
        struct sip_options_aor *aor_options;
 
        aor_options = ao2_find(sip_options_aors, aor_name, OBJ_SEARCH_KEY);
        if (!aor_options) {
            continue;
        }
 
        ast_cli(a->fd, "Qualifying AOR '%s' on endpoint '%s'\n", aor_name, endpoint_name);
        ast_sip_push_task_wait_serializer(aor_options->serializer, sip_options_qualify_aor,
            aor_options);
        ao2_ref(aor_options, -1);
    }
 
    return CLI_SUCCESS;
}

References a, ao2_cleanup, ao2_find, ao2_ref, ast_cli(), ast_sip_get_sorcery(), ast_sip_push_task_wait_serializer, ast_sorcery_retrieve_by_id(), ast_strdupa, ast_strip(), ast_strlen_zero(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, OBJ_SEARCH_KEY, RAII_VAR, sip_options_aor::serializer, sip_options_aors, sip_options_qualify_aor(), strsep(), and ast_cli_entry::usage.

cli_reload_qualify_aor()

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

static

Definition at line 3038 of file pjsip_options.c.

{
    struct ast_sip_aor *aor;
    const char *aor_name;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "pjsip reload qualify aor";
        e->usage =
            "Usage: pjsip reload qualify aor <id>\n"
            "       Synchronize the PJSIP Aor qualify options.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 5) {
        return CLI_SHOWUSAGE;
    }
 
    aor_name = a->argv[4];
 
    aor = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "aor", aor_name);
    if (!aor) {
        ast_cli(a->fd, "Unable to retrieve aor '%s'\n", aor_name);
        return CLI_FAILURE;
    }
 
    ast_cli(a->fd, "Synchronizing AOR '%s'\n", aor_name);
    ast_sip_push_task_wait_serializer(management_serializer,
        sip_options_aor_observer_modified_task, aor);
    ao2_ref(aor, -1);
 
    return CLI_SUCCESS;
}

References a, ao2_ref, ast_cli(), ast_sip_get_sorcery(), ast_sip_push_task_wait_serializer, ast_sorcery_retrieve_by_id(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, management_serializer, NULL, sip_options_aor_observer_modified_task(), and ast_cli_entry::usage.

cli_reload_qualify_endpoint()

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

static

Definition at line 2984 of file pjsip_options.c.

{
    RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
    const char *endpoint_name;
    char *aors;
    char *aor_name;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "pjsip reload qualify endpoint";
        e->usage =
            "Usage: pjsip reload qualify endpoint <id>\n"
            "       Synchronize the qualify options for all Aors on the PJSIP endpoint.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 5) {
        return CLI_SHOWUSAGE;
    }
 
    endpoint_name = a->argv[4];
 
    endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
        endpoint_name);
    if (!endpoint) {
        ast_cli(a->fd, "Unable to retrieve endpoint %s\n", endpoint_name);
        return CLI_FAILURE;
    }
 
    if (ast_strlen_zero(endpoint->aors)) {
        ast_cli(a->fd, "No AORs configured for endpoint '%s'\n", endpoint_name);
        return CLI_FAILURE;
    }
 
    aors = ast_strdupa(endpoint->aors);
    while ((aor_name = ast_strip(strsep(&aors, ",")))) {
        struct ast_sip_aor *aor;
 
        aor = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "aor", aor_name);
        if (!aor) {
            continue;
        }
 
        ast_cli(a->fd, "Synchronizing AOR '%s' on endpoint '%s'\n", aor_name, endpoint_name);
        ast_sip_push_task_wait_serializer(management_serializer,
            sip_options_aor_observer_modified_task, aor);
        ao2_ref(aor, -1);
    }
 
    return CLI_SUCCESS;
}

References a, ao2_cleanup, ao2_ref, ast_cli(), ast_sip_get_sorcery(), ast_sip_push_task_wait_serializer, ast_sorcery_retrieve_by_id(), ast_strdupa, ast_strip(), ast_strlen_zero(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, management_serializer, NULL, RAII_VAR, sip_options_aor_observer_modified_task(), strsep(), and ast_cli_entry::usage.

cli_show_qualify_aor()

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

static

Definition at line 2946 of file pjsip_options.c.

{
    struct sip_options_aor *aor_options;
    const char *aor_name;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "pjsip show qualify aor";
        e->usage =
            "Usage: pjsip show qualify aor <id>\n"
            "       Show the PJSIP Aor current qualify options.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 5) {
        return CLI_SHOWUSAGE;
    }
 
    aor_name = a->argv[4];
 
    aor_options = ao2_find(sip_options_aors, aor_name, OBJ_SEARCH_KEY);
    if (!aor_options) {
        ast_cli(a->fd, "Unable to retrieve aor '%s' qualify options\n", aor_name);
        return CLI_FAILURE;
    }
 
    ast_cli(a->fd, " * AOR '%s'\n", aor_name);
    ast_cli(a->fd, "  Qualify frequency    : %d sec\n", aor_options->qualify_frequency);
    ast_cli(a->fd, "  Qualify timeout      : %d ms\n", (int)(aor_options->qualify_timeout / 1000));
    ast_cli(a->fd, "  Qualify 2xx only     : %s\n", aor_options->qualify_2xx_only ? "yes" : "no");
    ast_cli(a->fd, "  Authenticate qualify : %s\n", aor_options->authenticate_qualify?"yes":"no");
    ao2_ref(aor_options, -1);
 
    return CLI_SUCCESS;
}

References a, ao2_find, ao2_ref, ast_cli(), sip_options_aor::authenticate_qualify, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, OBJ_SEARCH_KEY, sip_options_aor::qualify_2xx_only, sip_options_aor::qualify_frequency, sip_options_aor::qualify_timeout, sip_options_aors, and ast_cli_entry::usage.

cli_show_qualify_endpoint()

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

static

Definition at line 2889 of file pjsip_options.c.

{
    RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
    const char *endpoint_name;
    char *aors;
    char *aor_name;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "pjsip show qualify endpoint";
        e->usage =
            "Usage: pjsip show qualify endpoint <id>\n"
            "       Show the current qualify options for all Aors on the PJSIP endpoint.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 5) {
        return CLI_SHOWUSAGE;
    }
 
    endpoint_name = a->argv[4];
 
    endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
        endpoint_name);
    if (!endpoint) {
        ast_cli(a->fd, "Unable to retrieve endpoint %s\n", endpoint_name);
        return CLI_FAILURE;
    }
 
    if (ast_strlen_zero(endpoint->aors)) {
        ast_cli(a->fd, "No AORs configured for endpoint '%s'\n", endpoint_name);
        return CLI_FAILURE;
    }
 
    aors = ast_strdupa(endpoint->aors);
    while ((aor_name = ast_strip(strsep(&aors, ",")))) {
        struct sip_options_aor *aor_options;
 
        aor_options = ao2_find(sip_options_aors, aor_name, OBJ_SEARCH_KEY);
        if (!aor_options) {
            continue;
        }
 
        ast_cli(a->fd, " * AOR '%s' on endpoint '%s'\n", aor_name, endpoint_name);
        ast_cli(a->fd, "  Qualify frequency    : %d sec\n", aor_options->qualify_frequency);
        ast_cli(a->fd, "  Qualify timeout      : %d ms\n", (int)(aor_options->qualify_timeout / 1000));
        ast_cli(a->fd, "  Qualify 2xx only     : %s\n", aor_options->qualify_2xx_only ? "yes" : "no");
        ast_cli(a->fd, "  Authenticate qualify : %s\n", aor_options->authenticate_qualify?"yes":"no");
        ast_cli(a->fd, "\n");
        ao2_ref(aor_options, -1);
    }
 
    return CLI_SUCCESS;
}

References a, ao2_cleanup, ao2_find, ao2_ref, ast_cli(), ast_sip_get_sorcery(), ast_sorcery_retrieve_by_id(), ast_strdupa, ast_strip(), ast_strlen_zero(), sip_options_aor::authenticate_qualify, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, OBJ_SEARCH_KEY, sip_options_aor::qualify_2xx_only, sip_options_aor::qualify_frequency, sip_options_aor::qualify_timeout, RAII_VAR, sip_options_aors, strsep(), and ast_cli_entry::usage.

contact_observer_created()

static void contact_observer_created ( const void *  obj )

static

Observer callback invoked on contact creation.

Definition at line 2593 of file pjsip_options.c.

{
    ast_sip_push_task_wait_serializer(management_serializer,
        sip_options_contact_add_management_task, (void *) obj);
}

References ast_sip_push_task_wait_serializer, management_serializer, and sip_options_contact_add_management_task().

contact_observer_deleted()

static void contact_observer_deleted ( const void *  obj )

static

Observer callback invoked on contact deletion.

Definition at line 2739 of file pjsip_options.c.

{
    ast_sip_push_task_wait_serializer(management_serializer,
        sip_options_contact_delete_management_task, (void *) obj);
}

References ast_sip_push_task_wait_serializer, management_serializer, and sip_options_contact_delete_management_task().

contact_observer_updated()

static void contact_observer_updated ( const void *  obj )

static

Observer callback invoked on contact update.

Definition at line 2631 of file pjsip_options.c.

{
    const struct ast_sip_contact *contact = obj;
    struct sip_options_aor *aor_options = ao2_find(sip_options_aors, contact->aor, OBJ_SEARCH_KEY);
 
    if (has_qualify_changed(contact, aor_options)) {
        struct ast_sip_aor *aor;
 
        aor = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "aor",
            contact->aor);
        if (aor) {
            ast_debug(3, "AOR '%s' qualify options have been modified. Synchronize an AOR local state\n",
                contact->aor);
            ast_sip_push_task_wait_serializer(management_serializer,
                sip_options_aor_observer_modified_task, aor);
            ao2_ref(aor, -1);
        }
    }
 
    if (aor_options && ast_sip_get_send_contact_status_on_update_registration()) {
        struct sip_options_contact_observer_task_data *task_data;
 
        task_data = ast_malloc(sizeof(*task_data));
        if (!task_data) {
            ao2_ref(aor_options, -1);
            return;
        }
 
        task_data->contact = (struct ast_sip_contact *) contact;
        /* task_data takes ownership of aor_options and will take care of releasing the ref */
        task_data->aor_options = aor_options;
 
        ao2_ref(task_data->contact, +1);
        if (ast_sip_push_task(task_data->aor_options->serializer,
            sip_options_contact_update_task, task_data)) {
            ao2_ref(task_data->contact, -1);
            ao2_ref(task_data->aor_options, -1);
            ast_free(task_data);
        }
    } else {
        ao2_cleanup(aor_options);
    }
}

References ao2_cleanup, ao2_find, ao2_ref, ast_sip_contact::aor, sip_options_contact_observer_task_data::aor_options, ast_debug, ast_free, ast_malloc, ast_sip_get_send_contact_status_on_update_registration(), ast_sip_get_sorcery(), ast_sip_push_task, ast_sip_push_task_wait_serializer, ast_sorcery_retrieve_by_id(), has_qualify_changed(), management_serializer, OBJ_SEARCH_KEY, sip_options_aor_observer_modified_task(), sip_options_aors, and sip_options_contact_update_task().

contact_status_publish_update_task()

static int contact_status_publish_update_task ( void *  obj )

static

Task to notify endpoints of a contact status change.

Note

Run by management_serializer

Definition at line 435 of file pjsip_options.c.

{
    struct ast_sip_contact_status *contact_status = obj;
    struct sip_options_aor *aor_options;
 
    aor_options = ao2_find(sip_options_aors, contact_status->aor, OBJ_SEARCH_KEY);
    if (aor_options) {
        sip_options_publish_contact_state(aor_options, contact_status);
        ao2_ref(aor_options, -1);
    }
    ao2_ref(contact_status, -1);
 
    return 0;
}

References ao2_find, ao2_ref, ast_sip_contact_status::aor, OBJ_SEARCH_KEY, sip_options_aors, and sip_options_publish_contact_state().

Referenced by sip_options_contact_status_update().

endpoint_observer_deleted()

static void endpoint_observer_deleted ( const void *  obj )

static

Observer callback invoked on endpoint deletion.

Definition at line 2288 of file pjsip_options.c.

{
    ast_sip_push_task_wait_serializer(management_serializer,
        sip_options_endpoint_observer_deleted_task, (void *) obj);
}

References ast_sip_push_task_wait_serializer, management_serializer, and sip_options_endpoint_observer_deleted_task().

endpoint_observer_modified()

static void endpoint_observer_modified ( const void *  obj )

static

Observer callback invoked on endpoint creation or modification.

Definition at line 2320 of file pjsip_options.c.

{
    ast_sip_push_task_wait_serializer(management_serializer,
        sip_options_endpoint_observer_modified_task, (void *)obj);
}

References ast_sip_push_task_wait_serializer, management_serializer, and sip_options_endpoint_observer_modified_task().

format_ami_contact_status()

static int format_ami_contact_status ( const struct ast_sip_endpoint *  endpoint, struct ast_sip_ami *  ami  )

static

Definition at line 3190 of file pjsip_options.c.

{
    ami->arg = (void *)endpoint;
    return ast_sip_for_each_aor(endpoint->aors, format_contact_status_for_aor, ami);
}

References ast_sip_endpoint::aors, ast_sip_ami::arg, ast_sip_for_each_aor(), and format_contact_status_for_aor().

format_ami_contactlist_handler()

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

static

Definition at line 2822 of file pjsip_options.c.

{
    struct ast_sip_contact *contact = obj;
    struct ast_sip_ami *ami = arg;
    struct ast_str *buf;
    struct ast_sip_contact_status *status;
 
    buf = ast_sip_create_ami_event("ContactList", ami);
    if (!buf) {
        return CMP_STOP;
    }
 
    if (sip_contact_to_ami(contact, &buf)) {
        ast_free(buf);
        return CMP_STOP;
    }
 
    /* Add extra info */
    status = ast_sip_get_contact_status(contact);
    ast_str_append(&buf, 0, "Status: %s\r\n",
        ast_sip_get_contact_status_label(status ? status->status : UNKNOWN));
    if (!status || status->status != AVAILABLE) {
        ast_str_append(&buf, 0, "RoundtripUsec: N/A\r\n");
    } else {
        ast_str_append(&buf, 0, "RoundtripUsec: %" PRId64 "\r\n", status->rtt);
    }
    ao2_cleanup(status);
 
    astman_append(ami->s, "%s\r\n", ast_str_buffer(buf));
 
    ami->count++;
 
    ast_free(buf);
 
    return 0;
}

References ao2_cleanup, ast_sip_ami::arg, ast_free, ast_sip_create_ami_event(), ast_sip_get_contact_status(), ast_sip_get_contact_status_label(), ast_str_append(), ast_str_buffer(), astman_append(), AVAILABLE, buf, CMP_STOP, ast_sip_ami::count, ast_sip_ami::s, sip_contact_to_ami(), status, and UNKNOWN.

Referenced by ami_show_contacts().

format_contact_status_for_aor()

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

static

Definition at line 3183 of file pjsip_options.c.

{
    struct ast_sip_aor *aor = obj;
 
    return ast_sip_for_each_contact(aor, ast_sip_format_contact_ami, arg);
}

References ast_sip_for_each_contact(), and ast_sip_format_contact_ami().

Referenced by format_ami_contact_status().

get_all_contacts()

static struct ao2_container * get_all_contacts ( void  )

static

Definition at line 2806 of file pjsip_options.c.

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

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

Referenced by ami_show_contacts().

has_qualify_changed()

static int has_qualify_changed ( const struct ast_sip_contact *  contact, const struct sip_options_aor *  aor_options  )

static

Check if the contact qualify options are different than local aor qualify options.

Definition at line 2476 of file pjsip_options.c.

{
    if (!contact) {
        return 0;
    }
 
    if (!aor_options) {
        if (contact->qualify_frequency) {
            return 1;
        }
    } else if (contact->qualify_frequency != aor_options->qualify_frequency
        || contact->authenticate_qualify != aor_options->authenticate_qualify
        || contact->qualify_2xx_only != aor_options->qualify_2xx_only
        || ((int)(contact->qualify_timeout * 1000)) != ((int)(aor_options->qualify_timeout * 1000))) {
        return 1;
    }
 
    return 0;
}

References ast_sip_contact::authenticate_qualify, sip_options_aor::authenticate_qualify, ast_sip_contact::qualify_2xx_only, sip_options_aor::qualify_2xx_only, ast_sip_contact::qualify_frequency, sip_options_aor::qualify_frequency, ast_sip_contact::qualify_timeout, and sip_options_aor::qualify_timeout.

Referenced by contact_observer_updated(), and sip_options_contact_add_management_task().

options_on_rx_request()

static pj_bool_t options_on_rx_request ( pjsip_rx_data *  rdata )

static

Definition at line 266 of file pjsip_options.c.

{
    RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
    pjsip_uri *ruri;
    char exten[AST_MAX_EXTENSION];
 
    if (pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_options_method)) {
        return PJ_FALSE;
    }
 
    if (!(endpoint = ast_pjsip_rdata_get_endpoint(rdata))) {
        return PJ_FALSE;
    }
 
    ruri = rdata->msg_info.msg->line.req.uri;
    if (!ast_sip_is_allowed_uri(ruri)) {
        send_options_response(rdata, 416);
        return PJ_TRUE;
    }
 
    ast_copy_pj_str(exten, ast_sip_pjsip_uri_get_username(ruri), sizeof(exten));
 
    /*
     * We may want to match in the dialplan without any user
     * options getting in the way.
     */
    AST_SIP_USER_OPTIONS_TRUNCATE_CHECK(exten);
 
    if (ast_shutting_down()) {
        /*
         * Not taking any new calls at this time.
         * Likely a server availability OPTIONS poll.
         */
        send_options_response(rdata, 503);
    } else if (!ast_strlen_zero(exten)
        && !ast_exists_extension(NULL, endpoint->context, exten, 1, NULL)) {
        send_options_response(rdata, 404);
    } else {
        send_options_response(rdata, 200);
    }
    return PJ_TRUE;
}

References ao2_cleanup, ast_copy_pj_str(), ast_exists_extension(), AST_MAX_EXTENSION, ast_pjsip_rdata_get_endpoint(), ast_shutting_down(), ast_sip_is_allowed_uri(), ast_sip_pjsip_uri_get_username(), AST_SIP_USER_OPTIONS_TRUNCATE_CHECK, ast_strlen_zero(), NULL, RAII_VAR, and send_options_response().

qualify_contact_cb()

static void qualify_contact_cb ( void *  token, pjsip_event *  e  )

static

Callback for an OPTIONS response, timeout, or transport error.

Definition at line 1018 of file pjsip_options.c.

{
    struct sip_options_contact_callback_data *contact_callback_data = token;
    enum ast_sip_contact_status_type status;
 
    switch(e->body.tsx_state.type) {
    default:
        ast_log(LOG_ERROR, "Unexpected PJSIP event %u\n", e->body.tsx_state.type);
        /* Fall through */
    case PJSIP_EVENT_TRANSPORT_ERROR:
    case PJSIP_EVENT_TIMER:
        status = UNAVAILABLE;
        break;
    case PJSIP_EVENT_RX_MSG:
        if (contact_callback_data->aor_options->qualify_2xx_only &&
            (e->body.tsx_state.tsx->status_code < 200 || e->body.tsx_state.tsx->status_code >= 300)) {
            status = UNAVAILABLE;
        } else {
            status = AVAILABLE;
        }
        break;
    case PJSIP_EVENT_USER:
        /*
         * When one resolved target responds, we know the endpoint is available and we cancel the other
         * outstanding transactions.  The cancelled transactions will trigger this user event, which we
         * can ignore as we already have a result for the contact.
         */
        ast_debug(3, "Received user event for contact '%s', ignoring\n",
            ast_sorcery_object_get_id(contact_callback_data->contact));
        /* Decrement reference count for the contact callback data and return as we have no result */
        ao2_ref(contact_callback_data, -1);
        return;
    }
 
    sip_options_queue_target_result(contact_callback_data, status);
    ao2_ref(contact_callback_data, -1);
}

References ao2_ref, sip_options_contact_callback_data::aor_options, ast_debug, ast_log, ast_sorcery_object_get_id(), AVAILABLE, sip_options_contact_callback_data::contact, LOG_ERROR, sip_options_aor::qualify_2xx_only, sip_options_queue_target_result(), status, and UNAVAILABLE.

Referenced by sip_options_qualify_resolve_task().

send_options_response()

static pj_status_t send_options_response ( pjsip_rx_data *  rdata, int  code  )

static

Definition at line 214 of file pjsip_options.c.

{
    pjsip_endpoint *endpt = ast_sip_get_pjsip_endpoint();
    pjsip_dialog *dlg = pjsip_rdata_get_dlg(rdata);
    pjsip_transaction *trans = pjsip_rdata_get_tsx(rdata);
    pjsip_tx_data *tdata;
    const pjsip_hdr *hdr;
    pj_status_t status;
 
    /* Make the response object */
    status = ast_sip_create_response(rdata, code, NULL, &tdata);
    if (status != PJ_SUCCESS) {
        ast_log(LOG_ERROR, "Unable to create response (%d)\n", status);
        return status;
    }
 
    /* Add appropriate headers */
    if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_ACCEPT, NULL))) {
        pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
    }
    if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_ALLOW, NULL))) {
        pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
    }
    if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_SUPPORTED, NULL))) {
        pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
    }
 
    /*
     * XXX TODO: pjsip doesn't care a lot about either of these headers -
     * while it provides specific methods to create them, they are defined
     * to be the standard string header creation. Hard coded here.
     */
    ast_sip_add_header(tdata, "Accept-Encoding", DEFAULT_ENCODING);
    ast_sip_add_header(tdata, "Accept-Language", DEFAULT_LANGUAGE);
 
    if (dlg && trans) {
        status = pjsip_dlg_send_response(dlg, trans, tdata);
    } else {
        struct ast_sip_endpoint *endpoint;
 
        endpoint = ast_pjsip_rdata_get_endpoint(rdata);
        status = ast_sip_send_stateful_response(rdata, tdata, endpoint);
        ao2_cleanup(endpoint);
    }
 
    if (status != PJ_SUCCESS) {
        ast_log(LOG_ERROR, "Unable to send response (%d)\n", status);
    }
 
    return status;
}

References ao2_cleanup, ast_log, ast_pjsip_rdata_get_endpoint(), ast_sip_add_header(), ast_sip_create_response(), ast_sip_get_pjsip_endpoint(), ast_sip_send_stateful_response(), DEFAULT_ENCODING, DEFAULT_LANGUAGE, LOG_ERROR, NULL, and status.

Referenced by options_on_rx_request().

sip_contact_status_alloc()

static struct ast_sip_contact_status * sip_contact_status_alloc ( const char *  name )

static

Definition at line 354 of file pjsip_options.c.

{
    struct ast_sip_contact_status *contact_status;
    size_t size = sizeof(*contact_status) + strlen(name) + 1;
 
    contact_status = ao2_alloc_options(size, sip_contact_status_dtor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!contact_status) {
        return NULL;
    }
    if (ast_string_field_init(contact_status, 256)) {
        ao2_ref(contact_status, -1);
        return NULL;
    }
    AST_VECTOR_INIT(&contact_status->security_mechanisms, 0);
    strcpy(contact_status->name, name); /* SAFE */
    return contact_status;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_string_field_init, AST_VECTOR_INIT, ast_sip_contact_status::name, name, NULL, ast_sip_contact_status::security_mechanisms, and sip_contact_status_dtor().

Referenced by ast_res_pjsip_find_or_create_contact_status(), and sip_contact_status_copy().

sip_contact_status_copy()

static struct ast_sip_contact_status * sip_contact_status_copy ( const struct ast_sip_contact_status *  src )

static

Definition at line 373 of file pjsip_options.c.

{
    struct ast_sip_contact_status *dst;
 
    dst = sip_contact_status_alloc(src->name);
    if (!dst) {
        return NULL;
    }
 
    if (ast_string_fields_copy(dst, src)) {
        ao2_ref(dst, -1);
        return NULL;
    }
    dst->rtt = src->rtt;
    dst->status = src->status;
    dst->last_status = src->last_status;
 
    ast_sip_security_mechanisms_vector_copy(&dst->security_mechanisms, &src->security_mechanisms);
    return dst;
}

References ao2_ref, ast_sip_security_mechanisms_vector_copy(), ast_string_fields_copy, ast_sip_contact_status::last_status, ast_sip_contact_status::name, NULL, ast_sip_contact_status::rtt, ast_sip_contact_status::security_mechanisms, sip_contact_status_alloc(), and ast_sip_contact_status::status.

Referenced by sip_options_contact_status_notify_task(), sip_options_remove_contact_status(), and sip_options_set_contact_status().

sip_contact_status_dtor()

static void sip_contact_status_dtor ( void *  obj )

static

Destructor for contact statuses.

Definition at line 345 of file pjsip_options.c.

{
    struct ast_sip_contact_status *contact_status = obj;
 
    ast_sip_security_mechanisms_vector_destroy(&contact_status->security_mechanisms);
 
    ast_string_field_free_memory(contact_status);
}

References ast_sip_security_mechanisms_vector_destroy(), ast_string_field_free_memory, and ast_sip_contact_status::security_mechanisms.

Referenced by sip_contact_status_alloc().

sip_contact_to_ami()

static int sip_contact_to_ami ( const struct ast_sip_contact *  contact, struct ast_str **  buf  )

static

Definition at line 2816 of file pjsip_options.c.

{
    return ast_sip_sorcery_object_to_ami(contact, buf);
}

References ast_sip_sorcery_object_to_ami(), and buf.

Referenced by format_ami_contactlist_handler().

sip_options_aor_alloc()

static struct sip_options_aor * sip_options_aor_alloc ( struct ast_sip_aor *  aor )

static

Allocator for AOR OPTIONS.

Definition at line 1371 of file pjsip_options.c.

{
    struct sip_options_aor *aor_options;
 
    aor_options = ao2_alloc_options(sizeof(*aor_options) + strlen(ast_sorcery_object_get_id(aor)) + 1,
        sip_options_aor_dtor, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!aor_options) {
        return NULL;
    }
 
    strcpy(aor_options->name, ast_sorcery_object_get_id(aor)); /* SAFE */
 
    aor_options->serializer = ast_sip_get_distributor_serializer_hash(ast_str_hash(aor_options->name));
    if (!aor_options->serializer) {
        ao2_ref(aor_options, -1);
        return NULL;
    }
 
    if (AST_VECTOR_INIT(&aor_options->compositors, ENDPOINT_STATE_COMPOSITOR_INITIAL_SIZE)) {
        ao2_ref(aor_options, -1);
        return NULL;
    }
 
    aor_options->contacts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_NOLOCK,
        AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT, CONTACT_BUCKETS, ast_sorcery_object_id_hash,
        ast_sorcery_object_id_sort, ast_sorcery_object_id_compare);
    if (!aor_options->contacts) {
        ao2_ref(aor_options, -1);
        return NULL;
    }
 
    aor_options->dynamic_contacts = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_NOLOCK,
        AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT, CONTACT_BUCKETS, ast_sorcery_object_id_hash,
        ast_sorcery_object_id_sort, ast_sorcery_object_id_compare);
    if (!aor_options->dynamic_contacts) {
        ao2_ref(aor_options, -1);
        return NULL;
    }
 
    return aor_options;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_container_alloc_hash, AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT, ao2_ref, ast_sip_get_distributor_serializer_hash(), ast_sorcery_object_get_id(), ast_sorcery_object_id_compare(), ast_sorcery_object_id_hash(), ast_sorcery_object_id_sort(), ast_str_hash(), AST_VECTOR_INIT, sip_options_aor::compositors, CONTACT_BUCKETS, sip_options_aor::contacts, sip_options_aor::dynamic_contacts, ENDPOINT_STATE_COMPOSITOR_INITIAL_SIZE, sip_options_aor::name, NULL, sip_options_aor::serializer, and sip_options_aor_dtor().

Referenced by sip_options_aor_observer_modified_task(), and sip_options_synchronize_aor().

sip_options_aor_dtor()

static void sip_options_aor_dtor ( void *  obj )

static

Destructor function for SIP OPTIONS AORs.

Definition at line 1349 of file pjsip_options.c.

{
    struct sip_options_aor *aor_options = obj;
 
    /*
     * Any contacts are unreachable since the AOR is being destroyed
     * so remove their contact status
     */
    if (aor_options->contacts) {
        ao2_callback(aor_options->contacts, OBJ_NODATA | OBJ_UNLINK,
            sip_options_remove_contact, aor_options);
        ao2_ref(aor_options->contacts, -1);
    }
    ao2_cleanup(aor_options->dynamic_contacts);
 
    ast_taskprocessor_unreference(aor_options->serializer);
 
    ast_assert(AST_VECTOR_SIZE(&aor_options->compositors) == 0);
    AST_VECTOR_FREE(&aor_options->compositors);
}

References ao2_callback, ao2_cleanup, ao2_ref, ast_assert, ast_taskprocessor_unreference(), AST_VECTOR_FREE, AST_VECTOR_SIZE, sip_options_aor::compositors, sip_options_aor::contacts, sip_options_aor::dynamic_contacts, OBJ_NODATA, OBJ_UNLINK, sip_options_aor::serializer, and sip_options_remove_contact().

Referenced by sip_options_aor_alloc().

sip_options_aor_observer_deleted_task()

static int sip_options_aor_observer_deleted_task ( void *  obj )

static

Task to delete an AOR from the known universe.

Note

Run by management_serializer

Definition at line 2430 of file pjsip_options.c.

{
    struct ast_sip_aor *aor = obj;
    struct sip_options_aor *aor_options;
 
    aor_options = ao2_find(sip_options_aors, ast_sorcery_object_get_id(aor),
        OBJ_SEARCH_KEY | OBJ_UNLINK);
    if (!aor_options) {
        return 0;
    }
 
    ast_debug(3, "AOR '%s' has been deleted, removing it\n", aor_options->name);
 
    ast_sip_push_task_wait_serializer(aor_options->serializer, sip_options_aor_remove_task,
        aor_options);
    ao2_ref(aor_options, -1);
 
    return 0;
}

References ao2_find, ao2_ref, ast_debug, ast_sip_push_task_wait_serializer, ast_sorcery_object_get_id(), sip_options_aor::name, OBJ_SEARCH_KEY, OBJ_UNLINK, sip_options_aor::serializer, sip_options_aor_remove_task(), and sip_options_aors.

Referenced by aor_observer_deleted().

sip_options_aor_observer_modified_task()

static int sip_options_aor_observer_modified_task ( void *  obj )

static

Task to synchronize the AOR.

Note

Run by management_serializer

Definition at line 2365 of file pjsip_options.c.

{
    struct ast_sip_aor *aor = obj;
    struct sip_options_aor *aor_options;
 
    aor_options = ao2_find(sip_options_aors, ast_sorcery_object_get_id(aor),
        OBJ_SEARCH_KEY);
    if (!aor_options) {
        struct ao2_container *endpoints;
 
        aor_options = sip_options_aor_alloc(aor);
        if (!aor_options) {
            return 0;
        }
 
        /*
         * This is a newly added AOR and we need to establish any
         * endpoint state compositors that may reference only the
         * AOR.  If these need to be updated later then they'll
         * be done by modifying the endpoint or issuing a reload.
         */
        sip_options_apply_aor_configuration(aor_options, aor, 1);
        ao2_link(sip_options_aors, aor_options);
 
        /*
         * Using LIKE doesn't seem to work very well with non-realtime so we
         * fetch everything right now and do a filter on our side.
         */
        endpoints = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(),
            "endpoint", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
        if (endpoints) {
            ao2_callback(endpoints, OBJ_NODATA, sip_options_synchronize_endpoint, aor);
            ao2_ref(endpoints, -1);
        }
    } else {
        struct sip_options_synchronize_aor_task_data task_data = {
            .aor_options = aor_options,
            .aor = aor,
        };
 
        /*
         * If this AOR was modified we have to do our work in its serializer
         * instead of this thread to ensure that things aren't modified by
         * multiple threads.
         */
        ast_sip_push_task_wait_serializer(aor_options->serializer,
            sip_options_update_aor_task, &task_data);
    }
 
    ao2_ref(aor_options, -1);
 
    return 0;
}

References ao2_callback, ao2_find, ao2_link, ao2_ref, sip_options_synchronize_aor_task_data::aor, sip_options_synchronize_aor_task_data::aor_options, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sip_get_sorcery(), ast_sip_push_task_wait_serializer, ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_fields(), endpoints, NULL, OBJ_NODATA, OBJ_SEARCH_KEY, sip_options_aor::serializer, sip_options_aor_alloc(), sip_options_aors, sip_options_apply_aor_configuration(), sip_options_synchronize_endpoint(), and sip_options_update_aor_task().

Referenced by aor_observer_modified(), cli_reload_qualify_aor(), cli_reload_qualify_endpoint(), contact_observer_updated(), and sip_options_contact_add_management_task().

sip_options_aor_remove_task()

static int sip_options_aor_remove_task ( void *  obj )

static

Task which removes an AOR from all of the ESCs it is reporting to.

Note

Run by aor_options->serializer

Definition at line 2093 of file pjsip_options.c.

{
    struct sip_options_aor *aor_options = obj;
 
    sip_options_notify_endpoint_state_compositors(aor_options, REMOVED);
 
    if (aor_options->sched_task) {
        ast_sip_sched_task_cancel(aor_options->sched_task);
        ao2_ref(aor_options->sched_task, -1);
        aor_options->sched_task = NULL;
    }
 
    return 0;
}

References ao2_ref, ast_sip_sched_task_cancel(), NULL, REMOVED, sip_options_aor::sched_task, and sip_options_notify_endpoint_state_compositors().

Referenced by sip_options_aor_observer_deleted_task(), and sip_options_unused_aor().

sip_options_apply_aor_configuration()

static void sip_options_apply_aor_configuration ( struct sip_options_aor *  aor_options, struct ast_sip_aor *  aor, int  is_new  )

static

Function which applies configuration to an AOR options structure.

Note

Run by aor_options->serializer (or management_serializer on aor_options creation)

Definition at line 1644 of file pjsip_options.c.

{
    struct ao2_container *existing_contacts;
    struct ast_sip_contact *contact;
    struct ao2_iterator iter;
 
    ast_debug(3, "Configuring AOR '%s' with current state of configuration and world\n",
        aor_options->name);
 
    /*
     * Permanent contacts, since we receive no notification that they
     * are gone, follow the same approach as AORs.  We create a copy
     * of the existing container and any reused contacts are removed
     * from it.  Any contacts remaining in the container after
     * processing no longer exist so we need to remove their state.
     */
    existing_contacts = ao2_container_clone(aor_options->contacts, 0);
    if (!existing_contacts) {
        ast_log(LOG_WARNING, "Synchronization of AOR '%s' failed for qualify, retaining existing state\n",
            aor_options->name);
        return;
    }
 
    ao2_callback(aor_options->contacts, OBJ_NODATA | OBJ_UNLINK | OBJ_MULTIPLE,
        NULL, NULL);
 
    /* Process permanent contacts */
    if (aor->permanent_contacts) {
        iter = ao2_iterator_init(aor->permanent_contacts, 0);
        for (; (contact = ao2_iterator_next(&iter)); ao2_ref(contact, -1)) {
            ao2_find(existing_contacts, ast_sorcery_object_get_id(contact),
                OBJ_NODATA | OBJ_UNLINK | OBJ_SEARCH_KEY);
            ao2_link(aor_options->contacts, contact);
        }
        ao2_iterator_destroy(&iter);
    }
 
    /*
     * If this is newly added we need to see if there are any
     * existing dynamic contacts to add.  Ones that are added
     * after creation will occur as a result of the contact
     * observer creation callback.
     */
    if (is_new) {
        size_t prefix_len = strlen(ast_sorcery_object_get_id(aor)) + sizeof(";@") - 1;
        char prefix[prefix_len + 1];
        struct ao2_container *contacts;
 
        sprintf(prefix, "%s;@", ast_sorcery_object_get_id(aor)); /* Safe */
        contacts = ast_sorcery_retrieve_by_prefix(ast_sip_get_sorcery(), "contact",
            prefix, prefix_len);
        if (contacts) {
            ao2_container_dup(aor_options->dynamic_contacts, contacts, 0);
            ao2_ref(contacts, -1);
        }
    }
 
    /* Process dynamic contacts */
    iter = ao2_iterator_init(aor_options->dynamic_contacts, 0);
    for (; (contact = ao2_iterator_next(&iter)); ao2_ref(contact, -1)) {
        ao2_find(existing_contacts, ast_sorcery_object_get_id(contact),
            OBJ_NODATA | OBJ_UNLINK | OBJ_SEARCH_KEY);
        ao2_link(aor_options->contacts, contact);
    }
    ao2_iterator_destroy(&iter);
 
    /* Any contacts left no longer exist, so raise events and make them disappear */
    ao2_callback(existing_contacts, OBJ_NODATA | OBJ_UNLINK,
        sip_options_remove_contact, aor_options);
    ao2_ref(existing_contacts, -1);
 
    /*
     * Update the available count if we transition between qualified
     * and unqualified.  In the qualified case we need to start with
     * 0 available as the qualify process will take care of it.  In
     * the unqualified case it is based on the number of contacts
     * present.
     */
    if (!aor->qualify_frequency) {
        ao2_callback(aor_options->contacts, OBJ_NODATA,
            sip_options_set_contact_status_unqualified, NULL);
        aor_options->available = ao2_container_count(aor_options->contacts);
        ast_debug(3, "AOR '%s' is unqualified, number of available contacts is therefore '%d'\n",
            aor_options->name, aor_options->available);
    } else if (!aor_options->qualify_frequency) {
        ao2_callback(aor_options->contacts, OBJ_NODATA,
            sip_options_set_contact_status_qualified, NULL);
        aor_options->available = 0;
        ast_debug(3, "AOR '%s' has transitioned from unqualified to qualified, reset available contacts to 0\n",
            aor_options->name);
    } else {
        /*
        * Count the number of AVAILABLE qualified contacts to ensure
        * the count is in sync with reality.
        */
        aor_options->available = 0;
        ao2_callback(aor_options->contacts, OBJ_NODATA,
            sip_options_contact_status_available_count, &aor_options->available);
    }
 
    aor_options->authenticate_qualify = aor->authenticate_qualify;
    aor_options->qualify_2xx_only = aor->qualify_2xx_only;
    aor_options->qualify_timeout = aor->qualify_timeout;
 
    /*
     * If we need to stop or start the scheduled callback then do so.
     * This occurs due to the following:
     * 1. The qualify frequency has changed
     * 2. Contacts were added when previously there were none
     * 3. There are no contacts but previously there were some
     */
    if (aor_options->qualify_frequency != aor->qualify_frequency
        || (!aor_options->sched_task && ao2_container_count(aor_options->contacts))
        || (aor_options->sched_task && !ao2_container_count(aor_options->contacts))) {
        if (aor_options->sched_task) {
            ast_sip_sched_task_cancel(aor_options->sched_task);
            ao2_ref(aor_options->sched_task, -1);
            aor_options->sched_task = NULL;
        }
 
        /* If there is still a qualify frequency then schedule this */
        aor_options->qualify_frequency = aor->qualify_frequency;
        if (aor_options->qualify_frequency
            && ao2_container_count(aor_options->contacts)) {
            aor_options->sched_task = ast_sip_schedule_task(aor_options->serializer,
                sip_options_determine_initial_qualify_time(aor_options->qualify_frequency),
                sip_options_qualify_aor, ast_taskprocessor_name(aor_options->serializer),
                aor_options, AST_SIP_SCHED_TASK_VARIABLE | AST_SIP_SCHED_TASK_DATA_AO2);
            if (!aor_options->sched_task) {
                ast_log(LOG_ERROR, "Unable to schedule qualify for contacts of AOR '%s'\n",
                    aor_options->name);
            }
        }
    }
 
    ast_debug(3, "AOR '%s' now has %d available contacts\n", aor_options->name,
        aor_options->available);
}

References ao2_callback, ao2_container_clone, ao2_container_count(), ao2_container_dup(), ao2_find, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_link, ao2_ref, ast_debug, ast_log, ast_sip_get_sorcery(), ast_sip_sched_task_cancel(), AST_SIP_SCHED_TASK_DATA_AO2, AST_SIP_SCHED_TASK_VARIABLE, ast_sip_schedule_task(), ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_prefix(), ast_taskprocessor_name(), ast_sip_aor::authenticate_qualify, sip_options_aor::authenticate_qualify, sip_options_aor::available, sip_options_aor::contacts, sip_options_aor::dynamic_contacts, LOG_ERROR, LOG_WARNING, sip_options_aor::name, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_SEARCH_KEY, OBJ_UNLINK, ast_sip_aor::permanent_contacts, prefix, ast_sip_aor::qualify_2xx_only, sip_options_aor::qualify_2xx_only, ast_sip_aor::qualify_frequency, sip_options_aor::qualify_frequency, ast_sip_aor::qualify_timeout, sip_options_aor::qualify_timeout, sip_options_aor::sched_task, sip_options_aor::serializer, sip_options_contact_status_available_count(), sip_options_determine_initial_qualify_time(), sip_options_qualify_aor(), sip_options_remove_contact(), sip_options_set_contact_status_qualified(), and sip_options_set_contact_status_unqualified().

Referenced by sip_options_aor_observer_modified_task(), sip_options_synchronize_aor_task(), and sip_options_update_aor_task().

sip_options_apply_transport_to_destination()

static pj_status_t sip_options_apply_transport_to_destination ( const pjsip_tx_data *  tdata, pjsip_host_info *  destination  )

static

Apply a request's transport selector to its DNS destination.

pjsip_get_request_dest builds the destination from the Request-URI and may miss an outbound transport/listener. Before manual DNS resolution, apply the selected transport to the destination and check for mismatches so we use the correct transport for the request.

Definition at line 1113 of file pjsip_options.c.

{
    pjsip_transport_type_e transport_type = PJSIP_TRANSPORT_UNSPECIFIED;
 
    if ((tdata->tp_sel.type != PJSIP_TPSELECTOR_TRANSPORT
        && tdata->tp_sel.type != PJSIP_TPSELECTOR_LISTENER)
        || !tdata->tp_sel.u.ptr) {
        return PJ_SUCCESS;
    }
 
    if (tdata->tp_sel.type == PJSIP_TPSELECTOR_TRANSPORT) {
        transport_type = tdata->tp_sel.u.transport->key.type;
    } else {
        transport_type = tdata->tp_sel.u.listener->type;
    }
 
    if (destination->type != PJSIP_TRANSPORT_UNSPECIFIED
        && ((destination->type | PJSIP_TRANSPORT_IPV6)
            != (transport_type | PJSIP_TRANSPORT_IPV6))) {
        return PJSIP_ETPNOTSUITABLE;
    }
 
    destination->type = transport_type;
    return PJ_SUCCESS;
}

Referenced by sip_options_qualify_contact().

sip_options_cancel_target_transactions()

static void sip_options_cancel_target_transactions ( struct sip_options_contact_callback_data *  batch )

static

Terminate all in-flight target transactions for a batch.

Definition at line 689 of file pjsip_options.c.

{
    unsigned int idx;
 
    for (idx = 0; idx < AST_VECTOR_SIZE(&batch->target_transactions); ++idx) {
        pjsip_transaction *tsx = AST_VECTOR_GET(&batch->target_transactions, idx);
 
        if (tsx) {
            pjsip_tsx_terminate_async(tsx, PJSIP_SC_REQUEST_TERMINATED);
        }
    }
}

References AST_VECTOR_GET, AST_VECTOR_SIZE, and batch.

Referenced by sip_options_target_result_task().

sip_options_cleanup_aor_task()

static int sip_options_cleanup_aor_task ( void *  obj )

static

Management task to clean up an AOR.

Note

Run by aor_options->serializer

Definition at line 3205 of file pjsip_options.c.

{
    struct sip_options_aor *aor_options = obj;
 
    ast_debug(2, "Cleaning up AOR '%s' for shutdown\n", aor_options->name);
 
    aor_options->qualify_frequency = 0;
    if (aor_options->sched_task) {
        ast_sip_sched_task_cancel(aor_options->sched_task);
        ao2_ref(aor_options->sched_task, -1);
        aor_options->sched_task = NULL;
    }
    AST_VECTOR_RESET(&aor_options->compositors, ao2_cleanup);
 
    return 0;
}

References ao2_cleanup, ao2_ref, ast_debug, ast_sip_sched_task_cancel(), AST_VECTOR_RESET, sip_options_aor::compositors, sip_options_aor::name, NULL, sip_options_aor::qualify_frequency, and sip_options_aor::sched_task.

Referenced by sip_options_cleanup_task().

sip_options_cleanup_task()

static int sip_options_cleanup_task ( void *  obj )

static

Management task to clean up the environment.

Note

Run by management_serializer

Definition at line 3226 of file pjsip_options.c.

{
    struct ao2_iterator it_aor;
    struct sip_options_aor *aor_options;
 
    if (!sip_options_aors) {
        /* Nothing to do */
        return 0;
    }
 
    it_aor = ao2_iterator_init(sip_options_aors, AO2_ITERATOR_UNLINK);
    for (; (aor_options = ao2_iterator_next(&it_aor)); ao2_ref(aor_options, -1)) {
        ast_sip_push_task_wait_serializer(aor_options->serializer,
            sip_options_cleanup_aor_task, aor_options);
    }
    ao2_iterator_destroy(&it_aor);
 
    return 0;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, AO2_ITERATOR_UNLINK, ao2_ref, ast_sip_push_task_wait_serializer, sip_options_aor::serializer, sip_options_aors, and sip_options_cleanup_aor_task().

Referenced by ast_res_pjsip_cleanup_options_handling().

sip_options_contact_add_management_task()

static int sip_options_contact_add_management_task ( void *  obj )

static

Task to add a dynamic contact to an AOR in its serializer.

Note

Run by management_serializer

Definition at line 2560 of file pjsip_options.c.

{
    struct sip_options_contact_observer_task_data task_data;
 
    task_data.contact = obj;
    task_data.aor_options = ao2_find(sip_options_aors, task_data.contact->aor,
        OBJ_SEARCH_KEY);
 
    if (has_qualify_changed(task_data.contact, task_data.aor_options)) {
        struct ast_sip_aor *aor;
 
        aor = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "aor",
            task_data.contact->aor);
        if (aor) {
            ast_debug(3, "AOR '%s' qualify options have been modified. Synchronize an AOR local state\n",
                task_data.contact->aor);
            sip_options_aor_observer_modified_task(aor);
            ao2_ref(aor, -1);
        }
    }
 
    if (!task_data.aor_options) {
        return 0;
    }
 
    ast_sip_push_task_wait_serializer(task_data.aor_options->serializer,
        sip_options_contact_add_task, &task_data);
    ao2_ref(task_data.aor_options, -1);
 
    return 0;
}

References ao2_find, ao2_ref, ast_debug, ast_sip_get_sorcery(), ast_sip_push_task_wait_serializer, ast_sorcery_retrieve_by_id(), has_qualify_changed(), OBJ_SEARCH_KEY, sip_options_aor_observer_modified_task(), sip_options_aors, and sip_options_contact_add_task().

Referenced by contact_observer_created().

sip_options_contact_add_task()

static int sip_options_contact_add_task ( void *  obj )

static

Task which adds a dynamic contact to an AOR.

Note

Run by aor_options->serializer

Definition at line 2500 of file pjsip_options.c.

{
    struct sip_options_contact_observer_task_data *task_data = obj;
    struct ast_sip_contact_status *contact_status;
 
    ao2_link(task_data->aor_options->dynamic_contacts, task_data->contact);
    ao2_link(task_data->aor_options->contacts, task_data->contact);
 
    contact_status = ast_res_pjsip_find_or_create_contact_status(task_data->contact);
    ao2_cleanup(contact_status);
 
    if (task_data->aor_options->qualify_frequency) {
        /* There will always be a contact here, and we need to immediately schedule
         * a qualify so that contacts are not waiting for the qualify_frequency
         * timer duration before qualifying.
         */
        ast_debug(3, "Starting scheduled callback on AOR '%s' for qualifying as there is now a contact on it\n",
            task_data->aor_options->name);
        /*
         * We immediately schedule the initial qualify so that we get
         * reachable/unreachable as soon as possible.  Realistically
         * since they pretty much just registered they should be
         * reachable.
         */
        if (task_data->aor_options->sched_task) {
            ast_sip_sched_task_cancel(task_data->aor_options->sched_task);
            ao2_ref(task_data->aor_options->sched_task, -1);
            task_data->aor_options->sched_task = NULL;
        }
        task_data->aor_options->sched_task = ast_sip_schedule_task(
            task_data->aor_options->serializer, 1, sip_options_qualify_aor,
            ast_taskprocessor_name(task_data->aor_options->serializer),
            task_data->aor_options,
            AST_SIP_SCHED_TASK_VARIABLE | AST_SIP_SCHED_TASK_DATA_AO2);
        if (!task_data->aor_options->sched_task) {
            ast_log(LOG_ERROR, "Unable to schedule qualify for contacts of AOR '%s'\n",
                task_data->aor_options->name);
        }
    } else {
        /*
         * If this was the first contact added to a non-qualified AOR then
         * it should become available.
         */
        task_data->aor_options->available =
            ao2_container_count(task_data->aor_options->contacts);
        if (task_data->aor_options->available == 1) {
            ast_debug(3, "An unqualified contact has been added to AOR '%s' so it is now available\n",
                task_data->aor_options->name);
            sip_options_notify_endpoint_state_compositors(task_data->aor_options,
                AVAILABLE);
        }
    }
 
    return 0;
}

References ao2_cleanup, ao2_container_count(), ao2_link, ao2_ref, ast_debug, ast_log, ast_res_pjsip_find_or_create_contact_status(), ast_sip_sched_task_cancel(), AST_SIP_SCHED_TASK_DATA_AO2, AST_SIP_SCHED_TASK_VARIABLE, ast_sip_schedule_task(), ast_taskprocessor_name(), AVAILABLE, LOG_ERROR, NULL, sip_options_notify_endpoint_state_compositors(), and sip_options_qualify_aor().

Referenced by sip_options_contact_add_management_task().

sip_options_contact_callback_data_alloc()

static struct sip_options_contact_callback_data * sip_options_contact_callback_data_alloc ( struct ast_sip_contact *  contact, struct sip_options_aor *  aor_options, struct ast_sip_endpoint *  endpoint, pjsip_tx_data *  resolve_tdata  )

static

Contact callback data allocator.

Definition at line 1078 of file pjsip_options.c.

{
    struct sip_options_contact_callback_data *contact_callback_data;
 
    contact_callback_data = ao2_alloc_options(sizeof(*contact_callback_data),
        sip_options_contact_callback_data_dtor, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!contact_callback_data) {
        return NULL;
    }
 
    if (AST_VECTOR_INIT(&contact_callback_data->target_transactions, PJSIP_MAX_RESOLVED_ADDRESSES)) {
        ao2_ref(contact_callback_data, -1);
        return NULL;
    }
 
    contact_callback_data->contact = ao2_bump(contact);
    contact_callback_data->aor_options = ao2_bump(aor_options);
    contact_callback_data->endpoint = ao2_bump(endpoint);
    contact_callback_data->resolve_tdata = resolve_tdata;
    contact_callback_data->rtt_start = ast_tvnow();
 
    return contact_callback_data;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ao2_ref, sip_options_contact_callback_data::aor_options, ast_tvnow(), AST_VECTOR_INIT, sip_options_contact_callback_data::contact, sip_options_contact_callback_data::endpoint, NULL, sip_options_contact_callback_data::resolve_tdata, sip_options_contact_callback_data::rtt_start, sip_options_contact_callback_data_dtor(), and sip_options_contact_callback_data::target_transactions.

Referenced by sip_options_qualify_contact().

sip_options_contact_callback_data_dtor()

static void sip_options_contact_callback_data_dtor ( void *  obj )

static

Destructor for contact callback data.

Definition at line 1057 of file pjsip_options.c.

{
    struct sip_options_contact_callback_data *contact_callback_data = obj;
 
    ao2_cleanup(contact_callback_data->contact);
    ao2_cleanup(contact_callback_data->aor_options);
    ao2_cleanup(contact_callback_data->endpoint);
    /*
     * sip_options_qualify_resolve_cb should handle cleaning the resolve_tdata, but
     * keep this fallback just in case.
     */
    if (contact_callback_data->resolve_tdata) {
        pjsip_tx_data_dec_ref(contact_callback_data->resolve_tdata);
        contact_callback_data->resolve_tdata = NULL;
    }
    AST_VECTOR_RESET(&contact_callback_data->target_transactions,
        sip_options_transaction_free);
    AST_VECTOR_FREE(&contact_callback_data->target_transactions);
}

References ao2_cleanup, sip_options_contact_callback_data::aor_options, AST_VECTOR_FREE, AST_VECTOR_RESET, sip_options_contact_callback_data::contact, sip_options_contact_callback_data::endpoint, NULL, sip_options_contact_callback_data::resolve_tdata, sip_options_transaction_free(), and sip_options_contact_callback_data::target_transactions.

Referenced by sip_options_contact_callback_data_alloc().

sip_options_contact_delete_management_task()

static int sip_options_contact_delete_management_task ( void *  obj )

static

Task to delete a contact from an AOR in its serializer.

Note

Run by management_serializer

Definition at line 2719 of file pjsip_options.c.

{
    struct sip_options_contact_observer_task_data task_data;
 
    task_data.contact = obj;
    task_data.aor_options = ao2_find(sip_options_aors, task_data.contact->aor,
        OBJ_SEARCH_KEY);
    if (!task_data.aor_options) {
        /* For contacts that are deleted we don't really care if there is no AOR locally */
        return 0;
    }
 
    ast_sip_push_task_wait_serializer(task_data.aor_options->serializer,
        sip_options_contact_delete_task, &task_data);
    ao2_ref(task_data.aor_options, -1);
 
    return 0;
}

References ao2_find, ao2_ref, ast_sip_push_task_wait_serializer, OBJ_SEARCH_KEY, sip_options_aors, and sip_options_contact_delete_task().

Referenced by contact_observer_deleted().

sip_options_contact_delete_task()

static int sip_options_contact_delete_task ( void *  obj )

static

Task which deletes a dynamic contact from an AOR.

Note

Run by aor_options->serializer

Definition at line 2679 of file pjsip_options.c.

{
    struct sip_options_contact_observer_task_data *task_data = obj;
 
    ao2_find(task_data->aor_options->dynamic_contacts, task_data->contact,
        OBJ_NODATA | OBJ_UNLINK | OBJ_SEARCH_OBJECT);
    ao2_find(task_data->aor_options->contacts, task_data->contact,
        OBJ_NODATA | OBJ_UNLINK | OBJ_SEARCH_OBJECT);
 
    sip_options_remove_contact_status(task_data->aor_options, task_data->contact);
 
    if (task_data->aor_options->qualify_frequency) {
        /* If this is the last contact then we need to stop the scheduled callback */
        if (!ao2_container_count(task_data->aor_options->contacts)) {
            ast_debug(3, "Terminating scheduled callback on AOR '%s' as there are no contacts to qualify\n",
                task_data->aor_options->name);
            if (task_data->aor_options->sched_task) {
                ast_sip_sched_task_cancel(task_data->aor_options->sched_task);
                ao2_ref(task_data->aor_options->sched_task, -1);
                task_data->aor_options->sched_task = NULL;
            }
        }
    } else {
        task_data->aor_options->available =
            ao2_container_count(task_data->aor_options->contacts);
        if (!task_data->aor_options->available) {
            ast_debug(3, "An unqualified contact has been removed from AOR '%s' leaving no remaining contacts\n",
                task_data->aor_options->name);
            sip_options_notify_endpoint_state_compositors(task_data->aor_options,
                UNAVAILABLE);
        }
    }
 
    return 0;
}

References ao2_container_count(), ao2_find, ao2_ref, ast_debug, ast_sip_sched_task_cancel(), NULL, OBJ_NODATA, OBJ_SEARCH_OBJECT, OBJ_UNLINK, sip_options_notify_endpoint_state_compositors(), sip_options_remove_contact_status(), and UNAVAILABLE.

Referenced by sip_options_contact_delete_management_task().

sip_options_contact_status_available_count()

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

static

Count AVAILABLE qualified contacts.

Definition at line 1612 of file pjsip_options.c.

{
    struct ast_sip_contact *contact = obj;
    unsigned int *available = arg;
    struct ast_sip_contact_status *contact_status;
 
    contact_status = ast_res_pjsip_find_or_create_contact_status(contact);
    if (!contact_status) {
        return 0;
    }
 
    /* Count qualified available contacts. */
    switch (contact_status->status) {
    case AVAILABLE:
        ++*available;
        break;
    case UNAVAILABLE:
    case UNKNOWN:
    case CREATED:
    case REMOVED:
        break;
    }
 
    ao2_ref(contact_status, -1);
 
    return 0;
}

References ao2_ref, ast_res_pjsip_find_or_create_contact_status(), available(), AVAILABLE, CREATED, REMOVED, ast_sip_contact_status::status, UNAVAILABLE, and UNKNOWN.

Referenced by sip_options_apply_aor_configuration().

sip_options_contact_status_notify_task()

static int sip_options_contact_status_notify_task ( void *  obj )

static

Task to notify an AOR of a contact status change.

Note

Run by aor_options->serializer

Definition at line 811 of file pjsip_options.c.

{
    struct sip_options_contact_callback_data *contact_callback_data = obj;
    struct ast_sip_contact *contact;
    struct ast_sip_contact_status *cs_old;
    struct ast_sip_contact_status *cs_new;
 
    /*
     * Determine if this is a late arriving notification, as it is
     * possible that we get a callback from PJSIP giving us contact
     * status but in the mean time said contact has been removed
     * from the controlling AOR.
     */
 
    if (!contact_callback_data->aor_options->qualify_frequency) {
        /* Contact qualify response is late */
        ao2_ref(contact_callback_data, -1);
        return 0;
    }
 
    contact = ao2_find(contact_callback_data->aor_options->contacts,
        contact_callback_data->contact, OBJ_SEARCH_OBJECT);
    if (!contact) {
        /* Contact qualify response is late */
        ao2_ref(contact_callback_data, -1);
        return 0;
    }
    ao2_ref(contact, -1);
 
    cs_old = ao2_find(sip_options_contact_statuses,
        ast_sorcery_object_get_id(contact_callback_data->contact), OBJ_SEARCH_KEY);
    if (!cs_old) {
        /* Contact qualify response is late */
        ao2_ref(contact_callback_data, -1);
        return 0;
    }
 
    /* Update the contact specific status information */
    cs_new = sip_contact_status_copy(cs_old);
    ao2_ref(cs_old, -1);
    if (!cs_new) {
        ao2_ref(contact_callback_data, -1);
        return 0;
    }
    cs_new->last_status = cs_new->status;
    cs_new->status = contact_callback_data->status;
    cs_new->rtt =
        cs_new->status == AVAILABLE
            ? ast_tvdiff_us(ast_tvnow(), contact_callback_data->rtt_start)
            : 0;
    ao2_link(sip_options_contact_statuses, cs_new);
 
    /*
     * If the status has changed then notify the endpoint state compositors
     * and publish our events.
     */
    if (cs_new->last_status != cs_new->status) {
        if (cs_new->status == AVAILABLE) {
            /* If this is the first available contact then the AOR has become available */
            ++contact_callback_data->aor_options->available;
            if (contact_callback_data->aor_options->available == 1) {
                sip_options_notify_endpoint_state_compositors(
                    contact_callback_data->aor_options, AVAILABLE);
            }
        } else if (cs_new->last_status == AVAILABLE) {
            ast_assert(cs_new->status == UNAVAILABLE);
 
            /* If there are no more available contacts then this AOR is unavailable */
            --contact_callback_data->aor_options->available;
            if (!contact_callback_data->aor_options->available) {
                sip_options_notify_endpoint_state_compositors(
                    contact_callback_data->aor_options, UNAVAILABLE);
            }
        }
 
        ast_verb(3, "Contact %s/%s is now %s.  RTT: %.3f msec\n",
            cs_new->aor,
            cs_new->uri,
            ast_sip_get_contact_status_label(cs_new->status),
            cs_new->rtt / 1000.0);
 
        ast_statsd_log_string_va("PJSIP.contacts.states.%s", AST_STATSD_GAUGE,
            "-1", 1.0, ast_sip_get_contact_status_label(cs_new->last_status));
        ast_statsd_log_string_va("PJSIP.contacts.states.%s", AST_STATSD_GAUGE,
            "+1", 1.0, ast_sip_get_contact_status_label(cs_new->status));
 
        sip_options_contact_status_update(cs_new);
 
        ast_test_suite_event_notify("AOR_CONTACT_UPDATE",
            "Contact: %s\r\n"
            "Status: %s",
            cs_new->name,
            ast_sip_get_contact_status_label(cs_new->status));
    } else {
        ast_debug(3, "Contact %s/%s status didn't change: %s, RTT: %.3f msec\n",
            cs_new->aor,
            cs_new->uri,
            ast_sip_get_contact_status_label(cs_new->status),
            cs_new->rtt / 1000.0);
    }
 
    ast_statsd_log_full_va("PJSIP.contacts.%s.rtt", AST_STATSD_TIMER,
        cs_new->status != AVAILABLE ? -1 : cs_new->rtt / 1000,
        1.0,
        cs_new->name);
 
    ast_test_suite_event_notify("AOR_CONTACT_QUALIFY_RESULT",
        "Contact: %s\r\n"
        "Status: %s\r\n"
        "RTT: %" PRId64,
        cs_new->name,
        ast_sip_get_contact_status_label(cs_new->status),
        cs_new->rtt);
 
    ast_debug(3, "AOR '%s' now has %d available contacts\n",
        contact_callback_data->aor_options->name,
        contact_callback_data->aor_options->available);
 
    ao2_ref(cs_new, -1);
    ao2_ref(contact_callback_data, -1);
 
    return 0;
}

References ao2_find, ao2_link, ao2_ref, ast_sip_contact_status::aor, sip_options_contact_callback_data::aor_options, ast_assert, ast_debug, ast_sip_get_contact_status_label(), ast_sorcery_object_get_id(), AST_STATSD_GAUGE, ast_statsd_log_full_va(), ast_statsd_log_string_va(), AST_STATSD_TIMER, ast_test_suite_event_notify, ast_tvdiff_us(), ast_tvnow(), ast_verb, AVAILABLE, sip_options_aor::available, sip_options_contact_callback_data::contact, sip_options_aor::contacts, ast_sip_contact_status::last_status, ast_sip_contact_status::name, sip_options_aor::name, OBJ_SEARCH_KEY, OBJ_SEARCH_OBJECT, sip_options_aor::qualify_frequency, ast_sip_contact_status::rtt, sip_options_contact_callback_data::rtt_start, sip_contact_status_copy(), sip_options_contact_status_update(), sip_options_contact_statuses, sip_options_notify_endpoint_state_compositors(), ast_sip_contact_status::status, sip_options_contact_callback_data::status, UNAVAILABLE, and ast_sip_contact_status::uri.

Referenced by sip_options_target_result_task().

sip_options_contact_status_update()

static void sip_options_contact_status_update ( struct ast_sip_contact_status *  contact_status )

static

Definition at line 450 of file pjsip_options.c.

{
    struct ast_taskprocessor *mgmt_serializer = management_serializer;
 
    if (mgmt_serializer) {
        ao2_ref(contact_status, +1);
        if (ast_sip_push_task(mgmt_serializer, contact_status_publish_update_task,
            contact_status)) {
            ao2_ref(contact_status, -1);
        }
    }
}

References ao2_ref, ast_sip_push_task, contact_status_publish_update_task(), and management_serializer.

Referenced by ast_res_pjsip_find_or_create_contact_status(), sip_options_contact_status_notify_task(), sip_options_contact_update_task(), sip_options_remove_contact_status(), and sip_options_set_contact_status().

sip_options_contact_statuses_alloc()

static struct ao2_container * sip_options_contact_statuses_alloc ( void  )

static

Helper function to allocate a contact statuses container.

Definition at line 404 of file pjsip_options.c.

{
    /*
     * Replace duplicate objects so we can update the immutable
     * contact status objects by simply linking in a new object.
     */
    return ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX,
        AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, CONTACT_STATUS_BUCKETS,
        ast_sip_contact_status_hash_fn, ast_sip_contact_status_sort_fn,
        ast_sip_contact_status_cmp_fn);
}

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, and CONTACT_STATUS_BUCKETS.

Referenced by ast_res_pjsip_preinit_options_handling().

sip_options_contact_update_task()

static int sip_options_contact_update_task ( void *  obj )

static

Task which updates a dynamic contact to an AOR.

Note

Run by aor_options->serializer

Definition at line 2603 of file pjsip_options.c.

{
    struct sip_options_contact_observer_task_data *task_data = obj;
    struct ast_sip_contact_status *contact_status;
 
    contact_status = ast_sip_get_contact_status(task_data->contact);
    if (contact_status) {
        switch (contact_status->status) {
        case CREATED:
        case UNAVAILABLE:
        case AVAILABLE:
        case UNKNOWN:
            /* Refresh the ContactStatus AMI events. */
            sip_options_contact_status_update(contact_status);
            break;
        case REMOVED:
            break;
        }
        ao2_ref(contact_status, -1);
    }
 
    ao2_ref(task_data->contact, -1);
    ao2_ref(task_data->aor_options, -1);
    ast_free(task_data);
    return 0;
}

References ao2_ref, ast_free, ast_sip_get_contact_status(), AVAILABLE, CREATED, REMOVED, sip_options_contact_status_update(), ast_sip_contact_status::status, UNAVAILABLE, and UNKNOWN.

Referenced by contact_observer_updated().

sip_options_determine_initial_qualify_time()

static int sip_options_determine_initial_qualify_time ( int  qualify_frequency )

static

Determine an initial time for scheduling AOR qualifying.

Definition at line 1498 of file pjsip_options.c.

{
    int initial_interval;
    int max_time = ast_sip_get_max_initial_qualify_time();
 
    if (max_time && max_time < qualify_frequency) {
        initial_interval = max_time;
    } else {
        initial_interval = qualify_frequency;
    }
 
    initial_interval = (int)((initial_interval * 1000) * ast_random_double());
    return 0 < initial_interval ? initial_interval : 1;
}

References ast_random_double, ast_sip_get_max_initial_qualify_time(), and sip_options_aor::qualify_frequency.

Referenced by sip_options_apply_aor_configuration().

sip_options_endpoint_compositor_add_task()

static int sip_options_endpoint_compositor_add_task ( void *  obj )

static

Task which adds an AOR to an endpoint state compositor.

Note

Run by aor_options->serializer

Definition at line 1932 of file pjsip_options.c.

{
    struct sip_options_endpoint_compositor_task_data *task_data = obj;
 
    ast_debug(3, "Adding endpoint compositor '%s' to AOR '%s'\n",
        task_data->endpoint_state_compositor->name, task_data->aor_options->name);
 
    ao2_ref(task_data->endpoint_state_compositor, +1);
    if (AST_VECTOR_APPEND(&task_data->aor_options->compositors,
        task_data->endpoint_state_compositor)) {
        /* Failed to add so no need to update the endpoint status.  Nothing changed. */
        ao2_ref(task_data->endpoint_state_compositor, -1);
        return 0;
    }
 
    ao2_lock(task_data->endpoint_state_compositor);
    sip_options_update_endpoint_state_compositor_aor(task_data->endpoint_state_compositor,
        task_data->aor_options->name,
        task_data->aor_options->available ? AVAILABLE : UNAVAILABLE);
    ao2_unlock(task_data->endpoint_state_compositor);
 
    return 0;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_debug, AST_VECTOR_APPEND, AVAILABLE, sip_options_update_endpoint_state_compositor_aor(), and UNAVAILABLE.

Referenced by sip_options_synchronize_endpoint().

sip_options_endpoint_compositor_remove_task()

static int sip_options_endpoint_compositor_remove_task ( void *  obj )

static

Task which adds removes an AOR from an endpoint state compositor.

Note

Run by aor_options->serializer

Definition at line 1960 of file pjsip_options.c.

{
    struct sip_options_endpoint_compositor_task_data *task_data = obj;
    int i;
 
    ast_debug(3, "Removing endpoint compositor '%s' from AOR '%s'\n",
        task_data->endpoint_state_compositor->name,
        task_data->aor_options->name);
 
    for (i = 0; i < AST_VECTOR_SIZE(&task_data->aor_options->compositors); ++i) {
        struct sip_options_endpoint_state_compositor *endpoint_state_compositor;
 
        endpoint_state_compositor = AST_VECTOR_GET(&task_data->aor_options->compositors, i);
        if (endpoint_state_compositor != task_data->endpoint_state_compositor) {
            continue;
        }
 
        AST_VECTOR_REMOVE(&task_data->aor_options->compositors, i, 0);
        ao2_ref(endpoint_state_compositor, -1);
        break;
    }
 
    return 0;
}

References ao2_ref, ast_debug, AST_VECTOR_GET, AST_VECTOR_REMOVE, and AST_VECTOR_SIZE.

Referenced by sip_options_endpoint_unlink_aor_feeders().

sip_options_endpoint_observer_deleted_task()

static int sip_options_endpoint_observer_deleted_task ( void *  obj )

static

Task to delete an endpoint from the known universe.

Note

Run by management_serializer

Definition at line 2268 of file pjsip_options.c.

{
    struct ast_sip_endpoint *endpoint = obj;
    struct sip_options_endpoint_state_compositor *endpoint_state_compositor;
 
    endpoint_state_compositor = ao2_find(sip_options_endpoint_state_compositors,
        ast_sorcery_object_get_id(endpoint), OBJ_SEARCH_KEY | OBJ_UNLINK);
    if (!endpoint_state_compositor) {
        return 0;
    }
 
    ast_debug(3, "Endpoint '%s' has been deleted, removing endpoint state compositor from AORs\n",
        ast_sorcery_object_get_id(endpoint));
    sip_options_endpoint_unlink_aor_feeders(endpoint, endpoint_state_compositor);
    ao2_ref(endpoint_state_compositor, -1);
 
    return 0;
}

References ao2_find, ao2_ref, ast_debug, ast_sorcery_object_get_id(), OBJ_SEARCH_KEY, OBJ_UNLINK, sip_options_endpoint_state_compositors, and sip_options_endpoint_unlink_aor_feeders().

Referenced by endpoint_observer_deleted().

sip_options_endpoint_observer_modified_task()

static int sip_options_endpoint_observer_modified_task ( void *  obj )

static

Task to synchronize the endpoint.

Note

Run by management_serializer

Definition at line 2298 of file pjsip_options.c.

{
    struct ast_sip_endpoint *endpoint = obj;
    struct sip_options_endpoint_state_compositor *endpoint_state_compositor;
 
    ast_debug(3, "Endpoint '%s' has been created or modified, updating state\n",
        ast_sorcery_object_get_id(endpoint));
 
    endpoint_state_compositor = ao2_find(sip_options_endpoint_state_compositors,
        ast_sorcery_object_get_id(endpoint), OBJ_SEARCH_KEY | OBJ_UNLINK);
    if (endpoint_state_compositor) {
        /* Unlink the AORs currently feeding the endpoint. */
        sip_options_endpoint_unlink_aor_feeders(endpoint, endpoint_state_compositor);
        ao2_ref(endpoint_state_compositor, -1);
    }
 
    /* Connect the AORs that now feed the endpoint. */
    sip_options_synchronize_endpoint(endpoint, NULL, 0);
    return 0;
}

References ao2_find, ao2_ref, ast_debug, ast_sorcery_object_get_id(), NULL, OBJ_SEARCH_KEY, OBJ_UNLINK, sip_options_endpoint_state_compositors, sip_options_endpoint_unlink_aor_feeders(), and sip_options_synchronize_endpoint().

Referenced by endpoint_observer_modified().

sip_options_endpoint_state_compositor_dtor()

static void sip_options_endpoint_state_compositor_dtor ( void *  obj )

static

Destructor for endpoint state compositors.

Definition at line 1863 of file pjsip_options.c.

{
    struct sip_options_endpoint_state_compositor *endpoint_state_compositor = obj;
 
    ao2_cleanup(endpoint_state_compositor->aor_statuses);
}

References ao2_cleanup, and sip_options_endpoint_state_compositor::aor_statuses.

Referenced by sip_options_endpoint_state_compositor_find_or_alloc().

sip_options_endpoint_state_compositor_find_or_alloc()

static struct sip_options_endpoint_state_compositor * sip_options_endpoint_state_compositor_find_or_alloc ( const struct ast_sip_endpoint *  endpoint )

static

Find (or create) an endpoint state compositor.

Definition at line 1877 of file pjsip_options.c.

{
    struct sip_options_endpoint_state_compositor *endpoint_state_compositor;
 
    ao2_lock(sip_options_endpoint_state_compositors);
    endpoint_state_compositor = ao2_find(sip_options_endpoint_state_compositors,
        ast_sorcery_object_get_id(endpoint), OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (endpoint_state_compositor) {
        ao2_unlock(sip_options_endpoint_state_compositors);
        return endpoint_state_compositor;
    }
 
    endpoint_state_compositor = ao2_alloc(sizeof(*endpoint_state_compositor)
        + strlen(ast_sorcery_object_get_id(endpoint)) + 1,
        sip_options_endpoint_state_compositor_dtor);
    if (!endpoint_state_compositor) {
        ao2_unlock(sip_options_endpoint_state_compositors);
        return NULL;
    }
 
    /*
     * NOTE: The endpoint_state_compositor->aor_statuses container is
     * externally protected by the endpoint_state_compositor lock.
     */
    endpoint_state_compositor->aor_statuses = ao2_container_alloc_hash(
        AO2_ALLOC_OPT_LOCK_NOLOCK, 0, AOR_STATUS_BUCKETS,
        sip_options_endpoint_aor_status_hash_fn, NULL,
        sip_options_endpoint_aor_status_cmp_fn);
    if (!endpoint_state_compositor->aor_statuses) {
        ao2_unlock(sip_options_endpoint_state_compositors);
        ao2_ref(endpoint_state_compositor, -1);
        return NULL;
    }
 
    strcpy(endpoint_state_compositor->name, ast_sorcery_object_get_id(endpoint)); /* SAFE */
 
    ao2_link_flags(sip_options_endpoint_state_compositors, endpoint_state_compositor,
        OBJ_NOLOCK);
    ao2_unlock(sip_options_endpoint_state_compositors);
 
    return endpoint_state_compositor;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_container_alloc_hash, ao2_find, ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, AOR_STATUS_BUCKETS, sip_options_endpoint_state_compositor::aor_statuses, ast_sorcery_object_get_id(), sip_options_endpoint_state_compositor::name, NULL, OBJ_NOLOCK, OBJ_SEARCH_KEY, sip_options_endpoint_state_compositor_dtor(), and sip_options_endpoint_state_compositors.

Referenced by sip_options_synchronize_endpoint().

sip_options_endpoint_unlink_aor_feeders()

static void sip_options_endpoint_unlink_aor_feeders ( struct ast_sip_endpoint *  endpoint, struct sip_options_endpoint_state_compositor *  endpoint_state_compositor  )

static

Unlink AORs feeding the endpoint status compositor.

Note

Run by management_serializer

Definition at line 2224 of file pjsip_options.c.

{
    struct ao2_iterator it_aor_statuses;
    struct sip_options_endpoint_aor_status *aor_status;
    struct sip_options_endpoint_compositor_task_data task_data = {
        .endpoint_state_compositor = endpoint_state_compositor,
    };
 
    ao2_lock(endpoint_state_compositor);
    endpoint_state_compositor->active = 0;
 
    /* Unlink AOR feeders pointing to endpoint */
    it_aor_statuses = ao2_iterator_init(endpoint_state_compositor->aor_statuses, 0);
    for (; (aor_status = ao2_iterator_next(&it_aor_statuses)); ao2_ref(aor_status, -1)) {
        task_data.aor_options = ao2_find(sip_options_aors, aor_status->name,
            OBJ_SEARCH_KEY);
        if (!task_data.aor_options) {
            continue;
        }
 
        ast_debug(3, "Removing endpoint state compositor '%s' from AOR '%s'\n",
            ast_sorcery_object_get_id(endpoint), aor_status->name);
        ao2_unlock(endpoint_state_compositor);
        ast_sip_push_task_wait_serializer(task_data.aor_options->serializer,
            sip_options_endpoint_compositor_remove_task, &task_data);
        ao2_lock(endpoint_state_compositor);
        ao2_ref(task_data.aor_options, -1);
    }
    ao2_iterator_destroy(&it_aor_statuses);
 
    /*
     * We do not need to remove the AOR feeder status memory from the
     * aor_statuses container.  The endpoint_state_compositor is about
     * to die and do it for us.
     */
 
    ao2_unlock(endpoint_state_compositor);
}

References sip_options_endpoint_state_compositor::active, ao2_find, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, sip_options_endpoint_state_compositor::aor_statuses, ast_debug, ast_sip_push_task_wait_serializer, ast_sorcery_object_get_id(), sip_options_endpoint_compositor_task_data::endpoint_state_compositor, sip_options_endpoint_aor_status::name, OBJ_SEARCH_KEY, sip_options_aors, and sip_options_endpoint_compositor_remove_task().

Referenced by sip_options_endpoint_observer_deleted_task(), and sip_options_endpoint_observer_modified_task().

sip_options_get_endpoint_state_compositor_state()

static enum ast_endpoint_state sip_options_get_endpoint_state_compositor_state ( const struct sip_options_endpoint_state_compositor *  endpoint_state_compositor )

static

Return the current state of an endpoint state compositor.

Precondition

The endpoint_state_compositor lock must be held.

Definition at line 707 of file pjsip_options.c.

{
    struct ao2_iterator it_aor_statuses;
    struct sip_options_endpoint_aor_status *aor_status;
    enum ast_endpoint_state state = AST_ENDPOINT_OFFLINE;
 
    it_aor_statuses = ao2_iterator_init(endpoint_state_compositor->aor_statuses, 0);
    for (; (aor_status = ao2_iterator_next(&it_aor_statuses)); ao2_ref(aor_status, -1)) {
        if (aor_status->available) {
            state = AST_ENDPOINT_ONLINE;
            ao2_ref(aor_status, -1);
            break;
        }
    }
    ao2_iterator_destroy(&it_aor_statuses);
 
    return state;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, sip_options_endpoint_state_compositor::aor_statuses, AST_ENDPOINT_OFFLINE, AST_ENDPOINT_ONLINE, and sip_options_endpoint_aor_status::available.

Referenced by sip_options_synchronize_endpoint(), and sip_options_update_endpoint_state_compositor_aor().

sip_options_init_task()

static int sip_options_init_task ( void *  mgmt_serializer )

static

Management task to finish setting up the environment.

Note

Run by management_serializer

Definition at line 3283 of file pjsip_options.c.

{
    management_serializer = mgmt_serializer;
 
    if (ast_sorcery_observer_add(ast_sip_get_sorcery(), "endpoint",
        &endpoint_observer_callbacks)) {
        return -1;
    }
    if (ast_sorcery_observer_add(ast_sip_get_sorcery(), "aor",
        &aor_observer_callbacks)) {
        return -1;
    }
    if (ast_sorcery_observer_add(ast_sip_get_sorcery(), "contact",
        &contact_observer_callbacks)) {
        return -1;
    }
 
    sip_options_synchronize(0);
 
    return 0;
}

References aor_observer_callbacks, ast_sip_get_sorcery(), ast_sorcery_observer_add(), contact_observer_callbacks, endpoint_observer_callbacks, management_serializer, and sip_options_synchronize().

Referenced by ast_res_pjsip_init_options_handling().

sip_options_notify_endpoint_state_compositors()

static void sip_options_notify_endpoint_state_compositors ( struct sip_options_aor *  aor_options, enum ast_sip_contact_status_type  status  )

static

Function which notifies endpoint state compositors of a state change of an AOR.

Definition at line 785 of file pjsip_options.c.

{
    int i;
 
    /* Iterate through the associated endpoint state compositors updating them */
    for (i = 0; i < AST_VECTOR_SIZE(&aor_options->compositors); ++i) {
        struct sip_options_endpoint_state_compositor *endpoint_state_compositor;
 
        endpoint_state_compositor = AST_VECTOR_GET(&aor_options->compositors, i);
 
        ao2_lock(endpoint_state_compositor);
        sip_options_update_endpoint_state_compositor_aor(endpoint_state_compositor,
            aor_options->name, status);
        ao2_unlock(endpoint_state_compositor);
    }
 
    if (status == REMOVED) {
        AST_VECTOR_RESET(&aor_options->compositors, ao2_cleanup);
    }
}

References ao2_cleanup, ao2_lock, ao2_unlock, AST_VECTOR_GET, AST_VECTOR_RESET, AST_VECTOR_SIZE, sip_options_aor::compositors, sip_options_aor::name, REMOVED, sip_options_update_endpoint_state_compositor_aor(), and status.

Referenced by sip_options_aor_remove_task(), sip_options_contact_add_task(), sip_options_contact_delete_task(), sip_options_contact_status_notify_task(), sip_options_remove_contact_status(), and sip_options_update_aor_task().

sip_options_publish_contact_state()

static void sip_options_publish_contact_state ( const struct sip_options_aor *  aor_options, const struct ast_sip_contact_status *  contact_status  )

static

Function which publishes a contact status update to all interested endpoints.

Definition at line 417 of file pjsip_options.c.

{
    int i;
 
    for (i = 0; i < AST_VECTOR_SIZE(&aor_options->compositors); ++i) {
        const struct sip_options_endpoint_state_compositor *endpoint_state_compositor;
 
        endpoint_state_compositor = AST_VECTOR_GET(&aor_options->compositors, i);
        ast_sip_persistent_endpoint_publish_contact_state(endpoint_state_compositor->name,
            contact_status);
    }
}

References ast_sip_persistent_endpoint_publish_contact_state(), AST_VECTOR_GET, AST_VECTOR_SIZE, sip_options_aor::compositors, and sip_options_endpoint_state_compositor::name.

Referenced by contact_status_publish_update_task().

sip_options_qualify_aor()

static int sip_options_qualify_aor ( void *  obj )

static

Task to qualify contacts of an AOR.

Note

Run by aor_options->serializer

Definition at line 1331 of file pjsip_options.c.

{
    struct sip_options_aor *aor_options = obj;
 
    ast_debug(3, "Qualifying all contacts on AOR '%s'\n", aor_options->name);
 
    /* Attempt to send an OPTIONS request to every contact on this AOR */
    ao2_callback(aor_options->contacts, OBJ_NODATA, sip_options_qualify_contact,
        (struct sip_options_aor *) aor_options);
 
    /* Always reschedule to the frequency we should go */
    return aor_options->qualify_frequency * 1000;
}

References ao2_callback, ast_debug, sip_options_aor::contacts, sip_options_aor::name, OBJ_NODATA, sip_options_aor::qualify_frequency, and sip_options_qualify_contact().

Referenced by ami_sip_qualify(), cli_qualify(), sip_options_apply_aor_configuration(), and sip_options_contact_add_task().

sip_options_qualify_contact()

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

static

Send a SIP OPTIONS request for a contact.

Definition at line 1236 of file pjsip_options.c.

{
    struct ast_sip_contact *contact = obj;
    struct sip_options_aor *aor_options = arg;
    RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
    pjsip_tx_data *tdata;
    pjsip_host_info destination;
    struct ast_sip_contact_status *contact_status;
    struct sip_options_contact_callback_data *contact_callback_data;
 
    ast_debug(3, "Qualifying contact '%s' on AOR '%s'\n",
        ast_sorcery_object_get_id(contact), aor_options->name);
 
    if (!ast_strlen_zero(contact->endpoint_name)) {
        endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
            contact->endpoint_name);
    }
    if (!endpoint && AST_VECTOR_SIZE(&aor_options->compositors)) {
        struct sip_options_endpoint_state_compositor *endpoint_state_compositor;
 
        endpoint_state_compositor = AST_VECTOR_GET(&aor_options->compositors, 0);
        endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint",
            endpoint_state_compositor->name);
    }
    if (!endpoint) {
        ast_debug(3, "Could not find an endpoint to qualify contact '%s' on AOR '%s'\n",
            ast_sorcery_object_get_id(contact), aor_options->name);
        return 0;
    }
 
    /*
     * Create a request solely for DNS resolution. Its pool keeps the resolver strings alive,
     * and passing a URI with no contact avoids leaving a contact reference behind in case
     * resolution fails before it can send.
     */
    if (ast_sip_create_request("OPTIONS", NULL, endpoint, contact->uri, NULL,
        &tdata)) {
        ast_log(LOG_ERROR, "Unable to create request to qualify contact %s on AOR %s\n",
            contact->uri, aor_options->name);
        return 0;
    }
 
    /* If an outbound proxy is specified set it on this request */
    if (!ast_strlen_zero(contact->outbound_proxy) &&
        ast_sip_set_outbound_proxy(tdata, contact->outbound_proxy)) {
        ast_log(LOG_ERROR, "Unable to apply outbound proxy on request to qualify contact %s\n",
            contact->uri);
        pjsip_tx_data_dec_ref(tdata);
        return 0;
    }
 
    contact_status = ast_res_pjsip_find_or_create_contact_status(contact);
    if (!contact_status) {
        ast_log(LOG_ERROR, "Unable to retrieve contact status information for contact %s on AOR %s\n",
            contact->uri, aor_options->name);
        pjsip_tx_data_dec_ref(tdata);
        return 0;
    }
    ao2_ref(contact_status, -1);
 
    contact_callback_data = sip_options_contact_callback_data_alloc(contact,
        aor_options, endpoint, tdata);
    if (!contact_callback_data) {
        ast_log(LOG_ERROR, "Unable to create object to contain callback data for contact %s on AOR %s\n",
            contact->uri, aor_options->name);
        pjsip_tx_data_dec_ref(tdata);
        return 0;
    }
 
 
    /*
     * Resolve the contact destination explicitly via DNS, then create and send
     * an independent OPTIONS for each returned transport/address/port tuple.
     * Keep the resolver-only tdata alive because its pool owns strings used
     * by the asynchronous resolver.
     */
    if (pjsip_get_request_dest(tdata, &destination) != PJ_SUCCESS
        || sip_options_apply_transport_to_destination(tdata, &destination)
            != PJ_SUCCESS) {
        ast_log(LOG_ERROR, "Unable to resolve destination to qualify contact %s on AOR %s\n",
            contact->uri, aor_options->name);
        ao2_ref(contact_callback_data, -1);
        return 0;
    }
 
    pjsip_endpt_resolve(ast_sip_get_pjsip_endpoint(), tdata->pool, &destination,
        contact_callback_data, sip_options_qualify_resolve_cb);
 
    return 0;
}

References ao2_cleanup, ao2_ref, sip_options_contact_callback_data::aor_options, ast_debug, ast_log, ast_res_pjsip_find_or_create_contact_status(), ast_sip_create_request(), ast_sip_get_pjsip_endpoint(), ast_sip_get_sorcery(), ast_sip_set_outbound_proxy(), ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_id(), ast_strlen_zero(), AST_VECTOR_GET, AST_VECTOR_SIZE, sip_options_aor::compositors, sip_options_contact_callback_data::contact, sip_options_contact_callback_data::endpoint, ast_sip_contact::endpoint_name, LOG_ERROR, sip_options_endpoint_state_compositor::name, sip_options_aor::name, NULL, ast_sip_contact::outbound_proxy, RAII_VAR, sip_options_apply_transport_to_destination(), sip_options_contact_callback_data_alloc(), sip_options_qualify_resolve_cb(), and ast_sip_contact::uri.

Referenced by sip_options_qualify_aor().

sip_options_qualify_resolve_cb()

static void sip_options_qualify_resolve_cb ( pj_status_t  status, void *  token, const pjsip_server_addresses *  addresses  )

static

DNS callback used to fan out a qualify to every resolved target.

Definition at line 1141 of file pjsip_options.c.

{
    struct sip_options_contact_callback_data *batch = token;
    struct sip_options_qualify_resolve_task_data *task_data;
    unsigned int idx;
 
    task_data = ao2_alloc_options(sizeof(*task_data),
        sip_options_qualify_resolve_task_dtor, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!task_data) {
        /*
         * Resolver callbacks are not guaranteed to run on the AOR serializer,
         * so on allocation failure we must log and drop to avoid potential state
         * issues.
         */
        ast_log(LOG_WARNING,
            "Unable to allocate qualify resolve task for '%s'\n",
            ast_sorcery_object_get_id(batch->contact));
        ao2_ref(batch, -1);
        return;
    }
 
    memset(task_data, 0, sizeof(*task_data));
    task_data->batch = ao2_bump(batch);
    task_data->status = status;
 
    if (status != PJ_SUCCESS || !addresses || !addresses->count) {
        if (batch->resolve_tdata) {
            pjsip_tx_data_dec_ref(batch->resolve_tdata);
            batch->resolve_tdata = NULL;
        }
 
        if (ast_sip_push_task(batch->aor_options->serializer,
            sip_options_qualify_resolve_task, task_data)) {
            ast_log(LOG_WARNING,
                "Unable to queue qualify resolve task for '%s'\n",
                ast_sorcery_object_get_id(batch->contact));
            ao2_ref(task_data, -1);
        }
        ao2_ref(batch, -1);
        return;
    }
 
    /* Each resolved address must contribute exactly one batch result. */
    task_data->count = addresses->count;
    if (task_data->count > PJSIP_MAX_RESOLVED_ADDRESSES) {
        task_data->count = PJSIP_MAX_RESOLVED_ADDRESSES;
    }
 
    for (idx = 0; idx < task_data->count; ++idx) {
        char *name_copy;
 
        name_copy = ast_malloc(addresses->entry[idx].name.slen + 1);
        if (!name_copy) {
            task_data->status = PJ_ENOMEM;
            task_data->count = idx;
            break;
        }
 
        ast_copy_pj_str(name_copy, &addresses->entry[idx].name,
            addresses->entry[idx].name.slen + 1);
        task_data->names[idx] = name_copy;
        task_data->addresses.entry[idx] = addresses->entry[idx];
        task_data->addresses.entry[idx].name.ptr = name_copy;
        task_data->addresses.entry[idx].name.slen = addresses->entry[idx].name.slen;
    }
 
    if (task_data->status == PJ_SUCCESS) {
        task_data->addresses.count = task_data->count;
    }
 
    if (batch->resolve_tdata) {
        pjsip_tx_data_dec_ref(batch->resolve_tdata);
        batch->resolve_tdata = NULL;
    }
 
    /*
     * Push the qualify resolve task to the AOR serializer to avoid potential race
     * conditions between the resolve callback and the qualify contact task.
     */
    if (ast_sip_push_task(batch->aor_options->serializer,
        sip_options_qualify_resolve_task, task_data)) {
        ast_log(LOG_WARNING,
            "Unable to queue qualify resolve task for '%s'\n",
            ast_sorcery_object_get_id(batch->contact));
        ao2_ref(task_data, -1);
    } else {
        ao2_ref(batch, -1);
        return;
    }
 
    ao2_ref(batch, -1);
}

References sip_options_qualify_resolve_task_data::addresses, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ao2_ref, ast_copy_pj_str(), ast_log, ast_malloc, ast_sip_push_task, ast_sorcery_object_get_id(), batch, LOG_WARNING, NULL, sip_options_qualify_resolve_task(), sip_options_qualify_resolve_task_dtor(), and status.

Referenced by sip_options_qualify_contact().

sip_options_qualify_resolve_task()

static int sip_options_qualify_resolve_task ( void *  obj )

static

Process a DNS resolution result on the AOR serializer.

Definition at line 590 of file pjsip_options.c.

{
    struct sip_options_qualify_resolve_task_data *task_data = obj;
    struct sip_options_contact_callback_data *batch = task_data->batch;
    unsigned int idx;
 
    if (task_data->status != PJ_SUCCESS || !task_data->count) {
        /* This failure is a de facto single pending result. */
        batch->pending = 1;
        sip_options_queue_target_result(batch, UNAVAILABLE);
        ao2_ref(task_data, -1);
        return 0;
    }
 
    /* Each resolved address must contribute exactly one batch result. */
    batch->pending = task_data->count;
 
    for (idx = 0; idx < task_data->count; ++idx) {
        pjsip_tx_data *tdata;
        pjsip_via_hdr *via;
        pjsip_transaction *tsx = NULL;
 
        if (ast_sip_create_request("OPTIONS", NULL, batch->endpoint, NULL,
            batch->contact, &tdata)) {
            sip_options_queue_target_result(batch, UNAVAILABLE);
            continue;
        }
 
        if (!ast_strlen_zero(batch->contact->outbound_proxy) &&
            ast_sip_set_outbound_proxy(tdata, batch->contact->outbound_proxy)) {
            pjsip_tx_data_dec_ref(tdata);
            sip_options_queue_target_result(batch, UNAVAILABLE);
            continue;
        }
 
        /*
         * Build a new request per resolved target so each send gets its own
         * transaction and Via branch. Setting exactly one pre-resolved
         * destination here avoids PJSIP re-resolving and choosing only the
         * first DNS result.
         */
        tdata->dest_info.addr.count = 1;
        tdata->dest_info.cur_addr = 0;
        tdata->dest_info.addr.entry[0].type = task_data->addresses.entry[idx].type;
        tdata->dest_info.addr.entry[0].priority = task_data->addresses.entry[idx].priority;
        tdata->dest_info.addr.entry[0].weight = task_data->addresses.entry[idx].weight;
        tdata->dest_info.addr.entry[0].addr_len = task_data->addresses.entry[idx].addr_len;
        pj_sockaddr_cp(&tdata->dest_info.addr.entry[0].addr,
            &task_data->addresses.entry[idx].addr);
        pj_strdup(tdata->pool, &tdata->dest_info.addr.entry[0].name,
            &task_data->addresses.entry[idx].name);
        via = pjsip_msg_find_hdr(tdata->msg, PJSIP_H_VIA, NULL);
        if (via) {
            via->branch_param.slen = 0;
        }
 
        /* ast_sip_send_out_of_dialog_request_with_tsx consumes the tdata reference. */
        if (ast_sip_send_out_of_dialog_request_with_tsx(tdata, batch->endpoint,
            (int)(batch->aor_options->qualify_timeout * 1000),
            ao2_bump(batch), qualify_contact_cb, &tsx)) {
            ao2_ref(batch, -1);
            sip_options_queue_target_result(batch, UNAVAILABLE);
        } else if (tsx) {
            /*
             * It is possible that we will not get back a transaction under two circumstances:
             * 1. The send failed.
             * 2. The build of PJPROJECT used does not contain pjsip_endpt_send_request2() so
             * there is no way to get an in-flight transaction reference for the OPTIONS.
             *
             * With no transaction references, we can not cancel in-flight OPTIONS requests when
             * an endpoint responds with a 2xx response to one of the requests. This is not ideal
             * and will result in unnecessary OPTIONS retransmissions being sent.
             *
             * The Append should never fail as we init the vector to PJSIP_MAX_RESOLVED_ADDRESSES
             * and also limit the count of resolved addresses in sip_options_qualify_resolve_cb.
             */
            AST_VECTOR_APPEND(&batch->target_transactions, tsx);
        }
    }
 
    ao2_ref(task_data, -1);
    return 0;
}

References ao2_bump, ao2_ref, ast_sip_create_request(), ast_sip_send_out_of_dialog_request_with_tsx(), ast_sip_set_outbound_proxy(), ast_strlen_zero(), AST_VECTOR_APPEND, batch, NULL, qualify_contact_cb(), sip_options_queue_target_result(), and UNAVAILABLE.

Referenced by sip_options_qualify_resolve_cb().

sip_options_qualify_resolve_task_dtor()

static void sip_options_qualify_resolve_task_dtor ( void *  obj )

static

Definition at line 577 of file pjsip_options.c.

{
    struct sip_options_qualify_resolve_task_data *task_data = obj;
    unsigned int idx;
 
    for (idx = 0; idx < task_data->count; ++idx) {
        ast_free(task_data->names[idx]);
    }
 
    ao2_ref(task_data->batch, -1);
}

References ao2_ref, and ast_free.

Referenced by sip_options_qualify_resolve_cb().

sip_options_queue_target_result()

static void sip_options_queue_target_result ( struct sip_options_contact_callback_data *  batch, enum ast_sip_contact_status_type  status  )

static

Queue a resolved target's qualification result to be combined with the other targets.

Definition at line 977 of file pjsip_options.c.

{
    struct sip_options_target_result *result;
 
    result = ao2_alloc_options(sizeof(*result), sip_options_target_result_dtor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!result) {
        ast_log(LOG_WARNING, "Unable to allocate qualify target result for '%s'\n",
            ast_sorcery_object_get_id(batch->contact));
        return;
    }
 
    result->batch = ao2_bump(batch);
    result->status = status;
    /*
     * Callbacks may arrive on non-serializer threads, so they queue one result per
     * target onto the AOR serializer, the single owner of the batch's processing.
     *
     * Sends and callbacks can execute synchronously while we are already
     * running on that serializer thread. Re-queueing to the same serializer in
     * that case would defer updates and can break processing.
     *
     * Process inline when already on the same taskpool serializer to preserve
     * immediate, in-order state transitions.
     */
    if (batch->aor_options->serializer == ast_taskpool_serializer_get_current()) {
        sip_options_target_result_task(result);
        return;
    }
 
    if (ast_sip_push_task(batch->aor_options->serializer,
        sip_options_target_result_task, result)) {
        ast_log(LOG_WARNING, "Unable to queue qualify target result for '%s'\n",
            ast_sorcery_object_get_id(batch->contact));
        ao2_ref(result, -1);
    }
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ao2_ref, ast_log, ast_sip_push_task, ast_sorcery_object_get_id(), ast_taskpool_serializer_get_current(), batch, LOG_WARNING, result, sip_options_target_result_dtor(), sip_options_target_result_task(), and status.

Referenced by qualify_contact_cb(), and sip_options_qualify_resolve_task().

sip_options_remove_contact()

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

static

Forward declaration of this helpful function.

Callback function to remove a contact and its contact status from an AOR.

Definition at line 1487 of file pjsip_options.c.

{
    struct ast_sip_contact *contact = obj;
    struct sip_options_aor *aor_options = arg;
 
    sip_options_remove_contact_status(aor_options, contact);
 
    return CMP_MATCH;
}

References CMP_MATCH, and sip_options_remove_contact_status().

Referenced by sip_options_aor_dtor(), and sip_options_apply_aor_configuration().

sip_options_remove_contact_status()

static void sip_options_remove_contact_status ( struct sip_options_aor *  aor_options, struct ast_sip_contact *  contact  )

static

Remove contact status for a hint.

Definition at line 1414 of file pjsip_options.c.

{
    struct ast_sip_contact_status *cs_new;
    struct ast_sip_contact_status *cs_old;
 
    cs_old = ao2_find(sip_options_contact_statuses, ast_sorcery_object_get_id(contact),
        OBJ_SEARCH_KEY | OBJ_UNLINK);
    if (!cs_old) {
        ast_debug(3, "Attempted to remove contact status for '%s' but it does not exist\n",
            ast_sorcery_object_get_id(contact));
        return;
    }
 
    ast_verb(2, "Contact %s/%s has been deleted\n", contact->aor, contact->uri);
 
    /* Update the contact status to reflect its new state */
    cs_new = sip_contact_status_copy(cs_old);
    if (!cs_new) {
        /*
         * We'll have to violate the immutable property because we
         * couldn't create a new one to modify and we are deleting
         * the contact status anyway.
         */
        cs_new = cs_old;
    } else {
        ao2_ref(cs_old, -1);
    }
    cs_new->last_status = cs_new->status;
    cs_new->status = REMOVED;
    cs_new->rtt = 0;
 
    ast_statsd_log_string_va("PJSIP.contacts.states.%s", AST_STATSD_GAUGE,
        "-1", 1.0, ast_sip_get_contact_status_label(cs_new->last_status));
    ast_statsd_log_string_va("PJSIP.contacts.states.%s", AST_STATSD_GAUGE,
        "+1", 1.0, ast_sip_get_contact_status_label(cs_new->status));
 
    sip_options_contact_status_update(cs_new);
 
    /*
     * The only time we need to update the AOR is if this contact was
     * available and qualify is in use, otherwise we can just stop
     * early.
     */
    if (!aor_options->qualify_frequency || cs_new->last_status != AVAILABLE) {
        ao2_ref(cs_new, -1);
        return;
    }
 
    --aor_options->available;
    if (!aor_options->available) {
        sip_options_notify_endpoint_state_compositors(aor_options, UNAVAILABLE);
    }
 
    ast_debug(3, "AOR '%s' now has %d available contacts\n", aor_options->name,
        aor_options->available);
 
    ao2_ref(cs_new, -1);
}

References ao2_find, ao2_ref, ast_sip_contact::aor, ast_debug, ast_sip_get_contact_status_label(), ast_sorcery_object_get_id(), AST_STATSD_GAUGE, ast_statsd_log_string_va(), ast_verb, AVAILABLE, sip_options_aor::available, ast_sip_contact_status::last_status, sip_options_aor::name, OBJ_SEARCH_KEY, OBJ_UNLINK, sip_options_aor::qualify_frequency, REMOVED, ast_sip_contact_status::rtt, sip_contact_status_copy(), sip_options_contact_status_update(), sip_options_contact_statuses, sip_options_notify_endpoint_state_compositors(), ast_sip_contact_status::status, UNAVAILABLE, and ast_sip_contact::uri.

Referenced by sip_options_contact_delete_task(), and sip_options_remove_contact().

sip_options_set_contact_status()

static void sip_options_set_contact_status ( struct ast_sip_contact_status *  contact_status, enum ast_sip_contact_status_type  status  )

static

Set the contact status for a contact.

Definition at line 1514 of file pjsip_options.c.

{
    struct ast_sip_contact_status *cs_new;
 
    /* Update the contact specific status information */
    cs_new = sip_contact_status_copy(contact_status);
    if (!cs_new) {
        return;
    }
    cs_new->last_status = cs_new->status;
    cs_new->status = status;
 
    /*
     * We need to always set the RTT to zero because we haven't completed
     * an OPTIONS ping so RTT is unknown.  If the OPTIONS ping were still
     * running it will be refreshed on the next go round anyway.
     */
    cs_new->rtt = 0;
 
    ao2_link(sip_options_contact_statuses, cs_new);
 
    if (cs_new->status != cs_new->last_status) {
        ast_verb(3, "Contact %s/%s is now %s.\n",
            cs_new->aor, cs_new->uri,
            ast_sip_get_contact_status_label(cs_new->status));
 
        ast_statsd_log_string_va("PJSIP.contacts.states.%s", AST_STATSD_GAUGE,
            "-1", 1.0, ast_sip_get_contact_status_label(cs_new->last_status));
        ast_statsd_log_string_va("PJSIP.contacts.states.%s", AST_STATSD_GAUGE,
            "+1", 1.0, ast_sip_get_contact_status_label(cs_new->status));
 
        sip_options_contact_status_update(cs_new);
 
        ast_test_suite_event_notify("AOR_CONTACT_UPDATE",
            "Contact: %s\r\n"
            "Status: %s",
            cs_new->name,
            ast_sip_get_contact_status_label(cs_new->status));
    }
    ao2_ref(cs_new, -1);
}

References ao2_link, ao2_ref, ast_sip_contact_status::aor, ast_sip_get_contact_status_label(), AST_STATSD_GAUGE, ast_statsd_log_string_va(), ast_test_suite_event_notify, ast_verb, ast_sip_contact_status::last_status, ast_sip_contact_status::name, ast_sip_contact_status::rtt, sip_contact_status_copy(), sip_options_contact_status_update(), sip_options_contact_statuses, status, ast_sip_contact_status::status, and ast_sip_contact_status::uri.

Referenced by sip_options_set_contact_status_qualified(), and sip_options_set_contact_status_unqualified().

sip_options_set_contact_status_qualified()

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

static

Transition the contact status to qualified mode.

Definition at line 1585 of file pjsip_options.c.

{
    struct ast_sip_contact *contact = obj;
    struct ast_sip_contact_status *contact_status;
 
    contact_status = ast_res_pjsip_find_or_create_contact_status(contact);
    if (!contact_status) {
        return 0;
    }
 
    switch (contact_status->status) {
    case AVAILABLE:
        sip_options_set_contact_status(contact_status, UNAVAILABLE);
        break;
    case UNAVAILABLE:
    case UNKNOWN:
    case CREATED:
    case REMOVED:
        break;
    }
 
    ao2_ref(contact_status, -1);
 
    return 0;
}

References ao2_ref, ast_res_pjsip_find_or_create_contact_status(), AVAILABLE, CREATED, REMOVED, sip_options_set_contact_status(), ast_sip_contact_status::status, UNAVAILABLE, and UNKNOWN.

Referenced by sip_options_apply_aor_configuration().

sip_options_set_contact_status_unqualified()

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

static

Transition the contact status to unqualified mode.

Definition at line 1558 of file pjsip_options.c.

{
    struct ast_sip_contact *contact = obj;
    struct ast_sip_contact_status *contact_status;
 
    contact_status = ast_res_pjsip_find_or_create_contact_status(contact);
    if (!contact_status) {
        return 0;
    }
 
    switch (contact_status->status) {
    case AVAILABLE:
    case UNAVAILABLE:
    case UNKNOWN:
        sip_options_set_contact_status(contact_status, CREATED);
        break;
    case CREATED:
    case REMOVED:
        break;
    }
 
    ao2_ref(contact_status, -1);
 
    return 0;
}

References ao2_ref, ast_res_pjsip_find_or_create_contact_status(), AVAILABLE, CREATED, REMOVED, sip_options_set_contact_status(), ast_sip_contact_status::status, UNAVAILABLE, and UNKNOWN.

Referenced by sip_options_apply_aor_configuration().

sip_options_synchronize()

static void sip_options_synchronize ( int  reload )

static

Synchronize our local container of AORs and endpoint state compositors with the current configuration.

Definition at line 2210 of file pjsip_options.c.

{
    struct sip_options_synchronize_task_data task_data = {
        .reload = reload,
    };
 
    ast_sip_push_task_wait_serializer(management_serializer, sip_options_synchronize_task,
        &task_data);
}

References ast_sip_push_task_wait_serializer, management_serializer, reload(), and sip_options_synchronize_task().

Referenced by ast_res_pjsip_init_options_handling(), and sip_options_init_task().

sip_options_synchronize_aor()

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

static

Synchronize an AOR with our local state.

Note

Run by management_serializer

Definition at line 1826 of file pjsip_options.c.

{
    struct sip_options_synchronize_aor_task_data task_data = {
        .aor = obj,
        .existing = arg,
    };
 
    task_data.aor_options = ao2_find(sip_options_aors,
        ast_sorcery_object_get_id(task_data.aor), OBJ_SEARCH_KEY);
    if (!task_data.aor_options) {
        task_data.aor_options = sip_options_aor_alloc(task_data.aor);
        if (!task_data.aor_options) {
            return 0;
        }
 
        task_data.added = 1;
 
        /* Nothing is aware of this AOR yet so we can just update it in this thread */
        sip_options_synchronize_aor_task(&task_data);
        ao2_link(sip_options_aors, task_data.aor_options);
    } else {
        /* This AOR already exists so we have to do manipulation in its serializer */
        ast_sip_push_task_wait_serializer(task_data.aor_options->serializer,
            sip_options_synchronize_aor_task, &task_data);
    }
 
    ao2_ref(task_data.aor_options, -1);
 
    if (task_data.existing) {
        ao2_find(task_data.existing, ast_sorcery_object_get_id(task_data.aor),
            OBJ_SEARCH_KEY | OBJ_UNLINK | OBJ_NODATA);
    }
 
    return 0;
}

References ao2_find, ao2_link, ao2_ref, ast_sip_push_task_wait_serializer, ast_sorcery_object_get_id(), OBJ_NODATA, OBJ_SEARCH_KEY, OBJ_UNLINK, sip_options_aor_alloc(), sip_options_aors, and sip_options_synchronize_aor_task().

Referenced by sip_options_synchronize_task().

sip_options_synchronize_aor_task()

static int sip_options_synchronize_aor_task ( void *  obj )

static

Task to synchronize an AOR with our local state.

Note

Run by aor_options->serializer (or management_serializer on aor_options creation)

Definition at line 1788 of file pjsip_options.c.

{
    struct sip_options_synchronize_aor_task_data *task_data = obj;
    int i;
 
    ast_debug(3, "Synchronizing AOR '%s' with current state of configuration and world\n",
        task_data->aor_options->name);
 
    sip_options_apply_aor_configuration(task_data->aor_options, task_data->aor,
        task_data->added);
 
    /*
     * Endpoint state compositors are removed in this operation but not
     * added.  To reduce the amount of work done they are done later.  In
     * the mean time things can still qualify and once an endpoint state
     * compositor is added to the AOR it will be updated with the current
     * state.
     */
    for (i = 0; i < AST_VECTOR_SIZE(&task_data->aor_options->compositors); ++i) {
        struct sip_options_endpoint_state_compositor *endpoint_state_compositor;
 
        endpoint_state_compositor = AST_VECTOR_GET(&task_data->aor_options->compositors, i);
 
        ao2_lock(endpoint_state_compositor);
        endpoint_state_compositor->active = 0;
        sip_options_update_endpoint_state_compositor_aor(endpoint_state_compositor,
            task_data->aor_options->name, REMOVED);
        ao2_unlock(endpoint_state_compositor);
    }
    AST_VECTOR_RESET(&task_data->aor_options->compositors, ao2_cleanup);
 
    return 0;
}

References sip_options_endpoint_state_compositor::active, ao2_cleanup, ao2_lock, ao2_unlock, ast_debug, AST_VECTOR_GET, AST_VECTOR_RESET, AST_VECTOR_SIZE, REMOVED, sip_options_apply_aor_configuration(), and sip_options_update_endpoint_state_compositor_aor().

Referenced by sip_options_synchronize_aor().

sip_options_synchronize_endpoint()

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

static

Synchronize an endpoint with our local state.

Note

Run by management_serializer

Definition at line 1989 of file pjsip_options.c.

{
    struct ast_sip_endpoint *endpoint = obj;
    struct ast_sip_aor *aor = arg;
    char *aors;
    char *aor_name;
    struct sip_options_endpoint_compositor_task_data task_data = { NULL, };
 
    if (ast_strlen_zero(endpoint->aors)) {
        /* There are no AORs, so really... who the heck knows */
        ast_debug(3, "Endpoint '%s' is not interested in any AORs so not creating endpoint state compositor\n",
            ast_sorcery_object_get_id(endpoint));
        return 0;
    }
 
    ast_debug(3, "Synchronizing endpoint '%s' with AORs '%s'\n",
        ast_sorcery_object_get_id(endpoint), endpoint->aors);
 
    aors = ast_strdupa(endpoint->aors);
    while ((aor_name = ast_strip(strsep(&aors, ",")))) {
        if (ast_strlen_zero(aor_name)) {
            continue;
        }
        if (aor && strcasecmp(ast_sorcery_object_get_id(aor), aor_name)) {
            ast_debug(3, "Filtered AOR '%s' on endpoint '%s' as we are looking for '%s'\n",
                aor_name, ast_sorcery_object_get_id(endpoint),
                ast_sorcery_object_get_id(aor));
            continue;
        }
 
        task_data.aor_options = ao2_find(sip_options_aors, aor_name, OBJ_SEARCH_KEY);
        if (!task_data.aor_options) {
            /*
             * They have referenced an invalid AOR. If that's all they've
             * done we will set them to offline at the end.
             */
            ast_debug(3, "Endpoint '%s' referenced invalid AOR '%s'\n",
                ast_sorcery_object_get_id(endpoint), aor_name);
            continue;
        }
 
        if (!task_data.endpoint_state_compositor) {
            /*
             * We create an endpoint state compositor only after we know
             * for sure we need it.
             */
            task_data.endpoint_state_compositor =
                sip_options_endpoint_state_compositor_find_or_alloc(endpoint);
            if (!task_data.endpoint_state_compositor) {
                ast_log(LOG_WARNING,
                    "Could not create endpoint state compositor for '%s', endpoint state will be incorrect\n",
                    ast_sorcery_object_get_id(endpoint));
                ao2_ref(task_data.aor_options, -1);
                ast_sip_persistent_endpoint_update_state(ast_sorcery_object_get_id(endpoint),
                    AST_ENDPOINT_OFFLINE);
                return 0;
            }
        }
 
        /* We use a synchronous task so that we don't flood the system */
        ast_sip_push_task_wait_serializer(task_data.aor_options->serializer,
            sip_options_endpoint_compositor_add_task, &task_data);
 
        ao2_ref(task_data.aor_options, -1);
 
        /*
         * If we filtered on a specific AOR name then the endpoint can
         * only reference it once so break early.
         */
        if (aor) {
            break;
        }
    }
 
    if (task_data.endpoint_state_compositor) {
        /*
         * If an endpoint state compositor is present determine the current state
         * of the endpoint and update it.
         */
        ao2_lock(task_data.endpoint_state_compositor);
        task_data.endpoint_state_compositor->active = 1;
        ast_sip_persistent_endpoint_update_state(ast_sorcery_object_get_id(endpoint),
            sip_options_get_endpoint_state_compositor_state(task_data.endpoint_state_compositor));
        ao2_unlock(task_data.endpoint_state_compositor);
 
        ao2_ref(task_data.endpoint_state_compositor, -1);
    } else if (!aor) {
        /* If no explicit AOR is specified we are updating the endpoint itself, so then set
         * it to offline if no endpoint compositor exists as they referenced an invalid AOR
         * or none at all
         */
        ast_debug(3, "Endpoint '%s' has no AORs feeding it, setting it to offline state as default\n",
            ast_sorcery_object_get_id(endpoint));
        ast_sip_persistent_endpoint_update_state(ast_sorcery_object_get_id(endpoint),
            AST_ENDPOINT_OFFLINE);
    }
 
    return 0;
}

References ao2_find, ao2_lock, ao2_ref, ao2_unlock, ast_sip_endpoint::aors, ast_debug, AST_ENDPOINT_OFFLINE, ast_log, ast_sip_persistent_endpoint_update_state(), ast_sip_push_task_wait_serializer, ast_sorcery_object_get_id(), ast_strdupa, ast_strip(), ast_strlen_zero(), LOG_WARNING, NULL, OBJ_SEARCH_KEY, sip_options_aors, sip_options_endpoint_compositor_add_task(), sip_options_endpoint_state_compositor_find_or_alloc(), sip_options_get_endpoint_state_compositor_state(), and strsep().

Referenced by sip_options_aor_observer_modified_task(), sip_options_endpoint_observer_modified_task(), and sip_options_synchronize_task().

sip_options_synchronize_task()

static int sip_options_synchronize_task ( void *  obj )

static

Task to synchronize our local container of AORs and endpoint state compositors with the current configuration.

Note

Run by management_serializer

Definition at line 2154 of file pjsip_options.c.

{
    struct sip_options_synchronize_task_data *task_data = obj;
    struct ao2_container *existing = NULL;
    struct ao2_container *objects;
 
    /*
     * When reloading we keep track of the existing AORs so we can
     * terminate old ones that are no longer referenced or used.
     */
    if (task_data->reload) {
        existing = ao2_container_clone(sip_options_aors, 0);
        if (!existing) {
            return 0;
        }
    }
 
    objects = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "aor",
        AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
    if (objects) {
        /* Go through the returned AORs and synchronize with our local state */
        ao2_callback(objects, OBJ_NODATA, sip_options_synchronize_aor, existing);
        ao2_ref(objects, -1);
    }
 
    /*
     * Any AORs remaining in existing are no longer referenced by
     * the current container of AORs we retrieved, so remove them.
     */
    if (existing) {
        ao2_callback(existing, OBJ_NODATA | OBJ_MULTIPLE | OBJ_UNLINK,
            sip_options_unused_aor, NULL);
        ao2_ref(existing, -1);
    }
 
    objects = ast_sorcery_retrieve_by_fields(ast_sip_get_sorcery(), "endpoint",
        AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
    if (objects) {
        /* Go through the provided endpoints and update AORs */
        ao2_callback(objects, OBJ_NODATA, sip_options_synchronize_endpoint, NULL);
        ao2_ref(objects, -1);
    }
 
    /*
     * All endpoint state compositors that don't have any AORs
     * feeding them information can be removed.  If they end
     * up getting needed later they'll just be recreated.
     */
    ao2_callback(sip_options_endpoint_state_compositors,
        OBJ_NODATA | OBJ_MULTIPLE | OBJ_UNLINK,
        sip_options_unused_endpoint_state_compositor, NULL);
 
    return 0;
}

References ao2_callback, ao2_container_clone, ao2_ref, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sip_get_sorcery(), ast_sorcery_retrieve_by_fields(), NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, sip_options_aors, sip_options_endpoint_state_compositors, sip_options_synchronize_aor(), sip_options_synchronize_endpoint(), sip_options_unused_aor(), and sip_options_unused_endpoint_state_compositor().

Referenced by sip_options_synchronize().

sip_options_target_result_dtor()

static void sip_options_target_result_dtor ( void *  obj )

static

Destructor for a resolved target's qualification result.

Definition at line 936 of file pjsip_options.c.

{
    struct sip_options_target_result *result = obj;
    ao2_cleanup(result->batch);
}

References ao2_cleanup, and result.

Referenced by sip_options_queue_target_result().

sip_options_target_result_task()

static int sip_options_target_result_task ( void *  obj )

static

Combine the result of one resolved target with the other targets.

Note

Run by aor_options->serializer

Definition at line 946 of file pjsip_options.c.

{
    struct sip_options_target_result *result = obj;
    struct sip_options_contact_callback_data *batch = result->batch;
 
    if (!batch->completed) {
        /* If the result is available then we can mark the batch as completed
            and notify the AOR */
        ast_assert(batch->pending);
        --batch->pending;
 
        if (result->status == AVAILABLE) {
            /* At least one resolved target was available. */
            batch->completed = 1;
            batch->status = AVAILABLE;
            sip_options_cancel_target_transactions(batch);
            /* The notify task inherits this reference. */
            sip_options_contact_status_notify_task(ao2_bump(batch));
        } else if (!batch->pending) {
            /* Every resolved target failed. */
            batch->completed = 1;
            batch->status = UNAVAILABLE;
            sip_options_contact_status_notify_task(ao2_bump(batch));
        }
    }
 
    ao2_ref(result, -1);
    return 0;
}

References ao2_bump, ao2_ref, ast_assert, AVAILABLE, batch, result, sip_options_cancel_target_transactions(), sip_options_contact_status_notify_task(), and UNAVAILABLE.

Referenced by sip_options_queue_target_result().

sip_options_transaction_free()

static void sip_options_transaction_free ( pjsip_transaction *  tsx )

static

Definition at line 674 of file pjsip_options.c.

{
    if (tsx) {
        pj_grp_lock_dec_ref(tsx->grp_lock);
    }
}

Referenced by sip_options_contact_callback_data_dtor().

sip_options_unused_aor()

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

static

Callback which removes any unused AORs that remained after reloading.

Note

Run by management_serializer

Definition at line 2112 of file pjsip_options.c.

{
    struct sip_options_aor *aor_options = obj;
 
    ast_debug(3, "AOR '%s' is no longer configured, removing it\n", aor_options->name);
 
    ast_sip_push_task_wait_serializer(aor_options->serializer, sip_options_aor_remove_task,
        aor_options);
    ao2_unlink(sip_options_aors, aor_options);
 
    return CMP_MATCH;
}

References ao2_unlink, ast_debug, ast_sip_push_task_wait_serializer, CMP_MATCH, sip_options_aor::name, sip_options_aor::serializer, sip_options_aor_remove_task(), and sip_options_aors.

Referenced by sip_options_synchronize_task().

sip_options_unused_endpoint_state_compositor()

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

static

Callback function used to unlink and remove event state compositors that have no AORs feeding them.

Note

Run by management_serializer

Definition at line 2129 of file pjsip_options.c.

{
    struct sip_options_endpoint_state_compositor *endpoint_state_compositor = obj;
 
    if (ao2_container_count(endpoint_state_compositor->aor_statuses)) {
        return 0;
    }
 
    /* No AORs are feeding this endpoint state compositor */
    ast_sip_persistent_endpoint_update_state(endpoint_state_compositor->name,
        AST_ENDPOINT_OFFLINE);
 
    return CMP_MATCH;
}

References ao2_container_count(), sip_options_endpoint_state_compositor::aor_statuses, AST_ENDPOINT_OFFLINE, ast_sip_persistent_endpoint_update_state(), CMP_MATCH, and sip_options_endpoint_state_compositor::name.

Referenced by sip_options_synchronize_task().

sip_options_update_aor_task()

static int sip_options_update_aor_task ( void *  obj )

static

Task to synchronize an AOR with our local state.

Note

Run by aor_options->serializer

Definition at line 2337 of file pjsip_options.c.

{
    struct sip_options_synchronize_aor_task_data *task_data = obj;
    int available = task_data->aor_options->available;
 
    ast_debug(3, "Individually updating AOR '%s' with current state of configuration and world\n",
        task_data->aor_options->name);
 
    sip_options_apply_aor_configuration(task_data->aor_options, task_data->aor,
        task_data->added);
 
    if (!available && task_data->aor_options->available) {
        ast_debug(3, "After modifying AOR '%s' it has now become available\n",
            task_data->aor_options->name);
        sip_options_notify_endpoint_state_compositors(task_data->aor_options, AVAILABLE);
    } else if (available && !task_data->aor_options->available) {
        ast_debug(3, "After modifying AOR '%s' it has become unavailable\n",
            task_data->aor_options->name);
        sip_options_notify_endpoint_state_compositors(task_data->aor_options, UNAVAILABLE);
    }
 
    return 0;
}

References ast_debug, available(), AVAILABLE, sip_options_apply_aor_configuration(), sip_options_notify_endpoint_state_compositors(), and UNAVAILABLE.

Referenced by sip_options_aor_observer_modified_task().

sip_options_update_endpoint_state_compositor_aor()

static void sip_options_update_endpoint_state_compositor_aor ( struct sip_options_endpoint_state_compositor *  endpoint_state_compositor, const char *  name, enum ast_sip_contact_status_type  status  )

static

Update the AOR status on an endpoint state compositor.

Precondition

The endpoint_state_compositor lock must be held.

Definition at line 731 of file pjsip_options.c.

{
    struct sip_options_endpoint_aor_status *aor_status;
    enum ast_endpoint_state endpoint_state;
 
    aor_status = ao2_find(endpoint_state_compositor->aor_statuses, name,
        OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (!aor_status) {
        /* The AOR status doesn't exist already so we don't need to go any further */
        if (status == REMOVED) {
            return;
        }
 
        aor_status = ao2_alloc_options(sizeof(*aor_status) + strlen(name) + 1, NULL,
            AO2_ALLOC_OPT_LOCK_NOLOCK);
        if (!aor_status) {
            return;
        }
 
        strcpy(aor_status->name, name); /* SAFE */
        ao2_link(endpoint_state_compositor->aor_statuses, aor_status);
    }
 
    if (status == REMOVED) {
        /*
         * If the AOR is being removed then remove its AOR status
         * from the endpoint compositor.
         */
        ao2_unlink(endpoint_state_compositor->aor_statuses, aor_status);
    } else {
        aor_status->available = (status == AVAILABLE ? 1 : 0);
    }
    ao2_ref(aor_status, -1);
 
    if (!endpoint_state_compositor->active) {
        return;
    }
 
    /* If this AOR is available then the endpoint itself has to be online */
    if (status == AVAILABLE) {
        ast_debug(3, "Endpoint state compositor '%s' is online as AOR '%s' is available\n",
            endpoint_state_compositor->name, name);
        endpoint_state = AST_ENDPOINT_ONLINE;
    } else {
        endpoint_state =
            sip_options_get_endpoint_state_compositor_state(endpoint_state_compositor);
    }
 
    ast_sip_persistent_endpoint_update_state(endpoint_state_compositor->name,
        endpoint_state);
}

References sip_options_endpoint_state_compositor::active, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_find, ao2_link, ao2_ref, ao2_unlink, sip_options_endpoint_state_compositor::aor_statuses, ast_debug, AST_ENDPOINT_ONLINE, ast_sip_persistent_endpoint_update_state(), AVAILABLE, sip_options_endpoint_aor_status::available, sip_options_endpoint_aor_status::name, sip_options_endpoint_state_compositor::name, name, NULL, OBJ_NOLOCK, OBJ_SEARCH_KEY, REMOVED, sip_options_get_endpoint_state_compositor_state(), and status.

Referenced by sip_options_endpoint_compositor_add_task(), sip_options_notify_endpoint_state_compositors(), and sip_options_synchronize_aor_task().

Variable Documentation

aor_observer_callbacks

const struct ast_sorcery_observer aor_observer_callbacks

static

Initial value:

= {
    .created = aor_observer_modified,
    .updated = aor_observer_modified,
    .deleted = aor_observer_deleted,
}

Observer callbacks for AORs.

Definition at line 2458 of file pjsip_options.c.

                                                                  {
    .created = aor_observer_modified,
    .updated = aor_observer_modified,
    .deleted = aor_observer_deleted,
};

Referenced by ast_res_pjsip_cleanup_options_handling(), and sip_options_init_task().

cli_options

struct ast_cli_entry cli_options[]

static

Definition at line 3117 of file pjsip_options.c.

                                            {
    AST_CLI_DEFINE(cli_qualify, "Send an OPTIONS request to a PJSIP endpoint"),
    AST_CLI_DEFINE(cli_show_qualify_endpoint, "Show the current qualify options for all Aors on the PJSIP endpoint"),
    AST_CLI_DEFINE(cli_show_qualify_aor, "Show the PJSIP Aor current qualify options"),
    AST_CLI_DEFINE(cli_reload_qualify_endpoint, "Synchronize the qualify options for all Aors on the PJSIP endpoint"),
    AST_CLI_DEFINE(cli_reload_qualify_aor, "Synchronize the PJSIP Aor qualify options"),
};

Referenced by ast_res_pjsip_cleanup_options_handling(), and ast_res_pjsip_init_options_handling().

contact_observer_callbacks

const struct ast_sorcery_observer contact_observer_callbacks

static

Initial value:

= {
    .created = contact_observer_created,
    .updated = contact_observer_updated,
    .deleted = contact_observer_deleted,
}

Observer callbacks for contacts.

Definition at line 2746 of file pjsip_options.c.

                                                                      {
    .created = contact_observer_created,
    .updated = contact_observer_updated,
    .deleted = contact_observer_deleted,
};

Referenced by ast_res_pjsip_cleanup_options_handling(), and sip_options_init_task().

contact_status_formatter

struct ast_sip_endpoint_formatter contact_status_formatter

static

Initial value:

= {
    .format_ami = format_ami_contact_status
}

Definition at line 3197 of file pjsip_options.c.

                                                                    {
    .format_ami = format_ami_contact_status
};

Referenced by ast_res_pjsip_cleanup_options_handling(), and ast_res_pjsip_init_options_handling().

endpoint_observer_callbacks

const struct ast_sorcery_observer endpoint_observer_callbacks

static

Initial value:

= {
    .created = endpoint_observer_modified,
    .updated = endpoint_observer_modified,
    .deleted = endpoint_observer_deleted,
}

Observer callbacks for endpoints.

Definition at line 2327 of file pjsip_options.c.

                                                                       {
    .created = endpoint_observer_modified,
    .updated = endpoint_observer_modified,
    .deleted = endpoint_observer_deleted,
};

Referenced by ast_res_pjsip_cleanup_options_handling(), and sip_options_init_task().

management_serializer

struct ast_taskprocessor* management_serializer

static

Definition at line 212 of file pjsip_options.c.

Referenced by aor_observer_deleted(), aor_observer_modified(), ast_res_pjsip_cleanup_options_handling(), ast_res_pjsip_init_options_handling(), cli_reload_qualify_aor(), cli_reload_qualify_endpoint(), contact_observer_created(), contact_observer_deleted(), contact_observer_updated(), endpoint_observer_deleted(), endpoint_observer_modified(), sip_options_contact_status_update(), sip_options_init_task(), and sip_options_synchronize().

options_module

pjsip_module options_module

static

Definition at line 309 of file pjsip_options.c.

                                     {
    .name = {"Options Module", 14},
    .id = -1,
    .priority = PJSIP_MOD_PRIORITY_APPLICATION,
    .on_rx_request = options_on_rx_request,
};

Referenced by ast_res_pjsip_cleanup_options_handling(), and ast_res_pjsip_init_options_handling().

short_status_map

const char* short_status_map[]

static

Definition at line 324 of file pjsip_options.c.

                                        {
    [UNAVAILABLE] = "Unavail",
    [AVAILABLE] = "Avail",
    [UNKNOWN] = "Unknown",
    [CREATED] = "NonQual",
    [REMOVED] = "Removed",
};

Referenced by ast_sip_get_contact_short_status_label().

sip_options_aors

struct ao2_container* sip_options_aors

static

Definition at line 194 of file pjsip_options.c.

Referenced by ami_sip_qualify(), ast_res_pjsip_cleanup_options_handling(), ast_res_pjsip_init_options_handling(), cli_qualify(), cli_show_qualify_aor(), cli_show_qualify_endpoint(), contact_observer_updated(), contact_status_publish_update_task(), sip_options_aor_observer_deleted_task(), sip_options_aor_observer_modified_task(), sip_options_cleanup_task(), sip_options_contact_add_management_task(), sip_options_contact_delete_management_task(), sip_options_endpoint_unlink_aor_feeders(), sip_options_synchronize_aor(), sip_options_synchronize_endpoint(), sip_options_synchronize_task(), and sip_options_unused_aor().

sip_options_contact_statuses

struct ao2_container* sip_options_contact_statuses

static

Definition at line 200 of file pjsip_options.c.

Referenced by ast_res_pjsip_cleanup_options_handling(), ast_res_pjsip_find_or_create_contact_status(), ast_res_pjsip_preinit_options_handling(), ast_sip_get_contact_status(), sip_options_contact_status_notify_task(), sip_options_remove_contact_status(), and sip_options_set_contact_status().

sip_options_endpoint_state_compositors

struct ao2_container* sip_options_endpoint_state_compositors

static

Definition at line 206 of file pjsip_options.c.

Referenced by ast_res_pjsip_cleanup_options_handling(), ast_res_pjsip_init_options_handling(), sip_options_endpoint_observer_deleted_task(), sip_options_endpoint_observer_modified_task(), sip_options_endpoint_state_compositor_find_or_alloc(), and sip_options_synchronize_task().

status_map

const char* status_map[]

static

Definition at line 316 of file pjsip_options.c.

                                  {
    [UNAVAILABLE] = "Unreachable",
    [AVAILABLE] = "Reachable",
    [UNKNOWN] = "Unknown",
    [CREATED] = "NonQualified",
    [REMOVED] = "Removed",
};