channel.c File Reference

Channel Management. More...

#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 "asterisk.h"
#include "asterisk/pbx.h"
#include "asterisk/frame.h"
#include "asterisk/sched.h"
#include "asterisk/options.h"
#include "asterisk/channel.h"
#include "asterisk/chanspy.h"
#include "asterisk/musiconhold.h"
#include "asterisk/logger.h"
#include "asterisk/say.h"
#include "asterisk/file.h"
#include "asterisk/cli.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/callerid.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/app.h"
#include "asterisk/transcap.h"
#include "asterisk/devicestate.h"

Include dependency graph for channel.c:

Go to the source code of this file.

Data Structures
struct	ast_cause
struct	ast_channel_spy_list
struct	ast_silence_generator
struct	chanlist
struct	channel_spy_trans
struct	tonepair_def
struct	tonepair_state
Defines
#define	FORMAT   "%-10.10s %-30.30s %-12.12s %-12.12s %-12.12s\n"
#define	SPY_QUEUE_SAMPLE_LIMIT   4000
Enumerations
enum	spy_direction { SPY_READ, SPY_WRITE }
Functions
struct ast_channel *	__ast_request_and_dial (const char *type, int format, void *data, int timeout, int *outstate, const char *cid_num, const char *cid_name, struct outgoing_helper *oh)
int	ast_activate_generator (struct ast_channel *chan, struct ast_generator *gen, void *params)
int	ast_active_channels (void)
int	ast_answer (struct ast_channel *chan)
	Answer a ringing call.
void	ast_begin_shutdown (int hangup)
int	ast_best_codec (int fmts)
struct ast_channel *	ast_bridged_channel (struct ast_channel *chan)
	Find bridged channel.
int	ast_call (struct ast_channel *chan, char *addr, int timeout)
	Make a call.
void	ast_cancel_shutdown (void)
const char *	ast_cause2str (int cause)
void	ast_change_name (struct ast_channel *chan, char *newname)
	Change channel name.
struct ast_channel *	ast_channel_alloc (int needqueue)
	Create a channel structure.
enum ast_bridge_result	ast_channel_bridge (struct ast_channel *c0, struct ast_channel *c1, struct ast_bridge_config *config, struct ast_frame **fo, struct ast_channel **rc)
int	ast_channel_cmpwhentohangup (struct ast_channel *chan, time_t offset)
	Compare a offset with the settings of when to hang a channel up.
int	ast_channel_defer_dtmf (struct ast_channel *chan)
void	ast_channel_free (struct ast_channel *chan)
	Free a channel structure.
void	ast_channel_inherit_variables (const struct ast_channel *parent, struct ast_channel *child)
	Inherits channel variable from parent to child channel.
int	ast_channel_make_compatible (struct ast_channel *chan, struct ast_channel *peer)
int	ast_channel_masquerade (struct ast_channel *original, struct ast_channel *clone)
int	ast_channel_register (const struct ast_channel_tech *tech)
	Register a channel technology (a new channel driver) Called by a channel module to register the kind of channels it supports.
int	ast_channel_sendhtml (struct ast_channel *chan, int subclass, const char *data, int datalen)
int	ast_channel_sendurl (struct ast_channel *chan, const char *url)
int	ast_channel_setoption (struct ast_channel *chan, int option, void *data, int datalen, int block)
void	ast_channel_setwhentohangup (struct ast_channel *chan, time_t offset)
	Set when to hang a channel up.
int	ast_channel_spy_add (struct ast_channel *chan, struct ast_channel_spy *spy)
	Adds a spy to a channel, to begin receiving copies of the channel's audio frames.
void	ast_channel_spy_free (struct ast_channel_spy *spy)
	Free a spy.
struct ast_frame *	ast_channel_spy_read_frame (struct ast_channel_spy *spy, unsigned int samples)
	Read one (or more) frames of audio from a channel being spied upon.
void	ast_channel_spy_remove (struct ast_channel *chan, struct ast_channel_spy *spy)
	Remove a spy from a channel.
void	ast_channel_spy_stop_by_type (struct ast_channel *chan, const char *type)
	Find all spies of a particular type on a channel and stop them.
void	ast_channel_spy_trigger_wait (struct ast_channel_spy *spy)
	Efficiently wait until audio is available for a spy, or an exception occurs.
struct ast_silence_generator *	ast_channel_start_silence_generator (struct ast_channel *chan)
	Starts a silence generator on the given channel.
void	ast_channel_stop_silence_generator (struct ast_channel *chan, struct ast_silence_generator *state)
	Stops a previously-started silence generator on the given channel.
int	ast_channel_supports_html (struct ast_channel *chan)
void	ast_channel_undefer_dtmf (struct ast_channel *chan)
void	ast_channel_unregister (const struct ast_channel_tech *tech)
	Unregister a channel technology.
struct ast_channel *	ast_channel_walk_locked (const struct ast_channel *prev)
void	ast_channels_init (void)
int	ast_check_hangup (struct ast_channel *chan)
	Check to see if a channel is needing hang up.
static int	ast_check_hangup_locked (struct ast_channel *chan)
void	ast_deactivate_generator (struct ast_channel *chan)
int	ast_do_masquerade (struct ast_channel *original)
	Start masquerading a channel 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.
static enum ast_bridge_result	ast_generic_bridge (struct ast_channel *c0, struct ast_channel *c1, struct ast_bridge_config *config, struct ast_frame **fo, struct ast_channel **rc, struct timeval bridge_end)
struct ast_channel *	ast_get_channel_by_exten_locked (const char *exten, const char *context)
struct ast_channel *	ast_get_channel_by_name_locked (const char *name)
struct ast_channel *	ast_get_channel_by_name_prefix_locked (const char *name, const int namelen)
struct ast_channel_tech *	ast_get_channel_tech (const char *name)
	Get a channel technology structure by name.
ast_group_t	ast_get_group (char *s)
int	ast_hangup (struct ast_channel *chan)
	Hang up a channel.
int	ast_indicate (struct ast_channel *chan, int condition)
	Indicates condition of channel.
void	ast_install_music_functions (int(*start_ptr)(struct ast_channel *, char *), void(*stop_ptr)(struct ast_channel *), void(*cleanup_ptr)(struct ast_channel *))
void	ast_moh_cleanup (struct ast_channel *chan)
int	ast_moh_start (struct ast_channel *chan, char *mclass)
void	ast_moh_stop (struct ast_channel *chan)
	AST_MUTEX_DEFINE_STATIC (chlock)
	AST_MUTEX_DEFINE_STATIC (uniquelock)
char *	ast_print_group (char *buf, int buflen, ast_group_t group)
int	ast_prod (struct ast_channel *chan)
int	ast_queue_control (struct ast_channel *chan, int control)
	Queue a control frame.
int	ast_queue_frame (struct ast_channel *chan, struct ast_frame *fin)
	Queue an outgoing frame.
int	ast_queue_hangup (struct ast_channel *chan)
	Queue a hangup frame.
struct ast_frame *	ast_read (struct ast_channel *chan)
int	ast_readstring (struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders)
int	ast_readstring_full (struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders, int audiofd, int ctrlfd)
int	ast_recvchar (struct ast_channel *chan, int timeout)
char *	ast_recvtext (struct ast_channel *chan, int timeout)
struct ast_channel *	ast_request (const char *type, int format, void *data, int *cause)
	Requests a channel.
struct ast_channel *	ast_request_and_dial (const char *type, int format, void *data, int timeout, int *outstate, const char *cidnum, const char *cidname)
	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.
int	ast_safe_sleep (struct ast_channel *chan, int ms)
	Wait for a specied amount of time, looking for hangups.
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_senddigit (struct ast_channel *chan, char digit)
int	ast_sendtext (struct ast_channel *chan, const char *text)
void	ast_set_callerid (struct ast_channel *chan, const char *callerid, const char *calleridname, const char *ani)
int	ast_set_read_format (struct ast_channel *chan, int fmt)
void	ast_set_variables (struct ast_channel *chan, struct ast_variable *vars)
	adds a list of channel variables to a channel
int	ast_set_write_format (struct ast_channel *chan, int fmt)
int	ast_setstate (struct ast_channel *chan, int state)
	Change the state of a channel.
int	ast_settimeout (struct ast_channel *c, int samples, int(*func)(void *data), void *data)
int	ast_shutting_down (void)
int	ast_softhangup (struct ast_channel *chan, int cause)
	Softly hangup up a channel.
int	ast_softhangup_nolock (struct ast_channel *chan, int cause)
	Softly hangup up a channel (no channel lock).
