channel.h File Reference

General Asterisk PBX channel definitions. More...

#include "asterisk/abstract_jb.h"
#include "asterisk/poll-compat.h"
#include "asterisk/frame.h"
#include "asterisk/sched.h"
#include "asterisk/chanvars.h"
#include "asterisk/config.h"
#include "asterisk/lock.h"
#include "asterisk/cdr.h"
#include "asterisk/utils.h"
#include "asterisk/linkedlists.h"
#include "asterisk/stringfields.h"
#include "asterisk/datastore.h"

Include dependency graph for channel.h:

Go to the source code of this file.

Data Structures
struct	ast_bridge_config
	bridge configuration More...
struct	ast_callerid
	Structure for all kinds of caller ID identifications. More...
struct	ast_channel
	Main Channel structure associated with a channel. This is the side of it mostly used by the pbx and call management. More...
struct	ast_channel_tech
	Structure to describe a channel "technology", ie a channel driver See for examples:. More...
struct	ast_generator
struct	ast_group_info
	channel group info More...
struct	outgoing_helper
Defines
#define	AST_AGENT_FD (AST_MAX_FDS-3)
#define	AST_ALERT_FD (AST_MAX_FDS-1)
#define	AST_BRIDGE_DTMF_CHANNEL_0 (1 << 0)
	Report DTMF on channel 0.
#define	AST_BRIDGE_DTMF_CHANNEL_1 (1 << 1)
	Report DTMF on channel 1.
#define	AST_BRIDGE_IGNORE_SIGS (1 << 4)
	Ignore all signal frames except NULL.
#define	AST_BRIDGE_REC_CHANNEL_0 (1 << 2)
	Return all voice frames on channel 0.
#define	AST_BRIDGE_REC_CHANNEL_1 (1 << 3)
	Return all voice frames on channel 1.
#define	ast_channel_alloc(needqueue, state, cid_num, cid_name, acctcode, exten, context, amaflag,...)
#define	AST_CHANNEL_NAME 80
#define	AST_GENERATOR_FD (AST_MAX_FDS-4)
#define	AST_MAX_CONTEXT 80
#define	AST_MAX_EXTENSION 80
#define	AST_MAX_FDS 10
#define	AST_TIMING_FD (AST_MAX_FDS-2)
#define	CHECK_BLOCKING(c)
#define	DATASTORE_INHERIT_FOREVER INT_MAX
#define	DEBUGCHAN_FLAG 0x80000000
#define	FRAMECOUNT_INC(x) ( ((x) & DEBUGCHAN_FLAG) \| (((x)+1) & ~DEBUGCHAN_FLAG) )
#define	MAX_LANGUAGE 20
#define	MAX_MUSICCLASS 80
Typedefs
typedef unsigned long long	ast_group_t
Enumerations
enum	{ AST_CHAN_TP_WANTSJITTER = (1 << 0), AST_CHAN_TP_CREATESJITTER = (1 << 1) }
	ast_channel_tech Properties More...
enum	{ AST_FLAG_DEFER_DTMF = (1 << 1), AST_FLAG_WRITE_INT = (1 << 2), AST_FLAG_BLOCKING = (1 << 3), AST_FLAG_ZOMBIE = (1 << 4), AST_FLAG_EXCEPTION = (1 << 5), AST_FLAG_MOH = (1 << 6), AST_FLAG_SPYING = (1 << 7), AST_FLAG_NBRIDGE = (1 << 8), AST_FLAG_IN_AUTOLOOP = (1 << 9), AST_FLAG_OUTGOING = (1 << 10), AST_FLAG_IN_DTMF = (1 << 12), AST_FLAG_EMULATE_DTMF = (1 << 13), AST_FLAG_END_DTMF_ONLY = (1 << 14), AST_FLAG_ANSWERED_ELSEWHERE = (1 << 15), AST_FLAG_MASQ_NOSTREAM = (1 << 16), AST_FLAG_BRIDGE_HANGUP_RUN = (1 << 17), AST_FLAG_BRIDGE_HANGUP_DONT = (1 << 18) }
	ast_channel flags More...
enum	{ AST_FEATURE_PLAY_WARNING = (1 << 0), AST_FEATURE_REDIRECT = (1 << 1), AST_FEATURE_DISCONNECT = (1 << 2), AST_FEATURE_ATXFER = (1 << 3), AST_FEATURE_AUTOMON = (1 << 4), AST_FEATURE_PARKCALL = (1 << 5), AST_FEATURE_AUTOMIXMON = (1 << 6), AST_FEATURE_NO_H_EXTEN = (1 << 7), AST_FEATURE_WARNING_ACTIVE = (1 << 8) }
	ast_bridge_config flags More...
enum	{ AST_CDR_TRANSFER = (1 << 0), AST_CDR_FORWARD = (1 << 1), AST_CDR_CALLWAIT = (1 << 2), AST_CDR_CONFERENCE = (1 << 3) }
enum	{ AST_SOFTHANGUP_DEV = (1 << 0), AST_SOFTHANGUP_ASYNCGOTO = (1 << 1), AST_SOFTHANGUP_SHUTDOWN = (1 << 2), AST_SOFTHANGUP_TIMEOUT = (1 << 3), AST_SOFTHANGUP_APPUNLOAD = (1 << 4), AST_SOFTHANGUP_EXPLICIT = (1 << 5), AST_SOFTHANGUP_UNBRIDGE = (1 << 6) }
enum	ast_bridge_result { AST_BRIDGE_COMPLETE = 0, AST_BRIDGE_FAILED = -1, AST_BRIDGE_FAILED_NOWARN = -2, AST_BRIDGE_RETRY = -3 }
enum	ast_channel_adsicpe { AST_ADSI_UNKNOWN, AST_ADSI_AVAILABLE, AST_ADSI_UNAVAILABLE, AST_ADSI_OFFHOOKONLY }
enum	ast_channel_state { AST_STATE_DOWN, AST_STATE_RESERVED, AST_STATE_OFFHOOK, AST_STATE_DIALING, AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, AST_STATE_BUSY, AST_STATE_DIALING_OFFHOOK, AST_STATE_PRERING, AST_STATE_MUTE = (1 << 16) }
	ast_channel states More...
enum	ast_t38_state { T38_STATE_UNAVAILABLE, T38_STATE_UNKNOWN, T38_STATE_NEGOTIATING, T38_STATE_REJECTED, T38_STATE_NEGOTIATED }
	Possible T38 states on channels. More...
enum	channelreloadreason { CHANNEL_MODULE_LOAD, CHANNEL_MODULE_RELOAD, CHANNEL_CLI_RELOAD, CHANNEL_MANAGER_RELOAD }
	Channel reload reasons for manager events at load or reload of configuration. More...
Functions
int	__ast_answer (struct ast_channel *chan, unsigned int delay, int cdr_answer)
	Answer a channel, with a selectable delay before returning.
struct ast_channel *attribute_malloc	__ast_channel_alloc (int needqueue, int state, const char cid_num, const char cid_name, const char acctcode, const char exten, const char context, const int amaflag, const char file, int line, const char function, const char name_fmt,...)
	Create a channel structure.
struct ast_channel *	__ast_request_and_dial (const char type, int format, void data, int timeout, int reason, const char cid_num, const char cid_name, struct outgoing_helper oh)
	Request a channel of a given type, with data as optional information used by the low level module and attempt to place a call on it.
int	ast_activate_generator (struct ast_channel chan, struct ast_generator gen, void *params)
int	ast_active_channels (void)
	returns number of active/allocated channels
static int	ast_add_fd (struct pollfd *pfd, int fd)
	if fd is a valid descriptor, set *pfd with the descriptor
int	ast_answer (struct ast_channel *chan)
	Answer a channel.
int	ast_autoservice_start (struct ast_channel *chan)
	Automatically service a channel for us...
int	ast_autoservice_stop (struct ast_channel *chan)
	Stop servicing a channel for us...
void	ast_begin_shutdown (int hangup)
	Initiate system shutdown.
int	ast_best_codec (int fmts)
	Pick the best audio codec.
struct ast_channel *	ast_bridged_channel (struct ast_channel *chan)
	Find bridged channel.
int	ast_call (struct ast_channel chan, char addr, int timeout)
	Make a call.
struct ast_channel *	ast_call_forward (struct ast_channel caller, struct ast_channel orig, int timeout, int format, struct outgoing_helper oh, int *outstate)
	Forwards a call to a new channel specified by the original channel's call_forward str. If possible, the new forwarded channel is created and returned while the original one is terminated.
void	ast_cancel_shutdown (void)
	Cancel a shutdown in progress.
const char *	ast_cause2str (int state) attribute_pure
	Gives the string form of a given hangup cause.
void	ast_change_name (struct ast_channel chan, char newname)
	Change channel name.
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_cmpwhentohangup (struct ast_channel *chan, time_t offset)
	Compare a offset with the settings of when to hang a channel up.
int	ast_channel_cmpwhentohangup_tv (struct ast_channel *chan, struct timeval offset)
	Compare a offset with the settings of when to hang a channel up.
int	ast_channel_datastore_add (struct ast_channel chan, struct ast_datastore datastore)
	Add a datastore to a channel.
struct ast_datastore *attribute_malloc	ast_channel_datastore_alloc (const struct ast_datastore_info info, const char uid)
	Create a channel data store object.
struct ast_datastore *	ast_channel_datastore_find (struct ast_channel chan, const struct ast_datastore_info info, const char *uid)
	Find a datastore on a channel.
int	ast_channel_datastore_free (struct ast_datastore *datastore)
	Free a channel data store object.
int	ast_channel_datastore_inherit (struct ast_channel from, struct ast_channel to)
	Inherit datastores from a parent to a child.
int	ast_channel_datastore_remove (struct ast_channel chan, struct ast_datastore datastore)
	Remove a datastore from a channel.
int	ast_channel_defer_dtmf (struct ast_channel *chan)
	Set defer DTMF flag on channel.
int	ast_channel_early_bridge (struct ast_channel c0, struct ast_channel c1)
	Bridge two channels together (early).
void	ast_channel_free (struct ast_channel *)
	Free a channel structure.
static enum ast_t38_state	ast_channel_get_t38_state (struct ast_channel *chan)
	Retrieves the current T38 state of a channel.
void	ast_channel_inherit_variables (const struct ast_channel parent, struct ast_channel child)
	Inherits channel variable from parent to child channel.
int	ast_channel_make_compatible (struct ast_channel c0, struct ast_channel c1)
	Makes two channel formats compatible.
int	ast_channel_masquerade (struct ast_channel original, struct ast_channel clone)
	Weird function made for call transfers.
int	ast_channel_queryoption (struct ast_channel channel, int option, void data, int *datalen, int block)
const char *	ast_channel_reason2str (int reason)
	return an english explanation of the code returned thru __ast_request_and_dial's 'outstate' argument
int	ast_channel_register (const struct ast_channel_tech *tech)
	Register a channel technology (a new channel driver) Called by a channel module to register the kind of channels it supports.
int	ast_channel_sendhtml (struct ast_channel channel, int subclass, const char data, int datalen)
int	ast_channel_sendurl (struct ast_channel channel, const char url)
void	ast_channel_set_fd (struct ast_channel *chan, int which, int fd)
int	ast_channel_setoption (struct ast_channel channel, int option, void data, int datalen, int block)
	Sets an option on a channel.
void	ast_channel_setwhentohangup (struct ast_channel *chan, time_t offset)
	Set when to hang a channel up.
void	ast_channel_setwhentohangup_tv (struct ast_channel *chan, struct timeval offset)
	Set when to hang a channel up.
struct ast_silence_generator *	ast_channel_start_silence_generator (struct ast_channel *chan)
	Starts a silence generator on the given channel.
void	ast_channel_stop_silence_generator (struct ast_channel chan, struct ast_silence_generator state)
	Stops a previously-started silence generator on the given channel.
int	ast_channel_supports_html (struct ast_channel *channel)
void	ast_channel_undefer_dtmf (struct ast_channel *chan)
	Unset defer DTMF flag on channel.
void	ast_channel_unregister (const struct ast_channel_tech *tech)
	Unregister a channel technology.
struct ast_channel *	ast_channel_walk_locked (const struct ast_channel *prev)
	Browse channels in use Browse the channels currently in use.
struct ast_variable *	ast_channeltype_list (void)
	return an ast_variable list of channeltypes
int	ast_check_hangup (struct ast_channel *chan)
	Check to see if a channel is needing hang up.
void	ast_deactivate_generator (struct ast_channel *chan)
int	ast_do_masquerade (struct ast_channel *chan)
	Start masquerading a channel XXX This is a seriously whacked out operation. We're essentially putting the guts of the clone channel into the original channel. Start by killing off the original channel's backend. I'm not sure we're going to keep this function, because while the features are nice, the cost is very high in terms of pure nastiness. XXX.
static int	ast_fdisset (struct pollfd pfds, int fd, int maximum, int start)
	Helper function for migrating select to poll.
struct ast_channel *	ast_get_channel_by_exten_locked (const char exten, const char context)
	Get channel by exten (and optionally context) and lock it.
struct ast_channel *	ast_get_channel_by_name_locked (const char *chan)
	Get channel by name or uniqueid (locks channel).
struct ast_channel *	ast_get_channel_by_name_prefix_locked (const char *name, const int namelen)
	Get channel by name or uniqueid prefix (locks channel).
struct ast_channel_tech *	ast_get_channel_tech (const char *name)
	Get a channel technology structure by name.
ast_group_t	ast_get_group (const char *s)
int	ast_hangup (struct ast_channel *chan)
	Hang up a channel.
int	ast_indicate (struct ast_channel *chan, int condition)
	Indicates condition of channel.
int	ast_indicate_data (struct ast_channel chan, int condition, const void data, size_t datalen)
	Indicates condition of channel, with payload.
int	ast_internal_timing_enabled (struct ast_channel *chan)
	Check if the channel can run in internal timing mode.
void	ast_poll_channel_add (struct ast_channel chan0, struct ast_channel chan1)
void	ast_poll_channel_del (struct ast_channel chan0, struct ast_channel chan1)
char *	ast_print_group (char *buf, int buflen, ast_group_t group)
	print call- and pickup groups into buffer
int	ast_prod (struct ast_channel *chan)
	Send empty audio to prime a channel driver.
int	ast_queue_control (struct ast_channel *chan, enum ast_control_frame_type control)
	Queue a control frame with payload.
int	ast_queue_control_data (struct ast_channel chan, enum ast_control_frame_type control, const void data, size_t datalen)
	Queue a control frame with payload.
int	ast_queue_frame (struct ast_channel chan, struct ast_frame f)
	Queue one or more frames to a channel's frame queue.
int	ast_queue_frame_head (struct ast_channel chan, struct ast_frame f)
	Queue one or more frames to the head of a channel's frame queue.
int	ast_queue_hangup (struct ast_channel *chan)
	Queue a hangup frame.
int	ast_queue_hangup_with_cause (struct ast_channel *chan, int cause)
	Queue a hangup frame with hangupcause set.
int	ast_raw_answer (struct ast_channel *chan, int cdr_answer)
	Answer a channel.
struct ast_frame *	ast_read (struct ast_channel *chan)
	Reads a frame.
struct ast_frame *	ast_read_noaudio (struct ast_channel *chan)
	Reads a frame, returning AST_FRAME_NULL frame if audio.
int	ast_readstring (struct ast_channel c, char s, int len, int timeout, int rtimeout, char *enders)
int	ast_readstring_full (struct ast_channel c, char s, int len, int timeout, int rtimeout, char *enders, int audiofd, int ctrlfd)
int	ast_recvchar (struct ast_channel *chan, int timeout)
	Receives a text character from a channel.
char *	ast_recvtext (struct ast_channel *chan, int timeout)
	Receives a text string from a channel Read a string of text from a channel.
struct ast_channel *	ast_request (const char type, int format, void data, int *status)
	Requests a channel.
struct ast_channel *	ast_request_and_dial (const char type, int format, void data, int timeout, int reason, const char cid_num, const char *cid_name)
	Request a channel of a given type, with data as optional information used by the low level module and attempt to place a call on it.
int	ast_safe_sleep (struct ast_channel *chan, int ms)
	Wait for a specified 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 specified amount of time, looking for hangups and a condition argument.
static int	ast_select (int nfds, fd_set rfds, fd_set wfds, fd_set efds, struct timeval tvp)
	Waits for activity on a group of channels.
int	ast_senddigit (struct ast_channel *chan, char digit, unsigned int duration)
	Send a DTMF digit to a channel Send a DTMF digit to a channel.
int	ast_senddigit_begin (struct ast_channel *chan, char digit)
	Send a DTMF digit to a channel Send a DTMF digit to a channel.
int	ast_senddigit_end (struct ast_channel *chan, char digit, unsigned int duration)
	Send a DTMF digit to a channel.
int	ast_sendtext (struct ast_channel chan, const char text)
	Sends text to a channel.
void	ast_set_callerid (struct ast_channel chan, const char cid_num, const char cid_name, const char cid_ani)
	Set caller ID number, name and ANI.
int	ast_set_read_format (struct ast_channel *chan, int format)
	Sets read format on channel chan Set read format for channel to whichever component of "format" is best.
void	ast_set_variables (struct ast_channel chan, struct ast_variable vars)
	adds a list of channel variables to a channel
int	ast_set_write_format (struct ast_channel *chan, int format)
	Sets write format on channel chan Set write format for channel to whichever component of "format" is best.
int	ast_setstate (struct ast_channel *chan, enum ast_channel_state)
	Change the state of a channel.
int	ast_settimeout (struct ast_channel c, unsigned int rate, int(func)(const void data), void data)
	Enable or disable timer ticks for a channel.
int	ast_shutting_down (void)
	Returns non-zero if Asterisk is being shut down.
int	ast_softhangup (struct ast_channel *chan, int cause)
	Softly hangup up a channel.
int	ast_softhangup_nolock (struct ast_channel *chan, int cause)
	Softly hangup up a channel (no channel lock).
const char *	ast_state2str (enum ast_channel_state)
	Gives the string form of a given channel state.
int	ast_str2cause (const char *name) attribute_pure
	Convert a symbolic hangup cause to number.
int	ast_tonepair (struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
int	ast_tonepair_start (struct ast_channel *chan, int freq1, int freq2, int duration, int vol)
void	ast_tonepair_stop (struct ast_channel *chan)
int	ast_transfer (struct ast_channel chan, char dest)
	Transfer a channel (if supported). Returns -1 on error, 0 if not supported and 1 if supported and requested.
char *	ast_transfercapability2str (int transfercapability) attribute_const
	Gives the string form of a given transfer capability.
int	ast_waitfor (struct ast_channel *chan, int ms)
	Wait for input on a channel.
struct ast_channel *	ast_waitfor_n (struct ast_channel *chan, int n, int ms)
	Waits for input on a group of channels Wait for input on an array of channels for a given # of milliseconds.
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.
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.
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)
	Wait for a digit Same as ast_waitfordigit() with audio fd for outputting read audio and ctrlfd to monitor for reading.
struct ast_channel *	ast_walk_channel_by_exten_locked (const struct ast_channel chan, const char exten, const char *context)
	Get next channel by exten (and optionally context) and lock it.
struct ast_channel *	ast_walk_channel_by_name_prefix_locked (const struct ast_channel chan, const char name, const int namelen)
	Get channel by name or uniqueid prefix (locks channel).
int	ast_write (struct ast_channel chan, struct ast_frame frame)
	Write a frame to a channel This function writes the given frame to the indicated channel.
int	ast_write_text (struct ast_channel chan, struct ast_frame frame)
	Write text frame to a channel This function writes the given frame to the indicated channel.
int	ast_write_video (struct ast_channel chan, struct ast_frame frame)
	Write video frame to a channel This function writes the given frame to the indicated channel.
const char *	channelreloadreason2txt (enum channelreloadreason reason)
	Convert enum channelreloadreason to text string for manager event.
Variables
unsigned long	global_fin
unsigned long	global_fout

Detailed Description

General Asterisk PBX channel definitions.

See also:

Definition in file channel.h.

Define Documentation

#define AST_AGENT_FD (AST_MAX_FDS-3)

used by agents for pass through

Definition at line 160 of file channel.h.

Referenced by agent_read().

#define AST_ALERT_FD (AST_MAX_FDS-1)

used for alertpipe

Definition at line 158 of file channel.h.

Referenced by __ast_channel_alloc_ap().

#define AST_BRIDGE_DTMF_CHANNEL_0 (1 << 0)

Report DTMF on channel 0.

Definition at line 1350 of file channel.h.

Referenced by ast_generic_bridge(), ast_rtp_bridge(), bridge_native_loop(), bridge_p2p_loop(), dahdi_bridge(), iax2_bridge(), misdn_bridge(), and set_config_flags().

#define AST_BRIDGE_DTMF_CHANNEL_1 (1 << 1)

Report DTMF on channel 1.

Definition at line 1352 of file channel.h.

Referenced by ast_generic_bridge(), ast_rtp_bridge(), bridge_native_loop(), bridge_p2p_loop(), dahdi_bridge(), iax2_bridge(), misdn_bridge(), and set_config_flags().

#define AST_BRIDGE_IGNORE_SIGS (1 << 4)

Ignore all signal frames except NULL.

Definition at line 1358 of file channel.h.

Referenced by ast_generic_bridge(), bridge_native_loop(), bridge_p2p_loop(), and iax2_bridge().

#define AST_BRIDGE_REC_CHANNEL_0 (1 << 2)

Return all voice frames on channel 0.

Definition at line 1354 of file channel.h.

#define AST_BRIDGE_REC_CHANNEL_1 (1 << 3)

Return all voice frames on channel 1.

Definition at line 1356 of file channel.h.

#define ast_channel_alloc	(	needqueue,
		state,
		cid_num,
		cid_name,
		acctcode,
		exten,
		context,
		amaflag,
		...	)

Value:

__ast_channel_alloc(needqueue, state, cid_num, cid_name, acctcode, exten, context, amaflag, \
             __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__)

Definition at line 723 of file channel.h.

Referenced by __oh323_new(), acf_odbc_read(), acf_odbc_write(), action_bridge(), action_getvar(), agent_new(), alsa_new(), ast_async_goto(), ast_iax2_new(), ast_pbx_outgoing_cdr_failed(), ast_pbx_outgoing_exten(), bridge_exec(), builtin_atxfer(), check_goto_on_transfer(), console_new(), dahdi_new(), gtalk_new(), iax_park(), jingle_new(), local_new(), make_email_file(), masq_park_call(), mgcp_new(), misdn_new(), nbs_new(), oss_new(), pbx_substitute_variables_helper_full(), phone_new(), rotate_file(), sendmail(), sendpage(), sip_new(), sip_park(), skinny_new(), unistim_new(), and usbradio_new().

#define AST_CHANNEL_NAME 80

Max length of an ast_channel name

Definition at line 136 of file channel.h.

Referenced by ast_channel_free(), ast_do_masquerade(), ast_park_call_full(), ast_parse_device_state(), ast_setstate(), common_exec(), create_jb(), fast_originate(), page_exec(), and softhangup_exec().

#define AST_GENERATOR_FD (AST_MAX_FDS-4)

used by generator

Definition at line 161 of file channel.h.

Referenced by __ast_read(), ast_deactivate_generator(), and ast_do_masquerade().

#define AST_MAX_CONTEXT 80

Max length of a context

Definition at line 135 of file channel.h.

Referenced by _macro_exec(), cleanup_stale_contexts(), common_exec(), conf_run(), gtalk_load_config(), handle_gosub(), reload_config(), and try_calling().

#define AST_MAX_EXTENSION 80

Max length of an extension

Definition at line 134 of file channel.h.

Referenced by advanced_options(), ast_bridge_call(), ast_device_state_changed(), ast_devstate_changed(), ast_extension_state2(), ast_ivr_menu_run_internal(), begin_dial_channel(), build_device(), conf_run(), destroy_station(), dial_exec_full(), disa_exec(), do_forward(), dundi_lookup_local(), forward_message(), function_enum(), get_destination(), handle_gosub(), handle_statechange(), load_config(), load_module(), log_exec(), manage_parkinglot(), manager_show_dialplan_helper(), mgcp_ss(), park_add_hints(), park_call_exec(), phone_check_exception(), realtime_switch_common(), search_directory(), show_dialplan_helper(), skinny_extensionstate_cb(), skinny_ss(), sla_build_station(), speech_background(), ss_thread(), transmit_state_notify(), try_calling(), vm_authenticate(), and vmauthenticate().

#define AST_MAX_FDS 10

Definition at line 153 of file channel.h.

Referenced by __ast_channel_alloc_ap(), ast_channel_free(), ast_do_masquerade(), ast_poll_channel_add(), ast_poll_channel_del(), ast_waitfor_nandfds(), and manage_parkinglot().

#define AST_TIMING_FD (AST_MAX_FDS-2)

used for timingfd

Definition at line 159 of file channel.h.

Referenced by __ast_channel_alloc_ap(), __ast_read(), agent_read(), and ast_do_masquerade().

#define CHECK_BLOCKING ( c )

Definition at line 1743 of file channel.h.

Referenced by ast_sendtext(), ast_waitfor_nandfds(), ast_write(), dahdi_read(), and phone_read().

#define DATASTORE_INHERIT_FOREVER INT_MAX

Definition at line 151 of file channel.h.

Referenced by _macro_exec(), acf_iaxvar_write(), add_features_datastores(), ast_channel_datastore_inherit(), ast_iax2_new(), authenticate_reply(), dial_exec_full(), socket_process(), and try_calling().

#define DEBUGCHAN_FLAG 0x80000000

The high bit of the frame count is used as a debug marker, so increments of the counters must be done with care. Please use c->fin = FRAMECOUNT_INC(c->fin) and the same for c->fout.

Definition at line 334 of file channel.h.

Referenced by __ast_read(), ast_write(), handle_core_set_debug_channel(), handle_showchan(), and serialize_showchan().

#define FRAMECOUNT_INC ( x ) ( ((x) & DEBUGCHAN_FLAG) | (((x)+1) & ~DEBUGCHAN_FLAG) )

Definition at line 337 of file channel.h.

Referenced by __ast_read(), and ast_write().

#define MAX_LANGUAGE 20

Max length of the language setting

Definition at line 137 of file channel.h.

#define MAX_MUSICCLASS 80

Max length of the music class setting

Definition at line 138 of file channel.h.

Typedef Documentation

typedef unsigned long long ast_group_t

Definition at line 170 of file channel.h.

Enumeration Type Documentation

anonymous enum

ast_channel_tech Properties

Enumerator:

AST_CHAN_TP_WANTSJITTER	Channels have this property if they can accept input with jitter; i.e. most VoIP channels.
AST_CHAN_TP_CREATESJITTER	Channels have this property if they can create jitter; i.e. most VoIP channels.

Definition at line 510 of file channel.h.

00510      {
00511    /*! \brief Channels have this property if they can accept input with jitter;
00512     *         i.e. most VoIP channels */
00513    AST_CHAN_TP_WANTSJITTER = (1 << 0),
00514    /*! \brief Channels have this property if they can create jitter;
00515     *         i.e. most VoIP channels */
00516    AST_CHAN_TP_CREATESJITTER = (1 << 1),
00517 };

anonymous enum

ast_channel flags

Enumerator:

AST_FLAG_DEFER_DTMF	Queue incoming dtmf, to be released when this flag is turned off
AST_FLAG_WRITE_INT	write should be interrupt generator
AST_FLAG_BLOCKING	a thread is blocking on this channel
AST_FLAG_ZOMBIE	This is a zombie channel
AST_FLAG_EXCEPTION	There is an exception pending
AST_FLAG_MOH	Listening to moh XXX anthm promises me this will disappear XXX
AST_FLAG_SPYING	This channel is spying on another channel
AST_FLAG_NBRIDGE	This channel is in a native bridge
AST_FLAG_IN_AUTOLOOP	the channel is in an auto-incrementing dialplan processor, so when ->priority is set, it will get incremented before finding the next priority to run
AST_FLAG_OUTGOING	This is an outgoing call
AST_FLAG_IN_DTMF	A DTMF_BEGIN frame has been read from this channel, but not yet an END
AST_FLAG_EMULATE_DTMF	A DTMF_END was received when not IN_DTMF, so the length of the digit is currently being emulated
AST_FLAG_END_DTMF_ONLY	This is set to tell the channel not to generate DTMF begin frames, and to instead only generate END frames.
AST_FLAG_ANSWERED_ELSEWHERE	Flag to show channels that this call is hangup due to the fact that the call was indeed anwered, but in another channel
AST_FLAG_MASQ_NOSTREAM	This flag indicates that on a masquerade, an active stream should not be carried over
AST_FLAG_BRIDGE_HANGUP_RUN	This flag indicates that the hangup exten was run when the bridge terminated, a message aimed at preventing a subsequent hangup exten being run at the pbx_run level
AST_FLAG_BRIDGE_HANGUP_DONT	This flag indicates that the hangup exten should NOT be run when the bridge terminates, this will allow the hangup in the pbx loop to be run instead.

Definition at line 520 of file channel.h.

