aeap.c File Reference

#include "asterisk.h"
#include <pthread.h>
#include "asterisk/astobj2.h"
#include "asterisk/strings.h"
#include "asterisk/res_aeap.h"
#include "asterisk/res_aeap_message.h"
#include "logger.h"
#include "transaction.h"
#include "transport.h"

Include dependency graph for aeap.c:

Go to the source code of this file.

Data Structures
struct	aeap_user_data
struct	ast_aeap

Macros
#define	AEAP_RECV_SIZE   32768
#define	USER_DATA_BUCKETS   11

Functions
static void	aeap_destructor (void *obj)
static void *	aeap_receive (void *data)
static int	aeap_send (struct ast_aeap *aeap, const void *buf, uintmax_t size, enum AST_AEAP_DATA_TYPE type)
static struct aeap_user_data *	aeap_user_data_create (const char *id, void *obj, ast_aeap_user_obj_cleanup cleanup)
	AO2_STRING_FIELD_CMP_FN (aeap_user_data, id)
	AO2_STRING_FIELD_HASH_FN (aeap_user_data, id)
int	ast_aeap_connect (struct ast_aeap *aeap, const char *url, const char *protocol, int timeout)
	Connect to an external application. More...
struct ast_aeap *	ast_aeap_create (const char *transport_type, const struct ast_aeap_params *params)
	Create an Asterisk external application object. More...
struct ast_aeap *	ast_aeap_create_and_connect (const char *type, const struct ast_aeap_params *params, const char *url, const char *protocol, int timeout)
	Create and connect to an Asterisk external application. More...
int	ast_aeap_disconnect (struct ast_aeap *aeap)
	Disconnect an Asterisk external application object. More...
int	ast_aeap_send_binary (struct ast_aeap *aeap, const void *buf, uintmax_t size)
	Send a binary data to an external application. More...
int	ast_aeap_send_msg (struct ast_aeap *aeap, struct ast_aeap_message *msg)
	Send a message to an external application. More...
int	ast_aeap_send_msg_tsx (struct ast_aeap *aeap, struct ast_aeap_tsx_params *params)
	Send a transaction based message to an external application using the given parameters. More...
void *	ast_aeap_user_data_object_by_id (struct ast_aeap *aeap, const char *id)
	Retrieve a registered user data object by its id. More...
int	ast_aeap_user_data_register (struct ast_aeap *aeap, const char *id, void *obj, ast_aeap_user_obj_cleanup cleanup)
	Register a user data object. More...
void	ast_aeap_user_data_unregister (struct ast_aeap *aeap, const char *id)
	Un-register a user data object. More...
static void	raise_msg (struct ast_aeap *aeap, const void *buf, intmax_t size, enum AST_AEAP_DATA_TYPE serial_type)
static int	raise_msg_handler (struct ast_aeap *aeap, const struct ast_aeap_message_handler *handlers, size_t size, struct ast_aeap_message *msg, void *data)
static int	tsx_end (void *obj, void *arg, int flags)

Macro Definition Documentation

AEAP_RECV_SIZE

#define AEAP_RECV_SIZE   32768

Definition at line 33 of file aeap.c.

USER_DATA_BUCKETS

#define USER_DATA_BUCKETS   11

Definition at line 45 of file aeap.c.

Function Documentation

aeap_destructor()

static void aeap_destructor ( void *  obj )

static

Definition at line 67 of file aeap.c.

{
    struct ast_aeap *aeap = obj;
 
    /* Disconnect things first, which keeps transactions from further executing */
    ast_aeap_disconnect(aeap);
 
    aeap_transport_destroy(aeap->transport);
 
    /*
     * Each contained transaction holds a pointer back to this transactions container,
     * which is removed upon transaction end. Thus by explicitly ending each transaction
     * here we can ensure all references to the transactions container are removed.
     */
    ao2_callback(aeap->transactions, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE,
            tsx_end, NULL);
    ao2_cleanup(aeap->transactions);
 
    ao2_cleanup(aeap->user_data);
}

References aeap_transport_destroy(), ao2_callback, ao2_cleanup, ast_aeap_disconnect(), NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, ast_aeap::transactions, ast_aeap::transport, tsx_end(), and ast_aeap::user_data.

Referenced by ast_aeap_create().

aeap_receive()

static void * aeap_receive ( void *  data )

static