char *	ast_state2str (int state)
int	ast_tonepair (struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
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_transfer (struct ast_channel *chan, char *dest)
	Transfer a channel (if supported). Returns -1 on error, 0 if not supported and 1 if supported and requested.
char *	ast_transfercapability2str (int transfercapability)
void	ast_uninstall_music_functions (void)
int	ast_waitfor (struct ast_channel *c, int ms)
	Wait for input on a channel.
struct ast_channel *	ast_waitfor_n (struct ast_channel **c, int n, int *ms)
int	ast_waitfor_n_fd (int *fds, int n, int *ms, int *exception)
struct 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.
int	ast_waitfordigit (struct ast_channel *c, int ms)
int	ast_waitfordigit_full (struct ast_channel *c, int ms, int audiofd, int cmdfd)
struct ast_channel *	ast_walk_channel_by_name_prefix_locked (struct ast_channel *chan, const char *name, const int namelen)
int	ast_write (struct ast_channel *chan, struct ast_frame *fr)
int	ast_write_video (struct ast_channel *chan, struct ast_frame *fr)
static void	bridge_playfile (struct ast_channel *chan, struct ast_channel *peer, char *sound, int remain)
static struct ast_channel *	channel_find_locked (const struct ast_channel *prev, const char *name, const int namelen, const char *context, const char *exten)
static void	clone_variables (struct ast_channel *original, struct ast_channel *clone)
static void	copy_data_from_queue (struct ast_channel_spy_queue *queue, short *buf, unsigned int samples)
static void	detach_spies (struct ast_channel *chan)
static int	do_senddigit (struct ast_channel *chan, char digit)
static void	free_cid (struct ast_callerid *cid)
static void	free_translation (struct ast_channel *clone)
static int	generator_force (void *data)
static void	queue_frame_to_spies (struct ast_channel *chan, struct ast_frame *f, enum spy_direction dir)
static int	set_format (struct ast_channel *chan, int fmt, int *rawformat, int *format, struct ast_trans_pvt **trans, const int direction)
static int	show_channeltypes (int fd, int argc, char *argv[])
static void *	silence_generator_alloc (struct ast_channel *chan, void *data)
static int	silence_generator_generate (struct ast_channel *chan, void *data, int len, int samples)
static void	silence_generator_release (struct ast_channel *chan, void *data)
static void	spy_cleanup (struct ast_channel *chan)
static void	spy_detach (struct ast_channel_spy *spy, struct ast_channel *chan)
static void *	tonepair_alloc (struct ast_channel *chan, void *params)
static int	tonepair_generator (struct ast_channel *chan, void *data, int len, int samples)
static void	tonepair_release (struct ast_channel *chan, void *params)
Variables
static void(*	ast_moh_cleanup_ptr )(struct ast_channel *) = NULL
static int(*	ast_moh_start_ptr )(struct ast_channel *, char *) = NULL
static void(*	ast_moh_stop_ptr )(struct ast_channel *) = NULL
static struct chanlist *	backends = NULL
struct ast_cause	causes []
static struct ast_channel *	channels = NULL
static struct ast_cli_entry	cli_show_channeltypes
unsigned long	global_fin = 0
unsigned long	global_fout = 0
static struct ast_channel_tech	null_tech
static char	show_channeltypes_usage []
static int	shutting_down = 0
static struct ast_generator	silence_generator
static struct ast_generator	tonepair
static int	uniqueint = 0

---

Detailed Description

Channel Management.

Definition in file channel.c.

---

Define Documentation

#define FORMAT   "%-10.10s %-30.30s %-12.12s %-12.12s %-12.12s\n"

#define SPY_QUEUE_SAMPLE_LIMIT   4000

Definition at line 1183 of file channel.c.

Referenced by queue_frame_to_spies().

---

Enumeration Type Documentation

enum spy_direction

Enumerator:

SPY_READ
SPY_WRITE

Definition at line 1178 of file channel.c.

                   {
   SPY_READ,
   SPY_WRITE,
};

---

Function Documentation

struct ast_channel* __ast_request_and_dial	(	const char *	type,
		int	format,
		void *	data,
		int	timeout,
		int *	outstate,
		const char *	cid_num,
		const char *	cid_name,
		struct outgoing_helper *	oh
	)			[read]

Definition at line 2449 of file channel.c.

References ast_channel::_state, outgoing_helper::account, ast_call(), AST_CAUSE_BUSY, AST_CAUSE_CONGESTION, 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_channel_inherit_variables(), AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_HANGUP, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, AST_FRAME_CONTROL, ast_frfree(), ast_hangup(), ast_log(), ast_read(), ast_request(), ast_set_callerid(), ast_set_variables(), AST_STATE_UP, ast_waitfor(), ast_channel::cdr, outgoing_helper::cid_name, outgoing_helper::cid_num, ast_channel::context, outgoing_helper::context, ast_channel::exten, outgoing_helper::exten, ast_frame::frametype, ast_channel::hangupcause, LOG_NOTICE, LOG_WARNING, outgoing_helper::parent_channel, ast_channel::priority, outgoing_helper::priority, ast_frame::subclass, and outgoing_helper::vars.

Referenced by ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_request_and_dial(), and parkandannounce_exec().

{
   int state = 0;
   int cause = 0;
   struct ast_channel *chan;
   struct ast_frame *f;
   int res = 0;
   
   chan = ast_request(type, format, data, &cause);
   if (chan) {
      if (oh) {
         if (oh->vars)  
            ast_set_variables(chan, oh->vars);
         if (oh->cid_num && *oh->cid_num && oh->cid_name && *oh->cid_name)
            ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num);
         if (oh->parent_channel)
            ast_channel_inherit_variables(oh->parent_channel, chan);
         if (oh->account)
            ast_cdr_setaccount(chan, oh->account); 
      }
      ast_set_callerid(chan, cid_num, cid_name, cid_num);

      if (!ast_call(chan, data, 0)) {
         res = 1; /* in case chan->_state is already AST_STATE_UP */
         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 || f->subclass == AST_CONTROL_PROCEEDING) {
                  /* 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 call channel %s/%s\n", type, (char *)data);
   } else {
      ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
      switch(cause) {
      case AST_CAUSE_BUSY:
         state = AST_CONTROL_BUSY;
         break;
      case AST_CAUSE_CONGESTION:
         state = AST_CONTROL_CONGESTION;
         break;
      }
   }
   if (chan) {
      /* Final fixups */
      if (oh) {
         if (oh->context && *oh->context)
            ast_copy_string(chan->context, oh->context, sizeof(chan->context));
         if (oh->exten && *oh->exten)
            ast_copy_string(chan->exten, oh->exten, sizeof(chan->exten));
         if (oh->priority) 
            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 1476 of file channel.c.

References ast_generator::alloc, ast_mutex_lock(), ast_mutex_unlock(), ast_prod(), ast_settimeout(), ast_channel::generator, generator_force(), ast_channel::generatordata, ast_channel::lock, and ast_generator::release.

Referenced by app_exec(), ast_channel_start_silence_generator(), ast_linear_stream(), ast_playtones_start(), ast_tonepair_start(), channel_spy(), local_ast_moh_start(), milliwatt_exec(), and sms_exec().

{
   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 (gen->alloc) {
      if (!(chan->generatordata = gen->alloc(chan, params)))
         res = -1;
   }
   
   if (!res) {
      ast_settimeout(chan, 160, generator_force, chan);
      chan->generator = gen;
   }

   ast_mutex_unlock(&chan->lock);

   return res;
}

int ast_active_channels

(

void

)

Returns number of active/allocated channels

Definition at line 250 of file channel.c.

References ast_mutex_lock(), ast_mutex_unlock(), channels, and ast_channel::next.

Referenced by quit_handler().

{
   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:

Returns 0 on success, -1 on failure

Definition at line 1412 of file channel.c.

References ast_channel::_state, ast_channel_tech::answer, ast_cdr_answer(), ast_check_hangup(), AST_FLAG_ZOMBIE, ast_mutex_lock(), ast_mutex_unlock(), ast_setstate(), AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, ast_test_flag, ast_channel::cdr, ast_channel::lock, and ast_channel::tech.

Referenced by __login_exec(), agi_exec_full(), alarmreceiver_exec(), app_exec(), ast_bridge_call(), ast_control_streamfile(), ast_pickup_call(), auth_exec(), background_detect_exec(), chanspy_exec(), conf_exec(), count_exec(), datetime_exec(), dial_exec_full(), dictate_exec(), directory_exec(), disa_exec(), features_answer(), handle_answer(), ices_exec(), milliwatt_exec(), park_call_exec(), park_exec(), pbx_builtin_answer(), pbx_builtin_background(), pickup_exec(), playback_exec(), privacy_exec(), read_exec(), record_exec(), rpt_exec(), sayunixtime_exec(), send_waveform_to_channel(), skel_exec(), sms_exec(), testclient_exec(), testserver_exec(), vm_exec(), vm_execmain(), waitforsilence_exec(), zapateller_exec(), and zapras_exec().

{
   int res = 0;
   ast_mutex_lock(&chan->lock);
   /* Stop if we're a zombie or need a soft hangup */
   if (ast_test_flag(chan, AST_FLAG_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->tech->answer)
         res = chan->tech->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 234 of file channel.c.

References ast_mutex_lock(), ast_mutex_unlock(), ast_softhangup(), AST_SOFTHANGUP_SHUTDOWN, channels, ast_channel::next, and shutting_down.

Referenced by quit_handler().

{
   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 471 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(), LOG_WARNING, and prefs.

Referenced by __login_exec(), __oh323_new(), agent_call(), ast_codec_choose(), ast_iax2_new(), builtin_atxfer(), echo_exec(), iax2_request(), local_new(), mgcp_new(), sip_new(), skinny_new(), and socket_read().

{
   /* 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,
   };
   
   
   /* Find the first prefered codec in the format given */
   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;
}

struct ast_channel* ast_bridged_channel

(

struct ast_channel *

chan

)

[read]

Find bridged channel.

Parameters:

chan

Current channel

Definition at line 3295 of file channel.c.

References ast_channel::_bridge, ast_channel_tech::bridged_channel, and ast_channel::tech.

Referenced by __zt_exception(), agents_show(), ast_channel_masquerade(), attempt_transfer(), chanspy_exec(), check_bridge(), console_transfer(), get_refer_info(), handle_chanlist(), handle_hd_hf(), handle_request(), handle_request_bye(), handle_request_info(), handle_request_refer(), handle_showchan(), mgcp_hangup(), mgcp_ss(), mixmonitor_thread(), process_sdp(), schedule_delivery(), skinny_ss(), socket_read(), ss_thread(), start_spying(), startmon(), zt_handle_event(), and zt_hangup().

{
   struct ast_channel *bridged;
   bridged = chan->_bridge;
   if (bridged && bridged->tech->bridged_channel) 
      bridged = bridged->tech->bridged_channel(chan, bridged);
   return bridged;
}

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:

Returns -1 on failure, 0 on not enough time (does not automatically stop ringing), and the number of seconds the connect took otherwise.

Definition at line 2628 of file channel.c.

References ast_check_hangup(), AST_FLAG_ZOMBIE, ast_mutex_lock(), ast_mutex_unlock(), ast_test_flag, ast_channel_tech::call, ast_channel::lock, and ast_channel::tech.

Referenced by __ast_request_and_dial(), agent_call(), ast_feature_request_and_dial(), attempt_reconnect(), dial_exec_full(), features_call(), function_ilink(), ring_entry(), rpt(), rpt_exec(), and wait_for_answer().

{
   /* 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 (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) 
      if (chan->tech->call)
         res = chan->tech->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 265 of file channel.c.

References shutting_down.

Referenced by handle_abort_halt().

{
   shutting_down = 0;
}

const char* ast_cause2str

(

int

state

)

Gives the string form of a given cause code

Parameters:

state

cause to get the description of Give a name to a cause code Returns the text form of the binary cause code given

Definition at line 410 of file channel.c.

References causes, and ast_cause::desc.

Referenced by __transmit_response(), ast_do_masquerade(), ast_hangup(), dial_exec_full(), and transmit_request_with_auth().

{
   int x;

   for (x=0; x < sizeof(causes) / sizeof(causes[0]); x++) 
      if (causes[x].cause == cause)
         return causes[x].desc;

   return "Unknown";
}

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

Change channel name.

Definition at line 2886 of file channel.c.

References EVENT_FLAG_CALL, manager_event(), ast_channel::name, and ast_channel::uniqueid.

{
   char tmp[256];
   ast_copy_string(tmp, chan->name, sizeof(tmp));
   ast_copy_string(chan->name, newname, sizeof(chan->name));
   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

)

[read]

Create a channel structure.

Returns:

Returns NULL on failure to allocate.

Note:

New channels are by default set to the "default" context and extension "s"

Definition at line 519 of file channel.c.

References ast_channel::_state, ast_channel::accountcode, ast_channel::alertpipe, ast_channel::amaflags, ast_channel::appl, ast_default_accountcode, ast_default_amaflags, AST_LIST_HEAD_INIT_NOLOCK, ast_log(), AST_MAX_FDS, ast_mutex_init(), ast_mutex_lock(), ast_mutex_unlock(), AST_STATE_DOWN, channels, ast_channel::context, ast_channel::data, defaultlanguage, ast_channel::exten, ast_channel::fds, ast_channel::fin, ast_channel::flags, ast_channel::fout, free, global_fin, global_fout, ast_channel::language, ast_channel::lock, LOG_WARNING, malloc, ast_channel::name, ast_channel::next, null_tech, ast_channel::priority, ast_channel::sched, sched_context_create(), shutting_down, ast_channel::streamid, ast_channel::tech, ast_channel::timingfd, ast_channel::uniqueid, uniqueint, and ast_channel::varshead.

Referenced by __oh323_new(), agent_new(), alsa_new(), ast_async_goto(), ast_iax2_new(), ast_masq_park_call(), ast_modem_new(), ast_pbx_outgoing_cdr_failed(), ast_pbx_outgoing_exten(), builtin_atxfer(), check_goto_on_transfer(), features_new(), iax_park(), local_new(), mgcp_new(), misdn_new(), nbs_new(), oss_new(), phone_new(), sendmail(), sendpage(), sip_new(), sip_park(), skinny_new(), vpb_new(), and zt_new().

{
   struct ast_channel *tmp;
   int x;
   int flags;
   struct varshead *headp;        
           

   /* If shutting down, don't allocate any new channels */
   if (shutting_down) {
      ast_log(LOG_WARNING, "Channel allocation failed: Refusing due to active shutdown\n");
      return NULL;
   }

   tmp = malloc(sizeof(struct ast_channel));
   if (!tmp) {
      ast_log(LOG_WARNING, "Channel allocation failed: Out of memory\n");
      return NULL;
   }

   memset(tmp, 0, sizeof(struct ast_channel));
   tmp->sched = sched_context_create();
   if (!tmp->sched) {
      ast_log(LOG_WARNING, "Channel allocation failed: Unable to create schedule context\n");
      free(tmp);
      return NULL;
   }
   
   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) {
      if (pipe(tmp->alertpipe)) {
         ast_log(LOG_WARNING, "Channel allocation failed: Can't create alert pipe!\n");
         free(tmp);
         return NULL;
      } else {
         flags = fcntl(tmp->alertpipe[0], F_GETFL);
         fcntl(tmp->alertpipe[0], F_SETFL, flags | O_NONBLOCK);
         flags = fcntl(tmp->alertpipe[1], F_GETFL);
         fcntl(tmp->alertpipe[1], F_SETFL, flags | O_NONBLOCK);
      }
   } else 
      /* Make sure we've got it done right if they don't */
      tmp->alertpipe[0] = tmp->alertpipe[1] = -1;

   /* Always watch the alertpipe */
   tmp->fds[AST_MAX_FDS-1] = tmp->alertpipe[0];
   /* And timing pipe */
   tmp->fds[AST_MAX_FDS-2] = tmp->timingfd;
   strcpy(tmp->name, "**Unknown**");
   /* Initial state */
   tmp->_state = AST_STATE_DOWN;
   tmp->streamid = -1;
   tmp->appl = NULL;
   tmp->data = NULL;
   tmp->fin = global_fin;
   tmp->fout = global_fout;
   ast_mutex_lock(&uniquelock);
   snprintf(tmp->uniqueid, sizeof(tmp->uniqueid), "%li.%d", (long) time(NULL), uniqueint++);
   ast_mutex_unlock(&uniquelock);
   headp = &tmp->varshead;
   ast_mutex_init(&tmp->lock);
   AST_LIST_HEAD_INIT_NOLOCK(headp);
   strcpy(tmp->context, "default");
   ast_copy_string(tmp->language, defaultlanguage, sizeof(tmp->language));
   strcpy(tmp->exten, "s");
   tmp->priority = 1;
   tmp->amaflags = ast_default_amaflags;
   ast_copy_string(tmp->accountcode, ast_default_accountcode, sizeof(tmp->accountcode));

   tmp->tech = &null_tech;

   ast_mutex_lock(&chlock);
   tmp->next = channels;
   channels = tmp;

   ast_mutex_unlock(&chlock);
   return tmp;
}

enum ast_bridge_result 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
	config	config 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 3459 of file channel.c.

References ast_channel::_bridge, ast_channel::_softhangup, AST_BRIDGE_COMPLETE, AST_BRIDGE_FAILED, AST_BRIDGE_FAILED_NOWARN, AST_BRIDGE_RETRY, ast_channel_make_compatible(), ast_check_hangup(), ast_check_hangup_locked(), ast_clear_flag, AST_FEATURE_PLAY_WARNING, AST_FEATURE_REDIRECT, AST_FLAG_NBRIDGE, AST_FLAG_ZOMBIE, ast_generic_bridge(), ast_log(), ast_set_flag, AST_SOFTHANGUP_UNBRIDGE, ast_strlen_zero(), ast_test_flag, ast_tvadd(), ast_tvsub(), ast_verbose(), ast_channel_tech::bridge, bridge_playfile(), ast_channel::cid, ast_callerid::cid_num, ast_bridge_config::end_sound, EVENT_FLAG_CALL, ast_bridge_config::feature_timer, ast_bridge_config::features_callee, ast_bridge_config::features_caller, ast_bridge_config::firstpass, ast_bridge_config::flags, ast_channel::generator, LOG_DEBUG, LOG_WARNING, manager_event(), ast_channel::monitor, ast_channel::name, ast_channel::nativeformats, option_verbose, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), ast_bridge_config::play_warning, ast_channel::readformat, ast_channel::spies, ast_bridge_config::start_sound, ast_bridge_config::start_time, ast_channel::tech, ast_bridge_config::timelimit, ast_channel::uniqueid, VERBOSE_PREFIX_3, ast_bridge_config::warning_freq, ast_bridge_config::warning_sound, and ast_channel::writeformat.

Referenced by ast_bridge_call().

{
   struct ast_channel *who = NULL;
   enum ast_bridge_result res = AST_BRIDGE_COMPLETE;
   int nativefailed=0;
   int firstpass;
   int o0nativeformats;
   int o1nativeformats;
   long time_left_ms=0;
   struct timeval nexteventts = { 0, };
   char caller_warning = 0;
   char callee_warning = 0;

   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;
   }
   
   /* Stop if we're a zombie or need a soft hangup */
   if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) ||
       ast_test_flag(c1, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c1)) 
      return -1;

   *fo = NULL;
   firstpass = config->firstpass;
   config->firstpass = 0;

   if (ast_tvzero(config->start_time))
      config->start_time = ast_tvnow();
   time_left_ms = config->timelimit;

   caller_warning = ast_test_flag(&config->features_caller, AST_FEATURE_PLAY_WARNING);
   callee_warning = ast_test_flag(&config->features_callee, AST_FEATURE_PLAY_WARNING);

   if (config->start_sound && firstpass) {
      if (caller_warning)
         bridge_playfile(c0, c1, config->start_sound, time_left_ms / 1000);
      if (callee_warning)
         bridge_playfile(c1, c0, config->start_sound, time_left_ms / 1000);
   }

   /* Keep track of bridge */
   c0->_bridge = c1;
   c1->_bridge = c0;
   
   manager_event(EVENT_FLAG_CALL, "Link", 
            "Channel1: %s\r\n"
            "Channel2: %s\r\n"
            "Uniqueid1: %s\r\n"
            "Uniqueid2: %s\r\n"
            "CallerID1: %s\r\n"
            "CallerID2: %s\r\n",
            c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
                                                                        
   o0nativeformats = c0->nativeformats;
   o1nativeformats = c1->nativeformats;

   if (config->feature_timer) {
      nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->feature_timer, 1000));
   } else if (config->timelimit) {
      nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000));
      if (caller_warning || callee_warning)
         nexteventts = ast_tvsub(nexteventts, ast_samp2tv(config->play_warning, 1000));
   }

   for (/* ever */;;) {
      struct timeval now = { 0, };
      int to;

      to = -1;

      if (!ast_tvzero(nexteventts)) {
         now = ast_tvnow();
         to = ast_tvdiff_ms(nexteventts, now);
         if (to <= 0 && !config->timelimit) {   
            res = AST_BRIDGE_COMPLETE;
            break;
         }  
            
      }

      if (config->timelimit) {
         time_left_ms = config->timelimit - ast_tvdiff_ms(now, config->start_time);
         if (time_left_ms < to)
            to = time_left_ms;

         if (time_left_ms <= 0) {
            if (caller_warning && config->end_sound)
               bridge_playfile(c0, c1, config->end_sound, 0);
            if (callee_warning && config->end_sound)
               bridge_playfile(c1, c0, config->end_sound, 0);
            *fo = NULL;
            if (who) 
               *rc = who;
            res = 0;
            break;
         }
         
         if (to <= 0) {
            if (time_left_ms >= 5000) {
               /* force the time left to round up if appropriate */
               if (caller_warning && config->warning_sound && config->play_warning)
                  bridge_playfile(c0, c1, config->warning_sound,
                        (time_left_ms + 500) / 1000);
               if (callee_warning && config->warning_sound && config->play_warning)
                  bridge_playfile(c1, c0, config->warning_sound,
                        (time_left_ms + 500) / 1000);
            }
            if (config->warning_freq) {
               nexteventts = ast_tvadd(nexteventts, ast_samp2tv(config->warning_freq, 1000));
            }
               
            if ( (!config->warning_freq) ||  ( config->timelimit - ast_tvdiff_ms(nexteventts, config->start_time) < 0)) {
               nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000));
            }
         }
      }

      if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE) {
         if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
            c0->_softhangup = 0;
         if (c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
            c1->_softhangup = 0;
         c0->_bridge = c1;
         c1->_bridge = c0;
         ast_log(LOG_DEBUG, "Unbridge signal received. Ending native bridge.\n");
         continue;
      }
      
      /* Stop if we're a zombie or need a soft hangup */
      if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) ||
          ast_test_flag(c1, AST_FLAG_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,
            ast_test_flag(c0, AST_FLAG_ZOMBIE) ? "Yes" : "No",
            ast_check_hangup(c0) ? "Yes" : "No",
            ast_test_flag(c1, AST_FLAG_ZOMBIE) ? "Yes" : "No",
            ast_check_hangup(c1) ? "Yes" : "No");
         break;
      }

      /* See if the BRIDGEPEER variable needs to be updated */
      if (!ast_strlen_zero(pbx_builtin_getvar_helper(c0, "BRIDGEPEER")))
         pbx_builtin_setvar_helper(c0, "BRIDGEPEER", c1->name);
      if (!ast_strlen_zero(pbx_builtin_getvar_helper(c1, "BRIDGEPEER")))
         pbx_builtin_setvar_helper(c1, "BRIDGEPEER", c0->name);

      if (c0->tech->bridge &&
          (config->timelimit == 0) &&
          (c0->tech->bridge == c1->tech->bridge) &&
          !nativefailed && !c0->monitor && !c1->monitor &&
          !c0->spies && !c1->spies && !ast_test_flag(&(config->features_callee),AST_FEATURE_REDIRECT) &&
          !ast_test_flag(&(config->features_caller),AST_FEATURE_REDIRECT) ) {
         /* Looks like they share a bridge method and nothing else is in the way */
         if (option_verbose > 2) 
            ast_verbose(VERBOSE_PREFIX_3 "Attempting native bridge of %s and %s\n", c0->name, c1->name);
         ast_set_flag(c0, AST_FLAG_NBRIDGE);
         ast_set_flag(c1, AST_FLAG_NBRIDGE);
         if ((res = c0->tech->bridge(c0, c1, config->flags, fo, rc, to)) == AST_BRIDGE_COMPLETE) {
            manager_event(EVENT_FLAG_CALL, "Unlink", 
                     "Channel1: %s\r\n"
                     "Channel2: %s\r\n"
                     "Uniqueid1: %s\r\n"
                     "Uniqueid2: %s\r\n"
                     "CallerID1: %s\r\n"
                     "CallerID2: %s\r\n",
                     c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
            ast_log(LOG_DEBUG, "Returning from native bridge, channels: %s, %s\n", c0->name, c1->name);

            ast_clear_flag(c0, AST_FLAG_NBRIDGE);
            ast_clear_flag(c1, AST_FLAG_NBRIDGE);

            if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
               continue;

            c0->_bridge = NULL;
            c1->_bridge = NULL;

            return res;
         } else {
            ast_clear_flag(c0, AST_FLAG_NBRIDGE);
            ast_clear_flag(c1, AST_FLAG_NBRIDGE);
         }
         switch (res) {
         case AST_BRIDGE_RETRY:
            continue;
         default:
            ast_log(LOG_WARNING, "Private bridge between %s and %s failed\n", c0->name, c1->name);
            /* fallthrough */
         case AST_BRIDGE_FAILED_NOWARN:
            nativefailed++;
            break;
         }
      }
   
      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"
                     "CallerID1: %s\r\n"
                     "CallerID2: %s\r\n",
                     c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
            return AST_BRIDGE_FAILED;
         }
         o0nativeformats = c0->nativeformats;
         o1nativeformats = c1->nativeformats;
      }
      res = ast_generic_bridge(c0, c1, config, fo, rc, nexteventts);
      if (res != AST_BRIDGE_RETRY && fo)
         break;
   }

   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"
            "CallerID1: %s\r\n"
            "CallerID2: %s\r\n",
            c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
   ast_log(LOG_DEBUG, "Bridge stops bridging channels %s and %s\n", c0->name, c1->name);

   return res;
}

int ast_channel_cmpwhentohangup	(	struct ast_channel *	chan,
		time_t	offset
	)

Compare a offset with the settings of when to hang a channel up.

Parameters:

	chan	channel on which to check for hang up
	offset	offset in seconds from current time

Returns:

1, 0, or -1 This function compares a offset from current time with the absolute time out on a channel (when to hang up). If the absolute time out on a channel is earlier than current time plus the offset, it returns 1, if the two time values are equal, it return 0, otherwise, it retturn -1.

Definition at line 292 of file channel.c.

References ast_channel::whentohangup.

Referenced by ast_osp_lookup().

{
   time_t whentohangup;

   if (chan->whentohangup == 0) {
      if (offset == 0)
         return (0);
      else
         return (-1);
   } else { 
      if (offset == 0)
         return (1);
      else {
         whentohangup = offset + time (NULL);
         if (chan->whentohangup < whentohangup)
            return (1);
         else if (chan->whentohangup == whentohangup)
            return (0);
         else
            return (-1);
      }
   }
}

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 693 of file channel.c.

References AST_FLAG_DEFER_DTMF, ast_set_flag, and ast_test_flag.

Referenced by __adsi_transmit_messages(), and find_cache().

{
   int pre = 0;

   if (chan) {
      pre = ast_test_flag(chan, AST_FLAG_DEFER_DTMF);
      ast_set_flag(chan, AST_FLAG_DEFER_DTMF);
   }
   return pre;
}

void ast_channel_free

(

struct ast_channel *

chan

)

Free a channel structure.

Definition at line 886 of file channel.c.

References ast_channel::alertpipe, ast_app_group_discard(), AST_CHANNEL_NAME, ast_device_state_changed_literal(), ast_frfree(), AST_LIST_REMOVE_HEAD, ast_log(), ast_moh_cleanup(), ast_mutex_destroy(), ast_mutex_lock(), ast_mutex_unlock(), ast_translator_free_path(), ast_var_delete(), channels, ast_channel::cid, free, free_cid(), last, ast_channel::lock, LOG_ERROR, LOG_WARNING, ast_channel::monitor, ast_channel::music_state, ast_channel::name, name, ast_frame::next, ast_channel::next, ast_channel::pbx, ast_channel::readq, ast_channel::readtrans, ast_channel::sched, sched_context_destroy(), ast_channel_monitor::stop, ast_channel::tech_pvt, ast_channel::timingfd, ast_channel::varshead, and ast_channel::writetrans.

Referenced by agent_cleanup(), agent_new(), ast_do_masquerade(), ast_hangup(), ast_pbx_outgoing_cdr_failed(), local_new(), sendmail(), and sendpage().

{
   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_mutex_unlock(&chlock);
      ast_log(LOG_ERROR, "Unable to find channel in list to free. Assuming it has already been done.\n");
      return;
   }

   /* 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->tech_pvt) {
      ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name);
      free(chan->tech_pvt);
   }

   if (chan->sched)
      sched_context_destroy(chan->sched);

   ast_copy_string(name, chan->name, sizeof(name));

   /* Stop monitoring */
   if (chan->monitor) {
      chan->monitor->stop( chan, 0 );
   }

   /* If there is native format music-on-hold state, free it */
   if(chan->music_state)
      ast_moh_cleanup(chan);

   /* Free translatosr */
   if (chan->readtrans)
      ast_translator_free_path(chan->readtrans);
   if (chan->writetrans)
      ast_translator_free_path(chan->writetrans);
   if (chan->pbx) 
      ast_log(LOG_WARNING, "PBX may not have been terminated properly on '%s'\n", chan->name);
   free_cid(&chan->cid);
   ast_mutex_destroy(&chan->lock);
   /* Close pipes if appropriate */
   if ((fd = chan->alertpipe[0]) > -1)
      close(fd);
   if ((fd = chan->alertpipe[1]) > -1)
      close(fd);
   if ((fd = chan->timingfd) > -1)
      close(fd);
   f = chan->readq;
   chan->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 ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
      ast_var_delete(vardata);

   /* Drop out of the group counting radar */
   ast_app_group_discard(chan);

   free(chan);
   ast_mutex_unlock(&chlock);

   ast_device_state_changed_literal(name);
}

void ast_channel_inherit_variables	(	const struct ast_channel *	parent,
		struct ast_channel *	child
	)

Inherits channel variable from parent to child channel.

Parameters:

	parent	Parent channel
	child	Child channel

Scans all channel variables in the parent channel, looking for those that should be copied into the child channel. Variables whose names begin with a single '_' are copied into the child channel with the prefix removed. Variables whose names begin with '__' are copied into the child channel with their names unchanged.

Definition at line 2894 of file channel.c.

References AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log(), ast_var_assign(), ast_var_full_name(), ast_var_name(), ast_var_value(), LOG_DEBUG, option_debug, and ast_channel::varshead.

Referenced by __ast_request_and_dial(), agent_call(), ast_feature_request_and_dial(), dial_exec_full(), ring_entry(), and wait_for_answer().

{
   struct ast_var_t *current, *newvar;
   char *varname;

   AST_LIST_TRAVERSE(&parent->varshead, current, entries) {
      int vartype = 0;

      varname = ast_var_full_name(current);
      if (!varname)
         continue;

      if (varname[0] == '_') {
         vartype = 1;
         if (varname[1] == '_')
            vartype = 2;
      }

      switch (vartype) {
      case 1:
         newvar = ast_var_assign(&varname[1], ast_var_value(current));
         if (newvar) {
            AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
            if (option_debug)
               ast_log(LOG_DEBUG, "Copying soft-transferable variable %s.\n", ast_var_name(newvar));
         }
         break;
      case 2:
         newvar = ast_var_assign(ast_var_full_name(current), ast_var_value(current));
         if (newvar) {
            AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
            if (option_debug)
               ast_log(LOG_DEBUG, "Copying hard-transferable variable %s.\n", ast_var_name(newvar));
         }
         break;
      default:
         if (option_debug)
            ast_log(LOG_DEBUG, "Not copying variable %s.\n", ast_var_name(current));
         break;
      }
   }
}

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 2767 of file channel.c.

