res_pjsip_outbound_publish.c File Reference

#include "asterisk.h"
#include <pjsip.h>
#include <pjsip_simple.h>
#include "asterisk/res_pjproject.h"
#include "asterisk/res_pjsip.h"
#include "asterisk/res_pjsip_outbound_publish.h"
#include "asterisk/module.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/taskpool.h"
#include "asterisk/serializer_shutdown_group.h"
#include "asterisk/datastore.h"
#include "res_pjsip/include/res_pjsip_private.h"

Include dependency graph for res_pjsip_outbound_publish.c:

Go to the source code of this file.

Data Structures
struct	ast_sip_outbound_publish
	Outbound publish information. More...
struct	ast_sip_outbound_publish_client
	Outbound publish client state information (persists for lifetime of a publish) More...
struct	ast_sip_outbound_publish_state
	Outbound publish state information (persists for lifetime of a publish) More...
struct	publisher_handlers
struct	sip_outbound_publish_message
	Queued outbound publish message. More...
struct	sip_outbound_publisher

Macros
#define	ADD_TO_NEW_STATES(__obj)
#define	DATASTORE_BUCKETS   53
#define	DEFAULT_PUBLISHER_BUCKETS   119
#define	DEFAULT_STATE_BUCKETS   31
	Default number of client state container buckets.
#define	DESTROY_CLIENT()
#define	MAX_UNLOAD_TIMEOUT_TIME   35 /* Seconds */

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static	AO2_GLOBAL_OBJ_STATIC (current_states)
	AO2_STRING_FIELD_CMP_FN (sip_outbound_publisher, user)
	AO2_STRING_FIELD_HASH_FN (sip_outbound_publisher, user)
struct ast_module *	AST_MODULE_SELF_SYM (void)
int	ast_sip_publish_client_add_datastore (struct ast_sip_outbound_publish_client *client, struct ast_datastore *datastore)
	Add a datastore to a SIP event publisher.
struct ast_datastore *	ast_sip_publish_client_alloc_datastore (const struct ast_datastore_info *info, const char *uid)
	Alternative for ast_datastore_alloc()
struct ast_sip_outbound_publish_client *	ast_sip_publish_client_get (const char *name)
	Find a publish client using its name.
struct ast_datastore *	ast_sip_publish_client_get_datastore (struct ast_sip_outbound_publish_client *client, const char *name)
	Retrieve an event publisher datastore.
const char *	ast_sip_publish_client_get_from_uri (struct ast_sip_outbound_publish_client *client)
	Get the From URI the client will use.
const char *	ast_sip_publish_client_get_to_uri (struct ast_sip_outbound_publish_client *client)
	Get the To URI the client will use.
const char *	ast_sip_publish_client_get_user_from_uri (struct ast_sip_outbound_publish_client *client, const char *user, char *uri, size_t size)
	Get the From URI the client will use for a specific user.
const char *	ast_sip_publish_client_get_user_to_uri (struct ast_sip_outbound_publish_client *client, const char *user, char *uri, size_t size)
	Get the To URI the client will use for a specific user.
void	ast_sip_publish_client_remove (struct ast_sip_outbound_publish_client *client, const char *user)
	Remove the user from the client (stopping it from publishing)
void	ast_sip_publish_client_remove_datastore (struct ast_sip_outbound_publish_client *client, const char *name)
	Remove a publication datastore from an event publisher.
int	ast_sip_publish_client_send (struct ast_sip_outbound_publish_client *client, const struct ast_sip_body *body)
	Send an outgoing PUBLISH message using a client.
int	ast_sip_publish_client_user_send (struct ast_sip_outbound_publish_client *client, const char *user, const struct ast_sip_body *body)
	Send an outgoing PUBLISH message based on the user.
int	ast_sip_register_event_publisher_handler (struct ast_sip_event_publisher_handler *handler)
	Register an event publisher handler.
void	ast_sip_unregister_event_publisher_handler (struct ast_sip_event_publisher_handler *handler)
	Unregister a publish handler.
static int	can_reuse_publish (struct ast_sip_outbound_publish *existing, struct ast_sip_outbound_publish *applied)
static int	cancel_and_unpublish (void *obj, void *arg, int flags)
	Helper function which cancels and un-publishes a no longer used client.
static void	cancel_publish_refresh (struct sip_outbound_publisher *publisher)
	Helper function which cancels the refresh timer on a publisher.
static int	cancel_refresh_timer_task (void *data)
	Task for cancelling a refresh timer.
static int	current_state_reusable (struct ast_sip_outbound_publish *publish, struct ast_sip_outbound_publish_state *current_state)
static int	datastore_cmp (void *obj, void *arg, int flags)
static int	datastore_hash (const void *obj, int flags)
static int	explicit_publish_destroy (void *data)
static struct ast_sip_event_publisher_handler *	find_publisher_handler_for_event_name (const char *event_name)
static struct ao2_container *	get_publishes_and_update_state (void)
static int	load_module (void)
static int	outbound_auth_handler (const struct aco_option *opt, struct ast_variable *var, void *obj)
static int	outbound_publish_state_cmp (void *obj, void *arg, int flags)
	comparator function for client objects
static int	outbound_publish_state_hash (const void *obj, const int flags)
	hashing function for state objects
static int	publisher_client_send (void *obj, void *arg, void *data, int flags)
static int	reload_module (void)
static void	schedule_publish_refresh (struct sip_outbound_publisher *publisher, int expiration)
	Helper function which sets up the timer to send publication.
static int	send_unpublish_task (void *data)
	Task for sending an unpublish.
static void	set_transport (struct sip_outbound_publisher *publisher, pjsip_tx_data *tdata)
static void *	sip_outbound_publish_alloc (const char *name)
	Allocator function for publish information.
static int	sip_outbound_publish_apply (const struct ast_sorcery *sorcery, void *obj)
	Apply function which finds or allocates a state structure.
static void	sip_outbound_publish_callback (struct pjsip_publishc_cbparam *param)
	Callback function for publish client responses.
static struct sip_outbound_publisher *	sip_outbound_publish_client_add_publisher (struct ast_sip_outbound_publish_client *client, const char *user)
static void	sip_outbound_publish_client_destroy (void *obj)
	Destructor function for publish client.
static struct sip_outbound_publisher *	sip_outbound_publish_client_get_publisher (struct ast_sip_outbound_publish_client *client, const char *user)
static void	sip_outbound_publish_datastore_destroy (void *obj)
static void	sip_outbound_publish_destroy (void *obj)
	Destructor function for publish information.
static struct ast_sip_outbound_publish_state *	sip_outbound_publish_state_alloc (struct ast_sip_outbound_publish *publish)
	Allocator function for publish client.
static void	sip_outbound_publish_state_destroy (void *obj)
	Destructor function for publish state.
static void	sip_outbound_publish_synchronize (struct ast_sip_event_publisher_handler *removed)
	Helper function which starts or stops publish clients when applicable.
static void	sip_outbound_publish_timer_cb (pj_timer_heap_t *timer_heap, struct pj_timer_entry *entry)
	Publish client timer callback function.
static struct sip_outbound_publisher *	sip_outbound_publisher_alloc (struct ast_sip_outbound_publish_client *client, const char *user)
static void	sip_outbound_publisher_destroy (void *obj)
	Destructor function for publish client.
static int	sip_outbound_publisher_init (void *data)
	Helper function that allocates a pjsip publish client and configures it.
static int	sip_outbound_publisher_reinit (void *obj, void *arg, int flags)
static int	sip_outbound_publisher_reinit_all (void *data)
static int	sip_outbound_publisher_set_uri (pj_pool_t *pool, const char *uri, const char *user, pj_str_t *res_uri)
static int	sip_outbound_publisher_set_uris (pj_pool_t *pool, struct sip_outbound_publisher *publisher, pj_str_t *server_uri, pj_str_t *to_uri, pj_str_t *from_uri)
static struct ast_sip_outbound_publish_state *	sip_publish_state_get (const char *id)
static int	sip_publisher_service_queue (void *data)
static void	stop_publishing (struct ast_sip_outbound_publish_client *client, struct ast_sip_event_publisher_handler *handler)
static void	sub_add_handler (struct ast_sip_event_publisher_handler *handler)
static int	unload_module (void)
static int	validate_publish_config (struct ast_sip_outbound_publish *publish)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "PJSIP Outbound Publish Support" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .reload = reload_module, .unload = unload_module, .load_pri = AST_MODPRI_CHANNEL_DEPEND, .requires = "res_pjproject,res_pjsip", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static ast_rwlock_t	load_lock = AST_RWLOCK_INIT_VALUE
	Used for locking while loading/reloading.
static struct ao2_container *	new_states
	Used on [re]loads to hold new state data.
static int	pjsip_max_url_size = PJSIP_MAX_URL_SIZE
struct publisher_handlers	publisher_handlers = AST_RWLIST_HEAD_INIT_VALUE
static struct ast_serializer_shutdown_group *	shutdown_group

Macro Definition Documentation

ADD_TO_NEW_STATES

#define ADD_TO_NEW_STATES

(

__obj

)

Value:

    do { if (__obj) { \
         ao2_link(new_states, __obj); \
         ao2_ref(__obj, -1); } } while (0)

DATASTORE_BUCKETS

#define DATASTORE_BUCKETS   53

Definition at line 1400 of file res_pjsip_outbound_publish.c.

DEFAULT_PUBLISHER_BUCKETS

#define DEFAULT_PUBLISHER_BUCKETS   119

Definition at line 294 of file res_pjsip_outbound_publish.c.

DEFAULT_STATE_BUCKETS

#define DEFAULT_STATE_BUCKETS   31

Default number of client state container buckets.

Definition at line 305 of file res_pjsip_outbound_publish.c.

DESTROY_CLIENT

#define DESTROY_CLIENT

(

)

Value:

    do {               \
    pjsip_publishc_destroy(publisher->client); \
    publisher->client = NULL; \
    ao2_ref(publisher, -1); } while (0)

MAX_UNLOAD_TIMEOUT_TIME

#define MAX_UNLOAD_TIMEOUT_TIME   35 /* Seconds */

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

Definition at line 299 of file res_pjsip_outbound_publish.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1744 of file res_pjsip_outbound_publish.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1744 of file res_pjsip_outbound_publish.c.

AO2_GLOBAL_OBJ_STATIC()

