res_pjsip_header_funcs.c File Reference

#include "asterisk.h"
#include <pjsip.h>
#include <pjsip_ua.h>
#include "asterisk/res_pjsip.h"
#include "asterisk/res_pjsip_session.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/app.h"
#include "asterisk/module.h"
#include "asterisk/utils.h"

Include dependency graph for res_pjsip_header_funcs.c:

Go to the source code of this file.

Data Structures
struct	hdr_list
struct	hdr_list_entry
	Linked list for accumulating headers. More...
struct	header_data
	Data structure used for ast_sip_push_task_wait_serializer More...
struct	param_data

Macros
#define	param_add(pool, list, pname, pvalue)

Enumerations
enum	param_type { PARAMETER_HEADER , PARAMETER_URI }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static int	add_header (void *obj)
static int	add_inheritable_header (struct ast_channel *channel, const char *header_name, const char *header_value)
static int	add_param (void *obj)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static pjsip_hdr *	find_header (struct hdr_list *list, const char *header_name, int header_number)
static int	func_read_header (struct ast_channel *chan, const char *function, char *data, char *buf, size_t len)
	Implements PJSIP_HEADER function 'read' callback.
static int	func_read_headers (struct ast_channel *chan, const char *function, char *data, char *buf, size_t len)
	Read list of unique SIP headers.
static int	func_read_param (struct ast_channel *chan, const char *function, char *data, char *buf, size_t len)
static int	func_response_read_header (struct ast_channel *chan, const char *function, char *data, char *buf, size_t len)
	Implements PJSIP_RESPONSE_HEADER function 'read' callback.
static int	func_response_read_headers (struct ast_channel *chan, const char *function, char *data, char *buf, size_t len)
	Read list of unique SIP response headers.
static int	func_write_header (struct ast_channel *chan, const char *cmd, char *data, const char *value)
	Implements PJSIP_HEADER function 'write' callback.
static int	func_write_inheritable_header (struct ast_channel *chan, const char *cmd, char *data, const char *value)
	Implements PJSIP_INHERITABLE_HEADER function 'write' callback.
static int	func_write_param (struct ast_channel *chan, const char *cmd, char *data, const char *value)
static int	incoming_request (struct ast_sip_session *session, pjsip_rx_data *rdata)
static void	incoming_response (struct ast_sip_session *session, pjsip_rx_data *rdata)
static void	inheritable_headers_destroy (void *data)
static void *	inheritable_headers_duplicate (void *data)
static int	insert_headers (pj_pool_t *pool, struct hdr_list *list, pjsip_msg *msg)
static int	load_module (void)
static void	outgoing_request (struct ast_sip_session *session, pjsip_tx_data *tdata)
static int	read_header (void *obj)
static int	read_headers (void *obj)
static int	read_param (void *obj)
static int	remove_header (void *obj)
static int	remove_inheritable_header (struct ast_channel *channel, const char *header_name)
static int	unload_module (void)
static int	update_header (void *obj)
static int	update_inheritable_header (struct ast_channel *channel, const char *header_name, const char *header_value, int header_number)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP Header Functions" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND, .requires = "res_pjsip,res_pjsip_session", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_sip_session_supplement	header_funcs_supplement
static const struct ast_datastore_info	inheritable_header_datastore
	Datastore for saving inheritable headers (contains hdr_list with ast_malloc'd entries)
static struct ast_custom_function	pjsip_header_function
static struct ast_custom_function	pjsip_header_inherit_function
static struct ast_custom_function	pjsip_header_param_function
static struct ast_custom_function	pjsip_headers_function
static struct ast_custom_function	pjsip_response_header_function
static struct ast_custom_function	pjsip_response_headers_function
static const struct ast_datastore_info	response_header_datastore
	Datastore for saving response headers.
static const struct ast_datastore_info	session_header_datastore
	Datastore for saving headers in session (contains hdr_list, no destroy needed)

Macro Definition Documentation

param_add

#define param_add	(		pool,
			list,
			pname,
			pvalue
	)

Enumeration Type Documentation

param_type

enum param_type

Enumerator
PARAMETER_HEADER
PARAMETER_URI

