static int setcallerid_pres_exec(struct ast_channel *chan, const char *data)
{
int pres = -1;
static int deprecated = 0;
if (!deprecated) {
deprecated = 1;
ast_log(LOG_WARNING, "SetCallerPres is deprecated. Please use Set(CALLERPRES()=%s) instead.\n", (char *)data);
}
/* For interface consistency, permit the argument to be specified as a number */
if (sscanf(data, "%30d", &pres) != 1 || pres < 0 || pres > 255 || (pres & 0x9c)) {
pres = ast_parse_caller_presentation(data);
}
if (pres < 0) {
ast_log(LOG_WARNING, "'%s' is not a valid presentation (see 'show application SetCallerPres')\n",
(char *) data);
return 0;
}
/* Set the combined caller id presentation. */
ast_channel_caller(chan)->id.name.presentation = pres;
ast_channel_caller(chan)->id.number.presentation = pres;
return 0;
}
/*
* Write the metadata to the log file
*/
static int write_metadata( FILE *logfile, char *signalling_type, struct ast_channel *chan)
{
int res = 0;
struct timeval t;
struct ast_tm now;
char *cl;
char *cn;
char workstring[80];
char timestamp[80];
/* Extract the caller ID location */
ast_copy_string(workstring,
S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, ""),
sizeof(workstring));
ast_shrink_phone_number(workstring);
if (ast_strlen_zero(workstring)) {
cl = "<unknown>";
} else {
cl = workstring;
}
cn = S_COR(ast_channel_caller(chan)->id.name.valid, ast_channel_caller(chan)->id.name.str, "<unknown>");
/* Get the current time */
t = ast_tvnow();
ast_localtime(&t, &now, NULL);
/* Format the time */
ast_strftime(timestamp, sizeof(timestamp), time_stamp_format, &now);
res = fprintf(logfile, "\n\n[metadata]\n\n");
if (res >= 0) {
res = fprintf(logfile, "PROTOCOL=%s\n", signalling_type);
}
if (res >= 0) {
res = fprintf(logfile, "CALLINGFROM=%s\n", cl);
}
if (res >= 0) {
res = fprintf(logfile, "CALLERNAME=%s\n", cn);
}
if (res >= 0) {
res = fprintf(logfile, "TIMESTAMP=%s\n\n", timestamp);
}
if (res >= 0) {
res = fprintf(logfile, "[events]\n\n");
}
if (res < 0) {
ast_verb(3, "AlarmReceiver: can't write metadata\n");
ast_debug(1,"AlarmReceiver: can't write metadata\n");
} else {
res = 0;
}
return res;
}
/*!
* \brief Write metadata to log file
*
* \param logfile Log File Pointer
* \param signalling_type Signaling Type
* \param chan Asterisk Channel
* \param no_checksum Expecting messages without checksum
*
* \retval 0 success
* \retval -1 failure
*/
static int write_metadata(FILE *logfile, char *signalling_type, struct ast_channel *chan, int no_checksum)
{
struct timeval t;
struct ast_tm now;
char *cl;
char *cn;
char workstring[80];
char timestamp[80];
/* Extract the caller ID location */
ast_copy_string(workstring,
S_COR(ast_channel_caller(chan)->id.number.valid,
ast_channel_caller(chan)->id.number.str, ""), sizeof(workstring));
ast_shrink_phone_number(workstring);
if (ast_strlen_zero(workstring)) {
cl = "<unknown>";
} else {
cl = workstring;
}
cn = S_COR(ast_channel_caller(chan)->id.name.valid,
ast_channel_caller(chan)->id.name.str, "<unknown>");
/* Get the current time */
t = ast_tvnow();
ast_localtime(&t, &now, NULL);
/* Format the time */
ast_strftime(timestamp, sizeof(timestamp), time_stamp_format, &now);
if (no_group_meta && fprintf(logfile, "PROTOCOL=%s\n"
"CHECKSUM=%s\n"
"CALLINGFROM=%s\n"
"CALLERNAME=%s\n"
"TIMESTAMP=%s\n\n",
signalling_type, (!no_checksum) ? "yes" : "no", cl, cn, timestamp) > -1) {
return 0;
} else if (fprintf(logfile, "\n\n[metadata]\n\n"
"PROTOCOL=%s\n"
"CHECKSUM=%s\n"
"CALLINGFROM=%s\n"
"CALLERNAME=%s\n"
"TIMESTAMP=%s\n\n"
"[events]\n\n",
signalling_type, (!no_checksum) ? "yes" : "no", cl, cn, timestamp) > -1) {
return 0;
}
ast_verb(3, "AlarmReceiver: can't write metadata\n");
ast_debug(1, "AlarmReceiver: can't write metadata\n");
return -1;
}
static int find_matching_endwhile(struct ast_channel *chan)
{
struct ast_context *c;
int res=-1;
if (ast_rdlock_contexts()) {
ast_log(LOG_ERROR, "Failed to lock contexts list\n");
return -1;
}
for (c=ast_walk_contexts(NULL); c; c=ast_walk_contexts(c)) {
struct ast_exten *e;
if (!ast_rdlock_context(c)) {
if (!strcmp(ast_get_context_name(c), ast_channel_context(chan))) {
/* This is the matching context we want */
int cur_priority = ast_channel_priority(chan) + 1, level=1;
for (e = find_matching_priority(c, ast_channel_exten(chan), cur_priority,
S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL));
e;
e = find_matching_priority(c, ast_channel_exten(chan), ++cur_priority,
S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL))) {
if (!strcasecmp(ast_get_extension_app(e), "WHILE")) {
level++;
} else if (!strcasecmp(ast_get_extension_app(e), "ENDWHILE")) {
level--;
}
if (level == 0) {
res = cur_priority;
break;
}
}
}
ast_unlock_context(c);
if (res > 0) {
break;
}
}
}
ast_unlock_contexts();
return res;
}
/*!
* \internal
* \brief Helper function that creates an outgoing channel and returns it immediately. This function is nearly
* identical to the dial_transfer function in bridge_basic.c, however it doesn't swap the
* local channel and the channel that instigated the park.
*/
static struct ast_channel *park_local_transfer(struct ast_channel *parker, const char *context, const char *exten, struct transfer_channel_data *parked_channel_data)
{
char destination[AST_MAX_EXTENSION + AST_MAX_CONTEXT + 1];
struct ast_channel *parkee;
struct ast_channel *parkee_side_2;
int cause;
/* Fill the variable with the extension and context we want to call */
snprintf(destination, sizeof(destination), "%s@%s", exten, context);
/* Now we request that chan_local prepare to call the destination */
parkee = ast_request("Local", ast_channel_nativeformats(parker), NULL, parker, destination,
&cause);
if (!parkee) {
return NULL;
}
/* Before we actually dial out let's inherit appropriate information. */
ast_channel_lock_both(parker, parkee);
ast_channel_req_accountcodes(parkee, parker, AST_CHANNEL_REQUESTOR_REPLACEMENT);
ast_connected_line_copy_from_caller(ast_channel_connected(parkee), ast_channel_caller(parker));
ast_channel_inherit_variables(parker, parkee);
ast_channel_datastore_inherit(parker, parkee);
ast_channel_unlock(parker);
parkee_side_2 = ast_local_get_peer(parkee);
ast_assert(parkee_side_2 != NULL);
ast_channel_unlock(parkee);
/* We need to have the parker subscribe to the new local channel before hand. */
if (create_parked_subscription_full(parker, ast_channel_uniqueid(parkee_side_2), 1, parked_channel_data)) {
ast_channel_unref(parkee_side_2);
ast_hangup(parkee);
return NULL;
}
ast_bridge_set_transfer_variables(parkee_side_2, ast_channel_name(parker), 0);
ast_channel_unref(parkee_side_2);
/* Since the above worked fine now we actually call it and return the channel */
if (ast_call(parkee, destination, 0)) {
ast_hangup(parkee);
return NULL;
}
return parkee;
}
/*!
* \internal
* \brief Queue a connected line update on a session's channel.
* \param session The session whose channel should have the connected line update queued upon.
* \param id The identification information to place in the connected line update
*/
static void queue_connected_line_update(struct ast_sip_session *session, const struct ast_party_id *id)
{
struct ast_party_connected_line connected;
struct ast_party_caller caller;
/* Fill connected line information */
ast_party_connected_line_init(&connected);
connected.id = *id;
connected.id.tag = session->endpoint->id.self.tag;
connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
/* Save to channel driver copy */
ast_party_id_copy(&session->id, &connected.id);
/* Update our channel CALLERID() */
ast_party_caller_init(&caller);
caller.id = connected.id;
caller.ani = connected.id;
caller.ani2 = ast_channel_caller(session->channel)->ani2;
ast_channel_set_caller_event(session->channel, &caller, NULL);
/* Tell peer about the new connected line information. */
ast_channel_queue_connected_line_update(session->channel, &connected, NULL);
}
static int blacklist_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
{
char blacklist[1];
int bl = 0;
if (!chan) {
ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
return -1;
}
if (ast_channel_caller(chan)->id.number.valid && ast_channel_caller(chan)->id.number.str) {
if (!ast_db_get("blacklist", ast_channel_caller(chan)->id.number.str, blacklist, sizeof (blacklist)))
bl = 1;
}
if (ast_channel_caller(chan)->id.name.valid && ast_channel_caller(chan)->id.name.str) {
if (!ast_db_get("blacklist", ast_channel_caller(chan)->id.name.str, blacklist, sizeof (blacklist)))
bl = 1;
}
snprintf(buf, len, "%d", bl);
return 0;
}
{
struct chan_oss_pvt *o = ast_channel_tech_pvt(c);
struct ast_frame f = { AST_FRAME_CONTROL, };
AST_DECLARE_APP_ARGS(args,
AST_APP_ARG(name);
AST_APP_ARG(flags);
);
char *parse = ast_strdupa(dest);
AST_NONSTANDARD_APP_ARGS(args, parse, '/');
ast_verbose(" << Call to device '%s' dnid '%s' rdnis '%s' on console from '%s' <%s> >>\n",
dest,
S_OR(ast_channel_dialed(c)->number.str, ""),
S_COR(ast_channel_redirecting(c)->from.number.valid, ast_channel_redirecting(c)->from.number.str, ""),
S_COR(ast_channel_caller(c)->id.name.valid, ast_channel_caller(c)->id.name.str, ""),
S_COR(ast_channel_caller(c)->id.number.valid, ast_channel_caller(c)->id.number.str, ""));
if (!ast_strlen_zero(args.flags) && strcasecmp(args.flags, "answer") == 0) {
f.subclass.integer = AST_CONTROL_ANSWER;
ast_queue_frame(c, &f);
} else if (!ast_strlen_zero(args.flags) && strcasecmp(args.flags, "noanswer") == 0) {
f.subclass.integer = AST_CONTROL_RINGING;
ast_queue_frame(c, &f);
ast_indicate(c, AST_CONTROL_RINGING);
} else if (o->autoanswer) {
ast_verbose(" << Auto-answered >> \n");
f.subclass.integer = AST_CONTROL_ANSWER;
ast_queue_frame(c, &f);
o->hookstate = 1;
} else {
ast_verbose("<< Type 'answer' to answer, or use 'autoanswer' for future calls >> \n");
static void start_automixmonitor(struct ast_bridge_channel *bridge_channel, struct ast_channel *peer_chan, struct ast_features_general_config *features_cfg, const char *start_message)
{
char *touch_filename;
size_t len;
int x;
enum set_touch_variables_res set_touch_res;
RAII_VAR(char *, touch_format, NULL, ast_free);
RAII_VAR(char *, touch_monitor, NULL, ast_free);
RAII_VAR(char *, touch_monitor_prefix, NULL, ast_free);
set_touch_res = set_touch_variables(bridge_channel->chan, 1, &touch_format,
&touch_monitor, &touch_monitor_prefix);
switch (set_touch_res) {
case SET_TOUCH_SUCCESS:
break;
case SET_TOUCH_UNSET:
set_touch_res = set_touch_variables(peer_chan, 1, &touch_format, &touch_monitor,
&touch_monitor_prefix);
if (set_touch_res == SET_TOUCH_ALLOC_FAILURE) {
return;
}
break;
case SET_TOUCH_ALLOC_FAILURE:
return;
}
if (!ast_strlen_zero(touch_monitor)) {
len = strlen(touch_monitor) + 50;
touch_filename = ast_alloca(len);
snprintf(touch_filename, len, "%s-%ld-%s.%s",
S_OR(touch_monitor_prefix, "auto"),
(long) time(NULL),
touch_monitor,
S_OR(touch_format, "wav"));
} else {
char *caller_chan_id;
char *peer_chan_id;
caller_chan_id = ast_strdupa(S_COR(ast_channel_caller(bridge_channel->chan)->id.number.valid,
ast_channel_caller(bridge_channel->chan)->id.number.str, ast_channel_name(bridge_channel->chan)));
peer_chan_id = ast_strdupa(S_COR(ast_channel_caller(peer_chan)->id.number.valid,
ast_channel_caller(peer_chan)->id.number.str, ast_channel_name(peer_chan)));
len = strlen(caller_chan_id) + strlen(peer_chan_id) + 50;
touch_filename = ast_alloca(len);
snprintf(touch_filename, len, "%s-%ld-%s-%s.%s",
S_OR(touch_monitor_prefix, "auto"),
(long) time(NULL),
caller_chan_id,
peer_chan_id,
S_OR(touch_format, "wav"));
}
for (x = 0; x < strlen(touch_filename); x++) {
if (touch_filename[x] == '/') {
touch_filename[x] = '-';
}
}
ast_verb(3, "AutoMixMonitor used to record call. Filename: %s\n", touch_filename);
if (ast_start_mixmonitor(peer_chan, touch_filename, "b")) {
ast_verb(3, "automixmon feature was tried by '%s' but mixmonitor failed to start.\n",
ast_channel_name(bridge_channel->chan));
if (features_cfg && !ast_strlen_zero(features_cfg->recordingfailsound)) {
ast_bridge_channel_queue_playfile(bridge_channel, NULL, features_cfg->recordingfailsound, NULL);
}
return;
}
if (features_cfg && !ast_strlen_zero(features_cfg->courtesytone)) {
ast_bridge_channel_queue_playfile(bridge_channel, NULL, features_cfg->courtesytone, NULL);
ast_bridge_channel_write_playfile(bridge_channel, NULL, features_cfg->courtesytone, NULL);
}
if (!ast_strlen_zero(start_message)) {
ast_bridge_channel_queue_playfile(bridge_channel, NULL, start_message, NULL);
ast_bridge_channel_write_playfile(bridge_channel, NULL, start_message, NULL);
}
pbx_builtin_setvar_helper(peer_chan, "TOUCH_MIXMONITOR_OUTPUT", touch_filename);
}
int maxWaitTimeForFrame = dfltMaxWaitTimeForFrame;
AST_DECLARE_APP_ARGS(args,
AST_APP_ARG(argInitialSilence);
AST_APP_ARG(argGreeting);
AST_APP_ARG(argAfterGreetingSilence);
AST_APP_ARG(argTotalAnalysisTime);
AST_APP_ARG(argMinimumWordLength);
AST_APP_ARG(argBetweenWordsSilence);
AST_APP_ARG(argMaximumNumberOfWords);
AST_APP_ARG(argSilenceThreshold);
AST_APP_ARG(argMaximumWordLength);
);
ast_verb(3, "AMD: %s %s %s (Fmt: %s)\n", ast_channel_name(chan),
S_COR(ast_channel_caller(chan)->ani.number.valid, ast_channel_caller(chan)->ani.number.str, "(N/A)"),
S_COR(ast_channel_redirecting(chan)->from.number.valid, ast_channel_redirecting(chan)->from.number.str, "(N/A)"),
ast_format_get_name(ast_channel_readformat(chan)));
/* Lets parse the arguments. */
if (!ast_strlen_zero(parse)) {
/* Some arguments have been passed. Lets parse them and overwrite the defaults. */
AST_STANDARD_APP_ARGS(args, parse);
if (!ast_strlen_zero(args.argInitialSilence))
initialSilence = atoi(args.argInitialSilence);
if (!ast_strlen_zero(args.argGreeting))
greeting = atoi(args.argGreeting);
if (!ast_strlen_zero(args.argAfterGreetingSilence))
afterGreetingSilence = atoi(args.argAfterGreetingSilence);
if (!ast_strlen_zero(args.argTotalAnalysisTime))
totalAnalysisTime = atoi(args.argTotalAnalysisTime);
/*!
* \internal
* \brief Handle COLP and redirecting conditions.
* \since 12.0.0
*
* \param p Unreal private structure.
* \param ast Channel indicating the condition.
* \param condition What is being indicated.
*
* \retval 0 on success.
* \retval -1 on error.
*/
static int unreal_colp_redirect_indicate(struct ast_unreal_pvt *p, struct ast_channel *ast, int condition)
{
struct ast_channel *my_chan;
struct ast_channel *my_owner;
struct ast_channel *this_channel;
struct ast_channel *the_other_channel;
int isoutbound;
int res = 0;
unsigned char frame_data[1024];
struct ast_frame f = {
.frametype = AST_FRAME_CONTROL,
.subclass.integer = condition,
.data.ptr = frame_data,
};
/*
* A connected line update frame may only contain a partial
* amount of data, such as just a source, or just a ton, and not
* the full amount of information. However, the collected
* information is all stored in the outgoing channel's
* connectedline structure, so when receiving a connected line
* update on an outgoing unreal channel, we need to transmit the
* collected connected line information instead of whatever
* happens to be in this control frame. The same applies for
* redirecting information, which is why it is handled here as
* well.
*/
ast_channel_unlock(ast);
ast_unreal_lock_all(p, &my_chan, &my_owner);
isoutbound = AST_UNREAL_IS_OUTBOUND(ast, p);
if (isoutbound) {
this_channel = p->chan;
the_other_channel = p->owner;
} else {
this_channel = p->owner;
the_other_channel = p->chan;
}
if (the_other_channel) {
if (condition == AST_CONTROL_CONNECTED_LINE) {
ast_connected_line_copy_to_caller(ast_channel_caller(the_other_channel),
ast_channel_connected(this_channel));
f.datalen = ast_connected_line_build_data(frame_data, sizeof(frame_data),
ast_channel_connected(this_channel), NULL);
} else {
f.datalen = ast_redirecting_build_data(frame_data, sizeof(frame_data),
ast_channel_redirecting(this_channel), NULL);
}
}
if (my_chan) {
ast_channel_unlock(my_chan);
ast_channel_unref(my_chan);
}
if (my_owner) {
ast_channel_unlock(my_owner);
ast_channel_unref(my_owner);
}
if (the_other_channel) {
res = unreal_queue_frame(p, isoutbound, &f, ast, 0);
}
ao2_unlock(p);
ast_channel_lock(ast);
return res;
}
int ast_unreal_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
{
struct ast_unreal_pvt *p = ast_channel_tech_pvt(ast);
int res = 0;
if (!p) {
return -1;
}
ao2_ref(p, 1); /* ref for unreal_queue_frame */
switch (condition) {
case AST_CONTROL_CONNECTED_LINE:
case AST_CONTROL_REDIRECTING:
res = unreal_colp_redirect_indicate(p, ast, condition);
break;
case AST_CONTROL_HOLD:
if (ast_test_flag(p, AST_UNREAL_MOH_INTERCEPT)) {
ast_moh_start(ast, data, NULL);
break;
}
res = unreal_queue_indicate(p, ast, condition, data, datalen);
break;
case AST_CONTROL_UNHOLD:
if (ast_test_flag(p, AST_UNREAL_MOH_INTERCEPT)) {
ast_moh_stop(ast);
break;
}
res = unreal_queue_indicate(p, ast, condition, data, datalen);
break;
default:
res = unreal_queue_indicate(p, ast, condition, data, datalen);
break;
}
ao2_ref(p, -1);
return res;
}
int ast_unreal_digit_begin(struct ast_channel *ast, char digit)
{
struct ast_unreal_pvt *p = ast_channel_tech_pvt(ast);
int res = -1;
struct ast_frame f = { AST_FRAME_DTMF_BEGIN, };
int isoutbound;
if (!p) {
return -1;
}
ao2_ref(p, 1); /* ref for unreal_queue_frame */
ao2_lock(p);
isoutbound = AST_UNREAL_IS_OUTBOUND(ast, p);
f.subclass.integer = digit;
res = unreal_queue_frame(p, isoutbound, &f, ast, 0);
ao2_unlock(p);
ao2_ref(p, -1);
return res;
}
int ast_unreal_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
{
struct ast_unreal_pvt *p = ast_channel_tech_pvt(ast);
int res = -1;
struct ast_frame f = { AST_FRAME_DTMF_END, };
int isoutbound;
if (!p) {
return -1;
}
ao2_ref(p, 1); /* ref for unreal_queue_frame */
ao2_lock(p);
isoutbound = AST_UNREAL_IS_OUTBOUND(ast, p);
f.subclass.integer = digit;
f.len = duration;
res = unreal_queue_frame(p, isoutbound, &f, ast, 0);
ao2_unlock(p);
ao2_ref(p, -1);
return res;
}
int ast_unreal_sendtext(struct ast_channel *ast, const char *text)
{
struct ast_unreal_pvt *p = ast_channel_tech_pvt(ast);
int res = -1;
struct ast_frame f = { AST_FRAME_TEXT, };
int isoutbound;
if (!p) {
return -1;
}
ao2_ref(p, 1); /* ref for unreal_queue_frame */
ao2_lock(p);
isoutbound = AST_UNREAL_IS_OUTBOUND(ast, p);
f.data.ptr = (char *) text;
f.datalen = strlen(text) + 1;
res = unreal_queue_frame(p, isoutbound, &f, ast, 0);
ao2_unlock(p);
ao2_ref(p, -1);
return res;
}
int ast_unreal_sendhtml(struct ast_channel *ast, int subclass, const char *data, int datalen)
{
struct ast_unreal_pvt *p = ast_channel_tech_pvt(ast);
int res = -1;
struct ast_frame f = { AST_FRAME_HTML, };
int isoutbound;
if (!p) {
return -1;
}
ao2_ref(p, 1); /* ref for unreal_queue_frame */
ao2_lock(p);
isoutbound = AST_UNREAL_IS_OUTBOUND(ast, p);
f.subclass.integer = subclass;
f.data.ptr = (char *)data;
f.datalen = datalen;
res = unreal_queue_frame(p, isoutbound, &f, ast, 0);
ao2_unlock(p);
ao2_ref(p, -1);
return res;
}
void ast_unreal_call_setup(struct ast_channel *semi1, struct ast_channel *semi2)
{
struct ast_var_t *varptr;
struct ast_var_t *clone_var;
/*
* Note that cid_num and cid_name aren't passed in the
* ast_channel_alloc calls in ast_unreal_new_channels(). It's
* done here instead.
*/
ast_party_redirecting_copy(ast_channel_redirecting(semi2), ast_channel_redirecting(semi1));
ast_party_dialed_copy(ast_channel_dialed(semi2), ast_channel_dialed(semi1));
ast_connected_line_copy_to_caller(ast_channel_caller(semi2), ast_channel_connected(semi1));
ast_connected_line_copy_from_caller(ast_channel_connected(semi2), ast_channel_caller(semi1));
ast_channel_language_set(semi2, ast_channel_language(semi1));
ast_channel_accountcode_set(semi2, ast_channel_accountcode(semi1));
ast_channel_musicclass_set(semi2, ast_channel_musicclass(semi1));
ast_channel_cc_params_init(semi2, ast_channel_get_cc_config_params(semi1));
/*
* Make sure we inherit the AST_CAUSE_ANSWERED_ELSEWHERE if it's
* set on the queue/dial call request in the dialplan.
*/
if (ast_channel_hangupcause(semi1) == AST_CAUSE_ANSWERED_ELSEWHERE) {
ast_channel_hangupcause_set(semi2, AST_CAUSE_ANSWERED_ELSEWHERE);
}
/*
* Copy the channel variables from the semi1 channel to the
* outgoing channel.
*
* Note that due to certain assumptions, they MUST be in the
* same order.
*/
AST_LIST_TRAVERSE(ast_channel_varshead(semi1), varptr, entries) {
clone_var = ast_var_assign(varptr->name, varptr->value);
if (clone_var) {
AST_LIST_INSERT_TAIL(ast_channel_varshead(semi2), clone_var, entries);
}
}
ast_channel_datastore_inherit(semi1, semi2);
}
/*! \brief Initiate new call, part of PBX interface
* dest is the dial string */
static int local_call(struct ast_channel *ast, const char *dest, int timeout)
{
struct local_pvt *p = ast_channel_tech_pvt(ast);
int pvt_locked = 0;
struct ast_channel *owner = NULL;
struct ast_channel *chan = NULL;
int res;
char *reduced_dest = ast_strdupa(dest);
char *slash;
const char *chan_cid;
if (!p) {
return -1;
}
/* since we are letting go of channel locks that were locked coming into
* this function, then we need to give the tech pvt a ref */
ao2_ref(p, 1);
ast_channel_unlock(ast);
ast_unreal_lock_all(&p->base, &chan, &owner);
pvt_locked = 1;
if (owner != ast) {
res = -1;
goto return_cleanup;
}
if (!owner || !chan) {
res = -1;
goto return_cleanup;
}
ast_unreal_call_setup(owner, chan);
/*
* If the local channel has /n on the end of it, we need to lop
* that off for our argument to setting up the CC_INTERFACES
* variable.
*/
if ((slash = strrchr(reduced_dest, '/'))) {
*slash = '\0';
}
ast_set_cc_interfaces_chanvar(chan, reduced_dest);
ao2_unlock(p);
pvt_locked = 0;
ast_channel_unlock(owner);
chan_cid = S_COR(ast_channel_caller(chan)->id.number.valid,
ast_channel_caller(chan)->id.number.str, NULL);
if (chan_cid) {
chan_cid = ast_strdupa(chan_cid);
}
ast_channel_unlock(chan);
res = -1;
switch (p->type) {
case LOCAL_CALL_ACTION_DIALPLAN:
if (!ast_exists_extension(NULL, p->context, p->exten, 1, chan_cid)) {
ast_log(LOG_NOTICE, "No such extension/context %s@%s while calling Local channel\n",
p->exten, p->context);
} else {
publish_local_bridge_message(p);
/* Start switch on sub channel */
res = ast_pbx_start(chan);
}
break;
case LOCAL_CALL_ACTION_BRIDGE:
publish_local_bridge_message(p);
ast_answer(chan);
res = ast_bridge_impart(p->action.bridge.join, chan, p->action.bridge.swap,
p->action.bridge.features, AST_BRIDGE_IMPART_CHAN_INDEPENDENT);
ao2_ref(p->action.bridge.join, -1);
p->action.bridge.join = NULL;
ao2_cleanup(p->action.bridge.swap);
p->action.bridge.swap = NULL;
p->action.bridge.features = NULL;
break;
case LOCAL_CALL_ACTION_MASQUERADE:
publish_local_bridge_message(p);
ast_answer(chan);
res = ast_channel_move(p->action.masq, chan);
if (!res) {
/* Chan is now an orphaned zombie. Destroy it. */
ast_hangup(chan);
}
p->action.masq = ast_channel_unref(p->action.masq);
break;
}
if (!res) {
ao2_lock(p);
ast_set_flag(&p->base, AST_UNREAL_CARETAKER_THREAD);
ao2_unlock(p);
}
/* we already unlocked them, clear them here so the cleanup label won't touch them. */
owner = ast_channel_unref(owner);
chan = ast_channel_unref(chan);
return_cleanup:
if (p) {
if (pvt_locked) {
ao2_unlock(p);
}
ao2_ref(p, -1);
}
if (chan) {
ast_channel_unlock(chan);
ast_channel_unref(chan);
}
/*
* owner is supposed to be == to ast, if it is, don't unlock it
* because ast must exit locked
*/
if (owner) {
if (owner != ast) {
ast_channel_unlock(owner);
ast_channel_lock(ast);
}
ast_channel_unref(owner);
} else {
/* we have to exit with ast locked */
ast_channel_lock(ast);
}
return res;
}
/*!
* \internal
* \note This function assumes that we're only called from the "outbound" local channel side
*
* \note it is assummed p is locked and reffed before entering this function
*/
static void check_bridge(struct ast_channel *ast, struct local_pvt *p)
{
struct ast_channel *owner;
struct ast_channel *chan;
struct ast_channel *bridged_chan;
struct ast_frame *f;
/* Do a few conditional checks early on just to see if this optimization is possible */
if (ast_test_flag(p, LOCAL_NO_OPTIMIZATION | LOCAL_ALREADY_MASQED)
|| !p->chan || !p->owner) {
return;
}
/* Safely get the channel bridged to p->chan */
chan = ast_channel_ref(p->chan);
ao2_unlock(p); /* don't call bridged channel with the pvt locked */
bridged_chan = ast_bridged_channel(chan);
ao2_lock(p);
chan = ast_channel_unref(chan);
/* since we had to unlock p to get the bridged chan, validate our
* data once again and verify the bridged channel is what we expect
* it to be in order to perform this optimization */
if (ast_test_flag(p, LOCAL_NO_OPTIMIZATION | LOCAL_ALREADY_MASQED)
|| !p->chan || !p->owner
|| (ast_channel_internal_bridged_channel(p->chan) != bridged_chan)) {
return;
}
/* only do the masquerade if we are being called on the outbound channel,
if it has been bridged to another channel and if there are no pending
frames on the owner channel (because they would be transferred to the
outbound channel during the masquerade)
*/
if (!ast_channel_internal_bridged_channel(p->chan) /* Not ast_bridged_channel! Only go one step! */
|| !AST_LIST_EMPTY(ast_channel_readq(p->owner))
|| ast != p->chan /* Sanity check (should always be false) */) {
return;
}
/* Masquerade bridged channel into owner */
/* Lock everything we need, one by one, and give up if
we can't get everything. Remember, we'll get another
chance in just a little bit */
if (ast_channel_trylock(ast_channel_internal_bridged_channel(p->chan))) {
return;
}
if (ast_check_hangup(ast_channel_internal_bridged_channel(p->chan))
|| ast_channel_trylock(p->owner)) {
ast_channel_unlock(ast_channel_internal_bridged_channel(p->chan));
return;
}
/*
* At this point we have 4 locks:
* p, p->chan (same as ast), p->chan->_bridge, p->owner
*
* Flush a voice or video frame on the outbound channel to make
* the queue empty faster so we can get optimized out.
*/
f = AST_LIST_FIRST(ast_channel_readq(p->chan));
if (f && (f->frametype == AST_FRAME_VOICE || f->frametype == AST_FRAME_VIDEO)) {
AST_LIST_REMOVE_HEAD(ast_channel_readq(p->chan), frame_list);
ast_frfree(f);
f = AST_LIST_FIRST(ast_channel_readq(p->chan));
}
if (f
|| ast_check_hangup(p->owner)
|| ast_channel_masquerade(p->owner, ast_channel_internal_bridged_channel(p->chan))) {
ast_channel_unlock(p->owner);
ast_channel_unlock(ast_channel_internal_bridged_channel(p->chan));
return;
}
/* Masquerade got setup. */
ast_debug(4, "Masquerading %s <- %s\n",
ast_channel_name(p->owner),
ast_channel_name(ast_channel_internal_bridged_channel(p->chan)));
if (ast_channel_monitor(p->owner)
&& !ast_channel_monitor(ast_channel_internal_bridged_channel(p->chan))) {
struct ast_channel_monitor *tmp;
/* If a local channel is being monitored, we don't want a masquerade
* to cause the monitor to go away. Since the masquerade swaps the monitors,
* pre-swapping the monitors before the masquerade will ensure that the monitor
* ends up where it is expected.
*/
tmp = ast_channel_monitor(p->owner);
ast_channel_monitor_set(p->owner, ast_channel_monitor(ast_channel_internal_bridged_channel(p->chan)));
ast_channel_monitor_set(ast_channel_internal_bridged_channel(p->chan), tmp);
}
if (ast_channel_audiohooks(p->chan)) {
struct ast_audiohook_list *audiohooks_swapper;
audiohooks_swapper = ast_channel_audiohooks(p->chan);
ast_channel_audiohooks_set(p->chan, ast_channel_audiohooks(p->owner));
ast_channel_audiohooks_set(p->owner, audiohooks_swapper);
}
/* If any Caller ID was set, preserve it after masquerade like above. We must check
* to see if Caller ID was set because otherwise we'll mistakingly copy info not
* set from the dialplan and will overwrite the real channel Caller ID. The reason
* for this whole preswapping action is because the Caller ID is set on the channel
* thread (which is the to be masqueraded away local channel) before both local
* channels are optimized away.
*/
if (ast_channel_caller(p->owner)->id.name.valid || ast_channel_caller(p->owner)->id.number.valid
|| ast_channel_caller(p->owner)->id.subaddress.valid || ast_channel_caller(p->owner)->ani.name.valid
|| ast_channel_caller(p->owner)->ani.number.valid || ast_channel_caller(p->owner)->ani.subaddress.valid) {
SWAP(*ast_channel_caller(p->owner), *ast_channel_caller(ast_channel_internal_bridged_channel(p->chan)));
}
if (ast_channel_redirecting(p->owner)->from.name.valid || ast_channel_redirecting(p->owner)->from.number.valid
|| ast_channel_redirecting(p->owner)->from.subaddress.valid || ast_channel_redirecting(p->owner)->to.name.valid
|| ast_channel_redirecting(p->owner)->to.number.valid || ast_channel_redirecting(p->owner)->to.subaddress.valid) {
SWAP(*ast_channel_redirecting(p->owner), *ast_channel_redirecting(ast_channel_internal_bridged_channel(p->chan)));
}
if (ast_channel_dialed(p->owner)->number.str || ast_channel_dialed(p->owner)->subaddress.valid) {
SWAP(*ast_channel_dialed(p->owner), *ast_channel_dialed(ast_channel_internal_bridged_channel(p->chan)));
}
ast_app_group_update(p->chan, p->owner);
ast_set_flag(p, LOCAL_ALREADY_MASQED);
ast_channel_unlock(p->owner);
ast_channel_unlock(ast_channel_internal_bridged_channel(p->chan));
/* Do the masquerade now. */
owner = ast_channel_ref(p->owner);
ao2_unlock(p);
ast_channel_unlock(ast);
ast_do_masquerade(owner);
ast_channel_unref(owner);
ast_channel_lock(ast);
ao2_lock(p);
}
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;
}
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_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 _macro_exec(struct ast_channel *chan, const char *data, int exclusive)
{
const char *s;
char *tmp;
char *cur, *rest;
char *macro;
char fullmacro[80];
char varname[80];
char runningapp[80], runningdata[1024];
char *oldargs[MAX_ARGS + 1] = { NULL, };
int argc, x;
int res=0;
char oldexten[256]="";
int oldpriority, gosub_level = 0;
char pc[80], depthc[12];
char oldcontext[AST_MAX_CONTEXT] = "";
const char *inhangupc;
int offset, depth = 0, maxdepth = 7;
int setmacrocontext=0;
int autoloopflag, inhangup = 0;
struct ast_str *tmp_subst = NULL;
char *save_macro_exten;
char *save_macro_context;
char *save_macro_priority;
char *save_macro_offset;
struct ast_datastore *macro_store = ast_channel_datastore_find(chan, ¯o_ds_info, NULL);
if (ast_strlen_zero(data)) {
ast_log(LOG_WARNING, "Macro() requires arguments. See \"core show application macro\" for help.\n");
return -1;
}
do {
if (macro_store) {
break;
}
if (!(macro_store = ast_datastore_alloc(¯o_ds_info, NULL))) {
ast_log(LOG_WARNING, "Unable to allocate new datastore.\n");
break;
}
/* Just the existence of this datastore is enough. */
macro_store->inheritance = DATASTORE_INHERIT_FOREVER;
ast_channel_datastore_add(chan, macro_store);
} while (0);
/* does the user want a deeper rabbit hole? */
ast_channel_lock(chan);
if ((s = pbx_builtin_getvar_helper(chan, "MACRO_RECURSION"))) {
sscanf(s, "%30d", &maxdepth);
}
/* Count how many levels deep the rabbit hole goes */
if ((s = pbx_builtin_getvar_helper(chan, "MACRO_DEPTH"))) {
sscanf(s, "%30d", &depth);
}
/* Used for detecting whether to return when a Macro is called from another Macro after hangup */
if (strcmp(ast_channel_exten(chan), "h") == 0)
pbx_builtin_setvar_helper(chan, "MACRO_IN_HANGUP", "1");
if ((inhangupc = pbx_builtin_getvar_helper(chan, "MACRO_IN_HANGUP"))) {
sscanf(inhangupc, "%30d", &inhangup);
}
ast_channel_unlock(chan);
if (depth >= maxdepth) {
ast_log(LOG_ERROR, "Macro(): possible infinite loop detected. Returning early.\n");
return 0;
}
snprintf(depthc, sizeof(depthc), "%d", depth + 1);
tmp = ast_strdupa(data);
rest = tmp;
macro = strsep(&rest, ",");
if (ast_strlen_zero(macro)) {
ast_log(LOG_WARNING, "Invalid macro name specified\n");
return 0;
}
snprintf(fullmacro, sizeof(fullmacro), "macro-%s", macro);
if (!ast_exists_extension(chan, fullmacro, "s", 1,
S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL))) {
if (!ast_context_find(fullmacro))
ast_log(LOG_WARNING, "No such context '%s' for macro '%s'. Was called by %s@%s\n", fullmacro, macro, ast_channel_exten(chan), ast_channel_context(chan));
else
ast_log(LOG_WARNING, "Context '%s' for macro '%s' lacks 's' extension, priority 1\n", fullmacro, macro);
return 0;
}
/* If we are to run the macro exclusively, take the mutex */
if (exclusive) {
ast_debug(1, "Locking macrolock for '%s'\n", fullmacro);
ast_autoservice_start(chan);
if (ast_context_lockmacro(fullmacro)) {
ast_log(LOG_WARNING, "Failed to lock macro '%s' as in-use\n", fullmacro);
ast_autoservice_stop(chan);
return 0;
}
ast_autoservice_stop(chan);
}
if (!(tmp_subst = ast_str_create(16))) {
return -1;
}
/* Save old info */
oldpriority = ast_channel_priority(chan);
ast_copy_string(oldexten, ast_channel_exten(chan), sizeof(oldexten));
ast_copy_string(oldcontext, ast_channel_context(chan), sizeof(oldcontext));
if (ast_strlen_zero(ast_channel_macrocontext(chan))) {
ast_channel_macrocontext_set(chan, ast_channel_context(chan));
ast_channel_macroexten_set(chan, ast_channel_exten(chan));
ast_channel_macropriority_set(chan, ast_channel_priority(chan));
setmacrocontext=1;
}
argc = 1;
/* Save old macro variables */
save_macro_exten = ast_strdup(pbx_builtin_getvar_helper(chan, "MACRO_EXTEN"));
pbx_builtin_setvar_helper(chan, "MACRO_EXTEN", oldexten);
save_macro_context = ast_strdup(pbx_builtin_getvar_helper(chan, "MACRO_CONTEXT"));
pbx_builtin_setvar_helper(chan, "MACRO_CONTEXT", oldcontext);
save_macro_priority = ast_strdup(pbx_builtin_getvar_helper(chan, "MACRO_PRIORITY"));
snprintf(pc, sizeof(pc), "%d", oldpriority);
pbx_builtin_setvar_helper(chan, "MACRO_PRIORITY", pc);
save_macro_offset = ast_strdup(pbx_builtin_getvar_helper(chan, "MACRO_OFFSET"));
pbx_builtin_setvar_helper(chan, "MACRO_OFFSET", NULL);
pbx_builtin_setvar_helper(chan, "MACRO_DEPTH", depthc);
/* Setup environment for new run */
ast_channel_exten_set(chan, "s");
ast_channel_context_set(chan, fullmacro);
ast_channel_priority_set(chan, 1);
ast_channel_lock(chan);
while((cur = strsep(&rest, ",")) && (argc < MAX_ARGS)) {
const char *argp;
/* Save copy of old arguments if we're overwriting some, otherwise
let them pass through to the other macro */
snprintf(varname, sizeof(varname), "ARG%d", argc);
if ((argp = pbx_builtin_getvar_helper(chan, varname))) {
oldargs[argc] = ast_strdup(argp);
}
pbx_builtin_setvar_helper(chan, varname, cur);
argc++;
}
ast_channel_unlock(chan);
autoloopflag = ast_test_flag(ast_channel_flags(chan), AST_FLAG_IN_AUTOLOOP);
ast_set_flag(ast_channel_flags(chan), AST_FLAG_IN_AUTOLOOP);
while (ast_exists_extension(chan, ast_channel_context(chan), ast_channel_exten(chan), ast_channel_priority(chan),
S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL))) {
struct ast_context *c;
struct ast_exten *e;
int foundx;
runningapp[0] = '\0';
runningdata[0] = '\0';
/* What application will execute? */
if (ast_rdlock_contexts()) {
ast_log(LOG_WARNING, "Failed to lock contexts list\n");
} else {
for (c = ast_walk_contexts(NULL), e = NULL; c; c = ast_walk_contexts(c)) {
if (!strcmp(ast_get_context_name(c), ast_channel_context(chan))) {
if (ast_rdlock_context(c)) {
ast_log(LOG_WARNING, "Unable to lock context?\n");
} else {
e = find_matching_priority(c, ast_channel_exten(chan), ast_channel_priority(chan),
S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL));
if (e) { /* This will only be undefined for pbx_realtime, which is majorly broken. */
ast_copy_string(runningapp, ast_get_extension_app(e), sizeof(runningapp));
ast_copy_string(runningdata, ast_get_extension_app_data(e), sizeof(runningdata));
}
ast_unlock_context(c);
}
break;
}
}
}
ast_unlock_contexts();
/* Reset the macro depth, if it was changed in the last iteration */
pbx_builtin_setvar_helper(chan, "MACRO_DEPTH", depthc);
res = ast_spawn_extension(chan, ast_channel_context(chan), ast_channel_exten(chan), ast_channel_priority(chan),
S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL),
&foundx, 1);
if (res) {
/* Something bad happened, or a hangup has been requested. */
if (((res >= '0') && (res <= '9')) || ((res >= 'A') && (res <= 'F')) ||
(res == '*') || (res == '#')) {
/* Just return result as to the previous application as if it had been dialed */
ast_debug(1, "Oooh, got something to jump out with ('%c')!\n", res);
break;
}
switch(res) {
case MACRO_EXIT_RESULT:
res = 0;
goto out;
default:
ast_debug(2, "Spawn extension (%s,%s,%d) exited non-zero on '%s' in macro '%s'\n", ast_channel_context(chan), ast_channel_exten(chan), ast_channel_priority(chan), ast_channel_name(chan), macro);
ast_verb(2, "Spawn extension (%s, %s, %d) exited non-zero on '%s' in macro '%s'\n", ast_channel_context(chan), ast_channel_exten(chan), ast_channel_priority(chan), ast_channel_name(chan), macro);
goto out;
}
}
ast_debug(1, "Executed application: %s\n", runningapp);
if (!strcasecmp(runningapp, "GOSUB")) {
gosub_level++;
ast_debug(1, "Incrementing gosub_level\n");
} else if (!strcasecmp(runningapp, "GOSUBIF")) {
char *cond, *app_arg;
char *app2;
ast_str_substitute_variables(&tmp_subst, 0, chan, runningdata);
app2 = ast_str_buffer(tmp_subst);
cond = strsep(&app2, "?");
app_arg = strsep(&app2, ":");
if (pbx_checkcondition(cond)) {
if (!ast_strlen_zero(app_arg)) {
gosub_level++;
ast_debug(1, "Incrementing gosub_level\n");
}
} else {
if (!ast_strlen_zero(app2)) {
gosub_level++;
ast_debug(1, "Incrementing gosub_level\n");
}
}
} else if (!strcasecmp(runningapp, "RETURN")) {
gosub_level--;
ast_debug(1, "Decrementing gosub_level\n");
} else if (!strcasecmp(runningapp, "STACKPOP")) {
gosub_level--;
ast_debug(1, "Decrementing gosub_level\n");
} else if (!strncasecmp(runningapp, "EXEC", 4)) {
/* Must evaluate args to find actual app */
char *tmp2, *tmp3 = NULL;
ast_str_substitute_variables(&tmp_subst, 0, chan, runningdata);
tmp2 = ast_str_buffer(tmp_subst);
if (!strcasecmp(runningapp, "EXECIF")) {
if ((tmp3 = strchr(tmp2, '|'))) {
*tmp3++ = '\0';
}
if (!pbx_checkcondition(tmp2)) {
tmp3 = NULL;
}
} else {
tmp3 = tmp2;
}
if (tmp3) {
ast_debug(1, "Last app: %s\n", tmp3);
}
if (tmp3 && !strncasecmp(tmp3, "GOSUB", 5)) {
gosub_level++;
ast_debug(1, "Incrementing gosub_level\n");
} else if (tmp3 && !strncasecmp(tmp3, "RETURN", 6)) {
gosub_level--;
ast_debug(1, "Decrementing gosub_level\n");
} else if (tmp3 && !strncasecmp(tmp3, "STACKPOP", 8)) {
gosub_level--;
ast_debug(1, "Decrementing gosub_level\n");
}
}
if (gosub_level == 0 && strcasecmp(ast_channel_context(chan), fullmacro)) {
ast_verb(2, "Channel '%s' jumping out of macro '%s'\n", ast_channel_name(chan), macro);
break;
}
/* don't stop executing extensions when we're in "h" */
if (ast_check_hangup(chan) && !inhangup) {
ast_debug(1, "Extension %s, macroexten %s, priority %d returned normally even though call was hung up\n", ast_channel_exten(chan), ast_channel_macroexten(chan), ast_channel_priority(chan));
goto out;
}
ast_channel_priority_set(chan, ast_channel_priority(chan) + 1);
}
out:
/* Don't let the channel change now. */
ast_channel_lock(chan);
/* Reset the depth back to what it was when the routine was entered (like if we called Macro recursively) */
snprintf(depthc, sizeof(depthc), "%d", depth);
pbx_builtin_setvar_helper(chan, "MACRO_DEPTH", depthc);
ast_set2_flag(ast_channel_flags(chan), autoloopflag, AST_FLAG_IN_AUTOLOOP);
for (x = 1; x < argc; x++) {
/* Restore old arguments and delete ours */
snprintf(varname, sizeof(varname), "ARG%d", x);
if (oldargs[x]) {
pbx_builtin_setvar_helper(chan, varname, oldargs[x]);
ast_free(oldargs[x]);
} else {
pbx_builtin_setvar_helper(chan, varname, NULL);
}
}
/* Restore macro variables */
pbx_builtin_setvar_helper(chan, "MACRO_EXTEN", save_macro_exten);
pbx_builtin_setvar_helper(chan, "MACRO_CONTEXT", save_macro_context);
pbx_builtin_setvar_helper(chan, "MACRO_PRIORITY", save_macro_priority);
if (save_macro_exten)
ast_free(save_macro_exten);
if (save_macro_context)
ast_free(save_macro_context);
if (save_macro_priority)
ast_free(save_macro_priority);
if (setmacrocontext) {
ast_channel_macrocontext_set(chan, "");
ast_channel_macroexten_set(chan, "");
ast_channel_macropriority_set(chan, 0);
}
if (!strcasecmp(ast_channel_context(chan), fullmacro)) {
const char *offsets;
/* If we're leaving the macro normally, restore original information */
ast_channel_priority_set(chan, oldpriority);
ast_channel_context_set(chan, oldcontext);
ast_channel_exten_set(chan, oldexten);
if ((offsets = pbx_builtin_getvar_helper(chan, "MACRO_OFFSET"))) {
/* Handle macro offset if it's set by checking the availability of step n + offset + 1, otherwise continue
normally if there is any problem */
if (sscanf(offsets, "%30d", &offset) == 1) {
if (ast_exists_extension(chan, ast_channel_context(chan), ast_channel_exten(chan),
ast_channel_priority(chan) + offset + 1,
S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL))) {
ast_channel_priority_set(chan, ast_channel_priority(chan) + offset);
}
}
}
}
pbx_builtin_setvar_helper(chan, "MACRO_OFFSET", save_macro_offset);
if (save_macro_offset)
ast_free(save_macro_offset);
/* Unlock the macro */
if (exclusive) {
ast_debug(1, "Unlocking macrolock for '%s'\n", fullmacro);
if (ast_context_unlockmacro(fullmacro)) {
ast_log(LOG_ERROR, "Failed to unlock macro '%s' - that isn't good\n", fullmacro);
res = 0;
}
}
ast_channel_unlock(chan);
ast_free(tmp_subst);
return res;
}
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 int local_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
{
struct local_pvt *p = ast_channel_tech_pvt(ast);
int res = 0;
struct ast_frame f = { AST_FRAME_CONTROL, };
int isoutbound;
if (!p) {
return -1;
}
ao2_ref(p, 1); /* ref for local_queue_frame */
/* If this is an MOH hold or unhold, do it on the Local channel versus real channel */
if (!ast_test_flag(p, LOCAL_MOH_PASSTHRU) && condition == AST_CONTROL_HOLD) {
ast_moh_start(ast, data, NULL);
} else if (!ast_test_flag(p, LOCAL_MOH_PASSTHRU) && condition == AST_CONTROL_UNHOLD) {
ast_moh_stop(ast);
} else if (condition == AST_CONTROL_CONNECTED_LINE || condition == AST_CONTROL_REDIRECTING) {
struct ast_channel *this_channel;
struct ast_channel *the_other_channel;
/* A connected line update frame may only contain a partial amount of data, such
* as just a source, or just a ton, and not the full amount of information. However,
* the collected information is all stored in the outgoing channel's connectedline
* structure, so when receiving a connected line update on an outgoing local channel,
* we need to transmit the collected connected line information instead of whatever
* happens to be in this control frame. The same applies for redirecting information, which
* is why it is handled here as well.*/
ao2_lock(p);
isoutbound = IS_OUTBOUND(ast, p);
if (isoutbound) {
this_channel = p->chan;
the_other_channel = p->owner;
} else {
this_channel = p->owner;
the_other_channel = p->chan;
}
if (the_other_channel) {
unsigned char frame_data[1024];
if (condition == AST_CONTROL_CONNECTED_LINE) {
if (isoutbound) {
ast_connected_line_copy_to_caller(ast_channel_caller(the_other_channel), ast_channel_connected(this_channel));
}
f.datalen = ast_connected_line_build_data(frame_data, sizeof(frame_data), ast_channel_connected(this_channel), NULL);
} else {
f.datalen = ast_redirecting_build_data(frame_data, sizeof(frame_data), ast_channel_redirecting(this_channel), NULL);
}
f.subclass.integer = condition;
f.data.ptr = frame_data;
res = local_queue_frame(p, isoutbound, &f, ast, 1);
}
ao2_unlock(p);
} else {
/* Queue up a frame representing the indication as a control frame */
ao2_lock(p);
/*
* Block -1 stop tones events if we are to be optimized out. We
* don't need a flurry of these events on a local channel chain
* when initially connected to slow the optimization process.
*/
if (0 <= condition || ast_test_flag(p, LOCAL_NO_OPTIMIZATION)) {
isoutbound = IS_OUTBOUND(ast, p);
f.subclass.integer = condition;
f.data.ptr = (void *) data;
f.datalen = datalen;
res = local_queue_frame(p, isoutbound, &f, ast, 1);
if (!res && (condition == AST_CONTROL_T38_PARAMETERS) &&
(datalen == sizeof(struct ast_control_t38_parameters))) {
const struct ast_control_t38_parameters *parameters = data;
if (parameters->request_response == AST_T38_REQUEST_PARMS) {
res = AST_T38_REQUEST_PARMS;
}
}
} else {
ast_debug(4, "Blocked indication %d\n", condition);
}
ao2_unlock(p);
}
ao2_ref(p, -1);
return res;
}
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;
}
/*! \brief Initiate new call, part of PBX interface
* dest is the dial string */
static int local_call(struct ast_channel *ast, const char *dest, int timeout)
{
struct local_pvt *p = ast_channel_tech_pvt(ast);
int pvt_locked = 0;
struct ast_channel *owner = NULL;
struct ast_channel *chan = NULL;
int res;
struct ast_var_t *varptr;
struct ast_var_t *clone_var;
char *reduced_dest = ast_strdupa(dest);
char *slash;
const char *exten;
const char *context;
if (!p) {
return -1;
}
/* since we are letting go of channel locks that were locked coming into
* this function, then we need to give the tech pvt a ref */
ao2_ref(p, 1);
ast_channel_unlock(ast);
awesome_locking(p, &chan, &owner);
pvt_locked = 1;
if (owner != ast) {
res = -1;
goto return_cleanup;
}
if (!owner || !chan) {
res = -1;
goto return_cleanup;
}
/*
* Note that cid_num and cid_name aren't passed in the ast_channel_alloc
* call, so it's done here instead.
*
* All these failure points just return -1. The individual strings will
* be cleared when we destroy the channel.
*/
ast_party_redirecting_copy(ast_channel_redirecting(chan), ast_channel_redirecting(owner));
ast_party_dialed_copy(ast_channel_dialed(chan), ast_channel_dialed(owner));
ast_connected_line_copy_to_caller(ast_channel_caller(chan), ast_channel_connected(owner));
ast_connected_line_copy_from_caller(ast_channel_connected(chan), ast_channel_caller(owner));
ast_channel_language_set(chan, ast_channel_language(owner));
ast_channel_accountcode_set(chan, ast_channel_accountcode(owner));
ast_channel_musicclass_set(chan, ast_channel_musicclass(owner));
ast_cdr_update(chan);
ast_channel_cc_params_init(chan, ast_channel_get_cc_config_params(owner));
/* Make sure we inherit the AST_CAUSE_ANSWERED_ELSEWHERE if it's set on the queue/dial call request in the dialplan */
if (ast_channel_hangupcause(ast) == AST_CAUSE_ANSWERED_ELSEWHERE) {
ast_channel_hangupcause_set(chan, AST_CAUSE_ANSWERED_ELSEWHERE);
}
/* copy the channel variables from the incoming channel to the outgoing channel */
/* Note that due to certain assumptions, they MUST be in the same order */
AST_LIST_TRAVERSE(ast_channel_varshead(owner), varptr, entries) {
clone_var = ast_var_assign(varptr->name, varptr->value);
if (clone_var) {
AST_LIST_INSERT_TAIL(ast_channel_varshead(chan), clone_var, entries);
}
}
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)
{
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);
ast_manager_event(s->chan, EVENT_FLAG_CALL,
s->direction ? "FaxSent" : "FaxReceived",
"Channel: %s\r\n"
"Exten: %s\r\n"
"CallerID: %s\r\n"
"CallerIDName: %s\r\n"
"ConnectedLineNum: %s\r\n"
"ConnectedLineName: %s\r\n"
"RemoteStationID: %s\r\n"
"LocalStationID: %s\r\n"
"PagesTransferred: %d\r\n"
"Resolution: %d\r\n"
"TransferRate: %d\r\n"
"FileName: %s\r\n",
ast_channel_name(s->chan),
ast_channel_exten(s->chan),
S_COR(ast_channel_caller(s->chan)->id.number.valid, ast_channel_caller(s->chan)->id.number.str, ""),
S_COR(ast_channel_caller(s->chan)->id.name.valid, ast_channel_caller(s->chan)->id.name.str, ""),
S_COR(ast_channel_connected(s->chan)->id.number.valid, ast_channel_connected(s->chan)->id.number.str, ""),
S_COR(ast_channel_connected(s->chan)->id.name.valid, ast_channel_connected(s->chan)->id.name.str, ""),
far_ident,
local_ident,
pages_transferred,
stat.y_resolution,
stat.bit_rate,
s->file_name);
}
/* === Helper functions to configure fax === */
/* Setup SPAN logging according to Asterisk debug level */
static int set_logging(logging_state_t *state)
{
int level = SPAN_LOG_WARNING + option_debug;
span_log_set_message_handler(state, span_message);
span_log_set_level(state, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | level);
return 0;
}
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;
}
static int nv_detectfax_exec(struct ast_channel *chan, const char *data)
{
int res = 0;
char tmp[256] = "\0";
char *p = NULL;
char *waitstr = NULL;
char *options = NULL;
char *silstr = NULL;
char *minstr = NULL;
char *maxstr = NULL;
struct ast_frame *fr = NULL;
struct ast_frame *fr2 = NULL;
int notsilent = 0;
struct timeval start = {0, 0}, end = {0, 0};
int waitdur = 4;
int sildur = 1000;
int mindur = 100;
int maxdur = -1;
int skipanswer = 0;
int noextneeded = 0;
int ignoredtmf = 0;
int ignorefax = 0;
int ignoretalk = 0;
int x = 0;
struct ast_format* origrformat = NULL;
int features = 0;
time_t timeout = 0;
struct ast_dsp *dsp = NULL;
struct ast_format_cap *cap;
struct ast_format linearFormat;
/* linear format capabilities */
ast_format_set(&linearFormat, AST_FORMAT_SLINEAR, 0);
cap = ast_format_cap_alloc_nolock();
ast_format_cap_add(cap, &linearFormat);
/* done */
pbx_builtin_setvar_helper(chan, "FAX_DETECTED", "");
pbx_builtin_setvar_helper(chan, "FAXEXTEN", "");
pbx_builtin_setvar_helper(chan, "DTMF_DETECTED", "");
pbx_builtin_setvar_helper(chan, "TALK_DETECTED", "");
if (data || !ast_strlen_zero(data)) {
strncpy(tmp, data, sizeof(tmp)-1);
}
p = tmp;
waitstr = strsep(&p, ",");
options = strsep(&p, ",");
silstr = strsep(&p, ",");
minstr = strsep(&p, ",");
maxstr = strsep(&p, ",");
if (waitstr) {
if ((sscanf(waitstr, "%d", &x) == 1) && (x > 0))
waitdur = x;
}
if (options) {
if (strchr(options, 'n'))
skipanswer = 1;
if (strchr(options, 'x'))
noextneeded = 1;
if (strchr(options, 'd'))
ignoredtmf = 1;
if (strchr(options, 'f'))
ignorefax = 1;
if (strchr(options, 't'))
ignoretalk = 1;
}
if (silstr) {
if ((sscanf(silstr, "%d", &x) == 1) && (x > 0))
sildur = x;
}
if (minstr) {
if ((sscanf(minstr, "%d", &x) == 1) && (x > 0))
mindur = x;
}
if (maxstr) {
if ((sscanf(maxstr, "%d", &x) == 1) && (x > 0))
maxdur = x;
}
ast_log(LOG_DEBUG, "Preparing detect of fax (waitdur=%dms, sildur=%dms, mindur=%dms, maxdur=%dms)\n",
waitdur, sildur, mindur, maxdur);
// LOCAL_USER_ADD(u);
// if (chan->_state != AST_STATE_UP && !skipanswer) {
if (ast_channel_state(chan) != AST_STATE_UP && !skipanswer) {
/* Otherwise answer unless we're supposed to send this while on-hook */
res = ast_answer(chan);
}
if (!res) {
// origrformat = chan->readformat;
origrformat = ast_channel_readformat(chan);
// if ((res = ast_set_read_format(chan, AST_FORMAT_SLINEAR)))
if ((res = ast_set_read_format_from_cap(chan, cap)) ){
ast_log(LOG_WARNING, "Unable to set read format to linear!\n");
}
}
if (!(dsp = ast_dsp_new())) {
ast_log(LOG_WARNING, "Unable to allocate DSP!\n");
res = -1;
}
if (dsp) {
if (!ignoretalk)
; /* features |= DSP_FEATURE_SILENCE_SUPPRESS; */
if (!ignorefax)
features |= DSP_FEATURE_FAX_DETECT;
//if (!ignoredtmf)
features |= DSP_FEATURE_DIGIT_DETECT;
ast_dsp_set_threshold(dsp, 256);
ast_dsp_set_features(dsp, features | DSP_DIGITMODE_RELAXDTMF);
ast_dsp_set_digitmode(dsp, DSP_DIGITMODE_DTMF);
}
if (!res) {
if (waitdur > 0)
timeout = time(NULL) + (time_t)waitdur;
while(ast_waitfor(chan, -1) > -1) {
if (waitdur > 0 && time(NULL) > timeout) {
res = 0;
break;
}
fr = ast_read(chan);
if (!fr) {
ast_log(LOG_DEBUG, "Got hangup\n");
res = -1;
break;
}
fr2 = ast_dsp_process(chan, dsp, fr);
if (!fr2) {
ast_log(LOG_WARNING, "Bad DSP received (what happened?)\n");
fr2 = fr;
}
if (fr2->frametype == AST_FRAME_DTMF) {
if (fr2->subclass.integer == 'f' && !ignorefax) {
/* Fax tone -- Handle and return NULL */
ast_log(LOG_DEBUG, "Fax detected on %s\n", ast_channel_name(chan));
ast_log(LOG_DEBUG, "Fax detected on %s\n", ast_channel_name(chan));
if (strcmp(ast_channel_exten(chan), "fax")) {
ast_log(LOG_NOTICE, "Redirecting %s to fax extension\n", ast_channel_name(chan));
pbx_builtin_setvar_helper(chan, "FAX_DETECTED", "1");
pbx_builtin_setvar_helper(chan,"FAXEXTEN",ast_channel_exten(chan));
if (ast_exists_extension(chan, ast_channel_context(chan), "fax", 1, ast_channel_caller(chan)->id.number.str)) {
/* Save the DID/DNIS when we transfer the fax call to a "fax" extension */
// strncpy(ast_channel_exten(chan), "fax", sizeof(ast_channel_exten(chan))-1);
// chan->priority = 0;
ast_channel_exten_set(chan, "fax");
ast_channel_priority_set(chan, 0);
} else
ast_log(LOG_WARNING, "Fax detected, but no fax extension\n");
} else
ast_log(LOG_WARNING, "Already in a fax extension, not redirecting\n");
res = 0;
ast_frfree(fr);
break;
} else if (!ignoredtmf) {
ast_log(LOG_DEBUG, "DTMF detected on %s\n", ast_channel_name(chan));
char t[2];
t[0] = fr2->subclass.integer;
t[1] = '\0';
if (noextneeded || ast_canmatch_extension(chan, ast_channel_context(chan), t, 1, ast_channel_caller(chan)->id.number.str)) {
pbx_builtin_setvar_helper(chan, "DTMF_DETECTED", "1");
/* They entered a valid extension, or might be anyhow */
if (noextneeded) {
ast_log(LOG_NOTICE, "DTMF received (not matching to exten)\n");
res = 0;
} else {
ast_log(LOG_NOTICE, "DTMF received (matching to exten)\n");
res = fr2->subclass.integer;
}
ast_frfree(fr);
break;
} else
ast_log(LOG_DEBUG, "Valid extension requested and DTMF did not match\n");
}
// } else if ((fr->frametype == AST_FRAME_VOICE) && (fr->subclass == AST_FORMAT_SLINEAR) && !ignoretalk) {
} else if ((fr->frametype == AST_FRAME_VOICE) && ( ast_format_cap_iscompatible(cap, &fr->subclass.format)) && !ignoretalk) {
int totalsilence;
int ms;
res = ast_dsp_silence(dsp, fr, &totalsilence);
if (res && (totalsilence > sildur)) {
/* We've been quiet a little while */
if (notsilent) {
/* We had heard some talking */
gettimeofday(&end, NULL);
ms = (end.tv_sec - start.tv_sec) * 1000;
ms += (end.tv_usec - start.tv_usec) / 1000;
ms -= sildur;
if (ms < 0)
ms = 0;
if ((ms > mindur) && ((maxdur < 0) || (ms < maxdur))) {
char ms_str[10];
ast_log(LOG_DEBUG, "Found qualified token of %d ms\n", ms);
ast_log(LOG_NOTICE, "Redirecting %s to talk extension\n", ast_channel_name(chan));
/* Save detected talk time (in milliseconds) */
sprintf(ms_str, "%d", ms);
pbx_builtin_setvar_helper(chan, "TALK_DETECTED", ms_str);
if (ast_exists_extension(chan, ast_channel_context(chan), "talk", 1, ast_channel_caller(chan)->id.number.str)) {
// strncpy(ast_channel_exten(chan), "talk", sizeof(ast_channel_exten(chan)) - 1);
// chan->priority = 0;
ast_channel_exten_set(chan, "talk");
ast_channel_priority_set(chan, 0);
} else
ast_log(LOG_WARNING, "Talk detected, but no talk extension\n");
res = 0;
ast_frfree(fr);
break;
} else
ast_log(LOG_DEBUG, "Found unqualified token of %d ms\n", ms);
notsilent = 0;
}
} else {
if (!notsilent) {
/* Heard some audio, mark the begining of the token */
gettimeofday(&start, NULL);
ast_log(LOG_DEBUG, "Start of voice token!\n");
notsilent = 1;
}
}
}
ast_frfree(fr);
}
} else
ast_log(LOG_WARNING, "Could not answer channel '%s'\n", ast_channel_name(chan));
if (res > -1) {
if (origrformat && ast_set_read_format(chan, origrformat)) {
ast_log(LOG_WARNING, "Failed to restore read format for %s to %s\n",
ast_channel_name(chan), ast_getformatname(origrformat));
}
}
if (dsp)
ast_dsp_free(dsp);
// LOCAL_USER_REMOVE(u);
ast_format_cap_destroy(cap);
return res;
}
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;
}