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_FLAG_IN_CHANNEL_LIST = (1 << 19), AST_FLAG_DISABLE_WORKAROUNDS = (1 << 20) }
	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 reason)
	Softly hangup up a channel.
int	ast_softhangup_nolock (struct ast_channel *chan, int reason)
	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 1357 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 1359 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 1365 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 1361 of file channel.h.

#define AST_BRIDGE_REC_CHANNEL_1 (1 << 3)

Return all voice frames on channel 1.

Definition at line 1363 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 729 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 1750 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.
AST_FLAG_IN_CHANNEL_LIST	This flag indicates whether the channel is in the channel list or not.
AST_FLAG_DISABLE_WORKAROUNDS	Disable certain workarounds. This reintroduces certain bugs, but allows some non-traditional dialplans (like AGI) to continue to function.

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    /*! This flag indicates whether the channel is in the channel list or not. */
00566    AST_FLAG_IN_CHANNEL_LIST = (1 << 19),
00567    /*! Disable certain workarounds.  This reintroduces certain bugs, but allows
00568     *  some non-traditional dialplans (like AGI) to continue to function.
00569     */
00570    AST_FLAG_DISABLE_WORKAROUNDS = (1 << 20),
00571 };

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 574 of file channel.h.

00574      {
00575    AST_FEATURE_PLAY_WARNING = (1 << 0),
00576    AST_FEATURE_REDIRECT =     (1 << 1),
00577    AST_FEATURE_DISCONNECT =   (1 << 2),
00578    AST_FEATURE_ATXFER =       (1 << 3),
00579    AST_FEATURE_AUTOMON =      (1 << 4),
00580    AST_FEATURE_PARKCALL =     (1 << 5),
00581    AST_FEATURE_AUTOMIXMON =   (1 << 6),
00582    AST_FEATURE_NO_H_EXTEN =   (1 << 7),
00583    AST_FEATURE_WARNING_ACTIVE = (1 << 8),
00584 };

anonymous enum

Enumerator:

AST_CDR_TRANSFER
AST_CDR_FORWARD
AST_CDR_CALLWAIT
AST_CDR_CONFERENCE

Definition at line 623 of file channel.h.

00623      {
00624    AST_CDR_TRANSFER =   (1 << 0),
00625    AST_CDR_FORWARD =    (1 << 1),
00626    AST_CDR_CALLWAIT =   (1 << 2),
00627    AST_CDR_CONFERENCE = (1 << 3),
00628 };

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 630 of file channel.h.

00630      {
00631    /*! Soft hangup by device */
00632    AST_SOFTHANGUP_DEV =       (1 << 0),
00633    /*! Soft hangup for async goto */
00634    AST_SOFTHANGUP_ASYNCGOTO = (1 << 1),
00635    AST_SOFTHANGUP_SHUTDOWN =  (1 << 2),
00636    AST_SOFTHANGUP_TIMEOUT =   (1 << 3),
00637    AST_SOFTHANGUP_APPUNLOAD = (1 << 4),
00638    AST_SOFTHANGUP_EXPLICIT =  (1 << 5),
00639    AST_SOFTHANGUP_UNBRIDGE =  (1 << 6),
00640 };

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 644 of file channel.h.

00644                          {
00645    CHANNEL_MODULE_LOAD,
00646    CHANNEL_MODULE_RELOAD,
00647    CHANNEL_CLI_RELOAD,
00648    CHANNEL_MANAGER_RELOAD,
00649 };

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 1802 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().

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 01884          } 01885 01886 01887 01888 01889 01890 01891 01892 01893          } 01894 01895 01896 01897 01898    } 01899 01900 01901 }

class="fragment">01803 { 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 966 of file channel.c.

References __ast_channel_alloc_ap().

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

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 3791 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().

03792 {
03793    int dummy_outstate;
03794    int cause = 0;
03795    struct ast_channel *chan;
03796    int res = 0;
03797    int last_subclass = 0;
03798    
03799    if (outstate)
03800       *outstate = 0;
03801    else
03802       outstate = &dummy_outstate;   /* make outstate always a valid pointer */
03803 
03804    chan = ast_request(type, format, data, &cause);
03805    if (!chan) {
03806       ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
03807       handle_cause(cause, outstate);
03808       return NULL;
03809    }
03810 
03811    if (oh) {
03812       if (oh->vars)  
03813          ast_set_variables(chan, oh->vars);
03814       /* XXX why is this necessary, for the parent_channel perhaps ? */
03815       if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name))
03816          ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num);
03817       if (oh->parent_channel) {
03818          ast_channel_inherit_variables(oh->parent_channel, chan);
03819          ast_channel_datastore_inherit(oh->parent_channel, chan);
03820       }
03821       if (oh->account)
03822          ast_cdr_setaccount(chan, oh->account); 
03823    }
03824    ast_set_callerid(chan, cid_num, cid_name, cid_num);
03825    ast_set_flag(chan->cdr, AST_CDR_FLAG_ORIGINATED);
03826 
03827    if (ast_call(chan, data, 0)) {   /* ast_call failed... */
03828       ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
03829    } else {
03830       res = 1; /* mark success in case chan->_state is already AST_STATE_UP */
03831       while (timeout && chan->_state != AST_STATE_UP) {
03832          struct ast_frame *f;
03833          res = ast_waitfor(chan, timeout);
03834          if (res == 0) { /* timeout, treat it like ringing */
03835             *outstate = AST_CONTROL_RINGING;
03836             break;
03837          }
03838          if (res < 0) /* error or done */
03839             break;
03840          if (timeout > -1)
03841             timeout = res;
03842          if (!ast_strlen_zero(chan->call_forward)) {
03843             if (!(chan = ast_call_forward(NULL, chan, &timeout, format, oh, outstate))) {
03844                return NULL;
03845             }
03846             continue;
03847          }
03848 
03849          f = ast_read(chan);
03850          if (!f) {
03851             *outstate = AST_CONTROL_HANGUP;
03852             res = 0;
03853             break;
03854          }
03855          if (f->frametype == AST_FRAME_CONTROL) {
03856             switch (f->subclass) {
03857             case AST_CONTROL_RINGING:  /* record but keep going */
03858                *outstate = f->subclass;
03859                break;
03860 
03861             case AST_CONTROL_BUSY:
03862             case AST_CONTROL_CONGESTION:
03863             case AST_CONTROL_ANSWER:
03864                *outstate = f->subclass;
03865                timeout = 0;      /* trick to force exit from the while() */
03866                break;
03867 
03868             /* Ignore these */
03869             case AST_CONTROL_PROGRESS:
03870             case AST_CONTROL_PROCEEDING:
03871             case AST_CONTROL_HOLD:
03872             case AST_CONTROL_UNHOLD:
03873             case AST_CONTROL_VIDUPDATE:
03874             case AST_CONTROL_SRCUPDATE:
03875             case -1:       /* Ignore -- just stopping indications */
03876                break;
03877 
03878             default:
03879                ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass);
03880             }
03881             last_subclass = f->subclass;
03882          }
03883          ast_frfree(f);
03884       }
03885    }
03886 
03887    /* Final fixups */
03888    if (oh) {
03889       if (!ast_strlen_zero(oh->context))
03890          ast_copy_string(chan->context, oh->context, sizeof(chan->context));
03891       if (!ast_strlen_zero(oh->exten))
03892          ast_copy_string(chan->exten, oh->exten, sizeof(chan->exten));
03893       if (oh->priority) 
03894          chan->priority = oh->priority;
03895    }
03896    if (chan->_state == AST_STATE_UP)
03897       *outstate = AST_CONTROL_ANSWER;
03898 
03899    if (res <= 0) {
03900       if ( AST_CONTROL_RINGING == last_subclass ) 
03901          chan->hangupcause = AST_CAUSE_NO_ANSWER;
03902       if (!chan->cdr && (chan->cdr = ast_cdr_alloc()))
03903          ast_cdr_init(chan->cdr, chan);
03904       if (chan->cdr) {
03905          char tmp[256];
03906          snprintf(tmp, sizeof(tmp), "%s/%s", type, (char *)data);
03907          ast_cdr_setapp(chan->cdr,"Dial",tmp);
03908          ast_cdr_update(chan);
03909          ast_cdr_start(chan->cdr);
03910          ast_cdr_end(chan->cdr);
03911          /* If the cause wasn't handled properly */
03912          if (ast_cdr_disposition(chan->cdr,chan->hangupcause))
03913             ast_cdr_failed(chan->cdr);
03914       }
03915       ast_hangup(chan);
03916       chan = NULL;
03917    }
03918    return chan;
03919 }

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

Activate a given generator

Definition at line 1953 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().

01954 {
01955    int res = 0;
01956 
01957    ast_channel_lock(chan);
01958 
01959    if (chan->generatordata) {
01960       if (chan->generator && chan->generator->release)
01961          chan->generator->release(chan, chan->generatordata);
01962       chan->generatordata = NULL;
01963    }
01964 
01965    ast_prod(chan);
01966    if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) {
01967       res = -1;
01968    }
01969    
01970    if (!res) {
01971       ast_settimeout(chan, 50, generator_force, chan);
01972       chan->generator = gen;
01973    }
01974 
01975    ast_channel_unlock(chan);
01976 
01977    return res;
01978 }

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 1664 of file channel.h.