static AO2_GLOBAL_OBJ_STATIC ( current_states  )

static

AO2_STRING_FIELD_CMP_FN()

AO2_STRING_FIELD_CMP_FN	(	sip_outbound_publisher	,
		user
	)

AO2_STRING_FIELD_HASH_FN()

AO2_STRING_FIELD_HASH_FN	(	sip_outbound_publisher	,
		user
	)

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1744 of file res_pjsip_outbound_publish.c.

ast_sip_publish_client_add_datastore()

int ast_sip_publish_client_add_datastore	(	struct ast_sip_outbound_publish_client *	client,
		struct ast_datastore *	datastore
	)

Add a datastore to a SIP event publisher.

Note that SIP uses reference counted datastores. The datastore passed into this function must have been allocated using ao2_alloc() or there will be serious problems.

Parameters

client	The publication client to add the datastore to
datastore	The datastore to be added to the subscription

Return values

0	Success
-1	Failure

Definition at line 761 of file res_pjsip_outbound_publish.c.

{
    ast_assert(datastore != NULL);
    ast_assert(datastore->info != NULL);
    ast_assert(!ast_strlen_zero(datastore->uid));
 
    if (!ao2_link(client->datastores, datastore)) {
        return -1;
    }
    return 0;
}

References ao2_link, ast_assert, ast_strlen_zero(), ast_sip_outbound_publish_client::datastores, ast_datastore::info, NULL, and ast_datastore::uid.

Referenced by asterisk_start_devicestate_publishing(), and asterisk_start_mwi_publishing().

ast_sip_publish_client_alloc_datastore()

struct ast_datastore * ast_sip_publish_client_alloc_datastore	(	const struct ast_datastore_info *	info,
		const char *	uid
	)

Alternative for ast_datastore_alloc()

There are two major differences between this and ast_datastore_alloc() 1) This allocates a refcounted object 2) This will fill in a uid if one is not provided

DO NOT call ast_datastore_free() on a datastore allocated in this way since that function will attempt to free the datastore rather than play nicely with its refcount.

Parameters

info	Callbacks for datastore
uid	Identifier for datastore

Return values

NULL	Failed to allocate datastore
non-NULL	Newly allocated datastore

Definition at line 731 of file res_pjsip_outbound_publish.c.

{
    RAII_VAR(struct ast_datastore *, datastore, NULL, ao2_cleanup);
    const char *uid_ptr = uid;
    char uuid_buf[AST_UUID_STR_LEN];
 
    if (!info) {
        return NULL;
    }
 
    datastore = ao2_alloc(sizeof(*datastore), sip_outbound_publish_datastore_destroy);
    if (!datastore) {
        return NULL;
    }
 
    datastore->info = info;
    if (ast_strlen_zero(uid)) {
        /* They didn't provide an ID so we'll provide one ourself */
        uid_ptr = ast_uuid_generate_str(uuid_buf, sizeof(uuid_buf));
    }
 
    datastore->uid = ast_strdup(uid_ptr);
    if (!datastore->uid) {
        return NULL;
    }
 
    ao2_ref(datastore, +1);
    return datastore;
}

References ao2_alloc, ao2_cleanup, ao2_ref, ast_strdup, ast_strlen_zero(), ast_uuid_generate_str(), AST_UUID_STR_LEN, ast_datastore::info, NULL, RAII_VAR, sip_outbound_publish_datastore_destroy(), and ast_datastore::uid.

Referenced by asterisk_start_devicestate_publishing(), and asterisk_start_mwi_publishing().

ast_sip_publish_client_get()

struct ast_sip_outbound_publish_client * ast_sip_publish_client_get

(

const char *

name

)

Find a publish client using its name.

Parameters

name	The name of the publish client

Return values

NULL	failure
non-NULL	success

Note

The publish client is returned with its reference count increased and must be released using ao2_cleanup.

Definition at line 565 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_outbound_publish_state *state = sip_publish_state_get(name);
 
    if (!state) {
        return NULL;
    }
 
    ao2_ref(state->client, +1);
    ao2_ref(state, -1);
    return state->client;
}

References ao2_ref, name, NULL, and sip_publish_state_get().

Referenced by asterisk_publication_devicestate_refresh(), asterisk_publication_mwi_refresh(), and send_refresh_cb().

ast_sip_publish_client_get_datastore()

struct ast_datastore * ast_sip_publish_client_get_datastore	(	struct ast_sip_outbound_publish_client *	client,
		const char *	name
	)

Retrieve an event publisher datastore.

The datastore retrieved will have its reference count incremented. When the caller is done with the datastore, the reference counted needs to be decremented using ao2_ref().

Parameters

client	The publication client from which to retrieve the datastore
name	The name of the datastore to retrieve

Return values

NULL	Failed to find the specified datastore
non-NULL	The specified datastore

Definition at line 774 of file res_pjsip_outbound_publish.c.

{
    return ao2_find(client->datastores, name, OBJ_SEARCH_KEY);
}

References ao2_find, ast_sip_outbound_publish_client::datastores, name, and OBJ_SEARCH_KEY.

Referenced by asterisk_publication_devicestate_refresh(), asterisk_publication_mwi_refresh(), asterisk_stop_devicestate_publishing(), and asterisk_stop_mwi_publishing().

ast_sip_publish_client_get_from_uri()

const char * ast_sip_publish_client_get_from_uri

(

struct ast_sip_outbound_publish_client *

client

)

Get the From URI the client will use.

Since

14.0.0

Parameters

client

The publication client to get the From URI

Return values

From-uri	on success
Empty-string	on failure

Definition at line 578 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_outbound_publish *publish = client->publish;
 
    return S_OR(publish->from_uri, S_OR(publish->server_uri, ""));
}

References publish, ast_sip_outbound_publish_client::publish, and S_OR.

ast_sip_publish_client_get_to_uri()

const char * ast_sip_publish_client_get_to_uri

(

struct ast_sip_outbound_publish_client *

client

)

Get the To URI the client will use.

Since

14.0.0

Parameters

client

The publication client to get the To URI

Return values

From-uri	on success
Empty-string	on failure

Definition at line 628 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_outbound_publish *publish = client->publish;
 
    return S_OR(publish->to_uri, S_OR(publish->server_uri, ""));
}

References publish, ast_sip_outbound_publish_client::publish, and S_OR.

ast_sip_publish_client_get_user_from_uri()

const char * ast_sip_publish_client_get_user_from_uri	(	struct ast_sip_outbound_publish_client *	client,
		const char *	user,
		char *	uri,
		size_t	size
	)

Get the From URI the client will use for a specific user.

Since

14.0.0

Parameters

client	The publication client to get the From URI of a user
user	The user to retrieve the From URI for
uri	A buffer to place the URI into
size	The size of the buffer

Return values

From-uri	on success
Empty-string	on failure

Definition at line 612 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher;
 
    publisher = sip_outbound_publish_client_get_publisher(client, user);
    if (!publisher) {
        return NULL;
    }
 
    ast_copy_string(uri, publisher->from_uri, size);
    ao2_ref(publisher, -1);
 
    return uri;
}

References ao2_ref, ast_copy_string(), sip_outbound_publisher::client, sip_outbound_publisher::from_uri, NULL, and sip_outbound_publish_client_get_publisher().

Referenced by exten_state_publisher_cb().

ast_sip_publish_client_get_user_to_uri()

const char * ast_sip_publish_client_get_user_to_uri	(	struct ast_sip_outbound_publish_client *	client,
		const char *	user,
		char *	uri,
		size_t	size
	)

Get the To URI the client will use for a specific user.

Since

14.0.0

Parameters

client	The publication client to get the To URI of a user
user	The user to retrieve the To URI for
uri	A buffer to place the URI into
size	The size of the buffer

Return values

To-uri	on success
Empty-string	on failure

Definition at line 635 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher;
 
    publisher = sip_outbound_publish_client_get_publisher(client, user);
    if (!publisher) {
        return NULL;
    }
 
    ast_copy_string(uri, publisher->to_uri, size);
    ao2_ref(publisher, -1);
 
    return uri;
}

References ao2_ref, ast_copy_string(), sip_outbound_publisher::client, NULL, sip_outbound_publish_client_get_publisher(), and sip_outbound_publisher::to_uri.

Referenced by exten_state_publisher_cb().

ast_sip_publish_client_remove()

void ast_sip_publish_client_remove	(	struct ast_sip_outbound_publish_client *	client,
		const char *	user
	)

Remove the user from the client (stopping it from publishing)

Parameters

client	The publication client
user	The user to remove

Definition at line 1162 of file res_pjsip_outbound_publish.c.

{
    SCOPED_WRLOCK(lock, &load_lock);
    ao2_find(client->publishers, user, OBJ_SEARCH_KEY | OBJ_UNLINK | OBJ_NODATA);
}

References ao2_find, sip_outbound_publisher::client, load_lock, lock, OBJ_NODATA, OBJ_SEARCH_KEY, OBJ_UNLINK, and SCOPED_WRLOCK.

ast_sip_publish_client_remove_datastore()

void ast_sip_publish_client_remove_datastore	(	struct ast_sip_outbound_publish_client *	client,
		const char *	name
	)

Remove a publication datastore from an event publisher.

This operation may cause the datastore's free() callback to be called if the reference count reaches zero.

Parameters

client	The publication client to remove the datastore from
name	The name of the datastore to remove

Definition at line 780 of file res_pjsip_outbound_publish.c.

{
    ao2_find(client->datastores, name, OBJ_SEARCH_KEY | OBJ_UNLINK | OBJ_NODATA);
}

References ao2_find, ast_sip_outbound_publish_client::datastores, name, OBJ_NODATA, OBJ_SEARCH_KEY, and OBJ_UNLINK.

Referenced by asterisk_start_devicestate_publishing(), asterisk_start_mwi_publishing(), asterisk_stop_devicestate_publishing(), and asterisk_stop_mwi_publishing().

ast_sip_publish_client_send()

int ast_sip_publish_client_send	(	struct ast_sip_outbound_publish_client *	client,
		const struct ast_sip_body *	body
	)

Send an outgoing PUBLISH message using a client.

Parameters

client	The publication client to send from
body	An optional body to add to the PUBLISH

Return values

-1	failure
0	success

Definition at line 879 of file res_pjsip_outbound_publish.c.