00520      {
00521    /*! Queue incoming dtmf, to be released when this flag is turned off */
00522    AST_FLAG_DEFER_DTMF =    (1 << 1),
00523    /*! write should be interrupt generator */
00524    AST_FLAG_WRITE_INT =     (1 << 2),
00525    /*! a thread is blocking on this channel */
00526    AST_FLAG_BLOCKING =      (1 << 3),
00527    /*! This is a zombie channel */
00528    AST_FLAG_ZOMBIE =        (1 << 4),
00529    /*! There is an exception pending */
00530    AST_FLAG_EXCEPTION =     (1 << 5),
00531    /*! Listening to moh XXX anthm promises me this will disappear XXX */
00532    AST_FLAG_MOH =           (1 << 6),
00533    /*! This channel is spying on another channel */
00534    AST_FLAG_SPYING =        (1 << 7),
00535    /*! This channel is in a native bridge */
00536    AST_FLAG_NBRIDGE =       (1 << 8),
00537    /*! the channel is in an auto-incrementing dialplan processor,
00538     *  so when ->priority is set, it will get incremented before
00539     *  finding the next priority to run */
00540    AST_FLAG_IN_AUTOLOOP =   (1 << 9),
00541    /*! This is an outgoing call */
00542    AST_FLAG_OUTGOING =      (1 << 10),
00543    /*! A DTMF_BEGIN frame has been read from this channel, but not yet an END */
00544    AST_FLAG_IN_DTMF =       (1 << 12),
00545    /*! A DTMF_END was received when not IN_DTMF, so the length of the digit is
00546     *  currently being emulated */
00547    AST_FLAG_EMULATE_DTMF =  (1 << 13),
00548    /*! This is set to tell the channel not to generate DTMF begin frames, and
00549     *  to instead only generate END frames. */
00550    AST_FLAG_END_DTMF_ONLY = (1 << 14),
00551    /*! Flag to show channels that this call is hangup due to the fact that the call
00552        was indeed anwered, but in another channel */
00553    AST_FLAG_ANSWERED_ELSEWHERE = (1 << 15),
00554    /*! This flag indicates that on a masquerade, an active stream should not
00555     *  be carried over */
00556    AST_FLAG_MASQ_NOSTREAM = (1 << 16),
00557    /*! This flag indicates that the hangup exten was run when the bridge terminated,
00558     *  a message aimed at preventing a subsequent hangup exten being run at the pbx_run
00559     *  level */
00560    AST_FLAG_BRIDGE_HANGUP_RUN = (1 << 17),
00561    /*! This flag indicates that the hangup exten should NOT be run when the
00562     *  bridge terminates, this will allow the hangup in the pbx loop to be run instead.
00563     *  */
00564    AST_FLAG_BRIDGE_HANGUP_DONT = (1 << 18),
00565 };

anonymous enum

ast_bridge_config flags

Enumerator:

AST_FEATURE_PLAY_WARNING
AST_FEATURE_REDIRECT
AST_FEATURE_DISCONNECT
AST_FEATURE_ATXFER
AST_FEATURE_AUTOMON
AST_FEATURE_PARKCALL
AST_FEATURE_AUTOMIXMON
AST_FEATURE_NO_H_EXTEN
AST_FEATURE_WARNING_ACTIVE

Definition at line 568 of file channel.h.

00568      {
00569    AST_FEATURE_PLAY_WARNING = (1 << 0),
00570    AST_FEATURE_REDIRECT =     (1 << 1),
00571    AST_FEATURE_DISCONNECT =   (1 << 2),
00572    AST_FEATURE_ATXFER =       (1 << 3),
00573    AST_FEATURE_AUTOMON =      (1 << 4),
00574    AST_FEATURE_PARKCALL =     (1 << 5),
00575    AST_FEATURE_AUTOMIXMON =   (1 << 6),
00576    AST_FEATURE_NO_H_EXTEN =   (1 << 7),
00577    AST_FEATURE_WARNING_ACTIVE = (1 << 8),
00578 };

anonymous enum

Enumerator:

AST_CDR_TRANSFER
AST_CDR_FORWARD
AST_CDR_CALLWAIT
AST_CDR_CONFERENCE

Definition at line 617 of file channel.h.

00617      {
00618    AST_CDR_TRANSFER =   (1 << 0),
00619    AST_CDR_FORWARD =    (1 << 1),
00620    AST_CDR_CALLWAIT =   (1 << 2),
00621    AST_CDR_CONFERENCE = (1 << 3),
00622 };

anonymous enum

Enumerator:

AST_SOFTHANGUP_DEV	Soft hangup by device
AST_SOFTHANGUP_ASYNCGOTO	Soft hangup for async goto
AST_SOFTHANGUP_SHUTDOWN
AST_SOFTHANGUP_TIMEOUT
AST_SOFTHANGUP_APPUNLOAD
AST_SOFTHANGUP_EXPLICIT
AST_SOFTHANGUP_UNBRIDGE

Definition at line 624 of file channel.h.

00624      {
00625    /*! Soft hangup by device */
00626    AST_SOFTHANGUP_DEV =       (1 << 0),
00627    /*! Soft hangup for async goto */
00628    AST_SOFTHANGUP_ASYNCGOTO = (1 << 1),
00629    AST_SOFTHANGUP_SHUTDOWN =  (1 << 2),
00630    AST_SOFTHANGUP_TIMEOUT =   (1 << 3),
00631    AST_SOFTHANGUP_APPUNLOAD = (1 << 4),
00632    AST_SOFTHANGUP_EXPLICIT =  (1 << 5),
00633    AST_SOFTHANGUP_UNBRIDGE =  (1 << 6),
00634 };

enum ast_bridge_result

Enumerator:

AST_BRIDGE_COMPLETE
AST_BRIDGE_FAILED
AST_BRIDGE_FAILED_NOWARN
AST_BRIDGE_RETRY

Definition at line 163 of file channel.h.

00163                        {
00164    AST_BRIDGE_COMPLETE = 0,
00165    AST_BRIDGE_FAILED = -1,
00166    AST_BRIDGE_FAILED_NOWARN = -2,
00167    AST_BRIDGE_RETRY = -3,
00168 };

enum ast_channel_adsicpe

Enumerator:

AST_ADSI_UNKNOWN
AST_ADSI_AVAILABLE
AST_ADSI_UNAVAILABLE
AST_ADSI_OFFHOOKONLY

Definition at line 345 of file channel.h.

00345                          {
00346    AST_ADSI_UNKNOWN,
00347    AST_ADSI_AVAILABLE,
00348    AST_ADSI_UNAVAILABLE,
00349    AST_ADSI_OFFHOOKONLY,
00350 };

enum ast_channel_state

ast_channel states

Note:: Bits 0-15 of state are reserved for the state (up/down) of the line Bits 16-32 of state are reserved for flags

Enumerator:

AST_STATE_DOWN	Channel is down and available
AST_STATE_RESERVED	Channel is down, but reserved
AST_STATE_OFFHOOK	Channel is off hook
AST_STATE_DIALING	Digits (or equivalent) have been dialed
AST_STATE_RING	Line is ringing
AST_STATE_RINGING	Remote end is ringing
AST_STATE_UP	Line is up
AST_STATE_BUSY	Line is busy
AST_STATE_DIALING_OFFHOOK	Digits (or equivalent) have been dialed while offhook
AST_STATE_PRERING	Channel has detected an incoming call and is waiting for ring
AST_STATE_MUTE	Do not transmit voice data

Definition at line 358 of file channel.h.

00358                        {
00359    AST_STATE_DOWN,         /*!< Channel is down and available */
00360    AST_STATE_RESERVED,     /*!< Channel is down, but reserved */
00361    AST_STATE_OFFHOOK,      /*!< Channel is off hook */
00362    AST_STATE_DIALING,      /*!< Digits (or equivalent) have been dialed */
00363    AST_STATE_RING,         /*!< Line is ringing */
00364    AST_STATE_RINGING,      /*!< Remote end is ringing */
00365    AST_STATE_UP,        /*!< Line is up */
00366    AST_STATE_BUSY,         /*!< Line is busy */
00367    AST_STATE_DIALING_OFFHOOK, /*!< Digits (or equivalent) have been dialed while offhook */
00368    AST_STATE_PRERING,      /*!< Channel has detected an incoming call and is waiting for ring */
00369 
00370    AST_STATE_MUTE = (1 << 16),   /*!< Do not transmit voice data */
00371 };

enum ast_t38_state

Possible T38 states on channels.

Enumerator:

T38_STATE_UNAVAILABLE	T38 is unavailable on this channel or disabled by configuration
T38_STATE_UNKNOWN	The channel supports T38 but the current status is unknown
T38_STATE_NEGOTIATING	T38 is being negotiated
T38_STATE_REJECTED	Remote side has rejected our offer
T38_STATE_NEGOTIATED	T38 established

Definition at line 376 of file channel.h.

00376                    {
00377    T38_STATE_UNAVAILABLE,  /*!< T38 is unavailable on this channel or disabled by configuration */
00378    T38_STATE_UNKNOWN,   /*!< The channel supports T38 but the current status is unknown */
00379    T38_STATE_NEGOTIATING,  /*!< T38 is being negotiated */
00380    T38_STATE_REJECTED,  /*!< Remote side has rejected our offer */
00381    T38_STATE_NEGOTIATED,   /*!< T38 established */
00382 };

enum channelreloadreason

Channel reload reasons for manager events at load or reload of configuration.

Enumerator:

CHANNEL_MODULE_LOAD
CHANNEL_MODULE_RELOAD
CHANNEL_CLI_RELOAD
CHANNEL_MANAGER_RELOAD

Definition at line 638 of file channel.h.

00638                          {
00639    CHANNEL_MODULE_LOAD,
00640    CHANNEL_MODULE_RELOAD,
00641    CHANNEL_CLI_RELOAD,
00642    CHANNEL_MANAGER_RELOAD,
00643 };

Function Documentation

int __ast_answer	(	struct ast_channel *	chan,
		unsigned int	delay,
		int	cdr_answer
	)

Answer a channel, with a selectable delay before returning.

Parameters:

	chan	channel to answer
	delay	maximum amount of time to wait for incoming media
	cdr_answer	flag to control whether any associated CDR should be marked as 'answered'

This function answers a channel and handles all necessary call setup functions.

Note:: The channel passed does not need to be locked, but is locked by the function when needed.; This function will wait up to 'delay' milliseconds for media to arrive on the channel before returning to the caller, so that the caller can properly assume the channel is 'ready' for media flow. If 'delay' is less than 500, the function will wait up to 500 milliseconds.

Return values:

	0	on success
	non-zero	on failure

Definition at line 1784 of file channel.c.

References ast_channel::_state, ast_channel_lock, ast_channel_unlock, AST_CONTROL_HANGUP, ast_debug, AST_FRAME_CNG, AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_HTML, AST_FRAME_IAX, AST_FRAME_IMAGE, AST_FRAME_MODEM, AST_FRAME_NULL, AST_FRAME_TEXT, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree, ast_frisolate(), AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_HEAD_NOLOCK, AST_LIST_INSERT_HEAD, AST_LIST_REMOVE_HEAD, ast_log(), ast_queue_frame_head(), ast_raw_answer(), ast_read(), AST_STATE_RING, AST_STATE_RINGING, ast_waitfor(), errno, frames, ast_frame::frametype, LOG_WARNING, MAX, and ast_frame::subclass.

Referenced by ast_answer(), dial_exec_full(), pbx_builtin_answer(), and pbx_builtin_incomplete().

01786 01787 01788 01789 01790 01791 01792    } 01793 01794 01795 01796 01797 01798 01799 01800 01801 01802 01803 01804 01805 01806 01807 01808 01809 01810 01811 01812 01813 01814 01815 01816 01817 01818 01819 01820 01821 01822 01823 01824 01825 01826 01827 01828 01829 01830 01831 01832 01833 01834 01835 01836 01837 01838 01839 01840 01841 01842 01843 01844 01845 01846 01847 01848 01849 01850 01851 01852 01853 01854 01855 01856 01857 01858 01859 01860 01861 01862 01863 01864 01865 01866          } 01867 01868 01869 01870 01871 01872 01873 01874 01875          } 01876 01877 01878 01879 01880    } 01881 01882 01883 }

class="fragment">01785 { int res = 0; enum ast_channel_state old_state; old_state = chan->_state; if ((res = ast_raw_answer(chan, cdr_answer))) { return res; switch (old_state) { case AST_STATE_RINGING: case AST_STATE_RING: /* wait for media to start flowing, but don't wait any longer * than 'delay' or 500 milliseconds, whichever is longer */ do { AST_LIST_HEAD_NOLOCK(, ast_frame) frames; struct ast_frame *cur, *new; int ms = MAX(delay, 500); unsigned int done = 0; AST_LIST_HEAD_INIT_NOLOCK(&frames); for (;;) { ms = ast_waitfor(chan, ms); if (ms < 0) { ast_log(LOG_WARNING, "Error condition occurred when polling channel %s for a voice frame: %s\n", chan->name, strerror(errno)); res = -1; break; } if (ms == 0) { ast_debug(2, "Didn't receive a media frame from %s within %d ms of answering. Continuing anyway\n", chan->name, MAX(delay, 500)); break; } cur = ast_read(chan); if (!cur || ((cur->frametype == AST_FRAME_CONTROL) && (cur->subclass == AST_CONTROL_HANGUP))) { if (cur) { ast_frfree(cur); } res = -1; ast_debug(2, "Hangup of channel %s detected in answer routine\n", chan->name); break; } if ((new = ast_frisolate(cur)) != cur) { ast_frfree(cur); } AST_LIST_INSERT_HEAD(&frames, new, frame_list); /* if a specific delay period was requested, continue * until that delay has passed. don't stop just because * incoming media has arrived. */ if (delay) { continue; } switch (new->frametype) { /* all of these frametypes qualify as 'media' */ case AST_FRAME_VOICE: case AST_FRAME_VIDEO: case AST_FRAME_TEXT: case AST_FRAME_DTMF_BEGIN: case AST_FRAME_DTMF_END: case AST_FRAME_IMAGE: case AST_FRAME_HTML: case AST_FRAME_MODEM: done = 1; break; case AST_FRAME_CONTROL: case AST_FRAME_IAX: case AST_FRAME_NULL: case AST_FRAME_CNG: break; } if (done) { break; } if (res == 0) { ast_channel_lock(chan); while ((cur = AST_LIST_REMOVE_HEAD(&frames, frame_list))) { ast_queue_frame_head(chan, cur); ast_frfree(cur); } ast_channel_unlock(chan); } while (0); break; default: break; return res;

struct ast_channel* attribute_malloc __ast_channel_alloc	(	int	needqueue,
		int	state,
		const char *	cid_num,
		const char *	cid_name,
		const char *	acctcode,
		const char *	exten,
		const char *	context,
		const int	amaflag,
		const char *	file,
		int	line,
		const char *	function,
		const char *	name_fmt,
			...
	)			`[read]`

Create a channel structure.

Return values:

	NULL	failure
	non-NULL	successfully allocated channel

Note:: By default, new channels are set to the "s" extension and "default" context.

Definition at line 964 of file channel.c.

References __ast_channel_alloc_ap().

00969 {
00970    va_list ap1, ap2;
00971    struct ast_channel *result;
00972 
00973    va_start(ap1, name_fmt);
00974    va_start(ap2, name_fmt);
00975    result = __ast_channel_alloc_ap(needqueue, state, cid_num, cid_name, acctcode, exten, context,
00976                amaflag, file, line, function, name_fmt, ap1, ap2);
00977    va_end(ap1);
00978    va_end(ap2);
00979 
00980    return result;
00981 }

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

Request a channel of a given type, with data as optional information used by the low level module and attempt to place a call on it.

Parameters:

	type	type of channel to request
	format	requested channel format
	data	data to pass to the channel requester
	timeout	maximum amount of time to wait for an answer
	reason	why unsuccessful (if unsuccessful)
	cid_num	Caller-ID Number
	cid_name	Caller-ID Name (ascii)
	oh	Outgoing helper

Returns:: Returns an ast_channel on success or no answer, NULL on failure. Check the value of chan->_state to know if the call was answered or not.

Definition at line 3734 of file channel.c.

References ast_channel::_state, outgoing_helper::account, ast_call(), ast_call_forward(), AST_CAUSE_NO_ANSWER, ast_cdr_alloc(), ast_cdr_disposition(), ast_cdr_end(), ast_cdr_failed(), AST_CDR_FLAG_ORIGINATED, ast_cdr_init(), ast_cdr_setaccount(), ast_cdr_setapp(), ast_cdr_start(), ast_cdr_update(), ast_channel_datastore_inherit(), ast_channel_inherit_variables(), AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_HANGUP, AST_CONTROL_HOLD, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, AST_CONTROL_SRCUPDATE, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, ast_copy_string(), AST_FRAME_CONTROL, ast_frfree, ast_hangup(), ast_log(), ast_read(), ast_request(), ast_set_callerid(), ast_set_flag, ast_set_variables(), AST_STATE_UP, ast_strlen_zero(), ast_waitfor(), ast_channel::cdr, outgoing_helper::cid_name, outgoing_helper::cid_num, ast_channel::context, outgoing_helper::context, ast_channel::exten, outgoing_helper::exten, f, ast_frame::frametype, handle_cause(), ast_channel::hangupcause, LOG_NOTICE, outgoing_helper::parent_channel, ast_channel::priority, outgoing_helper::priority, ast_frame::subclass, and outgoing_helper::vars.

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

03735 {
03736    int dummy_outstate;
03737    int cause = 0;
03738    struct ast_channel *chan;
03739    int res = 0;
03740    int last_subclass = 0;
03741    
03742    if (outstate)
03743       *outstate = 0;
03744    else
03745       outstate = &dummy_outstate;   /* make outstate always a valid pointer */
03746 
03747    chan = ast_request(type, format, data, &cause);
03748    if (!chan) {
03749       ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
03750       handle_cause(cause, outstate);
03751       return NULL;
03752    }
03753 
03754    if (oh) {
03755       if (oh->vars)  
03756          ast_set_variables(chan, oh->vars);
03757       /* XXX why is this necessary, for the parent_channel perhaps ? */
03758       if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name))
03759          ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num);
03760       if (oh->parent_channel) {
03761          ast_channel_inherit_variables(oh->parent_channel, chan);
03762          ast_channel_datastore_inherit(oh->parent_channel, chan);
03763       }
03764       if (oh->account)
03765          ast_cdr_setaccount(chan, oh->account); 
03766    }
03767    ast_set_callerid(chan, cid_num, cid_name, cid_num);
03768    ast_set_flag(chan->cdr, AST_CDR_FLAG_ORIGINATED);
03769 
03770    if (ast_call(chan, data, 0)) {   /* ast_call failed... */
03771       ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
03772    } else {
03773       res = 1; /* mark success in case chan->_state is already AST_STATE_UP */
03774       while (timeout && chan->_state != AST_STATE_UP) {
03775          struct ast_frame *f;
03776          res = ast_waitfor(chan, timeout);
03777          if (res <= 0) /* error, timeout, or done */
03778             break;
03779          if (timeout > -1)
03780             timeout = res;
03781          if (!ast_strlen_zero(chan->call_forward)) {
03782             if (!(chan = ast_call_forward(NULL, chan, &timeout, format, oh, outstate))) {
03783                return NULL;
03784             }
03785             continue;
03786          }
03787 
03788          f = ast_read(chan);
03789          if (!f) {
03790             *outstate = AST_CONTROL_HANGUP;
03791             res = 0;
03792             break;
03793          }
03794          if (f->frametype == AST_FRAME_CONTROL) {
03795             switch (f->subclass) {
03796             case AST_CONTROL_RINGING:  /* record but keep going */
03797                *outstate = f->subclass;
03798                break;
03799 
03800             case AST_CONTROL_BUSY:
03801             case AST_CONTROL_CONGESTION:
03802             case AST_CONTROL_ANSWER:
03803                *outstate = f->subclass;
03804                timeout = 0;      /* trick to force exit from the while() */
03805                break;
03806 
03807             /* Ignore these */
03808             case AST_CONTROL_PROGRESS:
03809             case AST_CONTROL_PROCEEDING:
03810             case AST_CONTROL_HOLD:
03811             case AST_CONTROL_UNHOLD:
03812             case AST_CONTROL_VIDUPDATE:
03813             case AST_CONTROL_SRCUPDATE:
03814             case -1:       /* Ignore -- just stopping indications */
03815                break;
03816 
03817             default:
03818                ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass);
03819             }
03820             last_subclass = f->subclass;
03821          }
03822          ast_frfree(f);
03823       }
03824    }
03825 
03826    /* Final fixups */
03827    if (oh) {
03828       if (!ast_strlen_zero(oh->context))
03829          ast_copy_string(chan->context, oh->context, sizeof(chan->context));
03830       if (!ast_strlen_zero(oh->exten))
03831          ast_copy_string(chan->exten, oh->exten, sizeof(chan->exten));
03832       if (oh->priority) 
03833          chan->priority = oh->priority;
03834    }
03835    if (chan->_state == AST_STATE_UP)
03836       *outstate = AST_CONTROL_ANSWER;
03837 
03838    if (res <= 0) {
03839       if ( AST_CONTROL_RINGING == last_subclass ) 
03840          chan->hangupcause = AST_CAUSE_NO_ANSWER;
03841       if (!chan->cdr && (chan->cdr = ast_cdr_alloc()))
03842          ast_cdr_init(chan->cdr, chan);
03843       if (chan->cdr) {
03844          char tmp[256];
03845          snprintf(tmp, sizeof(tmp), "%s/%s", type, (char *)data);
03846          ast_cdr_setapp(chan->cdr,"Dial",tmp);
03847          ast_cdr_update(chan);
03848          ast_cdr_start(chan->cdr);
03849          ast_cdr_end(chan->cdr);
03850          /* If the cause wasn't handled properly */
03851          if (ast_cdr_disposition(chan->cdr,chan->hangupcause))
03852             ast_cdr_failed(chan->cdr);
03853       }
03854       ast_hangup(chan);
03855       chan = NULL;
03856    }
03857    return chan;
03858 }

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

Activate a given generator

Definition at line 1935 of file channel.c.

References ast_generator::alloc, ast_channel_lock, ast_channel_unlock, ast_prod(), ast_settimeout(), ast_channel::generator, generator_force(), ast_channel::generatordata, and ast_generator::release.

Referenced by app_exec(), ast_channel_start_silence_generator(), ast_linear_stream(), ast_playtones_start(), ast_tonepair_start(), channel_spy(), eivr_comm(), local_ast_moh_start(), old_milliwatt_exec(), and transmit_audio().

01936 {
01937    int res = 0;
01938 
01939    ast_channel_lock(chan);
01940 
01941    if (chan->generatordata) {
01942       if (chan->generator && chan->generator->release)
01943          chan->generator->release(chan, chan->generatordata);
01944       chan->generatordata = NULL;
01945    }
01946 
01947    ast_prod(chan);
01948    if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) {
01949       res = -1;
01950    }
01951    
01952    if (!res) {
01953       ast_settimeout(chan, 50, generator_force, chan);
01954       chan->generator = gen;
01955    }
01956 
01957    ast_channel_unlock(chan);
01958 
01959    return res;
01960 }

int ast_active_channels ( void )

returns number of active/allocated channels

Returns number of active/allocated channels

Definition at line 497 of file channel.c.

References AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, and channels.

Referenced by action_corestatus(), dahdi_restart(), handle_show_settings(), and quit_handler().

00498 {
00499    struct ast_channel *c;
00500    int cnt = 0;
00501    AST_RWLIST_RDLOCK(&channels);
00502    AST_RWLIST_TRAVERSE(&channels, c, chan_list)
00503       cnt++;
00504    AST_RWLIST_UNLOCK(&channels);
00505    return cnt;
00506 }

static int ast_add_fd	(	struct pollfd *	pfd,
		int	fd
	)			`[inline, static]`

if fd is a valid descriptor, set *pfd with the descriptor

Returns:: Return 1 (not -1!) if added, 0 otherwise (so we can add the return value to the index into the array)

Definition at line 1657 of file channel.h.

Referenced by ast_waitfor_nandfds().

01658 {
01659    pfd->fd = fd;
01660    pfd->events = POLLIN | POLLPRI;
01661    return fd >= 0;
01662 }

int ast_answer ( struct ast_channel * chan )

Answer a channel.

Parameters:

chan

channel to answer

This function answers a channel and handles all necessary call setup functions.

Note:: The channel passed does not need to be locked, but is locked by the function when needed.; This function will wait up to 500 milliseconds for media to arrive on the channel before returning to the caller, so that the caller can properly assume the channel is 'ready' for media flow.

Return values:

	0	on success
	non-zero	on failure

Definition at line 1885 of file channel.c.

References __ast_answer().

Referenced by action_bridge(), agi_exec_full(), alarmreceiver_exec(), answer_trunk_chan(), app_exec(), ast_control_streamfile(), ast_pickup_call(), auth_exec(), background_detect_exec(), bridge_exec(), builtin_parkcall(), common_exec(), conf_exec(), count_exec(), dahdiras_exec(), dictate_exec(), directory_exec(), disa_exec(), eivr_comm(), handle_answer(), ices_exec(), login_exec(), minivm_accmess_exec(), minivm_greet_exec(), minivm_record_exec(), old_milliwatt_exec(), park_call_exec(), park_exec_full(), pbx_builtin_background(), pickup_do(), playback_exec(), privacy_exec(), read_exec(), readexten_exec(), record_exec(), rpt_exec(), sayunixtime_exec(), send_waveform_to_channel(), setup_privacy_args(), skel_exec(), sla_station_exec(), speech_background(), testclient_exec(), testserver_exec(), transmit(), vm_exec(), vm_execmain(), waitfor_exec(), and zapateller_exec().

01886 {
01887    return __ast_answer(chan, 0, 1);
01888 }

int ast_autoservice_start ( struct ast_channel * chan )

Automatically service a channel for us...

Return values:

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

Definition at line 191 of file autoservice.c.

References as_cond, ast_calloc, ast_channel_lock, ast_channel_unlock, ast_cond_signal(), AST_FLAG_END_DTMF_ONLY, AST_LIST_EMPTY, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_pthread_create_background, AST_PTHREADT_NULL, ast_set_flag, ast_test_flag, asthread, autoservice_run(), asent::chan, free, LOG_WARNING, asent::orig_end_dtmf_flag, and asent::use_count.

Referenced by _macro_exec(), acf_curl_exec(), acf_odbc_read(), acf_odbc_write(), ast_dtmf_stream(), ast_get_enum(), ast_get_srv(), ast_get_txt(), bridge_playfile(), builtin_atxfer(), builtin_automixmonitor(), builtin_blindtransfer(), conf_play(), dial_exec_full(), feature_exec_app(), function_realtime_read(), function_realtime_readdestroy(), function_realtime_store(), function_realtime_write(), lock_read(), lua_autoservice_start(), lua_get_variable_value(), lua_pbx_exec(), lua_set_variable(), lua_set_variable_value(), osplookup_exec(), pbx_find_extension(), play_message_in_bridged_call(), shell_helper(), sla_station_exec(), smdi_msg_retrieve_read(), system_exec_helper(), try_calling(), and trylock_read().

00192 {
00193    int res = 0;
00194    struct asent *as;
00195 
00196    AST_LIST_LOCK(&aslist);
00197    AST_LIST_TRAVERSE(&aslist, as, list) {
00198       if (as->chan == chan) {
00199          as->use_count++;
00200          break;
00201       }
00202    }
00203    AST_LIST_UNLOCK(&aslist);
00204 
00205    if (as) {
00206       /* Entry exists, autoservice is already handling this channel */
00207       return 0;
00208    }
00209 
00210    if (!(as = ast_calloc(1, sizeof(*as))))
00211       return -1;
00212    
00213    /* New entry created */
00214    as->chan = chan;
00215    as->use_count = 1;
00216 
00217    ast_channel_lock(chan);
00218    as->orig_end_dtmf_flag = ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY) ? 1 : 0;
00219    if (!as->orig_end_dtmf_flag)
00220       ast_set_flag(chan, AST_FLAG_END_DTMF_ONLY);
00221    ast_channel_unlock(chan);
00222 
00223    AST_LIST_LOCK(&aslist);
00224 
00225    if (AST_LIST_EMPTY(&aslist) && asthread != AST_PTHREADT_NULL) {
00226       ast_cond_signal(&as_cond);
00227    }
00228 
00229    AST_LIST_INSERT_HEAD(&aslist, as, list);
00230 
00231    if (asthread == AST_PTHREADT_NULL) { /* need start the thread */
00232       if (ast_pthread_create_background(&asthread, NULL, autoservice_run, NULL)) {
00233          ast_log(LOG_WARNING, "Unable to create autoservice thread :(\n");
00234          /* There will only be a single member in the list at this point,
00235             the one we just added. */
00236          AST_LIST_REMOVE(&aslist, as, list);
00237          free(as);
00238          asthread = AST_PTHREADT_NULL;
00239          res = -1;
00240       } else {
00241          pthread_kill(asthread, SIGURG);
00242       }
00243    }
00244 
00245    AST_LIST_UNLOCK(&aslist);
00246 
00247    return res;
00248 }

int ast_autoservice_stop ( struct ast_channel * chan )

Stop servicing a channel for us...

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

Return values:

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

Definition at line 250 of file autoservice.c.

References ast_channel::_softhangup, as_chan_list_state, ast_channel_lock, ast_channel_unlock, ast_clear_flag, AST_FLAG_END_DTMF_ONLY, ast_frfree, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_REMOVE_HEAD, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, AST_PTHREADT_NULL, ast_queue_frame_head(), asthread, asent::chan, f, free, asent::orig_end_dtmf_flag, and asent::use_count.

