static void cpg_deliver_cb(cpg_handle_t handle, const struct cpg_name *group_name,
uint32_t nodeid, uint32_t pid, void *msg, size_t msg_len)
{
struct ast_event *event;
if (msg_len < ast_event_minimum_length()) {
ast_debug(1, "Ignoring event that's too small. %u < %u\n",
(unsigned int) msg_len,
(unsigned int) ast_event_minimum_length());
return;
}
if (!ast_eid_cmp(&ast_eid_default, ast_event_get_ie_raw(msg, AST_EVENT_IE_EID))) {
/* Don't feed events back in that originated locally. */
return;
}
ast_rwlock_rdlock(&event_types_lock);
if (!event_types[ast_event_get_type(msg)].subscribe) {
/* We are not configured to subscribe to these events. */
ast_rwlock_unlock(&event_types_lock);
return;
}
ast_rwlock_unlock(&event_types_lock);
if (!(event = ast_malloc(msg_len))) {
return;
}
memcpy(event, msg, msg_len);
ast_event_queue_and_cache(event);
}
static void cpg_confchg_cb(cpg_handle_t handle, const struct cpg_name *group_name,
const struct cpg_address *member_list, size_t member_list_entries,
const struct cpg_address *left_list, size_t left_list_entries,
const struct cpg_address *joined_list, size_t joined_list_entries)
{
unsigned int i;
/* If any new nodes have joined, dump our cache of events we are publishing
* that originated from this server. */
if (!joined_list_entries) {
return;
}
for (i = 0; i < ARRAY_LEN(event_types); i++) {
struct ast_event_sub *event_sub;
ast_rwlock_rdlock(&event_types_lock);
if (!event_types[i].publish) {
ast_rwlock_unlock(&event_types_lock);
continue;
}
ast_rwlock_unlock(&event_types_lock);
event_sub = ast_event_subscribe_new(i, ast_event_cb, NULL);
ast_event_sub_append_ie_raw(event_sub, AST_EVENT_IE_EID,
&ast_eid_default, sizeof(ast_eid_default));
ast_event_dump_cache(event_sub);
ast_event_sub_destroy(event_sub);
}
}
static void cpg_deliver_cb(cpg_handle_t handle, const struct cpg_name *group_name,
uint32_t nodeid, uint32_t pid, void *msg, size_t msg_len)
{
struct ast_event *event;
void (*publish_handler)(struct ast_event *) = NULL;
enum ast_event_type event_type;
if (msg_len < ast_event_minimum_length()) {
ast_debug(1, "Ignoring event that's too small. %u < %u\n",
(unsigned int) msg_len,
(unsigned int) ast_event_minimum_length());
return;
}
if (!ast_eid_cmp(&ast_eid_default, ast_event_get_ie_raw(msg, AST_EVENT_IE_EID))) {
/* Don't feed events back in that originated locally. */
return;
}
event_type = ast_event_get_type(msg);
if (event_type > AST_EVENT_TOTAL) {
/* Egads, we don't support this */
return;
}
ast_rwlock_rdlock(&event_types_lock);
publish_handler = event_types[event_type].publish_to_stasis;
if (!event_types[event_type].subscribe || !publish_handler) {
/* We are not configured to subscribe to these events or
we have no way to publish it internally. */
ast_rwlock_unlock(&event_types_lock);
return;
}
ast_rwlock_unlock(&event_types_lock);
if (!(event = ast_malloc(msg_len))) {
return;
}
memcpy(event, msg, msg_len);
if (event_type == AST_EVENT_PING) {
const struct ast_eid *eid;
char buf[128] = "";
eid = ast_event_get_ie_raw(event, AST_EVENT_IE_EID);
ast_eid_to_str(buf, sizeof(buf), (struct ast_eid *) eid);
ast_log(LOG_NOTICE, "Got event PING from server with EID: '%s'\n", buf);
}
ast_debug(5, "Publishing event %s (%u) to stasis\n",
ast_event_get_type_name(event), event_type);
publish_handler(event);
}
static void cpg_confchg_cb(cpg_handle_t handle, const struct cpg_name *group_name,
const struct cpg_address *member_list, size_t member_list_entries,
const struct cpg_address *left_list, size_t left_list_entries,
const struct cpg_address *joined_list, size_t joined_list_entries)
{
unsigned int i;
for (i = 0; i < left_list_entries; i++) {
const struct cpg_address *cpg_node = &left_list[i];
struct corosync_node* node;
node = ao2_find(nodes, &cpg_node->nodeid, OBJ_UNLINK | OBJ_SEARCH_KEY);
if (!node) {
continue;
}
publish_cluster_discovery_to_stasis_full(node, 0);
ao2_ref(node, -1);
}
/* If any new nodes have joined, dump our cache of events we are publishing
* that originated from this server. */
if (!joined_list_entries) {
return;
}
for (i = 0; i < ARRAY_LEN(event_types); i++) {
struct ao2_container *messages;
ast_rwlock_rdlock(&event_types_lock);
if (!event_types[i].publish) {
ast_rwlock_unlock(&event_types_lock);
continue;
}
if (!event_types[i].cache_fn || !event_types[i].message_type_fn) {
ast_rwlock_unlock(&event_types_lock);
continue;
}
messages = stasis_cache_dump_by_eid(event_types[i].cache_fn(),
event_types[i].message_type_fn(),
&ast_eid_default);
ast_rwlock_unlock(&event_types_lock);
ao2_callback(messages, OBJ_NODATA, dump_cache_cb, NULL);
ao2_t_ref(messages, -1, "Dispose of dumped cache");
}
}
/*! \internal
* \brief determine if a list of attribute key value pairs are set on a format
*/
static int format_isset_helper(const struct ast_format *format, va_list ap)
{
int res;
struct interface_ao2_wrapper *wrapper;
struct ast_format tmp = {
.id = format->id,
.fattr = { { 0, }, },
};
if (!(wrapper = find_interface(format))) {
return -1;
}
ast_rwlock_rdlock(&wrapper->wraplock);
if (!wrapper->interface ||
!wrapper->interface->format_attr_set ||
!wrapper->interface->format_attr_cmp) {
ast_rwlock_unlock(&wrapper->wraplock);
ao2_ref(wrapper, -1);
return -1;
}
/* if isset is present, use that function, else just build a new
* format and use the cmp function */
if (wrapper->interface->format_attr_isset) {
res = wrapper->interface->format_attr_isset(&format->fattr, ap);
} else {
wrapper->interface->format_attr_set(&tmp.fattr, ap);
/* use our tmp structure to tell if the attributes are set or not */
res = wrapper->interface->format_attr_cmp(&tmp.fattr, &format->fattr);
res = (res == AST_FORMAT_CMP_NOT_EQUAL) ? -1 : 0;
}
ast_rwlock_unlock(&wrapper->wraplock);
ao2_ref(wrapper, -1);
return res;
}
int ast_format_isset(const struct ast_format *format, ... )
{
va_list ap;
int res;
va_start(ap, format);
res = format_isset_helper(format, ap);
va_end(ap);
return res;
}
static int handle_show_http(int fd, int argc, char *argv[])
{
struct ast_http_uri *urih;
if (argc != 3)
return RESULT_SHOWUSAGE;
ast_cli(fd, "HTTP Server Status:\n");
ast_cli(fd, "Prefix: %s\n", prefix);
if (oldsin.sin_family)
ast_cli(fd, "Server Enabled and Bound to %s:%d\n\n",
ast_inet_ntoa(oldsin.sin_addr),
ntohs(oldsin.sin_port));
else
ast_cli(fd, "Server Disabled\n\n");
ast_cli(fd, "Enabled URI's:\n");
ast_rwlock_rdlock(&uris_lock);
urih = uris;
while(urih){
ast_cli(fd, "%s/%s%s => %s\n", prefix, urih->uri, (urih->has_subtree ? "/..." : "" ), urih->description);
urih = urih->next;
}
if (!uris)
ast_cli(fd, "None.\n");
ast_rwlock_unlock(&uris_lock);
return RESULT_SUCCESS;
}
int ast_adsi_channel_restore(struct ast_channel *chan)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->channel_restore) {
res = installed_funcs->channel_restore(chan);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_print(struct ast_channel *chan, char **lines, int *align, int voice)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->print) {
res = installed_funcs->print(chan, lines, align, voice);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_get_cpeinfo(struct ast_channel *chan, int *width, int *height, int *buttons, int voice)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->get_cpeinfo) {
res = installed_funcs->get_cpeinfo(chan, width, height, buttons, voice);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_end_download(struct ast_channel *chan)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->end_download) {
res = installed_funcs->end_download(chan);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_query_cpeinfo(unsigned char *buf)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->query_cpeinfo) {
res = installed_funcs->query_cpeinfo(buf);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_data_mode(unsigned char *buf)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->data_mode) {
res = installed_funcs->data_mode(buf);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_download_connect(unsigned char *buf, char *service, unsigned char *fdn, unsigned char *sec, int ver)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->download_connect) {
res = installed_funcs->download_connect(buf, service, fdn, sec, ver);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_transmit_message(struct ast_channel *chan, unsigned char *msg, int msglen, int msgtype)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->transmit_message) {
res = installed_funcs->transmit_message(chan, msg, msglen, msgtype);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_set_line(unsigned char *buf, int page, int line)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->set_line) {
res = installed_funcs->set_line(buf, page, line);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_load_soft_key(unsigned char *buf, int key, const char *llabel, const char *slabel, char *ret, int data)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->load_soft_key) {
res = installed_funcs->load_soft_key(buf, key, llabel, slabel, ret, data);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_display(unsigned char *buf, int page, int line, int just, int wrap, char *col1, char *col2)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->display) {
res = installed_funcs->display(buf, page, line, just, wrap, col1, col2);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_voice_mode(unsigned char *buf, int when)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->voice_mode) {
res = installed_funcs->voice_mode(buf, when);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_clear_screen(unsigned char *buf)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->clear_screen) {
res = installed_funcs->clear_screen(buf);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_load_session(struct ast_channel *chan, unsigned char *app, int ver, int data)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->load_session) {
res = installed_funcs->load_session(chan, app, ver, data);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_begin_download(struct ast_channel *chan, char *service, unsigned char *fdn, unsigned char *sec, int version)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->begin_download) {
res = installed_funcs->begin_download(chan, service, fdn, sec, version);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_unload_session(struct ast_channel *chan)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->unload_session) {
res = installed_funcs->unload_session(chan);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_connect_session(unsigned char *buf, unsigned char *fdn, int ver)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->connect_session) {
res = installed_funcs->connect_session(buf, fdn, ver);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_get_cpeid(struct ast_channel *chan, unsigned char *cpeid, int voice)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->get_cpeid) {
res = installed_funcs->get_cpeid(chan, cpeid, voice);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_input_format(unsigned char *buf, int num, int dir, int wrap, char *format1, char *format2)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->input_format) {
res = installed_funcs->input_format(buf, num, dir, wrap, format1, format2);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_set_keys(unsigned char *buf, unsigned char *keys)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->set_keys) {
res = installed_funcs->set_keys(buf, keys);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_download_disconnect(unsigned char *buf)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->download_disconnect) {
res = installed_funcs->download_disconnect(buf);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_input_control(unsigned char *buf, int page, int line, int display, int format, int just)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->input_control) {
res = installed_funcs->input_control(buf, page, line, display, format, just);
}
ast_rwlock_unlock(&func_lock);
return res;
}
int ast_adsi_read_encoded_dtmf(struct ast_channel *chan, unsigned char *buf, int maxlen)
{
int res = 0;
ast_rwlock_rdlock(&func_lock);
if (installed_funcs && installed_funcs->read_encoded_dtmf) {
res = installed_funcs->read_encoded_dtmf(chan, buf, maxlen);
}
ast_rwlock_unlock(&func_lock);
return res;
}
void ast_adsi_install_funcs(const struct adsi_funcs *funcs)
{
if (funcs && funcs->version < current_adsi_version) {
ast_log(LOG_WARNING, "Cannot install ADSI function pointers due to version mismatch."
"Ours: %d, Theirs: %u\n", current_adsi_version, funcs->version);
return;
}
ast_rwlock_wrlock(&func_lock);
installed_funcs = funcs;
ast_rwlock_unlock(&func_lock);
}