Definition at line 269 of file aeap.c.

{
    struct ast_aeap *aeap = data;
    void *buf;
 
    buf = ast_calloc(1, AEAP_RECV_SIZE);
    if (!buf) {
        aeap_error(aeap, NULL, "unable to create read buffer");
        goto aeap_receive_error;
    }
 
    while (aeap_transport_is_connected(aeap->transport)) {
        enum AST_AEAP_DATA_TYPE rtype;
        intmax_t size;
 
        size = aeap_transport_read(aeap->transport, buf, AEAP_RECV_SIZE, &rtype);
        if (size < 0) {
            goto aeap_receive_error;
        }
 
        if (!size) {
            continue;
        }
 
        switch (rtype) {
        case AST_AEAP_DATA_TYPE_BINARY:
            if (aeap->params && aeap->params->on_binary) {
                aeap->params->on_binary(aeap, buf, size);
            }
            break;
        case AST_AEAP_DATA_TYPE_STRING:
            ast_debug(3, "AEAP: received message: %s\n", (char *)buf);
            if (aeap->params && aeap->params->on_string) {
                aeap->params->on_string(aeap, (const char *)buf, size - 1);
            }
            break;
        default:
            break;
        }
 
        raise_msg(aeap, buf, size, rtype);
    };
 
    ast_free(buf);
    return NULL;
 
aeap_receive_error:
    /*
     * An unrecoverable error occurred so ensure the aeap and transport reset
     * to a disconnected state. We don't want this thread to "join" itself so set
     * its id to NULL prior to disconnecting.
     */
    aeap_error(aeap, NULL, "unrecoverable read error, disconnecting");
 
    ao2_lock(aeap);
    aeap->read_thread_id = AST_PTHREADT_NULL;
    ao2_unlock(aeap);
 
    ast_aeap_disconnect(aeap);
 
    ast_free(buf);
 
    if (aeap->params && aeap->params->on_error) {
        aeap->params->on_error(aeap);
    }
 
    return NULL;
}

References aeap_error, AEAP_RECV_SIZE, aeap_transport_is_connected(), aeap_transport_read(), ao2_lock, ao2_unlock, AST_AEAP_DATA_TYPE_BINARY, AST_AEAP_DATA_TYPE_STRING, ast_aeap_disconnect(), ast_calloc, ast_debug, ast_free, AST_PTHREADT_NULL, buf, NULL, ast_aeap_params::on_binary, ast_aeap_params::on_error, ast_aeap_params::on_string, ast_aeap::params, raise_msg(), ast_aeap::read_thread_id, and ast_aeap::transport.

Referenced by ast_aeap_connect().

aeap_send()

static int aeap_send ( struct ast_aeap *  aeap, const void *  buf, uintmax_t  size, enum AST_AEAP_DATA_TYPE  type  )

static

Definition at line 404 of file aeap.c.

{
    intmax_t num;
 
    num = aeap_transport_write(aeap->transport, buf, size, type);
 
    if (num == 0) {
        /* Nothing written, could be disconnected */
        return 0;
    }
 
    if (num < 0) {
        aeap_error(aeap, NULL, "error sending data");
        return -1;
    }
 
    if (num < size) {
        aeap_error(aeap, NULL, "not all data sent");
        return -1;
    }
 
    if (num > size) {
        aeap_error(aeap, NULL, "sent data truncated");
        return -1;
    }
 
    return 0;
}

References aeap_error, aeap_transport_write(), buf, NULL, ast_aeap::transport, and type.

Referenced by ast_aeap_send_binary(), and ast_aeap_send_msg().

aeap_user_data_create()

static struct aeap_user_data * aeap_user_data_create ( const char *  id, void *  obj, ast_aeap_user_obj_cleanup  cleanup  )

static

Definition at line 127 of file aeap.c.

