main/message.c File Reference

Out-of-call text message support. More...

#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/module.h"
#include "asterisk/datastore.h"
#include "asterisk/pbx.h"
#include "asterisk/manager.h"
#include "asterisk/strings.h"
#include "asterisk/astobj2.h"
#include "asterisk/vector.h"
#include "asterisk/app.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/message.h"

Include dependency graph for main/message.c:

Go to the source code of this file.

Data Structures
struct	ast_msg
	A message. More...
struct	ast_msg_data
	Structure used to transport a message through the frame core. More...
struct	ast_msg_var_iterator
struct	msg_data
struct	outhead

Macros
#define	ATTRIBUTE_UNSET   -1

Functions
static void	__init_msg_q_chan (void)
static int	action_messagesend (struct mansession *s, const struct message *m)
struct ast_msg *	ast_msg_alloc (void)
	Allocate a message. More...
struct ast_msg_data *	ast_msg_data_alloc (enum ast_msg_data_source_type source, struct ast_msg_data_attribute attributes[], size_t count)
	Allocates an ast_msg_data structure. More...
struct ast_msg_data *	ast_msg_data_alloc2 (enum ast_msg_data_source_type source_type, const char *to, const char *from, const char *content_type, const char *body)
	Allocates an ast_msg_data structure. More...
struct ast_msg_data *	ast_msg_data_dup (struct ast_msg_data *msg)
	Clone an ast_msg_data structure. More...
const char *	ast_msg_data_get_attribute (struct ast_msg_data *msg, enum ast_msg_data_attribute_type attribute_type)
	Get attribute from ast_msg_data. More...
size_t	ast_msg_data_get_length (struct ast_msg_data *msg)
	Get length of the structure. More...
enum ast_msg_data_source_type	ast_msg_data_get_source_type (struct ast_msg_data *msg)
	Get "source type" from ast_msg_data. More...
int	ast_msg_data_queue_frame (struct ast_channel *channel, struct ast_msg_data *msg)
	Queue an AST_FRAME_TEXT_DATA frame containing an ast_msg_data structure. More...
struct ast_msg *	ast_msg_destroy (struct ast_msg *msg)
	Destroy an ast_msg. More...
const char *	ast_msg_get_body (const struct ast_msg *msg)
	Get the body of a message. More...
const char *	ast_msg_get_endpoint (const struct ast_msg *msg)
	Retrieve the endpoint associated with this message. More...
const char *	ast_msg_get_from (const struct ast_msg *msg)
	Retrieve the source of this message. More...
const char *	ast_msg_get_tech (const struct ast_msg *msg)
	Retrieve the technology associated with this message. More...
const char *	ast_msg_get_to (const struct ast_msg *msg)
	Retrieve the destination of this message. More...
const char *	ast_msg_get_var (struct ast_msg *msg, const char *name)
	Get the specified variable on the message. More...
int	ast_msg_handler_register (const struct ast_msg_handler *handler)
	Register a ast_msg_handler. More...
int	ast_msg_handler_unregister (const struct ast_msg_handler *handler)
	Unregister a ast_msg_handler. More...
int	ast_msg_has_destination (const struct ast_msg *msg)
	Determine if a particular message has a destination via some handler. More...
int	ast_msg_init (void)
int	ast_msg_queue (struct ast_msg *msg)
	Queue a message for routing through the dialplan. More...
struct ast_msg *	ast_msg_ref (struct ast_msg *msg)
	Bump a msg's ref count. More...
int	ast_msg_send (struct ast_msg *msg, const char *to, const char *from)
	Send a msg directly to an endpoint. More...
int	ast_msg_set_body (struct ast_msg *msg, const char *fmt,...)
	Set the 'body' text of a message (in UTF-8) More...
int	ast_msg_set_context (struct ast_msg *msg, const char *fmt,...)
	Set the dialplan context for this message. More...
int	ast_msg_set_endpoint (struct ast_msg *msg, const char *fmt,...)
	Set the technology's endpoint associated with this message. More...
int	ast_msg_set_exten (struct ast_msg *msg, const char *fmt,...)
	Set the dialplan extension for this message. More...
int	ast_msg_set_from (struct ast_msg *msg, const char *fmt,...)
	Set the 'from' URI of a message. More...
int	ast_msg_set_tech (struct ast_msg *msg, const char *fmt,...)
	Set the technology associated with this message. More...
int	ast_msg_set_to (struct ast_msg *msg, const char *fmt,...)
	Set the 'to' URI of a message. More...
int	ast_msg_set_var (struct ast_msg *msg, const char *name, const char *value)
	Set a variable on the message going to the dialplan. More...
int	ast_msg_set_var_outbound (struct ast_msg *msg, const char *name, const char *value)
	Set a variable on the message being sent to a message tech directly. More...
void	ast_msg_shutdown (void)
int	ast_msg_tech_register (const struct ast_msg_tech *tech)
	Register a message technology. More...
int	ast_msg_tech_unregister (const struct ast_msg_tech *tech)
	Unregister a message technology. More...
void	ast_msg_var_iterator_destroy (struct ast_msg_var_iterator *iter)
	Destroy a message variable iterator. More...
static int	ast_msg_var_iterator_get_next (const struct ast_msg *msg, struct ast_msg_var_iterator *iter, const char **name, const char **value, unsigned int send)
struct ast_msg_var_iterator *	ast_msg_var_iterator_init (const struct ast_msg *msg)
	Create a new message variable iterator. More...
int	ast_msg_var_iterator_next (const struct ast_msg *msg, struct ast_msg_var_iterator *iter, const char **name, const char **value)
	Get the next variable name and value that is set for sending outbound. More...
int	ast_msg_var_iterator_next_received (const struct ast_msg *msg, struct ast_msg_var_iterator *iter, const char **name, const char **value)
	Get the next variable name and value that was set on a received message. More...
void	ast_msg_var_unref_current (struct ast_msg_var_iterator *iter)
	Unref a message var from inside an iterator loop. More...
static void	chan_cleanup (struct ast_channel *chan)
static int	chan_msg_indicate (struct ast_channel *chan, int condition, const void *data, size_t datalen)
static struct ast_frame *	chan_msg_read (struct ast_channel *chan)
static int	chan_msg_send_digit_begin (struct ast_channel *chan, char digit)
static int	chan_msg_send_digit_end (struct ast_channel *chan, char digit, unsigned int duration)
static int	chan_msg_write (struct ast_channel *chan, struct ast_frame *fr)
static struct ast_channel *	create_msg_q_chan (void)
static void	destroy_msg_q_chan (void *data)
static int	dialplan_handle_msg_cb (struct ast_msg *msg)
static int	dialplan_has_destination_cb (const struct ast_msg *msg)
static void	message_shutdown (void)
static struct msg_data *	msg_data_alloc (void)
static int	msg_data_cmp_fn (void *obj, void *arg, int flags)
static void	msg_data_destructor (void *obj)
static struct msg_data *	msg_data_find (struct ao2_container *vars, const char *name)
static int	msg_data_func_read (struct ast_channel *chan, const char *function, char *data, char *buf, size_t len)
static int	msg_data_func_write (struct ast_channel *chan, const char *function, char *data, const char *value)
static struct ast_datastore *	msg_datastore_find_or_create (struct ast_channel *chan)
static void	msg_destructor (void *obj)
static void	msg_ds_destroy (void *data)
static const struct ast_msg_tech *	msg_find_by_tech_name (const char *tech_name)
static int	msg_func_read (struct ast_channel *chan, const char *function, char *data, char *buf, size_t len)
static int	msg_func_write (struct ast_channel *chan, const char *function, char *data, const char *value)
static int	msg_handler_cmp (const struct ast_msg_handler *vec_elem, const struct ast_msg_handler *srch)
	Comparison callback for ast_msg_handler vector removal. More...
static const struct ast_msg_handler *	msg_handler_find_by_tech_name (const char *tech_name)
static int	msg_q_cb (void *data)
static void	msg_route (struct ast_channel *chan, struct ast_msg *msg)
static int	msg_send_exec (struct ast_channel *chan, const char *data)
static int	msg_set_var_full (struct ast_msg *msg, const char *name, const char *value, unsigned int outbound)
static int	msg_tech_cmp (const struct ast_msg_tech *vec_elem, const struct ast_msg_tech *srch)
	Comparison callback for ast_msg_tech vector removal. More...