Referenced by ast_waitfor_nandfds().

01665 {
01666    pfd->fd = fd;
01667    pfd->events = POLLIN | POLLPRI;
01668    return fd >= 0;
01669 }

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 1903 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().

01904 {
01905    return __ast_answer(chan, 0, 1);
01906 }

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 192 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().

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

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 251 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().

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

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 4673 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_set_rtp_peer(), skinny_transfer(), socket_process(), ss_thread(), start_spying(), startmon(), TransferCallStep1(), and unistim_hangup().

04674 {
04675    struct ast_channel *bridged;
04676    bridged = chan->_bridge;
04677    if (bridged && bridged->tech->bridged_channel)
04678       bridged = bridged->tech->bridged_channel(chan, bridged);
04679    return bridged;
04680 }

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

References AST_CDR_FLAG_DIALED, AST_CDR_FLAG_ORIGINATED, 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().

03983 {
03984    /* Place an outgoing call, but don't wait any longer than timeout ms before returning.
03985       If the remote end does not answer within the timeout, then do NOT hang up, but
03986       return anyway.  */
03987    int res = -1;
03988    /* Stop if we're a zombie or need a soft hangup */
03989    ast_channel_lock(chan);
03990    if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
03991       if (chan->cdr) {
03992          ast_set_flag(chan->cdr, AST_CDR_FLAG_DIALED);
03993          ast_set_flag(chan->cdr, AST_CDR_FLAG_ORIGINATED);
03994       }
03995       if (chan->tech->call)
03996          res = chan->tech->call(chan, addr, timeout);
03997       ast_set_flag(chan, AST_FLAG_OUTGOING);
03998    }
03999    ast_channel_unlock(chan);
04000    return res;
04001 }

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 3719 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().

03720 {
03721    char tmpchan[256];
03722    struct ast_channel *new = NULL;
03723    char *data, *type;
03724    int cause = 0;
03725 
03726    /* gather data and request the new forward channel */
03727    ast_copy_string(tmpchan, orig->call_forward, sizeof(tmpchan));
03728    if ((data = strchr(tmpchan, '/'))) {
03729       *data++ = '\0';
03730       type = tmpchan;
03731    } else {
03732       const char *forward_context;
03733       ast_channel_lock(orig);
03734       forward_context = pbx_builtin_getvar_helper(orig, "FORWARD_CONTEXT");
03735       snprintf(tmpchan, sizeof(tmpchan), "%s@%s", orig->call_forward, S_OR(forward_context, orig->context));
03736       ast_channel_unlock(orig);
03737       data = tmpchan;
03738       type = "Local";
03739    }
03740    if (!(new = ast_request(type, format, data, &cause))) {
03741       ast_log(LOG_NOTICE, "Unable to create channel for call forward to '%s/%s' (cause = %d)\n", type, data, cause);
03742       handle_cause(cause, outstate);
03743       ast_hangup(orig);
03744       return NULL;
03745    }
03746 
03747    /* Copy/inherit important information into new channel */
03748    if (oh) {
03749       if (oh->vars) {
03750          ast_set_variables(new, oh->vars);
03751       }
03752       if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name)) {
03753          ast_set_callerid(new, oh->cid_num, oh->cid_name, oh->cid_num);
03754       }
03755       if (oh->parent_channel) {
03756          ast_channel_inherit_variables(oh->parent_channel, new);
03757          ast_channel_datastore_inherit(oh->parent_channel, new);
03758       }
03759       if (oh->account) {
03760          ast_cdr_setaccount(new, oh->account);
03761       }
03762    } else if (caller) { /* no outgoing helper so use caller if avaliable */
03763       ast_channel_inherit_variables(caller, new);
03764       ast_channel_datastore_inherit(caller, new);
03765    }
03766 
03767    ast_channel_lock(orig);
03768    while (ast_channel_trylock(new)) {
03769       CHANNEL_DEADLOCK_AVOIDANCE(orig);
03770    }
03771    ast_copy_flags(new->cdr, orig->cdr, AST_CDR_FLAG_ORIGINATED);
03772    ast_string_field_set(new, accountcode, orig->accountcode);
03773    if (!ast_strlen_zero(orig->cid.cid_num) && !ast_strlen_zero(new->cid.cid_name)) {
03774       ast_set_callerid(new, orig->cid.cid_num, orig->cid.cid_name, orig->cid.cid_num);
03775    }
03776    ast_channel_unlock(new);
03777    ast_channel_unlock(orig);
03778 
03779    /* call new channel */
03780    if ((*timeout = ast_call(new, data, 0))) {
03781       ast_log(LOG_NOTICE, "Unable to call forward to channel %s/%s\n", type, (char *)data);
03782       ast_hangup(orig);
03783       ast_hangup(new);
03784       return NULL;
03785    }
03786    ast_hangup(orig);
03787 
03788    return new;
03789 }

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

References ast_string_field_set, EVENT_FLAG_CALL, manager_event, and name.

Referenced by update_name().

04237 {
04238    manager_event(EVENT_FLAG_CALL, "Rename", "Channel: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", chan->name, newname, chan->uniqueid);
04239    ast_string_field_set(chan, name, newname);
04240 }

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

Referenced by ast_bridge_call().

