res_pjsip_notify.c File Reference

#include "asterisk.h"
#include <pjsip.h>
#include <pjsip_ua.h>
#include "asterisk/app.h"
#include "asterisk/cli.h"
#include "asterisk/config.h"
#include "asterisk/manager.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/res_pjsip.h"
#include "asterisk/res_pjsip_session.h"
#include "asterisk/sorcery.h"

Include dependency graph for res_pjsip_notify.c:

Go to the source code of this file.

Data Structures
struct	notify_cfg
struct	notify_channel_data
struct	notify_data
struct	notify_option
struct	notify_option_item
struct	notify_uri_data

Macros
#define	CONTENT_SIZE   512
#define	CONTENT_TYPE_SIZE   64

Typedefs
typedef struct notify_channel_data *(*	task_channel_data_create) (struct ast_sip_session *session, void *info)
typedef struct notify_data *(*	task_data_create) (struct ast_sip_endpoint *, void *info)
typedef struct notify_uri_data *(*	task_uri_data_create) (const char *uri, void *info)

Enumerations
enum	notify_result {   SUCCESS , INVALID_ENDPOINT , INVALID_CHANNEL , ALLOC_ERROR ,   TASK_PUSH_ERROR }
enum	notify_type { NOTIFY_ENDPOINT , NOTIFY_URI , NOTIFY_CHANNEL }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
	AO2_GLOBAL_OBJ_STATIC (globals)
static int	app_notify (struct ast_channel *chan, const char *data)
	Application entry point to send a SIP notify to an endpoint.
struct ast_module *	AST_MODULE_SELF_SYM (void)
static void	build_ami_notify (pjsip_tx_data *tdata, void *info)
static void	build_cli_notify (pjsip_tx_data *tdata, void *info)
static void	build_notify (pjsip_tx_data *tdata, const char *name, const char *value, struct ast_str **content_type, struct ast_str **content)
static void	build_notify_body (pjsip_tx_data *tdata, struct ast_str *content_type, struct ast_str *content)
static char *	cli_complete_endpoint (const char *word)
static char *	cli_complete_notify (struct ast_cli_args *a)
static char *	cli_notify (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CONFIG_INFO_STANDARD (notify_cfg, globals, notify_cfg_alloc,.files=ACO_FILES(&module_conf))
static struct ast_variable *	headers_to_variables (const char *headers)
	Convert headers string such as "Event=hold&Event=answer&..." into ast variable list.
static int	load_module (void)
static int	manager_notify (struct mansession *s, const struct message *m)
static void	manager_notify_channel (struct mansession *s, const struct message *m, const char *channel)
static void	manager_notify_endpoint (struct mansession *s, const struct message *m, const char *endpoint_name)
static void	manager_notify_uri (struct mansession *s, const struct message *m, const char *uri)
static void	manager_send_response (struct mansession *s, const struct message *m, enum notify_type type, enum notify_result res, struct ast_variable *vars, const char *endpoint_name)
static int	multiple_headers_allowed (const char *name)
static int	not_allowed (const char *name)
static struct notify_channel_data *	notify_ami_channel_data_create (struct ast_sip_session *session, void *info)
static void	notify_ami_channel_data_destroy (void *obj)
static struct notify_data *	notify_ami_data_create (struct ast_sip_endpoint *endpoint, void *info)
static void	notify_ami_data_destroy (void *obj)
static struct notify_uri_data *	notify_ami_uri_data_create (const char *uri, void *info)
static void	notify_ami_uri_data_destroy (void *obj)
static void *	notify_cfg_alloc (void)
static void	notify_cfg_destroy (void *obj)
static int	notify_channel (void *obj)
static struct notify_channel_data *	notify_cli_channel_data_create (struct ast_sip_session *session, void *info)
static void	notify_cli_channel_data_destroy (void *obj)
static struct notify_data *	notify_cli_data_create (struct ast_sip_endpoint *endpoint, void *info)
static void	notify_cli_data_destroy (void *obj)
static struct notify_uri_data *	notify_cli_uri_data_create (const char *uri, void *info)
static void	notify_cli_uri_data_destroy (void *obj)
static int	notify_contact (void *obj, void *arg, int flags)
static int	notify_endpoint (void *obj)
static void *	notify_option_alloc (const char *category)
static int	notify_option_cmp (void *obj, void *arg, int flags)
static void	notify_option_destroy (void *obj)
static void *	notify_option_find (struct ao2_container *container, const char *category)
static int	notify_option_handler (const struct aco_option *opt, struct ast_variable *var, void *obj)
static int	notify_option_hash (const void *obj, int flags)
static int	notify_uri (void *obj)
static enum notify_result	push_notify (const char *endpoint_name, void *info, task_data_create data_create)
static enum notify_result	push_notify_channel (const char *channel_name, void *info, task_channel_data_create data_create)
static enum notify_result	push_notify_uri (const char *uri, void *info, task_uri_data_create data_create)
static int	reload_module (void)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "CLI/AMI PJSIP NOTIFY 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_APP_DEPEND, .requires = "res_pjsip", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_cli_entry	cli_options []
static struct aco_file	module_conf
static const char	notify_config [] = "pjsip_notify.conf"
static struct aco_type	notify_option
static struct aco_type *	notify_options [] = ACO_TYPES(&notify_option)

Macro Definition Documentation

CONTENT_SIZE

#define CONTENT_SIZE   512

Definition at line 128 of file res_pjsip_notify.c.

CONTENT_TYPE_SIZE

#define CONTENT_TYPE_SIZE   64

Definition at line 127 of file res_pjsip_notify.c.

Typedef Documentation

task_channel_data_create

typedef struct notify_channel_data *(* task_channel_data_create) (struct ast_sip_session *session, void *info)

Definition at line 794 of file res_pjsip_notify.c.

task_data_create

typedef struct notify_data *(* task_data_create) (struct ast_sip_endpoint *, void *info)

Definition at line 794 of file res_pjsip_notify.c.

task_uri_data_create

typedef struct notify_uri_data *(* task_uri_data_create) (const char *uri, void *info)

Definition at line 794 of file res_pjsip_notify.c.

Enumeration Type Documentation

notify_result

enum notify_result

Enumerator
SUCCESS
INVALID_ENDPOINT
INVALID_CHANNEL
ALLOC_ERROR
TASK_PUSH_ERROR

Definition at line 825 of file res_pjsip_notify.c.

                   {
    SUCCESS,
    INVALID_ENDPOINT,
    INVALID_CHANNEL,
    ALLOC_ERROR,
    TASK_PUSH_ERROR
};

notify_type

enum notify_type

Enumerator
NOTIFY_ENDPOINT
NOTIFY_URI
NOTIFY_CHANNEL

Definition at line 1135 of file res_pjsip_notify.c.

                 {
    NOTIFY_ENDPOINT,
    NOTIFY_URI,
    NOTIFY_CHANNEL,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1444 of file res_pjsip_notify.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1444 of file res_pjsip_notify.c.

AO2_GLOBAL_OBJ_STATIC()

AO2_GLOBAL_OBJ_STATIC

(

globals

)

app_notify()

static int app_notify ( struct ast_channel *  chan, const char *  data  )

static

Application entry point to send a SIP notify to an endpoint.

Definition at line 1335 of file res_pjsip_notify.c.

{
    RAII_VAR(struct notify_cfg *, cfg, NULL, ao2_cleanup);
    RAII_VAR(struct notify_option *, option, NULL, ao2_cleanup);
 
    struct ast_variable *varlist = NULL;
    char *tmp;
    int res;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(to);
        AST_APP_ARG(headers);
    );
 
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "PJSIPNotify requires arguments (to, &header=...)\n");
        return -1;
    }
 
    tmp = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, tmp);
    cfg = ao2_global_obj_ref(globals);
 
    if (!(option = notify_option_find(cfg->notify_options, args.headers))) {
        /* If the app is passed a list of headers, use the notify_ami_*_data_create
           functions as the option data is handled the same way as the ami command. */
        varlist = headers_to_variables(args.headers);
        if (ast_strlen_zero(args.to)) {
            res = push_notify_channel(ast_channel_name(chan), varlist, notify_ami_channel_data_create);
        } else {
            res = push_notify_uri(args.to, varlist, notify_ami_uri_data_create);
        }
    } else {
        /* If the app is passed a configured notify option, use the notify_cli_*_data_create
           functions as the option data is handled the same way as the cli command. */
        if (ast_strlen_zero(args.to)) {
            res = push_notify_channel(ast_channel_name(chan), option, notify_cli_channel_data_create);
        } else {
            res = push_notify_uri(args.to, option, notify_cli_uri_data_create);
        }
    }
 
    switch (res) {
        case INVALID_CHANNEL:
        case INVALID_ENDPOINT:
        case ALLOC_ERROR:
            res = -1;
            ast_variables_destroy(varlist);
            break;
        case TASK_PUSH_ERROR:
            /* Don't need to destroy vars since it is handled by cleanup in push_notify_channel */
            res = -1;
            break;
        case SUCCESS:
            res = 0;
            break;
    }
 
    return res;
}