Referenced by _macro_exec(), acf_curl_exec(), acf_odbc_read(), acf_odbc_write(), array(), ast_dtmf_stream(), ast_get_enum(), ast_get_srv(), ast_get_txt(), ast_hangup(), bridge_playfile(), builtin_atxfer(), builtin_automixmonitor(), conf_play(), dial_exec_full(), feature_exec_app(), finishup(), function_realtime_read(), function_realtime_readdestroy(), function_realtime_store(), function_realtime_write(), lock_read(), lua_autoservice_stop(), lua_get_variable_value(), lua_pbx_exec(), lua_set_variable(), lua_set_variable_value(), osplookup_exec(), pbx_find_extension(), play_message_in_bridged_call(), shell_helper(), sla_station_exec(), smdi_msg_retrieve_read(), system_exec_helper(), try_calling(), and trylock_read().

00251 {
00252    int res = -1;
00253    struct asent *as, *removed = NULL;
00254    struct ast_frame *f;
00255    int chan_list_state;
00256 
00257    AST_LIST_LOCK(&aslist);
00258 
00259    /* Save the autoservice channel list state.  We _must_ verify that the channel
00260     * list has been rebuilt before we return.  Because, after we return, the channel
00261     * could get destroyed and we don't want our poor autoservice thread to step on
00262     * it after its gone! */
00263    chan_list_state = as_chan_list_state;
00264 
00265    /* Find the entry, but do not free it because it still can be in the
00266       autoservice thread array */
00267    AST_LIST_TRAVERSE_SAFE_BEGIN(&aslist, as, list) {  
00268       if (as->chan == chan) {
00269          as->use_count--;
00270          if (as->use_count < 1) {
00271             AST_LIST_REMOVE_CURRENT(list);
00272             removed = as;
00273          }
00274          break;
00275       }
00276    }
00277    AST_LIST_TRAVERSE_SAFE_END;
00278 
00279    if (removed && asthread != AST_PTHREADT_NULL) {
00280       pthread_kill(asthread, SIGURG);
00281    }
00282 
00283    AST_LIST_UNLOCK(&aslist);
00284 
00285    if (!removed) {
00286       return 0;
00287    }
00288 
00289    /* Wait while autoservice thread rebuilds its list. */
00290    while (chan_list_state == as_chan_list_state) {
00291       usleep(1000);
00292    }
00293 
00294    /* Now autoservice thread should have no references to our entry
00295       and we can safely destroy it */
00296 
00297    if (!chan->_softhangup) {
00298       res = 0;
00299    }
00300 
00301    if (!as->orig_end_dtmf_flag) {
00302       ast_clear_flag(chan, AST_FLAG_END_DTMF_ONLY);
00303    }
00304 
00305    ast_channel_lock(chan);
00306    while ((f = AST_LIST_REMOVE_HEAD(&as->deferred_frames, frame_list))) {
00307       ast_queue_frame_head(chan, f);
00308       ast_frfree(f);
00309    }
00310    ast_channel_unlock(chan);
00311 
00312    free(as);
00313 
00314    return res;
00315 }

void ast_begin_shutdown ( int hangup )

Initiate system shutdown.

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

Definition at line 483 of file channel.c.

References AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_softhangup(), AST_SOFTHANGUP_SHUTDOWN, and channels.

Referenced by quit_handler().

00484 {
00485    struct ast_channel *c;
00486    shutting_down = 1;
00487    if (hangup) {
00488       AST_RWLIST_RDLOCK(&channels);
00489       AST_RWLIST_TRAVERSE(&channels, c, chan_list) {
00490          ast_softhangup(c, AST_SOFTHANGUP_SHUTDOWN);
00491       }
00492       AST_RWLIST_UNLOCK(&channels);
00493    }
00494 }

int ast_best_codec ( int fmts )

Pick the best audio codec.

Pick the best codec

Okay, ulaw is used by all telephony equipment, so start with it

Unless of course, you're a silly European, so then prefer ALAW

G.722 is better then all below, but not as common as the above... so give ulaw and alaw priority

Okay, well, signed linear is easy to translate into other stuff

G.726 is standard ADPCM, in RFC3551 packing order

G.726 is standard ADPCM, in AAL2 packing order

ADPCM has great sound quality and is still pretty easy to translate

Okay, we're down to vocoders now, so pick GSM because it's small and easier to translate and sounds pretty good

iLBC is not too bad

Speex is free, but computationally more expensive than GSM

Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough to use it

G.729a is faster than 723 and slightly less expensive

Down to G.723.1 which is proprietary but at least designed for voice

Definition at line 711 of file channel.c.

References ARRAY_LEN, AST_FORMAT_ADPCM, AST_FORMAT_ALAW, AST_FORMAT_AUDIO_MASK, AST_FORMAT_G722, AST_FORMAT_G723_1, AST_FORMAT_G726, AST_FORMAT_G726_AAL2, AST_FORMAT_G729A, AST_FORMAT_GSM, AST_FORMAT_ILBC, AST_FORMAT_LPC10, AST_FORMAT_SLINEAR, AST_FORMAT_SLINEAR16, AST_FORMAT_SPEEX, AST_FORMAT_ULAW, ast_log(), LOG_WARNING, and prefs.

Referenced by __oh323_new(), agent_call(), ast_codec_choose(), ast_iax2_new(), ast_speech_new(), builtin_atxfer(), echo_exec(), findmeexec(), gtalk_new(), handle_open_receive_channel_ack_message(), iax2_request(), jingle_new(), local_new(), login_exec(), mgcp_new(), sip_new(), skinny_new(), skinny_set_rtp_peer(), socket_process(), start_rtp(), transmit_connect(), and unistim_new().

00712 {
00713    /* This just our opinion, expressed in code.  We are asked to choose
00714       the best codec to use, given no information */
00715    int x;
00716    static const int prefs[] =
00717    {
00718       /*! Okay, ulaw is used by all telephony equipment, so start with it */
00719       AST_FORMAT_ULAW,
00720       /*! Unless of course, you're a silly European, so then prefer ALAW */
00721       AST_FORMAT_ALAW,
00722       /*! G.722 is better then all below, but not as common as the above... so give ulaw and alaw priority */
00723       AST_FORMAT_G722,
00724       /*! Okay, well, signed linear is easy to translate into other stuff */
00725       AST_FORMAT_SLINEAR16,
00726       AST_FORMAT_SLINEAR,
00727       /*! G.726 is standard ADPCM, in RFC3551 packing order */
00728       AST_FORMAT_G726,
00729       /*! G.726 is standard ADPCM, in AAL2 packing order */
00730       AST_FORMAT_G726_AAL2,
00731       /*! ADPCM has great sound quality and is still pretty easy to translate */
00732       AST_FORMAT_ADPCM,
00733       /*! Okay, we're down to vocoders now, so pick GSM because it's small and easier to
00734           translate and sounds pretty good */
00735       AST_FORMAT_GSM,
00736       /*! iLBC is not too bad */
00737       AST_FORMAT_ILBC,
00738       /*! Speex is free, but computationally more expensive than GSM */
00739       AST_FORMAT_SPEEX,
00740       /*! Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough
00741           to use it */
00742       AST_FORMAT_LPC10,
00743       /*! G.729a is faster than 723 and slightly less expensive */
00744       AST_FORMAT_G729A,
00745       /*! Down to G.723.1 which is proprietary but at least designed for voice */
00746       AST_FORMAT_G723_1,
00747    };
00748 
00749    /* Strip out video */
00750    fmts &= AST_FORMAT_AUDIO_MASK;
00751    
00752    /* Find the first preferred codec in the format given */
00753    for (x = 0; x < ARRAY_LEN(prefs); x++) {
00754       if (fmts & prefs[x])
00755          return prefs[x];
00756    }
00757 
00758    ast_log(LOG_WARNING, "Don't know any of 0x%x formats\n", fmts);
00759 
00760    return 0;
00761 }

struct ast_channel* ast_bridged_channel ( struct ast_channel * chan ) [read]

Find bridged channel.

Parameters:

chan

Current channel

Definition at line 4610 of file channel.c.

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

Referenced by __dahdi_exception(), action_agents(), action_coreshowchannels(), agents_show(), agents_show_online(), ast_bridge_call(), ast_channel_masquerade(), ast_park_call_full(), ast_rtp_set_vars(), attempt_transfer(), cb_events(), channel_spy(), check_bridge(), common_exec(), console_transfer(), create_jb(), dahdi_handle_event(), dahdi_hangup(), export_aoc_vars(), get_refer_info(), handle_chanlist(), handle_hd_hf(), handle_invite_replaces(), handle_request(), handle_request_bye(), handle_request_info(), handle_request_refer(), handle_showchan(), handle_soft_key_event_message(), handle_stimulus_message(), key_call(), key_dial_page(), local_attended_transfer(), mgcp_hangup(), mgcp_ss(), misdn_attempt_transfer(), mixmonitor_thread(), schedule_delivery(), sip_hangup(), sip_read(), sip_set_rtp_peer(), skinny_transfer(), socket_process(), ss_thread(), start_spying(), startmon(), TransferCallStep1(), and unistim_hangup().

04611 {
04612    struct ast_channel *bridged;
04613    bridged = chan->_bridge;
04614    if (bridged && bridged->tech->bridged_channel)
04615       bridged = bridged->tech->bridged_channel(chan, bridged);
04616    return bridged;
04617 }

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

Make a call.

Parameters:

	chan	which channel to make the call on
	addr	destination of the call
	timeout	time to wait on for connect Place a call, take no longer than timeout ms.

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

Definition at line 3921 of file channel.c.

References AST_CDR_FLAG_DIALED, ast_channel_lock, ast_channel_unlock, ast_check_hangup(), AST_FLAG_OUTGOING, AST_FLAG_ZOMBIE, ast_set_flag, ast_test_flag, ast_channel_tech::call, ast_channel::cdr, and ast_channel::tech.

Referenced by __ast_request_and_dial(), agent_call(), ast_call_forward(), ast_feature_request_and_dial(), attempt_reconnect(), begin_dial_channel(), connect_link(), dial_exec_full(), do_forward(), do_idle_thread(), findmeexec(), ring_entry(), rpt(), rpt_exec(), and wait_for_answer().

03922 {
03923    /* Place an outgoing call, but don't wait any longer than timeout ms before returning.
03924       If the remote end does not answer within the timeout, then do NOT hang up, but
03925       return anyway.  */
03926    int res = -1;
03927    /* Stop if we're a zombie or need a soft hangup */
03928    ast_channel_lock(chan);
03929    if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
03930       if (chan->cdr)
03931          ast_set_flag(chan->cdr, AST_CDR_FLAG_DIALED);
03932       if (chan->tech->call)
03933          res = chan->tech->call(chan, addr, timeout);
03934       ast_set_flag(chan, AST_FLAG_OUTGOING);
03935    }
03936    ast_channel_unlock(chan);
03937    return res;
03938 }

struct ast_channel* ast_call_forward	(	struct ast_channel *	caller,
		struct ast_channel *	orig,
		int *	timeout,
		int	format,
		struct outgoing_helper *	oh,
		int *	outstate
	)			`[read]`

Forwards a call to a new channel specified by the original channel's call_forward str. If possible, the new forwarded channel is created and returned while the original one is terminated.

Parameters:

	caller	in channel that requested orig
	orig	channel being replaced by the call forward channel
	timeout	maximum amount of time to wait for setup of new forward channel
	format	requested channel format
	oh	outgoing helper used with original channel
	outstate	reason why unsuccessful (if uncuccessful)

Returns:: Returns the forwarded call's ast_channel on success or NULL on failure

Definition at line 3662 of file channel.c.

References outgoing_helper::account, accountcode, ast_call(), AST_CDR_FLAG_ORIGINATED, ast_cdr_setaccount(), ast_channel_datastore_inherit(), ast_channel_inherit_variables(), ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_copy_flags, ast_copy_string(), ast_hangup(), ast_log(), ast_request(), ast_set_callerid(), ast_set_variables(), ast_string_field_set, ast_strlen_zero(), ast_channel::cdr, CHANNEL_DEADLOCK_AVOIDANCE, ast_channel::cid, ast_callerid::cid_name, outgoing_helper::cid_name, ast_callerid::cid_num, outgoing_helper::cid_num, ast_channel::context, handle_cause(), LOG_NOTICE, outgoing_helper::parent_channel, pbx_builtin_getvar_helper(), S_OR, type, and outgoing_helper::vars.

Referenced by __ast_request_and_dial(), and ast_feature_request_and_dial().

03663 {
03664    char tmpchan[256];
03665    struct ast_channel *new = NULL;
03666    char *data, *type;
03667    int cause = 0;
03668 
03669    /* gather data and request the new forward channel */
03670    ast_copy_string(tmpchan, orig->call_forward, sizeof(tmpchan));
03671    if ((data = strchr(tmpchan, '/'))) {
03672       *data++ = '\0';
03673       type = tmpchan;
03674    } else {
03675       const char *forward_context;
03676       ast_channel_lock(orig);
03677       forward_context = pbx_builtin_getvar_helper(orig, "FORWARD_CONTEXT");
03678       snprintf(tmpchan, sizeof(tmpchan), "%s@%s", orig->call_forward, S_OR(forward_context, orig->context));
03679       ast_channel_unlock(orig);
03680       data = tmpchan;
03681       type = "Local";
03682    }
03683    if (!(new = ast_request(type, format, data, &cause))) {
03684       ast_log(LOG_NOTICE, "Unable to create channel for call forward to '%s/%s' (cause = %d)\n", type, data, cause);
03685       handle_cause(cause, outstate);
03686       ast_hangup(orig);
03687       return NULL;
03688    }
03689 
03690    /* Copy/inherit important information into new channel */
03691    if (oh) {
03692       if (oh->vars) {
03693          ast_set_variables(new, oh->vars);
03694       }
03695       if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name)) {
03696          ast_set_callerid(new, oh->cid_num, oh->cid_name, oh->cid_num);
03697       }
03698       if (oh->parent_channel) {
03699          ast_channel_inherit_variables(oh->parent_channel, new);
03700          ast_channel_datastore_inherit(oh->parent_channel, new);
03701       }
03702       if (oh->account) {
03703          ast_cdr_setaccount(new, oh->account);
03704       }
03705    } else if (caller) { /* no outgoing helper so use caller if avaliable */
03706       ast_channel_inherit_variables(caller, new);
03707       ast_channel_datastore_inherit(caller, new);
03708    }
03709 
03710    ast_channel_lock(orig);
03711    while (ast_channel_trylock(new)) {
03712       CHANNEL_DEADLOCK_AVOIDANCE(orig);
03713    }
03714    ast_copy_flags(new->cdr, orig->cdr, AST_CDR_FLAG_ORIGINATED);
03715    ast_string_field_set(new, accountcode, orig->accountcode);
03716    if (!ast_strlen_zero(orig->cid.cid_num) && !ast_strlen_zero(new->cid.cid_name)) {
03717       ast_set_callerid(new, orig->cid.cid_num, orig->cid.cid_name, orig->cid.cid_num);
03718    }
03719    ast_channel_unlock(new);
03720    ast_channel_unlock(orig);
03721 
03722    /* call new channel */
03723    if ((*timeout = ast_call(new, data, 0))) {
03724       ast_log(LOG_NOTICE, "Unable to call forward to channel %s/%s\n", type, (char *)data);
03725       ast_hangup(orig);
03726       ast_hangup(new);
03727       return NULL;
03728    }
03729    ast_hangup(orig);
03730 
03731    return new;
03732 }

void ast_cancel_shutdown ( void )

Cancel a shutdown in progress.

Cancels an existing shutdown and returns to normal operation

Definition at line 509 of file channel.c.

Referenced by handle_abort_shutdown().

00510 {
00511    shutting_down = 0;
00512 }

const char* ast_cause2str ( int state )

Gives the string form of a given hangup cause.

Gives the string form of a given cause code

Parameters:

state

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

Definition at line 629 of file channel.c.

References ARRAY_LEN, causes, and ast_cause::desc.

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

00630 {
00631    int x;
00632 
00633    for (x = 0; x < ARRAY_LEN(causes); x++) {
00634       if (causes[x].cause == cause)
00635          return causes[x].desc;
00636    }
00637 
00638    return "Unknown";
00639 }

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

Change channel name.

Note:: The channel must be locked before calling this function.

Definition at line 4173 of file channel.c.

References ast_string_field_set, EVENT_FLAG_CALL, manager_event, and name.

Referenced by update_name().

04174 {
04175    manager_event(EVENT_FLAG_CALL, "Rename", "Channel: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", chan->name, newname, chan->uniqueid);
04176    ast_string_field_set(chan, name, newname);
04177 }

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.

Bridge two channels together

Parameters:

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

Definition at line 4932 of file channel.c.

Referenced by ast_bridge_call().

04934 {
04935    struct ast_channel *who = NULL;
04936    enum ast_bridge_result res = AST_BRIDGE_COMPLETE;
04937    int nativefailed=0;
04938    int firstpass;
04939    int o0nativeformats;
04940    int o1nativeformats;
04941    long time_left_ms=0;
04942    char caller_warning = 0;
04943    char callee_warning = 0;
04944 
04945    if (c0->_bridge) {
04946       ast_log(LOG_WARNING, "%s is already in a bridge with %s\n",
04947          c0->name, c0->_bridge->name);
04948       return -1;
04949    }
04950    if (c1->_bridge) {
04951       ast_log(LOG_WARNING, "%s is already in a bridge with %s\n",
04952          c1->name, c1->_bridge->name);
04953       return -1;
04954    }
04955    
04956    /* Stop if we're a zombie or need a soft hangup */
04957    if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) ||
04958        ast_test_flag(c1, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c1))
04959       return -1;
04960 
04961    *fo = NULL;
04962    firstpass = config->firstpass;
04963    config->firstpass = 0;
04964 
04965    if (ast_tvzero(config->start_time))
04966       config->start_time = ast_tvnow();
04967    time_left_ms = config->timelimit;
04968 
04969    caller_warning = ast_test_flag(&config->features_caller, AST_FEATURE_PLAY_WARNING);
04970    callee_warning = ast_test_flag(&config->features_callee, AST_FEATURE_PLAY_WARNING);
04971 
04972    if (config->start_sound && firstpass) {
04973       if (caller_warning)
04974          bridge_playfile(c0, c1, config->start_sound, time_left_ms / 1000);
04975       if (callee_warning)
04976          bridge_playfile(c1, c0, config->start_sound, time_left_ms / 1000);
04977    }
04978 
04979    /* Keep track of bridge */
04980    c0->_bridge = c1;
04981    c1->_bridge = c0;
04982 
04983 
04984    o0nativeformats = c0->nativeformats;
04985    o1nativeformats = c1->nativeformats;
04986 
04987    if (config->feature_timer && !ast_tvzero(config->nexteventts)) {
04988       config->nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->feature_timer, 1000));
04989    } else if (config->timelimit && firstpass) {
04990       config->nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000));
04991       if (caller_warning || callee_warning)
04992          config->nexteventts = ast_tvsub(config->nexteventts, ast_samp2tv(config->play_warning, 1000));
04993    }
04994 
04995    if (!c0->tech->send_digit_begin)
04996       ast_set_flag(c1, AST_FLAG_END_DTMF_ONLY);
04997    if (!c1->tech->send_digit_begin)
04998       ast_set_flag(c0, AST_FLAG_END_DTMF_ONLY);
04999    manager_bridge_event(1, 1, c0, c1);
05000 
05001    /* Before we enter in and bridge these two together tell them both the source of audio has changed */
05002    ast_indicate(c0, AST_CONTROL_SRCUPDATE);
05003    ast_indicate(c1, AST_CONTROL_SRCUPDATE);
05004 
05005    for (/* ever */;;) {
05006       struct timeval now = { 0, };
05007       int to;
05008 
05009       to = -1;
05010 
05011       if (!ast_tvzero(config->nexteventts)) {
05012          now = ast_tvnow();
05013          to = ast_tvdiff_ms(config->nexteventts, now);
05014          if (to <= 0) {
05015             if (!config->timelimit) {
05016                res = AST_BRIDGE_COMPLETE;
05017                break;
05018             }
05019             to = 0;
05020          }
05021       }
05022 
05023       if (config->timelimit) {
05024          time_left_ms = config->timelimit - ast_tvdiff_ms(now, config->start_time);
05025          if (time_left_ms < to)
05026             to = time_left_ms;
05027 
05028          if (time_left_ms <= 0) {
05029             if (caller_warning && config->end_sound)
05030                bridge_playfile(c0, c1, config->end_sound, 0);
05031             if (callee_warning && config->end_sound)
05032                bridge_playfile(c1, c0, config->end_sound, 0);
05033             *fo = NULL;
05034             if (who)
05035                *rc = who;
05036             res = 0;
05037             break;
05038          }
05039 
05040          if (!to) {
05041             if (time_left_ms >= 5000 && config->warning_sound && config->play_warning && ast_test_flag(config, AST_FEATURE_WARNING_ACTIVE)) {
05042                int t = (time_left_ms + 500) / 1000; /* round to nearest second */
05043                if (caller_warning)
05044                   bridge_playfile(c0, c1, config->warning_sound, t);
05045                if (callee_warning)
05046                   bridge_playfile(c1, c0, config->warning_sound, t);
05047             }
05048             if (config->warning_freq && (time_left_ms > (config->warning_freq + 5000)))
05049                config->nexteventts = ast_tvadd(config->nexteventts, ast_samp2tv(config->warning_freq, 1000));
05050             else
05051                config->nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000));
05052          }
05053          ast_clear_flag(config, AST_FEATURE_WARNING_ACTIVE);
05054       }
05055 
05056       if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE) {
05057          if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
05058             c0->_softhangup = 0;
05059          if (c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
05060             c1->_softhangup = 0;
05061          c0->_bridge = c1;
05062          c1->_bridge = c0;
05063          ast_debug(1, "Unbridge signal received. Ending native bridge.\n");
05064          continue;
05065       }
05066 
05067       /* Stop if we're a zombie or need a soft hangup */
05068       if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) ||
05069           ast_test_flag(c1, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c1)) {
05070          *fo = NULL;
05071          if (who)
05072             *rc = who;
05073          res = 0;
05074          ast_debug(1, "Bridge stops because we're zombie or need a soft hangup: c0=%s, c1=%s, flags: %s,%s,%s,%s\n",
05075             c0->name, c1->name,
05076             ast_test_flag(c0, AST_FLAG_ZOMBIE) ? "Yes" : "No",
05077             ast_check_hangup(c0) ? "Yes" : "No",
05078             ast_test_flag(c1, AST_FLAG_ZOMBIE) ? "Yes" : "No",
05079             ast_check_hangup(c1) ? "Yes" : "No");
05080          break;
05081       }
05082 
05083       update_bridge_vars(c0, c1);
05084 
05085       bridge_play_sounds(c0, c1);
05086 
05087       if (c0->tech->bridge &&
05088           (c0->tech->bridge == c1->tech->bridge) &&
05089           !nativefailed && !c0->monitor && !c1->monitor &&
05090           !c0->audiohooks && !c1->audiohooks && 
05091           !c0->masq && !c0->masqr && !c1->masq && !c1->masqr) {
05092          /* Looks like they share a bridge method and nothing else is in the way */
05093          ast_set_flag(c0, AST_FLAG_NBRIDGE);
05094          ast_set_flag(c1, AST_FLAG_NBRIDGE);
05095          if ((res = c0->tech->bridge(c0, c1, config->flags, fo, rc, to)) == AST_BRIDGE_COMPLETE) {
05096             /* \todo  XXX here should check that cid_num is not NULL */
05097             manager_event(EVENT_FLAG_CALL, "Unlink",
05098                      "Channel1: %s\r\n"
05099                      "Channel2: %s\r\n"
05100                      "Uniqueid1: %s\r\n"
05101                      "Uniqueid2: %s\r\n"
05102                      "CallerID1: %s\r\n"
05103                      "CallerID2: %s\r\n",
05104                      c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
05105             ast_debug(1, "Returning from native bridge, channels: %s, %s\n", c0->name, c1->name);
05106 
05107             ast_clear_flag(c0, AST_FLAG_NBRIDGE);
05108             ast_clear_flag(c1, AST_FLAG_NBRIDGE);
05109 
05110             if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
05111                continue;
05112 
05113             c0->_bridge = NULL;
05114             c1->_bridge = NULL;
05115 
05116             return res;
05117          } else {
05118             ast_clear_flag(c0, AST_FLAG_NBRIDGE);
05119             ast_clear_flag(c1, AST_FLAG_NBRIDGE);
05120          }
05121          switch (res) {
05122          case AST_BRIDGE_RETRY:
05123             if (config->play_warning) {
05124                ast_set_flag(config, AST_FEATURE_WARNING_ACTIVE);
05125             }
05126             continue;
05127          default:
05128             ast_verb(3, "Native bridging %s and %s ended\n", c0->name, c1->name);
05129             /* fallthrough */
05130          case AST_BRIDGE_FAILED_NOWARN:
05131             nativefailed++;
05132             break;
05133          }
05134       }
05135 
05136       if (((c0->writeformat != c1->readformat) || (c0->readformat != c1->writeformat) ||
05137           (c0->nativeformats != o0nativeformats) || (c1->nativeformats != o1nativeformats)) &&
05138           !(c0->generator || c1->generator)) {
05139          if (ast_channel_make_compatible(c0, c1)) {
05140             ast_log(LOG_WARNING, "Can't make %s and %s compatible\n", c0->name, c1->name);
05141             manager_bridge_event(0, 1, c0, c1);
05142             return AST_BRIDGE_FAILED;
05143          }
05144          o0nativeformats = c0->nativeformats;
05145          o1nativeformats = c1->nativeformats;
05146       }
05147 
05148       update_bridge_vars(c0, c1);
05149 
05150       res = ast_generic_bridge(c0, c1, config, fo, rc, config->nexteventts);
05151       if (res != AST_BRIDGE_RETRY) {
05152          break;
05153       } else if (config->feature_timer) {
05154          /* feature timer expired but has not been updated, sending to ast_bridge_call to do so */
05155          break;
05156       }
05157    }
05158 
05159    ast_clear_flag(c0, AST_FLAG_END_DTMF_ONLY);
05160    ast_clear_flag(c1, AST_FLAG_END_DTMF_ONLY);
05161 
05162    /* Now that we have broken the bridge the source will change yet again */
05163    ast_indicate(c0, AST_CONTROL_SRCUPDATE);
05164    ast_indicate(c1, AST_CONTROL_SRCUPDATE);
05165 
05166    c0->_bridge = NULL;
05167    c1->_bridge = NULL;
05168 
05169    /* \todo  XXX here should check that cid_num is not NULL */
05170    manager_event(EVENT_FLAG_CALL, "Unlink",
05171             "Channel1: %s\r\n"
05172             "Channel2: %s\r\n"
05173             "Uniqueid1: %s\r\n"
05174             "Uniqueid2: %s\r\n"
05175             "CallerID1: %s\r\n"
05176             "CallerID2: %s\r\n",
05177             c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
05178    ast_debug(1, "Bridge stops bridging channels %s and %s\n", c0->name, c1->name);
05179 
05180    return res;
05181 }

int ast_channel_cmpwhentohangup	(	struct ast_channel *	chan,
		time_t	offset
	)

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

Parameters:

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

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

See also:: ast_channel_cmpwhentohangup_tv()

Version:: 1.6.1 deprecated function (only had seconds precision)

Definition at line 550 of file channel.c.

References ast_channel_cmpwhentohangup_tv().

00551 {
00552    struct timeval when = { offset, };
00553    return ast_channel_cmpwhentohangup_tv(chan, when);
00554 }

int ast_channel_cmpwhentohangup_tv	(	struct ast_channel *	chan,
		struct timeval	offset
	)

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

Parameters:

	chan	channel on which to check for hangup
	offset	offset in seconds and microseconds from current time

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

Since:: 1.6.1

Definition at line 535 of file channel.c.

References ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), and ast_channel::whentohangup.

Referenced by ast_channel_cmpwhentohangup().

00536 {
00537    struct timeval whentohangup;
00538 
00539    if (ast_tvzero(chan->whentohangup))
00540       return ast_tvzero(offset) ? 0 : -1;
00541 
00542    if (ast_tvzero(offset))
00543       return 1;
00544 
00545    whentohangup = ast_tvadd(offset, ast_tvnow());
00546 
00547    return ast_tvdiff_ms(whentohangup, chan->whentohangup);
00548 }

int ast_channel_datastore_add	(	struct ast_channel *	chan,
		struct ast_datastore *	datastore
	)

Add a datastore to a channel.

Note:: The channel should be locked before calling this function.

Return values:

	0	success
	non-zero	failure

Definition at line 1478 of file channel.c.

References AST_LIST_INSERT_HEAD.

Referenced by _macro_exec(), acf_iaxvar_write(), acf_odbc_read(), add_features_datastores(), add_to_agi(), ast_iax2_new(), audiohook_volume_get(), authenticate_reply(), dial_exec_full(), dundi_query_read(), enable_jack_hook(), enum_query_read(), get_lock(), gosub_exec(), lua_get_state(), pbx_builtin_raise_exception(), setup_chanspy_ds(), setup_inheritance_datastore(), setup_mixmonitor_ds(), setup_transfer_datastore(), shared_write(), smdi_msg_retrieve_read(), socket_process(), speech_create(), speex_write(), try_calling(), and volume_write().

01479 {
01480    int res = 0;
01481 
01482    AST_LIST_INSERT_HEAD(&chan->datastores, datastore, entry);
01483 
01484    return res;
01485 }

struct ast_datastore* attribute_malloc ast_channel_datastore_alloc	(	const struct ast_datastore_info *	info,
		const char *	uid
	)			`[read]`

Create a channel data store object.

