static u_char *ast_var_channels_table(struct variable *vp, oid *name, size_t *length,
int exact, size_t *var_len, WriteMethod **write_method)
{
static unsigned long long_ret;
static u_char bits_ret[2];
static char string_ret[256];
struct ast_channel *chan, *bridge;
struct timeval tval;
u_char *ret = NULL;
int i, bit;
struct ast_str *out = ast_str_alloca(2048);
struct ast_channel_iterator *iter;
if (header_simple_table(vp, name, length, exact, var_len, write_method, ast_active_channels()))
return NULL;
i = name[*length - 1] - 1;
if (!(iter = ast_channel_iterator_all_new())) {
return NULL;
}
while ((chan = ast_channel_iterator_next(iter)) && i) {
ast_channel_unref(chan);
i--;
}
iter = ast_channel_iterator_destroy(iter);
if (chan == NULL) {
return NULL;
}
*var_len = sizeof(long_ret);
ast_channel_lock(chan);
switch (vp->magic) {
case ASTCHANINDEX:
long_ret = name[*length - 1];
ret = (u_char *)&long_ret;
break;
case ASTCHANNAME:
if (!ast_strlen_zero(ast_channel_name(chan))) {
ast_copy_string(string_ret, ast_channel_name(chan), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANLANGUAGE:
if (!ast_strlen_zero(ast_channel_language(chan))) {
ast_copy_string(string_ret, ast_channel_language(chan), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANTYPE:
ast_copy_string(string_ret, ast_channel_tech(chan)->type, sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
break;
case ASTCHANMUSICCLASS:
if (!ast_strlen_zero(ast_channel_musicclass(chan))) {
ast_copy_string(string_ret, ast_channel_musicclass(chan), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANBRIDGE:
if ((bridge = ast_bridged_channel(chan)) != NULL) {
ast_copy_string(string_ret, ast_channel_name(bridge), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANMASQ:
if (ast_channel_masq(chan) && !ast_strlen_zero(ast_channel_name(ast_channel_masq(chan)))) {
ast_copy_string(string_ret, ast_channel_name(ast_channel_masq(chan)), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANMASQR:
if (ast_channel_masqr(chan) && !ast_strlen_zero(ast_channel_name(ast_channel_masqr(chan)))) {
ast_copy_string(string_ret, ast_channel_name(ast_channel_masqr(chan)), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANWHENHANGUP:
if (!ast_tvzero(*ast_channel_whentohangup(chan))) {
gettimeofday(&tval, NULL);
long_ret = difftime(ast_channel_whentohangup(chan)->tv_sec, tval.tv_sec) * 100 - tval.tv_usec / 10000;
ret= (u_char *)&long_ret;
}
break;
case ASTCHANAPP:
if (ast_channel_appl(chan)) {
ast_copy_string(string_ret, ast_channel_appl(chan), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANDATA:
if (ast_channel_data(chan)) {
ast_copy_string(string_ret, ast_channel_data(chan), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANCONTEXT:
ast_copy_string(string_ret, ast_channel_context(chan), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
break;
case ASTCHANMACROCONTEXT:
ast_copy_string(string_ret, ast_channel_macrocontext(chan), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
break;
case ASTCHANMACROEXTEN:
ast_copy_string(string_ret, ast_channel_macroexten(chan), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
break;
case ASTCHANMACROPRI:
long_ret = ast_channel_macropriority(chan);
ret = (u_char *)&long_ret;
break;
case ASTCHANEXTEN:
ast_copy_string(string_ret, ast_channel_exten(chan), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
break;
case ASTCHANPRI:
long_ret = ast_channel_priority(chan);
ret = (u_char *)&long_ret;
break;
case ASTCHANACCOUNTCODE:
if (!ast_strlen_zero(ast_channel_accountcode(chan))) {
ast_copy_string(string_ret, ast_channel_accountcode(chan), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANFORWARDTO:
if (!ast_strlen_zero(ast_channel_call_forward(chan))) {
ast_copy_string(string_ret, ast_channel_call_forward(chan), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANUNIQUEID:
ast_copy_string(string_ret, ast_channel_uniqueid(chan), sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
break;
case ASTCHANCALLGROUP:
long_ret = ast_channel_callgroup(chan);
ret = (u_char *)&long_ret;
break;
case ASTCHANPICKUPGROUP:
long_ret = ast_channel_pickupgroup(chan);
ret = (u_char *)&long_ret;
break;
case ASTCHANSTATE:
long_ret = ast_channel_state(chan) & 0xffff;
ret = (u_char *)&long_ret;
break;
case ASTCHANMUTED:
long_ret = ast_channel_state(chan) & AST_STATE_MUTE ? 1 : 2;
ret = (u_char *)&long_ret;
break;
case ASTCHANRINGS:
long_ret = ast_channel_rings(chan);
ret = (u_char *)&long_ret;
break;
case ASTCHANCIDDNID:
if (ast_channel_dialed(chan)->number.str) {
ast_copy_string(string_ret, ast_channel_dialed(chan)->number.str, sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANCIDNUM:
if (ast_channel_caller(chan)->id.number.valid && ast_channel_caller(chan)->id.number.str) {
ast_copy_string(string_ret, ast_channel_caller(chan)->id.number.str, sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANCIDNAME:
if (ast_channel_caller(chan)->id.name.valid && ast_channel_caller(chan)->id.name.str) {
ast_copy_string(string_ret, ast_channel_caller(chan)->id.name.str, sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANCIDANI:
if (ast_channel_caller(chan)->ani.number.valid && ast_channel_caller(chan)->ani.number.str) {
ast_copy_string(string_ret, ast_channel_caller(chan)->ani.number.str, sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANCIDRDNIS:
if (ast_channel_redirecting(chan)->from.number.valid && ast_channel_redirecting(chan)->from.number.str) {
ast_copy_string(string_ret, ast_channel_redirecting(chan)->from.number.str, sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANCIDPRES:
long_ret = ast_party_id_presentation(&ast_channel_caller(chan)->id);
ret = (u_char *)&long_ret;
break;
case ASTCHANCIDANI2:
long_ret = ast_channel_caller(chan)->ani2;
ret = (u_char *)&long_ret;
break;
case ASTCHANCIDTON:
long_ret = ast_channel_caller(chan)->id.number.plan;
ret = (u_char *)&long_ret;
break;
case ASTCHANCIDTNS:
long_ret = ast_channel_dialed(chan)->transit_network_select;
ret = (u_char *)&long_ret;
break;
case ASTCHANAMAFLAGS:
long_ret = ast_channel_amaflags(chan);
ret = (u_char *)&long_ret;
break;
case ASTCHANADSI:
long_ret = ast_channel_adsicpe(chan);
ret = (u_char *)&long_ret;
break;
case ASTCHANTONEZONE:
if (ast_channel_zone(chan)) {
ast_copy_string(string_ret, ast_channel_zone(chan)->country, sizeof(string_ret));
*var_len = strlen(string_ret);
ret = (u_char *)string_ret;
}
break;
case ASTCHANHANGUPCAUSE:
long_ret = ast_channel_hangupcause(chan);
ret = (u_char *)&long_ret;
break;
case ASTCHANVARIABLES:
if (pbx_builtin_serialize_variables(chan, &out)) {
*var_len = ast_str_strlen(out);
ret = (u_char *)ast_str_buffer(out);
}
break;
case ASTCHANFLAGS:
bits_ret[0] = 0;
for (bit = 0; bit < 8; bit++)
bits_ret[0] |= ((ast_channel_flags(chan)->flags & (1 << bit)) >> bit) << (7 - bit);
bits_ret[1] = 0;
for (bit = 0; bit < 8; bit++)
bits_ret[1] |= (((ast_channel_flags(chan)->flags >> 8) & (1 << bit)) >> bit) << (7 - bit);
*var_len = 2;
ret = bits_ret;
break;
case ASTCHANTRANSFERCAP:
long_ret = ast_channel_transfercapability(chan);
ret = (u_char *)&long_ret;
default:
break;
}
ast_channel_unlock(chan);
chan = ast_channel_unref(chan);
return ret;
}
static int func_channel_read(struct ast_channel *chan, const char *function,
char *data, char *buf, size_t len)
{
int ret = 0;
struct ast_format_cap *tmpcap;
if (!chan) {
ast_log(LOG_WARNING, "No channel was provided to %s function.\n", function);
return -1;
}
if (!strcasecmp(data, "audionativeformat")) {
tmpcap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
if (tmpcap) {
struct ast_str *codec_buf = ast_str_alloca(128);
ast_channel_lock(chan);
ast_format_cap_append_from_cap(tmpcap, ast_channel_nativeformats(chan), AST_MEDIA_TYPE_AUDIO);
ast_channel_unlock(chan);
ast_copy_string(buf, ast_format_cap_get_names(tmpcap, &codec_buf), len);
ao2_ref(tmpcap, -1);
}
} else if (!strcasecmp(data, "videonativeformat")) {
tmpcap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
if (tmpcap) {
struct ast_str *codec_buf = ast_str_alloca(128);
ast_channel_lock(chan);
ast_format_cap_append_from_cap(tmpcap, ast_channel_nativeformats(chan), AST_MEDIA_TYPE_VIDEO);
ast_channel_unlock(chan);
ast_copy_string(buf, ast_format_cap_get_names(tmpcap, &codec_buf), len);
ao2_ref(tmpcap, -1);
}
} else if (!strcasecmp(data, "audioreadformat")) {
locked_copy_string(chan, buf, ast_format_get_name(ast_channel_readformat(chan)), len);
} else if (!strcasecmp(data, "audiowriteformat")) {
locked_copy_string(chan, buf, ast_format_get_name(ast_channel_writeformat(chan)), len);
#ifdef CHANNEL_TRACE
} else if (!strcasecmp(data, "trace")) {
locked_copy_string(chan, buf, ast_channel_trace_is_enabled(chan) ? "1" : "0", len);
#endif
} else if (!strcasecmp(data, "tonezone") && ast_channel_zone(chan)) {
locked_copy_string(chan, buf, ast_channel_zone(chan)->country, len);
} else if (!strcasecmp(data, "dtmf_features")) {
if (ast_bridge_features_ds_get_string(chan, buf, len)) {
buf[0] = '\0';
}
} else if (!strcasecmp(data, "language"))
locked_copy_string(chan, buf, ast_channel_language(chan), len);
else if (!strcasecmp(data, "musicclass"))
locked_copy_string(chan, buf, ast_channel_musicclass(chan), len);
else if (!strcasecmp(data, "name")) {
locked_copy_string(chan, buf, ast_channel_name(chan), len);
} else if (!strcasecmp(data, "parkinglot"))
locked_copy_string(chan, buf, ast_channel_parkinglot(chan), len);
else if (!strcasecmp(data, "state"))
locked_copy_string(chan, buf, ast_state2str(ast_channel_state(chan)), len);
else if (!strcasecmp(data, "onhold")) {
locked_copy_string(chan, buf,
ast_channel_hold_state(chan) == AST_CONTROL_HOLD ? "1" : "0", len);
} else if (!strcasecmp(data, "channeltype"))
locked_copy_string(chan, buf, ast_channel_tech(chan)->type, len);
else if (!strcasecmp(data, "accountcode"))
locked_copy_string(chan, buf, ast_channel_accountcode(chan), len);
else if (!strcasecmp(data, "checkhangup")) {
locked_copy_string(chan, buf, ast_check_hangup(chan) ? "1" : "0", len);
} else if (!strcasecmp(data, "peeraccount"))
locked_copy_string(chan, buf, ast_channel_peeraccount(chan), len);
else if (!strcasecmp(data, "hangupsource"))
locked_copy_string(chan, buf, ast_channel_hangupsource(chan), len);
else if (!strcasecmp(data, "appname") && ast_channel_appl(chan))
locked_copy_string(chan, buf, ast_channel_appl(chan), len);
else if (!strcasecmp(data, "appdata") && ast_channel_data(chan))
locked_copy_string(chan, buf, ast_channel_data(chan), len);
else if (!strcasecmp(data, "exten") && ast_channel_data(chan))
locked_copy_string(chan, buf, ast_channel_exten(chan), len);
else if (!strcasecmp(data, "context") && ast_channel_data(chan))
locked_copy_string(chan, buf, ast_channel_context(chan), len);
else if (!strcasecmp(data, "userfield") && ast_channel_data(chan))
locked_copy_string(chan, buf, ast_channel_userfield(chan), len);
else if (!strcasecmp(data, "channame") && ast_channel_data(chan))
locked_copy_string(chan, buf, ast_channel_name(chan), len);
else if (!strcasecmp(data, "linkedid")) {
ast_channel_lock(chan);
if (ast_strlen_zero(ast_channel_linkedid(chan))) {
/* fall back on the channel's uniqueid if linkedid is unset */
ast_copy_string(buf, ast_channel_uniqueid(chan), len);
}
else {
ast_copy_string(buf, ast_channel_linkedid(chan), len);
}
ast_channel_unlock(chan);
} else if (!strcasecmp(data, "peer")) {
struct ast_channel *peer;
peer = ast_channel_bridge_peer(chan);
if (peer) {
/* Only real channels could have a bridge peer this way. */
ast_channel_lock(peer);
ast_copy_string(buf, ast_channel_name(peer), len);
ast_channel_unlock(peer);
ast_channel_unref(peer);
} else {
buf[0] = '\0';
ast_channel_lock(chan);
if (!ast_channel_tech(chan)) {
const char *pname;
/*
* A dummy channel can still pass along bridged peer info
* via the BRIDGEPEER variable.
*
* A horrible kludge, but... how else?
*/
pname = pbx_builtin_getvar_helper(chan, "BRIDGEPEER");
if (!ast_strlen_zero(pname)) {
ast_copy_string(buf, pname, len);
}
}
ast_channel_unlock(chan);
}
} else if (!strcasecmp(data, "uniqueid")) {
locked_copy_string(chan, buf, ast_channel_uniqueid(chan), len);
} else if (!strcasecmp(data, "transfercapability")) {
locked_copy_string(chan, buf, transfercapability_table[ast_channel_transfercapability(chan) & 0x1f], len);
} else if (!strcasecmp(data, "callgroup")) {
char groupbuf[256];
locked_copy_string(chan, buf, ast_print_group(groupbuf, sizeof(groupbuf), ast_channel_callgroup(chan)), len);
} else if (!strcasecmp(data, "pickupgroup")) {
char groupbuf[256];
locked_copy_string(chan, buf, ast_print_group(groupbuf, sizeof(groupbuf), ast_channel_pickupgroup(chan)), len);
} else if (!strcasecmp(data, "namedcallgroup")) {
struct ast_str *tmp_str = ast_str_alloca(1024);
locked_copy_string(chan, buf, ast_print_namedgroups(&tmp_str, ast_channel_named_callgroups(chan)), len);
} else if (!strcasecmp(data, "namedpickupgroup")) {
struct ast_str *tmp_str = ast_str_alloca(1024);
locked_copy_string(chan, buf, ast_print_namedgroups(&tmp_str, ast_channel_named_pickupgroups(chan)), len);
} else if (!strcasecmp(data, "after_bridge_goto")) {
ast_bridge_read_after_goto(chan, buf, len);
} else if (!strcasecmp(data, "amaflags")) {
ast_channel_lock(chan);
snprintf(buf, len, "%u", ast_channel_amaflags(chan));
ast_channel_unlock(chan);
} else if (!strncasecmp(data, "secure_bridge_", 14)) {
struct ast_datastore *ds;
buf[0] = '\0';
ast_channel_lock(chan);
if ((ds = ast_channel_datastore_find(chan, &secure_call_info, NULL))) {
struct ast_secure_call_store *encrypt = ds->data;
if (!strcasecmp(data, "secure_bridge_signaling")) {
snprintf(buf, len, "%s", encrypt->signaling ? "1" : "");
} else if (!strcasecmp(data, "secure_bridge_media")) {
snprintf(buf, len, "%s", encrypt->media ? "1" : "");
}
}
ast_channel_unlock(chan);
} else if (!strcasecmp(data, "max_forwards")) {
ast_channel_lock(chan);
snprintf(buf, len, "%d", ast_max_forwards_get(chan));
ast_channel_unlock(chan);
} else if (!ast_channel_tech(chan) || !ast_channel_tech(chan)->func_channel_read || ast_channel_tech(chan)->func_channel_read(chan, function, data, buf, len)) {
ast_log(LOG_WARNING, "Unknown or unavailable item requested: '%s'\n", data);
ret = -1;
}
return ret;
}
static int serialize_showchan(struct ast_channel *c, char *buf, size_t size)
{
long elapsed_seconds = 0;
int hour = 0, min = 0, sec = 0;
struct ast_str *format_buf = ast_str_alloca(64);
char cgrp[256];
char pgrp[256];
struct ast_str *write_transpath = ast_str_alloca(256);
struct ast_str *read_transpath = ast_str_alloca(256);
struct ast_bridge *bridge;
memset(buf, 0, size);
if (!c)
return 0;
elapsed_seconds = ast_channel_get_duration(c);
hour = elapsed_seconds / 3600;
min = (elapsed_seconds % 3600) / 60;
sec = elapsed_seconds % 60;
ast_channel_lock(c);
bridge = ast_channel_get_bridge(c);
ast_channel_unlock(c);
snprintf(buf,size,
"Name= %s\n"
"Type= %s\n"
"UniqueID= %s\n"
"LinkedID= %s\n"
"CallerIDNum= %s\n"
"CallerIDName= %s\n"
"ConnectedLineIDNum= %s\n"
"ConnectedLineIDName=%s\n"
"DNIDDigits= %s\n"
"RDNIS= %s\n"
"Parkinglot= %s\n"
"Language= %s\n"
"State= %s (%u)\n"
"Rings= %d\n"
"NativeFormat= %s\n"
"WriteFormat= %s\n"
"ReadFormat= %s\n"
"RawWriteFormat= %s\n"
"RawReadFormat= %s\n"
"WriteTranscode= %s %s\n"
"ReadTranscode= %s %s\n"
"1stFileDescriptor= %d\n"
"Framesin= %u %s\n"
"Framesout= %u %s\n"
"TimetoHangup= %ld\n"
"ElapsedTime= %dh%dm%ds\n"
"BridgeID= %s\n"
"Context= %s\n"
"Extension= %s\n"
"Priority= %d\n"
"CallGroup= %s\n"
"PickupGroup= %s\n"
"Application= %s\n"
"Data= %s\n"
"Blocking_in= %s\n",
ast_channel_name(c),
ast_channel_tech(c)->type,
ast_channel_uniqueid(c),
ast_channel_linkedid(c),
S_COR(ast_channel_caller(c)->id.number.valid, ast_channel_caller(c)->id.number.str, "(N/A)"),
S_COR(ast_channel_caller(c)->id.name.valid, ast_channel_caller(c)->id.name.str, "(N/A)"),
S_COR(ast_channel_connected(c)->id.number.valid, ast_channel_connected(c)->id.number.str, "(N/A)"),
S_COR(ast_channel_connected(c)->id.name.valid, ast_channel_connected(c)->id.name.str, "(N/A)"),
S_OR(ast_channel_dialed(c)->number.str, "(N/A)"),
S_COR(ast_channel_redirecting(c)->from.number.valid, ast_channel_redirecting(c)->from.number.str, "(N/A)"),
ast_channel_parkinglot(c),
ast_channel_language(c),
ast_state2str(ast_channel_state(c)),
ast_channel_state(c),
ast_channel_rings(c),
ast_format_cap_get_names(ast_channel_nativeformats(c), &format_buf),
ast_format_get_name(ast_channel_writeformat(c)),
ast_format_get_name(ast_channel_readformat(c)),
ast_format_get_name(ast_channel_rawwriteformat(c)),
ast_format_get_name(ast_channel_rawreadformat(c)),
ast_channel_writetrans(c) ? "Yes" : "No",
ast_translate_path_to_str(ast_channel_writetrans(c), &write_transpath),
ast_channel_readtrans(c) ? "Yes" : "No",
ast_translate_path_to_str(ast_channel_readtrans(c), &read_transpath),
ast_channel_fd(c, 0),
ast_channel_fin(c) & ~DEBUGCHAN_FLAG, (ast_channel_fin(c) & DEBUGCHAN_FLAG) ? " (DEBUGGED)" : "",
ast_channel_fout(c) & ~DEBUGCHAN_FLAG, (ast_channel_fout(c) & DEBUGCHAN_FLAG) ? " (DEBUGGED)" : "",
(long)ast_channel_whentohangup(c)->tv_sec,
hour,
min,
sec,
bridge ? bridge->uniqueid : "(Not bridged)",
ast_channel_context(c),
ast_channel_exten(c),
ast_channel_priority(c),
ast_print_group(cgrp, sizeof(cgrp), ast_channel_callgroup(c)),
ast_print_group(pgrp, sizeof(pgrp), ast_channel_pickupgroup(c)),
ast_channel_appl(c) ? ast_channel_appl(c) : "(N/A)",
ast_channel_data(c) ? S_OR(ast_channel_data(c), "(Empty)") : "(None)",
(ast_test_flag(ast_channel_flags(c), AST_FLAG_BLOCKING) ? ast_channel_blockproc(c) : "(Not Blocking)"));
ao2_cleanup(bridge);
return 0;
}
static void aoc_s_event(const struct ast_aoc_decoded *decoded, struct ast_channel *owner, struct ast_str **msg)
{
const char *rate_str;
char prefix[32];
int idx;
if (owner) {
ast_str_append(msg, 0, "Channel: %s\r\n", ast_channel_name(owner));
ast_str_append(msg, 0, "UniqueID: %s\r\n", ast_channel_uniqueid(owner));
}
ast_str_append(msg, 0, "NumberRates: %d\r\n", decoded->aoc_s_count);
for (idx = 0; idx < decoded->aoc_s_count; ++idx) {
snprintf(prefix, sizeof(prefix), "Rate(%d)", idx);
ast_str_append(msg, 0, "%s/Chargeable: %s\r\n", prefix,
aoc_charged_item_str(decoded->aoc_s_entries[idx].charged_item));
if (decoded->aoc_s_entries[idx].charged_item == AST_AOC_CHARGED_ITEM_NA) {
continue;
}
rate_str = aoc_rate_type_str(decoded->aoc_s_entries[idx].rate_type);
ast_str_append(msg, 0, "%s/Type: %s\r\n", prefix, rate_str);
switch (decoded->aoc_s_entries[idx].rate_type) {
case AST_AOC_RATE_TYPE_DURATION:
strcat(prefix, "/");
strcat(prefix, rate_str);
ast_str_append(msg, 0, "%s/Currency: %s\r\n", prefix,
decoded->aoc_s_entries[idx].rate.duration.currency_name);
aoc_amount_str(msg, prefix,
decoded->aoc_s_entries[idx].rate.duration.amount,
decoded->aoc_s_entries[idx].rate.duration.multiplier);
ast_str_append(msg, 0, "%s/ChargingType: %s\r\n", prefix,
decoded->aoc_s_entries[idx].rate.duration.charging_type ?
"StepFunction" : "ContinuousCharging");
aoc_time_str(msg, prefix, "Time",
decoded->aoc_s_entries[idx].rate.duration.time,
decoded->aoc_s_entries[idx].rate.duration.time_scale);
if (decoded->aoc_s_entries[idx].rate.duration.granularity_time) {
aoc_time_str(msg, prefix, "Granularity",
decoded->aoc_s_entries[idx].rate.duration.granularity_time,
decoded->aoc_s_entries[idx].rate.duration.granularity_time_scale);
}
break;
case AST_AOC_RATE_TYPE_FLAT:
strcat(prefix, "/");
strcat(prefix, rate_str);
ast_str_append(msg, 0, "%s/Currency: %s\r\n", prefix,
decoded->aoc_s_entries[idx].rate.flat.currency_name);
aoc_amount_str(msg, prefix,
decoded->aoc_s_entries[idx].rate.flat.amount,
decoded->aoc_s_entries[idx].rate.flat.multiplier);
break;
case AST_AOC_RATE_TYPE_VOLUME:
strcat(prefix, "/");
strcat(prefix, rate_str);
ast_str_append(msg, 0, "%s/Currency: %s\r\n", prefix,
decoded->aoc_s_entries[idx].rate.volume.currency_name);
aoc_amount_str(msg, prefix,
decoded->aoc_s_entries[idx].rate.volume.amount,
decoded->aoc_s_entries[idx].rate.volume.multiplier);
ast_str_append(msg, 0, "%s/Unit: %s\r\n", prefix,
aoc_volume_unit_str(decoded->aoc_s_entries[idx].rate.volume.volume_unit));
break;
case AST_AOC_RATE_TYPE_SPECIAL_CODE:
ast_str_append(msg, 0, "%s/%s: %d\r\n", prefix, rate_str,
decoded->aoc_s_entries[idx].rate.special_code);
break;
default:
break;
}
}
}
static void aoc_e_event(const struct ast_aoc_decoded *decoded, struct ast_channel *chan, struct ast_str **msg)
{
const char *charge_str;
int idx;
char prefix[32];
if (chan) {
ast_str_append(msg, 0, "Channel: %s\r\n", ast_channel_name(chan));
ast_str_append(msg, 0, "UniqueID: %s\r\n", ast_channel_uniqueid(chan));
}
charge_str = "ChargingAssociation";
switch (decoded->charging_association.charging_type) {
case AST_AOC_CHARGING_ASSOCIATION_NUMBER:
snprintf(prefix, sizeof(prefix), "%s/Number", charge_str);
ast_str_append(msg, 0, "%s: %s\r\n", prefix,
decoded->charging_association.charge.number.number);
ast_str_append(msg, 0, "%s/Plan: %d\r\n", prefix,
decoded->charging_association.charge.number.plan);
break;
case AST_AOC_CHARGING_ASSOCIATION_ID:
ast_str_append(msg, 0, "%s/ID: %d\r\n", charge_str, decoded->charging_association.charge.id);
break;
case AST_AOC_CHARGING_ASSOCIATION_NA:
default:
break;
}
charge_str = aoc_charge_type_str(decoded->charge_type);
ast_str_append(msg, 0, "Type: %s\r\n", charge_str);
switch (decoded->charge_type) {
case AST_AOC_CHARGE_CURRENCY:
case AST_AOC_CHARGE_UNIT:
ast_str_append(msg, 0, "BillingID: %s\r\n",
aoc_billingid_str(decoded->billing_id));
break;
default:
break;
}
switch (decoded->charge_type) {
case AST_AOC_CHARGE_CURRENCY:
ast_str_append(msg, 0, "%s: %s\r\n", charge_str,
decoded->currency_name);
aoc_amount_str(msg, charge_str,
decoded->currency_amount,
decoded->multiplier);
break;
case AST_AOC_CHARGE_UNIT:
ast_str_append(msg, 0, "%s/NumberItems: %d\r\n", charge_str,
decoded->unit_count);
for (idx = 0; idx < decoded->unit_count; ++idx) {
snprintf(prefix, sizeof(prefix), "%s/Item(%d)", charge_str, idx);
if (decoded->unit_list[idx].valid_amount) {
ast_str_append(msg, 0, "%s/NumberOf: %u\r\n", prefix,
decoded->unit_list[idx].amount);
}
if (decoded->unit_list[idx].valid_type) {
ast_str_append(msg, 0, "%s/TypeOf: %d\r\n", prefix,
decoded->unit_list[idx].type);
}
}
break;
default:
break;
}
}
/*! \brief Start monitoring a channel
* \param chan ast_channel struct to record
* \param format_spec file format to use for recording
* \param fname_base filename base to record to
* \param need_lock whether to lock the channel mutex
* \param stream_action whether to record the input and/or output streams. X_REC_IN | X_REC_OUT is most often used
* Creates the file to record, if no format is specified it assumes WAV
* It also sets channel variable __MONITORED=yes
* \retval 0 on success
* \retval -1 on failure
*/
int AST_OPTIONAL_API_NAME(ast_monitor_start)(struct ast_channel *chan, const char *format_spec,
const char *fname_base, int need_lock, int stream_action)
{
int res = 0;
LOCK_IF_NEEDED(chan, need_lock);
if (!(ast_channel_monitor(chan))) {
struct ast_channel_monitor *monitor;
char *channel_name, *p;
/* Create monitoring directory if needed */
ast_mkdir(ast_config_AST_MONITOR_DIR, 0777);
if (!(monitor = ast_calloc(1, sizeof(*monitor)))) {
UNLOCK_IF_NEEDED(chan, need_lock);
return -1;
}
/* Determine file names */
if (!ast_strlen_zero(fname_base)) {
int directory = strchr(fname_base, '/') ? 1 : 0;
const char *absolute = *fname_base == '/' ? "" : ast_config_AST_MONITOR_DIR;
const char *absolute_suffix = *fname_base == '/' ? "" : "/";
snprintf(monitor->read_filename, FILENAME_MAX, "%s%s%s-in",
absolute, absolute_suffix, fname_base);
snprintf(monitor->write_filename, FILENAME_MAX, "%s%s%s-out",
absolute, absolute_suffix, fname_base);
snprintf(monitor->filename_base, FILENAME_MAX, "%s%s%s",
absolute, absolute_suffix, fname_base);
/* try creating the directory just in case it doesn't exist */
if (directory) {
char *name = ast_strdupa(monitor->filename_base);
ast_mkdir(dirname(name), 0777);
}
} else {
ast_mutex_lock(&monitorlock);
snprintf(monitor->read_filename, FILENAME_MAX, "%s/audio-in-%lu",
ast_config_AST_MONITOR_DIR, seq);
snprintf(monitor->write_filename, FILENAME_MAX, "%s/audio-out-%lu",
ast_config_AST_MONITOR_DIR, seq);
seq++;
ast_mutex_unlock(&monitorlock);
/* Replace all '/' chars from the channel name with '-' chars. */
channel_name = ast_strdupa(ast_channel_name(chan));
for (p = channel_name; (p = strchr(p, '/')); ) {
*p = '-';
}
snprintf(monitor->filename_base, FILENAME_MAX, "%s/%d-%s",
ast_config_AST_MONITOR_DIR, (int)time(NULL), channel_name);
monitor->filename_changed = 1;
}
monitor->stop = ast_monitor_stop;
/* Determine file format */
if (!ast_strlen_zero(format_spec)) {
monitor->format = ast_strdup(format_spec);
} else {
monitor->format = ast_strdup("wav");
}
/* open files */
if (stream_action & X_REC_IN) {
if (ast_fileexists(monitor->read_filename, NULL, NULL) > 0)
ast_filedelete(monitor->read_filename, NULL);
if (!(monitor->read_stream = ast_writefile(monitor->read_filename,
monitor->format, NULL,
O_CREAT|O_TRUNC|O_WRONLY, 0, AST_FILE_MODE))) {
ast_log(LOG_WARNING, "Could not create file %s\n",
monitor->read_filename);
ast_free(monitor);
UNLOCK_IF_NEEDED(chan, need_lock);
return -1;
}
} else
monitor->read_stream = NULL;
if (stream_action & X_REC_OUT) {
if (ast_fileexists(monitor->write_filename, NULL, NULL) > 0) {
ast_filedelete(monitor->write_filename, NULL);
}
if (!(monitor->write_stream = ast_writefile(monitor->write_filename,
monitor->format, NULL,
O_CREAT|O_TRUNC|O_WRONLY, 0, AST_FILE_MODE))) {
ast_log(LOG_WARNING, "Could not create file %s\n",
monitor->write_filename);
if (monitor->read_stream) {
ast_closestream(monitor->read_stream);
}
ast_free(monitor);
UNLOCK_IF_NEEDED(chan, need_lock);
return -1;
}
} else
monitor->write_stream = NULL;
ast_channel_monitor_set(chan, monitor);
ast_monitor_set_state(chan, AST_MONITOR_RUNNING);
/* so we know this call has been monitored in case we need to bill for it or something */
pbx_builtin_setvar_helper(chan, "__MONITORED","true");
ast_manager_event(chan, EVENT_FLAG_CALL, "MonitorStart",
"Channel: %s\r\n"
"Uniqueid: %s\r\n",
ast_channel_name(chan),
ast_channel_uniqueid(chan));
} else {
ast_debug(1,"Cannot start monitoring %s, already monitored\n", ast_channel_name(chan));
res = -1;
}
UNLOCK_IF_NEEDED(chan, need_lock);
return res;
}
int ast_do_pickup(struct ast_channel *chan, struct ast_channel *target)
{
struct ast_party_connected_line connected_caller;
struct ast_datastore *ds_pickup;
const char *chan_name;/*!< A masquerade changes channel names. */
const char *target_name;/*!< A masquerade changes channel names. */
int res = -1;
RAII_VAR(struct ast_channel_snapshot *, chan_snapshot, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, target_snapshot, NULL, ao2_cleanup);
target_name = ast_strdupa(ast_channel_name(target));
ast_debug(1, "Call pickup on '%s' by '%s'\n", target_name, ast_channel_name(chan));
/* Mark the target to block any call pickup race. */
ds_pickup = ast_datastore_alloc(&pickup_active, NULL);
if (!ds_pickup) {
ast_log(LOG_WARNING,
"Unable to create channel datastore on '%s' for call pickup\n", target_name);
return -1;
}
ast_channel_datastore_add(target, ds_pickup);
ast_party_connected_line_init(&connected_caller);
ast_party_connected_line_copy(&connected_caller, ast_channel_connected(target));
ast_channel_unlock(target);/* The pickup race is avoided so we do not need the lock anymore. */
/* Reset any earlier private connected id representation */
ast_party_id_reset(&connected_caller.priv);
connected_caller.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
if (ast_channel_connected_line_sub(NULL, chan, &connected_caller, 0) &&
ast_channel_connected_line_macro(NULL, chan, &connected_caller, 0, 0)) {
ast_channel_update_connected_line(chan, &connected_caller, NULL);
}
ast_party_connected_line_free(&connected_caller);
ast_channel_lock(chan);
chan_name = ast_strdupa(ast_channel_name(chan));
ast_connected_line_copy_from_caller(&connected_caller, ast_channel_caller(chan));
ast_channel_unlock(chan);
connected_caller.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
if (ast_answer(chan)) {
ast_log(LOG_WARNING, "Unable to answer '%s'\n", chan_name);
goto pickup_failed;
}
if (ast_queue_control(chan, AST_CONTROL_ANSWER)) {
ast_log(LOG_WARNING, "Unable to queue answer on '%s'\n", chan_name);
goto pickup_failed;
}
ast_channel_queue_connected_line_update(chan, &connected_caller, NULL);
/* setting the HANGUPCAUSE so the ringing channel knows this call was not a missed call */
ast_channel_hangupcause_set(chan, AST_CAUSE_ANSWERED_ELSEWHERE);
ast_channel_lock(chan);
chan_snapshot = ast_channel_snapshot_create(chan);
ast_channel_unlock(chan);
if (!chan_snapshot) {
goto pickup_failed;
}
target_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(target));
if (!target_snapshot) {
goto pickup_failed;
}
if (ast_channel_move(target, chan)) {
ast_log(LOG_WARNING, "Unable to complete call pickup of '%s' with '%s'\n",
chan_name, target_name);
goto pickup_failed;
}
/* target points to the channel that did the pickup at this point, so use that channel's topic instead of chan */
send_call_pickup_stasis_message(target, chan_snapshot, target_snapshot);
res = 0;
pickup_failed:
ast_channel_lock(target);
if (!ast_channel_datastore_remove(target, ds_pickup)) {
ast_datastore_free(ds_pickup);
}
ast_party_connected_line_free(&connected_caller);
return res;
}
/*!
* \internal
* \brief Determine if an extension is a parking extension
*/
static int parking_is_exten_park(const char *context, const char *exten)
{
struct ast_exten *exten_obj;
struct pbx_find_info info = { .stacklen = 0 }; /* the rest is reset in pbx_find_extension */
const char *app_at_exten;
ast_debug(4, "Checking if %s@%s is a parking exten\n", exten, context);
exten_obj = pbx_find_extension(NULL, NULL, &info, context, exten, 1, NULL, NULL, E_MATCH);
if (!exten_obj) {
return 0;
}
app_at_exten = ast_get_extension_app(exten_obj);
if (!app_at_exten || strcasecmp(PARK_APPLICATION, app_at_exten)) {
return 0;
}
return 1;
}
/*!
* \internal
* \since 12.0.0
* \brief Perform a blind transfer to a parking lot
*
* In general, most parking features should work to call this function. This will safely
* park either a channel in the bridge with \ref bridge_channel or will park the entire
* bridge if more than one channel is in the bridge. It will create the correct data to
* pass to the \ref AstBridging Bridging API to safely park the channel.
*
* \param bridge_channel The bridge_channel representing the channel performing the park
* \param context The context to blind transfer to
* \param exten The extension to blind transfer to
* \param parked_channel_cb Optional callback executed prior to sending the parked channel into the bridge
* \param parked_channel_data Data for the parked_channel_cb
*
* \retval 0 on success
* \retval non-zero on error
*/
static int parking_blind_transfer_park(struct ast_bridge_channel *bridge_channel,
const char *context, const char *exten, transfer_channel_cb parked_channel_cb,
struct transfer_channel_data *parked_channel_data)
{
RAII_VAR(struct ast_bridge_channel *, other, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel *, other_chan, NULL, ast_channel_cleanup);
struct ast_exten *e;
struct pbx_find_info find_info = { .stacklen = 0 };
int peer_count;
if (ast_strlen_zero(context) || ast_strlen_zero(exten)) {
return -1;
}
if (!bridge_channel->in_bridge) {
return -1;
}
if (!parking_is_exten_park(context, exten)) {
return -1;
}
ast_bridge_channel_lock_bridge(bridge_channel);
peer_count = bridge_channel->bridge->num_channels;
if (peer_count == 2) {
other = ast_bridge_channel_peer(bridge_channel);
ao2_ref(other, +1);
other_chan = other->chan;
ast_channel_ref(other_chan);
}
ast_bridge_unlock(bridge_channel->bridge);
if (peer_count < 2) {
/* There is nothing to do if there is no one to park. */
return -1;
}
/* With a multiparty bridge, we need to do a regular blind transfer. We link the
* existing bridge to the parking lot with a Local channel rather than
* transferring others. */
if (peer_count > 2) {
struct ast_channel *transfer_chan = NULL;
transfer_chan = park_local_transfer(bridge_channel->chan, context, exten, parked_channel_data);
if (!transfer_chan) {
return -1;
}
ast_channel_ref(transfer_chan);
if (parked_channel_cb) {
parked_channel_cb(transfer_chan, parked_channel_data, AST_BRIDGE_TRANSFER_MULTI_PARTY);
}
if (ast_bridge_impart(bridge_channel->bridge, transfer_chan, NULL, NULL,
AST_BRIDGE_IMPART_CHAN_INDEPENDENT)) {
ast_hangup(transfer_chan);
ast_channel_unref(transfer_chan);
return -1;
}
ast_channel_unref(transfer_chan);
return 0;
}
/* Subscribe to park messages with the other channel entering */
if (create_parked_subscription_full(bridge_channel->chan, ast_channel_uniqueid(other->chan), 1, parked_channel_data)) {
return -1;
}
if (parked_channel_cb) {
parked_channel_cb(other_chan, parked_channel_data, AST_BRIDGE_TRANSFER_SINGLE_PARTY);
}
e = pbx_find_extension(NULL, NULL, &find_info, context, exten, 1, NULL, NULL, E_MATCH);
/* Write the park frame with the intended recipient and other data out to the bridge. */
ast_bridge_channel_write_park(bridge_channel,
ast_channel_uniqueid(other_chan),
ast_channel_uniqueid(bridge_channel->chan),
e ? ast_get_extension_app_data(e) : NULL);
return 0;
}
/*!
* \internal
* \since 12.0.0
* \brief Perform a direct park on a channel in a bridge
*
* \note This will be called from within the \ref AstBridging Bridging API
*
* \param bridge_channel The bridge_channel representing the channel to be parked
* \param uuid_parkee The UUID of the channel being parked
* \param uuid_parker The UUID of the channel performing the park
* \param app_data Application parseable data to pass to the parking application
*/
static int parking_park_bridge_channel(struct ast_bridge_channel *bridge_channel, const char *uuid_parkee, const char *uuid_parker, const char *app_data)
{
RAII_VAR(struct ast_bridge *, parking_bridge, NULL, ao2_cleanup);
RAII_VAR(struct ast_bridge *, original_bridge, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel *, parker, NULL, ao2_cleanup);
if (strcmp(ast_channel_uniqueid(bridge_channel->chan), uuid_parkee)) {
/* We aren't the parkee, so ignore this action. */
return -1;
}
parker = ast_channel_get_by_name(uuid_parker);
if (!parker) {
ast_log(LOG_NOTICE, "Channel with uuid %s left before we could start parking the call. Parking canceled.\n", uuid_parker);
publish_parked_call_failure(bridge_channel->chan);
return -1;
}
if (!(parking_bridge = park_application_setup(bridge_channel->chan, parker, app_data, NULL))) {
publish_parked_call_failure(bridge_channel->chan);
return -1;
}
ast_bridge_set_transfer_variables(bridge_channel->chan, ast_channel_name(parker), 0);
/* bridge_channel must be locked so we can get a reference to the bridge it is currently on */
ao2_lock(bridge_channel);
original_bridge = bridge_channel->bridge;
if (!original_bridge) {
ao2_unlock(bridge_channel);
publish_parked_call_failure(bridge_channel->chan);
return -1;
}
ao2_ref(original_bridge, +1); /* Cleaned by RAII_VAR */
ao2_unlock(bridge_channel);
if (ast_bridge_move(parking_bridge, original_bridge, bridge_channel->chan, NULL, 1)) {
ast_log(LOG_ERROR, "Failed to move %s into the parking bridge.\n",
ast_channel_name(bridge_channel->chan));
return -1;
}
return 0;
}
int ast_cel_report_event(struct ast_channel *chan, enum ast_cel_event_type event_type,
const char *userdefevname, const char *extra, struct ast_channel *peer2)
{
struct timeval eventtime;
struct ast_event *ev;
const char *peername = "";
struct ast_channel *peer;
ast_channel_lock(chan);
peer = ast_bridged_channel(chan);
if (peer) {
ast_channel_ref(peer);
}
ast_channel_unlock(chan);
/* Make sure a reload is not occurring while we're checking to see if this
* is an event that we care about. We could lose an important event in this
* process otherwise. */
ast_mutex_lock(&reload_lock);
if (!cel_enabled || !ast_cel_track_event(event_type)) {
ast_mutex_unlock(&reload_lock);
if (peer) {
ast_channel_unref(peer);
}
return 0;
}
if (event_type == AST_CEL_APP_START || event_type == AST_CEL_APP_END) {
char *app;
if (!(app = ao2_find(appset, (char *) ast_channel_appl(chan), OBJ_POINTER))) {
ast_mutex_unlock(&reload_lock);
if (peer) {
ast_channel_unref(peer);
}
return 0;
}
ao2_ref(app, -1);
}
ast_mutex_unlock(&reload_lock);
if (peer) {
ast_channel_lock(peer);
peername = ast_strdupa(ast_channel_name(peer));
ast_channel_unlock(peer);
} else if (peer2) {
ast_channel_lock(peer2);
peername = ast_strdupa(ast_channel_name(peer2));
ast_channel_unlock(peer2);
}
if (!userdefevname) {
userdefevname = "";
}
if (!extra) {
extra = "";
}
eventtime = ast_tvnow();
ast_channel_lock(chan);
ev = ast_event_new(AST_EVENT_CEL,
AST_EVENT_IE_CEL_EVENT_TYPE, AST_EVENT_IE_PLTYPE_UINT, event_type,
AST_EVENT_IE_CEL_EVENT_TIME, AST_EVENT_IE_PLTYPE_UINT, eventtime.tv_sec,
AST_EVENT_IE_CEL_EVENT_TIME_USEC, AST_EVENT_IE_PLTYPE_UINT, eventtime.tv_usec,
AST_EVENT_IE_CEL_USEREVENT_NAME, AST_EVENT_IE_PLTYPE_STR, userdefevname,
AST_EVENT_IE_CEL_CIDNAME, AST_EVENT_IE_PLTYPE_STR,
S_COR(ast_channel_caller(chan)->id.name.valid, ast_channel_caller(chan)->id.name.str, ""),
AST_EVENT_IE_CEL_CIDNUM, AST_EVENT_IE_PLTYPE_STR,
S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, ""),
AST_EVENT_IE_CEL_CIDANI, AST_EVENT_IE_PLTYPE_STR,
S_COR(ast_channel_caller(chan)->ani.number.valid, ast_channel_caller(chan)->ani.number.str, ""),
AST_EVENT_IE_CEL_CIDRDNIS, AST_EVENT_IE_PLTYPE_STR,
S_COR(ast_channel_redirecting(chan)->from.number.valid, ast_channel_redirecting(chan)->from.number.str, ""),
AST_EVENT_IE_CEL_CIDDNID, AST_EVENT_IE_PLTYPE_STR,
S_OR(ast_channel_dialed(chan)->number.str, ""),
AST_EVENT_IE_CEL_EXTEN, AST_EVENT_IE_PLTYPE_STR, ast_channel_exten(chan),
AST_EVENT_IE_CEL_CONTEXT, AST_EVENT_IE_PLTYPE_STR, ast_channel_context(chan),
AST_EVENT_IE_CEL_CHANNAME, AST_EVENT_IE_PLTYPE_STR, ast_channel_name(chan),
AST_EVENT_IE_CEL_APPNAME, AST_EVENT_IE_PLTYPE_STR, S_OR(ast_channel_appl(chan), ""),
AST_EVENT_IE_CEL_APPDATA, AST_EVENT_IE_PLTYPE_STR, S_OR(ast_channel_data(chan), ""),
AST_EVENT_IE_CEL_AMAFLAGS, AST_EVENT_IE_PLTYPE_UINT, ast_channel_amaflags(chan),
AST_EVENT_IE_CEL_ACCTCODE, AST_EVENT_IE_PLTYPE_STR, ast_channel_accountcode(chan),
AST_EVENT_IE_CEL_PEERACCT, AST_EVENT_IE_PLTYPE_STR, ast_channel_peeraccount(chan),
AST_EVENT_IE_CEL_UNIQUEID, AST_EVENT_IE_PLTYPE_STR, ast_channel_uniqueid(chan),
AST_EVENT_IE_CEL_LINKEDID, AST_EVENT_IE_PLTYPE_STR, ast_channel_linkedid(chan),
AST_EVENT_IE_CEL_USERFIELD, AST_EVENT_IE_PLTYPE_STR, ast_channel_userfield(chan),
AST_EVENT_IE_CEL_EXTRA, AST_EVENT_IE_PLTYPE_STR, extra,
AST_EVENT_IE_CEL_PEER, AST_EVENT_IE_PLTYPE_STR, peername,
AST_EVENT_IE_END);
ast_channel_unlock(chan);
if (peer) {
peer = ast_channel_unref(peer);
}
if (ev && ast_event_queue(ev)) {
ast_event_destroy(ev);
return -1;
}
return 0;
}
const char *stasis_app_control_get_channel_id(
const struct stasis_app_control *control)
{
return ast_channel_uniqueid(control->channel);
}
struct ast_channel_snapshot *ast_channel_snapshot_create(struct ast_channel *chan)
{
struct ast_channel_snapshot *snapshot;
struct ast_bridge *bridge;
char nativeformats[256];
struct ast_str *write_transpath = ast_str_alloca(256);
struct ast_str *read_transpath = ast_str_alloca(256);
struct ast_party_id effective_connected_id;
struct ast_callid *callid;
/* no snapshots for dummy channels */
if (!ast_channel_tech(chan)) {
return NULL;
}
snapshot = ao2_alloc(sizeof(*snapshot), channel_snapshot_dtor);
if (!snapshot || ast_string_field_init(snapshot, 1024)) {
ao2_cleanup(snapshot);
return NULL;
}
ast_string_field_set(snapshot, name, ast_channel_name(chan));
ast_string_field_set(snapshot, type, ast_channel_tech(chan)->type);
ast_string_field_set(snapshot, accountcode, ast_channel_accountcode(chan));
ast_string_field_set(snapshot, peeraccount, ast_channel_peeraccount(chan));
ast_string_field_set(snapshot, userfield, ast_channel_userfield(chan));
ast_string_field_set(snapshot, uniqueid, ast_channel_uniqueid(chan));
ast_string_field_set(snapshot, linkedid, ast_channel_linkedid(chan));
ast_string_field_set(snapshot, hangupsource, ast_channel_hangupsource(chan));
if (ast_channel_appl(chan)) {
ast_string_field_set(snapshot, appl, ast_channel_appl(chan));
}
if (ast_channel_data(chan)) {
ast_string_field_set(snapshot, data, ast_channel_data(chan));
}
ast_string_field_set(snapshot, context, ast_channel_context(chan));
ast_string_field_set(snapshot, exten, ast_channel_exten(chan));
ast_string_field_set(snapshot, caller_name,
S_COR(ast_channel_caller(chan)->id.name.valid, ast_channel_caller(chan)->id.name.str, ""));
ast_string_field_set(snapshot, caller_number,
S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, ""));
ast_string_field_set(snapshot, caller_dnid, S_OR(ast_channel_dialed(chan)->number.str, ""));
ast_string_field_set(snapshot, caller_subaddr,
S_COR(ast_channel_caller(chan)->id.subaddress.valid, ast_channel_caller(chan)->id.subaddress.str, ""));
ast_string_field_set(snapshot, dialed_subaddr,
S_COR(ast_channel_dialed(chan)->subaddress.valid, ast_channel_dialed(chan)->subaddress.str, ""));
ast_string_field_set(snapshot, caller_ani,
S_COR(ast_channel_caller(chan)->ani.number.valid, ast_channel_caller(chan)->ani.number.str, ""));
ast_string_field_set(snapshot, caller_rdnis,
S_COR(ast_channel_redirecting(chan)->from.number.valid, ast_channel_redirecting(chan)->from.number.str, ""));
ast_string_field_set(snapshot, caller_dnid,
S_OR(ast_channel_dialed(chan)->number.str, ""));
ast_string_field_set(snapshot, connected_name,
S_COR(ast_channel_connected(chan)->id.name.valid, ast_channel_connected(chan)->id.name.str, ""));
ast_string_field_set(snapshot, connected_number,
S_COR(ast_channel_connected(chan)->id.number.valid, ast_channel_connected(chan)->id.number.str, ""));
ast_string_field_set(snapshot, language, ast_channel_language(chan));
if ((bridge = ast_channel_get_bridge(chan))) {
ast_string_field_set(snapshot, bridgeid, bridge->uniqueid);
ao2_cleanup(bridge);
}
ast_string_field_set(snapshot, nativeformats, ast_getformatname_multiple(nativeformats, sizeof(nativeformats),
ast_channel_nativeformats(chan)));
ast_string_field_set(snapshot, readformat, ast_getformatname(ast_channel_readformat(chan)));
ast_string_field_set(snapshot, writeformat, ast_getformatname(ast_channel_writeformat(chan)));
ast_string_field_set(snapshot, writetrans, ast_translate_path_to_str(ast_channel_writetrans(chan), &write_transpath));
ast_string_field_set(snapshot, readtrans, ast_translate_path_to_str(ast_channel_readtrans(chan), &read_transpath));
effective_connected_id = ast_channel_connected_effective_id(chan);
ast_string_field_set(snapshot, effective_name,
S_COR(effective_connected_id.name.valid, effective_connected_id.name.str, ""));
ast_string_field_set(snapshot, effective_number,
S_COR(effective_connected_id.number.valid, effective_connected_id.number.str, ""));
if ((callid = ast_channel_callid(chan))) {
ast_callid_strnprint(snapshot->callid, sizeof(snapshot->callid), callid);
ast_callid_unref(callid);
}
snapshot->creationtime = ast_channel_creationtime(chan);
snapshot->hanguptime = *(ast_channel_whentohangup(chan));
snapshot->state = ast_channel_state(chan);
snapshot->priority = ast_channel_priority(chan);
snapshot->amaflags = ast_channel_amaflags(chan);
snapshot->hangupcause = ast_channel_hangupcause(chan);
ast_copy_flags(&snapshot->flags, ast_channel_flags(chan), 0xFFFFFFFF);
snapshot->caller_pres = ast_party_id_presentation(&ast_channel_caller(chan)->id);
snapshot->callgroup = ast_channel_callgroup(chan);
snapshot->pickupgroup = ast_channel_pickupgroup(chan);
ast_set_flag(&snapshot->softhangup_flags, ast_channel_softhangup_internal_flag(chan));
snapshot->manager_vars = ast_channel_get_manager_vars(chan);
snapshot->channel_vars = ast_channel_get_vars(chan);
snapshot->tech_properties = ast_channel_tech(chan)->properties;
return snapshot;
}
static int func_channel_read(struct ast_channel *chan, const char *function,
char *data, char *buf, size_t len)
{
int ret = 0;
char tmp[512];
struct ast_format_cap *tmpcap;
if (!strcasecmp(data, "audionativeformat")) {
if ((tmpcap = ast_format_cap_get_type(ast_channel_nativeformats(chan), AST_FORMAT_TYPE_AUDIO))) {
ast_copy_string(buf, ast_getformatname_multiple(tmp, sizeof(tmp), tmpcap), len);
tmpcap = ast_format_cap_destroy(tmpcap);
}
} else if (!strcasecmp(data, "videonativeformat")) {
if ((tmpcap = ast_format_cap_get_type(ast_channel_nativeformats(chan), AST_FORMAT_TYPE_VIDEO))) {
ast_copy_string(buf, ast_getformatname_multiple(tmp, sizeof(tmp), tmpcap), len);
tmpcap = ast_format_cap_destroy(tmpcap);
}
} else if (!strcasecmp(data, "audioreadformat")) {
ast_copy_string(buf, ast_getformatname(ast_channel_readformat(chan)), len);
} else if (!strcasecmp(data, "audiowriteformat")) {
ast_copy_string(buf, ast_getformatname(ast_channel_writeformat(chan)), len);
#ifdef CHANNEL_TRACE
} else if (!strcasecmp(data, "trace")) {
ast_channel_lock(chan);
ast_copy_string(buf, ast_channel_trace_is_enabled(chan) ? "1" : "0", len);
ast_channel_unlock(chan);
#endif
} else if (!strcasecmp(data, "tonezone") && ast_channel_zone(chan))
locked_copy_string(chan, buf, ast_channel_zone(chan)->country, len);
else if (!strcasecmp(data, "language"))
locked_copy_string(chan, buf, ast_channel_language(chan), len);
else if (!strcasecmp(data, "musicclass"))
locked_copy_string(chan, buf, ast_channel_musicclass(chan), len);
else if (!strcasecmp(data, "name")) {
locked_copy_string(chan, buf, ast_channel_name(chan), len);
} else if (!strcasecmp(data, "parkinglot"))
locked_copy_string(chan, buf, ast_channel_parkinglot(chan), len);
else if (!strcasecmp(data, "state"))
locked_copy_string(chan, buf, ast_state2str(ast_channel_state(chan)), len);
else if (!strcasecmp(data, "channeltype"))
locked_copy_string(chan, buf, ast_channel_tech(chan)->type, len);
else if (!strcasecmp(data, "accountcode"))
locked_copy_string(chan, buf, ast_channel_accountcode(chan), len);
else if (!strcasecmp(data, "checkhangup")) {
ast_channel_lock(chan);
ast_copy_string(buf, ast_check_hangup(chan) ? "1" : "0", len);
ast_channel_unlock(chan);
} else if (!strcasecmp(data, "peeraccount"))
locked_copy_string(chan, buf, ast_channel_peeraccount(chan), len);
else if (!strcasecmp(data, "hangupsource"))
locked_copy_string(chan, buf, ast_channel_hangupsource(chan), len);
else if (!strcasecmp(data, "appname") && ast_channel_appl(chan))
locked_copy_string(chan, buf, ast_channel_appl(chan), len);
else if (!strcasecmp(data, "appdata") && ast_channel_data(chan))
locked_copy_string(chan, buf, ast_channel_data(chan), len);
else if (!strcasecmp(data, "exten") && ast_channel_data(chan))
locked_copy_string(chan, buf, ast_channel_exten(chan), len);
else if (!strcasecmp(data, "context") && ast_channel_data(chan))
locked_copy_string(chan, buf, ast_channel_context(chan), len);
else if (!strcasecmp(data, "userfield") && ast_channel_data(chan))
locked_copy_string(chan, buf, ast_channel_userfield(chan), len);
else if (!strcasecmp(data, "channame") && ast_channel_data(chan))
locked_copy_string(chan, buf, ast_channel_name(chan), len);
else if (!strcasecmp(data, "linkedid")) {
ast_channel_lock(chan);
if (ast_strlen_zero(ast_channel_linkedid(chan))) {
/* fall back on the channel's uniqueid if linkedid is unset */
ast_copy_string(buf, ast_channel_uniqueid(chan), len);
}
else {
ast_copy_string(buf, ast_channel_linkedid(chan), len);
}
ast_channel_unlock(chan);
} else if (!strcasecmp(data, "peer")) {
struct ast_channel *p;
ast_channel_lock(chan);
p = ast_bridged_channel(chan);
if (p || ast_channel_tech(chan) || ast_channel_cdr(chan)) /* dummy channel? if so, we hid the peer name in the language */
ast_copy_string(buf, (p ? ast_channel_name(p) : ""), len);
else {
/* a dummy channel can still pass along bridged peer info via
the BRIDGEPEER variable */
const char *pname = pbx_builtin_getvar_helper(chan, "BRIDGEPEER");
if (!ast_strlen_zero(pname))
ast_copy_string(buf, pname, len); /* a horrible kludge, but... how else? */
else
buf[0] = 0;
}
ast_channel_unlock(chan);
} else if (!strcasecmp(data, "uniqueid")) {
locked_copy_string(chan, buf, ast_channel_uniqueid(chan), len);
} else if (!strcasecmp(data, "transfercapability")) {
locked_copy_string(chan, buf, transfercapability_table[ast_channel_transfercapability(chan) & 0x1f], len);
} else if (!strcasecmp(data, "callgroup")) {
char groupbuf[256];
locked_copy_string(chan, buf, ast_print_group(groupbuf, sizeof(groupbuf), ast_channel_callgroup(chan)), len);
} else if (!strcasecmp(data, "pickupgroup")) {
char groupbuf[256];
locked_copy_string(chan, buf, ast_print_group(groupbuf, sizeof(groupbuf), ast_channel_pickupgroup(chan)), len);
} else if (!strcasecmp(data, "amaflags")) {
char amabuf[256];
snprintf(amabuf,sizeof(amabuf), "%d", ast_channel_amaflags(chan));
locked_copy_string(chan, buf, amabuf, len);
} else if (!strncasecmp(data, "secure_bridge_", 14)) {
struct ast_datastore *ds;
ast_channel_lock(chan);
if ((ds = ast_channel_datastore_find(chan, &secure_call_info, NULL))) {
struct ast_secure_call_store *encrypt = ds->data;
if (!strcasecmp(data, "secure_bridge_signaling")) {
snprintf(buf, len, "%s", encrypt->signaling ? "1" : "");
} else if (!strcasecmp(data, "secure_bridge_media")) {
snprintf(buf, len, "%s", encrypt->media ? "1" : "");
}
}
ast_channel_unlock(chan);
} else if (!ast_channel_tech(chan) || !ast_channel_tech(chan)->func_channel_read || ast_channel_tech(chan)->func_channel_read(chan, function, data, buf, len)) {
ast_log(LOG_WARNING, "Unknown or unavailable item requested: '%s'\n", data);
ret = -1;
}
return ret;
}
static int t38_tx_packet_handler(t38_core_state_t *s, void *user_data, const uint8_t *buf, int len, int count)
{
struct ast_channel *chan = (struct ast_channel *) user_data;
struct ast_frame outf = {
.frametype = AST_FRAME_MODEM,
.subclass.integer = AST_MODEM_T38,
.src = __FUNCTION__,
};
/* TODO: Asterisk does not provide means of resending the same packet multiple
times so count is ignored at the moment */
AST_FRAME_SET_BUFFER(&outf, buf, 0, len);
if (ast_write(chan, &outf) < 0) {
ast_log(LOG_WARNING, "Unable to write frame to channel; %s\n", strerror(errno));
return -1;
}
return 0;
}
static void phase_e_handler(t30_state_t *f, void *user_data, int result)
{
RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
RAII_VAR(struct ast_json *, json_filenames, NULL, ast_json_unref);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
const char *local_ident;
const char *far_ident;
char buf[20];
fax_session *s = (fax_session *) user_data;
t30_stats_t stat;
int pages_transferred;
ast_debug(1, "Fax phase E handler. result=%d\n", result);
t30_get_transfer_statistics(f, &stat);
s = (fax_session *) user_data;
if (result != T30_ERR_OK) {
s->finished = -1;
/* FAXSTATUS is already set to FAILED */
pbx_builtin_setvar_helper(s->chan, "FAXERROR", t30_completion_code_to_str(result));
ast_log(LOG_WARNING, "Error transmitting fax. result=%d: %s.\n", result, t30_completion_code_to_str(result));
return;
}
s->finished = 1;
local_ident = S_OR(t30_get_tx_ident(f), "");
far_ident = S_OR(t30_get_rx_ident(f), "");
pbx_builtin_setvar_helper(s->chan, "FAXSTATUS", "SUCCESS");
pbx_builtin_setvar_helper(s->chan, "FAXERROR", NULL);
pbx_builtin_setvar_helper(s->chan, "REMOTESTATIONID", far_ident);
#if SPANDSP_RELEASE_DATE >= 20090220
pages_transferred = (s->direction) ? stat.pages_tx : stat.pages_rx;
#else
pages_transferred = stat.pages_transferred;
#endif
snprintf(buf, sizeof(buf), "%d", pages_transferred);
pbx_builtin_setvar_helper(s->chan, "FAXPAGES", buf);
snprintf(buf, sizeof(buf), "%d", stat.y_resolution);
pbx_builtin_setvar_helper(s->chan, "FAXRESOLUTION", buf);
snprintf(buf, sizeof(buf), "%d", stat.bit_rate);
pbx_builtin_setvar_helper(s->chan, "FAXBITRATE", buf);
ast_debug(1, "Fax transmitted successfully.\n");
ast_debug(1, " Remote station ID: %s\n", far_ident);
ast_debug(1, " Pages transferred: %d\n", pages_transferred);
ast_debug(1, " Image resolution: %d x %d\n", stat.x_resolution, stat.y_resolution);
ast_debug(1, " Transfer Rate: %d\n", stat.bit_rate);
json_filenames = ast_json_pack("[s]", s->file_name);
if (!json_filenames) {
return;
}
ast_json_ref(json_filenames);
json_object = ast_json_pack("{s: s, s: s, s: s, s: i, s: i, s: i, s: o}",
"type", s->direction ? "send" : "receive",
"remote_station_id", far_ident,
"local_station_id", local_ident,
"fax_pages", pages_transferred,
"fax_resolution", stat.y_resolution,
"fax_bitrate", stat.bit_rate,
"filenames", json_filenames);
message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(s->chan), ast_channel_fax_type(), json_object);
if (!message) {
return;
}
stasis_publish(ast_channel_topic(s->chan), message);
}
struct ast_channel *stasis_app_control_snoop(struct ast_channel *chan,
enum stasis_app_snoop_direction spy, enum stasis_app_snoop_direction whisper,
const char *app, const char *app_args, const char *snoop_id)
{
RAII_VAR(struct stasis_app_snoop *, snoop, NULL, ao2_cleanup);
struct ast_format_cap *caps;
pthread_t thread;
struct ast_assigned_ids assignedids = {
.uniqueid = snoop_id,
};
if (spy == STASIS_SNOOP_DIRECTION_NONE &&
whisper == STASIS_SNOOP_DIRECTION_NONE) {
return NULL;
}
snoop = ao2_alloc_options(sizeof(*snoop), snoop_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
if (!snoop) {
return NULL;
}
/* Allocate a buffer to store the Stasis application and arguments in */
snoop->app = ast_str_create(64);
if (!snoop->app) {
return NULL;
}
ast_str_set(&snoop->app, 0, "%s", app);
if (!ast_strlen_zero(app_args)) {
ast_str_append(&snoop->app, 0, ",%s", app_args);
}
/* Set up a timer for the Snoop channel so it wakes up at a specific interval */
snoop->timer = ast_timer_open();
if (!snoop->timer) {
return NULL;
}
ast_timer_set_rate(snoop->timer, 1000 / SNOOP_INTERVAL);
/* Determine which signed linear format should be used */
snoop_determine_format(chan, snoop);
/* Allocate a Snoop channel and set up various parameters */
snoop->chan = ast_channel_alloc(1, AST_STATE_UP, "", "", "", "", "", &assignedids, NULL, 0, "Snoop/%s-%08x", ast_channel_uniqueid(chan),
(unsigned)ast_atomic_fetchadd_int((int *)&chan_idx, +1));
if (!snoop->chan) {
return NULL;
}
ast_copy_string(snoop->uniqueid, ast_channel_uniqueid(chan), sizeof(snoop->uniqueid));
/* To keep the channel valid on the Snoop structure until it is destroyed we bump the ref up here */
ast_channel_ref(snoop->chan);
ast_channel_tech_set(snoop->chan, &snoop_tech);
ao2_ref(snoop, +1);
ast_channel_tech_pvt_set(snoop->chan, snoop);
ast_channel_set_fd(snoop->chan, 0, ast_timer_fd(snoop->timer));
/* The format on the Snoop channel will be this signed linear format, and it will never change */
caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
if (!caps) {
ast_channel_unlock(snoop->chan);
ast_hangup(snoop->chan);
return NULL;
}
ast_format_cap_append(caps, snoop->spy_format, 0);
ast_channel_nativeformats_set(snoop->chan, caps);
ao2_ref(caps, -1);
ast_channel_set_writeformat(snoop->chan, snoop->spy_format);
ast_channel_set_rawwriteformat(snoop->chan, snoop->spy_format);
ast_channel_set_readformat(snoop->chan, snoop->spy_format);
ast_channel_set_rawreadformat(snoop->chan, snoop->spy_format);
ast_channel_unlock(snoop->chan);
if (spy != STASIS_SNOOP_DIRECTION_NONE) {
if (snoop_setup_audiohook(chan, AST_AUDIOHOOK_TYPE_SPY, spy, &snoop->spy_direction, &snoop->spy)) {
ast_hangup(snoop->chan);
return NULL;
}
snoop->spy_samples = ast_format_get_sample_rate(snoop->spy_format) / (1000 / SNOOP_INTERVAL);
snoop->spy_active = 1;
}
/* If whispering is enabled set up the audiohook */
if (whisper != STASIS_SNOOP_DIRECTION_NONE) {
if (snoop_setup_audiohook(chan, AST_AUDIOHOOK_TYPE_WHISPER, whisper, &snoop->whisper_direction, &snoop->whisper)) {
ast_hangup(snoop->chan);
return NULL;
}
snoop->whisper_active = 1;
}
/* Create the thread which services the Snoop channel */
ao2_ref(snoop, +1);
if (ast_pthread_create_detached_background(&thread, NULL, snoop_stasis_thread, snoop)) {
ao2_cleanup(snoop);
/* No other thread is servicing this channel so we can immediately hang it up */
ast_hangup(snoop->chan);
return NULL;
}
publish_chanspy_message(snoop, 1);
/* The caller of this has a reference as well */
return ast_channel_ref(snoop->chan);
}
static int record_file(struct stasis_app_control *control,
struct ast_channel *chan, void *data)
{
struct stasis_app_recording *recording = data;
char *acceptdtmf;
int res;
ast_assert(recording != NULL);
if (stasis_app_get_bridge(control)) {
ast_log(LOG_ERROR, "Cannot record channel while in bridge\n");
recording_fail(control, recording, "Cannot record channel while in bridge");
return -1;
}
switch (recording->options->terminate_on) {
case STASIS_APP_RECORDING_TERMINATE_NONE:
case STASIS_APP_RECORDING_TERMINATE_INVALID:
acceptdtmf = "";
break;
case STASIS_APP_RECORDING_TERMINATE_ANY:
acceptdtmf = "#*0123456789abcd";
break;
default:
acceptdtmf = ast_alloca(2);
acceptdtmf[0] = recording->options->terminate_on;
acceptdtmf[1] = '\0';
}
res = ast_auto_answer(chan);
if (res != 0) {
ast_debug(3, "%s: Failed to answer\n",
ast_channel_uniqueid(chan));
recording_fail(control, recording, "Failed to answer channel");
return -1;
}
recording_set_state(
recording, STASIS_APP_RECORDING_STATE_RECORDING, NULL);
ast_play_and_record_full(chan,
NULL, /* playfile */
recording->absolute_name,
recording->options->max_duration_seconds,
recording->options->format,
&recording->duration.total,
recording->options->max_silence_seconds ? &recording->duration.energy_only : NULL,
recording->options->beep,
-1, /* silencethreshold */
recording->options->max_silence_seconds * 1000,
NULL, /* path */
acceptdtmf,
NULL, /* canceldtmf */
1, /* skip_confirmation_sound */
recording->options->if_exists);
ast_debug(3, "%s: Recording complete\n", ast_channel_uniqueid(chan));
recording_set_state(
recording, STASIS_APP_RECORDING_STATE_COMPLETE, NULL);
stasis_app_control_unregister_add_rule(control, &rule_recording);
return 0;
}
static void *record_file(struct stasis_app_control *control,
struct ast_channel *chan, void *data)
{
RAII_VAR(struct stasis_app_recording *, recording,
NULL, recording_cleanup);
char *acceptdtmf;
int res;
int duration = 0;
recording = data;
ast_assert(recording != NULL);
if (stasis_app_get_bridge(control)) {
ast_log(LOG_ERROR, "Cannot record channel while in bridge\n");
recording_fail(recording);
return NULL;
}
switch (recording->options->terminate_on) {
case STASIS_APP_RECORDING_TERMINATE_NONE:
case STASIS_APP_RECORDING_TERMINATE_INVALID:
acceptdtmf = "";
break;
case STASIS_APP_RECORDING_TERMINATE_ANY:
acceptdtmf = "#*0123456789abcd";
break;
default:
acceptdtmf = ast_alloca(2);
acceptdtmf[0] = recording->options->terminate_on;
acceptdtmf[1] = '\0';
}
res = ast_auto_answer(chan);
if (res != 0) {
ast_debug(3, "%s: Failed to answer\n",
ast_channel_uniqueid(chan));
recording_fail(recording);
return NULL;
}
ao2_lock(recording);
recording->state = STASIS_APP_RECORDING_STATE_RECORDING;
recording_publish(recording);
ao2_unlock(recording);
ast_play_and_record_full(chan,
NULL, /* playfile */
recording->absolute_name,
recording->options->max_duration_seconds,
recording->options->format,
&duration,
NULL, /* sound_duration */
recording->options->beep,
-1, /* silencethreshold */
recording->options->max_silence_seconds * 1000,
NULL, /* path */
acceptdtmf,
NULL, /* canceldtmf */
1, /* skip_confirmation_sound */
recording->options->if_exists);
ast_debug(3, "%s: Recording complete\n", ast_channel_uniqueid(chan));
ao2_lock(recording);
recording->state = STASIS_APP_RECORDING_STATE_COMPLETE;
recording_publish(recording);
ao2_unlock(recording);
return NULL;
}
static int manager_park(struct mansession *s, const struct message *m)
{
const char *channel = astman_get_header(m, "Channel");
const char *timeout_channel = S_OR(astman_get_header(m, "TimeoutChannel"), astman_get_header(m, "Channel2"));
const char *announce_channel = astman_get_header(m, "AnnounceChannel");
const char *timeout = astman_get_header(m, "Timeout");
const char *parkinglot = astman_get_header(m, "Parkinglot");
char buf[BUFSIZ];
int timeout_override = -1;
RAII_VAR(struct ast_channel *, parker_chan, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup);
if (ast_strlen_zero(channel)) {
astman_send_error(s, m, "Channel not specified");
return 0;
}
if (!ast_strlen_zero(timeout)) {
if (sscanf(timeout, "%30d", &timeout_override) != 1 || timeout < 0) {
astman_send_error(s, m, "Invalid Timeout value.");
return 0;
}
if (timeout_override > 0) {
/* If greater than zero, convert to seconds for internal use. Must be >= 1 second. */
timeout_override = MAX(1, timeout_override / 1000);
}
}
if (!(chan = ast_channel_get_by_name(channel))) {
snprintf(buf, sizeof(buf), "Channel does not exist: %s", channel);
astman_send_error(s, m, buf);
return 0;
}
ast_channel_lock(chan);
if (!ast_strlen_zero(timeout_channel)) {
ast_bridge_set_transfer_variables(chan, timeout_channel, 0);
}
ast_channel_unlock(chan);
parker_chan = ast_channel_bridge_peer(chan);
if (!parker_chan || strcmp(ast_channel_name(parker_chan), timeout_channel)) {
if (!ast_strlen_zero(announce_channel)) {
struct ast_channel *announce_chan = ast_channel_get_by_name(announce_channel);
if (!announce_channel) {
astman_send_error(s, m, "AnnounceChannel does not exist");
return 0;
}
create_parked_subscription(announce_chan, ast_channel_uniqueid(chan), 0);
ast_channel_cleanup(announce_chan);
}
manager_park_unbridged(s, m, chan, parkinglot, timeout_override);
return 0;
}
if (!ast_strlen_zero(announce_channel) && strcmp(announce_channel, timeout_channel)) {
/* When using an announce_channel in bridge mode, only add the announce channel if it isn't
* the same as the timeout channel (which will play announcements anyway) */
struct ast_channel *announce_chan = ast_channel_get_by_name(announce_channel);
if (!announce_channel) {
astman_send_error(s, m, "AnnounceChannel does not exist");
return 0;
}
create_parked_subscription(announce_chan, ast_channel_uniqueid(chan), 0);
ast_channel_cleanup(announce_chan);
}
manager_park_bridged(s, m, chan, parker_chan, parkinglot, timeout_override);
return 0;
}
/*! \brief Function called when we should prepare to call the destination */
static struct ast_channel *multicast_rtp_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *data, int *cause)
{
char *tmp = ast_strdupa(data), *multicast_type = tmp, *destination, *control;
struct ast_rtp_instance *instance;
struct ast_sockaddr control_address;
struct ast_sockaddr destination_address;
struct ast_channel *chan;
struct ast_format fmt;
ast_best_codec(cap, &fmt);
ast_sockaddr_setnull(&control_address);
/* If no type was given we can't do anything */
if (ast_strlen_zero(multicast_type)) {
goto failure;
}
if (!(destination = strchr(tmp, '/'))) {
goto failure;
}
*destination++ = '\0';
if ((control = strchr(destination, '/'))) {
*control++ = '\0';
if (!ast_sockaddr_parse(&control_address, control,
PARSE_PORT_REQUIRE)) {
goto failure;
}
}
if (!ast_sockaddr_parse(&destination_address, destination,
PARSE_PORT_REQUIRE)) {
goto failure;
}
if (!(instance = ast_rtp_instance_new("multicast", NULL, &control_address, multicast_type))) {
goto failure;
}
if (!(chan = ast_channel_alloc(1, AST_STATE_DOWN, "", "", "", "", "", requestor ? ast_channel_linkedid(requestor) : "", 0, "MulticastRTP/%p", instance))) {
ast_rtp_instance_destroy(instance);
goto failure;
}
ast_rtp_instance_set_channel_id(instance, ast_channel_uniqueid(chan));
ast_rtp_instance_set_remote_address(instance, &destination_address);
ast_channel_tech_set(chan, &multicast_rtp_tech);
ast_format_cap_add(ast_channel_nativeformats(chan), &fmt);
ast_format_copy(ast_channel_writeformat(chan), &fmt);
ast_format_copy(ast_channel_rawwriteformat(chan), &fmt);
ast_format_copy(ast_channel_readformat(chan), &fmt);
ast_format_copy(ast_channel_rawreadformat(chan), &fmt);
ast_channel_tech_pvt_set(chan, instance);
return chan;
failure:
*cause = AST_CAUSE_FAILURE;
return NULL;
}
/*!
* \brief Stop monitoring channel
* \param chan
* \param need_lock
* Stop the recording, close any open streams, mix in/out channels if required
* \return Always 0
*/
int AST_OPTIONAL_API_NAME(ast_monitor_stop)(struct ast_channel *chan, int need_lock)
{
int delfiles = 0;
LOCK_IF_NEEDED(chan, need_lock);
if (ast_channel_monitor(chan)) {
char filename[ FILENAME_MAX ];
if (ast_channel_monitor(chan)->read_stream) {
ast_closestream(ast_channel_monitor(chan)->read_stream);
}
if (ast_channel_monitor(chan)->write_stream) {
ast_closestream(ast_channel_monitor(chan)->write_stream);
}
if (ast_channel_monitor(chan)->filename_changed && !ast_strlen_zero(ast_channel_monitor(chan)->filename_base)) {
if (ast_channel_monitor(chan)->read_stream) {
if (ast_fileexists(ast_channel_monitor(chan)->read_filename,NULL,NULL) > 0) {
snprintf(filename, FILENAME_MAX, "%s-in", ast_channel_monitor(chan)->filename_base);
if (ast_fileexists(filename, NULL, NULL) > 0) {
ast_filedelete(filename, NULL);
}
ast_filerename(ast_channel_monitor(chan)->read_filename, filename, ast_channel_monitor(chan)->format);
} else {
ast_log(LOG_WARNING, "File %s not found\n", ast_channel_monitor(chan)->read_filename);
}
}
if (ast_channel_monitor(chan)->write_stream) {
if (ast_fileexists(ast_channel_monitor(chan)->write_filename,NULL,NULL) > 0) {
snprintf(filename, FILENAME_MAX, "%s-out", ast_channel_monitor(chan)->filename_base);
if (ast_fileexists(filename, NULL, NULL) > 0) {
ast_filedelete(filename, NULL);
}
ast_filerename(ast_channel_monitor(chan)->write_filename, filename, ast_channel_monitor(chan)->format);
} else {
ast_log(LOG_WARNING, "File %s not found\n", ast_channel_monitor(chan)->write_filename);
}
}
}
if (ast_channel_monitor(chan)->joinfiles && !ast_strlen_zero(ast_channel_monitor(chan)->filename_base)) {
char tmp[1024];
char tmp2[1024];
const char *format = !strcasecmp(ast_channel_monitor(chan)->format,"wav49") ? "WAV" : ast_channel_monitor(chan)->format;
char *fname_base = ast_channel_monitor(chan)->filename_base;
const char *execute, *execute_args;
/* at this point, fname_base really is the full path */
/* Set the execute application */
execute = pbx_builtin_getvar_helper(chan, "MONITOR_EXEC");
if (ast_strlen_zero(execute)) {
#ifdef HAVE_SOXMIX
execute = "nice -n 19 soxmix";
#else
execute = "nice -n 19 sox -m";
#endif
format = get_soxmix_format(format);
delfiles = 1;
}
execute_args = pbx_builtin_getvar_helper(chan, "MONITOR_EXEC_ARGS");
if (ast_strlen_zero(execute_args)) {
execute_args = "";
}
snprintf(tmp, sizeof(tmp), "%s \"%s-in.%s\" \"%s-out.%s\" \"%s.%s\" %s &",
execute, fname_base, format, fname_base, format, fname_base, format,execute_args);
if (delfiles) {
snprintf(tmp2,sizeof(tmp2), "( %s& rm -f \"%s-\"* ) &",tmp, fname_base); /* remove legs when done mixing */
ast_copy_string(tmp, tmp2, sizeof(tmp));
}
ast_debug(1,"monitor executing %s\n",tmp);
if (ast_safe_system(tmp) == -1)
ast_log(LOG_WARNING, "Execute of %s failed.\n",tmp);
}
ast_free(ast_channel_monitor(chan)->format);
ast_free(ast_channel_monitor(chan));
ast_channel_monitor_set(chan, NULL);
ast_manager_event(chan, EVENT_FLAG_CALL, "MonitorStop",
"Channel: %s\r\n"
"Uniqueid: %s\r\n",
ast_channel_name(chan),
ast_channel_uniqueid(chan)
);
pbx_builtin_setvar_helper(chan, "MONITORED", NULL);
}
pbx_builtin_setvar_helper(chan, "AUTO_MONITOR", NULL);
UNLOCK_IF_NEEDED(chan, need_lock);
return 0;
}
/*! \internal \brief An audiohook modification callback
*
* This processes the read side of a channel's voice data to see if
* they are talking
*
* \note We don't actually modify the audio, so this function always
* returns a 'failure' indicating that it didn't modify the data
*/
static int talk_detect_audiohook_cb(struct ast_audiohook *audiohook, struct ast_channel *chan, struct ast_frame *frame, enum ast_audiohook_direction direction)
{
int total_silence;
int update_talking = 0;
struct ast_datastore *datastore;
struct talk_detect_params *td_params;
struct stasis_message *message;
if (audiohook->status == AST_AUDIOHOOK_STATUS_DONE) {
return 1;
}
if (direction != AST_AUDIOHOOK_DIRECTION_READ) {
return 1;
}
if (frame->frametype != AST_FRAME_VOICE) {
return 1;
}
if (!(datastore = ast_channel_datastore_find(chan, &talk_detect_datastore, NULL))) {
return 1;
}
td_params = datastore->data;
ast_dsp_silence(td_params->dsp, frame, &total_silence);
if (total_silence < td_params->dsp_silence_threshold) {
if (!td_params->talking) {
update_talking = 1;
td_params->talking_start = ast_tvnow();
}
td_params->talking = 1;
} else {
if (td_params->talking) {
update_talking = 1;
}
td_params->talking = 0;
}
if (update_talking) {
struct ast_json *blob = NULL;
if (!td_params->talking) {
int64_t diff_ms = ast_tvdiff_ms(ast_tvnow(), td_params->talking_start);
diff_ms -= td_params->dsp_silence_threshold;
blob = ast_json_pack("{s: i}", "duration", diff_ms);
if (!blob) {
return 1;
}
}
ast_verb(4, "%s is now %s\n", ast_channel_name(chan),
td_params->talking ? "talking" : "silent");
message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan),
td_params->talking ? ast_channel_talking_start() : ast_channel_talking_stop(),
blob);
if (message) {
stasis_publish(ast_channel_topic(chan), message);
ao2_ref(message, -1);
}
ast_json_unref(blob);
}
return 1;
}
