static struct ast_channel *rec_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *data, int *cause)
{
struct ast_channel *chan;
struct ast_format format;
const char *conf_name = data;
chan = ast_channel_alloc(1, AST_STATE_UP, NULL, NULL, NULL, NULL, NULL, NULL, 0,
"CBRec/conf-%s-uid-%d",
conf_name, (int) ast_random());
if (!chan) {
return NULL;
}
if (ast_channel_add_bridge_role(chan, "recorder")) {
ast_channel_release(chan);
return NULL;
}
ast_format_set(&format, AST_FORMAT_SLINEAR, 0);
ast_channel_tech_set(chan, conf_record_get_tech());
ast_format_cap_add_all(ast_channel_nativeformats(chan));
ast_format_copy(ast_channel_writeformat(chan), &format);
ast_format_copy(ast_channel_rawwriteformat(chan), &format);
ast_format_copy(ast_channel_readformat(chan), &format);
ast_format_copy(ast_channel_rawreadformat(chan), &format);
return chan;
}
/*! \brief Function called when we should prepare to call the destination */
static struct ast_channel *multicast_rtp_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *data, int *cause)
{
char *tmp = ast_strdupa(data), *multicast_type = tmp, *destination, *control;
struct ast_rtp_instance *instance;
struct ast_sockaddr control_address;
struct ast_sockaddr destination_address;
struct ast_channel *chan;
struct ast_format fmt;
ast_best_codec(cap, &fmt);
ast_sockaddr_setnull(&control_address);
/* If no type was given we can't do anything */
if (ast_strlen_zero(multicast_type)) {
goto failure;
}
if (!(destination = strchr(tmp, '/'))) {
goto failure;
}
*destination++ = '\0';
if ((control = strchr(destination, '/'))) {
*control++ = '\0';
if (!ast_sockaddr_parse(&control_address, control,
PARSE_PORT_REQUIRE)) {
goto failure;
}
}
if (!ast_sockaddr_parse(&destination_address, destination,
PARSE_PORT_REQUIRE)) {
goto failure;
}
if (!(instance = ast_rtp_instance_new("multicast", NULL, &control_address, multicast_type))) {
goto failure;
}
if (!(chan = ast_channel_alloc(1, AST_STATE_DOWN, "", "", "", "", "", requestor ? ast_channel_linkedid(requestor) : "", 0, "MulticastRTP/%p", instance))) {
ast_rtp_instance_destroy(instance);
goto failure;
}
ast_rtp_instance_set_channel_id(instance, ast_channel_uniqueid(chan));
ast_rtp_instance_set_remote_address(instance, &destination_address);
ast_channel_tech_set(chan, &multicast_rtp_tech);
ast_format_cap_add(ast_channel_nativeformats(chan), &fmt);
ast_format_copy(ast_channel_writeformat(chan), &fmt);
ast_format_copy(ast_channel_rawwriteformat(chan), &fmt);
ast_format_copy(ast_channel_readformat(chan), &fmt);
ast_format_copy(ast_channel_rawreadformat(chan), &fmt);
ast_channel_tech_pvt_set(chan, instance);
return chan;
failure:
*cause = AST_CAUSE_FAILURE;
return NULL;
}
struct ast_unreal_pvt *ast_unreal_alloc(size_t size, ao2_destructor_fn destructor, struct ast_format_cap *cap)
{
struct ast_unreal_pvt *unreal;
static const struct ast_jb_conf jb_conf = {
.flags = 0,
.max_size = -1,
.resync_threshold = -1,
.impl = "",
.target_extra = -1,
};
unreal = ao2_alloc(size, destructor);
if (!unreal) {
return NULL;
}
unreal->reqcap = ast_format_cap_dup(cap);
if (!unreal->reqcap) {
ao2_ref(unreal, -1);
return NULL;
}
memcpy(&unreal->jb_conf, &jb_conf, sizeof(unreal->jb_conf));
return unreal;
}
struct ast_channel *ast_unreal_new_channels(struct ast_unreal_pvt *p,
const struct ast_channel_tech *tech, int semi1_state, int semi2_state,
const char *exten, const char *context, const struct ast_assigned_ids *assignedids,
const struct ast_channel *requestor, struct ast_callid *callid)
{
struct ast_channel *owner;
struct ast_channel *chan;
struct ast_format fmt;
struct ast_assigned_ids id1 = {NULL, NULL};
struct ast_assigned_ids id2 = {NULL, NULL};
int generated_seqno = ast_atomic_fetchadd_int((int *) &name_sequence, +1);
/* set unique ids for the two channels */
if (assignedids && !ast_strlen_zero(assignedids->uniqueid)) {
id1.uniqueid = assignedids->uniqueid;
id2.uniqueid = assignedids->uniqueid2;
}
/* if id1 given but not id2, use default of id1;2 */
if (id1.uniqueid && ast_strlen_zero(id2.uniqueid)) {
char *uniqueid2;
uniqueid2 = ast_alloca(strlen(id1.uniqueid) + 2);
strcpy(uniqueid2, id1.uniqueid);/* Safe */
strcat(uniqueid2, ";2");/* Safe */
id2.uniqueid = uniqueid2;
}
/*
* Allocate two new Asterisk channels
*
* Make sure that the ;2 channel gets the same linkedid as ;1.
* You can't pass linkedid to both allocations since if linkedid
* isn't set, then each channel will generate its own linkedid.
*/
if (!(owner = ast_channel_alloc(1, semi1_state, NULL, NULL, NULL,
exten, context, &id1, requestor, 0,
"%s/%s-%08x;1", tech->type, p->name, generated_seqno))) {
ast_log(LOG_WARNING, "Unable to allocate owner channel structure\n");
return NULL;
}
if (callid) {
ast_channel_callid_set(owner, callid);
}
ast_channel_tech_set(owner, tech);
ao2_ref(p, +1);
ast_channel_tech_pvt_set(owner, p);
ast_format_cap_copy(ast_channel_nativeformats(owner), p->reqcap);
/* Determine our read/write format and set it on each channel */
ast_best_codec(p->reqcap, &fmt);
ast_format_copy(ast_channel_writeformat(owner), &fmt);
ast_format_copy(ast_channel_rawwriteformat(owner), &fmt);
ast_format_copy(ast_channel_readformat(owner), &fmt);
ast_format_copy(ast_channel_rawreadformat(owner), &fmt);
ast_set_flag(ast_channel_flags(owner), AST_FLAG_DISABLE_DEVSTATE_CACHE);
ast_jb_configure(owner, &p->jb_conf);
if (ast_channel_cc_params_init(owner, requestor
? ast_channel_get_cc_config_params((struct ast_channel *) requestor) : NULL)) {
ao2_ref(p, -1);
ast_channel_unlock(owner);
ast_channel_release(owner);
return NULL;
}
p->owner = owner;
ast_channel_unlock(owner);
if (!(chan = ast_channel_alloc(1, semi2_state, NULL, NULL, NULL,
exten, context, &id2, owner, 0,
"%s/%s-%08x;2", tech->type, p->name, generated_seqno))) {
ast_log(LOG_WARNING, "Unable to allocate chan channel structure\n");
ao2_ref(p, -1);
ast_channel_release(owner);
return NULL;
}
if (callid) {
ast_channel_callid_set(chan, callid);
}
ast_channel_tech_set(chan, tech);
ao2_ref(p, +1);
ast_channel_tech_pvt_set(chan, p);
ast_format_cap_copy(ast_channel_nativeformats(chan), p->reqcap);
/* Format was already determined when setting up owner */
ast_format_copy(ast_channel_writeformat(chan), &fmt);
ast_format_copy(ast_channel_rawwriteformat(chan), &fmt);
ast_format_copy(ast_channel_readformat(chan), &fmt);
ast_format_copy(ast_channel_rawreadformat(chan), &fmt);
ast_set_flag(ast_channel_flags(chan), AST_FLAG_DISABLE_DEVSTATE_CACHE);
p->chan = chan;
ast_channel_unlock(chan);
return owner;
}
struct ast_channel *stasis_app_control_snoop(struct ast_channel *chan,
enum stasis_app_snoop_direction spy, enum stasis_app_snoop_direction whisper,
const char *app, const char *app_args, const char *snoop_id)
{
RAII_VAR(struct stasis_app_snoop *, snoop, NULL, ao2_cleanup);
struct ast_format_cap *caps;
pthread_t thread;
struct ast_assigned_ids assignedids = {
.uniqueid = snoop_id,
};
if (spy == STASIS_SNOOP_DIRECTION_NONE &&
whisper == STASIS_SNOOP_DIRECTION_NONE) {
return NULL;
}
snoop = ao2_alloc_options(sizeof(*snoop), snoop_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
if (!snoop) {
return NULL;
}
/* Allocate a buffer to store the Stasis application and arguments in */
snoop->app = ast_str_create(64);
if (!snoop->app) {
return NULL;
}
ast_str_set(&snoop->app, 0, "%s", app);
if (!ast_strlen_zero(app_args)) {
ast_str_append(&snoop->app, 0, ",%s", app_args);
}
/* Set up a timer for the Snoop channel so it wakes up at a specific interval */
snoop->timer = ast_timer_open();
if (!snoop->timer) {
return NULL;
}
ast_timer_set_rate(snoop->timer, 1000 / SNOOP_INTERVAL);
/* Determine which signed linear format should be used */
snoop_determine_format(chan, snoop);
/* Allocate a Snoop channel and set up various parameters */
snoop->chan = ast_channel_alloc(1, AST_STATE_UP, "", "", "", "", "", &assignedids, NULL, 0, "Snoop/%s-%08x", ast_channel_uniqueid(chan),
(unsigned)ast_atomic_fetchadd_int((int *)&chan_idx, +1));
if (!snoop->chan) {
return NULL;
}
ast_copy_string(snoop->uniqueid, ast_channel_uniqueid(chan), sizeof(snoop->uniqueid));
/* To keep the channel valid on the Snoop structure until it is destroyed we bump the ref up here */
ast_channel_ref(snoop->chan);
ast_channel_tech_set(snoop->chan, &snoop_tech);
ao2_ref(snoop, +1);
ast_channel_tech_pvt_set(snoop->chan, snoop);
ast_channel_set_fd(snoop->chan, 0, ast_timer_fd(snoop->timer));
/* The format on the Snoop channel will be this signed linear format, and it will never change */
caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
if (!caps) {
ast_channel_unlock(snoop->chan);
ast_hangup(snoop->chan);
return NULL;
}
ast_format_cap_append(caps, snoop->spy_format, 0);
ast_channel_nativeformats_set(snoop->chan, caps);
ao2_ref(caps, -1);
ast_channel_set_writeformat(snoop->chan, snoop->spy_format);
ast_channel_set_rawwriteformat(snoop->chan, snoop->spy_format);
ast_channel_set_readformat(snoop->chan, snoop->spy_format);
ast_channel_set_rawreadformat(snoop->chan, snoop->spy_format);
ast_channel_unlock(snoop->chan);
if (spy != STASIS_SNOOP_DIRECTION_NONE) {
if (snoop_setup_audiohook(chan, AST_AUDIOHOOK_TYPE_SPY, spy, &snoop->spy_direction, &snoop->spy)) {
ast_hangup(snoop->chan);
return NULL;
}
snoop->spy_samples = ast_format_get_sample_rate(snoop->spy_format) / (1000 / SNOOP_INTERVAL);
snoop->spy_active = 1;
}
/* If whispering is enabled set up the audiohook */
if (whisper != STASIS_SNOOP_DIRECTION_NONE) {
if (snoop_setup_audiohook(chan, AST_AUDIOHOOK_TYPE_WHISPER, whisper, &snoop->whisper_direction, &snoop->whisper)) {
ast_hangup(snoop->chan);
return NULL;
}
snoop->whisper_active = 1;
}
/* Create the thread which services the Snoop channel */
ao2_ref(snoop, +1);
if (ast_pthread_create_detached_background(&thread, NULL, snoop_stasis_thread, snoop)) {
ao2_cleanup(snoop);
/* No other thread is servicing this channel so we can immediately hang it up */
ast_hangup(snoop->chan);
return NULL;
}
publish_chanspy_message(snoop, 1);
/* The caller of this has a reference as well */
return ast_channel_ref(snoop->chan);
}