Asterisk
/
asterisk
mirror of https://github.com/asterisk/asterisk
1
0
Fork 0
Code Issues Releases Wiki Activity

stasis_channels.c: Misc cleanup.

Browse Source 
* Use current OBJ_SEARCH_xxx defines instead of the deprecated versions.

* Fix hash_cb and cmp_cb container functions to correctly use the
OBJ_SEARCH_xxx values.

* Remove incorrect usage of CMP_STOP.  Most uses in the system have no
effect.  This allows the collapse of channel_role_single_cmp_cb() and
channel_role_multi_cmp_cb() into channel_role_cmp_cb().

* Remove unnecessary usage of RAII_VAR().

Change-Id: I02c405518cab22aa2a082b61e2353bf7cd629a70
certified/13.21
Richard Mudgett 8 years ago
parent e4d536b64d
commit 751fd9b628
1 changed files with 195 additions and 121 deletions
Show Stats Download Patch File Download Diff File

316
main/stasis_channels.c
Unescape View File

@ -174,9 +174,21 @@ static const char *channel_snapshot_get_name(struct stasis_message *message)
*/ */
static int channel_snapshot_hash_cb(const void *obj, const int flags) static int channel_snapshot_hash_cb(const void *obj, const int flags)
{ {
const struct ast_channel_snapshot *snapshot = obj; const struct ast_channel_snapshot *object = obj;
const char *name = (flags & OBJ_KEY) ? obj : snapshot->name; const char *key;
return ast_str_case_hash(name);
switch (flags & OBJ_SEARCH_MASK) {
case OBJ_SEARCH_KEY:
key = obj;
break;
case OBJ_SEARCH_OBJECT:
key = object->name;
break;
default:
ast_assert(0);
return 0;
}
return ast_str_case_hash(key);
} }
/*! /*!
@ -185,10 +197,28 @@ static int channel_snapshot_hash_cb(const void *obj, const int flags)
*/ */
static int channel_snapshot_cmp_cb(void *obj, void *arg, int flags) static int channel_snapshot_cmp_cb(void *obj, void *arg, int flags)
{ {
struct ast_channel_snapshot *left = obj; const struct ast_channel_snapshot *object_left = obj;
struct ast_channel_snapshot *right = arg; const struct ast_channel_snapshot *object_right = arg;
const char *match = (flags & OBJ_KEY) ? arg : right->name; const char *right_key = arg;
return strcasecmp(left->name, match) ? 0 : (CMP_MATCH | CMP_STOP); int cmp;
switch (flags & OBJ_SEARCH_MASK) {
case OBJ_SEARCH_OBJECT:
right_key = object_right->name;
case OBJ_SEARCH_KEY:
cmp = strcasecmp(object_left->name, right_key);
break;
case OBJ_SEARCH_PARTIAL_KEY:
cmp = strncasecmp(object_left->name, right_key, strlen(right_key));
break;
default:
cmp = 0;
break;
}
if (cmp) {
return 0;
}
return CMP_MATCH;
} }
static void channel_snapshot_dtor(void *obj) static void channel_snapshot_dtor(void *obj)
@ -297,31 +327,33 @@ static void ast_channel_publish_dial_internal(struct ast_channel *caller,
struct ast_channel *peer, struct ast_channel *forwarded, const char *dialstring, struct ast_channel *peer, struct ast_channel *forwarded, const char *dialstring,
const char *dialstatus, const char *forward) const char *dialstatus, const char *forward)
{ {
RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup); struct ast_multi_channel_blob *payload;
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup); struct stasis_message *msg;
RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref); struct ast_json *blob;
RAII_VAR(struct ast_channel_snapshot *, caller_snapshot, NULL, ao2_cleanup); struct ast_channel_snapshot *peer_snapshot;
RAII_VAR(struct ast_channel_snapshot *, peer_snapshot, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, forwarded_snapshot, NULL, ao2_cleanup);
if (!ast_channel_dial_type()) { if (!ast_channel_dial_type()) {
return; return;
} }
ast_assert(peer != NULL); ast_assert(peer != NULL);
blob = ast_json_pack("{s: s, s: s, s: s}", blob = ast_json_pack("{s: s, s: s, s: s}",
"dialstatus", S_OR(dialstatus, ""), "dialstatus", S_OR(dialstatus, ""),
"forward", S_OR(forward, ""), "forward", S_OR(forward, ""),
"dialstring", S_OR(dialstring, "")); "dialstring", S_OR(dialstring, ""));
if (!blob) { if (!blob) {
return; return;
} }
payload = ast_multi_channel_blob_create(blob); payload = ast_multi_channel_blob_create(blob);
ast_json_unref(blob);
if (!payload) { if (!payload) {
return; return;
} }
if (caller) { if (caller) {
struct ast_channel_snapshot *caller_snapshot;
ast_channel_lock(caller); ast_channel_lock(caller);
if (ast_strlen_zero(dialstatus)) { if (ast_strlen_zero(dialstatus)) {
caller_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(caller)); caller_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(caller));
@ -330,9 +362,11 @@ static void ast_channel_publish_dial_internal(struct ast_channel *caller,
} }
ast_channel_unlock(caller); ast_channel_unlock(caller);
if (!caller_snapshot) { if (!caller_snapshot) {
ao2_ref(payload, -1);
return; return;
} }
ast_multi_channel_blob_add_channel(payload, "caller", caller_snapshot); ast_multi_channel_blob_add_channel(payload, "caller", caller_snapshot);
ao2_ref(caller_snapshot, -1);
} }
ast_channel_lock(peer); ast_channel_lock(peer);
@ -343,26 +377,32 @@ static void ast_channel_publish_dial_internal(struct ast_channel *caller,
} }
ast_channel_unlock(peer); ast_channel_unlock(peer);
if (!peer_snapshot) { if (!peer_snapshot) {
ao2_ref(payload, -1);
return; return;
} }
ast_multi_channel_blob_add_channel(payload, "peer", peer_snapshot); ast_multi_channel_blob_add_channel(payload, "peer", peer_snapshot);
ao2_ref(peer_snapshot, -1);
if (forwarded) { if (forwarded) {
struct ast_channel_snapshot *forwarded_snapshot;
ast_channel_lock(forwarded); ast_channel_lock(forwarded);
forwarded_snapshot = ast_channel_snapshot_create(forwarded); forwarded_snapshot = ast_channel_snapshot_create(forwarded);
ast_channel_unlock(forwarded); ast_channel_unlock(forwarded);
if (!forwarded_snapshot) { if (!forwarded_snapshot) {
ao2_ref(payload, -1);
return; return;
} }
ast_multi_channel_blob_add_channel(payload, "forwarded", forwarded_snapshot); ast_multi_channel_blob_add_channel(payload, "forwarded", forwarded_snapshot);
ao2_ref(forwarded_snapshot, -1);
} }
msg = stasis_message_create(ast_channel_dial_type(), payload); msg = stasis_message_create(ast_channel_dial_type(), payload);
if (!msg) { ao2_ref(payload, -1);
return; if (msg) {
publish_message_for_channel_topics(msg, caller);
ao2_ref(msg, -1);
} }
publish_message_for_channel_topics(msg, caller);
} }
static void remove_dial_masquerade(struct ast_channel *peer); static void remove_dial_masquerade(struct ast_channel *peer);
@ -456,33 +496,33 @@ struct stasis_message *ast_channel_blob_create_from_cache(const char *channel_id
struct stasis_message_type *type, struct stasis_message_type *type,
struct ast_json *blob) struct ast_json *blob)
{ {
RAII_VAR(struct ast_channel_snapshot *, snapshot, struct ast_channel_snapshot *snapshot;
NULL, struct stasis_message *msg;
ao2_cleanup);
if (!type) { if (!type) {
return NULL; return NULL;
} }
snapshot = ast_channel_snapshot_get_latest(channel_id); snapshot = ast_channel_snapshot_get_latest(channel_id);
msg = create_channel_blob_message(snapshot, type, blob);
return create_channel_blob_message(snapshot, type, blob); ao2_cleanup(snapshot);
return msg;
} }
struct stasis_message *ast_channel_blob_create(struct ast_channel *chan, struct stasis_message *ast_channel_blob_create(struct ast_channel *chan,
struct stasis_message_type *type, struct ast_json *blob) struct stasis_message_type *type, struct ast_json *blob)
{ {
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup); struct ast_channel_snapshot *snapshot;
struct stasis_message *msg;
if (!type) { if (!type) {
return NULL; return NULL;
} }
if (chan) { snapshot = chan ? ast_channel_snapshot_create(chan) : NULL;
snapshot = ast_channel_snapshot_create(chan); msg = create_channel_blob_message(snapshot, type, blob);
} ao2_cleanup(snapshot);
return msg;
return create_channel_blob_message(snapshot, type, blob);
} }
/*! \brief A channel snapshot wrapper object used in \ref ast_multi_channel_blob objects */ /*! \brief A channel snapshot wrapper object used in \ref ast_multi_channel_blob objects */
@ -494,31 +534,37 @@ struct channel_role_snapshot {
/*! \brief A multi channel blob data structure for multi_channel_blob stasis messages */ /*! \brief A multi channel blob data structure for multi_channel_blob stasis messages */
struct ast_multi_channel_blob { struct ast_multi_channel_blob {
struct ao2_container *channel_snapshots; /*!< A container holding the snapshots */ struct ao2_container *channel_snapshots; /*!< A container holding the snapshots */
struct ast_json *blob; /*< A blob of JSON data */ struct ast_json *blob; /*!< A blob of JSON data */
}; };
/*! /*!
* \internal * \internal
* \brief Standard comparison function for \ref channel_role_snapshot objects * \brief Comparison function for \ref channel_role_snapshot objects
*/ */
static int channel_role_single_cmp_cb(void *obj, void *arg, int flags) static int channel_role_cmp_cb(void *obj, void *arg, int flags)
{ {
struct channel_role_snapshot *left = obj; const struct channel_role_snapshot *object_left = obj;
struct channel_role_snapshot *right = arg; const struct channel_role_snapshot *object_right = arg;
const char *match = (flags & OBJ_KEY) ? arg : right->role; const char *right_key = arg;
return strcasecmp(left->role, match) ? 0 : (CMP_MATCH | CMP_STOP); int cmp;
}
switch (flags & OBJ_SEARCH_MASK) {
/*! case OBJ_SEARCH_OBJECT:
* \internal right_key = object_right->role;
* \brief Multi comparison function for \ref channel_role_snapshot objects case OBJ_SEARCH_KEY:
*/ cmp = strcasecmp(object_left->role, right_key);
static int channel_role_multi_cmp_cb(void *obj, void *arg, int flags) break;
{ case OBJ_SEARCH_PARTIAL_KEY:
struct channel_role_snapshot *left = obj; cmp = strncasecmp(object_left->role, right_key, strlen(right_key));
struct channel_role_snapshot *right = arg; break;
const char *match = (flags & OBJ_KEY) ? arg : right->role; default:
return strcasecmp(left->role, match) ? 0 : (CMP_MATCH); cmp = 0;
break;
}
if (cmp) {
return 0;
}
return CMP_MATCH;
} }
/*! /*!
@ -527,9 +573,21 @@ static int channel_role_multi_cmp_cb(void *obj, void *arg, int flags)
*/ */
static int channel_role_hash_cb(const void *obj, const int flags) static int channel_role_hash_cb(const void *obj, const int flags)
{ {
const struct channel_role_snapshot *snapshot = obj; const struct channel_role_snapshot *object = obj;
const char *name = (flags & OBJ_KEY) ? obj : snapshot->role; const char *key;
return ast_str_case_hash(name);
switch (flags & OBJ_SEARCH_MASK) {
case OBJ_SEARCH_KEY:
key = obj;
break;
case OBJ_SEARCH_OBJECT:
key = object->role;
break;
default:
ast_assert(0);
return 0;
}
return ast_str_case_hash(key);
} }
/*! /*!
@ -546,89 +604,80 @@ static void multi_channel_blob_dtor(void *obj)
struct ast_multi_channel_blob *ast_multi_channel_blob_create(struct ast_json *blob) struct ast_multi_channel_blob *ast_multi_channel_blob_create(struct ast_json *blob)
{ {
RAII_VAR(struct ast_multi_channel_blob *, obj, struct ast_multi_channel_blob *obj;
ao2_alloc(sizeof(*obj), multi_channel_blob_dtor),
ao2_cleanup);
ast_assert(blob != NULL); ast_assert(blob != NULL);
obj = ao2_alloc(sizeof(*obj), multi_channel_blob_dtor);
if (!obj) { if (!obj) {
return NULL; return NULL;
} }
obj->channel_snapshots = ao2_container_alloc(NUM_MULTI_CHANNEL_BLOB_BUCKETS, obj->channel_snapshots = ao2_container_alloc(NUM_MULTI_CHANNEL_BLOB_BUCKETS,
channel_role_hash_cb, channel_role_single_cmp_cb); channel_role_hash_cb, channel_role_cmp_cb);
if (!obj->channel_snapshots) { if (!obj->channel_snapshots) {
ao2_ref(obj, -1);
return NULL; return NULL;
} }
obj->blob = ast_json_ref(blob); obj->blob = ast_json_ref(blob);
ao2_ref(obj, +1);
return obj; return obj;
} }
struct ast_channel_snapshot *ast_channel_snapshot_get_latest(const char *uniqueid) struct ast_channel_snapshot *ast_channel_snapshot_get_latest(const char *uniqueid)
{ {
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup); struct stasis_message *message;
struct ast_channel_snapshot *snapshot; struct ast_channel_snapshot *snapshot;
ast_assert(!ast_strlen_zero(uniqueid)); ast_assert(!ast_strlen_zero(uniqueid));
message = stasis_cache_get(ast_channel_cache(), message = stasis_cache_get(ast_channel_cache(), ast_channel_snapshot_type(),
ast_channel_snapshot_type(), uniqueid);
uniqueid);
if (!message) { if (!message) {
return NULL; return NULL;
} }
snapshot = stasis_message_data(message); snapshot = ao2_bump(stasis_message_data(message));
if (!snapshot) { ao2_ref(message, -1);
return NULL;
}
ao2_ref(snapshot, +1);
return snapshot; return snapshot;
} }
struct ast_channel_snapshot *ast_channel_snapshot_get_latest_by_name(const char *name) struct ast_channel_snapshot *ast_channel_snapshot_get_latest_by_name(const char *name)
{ {
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup); struct stasis_message *message;
struct ast_channel_snapshot *snapshot; struct ast_channel_snapshot *snapshot;
ast_assert(!ast_strlen_zero(name)); ast_assert(!ast_strlen_zero(name));
message = stasis_cache_get(ast_channel_cache_by_name(), message = stasis_cache_get(ast_channel_cache_by_name(), ast_channel_snapshot_type(),
ast_channel_snapshot_type(), name);
name);
if (!message) { if (!message) {
return NULL; return NULL;
} }
snapshot = stasis_message_data(message); snapshot = ao2_bump(stasis_message_data(message));
if (!snapshot) { ao2_ref(message, -1);
return NULL;
}
ao2_ref(snapshot, +1);
return snapshot; return snapshot;
} }
static void channel_role_snapshot_dtor(void *obj) static void channel_role_snapshot_dtor(void *obj)
{ {
struct channel_role_snapshot *role_snapshot = obj; struct channel_role_snapshot *role_snapshot = obj;
ao2_cleanup(role_snapshot->snapshot); ao2_cleanup(role_snapshot->snapshot);
} }
void ast_multi_channel_blob_add_channel(struct ast_multi_channel_blob *obj, const char *role, struct ast_channel_snapshot *snapshot) void ast_multi_channel_blob_add_channel(struct ast_multi_channel_blob *obj, const char *role, struct ast_channel_snapshot *snapshot)
{ {
RAII_VAR(struct channel_role_snapshot *, role_snapshot, NULL, ao2_cleanup); struct channel_role_snapshot *role_snapshot;
int role_len = strlen(role) + 1; int role_len = strlen(role) + 1;
if (!obj || ast_strlen_zero(role) || !snapshot) { if (!obj || ast_strlen_zero(role) || !snapshot) {
return; return;
} }
role_snapshot = ao2_alloc_options(sizeof(*role_snapshot) + role_len, channel_role_snapshot_dtor, role_snapshot = ao2_alloc_options(sizeof(*role_snapshot) + role_len,
AO2_ALLOC_OPT_LOCK_NOLOCK); channel_role_snapshot_dtor, AO2_ALLOC_OPT_LOCK_NOLOCK);
if (!role_snapshot) { if (!role_snapshot) {
return; return;
} }
@ -636,40 +685,49 @@ void ast_multi_channel_blob_add_channel(struct ast_multi_channel_blob *obj, cons
role_snapshot->snapshot = snapshot; role_snapshot->snapshot = snapshot;
ao2_ref(role_snapshot->snapshot, +1); ao2_ref(role_snapshot->snapshot, +1);
ao2_link(obj->channel_snapshots, role_snapshot); ao2_link(obj->channel_snapshots, role_snapshot);
ao2_ref(role_snapshot, -1);
} }
struct ast_channel_snapshot *ast_multi_channel_blob_get_channel(struct ast_multi_channel_blob *obj, const char *role) struct ast_channel_snapshot *ast_multi_channel_blob_get_channel(struct ast_multi_channel_blob *obj, const char *role)
{ {
struct channel_role_snapshot *role_snapshot; struct channel_role_snapshot *role_snapshot;
struct ast_channel_snapshot *snapshot;
if (!obj || ast_strlen_zero(role)) { if (!obj || ast_strlen_zero(role)) {
return NULL; return NULL;
} }
role_snapshot = ao2_find(obj->channel_snapshots, role, OBJ_KEY); role_snapshot = ao2_find(obj->channel_snapshots, role, OBJ_SEARCH_KEY);
/* Note that this function does not increase the ref count on snapshot */ /* Note that this function does not increase the ref count on snapshot */
if (!role_snapshot) { if (!role_snapshot) {
return NULL; return NULL;
} }
snapshot = role_snapshot->snapshot;
ao2_ref(role_snapshot, -1); ao2_ref(role_snapshot, -1);
return role_snapshot->snapshot; return snapshot;
} }
struct ao2_container *ast_multi_channel_blob_get_channels(struct ast_multi_channel_blob *obj, const char *role) struct ao2_container *ast_multi_channel_blob_get_channels(struct ast_multi_channel_blob *obj, const char *role)
{ {
RAII_VAR(struct ao2_container *, ret_container, struct ao2_container *ret_container;
ao2_container_alloc(NUM_MULTI_CHANNEL_BLOB_BUCKETS, channel_snapshot_hash_cb, channel_snapshot_cmp_cb),
ao2_cleanup);
struct ao2_iterator *it_role_snapshots; struct ao2_iterator *it_role_snapshots;
struct channel_role_snapshot *role_snapshot; struct channel_role_snapshot *role_snapshot;
char *arg; char *arg;
if (!obj || ast_strlen_zero(role) || !ret_container) { if (!obj || ast_strlen_zero(role)) {
return NULL; return NULL;
} }
arg = ast_strdupa(role);
it_role_snapshots = ao2_callback(obj->channel_snapshots, OBJ_MULTIPLE | OBJ_KEY, channel_role_multi_cmp_cb, arg); ret_container = ao2_container_alloc(NUM_MULTI_CHANNEL_BLOB_BUCKETS,
channel_snapshot_hash_cb, channel_snapshot_cmp_cb);
if (!ret_container) {
return NULL;
}
arg = ast_strdupa(role);
it_role_snapshots = ao2_callback(obj->channel_snapshots,
OBJ_MULTIPLE | OBJ_SEARCH_KEY, channel_role_cmp_cb, arg);
if (!it_role_snapshots) { if (!it_role_snapshots) {
ao2_ref(ret_container, -1);
return NULL; return NULL;
} }
@ -679,7 +737,6 @@ struct ao2_container *ast_multi_channel_blob_get_channels(struct ast_multi_chann
} }
ao2_iterator_destroy(it_role_snapshots); ao2_iterator_destroy(it_role_snapshots);
ao2_ref(ret_container, +1);
return ret_container; return ret_container;
} }
@ -704,8 +761,8 @@ void ast_channel_stage_snapshot_done(struct ast_channel *chan)
void ast_channel_publish_snapshot(struct ast_channel *chan) void ast_channel_publish_snapshot(struct ast_channel *chan)
{ {
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup); struct ast_channel_snapshot *snapshot;
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup); struct stasis_message *message;
if (!ast_channel_snapshot_type()) { if (!ast_channel_snapshot_type()) {
return; return;
@ -721,12 +778,14 @@ void ast_channel_publish_snapshot(struct ast_channel *chan)
} }
message = stasis_message_create(ast_channel_snapshot_type(), snapshot); message = stasis_message_create(ast_channel_snapshot_type(), snapshot);
ao2_ref(snapshot, -1);
if (!message) { if (!message) {
return; return;
} }
ast_assert(ast_channel_topic(chan) != NULL); ast_assert(ast_channel_topic(chan) != NULL);
stasis_publish(ast_channel_topic(chan), message); stasis_publish(ast_channel_topic(chan), message);
ao2_ref(message, -1);
} }
void ast_channel_publish_cached_blob(struct ast_channel *chan, struct stasis_message_type *type, struct ast_json *blob) void ast_channel_publish_cached_blob(struct ast_channel *chan, struct stasis_message_type *type, struct ast_json *blob)
@ -740,8 +799,8 @@ void ast_channel_publish_cached_blob(struct ast_channel *chan, struct stasis_mes
message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan), type, blob); message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan), type, blob);
if (message) { if (message) {
stasis_publish(ast_channel_topic(chan), message); stasis_publish(ast_channel_topic(chan), message);
ao2_ref(message, -1);
} }
ao2_cleanup(message);
} }
void ast_channel_publish_blob(struct ast_channel *chan, struct stasis_message_type *type, struct ast_json *blob) void ast_channel_publish_blob(struct ast_channel *chan, struct stasis_message_type *type, struct ast_json *blob)
@ -755,8 +814,8 @@ void ast_channel_publish_blob(struct ast_channel *chan, struct stasis_message_ty
message = ast_channel_blob_create(chan, type, blob); message = ast_channel_blob_create(chan, type, blob);
if (message) { if (message) {
stasis_publish(ast_channel_topic(chan), message); stasis_publish(ast_channel_topic(chan), message);
ao2_ref(message, -1);
} }
ao2_cleanup(message);
} }
void ast_channel_publish_varset(struct ast_channel *chan, const char *name, const char *value) void ast_channel_publish_varset(struct ast_channel *chan, const char *name, const char *value)
@ -791,78 +850,88 @@ void ast_channel_publish_varset(struct ast_channel *chan, const char *name, cons
static struct ast_manager_event_blob *varset_to_ami(struct stasis_message *msg) static struct ast_manager_event_blob *varset_to_ami(struct stasis_message *msg)
{ {
RAII_VAR(struct ast_str *, channel_event_string, NULL, ast_free); struct ast_str *channel_event_string;
struct ast_channel_blob *obj = stasis_message_data(msg); struct ast_channel_blob *obj = stasis_message_data(msg);
const char *variable = const char *variable =
ast_json_string_get(ast_json_object_get(obj->blob, "variable")); ast_json_string_get(ast_json_object_get(obj->blob, "variable"));
RAII_VAR(char *, value, ast_escape_c_alloc( char *value;
ast_json_string_get(ast_json_object_get(obj->blob, "value"))), ast_free); struct ast_manager_event_blob *ev;
value = ast_escape_c_alloc(ast_json_string_get(ast_json_object_get(obj->blob,
"value")));
if (!value) { if (!value) {
return NULL; return NULL;
} }
if (obj->snapshot) { if (obj->snapshot) {
channel_event_string = channel_event_string = ast_manager_build_channel_state_string(obj->snapshot);
ast_manager_build_channel_state_string(obj->snapshot);
} else { } else {
channel_event_string = ast_str_create(35); channel_event_string = ast_str_create(35);
ast_str_set(&channel_event_string, 0, ast_str_set(&channel_event_string, 0,
"Channel: none\r\n" "Channel: none\r\n"
"Uniqueid: none\r\n"); "Uniqueid: none\r\n");
} }
if (!channel_event_string) { if (!channel_event_string) {
ast_free(value);
return NULL; return NULL;
} }
return ast_manager_event_blob_create(EVENT_FLAG_DIALPLAN, "VarSet", ev = ast_manager_event_blob_create(EVENT_FLAG_DIALPLAN, "VarSet",
"%s" "%s"
"Variable: %s\r\n" "Variable: %s\r\n"
"Value: %s\r\n", "Value: %s\r\n",
ast_str_buffer(channel_event_string), variable, value); ast_str_buffer(channel_event_string), variable, value);
ast_free(channel_event_string);
ast_free(value);
return ev;
} }
static struct ast_manager_event_blob *agent_login_to_ami(struct stasis_message *msg) static struct ast_manager_event_blob *agent_login_to_ami(struct stasis_message *msg)
{ {
RAII_VAR(struct ast_str *, channel_string, NULL, ast_free); struct ast_str *channel_string;
struct ast_channel_blob *obj = stasis_message_data(msg); struct ast_channel_blob *obj = stasis_message_data(msg);
const char *agent = ast_json_string_get(ast_json_object_get(obj->blob, "agent")); const char *agent = ast_json_string_get(ast_json_object_get(obj->blob, "agent"));
struct ast_manager_event_blob *ev;
channel_string = ast_manager_build_channel_state_string(obj->snapshot); channel_string = ast_manager_build_channel_state_string(obj->snapshot);
if (!channel_string) { if (!channel_string) {
return NULL; return NULL;
} }
return ast_manager_event_blob_create(EVENT_FLAG_AGENT, "AgentLogin", ev = ast_manager_event_blob_create(EVENT_FLAG_AGENT, "AgentLogin",
"%s" "%s"
"Agent: %s\r\n", "Agent: %s\r\n",
ast_str_buffer(channel_string), agent); ast_str_buffer(channel_string), agent);
ast_free(channel_string);
return ev;
} }
static struct ast_manager_event_blob *agent_logoff_to_ami(struct stasis_message *msg) static struct ast_manager_event_blob *agent_logoff_to_ami(struct stasis_message *msg)
{ {
RAII_VAR(struct ast_str *, channel_string, NULL, ast_free); struct ast_str *channel_string;
struct ast_channel_blob *obj = stasis_message_data(msg); struct ast_channel_blob *obj = stasis_message_data(msg);
const char *agent = ast_json_string_get(ast_json_object_get(obj->blob, "agent")); const char *agent = ast_json_string_get(ast_json_object_get(obj->blob, "agent"));
long logintime = ast_json_integer_get(ast_json_object_get(obj->blob, "logintime")); long logintime = ast_json_integer_get(ast_json_object_get(obj->blob, "logintime"));
struct ast_manager_event_blob *ev;
channel_string = ast_manager_build_channel_state_string(obj->snapshot); channel_string = ast_manager_build_channel_state_string(obj->snapshot);
if (!channel_string) { if (!channel_string) {
return NULL; return NULL;
} }
return ast_manager_event_blob_create(EVENT_FLAG_AGENT, "AgentLogoff", ev = ast_manager_event_blob_create(EVENT_FLAG_AGENT, "AgentLogoff",
"%s" "%s"
"Agent: %s\r\n" "Agent: %s\r\n"
"Logintime: %ld\r\n", "Logintime: %ld\r\n",
ast_str_buffer(channel_string), agent, logintime); ast_str_buffer(channel_string), agent, logintime);
ast_free(channel_string);
return ev;
} }
void ast_publish_channel_state(struct ast_channel *chan) void ast_publish_channel_state(struct ast_channel *chan)
{ {
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup); struct ast_channel_snapshot *snapshot;
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup); struct stasis_message *message;
if (!ast_channel_snapshot_type()) { if (!ast_channel_snapshot_type()) {
return; return;
@ -879,12 +948,14 @@ void ast_publish_channel_state(struct ast_channel *chan)
} }
message = stasis_message_create(ast_channel_snapshot_type(), snapshot); message = stasis_message_create(ast_channel_snapshot_type(), snapshot);
ao2_ref(snapshot, -1);
if (!message) { if (!message) {
return; return;
} }
ast_assert(ast_channel_topic(chan) != NULL); ast_assert(ast_channel_topic(chan) != NULL);
stasis_publish(ast_channel_topic(chan), message); stasis_publish(ast_channel_topic(chan), message);
ao2_ref(message, -1);
} }
struct ast_json *ast_channel_snapshot_to_json( struct ast_json *ast_channel_snapshot_to_json(
@ -894,8 +965,9 @@ struct ast_json *ast_channel_snapshot_to_json(
struct ast_json *json_chan; struct ast_json *json_chan;
if (snapshot == NULL if (snapshot == NULL
|| (sanitize && sanitize->channel_snapshot || (sanitize
&& sanitize->channel_snapshot(snapshot))) { && sanitize->channel_snapshot
&& sanitize->channel_snapshot(snapshot))) {
return NULL; return NULL;
} }
@ -969,7 +1041,7 @@ static struct ast_json *channel_blob_to_json(
const char *type, const char *type,
const struct stasis_message_sanitizer *sanitize) const struct stasis_message_sanitizer *sanitize)
{ {
RAII_VAR(struct ast_json *, out, NULL, ast_json_unref); struct ast_json *to_json;
struct ast_channel_blob *channel_blob = stasis_message_data(message); struct ast_channel_blob *channel_blob = stasis_message_data(message);
struct ast_json *blob = channel_blob->blob; struct ast_json *blob = channel_blob->blob;
struct ast_channel_snapshot *snapshot = channel_blob->snapshot; struct ast_channel_snapshot *snapshot = channel_blob->snapshot;
@ -977,36 +1049,38 @@ static struct ast_json *channel_blob_to_json(
int res = 0; int res = 0;
if (blob == NULL || ast_json_is_null(blob)) { if (blob == NULL || ast_json_is_null(blob)) {
out = ast_json_object_create(); to_json = ast_json_object_create();
} else { } else {
/* blobs are immutable, so shallow copies are fine */ /* blobs are immutable, so shallow copies are fine */
out = ast_json_copy(blob); to_json = ast_json_copy(blob);
} }
if (!to_json) {
if (!out) {
return NULL; return NULL;
} }
res |= ast_json_object_set(out, "type", ast_json_string_create(type)); res |= ast_json_object_set(to_json, "type", ast_json_string_create(type));
res |= ast_json_object_set(out, "timestamp", res |= ast_json_object_set(to_json, "timestamp",
ast_json_timeval(*tv, NULL)); ast_json_timeval(*tv, NULL));
/* For global channel messages, the snapshot is optional */ /* For global channel messages, the snapshot is optional */
if (snapshot) { if (snapshot) {
struct ast_json *json_channel = ast_channel_snapshot_to_json(snapshot, sanitize); struct ast_json *json_channel;
json_channel = ast_channel_snapshot_to_json(snapshot, sanitize);
if (!json_channel) { if (!json_channel) {
ast_json_unref(to_json);
return NULL; return NULL;
} }
res |= ast_json_object_set(out, "channel", json_channel); res |= ast_json_object_set(to_json, "channel", json_channel);
} }
if (res != 0) { if (res != 0) {
ast_json_unref(to_json);
return NULL; return NULL;
} }
return ast_json_ref(out); return to_json;
} }
static struct ast_json *dtmf_end_to_json( static struct ast_json *dtmf_end_to_json(

Write Preview
Loading…
Cancel
Save