Variables
static const char	app_msg_send [] = "MessageSend"
static struct ast_msg_handler	dialplan_msg_handler
static struct ast_channel_tech	msg_chan_tech_hack
static struct ast_custom_function	msg_data_function
static const struct ast_datastore_info	msg_datastore
static struct ast_custom_function	msg_function
struct {
size_t   current
const struct ast_msg_handler **   elems
size_t   max
}	msg_handlers
	Vector of received message handlers. More...
static ast_rwlock_t	msg_handlers_lock
	Lock for msg_handlers vector. More...
static struct ast_threadstorage	msg_q_chan = { .once = PTHREAD_ONCE_INIT , .key_init = __init_msg_q_chan , .custom_init = NULL , }
static struct ast_taskprocessor *	msg_q_tp
struct {
size_t   current
const struct ast_msg_tech **   elems
size_t   max
}	msg_techs
	Vector of message technologies. More...
static ast_rwlock_t	msg_techs_lock
	Lock for msg_techs vector. More...

Detailed Description

Out-of-call text message support.

Author

Russell Bryant russe.nosp@m.ll@d.nosp@m.igium.nosp@m..com

Definition in file main/message.c.

Macro Definition Documentation

ATTRIBUTE_UNSET

#define ATTRIBUTE_UNSET   -1

Definition at line 1456 of file main/message.c.

Function Documentation

__init_msg_q_chan()

static void __init_msg_q_chan ( void  )

static

Definition at line 875 of file main/message.c.

