/*! Forward a channel's topics to an app */
static struct app_forwards *forwards_create_channel(struct stasis_app *app,
struct ast_channel *chan)
{
struct app_forwards *forwards;
if (!app) {
return NULL;
}
forwards = forwards_create(app, chan ? ast_channel_uniqueid(chan) : CHANNEL_ALL);
if (!forwards) {
return NULL;
}
forwards->forward_type = FORWARD_CHANNEL;
if (chan) {
forwards->topic_forward = stasis_forward_all(ast_channel_topic(chan),
app->topic);
}
forwards->topic_cached_forward = stasis_forward_all(
chan ? ast_channel_topic_cached(chan) : ast_channel_topic_all_cached(),
app->topic);
if ((!forwards->topic_forward && chan) || !forwards->topic_cached_forward) {
/* Half-subscribed is a bad thing */
forwards_unsubscribe(forwards);
ao2_ref(forwards, -1);
return NULL;
}
return forwards;
}
/*! \brief Publish single channel user event (for app_userevent compatibility) */
void ast_multi_object_blob_single_channel_publish(struct ast_channel *chan,
struct stasis_message_type *type, struct ast_json *blob)
{
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, channel_snapshot, NULL, ao2_cleanup);
RAII_VAR(struct ast_multi_object_blob *, multi, NULL, ao2_cleanup);
if (!type) {
return;
}
multi = ast_multi_object_blob_create(blob);
if (!multi) {
return;
}
channel_snapshot = ast_channel_snapshot_create(chan);
ao2_ref(channel_snapshot, +1);
ast_multi_object_blob_add(multi, STASIS_UMOS_CHANNEL, channel_snapshot);
message = stasis_message_create(type, multi);
if (message) {
/* app_userevent still publishes to channel */
stasis_publish(ast_channel_topic(chan), message);
}
}
/*! Forward a channel's topics to an app */
static struct app_forwards *forwards_create_channel(struct stasis_app *app,
struct ast_channel *chan)
{
RAII_VAR(struct app_forwards *, forwards, NULL, ao2_cleanup);
if (!app || !chan) {
return NULL;
}
forwards = forwards_create(app, ast_channel_uniqueid(chan));
if (!forwards) {
return NULL;
}
forwards->forward_type = FORWARD_CHANNEL;
forwards->topic_forward = stasis_forward_all(ast_channel_topic(chan),
app->topic);
if (!forwards->topic_forward) {
return NULL;
}
forwards->topic_cached_forward = stasis_forward_all(
ast_channel_topic_cached(chan), app->topic);
if (!forwards->topic_cached_forward) {
/* Half-subscribed is a bad thing */
stasis_forward_cancel(forwards->topic_forward);
forwards->topic_forward = NULL;
return NULL;
}
ao2_ref(forwards, +1);
return forwards;
}
/*! \brief Callback for \ref ast_unreal_pvt_callbacks \ref optimization_finished_cb */
static void local_optimization_finished_cb(struct ast_unreal_pvt *base, int success, unsigned int id)
{
RAII_VAR(struct ast_json *, json_object, ast_json_null(), ast_json_unref);
RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
struct local_pvt *p = (struct local_pvt *)base;
if (!ast_local_optimization_end_type()) {
return;
}
json_object = ast_json_pack("{s: i, s: i}", "success", success, "id", id);
if (!json_object) {
return;
}
payload = local_channel_optimization_blob(p, json_object);
if (!payload) {
return;
}
msg = stasis_message_create(ast_local_optimization_end_type(), payload);
if (!msg) {
return;
}
stasis_publish(ast_channel_topic(p->base.owner), msg);
}
/*! Forward a channel's topics to an app */
static struct app_forwards *forwards_create_channel(struct stasis_app *app,
struct ast_channel *chan)
{
struct app_forwards *forwards;
if (!app) {
return NULL;
}
forwards = forwards_create(app, chan ? ast_channel_uniqueid(chan) : CHANNEL_ALL);
if (!forwards) {
return NULL;
}
forwards->forward_type = FORWARD_CHANNEL;
forwards->topic_forward = stasis_forward_all(
chan ? ast_channel_topic(chan) : ast_channel_topic_all(),
app->topic);
if (!forwards->topic_forward) {
ao2_ref(forwards, -1);
return NULL;
}
return forwards;
}
void stasis_app_control_publish(
struct stasis_app_control *control, struct stasis_message *message)
{
if (!control || !control->channel || !message) {
return;
}
stasis_publish(ast_channel_topic(control->channel), message);
}
static void publish_message_for_channel_topics(struct stasis_message *message, struct ast_channel *chan)
{
if (chan) {
stasis_publish(ast_channel_topic(chan), message);
} else {
stasis_publish(ast_channel_topic_all(), message);
}
}
/*!
* \internal
* \brief Post the \ref ast_local_bridge_type \ref stasis message
* \since 12.0.0
*
* \param p local_pvt to raise the local bridge message
*
* \return Nothing
*/
static void publish_local_bridge_message(struct local_pvt *p)
{
RAII_VAR(struct ast_multi_channel_blob *, multi_blob, NULL, ao2_cleanup);
RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, one_snapshot, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, two_snapshot, NULL, ao2_cleanup);
struct ast_channel *owner;
struct ast_channel *chan;
if (!ast_local_bridge_type()) {
return;
}
ast_unreal_lock_all(&p->base, &chan, &owner);
blob = ast_json_pack("{s: s, s: s, s: b}",
"context", p->context,
"exten", p->exten,
"can_optimize", !ast_test_flag(&p->base, AST_UNREAL_NO_OPTIMIZATION));
if (!blob) {
goto end;
}
multi_blob = ast_multi_channel_blob_create(blob);
if (!multi_blob) {
goto end;
}
one_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(owner));
if (!one_snapshot) {
goto end;
}
two_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(chan));
if (!two_snapshot) {
goto end;
}
ast_multi_channel_blob_add_channel(multi_blob, "1", one_snapshot);
ast_multi_channel_blob_add_channel(multi_blob, "2", two_snapshot);
msg = stasis_message_create(ast_local_bridge_type(), multi_blob);
if (!msg) {
goto end;
}
stasis_publish(ast_channel_topic(owner), msg);
end:
ast_channel_unlock(owner);
ast_channel_unref(owner);
ast_channel_unlock(chan);
ast_channel_unref(chan);
ao2_unlock(&p->base);
}
void ast_channel_publish_blob(struct ast_channel *chan, struct stasis_message_type *type, struct ast_json *blob)
{
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
if (!blob) {
blob = ast_json_null();
}
message = ast_channel_blob_create(chan, type, blob);
if (message) {
stasis_publish(ast_channel_topic(chan), message);
}
}
void ast_channel_publish_snapshot(struct ast_channel *chan)
{
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_SNAPSHOT_STAGE)) {
return;
}
snapshot = ast_channel_snapshot_create(chan);
if (!snapshot) {
return;
}
message = stasis_message_create(ast_channel_snapshot_type(), snapshot);
if (!message) {
return;
}
ast_assert(ast_channel_topic(chan) != NULL);
stasis_publish(ast_channel_topic(chan), message);
}
void ast_publish_channel_state(struct ast_channel *chan)
{
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
ast_assert(chan != NULL);
if (!chan) {
return;
}
snapshot = ast_channel_snapshot_create(chan);
if (!snapshot) {
return;
}
message = stasis_message_create(ast_channel_snapshot_type(), snapshot);
if (!message) {
return;
}
ast_assert(ast_channel_topic(chan) != NULL);
stasis_publish(ast_channel_topic(chan), message);
}
int ast_channel_forward_endpoint(struct ast_channel *chan,
struct ast_endpoint *endpoint)
{
ast_assert(chan != NULL);
ast_assert(endpoint != NULL);
chan->endpoint_forward =
stasis_forward_all(ast_channel_topic(chan),
ast_endpoint_topic(endpoint));
if (chan->endpoint_forward == NULL) {
return -1;
}
return 0;
}
static int send_call_pickup_stasis_message(struct ast_channel *picking_up, struct ast_channel_snapshot *chan, struct ast_channel_snapshot *target)
{
RAII_VAR(struct ast_multi_channel_blob *, pickup_payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
if (!(pickup_payload = ast_multi_channel_blob_create(ast_json_null()))) {
return -1;
}
ast_multi_channel_blob_add_channel(pickup_payload, "channel", chan);
ast_multi_channel_blob_add_channel(pickup_payload, "target", target);
if (!(msg = stasis_message_create(ast_call_pickup_type(), pickup_payload))) {
return -1;
}
stasis_publish(ast_channel_topic(picking_up), msg);
return 0;
}
/*! \brief Callback for \ref ast_unreal_pvt_callbacks \ref optimization_started_cb */
static void local_optimization_started_cb(struct ast_unreal_pvt *base, struct ast_channel *source,
enum ast_unreal_channel_indicator dest, unsigned int id)
{
RAII_VAR(struct ast_json *, json_object, ast_json_null(), ast_json_unref);
RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
struct local_pvt *p = (struct local_pvt *)base;
if (!ast_local_optimization_begin_type()) {
return;
}
json_object = ast_json_pack("{s: i, s: i}",
"dest", dest, "id", id);
if (!json_object) {
return;
}
payload = local_channel_optimization_blob(p, json_object);
if (!payload) {
return;
}
if (source) {
RAII_VAR(struct ast_channel_snapshot *, source_snapshot, NULL, ao2_cleanup);
source_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(source));
if (!source_snapshot) {
return;
}
ast_multi_channel_blob_add_channel(payload, "source", source_snapshot);
}
msg = stasis_message_create(ast_local_optimization_begin_type(), payload);
if (!msg) {
return;
}
stasis_publish(ast_channel_topic(p->base.owner), msg);
}
/*! \internal
* \brief Publish the chanspy message over Stasis-Core
* \param spyer The channel doing the spying
* \param spyee Who is being spied upon
* \start start If non-zero, the spying is starting. Otherwise, the spyer is
* finishing
*/
static void publish_chanspy_message(struct ast_channel *spyer,
struct ast_channel *spyee,
int start)
{
RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
if (!spyer) {
ast_log(AST_LOG_WARNING, "Attempt to publish ChanSpy message for NULL spyer channel\n");
return;
}
blob = ast_json_null();
if (!blob) {
return;
}
payload = ast_multi_channel_blob_create(blob);
if (!payload) {
return;
}
if (pack_channel_into_message(spyer, "spyer_channel", payload)) {
return;
}
if (spyee) {
if (pack_channel_into_message(spyee, "spyee_channel", payload)) {
return;
}
}
message = stasis_message_create(
start ? ast_channel_chanspy_start_type(): ast_channel_chanspy_stop_type(),
payload);
if (!message) {
return;
}
stasis_publish(ast_channel_topic(spyer), message);
}
/*! \internal
* \brief Publish the chanspy message over Stasis-Core
* \param snoop The snoop structure
* \start start If non-zero, the spying is starting. Otherwise, the spyer is
* finishing
*/
static void publish_chanspy_message(struct stasis_app_snoop *snoop, int start)
{
RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, snoop_snapshot, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, spyee_snapshot, NULL, ao2_cleanup);
struct stasis_message_type *type = start ? ast_channel_chanspy_start_type(): ast_channel_chanspy_stop_type();
blob = ast_json_null();
if (!blob || !type) {
return;
}
payload = ast_multi_channel_blob_create(blob);
if (!payload) {
return;
}
snoop_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(snoop->chan));
if (!snoop_snapshot) {
return;
}
ast_multi_channel_blob_add_channel(payload, "spyer_channel", snoop_snapshot);
spyee_snapshot = ast_channel_snapshot_get_latest(snoop->uniqueid);
if (spyee_snapshot) {
ast_multi_channel_blob_add_channel(payload, "spyee_channel", spyee_snapshot);
}
message = stasis_message_create(type, payload);
if (!message) {
return;
}
stasis_publish(ast_channel_topic(snoop->chan), message);
}
/*! \internal \brief An audiohook modification callback
*
* This processes the read side of a channel's voice data to see if
* they are talking
*
* \note We don't actually modify the audio, so this function always
* returns a 'failure' indicating that it didn't modify the data
*/
static int talk_detect_audiohook_cb(struct ast_audiohook *audiohook, struct ast_channel *chan, struct ast_frame *frame, enum ast_audiohook_direction direction)
{
int total_silence;
int update_talking = 0;
struct ast_datastore *datastore;
struct talk_detect_params *td_params;
struct stasis_message *message;
if (audiohook->status == AST_AUDIOHOOK_STATUS_DONE) {
return 1;
}
if (direction != AST_AUDIOHOOK_DIRECTION_READ) {
return 1;
}
if (frame->frametype != AST_FRAME_VOICE) {
return 1;
}
if (!(datastore = ast_channel_datastore_find(chan, &talk_detect_datastore, NULL))) {
return 1;
}
td_params = datastore->data;
ast_dsp_silence(td_params->dsp, frame, &total_silence);
if (total_silence < td_params->dsp_silence_threshold) {
if (!td_params->talking) {
update_talking = 1;
td_params->talking_start = ast_tvnow();
}
td_params->talking = 1;
} else {
if (td_params->talking) {
update_talking = 1;
}
td_params->talking = 0;
}
if (update_talking) {
struct ast_json *blob = NULL;
if (!td_params->talking) {
int64_t diff_ms = ast_tvdiff_ms(ast_tvnow(), td_params->talking_start);
diff_ms -= td_params->dsp_silence_threshold;
blob = ast_json_pack("{s: i}", "duration", diff_ms);
if (!blob) {
return 1;
}
}
ast_verb(4, "%s is now %s\n", ast_channel_name(chan),
td_params->talking ? "talking" : "silent");
message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan),
td_params->talking ? ast_channel_talking_start() : ast_channel_talking_stop(),
blob);
if (message) {
stasis_publish(ast_channel_topic(chan), message);
ao2_ref(message, -1);
}
ast_json_unref(blob);
}
return 1;
}
void ast_ari_bridges_record(struct ast_variable *headers,
struct ast_ari_bridges_record_args *args,
struct ast_ari_response *response)
{
RAII_VAR(struct ast_bridge *, bridge, find_bridge(response, args->bridge_id), ao2_cleanup);
RAII_VAR(struct ast_channel *, record_channel, NULL, ast_hangup);
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
RAII_VAR(struct stasis_app_recording *, recording, NULL, ao2_cleanup);
RAII_VAR(char *, recording_url, NULL, ast_free);
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
RAII_VAR(struct stasis_app_recording_options *, options, NULL, ao2_cleanup);
RAII_VAR(char *, uri_encoded_name, NULL, ast_free);
RAII_VAR(struct stasis_forward *, channel_forward, NULL, stasis_forward_cancel);
struct stasis_topic *channel_topic;
struct stasis_topic *bridge_topic;
size_t uri_name_maxlen;
struct bridge_channel_control_thread_data *thread_data;
pthread_t threadid;
ast_assert(response != NULL);
if (bridge == NULL) {
return;
}
if (!(record_channel = prepare_bridge_media_channel("Recorder"))) {
ast_ari_response_error(
response, 500, "Internal Server Error", "Failed to create recording channel");
return;
}
bridge_topic = ast_bridge_topic(bridge);
channel_topic = ast_channel_topic(record_channel);
/* Forward messages from the recording channel topic to the bridge topic so that anything listening for
* messages on the bridge topic will receive the recording start/stop messages. Other messages that would
* go to this channel will be suppressed since the channel is marked as internal.
*/
if (!bridge_topic || !channel_topic || !(channel_forward = stasis_forward_all(channel_topic, bridge_topic))) {
ast_ari_response_error(
response, 500, "Internal Error", "Could not forward record channel stasis messages to bridge topic");
return;
}
if (ast_unreal_channel_push_to_bridge(record_channel, bridge,
AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE | AST_BRIDGE_CHANNEL_FLAG_LONELY)) {
ast_ari_response_error(
response, 500, "Internal Error", "Failed to put recording channel into the bridge");
return;
}
control = stasis_app_control_create(record_channel);
if (control == NULL) {
ast_ari_response_alloc_failed(response);
return;
}
options = stasis_app_recording_options_create(args->name, args->format);
if (options == NULL) {
ast_ari_response_alloc_failed(response);
return;
}
ast_string_field_build(options, target, "bridge:%s", args->bridge_id);
options->max_silence_seconds = args->max_silence_seconds;
options->max_duration_seconds = args->max_duration_seconds;
options->terminate_on =
stasis_app_recording_termination_parse(args->terminate_on);
options->if_exists =
stasis_app_recording_if_exists_parse(args->if_exists);
options->beep = args->beep;
if (options->terminate_on == STASIS_APP_RECORDING_TERMINATE_INVALID) {
ast_ari_response_error(
response, 400, "Bad Request",
"terminateOn invalid");
return;
}
if (options->if_exists == AST_RECORD_IF_EXISTS_ERROR) {
ast_ari_response_error(
response, 400, "Bad Request",
"ifExists invalid");
return;
}
if (!ast_get_format_for_file_ext(options->format)) {
ast_ari_response_error(
response, 422, "Unprocessable Entity",
"specified format is unknown on this system");
return;
}
recording = stasis_app_control_record(control, options);
if (recording == NULL) {
switch(errno) {
case EINVAL:
/* While the arguments are invalid, we should have
* caught them prior to calling record.
*/
ast_ari_response_error(
response, 500, "Internal Server Error",
"Error parsing request");
break;
case EEXIST:
ast_ari_response_error(response, 409, "Conflict",
"Recording '%s' already exists and can not be overwritten",
args->name);
break;
case ENOMEM:
ast_ari_response_alloc_failed(response);
break;
case EPERM:
ast_ari_response_error(
response, 400, "Bad Request",
"Recording name invalid");
break;
default:
ast_log(LOG_WARNING,
"Unrecognized recording error: %s\n",
strerror(errno));
ast_ari_response_error(
response, 500, "Internal Server Error",
"Internal Server Error");
break;
}
return;
}
uri_name_maxlen = strlen(args->name) * 3;
uri_encoded_name = ast_malloc(uri_name_maxlen);
if (!uri_encoded_name) {
ast_ari_response_alloc_failed(response);
return;
}
ast_uri_encode(args->name, uri_encoded_name, uri_name_maxlen, ast_uri_http);
if (ast_asprintf(&recording_url, "/recordings/live/%s",
uri_encoded_name) == -1) {
recording_url = NULL;
ast_ari_response_alloc_failed(response);
return;
}
json = stasis_app_recording_to_json(recording);
if (!json) {
ast_ari_response_alloc_failed(response);
return;
}
thread_data = ast_calloc(1, sizeof(*thread_data));
if (!thread_data) {
ast_ari_response_alloc_failed(response);
return;
}
thread_data->bridge_channel = record_channel;
thread_data->control = control;
thread_data->forward = channel_forward;
if (ast_pthread_create_detached(&threadid, NULL, bridge_channel_control_thread, thread_data)) {
ast_ari_response_alloc_failed(response);
ast_free(thread_data);
return;
}
/* These are owned by the other thread now, so we don't want RAII_VAR disposing of them. */
record_channel = NULL;
control = NULL;
channel_forward = NULL;
ast_ari_response_created(response, recording_url, ast_json_ref(json));
}
static void ari_bridges_play_new(const char *args_media,
const char *args_lang,
int args_offset_ms,
int args_skipms,
const char *args_playback_id,
struct ast_ari_response *response,
struct ast_bridge *bridge)
{
RAII_VAR(struct ast_channel *, play_channel, NULL, ast_hangup);
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
RAII_VAR(struct stasis_forward *, channel_forward, NULL, stasis_forward_cancel);
RAII_VAR(char *, playback_url, NULL, ast_free);
struct stasis_topic *channel_topic;
struct stasis_topic *bridge_topic;
struct bridge_channel_control_thread_data *thread_data;
pthread_t threadid;
if (!(play_channel = prepare_bridge_media_channel("Announcer"))) {
ast_ari_response_error(
response, 500, "Internal Error", "Could not create playback channel");
return;
}
ast_debug(1, "Created announcer channel '%s'\n", ast_channel_name(play_channel));
bridge_topic = ast_bridge_topic(bridge);
channel_topic = ast_channel_topic(play_channel);
/* Forward messages from the playback channel topic to the bridge topic so that anything listening for
* messages on the bridge topic will receive the playback start/stop messages. Other messages that would
* go to this channel will be suppressed since the channel is marked as internal.
*/
if (!bridge_topic || !channel_topic || !(channel_forward = stasis_forward_all(channel_topic, bridge_topic))) {
ast_ari_response_error(
response, 500, "Internal Error", "Could not forward playback channel stasis messages to bridge topic");
return;
}
if (ast_unreal_channel_push_to_bridge(play_channel, bridge,
AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE | AST_BRIDGE_CHANNEL_FLAG_LONELY)) {
ast_ari_response_error(
response, 500, "Internal Error", "Failed to put playback channel into the bridge");
return;
}
control = stasis_app_control_create(play_channel);
if (control == NULL) {
ast_ari_response_alloc_failed(response);
return;
}
ao2_lock(control);
if (ari_bridges_play_helper(args_media, args_lang, args_offset_ms,
args_skipms, args_playback_id, response, bridge, control,
&json, &playback_url)) {
ao2_unlock(control);
return;
}
ao2_unlock(control);
if (stasis_app_bridge_playback_channel_add(bridge, play_channel, control)) {
ast_ari_response_alloc_failed(response);
return;
}
/* Give play_channel and control reference to the thread data */
thread_data = ast_calloc(1, sizeof(*thread_data));
if (!thread_data) {
ast_ari_response_alloc_failed(response);
return;
}
thread_data->bridge_channel = play_channel;
thread_data->control = control;
thread_data->forward = channel_forward;
if (ast_pthread_create_detached(&threadid, NULL, bridge_channel_control_thread, thread_data)) {
ast_ari_response_alloc_failed(response);
ast_free(thread_data);
return;
}
/* These are owned by the other thread now, so we don't want RAII_VAR disposing of them. */
play_channel = NULL;
control = NULL;
channel_forward = NULL;
ast_ari_response_created(response, playback_url, ast_json_ref(json));
}
/*!
* \brief Stop monitoring channel
* \param chan
* \param need_lock
* Stop the recording, close any open streams, mix in/out channels if required
* \return Always 0
*/
int AST_OPTIONAL_API_NAME(ast_monitor_stop)(struct ast_channel *chan, int need_lock)
{
int delfiles = 0;
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
LOCK_IF_NEEDED(chan, need_lock);
if (ast_channel_monitor(chan)) {
char filename[ FILENAME_MAX ];
if (ast_channel_monitor(chan)->read_stream) {
ast_closestream(ast_channel_monitor(chan)->read_stream);
}
if (ast_channel_monitor(chan)->write_stream) {
ast_closestream(ast_channel_monitor(chan)->write_stream);
}
if (ast_channel_monitor(chan)->filename_changed && !ast_strlen_zero(ast_channel_monitor(chan)->filename_base)) {
if (ast_fileexists(ast_channel_monitor(chan)->read_filename,NULL,NULL) > 0) {
snprintf(filename, FILENAME_MAX, "%s-in", ast_channel_monitor(chan)->filename_base);
if (ast_fileexists(filename, NULL, NULL) > 0) {
ast_filedelete(filename, NULL);
}
ast_filerename(ast_channel_monitor(chan)->read_filename, filename, ast_channel_monitor(chan)->format);
} else {
ast_log(LOG_WARNING, "File %s not found\n", ast_channel_monitor(chan)->read_filename);
}
if (ast_fileexists(ast_channel_monitor(chan)->write_filename,NULL,NULL) > 0) {
snprintf(filename, FILENAME_MAX, "%s-out", ast_channel_monitor(chan)->filename_base);
if (ast_fileexists(filename, NULL, NULL) > 0) {
ast_filedelete(filename, NULL);
}
ast_filerename(ast_channel_monitor(chan)->write_filename, filename, ast_channel_monitor(chan)->format);
} else {
ast_log(LOG_WARNING, "File %s not found\n", ast_channel_monitor(chan)->write_filename);
}
}
if (ast_channel_monitor(chan)->joinfiles && !ast_strlen_zero(ast_channel_monitor(chan)->filename_base)) {
char tmp[1024];
char tmp2[1024];
const char *format = !strcasecmp(ast_channel_monitor(chan)->format,"wav49") ? "WAV" : ast_channel_monitor(chan)->format;
char *fname_base = ast_channel_monitor(chan)->filename_base;
const char *execute, *execute_args;
/* at this point, fname_base really is the full path */
/* Set the execute application */
execute = pbx_builtin_getvar_helper(chan, "MONITOR_EXEC");
if (ast_strlen_zero(execute)) {
#ifdef HAVE_SOXMIX
execute = "nice -n 19 soxmix";
#else
execute = "nice -n 19 sox -m";
#endif
format = get_soxmix_format(format);
delfiles = 1;
}
execute_args = pbx_builtin_getvar_helper(chan, "MONITOR_EXEC_ARGS");
if (ast_strlen_zero(execute_args)) {
execute_args = "";
}
snprintf(tmp, sizeof(tmp), "%s \"%s-in.%s\" \"%s-out.%s\" \"%s.%s\" %s &",
execute, fname_base, format, fname_base, format, fname_base, format,execute_args);
if (delfiles) {
snprintf(tmp2,sizeof(tmp2), "( %s& rm -f \"%s-\"* ) &",tmp, fname_base); /* remove legs when done mixing */
ast_copy_string(tmp, tmp2, sizeof(tmp));
}
ast_debug(1,"monitor executing %s\n",tmp);
if (ast_safe_system(tmp) == -1)
ast_log(LOG_WARNING, "Execute of %s failed.\n",tmp);
}
if (!ast_strlen_zero(ast_channel_monitor(chan)->beep_id)) {
ast_beep_stop(chan, ast_channel_monitor(chan)->beep_id);
}
ast_free(ast_channel_monitor(chan)->format);
ast_free(ast_channel_monitor(chan));
ast_channel_monitor_set(chan, NULL);
message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan),
ast_channel_monitor_stop_type(),
NULL);
if (message) {
stasis_publish(ast_channel_topic(chan), message);
}
pbx_builtin_setvar_helper(chan, "MONITORED", NULL);
}
pbx_builtin_setvar_helper(chan, "AUTO_MONITOR", NULL);
UNLOCK_IF_NEEDED(chan, need_lock);
return 0;
}
/*! \brief Start monitoring a channel
* \param chan ast_channel struct to record
* \param format_spec file format to use for recording
* \param fname_base filename base to record to
* \param need_lock whether to lock the channel mutex
* \param stream_action whether to record the input and/or output streams. X_REC_IN | X_REC_OUT is most often used
* Creates the file to record, if no format is specified it assumes WAV
* It also sets channel variable __MONITORED=yes
* \retval 0 on success
* \retval -1 on failure
*/
int AST_OPTIONAL_API_NAME(ast_monitor_start)(struct ast_channel *chan, const char *format_spec,
const char *fname_base, int need_lock, int stream_action,
const char *beep_id)
{
int res = 0;
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
LOCK_IF_NEEDED(chan, need_lock);
if (!(ast_channel_monitor(chan))) {
struct ast_channel_monitor *monitor;
char *channel_name, *p;
/* Create monitoring directory if needed */
ast_mkdir(ast_config_AST_MONITOR_DIR, 0777);
if (!(monitor = ast_calloc(1, sizeof(*monitor)))) {
UNLOCK_IF_NEEDED(chan, need_lock);
return -1;
}
if (!ast_strlen_zero(beep_id)) {
ast_copy_string(monitor->beep_id, beep_id, sizeof(monitor->beep_id));
}
/* Determine file names */
if (!ast_strlen_zero(fname_base)) {
int directory = strchr(fname_base, '/') ? 1 : 0;
const char *absolute = *fname_base == '/' ? "" : ast_config_AST_MONITOR_DIR;
const char *absolute_suffix = *fname_base == '/' ? "" : "/";
snprintf(monitor->read_filename, FILENAME_MAX, "%s%s%s-in",
absolute, absolute_suffix, fname_base);
snprintf(monitor->write_filename, FILENAME_MAX, "%s%s%s-out",
absolute, absolute_suffix, fname_base);
snprintf(monitor->filename_base, FILENAME_MAX, "%s%s%s",
absolute, absolute_suffix, fname_base);
/* try creating the directory just in case it doesn't exist */
if (directory) {
char *name = ast_strdupa(monitor->filename_base);
ast_mkdir(dirname(name), 0777);
}
} else {
ast_mutex_lock(&monitorlock);
snprintf(monitor->read_filename, FILENAME_MAX, "%s/audio-in-%lu",
ast_config_AST_MONITOR_DIR, seq);
snprintf(monitor->write_filename, FILENAME_MAX, "%s/audio-out-%lu",
ast_config_AST_MONITOR_DIR, seq);
seq++;
ast_mutex_unlock(&monitorlock);
/* Replace all '/' chars from the channel name with '-' chars. */
channel_name = ast_strdupa(ast_channel_name(chan));
for (p = channel_name; (p = strchr(p, '/')); ) {
*p = '-';
}
snprintf(monitor->filename_base, FILENAME_MAX, "%s/%d-%s",
ast_config_AST_MONITOR_DIR, (int)time(NULL), channel_name);
monitor->filename_changed = 1;
}
monitor->stop = ast_monitor_stop;
/* Determine file format */
if (!ast_strlen_zero(format_spec)) {
monitor->format = ast_strdup(format_spec);
} else {
monitor->format = ast_strdup("wav");
}
/* open files */
if (stream_action & X_REC_IN) {
if (ast_fileexists(monitor->read_filename, NULL, NULL) > 0)
ast_filedelete(monitor->read_filename, NULL);
if (!(monitor->read_stream = ast_writefile(monitor->read_filename,
monitor->format, NULL,
O_CREAT|O_TRUNC|O_WRONLY, 0, AST_FILE_MODE))) {
ast_log(LOG_WARNING, "Could not create file %s\n",
monitor->read_filename);
ast_free(monitor);
UNLOCK_IF_NEEDED(chan, need_lock);
return -1;
}
} else
monitor->read_stream = NULL;
if (stream_action & X_REC_OUT) {
if (ast_fileexists(monitor->write_filename, NULL, NULL) > 0) {
ast_filedelete(monitor->write_filename, NULL);
}
if (!(monitor->write_stream = ast_writefile(monitor->write_filename,
monitor->format, NULL,
O_CREAT|O_TRUNC|O_WRONLY, 0, AST_FILE_MODE))) {
ast_log(LOG_WARNING, "Could not create file %s\n",
monitor->write_filename);
if (monitor->read_stream) {
ast_closestream(monitor->read_stream);
}
ast_free(monitor);
UNLOCK_IF_NEEDED(chan, need_lock);
return -1;
}
} else
monitor->write_stream = NULL;
ast_channel_insmpl_set(chan, 0);
ast_channel_outsmpl_set(chan, 0);
ast_channel_monitor_set(chan, monitor);
ast_monitor_set_state(chan, AST_MONITOR_RUNNING);
/* so we know this call has been monitored in case we need to bill for it or something */
pbx_builtin_setvar_helper(chan, "__MONITORED","true");
message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan),
ast_channel_monitor_start_type(),
NULL);
if (message) {
stasis_publish(ast_channel_topic(chan), message);
}
} else {
ast_debug(1,"Cannot start monitoring %s, already monitored\n", ast_channel_name(chan));
res = -1;
}
UNLOCK_IF_NEEDED(chan, need_lock);
return res;
}
static int t38_tx_packet_handler(t38_core_state_t *s, void *user_data, const uint8_t *buf, int len, int count)
{
struct ast_channel *chan = (struct ast_channel *) user_data;
struct ast_frame outf = {
.frametype = AST_FRAME_MODEM,
.subclass.integer = AST_MODEM_T38,
.src = __FUNCTION__,
};
/* TODO: Asterisk does not provide means of resending the same packet multiple
times so count is ignored at the moment */
AST_FRAME_SET_BUFFER(&outf, buf, 0, len);
if (ast_write(chan, &outf) < 0) {
ast_log(LOG_WARNING, "Unable to write frame to channel; %s\n", strerror(errno));
return -1;
}
return 0;
}
static void phase_e_handler(t30_state_t *f, void *user_data, int result)
{
RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
RAII_VAR(struct ast_json *, json_filenames, NULL, ast_json_unref);
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
const char *local_ident;
const char *far_ident;
char buf[20];
fax_session *s = (fax_session *) user_data;
t30_stats_t stat;
int pages_transferred;
ast_debug(1, "Fax phase E handler. result=%d\n", result);
t30_get_transfer_statistics(f, &stat);
s = (fax_session *) user_data;
if (result != T30_ERR_OK) {
s->finished = -1;
/* FAXSTATUS is already set to FAILED */
pbx_builtin_setvar_helper(s->chan, "FAXERROR", t30_completion_code_to_str(result));
ast_log(LOG_WARNING, "Error transmitting fax. result=%d: %s.\n", result, t30_completion_code_to_str(result));
return;
}
s->finished = 1;
local_ident = S_OR(t30_get_tx_ident(f), "");
far_ident = S_OR(t30_get_rx_ident(f), "");
pbx_builtin_setvar_helper(s->chan, "FAXSTATUS", "SUCCESS");
pbx_builtin_setvar_helper(s->chan, "FAXERROR", NULL);
pbx_builtin_setvar_helper(s->chan, "REMOTESTATIONID", far_ident);
#if SPANDSP_RELEASE_DATE >= 20090220
pages_transferred = (s->direction) ? stat.pages_tx : stat.pages_rx;
#else
pages_transferred = stat.pages_transferred;
#endif
snprintf(buf, sizeof(buf), "%d", pages_transferred);
pbx_builtin_setvar_helper(s->chan, "FAXPAGES", buf);
snprintf(buf, sizeof(buf), "%d", stat.y_resolution);
pbx_builtin_setvar_helper(s->chan, "FAXRESOLUTION", buf);
snprintf(buf, sizeof(buf), "%d", stat.bit_rate);
pbx_builtin_setvar_helper(s->chan, "FAXBITRATE", buf);
ast_debug(1, "Fax transmitted successfully.\n");
ast_debug(1, " Remote station ID: %s\n", far_ident);
ast_debug(1, " Pages transferred: %d\n", pages_transferred);
ast_debug(1, " Image resolution: %d x %d\n", stat.x_resolution, stat.y_resolution);
ast_debug(1, " Transfer Rate: %d\n", stat.bit_rate);
json_filenames = ast_json_pack("[s]", s->file_name);
if (!json_filenames) {
return;
}
ast_json_ref(json_filenames);
json_object = ast_json_pack("{s: s, s: s, s: s, s: i, s: i, s: i, s: o}",
"type", s->direction ? "send" : "receive",
"remote_station_id", far_ident,
"local_station_id", local_ident,
"fax_pages", pages_transferred,
"fax_resolution", stat.y_resolution,
"fax_bitrate", stat.bit_rate,
"filenames", json_filenames);
message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(s->chan), ast_channel_fax_type(), json_object);
if (!message) {
return;
}
stasis_publish(ast_channel_topic(s->chan), message);
}
void ast_channel_publish_dial_forward(struct ast_channel *caller, struct ast_channel *peer,
struct ast_channel *forwarded, const char *dialstring, const char *dialstatus,
const char *forward)
{
RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
RAII_VAR(struct ast_channel_snapshot *, caller_snapshot, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, peer_snapshot, NULL, ao2_cleanup);
RAII_VAR(struct ast_channel_snapshot *, forwarded_snapshot, NULL, ao2_cleanup);
ast_assert(peer != NULL);
blob = ast_json_pack("{s: s, s: s, s: s}",
"dialstatus", S_OR(dialstatus, ""),
"forward", S_OR(forward, ""),
"dialstring", S_OR(dialstring, ""));
if (!blob) {
return;
}
payload = ast_multi_channel_blob_create(blob);
if (!payload) {
return;
}
if (caller) {
ast_channel_lock(caller);
caller_snapshot = ast_channel_snapshot_create(caller);
ast_channel_unlock(caller);
if (!caller_snapshot) {
return;
}
ast_multi_channel_blob_add_channel(payload, "caller", caller_snapshot);
}
ast_channel_lock(peer);
peer_snapshot = ast_channel_snapshot_create(peer);
ast_channel_unlock(peer);
if (!peer_snapshot) {
return;
}
ast_multi_channel_blob_add_channel(payload, "peer", peer_snapshot);
if (forwarded) {
ast_channel_lock(forwarded);
forwarded_snapshot = ast_channel_snapshot_create(forwarded);
ast_channel_unlock(forwarded);
if (!forwarded_snapshot) {
return;
}
ast_multi_channel_blob_add_channel(payload, "forwarded", forwarded_snapshot);
}
msg = stasis_message_create(ast_channel_dial_type(), payload);
if (!msg) {
return;
}
if (forwarded) {
struct stasis_subscription *subscription = stasis_subscribe(ast_channel_topic(peer), dummy_event_cb, NULL);
stasis_publish(ast_channel_topic(peer), msg);
stasis_unsubscribe_and_join(subscription);
} else {
publish_message_for_channel_topics(msg, caller);
}
}