{
    struct aeap_user_data *data;
 
    ast_assert(id != NULL);
 
    data = ao2_t_alloc_options(sizeof(*data) + strlen(id) + 1, cleanup,
        AO2_ALLOC_OPT_LOCK_NOLOCK, "");
    if (!data) {
        if (cleanup) {
            cleanup(obj);
        }
 
        return NULL;
    }
 
    strcpy(data->id, id); /* safe */
    data->obj = obj;
 
    return data;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_t_alloc_options, ast_assert, cleanup(), aeap_user_data::id, NULL, and aeap_user_data::obj.

Referenced by ast_aeap_user_data_register().

AO2_STRING_FIELD_CMP_FN()

AO2_STRING_FIELD_CMP_FN	(	aeap_user_data	,
		id
	)

AO2_STRING_FIELD_HASH_FN()

AO2_STRING_FIELD_HASH_FN	(	aeap_user_data	,
		id
	)

ast_aeap_connect()

int ast_aeap_connect	(	struct ast_aeap *	aeap,
		const char *	url,
		const char *	protocol,
		int	timeout
	)

Connect to an external application.

Parameters

aeap	An Asterisk external application object
url	The url to connect to
protocol	A protocol to use
timeout	How long (in milliseconds) to attempt to connect (-1 equals infinite)

Returns

0 if able to connect, -1 on error

Definition at line 338 of file aeap.c.

{
    SCOPED_AO2LOCK(lock, aeap);
 
    if (aeap_transport_is_connected(aeap->transport)) {
        /* Should already be connected, so nothing to do */
        return 0;
    }
 
    if (aeap_transport_connect(aeap->transport, url, protocol, timeout)) {
        aeap_error(aeap, NULL, "unable to connect transport");
        return -1;
    }
 
    if (ast_pthread_create_background(&aeap->read_thread_id, NULL,
            aeap_receive, aeap)) {
        aeap_error(aeap, NULL, "unable to start read thread: %s",
            strerror(errno));
        ast_aeap_disconnect(aeap);
        return -1;
    }
 
    return 0;
}

References aeap_error, aeap_receive(), aeap_transport_connect(), aeap_transport_is_connected(), ast_aeap_disconnect(), ast_pthread_create_background, errno, lock, NULL, ast_aeap::read_thread_id, SCOPED_AO2LOCK, ast_aeap::transport, and url.

Referenced by ast_aeap_create_and_connect().

ast_aeap_create()

struct ast_aeap * ast_aeap_create	(	const char *	type,
		const struct ast_aeap_params *	params
	)

Create an Asterisk external application object.

Parameters

type	The type of underlying transport
params	Callbacks and other parameters to use

Returns

A new ao2 reference counted aeap object, or NULL on error

Definition at line 88 of file aeap.c.

{
    struct ast_aeap *aeap;
 
    aeap = ao2_alloc(sizeof(*aeap), aeap_destructor);
    if (!aeap) {
        ast_log(LOG_ERROR, "AEAP: unable to create");
        return NULL;
    }
 
    aeap->params = params;
    aeap->read_thread_id = AST_PTHREADT_NULL;
 
    aeap->user_data = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, USER_DATA_BUCKETS,
        aeap_user_data_hash_fn, NULL, aeap_user_data_cmp_fn);
    if (!aeap->user_data) {
        aeap_error(aeap, NULL, "unable to create user data container");
        ao2_ref(aeap, -1);
        return NULL;
    }
 
    aeap->transactions = aeap_transactions_create();
    if (!aeap->transactions) {
        aeap_error(aeap, NULL, "unable to create transactions container");
        ao2_ref(aeap, -1);
        return NULL;
    }
 
    aeap->transport = aeap_transport_create(transport_type);
    if (!aeap->transport) {
        aeap_error(aeap, NULL, "unable to create transport");
        ao2_ref(aeap, -1);
        return NULL;
    }
 
    return aeap;
}

References aeap_destructor(), aeap_error, aeap_transactions_create(), aeap_transport_create(), ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_ref, ast_log, AST_PTHREADT_NULL, LOG_ERROR, NULL, ast_aeap::params, ast_aeap::read_thread_id, ast_aeap::transactions, ast_aeap::transport, ast_aeap::user_data, and USER_DATA_BUCKETS.

Referenced by aeap_create(), and ast_aeap_create_and_connect().

ast_aeap_create_and_connect()

struct ast_aeap * ast_aeap_create_and_connect	(	const char *	type,
		const struct ast_aeap_params *	params,
		const char *	url,
		const char *	protocol,
		int	timeout
	)

Create and connect to an Asterisk external application.

Parameters

type	The type of client connection to make
params	Callbacks and other parameters to use
url	The url to connect to
protocol	A protocol to use
timeout	How long (in milliseconds) to attempt to connect (-1 equals infinite)

Returns

A new ao2 reference counted aeap object, or NULL on error