{

action_messagesend()

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

static

Definition at line 1333 of file main/message.c.

{
    const char *destination = astman_get_header(m, "Destination");
    const char *to = astman_get_header(m, "To");
    const char *from = astman_get_header(m, "From");
    const char *body = astman_get_header(m, "Body");
    const char *base64body = astman_get_header(m, "Base64Body");
    const char *to_override = NULL;
    char base64decoded[1301] = { 0, };
    char *tech_name = NULL;
    struct ast_variable *vars = NULL;
    struct ast_variable *data = NULL;
    const struct ast_msg_tech *msg_tech;
    struct ast_msg *msg;
    int res = -1;
 
    if (!ast_strlen_zero(destination)) {
        if (!ast_strlen_zero(to)) {
            to_override = to;
        }
        to = destination;
    } else {
        if (ast_strlen_zero(to)) {
            astman_send_error(s, m, "No 'To' address specified.");
            return 0;
        }
    }
 
    if (!ast_strlen_zero(base64body)) {
        ast_base64decode((unsigned char *) base64decoded, base64body, sizeof(base64decoded) - 1);
        body = base64decoded;
    }
 
    tech_name = ast_strdupa(to);
    tech_name = strsep(&tech_name, ":");
 
    ast_rwlock_rdlock(&msg_techs_lock);
    msg_tech = msg_find_by_tech_name(tech_name);
    if (!msg_tech) {
        ast_rwlock_unlock(&msg_techs_lock);
        astman_send_error(s, m, "Message technology not found.");
        return 0;
    }
 
    if (!(msg = ast_msg_alloc())) {
        ast_rwlock_unlock(&msg_techs_lock);
        astman_send_error(s, m, "Internal failure\n");
        return 0;
    }
 
    data = astman_get_variables_order(m, ORDER_NATURAL);
    for (vars = data; vars; vars = vars->next) {
        ast_msg_set_var_outbound(msg, vars->name, vars->value);
    }
 
    ast_msg_set_body(msg, "%s", body);
 
    if (to_override) {
        ast_string_field_set(msg, to, to_override);
    }
 
    res = msg_tech->msg_send(msg, S_OR(to, ""), S_OR(from, ""));
 
    ast_rwlock_unlock(&msg_techs_lock);
 
    ast_variables_destroy(vars);
    ao2_ref(msg, -1);
 
    if (res) {
        astman_send_error(s, m, "Message failed to send.");
    } else {
        astman_send_ack(s, m, "Message successfully sent");
    }
    return 0;
}

References ao2_ref, ast_base64decode(), ast_msg_alloc(), ast_msg_set_body(), ast_msg_set_var_outbound(), ast_rwlock_rdlock, ast_rwlock_unlock, ast_strdupa, ast_string_field_set, ast_strlen_zero(), ast_variables_destroy(), astman_get_header(), astman_get_variables_order(), astman_send_ack(), astman_send_error(), ast_msg::body, ast_msg::from, msg_find_by_tech_name(), ast_msg_tech::msg_send, msg_tech, msg_techs_lock, NULL, ORDER_NATURAL, S_OR, strsep(), ast_msg::to, and ast_msg::vars.

Referenced by ast_msg_init().

ast_msg_alloc()

struct ast_msg * ast_msg_alloc

(

void

)

Allocate a message.

Allocate a message for the purposes of passing it into the Asterisk core to be routed through the dialplan. If ast_msg_queue() is not called, this message must be destroyed using ast_msg_destroy(). Otherwise, the message core code will take care of it.

Returns

A message object. This function will return NULL if an allocation error occurs.

Definition at line 444 of file main/message.c.

{
    struct ast_msg *msg;
 
    if (!(msg = ao2_alloc(sizeof(*msg), msg_destructor))) {
        return NULL;
    }
 
    if (ast_string_field_init(msg, 128)) {
        ao2_ref(msg, -1);
        return NULL;
    }
 
    msg->vars = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        NULL, msg_data_cmp_fn);
    if (!msg->vars) {
        ao2_ref(msg, -1);
        return NULL;
    }
    ast_string_field_set(msg, context, "default");
 
    return msg;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_list, ao2_ref, ast_string_field_init, ast_string_field_set, voicemailpwcheck::context, msg_data_cmp_fn(), msg_destructor(), NULL, and ast_msg::vars.

Referenced by action_messagesend(), AST_TEST_DEFINE(), module_on_rx_request(), msg_datastore_find_or_create(), send_message(), and xmpp_pak_message().

ast_msg_destroy()

struct ast_msg * ast_msg_destroy

(

struct ast_msg *

msg

)

Destroy an ast_msg.

This should only be called on a message if it was not passed on to ast_msg_queue().

Return values

NULL

always.

Definition at line 474 of file main/message.c.

{
    ao2_ref(msg, -1);
    return NULL;
}

References ao2_ref, and NULL.

Referenced by ast_msg_safe_destroy(), module_on_rx_request(), msg_data_destroy(), send_message(), and xmpp_pak_message().

ast_msg_get_body()

const char * ast_msg_get_body

(

const struct ast_msg *

msg

)

Get the body of a message.

Note

The return value is valid only as long as the ast_message is valid. Hold a reference to the message if you plan on storing the return value.

Returns

The body of the messsage, encoded in UTF-8.

Definition at line 557 of file main/message.c.

{
    return msg->body;
}

References ast_msg::body.

Referenced by AST_TEST_DEFINE(), msg_send(), msg_to_json(), and xmpp_send_cb().

ast_msg_get_endpoint()

const char * ast_msg_get_endpoint

(

const struct ast_msg *

msg

)

Retrieve the endpoint associated with this message.

Since

12.5.0

Parameters

msg	The message to get the endpoint from

Returns

The endpoint associated with the message

Return values

NULL	or empty string if the message has no associated endpoint

Definition at line 577 of file main/message.c.

{
    return msg->endpoint;
}

References ast_msg::endpoint.

Referenced by AST_TEST_DEFINE(), and msg_to_endpoint().

ast_msg_get_from()

const char * ast_msg_get_from

(

const struct ast_msg *

msg

)

Retrieve the source of this message.

Since

12.5.0

Parameters

msg	The message to get the soure from

Returns

The source of the message

Return values

NULL	or empty string if the message has no source

Definition at line 562 of file main/message.c.

{
    return msg->from;
}

References ast_msg::from.

Referenced by AST_TEST_DEFINE(), msg_send(), and msg_to_json().

ast_msg_get_tech()

const char * ast_msg_get_tech

(

const struct ast_msg *

msg

)

Retrieve the technology associated with this message.

Since

12.5.0

Parameters

msg	The message to get the technology from

Returns

The technology of the message

Return values

NULL	or empty string if the message has no associated technology

Definition at line 572 of file main/message.c.

{
    return msg->tech;
}

References ast_msg::tech.

Referenced by AST_TEST_DEFINE(), and msg_to_endpoint().

ast_msg_get_to()

const char * ast_msg_get_to

(

const struct ast_msg *

msg

)

Retrieve the destination of this message.

Since

12.5.0

Parameters

msg	The message to get the destination from

Returns

The destination of the message

Return values

NULL	or empty string if the message has no destination

Definition at line 567 of file main/message.c.

{
    return msg->to;
}

References ast_msg::to.

Referenced by AST_TEST_DEFINE(), msg_send(), msg_to_json(), and test_msg_has_destination_cb().

ast_msg_get_var()

const char * ast_msg_get_var	(	struct ast_msg *	msg,
		const char *	name
	)

Get the specified variable on the message.

Note

The return value is valid only as long as the ast_message is valid. Hold a reference to the message if you plan on storing the return value. Do re-set the same message var name while holding a pointer to the result of this function.

Returns

The value associated with variable "name". NULL if variable not found.

Definition at line 646 of file main/message.c.

{
    struct msg_data *data;
    const char *val = NULL;
 
    if (!(data = msg_data_find(msg->vars, name))) {
        return NULL;
    }
 
    /* Yep, this definitely looks like val would be a dangling pointer
     * after the ref count is decremented.  As long as the message structure
     * is used in a thread safe manner, this will not be the case though.
     * The ast_msg holds a reference to this object in the msg->vars container. */
    val = data->value;
    ao2_ref(data, -1);
 
    return val;
}

References ao2_ref, msg_data::msg, msg_data_find(), name, NULL, msg_data::value, and ast_msg::vars.

Referenced by AST_TEST_DEFINE(), msg_data_func_read(), and update_content_type().

ast_msg_handler_register()

int ast_msg_handler_register

(

const struct ast_msg_handler *

handler

)

Register a ast_msg_handler.

Since

12.5.0

Parameters

handler

The handler to register

Return values

0	Success
non-zero	Error

Definition at line 1669 of file main/message.c.

{
    const struct ast_msg_handler *match;
 
    ast_rwlock_wrlock(&msg_handlers_lock);
 
    match = msg_handler_find_by_tech_name(handler->name);
    if (match) {
        ast_log(LOG_ERROR, "Message handler already registered for '%s'\n",
                handler->name);
        ast_rwlock_unlock(&msg_handlers_lock);
        return -1;
    }
 
    if (AST_VECTOR_APPEND(&msg_handlers, handler)) {
        ast_log(LOG_ERROR, "Failed to register message handler for '%s'\n",
                handler->name);
        ast_rwlock_unlock(&msg_handlers_lock);
        return -1;
    }
    ast_verb(5, "Message handler '%s' registered.\n", handler->name);
 
    ast_rwlock_unlock(&msg_handlers_lock);
 
    return 0;
 
}

References ast_log, ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_APPEND, ast_verb, handler(), LOG_ERROR, match(), msg_handler_find_by_tech_name(), msg_handlers, and msg_handlers_lock.

Referenced by ast_msg_init(), AST_TEST_DEFINE(), and messaging_init().

ast_msg_handler_unregister()

int ast_msg_handler_unregister

(

const struct ast_msg_handler *

handler

)

Unregister a ast_msg_handler.

Since

12.5.0

Parameters

handler

The handler to unregister

Return values

0	Success
non-zero	Error

Definition at line 1711 of file main/message.c.

{
    int match;
 
    ast_rwlock_wrlock(&msg_handlers_lock);
    match = AST_VECTOR_REMOVE_CMP_UNORDERED(&msg_handlers, handler, msg_handler_cmp,
                                            AST_VECTOR_ELEM_CLEANUP_NOOP);
    ast_rwlock_unlock(&msg_handlers_lock);
 
    if (match) {
        ast_log(LOG_ERROR, "No '%s' message handler found.\n", handler->name);
        return -1;
    }
 
    ast_verb(5, "Message handler '%s' unregistered.\n", handler->name);
    return 0;
}

References ast_log, ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_ELEM_CLEANUP_NOOP, AST_VECTOR_REMOVE_CMP_UNORDERED, ast_verb, handler(), LOG_ERROR, match(), msg_handler_cmp(), msg_handlers, and msg_handlers_lock.

Referenced by AST_TEST_DEFINE(), message_shutdown(), and messaging_cleanup().

ast_msg_has_destination()

int ast_msg_has_destination

(

const struct ast_msg *

msg

)

Determine if a particular message has a destination via some handler.

Since

12.5.0

Parameters

msg	The message to check

Return values

0	if the message has no handler that can find a destination
1	if the message has a handler that can find a destination

Definition at line 963 of file main/message.c.

{
    int i;
    int result = 0;
 
    ast_rwlock_rdlock(&msg_handlers_lock);
    for (i = 0; i < AST_VECTOR_SIZE(&msg_handlers); i++) {
        const struct ast_msg_handler *handler = AST_VECTOR_GET(&msg_handlers, i);
 
        ast_debug(5, "Seeing if %s can handle message\n", handler->name);
        if (handler->has_destination(msg)) {
            ast_debug(5, "%s can handle message\n", handler->name);
            result = 1;
            break;
        }
    }
    ast_rwlock_unlock(&msg_handlers_lock);
 
    return result;
}

References ast_debug, ast_rwlock_rdlock, ast_rwlock_unlock, AST_VECTOR_GET, AST_VECTOR_SIZE, handler(), msg_handlers, msg_handlers_lock, and result.

Referenced by AST_TEST_DEFINE(), and module_on_rx_request().

ast_msg_init()

int ast_msg_init

(

void

)

Provided by message.c

Definition at line 1770 of file main/message.c.

{
    int res;
 
    msg_q_tp = ast_taskprocessor_get("ast_msg_queue", TPS_REF_DEFAULT);
    if (!msg_q_tp) {
        return -1;
    }
 
    ast_rwlock_init(&msg_techs_lock);
    if (AST_VECTOR_INIT(&msg_techs, 8)) {
        return -1;
    }
 
    ast_rwlock_init(&msg_handlers_lock);
    if (AST_VECTOR_INIT(&msg_handlers, 4)) {
        return -1;
    }
 
    res = ast_msg_handler_register(&dialplan_msg_handler);
 
    res |= __ast_custom_function_register(&msg_function, NULL);
    res |= __ast_custom_function_register(&msg_data_function, NULL);
    res |= ast_register_application2(app_msg_send, msg_send_exec, NULL, NULL, NULL);
    res |= ast_manager_register_xml_core("MessageSend", EVENT_FLAG_MESSAGE, action_messagesend);
 
    ast_register_cleanup(message_shutdown);
 
    return res;
}

References __ast_custom_function_register(), action_messagesend(), app_msg_send, ast_manager_register_xml_core, ast_msg_handler_register(), ast_register_application2(), ast_register_cleanup(), ast_rwlock_init, ast_taskprocessor_get(), AST_VECTOR_INIT, dialplan_msg_handler, EVENT_FLAG_MESSAGE, message_shutdown(), msg_data_function, msg_function, msg_handlers, msg_handlers_lock, msg_q_tp, msg_send_exec(), msg_techs, msg_techs_lock, NULL, and TPS_REF_DEFAULT.

Referenced by asterisk_daemon().

ast_msg_queue()

int ast_msg_queue

(

struct ast_msg *

msg

)

Queue a message for routing through the dialplan.

Regardless of the return value of this function, this funciton will take care of ensuring that the message object is properly destroyed when needed.

Return values

0	message successfully queued
non-zero	failure, message not sent to dialplan

Definition at line 984 of file main/message.c.

{
    int res;
    res = ast_taskprocessor_push(msg_q_tp, msg_q_cb, msg);
    if (res == -1) {
        ao2_ref(msg, -1);
    }
 
    return res;
}

References ao2_ref, ast_taskprocessor_push(), msg_q_cb(), and msg_q_tp.

Referenced by AST_TEST_DEFINE(), module_on_rx_request(), and xmpp_pak_message().

ast_msg_ref()

struct ast_msg * ast_msg_ref

(

struct ast_msg *

msg

)

Bump a msg's ref count.

Definition at line 468 of file main/message.c.

{
    ao2_ref(msg, 1);
    return msg;
}

References ao2_ref.

Referenced by msg_data_create().

ast_msg_send()

int ast_msg_send	(	struct ast_msg *	msg,
		const char *	to,
		const char *	from
	)

Send a msg directly to an endpoint.

Regardless of the return value of this function, this funciton will take care of ensuring that the message object is properly destroyed when needed.

Return values

0	message successfully queued to be sent out
non-zero	failure, message not get sent out.

Definition at line 1409 of file main/message.c.

{
    char *tech_name = NULL;
    const struct ast_msg_tech *msg_tech;
    int res = -1;
 
    if (ast_strlen_zero(to)) {
        ao2_ref(msg, -1);
        return -1;
    }
 
    tech_name = ast_strdupa(to);
    tech_name = strsep(&tech_name, ":");
 
    ast_rwlock_rdlock(&msg_techs_lock);
    msg_tech = msg_find_by_tech_name(tech_name);
 
    if (!msg_tech) {
        ast_log(LOG_ERROR, "Unknown message tech: %s\n", tech_name);
        ast_rwlock_unlock(&msg_techs_lock);
        return -1;
    }
 
    res = msg_tech->msg_send(msg, S_OR(to, ""), S_OR(from, ""));
 
    ast_rwlock_unlock(&msg_techs_lock);
 
    ao2_ref(msg, -1);
 
    return res;
}

References ao2_ref, ast_log, ast_rwlock_rdlock, ast_rwlock_unlock, ast_strdupa, ast_strlen_zero(), LOG_ERROR, msg_find_by_tech_name(), ast_msg_tech::msg_send, msg_tech, msg_techs_lock, NULL, S_OR, and strsep().

Referenced by AST_TEST_DEFINE(), and send_message().

ast_msg_set_body()

int ast_msg_set_body	(	struct ast_msg *	msg,
		const char *	fmt,
			...
	)

Set the 'body' text of a message (in UTF-8)

Return values

0	success
-1	failure

Definition at line 502 of file main/message.c.

{
    va_list ap;
 
    va_start(ap, fmt);
    ast_string_field_build_va(msg, body, fmt, ap);
    va_end(ap);
 
    return 0;
}

References ast_string_field_build_va, and ast_msg::body.

Referenced by action_messagesend(), AST_TEST_DEFINE(), msg_func_write(), rx_data_to_ast_msg(), send_message(), and xmpp_pak_message().

ast_msg_set_context()

int ast_msg_set_context	(	struct ast_msg *	msg,
		const char *	fmt,
			...
	)

Set the dialplan context for this message.

Return values

0	success
-1	failure

Definition at line 513 of file main/message.c.

{
    va_list ap;
 
    va_start(ap, fmt);
    ast_string_field_build_va(msg, context, fmt, ap);
    va_end(ap);
 
    return 0;
}

References ast_string_field_build_va, and voicemailpwcheck::context.

Referenced by AST_TEST_DEFINE(), rx_data_to_ast_msg(), and xmpp_pak_message().

ast_msg_set_endpoint()

int ast_msg_set_endpoint	(	struct ast_msg *	msg,
		const char *	fmt,
			...
	)

Set the technology's endpoint associated with this message.

Since

12.5.0

Return values

0	success
-1	failure

Definition at line 546 of file main/message.c.

{
    va_list ap;
 
    va_start(ap, fmt);
    ast_string_field_build_va(msg, endpoint, fmt, ap);
    va_end(ap);
 
    return 0;
}

References ast_string_field_build_va, and ast_msg::endpoint.

Referenced by AST_TEST_DEFINE(), rx_data_to_ast_msg(), and xmpp_pak_message().

ast_msg_set_exten()

int ast_msg_set_exten	(	struct ast_msg *	msg,
		const char *	fmt,
			...
	)

Set the dialplan extension for this message.

Return values

0	success
-1	failure

Definition at line 524 of file main/message.c.

{
    va_list ap;
 
    va_start(ap, fmt);
    ast_string_field_build_va(msg, exten, fmt, ap);
    va_end(ap);
 
    return 0;
}

References ast_string_field_build_va, and ast_msg::exten.

Referenced by AST_TEST_DEFINE(), and rx_data_to_ast_msg().

ast_msg_set_from()

int ast_msg_set_from	(	struct ast_msg *	msg,
		const char *	fmt,
			...
	)

Set the 'from' URI of a message.

Return values

0	success
-1	failure

Definition at line 491 of file main/message.c.

{
    va_list ap;
 
    va_start(ap, fmt);
    ast_string_field_build_va(msg, from, fmt, ap);
    va_end(ap);
 
    return 0;
}

References ast_string_field_build_va, and ast_msg::from.

Referenced by AST_TEST_DEFINE(), msg_func_write(), rx_data_to_ast_msg(), send_message(), and xmpp_pak_message().

ast_msg_set_tech()

int ast_msg_set_tech	(	struct ast_msg *	msg,
		const char *	fmt,
			...
	)

Set the technology associated with this message.

Since

12.5.0

Return values

0	success
-1	failure

Definition at line 535 of file main/message.c.

{
    va_list ap;
 
    va_start(ap, fmt);
    ast_string_field_build_va(msg, tech, fmt, ap);
    va_end(ap);
 
    return 0;
}

References ast_string_field_build_va, and ast_msg::tech.

Referenced by AST_TEST_DEFINE(), rx_data_to_ast_msg(), and xmpp_pak_message().

ast_msg_set_to()

int ast_msg_set_to	(	struct ast_msg *	msg,
		const char *	fmt,
			...
	)

Set the 'to' URI of a message.

Return values

0	success
-1	failure

Definition at line 480 of file main/message.c.

{
    va_list ap;
 
    va_start(ap, fmt);
    ast_string_field_build_va(msg, to, fmt, ap);
    va_end(ap);
 
    return 0;
}

References ast_string_field_build_va, and ast_msg::to.

Referenced by AST_TEST_DEFINE(), msg_func_write(), rx_data_to_ast_msg(), send_message(), and xmpp_pak_message().

ast_msg_set_var()

int ast_msg_set_var	(	struct ast_msg *	msg,
		const char *	name,
		const char *	value
	)

Set a variable on the message going to the dialplan.

Note

Setting a variable that already exists overwrites the existing variable value

Parameters

msg
name	Name of variable to set
value	Value of variable to set

Return values

0	success
-1	failure

Definition at line 641 of file main/message.c.

{
    return msg_set_var_full(msg, name, value, 0);
}

References msg_data::msg, msg_set_var_full(), name, and value.

Referenced by AST_TEST_DEFINE(), headers_to_vars(), rx_data_to_ast_msg(), and xmpp_pak_message().

ast_msg_set_var_outbound()

int ast_msg_set_var_outbound	(	struct ast_msg *	msg,
		const char *	name,
		const char *	value
	)

Set a variable on the message being sent to a message tech directly.

Note

Setting a variable that already exists overwrites the existing variable value

Parameters

msg
name	Name of variable to set
value	Value of variable to set

Return values

0	success
-1	failure

Definition at line 636 of file main/message.c.

{
    return msg_set_var_full(msg, name, value, 1);
}

References msg_data::msg, msg_set_var_full(), name, and value.

Referenced by action_messagesend(), AST_TEST_DEFINE(), msg_data_func_write(), and send_message().

ast_msg_shutdown()

void ast_msg_shutdown

(

void

)

Provided by message.c

Definition at line 1729 of file main/message.c.

{
    if (msg_q_tp) {
        msg_q_tp = ast_taskprocessor_unreference(msg_q_tp);
    }
}

References ast_taskprocessor_unreference(), and msg_q_tp.

Referenced by can_safely_quit().

ast_msg_tech_register()

int ast_msg_tech_register

(

const struct ast_msg_tech *

tech

)

Register a message technology.

Return values

0	success
non-zero	failure

Definition at line 1609 of file main/message.c.

{
    const struct ast_msg_tech *match;
 
    ast_rwlock_wrlock(&msg_techs_lock);
 
    match = msg_find_by_tech_name(tech->name);
    if (match) {
        ast_log(LOG_ERROR, "Message technology already registered for '%s'\n",
                tech->name);
        ast_rwlock_unlock(&msg_techs_lock);
        return -1;
    }
 
    if (AST_VECTOR_APPEND(&msg_techs, tech)) {
        ast_log(LOG_ERROR, "Failed to register message technology for '%s'\n",
                tech->name);
        ast_rwlock_unlock(&msg_techs_lock);
        return -1;
    }
    ast_verb(5, "Message technology '%s' registered.\n", tech->name);
 
    ast_rwlock_unlock(&msg_techs_lock);
 
    return 0;
}

References ast_log, ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_APPEND, ast_verb, LOG_ERROR, match(), msg_find_by_tech_name(), msg_techs, msg_techs_lock, and ast_msg_tech::name.

Referenced by AST_TEST_DEFINE(), and load_module().

ast_msg_tech_unregister()

int ast_msg_tech_unregister

(

const struct ast_msg_tech *

tech

)

Unregister a message technology.

Return values

0	success
non-zero	failure

Definition at line 1650 of file main/message.c.

{
    int match;
 
    ast_rwlock_wrlock(&msg_techs_lock);
    match = AST_VECTOR_REMOVE_CMP_UNORDERED(&msg_techs, tech, msg_tech_cmp,
                                            AST_VECTOR_ELEM_CLEANUP_NOOP);
    ast_rwlock_unlock(&msg_techs_lock);
 
    if (match) {
        ast_log(LOG_ERROR, "No '%s' message technology found.\n", tech->name);
        return -1;
    }
 
    ast_verb(5, "Message technology '%s' unregistered.\n", tech->name);
 
    return 0;
}

References ast_log, ast_rwlock_unlock, ast_rwlock_wrlock, AST_VECTOR_ELEM_CLEANUP_NOOP, AST_VECTOR_REMOVE_CMP_UNORDERED, ast_verb, LOG_ERROR, match(), msg_tech_cmp(), msg_techs, msg_techs_lock, and ast_msg_tech::name.

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

ast_msg_var_iterator_destroy()

void ast_msg_var_iterator_destroy

(

struct ast_msg_var_iterator *

iter

)

Destroy a message variable iterator.

Parameters

iter	Iterator to be destroyed

Definition at line 732 of file main/message.c.

{
    if (iter) {
        ao2_iterator_destroy(&iter->iter);
        ast_msg_var_unref_current(iter);
        ast_free(iter);
    }
}

References ao2_iterator_destroy(), ast_free, ast_msg_var_unref_current(), and ast_msg_var_iterator::iter.

Referenced by AST_TEST_DEFINE(), msg_to_json(), and vars_to_headers().

ast_msg_var_iterator_get_next()

static int ast_msg_var_iterator_get_next ( const struct ast_msg *  msg, struct ast_msg_var_iterator *  iter, const char **  name, const char **  value, unsigned int  send  )

static

Definition at line 684 of file main/message.c.

{
    struct msg_data *data;
 
    if (!iter) {
        return 0;
    }
 
    /* Skip any that we're told to */
    while ((data = ao2_iterator_next(&iter->iter)) && (data->send != send)) {
        ao2_ref(data, -1);
    }
 
    if (!data) {
        return 0;
    }
 
    if (data->send == send) {
        *name = data->name;
        *value = data->value;
    }
 
    /* Leave the refcount to be cleaned up by the caller with
     * ast_msg_var_unref_current after they finish with the pointers to the data */
    iter->current_used = data;
 
    return 1;
}

References ao2_iterator_next, ao2_ref, ast_msg_var_iterator::current_used, ast_msg_var_iterator::iter, name, msg_data::name, msg_data::send, msg_data::value, and value.

Referenced by ast_msg_var_iterator_next(), and ast_msg_var_iterator_next_received().

ast_msg_var_iterator_init()

struct ast_msg_var_iterator * ast_msg_var_iterator_init

(

const struct ast_msg *

msg

)

Create a new message variable iterator.

Parameters

msg	A message whose variables are to be iterated over

Returns

An opaque pointer to the new iterator

Definition at line 670 of file main/message.c.

{
    struct ast_msg_var_iterator *iter;
 
    iter = ast_calloc(1, sizeof(*iter));
    if (!iter) {
        return NULL;
    }
 
    iter->iter = ao2_iterator_init(msg->vars, 0);
 
    return iter;
}

References ao2_iterator_init(), ast_calloc, ast_msg_var_iterator::iter, NULL, and ast_msg::vars.

Referenced by AST_TEST_DEFINE(), msg_to_json(), and vars_to_headers().

ast_msg_var_iterator_next()

int ast_msg_var_iterator_next	(	const struct ast_msg *	msg,
		struct ast_msg_var_iterator *	iter,
		const char **	name,
		const char **	value
	)

Get the next variable name and value that is set for sending outbound.

Parameters

msg	The message with the variables
iter	An iterator created with ast_msg_var_iterator_init
name	A pointer to the name result pointer
value	A pointer to the value result pointer

Return values

0	No more entries
1	Valid entry

Definition at line 715 of file main/message.c.

{
    return ast_msg_var_iterator_get_next(msg, iter, name, value, 1);
}

References ast_msg_var_iterator_get_next(), msg_data::msg, name, and value.

Referenced by AST_TEST_DEFINE(), and vars_to_headers().

ast_msg_var_iterator_next_received()

int ast_msg_var_iterator_next_received	(	const struct ast_msg *	msg,
		struct ast_msg_var_iterator *	iter,
		const char **	name,
		const char **	value
	)

Get the next variable name and value that was set on a received message.

Parameters

msg	The message with the variables
iter	An iterator created with ast_msg_var_iterator_init
name	A pointer to the name result pointer
value	A pointer to the value result pointer

Return values

0	No more entries
1	Valid entry

Definition at line 720 of file main/message.c.

{
    return ast_msg_var_iterator_get_next(msg, iter, name, value, 0);
}

References ast_msg_var_iterator_get_next(), msg_data::msg, name, and value.

Referenced by msg_to_json().

ast_msg_var_unref_current()

void ast_msg_var_unref_current

(

struct ast_msg_var_iterator *

iter

)

Unref a message var from inside an iterator loop.

Definition at line 726 of file main/message.c.

{
    ao2_cleanup(iter->current_used);
    iter->current_used = NULL;
}

References ao2_cleanup, ast_msg_var_iterator::current_used, and NULL.

Referenced by ast_msg_var_iterator_destroy(), AST_TEST_DEFINE(), msg_to_json(), and vars_to_headers().

chan_cleanup()

static void chan_cleanup ( struct ast_channel *  chan )

static

Definition at line 800 of file main/message.c.

{
    struct ast_datastore *msg_ds, *ds;
    struct varshead *headp;
    struct ast_var_t *vardata;
    struct ast_frame *cur;
 
    ast_channel_lock(chan);
 
    /*
     * Remove the msg datastore.  Free its data but keep around the datastore
     * object and just reuse it.
     */
    if ((msg_ds = ast_channel_datastore_find(chan, &msg_datastore, NULL)) && msg_ds->data) {
        ast_channel_datastore_remove(chan, msg_ds);
        ao2_ref(msg_ds->data, -1);
        msg_ds->data = NULL;
    }
 
    /*
     * Destroy all other datastores.
     */
    while ((ds = AST_LIST_REMOVE_HEAD(ast_channel_datastores(chan), entry))) {
        ast_datastore_free(ds);
    }
 
    /*
     * Destroy all channel variables.
     */
    headp = ast_channel_varshead(chan);
    while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries))) {
        ast_var_delete(vardata);
    }
 
    /*
     * Remove frames from read queue
     */
    while ((cur = AST_LIST_REMOVE_HEAD(ast_channel_readq(chan), frame_list))) {
        ast_frfree(cur);
    }
 
    /*
     * Restore msg datastore.
     */
    if (msg_ds) {
        ast_channel_datastore_add(chan, msg_ds);
    }
 
    /*
     * Clear softhangup flags.
     */
    ast_channel_clear_softhangup(chan, AST_SOFTHANGUP_ALL);
 
    /*
     * Flush the alert pipe in case we miscounted somewhere when
     * messing with frames on the read queue, we had to flush the
     * read queue above, or we had an "Exceptionally long queue
     * length" event.
     */
    ast_channel_internal_alert_flush(chan);
 
    ast_channel_unlock(chan);
}