Definition at line 1597 of file res_pjsip_header_funcs.c.

                {
    PARAMETER_HEADER,
    PARAMETER_URI,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1847 of file res_pjsip_header_funcs.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1847 of file res_pjsip_header_funcs.c.

add_header()

static int add_header ( void *  obj )

static

Definition at line 760 of file res_pjsip_header_funcs.c.

{
    struct header_data *data = obj;
    struct ast_sip_session *session = data->channel->session;
    pj_pool_t *pool = session->inv_session->dlg->pool;
    pj_str_t pj_header_name;
    pj_str_t pj_header_value;
    struct hdr_list_entry *le;
    struct hdr_list *list;
 
    RAII_VAR(struct ast_datastore *, datastore,
             ast_sip_session_get_datastore(session, session_header_datastore.type), ao2_cleanup);
 
    if (!datastore) {
        if (!(datastore = ast_sip_session_alloc_datastore(&session_header_datastore,
                                                        session_header_datastore.type))
            || !(datastore->data = pj_pool_alloc(pool, sizeof(struct hdr_list)))
            || ast_sip_session_add_datastore(session, datastore)) {
            ast_log(AST_LOG_ERROR, "Unable to create datastore for header functions.\n");
            return -1;
        }
        AST_LIST_HEAD_INIT_NOLOCK((struct hdr_list *) datastore->data);
    }
 
    ast_debug(1, "Adding header %s with value %s\n", data->header_name,
              data->header_value);
 
    pj_cstr(&pj_header_name, data->header_name);
    pj_cstr(&pj_header_value, data->header_value);
    le = pj_pool_zalloc(pool, sizeof(struct hdr_list_entry));
    le->hdr = (pjsip_hdr *) pjsip_generic_string_hdr_create(pool, &pj_header_name,
                                                            &pj_header_value);
    list = datastore->data;
 
    AST_LIST_INSERT_TAIL(list, le, nextptr);
 
    return 0;
}

References ao2_cleanup, ast_debug, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_TAIL, ast_log, AST_LOG_ERROR, ast_sip_session_add_datastore(), ast_sip_session_alloc_datastore(), ast_sip_session_get_datastore(), header_data::channel, hdr_list_entry::hdr, header_data::header_name, header_data::header_value, RAII_VAR, ast_sip_channel_pvt::session, session, session_header_datastore, and ast_datastore_info::type.

Referenced by func_write_header().

add_inheritable_header()

static int add_inheritable_header ( struct ast_channel *  channel, const char *  header_name, const char *  header_value  )

static

Definition at line 811 of file res_pjsip_header_funcs.c.

{
    struct ast_variable *headers = NULL;
 
    /* Add to channel datastore to be inherited by bridged channel(s) */
    struct ast_datastore *chan_datastore;
    struct ast_variable *new_var;
 
    ast_channel_lock(channel);
    chan_datastore = ast_channel_datastore_find(channel, &inheritable_header_datastore, NULL);
    ast_debug(3, "Adding inheritable header %s with value %s to channel %s\n", header_name,
        header_value, ast_channel_name(channel));
 
    if (!chan_datastore) {
        /* Create new channel datastore */
        chan_datastore = ast_datastore_alloc(&inheritable_header_datastore,
            inheritable_header_datastore.type);
        if (chan_datastore) {
            chan_datastore->data = NULL;
            chan_datastore->inheritance = DATASTORE_INHERIT_FOREVER;
            ast_channel_datastore_add(channel, chan_datastore);
            ast_debug(3, "Created new inheritable SIP header channel datastore for channel %s\n",
                ast_channel_name(channel));
        } else {
            ast_log(LOG_ERROR, "Failed to allocate channel datastore for channel %s to store inheritable SIP headers\n",
                ast_channel_name(channel));
            ast_channel_unlock(channel);
            return -1;
        }
    } else {
        /* Ensure it's marked as inheritable */
        if (!chan_datastore->inheritance) {
            chan_datastore->inheritance = DATASTORE_INHERIT_FOREVER;
            ast_debug(3, "Upgraded SIP header channel datastore to inheritable for channel %s\n",
                ast_channel_name(channel));
        }
    }
 
    /* Add THIS header to the channel datastore */
    headers = chan_datastore->data;
    new_var = ast_variable_new(header_name, header_value, "");
    if (!new_var) {
        ast_log(LOG_ERROR, "Failed to allocate variable for channel %s to store inheritable SIP headers\n",
            ast_channel_name(channel));
        ast_channel_unlock(channel);
        return -1;
    }
 
    /* Prepend to list */
    new_var->next = headers;
    chan_datastore->data = new_var;
 
    ast_debug(1, "Inherited Header %s added with value %s for channel %s\n",
            header_name, header_value, ast_channel_name(channel));
 
    ast_channel_unlock(channel);
 
    return 0;
}

References ast_channel_datastore_add(), ast_channel_datastore_find(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_datastore_alloc, ast_debug, ast_log, ast_variable_new, ast_datastore::data, DATASTORE_INHERIT_FOREVER, inheritable_header_datastore, ast_datastore::inheritance, LOG_ERROR, ast_variable::next, NULL, and ast_datastore_info::type.

Referenced by func_write_inheritable_header().

add_param()

static int add_param ( void *  obj )

static

Definition at line 1665 of file res_pjsip_header_funcs.c.

{
    struct param_data *data = obj;
    struct ast_sip_session *session = data->channel->session;
    pj_pool_t *pool = session->inv_session->dlg->pool;
 
    pjsip_fromto_hdr *dlg_info;
    pjsip_name_addr *dlg_info_name_addr;
    pjsip_sip_uri *dlg_info_uri;
 
    dlg_info = session->inv_session->dlg->local.info; /* Local for outgoing */
    dlg_info_name_addr = (pjsip_name_addr *) dlg_info->uri;
    dlg_info_uri = pjsip_uri_get_uri(dlg_info_name_addr);
    if (!PJSIP_URI_SCHEME_IS_SIP(dlg_info_uri) && !PJSIP_URI_SCHEME_IS_SIPS(dlg_info_uri)) {
        ast_log(LOG_WARNING, "Non SIP/SIPS URI\n");
        return -1;
    }
 
    ast_debug(1, "Adding custom %s param %s = %s\n",
        data->paramtype == PARAMETER_URI ? "URI" : "header", data->param_name, data->param_value);
 
    /* This works the same as doing this in set_from_header in res_pjsip_session.c
     * The way that this maps to pjproject is a little confusing.
     * Say we have <sip:foo@bar.com;p1=abc;p2=def?h1=qrs&h2=tuv>;o1=foo;o2=bar
     * p1 and p2 are URI parameters.
     * (h1 and h2 are URI headers)
     * o1 and o2 are header parameters (and don't have anything to do with the URI)
     * In pjproject, other_param is used for adding all custom parameters.
     * We use the URI for URI stuff, including URI parameters, and the header directly for header parameters.
     */
 
#define param_add(pool, list, pname, pvalue) { \
    pjsip_param *param; \
    param = PJ_POOL_ALLOC_T(pool, pjsip_param); \
    pj_strdup2(pool, &param->name, pname); \
    pj_strdup2(pool, &param->value, pvalue); \
    pj_list_insert_before(list, param); \
}
 
    if (data->paramtype == PARAMETER_URI) { /* URI parameter */
        param_add(pool, &dlg_info_uri->other_param, data->param_name, S_OR(data->param_value, ""));
    } else { /* Header parameter */
        param_add(pool, &dlg_info->other_param, data->param_name, S_OR(data->param_value, ""));
    }
 
    return 0;
}

References ast_debug, ast_log, param_data::channel, LOG_WARNING, param_add, param_data::param_name, param_data::param_value, PARAMETER_URI, param_data::paramtype, S_OR, ast_sip_channel_pvt::session, and session.

Referenced by func_write_param().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1847 of file res_pjsip_header_funcs.c.

find_header()

static pjsip_hdr * find_header ( struct hdr_list *  list, const char *  header_name, int  header_number  )

static

Definition at line 555 of file res_pjsip_header_funcs.c.

{
    struct hdr_list_entry *le;
    pjsip_hdr *hdr = NULL;
    int i = 1;
 
    if (!list || ast_strlen_zero(header_name) || header_number < 1) {
        return NULL;
    }
 
    AST_LIST_TRAVERSE(list, le, nextptr) {
        if (pj_stricmp2(&le->hdr->name, header_name) == 0 && i++ == header_number) {
            hdr = le->hdr;
            break;
        }
    }
 
    return hdr;
}

References AST_LIST_TRAVERSE, ast_strlen_zero(), hdr_list_entry::hdr, hdr_list_entry::nextptr, and NULL.

Referenced by update_header().

func_read_header()

static int func_read_header ( struct ast_channel *  chan, const char *  function, char *  data, char *  buf, size_t  len  )

static

Implements PJSIP_HEADER function 'read' callback.

Valid actions are 'read' and 'remove'.

Definition at line 1237 of file res_pjsip_header_funcs.c.

{
    struct ast_sip_channel_pvt *channel = chan ? ast_channel_tech_pvt(chan) : NULL;
    struct header_data header_data;
    int number;
    AST_DECLARE_APP_ARGS(args,
                         AST_APP_ARG(action);
                         AST_APP_ARG(header_name); AST_APP_ARG(header_number););
    AST_STANDARD_APP_ARGS(args, data);
 
    if (!channel || strncmp(ast_channel_name(chan), "PJSIP/", 6)) {
        ast_log(LOG_ERROR, "This function requires a PJSIP channel.\n");
        return -1;
    }
 
    if (ast_strlen_zero(args.action)) {
        ast_log(AST_LOG_ERROR, "This function requires an action.\n");
        return -1;
    }
    if (ast_strlen_zero(args.header_name)) {
        ast_log(AST_LOG_ERROR, "This function requires a header name.\n");
        return -1;
    }
    if (!args.header_number) {
        number = 1;
    } else {
        sscanf(args.header_number, "%30d", &number);
        if (number < 1) {
            number = 1;
        }
    }
 
    header_data.channel = channel;
    header_data.header_name = args.header_name;
    header_data.header_number = number;
    header_data.header_value = NULL;
    header_data.buf = buf;
    header_data.len = len;
    header_data.header_datastore = &session_header_datastore;
 
    if (!strcasecmp(args.action, "read")) {
        return ast_sip_push_task_wait_serializer(channel->session->serializer, read_header, &header_data);
    } else if (!strcasecmp(args.action, "remove")) {
        return ast_sip_push_task_wait_serializer(channel->session->serializer,
            remove_header, &header_data);
    } else {
        ast_log(AST_LOG_ERROR,
                "Unknown action '%s' is not valid, must be 'read' or 'remove'.\n",
                args.action);
        return -1;
    }
}

References args, AST_APP_ARG, ast_channel_name(), ast_channel_tech_pvt(), AST_DECLARE_APP_ARGS, ast_log, AST_LOG_ERROR, ast_sip_push_task_wait_serializer, AST_STANDARD_APP_ARGS, ast_strlen_zero(), buf, header_data::buf, header_data::channel, header_data::header_datastore, header_data::header_name, header_data::header_number, header_data::header_value, len(), header_data::len, LOG_ERROR, NULL, read_header(), remove_header(), ast_sip_session::serializer, ast_sip_channel_pvt::session, and session_header_datastore.

func_read_headers()

static int func_read_headers ( struct ast_channel *  chan, const char *  function, char *  data, char *  buf, size_t  len  )

static

Read list of unique SIP headers.

Definition at line 1174 of file res_pjsip_header_funcs.c.

{
    struct ast_sip_channel_pvt *channel = chan ? ast_channel_tech_pvt(chan) : NULL;
    struct header_data header_data;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(header_pattern);
    );
    AST_STANDARD_APP_ARGS(args, data);
 
    if (!chan || strncmp(ast_channel_name(chan), "PJSIP/", 6)) {
        ast_log(LOG_ERROR, "This function requires a PJSIP channel.\n");
        return -1;
    }
 
    header_data.channel = channel;
    header_data.header_name = args.header_pattern;
    header_data.header_value = NULL;
    header_data.buf = buf;
    header_data.len = len;
    header_data.header_datastore = &session_header_datastore;
 
    return ast_sip_push_task_wait_serializer(channel->session->serializer, read_headers, &header_data);
 
}

References args, AST_APP_ARG, ast_channel_name(), ast_channel_tech_pvt(), AST_DECLARE_APP_ARGS, ast_log, ast_sip_push_task_wait_serializer, AST_STANDARD_APP_ARGS, buf, header_data::buf, header_data::channel, header_data::header_datastore, header_data::header_name, header_data::header_value, len(), header_data::len, LOG_ERROR, NULL, read_headers(), ast_sip_session::serializer, ast_sip_channel_pvt::session, and session_header_datastore.

