autoservice.c File Reference

Automatic channel service routines. More...

#include "asterisk.h"
#include <sys/time.h>
#include <signal.h>
#include "asterisk/_private.h"
#include "asterisk/pbx.h"
#include "asterisk/frame.h"
#include "asterisk/sched.h"
#include "asterisk/channel.h"
#include "asterisk/file.h"
#include "asterisk/translate.h"
#include "asterisk/manager.h"
#include "asterisk/chanvars.h"
#include "asterisk/linkedlists.h"
#include "asterisk/indications.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"

Include dependency graph for autoservice.c:

Go to the source code of this file.

Data Structures
struct	asent
struct	aslist

Macros
#define	MAX_AUTOMONS   1500

Functions
void	ast_autoservice_chan_hangup_peer (struct ast_channel *chan, struct ast_channel *peer)
	Put chan into autoservice while hanging up peer. More...
int	ast_autoservice_ignore (struct ast_channel *chan, enum ast_frame_type ftype)
	Ignore certain frame types. More...
void	ast_autoservice_init (void)
int	ast_autoservice_start (struct ast_channel *chan)
	Automatically service a channel for us... More...
int	ast_autoservice_stop (struct ast_channel *chan)
	Stop servicing a channel for us... More...
static void *	autoservice_run (void *ign)
static void	autoservice_shutdown (void)

Variables
static int	as_chan_list_state
static ast_cond_t	as_cond
static volatile int	asexit = 0
static struct aslist	aslist = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
static pthread_t	asthread = AST_PTHREADT_NULL

Detailed Description

Automatic channel service routines.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Russell Bryant russe.nosp@m.ll@d.nosp@m.igium.nosp@m..com

Definition in file autoservice.c.

Macro Definition Documentation

MAX_AUTOMONS

#define MAX_AUTOMONS   1500

Definition at line 52 of file autoservice.c.

Function Documentation

ast_autoservice_chan_hangup_peer()

void ast_autoservice_chan_hangup_peer	(	struct ast_channel *	chan,
		struct ast_channel *	peer
	)

Put chan into autoservice while hanging up peer.

Since

11.0

Parameters

chan	Chan to put into autoservice.
peer	Chan to run hangup handlers and hangup.

Definition at line 349 of file autoservice.c.

{
    if (chan && !ast_autoservice_start(chan)) {
        ast_hangup(peer);
        ast_autoservice_stop(chan);
    } else {
        ast_hangup(peer);
    }
}

References ast_autoservice_start(), ast_autoservice_stop(), and ast_hangup().

Referenced by app_exec(), bridge_failed_peer_goto(), dial_exec_full(), and try_calling().

ast_autoservice_ignore()

int ast_autoservice_ignore	(	struct ast_channel *	chan,
		enum ast_frame_type	ftype
	)

Ignore certain frame types.

Note

Normally, we cache DTMF, IMAGE, HTML, TEXT, and CONTROL frames while a channel is in autoservice and queue them up when taken out of autoservice. When this is not desireable, this API may be used to cause the channel to ignore those frametypes after the channel is put into autoservice, but before autoservice is stopped.

Return values

0	success
-1	channel is not in autoservice

Definition at line 359 of file autoservice.c.

{
    struct asent *as;
    int res = -1;
 
    AST_LIST_LOCK(&aslist);
    AST_LIST_TRAVERSE(&aslist, as, list) {
        if (as->chan == chan) {
            res = 0;
            as->ignore_frame_types |= (1 << ftype);
            break;
        }
    }
    AST_LIST_UNLOCK(&aslist);
    return res;
}

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, asent::chan, asent::ignore_frame_types, and asent::list.

ast_autoservice_init()

void ast_autoservice_init

(

void

)

Provided by autoservice.c

Definition at line 387 of file autoservice.c.

{
    ast_register_cleanup(autoservice_shutdown);
    ast_cond_init(&as_cond, NULL);
}

References as_cond, ast_cond_init, ast_register_cleanup(), autoservice_shutdown(), and NULL.

Referenced by asterisk_daemon().

ast_autoservice_start()

int ast_autoservice_start

(

struct ast_channel *

chan

)

Automatically service a channel for us...

Return values

0	success
-1	failure, or the channel is already being autoserviced

Definition at line 200 of file autoservice.c.