References AST_FORMAT_SLINEAR, ast_log(), ast_set_read_format(), ast_set_write_format(), ast_translator_best_choice(), LOG_WARNING, ast_channel::name, ast_channel::nativeformats, option_transcode_slin, ast_channel::readformat, and ast_channel::writeformat.

Referenced by ast_channel_bridge(), builtin_atxfer(), dial_exec_full(), park_exec(), try_calling(), and wait_for_answer().

{
   int src;
   int dst;

   if (chan->readformat == peer->writeformat && chan->writeformat == peer->readformat) {
      /* Already compatible!  Moving on ... */
      return 0;
   }

   /* Set up translation from the chan to the peer */
   src = chan->nativeformats;
   dst = peer->nativeformats;
   if (ast_translator_best_choice(&dst, &src) < 0) {
      ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", chan->name, src, peer->name, dst);
      return -1;
   }

   /* if the best path is not 'pass through', then
      transcoding is needed; if desired, force transcode path
      to use SLINEAR between channels */
   if ((src != dst) && option_transcode_slin)
      dst = AST_FORMAT_SLINEAR;
   if (ast_set_read_format(chan, dst) < 0) {
      ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", chan->name, dst);
      return -1;
   }
   if (ast_set_write_format(peer, dst) < 0) {
      ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", peer->name, dst);
      return -1;
   }

   /* Set up translation from the peer to the chan */
   src = peer->nativeformats;
   dst = chan->nativeformats;
   if (ast_translator_best_choice(&dst, &src) < 0) {
      ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", peer->name, src, chan->name, dst);
      return -1;
   }
   /* if the best path is not 'pass through', then
      transcoding is needed; if desired, force transcode path
      to use SLINEAR between channels */
   if ((src != dst) && option_transcode_slin)
      dst = AST_FORMAT_SLINEAR;
   if (ast_set_read_format(peer, dst) < 0) {
      ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", peer->name, dst);
      return -1;
   }
   if (ast_set_write_format(chan, dst) < 0) {
      ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", chan->name, dst);
      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 2822 of file channel.c.

References ast_channel::_bridge, ast_bridged_channel(), 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(), ast_masq_park_call(), ast_pickup_call(), attempt_transfer(), builtin_atxfer(), check_availability(), check_bridge(), check_goto_on_transfer(), iax_park(), misdn_transfer_bc(), pickup_exec(), and sip_park().

{
   struct ast_frame null = { AST_FRAME_NULL, };
   int res = -1;
   struct ast_channel *final_orig = original, *final_clone = clone;

   ast_mutex_lock(&original->lock);
   while(ast_mutex_trylock(&clone->lock)) {
      ast_mutex_unlock(&original->lock);
      usleep(1);
      ast_mutex_lock(&original->lock);
   }

   /* each of these channels may be sitting behind a channel proxy (i.e. chan_agent)
      and if so, we don't really want to masquerade it, but its proxy */
   if (original->_bridge && (original->_bridge != ast_bridged_channel(original)) && (original->_bridge->_bridge != original))
      final_orig = original->_bridge;

   if (clone->_bridge && (clone->_bridge != ast_bridged_channel(clone)) && (clone->_bridge->_bridge != clone))
      final_clone = clone->_bridge;

   if ((final_orig != original) || (final_clone != clone)) {
      ast_mutex_lock(&final_orig->lock);
      while(ast_mutex_trylock(&final_clone->lock)) {
         ast_mutex_unlock(&final_orig->lock);
         usleep(1);
         ast_mutex_lock(&final_orig->lock);
      }
      ast_mutex_unlock(&clone->lock);
      ast_mutex_unlock(&original->lock);
      original = final_orig;
      clone = final_clone;
   }

   if (original == clone) {
      ast_log(LOG_WARNING, "Can't masquerade channel '%s' into itself!\n", original->name);
      ast_mutex_unlock(&clone->lock);
      ast_mutex_unlock(&original->lock);
      return -1;
   }

   ast_log(LOG_DEBUG, "Planning to masquerade channel %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 channel %s into the structure of %s\n", clone->name, original->name);
      res = 0;
   }

   ast_mutex_unlock(&clone->lock);
   ast_mutex_unlock(&original->lock);

   return res;
}

int ast_channel_register

(

const struct ast_channel_tech *

tech

)

Register a channel technology (a new channel driver) Called by a channel module to register the kind of channels it supports.

Parameters:

tech

Structure defining channel technology or "type"

Returns:

Returns 0 on success, -1 on failure.

Definition at line 317 of file channel.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_verbose(), backends, ast_channel_tech::description, LOG_DEBUG, LOG_WARNING, malloc, chanlist::next, option_debug, option_verbose, chanlist::tech, ast_channel_tech::type, and VERBOSE_PREFIX_2.

Referenced by load_module(), and unload_module().

{
   struct chanlist *chan;

   ast_mutex_lock(&chlock);

   chan = backends;
   while (chan) {
      if (!strcasecmp(tech->type, chan->tech->type)) {
         ast_log(LOG_WARNING, "Already have a handler for type '%s'\n", tech->type);
         ast_mutex_unlock(&chlock);
         return -1;
      }
      chan = chan->next;
   }

   chan = malloc(sizeof(*chan));
   if (!chan) {
      ast_log(LOG_WARNING, "Out of memory\n");
      ast_mutex_unlock(&chlock);
      return -1;
   }
   chan->tech = tech;
   chan->next = backends;
   backends = chan;

   if (option_debug)
      ast_log(LOG_DEBUG, "Registered handler for '%s' (%s)\n", chan->tech->type, chan->tech->description);

   if (option_verbose > 1)
      ast_verbose(VERBOSE_PREFIX_2 "Registered channel type '%s' (%s)\n", chan->tech->type,
             chan->tech->description);

   ast_mutex_unlock(&chlock);
   return 0;
}

int ast_channel_sendhtml	(	struct ast_channel *	channel,
		int	subclass,
		const 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 2753 of file channel.c.

References ast_channel_tech::send_html, and ast_channel::tech.

Referenced by agent_sendhtml(), and wait_for_answer().

{
   if (chan->tech->send_html)
      return chan->tech->send_html(chan, subclass, data, datalen);
   return -1;
}

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

Sends a URL on a given link

Send URL on link. Returns 0 on success or -1 on failure

Definition at line 2760 of file channel.c.

References AST_HTML_URL, ast_channel_tech::send_html, and ast_channel::tech.

Referenced by dial_exec_full(), sendurl_exec(), and try_calling().

{
   if (chan->tech->send_html)
      return chan->tech->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 3705 of file channel.c.

References ast_log(), LOG_ERROR, ast_channel_tech::setoption, and ast_channel::tech.

Referenced by ast_bridge_call(), chanspy_exec(), conf_run(), handle_tddmode(), play_record_review(), reset_volumes(), rpt(), set_listen_volume(), set_talk_volume(), set_volume(), try_calling(), vm_forwardoptions(), and zt_hangup().

{
   int res;

   if (chan->tech->setoption) {
      res = chan->tech->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 277 of file channel.c.

References AST_FRAME_NULL, ast_queue_frame(), and ast_channel::whentohangup.

Referenced by action_timeout(), ast_osp_lookup(), builtin_function_timeout_write(), handle_request_invite(), and pbx_builtin_atimeout().

{
   time_t   myt;
   struct ast_frame fr = { AST_FRAME_NULL, };

   time(&myt);
   if (offset)
      chan->whentohangup = myt + offset;
   else
      chan->whentohangup = 0;
   ast_queue_frame(chan, &fr);
   return;
}

int ast_channel_spy_add	(	struct ast_channel *	chan,
		struct ast_channel_spy *	spy
	)

Adds a spy to a channel, to begin receiving copies of the channel's audio frames.

Parameters:

	chan	The channel to add the spy to.
	spy	A pointer to ast_channel_spy structure describing how the spy is to be used.

Returns:

0 for success, non-zero for failure

Note: This function performs no locking; you must hold the channel's lock before calling this function.

Definition at line 978 of file channel.c.

References ast_clear_flag, ast_cond_init(), AST_FORMAT_SLINEAR, ast_getformatname(), AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_HEAD, AST_LIST_INSERT_TAIL, ast_log(), ast_set_flag, ast_test_flag, calloc, ast_channel_spy::chan, CHANSPY_FORMAT_AUDIO, CHANSPY_MIXAUDIO, CHANSPY_READ_VOLADJUST, CHANSPY_TRIGGER_MODE, CHANSPY_TRIGGER_NONE, CHANSPY_TRIGGER_READ, CHANSPY_TRIGGER_WRITE, CHANSPY_WRITE_VOLADJUST, ast_channel_spy_queue::format, LOG_DEBUG, LOG_WARNING, ast_channel::name, ast_channel_spy::read_queue, ast_channel::spies, ast_channel_spy::trigger, ast_channel_spy::type, and ast_channel_spy::write_queue.

Referenced by start_spying(), and startmon().

{
   /* Link the owner channel to the spy */
   spy->chan = chan;

   if (!ast_test_flag(spy, CHANSPY_FORMAT_AUDIO)) {
      ast_log(LOG_WARNING, "Could not add channel spy '%s' to channel '%s', only audio format spies are supported.\n",
         spy->type, chan->name);
      return -1;
   }

   if (ast_test_flag(spy, CHANSPY_READ_VOLADJUST) && (spy->read_queue.format != AST_FORMAT_SLINEAR)) {
      ast_log(LOG_WARNING, "Cannot provide volume adjustment on '%s' format spies\n",
         ast_getformatname(spy->read_queue.format));
      return -1;
   }

   if (ast_test_flag(spy, CHANSPY_WRITE_VOLADJUST) && (spy->write_queue.format != AST_FORMAT_SLINEAR)) {
      ast_log(LOG_WARNING, "Cannot provide volume adjustment on '%s' format spies\n",
         ast_getformatname(spy->write_queue.format));
      return -1;
   }

   if (ast_test_flag(spy, CHANSPY_MIXAUDIO) &&
       ((spy->read_queue.format != AST_FORMAT_SLINEAR) ||
        (spy->write_queue.format != AST_FORMAT_SLINEAR))) {
      ast_log(LOG_WARNING, "Cannot provide audio mixing on '%s'-'%s' format spies\n",
         ast_getformatname(spy->read_queue.format), ast_getformatname(spy->write_queue.format));
      return -1;
   }

   if (!chan->spies) {
      if (!(chan->spies = calloc(1, sizeof(*chan->spies)))) {
         ast_log(LOG_WARNING, "Memory allocation failure\n");
         return -1;
      }

      AST_LIST_HEAD_INIT_NOLOCK(&chan->spies->list);
      AST_LIST_INSERT_HEAD(&chan->spies->list, spy, list);
   } else {
      AST_LIST_INSERT_TAIL(&chan->spies->list, spy, list);
   }

   if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE) {
      ast_cond_init(&spy->trigger, NULL);
      ast_set_flag(spy, CHANSPY_TRIGGER_READ);
      ast_clear_flag(spy, CHANSPY_TRIGGER_WRITE);
   }

   ast_log(LOG_DEBUG, "Spy %s added to channel %s\n",
      spy->type, chan->name);

   return 0;
}

void ast_channel_spy_free

(

struct ast_channel_spy *

spy

)

Free a spy.

Parameters:

spy

The spy to free

Returns:

nothing

Note: This function MUST NOT be called with the spy locked.

Definition at line 1106 of file channel.c.

References ast_cond_destroy(), ast_frfree(), ast_mutex_destroy(), ast_test_flag, CHANSPY_DONE, CHANSPY_TRIGGER_MODE, CHANSPY_TRIGGER_NONE, ast_channel_spy_queue::head, ast_channel_spy::lock, ast_frame::next, ast_channel_spy::read_queue, ast_channel_spy::status, ast_channel_spy::trigger, and ast_channel_spy::write_queue.

Referenced by channel_spy(), and mixmonitor_thread().

{
   struct ast_frame *f = NULL;

   if (spy->status == CHANSPY_DONE)
      return;

   /* Switch status to done in case we get called twice */
   spy->status = CHANSPY_DONE;

   /* Drop any frames in the queue */
   for (f = spy->write_queue.head; f; f = spy->write_queue.head) {
      spy->write_queue.head = f->next;
      ast_frfree(f);
   }
   for (f = spy->read_queue.head; f; f= spy->read_queue.head) {
      spy->read_queue.head = f->next;
      ast_frfree(f);
   }

   /* Destroy the condition if in use */
   if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE)
      ast_cond_destroy(&spy->trigger);

   /* Destroy our mutex since it is no longer in use */
   ast_mutex_destroy(&spy->lock);

   return;
}

struct ast_frame* ast_channel_spy_read_frame	(	struct ast_channel_spy *	spy,
		unsigned int	samples
	)			[read]

Read one (or more) frames of audio from a channel being spied upon.

Parameters:

	spy	The spy to operate on
	samples	The number of audio samples to read

Returns:

NULL for failure, one ast_frame pointer, or a chain of ast_frame pointers

This function can return multiple frames if the spy structure needs to be 'flushed' due to mismatched queue lengths, or if the spy structure is configured to return unmixed audio (in which case each call to this function will return a frame of audio from each side of channel).

Note: This function performs no locking; you must hold the spy's lock before calling this function. You must not hold the channel's lock at the same time.

Definition at line 4014 of file channel.c.

References ast_clear_flag, ast_codec_get_len(), ast_frame_adjust_volume(), ast_frame_slinear_sum(), AST_FRAME_VOICE, ast_frdup(), ast_frfree(), ast_test_flag, CHANSPY_MIXAUDIO, CHANSPY_READ_VOLADJUST, CHANSPY_TRIGGER_FLUSH, CHANSPY_WRITE_VOLADJUST, copy_data_from_queue(), ast_channel_spy_queue::format, ast_frame::frametype, ast_channel_spy_queue::head, ast_frame::next, ast_channel_spy::read_queue, ast_channel_spy::read_vol_adjustment, result, ast_frame::samples, ast_channel_spy_queue::samples, ast_channel_spy::write_queue, and ast_channel_spy::write_vol_adjustment.

Referenced by mixmonitor_thread(), and spy_generate().

{
   struct ast_frame *result;
   /* buffers are allocated to hold SLINEAR, which is the largest format */
        short read_buf[samples];
        short write_buf[samples];
   struct ast_frame *read_frame;
   struct ast_frame *write_frame;
   int need_dup;
   struct ast_frame stack_read_frame = { .frametype = AST_FRAME_VOICE,
                     .subclass = spy->read_queue.format,
                     .data = read_buf,
                     .samples = samples,
                     .datalen = ast_codec_get_len(spy->read_queue.format, samples),
   };
   struct ast_frame stack_write_frame = { .frametype = AST_FRAME_VOICE,
                      .subclass = spy->write_queue.format,
                      .data = write_buf,
                      .samples = samples,
                      .datalen = ast_codec_get_len(spy->write_queue.format, samples),
   };

   /* if a flush has been requested, dump everything in whichever queue is larger */
   if (ast_test_flag(spy, CHANSPY_TRIGGER_FLUSH)) {
      if (spy->read_queue.samples > spy->write_queue.samples) {
         if (ast_test_flag(spy, CHANSPY_READ_VOLADJUST)) {
            for (result = spy->read_queue.head; result; result = result->next)
               ast_frame_adjust_volume(result, spy->read_vol_adjustment);
         }
         result = spy->read_queue.head;
         spy->read_queue.head = NULL;
         spy->read_queue.samples = 0;
         ast_clear_flag(spy, CHANSPY_TRIGGER_FLUSH);
         return result;
      } else {
         if (ast_test_flag(spy, CHANSPY_WRITE_VOLADJUST)) {
            for (result = spy->write_queue.head; result; result = result->next)
               ast_frame_adjust_volume(result, spy->write_vol_adjustment);
         }
         result = spy->write_queue.head;
         spy->write_queue.head = NULL;
         spy->write_queue.samples = 0;
         ast_clear_flag(spy, CHANSPY_TRIGGER_FLUSH);
         return result;
      }
   }

   if ((spy->read_queue.samples < samples) || (spy->write_queue.samples < samples))
      return NULL;

   /* short-circuit if both head frames have exactly what we want */
   if ((spy->read_queue.head->samples == samples) &&
       (spy->write_queue.head->samples == samples)) {
      read_frame = spy->read_queue.head;
      spy->read_queue.head = read_frame->next;
      read_frame->next = NULL;

      write_frame = spy->write_queue.head;
      spy->write_queue.head = write_frame->next;
      write_frame->next = NULL;

      spy->read_queue.samples -= samples;
      spy->write_queue.samples -= samples;

      need_dup = 0;
   } else {
      copy_data_from_queue(&spy->read_queue, read_buf, samples);
      copy_data_from_queue(&spy->write_queue, write_buf, samples);

      read_frame = &stack_read_frame;
      write_frame = &stack_write_frame;
      need_dup = 1;
   }
   
   if (ast_test_flag(spy, CHANSPY_READ_VOLADJUST))
      ast_frame_adjust_volume(read_frame, spy->read_vol_adjustment);

   if (ast_test_flag(spy, CHANSPY_WRITE_VOLADJUST))
      ast_frame_adjust_volume(write_frame, spy->write_vol_adjustment);

   if (ast_test_flag(spy, CHANSPY_MIXAUDIO)) {
      ast_frame_slinear_sum(read_frame, write_frame);

      if (need_dup)
         result = ast_frdup(read_frame);
      else {
         result = read_frame;
         ast_frfree(write_frame);
      }
   } else {
      if (need_dup) {
         result = ast_frdup(read_frame);
         result->next = ast_frdup(write_frame);
      } else {
         result = read_frame;
         result->next = write_frame;
      }
   }

   return result;
}

void ast_channel_spy_remove	(	struct ast_channel *	chan,
		struct ast_channel_spy *	spy
	)

Remove a spy from a channel.

Parameters:

	chan	The channel to remove the spy from
	spy	The spy to be removed

Returns:

nothing

Note: This function performs no locking; you must hold the channel's lock before calling this function.

Definition at line 1095 of file channel.c.

References AST_LIST_REMOVE, ast_channel::spies, spy_cleanup(), and spy_detach().

Referenced by channel_spy().

{
   if (!chan->spies)
      return;

   AST_LIST_REMOVE(&chan->spies->list, spy, list);

   spy_detach(spy, chan);
   spy_cleanup(chan);
}

void ast_channel_spy_stop_by_type	(	struct ast_channel *	chan,
		const char *	type
	)

Find all spies of a particular type on a channel and stop them.

Parameters:

	chan	The channel to operate on
	type	A character string identifying the type of spies to be stopped

Returns:

nothing

Note: This function performs no locking; you must hold the channel's lock before calling this function.

Definition at line 1066 of file channel.c.

References AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, CHANSPY_RUNNING, ast_channel::spies, spy_cleanup(), spy_detach(), ast_channel_spy::status, and ast_channel_spy::type.

Referenced by mixmonitor_cli().

{
   struct ast_channel_spy *spy = NULL;
   
   if (!chan->spies)
      return;

   AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->spies->list, spy, list) {
      if ((spy->type == type) && (spy->status == CHANSPY_RUNNING)) {
         AST_LIST_REMOVE_CURRENT(&chan->spies->list, list);
         spy_detach(spy, chan);
      }
   }
   AST_LIST_TRAVERSE_SAFE_END
   spy_cleanup(chan);
}

void ast_channel_spy_trigger_wait

(

struct ast_channel_spy *

spy

)

Efficiently wait until audio is available for a spy, or an exception occurs.

Parameters:

spy

The spy to wait on

Returns:

nothing

Note: The locking rules for this function are non-obvious... first, you must not hold the channel's lock when calling this function. Second, you must hold the spy's lock before making the function call; while the function runs the lock will be released, and when the trigger event occurs, the lock will be re-obtained. This means that when control returns to your code, you will again hold the spy's lock.

Definition at line 1083 of file channel.c.

References ast_cond_timedwait(), ast_tvadd(), ast_channel_spy::lock, and ast_channel_spy::trigger.

Referenced by mixmonitor_thread().

{
   struct timeval tv;
   struct timespec ts;

   tv = ast_tvadd(ast_tvnow(), ast_samp2tv(50000, 1000));
   ts.tv_sec = tv.tv_sec;
   ts.tv_nsec = tv.tv_usec * 1000;

   ast_cond_timedwait(&spy->trigger, &spy->lock, &ts);
}

struct ast_silence_generator* ast_channel_start_silence_generator

(

struct ast_channel *

chan

)

[read]

Starts a silence generator on the given channel.

Parameters:

chan

The channel to generate silence on

Returns:

An ast_silence_generator pointer, or NULL if an error occurs

This function will cause SLINEAR silence to be generated on the supplied channel until it is disabled; if the channel cannot be put into SLINEAR mode then the function will fail.

The pointer returned by this function must be preserved and passed to ast_channel_stop_silence_generator when you wish to stop the silence generation.

Definition at line 4172 of file channel.c.

References ast_activate_generator(), AST_FORMAT_SLINEAR, ast_log(), ast_set_write_format(), calloc, free, LOG_DEBUG, LOG_ERROR, LOG_WARNING, ast_channel::name, ast_silence_generator::old_write_format, option_debug, and ast_channel::writeformat.

Referenced by ast_play_and_record_full(), and record_exec().

{
   struct ast_silence_generator *state;

   if (!(state = calloc(1, sizeof(*state)))) {
      ast_log(LOG_WARNING, "Could not allocate state structure\n");
      return NULL;
   }

   state->old_write_format = chan->writeformat;

   if (ast_set_write_format(chan, AST_FORMAT_SLINEAR) < 0) {
      ast_log(LOG_ERROR, "Could not set write format to SLINEAR\n");
      free(state);
      return NULL;
   }

   ast_activate_generator(chan, &silence_generator, state);

   if (option_debug)
      ast_log(LOG_DEBUG, "Started silence generator on '%s'\n", chan->name);

   return state;
}

void ast_channel_stop_silence_generator	(	struct ast_channel *	chan,
		struct ast_silence_generator *	state
	)

Stops a previously-started silence generator on the given channel.

Parameters:

	chan	The channel to operate on
	state	The ast_silence_generator pointer return by a previous call to ast_channel_start_silence_generator.

Returns:

nothing

This function will stop the operating silence generator and return the channel to its previous write format.

Definition at line 4197 of file channel.c.

References ast_deactivate_generator(), ast_log(), ast_set_write_format(), free, LOG_DEBUG, LOG_ERROR, ast_channel::name, ast_silence_generator::old_write_format, and option_debug.

Referenced by ast_play_and_record_full(), and record_exec().

{
   if (!state)
      return;

   ast_deactivate_generator(chan);

   if (option_debug)
      ast_log(LOG_DEBUG, "Stopped silence generator on '%s'\n", chan->name);

   if (ast_set_write_format(chan, state->old_write_format) < 0)
      ast_log(LOG_ERROR, "Could not return write format to its original state\n");

   free(state);
}

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 2746 of file channel.c.

References ast_channel_tech::send_html, and ast_channel::tech.

Referenced by dial_exec_full(), sendurl_exec(), and try_calling().

{
   if (chan->tech->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 705 of file channel.c.

References ast_clear_flag, and AST_FLAG_DEFER_DTMF.

Referenced by __adsi_transmit_messages(), find_cache(), and rpt_call().

{
   if (chan)
      ast_clear_flag(chan, AST_FLAG_DEFER_DTMF);
}

void ast_channel_unregister

(

const struct ast_channel_tech *

tech

)

Unregister a channel technology.

Parameters:

tech

Structure defining channel technology or "type" that was previously registered

Returns:

No return value.

Definition at line 354 of file channel.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_verbose(), backends, free, last, LOG_DEBUG, chanlist::next, option_debug, option_verbose, chanlist::tech, ast_channel_tech::type, and VERBOSE_PREFIX_2.

Referenced by __unload_module(), and unload_module().

{
   struct chanlist *chan, *last=NULL;

   if (option_debug && tech && tech->type )
      ast_log(LOG_DEBUG, "Unregistering channel type '%s'\n", tech->type);
   else if (option_debug)
      ast_log(LOG_DEBUG, "Unregistering channel, tech is NULL!!!\n");
      

   ast_mutex_lock(&chlock);

   chan = backends;
   while (chan) {
      if (chan->tech == tech) {
         if (last)
            last->next = chan->next;
         else
            backends = backends->next;
         free(chan);
         ast_mutex_unlock(&chlock);

         if (option_verbose > 1)
            ast_verbose( VERBOSE_PREFIX_2 "Unregistered channel type '%s'\n", tech->type);

         return;
      }
      last = chan;
      chan = chan->next;
   }

   ast_mutex_unlock(&chlock);
}

struct ast_channel* ast_channel_walk_locked

(

const struct ast_channel *

prev

)

[read]

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 802 of file channel.c.

References channel_find_locked().

Referenced by action_status(), ast_pickup_call(), complete_ch_helper(), conf_exec(), handle_chanlist(), handle_debugchan(), handle_nodebugchan(), local_channel_walk(), moh_on_off(), and softhangup_exec().

{
   return channel_find_locked(prev, NULL, 0, NULL, NULL);
}

void ast_channels_init

(

void

)

Definition at line 3944 of file channel.c.

References ast_cli_register(), and cli_show_channeltypes.

Referenced by main().

{
   ast_cli_register(&cli_show_channeltypes);
}

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:

Returns 0 if not, or 1 if hang up is requested (including time-out).

Definition at line 203 of file channel.c.

References ast_channel::_softhangup, AST_SOFTHANGUP_TIMEOUT, ast_channel::tech_pvt, and ast_channel::whentohangup.

Referenced by action_redirect(), app_exec(), ast_answer(), ast_call(), ast_cdr_update(), ast_channel_bridge(), ast_check_hangup_locked(), ast_feature_request_and_dial(), ast_indicate(), ast_read(), ast_readstring(), ast_readstring_full(), ast_recvtext(), ast_rtp_bridge(), ast_sendtext(), ast_transfer(), ast_waitfordigit(), ast_waitfordigit_full(), ast_write(), builtin_atxfer(), channel_spy(), chanspy_exec(), conf_run(), handle_sendimage(), iax2_bridge(), pbx_exec(), rpt(), rpt_exec(), vpb_bridge(), wait_for_answer(), zt_sendtext(), and zt_setoption().

{
   time_t   myt;

   /* if soft hangup flag, return true */
   if (chan->_softhangup) 
      return 1;
   /* if no technology private data, return true */
   if (!chan->tech_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;
}

static int ast_check_hangup_locked

(

struct ast_channel *

chan

)

[static]

Definition at line 224 of file channel.c.

References ast_check_hangup(), ast_mutex_lock(), ast_mutex_unlock(), and ast_channel::lock.

Referenced by ast_channel_bridge().

{
   int res;
   ast_mutex_lock(&chan->lock);
   res = ast_check_hangup(chan);
   ast_mutex_unlock(&chan->lock);
   return res;
}

void ast_deactivate_generator

(

struct ast_channel *

chan

)

Deactive an active generator

Definition at line 1443 of file channel.c.

References ast_clear_flag, AST_FLAG_WRITE_INT, ast_mutex_lock(), ast_mutex_unlock(), ast_settimeout(), ast_channel::generator, ast_channel::generatordata, ast_channel::lock, and ast_generator::release.

Referenced by app_exec(), ast_channel_stop_silence_generator(), ast_openstream_full(), ast_playtones_stop(), ast_quiet_chan(), ast_read(), ast_tonepair_stop(), ast_write(), cb_events(), channel_spy(), dial_exec_full(), generator_force(), local_ast_moh_stop(), milliwatt_exec(), moh_on_off(), and wait_for_answer().

{
   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;
      ast_clear_flag(chan, AST_FLAG_WRITE_INT);
      ast_settimeout(chan, 0, NULL, NULL);
   }
   ast_mutex_unlock(&chan->lock);
}

int ast_do_masquerade

(

struct ast_channel *

chan

)

Start masquerading a channel 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.

Parameters:

chan

Channel to masquerade

Definition at line 2964 of file channel.c.

References ast_channel::_softhangup, ast_channel::_state, ast_channel::adsicpe, ast_channel::alertpipe, ast_app_group_update(), ast_cause2str(), ast_channel_free(), ast_copy_flags, AST_FLAG_BLOCKING, AST_FLAG_EXCEPTION, AST_FLAG_ZOMBIE, AST_FRAME_NULL, AST_LIST_TRAVERSE, ast_log(), AST_MAX_FDS, ast_mutex_lock(), ast_mutex_unlock(), ast_queue_frame(), ast_set_flag, ast_set_read_format(), ast_set_write_format(), AST_SOFTHANGUP_DEV, ast_test_flag, ast_channel::blocker, ast_channel_spy::chan, ast_channel::cid, clone_variables(), EVENT_FLAG_CALL, ast_channel::fdno, ast_channel::fds, ast_channel_tech::fixup, free_translation(), ast_channel_tech::hangup, ast_channel::hangupcause, ast_channel::language, ast_channel_spy::lock, ast_channel::lock, LOG_DEBUG, LOG_WARNING, manager_event(), ast_channel::masq, ast_channel::masqr, ast_channel::monitor, ast_channel::musicclass, ast_channel::name, ast_channel::nativeformats, ast_frame::next, option_debug, ast_frame::prev, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel::readformat, ast_channel::readq, ast_channel::spies, t, ast_channel::tech, ast_channel::tech_pvt, ast_channel::timingfd, ast_channel::type, ast_channel::uniqueid, and ast_channel::writeformat.

Referenced by ast_async_goto(), ast_hangup(), ast_read(), ast_waitfor_nandfds(), ast_write(), iax_park(), sip_park(), and sip_park_thread().

{
   int x,i;
   int res=0;
   int origstate;
   struct ast_frame *cur, *prev;
   const struct ast_channel_tech *t;
   void *t_pvt;
   struct ast_callerid tmpcid;
   struct ast_channel *clone = original->masq;
   struct ast_channel_spy_list *spy_list;
   struct ast_channel_spy *spy = NULL;
   int rformat = original->readformat;
   int wformat = original->writeformat;
   char newn[100];
   char orig[100];
   char masqn[100];
   char zombn[100];

   if (option_debug > 3)
      ast_log(LOG_DEBUG, "Actually Masquerading %s(%d) into the structure of %s(%d)\n",
         clone->name, clone->_state, original->name, original->_state);

   /* 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 for masquerade 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 */
   ast_copy_string(orig, original->name, sizeof(orig));
   /* Save the new name */
   ast_copy_string(newn, clone->name, sizeof(newn));
   /* Create the masq name */
   snprintf(masqn, sizeof(masqn), "%s<MASQ>", newn);
      
   /* Copy the name from the clone channel */
   ast_copy_string(original->name, newn, sizeof(original->name));

   /* Mangle the name of the clone channel */
   ast_copy_string(clone->name, masqn, sizeof(clone->name));
   
   /* 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 technlogies */ 
   t = original->tech;
   original->tech = clone->tech;
   clone->tech = t;

   t_pvt = original->tech_pvt;
   original->tech_pvt = clone->tech_pvt;
   clone->tech_pvt = t_pvt;

   /* Swap the readq's */
   cur = original->readq;
   original->readq = clone->readq;
   clone->readq = cur;

   /* Swap the alertpipes */
   for (i = 0; i < 2; i++) {
      x = original->alertpipe[i];
      original->alertpipe[i] = clone->alertpipe[i];
      clone->alertpipe[i] = x;
   }

   /* Swap the raw formats */
   x = original->rawreadformat;
   original->rawreadformat = clone->rawreadformat;
   clone->rawreadformat = x;
   x = original->rawwriteformat;
   original->rawwriteformat = clone->rawwriteformat;
   clone->rawwriteformat = x;

   /* Swap the spies */
   spy_list = original->spies;
   original->spies = clone->spies;
   clone->spies = spy_list;

   /* Update channel on respective spy lists if present */
   if (original->spies) {
      AST_LIST_TRAVERSE(&original->spies->list, spy, list) {
         ast_mutex_lock(&spy->lock);
         spy->chan = original;
         ast_mutex_unlock(&spy->lock);
      }
   }
   if (clone->spies) {
      AST_LIST_TRAVERSE(&clone->spies->list, spy, list) {
         ast_mutex_lock(&spy->lock);
         spy->chan = clone;
         ast_mutex_unlock(&spy->lock);
      }
   }

   /* Save any pending frames on both sides.  Start by counting
    * how many we're going to need... */
   prev = NULL;
   cur = clone->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->readq;
      original->readq = clone->readq;
      clone->readq = NULL;
      if (original->alertpipe[1] > -1) {
         for (i = 0; i < x; i++)
            write(original->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->tech->fixup){
      res = clone->tech->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->tech->hangup)
      res = clone->tech->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 */
   ast_copy_string(clone->name, zombn, sizeof(clone->name));
   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;
   t_pvt = original->monitor;
   original->monitor = clone->monitor;
   clone->monitor = t_pvt;
   
   /* Keep the same language.  */
   ast_copy_string(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];
   }
   /* Drop group from original */
   ast_app_group_update(clone, original);
   clone_variables(original, clone);
   /* 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 */
   ast_copy_flags(original, clone, AST_FLAG_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 */

   /* Just swap the whole structures, nevermind the allocations, they'll work themselves
      out. */
   tmpcid = original->cid;
   original->cid = clone->cid;
   clone->cid = tmpcid;
   
   /* 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 */
   ast_copy_string(original->musicclass, clone->musicclass, sizeof(original->musicclass));

   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->tech->fixup) {
      res = original->tech->fixup(clone, original);
      if (res) {
         ast_log(LOG_WARNING, "Channel for type '%s' could not fixup channel %s\n",
            original->type, original->name);
         ast_mutex_unlock(&clone->lock);
         return -1;
      }
   } else
      ast_log(LOG_WARNING, "Channel type '%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 (ast_test_flag(clone, AST_FLAG_ZOMBIE)) {
      ast_log(LOG_DEBUG, "Destroying channel clone '%s'\n", clone->name);
      ast_mutex_unlock(&clone->lock);
      manager_event(EVENT_FLAG_CALL, "Hangup", 
         "Channel: %s\r\n"
         "Uniqueid: %s\r\n"
         "Cause: %d\r\n"
         "Cause-txt: %s\r\n",
         clone->name, 
         clone->uniqueid, 
         clone->hangupcause,
         ast_cause2str(clone->hangupcause)
         );
      ast_channel_free(clone);
   } else {
      struct ast_frame null_frame = { AST_FRAME_NULL, };
      ast_log(LOG_DEBUG, "Released clone lock on '%s'\n", clone->name);
      ast_set_flag(clone, AST_FLAG_ZOMBIE);
      ast_queue_frame(clone, &null_frame);
      ast_mutex_unlock(&clone->lock);
   }
   
   /* Signal any blocker */
   if (ast_test_flag(original, AST_FLAG_BLOCKING))
      pthread_kill(original->blocker, SIGURG);
   ast_log(LOG_DEBUG, "Done Masquerading %s (%d)\n", original->name, original->_state);
   return 0;
}

static enum ast_bridge_result ast_generic_bridge	(	struct ast_channel *	c0,
		struct ast_channel *	c1,
		struct ast_bridge_config *	config,
		struct ast_frame **	fo,
		struct ast_channel **	rc,
		struct timeval	bridge_end
	)			[static]

Definition at line 3342 of file channel.c.

References ast_channel::_bridge, ast_channel::_softhangup, AST_BRIDGE_COMPLETE, AST_BRIDGE_DTMF_CHANNEL_0, AST_BRIDGE_DTMF_CHANNEL_1, AST_BRIDGE_IGNORE_SIGS, AST_BRIDGE_RETRY, AST_CONTROL_HOLD, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_HTML, AST_FRAME_IMAGE, AST_FRAME_TEXT, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree(), ast_indicate(), ast_log(), ast_read(), AST_SOFTHANGUP_UNBRIDGE, ast_waitfor_n(), ast_write(), ast_bridge_config::flags, ast_frame::frametype, last, LOG_DEBUG, ast_channel::name, ast_channel::nativeformats, ast_frame::subclass, ast_channel::tech_pvt, and ast_bridge_config::timelimit.

Referenced by ast_channel_bridge().

{
   /* Copy voice back and forth between the two channels. */
   struct ast_channel *cs[3];
   struct ast_frame *f;
   struct ast_channel *who = NULL;
   enum ast_bridge_result res = AST_BRIDGE_COMPLETE;
   int o0nativeformats;
   int o1nativeformats;
   int watch_c0_dtmf;
   int watch_c1_dtmf;
   void *pvt0, *pvt1;
   int to;
   
   cs[0] = c0;
   cs[1] = c1;
   pvt0 = c0->tech_pvt;
   pvt1 = c1->tech_pvt;
   o0nativeformats = c0->nativeformats;
   o1nativeformats = c1->nativeformats;
   watch_c0_dtmf = config->flags & AST_BRIDGE_DTMF_CHANNEL_0;
   watch_c1_dtmf = config->flags & AST_BRIDGE_DTMF_CHANNEL_1;

   for (;;) {
      if ((c0->tech_pvt != pvt0) || (c1->tech_pvt != pvt1) ||
          (o0nativeformats != c0->nativeformats) ||
          (o1nativeformats != c1->nativeformats)) {
         /* Check for Masquerade, codec changes, etc */
         res = AST_BRIDGE_RETRY;
         break;
      }
      if (bridge_end.tv_sec) {
         to = ast_tvdiff_ms(bridge_end, ast_tvnow());
         if (to <= 0) {
            if (config->timelimit)
               res = AST_BRIDGE_RETRY;
            else
               res = AST_BRIDGE_COMPLETE;
            break;
         }
      } else
         to = -1;
      who = ast_waitfor_n(cs, 2, &to);
      if (!who) {
         ast_log(LOG_DEBUG, "Nobody there, continuing...\n"); 
         if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE) {
            if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
               c0->_softhangup = 0;
            if (c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
               c1->_softhangup = 0;
            c0->_bridge = c1;
            c1->_bridge = c0;
         }
         continue;
      }
      f = ast_read(who);
      if (!f) {
         *fo = NULL;
         *rc = who;
         res = AST_BRIDGE_COMPLETE;
         ast_log(LOG_DEBUG, "Didn't get a frame from channel: %s\n",who->name);
         break;
      }

      if ((f->frametype == AST_FRAME_CONTROL) && !(config->flags & AST_BRIDGE_IGNORE_SIGS)) {
         if ((f->subclass == AST_CONTROL_HOLD) || (f->subclass == AST_CONTROL_UNHOLD) ||
             (f->subclass == AST_CONTROL_VIDUPDATE)) {
            ast_indicate(who == c0 ? c1 : c0, f->subclass);
         } else {
            *fo = f;
            *rc = who;
            res =  AST_BRIDGE_COMPLETE;
            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_DTMF) ||
          (f->frametype == AST_FRAME_VIDEO) || 
          (f->frametype == AST_FRAME_IMAGE) ||
          (f->frametype == AST_FRAME_HTML) ||
          (f->frametype == AST_FRAME_TEXT)) {
         if (f->frametype == AST_FRAME_DTMF) {
            if (((who == c0) && watch_c0_dtmf) ||
                ((who == c1) && watch_c1_dtmf)) {
               *rc = who;
               *fo = f;
               res = AST_BRIDGE_COMPLETE;
               ast_log(LOG_DEBUG, "Got DTMF on channel (%s)\n", who->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:
            ast_write((who == c0) ? c1 : c0, f);
         }
      }
      ast_frfree(f);

      /* Swap who gets priority */
      cs[2] = cs[0];
      cs[0] = cs[1];
      cs[1] = cs[2];
   }
   return res;
}

struct ast_channel* ast_get_channel_by_exten_locked	(	const char *	exten,
		const char *	context
	)			[read]

Definition at line 826 of file channel.c.

References channel_find_locked().

Referenced by pickup_exec().

{
   return channel_find_locked(NULL, NULL, 0, context, exten);
}

struct ast_channel* ast_get_channel_by_name_locked

(

const char *

chan

)

[read]

Get channel by name (locks channel)

Definition at line 808 of file channel.c.

References channel_find_locked().

Referenced by action_getvar(), action_hangup(), action_redirect(), action_setcdruserfield(), action_setvar(), action_status(), action_timeout(), ast_async_goto_by_name(), change_monitor_action(), get_zap_channel_locked(), handle_channelstatus(), handle_debugchan(), handle_getvariablefull(), handle_hangup(), handle_nodebugchan(), handle_showchan(), handle_softhangup(), pbx_builtin_importvar(), pickup_exec(), start_monitor_action(), and stop_monitor_action().

{
   return channel_find_locked(NULL, name, 0, NULL, NULL);
}

struct ast_channel* ast_get_channel_by_name_prefix_locked	(	const char *	name,
		const int	namelen
	)			[read]

Get channel by name prefix (locks channel)

Definition at line 814 of file channel.c.

References channel_find_locked().

Referenced by ast_parse_device_state(), and mixmonitor_cli().

{
   return channel_find_locked(NULL, name, namelen, NULL, NULL);
}

struct ast_channel_tech* ast_get_channel_tech

(

const char *

name

)

[read]

Get a channel technology structure by name.

Parameters:

name

name of technology to find

Returns:

a pointer to the structure, or NULL if no matching technology found

Definition at line 388 of file channel.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), backends, LOG_WARNING, chanlist::next, chanlist::tech, and ast_channel_tech::type.

Referenced by ast_device_state().

{
   struct chanlist *chanls;

   if (ast_mutex_lock(&chlock)) {
      ast_log(LOG_WARNING, "Unable to lock channel tech list\n");
      return NULL;
   }

   for (chanls = backends; chanls; chanls = chanls->next) {
      if (strcasecmp(name, chanls->tech->type))
         continue;

      ast_mutex_unlock(&chlock);
      return chanls->tech;
   }

   ast_mutex_unlock(&chlock);
   return NULL;
}

ast_group_t ast_get_group

(

char *

s

)

Definition at line 3862 of file channel.c.

References ast_log(), ast_strdupa, copy(), group, LOG_ERROR, LOG_WARNING, and strsep().

Referenced by _parse(), build_device(), build_gateway(), build_peer(), build_user(), load_module(), read_agent_config(), and setup_zap().

{
   char *copy;
   char *piece;
   char *c=NULL;
   int start=0, finish=0, x;
   ast_group_t 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, "%30d-%30d", &start, &finish) == 2) {
         /* Range */
      } else if (sscanf(piece, "%30d", &start)) {
         /* Just one */
         finish = start;
      } else {
         ast_log(LOG_ERROR, "Syntax error parsing group configuration '%s' at '%s'. Ignoring.\n", s, piece);
         continue;
      }
      for (x = start; x <= finish; x++) {
         if ((x > 63) || (x < 0)) {
            ast_log(LOG_WARNING, "Ignoring invalid group %d (maximum group is 63)\n", x);
         } else
            group |= ((ast_group_t) 1 << x);
      }
   }
   return group;
}

int ast_hangup

(

struct ast_channel *

chan

)

Hang up a channel.

Note:

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.

Parameters:

chan

channel to hang up

Returns:

Returns 0 on success, -1 on failure.

Definition at line 1323 of file channel.c.

References ast_cause2str(), ast_cdr_detach(), ast_cdr_end(), ast_channel_free(), ast_closestream(), ast_do_masquerade(), AST_FLAG_BLOCKING, AST_FLAG_ZOMBIE, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, ast_test_flag, ast_channel::blocker, ast_channel::blockproc, ast_channel::cdr, CRASH, detach_spies(), EVENT_FLAG_CALL, free_translation(), ast_channel::generator, ast_channel::generatordata, ast_channel_tech::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_generator::release, ast_channel::sched, sched_context_destroy(), ast_channel::stream, ast_channel::tech, ast_channel::uniqueid, and ast_channel::vstream.

Referenced by __ast_pbx_run(), __ast_request_and_dial(), __oh323_new(), agent_hangup(), agent_read(), alsa_new(), ast_async_goto(), ast_bridge_call_thread(), ast_feature_request_and_dial(), ast_iax2_new(), ast_modem_new(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_pbx_run_app(), async_wait(), build_conf(), builtin_atxfer(), chanavail_exec(), check_goto_on_transfer(), conf_free(), dial_exec_full(), do_parking_thread(), features_hangup(), function_ilink(), handle_hd_hf(), handle_init_event(), handle_message(), handle_request_invite(), hangup_chan(), hangupcalls(), hanguptree(), iax2_request(), iax_park(), iax_park_thread(), local_hangup(), mgcp_new(), mgcp_ss(), nbs_new(), oss_new(), park_exec(), parkandannounce_exec(), phone_new(), ring_entry(), rpt(), rpt_call(), rpt_exec(), rpt_tele_thread(), sip_new(), sip_park(), sip_park_thread(), skinny_new(), skinny_ss(), ss_thread(), try_calling(), vpb_new(), wait_for_answer(), zt_handle_event(), and zt_new().

{
   int res = 0;
   struct ast_cdr *cdr = NULL;

   /* 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);

   detach_spies(chan);     /* get rid of spies */

   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) {
      ast_set_flag(chan, AST_FLAG_ZOMBIE);
      ast_mutex_unlock(&chan->lock);
      return 0;
   }
   free_translation(chan);
   /* Close audio stream */
   if (chan->stream) {
      ast_closestream(chan->stream);
      chan->stream = NULL;
   }
   /* Close video stream */
   if (chan->vstream) {
      ast_closestream(chan->vstream);
      chan->vstream = NULL;
   }
   if (chan->sched) {
      sched_context_destroy(chan->sched);
      chan->sched = NULL;
   }
   
   if (chan->generatordata)   /* Clear any tone stuff remaining */ 
      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);
      cdr = chan->cdr;
      chan->cdr = NULL;
   }
   if (ast_test_flag(chan, AST_FLAG_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 (!ast_test_flag(chan, AST_FLAG_ZOMBIE)) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Hanging up channel '%s'\n", chan->name);
      if (chan->tech->hangup)
         res = chan->tech->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: %d\r\n"
         "Cause-txt: %s\r\n",
         chan->name, 
         chan->uniqueid, 
         chan->hangupcause,
         ast_cause2str(chan->hangupcause)
         );
   ast_channel_free(chan);

   /* Defer CDR processing until later */
   if (cdr)
      ast_cdr_detach(cdr);

   return res;
}

int ast_indicate	(	struct ast_channel *	chan,
		int	condition
	)

Indicates condition of channel.

Note:

Indicate a condition such as AST_CONTROL_BUSY, AST_CONTROL_RINGING, or AST_CONTROL_CONGESTION on a channel

Parameters:

	chan	channel to change the indication
	condition	which condition to indicate on the channel

Returns:

Returns 0 on success, -1 on failure

Definition at line 2073 of file channel.c.

References ast_check_hangup(), AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_HOLD, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, AST_FLAG_ZOMBIE, ast_get_indication_tone(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_playtones_start(), ast_playtones_stop(), ast_test_flag, tone_zone_sound::data, ast_channel_tech::indicate, ast_channel::lock, LOG_DEBUG, LOG_WARNING, ast_channel::name, ast_channel::tech, and ast_channel::zone.

Referenced by ast_bridge_call(), ast_feature_request_and_dial(), ast_generic_bridge(), ast_park_call(), ast_play_and_record_full(), ast_rtp_bridge(), attempt_transfer(), builtin_atxfer(), builtin_blindtransfer(), conf_run(), dial_exec_full(), disa_exec(), do_parking_thread(), features_indicate(), function_remote(), handle_recordfile(), handle_remote_data(), handle_remote_phone_dtmf(), mgcp_ss(), park_exec(), pbx_builtin_busy(), pbx_builtin_congestion(), pbx_builtin_progress(), pbx_builtin_ringing(), queue_exec(), record_exec(), rmt_telem_finish(), rmt_telem_start(), rpt(), rpt_exec(), send_waveform_to_channel(), skinny_ss(), vpb_fixup(), and wait_for_answer().

{
   int res = -1;

   ast_mutex_lock(&chan->lock);
   /* Stop if we're a zombie or need a soft hangup */
   if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
      ast_mutex_unlock(&chan->lock);
      return -1;
   }
   if (chan->tech->indicate)
      res = chan->tech->indicate(chan, condition);
   ast_mutex_unlock(&chan->lock);
   if (!chan->tech->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 if (condition == AST_CONTROL_HOLD) {
            /* Do nothing.... */
         } else if (condition == AST_CONTROL_UNHOLD) {
            /* Do nothing.... */
         } else if (condition == AST_CONTROL_VIDUPDATE) {
            /* Do nothing.... */
         } 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;
}

void ast_install_music_functions	(	int(*)(struct ast_channel *, char *)	start_ptr,
		void(*)(struct ast_channel *)	stop_ptr,
		void(*)(struct ast_channel *)	cleanup_ptr
	)

Definition at line 3902 of file channel.c.

References ast_moh_cleanup_ptr, ast_moh_start_ptr, and ast_moh_stop_ptr.

Referenced by load_module(), and reload().

{
   ast_moh_start_ptr = start_ptr;
   ast_moh_stop_ptr = stop_ptr;
   ast_moh_cleanup_ptr = cleanup_ptr;
}

void ast_moh_cleanup

(

struct ast_channel *

chan

)

Definition at line 3938 of file channel.c.

References ast_moh_cleanup_ptr.

Referenced by ast_channel_free().

{
   if(ast_moh_cleanup_ptr)
        ast_moh_cleanup_ptr(chan);
}

int ast_moh_start	(	struct ast_channel *	chan,
		char *	mclass
	)

Turn on music on hold on a given channel

Definition at line 3920 of file channel.c.

References ast_moh_start_ptr, ast_verbose(), option_verbose, and VERBOSE_PREFIX_3.

Referenced by __login_exec(), agent_hangup(), ast_park_call(), builtin_atxfer(), builtin_blindtransfer(), cb_events(), conf_run(), dial_exec_full(), do_parking_thread(), handle_request(), handle_setmusic(), moh0_exec(), moh1_exec(), moh3_exec(), pbx_builtin_waitexten(), process_sdp(), queue_exec(), retrydial_exec(), say_periodic_announcement(), say_position(), socket_read(), zt_handle_event(), and zt_hangup().

{
   if (ast_moh_start_ptr)
      return ast_moh_start_ptr(chan, mclass);

   if (option_verbose > 2)
      ast_verbose(VERBOSE_PREFIX_3 "Music class %s requested but no musiconhold loaded.\n", mclass ? mclass : "default");
   
   return 0;
}

void ast_moh_stop

(

struct ast_channel *

chan

)

Turn off music on hold on a given channel

Definition at line 3932 of file channel.c.

References ast_moh_stop_ptr.

Referenced by __zt_exception(), agent_new(), attempt_transfer(), builtin_atxfer(), builtin_blindtransfer(), cb_events(), conf_run(), dial_exec_full(), do_parking_thread(), handle_hd_hf(), handle_request(), handle_request_bye(), handle_request_refer(), handle_setmusic(), misdn_transfer_bc(), moh0_exec(), moh1_exec(), moh4_exec(), park_exec(), pbx_builtin_waitexten(), process_sdp(), queue_exec(), retrydial_exec(), say_periodic_announcement(), say_position(), socket_read(), ss_thread(), try_calling(), zt_handle_event(), and zt_hangup().

{
   if(ast_moh_stop_ptr)
      ast_moh_stop_ptr(chan);
}

AST_MUTEX_DEFINE_STATIC

(

chlock

)

AST_MUTEX_DEFINE_STATIC

(

uniquelock

)

char* ast_print_group	(	char *	buf,
		int	buflen,
		ast_group_t	group
	)

Definition at line 3950 of file channel.c.

Referenced by ast_serialize_showchan(), misdn_cfg_get_config_string(), print_group(), and read_config().

{
   unsigned int i;
   int first=1;
   char num[3];

   buf[0] = '\0';
   
   if (!group) /* Return empty string if no group */
      return(buf);

   for (i=0; i<=63; i++) { /* Max group is 63 */
      if (group & ((ast_group_t) 1 << i)) {
            if (!first) {
            strncat(buf, ", ", buflen);
         } else {
            first=0;
         }
         snprintf(num, sizeof(num), "%u", i);
         strncat(buf, num, buflen);
      }
   }
   return(buf);
}

int ast_prod

(

struct ast_channel *

chan

)

Definition at line 2229 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::rawwriteformat, ast_frame::src, 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->rawwriteformat;
      a.data = nothing + AST_FRIENDLY_OFFSET;
      a.src = "ast_prod";
      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
	)

Queue a control frame.

Definition at line 685 of file channel.c.

References AST_FRAME_CONTROL, ast_queue_frame(), and ast_frame::subclass.

Referenced by __oh323_update_info(), ast_pickup_call(), auto_congest(), cb_events(), handle_message(), handle_request_info(), handle_response(), handle_response_invite(), mgcp_call(), nbs_call(), phone_call(), pickup_exec(), send_cause2ast(), setup_rtp_connection(), skinny_call(), update_state(), and vpb_call().

{
   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 *	fin
	)

Queue an outgoing frame.

Definition at line 614 of file channel.c.

References ast_channel::alertpipe, AST_CONTROL_HANGUP, AST_FLAG_BLOCKING, AST_FRAME_CONTROL, AST_FRAME_VOICE, ast_frdup(), ast_frfree(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_test_flag, ast_channel::blocker, CRASH, ast_frame::frametype, ast_channel::lock, LOG_DEBUG, LOG_WARNING, ast_channel::name, ast_frame::next, ast_frame::prev, ast_channel::readq, ast_frame::subclass, and ast_channel::timingfd.

Referenced by agent_new(), alsa_call(), ast_channel_masquerade(), ast_channel_setwhentohangup(), ast_do_masquerade(), ast_dsp_process(), ast_queue_control(), ast_queue_hangup(), ast_softhangup_nolock(), cb_events(), console_answer(), console_dial(), console_flash(), console_sendtext(), dictate_exec(), do_chanreads(), do_immediate_setup(), handle_message(), handle_request_info(), handle_request_invite(), handle_response_invite(), iax2_queue_frame(), local_queue_frame(), mgcp_queue_frame(), monitor_handle_owned(), oss_call(), process_sdp(), receive_message(), send_digit(), wakeup_sub(), and zap_queue_frame().

{
   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->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->readq = f;
   if (chan->alertpipe[1] > -1) {
      if (write(chan->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 (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
      pthread_kill(chan->blocker, SIGURG);
   }
   ast_mutex_unlock(&chan->lock);
   return 0;
}

int ast_queue_hangup

(

struct ast_channel *

chan

)

Queue a hangup frame.

Definition at line 673 of file channel.c.

References ast_channel::_softhangup, AST_CONTROL_HANGUP, AST_FRAME_CONTROL, ast_mutex_trylock(), ast_mutex_unlock(), ast_queue_frame(), AST_SOFTHANGUP_DEV, and ast_channel::lock.

Referenced by __oh323_update_info(), __sip_autodestruct(), cleanup_connection(), console_hangup(), handle_message(), handle_request_bye(), handle_request_cancel(), handle_request_refer(), handle_response(), handle_response_invite(), hangup_chan(), hangup_connection(), iax2_destroy(), iax2_predestroy(), mgcp_queue_hangup(), misdn_answer(), retrans_pkt(), and zt_handle_event().

{
   struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
   /* Yeah, let's not change a lock-critical value without locking */
   if (!ast_mutex_trylock(&chan->lock)) {
      chan->_softhangup |= AST_SOFTHANGUP_DEV;
      ast_mutex_unlock(&chan->lock);
   }
   return ast_queue_frame(chan, &f);
}

struct ast_frame* ast_read

(

struct ast_channel *

chan

)

[read]

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 1845 of file channel.c.

References ast_channel::_softhangup, ast_channel::_state, ast_channel::alertpipe, ast_cdr_answer(), ast_cdr_end(), ast_check_hangup(), ast_clear_flag, AST_CONTROL_ANSWER, AST_CONTROL_HANGUP, ast_deactivate_generator(), ast_do_masquerade(), AST_FLAG_DEFER_DTMF, AST_FLAG_EXCEPTION, AST_FLAG_ZOMBIE, 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_strlen_zero(), ast_test_flag, ast_translate(), ast_writestream(), ast_channel::blocker, ast_channel::cdr, ast_frame::data, ast_frame::datalen, ast_channel::dtmff, ast_channel::dtmfq, ast_channel_tech::exception, ast_channel::fdno, ast_channel::fin, ast_frame::frametype, ast_generator::generate, ast_channel::generator, generator_force(), 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, queue_frame_to_spies(), ast_channel_tech::read, ast_channel_monitor::read_stream, ast_channel::readq, ast_channel::readtrans, ast_frame::samples, SEEK_FORCECUR, ast_channel::spies, SPY_READ, ast_frame::subclass, ast_channel::tech, ast_channel::timingdata, ast_channel::timingfd, and ast_channel::timingfunc.

Referenced by __adsi_transmit_messages(), __ast_request_and_dial(), adsi_careful_send(), agent_ack_sleep(), agent_read(), app_exec(), ast_app_getvoice(), ast_feature_request_and_dial(), ast_generic_bridge(), ast_masq_park_call(), ast_play_and_prepend(), ast_play_and_record_full(), ast_recvtext(), ast_rtp_bridge(), ast_safe_sleep(), ast_safe_sleep_conditional(), ast_tonepair(), ast_waitfordigit(), ast_waitfordigit_full(), ast_waitstream(), ast_waitstream_exten(), ast_waitstream_fr(), ast_waitstream_full(), async_wait(), autoservice_run(), background_detect_exec(), builtin_atxfer(), channel_spy(), check_goto_on_transfer(), conf_exec(), conf_flush(), conf_run(), dictate_exec(), disa_exec(), do_parking_thread(), do_waiting(), echo_exec(), features_read(), find_cache(), handle_recordfile(), iax2_bridge(), iax_park_thread(), ices_exec(), measurenoise(), misdn_bridge(), mp3_exec(), NBScat_exec(), receive_dtmf_digits(), record_exec(), recordthread(), rpt(), rpt_exec(), run_agi(), send_tone_burst(), send_waveform_to_channel(), sendurl_exec(), sms_exec(), ss_thread(), vpb_bridge(), wait_for_answer(), wait_for_hangup(), waitforring_exec(), and zt_bridge().

{
   struct ast_frame *f = NULL;
   int blah;
   int prestate;
#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 (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
      if (chan->generator)
         ast_deactivate_generator(chan);
      ast_mutex_unlock(&chan->lock);
      return NULL;
   }
   prestate = chan->_state;

   if (!ast_test_flag(chan, AST_FLAG_DEFER_DTMF) && !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->alertpipe[0] > -1) {
      read(chan->alertpipe[0], &blah, sizeof(blah));
   }
#ifdef ZAPTEL_OPTIMIZATIONS
   if ((chan->timingfd > -1) && (chan->fdno == AST_MAX_FDS - 2) && ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
      ast_clear_flag(chan, AST_FLAG_EXCEPTION);
      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->readq || !chan->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->readq) {
      f = chan->readq;
      chan->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 (ast_test_flag(chan, AST_FLAG_EXCEPTION)) {
         if (chan->tech->exception) 
            f = chan->tech->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 */
         ast_clear_flag(chan, AST_FLAG_EXCEPTION);
      } else {
         if (chan->tech->read)
            f = chan->tech->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->spies)
            queue_frame_to_spies(chan, f, SPY_READ);

         if (chan->monitor && chan->monitor->read_stream ) {
#ifndef MONITOR_CONSTANT_DELAY
            int jump = chan->outsmpl - chan->insmpl - 4 * f->samples;
            if (jump >= 0) {
               jump = chan->outsmpl - chan->insmpl;
               if (ast_seekstream(chan->monitor->read_stream, jump, 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 + 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->readtrans) {
            f = ast_translate(chan->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 (ast_test_flag(chan, AST_FLAG_DEFER_DTMF) && 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);
      ast_frfree(f);
      f = &null_frame;
   } else if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_ANSWER)) {
      if (prestate == AST_STATE_UP) {
         ast_log(LOG_DEBUG, "Dropping duplicate answer!\n");
         ast_frfree(f);
         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 2663 of file channel.c.

References ast_check_hangup(), AST_DIGIT_ANY, AST_FLAG_ZOMBIE, ast_stopstream(), ast_test_flag, ast_waitfordigit(), ast_waitstream(), and ast_channel::stream.

Referenced by __adsi_transmit_messages(), adsi_begin_download(), adsi_get_cpeinfo(), adsi_load_session(), ast_app_getdata(), dialout(), do_directory(), forward_message(), privacy_exec(), vm_authenticate(), vm_newuser(), and vm_options().

{
   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 (ast_test_flag(c, AST_FLAG_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 2703 of file channel.c.

References ast_check_hangup(), AST_DIGIT_ANY, AST_FLAG_ZOMBIE, ast_stopstream(), ast_test_flag, ast_waitfordigit_full(), ast_waitstream_full(), and ast_channel::stream.

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 (ast_test_flag(c, AST_FLAG_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
	)

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 2129 of file channel.c.

References ast_recvtext(), and free.

Referenced by handle_recvchar().

{
   int c;
   char *buf = ast_recvtext(chan, timeout);
   if (buf == NULL)
      return -1;  /* error or timeout */
   c = *(unsigned char *)buf;
   free(buf);
   return c;
}

char* ast_recvtext	(	struct ast_channel *	chan,
		int	timeout
	)

Receives a text string from a channel

Parameters:

	chan	channel to act upon
	timeout	timeout in milliseconds (0 for infinite wait)

Returns:

the received text, or NULL to signify failure. Read a string of text from a channel

Definition at line 2140 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::datalen, ast_frame::frametype, strndup, and ast_frame::subclass.

Referenced by ast_recvchar(), and handle_recvtext().

{
   int res, done = 0;
   char *buf = NULL;
   
   while (!done) {
      struct ast_frame *f;
      if (ast_check_hangup(chan))
         break;
      res = ast_waitfor(chan, timeout);
      if (res <= 0) /* timeout or error */
         break;
      timeout = res; /* update timeout */
      f = ast_read(chan);
      if (f == NULL)
         break; /* no frame */
      if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
         done = 1;   /* force a break */
      else if (f->frametype == AST_FRAME_TEXT) {      /* what we want */
         buf = strndup((char *) f->data, f->datalen); /* dup and break */
         done = 1;
      }
      ast_frfree(f);
   }
   return buf;
}

struct ast_channel* ast_request	(	const char *	type,
		int	format,
		void *	data,
		int *	status
	)			[read]

Requests a channel.

Parameters:

	type	type of channel to request
	format	requested channel format
	data	data to pass to the channel requester
	status	status Request a channel of a given type, with data as optional information used by the low level module

Returns:

Returns an ast_channel on success, NULL on failure.

Definition at line 2568 of file channel.c.

References ast_channel::_state, AST_CAUSE_NOSUCHDRIVER, AST_CAUSE_NOTDEFINED, AST_FLAG_NOTNEW, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, ast_state2str(), AST_STATE_DOWN, ast_translator_best_choice(), backends, ast_channel_tech::capabilities, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, EVENT_FLAG_CALL, fmt, LOG_WARNING, manager_event(), ast_channel::name, chanlist::next, ast_channel_tech::requester, chanlist::tech, ast_channel_tech::type, and ast_channel::uniqueid.

Referenced by __ast_request_and_dial(), agent_request(), ast_feature_request_and_dial(), attempt_reconnect(), build_conf(), chanavail_exec(), dial_exec_full(), features_alloc(), function_ilink(), ring_entry(), rpt(), rpt_call(), rpt_exec(), rpt_tele_thread(), and wait_for_answer().

{
   struct chanlist *chan;
   struct ast_channel *c;
   int capabilities;
   int fmt;
   int res;
   int foo;

   if (!cause)
      cause = &foo;
   *cause = AST_CAUSE_NOTDEFINED;

   if (ast_mutex_lock(&chlock)) {
      ast_log(LOG_WARNING, "Unable to lock channel list\n");
      return NULL;
   }

   for (chan = backends; chan; chan = chan->next) {
      if (strcasecmp(type, chan->tech->type))
         continue;

      capabilities = chan->tech->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->tech->capabilities, format);
         ast_mutex_unlock(&chlock);
         return NULL;
      }
      ast_mutex_unlock(&chlock);
      if (!chan->tech->requester)
         return NULL;
      
      if (!(c = chan->tech->requester(type, capabilities, data, cause)))
         return NULL;

      if (c->_state == AST_STATE_DOWN) {
         manager_event(EVENT_FLAG_CALL, "Newchannel",
                  "Channel: %s\r\n"
                  "State: %s\r\n"
                  "CallerID: %s\r\n"
                  "CallerIDName: %s\r\n"
                  "Uniqueid: %s\r\n",
                  c->name, ast_state2str(c->_state),
                  c->cid.cid_num ? c->cid.cid_num : "<unknown>",
                  c->cid.cid_name ? c->cid.cid_name : "<unknown>",
                  c->uniqueid);
         ast_set_flag(c, AST_FLAG_NOTNEW);
      }
      return c;
   }

   ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type);
   *cause = AST_CAUSE_NOSUCHDRIVER;
   ast_mutex_unlock(&chlock);

   return NULL;
}

struct ast_channel* ast_request_and_dial	(	const char *	type,
		int	format,
		void *	data,
		int	timeout,
		int *	reason,
		const char *	cidnum,
		const char *	cidname
	)			[read]

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.

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
	reason	why unsuccessful (if unsuceessful)
	cidnum	Caller-ID Number
	cidname	Caller-ID Name

Returns:

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 2563 of file channel.c.

References __ast_request_and_dial().

Referenced by ast_pbx_outgoing_exten().

{
   return __ast_request_and_dial(type, format, data, timeout, outstate, cidnum, cidname, 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:

returns -1 on hangup, otherwise 0.

Definition at line 854 of file channel.c.

References ast_frfree(), ast_read(), and ast_waitfor().

Referenced by __login_exec(), adsi_transmit_message_full(), alarmreceiver_exec(), ast_dtmf_stream(), dictate_exec(), flash_exec(), function_ilink(), function_remote(), handle_remote_data(), handle_remote_phone_dtmf(), milliwatt_exec(), moh0_exec(), moh1_exec(), park_call_exec(), pbx_builtin_answer(), pbx_builtin_wait(), play_tone_pair(), privacy_exec(), receive_ademco_contact_id(), rmt_telem_start(), rpt_call(), rpt_exec(), rpt_tele_thread(), send_morse(), send_tone_telemetry(), skinny_ss(), testclient_exec(), testserver_exec(), try_calling(), wait_for_hangup(), wait_interval(), and zapateller_exec().

{
   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

Returns:

returns -1 on hangup, otherwise 0. Waits for a specified amount of time, servicing the channel as required. If cond returns 0, this function returns.

Definition at line 832 of file channel.c.

References ast_frfree(), ast_read(), and ast_waitfor().

Referenced by __login_exec().

{
   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
	)

Send a DTMF digit to a channel

Parameters:

	chan	channel to act upon
	digit	the DTMF digit to send, encoded in ASCII Send a DTMF digit to a channel. Returns 0 on success, -1 on failure

Definition at line 2224 of file channel.c.

References do_senddigit().

Referenced by dial_exec_full(), and features_digit().

{
   return do_senddigit(chan, digit);
}

int ast_sendtext	(	struct ast_channel *	chan,
		const 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 2167 of file channel.c.

References ast_check_hangup(), ast_clear_flag, AST_FLAG_BLOCKING, AST_FLAG_ZOMBIE, ast_test_flag, CHECK_BLOCKING, ast_channel_tech::send_text, and ast_channel::tech.

Referenced by agent_sendtext(), handle_sendtext(), and sendtext_exec().

{
   int res = 0;
   /* Stop if we're a zombie or need a soft hangup */
   if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) 
      return -1;
   CHECK_BLOCKING(chan);
   if (chan->tech->send_text)
      res = chan->tech->send_text(chan, text);
   ast_clear_flag(chan, AST_FLAG_BLOCKING);
   return res;
}

void ast_set_callerid	(	struct ast_channel *	chan,
		const char *	callerid,
		const char *	calleridname,
		const char *	ani
	)

Definition at line 3226 of file channel.c.

References ast_cdr_setcid(), ast_describe_caller_presentation(), ast_strlen_zero(), ast_channel::cdr, ast_channel::cid, ast_callerid::cid_ani, ast_callerid::cid_name, ast_callerid::cid_num, ast_callerid::cid_pres, EVENT_FLAG_CALL, free, manager_event(), ast_channel::name, strdup, and ast_channel::uniqueid.

Referenced by __ast_request_and_dial(), agent_call(), ast_feature_request_and_dial(), callerid_write(), dial_exec_full(), disa_exec(), get_callerid(), handle_setcallerid(), local_call(), lookupcidname_exec(), mgcp_ss(), monitor_handle_notowned(), privacy_exec(), read_config(), rpt_exec(), setcallerid_exec(), skinny_ss(), ss_thread(), wait_for_answer(), and zt_read().

{
   if (callerid) {
      if (chan->cid.cid_num)
         free(chan->cid.cid_num);
      if (ast_strlen_zero(callerid))
         chan->cid.cid_num = NULL;
      else
         chan->cid.cid_num = strdup(callerid);
   }
   if (calleridname) {
      if (chan->cid.cid_name)
         free(chan->cid.cid_name);
      if (ast_strlen_zero(calleridname))
         chan->cid.cid_name = NULL;
      else
         chan->cid.cid_name = strdup(calleridname);
   }
   if (ani) {
      if (chan->cid.cid_ani)
         free(chan->cid.cid_ani);
      if (ast_strlen_zero(ani))
         chan->cid.cid_ani = NULL;
      else
         chan->cid.cid_ani = strdup(ani);
   }
   if (chan->cdr)
      ast_cdr_setcid(chan->cdr, chan);
   manager_event(EVENT_FLAG_CALL, "Newcallerid", 
            "Channel: %s\r\n"
            "CallerID: %s\r\n"
            "CallerIDName: %s\r\n"
            "Uniqueid: %s\r\n"
            "CID-CallingPres: %d (%s)\r\n",
            chan->name, chan->cid.cid_num ? 
            chan->cid.cid_num : "<Unknown>",
            chan->cid.cid_name ? 
            chan->cid.cid_name : "<Unknown>",
            chan->uniqueid,
            chan->cid.cid_pres,
            ast_describe_caller_presentation(chan->cid.cid_pres)
            );
}

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 2437 of file channel.c.

References ast_channel::rawreadformat, ast_channel::readformat, ast_channel::readtrans, and set_format().

Referenced by __login_exec(), __oh323_update_info(), adsi_transmit_message_full(), agent_call(), alarmreceiver_exec(), ast_app_getvoice(), ast_channel_make_compatible(), ast_do_masquerade(), ast_play_and_prepend(), ast_play_and_record_full(), attempt_reconnect(), background_detect_exec(), chanspy_exec(), conf_run(), dictate_exec(), disa_exec(), do_waiting(), eagi_exec(), echo_exec(), function_ilink(), handle_recordfile(), ices_exec(), measurenoise(), mgcp_rtp_read(), milliwatt_exec(), oh323_rtp_read(), process_sdp(), record_exec(), rpt(), rpt_exec(), setup_rtp_connection(), sip_rtp_read(), skinny_rtp_read(), sms_exec(), socket_read(), and update_features().

{
   return set_format(chan, fmt, &chan->rawreadformat, &chan->readformat,
           &chan->readtrans, 0);
}

void ast_set_variables	(	struct ast_channel *	chan,
		struct ast_variable *	vars
	)

adds a list of channel variables to a channel

Parameters:

	chan	the channel
	vars	a linked list of variables

Variable names can be for a regular channel variable or a dialplan function that has the ability to be written to.

Definition at line 3975 of file channel.c.

References ast_variable::name, ast_variable::next, pbx_builtin_setvar_helper(), and ast_variable::value.

Referenced by __ast_request_and_dial(), ast_pbx_outgoing_app(), and ast_pbx_outgoing_exten().

{
   struct ast_variable *cur;

   for (cur = vars; cur; cur = cur->next)
      pbx_builtin_setvar_helper(chan, cur->name, cur->value);  
}

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 2443 of file channel.c.

References ast_channel::rawwriteformat, set_format(), ast_channel::writeformat, and ast_channel::writetrans.

Referenced by __login_exec(), __oh323_update_info(), adsi_transmit_message_full(), agent_call(), alarmreceiver_exec(), ast_channel_make_compatible(), ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), ast_do_masquerade(), ast_openstream_full(), ast_stopstream(), attempt_reconnect(), chanspy_exec(), conf_run(), disa_exec(), echo_exec(), function_ilink(), linear_alloc(), linear_release(), mgcp_rtp_read(), milliwatt_exec(), moh_alloc(), moh_files_release(), moh_release(), mp3_exec(), NBScat_exec(), oh323_rtp_read(), playtones_alloc(), playtones_release(), process_sdp(), rpt(), rpt_exec(), send_waveform_to_channel(), setup_rtp_connection(), sip_rtp_read(), skinny_rtp_read(), sms_exec(), socket_read(), tonepair_alloc(), tonepair_release(), and update_features().

{
   return set_format(chan, fmt, &chan->rawwriteformat, &chan->writeformat,
           &chan->writetrans, 1);
}

int ast_setstate	(	struct ast_channel *	chan,
		int	state
	)

Change the state of a channel.

Definition at line 3270 of file channel.c.

References ast_channel::_state, ast_device_state_changed_literal(), AST_FLAG_NOTNEW, ast_state2str(), AST_STATE_DOWN, ast_test_flag, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, EVENT_FLAG_CALL, manager_event(), ast_channel::name, and ast_channel::uniqueid.

Referenced by __oh323_new(), __oh323_update_info(), __zt_exception(), agent_call(), agent_new(), alsa_answer(), alsa_new(), aopen_handle_escape(), ast_answer(), ast_async_goto(), ast_iax2_new(), ast_modem_new(), ast_read(), bestdata_handle_escape(), cb_events(), check_availability(), features_new(), handle_message(), handle_request_invite(), handle_response_invite(), i4l_handle_escape(), iax2_call(), local_new(), mgcp_answer(), mgcp_call(), mgcp_new(), mgcp_ss(), misdn_call(), misdn_indication(), misdn_new(), modem_answer(), modem_call(), modem_hangup(), nbs_call(), nbs_hangup(), nbs_new(), oh323_answer(), oss_answer(), oss_new(), pbx_builtin_busy(), pbx_builtin_congestion(), phone_answer(), phone_call(), phone_exception(), phone_hangup(), phone_new(), phone_write(), release_chan(), sip_answer(), sip_new(), skinny_answer(), skinny_call(), skinny_new(), skinny_ss(), ss_thread(), update_state(), vpb_answer(), vpb_call(), vpb_hangup(), vpb_new(), zt_answer(), zt_call(), zt_handle_event(), zt_indicate(), zt_new(), and zt_read().

{
   int oldstate = chan->_state;

   if (oldstate == state)
      return 0;

   chan->_state = state;
   ast_device_state_changed_literal(chan->name);
   manager_event(EVENT_FLAG_CALL,
            (oldstate == AST_STATE_DOWN && !ast_test_flag(chan, AST_FLAG_NOTNEW)) ? "Newchannel" : "Newstate",
            "Channel: %s\r\n"
            "State: %s\r\n"
            "CallerID: %s\r\n"
            "CallerIDName: %s\r\n"
            "Uniqueid: %s\r\n",
            chan->name, ast_state2str(chan->_state), 
            chan->cid.cid_num ? chan->cid.cid_num : "<unknown>", 
            chan->cid.cid_name ? chan->cid.cid_name : "<unknown>", 
            chan->uniqueid);

   return 0;
}

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

Definition at line 1768 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(), ast_read(), and ast_readaudio_callback().

{
   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 271 of file channel.c.

References shutting_down.

{
   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.
	cause	Ast hangupcause for hangup

Returns:

Returns 0 regardless

Definition at line 1169 of file channel.c.

References ast_mutex_lock(), ast_mutex_unlock(), ast_softhangup_nolock(), and ast_channel::lock.

Referenced by __login_exec(), __unload_module(), action_hangup(), agent_hangup(), agent_logoff(), ast_begin_shutdown(), function_ilink(), handle_hangup(), handle_link_data(), handle_softhangup(), read_agent_config(), rpt(), rpt_call(), softhangup_exec(), start_spying(), startmon(), unload_module(), and zt_handle_event().

{
   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
	)

Softly hangup up a channel (no channel lock).

Parameters:

	chan	channel to be soft-hung-up
	cause	Ast hangupcause for hangup (see cause.h)

Definition at line 1153 of file channel.c.

References ast_channel::_softhangup, AST_FLAG_BLOCKING, AST_FRAME_NULL, ast_log(), ast_queue_frame(), ast_test_flag, ast_channel::blocker, LOG_DEBUG, ast_channel::name, and option_debug.

Referenced by ast_async_goto(), ast_softhangup(), attempt_transfer(), do_monitor(), oh323_indicate(), sip_indicate(), and skinny_indicate().

{
   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 (ast_test_flag(chan, AST_FLAG_BLOCKING))
      pthread_kill(chan->blocker, SIGURG);
   return res;
}

char* ast_state2str

(

int

state

)

Gives the string form of a given channel state

Parameters:

state

state to get the name of Give a name to a state Returns the text form of the binary state given

Definition at line 422 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 action_status(), agent_hangup(), ast_request(), ast_serialize_showchan(), ast_setstate(), handle_chanlist(), handle_showchan(), and mgcp_new().

{
   /* 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 3843 of file channel.c.

References ast_frfree(), ast_read(), ast_tonepair_start(), ast_waitfor(), and ast_channel::generatordata.

Referenced by zapateller_exec().

{
   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 3822 of file channel.c.

References ast_activate_generator(), tonepair_def::duration, tonepair_def::freq1, tonepair_def::freq2, tonepair, and tonepair_def::vol.

Referenced by ast_tonepair(), play_dialtone(), play_tone_pair(), rpt_tele_thread(), and sendnoise().

{
   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 3838 of file channel.c.

References ast_deactivate_generator().

Referenced by sendnoise().

{
   ast_deactivate_generator(chan);
}

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

Transfer a channel (if supported). Returns -1 on error, 0 if not supported and 1 if supported and requested.

Parameters:

	chan	current channel
	dest	destination extension for transfer

Definition at line 2645 of file channel.c.

References ast_check_hangup(), AST_FLAG_ZOMBIE, ast_mutex_lock(), ast_mutex_unlock(), ast_test_flag, ast_channel::lock, ast_channel::tech, and ast_channel_tech::transfer.

Referenced by transfer_exec().

{
   int res = -1;

   /* Stop if we're a zombie or need a soft hangup */
   ast_mutex_lock(&chan->lock);
   if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
      if (chan->tech->transfer) {
         res = chan->tech->transfer(chan, dest);
         if (!res)
            res = 1;
      } else
         res = 0;
   }
   ast_mutex_unlock(&chan->lock);
   return res;
}

char* ast_transfercapability2str

(

int

transfercapability

)

Gives the string form of a given transfer capability

Parameters:

transfercapability

transfercapabilty to get the name of Give a name to a transfercapbility See above Returns the text form of the binary transfer capbility

Definition at line 450 of file channel.c.

References AST_TRANS_CAP_3_1K_AUDIO, AST_TRANS_CAP_DIGITAL, AST_TRANS_CAP_DIGITAL_W_TONES, AST_TRANS_CAP_RESTRICTED_DIGITAL, AST_TRANS_CAP_SPEECH, and AST_TRANS_CAP_VIDEO.

Referenced by cb_events(), misdn_call(), zt_call(), and zt_new().

{
   switch(transfercapability) {
   case AST_TRANS_CAP_SPEECH:
      return "SPEECH";
   case AST_TRANS_CAP_DIGITAL:
      return "DIGITAL";
   case AST_TRANS_CAP_RESTRICTED_DIGITAL:
      return "RESTRICTED_DIGITAL";
   case AST_TRANS_CAP_3_1K_AUDIO:
      return "3K1AUDIO";
   case AST_TRANS_CAP_DIGITAL_W_TONES:
      return "DIGITAL_W_TONES";
   case AST_TRANS_CAP_VIDEO:
      return "VIDEO";
   default:
      return "UNKNOWN";
   }
}

void ast_uninstall_music_functions

(

void

)

Definition at line 3912 of file channel.c.

References ast_moh_cleanup_ptr, ast_moh_start_ptr, and ast_moh_stop_ptr.

{
   ast_moh_start_ptr = NULL;
   ast_moh_stop_ptr = NULL;
   ast_moh_cleanup_ptr = NULL;
}

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:

Returns < 0 on failure, 0 if nothing ever arrived, and the # of ms remaining otherwise

Definition at line 1724 of file channel.c.

References ast_waitfor_n().

Referenced by __adsi_transmit_messages(), __ast_request_and_dial(), adsi_careful_send(), agent_ack_sleep(), ast_app_getvoice(), ast_dtmf_stream(), ast_play_and_prepend(), ast_play_and_record_full(), ast_recvtext(), ast_safe_sleep(), ast_safe_sleep_conditional(), ast_tonepair(), ast_waitfordigit(), ast_waitstream(), ast_waitstream_exten(), ast_waitstream_fr(), async_wait(), background_detect_exec(), channel_spy(), conf_exec(), conf_flush(), dictate_exec(), disa_exec(), do_waiting(), echo_exec(), handle_recordfile(), ices_exec(), measurenoise(), modem_call(), mp3_exec(), NBScat_exec(), receive_dtmf_digits(), record_exec(), recordthread(), send_tone_burst(), send_waveform_to_channel(), sendurl_exec(), sms_exec(), ss_thread(), wait_for_hangup(), and waitforring_exec().

{
   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
	)			[read]

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 1719 of file channel.c.

References ast_waitfor_nandfds().

Referenced by ast_feature_request_and_dial(), ast_generic_bridge(), ast_rtp_bridge(), ast_waitfor(), autoservice_run(), iax2_bridge(), misdn_bridge(), rpt(), rpt_exec(), vpb_bridge(), wait_for_answer(), and zt_bridge().

{
   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 1505 of file channel.c.

References ast_fdisset(), ast_log(), pollfd::events, pollfd::fd, LOG_ERROR, poll(), POLLIN, and POLLPRI.

Referenced by ast_modem_expect(), ast_modem_read_response(), bestdata_read(), dundi_lookup_internal(), and dundi_precache_internal().

{
   struct timeval start = { 0 , 0 };
   int res;
   int x, y;
   int winner = -1;
   int spoint;
   struct pollfd *pfds;
   
   pfds = alloca(sizeof(struct pollfd) * n);
   if (!pfds) {
      ast_log(LOG_ERROR, "Out of memory\n");
      return -1;
   }
   if (*ms > 0)
      start = ast_tvnow();
   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) {
      *ms -= ast_tvdiff_ms(ast_tvnow(), start);
      if (*ms < 0)
         *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
	)			[read]

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:

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 1561 of file channel.c.

References ast_channel::_softhangup, ast_clear_flag, ast_do_masquerade(), ast_fdisset(), AST_FLAG_BLOCKING, AST_FLAG_EXCEPTION, ast_log(), AST_MAX_FDS, ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, AST_SOFTHANGUP_TIMEOUT, CHECK_BLOCKING, pollfd::events, pollfd::fd, ast_channel::fdno, ast_channel::fds, lock, LOG_ERROR, LOG_WARNING, ast_channel::masq, poll(), POLLIN, POLLPRI, pollfd::revents, and ast_channel::whentohangup.

Referenced by app_exec(), ast_waitfor_n(), ast_waitfordigit_full(), ast_waitstream_full(), conf_run(), find_cache(), and run_agi().

{
   struct timeval start = { 0 , 0 };
   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_ERROR, "Out of memory\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;
            pfds[max].revents = 0;
            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;
         pfds[max].revents = 0;
         max++;
      }
   }
   if (*ms > 0) 
      start = ast_tvnow();
   
   if (sizeof(int) == 4) {
      do {
         int kbrms = rms;
         if (kbrms > 600000)
            kbrms = 600000;
         res = poll(pfds, max, kbrms);
         if (!res)
            rms -= kbrms;
      } while (!res && (rms > 0));
   } else {
      res = poll(pfds, max, rms);
   }
   
   if (res < 0) {
      for (x=0; x < n; x++) 
         ast_clear_flag(c[x], AST_FLAG_BLOCKING);
      /* Simulate a timeout if we were interrupted */
      if (errno != EINTR)
         *ms = -1;
      else {
         /* Just an interrupt */
#if 0
         *ms = 0;
#endif         
      }
      return NULL;
        } else {
         /* If no fds signalled, then timeout. So set ms = 0
         since we may not have an exact timeout.
      */
      if (res == 0)
         *ms = 0;
   }

   if (havewhen)
      time(&now);
   spoint = 0;
   for (x=0; x < n; x++) {
      ast_clear_flag(c[x], AST_FLAG_BLOCKING);
      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)
                  ast_set_flag(c[x], AST_FLAG_EXCEPTION);
               else
                  ast_clear_flag(c[x], AST_FLAG_EXCEPTION);
               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) {
      *ms -= ast_tvdiff_ms(ast_tvnow(), start);
      if (*ms < 0)
         *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 1739 of file channel.c.

References ast_check_hangup(), AST_FLAG_ZOMBIE, AST_FRAME_DTMF, ast_frfree(), ast_read(), ast_test_flag, ast_waitfor(), ast_frame::frametype, result, and ast_frame::subclass.

Referenced by __ast_pbx_run(), _while_exec(), adsi_get_cpeid(), adsi_get_cpeinfo(), adsi_print(), adsi_read_encoded_dtmf(), adsi_transmit_message_full(), advanced_options(), ast_app_dtget(), ast_control_streamfile(), ast_readstring(), ast_record_review(), builtin_atxfer(), chanspy_exec(), cpeid_exec(), dialout(), directory_exec(), forward_message(), get_folder(), ivr_dispatch(), mgcp_ss(), my_getsigstr(), pbx_builtin_waitexten(), play_mailbox_owner(), play_record_review(), read_newoption(), retrydial_exec(), sendnoise(), skinny_ss(), ss_thread(), testclient_exec(), testserver_exec(), vm_execmain(), vm_forwardoptions(), vm_instructions(), vm_options(), vm_tempgreeting(), wait_a_bit(), and wait_our_turn().

{
   /* 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 (ast_test_flag(c, AST_FLAG_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 1786 of file channel.c.

References ast_check_hangup(), AST_CONTROL_ANSWER, AST_CONTROL_HANGUP, AST_CONTROL_RINGING, AST_FLAG_ZOMBIE, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_VOICE, ast_frfree(), ast_log(), ast_read(), ast_test_flag, ast_waitfor_nandfds(), ast_frame::data, ast_frame::datalen, ast_frame::frametype, LOG_WARNING, and ast_frame::subclass.

Referenced by ast_readstring_full(), handle_getoption(), and handle_waitfordigit().

{
   struct ast_frame *f;
   struct ast_channel *rchan;
   int outfd;
   int res;

   /* Stop if we're a zombie or need a soft hangup */
   if (ast_test_flag(c, AST_FLAG_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);
               break;
            }
            break;
         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 */
}

struct ast_channel* ast_walk_channel_by_name_prefix_locked	(	struct ast_channel *	chan,
		const char *	name,
		const int	namelen
	)			[read]

Get channel by name prefix (locks channel)

Definition at line 820 of file channel.c.

References channel_find_locked().

{
   return channel_find_locked(chan, name, namelen, NULL, NULL);
}

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 2257 of file channel.c.

References ast_channel::_softhangup, ast_check_hangup(), ast_clear_flag, ast_deactivate_generator(), ast_do_masquerade(), AST_FLAG_BLOCKING, AST_FLAG_WRITE_INT, AST_FLAG_ZOMBIE, AST_FRAME_CONTROL, AST_FRAME_DTMF, ast_frame_dump(), AST_FRAME_HTML, AST_FRAME_IAX, AST_FRAME_NULL, 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_test_flag, ast_translate(), ast_writestream(), CHECK_BLOCKING, ast_frame::data, ast_frame::datalen, do_senddigit(), ast_channel::fout, ast_frame::frametype, ast_channel::generatordata, ast_channel::insmpl, ast_channel::lock, LOG_DTMF, LOG_WARNING, ast_channel::masq, ast_channel::masqr, ast_channel::monitor, ast_channel::name, ast_channel::outsmpl, queue_frame_to_spies(), ast_frame::samples, SEEK_FORCECUR, ast_channel_tech::send_html, ast_channel_tech::send_text, ast_channel::spies, SPY_WRITE, ast_frame::subclass, ast_channel::tech, ast_channel_tech::write, ast_channel_monitor::write_stream, ast_channel_tech::write_video, and ast_channel::writetrans.

Referenced by adsi_careful_send(), agent_write(), ast_dtmf_stream(), ast_generic_bridge(), ast_prod(), ast_readaudio_callback(), ast_readvideo_callback(), ast_rtp_bridge(), ast_write_video(), conf_run(), dictate_exec(), echo_exec(), features_write(), function_ilink(), gen_generate(), handle_link_data(), iax2_bridge(), linear_generator(), milliwatt_generate(), misdn_bridge(), moh_files_generator(), moh_generate(), mp3_exec(), NBScat_exec(), playtones_generator(), rpt(), rpt_call(), rpt_exec(), send_link_dtmf(), send_tone_burst(), send_waveform_to_channel(), silence_generator_generate(), sms_generate(), spy_generate(), tonepair_generator(), wait_for_answer(), and zt_bridge().

{
   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 (ast_test_flag(chan, AST_FLAG_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 (ast_test_flag(chan, AST_FLAG_WRITE_INT))
         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:
      ast_clear_flag(chan, AST_FLAG_BLOCKING);
      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->tech->send_text)
         res = chan->tech->send_text(chan, (char *) fr->data);
      else
         res = 0;
      break;
   case AST_FRAME_HTML:
      if (chan->tech->send_html)
         res = chan->tech->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->tech->write_video)
         res = chan->tech->write_video(chan, fr);
      else
         res = 0;
      break;
   case AST_FRAME_NULL:
   case AST_FRAME_IAX:
      /* Ignore these */
      res = 0;
      break;
   default:
      if (chan->tech->write) {
         f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr;
         if (f) {
            if (f->frametype == AST_FRAME_VOICE && chan->spies)
               queue_frame_to_spies(chan, f, SPY_WRITE);

            if( chan->monitor && chan->monitor->write_stream &&
                  f && ( f->frametype == AST_FRAME_VOICE ) ) {
#ifndef MONITOR_CONSTANT_DELAY
               int jump = chan->insmpl - chan->outsmpl - 4 * f->samples;
               if (jump >= 0) {
                  jump = chan->insmpl - chan->outsmpl;
                  if (ast_seekstream(chan->monitor->write_stream, jump, 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 + 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");
            }

            res = chan->tech->write(chan, f);
         } else
            res = 0;
      }
   }

   /* It's possible this is a translated frame */
   if (f && f->frametype == AST_FRAME_DTMF) {
      ast_log(LOG_DTMF, "%s : %c\n", chan->name, f->subclass);
   } else if (fr->frametype == AST_FRAME_DTMF) {
      ast_log(LOG_DTMF, "%s : %c\n", chan->name, fr->subclass);
   }

   if (f && (f != fr))
      ast_frfree(f);
   ast_clear_flag(chan, AST_FLAG_BLOCKING);
   /* 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 2246 of file channel.c.

References ast_write(), ast_channel::tech, and ast_channel_tech::write_video.

{
   int res;
   if (!chan->tech->write_video)
      return 0;
   res = ast_write(chan, fr);
   if (!res)
      res = 1;
   return res;
}

static void bridge_playfile	(	struct ast_channel *	chan,
		struct ast_channel *	peer,
		char *	sound,
		int	remain
	)			[static]

Definition at line 3304 of file channel.c.

References ast_autoservice_start(), ast_autoservice_stop(), AST_DIGIT_ANY, ast_say_number(), ast_streamfile(), ast_waitstream(), and ast_channel::language.

Referenced by ast_channel_bridge().

{
   int res=0, min=0, sec=0,check=0;

   check = ast_autoservice_start(peer);
   if(check) 
      return;

   if (remain > 0) {
      if (remain / 60 > 1) {
         min = remain / 60;
         sec = remain % 60;
      } else {
         sec = remain;
      }
   }
   
   if (!strcmp(sound,"timeleft")) { /* Queue support */
      res = ast_streamfile(chan, "vm-youhave", chan->language);
      res = ast_waitstream(chan, "");
      if (min) {
         res = ast_say_number(chan, min, AST_DIGIT_ANY, chan->language, (char *) NULL);
         res = ast_streamfile(chan, "queue-minutes", chan->language);
         res = ast_waitstream(chan, "");
      }
      if (sec) {
         res = ast_say_number(chan, sec, AST_DIGIT_ANY, chan->language, (char *) NULL);
         res = ast_streamfile(chan, "queue-seconds", chan->language);
         res = ast_waitstream(chan, "");
      }
   } else {
      res = ast_streamfile(chan, sound, chan->language);
      res = ast_waitstream(chan, "");
   }

   check = ast_autoservice_stop(peer);
}

static struct ast_channel* channel_find_locked	(	const struct ast_channel *	prev,
		const char *	name,
		const int	namelen,
		const char *	context,
		const char *	exten
	)			[static, read]

Definition at line 733 of file channel.c.

References ast_log(), ast_mutex_lock(), ast_mutex_trylock(), ast_mutex_unlock(), channels, ast_channel::context, ast_channel::exten, ast_channel::lock, LOG_DEBUG, LOG_WARNING, ast_channel::macrocontext, ast_channel::macroexten, ast_channel::name, and ast_channel::next.

Referenced by ast_channel_walk_locked(), ast_get_channel_by_exten_locked(), ast_get_channel_by_name_locked(), ast_get_channel_by_name_prefix_locked(), and ast_walk_channel_by_name_prefix_locked().

{
   const char *msg = prev ? "deadlock" : "initial deadlock";
   int retries;
   struct ast_channel *c;

   for (retries = 0; retries < 10; retries++) {
      int done;

      ast_mutex_lock(&chlock);
      for (c = channels; c; c = c->next) {
         if (prev) { /* look for next item */
            if (c != prev) /* not this one */
               continue;
            /* found, prepare to return c->next */
            if ((c = c->next) == NULL) break;
            /* If prev was the last item on the channel list, then we just
             * want to return NULL, instead of trying to deref NULL in the
             * next section.
             */
         }
         if (name) { /* want match by name */
            if ((!namelen && strcasecmp(c->name, name)) ||
                (namelen && strncasecmp(c->name, name, namelen)))
               continue;   /* name match failed */
         } else if (exten) {
            if (context && strcasecmp(c->context, context) &&
                strcasecmp(c->macrocontext, context))
               continue;   /* context match failed */
            if (strcasecmp(c->exten, exten) &&
                strcasecmp(c->macroexten, exten))
               continue;   /* exten match failed */
         }
         /* if we get here, c points to the desired record */
         break;
      }
      /* exit if chan not found or mutex acquired successfully */
      done = (c == NULL) || (ast_mutex_trylock(&c->lock) == 0);
      /* this is slightly unsafe, as we _should_ hold the lock to access c->name */
      if (!done && c) {
         ast_log(LOG_DEBUG, "Avoiding %s for '%s'\n", msg, c->name);
         if (retries == 9) {
            /* We are about to fail due to a deadlock, so report this
             * while we still have the list lock.
             */
            ast_log(LOG_WARNING, "Avoided %s for '%p', %d retries!\n", msg, c, retries);
            /* As we have deadlocked, we will skip this channel and see if
             * there is another match.
             * NOTE: No point doing this for a full-name match, as there
             * can be no more matches.
             */
            if (!(name && !namelen)) {
               prev = c;
               retries = -1;
            }
         }
      }
      ast_mutex_unlock(&chlock);
      if (done)
         return c;
      usleep(1);
   }

   return NULL;
}

static void clone_variables	(	struct ast_channel *	original,
		struct ast_channel *	clone
	)			[static]

Definition at line 2944 of file channel.c.

References AST_LIST_APPEND_LIST, AST_LIST_FIRST, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_var_assign(), ast_var_t::name, ast_var_t::value, and ast_channel::varshead.

Referenced by ast_do_masquerade().

{
   struct ast_var_t *current, *newvar;
   /* Append variables from clone channel into original channel */
   /* XXX Is this always correct?  We have to in order to keep MACROS working XXX */
   if (AST_LIST_FIRST(&clone->varshead))
      AST_LIST_APPEND_LIST(&original->varshead, &clone->varshead, entries);
   AST_LIST_HEAD_INIT_NOLOCK(&clone->varshead);

   /* then, dup the varshead list into the clone */
   
   AST_LIST_TRAVERSE(&original->varshead, current, entries) {
      newvar = ast_var_assign(current->name, current->value);
      if (newvar)
         AST_LIST_INSERT_TAIL(&clone->varshead, newvar, entries);
   }
}

static void copy_data_from_queue	(	struct ast_channel_spy_queue *	queue,
		short *	buf,
		unsigned int	samples
	)			[static]

Definition at line 3983 of file channel.c.

References ast_codec_get_len(), ast_frfree(), ast_log(), ast_frame::data, ast_frame::datalen, ast_channel_spy_queue::format, ast_channel_spy_queue::head, LOG_ERROR, ast_frame::next, ast_frame::offset, ast_channel_spy_queue::samples, and ast_frame::samples.

Referenced by ast_channel_spy_read_frame().

{
   struct ast_frame *f;
   int tocopy;
   int bytestocopy;

   while (samples) {
      f = queue->head;

      if (!f) {
         ast_log(LOG_ERROR, "Ran out of frames before buffer filled!\n");
         break;
      }

      tocopy = (f->samples > samples) ? samples : f->samples;
      bytestocopy = ast_codec_get_len(queue->format, tocopy);
      memcpy(buf, f->data, bytestocopy);
      samples -= tocopy;
      buf += tocopy;
      f->samples -= tocopy;
      f->data += bytestocopy;
      f->datalen -= bytestocopy;
      f->offset += bytestocopy;
      queue->samples -= tocopy;
      if (!f->samples) {
         queue->head = f->next;
         ast_frfree(f);
      }
   }
}

static void detach_spies

(

struct ast_channel *

chan

)

[static]

Definition at line 1136 of file channel.c.

References AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_channel::spies, spy_cleanup(), and spy_detach().

Referenced by ast_hangup().

{
   struct ast_channel_spy *spy = NULL;

   if (!chan->spies)
      return;

   AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->spies->list, spy, list) {
      AST_LIST_REMOVE_CURRENT(&chan->spies->list, list);
      spy_detach(spy, chan);
   }
   AST_LIST_TRAVERSE_SAFE_END

   spy_cleanup(chan);
}

static int do_senddigit	(	struct ast_channel *	chan,
		char	digit
	)			[static]

Definition at line 2180 of file channel.c.

References ast_log(), ast_playtones_start(), LOG_DEBUG, ast_channel::name, ast_channel_tech::send_digit, and ast_channel::tech.

Referenced by ast_senddigit(), and ast_write().

{
   int res = -1;

   if (chan->tech->send_digit)
      res = chan->tech->send_digit(chan, digit);
   if (!chan->tech->send_digit || res) {
      /*
       * Device does not support DTMF tones, lets fake
       * it by doing our own generation. (PM2002)
       */
      static const char* dtmf_tones[] = {
         "!941+1336/100,!0/100", /* 0 */
         "!697+1209/100,!0/100", /* 1 */
         "!697+1336/100,!0/100", /* 2 */
         "!697+1477/100,!0/100", /* 3 */
         "!770+1209/100,!0/100", /* 4 */
         "!770+1336/100,!0/100", /* 5 */
         "!770+1477/100,!0/100", /* 6 */
         "!852+1209/100,!0/100", /* 7 */
         "!852+1336/100,!0/100", /* 8 */
         "!852+1477/100,!0/100", /* 9 */
         "!697+1633/100,!0/100", /* A */
         "!770+1633/100,!0/100", /* B */
         "!852+1633/100,!0/100", /* C */
         "!941+1633/100,!0/100", /* D */
         "!941+1209/100,!0/100", /* * */
         "!941+1477/100,!0/100" };  /* # */
      if (digit >= '0' && digit <='9')
         ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
      else if (digit >= 'A' && digit <= 'D')
         ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
      else if (digit == '*')
         ast_playtones_start(chan, 0, dtmf_tones[14], 0);
      else if (digit == '#')
         ast_playtones_start(chan, 0, dtmf_tones[15], 0);
      else {
         /* not handled */
         ast_log(LOG_DEBUG, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
      }
   }
   return 0;
}

static void free_cid

(

struct ast_callerid *

cid

)

[static]

Definition at line 871 of file channel.c.

References ast_callerid::cid_ani, ast_callerid::cid_dnid, ast_callerid::cid_name, ast_callerid::cid_num, ast_callerid::cid_rdnis, and free.

Referenced by ast_channel_free().

{
   if (cid->cid_dnid)
      free(cid->cid_dnid);
   if (cid->cid_num)
      free(cid->cid_num);  
   if (cid->cid_name)
      free(cid->cid_name); 
   if (cid->cid_ani)
      free(cid->cid_ani);
   if (cid->cid_rdnis)
      free(cid->cid_rdnis);
}

static void free_translation

(

struct ast_channel *

clone

)

[static]

Definition at line 1310 of file channel.c.

References ast_translator_free_path(), ast_channel::nativeformats, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel::readtrans, and ast_channel::writetrans.

Referenced by ast_do_masquerade(), and ast_hangup().

{
   if (clone->writetrans)
      ast_translator_free_path(clone->writetrans);
   if (clone->readtrans)
      ast_translator_free_path(clone->readtrans);
   clone->writetrans = NULL;
   clone->readtrans = NULL;
   clone->rawwriteformat = clone->nativeformats;
   clone->rawreadformat = clone->nativeformats;
}

static int generator_force

(

void *

data

)

[static]

Definition at line 1457 of file channel.c.

References ast_deactivate_generator(), ast_log(), ast_generator::generate, ast_channel::generator, ast_channel::generatordata, and LOG_DEBUG.

Referenced by ast_activate_generator(), and ast_read().

{
   /* Called if generator doesn't have data */
   void *tmp;
   int res;
   int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples);
   struct ast_channel *chan = data;
   tmp = chan->generatordata;
   chan->generatordata = NULL;
   generate = chan->generator->generate;
   res = generate(chan, tmp, 0, 160);
   chan->generatordata = tmp;
   if (res) {
      ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
      ast_deactivate_generator(chan);
   }
   return 0;
}

static void queue_frame_to_spies	(	struct ast_channel *	chan,
		struct ast_frame *	f,
		enum spy_direction	dir
	)			[static]

Definition at line 1185 of file channel.c.

References ast_clear_flag, ast_cond_signal(), AST_FORMAT_SLINEAR, ast_frdup(), ast_frfree(), ast_getformatname(), AST_LIST_TRAVERSE, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, ast_test_flag, ast_translate(), ast_translator_build_path(), ast_translator_free_path(), CHANSPY_RUNNING, CHANSPY_TRIGGER_FLUSH, CHANSPY_TRIGGER_MODE, CHANSPY_TRIGGER_NONE, CHANSPY_TRIGGER_READ, CHANSPY_TRIGGER_WRITE, ast_channel_spy_queue::format, ast_channel_spy_queue::head, last, channel_spy_trans::last_format, ast_channel_spy::lock, LOG_DEBUG, LOG_ERROR, LOG_WARNING, ast_channel::name, ast_frame::next, option_debug, channel_spy_trans::path, ast_channel_spy::read_queue, ast_channel_spy_list::read_translator, ast_frame::samples, ast_channel_spy_queue::samples, ast_channel::spies, SPY_QUEUE_SAMPLE_LIMIT, SPY_READ, SPY_WRITE, ast_channel_spy::status, ast_frame::subclass, ast_channel_spy::trigger, ast_channel_spy::type, ast_channel_spy::write_queue, and ast_channel_spy_list::write_translator.

Referenced by ast_read(), and ast_write().

{
   struct ast_frame *translated_frame = NULL;
   struct ast_channel_spy *spy;
   struct ast_channel_spy_queue *queue;
   struct channel_spy_trans *trans;
   struct ast_frame *last;

   trans = (dir == SPY_READ) ? &chan->spies->read_translator : &chan->spies->write_translator;

   AST_LIST_TRAVERSE(&chan->spies->list, spy, list) {
      if (spy->status != CHANSPY_RUNNING)
         continue;
      ast_mutex_lock(&spy->lock);

      queue = (dir == SPY_READ) ? &spy->read_queue : &spy->write_queue;

      if ((queue->format == AST_FORMAT_SLINEAR) && (f->subclass != AST_FORMAT_SLINEAR)) {
         if (!translated_frame) {
            if (trans->path && (trans->last_format != f->subclass)) {
               ast_translator_free_path(trans->path);
               trans->path = NULL;
            }
            if (!trans->path) {
               ast_log(LOG_DEBUG, "Building translator from %s to SLINEAR for spies on channel %s\n",
                  ast_getformatname(f->subclass), chan->name);
               if ((trans->path = ast_translator_build_path(AST_FORMAT_SLINEAR, f->subclass)) == NULL) {
                  ast_log(LOG_WARNING, "Cannot build a path from %s to %s\n",
                     ast_getformatname(f->subclass), ast_getformatname(AST_FORMAT_SLINEAR));
                  ast_mutex_unlock(&spy->lock);
                  continue;
               } else {
                  trans->last_format = f->subclass;
               }
            }
            if (!(translated_frame = ast_translate(trans->path, f, 0))) {
               ast_log(LOG_ERROR, "Translation to %s failed, dropping frame for spies\n",
                  ast_getformatname(AST_FORMAT_SLINEAR));
               ast_mutex_unlock(&spy->lock);
               break;
            }
         }

         for (last = queue->head; last && last->next; last = last->next);
         if (last)
            last->next = ast_frdup(translated_frame);
         else
            queue->head = ast_frdup(translated_frame);
      } else {
         if (f->subclass != queue->format) {
            ast_log(LOG_WARNING, "Spy '%s' on channel '%s' wants format '%s', but frame is '%s', dropping\n",
               spy->type, chan->name,
               ast_getformatname(queue->format), ast_getformatname(f->subclass));
            ast_mutex_unlock(&spy->lock);
            continue;
         }

         for (last = queue->head; last && last->next; last = last->next);
         if (last)
            last->next = ast_frdup(f);
         else
            queue->head = ast_frdup(f);
      }

      queue->samples += f->samples;

      if (queue->samples > SPY_QUEUE_SAMPLE_LIMIT) {
         if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE) {
            switch (ast_test_flag(spy, CHANSPY_TRIGGER_MODE)) {
            case CHANSPY_TRIGGER_READ:
               if (dir == SPY_WRITE) {
                  ast_set_flag(spy, CHANSPY_TRIGGER_WRITE);
                  ast_clear_flag(spy, CHANSPY_TRIGGER_READ);
                  if (option_debug)
                     ast_log(LOG_DEBUG, "Switching spy '%s' on '%s' to write-trigger mode\n",
                        spy->type, chan->name);
               }
               break;
            case CHANSPY_TRIGGER_WRITE:
               if (dir == SPY_READ) {
                  ast_set_flag(spy, CHANSPY_TRIGGER_READ);
                  ast_clear_flag(spy, CHANSPY_TRIGGER_WRITE);
                  if (option_debug)
                     ast_log(LOG_DEBUG, "Switching spy '%s' on '%s' to read-trigger mode\n",
                        spy->type, chan->name);
               }
               break;
            }
            if (option_debug)
               ast_log(LOG_DEBUG, "Triggering queue flush for spy '%s' on '%s'\n",
                  spy->type, chan->name);
            ast_set_flag(spy, CHANSPY_TRIGGER_FLUSH);
            ast_cond_signal(&spy->trigger);
         } else {
            if (option_debug)
               ast_log(LOG_DEBUG, "Spy '%s' on channel '%s' %s queue too long, dropping frames\n",
                  spy->type, chan->name, (dir == SPY_READ) ? "read" : "write");
            while (queue->samples > SPY_QUEUE_SAMPLE_LIMIT) {
               struct ast_frame *drop = queue->head;
               
               queue->samples -= drop->samples;
               queue->head = drop->next;
               ast_frfree(drop);
            }
         }
      } else {
         switch (ast_test_flag(spy, CHANSPY_TRIGGER_MODE)) {
         case CHANSPY_TRIGGER_READ:
            if (dir == SPY_READ)
               ast_cond_signal(&spy->trigger);
            break;
         case CHANSPY_TRIGGER_WRITE:
            if (dir == SPY_WRITE)
               ast_cond_signal(&spy->trigger);
            break;
         }
      }

      ast_mutex_unlock(&spy->lock);
   }

   if (translated_frame)
      ast_frfree(translated_frame);
}

static int set_format	(	struct ast_channel *	chan,
		int	fmt,
		int *	rawformat,
		int *	format,
		struct ast_trans_pvt **	trans,
		const int	direction
	)			[static]

Definition at line 2387 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_WARNING, ast_channel::name, ast_channel::nativeformats, and option_debug.

Referenced by ast_set_read_format(), and ast_set_write_format().

{
   int native;
   int res;
   
   native = chan->nativeformats;
   /* Find a translation path from the native format to one of the desired formats */
   if (!direction)
      /* reading */
      res = ast_translator_best_choice(&fmt, &native);
   else
      /* writing */
      res = ast_translator_best_choice(&native, &fmt);

   if (res < 0) {
      ast_log(LOG_WARNING, "Unable to find a codec translation path from %s to %s\n",
         ast_getformatname(native), ast_getformatname(fmt));
      return -1;
   }
   
   /* Now we have a good choice for both. */
   ast_mutex_lock(&chan->lock);

   if ((*rawformat == native) && (*format == fmt) && ((*rawformat == *format) || (*trans))) {
      /* the channel is already in these formats, so nothing to do */
      ast_mutex_unlock(&chan->lock);
      return 0;
   }

   *rawformat = native;
   /* User perspective is fmt */
   *format = fmt;
   /* Free any read translation we have right now */
   if (*trans)
      ast_translator_free_path(*trans);
   /* Build a translation path from the raw format to the desired format */
   if (!direction)
      /* reading */
      *trans = ast_translator_build_path(*format, *rawformat);
   else
      /* writing */
      *trans = ast_translator_build_path(*rawformat, *format);
   ast_mutex_unlock(&chan->lock);
   if (option_debug)
      ast_log(LOG_DEBUG, "Set channel %s to %s format %s\n", chan->name,
         direction ? "write" : "read", ast_getformatname(fmt));
   return 0;
}

static int show_channeltypes	(	int	fd,
		int	argc,
		char *	argv[]
	)			[static]

Definition at line 171 of file channel.c.

References ast_cli(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), backends, ast_channel_tech::description, ast_channel_tech::devicestate, FORMAT, ast_channel_tech::indicate, LOG_WARNING, chanlist::next, RESULT_SUCCESS, chanlist::tech, ast_channel_tech::transfer, and ast_channel_tech::type.

{
#define FORMAT  "%-10.10s  %-30.30s %-12.12s %-12.12s %-12.12s\n"
   struct chanlist *cl = backends;
   ast_cli(fd, FORMAT, "Type", "Description",       "Devicestate", "Indications", "Transfer");
   ast_cli(fd, FORMAT, "----------", "-----------", "-----------", "-----------", "--------");
   if (ast_mutex_lock(&chlock)) {
      ast_log(LOG_WARNING, "Unable to lock channel list\n");
      return -1;
   }
   while (cl) {
      ast_cli(fd, FORMAT, cl->tech->type, cl->tech->description, 
         (cl->tech->devicestate) ? "yes" : "no", 
         (cl->tech->indicate) ? "yes" : "no",
         (cl->tech->transfer) ? "yes" : "no");
      cl = cl->next;
   }
   ast_mutex_unlock(&chlock);
   return RESULT_SUCCESS;

#undef FORMAT

}

static void* silence_generator_alloc	(	struct ast_channel *	chan,
		void *	data
	)			[static]

Definition at line 4116 of file channel.c.

{
   /* just store the data pointer in the channel structure */
   return data;
}

static int silence_generator_generate	(	struct ast_channel *	chan,
		void *	data,
		int	len,
		int	samples
	)			[static]

Definition at line 4127 of file channel.c.

References AST_FORMAT_SLINEAR, AST_FRAME_VOICE, ast_write(), and ast_frame::frametype.

{
   if (samples == 160) {
      short buf[160] = { 0, };
      struct ast_frame frame = {
         .frametype = AST_FRAME_VOICE,
         .subclass = AST_FORMAT_SLINEAR,
         .data = buf,
         .samples = 160,
         .datalen = sizeof(buf),
      };

      if (ast_write(chan, &frame))
         return -1;
   } else {
      short buf[samples];
      int x;
      struct ast_frame frame = {
         .frametype = AST_FRAME_VOICE,
         .subclass = AST_FORMAT_SLINEAR,
         .data = buf,
         .samples = samples,
         .datalen = sizeof(buf),
      };

      for (x = 0; x < samples; x++)
         buf[x] = 0;

      if (ast_write(chan, &frame))
         return -1;
   }

   return 0;
}

static void silence_generator_release	(	struct ast_channel *	chan,
		void *	data
	)			[static]

Definition at line 4122 of file channel.c.

{
   /* nothing to do */
}

static void spy_cleanup

(

struct ast_channel *

chan

)

[static]

Definition at line 1034 of file channel.c.

References AST_LIST_FIRST, ast_translator_free_path(), free, channel_spy_trans::path, ast_channel_spy_list::read_translator, ast_channel::spies, and ast_channel_spy_list::write_translator.

Referenced by ast_channel_spy_remove(), ast_channel_spy_stop_by_type(), and detach_spies().

{
   if (AST_LIST_FIRST(&chan->spies->list))
      return;
   if (chan->spies->read_translator.path)
      ast_translator_free_path(chan->spies->read_translator.path);
   if (chan->spies->write_translator.path)
      ast_translator_free_path(chan->spies->write_translator.path);
   free(chan->spies);
   chan->spies = NULL;
   return;
}

static void spy_detach	(	struct ast_channel_spy *	spy,
		struct ast_channel *	chan
	)			[static]

Definition at line 1048 of file channel.c.

References ast_cond_signal(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_test_flag, ast_channel_spy::chan, CHANSPY_DONE, CHANSPY_STOP, CHANSPY_TRIGGER_MODE, CHANSPY_TRIGGER_NONE, ast_channel_spy::lock, LOG_DEBUG, ast_channel::name, ast_channel_spy::status, ast_channel_spy::trigger, and ast_channel_spy::type.

Referenced by ast_channel_spy_remove(), ast_channel_spy_stop_by_type(), and detach_spies().

{
   /* We only need to poke them if they aren't already done */
   if (spy->status != CHANSPY_DONE) {
      ast_mutex_lock(&spy->lock);
      spy->status = CHANSPY_STOP;
      spy->chan = NULL;
      if (ast_test_flag(spy, CHANSPY_TRIGGER_MODE) != CHANSPY_TRIGGER_NONE)
         ast_cond_signal(&spy->trigger);
      ast_mutex_unlock(&spy->lock);
   }
   
   /* Print it out while we still have a lock so the structure can't go away (if signalled above) */
   ast_log(LOG_DEBUG, "Spy %s removed from channel %s\n", spy->type, chan->name);

   return;
}

static void* tonepair_alloc	(	struct ast_channel *	chan,
		void *	params
	)			[static]

Definition at line 3755 of file channel.c.

References AST_FLAG_WRITE_INT, AST_FORMAT_SLINEAR, ast_log(), ast_set_flag, ast_set_write_format(), tonepair_def::duration, tonepair_state::duration, tonepair_def::freq1, tonepair_state::freq1, tonepair_def::freq2, tonepair_state::freq2, LOG_WARNING, malloc, ast_channel::name, tonepair_state::origwfmt, tonepair_release(), tonepair_def::vol, tonepair_state::vol, and ast_channel::writeformat.

{
   struct tonepair_state *ts;
   struct tonepair_def *td = params;

   ts = malloc(sizeof(struct tonepair_state));
   if (!ts)
      return NULL;
   memset(ts, 0, sizeof(struct tonepair_state));
   ts->origwfmt = chan->writeformat;
   if (ast_set_write_format(chan, AST_FORMAT_SLINEAR)) {
      ast_log(LOG_WARNING, "Unable to set '%s' to signed linear format (write)\n", chan->name);
      tonepair_release(NULL, ts);
      ts = NULL;
   } else {
      ts->freq1 = td->freq1;
      ts->freq2 = td->freq2;
      ts->duration = td->duration;
      ts->vol = td->vol;
   }
   /* Let interrupts interrupt :) */
   ast_set_flag(chan, AST_FLAG_WRITE_INT);
   return ts;
}

static int tonepair_generator	(	struct ast_channel *	chan,
		void *	data,
		int	len,
		int	samples
	)			[static]

Definition at line 3780 of file channel.c.

References AST_FORMAT_SLINEAR, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log(), ast_write(), ast_frame::data, tonepair_state::data, ast_frame::datalen, tonepair_state::duration, tonepair_state::f, ast_frame::frametype, tonepair_state::freq1, tonepair_state::freq2, LOG_WARNING, ast_frame::offset, tonepair_state::pos, ast_frame::samples, ast_frame::subclass, and tonepair_state::vol.

{
   struct tonepair_state *ts = data;
   int x;

   /* we need to prepare a frame with 16 * timelen samples as we're 
    * generating SLIN audio
    */
   len = samples * 2;

   if (len > sizeof(ts->data) / 2 - 1) {
      ast_log(LOG_WARNING, "Can't generate that much data!\n");
      return -1;
   }
   memset(&ts->f, 0, sizeof(ts->f));
   for (x = 0; x < (len / 2); x++) {
      ts->data[x] = ts->vol * (
            sin((ts->freq1 * 2.0 * M_PI / 8000.0) * (ts->pos + x)) +
            sin((ts->freq2 * 2.0 * M_PI / 8000.0) * (ts->pos + x))
         );
   }
   ts->f.frametype = AST_FRAME_VOICE;
   ts->f.subclass = AST_FORMAT_SLINEAR;
   ts->f.datalen = len;
   ts->f.samples = samples;
   ts->f.offset = AST_FRIENDLY_OFFSET;
   ts->f.data = ts->data;
   ast_write(chan, &ts->f);
   ts->pos += x;
   if (ts->duration > 0) {
      if (ts->pos >= ts->duration * 8)
         return -1;
   }
   return 0;
}

static void tonepair_release	(	struct ast_channel *	chan,
		void *	params
	)			[static]

Definition at line 3745 of file channel.c.

References ast_set_write_format(), free, and tonepair_state::origwfmt.

Referenced by tonepair_alloc().

{
   struct tonepair_state *ts = params;

   if (chan) {
      ast_set_write_format(chan, ts->origwfmt);
   }
   free(ts);
}

---

Variable Documentation

void(* ast_moh_cleanup_ptr)(struct ast_channel *) = NULL [static]

Referenced by ast_install_music_functions(), ast_moh_cleanup(), and ast_uninstall_music_functions().

int(* ast_moh_start_ptr)(struct ast_channel *, char *) = NULL [static]

Referenced by ast_install_music_functions(), ast_moh_start(), and ast_uninstall_music_functions().

void(* ast_moh_stop_ptr)(struct ast_channel *) = NULL [static]

Referenced by ast_install_music_functions(), ast_moh_stop(), and ast_uninstall_music_functions().

struct chanlist* backends = NULL [static]

Definition at line 109 of file channel.c.

Referenced by ast_channel_register(), ast_channel_unregister(), ast_get_channel_tech(), ast_request(), and show_channeltypes().

struct ast_cause causes[]

Referenced by ast_cause2str(), and dump_cause().

struct ast_channel* channels = NULL [static]

Definition at line 114 of file channel.c.

Referenced by add_channel(), ast_active_channels(), ast_begin_shutdown(), ast_channel_alloc(), ast_channel_free(), channel_find_locked(), check_header(), check_mute(), find_channel(), getvol(), load_config(), and setvol().

struct ast_cli_entry cli_show_channeltypes [static]

Initial value:

 
   { { "show", "channeltypes", NULL }, show_channeltypes, "Show available channel types", show_channeltypes_usage }

Definition at line 199 of file channel.c.

Referenced by ast_channels_init().

unsigned long global_fin = 0

Definition at line 100 of file channel.c.

Referenced by ast_channel_alloc().

unsigned long global_fout = 0

Definition at line 100 of file channel.c.

Referenced by ast_channel_alloc().

struct ast_channel_tech null_tech [static]

Initial value:

 {
   .type = "NULL",
   .description = "Null channel (should not see this)",
}

Definition at line 513 of file channel.c.

Referenced by ast_channel_alloc().

char show_channeltypes_usage[] [static]

Initial value:

 
"Usage: show channeltypes\n"
"       Shows available channel types registered in your Asterisk server.\n"

Definition at line 195 of file channel.c.

int shutting_down = 0 [static]

Definition at line 95 of file channel.c.

Referenced by ast_begin_shutdown(), ast_cancel_shutdown(), ast_channel_alloc(), and ast_shutting_down().

struct ast_generator silence_generator [static]

Initial value:

 {
   .alloc = silence_generator_alloc,
   .release = silence_generator_release,
   .generate = silence_generator_generate, 
}

Definition at line 4162 of file channel.c.

struct ast_generator tonepair [static]

Initial value:

 {
   alloc: tonepair_alloc,
   release: tonepair_release,
   generate: tonepair_generator,
}

Definition at line 3816 of file channel.c.

Referenced by ast_tonepair_start().

int uniqueint = 0 [static]

Definition at line 98 of file channel.c.

Referenced by ast_channel_alloc().