{
    SCOPED_AO2LOCK(lock, client);
    int res = 0;
 
    ao2_callback_data(client->publishers, OBJ_NODATA,
              publisher_client_send, (void *)body, &res);
    return res;
}

References ao2_callback_data, sip_outbound_publish_message::body, lock, OBJ_NODATA, publisher_client_send(), ast_sip_outbound_publish_client::publishers, and SCOPED_AO2LOCK.

Referenced by asterisk_publisher_devstate_cb(), asterisk_publisher_mwistate_cb(), and send_refresh_cb().

ast_sip_publish_client_user_send()

int ast_sip_publish_client_user_send	(	struct ast_sip_outbound_publish_client *	client,
		const char *	user,
		const struct ast_sip_body *	body
	)

Send an outgoing PUBLISH message based on the user.

Parameters

client	The publication client to send from
user	The user to send to
body	An optional body to add to the PUBLISH

Return values

-1	failure
0	success

Definition at line 1146 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher;
    int res;
 
    publisher = sip_outbound_publish_client_get_publisher(client, user);
    if (!publisher) {
        return -1;
    }
 
    publisher_client_send(publisher, (void *)body, &res, 0);
    ao2_ref(publisher, -1);
    return res;
}

References ao2_ref, sip_outbound_publisher::client, publisher_client_send(), and sip_outbound_publish_client_get_publisher().

Referenced by exten_state_publisher_cb().

ast_sip_register_event_publisher_handler()

int ast_sip_register_event_publisher_handler

(

struct ast_sip_event_publisher_handler *

handler

)

Register an event publisher handler.

Return values

0	Handler was registered successfully
non-zero	Handler was not registered successfully

Definition at line 651 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_event_publisher_handler *existing;
    SCOPED_LOCK(lock, &publisher_handlers, AST_RWLIST_WRLOCK, AST_RWLIST_UNLOCK);
 
    if (!handler->start_publishing || !handler->stop_publishing) {
        ast_log(LOG_ERROR, "Handler does not implement required callbacks. Cannot register\n");
        return -1;
    } else if (ast_strlen_zero(handler->event_name)) {
        ast_log(LOG_ERROR, "No event package specified for event publisher handler. Cannot register\n");
        return -1;
    }
 
    existing = find_publisher_handler_for_event_name(handler->event_name);
    if (existing) {
        ast_log(LOG_ERROR, "Unable to register event publisher handler for event %s. "
                "A handler is already registered\n", handler->event_name);
        return -1;
    }
 
    sub_add_handler(handler);
 
    sip_outbound_publish_synchronize(NULL);
 
    return 0;
}

References ast_log, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_strlen_zero(), find_publisher_handler_for_event_name(), handler(), lock, LOG_ERROR, NULL, SCOPED_LOCK, sip_outbound_publish_synchronize(), and sub_add_handler().

Referenced by load_module(), and load_module().

ast_sip_unregister_event_publisher_handler()

void ast_sip_unregister_event_publisher_handler

(

struct ast_sip_event_publisher_handler *

handler

)

Unregister a publish handler.

Definition at line 678 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_event_publisher_handler *iter;
    SCOPED_LOCK(lock, &publisher_handlers, AST_RWLIST_WRLOCK, AST_RWLIST_UNLOCK);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&publisher_handlers, iter, next) {
        if (handler == iter) {
            AST_RWLIST_REMOVE_CURRENT(next);
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
 
    sip_outbound_publish_synchronize(handler);
}

References AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, handler(), lock, ast_sip_event_publisher_handler::next, SCOPED_LOCK, and sip_outbound_publish_synchronize().

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

can_reuse_publish()

static int can_reuse_publish ( struct ast_sip_outbound_publish *  existing, struct ast_sip_outbound_publish *  applied  )

static

Definition at line 1276 of file res_pjsip_outbound_publish.c.

{
    int i;
 
    if (strcmp(existing->server_uri, applied->server_uri) || strcmp(existing->from_uri, applied->from_uri) ||
        strcmp(existing->to_uri, applied->to_uri) || strcmp(existing->outbound_proxy, applied->outbound_proxy) ||
        strcmp(existing->event, applied->event) ||
        AST_VECTOR_SIZE(&existing->outbound_auths) != AST_VECTOR_SIZE(&applied->outbound_auths)) {
        return 0;
    }
 
    for (i = 0; i < AST_VECTOR_SIZE(&existing->outbound_auths); ++i) {
        if (strcmp(AST_VECTOR_GET(&existing->outbound_auths, i), AST_VECTOR_GET(&applied->outbound_auths, i))) {
            return 0;
        }
    }
 
    return 1;
}

References AST_VECTOR_GET, AST_VECTOR_SIZE, ast_sip_outbound_publish::event, ast_sip_outbound_publish::from_uri, ast_sip_outbound_publish::outbound_auths, ast_sip_outbound_publish::outbound_proxy, ast_sip_outbound_publish::server_uri, and ast_sip_outbound_publish::to_uri.

Referenced by current_state_reusable().

cancel_and_unpublish()

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

static

Helper function which cancels and un-publishes a no longer used client.

Definition at line 1189 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher = obj;
    struct ast_sip_outbound_publish_client *client = publisher->owner;
 
    SCOPED_AO2LOCK(lock, publisher);
 
    if (!client->started) {
        /* If the publisher was never started, there's nothing to unpublish, so just
         * destroy the publication and remove its reference to the publisher.
         */
        if (ast_sip_push_task(publisher->serializer, explicit_publish_destroy, ao2_bump(publisher))) {
            ao2_ref(publisher, -1);
        }
        return 0;
    }
 
    if (ast_sip_push_task(publisher->serializer, cancel_refresh_timer_task, ao2_bump(publisher))) {
        ast_log(LOG_WARNING, "Could not stop refresh timer on outbound publish '%s'\n",
            ast_sorcery_object_get_id(client->publish));
        ao2_ref(publisher, -1);
    }
 
    /* If nothing is being sent right now send the unpublish - the destroy will happen in the subsequent callback */
    if (!publisher->sending) {
        if (ast_sip_push_task(publisher->serializer, send_unpublish_task, ao2_bump(publisher))) {
            ast_log(LOG_WARNING, "Could not send unpublish message on outbound publish '%s'\n",
                ast_sorcery_object_get_id(client->publish));
            ao2_ref(publisher, -1);
        }
    }
    publisher->destroy = 1;
    return 0;
}

References ao2_bump, ao2_ref, ast_log, ast_sip_push_task, ast_sorcery_object_get_id(), cancel_refresh_timer_task(), sip_outbound_publisher::destroy, explicit_publish_destroy(), lock, LOG_WARNING, sip_outbound_publisher::owner, ast_sip_outbound_publish_client::publish, SCOPED_AO2LOCK, send_unpublish_task(), sip_outbound_publisher::sending, sip_outbound_publisher::serializer, and ast_sip_outbound_publish_client::started.

Referenced by sip_outbound_publish_state_destroy(), and sip_outbound_publish_synchronize().

cancel_publish_refresh()

static void cancel_publish_refresh ( struct sip_outbound_publisher *  publisher )

static

Helper function which cancels the refresh timer on a publisher.

Definition at line 400 of file res_pjsip_outbound_publish.c.

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

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

Referenced by cancel_refresh_timer_task(), and schedule_publish_refresh().

cancel_refresh_timer_task()

static int cancel_refresh_timer_task ( void *  data )

static

Task for cancelling a refresh timer.

Definition at line 454 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher = data;
 
    cancel_publish_refresh(publisher);
    ao2_ref(publisher, -1);
 
    return 0;
}

References ao2_ref, and cancel_publish_refresh().

Referenced by cancel_and_unpublish(), and sip_outbound_publish_client_add_publisher().

current_state_reusable()

static int current_state_reusable ( struct ast_sip_outbound_publish *  publish, struct ast_sip_outbound_publish_state *  current_state  )

static

Definition at line 1529 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_outbound_publish *old_publish;
 
    /*
     * Don't maintain the old state/client objects if the multi_user option changed.
     */
    if ((!publish->multi_user && current_state->client->publish->multi_user) ||
        (publish->multi_user && !current_state->client->publish->multi_user)) {
        return 0;
    }
 
 
    if (!can_reuse_publish(current_state->client->publish, publish)) {
        /*
         * Something significant has changed in the configuration, so we are
         * unable to use the old state object. The current state needs to go
         * away and a new one needs to be created.
         */
        return 0;
    }
 
    /*
     * We can reuse the current state object so keep it, but swap out the
     * underlying publish object with the new one.
     */
    old_publish = current_state->client->publish;
    current_state->client->publish = publish;
    if (ast_sip_push_task_wait_servant(NULL, sip_outbound_publisher_reinit_all,
        current_state->client->publishers)) {
        /*
         * If the state object fails to re-initialize then swap
         * the old publish info back in.
         */
        current_state->client->publish = publish;
        ast_log(LOG_ERROR, "Unable to reinitialize client(s) for outbound publish '%s'\n",
            ast_sorcery_object_get_id(current_state->client->publish));
        return -1;
    }
 
    /*
     * Since we swapped out the publish object the new one needs a ref
     * while the old one needs to go away.
     */
    ao2_ref(current_state->client->publish, +1);
    ao2_cleanup(old_publish);
 
    /* Tell the caller that the current state object should be used */
    return 1;
}

References ao2_cleanup, ao2_ref, ast_log, ast_sip_push_task_wait_servant, ast_sorcery_object_get_id(), can_reuse_publish(), ast_sip_outbound_publish_state::client, LOG_ERROR, ast_sip_outbound_publish::multi_user, NULL, publish, ast_sip_outbound_publish_client::publish, ast_sip_outbound_publish_client::publishers, and sip_outbound_publisher_reinit_all().

Referenced by sip_outbound_publish_apply().

datastore_cmp()

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

static

Definition at line 1424 of file res_pjsip_outbound_publish.c.

{
    const struct ast_datastore *object_left = obj;
    const struct ast_datastore *object_right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = object_right->uid;
        /* Fall through */
    case OBJ_SEARCH_KEY:
        cmp = strcmp(object_left->uid, right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        cmp = strncmp(object_left->uid, right_key, strlen(right_key));
        break;
    default:
        /*
         * What arg points to is specific to this traversal callback
         * and has no special meaning to astobj2.
         */
        cmp = 0;
        break;
    }
    if (cmp) {
        return 0;
    }
    /*
     * At this point the traversal callback is identical to a sorted
     * container.
     */
    return CMP_MATCH;
}

