channel.h File Reference

#include <asterisk/frame.h>
#include <asterisk/sched.h>
#include <asterisk/chanvars.h>
#include <unistd.h>
#include <setjmp.h>
#include <sys/poll.h>
#include <asterisk/lock.h>
#include <asterisk/cdr.h>
#include <asterisk/monitor.h>

Include dependency graph for channel.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ast_generator
struct	ast_channel
	Main Channel structure associated with a channel. More...
struct	ast_bridge_config
struct	outgoing_helper
Defines
#define	AST_MAX_EXTENSION   80
	Max length of an extension.
#define	AST_CHANNEL_NAME   80
#define	AST_CHANNEL_MAX_STACK   32
#define	MAX_LANGUAGE   20
#define	AST_MAX_FDS   8
#define	AST_FLAG_DIGITAL   1
#define	LOAD_OH(oh)
#define	AST_CDR_TRANSFER   (1 << 0)
#define	AST_CDR_FORWARD   (1 << 1)
#define	AST_CDR_CALLWAIT   (1 << 2)
#define	AST_CDR_CONFERENCE   (1 << 3)
#define	AST_ADSI_UNKNOWN   (0)
#define	AST_ADSI_AVAILABLE   (1)
#define	AST_ADSI_UNAVAILABLE   (2)
#define	AST_ADSI_OFFHOOKONLY   (3)
#define	AST_SOFTHANGUP_DEV   (1 << 0)
#define	AST_SOFTHANGUP_ASYNCGOTO   (1 << 1)
#define	AST_SOFTHANGUP_SHUTDOWN   (1 << 2)
#define	AST_SOFTHANGUP_TIMEOUT   (1 << 3)
#define	AST_SOFTHANGUP_APPUNLOAD   (1 << 4)
#define	AST_SOFTHANGUP_EXPLICIT   (1 << 5)
#define	AST_STATE_DOWN   0
#define	AST_STATE_RESERVED   1
#define	AST_STATE_OFFHOOK   2
#define	AST_STATE_DIALING   3
#define	AST_STATE_RING   4
#define	AST_STATE_RINGING   5
#define	AST_STATE_UP   6
#define	AST_STATE_BUSY   7
#define	AST_STATE_DIALING_OFFHOOK   8
#define	AST_STATE_PRERING   9
#define	AST_STATE_MUTE   (1 << 16)
#define	AST_DEVICE_UNKNOWN   0
#define	AST_DEVICE_NOT_INUSE   1
#define	AST_DEVICE_INUSE   2
#define	AST_DEVICE_BUSY   3
#define	AST_DEVICE_INVALID   4
#define	AST_DEVICE_UNAVAILABLE   5
#define	AST_BRIDGE_DTMF_CHANNEL_0   (1 << 0)
#define	AST_BRIDGE_DTMF_CHANNEL_1   (1 << 1)
#define	AST_BRIDGE_REC_CHANNEL_0   (1 << 2)
#define	AST_BRIDGE_REC_CHANNEL_1   (1 << 3)
#define	AST_BRIDGE_IGNORE_SIGS   (1 << 4)
#define	CRASH   do { } while(0)
#define	CHECK_BLOCKING(c)
Functions
struct ast_channel *	ast_request (char *type, int format, void *data)
	Requests a channel.
int	ast_parse_device_state (char *device)
	Search the Channels by Name.
int	ast_device_state (char *device)
	Asks a channel for device state.
struct ast_channel *	ast_request_and_dial (char *type, int format, void *data, int timeout, int *reason, char *callerid)
struct ast_channel *	__ast_request_and_dial (char *type, int format, void *data, int timeout, int *reason, char *callerid, struct outgoing_helper *oh)
int	ast_channel_register (char *type, char *description, int capabilities, struct ast_channel *(*requester)(char *type, int format, void *data))
	Registers a channel.
int	ast_channel_register_ex (char *type, char *description, int capabilities, struct ast_channel *(*requester)(char *type, int format, void *data), int(*devicestate)(void *data))
void	ast_channel_unregister (char *type)
	Unregister a channel class.
int	ast_hangup (struct ast_channel *chan)
	Hang up a channel.
int	ast_softhangup (struct ast_channel *chan, int cause)
	Softly hangup up a channel.
int	ast_softhangup_nolock (struct ast_channel *chan, int cause)
int	ast_check_hangup (struct ast_channel *chan)
	Check to see if a channel is needing hang up.
void	ast_channel_setwhentohangup (struct ast_channel *chan, time_t offset)
	Set when to hang a channel up.
int	ast_answer (struct ast_channel *chan)
	Answer a ringing call.
int	ast_call (struct ast_channel *chan, char *addr, int timeout)
	Make a call.
int	ast_indicate (struct ast_channel *chan, int condition)
	Indicates condition of channel.
int	ast_waitfor (struct ast_channel *chan, int ms)
	Wait for input on a channel.
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.
struct ast_channel *	ast_waitfor_nandfds (struct ast_channel **chan, int n, int *fds, int nfds, int *exception, int *outfd, int *ms)
	Waits for activity on a group of channels.
struct ast_channel *	ast_waitfor_n (struct ast_channel **chan, int n, int *ms)
	Waits for input on a group of channels.
int	ast_waitfor_n_fd (int *fds, int n, int *ms, int *exception)
	Waits for input on an fd.
struct ast_frame *	ast_read (struct ast_channel *chan)
	Reads a frame.
int	ast_write (struct ast_channel *chan, struct ast_frame *frame)
	Write a frame to a channel.
int	ast_write_video (struct ast_channel *chan, struct ast_frame *frame)
	Write video frame to a channel.
int	ast_prod (struct ast_channel *chan)
int	ast_set_read_format (struct ast_channel *chan, int format)
	Sets read format on channel chan.
int	ast_set_write_format (struct ast_channel *chan, int format)
	Sets write format on channel chan.
int	ast_sendtext (struct ast_channel *chan, char *text)
	Sends text to a channel.
int	ast_senddigit (struct ast_channel *chan, char digit)
	Receives a text character from a channel.
int	ast_recvchar (struct ast_channel *chan, int timeout)
struct ast_channel *	ast_channel_walk_locked (struct ast_channel *prev)
	Browse channels in use.
struct ast_channel *	ast_get_channel_by_name_locked (char *channame)
	Get channel by name (locks channel).
int	ast_waitfordigit (struct ast_channel *c, int ms)
	Waits for a digit.
int	ast_waitfordigit_full (struct ast_channel *c, int ms, int audiofd, int ctrlfd)
int	ast_readstring (struct ast_channel *c, char *s, int len, int timeout, int rtimeout, char *enders)
	Reads multiple digits.
int	ast_readstring_full (struct ast_channel *c, char *s, int len, int timeout, int rtimeout, char *enders, int audiofd, int ctrlfd)
int	ast_channel_make_compatible (struct ast_channel *c0, struct ast_channel *c1)
	Makes two channel formats compatible.
int	ast_channel_bridge (struct ast_channel *c0, struct ast_channel *c1, struct ast_bridge_config *config, struct ast_frame **fo, struct ast_channel **rc)
	Bridge two channels together.
int	ast_channel_masquerade (struct ast_channel *original, struct ast_channel *clone)
	Weird function made for call transfers.
char *	ast_state2str (int state)
	Gives the string form of a given state.
int	ast_channel_setoption (struct ast_channel *channel, int option, void *data, int datalen, int block)
	Sets an option on a channel.
struct ast_frame *	ast_channel_queryoption (struct ast_channel *channel, int option, void *data, int *datalen, int block)
	Checks the value of an option.
int	ast_channel_supports_html (struct ast_channel *channel)
	Checks for HTML support on a channel.
int	ast_channel_sendhtml (struct ast_channel *channel, int subclass, char *data, int datalen)
	Sends HTML on given channel.
int	ast_channel_sendurl (struct ast_channel *channel, char *url)
	Sends a URL on a given link.
int	ast_channel_defer_dtmf (struct ast_channel *chan)
	Defers DTMF.
void	ast_channel_undefer_dtmf (struct ast_channel *chan)
	Undeos a defer.