References ALLOC_ERROR, ao2_cleanup, ao2_global_obj_ref, args, AST_APP_ARG, ast_channel_name(), AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_variables_destroy(), globals, headers_to_variables(), INVALID_CHANNEL, INVALID_ENDPOINT, LOG_WARNING, notify_ami_channel_data_create(), notify_ami_uri_data_create(), notify_cli_channel_data_create(), notify_cli_uri_data_create(), notify_option_find(), NULL, push_notify_channel(), push_notify_uri(), RAII_VAR, SUCCESS, and TASK_PUSH_ERROR.

Referenced by load_module().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1444 of file res_pjsip_notify.c.

build_ami_notify()

static void build_ami_notify ( pjsip_tx_data *  tdata, void *  info  )

static

Definition at line 665 of file res_pjsip_notify.c.

{
    struct ast_variable *vars = info;
    RAII_VAR(struct ast_str *, content_type, NULL, ast_free);
    RAII_VAR(struct ast_str *, content, NULL, ast_free);
    struct ast_variable *i;
 
    for (i = vars; i; i = i->next) {
        if (!strcasecmp(i->name, "Content-Length")) {
            ast_log(LOG_NOTICE, "It is not necessary to specify Content-Length, ignoring.\n");
            continue;
        }
        build_notify(tdata, i->name, i->value,
                 &content_type, &content);
    }
 
    build_notify_body(tdata, content_type, content);
}

References ast_free, ast_log, build_notify(), build_notify_body(), LOG_NOTICE, ast_variable::name, ast_variable::next, NULL, RAII_VAR, and ast_variable::value.

Referenced by notify_ami_channel_data_create(), notify_ami_data_create(), and notify_ami_uri_data_create().

build_cli_notify()

static void build_cli_notify ( pjsip_tx_data *  tdata, void *  info  )

static

Definition at line 641 of file res_pjsip_notify.c.

{
    struct notify_option *option = info;
    RAII_VAR(struct ast_str *, content_type, NULL, ast_free);
    RAII_VAR(struct ast_str *, content, NULL, ast_free);
 
    struct notify_option_item *item;
    struct ao2_iterator i = ao2_iterator_init(option->items, 0);
 
    while ((item = ao2_iterator_next(&i))) {
        build_notify(tdata, item->name, item->value,
                 &content_type, &content);
        ao2_cleanup(item);
    }
    ao2_iterator_destroy(&i);
 
    build_notify_body(tdata, content_type, content);
}

References ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_free, build_notify(), build_notify_body(), item, notify_option::items, aco_type::name, NULL, and RAII_VAR.

Referenced by notify_cli_channel_data_create(), notify_cli_data_create(), and notify_cli_uri_data_create().

build_notify()

static void build_notify ( pjsip_tx_data *  tdata, const char *  name, const char *  value, struct ast_str **  content_type, struct ast_str **  content  )

static

Definition at line 596 of file res_pjsip_notify.c.

{
    if (not_allowed(name)) {
        ast_log(LOG_WARNING, "Cannot specify %s header, "
            "ignoring\n", name);
        return;
    }
 
    if (!strcasecmp(name, "Content-type")) {
        if (!(*content_type)) {
            *content_type = ast_str_create(CONTENT_TYPE_SIZE);
        }
        ast_str_set(content_type, 0,"%s", value);
    } else if (!strcasecmp(name, "Content")) {
        if (!(*content)) {
            *content = ast_str_create(CONTENT_SIZE);
        }
 
        if (ast_str_strlen(*content)) {
            ast_str_append(content, 0, "\r\n");
        }
        ast_str_append(content, 0, "%s", value);
    } else {
        /* See if there is an existing one */
        if (!multiple_headers_allowed(name)) {
            pj_str_t hdr_name;
            pj_cstr(&hdr_name, name);
 
            if (pjsip_msg_find_hdr_by_name(tdata->msg, &hdr_name, NULL)) {
                ast_log(LOG_ERROR, "Only one '%s' header can be added to a NOTIFY, "
                        "ignoring \"%s: %s\"\n", name, name, value);
                return;
            }
        }
 
        ast_sip_add_header(tdata, name, value);
    }
}

References ast_log, ast_sip_add_header(), ast_str_append(), ast_str_create, ast_str_set(), ast_str_strlen(), CONTENT_SIZE, CONTENT_TYPE_SIZE, LOG_ERROR, LOG_WARNING, multiple_headers_allowed(), name, not_allowed(), NULL, and value.

Referenced by build_ami_notify(), and build_cli_notify().

build_notify_body()

static void build_notify_body ( pjsip_tx_data *  tdata, struct ast_str *  content_type, struct ast_str *  content  )

static

Definition at line 572 of file res_pjsip_notify.c.

