pjsip_transport_management.c File Reference

#include "asterisk.h"
#include <signal.h>
#include <pjsip.h>
#include <pjsip_ua.h>
#include "asterisk/res_pjsip.h"
#include "asterisk/module.h"
#include "asterisk/astobj2.h"
#include "include/res_pjsip_private.h"

Include dependency graph for pjsip_transport_management.c:

Go to the source code of this file.

Data Structures
struct	monitored_transport
	Structure for transport to be monitored. More...

Macros
#define	IDLE_TIMEOUT   (pjsip_cfg()->tsx.td)
#define	TRANSPORTS_BUCKETS   127
	Number of buckets for monitored transports. More...

Functions
static void	__init_desc_storage (void)
static	AO2_GLOBAL_OBJ_STATIC (monitored_transports)
	Global container of active transports. More...
void	ast_sip_destroy_transport_management (void)
int	ast_sip_initialize_transport_management (void)
static struct monitored_transport *	get_monitored_transport_by_name (const char *obj_name)
static pj_bool_t	idle_monitor_on_rx_request (pjsip_rx_data *rdata)
	On incoming TCP connections, when we receive a SIP request, we mark that we have received a valid SIP request. This way, we will not shut the transport down for idleness. More...
static int	idle_sched_cb (const void *data)
static int	idle_sched_cleanup (const void *data)
static int	idle_sched_init_pj_thread (void)
static void	keepalive_global_loaded (const char *object_type)
static void	keepalive_transport_send_keepalive (struct monitored_transport *monitored)
static void *	keepalive_transport_thread (void *data)
	Thread which sends keepalives to all active connection-oriented transports. More...
static int	monitored_transport_cmp_fn (void *obj, void *arg, int flags)
	Comparison function for monitored transport. More...
static void	monitored_transport_destroy (void *obj)
	Destructor for keepalive transport. More...
static int	monitored_transport_hash_fn (const void *obj, int flags)
	Hashing function for monitored transport. More...
static void	monitored_transport_state_callback (pjsip_transport *transport, pjsip_transport_state state, const pjsip_transport_state_info *info)
	Callback invoked when transport changes occur. More...

Variables
static struct ast_threadstorage	desc_storage = { .once = PTHREAD_ONCE_INIT , .key_init = __init_desc_storage , .custom_init = NULL , }
static pjsip_module	idle_monitor_module
static struct ast_sorcery_observer	keepalive_global_observer
	Observer which is used to update our interval when the global setting changes. More...
static unsigned int	keepalive_interval
	The global interval at which to send keepalives. More...
static const pj_str_t	keepalive_packet = { "\r\n\r\n", 4 }
	The keep alive packet to send. More...
static pthread_t	keepalive_thread = AST_PTHREADT_NULL
	Thread keeping things alive. More...
struct ast_sip_tpmgr_state_callback	monitored_transport_reg
static struct ast_sched_context *	sched
	Scheduler context for timing out connections with no data received. More...

Macro Definition Documentation

IDLE_TIMEOUT

#define IDLE_TIMEOUT   (pjsip_cfg()->tsx.td)

Definition at line 34 of file pjsip_transport_management.c.

TRANSPORTS_BUCKETS

#define TRANSPORTS_BUCKETS   127

Number of buckets for monitored transports.

Definition at line 32 of file pjsip_transport_management.c.

Function Documentation

__init_desc_storage()

static void __init_desc_storage ( void  )

static

Definition at line 120 of file pjsip_transport_management.c.