References CMP_MATCH, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, and ast_datastore::uid.

Referenced by sip_outbound_publish_state_alloc().

datastore_hash()

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

static

Definition at line 1402 of file res_pjsip_outbound_publish.c.

{
    const struct ast_datastore *datastore;
    const char *uid;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_KEY:
        uid = obj;
        break;
    case OBJ_SEARCH_OBJECT:
        datastore = obj;
        uid = datastore->uid;
        break;
    default:
        /* Hash can only work on something with a full key. */
        ast_assert(0);
        return 0;
    }
 
    return ast_str_hash(uid);
}

References ast_assert, ast_str_hash(), OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and ast_datastore::uid.

Referenced by sip_outbound_publish_state_alloc().

explicit_publish_destroy()

static int explicit_publish_destroy ( void *  data )

static

Definition at line 1169 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher = data;
 
    /*
     * If there is no pjsip publishing client then we obviously don't need
     * to destroy it. Also, the ref for the Asterisk publishing client that
     * pjsip had would not exist or should already be gone as well.
     */
    if (publisher->client) {
        pjsip_publishc_destroy(publisher->client);
        ao2_ref(publisher, -1);
    }
 
    ao2_ref(publisher, -1);
 
    return 0;
}

References ao2_ref, and sip_outbound_publisher::client.

Referenced by cancel_and_unpublish().

find_publisher_handler_for_event_name()

static struct ast_sip_event_publisher_handler * find_publisher_handler_for_event_name ( const char *  event_name )

static

Definition at line 387 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_event_publisher_handler *iter;
 
    AST_RWLIST_TRAVERSE(&publisher_handlers, iter, next) {
        if (!strcmp(iter->event_name, event_name)) {
            break;
        }
    }
    return iter;
}

References AST_RWLIST_TRAVERSE, ast_sip_event_publisher_handler::event_name, and ast_sip_event_publisher_handler::next.

Referenced by ast_sip_register_event_publisher_handler(), sip_outbound_publish_synchronize(), and stop_publishing().

get_publishes_and_update_state()

static struct ao2_container * get_publishes_and_update_state ( void  )

static

Definition at line 360 of file res_pjsip_outbound_publish.c.

{
    struct ao2_container *container;
    SCOPED_WRLOCK(lock, &load_lock);
 
    container = ast_sorcery_retrieve_by_fields(
        ast_sip_get_sorcery(), "outbound-publish",
        AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
 
    if (!new_states) {
        return container;
    }
 
    ao2_global_obj_replace_unref(current_states, new_states);
    ao2_cleanup(new_states);
    new_states = NULL;
 
    return container;
}

References ao2_cleanup, ao2_global_obj_replace_unref, AST_RETRIEVE_FLAG_ALL, AST_RETRIEVE_FLAG_MULTIPLE, ast_sip_get_sorcery(), ast_sorcery_retrieve_by_fields(), container, load_lock, lock, new_states, NULL, and SCOPED_WRLOCK.

Referenced by sip_outbound_publish_synchronize().

load_module()

static int load_module ( void  )

static

Definition at line 1684 of file res_pjsip_outbound_publish.c.

{
    /* As of pjproject 2.4.5, PJSIP_MAX_URL_SIZE isn't exposed yet but we try anyway. */
    ast_pjproject_get_buildopt("PJSIP_MAX_URL_SIZE", "%d", &pjsip_max_url_size);
 
    shutdown_group = ast_serializer_shutdown_group_alloc();
    if (!shutdown_group) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    ast_sorcery_apply_config(ast_sip_get_sorcery(), "res_pjsip_outbound_publish");
    ast_sorcery_apply_default(ast_sip_get_sorcery(), "outbound-publish", "config", "pjsip.conf,criteria=type=outbound-publish");
 
    if (ast_sorcery_object_register(ast_sip_get_sorcery(), "outbound-publish", sip_outbound_publish_alloc, NULL,
        sip_outbound_publish_apply)) {
        ast_log(LOG_ERROR, "Unable to register 'outbound-publish' type with sorcery\n");
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "outbound-publish", "type", "", OPT_NOOP_T, 0, 0);
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "outbound-publish", "server_uri", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_outbound_publish, server_uri));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "outbound-publish", "from_uri", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_outbound_publish, from_uri));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "outbound-publish", "event", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_outbound_publish, event));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "outbound-publish", "to_uri", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_outbound_publish, to_uri));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "outbound-publish", "outbound_proxy", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_outbound_publish, outbound_proxy));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "outbound-publish", "expiration", "3600", OPT_UINT_T, 0, FLDSET(struct ast_sip_outbound_publish, expiration));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "outbound-publish", "max_auth_attempts", "5", OPT_UINT_T, 0, FLDSET(struct ast_sip_outbound_publish, max_auth_attempts));
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "outbound-publish", "transport", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_outbound_publish, transport));
    ast_sorcery_object_field_register_custom(ast_sip_get_sorcery(), "outbound-publish", "outbound_auth", "", outbound_auth_handler, NULL, NULL, 0, 0);
    ast_sorcery_object_field_register(ast_sip_get_sorcery(), "outbound-publish", "multi_user", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_outbound_publish, multi_user));
 
    ast_sorcery_reload_object(ast_sip_get_sorcery(), "outbound-publish");
 
    AST_RWLIST_RDLOCK(&publisher_handlers);
    sip_outbound_publish_synchronize(NULL);
    AST_RWLIST_UNLOCK(&publisher_handlers);
 
    pjsip_publishc_init_module(ast_sip_get_pjsip_endpoint());
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ast_log, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_pjproject_get_buildopt(), AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_serializer_shutdown_group_alloc(), ast_sip_get_pjsip_endpoint(), ast_sip_get_sorcery(), ast_sorcery_apply_config, ast_sorcery_apply_default, ast_sorcery_object_field_register, ast_sorcery_object_field_register_custom, ast_sorcery_object_register, ast_sorcery_reload_object(), ast_sip_outbound_publish::expiration, FLDSET, ast_sip_outbound_publish::from_uri, LOG_ERROR, ast_sip_outbound_publish::max_auth_attempts, ast_sip_outbound_publish::multi_user, NULL, OPT_BOOL_T, OPT_NOOP_T, OPT_STRINGFIELD_T, OPT_UINT_T, outbound_auth_handler(), ast_sip_outbound_publish::outbound_proxy, pjsip_max_url_size, server_uri, shutdown_group, sip_outbound_publish_alloc(), sip_outbound_publish_apply(), sip_outbound_publish_synchronize(), STRFLDSET, ast_sip_outbound_publish::to_uri, ast_sip_outbound_publish::transport, and unload_module().

outbound_auth_handler()

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

static

Definition at line 1651 of file res_pjsip_outbound_publish.c.

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

References ast_sip_auth_vector_init(), publish, and var.

Referenced by load_module().

outbound_publish_state_cmp()

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

static

comparator function for client objects

Definition at line 332 of file res_pjsip_outbound_publish.c.

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

References ast_assert, CMP_MATCH, ast_sip_outbound_publish_state::id, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and OBJ_SEARCH_PARTIAL_KEY.

Referenced by sip_outbound_publish_apply().

outbound_publish_state_hash()

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

static

hashing function for state objects

Definition at line 311 of file res_pjsip_outbound_publish.c.

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

References ast_assert, ast_str_hash(), ast_sip_outbound_publish_state::id, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, and OBJ_SEARCH_OBJECT.

Referenced by sip_outbound_publish_apply().

publisher_client_send()

static int publisher_client_send ( void *  obj, void *  arg, void *  data, int  flags  )

static

Definition at line 833 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher = obj;
    const struct ast_sip_body *body = arg;
    struct sip_outbound_publish_message *message;
    size_t type_len = 0, subtype_len = 0, body_text_len = 0;
    int *res = data;
    SCOPED_AO2LOCK(lock, publisher);
 
    *res = -1;
    if (!publisher->client) {
        return -1;
    }
 
    /* If a body is present we need more space for the contents of it */
    if (body) {
        type_len = strlen(body->type) + 1;
        subtype_len = strlen(body->subtype) + 1;
        body_text_len = strlen(body->body_text) + 1;
    }
 
    message = ast_calloc(1, sizeof(*message) + type_len + subtype_len + body_text_len);
    if (!message) {
        return -1;
    }
 
    if (body) {
        char *dst = message->body_contents;
 
        message->body.type = strcpy(dst, body->type);
        dst += type_len;
        message->body.subtype = strcpy(dst, body->subtype);
        dst += subtype_len;
        message->body.body_text = strcpy(dst, body->body_text);
    }
 
    AST_LIST_INSERT_TAIL(&publisher->queue, message, entry);
 
    *res = ast_sip_push_task(publisher->serializer, sip_publisher_service_queue, ao2_bump(publisher));
    if (*res) {
        ao2_ref(publisher, -1);
    }
 
    return *res;
}

References ao2_bump, ao2_ref, ast_calloc, AST_LIST_INSERT_TAIL, ast_sip_push_task, sip_outbound_publish_message::body, ast_sip_body::body_text, sip_outbound_publisher::client, sip_outbound_publish_message::entry, lock, sip_outbound_publisher::queue, SCOPED_AO2LOCK, sip_outbound_publisher::serializer, sip_publisher_service_queue(), ast_sip_body::subtype, and ast_sip_body::type.

Referenced by ast_sip_publish_client_send(), ast_sip_publish_client_user_send(), and sip_outbound_publish_timer_cb().

reload_module()

static int reload_module ( void  )

static

Definition at line 1727 of file res_pjsip_outbound_publish.c.

{
    ast_sorcery_reload_object(ast_sip_get_sorcery(), "outbound-publish");
 
    AST_RWLIST_RDLOCK(&publisher_handlers);
    sip_outbound_publish_synchronize(NULL);
    AST_RWLIST_UNLOCK(&publisher_handlers);
    return 0;
}

References AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_sip_get_sorcery(), ast_sorcery_reload_object(), NULL, and sip_outbound_publish_synchronize().

schedule_publish_refresh()

static void schedule_publish_refresh ( struct sip_outbound_publisher *  publisher, int  expiration  )

static

Helper function which sets up the timer to send publication.

