channel.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <math.h>
#include <sys/poll.h>
#include <asterisk/pbx.h>
#include <asterisk/frame.h>
#include <asterisk/sched.h>
#include <asterisk/options.h>
#include <asterisk/channel.h>
#include <asterisk/channel_pvt.h>
#include <asterisk/logger.h>
#include <asterisk/say.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/monitor.h>
#include <asterisk/causes.h>
#include <asterisk/utils.h>
#include <asterisk/lock.h>

Go to the source code of this file.

Data Structures
struct	chanlist
struct	tonepair_def
struct	tonepair_state
Functions
	AST_MUTEX_DEFINE_STATIC (chlock)
int	ast_check_hangup (struct ast_channel *chan)
	Check to see if a channel is needing hang up.
void	ast_begin_shutdown (int hangup)
int	ast_active_channels (void)
void	ast_cancel_shutdown (void)
int	ast_shutting_down (void)
void	ast_channel_setwhentohangup (struct ast_channel *chan, time_t offset)
	Set when to hang a channel up.
int	ast_channel_register (char *type, char *description, int capabilities, struct ast_channel *(*requester)(char *type, int format, void *data))
	Registers a channel.
int	ast_channel_register_ex (char *type, char *description, int capabilities, struct ast_channel *(*requester)(char *type, int format, void *data), int(*devicestate)(void *data))
char *	ast_state2str (int state)
	Gives the string form of a given state.
int	ast_best_codec (int fmts)
	Pick the best codec.
ast_channel *	ast_channel_alloc (int needqueue)
	Create a channel structure.
int	ast_queue_frame (struct ast_channel *chan, struct ast_frame *fin)
int	ast_queue_hangup (struct ast_channel *chan)
int	ast_queue_control (struct ast_channel *chan, int control)
int	ast_channel_defer_dtmf (struct ast_channel *chan)
	Defers DTMF.
void	ast_channel_undefer_dtmf (struct ast_channel *chan)
	Undeos a defer.
ast_channel *	ast_channel_walk_locked (struct ast_channel *prev)
	Browse channels in use.
ast_channel *	ast_get_channel_by_name_locked (char *channame)
	Get channel by name (locks channel).
int	ast_safe_sleep_conditional (struct ast_channel *chan, int ms, int(*cond)(void *), void *data)
	Wait for a specied amount of time, looking for hangups and a condition argument.
int	ast_safe_sleep (struct ast_channel *chan, int ms)
	Wait for a specied amount of time, looking for hangups.
void	ast_channel_free (struct ast_channel *chan)
	Free a channel structure.
int	ast_softhangup_nolock (struct ast_channel *chan, int cause)
int	ast_softhangup (struct ast_channel *chan, int cause)
	Softly hangup up a channel.
int	ast_hangup (struct ast_channel *chan)
	Hang up a channel.
void	ast_channel_unregister (char *type)
	Unregister a channel class.
int	ast_answer (struct ast_channel *chan)
	Answer a ringing call.
void	ast_deactivate_generator (struct ast_channel *chan)
int	ast_activate_generator (struct ast_channel *chan, struct ast_generator *gen, void *params)
int	ast_waitfor_n_fd (int *fds, int n, int *ms, int *exception)
	Waits for input on an fd.
ast_channel *	ast_waitfor_nandfds (struct ast_channel **c, int n, int *fds, int nfds, int *exception, int *outfd, int *ms)
	Waits for activity on a group of channels.
ast_channel *	ast_waitfor_n (struct ast_channel **c, int n, int *ms)
	Waits for input on a group of channels.
int	ast_waitfor (struct ast_channel *c, int ms)
	Wait for input on a channel.
int	ast_waitfordigit (struct ast_channel *c, int ms)
	Waits for a digit.
int	ast_settimeout (struct ast_channel *c, int samples, int(*func)(void *data), void *data)
int	ast_waitfordigit_full (struct ast_channel *c, int ms, int audiofd, int cmdfd)
ast_frame *	ast_read (struct ast_channel *chan)
	Reads a frame.
int	ast_indicate (struct ast_channel *chan, int condition)
	Indicates condition of channel.
int	ast_recvchar (struct ast_channel *chan, int timeout)
int	ast_sendtext (struct ast_channel *chan, char *text)
	Sends text to a channel.
int	ast_senddigit (struct ast_channel *chan, char digit)
	Receives a text character from a channel.
int	ast_prod (struct ast_channel *chan)
int	ast_write_video (struct ast_channel *chan, struct ast_frame *fr)
	Write video frame to a channel.
int	ast_write (struct ast_channel *chan, struct ast_frame *fr)
	Write a frame to a channel.
int	ast_set_write_format (struct ast_channel *chan, int fmts)
	Sets write format on channel chan.
int	ast_set_read_format (struct ast_channel *chan, int fmts)
	Sets read format on channel chan.
ast_channel *	__ast_request_and_dial (char *type, int format, void *data, int timeout, int *outstate, char *callerid, struct outgoing_helper *oh)
ast_channel *	ast_request_and_dial (char *type, int format, void *data, int timeout, int *outstate, char *callerid)
ast_channel *	ast_request (char *type, int format, void *data)
	Requests a channel.
int	ast_parse_device_state (char *device)
	Search the Channels by Name.
int	ast_device_state (char *device)
	Asks a channel for device state.
int	ast_call (struct ast_channel *chan, char *addr, int timeout)
	Make a call.
int	ast_transfer (struct ast_channel *chan, char *dest)
int	ast_readstring (struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders)
	Reads multiple digits.
int	ast_readstring_full (struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders, int audiofd, int ctrlfd)
int	ast_channel_supports_html (struct ast_channel *chan)
	Checks for HTML support on a channel.
int	ast_channel_sendhtml (struct ast_channel *chan, int subclass, char *data, int datalen)
	Sends HTML on given channel.
int	ast_channel_sendurl (struct ast_channel *chan, char *url)
	Sends a URL on a given link.
int	ast_channel_make_compatible (struct ast_channel *chan, struct ast_channel *peer)
	Makes two channel formats compatible.
int	ast_channel_masquerade (struct ast_channel *original, struct ast_channel *clone)
	Weird function made for call transfers.
void	ast_change_name (struct ast_channel *chan, char *newname)
int	ast_do_masquerade (struct ast_channel *original)
void	ast_set_callerid (struct ast_channel *chan, char *callerid, int anitoo)
int	ast_setstate (struct ast_channel *chan, int state)
int	ast_channel_bridge (struct ast_channel *c0, struct ast_channel *c1, struct ast_bridge_config *config, struct ast_frame **fo, struct ast_channel **rc)
	Bridge two channels together.
int	ast_channel_setoption (struct ast_channel *chan, int option, void *data, int datalen, int block)
	Sets an option on a channel.
int	ast_tonepair_start (struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
void	ast_tonepair_stop (struct ast_channel *chan)
int	ast_tonepair (struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
unsigned int	ast_get_group (char *s)
Variables
chanlist *	backends
ast_channel *	channels = NULL

---

Function Documentation

struct ast_channel* __ast_request_and_dial (  char *  type, int  format, void *  data, int  timeout, int *  outstate, char *  callerid, struct outgoing_helper *  oh )

Definition at line 1758 of file channel.c. References ast_channel::_state, ast_call(), ast_cdr_alloc(), ast_cdr_disposition(), ast_cdr_end(), ast_cdr_failed(), ast_cdr_init(), ast_cdr_setaccount(), ast_cdr_setapp(), ast_cdr_start(), ast_cdr_update(), AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_HANGUP, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, AST_FRAME_CONTROL, ast_frfree(), ast_hangup(), ast_log(), ast_read(), ast_request(), ast_set_callerid(), AST_STATE_UP, ast_waitfor(), ast_channel::callerid, ast_channel::cdr, ast_channel::context, ast_channel::exten, ast_frame::frametype, ast_channel::hangupcause, LOG_NOTICE, LOG_WARNING, pbx_builtin_setvar(), ast_channel::priority, and ast_frame::subclass. Referenced by ast_pbx_outgoing_exten(), and ast_request_and_dial(). { int state = 0; struct ast_channel *chan; struct ast_frame *f; int res = 0; char *variable; chan = ast_request(type, format, data); if (chan) { if (oh) { char *tmp, *var; /* JDG chanvar */ if (oh->variable) variable = ast_strdupa(oh->variable); else variable = NULL; tmp = variable; /* FIXME replace this call with strsep NOT*/ while( (var = strtok_r(NULL, "|", &tmp)) ) { pbx_builtin_setvar( chan, var ); } /* /JDG */ if (oh->callerid && *oh->callerid) ast_set_callerid(chan, oh->callerid, 1); if (oh->account && *oh->account) ast_cdr_setaccount(chan, oh->account); } if (callerid && !ast_strlen_zero(callerid)) ast_set_callerid(chan, callerid, 1); if (!ast_call(chan, data, 0)) { while(timeout && (chan->_state != AST_STATE_UP)) { res = ast_waitfor(chan, timeout); if (res < 0) { /* Something not cool, or timed out */ break; } /* If done, break out */ if (!res) break; if (timeout > -1) timeout = res; f = ast_read(chan); if (!f) { state = AST_CONTROL_HANGUP; res = 0; break; } if (f->frametype == AST_FRAME_CONTROL) { if (f->subclass == AST_CONTROL_RINGING) state = AST_CONTROL_RINGING; else if ((f->subclass == AST_CONTROL_BUSY) || (f->subclass == AST_CONTROL_CONGESTION)) { state = f->subclass; ast_frfree(f); break; } else if (f->subclass == AST_CONTROL_ANSWER) { state = f->subclass; ast_frfree(f); break; } else if (f->subclass == AST_CONTROL_PROGRESS) { /* Ignore */ } else if (f->subclass == -1) { /* Ignore -- just stopping indications */ } else { ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass); } } ast_frfree(f); } } else ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data); } else ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data); if (chan) { /* Final fixups */ if (oh) { if (oh->context && *oh->context) strncpy(chan->context, oh->context, sizeof(chan->context) - 1); if (oh->exten && *oh->exten) strncpy(chan->exten, oh->exten, sizeof(chan->exten) - 1); chan->priority = oh->priority; } if (chan->_state == AST_STATE_UP) state = AST_CONTROL_ANSWER; } if (outstate) *outstate = state; if (chan && res <= 0) { if (!chan->cdr) { chan->cdr = ast_cdr_alloc(); if (chan->cdr) ast_cdr_init(chan->cdr, chan); } if (chan->cdr) { char tmp[256]; snprintf(tmp, 256, "%s/%s", type, (char *)data); ast_cdr_setapp(chan->cdr,"Dial",tmp); ast_cdr_update(chan); ast_cdr_start(chan->cdr); ast_cdr_end(chan->cdr); /* If the cause wasn't handled properly */ if (ast_cdr_disposition(chan->cdr,chan->hangupcause)) ast_cdr_failed(chan->cdr); } else ast_log(LOG_WARNING, "Unable to create Call Detail Record\n"); ast_hangup(chan); chan = NULL; } return chan; }

int ast_activate_generator (  struct ast_channel *  chan, struct ast_generator *  gen, void *  params )

Activate a given generator Definition at line 849 of file channel.c. References ast_generator::alloc, ast_mutex_lock, ast_mutex_unlock, ast_prod(), ast_settimeout(), ast_channel::generator, ast_channel::generatordata, ast_channel::lock, and ast_generator::release. Referenced by ast_linear_stream(), ast_playtones_start(), and ast_tonepair_start(). { int res = 0; ast_mutex_lock(&chan->lock); if (chan->generatordata) { if (chan->generator && chan->generator->release) chan->generator->release(chan, chan->generatordata); chan->generatordata = NULL; } ast_prod(chan); if ((chan->generatordata = gen->alloc(chan, params))) { ast_settimeout(chan, 160, generator_force, chan); chan->generator = gen; } else { res = -1; } ast_mutex_unlock(&chan->lock); return res; }

int ast_active_channels (  void   )

Returns number of active/allocated channels Definition at line 120 of file channel.c. References ast_mutex_lock, ast_mutex_unlock, and ast_channel::next. { struct ast_channel *c; int cnt = 0; ast_mutex_lock(&chlock); c = channels; while(c) { cnt++; c = c->next; } ast_mutex_unlock(&chlock); return cnt; }

int ast_answer (  struct ast_channel *  chan  )

Answer a ringing call. Parameters: chan  channel to answer This function answers a channel and handles all necessary call setup functions. Returns 0 on success, -1 on failure Definition at line 785 of file channel.c. References ast_channel::_state, ast_channel_pvt::answer, ast_cdr_answer(), ast_check_hangup(), ast_mutex_lock, ast_mutex_unlock, ast_setstate(), AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, ast_channel::cdr, ast_channel::lock, ast_channel::pvt, and ast_channel::zombie. Referenced by ast_control_streamfile(). { int res = 0; ast_mutex_lock(&chan->lock); /* Stop if we're a zombie or need a soft hangup */ if (chan->zombie || ast_check_hangup(chan)) { ast_mutex_unlock(&chan->lock); return -1; } switch(chan->_state) { case AST_STATE_RINGING: case AST_STATE_RING: if (chan->pvt->answer) res = chan->pvt->answer(chan); ast_setstate(chan, AST_STATE_UP); if (chan->cdr) ast_cdr_answer(chan->cdr); ast_mutex_unlock(&chan->lock); return res; break; case AST_STATE_UP: if (chan->cdr) ast_cdr_answer(chan->cdr); break; } ast_mutex_unlock(&chan->lock); return 0; }

void ast_begin_shutdown (  int  hangup  )

Initiate system shutdown -- prevents new channels from being allocated. If "hangup" is non-zero, all existing channels will receive soft hangups Definition at line 105 of file channel.c. References ast_mutex_lock, ast_mutex_unlock, ast_softhangup(), AST_SOFTHANGUP_SHUTDOWN, and ast_channel::next. { struct ast_channel *c; shutting_down = 1; if (hangup) { ast_mutex_lock(&chlock); c = channels; while(c) { ast_softhangup(c, AST_SOFTHANGUP_SHUTDOWN); c = c->next; } ast_mutex_unlock(&chlock); } }

int ast_best_codec (  int  fmts  )

