void ast_ari_channels_hangup(struct ast_variable *headers,
struct ast_ari_channels_hangup_args *args,
struct ast_ari_response *response)
{
RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup);
int cause;
chan = ast_channel_get_by_name(args->channel_id);
if (chan == NULL) {
ast_ari_response_error(
response, 404, "Not Found",
"Channel not found");
return;
}
if (ast_strlen_zero(args->reason) || !strcmp(args->reason, "normal")) {
cause = AST_CAUSE_NORMAL;
} else if (!strcmp(args->reason, "busy")) {
cause = AST_CAUSE_BUSY;
} else if (!strcmp(args->reason, "congestion")) {
cause = AST_CAUSE_CONGESTION;
} else {
ast_ari_response_error(
response, 400, "Invalid Reason",
"Invalid reason for hangup provided");
return;
}
ast_channel_hangupcause_set(chan, cause);
ast_softhangup(chan, AST_SOFTHANGUP_EXPLICIT);
ast_ari_response_no_content(response);
}
/*! \brief Check whether RTP is being received or not */
static int rtp_check_timeout(const void *data)
{
struct ast_sip_session_media *session_media = (struct ast_sip_session_media *)data;
struct ast_rtp_instance *rtp = session_media->rtp;
int elapsed;
struct ast_channel *chan;
if (!rtp) {
return 0;
}
elapsed = time(NULL) - ast_rtp_instance_get_last_rx(rtp);
if (elapsed < ast_rtp_instance_get_timeout(rtp)) {
return (ast_rtp_instance_get_timeout(rtp) - elapsed) * 1000;
}
chan = ast_channel_get_by_name(ast_rtp_instance_get_channel_id(rtp));
if (!chan) {
return 0;
}
ast_log(LOG_NOTICE, "Disconnecting channel '%s' for lack of RTP activity in %d seconds\n",
ast_channel_name(chan), elapsed);
ast_softhangup(chan, AST_SOFTHANGUP_DEV);
ast_channel_unref(chan);
return 0;
}
/*!
* \internal
* \brief Shutdown the local proxy channel.
* \since 12.0.0
*
* \return Nothing
*/
static void local_shutdown(void)
{
struct local_pvt *p;
struct ao2_iterator it;
/* First, take us out of the channel loop */
ast_cli_unregister_multiple(cli_local, ARRAY_LEN(cli_local));
ast_manager_unregister("LocalOptimizeAway");
ast_channel_unregister(&local_tech);
it = ao2_iterator_init(locals, 0);
while ((p = ao2_iterator_next(&it))) {
if (p->base.owner) {
ast_softhangup(p->base.owner, AST_SOFTHANGUP_APPUNLOAD);
}
ao2_ref(p, -1);
}
ao2_iterator_destroy(&it);
ao2_ref(locals, -1);
locals = NULL;
ao2_cleanup(local_tech.capabilities);
local_tech.capabilities = NULL;
STASIS_MESSAGE_TYPE_CLEANUP(ast_local_optimization_begin_type);
STASIS_MESSAGE_TYPE_CLEANUP(ast_local_optimization_end_type);
STASIS_MESSAGE_TYPE_CLEANUP(ast_local_bridge_type);
}
static int __unload_module(void)
{
struct phone_pvt *p, *pl;
/* First, take us out of the channel loop */
ast_channel_unregister(type);
if (!ast_mutex_lock(&iflock)) {
/* Hangup all interfaces if they have an owner */
p = iflist;
while(p) {
if (p->owner)
ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
p = p->next;
}
iflist = NULL;
ast_mutex_unlock(&iflock);
} else {
ast_log(LOG_WARNING, "Unable to lock the monitor\n");
return -1;
}
if (!ast_mutex_lock(&monlock)) {
if (monitor_thread > AST_PTHREADT_NULL) {
pthread_cancel(monitor_thread);
pthread_join(monitor_thread, NULL);
}
monitor_thread = AST_PTHREADT_STOP;
ast_mutex_unlock(&monlock);
} else {
ast_log(LOG_WARNING, "Unable to lock the monitor\n");
return -1;
}
if (!ast_mutex_lock(&iflock)) {
/* Destroy all the interfaces and free their memory */
p = iflist;
while(p) {
/* Close the socket, assuming it's real */
if (p->fd > -1)
close(p->fd);
pl = p;
p = p->next;
/* Free associated memory */
free(pl);
}
iflist = NULL;
ast_mutex_unlock(&iflock);
} else {
ast_log(LOG_WARNING, "Unable to lock the monitor\n");
return -1;
}
return 0;
}
static int start_spying(struct ast_channel *chan, const char *spychan_name, struct ast_audiohook *audiohook)
{
int res = 0;
struct ast_channel *peer = NULL;
ast_log(LOG_NOTICE, "Attaching %s to %s\n", spychan_name, chan->name);
res = ast_audiohook_attach(chan, audiohook);
if (!res && ast_test_flag(chan, AST_FLAG_NBRIDGE) && (peer = ast_bridged_channel(chan))) {
ast_softhangup(peer, AST_SOFTHANGUP_UNBRIDGE);
}
return res;
}
static int start_spying(struct ast_autochan *autochan, const char *spychan_name, struct ast_audiohook *audiohook)
{
int res = 0;
struct ast_channel *peer = NULL;
ast_log(LOG_NOTICE, "Attaching %s to %s\n", spychan_name, autochan->chan->name);
ast_set_flag(audiohook, AST_AUDIOHOOK_TRIGGER_SYNC | AST_AUDIOHOOK_SMALL_QUEUE);
res = ast_audiohook_attach(autochan->chan, audiohook);
if (!res && ast_test_flag(autochan->chan, AST_FLAG_NBRIDGE) && (peer = ast_bridged_channel(autochan->chan))) {
ast_softhangup(peer, AST_SOFTHANGUP_UNBRIDGE);
}
return res;
}
static int startmon(struct ast_channel *chan, struct ast_audiohook *audiohook)
{
struct ast_channel *peer = NULL;
int res = 0;
if (!chan)
return -1;
ast_audiohook_attach(chan, audiohook);
if (!res && ast_test_flag(ast_channel_flags(chan), AST_FLAG_NBRIDGE) && (peer = ast_bridged_channel(chan)))
ast_softhangup(peer, AST_SOFTHANGUP_UNBRIDGE);
return res;
}
static int start_spying(struct ast_channel *chan, struct ast_channel *spychan, struct ast_channel_spy *spy)
{
int res;
struct ast_channel *peer;
ast_log(LOG_NOTICE, "Attaching %s to %s\n", spychan->name, chan->name);
ast_mutex_lock(&chan->lock);
res = ast_channel_spy_add(chan, spy);
ast_mutex_unlock(&chan->lock);
if (!res && ast_test_flag(chan, AST_FLAG_NBRIDGE) && (peer = ast_bridged_channel(chan))) {
ast_softhangup(peer, AST_SOFTHANGUP_UNBRIDGE);
}
return res;
}
int unload_module()
{
struct ast_filestream *tmp, *tmpl;
if (ast_mutex_lock(&g723_lock)) {
ast_log(LOG_WARNING, "Unable to lock g723 list\n");
return -1;
}
tmp = glist;
while(tmp) {
if (tmp->owner)
ast_softhangup(tmp->owner, AST_SOFTHANGUP_APPUNLOAD);
tmpl = tmp;
tmp = tmp->next;
free(tmpl);
}
ast_mutex_unlock(&g723_lock);
return ast_format_unregister(name);
}
static int handle_softhangup(int fd, int argc, char *argv[])
{
struct ast_channel *c=NULL;
if (argc != 3)
return RESULT_SHOWUSAGE;
c = ast_channel_walk_locked(NULL);
while(c) {
if (!strcasecmp(c->name, argv[2])) {
ast_cli(fd, "Requested Hangup on channel '%s'\n", c->name);
ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
ast_mutex_unlock(&c->lock);
break;
}
ast_mutex_unlock(&c->lock);
c = ast_channel_walk_locked(c);
}
if (!c)
ast_cli(fd, "%s is not a known channel\n", argv[2]);
return RESULT_SUCCESS;
}
static int softhangup_exec(struct ast_channel *chan, void *data)
{
struct localuser *u;
struct ast_channel *c=NULL;
if (!data) {
ast_log(LOG_WARNING, "SoftHangup requires an argument (Technology/resource)\n");
return 0;
}
LOCAL_USER_ADD(u);
c = ast_channel_walk_locked(NULL);
while (c) {
if (!strcasecmp(c->name, data)) {
ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
ast_mutex_unlock(&c->lock);
break;
}
ast_mutex_unlock(&c->lock);
c = ast_channel_walk_locked(c);
}
LOCAL_USER_REMOVE(u);
return 0;
}
static int hangup_channel(struct stasis_app_control *control,
struct ast_channel *chan, void *data)
{
ast_softhangup(chan, AST_SOFTHANGUP_EXPLICIT);
return 0;
}