func_read_param()

static int func_read_param ( struct ast_channel *  chan, const char *  function, char *  data, char *  buf, size_t  len  )

static

Definition at line 1713 of file res_pjsip_header_funcs.c.

{
    struct ast_sip_channel_pvt *channel = chan ? ast_channel_tech_pvt(chan) : NULL;
    struct param_data param_data;
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(header_name);
        AST_APP_ARG(param_type);
        AST_APP_ARG(param_name);
    );
 
    AST_STANDARD_APP_ARGS(args, data);
 
    param_data.channel = channel;
 
    if (!channel || strncmp(ast_channel_name(chan), "PJSIP/", 6)) {
        ast_log(LOG_ERROR, "This function requires a PJSIP channel.\n");
        return -1;
    }
    if (ast_strlen_zero(args.param_type)) {
        ast_log(AST_LOG_ERROR, "This function requires a parameter type.\n");
        return -1;
    }
    if (ast_strlen_zero(args.param_name)) {
        ast_log(AST_LOG_ERROR, "This function requires a parameter name.\n");
        return -1;
    }
 
    /* Currently, only From is supported, but this could be extended in the future. */
    if (ast_strlen_zero(args.header_name) || strcasecmp(args.header_name, "From")) {
        ast_log(LOG_WARNING, "Only the From header is currently supported\n");
        return -1;
    }
 
    param_data.param_name = args.param_name;
    if (!strcasecmp(args.param_type, "header")) {
        param_data.paramtype = PARAMETER_HEADER;
    } else if (!strcasecmp(args.param_type, "uri")) {
        param_data.paramtype = PARAMETER_URI;
    } else {
        ast_log(LOG_WARNING, "Parameter type '%s' is invalid: must be 'header' or 'uri'\n", args.param_type);
        return -1;
    }
 
    param_data.buf = buf;
    param_data.len = len;
 
    return ast_sip_push_task_wait_serializer(channel->session->serializer, read_param, &param_data);
}

References args, AST_APP_ARG, ast_channel_name(), ast_channel_tech_pvt(), AST_DECLARE_APP_ARGS, ast_log, AST_LOG_ERROR, ast_sip_push_task_wait_serializer, AST_STANDARD_APP_ARGS, ast_strlen_zero(), buf, param_data::buf, param_data::channel, param_data::header_name, len(), param_data::len, LOG_ERROR, LOG_WARNING, NULL, param_data::param_name, PARAMETER_HEADER, PARAMETER_URI, param_data::paramtype, read_param(), ast_sip_session::serializer, and ast_sip_channel_pvt::session.

func_response_read_header()

static int func_response_read_header ( struct ast_channel *  chan, const char *  function, char *  data, char *  buf, size_t  len  )

static

Implements PJSIP_RESPONSE_HEADER function 'read' callback.

Valid actions are 'read'

Definition at line 1295 of file res_pjsip_header_funcs.c.

{
    struct ast_sip_channel_pvt *channel = chan ? ast_channel_tech_pvt(chan) : NULL;
    struct header_data header_data;
    int number;
    AST_DECLARE_APP_ARGS(args,
                         AST_APP_ARG(action);
                         AST_APP_ARG(header_name); AST_APP_ARG(header_number););
    AST_STANDARD_APP_ARGS(args, data);
 
    if (!channel || strncmp(ast_channel_name(chan), "PJSIP/", 6)) {
        ast_log(LOG_ERROR, "This function requires a PJSIP channel.\n");
        return -1;
    }
 
    if (ast_strlen_zero(args.action)) {
        ast_log(AST_LOG_ERROR, "This function requires an action.\n");
        return -1;
    }
    if (ast_strlen_zero(args.header_name)) {
        ast_log(AST_LOG_ERROR, "This function requires a header name.\n");
        return -1;
    }
    if (!args.header_number) {
        number = 1;
    } else {
        sscanf(args.header_number, "%30d", &number);
        if (number < 1) {
            number = 1;
        }
    }
 
    header_data.channel = channel;
    header_data.header_name = args.header_name;
    header_data.header_number = number;
    header_data.header_value = NULL;
    header_data.buf = buf;
    header_data.len = len;
    header_data.header_datastore = &response_header_datastore;
 
    if (!strcasecmp(args.action, "read")) {
        return ast_sip_push_task_wait_serializer(channel->session->serializer, read_header, &header_data);
    } else {
        ast_log(AST_LOG_ERROR,
                "Unknown action '%s' is not valid, must be 'read'.\n",
                args.action);
        return -1;
    }
}

References args, AST_APP_ARG, ast_channel_name(), ast_channel_tech_pvt(), AST_DECLARE_APP_ARGS, ast_log, AST_LOG_ERROR, ast_sip_push_task_wait_serializer, AST_STANDARD_APP_ARGS, ast_strlen_zero(), buf, header_data::buf, header_data::channel, header_data::header_datastore, header_data::header_name, header_data::header_number, header_data::header_value, len(), header_data::len, LOG_ERROR, NULL, read_header(), response_header_datastore, ast_sip_session::serializer, and ast_sip_channel_pvt::session.

func_response_read_headers()

static int func_response_read_headers ( struct ast_channel *  chan, const char *  function, char *  data, char *  buf, size_t  len  )

static

Read list of unique SIP response headers.

Definition at line 1202 of file res_pjsip_header_funcs.c.

{
    struct ast_sip_channel_pvt *channel = chan ? ast_channel_tech_pvt(chan) : NULL;
    struct header_data header_data;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(header_pattern);
    );
    AST_STANDARD_APP_ARGS(args, data);
 
    if (!chan || strncmp(ast_channel_name(chan), "PJSIP/", 6)) {
        ast_log(LOG_ERROR, "This function requires a PJSIP channel.\n");
        return -1;
    }
 
    if (ast_strlen_zero(args.header_pattern)) {
        ast_log(AST_LOG_ERROR, "This function requires a pattern.\n");
        return -1;
    }
 
    header_data.channel = channel;
    header_data.header_name = args.header_pattern;
    header_data.header_value = NULL;
    header_data.buf = buf;
    header_data.len = len;
    header_data.header_datastore = &response_header_datastore;
 
    return ast_sip_push_task_wait_serializer(channel->session->serializer, read_headers, &header_data);
 
}

References args, AST_APP_ARG, ast_channel_name(), ast_channel_tech_pvt(), AST_DECLARE_APP_ARGS, ast_log, AST_LOG_ERROR, ast_sip_push_task_wait_serializer, AST_STANDARD_APP_ARGS, ast_strlen_zero(), buf, header_data::buf, header_data::channel, header_data::header_datastore, header_data::header_name, header_data::header_value, len(), header_data::len, LOG_ERROR, NULL, read_headers(), response_header_datastore, ast_sip_session::serializer, and ast_sip_channel_pvt::session.

func_write_header()

static int func_write_header ( struct ast_channel *  chan, const char *  cmd, char *  data, const char *  value  )

static

Implements PJSIP_HEADER function 'write' callback.

Valid actions are 'add', 'update' and 'remove'.

Definition at line 1350 of file res_pjsip_header_funcs.c.

{
    struct ast_sip_channel_pvt *channel = chan ? ast_channel_tech_pvt(chan) : NULL;
    struct header_data header_data;
    int header_number;
    AST_DECLARE_APP_ARGS(args,
                         AST_APP_ARG(action);
                         AST_APP_ARG(header_name);
                         AST_APP_ARG(header_number););
    AST_STANDARD_APP_ARGS(args, data);
 
    if (!channel || strncmp(ast_channel_name(chan), "PJSIP/", 6)) {
        ast_log(LOG_ERROR, "This function requires a PJSIP channel.\n");
        return -1;
    }
 
    if (ast_strlen_zero(args.action)) {
        ast_log(AST_LOG_ERROR, "This function requires an action.\n");
        return -1;
    }
    if (ast_strlen_zero(args.header_name)) {
        ast_log(AST_LOG_ERROR, "This function requires a header name.\n");
        return -1;
    }
    if (!args.header_number) {
        header_number = 1;
    } else {
        sscanf(args.header_number, "%30d", &header_number);
        if (header_number < 1) {
            header_number = 1;
        }
    }
 
    header_data.channel = channel;
    header_data.header_name = args.header_name;
    header_data.header_number = header_number;
    header_data.header_value = value;
    header_data.buf = NULL;
    header_data.len = 0;
    header_data.header_datastore = &session_header_datastore;
 
    if (!strcasecmp(args.action, "add")) {
        return ast_sip_push_task_wait_serializer(channel->session->serializer,
            add_header, &header_data);
    } else if (!strcasecmp(args.action, "update")) {
        return ast_sip_push_task_wait_serializer(channel->session->serializer,
            update_header, &header_data);
    } else if (!strcasecmp(args.action, "remove")) {
        return ast_sip_push_task_wait_serializer(channel->session->serializer,
            remove_header, &header_data);
    } else {
        ast_log(AST_LOG_ERROR,
                "Unknown action '%s' is not valid, must be 'add', 'update', or 'remove'.\n",
                args.action);
        return -1;
    }
}

