........ r420089 | mjordan | 2014-08-05 15:10:52 -0500 (Tue, 05 Aug 2014) | 72 lines ARI: Add channel technology agnostic out of call text messaging This patch adds the ability to send and receive text messages from various technology stacks in Asterisk through ARI. This includes chan_sip (sip), res_pjsip_messaging (pjsip), and res_xmpp (xmpp). Messages are sent using the endpoints resource, and can be sent directly through that resource, or to a particular endpoint. For example, the following would send the message "Hello there" to PJSIP endpoint alice with a display URI of sip:asterisk@mycooldomain.org: ari/endpoints/sendMessage?to=pjsip:alice&from=sip:asterisk@mycooldomain.org&body=Hello+There This is equivalent to the following as well: ari/endpoints/PJSIP/alice/sendMessage?from=sip:asterisk@mycooldomain.org&body=Hello+There Both forms are available for message technologies that allow for arbitrary destinations, such as chan_sip. Inbound messages can now be received over ARI as well. An ARI application that subscribes to endpoints will receive messages from those endpoints: { "type": "TextMessageReceived", "timestamp": "2014-07-12T22:53:13.494-0500", "endpoint": { "technology": "PJSIP", "resource": "alice", "state": "online", "channel_ids": [] }, "message": { "from": "\"alice\" <sip:alice@127.0.0.1>", "to": "pjsip:asterisk@127.0.0.1", "body": "Watson, come here.", "variables": [] }, "application": "testsuite" } The above was made possible due to some rather major changes in the message core. This includes (but is not limited to): - Users of the message API can now register message handlers. A handler has two callbacks: one to determine if the handler has a destination for the message, and another to handle it. - All dialplan functionality of handling a message was moved into a message handler provided by the message API. - Messages can now have the technology/endpoint associated with them. Various other properties are also now more easily accessible. - A number of ao2 containers that weren't really needed were replaced with vectors. Iteration over ao2_containers is expensive and pointless when the lifetime of things is well defined and the number of things is very small. res_stasis now has a new file that makes up its structure, messaging. The messaging functionality implements a message handler, and passes received messages that match an interested endpoint over to the app for processing. Note that inadvertently while testing this, I reproduced ASTERISK-23969. res_pjsip_messaging was incorrectly parsing out the 'to' field, such that arbitrary SIP URIs mangled the endpoint lookup. This patch includes the fix for that as well. Review: https://reviewboard.asterisk.org/r/3726 ASTERISK-23692 #close Reported by: Matt Jordan ASTERISK-23969 #close Reported by: Andrew Nagy ........ r420090 | mjordan | 2014-08-05 15:16:37 -0500 (Tue, 05 Aug 2014) | 2 lines Remove automerge properties :-( ........ r420097 | mjordan | 2014-08-05 16:36:25 -0500 (Tue, 05 Aug 2014) | 2 lines test_message: Fix strict-aliasing compilation issue ........ Merged revisions 420089-420090,420097 from http://svn.asterisk.org/svn/asterisk/branches/12 git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@420098 65c4cc65-6c06-0410-ace0-fbb531ad65f3
282 lines
7.6 KiB
C
282 lines
7.6 KiB
C
/*
|
|
* Asterisk -- An open source telephony toolkit.
|
|
*
|
|
* Copyright (C) 2012 - 2013, Digium, Inc.
|
|
*
|
|
* David M. Lee, II <dlee@digium.com>
|
|
*
|
|
* See http://www.asterisk.org for more information about
|
|
* the Asterisk project. Please do not directly contact
|
|
* any of the maintainers of this project for assistance;
|
|
* the project provides a web site, mailing lists and IRC
|
|
* channels for your use.
|
|
*
|
|
* This program is free software, distributed under the terms of
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
* at the top of the source tree.
|
|
*/
|
|
|
|
/*! \file
|
|
*
|
|
* \brief /api-docs/endpoints.{format} implementation- Endpoint resources
|
|
*
|
|
* \author David M. Lee, II <dlee@digium.com>
|
|
*/
|
|
|
|
#include "asterisk.h"
|
|
|
|
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
|
|
|
|
#include "resource_endpoints.h"
|
|
|
|
#include "asterisk/astobj2.h"
|
|
#include "asterisk/stasis.h"
|
|
#include "asterisk/stasis_app.h"
|
|
#include "asterisk/stasis_endpoints.h"
|
|
#include "asterisk/channel.h"
|
|
#include "asterisk/message.h"
|
|
|
|
void ast_ari_endpoints_list(struct ast_variable *headers,
|
|
struct ast_ari_endpoints_list_args *args,
|
|
struct ast_ari_response *response)
|
|
{
|
|
RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
|
|
RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
|
|
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
|
struct ao2_iterator i;
|
|
void *obj;
|
|
|
|
cache = ast_endpoint_cache();
|
|
if (!cache) {
|
|
ast_ari_response_error(
|
|
response, 500, "Internal Server Error",
|
|
"Message bus not initialized");
|
|
return;
|
|
}
|
|
ao2_ref(cache, +1);
|
|
|
|
snapshots = stasis_cache_dump(cache, ast_endpoint_snapshot_type());
|
|
if (!snapshots) {
|
|
ast_ari_response_alloc_failed(response);
|
|
return;
|
|
}
|
|
|
|
json = ast_json_array_create();
|
|
if (!json) {
|
|
ast_ari_response_alloc_failed(response);
|
|
return;
|
|
}
|
|
|
|
i = ao2_iterator_init(snapshots, 0);
|
|
while ((obj = ao2_iterator_next(&i))) {
|
|
RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
|
|
struct ast_endpoint_snapshot *snapshot = stasis_message_data(msg);
|
|
struct ast_json *json_endpoint = ast_endpoint_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
|
|
|
|
if (!json_endpoint || ast_json_array_append(json, json_endpoint)) {
|
|
ao2_iterator_destroy(&i);
|
|
ast_ari_response_alloc_failed(response);
|
|
return;
|
|
}
|
|
}
|
|
ao2_iterator_destroy(&i);
|
|
|
|
ast_ari_response_ok(response, ast_json_ref(json));
|
|
}
|
|
|
|
void ast_ari_endpoints_list_by_tech(struct ast_variable *headers,
|
|
struct ast_ari_endpoints_list_by_tech_args *args,
|
|
struct ast_ari_response *response)
|
|
{
|
|
RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
|
|
RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
|
|
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
|
struct ast_endpoint *tech_endpoint;
|
|
struct ao2_iterator i;
|
|
void *obj;
|
|
|
|
tech_endpoint = ast_endpoint_find_by_id(args->tech);
|
|
if (!tech_endpoint) {
|
|
ast_ari_response_error(response, 404, "Not Found",
|
|
"No Endpoints found - invalid tech %s", args->tech);
|
|
return;
|
|
}
|
|
ao2_ref(tech_endpoint, -1);
|
|
|
|
cache = ast_endpoint_cache();
|
|
if (!cache) {
|
|
ast_ari_response_error(
|
|
response, 500, "Internal Server Error",
|
|
"Message bus not initialized");
|
|
return;
|
|
}
|
|
ao2_ref(cache, +1);
|
|
|
|
snapshots = stasis_cache_dump(cache, ast_endpoint_snapshot_type());
|
|
if (!snapshots) {
|
|
ast_ari_response_alloc_failed(response);
|
|
return;
|
|
}
|
|
|
|
json = ast_json_array_create();
|
|
if (!json) {
|
|
ast_ari_response_alloc_failed(response);
|
|
return;
|
|
}
|
|
|
|
i = ao2_iterator_init(snapshots, 0);
|
|
while ((obj = ao2_iterator_next(&i))) {
|
|
RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
|
|
struct ast_endpoint_snapshot *snapshot = stasis_message_data(msg);
|
|
struct ast_json *json_endpoint;
|
|
int r;
|
|
|
|
if (strcasecmp(args->tech, snapshot->tech) != 0) {
|
|
continue;
|
|
}
|
|
|
|
json_endpoint = ast_endpoint_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
|
|
if (!json_endpoint) {
|
|
continue;
|
|
}
|
|
|
|
r = ast_json_array_append(
|
|
json, json_endpoint);
|
|
if (r != 0) {
|
|
ao2_iterator_destroy(&i);
|
|
ast_ari_response_alloc_failed(response);
|
|
return;
|
|
}
|
|
}
|
|
ao2_iterator_destroy(&i);
|
|
ast_ari_response_ok(response, ast_json_ref(json));
|
|
}
|
|
|
|
void ast_ari_endpoints_get(struct ast_variable *headers,
|
|
struct ast_ari_endpoints_get_args *args,
|
|
struct ast_ari_response *response)
|
|
{
|
|
struct ast_json *json;
|
|
RAII_VAR(struct ast_endpoint_snapshot *, snapshot, NULL, ao2_cleanup);
|
|
|
|
snapshot = ast_endpoint_latest_snapshot(args->tech, args->resource);
|
|
if (!snapshot) {
|
|
ast_ari_response_error(response, 404, "Not Found",
|
|
"Endpoint not found");
|
|
return;
|
|
}
|
|
|
|
json = ast_endpoint_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
|
|
if (!json) {
|
|
ast_ari_response_alloc_failed(response);
|
|
return;
|
|
}
|
|
|
|
ast_ari_response_ok(response, json);
|
|
}
|
|
|
|
static void send_message(const char *to, const char *from, const char *body, struct ast_variable *variables, struct ast_ari_response *response)
|
|
{
|
|
struct ast_variable *current;
|
|
struct ast_msg *msg;
|
|
int res = 0;
|
|
|
|
if (ast_strlen_zero(to)) {
|
|
ast_ari_response_error(response, 400, "Bad Request",
|
|
"To must be specified");
|
|
return;
|
|
}
|
|
|
|
msg = ast_msg_alloc();
|
|
if (!msg) {
|
|
ast_ari_response_alloc_failed(response);
|
|
return;
|
|
}
|
|
|
|
res |= ast_msg_set_from(msg, "%s", from);
|
|
res |= ast_msg_set_to(msg, "%s", to);
|
|
|
|
if (!ast_strlen_zero(body)) {
|
|
res |= ast_msg_set_body(msg, "%s", body);
|
|
}
|
|
|
|
for (current = variables; current; current = current->next) {
|
|
res |= ast_msg_set_var_outbound(msg, current->name, current->value);
|
|
}
|
|
|
|
if (res) {
|
|
ast_ari_response_alloc_failed(response);
|
|
ast_msg_destroy(msg);
|
|
return;
|
|
}
|
|
|
|
if (ast_msg_send(msg, to, from)) {
|
|
ast_ari_response_error(response, 404, "Not Found",
|
|
"Endpoint not found");
|
|
}
|
|
|
|
response->message = ast_json_null();
|
|
response->response_code = 202;
|
|
response->response_text = "Accepted";
|
|
}
|
|
|
|
void ast_ari_endpoints_send_message(struct ast_variable *headers,
|
|
struct ast_ari_endpoints_send_message_args *args,
|
|
struct ast_ari_response *response)
|
|
{
|
|
RAII_VAR(struct ast_variable *, variables, NULL, ast_variables_destroy);
|
|
|
|
if (args->variables) {
|
|
struct ast_json *json_variables;
|
|
|
|
ast_ari_endpoints_send_message_parse_body(args->variables, args);
|
|
json_variables = ast_json_object_get(args->variables, "variables");
|
|
if (json_variables) {
|
|
if (ast_json_to_ast_variables(json_variables, &variables)) {
|
|
ast_log(AST_LOG_ERROR, "Unable to convert 'variables' in JSON body to Asterisk variables\n");
|
|
ast_ari_response_alloc_failed(response);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
send_message(args->to, args->from, args->body, variables, response);
|
|
}
|
|
|
|
void ast_ari_endpoints_send_message_to_endpoint(struct ast_variable *headers,
|
|
struct ast_ari_endpoints_send_message_to_endpoint_args *args,
|
|
struct ast_ari_response *response)
|
|
{
|
|
RAII_VAR(struct ast_variable *, variables, NULL, ast_variables_destroy);
|
|
RAII_VAR(struct ast_endpoint_snapshot *, snapshot, NULL, ao2_cleanup);
|
|
char msg_to[128];
|
|
char *tech = ast_strdupa(args->tech);
|
|
|
|
/* Really, we just want to know if this thing exists */
|
|
snapshot = ast_endpoint_latest_snapshot(args->tech, args->resource);
|
|
if (!snapshot) {
|
|
ast_ari_response_error(response, 404, "Not Found",
|
|
"Endpoint not found");
|
|
return;
|
|
}
|
|
|
|
if (args->variables) {
|
|
struct ast_json *json_variables;
|
|
|
|
ast_ari_endpoints_send_message_to_endpoint_parse_body(args->variables, args);
|
|
json_variables = ast_json_object_get(args->variables, "variables");
|
|
|
|
if (json_variables) {
|
|
if (ast_json_to_ast_variables(json_variables, &variables)) {
|
|
ast_log(AST_LOG_ERROR, "Unable to convert 'variables' in JSON body to Asterisk variables\n");
|
|
ast_ari_response_alloc_failed(response);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
snprintf(msg_to, sizeof(msg_to), "%s:%s", ast_str_to_lower(tech), args->resource);
|
|
|
|
send_message(msg_to, args->from, args->body, variables, response);
|
|
}
|