References ao2_ref, ast_channel_clear_softhangup(), ast_channel_datastore_add(), ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_channel_datastores(), ast_channel_internal_alert_flush(), ast_channel_lock, ast_channel_readq(), ast_channel_unlock, ast_channel_varshead(), ast_datastore_free(), ast_frfree, AST_LIST_REMOVE_HEAD, AST_SOFTHANGUP_ALL, ast_var_delete(), ast_datastore::data, msg_datastore, and NULL.

Referenced by dialplan_handle_msg_cb().

chan_msg_indicate()

static int chan_msg_indicate ( struct ast_channel *  chan, int  condition, const void *  data, size_t  datalen  )

static

Definition at line 384 of file main/message.c.

{
    return 0;
}

chan_msg_read()

static struct ast_frame * chan_msg_read ( struct ast_channel *  chan )

static

Definition at line 358 of file main/message.c.

{
    return &ast_null_frame;
}

References ast_null_frame.

chan_msg_send_digit_begin()

static int chan_msg_send_digit_begin ( struct ast_channel *  chan, char  digit  )

static

Definition at line 398 of file main/message.c.

{
    return 0;
}

chan_msg_send_digit_end()

static int chan_msg_send_digit_end ( struct ast_channel *  chan, char  digit, unsigned int  duration  )