04997 {
04998    struct ast_channel *who = NULL;
04999    enum ast_bridge_result res = AST_BRIDGE_COMPLETE;
05000    int nativefailed=0;
05001    int firstpass;
05002    int o0nativeformats;
05003    int o1nativeformats;
05004    long time_left_ms=0;
05005    char caller_warning = 0;
05006    char callee_warning = 0;
05007 
05008    if (c0->_bridge) {
05009       ast_log(LOG_WARNING, "%s is already in a bridge with %s\n",
05010          c0->name, c0->_bridge->name);
05011       return -1;
05012    }
05013    if (c1->_bridge) {
05014       ast_log(LOG_WARNING, "%s is already in a bridge with %s\n",
05015          c1->name, c1->_bridge->name);
05016       return -1;
05017    }
05018    
05019    /* Stop if we're a zombie or need a soft hangup */
05020    if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) ||
05021        ast_test_flag(c1, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c1))
05022       return -1;
05023 
05024    *fo = NULL;
05025    firstpass = config->firstpass;
05026    config->firstpass = 0;
05027 
05028    if (ast_tvzero(config->start_time))
05029       config->start_time = ast_tvnow();
05030    time_left_ms = config->timelimit;
05031 
05032    caller_warning = ast_test_flag(&config->features_caller, AST_FEATURE_PLAY_WARNING);
05033    callee_warning = ast_test_flag(&config->features_callee, AST_FEATURE_PLAY_WARNING);
05034 
05035    if (config->start_sound && firstpass) {
05036       if (caller_warning)
05037          bridge_playfile(c0, c1, config->start_sound, time_left_ms / 1000);
05038       if (callee_warning)
05039          bridge_playfile(c1, c0, config->start_sound, time_left_ms / 1000);
05040    }
05041 
05042    /* Keep track of bridge */
05043    c0->_bridge = c1;
05044    c1->_bridge = c0;
05045 
05046 
05047    o0nativeformats = c0->nativeformats;
05048    o1nativeformats = c1->nativeformats;
05049 
05050    if (config->feature_timer && !ast_tvzero(config->nexteventts)) {
05051       config->nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->feature_timer, 1000));
05052    } else if (config->timelimit && firstpass) {
05053       config->nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000));
05054       if (caller_warning || callee_warning)
05055          config->nexteventts = ast_tvsub(config->nexteventts, ast_samp2tv(config->play_warning, 1000));
05056    }
05057 
05058    if (!c0->tech->send_digit_begin)
05059       ast_set_flag(c1, AST_FLAG_END_DTMF_ONLY);
05060    if (!c1->tech->send_digit_begin)
05061       ast_set_flag(c0, AST_FLAG_END_DTMF_ONLY);
05062    manager_bridge_event(1, 1, c0, c1);
05063 
05064    /* Before we enter in and bridge these two together tell them both the source of audio has changed */
05065    ast_indicate(c0, AST_CONTROL_SRCUPDATE);
05066    ast_indicate(c1, AST_CONTROL_SRCUPDATE);
05067 
05068    for (/* ever */;;) {
05069       struct timeval now = { 0, };
05070       int to;
05071 
05072       to = -1;
05073 
05074       if (!ast_tvzero(config->nexteventts)) {
05075          now = ast_tvnow();
05076          to = ast_tvdiff_ms(config->nexteventts, now);
05077          if (to <= 0) {
05078             if (!config->timelimit) {
05079                res = AST_BRIDGE_COMPLETE;
05080                break;
05081             }
05082             to = 0;
05083          }
05084       }
05085 
05086       if (config->timelimit) {
05087          time_left_ms = config->timelimit - ast_tvdiff_ms(now, config->start_time);
05088          if (time_left_ms < to)
05089             to = time_left_ms;
05090 
05091          if (time_left_ms <= 0) {
05092             if (caller_warning && config->end_sound)
05093                bridge_playfile(c0, c1, config->end_sound, 0);
05094             if (callee_warning && config->end_sound)
05095                bridge_playfile(c1, c0, config->end_sound, 0);
05096             *fo = NULL;
05097             if (who)
05098                *rc = who;
05099             res = 0;
05100             break;
05101          }
05102 
05103          if (!to) {
05104             if (time_left_ms >= 5000 && config->warning_sound && config->play_warning && ast_test_flag(config, AST_FEATURE_WARNING_ACTIVE)) {
05105                int t = (time_left_ms + 500) / 1000; /* round to nearest second */
05106                if (caller_warning)
05107                   bridge_playfile(c0, c1, config->warning_sound, t);
05108                if (callee_warning)
05109                   bridge_playfile(c1, c0, config->warning_sound, t);
05110             }
05111             if (config->warning_freq && (time_left_ms > (config->warning_freq + 5000)))
05112                config->nexteventts = ast_tvadd(config->nexteventts, ast_samp2tv(config->warning_freq, 1000));
05113             else
05114                config->nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000));
05115          }
05116          ast_clear_flag(config, AST_FEATURE_WARNING_ACTIVE);
05117       }
05118 
05119       if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE) {
05120          if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
05121             c0->_softhangup = 0;
05122          if (c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
05123             c1->_softhangup = 0;
05124          c0->_bridge = c1;
05125          c1->_bridge = c0;
05126          ast_debug(1, "Unbridge signal received. Ending native bridge.\n");
05127          continue;
05128       }
05129 
05130       /* Stop if we're a zombie or need a soft hangup */
05131       if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) ||
05132           ast_test_flag(c1, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c1)) {
05133          *fo = NULL;
05134          if (who)
05135             *rc = who;
05136          res = 0;
05137          ast_debug(1, "Bridge stops because we're zombie or need a soft hangup: c0=%s, c1=%s, flags: %s,%s,%s,%s\n",
05138             c0->name, c1->name,
05139             ast_test_flag(c0, AST_FLAG_ZOMBIE) ? "Yes" : "No",
05140             ast_check_hangup(c0) ? "Yes" : "No",
05141             ast_test_flag(c1, AST_FLAG_ZOMBIE) ? "Yes" : "No",
05142             ast_check_hangup(c1) ? "Yes" : "No");
05143          break;
05144       }
05145 
05146       update_bridge_vars(c0, c1);
05147 
05148       bridge_play_sounds(c0, c1);
05149 
05150       if (c0->tech->bridge &&
05151           (c0->tech->bridge == c1->tech->bridge) &&
05152           !nativefailed && !c0->monitor && !c1->monitor &&
05153           !c0->audiohooks && !c1->audiohooks && 
05154           !c0->masq && !c0->masqr && !c1->masq && !c1->masqr) {
05155          /* Looks like they share a bridge method and nothing else is in the way */
05156          ast_set_flag(c0, AST_FLAG_NBRIDGE);
05157          ast_set_flag(c1, AST_FLAG_NBRIDGE);
05158          if ((res = c0->tech->bridge(c0, c1, config->flags, fo, rc, to)) == AST_BRIDGE_COMPLETE) {
05159             /* \todo  XXX here should check that cid_num is not NULL */
05160             manager_event(EVENT_FLAG_CALL, "Unlink",
05161                      "Channel1: %s\r\n"
05162                      "Channel2: %s\r\n"
05163                      "Uniqueid1: %s\r\n"
05164                      "Uniqueid2: %s\r\n"
05165                      "CallerID1: %s\r\n"
05166                      "CallerID2: %s\r\n",
05167                      c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
05168             ast_debug(1, "Returning from native bridge, channels: %s, %s\n", c0->name, c1->name);
05169 
05170             ast_clear_flag(c0, AST_FLAG_NBRIDGE);
05171             ast_clear_flag(c1, AST_FLAG_NBRIDGE);
05172 
05173             if (c0->_softhangup == AST_SOFTHANGUP_UNBRIDGE || c1->_softhangup == AST_SOFTHANGUP_UNBRIDGE)
05174                continue;
05175 
05176             c0->_bridge = NULL;
05177             c1->_bridge = NULL;
05178 
05179             return res;
05180          } else {
05181             ast_clear_flag(c0, AST_FLAG_NBRIDGE);
05182             ast_clear_flag(c1, AST_FLAG_NBRIDGE);
05183          }
05184          switch (res) {
05185          case AST_BRIDGE_RETRY:
05186             if (config->play_warning) {
05187                ast_set_flag(config, AST_FEATURE_WARNING_ACTIVE);
05188             }
05189             continue;
05190          default:
05191             ast_verb(3, "Native bridging %s and %s ended\n", c0->name, c1->name);
05192             /* fallthrough */
05193          case AST_BRIDGE_FAILED_NOWARN:
05194             nativefailed++;
05195             break;
05196          }
05197       }
05198 
05199       if (((c0->writeformat != c1->readformat) || (c0->readformat != c1->writeformat) ||
05200           (c0->nativeformats != o0nativeformats) || (c1->nativeformats != o1nativeformats)) &&
05201           !(c0->generator || c1->generator)) {
05202          if (ast_channel_make_compatible(c0, c1)) {
05203             ast_log(LOG_WARNING, "Can't make %s and %s compatible\n", c0->name, c1->name);
05204             manager_bridge_event(0, 1, c0, c1);
05205             return AST_BRIDGE_FAILED;
05206          }
05207          o0nativeformats = c0->nativeformats;
05208          o1nativeformats = c1->nativeformats;
05209       }
05210 
05211       update_bridge_vars(c0, c1);
05212 
05213       res = ast_generic_bridge(c0, c1, config, fo, rc, config->nexteventts);
05214       if (res != AST_BRIDGE_RETRY) {
05215          break;
05216       } else if (config->feature_timer) {
05217          /* feature timer expired but has not been updated, sending to ast_bridge_call to do so */
05218          break;
05219       }
05220    }
05221 
05222    ast_clear_flag(c0, AST_FLAG_END_DTMF_ONLY);
05223    ast_clear_flag(c1, AST_FLAG_END_DTMF_ONLY);
05224 
05225    /* Now that we have broken the bridge the source will change yet again */
05226    ast_indicate(c0, AST_CONTROL_SRCUPDATE);
05227    ast_indicate(c1, AST_CONTROL_SRCUPDATE);
05228 
05229    c0->_bridge = NULL;
05230    c1->_bridge = NULL;
05231 
05232    /* \todo  XXX here should check that cid_num is not NULL */
05233    manager_event(EVENT_FLAG_CALL, "Unlink",
05234             "Channel1: %s\r\n"
05235             "Channel2: %s\r\n"
05236             "Uniqueid1: %s\r\n"
05237             "Uniqueid2: %s\r\n"
05238             "CallerID1: %s\r\n"
05239             "CallerID2: %s\r\n",
05240             c0->name, c1->name, c0->uniqueid, c1->uniqueid, c0->cid.cid_num, c1->cid.cid_num);
05241    ast_debug(1, "Bridge stops bridging channels %s and %s\n", c0->name, c1->name);
05242 
05243    return res;
05244 }

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 1486 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().

01487 {
01488    int res = 0;
01489 
01490    AST_LIST_INSERT_HEAD(&chan->datastores, datastore, entry);
01491 
01492    return res;
01493 }

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

References ast_datastore_alloc.

01460 {
01461    return ast_datastore_alloc(info, uid);
01462 }

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 1500 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(), handle_gosub(), iax2_call(), jack_hook_callback(), local_read(), local_write(), lock_fixup(), 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().

01501 {
01502    struct ast_datastore *datastore = NULL;
01503    
01504    if (info == NULL)
01505       return NULL;
01506 
01507    AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore, entry) {
01508       if (datastore->info != info) {
01509          continue;
01510       }
01511 
01512       if (uid == NULL) {
01513          /* matched by type only */
01514          break;
01515       }
01516 
01517       if ((datastore->uid != NULL) && !strcasecmp(uid, datastore->uid)) {
01518          /* Matched by type AND uid */
01519          break;
01520       }
01521    }
01522    AST_LIST_TRAVERSE_SAFE_END;
01523 
01524    return datastore;
01525 }

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

References ast_datastore_free().

01465 {
01466    return ast_datastore_free(datastore);
01467 }

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

Inherit datastores from a parent to a child.

Definition at line 1469 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(), findmeexec(), local_call(), ring_entry(), and wait_for_answer().