{
    if (content_type) {
        char *p;
        struct ast_sip_body body;
 
        if (content) {
            body.body_text = ast_str_buffer(content);
        }
 
        body.type = ast_str_buffer(content_type);
        if ((p = strchr(body.type, '/'))) {
            *p++ = '\0';
            body.subtype = p;
        }
        ast_sip_add_body(tdata, &body);
    }
}

References ast_sip_add_body(), ast_str_buffer(), ast_sip_body::body_text, ast_sip_body::subtype, and ast_sip_body::type.

Referenced by build_ami_notify(), and build_cli_notify().

cli_complete_endpoint()

static char * cli_complete_endpoint ( const char *  word )

static

Definition at line 956 of file res_pjsip_notify.c.

{
    int wordlen = strlen(word);
    struct ao2_container * endpoints;
    struct ast_sip_endpoint *endpoint;
    struct ao2_iterator i;
 
    endpoints = ast_sorcery_retrieve_by_prefix(ast_sip_get_sorcery(),
        "endpoint", word, wordlen);
    if (endpoints == NULL) {
        return NULL;
    }
 
    i = ao2_iterator_init(endpoints, 0);
    while ((endpoint = ao2_iterator_next(&i))) {
        ast_cli_completion_add(
            ast_strdup(ast_sorcery_object_get_id(endpoint)));
        ao2_cleanup(endpoint);
    }
    ao2_iterator_destroy(&i);
 
    ao2_ref(endpoints, -1);
 
    return NULL;
}

References ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli_completion_add(), ast_sip_get_sorcery(), ast_sorcery_object_get_id(), ast_sorcery_retrieve_by_prefix(), ast_strdup, endpoints, and NULL.

Referenced by cli_complete_notify().

cli_complete_notify()

static char * cli_complete_notify ( struct ast_cli_args *  a )

static

Definition at line 986 of file res_pjsip_notify.c.

{
    char *c = NULL;
 
    if (a->pos == 3) {
        int which = 0;
        int wordlen = strlen(a->word);
 
        RAII_VAR(struct notify_cfg *, cfg,
             ao2_global_obj_ref(globals), ao2_cleanup);
        struct notify_option *option;
 
        /* do completion for notify type */
        struct ao2_iterator i = ao2_iterator_init(cfg->notify_options, 0);
        while ((option = ao2_iterator_next(&i))) {
            if (!strncasecmp(a->word, option->name, wordlen) && ++which > a->n) {
                c = ast_strdup(option->name);
            }
 
            ao2_cleanup(option);
            if (c) {
                break;
            }
        }
        ao2_iterator_destroy(&i);
        return c;
    }
 
    if (a->pos == 4) {
        int wordlen = strlen(a->word);
 
        if (ast_strlen_zero(a->word)) {
            if (a->n == 0) {
                c = ast_strdup("endpoint");
            } else if (a->n == 1) {
                c = ast_strdup("uri");
            } else if (a->n == 2) {
                c = ast_strdup("channel");
            }
        } else if (a->n == 0) {
            if (!strncasecmp(a->word, "endpoint", wordlen)) {
                c = ast_strdup("endpoint");
            } else if (!strncasecmp(a->word, "uri", wordlen)) {
                c = ast_strdup("uri");
            } else if (!strncasecmp(a->word, "channel", wordlen)) {
                c = ast_strdup("channel");
            }
        }
 
        return c;
    }
 
    if (a->pos > 4) {
        if (!strcasecmp(a->argv[4], "endpoint")) {
            return cli_complete_endpoint(a->word);
        } else if (!strcasecmp(a->argv[4], "channel")) {
            return ast_complete_channels(a->line, a->word, a->pos, a->n, 5);
        }
    }
    return NULL;
}

References a, ao2_cleanup, ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_complete_channels(), ast_strdup, ast_strlen_zero(), c, cli_complete_endpoint(), globals, notify_option::name, NULL, and RAII_VAR.

Referenced by cli_notify().

cli_notify()

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

static

Definition at line 1056 of file res_pjsip_notify.c.

{
    RAII_VAR(struct notify_cfg *, cfg, NULL, ao2_cleanup);
    RAII_VAR(struct notify_option *, option, NULL, ao2_cleanup);
 
    int i;
    int using_uri = 0;
    int using_channel = 0;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "pjsip send notify";
        e->usage =
            "Usage: pjsip send notify <type> {endpoint|uri|channel} <peer> [<peer>...]\n"
            "       Send a NOTIFY request to an endpoint\n"
            "       Message types are defined in pjsip_notify.conf\n";
        return NULL;
    case CLI_GENERATE:
        return cli_complete_notify(a);
    }
 
    if (a->argc < 6) {
        return CLI_SHOWUSAGE;
    }
 
    if (!strcasecmp(a->argv[4], "uri")) {
        using_uri = 1;
    } else if (!strcasecmp(a->argv[4], "channel")) {
        using_channel = 1;
    } else if (strcasecmp(a->argv[4], "endpoint")) {
        return CLI_SHOWUSAGE;
    }
 
    cfg = ao2_global_obj_ref(globals);
 
    if (!(option = notify_option_find(cfg->notify_options, a->argv[3])))
    {
        ast_cli(a->fd, "Unable to find notify type '%s'\n",
            a->argv[3]);
        return CLI_FAILURE;
    }
 
    for (i = 5; i < a->argc; ++i) {
        enum notify_result result;
        ast_cli(a->fd, "Sending NOTIFY of type '%s' to '%s'\n",
            a->argv[3], a->argv[i]);
 
        if (using_uri) {
            result = push_notify_uri(a->argv[i], option, notify_cli_uri_data_create);
        } else if (using_channel) {
            result = push_notify_channel(a->argv[i], option, notify_cli_channel_data_create);
        } else {
            result = push_notify(a->argv[i], option, notify_cli_data_create);
        }
        switch(result) {
        case INVALID_ENDPOINT:
            ast_cli(a->fd, "Unable to retrieve endpoint %s\n", a->argv[i]);
            break;
        case INVALID_CHANNEL:
            ast_cli(a->fd, "Unable to find channel %s\n", a->argv[i]);
            break;
        case ALLOC_ERROR:
            ast_cli(a->fd, "Unable to allocate NOTIFY task data\n");
            return CLI_FAILURE;
        case TASK_PUSH_ERROR:
            ast_cli(a->fd, "Unable to push NOTIFY task\n");
            return CLI_FAILURE;
        default:
            break;
        }
    }
 
    return CLI_SUCCESS;
}