References add_header(), args, AST_APP_ARG, ast_channel_name(), ast_channel_tech_pvt(), AST_DECLARE_APP_ARGS, ast_log, AST_LOG_ERROR, ast_sip_push_task_wait_serializer, AST_STANDARD_APP_ARGS, ast_strlen_zero(), header_data::buf, header_data::channel, header_data::header_datastore, header_data::header_name, header_data::header_number, header_data::header_value, header_data::len, LOG_ERROR, NULL, remove_header(), ast_sip_session::serializer, ast_sip_channel_pvt::session, session_header_datastore, update_header(), and value.

func_write_inheritable_header()

static int func_write_inheritable_header ( struct ast_channel *  chan, const char *  cmd, char *  data, const char *  value  )

static

Implements PJSIP_INHERITABLE_HEADER function 'write' callback.

Valid actions are 'add', 'update' and 'remove'.

Definition at line 1414 of file res_pjsip_header_funcs.c.

{
    int header_number;
    AST_DECLARE_APP_ARGS(args,
                         AST_APP_ARG(action);
                         AST_APP_ARG(header_name);
                         AST_APP_ARG(header_number););
    AST_STANDARD_APP_ARGS(args, data);
 
    if (!chan) {
        ast_log(LOG_ERROR, "The PJSIP_INHERITABLE_HEADER function requires a channel.\n");
        return -1;
    }
    if (ast_strlen_zero(args.action)) {
        ast_log(AST_LOG_ERROR, "The PJSIP_INHERITABLE_HEADER function requires an action.\n");
        return -1;
    }
    if (ast_strlen_zero(args.header_name)) {
        ast_log(AST_LOG_ERROR, "The PJSIP_INHERITABLE_HEADER function requires a header name.\n");
        return -1;
    }
    if (!args.header_number) {
        header_number = 1;
    } else {
        sscanf(args.header_number, "%30d", &header_number);
        if (header_number < 1) {
            header_number = 1;
        }
    }
 
    /* TODO: we might want to check channel type and use the serializer if PJSIP */
    if (!strcasecmp(args.action, "add")) {
        return add_inheritable_header(chan, args.header_name, value);
    } else if (!strcasecmp(args.action, "update")) {
        return update_inheritable_header(chan, args.header_name, value, header_number);
    } else if (!strcasecmp(args.action, "remove")) {
        return remove_inheritable_header(chan, args.header_name);
    } else {
        ast_log(AST_LOG_ERROR,
                "Unknown action '%s' is not valid, must be 'add', 'update', or 'remove'.\n",
                args.action);
        return -1;
    }
}

References add_inheritable_header(), args, AST_APP_ARG, AST_DECLARE_APP_ARGS, ast_log, AST_LOG_ERROR, AST_STANDARD_APP_ARGS, ast_strlen_zero(), header_data::header_name, header_data::header_number, LOG_ERROR, remove_inheritable_header(), update_inheritable_header(), and value.

func_write_param()

static int func_write_param ( struct ast_channel *  chan, const char *  cmd, char *  data, const char *  value  )

static

Definition at line 1763 of file res_pjsip_header_funcs.c.

{
    struct ast_sip_channel_pvt *channel = chan ? ast_channel_tech_pvt(chan) : NULL;
    struct param_data param_data;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(header_name);
        AST_APP_ARG(param_type);
        AST_APP_ARG(param_name);
    );
 
    AST_STANDARD_APP_ARGS(args, data);
 
    param_data.channel = channel;
 
    if (!channel || strncmp(ast_channel_name(chan), "PJSIP/", 6)) {
        ast_log(LOG_ERROR, "This function requires a PJSIP channel.\n");
        return -1;
    }
    if (ast_strlen_zero(args.param_type)) {
        ast_log(AST_LOG_ERROR, "This function requires a parameter type.\n");
        return -1;
    }
    if (ast_strlen_zero(args.param_name)) {
        ast_log(AST_LOG_ERROR, "This function requires a parameter name.\n");
        return -1;
    }
 
    /* Currently, only From is supported, but this could be extended in the future. */
    if (ast_strlen_zero(args.header_name) || strcasecmp(args.header_name, "From")) {
        ast_log(LOG_WARNING, "Only the From header is currently supported\n");
        return -1;
    }
 
    param_data.param_name = args.param_name;
    if (!strcasecmp(args.param_type, "header")) {
        param_data.paramtype = PARAMETER_HEADER;
    } else if (!strcasecmp(args.param_type, "uri")) {
        param_data.paramtype = PARAMETER_URI;
    } else {
        ast_log(LOG_WARNING, "Parameter type '%s' is invalid: must be 'header' or 'uri'\n", args.param_type);
        return -1;
    }
    param_data.param_value = value;
 
    return ast_sip_push_task_wait_serializer(channel->session->serializer, add_param, &param_data);
}

References add_param(), args, AST_APP_ARG, ast_channel_name(), ast_channel_tech_pvt(), AST_DECLARE_APP_ARGS, ast_log, AST_LOG_ERROR, ast_sip_push_task_wait_serializer, AST_STANDARD_APP_ARGS, ast_strlen_zero(), param_data::channel, param_data::header_name, LOG_ERROR, LOG_WARNING, NULL, param_data::param_name, param_data::param_value, PARAMETER_HEADER, PARAMETER_URI, param_data::paramtype, ast_sip_session::serializer, ast_sip_channel_pvt::session, and value.

incoming_request()

static int incoming_request ( struct ast_sip_session *  session, pjsip_rx_data *  rdata  )

static

Definition at line 493 of file res_pjsip_header_funcs.c.

{
    pj_pool_t *pool = session->inv_session->dlg->pool;
    RAII_VAR(struct ast_datastore *, datastore,
             ast_sip_session_get_datastore(session, session_header_datastore.type), ao2_cleanup);
 
    if (!datastore) {
        if (!(datastore =
              ast_sip_session_alloc_datastore(&session_header_datastore, session_header_datastore.type))
            ||
            !(datastore->data = pj_pool_alloc(pool, sizeof(struct hdr_list))) ||
            ast_sip_session_add_datastore(session, datastore)) {
            ast_log(AST_LOG_ERROR, "Unable to create datastore for header functions.\n");
            return 0;
        }
        AST_LIST_HEAD_INIT_NOLOCK((struct hdr_list *) datastore->data);
    }
    insert_headers(pool, (struct hdr_list *) datastore->data, rdata->msg_info.msg);
 
    return 0;
}

References ao2_cleanup, AST_LIST_HEAD_INIT_NOLOCK, ast_log, AST_LOG_ERROR, ast_sip_session_add_datastore(), ast_sip_session_alloc_datastore(), ast_sip_session_get_datastore(), insert_headers(), RAII_VAR, session, session_header_datastore, and ast_datastore_info::type.

incoming_response()

static void incoming_response ( struct ast_sip_session *  session, pjsip_rx_data *  rdata  )

static

Definition at line 523 of file res_pjsip_header_funcs.c.