01470 {
01471    struct ast_datastore *datastore = NULL, *datastore2;
01472 
01473    AST_LIST_TRAVERSE(&from->datastores, datastore, entry) {
01474       if (datastore->inheritance > 0) {
01475          datastore2 = ast_datastore_alloc(datastore->info, datastore->uid);
01476          if (datastore2) {
01477             datastore2->data = datastore->info->duplicate ? datastore->info->duplicate(datastore->data) : NULL;
01478             datastore2->inheritance = datastore->inheritance == DATASTORE_INHERIT_FOREVER ? DATASTORE_INHERIT_FOREVER : datastore->inheritance - 1;
01479             AST_LIST_INSERT_TAIL(&to->datastores, datastore2, entry);
01480          }
01481       }
01482    }
01483    return 0;
01484 }

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 1495 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(), stop_mixmonitor_exec(), and try_calling().

01496 {
01497    return AST_LIST_REMOVE(&chan->datastores, datastore, entry) ? 0 : -1;
01498 }

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

References AST_FLAG_DEFER_DTMF, ast_set_flag, and ast_test_flag.

Referenced by __adsi_transmit_messages(), and find_cache().

01141 {
01142    int pre = 0;
01143 
01144    if (chan) {
01145       pre = ast_test_flag(chan, AST_FLAG_DEFER_DTMF);
01146       ast_set_flag(chan, AST_FLAG_DEFER_DTMF);
01147    }
01148    return pre;
01149 }

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

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

Referenced by dial_exec_full(), and wait_for_answer().

04898 {
04899    /* Make sure we can early bridge, if not error out */
04900    if (!c0->tech->early_bridge || (c1 && (!c1->tech->early_bridge || c0->tech->early_bridge != c1->tech->early_bridge)))
04901       return -1;
04902 
04903    return c0->tech->early_bridge(c0, c1);
04904 }

void ast_channel_free ( struct ast_channel * )

Free a channel structure.

Definition at line 1346 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_debug, AST_DEVICE_UNKNOWN, ast_devstate_changed_literal(), AST_FLAG_IN_CHANNEL_LIST, 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_test_flag, 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_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().

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

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 1740 of file channel.h.

References ast_channel_queryoption(), AST_OPTION_T38_STATE, and T38_STATE_UNAVAILABLE.

Referenced by transmit(), transmit_audio(), and transmit_t38().

01741 {
01742    enum ast_t38_state state = T38_STATE_UNAVAILABLE;
01743    int datalen = sizeof(state);
01744 
01745    ast_channel_queryoption(chan, AST_OPTION_T38_STATE, &state, &datalen, 0);
01746 
01747    return state;
01748 }

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 4242 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().

04243 {
04244    struct ast_var_t *current, *newvar;
04245    const char *varname;
04246 
04247    AST_LIST_TRAVERSE(&parent->varshead, current, entries) {
04248       int vartype = 0;
04249 
04250       varname = ast_var_full_name(current);
04251       if (!varname)
04252          continue;
04253 
04254       if (varname[0] == '_') {
04255          vartype = 1;
04256          if (varname[1] == '_')
04257             vartype = 2;
04258       }
04259 
04260       switch (vartype) {
04261       case 1:
04262          newvar = ast_var_assign(&varname[1], ast_var_value(current));
04263          if (newvar) {
04264             AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
04265             ast_debug(1, "Copying soft-transferable variable %s.\n", ast_var_name(newvar));
04266          }
04267          break;
04268       case 2:
04269          newvar = ast_var_assign(varname, ast_var_value(current));
04270          if (newvar) {
04271             AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries);
04272             ast_debug(1, "Copying hard-transferable variable %s.\n", ast_var_name(newvar));
04273          }
04274          break;
04275       default:
04276          ast_debug(1, "Not copying variable %s.\n", ast_var_name(current));
04277          break;
04278       }
04279    }
04280 }

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 4140 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().

04141 {
04142    /* Some callers do not check return code, and we must try to set all call legs correctly */
04143    int rc = 0;
04144 
04145    /* Set up translation from the chan to the peer */
04146    rc = ast_channel_make_compatible_helper(chan, peer);
04147 
04148    if (rc < 0)
04149       return rc;
04150 
04151    /* Set up translation from the peer to the chan */
04152    rc = ast_channel_make_compatible_helper(peer, chan);
04153 
04154    return rc;
04155 }

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 4157 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().

04158 {
04159    int res = -1;
04160    struct ast_channel *final_orig, *final_clone, *base;
04161 
04162 retrymasq:
04163    final_orig = original;
04164    final_clone = clonechan;
04165 
04166    ast_channel_lock(original);
04167    while (ast_channel_trylock(clonechan)) {
04168       ast_channel_unlock(original);
04169       usleep(1);
04170       ast_channel_lock(original);
04171    }
04172 
04173    /* each of these channels may be sitting behind a channel proxy (i.e. chan_agent)
04174       and if so, we don't really want to masquerade it, but its proxy */
04175    if (original->_bridge && (original->_bridge != ast_bridged_channel(original)) && (original->_bridge->_bridge != original))
04176       final_orig = original->_bridge;
04177 
04178    if (clonechan->_bridge && (clonechan->_bridge != ast_bridged_channel(clonechan)) && (clonechan->_bridge->_bridge != clonechan))
04179       final_clone = clonechan->_bridge;
04180    
04181    if (final_clone->tech->get_base_channel && (base = final_clone->tech->get_base_channel(final_clone))) {
04182       final_clone = base;
04183    }
04184 
04185    if ((final_orig != original) || (final_clone != clonechan)) {
04186       /* Lots and lots of deadlock avoidance.  The main one we're competing with
04187        * is ast_write(), which locks channels recursively, when working with a
04188        * proxy channel. */
04189       if (ast_channel_trylock(final_orig)) {
04190          ast_channel_unlock(clonechan);
04191          ast_channel_unlock(original);
04192          goto retrymasq;
04193       }
04194       if (ast_channel_trylock(final_clone)) {
04195          ast_channel_unlock(final_orig);
04196          ast_channel_unlock(clonechan);
04197          ast_channel_unlock(original);
04198          goto retrymasq;
04199       }
04200       ast_channel_unlock(clonechan);
04201       ast_channel_unlock(original);
04202       original = final_orig;
04203       clonechan = final_clone;
04204    }
04205 
04206    if (original == clonechan) {
04207       ast_log(LOG_WARNING, "Can't masquerade channel '%s' into itself!\n", original->name);
04208       ast_channel_unlock(clonechan);
04209       ast_channel_unlock(original);
04210       return -1;
04211    }
04212 
04213    ast_debug(1, "Planning to masquerade channel %s into the structure of %s\n",
04214       clonechan->name, original->name);
04215    if (original->masq) {
04216       ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n",
04217          original->masq->name, original->name);
04218    } else if (clonechan->masqr) {
04219       ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n",
04220          clonechan->name, clonechan->masqr->name);
04221    } else {
04222       original->masq = clonechan;
04223       clonechan->masqr = original;
04224       ast_queue_frame(original, &ast_null_frame);
04225       ast_queue_frame(clonechan, &ast_null_frame);
04226       ast_debug(1, "Done planning to masquerade channel %s into the structure of %s\n", clonechan->name, original->name);
04227       res = 0;
04228    }
04229 
04230    ast_channel_unlock(clonechan);
04231    ast_channel_unlock(original);
04232 
04233    return res;
04234 }

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 5260 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().

05261 {
05262    if (!chan->tech->queryoption) {
05263       errno = ENOSYS;
05264       return -1;
05265    }
05266 
05267    if (block)
05268       ast_log(LOG_ERROR, "XXX Blocking not implemented yet XXX\n");
05269 
05270    return chan->tech->queryoption(chan, option, data, datalen);
05271 }

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 3683 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().

03684 {
03685    switch (reason) /* the following appear to be the only ones actually returned by request_and_dial */
03686    {
03687    case 0:
03688       return "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)";
03689    case AST_CONTROL_HANGUP:
03690       return "Hangup";
03691    case AST_CONTROL_RING:
03692       return "Local Ring";
03693    case AST_CONTROL_RINGING:
03694       return "Remote end Ringing";
03695    case AST_CONTROL_ANSWER:
03696       return "Remote end has Answered";
03697    case AST_CONTROL_BUSY:
03698       return "Remote end is Busy";
03699    case AST_CONTROL_CONGESTION:
03700       return "Congestion (circuits busy)";
03701    default:
03702       return "Unknown Reason!!";
03703    }
03704 }

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 4086 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().

04087 {
04088    if (chan->tech->send_html)
04089       return chan->tech->send_html(chan, subclass, data, datalen);
04090    return -1;
04091 }

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

References ast_channel_sendhtml(), and AST_HTML_URL.

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

04094 {
04095    return ast_channel_sendhtml(chan, AST_HTML_URL, url, strlen(url) + 1);
04096 }

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

Set the file descriptor on the channel

Definition at line 1528 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().

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

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 5247 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().

05248 {
05249    if (!chan->tech->setoption) {
05250       errno = ENOSYS;
05251       return -1;
05252    }
05253 
05254    if (block)
05255       ast_log(LOG_ERROR, "XXX Blocking not implemented yet XXX\n");
05256 
05257    return chan->tech->setoption(chan, option, data, datalen);
05258 }

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 5580 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().