static

Definition at line 411 of file main/message.c.

{
    return 0;
}

chan_msg_write()

static int chan_msg_write ( struct ast_channel *  chan, struct ast_frame *  fr  )

static

Definition at line 369 of file main/message.c.

{
    return 0;
}

create_msg_q_chan()

static struct ast_channel * create_msg_q_chan ( void  )

static

Definition at line 741 of file main/message.c.

{
    struct ast_channel *chan;
    struct ast_datastore *ds;
 
    chan = ast_channel_alloc(1, AST_STATE_UP,
            NULL, NULL, NULL,
            NULL, NULL, NULL, NULL, 0,
            "%s", "Message/ast_msg_queue");
 
    if (!chan) {
        return NULL;
    }
 
    if (ast_opt_hide_messaging_ami_events) {
        msg_chan_tech_hack.properties |= AST_CHAN_TP_INTERNAL;
    }
 
    ast_channel_tech_set(chan, &msg_chan_tech_hack);
    ast_channel_unlock(chan);
    ast_channel_unlink(chan);
 
    if (!(ds = ast_datastore_alloc(&msg_datastore, NULL))) {
        ast_hangup(chan);
        return NULL;
    }
 
    ast_channel_lock(chan);
    ast_channel_datastore_add(chan, ds);
    ast_channel_unlock(chan);
 
    return chan;
}