Note:: None of the datastore API calls lock the ast_channel they are using. So, the channel should be locked before calling the functions that take a channel argument.

Deprecated:: You should use the ast_datastore_alloc() generic function instead.

Version:: 1.6.1 deprecated

Definition at line 1451 of file channel.c.

References ast_datastore_alloc.

01452 {
01453    return ast_datastore_alloc(info, uid);
01454 }

struct ast_datastore* ast_channel_datastore_find	(	struct ast_channel *	chan,
		const struct ast_datastore_info *	info,
		const char *	uid
	)			`[read]`

Find a datastore on a channel.

Note:: The channel should be locked before calling this function.; The datastore returned from this function must not be used if the reference to the channel is released.

Return values:

	pointer	to the datastore if found
	NULL	if not found

Definition at line 1492 of file channel.c.

References AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_datastore::info, and ast_datastore::uid.

Referenced by _macro_exec(), acf_exception_read(), acf_fetch(), acf_iaxvar_read(), acf_iaxvar_write(), add_agi_cmd(), add_features_datastores(), add_to_agi(), attended_transfer_occurred(), audiohook_volume_callback(), audiohook_volume_get(), builtin_atxfer(), chanspy_ds_free(), dial_exec_full(), disable_jack_hook(), dundi_result_read(), enable_jack_hook(), enum_result_read(), exec_odbcfinish(), find_speech(), func_inheritance_write(), get_agi_cmd(), get_lock(), gosub_exec(), iax2_call(), jack_hook_callback(), local_read(), local_write(), lua_get_state(), manage_parkinglot(), park_exec_full(), pbx_builtin_raise_exception(), pop_exec(), queue_transfer_fixup(), return_exec(), shared_read(), shared_write(), smdi_msg_read(), speech_background(), speech_destroy(), speex_callback(), speex_read(), speex_write(), stop_mixmonitor_exec(), try_calling(), unlock_read(), volume_callback(), and volume_write().

01493 {
01494    struct ast_datastore *datastore = NULL;
01495    
01496    if (info == NULL)
01497       return NULL;
01498 
01499    AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore, entry) {
01500       if (datastore->info != info) {
01501          continue;
01502       }
01503 
01504       if (uid == NULL) {
01505          /* matched by type only */
01506          break;
01507       }
01508 
01509       if ((datastore->uid != NULL) && !strcasecmp(uid, datastore->uid)) {
01510          /* Matched by type AND uid */
01511          break;
01512       }
01513    }
01514    AST_LIST_TRAVERSE_SAFE_END;
01515 
01516    return datastore;
01517 }

int ast_channel_datastore_free ( struct ast_datastore * datastore )

Free a channel data store object.

Deprecated:: You should use the ast_datastore_free() generic function instead.

Version:: 1.6.1 deprecated

Definition at line 1456 of file channel.c.

References ast_datastore_free().

01457 {
01458    return ast_datastore_free(datastore);
01459 }

int ast_channel_datastore_inherit	(	struct ast_channel *	from,
		struct ast_channel *	to
	)

Inherit datastores from a parent to a child.

Definition at line 1461 of file channel.c.

References ast_datastore_alloc, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_datastore::data, DATASTORE_INHERIT_FOREVER, ast_datastore_info::duplicate, ast_datastore::info, ast_datastore::inheritance, and ast_datastore::uid.

Referenced by __ast_request_and_dial(), ast_call_forward(), dial_exec_full(), do_forward(), local_call(), and wait_for_answer().

01462 {
01463    struct ast_datastore *datastore = NULL, *datastore2;
01464 
01465    AST_LIST_TRAVERSE(&from->datastores, datastore, entry) {
01466       if (datastore->inheritance > 0) {
01467          datastore2 = ast_datastore_alloc(datastore->info, datastore->uid);
01468          if (datastore2) {
01469             datastore2->data = datastore->info->duplicate ? datastore->info->duplicate(datastore->data) : NULL;
01470             datastore2->inheritance = datastore->inheritance == DATASTORE_INHERIT_FOREVER ? DATASTORE_INHERIT_FOREVER : datastore->inheritance - 1;
01471             AST_LIST_INSERT_TAIL(&to->datastores, datastore2, entry);
01472          }
01473       }
01474    }
01475    return 0;
01476 }

int ast_channel_datastore_remove	(	struct ast_channel *	chan,
		struct ast_datastore *	datastore
	)

Remove a datastore from a channel.

Note:: The channel should be locked before calling this function.

Return values:

	0	success
	non-zero	failure

Definition at line 1487 of file channel.c.

References AST_LIST_REMOVE.

Referenced by acf_fetch(), chanspy_ds_free(), dial_exec_full(), disable_jack_hook(), exec_odbcfinish(), lua_get_state(), queue_transfer_fixup(), speech_background(), speech_destroy(), speex_write(), and try_calling().

01488 {
01489    return AST_LIST_REMOVE(&chan->datastores, datastore, entry) ? 0 : -1;
01490 }

int ast_channel_defer_dtmf ( struct ast_channel * chan )

Set defer DTMF flag on channel.

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

References AST_FLAG_DEFER_DTMF, ast_set_flag, and ast_test_flag.

Referenced by __adsi_transmit_messages(), and find_cache().

01138 {
01139    int pre = 0;
01140 
01141    if (chan) {
01142       pre = ast_test_flag(chan, AST_FLAG_DEFER_DTMF);
01143       ast_set_flag(chan, AST_FLAG_DEFER_DTMF);
01144    }
01145    return pre;
01146 }

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

Bridge two channels together (early).

Bridge two channels together (early)

Parameters:

	c0	first channel to bridge
	c1	second channel to bridge Bridge two channels (c0 and c1) together early. This implies either side may not be answered yet.

Returns:: Returns 0 on success and -1 if it could not be done

Definition at line 4834 of file channel.c.

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

Referenced by dial_exec_full(), and wait_for_answer().

04835 {
04836    /* Make sure we can early bridge, if not error out */
04837    if (!c0->tech->early_bridge || (c1 && (!c1->tech->early_bridge || c0->tech->early_bridge != c1->tech->early_bridge)))
04838       return -1;
04839 
04840    return c0->tech->early_bridge(c0, c1);
04841 }

void ast_channel_free ( struct ast_channel * )

Free a channel structure.

Definition at line 1343 of file channel.c.

References ast_channel::alertpipe, ast_app_group_discard(), ast_cdr_discard(), ast_channel_lock, AST_CHANNEL_NAME, ast_channel_unlock, ast_copy_string(), ast_datastore_free(), AST_DEVICE_UNKNOWN, ast_devstate_changed_literal(), ast_free, ast_frfree, ast_jb_destroy(), AST_LIST_REMOVE_HEAD, ast_log(), AST_MAX_FDS, ast_moh_cleanup(), ast_mutex_destroy(), AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_string_field_free_memory, ast_timer_close(), ast_translator_free_path(), ast_var_delete(), ast_channel::cdr, channels, ast_channel::cid, f, free, free_cid(), ast_channel::lock_dont_use, LOG_ERROR, LOG_WARNING, ast_channel::monitor, ast_channel::music_state, name, ast_channel::pbx, ast_channel::readtrans, ast_channel::sched, sched_context_destroy(), ast_channel_monitor::stop, ast_channel::tech_pvt, ast_channel::timer, ast_channel::varshead, and ast_channel::writetrans.

Referenced by acf_odbc_read(), acf_odbc_write(), action_getvar(), agent_cleanup(), agent_new(), ast_do_masquerade(), ast_hangup(), ast_iax2_new(), ast_pbx_outgoing_cdr_failed(), gtalk_newcall(), local_new(), make_email_file(), pbx_substitute_variables_helper_full(), rotate_file(), sendmail(), and sendpage().

01344 {
01345    int fd;
01346 #ifdef HAVE_EPOLL
01347    int i;
01348 #endif
01349    struct ast_var_t *vardata;
01350    struct ast_frame *f;
01351    struct varshead *headp;
01352    struct ast_datastore *datastore = NULL;
01353    char name[AST_CHANNEL_NAME], *dashptr;
01354    
01355    headp=&chan->varshead;
01356    
01357    AST_RWLIST_WRLOCK(&channels);
01358    if (!AST_RWLIST_REMOVE(&channels, chan, chan_list)) {
01359       ast_log(LOG_ERROR, "Unable to find channel in list to free. Assuming it has already been done.\n");
01360    }
01361    /* Lock and unlock the channel just to be sure nobody has it locked still
01362       due to a reference retrieved from the channel list. */
01363    ast_channel_lock(chan);
01364    ast_channel_unlock(chan);
01365 
01366    /* Get rid of each of the data stores on the channel */
01367    while ((datastore = AST_LIST_REMOVE_HEAD(&chan->datastores, entry)))
01368       /* Free the data store */
01369       ast_datastore_free(datastore);
01370 
01371    /* Lock and unlock the channel just to be sure nobody has it locked still
01372       due to a reference that was stored in a datastore. (i.e. app_chanspy) */
01373    ast_channel_lock(chan);
01374    ast_channel_unlock(chan);
01375 
01376    if (chan->tech_pvt) {
01377       ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name);
01378       ast_free(chan->tech_pvt);
01379    }
01380 
01381    if (chan->sched)
01382       sched_context_destroy(chan->sched);
01383 
01384    ast_copy_string(name, chan->name, sizeof(name));
01385    if ((dashptr = strrchr(name, '-'))) {
01386       *dashptr = '\0';
01387    }
01388 
01389    /* Stop monitoring */
01390    if (chan->monitor)
01391       chan->monitor->stop( chan, 0 );
01392 
01393    /* If there is native format music-on-hold state, free it */
01394    if (chan->music_state)
01395       ast_moh_cleanup(chan);
01396 
01397    /* Free translators */
01398    if (chan->readtrans)
01399       ast_translator_free_path(chan->readtrans);
01400    if (chan->writetrans)
01401       ast_translator_free_path(chan->writetrans);
01402    if (chan->pbx)
01403       ast_log(LOG_WARNING, "PBX may not have been terminated properly on '%s'\n", chan->name);
01404    free_cid(&chan->cid);
01405    /* Close pipes if appropriate */
01406    if ((fd = chan->alertpipe[0]) > -1)
01407       close(fd);
01408    if ((fd = chan->alertpipe[1]) > -1)
01409       close(fd);
01410    if (chan->timer) {
01411       ast_timer_close(chan->timer);
01412    }
01413 #ifdef HAVE_EPOLL
01414    for (i = 0; i < AST_MAX_FDS; i++) {
01415       if (chan->epfd_data[i])
01416          free(chan->epfd_data[i]);
01417    }
01418    close(chan->epfd);
01419 #endif
01420    while ((f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list)))
01421       ast_frfree(f);
01422    
01423    /* loop over the variables list, freeing all data and deleting list items */
01424    /* no need to lock the list, as the channel is already locked */
01425    
01426    while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
01427       ast_var_delete(vardata);
01428 
01429    ast_app_group_discard(chan);
01430 
01431    /* Destroy the jitterbuffer */
01432    ast_jb_destroy(chan);
01433 
01434    if (chan->cdr) {
01435       ast_cdr_discard(chan->cdr);
01436       chan->cdr = NULL;
01437    }
01438    
01439    ast_mutex_destroy(&chan->lock_dont_use);
01440 
01441    ast_string_field_free_memory(chan);
01442    ast_free(chan);
01443    AST_RWLIST_UNLOCK(&channels);
01444 
01445    /* Queue an unknown state, because, while we know that this particular
01446     * instance is dead, we don't know the state of all other possible
01447     * instances. */
01448    ast_devstate_changed_literal(AST_DEVICE_UNKNOWN, name);
01449 }

static enum ast_t38_state ast_channel_get_t38_state ( struct ast_channel * chan ) [inline, static]

Retrieves the current T38 state of a channel.

Definition at line 1733 of file channel.h.

References ast_channel_queryoption(), AST_OPTION_T38_STATE, and T38_STATE_UNAVAILABLE.

Referenced by transmit(), and transmit_audio().

01734 {
01735    enum ast_t38_state state = T38_STATE_UNAVAILABLE;
01736    int datalen = sizeof(state);
01737 
01738    ast_channel_queryoption(chan, AST_OPTION_T38_STATE, &state, &datalen, 0);
01739 
01740    return state;
01741 }

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

Inherits channel variable from parent to child channel.

Parameters:

	parent	Parent channel
	child	Child channel

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

Definition at line 4179 of file channel.c.

References ast_debug, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_var_assign(), ast_var_full_name(), ast_var_name(), ast_var_value(), and ast_channel::varshead.

Referenced by __ast_request_and_dial(), agent_call(), ast_call_forward(), ast_feature_request_and_dial(), begin_dial_channel(), dial_exec_full(), do_forward(), findmeexec(), ring_entry(), and wait_for_answer().

04180 {
04181    struct ast_var_t *current, *newvar;
04182    const char *varname;
04183 
04184    AST_LIST_TRAVERSE(&parent->varshead, current, entries) {
04185       int vartype = 0;
04186 
04187       varname = ast_var_full_name(current);
04188       if (!varname)
04189          continue;
04190 
04191       if (varname[0] == '_') {
04192          vartype = 1;
04193          if (varname[1] == '_')
04194             vartype = 2;
04195       }
04196 
04197       switch (vartype) {
04198       case 1:
04199          newvar = ast_var_assign(&varname[1], ast_var_value(current));
04200          if (newvar) {
04201             AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
04202             ast_debug(1, "Copying soft-transferable variable %s.\n", ast_var_name(newvar));
04203          }
04204          break;
04205       case 2:
04206          newvar = ast_var_assign(varname, ast_var_value(current));
04207          if (newvar) {
04208             AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
04209             ast_debug(1, "Copying hard-transferable variable %s.\n", ast_var_name(newvar));
04210          }
04211          break;
04212       default:
04213          ast_debug(1, "Not copying variable %s.\n", ast_var_name(current));
04214          break;
04215       }
04216    }
04217 }

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:: Returns 0 on success and -1 if it could not be done

Definition at line 4077 of file channel.c.

References ast_channel_make_compatible_helper().

Referenced by action_bridge(), app_exec(), ast_channel_bridge(), bridge_exec(), check_compat(), dial_exec_full(), do_forward(), park_exec_full(), try_calling(), and wait_for_answer().

04078 {
04079    /* Some callers do not check return code, and we must try to set all call legs correctly */
04080    int rc = 0;
04081 
04082    /* Set up translation from the chan to the peer */
04083    rc = ast_channel_make_compatible_helper(chan, peer);
04084 
04085    if (rc < 0)
04086       return rc;
04087 
04088    /* Set up translation from the peer to the chan */
04089    rc = ast_channel_make_compatible_helper(peer, chan);
04090 
04091    return rc;
04092 }

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.

Note:: Neither channel passed here needs to be locked before calling this function.

Definition at line 4094 of file channel.c.

References ast_channel::_bridge, ast_bridged_channel(), ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_debug, ast_log(), ast_null_frame, ast_queue_frame(), ast_channel_tech::get_base_channel, LOG_WARNING, ast_channel::masq, ast_channel::masqr, and ast_channel::tech.

Referenced by ast_async_goto(), ast_pickup_call(), attempt_transfer(), builtin_atxfer(), check_availability(), check_bridge(), check_goto_on_transfer(), do_bridge_masquerade(), handle_invite_replaces(), iax_park(), masq_park_call(), misdn_attempt_transfer(), pickup_do(), sip_park(), and skinny_transfer().

04095 {
04096    int res = -1;
04097    struct ast_channel *final_orig, *final_clone, *base;
04098 
04099 retrymasq:
04100    final_orig = original;
04101    final_clone = clonechan;
04102 
04103    ast_channel_lock(original);
04104    while (ast_channel_trylock(clonechan)) {
04105       ast_channel_unlock(original);
04106       usleep(1);
04107       ast_channel_lock(original);
04108    }
04109 
04110    /* each of these channels may be sitting behind a channel proxy (i.e. chan_agent)
04111       and if so, we don't really want to masquerade it, but its proxy */
04112    if (original->_bridge && (original->_bridge != ast_bridged_channel(original)) && (original->_bridge->_bridge != original))
04113       final_orig = original->_bridge;
04114 
04115    if (clonechan->_bridge && (clonechan->_bridge != ast_bridged_channel(clonechan)) && (clonechan->_bridge->_bridge != clonechan))
04116       final_clone = clonechan->_bridge;
04117    
04118    if (final_clone->tech->get_base_channel && (base = final_clone->tech->get_base_channel(final_clone))) {
04119       final_clone = base;
04120    }
04121 
04122    if ((final_orig != original) || (final_clone != clonechan)) {
04123       /* Lots and lots of deadlock avoidance.  The main one we're competing with
04124        * is ast_write(), which locks channels recursively, when working with a
04125        * proxy channel. */
04126       if (ast_channel_trylock(final_orig)) {
04127          ast_channel_unlock(clonechan);
04128          ast_channel_unlock(original);
04129          goto retrymasq;
04130       }
04131       if (ast_channel_trylock(final_clone)) {
04132          ast_channel_unlock(final_orig);
04133          ast_channel_unlock(clonechan);
04134          ast_channel_unlock(original);
04135          goto retrymasq;
04136       }
04137       ast_channel_unlock(clonechan);
04138       ast_channel_unlock(original);
04139       original = final_orig;
04140       clonechan = final_clone;
04141    }
04142 
04143    if (original == clonechan) {
04144       ast_log(LOG_WARNING, "Can't masquerade channel '%s' into itself!\n", original->name);
04145       ast_channel_unlock(clonechan);
04146       ast_channel_unlock(original);
04147       return -1;
04148    }
04149 
04150    ast_debug(1, "Planning to masquerade channel %s into the structure of %s\n",
04151       clonechan->name, original->name);
04152    if (original->masq) {
04153       ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n",
04154          original->masq->name, original->name);
04155    } else if (clonechan->masqr) {
04156       ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n",
04157          clonechan->name, clonechan->masqr->name);
04158    } else {
04159       original->masq = clonechan;
04160       clonechan->masqr = original;
04161       ast_queue_frame(original, &ast_null_frame);
04162       ast_queue_frame(clonechan, &ast_null_frame);
04163       ast_debug(1, "Done planning to masquerade channel %s into the structure of %s\n", clonechan->name, original->name);
04164       res = 0;
04165    }
04166 
04167    ast_channel_unlock(clonechan);
04168    ast_channel_unlock(original);
04169 
04170    return res;
04171 }

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

Checks the value of an option

Query the value of an option Works similarly to setoption except only reads the options.

Definition at line 5197 of file channel.c.

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

Referenced by ast_channel_get_t38_state().

05198 {
05199    if (!chan->tech->queryoption) {
05200       errno = ENOSYS;
05201       return -1;
05202    }
05203 
05204    if (block)
05205       ast_log(LOG_ERROR, "XXX Blocking not implemented yet XXX\n");
05206 
05207    return chan->tech->queryoption(chan, option, data, datalen);
05208 }

const char* ast_channel_reason2str ( int reason )

return an english explanation of the code returned thru __ast_request_and_dial's 'outstate' argument

Parameters:

reason

The integer argument, usually taken from AST_CONTROL_ macros

Returns:: char pointer explaining the code

Definition at line 3626 of file channel.c.

References AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_HANGUP, AST_CONTROL_RING, and AST_CONTROL_RINGING.

Referenced by attempt_thread().

03627 {
03628    switch (reason) /* the following appear to be the only ones actually returned by request_and_dial */
03629    {
03630    case 0:
03631       return "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)";
03632    case AST_CONTROL_HANGUP:
03633       return "Hangup";
03634    case AST_CONTROL_RING:
03635       return "Local Ring";
03636    case AST_CONTROL_RINGING:
03637       return "Remote end Ringing";
03638    case AST_CONTROL_ANSWER:
03639       return "Remote end has Answered";
03640    case AST_CONTROL_BUSY:
03641       return "Remote end is Busy";
03642    case AST_CONTROL_CONGESTION:
03643       return "Congestion (circuits busy)";
03644    default:
03645       return "Unknown Reason!!";
03646    }
03647 }

int ast_channel_register ( const struct ast_channel_tech * tech )

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

Parameters:

tech

Structure defining channel technology or "type"

Returns:: Returns 0 on success, -1 on failure.

Definition at line 557 of file channel.c.

References ast_calloc, ast_debug, AST_LIST_INSERT_HEAD, AST_LIST_TRAVERSE, ast_log(), AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, channels, ast_channel_tech::description, LOG_WARNING, chanlist::tech, and ast_channel_tech::type.

Referenced by load_module(), and unload_module().

00558 {
00559    struct chanlist *chan;
00560 
00561    AST_RWLIST_WRLOCK(&channels);
00562 
00563    AST_LIST_TRAVERSE(&backends, chan, list) {
00564       if (!strcasecmp(tech->type, chan->tech->type)) {
00565          ast_log(LOG_WARNING, "Already have a handler for type '%s'\n", tech->type);
00566          AST_RWLIST_UNLOCK(&channels);
00567          return -1;
00568       }
00569    }
00570    
00571    if (!(chan = ast_calloc(1, sizeof(*chan)))) {
00572       AST_RWLIST_UNLOCK(&channels);
00573       return -1;
00574    }
00575    chan->tech = tech;
00576    AST_LIST_INSERT_HEAD(&backends, chan, list);
00577 
00578    ast_debug(1, "Registered handler for '%s' (%s)\n", chan->tech->type, chan->tech->description);
00579 
00580    ast_verb(2, "Registered channel type '%s' (%s)\n", chan->tech->type, chan->tech->description);
00581 
00582    AST_RWLIST_UNLOCK(&channels);
00583    return 0;
00584 }

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

Sends HTML on given channel

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

Definition at line 4023 of file channel.c.

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

Referenced by agent_sendhtml(), ast_channel_sendurl(), and wait_for_answer().

04024 {
04025    if (chan->tech->send_html)
04026       return chan->tech->send_html(chan, subclass, data, datalen);
04027    return -1;
04028 }

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

Sends a URL on a given link

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

Definition at line 4030 of file channel.c.

References ast_channel_sendhtml(), and AST_HTML_URL.

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

04031 {
04032    return ast_channel_sendhtml(chan, AST_HTML_URL, url, strlen(url) + 1);
04033 }

void ast_channel_set_fd	(	struct ast_channel *	chan,
		int	which,
		int	fd
	)

Set the file descriptor on the channel

Definition at line 1520 of file channel.c.

References ast_calloc, ast_epoll_data::chan, ast_channel::fds, free, and ast_epoll_data::which.

Referenced by __ast_channel_alloc_ap(), __oh323_new(), __oh323_rtp_create(), __oh323_update_info(), alsa_new(), ast_deactivate_generator(), ast_do_masquerade(), dahdi_new(), gtalk_new(), jingle_new(), mgcp_new(), misdn_new(), nbs_new(), oss_new(), phone_new(), pri_assign_bearer(), pri_fixup_principle(), setformat(), sip_new(), skinny_new(), start_rtp(), and swap_subs().

01521 {
01522 #ifdef HAVE_EPOLL
01523    struct epoll_event ev;
01524    struct ast_epoll_data *aed = NULL;
01525 
01526    if (chan->fds[which] > -1) {
01527       epoll_ctl(chan->epfd, EPOLL_CTL_DEL, chan->fds[which], &ev);
01528       aed = chan->epfd_data[which];
01529    }
01530 
01531    /* If this new fd is valid, add it to the epoll */
01532    if (fd > -1) {
01533       if (!aed && (!(aed = ast_calloc(1, sizeof(*aed)))))
01534          return;
01535       
01536       chan->epfd_data[which] = aed;
01537       aed->chan = chan;
01538       aed->which = which;
01539       
01540       ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
01541       ev.data.ptr = aed;
01542       epoll_ctl(chan->epfd, EPOLL_CTL_ADD, fd, &ev);
01543    } else if (aed) {
01544       /* We don't have to keep around this epoll data structure now */
01545       free(aed);
01546       chan->epfd_data[which] = NULL;
01547    }
01548 #endif
01549    chan->fds[which] = fd;
01550    return;
01551 }

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

Sets an option on a channel.

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

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

Referenced by ast_bridge_call(), common_exec(), conf_run(), dahdi_hangup(), dial_exec_full(), func_channel_write(), handle_tddmode(), play_record_review(), reset_volumes(), rpt(), rpt_exec(), set_listen_volume(), set_talk_volume(), try_calling(), and vm_forwardoptions().

05185 {
05186    if (!chan->tech->setoption) {
05187       errno = ENOSYS;
05188       return -1;
05189    }
05190 
05191    if (block)
05192       ast_log(LOG_ERROR, "XXX Blocking not implemented yet XXX\n");
05193 
05194    return chan->tech->setoption(chan, option, data, datalen);
05195 }

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 relative to the current time of when to hang up

This function sets the absolute time out on a channel (when to hang up).

Note:: This function does not require that the channel is locked before calling it.

Returns:: Nothing

See also:: ast_channel_setwhentohangup_tv()

Version:: 1.6.1 deprecated function (only had seconds precision)

Definition at line 528 of file channel.c.

References ast_channel_setwhentohangup_tv().

00529 {
00530    struct timeval when = { offset, };
00531    ast_channel_setwhentohangup_tv(chan, when);
00532 }

void ast_channel_setwhentohangup_tv	(	struct ast_channel *	chan,
		struct timeval	offset
	)

Set when to hang a channel up.

Parameters:

	chan	channel on which to check for hang up
	offset	offset in seconds and useconds relative to the current time of when to hang up

This function sets the absolute time out on a channel (when to hang up).

Note:: This function does not require that the channel is locked before calling it.

Returns:: Nothing

Since:: 1.6.1

Definition at line 521 of file channel.c.

References ast_null_frame, ast_queue_frame(), ast_tvadd(), ast_tvnow(), ast_tvzero(), and ast_channel::whentohangup.

Referenced by action_timeout(), ast_channel_setwhentohangup(), handle_autohangup(), and timeout_write().

00522 {
00523    chan->whentohangup = ast_tvzero(offset) ? offset : ast_tvadd(offset, ast_tvnow());
00524    ast_queue_frame(chan, &ast_null_frame);
00525    return;
00526 }

struct ast_silence_generator* ast_channel_start_silence_generator ( struct ast_channel * chan ) [read]

Starts a silence generator on the given channel.

Parameters:

chan

The channel to generate silence on

Returns:: An ast_silence_generator pointer, or NULL if an error occurs

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

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

Definition at line 5517 of file channel.c.

References ast_activate_generator(), ast_calloc, ast_debug, AST_FORMAT_SLINEAR, ast_free, ast_log(), ast_set_write_format(), LOG_ERROR, ast_silence_generator::old_write_format, and ast_channel::writeformat.

Referenced by __ast_play_and_record(), ast_dtmf_stream(), channel_spy(), record_exec(), and TransferCallStep1().

05518 {
05519    struct ast_silence_generator *state;
05520 
05521    if (!(state = ast_calloc(1, sizeof(*state)))) {
05522       return NULL;
05523    }
05524 
05525    state->old_write_format = chan->writeformat;
05526 
05527    if (ast_set_write_format(chan, AST_FORMAT_SLINEAR) < 0) {
05528       ast_log(LOG_ERROR, "Could not set write format to SLINEAR\n");
05529       ast_free(state);
05530       return NULL;
05531    }
05532 
05533    ast_activate_generator(chan, &silence_generator, state);
05534 
05535    ast_debug(1, "Started silence generator on '%s'\n", chan->name);
05536 
05537    return state;
05538 }

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

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

Parameters:

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

Returns:: nothing

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

Definition at line 5540 of file channel.c.

References ast_deactivate_generator(), ast_debug, ast_free, ast_log(), ast_set_write_format(), LOG_ERROR, and ast_silence_generator::old_write_format.

Referenced by __ast_play_and_record(), ast_dtmf_stream(), channel_spy(), HandleCallOutgoing(), key_dial_page(), record_exec(), and unistim_hangup().

05541 {
05542    if (!state)
05543       return;
05544 
05545    ast_deactivate_generator(chan);
05546 
05547    ast_debug(1, "Stopped silence generator on '%s'\n", chan->name);
05548 
05549    if (ast_set_write_format(chan, state->old_write_format) < 0)
05550       ast_log(LOG_ERROR, "Could not return write format to its original state\n");
05551 
05552    ast_free(state);
05553 }

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

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

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

04019 {
04020    return (chan->tech->send_html) ? 1 : 0;
04021 }

void ast_channel_undefer_dtmf ( struct ast_channel * chan )

Unset defer DTMF flag on channel.

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

Definition at line 1149 of file channel.c.

References ast_clear_flag, and AST_FLAG_DEFER_DTMF.

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

01150 {
01151    if (chan)
01152       ast_clear_flag(chan, AST_FLAG_DEFER_DTMF);
01153 }

void ast_channel_unregister ( const struct ast_channel_tech * tech )

Unregister a channel technology.

Parameters:

tech

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

Returns:: No return value.

Definition at line 587 of file channel.c.

References ast_debug, ast_free, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, channels, chanlist::tech, and ast_channel_tech::type.

Referenced by __unload_module(), load_module(), and unload_module().

00588 {
00589    struct chanlist *chan;
00590 
00591    ast_debug(1, "Unregistering channel type '%s'\n", tech->type);
00592 
00593    AST_RWLIST_WRLOCK(&channels);
00594 
00595    AST_LIST_TRAVERSE_SAFE_BEGIN(&backends, chan, list) {
00596       if (chan->tech == tech) {
00597          AST_LIST_REMOVE_CURRENT(list);
00598          ast_free(chan);
00599          ast_verb(2, "Unregistered channel type '%s'\n", tech->type);
00600          break;   
00601       }
00602    }
00603    AST_LIST_TRAVERSE_SAFE_END;
00604 
00605    AST_RWLIST_UNLOCK(&channels);
00606 }