Definition at line 410 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_outbound_publish *publish = ao2_bump(publisher->owner->publish);
    pj_time_val delay = { .sec = 0, };
 
    cancel_publish_refresh(publisher);
 
    if (expiration > 0) {
        delay.sec = expiration - PJSIP_PUBLISHC_DELAY_BEFORE_REFRESH;
    }
    if (publish->expiration && ((delay.sec > publish->expiration) || !delay.sec)) {
        delay.sec = publish->expiration;
    }
    if (delay.sec < PJSIP_PUBLISHC_DELAY_BEFORE_REFRESH) {
        delay.sec = PJSIP_PUBLISHC_DELAY_BEFORE_REFRESH;
    }
 
    ao2_ref(publisher, +1);
    if (pjsip_endpt_schedule_timer(ast_sip_get_pjsip_endpoint(), &publisher->timer, &delay) != PJ_SUCCESS) {
        ast_log(LOG_WARNING, "Failed to pass timed publish refresh to scheduler\n");
        ao2_ref(publisher, -1);
    }
    ao2_ref(publish, -1);
}

References ao2_bump, ao2_ref, ast_log, ast_sip_get_pjsip_endpoint(), cancel_publish_refresh(), ast_sip_outbound_publish::expiration, LOG_WARNING, sip_outbound_publisher::owner, publish, ast_sip_outbound_publish_client::publish, and sip_outbound_publisher::timer.

Referenced by sip_outbound_publish_callback().

send_unpublish_task()

static int send_unpublish_task ( void *  data )

static

Task for sending an unpublish.

Definition at line 477 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher = data;
    pjsip_tx_data *tdata;
 
    if (pjsip_publishc_unpublish(publisher->client, &tdata) == PJ_SUCCESS) {
        set_transport(publisher, tdata);
        pjsip_publishc_send(publisher->client, tdata);
    }
 
    ao2_ref(publisher, -1);
 
    return 0;
}

References ao2_ref, sip_outbound_publisher::client, and set_transport().

Referenced by cancel_and_unpublish(), and sip_outbound_publish_callback().

set_transport()

static void set_transport ( struct sip_outbound_publisher *  publisher, pjsip_tx_data *  tdata  )

static

Definition at line 464 of file res_pjsip_outbound_publish.c.

{
    if (!ast_strlen_zero(publisher->owner->publish->transport)) {
        pjsip_tpselector selector = { .type = PJSIP_TPSELECTOR_NONE, };
 
        ast_sip_set_tpselector_from_transport_name(
            publisher->owner->publish->transport, &selector);
        pjsip_tx_data_set_transport(tdata, &selector);
        ast_sip_tpselector_unref(&selector);
    }
}

References ast_sip_set_tpselector_from_transport_name(), ast_sip_tpselector_unref(), ast_strlen_zero(), sip_outbound_publisher::owner, ast_sip_outbound_publish_client::publish, and ast_sip_outbound_publish::transport.

Referenced by send_unpublish_task(), sip_outbound_publish_callback(), and sip_publisher_service_queue().

sip_outbound_publish_alloc()

static void * sip_outbound_publish_alloc ( const char *  name )

static

Allocator function for publish information.

Definition at line 704 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_outbound_publish *publish = ast_sorcery_generic_alloc(sizeof(*publish),
        sip_outbound_publish_destroy);
 
    if (!publish || ast_string_field_init(publish, 256)) {
        ao2_cleanup(publish);
        return NULL;
    }
 
    return publish;
}

References ao2_cleanup, ast_sorcery_generic_alloc(), ast_string_field_init, NULL, publish, and sip_outbound_publish_destroy().

Referenced by load_module().

sip_outbound_publish_apply()

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

static

Apply function which finds or allocates a state structure.

Definition at line 1582 of file res_pjsip_outbound_publish.c.

{
#define ADD_TO_NEW_STATES(__obj) \
    do { if (__obj) { \
         ao2_link(new_states, __obj); \
         ao2_ref(__obj, -1); } } while (0)
 
    struct ast_sip_outbound_publish *applied = obj;
    struct ast_sip_outbound_publish_state *current_state, *new_state;
    struct sip_outbound_publisher *publisher = NULL;
    int res;
 
    /*
     * New states are being loaded or reloaded. We'll need to add the new
     * object if created/updated, or keep the old object if an error occurs.
     */
    if (!new_states) {
        new_states = ao2_container_alloc_hash(
            AO2_ALLOC_OPT_LOCK_NOLOCK, 0, DEFAULT_STATE_BUCKETS,
            outbound_publish_state_hash, NULL, outbound_publish_state_cmp);
 
        if (!new_states) {
            ast_log(LOG_ERROR, "Unable to allocate new states container\n");
            return -1;
        }
    }
 
    /* If there is current state we'll want to maintain it if any errors occur */
    current_state = sip_publish_state_get(ast_sorcery_object_get_id(applied));
 
    if ((res = validate_publish_config(applied))) {
        ADD_TO_NEW_STATES(current_state);
        return res;
    }
 
    if (current_state && (res = current_state_reusable(applied, current_state))) {
        /*
         * The current state object was able to be reused, or an error
         * occurred. Either way we keep the current state and be done.
         */
        ADD_TO_NEW_STATES(current_state);
        return res == 1 ? 0 : -1;
    }
 
    /*
     * No current state was found or it was unable to be reused. Either way
     * we'll need to create a new state object.
     */
    new_state = sip_outbound_publish_state_alloc(applied);
    if (!new_state) {
        ast_log(LOG_ERROR, "Unable to create state for outbound publish '%s'\n",
            ast_sorcery_object_get_id(applied));
        ADD_TO_NEW_STATES(current_state);
        return -1;
    };
 
    if (!applied->multi_user &&
        !(publisher = sip_outbound_publish_client_add_publisher(new_state->client, NULL))) {
        ADD_TO_NEW_STATES(current_state);
        ao2_ref(new_state, -1);
        return -1;
    }
    ao2_cleanup(publisher);
 
    ADD_TO_NEW_STATES(new_state);
    ao2_cleanup(current_state);
    return res;
}

References ADD_TO_NEW_STATES, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_cleanup, ao2_container_alloc_hash, ao2_ref, ast_log, ast_sorcery_object_get_id(), ast_sip_outbound_publish_state::client, current_state_reusable(), DEFAULT_STATE_BUCKETS, LOG_ERROR, ast_sip_outbound_publish::multi_user, new_states, NULL, outbound_publish_state_cmp(), outbound_publish_state_hash(), sip_outbound_publish_client_add_publisher(), sip_outbound_publish_state_alloc(), sip_publish_state_get(), and validate_publish_config().

Referenced by load_module().

sip_outbound_publish_callback()

static void sip_outbound_publish_callback ( struct pjsip_publishc_cbparam *  param )

static

Callback function for publish client responses.

Definition at line 1297 of file res_pjsip_outbound_publish.c.

{
#define DESTROY_CLIENT() do {              \
    pjsip_publishc_destroy(publisher->client); \
    publisher->client = NULL; \
    ao2_ref(publisher, -1); } while (0)
 
    RAII_VAR(struct sip_outbound_publisher *, publisher, ao2_bump(param->token), ao2_cleanup);
    RAII_VAR(struct ast_sip_outbound_publish *, publish, ao2_bump(publisher->owner->publish), ao2_cleanup);
    SCOPED_AO2LOCK(lock, publisher);
    pjsip_tx_data *tdata;
 
    if (publisher->destroy) {
        if (publisher->sending) {
            publisher->sending = NULL;
 
            if (!ast_sip_push_task(publisher->serializer, send_unpublish_task, ao2_bump(publisher))) {
                return;
            }
            ast_log(LOG_WARNING, "Could not send unpublish message on outbound publish '%s'\n",
                ast_sorcery_object_get_id(publish));
            ao2_ref(publisher, -1);
        }
        /* Once the destroy is called this callback will not get called any longer, so drop the publisher ref */
        DESTROY_CLIENT();
        return;
    }
 
    if (param->code == 401 || param->code == 407) {
        pjsip_transaction *tsx = pjsip_rdata_get_tsx(param->rdata);
 
        if (!ast_sip_create_request_with_auth(&publish->outbound_auths,
                param->rdata, tsx->last_tx, &tdata)) {
            set_transport(publisher, tdata);
            pjsip_publishc_send(publisher->client, tdata);
        }
        publisher->auth_attempts++;
 
        if (publisher->auth_attempts == publish->max_auth_attempts) {
            DESTROY_CLIENT();
            ast_log(LOG_ERROR, "Reached maximum number of PUBLISH authentication attempts on outbound publish '%s'\n",
                ast_sorcery_object_get_id(publish));
 
            goto end;
        }
        return;
    }
 
    publisher->auth_attempts = 0;
 
    if (param->code == 412) {
        DESTROY_CLIENT();
        if (sip_outbound_publisher_init(publisher)) {
            ast_log(LOG_ERROR, "Failed to create a new outbound publish client for '%s' on 412 response\n",
                ast_sorcery_object_get_id(publish));
            goto end;
        }
 
        /* Setting this to NULL will cause a new PUBLISH to get created and sent for the same underlying body */
        publisher->sending = NULL;
    } else if (param->code == 423) {
        /* Update the expiration with the new expiration time if available */
        pjsip_expires_hdr *expires;
 
        expires = pjsip_msg_find_hdr(param->rdata->msg_info.msg, PJSIP_H_MIN_EXPIRES, NULL);
        if (!expires || !expires->ivalue) {
            DESTROY_CLIENT();
            ast_log(LOG_ERROR, "Received 423 response on outbound publish '%s' without a Min-Expires header\n",
                ast_sorcery_object_get_id(publish));
            goto end;
        }
 
        pjsip_publishc_update_expires(publisher->client, expires->ivalue);
        publisher->sending = NULL;
    } else if (publisher->sending) {
        /* Remove the message currently being sent so that when the queue is serviced another will get sent */
        AST_LIST_REMOVE_HEAD(&publisher->queue, entry);
        ast_free(publisher->sending);
        publisher->sending = NULL;
        if (!param->rdata) {
            ast_log(LOG_NOTICE, "No response received for outbound publish '%s'\n",
                ast_sorcery_object_get_id(publish));
        }
    }
 
    if (AST_LIST_EMPTY(&publisher->queue)) {
        schedule_publish_refresh(publisher, param->expiration);
    }
 