Pick the best codec. Definition at line 233 of file channel.c. References AST_FORMAT_ADPCM, AST_FORMAT_ALAW, AST_FORMAT_G723_1, AST_FORMAT_G726, AST_FORMAT_G729A, AST_FORMAT_GSM, AST_FORMAT_ILBC, AST_FORMAT_LPC10, AST_FORMAT_SLINEAR, AST_FORMAT_SPEEX, AST_FORMAT_ULAW, ast_log(), and LOG_WARNING. Referenced by ast_codec_choose(). { /* This just our opinion, expressed in code. We are asked to choose the best codec to use, given no information */ int x; static int prefs[] = { /* Okay, ulaw is used by all telephony equipment, so start with it */ AST_FORMAT_ULAW, /* Unless of course, you're a silly European, so then prefer ALAW */ AST_FORMAT_ALAW, /* Okay, well, signed linear is easy to translate into other stuff */ AST_FORMAT_SLINEAR, /* G.726 is standard ADPCM */ AST_FORMAT_G726, /* ADPCM has great sound quality and is still pretty easy to translate */ AST_FORMAT_ADPCM, /* Okay, we're down to vocoders now, so pick GSM because it's small and easier to translate and sounds pretty good */ AST_FORMAT_GSM, /* iLBC is not too bad */ AST_FORMAT_ILBC, /* Speex is free, but computationally more expensive than GSM */ AST_FORMAT_SPEEX, /* Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough to use it */ AST_FORMAT_LPC10, /* G.729a is faster than 723 and slightly less expensive */ AST_FORMAT_G729A, /* Down to G.723.1 which is proprietary but at least designed for voice */ AST_FORMAT_G723_1, }; for (x=0;x<sizeof(prefs) / sizeof(prefs[0]); x++) if (fmts & prefs[x]) return prefs[x]; ast_log(LOG_WARNING, "Don't know any of 0x%x formats\n", fmts); return 0; }

int ast_call (  struct ast_channel *  chan, char *  addr, int  timeout )

Make a call. Parameters: chan  which channel to make the call on addr  destination of the call timeout  time to wait on for connect Place a call, take no longer than timeout ms. Returns -1 on failure, 0 on not enough time (does not auto matically stop ringing), and the number of seconds the connect took otherwise. Returns 0 on success, -1 on failure Definition at line 1977 of file channel.c. References ast_check_hangup(), ast_mutex_lock, ast_mutex_unlock, ast_channel_pvt::call, ast_channel::lock, ast_channel::pvt, and ast_channel::zombie. Referenced by __ast_request_and_dial(). { /* Place an outgoing call, but don't wait any longer than timeout ms before returning. If the remote end does not answer within the timeout, then do NOT hang up, but return anyway. */ int res = -1; /* Stop if we're a zombie or need a soft hangup */ ast_mutex_lock(&chan->lock); if (!chan->zombie && !ast_check_hangup(chan)) if (chan->pvt->call) res = chan->pvt->call(chan, addr, timeout); ast_mutex_unlock(&chan->lock); return res; }

void ast_cancel_shutdown (  void   )

Cancels an existing shutdown and returns to normal operation Definition at line 134 of file channel.c. { shutting_down = 0; }

void ast_change_name (  struct ast_channel *  chan, char *  newname )

