2012-06-04 20:26:12 +00:00
|
|
|
/*
|
|
|
|
* Asterisk -- An open source telephony toolkit.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2011, Digium, Inc.
|
|
|
|
*
|
|
|
|
* David Vossel <dvossel@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 Custom presence provider
|
|
|
|
* \ingroup functions
|
|
|
|
*/
|
|
|
|
|
2012-06-15 16:20:16 +00:00
|
|
|
/*** MODULEINFO
|
|
|
|
<support_level>core</support_level>
|
|
|
|
***/
|
|
|
|
|
2012-06-04 20:26:12 +00:00
|
|
|
#include "asterisk.h"
|
|
|
|
|
git migration: Refactor the ASTERISK_FILE_VERSION macro
Git does not support the ability to replace a token with a version
string during check-in. While it does have support for replacing a
token on clone, this is somewhat sub-optimal: the token is replaced
with the object hash, which is not particularly easy for human
consumption. What's more, in practice, the source file version was often
not terribly useful. Generally, when triaging bugs, the overall version
of Asterisk is far more useful than an individual SVN version of a file. As a
result, this patch removes Asterisk's support for showing source file
versions.
Specifically, it does the following:
* Rename ASTERISK_FILE_VERSION macro to ASTERISK_REGISTER_FILE, and
remove passing the version in with the macro. Other facilities
than 'core show file version' make use of the file names, such as
setting a debug level only on a specific file. As such, the act of
registering source files with the Asterisk core still has use. The
macro rename now reflects the new macro purpose.
* main/asterisk:
- Refactor the file_version structure to reflect that it no longer
tracks a version field.
- Remove the "core show file version" CLI command. Without the file
version, it is no longer useful.
- Remove the ast_file_version_find function. The file version is no
longer tracked.
- Rename ast_register_file_version/ast_unregister_file_version to
ast_register_file/ast_unregister_file, respectively.
* main/manager: Remove value from the Version key of the ModuleCheck
Action. The actual key itself has not been removed, as doing so would
absolutely constitute a backwards incompatible change. However, since
the file version is no longer tracked, there is no need to attempt to
include it in the Version key.
* UPGRADE: Add notes for:
- Modification to the ModuleCheck AMI Action
- Removal of the "core show file version" CLI command
Change-Id: I6cf0ff280e1668bf4957dc21f32a5ff43444a40e
2015-04-12 02:38:22 +00:00
|
|
|
ASTERISK_REGISTER_FILE()
|
2012-06-04 20:26:12 +00:00
|
|
|
|
|
|
|
#include "asterisk/module.h"
|
|
|
|
#include "asterisk/channel.h"
|
|
|
|
#include "asterisk/pbx.h"
|
|
|
|
#include "asterisk/utils.h"
|
|
|
|
#include "asterisk/linkedlists.h"
|
|
|
|
#include "asterisk/presencestate.h"
|
|
|
|
#include "asterisk/cli.h"
|
|
|
|
#include "asterisk/astdb.h"
|
|
|
|
#include "asterisk/app.h"
|
|
|
|
#ifdef TEST_FRAMEWORK
|
|
|
|
#include "asterisk/test.h"
|
2015-01-26 14:50:40 +00:00
|
|
|
#include "asterisk/sem.h"
|
2012-06-04 20:26:12 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*** DOCUMENTATION
|
|
|
|
<function name="PRESENCE_STATE" language="en_US">
|
|
|
|
<synopsis>
|
|
|
|
Get or Set a presence state.
|
|
|
|
</synopsis>
|
|
|
|
<syntax>
|
|
|
|
<parameter name="provider" required="true">
|
|
|
|
<para>The provider of the presence, such as <literal>CustomPresence</literal></para>
|
|
|
|
</parameter>
|
|
|
|
<parameter name="field" required="true">
|
|
|
|
<para>Which field of the presence state information is wanted.</para>
|
|
|
|
<optionlist>
|
|
|
|
<option name="value">
|
|
|
|
<para>The current presence, such as <literal>away</literal></para>
|
|
|
|
</option>
|
|
|
|
<option name="subtype">
|
|
|
|
<para>Further information about the current presence</para>
|
|
|
|
</option>
|
|
|
|
<option name="message">
|
|
|
|
<para>A custom message that may indicate further details about the presence</para>
|
|
|
|
</option>
|
|
|
|
</optionlist>
|
|
|
|
</parameter>
|
|
|
|
<parameter name="options" required="false">
|
|
|
|
<optionlist>
|
|
|
|
<option name="e">
|
2013-02-18 19:48:47 +00:00
|
|
|
<para>On Write - Use this option when the subtype and message provided are Base64
|
2014-05-01 16:21:09 +00:00
|
|
|
encoded. The values will be stored encoded within Asterisk, but all consumers of
|
|
|
|
the presence state (e.g. the SIP presence event package) will receive decoded values.</para>
|
|
|
|
<para>On Read - Retrieves unencoded message/subtype in Base64 encoded form.</para>
|
2012-06-04 20:26:12 +00:00
|
|
|
</option>
|
|
|
|
</optionlist>
|
|
|
|
</parameter>
|
|
|
|
</syntax>
|
|
|
|
<description>
|
|
|
|
<para>The PRESENCE_STATE function can be used to retrieve the presence from any
|
|
|
|
presence provider. For example:</para>
|
|
|
|
<para>NoOp(SIP/mypeer has presence ${PRESENCE_STATE(SIP/mypeer,value)})</para>
|
|
|
|
<para>NoOp(Conference number 1234 has presence message ${PRESENCE_STATE(MeetMe:1234,message)})</para>
|
|
|
|
<para>The PRESENCE_STATE function can also be used to set custom presence state from
|
|
|
|
the dialplan. The <literal>CustomPresence:</literal> prefix must be used. For example:</para>
|
|
|
|
<para>Set(PRESENCE_STATE(CustomPresence:lamp1)=away,temporary,Out to lunch)</para>
|
|
|
|
<para>Set(PRESENCE_STATE(CustomPresence:lamp2)=dnd,,Trying to get work done)</para>
|
2013-02-18 19:48:47 +00:00
|
|
|
<para>Set(PRESENCE_STATE(CustomPresence:lamp3)=xa,T24gdmFjYXRpb24=,,e)</para>
|
|
|
|
<para>Set(BASE64_LAMP3_PRESENCE=${PRESENCE_STATE(CustomPresence:lamp3,subtype,e)})</para>
|
2012-06-04 20:26:12 +00:00
|
|
|
<para>You can subscribe to the status of a custom presence state using a hint in
|
|
|
|
the dialplan:</para>
|
2014-03-05 18:47:30 +00:00
|
|
|
<para>exten => 1234,hint,,CustomPresence:lamp1</para>
|
2012-06-04 20:26:12 +00:00
|
|
|
<para>The possible values for both uses of this function are:</para>
|
|
|
|
<para>not_set | unavailable | available | away | xa | chat | dnd</para>
|
|
|
|
</description>
|
|
|
|
</function>
|
|
|
|
***/
|
|
|
|
|
|
|
|
|
|
|
|
static const char astdb_family[] = "CustomPresence";
|
|
|
|
|
|
|
|
static int presence_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
|
|
|
|
{
|
|
|
|
int state;
|
|
|
|
char *message = NULL;
|
|
|
|
char *subtype = NULL;
|
|
|
|
char *parse;
|
|
|
|
int base64encode = 0;
|
|
|
|
AST_DECLARE_APP_ARGS(args,
|
|
|
|
AST_APP_ARG(provider);
|
|
|
|
AST_APP_ARG(field);
|
|
|
|
AST_APP_ARG(options);
|
|
|
|
);
|
|
|
|
|
|
|
|
if (ast_strlen_zero(data)) {
|
|
|
|
ast_log(LOG_WARNING, "PRESENCE_STATE reading requires an argument \n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
parse = ast_strdupa(data);
|
|
|
|
|
|
|
|
AST_STANDARD_APP_ARGS(args, parse);
|
|
|
|
|
|
|
|
if (ast_strlen_zero(args.provider) || ast_strlen_zero(args.field)) {
|
|
|
|
ast_log(LOG_WARNING, "PRESENCE_STATE reading requires both presence provider and presence field arguments. \n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
state = ast_presence_state_nocache(args.provider, &subtype, &message);
|
|
|
|
if (state == AST_PRESENCE_INVALID) {
|
|
|
|
ast_log(LOG_WARNING, "PRESENCE_STATE unknown \n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(ast_strlen_zero(args.options)) && (strchr(args.options, 'e'))) {
|
|
|
|
base64encode = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(subtype) && !strcasecmp(args.field, "subtype")) {
|
|
|
|
if (base64encode) {
|
|
|
|
ast_base64encode(buf, (unsigned char *) subtype, strlen(subtype), len);
|
|
|
|
} else {
|
|
|
|
ast_copy_string(buf, subtype, len);
|
|
|
|
}
|
|
|
|
} else if (!ast_strlen_zero(message) && !strcasecmp(args.field, "message")) {
|
|
|
|
if (base64encode) {
|
|
|
|
ast_base64encode(buf, (unsigned char *) message, strlen(message), len);
|
|
|
|
} else {
|
|
|
|
ast_copy_string(buf, message, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (!strcasecmp(args.field, "value")) {
|
|
|
|
ast_copy_string(buf, ast_presence_state2str(state), len);
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_free(message);
|
|
|
|
ast_free(subtype);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int parse_data(char *data, enum ast_presence_state *state, char **subtype, char **message, char **options)
|
|
|
|
{
|
|
|
|
char *state_str;
|
|
|
|
|
|
|
|
/* data syntax is state,subtype,message,options */
|
|
|
|
*subtype = "";
|
|
|
|
*message = "";
|
|
|
|
*options = "";
|
|
|
|
|
|
|
|
state_str = strsep(&data, ",");
|
|
|
|
if (ast_strlen_zero(state_str)) {
|
|
|
|
return -1; /* state is required */
|
|
|
|
}
|
|
|
|
|
|
|
|
*state = ast_presence_state_val(state_str);
|
|
|
|
|
|
|
|
/* not a valid state */
|
|
|
|
if (*state == AST_PRESENCE_INVALID) {
|
|
|
|
ast_log(LOG_WARNING, "Unknown presence state value %s\n", state_str);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(*subtype = strsep(&data,","))) {
|
|
|
|
*subtype = "";
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(*message = strsep(&data, ","))) {
|
|
|
|
*message = "";
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(*options = strsep(&data, ","))) {
|
|
|
|
*options = "";
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(*options) && !(strchr(*options, 'e'))) {
|
|
|
|
ast_log(LOG_NOTICE, "Invalid options '%s'\n", *options);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int presence_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
|
|
|
|
{
|
|
|
|
size_t len = strlen("CustomPresence:");
|
|
|
|
char *tmp = data;
|
|
|
|
char *args = ast_strdupa(value);
|
|
|
|
enum ast_presence_state state;
|
|
|
|
char *options, *message, *subtype;
|
|
|
|
|
|
|
|
if (strncasecmp(data, "CustomPresence:", len)) {
|
|
|
|
ast_log(LOG_WARNING, "The PRESENCE_STATE function can only set CustomPresence: presence providers.\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
data += len;
|
|
|
|
if (ast_strlen_zero(data)) {
|
|
|
|
ast_log(LOG_WARNING, "PRESENCE_STATE function called with no custom device name!\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parse_data(args, &state, &subtype, &message, &options)) {
|
|
|
|
ast_log(LOG_WARNING, "Invalid arguments to PRESENCE_STATE\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_db_put(astdb_family, data, value);
|
|
|
|
|
2014-05-01 16:21:09 +00:00
|
|
|
if (strchr(options, 'e')) {
|
|
|
|
/* Let's decode the values before sending them to stasis, yes? */
|
|
|
|
char decoded_subtype[256] = { 0, };
|
|
|
|
char decoded_message[256] = { 0, };
|
|
|
|
|
|
|
|
ast_base64decode((unsigned char *) decoded_subtype, subtype, sizeof(decoded_subtype) -1);
|
|
|
|
ast_base64decode((unsigned char *) decoded_message, message, sizeof(decoded_message) -1);
|
|
|
|
|
|
|
|
ast_presence_state_changed_literal(state, decoded_subtype, decoded_message, tmp);
|
|
|
|
} else {
|
|
|
|
ast_presence_state_changed_literal(state, subtype, message, tmp);
|
|
|
|
}
|
2012-06-04 20:26:12 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum ast_presence_state custom_presence_callback(const char *data, char **subtype, char **message)
|
|
|
|
{
|
|
|
|
char buf[1301] = "";
|
|
|
|
enum ast_presence_state state;
|
|
|
|
char *_options;
|
|
|
|
char *_message;
|
|
|
|
char *_subtype;
|
|
|
|
|
2015-10-07 06:24:31 +00:00
|
|
|
if (ast_db_get(astdb_family, data, buf, sizeof(buf))) {
|
|
|
|
return AST_PRESENCE_NOT_SET;
|
|
|
|
}
|
2012-06-04 20:26:12 +00:00
|
|
|
|
|
|
|
if (parse_data(buf, &state, &_subtype, &_message, &_options)) {
|
2013-02-15 23:29:28 +00:00
|
|
|
return AST_PRESENCE_INVALID;
|
2012-06-04 20:26:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((strchr(_options, 'e'))) {
|
|
|
|
char tmp[1301];
|
2014-05-07 21:58:37 +00:00
|
|
|
|
2012-06-04 20:26:12 +00:00
|
|
|
if (ast_strlen_zero(_subtype)) {
|
|
|
|
*subtype = NULL;
|
|
|
|
} else {
|
|
|
|
memset(tmp, 0, sizeof(tmp));
|
|
|
|
ast_base64decode((unsigned char *) tmp, _subtype, sizeof(tmp) - 1);
|
|
|
|
*subtype = ast_strdup(tmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_strlen_zero(_message)) {
|
|
|
|
*message = NULL;
|
|
|
|
} else {
|
|
|
|
memset(tmp, 0, sizeof(tmp));
|
|
|
|
ast_base64decode((unsigned char *) tmp, _message, sizeof(tmp) - 1);
|
|
|
|
*message = ast_strdup(tmp);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
*subtype = ast_strlen_zero(_subtype) ? NULL : ast_strdup(_subtype);
|
|
|
|
*message = ast_strlen_zero(_message) ? NULL : ast_strdup(_message);
|
|
|
|
}
|
|
|
|
return state;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ast_custom_function presence_function = {
|
|
|
|
.name = "PRESENCE_STATE",
|
|
|
|
.read = presence_read,
|
|
|
|
.write = presence_write,
|
|
|
|
};
|
|
|
|
|
|
|
|
static char *handle_cli_presencestate_list(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
|
|
{
|
|
|
|
struct ast_db_entry *db_entry, *db_tree;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case CLI_INIT:
|
|
|
|
e->command = "presencestate list";
|
|
|
|
e->usage =
|
|
|
|
"Usage: presencestate list\n"
|
|
|
|
" List all custom presence states that have been set by using\n"
|
|
|
|
" the PRESENCE_STATE dialplan function.\n";
|
|
|
|
return NULL;
|
|
|
|
case CLI_GENERATE:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (a->argc != e->args) {
|
|
|
|
return CLI_SHOWUSAGE;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_cli(a->fd, "\n"
|
|
|
|
"---------------------------------------------------------------------\n"
|
|
|
|
"--- Custom Presence States ------------------------------------------\n"
|
|
|
|
"---------------------------------------------------------------------\n"
|
|
|
|
"---\n");
|
|
|
|
|
|
|
|
db_entry = db_tree = ast_db_gettree(astdb_family, NULL);
|
|
|
|
if (!db_entry) {
|
|
|
|
ast_cli(a->fd, "No custom presence states defined\n");
|
|
|
|
return CLI_SUCCESS;
|
|
|
|
}
|
|
|
|
for (; db_entry; db_entry = db_entry->next) {
|
|
|
|
const char *object_name = strrchr(db_entry->key, '/') + 1;
|
|
|
|
char state_info[1301];
|
|
|
|
enum ast_presence_state state;
|
|
|
|
char *subtype;
|
|
|
|
char *message;
|
|
|
|
char *options;
|
|
|
|
|
|
|
|
ast_copy_string(state_info, db_entry->data, sizeof(state_info));
|
|
|
|
if (parse_data(state_info, &state, &subtype, &message, &options)) {
|
|
|
|
ast_log(LOG_WARNING, "Invalid CustomPresence entry %s encountered\n", db_entry->data);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (object_name <= (const char *) 1) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
ast_cli(a->fd, "--- Name: 'CustomPresence:%s'\n"
|
|
|
|
" --- State: '%s'\n"
|
|
|
|
" --- Subtype: '%s'\n"
|
|
|
|
" --- Message: '%s'\n"
|
|
|
|
" --- Base64 Encoded: '%s'\n"
|
|
|
|
"---\n",
|
|
|
|
object_name,
|
|
|
|
ast_presence_state2str(state),
|
|
|
|
subtype,
|
|
|
|
message,
|
|
|
|
AST_CLI_YESNO(strchr(options, 'e')));
|
|
|
|
}
|
|
|
|
ast_db_freetree(db_tree);
|
|
|
|
db_tree = NULL;
|
|
|
|
|
|
|
|
ast_cli(a->fd,
|
|
|
|
"---------------------------------------------------------------------\n"
|
|
|
|
"---------------------------------------------------------------------\n"
|
|
|
|
"\n");
|
|
|
|
|
|
|
|
return CLI_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *handle_cli_presencestate_change(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
|
|
|
|
{
|
|
|
|
size_t len;
|
|
|
|
const char *dev, *state, *full_dev;
|
|
|
|
enum ast_presence_state state_val;
|
|
|
|
char *message;
|
|
|
|
char *subtype;
|
|
|
|
char *options;
|
|
|
|
char *args;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case CLI_INIT:
|
|
|
|
e->command = "presencestate change";
|
|
|
|
e->usage =
|
|
|
|
"Usage: presencestate change <entity> <state>[,<subtype>[,message[,options]]]\n"
|
|
|
|
" Change a custom presence to a new state.\n"
|
|
|
|
" The possible values for the state are:\n"
|
|
|
|
"NOT_SET | UNAVAILABLE | AVAILABLE | AWAY | XA | CHAT | DND\n"
|
|
|
|
"Optionally, a custom subtype and message may be provided, along with any options\n"
|
|
|
|
"accepted by func_presencestate. If the subtype or message provided contain spaces,\n"
|
|
|
|
"be sure to enclose the data in quotation marks (\"\")\n"
|
|
|
|
"\n"
|
|
|
|
"Examples:\n"
|
|
|
|
" presencestate change CustomPresence:mystate1 AWAY\n"
|
|
|
|
" presencestate change CustomPresence:mystate1 AVAILABLE\n"
|
|
|
|
" presencestate change CustomPresence:mystate1 \"Away,upstairs,eating lunch\"\n"
|
|
|
|
" \n";
|
|
|
|
return NULL;
|
|
|
|
case CLI_GENERATE:
|
|
|
|
{
|
|
|
|
static const char * const cmds[] = { "NOT_SET", "UNAVAILABLE", "AVAILABLE", "AWAY",
|
|
|
|
"XA", "CHAT", "DND", NULL };
|
|
|
|
|
|
|
|
if (a->pos == e->args + 1) {
|
|
|
|
return ast_cli_complete(a->word, cmds, a->n);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (a->argc != e->args + 2) {
|
|
|
|
return CLI_SHOWUSAGE;
|
|
|
|
}
|
|
|
|
|
|
|
|
len = strlen("CustomPresence:");
|
|
|
|
full_dev = dev = a->argv[e->args];
|
|
|
|
state = a->argv[e->args + 1];
|
|
|
|
|
|
|
|
if (strncasecmp(dev, "CustomPresence:", len)) {
|
|
|
|
ast_cli(a->fd, "The presencestate command can only be used to set 'CustomPresence:' presence state!\n");
|
|
|
|
return CLI_FAILURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev += len;
|
|
|
|
if (ast_strlen_zero(dev)) {
|
|
|
|
return CLI_SHOWUSAGE;
|
|
|
|
}
|
|
|
|
|
|
|
|
args = ast_strdupa(state);
|
|
|
|
if (parse_data(args, &state_val, &subtype, &message, &options)) {
|
|
|
|
return CLI_SHOWUSAGE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (state_val == AST_PRESENCE_NOT_SET) {
|
|
|
|
return CLI_SHOWUSAGE;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_cli(a->fd, "Changing %s to %s\n", dev, args);
|
|
|
|
|
|
|
|
ast_db_put(astdb_family, dev, state);
|
|
|
|
|
|
|
|
ast_presence_state_changed_literal(state_val, subtype, message, full_dev);
|
|
|
|
|
|
|
|
return CLI_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ast_cli_entry cli_funcpresencestate[] = {
|
|
|
|
AST_CLI_DEFINE(handle_cli_presencestate_list, "List currently know custom presence states"),
|
|
|
|
AST_CLI_DEFINE(handle_cli_presencestate_change, "Change a custom presence state"),
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef TEST_FRAMEWORK
|
|
|
|
|
|
|
|
struct test_string {
|
|
|
|
char *parse_string;
|
|
|
|
struct {
|
|
|
|
int value;
|
|
|
|
const char *subtype;
|
|
|
|
const char *message;
|
|
|
|
const char *options;
|
|
|
|
} outputs;
|
|
|
|
};
|
|
|
|
|
|
|
|
AST_TEST_DEFINE(test_valid_parse_data)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
enum ast_presence_state state;
|
|
|
|
char *subtype;
|
|
|
|
char *message;
|
|
|
|
char *options;
|
|
|
|
enum ast_test_result_state res = AST_TEST_PASS;
|
|
|
|
|
|
|
|
struct test_string tests [] = {
|
|
|
|
{ "away",
|
|
|
|
{ AST_PRESENCE_AWAY,
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
""
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "not_set",
|
|
|
|
{ AST_PRESENCE_NOT_SET,
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
""
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "unavailable",
|
|
|
|
{ AST_PRESENCE_UNAVAILABLE,
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
""
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "available",
|
|
|
|
{ AST_PRESENCE_AVAILABLE,
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
""
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "xa",
|
|
|
|
{ AST_PRESENCE_XA,
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
""
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "chat",
|
|
|
|
{ AST_PRESENCE_CHAT,
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
""
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "dnd",
|
|
|
|
{ AST_PRESENCE_DND,
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
""
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "away,down the hall",
|
|
|
|
{ AST_PRESENCE_AWAY,
|
|
|
|
"down the hall",
|
|
|
|
"",
|
|
|
|
""
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "away,down the hall,Quarterly financial meeting",
|
|
|
|
{ AST_PRESENCE_AWAY,
|
|
|
|
"down the hall",
|
|
|
|
"Quarterly financial meeting",
|
|
|
|
""
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "away,,Quarterly financial meeting",
|
|
|
|
{ AST_PRESENCE_AWAY,
|
|
|
|
"",
|
|
|
|
"Quarterly financial meeting",
|
|
|
|
""
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "away,,,e",
|
|
|
|
{ AST_PRESENCE_AWAY,
|
|
|
|
"",
|
|
|
|
"",
|
|
|
|
"e",
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "away,down the hall,,e",
|
|
|
|
{ AST_PRESENCE_AWAY,
|
|
|
|
"down the hall",
|
|
|
|
"",
|
|
|
|
"e"
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "away,down the hall,Quarterly financial meeting,e",
|
|
|
|
{ AST_PRESENCE_AWAY,
|
|
|
|
"down the hall",
|
|
|
|
"Quarterly financial meeting",
|
|
|
|
"e"
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{ "away,,Quarterly financial meeting,e",
|
|
|
|
{ AST_PRESENCE_AWAY,
|
|
|
|
"",
|
|
|
|
"Quarterly financial meeting",
|
|
|
|
"e"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case TEST_INIT:
|
|
|
|
info->name = "parse_valid_presence_data";
|
2012-07-30 23:18:13 +00:00
|
|
|
info->category = "/funcs/func_presence/";
|
2012-06-04 20:26:12 +00:00
|
|
|
info->summary = "PRESENCESTATE parsing test";
|
|
|
|
info->description =
|
|
|
|
"Ensure that parsing function accepts proper values, and gives proper outputs";
|
|
|
|
return AST_TEST_NOT_RUN;
|
|
|
|
case TEST_EXECUTE:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_LEN(tests); ++i) {
|
|
|
|
int parse_result;
|
|
|
|
char *parse_string = ast_strdup(tests[i].parse_string);
|
|
|
|
if (!parse_string) {
|
|
|
|
res = AST_TEST_FAIL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
parse_result = parse_data(parse_string, &state, &subtype, &message, &options);
|
|
|
|
if (parse_result == -1) {
|
|
|
|
res = AST_TEST_FAIL;
|
|
|
|
ast_free(parse_string);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (tests[i].outputs.value != state ||
|
|
|
|
strcmp(tests[i].outputs.subtype, subtype) ||
|
|
|
|
strcmp(tests[i].outputs.message, message) ||
|
|
|
|
strcmp(tests[i].outputs.options, options)) {
|
|
|
|
res = AST_TEST_FAIL;
|
|
|
|
ast_free(parse_string);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ast_free(parse_string);
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
AST_TEST_DEFINE(test_invalid_parse_data)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
enum ast_presence_state state;
|
|
|
|
char *subtype;
|
|
|
|
char *message;
|
|
|
|
char *options;
|
|
|
|
enum ast_test_result_state res = AST_TEST_PASS;
|
|
|
|
|
|
|
|
char *tests[] = {
|
|
|
|
"",
|
|
|
|
"bored",
|
|
|
|
"away,,,i",
|
|
|
|
/* XXX The following actually is parsed correctly. Should that
|
|
|
|
* be changed?
|
|
|
|
* "away,,,,e",
|
|
|
|
*/
|
|
|
|
};
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case TEST_INIT:
|
|
|
|
info->name = "parse_invalid_presence_data";
|
2012-07-30 23:18:13 +00:00
|
|
|
info->category = "/funcs/func_presence/";
|
2012-06-04 20:26:12 +00:00
|
|
|
info->summary = "PRESENCESTATE parsing test";
|
|
|
|
info->description =
|
|
|
|
"Ensure that parsing function rejects improper values";
|
|
|
|
return AST_TEST_NOT_RUN;
|
|
|
|
case TEST_EXECUTE:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_LEN(tests); ++i) {
|
|
|
|
int parse_result;
|
|
|
|
char *parse_string = ast_strdup(tests[i]);
|
|
|
|
if (!parse_string) {
|
|
|
|
res = AST_TEST_FAIL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
parse_result = parse_data(parse_string, &state, &subtype, &message, &options);
|
|
|
|
if (parse_result == 0) {
|
|
|
|
ast_log(LOG_WARNING, "Invalid string parsing failed on %s\n", tests[i]);
|
|
|
|
res = AST_TEST_FAIL;
|
|
|
|
ast_free(parse_string);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ast_free(parse_string);
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2014-05-01 16:21:09 +00:00
|
|
|
#define PRES_STATE "away"
|
|
|
|
#define PRES_SUBTYPE "down the hall"
|
|
|
|
#define PRES_MESSAGE "Quarterly financial meeting"
|
|
|
|
|
2012-06-04 20:26:12 +00:00
|
|
|
struct test_cb_data {
|
2013-04-16 15:48:16 +00:00
|
|
|
struct ast_presence_state_message *presence_state;
|
2012-06-04 20:26:12 +00:00
|
|
|
/* That's right. I'm using a semaphore */
|
2015-01-26 14:50:40 +00:00
|
|
|
struct ast_sem sem;
|
2012-06-04 20:26:12 +00:00
|
|
|
};
|
|
|
|
|
2014-05-01 16:21:09 +00:00
|
|
|
static struct test_cb_data *test_cb_data_alloc(void)
|
|
|
|
{
|
|
|
|
struct test_cb_data *cb_data = ast_calloc(1, sizeof(*cb_data));
|
|
|
|
|
|
|
|
if (!cb_data) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-01-26 14:50:40 +00:00
|
|
|
if (ast_sem_init(&cb_data->sem, 0, 0)) {
|
2014-05-01 16:21:09 +00:00
|
|
|
ast_free(cb_data);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cb_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_cb_data_destroy(struct test_cb_data *cb_data)
|
|
|
|
{
|
|
|
|
ao2_cleanup(cb_data->presence_state);
|
2015-01-26 14:50:40 +00:00
|
|
|
ast_sem_destroy(&cb_data->sem);
|
2014-05-01 16:21:09 +00:00
|
|
|
ast_free(cb_data);
|
|
|
|
}
|
|
|
|
|
Multiple revisions 399887,400138,400178,400180-400181
........
r399887 | dlee | 2013-09-26 10:41:47 -0500 (Thu, 26 Sep 2013) | 1 line
Minor performance bump by not allocate manager variable struct if we don't need it
........
r400138 | dlee | 2013-09-30 10:24:00 -0500 (Mon, 30 Sep 2013) | 23 lines
Stasis performance improvements
This patch addresses several performance problems that were found in
the initial performance testing of Asterisk 12.
The Stasis dispatch object was allocated as an AO2 object, even though
it has a very confined lifecycle. This was replaced with a straight
ast_malloc().
The Stasis message router was spending an inordinate amount of time
searching hash tables. In this case, most of our routers had 6 or
fewer routes in them to begin with. This was replaced with an array
that's searched linearly for the route.
We more heavily rely on AO2 objects in Asterisk 12, and the memset()
in ao2_ref() actually became noticeable on the profile. This was
#ifdef'ed to only run when AO2_DEBUG was enabled.
After being misled by an erroneous comment in taskprocessor.c during
profiling, the wrong comment was removed.
Review: https://reviewboard.asterisk.org/r/2873/
........
r400178 | dlee | 2013-09-30 13:26:27 -0500 (Mon, 30 Sep 2013) | 24 lines
Taskprocessor optimization; switch Stasis to use taskprocessors
This patch optimizes taskprocessor to use a semaphore for signaling,
which the OS can do a better job at managing contention and waiting
that we can with a mutex and condition.
The taskprocessor execution was also slightly optimized to reduce the
number of locks taken.
The only observable difference in the taskprocessor implementation is
that when the final reference to the taskprocessor goes away, it will
execute all tasks to completion instead of discarding the unexecuted
tasks.
For systems where unnamed semaphores are not supported, a really
simple semaphore implementation is provided. (Which gives identical
performance as the original taskprocessor implementation).
The way we ended up implementing Stasis caused the threadpool to be a
burden instead of a boost to performance. This was switched to just
use taskprocessors directly for subscriptions.
Review: https://reviewboard.asterisk.org/r/2881/
........
r400180 | dlee | 2013-09-30 13:39:34 -0500 (Mon, 30 Sep 2013) | 28 lines
Optimize how Stasis forwards are dispatched
This patch optimizes how forwards are dispatched in Stasis.
Originally, forwards were dispatched as subscriptions that are invoked
on the publishing thread. This did not account for the vast number of
forwards we would end up having in the system, and the amount of work it
would take to walk though the forward subscriptions.
This patch modifies Stasis so that rather than walking the tree of
forwards on every dispatch, when forwards and subscriptions are changed,
the subscriber list for every topic in the tree is changed.
This has a couple of benefits. First, this reduces the workload of
dispatching messages. It also reduces contention when dispatching to
different topics that happen to forward to the same aggregation topic
(as happens with all of the channel, bridge and endpoint topics).
Since forwards are no longer subscriptions, the bulk of this patch is
simply changing stasis_subscription objects to stasis_forward objects
(which, admittedly, I should have done in the first place.)
Since this required me to yet again put in a growing array, I finally
abstracted that out into a set of ast_vector macros in
asterisk/vector.h.
Review: https://reviewboard.asterisk.org/r/2883/
........
r400181 | dlee | 2013-09-30 13:48:57 -0500 (Mon, 30 Sep 2013) | 28 lines
Remove dispatch object allocation from Stasis publishing
While looking for areas for performance improvement, I realized that an
unused feature in Stasis was negatively impacting performance.
When a message is sent to a subscriber, a dispatch object is allocated
for the dispatch, containing the topic the message was published to, the
subscriber the message is being sent to, and the message itself.
The topic is actually unused by any subscriber in Asterisk today. And
the subscriber is associated with the taskprocessor the message is being
dispatched to.
First, this patch removes the unused topic parameter from Stasis
subscription callbacks.
Second, this patch introduces the concept of taskprocessor local data,
data that may be set on a taskprocessor and provided along with the data
pointer when a task is pushed using the ast_taskprocessor_push_local()
call. This allows the task to have both data specific to that
taskprocessor, in addition to data specific to that invocation.
With those two changes, the dispatch object can be removed completely,
and the message is simply refcounted and sent directly to the
taskprocessor.
Review: https://reviewboard.asterisk.org/r/2884/
........
Merged revisions 399887,400138,400178,400180-400181 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@400186 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2013-09-30 18:55:27 +00:00
|
|
|
static void test_cb(void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
|
2012-06-04 20:26:12 +00:00
|
|
|
{
|
|
|
|
struct test_cb_data *cb_data = userdata;
|
2013-04-16 15:48:16 +00:00
|
|
|
if (stasis_message_type(msg) != ast_presence_state_message_type()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
cb_data->presence_state = stasis_message_data(msg);
|
|
|
|
ao2_ref(cb_data->presence_state, +1);
|
|
|
|
|
2015-01-26 14:50:40 +00:00
|
|
|
ast_sem_post(&cb_data->sem);
|
2012-06-04 20:26:12 +00:00
|
|
|
}
|
|
|
|
|
2014-05-01 16:21:09 +00:00
|
|
|
static enum ast_test_result_state presence_change_common(struct ast_test *test,
|
|
|
|
const char *state, const char *subtype, const char *message, const char *options,
|
|
|
|
char *out_state, size_t out_state_size,
|
|
|
|
char *out_subtype, size_t out_subtype_size,
|
|
|
|
char *out_message, size_t out_message_size)
|
2012-06-04 20:26:12 +00:00
|
|
|
{
|
2014-05-01 16:21:09 +00:00
|
|
|
RAII_VAR(struct test_cb_data *, cb_data, test_cb_data_alloc(), test_cb_data_destroy);
|
2013-04-16 15:48:16 +00:00
|
|
|
struct stasis_subscription *test_sub;
|
2014-05-01 16:21:09 +00:00
|
|
|
char pres[1301];
|
|
|
|
|
|
|
|
if (!(test_sub = stasis_subscribe(ast_presence_state_topic_all(), test_cb, cb_data))) {
|
|
|
|
return AST_TEST_FAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_strlen_zero(options)) {
|
|
|
|
snprintf(pres, sizeof(pres), "%s,%s,%s", state, subtype, message);
|
|
|
|
} else {
|
|
|
|
snprintf(pres, sizeof(pres), "%s,%s,%s,%s", state, subtype, message, options);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (presence_write(NULL, "PRESENCESTATE", "CustomPresence:TestPresenceStateChange", pres)) {
|
|
|
|
test_sub = stasis_unsubscribe_and_join(test_sub);
|
|
|
|
return AST_TEST_FAIL;
|
|
|
|
}
|
|
|
|
|
2015-01-26 14:50:40 +00:00
|
|
|
ast_sem_wait(&cb_data->sem);
|
2014-05-01 16:21:09 +00:00
|
|
|
|
|
|
|
ast_copy_string(out_state, ast_presence_state2str(cb_data->presence_state->state), out_state_size);
|
|
|
|
ast_copy_string(out_subtype, cb_data->presence_state->subtype, out_subtype_size);
|
|
|
|
ast_copy_string(out_message, cb_data->presence_state->message, out_message_size);
|
|
|
|
|
|
|
|
test_sub = stasis_unsubscribe_and_join(test_sub);
|
|
|
|
ast_db_del("CustomPresence", "TestPresenceStateChange");
|
|
|
|
|
|
|
|
return AST_TEST_PASS;
|
|
|
|
}
|
|
|
|
|
|
|
|
AST_TEST_DEFINE(test_presence_state_change)
|
|
|
|
{
|
|
|
|
char out_state[32];
|
|
|
|
char out_subtype[32];
|
|
|
|
char out_message[32];
|
2012-06-04 20:26:12 +00:00
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case TEST_INIT:
|
|
|
|
info->name = "test_presence_state_change";
|
2012-07-30 23:18:13 +00:00
|
|
|
info->category = "/funcs/func_presence/";
|
2012-06-04 20:26:12 +00:00
|
|
|
info->summary = "presence state change subscription";
|
|
|
|
info->description =
|
|
|
|
"Ensure that presence state changes are communicated to subscribers";
|
|
|
|
return AST_TEST_NOT_RUN;
|
|
|
|
case TEST_EXECUTE:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-05-01 16:21:09 +00:00
|
|
|
if (presence_change_common(test, PRES_STATE, PRES_SUBTYPE, PRES_MESSAGE, NULL,
|
|
|
|
out_state, sizeof(out_state),
|
|
|
|
out_subtype, sizeof(out_subtype),
|
|
|
|
out_message, sizeof(out_message)) == AST_TEST_FAIL) {
|
2012-06-04 20:26:12 +00:00
|
|
|
return AST_TEST_FAIL;
|
|
|
|
}
|
|
|
|
|
2014-05-01 16:21:09 +00:00
|
|
|
if (strcmp(out_state, PRES_STATE) ||
|
|
|
|
strcmp(out_subtype, PRES_SUBTYPE) ||
|
|
|
|
strcmp(out_message, PRES_MESSAGE)) {
|
|
|
|
ast_test_status_update(test, "Unexpected presence values, %s != %s, %s != %s, or %s != %s\n",
|
|
|
|
PRES_STATE, out_state,
|
|
|
|
PRES_SUBTYPE, out_subtype,
|
|
|
|
PRES_MESSAGE, out_message);
|
2012-06-04 20:26:12 +00:00
|
|
|
return AST_TEST_FAIL;
|
|
|
|
}
|
|
|
|
|
2014-05-01 16:21:09 +00:00
|
|
|
return AST_TEST_PASS;
|
|
|
|
}
|
2012-06-04 20:26:12 +00:00
|
|
|
|
2014-05-01 16:21:09 +00:00
|
|
|
AST_TEST_DEFINE(test_presence_state_base64_encode)
|
|
|
|
{
|
|
|
|
char out_state[32];
|
|
|
|
char out_subtype[32];
|
|
|
|
char out_message[32];
|
|
|
|
char encoded_subtype[64];
|
|
|
|
char encoded_message[64];
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case TEST_INIT:
|
|
|
|
info->name = "test_presence_state_base64_encode";
|
|
|
|
info->category = "/funcs/func_presence/";
|
|
|
|
info->summary = "presence state base64 encoding";
|
|
|
|
info->description =
|
|
|
|
"Ensure that base64-encoded presence state is stored base64-encoded but\n"
|
|
|
|
"is presented to consumers decoded.";
|
|
|
|
return AST_TEST_NOT_RUN;
|
|
|
|
case TEST_EXECUTE:
|
|
|
|
break;
|
2012-06-04 20:26:12 +00:00
|
|
|
}
|
|
|
|
|
2014-05-01 16:21:09 +00:00
|
|
|
ast_base64encode(encoded_subtype, (unsigned char *) PRES_SUBTYPE, strlen(PRES_SUBTYPE), sizeof(encoded_subtype) - 1);
|
|
|
|
ast_base64encode(encoded_message, (unsigned char *) PRES_MESSAGE, strlen(PRES_MESSAGE), sizeof(encoded_message) - 1);
|
2013-04-16 15:48:16 +00:00
|
|
|
|
2014-05-01 16:21:09 +00:00
|
|
|
if (presence_change_common(test, PRES_STATE, encoded_subtype, encoded_message, "e",
|
|
|
|
out_state, sizeof(out_state),
|
|
|
|
out_subtype, sizeof(out_subtype),
|
|
|
|
out_message, sizeof(out_message)) == AST_TEST_FAIL) {
|
|
|
|
return AST_TEST_FAIL;
|
|
|
|
}
|
2012-06-04 20:26:12 +00:00
|
|
|
|
2014-05-01 16:21:09 +00:00
|
|
|
if (strcmp(out_state, PRES_STATE) ||
|
|
|
|
strcmp(out_subtype, PRES_SUBTYPE) ||
|
|
|
|
strcmp(out_message, PRES_MESSAGE)) {
|
|
|
|
ast_test_status_update(test, "Unexpected presence values, %s != %s, %s != %s, or %s != %s\n",
|
|
|
|
PRES_STATE, out_state,
|
|
|
|
PRES_SUBTYPE, out_subtype,
|
|
|
|
PRES_MESSAGE, out_message);
|
|
|
|
return AST_TEST_FAIL;
|
|
|
|
}
|
2012-06-04 20:26:12 +00:00
|
|
|
|
|
|
|
return AST_TEST_PASS;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int unload_module(void)
|
|
|
|
{
|
|
|
|
int res = 0;
|
|
|
|
|
|
|
|
res |= ast_custom_function_unregister(&presence_function);
|
|
|
|
res |= ast_presence_state_prov_del("CustomPresence");
|
|
|
|
res |= ast_cli_unregister_multiple(cli_funcpresencestate, ARRAY_LEN(cli_funcpresencestate));
|
|
|
|
#ifdef TEST_FRAMEWORK
|
|
|
|
AST_TEST_UNREGISTER(test_valid_parse_data);
|
|
|
|
AST_TEST_UNREGISTER(test_invalid_parse_data);
|
|
|
|
AST_TEST_UNREGISTER(test_presence_state_change);
|
2014-05-01 16:21:09 +00:00
|
|
|
AST_TEST_UNREGISTER(test_presence_state_base64_encode);
|
2012-06-04 20:26:12 +00:00
|
|
|
#endif
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int load_module(void)
|
|
|
|
{
|
|
|
|
int res = 0;
|
|
|
|
struct ast_db_entry *db_entry, *db_tree;
|
|
|
|
|
|
|
|
/* Populate the presence state cache on the system with all of the currently
|
|
|
|
* known custom presence states. */
|
|
|
|
db_entry = db_tree = ast_db_gettree(astdb_family, NULL);
|
|
|
|
for (; db_entry; db_entry = db_entry->next) {
|
|
|
|
const char *dev_name = strrchr(db_entry->key, '/') + 1;
|
|
|
|
enum ast_presence_state state;
|
|
|
|
char *message;
|
|
|
|
char *subtype;
|
|
|
|
if (dev_name <= (const char *) 1) {
|
|
|
|
continue;
|
|
|
|
}
|
2014-05-07 21:58:37 +00:00
|
|
|
state = custom_presence_callback(dev_name, &subtype, &message);
|
2012-06-04 20:26:12 +00:00
|
|
|
ast_presence_state_changed(state, subtype, message, "CustomPresence:%s", dev_name);
|
2014-05-07 21:58:37 +00:00
|
|
|
ast_free(subtype);
|
|
|
|
ast_free(message);
|
2012-06-04 20:26:12 +00:00
|
|
|
}
|
|
|
|
ast_db_freetree(db_tree);
|
|
|
|
db_tree = NULL;
|
|
|
|
|
|
|
|
res |= ast_custom_function_register(&presence_function);
|
|
|
|
res |= ast_presence_state_prov_add("CustomPresence", custom_presence_callback);
|
|
|
|
res |= ast_cli_register_multiple(cli_funcpresencestate, ARRAY_LEN(cli_funcpresencestate));
|
|
|
|
#ifdef TEST_FRAMEWORK
|
|
|
|
AST_TEST_REGISTER(test_valid_parse_data);
|
|
|
|
AST_TEST_REGISTER(test_invalid_parse_data);
|
|
|
|
AST_TEST_REGISTER(test_presence_state_change);
|
2014-05-01 16:21:09 +00:00
|
|
|
AST_TEST_REGISTER(test_presence_state_base64_encode);
|
2012-06-04 20:26:12 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Gets or sets a presence state in the dialplan",
|
2014-07-25 16:47:17 +00:00
|
|
|
.support_level = AST_MODULE_SUPPORT_CORE,
|
2012-06-04 20:26:12 +00:00
|
|
|
.load = load_module,
|
|
|
|
.unload = unload_module,
|
|
|
|
.load_pri = AST_MODPRI_DEVSTATE_PROVIDER,
|
|
|
|
);
|
|
|
|
|