end:
    if (!publisher->client) {
        struct sip_outbound_publish_message *message;
 
        while ((message = AST_LIST_REMOVE_HEAD(&publisher->queue, entry))) {
            ast_free(message);
        }
    } else {
        if (ast_sip_push_task(publisher->serializer, sip_publisher_service_queue, ao2_bump(publisher))) {
            ao2_ref(publisher, -1);
        }
    }
}

References ao2_bump, ao2_cleanup, ao2_ref, ast_free, AST_LIST_EMPTY, AST_LIST_REMOVE_HEAD, ast_log, ast_sip_create_request_with_auth(), ast_sip_push_task, ast_sorcery_object_get_id(), DESTROY_CLIENT, end, sip_outbound_publish_message::entry, lock, LOG_ERROR, LOG_NOTICE, LOG_WARNING, NULL, publish, RAII_VAR, schedule_publish_refresh(), SCOPED_AO2LOCK, send_unpublish_task(), set_transport(), sip_outbound_publisher_init(), and sip_publisher_service_queue().

Referenced by sip_outbound_publisher_init().

sip_outbound_publish_client_add_publisher()

static struct sip_outbound_publisher * sip_outbound_publish_client_add_publisher ( struct ast_sip_outbound_publish_client *  client, const char *  user  )

static

Definition at line 1122 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher =
        sip_outbound_publisher_alloc(client, user);
 
    if (!publisher) {
        return NULL;
    }
 
    if (!ao2_link(client->publishers, publisher)) {
        /*
         * No need to bump the reference here. The task will take care of
         * removing the reference.
         */
        if (ast_sip_push_task(publisher->serializer, cancel_refresh_timer_task, publisher)) {
            ao2_ref(publisher, -1);
        }
        return NULL;
    }
 
    return publisher;
}

References ao2_link, ao2_ref, ast_sip_push_task, cancel_refresh_timer_task(), sip_outbound_publisher::client, NULL, sip_outbound_publisher::serializer, and sip_outbound_publisher_alloc().

Referenced by sip_outbound_publish_apply(), and sip_outbound_publish_client_get_publisher().

sip_outbound_publish_client_destroy()

static void sip_outbound_publish_client_destroy ( void *  obj )

static

Destructor function for publish client.

Definition at line 1225 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_outbound_publish_client *client = obj;
 
    ao2_cleanup(client->datastores);
 
    /*
     * The client's publishers have already been unpublished and destroyed
     * by this point, so it is safe to finally remove the reference to the
     * publish object. The client needed to hold a reference to it until
     * the publishers were done with it.
     */
    ao2_cleanup(client->publish);
}

References ao2_cleanup, ast_sip_outbound_publish_client::datastores, and ast_sip_outbound_publish_client::publish.

Referenced by sip_outbound_publish_state_alloc().

sip_outbound_publish_client_get_publisher()

static struct sip_outbound_publisher * sip_outbound_publish_client_get_publisher ( struct ast_sip_outbound_publish_client *  client, const char *  user  )

static

Definition at line 588 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher;
 
    /*
     * Lock before searching since there could be a race between searching and adding.
     * Just use the load_lock since we might need to lock it anyway (if adding) and
     * also it simplifies the code (otherwise we'd have to lock the publishers, no-
     * lock the search and pass a flag to 'add publisher to no-lock the potential link).
     */
    ast_rwlock_wrlock(&load_lock);
    publisher = ao2_find(client->publishers, user, OBJ_SEARCH_KEY);
    if (!publisher) {
        if (!(publisher = sip_outbound_publish_client_add_publisher(client, user))) {
            ast_rwlock_unlock(&load_lock);
            return NULL;
        }
    }
    ast_rwlock_unlock(&load_lock);
 
    return publisher;
}

References ao2_find, ast_rwlock_unlock, ast_rwlock_wrlock, sip_outbound_publisher::client, load_lock, NULL, OBJ_SEARCH_KEY, and sip_outbound_publish_client_add_publisher().

Referenced by ast_sip_publish_client_get_user_from_uri(), ast_sip_publish_client_get_user_to_uri(), and ast_sip_publish_client_user_send().

sip_outbound_publish_datastore_destroy()

static void sip_outbound_publish_datastore_destroy ( void *  obj )

static

Definition at line 717 of file res_pjsip_outbound_publish.c.

{
    struct ast_datastore *datastore = obj;
 
    /* Using the destroy function (if present) destroy the data */
    if (datastore->info->destroy != NULL && datastore->data != NULL) {
        datastore->info->destroy(datastore->data);
        datastore->data = NULL;
    }
 
    ast_free((void *) datastore->uid);
    datastore->uid = NULL;
}

References ast_free, ast_datastore::data, ast_datastore_info::destroy, ast_datastore::info, NULL, and ast_datastore::uid.

Referenced by ast_sip_publish_client_alloc_datastore().

sip_outbound_publish_destroy()

static void sip_outbound_publish_destroy ( void *  obj )

static

Destructor function for publish information.

Definition at line 694 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_outbound_publish *publish = obj;
 
    ast_sip_auth_vector_destroy(&publish->outbound_auths);
 
    ast_string_field_free_memory(publish);
}

References ast_sip_auth_vector_destroy(), ast_string_field_free_memory, and publish.

Referenced by sip_outbound_publish_alloc().

sip_outbound_publish_state_alloc()

static struct ast_sip_outbound_publish_state * sip_outbound_publish_state_alloc ( struct ast_sip_outbound_publish *  publish )

static

Allocator function for publish client.

Definition at line 1460 of file res_pjsip_outbound_publish.c.

{
    const char *id = ast_sorcery_object_get_id(publish);
    struct ast_sip_outbound_publish_state *state =
        ao2_alloc(sizeof(*state) + strlen(id) + 1, sip_outbound_publish_state_destroy);
 
    if (!state) {
        return NULL;
    }
 
    state->client = ao2_alloc(sizeof(*state->client), sip_outbound_publish_client_destroy);
    if (!state->client) {
        ao2_ref(state, -1);
        return NULL;
    }
 
    state->client->datastores = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        DATASTORE_BUCKETS, datastore_hash, NULL, datastore_cmp);
    if (!state->client->datastores) {
        ao2_ref(state, -1);
        return NULL;
    }
 
    state->client->publishers = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        DATASTORE_BUCKETS,
        sip_outbound_publisher_hash_fn, NULL, sip_outbound_publisher_cmp_fn);
    if (!state->client->publishers) {
        ao2_ref(state, -1);
        return NULL;
    }
 
    state->client->publish = ao2_bump(publish);
 
    strcpy(state->id, id);
    return state;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_bump, ao2_container_alloc_hash, ao2_ref, ast_sorcery_object_get_id(), DATASTORE_BUCKETS, datastore_cmp(), datastore_hash(), NULL, publish, sip_outbound_publish_client_destroy(), and sip_outbound_publish_state_destroy().

Referenced by sip_outbound_publish_apply().

sip_outbound_publish_state_destroy()

static void sip_outbound_publish_state_destroy ( void *  obj )

static

Destructor function for publish state.

Definition at line 1241 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_outbound_publish_state *state = obj;
 
    stop_publishing(state->client, NULL);
    /*
     * Since the state is being destroyed the associated client needs to also
     * be destroyed. However simply removing the reference to the client will
     * not initiate client destruction since the client's publisher(s) hold a
     * reference to the client object as well. So we need to unpublish the
     * the client's publishers here, which will remove the publisher's client
     * reference during that process.
     *
     * That being said we don't want to remove the client's reference to the
     * publish object just yet. We'll hold off on that until client destruction
     * itself. This is because the publishers need access to the client's
     * publish object while they are unpublishing.
     */
    ao2_callback(state->client->publishers, OBJ_NODATA | OBJ_UNLINK, cancel_and_unpublish, NULL);
    ao2_cleanup(state->client->publishers);
 
    state->client->started = 0;
    ao2_cleanup(state->client);
}

References ao2_callback, ao2_cleanup, cancel_and_unpublish(), NULL, OBJ_NODATA, OBJ_UNLINK, and stop_publishing().

Referenced by sip_outbound_publish_state_alloc().

sip_outbound_publish_synchronize()

static void sip_outbound_publish_synchronize ( struct ast_sip_event_publisher_handler *  removed )

static

Helper function which starts or stops publish clients when applicable.

Definition at line 507 of file res_pjsip_outbound_publish.c.

{
    RAII_VAR(struct ao2_container *, publishes, get_publishes_and_update_state(), ao2_cleanup);
    struct ao2_container *states;
    struct ao2_iterator i;
    struct ast_sip_outbound_publish_state *state;
 
    if (!publishes) {
        return;
    }
 
    states = ao2_global_obj_ref(current_states);
    if (!states) {
        return;
    }
 
    i = ao2_iterator_init(states, 0);
    while ((state = ao2_iterator_next(&i))) {
        struct ast_sip_outbound_publish *publish = ao2_bump(state->client->publish);
        struct ast_sip_event_publisher_handler *handler = find_publisher_handler_for_event_name(publish->event);
 
        if (!state->client->started) {
            /* If the publisher client has not yet been started try to start it */
            if (!handler) {
                ast_debug(2, "Could not find handler for event '%s' for outbound publish client '%s'\n",
                      publish->event, ast_sorcery_object_get_id(publish));
            } else if (handler->start_publishing(publish, state->client)) {
                ast_log(LOG_ERROR, "Failed to start outbound publish with event '%s' for client '%s'\n",
                    publish->event, ast_sorcery_object_get_id(publish));
            } else {
                state->client->started = 1;
            }
        } else if (state->client->started && !handler && removed && !strcmp(publish->event, removed->event_name)) {
            stop_publishing(state->client, removed);
            ao2_callback(state->client->publishers, OBJ_NODATA, cancel_and_unpublish, NULL);
            state->client->started = 0;
        }
        ao2_ref(publish, -1);
        ao2_ref(state, -1);
    }
    ao2_iterator_destroy(&i);
    ao2_ref(states, -1);
}

References ao2_bump, ao2_callback, ao2_cleanup, ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_debug, ast_log, ast_sorcery_object_get_id(), cancel_and_unpublish(), ast_sip_event_publisher_handler::event_name, find_publisher_handler_for_event_name(), get_publishes_and_update_state(), handler(), LOG_ERROR, NULL, OBJ_NODATA, publish, RAII_VAR, and stop_publishing().