{
    int res = 0;
    struct asent *as;
 
    if (ast_thread_is_user_interface()) {
        /* User interface threads do not handle channel media. */
        ast_debug(1, "Thread is a user interface, not putting channel %s into autoservice\n",
            ast_channel_name(chan));
        return 0;
    }
 
    AST_LIST_LOCK(&aslist);
    AST_LIST_TRAVERSE(&aslist, as, list) {
        if (as->chan == chan) {
            as->use_count++;
            break;
        }
    }
    AST_LIST_UNLOCK(&aslist);
 
    if (as) {
        /* Entry exists, autoservice is already handling this channel */
        return 0;
    }
 
    if (!(as = ast_calloc(1, sizeof(*as))))
        return -1;
 
    /* New entry created */
    as->chan = chan;
    as->use_count = 1;
 
    ast_channel_lock(chan);
    as->orig_end_dtmf_flag = ast_test_flag(ast_channel_flags(chan), AST_FLAG_END_DTMF_ONLY) ? 1 : 0;
    if (!as->orig_end_dtmf_flag)
        ast_set_flag(ast_channel_flags(chan), AST_FLAG_END_DTMF_ONLY);
    ast_channel_unlock(chan);
 
    AST_LIST_LOCK(&aslist);
 
    if (AST_LIST_EMPTY(&aslist) && asthread != AST_PTHREADT_NULL) {
        ast_cond_signal(&as_cond);
    }
 
    AST_LIST_INSERT_HEAD(&aslist, as, list);
 
    if (asthread == AST_PTHREADT_NULL) { /* need start the thread */
        if (ast_pthread_create_background(&asthread, NULL, autoservice_run, NULL)) {
            ast_log(LOG_WARNING, "Unable to create autoservice thread :(\n");
            /* There will only be a single member in the list at this point,
               the one we just added. */
            AST_LIST_REMOVE(&aslist, as, list);
            ast_free(as);
            asthread = AST_PTHREADT_NULL;
            res = -1;
        } else {
            pthread_kill(asthread, SIGURG);
        }
    }
 
    AST_LIST_UNLOCK(&aslist);
 
    return res;
}