void	ast_begin_shutdown (int hangup)
void	ast_cancel_shutdown (void)
int	ast_active_channels (void)
int	ast_shutting_down (void)
int	ast_activate_generator (struct ast_channel *chan, struct ast_generator *gen, void *params)
void	ast_deactivate_generator (struct ast_channel *chan)
void	ast_set_callerid (struct ast_channel *chan, char *callerid, int anitoo)
int	ast_tonepair_start (struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
void	ast_tonepair_stop (struct ast_channel *chan)
int	ast_tonepair (struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
int	ast_autoservice_start (struct ast_channel *chan)
int	ast_autoservice_stop (struct ast_channel *chan)
int	ast_settimeout (struct ast_channel *c, int samples, int(*func)(void *data), void *data)
int	ast_transfer (struct ast_channel *chan, char *dest)
int	ast_do_masquerade (struct ast_channel *chan)
unsigned int	ast_get_group (char *s)

---

Define Documentation

#define AST_ADSI_AVAILABLE   (1)

Definition at line 315 of file channel.h.

#define AST_ADSI_OFFHOOKONLY   (3)

Definition at line 317 of file channel.h.

#define AST_ADSI_UNAVAILABLE   (2)

Definition at line 316 of file channel.h.

#define AST_ADSI_UNKNOWN   (0)

Definition at line 314 of file channel.h.

#define AST_BRIDGE_DTMF_CHANNEL_0   (1 << 0)

Report DTMF on channel 0

Definition at line 669 of file channel.h.

#define AST_BRIDGE_DTMF_CHANNEL_1   (1 << 1)

Report DTMF on channel 1

Definition at line 671 of file channel.h.

#define AST_BRIDGE_IGNORE_SIGS   (1 << 4)

Ignore all signal frames except NULL

Definition at line 677 of file channel.h.

#define AST_BRIDGE_REC_CHANNEL_0   (1 << 2)

Return all voice frames on channel 0

Definition at line 673 of file channel.h.

#define AST_BRIDGE_REC_CHANNEL_1   (1 << 3)

Return all voice frames on channel 1

Definition at line 675 of file channel.h.

#define AST_CDR_CALLWAIT   (1 << 2)

Definition at line 311 of file channel.h.

#define AST_CDR_CONFERENCE   (1 << 3)

Definition at line 312 of file channel.h.

#define AST_CDR_FORWARD   (1 << 1)

Definition at line 310 of file channel.h.

#define AST_CDR_TRANSFER   (1 << 0)

Definition at line 309 of file channel.h.

#define AST_CHANNEL_MAX_STACK   32

Definition at line 42 of file channel.h.

#define AST_CHANNEL_NAME   80

Definition at line 41 of file channel.h.

#define AST_DEVICE_BUSY   3

Device is busy

Definition at line 359 of file channel.h.

#define AST_DEVICE_INUSE   2

Device is in use

Definition at line 357 of file channel.h.

#define AST_DEVICE_INVALID   4

Device is invalid

Definition at line 361 of file channel.h.

#define AST_DEVICE_NOT_INUSE   1

Device is not used

Definition at line 355 of file channel.h.

#define AST_DEVICE_UNAVAILABLE   5

Device is unavailable

Definition at line 363 of file channel.h.

#define AST_DEVICE_UNKNOWN   0

Device is valid but channel didn't know state

Definition at line 353 of file channel.h.

#define AST_FLAG_DIGITAL   1

Definition at line 240 of file channel.h.

#define AST_MAX_EXTENSION   80

Max length of an extension.

Definition at line 35 of file channel.h.

#define AST_MAX_FDS   8

Definition at line 47 of file channel.h.

#define AST_SOFTHANGUP_APPUNLOAD   (1 << 4)

Definition at line 323 of file channel.h.

#define AST_SOFTHANGUP_ASYNCGOTO   (1 << 1)

Definition at line 320 of file channel.h.

#define AST_SOFTHANGUP_DEV   (1 << 0)

Definition at line 319 of file channel.h.

#define AST_SOFTHANGUP_EXPLICIT   (1 << 5)

Definition at line 324 of file channel.h.

#define AST_SOFTHANGUP_SHUTDOWN   (1 << 2)

Definition at line 321 of file channel.h.

#define AST_SOFTHANGUP_TIMEOUT   (1 << 3)

Definition at line 322 of file channel.h.

#define AST_STATE_BUSY   7

Line is busy

Definition at line 342 of file channel.h.

#define AST_STATE_DIALING   3

Digits (or equivalent) have been dialed

Definition at line 334 of file channel.h.

#define AST_STATE_DIALING_OFFHOOK   8

Digits (or equivalent) have been dialed while offhook

Definition at line 344 of file channel.h.

#define AST_STATE_DOWN   0

Channel is down and available

Definition at line 328 of file channel.h.

#define AST_STATE_MUTE   (1 << 16)

Do not transmit voice data

Definition at line 350 of file channel.h.

#define AST_STATE_OFFHOOK   2

Channel is off hook

Definition at line 332 of file channel.h.

#define AST_STATE_PRERING   9

Channel has detected an incoming call and is waiting for ring

Definition at line 346 of file channel.h.

#define AST_STATE_RESERVED   1

Channel is down, but reserved

Definition at line 330 of file channel.h.

#define AST_STATE_RING   4

Line is ringing

Definition at line 336 of file channel.h.

#define AST_STATE_RINGING   5

Remote end is ringing

Definition at line 338 of file channel.h.

#define AST_STATE_UP   6

Line is up

Definition at line 340 of file channel.h.

#define CHECK_BLOCKING

(

c

)

Definition at line 883 of file channel.h.

#define CRASH   do { } while(0)

Definition at line 880 of file channel.h.

#define LOAD_OH

(

oh

)

Definition at line 291 of file channel.h.

#define MAX_LANGUAGE   20

Definition at line 44 of file channel.h.

---

Function Documentation

struct ast_channel* __ast_request_and_dial	(	char *	type,
		int	format,
		void *	data,
		int	timeout,
		int *	reason,
		char *	callerid,
		struct outgoing_helper *	oh
	)			[read]

Definition at line 1758 of file channel.c.

{
   int state = 0;
   struct ast_channel *chan;
   struct ast_frame *f;
   int res = 0;
   char *variable;
   chan = ast_request(type, format, data);
   if (chan) {
      if (oh) {
         char *tmp, *var;
         /* JDG chanvar */
         if (oh->variable)
            variable = ast_strdupa(oh->variable);
         else
            variable = NULL;
         tmp = variable;
         /* FIXME replace this call with strsep  NOT*/
         while( (var = strtok_r(NULL, "|", &tmp)) ) {
            pbx_builtin_setvar( chan, var );
         } /* /JDG */
         if (oh->callerid && *oh->callerid)
            ast_set_callerid(chan, oh->callerid, 1);
         if (oh->account && *oh->account)
            ast_cdr_setaccount(chan, oh->account);
      }
      if (callerid && !ast_strlen_zero(callerid))
         ast_set_callerid(chan, callerid, 1);

      if (!ast_call(chan, data, 0)) {
         while(timeout && (chan->_state != AST_STATE_UP)) {
            res = ast_waitfor(chan, timeout);
            if (res < 0) {
               /* Something not cool, or timed out */
               break;
            }
            /* If done, break out */
            if (!res)
               break;
            if (timeout > -1)
               timeout = res;
            f = ast_read(chan);
            if (!f) {
               state = AST_CONTROL_HANGUP;
               res = 0;
               break;
            }
            if (f->frametype == AST_FRAME_CONTROL) {
               if (f->subclass == AST_CONTROL_RINGING)
                  state = AST_CONTROL_RINGING;
               else if ((f->subclass == AST_CONTROL_BUSY) || (f->subclass == AST_CONTROL_CONGESTION)) {
                  state = f->subclass;
                  ast_frfree(f);
                  break;
               } else if (f->subclass == AST_CONTROL_ANSWER) {
                  state = f->subclass;
                  ast_frfree(f);
                  break;
               } else if (f->subclass == AST_CONTROL_PROGRESS) {
                  /* Ignore */
               } else if (f->subclass == -1) {
                  /* Ignore -- just stopping indications */
               } else {
                  ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass);
               }
            }
            ast_frfree(f);
         }
      } else
         ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
   } else
      ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
   if (chan) {
      /* Final fixups */
      if (oh) {
         if (oh->context && *oh->context)
            strncpy(chan->context, oh->context, sizeof(chan->context) - 1);
         if (oh->exten && *oh->exten)
            strncpy(chan->exten, oh->exten, sizeof(chan->exten) - 1);
         chan->priority = oh->priority;
      }
      if (chan->_state == AST_STATE_UP) 
         state = AST_CONTROL_ANSWER;
   }
   if (outstate)
      *outstate = state;
   if (chan && res <= 0) {
      if (!chan->cdr) {
         chan->cdr = ast_cdr_alloc();
         if (chan->cdr)
            ast_cdr_init(chan->cdr, chan);
      }
      if (chan->cdr) {
         char tmp[256];
         snprintf(tmp, 256, "%s/%s", type, (char *)data);
         ast_cdr_setapp(chan->cdr,"Dial",tmp);
         ast_cdr_update(chan);
         ast_cdr_start(chan->cdr);
         ast_cdr_end(chan->cdr);
         /* If the cause wasn't handled properly */
         if (ast_cdr_disposition(chan->cdr,chan->hangupcause))
            ast_cdr_failed(chan->cdr);
      } else 
         ast_log(LOG_WARNING, "Unable to create Call Detail Record\n");
      ast_hangup(chan);
      chan = NULL;
   }
   return chan;
}

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

Activate a given generator

Definition at line 849 of file channel.c.

{
   int res = 0;
   ast_mutex_lock(&chan->lock);
   if (chan->generatordata) {
      if (chan->generator && chan->generator->release)
         chan->generator->release(chan, chan->generatordata);
      chan->generatordata = NULL;
   }
   ast_prod(chan);
   if ((chan->generatordata = gen->alloc(chan, params))) {
      ast_settimeout(chan, 160, generator_force, chan);
      chan->generator = gen;
   } else {
      res = -1;
   }
   ast_mutex_unlock(&chan->lock);
   return res;
}

int ast_active_channels

(

void

)

Returns number of active/allocated channels

Definition at line 120 of file channel.c.

{
   struct ast_channel *c;
   int cnt = 0;
   ast_mutex_lock(&chlock);
   c = channels;
   while(c) {
      cnt++;
      c = c->next;
   }
   ast_mutex_unlock(&chlock);
   return cnt;
}

int ast_answer

(

struct ast_channel *

chan

)

Answer a ringing call.

Parameters:

chan

channel to answer This function answers a channel and handles all necessary call setup functions. Returns 0 on success, -1 on failure

Definition at line 785 of file channel.c.

{
   int res = 0;
   ast_mutex_lock(&chan->lock);
   /* Stop if we're a zombie or need a soft hangup */
   if (chan->zombie || ast_check_hangup(chan)) {
      ast_mutex_unlock(&chan->lock);
      return -1;
   }
   switch(chan->_state) {
   case AST_STATE_RINGING:
   case AST_STATE_RING:
      if (chan->pvt->answer)
         res = chan->pvt->answer(chan);
      ast_setstate(chan, AST_STATE_UP);
      if (chan->cdr)
         ast_cdr_answer(chan->cdr);
      ast_mutex_unlock(&chan->lock);
      return res;
      break;
   case AST_STATE_UP:
      if (chan->cdr)
         ast_cdr_answer(chan->cdr);
      break;
   }
   ast_mutex_unlock(&chan->lock);
   return 0;
}

int ast_autoservice_start

(

struct ast_channel *

chan

)

Automatically service a channel for us...

Definition at line 88 of file autoservice.c.

{
   int res = -1;
   struct asent *as;
   int needstart;
   ast_mutex_lock(&autolock);
   needstart = (asthread == AST_PTHREADT_NULL) ? 1 : 0 /* aslist ? 0 : 1 */;
   as = aslist;
   while(as) {
      if (as->chan == chan)
         break;
      as = as->next;
   }
   if (!as) {
      as = malloc(sizeof(struct asent));
      if (as) {
         memset(as, 0, sizeof(struct asent));
         as->chan = chan;
         as->next = aslist;
         aslist = as;
         res = 0;
         if (needstart) {
            if (ast_pthread_create(&asthread, NULL, autoservice_run, NULL)) {
               ast_log(LOG_WARNING, "Unable to create autoservice thread :(\n");
               free(aslist);
               aslist = NULL;
               res = -1;
            } else
               pthread_kill(asthread, SIGURG);
         }
      }
   }
   ast_mutex_unlock(&autolock);
   return res;
}

int ast_autoservice_stop

(

struct ast_channel *

chan

)

Stop servicing a channel for us... Returns -1 on error or if channel has been hungup

Definition at line 124 of file autoservice.c.

{
   int res = -1;
   struct asent *as, *prev;
   ast_mutex_lock(&autolock);
   as = aslist;
   prev = NULL;
   while(as) {
      if (as->chan == chan)
         break;
      prev = as;
      as = as->next;
   }
   if (as) {
      if (prev)
         prev->next = as->next;
      else
         aslist = as->next;
      free(as);
      if (!chan->_softhangup)
         res = 0;
   }
   if (asthread != AST_PTHREADT_NULL) 
      pthread_kill(asthread, SIGURG);
   ast_mutex_unlock(&autolock);
   /* Wait for it to un-block */
   while(chan->blocking)
      usleep(1000);
   return res;
}

void ast_begin_shutdown

(

int

hangup

)

Initiate system shutdown -- prevents new channels from being allocated. If "hangup" is non-zero, all existing channels will receive soft hangups

Definition at line 105 of file channel.c.

{
   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_call	(	struct ast_channel *	chan,
		char *	addr,
		int	timeout
	)

Make a call.

Parameters:

	chan	which channel to make the call on
	addr	destination of the call
	timeout	time to wait on for connect Place a call, take no longer than timeout ms. Returns -1 on failure, 0 on not enough time (does not auto matically stop ringing), and the number of seconds the connect took otherwise. Returns 0 on success, -1 on failure

Definition at line 1977 of file channel.c.

{
   /* Place an outgoing call, but don't wait any longer than timeout ms before returning. 
      If the remote end does not answer within the timeout, then do NOT hang up, but 
      return anyway.  */
   int res = -1;
   /* Stop if we're a zombie or need a soft hangup */
   ast_mutex_lock(&chan->lock);
   if (!chan->zombie && !ast_check_hangup(chan)) 
      if (chan->pvt->call)
         res = chan->pvt->call(chan, addr, timeout);
   ast_mutex_unlock(&chan->lock);
   return res;
}

void ast_cancel_shutdown

(

void

)

Cancels an existing shutdown and returns to normal operation

Definition at line 134 of file channel.c.

{
   shutting_down = 0;
}

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

Bridge two channels together.

Parameters:

	c0	first channel to bridge
	c1	second channel to bridge
	flags	for the channels
	fo	destination frame(?)
	rc	destination channel(?) Bridge two channels (c0 and c1) together. If an important frame occurs, we return that frame in rf (remember, it could be NULL) and which channel (0 or 1) in rc

Definition at line 2523 of file channel.c.

{
   /* Copy voice back and forth between the two channels.   Give the peer
      the ability to transfer calls with '#<extension' syntax. */
   int flags;
   struct ast_channel *cs[3];
   int to = -1;
   struct ast_frame *f;
   struct ast_channel *who = NULL;
   int res=0;
   int nativefailed=0;
   int firstpass;
   int o0nativeformats;
   int o1nativeformats;
   struct timeval start_time,precise_now;
   long elapsed_ms=0, time_left_ms=0;
   int playit=0, playitagain=1, first_time=1;

   flags = (config->allowdisconnect_out||config->allowredirect_out ? AST_BRIDGE_DTMF_CHANNEL_0 : 0) + (config->allowdisconnect_in||config->allowredirect_in ? AST_BRIDGE_DTMF_CHANNEL_1 : 0);

   firstpass = config->firstpass;
   config->firstpass = 0;

   /* timestamp */
   gettimeofday(&start_time,NULL);
   time_left_ms = config->timelimit;

   if (config->play_to_caller && config->start_sound && firstpass)
      bridge_playfile(c0,c1,config->start_sound,time_left_ms / 1000);
   if (config->play_to_callee && config->start_sound && firstpass)
      bridge_playfile(c1,c0,config->start_sound,time_left_ms / 1000);

   /* Stop if we're a zombie or need a soft hangup */
   if (c0->zombie || ast_check_hangup_locked(c0) || c1->zombie || ast_check_hangup_locked(c1)) 
      return -1;
   if (c0->bridge) {
      ast_log(LOG_WARNING, "%s is already in a bridge with %s\n", 
         c0->name, c0->bridge->name);
      return -1;
   }
   if (c1->bridge) {
      ast_log(LOG_WARNING, "%s is already in a bridge with %s\n", 
         c1->name, c1->bridge->name);
      return -1;
   }
   
   /* Keep track of bridge */
   c0->bridge = c1;
   c1->bridge = c0;
   cs[0] = c0;
   cs[1] = c1;
   
   manager_event(EVENT_FLAG_CALL, "Link", 
         "Channel1: %s\r\n"
         "Channel2: %s\r\n"
         "Uniqueid1: %s\r\n"
         "Uniqueid2: %s\r\n",
         c0->name, c1->name, c0->uniqueid, c1->uniqueid);
   o1nativeformats = c1->nativeformats;
   o0nativeformats = c0->nativeformats;
   for (/* ever */;;) {
      /* timestamp */
      if (config->timelimit) {
         gettimeofday(&precise_now,NULL);
         elapsed_ms = tvdiff(&precise_now,&start_time);
         time_left_ms = config->timelimit - elapsed_ms;

         if (playitagain && (config->play_to_caller || config->play_to_callee) && (config->play_warning && time_left_ms <= config->play_warning)) { 
            /* narrowing down to the end */
            if (config->warning_freq == 0) {
               playit = 1;
               first_time=0;
               playitagain=0;
            } else if (first_time) {
               playit = 1;
               first_time=0;
            } else {
               if ((time_left_ms % config->warning_freq) <= 50) {
                  playit = 1;
               }
            }
         }
         if (time_left_ms <= 0) {
            if (config->play_to_caller && config->end_sound)
               bridge_playfile(c0,c1,config->end_sound,0);
            if (config->play_to_callee && config->end_sound)
               bridge_playfile(c1,c0,config->end_sound,0);
            *fo = NULL;
            if (who) *rc = who;
            res = 0;
            break;
         }
         if (time_left_ms >= 5000 && playit) {
            if (config->play_to_caller && config->warning_sound && config->play_warning)
               bridge_playfile(c0,c1,config->warning_sound,time_left_ms / 1000);
            if (config->play_to_callee && config->warning_sound && config->play_warning)
               bridge_playfile(c1,c0,config->warning_sound,time_left_ms / 1000);
            playit = 0;
         }
         
      }
      /* Stop if we're a zombie or need a soft hangup */
      if (c0->zombie || ast_check_hangup_locked(c0) || c1->zombie || ast_check_hangup_locked(c1)) {
         *fo = NULL;
         if (who) *rc = who;
         res = 0;
         ast_log(LOG_DEBUG, "Bridge stops because we're zombie or need a soft hangup: c0=%s, c1=%s, flags: %s,%s,%s,%s\n",c0->name,c1->name,c0->zombie?"Yes":"No",ast_check_hangup(c0)?"Yes":"No",c1->zombie?"Yes":"No",ast_check_hangup(c1)?"Yes":"No");
         break;
      }
      if (c0->pvt->bridge && config->timelimit==0 &&
         (c0->pvt->bridge == c1->pvt->bridge) && !nativefailed && !c0->monitor && !c1->monitor) {
            /* Looks like they share a bridge code */
         if (option_verbose > 2) 
            ast_verbose(VERBOSE_PREFIX_3 "Attempting native bridge of %s and %s\n", c0->name, c1->name);
         if (!(res = c0->pvt->bridge(c0, c1, flags, fo, rc))) {
            c0->bridge = NULL;
            c1->bridge = NULL;
            manager_event(EVENT_FLAG_CALL, "Unlink", 
               "Channel1: %s\r\n"
               "Channel2: %s\r\n"
               "Uniqueid1: %s\r\n"
               "Uniqueid2: %s\r\n",
               c0->name, c1->name, c0->uniqueid, c1->uniqueid);
            ast_log(LOG_DEBUG, "Returning from native bridge, channels: %s, %s\n",c0->name ,c1->name);
            return 0;
         }
         /* If they return non-zero then continue on normally.  Let "-2" mean don't worry about
            my not wanting to bridge */
         if ((res != -2) && (res != -3))
            ast_log(LOG_WARNING, "Private bridge between %s and %s failed\n", c0->name, c1->name);
         if (res != -3) nativefailed++;
      }
   
      if (((c0->writeformat != c1->readformat) || (c0->readformat != c1->writeformat) || (c0->nativeformats != o0nativeformats) || (c1->nativeformats != o1nativeformats)) &&
         !(c0->generator || c1->generator))  {
         if (ast_channel_make_compatible(c0, c1)) {
            ast_log(LOG_WARNING, "Can't make %s and %s compatible\n", c0->name, c1->name);
            manager_event(EVENT_FLAG_CALL, "Unlink", 
               "Channel1: %s\r\n"
               "Channel2: %s\r\n"
               "Uniqueid1: %s\r\n"
               "Uniqueid2: %s\r\n",
               c0->name, c1->name, c0->uniqueid, c1->uniqueid);
            return -1;
         }
         o0nativeformats = c0->nativeformats;
         o1nativeformats = c1->nativeformats;
      }
      who = ast_waitfor_n(cs, 2, &to);
      if (!who) {
         ast_log(LOG_DEBUG, "Nobody there, continuing...\n"); 
         continue;
      }
      f = ast_read(who);
      if (!f) {
         *fo = NULL;
         *rc = who;
         res = 0;
         ast_log(LOG_DEBUG, "Didn't get a frame from channel: %s\n",who->name);
         break;
      }

      if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
         *fo = f;
         *rc = who;
         res =  0;
         ast_log(LOG_DEBUG, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f->subclass, who->name);
         break;
      }
      if ((f->frametype == AST_FRAME_VOICE) ||
         (f->frametype == AST_FRAME_TEXT) ||
         (f->frametype == AST_FRAME_VIDEO) || 
         (f->frametype == AST_FRAME_IMAGE) ||
         (f->frametype == AST_FRAME_HTML) ||
         (f->frametype == AST_FRAME_DTMF)) {
         if ((f->frametype == AST_FRAME_DTMF) && 
            (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))) {
            if ((who == c0)) {
               if  ((flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
                  *rc = c0;
                  *fo = f;
                  /* Take out of conference mode */
                  res = 0;
                  ast_log(LOG_DEBUG, "Got AST_BRIDGE_DTMF_CHANNEL_0 on c0 (%s)\n",c0->name);
                  break;
               } else 
                  goto tackygoto;
            } else
            if ((who == c1)) {
               if (flags & AST_BRIDGE_DTMF_CHANNEL_1) {
                  *rc = c1;
                  *fo = f;
                  res =  0;
                  ast_log(LOG_DEBUG, "Got AST_BRIDGE_DTMF_CHANNEL_1 on c1 (%s)\n",c1->name);
                  break;
               } else
                  goto tackygoto;
            }
         } else {
#if 0
            ast_log(LOG_DEBUG, "Read from %s\n", who->name);
            if (who == last) 
               ast_log(LOG_DEBUG, "Servicing channel %s twice in a row?\n", last->name);
            last = who;
#endif
tackygoto:
            /* Don't copy packets if there is a generator on either one, since they're
               not supposed to be listening anyway */
            if (who == c0) 
               ast_write(c1, f);
            else 
               ast_write(c0, f);
         }
         ast_frfree(f);
      } else
         ast_frfree(f);
      /* Swap who gets priority */
      cs[2] = cs[0];
      cs[0] = cs[1];
      cs[1] = cs[2];
   }
   c0->bridge = NULL;
   c1->bridge = NULL;
   manager_event(EVENT_FLAG_CALL, "Unlink", 
               "Channel1: %s\r\n"
               "Channel2: %s\r\n"
               "Uniqueid1: %s\r\n"
               "Uniqueid2: %s\r\n",
               c0->name, c1->name, c0->uniqueid, c1->uniqueid);
   ast_log(LOG_DEBUG, "Bridge stops bridging channels %s and %s\n",c0->name,c1->name);
   return res;
}

int ast_channel_defer_dtmf

(

struct ast_channel *

chan

)

Defers DTMF.

Defer DTMF so that you only read things like hangups and audio. Returns non-zero if channel was already DTMF-deferred or 0 if channel is just now being DTMF-deferred

Definition at line 441 of file channel.c.

{
   int pre = 0;
   if (chan) {
      pre = chan->deferdtmf;
      chan->deferdtmf = 1;
   }
   return pre;
}

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

Makes two channel formats compatible.

Parameters:

	c0	first channel to make compatible
	c1	other channel to make compatible Set two channels to compatible formats -- call before ast_channel_bridge in general . Returns 0 on success and -1 if it could not be done

Definition at line 2114 of file channel.c.

{
   int peerf;
   int chanf;
   int res;
   ast_mutex_lock(&peer->lock);
   peerf = peer->nativeformats;
   ast_mutex_unlock(&peer->lock);
   ast_mutex_lock(&chan->lock);
   chanf = chan->nativeformats;
   ast_mutex_unlock(&chan->lock);
   res = ast_translator_best_choice(&peerf, &chanf);
   if (res < 0) {
      ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", chan->name, chan->nativeformats, peer->name, peer->nativeformats);
      return -1;
   }
   /* Set read format on channel */
   res = ast_set_read_format(chan, peerf);
   if (res < 0) {
      ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", chan->name, chanf);
      return -1;
   }
   /* Set write format on peer channel */
   res = ast_set_write_format(peer, peerf);
   if (res < 0) {
      ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", peer->name, peerf);
      return -1;
   }
   /* Now we go the other way */
   peerf = peer->nativeformats;
   chanf = chan->nativeformats;
   res = ast_translator_best_choice(&chanf, &peerf);
   if (res < 0) {
      ast_log(LOG_WARNING, "No path to translate from %s(%d) to %s(%d)\n", peer->name, peer->nativeformats, chan->name, chan->nativeformats);
      return -1;
   }
   /* Set writeformat on channel */
   res = ast_set_write_format(chan, chanf);
   if (res < 0) {
      ast_log(LOG_WARNING, "Unable to set write format on channel %s to %d\n", chan->name, chanf);
      return -1;
   }
   /* Set read format on peer channel */
   res = ast_set_read_format(peer, chanf);
   if (res < 0) {
      ast_log(LOG_WARNING, "Unable to set read format on channel %s to %d\n", peer->name, peerf);
      return -1;
   }
   return 0;
}

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

Weird function made for call transfers.

Parameters:

	original	channel to make a copy of
	clone	copy of the original channel This is a very strange and freaky function used primarily for transfer. Suppose that "original" and "clone" are two channels in random situations. This function takes the guts out of "clone" and puts them into the "original" channel, then alerts the channel driver of the change, asking it to fixup any private information (like the p->owner pointer) that is affected by the change. The physical layer of the original channel is hung up.

Definition at line 2165 of file channel.c.

{
   struct ast_frame null = { AST_FRAME_NULL, };
   int res = -1;
   ast_mutex_lock(&original->lock);
   while(ast_mutex_trylock(&clone->lock)) {
      ast_mutex_unlock(&original->lock);
      usleep(1);
      ast_mutex_lock(&original->lock);
   }
   ast_log(LOG_DEBUG, "Planning to masquerade %s into the structure of %s\n",
      clone->name, original->name);
   if (original->masq) {
      ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n", 
         original->masq->name, original->name);
   } else if (clone->masqr) {
      ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n", 
         clone->name, clone->masqr->name);
   } else {
      original->masq = clone;
      clone->masqr = original;
      ast_queue_frame(original, &null);
      ast_queue_frame(clone, &null);
      ast_log(LOG_DEBUG, "Done planning to masquerade %s into the structure of %s\n", original->name, clone->name);
      res = 0;
   }
   ast_mutex_unlock(&clone->lock);
   ast_mutex_unlock(&original->lock);
   return res;
}