struct ast_channel* ast_channel_walk_locked ( const struct ast_channel * prev ) [read]

Browse channels in use Browse the channels currently in use.

Parameters:

prev

where you want to start in the channel list

Returns:: Returns the next channel in the list, NULL on end. If it returns a channel, that channel *has been locked*!

Definition at line 1263 of file channel.c.

References channel_find_locked().

Referenced by action_coreshowchannels(), action_status(), ast_complete_channels(), ast_pickup_call(), conf_exec(), func_channels_read(), handle_chanlist(), handle_core_set_debug_channel(), next_channel(), pickup_by_exten(), and pickup_by_mark().

01264 {
01265    return channel_find_locked(prev, NULL, 0, NULL, NULL);
01266 }

struct ast_variable* ast_channeltype_list ( void ) [read]

return an ast_variable list of channeltypes

Definition at line 185 of file channel.c.

References AST_LIST_TRAVERSE, ast_variable_new(), ast_channel_tech::description, chanlist::tech, ast_channel_tech::type, and var.

00186 {
00187    struct chanlist *cl;
00188    struct ast_variable *var=NULL, *prev = NULL;
00189    AST_LIST_TRAVERSE(&backends, cl, list) {
00190       if (prev)  {
00191          if ((prev->next = ast_variable_new(cl->tech->type, cl->tech->description, "")))
00192             prev = prev->next;
00193       } else {
00194          var = ast_variable_new(cl->tech->type, cl->tech->description, "");
00195          prev = var;
00196       }
00197    }
00198    return var;
00199 }

int ast_check_hangup ( struct ast_channel * chan )

Check to see if a channel is needing hang up.

Parameters:

chan

channel on which to check for hang up This function determines if the channel is being requested to be hung up.

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

Definition at line 461 of file channel.c.

References ast_channel::_softhangup, AST_SOFTHANGUP_TIMEOUT, ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), and ast_channel::whentohangup.

Referenced by __ast_pbx_run(), __ast_read(), _macro_exec(), action_redirect(), agent_indicate(), agi_exec(), agi_handle_command(), announce_thread(), ast_bridge_call(), ast_bridge_call_thread(), ast_call(), ast_channel_bridge(), ast_check_hangup_locked(), ast_feature_request_and_dial(), ast_indicate_data(), ast_raw_answer(), ast_readstring_full(), ast_recvtext(), ast_rtp_bridge(), ast_sendtext(), ast_transfer(), ast_udptl_bridge(), ast_waitfordigit_full(), ast_write(), autoservice_run(), bridge_exec(), bridge_native_loop(), bridge_p2p_loop(), builtin_atxfer(), channel_spy(), check_bridge(), common_exec(), conf_play(), conf_run(), dahdi_sendtext(), dahdi_setoption(), dial_exec_full(), dundi_lookup_internal(), eagi_exec(), eivr_comm(), findmeexec(), handle_sendimage(), iax2_bridge(), launch_asyncagi(), lua_check_hangup(), ospfinished_exec(), pbx_builtin_incomplete(), pbx_exec(), read_exec(), readexten_exec(), rpt(), rpt_exec(), run_ras(), try_calling(), and wait_for_answer().

00462 {
00463    if (chan->_softhangup)     /* yes if soft hangup flag set */
00464       return 1;
00465    if (ast_tvzero(chan->whentohangup)) /* no if no hangup scheduled */
00466       return 0;
00467    if (ast_tvdiff_ms(chan->whentohangup, ast_tvnow()) > 0)  /* no if hangup time has not come yet. */
00468       return 0;
00469    chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT; /* record event */
00470    return 1;
00471 }

void ast_deactivate_generator ( struct ast_channel * chan )

Deactivate an active generator

Definition at line 1890 of file channel.c.

References ast_channel_lock, ast_channel_set_fd(), ast_channel_unlock, ast_clear_flag, AST_FLAG_WRITE_INT, AST_GENERATOR_FD, ast_settimeout(), ast_channel::generator, ast_channel::generatordata, and ast_generator::release.

Referenced by __ast_read(), app_exec(), ast_channel_stop_silence_generator(), ast_openstream_full(), ast_playtones_stop(), ast_quiet_chan(), ast_read_generator_actions(), ast_tonepair_stop(), ast_write(), cb_events(), channel_spy(), dial_exec_full(), generator_force(), local_ast_moh_stop(), old_milliwatt_exec(), transmit_audio(), and wait_for_answer().

01891 {
01892    ast_channel_lock(chan);
01893    if (chan->generatordata) {
01894       if (chan->generator && chan->generator->release)
01895          chan->generator->release(chan, chan->generatordata);
01896       chan->generatordata = NULL;
01897       chan->generator = NULL;
01898       ast_channel_set_fd(chan, AST_GENERATOR_FD, -1);
01899       ast_clear_flag(chan, AST_FLAG_WRITE_INT);
01900       ast_settimeout(chan, 0, NULL, NULL);
01901    }
01902    ast_channel_unlock(chan);
01903 }

int ast_do_masquerade ( struct ast_channel * original )

Start masquerading a channel XXX This is a seriously whacked out operation. We're essentially putting the guts of the clone channel into the original channel. Start by killing off the original channel's backend. I'm not sure we're going to keep this function, because while the features are nice, the cost is very high in terms of pure nastiness. XXX.

Parameters:

chan

Channel to masquerade

Start masquerading a channel XXX This is a seriously whacked 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.

Note:: Assumes channel will be locked when called

Definition at line 4270 of file channel.c.

References ast_channel::_softhangup, ast_channel::_state, ast_channel::adsicpe, ast_channel::alertpipe, ast_app_group_update(), ast_cause2str(), ast_channel_free(), ast_channel_lock, AST_CHANNEL_NAME, ast_channel_set_fd(), ast_channel_unlock, ast_copy_string(), ast_debug, AST_FLAG_BLOCKING, AST_FLAG_EXCEPTION, AST_FLAG_OUTGOING, AST_FLAG_ZOMBIE, AST_GENERATOR_FD, ast_indicate(), AST_LIST_APPEND_LIST, AST_LIST_FIRST, AST_LIST_HEAD_NOLOCK, AST_LIST_HEAD_SET_NOLOCK, AST_LIST_INSERT_TAIL, AST_LIST_REMOVE_HEAD, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log(), AST_MAX_FDS, ast_null_frame, ast_queue_frame(), ast_set_flag, ast_set_read_format(), ast_set_write_format(), AST_SOFTHANGUP_DEV, ast_state2str(), ast_string_field_set, ast_test_flag, AST_TIMING_FD, ast_channel::blocker, ast_channel::cdr, ast_datastore_info::chan_fixup, ast_channel::cid, clone_variables(), ast_datastore::data, errno, EVENT_FLAG_CALL, ast_channel::fdno, ast_channel::fds, ast_channel_tech::fixup, free_translation(), ast_channel_tech::hangup, ast_channel::hangupcause, ast_datastore::info, language, ast_channel::lock_dont_use, LOG_WARNING, manager_event, ast_channel::masq, ast_channel::masqr, ast_channel::monitor, musicclass, name, ast_channel::nativeformats, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel::readformat, report_new_callerid(), ast_channel::tech, ast_channel::tech_pvt, ast_channel::timingfd, ast_channel_tech::type, ast_channel::visible_indication, and ast_channel::writeformat.

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

04271 {
04272    int x,i;
04273    int res=0;
04274    int origstate;
04275    struct ast_frame *current;
04276    const struct ast_channel_tech *t;
04277    void *t_pvt;
04278    struct ast_callerid tmpcid;
04279    struct ast_channel *clonechan = original->masq;
04280    struct ast_cdr *cdr;
04281    int rformat = original->readformat;
04282    int wformat = original->writeformat;
04283    char newn[AST_CHANNEL_NAME];
04284    char orig[AST_CHANNEL_NAME];
04285    char masqn[AST_CHANNEL_NAME];
04286    char zombn[AST_CHANNEL_NAME];
04287 
04288    ast_debug(4, "Actually Masquerading %s(%d) into the structure of %s(%d)\n",
04289       clonechan->name, clonechan->_state, original->name, original->_state);
04290 
04291    manager_event(EVENT_FLAG_CALL, "Masquerade", "Clone: %s\r\nCloneState: %s\r\nOriginal: %s\r\nOriginalState: %s\r\n",
04292             clonechan->name, ast_state2str(clonechan->_state), original->name, ast_state2str(original->_state));
04293 
04294    /* XXX This is a seriously wacked out operation.  We're essentially putting the guts of
04295       the clone channel into the original channel.  Start by killing off the original
04296       channel's backend.   I'm not sure we're going to keep this function, because
04297       while the features are nice, the cost is very high in terms of pure nastiness. XXX */
04298 
04299    /* We need the clone's lock, too */
04300    ast_channel_lock(clonechan);
04301 
04302    ast_debug(2, "Got clone lock for masquerade on '%s' at %p\n", clonechan->name, &clonechan->lock_dont_use);
04303 
04304    /* Having remembered the original read/write formats, we turn off any translation on either
04305       one */
04306    free_translation(clonechan);
04307    free_translation(original);
04308 
04309 
04310    /* Unlink the masquerade */
04311    original->masq = NULL;
04312    clonechan->masqr = NULL;
04313    
04314    /* Save the original name */
04315    ast_copy_string(orig, original->name, sizeof(orig));
04316    /* Save the new name */
04317    ast_copy_string(newn, clonechan->name, sizeof(newn));
04318    /* Create the masq name */
04319    snprintf(masqn, sizeof(masqn), "%s<MASQ>", newn);
04320       
04321    /* Copy the name from the clone channel */
04322    ast_string_field_set(original, name, newn);
04323 
04324    /* Mangle the name of the clone channel */
04325    ast_string_field_set(clonechan, name, masqn);
04326    
04327    /* Notify any managers of the change, first the masq then the other */
04328    manager_event(EVENT_FLAG_CALL, "Rename", "Channel: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", newn, masqn, clonechan->uniqueid);
04329    manager_event(EVENT_FLAG_CALL, "Rename", "Channel: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", orig, newn, original->uniqueid);
04330 
04331    /* Swap the technologies */   
04332    t = original->tech;
04333    original->tech = clonechan->tech;
04334    clonechan->tech = t;
04335 
04336    /* Swap the cdrs */
04337    cdr = original->cdr;
04338    original->cdr = clonechan->cdr;
04339    clonechan->cdr = cdr;
04340 
04341    t_pvt = original->tech_pvt;
04342    original->tech_pvt = clonechan->tech_pvt;
04343    clonechan->tech_pvt = t_pvt;
04344 
04345    /* Swap the alertpipes */
04346    for (i = 0; i < 2; i++) {
04347       x = original->alertpipe[i];
04348       original->alertpipe[i] = clonechan->alertpipe[i];
04349       clonechan->alertpipe[i] = x;
04350    }
04351 
04352    /* 
04353     * Swap the readq's.  The end result should be this:
04354     *
04355     *  1) All frames should be on the new (original) channel.
04356     *  2) Any frames that were already on the new channel before this
04357     *     masquerade need to be at the end of the readq, after all of the
04358     *     frames on the old (clone) channel.
04359     *  3) The alertpipe needs to get poked for every frame that was already
04360     *     on the new channel, since we are now using the alert pipe from the
04361     *     old (clone) channel.
04362     */
04363    {
04364       AST_LIST_HEAD_NOLOCK(, ast_frame) tmp_readq;
04365       AST_LIST_HEAD_SET_NOLOCK(&tmp_readq, NULL);
04366 
04367       AST_LIST_APPEND_LIST(&tmp_readq, &original->readq, frame_list);
04368       AST_LIST_APPEND_LIST(&original->readq, &clonechan->readq, frame_list);
04369 
04370       while ((current = AST_LIST_REMOVE_HEAD(&tmp_readq, frame_list))) {
04371          AST_LIST_INSERT_TAIL(&original->readq, current, frame_list);
04372          if (original->alertpipe[1] > -1) {
04373             int poke = 0;
04374 
04375             if (write(original->alertpipe[1], &poke, sizeof(poke)) < 0) {
04376                ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
04377             }
04378          }
04379       }
04380    }
04381 
04382    /* Swap the raw formats */
04383    x = original->rawreadformat;
04384    original->rawreadformat = clonechan->rawreadformat;
04385    clonechan->rawreadformat = x;
04386    x = original->rawwriteformat;
04387    original->rawwriteformat = clonechan->rawwriteformat;
04388    clonechan->rawwriteformat = x;
04389 
04390    clonechan->_softhangup = AST_SOFTHANGUP_DEV;
04391 
04392    /* And of course, so does our current state.  Note we need not
04393       call ast_setstate since the event manager doesn't really consider
04394       these separate.  We do this early so that the clone has the proper
04395       state of the original channel. */
04396    origstate = original->_state;
04397    original->_state = clonechan->_state;
04398    clonechan->_state = origstate;
04399 
04400    if (clonechan->tech->fixup){
04401       res = clonechan->tech->fixup(original, clonechan);
04402       if (res)
04403          ast_log(LOG_WARNING, "Fixup failed on channel %s, strange things may happen.\n", clonechan->name);
04404    }
04405 
04406    /* Start by disconnecting the original's physical side */
04407    if (clonechan->tech->hangup)
04408       res = clonechan->tech->hangup(clonechan);
04409    if (res) {
04410       ast_log(LOG_WARNING, "Hangup failed!  Strange things may happen!\n");
04411       ast_channel_unlock(clonechan);
04412       return -1;
04413    }
04414 
04415    snprintf(zombn, sizeof(zombn), "%s<ZOMBIE>", orig);
04416    /* Mangle the name of the clone channel */
04417    ast_string_field_set(clonechan, name, zombn);
04418    manager_event(EVENT_FLAG_CALL, "Rename", "Channel: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", masqn, zombn, clonechan->uniqueid);
04419 
04420    /* Update the type. */
04421    t_pvt = original->monitor;
04422    original->monitor = clonechan->monitor;
04423    clonechan->monitor = t_pvt;
04424 
04425    /* Keep the same language.  */
04426    ast_string_field_set(original, language, clonechan->language);
04427    /* Copy the FD's other than the generator fd */
04428    for (x = 0; x < AST_MAX_FDS; x++) {
04429       if (x != AST_GENERATOR_FD)
04430          ast_channel_set_fd(original, x, clonechan->fds[x]);
04431    }
04432 
04433    ast_app_group_update(clonechan, original);
04434 
04435    /* Move data stores over */
04436    if (AST_LIST_FIRST(&clonechan->datastores)) {
04437       struct ast_datastore *ds;
04438       /* We use a safe traversal here because some fixup routines actually
04439        * remove the datastore from the list and free them.
04440        */
04441       AST_LIST_TRAVERSE_SAFE_BEGIN(&clonechan->datastores, ds, entry) {
04442          if (ds->info->chan_fixup)
04443             ds->info->chan_fixup(ds->data, clonechan, original);
04444       }
04445       AST_LIST_TRAVERSE_SAFE_END;
04446       AST_LIST_APPEND_LIST(&original->datastores, &clonechan->datastores, entry);
04447    }
04448 
04449    clone_variables(original, clonechan);
04450    /* Presense of ADSI capable CPE follows clone */
04451    original->adsicpe = clonechan->adsicpe;
04452    /* Bridge remains the same */
04453    /* CDR fields remain the same */
04454    /* XXX What about blocking, softhangup, blocker, and lock and blockproc? XXX */
04455    /* Application and data remain the same */
04456    /* Clone exception  becomes real one, as with fdno */
04457    ast_set_flag(original, ast_test_flag(clonechan, AST_FLAG_OUTGOING | AST_FLAG_EXCEPTION));
04458    original->fdno = clonechan->fdno;
04459    /* Schedule context remains the same */
04460    /* Stream stuff stays the same */
04461    /* Keep the original state.  The fixup code will need to work with it most likely */
04462 
04463    /* Just swap the whole structures, nevermind the allocations, they'll work themselves
04464       out. */
04465    tmpcid = original->cid;
04466    original->cid = clonechan->cid;
04467    clonechan->cid = tmpcid;
04468    report_new_callerid(original);
04469 
04470    /* Restore original timing file descriptor */
04471    ast_channel_set_fd(original, AST_TIMING_FD, original->timingfd);
04472 
04473    /* Our native formats are different now */
04474    original->nativeformats = clonechan->nativeformats;
04475 
04476    /* Context, extension, priority, app data, jump table,  remain the same */
04477    /* pvt switches.  pbx stays the same, as does next */
04478 
04479    /* Set the write format */
04480    ast_set_write_format(original, wformat);
04481 
04482    /* Set the read format */
04483    ast_set_read_format(original, rformat);
04484 
04485    /* Copy the music class */
04486    ast_string_field_set(original, musicclass, clonechan->musicclass);
04487 
04488    ast_debug(1, "Putting channel %s in %d/%d formats\n", original->name, wformat, rformat);
04489 
04490    /* Okay.  Last thing is to let the channel driver know about all this mess, so he
04491       can fix up everything as best as possible */
04492    if (original->tech->fixup) {
04493       res = original->tech->fixup(clonechan, original);
04494       if (res) {
04495          ast_log(LOG_WARNING, "Channel for type '%s' could not fixup channel %s\n",
04496             original->tech->type, original->name);
04497          ast_channel_unlock(clonechan);
04498          return -1;
04499       }
04500    } else
04501       ast_log(LOG_WARNING, "Channel type '%s' does not have a fixup routine (for %s)!  Bad things may happen.\n",
04502          original->tech->type, original->name);
04503 
04504    /* 
04505     * If an indication is currently playing, maintain it on the channel 
04506     * that is taking the place of original 
04507     *
04508     * This is needed because the masquerade is swapping out in the internals
04509     * of this channel, and the new channel private data needs to be made
04510     * aware of the current visible indication (RINGING, CONGESTION, etc.)
04511     */
04512    if (original->visible_indication) {
04513       ast_indicate(original, original->visible_indication);
04514    }
04515    
04516    /* Now, at this point, the "clone" channel is totally F'd up.  We mark it as
04517       a zombie so nothing tries to touch it.  If it's already been marked as a
04518       zombie, then free it now (since it already is considered invalid). */
04519    if (ast_test_flag(clonechan, AST_FLAG_ZOMBIE)) {
04520       ast_debug(1, "Destroying channel clone '%s'\n", clonechan->name);
04521       ast_channel_unlock(clonechan);
04522       manager_event(EVENT_FLAG_CALL, "Hangup",
04523          "Channel: %s\r\n"
04524          "Uniqueid: %s\r\n"
04525          "Cause: %d\r\n"
04526          "Cause-txt: %s\r\n",
04527          clonechan->name,
04528          clonechan->uniqueid,
04529          clonechan->hangupcause,
04530          ast_cause2str(clonechan->hangupcause)
04531          );
04532       ast_channel_free(clonechan);
04533    } else {
04534       ast_debug(1, "Released clone lock on '%s'\n", clonechan->name);
04535       ast_set_flag(clonechan, AST_FLAG_ZOMBIE);
04536       ast_queue_frame(clonechan, &ast_null_frame);
04537       ast_channel_unlock(clonechan);
04538    }
04539 
04540    /* Signal any blocker */
04541    if (ast_test_flag(original, AST_FLAG_BLOCKING))
04542       pthread_kill(original->blocker, SIGURG);
04543    ast_debug(1, "Done Masquerading %s (%d)\n", original->name, original->_state);
04544    return 0;
04545 }

static int ast_fdisset	(	struct pollfd *	pfds,
		int	fd,
		int	maximum,
		int *	start
	)			`[inline, static]`

Helper function for migrating select to poll.

Definition at line 1665 of file channel.h.

References dummy().

Referenced by do_monitor().

01666 {
01667    int x;
01668    int dummy = 0;
01669 
01670    if (fd < 0)
01671       return 0;
01672    if (!start)
01673       start = &dummy;
01674    for (x = *start; x < maximum; x++)
01675       if (pfds[x].fd == fd) {
01676          if (x == *start)
01677             (*start)++;
01678          return pfds[x].revents;
01679       }
01680    return 0;
01681 }

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

Get channel by exten (and optionally context) and lock it.

Definition at line 1288 of file channel.c.

References channel_find_locked().

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

struct ast_channel* ast_get_channel_by_name_locked ( const char * name ) [read]

Get channel by name or uniqueid (locks channel).

Definition at line 1269 of file channel.c.

References channel_find_locked().

Referenced by acf_import(), action_add_agi_cmd(), action_atxfer(), action_getvar(), action_hangup(), action_redirect(), action_sendtext(), action_setvar(), action_status(), action_timeout(), ast_async_goto_by_name(), ast_bridge_call(), ast_park_call_full(), asyncgoto_exec(), change_monitor_action(), do_pause_or_unpause(), get_dahdi_channel_locked(), handle_channelstatus(), handle_cli_agi_add_cmd(), handle_core_set_debug_channel(), handle_getvariablefull(), handle_hangup(), handle_set_chanvar(), handle_show_chanvar(), handle_showchan(), handle_softhangup(), manager_park(), manager_play_dtmf(), pbx_builtin_importvar(), shared_read(), shared_write(), start_monitor_action(), and stop_monitor_action().

01270 {
01271    return channel_find_locked(NULL, name, 0, NULL, NULL);
01272 }

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

Get channel by name or uniqueid prefix (locks channel).

Definition at line 1275 of file channel.c.

References channel_find_locked().

Referenced by action_bridge(), ast_parse_device_state(), bridge_exec(), common_exec(), handle_cli_mixmonitor(), shared_read(), and shared_write().

01276 {
01277    return channel_find_locked(NULL, name, namelen, NULL, NULL);
01278 }

struct ast_channel_tech* ast_get_channel_tech ( const char * name ) [read]

Get a channel technology structure by name.

Parameters:

name

name of technology to find

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

Definition at line 609 of file channel.c.

References AST_LIST_TRAVERSE, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, channels, chanlist::tech, and ast_channel_tech::type.

Referenced by _ast_device_state().

00610 {
00611    struct chanlist *chanls;
00612    const struct ast_channel_tech *ret = NULL;
00613 
00614    AST_RWLIST_RDLOCK(&channels);
00615 
00616    AST_LIST_TRAVERSE(&backends, chanls, list) {
00617       if (!strcasecmp(name, chanls->tech->type)) {
00618          ret = chanls->tech;
00619          break;
00620       }
00621    }
00622 
00623    AST_RWLIST_UNLOCK(&channels);
00624    
00625    return ret;
00626 }

ast_group_t ast_get_group ( const char * s )

Definition at line 5362 of file channel.c.

References ast_log(), ast_strdupa, ast_strlen_zero(), LOG_ERROR, LOG_WARNING, and strsep().

Referenced by _parse(), build_device(), build_gateway(), build_peer(), func_channel_write(), process_dahdi(), and read_agent_config().

05363 {
05364    char *piece;
05365    char *c;
05366    int start=0, finish=0, x;
05367    ast_group_t group = 0;
05368 
05369    if (ast_strlen_zero(s))
05370       return 0;
05371 
05372    c = ast_strdupa(s);
05373    
05374    while ((piece = strsep(&c, ","))) {
05375       if (sscanf(piece, "%30d-%30d", &start, &finish) == 2) {
05376          /* Range */
05377       } else if (sscanf(piece, "%30d", &start)) {
05378          /* Just one */
05379          finish = start;
05380       } else {
05381          ast_log(LOG_ERROR, "Syntax error parsing group configuration '%s' at '%s'. Ignoring.\n", s, piece);
05382          continue;
05383       }
05384       for (x = start; x <= finish; x++) {
05385          if ((x > 63) || (x < 0)) {
05386             ast_log(LOG_WARNING, "Ignoring invalid group %d (maximum group is 63)\n", x);
05387          } else
05388             group |= ((ast_group_t) 1 << x);
05389       }
05390    }
05391    return group;
05392 }

int ast_hangup ( struct ast_channel * chan )

Hang up a channel.

Note:: This function performs a hard hangup on a channel. Unlike the soft-hangup, this function performs all stream stopping, etc, on the channel that needs to end. chan is no longer valid after this call.

Parameters:

chan

channel to hang up

Returns:: Returns 0 on success, -1 on failure.

Definition at line 1634 of file channel.c.

References ast_assert, ast_audiohook_detach_list(), ast_autoservice_stop(), ast_cause2str(), ast_cdr_detach(), ast_cdr_end(), AST_CDR_FLAG_BRIDGED, AST_CDR_FLAG_DIALED, AST_CDR_FLAG_POST_DISABLED, AST_CDR_NULL, ast_channel_free(), ast_channel_lock, ast_channel_unlock, ast_closestream(), ast_debug, ast_do_masquerade(), AST_FLAG_BLOCKING, AST_FLAG_ZOMBIE, ast_log(), ast_set_flag, ast_test_flag, ast_channel::audiohooks, ast_channel::blocker, ast_channel::blockproc, ast_channel::cdr, ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, ast_cdr::disposition, EVENT_FLAG_CALL, free_translation(), ast_channel::generator, ast_channel::generatordata, ast_channel_tech::hangup, ast_channel::hangupcause, LOG_WARNING, manager_event, ast_channel::masq, ast_channel::masqr, ast_generator::release, S_OR, ast_channel::sched, sched_context_destroy(), ast_channel::stream, ast_channel::tech, and ast_channel::vstream.

Referenced by __ast_pbx_run(), __ast_request_and_dial(), __oh323_new(), action_bridge(), agent_hangup(), agent_read(), alsa_new(), answer_exec_run(), app_exec(), ast_async_goto(), ast_bridge_call_thread(), ast_call_forward(), ast_dial_destroy(), ast_dial_hangup(), ast_feature_request_and_dial(), ast_iax2_new(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_pbx_run_app(), async_wait(), begin_dial_channel(), bridge_exec(), build_conf(), builtin_atxfer(), chanavail_exec(), check_compat(), check_goto_on_transfer(), clear_caller(), conf_free(), conf_run(), connect_link(), console_new(), dahdi_handle_event(), dahdi_new(), dial_exec_full(), do_forward(), do_hang(), do_idle_thread(), findmeexec(), gtalk_new(), handle_call_forward(), handle_callforward_button(), handle_enbloc_call_message(), handle_frame(), handle_frame_ownerless(), handle_hd_hf(), handle_init_event(), handle_invite_replaces(), handle_offhook_message(), handle_request_invite(), handle_soft_key_event_message(), handle_stimulus_message(), handle_timeout_trip(), handle_transfer_button(), HandleCallOutgoing(), hangup_chan(), hangupcalls(), hanguptree(), iax2_request(), iax_park(), iax_park_thread(), jingle_new(), local_hangup(), manage_parkinglot(), masq_park_call(), mgcp_new(), mgcp_ss(), monitor_dial(), mwi_thread(), nbs_new(), oss_new(), park_exec_full(), parkandannounce_exec(), phone_new(), pri_dchannel(), rpt(), rpt_call(), rpt_exec(), rpt_tele_thread(), sip_new(), sip_park(), sip_park_thread(), skinny_new(), skinny_ss(), ss_thread(), try_calling(), unistim_new(), usbradio_new(), wait_for_answer(), and wait_for_winner().

01635 {
01636    int res = 0;
01637 
01638    /* Don't actually hang up a channel that will masquerade as someone else, or
01639       if someone is going to masquerade as us */
01640    ast_channel_lock(chan);
01641 
01642    if (chan->audiohooks) {
01643       ast_audiohook_detach_list(chan->audiohooks);
01644       chan->audiohooks = NULL;
01645    }
01646 
01647    ast_autoservice_stop(chan);
01648 
01649    if (chan->masq) {
01650       if (ast_do_masquerade(chan))
01651          ast_log(LOG_WARNING, "Failed to perform masquerade\n");
01652    }
01653 
01654    if (chan->masq) {
01655       ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name);
01656       ast_channel_unlock(chan);
01657       return 0;
01658    }
01659    /* If this channel is one which will be masqueraded into something,
01660       mark it as a zombie already, so we know to free it later */
01661    if (chan->masqr) {
01662       ast_set_flag(chan, AST_FLAG_ZOMBIE);
01663       ast_channel_unlock(chan);
01664       return 0;
01665    }
01666    free_translation(chan);
01667    /* Close audio stream */
01668    if (chan->stream) {
01669       ast_closestream(chan->stream);
01670       chan->stream = NULL;
01671    }
01672    /* Close video stream */
01673    if (chan->vstream) {
01674       ast_closestream(chan->vstream);
01675       chan->vstream = NULL;
01676    }
01677    if (chan->sched) {
01678       sched_context_destroy(chan->sched);
01679       chan->sched = NULL;
01680    }
01681    
01682    if (chan->generatordata)   /* Clear any tone stuff remaining */
01683       if (chan->generator && chan->generator->release)
01684          chan->generator->release(chan, chan->generatordata);
01685    chan->generatordata = NULL;
01686    chan->generator = NULL;
01687    if (ast_test_flag(chan, AST_FLAG_BLOCKING)) {
01688       ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd "
01689                "is blocked by thread %ld in procedure %s!  Expect a failure\n",
01690                (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc);
01691       ast_assert(ast_test_flag(chan, AST_FLAG_BLOCKING) == 0);
01692    }
01693    if (!ast_test_flag(chan, AST_FLAG_ZOMBIE)) {
01694       ast_debug(1, "Hanging up channel '%s'\n", chan->name);
01695       if (chan->tech->hangup)
01696          res = chan->tech->hangup(chan);
01697    } else {
01698       ast_debug(1, "Hanging up zombie '%s'\n", chan->name);
01699    }
01700          
01701    ast_channel_unlock(chan);
01702    manager_event(EVENT_FLAG_CALL, "Hangup",
01703          "Channel: %s\r\n"
01704          "Uniqueid: %s\r\n"
01705          "CallerIDNum: %s\r\n"
01706          "CallerIDName: %s\r\n"
01707          "Cause: %d\r\n"
01708          "Cause-txt: %s\r\n",
01709          chan->name,
01710          chan->uniqueid,
01711          S_OR(chan->cid.cid_num, "<unknown>"),
01712          S_OR(chan->cid.cid_name, "<unknown>"),
01713          chan->hangupcause,
01714          ast_cause2str(chan->hangupcause)
01715          );
01716 
01717    if (chan->cdr && !ast_test_flag(chan->cdr, AST_CDR_FLAG_BRIDGED) && 
01718       !ast_test_flag(chan->cdr, AST_CDR_FLAG_POST_DISABLED) && 
01719        (chan->cdr->disposition != AST_CDR_NULL || ast_test_flag(chan->cdr, AST_CDR_FLAG_DIALED))) {
01720       ast_channel_lock(chan);
01721          
01722       ast_cdr_end(chan->cdr);
01723       ast_cdr_detach(chan->cdr);
01724       chan->cdr = NULL;
01725       ast_channel_unlock(chan);
01726    }
01727    
01728    ast_channel_free(chan);
01729 
01730    return res;
01731 }