05581 {
05582    struct ast_silence_generator *state;
05583 
05584    if (!(state = ast_calloc(1, sizeof(*state)))) {
05585       return NULL;
05586    }
05587 
05588    state->old_write_format = chan->writeformat;
05589 
05590    if (ast_set_write_format(chan, AST_FORMAT_SLINEAR) < 0) {
05591       ast_log(LOG_ERROR, "Could not set write format to SLINEAR\n");
05592       ast_free(state);
05593       return NULL;
05594    }
05595 
05596    ast_activate_generator(chan, &silence_generator, state);
05597 
05598    ast_debug(1, "Started silence generator on '%s'\n", chan->name);
05599 
05600    return state;
05601 }

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 5603 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().

05604 {
05605    if (!state)
05606       return;
05607 
05608    ast_deactivate_generator(chan);
05609 
05610    ast_debug(1, "Stopped silence generator on '%s'\n", chan->name);
05611 
05612    if (ast_set_write_format(chan, state->old_write_format) < 0)
05613       ast_log(LOG_ERROR, "Could not return write format to its original state\n");
05614 
05615    ast_free(state);
05616 }

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

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

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

04082 {
04083    return (chan->tech->send_html) ? 1 : 0;
04084 }

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

References ast_clear_flag, and AST_FLAG_DEFER_DTMF.

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

01153 {
01154    if (chan)
01155       ast_clear_flag(chan, AST_FLAG_DEFER_DTMF);
01156 }

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 1266 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().

01267 {
01268    return channel_find_locked(prev, NULL, 0, NULL, NULL);
01269 }

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 1908 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().

01909 {
01910    ast_channel_lock(chan);
01911    if (chan->generatordata) {
01912       if (chan->generator && chan->generator->release)
01913          chan->generator->release(chan, chan->generatordata);
01914       chan->generatordata = NULL;
01915       chan->generator = NULL;
01916       ast_channel_set_fd(chan, AST_GENERATOR_FD, -1);
01917       ast_clear_flag(chan, AST_FLAG_WRITE_INT);
01918       ast_settimeout(chan, 0, NULL, NULL);
01919    }
01920    ast_channel_unlock(chan);
01921 }

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 4333 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(), handle_invite_replaces(), iax_park(), sip_park(), and sip_park_thread().

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

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 1672 of file channel.h.

References dummy().

Referenced by do_monitor().

01673 {
01674    int x;
01675    int dummy = 0;
01676 
01677    if (fd < 0)
01678       return 0;
01679    if (!start)
01680       start = &dummy;
01681    for (x = *start; x < maximum; x++)
01682       if (pfds[x].fd == fd) {
01683          if (x == *start)
01684             (*start)++;
01685          return pfds[x].revents;
01686       }
01687    return 0;
01688 }

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

References channel_find_locked().

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

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

Get channel by name or uniqueid (locks channel).

Definition at line 1272 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().

01273 {
01274    return channel_find_locked(NULL, name, 0, NULL, NULL);
01275 }

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 1278 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().

01279 {
01280    return channel_find_locked(NULL, name, namelen, NULL, NULL);
01281 }

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 5425 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().

05426 {
05427    char *piece;
05428    char *c;
05429    int start=0, finish=0, x;
05430    ast_group_t group = 0;
05431 
05432    if (ast_strlen_zero(s))
05433       return 0;
05434 
05435    c = ast_strdupa(s);
05436    
05437    while ((piece = strsep(&c, ","))) {
05438       if (sscanf(piece, "%30d-%30d", &start, &finish) == 2) {
05439          /* Range */
05440       } else if (sscanf(piece, "%30d", &start)) {
05441          /* Just one */
05442          finish = start;
05443       } else {
05444          ast_log(LOG_ERROR, "Syntax error parsing group configuration '%s' at '%s'. Ignoring.\n", s, piece);
05445          continue;
05446       }
05447       for (x = start; x <= finish; x++) {
05448          if ((x > 63) || (x < 0)) {
05449             ast_log(LOG_WARNING, "Ignoring invalid group %d (maximum group is 63)\n", x);
05450          } else
05451             group |= ((ast_group_t) 1 << x);
05452       }
05453    }
05454    return group;
05455 }

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 1642 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_clear_flag, ast_closestream(), ast_debug, ast_do_masquerade(), AST_FLAG_BLOCKING, AST_FLAG_IN_CHANNEL_LIST, AST_FLAG_ZOMBIE, ast_log(), AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_set_flag, ast_test_flag, ast_channel::audiohooks, ast_channel::blocker, ast_channel::blockproc, ast_channel::cdr, channels, 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_ERROR, 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().

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

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 3051 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().

03052 {
03053    return ast_indicate_data(chan, condition, NULL, 0);
03054 }

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 3091 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(), transmit_t38(), and wait_for_answer().

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

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

References ast_debug, ast_opt_internal_timing, and ast_channel::timingfd.

Referenced by add_sdp(), and ast_read_generator_actions().

03035 {
03036    int ret = ast_opt_internal_timing && chan->timingfd > -1;
03037    ast_debug(5, "Internal timing is %s (option_internal_timing=%d chan->timingfd=%d)\n", ret? "enabled": "disabled", ast_opt_internal_timing, chan->timingfd);
03038    return ret;
03039 }

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

Add a channel to an optimized waitfor

Definition at line 1562 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().

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

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

Delete a channel from an optimized waitfor

Definition at line 1585 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().

01586 {
01587 #ifdef HAVE_EPOLL
01588    struct epoll_event ev;
01589    int i = 0;
01590 
01591    if (chan0->epfd == -1)
01592       return;
01593 
01594    for (i = 0; i < AST_MAX_FDS; i++) {
01595       if (chan1->fds[i] == -1)
01596          continue;
01597       epoll_ctl(chan0->epfd, EPOLL_CTL_DEL, chan1->fds[i], &ev);
01598    }
01599 
01600 #endif
01601    return;
01602 }

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

print call- and pickup groups into buffer

Definition at line 5507 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().

05508 {
05509    unsigned int i;
05510    int first = 1;
05511    char num[3];
05512 
05513    buf[0] = '\0';
05514    
05515    if (!group) /* Return empty string if no group */
05516       return buf;
05517 
05518    for (i = 0; i <= 63; i++) {   /* Max group is 63 */
05519       if (group & ((ast_group_t) 1 << i)) {
05520             if (!first) {
05521             strncat(buf, ", ", buflen - strlen(buf) - 1);
05522          } else {
05523             first = 0;
05524          }
05525          snprintf(num, sizeof(num), "%u", i);
05526          strncat(buf, num, buflen - strlen(buf) - 1);
05527       }
05528    }
05529    return buf;
05530 }

int ast_prod ( struct ast_channel * chan )

Send empty audio to prime a channel driver.

Definition at line 3323 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().

03324 {
03325    struct ast_frame a = { AST_FRAME_VOICE };
03326    char nothing[128];
03327 
03328    /* Send an empty audio frame to get things moving */
03329    if (chan->_state != AST_STATE_UP) {
03330       ast_debug(1, "Prodding channel '%s'\n", chan->name);
03331       a.subclass = chan->rawwriteformat;
03332       a.data.ptr = nothing + AST_FRIENDLY_OFFSET;
03333       a.src = "ast_prod";
03334       if (ast_write(chan, &a))
03335          ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
03336    }
03337    return 0;
03338 }

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 1117 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().

01118 {
01119    struct ast_frame f = { AST_FRAME_CONTROL, };
01120 
01121    f.subclass = control;
01122 
01123    return ast_queue_frame(chan, &f);
01124 }

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 1127 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().

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

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 1074 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().

01075 {
01076    return __ast_queue_frame(chan, fin, 0, NULL);
01077 }

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

References __ast_queue_frame().

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

01080 {
01081    return __ast_queue_frame(chan, fin, 1, NULL);
01082 }

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 1085 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().

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

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 1097 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().

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

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 1751 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().

01752 {
01753    int res = 0;
01754 
01755    ast_channel_lock(chan);
01756 
01757    /* You can't answer an outbound call */
01758    if (ast_test_flag(chan, AST_FLAG_OUTGOING)) {
01759       ast_channel_unlock(chan);
01760       return 0;
01761    }
01762 
01763    /* Stop if we're a zombie or need a soft hangup */
01764    if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) {
01765       ast_channel_unlock(chan);
01766       return -1;
01767    }
01768 
01769    ast_channel_unlock(chan);
01770 
01771    switch (chan->_state) {
01772    case AST_STATE_RINGING:
01773    case AST_STATE_RING:
01774       ast_channel_lock(chan);
01775       if (chan->tech->answer) {
01776          res = chan->tech->answer(chan);
01777       }
01778       ast_setstate(chan, AST_STATE_UP);
01779       if (cdr_answer) {
01780          ast_cdr_answer(chan->cdr);
01781       }
01782       ast_channel_unlock(chan);
01783       break;
01784    case AST_STATE_UP:
01785       /* Calling ast_cdr_answer when it it has previously been called
01786        * is essentially a no-op, so it is safe.
01787        */
01788       if (cdr_answer) {
01789          ast_cdr_answer(chan->cdr);
01790       }
01791       break;
01792    default:
01793       break;
01794    }
01795 
01796    ast_indicate(chan, -1);
01797    chan->visible_indication = 0;
01798 
01799    return res;
01800 }

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 3041 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(), dial_exec_full(), dictate_exec(), disa_exec(), do_idle_thread(), do_waiting(), echo_exec(), eivr_comm(), find_cache(), 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().