struct ast_frame* ast_channel_queryoption	(	struct ast_channel *	channel,
		int	option,
		void *	data,
		int *	datalen,
		int	block
	)			[read]

Checks the value of an option.

Query the value of an option, optionally blocking until a reply is received Works similarly to setoption except only reads the options.

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

Registers a channel.

Parameters:

	type	type of channel you are registering
	description	short description of the channel
	capabilities	a bit mask of the capabilities of the channel
	requester	a function pointer that properly responds to a call. See one of the channel drivers for details. Called by a channel module to register the kind of channels it supports. It supplies a brief type, a longer, but still short description, and a routine that creates a channel Returns 0 on success, -1 on failure.

Definition at line 156 of file channel.c.

{
   return ast_channel_register_ex(type, description, capabilities, requester, NULL);
}

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

Definition at line 162 of file channel.c.

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

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

Sends HTML on given channel.

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

Definition at line 2100 of file channel.c.

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

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

Sends a URL on a given link.

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

Definition at line 2107 of file channel.c.

{
   if (chan->pvt->send_html)
      return chan->pvt->send_html(chan, AST_HTML_URL, url, strlen(url) + 1);
   return -1;
}

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

Sets an option on a channel.

Parameters:

	channel	channel to set options on
	option	option to change
	data	data specific to option
	datalen	length of the data
	block	blocking or not Set an option on a channel (see frame.h), optionally blocking awaiting the reply Returns 0 on success and -1 on failure

Definition at line 2756 of file channel.c.

{
   int res;
   if (chan->pvt->setoption) {
      res = chan->pvt->setoption(chan, option, data, datalen);
      if (res < 0)
         return res;
   } else {
      errno = ENOSYS;
      return -1;
   }
   if (block) {
      /* XXX Implement blocking -- just wait for our option frame reply, discarding
         intermediate packets. XXX */
      ast_log(LOG_ERROR, "XXX Blocking not implemented yet XXX\n");
      return -1;
   }
   return 0;
}

void ast_channel_setwhentohangup	(	struct ast_channel *	chan,
		time_t	offset
	)

Set when to hang a channel up.

Parameters:

	chan	channel on which to check for hang up
	offset	offset in seconds from current time of when to hang up This function sets the absolute time out on a channel (when to hang up).

Definition at line 144 of file channel.c.

{
   time_t   myt;

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

int ast_channel_supports_html

(

struct ast_channel *

channel

)

Checks for HTML support on a channel.

Returns 0 if channel does not support HTML or non-zero if it does

Definition at line 2093 of file channel.c.

{
   if (chan->pvt->send_html)
      return 1;
   return 0;
}

void ast_channel_undefer_dtmf

(

struct ast_channel *

chan

)

Undeos a defer.

Undo defer. ast_read will return any dtmf characters that were queued

Definition at line 451 of file channel.c.

{
   if (chan)
      chan->deferdtmf = 0;
}

void ast_channel_unregister

(

char *

type

)

Unregister a channel class.

Definition at line 756 of file channel.c.

{
   struct chanlist *chan, *last=NULL;
   if (option_debug)
      ast_log(LOG_DEBUG, "Unregistering channel type '%s'\n", type);
   if (ast_mutex_lock(&chlock)) {
      ast_log(LOG_WARNING, "Unable to lock channel list\n");
      return;
   }
   if (option_verbose > 1)
      ast_verbose( VERBOSE_PREFIX_2 "Unregistered channel type '%s'\n", type);

   chan = backends;
   while(chan) {
      if (!strcasecmp(chan->type, type)) {
         if (last)
            last->next = chan->next;
         else
            backends = backends->next;
         free(chan);
         ast_mutex_unlock(&chlock);
         return;
      }
      last = chan;
      chan = chan->next;
   }
   ast_mutex_unlock(&chlock);
}

struct ast_channel* ast_channel_walk_locked

(

struct ast_channel *

prev

)

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

{
   /* Returns next channel (locked) */
   struct ast_channel *l, *ret;
   int retries = 0;  
retry:
   ret=NULL;
   ast_mutex_lock(&chlock);
   l = channels;
   if (!prev) {
      if (l) {
         if (ast_mutex_trylock(&l->lock)) {
            if (retries < 10)
               ast_log(LOG_DEBUG, "Avoiding initial deadlock for '%s'\n", l->name);
            else
               ast_log(LOG_WARNING, "Avoided initial deadlock for '%s', %d retries!\n", l->name, retries);
            ast_mutex_unlock(&chlock);
            if (retries < 10) {
               usleep(1);
               retries++;
               goto retry;
            } else
               return NULL;
         }
      }
      ast_mutex_unlock(&chlock);
      return l;
   }
   while(l) {
      if (l == prev)
         ret = l->next;
      l = l->next;
   }
   if (ret) {
      if (ast_mutex_trylock(&ret->lock)) {
         if (retries < 10)
            ast_log(LOG_DEBUG, "Avoiding deadlock for '%s'\n", ret->name);
         else
            ast_log(LOG_WARNING, "Avoided deadlock for '%s', %d retries!\n", ret->name, retries);
         ast_mutex_unlock(&chlock);
         if (retries < 10) {
            usleep(1);
            retries++;
            goto retry;
         } else
            return NULL;
      }
   }
   ast_mutex_unlock(&chlock);
   return ret;
   
}

int ast_check_hangup

(

struct ast_channel *

chan

)

Check to see if a channel is needing hang up.

Parameters:

chan

channel on which to check for hang up This function determines if the channel is being requested to be hung up. Returns 0 if not, or 1 if hang up is requested (including time-out).

Definition at line 79 of file channel.c.

{
time_t   myt;

     /* if soft hangup flag, return true */
   if (chan->_softhangup) return 1;
     /* if no private structure, return true */
   if (!chan->pvt->pvt) return 1;
     /* if no hangup scheduled, just return here */
   if (!chan->whentohangup) return 0;
   time(&myt); /* get current time */
     /* return, if not yet */
   if (chan->whentohangup > myt) return 0;
   chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
   return 1;
}

void ast_deactivate_generator

(

struct ast_channel *

chan

)

Deactive an active generator

Definition at line 816 of file channel.c.

{
   ast_mutex_lock(&chan->lock);
   if (chan->generatordata) {
      if (chan->generator && chan->generator->release) 
         chan->generator->release(chan, chan->generatordata);
      chan->generatordata = NULL;
      chan->generator = NULL;
      chan->writeinterrupt = 0;
      ast_settimeout(chan, 0, NULL, NULL);
   }
   ast_mutex_unlock(&chan->lock);
}

int ast_device_state

(

char *

device

)

Asks a channel for device state.

Parameters:

device

like a dialstring Asks a channel for device state, data is normaly a number from dialstring used by the low level module Trys the channel devicestate callback if not supported search in the active channels list for the device. Returns an AST_DEVICE_??? state -1 on failure

Definition at line 1938 of file channel.c.

{
   char tech[AST_MAX_EXTENSION] = "";
   char *number;
   struct chanlist *chanls;
   int res = 0;
   
   strncpy(tech, device, sizeof(tech)-1);
   number = strchr(tech, '/');
   if (!number) {
       return AST_DEVICE_INVALID;
   }
   *number = 0;
   number++;
      
   if (ast_mutex_lock(&chlock)) {
      ast_log(LOG_WARNING, "Unable to lock channel list\n");
      return -1;
   }
   chanls = backends;
   while(chanls) {
      if (!strcasecmp(tech, chanls->type)) {
         ast_mutex_unlock(&chlock);
         if (!chanls->devicestate) 
            return ast_parse_device_state(device);
         else {
            res = chanls->devicestate(number);
            if (res == AST_DEVICE_UNKNOWN)
               return ast_parse_device_state(device);
            else
               return res;
         }
      }
      chanls = chanls->next;
   }
   ast_mutex_unlock(&chlock);
   return AST_DEVICE_INVALID;
}

int ast_do_masquerade

(

struct ast_channel *

chan

)

Definition at line 2204 of file channel.c.

{
   int x,i;
   int res=0;
   int origstate;
   char *tmp;
   struct ast_var_t *varptr;
   struct ast_frame *cur, *prev;
   struct ast_channel_pvt *p;
   struct ast_channel *clone = original->masq;
   struct ast_channel_monitor *monitor;
   int rformat = original->readformat;
   int wformat = original->writeformat;
   char newn[100];
   char orig[100];
   char masqn[100];
   char zombn[100];

#if 1
   ast_log(LOG_DEBUG, "Actually Masquerading %s(%d) into the structure of %s(%d)\n",
      clone->name, clone->_state, original->name, original->_state);
#endif
   /* XXX This is a seriously wacked out operation.  We're essentially putting the guts of
      the clone channel into the original channel.  Start by killing off the original
      channel's backend.   I'm not sure we're going to keep this function, because 
      while the features are nice, the cost is very high in terms of pure nastiness. XXX */

   /* We need the clone's lock, too */
   ast_mutex_lock(&clone->lock);

   ast_log(LOG_DEBUG, "Got clone lock on '%s' at %p\n", clone->name, &clone->lock);

   /* Having remembered the original read/write formats, we turn off any translation on either
      one */
   free_translation(clone);
   free_translation(original);


   /* Unlink the masquerade */
   original->masq = NULL;
   clone->masqr = NULL;
   
   /* Save the original name */
   strncpy(orig, original->name, sizeof(orig) - 1);
   /* Save the new name */
   strncpy(newn, clone->name, sizeof(newn) - 1);
   /* Create the masq name */
   snprintf(masqn, sizeof(masqn), "%s<MASQ>", newn);
      
   /* Copy the name from the clone channel */
   strncpy(original->name, newn, sizeof(original->name)-1);

   /* Mangle the name of the clone channel */
   strncpy(clone->name, masqn, sizeof(clone->name) - 1);
   
   /* Notify any managers of the change, first the masq then the other */
   manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", newn, masqn, clone->uniqueid);
   manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", orig, newn, original->uniqueid);

   /* Swap the guts */  
   p = original->pvt;
   original->pvt = clone->pvt;
   clone->pvt = p;

   /* Save any pending frames on both sides.  Start by counting
    * how many we're going to need... */
   prev = NULL;
   cur = clone->pvt->readq;
   x = 0;
   while(cur) {
      x++;
      prev = cur;
      cur = cur->next;
   }
   /* If we had any, prepend them to the ones already in the queue, and 
    * load up the alertpipe */
   if (prev) {
      prev->next = original->pvt->readq;
      original->pvt->readq = clone->pvt->readq;
      clone->pvt->readq = NULL;
      if (original->pvt->alertpipe[1] > -1) {
         for (i=0;i<x;i++)
            write(original->pvt->alertpipe[1], &x, sizeof(x));
      }
   }
   clone->_softhangup = AST_SOFTHANGUP_DEV;


   /* And of course, so does our current state.  Note we need not
      call ast_setstate since the event manager doesn't really consider
      these separate.  We do this early so that the clone has the proper
      state of the original channel. */
   origstate = original->_state;
   original->_state = clone->_state;
   clone->_state = origstate;

   if (clone->pvt->fixup){
      res = clone->pvt->fixup(original, clone);
      if (res) 
         ast_log(LOG_WARNING, "Fixup failed on channel %s, strange things may happen.\n", clone->name);
   }

   /* Start by disconnecting the original's physical side */
   if (clone->pvt->hangup)
      res = clone->pvt->hangup(clone);
   if (res) {
      ast_log(LOG_WARNING, "Hangup failed!  Strange things may happen!\n");
      ast_mutex_unlock(&clone->lock);
      return -1;
   }
   
   snprintf(zombn, sizeof(zombn), "%s<ZOMBIE>", orig);
   /* Mangle the name of the clone channel */
   strncpy(clone->name, zombn, sizeof(clone->name) - 1);
   manager_event(EVENT_FLAG_CALL, "Rename", "Oldname: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", masqn, zombn, clone->uniqueid);

   /* Update the type. */
   original->type = clone->type;

   /* copy the monitor */
   monitor = original->monitor;
   original->monitor = clone->monitor;
   clone->monitor = monitor;  
   
   /* Keep the same language.  */
   strncpy(original->language, clone->language, sizeof(original->language));

   /* Copy the FD's */
   for (x=0;x<AST_MAX_FDS;x++) {
      original->fds[x] = clone->fds[x];
   }
   /* Append variables from clone channel into original channel */
   /* XXX Is this always correct?  We have to in order to keep MACROS working XXX */
   varptr = original->varshead.first;
   if (varptr) {
      while(varptr->entries.next) {
         varptr = varptr->entries.next;
      }
      varptr->entries.next = clone->varshead.first;
   } else {
      original->varshead.first = clone->varshead.first;
   }
   clone->varshead.first = NULL;
   /* Presense of ADSI capable CPE follows clone */
   original->adsicpe = clone->adsicpe;
   /* Bridge remains the same */
   /* CDR fields remain the same */
   /* XXX What about blocking, softhangup, blocker, and lock and blockproc? XXX */
   /* Application and data remain the same */
   /* Clone exception  becomes real one, as with fdno */
   original->exception = clone->exception;
   original->fdno = clone->fdno;
   /* Schedule context remains the same */
   /* Stream stuff stays the same */
   /* Keep the original state.  The fixup code will need to work with it most likely */

   /* dnid and callerid change to become the new, HOWEVER, we also link the original's
      fields back into the defunct 'clone' so that they will be freed when
      ast_frfree is eventually called */
   tmp = original->dnid;
   original->dnid = clone->dnid;
   clone->dnid = tmp;
   
   tmp = original->callerid;
   original->callerid = clone->callerid;
   clone->callerid = tmp;
   
   /* Restore original timing file descriptor */
   original->fds[AST_MAX_FDS - 2] = original->timingfd;
   
   /* Our native formats are different now */
   original->nativeformats = clone->nativeformats;
   
   /* Context, extension, priority, app data, jump table,  remain the same */
   /* pvt switches.  pbx stays the same, as does next */
   
   /* Set the write format */
   ast_set_write_format(original, wformat);

   /* Set the read format */
   ast_set_read_format(original, rformat);

   /* Copy the music class */
   strncpy(original->musicclass, clone->musicclass, sizeof(original->musicclass) - 1);

   ast_log(LOG_DEBUG, "Putting channel %s in %d/%d formats\n", original->name, wformat, rformat);

   /* Okay.  Last thing is to let the channel driver know about all this mess, so he
      can fix up everything as best as possible */
   if (original->pvt->fixup) {
      res = original->pvt->fixup(clone, original);
      if (res) {
         ast_log(LOG_WARNING, "Driver for '%s' could not fixup channel %s\n",
            original->type, original->name);
         ast_mutex_unlock(&clone->lock);
         return -1;
      }
   } else
      ast_log(LOG_WARNING, "Driver '%s' does not have a fixup routine (for %s)!  Bad things may happen.\n",
         original->type, original->name);
   
   /* Now, at this point, the "clone" channel is totally F'd up.  We mark it as
      a zombie so nothing tries to touch it.  If it's already been marked as a
      zombie, then free it now (since it already is considered invalid). */
   if (clone->zombie) {
      ast_log(LOG_DEBUG, "Destroying clone '%s'\n", clone->name);
      ast_mutex_unlock(&clone->lock);
      ast_channel_free(clone);
      manager_event(EVENT_FLAG_CALL, "Hangup", "Channel: %s\r\n", zombn);
   } else {
      struct ast_frame null_frame = { AST_FRAME_NULL, };
      ast_log(LOG_DEBUG, "Released clone lock on '%s'\n", clone->name);
      clone->zombie=1;
      ast_queue_frame(clone, &null_frame);
      ast_mutex_unlock(&clone->lock);
   }
   
   /* Signal any blocker */
   if (original->blocking)
      pthread_kill(original->blocker, SIGURG);
   ast_log(LOG_DEBUG, "Done Masquerading %s (%d)\n",
      original->name, original->_state);
   return 0;
}

struct ast_channel* ast_get_channel_by_name_locked

(

char *

channame

)

[read]

Get channel by name (locks channel).

Definition at line 510 of file channel.c.

{
   struct ast_channel *chan;
   chan = ast_channel_walk_locked(NULL);
   while(chan) {
      if (!strcasecmp(chan->name, channame))
         return chan;
      ast_mutex_unlock(&chan->lock);
      chan = ast_channel_walk_locked(chan);
   }
   return NULL;
}

unsigned int ast_get_group

(

char *

s

)

Definition at line 2908 of file channel.c.

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

int ast_hangup

(

struct ast_channel *

chan

)

Hang up a channel.

Parameters:

chan

channel to hang up This function performs a hard hangup on a channel. Unlike the soft-hangup, this function performs all stream stopping, etc, on the channel that needs to end. chan is no longer valid after this call. Returns 0 on success, -1 on failure.

Definition at line 689 of file channel.c.

{
   int res = 0;
   /* Don't actually hang up a channel that will masquerade as someone else, or
      if someone is going to masquerade as us */
   ast_mutex_lock(&chan->lock);
   if (chan->masq) {
      if (ast_do_masquerade(chan)) 
         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
   }

   if (chan->masq) {
      ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name);
      ast_mutex_unlock(&chan->lock);
      return 0;
   }
   /* If this channel is one which will be masqueraded into something, 
      mark it as a zombie already, so we know to free it later */
   if (chan->masqr) {
      chan->zombie=1;
      ast_mutex_unlock(&chan->lock);
      return 0;
   }
   free_translation(chan);
   if (chan->stream) 
      ast_closestream(chan->stream);
   if (chan->vstream)
      ast_closestream(chan->vstream);
   if (chan->sched)
      sched_context_destroy(chan->sched);
   /* Clear any tone stuff remaining */
   if (chan->generatordata)
      chan->generator->release(chan, chan->generatordata);
   chan->generatordata = NULL;
   chan->generator = NULL;
   if (chan->cdr) {
      /* End the CDR if it hasn't already */
      ast_cdr_end(chan->cdr);
      /* Post and Free the CDR */
      ast_cdr_post(chan->cdr);
      ast_cdr_free(chan->cdr);
   }
   if (chan->blocking) {
      ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd "
               "is blocked by thread %ld in procedure %s!  Expect a failure\n",
               (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc);
      CRASH;
   }
   if (!chan->zombie) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Hanging up channel '%s'\n", chan->name);
      if (chan->pvt->hangup)
         res = chan->pvt->hangup(chan);
   } else
      if (option_debug)
         ast_log(LOG_DEBUG, "Hanging up zombie '%s'\n", chan->name);
         
   ast_mutex_unlock(&chan->lock);
   manager_event(EVENT_FLAG_CALL, "Hangup", 
         "Channel: %s\r\n"
         "Uniqueid: %s\r\n"
         "Cause: %i\r\n",
         chan->name, chan->uniqueid, chan->hangupcause);
   ast_channel_free(chan);
   return res;
}