int ast_indicate	(	struct ast_channel *	chan,
		int	condition
	)

Indicates condition of channel.

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

Parameters:

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

Returns:: Returns 0 on success, -1 on failure

Definition at line 3025 of file channel.c.

References ast_indicate_data().

Referenced by __ast_play_and_record(), agent_new(), alsa_call(), answer_trunk_chan(), ast_bridge_call(), ast_channel_bridge(), ast_do_masquerade(), ast_dtmf_stream(), ast_feature_request_and_dial(), ast_park_call_full(), ast_raw_answer(), attempt_transfer(), builtin_atxfer(), builtin_blindtransfer(), cli_console_answer(), conf_run(), console_call(), dial_exec_full(), disa_exec(), do_forward(), finishup(), function_remote(), handle_callforward_button(), handle_frame(), handle_recordfile(), manage_parkinglot(), mgcp_ss(), monitor_dial(), oss_call(), park_exec_full(), pbx_builtin_busy(), pbx_builtin_congestion(), pbx_builtin_proceeding(), pbx_builtin_progress(), pbx_builtin_ringing(), pbx_builtin_waitexten(), queue_exec(), record_exec(), rpt(), rpt_exec(), say_periodic_announcement(), say_position(), send_waveform_to_channel(), skinny_ss(), sla_handle_hold_event(), sla_station_exec(), sla_trunk_exec(), try_calling(), and wait_for_answer().

03026 {
03027    return ast_indicate_data(chan, condition, NULL, 0);
03028 }

int ast_indicate_data	(	struct ast_channel *	chan,
		int	condition,
		const void *	data,
		size_t	datalen
	)

Indicates condition of channel, with payload.

Note:: Indicate a condition such as AST_CONTROL_HOLD with payload being music on hold class

Parameters:

	chan	channel to change the indication
	condition	which condition to indicate on the channel
	data	pointer to payload data
	datalen	size of payload data

Returns:: Returns 0 on success, -1 on failure

Note:: If we compare the enumeration type, which does not have any negative constants, the compiler may optimize this code away. Therefore, we must perform an integer comparison here.

Definition at line 3065 of file channel.c.

References ast_channel::_state, _XXX_AST_CONTROL_T38, ast_channel_lock, ast_channel_unlock, ast_check_hangup(), AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_FLASH, AST_CONTROL_HANGUP, AST_CONTROL_HOLD, AST_CONTROL_OFFHOOK, AST_CONTROL_OPTION, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RADIO_KEY, AST_CONTROL_RADIO_UNKEY, AST_CONTROL_RING, AST_CONTROL_RINGING, AST_CONTROL_SRCUPDATE, AST_CONTROL_T38_PARAMETERS, AST_CONTROL_TAKEOFFHOOK, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, AST_CONTROL_WINK, ast_debug, AST_FLAG_ZOMBIE, ast_get_indication_tone(), ast_log(), ast_playtones_start(), ast_playtones_stop(), AST_STATE_UP, ast_test_flag, tone_zone_sound::data, ast_channel_tech::indicate, is_visible_indication(), LOG_WARNING, ast_channel::tech, ast_channel::visible_indication, and ast_channel::zone.

Referenced by agent_hangup(), ast_bridge_call(), ast_generic_bridge(), ast_indicate(), ast_park_call_full(), bridge_native_loop(), bridge_p2p_loop(), login_exec(), manage_parkinglot(), pbx_builtin_waitexten(), transmit_audio(), and wait_for_answer().

03067 {
03068    /* By using an enum, we'll get compiler warnings for values not handled 
03069     * in switch statements. */
03070    enum ast_control_frame_type condition = _condition;
03071    const struct tone_zone_sound *ts = NULL;
03072    int res = -1;
03073 
03074    ast_channel_lock(chan);
03075 
03076    /* Don't bother if the channel is about to go away, anyway. */
03077    if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
03078       ast_channel_unlock(chan);
03079       return -1;
03080    }
03081 
03082    if (chan->tech->indicate) {
03083       /* See if the channel driver can handle this condition. */
03084       res = chan->tech->indicate(chan, condition, data, datalen);
03085    }
03086 
03087    ast_channel_unlock(chan);
03088 
03089    if (!res) {
03090       /* The channel driver successfully handled this indication */
03091       if (is_visible_indication(condition)) {
03092          chan->visible_indication = condition;
03093       }
03094       return 0;
03095    }
03096 
03097    /* The channel driver does not support this indication, let's fake
03098     * it by doing our own tone generation if applicable. */
03099 
03100    /*!\note If we compare the enumeration type, which does not have any
03101     * negative constants, the compiler may optimize this code away.
03102     * Therefore, we must perform an integer comparison here. */
03103    if (_condition < 0) {
03104       /* Stop any tones that are playing */
03105       ast_playtones_stop(chan);
03106       return 0;
03107    }
03108 
03109    /* Handle conditions that we have tones for. */
03110    switch (condition) {
03111    case _XXX_AST_CONTROL_T38:
03112       /* deprecated T.38 control frame */
03113       return -1;
03114    case AST_CONTROL_T38_PARAMETERS:
03115       /* there is no way to provide 'default' behavior for these
03116        * control frames, so we need to return failure, but there
03117        * is also no value in the log message below being emitted
03118        * since failure to handle these frames is not an 'error'
03119        * so just return right now.
03120        */
03121       return -1;
03122    case AST_CONTROL_RINGING:
03123       ts = ast_get_indication_tone(chan->zone, "ring");
03124       /* It is common practice for channel drivers to return -1 if trying
03125        * to indicate ringing on a channel which is up. The idea is to let the
03126        * core generate the ringing inband. However, we don't want the
03127        * warning message about not being able to handle the specific indication
03128        * to print nor do we want ast_indicate_data to return an "error" for this
03129        * condition
03130        */
03131       if (chan->_state == AST_STATE_UP) {
03132          res = 0;
03133       }
03134       break;
03135    case AST_CONTROL_BUSY:
03136       ts = ast_get_indication_tone(chan->zone, "busy");
03137       break;
03138    case AST_CONTROL_CONGESTION:
03139       ts = ast_get_indication_tone(chan->zone, "congestion");
03140       break;
03141    case AST_CONTROL_PROGRESS:
03142    case AST_CONTROL_PROCEEDING:
03143    case AST_CONTROL_VIDUPDATE:
03144    case AST_CONTROL_SRCUPDATE:
03145    case AST_CONTROL_RADIO_KEY:
03146    case AST_CONTROL_RADIO_UNKEY:
03147    case AST_CONTROL_OPTION:
03148    case AST_CONTROL_WINK:
03149    case AST_CONTROL_FLASH:
03150    case AST_CONTROL_OFFHOOK:
03151    case AST_CONTROL_TAKEOFFHOOK:
03152    case AST_CONTROL_ANSWER:
03153    case AST_CONTROL_HANGUP:
03154    case AST_CONTROL_RING:
03155    case AST_CONTROL_HOLD:
03156    case AST_CONTROL_UNHOLD:
03157       /* Nothing left to do for these. */
03158       res = 0;
03159       break;
03160    }
03161 
03162    if (ts && ts->data[0]) {
03163       /* We have a tone to play, yay. */
03164       ast_debug(1, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition);
03165       ast_playtones_start(chan, 0, ts->data, 1);
03166       res = 0;
03167       chan->visible_indication = condition;
03168    }
03169 
03170    if (res) {
03171       /* not handled */
03172       ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name);
03173    }
03174 
03175    return res;
03176 }

int ast_internal_timing_enabled ( struct ast_channel * chan )

Check if the channel can run in internal timing mode.

Parameters:

chan

The channel to check

Returns:: boolean

This function will return 1 if internal timing is enabled and the timing device is available.

Definition at line 3008 of file channel.c.

References ast_debug, ast_opt_internal_timing, and ast_channel::timingfd.

Referenced by add_sdp(), and ast_read_generator_actions().

03009 {
03010    int ret = ast_opt_internal_timing && chan->timingfd > -1;
03011    ast_debug(5, "Internal timing is %s (option_internal_timing=%d chan->timingfd=%d)\n", ret? "enabled": "disabled", ast_opt_internal_timing, chan->timingfd);
03012    return ret;
03013 }

void ast_poll_channel_add	(	struct ast_channel *	chan0,
		struct ast_channel *	chan1
	)

Add a channel to an optimized waitfor

Definition at line 1554 of file channel.c.

References AST_MAX_FDS, and ast_channel::fds.

Referenced by ast_feature_request_and_dial(), ast_generic_bridge(), begin_dial_channel(), bridge_native_loop(), bridge_p2p_loop(), and wait_for_answer().

01555 {
01556 #ifdef HAVE_EPOLL
01557    struct epoll_event ev;
01558    int i = 0;
01559 
01560    if (chan0->epfd == -1)
01561       return;
01562 
01563    /* Iterate through the file descriptors on chan1, adding them to chan0 */
01564    for (i = 0; i < AST_MAX_FDS; i++) {
01565       if (chan1->fds[i] == -1)
01566          continue;
01567       ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP;
01568       ev.data.ptr = chan1->epfd_data[i];
01569       epoll_ctl(chan0->epfd, EPOLL_CTL_ADD, chan1->fds[i], &ev);
01570    }
01571 
01572 #endif
01573    return;
01574 }

void ast_poll_channel_del	(	struct ast_channel *	chan0,
		struct ast_channel *	chan1
	)

Delete a channel from an optimized waitfor

Definition at line 1577 of file channel.c.

References AST_MAX_FDS, and ast_channel::fds.

Referenced by ast_feature_request_and_dial(), ast_generic_bridge(), bridge_native_loop(), bridge_p2p_loop(), monitor_dial(), and wait_for_answer().

01578 {
01579 #ifdef HAVE_EPOLL
01580    struct epoll_event ev;
01581    int i = 0;
01582 
01583    if (chan0->epfd == -1)
01584       return;
01585 
01586    for (i = 0; i < AST_MAX_FDS; i++) {
01587       if (chan1->fds[i] == -1)
01588          continue;
01589       epoll_ctl(chan0->epfd, EPOLL_CTL_DEL, chan1->fds[i], &ev);
01590    }
01591 
01592 #endif
01593    return;
01594 }

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

print call- and pickup groups into buffer

Definition at line 5444 of file channel.c.

References first, and num.

Referenced by _sip_show_peer(), func_channel_read(), function_sippeer(), handle_skinny_show_line(), misdn_cfg_get_config_string(), print_group(), read_config(), and serialize_showchan().

05445 {
05446    unsigned int i;
05447    int first = 1;
05448    char num[3];
05449 
05450    buf[0] = '\0';
05451    
05452    if (!group) /* Return empty string if no group */
05453       return buf;
05454 
05455    for (i = 0; i <= 63; i++) {   /* Max group is 63 */
05456       if (group & ((ast_group_t) 1 << i)) {
05457             if (!first) {
05458             strncat(buf, ", ", buflen - strlen(buf) - 1);
05459          } else {
05460             first = 0;
05461          }
05462          snprintf(num, sizeof(num), "%u", i);
05463          strncat(buf, num, buflen - strlen(buf) - 1);
05464       }
05465    }
05466    return buf;
05467 }

int ast_prod ( struct ast_channel * chan )

Send empty audio to prime a channel driver.

Definition at line 3297 of file channel.c.

References ast_channel::_state, ast_debug, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log(), AST_STATE_UP, ast_write(), ast_frame::data, LOG_WARNING, ast_frame::ptr, ast_channel::rawwriteformat, ast_frame::src, and ast_frame::subclass.

Referenced by ast_activate_generator().

03298 {
03299    struct ast_frame a = { AST_FRAME_VOICE };
03300    char nothing[128];
03301 
03302    /* Send an empty audio frame to get things moving */
03303    if (chan->_state != AST_STATE_UP) {
03304       ast_debug(1, "Prodding channel '%s'\n", chan->name);
03305       a.subclass = chan->rawwriteformat;
03306       a.data.ptr = nothing + AST_FRIENDLY_OFFSET;
03307       a.src = "ast_prod";
03308       if (ast_write(chan, &a))
03309          ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
03310    }
03311    return 0;
03312 }

int ast_queue_control	(	struct ast_channel *	chan,
		enum ast_control_frame_type	control
	)

Queue a control frame with payload.

Parameters:

	chan	channel to queue frame onto
	control	type of control frame

Note:: The channel does not need to be locked before calling this function.

Return values:

	zero	on success
	non-zero	on failure

Definition at line 1114 of file channel.c.

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

Referenced by __dahdi_exception(), __oh323_update_info(), ast_pickup_call(), attempt_transfer(), auto_congest(), cb_events(), dahdi_handle_event(), dahdi_hangup(), gtalk_is_answered(), gtalk_ringing_ack(), handle_hd_hf(), handle_offhook_message(), handle_request(), handle_request_bye(), handle_request_info(), handle_request_invite(), handle_request_refer(), handle_response(), handle_response_invite(), handle_response_refer(), handle_soft_key_event_message(), handle_stimulus_message(), HandleCallIncoming(), jingle_is_answered(), jingle_ringing_ack(), mgcp_call(), misdn_attempt_transfer(), nbs_call(), phone_call(), pickup_do(), process_sdp(), receive_digit(), remote_hold(), send_cause2ast(), setup_rtp_connection(), skinny_call(), skinny_transfer(), skinny_unhold(), ss_thread(), unistim_call(), and update_state().

01115 {
01116    struct ast_frame f = { AST_FRAME_CONTROL, };
01117 
01118    f.subclass = control;
01119 
01120    return ast_queue_frame(chan, &f);
01121 }

int ast_queue_control_data	(	struct ast_channel *	chan,
		enum ast_control_frame_type	control,
		const void *	data,
		size_t	datalen
	)

Queue a control frame with payload.

Parameters:

	chan	channel to queue frame onto
	control	type of control frame
	data	pointer to payload data to be included in frame
	datalen	number of bytes of payload data

Return values:

	0	success
	non-zero	failure

The supplied payload data is copied into the frame, so the caller's copy is not modified nor freed, and the resulting frame will retain a copy of the data even if the caller frees their local copy.

Note:: This method should be treated as a 'network transport'; in other words, your frames may be transferred across an IAX2 channel to another system, which may be a different endianness than yours. Because of this, you should ensure that either your frames will never be expected to work across systems, or that you always put your payload data into 'network byte order' before calling this function.; The channel does not need to be locked before calling this function.

Definition at line 1124 of file channel.c.

References AST_FRAME_CONTROL, ast_queue_frame(), ast_frame::data, ast_frame::datalen, ast_frame::ptr, and ast_frame::subclass.

Referenced by change_t38_state(), dahdi_handle_event(), dahdi_hangup(), iax2_queue_control_data(), process_sdp(), and skinny_hold().

01126 {
01127    struct ast_frame f = { AST_FRAME_CONTROL, };
01128 
01129    f.subclass = control;
01130    f.data.ptr = (void *) data;
01131    f.datalen = datalen;
01132 
01133    return ast_queue_frame(chan, &f);
01134 }

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

Queue one or more frames to a channel's frame queue.

Parameters:

	chan	the channel to queue the frame(s) on
	f	the frame(s) to queue. Note that the frame(s) will be duplicated by this function. It is the responsibility of the caller to handle freeing the memory associated with the frame(s) being passed if necessary.

Return values:

	0	success
	non-zero	failure

Definition at line 1071 of file channel.c.

References __ast_queue_frame().

Referenced by __ast_read(), __oh323_rtp_create(), __oh323_update_info(), action_atxfer(), agent_new(), alsa_call(), ast_channel_masquerade(), ast_channel_setwhentohangup_tv(), ast_do_masquerade(), ast_dsp_process(), ast_queue_control(), ast_queue_control_data(), ast_queue_hangup(), ast_queue_hangup_with_cause(), ast_softhangup_nolock(), cb_events(), cli_console_answer(), cli_console_dial(), cli_console_flash(), cli_console_sendtext(), console_answer(), console_call(), console_dial(), console_do_answer(), console_flash(), console_sendtext(), dahdi_queue_frame(), dictate_exec(), do_immediate_setup(), gtalk_handle_dtmf(), handle_keypad_button_message(), handle_request_info(), handle_request_invite(), handle_response_invite(), iax2_queue_frame(), jingle_handle_dtmf(), local_queue_frame(), mgcp_queue_frame(), oh323_simulate_dtmf_end(), oss_call(), process_sdp(), queue_dtmf_readq(), receive_digit(), receive_message(), rpt_call(), stream_monitor(), unistim_do_senddigit(), unistim_senddigit_end(), usbradio_read(), and wakeup_sub().

01072 {
01073    return __ast_queue_frame(chan, fin, 0, NULL);
01074 }

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

Queue one or more frames to the head of a channel's frame queue.

Parameters:

	chan	the channel to queue the frame(s) on
	f	the frame(s) to queue. Note that the frame(s) will be duplicated by this function. It is the responsibility of the caller to handle freeing the memory associated with the frame(s) being passed if necessary.

Return values:

	0	success
	non-zero	failure

Definition at line 1076 of file channel.c.

References __ast_queue_frame().

Referenced by __ast_answer(), __ast_read(), and ast_autoservice_stop().

01077 {
01078    return __ast_queue_frame(chan, fin, 1, NULL);
01079 }

int ast_queue_hangup ( struct ast_channel * chan )

Queue a hangup frame.

Note:: The channel does not need to be locked before calling this function.

Definition at line 1082 of file channel.c.

References ast_channel::_softhangup, ast_channel_trylock, ast_channel_unlock, AST_CONTROL_HANGUP, AST_FRAME_CONTROL, ast_queue_frame(), and AST_SOFTHANGUP_DEV.

Referenced by cleanup_connection(), cli_console_hangup(), close_call(), gtalk_hangup_farend(), gtalk_is_answered(), handle_onhook_message(), handle_request_bye(), handle_request_cancel(), handle_soft_key_event_message(), iax2_destroy(), iax2_queue_hangup(), jingle_hangup_farend(), local_hangup(), and mgcp_queue_hangup().

01083 {
01084    struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
01085    /* Yeah, let's not change a lock-critical value without locking */
01086    if (!ast_channel_trylock(chan)) {
01087       chan->_softhangup |= AST_SOFTHANGUP_DEV;
01088       ast_channel_unlock(chan);
01089    }
01090    return ast_queue_frame(chan, &f);
01091 }

int ast_queue_hangup_with_cause	(	struct ast_channel *	chan,
		int	cause
	)

Queue a hangup frame with hangupcause set.

Note:: The channel does not need to be locked before calling this function.

Parameters:

`[in]`	chan	channel to queue frame onto
`[in]`	cause	the hangup cause

Returns:: 0 on success, -1 on error

Since:: 1.6.1

Definition at line 1094 of file channel.c.

References ast_channel::_softhangup, ast_channel_trylock, ast_channel_unlock, AST_CONTROL_HANGUP, AST_FRAME_CONTROL, ast_queue_frame(), AST_SOFTHANGUP_DEV, ast_frame::data, ast_channel::hangupcause, and ast_frame::uint32.

Referenced by __oh323_update_info(), __sip_autodestruct(), close_call(), close_client(), console_hangup(), dahdi_handle_event(), handle_request_bye(), handle_response(), handle_response_invite(), handle_response_notify(), HandleCallOutgoing(), hangup_chan(), hangup_connection(), misdn_answer(), pri_hangup_all(), retrans_pkt(), and TransferCallStep1().

01095 {
01096    struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
01097 
01098    if (cause >= 0)
01099       f.data.uint32 = cause;
01100 
01101    /* Yeah, let's not change a lock-critical value without locking */
01102    if (!ast_channel_trylock(chan)) {
01103       chan->_softhangup |= AST_SOFTHANGUP_DEV;
01104       if (cause < 0)
01105          f.data.uint32 = chan->hangupcause;
01106 
01107       ast_channel_unlock(chan);
01108    }
01109 
01110    return ast_queue_frame(chan, &f);
01111 }

int ast_raw_answer	(	struct ast_channel *	chan,
		int	cdr_answer
	)

Answer a channel.

Parameters:

	chan	channel to answer
	cdr_answer	flag to control whether any associated CDR should be marked as 'answered'

This function answers a channel and handles all necessary call setup functions.

Note:: The channel passed does not need to be locked, but is locked by the function when needed.; Unlike ast_answer(), this function will not wait for media flow to begin. The caller should be careful before sending media to the channel before incoming media arrives, as the outgoing media may be lost.

Return values:

	0	on success
	non-zero	on failure

Definition at line 1733 of file channel.c.

References ast_channel::_state, ast_channel_tech::answer, ast_cdr_answer(), ast_channel_lock, ast_channel_unlock, ast_check_hangup(), AST_FLAG_OUTGOING, AST_FLAG_ZOMBIE, ast_indicate(), ast_setstate(), AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, ast_test_flag, ast_channel::cdr, ast_channel::tech, and ast_channel::visible_indication.

Referenced by __ast_answer(), and ast_bridge_call().

01734 {
01735    int res = 0;
01736 
01737    ast_channel_lock(chan);
01738 
01739    /* You can't answer an outbound call */
01740    if (ast_test_flag(chan, AST_FLAG_OUTGOING)) {
01741       ast_channel_unlock(chan);
01742       return 0;
01743    }
01744 
01745    /* Stop if we're a zombie or need a soft hangup */
01746    if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
01747       ast_channel_unlock(chan);
01748       return -1;
01749    }
01750 
01751    ast_channel_unlock(chan);
01752 
01753    switch (chan->_state) {
01754    case AST_STATE_RINGING:
01755    case AST_STATE_RING:
01756       ast_channel_lock(chan);
01757       if (chan->tech->answer) {
01758          res = chan->tech->answer(chan);
01759       }
01760       ast_setstate(chan, AST_STATE_UP);
01761       if (cdr_answer) {
01762          ast_cdr_answer(chan->cdr);
01763       }
01764       ast_channel_unlock(chan);
01765       break;
01766    case AST_STATE_UP:
01767       /* Calling ast_cdr_answer when it it has previously been called
01768        * is essentially a no-op, so it is safe.
01769        */
01770       if (cdr_answer) {
01771          ast_cdr_answer(chan->cdr);
01772       }
01773       break;
01774    default:
01775       break;
01776    }
01777 
01778    ast_indicate(chan, -1);
01779    chan->visible_indication = 0;
01780 
01781    return res;
01782 }

struct ast_frame* ast_read ( struct ast_channel * chan ) [read]

Reads a frame.

Parameters:

chan

channel to read a frame from

Returns:: 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 3015 of file channel.c.

References __ast_read().

Referenced by __adsi_transmit_messages(), __ast_answer(), __ast_play_and_record(), __ast_request_and_dial(), adsi_careful_send(), agent_ack_sleep(), agent_read(), ast_feature_request_and_dial(), ast_generic_bridge(), ast_recvtext(), ast_safe_sleep_conditional(), ast_tonepair(), ast_udptl_bridge(), ast_waitfordigit_full(), async_wait(), autoservice_run(), background_detect_exec(), bridge_native_loop(), bridge_p2p_loop(), builtin_atxfer(), channel_spy(), check_goto_on_transfer(), conf_exec(), conf_flush(), conf_run(), dahdi_bridge(), dictate_exec(), disa_exec(), do_idle_thread(), do_waiting(), echo_exec(), eivr_comm(), find_cache(), handle_invite_replaces(), handle_recordfile(), handle_speechrecognize(), iax2_bridge(), iax_park_thread(), ices_exec(), isAnsweringMachine(), jack_exec(), launch_asyncagi(), manage_parkinglot(), masq_park_call(), measurenoise(), misdn_bridge(), monitor_dial(), mp3_exec(), NBScat_exec(), receive_dtmf_digits(), record_exec(), recordthread(), rpt(), rpt_exec(), run_agi(), send_tone_burst(), send_waveform_to_channel(), sendurl_exec(), speech_background(), ss_thread(), transmit_audio(), transmit_t38(), wait_for_answer(), wait_for_hangup(), wait_for_winner(), waitforring_exec(), and waitstream_core().

03016 {
03017    return __ast_read(chan, 0);
03018 }

struct ast_frame* ast_read_noaudio ( struct ast_channel * chan ) [read]

Reads a frame, returning AST_FRAME_NULL frame if audio.

Parameters:

chan

channel to read a frame from

Returns:: Returns a frame, or NULL on error. If it returns NULL, you best just stop reading frames and assume the channel has been disconnected.

Note:: Audio is replaced with AST_FRAME_NULL to avoid transcode when the resulting audio is not necessary.

Definition at line 3020 of file channel.c.

References __ast_read().

Referenced by conf_run().

03021 {
03022    return __ast_read(chan, 1);
03023 }

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

References ast_readstring_full().

Referenced by __adsi_transmit_messages(), _ast_adsi_begin_download(), _ast_adsi_get_cpeinfo(), _ast_adsi_load_session(), ast_app_getdata(), dialout(), do_directory(), forward_message(), privacy_exec(), vm_authenticate(), vm_newuser(), and vm_options().

03966 {
03967    return ast_readstring_full(c, s, len, timeout, ftimeout, enders, -1, -1);
03968 }

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

References ast_check_hangup(), AST_DIGIT_ANY, AST_FLAG_ZOMBIE, AST_GETDATA_COMPLETE, AST_GETDATA_EMPTY_END_TERMINATED, AST_GETDATA_FAILED, AST_GETDATA_INTERRUPTED, AST_GETDATA_TIMEOUT, ast_stopstream(), ast_test_flag, ast_waitfordigit_full(), ast_waitstream_full(), and ast_channel::stream.

Referenced by ast_app_getdata_full(), and ast_readstring().

03971 {
03972    int pos = 0;   /* index in the buffer where we accumulate digits */
03973    int to = ftimeout;
03974 
03975    /* Stop if we're a zombie or need a soft hangup */
03976    if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
03977       return -1;
03978    if (!len)
03979       return -1;
03980    for (;;) {
03981       int d;
03982       if (c->stream) {
03983          d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd);
03984          ast_stopstream(c);
03985          usleep(1000);
03986          if (!d)
03987             d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
03988       } else {
03989          d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
03990       }
03991       if (d < 0)
03992          return AST_GETDATA_FAILED;
03993       if (d == 0) {
03994          s[pos] = '\0';
03995          return AST_GETDATA_TIMEOUT;
03996       }
03997       if (d == 1) {
03998          s[pos] = '\0';
03999          return AST_GETDATA_INTERRUPTED;
04000       }
04001       if (strchr(enders, d) && (pos == 0)) {
04002          s[pos] = '\0';
04003          return AST_GETDATA_EMPTY_END_TERMINATED;
04004       }
04005       if (!strchr(enders, d)) {
04006          s[pos++] = d;
04007       }
04008       if (strchr(enders, d) || (pos >= len)) {
04009          s[pos] = '\0';
04010          return AST_GETDATA_COMPLETE;
04011       }
04012       to = timeout;
04013    }
04014    /* Never reached */
04015    return 0;
04016 }

int ast_recvchar	(	struct ast_channel *	chan,
		int	timeout
	)

Receives a text character from a channel.

Parameters:

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

Definition at line 3178 of file channel.c.

References ast_free, and ast_recvtext().

Referenced by handle_recvchar().

03179 {
03180    int c;
03181    char *buf = ast_recvtext(chan, timeout);
03182    if (buf == NULL)
03183       return -1;  /* error or timeout */
03184    c = *(unsigned char *)buf;
03185    ast_free(buf);
03186    return c;
03187 }

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

Receives a text string from a channel Read a string of text from a channel.

Parameters:

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

Returns:: the received text, or NULL to signify failure.

Definition at line 3189 of file channel.c.

References ast_check_hangup(), AST_CONTROL_HANGUP, AST_FRAME_CONTROL, AST_FRAME_TEXT, ast_frfree, ast_read(), ast_strndup, ast_waitfor(), ast_frame::data, ast_frame::datalen, f, ast_frame::frametype, ast_frame::ptr, and ast_frame::subclass.

