/*!
* \internal
* \brief Build the NOTIFY request adding content or header info.
*/
static void build_notify(pjsip_tx_data *tdata, const char *name, const char *value,
struct ast_str **content_type, struct ast_str **content)
{
if (not_allowed(name)) {
ast_log(LOG_WARNING, "Cannot specify %s header, "
"ignoring\n", name);
return;
}
if (!strcasecmp(name, "Content-type")) {
if (!(*content_type)) {
*content_type = ast_str_create(CONTENT_TYPE_SIZE);
}
ast_str_set(content_type, 0,"%s", value);
} else if (!strcasecmp(name, "Content")) {
if (!(*content)) {
*content = ast_str_create(CONTENT_SIZE);
}
if (ast_str_strlen(*content)) {
ast_str_append(content, 0, "\r\n");
}
ast_str_append(content, 0, "%s", value);
} else {
ast_sip_add_header(tdata, name, value);
}
}
static enum ast_test_result_state test_chan_variable(struct ast_test *test,
struct ast_channel *c, const char *varname)
{
const char *values[] = { "one", "three", "reallylongdinosaursoundingthingwithwordsinit" };
int i, okay = 1;
char workspace[4096];
struct ast_str *str = ast_str_create(16);
struct ast_str *var = ast_str_create(16);
ast_str_set(&var, 0, "${%s}", varname);
for (i = 0; i < ARRAY_LEN(values); i++) {
pbx_builtin_setvar_helper(c, varname, values[i]);
ast_str_substitute_variables(&str, 0, c, ast_str_buffer(var));
pbx_substitute_variables_helper(c, ast_str_buffer(var), workspace, sizeof(workspace));
ast_test_status_update(test, "Testing '%s' . . . . . %s\n",
ast_str_buffer(var), okay ? "passed" : "FAILED");
if (strcmp(values[i], ast_str_buffer(str)) != 0 || strcmp(values[i], workspace) != 0) {
ast_test_status_update(test, "%s != %s != %s\n",
values[i], ast_str_buffer(str), workspace);
okay = 0;
}
}
ast_free(str);
ast_free(var);
return okay ? AST_TEST_PASS : AST_TEST_FAIL;
}
void ast_ari_asterisk_get_global_var(struct ast_variable *headers,
struct ast_ari_asterisk_get_global_var_args *args,
struct ast_ari_response *response)
{
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
RAII_VAR(struct ast_str *, tmp, NULL, ast_free);
const char *value;
ast_assert(response != NULL);
if (ast_strlen_zero(args->variable)) {
ast_ari_response_error(
response, 400, "Bad Request",
"Variable name is required");
return;
}
tmp = ast_str_create(32);
if (!tmp) {
ast_ari_response_alloc_failed(response);
return;
}
value = ast_str_retrieve_variable(&tmp, 0, NULL, NULL, args->variable);
if (!(json = ast_json_pack("{s: s}", "value", S_OR(value, "")))) {
ast_ari_response_alloc_failed(response);
return;
}
ast_ari_response_ok(response, ast_json_ref(json));
}
static void aoc_display_decoded_debug(const struct ast_aoc_decoded *decoded, int decoding, struct ast_channel *chan)
{
struct ast_str *msg;
if (!decoded || !(msg = ast_str_create(1024))) {
return;
}
if (decoding) {
ast_str_append(&msg, 0, "---- DECODED AOC MSG ----\r\n");
} else {
ast_str_append(&msg, 0, "---- ENCODED AOC MSG ----\r\n");
}
if (chan) {
ast_str_append(&msg, 0, "CHANNEL: %s\r\n", ast_channel_name(chan));
}
if (ast_aoc_decoded2str(decoded, &msg)) {
ast_free(msg);
return;
}
ast_verb(1, "%s\r\n", ast_str_buffer(msg));
ast_free(msg);
}
static enum ast_test_result_state test_chan_string(struct ast_test *test,
struct ast_channel *c, char *cfield, size_t cfieldsize,
const char *expression)
{
const char *values[] = { "one", "three", "reallylongdinosaursoundingthingwithwordsinit" };
int i, okay = 1;
char workspace[4096];
struct ast_str *str = ast_str_create(16);
for (i = 0; i < ARRAY_LEN(values); i++) {
ast_copy_string(cfield, values[i], cfieldsize);
ast_str_substitute_variables(&str, 0, c, expression);
pbx_substitute_variables_helper(c, expression, workspace, sizeof(workspace));
ast_test_status_update(test, "Testing '%s' . . . . . %s\n",
expression, okay ? "passed" : "FAILED");
if (strcmp(cfield, ast_str_buffer(str)) != 0 || strcmp(cfield, workspace) != 0) {
ast_test_status_update(test, "%s != %s != %s\n", cfield, ast_str_buffer(str), workspace);
okay = 0;
}
}
ast_free(str);
return okay ? AST_TEST_PASS : AST_TEST_FAIL;
}
static enum ast_test_result_state test_2way_function(struct ast_test *test,
struct ast_channel *c, const char *encode1, const char *encode2,
const char *decode1, const char *decode2)
{
struct ast_str *str = ast_str_create(16), *expression = ast_str_alloca(120);
int okay;
ast_str_set(&expression, 0, "%s%s%s", encode1, "foobarbaz", encode2);
ast_str_substitute_variables(&str, 0, c, ast_str_buffer(expression));
ast_str_set(&expression, 0, "%s%s%s", decode1, ast_str_buffer(str), decode2);
ast_str_substitute_variables(&str, 0, c, ast_str_buffer(expression));
okay = !strcmp(ast_str_buffer(str), "foobarbaz");
ast_test_status_update(test, "Testing '%s%s' and '%s%s' . . . . . %s\n",
encode1, encode2, decode1, decode2,
okay ? "passed" : "FAILED");
if (!okay) {
ast_test_status_update(test, " '%s' != 'foobarbaz'\n",
ast_str_buffer(str));
}
ast_free(str);
return okay ? AST_TEST_PASS : AST_TEST_FAIL;
}
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_channel_blob *obj = stasis_message_data(msg);
const char *variable =
ast_json_string_get(ast_json_object_get(obj->blob, "variable"));
const char *value =
ast_json_string_get(ast_json_object_get(obj->blob, "value"));
if (obj->snapshot) {
channel_event_string =
ast_manager_build_channel_state_string(obj->snapshot);
} else {
channel_event_string = ast_str_create(35);
ast_str_set(&channel_event_string, 0,
"Channel: none\r\n"
"Uniqueid: none\r\n");
}
if (!channel_event_string) {
return NULL;
}
return ast_manager_event_blob_create(EVENT_FLAG_DIALPLAN, "VarSet",
"%s"
"Variable: %s\r\n"
"Value: %s\r\n",
ast_str_buffer(channel_event_string), variable, value);
}
static int load_config_string(struct ast_config *cfg, const char *category, const char *variable, struct ast_str **field, const char *def)
{
struct unload_string *us;
const char *tmp;
if (!(us = ast_calloc(1, sizeof(*us)))) {
return -1;
}
if (!(*field = ast_str_create(16))) {
ast_free(us);
return -1;
}
tmp = ast_variable_retrieve(cfg, category, variable);
ast_str_set(field, 0, "%s", tmp ? tmp : def);
us->str = *field;
AST_LIST_LOCK(&unload_strings);
AST_LIST_INSERT_HEAD(&unload_strings, us, entry);
AST_LIST_UNLOCK(&unload_strings);
return 0;
}
static int tryexec_exec(struct ast_channel *chan, const char *data)
{
int res = 0;
char *s, *appname, *endargs;
struct ast_app *app;
struct ast_str *args = NULL;
if (ast_strlen_zero(data))
return 0;
s = ast_strdupa(data);
appname = strsep(&s, "(");
if (s) {
endargs = strrchr(s, ')');
if (endargs)
*endargs = '\0';
if ((args = ast_str_create(16))) {
ast_str_substitute_variables(&args, 0, chan, s);
}
}
if (appname) {
app = pbx_findapp(appname);
if (app) {
res = pbx_exec(chan, app, args ? ast_str_buffer(args) : NULL);
pbx_builtin_setvar_helper(chan, "TRYSTATUS", res ? "FAILED" : "SUCCESS");
} else {
ast_log(LOG_WARNING, "Could not find application (%s)\n", appname);
pbx_builtin_setvar_helper(chan, "TRYSTATUS", "NOAPP");
}
}
ast_free(args);
return 0;
}
struct ast_str *ast_manager_build_bridge_state_string_prefix(
const struct ast_bridge_snapshot *snapshot,
const char *prefix)
{
struct ast_str *out = ast_str_create(128);
int res;
if (!out) {
return NULL;
}
res = ast_str_set(&out, 0,
"%sBridgeUniqueid: %s\r\n"
"%sBridgeType: %s\r\n"
"%sBridgeTechnology: %s\r\n"
"%sBridgeCreator: %s\r\n"
"%sBridgeName: %s\r\n"
"%sBridgeNumChannels: %u\r\n",
prefix, snapshot->uniqueid,
prefix, snapshot->subclass,
prefix, snapshot->technology,
prefix, ast_strlen_zero(snapshot->creator) ? "<unknown>": snapshot->creator,
prefix, ast_strlen_zero(snapshot->name) ? "<unknown>": snapshot->name,
prefix, snapshot->num_channels);
if (!res) {
ast_free(out);
return NULL;
}
return out;
}
/*!
* \internal
* \brief Delete the requested mailboxes.
* \since 12.1.0
*
* \param s AMI session.
* \param m AMI message.
*
* \retval 0 to keep AMI connection.
* \retval -1 to disconnect AMI connection.
*/
static int mwi_mailbox_delete(struct mansession *s, const struct message *m)
{
const char *mailbox_id = astman_get_header(m, "Mailbox");
if (ast_strlen_zero(mailbox_id)) {
astman_send_error(s, m, "Missing mailbox parameter in request");
return 0;
}
if (*mailbox_id == '/') {
struct ast_str *regex_string;
regex_string = ast_str_create(strlen(mailbox_id) + 1);
if (!regex_string) {
astman_send_error(s, m, "Memory Allocation Failure");
return 0;
}
/* Make "/regex/" into "regex" */
if (ast_regex_string_to_regex_pattern(mailbox_id, ®ex_string) != 0) {
astman_send_error_va(s, m, "Mailbox regex format invalid in: %s", mailbox_id);
ast_free(regex_string);
return 0;
}
ast_mwi_mailbox_delete_by_regex(ast_str_buffer(regex_string));
ast_free(regex_string);
} else {
ast_mwi_mailbox_delete(mailbox_id);
}
astman_send_ack(s, m, NULL);
return 0;
}
void *ast_tcptls_server_root(void *data)
{
struct ast_tcptls_session_args *desc = data;
int fd;
struct ast_sockaddr addr;
struct ast_tcptls_session_instance *tcptls_session;
pthread_t launched;
for (;;) {
int i, flags;
if (desc->periodic_fn) {
desc->periodic_fn(desc);
}
i = ast_wait_for_input(desc->accept_fd, desc->poll_timeout);
if (i <= 0) {
continue;
}
fd = ast_accept(desc->accept_fd, &addr);
if (fd < 0) {
if ((errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINTR) && (errno != ECONNABORTED)) {
ast_log(LOG_ERROR, "Accept failed: %s\n", strerror(errno));
break;
}
continue;
}
tcptls_session = ao2_alloc(sizeof(*tcptls_session), session_instance_destructor);
if (!tcptls_session) {
ast_log(LOG_WARNING, "No memory for new session: %s\n", strerror(errno));
if (close(fd)) {
ast_log(LOG_ERROR, "close() failed: %s\n", strerror(errno));
}
continue;
}
tcptls_session->overflow_buf = ast_str_create(128);
flags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
tcptls_session->stream = ast_iostream_from_fd(&fd);
if (!tcptls_session->stream) {
ast_log(LOG_WARNING, "No memory for new session iostream\n");
continue;
}
tcptls_session->parent = desc;
ast_sockaddr_copy(&tcptls_session->remote_address, &addr);
tcptls_session->client = 0;
/* This thread is now the only place that controls the single ref to tcptls_session */
if (ast_pthread_create_detached_background(&launched, NULL, handle_tcptls_connection, tcptls_session)) {
ast_log(LOG_ERROR, "Unable to launch helper thread: %s\n", strerror(errno));
ast_tcptls_close_session_file(tcptls_session);
ao2_ref(tcptls_session, -1);
}
}
return NULL;
}
/*! \brief Function which adds ICE attributes to a media stream */
static void add_ice_to_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media, pj_pool_t *pool, pjmedia_sdp_media *media)
{
struct ast_rtp_engine_ice *ice;
struct ao2_container *candidates;
const char *username, *password;
pj_str_t stmp;
pjmedia_sdp_attr *attr;
struct ao2_iterator it_candidates;
struct ast_rtp_engine_ice_candidate *candidate;
if (!session->endpoint->media.rtp.ice_support || !(ice = ast_rtp_instance_get_ice(session_media->rtp)) ||
!(candidates = ice->get_local_candidates(session_media->rtp))) {
return;
}
if ((username = ice->get_ufrag(session_media->rtp))) {
attr = pjmedia_sdp_attr_create(pool, "ice-ufrag", pj_cstr(&stmp, username));
media->attr[media->attr_count++] = attr;
}
if ((password = ice->get_password(session_media->rtp))) {
attr = pjmedia_sdp_attr_create(pool, "ice-pwd", pj_cstr(&stmp, password));
media->attr[media->attr_count++] = attr;
}
it_candidates = ao2_iterator_init(candidates, 0);
for (; (candidate = ao2_iterator_next(&it_candidates)); ao2_ref(candidate, -1)) {
struct ast_str *attr_candidate = ast_str_create(128);
ast_str_set(&attr_candidate, -1, "%s %u %s %d %s ", candidate->foundation, candidate->id, candidate->transport,
candidate->priority, ast_sockaddr_stringify_addr_remote(&candidate->address));
ast_str_append(&attr_candidate, -1, "%s typ ", ast_sockaddr_stringify_port(&candidate->address));
switch (candidate->type) {
case AST_RTP_ICE_CANDIDATE_TYPE_HOST:
ast_str_append(&attr_candidate, -1, "host");
break;
case AST_RTP_ICE_CANDIDATE_TYPE_SRFLX:
ast_str_append(&attr_candidate, -1, "srflx");
break;
case AST_RTP_ICE_CANDIDATE_TYPE_RELAYED:
ast_str_append(&attr_candidate, -1, "relay");
break;
}
if (!ast_sockaddr_isnull(&candidate->relay_address)) {
ast_str_append(&attr_candidate, -1, " raddr %s rport", ast_sockaddr_stringify_addr_remote(&candidate->relay_address));
ast_str_append(&attr_candidate, -1, " %s", ast_sockaddr_stringify_port(&candidate->relay_address));
}
attr = pjmedia_sdp_attr_create(pool, "candidate", pj_cstr(&stmp, ast_str_buffer(attr_candidate)));
media->attr[media->attr_count++] = attr;
ast_free(attr_candidate);
}
ao2_iterator_destroy(&it_candidates);
ao2_ref(candidates, -1);
}
static int __ast_http_post_load(int reload)
{
struct ast_config *cfg;
struct ast_variable *v;
struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
cfg = ast_config_load2("http.conf", "http", config_flags);
if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
return 0;
}
if (reload) {
ast_http_uri_unlink_all_with_key(__FILE__);
}
if (cfg) {
for (v = ast_variable_browse(cfg, "general"); v; v = v->next) {
if (!strcasecmp(v->name, "prefix")) {
ast_copy_string(prefix, v->value, sizeof(prefix));
if (prefix[strlen(prefix)] == '/') {
prefix[strlen(prefix)] = '\0';
}
}
}
for (v = ast_variable_browse(cfg, "post_mappings"); v; v = v->next) {
struct ast_http_uri *urih;
struct ast_str *ds;
if (!(urih = ast_calloc(sizeof(*urih), 1))) {
ast_config_destroy(cfg);
return -1;
}
if (!(ds = ast_str_create(32))) {
ast_free(urih);
ast_config_destroy(cfg);
return -1;
}
urih->description = ast_strdup("HTTP POST mapping");
urih->uri = ast_strdup(v->name);
ast_str_set(&ds, 0, "%s", v->value);
urih->data = ds;
urih->has_subtree = 0;
urih->supports_get = 0;
urih->supports_post = 1;
urih->callback = http_post_callback;
urih->key = __FILE__;
urih->mallocd = urih->dmallocd = 1;
ast_http_uri_link(urih);
}
ast_config_destroy(cfg);
}
return 0;
}
struct ast_str *ast_channel_dialed_causes_channels(const struct ast_channel *chan)
{
struct ast_str *chanlist = ast_str_create(128);
if (!chanlist) {
return NULL;
}
ao2_callback(chan->dialed_causes, 0, collect_names_cb, &chanlist);
return chanlist;
}
/*!
* \brief Execute an DELETE query
* \param url
* \param unused
* \param keyfield where clause field
* \param lookup value of field for where clause
* \param ap list containing one or more field/value set(s)
*
* Delete a row from a database table, prepare the sql statement using keyfield and lookup
* control the number of records to change. Additional params to match rows are stored in ap list.
* Sub-in the values to the prepared statement and execute it.
*
* \retval number of rows affected
* \retval -1 on failure
*/
static int destroy_curl(const char *url, const char *unused, const char *keyfield, const char *lookup, va_list ap)
{
struct ast_str *query;
char buf1[200], buf2[200];
const char *newparam, *newval;
char *stringp;
int i, rowcount = -1;
const int EncodeSpecialChars = 1, bufsize = 100;
char *buffer;
if (!ast_custom_function_find("CURL")) {
ast_log(LOG_ERROR, "func_curl.so must be loaded in order to use res_config_curl.so!!\n");
return -1;
}
if (!(query = ast_str_create(1000)))
return -1;
if (!(buffer = ast_malloc(bufsize))) {
ast_free(query);
return -1;
}
ast_uri_encode(keyfield, buf1, sizeof(buf1), EncodeSpecialChars);
ast_uri_encode(lookup, buf2, sizeof(buf2), EncodeSpecialChars);
ast_str_set(&query, 0, "${CURL(%s/destroy,%s=%s&", url, buf1, buf2);
for (i = 0; (newparam = va_arg(ap, const char *)); i++) {
newval = va_arg(ap, const char *);
ast_uri_encode(newparam, buf1, sizeof(buf1), EncodeSpecialChars);
ast_uri_encode(newval, buf2, sizeof(buf2), EncodeSpecialChars);
ast_str_append(&query, 0, "%s%s=%s", i > 0 ? "&" : "", buf1, buf2);
}
va_end(ap);
ast_str_append(&query, 0, ")}");
pbx_substitute_variables_helper(NULL, query->str, buffer, bufsize);
/* Line oriented output */
stringp = buffer;
while (*stringp <= ' ')
stringp++;
sscanf(stringp, "%d", &rowcount);
ast_free(buffer);
ast_free(query);
if (rowcount >= 0)
return (int)rowcount;
return -1;
}
static void *transport_websocket_init(const struct ast_socket_io_session *session)
{
struct ast_websocket *ws;
struct ast_str *uri = ast_str_create(128);
enum ast_websocket_result result;
struct ast_uri *session_uri = ast_socket_io_uri(session);
struct ast_tls_config *tls_cfg = NULL;
if (!uri) {
ast_log(LOG_ERROR, "Unable to allocate websocket uri\n");
return NULL;
}
ast_str_set(&uri, 0, "%s://%s:%s/socket.io/%s/websocket/%s",
ast_uri_is_secure(session_uri) ? "wss" : "ws",
ast_uri_host(session_uri), ast_uri_port(session_uri),
SOCKET_IO_VERSION, ast_socket_io_id(session));
if (!ast_strlen_zero(ast_uri_query(session_uri))) {
ast_str_append(&uri, 0, "?%s", ast_uri_query(session_uri));
}
if (ast_uri_is_secure(session_uri)) {
/* The websocket client expects a copy of the TLS configuration so provide it */
tls_cfg = ast_calloc(1, sizeof(*tls_cfg));
ast_set_flag(&tls_cfg->flags, AST_SSL_DONT_VERIFY_SERVER);
}
ws = ast_websocket_client_create(
ast_str_buffer(uri), "socket.io",
tls_cfg, &result);
ast_free(uri);
if (ws) {
struct protoent *p;
p = getprotobyname("tcp");
if (p) {
int arg = 1;
if (setsockopt(ast_websocket_fd(ws), p->p_proto, TCP_NODELAY, (char *) &arg, sizeof(arg) ) < 0) {
ast_log(LOG_WARNING, "Failed to set TCP_NODELAY on HTTP connection: %s\n", strerror(errno));
ast_log(LOG_WARNING, "Some HTTP requests may be slow to respond.\n");
}
}
ast_websocket_set_nonblock(ws);
}
return ws;
}
static void send_eivr_event(FILE *handle, const char event, const char *data,
const struct ast_channel *chan)
{
struct ast_str *tmp = ast_str_create(12);
ast_str_append(&tmp, 0, "%c,%10d", event, (int)time(NULL));
if (data) {
ast_str_append(&tmp, 0, ",%s", data);
}
fprintf(handle, "%s\n", ast_str_buffer(tmp));
ast_debug(1, "sent '%s'\n", ast_str_buffer(tmp));
ast_free(tmp);
}
static struct ast_sip_aor *find_aor(struct ast_sip_endpoint *endpoint, pjsip_uri *uri)
{
char *configured_aors, *aor_name;
pjsip_sip_uri *sip_uri;
char *domain_name;
RAII_VAR(struct ast_str *, id, NULL, ast_free);
if (ast_strlen_zero(endpoint->aors)) {
return NULL;
}
sip_uri = pjsip_uri_get_uri(uri);
domain_name = ast_alloca(sip_uri->host.slen + 1);
ast_copy_pj_str(domain_name, &sip_uri->host, sip_uri->host.slen + 1);
configured_aors = ast_strdupa(endpoint->aors);
/* Iterate the configured AORs to see if the user or the user+domain match */
while ((aor_name = strsep(&configured_aors, ","))) {
struct ast_sip_domain_alias *alias = NULL;
if (!pj_strcmp2(&sip_uri->user, aor_name)) {
break;
}
if (!id && !(id = ast_str_create(sip_uri->user.slen + sip_uri->host.slen + 2))) {
return NULL;
}
ast_str_set(&id, 0, "%.*s@", (int)sip_uri->user.slen, sip_uri->user.ptr);
if ((alias = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "domain_alias", domain_name))) {
ast_str_append(&id, 0, "%s", alias->domain);
ao2_cleanup(alias);
} else {
ast_str_append(&id, 0, "%s", domain_name);
}
if (!strcmp(aor_name, ast_str_buffer(id))) {
ast_free(id);
break;
}
}
if (ast_strlen_zero(aor_name)) {
return NULL;
}
return ast_sip_location_retrieve_aor(aor_name);
}
static void *mwi_allocate_body(void *data)
{
struct ast_str **mwi_str;
mwi_str = ast_malloc(sizeof(*mwi_str));
if (!mwi_str) {
return NULL;
}
*mwi_str = ast_str_create(128);
if (!*mwi_str) {
ast_free(mwi_str);
return NULL;
}
return mwi_str;
}
/*! \internal \brief convert multi object blob to ami string */
static struct ast_str *multi_object_blob_to_ami(void *obj)
{
struct ast_str *ami_str=ast_str_create(1024);
struct ast_str *ami_snapshot;
const struct ast_multi_object_blob *multi = obj;
enum stasis_user_multi_object_snapshot_type type;
int i;
if (!ami_str) {
return NULL;
}
if (!multi) {
ast_free(ami_str);
return NULL;
}
for (type = 0; type < STASIS_UMOS_MAX; ++type) {
for (i = 0; i < AST_VECTOR_SIZE(&multi->snapshots[type]); ++i) {
char *name = "";
void *snapshot = AST_VECTOR_GET(&multi->snapshots[type], i);
ami_snapshot = NULL;
if (i > 0) {
ast_asprintf(&name, "%d", i + 1);
}
switch (type) {
case STASIS_UMOS_CHANNEL:
ami_snapshot = ast_manager_build_channel_state_string_prefix(snapshot, name);
break;
case STASIS_UMOS_BRIDGE:
ami_snapshot = ast_manager_build_bridge_state_string_prefix(snapshot, name);
break;
case STASIS_UMOS_ENDPOINT:
/* currently not sending endpoint snapshots to AMI */
break;
}
if (ami_snapshot) {
ast_str_append(&ami_str, 0, "%s", ast_str_buffer(ami_snapshot));
ast_free(ami_snapshot);
}
}
}
return ami_str;
}
static void send_eivr_event(struct ast_iostream *stream, const char event, const char *data,
const struct ast_channel *chan)
{
struct ast_str *tmp = ast_str_create(12);
ast_str_append(&tmp, 0, "%c,%10d", event, (int)time(NULL));
if (data) {
ast_str_append(&tmp, 0, ",%s", data);
}
ast_str_append(&tmp, 0, "\n");
ast_iostream_write(stream, ast_str_buffer(tmp), strlen(ast_str_buffer(tmp)));
ast_str_truncate(tmp, -1);
ast_debug(1, "sent '%s'", ast_str_buffer(tmp));
ast_free(tmp);
}
static int pgsql_reconnect(const char *database)
{
char my_database[50];
ast_copy_string(my_database, S_OR(database, dbname), sizeof(my_database));
/* mutex lock should have been locked before calling this function. */
if (pgsqlConn && PQstatus(pgsqlConn) != CONNECTION_OK) {
PQfinish(pgsqlConn);
pgsqlConn = NULL;
}
/* DB password can legitimately be 0-length */
if ((!pgsqlConn) && (!ast_strlen_zero(dbhost) || !ast_strlen_zero(dbsock)) && !ast_strlen_zero(dbuser) && !ast_strlen_zero(my_database)) {
struct ast_str *connInfo = ast_str_create(32);
ast_str_set(&connInfo, 0, "host=%s port=%d dbname=%s user=%s",
dbhost, dbport, my_database, dbuser);
if (!ast_strlen_zero(dbpass))
ast_str_append(&connInfo, 0, " password=%s", dbpass);
ast_debug(1, "%u connInfo=%s\n", (unsigned int)connInfo->len, connInfo->str);
pgsqlConn = PQconnectdb(connInfo->str);
ast_debug(1, "%u connInfo=%s\n", (unsigned int)connInfo->len, connInfo->str);
ast_free(connInfo);
connInfo = NULL;
ast_debug(1, "pgsqlConn=%p\n", pgsqlConn);
if (pgsqlConn && PQstatus(pgsqlConn) == CONNECTION_OK) {
ast_debug(1, "PostgreSQL RealTime: Successfully connected to database.\n");
connect_time = time(NULL);
return 1;
} else {
ast_log(LOG_ERROR,
"PostgreSQL RealTime: Failed to connect database %s on %s: %s\n",
dbname, dbhost, PQresultErrorMessage(NULL));
return 0;
}
} else {
ast_debug(1, "PostgreSQL RealTime: One or more of the parameters in the config does not pass our validity checks.\n");
return 1;
}
}
/*! \brief Builds a manager string based on the contents of a parked call payload */
static struct ast_str *manager_build_parked_call_string(const struct ast_parked_call_payload *payload)
{
struct ast_str *out = ast_str_create(1024);
RAII_VAR(struct ast_str *, parkee_string, NULL, ast_free);
RAII_VAR(struct ast_str *, retriever_string, NULL, ast_free);
if (!out) {
return NULL;
}
parkee_string = ast_manager_build_channel_state_string_prefix(payload->parkee, "Parkee");
if (!parkee_string) {
ast_free(out);
return NULL;
}
if (payload->retriever) {
retriever_string = ast_manager_build_channel_state_string_prefix(payload->retriever, "Retriever");
if (!retriever_string) {
ast_free(out);
return NULL;
}
}
ast_str_set(&out, 0,
"%s" /* parkee channel state */
"%s" /* retriever channel state (when available) */
"ParkerDialString: %s\r\n"
"Parkinglot: %s\r\n"
"ParkingSpace: %u\r\n"
"ParkingTimeout: %lu\r\n"
"ParkingDuration: %lu\r\n",
ast_str_buffer(parkee_string),
retriever_string ? ast_str_buffer(retriever_string) : "",
payload->parker_dial_string,
payload->parkinglot,
payload->parkingspace,
payload->timeout,
payload->duration);
return out;
}
struct ast_str *ast_manager_build_bridge_state_string_prefix(
const struct ast_bridge_snapshot *snapshot,
const char *prefix)
{
struct ast_str *out = ast_str_create(128);
int res;
if (!out) {
return NULL;
}
res = ast_str_set(&out, 0,
"%sBridgeUniqueid: %s\r\n"
"%sBridgeType: %s\r\n"
"%sBridgeTechnology: %s\r\n"
"%sBridgeCreator: %s\r\n"
"%sBridgeName: %s\r\n"
"%sBridgeNumChannels: %u\r\n"
"%sBridgeVideoSourceMode: %s\r\n",
prefix, snapshot->uniqueid,
prefix, snapshot->subclass,
prefix, snapshot->technology,
prefix, ast_strlen_zero(snapshot->creator) ? "<unknown>": snapshot->creator,
prefix, ast_strlen_zero(snapshot->name) ? "<unknown>": snapshot->name,
prefix, snapshot->num_channels,
prefix, ast_bridge_video_mode_to_string(snapshot->video_mode));
if (!res) {
ast_free(out);
return NULL;
}
if (snapshot->video_mode != AST_BRIDGE_VIDEO_MODE_NONE
&& !ast_strlen_zero(snapshot->video_source_id)) {
res = ast_str_append(&out, 0, "%sBridgeVideoSource: %s\r\n",
prefix, snapshot->video_source_id);
if (!res) {
ast_free(out);
return NULL;
}
}
return out;
}
static int contacts_to_str(const void *obj, const intptr_t *args, char **buf)
{
const struct ast_sip_aor *aor = obj;
struct ast_str *str;
str = ast_str_create(MAX_OBJECT_FIELD);
if (!str) {
*buf = NULL;
return -1;
}
ast_sip_for_each_contact(aor, ast_sip_contact_to_str, &str);
ast_str_truncate(str, -1);
*buf = ast_strdup(ast_str_buffer(str));
ast_free(str);
return *buf ? 0 : -1;
}
static int load_column_config(const char *tmp)
{
char *col = NULL;
char *cols = NULL, *save = NULL;
char *escaped = NULL;
struct ast_str *column_string = NULL;
if (ast_strlen_zero(tmp)) {
ast_log(LOG_WARNING, "Column names not specified. Module not loaded.\n");
return -1;
}
if (!(column_string = ast_str_create(1024))) {
ast_log(LOG_ERROR, "Out of memory creating temporary buffer for column list for table '%s.'\n", table);
return -1;
}
if (!(save = cols = ast_strdup(tmp))) {
ast_log(LOG_ERROR, "Out of memory creating temporary buffer for column list for table '%s.'\n", table);
ast_free(column_string);
return -1;
}
while ((col = strsep(&cols, ","))) {
col = ast_strip(col);
escaped = sqlite3_mprintf("%q", col);
if (!escaped) {
ast_log(LOG_ERROR, "Out of memory creating entry for column '%s' in table '%s.'\n", col, table);
ast_free(column_string);
ast_free(save);
return -1;
}
ast_str_append(&column_string, 0, "%s%s", ast_str_strlen(column_string) ? "," : "", escaped);
sqlite3_free(escaped);
}
if (!(columns = ast_strdup(ast_str_buffer(column_string)))) {
ast_log(LOG_ERROR, "Out of memory copying columns string for table '%s.'\n", table);
ast_free(column_string);
ast_free(save);
return -1;
}
ast_free(column_string);
ast_free(save);
return 0;
}
static enum ast_test_result_state test_chan_function(struct ast_test *test,
struct ast_channel *c, const char *expression)
{
int okay = 1;
char workspace[4096];
struct ast_str *str = ast_str_create(16);
ast_str_substitute_variables(&str, 0, c, expression);
pbx_substitute_variables_helper(c, expression, workspace, sizeof(workspace));
ast_test_status_update(test, "Testing '%s' . . . . . %s\n",
expression, okay ? "passed" : "FAILED");
if (strcmp(workspace, ast_str_buffer(str)) != 0) {
ast_test_status_update(test, "test_chan_function, expr: '%s' ... %s != %s\n",
expression, ast_str_buffer(str), workspace);
okay = 0;
}
ast_free(str);
return okay ? AST_TEST_PASS : AST_TEST_FAIL;
}
static void cipher_to_str(char **buf, const pj_ssl_cipher *ciphers, unsigned int cipher_num)
{
struct ast_str *str;
int idx;
str = ast_str_create(128);
if (!str) {
*buf = NULL;
return;
}
for (idx = 0; idx < cipher_num; ++idx) {
ast_str_append(&str, 0, "%s", pj_ssl_cipher_name(ciphers[idx]));
if (idx < cipher_num - 1) {
ast_str_append(&str, 0, ", ");
}
}
*buf = ast_strdup(ast_str_buffer(str));
ast_free(str);
}
static int build_path_data(pjsip_rx_data *rdata, struct ast_str **path_str)
{
pjsip_generic_string_hdr *path_hdr = pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &path_hdr_name, NULL);
if (!path_hdr) {
return 0;
}
*path_str = ast_str_create(64);
if (!path_str) {
return -1;
}
ast_str_set(path_str, 0, "%.*s", (int)path_hdr->hvalue.slen, path_hdr->hvalue.ptr);
while ((path_hdr = (pjsip_generic_string_hdr *) pjsip_msg_find_hdr_by_name(rdata->msg_info.msg, &path_hdr_name, path_hdr->next))) {
ast_str_append(path_str, 0, ",%.*s", (int)path_hdr->hvalue.slen, path_hdr->hvalue.ptr);
}
return 0;
}