Definition at line 363 of file aeap.c.

{
    struct ast_aeap *aeap;
 
    aeap = ast_aeap_create(type, params);
    if (!aeap) {
        return NULL;
    }
 
    if (ast_aeap_connect(aeap, url, protocol, timeout)) {
        ao2_ref(aeap, -1);
        return NULL;
    }
 
    return aeap;
}

References ao2_ref, ast_aeap_connect(), ast_aeap_create(), NULL, ast_aeap::params, type, and url.

Referenced by aeap_create(), and AST_TEST_DEFINE().

ast_aeap_disconnect()

int ast_aeap_disconnect

(

struct ast_aeap *

aeap

)

Disconnect an Asterisk external application object.

Note

Depending on the underlying transport this call may block

Parameters

aeap	An Asterisk external application object

Returns

0 on success, -1 on error

Definition at line 381 of file aeap.c.

{
    ao2_lock(aeap);
 
    aeap_transport_disconnect(aeap->transport);
 
    if (aeap->read_thread_id != AST_PTHREADT_NULL) {
        /*
         * The read thread calls disconnect if an error occurs, so
         * unlock the aeap before "joining" to avoid a deadlock.
         */
        ao2_unlock(aeap);
        pthread_join(aeap->read_thread_id, NULL);
        ao2_lock(aeap);
 
        aeap->read_thread_id = AST_PTHREADT_NULL;
    }
 
    ao2_unlock(aeap);
 
    return 0;
}

References aeap_transport_disconnect(), ao2_lock, ao2_unlock, AST_PTHREADT_NULL, NULL, ast_aeap::read_thread_id, and ast_aeap::transport.

Referenced by aeap_destructor(), aeap_receive(), and ast_aeap_connect().

ast_aeap_send_binary()

int ast_aeap_send_binary	(	struct ast_aeap *	aeap,
		const void *	buf,
		uintmax_t	size
	)

Send a binary data to an external application.

Parameters

aeap	An Asterisk external application object
buf	Binary data to send
size	The size of the binary data

Returns

0 on success, -1 on error

Definition at line 434 of file aeap.c.

{
    return aeap_send(aeap, buf, size, AST_AEAP_DATA_TYPE_BINARY);
}

References aeap_send(), AST_AEAP_DATA_TYPE_BINARY, and buf.

Referenced by speech_aeap_engine_write().

ast_aeap_send_msg()

int ast_aeap_send_msg	(	struct ast_aeap *	aeap,
		struct ast_aeap_message *	msg
	)

Send a message to an external application.

Note

"Steals" the given message reference, thus callers are not required to un-ref the message object after calling this function.

Parameters

aeap	An Asterisk external application object
msg	The message to send

Returns

0 on success, -1 on error

Definition at line 439 of file aeap.c.

{
    void *buf;
    intmax_t size;
    int res;
 
    if (!msg) {
        aeap_error(aeap, NULL, "no message to send");
        return -1;
    }
 
    if (ast_aeap_message_serialize(msg, &buf, &size)) {
        aeap_error(aeap, NULL, "unable to serialize outgoing message");
        ao2_ref(msg, -1);
        return -1;
    }
 
    res = aeap_send(aeap, buf, size, msg->type->serial_type);
 
    ast_free(buf);
    ao2_ref(msg, -1);
 
    return res;
}

References aeap_error, aeap_send(), ao2_ref, ast_aeap_message_serialize(), ast_free, buf, NULL, ast_aeap_message_type::serial_type, and ast_aeap_message::type.

Referenced by ast_aeap_send_msg_tsx(), handle_request_set(), and raise_msg_handler().

ast_aeap_send_msg_tsx()

int ast_aeap_send_msg_tsx	(	struct ast_aeap *	aeap,
		struct ast_aeap_tsx_params *	params
	)

Send a transaction based message to an external application using the given parameters.

Note

"Steals" the given message reference, thus callers are not required to un-ref the message object after calling this function.

Also handles cleaning up the user object if the obj_cleanup callback is specified in "params".

Parameters

aeap	An Asterisk external application object
params	(optional) Additional parameters to consider when sending. Heap allocation not required.

Returns

0 on success, -1 on error

Definition at line 464 of file aeap.c.