Referenced by ast_recvchar(), and handle_recvtext().

03190 {
03191    int res, done = 0;
03192    char *buf = NULL;
03193    
03194    while (!done) {
03195       struct ast_frame *f;
03196       if (ast_check_hangup(chan))
03197          break;
03198       res = ast_waitfor(chan, timeout);
03199       if (res <= 0) /* timeout or error */
03200          break;
03201       timeout = res; /* update timeout */
03202       f = ast_read(chan);
03203       if (f == NULL)
03204          break; /* no frame */
03205       if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
03206          done = 1;   /* force a break */
03207       else if (f->frametype == AST_FRAME_TEXT) {      /* what we want */
03208          buf = ast_strndup((char *) f->data.ptr, f->datalen);  /* dup and break */
03209          done = 1;
03210       }
03211       ast_frfree(f);
03212    }
03213    return buf;
03214 }

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

Requests a channel.

Parameters:

	type	type of channel to request
	format	requested channel format (codec)
	data	data to pass to the channel requester
	status	status

Request a channel of a given type, with data as optional information used by the low level module

Return values:

	NULL	failure
	non-NULL	channel on success

Definition at line 3865 of file channel.c.

References AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, AST_CAUSE_NOSUCHDRIVER, AST_CAUSE_NOTDEFINED, AST_FORMAT_AUDIO_MASK, AST_FORMAT_TEXT_MASK, AST_FORMAT_VIDEO_MASK, AST_LIST_TRAVERSE, ast_log(), AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_translator_best_choice(), ast_channel_tech::capabilities, capabilities, channels, LOG_WARNING, ast_channel_tech::requester, chanlist::tech, and ast_channel_tech::type.

Referenced by __ast_request_and_dial(), agent_request(), ast_call_forward(), ast_feature_request_and_dial(), attempt_reconnect(), begin_dial_channel(), build_conf(), chanavail_exec(), conf_run(), connect_link(), dial_exec_full(), do_forward(), findmeexec(), ring_entry(), rpt(), rpt_call(), rpt_exec(), rpt_tele_thread(), and wait_for_answer().

03866 {
03867    struct chanlist *chan;
03868    struct ast_channel *c;
03869    int capabilities;
03870    int fmt;
03871    int res;
03872    int foo;
03873    int videoformat = format & AST_FORMAT_VIDEO_MASK;
03874    int textformat = format & AST_FORMAT_TEXT_MASK;
03875 
03876    if (!cause)
03877       cause = &foo;
03878    *cause = AST_CAUSE_NOTDEFINED;
03879 
03880    if (AST_RWLIST_RDLOCK(&channels)) {
03881       ast_log(LOG_WARNING, "Unable to lock channel list\n");
03882       return NULL;
03883    }
03884 
03885    AST_LIST_TRAVERSE(&backends, chan, list) {
03886       if (strcasecmp(type, chan->tech->type))
03887          continue;
03888 
03889       capabilities = chan->tech->capabilities;
03890       fmt = format & AST_FORMAT_AUDIO_MASK;
03891       if (fmt) {
03892          /* We have audio - is it possible to connect the various calls to each other? 
03893             (Avoid this check for calls without audio, like text+video calls)
03894          */
03895          res = ast_translator_best_choice(&fmt, &capabilities);
03896          if (res < 0) {
03897             ast_log(LOG_WARNING, "No translator path exists for channel type %s (native 0x%x) to 0x%x\n", type, chan->tech->capabilities, format);
03898             *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
03899             AST_RWLIST_UNLOCK(&channels);
03900             return NULL;
03901          }
03902       }
03903       AST_RWLIST_UNLOCK(&channels);
03904       if (!chan->tech->requester)
03905          return NULL;
03906       
03907       if (!(c = chan->tech->requester(type, capabilities | videoformat | textformat, data, cause)))
03908          return NULL;
03909       
03910       /* no need to generate a Newchannel event here; it is done in the channel_alloc call */
03911       return c;
03912    }
03913 
03914    ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type);
03915    *cause = AST_CAUSE_NOSUCHDRIVER;
03916    AST_RWLIST_UNLOCK(&channels);
03917 
03918    return NULL;
03919 }

struct ast_channel* ast_request_and_dial	(	const char *	type,
		int	format,
		void *	data,
		int	timeout,
		int *	reason,
		const char *	cid_num,
		const char *	cid_name
	)			`[read]`

Request a channel of a given type, with data as optional information used by the low level module and attempt to place a call on it.

Parameters:

	type	type of channel to request
	format	requested channel format
	data	data to pass to the channel requester
	timeout	maximum amount of time to wait for an answer
	reason	why unsuccessful (if unsuccessful)
	cid_num	Caller-ID Number
	cid_name	Caller-ID Name (ascii)

Returns:: Returns an ast_channel on success or no answer, NULL on failure. Check the value of chan->_state to know if the call was answered or not.

Definition at line 3860 of file channel.c.

References __ast_request_and_dial().

Referenced by ast_pbx_outgoing_exten().

03861 {
03862    return __ast_request_and_dial(type, format, data, timeout, outstate, cidnum, cidname, NULL);
03863 }

int ast_safe_sleep	(	struct ast_channel *	chan,
		int	ms
	)

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

Parameters:

	chan	channel to wait for
	ms	length of time in milliseconds to sleep Waits for a specified amount of time, servicing the channel as required.

Returns:: returns -1 on hangup, otherwise 0.

Definition at line 1322 of file channel.c.

References ast_safe_sleep_conditional().

Referenced by _ast_adsi_transmit_message_full(), alarmreceiver_exec(), ast_dtmf_stream(), ast_senddigit(), builtin_atxfer(), builtin_parkcall(), conf_run(), dictate_exec(), disa_exec(), flash_exec(), function_ilink(), handle_callforward_button(), login_exec(), mgcp_ss(), milliwatt_exec(), misdn_check_l2l1(), old_milliwatt_exec(), park_call_exec(), pbx_builtin_wait(), play_moh_exec(), play_tone_pair(), playtone(), privacy_exec(), receive_ademco_contact_id(), rpt_call(), rpt_exec(), rpt_tele_thread(), send_morse(), send_tone_telemetry(), skinny_ss(), ss_thread(), testclient_exec(), testserver_exec(), try_calling(), wait_for_hangup(), wait_interval(), wait_moh_exec(), waituntil_exec(), and zapateller_exec().

01323 {
01324    return ast_safe_sleep_conditional(chan, ms, NULL, NULL);
01325 }

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

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

Parameters:

	chan	channel to wait for
	ms	length of time in milliseconds to sleep
	cond	a function pointer for testing continue condition
	data	argument to be passed to the condition test function

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

Definition at line 1301 of file channel.c.

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

Referenced by ast_safe_sleep(), and login_exec().

01302 {
01303    struct ast_frame *f;
01304 
01305    while (ms > 0) {
01306       if (cond && ((*cond)(data) == 0))
01307          return 0;
01308       ms = ast_waitfor(chan, ms);
01309       if (ms < 0)
01310          return -1;
01311       if (ms > 0) {
01312          f = ast_read(chan);
01313          if (!f)
01314             return -1;
01315          ast_frfree(f);
01316       }
01317    }
01318    return 0;
01319 }

static int ast_select	(	int	nfds,
		fd_set *	rfds,
		fd_set *	wfds,
		fd_set *	efds,
		struct timeval *	tvp
	)			`[inline, static]`

Waits for activity on a group of channels.

Parameters:

	nfds	the maximum number of file descriptors in the sets
	rfds	file descriptors to check for read availability
	wfds	file descriptors to check for write availability
	efds	file descriptors to check for exceptions (OOB data)
	tvp	timeout while waiting for events This is the same as a standard select(), except it guarantees the behaviour where the passed struct timeval is updated with how much time was not slept while waiting for the specified events

Definition at line 1706 of file channel.h.

Referenced by aji_io_recv(), ast_stun_request(), dispatch_thread_handler(), do_monitor(), do_parking_thread(), and hidthread().

01707 {
01708 #ifdef __linux__
01709    return select(nfds, rfds, wfds, efds, tvp);
01710 #else
01711    if (tvp) {
01712       struct timeval tv, tvstart, tvend, tvlen;
01713       int res;
01714 
01715       tv = *tvp;
01716       gettimeofday(&tvstart, NULL);
01717       res = select(nfds, rfds, wfds, efds, tvp);
01718       gettimeofday(&tvend, NULL);
01719       timersub(&tvend, &tvstart, &tvlen);
01720       timersub(&tv, &tvlen, tvp);
01721       if (tvp->tv_sec < 0 || (tvp->tv_sec == 0 && tvp->tv_usec < 0)) {
01722          tvp->tv_sec = 0;
01723          tvp->tv_usec = 0;
01724       }
01725       return res;
01726    }
01727    else
01728       return select(nfds, rfds, wfds, efds, NULL);
01729 #endif
01730 }

int ast_senddigit	(	struct ast_channel *	chan,
		char	digit,
		unsigned int	duration
	)

Send a DTMF digit to a channel Send a DTMF digit to a channel.

Parameters:

	chan	channel to act upon
	digit	the DTMF digit to send, encoded in ASCII
	duration	the duration of the digit ending in ms

Returns:: Returns 0 on success, -1 on failure

Definition at line 3287 of file channel.c.

References AST_DEFAULT_EMULATE_DTMF_DURATION, ast_safe_sleep(), ast_senddigit_begin(), ast_senddigit_end(), ast_channel_tech::send_digit_begin, and ast_channel::tech.

Referenced by ast_dtmf_stream(), dial_exec_full(), do_dtmf_phone(), manager_play_dtmf(), and rpt_call().

03288 {
03289    if (chan->tech->send_digit_begin) {
03290       ast_senddigit_begin(chan, digit);
03291       ast_safe_sleep(chan, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
03292    }
03293    
03294    return ast_senddigit_end(chan, digit, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
03295 }

int ast_senddigit_begin	(	struct ast_channel *	chan,
		char	digit
	)

Send a DTMF digit to a channel Send a DTMF digit to a channel.

Parameters:

	chan	channel to act upon
	digit	the DTMF digit to send, encoded in ASCII

Returns:: Returns 0 on success, -1 on failure

Definition at line 3229 of file channel.c.

References ast_debug, ast_playtones_start(), ast_channel_tech::send_digit_begin, and ast_channel::tech.

Referenced by agent_digit_begin(), ast_senddigit(), and ast_write().

03230 {
03231    /* Device does not support DTMF tones, lets fake
03232     * it by doing our own generation. */
03233    static const char* dtmf_tones[] = {
03234       "941+1336", /* 0 */
03235       "697+1209", /* 1 */
03236       "697+1336", /* 2 */
03237       "697+1477", /* 3 */
03238       "770+1209", /* 4 */
03239       "770+1336", /* 5 */
03240       "770+1477", /* 6 */
03241       "852+1209", /* 7 */
03242       "852+1336", /* 8 */
03243       "852+1477", /* 9 */
03244       "697+1633", /* A */
03245       "770+1633", /* B */
03246       "852+1633", /* C */
03247       "941+1633", /* D */
03248       "941+1209", /* * */
03249       "941+1477"  /* # */
03250    };
03251 
03252    if (!chan->tech->send_digit_begin)
03253       return 0;
03254 
03255    if (!chan->tech->send_digit_begin(chan, digit))
03256       return 0;
03257 
03258    if (digit >= '0' && digit <='9')
03259       ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
03260    else if (digit >= 'A' && digit <= 'D')
03261       ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
03262    else if (digit == '*')
03263       ast_playtones_start(chan, 0, dtmf_tones[14], 0);
03264    else if (digit == '#')
03265       ast_playtones_start(chan, 0, dtmf_tones[15], 0);
03266    else {
03267       /* not handled */
03268       ast_debug(1, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
03269    }
03270 
03271    return 0;
03272 }

int ast_senddigit_end	(	struct ast_channel *	chan,
		char	digit,
		unsigned int	duration
	)

Send a DTMF digit to a channel.

Parameters:

	chan	channel to act upon
	digit	the DTMF digit to send, encoded in ASCII
	duration	the duration of the digit ending in ms

Returns:: Returns 0 on success, -1 on failure

Definition at line 3274 of file channel.c.

References ast_playtones_stop(), ast_channel::generator, ast_channel_tech::send_digit_end, and ast_channel::tech.

Referenced by agent_digit_end(), ast_senddigit(), and ast_write().

03275 {
03276    int res = -1;
03277 
03278    if (chan->tech->send_digit_end)
03279       res = chan->tech->send_digit_end(chan, digit, duration);
03280 
03281    if (res && chan->generator)
03282       ast_playtones_stop(chan);
03283    
03284    return 0;
03285 }

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

Sends text to a channel.

Parameters:

	chan	channel to act upon
	text	string of text to send on the channel

Write text to a display on a channel

Note:: The channel does not need to be locked before calling this function.

Return values:

	0	on success
	-1	on failure

Definition at line 3216 of file channel.c.

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

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

03217 {
03218    int res = 0;
03219    /* Stop if we're a zombie or need a soft hangup */
03220    if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
03221       return -1;
03222    CHECK_BLOCKING(chan);
03223    if (chan->tech->send_text)
03224       res = chan->tech->send_text(chan, text);
03225    ast_clear_flag(chan, AST_FLAG_BLOCKING);
03226    return res;
03227 }

void ast_set_callerid	(	struct ast_channel *	chan,
		const char *	cid_num,
		const char *	cid_name,
		const char *	cid_ani
	)

Set caller ID number, name and ANI.

Note:: The channel does not need to be locked before calling this function.

Definition at line 4547 of file channel.c.

References ast_channel_lock, ast_channel_unlock, ast_free, ast_strdup, ast_channel::cid, ast_callerid::cid_ani, ast_callerid::cid_name, ast_callerid::cid_num, and report_new_callerid().

Referenced by __ast_request_and_dial(), agent_call(), ast_call_forward(), ast_feature_request_and_dial(), callerid_write(), dahdi_read(), dial_exec_full(), disa_exec(), do_forward(), findmeexec(), handle_setcallerid(), mgcp_ss(), privacy_exec(), read_config(), rpt_exec(), skinny_newcall(), and ss_thread().

04548 {
04549    ast_channel_lock(chan);
04550 
04551    if (cid_num) {
04552       if (chan->cid.cid_num)
04553          ast_free(chan->cid.cid_num);
04554       chan->cid.cid_num = ast_strdup(cid_num);
04555    }
04556    if (cid_name) {
04557       if (chan->cid.cid_name)
04558          ast_free(chan->cid.cid_name);
04559       chan->cid.cid_name = ast_strdup(cid_name);
04560    }
04561    if (cid_ani) {
04562       if (chan->cid.cid_ani)
04563          ast_free(chan->cid.cid_ani);
04564       chan->cid.cid_ani = ast_strdup(cid_ani);
04565    }
04566 
04567    report_new_callerid(chan);
04568 
04569    ast_channel_unlock(chan);
04570 }

int ast_set_read_format	(	struct ast_channel *	chan,
		int	format
	)

Sets read format on channel chan Set read format for channel to whichever component of "format" is best.

Parameters:

	chan	channel to change
	format	format to change to

Returns:: Returns 0 on success, -1 on failure

Definition at line 3614 of file channel.c.

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

Referenced by __ast_play_and_record(), __oh323_update_info(), _ast_adsi_transmit_message_full(), agent_call(), alarmreceiver_exec(), ast_channel_make_compatible_helper(), ast_do_masquerade(), attempt_reconnect(), background_detect_exec(), build_conf(), conf_run(), connect_link(), dictate_exec(), do_waiting(), eagi_exec(), echo_exec(), gtalk_rtp_read(), handle_recordfile(), handle_speechrecognize(), ices_exec(), isAnsweringMachine(), jack_exec(), jingle_rtp_read(), login_exec(), measurenoise(), mgcp_rtp_read(), oh323_rtp_read(), old_milliwatt_exec(), process_sdp(), record_exec(), rpt(), rpt_exec(), setup_rtp_connection(), sip_rtp_read(), skinny_rtp_read(), socket_process(), speech_background(), transmit_audio(), and unistim_rtp_read().

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

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

adds a list of channel variables to a channel

Parameters:

	chan	the channel
	vars	a linked list of variables

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

Definition at line 5469 of file channel.c.

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

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

05470 {
05471    struct ast_variable *cur;
05472 
05473    for (cur = vars; cur; cur = cur->next)
05474       pbx_builtin_setvar_helper(chan, cur->name, cur->value);  
05475 }

int ast_set_write_format	(	struct ast_channel *	chan,
		int	format
	)

Sets write format on channel chan Set write format for channel to whichever component of "format" is best.

Parameters:

	chan	channel to change
	format	new format for writing

Returns:: Returns 0 on success, -1 on failure

Definition at line 3620 of file channel.c.

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

Referenced by __oh323_update_info(), _ast_adsi_transmit_message_full(), agent_call(), alarmreceiver_exec(), ast_channel_make_compatible_helper(), ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), ast_do_masquerade(), ast_openstream_full(), ast_stopstream(), attempt_reconnect(), build_conf(), chanspy_exec(), conf_run(), connect_link(), echo_exec(), extenspy_exec(), gtalk_rtp_read(), jack_exec(), jingle_rtp_read(), linear_alloc(), linear_release(), login_exec(), mgcp_rtp_read(), moh_alloc(), moh_files_release(), moh_release(), mp3_exec(), NBScat_exec(), oh323_rtp_read(), old_milliwatt_exec(), playtones_alloc(), playtones_release(), process_sdp(), rpt(), rpt_exec(), send_waveform_to_channel(), setup_rtp_connection(), sip_rtp_read(), skinny_rtp_read(), socket_process(), tonepair_alloc(), tonepair_release(), transmit_audio(), and unistim_rtp_read().

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

int ast_setstate	(	struct ast_channel *	chan,
		enum	ast_channel_state
	)

Change the state of a channel.

Definition at line 4572 of file channel.c.

References ast_channel::_state, AST_CHANNEL_NAME, ast_copy_string(), AST_DEVICE_UNKNOWN, ast_devstate_changed_literal(), ast_state2str(), ast_channel::cid, ast_callerid::cid_name, ast_callerid::cid_num, EVENT_FLAG_CALL, manager_event, name, and S_OR.

Referenced by __ast_read(), __dahdi_exception(), __oh323_update_info(), agent_call(), alsa_answer(), ast_raw_answer(), cb_events(), check_availability(), console_answer(), dahdi_answer(), dahdi_call(), dahdi_handle_event(), dahdi_indicate(), dahdi_read(), do_bridge_masquerade(), gtalk_call(), gtalk_newcall(), handle_invite_replaces(), handle_offhook_message(), handle_request_invite(), handle_response_invite(), handle_soft_key_event_message(), handle_stimulus_message(), iax2_call(), jingle_call(), jingle_newcall(), mgcp_answer(), mgcp_call(), mgcp_ss(), misdn_call(), misdn_indication(), nbs_call(), nbs_hangup(), oh323_answer(), oss_answer(), pbx_builtin_busy(), pbx_builtin_congestion(), phone_answer(), phone_call(), phone_exception(), phone_hangup(), phone_write(), release_chan(), release_chan_early(), sip_answer(), skinny_answer(), skinny_call(), skinny_newcall(), ss_thread(), unistim_answer(), unistim_call(), unistim_new(), unistim_ss(), update_state(), usbradio_answer(), and usbradio_call().

04573 {
04574    int oldstate = chan->_state;
04575    char name[AST_CHANNEL_NAME], *dashptr;
04576 
04577    if (oldstate == state)
04578       return 0;
04579 
04580    ast_copy_string(name, chan->name, sizeof(name));
04581    if ((dashptr = strrchr(name, '-'))) {
04582       *dashptr = '\0';
04583    }
04584 
04585    chan->_state = state;
04586 
04587    /* We have to pass AST_DEVICE_UNKNOWN here because it is entirely possible that the channel driver
04588     * for this channel is using the callback method for device state. If we pass in an actual state here
04589     * we override what they are saying the state is and things go amuck. */
04590    ast_devstate_changed_literal(AST_DEVICE_UNKNOWN, name);
04591 
04592    /* setstate used to conditionally report Newchannel; this is no more */
04593    manager_event(EVENT_FLAG_CALL,
04594             "Newstate",
04595             "Channel: %s\r\n"
04596             "ChannelState: %d\r\n"
04597             "ChannelStateDesc: %s\r\n"
04598             "CallerIDNum: %s\r\n"
04599             "CallerIDName: %s\r\n"
04600             "Uniqueid: %s\r\n",
04601             chan->name, chan->_state, ast_state2str(chan->_state),
04602             S_OR(chan->cid.cid_num, ""),
04603             S_OR(chan->cid.cid_name, ""),
04604             chan->uniqueid);
04605 
04606    return 0;
04607 }

int ast_settimeout	(	struct ast_channel *	c,
		unsigned int	rate,
		int()(const void data)	func,
		void *	data
	)

Enable or disable timer ticks for a channel.

Parameters:

rate

number of timer ticks per second

If timers are supported, force a scheduled expiration on the timer fd, at which point we call the callback function / data

Call this function with a rate of 0 to turn off the timer ticks

Version:: 1.6.1 changed samples parameter to rate, accomodates new timing methods

Definition at line 2339 of file channel.c.

References ast_channel_lock, ast_channel_unlock, ast_debug, ast_timer_get_max_rate(), ast_timer_set_rate(), ast_channel::timer, ast_channel::timingdata, ast_channel::timingfd, and ast_channel::timingfunc.

Referenced by ast_activate_generator(), ast_deactivate_generator(), ast_read_generator_actions(), ast_readaudio_callback(), and filestream_destructor().

02340 {
02341    int res;
02342    unsigned int real_rate = rate, max_rate;
02343 
02344    ast_channel_lock(c);
02345 
02346    if (c->timingfd == -1) {
02347       ast_channel_unlock(c);
02348       return -1;
02349    }
02350 
02351    if (!func) {
02352       rate = 0;
02353       data = NULL;
02354    }
02355 
02356    if (rate && rate > (max_rate = ast_timer_get_max_rate(c->timer))) {
02357       real_rate = max_rate;
02358    }
02359 
02360    ast_debug(1, "Scheduling timer at (%u requested / %u actual) timer ticks per second\n", rate, real_rate);
02361 
02362    res = ast_timer_set_rate(c->timer, real_rate);
02363 
02364    c->timingfunc = func;
02365    c->timingdata = data;
02366 
02367    ast_channel_unlock(c);
02368 
02369    return res;
02370 }

int ast_shutting_down ( void )

Returns non-zero if Asterisk is being shut down.

Returns non-zero if Asterisk is being shut down

Definition at line 515 of file channel.c.

Referenced by handle_request_options().

00516 {
00517    return shutting_down;
00518 }

int ast_softhangup	(	struct ast_channel *	chan,
		int	cause
	)

Softly hangup up a channel.

Parameters:

	chan	channel to be soft-hung-up
	cause	Ast hangupcause for hangup

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.

Note:: The channel passed to this function does not need to be locked.

Returns:: Returns 0 regardless

Definition at line 1610 of file channel.c.

References ast_channel_lock, ast_channel_unlock, and ast_softhangup_nolock().

Referenced by __ast_module_user_hangup_all(), __ast_pbx_run(), __unload_module(), action_hangup(), agent_hangup(), agent_logoff(), ast_begin_shutdown(), ast_dial_join(), birdbath(), conf_free(), connect_link(), dahdi_handle_event(), flush_telem(), function_ilink(), handle_hangup(), handle_link_data(), handle_softhangup(), login_exec(), manager_park(), read_agent_config(), rpt(), rpt_call(), rpt_do_restart(), rpt_exec(), sla_handle_hold_event(), softhangup_exec(), start_spying(), startmon(), and unload_module().

01611 {
01612    int res;
01613 
01614    ast_channel_lock(chan);
01615    res = ast_softhangup_nolock(chan, cause);
01616    ast_channel_unlock(chan);
01617 
01618    return res;
01619 }

int ast_softhangup_nolock	(	struct ast_channel *	chan,
		int	cause
	)

Softly hangup up a channel (no channel lock).

Parameters:

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

Definition at line 1597 of file channel.c.

References ast_channel::_softhangup, ast_debug, AST_FLAG_BLOCKING, ast_null_frame, ast_queue_frame(), ast_test_flag, and ast_channel::blocker.

Referenced by ast_async_goto(), ast_softhangup(), attempt_transfer(), check_rtp_timeout(), dahdi_softhangup_all(), oh323_indicate(), proc_session_timer(), sip_indicate(), and skinny_indicate().

01598 {
01599    ast_debug(1, "Soft-Hanging up channel '%s'\n", chan->name);
01600    /* Inform channel driver that we need to be hung up, if it cares */
01601    chan->_softhangup |= cause;
01602    ast_queue_frame(chan, &ast_null_frame);
01603    /* Interrupt any poll call or such */
01604    if (ast_test_flag(chan, AST_FLAG_BLOCKING))
01605       pthread_kill(chan->blocker, SIGURG);
01606    return 0;
01607 }

const char* ast_state2str ( enum ast_channel_state state )

Gives the string form of a given channel state.

Gives the string form of a given channel state

Parameters:

ast_channel_state

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

Note:: This function is not reentrant.

Definition at line 656 of file channel.c.

References AST_STATE_BUSY, AST_STATE_DIALING, AST_STATE_DIALING_OFFHOOK, AST_STATE_DOWN, AST_STATE_OFFHOOK, AST_STATE_PRERING, AST_STATE_RESERVED, AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, ast_threadstorage_get(), and STATE2STR_BUFSIZE.

Referenced by __ast_channel_alloc_ap(), action_coreshowchannels(), action_status(), agent_hangup(), ast_do_masquerade(), ast_setstate(), attempt_transfer(), func_channel_read(), handle_chanlist(), handle_invite_replaces(), handle_showchan(), local_attended_transfer(), mgcp_new(), serialize_showchan(), and sip_hangup().

00657 {
00658    char *buf;
00659 
00660    switch (state) {
00661    case AST_STATE_DOWN:
00662       return "Down";
00663    case AST_STATE_RESERVED:
00664       return "Rsrvd";
00665    case AST_STATE_OFFHOOK:
00666       return "OffHook";
00667    case AST_STATE_DIALING:
00668       return "Dialing";
00669    case AST_STATE_RING:
00670       return "Ring";
00671    case AST_STATE_RINGING:
00672       return "Ringing";
00673    case AST_STATE_UP:
00674       return "Up";
00675    case AST_STATE_BUSY:
00676       return "Busy";
00677    case AST_STATE_DIALING_OFFHOOK:
00678       return "Dialing Offhook";
00679    case AST_STATE_PRERING:
00680       return "Pre-ring";
00681    default:
00682       if (!(buf = ast_threadstorage_get(&state2str_threadbuf, STATE2STR_BUFSIZE)))
00683          return "Unknown";
00684       snprintf(buf, STATE2STR_BUFSIZE, "Unknown (%d)", state);
00685       return buf;
00686    }
00687 }

int ast_str2cause ( const char * name )

Convert a symbolic hangup cause to number.

Convert the string form of a cause code to a number

Parameters:

name

string form of the cause Returns the cause code

Definition at line 642 of file channel.c.

References ARRAY_LEN, and causes.

Referenced by pbx_builtin_hangup().

00643 {
00644    int x;
00645 
00646    for (x = 0; x < ARRAY_LEN(causes); x++)
00647       if (!strncasecmp(causes[x].name, name, strlen(causes[x].name)))
00648          return causes[x].cause;
00649 
00650    return -1;
00651 }

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

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

Referenced by zapateller_exec().

05345 {
05346    int res;
05347 
05348    if ((res = ast_tonepair_start(chan, freq1, freq2, duration, vol)))
05349       return res;
05350 
05351    /* Give us some wiggle room */
05352    while (chan->generatordata && ast_waitfor(chan, 100) >= 0) {
05353       struct ast_frame *f = ast_read(chan);
05354       if (f)
05355          ast_frfree(f);
05356       else
05357          return -1;
05358    }
05359    return 0;
05360 }

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

Start a tone going

Definition at line 5326 of file channel.c.

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

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

05327 {
05328    struct tonepair_def d = { 0, };
05329 
05330    d.freq1 = freq1;
05331    d.freq2 = freq2;
05332    d.duration = duration;
05333    d.vol = (vol < 1) ? 8192 : vol; /* force invalid to 8192 */
05334    if (ast_activate_generator(chan, &tonepair, &d))
05335       return -1;
05336    return 0;
05337 }

void ast_tonepair_stop ( struct ast_channel * chan )

Stop a tone from playing

Definition at line 5339 of file channel.c.

References ast_deactivate_generator().

Referenced by sendnoise().

05340 {
05341    ast_deactivate_generator(chan);
05342 }

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

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

Parameters:

	chan	current channel
	dest	destination extension for transfer

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

Called by:

app_transfer
the manager interface

Definition at line 3947 of file channel.c.

References ast_channel_lock, ast_channel_unlock, ast_check_hangup(), AST_FLAG_ZOMBIE, ast_test_flag, ast_channel::tech, and ast_channel_tech::transfer.

Referenced by transfer_exec().

03948 {
03949    int res = -1;
03950 
03951    /* Stop if we're a zombie or need a soft hangup */
03952    ast_channel_lock(chan);
03953    if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
03954       if (chan->tech->transfer) {
03955          res = chan->tech->transfer(chan, dest);
03956          if (!res)
03957             res = 1;
03958       } else
03959          res = 0;
03960    }
03961    ast_channel_unlock(chan);
03962    return res;
03963 }

char* ast_transfercapability2str ( int transfercapability ) const

Gives the string form of a given transfer capability.

Gives the string form of a given transfer capability

Parameters:

transfercapability

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

Definition at line 690 of file channel.c.

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

Referenced by cb_events(), dahdi_call(), dahdi_new(), misdn_call(), and oh323_call().

00691 {
00692    switch (transfercapability) {
00693    case AST_TRANS_CAP_SPEECH:
00694       return "SPEECH";
00695    case AST_TRANS_CAP_DIGITAL:
00696       return "DIGITAL";
00697    case AST_TRANS_CAP_RESTRICTED_DIGITAL:
00698       return "RESTRICTED_DIGITAL";
00699    case AST_TRANS_CAP_3_1K_AUDIO:
00700       return "3K1AUDIO";
00701    case AST_TRANS_CAP_DIGITAL_W_TONES:
00702       return "DIGITAL_W_TONES";
00703    case AST_TRANS_CAP_VIDEO:
00704       return "VIDEO";
00705    default:
00706       return "UNKNOWN";
00707    }
00708 }

int ast_waitfor	(	struct ast_channel *	chan,
		int	ms
	)

Wait for input on a channel.

Parameters:

	chan	channel to wait on
	ms	length of time to wait on the channel Wait for input on a channel for a given # of milliseconds (<0 for indefinite).

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

Definition at line 2323 of file channel.c.

References ast_waitfor_nandfds().

Referenced by __adsi_transmit_messages(), __ast_answer(), __ast_play_and_record(), __ast_request_and_dial(), adsi_careful_send(), agent_ack_sleep(), ast_dtmf_stream(), ast_recvtext(), ast_safe_sleep_conditional(), ast_tonepair(), async_wait(), background_detect_exec(), channel_spy(), conf_exec(), conf_flush(), dictate_exec(), disa_exec(), do_idle_thread(), do_waiting(), echo_exec(), handle_recordfile(), handle_speechrecognize(), ices_exec(), isAnsweringMachine(), jack_exec(), launch_asyncagi(), measurenoise(), mp3_exec(), NBScat_exec(), receive_dtmf_digits(), record_exec(), recordthread(), send_tone_burst(), send_waveform_to_channel(), sendurl_exec(), speech_background(), ss_thread(), transmit_audio(), transmit_t38(), wait_for_hangup(), waitforring_exec(), and waitstream_core().

02324 {
02325    int oldms = ms;   /* -1 if no timeout */
02326 
02327    ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
02328    if ((ms < 0) && (oldms < 0))
02329       ms = 0;
02330    return ms;
02331 }

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.

Returns:: Return channel with activity, or NULL if none has activity.

Parameters:

	chan	an array of pointers to channels
	n	number of channels that are to be waited upon
	ms	time "ms" is modified in-place, if applicable

Definition at line 2318 of file channel.c.

References ast_waitfor_nandfds().

Referenced by ast_feature_request_and_dial(), ast_generic_bridge(), ast_udptl_bridge(), autoservice_run(), bridge_native_loop(), bridge_p2p_loop(), dahdi_bridge(), iax2_bridge(), misdn_bridge(), monitor_dial(), rpt(), rpt_exec(), wait_for_answer(), and wait_for_winner().

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

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

References ast_waitfor_nandfds().

Referenced by dundi_lookup_internal(), and dundi_precache_internal().

01964 {
01965    int winner = -1;
01966    ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
01967    return winner;
01968 }

struct ast_channel* ast_waitfor_nandfds	(	struct ast_channel **	c,
		int	n,
		int *	fds,
		int	nfds,
		int *	exception,
		int *	outfd,
		int *	ms
	)			`[read]`

Waits for activity on a group of channels.

Parameters:

	chan	an array of pointers to channels
	n	number of channels that are to be waited upon
	fds	an array of fds to wait upon
	nfds	the number of fds to wait upon
	exception	exception flag
	outfd	fd that had activity on it
	ms	how long the wait was Big momma function here. Wait for activity on any of the n channels, or any of the nfds file descriptors.

Returns:: Returns the channel with activity, or NULL on error or if an FD came first. If the FD came first, it will be returned in outfd, otherwise, outfd will be -1

Definition at line 1975 of file channel.c.

References ast_channel::_softhangup, ast_add_fd(), ast_channel_lock, ast_channel_unlock, ast_clear_flag, ast_do_masquerade(), AST_FLAG_BLOCKING, AST_FLAG_EXCEPTION, ast_log(), AST_MAX_FDS, ast_poll, ast_set_flag, AST_SOFTHANGUP_TIMEOUT, ast_tvcmp(), ast_tvdiff_ms(), ast_tvnow(), ast_tvsub(), ast_tvzero(), CHECK_BLOCKING, errno, ast_channel::fdno, and LOG_WARNING.

Referenced by ast_waitfor(), ast_waitfor_n(), ast_waitfor_n_fd(), ast_waitfordigit_full(), conf_run(), eivr_comm(), find_cache(), run_agi(), and waitstream_core().

01978 {
01979    struct timeval start = { 0 , 0 };
01980    struct pollfd *pfds = NULL;
01981    int res;
01982    long rms;
01983    int x, y, max;
01984    int sz;
01985    struct timeval now = { 0, 0 };
01986    struct timeval whentohangup = { 0, 0 }, diff;
01987    struct ast_channel *winner = NULL;
01988    struct fdmap {
01989       int chan;
01990       int fdno;
01991    } *fdmap = NULL;
01992 
01993    if ((sz = n * AST_MAX_FDS + nfds)) {
01994       pfds = alloca(sizeof(*pfds) * sz);
01995       fdmap = alloca(sizeof(*fdmap) * sz);
01996    }
01997 
01998    if (outfd)
01999       *outfd = -99999;
02000    if (exception)
02001       *exception = 0;
02002    
02003    /* Perform any pending masquerades */
02004    for (x = 0; x < n; x++) {
02005       ast_channel_lock(c[x]);
02006       if (c[x]->masq && ast_do_masquerade(c[x])) {
02007          ast_log(LOG_WARNING, "Masquerade failed\n");
02008          *ms = -1;
02009          ast_channel_unlock(c[x]);
02010          return NULL;
02011       }
02012       if (!ast_tvzero(c[x]->whentohangup)) {
02013          if (ast_tvzero(whentohangup))
02014             now = ast_tvnow();
02015          diff = ast_tvsub(c[x]->whentohangup, now);
02016          if (diff.tv_sec < 0 || ast_tvzero(diff)) {
02017             /* Should already be hungup */
02018             c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
02019             ast_channel_unlock(c[x]);
02020             return c[x];
02021          }
02022          if (ast_tvzero(whentohangup) || ast_tvcmp(diff, whentohangup) < 0)
02023             whentohangup = diff;
02024       }
02025       ast_channel_unlock(c[x]);
02026    }
02027    /* Wait full interval */
02028    rms = *ms;
02029    if (!ast_tvzero(whentohangup)) {
02030       rms = whentohangup.tv_sec * 1000 + whentohangup.tv_usec / 1000;              /* timeout in milliseconds */
02031       if (*ms >= 0 && *ms < rms)    /* original *ms still smaller */
02032          rms =  *ms;
02033    }
02034    /*
02035     * Build the pollfd array, putting the channels' fds first,
02036     * followed by individual fds. Order is important because
02037     * individual fd's must have priority over channel fds.
02038     */
02039    max = 0;
02040    for (x = 0; x < n; x++) {
02041       for (y = 0; y < AST_MAX_FDS; y++) {
02042          fdmap[max].fdno = y;  /* fd y is linked to this pfds */
02043          fdmap[max].chan = x;  /* channel x is linked to this pfds */
02044          max += ast_add_fd(&pfds[max], c[x]->fds[y]);
02045       }
02046       CHECK_BLOCKING(c[x]);
02047    }
02048    /* Add the individual fds */
02049    for (x = 0; x < nfds; x++) {
02050       fdmap[max].chan = -1;
02051       max += ast_add_fd(&pfds[max], fds[x]);
02052    }
02053 
02054    if (*ms > 0)
02055       start = ast_tvnow();
02056    
02057    if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */
02058       do {
02059          int kbrms = rms;
02060          if (kbrms > 600000)
02061             kbrms = 600000;
02062          res = ast_poll(pfds, max, kbrms);
02063          if (!res)
02064             rms -= kbrms;
02065       } while (!res && (rms > 0));
02066    } else {
02067       res = ast_poll(pfds, max, rms);
02068    }
02069    for (x = 0; x < n; x++)
02070       ast_clear_flag(c[x], AST_FLAG_BLOCKING);
02071    if (res < 0) { /* Simulate a timeout if we were interrupted */
02072       if (errno != EINTR)
02073          *ms = -1;
02074       return NULL;
02075    }
02076    if (!ast_tvzero(whentohangup)) {   /* if we have a timeout, check who expired */
02077       now = ast_tvnow();
02078       for (x = 0; x < n; x++) {
02079          if (!ast_tvzero(c[x]->whentohangup) && ast_tvcmp(c[x]->whentohangup, now) <= 0) {
02080             c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT;
02081             if (winner == NULL)
02082                winner = c[x];
02083          }
02084       }
02085    }
02086    if (res == 0) { /* no fd ready, reset timeout and done */
02087       *ms = 0; /* XXX use 0 since we may not have an exact timeout. */
02088       return winner;
02089    }
02090    /*
02091     * Then check if any channel or fd has a pending event.
02092     * Remember to check channels first and fds last, as they
02093     * must have priority on setting 'winner'
02094     */
02095    for (x = 0; x < max; x++) {
02096       res = pfds[x].revents;
02097       if (res == 0)
02098          continue;
02099       if (fdmap[x].chan >= 0) {  /* this is a channel */
02100          winner = c[fdmap[x].chan]; /* override previous winners */
02101          if (res & POLLPRI)
02102             ast_set_flag(winner, AST_FLAG_EXCEPTION);
02103          else
02104             ast_clear_flag(winner, AST_FLAG_EXCEPTION);
02105          winner->fdno = fdmap[x].fdno;
02106       } else {       /* this is an fd */
02107          if (outfd)
02108             *outfd = pfds[x].fd;
02109          if (exception)
02110             *exception = (res & POLLPRI) ? -1 : 0;
02111          winner = NULL;
02112       }
02113    }
02114    if (*ms > 0) {
02115       *ms -= ast_tvdiff_ms(ast_tvnow(), start);
02116       if (*ms < 0)
02117          *ms = 0;
02118    }
02119    return winner;
02120 }

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