{
    pj_pool_t *pool = session->inv_session->dlg->pool;
    RAII_VAR(struct ast_datastore *, datastore,
             ast_sip_session_get_datastore(session, response_header_datastore.type), ao2_cleanup);
    pjsip_status_line status = rdata->msg_info.msg->line.status;
 
    /* Skip responses different of 200 OK, when 2xx is received. */
    if (session->inv_session->state != PJSIP_INV_STATE_CONNECTING || status.code!=200) {
        return;
    }
 
    if (!datastore) {
        if (!(datastore =
              ast_sip_session_alloc_datastore(&response_header_datastore, response_header_datastore.type))
            ||
            !(datastore->data = pj_pool_alloc(pool, sizeof(struct hdr_list))) ||
            ast_sip_session_add_datastore(session, datastore)) {
            ast_log(AST_LOG_ERROR, "Unable to create datastore for header functions.\n");
            return;
        }
        AST_LIST_HEAD_INIT_NOLOCK((struct hdr_list *) datastore->data);
    }
    insert_headers(pool, (struct hdr_list *) datastore->data, rdata->msg_info.msg);
 
    return;
}

References ao2_cleanup, AST_LIST_HEAD_INIT_NOLOCK, ast_log, AST_LOG_ERROR, ast_sip_session_add_datastore(), ast_sip_session_alloc_datastore(), ast_sip_session_get_datastore(), insert_headers(), RAII_VAR, response_header_datastore, session, status, and ast_datastore_info::type.

inheritable_headers_destroy()

static void inheritable_headers_destroy ( void *  data )

static

Definition at line 429 of file res_pjsip_header_funcs.c.

{
    ast_variables_destroy(data);
}

References ast_variables_destroy().

Referenced by remove_inheritable_header(), and update_inheritable_header().

inheritable_headers_duplicate()

static void * inheritable_headers_duplicate ( void *  data )

static

Definition at line 420 of file res_pjsip_header_funcs.c.

{
    return ast_variables_dup(data);
}

References ast_variables_dup().

Referenced by outgoing_request().

insert_headers()

static int insert_headers ( pj_pool_t *  pool, struct hdr_list *  list, pjsip_msg *  msg  )

static

Definition at line 470 of file res_pjsip_header_funcs.c.

{
    pjsip_hdr *hdr = msg->hdr.next;
    struct hdr_list_entry *le;
 
    while (hdr && hdr != &msg->hdr) {
        le = pj_pool_zalloc(pool, sizeof(struct hdr_list_entry));
        le->hdr = pjsip_hdr_clone(pool, hdr);
        AST_LIST_INSERT_TAIL(list, le, nextptr);
        hdr = hdr->next;
    }
 
    return 0;
}

References AST_LIST_INSERT_TAIL, hdr_list_entry::hdr, and hdr_list_entry::nextptr.

Referenced by incoming_request(), and incoming_response().

load_module()

static int load_module ( void  )

static

Definition at line 1816 of file res_pjsip_header_funcs.c.

{
    ast_sip_session_register_supplement(&header_funcs_supplement);
    ast_custom_function_register(&pjsip_header_function);
    ast_custom_function_register(&pjsip_header_inherit_function);
    ast_custom_function_register(&pjsip_headers_function);
    ast_custom_function_register(&pjsip_response_header_function);
    ast_custom_function_register(&pjsip_response_headers_function);
    ast_custom_function_register(&pjsip_header_param_function);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ast_custom_function_register, AST_MODULE_LOAD_SUCCESS, ast_sip_session_register_supplement, header_funcs_supplement, pjsip_header_function, pjsip_header_inherit_function, pjsip_header_param_function, pjsip_headers_function, pjsip_response_header_function, and pjsip_response_headers_function.

outgoing_request()

static void outgoing_request ( struct ast_sip_session *  session, pjsip_tx_data *  tdata  )

static

Definition at line 1498 of file res_pjsip_header_funcs.c.

{
    struct hdr_list *hdr_list;
    struct hdr_list_entry *le;
    int header_count = 0;
    struct ast_datastore *inherited_datastore = NULL;
    RAII_VAR(struct ast_datastore *, session_datastore,
             ast_sip_session_get_datastore(session, session_header_datastore.type), ao2_cleanup);
 
    /* Check if we're past the INVITE stage */
    if (session->inv_session->state >= PJSIP_INV_STATE_CONFIRMED) {
        ast_debug(3, "Already confirmed (state=%d)\n",
            session->inv_session->state);
        return;
    }
 
    /* If we're UAC and have a channel, check the channel datastore for an inheritable header datastore */
    if (session->channel && session->inv_session->role == PJSIP_ROLE_UAC) {
        struct ast_datastore *chan_datastore = NULL;
 
        ast_channel_lock(session->channel);
 
        chan_datastore = ast_channel_datastore_find(session->channel, &inheritable_header_datastore, NULL);
 
        if (chan_datastore && chan_datastore->inheritance && chan_datastore->data) {
            inherited_datastore = ast_sip_session_alloc_datastore(&inheritable_header_datastore,
                inheritable_header_datastore.type);
 
            if (inherited_datastore) {
                /* The data is in ast_variable format from the duplicate callback.  We need to make our own copy to
                 avoid sharing the pointer. Reverse the order so they appear in the INVITE in the order added. */
                inherited_datastore->data = ast_variables_reverse((struct ast_variable *)
                    inheritable_headers_duplicate((struct ast_variable *) chan_datastore->data));
                if (inherited_datastore->data) {
                    inherited_datastore->inheritance = chan_datastore->inheritance;
                    ast_sip_session_add_datastore(session, inherited_datastore);
                } else {
                    ast_log(LOG_ERROR, "Failed to duplicate ast_variable list for channel %s\n",
                        session->channel ? ast_channel_name(session->channel) : "(none)");
                    ao2_ref(inherited_datastore, -1);
                    inherited_datastore = NULL;
                }
            } else {
                ast_log(LOG_ERROR, "Failed to allocate inherited session datastore for channel %s\n",
                    session->channel ? ast_channel_name(session->channel) : "(none)");
            }
        }
        ast_channel_unlock(session->channel);
    }
 
    /* If we have no datastores at all, nothing to do */
    if (!session_datastore && !inherited_datastore) {
        return;
    }
 
    /* Add headers from regular session datastore (non-inheritable headers added on this channel) */
    if (session_datastore && session_datastore->data) {
        hdr_list = session_datastore->data;
        AST_LIST_TRAVERSE(hdr_list, le, nextptr) {
            pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) pjsip_hdr_clone(tdata->pool, le->hdr));
            header_count++;
        }
        ast_debug(3, "Added %d regular header(s) to channel %s\n", header_count,
            session->channel ? ast_channel_name(session->channel) : "(none)");
        /* Remove datastores after use */
        ast_sip_session_remove_datastore(session, session_datastore->uid);
    }
 
    /* Add headers from inherited datastore (inheritable headers from parent channel) */
    if (inherited_datastore && inherited_datastore->data) {
        int inherited_count = 0;
        struct ast_variable *headers = inherited_datastore->data;
        struct ast_variable *var;
 
        for (var = headers; var; var = var->next) {
            if (!ast_sip_add_header(tdata, var->name, var->value)) {
                inherited_count++;
            }
        }
        ast_debug(3, "Added %d inherited header(s) to channel %s\n", inherited_count,
            session->channel ? ast_channel_name(session->channel) : "(none)");
        header_count += inherited_count;
        /* Remove datastores after use */
        ast_sip_session_remove_datastore(session, inherited_datastore->uid);
        ao2_ref(inherited_datastore, -1);
    }
 
    ast_debug(3, "Added total of %d header(s) to channel %s\n", header_count,
        session->channel ? ast_channel_name(session->channel) : "(none)");
}