Referenced by ast_sip_register_event_publisher_handler(), ast_sip_unregister_event_publisher_handler(), load_module(), and reload_module().

sip_outbound_publish_timer_cb()

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

static

Publish client timer callback function.

Definition at line 438 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher = entry->user_data;
 
    ao2_lock(publisher);
    if (AST_LIST_EMPTY(&publisher->queue)) {
        int res;
        /* If there are no outstanding messages send an empty PUBLISH message so our publication doesn't expire */
        publisher_client_send(publisher, NULL, &res, 0);
    }
    ao2_unlock(publisher);
 
    ao2_ref(publisher, -1);
}

References ao2_lock, ao2_ref, ao2_unlock, AST_LIST_EMPTY, NULL, publisher_client_send(), and sip_outbound_publisher::queue.

Referenced by sip_outbound_publisher_alloc().

sip_outbound_publisher_alloc()

static struct sip_outbound_publisher * sip_outbound_publisher_alloc ( struct ast_sip_outbound_publish_client *  client, const char *  user  )

static

Definition at line 1070 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher;
    char tps_name[AST_TASKPROCESSOR_MAX_NAME + 1];
 
    publisher = ao2_alloc(sizeof(*publisher) + (user ? strlen(user) : 0) + 1,
                  sip_outbound_publisher_destroy);
    if (!publisher) {
        return NULL;
    }
 
    /*
     * Bump the ref to the client. This essentially creates a circular reference,
     * but it is needed in order to make sure the client object doesn't get pulled
     * out from under us when the publisher stops publishing.
     *
     * The circular reference is alleviated by calling cancel_and_unpublish for
     * each client, from the state's destructor. By calling it there all references
     * to the publishers should go to zero, thus calling the publisher's destructor.
     * This in turn removes the client reference we added here. The state then removes
     * its reference to the client, which should take it to zero.
     */
    publisher->owner = ao2_bump(client);
    publisher->timer.user_data = publisher;
    publisher->timer.cb = sip_outbound_publish_timer_cb;
    if (user) {
        strcpy(publisher->user, user);
    } else {
        *publisher->user = '\0';
    }
 
    ast_taskprocessor_build_name(tps_name, sizeof(tps_name), "pjsip/outpub/%s",
        ast_sorcery_object_get_id(client->publish));
 
    publisher->serializer = ast_sip_create_serializer_group(tps_name,
        shutdown_group);
    if (!publisher->serializer) {
        ao2_ref(publisher, -1);
        return NULL;
    }
 
    if (ast_sip_push_task_wait_servant(NULL, sip_outbound_publisher_init, publisher)) {
        ast_log(LOG_ERROR, "Unable to create publisher for outbound publish '%s'\n",
            ast_sorcery_object_get_id(client->publish));
        ao2_ref(publisher, -1);
        return NULL;
    }
 
    return publisher;
}

References ao2_alloc, ao2_bump, ao2_ref, ast_log, ast_sip_create_serializer_group(), ast_sip_push_task_wait_servant, ast_sorcery_object_get_id(), ast_taskprocessor_build_name(), AST_TASKPROCESSOR_MAX_NAME, sip_outbound_publisher::client, LOG_ERROR, NULL, sip_outbound_publisher::owner, sip_outbound_publisher::serializer, shutdown_group, sip_outbound_publish_timer_cb(), sip_outbound_publisher_destroy(), sip_outbound_publisher_init(), sip_outbound_publisher::timer, and sip_outbound_publisher::user.

Referenced by sip_outbound_publish_client_add_publisher().

sip_outbound_publisher_destroy()

static void sip_outbound_publisher_destroy ( void *  obj )

static

Destructor function for publish client.

Definition at line 1052 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher = obj;
    struct sip_outbound_publish_message *message;
 
    /* You might be tempted to think "the publish client isn't being destroyed" but it actually is - just elsewhere */
 
    while ((message = AST_LIST_REMOVE_HEAD(&publisher->queue, entry))) {
        ast_free(message);
    }
 
    ao2_cleanup(publisher->owner);
    ast_free(publisher->from_uri);
    ast_free(publisher->to_uri);
 
    ast_taskprocessor_unreference(publisher->serializer);
}

References ao2_cleanup, ast_free, AST_LIST_REMOVE_HEAD, ast_taskprocessor_unreference(), sip_outbound_publish_message::entry, sip_outbound_publisher::from_uri, sip_outbound_publisher::owner, sip_outbound_publisher::queue, sip_outbound_publisher::serializer, and sip_outbound_publisher::to_uri.

Referenced by sip_outbound_publisher_alloc().

sip_outbound_publisher_init()

static int sip_outbound_publisher_init ( void *  data )

static

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

Definition at line 972 of file res_pjsip_outbound_publish.c.

{
    struct sip_outbound_publisher *publisher = data;
    RAII_VAR(struct ast_sip_outbound_publish *, publish, NULL, ao2_cleanup);
    pjsip_publishc_opt opt = {
        .queue_request = PJ_FALSE,
    };
    pj_pool_t *pool;
    pj_str_t event, server_uri, to_uri, from_uri;
 
    if (publisher->client) {
        return 0;
    }
 
    if (pjsip_publishc_create(ast_sip_get_pjsip_endpoint(), &opt,
                  ao2_bump(publisher), sip_outbound_publish_callback,
        &publisher->client) != PJ_SUCCESS) {
        ao2_ref(publisher, -1);
        return -1;
    }
 
    publish = ao2_bump(publisher->owner->publish);
 
    if (!ast_strlen_zero(publish->outbound_proxy)) {
        pjsip_route_hdr route_set, *route;
        static const pj_str_t ROUTE_HNAME = { "Route", 5 };
 
        pj_list_init(&route_set);
 
        if (!(route = pjsip_parse_hdr(pjsip_publishc_get_pool(publisher->client), &ROUTE_HNAME,
            (char*)publish->outbound_proxy, strlen(publish->outbound_proxy), NULL))) {
            pjsip_publishc_destroy(publisher->client);
            return -1;
        }
        pj_list_insert_nodes_before(&route_set, route);
 
        pjsip_publishc_set_route_set(publisher->client, &route_set);
    }
 
    pool = pjsip_endpt_create_pool(ast_sip_get_pjsip_endpoint(), "URI Validation",
                       pjsip_max_url_size, pjsip_max_url_size);
    if (!pool) {
        ast_log(LOG_ERROR, "Could not create pool for URI validation on outbound publish '%s'\n",
            ast_sorcery_object_get_id(publish));
        pjsip_publishc_destroy(publisher->client);
        return -1;
    }
 
    if (sip_outbound_publisher_set_uris(pool, publisher, &server_uri, &from_uri, &to_uri)) {
        pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
        pjsip_publishc_destroy(publisher->client);
        return -1;
    }
 
    pj_cstr(&event, publish->event);
    if (pjsip_publishc_init(publisher->client, &event, &server_uri, &from_uri, &to_uri,
            publish->expiration) != PJ_SUCCESS) {
        ast_log(LOG_ERROR, "Failed to initialize publishing client on outbound publish '%s'\n",
            ast_sorcery_object_get_id(publish));
        pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
        pjsip_publishc_destroy(publisher->client);
        return -1;
    }
 
    pjsip_endpt_release_pool(ast_sip_get_pjsip_endpoint(), pool);
    return 0;
}

References ao2_bump, ao2_cleanup, ao2_ref, ast_log, ast_sip_get_pjsip_endpoint(), ast_sorcery_object_get_id(), ast_strlen_zero(), sip_outbound_publisher::client, event::event, sip_outbound_publisher::from_uri, LOG_ERROR, NULL, sip_outbound_publisher::owner, pjsip_max_url_size, publish, ast_sip_outbound_publish_client::publish, RAII_VAR, server_uri, sip_outbound_publish_callback(), sip_outbound_publisher_set_uris(), and sip_outbound_publisher::to_uri.

Referenced by sip_outbound_publish_callback(), sip_outbound_publisher_alloc(), and sip_outbound_publisher_reinit().

sip_outbound_publisher_reinit()

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

static

Definition at line 1040 of file res_pjsip_outbound_publish.c.

{
    return sip_outbound_publisher_init(obj);
}

References sip_outbound_publisher_init().

Referenced by sip_outbound_publisher_reinit_all().

sip_outbound_publisher_reinit_all()

static int sip_outbound_publisher_reinit_all ( void *  data )

static

Definition at line 1045 of file res_pjsip_outbound_publish.c.

{
    ao2_callback(data, OBJ_NODATA, sip_outbound_publisher_reinit, NULL);
    return 0;
}

References ao2_callback, NULL, OBJ_NODATA, and sip_outbound_publisher_reinit().

Referenced by current_state_reusable().

sip_outbound_publisher_set_uri()

static int sip_outbound_publisher_set_uri ( pj_pool_t *  pool, const char *  uri, const char *  user, pj_str_t *  res_uri  )

static

Definition at line 890 of file res_pjsip_outbound_publish.c.

{
    pj_str_t tmp;
    pjsip_uri *parsed;
    pjsip_sip_uri *parsed_uri;
    int size;
 
    pj_strdup2_with_null(pool, &tmp, uri);
    if (!(parsed = pjsip_parse_uri(pool, tmp.ptr, tmp.slen, 0))) {
        return -1;
    }
 
    if (!(parsed_uri = pjsip_uri_get_uri(parsed))) {
        return -1;
    }
 
    if (!ast_strlen_zero(user)) {
        pj_strdup2(pool, &parsed_uri->user, user);
    }
 
    res_uri->ptr = (char*) pj_pool_alloc(pool, pjsip_max_url_size);
    if (!res_uri->ptr) {
        return -1;
    }
 
    if ((size = pjsip_uri_print(PJSIP_URI_IN_OTHER, parsed_uri, res_uri->ptr,
                    pjsip_max_url_size - 1)) <= 0) {
        return -1;
    }
    res_uri->ptr[size] = '\0';
    res_uri->slen = size;
 
    return 0;
}

References ast_strlen_zero(), and pjsip_max_url_size.

Referenced by sip_outbound_publisher_set_uris().

sip_outbound_publisher_set_uris()

static int sip_outbound_publisher_set_uris ( pj_pool_t *  pool, struct sip_outbound_publisher *  publisher, pj_str_t *  server_uri, pj_str_t *  to_uri, pj_str_t *  from_uri  )

static

