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;
}
void ast_pbx_hangup_handler_push(struct ast_channel *chan, const char *handler)
{
struct ast_hangup_handler_list *handlers;
struct ast_hangup_handler *h_handler;
const char *expanded_handler;
if (ast_strlen_zero(handler)) {
return;
}
expanded_handler = ast_app_expand_sub_args(chan, handler);
if (!expanded_handler) {
return;
}
h_handler = ast_malloc(sizeof(*h_handler) + 1 + strlen(expanded_handler));
if (!h_handler) {
ast_free((char *) expanded_handler);
return;
}
strcpy(h_handler->args, expanded_handler);/* Safe */
ast_free((char *) expanded_handler);
ast_channel_lock(chan);
handlers = ast_channel_hangup_handlers(chan);
AST_LIST_INSERT_HEAD(handlers, h_handler, node);
publish_hangup_handler_message("push", chan, h_handler->args);
ast_channel_unlock(chan);
}
void ast_json_free(void *p)
{
struct json_mem *mem;
struct json_mem_list *free_list;
mem = to_json_mem(p);
if (!mem) {
return;
}
/* Since the unref is holding a lock in mem, we can't free it
* immediately. Store it off on a thread local list to be freed by
* ast_json_unref().
*/
free_list = json_free_list();
if (!free_list) {
ast_log(LOG_ERROR, "Error allocating free list\n");
ast_assert(0);
/* It's not ideal to free the memory immediately, but that's the
* best we can do if the threadlocal allocation fails */
json_mem_free(mem);
return;
}
AST_LIST_INSERT_HEAD(free_list, mem, list);
}
const char *sip_route_add(struct sip_route *route, const char *uri, size_t len, int inserthead)
{
struct sip_route_hop *hop;
if (!uri || len < 1 || uri[0] == '\0') {
return NULL;
}
/* Expand len to include null terminator */
len++;
/* ast_calloc is not needed because all fields are initialized in this block */
hop = ast_malloc(sizeof(struct sip_route_hop) + len);
if (!hop) {
return NULL;
}
ast_copy_string(hop->uri, uri, len);
if (inserthead) {
AST_LIST_INSERT_HEAD(&route->list, hop, list);
route->type = route_invalidated;
} else {
if (sip_route_empty(route)) {
route->type = route_invalidated;
}
AST_LIST_INSERT_TAIL(&route->list, hop, list);
hop->list.next = NULL;
}
return hop->uri;
}
static char *loopback_helper(char *buf, int buflen, const char *exten, const char *context, int priority, const char *data)
{
struct ast_var_t *newvariable;
struct varshead headp;
char tmp[80];
snprintf(tmp, sizeof(tmp), "%d", priority);
memset(buf, 0, buflen);
AST_LIST_HEAD_INIT_NOLOCK(&headp);
AST_LIST_INSERT_HEAD(&headp, ast_var_assign("EXTEN", exten), entries);
AST_LIST_INSERT_HEAD(&headp, ast_var_assign("CONTEXT", context), entries);
AST_LIST_INSERT_HEAD(&headp, ast_var_assign("PRIORITY", tmp), entries);
/* Substitute variables */
pbx_substitute_variables_varshead(&headp, data, buf, buflen);
/* free the list */
while ((newvariable = AST_LIST_REMOVE_HEAD(&headp, entries)))
ast_var_delete(newvariable);
return buf;
}
/*!
* \internal
* \brief Convert the allocated regions hash table to a list.
*
* \param list Fill list with the allocated regions.
*
* \details
* Take all allocated regions from the regions[] and put them
* into the list.
*
* \note reglock must be locked before calling.
*
* \note This function is destructive to the regions[] lists.
*
* \return Length of list created.
*/
static size_t mm_atexit_hash_list(struct region_list *list)
{
struct ast_region *reg;
size_t total_length;
int idx;
total_length = 0;
for (idx = 0; idx < ARRAY_LEN(regions); ++idx) {
while ((reg = regions[idx])) {
regions[idx] = AST_LIST_NEXT(reg, node);
AST_LIST_NEXT(reg, node) = NULL;
AST_LIST_INSERT_HEAD(list, reg, node);
++total_length;
}
}
return total_length;
}
/*! \brief
* the string is 'prefix:data' or prefix:fmt:data'
* with ':' being invalid in strings.
*/
static int do_say(say_args_t *a, const char *s, const char *options, int depth)
{
struct ast_variable *v;
char *lang, *x, *rule = NULL;
int ret = 0;
struct varshead head = { .first = NULL, .last = NULL };
struct ast_var_t *n;
ast_debug(2, "string <%s> depth <%d>\n", s, depth);
if (depth++ > 10) {
ast_log(LOG_WARNING, "recursion too deep, exiting\n");
return -1;
} else if (!say_cfg) {
ast_log(LOG_WARNING, "no say.conf, cannot spell '%s'\n", s);
return -1;
}
/* scan languages same as in file.c */
if (a->language == NULL)
a->language = "en"; /* default */
ast_debug(2, "try <%s> in <%s>\n", s, a->language);
lang = ast_strdupa(a->language);
for (;;) {
for (v = ast_variable_browse(say_cfg, lang); v ; v = v->next) {
if (ast_extension_match(v->name, s)) {
rule = ast_strdupa(v->value);
break;
}
}
if (rule)
break;
if ( (x = strchr(lang, '_')) )
*x = '\0'; /* try without suffix */
else if (strcmp(lang, "en"))
lang = "en"; /* last resort, try 'en' if not done yet */
else
break;
}
if (!rule)
return 0;
/* skip up to two prefixes to get the value */
if ( (x = strchr(s, ':')) )
s = x + 1;
if ( (x = strchr(s, ':')) )
s = x + 1;
ast_debug(2, "value is <%s>\n", s);
n = ast_var_assign("SAY", s);
if (!n) {
ast_log(LOG_ERROR, "Memory allocation error in do_say\n");
return -1;
}
AST_LIST_INSERT_HEAD(&head, n, entries);
/* scan the body, one piece at a time */
while ( !ret && (x = strsep(&rule, ",")) ) { /* exit on key */
char fn[128];
const char *p, *fmt, *data; /* format and data pointers */
/* prepare a decent file name */
x = ast_skip_blanks(x);
ast_trim_blanks(x);
/* replace variables */
pbx_substitute_variables_varshead(&head, x, fn, sizeof(fn));
ast_debug(2, "doing [%s]\n", fn);
/* locate prefix and data, if any */
fmt = strchr(fn, ':');
if (!fmt || fmt == fn) { /* regular filename */
ret = s_streamwait3(a, fn);
continue;
}
fmt++;
data = strchr(fmt, ':'); /* colon before data */
if (!data || data == fmt) { /* simple prefix-fmt */
ret = do_say(a, fn, options, depth);
continue;
}
/* prefix:fmt:data */
for (p = fmt; p < data && ret <= 0; p++) {
char fn2[sizeof(fn)];
if (*p == ' ' || *p == '\t') /* skip blanks */
continue;
if (*p == '\'') {/* file name - we trim them */
char *y;
strcpy(fn2, ast_skip_blanks(p+1)); /* make a full copy */
y = strchr(fn2, '\'');
if (!y) {
p = data; /* invalid. prepare to end */
break;
}
*y = '\0';
ast_trim_blanks(fn2);
p = strchr(p+1, '\'');
ret = s_streamwait3(a, fn2);
} else {
int l = fmt-fn;
strcpy(fn2, fn); /* copy everything */
/* after prefix, append the format */
fn2[l++] = *p;
strcpy(fn2 + l, data);
ret = do_say(a, fn2, options, depth);
}
if (ret) {
break;
}
}
}
ast_var_delete(n);
return ret;
}
struct ast_channel *ast_cel_fabricate_channel_from_event(const struct ast_event *event)
{
struct varshead *headp;
struct ast_var_t *newvariable;
char timebuf[30];
struct ast_channel *tchan;
struct ast_cel_event_record record = {
.version = AST_CEL_EVENT_RECORD_VERSION,
};
/* do not call ast_channel_alloc because this is not really a real channel */
if (!(tchan = ast_dummy_channel_alloc())) {
return NULL;
}
headp = &tchan->varshead;
/* first, get the variables from the event */
if (ast_cel_fill_record(event, &record)) {
ast_channel_release(tchan);
return NULL;
}
/* next, fill the channel with their data */
if ((newvariable = ast_var_assign("eventtype", record.event_name))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
if (ast_strlen_zero(cel_dateformat)) {
snprintf(timebuf, sizeof(timebuf), "%ld.%06ld", (long) record.event_time.tv_sec,
(long) record.event_time.tv_usec);
} else {
struct ast_tm tm;
ast_localtime(&record.event_time, &tm, NULL);
ast_strftime(timebuf, sizeof(timebuf), cel_dateformat, &tm);
}
if ((newvariable = ast_var_assign("eventtime", timebuf))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
if ((newvariable = ast_var_assign("eventextra", record.extra))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
tchan->caller.id.name.valid = 1;
tchan->caller.id.name.str = ast_strdup(record.caller_id_name);
tchan->caller.id.number.valid = 1;
tchan->caller.id.number.str = ast_strdup(record.caller_id_num);
tchan->caller.ani.number.valid = 1;
tchan->caller.ani.number.str = ast_strdup(record.caller_id_ani);
tchan->redirecting.from.number.valid = 1;
tchan->redirecting.from.number.str = ast_strdup(record.caller_id_rdnis);
tchan->dialed.number.str = ast_strdup(record.caller_id_dnid);
ast_copy_string(tchan->exten, record.extension, sizeof(tchan->exten));
ast_copy_string(tchan->context, record.context, sizeof(tchan->context));
ast_string_field_set(tchan, name, record.channel_name);
ast_string_field_set(tchan, uniqueid, record.unique_id);
ast_string_field_set(tchan, linkedid, record.linked_id);
ast_string_field_set(tchan, accountcode, record.account_code);
ast_string_field_set(tchan, peeraccount, record.peer_account);
ast_string_field_set(tchan, userfield, record.user_field);
pbx_builtin_setvar_helper(tchan, "BRIDGEPEER", record.peer);
tchan->appl = ast_strdup(record.application_name);
tchan->data = ast_strdup(record.application_data);
tchan->amaflags = record.amaflag;
return tchan;
}
struct ast_channel *ast_cel_fabricate_channel_from_event(const struct ast_event *event)
{
struct varshead *headp;
struct ast_var_t *newvariable;
const char *mixed_name;
char timebuf[30];
struct ast_channel *tchan;
struct ast_cel_event_record record = {
.version = AST_CEL_EVENT_RECORD_VERSION,
};
/* do not call ast_channel_alloc because this is not really a real channel */
if (!(tchan = ast_dummy_channel_alloc())) {
return NULL;
}
headp = ast_channel_varshead(tchan);
/* first, get the variables from the event */
if (ast_cel_fill_record(event, &record)) {
ast_channel_unref(tchan);
return NULL;
}
/* next, fill the channel with their data */
mixed_name = (record.event_type == AST_CEL_USER_DEFINED)
? record.user_defined_name : record.event_name;
if ((newvariable = ast_var_assign("eventtype", mixed_name))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
if (ast_strlen_zero(cel_dateformat)) {
snprintf(timebuf, sizeof(timebuf), "%ld.%06ld", (long) record.event_time.tv_sec,
(long) record.event_time.tv_usec);
} else {
struct ast_tm tm;
ast_localtime(&record.event_time, &tm, NULL);
ast_strftime(timebuf, sizeof(timebuf), cel_dateformat, &tm);
}
if ((newvariable = ast_var_assign("eventtime", timebuf))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
if ((newvariable = ast_var_assign("eventenum", record.event_name))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
if ((newvariable = ast_var_assign("userdeftype", record.user_defined_name))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
if ((newvariable = ast_var_assign("eventextra", record.extra))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
ast_channel_caller(tchan)->id.name.valid = 1;
ast_channel_caller(tchan)->id.name.str = ast_strdup(record.caller_id_name);
ast_channel_caller(tchan)->id.number.valid = 1;
ast_channel_caller(tchan)->id.number.str = ast_strdup(record.caller_id_num);
ast_channel_caller(tchan)->ani.number.valid = 1;
ast_channel_caller(tchan)->ani.number.str = ast_strdup(record.caller_id_ani);
ast_channel_redirecting(tchan)->from.number.valid = 1;
ast_channel_redirecting(tchan)->from.number.str = ast_strdup(record.caller_id_rdnis);
ast_channel_dialed(tchan)->number.str = ast_strdup(record.caller_id_dnid);
ast_channel_exten_set(tchan, record.extension);
ast_channel_context_set(tchan, record.context);
ast_channel_name_set(tchan, record.channel_name);
ast_channel_uniqueid_set(tchan, record.unique_id);
ast_channel_linkedid_set(tchan, record.linked_id);
ast_channel_accountcode_set(tchan, record.account_code);
ast_channel_peeraccount_set(tchan, record.peer_account);
ast_channel_userfield_set(tchan, record.user_field);
if ((newvariable = ast_var_assign("BRIDGEPEER", record.peer))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
ast_channel_appl_set(tchan, ast_strdup(record.application_name));
ast_channel_data_set(tchan, ast_strdup(record.application_data));
ast_channel_amaflags_set(tchan, record.amaflag);
return tchan;
}
struct ast_channel *ast_cel_fabricate_channel_from_event(const struct ast_event *event)
{
struct varshead *headp;
struct ast_var_t *newvariable;
const char *mixed_name;
char timebuf[30];
struct ast_channel *tchan;
struct ast_cel_event_record record = {
.version = AST_CEL_EVENT_RECORD_VERSION,
};
struct ast_datastore *datastore;
char *app_data;
/* do not call ast_channel_alloc because this is not really a real channel */
if (!(tchan = ast_dummy_channel_alloc())) {
return NULL;
}
headp = ast_channel_varshead(tchan);
/* first, get the variables from the event */
if (ast_cel_fill_record(event, &record)) {
ast_channel_unref(tchan);
return NULL;
}
/* next, fill the channel with their data */
mixed_name = (record.event_type == AST_CEL_USER_DEFINED)
? record.user_defined_name : record.event_name;
if ((newvariable = ast_var_assign("eventtype", mixed_name))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
if (ast_strlen_zero(cel_dateformat)) {
snprintf(timebuf, sizeof(timebuf), "%ld.%06ld", (long) record.event_time.tv_sec,
(long) record.event_time.tv_usec);
} else {
struct ast_tm tm;
ast_localtime(&record.event_time, &tm, NULL);
ast_strftime(timebuf, sizeof(timebuf), cel_dateformat, &tm);
}
if ((newvariable = ast_var_assign("eventtime", timebuf))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
if ((newvariable = ast_var_assign("eventenum", record.event_name))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
if ((newvariable = ast_var_assign("userdeftype", record.user_defined_name))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
if ((newvariable = ast_var_assign("eventextra", record.extra))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
ast_channel_caller(tchan)->id.name.valid = 1;
ast_channel_caller(tchan)->id.name.str = ast_strdup(record.caller_id_name);
ast_channel_caller(tchan)->id.number.valid = 1;
ast_channel_caller(tchan)->id.number.str = ast_strdup(record.caller_id_num);
ast_channel_caller(tchan)->ani.number.valid = 1;
ast_channel_caller(tchan)->ani.number.str = ast_strdup(record.caller_id_ani);
ast_channel_redirecting(tchan)->from.number.valid = 1;
ast_channel_redirecting(tchan)->from.number.str = ast_strdup(record.caller_id_rdnis);
ast_channel_dialed(tchan)->number.str = ast_strdup(record.caller_id_dnid);
ast_channel_exten_set(tchan, record.extension);
ast_channel_context_set(tchan, record.context);
ast_channel_name_set(tchan, record.channel_name);
ast_channel_uniqueid_set(tchan, record.unique_id);
ast_channel_linkedid_set(tchan, record.linked_id);
ast_channel_accountcode_set(tchan, record.account_code);
ast_channel_peeraccount_set(tchan, record.peer_account);
ast_channel_userfield_set(tchan, record.user_field);
if ((newvariable = ast_var_assign("BRIDGEPEER", record.peer))) {
AST_LIST_INSERT_HEAD(headp, newvariable, entries);
}
ast_channel_amaflags_set(tchan, record.amaflag);
/* We need to store an 'application name' and 'application
* data' on the channel for logging purposes, but the channel
* structure only provides a place to store pointers, and it
* expects these pointers to be pointing to data that does not
* need to be freed. This means that the channel's destructor
* does not attempt to free any storage that these pointers
* point to. However, we can't provide data in that form directly for
* these structure members. In order to ensure that these data
* elements have a lifetime that matches the channel's
* lifetime, we'll put them in a datastore attached to the
* channel, and set's the channel's pointers to point into the
* datastore. The datastore will then be automatically destroyed
* when the channel is destroyed.
*/
if (!(datastore = ast_datastore_alloc(&fabricated_channel_datastore, NULL))) {
ast_channel_unref(tchan);
return NULL;
}
if (!(app_data = ast_malloc(strlen(record.application_name) + strlen(record.application_data) + 2))) {
ast_datastore_free(datastore);
ast_channel_unref(tchan);
return NULL;
}
ast_channel_appl_set(tchan, strcpy(app_data, record.application_name));
ast_channel_data_set(tchan, strcpy(app_data + strlen(record.application_name) + 1,
record.application_data));
datastore->data = app_data;
ast_channel_datastore_add(tchan, datastore);
return tchan;
}