Returns:: Returns <0 on error, 0 on no entry, and the digit on success.

Definition at line 2334 of file channel.c.

References ast_waitfordigit_full().

Referenced by _ast_adsi_get_cpeid(), _ast_adsi_get_cpeinfo(), _ast_adsi_print(), _ast_adsi_read_encoded_dtmf(), _ast_adsi_transmit_message_full(), _while_exec(), advanced_options(), ast_app_dtget(), ast_control_streamfile(), ast_record_review(), builtin_atxfer(), collect_digits(), common_exec(), cpeid_exec(), dialout(), directory_exec(), forward_message(), get_folder(), ivr_dispatch(), mgcp_ss(), my_getsigstr(), pbx_builtin_waitexten(), play_record_review(), read_exec(), read_newoption(), readexten_exec(), retrydial_exec(), select_item_menu(), select_item_seq(), sendnoise(), ss_thread(), testclient_exec(), testserver_exec(), vm_execmain(), vm_forwardoptions(), vm_instructions_en(), vm_options(), vm_tempgreeting(), wait_a_bit(), and wait_our_turn().

02335 {
02336    return ast_waitfordigit_full(c, ms, -1, -1);
02337 }

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

Wait for a digit Same as ast_waitfordigit() with audio fd for outputting read audio and ctrlfd to monitor for reading.

Parameters:

	c	channel to wait for a digit on
	ms	how many milliseconds to wait
	audiofd	audio file descriptor to write to if audio frames are received
	ctrlfd	control file descriptor to monitor for reading

Returns:: Returns 1 if ctrlfd becomes available

Definition at line 2372 of file channel.c.

References ast_check_hangup(), ast_clear_flag, AST_CONTROL_ANSWER, AST_CONTROL_HANGUP, AST_CONTROL_RINGING, AST_CONTROL_SRCUPDATE, AST_FLAG_END_DTMF_ONLY, AST_FLAG_ZOMBIE, AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_VOICE, ast_frfree, ast_log(), ast_read(), ast_set_flag, ast_test_flag, ast_waitfor_nandfds(), ast_frame::data, ast_frame::datalen, errno, f, ast_frame::frametype, LOG_WARNING, ast_frame::ptr, and ast_frame::subclass.

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

02373 {
02374    /* Stop if we're a zombie or need a soft hangup */
02375    if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
02376       return -1;
02377 
02378    /* Only look for the end of DTMF, don't bother with the beginning and don't emulate things */
02379    ast_set_flag(c, AST_FLAG_END_DTMF_ONLY);
02380 
02381    /* Wait for a digit, no more than ms milliseconds total. */
02382    
02383    while (ms) {
02384       struct ast_channel *rchan;
02385       int outfd=-1;
02386 
02387       errno = 0;
02388       rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
02389       
02390       if (!rchan && outfd < 0 && ms) {
02391          if (errno == 0 || errno == EINTR)
02392             continue;
02393          ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
02394          ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
02395          return -1;
02396       } else if (outfd > -1) {
02397          /* The FD we were watching has something waiting */
02398          ast_log(LOG_WARNING, "The FD we were waiting for has something waiting. Waitfordigit returning numeric 1\n");
02399          ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
02400          return 1;
02401       } else if (rchan) {
02402          int res;
02403          struct ast_frame *f = ast_read(c);
02404          if (!f)
02405             return -1;
02406 
02407          switch (f->frametype) {
02408          case AST_FRAME_DTMF_BEGIN:
02409             break;
02410          case AST_FRAME_DTMF_END:
02411             res = f->subclass;
02412             ast_frfree(f);
02413             ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
02414             return res;
02415          case AST_FRAME_CONTROL:
02416             switch (f->subclass) {
02417             case AST_CONTROL_HANGUP:
02418                ast_frfree(f);
02419                ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
02420                return -1;
02421             case AST_CONTROL_RINGING:
02422             case AST_CONTROL_ANSWER:
02423             case AST_CONTROL_SRCUPDATE:
02424                /* Unimportant */
02425                break;
02426             default:
02427                ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass);
02428                break;
02429             }
02430             break;
02431          case AST_FRAME_VOICE:
02432             /* Write audio if appropriate */
02433             if (audiofd > -1) {
02434                if (write(audiofd, f->data.ptr, f->datalen) < 0) {
02435                   ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
02436                }
02437             }
02438          default:
02439             /* Ignore */
02440             break;
02441          }
02442          ast_frfree(f);
02443       }
02444    }
02445 
02446    ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
02447 
02448    return 0; /* Time is up */
02449 }

struct ast_channel* ast_walk_channel_by_exten_locked	(	const struct ast_channel *	chan,
		const char *	exten,
		const char *	context
	)			`[read]`

Get next channel by exten (and optionally context) and lock it.

Definition at line 1294 of file channel.c.

References channel_find_locked().

Referenced by next_channel().

01296 {
01297    return channel_find_locked(chan, NULL, 0, context, exten);
01298 }

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

Get channel by name or uniqueid prefix (locks channel).

Definition at line 1281 of file channel.c.

References channel_find_locked().

Referenced by my_ast_get_channel_by_name_locked(), next_channel(), and softhangup_exec().

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

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

Write a frame to a channel This function writes the given frame to the indicated channel.

Parameters:

	chan	destination channel of the frame
	frame	frame that will be written

Returns:: It returns 0 on success, -1 on failure.

Todo:: XXX should return 0 maybe ?

Definition at line 3325 of file channel.c.

References ast_channel::_softhangup, AST_AUDIOHOOK_DIRECTION_WRITE, ast_audiohook_write_list(), ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_check_hangup(), ast_clear_flag, AST_CONTROL_UNHOLD, ast_deactivate_generator(), ast_debug, ast_do_masquerade(), AST_FLAG_BLOCKING, AST_FLAG_WRITE_INT, AST_FLAG_ZOMBIE, AST_FORMAT_T140, AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, ast_frame_dump(), AST_FRAME_HTML, AST_FRAME_IAX, AST_FRAME_MODEM, AST_FRAME_NULL, AST_FRAME_TEXT, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree, AST_LIST_NEXT, ast_log(), AST_MONITOR_RUNNING, ast_seekstream(), ast_senddigit_begin(), ast_senddigit_end(), AST_SOFTHANGUP_DEV, ast_test_flag, ast_translate(), ast_writestream(), ast_channel::audiohooks, CHECK_BLOCKING, ast_frame::data, ast_frame::datalen, DEBUGCHAN_FLAG, f, ast_channel::fout, FRAMECOUNT_INC, ast_frame::frametype, ast_channel::generatordata, ast_channel_tech::indicate, ast_channel::insmpl, ast_frame::len, LOG_WARNING, ast_channel::masq, ast_channel::masqr, ast_channel::monitor, chanlist::next, ast_channel::outsmpl, ast_frame::ptr, ast_channel::rawwriteformat, ast_frame::samples, SEEK_FORCECUR, send_dtmf_event(), ast_channel_tech::send_html, ast_channel_tech::send_text, ast_channel_monitor::state, ast_frame::subclass, ast_channel::tech, ast_channel_tech::write, ast_channel_monitor::write_stream, ast_channel_tech::write_text, ast_channel_tech::write_video, and ast_channel::writetrans.

Referenced by adsi_careful_send(), agent_write(), ast_generic_bridge(), ast_prod(), ast_readaudio_callback(), ast_readvideo_callback(), ast_udptl_bridge(), ast_write_video(), bridge_native_loop(), bridge_p2p_loop(), conf_queue_dtmf(), conf_run(), dahdi_bridge(), dictate_exec(), echo_exec(), fax_generator_generate(), function_ilink(), gen_generate(), handle_jack_audio(), handle_link_data(), iax2_bridge(), jb_get_and_deliver(), linear_generator(), milliwatt_generate(), misdn_bridge(), moh_files_generator(), moh_generate(), mp3_exec(), NBScat_exec(), playtones_generator(), rpt(), rpt_exec(), send_link_dtmf(), send_link_keyquery(), send_tone_burst(), send_usb_txt(), send_waveform_to_channel(), silence_generator_generate(), sms_generate(), spy_generate(), t38_tx_packet_handler(), tonepair_generator(), and wait_for_answer().

03326 {
03327    int res = -1;
03328    struct ast_frame *f = NULL;
03329    int count = 0;
03330 
03331    /*Deadlock avoidance*/
03332    while(ast_channel_trylock(chan)) {
03333       /*cannot goto done since the channel is not locked*/
03334       if(count++ > 10) {
03335          ast_debug(1, "Deadlock avoided for write to channel '%s'\n", chan->name);
03336          return 0;
03337       }
03338       usleep(1);
03339    }
03340    /* Stop if we're a zombie or need a soft hangup */
03341    if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
03342       goto done;
03343 
03344    /* Handle any pending masquerades */
03345    if (chan->masq && ast_do_masquerade(chan)) {
03346       ast_log(LOG_WARNING, "Failed to perform masquerade\n");
03347       goto done;
03348    }
03349    if (chan->masqr) {
03350       res = 0; /* XXX explain, why 0 ? */
03351       goto done;
03352    }
03353    if (chan->generatordata) {
03354       if (ast_test_flag(chan, AST_FLAG_WRITE_INT))
03355          ast_deactivate_generator(chan);
03356       else {
03357          if (fr->frametype == AST_FRAME_DTMF_END) {
03358             /* There is a generator running while we're in the middle of a digit.
03359              * It's probably inband DTMF, so go ahead and pass it so it can
03360              * stop the generator */
03361             ast_clear_flag(chan, AST_FLAG_BLOCKING);
03362             ast_channel_unlock(chan);
03363             res = ast_senddigit_end(chan, fr->subclass, fr->len);
03364             ast_channel_lock(chan);
03365             CHECK_BLOCKING(chan);
03366          } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_UNHOLD) {
03367             /* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
03368             res = (chan->tech->indicate == NULL) ? 0 :
03369                chan->tech->indicate(chan, fr->subclass, fr->data.ptr, fr->datalen);
03370          }
03371          res = 0; /* XXX explain, why 0 ? */
03372          goto done;
03373       }
03374    }
03375    /* High bit prints debugging */
03376    if (chan->fout & DEBUGCHAN_FLAG)
03377       ast_frame_dump(chan->name, fr, ">>");
03378    CHECK_BLOCKING(chan);
03379    switch (fr->frametype) {
03380    case AST_FRAME_CONTROL:
03381       res = (chan->tech->indicate == NULL) ? 0 :
03382          chan->tech->indicate(chan, fr->subclass, fr->data.ptr, fr->datalen);
03383       break;
03384    case AST_FRAME_DTMF_BEGIN:
03385       if (chan->audiohooks) {
03386          struct ast_frame *old_frame = fr;
03387          fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
03388          if (old_frame != fr)
03389             f = fr;
03390       }
03391       send_dtmf_event(chan, "Sent", fr->subclass, "Yes", "No");
03392       ast_clear_flag(chan, AST_FLAG_BLOCKING);
03393       ast_channel_unlock(chan);
03394       res = ast_senddigit_begin(chan, fr->subclass);
03395       ast_channel_lock(chan);
03396       CHECK_BLOCKING(chan);
03397       break;
03398    case AST_FRAME_DTMF_END:
03399       if (chan->audiohooks) {
03400          struct ast_frame *new_frame = fr;
03401 
03402          new_frame = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
03403          if (new_frame != fr) {
03404             ast_frfree(new_frame);
03405          }
03406       }
03407       send_dtmf_event(chan, "Sent", fr->subclass, "No", "Yes");
03408       ast_clear_flag(chan, AST_FLAG_BLOCKING);
03409       ast_channel_unlock(chan);
03410       res = ast_senddigit_end(chan, fr->subclass, fr->len);
03411       ast_channel_lock(chan);
03412       CHECK_BLOCKING(chan);
03413       break;
03414    case AST_FRAME_TEXT:
03415       if (fr->subclass == AST_FORMAT_T140) {
03416          res = (chan->tech->write_text == NULL) ? 0 :
03417             chan->tech->write_text(chan, fr);
03418       } else {
03419          res = (chan->tech->send_text == NULL) ? 0 :
03420             chan->tech->send_text(chan, (char *) fr->data.ptr);
03421       }
03422       break;
03423    case AST_FRAME_HTML:
03424       res = (chan->tech->send_html == NULL) ? 0 :
03425          chan->tech->send_html(chan, fr->subclass, (char *) fr->data.ptr, fr->datalen);
03426       break;
03427    case AST_FRAME_VIDEO:
03428       /* XXX Handle translation of video codecs one day XXX */
03429       res = (chan->tech->write_video == NULL) ? 0 :
03430          chan->tech->write_video(chan, fr);
03431       break;
03432    case AST_FRAME_MODEM:
03433       res = (chan->tech->write == NULL) ? 0 :
03434          chan->tech->write(chan, fr);
03435       break;
03436    case AST_FRAME_VOICE:
03437       if (chan->tech->write == NULL)
03438          break;   /*! \todo XXX should return 0 maybe ? */
03439 
03440       /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
03441       if (fr->subclass == chan->rawwriteformat)
03442          f = fr;
03443       else
03444          f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr;
03445 
03446       if (!f) {
03447          res = 0;
03448          break;
03449       }
03450 
03451       if (chan->audiohooks) {
03452          struct ast_frame *new_frame, *cur;
03453 
03454          for (cur = f; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
03455             new_frame = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, cur);
03456             if (new_frame != cur) {
03457                ast_frfree(new_frame);
03458             }
03459          }
03460       }
03461       
03462       /* If Monitor is running on this channel, then we have to write frames out there too */
03463       /* the translator on chan->writetrans may have returned multiple frames
03464          from the single frame we passed in; if so, feed each one of them to the
03465          monitor */
03466       if (chan->monitor && chan->monitor->write_stream) {
03467          struct ast_frame *cur;
03468 
03469          for (cur = f; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
03470          /* XXX must explain this code */
03471 #ifndef MONITOR_CONSTANT_DELAY
03472             int jump = chan->insmpl - chan->outsmpl - 4 * cur->samples;
03473             if (jump >= 0) {
03474                jump = chan->insmpl - chan->outsmpl;
03475                if (ast_seekstream(chan->monitor->write_stream, jump, SEEK_FORCECUR) == -1)
03476                   ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
03477                chan->outsmpl += jump + cur->samples;
03478             } else {
03479                chan->outsmpl += cur->samples;
03480             }
03481 #else
03482             int jump = chan->insmpl - chan->outsmpl;
03483             if (jump - MONITOR_DELAY >= 0) {
03484                if (ast_seekstream(chan->monitor->write_stream, jump - cur->samples, SEEK_FORCECUR) == -1)
03485                   ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
03486                chan->outsmpl += jump;
03487             } else {
03488                chan->outsmpl += cur->samples;
03489             }
03490 #endif
03491             if (chan->monitor->state == AST_MONITOR_RUNNING) {
03492                if (ast_writestream(chan->monitor->write_stream, cur) < 0)
03493                   ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n");
03494             }
03495          }
03496       }
03497 
03498       /* the translator on chan->writetrans may have returned multiple frames
03499          from the single frame we passed in; if so, feed each one of them to the
03500          channel, freeing each one after it has been written */
03501       if ((f != fr) && AST_LIST_NEXT(f, frame_list)) {
03502          struct ast_frame *cur, *next;
03503          unsigned int skip = 0;
03504 
03505          for (cur = f, next = AST_LIST_NEXT(cur, frame_list);
03506               cur;
03507               cur = next, next = cur ? AST_LIST_NEXT(cur, frame_list) : NULL) {
03508             if (!skip) {
03509                if ((res = chan->tech->write(chan, cur)) < 0) {
03510                   chan->_softhangup |= AST_SOFTHANGUP_DEV;
03511                   skip = 1;
03512                } else if (next) {
03513                   /* don't do this for the last frame in the list,
03514                      as the code outside the loop will do it once
03515                   */
03516                   chan->fout = FRAMECOUNT_INC(chan->fout);
03517                }
03518             }
03519             ast_frfree(cur);
03520          }
03521 
03522          /* reset f so the code below doesn't attempt to free it */
03523          f = NULL;
03524       } else {
03525          res = chan->tech->write(chan, f);
03526       }
03527       break;
03528    case AST_FRAME_NULL:
03529    case AST_FRAME_IAX:
03530       /* Ignore these */
03531       res = 0;
03532       break;
03533    default:
03534       /* At this point, fr is the incoming frame and f is NULL.  Channels do
03535        * not expect to get NULL as a frame pointer and will segfault.  Hence,
03536        * we output the original frame passed in. */
03537       res = chan->tech->write(chan, fr);
03538       break;
03539    }
03540 
03541    if (f && f != fr)
03542       ast_frfree(f);
03543    ast_clear_flag(chan, AST_FLAG_BLOCKING);
03544 
03545    /* Consider a write failure to force a soft hangup */
03546    if (res < 0) {
03547       chan->_softhangup |= AST_SOFTHANGUP_DEV;
03548    } else {
03549       chan->fout = FRAMECOUNT_INC(chan->fout);
03550    }
03551 done:
03552    ast_channel_unlock(chan);
03553    return res;
03554 }

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

Write text frame to a channel This function writes the given frame to the indicated channel.

Parameters:

	chan	destination channel of the frame
	frame	frame that will be written

Returns:: It returns 1 on success, 0 if not implemented, and -1 on failure.

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

Write video frame to a channel This function writes the given frame to the indicated channel.

Parameters:

	chan	destination channel of the frame
	frame	frame that will be written

Returns:: It returns 1 on success, 0 if not implemented, and -1 on failure.

Definition at line 3314 of file channel.c.

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

03315 {
03316    int res;
03317    if (!chan->tech->write_video)
03318       return 0;
03319    res = ast_write(chan, fr);
03320    if (!res)
03321       res = 1;
03322    return res;
03323 }

const char* channelreloadreason2txt ( enum channelreloadreason reason )

Convert enum channelreloadreason to text string for manager event.

Parameters:

reason

Enum channelreloadreason - reason for reload (manager, cli, start etc)

\ brief Convert channel reloadreason (ENUM) to text string for manager event

Definition at line 5557 of file channel.c.

References CHANNEL_CLI_RELOAD, CHANNEL_MODULE_LOAD, and CHANNEL_MODULE_RELOAD.

Referenced by reload_config().

05558 {
05559    switch (reason) {
05560    case CHANNEL_MODULE_LOAD:
05561       return "LOAD (Channel module load)";
05562 
05563    case CHANNEL_MODULE_RELOAD:
05564       return "RELOAD (Channel module reload)";
05565 
05566    case CHANNEL_CLI_RELOAD:
05567       return "CLIRELOAD (Channel module reload by CLI command)";
05568 
05569    default:
05570       return "MANAGERRELOAD (Channel module reload by manager)";
05571    }
05572 };

Variable Documentation

unsigned long global_fin

The current value of the debug flags is stored in the two variables global_fin and global_fout (declared in main/channel.c)

Definition at line 85 of file channel.c.

Referenced by handle_core_set_debug_channel().

unsigned long global_fout

Definition at line 85 of file channel.c.

Referenced by handle_core_set_debug_channel().

Asterisk developer's documentation

channel.h File Reference

Data Structures

Defines

Typedefs

Enumerations

Functions

Variables

Detailed Description

Define Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation