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_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_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 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	unload_module (void)
static int	update_header (void *obj)

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 const struct ast_datastore_info	header_datastore
	Datastore for saving headers.
static struct ast_sip_session_supplement	header_funcs_supplement
static struct ast_custom_function	pjsip_header_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.

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 1063 of file res_pjsip_header_funcs.c.

                {
    PARAMETER_HEADER,
    PARAMETER_URI,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1311 of file res_pjsip_header_funcs.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1311 of file res_pjsip_header_funcs.c.

add_header()

static int add_header ( void *  obj )

static

Definition at line 643 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, data->header_datastore->type), ao2_cleanup);
 
    if (!datastore) {
        if (!(datastore = ast_sip_session_alloc_datastore(data->header_datastore,
                                                        data->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_datastore, header_data::header_name, header_data::header_value, RAII_VAR, ast_sip_channel_pvt::session, session, and ast_datastore_info::type.

Referenced by func_write_header().

add_param()

static int add_param ( void *  obj )

static

Definition at line 1131 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 1311 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 438 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 832 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 = &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_datastore, 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, and ast_sip_channel_pvt::session.

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 769 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 = &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_datastore, 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, and ast_sip_channel_pvt::session.

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 1179 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 890 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 797 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 945 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 = &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_datastore, 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, update_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 1229 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 376 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, header_datastore.type), ao2_cleanup);
 
    if (!datastore) {
        if (!(datastore =
              ast_sip_session_alloc_datastore(&header_datastore, 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(), header_datastore, insert_headers(), RAII_VAR, session, and ast_datastore_info::type.

incoming_response()

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

static

Definition at line 406 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.

insert_headers()

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

static

Definition at line 353 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 1282 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_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_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 1036 of file res_pjsip_header_funcs.c.

{
    struct hdr_list *list;
    struct hdr_list_entry *le;
    RAII_VAR(struct ast_datastore *, datastore,
             ast_sip_session_get_datastore(session, header_datastore.type), ao2_cleanup);
 
    if (!datastore || !datastore->data ||
        (session->inv_session->state >= PJSIP_INV_STATE_CONFIRMED)) {
        return;
    }
 
    list = datastore->data;
    AST_LIST_TRAVERSE(list, le, nextptr) {
        pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr *) pjsip_hdr_clone(tdata->pool, le->hdr));
    }
    ast_sip_session_remove_datastore(session, datastore->uid);
}

References ao2_cleanup, AST_LIST_TRAVERSE, ast_sip_session_get_datastore(), ast_sip_session_remove_datastore(), hdr_list_entry::hdr, header_datastore, hdr_list_entry::nextptr, RAII_VAR, session, and ast_datastore_info::type.

read_header()

static int read_header ( void *  obj )

static

Definition at line 560 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 (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 469 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 1079 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 727 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, data->header_datastore->type),
             ao2_cleanup);
 
    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 (data->header_name[len - 1] == '*') {
            if (pj_strnicmp2(&le->hdr->name, data->header_name, len - 1) == 0) {
                AST_LIST_REMOVE_CURRENT(nextptr);
                removed_count++;
            }
        } else {
            if (pj_stricmp2(&le->hdr->name, data->header_name) == 0) {
                AST_LIST_REMOVE_CURRENT(nextptr);
                removed_count++;
            }
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    if (data->buf && data->len) {
        snprintf(data->buf, data->len, "%d", removed_count);
    }
 
    return 0;
}

References ao2_cleanup, 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, header_data::channel, hdr_list_entry::hdr, header_data::header_datastore, header_data::header_name, len(), header_data::len, hdr_list_entry::nextptr, RAII_VAR, ast_sip_channel_pvt::session, and ast_datastore_info::type.

Referenced by func_read_header(), and func_write_header().

unload_module()

static int unload_module ( void  )

static

Definition at line 1294 of file res_pjsip_header_funcs.c.

{
    ast_custom_function_unregister(&pjsip_header_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_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 692 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, data->header_datastore->type),
             ao2_cleanup);
 
    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;
    }
 
    pj_strdup2(pool, &((pjsip_generic_string_hdr *) hdr)->hvalue, data->header_value);
 
    return 0;
}

References ao2_cleanup, ast_log, AST_LOG_ERROR, ast_sip_session_get_datastore(), header_data::channel, find_header(), header_data::header_datastore, 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, and ast_datastore_info::type.

Referenced by func_write_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 1311 of file res_pjsip_header_funcs.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1311 of file res_pjsip_header_funcs.c.

header_datastore

const struct ast_datastore_info header_datastore

static

Initial value:

= {
    .type = "header_datastore",
}

Datastore for saving headers.

Definition at line 327 of file res_pjsip_header_funcs.c.

                                                          {
    .type = "header_datastore",
};

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

header_funcs_supplement

struct ast_sip_session_supplement header_funcs_supplement

static

Definition at line 1055 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().

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 1003 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_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 1276 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 1009 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 1014 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 1019 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 331 of file res_pjsip_header_funcs.c.

                                                                   {
    .type = "response_header_datastore",
};

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