{
    struct aeap_transaction *tsx = NULL;
    int res = 0;
 
    if (!params) {
        return -1;
    }
 
    if (!params->msg) {
        aeap_transaction_params_cleanup(params);
        aeap_error(aeap, NULL, "no message to send");
        return -1;
    }
 
    /* The transaction will take over params cleanup, which includes the msg reference */
    tsx = aeap_transaction_create_and_add(aeap->transactions,
        ast_aeap_message_id(params->msg), params, aeap);
    if (!tsx) {
        return -1;
    }
 
    if (ast_aeap_send_msg(aeap, ao2_bump(params->msg))) {
        aeap_transaction_end(tsx, -1); /* Removes container, and tsx ref */
        return -1;
    }
 
    if (aeap_transaction_start(tsx)) {
        aeap_transaction_end(tsx, -1); /* Removes container, and tsx ref */
        return -1;
    }
 
    res = aeap_transaction_result(tsx);
 
    ao2_ref(tsx, -1);
 
    return res;
}

References aeap_transaction::aeap, aeap_error, aeap_transaction_create_and_add(), aeap_transaction_end(), aeap_transaction_params_cleanup(), aeap_transaction_result(), aeap_transaction_start(), ao2_bump, ao2_ref, ast_aeap_message_id(), ast_aeap_send_msg(), ast_aeap_tsx_params::msg, NULL, aeap_transaction::params, and ast_aeap::transactions.

Referenced by AST_TEST_DEFINE(), and speech_aeap_send_request().

ast_aeap_user_data_object_by_id()

void * ast_aeap_user_data_object_by_id	(	struct ast_aeap *	aeap,
		const char *	id
	)

Retrieve a registered user data object by its id.

Note

Depending on how it was registered the returned user data object's lifetime may be managed by the given "aeap" object. If it was registered with a cleanup handler that [potentially] frees it the caller of this function must ensure it's done using the returned object before it's unregistered.

Parameters

aeap	An Asterisk external application object
id	The look up id for the object

Returns

A user data object

Definition at line 174 of file aeap.c.

{
    struct aeap_user_data *data;
    void *obj;
 
    data = ao2_find(aeap->user_data, id, OBJ_SEARCH_KEY);
    if (!data) {
        return NULL;
    }
 
    obj = data->obj;
    ao2_ref(data, -1);
 
    /*
     * Returned object's lifetime is based on how it was registered.
     * See public function docs for more info
     */
    return obj;
}

References ao2_find, ao2_ref, NULL, aeap_user_data::obj, OBJ_SEARCH_KEY, and ast_aeap::user_data.

Referenced by ast_aeap_speech_on_error(), handle_msg(), handle_request_set(), handle_string(), and handle_timeout().

ast_aeap_user_data_register()

int ast_aeap_user_data_register	(	struct ast_aeap *	aeap,
		const char *	id,
		void *	obj,
		ast_aeap_user_obj_cleanup	cleanup
	)

Register a user data object.

Note

The "cleanup" is called on un-register, if one is specified

Parameters

aeap	An Asterisk external application object
id	The look up id for the object
obj	The user object to register
cleanup	Optional user object clean up callback

Returns

0 on success, -1 on error

Definition at line 150 of file aeap.c.

{
    struct aeap_user_data *data;
 
    data = aeap_user_data_create(id, obj, cleanup);
    if (!data) {
        return -1;
    }
 
    if (!ao2_link(aeap->user_data, data)) {
        ao2_ref(data, -1);
        return -1;
    }
 
    ao2_ref(data, -1);
    return 0;
}

References aeap_user_data_create(), ao2_link, ao2_ref, cleanup(), aeap_user_data::obj, and ast_aeap::user_data.

Referenced by AST_TEST_DEFINE(), and speech_aeap_engine_create().

ast_aeap_user_data_unregister()

void ast_aeap_user_data_unregister	(	struct ast_aeap *	aeap,
		const char *	id
	)

Un-register a user data object.

Note

If specified on register, the "cleanup" callback is called during unregister.

Parameters

aeap	An Asterisk external application object
id	The look up id for the object

Definition at line 169 of file aeap.c.

{
    ao2_find(aeap->user_data, id, OBJ_SEARCH_KEY | OBJ_UNLINK | OBJ_NODATA);
}

References ao2_find, OBJ_NODATA, OBJ_SEARCH_KEY, OBJ_UNLINK, and ast_aeap::user_data.