int ast_indicate	(	struct ast_channel *	chan,
		int	condition
	)

Indicates condition of channel.

Parameters:

	chan	channel to change the indication
	condition	which condition to indicate on the channel Indicate a condition such as AST_CONTROL_BUSY, AST_CONTROL_RINGING, or AST_CONTROL_CONGESTION on a channel Returns 0 on success, -1 on failure

Definition at line 1411 of file channel.c.

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

int ast_parse_device_state

(

char *

device

)

Search the Channels by Name.

Parameters:

device

like a dialstring Search the Device in active channels by compare the channelname against the devicename. Compared are only the first chars to the first '-' char. Returns an AST_DEVICE_UNKNOWN if no channel found or AST_DEVICE_INUSE if a channel is found

Definition at line 1918 of file channel.c.

{
   char name[AST_CHANNEL_NAME] = "";
   char *cut;
   struct ast_channel *chan;

   chan = ast_channel_walk_locked(NULL);
   while (chan) {
      strncpy(name, chan->name, sizeof(name)-1);
      ast_mutex_unlock(&chan->lock);
      cut = strchr(name,'-');
      if (cut)
              *cut = 0;
      if (!strcmp(name, device))
              return AST_DEVICE_INUSE;
      chan = ast_channel_walk_locked(chan);
   }
   return AST_DEVICE_UNKNOWN;
}