References ao2_cleanup, ao2_ref, ast_channel_datastore_find(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_debug, AST_LIST_TRAVERSE, ast_log, ast_sip_add_header(), ast_sip_session_add_datastore(), ast_sip_session_alloc_datastore(), ast_sip_session_get_datastore(), ast_sip_session_remove_datastore(), ast_variables_reverse(), ast_datastore::data, hdr_list_entry::hdr, inheritable_header_datastore, inheritable_headers_duplicate(), ast_datastore::inheritance, LOG_ERROR, ast_variable::next, NULL, RAII_VAR, session, session_header_datastore, ast_datastore_info::type, ast_datastore::uid, and var.

read_header()

static int read_header ( void *  obj )

static

Definition at line 677 of file res_pjsip_header_funcs.c.

{
    struct header_data *data = obj;
    size_t len = strlen(data->header_name);
    pjsip_hdr *hdr = NULL;
    char *pj_hdr_string;
    int pj_hdr_string_len;
    char *p;
    size_t plen;
    struct hdr_list_entry *le;
    struct hdr_list *list;
    int i = 1;
    RAII_VAR(struct ast_datastore *, datastore,
             ast_sip_session_get_datastore(data->channel->session, data->header_datastore->type),
             ao2_cleanup);
 
    if (!datastore || !datastore->data) {
        ast_debug(1, "There was no datastore from which to read headers.\n");
        return -1;
    }
 
    list = datastore->data;
    AST_LIST_TRAVERSE(list, le, nextptr) {
        if (len >= 1 && data->header_name[len - 1] == '*') {
            if (pj_strnicmp2(&le->hdr->name, data->header_name, len - 1) == 0 && i++ == data->header_number) {
                hdr = le->hdr;
                break;
            }
        } else {
            if (pj_stricmp2(&le->hdr->name, data->header_name) == 0 && i++ == data->header_number) {
                hdr = le->hdr;
                break;
            }
        }
    }
 
    if (!hdr) {
        ast_debug(1, "There was no header named %s.\n", data->header_name);
        return -1;
    }
 
    pj_hdr_string = ast_alloca(data->len);
    pj_hdr_string_len = pjsip_hdr_print_on(hdr, pj_hdr_string, data->len - 1);
    if (pj_hdr_string_len == -1) {
        ast_log(AST_LOG_ERROR,
            "Not enough buffer space in pjsip_hdr_print_on\n");
        return -1;
    }
 
    pj_hdr_string[pj_hdr_string_len] = '\0';
 
    p = strchr(pj_hdr_string, ':');
    if (!p) {
        ast_log(AST_LOG_ERROR,
                "A malformed header was returned from pjsip_hdr_print_on.\n");
        return -1;
    }
 
    ++p;
    p = ast_strip(p);
    plen = strlen(p);
    if (plen + 1 > data->len) {
        ast_log(AST_LOG_ERROR,
                "Buffer isn't big enough to hold header value.  %zu > %zu\n", plen + 1,
                data->len);
        return -1;
    }
 
    ast_copy_string(data->buf, p, data->len);
 
    return 0;
}

References ao2_cleanup, ast_alloca, ast_copy_string(), ast_debug, AST_LIST_TRAVERSE, ast_log, AST_LOG_ERROR, ast_sip_session_get_datastore(), ast_strip(), header_data::buf, header_data::channel, hdr_list_entry::hdr, header_data::header_datastore, header_data::header_name, header_data::header_number, len(), header_data::len, NULL, RAII_VAR, ast_sip_channel_pvt::session, and ast_datastore_info::type.

Referenced by func_read_header(), and func_response_read_header().

read_headers()

static int read_headers ( void *  obj )

static

Definition at line 586 of file res_pjsip_header_funcs.c.

{
    struct header_data *data = obj;
    size_t len = !ast_strlen_zero(data->header_name) ? strlen(data->header_name) : 0;
    pjsip_hdr *hdr = NULL;
    char *pj_hdr_string;
    int pj_hdr_string_len;
    char *p;
    char *pos;
    size_t plen, wlen = 0;
    struct hdr_list_entry *le;
    struct hdr_list *list;
 
    RAII_VAR(struct ast_datastore *, datastore,
             ast_sip_session_get_datastore(data->channel->session, data->header_datastore->type),
             ao2_cleanup);
 
    if (!datastore || !datastore->data) {
        ast_debug(1, "There was no datastore from which to read headers.\n");
        return -1;
    }
 
    list = datastore->data;
    pj_hdr_string = ast_alloca(data->len);
    AST_LIST_TRAVERSE(list, le, nextptr) {
        if (!len || pj_strnicmp2(&le->hdr->name, data->header_name, len) == 0) {
            /* Found matched header, append to buf */
            hdr = le->hdr;
 
            pj_hdr_string_len = pjsip_hdr_print_on(hdr, pj_hdr_string, data->len - 1);
            if (pj_hdr_string_len == -1) {
                ast_log(AST_LOG_ERROR,
                    "Not enough buffer space in pjsip_hdr_print_on\n");
                return -1;
            }
            pj_hdr_string[pj_hdr_string_len] = '\0';
            p = strchr(pj_hdr_string, ':');
            if (!p) {
                ast_log(AST_LOG_WARNING,
                    "A malformed header was returned from pjsip_hdr_print_on\n");
                continue;
            }
 
            pj_hdr_string[p - pj_hdr_string] = '\0';
            p = ast_strip(pj_hdr_string);
            plen = strlen(p);
            if (wlen + plen + 1 > data->len) {
                ast_log(AST_LOG_ERROR,
                        "Buffer isn't big enough to hold header value.  %zu > %zu\n", plen + 1,
                        data->len);
                return -1;
            }
            pos = strstr(data->buf, p);
            if (pos && pos[1] == ',') {
                if (pos == data->buf) {
                    continue;
                } else if (pos[-1] == ',') {
                    continue;
                }
            }
            ast_copy_string(data->buf + wlen, p, data->len - wlen);
            wlen += plen;
            ast_copy_string(data->buf + wlen, ",", data->len - wlen);
            wlen++;
        }
    }
 
    if (wlen == 0) {
        if (!len) {
            /* No headers at all on this channel */
            return 0;
        } else {
            ast_debug(1, "There was no header beginning with %s.\n", data->header_name);
            return -1;
        }
    } else {
        data->buf[wlen-1] = '\0';
    }
    return 0;
}

References ao2_cleanup, ast_alloca, ast_copy_string(), ast_debug, AST_LIST_TRAVERSE, ast_log, AST_LOG_ERROR, AST_LOG_WARNING, ast_sip_session_get_datastore(), ast_strip(), ast_strlen_zero(), header_data::buf, header_data::channel, hdr_list_entry::hdr, header_data::header_datastore, header_data::header_name, len(), header_data::len, NULL, RAII_VAR, ast_sip_channel_pvt::session, and ast_datastore_info::type.

Referenced by func_read_headers(), and func_response_read_headers().

read_param()

static int read_param ( void *  obj )

static

Definition at line 1613 of file res_pjsip_header_funcs.c.

{
    struct param_data *data = obj;
    struct ast_sip_session *session = data->channel->session;
    pj_str_t param_name;
 
    pjsip_fromto_hdr *dlg_info;
    pjsip_name_addr *dlg_info_name_addr;
    pjsip_sip_uri *dlg_info_uri;
    pjsip_param *param;
    size_t param_len;
 
    dlg_info = session->inv_session->dlg->remote.info; /* Remote dialog for incoming */
    dlg_info_name_addr = (pjsip_name_addr *) dlg_info->uri;
    dlg_info_uri = pjsip_uri_get_uri(dlg_info_name_addr);
 
    pj_cstr(&param_name, data->param_name);
 
    if (data->paramtype == PARAMETER_URI) { /* URI parameter */
        param = pjsip_param_find(&dlg_info_uri->other_param, &param_name);
    } else { /* Header parameter */
        param = pjsip_param_find(&dlg_info->other_param, &param_name);
    }
 
    if (!param) {
        ast_debug(1, "No %s parameter found named %s\n",
            data->paramtype == PARAMETER_URI ? "URI" : "header", data->param_name);
        return -1;
    }
 
    param_len = pj_strlen(&param->value);
    if (param_len >= data->len) {
        ast_log(LOG_ERROR, "Buffer is too small for parameter value (%zu > %zu)\n", param_len, data->len);
        return -1;
    }
 
    ast_debug(2, "Successfully read %s parameter %s (length %zu)\n",
        data->paramtype == PARAMETER_URI ? "URI" : "header", data->param_name, param_len);
    if (param_len) {
        ast_copy_string(data->buf, pj_strbuf(&param->value), data->len);
    }
    data->buf[param_len] = '\0';
 
    return 0;
}

References ast_copy_string(), ast_debug, ast_log, param_data::buf, param_data::channel, param_data::len, LOG_ERROR, param_data::param_name, PARAMETER_URI, param_data::paramtype, ast_sip_channel_pvt::session, and session.

Referenced by func_read_param().

remove_header()

static int remove_header ( void *  obj )

static

Definition at line 1015 of file res_pjsip_header_funcs.c.

{
    struct header_data *data = obj;
    size_t len = strlen(data->header_name);
    struct hdr_list *list;
    struct hdr_list_entry *le;
    int removed_count = 0;
    RAII_VAR(struct ast_datastore *, datastore,
             ast_sip_session_get_datastore(data->channel->session, session_header_datastore.type),
             ao2_cleanup);
 
    ast_debug(3, "Attempting to remove header %s from channel %p\n", data->header_name,
        data->channel->session->channel ? ast_channel_name(data->channel->session->channel) : "(none)");
 
    if (!datastore || !datastore->data) {
        ast_log(AST_LOG_ERROR, "No headers had been previously added to this session.\n");
        return -1;
    }
 
    list = datastore->data;
    AST_LIST_TRAVERSE_SAFE_BEGIN(list, le, nextptr) {
        if (len >= 1 && data->header_name[len - 1] == '*') {
            if (pj_strnicmp2(&le->hdr->name, data->header_name, len - 1) == 0) {
                ast_debug(3, "Found wildcard match, removing header %.*s from channel %p\n",
                    (int)le->hdr->name.slen, le->hdr->name.ptr,
                    data->channel->session->channel ? ast_channel_name(data->channel->session->channel) : "(none)");
                AST_LIST_REMOVE_CURRENT(nextptr);
                removed_count++;
            }
        } else {
            if (pj_stricmp2(&le->hdr->name, data->header_name) == 0) {
                ast_debug(3, "Found exact match, removing header %.*s from channel %p\n",
                    (int)le->hdr->name.slen, le->hdr->name.ptr,
                    data->channel->session->channel ? ast_channel_name(data->channel->session->channel) : "(none)");
                AST_LIST_REMOVE_CURRENT(nextptr);
                removed_count++;
            }
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    if (removed_count == 0) {
        ast_debug(3, "No headers named %s found to remove on channel %s.\n", data->header_name,
            data->channel->session->channel ? ast_channel_name(data->channel->session->channel) : "(none)");
    }
 
    if (data->buf && data->len) {
        snprintf(data->buf, data->len, "%d", removed_count);
        ast_debug(3, "Removed %d headers matching %s from channel %s\n", removed_count, data->header_name,
            data->channel->session->channel ? ast_channel_name(data->channel->session->channel) : "(none)");
    }
 
    return 0;
}

References ao2_cleanup, ast_channel_name(), ast_debug, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log, AST_LOG_ERROR, ast_sip_session_get_datastore(), header_data::buf, ast_sip_session::channel, header_data::channel, hdr_list_entry::hdr, header_data::header_name, len(), header_data::len, hdr_list_entry::nextptr, RAII_VAR, ast_sip_channel_pvt::session, session_header_datastore, and ast_datastore_info::type.

Referenced by func_read_header(), and func_write_header().

remove_inheritable_header()

static int remove_inheritable_header ( struct ast_channel *  channel, const char *  header_name  )

static

Definition at line 1079 of file res_pjsip_header_funcs.c.

{
    size_t len = strlen(header_name);
    struct ast_variable *headers = NULL;
    struct ast_variable *var, *prev = NULL;
    int removed_count = 0;
    struct ast_datastore *inherited_datastore;
 
    ast_channel_lock(channel);
    inherited_datastore = ast_channel_datastore_find(channel, &inheritable_header_datastore, NULL);
    ast_debug(3, "Attempting to remove header %s from channel %s\n",
        header_name, ast_channel_name(channel));
 
    /* Remove from inherited datastore */
    if (!inherited_datastore || !inherited_datastore->data) {
        ast_log(AST_LOG_ERROR, "No inheritable headers had been previously added to channel %s.\n",
            ast_channel_name(channel));
        ast_channel_unlock(channel);
        return -1;
    }
 
    headers = inherited_datastore->data;
 
    /* If removing all headers */
    if (strcmp(header_name, "*") == 0) {
        inheritable_headers_destroy(headers);
        inherited_datastore->data = NULL;
        ast_debug(3, "Removed all inheritable headers from channel %s\n",
            ast_channel_name(channel));
        ast_channel_unlock(channel);
        return 0;
    }
 
    /* Remove specific headers (exact match or wildcard) */
    var = headers;
    while (var) {
        struct ast_variable *next = var->next;
        int match = 0;
 
        if (len >= 1 && header_name[len - 1] == '*') {
            /* Wildcard match */
            match = (strncasecmp(var->name, header_name, len - 1) == 0);
            if (match) {
                ast_debug(3, "Found wildcard match, removing header %s with value %s from channel %s\n",
                    var->name, var->value, ast_channel_name(channel));
            }
        } else {
            /* Exact match */
            match = (strcasecmp(var->name, header_name) == 0);
            if (match) {
                ast_debug(3, "Found exact match, removing header %s with value %s from channel %s\n",
                    var->name, var->value, ast_channel_name(channel));
            }
        }
 
        if (match) {
            /* Remove this variable */
            if (var == headers) {
                /* If we're removing the first header in the list, we need to update the head pointer */
                headers = next;
                inherited_datastore->data = headers;
            } else if (prev) {
                /* Otherwise, we need to link the previous header to the next header */
                prev->next = next;
            }
 
            /* destroy the variable */
            var->next = NULL;
            ast_variables_destroy(var);
            removed_count++;
            var = next;
        } else {
            prev = var;
            var = next;
        }
    }
 
    /* Update datastore with new list head */
    inherited_datastore->data = headers;
 
    if (removed_count == 0) {
        ast_debug(3, "No headers matching %s found for channel %s\n",
            header_name, ast_channel_name(channel));
    }
 
    ast_debug(3, "Removed %d headers matching %s from channel %s\n", removed_count, header_name,
        ast_channel_name(channel));
 
    ast_channel_unlock(channel);
    return 0;
}

References ast_channel_datastore_find(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_debug, ast_log, AST_LOG_ERROR, ast_variables_destroy(), ast_datastore::data, inheritable_header_datastore, inheritable_headers_destroy(), len(), match(), ast_variable::next, NULL, and var.

Referenced by func_write_inheritable_header().

unload_module()

static int unload_module ( void  )

static

Definition at line 1829 of file res_pjsip_header_funcs.c.

{
    ast_custom_function_unregister(&pjsip_header_function);
    ast_custom_function_unregister(&pjsip_header_inherit_function);
    ast_custom_function_unregister(&pjsip_headers_function);
    ast_custom_function_unregister(&pjsip_response_header_function);
    ast_custom_function_unregister(&pjsip_response_headers_function);
    ast_custom_function_unregister(&pjsip_header_param_function);
    ast_sip_session_unregister_supplement(&header_funcs_supplement);
    return 0;
}

References ast_custom_function_unregister(), ast_sip_session_unregister_supplement(), header_funcs_supplement, pjsip_header_function, pjsip_header_inherit_function, pjsip_header_param_function, pjsip_headers_function, pjsip_response_header_function, and pjsip_response_headers_function.

update_header()

static int update_header ( void *  obj )

static

Definition at line 881 of file res_pjsip_header_funcs.c.

{
    struct header_data *data = obj;
    pj_pool_t *pool = data->channel->session->inv_session->dlg->pool;
    pjsip_hdr *hdr = NULL;
    RAII_VAR(struct ast_datastore *, datastore,
             ast_sip_session_get_datastore(data->channel->session, session_header_datastore.type),
             ao2_cleanup);
 
    ast_debug(3, "Attempting to update header %s for channel %p\n", data->header_name,
        data->channel->session->channel ? ast_channel_name(data->channel->session->channel) : "(none)");
 
    if (!datastore || !datastore->data) {
        ast_log(AST_LOG_ERROR, "No headers had been previously added to this session.\n");
        return -1;
    }
 
    hdr = find_header((struct hdr_list *) datastore->data, data->header_name,
                      data->header_number);
 
    if (!hdr) {
        ast_log(AST_LOG_ERROR, "There was no header named %s.\n", data->header_name);
        return -1;
    }
 
    ast_debug(3, "Found header %s in session datastore, updating value to %s for channel %p\n",
                data->header_name, data->header_value,
                data->channel->session->channel ? ast_channel_name(data->channel->session->channel) : "(none)");
    pj_strdup2(pool, &((pjsip_generic_string_hdr *) hdr)->hvalue, data->header_value);
 
    return 0;
}

References ao2_cleanup, ast_channel_name(), ast_debug, ast_log, AST_LOG_ERROR, ast_sip_session_get_datastore(), ast_sip_session::channel, header_data::channel, find_header(), header_data::header_name, header_data::header_number, header_data::header_value, ast_sip_session::inv_session, NULL, RAII_VAR, ast_sip_channel_pvt::session, session_header_datastore, and ast_datastore_info::type.

Referenced by func_write_header().

update_inheritable_header()

static int update_inheritable_header ( struct ast_channel *  channel, const char *  header_name, const char *  header_value, int  header_number  )

static

Definition at line 925 of file res_pjsip_header_funcs.c.

{
    struct ast_datastore *inherited_datastore;
    struct ast_variable *headers = NULL;
    struct ast_variable *var, *prev = NULL;
    int i = 1, num_matching_headers = 0, target_header_index;
 
    ast_channel_lock(channel);
    inherited_datastore = ast_channel_datastore_find(channel, &inheritable_header_datastore, NULL);
    ast_debug(3, "Attempting to update header %s for channel %s\n", header_name,
        ast_channel_name(channel));
 
    if (!inherited_datastore || !inherited_datastore->data) {
        ast_log(AST_LOG_ERROR, "No inheritable headers had been previously added to this channel.\n");
        ast_channel_unlock(channel);
        return -1;
    }
 
    headers = inherited_datastore->data;
 
    /* The headers are in reverse order so we need to find out how many there are to know which one to update */
    for (var = headers; var; var = var->next) {
        if (strcasecmp(var->name, header_name) == 0) {
            num_matching_headers++;
        }
    }
 
    /* As we already counted the matching headers, we can skip walking the list again if the count is 0 or
        is less than the requested header number */
    if (num_matching_headers == 0) {
        ast_log(AST_LOG_ERROR, "There was no header named %s on channel %s.\n", header_name,
            ast_channel_name(channel));
        ast_channel_unlock(channel);
        return -1;
    } else if (num_matching_headers < header_number) {
        ast_log(AST_LOG_ERROR, "There were only %d headers named %s on channel %s, cannot update header number %d.\n",
            num_matching_headers, header_name, ast_channel_name(channel), header_number);
        ast_channel_unlock(channel);
        return -1;
    }
 
    target_header_index = num_matching_headers - header_number + 1;
    /* Search for the header in the inherited list */
    for (var = headers; var; var = var->next) {
        if (strcasecmp(var->name, header_name) == 0 && i++ == target_header_index) {
            /* Found the header, create a new one with the new value and free the old */
            struct ast_variable *new_var = ast_variable_new(header_name, header_value, "");
            if (!new_var) {
                ast_log(AST_LOG_ERROR, "Failed to allocate variable for updated header for channel %s\n",
                    ast_channel_name(channel));
                ast_channel_unlock(channel);
                return -1;
            }
 
            new_var->next = var->next;
 
            if (var == headers) {
                /* If we're updating the first header in the list, we need to update the head pointer */
                inherited_datastore->data = new_var;
            } else if (prev) {
                /* Otherwise, we need to link the previous header to the new header */
                prev->next = new_var;
            }
 
            var->next = NULL;
            inheritable_headers_destroy(var);
 
            ast_debug(3, "Updated header %s with new value %s for channel %s\n",
                header_name, header_value, ast_channel_name(channel));
            ast_channel_unlock(channel);
            return 0;
        }
        prev = var;
    }
 
    /* We should never get here*/
    ast_log(AST_LOG_ERROR, "Unable to update header %s on channel %s.\n", header_name,
        ast_channel_name(channel));
    ast_channel_unlock(channel);
    return -1;
}

References ast_channel_datastore_find(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_debug, ast_log, AST_LOG_ERROR, ast_variable_new, ast_datastore::data, inheritable_header_datastore, inheritable_headers_destroy(), ast_variable::next, NULL, and var.

Referenced by func_write_inheritable_header().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP Header Functions" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND, .requires = "res_pjsip,res_pjsip_session", }

static

Definition at line 1847 of file res_pjsip_header_funcs.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1847 of file res_pjsip_header_funcs.c.

header_funcs_supplement

struct ast_sip_session_supplement header_funcs_supplement

static

Definition at line 1589 of file res_pjsip_header_funcs.c.

                                                                   {
    .method = "INVITE",
    .priority = AST_SIP_SUPPLEMENT_PRIORITY_CHANNEL - 1000,
    .incoming_request = incoming_request,
    .outgoing_request = outgoing_request,
    .incoming_response = incoming_response,
};

Referenced by load_module(), and unload_module().

inheritable_header_datastore

const struct ast_datastore_info inheritable_header_datastore

static

Initial value:

= {
    .type = "inheritable_header_datastore",
    .duplicate = inheritable_headers_duplicate,
    .destroy = inheritable_headers_destroy,
}

Datastore for saving inheritable headers (contains hdr_list with ast_malloc'd entries)

Definition at line 441 of file res_pjsip_header_funcs.c.

                                                                      {
    .type = "inheritable_header_datastore",
    .duplicate = inheritable_headers_duplicate,
    .destroy = inheritable_headers_destroy,
};

Referenced by add_inheritable_header(), outgoing_request(), remove_inheritable_header(), and update_inheritable_header().

pjsip_header_function

struct ast_custom_function pjsip_header_function

static

Initial value:

= {
    .name = "PJSIP_HEADER",
    .read = func_read_header,
    .write = func_write_header,
}

Definition at line 1460 of file res_pjsip_header_funcs.c.

                                                          {
    .name = "PJSIP_HEADER",
    .read = func_read_header,
    .write = func_write_header,
};

Referenced by load_module(), and unload_module().

pjsip_header_inherit_function

struct ast_custom_function pjsip_header_inherit_function

static

Initial value:

= {
    .name = "PJSIP_INHERITABLE_HEADER",
    .write = func_write_inheritable_header,
}

Definition at line 1466 of file res_pjsip_header_funcs.c.

                                                                  {
    .name = "PJSIP_INHERITABLE_HEADER",
    .write = func_write_inheritable_header,
};

Referenced by load_module(), and unload_module().

pjsip_header_param_function

struct ast_custom_function pjsip_header_param_function

static

Initial value:

= {
    .name = "PJSIP_HEADER_PARAM",
    .read = func_read_param,
    .write = func_write_param,
}

Definition at line 1810 of file res_pjsip_header_funcs.c.

                                                                {
    .name = "PJSIP_HEADER_PARAM",
    .read = func_read_param,
    .write = func_write_param,
};

Referenced by load_module(), and unload_module().

pjsip_headers_function

struct ast_custom_function pjsip_headers_function

static

Initial value:

= {
    .name = "PJSIP_HEADERS",
    .read = func_read_headers
}

Definition at line 1471 of file res_pjsip_header_funcs.c.

                                                           {
    .name = "PJSIP_HEADERS",
    .read = func_read_headers
};

Referenced by load_module(), and unload_module().

pjsip_response_header_function

struct ast_custom_function pjsip_response_header_function

static

Initial value:

= {
    .name = "PJSIP_RESPONSE_HEADER",
    .read = func_response_read_header
}

Definition at line 1476 of file res_pjsip_header_funcs.c.

                                                                   {
    .name = "PJSIP_RESPONSE_HEADER",
    .read = func_response_read_header
};

Referenced by load_module(), and unload_module().

pjsip_response_headers_function

struct ast_custom_function pjsip_response_headers_function

static

Initial value:

= {
    .name = "PJSIP_RESPONSE_HEADERS",
    .read = func_response_read_headers
}

Definition at line 1481 of file res_pjsip_header_funcs.c.

                                                                    {
    .name = "PJSIP_RESPONSE_HEADERS",
    .read = func_response_read_headers
};

Referenced by load_module(), and unload_module().

response_header_datastore

const struct ast_datastore_info response_header_datastore

static

Initial value:

= {
    .type = "response_header_datastore",
}

Datastore for saving response headers.

Definition at line 448 of file res_pjsip_header_funcs.c.

                                                                   {
    .type = "response_header_datastore",
};

Referenced by func_response_read_header(), func_response_read_headers(), and incoming_response().

session_header_datastore

const struct ast_datastore_info session_header_datastore

static

Initial value:

= {
    .type = "session_header_datastore",
    
}

Datastore for saving headers in session (contains hdr_list, no destroy needed)

Definition at line 435 of file res_pjsip_header_funcs.c.

                                                                  {
    .type = "session_header_datastore",
    /* No destroy or duplicate callback - data is pool-allocated hdr_list */
};

Referenced by add_header(), func_read_header(), func_read_headers(), func_write_header(), incoming_request(), outgoing_request(), remove_header(), and update_header().