Referenced by AST_TEST_DEFINE().

raise_msg()

static void raise_msg ( struct ast_aeap *  aeap, const void *  buf, intmax_t  size, enum AST_AEAP_DATA_TYPE  serial_type  )

static

Definition at line 236 of file aeap.c.

{
    struct ast_aeap_message *msg;
    struct aeap_transaction *tsx;
    int res = 0;
 
    if (!aeap->params || !aeap->params->msg_type ||
        ast_aeap_message_serial_type(aeap->params->msg_type) != serial_type ||
        !(msg = ast_aeap_message_deserialize(aeap->params->msg_type, buf, size))) {
        return;
    }
 
    /* See if this msg is involved in a transaction */
    tsx = aeap_transaction_get(aeap->transactions, ast_aeap_message_id(msg));
 
    /* If so go ahead and cancel the timeout timer */
    aeap_transaction_cancel_timer(tsx);
 
    if (aeap->params->request_handlers && ast_aeap_message_is_request(msg)) {
        res = raise_msg_handler(aeap, aeap->params->request_handlers, aeap->params->request_handlers_size,
            msg, tsx ? aeap_transaction_user_obj(tsx) : NULL);
    } else if (aeap->params->response_handlers && ast_aeap_message_is_response(msg)) {
        res = raise_msg_handler(aeap, aeap->params->response_handlers, aeap->params->response_handlers_size,
            msg, tsx ? aeap_transaction_user_obj(tsx) : NULL);
    }
 
    /* Complete transaction (Note, removes tsx ref) */
    aeap_transaction_end(tsx, res);
 
    ao2_ref(msg, -1);
}

References aeap_transaction::aeap, aeap_transaction_cancel_timer(), aeap_transaction_end(), aeap_transaction_get(), aeap_transaction_user_obj(), ao2_ref, ast_aeap_message_deserialize(), ast_aeap_message_id(), ast_aeap_message_is_request(), ast_aeap_message_is_response(), ast_aeap_message_serial_type(), buf, ast_aeap_params::msg_type, NULL, ast_aeap::params, raise_msg_handler(), ast_aeap_params::request_handlers, ast_aeap_params::request_handlers_size, ast_aeap_params::response_handlers, ast_aeap_params::response_handlers_size, and ast_aeap::transactions.

Referenced by aeap_receive().

raise_msg_handler()

static int raise_msg_handler ( struct ast_aeap *  aeap, const struct ast_aeap_message_handler *  handlers, size_t  size, struct ast_aeap_message *  msg, void *  data  )

static

Definition at line 194 of file aeap.c.

{
    ast_aeap_on_message on_message = NULL;
    size_t i;
 
    if (!aeap->params->emit_error) {
        const char *error_msg = ast_aeap_message_error_msg(msg);
 
        if (error_msg) {
            aeap_error(aeap, NULL, "%s", error_msg);
            return -1;
        }
 
        /* If no error_msg then it's assumed this is not an error message */
    }
 
    for (i = 0; i < size; ++i) {
        if (ast_strlen_zero(handlers[i].name)) {
            /* A default handler is specified. Use it if no other match is found */
            on_message = handlers[i].on_message;
            continue;
        }
 
        if (ast_aeap_message_is_named(msg, handlers[i].name)) {
            on_message = handlers[i].on_message;
            break;
        }
    }
 
    if (on_message) {
        return on_message(aeap, msg, data);
    }
 
    /* Respond with un-handled error */
    ast_aeap_send_msg(aeap, ast_aeap_message_create_error(aeap->params->msg_type,
        ast_aeap_message_name(msg), ast_aeap_message_id(msg),
        "Unsupported and/or un-handled message"));
 
    return 0;
}

References aeap_error, ast_aeap_message_create_error(), ast_aeap_message_error_msg(), ast_aeap_message_id(), ast_aeap_message_is_named(), ast_aeap_message_name(), ast_aeap_send_msg(), ast_strlen_zero(), ast_aeap_params::emit_error, handlers, ast_aeap_params::msg_type, name, NULL, ast_aeap_message_handler::on_message, and ast_aeap::params.

Referenced by raise_msg().

tsx_end()

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

static

Definition at line 60 of file aeap.c.

{
    aeap_transaction_end(obj, -1);
 
    return 0;
}

References aeap_transaction_end().

Referenced by aeap_destructor().