int ast_prod

(

struct ast_channel *

chan

)

Definition at line 1549 of file channel.c.

{
   struct ast_frame a = { AST_FRAME_VOICE };
   char nothing[128];
   /* Send an empty audio frame to get things moving */
   if (chan->_state != AST_STATE_UP) {
      ast_log(LOG_DEBUG, "Prodding channel '%s'\n", chan->name);
      a.subclass = chan->pvt->rawwriteformat;
      a.data = nothing + AST_FRIENDLY_OFFSET;
      if (ast_write(chan, &a))
         ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
   }
   return 0;
}

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

{
   struct ast_frame *f = NULL;
   int blah;
#ifdef ZAPTEL_OPTIMIZATIONS
   int (*func)(void *);
   void *data;
   int res;
#endif
   static struct ast_frame null_frame = 
   {
      AST_FRAME_NULL,
   };
   
   ast_mutex_lock(&chan->lock);
   if (chan->masq) {
      if (ast_do_masquerade(chan)) {
         ast_log(LOG_WARNING, "Failed to perform masquerade\n");
         f = NULL;
      } else
         f =  &null_frame;
      ast_mutex_unlock(&chan->lock);
      return f;
   }

   /* Stop if we're a zombie or need a soft hangup */
   if (chan->zombie || ast_check_hangup(chan)) {
      if (chan->generator)
         ast_deactivate_generator(chan);
      ast_mutex_unlock(&chan->lock);
      return NULL;
   }

   if (!chan->deferdtmf && !ast_strlen_zero(chan->dtmfq)) {
      /* We have DTMF that has been deferred.  Return it now */
      chan->dtmff.frametype = AST_FRAME_DTMF;
      chan->dtmff.subclass = chan->dtmfq[0];
      /* Drop first digit */
      memmove(chan->dtmfq, chan->dtmfq + 1, sizeof(chan->dtmfq) - 1);
      ast_mutex_unlock(&chan->lock);
      return &chan->dtmff;
   }
   
   /* Read and ignore anything on the alertpipe, but read only
      one sizeof(blah) per frame that we send from it */
   if (chan->pvt->alertpipe[0] > -1) {
      read(chan->pvt->alertpipe[0], &blah, sizeof(blah));
   }
#ifdef ZAPTEL_OPTIMIZATIONS
   if ((chan->timingfd > -1) && (chan->fdno == AST_MAX_FDS - 2) && chan->exception) {
      chan->exception = 0;
      blah = -1;
      /* IF we can't get event, assume it's an expired as-per the old interface */
      res = ioctl(chan->timingfd, ZT_GETEVENT, &blah);
      if (res) 
         blah = ZT_EVENT_TIMER_EXPIRED;

      if (blah == ZT_EVENT_TIMER_PING) {
#if 0
         ast_log(LOG_NOTICE, "Oooh, there's a PING!\n");
#endif         
         if (!chan->pvt->readq || !chan->pvt->readq->next) {
            /* Acknowledge PONG unless we need it again */
#if 0
            ast_log(LOG_NOTICE, "Sending a PONG!\n");
#endif            
            if (ioctl(chan->timingfd, ZT_TIMERPONG, &blah)) {
               ast_log(LOG_WARNING, "Failed to pong timer on '%s': %s\n", chan->name, strerror(errno));
            }
         }
      } else if (blah == ZT_EVENT_TIMER_EXPIRED) {
         ioctl(chan->timingfd, ZT_TIMERACK, &blah);
         func = chan->timingfunc;
         data = chan->timingdata;
         ast_mutex_unlock(&chan->lock);
         if (func) {
#if 0
            ast_log(LOG_DEBUG, "Calling private function\n");
#endif         
            func(data);
         } else {
            blah = 0;
            ast_mutex_lock(&chan->lock);
            ioctl(chan->timingfd, ZT_TIMERCONFIG, &blah);
            chan->timingdata = NULL;
            ast_mutex_unlock(&chan->lock);
         }
         f =  &null_frame;
         return f;
      } else
         ast_log(LOG_NOTICE, "No/unknown event '%d' on timer for '%s'?\n", blah, chan->name);
   }
#endif
   /* Check for pending read queue */
   if (chan->pvt->readq) {
      f = chan->pvt->readq;
      chan->pvt->readq = f->next;
      /* Interpret hangup and return NULL */
      if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) {
         ast_frfree(f);
         f = NULL;
      }
   } else {
      chan->blocker = pthread_self();
      if (chan->exception) {
         if (chan->pvt->exception) 
            f = chan->pvt->exception(chan);
         else {
            ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name);
            f = &null_frame;
         }
         /* Clear the exception flag */
         chan->exception = 0;
      } else
      if (chan->pvt->read)
         f = chan->pvt->read(chan);
      else
         ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name);
   }


   if (f && (f->frametype == AST_FRAME_VOICE)) {
      if (!(f->subclass & chan->nativeformats)) {
         /* This frame can't be from the current native formats -- drop it on the
            floor */
         ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n", chan->name, ast_getformatname(f->subclass), ast_getformatname(chan->nativeformats));
         ast_frfree(f);
         f = &null_frame;
      } else {
         if (chan->monitor && chan->monitor->read_stream ) {
#ifndef MONITOR_CONSTANT_DELAY
            int jump = chan->outsmpl - chan->insmpl - 2 * f->samples;
            if (jump >= 0) {
               if (ast_seekstream(chan->monitor->read_stream, jump + f->samples, SEEK_FORCECUR) == -1)
                  ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
               chan->insmpl += jump + 2 * f->samples;
            } else
               chan->insmpl+= f->samples;
#else
            int jump = chan->outsmpl - chan->insmpl;
            if (jump - MONITOR_DELAY >= 0) {
               if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1)
                  ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n");
               chan->insmpl += jump;
            } else
               chan->insmpl += f->samples;
#endif
            if (ast_writestream(chan->monitor->read_stream, f) < 0)
               ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n");
         }
         if (chan->pvt->readtrans) {
            f = ast_translate(chan->pvt->readtrans, f, 1);
            if (!f)
               f = &null_frame;
         }
      }
   }

   /* Make sure we always return NULL in the future */
   if (!f) {
      chan->_softhangup |= AST_SOFTHANGUP_DEV;
      if (chan->generator)
         ast_deactivate_generator(chan);
      /* End the CDR if appropriate */
      if (chan->cdr)
         ast_cdr_end(chan->cdr);
   } else if (chan->deferdtmf && f->frametype == AST_FRAME_DTMF) {
      if (strlen(chan->dtmfq) < sizeof(chan->dtmfq) - 2)
         chan->dtmfq[strlen(chan->dtmfq)] = f->subclass;
      else
         ast_log(LOG_WARNING, "Dropping deferred DTMF digits on %s\n", chan->name);
      f = &null_frame;
   } else if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_ANSWER)) {
      if (chan->_state == AST_STATE_UP) {
         ast_log(LOG_DEBUG, "Dropping duplicate answer!\n");
         f = &null_frame;
      }
      /* Answer the CDR */
      ast_setstate(chan, AST_STATE_UP);
      ast_cdr_answer(chan->cdr);
   } 

   /* Run any generator sitting on the line */
   if (f && (f->frametype == AST_FRAME_VOICE) && chan->generatordata) {
      /* Mask generator data temporarily and apply.  If there is a timing function, it
         will be calling the generator instead */
      void *tmp;
      int res;
      int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples);
      if (chan->timingfunc) {
         ast_log(LOG_DEBUG, "Generator got voice, switching to phase locked mode\n");
         ast_settimeout(chan, 0, NULL, NULL);
      }
      tmp = chan->generatordata;
      chan->generatordata = NULL;
      generate = chan->generator->generate;
      res = generate(chan, tmp, f->datalen, f->samples);
      chan->generatordata = tmp;
      if (res) {
         ast_log(LOG_DEBUG, "Auto-deactivating generator\n");
         ast_deactivate_generator(chan);
      }
   } else if (f && (f->frametype == AST_FRAME_CNG)) {
      if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) {
         ast_log(LOG_DEBUG, "Generator got CNG, switching to zap timed mode\n");
         ast_settimeout(chan, 160, generator_force, chan);
      }
   }
   /* High bit prints debugging */
   if (chan->fin & 0x80000000)
      ast_frame_dump(chan->name, f, "<<");
   if ((chan->fin & 0x7fffffff) == 0x7fffffff)
      chan->fin &= 0x80000000;
   else
      chan->fin++;
   ast_mutex_unlock(&chan->lock);
   return f;
}

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

Reads multiple digits.

Parameters:

	c	channel to read from
	s	string to read in to. Must be at least the size of your length
	len	how many digits to read (maximum)
	timeout	how long to timeout between digits
	rtimeout	timeout to wait on the first digit
	enders	digits to end the string Read in a digit string "s", max length "len", maximum timeout between digits "timeout" (-1 for none), terminated by anything in "enders". Give them rtimeout for the first digit. Returns 0 on normal return, or 1 on a timeout. In the case of a timeout, any digits that were read before the timeout will still be available in s. RETURNS 2 in full version when ctrlfd is available, NOT 1

Definition at line 2012 of file channel.c.

{
   int pos=0;
   int to = ftimeout;
   int d;
   /* XXX Merge with full version? XXX */
   /* Stop if we're a zombie or need a soft hangup */
   if (c->zombie || ast_check_hangup(c)) 
      return -1;
   if (!len)
      return -1;
   do {
      if (c->stream) {
         d = ast_waitstream(c, AST_DIGIT_ANY);
         ast_stopstream(c);
         usleep(1000);
         if (!d)
            d = ast_waitfordigit(c, to);
      } else {
         d = ast_waitfordigit(c, to);
      }
      if (d < 0)
         return -1;
      if (d == 0) {
         s[pos]='\0';
         return 1;
      }
      if (!strchr(enders, d))
         s[pos++] = d;
      if (strchr(enders, d) || (pos >= len)) {
         s[pos]='\0';
         return 0;
      }
      to = timeout;
   } while(1);
   /* Never reached */
   return 0;
}

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

Definition at line 2051 of file channel.c.

{
   int pos=0;
   int to = ftimeout;
   int d;
   /* Stop if we're a zombie or need a soft hangup */
   if (c->zombie || ast_check_hangup(c)) 
      return -1;
   if (!len)
      return -1;
   do {
      if (c->stream) {
         d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd);
         ast_stopstream(c);
         usleep(1000);
         if (!d)
            d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
      } else {
         d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
      }
      if (d < 0)
         return -1;
      if (d == 0) {
         s[pos]='\0';
         return 1;
      }
      if (d == 1) {
         s[pos]='\0';
         return 2;
      }
      if (!strchr(enders, d))
         s[pos++] = d;
      if (strchr(enders, d) || (pos >= len)) {
         s[pos]='\0';
         return 0;
      }
      to = timeout;
   } while(1);
   /* Never reached */
   return 0;
}

int ast_recvchar	(	struct ast_channel *	chan,
		int	timeout
	)

Definition at line 1458 of file channel.c.

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

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

Requests a channel.

Parameters:

	type	type of channel to request
	format	requested channel format
	data	data to pass to the channel requester Request a channel of a given type, with data as optional information used by the low level module Returns an ast_channel on success, NULL on failure.

Definition at line 1873 of file channel.c.

{
   struct chanlist *chan;
   struct ast_channel *c = NULL;
   int capabilities;
   int fmt;
   int res;
   if (ast_mutex_lock(&chlock)) {
      ast_log(LOG_WARNING, "Unable to lock channel list\n");
      return NULL;
   }
   chan = backends;
   while(chan) {
      if (!strcasecmp(type, chan->type)) {
         capabilities = chan->capabilities;
         fmt = format;
         res = ast_translator_best_choice(&fmt, &capabilities);
         if (res < 0) {
            ast_log(LOG_WARNING, "No translator path exists for channel type %s (native %d) to %d\n", type, chan->capabilities, format);
            ast_mutex_unlock(&chlock);
            return NULL;
         }
         ast_mutex_unlock(&chlock);
         if (chan->requester)
            c = chan->requester(type, capabilities, data);
         if (c) {
            if (c->_state == AST_STATE_DOWN) {
               manager_event(EVENT_FLAG_CALL, "Newchannel",
               "Channel: %s\r\n"
               "State: %s\r\n"
               "CallerID: %s\r\n"
               "Uniqueid: %s\r\n",
               c->name, ast_state2str(c->_state), c->callerid ? c->callerid : "<unknown>", c->uniqueid);
            }
         }
         return c;
      }
      chan = chan->next;
   }
   if (!chan)
      ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type);
   ast_mutex_unlock(&chlock);
   return c;
}

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

Parameters:

	type	type of channel to request
	format	requested channel format
	data	data to pass to the channel requester
	timeout	maximum amount of time to wait for an answer
	why	unsuccessful (if unsuceessful) Request a channel of a given type, with data as optional information used by the low level module and attempt to place a call on it Returns an ast_channel on success or no answer, NULL on failure. Check the value of chan->_state to know if the call was answered or not.

Definition at line 1868 of file channel.c.

{
   return __ast_request_and_dial(type, format, data, timeout, outstate, callerid, NULL);
}

int ast_safe_sleep	(	struct ast_channel *	chan,
		int	ms
	)

Wait for a specied amount of time, looking for hangups.

Parameters:

	chan	channel to wait for
	ms	length of time in milliseconds to sleep Waits for a specified amount of time, servicing the channel as required. returns -1 on hangup, otherwise 0.

Definition at line 544 of file channel.c.

{
   struct ast_frame *f;
   while(ms > 0) {
      ms = ast_waitfor(chan, ms);
      if (ms <0)
         return -1;
      if (ms > 0) {
         f = ast_read(chan);
         if (!f)
            return -1;
         ast_frfree(f);
      }
   }
   return 0;
}

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

Wait for a specied amount of time, looking for hangups and a condition argument.

Parameters:

	chan	channel to wait for
	ms	length of time in milliseconds to sleep
	cond	a function pointer for testing continue condition
	data	argument to be passed to the condition test function Waits for a specified amount of time, servicing the channel as required. If cond returns 0, this function returns. returns -1 on hangup, otherwise 0.

Definition at line 523 of file channel.c.

{
   struct ast_frame *f;

   while(ms > 0) {
      if( cond && ((*cond)(data) == 0 ) )
         return 0;
      ms = ast_waitfor(chan, ms);
      if (ms <0)
         return -1;
      if (ms > 0) {
         f = ast_read(chan);
         if (!f)
            return -1;
         ast_frfree(f);
      }
   }
   return 0;
}

int ast_senddigit	(	struct ast_channel *	chan,
		char	digit
	)

Receives a text character from a channel.

Parameters:

	chan	channel to act upon
	timeout	timeout in milliseconds (0 for infinite wait) Read a char of text from a channel Returns 0 on success, -1 on failure

Definition at line 1544 of file channel.c.

{
   return do_senddigit(chan, digit);
}

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

Sends text to a channel.

Parameters:

	chan	channel to act upon
	text	string of text to send on the channel Write text to a display on a channel Returns 0 on success, -1 on failure

Definition at line 1487 of file channel.c.

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

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

Definition at line 2429 of file channel.c.

{
   if (chan->callerid)
      free(chan->callerid);
   if (anitoo && chan->ani)
      free(chan->ani);
   if (callerid) {
      chan->callerid = strdup(callerid);
      if (anitoo)
         chan->ani = strdup(callerid);
   } else {
      chan->callerid = NULL;
      if (anitoo)
         chan->ani = NULL;
   }
   if (chan->cdr)
      ast_cdr_setcid(chan->cdr, chan);
   manager_event(EVENT_FLAG_CALL, "Newcallerid", 
            "Channel: %s\r\n"
            "CallerID: %s\r\n"
            "Uniqueid: %s\r\n",
            chan->name, chan->callerid ? 
            chan->callerid : "<Unknown>",
            chan->uniqueid);
}

int ast_set_read_format	(	struct ast_channel *	chan,
		int	format
	)

Sets read format on channel chan.

Parameters:

	chan	channel to change
	format	format to change to Set read format for channel to whichever component of "format" is best. Returns 0 on success, -1 on failure

Definition at line 1724 of file channel.c.

{
   int fmt;
   int native;
   int res;
   
   ast_mutex_lock(&chan->lock);
   native = chan->nativeformats;
   fmt = fmts;
   /* Find a translation path from the native read format to one of the user's read formats */
   res = ast_translator_best_choice(&fmt, &native);
   if (res < 0) {
      ast_log(LOG_NOTICE, "Unable to find a path from %s to %s\n",
         ast_getformatname(chan->nativeformats), ast_getformatname(fmts));
      ast_mutex_unlock(&chan->lock);
      return -1;
   }
   
   /* Now we have a good choice for both.  We'll write using our native format. */
   chan->pvt->rawreadformat = native;
   /* User perspective is fmt */
   chan->readformat = fmt;
   /* Free any read translation we have right now */
   if (chan->pvt->readtrans)
      ast_translator_free_path(chan->pvt->readtrans);
   /* Build a translation path from the raw read format to the user reading format */
   chan->pvt->readtrans = ast_translator_build_path(chan->readformat, chan->pvt->rawreadformat);
   if (option_debug)
      ast_log(LOG_DEBUG, "Set channel %s to read format %s\n", 
         chan->name, ast_getformatname(chan->readformat));
   ast_mutex_unlock(&chan->lock);
   return 0;
}

int ast_set_write_format	(	struct ast_channel *	chan,
		int	format
	)

Sets write format on channel chan.

Parameters:

	chan	channel to change
	format	new format for writing Set write format for channel to whichever compoent of "format" is best. Returns 0 on success, -1 on failure

Definition at line 1691 of file channel.c.

{
   int fmt;
   int native;
   int res;
   
   ast_mutex_lock(&chan->lock);
   native = chan->nativeformats;
   fmt = fmts;
   
   res = ast_translator_best_choice(&native, &fmt);
   if (res < 0) {
      ast_log(LOG_NOTICE, "Unable to find a path from %s to %s\n",
         ast_getformatname(fmts), ast_getformatname(chan->nativeformats));
      ast_mutex_unlock(&chan->lock);
      return -1;
   }
   
   /* Now we have a good choice for both.  We'll write using our native format. */
   chan->pvt->rawwriteformat = native;
   /* User perspective is fmt */
   chan->writeformat = fmt;
   /* Free any write translation we have right now */
   if (chan->pvt->writetrans)
      ast_translator_free_path(chan->pvt->writetrans);
   /* Build a translation path from the user write format to the raw writing format */
   chan->pvt->writetrans = ast_translator_build_path(chan->pvt->rawwriteformat, chan->writeformat);
   if (option_debug)
      ast_log(LOG_DEBUG, "Set channel %s to write format %s\n", chan->name, ast_getformatname(chan->writeformat));
   ast_mutex_unlock(&chan->lock);
   return 0;
}

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

Definition at line 1119 of file channel.c.

{
   int res = -1;
#ifdef ZAPTEL_OPTIMIZATIONS
   if (c->timingfd > -1) {
      if (!func) {
         samples = 0;
         data = 0;
      }
      ast_log(LOG_DEBUG, "Scheduling timer at %d sample intervals\n", samples);
      res = ioctl(c->timingfd, ZT_TIMERCONFIG, &samples);
      c->timingfunc = func;
      c->timingdata = data;
   }
#endif   
   return res;
}