03042 {
03043    return __ast_read(chan, 0);
03044 }

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

References __ast_read().

Referenced by conf_run().

03047 {
03048    return __ast_read(chan, 1);
03049 }

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 4028 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().

04029 {
04030    return ast_readstring_full(c, s, len, timeout, ftimeout, enders, -1, -1);
04031 }

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 4033 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().

04034 {
04035    int pos = 0;   /* index in the buffer where we accumulate digits */
04036    int to = ftimeout;
04037 
04038    /* Stop if we're a zombie or need a soft hangup */
04039    if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c))
04040       return -1;
04041    if (!len)
04042       return -1;
04043    for (;;) {
04044       int d;
04045       if (c->stream) {
04046          d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd);
04047          ast_stopstream(c);
04048          usleep(1000);
04049          if (!d)
04050             d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
04051       } else {
04052          d = ast_waitfordigit_full(c, to, audiofd, ctrlfd);
04053       }
04054       if (d < 0)
04055          return AST_GETDATA_FAILED;
04056       if (d == 0) {
04057          s[pos] = '\0';
04058          return AST_GETDATA_TIMEOUT;
04059       }
04060       if (d == 1) {
04061          s[pos] = '\0';
04062          return AST_GETDATA_INTERRUPTED;
04063       }
04064       if (strchr(enders, d) && (pos == 0)) {
04065          s[pos] = '\0';
04066          return AST_GETDATA_EMPTY_END_TERMINATED;
04067       }
04068       if (!strchr(enders, d)) {
04069          s[pos++] = d;
04070       }
04071       if (strchr(enders, d) || (pos >= len)) {
04072          s[pos] = '\0';
04073          return AST_GETDATA_COMPLETE;
04074       }
04075       to = timeout;
04076    }
04077    /* Never reached */
04078    return 0;
04079 }

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

References ast_free, and ast_recvtext().

Referenced by handle_recvchar().

03205 {
03206    int c;
03207    char *buf = ast_recvtext(chan, timeout);
03208    if (buf == NULL)
03209       return -1;  /* error or timeout */
03210    c = *(unsigned char *)buf;
03211    ast_free(buf);
03212    return c;
03213 }

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 3215 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().

03216 {
03217    int res, done = 0;
03218    char *buf = NULL;
03219    
03220    while (!done) {
03221       struct ast_frame *f;
03222       if (ast_check_hangup(chan))
03223          break;
03224       res = ast_waitfor(chan, timeout);
03225       if (res <= 0) /* timeout or error */
03226          break;
03227       timeout = res; /* update timeout */
03228       f = ast_read(chan);
03229       if (f == NULL)
03230          break; /* no frame */
03231       if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
03232          done = 1;   /* force a break */
03233       else if (f->frametype == AST_FRAME_TEXT) {      /* what we want */
03234          buf = ast_strndup((char *) f->data.ptr, f->datalen);  /* dup and break */
03235          done = 1;
03236       }
03237       ast_frfree(f);
03238    }
03239    return buf;
03240 }

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 3926 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().

03927 {
03928    struct chanlist *chan;
03929    struct ast_channel *c;
03930    int capabilities;
03931    int fmt;
03932    int res;
03933    int foo;
03934    int videoformat = format & AST_FORMAT_VIDEO_MASK;
03935    int textformat = format & AST_FORMAT_TEXT_MASK;
03936 
03937    if (!cause)
03938       cause = &foo;
03939    *cause = AST_CAUSE_NOTDEFINED;
03940 
03941    if (AST_RWLIST_RDLOCK(&channels)) {
03942       ast_log(LOG_WARNING, "Unable to lock channel list\n");
03943       return NULL;
03944    }
03945 
03946    AST_LIST_TRAVERSE(&backends, chan, list) {
03947       if (strcasecmp(type, chan->tech->type))
03948          continue;
03949 
03950       capabilities = chan->tech->capabilities;
03951       fmt = format & AST_FORMAT_AUDIO_MASK;
03952       if (fmt) {
03953          /* We have audio - is it possible to connect the various calls to each other? 
03954             (Avoid this check for calls without audio, like text+video calls)
03955          */
03956          res = ast_translator_best_choice(&fmt, &capabilities);
03957          if (res < 0) {
03958             ast_log(LOG_WARNING, "No translator path exists for channel type %s (native 0x%x) to 0x%x\n", type, chan->tech->capabilities, format);
03959             *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
03960             AST_RWLIST_UNLOCK(&channels);
03961             return NULL;
03962          }
03963       }
03964       AST_RWLIST_UNLOCK(&channels);
03965       if (!chan->tech->requester)
03966          return NULL;
03967       
03968       if (!(c = chan->tech->requester(type, capabilities | videoformat | textformat, data, cause)))
03969          return NULL;
03970       
03971       /* no need to generate a Newchannel event here; it is done in the channel_alloc call */
03972       return c;
03973    }
03974 
03975    ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type);
03976    *cause = AST_CAUSE_NOSUCHDRIVER;
03977    AST_RWLIST_UNLOCK(&channels);
03978 
03979    return NULL;
03980 }

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

References __ast_request_and_dial().

Referenced by ast_pbx_outgoing_exten().

03922 {
03923    return __ast_request_and_dial(type, format, data, timeout, outstate, cidnum, cidname, NULL);
03924 }

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 1325 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().

01326 {
01327    return ast_safe_sleep_conditional(chan, ms, NULL, NULL);
01328 }

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

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

Referenced by ast_safe_sleep(), and login_exec().

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

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 1713 of file channel.h.

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

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

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 3313 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().

03314 {
03315    if (chan->tech->send_digit_begin) {
03316       ast_senddigit_begin(chan, digit);
03317       ast_safe_sleep(chan, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
03318    }
03319    
03320    return ast_senddigit_end(chan, digit, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION));
03321 }

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 3255 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().

03256 {
03257    /* Device does not support DTMF tones, lets fake
03258     * it by doing our own generation. */
03259    static const char* dtmf_tones[] = {
03260       "941+1336", /* 0 */
03261       "697+1209", /* 1 */
03262       "697+1336", /* 2 */
03263       "697+1477", /* 3 */
03264       "770+1209", /* 4 */
03265       "770+1336", /* 5 */
03266       "770+1477", /* 6 */
03267       "852+1209", /* 7 */
03268       "852+1336", /* 8 */
03269       "852+1477", /* 9 */
03270       "697+1633", /* A */
03271       "770+1633", /* B */
03272       "852+1633", /* C */
03273       "941+1633", /* D */
03274       "941+1209", /* * */
03275       "941+1477"  /* # */
03276    };
03277 
03278    if (!chan->tech->send_digit_begin)
03279       return 0;
03280 
03281    if (!chan->tech->send_digit_begin(chan, digit))
03282       return 0;
03283 
03284    if (digit >= '0' && digit <='9')
03285       ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0);
03286    else if (digit >= 'A' && digit <= 'D')
03287       ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0);
03288    else if (digit == '*')
03289       ast_playtones_start(chan, 0, dtmf_tones[14], 0);
03290    else if (digit == '#')
03291       ast_playtones_start(chan, 0, dtmf_tones[15], 0);
03292    else {
03293       /* not handled */
03294       ast_debug(1, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name);
03295    }
03296 
03297    return 0;
03298 }

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 3300 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().

03301 {
03302    int res = -1;
03303 
03304    if (chan->tech->send_digit_end)
03305       res = chan->tech->send_digit_end(chan, digit, duration);
03306 
03307    if (res && chan->generator)
03308       ast_playtones_stop(chan);
03309    
03310    return 0;
03311 }

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 3242 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().

03243 {
03244    int res = 0;
03245    /* Stop if we're a zombie or need a soft hangup */
03246    if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
03247       return -1;
03248    CHECK_BLOCKING(chan);
03249    if (chan->tech->send_text)
03250       res = chan->tech->send_text(chan, text);
03251    ast_clear_flag(chan, AST_FLAG_BLOCKING);
03252    return res;
03253 }

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 4610 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().

04611 {
04612    ast_channel_lock(chan);
04613 
04614    if (cid_num) {
04615       if (chan->cid.cid_num)
04616          ast_free(chan->cid.cid_num);
04617       chan->cid.cid_num = ast_strdup(cid_num);
04618    }
04619    if (cid_name) {
04620       if (chan->cid.cid_name)
04621          ast_free(chan->cid.cid_name);
04622       chan->cid.cid_name = ast_strdup(cid_name);
04623    }
04624    if (cid_ani) {
04625       if (chan->cid.cid_ani)
04626          ast_free(chan->cid.cid_ani);
04627       chan->cid.cid_ani = ast_strdup(cid_ani);
04628    }
04629 
04630    report_new_callerid(chan);
04631 
04632    ast_channel_unlock(chan);
04633 }

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 3671 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().

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

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 5532 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().

05533 {
05534    struct ast_variable *cur;
05535 
05536    for (cur = vars; cur; cur = cur->next)
05537       pbx_builtin_setvar_helper(chan, cur->name, cur->value);  
05538 }

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 3677 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().

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

int ast_setstate	(	struct ast_channel *	chan,
		enum	ast_channel_state
	)

Change the state of a channel.

Definition at line 4635 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().

04636 {
04637    int oldstate = chan->_state;
04638    char name[AST_CHANNEL_NAME], *dashptr;
04639 
04640    if (oldstate == state)
04641       return 0;
04642 
04643    ast_copy_string(name, chan->name, sizeof(name));
04644    if ((dashptr = strrchr(name, '-'))) {
04645       *dashptr = '\0';
04646    }
04647 
04648    chan->_state = state;
04649 
04650    /* We have to pass AST_DEVICE_UNKNOWN here because it is entirely possible that the channel driver
04651     * for this channel is using the callback method for device state. If we pass in an actual state here
04652     * we override what they are saying the state is and things go amuck. */
04653    ast_devstate_changed_literal(AST_DEVICE_UNKNOWN, name);
04654 
04655    /* setstate used to conditionally report Newchannel; this is no more */
04656    manager_event(EVENT_FLAG_CALL,
04657             "Newstate",
04658             "Channel: %s\r\n"
04659             "ChannelState: %d\r\n"
04660             "ChannelStateDesc: %s\r\n"
04661             "CallerIDNum: %s\r\n"
04662             "CallerIDName: %s\r\n"
04663             "Uniqueid: %s\r\n",
04664             chan->name, chan->_state, ast_state2str(chan->_state),
04665             S_OR(chan->cid.cid_num, ""),
04666             S_OR(chan->cid.cid_name, ""),
04667             chan->uniqueid);
04668 
04669    return 0;
04670 }

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 2357 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_closestream(), ast_deactivate_generator(), ast_read_generator_actions(), ast_readaudio_callback(), and filestream_destructor().

02358 {
02359    int res;
02360    unsigned int real_rate = rate, max_rate;
02361 
02362    ast_channel_lock(c);
02363 
02364    if (c->timingfd == -1) {
02365       ast_channel_unlock(c);
02366       return -1;
02367    }
02368 
02369    if (!func) {
02370       rate = 0;
02371       data = NULL;
02372    }
02373 
02374    if (rate && rate > (max_rate = ast_timer_get_max_rate(c->timer))) {
02375       real_rate = max_rate;
02376    }
02377 
02378    ast_debug(1, "Scheduling timer at (%u requested / %u actual) timer ticks per second\n", rate, real_rate);
02379 
02380    res = ast_timer_set_rate(c->timer, real_rate);
02381 
02382    c->timingfunc = func;
02383    c->timingdata = data;
02384 
02385    ast_channel_unlock(c);
02386 
02387    return res;
02388 }

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
	reason	an AST_SOFTHANGUP_* reason code

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 1618 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().

01619 {
01620    int res;
01621 
01622    ast_channel_lock(chan);
01623    res = ast_softhangup_nolock(chan, cause);
01624    ast_channel_unlock(chan);
01625 
01626    return res;
01627 }

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
	reason	an AST_SOFTHANGUP_* reason code

Definition at line 1605 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().

01606 {
01607    ast_debug(1, "Soft-Hanging up channel '%s'\n", chan->name);
01608    /* Inform channel driver that we need to be hung up, if it cares */
01609    chan->_softhangup |= cause;
01610    ast_queue_frame(chan, &ast_null_frame);
01611    /* Interrupt any poll call or such */
01612    if (ast_test_flag(chan, AST_FLAG_BLOCKING))
01613       pthread_kill(chan->blocker, SIGURG);
01614    return 0;
01615 }

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

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

Referenced by zapateller_exec().

05408 {
05409    int res;
05410 
05411    if ((res = ast_tonepair_start(chan, freq1, freq2, duration, vol)))
05412       return res;
05413 
05414    /* Give us some wiggle room */
05415    while (chan->generatordata && ast_waitfor(chan, 100) >= 0) {
05416       struct ast_frame *f = ast_read(chan);
05417       if (f)
05418          ast_frfree(f);
05419       else
05420          return -1;
05421    }
05422    return 0;
05423 }

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

Start a tone going

Definition at line 5389 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().

05390 {
05391    struct tonepair_def d = { 0, };
05392 
05393    d.freq1 = freq1;
05394    d.freq2 = freq2;
05395    d.duration = duration;
05396    d.vol = (vol < 1) ? 8192 : vol; /* force invalid to 8192 */
05397    if (ast_activate_generator(chan, &tonepair, &d))
05398       return -1;
05399    return 0;
05400 }

void ast_tonepair_stop ( struct ast_channel * chan )

Stop a tone from playing

Definition at line 5402 of file channel.c.

References ast_deactivate_generator().

Referenced by sendnoise().

05403 {
05404    ast_deactivate_generator(chan);
05405 }

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 4010 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().

04011 {
04012    int res = -1;
04013 
04014    /* Stop if we're a zombie or need a soft hangup */
04015    ast_channel_lock(chan);
04016    if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) {
04017       if (chan->tech->transfer) {
04018          res = chan->tech->transfer(chan, dest);
04019          if (!res)
04020             res = 1;
04021       } else
04022          res = 0;
04023    }
04024    ast_channel_unlock(chan);
04025    return res;
04026 }

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 2341 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().

02342 {
02343    int oldms = ms;   /* -1 if no timeout */
02344 
02345    ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms);
02346    if ((ms < 0) && (oldms < 0))
02347       ms = 0;
02348    return ms;
02349 }

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 2336 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(), dial_exec_full(), iax2_bridge(), misdn_bridge(), monitor_dial(), rpt(), rpt_exec(), wait_for_answer(), and wait_for_winner().

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

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

References ast_waitfor_nandfds().

Referenced by dundi_lookup_internal(), and dundi_precache_internal().

01982 {
01983    int winner = -1;
01984    ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms);
01985    return winner;
01986 }

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 1993 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().

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

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 2352 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().

02353 {
02354    return ast_waitfordigit_full(c, ms, -1, -1);
02355 }

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 2390 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().

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

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

References channel_find_locked().

Referenced by next_channel().

01299 {
01300    return channel_find_locked(chan, NULL, 0, context, exten);
01301 }

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

References channel_find_locked().

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

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

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 3351 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_frisolate(), 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_feature_request_and_dial(), 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().