{

AO2_GLOBAL_OBJ_STATIC()

static AO2_GLOBAL_OBJ_STATIC ( monitored_transports  )

static

Global container of active transports.

ast_sip_destroy_transport_management()

void ast_sip_destroy_transport_management

(

void

)

Definition at line 410 of file pjsip_transport_management.c.

{
    if (keepalive_interval) {
        keepalive_interval = 0;
        if (keepalive_thread != AST_PTHREADT_NULL) {
            pthread_kill(keepalive_thread, SIGURG);
            pthread_join(keepalive_thread, NULL);
            keepalive_thread = AST_PTHREADT_NULL;
        }
    }
 
    ast_sorcery_observer_remove(ast_sip_get_sorcery(), "global", &keepalive_global_observer);
 
    ast_sip_transport_state_unregister(&monitored_transport_reg);
 
    ast_sip_unregister_service(&idle_monitor_module);
 
    ast_sched_clean_by_callback(sched, idle_sched_cb, idle_sched_cleanup);
    ast_sched_context_destroy(sched);
    sched = NULL;
 
    ao2_global_obj_release(monitored_transports);
}

References ao2_global_obj_release, AST_PTHREADT_NULL, ast_sched_clean_by_callback(), ast_sched_context_destroy(), ast_sip_get_sorcery(), ast_sip_transport_state_unregister(), ast_sip_unregister_service(), ast_sorcery_observer_remove(), idle_monitor_module, idle_sched_cb(), idle_sched_cleanup(), keepalive_global_observer, keepalive_interval, keepalive_thread, monitored_transport_reg, and NULL.

Referenced by unload_pjsip().

ast_sip_initialize_transport_management()

int ast_sip_initialize_transport_management

(

void

)

Definition at line 372 of file pjsip_transport_management.c.

{
    struct ao2_container *transports;
 
    transports = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, TRANSPORTS_BUCKETS,
        monitored_transport_hash_fn, NULL, monitored_transport_cmp_fn);
    if (!transports) {
        ast_log(LOG_ERROR, "Could not create container for transports to perform keepalive on.\n");
        return AST_MODULE_LOAD_DECLINE;
    }
    ao2_global_obj_replace_unref(monitored_transports, transports);
    ao2_ref(transports, -1);
 
    sched = ast_sched_context_create();
    if (!sched) {
        ast_log(LOG_ERROR, "Failed to create keepalive scheduler context.\n");
        ao2_global_obj_release(monitored_transports);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (ast_sched_start_thread(sched)) {
        ast_log(LOG_ERROR, "Failed to start keepalive scheduler thread\n");
        ast_sched_context_destroy(sched);
        sched = NULL;
        ao2_global_obj_release(monitored_transports);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    ast_sip_register_service(&idle_monitor_module);
 
    ast_sip_transport_state_register(&monitored_transport_reg);
 
    ast_sorcery_observer_add(ast_sip_get_sorcery(), "global", &keepalive_global_observer);
    ast_sorcery_reload_object(ast_sip_get_sorcery(), "global");
 
    return AST_MODULE_LOAD_SUCCESS;
}

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_global_obj_release, ao2_global_obj_replace_unref, ao2_ref, ast_log, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_sched_context_create(), ast_sched_context_destroy(), ast_sched_start_thread(), ast_sip_get_sorcery(), ast_sip_register_service(), ast_sip_transport_state_register(), ast_sorcery_observer_add(), ast_sorcery_reload_object(), idle_monitor_module, keepalive_global_observer, LOG_ERROR, monitored_transport_cmp_fn(), monitored_transport_hash_fn(), monitored_transport_reg, NULL, and TRANSPORTS_BUCKETS.

Referenced by load_module().

get_monitored_transport_by_name()

static struct monitored_transport * get_monitored_transport_by_name ( const char *  obj_name )

static

Definition at line 142 of file pjsip_transport_management.c.

{
    struct ao2_container *transports;
    struct monitored_transport *monitored = NULL;
 
    transports = ao2_global_obj_ref(monitored_transports);
    if (transports) {
        monitored = ao2_find(transports, obj_name, OBJ_SEARCH_KEY);
    }
    ao2_cleanup(transports);
 
    /* Caller is responsible for cleaning up reference */
    return monitored;
}

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

Referenced by idle_monitor_on_rx_request(), idle_sched_cb(), and idle_sched_cleanup().

idle_monitor_on_rx_request()

static pj_bool_t idle_monitor_on_rx_request ( pjsip_rx_data *  rdata )

static

On incoming TCP connections, when we receive a SIP request, we mark that we have received a valid SIP request. This way, we will not shut the transport down for idleness.

Definition at line 353 of file pjsip_transport_management.c.

{
    struct monitored_transport *idle_trans;
 
    idle_trans = get_monitored_transport_by_name(rdata->tp_info.transport->obj_name);
    if (idle_trans) {
        idle_trans->sip_received = 1;
        ao2_ref(idle_trans, -1);
    }
 
    return PJ_FALSE;
}

References ao2_ref, get_monitored_transport_by_name(), and monitored_transport::sip_received.

idle_sched_cb()

static int idle_sched_cb ( const void *  data )

static

Definition at line 157 of file pjsip_transport_management.c.

{
    char *obj_name = (char *) data;
    struct monitored_transport *monitored;
 
    if (idle_sched_init_pj_thread()) {
        ast_free(obj_name);
        return 0;
    }
 
    monitored = get_monitored_transport_by_name(obj_name);
    if (monitored) {
        if (!monitored->sip_received) {
            ast_log(LOG_NOTICE, "Shutting down transport '%s' since no request was received in %d seconds\n",
                monitored->transport->info, IDLE_TIMEOUT / 1000);
            pjsip_transport_shutdown(monitored->transport);
        }
        ao2_ref(monitored, -1);
    }
 
    ast_free(obj_name);
    return 0;
}

References ao2_ref, ast_free, ast_log, get_monitored_transport_by_name(), idle_sched_init_pj_thread(), IDLE_TIMEOUT, LOG_NOTICE, monitored_transport::sip_received, and monitored_transport::transport.

Referenced by ast_sip_destroy_transport_management(), and monitored_transport_state_callback().

idle_sched_cleanup()

static int idle_sched_cleanup ( const void *  data )

static

Definition at line 181 of file pjsip_transport_management.c.

{
    char *obj_name = (char *) data;
    struct monitored_transport *monitored;
 
    if (idle_sched_init_pj_thread()) {
        ast_free(obj_name);
        return 0;
    }
 
    monitored = get_monitored_transport_by_name(obj_name);
    if (monitored) {
        pjsip_transport_shutdown(monitored->transport);
        ao2_ref(monitored, -1);
    }
 
    ast_free(obj_name);
    return 0;
}

References ao2_ref, ast_free, get_monitored_transport_by_name(), idle_sched_init_pj_thread(), and monitored_transport::transport.

Referenced by ast_sip_destroy_transport_management().

idle_sched_init_pj_thread()

static int idle_sched_init_pj_thread ( void  )

static

Definition at line 122 of file pjsip_transport_management.c.

{
    if (!pj_thread_is_registered()) {
        pj_thread_t *thread;
        pj_thread_desc *desc;
 
        desc = ast_threadstorage_get(&desc_storage, sizeof(pj_thread_desc));
        if (!desc) {
            ast_log(LOG_ERROR, "Could not get thread desc from thread-local storage.\n");
            return -1;
        }
 
        pj_bzero(*desc, sizeof(*desc));
 
        pj_thread_register("Transport Monitor", *desc, &thread);
    }
 
    return 0;
}

References ast_log, ast_threadstorage_get(), desc, desc_storage, LOG_ERROR, and thread.

Referenced by idle_sched_cb(), and idle_sched_cleanup().

keepalive_global_loaded()

static void keepalive_global_loaded ( const char *  object_type )

static

Definition at line 317 of file pjsip_transport_management.c.

{
    unsigned int new_interval = ast_sip_get_keep_alive_interval();
 
    if (new_interval) {
        keepalive_interval = new_interval;
    } else if (keepalive_interval) {
        ast_log(LOG_NOTICE, "Keepalive support can not be disabled once activated.\n");
        return;
    } else {
        /* This will occur if no keepalive interval has been specified at initial start */
        return;
    }
 
    if (keepalive_thread != AST_PTHREADT_NULL) {
        return;
    }
 
    if (ast_pthread_create(&keepalive_thread, NULL, keepalive_transport_thread, NULL)) {
        ast_log(LOG_ERROR, "Could not create thread for sending keepalive messages.\n");
        keepalive_thread = AST_PTHREADT_NULL;
        keepalive_interval = 0;
    }
}

References ast_log, ast_pthread_create, AST_PTHREADT_NULL, ast_sip_get_keep_alive_interval(), keepalive_interval, keepalive_thread, keepalive_transport_thread(), LOG_ERROR, LOG_NOTICE, and NULL.

keepalive_transport_send_keepalive()

static void keepalive_transport_send_keepalive ( struct monitored_transport *  monitored )

static

Definition at line 59 of file pjsip_transport_management.c.

{
    pjsip_tpselector selector = {
        .type = PJSIP_TPSELECTOR_TRANSPORT,
        .u.transport = monitored->transport,
    };
 
    pjsip_tpmgr_send_raw(pjsip_endpt_get_tpmgr(ast_sip_get_pjsip_endpoint()),
        monitored->transport->key.type,
        &selector,
        NULL,
        keepalive_packet.ptr,
        keepalive_packet.slen,
        &monitored->transport->key.rem_addr,
        pj_sockaddr_get_len(&monitored->transport->key.rem_addr),
        NULL, NULL);
}

References ast_sip_get_pjsip_endpoint(), keepalive_packet, NULL, and monitored_transport::transport.

Referenced by keepalive_transport_thread().

keepalive_transport_thread()

static void * keepalive_transport_thread ( void *  data )

static

Thread which sends keepalives to all active connection-oriented transports.

Definition at line 78 of file pjsip_transport_management.c.

{
    struct ao2_container *transports;
    pj_thread_desc desc = { 0 };
    pj_thread_t *thread;
 
    if (pj_thread_register("Asterisk Keepalive Thread", desc, &thread) != PJ_SUCCESS) {
        ast_log(LOG_ERROR, "Could not register keepalive thread with PJLIB, keepalives will not occur.\n");
        return NULL;
    }
 
    transports = ao2_global_obj_ref(monitored_transports);
    if (!transports) {
        return NULL;
    }
 
    /*
     * Once loaded this module just keeps on going as it is unsafe to stop
     * and change the underlying callback for the transport manager.
     */
    while (keepalive_interval) {
        struct ao2_iterator iter;
        struct monitored_transport *monitored;
 
        sleep(keepalive_interval);
 
        /*
         * We must use the iterator to avoid deadlock between the container lock
         * and the pjproject transport manager group lock when sending
         * the keepalive packet.
         */
        iter = ao2_iterator_init(transports, 0);
        for (; (monitored = ao2_iterator_next(&iter)); ao2_ref(monitored, -1)) {
            keepalive_transport_send_keepalive(monitored);
        }
        ao2_iterator_destroy(&iter);
    }
 
    ao2_ref(transports, -1);
    return NULL;
}

References ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_log, desc, keepalive_interval, keepalive_transport_send_keepalive(), LOG_ERROR, NULL, and thread.

Referenced by keepalive_global_loaded().

monitored_transport_cmp_fn()

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

static

Comparison function for monitored transport.

Definition at line 284 of file pjsip_transport_management.c.

{
    const struct monitored_transport *object_left = obj;
    const struct monitored_transport *object_right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = object_right->transport->obj_name;
        /* Fall through */
    case OBJ_SEARCH_KEY:
        cmp = strcmp(object_left->transport->obj_name, right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        /*
         * We could also use a partial key struct containing a length
         * so strlen() does not get called for every comparison instead.
         */
        cmp = strncmp(object_left->transport->obj_name, 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;
    }
 
    return !cmp ? CMP_MATCH : 0;
}

References CMP_MATCH, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, and monitored_transport::transport.

Referenced by ast_sip_initialize_transport_management().

monitored_transport_destroy()

static void monitored_transport_destroy ( void *  obj )

static

Destructor for keepalive transport.

Definition at line 202 of file pjsip_transport_management.c.

{
    struct monitored_transport *monitored = obj;
 
    pjsip_transport_dec_ref(monitored->transport);
}

References monitored_transport::transport.

Referenced by monitored_transport_state_callback().

monitored_transport_hash_fn()

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

static

Hashing function for monitored transport.

Definition at line 262 of file pjsip_transport_management.c.

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

References ast_assert, ast_str_hash(), OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, and OBJ_SEARCH_OBJECT.

Referenced by ast_sip_initialize_transport_management().

monitored_transport_state_callback()

static void monitored_transport_state_callback ( pjsip_transport *  transport, pjsip_transport_state  state, const pjsip_transport_state_info *  info  )

static

Callback invoked when transport changes occur.

Definition at line 210 of file pjsip_transport_management.c.

{
    struct ao2_container *transports;
 
    /* We only care about reliable transports */
    if (PJSIP_TRANSPORT_IS_RELIABLE(transport)
        && (transport->dir == PJSIP_TP_DIR_INCOMING || keepalive_interval)
        && (transports = ao2_global_obj_ref(monitored_transports))) {
        struct monitored_transport *monitored;
 
        switch (state) {
        case PJSIP_TP_STATE_CONNECTED:
            monitored = ao2_alloc_options(sizeof(*monitored),
                monitored_transport_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
            if (!monitored) {
                break;
            }
            monitored->transport = transport;
            pjsip_transport_add_ref(monitored->transport);
 
            ao2_link(transports, monitored);
 
            if (transport->dir == PJSIP_TP_DIR_INCOMING) {
                char *obj_name = ast_strdup(transport->obj_name);
 
                if (!obj_name
                   || ast_sched_add_variable(sched, IDLE_TIMEOUT, idle_sched_cb, obj_name, 1) < 0) {
                    /* Shut down the transport if anything fails */
                    pjsip_transport_shutdown(transport);
                    ast_free(obj_name);
                }
            }
            ao2_ref(monitored, -1);
            break;
        case PJSIP_TP_STATE_SHUTDOWN:
        case PJSIP_TP_STATE_DISCONNECTED:
            ao2_find(transports, transport->obj_name, OBJ_SEARCH_KEY | OBJ_NODATA | OBJ_UNLINK);
            break;
        default:
            break;
        }
 
        ao2_ref(transports, -1);
    }
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_find, ao2_global_obj_ref, ao2_link, ao2_ref, ast_free, ast_sched_add_variable(), ast_strdup, idle_sched_cb(), IDLE_TIMEOUT, keepalive_interval, monitored_transport_destroy(), OBJ_NODATA, OBJ_SEARCH_KEY, OBJ_UNLINK, and monitored_transport::transport.

Variable Documentation

desc_storage

struct ast_threadstorage desc_storage = { .once = PTHREAD_ONCE_INIT , .key_init = __init_desc_storage , .custom_init = NULL , }

static

Definition at line 120 of file pjsip_transport_management.c.

Referenced by idle_sched_init_pj_thread().

idle_monitor_module

pjsip_module idle_monitor_module

static

Initial value:

= {
    .name = {"idle monitor module", 19},
    .priority = PJSIP_MOD_PRIORITY_TRANSPORT_LAYER + 3,
    .on_rx_request = idle_monitor_on_rx_request,
}

Definition at line 366 of file pjsip_transport_management.c.

Referenced by ast_sip_destroy_transport_management(), and ast_sip_initialize_transport_management().

keepalive_global_observer

struct ast_sorcery_observer keepalive_global_observer

static

Initial value:

= {
    .loaded = keepalive_global_loaded,
}

Observer which is used to update our interval when the global setting changes.

Definition at line 343 of file pjsip_transport_management.c.

Referenced by ast_sip_destroy_transport_management(), and ast_sip_initialize_transport_management().

keepalive_interval

unsigned int keepalive_interval

static

The global interval at which to send keepalives.

Definition at line 49 of file pjsip_transport_management.c.

Referenced by ast_sip_destroy_transport_management(), keepalive_global_loaded(), keepalive_transport_thread(), and monitored_transport_state_callback().

keepalive_packet

const pj_str_t keepalive_packet = { "\r\n\r\n", 4 }

static

The keep alive packet to send.

Definition at line 37 of file pjsip_transport_management.c.

Referenced by keepalive_transport_send_keepalive().

keepalive_thread

pthread_t keepalive_thread = AST_PTHREADT_NULL

static

Thread keeping things alive.

Definition at line 46 of file pjsip_transport_management.c.

Referenced by ast_sip_destroy_transport_management(), and keepalive_global_loaded().

monitored_transport_reg

struct ast_sip_tpmgr_state_callback monitored_transport_reg

Initial value:

= {
    monitored_transport_state_callback,
}

Definition at line 257 of file pjsip_transport_management.c.

Referenced by ast_sip_destroy_transport_management(), and ast_sip_initialize_transport_management().

sched

struct ast_sched_context* sched

static

Scheduler context for timing out connections with no data received.

Definition at line 43 of file pjsip_transport_management.c.