References AST_CHAN_TP_INTERNAL, ast_channel_alloc, ast_channel_datastore_add(), ast_channel_lock, ast_channel_tech_set(), ast_channel_unlink(), ast_channel_unlock, ast_datastore_alloc, ast_hangup(), ast_opt_hide_messaging_ami_events, AST_STATE_UP, msg_chan_tech_hack, msg_datastore, NULL, and ast_channel_tech::properties.

Referenced by dialplan_handle_msg_cb().

destroy_msg_q_chan()

static void destroy_msg_q_chan ( void *  data )

static

Definition at line 864 of file main/message.c.

{
    struct ast_channel **chan = data;
 
    if (!*chan) {
        return;
    }
 
    ast_channel_release(*chan);
}

References ast_channel_release(), and ast_channel::data.

dialplan_handle_msg_cb()

static int dialplan_handle_msg_cb ( struct ast_msg *  msg )

static

Definition at line 878 of file main/message.c.

{
    struct ast_channel **chan_p, *chan;
    struct ast_datastore *ds;
 
    if (!(chan_p = ast_threadstorage_get(&msg_q_chan, sizeof(struct ast_channel *)))) {
        return -1;
    }
    if (!*chan_p) {
        if (!(*chan_p = create_msg_q_chan())) {
            return -1;
        }
    }
    chan = *chan_p;
 
    ast_channel_lock(chan);
    if (!(ds = ast_channel_datastore_find(chan, &msg_datastore, NULL))) {
        ast_channel_unlock(chan);
        return -1;
    }
    ao2_ref(msg, +1);
    ds->data = msg;
    ast_channel_unlock(chan);
 
    msg_route(chan, msg);
    chan_cleanup(chan);
 
    return 0;
}

References ao2_ref, ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_threadstorage_get(), chan_cleanup(), create_msg_q_chan(), ast_datastore::data, msg_datastore, msg_q_chan, msg_route(), and NULL.

dialplan_has_destination_cb()

static int dialplan_has_destination_cb ( const struct ast_msg *  msg )

static

Definition at line 909 of file main/message.c.

{
    if (ast_strlen_zero(msg->context)) {
        return 0;
    }
 
    return ast_exists_extension(NULL, msg->context, S_OR(msg->exten, "s"), 1, NULL);
}

References ast_exists_extension(), ast_strlen_zero(), ast_msg::context, ast_msg::exten, NULL, and S_OR.

message_shutdown()

static void message_shutdown ( void  )

static

Definition at line 1744 of file main/message.c.

{
    ast_msg_handler_unregister(&dialplan_msg_handler);
 
    ast_custom_function_unregister(&msg_function);
    ast_custom_function_unregister(&msg_data_function);
    ast_unregister_application(app_msg_send);
    ast_manager_unregister("MessageSend");
 
    AST_VECTOR_FREE(&msg_techs);
    ast_rwlock_destroy(&msg_techs_lock);
 
    AST_VECTOR_FREE(&msg_handlers);
    ast_rwlock_destroy(&msg_handlers_lock);
}

References app_msg_send, ast_custom_function_unregister(), ast_manager_unregister(), ast_msg_handler_unregister(), ast_rwlock_destroy, ast_unregister_application(), AST_VECTOR_FREE, dialplan_msg_handler, msg_data_function, msg_function, msg_handlers, msg_handlers_lock, msg_techs, and msg_techs_lock.

Referenced by ast_msg_init().

msg_data_alloc()

static struct msg_data * msg_data_alloc ( void  )

static

Definition at line 582 of file main/message.c.

{
    struct msg_data *data;
 
    if (!(data = ao2_alloc(sizeof(*data), msg_data_destructor))) {
        return NULL;
    }
 
    if (ast_string_field_init(data, 32)) {
        ao2_ref(data, -1);
        return NULL;
    }
 
    return data;
}

References ao2_alloc, ao2_ref, ast_string_field_init, msg_data_destructor(), and NULL.

Referenced by msg_set_var_full().

msg_data_cmp_fn()

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

static

Definition at line 424 of file main/message.c.