03352 {
03353    int res = -1;
03354    struct ast_frame *f = NULL;
03355    int count = 0;
03356 
03357    /*Deadlock avoidance*/
03358    while(ast_channel_trylock(chan)) {
03359       /*cannot goto done since the channel is not locked*/
03360       if(count++ > 10) {
03361          ast_debug(1, "Deadlock avoided for write to channel '%s'\n", chan->name);
03362          return 0;
03363       }
03364       usleep(1);
03365    }
03366    /* Stop if we're a zombie or need a soft hangup */
03367    if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan))
03368       goto done;
03369 
03370    /* Handle any pending masquerades */
03371    if (chan->masq && ast_do_masquerade(chan)) {
03372       ast_log(LOG_WARNING, "Failed to perform masquerade\n");
03373       goto done;
03374    }
03375    if (chan->masqr) {
03376       res = 0; /* XXX explain, why 0 ? */
03377       goto done;
03378    }
03379    if (chan->generatordata) {
03380       if (ast_test_flag(chan, AST_FLAG_WRITE_INT))
03381          ast_deactivate_generator(chan);
03382       else {
03383          if (fr->frametype == AST_FRAME_DTMF_END) {
03384             /* There is a generator running while we're in the middle of a digit.
03385              * It's probably inband DTMF, so go ahead and pass it so it can
03386              * stop the generator */
03387             ast_clear_flag(chan, AST_FLAG_BLOCKING);
03388             ast_channel_unlock(chan);
03389             res = ast_senddigit_end(chan, fr->subclass, fr->len);
03390             ast_channel_lock(chan);
03391             CHECK_BLOCKING(chan);
03392          } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_UNHOLD) {
03393             /* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
03394             res = (chan->tech->indicate == NULL) ? 0 :
03395                chan->tech->indicate(chan, fr->subclass, fr->data.ptr, fr->datalen);
03396          }
03397          res = 0; /* XXX explain, why 0 ? */
03398          goto done;
03399       }
03400    }
03401    /* High bit prints debugging */
03402    if (chan->fout & DEBUGCHAN_FLAG)
03403       ast_frame_dump(chan->name, fr, ">>");
03404    CHECK_BLOCKING(chan);
03405    switch (fr->frametype) {
03406    case AST_FRAME_CONTROL:
03407       res = (chan->tech->indicate == NULL) ? 0 :
03408          chan->tech->indicate(chan, fr->subclass, fr->data.ptr, fr->datalen);
03409       break;
03410    case AST_FRAME_DTMF_BEGIN:
03411       if (chan->audiohooks) {
03412          struct ast_frame *old_frame = fr;
03413          fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
03414          if (old_frame != fr)
03415             f = fr;
03416       }
03417       send_dtmf_event(chan, "Sent", fr->subclass, "Yes", "No");
03418       ast_clear_flag(chan, AST_FLAG_BLOCKING);
03419       ast_channel_unlock(chan);
03420       res = ast_senddigit_begin(chan, fr->subclass);
03421       ast_channel_lock(chan);
03422       CHECK_BLOCKING(chan);
03423       break;
03424    case AST_FRAME_DTMF_END:
03425       if (chan->audiohooks) {
03426          struct ast_frame *new_frame = fr;
03427 
03428          new_frame = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr);
03429          if (new_frame != fr) {
03430             ast_frfree(new_frame);
03431          }
03432       }
03433       send_dtmf_event(chan, "Sent", fr->subclass, "No", "Yes");
03434       ast_clear_flag(chan, AST_FLAG_BLOCKING);
03435       ast_channel_unlock(chan);
03436       res = ast_senddigit_end(chan, fr->subclass, fr->len);
03437       ast_channel_lock(chan);
03438       CHECK_BLOCKING(chan);
03439       break;
03440    case AST_FRAME_TEXT:
03441       if (fr->subclass == AST_FORMAT_T140) {
03442          res = (chan->tech->write_text == NULL) ? 0 :
03443             chan->tech->write_text(chan, fr);
03444       } else {
03445          res = (chan->tech->send_text == NULL) ? 0 :
03446             chan->tech->send_text(chan, (char *) fr->data.ptr);
03447       }
03448       break;
03449    case AST_FRAME_HTML:
03450       res = (chan->tech->send_html == NULL) ? 0 :
03451          chan->tech->send_html(chan, fr->subclass, (char *) fr->data.ptr, fr->datalen);
03452       break;
03453    case AST_FRAME_VIDEO:
03454       /* XXX Handle translation of video codecs one day XXX */
03455       res = (chan->tech->write_video == NULL) ? 0 :
03456          chan->tech->write_video(chan, fr);
03457       break;
03458    case AST_FRAME_MODEM:
03459       res = (chan->tech->write == NULL) ? 0 :
03460          chan->tech->write(chan, fr);
03461       break;
03462    case AST_FRAME_VOICE:
03463       if (chan->tech->write == NULL)
03464          break;   /*! \todo XXX should return 0 maybe ? */
03465 
03466       /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */
03467       if (fr->subclass == chan->rawwriteformat)
03468          f = fr;
03469       else
03470          f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr;
03471 
03472       if (!f) {
03473          res = 0;
03474          break;
03475       }
03476 
03477       if (chan->audiohooks) {
03478          struct ast_frame *prev = NULL, *new_frame, *cur, *dup;
03479          int freeoldlist = 0;
03480 
03481          if (f != fr) {
03482             freeoldlist = 1;
03483          }
03484 
03485          /* Since ast_audiohook_write may return a new frame, and the cur frame is
03486           * an item in a list of frames, create a new list adding each cur frame back to it
03487           * regardless if the cur frame changes or not. */
03488          for (cur = f; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
03489             new_frame = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, cur);
03490 
03491             /* if this frame is different than cur, preserve the end of the list,
03492              * free the old frames, and set cur to be the new frame */
03493             if (new_frame != cur) {
03494 
03495                /* doing an ast_frisolate here seems silly, but we are not guaranteed the new_frame
03496                 * isn't part of local storage, meaning if ast_audiohook_write is called multiple
03497                 * times it may override the previous frame we got from it unless we dup it */
03498                if ((dup = ast_frisolate(new_frame))) {
03499                   AST_LIST_NEXT(dup, frame_list) = AST_LIST_NEXT(cur, frame_list);
03500                   if (freeoldlist) {
03501                      AST_LIST_NEXT(cur, frame_list) = NULL;
03502                      ast_frfree(cur);
03503                   }
03504                   cur = dup;
03505                }
03506             }
03507 
03508             /* now, regardless if cur is new or not, add it to the new list,
03509              * if the new list has not started, cur will become the first item. */
03510             if (prev) {
03511                AST_LIST_NEXT(prev, frame_list) = cur;
03512             } else {
03513                f = cur; /* set f to be the beginning of our new list */
03514             }
03515             prev = cur;
03516          }
03517       }
03518       
03519       /* If Monitor is running on this channel, then we have to write frames out there too */
03520       /* the translator on chan->writetrans may have returned multiple frames
03521          from the single frame we passed in; if so, feed each one of them to the
03522          monitor */
03523       if (chan->monitor && chan->monitor->write_stream) {
03524          struct ast_frame *cur;
03525 
03526          for (cur = f; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
03527          /* XXX must explain this code */
03528 #ifndef MONITOR_CONSTANT_DELAY
03529             int jump = chan->insmpl - chan->outsmpl - 4 * cur->samples;
03530             if (jump >= 0) {
03531                jump = chan->insmpl - chan->outsmpl;
03532                if (ast_seekstream(chan->monitor->write_stream, jump, SEEK_FORCECUR) == -1)
03533                   ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
03534                chan->outsmpl += jump + cur->samples;
03535             } else {
03536                chan->outsmpl += cur->samples;
03537             }
03538 #else
03539             int jump = chan->insmpl - chan->outsmpl;
03540             if (jump - MONITOR_DELAY >= 0) {
03541                if (ast_seekstream(chan->monitor->write_stream, jump - cur->samples, SEEK_FORCECUR) == -1)
03542                   ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n");
03543                chan->outsmpl += jump;
03544             } else {
03545                chan->outsmpl += cur->samples;
03546             }
03547 #endif
03548             if (chan->monitor->state == AST_MONITOR_RUNNING) {
03549                if (ast_writestream(chan->monitor->write_stream, cur) < 0)
03550                   ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n");
03551             }
03552          }
03553       }
03554 
03555       /* the translator on chan->writetrans may have returned multiple frames
03556          from the single frame we passed in; if so, feed each one of them to the
03557          channel, freeing each one after it has been written */
03558       if ((f != fr) && AST_LIST_NEXT(f, frame_list)) {
03559          struct ast_frame *cur, *next;
03560          unsigned int skip = 0;
03561 
03562          for (cur = f, next = AST_LIST_NEXT(cur, frame_list);
03563               cur;
03564               cur = next, next = cur ? AST_LIST_NEXT(cur, frame_list) : NULL) {
03565             if (!skip) {
03566                if ((res = chan->tech->write(chan, cur)) < 0) {
03567                   chan->_softhangup |= AST_SOFTHANGUP_DEV;
03568                   skip = 1;
03569                } else if (next) {
03570                   /* don't do this for the last frame in the list,
03571                      as the code outside the loop will do it once
03572                   */
03573                   chan->fout = FRAMECOUNT_INC(chan->fout);
03574                }
03575             }
03576             ast_frfree(cur);
03577          }
03578 
03579          /* reset f so the code below doesn't attempt to free it */
03580          f = NULL;
03581       } else {
03582          res = chan->tech->write(chan, f);
03583       }
03584       break;
03585    case AST_FRAME_NULL:
03586    case AST_FRAME_IAX:
03587       /* Ignore these */
03588       res = 0;
03589       break;
03590    default:
03591       /* At this point, fr is the incoming frame and f is NULL.  Channels do
03592        * not expect to get NULL as a frame pointer and will segfault.  Hence,
03593        * we output the original frame passed in. */
03594       res = chan->tech->write(chan, fr);
03595       break;
03596    }
03597 
03598    if (f && f != fr)
03599       ast_frfree(f);
03600    ast_clear_flag(chan, AST_FLAG_BLOCKING);
03601 
03602    /* Consider a write failure to force a soft hangup */
03603    if (res < 0) {
03604       chan->_softhangup |= AST_SOFTHANGUP_DEV;
03605    } else {
03606       chan->fout = FRAMECOUNT_INC(chan->fout);
03607    }
03608 done:
03609    ast_channel_unlock(chan);
03610    return res;
03611 }

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

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

03341 {
03342    int res;
03343    if (!chan->tech->write_video)
03344       return 0;
03345    res = ast_write(chan, fr);
03346    if (!res)
03347       res = 1;
03348    return res;
03349 }

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

References CHANNEL_CLI_RELOAD, CHANNEL_MODULE_LOAD, and CHANNEL_MODULE_RELOAD.

Referenced by reload_config().

05621 {
05622    switch (reason) {
05623    case CHANNEL_MODULE_LOAD:
05624       return "LOAD (Channel module load)";
05625 
05626    case CHANNEL_MODULE_RELOAD:
05627       return "RELOAD (Channel module reload)";
05628 
05629    case CHANNEL_CLI_RELOAD:
05630       return "CLIRELOAD (Channel module reload by CLI command)";
05631 
05632    default:
05633       return "MANAGERRELOAD (Channel module reload by manager)";
05634    }
05635 };

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