Definition at line 926 of file res_pjsip_outbound_publish.c.

{
    struct ast_sip_outbound_publish *publish = publisher->owner->publish;
 
    if (sip_outbound_publisher_set_uri(pool, publish->server_uri, publisher->user, server_uri)) {
        ast_log(LOG_ERROR, "Invalid server URI '%s' specified on outbound publish '%s'\n",
            publish->server_uri, ast_sorcery_object_get_id(publish));
        return -1;
    }
 
    if (ast_strlen_zero(publish->to_uri)) {
        to_uri->ptr = server_uri->ptr;
        to_uri->slen = server_uri->slen;
    } else if (sip_outbound_publisher_set_uri(pool, publish->to_uri, publisher->user, to_uri)) {
        ast_log(LOG_ERROR, "Invalid to URI '%s' specified on outbound publish '%s'\n",
            publish->to_uri, ast_sorcery_object_get_id(publish));
        return -1;
    }
 
    publisher->to_uri = ast_strdup(to_uri->ptr);
    if (!publisher->to_uri) {
        return -1;
    }
 
    if (ast_strlen_zero(publish->from_uri)) {
        from_uri->ptr = server_uri->ptr;
        from_uri->slen = server_uri->slen;
    } else if (sip_outbound_publisher_set_uri(pool, publish->from_uri, publisher->user, from_uri)) {
        ast_log(LOG_ERROR, "Invalid from URI '%s' specified on outbound publish '%s'\n",
            publish->from_uri, ast_sorcery_object_get_id(publish));
        return -1;
    }
 
    publisher->from_uri = ast_strdup(from_uri->ptr);
    if (!publisher->from_uri) {
        return -1;
    }
 
    return 0;
}

References ast_log, ast_sorcery_object_get_id(), ast_strdup, ast_strlen_zero(), ast_sip_outbound_publish::from_uri, sip_outbound_publisher::from_uri, LOG_ERROR, sip_outbound_publisher::owner, publish, ast_sip_outbound_publish_client::publish, server_uri, sip_outbound_publisher_set_uri(), ast_sip_outbound_publish::to_uri, sip_outbound_publisher::to_uri, and sip_outbound_publisher::user.

Referenced by sip_outbound_publisher_init().

sip_publish_state_get()

static struct ast_sip_outbound_publish_state * sip_publish_state_get ( const char *  id )

static

Definition at line 551 of file res_pjsip_outbound_publish.c.

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

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

Referenced by ast_sip_publish_client_get(), and sip_outbound_publish_apply().

sip_publisher_service_queue()

static int sip_publisher_service_queue ( void *  data )

static

Definition at line 786 of file res_pjsip_outbound_publish.c.

{
    RAII_VAR(struct sip_outbound_publisher *, publisher, data, ao2_cleanup);
    SCOPED_AO2LOCK(lock, publisher);
    struct sip_outbound_publish_message *message;
    pjsip_tx_data *tdata;
    pj_status_t status;
 
    if (publisher->destroy || publisher->sending || !(message = AST_LIST_FIRST(&publisher->queue))) {
        return 0;
    }
 
    if (pjsip_publishc_publish(publisher->client, PJ_FALSE, &tdata) != PJ_SUCCESS) {
        goto fatal;
    }
 
    if (!ast_strlen_zero(message->body.type) && !ast_strlen_zero(message->body.subtype) &&
        ast_sip_add_body(tdata, &message->body)) {
        pjsip_tx_data_dec_ref(tdata);
        goto fatal;
    }
 
    set_transport(publisher, tdata);
 
    status = pjsip_publishc_send(publisher->client, tdata);
    if (status == PJ_EBUSY) {
        /* We attempted to send the message but something else got there first */
        goto service;
    } else if (status != PJ_SUCCESS) {
        goto fatal;
    }
 
    publisher->sending = message;
 
    return 0;
 
fatal:
    AST_LIST_REMOVE_HEAD(&publisher->queue, entry);
    ast_free(message);
 
service:
    if (ast_sip_push_task(publisher->serializer, sip_publisher_service_queue, ao2_bump(publisher))) {
        ao2_ref(publisher, -1);
    }
    return -1;
}

References ao2_bump, ao2_cleanup, ao2_ref, ast_free, AST_LIST_FIRST, AST_LIST_REMOVE_HEAD, ast_sip_add_body(), ast_sip_push_task, ast_strlen_zero(), ast_datastore::data, sip_outbound_publish_message::entry, lock, RAII_VAR, SCOPED_AO2LOCK, service, set_transport(), sip_publisher_service_queue(), and status.

Referenced by publisher_client_send(), sip_outbound_publish_callback(), and sip_publisher_service_queue().

stop_publishing()

static void stop_publishing ( struct ast_sip_outbound_publish_client *  client, struct ast_sip_event_publisher_handler *  handler  )

static

Definition at line 492 of file res_pjsip_outbound_publish.c.

{
    if (!handler) {
        handler = find_publisher_handler_for_event_name(client->publish->event);
    }
 
    if (handler) {
        handler->stop_publishing(client);
    }
}

References sip_outbound_publisher::client, find_publisher_handler_for_event_name(), and handler().

Referenced by sip_outbound_publish_state_destroy(), and sip_outbound_publish_synchronize().

sub_add_handler()

static void sub_add_handler ( struct ast_sip_event_publisher_handler *  handler )

static

Definition at line 382 of file res_pjsip_outbound_publish.c.

{
    AST_RWLIST_INSERT_TAIL(&publisher_handlers, handler, next);
}

References AST_RWLIST_INSERT_TAIL, and handler().

Referenced by ast_sip_register_event_publisher_handler().

unload_module()

static int unload_module ( void  )

static

Definition at line 1659 of file res_pjsip_outbound_publish.c.

{
    int remaining;
 
    ast_sorcery_object_unregister(ast_sip_get_sorcery(), "outbound-publish");
 
    ao2_global_obj_release(current_states);
 
    /* Wait for publication serializers to get destroyed. */
    ast_debug(2, "Waiting for publication to complete for unload.\n");
    remaining = ast_serializer_shutdown_group_join(shutdown_group, MAX_UNLOAD_TIMEOUT_TIME);
    if (remaining) {
        ast_log(LOG_WARNING, "Unload incomplete.  Could not stop %d outbound publications.  Try again later.\n",
            remaining);
        return -1;
    }
 
    ast_debug(2, "Successful shutdown.\n");
 
    ao2_cleanup(shutdown_group);
    shutdown_group = NULL;
 
    return 0;
}

References ao2_cleanup, ao2_global_obj_release, ast_debug, ast_log, ast_serializer_shutdown_group_join(), ast_sip_get_sorcery(), ast_sorcery_object_unregister(), LOG_WARNING, MAX_UNLOAD_TIMEOUT_TIME, NULL, and shutdown_group.

Referenced by load_module().

validate_publish_config()

static int validate_publish_config ( struct ast_sip_outbound_publish *  publish )

static

Definition at line 1498 of file res_pjsip_outbound_publish.c.

{
    if (ast_strlen_zero(publish->server_uri)) {
        ast_log(LOG_ERROR, "No server URI specified on outbound publish '%s'\n",
            ast_sorcery_object_get_id(publish));
        return -1;
    } else if (ast_sip_validate_uri_length(publish->server_uri)) {
        ast_log(LOG_ERROR, "Server URI or hostname length exceeds pjproject limit or is not a sip(s) uri: '%s' on outbound publish '%s'\n",
            publish->server_uri,
            ast_sorcery_object_get_id(publish));
        return -1;
    } else if (ast_strlen_zero(publish->event)) {
        ast_log(LOG_ERROR, "No event type specified for outbound publish '%s'\n",
            ast_sorcery_object_get_id(publish));
        return -1;
    } else if (!ast_strlen_zero(publish->from_uri)
        && ast_sip_validate_uri_length(publish->from_uri)) {
        ast_log(LOG_ERROR, "From URI or hostname length exceeds pjproject limit or is not a sip(s) uri: '%s' on outbound publish '%s'\n",
            publish->from_uri,
            ast_sorcery_object_get_id(publish));
        return -1;
    } else if (!ast_strlen_zero(publish->to_uri)
        && ast_sip_validate_uri_length(publish->to_uri)) {
        ast_log(LOG_ERROR, "To URI or hostname length exceeds pjproject limit or is not a sip(s) uri: '%s' on outbound publish '%s'\n",
            publish->to_uri,
            ast_sorcery_object_get_id(publish));
        return -1;
    }
    return 0;
}

References ast_log, ast_sip_validate_uri_length(), ast_sorcery_object_get_id(), ast_strlen_zero(), LOG_ERROR, and publish.

Referenced by sip_outbound_publish_apply().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "PJSIP Outbound Publish Support" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .reload = reload_module, .unload = unload_module, .load_pri = AST_MODPRI_CHANNEL_DEPEND, .requires = "res_pjproject,res_pjsip", }

static

Definition at line 1744 of file res_pjsip_outbound_publish.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1744 of file res_pjsip_outbound_publish.c.

load_lock

ast_rwlock_t load_lock = AST_RWLOCK_INIT_VALUE

static

Used for locking while loading/reloading.

Mutli-user configurations make it so publishers can be dynamically added and removed. Publishers should not be added or removed during a [re]load since it could cause the current_clients container to be out of sync. Thus the reason for this lock.

Definition at line 292 of file res_pjsip_outbound_publish.c.

Referenced by ast_sip_publish_client_remove(), get_publishes_and_update_state(), and sip_outbound_publish_client_get_publisher().

new_states

struct ao2_container* new_states

static

Used on [re]loads to hold new state data.

Definition at line 308 of file res_pjsip_outbound_publish.c.

Referenced by get_publishes_and_update_state(), load_module(), and sip_outbound_publish_apply().

pjsip_max_url_size

int pjsip_max_url_size = PJSIP_MAX_URL_SIZE

static

Definition at line 161 of file res_pjsip_outbound_publish.c.

Referenced by load_module(), sip_outbound_publisher_init(), and sip_outbound_publisher_set_uri().

publisher_handlers

struct publisher_handlers publisher_handlers = AST_RWLIST_HEAD_INIT_VALUE

shutdown_group

struct ast_serializer_shutdown_group* shutdown_group

static

Shutdown group to monitor sip_outbound_registration_client_state serializers.

Definition at line 302 of file res_pjsip_outbound_publish.c.

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