{
    const struct msg_data *one = obj, *two = arg;
    return !strcasecmp(one->name, two->name) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, and msg_data::name.

Referenced by ast_msg_alloc().

msg_data_destructor()

static void msg_data_destructor ( void *  obj )

static

Definition at line 430 of file main/message.c.

{
    struct msg_data *data = obj;
    ast_string_field_free_memory(data);
}

References ast_string_field_free_memory.

Referenced by msg_data_alloc().

msg_data_find()

static struct msg_data * msg_data_find ( struct ao2_container *  vars, const char *  name  )

static

Definition at line 598 of file main/message.c.

{
    struct msg_data tmp = {
        .name = name,
    };
    return ao2_find(vars, &tmp, OBJ_POINTER);
}

References ao2_find, name, msg_data::name, and OBJ_POINTER.

Referenced by ast_msg_get_var(), and msg_set_var_full().

msg_data_func_read()

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

static

Definition at line 1129 of file main/message.c.

{
    struct ast_datastore *ds;
    struct ast_msg *msg;
    const char *val;
 
    if (!chan) {
        ast_log(LOG_WARNING, "No channel was provided to %s function.\n", function);
        return -1;
    }
 
    ast_channel_lock(chan);
 
    if (!(ds = ast_channel_datastore_find(chan, &msg_datastore, NULL))) {
        ast_channel_unlock(chan);
        ast_log(LOG_ERROR, "No MESSAGE data found on the channel to read.\n");
        return -1;
    }
 
    msg = ds->data;
    ao2_ref(msg, +1);
    ast_channel_unlock(chan);
 
    ao2_lock(msg);
 
    if ((val = ast_msg_get_var(msg, data))) {
        ast_copy_string(buf, val, len);
    }
 
    ao2_unlock(msg);
    ao2_ref(msg, -1);
 
    return 0;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_copy_string(), ast_log, ast_msg_get_var(), buf, ast_datastore::data, len(), LOG_ERROR, LOG_WARNING, msg_datastore, and NULL.

msg_data_func_write()

static int msg_data_func_write ( struct ast_channel *  chan, const char *  function, char *  data, const char *  value  )

static

Definition at line 1165 of file main/message.c.

{
    struct ast_datastore *ds;
    struct ast_msg *msg;
 
    if (!chan) {
        ast_log(LOG_WARNING, "No channel was provided to %s function.\n", function);
        return -1;
    }
 
    ast_channel_lock(chan);
 
    if (!(ds = msg_datastore_find_or_create(chan))) {
        ast_channel_unlock(chan);
        return -1;
    }
 
    msg = ds->data;
    ao2_ref(msg, +1);
    ast_channel_unlock(chan);
 
    ao2_lock(msg);
 
    ast_msg_set_var_outbound(msg, data, value);
 
    ao2_unlock(msg);
    ao2_ref(msg, -1);
 
    return 0;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_channel_lock, ast_channel_unlock, ast_log, ast_msg_set_var_outbound(), ast_datastore::data, LOG_WARNING, msg_datastore_find_or_create(), and value.

msg_datastore_find_or_create()

static struct ast_datastore * msg_datastore_find_or_create ( struct ast_channel *  chan )

static

Definition at line 1006 of file main/message.c.

{
    struct ast_datastore *ds;
 
    if ((ds = ast_channel_datastore_find(chan, &msg_datastore, NULL))) {
        return ds;
    }
 
    if (!(ds = ast_datastore_alloc(&msg_datastore, NULL))) {
        return NULL;
    }
 
    if (!(ds->data = ast_msg_alloc())) {
        ast_datastore_free(ds);
        return NULL;
    }
 
    ast_channel_datastore_add(chan, ds);
 
    return ds;
}

References ast_channel_datastore_add(), ast_channel_datastore_find(), ast_datastore_alloc, ast_datastore_free(), ast_msg_alloc(), ast_datastore::data, msg_datastore, and NULL.

Referenced by msg_data_func_write(), and msg_func_write().

msg_destructor()

static void msg_destructor ( void *  obj )

static

Definition at line 436 of file main/message.c.

{
    struct ast_msg *msg = obj;
 
    ast_string_field_free_memory(msg);
    ao2_cleanup(msg->vars);
}

References ao2_cleanup, ast_string_field_free_memory, and ast_msg::vars.

Referenced by ast_msg_alloc().

msg_ds_destroy()

static void msg_ds_destroy ( void *  data )

static

Definition at line 417 of file main/message.c.

{
    struct ast_msg *msg = data;
 
    ao2_ref(msg, -1);
}

References ao2_ref.

msg_find_by_tech_name()

static const struct ast_msg_tech * msg_find_by_tech_name ( const char *  tech_name )

static

Definition at line 1208 of file main/message.c.

{
    const struct ast_msg_tech *current;
    int i;
 
    for (i = 0; i < AST_VECTOR_SIZE(&msg_techs); i++) {
        current = AST_VECTOR_GET(&msg_techs, i);
        if (!strcmp(current->name, tech_name)) {
            return current;
        }
    }
 
    return NULL;
}

References AST_VECTOR_GET, AST_VECTOR_SIZE, current, msg_techs, and NULL.

Referenced by action_messagesend(), ast_msg_send(), ast_msg_tech_register(), and msg_send_exec().

msg_func_read()

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

static

Definition at line 1028 of file main/message.c.

{
    struct ast_datastore *ds;
    struct ast_msg *msg;
 
    if (!chan) {
        ast_log(LOG_WARNING, "No channel was provided to %s function.\n", function);
        return -1;
    }
 
    ast_channel_lock(chan);
 
    if (!(ds = ast_channel_datastore_find(chan, &msg_datastore, NULL))) {
        ast_channel_unlock(chan);
        ast_log(LOG_ERROR, "No MESSAGE data found on the channel to read.\n");
        return -1;
    }
 
    msg = ds->data;
    ao2_ref(msg, +1);
    ast_channel_unlock(chan);
 
    ao2_lock(msg);
 
    if (!strcasecmp(data, "to")) {
        ast_copy_string(buf, msg->to, len);
    } else if (!strcasecmp(data, "from")) {
        ast_copy_string(buf, msg->from, len);
    } else if (!strcasecmp(data, "body")) {
        ast_copy_string(buf, msg->body, len);
    } else {
        ast_log(LOG_WARNING, "Invalid argument to MESSAGE(): '%s'\n", data);
    }
 
    ao2_unlock(msg);
    ao2_ref(msg, -1);
 
    return 0;
}

References ao2_lock, ao2_ref, ao2_unlock, ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_copy_string(), ast_log, ast_msg::body, buf, ast_datastore::data, ast_msg::from, len(), LOG_ERROR, LOG_WARNING, msg_datastore, NULL, and ast_msg::to.

msg_func_write()

static int msg_func_write ( struct ast_channel *  chan, const char *  function, char *  data, const char *  value  )

static

Definition at line 1069 of file main/message.c.

{
    struct ast_datastore *ds;
    struct ast_msg *msg;
 
    if (!chan) {
        ast_log(LOG_WARNING, "No channel was provided to %s function.\n", function);
        return -1;
    }
 
    ast_channel_lock(chan);
 
    if (!(ds = msg_datastore_find_or_create(chan))) {
        ast_channel_unlock(chan);
        return -1;
    }
 
    msg = ds->data;
    ao2_ref(msg, +1);
    ast_channel_unlock(chan);
 
    ao2_lock(msg);
 
    if (!strcasecmp(data, "to")) {
        ast_msg_set_to(msg, "%s", value);
    } else if (!strcasecmp(data, "from")) {
        ast_msg_set_from(msg, "%s", value);
    } else if (!strcasecmp(data, "body")) {
        ast_msg_set_body(msg, "%s", value);
    } else if (!strcasecmp(data, "custom_data")) {
        int outbound = -1;
        if (!strcasecmp(value, "mark_all_outbound")) {
            outbound = 1;
        } else if (!strcasecmp(value, "clear_all_outbound")) {
            outbound = 0;
        } else {
            ast_log(LOG_WARNING, "'%s' is not a valid value for custom_data\n", value);
        }
 
        if (outbound != -1) {
            struct msg_data *hdr_data;
            struct ao2_iterator iter = ao2_iterator_init(msg->vars, 0);
 
            while ((hdr_data = ao2_iterator_next(&iter))) {
                hdr_data->send = outbound;
                ao2_ref(hdr_data, -1);
            }
            ao2_iterator_destroy(&iter);
        }
    } else {
        ast_log(LOG_WARNING, "'%s' is not a valid write argument.\n", data);
    }
 
    ao2_unlock(msg);
    ao2_ref(msg, -1);
 
    return 0;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_channel_lock, ast_channel_unlock, ast_log, ast_msg_set_body(), ast_msg_set_from(), ast_msg_set_to(), ast_datastore::data, LOG_WARNING, msg_datastore_find_or_create(), msg_data::send, value, and ast_msg::vars.

msg_handler_cmp()

static int msg_handler_cmp ( const struct ast_msg_handler *  vec_elem, const struct ast_msg_handler *  srch  )

static

Comparison callback for ast_msg_handler vector removal.

Parameters

vec_elem	The element in the vector being compared
srch	The element being looked up

Return values

non-zero	The items are equal
0	The items are not equal

Definition at line 1706 of file main/message.c.

{
    return !strcmp(vec_elem->name, srch->name);
}

References ast_msg_handler::name.

Referenced by ast_msg_handler_unregister().

msg_handler_find_by_tech_name()

static const struct ast_msg_handler * msg_handler_find_by_tech_name ( const char *  tech_name )

static

Definition at line 1234 of file main/message.c.

{
    const struct ast_msg_handler *current;
    int i;
 
    for (i = 0; i < AST_VECTOR_SIZE(&msg_handlers); i++) {
        current = AST_VECTOR_GET(&msg_handlers, i);
        if (!strcmp(current->name, tech_name)) {
            return current;
        }
    }
 
    return NULL;
}

References AST_VECTOR_GET, AST_VECTOR_SIZE, current, msg_handlers, and NULL.

Referenced by ast_msg_handler_register().

msg_q_cb()

static int msg_q_cb ( void *  data )

static

Definition at line 933 of file main/message.c.

{
    struct ast_msg *msg = data;
    int res = 1;
    int i;
 
    ast_rwlock_rdlock(&msg_handlers_lock);
    for (i = 0; i < AST_VECTOR_SIZE(&msg_handlers); i++) {
        const struct ast_msg_handler *handler = AST_VECTOR_GET(&msg_handlers, i);
 
        if (!handler->has_destination(msg)) {
            ast_debug(5, "Handler %s doesn't want message, moving on\n", handler->name);
            continue;
        }
 
        ast_debug(5, "Dispatching message to %s handler\n", handler->name);
        res &= handler->handle_msg(msg);
    }
    ast_rwlock_unlock(&msg_handlers_lock);
 
    if (res != 0) {
        ast_log(LOG_WARNING, "No handler processed message from %s to %s\n",
            S_OR(msg->from, "<unknown>"), S_OR(msg->to, "<unknown>"));
    }
 
    ao2_ref(msg, -1);
 
    return res;
}

References ao2_ref, ast_debug, ast_log, ast_rwlock_rdlock, ast_rwlock_unlock, AST_VECTOR_GET, AST_VECTOR_SIZE, ast_msg::from, handler(), LOG_WARNING, msg_handlers, msg_handlers_lock, S_OR, and ast_msg::to.

Referenced by ast_msg_queue().

msg_route()

static void msg_route ( struct ast_channel *  chan, struct ast_msg *  msg  )

static

Definition at line 782 of file main/message.c.

{
    struct ast_pbx_args pbx_args;
 
    ast_explicit_goto(chan, msg->context, S_OR(msg->exten, "s"), 1);
 
    memset(&pbx_args, 0, sizeof(pbx_args));
    pbx_args.no_hangup_chan = 1,
    ast_pbx_run_args(chan, &pbx_args);
}

References ast_explicit_goto(), ast_pbx_run_args(), ast_msg::context, ast_msg::exten, ast_pbx_args::no_hangup_chan, and S_OR.

Referenced by dialplan_handle_msg_cb().

msg_send_exec()

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

static

Definition at line 1253 of file main/message.c.

{
    struct ast_datastore *ds;
    struct ast_msg *msg;
    char *tech_name;
    const struct ast_msg_tech *msg_tech;
    char *parse;
    int res = -1;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(destination);
        AST_APP_ARG(from);
        AST_APP_ARG(to);
    );
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "An argument is required to MessageSend()\n");
        pbx_builtin_setvar_helper(chan, "MESSAGE_SEND_STATUS", "INVALID_URI");
        return 0;
    }
 
    parse = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (ast_strlen_zero(args.destination)) {
        ast_log(LOG_WARNING, "A 'to' URI is required for MessageSend()\n");
        pbx_builtin_setvar_helper(chan, "MESSAGE_SEND_STATUS", "INVALID_URI");
        return 0;
    }
 
    ast_channel_lock(chan);
 
    if (!(ds = ast_channel_datastore_find(chan, &msg_datastore, NULL))) {
        ast_channel_unlock(chan);
        ast_log(LOG_WARNING, "No message data found on channel to send.\n");
        pbx_builtin_setvar_helper(chan, "MESSAGE_SEND_STATUS", "FAILURE");
        return 0;
    }
 
    msg = ds->data;
    ao2_ref(msg, +1);
    ast_channel_unlock(chan);
 
    tech_name = ast_strdupa(args.destination);
    tech_name = strsep(&tech_name, ":");
 
    ast_rwlock_rdlock(&msg_techs_lock);
    msg_tech = msg_find_by_tech_name(tech_name);
 
    if (!msg_tech) {
        ast_log(LOG_WARNING, "No message technology '%s' found.\n", tech_name);
        pbx_builtin_setvar_helper(chan, "MESSAGE_SEND_STATUS", "INVALID_PROTOCOL");
        goto exit_cleanup;
    }
 
    /*
     * If there was a "to" in the call to MessageSend,
     * replace the to already in the channel datastore.
     */
    if (!ast_strlen_zero(args.to)) {
        ast_string_field_set(msg, to, args.to);
    }
 
    /*
     * The message lock is held here to safely allow the technology
     * implementation to access the message fields without worrying
     * that they could change.
     */
    ao2_lock(msg);
    res = msg_tech->msg_send(msg, S_OR(args.destination, ""), S_OR(args.from, ""));
    ao2_unlock(msg);
 
    pbx_builtin_setvar_helper(chan, "MESSAGE_SEND_STATUS", res ? "FAILURE" : "SUCCESS");
 
exit_cleanup:
    ast_rwlock_unlock(&msg_techs_lock);
    ao2_ref(msg, -1);
 
    return 0;
}

References ao2_lock, ao2_ref, ao2_unlock, args, AST_APP_ARG, ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, AST_DECLARE_APP_ARGS, ast_log, ast_rwlock_rdlock, ast_rwlock_unlock, AST_STANDARD_APP_ARGS, ast_strdupa, ast_string_field_set, ast_strlen_zero(), ast_datastore::data, LOG_WARNING, msg_datastore, msg_find_by_tech_name(), ast_msg_tech::msg_send, msg_tech, msg_techs_lock, NULL, pbx_builtin_setvar_helper(), S_OR, and strsep().

Referenced by ast_msg_init().

msg_set_var_full()

static int msg_set_var_full ( struct ast_msg *  msg, const char *  name, const char *  value, unsigned int  outbound  )

static

Definition at line 606 of file main/message.c.

{
    struct msg_data *data;
 
    if (!(data = msg_data_find(msg->vars, name))) {
        if (ast_strlen_zero(value)) {
            return 0;
        }
        if (!(data = msg_data_alloc())) {
            return -1;
        };
 
        ast_string_field_set(data, name, name);
        ast_string_field_set(data, value, value);
        data->send = outbound;
        ao2_link(msg->vars, data);
    } else {
        if (ast_strlen_zero(value)) {
            ao2_unlink(msg->vars, data);
        } else {
            ast_string_field_set(data, value, value);
            data->send = outbound;
        }
    }
 
    ao2_ref(data, -1);
 
    return 0;
}

References ao2_link, ao2_ref, ao2_unlink, ast_string_field_set, ast_strlen_zero(), msg_data::msg, msg_data_alloc(), msg_data_find(), name, msg_data::send, value, and ast_msg::vars.

Referenced by ast_msg_set_var(), and ast_msg_set_var_outbound().

msg_tech_cmp()

static int msg_tech_cmp ( const struct ast_msg_tech *  vec_elem, const struct ast_msg_tech *  srch  )

static

Comparison callback for ast_msg_tech vector removal.

Parameters

vec_elem	The element in the vector being compared
srch	The element being looked up

Return values

non-zero	The items are equal
0	The items are not equal

Definition at line 1645 of file main/message.c.

{
    return !strcmp(vec_elem->name, srch->name);
}

References ast_msg_tech::name.

Referenced by ast_msg_tech_unregister().

Variable Documentation

app_msg_send

const char app_msg_send[] = "MessageSend"

static

Definition at line 294 of file main/message.c.

Referenced by ast_msg_init(), and message_shutdown().

current

size_t current

Definition at line 284 of file main/message.c.

Referenced by msg_find_by_tech_name(), and msg_handler_find_by_tech_name().

dialplan_msg_handler

struct ast_msg_handler dialplan_msg_handler

static

Initial value:

= {
    .name = "dialplan",
    .handle_msg = dialplan_handle_msg_cb,
    .has_destination = dialplan_has_destination_cb,
}

Definition at line 918 of file main/message.c.

Referenced by ast_msg_init(), and message_shutdown().

elems

const struct ast_msg_handler* * elems

Definition at line 284 of file main/message.c.

max

size_t max

Definition at line 284 of file main/message.c.

msg_chan_tech_hack

struct ast_channel_tech msg_chan_tech_hack

static

Definition at line 340 of file main/message.c.

Referenced by create_msg_q_chan().

msg_data_function

struct ast_custom_function msg_data_function

static

Initial value:

= {
    .name = "MESSAGE_DATA",
    .read = msg_data_func_read,
    .write = msg_data_func_write,
}

Definition at line 319 of file main/message.c.

Referenced by ast_msg_init(), and message_shutdown().

msg_datastore

const struct ast_datastore_info msg_datastore

static

Initial value:

= {
    .type = "message",
    .destroy = msg_ds_destroy,
}

Definition at line 298 of file main/message.c.

Referenced by chan_cleanup(), create_msg_q_chan(), dialplan_handle_msg_cb(), msg_data_func_read(), msg_datastore_find_or_create(), msg_func_read(), and msg_send_exec().

msg_function

struct ast_custom_function msg_function

static

Initial value:

= {
    .name = "MESSAGE",
    .read = msg_func_read,
    .write = msg_func_write,
}

Definition at line 308 of file main/message.c.

Referenced by ast_msg_init(), and message_shutdown().

struct { ... } msg_handlers

Vector of received message handlers.

Referenced by ast_msg_handler_register(), ast_msg_handler_unregister(), ast_msg_has_destination(), ast_msg_init(), message_shutdown(), msg_handler_find_by_tech_name(), and msg_q_cb().

msg_handlers_lock

ast_rwlock_t msg_handlers_lock

static

Lock for msg_handlers vector.

Definition at line 287 of file main/message.c.

Referenced by ast_msg_handler_register(), ast_msg_handler_unregister(), ast_msg_has_destination(), ast_msg_init(), message_shutdown(), and msg_q_cb().

msg_q_chan

struct ast_threadstorage msg_q_chan = { .once = PTHREAD_ONCE_INIT , .key_init = __init_msg_q_chan , .custom_init = NULL , }

static

Definition at line 875 of file main/message.c.

Referenced by dialplan_handle_msg_cb().

msg_q_tp

struct ast_taskprocessor* msg_q_tp

static

Definition at line 292 of file main/message.c.

Referenced by ast_msg_init(), ast_msg_queue(), and ast_msg_shutdown().

struct { ... } msg_techs

Vector of message technologies.

Referenced by ast_msg_init(), ast_msg_tech_register(), ast_msg_tech_unregister(), message_shutdown(), and msg_find_by_tech_name().

msg_techs_lock

ast_rwlock_t msg_techs_lock

static

Lock for msg_techs vector.

Definition at line 281 of file main/message.c.

Referenced by action_messagesend(), ast_msg_init(), ast_msg_send(), ast_msg_tech_register(), ast_msg_tech_unregister(), message_shutdown(), and msg_send_exec().