References as_cond, ast_calloc, ast_channel_flags(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_cond_signal, ast_debug, AST_FLAG_END_DTMF_ONLY, ast_free, AST_LIST_EMPTY, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_pthread_create_background, AST_PTHREADT_NULL, ast_set_flag, ast_test_flag, ast_thread_is_user_interface(), asthread, autoservice_run(), asent::chan, asent::list, LOG_WARNING, NULL, asent::orig_end_dtmf_flag, and asent::use_count.

Referenced by acf_curl_helper(), acf_jabberreceive_read(), acf_odbc_read(), acf_odbc_write(), action_toggle_mute_participants(), app_exec(), ast_app_exec_sub(), ast_audiosocket_connect(), ast_autoservice_chan_hangup_peer(), ast_dtmf_stream(), ast_get_enum(), ast_get_srv(), ast_get_txt(), ast_mf_stream(), ast_sf_stream(), begin_dial_prerun(), conf_play(), confbridge_exec(), dial_exec_full(), exec(), findmeexec(), function_realtime_read(), function_realtime_readdestroy(), function_realtime_store(), function_realtime_write(), join_conference_bridge(), lock_read(), lua_autoservice_start(), lua_get_variable_value(), lua_pbx_exec(), lua_set_variable(), lua_set_variable_value(), mf_stream(), originate_exec(), pbx_find_extension(), playback_common(), post_join_play_begin(), push_announcer(), realtimefield_read(), reload_exec(), ring_one(), sf_stream(), shell_helper(), smdi_msg_retrieve_read(), srv_datastore_setup(), system_exec_helper(), try_calling(), and trylock_read().

ast_autoservice_stop()

int ast_autoservice_stop

(

struct ast_channel *

chan

)

Stop servicing a channel for us...

Note

if chan is locked prior to calling ast_autoservice_stop, it is likely that there will be a deadlock between the thread that calls ast_autoservice_stop and the autoservice thread. It is important that chan is not locked prior to this call

Parameters

chan

Return values

0	success
-1	error, or the channel has been hungup

Definition at line 266 of file autoservice.c.

{
    int res = -1;
    struct asent *as, *removed = NULL;
    struct ast_frame *f;
    int chan_list_state;
 
    if (ast_thread_is_user_interface()) {
        /* User interface threads do not handle channel media. */
        ast_debug(1, "Thread is a user interface, not removing channel %s from autoservice\n",
            ast_channel_name(chan));
        return 0;
    }
 
    AST_LIST_LOCK(&aslist);
 
    /* Save the autoservice channel list state.  We _must_ verify that the channel
     * list has been rebuilt before we return.  Because, after we return, the channel
     * could get destroyed and we don't want our poor autoservice thread to step on
     * it after its gone! */
    chan_list_state = as_chan_list_state;
 
    /* Find the entry, but do not free it because it still can be in the
       autoservice thread array */
    AST_LIST_TRAVERSE_SAFE_BEGIN(&aslist, as, list) {
        if (as->chan == chan) {
            as->use_count--;
            if (as->use_count < 1) {
                AST_LIST_REMOVE_CURRENT(list);
                removed = as;
            }
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    if (removed && asthread != AST_PTHREADT_NULL) {
        pthread_kill(asthread, SIGURG);
    }
 
    AST_LIST_UNLOCK(&aslist);
 
    if (!removed) {
        return 0;
    }
 
    if (asthread != AST_PTHREADT_NULL && pthread_equal(pthread_self(), asthread)) {
        /* Do not sleep if ast_autoservice_stop is called within the autoservice thread,
           otherwise the thread will be stuck in an endless sleep. */
        ast_debug(1, "ast_autoservice_stop is called within the autoservice thread, channel %s\n",
            ast_channel_name(chan));
    } else {
        /* Wait while autoservice thread rebuilds its list. */
        while (chan_list_state == as_chan_list_state) {
            usleep(1000);
        }
    }
 
    /* Now autoservice thread should have no references to our entry
       and we can safely destroy it */
 
    if (!ast_channel_softhangup_internal_flag(chan)) {
        res = 0;
    }
 
    ast_channel_lock(chan);
    if (!as->orig_end_dtmf_flag) {
        ast_clear_flag(ast_channel_flags(chan), AST_FLAG_END_DTMF_ONLY);
    }
 
    while ((f = AST_LIST_REMOVE_HEAD(&as->deferred_frames, frame_list))) {
        if (!((1 << f->frametype) & as->ignore_frame_types)) {
            ast_queue_frame_head(chan, f);
        }
        ast_frfree(f);
    }
    ast_channel_unlock(chan);
 
    ast_free(as);
 
    return res;
}

References as_chan_list_state, ast_channel_flags(), ast_channel_lock, ast_channel_name(), ast_channel_softhangup_internal_flag(), ast_channel_unlock, ast_clear_flag, ast_debug, AST_FLAG_END_DTMF_ONLY, ast_free, ast_frfree, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_REMOVE_HEAD, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, AST_PTHREADT_NULL, ast_queue_frame_head(), ast_thread_is_user_interface(), asthread, asent::chan, asent::deferred_frames, ast_frame::frametype, asent::ignore_frame_types, NULL, asent::orig_end_dtmf_flag, and asent::use_count.

Referenced by acf_curl_helper(), acf_jabberreceive_read(), acf_odbc_read(), acf_odbc_write(), action_toggle_mute_participants(), app_exec(), array(), ast_app_exec_sub(), ast_audiosocket_connect(), ast_autoservice_chan_hangup_peer(), ast_dtmf_stream(), ast_get_enum(), ast_get_srv(), ast_get_txt(), ast_hangup(), ast_mf_stream(), ast_sf_stream(), begin_dial_prerun(), conf_play(), confbridge_exec(), dial_exec_full(), exec(), findmeexec(), function_realtime_read(), function_realtime_readdestroy(), function_realtime_store(), function_realtime_write(), hangup_playback(), join_conference_bridge(), lock_read(), lua_autoservice_stop(), lua_get_variable_value(), lua_pbx_exec(), lua_set_variable(), lua_set_variable_value(), mf_stream(), originate_exec(), pbx_find_extension(), playback_common(), post_join_play_begin(), realtimefield_read(), reload_exec(), ring_one(), sf_stream(), shell_helper(), smdi_msg_retrieve_read(), srv_datastore_setup(), system_exec_helper(), try_calling(), and trylock_read().

autoservice_run()

static void * autoservice_run ( void *  ign )

static

Definition at line 78 of file autoservice.c.

{
    ast_callid callid = 0;
    struct ast_frame hangup_frame = {
        .frametype = AST_FRAME_CONTROL,
        .subclass.integer = AST_CONTROL_HANGUP,
    };
 
    while (!asexit) {
        struct ast_channel *mons[MAX_AUTOMONS];
        struct asent *ents[MAX_AUTOMONS];
        struct ast_channel *chan;
        struct asent *as;
        int i, x = 0, ms = 50;
        struct ast_frame *f = NULL;
        struct ast_frame *defer_frame = NULL;
 
        AST_LIST_LOCK(&aslist);
 
        /* At this point, we know that no channels that have been removed are going
         * to get used again. */
        as_chan_list_state++;
 
        if (AST_LIST_EMPTY(&aslist)) {
            ast_cond_wait(&as_cond, &aslist.lock);
        }
 
        AST_LIST_TRAVERSE(&aslist, as, list) {
            if (!ast_check_hangup(as->chan)) {
                if (x < MAX_AUTOMONS) {
                    ents[x] = as;
                    mons[x++] = as->chan;
                } else {
                    ast_log(LOG_WARNING, "Exceeded maximum number of automatic monitoring events.  Fix autoservice.c\n");
                }
            }
        }
 
        AST_LIST_UNLOCK(&aslist);
 
        if (!x) {
            /* If we don't sleep, this becomes a busy loop, which causes
             * problems when Asterisk runs at a different priority than other
             * user processes.  As long as we check for new channels at least
             * once every 10ms, we should be fine. */
            usleep(10000);
            continue;
        }
 
        chan = ast_waitfor_n(mons, x, &ms);
        if (!chan) {
            continue;
        }
 
        callid = ast_channel_callid(chan);
        ast_callid_threadassoc_change(callid);
 
        f = ast_read(chan);
 
        if (!f) {
            /* No frame means the channel has been hung up.
             * A hangup frame needs to be queued here as ast_waitfor() may
             * never return again for the condition to be detected outside
             * of autoservice.  So, we'll leave a HANGUP queued up so the
             * thread in charge of this channel will know. */
 
            defer_frame = &hangup_frame;
        } else if (ast_is_deferrable_frame(f)) {
            defer_frame = f;
        } else {
            /* Can't defer. Discard and continue with next. */
            ast_frfree(f);
            continue;
        }
 
        for (i = 0; i < x; i++) {
            struct ast_frame *dup_f;
 
            if (mons[i] != chan) {
                continue;
            }
 
            if (!f) { /* defer_frame == &hangup_frame */
                if ((dup_f = ast_frdup(defer_frame))) {
                    AST_LIST_INSERT_HEAD(&ents[i]->deferred_frames, dup_f, frame_list);
                }
            } else {
                if (defer_frame->frametype == AST_FRAME_CONTROL &&
                    defer_frame->subclass.integer == AST_CONTROL_VIDUPDATE) {
 
                    /* If a video update is already queued don't needlessly queue another */
                    if (ents[i]->video_update) {
                        ast_frfree(defer_frame);
                        break;
                    }
 
                    ents[i]->video_update = 1;
                }
                if ((dup_f = ast_frisolate(defer_frame))) {
                    AST_LIST_INSERT_HEAD(&ents[i]->deferred_frames, dup_f, frame_list);
                }
                if (dup_f != defer_frame) {
                    ast_frfree(defer_frame);
                }
            }
 
            break;
        }
        /* The ast_waitfor_n() call will only read frames from
         * the channels' file descriptors. If ast_waitfor_n()
         * returns non-NULL, then one of the channels in the
         * mons array must have triggered the return. It's
         * therefore impossible that we got here while (i >= x).
         * If we did, we'd need to ast_frfree(f) if (f). */
    }
 
    ast_callid_threadassoc_change(0);
    asthread = AST_PTHREADT_NULL;
 
    return NULL;
}

References as_chan_list_state, as_cond, asexit, ast_callid_threadassoc_change(), ast_channel_callid(), ast_check_hangup(), ast_cond_wait, AST_CONTROL_HANGUP, AST_CONTROL_VIDUPDATE, AST_FRAME_CONTROL, ast_frdup, ast_frfree, ast_frisolate, ast_is_deferrable_frame(), AST_LIST_EMPTY, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, AST_PTHREADT_NULL, ast_read(), ast_waitfor_n(), asthread, ast_channel::callid, asent::chan, ast_frame::frametype, ast_frame_subclass::integer, aslist::lock, LOG_WARNING, MAX_AUTOMONS, NULL, ast_frame::subclass, and asent::video_update.

Referenced by ast_autoservice_start().

autoservice_shutdown()

static void autoservice_shutdown ( void  )

static

Definition at line 376 of file autoservice.c.

{
    pthread_t th = asthread;
    asexit = 1;
    if (th != AST_PTHREADT_NULL) {
        ast_cond_signal(&as_cond);
        pthread_kill(th, SIGURG);
        pthread_join(th, NULL);
    }
}

References as_cond, asexit, ast_cond_signal, AST_PTHREADT_NULL, asthread, and NULL.

Referenced by ast_autoservice_init().

Variable Documentation

as_chan_list_state

int as_chan_list_state

static

Definition at line 76 of file autoservice.c.

Referenced by ast_autoservice_stop(), and autoservice_run().

as_cond

ast_cond_t as_cond

static

Definition at line 71 of file autoservice.c.

Referenced by ast_autoservice_init(), ast_autoservice_start(), autoservice_run(), and autoservice_shutdown().

asexit

volatile int asexit = 0

static

Definition at line 74 of file autoservice.c.

Referenced by autoservice_run(), and autoservice_shutdown().

aslist

struct aslist aslist = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

asthread

pthread_t asthread = AST_PTHREADT_NULL

static

Definition at line 73 of file autoservice.c.

Referenced by ast_autoservice_start(), ast_autoservice_stop(), autoservice_run(), and autoservice_shutdown().