Definition at line 2196 of file channel.c. References EVENT_FLAG_CALL, manager_event(), ast_channel::name, and ast_channel::uniqueid. { char tmp[256]; strncpy(tmp, chan->name, sizeof(tmp) - 1); strncpy(chan->name, newname, sizeof(chan->name) - 1); manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", tmp, chan->name, chan->uniqueid); }

struct ast_channel* ast_channel_alloc (  int  needalertpipe  )

Create a channel structure. Returns NULL on failure to allocate Definition at line 274 of file channel.c. References ast_default_accountcode, ast_default_amaflags, AST_LIST_HEAD_INIT, AST_LIST_INSERT_HEAD, ast_log(), AST_MAX_FDS, ast_mutex_lock, ast_mutex_unlock, AST_STATE_DOWN, ast_var_assign(), defaultlanguage, free, LOG_WARNING, malloc, ast_channel_pvt::pvt, and sched_context_create(). Referenced by ast_async_goto(), and ast_pbx_outgoing_exten(). { struct ast_channel *tmp; struct ast_channel_pvt *pvt; int x; int flags; struct varshead *headp; /* If shutting down, don't allocate any new channels */ if (shutting_down) return NULL; ast_mutex_lock(&chlock); tmp = malloc(sizeof(struct ast_channel)); if (tmp) { memset(tmp, 0, sizeof(struct ast_channel)); pvt = malloc(sizeof(struct ast_channel_pvt)); if (pvt) { memset(pvt, 0, sizeof(struct ast_channel_pvt)); tmp->sched = sched_context_create(); if (tmp->sched) { for (x=0;x<AST_MAX_FDS - 1;x++) tmp->fds[x] = -1; #ifdef ZAPTEL_OPTIMIZATIONS tmp->timingfd = open("/dev/zap/timer", O_RDWR); if (tmp->timingfd > -1) { /* Check if timing interface supports new ping/pong scheme */ flags = 1; if (!ioctl(tmp->timingfd, ZT_TIMERPONG, &flags)) needqueue = 0; } #else tmp->timingfd = -1; #endif if (needqueue && pipe(pvt->alertpipe)) { ast_log(LOG_WARNING, "Alert pipe creation failed!\n"); free(pvt); free(tmp); tmp = NULL; pvt = NULL; } else { if (needqueue) { flags = fcntl(pvt->alertpipe[0], F_GETFL); fcntl(pvt->alertpipe[0], F_SETFL, flags | O_NONBLOCK); flags = fcntl(pvt->alertpipe[1], F_GETFL); fcntl(pvt->alertpipe[1], F_SETFL, flags | O_NONBLOCK); } else /* Make sure we've got it done right if they don't */ pvt->alertpipe[0] = pvt->alertpipe[1] = -1; /* Always watch the alertpipe */ tmp->fds[AST_MAX_FDS-1] = pvt->alertpipe[0]; /* And timing pipe */ tmp->fds[AST_MAX_FDS-2] = tmp->timingfd; strncpy(tmp->name, "**Unknown**", sizeof(tmp->name)-1); tmp->pvt = pvt; /* Initial state */ tmp->_state = AST_STATE_DOWN; tmp->stack = -1; tmp->streamid = -1; tmp->appl = NULL; tmp->data = NULL; tmp->fin = 0; tmp->fout = 0; snprintf(tmp->uniqueid, sizeof(tmp->uniqueid), "%li.%d", (long)time(NULL), uniqueint++); headp=&tmp->varshead; ast_mutex_init(&tmp->lock); AST_LIST_HEAD_INIT(headp); tmp->vars=ast_var_assign("tempvar","tempval"); AST_LIST_INSERT_HEAD(headp,tmp->vars,entries); strncpy(tmp->context, "default", sizeof(tmp->context)-1); strncpy(tmp->language, defaultlanguage, sizeof(tmp->language)-1); strncpy(tmp->exten, "s", sizeof(tmp->exten)-1); tmp->priority=1; tmp->amaflags = ast_default_amaflags; strncpy(tmp->accountcode, ast_default_accountcode, sizeof(tmp->accountcode)-1); tmp->next = channels; channels= tmp; } } else { ast_log(LOG_WARNING, "Unable to create schedule context\n"); free(tmp); tmp = NULL; } } else { ast_log(LOG_WARNING, "Out of memory\n"); free(tmp); tmp = NULL; } } else ast_log(LOG_WARNING, "Out of memory\n"); ast_mutex_unlock(&chlock); return tmp; }

int ast_channel_bridge (  struct ast_channel *  c0, struct ast_channel *  c1, struct ast_bridge_config *  config, struct ast_frame **  fo, struct ast_channel **  rc )

Bridge two channels together. Parameters: c0  first channel to bridge c1  second channel to bridge flags  for the channels fo  destination frame(?) rc  destination channel(?) Bridge two channels (c0 and c1) together. If an important frame occurs, we return that frame in rf (remember, it could be NULL) and which channel (0 or 1) in rc Definition at line 2517 of file channel.c. References ast_bridge_config::allowdisconnect_in, ast_bridge_config::allowdisconnect_out, ast_bridge_config::allowredirect_in, ast_bridge_config::allowredirect_out, AST_BRIDGE_DTMF_CHANNEL_0, AST_BRIDGE_DTMF_CHANNEL_1, AST_BRIDGE_IGNORE_SIGS, ast_channel_make_compatible(), ast_check_hangup(), AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_HTML, AST_FRAME_IMAGE, AST_FRAME_TEXT, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree(), ast_log(), ast_read(), ast_verbose(), ast_waitfor_n(), ast_write(), ast_channel::bridge, ast_bridge_config::end_sound, EVENT_FLAG_CALL, ast_bridge_config::firstpass, ast_frame::frametype, LOG_DEBUG, LOG_WARNING, manager_event(), ast_channel::name, option_verbose, ast_bridge_config::play_to_callee, ast_bridge_config::play_to_caller, ast_bridge_config::play_warning, ast_bridge_config::start_sound, ast_frame::subclass, ast_bridge_config::timelimit, VERBOSE_PREFIX_3, ast_bridge_config::warning_freq, and ast_bridge_config::warning_sound. { /* Copy voice back and forth between the two channels. Give the peer the ability to transfer calls with '#<extension' syntax. */ int flags; struct ast_channel *cs[3]; int to = -1; struct ast_frame *f; struct ast_channel *who = NULL; int res=0; int nativefailed=0; int firstpass; int o0nativeformats; int o1nativeformats; struct timeval start_time,precise_now; long elapsed_ms=0, time_left_ms=0; int playit=0, playitagain=1, first_time=1; flags = (config->allowdisconnect_out||config->allowredirect_out ? AST_BRIDGE_DTMF_CHANNEL_0 : 0) + (config->allowdisconnect_in||config->allowredirect_in ? AST_BRIDGE_DTMF_CHANNEL_1 : 0); firstpass = config->firstpass; config->firstpass = 0; /* timestamp */ gettimeofday(&start_time,NULL); time_left_ms = config->timelimit; if (config->play_to_caller && config->start_sound && firstpass) bridge_playfile(c0,c1,config->start_sound,time_left_ms / 1000); if (config->play_to_callee && config->start_sound && firstpass) bridge_playfile(c1,c0,config->start_sound,time_left_ms / 1000); /* Stop if we're a zombie or need a soft hangup */ if (c0->zombie || ast_check_hangup_locked(c0) || c1->zombie || ast_check_hangup_locked(c1)) return -1; if (c0->bridge) { ast_log(LOG_WARNING, "%s is already in a bridge with %s\n", c0->name, c0->bridge->name); return -1; } if (c1->bridge) { ast_log(LOG_WARNING, "%s is already in a bridge with %s\n", c1->name, c1->bridge->name); return -1; } /* Keep track of bridge */ c0->bridge = c1; c1->bridge = c0; cs[0] = c0; cs[1] = c1; manager_event(EVENT_FLAG_CALL, "Link", "Channel1: %s\r\n" "Channel2: %s\r\n" "Uniqueid1: %s\r\n" "Uniqueid2: %s\r\n", c0->name, c1->name, c0->uniqueid, c1->uniqueid); o1nativeformats = c1->nativeformats; o0nativeformats = c0->nativeformats; for (/* ever */;;) { /* timestamp */ if (config->timelimit) { gettimeofday(&precise_now,NULL); elapsed_ms = tvdiff(&precise_now,&start_time); time_left_ms = config->timelimit - elapsed_ms; if (playitagain && (config->play_to_caller || config->play_to_callee) && (config->play_warning && time_left_ms <= config->play_warning)) { /* narrowing down to the end */ if (config->warning_freq == 0) { playit = 1; first_time=0; playitagain=0; } else if (first_time) { playit = 1; first_time=0; } else { if ((time_left_ms % config->warning_freq) <= 50) { playit = 1; } } } if (time_left_ms <= 0) { if (config->play_to_caller && config->end_sound) bridge_playfile(c0,c1,config->end_sound,0); if (config->play_to_callee && config->end_sound) bridge_playfile(c1,c0,config->end_sound,0); *fo = NULL; if (who) *rc = who; res = 0; break; } if (time_left_ms >= 5000 && playit) { if (config->play_to_caller && config->warning_sound && config->play_warning) bridge_playfile(c0,c1,config->warning_sound,time_left_ms / 1000); if (config->play_to_callee && config->warning_sound && config->play_warning) bridge_playfile(c1,c0,config->warning_sound,time_left_ms / 1000); playit = 0; } } /* Stop if we're a zombie or need a soft hangup */ if (c0->zombie || ast_check_hangup_locked(c0) || c1->zombie || ast_check_hangup_locked(c1)) { *fo = NULL; if (who) *rc = who; res = 0; ast_log(LOG_DEBUG, "Bridge stops because we're zombie or need a soft hangup: c0=%s, c1=%s, flags: %s,%s,%s,%s\n",c0->name,c1->name,c0->zombie?"Yes":"No",ast_check_hangup(c0)?"Yes":"No",c1->zombie?"Yes":"No",ast_check_hangup(c1)?"Yes":"No"); break; } if (c0->pvt->bridge && config->timelimit==0 && (c0->pvt->bridge == c1->pvt->bridge) && !nativefailed && !c0->monitor && !c1->monitor) { /* Looks like they share a bridge code */ if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "Attempting native bridge of %s and %s\n", c0->name, c1->name); if (!(res = c0->pvt->bridge(c0, c1, flags, fo, rc))) { c0->bridge = NULL; c1->bridge = NULL; manager_event(EVENT_FLAG_CALL, "Unlink", "Channel1: %s\r\n" "Channel2: %s\r\n" "Uniqueid1: %s\r\n" "Uniqueid2: %s\r\n", c0->name, c1->name, c0->uniqueid, c1->uniqueid); ast_log(LOG_DEBUG, "Returning from native bridge, channels: %s, %s\n",c0->name ,c1->name); return 0; } /* If they return non-zero then continue on normally. Let "-2" mean don't worry about my not wanting to bridge */ if ((res != -2) && (res != -3)) ast_log(LOG_WARNING, "Private bridge between %s and %s failed\n", c0->name, c1->name); if (res != -3) nativefailed++; } if (((c0->writeformat != c1->readformat) || (c0->readformat != c1->writeformat) || (c0->nativeformats != o0nativeformats) || (c1->nativeformats != o1nativeformats)) && !(c0->generator || c1->generator)) { if (ast_channel_make_compatible(c0, c1)) { ast_log(LOG_WARNING, "Can't make %s and %s compatible\n", c0->name, c1->name); manager_event(EVENT_FLAG_CALL, "Unlink", "Channel1: %s\r\n" "Channel2: %s\r\n" "Uniqueid1: %s\r\n" "Uniqueid2: %s\r\n", c0->name, c1->name, c0->uniqueid, c1->uniqueid); return -1; } o0nativeformats = c0->nativeformats; o1nativeformats = c1->nativeformats; } who = ast_waitfor_n(cs, 2, &to); if (!who) { ast_log(LOG_DEBUG, "Nobody there, continuing...\n"); continue; } f = ast_read(who); if (!f) { *fo = NULL; *rc = who; res = 0; ast_log(LOG_DEBUG, "Didn't get a frame from channel: %s\n",who->name); break; } if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) { *fo = f; *rc = who; res = 0; ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f->subclass, who->name); break; } if ((f->frametype == AST_FRAME_VOICE) || (f->frametype == AST_FRAME_TEXT) || (f->frametype == AST_FRAME_VIDEO) || (f->frametype == AST_FRAME_IMAGE) || (f->frametype == AST_FRAME_HTML) || (f->frametype == AST_FRAME_DTMF)) { if ((f->frametype == AST_FRAME_DTMF) && (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))) { if ((who == c0)) { if ((flags & AST_BRIDGE_DTMF_CHANNEL_0)) { *rc = c0; *fo = f; /* Take out of conference mode */ res = 0; ast_log(LOG_DEBUG, "Got AST_BRIDGE_DTMF_CHANNEL_0 on c0 (%s)\n",c0->name); break; } else goto tackygoto; } else if ((who == c1)) { if (flags & AST_BRIDGE_DTMF_CHANNEL_1) { *rc = c1; *fo = f; res = 0; ast_log(LOG_DEBUG, "Got AST_BRIDGE_DTMF_CHANNEL_1 on c1 (%s)\n",c1->name); break; } else goto tackygoto; } } else { #if 0 ast_log(LOG_DEBUG, "Read from %s\n", who->name); if (who == last) ast_log(LOG_DEBUG, "Servicing channel %s twice in a row?\n", last->name); last = who; #endif tackygoto: /* Don't copy packets if there is a generator on either one, since they're not supposed to be listening anyway */ if (who == c0) ast_write(c1, f); else ast_write(c0, f); } ast_frfree(f); } else ast_frfree(f); /* Swap who gets priority */ cs[2] = cs[0]; cs[0] = cs[1]; cs[1] = cs[2]; } c0->bridge = NULL; c1->bridge = NULL; manager_event(EVENT_FLAG_CALL, "Unlink", "Channel1: %s\r\n" "Channel2: %s\r\n" "Uniqueid1: %s\r\n" "Uniqueid2: %s\r\n", c0->name, c1->name, c0->uniqueid, c1->uniqueid); ast_log(LOG_DEBUG, "Bridge stops bridging channels %s and %s\n",c0->name,c1->name); return res; }

int ast_channel_defer_dtmf (  struct ast_channel *  chan  )

Defers DTMF. Defer DTMF so that you only read things like hangups and audio. Returns non-zero if channel was already DTMF-deferred or 0 if channel is just now being DTMF-deferred Definition at line 441 of file channel.c. References ast_channel::deferdtmf. { int pre = 0; if (chan) { pre = chan->deferdtmf; chan->deferdtmf = 1; } return pre; }

void ast_channel_free (  struct ast_channel *  chan  )

Free a channel structure. Definition at line 561 of file channel.c. References ast_channel_pvt::alertpipe, ast_channel::ani, AST_CHANNEL_NAME, ast_device_state_changed(), ast_frfree(), AST_LIST_EMPTY, AST_LIST_FIRST, AST_LIST_REMOVE_HEAD, ast_log(), ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, ast_translator_free_path(), ast_var_delete(), ast_channel::callerid, ast_channel::dnid, free, ast_channel::lock, LOG_WARNING, ast_channel::monitor, ast_channel::name, ast_channel::next, ast_frame::next, ast_channel::pbx, ast_channel::pvt, ast_channel_pvt::pvt, ast_channel::rdnis, ast_channel_pvt::readq, ast_channel_pvt::readtrans, ast_channel_monitor::stop, ast_channel::timingfd, and ast_channel_pvt::writetrans. Referenced by ast_do_masquerade(), and ast_hangup(). { struct ast_channel *last=NULL, *cur; int fd; struct ast_var_t *vardata; struct ast_frame *f, *fp; struct varshead *headp; char name[AST_CHANNEL_NAME]; headp=&chan->varshead; ast_mutex_lock(&chlock); cur = channels; while(cur) { if (cur == chan) { if (last) last->next = cur->next; else channels = cur->next; break; } last = cur; cur = cur->next; } if (!cur) ast_log(LOG_WARNING, "Unable to find channel in list\n"); else { /* Lock and unlock the channel just to be sure nobody has it locked still */ ast_mutex_lock(&cur->lock); ast_mutex_unlock(&cur->lock); } if (chan->pvt->pvt) ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name); strncpy(name, chan->name, sizeof(name)-1); /* Stop monitoring */ if (chan->monitor) { chan->monitor->stop( chan, 0 ); } /* Free translatosr */ if (chan->pvt->readtrans) ast_translator_free_path(chan->pvt->readtrans); if (chan->pvt->writetrans) ast_translator_free_path(chan->pvt->writetrans); if (chan->pbx) ast_log(LOG_WARNING, "PBX may not have been terminated properly on '%s'\n", chan->name); if (chan->dnid) free(chan->dnid); if (chan->callerid) free(chan->callerid); if (chan->ani) free(chan->ani); if (chan->rdnis) free(chan->rdnis); ast_mutex_destroy(&chan->lock); /* Close pipes if appropriate */ if ((fd = chan->pvt->alertpipe[0]) > -1) close(fd); if ((fd = chan->pvt->alertpipe[1]) > -1) close(fd); if ((fd = chan->timingfd) > -1) close(fd); f = chan->pvt->readq; chan->pvt->readq = NULL; while(f) { fp = f; f = f->next; ast_frfree(fp); } /* loop over the variables list, freeing all data and deleting list items */ /* no need to lock the list, as the channel is already locked */ while (!AST_LIST_EMPTY(headp)) { /* List Deletion. */ vardata = AST_LIST_FIRST(headp); AST_LIST_REMOVE_HEAD(headp, entries); // printf("deleting var %s=%s\n",ast_var_name(vardata),ast_var_value(vardata)); ast_var_delete(vardata); } free(chan->pvt); chan->pvt = NULL; free(chan); ast_mutex_unlock(&chlock); ast_device_state_changed(name); }

int ast_channel_make_compatible (  struct ast_channel *  c0, struct ast_channel *  c1 )

Makes two channel formats compatible. Parameters: c0  first channel to make compatible c1  other channel to make compatible Set two channels to compatible formats -- call before ast_channel_bridge in general . Returns 0 on success and -1 if it could not be done Definition at line 2114 of file channel.c. References ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_set_read_format(), ast_set_write_format(), ast_translator_best_choice(), ast_channel::lock, LOG_WARNING, ast_channel::name, and ast_channel::nativeformats. Referenced by ast_channel_bridge(). { int peerf; int chanf; int res; ast_mutex_lock(&peer->lock); peerf = peer->nativeformats; ast_mutex_unlock(&peer->lock); ast_mutex_lock(&chan->lock); chanf = chan->nativeformats; ast_mutex_unlock(&chan->lock); res = ast_translator_best_choice(&peerf, &chanf); if (res < 0) { ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", chan->name, chan->nativeformats, peer->name, peer->nativeformats); return -1; } /* Set read format on channel */ res = ast_set_read_format(chan, peerf); if (res < 0) { ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", chan->name, chanf); return -1; } /* Set write format on peer channel */ res = ast_set_write_format(peer, peerf); if (res < 0) { ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", peer->name, peerf); return -1; } /* Now we go the other way */ peerf = peer->nativeformats; chanf = chan->nativeformats; res = ast_translator_best_choice(&chanf, &peerf); if (res < 0) { ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", peer->name, peer->nativeformats, chan->name, chan->nativeformats); return -1; } /* Set writeformat on channel */ res = ast_set_write_format(chan, chanf); if (res < 0) { ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", chan->name, chanf); return -1; } /* Set read format on peer channel */ res = ast_set_read_format(peer, chanf); if (res < 0) { ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", peer->name, peerf); return -1; } return 0; }

int ast_channel_masquerade (  struct ast_channel *  original, struct ast_channel *  clone )

Weird function made for call transfers. Parameters: original  channel to make a copy of clone  copy of the original channel This is a very strange and freaky function used primarily for transfer. Suppose that "original" and "clone" are two channels in random situations. This function takes the guts out of "clone" and puts them into the "original" channel, then alerts the channel driver of the change, asking it to fixup any private information (like the p->owner pointer) that is affected by the change. The physical layer of the original channel is hung up. Definition at line 2165 of file channel.c. References AST_FRAME_NULL, ast_log(), ast_mutex_lock, ast_mutex_trylock, ast_mutex_unlock, ast_queue_frame(), ast_channel::lock, LOG_DEBUG, LOG_WARNING, ast_channel::masq, ast_channel::masqr, and ast_channel::name. Referenced by ast_async_goto(). { struct ast_frame null = { AST_FRAME_NULL, }; int res = -1; ast_mutex_lock(&original->lock); while(ast_mutex_trylock(&clone->lock)) { ast_mutex_unlock(&original->lock); usleep(1); ast_mutex_lock(&original->lock); } ast_log(LOG_DEBUG, "Planning to masquerade %s into the structure of %s\n", clone->name, original->name); if (original->masq) { ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n", original->masq->name, original->name); } else if (clone->masqr) { ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n", clone->name, clone->masqr->name); } else { original->masq = clone; clone->masqr = original; ast_queue_frame(original, &null); ast_queue_frame(clone, &null); ast_log(LOG_DEBUG, "Done planning to masquerade %s into the structure of %s\n", original->name, clone->name); res = 0; } ast_mutex_unlock(&clone->lock); ast_mutex_unlock(&original->lock); return res; }

int ast_channel_register (  char *  type, char *  description, int  capabilities, struct ast_channel *(*)(char *type, int format, void *data)  requester )

Registers a channel. Parameters: type  type of channel you are registering description  short description of the channel capabilities  a bit mask of the capabilities of the channel requester  a function pointer that properly responds to a call. See one of the channel drivers for details. Called by a channel module to register the kind of channels it supports. It supplies a brief type, a longer, but still short description, and a routine that creates a channel Returns 0 on success, -1 on failure. Definition at line 156 of file channel.c. References ast_channel_register_ex(). { return ast_channel_register_ex(type, description, capabilities, requester, NULL); }

int ast_channel_register_ex (  char *  type, char *  description, int  capabilities, struct ast_channel *(*)(char *type, int format, void *data)  requester, int(*)(void *data)  devicestate )

Definition at line 162 of file channel.c. References ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_verbose(), backends, chanlist::capabilities, chanlist::description, chanlist::devicestate, LOG_DEBUG, LOG_WARNING, malloc, chanlist::next, option_debug, option_verbose, chanlist::requester, chanlist::type, and VERBOSE_PREFIX_2. Referenced by ast_channel_register(). { struct chanlist *chan, *last=NULL; if (ast_mutex_lock(&chlock)) { ast_log(LOG_WARNING, "Unable to lock channel list\n"); return -1; } chan = backends; while (chan) { if (!strcasecmp(type, chan->type)) { ast_log(LOG_WARNING, "Already have a handler for type '%s'\n", type); ast_mutex_unlock(&chlock); return -1; } last = chan; chan = chan->next; } chan = malloc(sizeof(struct chanlist)); if (!chan) { ast_log(LOG_WARNING, "Out of memory\n"); ast_mutex_unlock(&chlock); return -1; } strncpy(chan->type, type, sizeof(chan->type)-1); strncpy(chan->description, description, sizeof(chan->description)-1); chan->capabilities = capabilities; chan->requester = requester; chan->devicestate = devicestate; chan->next = NULL; if (last) last->next = chan; else backends = chan; if (option_debug) ast_log(LOG_DEBUG, "Registered handler for '%s' (%s)\n", chan->type, chan->description); else if (option_verbose > 1) ast_verbose( VERBOSE_PREFIX_2 "Registered channel type '%s' (%s)\n", chan->type, chan->description); ast_mutex_unlock(&chlock); return 0; }

int ast_channel_sendhtml (  struct ast_channel *  channel, int  subclass, char *  data, int  datalen )

Sends HTML on given channel. Send HTML or URL on link. Returns 0 on success or -1 on failure Definition at line 2100 of file channel.c. References ast_channel::pvt, and ast_channel_pvt::send_html. { if (chan->pvt->send_html) return chan->pvt->send_html(chan, subclass, data, datalen); return -1; }

int ast_channel_sendurl (  struct ast_channel *  channel, char *  url )

Sends a URL on a given link. Send URL on link. Returns 0 on success or -1 on failure Definition at line 2107 of file channel.c. References AST_HTML_URL, ast_channel::pvt, and ast_channel_pvt::send_html. { if (chan->pvt->send_html) return chan->pvt->send_html(chan, AST_HTML_URL, url, strlen(url) + 1); return -1; }

int ast_channel_setoption (  struct ast_channel *  channel, int  option, void *  data, int  datalen, int  block )

Sets an option on a channel. Parameters: channel  channel to set options on option  option to change data  data specific to option datalen  length of the data block  blocking or not Set an option on a channel (see frame.h), optionally blocking awaiting the reply Returns 0 on success and -1 on failure Definition at line 2750 of file channel.c. References ast_log(), LOG_ERROR, ast_channel::pvt, and ast_channel_pvt::setoption. { int res; if (chan->pvt->setoption) { res = chan->pvt->setoption(chan, option, data, datalen); if (res < 0) return res; } else { errno = ENOSYS; return -1; } if (block) { /* XXX Implement blocking -- just wait for our option frame reply, discarding intermediate packets. XXX */ ast_log(LOG_ERROR, "XXX Blocking not implemented yet XXX\n"); return -1; } return 0; }

void ast_channel_setwhentohangup (  struct ast_channel *  chan, time_t  offset )

Set when to hang a channel up. Parameters: chan  channel on which to check for hang up offset  offset in seconds from current time of when to hang up This function sets the absolute time out on a channel (when to hang up). Definition at line 144 of file channel.c. References ast_channel::whentohangup. { time_t myt; time(&myt); if (offset) chan->whentohangup = myt + offset; else chan->whentohangup = 0; return; }

int ast_channel_supports_html (  struct ast_channel *  channel  )

Checks for HTML support on a channel. Returns 0 if channel does not support HTML or non-zero if it does Definition at line 2093 of file channel.c. References ast_channel::pvt, and ast_channel_pvt::send_html. { if (chan->pvt->send_html) return 1; return 0; }

void ast_channel_undefer_dtmf (  struct ast_channel *  chan  )

Undeos a defer. Undo defer. ast_read will return any dtmf characters that were queued Definition at line 451 of file channel.c. References ast_channel::deferdtmf. { if (chan) chan->deferdtmf = 0; }

void ast_channel_unregister (  char *  type  )

Unregister a channel class. Definition at line 756 of file channel.c. References ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_verbose(), backends, free, LOG_DEBUG, LOG_WARNING, chanlist::next, option_debug, option_verbose, chanlist::type, and VERBOSE_PREFIX_2. { struct chanlist *chan, *last=NULL; if (option_debug) ast_log(LOG_DEBUG, "Unregistering channel type '%s'\n", type); if (ast_mutex_lock(&chlock)) { ast_log(LOG_WARNING, "Unable to lock channel list\n"); return; } if (option_verbose > 1) ast_verbose( VERBOSE_PREFIX_2 "Unregistered channel type '%s'\n", type); chan = backends; while(chan) { if (!strcasecmp(chan->type, type)) { if (last) last->next = chan->next; else backends = backends->next; free(chan); ast_mutex_unlock(&chlock); return; } last = chan; chan = chan->next; } ast_mutex_unlock(&chlock); }

struct ast_channel* ast_channel_walk_locked (  struct ast_channel *  prev  )

Browse channels in use. Parameters: prev  where you want to start in the channel list Browse the channels currently in use Returns the next channel in the list, NULL on end. If it returns a channel, that channel *has been locked*! Definition at line 457 of file channel.c. References ast_log(), ast_mutex_lock, ast_mutex_trylock, ast_mutex_unlock, ast_channel::lock, LOG_DEBUG, LOG_WARNING, ast_channel::name, and ast_channel::next. Referenced by ast_async_goto_by_name(), ast_get_channel_by_name_locked(), and ast_parse_device_state(). { /* Returns next channel (locked) */ struct ast_channel *l, *ret; int retries = 0; retry: ret=NULL; ast_mutex_lock(&chlock); l = channels; if (!prev) { if (l) { if (ast_mutex_trylock(&l->lock)) { if (retries < 10) ast_log(LOG_DEBUG, "Avoiding initial deadlock for '%s'\n", l->name); else ast_log(LOG_WARNING, "Avoided initial deadlock for '%s', %d retries!\n", l->name, retries); ast_mutex_unlock(&chlock); if (retries < 10) { usleep(1); retries++; goto retry; } else return NULL; } } ast_mutex_unlock(&chlock); return l; } while(l) { if (l == prev) ret = l->next; l = l->next; } if (ret) { if (ast_mutex_trylock(&ret->lock)) { if (retries < 10) ast_log(LOG_DEBUG, "Avoiding deadlock for '%s'\n", ret->name); else ast_log(LOG_WARNING, "Avoided deadlock for '%s', %d retries!\n", ret->name, retries); ast_mutex_unlock(&chlock); if (retries < 10) { usleep(1); retries++; goto retry; } else return NULL; } } ast_mutex_unlock(&chlock); return ret; }

int ast_check_hangup (  struct ast_channel *  chan  )

Check to see if a channel is needing hang up. Parameters: chan  channel on which to check for hang up This function determines if the channel is being requested to be hung up. Returns 0 if not, or 1 if hang up is requested (including time-out). Definition at line 79 of file channel.c. References ast_channel::_softhangup, AST_SOFTHANGUP_TIMEOUT, ast_channel::pvt, ast_channel_pvt::pvt, and ast_channel::whentohangup. Referenced by ast_answer(), ast_call(), ast_channel_bridge(), ast_indicate(), ast_read(), ast_readstring(), ast_readstring_full(), ast_recvchar(), ast_rtp_bridge(), ast_sendtext(), ast_transfer(), ast_waitfordigit(), ast_waitfordigit_full(), and ast_write(). { time_t myt; /* if soft hangup flag, return true */ if (chan->_softhangup) return 1; /* if no private structure, return true */ if (!chan->pvt->pvt) return 1; /* if no hangup scheduled, just return here */ if (!chan->whentohangup) return 0; time(&myt); /* get current time */ /* return, if not yet */ if (chan->whentohangup > myt) return 0; chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT; return 1; }

void ast_deactivate_generator (  struct ast_channel *  chan  )

Deactive an active generator Definition at line 816 of file channel.c. References ast_mutex_lock, ast_mutex_unlock, ast_settimeout(), ast_channel::generator, ast_channel::generatordata, ast_channel::lock, ast_generator::release, and ast_channel::writeinterrupt. Referenced by ast_openstream(), ast_playtones_stop(), ast_read(), ast_tonepair_stop(), and ast_write(). { ast_mutex_lock(&chan->lock); if (chan->generatordata) { if (chan->generator && chan->generator->release) chan->generator->release(chan, chan->generatordata); chan->generatordata = NULL; chan->generator = NULL; chan->writeinterrupt = 0; ast_settimeout(chan, 0, NULL, NULL); } ast_mutex_unlock(&chan->lock); }

int ast_device_state (  char *  device  )

Asks a channel for device state. Parameters: device  like a dialstring Asks a channel for device state, data is normaly a number from dialstring used by the low level module Trys the channel devicestate callback if not supported search in the active channels list for the device. Returns an AST_DEVICE_??? state -1 on failure Definition at line 1938 of file channel.c. References AST_DEVICE_INVALID, AST_DEVICE_UNKNOWN, ast_log(), AST_MAX_EXTENSION, ast_mutex_lock, ast_mutex_unlock, ast_parse_device_state(), backends, chanlist::devicestate, LOG_WARNING, chanlist::next, and chanlist::type. { char tech[AST_MAX_EXTENSION] = ""; char *number; struct chanlist *chanls; int res = 0; strncpy(tech, device, sizeof(tech)-1); number = strchr(tech, '/'); if (!number) { return AST_DEVICE_INVALID; } *number = 0; number++; if (ast_mutex_lock(&chlock)) { ast_log(LOG_WARNING, "Unable to lock channel list\n"); return -1; } chanls = backends; while(chanls) { if (!strcasecmp(tech, chanls->type)) { ast_mutex_unlock(&chlock); if (!chanls->devicestate) return ast_parse_device_state(device); else { res = chanls->devicestate(number); if (res == AST_DEVICE_UNKNOWN) return ast_parse_device_state(device); else return res; } } chanls = chanls->next; } ast_mutex_unlock(&chlock); return AST_DEVICE_INVALID; }

int ast_do_masquerade (  struct ast_channel *  original  )

Definition at line 2204 of file channel.c. References ast_channel::_softhangup, ast_channel::_state, ast_channel::adsicpe, ast_channel_pvt::alertpipe, ast_channel_free(), AST_FRAME_NULL, ast_log(), AST_MAX_FDS, ast_mutex_lock, ast_mutex_unlock, ast_queue_frame(), ast_set_read_format(), ast_set_write_format(), AST_SOFTHANGUP_DEV, ast_channel::blocker, ast_channel::blocking, ast_channel::callerid, ast_channel::dnid, EVENT_FLAG_CALL, ast_channel::exception, ast_channel::fdno, ast_channel::fds, ast_channel_pvt::fixup, ast_channel_pvt::hangup, ast_channel::language, ast_channel::lock, LOG_DEBUG, LOG_WARNING, manager_event(), ast_channel::masq, ast_channel::masqr, ast_channel::musicclass, ast_channel::name, ast_channel::nativeformats, ast_frame::next, ast_frame::prev, ast_channel::pvt, ast_channel::readformat, ast_channel_pvt::readq, ast_channel::timingfd, ast_channel::type, ast_channel::uniqueid, ast_channel::writeformat, and ast_channel::zombie. Referenced by ast_async_goto(), ast_hangup(), ast_read(), ast_waitfor_nandfds(), and ast_write(). { int x,i; int res=0; int origstate; char *tmp; struct ast_var_t *varptr; struct ast_frame *cur, *prev; struct ast_channel_pvt *p; struct ast_channel *clone = original->masq; int rformat = original->readformat; int wformat = original->writeformat; char newn[100]; char orig[100]; char masqn[100]; char zombn[100]; #if 1 ast_log(LOG_DEBUG, "Actually Masquerading %s(%d) into the structure of %s(%d)\n", clone->name, clone->_state, original->name, original->_state); #endif /* XXX This is a seriously wacked out operation. We're essentially putting the guts of the clone channel into the original channel. Start by killing off the original channel's backend. I'm not sure we're going to keep this function, because while the features are nice, the cost is very high in terms of pure nastiness. XXX */ /* We need the clone's lock, too */ ast_mutex_lock(&clone->lock); ast_log(LOG_DEBUG, "Got clone lock on '%s' at %p\n", clone->name, &clone->lock); /* Having remembered the original read/write formats, we turn off any translation on either one */ free_translation(clone); free_translation(original); /* Unlink the masquerade */ original->masq = NULL; clone->masqr = NULL; /* Save the original name */ strncpy(orig, original->name, sizeof(orig) - 1); /* Save the new name */ strncpy(newn, clone->name, sizeof(newn) - 1); /* Create the masq name */ snprintf(masqn, sizeof(masqn), "%s<MASQ>", newn); /* Copy the name from the clone channel */ strncpy(original->name, newn, sizeof(original->name)-1); /* Mangle the name of the clone channel */ strncpy(clone->name, masqn, sizeof(clone->name) - 1); /* Notify any managers of the change, first the masq then the other */ manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", newn, masqn, clone->uniqueid); manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", orig, newn, original->uniqueid); /* Swap the guts */ p = original->pvt; original->pvt = clone->pvt; clone->pvt = p; /* Save any pending frames on both sides. Start by counting * how many we're going to need... */ prev = NULL; cur = clone->pvt->readq; x = 0; while(cur) { x++; prev = cur; cur = cur->next; } /* If we had any, prepend them to the ones already in the queue, and * load up the alertpipe */ if (prev) { prev->next = original->pvt->readq; original->pvt->readq = clone->pvt->readq; clone->pvt->readq = NULL; if (original->pvt->alertpipe[1] > -1) { for (i=0;i<x;i++) write(original->pvt->alertpipe[1], &x, sizeof(x)); } } clone->_softhangup = AST_SOFTHANGUP_DEV; /* And of course, so does our current state. Note we need not call ast_setstate since the event manager doesn't really consider these separate. We do this early so that the clone has the proper state of the original channel. */ origstate = original->_state; original->_state = clone->_state; clone->_state = origstate; if (clone->pvt->fixup){ res = clone->pvt->fixup(original, clone); if (res) ast_log(LOG_WARNING, "Fixup failed on channel %s, strange things may happen.\n", clone->name); } /* Start by disconnecting the original's physical side */ if (clone->pvt->hangup) res = clone->pvt->hangup(clone); if (res) { ast_log(LOG_WARNING, "Hangup failed! Strange things may happen!\n"); ast_mutex_unlock(&clone->lock); return -1; } snprintf(zombn, sizeof(zombn), "%s<ZOMBIE>", orig); /* Mangle the name of the clone channel */ strncpy(clone->name, zombn, sizeof(clone->name) - 1); manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", masqn, zombn, clone->uniqueid); /* Update the type. */ original->type = clone->type; /* Keep the same language. */ strncpy(original->language, clone->language, sizeof(original->language)); /* Copy the FD's */ for (x=0;x<AST_MAX_FDS;x++) { original->fds[x] = clone->fds[x]; } /* Append variables from clone channel into original channel */ /* XXX Is this always correct? We have to in order to keep MACROS working XXX */ varptr = original->varshead.first; if (varptr) { while(varptr->entries.next) { varptr = varptr->entries.next; } varptr->entries.next = clone->varshead.first; } else { original->varshead.first = clone->varshead.first; } clone->varshead.first = NULL; /* Presense of ADSI capable CPE follows clone */ original->adsicpe = clone->adsicpe; /* Bridge remains the same */ /* CDR fields remain the same */ /* XXX What about blocking, softhangup, blocker, and lock and blockproc? XXX */ /* Application and data remain the same */ /* Clone exception becomes real one, as with fdno */ original->exception = clone->exception; original->fdno = clone->fdno; /* Schedule context remains the same */ /* Stream stuff stays the same */ /* Keep the original state. The fixup code will need to work with it most likely */ /* dnid and callerid change to become the new, HOWEVER, we also link the original's fields back into the defunct 'clone' so that they will be freed when ast_frfree is eventually called */ tmp = original->dnid; original->dnid = clone->dnid; clone->dnid = tmp; tmp = original->callerid; original->callerid = clone->callerid; clone->callerid = tmp; /* Restore original timing file descriptor */ original->fds[AST_MAX_FDS - 2] = original->timingfd; /* Our native formats are different now */ original->nativeformats = clone->nativeformats; /* Context, extension, priority, app data, jump table, remain the same */ /* pvt switches. pbx stays the same, as does next */ /* Set the write format */ ast_set_write_format(original, wformat); /* Set the read format */ ast_set_read_format(original, rformat); /* Copy the music class */ strncpy(original->musicclass, clone->musicclass, sizeof(original->musicclass) - 1); ast_log(LOG_DEBUG, "Putting channel %s in %d/%d formats\n", original->name, wformat, rformat); /* Okay. Last thing is to let the channel driver know about all this mess, so he can fix up everything as best as possible */ if (original->pvt->fixup) { res = original->pvt->fixup(clone, original); if (res) { ast_log(LOG_WARNING, "Driver for '%s' could not fixup channel %s\n", original->type, original->name); ast_mutex_unlock(&clone->lock); return -1; } } else ast_log(LOG_WARNING, "Driver '%s' does not have a fixup routine (for %s)! Bad things may happen.\n", original->type, original->name); /* Now, at this point, the "clone" channel is totally F'd up. We mark it as a zombie so nothing tries to touch it. If it's already been marked as a zombie, then free it now (since it already is considered invalid). */ if (clone->zombie) { ast_log(LOG_DEBUG, "Destroying clone '%s'\n", clone->name); ast_mutex_unlock(&clone->lock); ast_channel_free(clone); manager_event(EVENT_FLAG_CALL, "Hangup", "Channel: %s\r\n", zombn); } else { struct ast_frame null_frame = { AST_FRAME_NULL, }; ast_log(LOG_DEBUG, "Released clone lock on '%s'\n", clone->name); clone->zombie=1; ast_queue_frame(clone, &null_frame); ast_mutex_unlock(&clone->lock); } /* Signal any blocker */ if (original->blocking) pthread_kill(original->blocker, SIGURG); ast_log(LOG_DEBUG, "Done Masquerading %s (%d)\n", original->name, original->_state); return 0; }

struct ast_channel* ast_get_channel_by_name_locked (  char *  channame  )

Get channel by name (locks channel). Definition at line 510 of file channel.c. References ast_channel_walk_locked(), ast_mutex_unlock, ast_channel::lock, and ast_channel::name. { struct ast_channel *chan; chan = ast_channel_walk_locked(NULL); while(chan) { if (!strcasecmp(chan->name, channame)) return chan; ast_mutex_unlock(&chan->lock); chan = ast_channel_walk_locked(chan); } return NULL; }

unsigned int ast_get_group (  char *  s  )

Definition at line 2902 of file channel.c. References ast_log(), LOG_ERROR, and LOG_WARNING. { char *copy; char *piece; char *c=NULL; int start=0, finish=0,x; unsigned int group = 0; copy = ast_strdupa(s); if (!copy) { ast_log(LOG_ERROR, "Out of memory\n"); return 0; } c = copy; while((piece = strsep(&c, ","))) { if (sscanf(piece, "%d-%d", &start, &finish) == 2) { /* Range */ } else if (sscanf(piece, "%d", &start)) { /* Just one */ finish = start; } else { ast_log(LOG_ERROR, "Syntax error parsing '%s' at '%s'.\n", s, piece); continue; } for (x=start;x<=finish;x++) { if ((x > 31) || (x < 0)) { ast_log(LOG_WARNING, "Ignoring invalid group %d (maximum group is 31)\n", x); } else group |= (1 << x); } } return group; }

int ast_hangup (  struct ast_channel *  chan  )

Hang up a channel. Parameters: chan  channel to hang up This function performs a hard hangup on a channel. Unlike the soft-hangup, this function performs all stream stopping, etc, on the channel that needs to end. chan is no longer valid after this call. Returns 0 on success, -1 on failure. Definition at line 689 of file channel.c. References ast_cdr_end(), ast_cdr_free(), ast_cdr_post(), ast_channel_free(), ast_closestream(), ast_do_masquerade(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_channel::blocker, ast_channel::blocking, ast_channel::blockproc, ast_channel::cdr, CRASH, EVENT_FLAG_CALL, ast_channel::generator, ast_channel::generatordata, ast_channel_pvt::hangup, ast_channel::hangupcause, ast_channel::lock, LOG_DEBUG, LOG_WARNING, manager_event(), ast_channel::masq, ast_channel::masqr, ast_channel::name, option_debug, ast_channel::pvt, ast_generator::release, ast_channel::sched, sched_context_destroy(), ast_channel::stream, ast_channel::uniqueid, ast_channel::vstream, and ast_channel::zombie. Referenced by __ast_request_and_dial(), ast_async_goto(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), and ast_pbx_run(). { int res = 0; /* Don't actually hang up a channel that will masquerade as someone else, or if someone is going to masquerade as us */ ast_mutex_lock(&chan->lock); if (chan->masq) { if (ast_do_masquerade(chan)) ast_log(LOG_WARNING, "Failed to perform masquerade\n"); } if (chan->masq) { ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name); ast_mutex_unlock(&chan->lock); return 0; } /* If this channel is one which will be masqueraded into something, mark it as a zombie already, so we know to free it later */ if (chan->masqr) { chan->zombie=1; ast_mutex_unlock(&chan->lock); return 0; } free_translation(chan); if (chan->stream) ast_closestream(chan->stream); if (chan->vstream) ast_closestream(chan->vstream); if (chan->sched) sched_context_destroy(chan->sched); /* Clear any tone stuff remaining */ if (chan->generatordata) chan->generator->release(chan, chan->generatordata); chan->generatordata = NULL; chan->generator = NULL; if (chan->cdr) { /* End the CDR if it hasn't already */ ast_cdr_end(chan->cdr); /* Post and Free the CDR */ ast_cdr_post(chan->cdr); ast_cdr_free(chan->cdr); } if (chan->blocking) { ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd " "is blocked by thread %ld in procedure %s! Expect a failure\n", (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc); CRASH; } if (!chan->zombie) { if (option_debug) ast_log(LOG_DEBUG, "Hanging up channel '%s'\n", chan->name); if (chan->pvt->hangup) res = chan->pvt->hangup(chan); } else if (option_debug) ast_log(LOG_DEBUG, "Hanging up zombie '%s'\n", chan->name); ast_mutex_unlock(&chan->lock); manager_event(EVENT_FLAG_CALL, "Hangup", "Channel: %s\r\n" "Uniqueid: %s\r\n" "Cause: %i\r\n", chan->name, chan->uniqueid, chan->hangupcause); ast_channel_free(chan); return res; }

int ast_indicate (  struct ast_channel *  chan, int  condition )

Indicates condition of channel. Parameters: chan  channel to change the indication condition  which condition to indicate on the channel Indicate a condition such as AST_CONTROL_BUSY, AST_CONTROL_RINGING, or AST_CONTROL_CONGESTION on a channel Returns 0 on success, -1 on failure Definition at line 1411 of file channel.c. References ast_check_hangup(), AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, ast_get_indication_tone(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_playtones_start(), ast_playtones_stop(), tone_zone_sound::data, ast_channel_pvt::indicate, ast_channel::lock, LOG_DEBUG, LOG_WARNING, ast_channel::name, ast_channel::pvt, ast_channel::zombie, and ast_channel::zone. { int res = -1; /* Stop if we're a zombie or need a soft hangup */ if (chan->zombie || ast_check_hangup(chan)) return -1; ast_mutex_lock(&chan->lock); if (chan->pvt->indicate) res = chan->pvt->indicate(chan, condition); ast_mutex_unlock(&chan->lock); if (!chan->pvt->indicate || res) { /* * Device does not support (that) indication, lets fake * it by doing our own tone generation. (PM2002) */ if (condition >= 0) { const struct tone_zone_sound *ts = NULL; switch (condition) { case AST_CONTROL_RINGING: ts = ast_get_indication_tone(chan->zone, "ring"); break; case AST_CONTROL_BUSY: ts = ast_get_indication_tone(chan->zone, "busy"); break; case AST_CONTROL_CONGESTION: ts = ast_get_indication_tone(chan->zone, "congestion"); break; } if (ts && ts->data[0]) { ast_log(LOG_DEBUG, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition); ast_playtones_start(chan,0,ts->data, 1); res = 0; } else if (condition == AST_CONTROL_PROGRESS) { /* ast_playtones_stop(chan); */ } else if (condition == AST_CONTROL_PROCEEDING) { /* Do nothing, really */ } else { /* not handled */ ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name); res = -1; } } else ast_playtones_stop(chan); } return res; }

AST_MUTEX_DEFINE_STATIC (  chlock   )

int ast_parse_device_state (  char *  device  )

Search the Channels by Name. Parameters: device  like a dialstring Search the Device in active channels by compare the channelname against the devicename. Compared are only the first chars to the first '-' char. Returns an AST_DEVICE_UNKNOWN if no channel found or AST_DEVICE_INUSE if a channel is found Definition at line 1918 of file channel.c. References AST_CHANNEL_NAME, ast_channel_walk_locked(), AST_DEVICE_INUSE, AST_DEVICE_UNKNOWN, ast_mutex_unlock, ast_channel::lock, and ast_channel::name. Referenced by ast_device_state(). { char name[AST_CHANNEL_NAME] = ""; char *cut; struct ast_channel *chan; chan = ast_channel_walk_locked(NULL); while (chan) { strncpy(name, chan->name, sizeof(name)-1); ast_mutex_unlock(&chan->lock); cut = strchr(name,'-'); if (cut) *cut = 0; if (!strcmp(name, device)) return AST_DEVICE_INUSE; chan = ast_channel_walk_locked(chan); } return AST_DEVICE_UNKNOWN; }

int ast_prod (  struct ast_channel *  chan  )

Definition at line 1549 of file channel.c. References ast_channel::_state, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log(), AST_STATE_UP, ast_write(), ast_frame::data, LOG_DEBUG, LOG_WARNING, ast_channel::name, ast_channel::pvt, ast_channel_pvt::rawwriteformat, and ast_frame::subclass. Referenced by ast_activate_generator(). { struct ast_frame a = { AST_FRAME_VOICE }; char nothing[128]; /* Send an empty audio frame to get things moving */ if (chan->_state != AST_STATE_UP) { ast_log(LOG_DEBUG, "Prodding channel '%s'\n", chan->name); a.subclass = chan->pvt->rawwriteformat; a.data = nothing + AST_FRIENDLY_OFFSET; if (ast_write(chan, &a)) ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name); } return 0; }

int ast_queue_control (  struct ast_channel *  chan, int  control )

Definition at line 434 of file channel.c. References AST_FRAME_CONTROL, ast_queue_frame(), and ast_frame::subclass. { struct ast_frame f = { AST_FRAME_CONTROL, }; f.subclass = control; return ast_queue_frame(chan, &f); }

int ast_queue_frame (  struct ast_channel *  chan, struct ast_frame *  f )

Queue an outgoing frame Definition at line 370 of file channel.c. References ast_channel_pvt::alertpipe, AST_CONTROL_HANGUP, AST_FRAME_CONTROL, AST_FRAME_VOICE, ast_frdup(), ast_frfree(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_channel::blocker, ast_channel::blocking, CRASH, ast_frame::frametype, ast_channel::lock, LOG_DEBUG, LOG_WARNING, ast_channel::name, ast_frame::next, ast_frame::prev, ast_channel::pvt, ast_channel_pvt::readq, ast_frame::subclass, and ast_channel::timingfd. Referenced by ast_channel_masquerade(), ast_do_masquerade(), ast_dsp_process(), ast_queue_control(), ast_queue_hangup(), and ast_softhangup_nolock(). { struct ast_frame *f; struct ast_frame *prev, *cur; int blah = 1; int qlen = 0; /* Build us a copy and free the original one */ f = ast_frdup(fin); if (!f) { ast_log(LOG_WARNING, "Unable to duplicate frame\n"); return -1; } ast_mutex_lock(&chan->lock); prev = NULL; cur = chan->pvt->readq; while(cur) { if ((cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP)) { /* Don't bother actually queueing anything after a hangup */ ast_frfree(f); ast_mutex_unlock(&chan->lock); return 0; } prev = cur; cur = cur->next; qlen++; } /* Allow up to 96 voice frames outstanding, and up to 128 total frames */ if (((fin->frametype == AST_FRAME_VOICE) && (qlen > 96)) || (qlen > 128)) { if (fin->frametype != AST_FRAME_VOICE) { ast_log(LOG_WARNING, "Exceptionally long queue length queuing to %s\n", chan->name); CRASH; } else { ast_log(LOG_DEBUG, "Dropping voice to exceptionally long queue on %s\n", chan->name); ast_frfree(f); ast_mutex_unlock(&chan->lock); return 0; } } if (prev) prev->next = f; else chan->pvt->readq = f; if (chan->pvt->alertpipe[1] > -1) { if (write(chan->pvt->alertpipe[1], &blah, sizeof(blah)) != sizeof(blah)) ast_log(LOG_WARNING, "Unable to write to alert pipe on %s, frametype/subclass %d/%d (qlen = %d): %s!\n", chan->name, f->frametype, f->subclass, qlen, strerror(errno)); #ifdef ZAPTEL_OPTIMIZATIONS } else if (chan->timingfd > -1) { ioctl(chan->timingfd, ZT_TIMERPING, &blah); #endif } else if (chan->blocking) { pthread_kill(chan->blocker, SIGURG); } ast_mutex_unlock(&chan->lock); return 0; }

int ast_queue_hangup (  struct ast_channel *  chan  )

Definition at line 427 of file channel.c. References ast_channel::_softhangup, AST_CONTROL_HANGUP, AST_FRAME_CONTROL, ast_queue_frame(), and AST_SOFTHANGUP_DEV. { struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP }; chan->_softhangup |= AST_SOFTHANGUP_DEV; return ast_queue_frame(chan, &f); }

struct ast_frame* ast_read (  struct ast_channel *  chan  )

Reads a frame. Parameters: chan  channel to read a frame from Read a frame. Returns a frame, or NULL on error. If it returns NULL, you best just stop reading frames and assume the channel has been disconnected. Definition at line 1192 of file channel.c. References ast_channel::_softhangup, ast_channel::_state, ast_channel_pvt::alertpipe, ast_cdr_answer(), ast_cdr_end(), ast_check_hangup(), AST_CONTROL_ANSWER, AST_CONTROL_HANGUP, ast_deactivate_generator(), ast_do_masquerade(), AST_FRAME_CNG, AST_FRAME_CONTROL, AST_FRAME_DTMF, ast_frame_dump(), AST_FRAME_NULL, AST_FRAME_VOICE, ast_frfree(), ast_getformatname(), ast_log(), AST_MAX_FDS, ast_mutex_lock, ast_mutex_unlock, ast_seekstream(), ast_setstate(), ast_settimeout(), AST_SOFTHANGUP_DEV, AST_STATE_UP, ast_translate(), ast_writestream(), ast_channel::blocker, ast_channel::cdr, ast_frame::datalen, ast_channel::deferdtmf, ast_channel::dtmff, ast_channel::dtmfq, ast_channel::exception, ast_channel_pvt::exception, ast_channel::fdno, ast_channel::fin, ast_frame::frametype, ast_generator::generate, ast_channel::generator, ast_channel::generatordata, ast_channel::insmpl, ast_channel::lock, LOG_DEBUG, LOG_NOTICE, LOG_WARNING, ast_channel::masq, ast_channel::monitor, ast_channel::name, ast_channel::nativeformats, ast_frame::next, ast_channel::outsmpl, ast_channel::pvt, ast_channel_pvt::read, ast_channel_monitor::read_stream, ast_channel_pvt::readq, ast_channel_pvt::readtrans, ast_frame::samples, SEEK_FORCECUR, ast_frame::subclass, ast_channel::timingdata, ast_channel::timingfd, ast_channel::timingfunc, and ast_channel::zombie. Referenced by __ast_request_and_dial(), ast_app_getvoice(), ast_channel_bridge(), ast_play_and_prepend(), ast_play_and_record(), ast_recvchar(), ast_rtp_bridge(), ast_safe_sleep(), ast_safe_sleep_conditional(), ast_tonepair(), ast_waitfordigit(), ast_waitfordigit_full(), ast_waitstream(), ast_waitstream_fr(), and ast_waitstream_full(). { struct ast_frame *f = NULL; int blah; #ifdef ZAPTEL_OPTIMIZATIONS int (*func)(void *); void *data; int res; #endif static struct ast_frame null_frame = { AST_FRAME_NULL, }; ast_mutex_lock(&chan->lock); if (chan->masq) { if (ast_do_masquerade(chan)) { ast_log(LOG_WARNING, "Failed to perform masquerade\n"); f = NULL; } else f = &null_frame; ast_mutex_unlock(&chan->lock); return f; } /* Stop if we're a zombie or need a soft hangup */ if (chan->zombie || ast_check_hangup(chan)) { if (chan->generator) ast_deactivate_generator(chan); ast_mutex_unlock(&chan->lock); return NULL; } if (!chan->deferdtmf && !ast_strlen_zero(chan->dtmfq)) { /* We have DTMF that has been deferred. Return it now */ chan->dtmff.frametype = AST_FRAME_DTMF; chan->dtmff.subclass = chan->dtmfq[0]; /* Drop first digit */ memmove(chan->dtmfq, chan->dtmfq + 1, sizeof(chan->dtmfq) - 1); ast_mutex_unlock(&chan->lock); return &chan->dtmff; } /* Read and ignore anything on the alertpipe, but read only one sizeof(blah) per frame that we send from it */ if (chan->pvt->alertpipe[0] > -1) { read(chan->pvt->alertpipe[0], &blah, sizeof(blah)); } #ifdef ZAPTEL_OPTIMIZATIONS if ((chan->timingfd > -1) && (chan->fdno == AST_MAX_FDS - 2) && chan->exception) { chan->exception = 0; blah = -1; /* IF we can't get event, assume it's an expired as-per the old interface */ res = ioctl(chan->timingfd, ZT_GETEVENT, &blah); if (res) blah = ZT_EVENT_TIMER_EXPIRED; if (blah == ZT_EVENT_TIMER_PING) { #if 0 ast_log(LOG_NOTICE, "Oooh, there's a PING!\n"); #endif if (!chan->pvt->readq || !chan->pvt->readq->next) { /* Acknowledge PONG unless we need it again */ #if 0 ast_log(LOG_NOTICE, "Sending a PONG!\n"); #endif if (ioctl(chan->timingfd, ZT_TIMERPONG, &blah)) { ast_log(LOG_WARNING, "Failed to pong timer on '%s': %s\n", chan->name, strerror(errno)); } } } else if (blah == ZT_EVENT_TIMER_EXPIRED) { ioctl(chan->timingfd, ZT_TIMERACK, &blah); func = chan->timingfunc; data = chan->timingdata; ast_mutex_unlock(&chan->lock); if (func) { #if 0 ast_log(LOG_DEBUG, "Calling private function\n"); #endif func(data); } else { blah = 0; ast_mutex_lock(&chan->lock); ioctl(chan->timingfd, ZT_TIMERCONFIG, &blah); chan->timingdata = NULL; ast_mutex_unlock(&chan->lock); } f = &null_frame; return f; } else ast_log(LOG_NOTICE, "No/unknown event '%d' on timer for '%s'?\n", blah, chan->name); } #endif /* Check for pending read queue */ if (chan->pvt->readq) { f = chan->pvt->readq; chan->pvt->readq = f->next; /* Interpret hangup and return NULL */ if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) { ast_frfree(f); f = NULL; } } else { chan->blocker = pthread_self(); if (chan->exception) { if (chan->pvt->exception) f = chan->pvt->exception(chan); else { ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name); f = &null_frame; } /* Clear the exception flag */ chan->exception = 0; } else if (chan->pvt->read) f = chan->pvt->read(chan); else ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name); } if (f && (f->frametype == AST_FRAME_VOICE)) { if (!(f->subclass & chan->nativeformats)) { /* This frame can't be from the current native formats -- drop it on the floor */ ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n", chan->name, ast_getformatname(f->subclass), ast_getformatname(chan->nativeformats)); ast_frfree(f); f = &null_frame; } else { if (chan->monitor && chan->monitor->read_stream ) { #ifndef MONITOR_CONSTANT_DELAY int jump = chan->outsmpl - chan->insmpl - 2 * f->samples; if (jump >= 0) { if (ast_seekstream(chan->monitor->read_stream, jump + f->samples, SEEK_FORCECUR) == -1) ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n"); chan->insmpl += jump + 2 * f->samples; } else chan->insmpl+= f->samples; #else int jump = chan->outsmpl - chan->insmpl; if (jump - MONITOR_DELAY >= 0) { if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1) ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n"); chan->insmpl += jump; } else chan->insmpl += f->samples; #endif if (ast_writestream(chan->monitor->read_stream, f) < 0) ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n"); } if (chan->pvt->readtrans) { f = ast_translate(chan->pvt->readtrans, f, 1); if (!f) f = &null_frame; } } } /* Make sure we always return NULL in the future */ if (!f) { chan->_softhangup |= AST_SOFTHANGUP_DEV; if (chan->generator) ast_deactivate_generator(chan); /* End the CDR if appropriate */ if (chan->cdr) ast_cdr_end(chan->cdr); } else if (chan->deferdtmf && f->frametype == AST_FRAME_DTMF) { if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2) chan->dtmfq[strlen(chan->dtmfq)] = f->subclass; else ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name); f = &null_frame; } else if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_ANSWER)) { if (chan->_state == AST_STATE_UP) { ast_log(LOG_DEBUG, "Dropping duplicate answer!\n"); f = &null_frame; } /* Answer the CDR */ ast_setstate(chan, AST_STATE_UP); ast_cdr_answer(chan->cdr); } /* Run any generator sitting on the line */ if (f && (f->frametype == AST_FRAME_VOICE) && chan->generatordata) { /* Mask generator data temporarily and apply. If there is a timing function, it will be calling the generator instead */ void *tmp; int res; int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples); if (chan->timingfunc) { ast_log(LOG_DEBUG, "Generator got voice, switching to phase locked mode\n"); ast_settimeout(chan, 0, NULL, NULL); } tmp = chan->generatordata; chan->generatordata = NULL; generate = chan->generator->generate; res = generate(chan, tmp, f->datalen, f->samples); chan->generatordata = tmp; if (res) { ast_log(LOG_DEBUG, "Auto-deactivating generator\n"); ast_deactivate_generator(chan); } } else if (f && (f->frametype == AST_FRAME_CNG)) { if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) { ast_log(LOG_DEBUG, "Generator got CNG, switching to zap timed mode\n"); ast_settimeout(chan, 160, generator_force, chan); } } /* High bit prints debugging */ if (chan->fin & 0x80000000) ast_frame_dump(chan->name, f, "<<"); if ((chan->fin & 0x7fffffff) == 0x7fffffff) chan->fin &= 0x80000000; else chan->fin++; ast_mutex_unlock(&chan->lock); return f; }

int ast_readstring (  struct ast_channel *  c, char *  s, int  len, int  timeout, int  rtimeout, char *  enders )

Reads multiple digits. Parameters: c  channel to read from s  string to read in to. Must be at least the size of your length len  how many digits to read (maximum) timeout  how long to timeout between digits rtimeout  timeout to wait on the first digit enders  digits to end the string Read in a digit string "s", max length "len", maximum timeout between digits "timeout" (-1 for none), terminated by anything in "enders". Give them rtimeout for the first digit. Returns 0 on normal return, or 1 on a timeout. In the case of a timeout, any digits that were read before the timeout will still be available in s. RETURNS 2 in full version when ctrlfd is available, NOT 1 Definition at line 2012 of file channel.c. References ast_check_hangup(), AST_DIGIT_ANY, ast_stopstream(), ast_waitfordigit(), ast_waitstream(), ast_channel::stream, and ast_channel::zombie. Referenced by ast_app_getdata(). { int pos=0; int to = ftimeout; int d; /* XXX Merge with full version? XXX */ /* Stop if we're a zombie or need a soft hangup */ if (c->zombie || ast_check_hangup(c)) return -1; if (!len) return -1; do { if (c->stream) { d = ast_waitstream(c, AST_DIGIT_ANY); ast_stopstream(c); usleep(1000); if (!d) d = ast_waitfordigit(c, to); } else { d = ast_waitfordigit(c, to); } if (d < 0) return -1; if (d == 0) { s[pos]='\0'; return 1; } if (!strchr(enders, d)) s[pos++] = d; if (strchr(enders, d) || (pos >= len)) { s[pos]='\0'; return 0; } to = timeout; } while(1); /* Never reached */ return 0; }

int ast_readstring_full (  struct ast_channel *  c, char *  s, int  len, int  timeout, int  ftimeout, char *  enders, int  audiofd, int  ctrlfd )

Definition at line 2051 of file channel.c. References ast_check_hangup(), AST_DIGIT_ANY, ast_stopstream(), ast_waitfordigit_full(), ast_waitstream_full(), ast_channel::stream, and ast_channel::zombie. Referenced by ast_app_getdata_full(). { int pos=0; int to = ftimeout; int d; /* Stop if we're a zombie or need a soft hangup */ if (c->zombie || ast_check_hangup(c)) return -1; if (!len) return -1; do { if (c->stream) { d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd); ast_stopstream(c); usleep(1000); if (!d) d = ast_waitfordigit_full(c, to, audiofd, ctrlfd); } else { d = ast_waitfordigit_full(c, to, audiofd, ctrlfd); } if (d < 0) return -1; if (d == 0) { s[pos]='\0'; return 1; } if (d == 1) { s[pos]='\0'; return 2; } if (!strchr(enders, d)) s[pos++] = d; if (strchr(enders, d) || (pos >= len)) { s[pos]='\0'; return 0; } to = timeout; } while(1); /* Never reached */ return 0; }

int ast_recvchar (  struct ast_channel *  chan, int  timeout )

Definition at line 1458 of file channel.c. References ast_check_hangup(), AST_CONTROL_HANGUP, AST_FRAME_CONTROL, AST_FRAME_TEXT, ast_frfree(), ast_read(), ast_waitfor(), ast_frame::data, ast_frame::frametype, and ast_frame::subclass. { int res,ourto,c; struct ast_frame *f; ourto = timeout; for(;;) { if (ast_check_hangup(chan)) return -1; res = ast_waitfor(chan,ourto); if (res <= 0) /* if timeout */ { return 0; } ourto = res; f = ast_read(chan); if (f == NULL) return -1; /* if hangup */ if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) return -1; /* if hangup */ if (f->frametype == AST_FRAME_TEXT) /* if a text frame */ { c = *((char *)f->data); /* get the data */ ast_frfree(f); return(c); } ast_frfree(f); } }

struct ast_channel* ast_request (  char *  type, int  format, void *  data )

Requests a channel. Parameters: type  type of channel to request format  requested channel format data  data to pass to the channel requester Request a channel of a given type, with data as optional information used by the low level module Returns an ast_channel on success, NULL on failure. Definition at line 1873 of file channel.c. References ast_channel::_state, ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_state2str(), AST_STATE_DOWN, ast_translator_best_choice(), backends, ast_channel::callerid, chanlist::capabilities, EVENT_FLAG_CALL, LOG_WARNING, manager_event(), ast_channel::name, chanlist::next, chanlist::requester, chanlist::type, and ast_channel::uniqueid. Referenced by __ast_request_and_dial(). { struct chanlist *chan; struct ast_channel *c = NULL; int capabilities; int fmt; int res; if (ast_mutex_lock(&chlock)) { ast_log(LOG_WARNING, "Unable to lock channel list\n"); return NULL; } chan = backends; while(chan) { if (!strcasecmp(type, chan->type)) { capabilities = chan->capabilities; fmt = format; res = ast_translator_best_choice(&fmt, &capabilities); if (res < 0) { ast_log(LOG_WARNING, "No translator path exists for channel type %s (native %d) to %d\n", type, chan->capabilities, format); ast_mutex_unlock(&chlock); return NULL; } ast_mutex_unlock(&chlock); if (chan->requester) c = chan->requester(type, capabilities, data); if (c) { if (c->_state == AST_STATE_DOWN) { manager_event(EVENT_FLAG_CALL, "Newchannel", "Channel: %s\r\n" "State: %s\r\n" "CallerID: %s\r\n" "Uniqueid: %s\r\n", c->name, ast_state2str(c->_state), c->callerid ? c->callerid : "<unknown>", c->uniqueid); } } return c; } chan = chan->next; } if (!chan) ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type); ast_mutex_unlock(&chlock); return c; }

struct ast_channel* ast_request_and_dial (  char *  type, int  format, void *  data, int  timeout, int *  reason, char *  callerid )

Parameters: type  type of channel to request format  requested channel format data  data to pass to the channel requester timeout  maximum amount of time to wait for an answer why  unsuccessful (if unsuceessful) Request a channel of a given type, with data as optional information used by the low level module and attempt to place a call on it Returns an ast_channel on success or no answer, NULL on failure. Check the value of chan->_state to know if the call was answered or not. Definition at line 1868 of file channel.c. References __ast_request_and_dial(). Referenced by ast_pbx_outgoing_app(), and ast_pbx_outgoing_exten(). { return __ast_request_and_dial(type, format, data, timeout, outstate, callerid, NULL); }

int ast_safe_sleep (  struct ast_channel *  chan, int  ms )

Wait for a specied amount of time, looking for hangups. Parameters: chan  channel to wait for ms  length of time in milliseconds to sleep Waits for a specified amount of time, servicing the channel as required. returns -1 on hangup, otherwise 0. Definition at line 544 of file channel.c. References ast_frfree(), ast_read(), and ast_waitfor(). Referenced by ast_dtmf_stream(). { struct ast_frame *f; while(ms > 0) { ms = ast_waitfor(chan, ms); if (ms <0) return -1; if (ms > 0) { f = ast_read(chan); if (!f) return -1; ast_frfree(f); } } return 0; }

int ast_safe_sleep_conditional (  struct ast_channel *  chan, int  ms, int(*)(void *)  cond, void *  data )

Wait for a specied amount of time, looking for hangups and a condition argument. Parameters: chan  channel to wait for ms  length of time in milliseconds to sleep cond  a function pointer for testing continue condition data  argument to be passed to the condition test function Waits for a specified amount of time, servicing the channel as required. If cond returns 0, this function returns. returns -1 on hangup, otherwise 0. Definition at line 523 of file channel.c. References ast_frfree(), ast_read(), and ast_waitfor(). { struct ast_frame *f; while(ms > 0) { if( cond && ((*cond)(data) == 0 ) ) return 0; ms = ast_waitfor(chan, ms); if (ms <0) return -1; if (ms > 0) { f = ast_read(chan); if (!f) return -1; ast_frfree(f); } } return 0; }

int ast_senddigit (  struct ast_channel *  chan, char  digit )

Receives a text character from a channel. Parameters: chan  channel to act upon timeout  timeout in milliseconds (0 for infinite wait) Read a char of text from a channel Returns 0 on success, -1 on failure Definition at line 1544 of file channel.c. { return do_senddigit(chan, digit); }

int ast_sendtext (  struct ast_channel *  chan, char *  text )

Sends text to a channel. Parameters: chan  channel to act upon text  string of text to send on the channel Write text to a display on a channel Returns 0 on success, -1 on failure Definition at line 1487 of file channel.c. References ast_check_hangup(), ast_channel::blocking, CHECK_BLOCKING, ast_channel::pvt, ast_channel_pvt::send_text, and ast_channel::zombie. { int res = 0; /* Stop if we're a zombie or need a soft hangup */ if (chan->zombie || ast_check_hangup(chan)) return -1; CHECK_BLOCKING(chan); if (chan->pvt->send_text) res = chan->pvt->send_text(chan, text); chan->blocking = 0; return res; }

void ast_set_callerid (  struct ast_channel *  chan, char *  callerid, int  anitoo )

Definition at line 2423 of file channel.c. References ast_channel::ani, ast_cdr_setcid(), ast_channel::callerid, ast_channel::cdr, EVENT_FLAG_CALL, free, manager_event(), ast_channel::name, strdup, and ast_channel::uniqueid. Referenced by __ast_request_and_dial(). { if (chan->callerid) free(chan->callerid); if (anitoo && chan->ani) free(chan->ani); if (callerid) { chan->callerid = strdup(callerid); if (anitoo) chan->ani = strdup(callerid); } else { chan->callerid = NULL; if (anitoo) chan->ani = NULL; } if (chan->cdr) ast_cdr_setcid(chan->cdr, chan); manager_event(EVENT_FLAG_CALL, "Newcallerid", "Channel: %s\r\n" "CallerID: %s\r\n" "Uniqueid: %s\r\n", chan->name, chan->callerid ? chan->callerid : "<Unknown>", chan->uniqueid); }

int ast_set_read_format (  struct ast_channel *  chan, int  format )

Sets read format on channel chan. Parameters: chan  channel to change format  format to change to Set read format for channel to whichever component of "format" is best. Returns 0 on success, -1 on failure Definition at line 1724 of file channel.c. References ast_getformatname(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_translator_best_choice(), ast_translator_build_path(), ast_translator_free_path(), ast_channel::lock, LOG_DEBUG, LOG_NOTICE, ast_channel::name, ast_channel::nativeformats, option_debug, ast_channel::pvt, ast_channel_pvt::rawreadformat, ast_channel::readformat, and ast_channel_pvt::readtrans. Referenced by ast_app_getvoice(), ast_channel_make_compatible(), ast_do_masquerade(), ast_play_and_prepend(), and ast_play_and_record(). { int fmt; int native; int res; ast_mutex_lock(&chan->lock); native = chan->nativeformats; fmt = fmts; /* Find a translation path from the native read format to one of the user's read formats */ res = ast_translator_best_choice(&fmt, &native); if (res < 0) { ast_log(LOG_NOTICE, "Unable to find a path from %s to %s\n", ast_getformatname(chan->nativeformats), ast_getformatname(fmts)); ast_mutex_unlock(&chan->lock); return -1; } /* Now we have a good choice for both. We'll write using our native format. */ chan->pvt->rawreadformat = native; /* User perspective is fmt */ chan->readformat = fmt; /* Free any read translation we have right now */ if (chan->pvt->readtrans) ast_translator_free_path(chan->pvt->readtrans); /* Build a translation path from the raw read format to the user reading format */ chan->pvt->readtrans = ast_translator_build_path(chan->readformat, chan->pvt->rawreadformat); if (option_debug) ast_log(LOG_DEBUG, "Set channel %s to read format %s\n", chan->name, ast_getformatname(chan->readformat)); ast_mutex_unlock(&chan->lock); return 0; }

int ast_set_write_format (  struct ast_channel *  chan, int  format )

Sets write format on channel chan. Parameters: chan  channel to change format  new format for writing Set write format for channel to whichever compoent of "format" is best. Returns 0 on success, -1 on failure Definition at line 1691 of file channel.c. References ast_getformatname(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_translator_best_choice(), ast_translator_build_path(), ast_translator_free_path(), ast_channel::lock, LOG_DEBUG, LOG_NOTICE, ast_channel::name, ast_channel::nativeformats, option_debug, ast_channel::pvt, ast_channel_pvt::rawwriteformat, ast_channel::writeformat, and ast_channel_pvt::writetrans. Referenced by ast_channel_make_compatible(), ast_do_masquerade(), ast_openstream(), and ast_stopstream(). { int fmt; int native; int res; ast_mutex_lock(&chan->lock); native = chan->nativeformats; fmt = fmts; res = ast_translator_best_choice(&native, &fmt); if (res < 0) { ast_log(LOG_NOTICE, "Unable to find a path from %s to %s\n", ast_getformatname(fmts), ast_getformatname(chan->nativeformats)); ast_mutex_unlock(&chan->lock); return -1; } /* Now we have a good choice for both. We'll write using our native format. */ chan->pvt->rawwriteformat = native; /* User perspective is fmt */ chan->writeformat = fmt; /* Free any write translation we have right now */ if (chan->pvt->writetrans) ast_translator_free_path(chan->pvt->writetrans); /* Build a translation path from the user write format to the raw writing format */ chan->pvt->writetrans = ast_translator_build_path(chan->pvt->rawwriteformat, chan->writeformat); if (option_debug) ast_log(LOG_DEBUG, "Set channel %s to write format %s\n", chan->name, ast_getformatname(chan->writeformat)); ast_mutex_unlock(&chan->lock); return 0; }

int ast_setstate (  struct ast_channel *  chan, int  state )

Change the state of a channel Definition at line 2449 of file channel.c. References ast_channel::_state, ast_device_state_changed(), ast_state2str(), AST_STATE_DOWN, ast_channel::callerid, EVENT_FLAG_CALL, manager_event(), ast_channel::name, and ast_channel::uniqueid. Referenced by ast_answer(), ast_async_goto(), and ast_read(). { if (chan->_state != state) { int oldstate = chan->_state; chan->_state = state; if (oldstate == AST_STATE_DOWN) { ast_device_state_changed(chan->name); manager_event(EVENT_FLAG_CALL, "Newchannel", "Channel: %s\r\n" "State: %s\r\n" "CallerID: %s\r\n" "Uniqueid: %s\r\n", chan->name, ast_state2str(chan->_state), chan->callerid ? chan->callerid : "<unknown>", chan->uniqueid); } else { manager_event(EVENT_FLAG_CALL, "Newstate", "Channel: %s\r\n" "State: %s\r\n" "CallerID: %s\r\n" "Uniqueid: %s\r\n", chan->name, ast_state2str(chan->_state), chan->callerid ? chan->callerid : "<unknown>", chan->uniqueid); } } return 0; }

int ast_settimeout (  struct ast_channel *  c, int  samples, int(*)(void *data)  func, void *  data )

Definition at line 1119 of file channel.c. References ast_log(), LOG_DEBUG, ast_channel::timingdata, ast_channel::timingfd, and ast_channel::timingfunc. Referenced by ast_activate_generator(), ast_closestream(), ast_deactivate_generator(), and ast_read(). { int res = -1; #ifdef ZAPTEL_OPTIMIZATIONS if (c->timingfd > -1) { if (!func) { samples = 0; data = 0; } ast_log(LOG_DEBUG, "Scheduling timer at %d sample intervals\n", samples); res = ioctl(c->timingfd, ZT_TIMERCONFIG, &samples); c->timingfunc = func; c->timingdata = data; } #endif return res; }

int ast_shutting_down (  void   )

Returns non-zero if Asterisk is being shut down Definition at line 139 of file channel.c. { return shutting_down; }

int ast_softhangup (  struct ast_channel *  chan, int  cause )

Softly hangup up a channel. Parameters: chan  channel to be soft-hung-up Call the protocol layer, but don't destroy the channel structure (use this if you are trying to safely hangup a channel managed by another thread. Returns 0 regardless Definition at line 668 of file channel.c. References ast_mutex_lock, ast_mutex_unlock, ast_softhangup_nolock(), and ast_channel::lock. Referenced by ast_begin_shutdown(). { int res; ast_mutex_lock(&chan->lock); res = ast_softhangup_nolock(chan, cause); ast_mutex_unlock(&chan->lock); return res; }

int ast_softhangup_nolock (  struct ast_channel *  chan, int  cause )

Definition at line 653 of file channel.c. References ast_channel::_softhangup, AST_FRAME_NULL, ast_log(), ast_queue_frame(), ast_channel::blocker, ast_channel::blocking, LOG_DEBUG, ast_channel::name, and option_debug. Referenced by ast_async_goto(), and ast_softhangup(). { int res = 0; struct ast_frame f = { AST_FRAME_NULL }; if (option_debug) ast_log(LOG_DEBUG, "Soft-Hanging up channel '%s'\n", chan->name); /* Inform channel driver that we need to be hung up, if it cares */ chan->_softhangup |= cause; ast_queue_frame(chan, &f); /* Interrupt any poll call or such */ if (chan->blocking) pthread_kill(chan->blocker, SIGURG); return res; }

char* ast_state2str (  int  state  )

Gives the string form of a given state. Parameters: state  state to get the name of Give a name to a state Pretty self explanatory. Returns the text form of the binary state given Definition at line 205 of file channel.c. References AST_STATE_BUSY, AST_STATE_DIALING, AST_STATE_DOWN, AST_STATE_OFFHOOK, AST_STATE_RESERVED, AST_STATE_RING, AST_STATE_RINGING, and AST_STATE_UP. Referenced by ast_request(), and ast_setstate(). { /* XXX Not reentrant XXX */ static char localtmp[256]; switch(state) { case AST_STATE_DOWN: return "Down"; case AST_STATE_RESERVED: return "Rsrvd"; case AST_STATE_OFFHOOK: return "OffHook"; case AST_STATE_DIALING: return "Dialing"; case AST_STATE_RING: return "Ring"; case AST_STATE_RINGING: return "Ringing"; case AST_STATE_UP: return "Up"; case AST_STATE_BUSY: return "Busy"; default: snprintf(localtmp, sizeof(localtmp), "Unknown (%d)\n", state); return localtmp; } }

int ast_tonepair (  struct ast_channel *  chan, int  freq1, int  freq2, int  duration, int  vol )

Play a tone pair for a given amount of time Definition at line 2884 of file channel.c. References ast_frfree(), ast_read(), ast_tonepair_start(), ast_waitfor(), and ast_channel::generatordata. { struct ast_frame *f; int res; if ((res = ast_tonepair_start(chan, freq1, freq2, duration, vol))) return res; /* Give us some wiggle room */ while(chan->generatordata && (ast_waitfor(chan, 100) >= 0)) { f = ast_read(chan); if (f) ast_frfree(f); else return -1; } return 0; }

int ast_tonepair_start (  struct ast_channel *  chan, int  freq1, int  freq2, int  duration, int  vol )

Start a tone going Definition at line 2864 of file channel.c. References ast_activate_generator(), tonepair_def::duration, tonepair_def::freq1, tonepair_def::freq2, and tonepair_def::vol. Referenced by ast_tonepair(). { struct tonepair_def d = { 0, }; d.freq1 = freq1; d.freq2 = freq2; d.duration = duration; if (vol < 1) d.vol = 8192; else d.vol = vol; if (ast_activate_generator(chan, &tonepair, &d)) return -1; return 0; }

void ast_tonepair_stop (  struct ast_channel *  chan  )

Stop a tone from playing Definition at line 2879 of file channel.c. References ast_deactivate_generator(). { ast_deactivate_generator(chan); }

int ast_transfer (  struct ast_channel *  chan, char *  dest )

Definition at line 1992 of file channel.c. References ast_check_hangup(), ast_mutex_lock, ast_mutex_unlock, ast_channel::lock, ast_channel::pvt, ast_channel_pvt::transfer, and ast_channel::zombie. { /* Place an outgoing call, but don't wait any longer than timeout ms before returning. If the remote end does not answer within the timeout, then do NOT hang up, but return anyway. */ int res = -1; /* Stop if we're a zombie or need a soft hangup */ ast_mutex_lock(&chan->lock); if (!chan->zombie && !ast_check_hangup(chan)) { if (chan->pvt->transfer) { res = chan->pvt->transfer(chan, dest); if (!res) res = 1; } else res = 0; } ast_mutex_unlock(&chan->lock); return res; }

int ast_waitfor (  struct ast_channel *  chan, int  ms )

Wait for input on a channel. Parameters: chan  channel to wait on ms  length of time to wait on the channel Wait for input on a channel for a given # of milliseconds (<0 for indefinite). Returns < 0 on failure, 0 if nothing ever arrived, and the # of ms remaining otherwise Definition at line 1078 of file channel.c. References ast_waitfor_n(). Referenced by __ast_request_and_dial(), ast_app_getvoice(), ast_dtmf_stream(), ast_play_and_prepend(), ast_play_and_record(), ast_recvchar(), ast_safe_sleep(), ast_safe_sleep_conditional(), ast_tonepair(), ast_waitfordigit(), ast_waitstream(), and ast_waitstream_fr(). { struct ast_channel *chan; int oldms = ms; chan = ast_waitfor_n(&c, 1, &ms); if (ms < 0) { if (oldms < 0) return 0; else return -1; } return ms; }

struct ast_channel* ast_waitfor_n (  struct ast_channel **  chan, int  n, int *  ms )

Waits for input on a group of channels. Wait for input on an array of channels for a given # of milliseconds. Return channel with activity, or NULL if none has activity. time "ms" is modified in-place, if applicable Definition at line 1073 of file channel.c. References ast_waitfor_nandfds(). Referenced by ast_channel_bridge(), ast_rtp_bridge(), and ast_waitfor(). { return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms); }

int ast_waitfor_n_fd (  int *  fds, int  n, int *  ms, int *  exception )

Waits for input on an fd. This version works on fd's only. Be careful with it. Definition at line 869 of file channel.c. References ast_log(), pollfd::events, pollfd::fd, LOG_WARNING, poll(), POLLIN, and POLLPRI. { /* Wait for x amount of time on a file descriptor to have input. */ struct timeval start, now; int res; int x, y; int winner = -1; int spoint; struct pollfd *pfds; pfds = alloca(sizeof(struct pollfd) * n); if (!pfds) { ast_log(LOG_WARNING, "alloca failed! bad things will happen.\n"); return -1; } if (*ms > 0) gettimeofday(&start, NULL); y = 0; for (x=0;x<n;x++) { if (fds[x] > -1) { pfds[y].fd = fds[x]; pfds[y].events = POLLIN | POLLPRI; y++; } } res = poll(pfds, y, *ms); if (res < 0) { /* Simulate a timeout if we were interrupted */ if (errno != EINTR) *ms = -1; else *ms = 0; return -1; } spoint = 0; for (x=0;x<n;x++) { if (fds[x] > -1) { if ((res = ast_fdisset(pfds, fds[x], y, &spoint))) { winner = fds[x]; if (exception) { if (res & POLLPRI) *exception = -1; else *exception = 0; } } } } if (*ms > 0) { long passed; gettimeofday(&now, NULL); passed = (now.tv_sec - start.tv_sec) * 1000; passed += (now.tv_usec - start.tv_usec) / 1000; if (passed <= *ms) *ms -= passed; else *ms = 0; } return winner; }

struct ast_channel* ast_waitfor_nandfds (  struct ast_channel **  chan, int  n, int *  fds, int  nfds, int *  exception, int *  outfd, int *  ms )

Waits for activity on a group of channels. Parameters: chan  an array of pointers to channels n  number of channels that are to be waited upon fds  an array of fds to wait upon nfds  the number of fds to wait upon exception  exception flag outfd  fd that had activity on it ms  how long the wait was Big momma function here. Wait for activity on any of the n channels, or any of the nfds file descriptors. Returns the channel with activity, or NULL on error or if an FD came first. If the FD came first, it will be returned in outfd, otherwise, outfd will be -1 Definition at line 930 of file channel.c. References ast_channel::_softhangup, ast_do_masquerade(), ast_log(), AST_MAX_FDS, ast_mutex_lock, ast_mutex_unlock, AST_SOFTHANGUP_TIMEOUT, ast_channel::blocking, CHECK_BLOCKING, pollfd::events, ast_channel::exception, pollfd::fd, ast_channel::fdno, ast_channel::fds, ast_channel::lock, LOG_WARNING, ast_channel::masq, poll(), POLLIN, POLLPRI, and ast_channel::whentohangup. Referenced by ast_waitfor_n(), ast_waitfordigit_full(), and ast_waitstream_full(). { /* Wait for x amount of time on a file descriptor to have input. */ struct timeval start, end; struct pollfd *pfds; int res; long rms; int x, y, max; int spoint; time_t now = 0; long whentohangup = 0, havewhen = 0, diff; struct ast_channel *winner = NULL; pfds = alloca(sizeof(struct pollfd) * (n * AST_MAX_FDS + nfds)); if (!pfds) { ast_log(LOG_WARNING, "alloca failed! bad things will happen.\n"); *outfd = -1; return NULL; } if (outfd) *outfd = -99999; if (exception) *exception = 0; /* Perform any pending masquerades */ for (x=0;x<n;x++) { ast_mutex_lock(&c[x]->lock); if (c[x]->whentohangup) { if (!havewhen) time(&now); diff = c[x]->whentohangup - now; if (!havewhen || (diff < whentohangup)) { havewhen++; whentohangup = diff; } } if (c[x]->masq) { if (ast_do_masquerade(c[x])) { ast_log(LOG_WARNING, "Masquerade failed\n"); *ms = -1; ast_mutex_unlock(&c[x]->lock); return NULL; } } ast_mutex_unlock(&c[x]->lock); } rms = *ms; if (havewhen) { if ((*ms < 0) || (whentohangup * 1000 < *ms)) { rms = whentohangup * 1000; } } max = 0; for (x=0;x<n;x++) { for (y=0;y<AST_MAX_FDS;y++) { if (c[x]->fds[y] > -1) { pfds[max].fd = c[x]->fds[y]; pfds[max].events = POLLIN | POLLPRI; max++; } } CHECK_BLOCKING(c[x]); } for (x=0;x<nfds; x++) { if (fds[x] > -1) { pfds[max].fd = fds[x]; pfds[max].events = POLLIN | POLLPRI; max++; } } if (*ms > 0) gettimeofday(&start, NULL); res = poll(pfds, max, rms); if (res < 0) { for (x=0;x<n;x++) c[x]->blocking = 0; /* Simulate a timeout if we were interrupted */ if (errno != EINTR) *ms = -1; else { /* Just an interrupt */ #if 0 *ms = 0; #endif } return NULL; } if (havewhen) time(&now); spoint = 0; for (x=0;x<n;x++) { c[x]->blocking = 0; if (havewhen && c[x]->whentohangup && (now > c[x]->whentohangup)) { c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT; if (!winner) winner = c[x]; } for (y=0;y<AST_MAX_FDS;y++) { if (c[x]->fds[y] > -1) { if ((res = ast_fdisset(pfds, c[x]->fds[y], max, &spoint))) { if (res & POLLPRI) c[x]->exception = -1; else c[x]->exception = 0; c[x]->fdno = y; winner = c[x]; } } } } for (x=0;x<nfds;x++) { if (fds[x] > -1) { if ((res = ast_fdisset(pfds, fds[x], max, &spoint))) { if (outfd) *outfd = fds[x]; if (exception) { if (res & POLLPRI) *exception = -1; else *exception = 0; } winner = NULL; } } } if (*ms > 0) { long diff; gettimeofday(&end, NULL); diff = (end.tv_sec - start.tv_sec) * 1000; diff += (end.tv_usec - start.tv_usec) / 1000; if (diff < *ms) *ms -= diff; else *ms = 0; } return winner; }

int ast_waitfordigit (  struct ast_channel *  c, int  ms )

Waits for a digit. Parameters: c  channel to wait for a digit on ms  how many milliseconds to wait Wait for a digit. Returns <0 on error, 0 on no entry, and the digit on success. Definition at line 1092 of file channel.c. References ast_check_hangup(), AST_FRAME_DTMF, ast_frfree(), ast_read(), ast_waitfor(), ast_frame::frametype, ast_frame::subclass, and ast_channel::zombie. Referenced by ast_control_streamfile(), ast_pbx_run(), and ast_readstring(). { /* XXX Should I be merged with waitfordigit_full XXX */ struct ast_frame *f; int result = 0; /* Stop if we're a zombie or need a soft hangup */ if (c->zombie || ast_check_hangup(c)) return -1; /* Wait for a digit, no more than ms milliseconds total. */ while(ms && !result) { ms = ast_waitfor(c, ms); if (ms < 0) /* Error */ result = -1; else if (ms > 0) { /* Read something */ f = ast_read(c); if (f) { if (f->frametype == AST_FRAME_DTMF) result = f->subclass; ast_frfree(f); } else result = -1; } } return result; }

int ast_waitfordigit_full (  struct ast_channel *  c, int  ms, int  audiofd, int  cmdfd )

Definition at line 1136 of file channel.c. References ast_check_hangup(), AST_CONTROL_ANSWER, AST_CONTROL_HANGUP, AST_CONTROL_RINGING, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_VOICE, ast_frfree(), ast_log(), ast_read(), ast_waitfor_nandfds(), ast_frame::data, ast_frame::datalen, ast_frame::frametype, LOG_WARNING, ast_frame::subclass, and ast_channel::zombie. Referenced by ast_readstring_full(). { struct ast_frame *f; struct ast_channel *rchan; int outfd; int res; /* Stop if we're a zombie or need a soft hangup */ if (c->zombie || ast_check_hangup(c)) return -1; /* Wait for a digit, no more than ms milliseconds total. */ while(ms) { errno = 0; rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms); if ((!rchan) && (outfd < 0) && (ms)) { if (errno == 0 || errno == EINTR) continue; ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno)); return -1; } else if (outfd > -1) { /* The FD we were watching has something waiting */ return 1; } else if (rchan) { f = ast_read(c); if(!f) { return -1; } switch(f->frametype) { case AST_FRAME_DTMF: res = f->subclass; ast_frfree(f); return res; case AST_FRAME_CONTROL: switch(f->subclass) { case AST_CONTROL_HANGUP: ast_frfree(f); return -1; case AST_CONTROL_RINGING: case AST_CONTROL_ANSWER: /* Unimportant */ break; default: ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass); } case AST_FRAME_VOICE: /* Write audio if appropriate */ if (audiofd > -1) write(audiofd, f->data, f->datalen); } /* Ignore */ ast_frfree(f); } } return 0; // Time is up }

int ast_write (  struct ast_channel *  chan, struct ast_frame *  frame )

Write a frame to a channel. Parameters: chan  destination channel of the frame frame  frame that will be written This function writes the given frame to the indicated channel. It returns 0 on success, -1 on failure. Definition at line 1575 of file channel.c. References ast_channel::_softhangup, ast_check_hangup(), ast_deactivate_generator(), ast_do_masquerade(), AST_FRAME_CONTROL, AST_FRAME_DTMF, ast_frame_dump(), AST_FRAME_HTML, AST_FRAME_TEXT, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree(), ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_seekstream(), AST_SOFTHANGUP_DEV, ast_translate(), ast_writestream(), ast_channel::blocking, CHECK_BLOCKING, ast_frame::data, ast_frame::datalen, ast_channel::fout, ast_frame::frametype, ast_channel::generatordata, ast_channel::insmpl, ast_channel::lock, LOG_WARNING, ast_channel::masq, ast_channel::masqr, ast_channel::monitor, ast_channel::name, ast_channel::outsmpl, ast_channel::pvt, ast_frame::samples, SEEK_FORCECUR, ast_channel_pvt::send_html, ast_channel_pvt::send_text, ast_frame::subclass, ast_channel_pvt::write, ast_channel_monitor::write_stream, ast_channel_pvt::write_video, ast_channel::writeinterrupt, ast_channel_pvt::writetrans, and ast_channel::zombie. Referenced by ast_channel_bridge(), ast_dtmf_stream(), ast_prod(), ast_rtp_bridge(), and ast_write_video(). { int res = -1; struct ast_frame *f = NULL; /* Stop if we're a zombie or need a soft hangup */ ast_mutex_lock(&chan->lock); if (chan->zombie || ast_check_hangup(chan)) { ast_mutex_unlock(&chan->lock); return -1; } /* Handle any pending masquerades */ if (chan->masq) { if (ast_do_masquerade(chan)) { ast_log(LOG_WARNING, "Failed to perform masquerade\n"); ast_mutex_unlock(&chan->lock); return -1; } } if (chan->masqr) { ast_mutex_unlock(&chan->lock); return 0; } if (chan->generatordata) { if (chan->writeinterrupt) ast_deactivate_generator(chan); else { ast_mutex_unlock(&chan->lock); return 0; } } /* High bit prints debugging */ if (chan->fout & 0x80000000) ast_frame_dump(chan->name, fr, ">>"); CHECK_BLOCKING(chan); switch(fr->frametype) { case AST_FRAME_CONTROL: /* XXX Interpret control frames XXX */ ast_log(LOG_WARNING, "Don't know how to handle control frames yet\n"); break; case AST_FRAME_DTMF: chan->blocking = 0; ast_mutex_unlock(&chan->lock); res = do_senddigit(chan,fr->subclass); ast_mutex_lock(&chan->lock); CHECK_BLOCKING(chan); break; case AST_FRAME_TEXT: if (chan->pvt->send_text) res = chan->pvt->send_text(chan, (char *) fr->data); else res = 0; break; case AST_FRAME_HTML: if (chan->pvt->send_html) res = chan->pvt->send_html(chan, fr->subclass, (char *) fr->data, fr->datalen); else res = 0; break; case AST_FRAME_VIDEO: /* XXX Handle translation of video codecs one day XXX */ if (chan->pvt->write_video) res = chan->pvt->write_video(chan, fr); else res = 0; break; default: if (chan->pvt->write) { if (chan->pvt->writetrans) { f = ast_translate(chan->pvt->writetrans, fr, 0); } else f = fr; if (f) { res = chan->pvt->write(chan, f); if( chan->monitor && chan->monitor->write_stream && f && ( f->frametype == AST_FRAME_VOICE ) ) { #ifndef MONITOR_CONSTANT_DELAY int jump = chan->insmpl - chan->outsmpl - 2 * f->samples; if (jump >= 0) { if (ast_seekstream(chan->monitor->write_stream, jump + f->samples, SEEK_FORCECUR) == -1) ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n"); chan->outsmpl += jump + 2 * f->samples; } else chan->outsmpl += f->samples; #else int jump = chan->insmpl - chan->outsmpl; if (jump - MONITOR_DELAY >= 0) { if (ast_seekstream(chan->monitor->write_stream, jump - f->samples, SEEK_FORCECUR) == -1) ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n"); chan->outsmpl += jump; } else chan->outsmpl += f->samples; #endif if (ast_writestream(chan->monitor->write_stream, f) < 0) ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n"); } } else res = 0; } } if (f && (f != fr)) ast_frfree(f); chan->blocking = 0; /* Consider a write failure to force a soft hangup */ if (res < 0) chan->_softhangup |= AST_SOFTHANGUP_DEV; else { if ((chan->fout & 0x7fffffff) == 0x7fffffff) chan->fout &= 0x80000000; else chan->fout++; } ast_mutex_unlock(&chan->lock); return res; }

int ast_write_video (  struct ast_channel *  chan, struct ast_frame *  frame )

Write video frame to a channel. Parameters: chan  destination channel of the frame frame  frame that will be written This function writes the given frame to the indicated channel. It returns 1 on success, 0 if not implemented, and -1 on failure. Definition at line 1564 of file channel.c. References ast_write(), ast_channel::pvt, and ast_channel_pvt::write_video. { int res; if (!chan->pvt->write_video) return 0; res = ast_write(chan, fr); if (!res) res = 1; return res; }

---

Variable Documentation

struct chanlist * backends

Referenced by ast_channel_register_ex(), ast_channel_unregister(), ast_device_state(), and ast_request().

struct ast_channel* channels = NULL

Definition at line 72 of file channel.c.

---