/*! \internal
* \brief Interval hook. Pulls a parked call from the parking bridge after the timeout is passed and sets the resolution to timeout.
*
* \param bridge_channel bridge channel this interval hook is being executed on
* \param hook_pvt A pointer to the parked_user struct associated with the channel is stuffed in here
*/
static int parking_duration_callback(struct ast_bridge_channel *bridge_channel, void *hook_pvt)
{
struct parked_user *user = hook_pvt;
struct ast_channel *chan = user->chan;
struct ast_context *park_dial_context;
const char *dial_string;
char *dial_string_flat;
char parking_space[AST_MAX_EXTENSION];
char returnexten[AST_MAX_EXTENSION];
char *duplicate_returnexten;
struct ast_exten *existing_exten;
struct pbx_find_info pbx_finder = { .stacklen = 0 }; /* The rest is reset in pbx_find_extension */
/* We are still in the bridge, so it's possible for other stuff to mess with the parked call before we leave the bridge
to deal with this, lock the parked user, check and set resolution. */
ao2_lock(user);
if (user->resolution != PARK_UNSET) {
/* Abandon timeout since something else has resolved the parked user before we got to it. */
ao2_unlock(user);
return -1;
}
user->resolution = PARK_TIMEOUT;
ao2_unlock(user);
ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE,
AST_CAUSE_NORMAL_CLEARING);
dial_string = user->parker_dial_string;
dial_string_flat = ast_strdupa(dial_string);
flatten_dial_string(dial_string_flat);
/* Set parking timeout channel variables */
snprintf(parking_space, sizeof(parking_space), "%d", user->parking_space);
ast_channel_lock(chan);
ast_channel_stage_snapshot(chan);
pbx_builtin_setvar_helper(chan, "PARKING_SPACE", parking_space);
pbx_builtin_setvar_helper(chan, "PARKINGSLOT", parking_space); /* Deprecated version of PARKING_SPACE */
pbx_builtin_setvar_helper(chan, "PARKEDLOT", user->lot->name);
pbx_builtin_setvar_helper(chan, "PARKER", dial_string);
pbx_builtin_setvar_helper(chan, "PARKER_FLAT", dial_string_flat);
parking_timeout_set_caller_features(chan, user->lot->cfg);
ast_channel_stage_snapshot_done(chan);
ast_channel_unlock(chan);
/* Dialplan generation for park-dial extensions */
if (ast_wrlock_contexts()) {
ast_log(LOG_ERROR, "Failed to lock the contexts list. Can't add the park-dial extension.\n");
return -1;
}
if (!(park_dial_context = ast_context_find_or_create(NULL, NULL, PARK_DIAL_CONTEXT, BASE_REGISTRAR))) {
ast_log(LOG_ERROR, "Parking dial context '%s' does not exist and unable to create\n", PARK_DIAL_CONTEXT);
if (ast_unlock_contexts()) {
ast_assert(0);
}
goto abandon_extension_creation;
}
if (ast_wrlock_context(park_dial_context)) {
ast_log(LOG_ERROR, "failed to obtain write lock on context '%s'\n", PARK_DIAL_CONTEXT);
if (ast_unlock_contexts()) {
ast_assert(0);
}
goto abandon_extension_creation;
}
if (ast_unlock_contexts()) {
ast_assert(0);
}
snprintf(returnexten, sizeof(returnexten), "%s,%u", dial_string,
user->lot->cfg->comebackdialtime);
duplicate_returnexten = ast_strdup(returnexten);
if (!duplicate_returnexten) {
ast_log(LOG_ERROR, "Failed to create parking redial parker extension %s@%s - Dial(%s)\n",
dial_string_flat, PARK_DIAL_CONTEXT, returnexten);
}
/* If an extension already exists here because we registered it for another parked call timing out, then we may overwrite it. */
if ((existing_exten = pbx_find_extension(NULL, NULL, &pbx_finder, PARK_DIAL_CONTEXT, dial_string_flat, 1, NULL, NULL, E_MATCH)) &&
(strcmp(ast_get_extension_registrar(existing_exten), BASE_REGISTRAR))) {
ast_debug(3, "An extension for '%s@%s' was already registered by another registrar '%s'\n",
dial_string_flat, PARK_DIAL_CONTEXT, ast_get_extension_registrar(existing_exten));
} else if (ast_add_extension2_nolock(park_dial_context, 1, dial_string_flat, 1, NULL, NULL,
"Dial", duplicate_returnexten, ast_free_ptr, BASE_REGISTRAR)) {
ast_free(duplicate_returnexten);
ast_log(LOG_ERROR, "Failed to create parking redial parker extension %s@%s - Dial(%s)\n",
dial_string_flat, PARK_DIAL_CONTEXT, returnexten);
}
if (ast_unlock_context(park_dial_context)) {
ast_assert(0);
}
abandon_extension_creation:
/* async_goto the proper PBX destination - this should happen when we come out of the bridge */
if (!ast_strlen_zero(user->comeback)) {
ast_async_parseable_goto(chan, user->comeback);
} else {
comeback_goto(user, user->lot);
}
return -1;
}
void say_parking_space(struct ast_bridge_channel *bridge_channel, const char *payload)
{
unsigned int numeric_value;
unsigned int hangup_after;
if (sscanf(payload, "%u %u", &hangup_after, &numeric_value) != 2) {
/* If say_parking_space is called with a non-numeric string, we have a problem. */
ast_assert(0);
ast_bridge_channel_leave_bridge(bridge_channel,
BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
return;
}
ast_say_digits(bridge_channel->chan, numeric_value, "",
ast_channel_language(bridge_channel->chan));
if (hangup_after) {
ast_bridge_channel_leave_bridge(bridge_channel,
BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
}
}
/*!
* \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_MASQUERADE_NOTIFY:
/*
* Always block this because this is the channel being
* masqueraded; not anything down the chain.
*/
break;
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;
case AST_CONTROL_RINGING:
/* Don't queue ringing frames if the channel is not in a "ring" state. Otherwise,
* the real channel on the other end will likely start a playtones generator. It is
* possible that this playtones generator will never be stopped under certain
* circumstances.
*/
if (ast_channel_state(ast) == AST_STATE_RING) {
res = unreal_queue_indicate(p, ast, condition, data, datalen);
} else {
res = -1;
}
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;
ast_channel_stage_snapshot(semi2);
/*
* 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));
/* Crossover the CallerID and conected-line to cross the unreal bridge. */
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));
/* Crossover the accountcode and peeraccount to cross the unreal bridge. */
ast_channel_accountcode_set(semi2, ast_channel_peeraccount(semi1));
ast_channel_peeraccount_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_publish_varset(semi2, ast_var_full_name(clone_var),
ast_var_value(clone_var));
}
}
ast_channel_datastore_inherit(semi1, semi2);
ast_channel_stage_snapshot_done(semi2);
}