int ast_shutting_down

(

void

)

Returns non-zero if Asterisk is being shut down

Definition at line 139 of file channel.c.

{
   return shutting_down;
}

int ast_softhangup	(	struct ast_channel *	chan,
		int	cause
	)

Softly hangup up a channel.

Parameters:

chan

channel to be soft-hung-up Call the protocol layer, but don't destroy the channel structure (use this if you are trying to safely hangup a channel managed by another thread. Returns 0 regardless

Definition at line 668 of file channel.c.

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

int ast_softhangup_nolock	(	struct ast_channel *	chan,
		int	cause
	)

Definition at line 653 of file channel.c.

{
   int res = 0;
   struct ast_frame f = { AST_FRAME_NULL };
   if (option_debug)
      ast_log(LOG_DEBUG, "Soft-Hanging up channel '%s'\n", chan->name);
   /* Inform channel driver that we need to be hung up, if it cares */
   chan->_softhangup |= cause;
   ast_queue_frame(chan, &f);
   /* Interrupt any poll call or such */
   if (chan->blocking)
      pthread_kill(chan->blocker, SIGURG);
   return res;
}

char* ast_state2str

(

int

state

)

Gives the string form of a given state.

Parameters:

state

state to get the name of Give a name to a state Pretty self explanatory. Returns the text form of the binary state given

Definition at line 205 of file channel.c.

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

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

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

{
   ast_deactivate_generator(chan);
}

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

Definition at line 1992 of file channel.c.

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

int ast_waitfor	(	struct ast_channel *	chan,
		int	ms
	)

Wait for input on a channel.

Parameters:

	chan	channel to wait on
	ms	length of time to wait on the channel Wait for input on a channel for a given # of milliseconds (<0 for indefinite). Returns < 0 on failure, 0 if nothing ever arrived, and the # of ms remaining otherwise

Definition at line 1078 of file channel.c.

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

{
   return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms);
}

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

Waits for input on an fd.

This version works on fd's only. Be careful with it.

Definition at line 869 of file channel.c.

{
   /* Wait for x amount of time on a file descriptor to have input.  */
   struct timeval start, now;
   int res;
   int x, y;
   int winner = -1;
   int spoint;
   struct pollfd *pfds;
   
   pfds = alloca(sizeof(struct pollfd) * n);
   if (!pfds) {
      ast_log(LOG_WARNING, "alloca failed!  bad things will happen.\n");
      return -1;
   }
   if (*ms > 0)
      gettimeofday(&start, NULL);
   y = 0;
   for (x=0;x<n;x++) {
      if (fds[x] > -1) {
         pfds[y].fd = fds[x];
         pfds[y].events = POLLIN | POLLPRI;
         y++;
      }
   }
   res = poll(pfds, y, *ms);
   if (res < 0) {
      /* Simulate a timeout if we were interrupted */
      if (errno != EINTR)
         *ms = -1;
      else
         *ms = 0;
      return -1;
   }
   spoint = 0;
   for (x=0;x<n;x++) {
      if (fds[x] > -1) {
         if ((res = ast_fdisset(pfds, fds[x], y, &spoint))) {
            winner = fds[x];
            if (exception) {
               if (res & POLLPRI)
                  *exception = -1;
               else
                  *exception = 0;
            }
         }
      }
   }
   if (*ms > 0) {
      long passed;
      gettimeofday(&now, NULL);
      passed = (now.tv_sec - start.tv_sec) * 1000;
      passed += (now.tv_usec - start.tv_usec) / 1000;
      if (passed <= *ms)
         *ms -= passed;
      else
         *ms = 0;
   }
   return winner;
}

struct ast_channel* ast_waitfor_nandfds	(	struct ast_channel **	chan,
		int	n,
		int *	fds,
		int	nfds,
		int *	exception,
		int *	outfd,
		int *	ms
	)			[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 the channel with activity, or NULL on error or if an FD came first. If the FD came first, it will be returned in outfd, otherwise, outfd will be -1

Definition at line 930 of file channel.c.

{
   /* Wait for x amount of time on a file descriptor to have input.  */
   struct timeval start, end;
   struct pollfd *pfds;
   int res;
   long rms;
   int x, y, max;
   int spoint;
   time_t now = 0;
   long whentohangup = 0, havewhen = 0, diff;
   struct ast_channel *winner = NULL;

   pfds = alloca(sizeof(struct pollfd) * (n * AST_MAX_FDS + nfds));
   if (!pfds) {
      ast_log(LOG_WARNING, "alloca failed!  bad things will happen.\n");
      *outfd = -1;
      return NULL;
   }

   if (outfd)
      *outfd = -99999;
   if (exception)
      *exception = 0;
   
   /* Perform any pending masquerades */
   for (x=0;x<n;x++) {
      ast_mutex_lock(&c[x]->lock);
      if (c[x]->whentohangup) {
         if (!havewhen)
            time(&now);
         diff = c[x]->whentohangup - now;
         if (!havewhen || (diff < whentohangup)) {
            havewhen++;
            whentohangup = diff;
         }
      }
      if (c[x]->masq) {
         if (ast_do_masquerade(c[x])) {
            ast_log(LOG_WARNING, "Masquerade failed\n");
            *ms = -1;
            ast_mutex_unlock(&c[x]->lock);
            return NULL;
         }
      }
      ast_mutex_unlock(&c[x]->lock);
   }

   rms = *ms;
   
   if (havewhen) {
      if ((*ms < 0) || (whentohangup * 1000 < *ms)) {
         rms =  whentohangup * 1000;
      }
   }
   max = 0;
   for (x=0;x<n;x++) {
      for (y=0;y<AST_MAX_FDS;y++) {
         if (c[x]->fds[y] > -1) {
            pfds[max].fd = c[x]->fds[y];
            pfds[max].events = POLLIN | POLLPRI;
            max++;
         }
      }
      CHECK_BLOCKING(c[x]);
   }
   for (x=0;x<nfds; x++) {
      if (fds[x] > -1) {
         pfds[max].fd = fds[x];
         pfds[max].events = POLLIN | POLLPRI;
         max++;
      }
   }
   if (*ms > 0) 
      gettimeofday(&start, NULL);
   res = poll(pfds, max, rms);
   if (res < 0) {
      for (x=0;x<n;x++) 
         c[x]->blocking = 0;
      /* Simulate a timeout if we were interrupted */
      if (errno != EINTR)
         *ms = -1;
      else {
         /* Just an interrupt */
#if 0
         *ms = 0;
#endif         
      }
      return NULL;
   }

   if (havewhen)
      time(&now);
   spoint = 0;
   for (x=0;x<n;x++) {
      c[x]->blocking = 0;
      if (havewhen && c[x]->whentohangup && (now > c[x]->whentohangup)) {
         c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
         if (!winner)
            winner = c[x];
      }
      for (y=0;y<AST_MAX_FDS;y++) {
         if (c[x]->fds[y] > -1) {
            if ((res = ast_fdisset(pfds, c[x]->fds[y], max, &spoint))) {
               if (res & POLLPRI)
                  c[x]->exception = -1;
               else
                  c[x]->exception = 0;
               c[x]->fdno = y;
               winner = c[x];
            }
         }
      }
   }
   for (x=0;x<nfds;x++) {
      if (fds[x] > -1) {
         if ((res = ast_fdisset(pfds, fds[x], max, &spoint))) {
            if (outfd)
               *outfd = fds[x];
            if (exception) {  
               if (res & POLLPRI) 
                  *exception = -1;
               else
                  *exception = 0;
            }
            winner = NULL;
         }
      }  
   }
   if (*ms > 0) {
      long diff;
      gettimeofday(&end, NULL);
      diff = (end.tv_sec - start.tv_sec) * 1000;
      diff += (end.tv_usec - start.tv_usec) / 1000;
      if (diff < *ms)
         *ms -= diff;
      else
         *ms = 0;
   }
   return winner;
}

int ast_waitfordigit	(	struct ast_channel *	c,
		int	ms
	)

Waits for a digit.

Parameters:

	c	channel to wait for a digit on
	ms	how many milliseconds to wait Wait for a digit. Returns <0 on error, 0 on no entry, and the digit on success.

Definition at line 1092 of file channel.c.

{
   /* XXX Should I be merged with waitfordigit_full XXX */
   struct ast_frame *f;
   int result = 0;
   /* Stop if we're a zombie or need a soft hangup */
   if (c->zombie || ast_check_hangup(c)) 
      return -1;
   /* Wait for a digit, no more than ms milliseconds total. */
   while(ms && !result) {
      ms = ast_waitfor(c, ms);
      if (ms < 0) /* Error */
         result = -1; 
      else if (ms > 0) {
         /* Read something */
         f = ast_read(c);
         if (f) {
            if (f->frametype == AST_FRAME_DTMF) 
               result = f->subclass;
            ast_frfree(f);
         } else
            result = -1;
      }
   }
   return result;
}

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

Definition at line 1136 of file channel.c.

{
   struct ast_frame *f;
   struct ast_channel *rchan;
   int outfd;
   int res;
   /* Stop if we're a zombie or need a soft hangup */
   if (c->zombie || ast_check_hangup(c)) 
      return -1;
   /* Wait for a digit, no more than ms milliseconds total. */
   while(ms) {
      errno = 0;
      rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
      if ((!rchan) && (outfd < 0) && (ms)) { 
         if (errno == 0 || errno == EINTR)
            continue;
         ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
         return -1;
      } else if (outfd > -1) {
         /* The FD we were watching has something waiting */
         return 1;
      } else if (rchan) {
         f = ast_read(c);
         if(!f) {
            return -1;
         }

         switch(f->frametype) {
         case AST_FRAME_DTMF:
            res = f->subclass;
            ast_frfree(f);
            return res;
         case AST_FRAME_CONTROL:
            switch(f->subclass) {
            case AST_CONTROL_HANGUP:
               ast_frfree(f);
               return -1;
            case AST_CONTROL_RINGING:
            case AST_CONTROL_ANSWER:
               /* Unimportant */
               break;
            default:
               ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass);
            }
         case AST_FRAME_VOICE:
            /* Write audio if appropriate */
            if (audiofd > -1)
               write(audiofd, f->data, f->datalen);
         }
         /* Ignore */
         ast_frfree(f);
      }
   }
   return 0; // Time is up
}

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

Write a frame to a channel.

Parameters:

	chan	destination channel of the frame
	frame	frame that will be written This function writes the given frame to the indicated channel. It returns 0 on success, -1 on failure.

Definition at line 1575 of file channel.c.

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

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

Write video frame to a channel.

Parameters:

	chan	destination channel of the frame
	frame	frame that will be written This function writes the given frame to the indicated channel. It returns 1 on success, 0 if not implemented, and -1 on failure.

Definition at line 1564 of file channel.c.

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