References a, ALLOC_ERROR, ao2_cleanup, ao2_global_obj_ref, ast_cli(), cli_complete_notify(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, globals, INVALID_CHANNEL, INVALID_ENDPOINT, notify_cli_channel_data_create(), notify_cli_data_create(), notify_cli_uri_data_create(), notify_option_find(), NULL, push_notify(), push_notify_channel(), push_notify_uri(), RAII_VAR, result, TASK_PUSH_ERROR, and ast_cli_entry::usage.

CONFIG_INFO_STANDARD()

CONFIG_INFO_STANDARD	(	notify_cfg	,
		globals	,
		notify_cfg_alloc	,
		.	files = ACO_FILES(&module_conf)
	)

headers_to_variables()

static struct ast_variable * headers_to_variables ( const char *  headers )

static

Convert headers string such as "Event=hold&Event=answer&..." into ast variable list.

Definition at line 1307 of file res_pjsip_notify.c.

{
    struct ast_variable *varlist = NULL;
    struct ast_variable *var;
    char *cur;
    char *header;
 
    cur = (char *)headers;
 
    while( (header = strsep(&cur, "&")) ) {
        char *name;
        char *value;
 
        name = value = header;
        strsep(&value, "=");
 
        if (!value || ast_strlen_zero(name)) {
            continue;
        }
 
        var = ast_variable_new(name, value, "");
        var->next = varlist;
        varlist = var;
    }
    return varlist;
}

References ast_strlen_zero(), ast_variable_new, name, NULL, strsep(), value, and var.

Referenced by app_notify().

load_module()

static int load_module ( void  )

static

Definition at line 1396 of file res_pjsip_notify.c.

{
    if (aco_info_init(&notify_cfg)) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    aco_option_register_custom(&notify_cfg, "", ACO_PREFIX, notify_options,
                   "", notify_option_handler, 0);
 
    if (aco_process_config(&notify_cfg, 0)) {
        aco_info_destroy(&notify_cfg);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    ast_cli_register_multiple(cli_options, ARRAY_LEN(cli_options));
    ast_manager_register_xml("PJSIPNotify", EVENT_FLAG_SYSTEM, manager_notify);
    ast_register_application_xml("PJSIPNotify", app_notify);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References aco_info_destroy(), aco_info_init(), aco_option_register_custom, ACO_PREFIX, aco_process_config(), app_notify(), ARRAY_LEN, ast_cli_register_multiple, ast_manager_register_xml, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_register_application_xml, cli_options, EVENT_FLAG_SYSTEM, manager_notify(), notify_option_handler(), and notify_options.

manager_notify()

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

static

Definition at line 1264 of file res_pjsip_notify.c.

{
    const char *endpoint_name = astman_get_header(m, "Endpoint");
    const char *uri = astman_get_header(m, "URI");
    const char *channel = astman_get_header(m, "Channel");
    const char *variables = astman_get_header(m, "Variable");
    const char *option = astman_get_header(m, "Option");
    int count = 0;
 
    if (!ast_strlen_zero(endpoint_name)) {
        ++count;
    }
    if (!ast_strlen_zero(uri)) {
        ++count;
    }
    if (!ast_strlen_zero(channel)) {
        ++count;
    }
 
    if ((!ast_strlen_zero(option) && !ast_strlen_zero(variables)) || (ast_strlen_zero(option) && ast_strlen_zero(variables))) {
        astman_send_error(s, m,
            "PJSIPNotify requires either an Option or Variable(s)."
            "You must use only one of them.");
    } else if (1 < count) {
        astman_send_error(s, m,
            "PJSIPNotify requires either an endpoint name, a SIP URI, or a channel.  "
            "You must use only one of them.");
    } else if (!ast_strlen_zero(endpoint_name)) {
        manager_notify_endpoint(s, m, endpoint_name);
    } else if (!ast_strlen_zero(uri)) {
        manager_notify_uri(s, m, uri);
    } else if (!ast_strlen_zero(channel)) {
        manager_notify_channel(s, m, channel);
    } else {
        astman_send_error(s, m,
            "PJSIPNotify requires either an endpoint name, a SIP URI, or a channel.");
    }
 
    return 0;
}

References ast_strlen_zero(), astman_get_header(), astman_send_error(), manager_notify_channel(), manager_notify_endpoint(), and manager_notify_uri().

Referenced by load_module().

manager_notify_channel()

static void manager_notify_channel ( struct mansession *  s, const struct message *  m, const char *  channel  )

static

Definition at line 1248 of file res_pjsip_notify.c.

{
    enum notify_result res;
    struct ast_variable *vars = NULL;
 
    vars = astman_get_variables_order(m, ORDER_NATURAL);
    res = push_notify_channel(channel, vars, notify_ami_channel_data_create);
 
    manager_send_response(s, m, NOTIFY_CHANNEL, res, vars, NULL);
}

References astman_get_variables_order(), manager_send_response(), notify_ami_channel_data_create(), NOTIFY_CHANNEL, NULL, ORDER_NATURAL, and push_notify_channel().

Referenced by manager_notify().

manager_notify_endpoint()

static void manager_notify_endpoint ( struct mansession *  s, const struct message *  m, const char *  endpoint_name  )

static

Definition at line 1180 of file res_pjsip_notify.c.

{
    RAII_VAR(struct notify_cfg *, cfg, NULL, ao2_cleanup);
    RAII_VAR(struct notify_option *, option, NULL, ao2_cleanup);
    struct ast_variable *vars = NULL;
    enum notify_result res;
    const char *option_name = astman_get_header(m, "Option");
 
    if (!ast_strlen_zero(option_name) && (cfg = ao2_global_obj_ref(globals)) && !(option = notify_option_find(cfg->notify_options, option_name))) {
        astman_send_error_va(s, m, "Unable to find notify type '%s'\n", option_name);
        return;
    }
    if (!option) {
        vars = astman_get_variables_order(m, ORDER_NATURAL);
    }
 
    if (!strncasecmp(endpoint_name, "sip/", 4)) {
        endpoint_name += 4;
    }
 
    if (!strncasecmp(endpoint_name, "pjsip/", 6)) {
        endpoint_name += 6;
    }
 
    if (option) {
        res = push_notify(endpoint_name, option, notify_cli_data_create); /* The CLI version happens to be suitable for options. */
    } else {
        res = push_notify(endpoint_name, vars, notify_ami_data_create);
    }
 
    manager_send_response(s, m, NOTIFY_ENDPOINT, res, vars, endpoint_name);
}

References ao2_cleanup, ao2_global_obj_ref, ast_strlen_zero(), astman_get_header(), astman_get_variables_order(), astman_send_error_va(), globals, manager_send_response(), notify_ami_data_create(), notify_cli_data_create(), NOTIFY_ENDPOINT, notify_option_find(), NULL, ORDER_NATURAL, push_notify(), and RAII_VAR.

Referenced by manager_notify().

manager_notify_uri()

static void manager_notify_uri ( struct mansession *  s, const struct message *  m, const char *  uri  )

static

Definition at line 1218 of file res_pjsip_notify.c.

{
    RAII_VAR(struct notify_cfg *, cfg, NULL, ao2_cleanup);
    RAII_VAR(struct notify_option *, option, NULL, ao2_cleanup);
    enum notify_result res;
    const char *option_name = astman_get_header(m, "Option");
    struct ast_variable *vars = NULL;
 
    if (!ast_strlen_zero(option_name) && (cfg = ao2_global_obj_ref(globals)) && !(option = notify_option_find(cfg->notify_options, option_name))) {
        astman_send_error_va(s, m, "Unable to find notify type '%s'\n", option_name);
        return;
    }
    if (!option) {
        vars = astman_get_variables_order(m, ORDER_NATURAL);
    }
 
    if (option) {
        res = push_notify_uri(uri, option, notify_cli_uri_data_create);
    } else {
        res = push_notify_uri(uri, vars, notify_ami_uri_data_create);
    }
 
    manager_send_response(s, m, NOTIFY_URI, res, vars, NULL);
}

References ao2_cleanup, ao2_global_obj_ref, ast_strlen_zero(), astman_get_header(), astman_get_variables_order(), astman_send_error_va(), globals, manager_send_response(), notify_ami_uri_data_create(), notify_cli_uri_data_create(), notify_option_find(), NOTIFY_URI, NULL, ORDER_NATURAL, push_notify_uri(), and RAII_VAR.

Referenced by manager_notify().

manager_send_response()

static void manager_send_response ( struct mansession *  s, const struct message *  m, enum notify_type  type, enum notify_result  res, struct ast_variable *  vars, const char *  endpoint_name  )

static

Definition at line 1141 of file res_pjsip_notify.c.

{
    switch (res) {
    case INVALID_CHANNEL:
        if (type == NOTIFY_CHANNEL) {
            ast_variables_destroy(vars);
            astman_send_error(s, m, "Channel not found");
        } else {
            /* Shouldn't be possible. */
            ast_assert(0);
        }
        break;
    case INVALID_ENDPOINT:
        if (type == NOTIFY_ENDPOINT) {
            ast_variables_destroy(vars);
            astman_send_error_va(s, m, "Unable to retrieve endpoint %s", endpoint_name);
        } else {
            /* Shouldn't be possible. */
            ast_assert(0);
        }
        break;
    case ALLOC_ERROR:
        ast_variables_destroy(vars);
        astman_send_error(s, m, "Unable to allocate NOTIFY task data");
        break;
    case TASK_PUSH_ERROR:
        /* Don't need to destroy vars since it is handled by cleanup in push_notify, push_notify_uri, etc. */
        astman_send_error(s, m, "Unable to push Notify task");
        break;
    case SUCCESS:
        astman_send_ack(s, m, "NOTIFY sent");
        break;
    }
}

References ALLOC_ERROR, ast_assert, ast_variables_destroy(), astman_send_ack(), astman_send_error(), astman_send_error_va(), INVALID_CHANNEL, INVALID_ENDPOINT, NOTIFY_CHANNEL, NOTIFY_ENDPOINT, SUCCESS, TASK_PUSH_ERROR, and type.

Referenced by manager_notify_channel(), manager_notify_endpoint(), and manager_notify_uri().

multiple_headers_allowed()

static int multiple_headers_allowed ( const char *  name )

static

Definition at line 561 of file res_pjsip_notify.c.

{
    /* This can be extended to include additional headers */
    return strcasecmp("Event", name);
}

References name.

Referenced by build_notify().

not_allowed()

static int not_allowed ( const char *  name )

static

Definition at line 534 of file res_pjsip_notify.c.

{
    int i;
    static const char *names[] = {
        "Call-ID",
        "Contact",
        "CSeq",
        "To",
        "From",
        "Record-Route",
        "Route",
        "Request-URI",
        "Via",
    };
 
    for (i = 0; i < ARRAY_LEN(names); ++i) {
        if (!strcasecmp(name, names[i])) {
            return 1;
        }
    }
    return 0;
}

References ARRAY_LEN, and name.

Referenced by build_notify().

notify_ami_channel_data_create()

static struct notify_channel_data * notify_ami_channel_data_create ( struct ast_sip_session *  session, void *  info  )

static

Definition at line 508 of file res_pjsip_notify.c.

{
    struct notify_channel_data *data;
 
    data = ao2_alloc_options(sizeof(*data), notify_ami_channel_data_destroy,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!data) {
        return NULL;
    }
 
    data->session = session;
    data->info = info;
    data->build_notify = build_ami_notify;
 
    return data;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, build_ami_notify(), notify_channel_data::build_notify, notify_channel_data::info, notify_ami_channel_data_destroy(), NULL, notify_channel_data::session, and session.

Referenced by app_notify(), and manager_notify_channel().

notify_ami_channel_data_destroy()

static void notify_ami_channel_data_destroy ( void *  obj )

static

Definition at line 446 of file res_pjsip_notify.c.

{
    struct notify_channel_data *data = obj;
    struct ast_variable *info = data->info;
 
    ao2_cleanup(data->session);
    ast_variables_destroy(info);
}

References ao2_cleanup, ast_variables_destroy(), notify_channel_data::info, and notify_channel_data::session.

Referenced by notify_ami_channel_data_create().

notify_ami_data_create()

static struct notify_data * notify_ami_data_create ( struct ast_sip_endpoint *  endpoint, void *  info  )

static

Definition at line 461 of file res_pjsip_notify.c.

{
    struct notify_data *data = ao2_alloc(sizeof(*data),
                         notify_ami_data_destroy);
    if (!data) {
        return NULL;
    }
 
    data->endpoint = endpoint;
    ao2_ref(data->endpoint, +1);
 
    data->info = info;
    data->build_notify = build_ami_notify;
 
    return data;
}

References ao2_alloc, ao2_ref, build_ami_notify(), notify_data::build_notify, notify_data::endpoint, notify_data::info, notify_ami_data_destroy(), and NULL.

Referenced by manager_notify_endpoint().

notify_ami_data_destroy()

static void notify_ami_data_destroy ( void *  obj )

static

Definition at line 420 of file res_pjsip_notify.c.

{
    struct notify_data *data = obj;
    struct ast_variable *info = data->info;
 
    ao2_cleanup(data->endpoint);
    ast_variables_destroy(info);
}

References ao2_cleanup, ast_variables_destroy(), notify_data::endpoint, and notify_data::info.

Referenced by notify_ami_data_create().

notify_ami_uri_data_create()

static struct notify_uri_data * notify_ami_uri_data_create ( const char *  uri, void *  info  )

static

Definition at line 483 of file res_pjsip_notify.c.

{
    struct notify_uri_data *data = ao2_alloc(sizeof(*data),
                            notify_ami_uri_data_destroy);
    if (!data) {
        return NULL;
    }
 
    data->uri = ast_strdup(uri);
    if (!data->uri) {
        ao2_ref(data, -1);
        return NULL;
    }
 
    data->info = info;
    data->build_notify = build_ami_notify;
 
    return data;
}

References ao2_alloc, ao2_ref, ast_strdup, build_ami_notify(), notify_uri_data::build_notify, notify_uri_data::info, notify_ami_uri_data_destroy(), NULL, and notify_uri_data::uri.

Referenced by app_notify(), and manager_notify_uri().

notify_ami_uri_data_destroy()

static void notify_ami_uri_data_destroy ( void *  obj )

static

Definition at line 433 of file res_pjsip_notify.c.

{
    struct notify_uri_data *data = obj;
    struct ast_variable *info = data->info;
 
    ast_free(data->uri);
    ast_variables_destroy(info);
}

References ast_free, ast_variables_destroy(), notify_uri_data::info, and notify_uri_data::uri.

Referenced by notify_ami_uri_data_create().

notify_cfg_alloc()

static void * notify_cfg_alloc ( void  )

static

Definition at line 233 of file res_pjsip_notify.c.

{
    struct notify_cfg *cfg;
 
    if (!(cfg = ao2_alloc(sizeof(*cfg), notify_cfg_destroy))) {
        return NULL;
    }
 
    cfg->notify_options = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_NOLOCK, 0,
        20, notify_option_hash, NULL, notify_option_cmp);
    if (!cfg->notify_options) {
        ao2_cleanup(cfg);
        return NULL;
    }
 
    return cfg;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_cleanup, ao2_container_alloc_hash, notify_cfg_destroy(), notify_option_cmp(), notify_option_hash(), notify_cfg::notify_options, and NULL.

notify_cfg_destroy()

static void notify_cfg_destroy ( void *  obj )

static

Definition at line 227 of file res_pjsip_notify.c.

{
    struct notify_cfg *cfg = obj;
    ao2_cleanup(cfg->notify_options);
}

References ao2_cleanup, and notify_cfg::notify_options.

Referenced by notify_cfg_alloc().

notify_channel()

static int notify_channel ( void *  obj )

static

Definition at line 794 of file res_pjsip_notify.c.

{
    RAII_VAR(struct notify_channel_data *, data, obj, ao2_cleanup);
    pjsip_tx_data *tdata;
    struct pjsip_dialog *dlg;
 
    if (!data->session->channel
        || !data->session->inv_session
        || data->session->inv_session->state < PJSIP_INV_STATE_EARLY
        || data->session->inv_session->state == PJSIP_INV_STATE_DISCONNECTED) {
        return -1;
    }
 
    ast_debug(1, "Sending notify on channel %s\n", ast_channel_name(data->session->channel));
 
    dlg = data->session->inv_session->dlg;
 
    if (ast_sip_create_request("NOTIFY", dlg, NULL, NULL, NULL, &tdata)) {
        return -1;
    }
 
    ast_sip_add_header(tdata, "Subscription-State", "terminated");
    data->build_notify(tdata, data->info);
 
    if (ast_sip_send_request(tdata, dlg, NULL, NULL, NULL)) {
        return -1;
    }
 
    return 0;
}

References ao2_cleanup, ast_channel_name(), ast_debug, ast_sip_add_header(), ast_sip_create_request(), ast_sip_send_request(), NULL, and RAII_VAR.

Referenced by build_calendar(), and push_notify_channel().

notify_cli_channel_data_create()

static struct notify_channel_data * notify_cli_channel_data_create ( struct ast_sip_session *  session, void *  info  )

static

Definition at line 397 of file res_pjsip_notify.c.

{
    struct notify_channel_data *data = ao2_alloc_options(sizeof(*data),
        notify_cli_channel_data_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
 
    if (!data) {
        return NULL;
    }
 
    data->session = session;
    data->info = info;
    ao2_ref(data->info, +1);
 
    data->build_notify = build_cli_notify;
 
    return data;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, build_cli_notify(), notify_channel_data::build_notify, notify_channel_data::info, notify_cli_channel_data_destroy(), NULL, notify_channel_data::session, and session.

Referenced by app_notify(), and cli_notify().

notify_cli_channel_data_destroy()

static void notify_cli_channel_data_destroy ( void *  obj )

static

Definition at line 327 of file res_pjsip_notify.c.

{
    struct notify_channel_data *data = obj;
 
    ao2_cleanup(data->info);
    ao2_cleanup(data->session);
}

References ao2_cleanup, notify_channel_data::info, and notify_channel_data::session.

Referenced by notify_cli_channel_data_create().

notify_cli_data_create()

static struct notify_data * notify_cli_data_create ( struct ast_sip_endpoint *  endpoint, void *  info  )

static

Definition at line 345 of file res_pjsip_notify.c.

{
    struct notify_data *data = ao2_alloc(sizeof(*data),
                         notify_cli_data_destroy);
    if (!data) {
        return NULL;
    }
 
    data->endpoint = endpoint;
    ao2_ref(data->endpoint, +1);
 
    data->info = info;
    ao2_ref(data->info, +1);
 
    data->build_notify = build_cli_notify;
 
    return data;
}

References ao2_alloc, ao2_ref, build_cli_notify(), notify_data::build_notify, notify_data::endpoint, notify_data::info, notify_cli_data_destroy(), and NULL.

Referenced by cli_notify(), and manager_notify_endpoint().

notify_cli_data_destroy()

static void notify_cli_data_destroy ( void *  obj )

static

Definition at line 291 of file res_pjsip_notify.c.

{
    struct notify_data *data = obj;
 
    ao2_cleanup(data->endpoint);
    ao2_cleanup(data->info);
}

References ao2_cleanup, notify_data::endpoint, and notify_data::info.

Referenced by notify_cli_data_create().

notify_cli_uri_data_create()

static struct notify_uri_data * notify_cli_uri_data_create ( const char *  uri, void *  info  )

static

Definition at line 369 of file res_pjsip_notify.c.

{
    struct notify_uri_data *data = ao2_alloc(sizeof(*data),
        notify_cli_uri_data_destroy);
 
    if (!data) {
        return NULL;
    }
 
    data->uri = ast_strdup(uri);
    if (!data->uri) {
        ao2_ref(data, -1);
        return NULL;
    }
 
    data->info = info;
    ao2_ref(data->info, +1);
 
    data->build_notify = build_cli_notify;
 
    return data;
}

References ao2_alloc, ao2_ref, ast_strdup, build_cli_notify(), notify_uri_data::build_notify, notify_uri_data::info, notify_cli_uri_data_destroy(), NULL, and notify_uri_data::uri.

Referenced by app_notify(), cli_notify(), and manager_notify_uri().

notify_cli_uri_data_destroy()

static void notify_cli_uri_data_destroy ( void *  obj )

static

Definition at line 319 of file res_pjsip_notify.c.

{
    struct notify_uri_data *data = obj;
 
    ast_free(data->uri);
    ao2_cleanup(data->info);
}

References ao2_cleanup, ast_free, notify_uri_data::info, and notify_uri_data::uri.

Referenced by notify_cli_uri_data_create().

notify_contact()

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

static

Definition at line 688 of file res_pjsip_notify.c.

{
    struct ast_sip_contact *contact = obj;
    struct notify_data *data = arg;
    pjsip_tx_data *tdata;
 
    if (ast_sip_create_request("NOTIFY", NULL, data->endpoint,
                   NULL, contact, &tdata)) {
        ast_log(LOG_WARNING, "SIP NOTIFY - Unable to create request for "
            "contact %s\n", contact->uri);
        return -1;
    }
 
    ast_sip_add_header(tdata, "Subscription-State", "terminated");
    data->build_notify(tdata, data->info);
 
    if (ast_sip_send_request(tdata, NULL, data->endpoint, NULL, NULL)) {
        ast_log(LOG_ERROR, "SIP NOTIFY - Unable to send request for "
            "contact %s\n", contact->uri);
        return -1;
    }
 
    return 0;
}

References ast_log, ast_sip_add_header(), ast_sip_create_request(), ast_sip_send_request(), notify_data::build_notify, notify_data::endpoint, notify_data::info, LOG_ERROR, LOG_WARNING, NULL, and ast_sip_contact::uri.

Referenced by notify_endpoint().

notify_endpoint()

static int notify_endpoint ( void *  obj )

static

Definition at line 720 of file res_pjsip_notify.c.

{
    RAII_VAR(struct notify_data *, data, obj, ao2_cleanup);
    char *aor_name, *aors;
 
    if (ast_strlen_zero(data->endpoint->aors)) {
        ast_log(LOG_WARNING, "Unable to NOTIFY - "
            "endpoint has no configured AORs\n");
        return -1;
    }
 
    aors = ast_strdupa(data->endpoint->aors);
 
    while ((aor_name = ast_strip(strsep(&aors, ",")))) {
        RAII_VAR(struct ast_sip_aor *, aor,
             ast_sip_location_retrieve_aor(aor_name), ao2_cleanup);
        RAII_VAR(struct ao2_container *, contacts, NULL, ao2_cleanup);
 
        if (!aor || !(contacts = ast_sip_location_retrieve_aor_contacts(aor))) {
            continue;
        }
 
        ao2_callback(contacts, OBJ_NODATA, notify_contact, data);
    }
 
    return 0;
}

References ao2_callback, ao2_cleanup, ast_log, ast_sip_location_retrieve_aor(), ast_sip_location_retrieve_aor_contacts(), ast_strdupa, ast_strip(), ast_strlen_zero(), LOG_WARNING, notify_contact(), NULL, OBJ_NODATA, RAII_VAR, and strsep().

Referenced by push_notify().

notify_option_alloc()

static void * notify_option_alloc ( const char *  category )

static

Definition at line 170 of file res_pjsip_notify.c.

{
    int category_size = strlen(category) + 1;
 
    struct notify_option *option = ao2_alloc(
        sizeof(*option) + category_size, notify_option_destroy);
 
    if (!option) {
        return NULL;
    }
 
    ast_copy_string(option->name, category, category_size);
 
    if (!(option->items = ao2_container_alloc_list(
              AO2_ALLOC_OPT_LOCK_NOLOCK,
              AO2_CONTAINER_ALLOC_OPT_DUPS_ALLOW, NULL, NULL))) {
        ao2_cleanup(option);
        return NULL;
    }
 
    return option;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_cleanup, ao2_container_alloc_list, AO2_CONTAINER_ALLOC_OPT_DUPS_ALLOW, ast_copy_string(), notify_option::items, notify_option::name, notify_option_destroy(), and NULL.

notify_option_cmp()

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

static

Definition at line 155 of file res_pjsip_notify.c.

{
    struct notify_option *option1 = obj;
    struct notify_option *option2 = arg;
    const char *key = flags & OBJ_KEY ? arg : option2->name;
 
    return strcasecmp(option1->name, key) ? 0 : CMP_MATCH;
}

References CMP_MATCH, notify_option::name, and OBJ_KEY.

Referenced by notify_cfg_alloc().

notify_option_destroy()

static void notify_option_destroy ( void *  obj )

static

Definition at line 164 of file res_pjsip_notify.c.

{
    struct notify_option *option = obj;
    ao2_cleanup(option->items);
}

References ao2_cleanup, and notify_option::items.

Referenced by notify_option_alloc().

notify_option_find()

static void * notify_option_find ( struct ao2_container *  container, const char *  category  )

static

Definition at line 193 of file res_pjsip_notify.c.

{
    return ao2_find(container, category, OBJ_KEY);
}

References ao2_find, container, and OBJ_KEY.

Referenced by app_notify(), cli_notify(), manager_notify_endpoint(), and manager_notify_uri().

notify_option_handler()

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

static

Definition at line 198 of file res_pjsip_notify.c.

{
    struct notify_option *option = obj;
 
    int name_size = strlen(var->name) + 1;
    int value_size = strlen(var->value) + 1;
 
    RAII_VAR(struct notify_option_item *, item,
         ao2_alloc(sizeof(*item) + name_size + value_size,
               NULL), ao2_cleanup);
 
    item->name = item->buf;
    item->value = item->buf + name_size;
 
    ast_copy_string(item->buf, var->name, name_size);
    ast_copy_string(item->buf + name_size, var->value, value_size);
 
    if (!ao2_link(option->items, item)) {
        return -1;
    }
 
    return 0;
}

References ao2_alloc, ao2_cleanup, ao2_link, ast_copy_string(), item, notify_option::items, aco_type::name, NULL, RAII_VAR, and var.

Referenced by load_module().

notify_option_hash()

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

static

Definition at line 149 of file res_pjsip_notify.c.

{
    const struct notify_option *option = obj;
    return ast_str_case_hash(flags & OBJ_KEY ? obj : option->name);
}

References ast_str_case_hash(), notify_option::name, and OBJ_KEY.

Referenced by notify_cfg_alloc().

notify_uri()

static int notify_uri ( void *  obj )

static

Definition at line 752 of file res_pjsip_notify.c.

{
    RAII_VAR(struct notify_uri_data *, data, obj, ao2_cleanup);
    RAII_VAR(struct ast_sip_endpoint *, endpoint,
        ast_sip_default_outbound_endpoint(), ao2_cleanup);
    pjsip_tx_data *tdata;
 
    if (!endpoint) {
        ast_log(LOG_WARNING, "No default outbound endpoint set, can not send "
            "NOTIFY requests to arbitrary URIs.\n");
        return -1;
    }
 
    if (ast_strlen_zero(data->uri)) {
        ast_log(LOG_WARNING, "Unable to NOTIFY - URI is blank.\n");
        return -1;
    }
 
    if (ast_sip_create_request("NOTIFY", NULL, endpoint,
                   data->uri, NULL, &tdata)) {
        ast_log(LOG_WARNING, "SIP NOTIFY - Unable to create request for "
            "uri %s\n", data->uri);
        return -1;
    }
 
    ast_sip_add_header(tdata, "Subscription-State", "terminated");
 
    data->build_notify(tdata, data->info);
 
    if (ast_sip_send_request(tdata, NULL, endpoint, NULL, NULL)) {
        ast_log(LOG_ERROR, "SIP NOTIFY - Unable to send request for "
            "uri %s\n", data->uri);
        return -1;
    }
 
    return 0;
}

References ao2_cleanup, ast_log, ast_sip_add_header(), ast_sip_create_request(), ast_sip_default_outbound_endpoint(), ast_sip_send_request(), ast_strlen_zero(), notify_data::endpoint, LOG_ERROR, LOG_WARNING, NULL, and RAII_VAR.

Referenced by push_notify_uri().

push_notify()

static enum notify_result push_notify ( const char *  endpoint_name, void *  info, task_data_create  data_create  )

static

Definition at line 846 of file res_pjsip_notify.c.

{
    RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
    struct notify_data *data;
 
    if (!(endpoint = ast_sorcery_retrieve_by_id(
              ast_sip_get_sorcery(), "endpoint", endpoint_name))) {
        return INVALID_ENDPOINT;
    }
 
    if (!(data = data_create(endpoint, info))) {
        return ALLOC_ERROR;
    }
 
    if (ast_sip_push_task(NULL, notify_endpoint, data)) {
        ao2_cleanup(data);
        return TASK_PUSH_ERROR;
    }
 
    return SUCCESS;
}

References ALLOC_ERROR, ao2_cleanup, ast_sip_get_sorcery(), ast_sip_push_task(), ast_sorcery_retrieve_by_id(), ast_sip_session::endpoint, notify_data::endpoint, notify_data::info, INVALID_ENDPOINT, notify_endpoint(), NULL, RAII_VAR, SUCCESS, and TASK_PUSH_ERROR.

Referenced by cli_notify(), and manager_notify_endpoint().

push_notify_channel()

static enum notify_result push_notify_channel ( const char *  channel_name, void *  info, task_channel_data_create  data_create  )

static

Definition at line 894 of file res_pjsip_notify.c.

{
    struct notify_channel_data *data;
    struct ast_channel *ch;
    struct ast_sip_session *session;
    struct ast_sip_channel_pvt *ch_pvt;
 
    /* note: this increases the refcount of the channel */
    ch = ast_channel_get_by_name(channel_name);
    if (!ch) {
        ast_debug(1, "No channel found with name %s", channel_name);
        return INVALID_CHANNEL;
    }
 
    if (strcmp(ast_channel_tech(ch)->type, "PJSIP")) {
        ast_log(LOG_WARNING, "Channel was a non-PJSIP channel: %s\n", channel_name);
        ast_channel_unref(ch);
        return INVALID_CHANNEL;
    }
 
    ast_channel_lock(ch);
    ch_pvt = ast_channel_tech_pvt(ch);
    session = ch_pvt->session;
 
    if (!session || !session->inv_session
            || session->inv_session->state < PJSIP_INV_STATE_EARLY
            || session->inv_session->state == PJSIP_INV_STATE_DISCONNECTED) {
        ast_debug(1, "No active session for channel %s\n", channel_name);
        ast_channel_unlock(ch);
        ast_channel_unref(ch);
        return INVALID_CHANNEL;
    }
 
    ao2_ref(session, +1);
    ast_channel_unlock(ch);
 
    /* don't keep a reference to the channel, we've got a reference to the session */
    ast_channel_unref(ch);
 
    /*
     * data_create will take ownership of the session,
     * and take care of releasing the ref.
     */
    data = data_create(session, info);
    if (!data) {
        ao2_ref(session, -1);
        return ALLOC_ERROR;
    }
 
    if (ast_sip_push_task(session->serializer, notify_channel, data)) {
        ao2_ref(data, -1);
        return TASK_PUSH_ERROR;
    }
 
    return SUCCESS;
}

References ALLOC_ERROR, ao2_ref, ast_channel_get_by_name(), ast_channel_lock, ast_channel_tech_pvt(), ast_channel_unlock, ast_channel_unref, ast_debug, ast_log, ast_sip_push_task(), INVALID_CHANNEL, LOG_WARNING, notify_channel(), ast_sip_channel_pvt::session, session, SUCCESS, TASK_PUSH_ERROR, and type.

Referenced by app_notify(), cli_notify(), and manager_notify_channel().

push_notify_uri()

static enum notify_result push_notify_uri ( const char *  uri, void *  info, task_uri_data_create  data_create  )

static

Definition at line 873 of file res_pjsip_notify.c.

{
    struct notify_uri_data *data;
 
    if (!(data = data_create(uri, info))) {
        return ALLOC_ERROR;
    }
 
    if (ast_sip_push_task(NULL, notify_uri, data)) {
        ao2_cleanup(data);
        return TASK_PUSH_ERROR;
    }
 
    return SUCCESS;
}

References ALLOC_ERROR, ao2_cleanup, ast_sip_push_task(), notify_uri_data::info, notify_uri(), NULL, SUCCESS, TASK_PUSH_ERROR, and notify_uri_data::uri.

Referenced by app_notify(), cli_notify(), and manager_notify_uri().

reload_module()

static int reload_module ( void  )

static

Definition at line 1417 of file res_pjsip_notify.c.

{
    if (aco_process_config(&notify_cfg, 1) == ACO_PROCESS_ERROR) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    return 0;
}

References aco_process_config(), ACO_PROCESS_ERROR, and AST_MODULE_LOAD_DECLINE.

unload_module()

static int unload_module ( void  )

static

Definition at line 1426 of file res_pjsip_notify.c.

{
    ast_manager_unregister("PJSIPNotify");
    ast_unregister_application("PJSIPNotify");
    ast_cli_unregister_multiple(cli_options, ARRAY_LEN(cli_options));
    aco_info_destroy(&notify_cfg);
    ao2_global_obj_release(globals);
 
    return 0;
}

References aco_info_destroy(), ao2_global_obj_release, ARRAY_LEN, ast_cli_unregister_multiple(), ast_manager_unregister(), ast_unregister_application(), cli_options, and globals.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "CLI/AMI PJSIP NOTIFY 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_APP_DEPEND, .requires = "res_pjsip", }

static

Definition at line 1444 of file res_pjsip_notify.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1444 of file res_pjsip_notify.c.

cli_options

struct ast_cli_entry cli_options[]

static

Initial value:

= {
    { .handler =  cli_notify , .summary =  "Send a NOTIFY request to a SIP endpoint" ,}
}

Definition at line 1131 of file res_pjsip_notify.c.

                                            {
    AST_CLI_DEFINE(cli_notify, "Send a NOTIFY request to a SIP endpoint")
};

Referenced by load_module(), and unload_module().

module_conf

struct aco_file module_conf

static

Initial value:

= {
    .filename = notify_config,
    .types = ACO_TYPES(&notify_option),
}

Definition at line 263 of file res_pjsip_notify.c.

                                     {
    .filename = notify_config,
    .types = ACO_TYPES(&notify_option),
};

notify_config

const char notify_config[] = "pjsip_notify.conf"

static

Definition at line 134 of file res_pjsip_notify.c.

notify_option

struct aco_type notify_option

static

Definition at line 251 of file res_pjsip_notify.c.

                                       {
    .type = ACO_ITEM,
    .name = "notify",
    .category_match = ACO_BLACKLIST_EXACT,
    .category = "general",
    .item_offset = offsetof(struct notify_cfg, notify_options),
    .item_alloc = notify_option_alloc,
    .item_find = notify_option_find
};

notify_options

struct aco_type* notify_options[] = ACO_TYPES(&notify_option)

static

Definition at line 261 of file res_pjsip_notify.c.

Referenced by load_module().