#include "asterisk.h"
#include "asterisk/_private.h"
#include <sys/time.h>
#include <signal.h>
#include <math.h>
#include "asterisk/paths.h"
#include "asterisk/pbx.h"
#include "asterisk/frame.h"
#include "asterisk/mod_format.h"
#include "asterisk/sched.h"
#include "asterisk/channel.h"
#include "asterisk/musiconhold.h"
#include "asterisk/say.h"
#include "asterisk/file.h"
#include "asterisk/cli.h"
#include "asterisk/translate.h"
#include "asterisk/manager.h"
#include "asterisk/cel.h"
#include "asterisk/chanvars.h"
#include "asterisk/linkedlists.h"
#include "asterisk/indications.h"
#include "asterisk/monitor.h"
#include "asterisk/causes.h"
#include "asterisk/callerid.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/app.h"
#include "asterisk/transcap.h"
#include "asterisk/devicestate.h"
#include "asterisk/sha1.h"
#include "asterisk/threadstorage.h"
#include "asterisk/slinfactory.h"
#include "asterisk/audiohook.h"
#include "asterisk/framehook.h"
#include "asterisk/timing.h"
#include "asterisk/autochan.h"
#include "asterisk/stringfields.h"
#include "asterisk/global_datastores.h"
#include "asterisk/data.h"
Go to the source code of this file.
Data Structures | |
struct | ast_channel_iterator |
struct | ast_epoll_data |
struct | ast_party_id_ies |
struct | ast_party_name_ies |
struct | ast_party_number_ies |
struct | ast_party_subaddress_ies |
struct | ast_silence_generator |
struct | backends |
the list of registered channel types More... | |
struct | chanlist |
List of channel drivers. More... | |
struct | plc_ds |
struct | tonepair_def |
struct | tonepair_state |
struct | xfer_masquerade_ds |
Defines | |
#define | AST_DEFAULT_EMULATE_DTMF_DURATION 100 |
#define | AST_MIN_DTMF_DURATION 80 |
#define | AST_MIN_DTMF_GAP 45 |
#define | DATA_EXPORT_CHANNEL(MEMBER) |
#define | FORMAT "%-10.10s %-40.40s %-12.12s %-12.12s %-12.12s\n" |
#define | NUM_CHANNEL_BUCKETS 1567 |
#define | STATE2STR_BUFSIZE 32 |
Enumerations | |
enum | { AST_CONNECTED_LINE_NUMBER, AST_CONNECTED_LINE_NAME, AST_CONNECTED_LINE_NUMBER_PLAN, AST_CONNECTED_LINE_ID_PRESENTATION, AST_CONNECTED_LINE_SOURCE, AST_CONNECTED_LINE_SUBADDRESS, AST_CONNECTED_LINE_SUBADDRESS_TYPE, AST_CONNECTED_LINE_SUBADDRESS_ODD_EVEN, AST_CONNECTED_LINE_SUBADDRESS_VALID, AST_CONNECTED_LINE_TAG, AST_CONNECTED_LINE_VERSION, AST_CONNECTED_LINE_NAME_VALID, AST_CONNECTED_LINE_NAME_CHAR_SET, AST_CONNECTED_LINE_NAME_PRESENTATION, AST_CONNECTED_LINE_NUMBER_VALID, AST_CONNECTED_LINE_NUMBER_PRESENTATION } |
Element identifiers for connected line indication frame data. More... | |
enum | { AST_REDIRECTING_FROM_NUMBER, AST_REDIRECTING_FROM_NAME, AST_REDIRECTING_FROM_NUMBER_PLAN, AST_REDIRECTING_FROM_ID_PRESENTATION, AST_REDIRECTING_TO_NUMBER, AST_REDIRECTING_TO_NAME, AST_REDIRECTING_TO_NUMBER_PLAN, AST_REDIRECTING_TO_ID_PRESENTATION, AST_REDIRECTING_REASON, AST_REDIRECTING_COUNT, AST_REDIRECTING_FROM_SUBADDRESS, AST_REDIRECTING_FROM_SUBADDRESS_TYPE, AST_REDIRECTING_FROM_SUBADDRESS_ODD_EVEN, AST_REDIRECTING_FROM_SUBADDRESS_VALID, AST_REDIRECTING_TO_SUBADDRESS, AST_REDIRECTING_TO_SUBADDRESS_TYPE, AST_REDIRECTING_TO_SUBADDRESS_ODD_EVEN, AST_REDIRECTING_TO_SUBADDRESS_VALID, AST_REDIRECTING_FROM_TAG, AST_REDIRECTING_TO_TAG, AST_REDIRECTING_VERSION, AST_REDIRECTING_FROM_NAME_VALID, AST_REDIRECTING_FROM_NAME_CHAR_SET, AST_REDIRECTING_FROM_NAME_PRESENTATION, AST_REDIRECTING_FROM_NUMBER_VALID, AST_REDIRECTING_FROM_NUMBER_PRESENTATION, AST_REDIRECTING_TO_NAME_VALID, AST_REDIRECTING_TO_NAME_CHAR_SET, AST_REDIRECTING_TO_NAME_PRESENTATION, AST_REDIRECTING_TO_NUMBER_VALID, AST_REDIRECTING_TO_NUMBER_PRESENTATION } |
Element identifiers for redirecting indication frame data. More... | |
Functions | |
int | __ast_answer (struct ast_channel *chan, unsigned int delay, int cdr_answer) |
Answer a channel, with a selectable delay before returning. | |
static void | __ast_change_name_nolink (struct ast_channel *chan, const char *newname) |
this function simply changes the name of the channel and issues a manager_event with out unlinking and linking the channel from the ao2_container. This should only be used when the channel has already been unlinked from the ao2_container. | |
ast_channel * | __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 char *linkedid, const int amaflag, const char *file, int line, const char *function, const char *name_fmt,...) |
Create a channel structure. | |
static struct ast_channel *attribute_malloc | __ast_channel_alloc_ap (int needqueue, int state, const char *cid_num, const char *cid_name, const char *acctcode, const char *exten, const char *context, const char *linkedid, const int amaflag, const char *file, int line, const char *function, const char *name_fmt, va_list ap1, va_list ap2) |
Create a new channel structure. | |
static int | __ast_channel_masquerade (struct ast_channel *original, struct ast_channel *clonechan, struct ast_datastore *xfer_ds) |
static int | __ast_queue_frame (struct ast_channel *chan, struct ast_frame *fin, int head, struct ast_frame *after) |
static struct ast_frame * | __ast_read (struct ast_channel *chan, int dropaudio) |
ast_channel * | __ast_request_and_dial (const char *type, format_t format, const struct ast_channel *requestor, void *data, int timeout, int *outstate, 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. | |
static void | __init_state2str_threadbuf (void) |
static void | adjust_frame_for_plc (struct ast_channel *chan, struct ast_frame *frame, struct ast_datastore *datastore) |
static void | apply_plc (struct ast_channel *chan, struct ast_frame *frame) |
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 | |
int | ast_answer (struct ast_channel *chan) |
Answer a channel. | |
void | ast_begin_shutdown (int hangup) |
format_t | ast_best_codec (format_t fmts) |
Pick the best audio codec. | |
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. | |
ast_channel * | ast_call_forward (struct ast_channel *caller, struct ast_channel *orig, int *timeout, format_t 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 cause) |
Gives the string form of a given cause code. | |
void | ast_change_name (struct ast_channel *chan, const char *newname) |
Change channel name. | |
ast_channel * | 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 char *linkedid, const int amaflag, const char *name_fmt,...) |
enum ast_bridge_result | ast_channel_bridge (struct ast_channel *c0, struct ast_channel *c1, struct ast_bridge_config *config, struct ast_frame **fo, struct ast_channel **rc) |
Bridge two channels together. | |
ast_channel * | ast_channel_callback (ao2_callback_data_fn *cb_fn, void *arg, void *data, int ao2_flags) |
Call a function with every active channel. | |
int | ast_channel_cc_params_init (struct ast_channel *chan, const struct ast_cc_config_params *base_params) |
Set up datastore with CCSS parameters for a channel. | |
static void | ast_channel_change_linkedid (struct ast_channel *chan, const char *linkedid) |
void | ast_channel_clear_softhangup (struct ast_channel *chan, int flag) |
Clear a set of softhangup flags from a channel. | |
static int | ast_channel_cmp_cb (void *obj, void *arg, int flags) |
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_connected_line_macro (struct ast_channel *autoservice_chan, struct ast_channel *macro_chan, const void *connected_info, int is_caller, int is_frame) |
Run a connected line interception macro and update a channel's connected line information. | |
int | ast_channel_data_add_structure (struct ast_data *tree, struct ast_channel *chan, int add_bridged) |
Insert into an astdata tree, the channel structure. | |
int | ast_channel_data_cmp_structure (const struct ast_data_search *tree, struct ast_channel *chan, const char *structure_name) |
Compare to channel structures using the data api. | |
int | ast_channel_datastore_add (struct ast_channel *chan, struct ast_datastore *datastore) |
Add a datastore to a channel. | |
ast_datastore * | ast_channel_datastore_alloc (const struct ast_datastore_info *info, const char *uid) |
Create a channel data store object. | |
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) |
Defers DTMF so that you only read things like hangups and audio. | |
static void | ast_channel_destructor (void *obj) |
Free a channel structure. | |
int | ast_channel_early_bridge (struct ast_channel *c0, struct ast_channel *c1) |
Bridge two channels together (early). | |
ast_channel * | ast_channel_get_by_exten (const char *exten, const char *context) |
Find a channel by extension and context. | |
ast_channel * | ast_channel_get_by_name (const char *name) |
Find a channel by name. | |
ast_channel * | ast_channel_get_by_name_prefix (const char *name, size_t name_len) |
Find a channel by a name prefix. | |
int | ast_channel_get_cc_agent_type (struct ast_channel *chan, char *agent_type, size_t size) |
Find the appropriate CC agent type to use given a channel. | |
ast_cc_config_params * | ast_channel_get_cc_config_params (struct ast_channel *chan) |
Get the CCSS parameters from a channel. | |
int | ast_channel_get_device_name (struct ast_channel *chan, char *device_name, size_t name_buffer_length) |
Get a device name given its channel structure. | |
static struct ast_channel * | ast_channel_get_full (const char *name, size_t name_len, const char *exten, const char *context) |
static int | ast_channel_hash_cb (const void *obj, const int flags) |
void | ast_channel_inherit_variables (const struct ast_channel *parent, struct ast_channel *child) |
Inherits channel variable from parent to child channel. | |
ast_channel_iterator * | ast_channel_iterator_all_new (void) |
Create a new channel iterator. | |
ast_channel_iterator * | ast_channel_iterator_by_exten_new (const char *exten, const char *context) |
Create a new channel iterator based on extension. | |
ast_channel_iterator * | ast_channel_iterator_by_name_new (const char *name, size_t name_len) |
Create a new channel iterator based on name. | |
ast_channel_iterator * | ast_channel_iterator_destroy (struct ast_channel_iterator *i) |
Destroy a channel iterator. | |
ast_channel * | ast_channel_iterator_next (struct ast_channel_iterator *i) |
Get the next channel for a channel iterator. | |
int | ast_channel_make_compatible (struct ast_channel *chan, struct ast_channel *peer) |
Makes two channel formats compatible. | |
static int | ast_channel_make_compatible_helper (struct ast_channel *from, struct ast_channel *to) |
Set up translation from one channel to another. | |
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 *chan, int option, void *data, int *datalen, int block) |
Checks the value of an option. | |
void | ast_channel_queue_connected_line_update (struct ast_channel *chan, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update) |
Queue a connected line update frame on a channel. | |
void | ast_channel_queue_redirecting_update (struct ast_channel *chan, const struct ast_party_redirecting *redirecting, const struct ast_set_party_redirecting *update) |
Queue a redirecting update frame on a channel. | |
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_redirecting_macro (struct ast_channel *autoservice_chan, struct ast_channel *macro_chan, const void *redirecting_info, int is_caller, int is_frame) |
Run a redirecting interception macro and update a channel's redirecting information. | |
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. | |
ast_channel * | ast_channel_release (struct ast_channel *chan) |
Unlink and release reference to a channel. | |
int | ast_channel_sendhtml (struct ast_channel *chan, int subclass, const char *data, int datalen) |
Sends HTML on given channel Send HTML or URL on link. | |
int | ast_channel_sendurl (struct ast_channel *chan, const char *url) |
Sends a URL on a given link Send URL on link. | |
void | ast_channel_set_caller (struct ast_channel *chan, const struct ast_party_caller *caller, const struct ast_set_party_caller *update) |
Set the caller id information in the Asterisk channel. | |
void | ast_channel_set_caller_event (struct ast_channel *chan, const struct ast_party_caller *caller, const struct ast_set_party_caller *update) |
Set the caller id information in the Asterisk channel and generate an AMI event if the caller id name or number changed. | |
void | ast_channel_set_connected_line (struct ast_channel *chan, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update) |
Set the connected line information in the Asterisk channel. | |
void | ast_channel_set_fd (struct ast_channel *chan, int which, int fd) |
void | ast_channel_set_linkgroup (struct ast_channel *chan, struct ast_channel *peer) |
propagate the linked id between chan and peer | |
void | ast_channel_set_redirecting (struct ast_channel *chan, const struct ast_party_redirecting *redirecting, const struct ast_set_party_redirecting *update) |
Set the redirecting id information in the Asterisk channel. | |
int | ast_channel_setoption (struct ast_channel *chan, 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. | |
static int | ast_channel_softhangup_cb (void *obj, void *arg, int flags) |
ast_silence_generator * | ast_channel_start_silence_generator (struct ast_channel *chan) |
Starts a silence generator on the given channel. | |
void | ast_channel_stop_silence_generator (struct ast_channel *chan, struct ast_silence_generator *state) |
Stops a previously-started silence generator on the given channel. | |
int | ast_channel_supports_html (struct ast_channel *chan) |
Checks for HTML support on a channel. | |
int | ast_channel_transfer_masquerade (struct ast_channel *target_chan, const struct ast_party_connected_line *target_id, int target_held, struct ast_channel *transferee_chan, const struct ast_party_connected_line *transferee_id, int transferee_held) |
Setup a masquerade to transfer a call. | |
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. | |
void | ast_channel_update_connected_line (struct ast_channel *chan, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update) |
Indicate that the connected line information has changed. | |
void | ast_channel_update_redirecting (struct ast_channel *chan, const struct ast_party_redirecting *redirecting, const struct ast_set_party_redirecting *update) |
Indicate that the redirecting id has changed. | |
void | ast_channels_init (void) |
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. | |
int | ast_check_hangup_locked (struct ast_channel *chan) |
int | ast_connected_line_build_data (unsigned char *data, size_t datalen, const struct ast_party_connected_line *connected, const struct ast_set_party_connected_line *update) |
Build the connected line information data frame. | |
void | ast_connected_line_copy_from_caller (struct ast_party_connected_line *dest, const struct ast_party_caller *src) |
Copy the caller information to the connected line information. | |
void | ast_connected_line_copy_to_caller (struct ast_party_caller *dest, const struct ast_party_connected_line *src) |
Copy the connected line information to the caller information. | |
int | ast_connected_line_parse_data (const unsigned char *data, size_t datalen, struct ast_party_connected_line *connected) |
Parse connected line indication frame data. | |
AST_DATA_STRUCTURE (ast_channel, DATA_EXPORT_CHANNEL) | |
void | ast_deactivate_generator (struct ast_channel *chan) |
int | ast_do_masquerade (struct ast_channel *original) |
Start masquerading a channel. | |
ast_channel * | ast_dummy_channel_alloc (void) |
Create a fake channel structure. | |
static void | ast_dummy_channel_destructor (void *obj) |
Free a dummy channel structure. | |
static enum ast_bridge_result | ast_generic_bridge (struct ast_channel *c0, struct ast_channel *c1, struct ast_bridge_config *config, struct ast_frame **fo, struct ast_channel **rc) |
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. | |
void | ast_install_music_functions (int(*start_ptr)(struct ast_channel *, const char *, const char *), void(*stop_ptr)(struct ast_channel *), void(*cleanup_ptr)(struct ast_channel *)) |
int | ast_internal_timing_enabled (struct ast_channel *chan) |
Check if the channel can run in internal timing mode. | |
int | ast_is_deferrable_frame (const struct ast_frame *frame) |
Should we keep this frame for later? | |
void | ast_moh_cleanup (struct ast_channel *chan) |
int | ast_moh_start (struct ast_channel *chan, const char *mclass, const char *interpclass) |
Turn on music on hold on a given channel. | |
void | ast_moh_stop (struct ast_channel *chan) |
Turn off music on hold on a given channel. | |
void | ast_party_caller_copy (struct ast_party_caller *dest, const struct ast_party_caller *src) |
Copy the source caller information to the destination caller. | |
void | ast_party_caller_free (struct ast_party_caller *doomed) |
Destroy the caller party contents. | |
void | ast_party_caller_init (struct ast_party_caller *init) |
Initialize the given caller structure. | |
void | ast_party_caller_set (struct ast_party_caller *dest, const struct ast_party_caller *src, const struct ast_set_party_caller *update) |
Set the caller information based on another caller source. | |
void | ast_party_caller_set_init (struct ast_party_caller *init, const struct ast_party_caller *guide) |
Initialize the given caller structure using the given guide for a set update operation. | |
void | ast_party_connected_line_collect_caller (struct ast_party_connected_line *connected, struct ast_party_caller *caller) |
Collect the caller party information into a connected line structure. | |
void | ast_party_connected_line_copy (struct ast_party_connected_line *dest, const struct ast_party_connected_line *src) |
Copy the source connected line information to the destination connected line. | |
void | ast_party_connected_line_free (struct ast_party_connected_line *doomed) |
Destroy the connected line information contents. | |
void | ast_party_connected_line_init (struct ast_party_connected_line *init) |
Initialize the given connected line structure. | |
void | ast_party_connected_line_set (struct ast_party_connected_line *dest, const struct ast_party_connected_line *src, const struct ast_set_party_connected_line *update) |
Set the connected line information based on another connected line source. | |
void | ast_party_connected_line_set_init (struct ast_party_connected_line *init, const struct ast_party_connected_line *guide) |
Initialize the given connected line structure using the given guide for a set update operation. | |
void | ast_party_dialed_copy (struct ast_party_dialed *dest, const struct ast_party_dialed *src) |
Copy the source dialed party information to the destination dialed party. | |
void | ast_party_dialed_free (struct ast_party_dialed *doomed) |
Destroy the dialed party contents. | |
void | ast_party_dialed_init (struct ast_party_dialed *init) |
Initialize the given dialed structure. | |
void | ast_party_dialed_set (struct ast_party_dialed *dest, const struct ast_party_dialed *src) |
Set the dialed information based on another dialed source. | |
void | ast_party_dialed_set_init (struct ast_party_dialed *init, const struct ast_party_dialed *guide) |
Initialize the given dialed structure using the given guide for a set update operation. | |
void | ast_party_id_copy (struct ast_party_id *dest, const struct ast_party_id *src) |
Copy the source party id information to the destination party id. | |
void | ast_party_id_free (struct ast_party_id *doomed) |
Destroy the party id contents. | |
void | ast_party_id_init (struct ast_party_id *init) |
Initialize the given party id structure. | |
int | ast_party_id_presentation (const struct ast_party_id *id) |
Determine the overall presentation value for the given party. | |
void | ast_party_id_set (struct ast_party_id *dest, const struct ast_party_id *src, const struct ast_set_party_id *update) |
Set the source party id information into the destination party id. | |
void | ast_party_id_set_init (struct ast_party_id *init, const struct ast_party_id *guide) |
Initialize the given party id structure using the given guide for a set update operation. | |
void | ast_party_name_copy (struct ast_party_name *dest, const struct ast_party_name *src) |
Copy the source party name information to the destination party name. | |
void | ast_party_name_free (struct ast_party_name *doomed) |
Destroy the party name contents. | |
void | ast_party_name_init (struct ast_party_name *init) |
Initialize the given name structure. | |
void | ast_party_name_set (struct ast_party_name *dest, const struct ast_party_name *src) |
Set the source party name information into the destination party name. | |
void | ast_party_name_set_init (struct ast_party_name *init, const struct ast_party_name *guide) |
Initialize the given party name structure using the given guide for a set update operation. | |
void | ast_party_number_copy (struct ast_party_number *dest, const struct ast_party_number *src) |
Copy the source party number information to the destination party number. | |
void | ast_party_number_free (struct ast_party_number *doomed) |
Destroy the party number contents. | |
void | ast_party_number_init (struct ast_party_number *init) |
Initialize the given number structure. | |
void | ast_party_number_set (struct ast_party_number *dest, const struct ast_party_number *src) |
Set the source party number information into the destination party number. | |
void | ast_party_number_set_init (struct ast_party_number *init, const struct ast_party_number *guide) |
Initialize the given party number structure using the given guide for a set update operation. | |
void | ast_party_redirecting_copy (struct ast_party_redirecting *dest, const struct ast_party_redirecting *src) |
Copy the source redirecting information to the destination redirecting. | |
void | ast_party_redirecting_free (struct ast_party_redirecting *doomed) |
Destroy the redirecting information contents. | |
void | ast_party_redirecting_init (struct ast_party_redirecting *init) |
Initialize the given redirecting structure. | |
void | ast_party_redirecting_set (struct ast_party_redirecting *dest, const struct ast_party_redirecting *src, const struct ast_set_party_redirecting *update) |
Set the redirecting information based on another redirecting source. | |
void | ast_party_redirecting_set_init (struct ast_party_redirecting *init, const struct ast_party_redirecting *guide) |
Initialize the given redirecting id structure using the given guide for a set update operation. | |
void | ast_party_subaddress_copy (struct ast_party_subaddress *dest, const struct ast_party_subaddress *src) |
Copy the source party subaddress information to the destination party subaddress. | |
void | ast_party_subaddress_free (struct ast_party_subaddress *doomed) |
Destroy the party subaddress contents. | |
void | ast_party_subaddress_init (struct ast_party_subaddress *init) |
Initialize the given subaddress structure. | |
void | ast_party_subaddress_set (struct ast_party_subaddress *dest, const struct ast_party_subaddress *src) |
Set the source party subaddress information into the destination party subaddress. | |
void | ast_party_subaddress_set_init (struct ast_party_subaddress *init, const struct ast_party_subaddress *guide) |
Initialize the given party subaddress structure using the given guide for a set update operation. | |
int | ast_plc_reload (void) |
Reload genericplc configuration value from codecs.conf. | |
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 *fin) |
Queue one or more frames to a channel's frame queue. | |
int | ast_queue_frame_head (struct ast_channel *chan, struct ast_frame *fin) |
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. | |
ast_frame * | ast_read (struct ast_channel *chan) |
Reads a frame. | |
static void | ast_read_generator_actions (struct ast_channel *chan, struct ast_frame *f) |
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 ftimeout, char *enders) |
Reads multiple digits. | |
int | ast_readstring_full (struct ast_channel *c, char *s, int len, int timeout, int ftimeout, char *enders, int audiofd, int ctrlfd) |
int | ast_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. | |
int | ast_redirecting_build_data (unsigned char *data, size_t datalen, const struct ast_party_redirecting *redirecting, const struct ast_set_party_redirecting *update) |
Build the redirecting id data frame. | |
int | ast_redirecting_parse_data (const unsigned char *data, size_t datalen, struct ast_party_redirecting *redirecting) |
Parse redirecting indication frame data. | |
ast_channel * | ast_request (const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause) |
Requests a channel. | |
ast_channel * | ast_request_and_dial (const char *type, format_t format, const struct ast_channel *requestor, void *data, int timeout, int *outstate, const char *cidnum, const char *cidname) |
Request a channel of a given type, with data as optional information used by the low level module and attempt to place a call on it. | |
int | ast_safe_sleep (struct ast_channel *chan, int ms) |
Wait for a 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. | |
int | ast_say_character_str (struct ast_channel *chan, const char *str, const char *ints, const char *lang) |
int | ast_say_digit_str (struct ast_channel *chan, const char *str, const char *ints, const char *lang) |
says digits of a string | |
int | ast_say_digits (struct ast_channel *chan, int num, const char *ints, const char *lang) |
says digits | |
int | ast_say_digits_full (struct ast_channel *chan, int num, const char *ints, const char *lang, int audiofd, int ctrlfd) |
int | ast_say_enumeration (struct ast_channel *chan, int num, const char *ints, const char *language, const char *options) |
says an enumeration | |
int | ast_say_number (struct ast_channel *chan, int num, const char *ints, const char *language, const char *options) |
says a number | |
int | ast_say_phonetic_str (struct ast_channel *chan, const char *str, const char *ints, const char *lang) |
int | ast_senddigit (struct ast_channel *chan, char digit, unsigned int duration) |
Send a DTMF digit to a channel. | |
int | ast_senddigit_begin (struct ast_channel *chan, char digit) |
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 and generate AMI event. | |
void | ast_set_hangupsource (struct ast_channel *chan, const char *source, int force) |
Set the source of the hangup in this channel and it's bridge. | |
static void | ast_set_owners_and_peers (struct ast_channel *chan1, struct ast_channel *chan2) |
int | ast_set_read_format (struct ast_channel *chan, format_t fmt) |
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, format_t fmt) |
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 state) |
Change the state of a channel. | |
int | ast_settimeout (struct ast_channel *c, unsigned int rate, int(*func)(const void *data), void *data) |
Enable or disable timer ticks for a channel. | |
int | ast_shutting_down (void) |
Returns non-zero if Asterisk is being shut down. | |
int | ast_softhangup (struct ast_channel *chan, int cause) |
Softly hangup up a channel. | |
int | ast_softhangup_nolock (struct ast_channel *chan, int cause) |
Softly hangup up a channel (no channel lock). | |
const char * | ast_state2str (enum ast_channel_state state) |
Gives the string form of a given channel state. | |
int | ast_str2cause (const char *name) |
Convert the string form of a cause code to a 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). | |
char * | ast_transfercapability2str (int transfercapability) |
Gives the string form of a given transfer capability. | |
void | ast_uninstall_music_functions (void) |
int | ast_waitfor (struct ast_channel *c, int ms) |
Wait for input on a channel. | |
ast_channel * | ast_waitfor_n (struct ast_channel **c, 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. | |
ast_channel * | ast_waitfor_nandfds (struct ast_channel **c, int n, int *fds, int nfds, int *exception, int *outfd, int *ms) |
Waits for activity on a group of channels. | |
int | ast_waitfordigit (struct ast_channel *c, int ms) |
Waits for a digit. | |
int | ast_waitfordigit_full (struct ast_channel *c, int ms, int audiofd, int cmdfd) |
Wait for a digit Same as ast_waitfordigit() with audio fd for outputting read audio and ctrlfd to monitor for reading. | |
int | ast_write (struct ast_channel *chan, struct ast_frame *fr) |
Write a 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 *fr) |
Write video frame to a channel This function writes the given frame to the indicated channel. | |
static void | bridge_play_sounds (struct ast_channel *c0, struct ast_channel *c1) |
static void | bridge_playfile (struct ast_channel *chan, struct ast_channel *peer, const char *sound, int remain) |
static int | calc_monitor_jump (int samples, int sample_rate, int seek_rate) |
calculates the number of samples to jump forward with in a monitor stream. | |
static void * | channel_cc_params_copy (void *data) |
static void | channel_cc_params_destroy (void *data) |
static void | channel_data_add_flags (struct ast_data *tree, struct ast_channel *chan) |
static struct ast_channel_iterator * | channel_iterator_search (const char *name, size_t name_len, const char *exten, const char *context) |
const char * | channelreloadreason2txt (enum channelreloadreason reason) |
Convert enum channelreloadreason to text string for manager event. | |
static void | clone_variables (struct ast_channel *original, struct ast_channel *clonechan) |
Clone channel variables from 'clone' channel into 'original' channel. | |
static char * | complete_channeltypes (struct ast_cli_args *a) |
static int | data_channels_provider_handler (const struct ast_data_search *search, struct ast_data *root) |
static int | data_channeltypes_provider_handler (const struct ast_data_search *search, struct ast_data *data_root) |
static void | free_translation (struct ast_channel *clonechan) |
static int | generator_force (const void *data) |
static void | handle_cause (int cause, int *outstate) |
static char * | handle_cli_core_show_channeltype (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) |
Show details about a channel driver - CLI command. | |
static char * | handle_cli_core_show_channeltypes (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) |
Show channel types - CLI command. | |
static int attribute_const | is_visible_indication (enum ast_control_frame_type condition) |
static void | manager_bridge_event (int onoff, int type, struct ast_channel *c0, struct ast_channel *c1) |
Send manager event for bridge link and unlink events. | |
static void | masquerade_colp_transfer (struct ast_channel *transferee, struct xfer_masquerade_ds *colp) |
static const char * | oldest_linkedid (const char *a, const char *b) |
static void | party_connected_line_copy_transfer (struct ast_party_connected_line *dest, const struct ast_party_connected_line *src) |
static int | party_id_build_data (unsigned char *data, size_t datalen, const struct ast_party_id *id, const char *label, const struct ast_party_id_ies *ies, const struct ast_set_party_id *update) |
static int | party_name_build_data (unsigned char *data, size_t datalen, const struct ast_party_name *name, const char *label, const struct ast_party_name_ies *ies) |
static int | party_number_build_data (unsigned char *data, size_t datalen, const struct ast_party_number *number, const char *label, const struct ast_party_number_ies *ies) |
static int | party_subaddress_build_data (unsigned char *data, size_t datalen, const struct ast_party_subaddress *subaddress, const char *label, const struct ast_party_subaddress_ies *ies) |
static void | plc_ds_destroy (void *data) |
static void | queue_dtmf_readq (struct ast_channel *chan, struct ast_frame *f) |
static void | report_new_callerid (struct ast_channel *chan) |
static void | send_dtmf_event (struct ast_channel *chan, const char *direction, const char digit, const char *begin, const char *end) |
static int | set_format (struct ast_channel *chan, format_t fmt, format_t *rawformat, format_t *format, struct ast_trans_pvt **trans, const int direction) |
static int | set_security_requirements (const struct ast_channel *requestor, struct ast_channel *out) |
static int | should_skip_dtmf (struct ast_channel *chan) |
Determine whether or not we should ignore DTMF in the readq. | |
static void * | silence_generator_alloc (struct ast_channel *chan, void *data) |
static int | silence_generator_generate (struct ast_channel *chan, void *data, int len, int samples) |
static void | silence_generator_release (struct ast_channel *chan, void *data) |
static void * | tonepair_alloc (struct ast_channel *chan, void *params) |
static int | tonepair_generator (struct ast_channel *chan, void *data, int len, int samples) |
static void | tonepair_release (struct ast_channel *chan, void *params) |
static void | update_bridge_vars (struct ast_channel *c0, struct ast_channel *c1) |
static void | xfer_ds_destroy (void *data) |
Variables | |
static void(*) | ast_moh_cleanup_ptr (struct ast_channel *) = NULL |
static int(*) | ast_moh_start_ptr (struct ast_channel *, const char *, const char *) = NULL |
static void(*) | ast_moh_stop_ptr (struct ast_channel *) = NULL |
struct { | |
int cause | |
const char * desc | |
const char * name | |
} | causes [] |
map AST_CAUSE's to readable string representations | |
static struct ast_datastore_info | cc_channel_datastore_info |
static struct ast_data_entry | channel_providers [] |
static struct ao2_container * | channels |
All active channels on the system. | |
static struct ast_data_handler | channels_provider |
static struct ast_data_handler | channeltypes_provider |
static struct ast_cli_entry | cli_channel [] |
unsigned long | global_fin |
unsigned long | global_fout |
static struct ast_channel_tech | null_tech |
static struct ast_datastore_info | plc_ds_info |
static int | shutting_down |
Prevent new channel allocation if shutting down. | |
static struct ast_generator | silence_generator |
static struct ast_threadstorage | state2str_threadbuf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_state2str_threadbuf , .custom_init = NULL , } |
static struct ast_generator | tonepair |
static int | uniqueint |
static struct ast_datastore_info | xfer_ds_info |
Definition in file channel.c.
#define AST_DEFAULT_EMULATE_DTMF_DURATION 100 |
Default amount of time to use when emulating a digit as a begin and end 100ms
Definition at line 105 of file channel.c.
Referenced by __ast_read(), and ast_senddigit().
#define AST_MIN_DTMF_DURATION 80 |
Minimum allowed digit length - 80ms
Definition at line 108 of file channel.c.
Referenced by __ast_read().
#define AST_MIN_DTMF_GAP 45 |
Minimum amount of time between the end of the last digit and the beginning of a new one - 45ms
Definition at line 112 of file channel.c.
Referenced by __ast_read(), and should_skip_dtmf().
#define FORMAT "%-10.10s %-40.40s %-12.12s %-12.12s %-12.12s\n" |
#define NUM_CHANNEL_BUCKETS 1567 |
#define STATE2STR_BUFSIZE 32 |
anonymous enum |
Element identifiers for connected line indication frame data.
Definition at line 8278 of file channel.c.
08278 { 08279 AST_CONNECTED_LINE_NUMBER, 08280 AST_CONNECTED_LINE_NAME, 08281 AST_CONNECTED_LINE_NUMBER_PLAN, 08282 AST_CONNECTED_LINE_ID_PRESENTATION,/* Combined number and name presentation. */ 08283 AST_CONNECTED_LINE_SOURCE, 08284 AST_CONNECTED_LINE_SUBADDRESS, 08285 AST_CONNECTED_LINE_SUBADDRESS_TYPE, 08286 AST_CONNECTED_LINE_SUBADDRESS_ODD_EVEN, 08287 AST_CONNECTED_LINE_SUBADDRESS_VALID, 08288 AST_CONNECTED_LINE_TAG, 08289 AST_CONNECTED_LINE_VERSION, 08290 AST_CONNECTED_LINE_NAME_VALID, 08291 AST_CONNECTED_LINE_NAME_CHAR_SET, 08292 AST_CONNECTED_LINE_NAME_PRESENTATION, 08293 AST_CONNECTED_LINE_NUMBER_VALID, 08294 AST_CONNECTED_LINE_NUMBER_PRESENTATION, 08295 };
anonymous enum |
Element identifiers for redirecting indication frame data.
Definition at line 8599 of file channel.c.
08599 { 08600 AST_REDIRECTING_FROM_NUMBER, 08601 AST_REDIRECTING_FROM_NAME, 08602 AST_REDIRECTING_FROM_NUMBER_PLAN, 08603 AST_REDIRECTING_FROM_ID_PRESENTATION, 08604 AST_REDIRECTING_TO_NUMBER, 08605 AST_REDIRECTING_TO_NAME, 08606 AST_REDIRECTING_TO_NUMBER_PLAN, 08607 AST_REDIRECTING_TO_ID_PRESENTATION, 08608 AST_REDIRECTING_REASON, 08609 AST_REDIRECTING_COUNT, 08610 AST_REDIRECTING_FROM_SUBADDRESS, 08611 AST_REDIRECTING_FROM_SUBADDRESS_TYPE, 08612 AST_REDIRECTING_FROM_SUBADDRESS_ODD_EVEN, 08613 AST_REDIRECTING_FROM_SUBADDRESS_VALID, 08614 AST_REDIRECTING_TO_SUBADDRESS, 08615 AST_REDIRECTING_TO_SUBADDRESS_TYPE, 08616 AST_REDIRECTING_TO_SUBADDRESS_ODD_EVEN, 08617 AST_REDIRECTING_TO_SUBADDRESS_VALID, 08618 AST_REDIRECTING_FROM_TAG, 08619 AST_REDIRECTING_TO_TAG, 08620 AST_REDIRECTING_VERSION, 08621 AST_REDIRECTING_FROM_NAME_VALID, 08622 AST_REDIRECTING_FROM_NAME_CHAR_SET, 08623 AST_REDIRECTING_FROM_NAME_PRESENTATION, 08624 AST_REDIRECTING_FROM_NUMBER_VALID, 08625 AST_REDIRECTING_FROM_NUMBER_PRESENTATION, 08626 AST_REDIRECTING_TO_NAME_VALID, 08627 AST_REDIRECTING_TO_NAME_CHAR_SET, 08628 AST_REDIRECTING_TO_NAME_PRESENTATION, 08629 AST_REDIRECTING_TO_NUMBER_VALID, 08630 AST_REDIRECTING_TO_NUMBER_PRESENTATION, 08631 };
int __ast_answer | ( | struct ast_channel * | chan, | |
unsigned int | delay, | |||
int | cdr_answer | |||
) |
Answer a channel, with a selectable delay before returning.
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 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.
0 | on success | |
non-zero | on failure |
Definition at line 2850 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(), chanlist::chan, errno, frames, ast_frame::frametype, ast_frame_subclass::integer, LOG_WARNING, MAX, ast_channel::name, and ast_frame::subclass.
Referenced by ast_answer(), dial_exec_full(), pbx_builtin_answer(), and pbx_builtin_incomplete().
02851 { 02852 int res = 0; 02853 enum ast_channel_state old_state; 02854 02855 old_state = chan->_state; 02856 if ((res = ast_raw_answer(chan, cdr_answer))) { 02857 return res; 02858 } 02859 02860 switch (old_state) { 02861 case AST_STATE_RINGING: 02862 case AST_STATE_RING: 02863 /* wait for media to start flowing, but don't wait any longer 02864 * than 'delay' or 500 milliseconds, whichever is longer 02865 */ 02866 do { 02867 AST_LIST_HEAD_NOLOCK(, ast_frame) frames; 02868 struct ast_frame *cur, *new; 02869 int ms = MAX(delay, 500); 02870 unsigned int done = 0; 02871 02872 AST_LIST_HEAD_INIT_NOLOCK(&frames); 02873 02874 for (;;) { 02875 ms = ast_waitfor(chan, ms); 02876 if (ms < 0) { 02877 ast_log(LOG_WARNING, "Error condition occurred when polling channel %s for a voice frame: %s\n", chan->name, strerror(errno)); 02878 res = -1; 02879 break; 02880 } 02881 if (ms == 0) { 02882 ast_debug(2, "Didn't receive a media frame from %s within %d ms of answering. Continuing anyway\n", chan->name, MAX(delay, 500)); 02883 break; 02884 } 02885 cur = ast_read(chan); 02886 if (!cur || ((cur->frametype == AST_FRAME_CONTROL) && 02887 (cur->subclass.integer == AST_CONTROL_HANGUP))) { 02888 if (cur) { 02889 ast_frfree(cur); 02890 } 02891 res = -1; 02892 ast_debug(2, "Hangup of channel %s detected in answer routine\n", chan->name); 02893 break; 02894 } 02895 02896 if ((new = ast_frisolate(cur)) != cur) { 02897 ast_frfree(cur); 02898 } 02899 02900 AST_LIST_INSERT_HEAD(&frames, new, frame_list); 02901 02902 /* if a specific delay period was requested, continue 02903 * until that delay has passed. don't stop just because 02904 * incoming media has arrived. 02905 */ 02906 if (delay) { 02907 continue; 02908 } 02909 02910 switch (new->frametype) { 02911 /* all of these frametypes qualify as 'media' */ 02912 case AST_FRAME_VOICE: 02913 case AST_FRAME_VIDEO: 02914 case AST_FRAME_TEXT: 02915 case AST_FRAME_DTMF_BEGIN: 02916 case AST_FRAME_DTMF_END: 02917 case AST_FRAME_IMAGE: 02918 case AST_FRAME_HTML: 02919 case AST_FRAME_MODEM: 02920 done = 1; 02921 break; 02922 case AST_FRAME_CONTROL: 02923 case AST_FRAME_IAX: 02924 case AST_FRAME_NULL: 02925 case AST_FRAME_CNG: 02926 break; 02927 } 02928 02929 if (done) { 02930 break; 02931 } 02932 } 02933 02934 if (res == 0) { 02935 ast_channel_lock(chan); 02936 while ((cur = AST_LIST_REMOVE_HEAD(&frames, frame_list))) { 02937 ast_queue_frame_head(chan, cur); 02938 ast_frfree(cur); 02939 } 02940 ast_channel_unlock(chan); 02941 } 02942 } while (0); 02943 break; 02944 default: 02945 break; 02946 } 02947 02948 return res; 02949 }
static void __ast_change_name_nolink | ( | struct ast_channel * | chan, | |
const char * | newname | |||
) | [static] |
this function simply changes the name of the channel and issues a manager_event with out unlinking and linking the channel from the ao2_container. This should only be used when the channel has already been unlinked from the ao2_container.
Definition at line 5880 of file channel.c.
References ast_manager_event, ast_string_field_set, chanlist::chan, EVENT_FLAG_CALL, name, ast_channel::name, and ast_channel::uniqueid.
Referenced by ast_change_name(), and ast_do_masquerade().
05881 { 05882 ast_manager_event(chan, EVENT_FLAG_CALL, "Rename", "Channel: %s\r\nNewname: %s\r\nUniqueid: %s\r\n", chan->name, newname, chan->uniqueid); 05883 ast_string_field_set(chan, name, newname); 05884 }
struct ast_channel* __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 char * | linkedid, | |||
const int | amaflag, | |||
const char * | file, | |||
int | line, | |||
const char * | function, | |||
const char * | name_fmt, | |||
... | ||||
) |
Create a channel structure.
NULL | failure | |
non-NULL | successfully allocated channel |
Definition at line 1295 of file channel.c.
References __ast_channel_alloc_ap().
01301 { 01302 va_list ap1, ap2; 01303 struct ast_channel *result; 01304 01305 va_start(ap1, name_fmt); 01306 va_start(ap2, name_fmt); 01307 result = __ast_channel_alloc_ap(needqueue, state, cid_num, cid_name, acctcode, exten, context, 01308 linkedid, amaflag, file, line, function, name_fmt, ap1, ap2); 01309 va_end(ap1); 01310 va_end(ap2); 01311 01312 return result; 01313 }
static struct ast_channel* attribute_malloc __ast_channel_alloc_ap | ( | int | needqueue, | |
int | state, | |||
const char * | cid_num, | |||
const char * | cid_name, | |||
const char * | acctcode, | |||
const char * | exten, | |||
const char * | context, | |||
const char * | linkedid, | |||
const int | amaflag, | |||
const char * | file, | |||
int | line, | |||
const char * | function, | |||
const char * | name_fmt, | |||
va_list | ap1, | |||
va_list | ap2 | |||
) | [static] |
Create a new channel structure.
Definition at line 1060 of file channel.c.
References __ao2_alloc_debug(), accountcode, ao2_alloc, ao2_link, ARRAY_LEN, AST_ALERT_FD, ast_atomic_fetchadd_int(), ast_cdr_alloc(), ast_cdr_init(), ast_cdr_start(), AST_CEL_CHANNEL_START, ast_cel_report_event(), ast_channel_destructor(), ast_channel_set_fd(), ast_channel_unref, ast_config_AST_SYSTEM_NAME, ast_copy_string(), ast_default_accountcode, ast_default_amaflags, ast_get_channel_tech(), AST_LIST_HEAD_INIT_NOLOCK, ast_log(), ast_manager_event, ast_party_caller_init(), ast_party_connected_line_init(), ast_party_dialed_init(), ast_party_redirecting_init(), ast_state2str(), ast_strdup, ast_strdupa, ast_string_field_build, ast_string_field_build_va, ast_string_field_init, ast_string_field_set, ast_strlen_zero(), ast_timer_fd(), ast_timer_get_name(), ast_timer_open(), AST_TIMING_FD, channels, defaultlanguage, errno, EVENT_FLAG_CALL, chanlist::flags, language, LOG_WARNING, name, null_tech, S_OR, sched_context_create(), and chanlist::tech.
Referenced by __ast_channel_alloc(), and ast_channel_alloc().
01064 { 01065 struct ast_channel *tmp; 01066 int x; 01067 int flags; 01068 struct varshead *headp; 01069 char *tech = "", *tech2 = NULL; 01070 01071 /* If shutting down, don't allocate any new channels */ 01072 if (shutting_down) { 01073 ast_log(LOG_WARNING, "Channel allocation failed: Refusing due to active shutdown\n"); 01074 return NULL; 01075 } 01076 01077 #if defined(REF_DEBUG) 01078 tmp = __ao2_alloc_debug(sizeof(*tmp), ast_channel_destructor, "", file, line, 01079 function, 1); 01080 #elif defined(__AST_DEBUG_MALLOC) 01081 tmp = __ao2_alloc_debug(sizeof(*tmp), ast_channel_destructor, "", file, line, 01082 function, 0); 01083 #else 01084 tmp = ao2_alloc(sizeof(*tmp), ast_channel_destructor); 01085 #endif 01086 if (!tmp) { 01087 /* Channel structure allocation failure. */ 01088 return NULL; 01089 } 01090 01091 /* 01092 * Init file descriptors to unopened state so 01093 * the destructor can know not to close them. 01094 */ 01095 tmp->timingfd = -1; 01096 for (x = 0; x < ARRAY_LEN(tmp->alertpipe); ++x) { 01097 tmp->alertpipe[x] = -1; 01098 } 01099 for (x = 0; x < ARRAY_LEN(tmp->fds); ++x) { 01100 tmp->fds[x] = -1; 01101 } 01102 #ifdef HAVE_EPOLL 01103 tmp->epfd = epoll_create(25); 01104 #endif 01105 01106 if (!(tmp->sched = sched_context_create())) { 01107 ast_log(LOG_WARNING, "Channel allocation failed: Unable to create schedule context\n"); 01108 return ast_channel_unref(tmp); 01109 } 01110 01111 ast_party_dialed_init(&tmp->dialed); 01112 ast_party_caller_init(&tmp->caller); 01113 ast_party_connected_line_init(&tmp->connected); 01114 ast_party_redirecting_init(&tmp->redirecting); 01115 01116 if (cid_name) { 01117 tmp->caller.id.name.valid = 1; 01118 tmp->caller.id.name.str = ast_strdup(cid_name); 01119 if (!tmp->caller.id.name.str) { 01120 return ast_channel_unref(tmp); 01121 } 01122 } 01123 if (cid_num) { 01124 tmp->caller.id.number.valid = 1; 01125 tmp->caller.id.number.str = ast_strdup(cid_num); 01126 if (!tmp->caller.id.number.str) { 01127 return ast_channel_unref(tmp); 01128 } 01129 } 01130 01131 if ((tmp->timer = ast_timer_open())) { 01132 if (strcmp(ast_timer_get_name(tmp->timer), "timerfd")) { 01133 needqueue = 0; 01134 } 01135 tmp->timingfd = ast_timer_fd(tmp->timer); 01136 } 01137 01138 if (needqueue) { 01139 if (pipe(tmp->alertpipe)) { 01140 ast_log(LOG_WARNING, "Channel allocation failed: Can't create alert pipe! Try increasing max file descriptors with ulimit -n\n"); 01141 return ast_channel_unref(tmp); 01142 } else { 01143 flags = fcntl(tmp->alertpipe[0], F_GETFL); 01144 if (fcntl(tmp->alertpipe[0], F_SETFL, flags | O_NONBLOCK) < 0) { 01145 ast_log(LOG_WARNING, "Channel allocation failed: Unable to set alertpipe nonblocking! (%d: %s)\n", errno, strerror(errno)); 01146 return ast_channel_unref(tmp); 01147 } 01148 flags = fcntl(tmp->alertpipe[1], F_GETFL); 01149 if (fcntl(tmp->alertpipe[1], F_SETFL, flags | O_NONBLOCK) < 0) { 01150 ast_log(LOG_WARNING, "Channel allocation failed: Unable to set alertpipe nonblocking! (%d: %s)\n", errno, strerror(errno)); 01151 return ast_channel_unref(tmp); 01152 } 01153 } 01154 } 01155 01156 /* 01157 * This is the last place the channel constructor can fail. 01158 * 01159 * The destructor takes advantage of this fact to ensure that the 01160 * AST_CEL_CHANNEL_END is not posted if we have not posted the 01161 * AST_CEL_CHANNEL_START yet. 01162 */ 01163 if ((ast_string_field_init(tmp, 128))) { 01164 return ast_channel_unref(tmp); 01165 } 01166 01167 /* Always watch the alertpipe */ 01168 ast_channel_set_fd(tmp, AST_ALERT_FD, tmp->alertpipe[0]); 01169 /* And timing pipe */ 01170 ast_channel_set_fd(tmp, AST_TIMING_FD, tmp->timingfd); 01171 01172 /* Initial state */ 01173 tmp->_state = state; 01174 01175 tmp->streamid = -1; 01176 01177 tmp->fin = global_fin; 01178 tmp->fout = global_fout; 01179 01180 if (ast_strlen_zero(ast_config_AST_SYSTEM_NAME)) { 01181 ast_string_field_build(tmp, uniqueid, "%li.%d", (long) time(NULL), 01182 ast_atomic_fetchadd_int(&uniqueint, 1)); 01183 } else { 01184 ast_string_field_build(tmp, uniqueid, "%s-%li.%d", ast_config_AST_SYSTEM_NAME, 01185 (long) time(NULL), ast_atomic_fetchadd_int(&uniqueint, 1)); 01186 } 01187 01188 if (!ast_strlen_zero(linkedid)) { 01189 ast_string_field_set(tmp, linkedid, linkedid); 01190 } else { 01191 ast_string_field_set(tmp, linkedid, tmp->uniqueid); 01192 } 01193 01194 if (!ast_strlen_zero(name_fmt)) { 01195 char *slash, *slash2; 01196 /* Almost every channel is calling this function, and setting the name via the ast_string_field_build() call. 01197 * And they all use slightly different formats for their name string. 01198 * This means, to set the name here, we have to accept variable args, and call the string_field_build from here. 01199 * This means, that the stringfields must have a routine that takes the va_lists directly, and 01200 * uses them to build the string, instead of forming the va_lists internally from the vararg ... list. 01201 * This new function was written so this can be accomplished. 01202 */ 01203 ast_string_field_build_va(tmp, name, name_fmt, ap1, ap2); 01204 tech = ast_strdupa(tmp->name); 01205 if ((slash = strchr(tech, '/'))) { 01206 if ((slash2 = strchr(slash + 1, '/'))) { 01207 tech2 = slash + 1; 01208 *slash2 = '\0'; 01209 } 01210 *slash = '\0'; 01211 } 01212 } else { 01213 /* 01214 * Start the string with '-' so it becomes an empty string 01215 * in the destructor. 01216 */ 01217 ast_string_field_set(tmp, name, "-**Unknown**"); 01218 } 01219 01220 /* Reminder for the future: under what conditions do we NOT want to track cdrs on channels? */ 01221 01222 /* These 4 variables need to be set up for the cdr_init() to work right */ 01223 if (amaflag) 01224 tmp->amaflags = amaflag; 01225 else 01226 tmp->amaflags = ast_default_amaflags; 01227 01228 if (!ast_strlen_zero(acctcode)) 01229 ast_string_field_set(tmp, accountcode, acctcode); 01230 else 01231 ast_string_field_set(tmp, accountcode, ast_default_accountcode); 01232 01233 if (!ast_strlen_zero(context)) 01234 ast_copy_string(tmp->context, context, sizeof(tmp->context)); 01235 else 01236 strcpy(tmp->context, "default"); 01237 01238 if (!ast_strlen_zero(exten)) 01239 ast_copy_string(tmp->exten, exten, sizeof(tmp->exten)); 01240 else 01241 strcpy(tmp->exten, "s"); 01242 01243 tmp->priority = 1; 01244 01245 tmp->cdr = ast_cdr_alloc(); 01246 ast_cdr_init(tmp->cdr, tmp); 01247 ast_cdr_start(tmp->cdr); 01248 01249 ast_cel_report_event(tmp, AST_CEL_CHANNEL_START, NULL, NULL, NULL); 01250 01251 headp = &tmp->varshead; 01252 AST_LIST_HEAD_INIT_NOLOCK(headp); 01253 01254 AST_LIST_HEAD_INIT_NOLOCK(&tmp->datastores); 01255 01256 AST_LIST_HEAD_INIT_NOLOCK(&tmp->autochans); 01257 01258 ast_string_field_set(tmp, language, defaultlanguage); 01259 01260 tmp->tech = &null_tech; 01261 01262 ao2_link(channels, tmp); 01263 01264 /* 01265 * And now, since the channel structure is built, and has its name, let's 01266 * call the manager event generator with this Newchannel event. This is the 01267 * proper and correct place to make this call, but you sure do have to pass 01268 * a lot of data into this func to do it here! 01269 */ 01270 if (ast_get_channel_tech(tech) || (tech2 && ast_get_channel_tech(tech2))) { 01271 ast_manager_event(tmp, EVENT_FLAG_CALL, "Newchannel", 01272 "Channel: %s\r\n" 01273 "ChannelState: %d\r\n" 01274 "ChannelStateDesc: %s\r\n" 01275 "CallerIDNum: %s\r\n" 01276 "CallerIDName: %s\r\n" 01277 "AccountCode: %s\r\n" 01278 "Exten: %s\r\n" 01279 "Context: %s\r\n" 01280 "Uniqueid: %s\r\n", 01281 tmp->name, 01282 state, 01283 ast_state2str(state), 01284 S_OR(cid_num, ""), 01285 S_OR(cid_name, ""), 01286 tmp->accountcode, 01287 S_OR(exten, ""), 01288 S_OR(context, ""), 01289 tmp->uniqueid); 01290 } 01291 01292 return tmp; 01293 }
static int __ast_channel_masquerade | ( | struct ast_channel * | original, | |
struct ast_channel * | clonechan, | |||
struct ast_datastore * | xfer_ds | |||
) | [static] |
Definition at line 5677 of file channel.c.
References ast_channel::_bridge, ast_bridged_channel(), ast_channel_datastore_add(), 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, ast_channel::name, and ast_channel::tech.
Referenced by ast_channel_masquerade(), and ast_channel_transfer_masquerade().
05678 { 05679 int res = -1; 05680 struct ast_channel *final_orig, *final_clone, *base; 05681 05682 retrymasq: 05683 final_orig = original; 05684 final_clone = clonechan; 05685 05686 ast_channel_lock(original); 05687 while (ast_channel_trylock(clonechan)) { 05688 ast_channel_unlock(original); 05689 usleep(1); 05690 ast_channel_lock(original); 05691 } 05692 05693 /* each of these channels may be sitting behind a channel proxy (i.e. chan_agent) 05694 and if so, we don't really want to masquerade it, but its proxy */ 05695 if (original->_bridge && (original->_bridge != ast_bridged_channel(original)) && (original->_bridge->_bridge != original)) 05696 final_orig = original->_bridge; 05697 05698 if (clonechan->_bridge && (clonechan->_bridge != ast_bridged_channel(clonechan)) && (clonechan->_bridge->_bridge != clonechan)) 05699 final_clone = clonechan->_bridge; 05700 05701 if (final_clone->tech->get_base_channel && (base = final_clone->tech->get_base_channel(final_clone))) { 05702 final_clone = base; 05703 } 05704 05705 if ((final_orig != original) || (final_clone != clonechan)) { 05706 /* Lots and lots of deadlock avoidance. The main one we're competing with 05707 * is ast_write(), which locks channels recursively, when working with a 05708 * proxy channel. */ 05709 if (ast_channel_trylock(final_orig)) { 05710 ast_channel_unlock(clonechan); 05711 ast_channel_unlock(original); 05712 goto retrymasq; 05713 } 05714 if (ast_channel_trylock(final_clone)) { 05715 ast_channel_unlock(final_orig); 05716 ast_channel_unlock(clonechan); 05717 ast_channel_unlock(original); 05718 goto retrymasq; 05719 } 05720 ast_channel_unlock(clonechan); 05721 ast_channel_unlock(original); 05722 original = final_orig; 05723 clonechan = final_clone; 05724 } 05725 05726 if (original == clonechan) { 05727 ast_log(LOG_WARNING, "Can't masquerade channel '%s' into itself!\n", original->name); 05728 ast_channel_unlock(clonechan); 05729 ast_channel_unlock(original); 05730 return -1; 05731 } 05732 05733 ast_debug(1, "Planning to masquerade channel %s into the structure of %s\n", 05734 clonechan->name, original->name); 05735 05736 if (!original->masqr && !original->masq && !clonechan->masq && !clonechan->masqr) { 05737 original->masq = clonechan; 05738 clonechan->masqr = original; 05739 if (xfer_ds) { 05740 ast_channel_datastore_add(original, xfer_ds); 05741 } 05742 ast_queue_frame(original, &ast_null_frame); 05743 ast_queue_frame(clonechan, &ast_null_frame); 05744 ast_debug(1, "Done planning to masquerade channel %s into the structure of %s\n", clonechan->name, original->name); 05745 res = 0; 05746 } else if (original->masq) { 05747 ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n", 05748 original->masq->name, original->name); 05749 } else if (original->masqr) { 05750 /* not yet as a previously planned masq hasn't yet happened */ 05751 ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n", 05752 original->name, original->masqr->name); 05753 } else if (clonechan->masq) { 05754 ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n", 05755 clonechan->masq->name, clonechan->name); 05756 } else { /* (clonechan->masqr) */ 05757 ast_log(LOG_WARNING, "%s is already going to masquerade as %s\n", 05758 clonechan->name, clonechan->masqr->name); 05759 } 05760 05761 ast_channel_unlock(clonechan); 05762 ast_channel_unlock(original); 05763 05764 return res; 05765 }
static int __ast_queue_frame | ( | struct ast_channel * | chan, | |
struct ast_frame * | fin, | |||
int | head, | |||
struct ast_frame * | after | |||
) | [static] |
Definition at line 1350 of file channel.c.
References ast_channel::alertpipe, ast_channel_lock, ast_channel_unlock, AST_CONTROL_END_OF_Q, AST_CONTROL_HANGUP, AST_FLAG_BLOCKING, AST_FRAME_CONTROL, AST_FRAME_NULL, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frdup(), ast_frfree, AST_LIST_APPEND_LIST, AST_LIST_FIRST, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_HEAD_NOLOCK, AST_LIST_INSERT_LIST_AFTER, AST_LIST_INSERT_TAIL, AST_LIST_LAST, AST_LIST_NEXT, AST_LIST_REMOVE, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log(), ast_test_flag, ast_timer_enable_continuous(), ast_channel::blocker, chanlist::chan, errno, f, frames, ast_frame::frametype, ast_frame_subclass::integer, LOG_WARNING, ast_channel::name, ast_channel::readq, ast_frame::subclass, ast_channel::timer, and ast_channel::timingfd.
Referenced by __ast_read(), ast_queue_frame(), and ast_queue_frame_head().
01351 { 01352 struct ast_frame *f; 01353 struct ast_frame *cur; 01354 int blah = 1; 01355 unsigned int new_frames = 0; 01356 unsigned int new_voice_frames = 0; 01357 unsigned int queued_frames = 0; 01358 unsigned int queued_voice_frames = 0; 01359 AST_LIST_HEAD_NOLOCK(, ast_frame) frames; 01360 01361 ast_channel_lock(chan); 01362 01363 /* 01364 * Check the last frame on the queue if we are queuing the new 01365 * frames after it. 01366 */ 01367 cur = AST_LIST_LAST(&chan->readq); 01368 if (cur && cur->frametype == AST_FRAME_CONTROL && !head && (!after || after == cur)) { 01369 switch (cur->subclass.integer) { 01370 case AST_CONTROL_END_OF_Q: 01371 if (fin->frametype == AST_FRAME_CONTROL 01372 && fin->subclass.integer == AST_CONTROL_HANGUP) { 01373 /* 01374 * Destroy the end-of-Q marker frame so we can queue the hangup 01375 * frame in its place. 01376 */ 01377 AST_LIST_REMOVE(&chan->readq, cur, frame_list); 01378 ast_frfree(cur); 01379 01380 /* 01381 * This has degenerated to a normal queue append anyway. Since 01382 * we just destroyed the last frame in the queue we must make 01383 * sure that "after" is NULL or bad things will happen. 01384 */ 01385 after = NULL; 01386 break; 01387 } 01388 /* Fall through */ 01389 case AST_CONTROL_HANGUP: 01390 /* Don't queue anything. */ 01391 ast_channel_unlock(chan); 01392 return 0; 01393 default: 01394 break; 01395 } 01396 } 01397 01398 /* Build copies of all the new frames and count them */ 01399 AST_LIST_HEAD_INIT_NOLOCK(&frames); 01400 for (cur = fin; cur; cur = AST_LIST_NEXT(cur, frame_list)) { 01401 if (!(f = ast_frdup(cur))) { 01402 if (AST_LIST_FIRST(&frames)) { 01403 ast_frfree(AST_LIST_FIRST(&frames)); 01404 } 01405 ast_channel_unlock(chan); 01406 return -1; 01407 } 01408 01409 AST_LIST_INSERT_TAIL(&frames, f, frame_list); 01410 new_frames++; 01411 if (f->frametype == AST_FRAME_VOICE) { 01412 new_voice_frames++; 01413 } 01414 } 01415 01416 /* Count how many frames exist on the queue */ 01417 AST_LIST_TRAVERSE(&chan->readq, cur, frame_list) { 01418 queued_frames++; 01419 if (cur->frametype == AST_FRAME_VOICE) { 01420 queued_voice_frames++; 01421 } 01422 } 01423 01424 if ((queued_frames + new_frames > 128 || queued_voice_frames + new_voice_frames > 96)) { 01425 int count = 0; 01426 ast_log(LOG_WARNING, "Exceptionally long %squeue length queuing to %s\n", queued_frames + new_frames > 128 ? "" : "voice ", chan->name); 01427 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->readq, cur, frame_list) { 01428 /* Save the most recent frame */ 01429 if (!AST_LIST_NEXT(cur, frame_list)) { 01430 break; 01431 } else if (cur->frametype == AST_FRAME_VOICE || cur->frametype == AST_FRAME_VIDEO || cur->frametype == AST_FRAME_NULL) { 01432 if (++count > 64) { 01433 break; 01434 } 01435 AST_LIST_REMOVE_CURRENT(frame_list); 01436 ast_frfree(cur); 01437 } 01438 } 01439 AST_LIST_TRAVERSE_SAFE_END; 01440 } 01441 01442 if (after) { 01443 AST_LIST_INSERT_LIST_AFTER(&chan->readq, &frames, after, frame_list); 01444 } else { 01445 if (head) { 01446 AST_LIST_APPEND_LIST(&frames, &chan->readq, frame_list); 01447 AST_LIST_HEAD_INIT_NOLOCK(&chan->readq); 01448 } 01449 AST_LIST_APPEND_LIST(&chan->readq, &frames, frame_list); 01450 } 01451 01452 if (chan->alertpipe[1] > -1) { 01453 if (write(chan->alertpipe[1], &blah, new_frames * sizeof(blah)) != (new_frames * sizeof(blah))) { 01454 ast_log(LOG_WARNING, "Unable to write to alert pipe on %s (qlen = %d): %s!\n", 01455 chan->name, queued_frames, strerror(errno)); 01456 } 01457 } else if (chan->timingfd > -1) { 01458 ast_timer_enable_continuous(chan->timer); 01459 } else if (ast_test_flag(chan, AST_FLAG_BLOCKING)) { 01460 pthread_kill(chan->blocker, SIGURG); 01461 } 01462 01463 ast_channel_unlock(chan); 01464 01465 return 0; 01466 }
static struct ast_frame* __ast_read | ( | struct ast_channel * | chan, | |
int | dropaudio | |||
) | [static] |
Definition at line 3641 of file channel.c.
References __ast_queue_frame(), ast_channel::_softhangup, ast_channel::_state, ast_control_read_action_payload::action, ast_channel::alertpipe, ast_audiohook_detach_list(), AST_AUDIOHOOK_DIRECTION_READ, ast_audiohook_write_list(), ast_audiohook_write_list_empty(), ast_bridged_channel(), AST_CEL_ANSWER, ast_cel_report_event(), ast_channel_connected_line_macro(), ast_channel_lock, ast_channel_unlock, ast_check_hangup(), ast_clear_flag, ast_connected_line_parse_data(), AST_CONTROL_ANSWER, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_END_OF_Q, AST_CONTROL_HANGUP, AST_CONTROL_READ_ACTION, ast_deactivate_generator(), ast_debug, AST_DEFAULT_EMULATE_DTMF_DURATION, ast_do_masquerade(), AST_FLAG_DEFER_DTMF, AST_FLAG_EMULATE_DTMF, AST_FLAG_END_DTMF_ONLY, AST_FLAG_EXCEPTION, AST_FLAG_IN_DTMF, AST_FLAG_OUTGOING, AST_FLAG_ZOMBIE, ast_format_rate(), AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, ast_frame_dump(), AST_FRAME_NULL, AST_FRAME_READ_ACTION_CONNECTED_LINE_MACRO, AST_FRAME_VOICE, ast_framehook_list_read_event(), ast_frfree, AST_GENERATOR_FD, ast_getformatname(), ast_getformatname_multiple(), ast_indicate_data(), AST_LIST_EMPTY, AST_LIST_FIRST, AST_LIST_LAST, AST_LIST_NEXT, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log(), AST_MIN_DTMF_DURATION, AST_MIN_DTMF_GAP, AST_MONITOR_RUNNING, ast_null_frame, ast_party_connected_line_copy(), ast_party_connected_line_free(), ast_party_connected_line_init(), ast_queue_control(), ast_queue_frame(), ast_queue_frame_head(), ast_read_generator_actions(), ast_seekstream(), ast_set_flag, ast_setstate(), AST_SOFTHANGUP_DEV, AST_STATE_UP, ast_test_flag, ast_timer_ack(), ast_timer_disable_continuous(), ast_timer_get_event(), ast_timer_set_rate(), AST_TIMING_EVENT_CONTINUOUS, AST_TIMING_EVENT_EXPIRED, AST_TIMING_FD, ast_translate(), ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), ast_writestream(), ast_channel::audiohooks, ast_channel::blocker, calc_monitor_jump(), cause, chanlist::chan, ast_channel::connected, chanlist::connected, DEBUGCHAN_FLAG, ast_generator::digit, ast_channel::dtmf_tv, ast_channel::dtmff, ast_channel::emulate_dtmf_digit, ast_channel::emulate_dtmf_duration, errno, ast_channel_tech::exception, f, ast_channel::fdno, ast_channel::fds, ast_channel::fin, chanlist::flags, ast_filestream::fmt, ast_format::format, FRAMECOUNT_INC, ast_channel::framehooks, ast_generator::generate, ast_channel::generator, ast_channel::generatordata, ast_channel::hangupcause, ast_channel::insmpl, LOG_DTMF, LOG_ERROR, LOG_NOTICE, LOG_WARNING, ast_channel::masq, ast_channel::monitor, ast_channel::music_state, ast_channel::name, ast_channel::nativeformats, ast_channel::outsmpl, ast_control_read_action_payload::payload, ast_control_read_action_payload::payload_size, queue_dtmf_readq(), ast_channel_tech::read, ast_channel_monitor::read_stream, ast_channel::readq, ast_channel::readtrans, SEEK_FORCECUR, send_dtmf_event(), should_skip_dtmf(), ast_channel_monitor::state, ast_channel::tech, ast_channel::timer, ast_channel::timingdata, ast_channel::timingfd, and ast_channel::timingfunc.
Referenced by ast_read(), and ast_read_noaudio().
03642 { 03643 struct ast_frame *f = NULL; /* the return value */ 03644 int blah; 03645 int prestate; 03646 int cause = 0; 03647 03648 /* this function is very long so make sure there is only one return 03649 * point at the end (there are only two exceptions to this). 03650 */ 03651 03652 if (chan->masq) { 03653 if (ast_do_masquerade(chan)) 03654 ast_log(LOG_WARNING, "Failed to perform masquerade\n"); 03655 else 03656 f = &ast_null_frame; 03657 return f; 03658 } 03659 03660 /* if here, no masq has happened, lock the channel and proceed */ 03661 ast_channel_lock(chan); 03662 03663 /* Stop if we're a zombie or need a soft hangup */ 03664 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) { 03665 if (chan->generator) 03666 ast_deactivate_generator(chan); 03667 03668 /* 03669 * It is possible for chan->_softhangup to be set and there 03670 * still be control frames that need to be read. Instead of 03671 * just going to 'done' in the case of ast_check_hangup(), we 03672 * need to queue the end-of-Q frame so that it can mark the end 03673 * of the read queue. If there are frames to be read, 03674 * ast_queue_control() will be called repeatedly, but will only 03675 * queue the first end-of-Q frame. 03676 */ 03677 if (chan->_softhangup) { 03678 ast_queue_control(chan, AST_CONTROL_END_OF_Q); 03679 } else { 03680 goto done; 03681 } 03682 } 03683 03684 #ifdef AST_DEVMODE 03685 /* 03686 * The ast_waitfor() code records which of the channel's file descriptors reported that 03687 * data is available. In theory, ast_read() should only be called after ast_waitfor() 03688 * reports that a channel has data available for reading. However, there still may be 03689 * some edge cases throughout the code where ast_read() is called improperly. This can 03690 * potentially cause problems, so if this is a developer build, make a lot of noise if 03691 * this happens so that it can be addressed. 03692 */ 03693 if (chan->fdno == -1) { 03694 ast_log(LOG_ERROR, 03695 "ast_read() on chan '%s' called with no recorded file descriptor.\n", 03696 chan->name); 03697 } 03698 #endif 03699 03700 prestate = chan->_state; 03701 03702 /* Read and ignore anything on the alertpipe, but read only 03703 one sizeof(blah) per frame that we send from it */ 03704 if (chan->alertpipe[0] > -1) { 03705 int flags = fcntl(chan->alertpipe[0], F_GETFL); 03706 /* For some odd reason, the alertpipe occasionally loses nonblocking status, 03707 * which immediately causes a deadlock scenario. Detect and prevent this. */ 03708 if ((flags & O_NONBLOCK) == 0) { 03709 ast_log(LOG_ERROR, "Alertpipe on channel %s lost O_NONBLOCK?!!\n", chan->name); 03710 if (fcntl(chan->alertpipe[0], F_SETFL, flags | O_NONBLOCK) < 0) { 03711 ast_log(LOG_WARNING, "Unable to set alertpipe nonblocking! (%d: %s)\n", errno, strerror(errno)); 03712 f = &ast_null_frame; 03713 goto done; 03714 } 03715 } 03716 if (read(chan->alertpipe[0], &blah, sizeof(blah)) < 0) { 03717 if (errno != EINTR && errno != EAGAIN) 03718 ast_log(LOG_WARNING, "read() failed: %s\n", strerror(errno)); 03719 } 03720 } 03721 03722 if (chan->timingfd > -1 && chan->fdno == AST_TIMING_FD) { 03723 enum ast_timer_event res; 03724 03725 ast_clear_flag(chan, AST_FLAG_EXCEPTION); 03726 03727 res = ast_timer_get_event(chan->timer); 03728 03729 switch (res) { 03730 case AST_TIMING_EVENT_EXPIRED: 03731 ast_timer_ack(chan->timer, 1); 03732 03733 if (chan->timingfunc) { 03734 /* save a copy of func/data before unlocking the channel */ 03735 int (*func)(const void *) = chan->timingfunc; 03736 void *data = chan->timingdata; 03737 chan->fdno = -1; 03738 ast_channel_unlock(chan); 03739 func(data); 03740 } else { 03741 ast_timer_set_rate(chan->timer, 0); 03742 chan->fdno = -1; 03743 ast_channel_unlock(chan); 03744 } 03745 03746 /* cannot 'goto done' because the channel is already unlocked */ 03747 return &ast_null_frame; 03748 03749 case AST_TIMING_EVENT_CONTINUOUS: 03750 if (AST_LIST_EMPTY(&chan->readq) || 03751 !AST_LIST_NEXT(AST_LIST_FIRST(&chan->readq), frame_list)) { 03752 ast_timer_disable_continuous(chan->timer); 03753 } 03754 break; 03755 } 03756 03757 } else if (chan->fds[AST_GENERATOR_FD] > -1 && chan->fdno == AST_GENERATOR_FD) { 03758 /* if the AST_GENERATOR_FD is set, call the generator with args 03759 * set to -1 so it can do whatever it needs to. 03760 */ 03761 void *tmp = chan->generatordata; 03762 chan->generatordata = NULL; /* reset to let ast_write get through */ 03763 chan->generator->generate(chan, tmp, -1, -1); 03764 chan->generatordata = tmp; 03765 f = &ast_null_frame; 03766 chan->fdno = -1; 03767 goto done; 03768 } 03769 03770 /* Check for pending read queue */ 03771 if (!AST_LIST_EMPTY(&chan->readq)) { 03772 int skip_dtmf = should_skip_dtmf(chan); 03773 03774 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->readq, f, frame_list) { 03775 /* We have to be picky about which frame we pull off of the readq because 03776 * there are cases where we want to leave DTMF frames on the queue until 03777 * some later time. */ 03778 03779 if ( (f->frametype == AST_FRAME_DTMF_BEGIN || f->frametype == AST_FRAME_DTMF_END) && skip_dtmf) { 03780 continue; 03781 } 03782 03783 AST_LIST_REMOVE_CURRENT(frame_list); 03784 break; 03785 } 03786 AST_LIST_TRAVERSE_SAFE_END; 03787 03788 if (!f) { 03789 /* There were no acceptable frames on the readq. */ 03790 f = &ast_null_frame; 03791 if (chan->alertpipe[0] > -1) { 03792 int poke = 0; 03793 /* Restore the state of the alertpipe since we aren't ready for any 03794 * of the frames in the readq. */ 03795 if (write(chan->alertpipe[1], &poke, sizeof(poke)) != sizeof(poke)) { 03796 ast_log(LOG_ERROR, "Failed to write to alertpipe: %s\n", strerror(errno)); 03797 } 03798 } 03799 } 03800 03801 /* Interpret hangup and end-of-Q frames to return NULL */ 03802 /* XXX why not the same for frames from the channel ? */ 03803 if (f->frametype == AST_FRAME_CONTROL) { 03804 switch (f->subclass.integer) { 03805 case AST_CONTROL_HANGUP: 03806 chan->_softhangup |= AST_SOFTHANGUP_DEV; 03807 cause = f->data.uint32; 03808 /* Fall through */ 03809 case AST_CONTROL_END_OF_Q: 03810 ast_frfree(f); 03811 f = NULL; 03812 break; 03813 default: 03814 break; 03815 } 03816 } 03817 } else { 03818 chan->blocker = pthread_self(); 03819 if (ast_test_flag(chan, AST_FLAG_EXCEPTION)) { 03820 if (chan->tech->exception) 03821 f = chan->tech->exception(chan); 03822 else { 03823 ast_log(LOG_WARNING, "Exception flag set on '%s', but no exception handler\n", chan->name); 03824 f = &ast_null_frame; 03825 } 03826 /* Clear the exception flag */ 03827 ast_clear_flag(chan, AST_FLAG_EXCEPTION); 03828 } else if (chan->tech->read) 03829 f = chan->tech->read(chan); 03830 else 03831 ast_log(LOG_WARNING, "No read routine on channel %s\n", chan->name); 03832 } 03833 03834 /* 03835 * Reset the recorded file descriptor that triggered this read so that we can 03836 * easily detect when ast_read() is called without properly using ast_waitfor(). 03837 */ 03838 chan->fdno = -1; 03839 03840 /* Perform the framehook read event here. After the frame enters the framehook list 03841 * there is no telling what will happen, <insert mad scientist laugh here>!!! */ 03842 f = ast_framehook_list_read_event(chan->framehooks, f); 03843 03844 if (f) { 03845 struct ast_frame *readq_tail = AST_LIST_LAST(&chan->readq); 03846 struct ast_control_read_action_payload *read_action_payload; 03847 struct ast_party_connected_line connected; 03848 03849 /* if the channel driver returned more than one frame, stuff the excess 03850 into the readq for the next ast_read call 03851 */ 03852 if (AST_LIST_NEXT(f, frame_list)) { 03853 ast_queue_frame(chan, AST_LIST_NEXT(f, frame_list)); 03854 ast_frfree(AST_LIST_NEXT(f, frame_list)); 03855 AST_LIST_NEXT(f, frame_list) = NULL; 03856 } 03857 03858 switch (f->frametype) { 03859 case AST_FRAME_CONTROL: 03860 if (f->subclass.integer == AST_CONTROL_ANSWER) { 03861 if (!ast_test_flag(chan, AST_FLAG_OUTGOING)) { 03862 ast_debug(1, "Ignoring answer on an inbound call!\n"); 03863 ast_frfree(f); 03864 f = &ast_null_frame; 03865 } else if (prestate == AST_STATE_UP && ast_bridged_channel(chan)) { 03866 ast_debug(1, "Dropping duplicate answer!\n"); 03867 ast_frfree(f); 03868 f = &ast_null_frame; 03869 } else { 03870 /* Answer the CDR */ 03871 ast_setstate(chan, AST_STATE_UP); 03872 /* removed a call to ast_cdr_answer(chan->cdr) from here. */ 03873 ast_cel_report_event(chan, AST_CEL_ANSWER, NULL, NULL, NULL); 03874 } 03875 } else if (f->subclass.integer == AST_CONTROL_READ_ACTION) { 03876 read_action_payload = f->data.ptr; 03877 switch (read_action_payload->action) { 03878 case AST_FRAME_READ_ACTION_CONNECTED_LINE_MACRO: 03879 ast_party_connected_line_init(&connected); 03880 ast_party_connected_line_copy(&connected, &chan->connected); 03881 if (ast_connected_line_parse_data(read_action_payload->payload, 03882 read_action_payload->payload_size, &connected)) { 03883 ast_party_connected_line_free(&connected); 03884 break; 03885 } 03886 if (ast_channel_connected_line_macro(NULL, chan, &connected, 1, 0)) { 03887 ast_indicate_data(chan, AST_CONTROL_CONNECTED_LINE, 03888 read_action_payload->payload, 03889 read_action_payload->payload_size); 03890 } 03891 ast_party_connected_line_free(&connected); 03892 break; 03893 } 03894 ast_frfree(f); 03895 f = &ast_null_frame; 03896 } 03897 break; 03898 case AST_FRAME_DTMF_END: 03899 send_dtmf_event(chan, "Received", f->subclass.integer, "No", "Yes"); 03900 ast_log(LOG_DTMF, "DTMF end '%c' received on %s, duration %ld ms\n", f->subclass.integer, chan->name, f->len); 03901 /* Queue it up if DTMF is deferred, or if DTMF emulation is forced. */ 03902 if (ast_test_flag(chan, AST_FLAG_DEFER_DTMF) || ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)) { 03903 queue_dtmf_readq(chan, f); 03904 ast_frfree(f); 03905 f = &ast_null_frame; 03906 } else if (!ast_test_flag(chan, AST_FLAG_IN_DTMF | AST_FLAG_END_DTMF_ONLY)) { 03907 if (!ast_tvzero(chan->dtmf_tv) && 03908 ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) { 03909 /* If it hasn't been long enough, defer this digit */ 03910 queue_dtmf_readq(chan, f); 03911 ast_frfree(f); 03912 f = &ast_null_frame; 03913 } else { 03914 /* There was no begin, turn this into a begin and send the end later */ 03915 f->frametype = AST_FRAME_DTMF_BEGIN; 03916 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF); 03917 chan->emulate_dtmf_digit = f->subclass.integer; 03918 chan->dtmf_tv = ast_tvnow(); 03919 if (f->len) { 03920 if (f->len > AST_MIN_DTMF_DURATION) 03921 chan->emulate_dtmf_duration = f->len; 03922 else 03923 chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION; 03924 } else 03925 chan->emulate_dtmf_duration = AST_DEFAULT_EMULATE_DTMF_DURATION; 03926 ast_log(LOG_DTMF, "DTMF begin emulation of '%c' with duration %u queued on %s\n", f->subclass.integer, chan->emulate_dtmf_duration, chan->name); 03927 } 03928 if (chan->audiohooks) { 03929 struct ast_frame *old_frame = f; 03930 /*! 03931 * \todo XXX It is possible to write a digit to the audiohook twice 03932 * if the digit was originally read while the channel was in autoservice. */ 03933 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f); 03934 if (old_frame != f) 03935 ast_frfree(old_frame); 03936 } 03937 } else { 03938 struct timeval now = ast_tvnow(); 03939 if (ast_test_flag(chan, AST_FLAG_IN_DTMF)) { 03940 ast_log(LOG_DTMF, "DTMF end accepted with begin '%c' on %s\n", f->subclass.integer, chan->name); 03941 ast_clear_flag(chan, AST_FLAG_IN_DTMF); 03942 if (!f->len) 03943 f->len = ast_tvdiff_ms(now, chan->dtmf_tv); 03944 03945 /* detect tones that were received on 03946 * the wire with durations shorter than 03947 * AST_MIN_DTMF_DURATION and set f->len 03948 * to the actual duration of the DTMF 03949 * frames on the wire. This will cause 03950 * dtmf emulation to be triggered later 03951 * on. 03952 */ 03953 if (ast_tvdiff_ms(now, chan->dtmf_tv) < AST_MIN_DTMF_DURATION) { 03954 f->len = ast_tvdiff_ms(now, chan->dtmf_tv); 03955 ast_log(LOG_DTMF, "DTMF end '%c' detected to have actual duration %ld on the wire, emulation will be triggered on %s\n", f->subclass.integer, f->len, chan->name); 03956 } 03957 } else if (!f->len) { 03958 ast_log(LOG_DTMF, "DTMF end accepted without begin '%c' on %s\n", f->subclass.integer, chan->name); 03959 f->len = AST_MIN_DTMF_DURATION; 03960 } 03961 if (f->len < AST_MIN_DTMF_DURATION && !ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)) { 03962 ast_log(LOG_DTMF, "DTMF end '%c' has duration %ld but want minimum %d, emulating on %s\n", f->subclass.integer, f->len, AST_MIN_DTMF_DURATION, chan->name); 03963 ast_set_flag(chan, AST_FLAG_EMULATE_DTMF); 03964 chan->emulate_dtmf_digit = f->subclass.integer; 03965 chan->emulate_dtmf_duration = AST_MIN_DTMF_DURATION - f->len; 03966 ast_frfree(f); 03967 f = &ast_null_frame; 03968 } else { 03969 ast_log(LOG_DTMF, "DTMF end passthrough '%c' on %s\n", f->subclass.integer, chan->name); 03970 if (f->len < AST_MIN_DTMF_DURATION) { 03971 f->len = AST_MIN_DTMF_DURATION; 03972 } 03973 chan->dtmf_tv = now; 03974 } 03975 if (chan->audiohooks) { 03976 struct ast_frame *old_frame = f; 03977 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f); 03978 if (old_frame != f) 03979 ast_frfree(old_frame); 03980 } 03981 } 03982 break; 03983 case AST_FRAME_DTMF_BEGIN: 03984 send_dtmf_event(chan, "Received", f->subclass.integer, "Yes", "No"); 03985 ast_log(LOG_DTMF, "DTMF begin '%c' received on %s\n", f->subclass.integer, chan->name); 03986 if ( ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_END_DTMF_ONLY | AST_FLAG_EMULATE_DTMF) || 03987 (!ast_tvzero(chan->dtmf_tv) && 03988 ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) ) { 03989 ast_log(LOG_DTMF, "DTMF begin ignored '%c' on %s\n", f->subclass.integer, chan->name); 03990 ast_frfree(f); 03991 f = &ast_null_frame; 03992 } else { 03993 ast_set_flag(chan, AST_FLAG_IN_DTMF); 03994 chan->dtmf_tv = ast_tvnow(); 03995 ast_log(LOG_DTMF, "DTMF begin passthrough '%c' on %s\n", f->subclass.integer, chan->name); 03996 } 03997 break; 03998 case AST_FRAME_NULL: 03999 /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration 04000 * is reached , because we want to make sure we pass at least one 04001 * voice frame through before starting the next digit, to ensure a gap 04002 * between DTMF digits. */ 04003 if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)) { 04004 struct timeval now = ast_tvnow(); 04005 if (!chan->emulate_dtmf_duration) { 04006 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF); 04007 chan->emulate_dtmf_digit = 0; 04008 } else if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) { 04009 chan->emulate_dtmf_duration = 0; 04010 ast_frfree(f); 04011 f = &chan->dtmff; 04012 f->frametype = AST_FRAME_DTMF_END; 04013 f->subclass.integer = chan->emulate_dtmf_digit; 04014 f->len = ast_tvdiff_ms(now, chan->dtmf_tv); 04015 chan->dtmf_tv = now; 04016 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF); 04017 chan->emulate_dtmf_digit = 0; 04018 ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass.integer, chan->name); 04019 if (chan->audiohooks) { 04020 struct ast_frame *old_frame = f; 04021 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f); 04022 if (old_frame != f) { 04023 ast_frfree(old_frame); 04024 } 04025 } 04026 } 04027 } 04028 break; 04029 case AST_FRAME_VOICE: 04030 /* The EMULATE_DTMF flag must be cleared here as opposed to when the duration 04031 * is reached , because we want to make sure we pass at least one 04032 * voice frame through before starting the next digit, to ensure a gap 04033 * between DTMF digits. */ 04034 if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !chan->emulate_dtmf_duration) { 04035 ast_clear_flag(chan, AST_FLAG_EMULATE_DTMF); 04036 chan->emulate_dtmf_digit = 0; 04037 } 04038 04039 if (dropaudio || ast_test_flag(chan, AST_FLAG_IN_DTMF)) { 04040 if (dropaudio) 04041 ast_read_generator_actions(chan, f); 04042 ast_frfree(f); 04043 f = &ast_null_frame; 04044 } 04045 04046 if (ast_test_flag(chan, AST_FLAG_EMULATE_DTMF) && !ast_test_flag(chan, AST_FLAG_IN_DTMF)) { 04047 struct timeval now = ast_tvnow(); 04048 if (ast_tvdiff_ms(now, chan->dtmf_tv) >= chan->emulate_dtmf_duration) { 04049 chan->emulate_dtmf_duration = 0; 04050 ast_frfree(f); 04051 f = &chan->dtmff; 04052 f->frametype = AST_FRAME_DTMF_END; 04053 f->subclass.integer = chan->emulate_dtmf_digit; 04054 f->len = ast_tvdiff_ms(now, chan->dtmf_tv); 04055 chan->dtmf_tv = now; 04056 if (chan->audiohooks) { 04057 struct ast_frame *old_frame = f; 04058 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f); 04059 if (old_frame != f) 04060 ast_frfree(old_frame); 04061 } 04062 ast_log(LOG_DTMF, "DTMF end emulation of '%c' queued on %s\n", f->subclass.integer, chan->name); 04063 } else { 04064 /* Drop voice frames while we're still in the middle of the digit */ 04065 ast_frfree(f); 04066 f = &ast_null_frame; 04067 } 04068 } else if ((f->frametype == AST_FRAME_VOICE) && !(f->subclass.codec & chan->nativeformats)) { 04069 /* This frame is not one of the current native formats -- drop it on the floor */ 04070 char to[200]; 04071 ast_log(LOG_NOTICE, "Dropping incompatible voice frame on %s of format %s since our native format has changed to %s\n", 04072 chan->name, ast_getformatname(f->subclass.codec), ast_getformatname_multiple(to, sizeof(to), chan->nativeformats)); 04073 ast_frfree(f); 04074 f = &ast_null_frame; 04075 } else if ((f->frametype == AST_FRAME_VOICE)) { 04076 /* Send frame to audiohooks if present */ 04077 if (chan->audiohooks) { 04078 struct ast_frame *old_frame = f; 04079 f = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_READ, f); 04080 if (old_frame != f) 04081 ast_frfree(old_frame); 04082 } 04083 if (chan->monitor && chan->monitor->read_stream ) { 04084 /* XXX what does this do ? */ 04085 #ifndef MONITOR_CONSTANT_DELAY 04086 int jump = chan->outsmpl - chan->insmpl - 4 * f->samples; 04087 if (jump >= 0) { 04088 jump = calc_monitor_jump((chan->outsmpl - chan->insmpl), ast_format_rate(f->subclass.codec), ast_format_rate(chan->monitor->read_stream->fmt->format)); 04089 if (ast_seekstream(chan->monitor->read_stream, jump, SEEK_FORCECUR) == -1) 04090 ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n"); 04091 chan->insmpl += (chan->outsmpl - chan->insmpl) + f->samples; 04092 } else 04093 chan->insmpl+= f->samples; 04094 #else 04095 int jump = calc_monitor_jump((chan->outsmpl - chan->insmpl), ast_format_rate(f->subclass.codec), ast_format_rate(chan->monitor->read_stream->fmt->format)); 04096 if (jump - MONITOR_DELAY >= 0) { 04097 if (ast_seekstream(chan->monitor->read_stream, jump - f->samples, SEEK_FORCECUR) == -1) 04098 ast_log(LOG_WARNING, "Failed to perform seek in monitoring read stream, synchronization between the files may be broken\n"); 04099 chan->insmpl += chan->outsmpl - chan->insmpl; 04100 } else 04101 chan->insmpl += f->samples; 04102 #endif 04103 if (chan->monitor->state == AST_MONITOR_RUNNING) { 04104 if (ast_writestream(chan->monitor->read_stream, f) < 0) 04105 ast_log(LOG_WARNING, "Failed to write data to channel monitor read stream\n"); 04106 } 04107 } 04108 04109 if (chan->readtrans && (f = ast_translate(chan->readtrans, f, 1)) == NULL) { 04110 f = &ast_null_frame; 04111 } 04112 04113 /* it is possible for the translation process on chan->readtrans to have 04114 produced multiple frames from the single input frame we passed it; if 04115 this happens, queue the additional frames *before* the frames we may 04116 have queued earlier. if the readq was empty, put them at the head of 04117 the queue, and if it was not, put them just after the frame that was 04118 at the end of the queue. 04119 */ 04120 if (AST_LIST_NEXT(f, frame_list)) { 04121 if (!readq_tail) { 04122 ast_queue_frame_head(chan, AST_LIST_NEXT(f, frame_list)); 04123 } else { 04124 __ast_queue_frame(chan, AST_LIST_NEXT(f, frame_list), 0, readq_tail); 04125 } 04126 ast_frfree(AST_LIST_NEXT(f, frame_list)); 04127 AST_LIST_NEXT(f, frame_list) = NULL; 04128 } 04129 04130 /* Run generator sitting on the line if timing device not available 04131 * and synchronous generation of outgoing frames is necessary */ 04132 ast_read_generator_actions(chan, f); 04133 } 04134 break; 04135 default: 04136 /* Just pass it on! */ 04137 break; 04138 } 04139 } else { 04140 /* Make sure we always return NULL in the future */ 04141 if (!chan->_softhangup) { 04142 chan->_softhangup |= AST_SOFTHANGUP_DEV; 04143 } 04144 if (cause) 04145 chan->hangupcause = cause; 04146 if (chan->generator) 04147 ast_deactivate_generator(chan); 04148 /* We no longer End the CDR here */ 04149 } 04150 04151 /* High bit prints debugging */ 04152 if (chan->fin & DEBUGCHAN_FLAG) 04153 ast_frame_dump(chan->name, f, "<<"); 04154 chan->fin = FRAMECOUNT_INC(chan->fin); 04155 04156 done: 04157 if (chan->music_state && chan->generator && chan->generator->digit && f && f->frametype == AST_FRAME_DTMF_END) 04158 chan->generator->digit(chan, f->subclass.integer); 04159 04160 if (chan->audiohooks && ast_audiohook_write_list_empty(chan->audiohooks)) { 04161 /* The list gets recreated if audiohooks are added again later */ 04162 ast_audiohook_detach_list(chan->audiohooks); 04163 chan->audiohooks = NULL; 04164 } 04165 ast_channel_unlock(chan); 04166 return f; 04167 }
struct ast_channel* __ast_request_and_dial | ( | const char * | type, | |
format_t | format, | |||
const struct ast_channel * | requestor, | |||
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.
type | type of channel to request | |
format | requested channel format | |
requestor | channel requesting data | |
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 |
Definition at line 5181 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_answer(), ast_cdr_busy(), 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_channel_set_connected_line(), AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CC, AST_CONTROL_CONGESTION, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_HANGUP, AST_CONTROL_HOLD, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_REDIRECTING, AST_CONTROL_RINGING, AST_CONTROL_SRCCHANGE, AST_CONTROL_SRCUPDATE, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, ast_copy_string(), AST_FRAME_CONTROL, ast_frfree, ast_hangup(), ast_log(), ast_party_connected_line_set_init(), AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED, ast_read(), ast_request(), ast_set_callerid(), ast_set_flag, ast_set_variables(), AST_STATE_UP, ast_strlen_zero(), ast_waitfor(), ast_channel::call_forward, cause, ast_channel::cdr, chanlist::chan, outgoing_helper::cid_name, outgoing_helper::cid_num, ast_channel::connected, chanlist::connected, ast_channel::context, outgoing_helper::context, ast_channel::exten, outgoing_helper::exten, f, handle_cause(), ast_channel::hangupcause, ast_party_connected_line::id, LOG_NOTICE, ast_party_id::name, ast_party_id::number, outgoing_helper::parent_channel, ast_party_name::presentation, ast_party_number::presentation, ast_channel::priority, outgoing_helper::priority, ast_party_name::str, ast_party_number::str, ast_party_name::valid, ast_party_number::valid, and outgoing_helper::vars.
Referenced by ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_request_and_dial(), and parkandannounce_exec().
05182 { 05183 int dummy_outstate; 05184 int cause = 0; 05185 struct ast_channel *chan; 05186 int res = 0; 05187 int last_subclass = 0; 05188 struct ast_party_connected_line connected; 05189 05190 if (outstate) 05191 *outstate = 0; 05192 else 05193 outstate = &dummy_outstate; /* make outstate always a valid pointer */ 05194 05195 chan = ast_request(type, format, requestor, data, &cause); 05196 if (!chan) { 05197 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data); 05198 handle_cause(cause, outstate); 05199 return NULL; 05200 } 05201 05202 if (oh) { 05203 if (oh->vars) 05204 ast_set_variables(chan, oh->vars); 05205 /* XXX why is this necessary, for the parent_channel perhaps ? */ 05206 if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name)) 05207 ast_set_callerid(chan, oh->cid_num, oh->cid_name, oh->cid_num); 05208 if (oh->parent_channel) { 05209 ast_channel_inherit_variables(oh->parent_channel, chan); 05210 ast_channel_datastore_inherit(oh->parent_channel, chan); 05211 } 05212 if (oh->account) 05213 ast_cdr_setaccount(chan, oh->account); 05214 } 05215 05216 ast_set_callerid(chan, cid_num, cid_name, cid_num); 05217 ast_set_flag(chan->cdr, AST_CDR_FLAG_ORIGINATED); 05218 ast_party_connected_line_set_init(&connected, &chan->connected); 05219 if (cid_num) { 05220 connected.id.number.valid = 1; 05221 connected.id.number.str = (char *) cid_num; 05222 connected.id.number.presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED; 05223 } 05224 if (cid_name) { 05225 connected.id.name.valid = 1; 05226 connected.id.name.str = (char *) cid_name; 05227 connected.id.name.presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED; 05228 } 05229 ast_channel_set_connected_line(chan, &connected, NULL); 05230 05231 if (ast_call(chan, data, 0)) { /* ast_call failed... */ 05232 ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data); 05233 } else { 05234 res = 1; /* mark success in case chan->_state is already AST_STATE_UP */ 05235 while (timeout && chan->_state != AST_STATE_UP) { 05236 struct ast_frame *f; 05237 res = ast_waitfor(chan, timeout); 05238 if (res == 0) { /* timeout, treat it like ringing */ 05239 *outstate = AST_CONTROL_RINGING; 05240 break; 05241 } 05242 if (res < 0) /* error or done */ 05243 break; 05244 if (timeout > -1) 05245 timeout = res; 05246 if (!ast_strlen_zero(chan->call_forward)) { 05247 if (!(chan = ast_call_forward(NULL, chan, NULL, format, oh, outstate))) { 05248 return NULL; 05249 } 05250 continue; 05251 } 05252 05253 f = ast_read(chan); 05254 if (!f) { 05255 *outstate = AST_CONTROL_HANGUP; 05256 res = 0; 05257 break; 05258 } 05259 if (f->frametype == AST_FRAME_CONTROL) { 05260 switch (f->subclass.integer) { 05261 case AST_CONTROL_RINGING: /* record but keep going */ 05262 *outstate = f->subclass.integer; 05263 break; 05264 05265 case AST_CONTROL_BUSY: 05266 ast_cdr_busy(chan->cdr); 05267 *outstate = f->subclass.integer; 05268 timeout = 0; 05269 break; 05270 05271 case AST_CONTROL_CONGESTION: 05272 ast_cdr_failed(chan->cdr); 05273 *outstate = f->subclass.integer; 05274 timeout = 0; 05275 break; 05276 05277 case AST_CONTROL_ANSWER: 05278 ast_cdr_answer(chan->cdr); 05279 *outstate = f->subclass.integer; 05280 timeout = 0; /* trick to force exit from the while() */ 05281 break; 05282 05283 /* Ignore these */ 05284 case AST_CONTROL_PROGRESS: 05285 case AST_CONTROL_PROCEEDING: 05286 case AST_CONTROL_HOLD: 05287 case AST_CONTROL_UNHOLD: 05288 case AST_CONTROL_VIDUPDATE: 05289 case AST_CONTROL_SRCUPDATE: 05290 case AST_CONTROL_SRCCHANGE: 05291 case AST_CONTROL_CONNECTED_LINE: 05292 case AST_CONTROL_REDIRECTING: 05293 case AST_CONTROL_CC: 05294 case -1: /* Ignore -- just stopping indications */ 05295 break; 05296 05297 default: 05298 ast_log(LOG_NOTICE, "Don't know what to do with control frame %d\n", f->subclass.integer); 05299 } 05300 last_subclass = f->subclass.integer; 05301 } 05302 ast_frfree(f); 05303 } 05304 } 05305 05306 /* Final fixups */ 05307 if (oh) { 05308 if (!ast_strlen_zero(oh->context)) 05309 ast_copy_string(chan->context, oh->context, sizeof(chan->context)); 05310 if (!ast_strlen_zero(oh->exten)) 05311 ast_copy_string(chan->exten, oh->exten, sizeof(chan->exten)); 05312 if (oh->priority) 05313 chan->priority = oh->priority; 05314 } 05315 if (chan->_state == AST_STATE_UP) 05316 *outstate = AST_CONTROL_ANSWER; 05317 05318 if (res <= 0) { 05319 if ( AST_CONTROL_RINGING == last_subclass ) 05320 chan->hangupcause = AST_CAUSE_NO_ANSWER; 05321 if (!chan->cdr && (chan->cdr = ast_cdr_alloc())) 05322 ast_cdr_init(chan->cdr, chan); 05323 if (chan->cdr) { 05324 char tmp[256]; 05325 snprintf(tmp, sizeof(tmp), "%s/%s", type, (char *)data); 05326 ast_cdr_setapp(chan->cdr,"Dial",tmp); 05327 ast_cdr_update(chan); 05328 ast_cdr_start(chan->cdr); 05329 ast_cdr_end(chan->cdr); 05330 /* If the cause wasn't handled properly */ 05331 if (ast_cdr_disposition(chan->cdr,chan->hangupcause)) 05332 ast_cdr_failed(chan->cdr); 05333 } 05334 ast_hangup(chan); 05335 chan = NULL; 05336 } 05337 return chan; 05338 }
static void __init_state2str_threadbuf | ( | void | ) | [static] |
static void adjust_frame_for_plc | ( | struct ast_channel * | chan, | |
struct ast_frame * | frame, | |||
struct ast_datastore * | datastore | |||
) | [static] |
Definition at line 4604 of file channel.c.
References ast_calloc, ast_channel_datastore_remove(), ast_datastore_free(), ast_free, AST_FRIENDLY_OFFSET, chanlist::chan, ast_frame::data, ast_datastore::data, ast_frame::datalen, plc_ds::num_samples, ast_frame::offset, plc_fillin(), plc_rx(), plc_ds::plc_state, ast_frame::ptr, ast_frame::samples, and plc_ds::samples_buf.
Referenced by apply_plc().
04605 { 04606 int num_new_samples = frame->samples; 04607 struct plc_ds *plc = datastore->data; 04608 04609 /* As a general note, let me explain the somewhat odd calculations used when taking 04610 * the frame offset into account here. According to documentation in frame.h, the frame's 04611 * offset field indicates the number of bytes that the audio is offset. The plc->samples_buf 04612 * is not an array of bytes, but rather an array of 16-bit integers since it holds SLIN 04613 * samples. So I had two choices to make here with the offset. 04614 * 04615 * 1. Make the offset AST_FRIENDLY_OFFSET bytes. The main downside for this is that 04616 * I can't just add AST_FRIENDLY_OFFSET to the plc->samples_buf and have the pointer 04617 * arithmetic come out right. I would have to do some odd casting or division for this to 04618 * work as I wanted. 04619 * 2. Make the offset AST_FRIENDLY_OFFSET * 2 bytes. This allows the pointer arithmetic 04620 * to work out better with the plc->samples_buf. The downside here is that the buffer's 04621 * allocation contains an extra 64 bytes of unused space. 04622 * 04623 * I decided to go with option 2. This is why in the calloc statement and the statement that 04624 * sets the frame's offset, AST_FRIENDLY_OFFSET is multiplied by 2. 04625 */ 04626 04627 /* If this audio frame has no samples to fill in, ignore it */ 04628 if (!num_new_samples) { 04629 return; 04630 } 04631 04632 /* First, we need to be sure that our buffer is large enough to accomodate 04633 * the samples we need to fill in. This will likely only occur on the first 04634 * frame we write. 04635 */ 04636 if (plc->num_samples < num_new_samples) { 04637 ast_free(plc->samples_buf); 04638 plc->samples_buf = ast_calloc(1, (num_new_samples * sizeof(*plc->samples_buf)) + (AST_FRIENDLY_OFFSET * 2)); 04639 if (!plc->samples_buf) { 04640 ast_channel_datastore_remove(chan, datastore); 04641 ast_datastore_free(datastore); 04642 return; 04643 } 04644 plc->num_samples = num_new_samples; 04645 } 04646 04647 if (frame->datalen == 0) { 04648 plc_fillin(&plc->plc_state, plc->samples_buf + AST_FRIENDLY_OFFSET, frame->samples); 04649 frame->data.ptr = plc->samples_buf + AST_FRIENDLY_OFFSET; 04650 frame->datalen = num_new_samples * 2; 04651 frame->offset = AST_FRIENDLY_OFFSET * 2; 04652 } else { 04653 plc_rx(&plc->plc_state, frame->data.ptr, frame->samples); 04654 } 04655 }
static void apply_plc | ( | struct ast_channel * | chan, | |
struct ast_frame * | frame | |||
) | [static] |
Definition at line 4657 of file channel.c.
References adjust_frame_for_plc(), ast_calloc, ast_channel_datastore_add(), ast_channel_datastore_find(), ast_datastore_alloc, ast_datastore_free(), chanlist::chan, ast_datastore::data, and plc_ds_info.
Referenced by ast_write().
04658 { 04659 struct ast_datastore *datastore; 04660 struct plc_ds *plc; 04661 04662 datastore = ast_channel_datastore_find(chan, &plc_ds_info, NULL); 04663 if (datastore) { 04664 plc = datastore->data; 04665 adjust_frame_for_plc(chan, frame, datastore); 04666 return; 04667 } 04668 04669 datastore = ast_datastore_alloc(&plc_ds_info, NULL); 04670 if (!datastore) { 04671 return; 04672 } 04673 plc = ast_calloc(1, sizeof(*plc)); 04674 if (!plc) { 04675 ast_datastore_free(datastore); 04676 return; 04677 } 04678 datastore->data = plc; 04679 ast_channel_datastore_add(chan, datastore); 04680 adjust_frame_for_plc(chan, frame, datastore); 04681 }
int ast_activate_generator | ( | struct ast_channel * | chan, | |
struct ast_generator * | gen, | |||
void * | params | |||
) |
Activate a given generator
Definition at line 3001 of file channel.c.
References ast_generator::alloc, ast_channel_lock, ast_channel_unlock, ast_prod(), ast_settimeout(), chanlist::chan, gen, ast_channel::generator, generator_force(), ast_channel::generatordata, and ast_generator::release.
Referenced by ast_channel_start_silence_generator(), ast_linear_stream(), ast_playtones_start(), ast_tonepair_start(), channel_spy(), eivr_comm(), old_milliwatt_exec(), and transmit_audio().
03002 { 03003 int res = 0; 03004 03005 ast_channel_lock(chan); 03006 if (chan->generatordata) { 03007 if (chan->generator && chan->generator->release) 03008 chan->generator->release(chan, chan->generatordata); 03009 chan->generatordata = NULL; 03010 } 03011 if (gen->alloc && !(chan->generatordata = gen->alloc(chan, params))) { 03012 res = -1; 03013 } 03014 if (!res) { 03015 ast_settimeout(chan, 50, generator_force, chan); 03016 chan->generator = gen; 03017 } 03018 ast_channel_unlock(chan); 03019 03020 ast_prod(chan); 03021 03022 return res; 03023 }
int ast_active_channels | ( | void | ) |
returns number of active/allocated channels
Definition at line 783 of file channel.c.
References ao2_container_count(), and channels.
Referenced by action_corestatus(), ast_var_channels(), ast_var_channels_table(), handle_chanlist(), handle_show_settings(), and quit_handler().
00784 { 00785 return channels ? ao2_container_count(channels) : 0; 00786 }
int ast_answer | ( | struct ast_channel * | chan | ) |
Answer a channel.
chan | channel to answer |
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.
0 | on success | |
non-zero | on failure |
Definition at line 2951 of file channel.c.
References __ast_answer(), and chanlist::chan.
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(), common_exec(), conf_exec(), count_exec(), dahdiras_exec(), dial_exec_full(), 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(), parkcall_helper(), pbx_builtin_background(), pickup_do(), playback_exec(), privacy_exec(), read_exec(), readexten_exec(), receivefax_exec(), rpt_exec(), sayunixtime_exec(), send_waveform_to_channel(), sendfax_exec(), setup_privacy_args(), skel_exec(), sla_station_exec(), speech_background(), testclient_exec(), testserver_exec(), transmit(), vm_exec(), vm_execmain(), waitfor_exec(), and zapateller_exec().
02952 { 02953 return __ast_answer(chan, 0, 1); 02954 }
void ast_begin_shutdown | ( | int | hangup | ) |
Initiate system shutdown -- prevents new channels from being allocated.
hangup | If "hangup" is non-zero, all existing channels will receive soft hangups |
Definition at line 773 of file channel.c.
References ao2_callback, ast_channel_softhangup_cb(), channels, OBJ_MULTIPLE, and OBJ_NODATA.
Referenced by quit_handler().
00774 { 00775 shutting_down = 1; 00776 00777 if (hangup) { 00778 ao2_callback(channels, OBJ_NODATA | OBJ_MULTIPLE, ast_channel_softhangup_cb, NULL); 00779 } 00780 }
Pick the best audio codec.
Pick the best codec Choose the best codec... Uhhh... Yah.
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 992 of file channel.c.
References ARRAY_LEN, AST_FORMAT_ADPCM, AST_FORMAT_ALAW, AST_FORMAT_AUDIO_MASK, AST_FORMAT_G719, 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_SIREN14, AST_FORMAT_SIREN7, AST_FORMAT_SLINEAR, AST_FORMAT_SLINEAR16, AST_FORMAT_SPEEX, AST_FORMAT_SPEEX16, AST_FORMAT_TESTLAW, AST_FORMAT_ULAW, ast_getformatname_multiple(), ast_log(), LOG_WARNING, and prefs.
Referenced by __oh323_new(), agent_call(), ast_codec_choose(), ast_iax2_new(), ast_speech_new(), bridge_make_compatible(), builtin_atxfer(), echo_exec(), findmeexec(), gtalk_new(), handle_open_receive_channel_ack_message(), iax2_request(), jingle_new(), local_new(), login_exec(), mgcp_new(), multicast_rtp_request(), set_format(), sip_new(), skinny_new(), skinny_set_rtp_peer(), socket_process(), start_rtp(), transmit_connect(), and unistim_new().
00993 { 00994 /* This just our opinion, expressed in code. We are asked to choose 00995 the best codec to use, given no information */ 00996 int x; 00997 static const format_t prefs[] = 00998 { 00999 /*! Okay, ulaw is used by all telephony equipment, so start with it */ 01000 AST_FORMAT_ULAW, 01001 /*! Unless of course, you're a silly European, so then prefer ALAW */ 01002 AST_FORMAT_ALAW, 01003 AST_FORMAT_G719, 01004 AST_FORMAT_SIREN14, 01005 AST_FORMAT_SIREN7, 01006 AST_FORMAT_TESTLAW, 01007 /*! G.722 is better then all below, but not as common as the above... so give ulaw and alaw priority */ 01008 AST_FORMAT_G722, 01009 /*! Okay, well, signed linear is easy to translate into other stuff */ 01010 AST_FORMAT_SLINEAR16, 01011 AST_FORMAT_SLINEAR, 01012 /*! G.726 is standard ADPCM, in RFC3551 packing order */ 01013 AST_FORMAT_G726, 01014 /*! G.726 is standard ADPCM, in AAL2 packing order */ 01015 AST_FORMAT_G726_AAL2, 01016 /*! ADPCM has great sound quality and is still pretty easy to translate */ 01017 AST_FORMAT_ADPCM, 01018 /*! Okay, we're down to vocoders now, so pick GSM because it's small and easier to 01019 translate and sounds pretty good */ 01020 AST_FORMAT_GSM, 01021 /*! iLBC is not too bad */ 01022 AST_FORMAT_ILBC, 01023 /*! Speex is free, but computationally more expensive than GSM */ 01024 AST_FORMAT_SPEEX16, 01025 AST_FORMAT_SPEEX, 01026 /*! Ick, LPC10 sounds terrible, but at least we have code for it, if you're tacky enough 01027 to use it */ 01028 AST_FORMAT_LPC10, 01029 /*! G.729a is faster than 723 and slightly less expensive */ 01030 AST_FORMAT_G729A, 01031 /*! Down to G.723.1 which is proprietary but at least designed for voice */ 01032 AST_FORMAT_G723_1, 01033 }; 01034 char buf[512]; 01035 01036 /* Strip out video */ 01037 fmts &= AST_FORMAT_AUDIO_MASK; 01038 01039 /* Find the first preferred codec in the format given */ 01040 for (x = 0; x < ARRAY_LEN(prefs); x++) { 01041 if (fmts & prefs[x]) 01042 return prefs[x]; 01043 } 01044 01045 ast_log(LOG_WARNING, "Don't know any of %s formats\n", ast_getformatname_multiple(buf, sizeof(buf), fmts)); 01046 01047 return 0; 01048 }
struct ast_channel* ast_bridged_channel | ( | struct ast_channel * | chan | ) |
Find bridged channel.
chan | Current channel |
Definition at line 6704 of file channel.c.
References ast_channel::_bridge, ast_channel_tech::bridged_channel, chanlist::chan, and ast_channel::tech.
Referenced by __analog_handle_event(), __analog_ss_thread(), __ast_channel_masquerade(), __ast_read(), __dahdi_exception(), _skinny_show_lines(), action_agents(), action_coreshowchannels(), agents_data_provider_get(), agents_show(), agents_show_online(), analog_attempt_transfer(), analog_exception(), analog_hangup(), analog_ss_thread(), ast_bridge_call(), ast_cel_report_event(), ast_channel_data_add_structure(), ast_channel_set_linkgroup(), ast_do_masquerade(), ast_rtp_instance_set_stats_vars(), ast_set_hangupsource(), ast_var_channel_bridge(), ast_var_channels_table(), attempt_transfer(), cb_events(), channel_spy(), check_bridge(), common_exec(), console_transfer(), create_jb(), dahdi_handle_event(), dahdi_hangup(), export_aoc_vars(), func_channel_read(), 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(), local_queryoption(), mgcp_hangup(), mgcp_ss(), misdn_attempt_transfer(), mixmonitor_thread(), my_get_sigpvt_bridged_channel(), park_call_full(), schedule_delivery(), sig_pri_attempt_transfer(), sig_pri_handle_hold(), sip_hangup(), sip_set_rtp_peer(), skinny_transfer(), socket_process(), start_spying(), startmon(), TransferCallStep1(), and unistim_hangup().
06705 { 06706 struct ast_channel *bridged; 06707 bridged = chan->_bridge; 06708 if (bridged && bridged->tech->bridged_channel) 06709 bridged = bridged->tech->bridged_channel(chan, bridged); 06710 return bridged; 06711 }
int ast_call | ( | struct ast_channel * | chan, | |
char * | addr, | |||
int | timeout | |||
) |
Make a call.
chan | which channel to make the call on | |
addr | destination of the call | |
timeout | time to wait on for connect |
Definition at line 5451 of file channel.c.
References AST_CDR_FLAG_DIALED, ast_channel_lock, ast_channel_unlock, ast_check_hangup(), AST_FLAG_OUTGOING, AST_FLAG_ZOMBIE, ast_set_flag, ast_test_flag, ast_channel_tech::call, ast_channel::cdr, chanlist::chan, and ast_channel::tech.
Referenced by __ast_request_and_dial(), ast_call_forward(), attempt_reconnect(), begin_dial_channel(), connect_link(), dial_exec_full(), dial_transfer(), do_forward(), do_idle_thread(), feature_request_and_dial(), findmeexec(), play_sound_file(), ring_entry(), and rpt().
05452 { 05453 /* Place an outgoing call, but don't wait any longer than timeout ms before returning. 05454 If the remote end does not answer within the timeout, then do NOT hang up, but 05455 return anyway. */ 05456 int res = -1; 05457 /* Stop if we're a zombie or need a soft hangup */ 05458 ast_channel_lock(chan); 05459 if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) { 05460 if (chan->cdr) { 05461 ast_set_flag(chan->cdr, AST_CDR_FLAG_DIALED); 05462 } 05463 if (chan->tech->call) 05464 res = chan->tech->call(chan, addr, timeout); 05465 ast_set_flag(chan, AST_FLAG_OUTGOING); 05466 } 05467 ast_channel_unlock(chan); 05468 return res; 05469 }
struct ast_channel* ast_call_forward | ( | struct ast_channel * | caller, | |
struct ast_channel * | orig, | |||
int * | timeout, | |||
format_t | 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.
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) |
Definition at line 5100 of file channel.c.
References outgoing_helper::account, ast_channel::accountcode, accountcode, ast_call(), AST_CDR_FLAG_ORIGINATED, ast_cdr_setaccount(), ast_channel_datastore_inherit(), ast_channel_inherit_variables(), ast_channel_lock, ast_channel_set_redirecting(), ast_channel_trylock, ast_channel_unlock, ast_channel_update_redirecting(), ast_copy_flags, ast_copy_string(), ast_hangup(), ast_log(), ast_party_caller_copy(), ast_party_connected_line_copy(), ast_request(), ast_set_callerid(), ast_set_variables(), ast_string_field_set, ast_strlen_zero(), ast_channel::call_forward, ast_channel::caller, cause, ast_channel::cdr, CHANNEL_DEADLOCK_AVOIDANCE, outgoing_helper::cid_name, outgoing_helper::cid_num, ast_channel::connected, ast_channel::context, handle_cause(), LOG_NOTICE, outgoing_helper::parent_channel, pbx_builtin_getvar_helper(), ast_channel::redirecting, S_OR, type, and outgoing_helper::vars.
Referenced by __ast_request_and_dial(), and feature_request_and_dial().
05101 { 05102 char tmpchan[256]; 05103 struct ast_channel *new = NULL; 05104 struct ast_party_redirecting *apr = &orig->redirecting; 05105 char *data, *type; 05106 int cause = 0; 05107 int res; 05108 05109 /* gather data and request the new forward channel */ 05110 ast_copy_string(tmpchan, orig->call_forward, sizeof(tmpchan)); 05111 if ((data = strchr(tmpchan, '/'))) { 05112 *data++ = '\0'; 05113 type = tmpchan; 05114 } else { 05115 const char *forward_context; 05116 ast_channel_lock(orig); 05117 forward_context = pbx_builtin_getvar_helper(orig, "FORWARD_CONTEXT"); 05118 snprintf(tmpchan, sizeof(tmpchan), "%s@%s", orig->call_forward, S_OR(forward_context, orig->context)); 05119 ast_channel_unlock(orig); 05120 data = tmpchan; 05121 type = "Local"; 05122 } 05123 if (!(new = ast_request(type, format, orig, data, &cause))) { 05124 ast_log(LOG_NOTICE, "Unable to create channel for call forward to '%s/%s' (cause = %d)\n", type, data, cause); 05125 handle_cause(cause, outstate); 05126 ast_hangup(orig); 05127 return NULL; 05128 } 05129 05130 ast_channel_set_redirecting(new, apr, NULL); 05131 05132 /* Copy/inherit important information into new channel */ 05133 if (oh) { 05134 if (oh->vars) { 05135 ast_set_variables(new, oh->vars); 05136 } 05137 if (!ast_strlen_zero(oh->cid_num) && !ast_strlen_zero(oh->cid_name)) { 05138 ast_set_callerid(new, oh->cid_num, oh->cid_name, oh->cid_num); 05139 } 05140 if (oh->parent_channel) { 05141 ast_channel_update_redirecting(oh->parent_channel, apr, NULL); 05142 ast_channel_inherit_variables(oh->parent_channel, new); 05143 ast_channel_datastore_inherit(oh->parent_channel, new); 05144 } 05145 if (oh->account) { 05146 ast_cdr_setaccount(new, oh->account); 05147 } 05148 } else if (caller) { /* no outgoing helper so use caller if avaliable */ 05149 ast_channel_update_redirecting(caller, apr, NULL); 05150 ast_channel_inherit_variables(caller, new); 05151 ast_channel_datastore_inherit(caller, new); 05152 } 05153 05154 ast_channel_lock(orig); 05155 while (ast_channel_trylock(new)) { 05156 CHANNEL_DEADLOCK_AVOIDANCE(orig); 05157 } 05158 ast_copy_flags(new->cdr, orig->cdr, AST_CDR_FLAG_ORIGINATED); 05159 ast_string_field_set(new, accountcode, orig->accountcode); 05160 ast_party_caller_copy(&new->caller, &orig->caller); 05161 ast_party_connected_line_copy(&new->connected, &orig->connected); 05162 ast_channel_unlock(new); 05163 ast_channel_unlock(orig); 05164 05165 /* call new channel */ 05166 res = ast_call(new, data, 0); 05167 if (timeout) { 05168 *timeout = res; 05169 } 05170 if (res) { 05171 ast_log(LOG_NOTICE, "Unable to call forward to channel %s/%s\n", type, (char *)data); 05172 ast_hangup(orig); 05173 ast_hangup(new); 05174 return NULL; 05175 } 05176 ast_hangup(orig); 05177 05178 return new; 05179 }
void ast_cancel_shutdown | ( | void | ) |
Cancel a shutdown in progress.
Cancels an existing shutdown and returns to normal operation
Definition at line 789 of file channel.c.
Referenced by handle_abort_shutdown().
00790 { 00791 shutting_down = 0; 00792 }
const char* ast_cause2str | ( | int | state | ) |
Gives the string form of a given cause code.
state | cause to get the description of |
Definition at line 910 of file channel.c.
References ARRAY_LEN, and causes.
Referenced by __transmit_response(), ast_channel_data_add_structure(), ast_do_masquerade(), ast_hangup(), dial_exec_full(), findmeexec(), sip_hangup(), and transmit_request_with_auth().
00911 { 00912 int x; 00913 00914 for (x = 0; x < ARRAY_LEN(causes); x++) { 00915 if (causes[x].cause == cause) 00916 return causes[x].desc; 00917 } 00918 00919 return "Unknown"; 00920 }
void ast_change_name | ( | struct ast_channel * | chan, | |
const char * | newname | |||
) |
Change channel name.
chan | the channel to change the name of | |
newname | the name to change to |
Definition at line 5886 of file channel.c.
References __ast_change_name_nolink(), ao2_link, ao2_unlink, ast_channel_lock, ast_channel_unlock, chanlist::chan, and channels.
Referenced by update_name().
05887 { 05888 /* We must re-link, as the hash value will change here. */ 05889 ao2_unlink(channels, chan); 05890 ast_channel_lock(chan); 05891 __ast_change_name_nolink(chan, newname); 05892 ast_channel_unlock(chan); 05893 ao2_link(channels, chan); 05894 }
struct ast_channel * 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 char * | linkedid, | |||
const int | amaflag, | |||
const char * | name_fmt, | |||
... | ||||
) |
Definition at line 9286 of file channel.c.
References __ast_channel_alloc_ap().
09291 { 09292 va_list ap1, ap2; 09293 struct ast_channel *result; 09294 09295 09296 va_start(ap1, name_fmt); 09297 va_start(ap2, name_fmt); 09298 result = __ast_channel_alloc_ap(needqueue, state, cid_num, cid_name, acctcode, exten, context, 09299 linkedid, amaflag, __FILE__, __LINE__, __FUNCTION__, name_fmt, ap1, ap2); 09300 va_end(ap1); 09301 va_end(ap2); 09302 09303 return result; 09304 }
enum ast_bridge_result ast_channel_bridge | ( | struct ast_channel * | c0, | |
struct ast_channel * | c1, | |||
struct ast_bridge_config * | config, | |||
struct ast_frame ** | fo, | |||
struct ast_channel ** | rc | |||
) |
Bridge two channels together.
c0 | first channel to bridge | |
c1 | second channel to bridge | |
config | config for the channels | |
fo | destination frame(?) | |
rc | destination channel(?) |
Definition at line 7047 of file channel.c.
References ast_channel::_bridge, ast_channel::_softhangup, AST_BRIDGE_COMPLETE, AST_BRIDGE_FAILED, AST_BRIDGE_FAILED_NOWARN, AST_BRIDGE_RETRY, ast_channel_clear_softhangup(), ast_channel_make_compatible(), ast_check_hangup(), ast_check_hangup_locked(), ast_clear_flag, AST_CONTROL_SRCUPDATE, ast_debug, AST_FEATURE_PLAY_WARNING, AST_FEATURE_WARNING_ACTIVE, AST_FLAG_END_DTMF_ONLY, AST_FLAG_NBRIDGE, AST_FLAG_ZOMBIE, ast_generic_bridge(), ast_indicate(), ast_log(), ast_manager_event_multichan, ast_samp2tv(), ast_set_flag, ast_set_owners_and_peers(), AST_SOFTHANGUP_UNBRIDGE, ast_test_flag, ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), ast_tvsub(), ast_tvzero(), ast_verb, ast_channel::audiohooks, ast_channel_tech::bridge, bridge_play_sounds(), bridge_playfile(), ast_channel::caller, config, EVENT_FLAG_CALL, ast_channel::generator, ast_party_caller::id, LOG_WARNING, manager_bridge_event(), ast_channel::masq, ast_channel::masqr, ast_channel::monitor, ast_channel::name, ast_channel::nativeformats, ast_party_id::number, ast_channel::readformat, S_COR, ast_channel_tech::send_digit_begin, ast_party_number::str, ast_channel::tech, ast_channel::uniqueid, update_bridge_vars(), ast_party_number::valid, and ast_channel::writeformat.
Referenced by ast_bridge_call().
07049 { 07050 struct ast_channel *chans[2] = { c0, c1 }; 07051 enum ast_bridge_result res = AST_BRIDGE_COMPLETE; 07052 format_t o0nativeformats; 07053 format_t o1nativeformats; 07054 long time_left_ms=0; 07055 char caller_warning = 0; 07056 char callee_warning = 0; 07057 07058 if (c0->_bridge) { 07059 ast_log(LOG_WARNING, "%s is already in a bridge with %s\n", 07060 c0->name, c0->_bridge->name); 07061 return -1; 07062 } 07063 if (c1->_bridge) { 07064 ast_log(LOG_WARNING, "%s is already in a bridge with %s\n", 07065 c1->name, c1->_bridge->name); 07066 return -1; 07067 } 07068 07069 /* Stop if we're a zombie or need a soft hangup */ 07070 if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) || 07071 ast_test_flag(c1, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c1)) 07072 return -1; 07073 07074 *fo = NULL; 07075 07076 if (ast_tvzero(config->start_time)) { 07077 config->start_time = ast_tvnow(); 07078 if (config->start_sound) { 07079 if (caller_warning) { 07080 bridge_playfile(c0, c1, config->start_sound, config->timelimit / 1000); 07081 } 07082 if (callee_warning) { 07083 bridge_playfile(c1, c0, config->start_sound, config->timelimit / 1000); 07084 } 07085 } 07086 } 07087 07088 /* Keep track of bridge */ 07089 c0->_bridge = c1; 07090 c1->_bridge = c0; 07091 07092 ast_set_owners_and_peers(c0, c1); 07093 07094 o0nativeformats = c0->nativeformats; 07095 o1nativeformats = c1->nativeformats; 07096 07097 if (config->feature_timer && !ast_tvzero(config->nexteventts)) { 07098 config->nexteventts = ast_tvadd(config->feature_start_time, ast_samp2tv(config->feature_timer, 1000)); 07099 } else if (config->timelimit) { 07100 time_left_ms = config->timelimit - ast_tvdiff_ms(ast_tvnow(), config->start_time); 07101 caller_warning = ast_test_flag(&config->features_caller, AST_FEATURE_PLAY_WARNING); 07102 callee_warning = ast_test_flag(&config->features_callee, AST_FEATURE_PLAY_WARNING); 07103 config->nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000)); 07104 if ((caller_warning || callee_warning) && config->play_warning) { 07105 long next_warn = config->play_warning; 07106 if (time_left_ms < config->play_warning) { 07107 /* At least one warning was played, which means we are returning after feature */ 07108 long warns_passed = (config->play_warning - time_left_ms) / config->warning_freq; 07109 /* It is 'warns_passed * warning_freq' NOT '(warns_passed + 1) * warning_freq', 07110 because nexteventts will be updated once again in the 'if (!to)' block */ 07111 next_warn = config->play_warning - warns_passed * config->warning_freq; 07112 } 07113 config->nexteventts = ast_tvsub(config->nexteventts, ast_samp2tv(next_warn, 1000)); 07114 } 07115 } else { 07116 config->nexteventts.tv_sec = 0; 07117 config->nexteventts.tv_usec = 0; 07118 } 07119 07120 if (!c0->tech->send_digit_begin) 07121 ast_set_flag(c1, AST_FLAG_END_DTMF_ONLY); 07122 if (!c1->tech->send_digit_begin) 07123 ast_set_flag(c0, AST_FLAG_END_DTMF_ONLY); 07124 manager_bridge_event(1, 1, c0, c1); 07125 07126 /* Before we enter in and bridge these two together tell them both the source of audio has changed */ 07127 ast_indicate(c0, AST_CONTROL_SRCUPDATE); 07128 ast_indicate(c1, AST_CONTROL_SRCUPDATE); 07129 07130 for (/* ever */;;) { 07131 struct timeval now = { 0, }; 07132 int to; 07133 07134 to = -1; 07135 07136 if (!ast_tvzero(config->nexteventts)) { 07137 now = ast_tvnow(); 07138 to = ast_tvdiff_ms(config->nexteventts, now); 07139 if (to <= 0) { 07140 if (!config->timelimit) { 07141 res = AST_BRIDGE_COMPLETE; 07142 break; 07143 } 07144 to = 0; 07145 } 07146 } 07147 07148 if (config->timelimit) { 07149 time_left_ms = config->timelimit - ast_tvdiff_ms(now, config->start_time); 07150 if (time_left_ms < to) 07151 to = time_left_ms; 07152 07153 if (time_left_ms <= 0) { 07154 if (caller_warning && config->end_sound) 07155 bridge_playfile(c0, c1, config->end_sound, 0); 07156 if (callee_warning && config->end_sound) 07157 bridge_playfile(c1, c0, config->end_sound, 0); 07158 *fo = NULL; 07159 res = 0; 07160 break; 07161 } 07162 07163 if (!to) { 07164 if (time_left_ms >= 5000 && config->warning_sound && config->play_warning && ast_test_flag(config, AST_FEATURE_WARNING_ACTIVE)) { 07165 int t = (time_left_ms + 500) / 1000; /* round to nearest second */ 07166 if (caller_warning) 07167 bridge_playfile(c0, c1, config->warning_sound, t); 07168 if (callee_warning) 07169 bridge_playfile(c1, c0, config->warning_sound, t); 07170 } 07171 07172 if (config->warning_freq && (time_left_ms > (config->warning_freq + 5000))) { 07173 config->nexteventts = ast_tvadd(config->nexteventts, ast_samp2tv(config->warning_freq, 1000)); 07174 } else { 07175 config->nexteventts = ast_tvadd(config->start_time, ast_samp2tv(config->timelimit, 1000)); 07176 } 07177 } 07178 ast_clear_flag(config, AST_FEATURE_WARNING_ACTIVE); 07179 } 07180 07181 if ((c0->_softhangup | c1->_softhangup) & AST_SOFTHANGUP_UNBRIDGE) {/* Bit operators are intentional. */ 07182 if (c0->_softhangup & AST_SOFTHANGUP_UNBRIDGE) { 07183 ast_channel_clear_softhangup(c0, AST_SOFTHANGUP_UNBRIDGE); 07184 } 07185 if (c1->_softhangup & AST_SOFTHANGUP_UNBRIDGE) { 07186 ast_channel_clear_softhangup(c1, AST_SOFTHANGUP_UNBRIDGE); 07187 } 07188 c0->_bridge = c1; 07189 c1->_bridge = c0; 07190 ast_debug(1, "Unbridge signal received. Ending native bridge.\n"); 07191 continue; 07192 } 07193 07194 /* Stop if we're a zombie or need a soft hangup */ 07195 if (ast_test_flag(c0, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c0) || 07196 ast_test_flag(c1, AST_FLAG_ZOMBIE) || ast_check_hangup_locked(c1)) { 07197 *fo = NULL; 07198 res = 0; 07199 ast_debug(1, "Bridge stops because we're zombie or need a soft hangup: c0=%s, c1=%s, flags: %s,%s,%s,%s\n", 07200 c0->name, c1->name, 07201 ast_test_flag(c0, AST_FLAG_ZOMBIE) ? "Yes" : "No", 07202 ast_check_hangup(c0) ? "Yes" : "No", 07203 ast_test_flag(c1, AST_FLAG_ZOMBIE) ? "Yes" : "No", 07204 ast_check_hangup(c1) ? "Yes" : "No"); 07205 break; 07206 } 07207 07208 update_bridge_vars(c0, c1); 07209 07210 bridge_play_sounds(c0, c1); 07211 07212 if (c0->tech->bridge && 07213 /* if < 1 ms remains use generic bridging for accurate timing */ 07214 (!config->timelimit || to > 1000 || to == 0) && 07215 (c0->tech->bridge == c1->tech->bridge) && 07216 !c0->monitor && !c1->monitor && 07217 !c0->audiohooks && !c1->audiohooks && 07218 !c0->masq && !c0->masqr && !c1->masq && !c1->masqr) { 07219 int timeoutms = to - 1000 > 0 ? to - 1000 : to; 07220 /* Looks like they share a bridge method and nothing else is in the way */ 07221 ast_set_flag(c0, AST_FLAG_NBRIDGE); 07222 ast_set_flag(c1, AST_FLAG_NBRIDGE); 07223 if ((res = c0->tech->bridge(c0, c1, config->flags, fo, rc, timeoutms)) == AST_BRIDGE_COMPLETE) { 07224 ast_manager_event_multichan(EVENT_FLAG_CALL, "Unlink", 2, chans, 07225 "Channel1: %s\r\n" 07226 "Channel2: %s\r\n" 07227 "Uniqueid1: %s\r\n" 07228 "Uniqueid2: %s\r\n" 07229 "CallerID1: %s\r\n" 07230 "CallerID2: %s\r\n", 07231 c0->name, c1->name, 07232 c0->uniqueid, c1->uniqueid, 07233 S_COR(c0->caller.id.number.valid, c0->caller.id.number.str, "<unknown>"), 07234 S_COR(c1->caller.id.number.valid, c1->caller.id.number.str, "<unknown>")); 07235 07236 ast_debug(1, "Returning from native bridge, channels: %s, %s\n", c0->name, c1->name); 07237 07238 ast_clear_flag(c0, AST_FLAG_NBRIDGE); 07239 ast_clear_flag(c1, AST_FLAG_NBRIDGE); 07240 07241 if ((c0->_softhangup | c1->_softhangup) & AST_SOFTHANGUP_UNBRIDGE) {/* Bit operators are intentional. */ 07242 continue; 07243 } 07244 07245 c0->_bridge = NULL; 07246 c1->_bridge = NULL; 07247 return res; 07248 } else { 07249 ast_clear_flag(c0, AST_FLAG_NBRIDGE); 07250 ast_clear_flag(c1, AST_FLAG_NBRIDGE); 07251 } 07252 switch (res) { 07253 case AST_BRIDGE_RETRY: 07254 if (config->play_warning) { 07255 ast_set_flag(config, AST_FEATURE_WARNING_ACTIVE); 07256 } 07257 continue; 07258 default: 07259 ast_verb(3, "Native bridging %s and %s ended\n", c0->name, c1->name); 07260 /* fallthrough */ 07261 case AST_BRIDGE_FAILED_NOWARN: 07262 break; 07263 } 07264 } 07265 07266 if (((c0->writeformat != c1->readformat) || (c0->readformat != c1->writeformat) || 07267 (c0->nativeformats != o0nativeformats) || (c1->nativeformats != o1nativeformats)) && 07268 !(c0->generator || c1->generator)) { 07269 if (ast_channel_make_compatible(c0, c1)) { 07270 ast_log(LOG_WARNING, "Can't make %s and %s compatible\n", c0->name, c1->name); 07271 manager_bridge_event(0, 1, c0, c1); 07272 return AST_BRIDGE_FAILED; 07273 } 07274 o0nativeformats = c0->nativeformats; 07275 o1nativeformats = c1->nativeformats; 07276 } 07277 07278 update_bridge_vars(c0, c1); 07279 07280 res = ast_generic_bridge(c0, c1, config, fo, rc); 07281 if (res != AST_BRIDGE_RETRY) { 07282 break; 07283 } else if (config->feature_timer) { 07284 /* feature timer expired but has not been updated, sending to ast_bridge_call to do so */ 07285 break; 07286 } 07287 } 07288 07289 ast_clear_flag(c0, AST_FLAG_END_DTMF_ONLY); 07290 ast_clear_flag(c1, AST_FLAG_END_DTMF_ONLY); 07291 07292 /* Now that we have broken the bridge the source will change yet again */ 07293 ast_indicate(c0, AST_CONTROL_SRCUPDATE); 07294 ast_indicate(c1, AST_CONTROL_SRCUPDATE); 07295 07296 c0->_bridge = NULL; 07297 c1->_bridge = NULL; 07298 07299 ast_manager_event_multichan(EVENT_FLAG_CALL, "Unlink", 2, chans, 07300 "Channel1: %s\r\n" 07301 "Channel2: %s\r\n" 07302 "Uniqueid1: %s\r\n" 07303 "Uniqueid2: %s\r\n" 07304 "CallerID1: %s\r\n" 07305 "CallerID2: %s\r\n", 07306 c0->name, c1->name, 07307 c0->uniqueid, c1->uniqueid, 07308 S_COR(c0->caller.id.number.valid, c0->caller.id.number.str, "<unknown>"), 07309 S_COR(c1->caller.id.number.valid, c1->caller.id.number.str, "<unknown>")); 07310 ast_debug(1, "Bridge stops bridging channels %s and %s\n", c0->name, c1->name); 07311 07312 return res; 07313 }
struct ast_channel* ast_channel_callback | ( | ao2_callback_data_fn * | cb_fn, | |
void * | arg, | |||
void * | data, | |||
int | ao2_flags | |||
) |
Call a function with every active channel.
This function executes a callback one time for each active channel on the system. The channel is provided as an argument to the function.
Definition at line 1544 of file channel.c.
References ao2_callback_data, and channels.
Referenced by ast_cel_check_retire_linkedid(), ast_pickup_call(), handle_core_set_debug_channel(), my_ast_get_channel_by_name_locked(), pickup_by_mark(), pickup_by_part(), and state_notify_build_xml().
01546 { 01547 return ao2_callback_data(channels, ao2_flags, cb_fn, arg, data); 01548 }
int ast_channel_cc_params_init | ( | struct ast_channel * | chan, | |
const struct ast_cc_config_params * | base_params | |||
) |
Set up datastore with CCSS parameters for a channel.
chan | The channel to create the datastore on | |
base_params | CCSS parameters we wish to copy into the channel |
0 | Success | |
-1 | Failure |
Definition at line 9192 of file channel.c.
References ast_cc_config_params_destroy(), ast_cc_config_params_init, ast_cc_copy_config_params(), ast_channel_datastore_add(), ast_datastore_alloc, cc_channel_datastore_info, and ast_datastore::data.
Referenced by ast_channel_get_cc_config_params(), dahdi_new(), local_call(), local_request(), and sip_new().
09194 { 09195 struct ast_cc_config_params *cc_params; 09196 struct ast_datastore *cc_datastore; 09197 09198 if (!(cc_params = ast_cc_config_params_init())) { 09199 return -1; 09200 } 09201 09202 if (!(cc_datastore = ast_datastore_alloc(&cc_channel_datastore_info, NULL))) { 09203 ast_cc_config_params_destroy(cc_params); 09204 return -1; 09205 } 09206 09207 if (base_params) { 09208 ast_cc_copy_config_params(cc_params, base_params); 09209 } 09210 cc_datastore->data = cc_params; 09211 ast_channel_datastore_add(chan, cc_datastore); 09212 return 0; 09213 }
static void ast_channel_change_linkedid | ( | struct ast_channel * | chan, | |
const char * | linkedid | |||
) | [static] |
Set the channel's linkedid to the given string, and also check to see if the channel's old linkedid is now being retired
Definition at line 6025 of file channel.c.
References ast_cel_check_retire_linkedid(), ast_string_field_set, ast_strlen_zero(), chanlist::chan, and ast_channel::linkedid.
Referenced by ast_channel_set_linkgroup().
06026 { 06027 /* if the linkedid for this channel is being changed from something, check... */ 06028 if (!ast_strlen_zero(chan->linkedid) && 0 != strcmp(chan->linkedid, linkedid)) { 06029 ast_cel_check_retire_linkedid(chan); 06030 } 06031 06032 ast_string_field_set(chan, linkedid, linkedid); 06033 }
void ast_channel_clear_softhangup | ( | struct ast_channel * | chan, | |
int | flag | |||
) |
Clear a set of softhangup flags from a channel.
Never clear a softhangup flag from a channel directly. Instead, use this function. This ensures that all aspects of the softhangup process are aborted.
chan | the channel to clear the flag on | |
flag | the flag or flags to clear |
Definition at line 2602 of file channel.c.
References ast_channel::_softhangup, ast_channel_lock, ast_channel_unlock, AST_CONTROL_END_OF_Q, AST_FRAME_CONTROL, ast_frfree, AST_LIST_LAST, AST_LIST_REMOVE, chanlist::chan, ast_frame::frametype, ast_frame_subclass::integer, ast_channel::readq, and ast_frame::subclass.
Referenced by __ast_pbx_run(), ast_channel_bridge(), check_goto_on_transfer(), and collect_digits().
02603 { 02604 ast_channel_lock(chan); 02605 02606 chan->_softhangup &= ~flag; 02607 02608 if (!chan->_softhangup) { 02609 struct ast_frame *fr; 02610 02611 /* If we have completely cleared the softhangup flag, 02612 * then we need to fully abort the hangup process. This requires 02613 * pulling the END_OF_Q frame out of the channel frame queue if it 02614 * still happens to be there. */ 02615 02616 fr = AST_LIST_LAST(&chan->readq); 02617 if (fr && fr->frametype == AST_FRAME_CONTROL && 02618 fr->subclass.integer == AST_CONTROL_END_OF_Q) { 02619 AST_LIST_REMOVE(&chan->readq, fr, frame_list); 02620 ast_frfree(fr); 02621 } 02622 } 02623 02624 ast_channel_unlock(chan); 02625 }
static int ast_channel_cmp_cb | ( | void * | obj, | |
void * | arg, | |||
int | flags | |||
) | [static] |
Definition at line 1630 of file channel.c.
References ast_channel_lock, ast_channel_unlock, ast_strlen_zero(), chanlist::chan, CMP_MATCH, ast_channel::context, ast_channel::exten, ast_channel::macrocontext, ast_channel::macroexten, ast_channel::name, and ast_channel::uniqueid.
01631 { 01632 struct ast_channel *chan = obj, *cmp_args = arg; 01633 size_t name_len; 01634 int ret = CMP_MATCH; 01635 01636 /* This is sort of a hack. Basically, we're using an arbitrary field 01637 * in ast_channel to pass the name_len for a prefix match. If this 01638 * gets changed, then the uses of ao2_find() must be changed, too. */ 01639 name_len = cmp_args->rings; 01640 01641 ast_channel_lock(chan); 01642 01643 if (!ast_strlen_zero(cmp_args->name)) { /* match by name */ 01644 if ((!name_len && strcasecmp(chan->name, cmp_args->name)) || 01645 (name_len && strncasecmp(chan->name, cmp_args->name, name_len))) { 01646 ret = 0; /* name match failed */ 01647 } 01648 } else if (!ast_strlen_zero(cmp_args->exten)) { 01649 if (cmp_args->context && strcasecmp(chan->context, cmp_args->context) && 01650 strcasecmp(chan->macrocontext, cmp_args->context)) { 01651 ret = 0; /* context match failed */ 01652 } 01653 if (ret && strcasecmp(chan->exten, cmp_args->exten) && 01654 strcasecmp(chan->macroexten, cmp_args->exten)) { 01655 ret = 0; /* exten match failed */ 01656 } 01657 } else if (!ast_strlen_zero(cmp_args->uniqueid)) { 01658 if ((!name_len && strcasecmp(chan->uniqueid, cmp_args->uniqueid)) || 01659 (name_len && strncasecmp(chan->uniqueid, cmp_args->uniqueid, name_len))) { 01660 ret = 0; /* uniqueid match failed */ 01661 } 01662 } else { 01663 ret = 0; 01664 } 01665 01666 ast_channel_unlock(chan); 01667 01668 return ret; 01669 }
int ast_channel_cmpwhentohangup | ( | struct ast_channel * | chan, | |
time_t | offset | |||
) |
Compare a offset with the settings of when to hang a channel up.
chan | channel on which to check for hang up | |
offset | offset in seconds from current time |
Definition at line 830 of file channel.c.
References ast_channel_cmpwhentohangup_tv(), and chanlist::chan.
00831 { 00832 struct timeval when = { offset, }; 00833 return ast_channel_cmpwhentohangup_tv(chan, when); 00834 }
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.
chan | channel on which to check for hangup | |
offset | offset in seconds and microseconds from current time |
Definition at line 815 of file channel.c.
References ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), chanlist::chan, and ast_channel::whentohangup.
Referenced by ast_channel_cmpwhentohangup().
00816 { 00817 struct timeval whentohangup; 00818 00819 if (ast_tvzero(chan->whentohangup)) 00820 return ast_tvzero(offset) ? 0 : -1; 00821 00822 if (ast_tvzero(offset)) 00823 return 1; 00824 00825 whentohangup = ast_tvadd(offset, ast_tvnow()); 00826 00827 return ast_tvdiff_ms(whentohangup, chan->whentohangup); 00828 }
int ast_channel_connected_line_macro | ( | struct ast_channel * | autoservice_chan, | |
struct ast_channel * | macro_chan, | |||
const void * | connected_info, | |||
int | caller, | |||
int | frame | |||
) |
Run a connected line interception macro and update a channel's connected line information.
autoservice_chan | Channel to place into autoservice while the macro is running. It is perfectly safe for this to be NULL | |
macro_chan | The channel to run the macro on. Also the channel from which we determine which macro we need to run. | |
connected_info | Either an ast_party_connected_line or ast_frame pointer of type AST_CONTROL_CONNECTED_LINE | |
caller | If true, then run CONNECTED_LINE_CALLER_SEND_MACRO, otherwise run CONNECTED_LINE_CALLEE_SEND_MACRO | |
frame | If true, then connected_info is an ast_frame pointer, otherwise it is an ast_party_connected_line pointer. |
0 | Success | |
-1 | Either the macro does not exist, or there was an error while attempting to run the macro |
Make constants so that caller and frame can be more expressive than just '1' and '0'
Definition at line 9090 of file channel.c.
References ast_app_run_macro(), ast_channel_lock, ast_channel_unlock, ast_channel_update_connected_line(), ast_connected_line_parse_data(), ast_party_connected_line_copy(), ast_strdupa, ast_strlen_zero(), connected, ast_channel::connected, ast_frame::data, ast_frame::datalen, pbx_builtin_getvar_helper(), ast_frame::ptr, and S_OR.
Referenced by __ast_read(), ast_bridge_call(), ast_pickup_call(), atxfer_fail_cleanup(), builtin_atxfer(), builtin_blindtransfer(), feature_request_and_dial(), handle_frame(), pickup_do(), remote_bridge_loop(), and wait_for_answer().
09091 { 09092 const char *macro; 09093 const char *macro_args; 09094 int retval; 09095 09096 ast_channel_lock(macro_chan); 09097 macro = pbx_builtin_getvar_helper(macro_chan, is_caller 09098 ? "CONNECTED_LINE_CALLER_SEND_MACRO" : "CONNECTED_LINE_CALLEE_SEND_MACRO"); 09099 macro = ast_strdupa(S_OR(macro, "")); 09100 macro_args = pbx_builtin_getvar_helper(macro_chan, is_caller 09101 ? "CONNECTED_LINE_CALLER_SEND_MACRO_ARGS" : "CONNECTED_LINE_CALLEE_SEND_MACRO_ARGS"); 09102 macro_args = ast_strdupa(S_OR(macro_args, "")); 09103 09104 if (ast_strlen_zero(macro)) { 09105 ast_channel_unlock(macro_chan); 09106 return -1; 09107 } 09108 09109 if (is_frame) { 09110 const struct ast_frame *frame = connected_info; 09111 09112 ast_connected_line_parse_data(frame->data.ptr, frame->datalen, ¯o_chan->connected); 09113 } else { 09114 const struct ast_party_connected_line *connected = connected_info; 09115 09116 ast_party_connected_line_copy(¯o_chan->connected, connected); 09117 } 09118 ast_channel_unlock(macro_chan); 09119 09120 if (!(retval = ast_app_run_macro(autoservice_chan, macro_chan, macro, macro_args))) { 09121 ast_channel_lock(macro_chan); 09122 ast_channel_update_connected_line(macro_chan, ¯o_chan->connected, NULL); 09123 ast_channel_unlock(macro_chan); 09124 } 09125 09126 return retval; 09127 }
int ast_channel_data_add_structure | ( | struct ast_data * | tree, | |
struct ast_channel * | chan, | |||
int | add_bridged | |||
) |
Insert into an astdata tree, the channel structure.
[in] | tree | The ast data tree. |
[in] | chan | The channel structure to add to tree. |
[in] | add_bridged | Add the bridged channel to the structure. |
<0 | on error. | |
0 | on success. |
Definition at line 343 of file channel.c.
References ast_channel::_softhangup, ast_channel::_state, ast_channel::amaflags, ast_bridged_channel(), ast_cause2str(), ast_cdr_data_add_structure(), ast_cdr_flags2str(), ast_channel_data_add_structure(), ast_data_add_bool(), ast_data_add_codecs(), ast_data_add_int(), ast_data_add_node(), ast_data_add_str(), ast_data_add_structure, ast_data_add_uint(), AST_SOFTHANGUP_APPUNLOAD, AST_SOFTHANGUP_ASYNCGOTO, AST_SOFTHANGUP_DEV, AST_SOFTHANGUP_EXPLICIT, AST_SOFTHANGUP_SHUTDOWN, AST_SOFTHANGUP_TIMEOUT, AST_SOFTHANGUP_UNBRIDGE, ast_state2str(), ast_tone_zone_data_add_structure(), ast_transfercapability2str(), ast_channel::cdr, chanlist::chan, channel_data_add_flags(), ast_channel::hangupcause, ast_channel::nativeformats, ast_channel::oldwriteformat, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel::readformat, ast_channel::transfercapability, ast_channel::whentohangup, ast_channel::writeformat, and ast_channel::zone.
Referenced by agents_data_provider_get(), ast_channel_data_add_structure(), data_channels_provider_handler(), queues_data_provider_get_helper(), and user_add_provider_cb().
00345 { 00346 struct ast_channel *bc; 00347 struct ast_data *data_bridged; 00348 struct ast_data *data_cdr; 00349 struct ast_data *data_flags; 00350 struct ast_data *data_zones; 00351 struct ast_data *enum_node; 00352 struct ast_data *data_softhangup; 00353 #if 0 /* XXX AstData: ast_callerid no longer exists. (Equivalent code not readily apparent.) */ 00354 struct ast_data *data_callerid; 00355 char value_str[100]; 00356 #endif 00357 00358 if (!tree) { 00359 return -1; 00360 } 00361 00362 ast_data_add_structure(ast_channel, tree, chan); 00363 00364 if (add_bridged) { 00365 bc = ast_bridged_channel(chan); 00366 if (bc) { 00367 data_bridged = ast_data_add_node(tree, "bridged"); 00368 if (!data_bridged) { 00369 return -1; 00370 } 00371 ast_channel_data_add_structure(data_bridged, bc, 0); 00372 } 00373 } 00374 00375 ast_data_add_codecs(tree, "oldwriteformat", chan->oldwriteformat); 00376 ast_data_add_codecs(tree, "nativeformats", chan->nativeformats); 00377 ast_data_add_codecs(tree, "readformat", chan->readformat); 00378 ast_data_add_codecs(tree, "writeformat", chan->writeformat); 00379 ast_data_add_codecs(tree, "rawreadformat", chan->rawreadformat); 00380 ast_data_add_codecs(tree, "rawwriteformat", chan->rawwriteformat); 00381 00382 /* state */ 00383 enum_node = ast_data_add_node(tree, "state"); 00384 if (!enum_node) { 00385 return -1; 00386 } 00387 ast_data_add_str(enum_node, "text", ast_state2str(chan->_state)); 00388 ast_data_add_int(enum_node, "value", chan->_state); 00389 00390 /* hangupcause */ 00391 enum_node = ast_data_add_node(tree, "hangupcause"); 00392 if (!enum_node) { 00393 return -1; 00394 } 00395 ast_data_add_str(enum_node, "text", ast_cause2str(chan->hangupcause)); 00396 ast_data_add_int(enum_node, "value", chan->hangupcause); 00397 00398 /* amaflags */ 00399 enum_node = ast_data_add_node(tree, "amaflags"); 00400 if (!enum_node) { 00401 return -1; 00402 } 00403 ast_data_add_str(enum_node, "text", ast_cdr_flags2str(chan->amaflags)); 00404 ast_data_add_int(enum_node, "value", chan->amaflags); 00405 00406 /* transfercapability */ 00407 enum_node = ast_data_add_node(tree, "transfercapability"); 00408 if (!enum_node) { 00409 return -1; 00410 } 00411 ast_data_add_str(enum_node, "text", ast_transfercapability2str(chan->transfercapability)); 00412 ast_data_add_int(enum_node, "value", chan->transfercapability); 00413 00414 /* _softphangup */ 00415 data_softhangup = ast_data_add_node(tree, "softhangup"); 00416 if (!data_softhangup) { 00417 return -1; 00418 } 00419 ast_data_add_bool(data_softhangup, "dev", chan->_softhangup & AST_SOFTHANGUP_DEV); 00420 ast_data_add_bool(data_softhangup, "asyncgoto", chan->_softhangup & AST_SOFTHANGUP_ASYNCGOTO); 00421 ast_data_add_bool(data_softhangup, "shutdown", chan->_softhangup & AST_SOFTHANGUP_SHUTDOWN); 00422 ast_data_add_bool(data_softhangup, "timeout", chan->_softhangup & AST_SOFTHANGUP_TIMEOUT); 00423 ast_data_add_bool(data_softhangup, "appunload", chan->_softhangup & AST_SOFTHANGUP_APPUNLOAD); 00424 ast_data_add_bool(data_softhangup, "explicit", chan->_softhangup & AST_SOFTHANGUP_EXPLICIT); 00425 ast_data_add_bool(data_softhangup, "unbridge", chan->_softhangup & AST_SOFTHANGUP_UNBRIDGE); 00426 00427 /* channel flags */ 00428 data_flags = ast_data_add_node(tree, "flags"); 00429 if (!data_flags) { 00430 return -1; 00431 } 00432 channel_data_add_flags(data_flags, chan); 00433 00434 ast_data_add_uint(tree, "timetohangup", chan->whentohangup.tv_sec); 00435 00436 #if 0 /* XXX AstData: ast_callerid no longer exists. (Equivalent code not readily apparent.) */ 00437 /* callerid */ 00438 data_callerid = ast_data_add_node(tree, "callerid"); 00439 if (!data_callerid) { 00440 return -1; 00441 } 00442 ast_data_add_structure(ast_callerid, data_callerid, &(chan->cid)); 00443 /* insert the callerid ton */ 00444 enum_node = ast_data_add_node(data_callerid, "cid_ton"); 00445 if (!enum_node) { 00446 return -1; 00447 } 00448 ast_data_add_int(enum_node, "value", chan->cid.cid_ton); 00449 snprintf(value_str, sizeof(value_str), "TON: %s/Plan: %s", 00450 party_number_ton2str(chan->cid.cid_ton), 00451 party_number_plan2str(chan->cid.cid_ton)); 00452 ast_data_add_str(enum_node, "text", value_str); 00453 #endif 00454 00455 /* tone zone */ 00456 if (chan->zone) { 00457 data_zones = ast_data_add_node(tree, "zone"); 00458 if (!data_zones) { 00459 return -1; 00460 } 00461 ast_tone_zone_data_add_structure(data_zones, chan->zone); 00462 } 00463 00464 /* insert cdr */ 00465 data_cdr = ast_data_add_node(tree, "cdr"); 00466 if (!data_cdr) { 00467 return -1; 00468 } 00469 00470 ast_cdr_data_add_structure(data_cdr, chan->cdr, 1); 00471 00472 return 0; 00473 }
int ast_channel_data_cmp_structure | ( | const struct ast_data_search * | tree, | |
struct ast_channel * | chan, | |||
const char * | structure_name | |||
) |
Compare to channel structures using the data api.
[in] | tree | The search tree generated by the data api. |
[in] | chan | The channel to compare. |
[in] | structure_name | The name of the node of the channel structure. |
0 | The structure matches. | |
1 | The structure doesn't matches. |
Definition at line 475 of file channel.c.
References ast_data_search_cmp_structure, and chanlist::chan.
00477 { 00478 return ast_data_search_cmp_structure(tree, ast_channel, chan, structure_name); 00479 }
int ast_channel_datastore_add | ( | struct ast_channel * | chan, | |
struct ast_datastore * | datastore | |||
) |
Add a datastore to a channel.
0 | success | |
non-zero | failure |
Definition at line 2484 of file channel.c.
References AST_LIST_INSERT_HEAD, chanlist::chan, ast_channel::datastores, and ast_datastore::entry.
Referenced by __ast_channel_masquerade(), _macro_exec(), acf_curlopt_write(), acf_iaxvar_write(), add_features_datastores(), add_to_agi(), apply_plc(), ast_channel_cc_params_init(), ast_iax2_new(), ast_setup_cc_recall_datastore(), audiohook_volume_get(), authenticate_reply(), calendar_query_exec(), cc_interfaces_datastore_init(), dial_exec_full(), do_notify(), dundi_query_read(), enable_jack_hook(), enum_query_read(), find_or_create_details(), find_transaction(), frame_trace_helper(), func_channel_write_real(), get_lock(), gosub_exec(), lua_get_state(), mute_add_audiohook(), pbx_builtin_raise_exception(), pitchshift_helper(), setup_inheritance_datastore(), setup_mixmonitor_ds(), setup_transfer_datastore(), shared_write(), smdi_msg_retrieve_read(), socket_process(), speech_create(), speex_write(), srv_datastore_setup(), and volume_write().
02485 { 02486 int res = 0; 02487 02488 AST_LIST_INSERT_HEAD(&chan->datastores, datastore, entry); 02489 02490 return res; 02491 }
struct ast_datastore* ast_channel_datastore_alloc | ( | const struct ast_datastore_info * | info, | |
const char * | uid | |||
) |
Create a channel data store object.
Definition at line 2457 of file channel.c.
References ast_datastore_alloc, and ast_datastore::info.
02458 { 02459 return ast_datastore_alloc(info, uid); 02460 }
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.
The datastore returned from this function must not be used if the reference to the channel is released.
pointer | to the datastore if found | |
NULL | if not found |
Definition at line 2498 of file channel.c.
References AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, chanlist::chan, ast_channel::datastores, ast_datastore::entry, ast_datastore::info, and ast_datastore::uid.
Referenced by _macro_exec(), acf_curl_helper(), acf_curlopt_helper(), acf_curlopt_write(), acf_exception_read(), acf_fetch(), acf_iaxvar_read(), acf_iaxvar_write(), add_agi_cmd(), add_features_datastores(), add_to_agi(), apply_plc(), ast_cc_agent_set_interfaces_chanvar(), ast_cc_call_init(), ast_cc_completed(), ast_cc_extension_monitor_add_dialstring(), ast_cc_get_current_core_id(), ast_cc_is_recall(), ast_cc_offer(), ast_channel_get_cc_config_params(), ast_do_masquerade(), ast_handle_cc_control_frame(), ast_ignore_cc(), ast_odbc_retrieve_transaction_obj(), ast_set_cc_interfaces_chanvar(), attended_transfer_occurred(), audiohook_volume_callback(), audiohook_volume_get(), builtin_atxfer(), calendar_event_read(), calendar_query_exec(), calendar_query_result_exec(), cc_build_payload(), dial_exec_full(), disable_jack_hook(), dundi_result_read(), enable_jack_hook(), enum_result_read(), exec_odbcfinish(), find_details(), find_speech(), find_transaction(), frame_trace_helper(), func_channel_read(), func_channel_write_real(), func_inheritance_write(), func_mute_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(), manager_mutestream(), mark_transaction_active(), mute_callback(), park_exec_full(), pbx_builtin_raise_exception(), pitchshift_cb(), pitchshift_helper(), pop_exec(), queue_transfer_fixup(), release_transaction(), return_exec(), set_security_requirements(), shared_read(), shared_write(), smdi_msg_read(), speech_background(), speech_destroy(), speex_callback(), speex_read(), speex_write(), srv_query_read(), srv_result_read(), stop_mixmonitor_exec(), try_calling(), unlock_read(), volume_callback(), and volume_write().
02499 { 02500 struct ast_datastore *datastore = NULL; 02501 02502 if (info == NULL) 02503 return NULL; 02504 02505 AST_LIST_TRAVERSE_SAFE_BEGIN(&chan->datastores, datastore, entry) { 02506 if (datastore->info != info) { 02507 continue; 02508 } 02509 02510 if (uid == NULL) { 02511 /* matched by type only */ 02512 break; 02513 } 02514 02515 if ((datastore->uid != NULL) && !strcasecmp(uid, datastore->uid)) { 02516 /* Matched by type AND uid */ 02517 break; 02518 } 02519 } 02520 AST_LIST_TRAVERSE_SAFE_END; 02521 02522 return datastore; 02523 }
int ast_channel_datastore_free | ( | struct ast_datastore * | datastore | ) |
Free a channel data store object.
Definition at line 2462 of file channel.c.
References ast_datastore_free().
02463 { 02464 return ast_datastore_free(datastore); 02465 }
int ast_channel_datastore_inherit | ( | struct ast_channel * | from, | |
struct ast_channel * | to | |||
) |
Inherit datastores from a parent to a child.
Definition at line 2467 of file channel.c.
References ast_datastore_alloc, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_datastore::data, DATASTORE_INHERIT_FOREVER, ast_channel::datastores, ast_datastore_info::duplicate, ast_datastore::entry, ast_datastore::info, ast_datastore::inheritance, and ast_datastore::uid.
Referenced by __ast_request_and_dial(), ast_call_forward(), begin_dial_channel(), dial_exec_full(), do_forward(), findmeexec(), local_call(), and ring_entry().
02468 { 02469 struct ast_datastore *datastore = NULL, *datastore2; 02470 02471 AST_LIST_TRAVERSE(&from->datastores, datastore, entry) { 02472 if (datastore->inheritance > 0) { 02473 datastore2 = ast_datastore_alloc(datastore->info, datastore->uid); 02474 if (datastore2) { 02475 datastore2->data = datastore->info->duplicate ? datastore->info->duplicate(datastore->data) : NULL; 02476 datastore2->inheritance = datastore->inheritance == DATASTORE_INHERIT_FOREVER ? DATASTORE_INHERIT_FOREVER : datastore->inheritance - 1; 02477 AST_LIST_INSERT_TAIL(&to->datastores, datastore2, entry); 02478 } 02479 } 02480 } 02481 return 0; 02482 }
int ast_channel_datastore_remove | ( | struct ast_channel * | chan, | |
struct ast_datastore * | datastore | |||
) |
Remove a datastore from a channel.
0 | success | |
non-zero | failure |
Definition at line 2493 of file channel.c.
References AST_LIST_REMOVE, chanlist::chan, ast_channel::datastores, and ast_datastore::entry.
Referenced by acf_fetch(), adjust_frame_for_plc(), ast_do_masquerade(), dial_exec_full(), disable_jack_hook(), exec_odbcfinish(), frame_trace_helper(), lua_get_state(), queue_transfer_fixup(), speech_background(), speech_destroy(), speex_write(), srv_query_read(), and stop_mixmonitor_exec().
02494 { 02495 return AST_LIST_REMOVE(&chan->datastores, datastore, entry) ? 0 : -1; 02496 }
int ast_channel_defer_dtmf | ( | struct ast_channel * | chan | ) |
Defers DTMF so that you only read things like hangups and audio.
Definition at line 1526 of file channel.c.
References AST_FLAG_DEFER_DTMF, ast_set_flag, ast_test_flag, and chanlist::chan.
Referenced by find_cache().
01527 { 01528 int pre = 0; 01529 01530 if (chan) { 01531 pre = ast_test_flag(chan, AST_FLAG_DEFER_DTMF); 01532 ast_set_flag(chan, AST_FLAG_DEFER_DTMF); 01533 } 01534 return pre; 01535 }
static void ast_channel_destructor | ( | void * | obj | ) | [static] |
Free a channel structure.
Definition at line 2306 of file channel.c.
References ast_channel::alertpipe, ast_app_group_discard(), ast_cdr_discard(), AST_CEL_CHANNEL_END, ast_cel_check_retire_linkedid(), ast_cel_report_event(), ast_channel_lock, AST_CHANNEL_NAME, ast_channel_unlock, ast_copy_string(), ast_datastore_free(), AST_DEVICE_UNKNOWN, ast_devstate_changed_literal(), ast_free, ast_frfree, ast_jb_destroy(), AST_LIST_REMOVE_HEAD, ast_log(), AST_MAX_FDS, ast_moh_cleanup(), ast_party_caller_free(), ast_party_connected_line_free(), ast_party_dialed_free(), ast_party_redirecting_free(), ast_string_field_free_memory, ast_timer_close(), ast_tone_zone_unref(), ast_translator_free_path(), ast_var_delete(), ast_channel::caller, ast_channel::cdr, chanlist::chan, ast_channel::connected, ast_channel::datastores, ast_channel::dialed, ast_datastore::entry, f, free, LOG_WARNING, ast_channel::monitor, ast_channel::music_state, ast_channel::name, ast_channel::pbx, ast_channel::readq, ast_channel::readtrans, ast_channel::redirecting, ast_channel::sched, sched_context_destroy(), ast_channel_monitor::stop, ast_channel::tech_pvt, ast_channel::timer, ast_channel::varshead, ast_channel::writetrans, and ast_channel::zone.
Referenced by __ast_channel_alloc_ap().
02307 { 02308 struct ast_channel *chan = obj; 02309 int fd; 02310 #ifdef HAVE_EPOLL 02311 int i; 02312 #endif 02313 struct ast_var_t *vardata; 02314 struct ast_frame *f; 02315 struct varshead *headp; 02316 struct ast_datastore *datastore; 02317 char device_name[AST_CHANNEL_NAME]; 02318 02319 if (chan->name) { 02320 /* The string fields were initialized. */ 02321 ast_cel_report_event(chan, AST_CEL_CHANNEL_END, NULL, NULL, NULL); 02322 ast_cel_check_retire_linkedid(chan); 02323 } 02324 02325 /* Get rid of each of the data stores on the channel */ 02326 ast_channel_lock(chan); 02327 while ((datastore = AST_LIST_REMOVE_HEAD(&chan->datastores, entry))) 02328 /* Free the data store */ 02329 ast_datastore_free(datastore); 02330 ast_channel_unlock(chan); 02331 02332 /* Lock and unlock the channel just to be sure nobody has it locked still 02333 due to a reference that was stored in a datastore. (i.e. app_chanspy) */ 02334 ast_channel_lock(chan); 02335 ast_channel_unlock(chan); 02336 02337 if (chan->tech_pvt) { 02338 ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n", chan->name); 02339 ast_free(chan->tech_pvt); 02340 } 02341 02342 if (chan->sched) 02343 sched_context_destroy(chan->sched); 02344 02345 if (chan->name) { 02346 char *dashptr; 02347 02348 /* The string fields were initialized. */ 02349 ast_copy_string(device_name, chan->name, sizeof(device_name)); 02350 if ((dashptr = strrchr(device_name, '-'))) { 02351 *dashptr = '\0'; 02352 } 02353 } else { 02354 device_name[0] = '\0'; 02355 } 02356 02357 /* Stop monitoring */ 02358 if (chan->monitor) 02359 chan->monitor->stop( chan, 0 ); 02360 02361 /* If there is native format music-on-hold state, free it */ 02362 if (chan->music_state) 02363 ast_moh_cleanup(chan); 02364 02365 /* Free translators */ 02366 if (chan->readtrans) 02367 ast_translator_free_path(chan->readtrans); 02368 if (chan->writetrans) 02369 ast_translator_free_path(chan->writetrans); 02370 if (chan->pbx) 02371 ast_log(LOG_WARNING, "PBX may not have been terminated properly on '%s'\n", chan->name); 02372 02373 ast_party_dialed_free(&chan->dialed); 02374 ast_party_caller_free(&chan->caller); 02375 ast_party_connected_line_free(&chan->connected); 02376 ast_party_redirecting_free(&chan->redirecting); 02377 02378 /* Close pipes if appropriate */ 02379 if ((fd = chan->alertpipe[0]) > -1) 02380 close(fd); 02381 if ((fd = chan->alertpipe[1]) > -1) 02382 close(fd); 02383 if (chan->timer) { 02384 ast_timer_close(chan->timer); 02385 } 02386 #ifdef HAVE_EPOLL 02387 for (i = 0; i < AST_MAX_FDS; i++) { 02388 if (chan->epfd_data[i]) 02389 free(chan->epfd_data[i]); 02390 } 02391 close(chan->epfd); 02392 #endif 02393 while ((f = AST_LIST_REMOVE_HEAD(&chan->readq, frame_list))) 02394 ast_frfree(f); 02395 02396 /* loop over the variables list, freeing all data and deleting list items */ 02397 /* no need to lock the list, as the channel is already locked */ 02398 headp = &chan->varshead; 02399 while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries))) 02400 ast_var_delete(vardata); 02401 02402 ast_app_group_discard(chan); 02403 02404 /* Destroy the jitterbuffer */ 02405 ast_jb_destroy(chan); 02406 02407 if (chan->cdr) { 02408 ast_cdr_discard(chan->cdr); 02409 chan->cdr = NULL; 02410 } 02411 02412 if (chan->zone) { 02413 chan->zone = ast_tone_zone_unref(chan->zone); 02414 } 02415 02416 ast_string_field_free_memory(chan); 02417 02418 if (device_name[0]) { 02419 /* 02420 * We have a device name to notify of a new state. 02421 * 02422 * Queue an unknown state, because, while we know that this particular 02423 * instance is dead, we don't know the state of all other possible 02424 * instances. 02425 */ 02426 ast_devstate_changed_literal(AST_DEVICE_UNKNOWN, device_name); 02427 } 02428 }
int ast_channel_early_bridge | ( | struct ast_channel * | c0, | |
struct ast_channel * | c1 | |||
) |
Bridge two channels together (early).
c0 | first channel to bridge | |
c1 | second channel to bridge |
Definition at line 6947 of file channel.c.
References ast_channel_tech::early_bridge, and ast_channel::tech.
Referenced by dial_exec_full().
06948 { 06949 /* Make sure we can early bridge, if not error out */ 06950 if (!c0->tech->early_bridge || (c1 && (!c1->tech->early_bridge || c0->tech->early_bridge != c1->tech->early_bridge))) 06951 return -1; 06952 06953 return c0->tech->early_bridge(c0, c1); 06954 }
struct ast_channel* ast_channel_get_by_exten | ( | const char * | exten, | |
const char * | context | |||
) |
Find a channel by extension and context.
a | channel that is at the specified extension and context | |
NULL | if no channel was found |
Definition at line 1723 of file channel.c.
References ast_channel_get_full().
01724 { 01725 return ast_channel_get_full(NULL, 0, exten, context); 01726 }
struct ast_channel* ast_channel_get_by_name | ( | const char * | name | ) |
Find a channel by name.
a | channel with the name specified by the argument | |
NULL | if no channel was found |
Definition at line 1713 of file channel.c.
References ast_channel_get_full().
Referenced by action_add_agi_cmd(), action_aocmessage(), action_atxfer(), action_getvar(), action_hangup(), action_redirect(), action_sendtext(), action_setvar(), action_status(), action_timeout(), ast_async_goto_by_name(), ast_bridge_call(), asyncgoto_exec(), change_monitor_action(), do_pause_or_unpause(), func_mchan_read(), func_mchan_write(), handle_channelstatus(), handle_cli_agi_add_cmd(), handle_core_set_debug_channel(), handle_getvariablefull(), handle_hangup(), handle_redirect(), handle_set_chanvar(), handle_show_chanvar(), handle_showchan(), handle_softhangup(), import_helper(), manager_mute_mixmonitor(), manager_mutestream(), manager_optimize_away(), manager_park(), manager_play_dtmf(), park_call_full(), pbx_builtin_importvar(), senddtmf_exec(), shared_read(), shared_write(), start_monitor_action(), and stop_monitor_action().
01714 { 01715 return ast_channel_get_full(name, 0, NULL, NULL); 01716 }
struct ast_channel* ast_channel_get_by_name_prefix | ( | const char * | name, | |
size_t | name_len | |||
) |
Find a channel by a name prefix.
a | channel with the name prefix specified by the arguments | |
NULL | if no channel was found |
Definition at line 1718 of file channel.c.
References ast_channel_get_full().
Referenced by action_aocmessage(), action_bridge(), ast_parse_device_state(), bridge_exec(), cc_generic_agent_stop_ringing(), common_exec(), handle_cli_mixmonitor(), shared_read(), and shared_write().
01719 { 01720 return ast_channel_get_full(name, name_len, NULL, NULL); 01721 }
int ast_channel_get_cc_agent_type | ( | struct ast_channel * | chan, | |
char * | agent_type, | |||
size_t | size | |||
) |
Find the appropriate CC agent type to use given a channel.
Prior to adding this function, the call completion core attempted to figure this out for itself by stripping the technology off the channel's name. However, in the case of chan_dahdi, there are multiple agent types registered, and so simply searching for an agent type called "DAHDI" is not possible. In a case where multiple agent types are defined, the channel driver must have a queryoption callback defined in its channel_tech, and the queryoption callback must handle AST_OPTION_CC_AGENT_TYPE
If a channel driver does not have a queryoption callback or if the queryoption callback does not handle AST_OPTION_CC_AGENT_TYPE, then the old behavior of using the technology portion of the channel name is used instead. This is perfectly suitable for channel drivers whose channel technologies are a one-to-one match with the agent types defined within.
Note that this function is only called when the agent policy on a given channel is set to "native." Generic agents' type can be determined automatically by the core.
chan | The channel for which we wish to retrieve the agent type | |
[out] | agent_type | The type of agent the channel driver wants us to use |
size | The size of the buffer to write to |
Definition at line 9254 of file channel.c.
References ast_channel_queryoption(), ast_copy_string(), AST_OPTION_CC_AGENT_TYPE, and ast_channel::name.
Referenced by find_agent_callbacks().
09255 { 09256 int len = size; 09257 char *slash; 09258 09259 if (!ast_channel_queryoption(chan, AST_OPTION_CC_AGENT_TYPE, agent_type, &len, 0)) { 09260 return 0; 09261 } 09262 09263 ast_copy_string(agent_type, chan->name, size); 09264 if ((slash = strchr(agent_type, '/'))) { 09265 *slash = '\0'; 09266 } 09267 return 0; 09268 }
struct ast_cc_config_params* ast_channel_get_cc_config_params | ( | struct ast_channel * | chan | ) |
Get the CCSS parameters from a channel.
chan | Channel to retrieve parameters from |
NULL | Failure | |
non-NULL | The parameters desired |
Definition at line 9215 of file channel.c.
References ast_assert, ast_channel_cc_params_init(), ast_channel_datastore_find(), cc_channel_datastore_info, and ast_datastore::data.
Referenced by acf_cc_read(), acf_cc_write(), analog_call(), ast_cc_call_failed(), ast_cc_call_init(), ast_queue_cc_frame(), cc_agent_init(), cc_core_init_instance(), find_agent_callbacks(), local_call(), local_request(), and sig_pri_cc_generic_check().
09216 { 09217 struct ast_datastore *cc_datastore; 09218 09219 if (!(cc_datastore = ast_channel_datastore_find(chan, &cc_channel_datastore_info, NULL))) { 09220 /* If we can't find the datastore, it almost definitely means that the channel type being 09221 * used has not had its driver modified to parse CC config parameters. The best action 09222 * to take here is to create the parameters on the spot with the defaults set. 09223 */ 09224 if (ast_channel_cc_params_init(chan, NULL)) { 09225 return NULL; 09226 } 09227 if (!(cc_datastore = ast_channel_datastore_find(chan, &cc_channel_datastore_info, NULL))) { 09228 /* Should be impossible */ 09229 return NULL; 09230 } 09231 } 09232 09233 ast_assert(cc_datastore->data != NULL); 09234 return cc_datastore->data; 09235 }
int ast_channel_get_device_name | ( | struct ast_channel * | chan, | |
char * | device_name, | |||
size_t | name_buffer_length | |||
) |
Get a device name given its channel structure.
This function interfaces with a channel tech's queryoption callback to retrieve the name of the device being communicated with. If the channel does not implement this specific option, then the traditional method of using the channel name is used instead.
chan | The channel to retrieve the information from | |
[out] | device_name | The buffer to place the device's name into |
name_buffer_length | The allocated space for the device_name |
Definition at line 9237 of file channel.c.
References ast_channel_queryoption(), ast_copy_string(), AST_OPTION_DEVICE_NAME, and ast_channel::name.
Referenced by ast_cc_call_failed(), ast_cc_is_recall(), ast_queue_cc_frame(), cc_core_init_instance(), cccancel_exec(), ccreq_exec(), dial_exec_full(), sig_pri_call(), sig_pri_cc_generic_check(), sip_call(), and sip_handle_cc().
09238 { 09239 int len = name_buffer_length; 09240 char *dash; 09241 if (!ast_channel_queryoption(chan, AST_OPTION_DEVICE_NAME, device_name, &len, 0)) { 09242 return 0; 09243 } 09244 09245 /* Dang. Do it the old-fashioned way */ 09246 ast_copy_string(device_name, chan->name, name_buffer_length); 09247 if ((dash = strrchr(device_name, '-'))) { 09248 *dash = '\0'; 09249 } 09250 09251 return 0; 09252 }
static struct ast_channel* ast_channel_get_full | ( | const char * | name, | |
size_t | name_len, | |||
const char * | exten, | |||
const char * | context | |||
) | [static] |
Definition at line 1671 of file channel.c.
References ao2_find, ast_copy_string(), ast_strlen_zero(), chanlist::chan, channels, ast_channel::context, ast_channel::exten, ast_channel::name, OBJ_POINTER, and ast_channel::uniqueid.
Referenced by ast_channel_get_by_exten(), ast_channel_get_by_name(), and ast_channel_get_by_name_prefix().
01673 { 01674 struct ast_channel tmp_chan = { 01675 .name = name, 01676 /* This is sort of a hack. Basically, we're using an arbitrary field 01677 * in ast_channel to pass the name_len for a prefix match. If this 01678 * gets changed, then the compare callback must be changed, too. */ 01679 .rings = name_len, 01680 }; 01681 struct ast_channel *chan; 01682 01683 if (exten) { 01684 ast_copy_string(tmp_chan.exten, exten, sizeof(tmp_chan.exten)); 01685 } 01686 01687 if (context) { 01688 ast_copy_string(tmp_chan.context, context, sizeof(tmp_chan.context)); 01689 } 01690 01691 if ((chan = ao2_find(channels, &tmp_chan, 01692 (!ast_strlen_zero(name) && (name_len == 0)) ? OBJ_POINTER : 0))) { 01693 return chan; 01694 } 01695 01696 if (!name) { 01697 return NULL; 01698 } 01699 01700 /* If name was specified, but the result was NULL, 01701 * try a search on uniqueid, instead. */ 01702 01703 { 01704 struct ast_channel tmp_chan2 = { 01705 .uniqueid = name, 01706 .rings = name_len, 01707 }; 01708 01709 return ao2_find(channels, &tmp_chan2, 0); 01710 } 01711 }
static int ast_channel_hash_cb | ( | const void * | obj, | |
const int | flags | |||
) | [static] |
Definition at line 7570 of file channel.c.
References ast_str_case_hash(), ast_strlen_zero(), and ast_channel::name.
07571 { 07572 const struct ast_channel *chan = obj; 07573 07574 /* If the name isn't set, return 0 so that the ao2_find() search will 07575 * start in the first bucket. */ 07576 if (ast_strlen_zero(chan->name)) { 07577 return 0; 07578 } 07579 07580 return ast_str_case_hash(chan->name); 07581 }
void ast_channel_inherit_variables | ( | const struct ast_channel * | parent, | |
struct ast_channel * | child | |||
) |
Inherits channel variable from parent to child channel.
parent | Parent channel | |
child | Child channel |
Definition at line 5896 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(), ast_var_t::entries, and ast_channel::varshead.
Referenced by __ast_request_and_dial(), ast_call_forward(), begin_dial_channel(), dial_exec_full(), dial_transfer(), do_forward(), feature_request_and_dial(), findmeexec(), and ring_entry().
05897 { 05898 struct ast_var_t *current, *newvar; 05899 const char *varname; 05900 05901 AST_LIST_TRAVERSE(&parent->varshead, current, entries) { 05902 int vartype = 0; 05903 05904 varname = ast_var_full_name(current); 05905 if (!varname) 05906 continue; 05907 05908 if (varname[0] == '_') { 05909 vartype = 1; 05910 if (varname[1] == '_') 05911 vartype = 2; 05912 } 05913 05914 switch (vartype) { 05915 case 1: 05916 newvar = ast_var_assign(&varname[1], ast_var_value(current)); 05917 if (newvar) { 05918 AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries); 05919 ast_debug(1, "Copying soft-transferable variable %s.\n", ast_var_name(newvar)); 05920 } 05921 break; 05922 case 2: 05923 newvar = ast_var_assign(varname, ast_var_value(current)); 05924 if (newvar) { 05925 AST_LIST_INSERT_TAIL(&child->varshead, newvar, entries); 05926 ast_debug(1, "Copying hard-transferable variable %s.\n", ast_var_name(newvar)); 05927 } 05928 break; 05929 default: 05930 ast_debug(1, "Not copying variable %s.\n", ast_var_name(current)); 05931 break; 05932 } 05933 } 05934 }
struct ast_channel_iterator* ast_channel_iterator_all_new | ( | void | ) |
Create a new channel iterator.
After creating an iterator using this function, the ast_channel_iterator_next() function can be used to iterate through all channels that exist.
NULL | on failure | |
a | new channel iterator |
Definition at line 1611 of file channel.c.
References ao2_iterator_init(), ast_calloc, channels, and ast_channel_iterator::simple_iterator.
Referenced by action_coreshowchannels(), action_status(), ast_complete_channels(), ast_var_channel_bridge(), ast_var_channel_types_table(), ast_var_channels_table(), common_exec(), data_channels_provider_handler(), func_channels_read(), handle_chanlist(), and handle_softhangup().
01612 { 01613 struct ast_channel_iterator *i; 01614 01615 if (!(i = ast_calloc(1, sizeof(*i)))) { 01616 return NULL; 01617 } 01618 01619 i->simple_iterator = ao2_iterator_init(channels, 0); 01620 i->active_iterator = &i->simple_iterator; 01621 01622 return i; 01623 }
struct ast_channel_iterator* ast_channel_iterator_by_exten_new | ( | const char * | exten, | |
const char * | context | |||
) |
Create a new channel iterator based on extension.
NULL | on failure | |
a | new channel iterator based on the specified parameters |
Definition at line 1601 of file channel.c.
References channel_iterator_search().
Referenced by common_exec(), and pickup_by_exten().
01602 { 01603 return channel_iterator_search(NULL, 0, exten, context); 01604 }
struct ast_channel_iterator* ast_channel_iterator_by_name_new | ( | const char * | name, | |
size_t | name_len | |||
) |
Create a new channel iterator based on name.
NULL | on failure | |
a | new channel iterator based on the specified parameters |
Definition at line 1606 of file channel.c.
References channel_iterator_search().
Referenced by ast_complete_channels(), common_exec(), and softhangup_exec().
01607 { 01608 return channel_iterator_search(name, name_len, NULL, NULL); 01609 }
struct ast_channel_iterator* ast_channel_iterator_destroy | ( | struct ast_channel_iterator * | i | ) |
Destroy a channel iterator.
Definition at line 1559 of file channel.c.
References ast_channel_iterator::active_iterator, ao2_iterator_destroy(), and ast_free.
Referenced by action_coreshowchannels(), ast_complete_channels(), ast_var_channel_bridge(), ast_var_channel_types_table(), ast_var_channels_table(), common_exec(), data_channels_provider_handler(), func_channels_read(), handle_chanlist(), handle_softhangup(), pickup_by_exten(), and softhangup_exec().
01560 { 01561 ao2_iterator_destroy(i->active_iterator); 01562 ast_free(i); 01563 01564 return NULL; 01565 }
struct ast_channel* ast_channel_iterator_next | ( | struct ast_channel_iterator * | i | ) |
Get the next channel for a channel iterator.
the | next channel that matches the parameters used when the iterator was created. | |
NULL,if | no more channels match the iterator parameters. |
Definition at line 1625 of file channel.c.
References ast_channel_iterator::active_iterator, and ao2_iterator_next.
Referenced by action_coreshowchannels(), action_status(), ast_complete_channels(), ast_var_channel_bridge(), ast_var_channel_types_table(), ast_var_channels_table(), data_channels_provider_handler(), func_channels_read(), handle_chanlist(), handle_softhangup(), next_channel(), pickup_by_exten(), and softhangup_exec().
01626 { 01627 return ao2_iterator_next(i->active_iterator); 01628 }
int ast_channel_make_compatible | ( | struct ast_channel * | c0, | |
struct ast_channel * | c1 | |||
) |
Makes two channel formats compatible.
c0 | first channel to make compatible | |
c1 | other channel to make compatible |
Definition at line 5660 of file channel.c.
References ast_channel_make_compatible_helper(), and chanlist::chan.
Referenced by action_bridge(), app_exec(), ast_channel_bridge(), bridge_exec(), check_compat(), dial_exec_full(), do_forward(), multiplexed_bridge_join(), park_exec_full(), simple_bridge_join(), and wait_for_answer().
05661 { 05662 /* Some callers do not check return code, and we must try to set all call legs correctly */ 05663 int rc = 0; 05664 05665 /* Set up translation from the chan to the peer */ 05666 rc = ast_channel_make_compatible_helper(chan, peer); 05667 05668 if (rc < 0) 05669 return rc; 05670 05671 /* Set up translation from the peer to the chan */ 05672 rc = ast_channel_make_compatible_helper(peer, chan); 05673 05674 return rc; 05675 }
static int ast_channel_make_compatible_helper | ( | struct ast_channel * | from, | |
struct ast_channel * | to | |||
) | [static] |
Set up translation from one channel to another.
Definition at line 5610 of file channel.c.
References ast_channel_setoption(), AST_FORMAT_AUDIO_MASK, AST_FORMAT_SLINEAR, ast_getformatname(), ast_log(), ast_opt_generic_plc, ast_opt_transcode_via_slin, AST_OPTION_MAKE_COMPATIBLE, ast_set_read_format(), ast_set_write_format(), ast_translate_path_steps(), ast_translator_best_choice(), ast_channel_tech::bridge, LOG_WARNING, ast_channel::name, ast_channel::nativeformats, ast_channel::readformat, ast_channel::tech, and ast_channel::writeformat.
Referenced by ast_channel_make_compatible().
05611 { 05612 format_t src, dst; 05613 int use_slin; 05614 05615 /* See if the channel driver can natively make these two channels compatible */ 05616 if (from->tech->bridge && from->tech->bridge == to->tech->bridge && 05617 !ast_channel_setoption(from, AST_OPTION_MAKE_COMPATIBLE, to, sizeof(struct ast_channel *), 0)) { 05618 return 0; 05619 } 05620 05621 if (from->readformat == to->writeformat && from->writeformat == to->readformat) { 05622 /* Already compatible! Moving on ... */ 05623 return 0; 05624 } 05625 05626 /* Set up translation from the 'from' channel to the 'to' channel */ 05627 src = from->nativeformats; 05628 dst = to->nativeformats; 05629 05630 /* If there's no audio in this call, don't bother with trying to find a translation path */ 05631 if ((src & AST_FORMAT_AUDIO_MASK) == 0 || (dst & AST_FORMAT_AUDIO_MASK) == 0) 05632 return 0; 05633 05634 if (ast_translator_best_choice(&dst, &src) < 0) { 05635 ast_log(LOG_WARNING, "No path to translate from %s to %s\n", from->name, to->name); 05636 return -1; 05637 } 05638 05639 /* if the best path is not 'pass through', then 05640 * transcoding is needed; if desired, force transcode path 05641 * to use SLINEAR between channels, but only if there is 05642 * no direct conversion available. If generic PLC is 05643 * desired, then transcoding via SLINEAR is a requirement 05644 */ 05645 use_slin = (src == AST_FORMAT_SLINEAR || dst == AST_FORMAT_SLINEAR); 05646 if ((src != dst) && (ast_opt_generic_plc || ast_opt_transcode_via_slin) && 05647 (ast_translate_path_steps(dst, src) != 1 || use_slin)) 05648 dst = AST_FORMAT_SLINEAR; 05649 if (ast_set_read_format(from, dst) < 0) { 05650 ast_log(LOG_WARNING, "Unable to set read format on channel %s to %s\n", from->name, ast_getformatname(dst)); 05651 return -1; 05652 } 05653 if (ast_set_write_format(to, dst) < 0) { 05654 ast_log(LOG_WARNING, "Unable to set write format on channel %s to %s\n", to->name, ast_getformatname(dst)); 05655 return -1; 05656 } 05657 return 0; 05658 }
int ast_channel_masquerade | ( | struct ast_channel * | original, | |
struct ast_channel * | clone | |||
) |
Weird function made for call transfers.
original | channel to make a copy of | |
clone | copy of the original channel |
Definition at line 5767 of file channel.c.
References __ast_channel_masquerade().
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(), pickup_do(), sip_park(), and skinny_transfer().
05768 { 05769 return __ast_channel_masquerade(original, clone, NULL); 05770 }
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 7329 of file channel.c.
References ast_log(), chanlist::chan, errno, LOG_ERROR, ast_channel_tech::queryoption, and ast_channel::tech.
Referenced by ast_channel_get_cc_agent_type(), ast_channel_get_device_name(), ast_channel_get_t38_state(), local_queryoption(), rcvfax_exec(), and sndfax_exec().
07330 { 07331 if (!chan->tech->queryoption) { 07332 errno = ENOSYS; 07333 return -1; 07334 } 07335 07336 if (block) 07337 ast_log(LOG_ERROR, "XXX Blocking not implemented yet XXX\n"); 07338 07339 return chan->tech->queryoption(chan, option, data, datalen); 07340 }
void ast_channel_queue_connected_line_update | ( | struct ast_channel * | chan, | |
const struct ast_party_connected_line * | connected, | |||
const struct ast_set_party_connected_line * | update | |||
) |
Queue a connected line update frame on a channel.
chan | Asterisk channel to indicate connected line information | |
connected | Connected line information | |
update | What connected line information to update. NULL if all. |
Definition at line 8570 of file channel.c.
References ast_connected_line_build_data(), AST_CONTROL_CONNECTED_LINE, ast_queue_control_data(), connected, and update().
Referenced by ast_pickup_call(), handle_request_invite(), handle_request_update(), handle_response_invite(), local_attended_transfer(), masquerade_colp_transfer(), misdn_queue_connected_line_update(), pickup_do(), and sig_pri_handle_subcmds().
08571 { 08572 unsigned char data[1024]; /* This should be large enough */ 08573 size_t datalen; 08574 08575 datalen = ast_connected_line_build_data(data, sizeof(data), connected, update); 08576 if (datalen == (size_t) -1) { 08577 return; 08578 } 08579 08580 ast_queue_control_data(chan, AST_CONTROL_CONNECTED_LINE, data, datalen); 08581 }
void ast_channel_queue_redirecting_update | ( | struct ast_channel * | chan, | |
const struct ast_party_redirecting * | redirecting, | |||
const struct ast_set_party_redirecting * | update | |||
) |
Queue a redirecting update frame on a channel.
chan | Asterisk channel to indicate redirecting id information | |
redirecting | Redirecting id information | |
update | What redirecting information to update. NULL if all. |
Definition at line 9077 of file channel.c.
References AST_CONTROL_REDIRECTING, ast_queue_control_data(), ast_redirecting_build_data(), and update().
Referenced by cb_events(), handle_response_invite(), misdn_facility_ie_handler(), and sig_pri_handle_subcmds().
09078 { 09079 unsigned char data[1024]; /* This should be large enough */ 09080 size_t datalen; 09081 09082 datalen = ast_redirecting_build_data(data, sizeof(data), redirecting, update); 09083 if (datalen == (size_t) -1) { 09084 return; 09085 } 09086 09087 ast_queue_control_data(chan, AST_CONTROL_REDIRECTING, data, datalen); 09088 }
const char* ast_channel_reason2str | ( | int | reason | ) |
return an english explanation of the code returned thru __ast_request_and_dial's 'outstate' argument
reason | The integer argument, usually taken from AST_CONTROL_ macros |
Definition at line 5064 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().
05065 { 05066 switch (reason) /* the following appear to be the only ones actually returned by request_and_dial */ 05067 { 05068 case 0: 05069 return "Call Failure (not BUSY, and not NO_ANSWER, maybe Circuit busy or down?)"; 05070 case AST_CONTROL_HANGUP: 05071 return "Hangup"; 05072 case AST_CONTROL_RING: 05073 return "Local Ring"; 05074 case AST_CONTROL_RINGING: 05075 return "Remote end Ringing"; 05076 case AST_CONTROL_ANSWER: 05077 return "Remote end has Answered"; 05078 case AST_CONTROL_BUSY: 05079 return "Remote end is Busy"; 05080 case AST_CONTROL_CONGESTION: 05081 return "Congestion (circuits busy)"; 05082 default: 05083 return "Unknown Reason!!"; 05084 } 05085 }
int ast_channel_redirecting_macro | ( | struct ast_channel * | autoservice_chan, | |
struct ast_channel * | macro_chan, | |||
const void * | redirecting_info, | |||
int | is_caller, | |||
int | is_frame | |||
) |
Run a redirecting interception macro and update a channel's redirecting information.
autoservice_chan | Channel to place into autoservice while the macro is running. It is perfectly safe for this to be NULL | |
macro_chan | The channel to run the macro on. Also the channel from which we determine which macro we need to run. | |
redirecting_info | Either an ast_party_redirecting or ast_frame pointer of type AST_CONTROL_REDIRECTING | |
is_caller | If true, then run REDIRECTING_CALLER_SEND_MACRO, otherwise run REDIRECTING_CALLEE_SEND_MACRO | |
is_frame | If true, then redirecting_info is an ast_frame pointer, otherwise it is an ast_party_redirecting pointer. |
0 | Success | |
-1 | Either the macro does not exist, or there was an error while attempting to run the macro |
Make constants so that caller and frame can be more expressive than just '1' and '0'
Definition at line 9129 of file channel.c.
References ast_app_run_macro(), ast_channel_lock, ast_channel_unlock, ast_channel_update_redirecting(), ast_party_redirecting_copy(), ast_redirecting_parse_data(), ast_strdupa, ast_strlen_zero(), ast_frame::data, ast_frame::datalen, pbx_builtin_getvar_helper(), ast_frame::ptr, ast_channel::redirecting, and S_OR.
Referenced by ast_bridge_call(), do_forward(), feature_request_and_dial(), handle_frame(), and remote_bridge_loop().
09130 { 09131 const char *macro; 09132 const char *macro_args; 09133 int retval; 09134 09135 ast_channel_lock(macro_chan); 09136 macro = pbx_builtin_getvar_helper(macro_chan, is_caller 09137 ? "REDIRECTING_CALLER_SEND_MACRO" : "REDIRECTING_CALLEE_SEND_MACRO"); 09138 macro = ast_strdupa(S_OR(macro, "")); 09139 macro_args = pbx_builtin_getvar_helper(macro_chan, is_caller 09140 ? "REDIRECTING_CALLER_SEND_MACRO_ARGS" : "REDIRECTING_CALLEE_SEND_MACRO_ARGS"); 09141 macro_args = ast_strdupa(S_OR(macro_args, "")); 09142 09143 if (ast_strlen_zero(macro)) { 09144 ast_channel_unlock(macro_chan); 09145 return -1; 09146 } 09147 09148 if (is_frame) { 09149 const struct ast_frame *frame = redirecting_info; 09150 09151 ast_redirecting_parse_data(frame->data.ptr, frame->datalen, ¯o_chan->redirecting); 09152 } else { 09153 const struct ast_party_redirecting *redirecting = redirecting_info; 09154 09155 ast_party_redirecting_copy(¯o_chan->redirecting, redirecting); 09156 } 09157 ast_channel_unlock(macro_chan); 09158 09159 retval = ast_app_run_macro(autoservice_chan, macro_chan, macro, macro_args); 09160 if (!retval) { 09161 ast_channel_lock(macro_chan); 09162 ast_channel_update_redirecting(macro_chan, ¯o_chan->redirecting, NULL); 09163 ast_channel_unlock(macro_chan); 09164 } 09165 09166 return retval; 09167 }
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.
tech | Structure defining channel technology or "type" |
Definition at line 837 of file channel.c.
References ast_calloc, ast_debug, ast_log(), AST_RWLIST_INSERT_HEAD, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, chanlist::chan, chanlist::list, LOG_WARNING, ast_channel::tech, chanlist::tech, and ast_channel_tech::type.
Referenced by load_module(), and unload_module().
00838 { 00839 struct chanlist *chan; 00840 00841 AST_RWLIST_WRLOCK(&backends); 00842 00843 AST_RWLIST_TRAVERSE(&backends, chan, list) { 00844 if (!strcasecmp(tech->type, chan->tech->type)) { 00845 ast_log(LOG_WARNING, "Already have a handler for type '%s'\n", tech->type); 00846 AST_RWLIST_UNLOCK(&backends); 00847 return -1; 00848 } 00849 } 00850 00851 if (!(chan = ast_calloc(1, sizeof(*chan)))) { 00852 AST_RWLIST_UNLOCK(&backends); 00853 return -1; 00854 } 00855 chan->tech = tech; 00856 AST_RWLIST_INSERT_HEAD(&backends, chan, list); 00857 00858 ast_debug(1, "Registered handler for '%s' (%s)\n", chan->tech->type, chan->tech->description); 00859 00860 ast_verb(2, "Registered channel type '%s' (%s)\n", chan->tech->type, chan->tech->description); 00861 00862 AST_RWLIST_UNLOCK(&backends); 00863 00864 return 0; 00865 }
struct ast_channel* ast_channel_release | ( | struct ast_channel * | chan | ) |
Unlink and release reference to a channel.
This function will unlink the channel from the global channels container if it is still there and also release the current reference to the channel.
Definition at line 1827 of file channel.c.
References ao2_unlink, ast_channel_unref, chanlist::chan, and channels.
Referenced by acf_odbc_read(), acf_odbc_write(), action_getvar(), agent_cleanup(), agent_new(), ast_add_extension2_lockopt(), ast_cel_fabricate_channel_from_event(), ast_do_masquerade(), ast_hangup(), ast_iax2_new(), ast_pbx_outgoing_cdr_failed(), ast_request(), ast_str_substitute_variables_full(), bridge_request(), custom_log(), do_notify(), gtalk_newcall(), local_new(), local_request(), make_email_file(), manager_log(), pbx_substitute_variables_helper_full(), rotate_file(), sendmail(), sendpage(), syslog_log(), and write_cdr().
01828 { 01829 /* Safe, even if already unlinked. */ 01830 ao2_unlink(channels, chan); 01831 return ast_channel_unref(chan); 01832 }
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.
Definition at line 5597 of file channel.c.
References chanlist::chan, ast_channel_tech::send_html, and ast_channel::tech.
Referenced by agent_sendhtml(), and ast_channel_sendurl().
05598 { 05599 if (chan->tech->send_html) 05600 return chan->tech->send_html(chan, subclass, data, datalen); 05601 return -1; 05602 }
int ast_channel_sendurl | ( | struct ast_channel * | channel, | |
const char * | url | |||
) |
Sends a URL on a given link Send URL on link.
Definition at line 5604 of file channel.c.
References ast_channel_sendhtml(), AST_HTML_URL, and chanlist::chan.
Referenced by dial_exec_full(), and sendurl_exec().
05605 { 05606 return ast_channel_sendhtml(chan, AST_HTML_URL, url, strlen(url) + 1); 05607 }
void ast_channel_set_caller | ( | struct ast_channel * | chan, | |
const struct ast_party_caller * | caller, | |||
const struct ast_set_party_caller * | update | |||
) |
Set the caller id information in the Asterisk channel.
chan | Asterisk channel to set caller id information | |
caller | Caller id information | |
update | What caller information to update. NULL if all. |
Definition at line 6630 of file channel.c.
References ast_channel_lock, ast_channel_unlock, ast_party_caller_set(), ast_channel::caller, chanlist::chan, and update().
06631 { 06632 if (&chan->caller == caller) { 06633 /* Don't set to self */ 06634 return; 06635 } 06636 06637 ast_channel_lock(chan); 06638 ast_party_caller_set(&chan->caller, caller, update); 06639 ast_channel_unlock(chan); 06640 }
void ast_channel_set_caller_event | ( | struct ast_channel * | chan, | |
const struct ast_party_caller * | caller, | |||
const struct ast_set_party_caller * | update | |||
) |
Set the caller id information in the Asterisk channel and generate an AMI event if the caller id name or number changed.
chan | Asterisk channel to set caller id information | |
caller | Caller id information | |
update | What caller information to update. NULL if all. |
Definition at line 6642 of file channel.c.
References ast_cdr_setcid(), ast_channel_lock, ast_channel_unlock, ast_party_caller_set(), ast_channel::caller, ast_channel::cdr, chanlist::chan, ast_party_caller::id, ast_party_id::name, ast_party_id::number, report_new_callerid(), S_COR, ast_party_name::str, ast_party_number::str, update(), ast_party_name::valid, and ast_party_number::valid.
Referenced by callerid_write(), dial_exec_full(), misdn_update_caller_id(), ring_entry(), and sig_pri_handle_subcmds().
06643 { 06644 struct ast_party_caller pre_set; 06645 06646 if (&chan->caller == caller) { 06647 /* Don't set to self */ 06648 return; 06649 } 06650 06651 ast_channel_lock(chan); 06652 pre_set = chan->caller; 06653 ast_party_caller_set(&chan->caller, caller, update); 06654 if (S_COR(pre_set.id.number.valid, pre_set.id.number.str, NULL) 06655 != S_COR(chan->caller.id.number.valid, chan->caller.id.number.str, NULL) 06656 || S_COR(pre_set.id.name.valid, pre_set.id.name.str, NULL) 06657 != S_COR(chan->caller.id.name.valid, chan->caller.id.name.str, NULL)) { 06658 /* The caller id name or number changed. */ 06659 report_new_callerid(chan); 06660 } 06661 if (chan->cdr) { 06662 ast_cdr_setcid(chan->cdr, chan); 06663 } 06664 ast_channel_unlock(chan); 06665 }
void ast_channel_set_connected_line | ( | struct ast_channel * | chan, | |
const struct ast_party_connected_line * | connected, | |||
const struct ast_set_party_connected_line * | update | |||
) |
Set the connected line information in the Asterisk channel.
chan | Asterisk channel to set connected line information | |
connected | Connected line information | |
update | What connected line information to update. NULL if all. |
Definition at line 7930 of file channel.c.
References ast_channel_lock, ast_channel_unlock, ast_party_connected_line_set(), connected, ast_channel::connected, and update().
Referenced by __ast_request_and_dial(), ast_indicate_data(), connectedline_write(), dial_exec_full(), and feature_request_and_dial().
07931 { 07932 if (&chan->connected == connected) { 07933 /* Don't set to self */ 07934 return; 07935 } 07936 07937 ast_channel_lock(chan); 07938 ast_party_connected_line_set(&chan->connected, connected, update); 07939 ast_channel_unlock(chan); 07940 }
void ast_channel_set_fd | ( | struct ast_channel * | chan, | |
int | which, | |||
int | fd | |||
) |
Set the file descriptor on the channel
Definition at line 2526 of file channel.c.
References ast_calloc, chanlist::chan, ast_channel::data, ast_channel::fds, and free.
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(), my_swap_subchannels(), nbs_new(), oss_new(), phone_new(), setformat(), sip_new(), skinny_new(), start_rtp(), and swap_subs().
02527 { 02528 #ifdef HAVE_EPOLL 02529 struct epoll_event ev; 02530 struct ast_epoll_data *aed = NULL; 02531 02532 if (chan->fds[which] > -1) { 02533 epoll_ctl(chan->epfd, EPOLL_CTL_DEL, chan->fds[which], &ev); 02534 aed = chan->epfd_data[which]; 02535 } 02536 02537 /* If this new fd is valid, add it to the epoll */ 02538 if (fd > -1) { 02539 if (!aed && (!(aed = ast_calloc(1, sizeof(*aed))))) 02540 return; 02541 02542 chan->epfd_data[which] = aed; 02543 aed->chan = chan; 02544 aed->which = which; 02545 02546 ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP; 02547 ev.data.ptr = aed; 02548 epoll_ctl(chan->epfd, EPOLL_CTL_ADD, fd, &ev); 02549 } else if (aed) { 02550 /* We don't have to keep around this epoll data structure now */ 02551 free(aed); 02552 chan->epfd_data[which] = NULL; 02553 } 02554 #endif 02555 chan->fds[which] = fd; 02556 return; 02557 }
void ast_channel_set_linkgroup | ( | struct ast_channel * | chan, | |
struct ast_channel * | peer | |||
) |
propagate the linked id between chan and peer
Definition at line 6040 of file channel.c.
References ast_channel::_bridge, ast_bridged_channel(), ast_channel_change_linkedid(), ast_strdupa, chanlist::chan, ast_channel::linkedid, oldest_linkedid(), and ast_channel::uniqueid.
Referenced by ast_bridge_call(), and ast_do_masquerade().
06041 { 06042 const char* linkedid=NULL; 06043 struct ast_channel *bridged; 06044 06045 linkedid = oldest_linkedid(chan->linkedid, peer->linkedid); 06046 linkedid = oldest_linkedid(linkedid, chan->uniqueid); 06047 linkedid = oldest_linkedid(linkedid, peer->uniqueid); 06048 if (chan->_bridge) { 06049 bridged = ast_bridged_channel(chan); 06050 if (bridged != peer) { 06051 linkedid = oldest_linkedid(linkedid, bridged->linkedid); 06052 linkedid = oldest_linkedid(linkedid, bridged->uniqueid); 06053 } 06054 } 06055 if (peer->_bridge) { 06056 bridged = ast_bridged_channel(peer); 06057 if (bridged != chan) { 06058 linkedid = oldest_linkedid(linkedid, bridged->linkedid); 06059 linkedid = oldest_linkedid(linkedid, bridged->uniqueid); 06060 } 06061 } 06062 06063 /* just in case setting a stringfield to itself causes problems */ 06064 linkedid = ast_strdupa(linkedid); 06065 06066 ast_channel_change_linkedid(chan, linkedid); 06067 ast_channel_change_linkedid(peer, linkedid); 06068 if (chan->_bridge) { 06069 bridged = ast_bridged_channel(chan); 06070 if (bridged != peer) { 06071 ast_channel_change_linkedid(bridged, linkedid); 06072 } 06073 } 06074 if (peer->_bridge) { 06075 bridged = ast_bridged_channel(peer); 06076 if (bridged != chan) { 06077 ast_channel_change_linkedid(bridged, linkedid); 06078 } 06079 } 06080 }
void ast_channel_set_redirecting | ( | struct ast_channel * | chan, | |
const struct ast_party_redirecting * | redirecting, | |||
const struct ast_set_party_redirecting * | update | |||
) |
Set the redirecting id information in the Asterisk channel.
chan | Asterisk channel to set redirecting id information | |
redirecting | Redirecting id information | |
update | What redirecting information to update. NULL if all. |
Definition at line 8583 of file channel.c.
References ast_channel_lock, ast_channel_unlock, ast_party_redirecting_set(), ast_channel::redirecting, and update().
Referenced by ast_call_forward(), ast_indicate_data(), do_forward(), handle_request_invite(), handle_response(), misdn_copy_redirecting_to_ast(), redirecting_write(), and sig_pri_handle_subcmds().
08584 { 08585 if (&chan->redirecting == redirecting) { 08586 /* Don't set to self */ 08587 return; 08588 } 08589 08590 ast_channel_lock(chan); 08591 ast_party_redirecting_set(&chan->redirecting, redirecting, update); 08592 ast_channel_unlock(chan); 08593 }
int ast_channel_setoption | ( | struct ast_channel * | channel, | |
int | option, | |||
void * | data, | |||
int | datalen, | |||
int | block | |||
) |
Sets an option on a channel.
channel | channel to set options on | |
option | option to change | |
data | data specific to option | |
datalen | length of the data | |
block | blocking or not |
Definition at line 7316 of file channel.c.
References ast_log(), chanlist::chan, errno, LOG_ERROR, ast_channel_tech::setoption, and ast_channel::tech.
Referenced by analog_hangup(), ast_bridge_call(), ast_channel_make_compatible_helper(), common_exec(), conf_run(), dahdi_hangup(), dial_exec_full(), func_channel_write(), func_channel_write_real(), handle_tddmode(), play_record_review(), rcvfax_exec(), reset_volumes(), rpt(), rpt_exec(), set_format(), set_listen_volume(), set_security_requirements(), set_talk_volume(), sndfax_exec(), and vm_forwardoptions().
07317 { 07318 if (!chan->tech->setoption) { 07319 errno = ENOSYS; 07320 return -1; 07321 } 07322 07323 if (block) 07324 ast_log(LOG_ERROR, "XXX Blocking not implemented yet XXX\n"); 07325 07326 return chan->tech->setoption(chan, option, data, datalen); 07327 }
void ast_channel_setwhentohangup | ( | struct ast_channel * | chan, | |
time_t | offset | |||
) |
Set when to hang a channel up.
chan | channel on which to check for hang up | |
offset | offset in seconds relative to the current time of when to hang up |
Definition at line 808 of file channel.c.
References ast_channel_setwhentohangup_tv(), and chanlist::chan.
00809 { 00810 struct timeval when = { offset, }; 00811 ast_channel_setwhentohangup_tv(chan, when); 00812 }
void ast_channel_setwhentohangup_tv | ( | struct ast_channel * | chan, | |
struct timeval | offset | |||
) |
Set when to hang a channel up.
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 |
Definition at line 801 of file channel.c.
References ast_null_frame, ast_queue_frame(), ast_tvadd(), ast_tvnow(), ast_tvzero(), chanlist::chan, and ast_channel::whentohangup.
Referenced by action_timeout(), ast_channel_setwhentohangup(), handle_autohangup(), and timeout_write().
00802 { 00803 chan->whentohangup = ast_tvzero(offset) ? offset : ast_tvadd(offset, ast_tvnow()); 00804 ast_queue_frame(chan, &ast_null_frame); 00805 return; 00806 }
static int ast_channel_softhangup_cb | ( | void * | obj, | |
void * | arg, | |||
int | flags | |||
) | [static] |
Definition at line 764 of file channel.c.
References ast_softhangup(), AST_SOFTHANGUP_SHUTDOWN, and chanlist::chan.
Referenced by ast_begin_shutdown().
00765 { 00766 struct ast_channel *chan = obj; 00767 00768 ast_softhangup(chan, AST_SOFTHANGUP_SHUTDOWN); 00769 00770 return 0; 00771 }
struct ast_silence_generator* ast_channel_start_silence_generator | ( | struct ast_channel * | chan | ) |
Starts a silence generator on the given channel.
chan | The channel to generate silence on |
Definition at line 7804 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_channel::name, ast_silence_generator::old_write_format, silence_generator, state, and ast_channel::writeformat.
Referenced by __ast_play_and_record(), ast_dtmf_stream(), ast_readstring_full(), ast_safe_sleep_conditional(), channel_spy(), TransferCallStep1(), waitfor_exec(), and waitforring_exec().
07805 { 07806 struct ast_silence_generator *state; 07807 07808 if (!(state = ast_calloc(1, sizeof(*state)))) { 07809 return NULL; 07810 } 07811 07812 state->old_write_format = chan->writeformat; 07813 07814 if (ast_set_write_format(chan, AST_FORMAT_SLINEAR) < 0) { 07815 ast_log(LOG_ERROR, "Could not set write format to SLINEAR\n"); 07816 ast_free(state); 07817 return NULL; 07818 } 07819 07820 ast_activate_generator(chan, &silence_generator, state); 07821 07822 ast_debug(1, "Started silence generator on '%s'\n", chan->name); 07823 07824 return state; 07825 }
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.
chan | The channel to operate on | |
state | The ast_silence_generator pointer return by a previous call to ast_channel_start_silence_generator. |
Definition at line 7827 of file channel.c.
References ast_deactivate_generator(), ast_debug, ast_free, ast_log(), ast_set_write_format(), LOG_ERROR, ast_channel::name, and state.
Referenced by ast_dtmf_stream(), ast_readstring_full(), ast_safe_sleep_conditional(), channel_spy(), HandleCallOutgoing(), key_dial_page(), unistim_hangup(), waitfor_exec(), and waitforring_exec().
07828 { 07829 if (!state) 07830 return; 07831 07832 ast_deactivate_generator(chan); 07833 07834 ast_debug(1, "Stopped silence generator on '%s'\n", chan->name); 07835 07836 if (ast_set_write_format(chan, state->old_write_format) < 0) 07837 ast_log(LOG_ERROR, "Could not return write format to its original state\n"); 07838 07839 ast_free(state); 07840 }
int ast_channel_supports_html | ( | struct ast_channel * | channel | ) |
Checks for HTML support on a channel.
Definition at line 5592 of file channel.c.
References chanlist::chan, ast_channel_tech::send_html, and ast_channel::tech.
Referenced by dial_exec_full(), and sendurl_exec().
int ast_channel_transfer_masquerade | ( | struct ast_channel * | target_chan, | |
const struct ast_party_connected_line * | target_id, | |||
int | target_held, | |||
struct ast_channel * | transferee_chan, | |||
const struct ast_party_connected_line * | transferee_id, | |||
int | transferee_held | |||
) |
Setup a masquerade to transfer a call.
target_chan | Target of the call transfer. (Masquerade original channel) | |
target_id | New connected line information for the target channel. | |
target_held | TRUE if the target call is on hold. | |
transferee_chan | Transferee of the call transfer. (Masquerade clone channel) | |
transferee_id | New connected line information for the transferee channel. | |
transferee_held | TRUE if the transferee call is on hold. |
Party B transfers A to C.
Party A is connected to bridged channel B1. Party B is connected to channels C1 and C2. Party C is connected to bridged channel B2.
Party B -- C1 == B1 -- Party A __/ / Party B -- C2 == B2 -- Party C
Bridged channel B1 is masqueraded into channel C2. Where B1 is the masquerade clone channel and C2 is the masquerade original channel.
0 | on success. | |
-1 | on error. |
Definition at line 5841 of file channel.c.
References __ast_channel_masquerade(), ast_calloc, ast_datastore_alloc, ast_datastore_free(), ast_datastore::data, party_connected_line_copy_transfer(), xfer_masquerade_ds::target_id, xfer_masquerade_ds::transferee_id, and xfer_ds_info.
Referenced by analog_attempt_transfer(), misdn_attempt_transfer(), and sig_pri_attempt_transfer().
05848 { 05849 struct ast_datastore *xfer_ds; 05850 struct xfer_masquerade_ds *xfer_colp; 05851 int res; 05852 05853 xfer_ds = ast_datastore_alloc(&xfer_ds_info, NULL); 05854 if (!xfer_ds) { 05855 return -1; 05856 } 05857 05858 xfer_colp = ast_calloc(1, sizeof(*xfer_colp)); 05859 if (!xfer_colp) { 05860 ast_datastore_free(xfer_ds); 05861 return -1; 05862 } 05863 party_connected_line_copy_transfer(&xfer_colp->target_id, target_id); 05864 xfer_colp->target_held = target_held; 05865 party_connected_line_copy_transfer(&xfer_colp->transferee_id, transferee_id); 05866 xfer_colp->transferee_held = transferee_held; 05867 xfer_ds->data = xfer_colp; 05868 05869 res = __ast_channel_masquerade(target_chan, transferee_chan, xfer_ds); 05870 if (res) { 05871 ast_datastore_free(xfer_ds); 05872 } 05873 return res; 05874 }
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 1538 of file channel.c.
References ast_clear_flag, AST_FLAG_DEFER_DTMF, and chanlist::chan.
Referenced by find_cache(), and rpt_call().
01539 { 01540 if (chan) 01541 ast_clear_flag(chan, AST_FLAG_DEFER_DTMF); 01542 }
void ast_channel_unregister | ( | const struct ast_channel_tech * | tech | ) |
Unregister a channel technology.
tech | Structure defining channel technology or "type" that was previously registered |
Definition at line 868 of file channel.c.
References ast_debug, ast_free, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_END, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, chanlist::chan, chanlist::list, ast_channel::tech, chanlist::tech, and ast_channel_tech::type.
Referenced by __unload_module(), load_module(), and unload_module().
00869 { 00870 struct chanlist *chan; 00871 00872 ast_debug(1, "Unregistering channel type '%s'\n", tech->type); 00873 00874 AST_RWLIST_WRLOCK(&backends); 00875 00876 AST_RWLIST_TRAVERSE_SAFE_BEGIN(&backends, chan, list) { 00877 if (chan->tech == tech) { 00878 AST_LIST_REMOVE_CURRENT(list); 00879 ast_free(chan); 00880 ast_verb(2, "Unregistered channel type '%s'\n", tech->type); 00881 break; 00882 } 00883 } 00884 AST_LIST_TRAVERSE_SAFE_END; 00885 00886 AST_RWLIST_UNLOCK(&backends); 00887 }
void ast_channel_update_connected_line | ( | struct ast_channel * | chan, | |
const struct ast_party_connected_line * | connected, | |||
const struct ast_set_party_connected_line * | update | |||
) |
Indicate that the connected line information has changed.
chan | Asterisk channel to indicate connected line information | |
connected | Connected line information | |
update | What connected line information to update. NULL if all. |
Definition at line 8557 of file channel.c.
References ast_connected_line_build_data(), AST_CONTROL_CONNECTED_LINE, ast_indicate_data(), connected, and update().
Referenced by ast_channel_connected_line_macro(), ast_pickup_call(), atxfer_fail_cleanup(), builtin_atxfer(), builtin_blindtransfer(), connectedline_write(), pickup_do(), and wait_for_answer().
08558 { 08559 unsigned char data[1024]; /* This should be large enough */ 08560 size_t datalen; 08561 08562 datalen = ast_connected_line_build_data(data, sizeof(data), connected, update); 08563 if (datalen == (size_t) -1) { 08564 return; 08565 } 08566 08567 ast_indicate_data(chan, AST_CONTROL_CONNECTED_LINE, data, datalen); 08568 }
void ast_channel_update_redirecting | ( | struct ast_channel * | chan, | |
const struct ast_party_redirecting * | redirecting, | |||
const struct ast_set_party_redirecting * | update | |||
) |
Indicate that the redirecting id has changed.
chan | Asterisk channel to indicate redirecting id information | |
redirecting | Redirecting id information | |
update | What redirecting information to update. NULL if all. |
Definition at line 9064 of file channel.c.
References AST_CONTROL_REDIRECTING, ast_indicate_data(), ast_redirecting_build_data(), and update().
Referenced by ast_call_forward(), ast_channel_redirecting_macro(), do_forward(), and redirecting_write().
09065 { 09066 unsigned char data[1024]; /* This should be large enough */ 09067 size_t datalen; 09068 09069 datalen = ast_redirecting_build_data(data, sizeof(data), redirecting, update); 09070 if (datalen == (size_t) -1) { 09071 return; 09072 } 09073 09074 ast_indicate_data(chan, AST_CONTROL_REDIRECTING, data, datalen); 09075 }
void ast_channels_init | ( | void | ) |
Provided by channel.c
Definition at line 7718 of file channel.c.
References ao2_container_alloc, ARRAY_LEN, ast_channel_cmp_cb(), ast_channel_hash_cb(), ast_cli_register_multiple(), ast_data_register_multiple_core, ast_plc_reload(), channel_providers, channels, cli_channel, and NUM_CHANNEL_BUCKETS.
Referenced by main().
07719 { 07720 channels = ao2_container_alloc(NUM_CHANNEL_BUCKETS, 07721 ast_channel_hash_cb, ast_channel_cmp_cb); 07722 07723 ast_cli_register_multiple(cli_channel, ARRAY_LEN(cli_channel)); 07724 07725 ast_data_register_multiple_core(channel_providers, ARRAY_LEN(channel_providers)); 07726 07727 ast_plc_reload(); 07728 }
struct ast_variable* ast_channeltype_list | ( | void | ) |
return an ast_variable list of channeltypes
Definition at line 248 of file channel.c.
References AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_variable_new(), ast_channel_tech::description, chanlist::list, chanlist::tech, ast_channel_tech::type, and var.
Referenced by ast_var_channel_types(), and ast_var_channel_types_table().
00249 { 00250 struct chanlist *cl; 00251 struct ast_variable *var = NULL, *prev = NULL; 00252 00253 AST_RWLIST_RDLOCK(&backends); 00254 AST_RWLIST_TRAVERSE(&backends, cl, list) { 00255 if (prev) { 00256 if ((prev->next = ast_variable_new(cl->tech->type, cl->tech->description, ""))) 00257 prev = prev->next; 00258 } else { 00259 var = ast_variable_new(cl->tech->type, cl->tech->description, ""); 00260 prev = var; 00261 } 00262 } 00263 AST_RWLIST_UNLOCK(&backends); 00264 00265 return var; 00266 }
int ast_check_hangup | ( | struct ast_channel * | chan | ) |
Check to see if a channel is needing hang up.
chan | channel on which to check for hang up This function determines if the channel is being requested to be hung up. |
Definition at line 742 of file channel.c.
References ast_channel::_softhangup, ast_debug, AST_SOFTHANGUP_TIMEOUT, ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), chanlist::chan, and ast_channel::whentohangup.
Referenced by __ast_pbx_run(), __ast_read(), _macro_exec(), agent_indicate(), agi_exec(), agi_handle_command(), announce_thread(), ast_bridge_call(), ast_call(), ast_channel_bridge(), ast_check_hangup_locked(), ast_indicate_data(), ast_raw_answer(), ast_readstring_full(), ast_recvtext(), ast_rtp_instance_bridge(), ast_sendtext(), ast_transfer(), ast_udptl_bridge(), ast_waitfordigit_full(), ast_write(), autoservice_run(), bridge_call_thread(), bridge_exec(), 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(), feature_request_and_dial(), findmeexec(), func_channel_read(), handle_sendimage(), launch_asyncagi(), local_fixup(), lua_check_hangup(), ospfinished_exec(), pbx_builtin_incomplete(), pbx_exec(), read_exec(), readexten_exec(), remote_bridge_loop(), rpt(), and run_ras().
00743 { 00744 if (chan->_softhangup) /* yes if soft hangup flag set */ 00745 return 1; 00746 if (ast_tvzero(chan->whentohangup)) /* no if no hangup scheduled */ 00747 return 0; 00748 if (ast_tvdiff_ms(chan->whentohangup, ast_tvnow()) > 0) /* no if hangup time has not come yet. */ 00749 return 0; 00750 ast_debug(4, "Hangup time has come: %" PRIi64 "\n", ast_tvdiff_ms(chan->whentohangup, ast_tvnow())); 00751 chan->_softhangup |= AST_SOFTHANGUP_TIMEOUT; /* record event */ 00752 return 1; 00753 }
int ast_check_hangup_locked | ( | struct ast_channel * | chan | ) |
Definition at line 755 of file channel.c.
References ast_channel_lock, ast_channel_unlock, ast_check_hangup(), and chanlist::chan.
Referenced by action_redirect(), and ast_channel_bridge().
00756 { 00757 int res; 00758 ast_channel_lock(chan); 00759 res = ast_check_hangup(chan); 00760 ast_channel_unlock(chan); 00761 return res; 00762 }
int ast_connected_line_build_data | ( | unsigned char * | data, | |
size_t | datalen, | |||
const struct ast_party_connected_line * | connected, | |||
const struct ast_set_party_connected_line * | update | |||
) |
Build the connected line information data frame.
data | Buffer to fill with the frame data | |
datalen | Size of the buffer to fill | |
connected | Connected line information | |
update | What connected line information to build. NULL if all. |
-1 | if error | |
Amount | of data buffer used |
Definition at line 8297 of file channel.c.
References AST_CONNECTED_LINE_ID_PRESENTATION, AST_CONNECTED_LINE_NAME, AST_CONNECTED_LINE_NAME_CHAR_SET, AST_CONNECTED_LINE_NAME_PRESENTATION, AST_CONNECTED_LINE_NAME_VALID, AST_CONNECTED_LINE_NUMBER, AST_CONNECTED_LINE_NUMBER_PLAN, AST_CONNECTED_LINE_NUMBER_PRESENTATION, AST_CONNECTED_LINE_NUMBER_VALID, AST_CONNECTED_LINE_SOURCE, AST_CONNECTED_LINE_SUBADDRESS, AST_CONNECTED_LINE_SUBADDRESS_ODD_EVEN, AST_CONNECTED_LINE_SUBADDRESS_TYPE, AST_CONNECTED_LINE_SUBADDRESS_VALID, AST_CONNECTED_LINE_TAG, AST_CONNECTED_LINE_VERSION, ast_log(), connected, LOG_WARNING, ast_party_id_ies::name, party_id_build_data(), ast_party_name_ies::str, update(), and value.
Referenced by ast_channel_queue_connected_line_update(), ast_channel_update_connected_line(), local_attended_transfer(), local_indicate(), and masquerade_colp_transfer().
08298 { 08299 int32_t value; 08300 size_t pos = 0; 08301 int res; 08302 08303 static const struct ast_party_id_ies ies = { 08304 .name.str = AST_CONNECTED_LINE_NAME, 08305 .name.char_set = AST_CONNECTED_LINE_NAME_CHAR_SET, 08306 .name.presentation = AST_CONNECTED_LINE_NAME_PRESENTATION, 08307 .name.valid = AST_CONNECTED_LINE_NAME_VALID, 08308 08309 .number.str = AST_CONNECTED_LINE_NUMBER, 08310 .number.plan = AST_CONNECTED_LINE_NUMBER_PLAN, 08311 .number.presentation = AST_CONNECTED_LINE_NUMBER_PRESENTATION, 08312 .number.valid = AST_CONNECTED_LINE_NUMBER_VALID, 08313 08314 .subaddress.str = AST_CONNECTED_LINE_SUBADDRESS, 08315 .subaddress.type = AST_CONNECTED_LINE_SUBADDRESS_TYPE, 08316 .subaddress.odd_even_indicator = AST_CONNECTED_LINE_SUBADDRESS_ODD_EVEN, 08317 .subaddress.valid = AST_CONNECTED_LINE_SUBADDRESS_VALID, 08318 08319 .tag = AST_CONNECTED_LINE_TAG, 08320 .combined_presentation = AST_CONNECTED_LINE_ID_PRESENTATION, 08321 }; 08322 08323 /* 08324 * The size of integer values must be fixed in case the frame is 08325 * shipped to another machine. 08326 */ 08327 08328 /* Connected line frame version */ 08329 if (datalen < pos + (sizeof(data[0]) * 2) + 1) { 08330 ast_log(LOG_WARNING, "No space left for connected line frame version\n"); 08331 return -1; 08332 } 08333 data[pos++] = AST_CONNECTED_LINE_VERSION; 08334 data[pos++] = 1; 08335 data[pos++] = 2;/* Version 1 did not have a version ie */ 08336 08337 res = party_id_build_data(data + pos, datalen - pos, &connected->id, 08338 "connected line", &ies, update ? &update->id : NULL); 08339 if (res < 0) { 08340 return -1; 08341 } 08342 pos += res; 08343 08344 /* Connected line source */ 08345 if (datalen < pos + (sizeof(data[0]) * 2) + sizeof(value)) { 08346 ast_log(LOG_WARNING, "No space left for connected line source\n"); 08347 return -1; 08348 } 08349 data[pos++] = AST_CONNECTED_LINE_SOURCE; 08350 data[pos++] = sizeof(value); 08351 value = htonl(connected->source); 08352 memcpy(data + pos, &value, sizeof(value)); 08353 pos += sizeof(value); 08354 08355 return pos; 08356 }
void ast_connected_line_copy_from_caller | ( | struct ast_party_connected_line * | dest, | |
const struct ast_party_caller * | src | |||
) |
Copy the caller information to the connected line information.
dest | Destination connected line information | |
src | Source caller information |
Definition at line 7915 of file channel.c.
References ast_party_caller::ani, ast_party_connected_line::ani, ast_party_caller::ani2, ast_party_connected_line::ani2, ast_party_id_copy(), ast_party_caller::id, and ast_party_connected_line::id.
Referenced by begin_dial_channel(), builtin_atxfer(), dial_exec_full(), feature_request_and_dial(), local_call(), pickup_do(), ring_entry(), and wait_for_answer().
07916 { 07917 ast_party_id_copy(&dest->id, &src->id); 07918 ast_party_id_copy(&dest->ani, &src->ani); 07919 dest->ani2 = src->ani2; 07920 }
void ast_connected_line_copy_to_caller | ( | struct ast_party_caller * | dest, | |
const struct ast_party_connected_line * | src | |||
) |
Copy the connected line information to the caller information.
dest | Destination caller information | |
src | Source connected line information |
Definition at line 7922 of file channel.c.
References ast_party_connected_line::ani, ast_party_caller::ani, ast_party_connected_line::ani2, ast_party_caller::ani2, ast_party_id_copy(), ast_party_connected_line::id, and ast_party_caller::id.
Referenced by local_call(), and local_indicate().
07923 { 07924 ast_party_id_copy(&dest->id, &src->id); 07925 ast_party_id_copy(&dest->ani, &src->ani); 07926 07927 dest->ani2 = src->ani2; 07928 }
int ast_connected_line_parse_data | ( | const unsigned char * | data, | |
size_t | datalen, | |||
struct ast_party_connected_line * | connected | |||
) |
Parse connected line indication frame data.
data | Buffer with the frame data to parse | |
datalen | Size of the buffer | |
connected | Extracted connected line information |
0 | on success. | |
-1 | on error. |
The filled in connected line structure needs to be destroyed by ast_party_connected_line_free() when it is no longer needed.
Definition at line 8358 of file channel.c.
References AST_CONNECTED_LINE_ID_PRESENTATION, AST_CONNECTED_LINE_NAME, AST_CONNECTED_LINE_NAME_CHAR_SET, AST_CONNECTED_LINE_NAME_PRESENTATION, AST_CONNECTED_LINE_NAME_VALID, AST_CONNECTED_LINE_NUMBER, AST_CONNECTED_LINE_NUMBER_PLAN, AST_CONNECTED_LINE_NUMBER_PRESENTATION, AST_CONNECTED_LINE_NUMBER_VALID, AST_CONNECTED_LINE_SOURCE, AST_CONNECTED_LINE_SUBADDRESS, AST_CONNECTED_LINE_SUBADDRESS_ODD_EVEN, AST_CONNECTED_LINE_SUBADDRESS_TYPE, AST_CONNECTED_LINE_SUBADDRESS_VALID, AST_CONNECTED_LINE_TAG, AST_CONNECTED_LINE_VERSION, ast_free, ast_log(), ast_malloc, AST_PARTY_CHAR_SET_ISO8859_1, ast_party_id_ies::combined_presentation, connected, LOG_DEBUG, LOG_WARNING, and value.
Referenced by __ast_read(), ast_channel_connected_line_macro(), ast_indicate_data(), feature_request_and_dial(), and socket_process().
08359 { 08360 size_t pos; 08361 unsigned char ie_len; 08362 unsigned char ie_id; 08363 int32_t value; 08364 int frame_version = 1; 08365 int combined_presentation = 0; 08366 int got_combined_presentation = 0;/* TRUE if got a combined name and number presentation value. */ 08367 08368 for (pos = 0; pos < datalen; pos += ie_len) { 08369 if (datalen < pos + sizeof(ie_id) + sizeof(ie_len)) { 08370 ast_log(LOG_WARNING, "Invalid connected line update\n"); 08371 return -1; 08372 } 08373 ie_id = data[pos++]; 08374 ie_len = data[pos++]; 08375 if (datalen < pos + ie_len) { 08376 ast_log(LOG_WARNING, "Invalid connected line update\n"); 08377 return -1; 08378 } 08379 08380 switch (ie_id) { 08381 /* Connected line party frame version */ 08382 case AST_CONNECTED_LINE_VERSION: 08383 if (ie_len != 1) { 08384 ast_log(LOG_WARNING, "Invalid connected line frame version (%u)\n", 08385 (unsigned) ie_len); 08386 break; 08387 } 08388 frame_version = data[pos]; 08389 break; 08390 /* Connected line party id name */ 08391 case AST_CONNECTED_LINE_NAME: 08392 ast_free(connected->id.name.str); 08393 connected->id.name.str = ast_malloc(ie_len + 1); 08394 if (connected->id.name.str) { 08395 memcpy(connected->id.name.str, data + pos, ie_len); 08396 connected->id.name.str[ie_len] = 0; 08397 } 08398 break; 08399 case AST_CONNECTED_LINE_NAME_CHAR_SET: 08400 if (ie_len != 1) { 08401 ast_log(LOG_WARNING, "Invalid connected line name char set (%u)\n", 08402 (unsigned) ie_len); 08403 break; 08404 } 08405 connected->id.name.char_set = data[pos]; 08406 break; 08407 case AST_CONNECTED_LINE_NAME_PRESENTATION: 08408 if (ie_len != 1) { 08409 ast_log(LOG_WARNING, "Invalid connected line name presentation (%u)\n", 08410 (unsigned) ie_len); 08411 break; 08412 } 08413 connected->id.name.presentation = data[pos]; 08414 break; 08415 case AST_CONNECTED_LINE_NAME_VALID: 08416 if (ie_len != 1) { 08417 ast_log(LOG_WARNING, "Invalid connected line name valid (%u)\n", 08418 (unsigned) ie_len); 08419 break; 08420 } 08421 connected->id.name.valid = data[pos]; 08422 break; 08423 /* Connected line party id number */ 08424 case AST_CONNECTED_LINE_NUMBER: 08425 ast_free(connected->id.number.str); 08426 connected->id.number.str = ast_malloc(ie_len + 1); 08427 if (connected->id.number.str) { 08428 memcpy(connected->id.number.str, data + pos, ie_len); 08429 connected->id.number.str[ie_len] = 0; 08430 } 08431 break; 08432 case AST_CONNECTED_LINE_NUMBER_PLAN: 08433 if (ie_len != 1) { 08434 ast_log(LOG_WARNING, "Invalid connected line numbering plan (%u)\n", 08435 (unsigned) ie_len); 08436 break; 08437 } 08438 connected->id.number.plan = data[pos]; 08439 break; 08440 case AST_CONNECTED_LINE_NUMBER_PRESENTATION: 08441 if (ie_len != 1) { 08442 ast_log(LOG_WARNING, "Invalid connected line number presentation (%u)\n", 08443 (unsigned) ie_len); 08444 break; 08445 } 08446 connected->id.number.presentation = data[pos]; 08447 break; 08448 case AST_CONNECTED_LINE_NUMBER_VALID: 08449 if (ie_len != 1) { 08450 ast_log(LOG_WARNING, "Invalid connected line number valid (%u)\n", 08451 (unsigned) ie_len); 08452 break; 08453 } 08454 connected->id.number.valid = data[pos]; 08455 break; 08456 /* Connected line party id combined presentation */ 08457 case AST_CONNECTED_LINE_ID_PRESENTATION: 08458 if (ie_len != 1) { 08459 ast_log(LOG_WARNING, "Invalid connected line combined presentation (%u)\n", 08460 (unsigned) ie_len); 08461 break; 08462 } 08463 combined_presentation = data[pos]; 08464 got_combined_presentation = 1; 08465 break; 08466 /* Connected line party id subaddress */ 08467 case AST_CONNECTED_LINE_SUBADDRESS: 08468 ast_free(connected->id.subaddress.str); 08469 connected->id.subaddress.str = ast_malloc(ie_len + 1); 08470 if (connected->id.subaddress.str) { 08471 memcpy(connected->id.subaddress.str, data + pos, ie_len); 08472 connected->id.subaddress.str[ie_len] = 0; 08473 } 08474 break; 08475 case AST_CONNECTED_LINE_SUBADDRESS_TYPE: 08476 if (ie_len != 1) { 08477 ast_log(LOG_WARNING, "Invalid connected line type of subaddress (%u)\n", 08478 (unsigned) ie_len); 08479 break; 08480 } 08481 connected->id.subaddress.type = data[pos]; 08482 break; 08483 case AST_CONNECTED_LINE_SUBADDRESS_ODD_EVEN: 08484 if (ie_len != 1) { 08485 ast_log(LOG_WARNING, 08486 "Invalid connected line subaddress odd-even indicator (%u)\n", 08487 (unsigned) ie_len); 08488 break; 08489 } 08490 connected->id.subaddress.odd_even_indicator = data[pos]; 08491 break; 08492 case AST_CONNECTED_LINE_SUBADDRESS_VALID: 08493 if (ie_len != 1) { 08494 ast_log(LOG_WARNING, "Invalid connected line subaddress valid (%u)\n", 08495 (unsigned) ie_len); 08496 break; 08497 } 08498 connected->id.subaddress.valid = data[pos]; 08499 break; 08500 /* Connected line party tag */ 08501 case AST_CONNECTED_LINE_TAG: 08502 ast_free(connected->id.tag); 08503 connected->id.tag = ast_malloc(ie_len + 1); 08504 if (connected->id.tag) { 08505 memcpy(connected->id.tag, data + pos, ie_len); 08506 connected->id.tag[ie_len] = 0; 08507 } 08508 break; 08509 /* Connected line party source */ 08510 case AST_CONNECTED_LINE_SOURCE: 08511 if (ie_len != sizeof(value)) { 08512 ast_log(LOG_WARNING, "Invalid connected line source (%u)\n", 08513 (unsigned) ie_len); 08514 break; 08515 } 08516 memcpy(&value, data + pos, sizeof(value)); 08517 connected->source = ntohl(value); 08518 break; 08519 /* Connected line party unknown element */ 08520 default: 08521 ast_log(LOG_DEBUG, "Unknown connected line element: %u (%u)\n", 08522 (unsigned) ie_id, (unsigned) ie_len); 08523 break; 08524 } 08525 } 08526 08527 switch (frame_version) { 08528 case 1: 08529 /* 08530 * The other end is an earlier version that we need to adjust 08531 * for compatibility. 08532 */ 08533 connected->id.name.valid = 1; 08534 connected->id.name.char_set = AST_PARTY_CHAR_SET_ISO8859_1; 08535 connected->id.number.valid = 1; 08536 if (got_combined_presentation) { 08537 connected->id.name.presentation = combined_presentation; 08538 connected->id.number.presentation = combined_presentation; 08539 } 08540 break; 08541 case 2: 08542 /* The other end is at the same level as we are. */ 08543 break; 08544 default: 08545 /* 08546 * The other end is newer than we are. 08547 * We need to assume that they are compatible with us. 08548 */ 08549 ast_log(LOG_DEBUG, "Connected line frame has newer version: %u\n", 08550 (unsigned) frame_version); 08551 break; 08552 } 08553 08554 return 0; 08555 }
AST_DATA_STRUCTURE | ( | ast_channel | , | |
DATA_EXPORT_CHANNEL | ||||
) |
void ast_deactivate_generator | ( | struct ast_channel * | chan | ) |
Deactivate an active generator
Definition at line 2956 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(), chanlist::chan, 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().
02957 { 02958 ast_channel_lock(chan); 02959 if (chan->generatordata) { 02960 if (chan->generator && chan->generator->release) 02961 chan->generator->release(chan, chan->generatordata); 02962 chan->generatordata = NULL; 02963 chan->generator = NULL; 02964 ast_channel_set_fd(chan, AST_GENERATOR_FD, -1); 02965 ast_clear_flag(chan, AST_FLAG_WRITE_INT); 02966 ast_settimeout(chan, 0, NULL, NULL); 02967 } 02968 ast_channel_unlock(chan); 02969 }
int ast_do_masquerade | ( | struct ast_channel * | original | ) |
Start masquerading a channel.
Definition at line 6199 of file channel.c.
References __ast_change_name_nolink(), ast_channel::_bridge, ast_channel::_softhangup, ast_channel::_state, accountcode, ast_channel::adsicpe, ast_channel::alertpipe, ao2_link, ao2_lock, ao2_unlink, ao2_unlock, ast_app_group_update(), ast_autochan_new_channel(), ast_bridged_channel(), ast_cause2str(), AST_CEL_BRIDGE_UPDATE, ast_cel_report_event(), ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_channel_lock, AST_CHANNEL_NAME, ast_channel_release(), ast_channel_set_fd(), ast_channel_set_linkgroup(), ast_channel_trylock, ast_channel_unlock, AST_CONTROL_SRCCHANGE, AST_CONTROL_UNHOLD, ast_copy_string(), ast_datastore_free(), ast_debug, AST_FLAG_BLOCKING, AST_FLAG_EXCEPTION, AST_FLAG_OUTGOING, AST_FLAG_ZOMBIE, AST_GENERATOR_FD, ast_getformatname(), 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_manager_event, ast_manager_event_multichan, 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::caller, ast_channel::cdr, ast_datastore_info::chan_fixup, CHANNEL_DEADLOCK_AVOIDANCE, channels, clone_variables(), ast_channel::connected, chanlist::connected, ast_datastore::data, ast_channel::datastores, ast_channel::dialed, ast_datastore::entry, errno, EVENT_FLAG_CALL, ast_channel::fdno, ast_channel::fds, ast_channel_tech::fixup, free_translation(), ast_channel_tech::hangup, ast_datastore::info, ast_channel::language, language, LOG_WARNING, ast_channel::masq, ast_channel::masqr, masquerade_colp_transfer(), ast_channel::monitor, musicclass, ast_channel::name, ast_channel::nativeformats, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel::readformat, ast_channel::readq, ast_channel::redirecting, report_new_callerid(), S_OR, ast_channel::tech, ast_channel::tech_pvt, ast_channel::timingfd, xfer_masquerade_ds::transferee_held, ast_channel_tech::type, ast_channel::visible_indication, ast_channel::writeformat, and xfer_ds_info.
Referenced by __ast_read(), ast_async_goto(), ast_hangup(), ast_waitfor_nandfds(), ast_write(), builtin_atxfer(), do_bridge_masquerade(), handle_invite_replaces(), iax_park(), local_attended_transfer(), sip_park(), and sip_park_thread().
06200 { 06201 format_t x; 06202 int i; 06203 int res=0; 06204 int origstate; 06205 int visible_indication; 06206 struct ast_frame *current; 06207 const struct ast_channel_tech *t; 06208 void *t_pvt; 06209 union { 06210 struct ast_party_dialed dialed; 06211 struct ast_party_caller caller; 06212 struct ast_party_connected_line connected; 06213 struct ast_party_redirecting redirecting; 06214 } exchange; 06215 struct ast_channel *clonechan, *chans[2]; 06216 struct ast_channel *bridged; 06217 struct ast_cdr *cdr; 06218 struct ast_datastore *xfer_ds; 06219 struct xfer_masquerade_ds *xfer_colp; 06220 format_t rformat = original->readformat; 06221 format_t wformat = original->writeformat; 06222 char newn[AST_CHANNEL_NAME]; 06223 char orig[AST_CHANNEL_NAME]; 06224 char masqn[AST_CHANNEL_NAME]; 06225 char zombn[AST_CHANNEL_NAME]; 06226 06227 /* XXX This operation is a bit odd. We're essentially putting the guts of 06228 * the clone channel into the original channel. Start by killing off the 06229 * original channel's backend. While the features are nice, which is the 06230 * reason we're keeping it, it's still awesomely weird. XXX */ 06231 06232 /* The reasoning for the channels ao2_container lock here is complex. 06233 * 06234 * In order to check for a race condition, the original channel must 06235 * be locked. If it is determined that the masquerade should proceed 06236 * the original channel can absolutely not be unlocked until the end 06237 * of the function. Since after determining the masquerade should 06238 * continue requires the channels to be unlinked from the ao2_container, 06239 * the container lock must be held first to achieve proper locking order. 06240 */ 06241 ao2_lock(channels); 06242 06243 /* lock the original channel to determine if the masquerade is require or not */ 06244 ast_channel_lock(original); 06245 06246 /* This checks to see if the masquerade has already happened or not. There is a 06247 * race condition that exists for this function. Since all pvt and channel locks 06248 * must be let go before calling do_masquerade, it is possible that it could be 06249 * called multiple times for the same channel. This check verifies whether 06250 * or not the masquerade has already been completed by another thread */ 06251 if (!original->masq) { 06252 ast_channel_unlock(original); 06253 ao2_unlock(channels); 06254 return 0; /* masq already completed by another thread, or never needed to be done to begin with */ 06255 } 06256 06257 /* now that we have verified no race condition exists, set the clone channel */ 06258 clonechan = original->masq; 06259 06260 /* since this function already holds the global container lock, unlocking original 06261 * for deadlock avoidance will not result in any sort of masquerade race condition. 06262 * If masq is called by a different thread while this happens, it will be stuck waiting 06263 * until we unlock the container. */ 06264 while (ast_channel_trylock(clonechan)) { 06265 CHANNEL_DEADLOCK_AVOIDANCE(original); 06266 } 06267 06268 /* Get any transfer masquerade connected line exchange data. */ 06269 xfer_ds = ast_channel_datastore_find(original, &xfer_ds_info, NULL); 06270 if (xfer_ds) { 06271 ast_channel_datastore_remove(original, xfer_ds); 06272 xfer_colp = xfer_ds->data; 06273 } else { 06274 xfer_colp = NULL; 06275 } 06276 06277 /* 06278 * Release any hold on the transferee channel before proceeding 06279 * with the masquerade. 06280 */ 06281 if (xfer_colp && xfer_colp->transferee_held) { 06282 ast_indicate(clonechan, AST_CONTROL_UNHOLD); 06283 } 06284 06285 /* clear the masquerade channels */ 06286 original->masq = NULL; 06287 clonechan->masqr = NULL; 06288 06289 /* unlink from channels container as name (which is the hash value) will change */ 06290 ao2_unlink(channels, original); 06291 ao2_unlink(channels, clonechan); 06292 06293 ast_debug(4, "Actually Masquerading %s(%d) into the structure of %s(%d)\n", 06294 clonechan->name, clonechan->_state, original->name, original->_state); 06295 06296 /* 06297 * Stop any visible indiction on the original channel so we can 06298 * transfer it to the clonechan taking the original's place. 06299 */ 06300 visible_indication = original->visible_indication; 06301 ast_indicate(original, -1); 06302 06303 chans[0] = clonechan; 06304 chans[1] = original; 06305 ast_manager_event_multichan(EVENT_FLAG_CALL, "Masquerade", 2, chans, 06306 "Clone: %s\r\n" 06307 "CloneState: %s\r\n" 06308 "Original: %s\r\n" 06309 "OriginalState: %s\r\n", 06310 clonechan->name, ast_state2str(clonechan->_state), original->name, ast_state2str(original->_state)); 06311 06312 /* Having remembered the original read/write formats, we turn off any translation on either 06313 one */ 06314 free_translation(clonechan); 06315 free_translation(original); 06316 06317 /* Save the original name */ 06318 ast_copy_string(orig, original->name, sizeof(orig)); 06319 /* Save the new name */ 06320 ast_copy_string(newn, clonechan->name, sizeof(newn)); 06321 /* Create the masq name */ 06322 snprintf(masqn, sizeof(masqn), "%s<MASQ>", newn); 06323 06324 /* Mangle the name of the clone channel */ 06325 __ast_change_name_nolink(clonechan, masqn); 06326 06327 /* Copy the name from the clone channel */ 06328 __ast_change_name_nolink(original, newn); 06329 06330 /* share linked id's */ 06331 ast_channel_set_linkgroup(original, clonechan); 06332 06333 /* Swap the technologies */ 06334 t = original->tech; 06335 original->tech = clonechan->tech; 06336 clonechan->tech = t; 06337 06338 /* Swap the cdrs */ 06339 cdr = original->cdr; 06340 original->cdr = clonechan->cdr; 06341 clonechan->cdr = cdr; 06342 06343 t_pvt = original->tech_pvt; 06344 original->tech_pvt = clonechan->tech_pvt; 06345 clonechan->tech_pvt = t_pvt; 06346 06347 /* Swap the alertpipes */ 06348 for (i = 0; i < 2; i++) { 06349 x = original->alertpipe[i]; 06350 original->alertpipe[i] = clonechan->alertpipe[i]; 06351 clonechan->alertpipe[i] = x; 06352 } 06353 06354 /* 06355 * Swap the readq's. The end result should be this: 06356 * 06357 * 1) All frames should be on the new (original) channel. 06358 * 2) Any frames that were already on the new channel before this 06359 * masquerade need to be at the end of the readq, after all of the 06360 * frames on the old (clone) channel. 06361 * 3) The alertpipe needs to get poked for every frame that was already 06362 * on the new channel, since we are now using the alert pipe from the 06363 * old (clone) channel. 06364 */ 06365 { 06366 AST_LIST_HEAD_NOLOCK(, ast_frame) tmp_readq; 06367 AST_LIST_HEAD_SET_NOLOCK(&tmp_readq, NULL); 06368 06369 AST_LIST_APPEND_LIST(&tmp_readq, &original->readq, frame_list); 06370 AST_LIST_APPEND_LIST(&original->readq, &clonechan->readq, frame_list); 06371 06372 while ((current = AST_LIST_REMOVE_HEAD(&tmp_readq, frame_list))) { 06373 AST_LIST_INSERT_TAIL(&original->readq, current, frame_list); 06374 if (original->alertpipe[1] > -1) { 06375 int poke = 0; 06376 06377 if (write(original->alertpipe[1], &poke, sizeof(poke)) < 0) { 06378 ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno)); 06379 } 06380 } 06381 } 06382 } 06383 06384 /* Swap the raw formats */ 06385 x = original->rawreadformat; 06386 original->rawreadformat = clonechan->rawreadformat; 06387 clonechan->rawreadformat = x; 06388 x = original->rawwriteformat; 06389 original->rawwriteformat = clonechan->rawwriteformat; 06390 clonechan->rawwriteformat = x; 06391 06392 clonechan->_softhangup = AST_SOFTHANGUP_DEV; 06393 06394 /* And of course, so does our current state. Note we need not 06395 call ast_setstate since the event manager doesn't really consider 06396 these separate. We do this early so that the clone has the proper 06397 state of the original channel. */ 06398 origstate = original->_state; 06399 original->_state = clonechan->_state; 06400 clonechan->_state = origstate; 06401 06402 if (clonechan->tech->fixup && clonechan->tech->fixup(original, clonechan)) { 06403 ast_log(LOG_WARNING, "Fixup failed on channel %s, strange things may happen.\n", clonechan->name); 06404 } 06405 06406 /* Start by disconnecting the original's physical side */ 06407 if (clonechan->tech->hangup && clonechan->tech->hangup(clonechan)) { 06408 ast_log(LOG_WARNING, "Hangup failed! Strange things may happen!\n"); 06409 res = -1; 06410 goto done; 06411 } 06412 06413 /* Mangle the name of the clone channel */ 06414 snprintf(zombn, sizeof(zombn), "%s<ZOMBIE>", orig); /* quick, hide the brains! */ 06415 __ast_change_name_nolink(clonechan, zombn); 06416 06417 /* Update the type. */ 06418 t_pvt = original->monitor; 06419 original->monitor = clonechan->monitor; 06420 clonechan->monitor = t_pvt; 06421 06422 /* Keep the same language. */ 06423 ast_string_field_set(original, language, clonechan->language); 06424 /* Copy the FD's other than the generator fd */ 06425 for (x = 0; x < AST_MAX_FDS; x++) { 06426 if (x != AST_GENERATOR_FD) 06427 ast_channel_set_fd(original, x, clonechan->fds[x]); 06428 } 06429 06430 ast_app_group_update(clonechan, original); 06431 06432 /* Move data stores over */ 06433 if (AST_LIST_FIRST(&clonechan->datastores)) { 06434 struct ast_datastore *ds; 06435 /* We use a safe traversal here because some fixup routines actually 06436 * remove the datastore from the list and free them. 06437 */ 06438 AST_LIST_TRAVERSE_SAFE_BEGIN(&clonechan->datastores, ds, entry) { 06439 if (ds->info->chan_fixup) 06440 ds->info->chan_fixup(ds->data, clonechan, original); 06441 } 06442 AST_LIST_TRAVERSE_SAFE_END; 06443 AST_LIST_APPEND_LIST(&original->datastores, &clonechan->datastores, entry); 06444 } 06445 06446 ast_autochan_new_channel(clonechan, original); 06447 06448 clone_variables(original, clonechan); 06449 /* Presense of ADSI capable CPE follows clone */ 06450 original->adsicpe = clonechan->adsicpe; 06451 /* Bridge remains the same */ 06452 /* CDR fields remain the same */ 06453 /* XXX What about blocking, softhangup, blocker, and lock and blockproc? XXX */ 06454 /* Application and data remain the same */ 06455 /* Clone exception becomes real one, as with fdno */ 06456 ast_set_flag(original, ast_test_flag(clonechan, AST_FLAG_EXCEPTION | AST_FLAG_OUTGOING)); 06457 original->fdno = clonechan->fdno; 06458 /* Schedule context remains the same */ 06459 /* Stream stuff stays the same */ 06460 /* Keep the original state. The fixup code will need to work with it most likely */ 06461 06462 /* 06463 * Just swap the whole structures, nevermind the allocations, 06464 * they'll work themselves out. 06465 */ 06466 exchange.dialed = original->dialed; 06467 original->dialed = clonechan->dialed; 06468 clonechan->dialed = exchange.dialed; 06469 06470 exchange.caller = original->caller; 06471 original->caller = clonechan->caller; 06472 clonechan->caller = exchange.caller; 06473 06474 exchange.connected = original->connected; 06475 original->connected = clonechan->connected; 06476 clonechan->connected = exchange.connected; 06477 06478 exchange.redirecting = original->redirecting; 06479 original->redirecting = clonechan->redirecting; 06480 clonechan->redirecting = exchange.redirecting; 06481 06482 report_new_callerid(original); 06483 06484 /* Restore original timing file descriptor */ 06485 ast_channel_set_fd(original, AST_TIMING_FD, original->timingfd); 06486 06487 /* Our native formats are different now */ 06488 original->nativeformats = clonechan->nativeformats; 06489 06490 /* Context, extension, priority, app data, jump table, remain the same */ 06491 /* pvt switches. pbx stays the same, as does next */ 06492 06493 /* Set the write format */ 06494 ast_set_write_format(original, wformat); 06495 06496 /* Set the read format */ 06497 ast_set_read_format(original, rformat); 06498 06499 /* Copy the music class */ 06500 ast_string_field_set(original, musicclass, clonechan->musicclass); 06501 06502 /* copy over accuntcode and set peeraccount across the bridge */ 06503 ast_string_field_set(original, accountcode, S_OR(clonechan->accountcode, "")); 06504 if (original->_bridge) { 06505 /* XXX - should we try to lock original->_bridge here? */ 06506 ast_string_field_set(original->_bridge, peeraccount, S_OR(clonechan->accountcode, "")); 06507 ast_cel_report_event(original, AST_CEL_BRIDGE_UPDATE, NULL, NULL, NULL); 06508 } 06509 06510 ast_debug(1, "Putting channel %s in %s/%s formats\n", original->name, 06511 ast_getformatname(wformat), ast_getformatname(rformat)); 06512 06513 /* Okay. Last thing is to let the channel driver know about all this mess, so he 06514 can fix up everything as best as possible */ 06515 if (original->tech->fixup) { 06516 if (original->tech->fixup(clonechan, original)) { 06517 ast_log(LOG_WARNING, "Channel for type '%s' could not fixup channel %s\n", 06518 original->tech->type, original->name); 06519 res = -1; 06520 goto done; 06521 } 06522 } else 06523 ast_log(LOG_WARNING, "Channel type '%s' does not have a fixup routine (for %s)! Bad things may happen.\n", 06524 original->tech->type, original->name); 06525 06526 /* 06527 * If an indication is currently playing, maintain it on the channel 06528 * that is taking the place of original 06529 * 06530 * This is needed because the masquerade is swapping out in the internals 06531 * of this channel, and the new channel private data needs to be made 06532 * aware of the current visible indication (RINGING, CONGESTION, etc.) 06533 */ 06534 if (visible_indication) { 06535 ast_indicate(original, visible_indication); 06536 } 06537 06538 /* Now, at this point, the "clone" channel is totally F'd up. We mark it as 06539 a zombie so nothing tries to touch it. If it's already been marked as a 06540 zombie, then free it now (since it already is considered invalid). */ 06541 if (ast_test_flag(clonechan, AST_FLAG_ZOMBIE)) { 06542 ast_debug(1, "Destroying channel clone '%s'\n", clonechan->name); 06543 ast_channel_unlock(clonechan); 06544 ast_manager_event(clonechan, EVENT_FLAG_CALL, "Hangup", 06545 "Channel: %s\r\n" 06546 "Uniqueid: %s\r\n" 06547 "Cause: %d\r\n" 06548 "Cause-txt: %s\r\n", 06549 clonechan->name, 06550 clonechan->uniqueid, 06551 clonechan->hangupcause, 06552 ast_cause2str(clonechan->hangupcause) 06553 ); 06554 clonechan = ast_channel_release(clonechan); 06555 } else { 06556 ast_debug(1, "Released clone lock on '%s'\n", clonechan->name); 06557 ast_set_flag(clonechan, AST_FLAG_ZOMBIE); 06558 ast_queue_frame(clonechan, &ast_null_frame); 06559 } 06560 06561 /* Signal any blocker */ 06562 if (ast_test_flag(original, AST_FLAG_BLOCKING)) 06563 pthread_kill(original->blocker, SIGURG); 06564 ast_debug(1, "Done Masquerading %s (%d)\n", original->name, original->_state); 06565 06566 if ((bridged = ast_bridged_channel(original))) { 06567 ast_channel_lock(bridged); 06568 ast_indicate(bridged, AST_CONTROL_SRCCHANGE); 06569 ast_channel_unlock(bridged); 06570 } 06571 ast_indicate(original, AST_CONTROL_SRCCHANGE); 06572 06573 if (xfer_colp) { 06574 /* 06575 * After the masquerade, the original channel pointer actually 06576 * points to the new transferee channel and the bridged channel 06577 * is still the intended transfer target party. 06578 */ 06579 masquerade_colp_transfer(original, xfer_colp); 06580 } 06581 06582 done: 06583 if (xfer_ds) { 06584 ast_datastore_free(xfer_ds); 06585 } 06586 /* it is possible for the clone channel to disappear during this */ 06587 if (clonechan) { 06588 ast_channel_unlock(original); 06589 ast_channel_unlock(clonechan); 06590 ao2_link(channels, clonechan); 06591 ao2_link(channels, original); 06592 } else { 06593 ast_channel_unlock(original); 06594 ao2_link(channels, original); 06595 } 06596 06597 ao2_unlock(channels); 06598 06599 return res; 06600 }
struct ast_channel* ast_dummy_channel_alloc | ( | void | ) |
Create a fake channel structure.
NULL | failure | |
non-NULL | successfully allocated channel |
Definition at line 1320 of file channel.c.
References __ao2_alloc_debug(), ao2_alloc, ast_channel_unref, ast_dummy_channel_destructor(), AST_LIST_HEAD_INIT_NOLOCK, and ast_string_field_init.
Referenced by acf_odbc_read(), acf_odbc_write(), action_getvar(), ast_add_extension2_lockopt(), ast_cel_fabricate_channel_from_event(), ast_pbx_outgoing_cdr_failed(), ast_str_substitute_variables_full(), custom_log(), make_email_file(), manager_log(), pbx_substitute_variables_helper_full(), rotate_file(), sendmail(), sendpage(), syslog_log(), and write_cdr().
01322 { 01323 struct ast_channel *tmp; 01324 struct varshead *headp; 01325 01326 #if defined(REF_DEBUG) 01327 tmp = __ao2_alloc_debug(sizeof(*tmp), ast_dummy_channel_destructor, "dummy channel", 01328 file, line, function, 1); 01329 #elif defined(__AST_DEBUG_MALLOC) 01330 tmp = __ao2_alloc_debug(sizeof(*tmp), ast_dummy_channel_destructor, "dummy channel", 01331 file, line, function, 0); 01332 #else 01333 tmp = ao2_alloc(sizeof(*tmp), ast_dummy_channel_destructor); 01334 #endif 01335 if (!tmp) { 01336 /* Dummy channel structure allocation failure. */ 01337 return NULL; 01338 } 01339 01340 if ((ast_string_field_init(tmp, 128))) { 01341 return ast_channel_unref(tmp); 01342 } 01343 01344 headp = &tmp->varshead; 01345 AST_LIST_HEAD_INIT_NOLOCK(headp); 01346 01347 return tmp; 01348 }
static void ast_dummy_channel_destructor | ( | void * | obj | ) | [static] |
Free a dummy channel structure.
Definition at line 2431 of file channel.c.
References ast_cdr_discard(), AST_LIST_REMOVE_HEAD, ast_party_caller_free(), ast_party_connected_line_free(), ast_party_dialed_free(), ast_party_redirecting_free(), ast_string_field_free_memory, ast_var_delete(), ast_channel::caller, ast_channel::cdr, chanlist::chan, ast_channel::connected, ast_channel::dialed, ast_channel::redirecting, and ast_channel::varshead.
Referenced by ast_dummy_channel_alloc().
02432 { 02433 struct ast_channel *chan = obj; 02434 struct ast_var_t *vardata; 02435 struct varshead *headp; 02436 02437 headp = &chan->varshead; 02438 02439 ast_party_dialed_free(&chan->dialed); 02440 ast_party_caller_free(&chan->caller); 02441 ast_party_connected_line_free(&chan->connected); 02442 ast_party_redirecting_free(&chan->redirecting); 02443 02444 /* loop over the variables list, freeing all data and deleting list items */ 02445 /* no need to lock the list, as the channel is already locked */ 02446 while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries))) 02447 ast_var_delete(vardata); 02448 02449 if (chan->cdr) { 02450 ast_cdr_discard(chan->cdr); 02451 chan->cdr = NULL; 02452 } 02453 02454 ast_string_field_free_memory(chan); 02455 }
static enum ast_bridge_result ast_generic_bridge | ( | struct ast_channel * | c0, | |
struct ast_channel * | c1, | |||
struct ast_bridge_config * | config, | |||
struct ast_frame ** | fo, | |||
struct ast_channel ** | rc | |||
) | [static] |
Definition at line 6747 of file channel.c.
References AST_BRIDGE_COMPLETE, AST_BRIDGE_DTMF_CHANNEL_0, AST_BRIDGE_DTMF_CHANNEL_1, AST_BRIDGE_RETRY, ast_clear_flag, AST_FEATURE_WARNING_ACTIVE, ast_jb_do_usecheck(), ast_jb_empty_and_reset(), ast_poll_channel_add(), ast_samp2tv(), ast_set_flag, ast_test_flag, ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), config, f, ast_channel::nativeformats, and ast_channel::tech_pvt.
Referenced by ast_channel_bridge().
06750 { 06751 /* Copy voice back and forth between the two channels. */ 06752 struct ast_channel *cs[3]; 06753 struct ast_frame *f; 06754 enum ast_bridge_result res = AST_BRIDGE_COMPLETE; 06755 format_t o0nativeformats; 06756 format_t o1nativeformats; 06757 int watch_c0_dtmf; 06758 int watch_c1_dtmf; 06759 void *pvt0, *pvt1; 06760 /* Indicates whether a frame was queued into a jitterbuffer */ 06761 int frame_put_in_jb = 0; 06762 int jb_in_use; 06763 int to; 06764 06765 cs[0] = c0; 06766 cs[1] = c1; 06767 pvt0 = c0->tech_pvt; 06768 pvt1 = c1->tech_pvt; 06769 o0nativeformats = c0->nativeformats; 06770 o1nativeformats = c1->nativeformats; 06771 watch_c0_dtmf = config->flags & AST_BRIDGE_DTMF_CHANNEL_0; 06772 watch_c1_dtmf = config->flags & AST_BRIDGE_DTMF_CHANNEL_1; 06773 06774 /* Check the need of a jitterbuffer for each channel */ 06775 jb_in_use = ast_jb_do_usecheck(c0, c1); 06776 if (jb_in_use) 06777 ast_jb_empty_and_reset(c0, c1); 06778 06779 ast_poll_channel_add(c0, c1); 06780 06781 if (config->feature_timer > 0 && ast_tvzero(config->nexteventts)) { 06782 /* nexteventts is not set when the bridge is not scheduled to 06783 * break, so calculate when the bridge should possibly break 06784 * if a partial feature match timed out */ 06785 config->nexteventts = ast_tvadd(ast_tvnow(), ast_samp2tv(config->feature_timer, 1000)); 06786 } 06787 06788 for (;;) { 06789 struct ast_channel *who, *other; 06790 06791 if ((c0->tech_pvt != pvt0) || (c1->tech_pvt != pvt1) || 06792 (o0nativeformats != c0->nativeformats) || 06793 (o1nativeformats != c1->nativeformats)) { 06794 /* Check for Masquerade, codec changes, etc */ 06795 res = AST_BRIDGE_RETRY; 06796 break; 06797 } 06798 if (config->nexteventts.tv_sec) { 06799 to = ast_tvdiff_ms(config->nexteventts, ast_tvnow()); 06800 if (to <= 0) { 06801 if (config->timelimit && !config->feature_timer && !ast_test_flag(config, AST_FEATURE_WARNING_ACTIVE)) { 06802 res = AST_BRIDGE_RETRY; 06803 /* generic bridge ending to play warning */ 06804 ast_set_flag(config, AST_FEATURE_WARNING_ACTIVE); 06805 } else if (config->feature_timer) { 06806 /* feature timer expired - make sure we do not play warning */ 06807 ast_clear_flag(config, AST_FEATURE_WARNING_ACTIVE); 06808 res = AST_BRIDGE_RETRY; 06809 } else { 06810 res = AST_BRIDGE_COMPLETE; 06811 } 06812 break; 06813 } 06814 } else { 06815 /* If a feature has been started and the bridge is configured to 06816 * to not break, leave the channel bridge when the feature timer 06817 * time has elapsed so the DTMF will be sent to the other side. 06818 */ 06819 if (!ast_tvzero(config->nexteventts)) { 06820 int diff = ast_tvdiff_ms(config->nexteventts, ast_tvnow()); 06821 if (diff <= 0) { 06822 res = AST_BRIDGE_RETRY; 06823 break; 06824 } 06825 } 06826 to = -1; 06827 } 06828 /* Calculate the appropriate max sleep interval - in general, this is the time, 06829 left to the closest jb delivery moment */ 06830 if (jb_in_use) 06831 to = ast_jb_get_when_to_wakeup(c0, c1, to); 06832 who = ast_waitfor_n(cs, 2, &to); 06833 if (!who) { 06834 /* No frame received within the specified timeout - check if we have to deliver now */ 06835 if (jb_in_use) 06836 ast_jb_get_and_deliver(c0, c1); 06837 if ((c0->_softhangup | c1->_softhangup) & AST_SOFTHANGUP_UNBRIDGE) {/* Bit operators are intentional. */ 06838 if (c0->_softhangup & AST_SOFTHANGUP_UNBRIDGE) { 06839 ast_channel_clear_softhangup(c0, AST_SOFTHANGUP_UNBRIDGE); 06840 } 06841 if (c1->_softhangup & AST_SOFTHANGUP_UNBRIDGE) { 06842 ast_channel_clear_softhangup(c1, AST_SOFTHANGUP_UNBRIDGE); 06843 } 06844 c0->_bridge = c1; 06845 c1->_bridge = c0; 06846 } 06847 continue; 06848 } 06849 f = ast_read(who); 06850 if (!f) { 06851 *fo = NULL; 06852 *rc = who; 06853 ast_debug(1, "Didn't get a frame from channel: %s\n",who->name); 06854 break; 06855 } 06856 06857 other = (who == c0) ? c1 : c0; /* the 'other' channel */ 06858 /* Try add the frame info the who's bridged channel jitterbuff */ 06859 if (jb_in_use) 06860 frame_put_in_jb = !ast_jb_put(other, f); 06861 06862 if ((f->frametype == AST_FRAME_CONTROL) && !(config->flags & AST_BRIDGE_IGNORE_SIGS)) { 06863 int bridge_exit = 0; 06864 06865 switch (f->subclass.integer) { 06866 case AST_CONTROL_AOC: 06867 ast_indicate_data(other, f->subclass.integer, f->data.ptr, f->datalen); 06868 break; 06869 case AST_CONTROL_REDIRECTING: 06870 if (ast_channel_redirecting_macro(who, other, f, other == c0, 1)) { 06871 ast_indicate_data(other, f->subclass.integer, f->data.ptr, f->datalen); 06872 } 06873 break; 06874 case AST_CONTROL_CONNECTED_LINE: 06875 if (ast_channel_connected_line_macro(who, other, f, other == c0, 1)) { 06876 ast_indicate_data(other, f->subclass.integer, f->data.ptr, f->datalen); 06877 } 06878 break; 06879 case AST_CONTROL_HOLD: 06880 case AST_CONTROL_UNHOLD: 06881 case AST_CONTROL_VIDUPDATE: 06882 case AST_CONTROL_SRCUPDATE: 06883 case AST_CONTROL_SRCCHANGE: 06884 case AST_CONTROL_T38_PARAMETERS: 06885 ast_indicate_data(other, f->subclass.integer, f->data.ptr, f->datalen); 06886 if (jb_in_use) { 06887 ast_jb_empty_and_reset(c0, c1); 06888 } 06889 break; 06890 default: 06891 *fo = f; 06892 *rc = who; 06893 bridge_exit = 1; 06894 ast_debug(1, "Got a FRAME_CONTROL (%d) frame on channel %s\n", f->subclass.integer, who->name); 06895 break; 06896 } 06897 if (bridge_exit) 06898 break; 06899 } 06900 if ((f->frametype == AST_FRAME_VOICE) || 06901 (f->frametype == AST_FRAME_DTMF_BEGIN) || 06902 (f->frametype == AST_FRAME_DTMF) || 06903 (f->frametype == AST_FRAME_VIDEO) || 06904 (f->frametype == AST_FRAME_IMAGE) || 06905 (f->frametype == AST_FRAME_HTML) || 06906 (f->frametype == AST_FRAME_MODEM) || 06907 (f->frametype == AST_FRAME_TEXT)) { 06908 /* monitored dtmf causes exit from bridge */ 06909 int monitored_source = (who == c0) ? watch_c0_dtmf : watch_c1_dtmf; 06910 06911 if (monitored_source && 06912 (f->frametype == AST_FRAME_DTMF_END || 06913 f->frametype == AST_FRAME_DTMF_BEGIN)) { 06914 *fo = f; 06915 *rc = who; 06916 ast_debug(1, "Got DTMF %s on channel (%s)\n", 06917 f->frametype == AST_FRAME_DTMF_END ? "end" : "begin", 06918 who->name); 06919 06920 break; 06921 } 06922 /* Write immediately frames, not passed through jb */ 06923 if (!frame_put_in_jb) 06924 ast_write(other, f); 06925 06926 /* Check if we have to deliver now */ 06927 if (jb_in_use) 06928 ast_jb_get_and_deliver(c0, c1); 06929 } 06930 /* XXX do we want to pass on also frames not matched above ? */ 06931 ast_frfree(f); 06932 06933 #ifndef HAVE_EPOLL 06934 /* Swap who gets priority */ 06935 cs[2] = cs[0]; 06936 cs[0] = cs[1]; 06937 cs[1] = cs[2]; 06938 #endif 06939 } 06940 06941 ast_poll_channel_del(c0, c1); 06942 06943 return res; 06944 }
struct ast_channel_tech* ast_get_channel_tech | ( | const char * | name | ) |
Get a channel technology structure by name.
name | name of technology to find |
Definition at line 890 of file channel.c.
References AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, chanlist::list, chanlist::tech, and ast_channel_tech::type.
Referenced by __ast_channel_alloc_ap(), _ast_device_state(), ast_cc_callback(), and ast_var_channel_types_table().
00891 { 00892 struct chanlist *chanls; 00893 const struct ast_channel_tech *ret = NULL; 00894 00895 AST_RWLIST_RDLOCK(&backends); 00896 00897 AST_RWLIST_TRAVERSE(&backends, chanls, list) { 00898 if (!strcasecmp(name, chanls->tech->type)) { 00899 ret = chanls->tech; 00900 break; 00901 } 00902 } 00903 00904 AST_RWLIST_UNLOCK(&backends); 00905 00906 return ret; 00907 }
ast_group_t ast_get_group | ( | const char * | s | ) |
Definition at line 7494 of file channel.c.
References ast_log(), ast_strdupa, ast_strlen_zero(), LOG_ERROR, LOG_WARNING, and strsep().
Referenced by _parse(), build_device(), build_peer(), config_parse_variables(), func_channel_write_real(), and read_agent_config().
07495 { 07496 char *piece; 07497 char *c; 07498 int start=0, finish=0, x; 07499 ast_group_t group = 0; 07500 07501 if (ast_strlen_zero(s)) 07502 return 0; 07503 07504 c = ast_strdupa(s); 07505 07506 while ((piece = strsep(&c, ","))) { 07507 if (sscanf(piece, "%30d-%30d", &start, &finish) == 2) { 07508 /* Range */ 07509 } else if (sscanf(piece, "%30d", &start)) { 07510 /* Just one */ 07511 finish = start; 07512 } else { 07513 ast_log(LOG_ERROR, "Syntax error parsing group configuration '%s' at '%s'. Ignoring.\n", s, piece); 07514 continue; 07515 } 07516 for (x = start; x <= finish; x++) { 07517 if ((x > 63) || (x < 0)) { 07518 ast_log(LOG_WARNING, "Ignoring invalid group %d (maximum group is 63)\n", x); 07519 } else 07520 group |= ((ast_group_t) 1 << x); 07521 } 07522 } 07523 return group; 07524 }
int ast_hangup | ( | struct ast_channel * | chan | ) |
Hang up a channel.
chan | channel to hang up |
Definition at line 2683 of file channel.c.
References ao2_unlink, ast_assert, ast_audiohook_detach_list(), ast_autoservice_stop(), ast_cause2str(), ast_cc_offer(), ast_cdr_detach(), ast_cdr_end(), AST_CDR_FLAG_BRIDGED, AST_CDR_FLAG_DIALED, AST_CDR_FLAG_POST_DISABLED, AST_CDR_NULL, AST_CEL_HANGUP, ast_cel_report_event(), ast_channel_lock, ast_channel_release(), ast_channel_unlock, ast_closestream(), ast_debug, ast_do_masquerade(), AST_FLAG_BLOCKING, AST_FLAG_ZOMBIE, ast_framehook_list_destroy(), ast_log(), ast_manager_event, ast_set_flag, ast_test_flag, ast_channel::audiohooks, ast_channel::blocker, ast_channel::blockproc, ast_channel::caller, ast_channel::cdr, chanlist::chan, channels, ast_cdr::disposition, EVENT_FLAG_CALL, free_translation(), ast_channel::generator, ast_channel::generatordata, ast_channel_tech::hangup, ast_channel::hangupcause, ast_channel::hangupsource, ast_party_caller::id, LOG_WARNING, ast_channel::masq, ast_channel::masqr, ast_party_id::name, ast_channel::name, ast_party_id::number, pbx_builtin_getvar_helper(), ast_generator::release, S_COR, S_OR, ast_channel::sched, sched_context_destroy(), ast_party_name::str, ast_party_number::str, ast_channel::stream, ast_channel::tech, ast_channel::uniqueid, ast_party_name::valid, ast_party_number::valid, and ast_channel::vstream.
Referenced by __analog_handle_event(), __analog_ss_thread(), __ast_request_and_dial(), __oh323_new(), action_bridge(), alsa_new(), analog_handle_init_event(), analog_ss_thread(), answer_exec_run(), app_exec(), ast_async_goto(), ast_call_forward(), ast_dial_destroy(), ast_dial_hangup(), ast_iax2_new(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_pbx_run_app(), async_wait(), begin_dial_channel(), bridge_call_thread(), bridge_channel_thread(), bridge_exec(), build_conf(), builtin_atxfer(), chanavail_exec(), check_compat(), check_goto_on_transfer(), clear_caller(), conf_run(), connect_link(), console_new(), dahdi_handle_event(), dahdi_new(), destroy_conference_bridge(), dial_exec_full(), dial_transfer(), do_forward(), do_hang(), do_idle_thread(), feature_attended_transfer(), feature_request_and_dial(), findmeexec(), generic_recall(), 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(), mgcp_new(), mgcp_ss(), monitor_dial(), mwi_thread(), my_distinctive_ring(), my_handle_notify_message(), nbs_new(), oss_new(), park_exec_full(), parkandannounce_exec(), phone_new(), play_sound_file(), pri_dchannel(), pri_ss_thread(), rpt(), rpt_call(), rpt_tele_thread(), sip_new(), sip_park(), sip_park_thread(), skinny_new(), skinny_ss(), unistim_new(), usbradio_new(), and wait_for_winner().
02684 { 02685 int res = 0; 02686 char extra_str[64]; /* used for cel logging below */ 02687 02688 /* Don't actually hang up a channel that will masquerade as someone else, or 02689 if someone is going to masquerade as us */ 02690 ast_channel_lock(chan); 02691 02692 if (chan->audiohooks) { 02693 ast_audiohook_detach_list(chan->audiohooks); 02694 chan->audiohooks = NULL; 02695 } 02696 02697 ast_framehook_list_destroy(chan); 02698 02699 ast_autoservice_stop(chan); 02700 02701 if (chan->masq) { 02702 ast_channel_unlock(chan); 02703 if (ast_do_masquerade(chan)) { 02704 ast_log(LOG_WARNING, "Failed to perform masquerade\n"); 02705 } 02706 ast_channel_lock(chan); 02707 } 02708 02709 if (chan->masq) { 02710 ast_log(LOG_WARNING, "%s getting hung up, but someone is trying to masq into us?!?\n", chan->name); 02711 ast_channel_unlock(chan); 02712 return 0; 02713 } 02714 /* If this channel is one which will be masqueraded into something, 02715 mark it as a zombie already, so we know to free it later */ 02716 if (chan->masqr) { 02717 ast_set_flag(chan, AST_FLAG_ZOMBIE); 02718 ast_channel_unlock(chan); 02719 return 0; 02720 } 02721 ast_channel_unlock(chan); 02722 02723 ao2_unlink(channels, chan); 02724 02725 ast_channel_lock(chan); 02726 free_translation(chan); 02727 /* Close audio stream */ 02728 if (chan->stream) { 02729 ast_closestream(chan->stream); 02730 chan->stream = NULL; 02731 } 02732 /* Close video stream */ 02733 if (chan->vstream) { 02734 ast_closestream(chan->vstream); 02735 chan->vstream = NULL; 02736 } 02737 if (chan->sched) { 02738 sched_context_destroy(chan->sched); 02739 chan->sched = NULL; 02740 } 02741 02742 if (chan->generatordata) /* Clear any tone stuff remaining */ 02743 if (chan->generator && chan->generator->release) 02744 chan->generator->release(chan, chan->generatordata); 02745 chan->generatordata = NULL; 02746 chan->generator = NULL; 02747 02748 snprintf(extra_str, sizeof(extra_str), "%d,%s,%s", chan->hangupcause, chan->hangupsource, S_OR(pbx_builtin_getvar_helper(chan, "DIALSTATUS"), "")); 02749 ast_cel_report_event(chan, AST_CEL_HANGUP, NULL, extra_str, NULL); 02750 02751 if (ast_test_flag(chan, AST_FLAG_BLOCKING)) { 02752 ast_log(LOG_WARNING, "Hard hangup called by thread %ld on %s, while fd " 02753 "is blocked by thread %ld in procedure %s! Expect a failure\n", 02754 (long)pthread_self(), chan->name, (long)chan->blocker, chan->blockproc); 02755 ast_assert(ast_test_flag(chan, AST_FLAG_BLOCKING) == 0); 02756 } 02757 if (!ast_test_flag(chan, AST_FLAG_ZOMBIE)) { 02758 ast_debug(1, "Hanging up channel '%s'\n", chan->name); 02759 if (chan->tech->hangup) 02760 res = chan->tech->hangup(chan); 02761 } else { 02762 ast_debug(1, "Hanging up zombie '%s'\n", chan->name); 02763 } 02764 02765 ast_channel_unlock(chan); 02766 ast_cc_offer(chan); 02767 ast_manager_event(chan, EVENT_FLAG_CALL, "Hangup", 02768 "Channel: %s\r\n" 02769 "Uniqueid: %s\r\n" 02770 "CallerIDNum: %s\r\n" 02771 "CallerIDName: %s\r\n" 02772 "Cause: %d\r\n" 02773 "Cause-txt: %s\r\n", 02774 chan->name, 02775 chan->uniqueid, 02776 S_COR(chan->caller.id.number.valid, chan->caller.id.number.str, "<unknown>"), 02777 S_COR(chan->caller.id.name.valid, chan->caller.id.name.str, "<unknown>"), 02778 chan->hangupcause, 02779 ast_cause2str(chan->hangupcause) 02780 ); 02781 02782 if (chan->cdr && !ast_test_flag(chan->cdr, AST_CDR_FLAG_BRIDGED) && 02783 !ast_test_flag(chan->cdr, AST_CDR_FLAG_POST_DISABLED) && 02784 (chan->cdr->disposition != AST_CDR_NULL || ast_test_flag(chan->cdr, AST_CDR_FLAG_DIALED))) { 02785 ast_channel_lock(chan); 02786 02787 ast_cdr_end(chan->cdr); 02788 ast_cdr_detach(chan->cdr); 02789 chan->cdr = NULL; 02790 ast_channel_unlock(chan); 02791 } 02792 02793 chan = ast_channel_release(chan); 02794 02795 return res; 02796 }
int ast_indicate | ( | struct ast_channel * | chan, | |
int | condition | |||
) |
Indicates condition of channel.
chan | channel to change the indication | |
condition | which condition to indicate on the channel |
Definition at line 4184 of file channel.c.
References ast_indicate_data(), and chanlist::chan.
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_raw_answer(), attempt_transfer(), builtin_atxfer(), builtin_blindtransfer(), cli_console_answer(), conf_run(), console_call(), dial_exec_full(), do_forward(), feature_request_and_dial(), finishup(), function_remote(), handle_callforward_button(), handle_frame(), handle_recordfile(), handle_request_refer(), local_attended_transfer(), manage_parkinglot(), mgcp_ss(), monitor_dial(), oss_call(), park_call_full(), park_exec_full(), pbx_builtin_busy(), pbx_builtin_congestion(), pbx_builtin_proceeding(), pbx_builtin_progress(), pbx_builtin_ringing(), pbx_builtin_waitexten(), queue_exec(), rna(), rpt(), rpt_exec(), say_periodic_announcement(), say_position(), send_waveform_to_channel(), skinny_ss(), sla_handle_hold_event(), sla_station_exec(), and sla_trunk_exec().
04185 { 04186 return ast_indicate_data(chan, condition, NULL, 0); 04187 }
int ast_indicate_data | ( | struct ast_channel * | chan, | |
int | condition, | |||
const void * | data, | |||
size_t | datalen | |||
) |
Indicates condition of channel, with payload.
chan | channel to change the indication | |
condition | which condition to indicate on the channel | |
data | pointer to payload data | |
datalen | size of payload data |
Definition at line 4236 of file channel.c.
References ast_channel::_state, _XXX_AST_CONTROL_T38, ast_channel_lock, ast_channel_set_connected_line(), ast_channel_set_redirecting(), ast_channel_unlock, ast_check_hangup(), ast_connected_line_parse_data(), AST_CONTROL_ANSWER, AST_CONTROL_AOC, AST_CONTROL_BUSY, AST_CONTROL_CC, AST_CONTROL_CONGESTION, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_END_OF_Q, 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_READ_ACTION, AST_CONTROL_REDIRECTING, AST_CONTROL_RING, AST_CONTROL_RINGING, AST_CONTROL_SRCCHANGE, AST_CONTROL_SRCUPDATE, AST_CONTROL_T38_PARAMETERS, AST_CONTROL_TAKEOFFHOOK, AST_CONTROL_TRANSFER, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, AST_CONTROL_WINK, ast_debug, AST_FLAG_ZOMBIE, AST_FRAME_CONTROL, ast_framehook_list_is_empty(), ast_framehook_list_read_event(), ast_frdup(), ast_frfree, ast_get_indication_tone(), ast_log(), ast_party_connected_line_free(), ast_party_connected_line_set_init(), ast_party_redirecting_free(), ast_party_redirecting_set_init(), ast_playtones_start(), ast_playtones_stop(), ast_redirecting_parse_data(), AST_STATE_UP, ast_test_flag, ast_tone_zone_sound_unref(), chanlist::chan, ast_channel::connected, chanlist::connected, ast_tone_zone_sound::data, ast_frame::data, ast_frame::datalen, ast_channel::framehooks, ast_frame::frametype, ast_channel_tech::indicate, ast_frame_subclass::integer, is_visible_indication(), LOG_WARNING, ast_channel::name, ast_frame::ptr, ast_channel::redirecting, ast_frame::subclass, ast_channel::tech, ast_channel::visible_indication, and ast_channel::zone.
Referenced by __ast_read(), action_aocmessage(), agent_hangup(), ast_bridge_call(), ast_channel_update_connected_line(), ast_channel_update_redirecting(), ast_handle_cc_control_frame(), ast_indicate(), disable_t38(), feature_request_and_dial(), generic_fax_exec(), handle_frame(), login_exec(), manage_parkinglot(), park_call_full(), pbx_builtin_waitexten(), receivefax_t38_init(), remote_bridge_loop(), sendfax_t38_init(), set_fax_t38_caps(), transmit_audio(), transmit_t38(), and wait_for_answer().
04238 { 04239 /* By using an enum, we'll get compiler warnings for values not handled 04240 * in switch statements. */ 04241 enum ast_control_frame_type condition = _condition; 04242 struct ast_tone_zone_sound *ts = NULL; 04243 int res; 04244 /* this frame is used by framehooks. if it is set, we must free it at the end of this function */ 04245 struct ast_frame *awesome_frame = NULL; 04246 04247 ast_channel_lock(chan); 04248 04249 /* Don't bother if the channel is about to go away, anyway. */ 04250 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) { 04251 res = -1; 04252 goto indicate_cleanup; 04253 } 04254 04255 if (!ast_framehook_list_is_empty(chan->framehooks)) { 04256 /* Do framehooks now, do it, go, go now */ 04257 struct ast_frame frame = { 04258 .frametype = AST_FRAME_CONTROL, 04259 .subclass.integer = condition, 04260 .data.ptr = (void *) data, /* this cast from const is only okay because we do the ast_frdup below */ 04261 .datalen = datalen 04262 }; 04263 04264 /* we have now committed to freeing this frame */ 04265 awesome_frame = ast_frdup(&frame); 04266 04267 /* who knows what we will get back! the anticipation is killing me. */ 04268 if (!(awesome_frame = ast_framehook_list_read_event(chan->framehooks, &frame))) { 04269 res = 0; 04270 goto indicate_cleanup; 04271 } 04272 04273 condition = awesome_frame->subclass.integer; 04274 data = awesome_frame->data.ptr; 04275 datalen = awesome_frame->datalen; 04276 } 04277 04278 switch (condition) { 04279 case AST_CONTROL_CONNECTED_LINE: 04280 { 04281 struct ast_party_connected_line connected; 04282 04283 ast_party_connected_line_set_init(&connected, &chan->connected); 04284 res = ast_connected_line_parse_data(data, datalen, &connected); 04285 if (!res) { 04286 ast_channel_set_connected_line(chan, &connected, NULL); 04287 } 04288 ast_party_connected_line_free(&connected); 04289 } 04290 break; 04291 04292 case AST_CONTROL_REDIRECTING: 04293 { 04294 struct ast_party_redirecting redirecting; 04295 04296 ast_party_redirecting_set_init(&redirecting, &chan->redirecting); 04297 res = ast_redirecting_parse_data(data, datalen, &redirecting); 04298 if (!res) { 04299 ast_channel_set_redirecting(chan, &redirecting, NULL); 04300 } 04301 ast_party_redirecting_free(&redirecting); 04302 } 04303 break; 04304 04305 default: 04306 break; 04307 } 04308 04309 if (is_visible_indication(condition)) { 04310 /* A new visible indication is requested. */ 04311 chan->visible_indication = condition; 04312 } else if (condition == AST_CONTROL_UNHOLD || _condition < 0) { 04313 /* Visible indication is cleared/stopped. */ 04314 chan->visible_indication = 0; 04315 } 04316 04317 if (chan->tech->indicate) { 04318 /* See if the channel driver can handle this condition. */ 04319 res = chan->tech->indicate(chan, condition, data, datalen); 04320 } else { 04321 res = -1; 04322 } 04323 04324 if (!res) { 04325 /* The channel driver successfully handled this indication */ 04326 res = 0; 04327 goto indicate_cleanup; 04328 } 04329 04330 /* The channel driver does not support this indication, let's fake 04331 * it by doing our own tone generation if applicable. */ 04332 04333 /*!\note If we compare the enumeration type, which does not have any 04334 * negative constants, the compiler may optimize this code away. 04335 * Therefore, we must perform an integer comparison here. */ 04336 if (_condition < 0) { 04337 /* Stop any tones that are playing */ 04338 ast_playtones_stop(chan); 04339 res = 0; 04340 goto indicate_cleanup; 04341 } 04342 04343 /* Handle conditions that we have tones for. */ 04344 switch (condition) { 04345 case _XXX_AST_CONTROL_T38: 04346 /* deprecated T.38 control frame */ 04347 res = -1; 04348 goto indicate_cleanup; 04349 case AST_CONTROL_T38_PARAMETERS: 04350 /* there is no way to provide 'default' behavior for these 04351 * control frames, so we need to return failure, but there 04352 * is also no value in the log message below being emitted 04353 * since failure to handle these frames is not an 'error' 04354 * so just return right now. in addition, we want to return 04355 * whatever value the channel driver returned, in case it 04356 * has some meaning.*/ 04357 goto indicate_cleanup; 04358 case AST_CONTROL_RINGING: 04359 ts = ast_get_indication_tone(chan->zone, "ring"); 04360 /* It is common practice for channel drivers to return -1 if trying 04361 * to indicate ringing on a channel which is up. The idea is to let the 04362 * core generate the ringing inband. However, we don't want the 04363 * warning message about not being able to handle the specific indication 04364 * to print nor do we want ast_indicate_data to return an "error" for this 04365 * condition 04366 */ 04367 if (chan->_state == AST_STATE_UP) { 04368 res = 0; 04369 } 04370 break; 04371 case AST_CONTROL_BUSY: 04372 ts = ast_get_indication_tone(chan->zone, "busy"); 04373 break; 04374 case AST_CONTROL_CONGESTION: 04375 ts = ast_get_indication_tone(chan->zone, "congestion"); 04376 break; 04377 case AST_CONTROL_PROGRESS: 04378 case AST_CONTROL_PROCEEDING: 04379 case AST_CONTROL_VIDUPDATE: 04380 case AST_CONTROL_SRCUPDATE: 04381 case AST_CONTROL_SRCCHANGE: 04382 case AST_CONTROL_RADIO_KEY: 04383 case AST_CONTROL_RADIO_UNKEY: 04384 case AST_CONTROL_OPTION: 04385 case AST_CONTROL_WINK: 04386 case AST_CONTROL_FLASH: 04387 case AST_CONTROL_OFFHOOK: 04388 case AST_CONTROL_TAKEOFFHOOK: 04389 case AST_CONTROL_ANSWER: 04390 case AST_CONTROL_HANGUP: 04391 case AST_CONTROL_RING: 04392 case AST_CONTROL_HOLD: 04393 case AST_CONTROL_UNHOLD: 04394 case AST_CONTROL_TRANSFER: 04395 case AST_CONTROL_CONNECTED_LINE: 04396 case AST_CONTROL_REDIRECTING: 04397 case AST_CONTROL_CC: 04398 case AST_CONTROL_READ_ACTION: 04399 case AST_CONTROL_AOC: 04400 case AST_CONTROL_END_OF_Q: 04401 /* Nothing left to do for these. */ 04402 res = 0; 04403 break; 04404 } 04405 04406 if (ts) { 04407 /* We have a tone to play, yay. */ 04408 ast_debug(1, "Driver for channel '%s' does not support indication %d, emulating it\n", chan->name, condition); 04409 res = ast_playtones_start(chan, 0, ts->data, 1); 04410 ts = ast_tone_zone_sound_unref(ts); 04411 } 04412 04413 if (res) { 04414 /* not handled */ 04415 ast_log(LOG_WARNING, "Unable to handle indication %d for '%s'\n", condition, chan->name); 04416 } 04417 04418 indicate_cleanup: 04419 ast_channel_unlock(chan); 04420 if (awesome_frame) { 04421 ast_frfree(awesome_frame); 04422 } 04423 04424 return res; 04425 }
void ast_install_music_functions | ( | int(*)(struct ast_channel *, const char *, const char *) | start_ptr, | |
void(*)(struct ast_channel *) | stop_ptr, | |||
void(*)(struct ast_channel *) | cleanup_ptr | |||
) |
Definition at line 7530 of file channel.c.
References ast_moh_cleanup_ptr, ast_moh_start_ptr, and ast_moh_stop_ptr.
Referenced by load_module().
07533 { 07534 ast_moh_start_ptr = start_ptr; 07535 ast_moh_stop_ptr = stop_ptr; 07536 ast_moh_cleanup_ptr = cleanup_ptr; 07537 }
int ast_internal_timing_enabled | ( | struct ast_channel * | chan | ) |
Check if the channel can run in internal timing mode.
chan | The channel to check |
Definition at line 4169 of file channel.c.
References ast_opt_internal_timing, chanlist::chan, and ast_channel::timingfd.
Referenced by add_sdp(), and ast_read_generator_actions().
04170 { 04171 return (ast_opt_internal_timing && chan->timingfd > -1); 04172 }
int ast_is_deferrable_frame | ( | const struct ast_frame * | frame | ) |
Should we keep this frame for later?
There are functions such as ast_safe_sleep which will service a channel to ensure that it does not have a large backlog of queued frames. When this happens, we want to hold on to specific frame types and just drop others. This function will tell if the frame we just read should be held onto.
frame | The frame we just read |
1 | frame should be kept | |
0 | frame should be dropped |
Definition at line 1728 of file channel.c.
References 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, and ast_frame::frametype.
Referenced by ast_safe_sleep_conditional(), autoservice_run(), and feature_request_and_dial().
01729 { 01730 /* Do not add a default entry in this switch statement. Each new 01731 * frame type should be addressed directly as to whether it should 01732 * be queued up or not. 01733 */ 01734 switch (frame->frametype) { 01735 case AST_FRAME_CONTROL: 01736 case AST_FRAME_TEXT: 01737 case AST_FRAME_IMAGE: 01738 case AST_FRAME_HTML: 01739 return 1; 01740 01741 case AST_FRAME_DTMF_END: 01742 case AST_FRAME_DTMF_BEGIN: 01743 case AST_FRAME_VOICE: 01744 case AST_FRAME_VIDEO: 01745 case AST_FRAME_NULL: 01746 case AST_FRAME_IAX: 01747 case AST_FRAME_CNG: 01748 case AST_FRAME_MODEM: 01749 return 0; 01750 } 01751 return 0; 01752 }
void ast_moh_cleanup | ( | struct ast_channel * | chan | ) |
Definition at line 7564 of file channel.c.
References ast_moh_cleanup_ptr.
Referenced by ast_channel_destructor().
07565 { 07566 if (ast_moh_cleanup_ptr) 07567 ast_moh_cleanup_ptr(chan); 07568 }
int ast_moh_start | ( | struct ast_channel * | chan, | |
const char * | mclass, | |||
const char * | interpclass | |||
) |
Turn on music on hold on a given channel.
chan | The channel structure that will get music on hold | |
mclass | The class to use if the musicclass is not currently set on the channel structure. | |
interpclass | The class to use if the musicclass is not currently set on the channel structure or in the mclass argument. |
Zero | on success | |
non-zero | on failure |
Definition at line 7547 of file channel.c.
References ast_moh_start_ptr, and ast_verb.
Referenced by alsa_indicate(), app_exec(), conf_run(), conf_start_moh(), console_indicate(), dahdi_indicate(), dial_exec_full(), feature_exec_app(), gtalk_indicate(), handle_setmusic(), iax2_indicate(), jingle_indicate(), key_call(), leave_conference_bridge(), local_indicate(), menu_callback(), mgcp_indicate(), misdn_indication(), moh_handle_digit(), monitor_dial(), oh323_indicate(), oss_indicate(), phone_indicate(), play_moh_exec(), post_join_marked(), post_join_unmarked(), queue_exec(), retrydial_exec(), rna(), say_periodic_announcement(), say_position(), sig_pri_indicate(), sip_indicate(), skinny_indicate(), start_moh_exec(), TransferCallStep1(), unistim_indicate(), usbradio_indicate(), and wait_moh_exec().
07548 { 07549 if (ast_moh_start_ptr) 07550 return ast_moh_start_ptr(chan, mclass, interpclass); 07551 07552 ast_verb(3, "Music class %s requested but no musiconhold loaded.\n", mclass ? mclass : (interpclass ? interpclass : "default")); 07553 07554 return 0; 07555 }
void ast_moh_stop | ( | struct ast_channel * | chan | ) |
Turn off music on hold on a given channel.
Turn off music on hold on a given channel
Definition at line 7558 of file channel.c.
References ast_moh_stop_ptr.
Referenced by alsa_indicate(), app_exec(), ast_quiet_chan(), conf_run(), console_indicate(), dahdi_indicate(), dial_exec_full(), do_bridge_masquerade(), feature_exec_app(), gtalk_indicate(), handle_setmusic(), iax2_indicate(), jingle_indicate(), key_call(), key_dial_page(), local_indicate(), menu_callback(), mgcp_indicate(), misdn_indication(), moh_handle_digit(), monitor_dial(), oh323_indicate(), oss_indicate(), phone_indicate(), play_moh_exec(), post_join_marked(), post_join_unmarked(), retrydial_exec(), say_periodic_announcement(), say_position(), sig_pri_indicate(), sip_indicate(), skinny_indicate(), stop_moh_exec(), unistim_hangup(), unistim_indicate(), usbradio_indicate(), and wait_moh_exec().
07559 { 07560 if (ast_moh_stop_ptr) 07561 ast_moh_stop_ptr(chan); 07562 }
void ast_party_caller_copy | ( | struct ast_party_caller * | dest, | |
const struct ast_party_caller * | src | |||
) |
Copy the source caller information to the destination caller.
dest | Destination caller | |
src | Source caller |
Definition at line 2179 of file channel.c.
References ast_party_caller::ani, ast_party_caller::ani2, ast_party_id_copy(), and ast_party_caller::id.
Referenced by ast_call_forward(), and do_forward().
02180 { 02181 if (dest == src) { 02182 /* Don't copy to self */ 02183 return; 02184 } 02185 02186 ast_party_id_copy(&dest->id, &src->id); 02187 ast_party_id_copy(&dest->ani, &src->ani); 02188 dest->ani2 = src->ani2; 02189 }
void ast_party_caller_free | ( | struct ast_party_caller * | doomed | ) |
Destroy the caller party contents.
doomed | The caller party to destroy. |
Definition at line 2205 of file channel.c.
References ast_party_caller::ani, ast_party_id_free(), and ast_party_caller::id.
Referenced by ast_channel_destructor(), ast_dummy_channel_destructor(), callerid_write(), dial_trunk(), and sla_ring_station().
02206 { 02207 ast_party_id_free(&doomed->id); 02208 ast_party_id_free(&doomed->ani); 02209 }
void ast_party_caller_init | ( | struct ast_party_caller * | init | ) |
Initialize the given caller structure.
init | Caller structure to initialize. |
Definition at line 2172 of file channel.c.
References ast_party_caller::ani, ast_party_caller::ani2, ast_party_id_init(), and ast_party_caller::id.
Referenced by __ast_channel_alloc_ap(), dial_trunk(), sig_pri_set_caller_id(), and sla_ring_station().
02173 { 02174 ast_party_id_init(&init->id); 02175 ast_party_id_init(&init->ani); 02176 init->ani2 = 0; 02177 }
void ast_party_caller_set | ( | struct ast_party_caller * | dest, | |
const struct ast_party_caller * | src, | |||
const struct ast_set_party_caller * | update | |||
) |
Set the caller information based on another caller source.
dest | The caller one wishes to update | |
src | The new caller values to update the dest | |
update | What caller information to update. NULL if all. |
Definition at line 2198 of file channel.c.
References ast_party_caller::ani, ast_party_caller::ani2, ast_party_id_set(), ast_party_caller::id, and update().
Referenced by ast_channel_set_caller(), ast_channel_set_caller_event(), and callerid_write().
02199 { 02200 ast_party_id_set(&dest->id, &src->id, update ? &update->id : NULL); 02201 ast_party_id_set(&dest->ani, &src->ani, update ? &update->ani : NULL); 02202 dest->ani2 = src->ani2; 02203 }
void ast_party_caller_set_init | ( | struct ast_party_caller * | init, | |
const struct ast_party_caller * | guide | |||
) |
Initialize the given caller structure using the given guide for a set update operation.
init | Caller structure to initialize. | |
guide | Source caller to use as a guide in initializing. |
Definition at line 2191 of file channel.c.
References ast_party_caller::ani, ast_party_caller::ani2, ast_party_id_set_init(), and ast_party_caller::id.
Referenced by callerid_write(), dial_exec_full(), misdn_update_caller_id(), ring_entry(), and sig_pri_handle_subcmds().
02192 { 02193 ast_party_id_set_init(&init->id, &guide->id); 02194 ast_party_id_set_init(&init->ani, &guide->ani); 02195 init->ani2 = guide->ani2; 02196 }
void ast_party_connected_line_collect_caller | ( | struct ast_party_connected_line * | connected, | |
struct ast_party_caller * | caller | |||
) |
Collect the caller party information into a connected line structure.
connected | Collected caller information for the connected line | |
caller | Caller information. |
DO NOT call ast_party_connected_line_free() on the filled in connected line structure!
Definition at line 2248 of file channel.c.
References ast_party_caller::ani, ast_party_connected_line::ani, ast_party_caller::ani2, ast_party_connected_line::ani2, AST_CONNECTED_LINE_UPDATE_SOURCE_UNKNOWN, ast_channel::caller, chanlist::connected, ast_party_caller::id, ast_party_connected_line::id, and ast_party_connected_line::source.
Referenced by ast_pickup_call().
02249 { 02250 connected->id = caller->id; 02251 connected->ani = caller->ani; 02252 connected->ani2 = caller->ani2; 02253 connected->source = AST_CONNECTED_LINE_UPDATE_SOURCE_UNKNOWN; 02254 }
void ast_party_connected_line_copy | ( | struct ast_party_connected_line * | dest, | |
const struct ast_party_connected_line * | src | |||
) |
Copy the source connected line information to the destination connected line.
dest | Destination connected line | |
src | Source connected line |
Definition at line 2219 of file channel.c.
References ast_party_connected_line::ani, ast_party_connected_line::ani2, ast_party_id_copy(), ast_party_connected_line::id, and ast_party_connected_line::source.
Referenced by __ast_read(), ast_call_forward(), ast_channel_connected_line_macro(), builtin_atxfer(), dial_exec_full(), do_forward(), local_attended_transfer(), misdn_attempt_transfer(), party_connected_line_copy_transfer(), and pickup_do().
02220 { 02221 if (dest == src) { 02222 /* Don't copy to self */ 02223 return; 02224 } 02225 02226 ast_party_id_copy(&dest->id, &src->id); 02227 ast_party_id_copy(&dest->ani, &src->ani); 02228 dest->ani2 = src->ani2; 02229 dest->source = src->source; 02230 }
void ast_party_connected_line_free | ( | struct ast_party_connected_line * | doomed | ) |
Destroy the connected line information contents.
doomed | The connected line information to destroy. |
Definition at line 2256 of file channel.c.
References ast_party_connected_line::ani, ast_party_id_free(), and ast_party_connected_line::id.
Referenced by __ast_read(), ast_channel_destructor(), ast_dummy_channel_destructor(), ast_indicate_data(), atxfer_fail_cleanup(), builtin_atxfer(), callattempt_free(), chanlist_free(), connectedline_write(), feature_request_and_dial(), local_attended_transfer(), misdn_attempt_transfer(), pickup_do(), sig_pri_handle_subcmds(), socket_process(), wait_for_answer(), and xfer_ds_destroy().
02257 { 02258 ast_party_id_free(&doomed->id); 02259 ast_party_id_free(&doomed->ani); 02260 }
void ast_party_connected_line_init | ( | struct ast_party_connected_line * | init | ) |
Initialize the given connected line structure.
init | Connected line structure to initialize. |
Definition at line 2211 of file channel.c.
References ast_party_connected_line::ani, ast_party_connected_line::ani2, AST_CONNECTED_LINE_UPDATE_SOURCE_UNKNOWN, ast_party_id_init(), ast_party_connected_line::id, and ast_party_connected_line::source.
Referenced by __ast_channel_alloc_ap(), __ast_read(), builtin_atxfer(), handle_request_invite(), handle_request_update(), handle_response_invite(), local_attended_transfer(), misdn_attempt_transfer(), misdn_queue_connected_line_update(), pickup_do(), sig_pri_handle_subcmds(), socket_process(), and wait_for_answer().
02212 { 02213 ast_party_id_init(&init->id); 02214 ast_party_id_init(&init->ani); 02215 init->ani2 = 0; 02216 init->source = AST_CONNECTED_LINE_UPDATE_SOURCE_UNKNOWN; 02217 }
void ast_party_connected_line_set | ( | struct ast_party_connected_line * | dest, | |
const struct ast_party_connected_line * | src, | |||
const struct ast_set_party_connected_line * | update | |||
) |
Set the connected line information based on another connected line source.
dest | The connected line one wishes to update | |
src | The new connected line values to update the dest | |
update | What connected line information to update. NULL if all. |
Definition at line 2240 of file channel.c.
References ast_party_connected_line::ani, ast_party_connected_line::ani2, ast_party_id_set(), ast_party_connected_line::id, ast_party_connected_line::source, and update().
Referenced by ast_channel_set_connected_line().
02241 { 02242 ast_party_id_set(&dest->id, &src->id, update ? &update->id : NULL); 02243 ast_party_id_set(&dest->ani, &src->ani, update ? &update->ani : NULL); 02244 dest->ani2 = src->ani2; 02245 dest->source = src->source; 02246 }
void ast_party_connected_line_set_init | ( | struct ast_party_connected_line * | init, | |
const struct ast_party_connected_line * | guide | |||
) |
Initialize the given connected line structure using the given guide for a set update operation.
init | Connected line structure to initialize. | |
guide | Source connected line to use as a guide in initializing. |
Definition at line 2232 of file channel.c.
References ast_party_connected_line::ani, ast_party_connected_line::ani2, ast_party_id_set_init(), ast_party_connected_line::id, and ast_party_connected_line::source.
Referenced by __ast_request_and_dial(), ast_indicate_data(), connectedline_write(), dial_exec_full(), and feature_request_and_dial().
02233 { 02234 ast_party_id_set_init(&init->id, &guide->id); 02235 ast_party_id_set_init(&init->ani, &guide->ani); 02236 init->ani2 = guide->ani2; 02237 init->source = guide->source; 02238 }
void ast_party_dialed_copy | ( | struct ast_party_dialed * | dest, | |
const struct ast_party_dialed * | src | |||
) |
Copy the source dialed party information to the destination dialed party.
dest | Destination dialed party | |
src | Source dialed party |
Definition at line 2130 of file channel.c.
References ast_free, ast_party_subaddress_copy(), ast_strdup, ast_party_dialed::number, ast_party_dialed::plan, ast_party_dialed::str, ast_party_dialed::subaddress, and ast_party_dialed::transit_network_select.
Referenced by local_call().
02131 { 02132 if (dest == src) { 02133 /* Don't copy to self */ 02134 return; 02135 } 02136 02137 ast_free(dest->number.str); 02138 dest->number.str = ast_strdup(src->number.str); 02139 dest->number.plan = src->number.plan; 02140 ast_party_subaddress_copy(&dest->subaddress, &src->subaddress); 02141 dest->transit_network_select = src->transit_network_select; 02142 }
void ast_party_dialed_free | ( | struct ast_party_dialed * | doomed | ) |
Destroy the dialed party contents.
doomed | The dialed party to destroy. |
Definition at line 2165 of file channel.c.
References ast_free, ast_party_subaddress_free(), ast_party_dialed::number, ast_party_dialed::str, and ast_party_dialed::subaddress.
Referenced by ast_channel_destructor(), ast_dummy_channel_destructor(), and callerid_write().
02166 { 02167 ast_free(doomed->number.str); 02168 doomed->number.str = NULL; 02169 ast_party_subaddress_free(&doomed->subaddress); 02170 }
void ast_party_dialed_init | ( | struct ast_party_dialed * | init | ) |
Initialize the given dialed structure.
init | Dialed structure to initialize. |
Definition at line 2122 of file channel.c.
References ast_party_subaddress_init(), ast_party_dialed::number, ast_party_dialed::plan, ast_party_dialed::str, ast_party_dialed::subaddress, and ast_party_dialed::transit_network_select.
Referenced by __ast_channel_alloc_ap().
02123 { 02124 init->number.str = NULL; 02125 init->number.plan = 0;/* Unknown */ 02126 ast_party_subaddress_init(&init->subaddress); 02127 init->transit_network_select = 0; 02128 }
void ast_party_dialed_set | ( | struct ast_party_dialed * | dest, | |
const struct ast_party_dialed * | src | |||
) |
Set the dialed information based on another dialed source.
dest | The dialed one wishes to update | |
src | The new dialed values to update the dest |
Definition at line 2152 of file channel.c.
References ast_free, ast_party_subaddress_set(), ast_strdup, ast_party_dialed::number, ast_party_dialed::plan, ast_party_dialed::str, ast_party_dialed::subaddress, and ast_party_dialed::transit_network_select.
Referenced by callerid_write().
02153 { 02154 if (src->number.str && src->number.str != dest->number.str) { 02155 ast_free(dest->number.str); 02156 dest->number.str = ast_strdup(src->number.str); 02157 } 02158 dest->number.plan = src->number.plan; 02159 02160 ast_party_subaddress_set(&dest->subaddress, &src->subaddress); 02161 02162 dest->transit_network_select = src->transit_network_select; 02163 }
void ast_party_dialed_set_init | ( | struct ast_party_dialed * | init, | |
const struct ast_party_dialed * | guide | |||
) |
Initialize the given dialed structure using the given guide for a set update operation.
init | Caller structure to initialize. | |
guide | Source dialed to use as a guide in initializing. |
Definition at line 2144 of file channel.c.
References ast_party_subaddress_set_init(), ast_party_dialed::number, ast_party_dialed::plan, ast_party_dialed::str, ast_party_dialed::subaddress, and ast_party_dialed::transit_network_select.
Referenced by callerid_write().
02145 { 02146 init->number.str = NULL; 02147 init->number.plan = guide->number.plan; 02148 ast_party_subaddress_set_init(&init->subaddress, &guide->subaddress); 02149 init->transit_network_select = guide->transit_network_select; 02150 }
void ast_party_id_copy | ( | struct ast_party_id * | dest, | |
const struct ast_party_id * | src | |||
) |
Copy the source party id information to the destination party id.
dest | Destination party id | |
src | Source party id |
Definition at line 2001 of file channel.c.
References ast_free, ast_party_name_copy(), ast_party_number_copy(), ast_party_subaddress_copy(), ast_strdup, ast_party_id::name, ast_party_id::number, ast_party_id::subaddress, and ast_party_id::tag.
Referenced by ast_connected_line_copy_from_caller(), ast_connected_line_copy_to_caller(), ast_party_caller_copy(), ast_party_connected_line_copy(), and ast_party_redirecting_copy().
02002 { 02003 if (dest == src) { 02004 /* Don't copy to self */ 02005 return; 02006 } 02007 02008 ast_party_name_copy(&dest->name, &src->name); 02009 ast_party_number_copy(&dest->number, &src->number); 02010 ast_party_subaddress_copy(&dest->subaddress, &src->subaddress); 02011 02012 ast_free(dest->tag); 02013 dest->tag = ast_strdup(src->tag); 02014 }
void ast_party_id_free | ( | struct ast_party_id * | doomed | ) |
Destroy the party id contents.
doomed | The party id to destroy. |
Definition at line 2047 of file channel.c.
References ast_free, ast_party_name_free(), ast_party_number_free(), ast_party_subaddress_free(), ast_party_id::name, ast_party_id::number, ast_party_id::subaddress, and ast_party_id::tag.
Referenced by ast_party_caller_free(), ast_party_connected_line_free(), ast_party_redirecting_free(), and do_forward().
02048 { 02049 ast_party_name_free(&doomed->name); 02050 ast_party_number_free(&doomed->number); 02051 ast_party_subaddress_free(&doomed->subaddress); 02052 02053 ast_free(doomed->tag); 02054 doomed->tag = NULL; 02055 }
void ast_party_id_init | ( | struct ast_party_id * | init | ) |
Initialize the given party id structure.
init | Party id structure to initialize. |
Definition at line 1993 of file channel.c.
References ast_party_name_init(), ast_party_number_init(), ast_party_subaddress_init(), ast_party_id::name, ast_party_id::number, ast_party_id::subaddress, and ast_party_id::tag.
Referenced by ast_party_caller_init(), ast_party_connected_line_init(), ast_party_redirecting_init(), and do_forward().
01994 { 01995 ast_party_name_init(&init->name); 01996 ast_party_number_init(&init->number); 01997 ast_party_subaddress_init(&init->subaddress); 01998 init->tag = NULL; 01999 }
int ast_party_id_presentation | ( | const struct ast_party_id * | id | ) |
Determine the overall presentation value for the given party.
id | Party to determine the overall presentation value. |
Definition at line 2057 of file channel.c.
References AST_PRES_ALLOWED, AST_PRES_NUMBER_TYPE, AST_PRES_RESTRICTED, AST_PRES_RESTRICTION, AST_PRES_UNAVAILABLE, AST_PRES_USER_NUMBER_UNSCREENED, and id.
Referenced by add_rpid(), ast_str_retrieve_variable(), ast_var_channels_table(), callerpres_read(), iax2_call(), initreqprep(), my_set_callerid(), oh323_call(), party_id_build_data(), party_id_read(), redirecting_read(), report_new_callerid(), setup_env(), sig_pri_handle_subcmds(), sip_call(), and socket_process().
02058 { 02059 int number_priority; 02060 int number_value; 02061 int number_screening; 02062 int name_priority; 02063 int name_value; 02064 02065 /* Determine name presentation priority. */ 02066 if (!id->name.valid) { 02067 name_value = AST_PRES_UNAVAILABLE; 02068 name_priority = 3; 02069 } else { 02070 name_value = id->name.presentation & AST_PRES_RESTRICTION; 02071 switch (name_value) { 02072 case AST_PRES_RESTRICTED: 02073 name_priority = 0; 02074 break; 02075 case AST_PRES_ALLOWED: 02076 name_priority = 1; 02077 break; 02078 case AST_PRES_UNAVAILABLE: 02079 name_priority = 2; 02080 break; 02081 default: 02082 name_value = AST_PRES_UNAVAILABLE; 02083 name_priority = 3; 02084 break; 02085 } 02086 } 02087 02088 /* Determine number presentation priority. */ 02089 if (!id->number.valid) { 02090 number_screening = AST_PRES_USER_NUMBER_UNSCREENED; 02091 number_value = AST_PRES_UNAVAILABLE; 02092 number_priority = 3; 02093 } else { 02094 number_screening = id->number.presentation & AST_PRES_NUMBER_TYPE; 02095 number_value = id->number.presentation & AST_PRES_RESTRICTION; 02096 switch (number_value) { 02097 case AST_PRES_RESTRICTED: 02098 number_priority = 0; 02099 break; 02100 case AST_PRES_ALLOWED: 02101 number_priority = 1; 02102 break; 02103 case AST_PRES_UNAVAILABLE: 02104 number_priority = 2; 02105 break; 02106 default: 02107 number_screening = AST_PRES_USER_NUMBER_UNSCREENED; 02108 number_value = AST_PRES_UNAVAILABLE; 02109 number_priority = 3; 02110 break; 02111 } 02112 } 02113 02114 /* Select the wining presentation value. */ 02115 if (name_priority < number_priority) { 02116 number_value = name_value; 02117 } 02118 02119 return number_value | number_screening; 02120 }
void ast_party_id_set | ( | struct ast_party_id * | dest, | |
const struct ast_party_id * | src, | |||
const struct ast_set_party_id * | update | |||
) |
Set the source party id information into the destination party id.
dest | The id one wishes to update | |
src | The new id values to update the dest | |
update | What id information to update. NULL if all. |
Definition at line 2024 of file channel.c.
References ast_free, ast_party_name_set(), ast_party_number_set(), ast_party_subaddress_set(), ast_strdup, ast_party_id::name, ast_party_id::number, ast_party_id::subaddress, ast_party_id::tag, and update().
Referenced by ast_party_caller_set(), ast_party_connected_line_set(), and ast_party_redirecting_set().
02025 { 02026 if (dest == src) { 02027 /* Don't set to self */ 02028 return; 02029 } 02030 02031 if (!update || update->name) { 02032 ast_party_name_set(&dest->name, &src->name); 02033 } 02034 if (!update || update->number) { 02035 ast_party_number_set(&dest->number, &src->number); 02036 } 02037 if (!update || update->subaddress) { 02038 ast_party_subaddress_set(&dest->subaddress, &src->subaddress); 02039 } 02040 02041 if (src->tag && src->tag != dest->tag) { 02042 ast_free(dest->tag); 02043 dest->tag = ast_strdup(src->tag); 02044 } 02045 }
void ast_party_id_set_init | ( | struct ast_party_id * | init, | |
const struct ast_party_id * | guide | |||
) |
Initialize the given party id structure using the given guide for a set update operation.
init | Party id structure to initialize. | |
guide | Source party id to use as a guide in initializing. |
Definition at line 2016 of file channel.c.
References ast_party_name_set_init(), ast_party_number_set_init(), ast_party_subaddress_set_init(), ast_party_id::name, ast_party_id::number, ast_party_id::subaddress, and ast_party_id::tag.
Referenced by ast_party_caller_set_init(), ast_party_connected_line_set_init(), and ast_party_redirecting_set_init().
02017 { 02018 ast_party_name_set_init(&init->name, &guide->name); 02019 ast_party_number_set_init(&init->number, &guide->number); 02020 ast_party_subaddress_set_init(&init->subaddress, &guide->subaddress); 02021 init->tag = NULL; 02022 }
void ast_party_name_copy | ( | struct ast_party_name * | dest, | |
const struct ast_party_name * | src | |||
) |
Copy the source party name information to the destination party name.
dest | Destination party name | |
src | Source party name |
Definition at line 1842 of file channel.c.
References ast_free, ast_strdup, ast_party_name::char_set, ast_party_name::presentation, ast_party_name::str, and ast_party_name::valid.
Referenced by ast_party_id_copy().
01843 { 01844 if (dest == src) { 01845 /* Don't copy to self */ 01846 return; 01847 } 01848 01849 ast_free(dest->str); 01850 dest->str = ast_strdup(src->str); 01851 dest->char_set = src->char_set; 01852 dest->presentation = src->presentation; 01853 dest->valid = src->valid; 01854 }
void ast_party_name_free | ( | struct ast_party_name * | doomed | ) |
Destroy the party name contents.
doomed | The party name to destroy. |
Definition at line 1881 of file channel.c.
References ast_free, and ast_party_name::str.
Referenced by __analog_ss_thread(), analog_ss_thread(), ast_party_id_free(), and skinny_newcall().
void ast_party_name_init | ( | struct ast_party_name * | init | ) |
Initialize the given name structure.
init | Name structure to initialize. |
Definition at line 1834 of file channel.c.
References AST_PARTY_CHAR_SET_ISO8859_1, AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED, ast_party_name::char_set, ast_party_name::presentation, ast_party_name::str, and ast_party_name::valid.
Referenced by __analog_ss_thread(), analog_ss_thread(), ast_party_id_init(), and skinny_newcall().
01835 { 01836 init->str = NULL; 01837 init->char_set = AST_PARTY_CHAR_SET_ISO8859_1; 01838 init->presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED; 01839 init->valid = 0; 01840 }
void ast_party_name_set | ( | struct ast_party_name * | dest, | |
const struct ast_party_name * | src | |||
) |
Set the source party name information into the destination party name.
dest | The name one wishes to update | |
src | The new name values to update the dest |
Definition at line 1864 of file channel.c.
References ast_free, ast_strdup, ast_party_name::char_set, ast_party_name::presentation, ast_party_name::str, and ast_party_name::valid.
Referenced by ast_party_id_set().
01865 { 01866 if (dest == src) { 01867 /* Don't set to self */ 01868 return; 01869 } 01870 01871 if (src->str && src->str != dest->str) { 01872 ast_free(dest->str); 01873 dest->str = ast_strdup(src->str); 01874 } 01875 01876 dest->char_set = src->char_set; 01877 dest->presentation = src->presentation; 01878 dest->valid = src->valid; 01879 }
void ast_party_name_set_init | ( | struct ast_party_name * | init, | |
const struct ast_party_name * | guide | |||
) |
Initialize the given party name structure using the given guide for a set update operation.
init | Party name structure to initialize. | |
guide | Source party name to use as a guide in initializing. |
Definition at line 1856 of file channel.c.
References ast_party_name::char_set, ast_party_name::presentation, ast_party_name::str, and ast_party_name::valid.
Referenced by ast_party_id_set_init().
01857 { 01858 init->str = NULL; 01859 init->char_set = guide->char_set; 01860 init->presentation = guide->presentation; 01861 init->valid = guide->valid; 01862 }
void ast_party_number_copy | ( | struct ast_party_number * | dest, | |
const struct ast_party_number * | src | |||
) |
Copy the source party number information to the destination party number.
dest | Destination party number | |
src | Source party number |
Definition at line 1895 of file channel.c.
References ast_free, ast_strdup, ast_party_number::plan, ast_party_number::presentation, ast_party_number::str, and ast_party_number::valid.
Referenced by ast_party_id_copy().
01896 { 01897 if (dest == src) { 01898 /* Don't copy to self */ 01899 return; 01900 } 01901 01902 ast_free(dest->str); 01903 dest->str = ast_strdup(src->str); 01904 dest->plan = src->plan; 01905 dest->presentation = src->presentation; 01906 dest->valid = src->valid; 01907 }
void ast_party_number_free | ( | struct ast_party_number * | doomed | ) |
Destroy the party number contents.
doomed | The party number to destroy. |
Definition at line 1934 of file channel.c.
References ast_free, and ast_party_number::str.
Referenced by __analog_ss_thread(), analog_ss_thread(), ast_party_id_free(), do_forward(), and skinny_newcall().
void ast_party_number_init | ( | struct ast_party_number * | init | ) |
Initialize the given number structure.
init | Number structure to initialize. |
Definition at line 1887 of file channel.c.
References AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED, ast_party_number::plan, ast_party_number::presentation, ast_party_number::str, and ast_party_number::valid.
Referenced by __analog_ss_thread(), analog_ss_thread(), ast_party_id_init(), do_forward(), and skinny_newcall().
01888 { 01889 init->str = NULL; 01890 init->plan = 0;/* Unknown */ 01891 init->presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED; 01892 init->valid = 0; 01893 }
void ast_party_number_set | ( | struct ast_party_number * | dest, | |
const struct ast_party_number * | src | |||
) |
Set the source party number information into the destination party number.
dest | The number one wishes to update | |
src | The new number values to update the dest |
Definition at line 1917 of file channel.c.
References ast_free, ast_strdup, ast_party_number::plan, ast_party_number::presentation, ast_party_number::str, and ast_party_number::valid.
Referenced by ast_party_id_set().
01918 { 01919 if (dest == src) { 01920 /* Don't set to self */ 01921 return; 01922 } 01923 01924 if (src->str && src->str != dest->str) { 01925 ast_free(dest->str); 01926 dest->str = ast_strdup(src->str); 01927 } 01928 01929 dest->plan = src->plan; 01930 dest->presentation = src->presentation; 01931 dest->valid = src->valid; 01932 }
void ast_party_number_set_init | ( | struct ast_party_number * | init, | |
const struct ast_party_number * | guide | |||
) |
Initialize the given party number structure using the given guide for a set update operation.
init | Party number structure to initialize. | |
guide | Source party number to use as a guide in initializing. |
Definition at line 1909 of file channel.c.
References ast_party_number::plan, ast_party_number::presentation, ast_party_number::str, and ast_party_number::valid.
Referenced by ast_party_id_set_init().
01910 { 01911 init->str = NULL; 01912 init->plan = guide->plan; 01913 init->presentation = guide->presentation; 01914 init->valid = guide->valid; 01915 }
void ast_party_redirecting_copy | ( | struct ast_party_redirecting * | dest, | |
const struct ast_party_redirecting * | src | |||
) |
Copy the source redirecting information to the destination redirecting.
dest | Destination redirecting | |
src | Source redirecting |
Definition at line 2270 of file channel.c.
References ast_party_id_copy(), ast_party_redirecting::count, ast_party_redirecting::from, ast_party_redirecting::reason, and ast_party_redirecting::to.
Referenced by ast_channel_redirecting_macro(), begin_dial_channel(), dial_exec_full(), do_forward(), local_call(), and ring_entry().
02271 { 02272 if (dest == src) { 02273 /* Don't copy to self */ 02274 return; 02275 } 02276 02277 ast_party_id_copy(&dest->from, &src->from); 02278 ast_party_id_copy(&dest->to, &src->to); 02279 dest->count = src->count; 02280 dest->reason = src->reason; 02281 }
void ast_party_redirecting_free | ( | struct ast_party_redirecting * | doomed | ) |
Destroy the redirecting information contents.
doomed | The redirecting information to destroy. |
Definition at line 2299 of file channel.c.
References ast_party_id_free(), ast_party_redirecting::from, and ast_party_redirecting::to.
Referenced by ast_channel_destructor(), ast_dummy_channel_destructor(), ast_indicate_data(), do_forward(), handle_request_invite(), handle_response(), handle_response_invite(), redirecting_write(), and sig_pri_handle_subcmds().
02300 { 02301 ast_party_id_free(&doomed->from); 02302 ast_party_id_free(&doomed->to); 02303 }
void ast_party_redirecting_init | ( | struct ast_party_redirecting * | init | ) |
Initialize the given redirecting structure.
init | Redirecting structure to initialize. |
Definition at line 2262 of file channel.c.
References ast_party_id_init(), AST_REDIRECTING_REASON_UNKNOWN, ast_party_redirecting::count, ast_party_redirecting::from, ast_party_redirecting::reason, and ast_party_redirecting::to.
Referenced by __ast_channel_alloc_ap(), do_forward(), handle_request_invite(), handle_response(), and handle_response_invite().
02263 { 02264 ast_party_id_init(&init->from); 02265 ast_party_id_init(&init->to); 02266 init->count = 0; 02267 init->reason = AST_REDIRECTING_REASON_UNKNOWN; 02268 }
void ast_party_redirecting_set | ( | struct ast_party_redirecting * | dest, | |
const struct ast_party_redirecting * | src, | |||
const struct ast_set_party_redirecting * | update | |||
) |
Set the redirecting information based on another redirecting source.
dest | The redirecting one wishes to update | |
src | The new redirecting values to update the dest | |
update | What redirecting information to update. NULL if all. |
Definition at line 2291 of file channel.c.
References ast_party_id_set(), ast_party_redirecting::count, ast_party_redirecting::from, ast_party_redirecting::reason, ast_party_redirecting::to, and update().
Referenced by ast_channel_set_redirecting().
02292 { 02293 ast_party_id_set(&dest->from, &src->from, update ? &update->from : NULL); 02294 ast_party_id_set(&dest->to, &src->to, update ? &update->to : NULL); 02295 dest->reason = src->reason; 02296 dest->count = src->count; 02297 }
void ast_party_redirecting_set_init | ( | struct ast_party_redirecting * | init, | |
const struct ast_party_redirecting * | guide | |||
) |
Initialize the given redirecting id structure using the given guide for a set update operation.
init | Redirecting id structure to initialize. | |
guide | Source redirecting id to use as a guide in initializing. |
Definition at line 2283 of file channel.c.
References ast_party_id_set_init(), ast_party_redirecting::count, ast_party_redirecting::from, ast_party_redirecting::reason, and ast_party_redirecting::to.
Referenced by ast_indicate_data(), misdn_copy_redirecting_to_ast(), redirecting_write(), and sig_pri_redirecting_convert().
02284 { 02285 ast_party_id_set_init(&init->from, &guide->from); 02286 ast_party_id_set_init(&init->to, &guide->to); 02287 init->count = guide->count; 02288 init->reason = guide->reason; 02289 }
void ast_party_subaddress_copy | ( | struct ast_party_subaddress * | dest, | |
const struct ast_party_subaddress * | src | |||
) |
Copy the source party subaddress information to the destination party subaddress.
dest | Destination party subaddress | |
src | Source party subaddress |
Definition at line 1948 of file channel.c.
References ast_free, ast_strdup, ast_party_subaddress::odd_even_indicator, ast_party_subaddress::str, ast_party_subaddress::type, and ast_party_subaddress::valid.
Referenced by ast_party_dialed_copy(), and ast_party_id_copy().
01949 { 01950 if (dest == src) { 01951 /* Don't copy to self */ 01952 return; 01953 } 01954 01955 ast_free(dest->str); 01956 dest->str = ast_strdup(src->str); 01957 dest->type = src->type; 01958 dest->odd_even_indicator = src->odd_even_indicator; 01959 dest->valid = src->valid; 01960 }
void ast_party_subaddress_free | ( | struct ast_party_subaddress * | doomed | ) |
Destroy the party subaddress contents.
doomed | The party subaddress to destroy. |
Definition at line 1987 of file channel.c.
References ast_free, and ast_party_subaddress::str.
Referenced by ast_party_dialed_free(), and ast_party_id_free().
void ast_party_subaddress_init | ( | struct ast_party_subaddress * | init | ) |
Initialize the given subaddress structure.
init | Subaddress structure to initialize. |
Definition at line 1940 of file channel.c.
References ast_party_subaddress::odd_even_indicator, ast_party_subaddress::str, ast_party_subaddress::type, and ast_party_subaddress::valid.
Referenced by ast_party_dialed_init(), ast_party_id_init(), sig_pri_call(), and sig_pri_set_subaddress().
01941 { 01942 init->str = NULL; 01943 init->type = 0; 01944 init->odd_even_indicator = 0; 01945 init->valid = 0; 01946 }
void ast_party_subaddress_set | ( | struct ast_party_subaddress * | dest, | |
const struct ast_party_subaddress * | src | |||
) |
Set the source party subaddress information into the destination party subaddress.
dest | The subaddress one wishes to update | |
src | The new subaddress values to update the dest |
Definition at line 1970 of file channel.c.
References ast_free, ast_strdup, ast_party_subaddress::odd_even_indicator, ast_party_subaddress::str, ast_party_subaddress::type, and ast_party_subaddress::valid.
Referenced by ast_party_dialed_set(), ast_party_id_set(), and sig_pri_handle_subcmds().
01971 { 01972 if (dest == src) { 01973 /* Don't set to self */ 01974 return; 01975 } 01976 01977 if (src->str && src->str != dest->str) { 01978 ast_free(dest->str); 01979 dest->str = ast_strdup(src->str); 01980 } 01981 01982 dest->type = src->type; 01983 dest->odd_even_indicator = src->odd_even_indicator; 01984 dest->valid = src->valid; 01985 }
void ast_party_subaddress_set_init | ( | struct ast_party_subaddress * | init, | |
const struct ast_party_subaddress * | guide | |||
) |
Initialize the given party subaddress structure using the given guide for a set update operation.
init | Party subaddress structure to initialize. | |
guide | Source party subaddress to use as a guide in initializing. |
Definition at line 1962 of file channel.c.
References ast_party_subaddress::odd_even_indicator, ast_party_subaddress::str, ast_party_subaddress::type, and ast_party_subaddress::valid.
Referenced by ast_party_dialed_set_init(), and ast_party_id_set_init().
01963 { 01964 init->str = NULL; 01965 init->type = guide->type; 01966 init->odd_even_indicator = guide->odd_even_indicator; 01967 init->valid = guide->valid; 01968 }
int ast_plc_reload | ( | void | ) |
Reload genericplc configuration value from codecs.conf.
Implementation is in main/channel.c
Definition at line 7583 of file channel.c.
References ast_config_load, AST_OPT_FLAG_GENERIC_PLC, ast_options, ast_set2_flag, ast_true(), ast_variable_browse(), config_flags, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, CONFIG_STATUS_FILEUNCHANGED, and var.
Referenced by ast_channels_init().
07584 { 07585 struct ast_variable *var; 07586 struct ast_flags config_flags = { 0 }; 07587 struct ast_config *cfg = ast_config_load("codecs.conf", config_flags); 07588 if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) 07589 return 0; 07590 for (var = ast_variable_browse(cfg, "plc"); var; var = var->next) { 07591 if (!strcasecmp(var->name, "genericplc")) { 07592 ast_set2_flag(&ast_options, ast_true(var->value), AST_OPT_FLAG_GENERIC_PLC); 07593 } 07594 } 07595 ast_config_destroy(cfg); 07596 return 0; 07597 }
void ast_poll_channel_add | ( | struct ast_channel * | chan0, | |
struct ast_channel * | chan1 | |||
) |
Add a channel to an optimized waitfor
Definition at line 2560 of file channel.c.
References AST_MAX_FDS, and ast_channel::fds.
Referenced by ast_generic_bridge(), begin_dial_channel(), feature_request_and_dial(), local_bridge_loop(), remote_bridge_loop(), and wait_for_answer().
02561 { 02562 #ifdef HAVE_EPOLL 02563 struct epoll_event ev; 02564 int i = 0; 02565 02566 if (chan0->epfd == -1) 02567 return; 02568 02569 /* Iterate through the file descriptors on chan1, adding them to chan0 */ 02570 for (i = 0; i < AST_MAX_FDS; i++) { 02571 if (chan1->fds[i] == -1) 02572 continue; 02573 ev.events = EPOLLIN | EPOLLPRI | EPOLLERR | EPOLLHUP; 02574 ev.data.ptr = chan1->epfd_data[i]; 02575 epoll_ctl(chan0->epfd, EPOLL_CTL_ADD, chan1->fds[i], &ev); 02576 } 02577 02578 #endif 02579 return; 02580 }
void ast_poll_channel_del | ( | struct ast_channel * | chan0, | |
struct ast_channel * | chan1 | |||
) |
Delete a channel from an optimized waitfor
Definition at line 2583 of file channel.c.
References AST_MAX_FDS, and ast_channel::fds.
Referenced by feature_request_and_dial(), and monitor_dial().
02584 { 02585 #ifdef HAVE_EPOLL 02586 struct epoll_event ev; 02587 int i = 0; 02588 02589 if (chan0->epfd == -1) 02590 return; 02591 02592 for (i = 0; i < AST_MAX_FDS; i++) { 02593 if (chan1->fds[i] == -1) 02594 continue; 02595 epoll_ctl(chan0->epfd, EPOLL_CTL_DEL, chan1->fds[i], &ev); 02596 } 02597 02598 #endif 02599 return; 02600 }
char* ast_print_group | ( | char * | buf, | |
int | buflen, | |||
ast_group_t | group | |||
) |
print call- and pickup groups into buffer
Definition at line 7731 of file channel.c.
References first.
Referenced by _sip_show_peer(), _skinny_show_line(), func_channel_read(), function_sippeer(), misdn_cfg_get_config_string(), print_group(), read_config(), and serialize_showchan().
07732 { 07733 unsigned int i; 07734 int first = 1; 07735 char num[3]; 07736 07737 buf[0] = '\0'; 07738 07739 if (!group) /* Return empty string if no group */ 07740 return buf; 07741 07742 for (i = 0; i <= 63; i++) { /* Max group is 63 */ 07743 if (group & ((ast_group_t) 1 << i)) { 07744 if (!first) { 07745 strncat(buf, ", ", buflen - strlen(buf) - 1); 07746 } else { 07747 first = 0; 07748 } 07749 snprintf(num, sizeof(num), "%u", i); 07750 strncat(buf, num, buflen - strlen(buf) - 1); 07751 } 07752 } 07753 return buf; 07754 }
int ast_prod | ( | struct ast_channel * | chan | ) |
Send empty audio to prime a channel driver.
Definition at line 4551 of file channel.c.
References ast_channel::_state, ast_debug, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log(), AST_STATE_UP, ast_write(), chanlist::chan, ast_frame_subclass::codec, ast_frame::data, LOG_WARNING, ast_channel::name, ast_frame::ptr, ast_channel::rawwriteformat, ast_frame::src, and ast_frame::subclass.
Referenced by ast_activate_generator().
04552 { 04553 struct ast_frame a = { AST_FRAME_VOICE }; 04554 char nothing[128]; 04555 04556 /* Send an empty audio frame to get things moving */ 04557 if (chan->_state != AST_STATE_UP) { 04558 ast_debug(1, "Prodding channel '%s'\n", chan->name); 04559 a.subclass.codec = chan->rawwriteformat; 04560 a.data.ptr = nothing + AST_FRIENDLY_OFFSET; 04561 a.src = "ast_prod"; /* this better match check in ast_write */ 04562 if (ast_write(chan, &a)) 04563 ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name); 04564 } 04565 return 0; 04566 }
int ast_queue_control | ( | struct ast_channel * | chan, | |
enum ast_control_frame_type | control | |||
) |
Queue a control frame with payload.
chan | channel to queue frame onto | |
control | type of control frame |
zero | on success | |
non-zero | on failure |
Definition at line 1511 of file channel.c.
References AST_FRAME_CONTROL, ast_queue_frame(), chanlist::chan, and f.
Referenced by __analog_handle_event(), __analog_ss_thread(), __ast_read(), __dahdi_exception(), __oh323_update_info(), analog_call(), analog_exception(), analog_hangup(), analog_ss_thread(), ast_pickup_call(), attempt_transfer(), auto_congest(), cb_events(), cli_console_answer(), cli_console_flash(), console_answer(), console_call(), console_sendtext(), 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(), masquerade_colp_transfer(), misdn_facility_ie_handler(), multicast_rtp_call(), nbs_call(), phone_call(), pickup_do(), process_sdp(), receive_digit(), remote_hold(), send_cause2ast(), setup_rtp_connection(), sig_pri_handle_subcmds(), skinny_call(), skinny_transfer(), skinny_unhold(), unistim_call(), and update_state().
01512 { 01513 struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = control }; 01514 return ast_queue_frame(chan, &f); 01515 }
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.
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 |
0 | success | |
non-zero | failure |
The channel does not need to be locked before calling this function.
Definition at line 1518 of file channel.c.
References AST_FRAME_CONTROL, ast_queue_frame(), chanlist::chan, and f.
Referenced by __analog_handle_event(), analog_hangup(), ast_channel_queue_connected_line_update(), ast_channel_queue_redirecting_update(), change_t38_state(), dahdi_handle_event(), dahdi_hangup(), handle_request_notify(), handle_response_refer(), iax2_queue_control_data(), iax2_transfer(), interpret_t38_parameters(), local_attended_transfer(), masquerade_colp_transfer(), process_sdp(), sip_sipredirect(), and skinny_hold().
01520 { 01521 struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = control, .data.ptr = (void *) data, .datalen = datalen }; 01522 return ast_queue_frame(chan, &f); 01523 }
int ast_queue_frame | ( | struct ast_channel * | chan, | |
struct ast_frame * | f | |||
) |
Queue one or more frames to a channel's frame queue.
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. |
0 | success | |
non-zero | failure |
Definition at line 1468 of file channel.c.
References __ast_queue_frame(), and chanlist::chan.
Referenced by __ast_channel_masquerade(), __ast_read(), __oh323_rtp_create(), __oh323_update_info(), action_atxfer(), agent_new(), alsa_call(), ast_channel_setwhentohangup_tv(), ast_do_masquerade(), ast_queue_cc_frame(), ast_queue_control(), ast_queue_control_data(), ast_queue_hangup(), ast_queue_hangup_with_cause(), ast_softhangup_nolock(), bridge_write(), cb_events(), cli_console_dial(), cli_console_sendtext(), console_dial(), console_do_answer(), console_flash(), console_sendtext(), dahdi_queue_frame(), dahdi_read(), 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(), keypad_digit(), local_queue_frame(), mgcp_queue_frame(), oh323_simulate_dtmf_end(), oss_call(), pri_queue_frame(), process_sdp(), queue_dtmf_readq(), receive_digit(), receive_message(), rpt_call(), sig_pri_handle_hold(), stream_monitor(), unistim_do_senddigit(), unistim_senddigit_end(), usbradio_read(), and wakeup_sub().
01469 { 01470 return __ast_queue_frame(chan, fin, 0, NULL); 01471 }
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.
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. |
0 | success | |
non-zero | failure |
Definition at line 1473 of file channel.c.
References __ast_queue_frame(), and chanlist::chan.
Referenced by __ast_answer(), __ast_read(), ast_autoservice_stop(), ast_safe_sleep_conditional(), and feature_request_and_dial().
01474 { 01475 return __ast_queue_frame(chan, fin, 1, NULL); 01476 }
int ast_queue_hangup | ( | struct ast_channel * | chan | ) |
Queue a hangup frame.
Definition at line 1479 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, chanlist::chan, and f.
Referenced by bridge_queue_hangup(), 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_fixup(), local_hangup(), and mgcp_queue_hangup().
01480 { 01481 struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = AST_CONTROL_HANGUP }; 01482 /* Yeah, let's not change a lock-critical value without locking */ 01483 if (!ast_channel_trylock(chan)) { 01484 chan->_softhangup |= AST_SOFTHANGUP_DEV; 01485 ast_channel_unlock(chan); 01486 } 01487 return ast_queue_frame(chan, &f); 01488 }
int ast_queue_hangup_with_cause | ( | struct ast_channel * | chan, | |
int | cause | |||
) |
Queue a hangup frame with hangupcause set.
[in] | chan | channel to queue frame onto |
[in] | cause | the hangup cause |
Definition at line 1491 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, chanlist::chan, f, and ast_channel::hangupcause.
Referenced by __analog_handle_event(), __oh323_update_info(), __sip_autodestruct(), close_call(), close_client(), console_hangup(), dahdi_handle_event(), dahdi_r2_on_call_disconnect(), handle_request_bye(), handle_response(), handle_response_invite(), handle_response_notify(), HandleCallOutgoing(), hangup_chan(), hangup_connection(), misdn_answer(), retrans_pkt(), and TransferCallStep1().
01492 { 01493 struct ast_frame f = { AST_FRAME_CONTROL, .subclass.integer = AST_CONTROL_HANGUP }; 01494 01495 if (cause >= 0) 01496 f.data.uint32 = cause; 01497 01498 /* Yeah, let's not change a lock-critical value without locking */ 01499 if (!ast_channel_trylock(chan)) { 01500 chan->_softhangup |= AST_SOFTHANGUP_DEV; 01501 if (cause < 0) 01502 f.data.uint32 = chan->hangupcause; 01503 01504 ast_channel_unlock(chan); 01505 } 01506 01507 return ast_queue_frame(chan, &f); 01508 }
int ast_raw_answer | ( | struct ast_channel * | chan, | |
int | cdr_answer | |||
) |
Answer a channel.
chan | channel to answer | |
cdr_answer | flag to control whether any associated CDR should be marked as 'answered' |
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.
0 | on success | |
non-zero | on failure |
Definition at line 2798 of file channel.c.
References ast_channel::_state, ast_channel_tech::answer, ast_cdr_answer(), AST_CEL_ANSWER, ast_cel_report_event(), 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, chanlist::chan, and ast_channel::tech.
Referenced by __ast_answer(), and ast_bridge_call().
02799 { 02800 int res = 0; 02801 02802 ast_channel_lock(chan); 02803 02804 /* You can't answer an outbound call */ 02805 if (ast_test_flag(chan, AST_FLAG_OUTGOING)) { 02806 ast_channel_unlock(chan); 02807 return 0; 02808 } 02809 02810 /* Stop if we're a zombie or need a soft hangup */ 02811 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) { 02812 ast_channel_unlock(chan); 02813 return -1; 02814 } 02815 02816 ast_channel_unlock(chan); 02817 02818 switch (chan->_state) { 02819 case AST_STATE_RINGING: 02820 case AST_STATE_RING: 02821 ast_channel_lock(chan); 02822 if (chan->tech->answer) { 02823 res = chan->tech->answer(chan); 02824 } 02825 ast_setstate(chan, AST_STATE_UP); 02826 if (cdr_answer) { 02827 ast_cdr_answer(chan->cdr); 02828 } 02829 ast_cel_report_event(chan, AST_CEL_ANSWER, NULL, NULL, NULL); 02830 ast_channel_unlock(chan); 02831 break; 02832 case AST_STATE_UP: 02833 ast_cel_report_event(chan, AST_CEL_ANSWER, NULL, NULL, NULL); 02834 /* Calling ast_cdr_answer when it it has previously been called 02835 * is essentially a no-op, so it is safe. 02836 */ 02837 if (cdr_answer) { 02838 ast_cdr_answer(chan->cdr); 02839 } 02840 break; 02841 default: 02842 break; 02843 } 02844 02845 ast_indicate(chan, -1); 02846 02847 return res; 02848 }
struct ast_frame* ast_read | ( | struct ast_channel * | chan | ) |
Reads a frame.
chan | channel to read a frame from |
Definition at line 4174 of file channel.c.
References __ast_read(), and chanlist::chan.
Referenced by __adsi_transmit_messages(), __analog_ss_thread(), __ast_answer(), __ast_play_and_record(), __ast_request_and_dial(), adsi_careful_send(), agent_ack_sleep(), agent_read(), analog_ss_thread(), ast_bridge_handle_trip(), ast_recvtext(), ast_safe_sleep_conditional(), ast_tonepair(), ast_transfer(), ast_udptl_bridge(), ast_waitfordigit_full(), async_wait(), autoservice_run(), background_detect_exec(), channel_spy(), check_goto_on_transfer(), conf_flush(), conf_run(), dahdi_bridge(), dial_exec_full(), dictate_exec(), disa_exec(), disable_t38(), do_idle_thread(), do_waiting(), echo_exec(), eivr_comm(), feature_request_and_dial(), find_cache(), generic_fax_exec(), handle_recordfile(), handle_speechrecognize(), iax_park_thread(), ices_exec(), isAnsweringMachine(), jack_exec(), launch_asyncagi(), local_bridge_loop(), manage_parkinglot(), masq_park_call(), measurenoise(), misdn_bridge(), monitor_dial(), mp3_exec(), NBScat_exec(), receive_dtmf_digits(), receivefax_t38_init(), recordthread(), remote_bridge_loop(), rpt(), run_agi(), send_tone_burst(), send_waveform_to_channel(), sendfax_t38_init(), sendurl_exec(), speech_background(), transmit_audio(), transmit_t38(), wait_for_hangup(), wait_for_winner(), waitforring_exec(), and waitstream_core().
04175 { 04176 return __ast_read(chan, 0); 04177 }
static void ast_read_generator_actions | ( | struct ast_channel * | chan, | |
struct ast_frame * | f | |||
) | [static] |
Definition at line 3535 of file channel.c.
References ast_channel_lock, ast_channel_unlock, ast_deactivate_generator(), ast_debug, ast_format_rate(), AST_FRAME_CNG, ast_internal_timing_enabled(), ast_settimeout(), chanlist::chan, f, ast_generator::generate, ast_channel::generator, generator_force(), ast_channel::generatordata, ast_channel::timingfd, ast_channel::timingfunc, and ast_channel::writeformat.
Referenced by __ast_read().
03536 { 03537 if (chan->generator && chan->generator->generate && chan->generatordata && !ast_internal_timing_enabled(chan)) { 03538 void *tmp = chan->generatordata; 03539 int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples) = chan->generator->generate; 03540 int res; 03541 int samples; 03542 03543 if (chan->timingfunc) { 03544 ast_debug(1, "Generator got voice, switching to phase locked mode\n"); 03545 ast_settimeout(chan, 0, NULL, NULL); 03546 } 03547 03548 chan->generatordata = NULL; /* reset, to let writes go through */ 03549 03550 if (f->subclass.codec != chan->writeformat) { 03551 float factor; 03552 factor = ((float) ast_format_rate(chan->writeformat)) / ((float) ast_format_rate(f->subclass.codec)); 03553 samples = (int) ( ((float) f->samples) * factor ); 03554 } else { 03555 samples = f->samples; 03556 } 03557 03558 /* This unlock is here based on two assumptions that hold true at this point in the 03559 * code. 1) this function is only called from within __ast_read() and 2) all generators 03560 * call ast_write() in their generate callback. 03561 * 03562 * The reason this is added is so that when ast_write is called, the lock that occurs 03563 * there will not recursively lock the channel. Doing this will cause intended deadlock 03564 * avoidance not to work in deeper functions 03565 */ 03566 ast_channel_unlock(chan); 03567 res = generate(chan, tmp, f->datalen, samples); 03568 ast_channel_lock(chan); 03569 chan->generatordata = tmp; 03570 if (res) { 03571 ast_debug(1, "Auto-deactivating generator\n"); 03572 ast_deactivate_generator(chan); 03573 } 03574 03575 } else if (f->frametype == AST_FRAME_CNG) { 03576 if (chan->generator && !chan->timingfunc && (chan->timingfd > -1)) { 03577 ast_debug(1, "Generator got CNG, switching to timed mode\n"); 03578 ast_settimeout(chan, 50, generator_force, chan); 03579 } 03580 } 03581 }
struct ast_frame* ast_read_noaudio | ( | struct ast_channel * | chan | ) |
Reads a frame, returning AST_FRAME_NULL frame if audio.
chan | channel to read a frame from |
Definition at line 4179 of file channel.c.
References __ast_read(), and chanlist::chan.
Referenced by ast_bridge_handle_trip(), and conf_run().
04180 { 04181 return __ast_read(chan, 1); 04182 }
int ast_readstring | ( | struct ast_channel * | c, | |
char * | s, | |||
int | len, | |||
int | timeout, | |||
int | rtimeout, | |||
char * | enders | |||
) |
Reads multiple digits.
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 |
Definition at line 5527 of file channel.c.
References ast_readstring_full().
Referenced by 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().
05528 { 05529 return ast_readstring_full(c, s, len, timeout, ftimeout, enders, -1, -1); 05530 }
int ast_readstring_full | ( | struct ast_channel * | c, | |
char * | s, | |||
int | len, | |||
int | timeout, | |||
int | ftimeout, | |||
char * | enders, | |||
int | audiofd, | |||
int | ctrlfd | |||
) |
Definition at line 5532 of file channel.c.
References ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), 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_opt_transmit_silence, ast_stopstream(), ast_test_flag, ast_waitfordigit_full(), ast_waitstream_full(), and ast_channel::stream.
Referenced by ast_app_getdata_full(), and ast_readstring().
05533 { 05534 int pos = 0; /* index in the buffer where we accumulate digits */ 05535 int to = ftimeout; 05536 05537 struct ast_silence_generator *silgen = NULL; 05538 05539 /* Stop if we're a zombie or need a soft hangup */ 05540 if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c)) 05541 return -1; 05542 if (!len) 05543 return -1; 05544 for (;;) { 05545 int d; 05546 if (c->stream) { 05547 d = ast_waitstream_full(c, AST_DIGIT_ANY, audiofd, ctrlfd); 05548 ast_stopstream(c); 05549 if (!silgen && ast_opt_transmit_silence) 05550 silgen = ast_channel_start_silence_generator(c); 05551 usleep(1000); 05552 if (!d) 05553 d = ast_waitfordigit_full(c, to, audiofd, ctrlfd); 05554 } else { 05555 if (!silgen && ast_opt_transmit_silence) 05556 silgen = ast_channel_start_silence_generator(c); 05557 d = ast_waitfordigit_full(c, to, audiofd, ctrlfd); 05558 } 05559 if (d < 0) { 05560 ast_channel_stop_silence_generator(c, silgen); 05561 return AST_GETDATA_FAILED; 05562 } 05563 if (d == 0) { 05564 s[pos] = '\0'; 05565 ast_channel_stop_silence_generator(c, silgen); 05566 return AST_GETDATA_TIMEOUT; 05567 } 05568 if (d == 1) { 05569 s[pos] = '\0'; 05570 ast_channel_stop_silence_generator(c, silgen); 05571 return AST_GETDATA_INTERRUPTED; 05572 } 05573 if (strchr(enders, d) && (pos == 0)) { 05574 s[pos] = '\0'; 05575 ast_channel_stop_silence_generator(c, silgen); 05576 return AST_GETDATA_EMPTY_END_TERMINATED; 05577 } 05578 if (!strchr(enders, d)) { 05579 s[pos++] = d; 05580 } 05581 if (strchr(enders, d) || (pos >= len)) { 05582 s[pos] = '\0'; 05583 ast_channel_stop_silence_generator(c, silgen); 05584 return AST_GETDATA_COMPLETE; 05585 } 05586 to = timeout; 05587 } 05588 /* Never reached */ 05589 return 0; 05590 }
int ast_recvchar | ( | struct ast_channel * | chan, | |
int | timeout | |||
) |
Receives a text character from a channel.
chan | channel to act upon | |
timeout | timeout in milliseconds (0 for infinite wait) |
Definition at line 4427 of file channel.c.
References ast_free, ast_recvtext(), and chanlist::chan.
Referenced by handle_recvchar().
04428 { 04429 int c; 04430 char *buf = ast_recvtext(chan, timeout); 04431 if (buf == NULL) 04432 return -1; /* error or timeout */ 04433 c = *(unsigned char *)buf; 04434 ast_free(buf); 04435 return c; 04436 }
char* ast_recvtext | ( | struct ast_channel * | chan, | |
int | timeout | |||
) |
Receives a text string from a channel Read a string of text from a channel.
chan | channel to act upon | |
timeout | timeout in milliseconds (0 for infinite wait) |
Definition at line 4438 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(), chanlist::chan, and f.
Referenced by ast_recvchar(), and handle_recvtext().
04439 { 04440 int res, done = 0; 04441 char *buf = NULL; 04442 04443 while (!done) { 04444 struct ast_frame *f; 04445 if (ast_check_hangup(chan)) 04446 break; 04447 res = ast_waitfor(chan, timeout); 04448 if (res <= 0) /* timeout or error */ 04449 break; 04450 timeout = res; /* update timeout */ 04451 f = ast_read(chan); 04452 if (f == NULL) 04453 break; /* no frame */ 04454 if (f->frametype == AST_FRAME_CONTROL && f->subclass.integer == AST_CONTROL_HANGUP) 04455 done = 1; /* force a break */ 04456 else if (f->frametype == AST_FRAME_TEXT) { /* what we want */ 04457 buf = ast_strndup((char *) f->data.ptr, f->datalen); /* dup and break */ 04458 done = 1; 04459 } 04460 ast_frfree(f); 04461 } 04462 return buf; 04463 }
int ast_redirecting_build_data | ( | unsigned char * | data, | |
size_t | datalen, | |||
const struct ast_party_redirecting * | redirecting, | |||
const struct ast_set_party_redirecting * | update | |||
) |
Build the redirecting id data frame.
data | Buffer to fill with the frame data | |
datalen | Size of the buffer to fill | |
redirecting | Redirecting id information | |
update | What redirecting information to build. NULL if all. |
-1 | if error | |
Amount | of data buffer used |
Definition at line 8633 of file channel.c.
References ast_log(), AST_REDIRECTING_COUNT, AST_REDIRECTING_FROM_ID_PRESENTATION, AST_REDIRECTING_FROM_NAME, AST_REDIRECTING_FROM_NAME_CHAR_SET, AST_REDIRECTING_FROM_NAME_PRESENTATION, AST_REDIRECTING_FROM_NAME_VALID, AST_REDIRECTING_FROM_NUMBER, AST_REDIRECTING_FROM_NUMBER_PLAN, AST_REDIRECTING_FROM_NUMBER_PRESENTATION, AST_REDIRECTING_FROM_NUMBER_VALID, AST_REDIRECTING_FROM_SUBADDRESS, AST_REDIRECTING_FROM_SUBADDRESS_ODD_EVEN, AST_REDIRECTING_FROM_SUBADDRESS_TYPE, AST_REDIRECTING_FROM_SUBADDRESS_VALID, AST_REDIRECTING_FROM_TAG, AST_REDIRECTING_TO_ID_PRESENTATION, AST_REDIRECTING_TO_NAME, AST_REDIRECTING_TO_NAME_CHAR_SET, AST_REDIRECTING_TO_NAME_PRESENTATION, AST_REDIRECTING_TO_NAME_VALID, AST_REDIRECTING_TO_NUMBER, AST_REDIRECTING_TO_NUMBER_PLAN, AST_REDIRECTING_TO_NUMBER_PRESENTATION, AST_REDIRECTING_TO_NUMBER_VALID, AST_REDIRECTING_TO_SUBADDRESS, AST_REDIRECTING_TO_SUBADDRESS_ODD_EVEN, AST_REDIRECTING_TO_SUBADDRESS_TYPE, AST_REDIRECTING_TO_SUBADDRESS_VALID, AST_REDIRECTING_TO_TAG, AST_REDIRECTING_VERSION, ast_party_redirecting::count, ast_party_redirecting::from, LOG_WARNING, ast_party_id_ies::name, party_id_build_data(), ast_party_redirecting::reason, ast_party_name_ies::str, ast_party_redirecting::to, update(), and value.
Referenced by ast_channel_queue_redirecting_update(), ast_channel_update_redirecting(), and local_indicate().
08634 { 08635 int32_t value; 08636 size_t pos = 0; 08637 int res; 08638 08639 static const struct ast_party_id_ies from_ies = { 08640 .name.str = AST_REDIRECTING_FROM_NAME, 08641 .name.char_set = AST_REDIRECTING_FROM_NAME_CHAR_SET, 08642 .name.presentation = AST_REDIRECTING_FROM_NAME_PRESENTATION, 08643 .name.valid = AST_REDIRECTING_FROM_NAME_VALID, 08644 08645 .number.str = AST_REDIRECTING_FROM_NUMBER, 08646 .number.plan = AST_REDIRECTING_FROM_NUMBER_PLAN, 08647 .number.presentation = AST_REDIRECTING_FROM_NUMBER_PRESENTATION, 08648 .number.valid = AST_REDIRECTING_FROM_NUMBER_VALID, 08649 08650 .subaddress.str = AST_REDIRECTING_FROM_SUBADDRESS, 08651 .subaddress.type = AST_REDIRECTING_FROM_SUBADDRESS_TYPE, 08652 .subaddress.odd_even_indicator = AST_REDIRECTING_FROM_SUBADDRESS_ODD_EVEN, 08653 .subaddress.valid = AST_REDIRECTING_FROM_SUBADDRESS_VALID, 08654 08655 .tag = AST_REDIRECTING_FROM_TAG, 08656 .combined_presentation = AST_REDIRECTING_FROM_ID_PRESENTATION, 08657 }; 08658 static const struct ast_party_id_ies to_ies = { 08659 .name.str = AST_REDIRECTING_TO_NAME, 08660 .name.char_set = AST_REDIRECTING_TO_NAME_CHAR_SET, 08661 .name.presentation = AST_REDIRECTING_TO_NAME_PRESENTATION, 08662 .name.valid = AST_REDIRECTING_TO_NAME_VALID, 08663 08664 .number.str = AST_REDIRECTING_TO_NUMBER, 08665 .number.plan = AST_REDIRECTING_TO_NUMBER_PLAN, 08666 .number.presentation = AST_REDIRECTING_TO_NUMBER_PRESENTATION, 08667 .number.valid = AST_REDIRECTING_TO_NUMBER_VALID, 08668 08669 .subaddress.str = AST_REDIRECTING_TO_SUBADDRESS, 08670 .subaddress.type = AST_REDIRECTING_TO_SUBADDRESS_TYPE, 08671 .subaddress.odd_even_indicator = AST_REDIRECTING_TO_SUBADDRESS_ODD_EVEN, 08672 .subaddress.valid = AST_REDIRECTING_TO_SUBADDRESS_VALID, 08673 08674 .tag = AST_REDIRECTING_TO_TAG, 08675 .combined_presentation = AST_REDIRECTING_TO_ID_PRESENTATION, 08676 }; 08677 08678 /* Redirecting frame version */ 08679 if (datalen < pos + (sizeof(data[0]) * 2) + 1) { 08680 ast_log(LOG_WARNING, "No space left for redirecting frame version\n"); 08681 return -1; 08682 } 08683 data[pos++] = AST_REDIRECTING_VERSION; 08684 data[pos++] = 1; 08685 data[pos++] = 2;/* Version 1 did not have a version ie */ 08686 08687 res = party_id_build_data(data + pos, datalen - pos, &redirecting->from, 08688 "redirecting-from", &from_ies, update ? &update->from : NULL); 08689 if (res < 0) { 08690 return -1; 08691 } 08692 pos += res; 08693 08694 res = party_id_build_data(data + pos, datalen - pos, &redirecting->to, 08695 "redirecting-to", &to_ies, update ? &update->to : NULL); 08696 if (res < 0) { 08697 return -1; 08698 } 08699 pos += res; 08700 08701 /* Redirecting reason */ 08702 if (datalen < pos + (sizeof(data[0]) * 2) + sizeof(value)) { 08703 ast_log(LOG_WARNING, "No space left for redirecting reason\n"); 08704 return -1; 08705 } 08706 data[pos++] = AST_REDIRECTING_REASON; 08707 data[pos++] = sizeof(value); 08708 value = htonl(redirecting->reason); 08709 memcpy(data + pos, &value, sizeof(value)); 08710 pos += sizeof(value); 08711 08712 /* Redirecting count */ 08713 if (datalen < pos + (sizeof(data[0]) * 2) + sizeof(value)) { 08714 ast_log(LOG_WARNING, "No space left for redirecting count\n"); 08715 return -1; 08716 } 08717 data[pos++] = AST_REDIRECTING_COUNT; 08718 data[pos++] = sizeof(value); 08719 value = htonl(redirecting->count); 08720 memcpy(data + pos, &value, sizeof(value)); 08721 pos += sizeof(value); 08722 08723 return pos; 08724 }
int ast_redirecting_parse_data | ( | const unsigned char * | data, | |
size_t | datalen, | |||
struct ast_party_redirecting * | redirecting | |||
) |
Parse redirecting indication frame data.
data | Buffer with the frame data to parse | |
datalen | Size of the buffer | |
redirecting | Extracted redirecting id information |
0 | on success. | |
-1 | on error. |
The filled in id structure needs to be destroyed by ast_party_redirecting_free() when it is no longer needed.
Definition at line 8726 of file channel.c.
References ast_free, ast_log(), ast_malloc, AST_PARTY_CHAR_SET_ISO8859_1, AST_REDIRECTING_COUNT, AST_REDIRECTING_FROM_ID_PRESENTATION, AST_REDIRECTING_FROM_NAME, AST_REDIRECTING_FROM_NAME_CHAR_SET, AST_REDIRECTING_FROM_NAME_PRESENTATION, AST_REDIRECTING_FROM_NAME_VALID, AST_REDIRECTING_FROM_NUMBER, AST_REDIRECTING_FROM_NUMBER_PLAN, AST_REDIRECTING_FROM_NUMBER_PRESENTATION, AST_REDIRECTING_FROM_NUMBER_VALID, AST_REDIRECTING_FROM_SUBADDRESS, AST_REDIRECTING_FROM_SUBADDRESS_ODD_EVEN, AST_REDIRECTING_FROM_SUBADDRESS_TYPE, AST_REDIRECTING_FROM_SUBADDRESS_VALID, AST_REDIRECTING_FROM_TAG, AST_REDIRECTING_TO_ID_PRESENTATION, AST_REDIRECTING_TO_NAME, AST_REDIRECTING_TO_NAME_CHAR_SET, AST_REDIRECTING_TO_NAME_PRESENTATION, AST_REDIRECTING_TO_NAME_VALID, AST_REDIRECTING_TO_NUMBER, AST_REDIRECTING_TO_NUMBER_PLAN, AST_REDIRECTING_TO_NUMBER_PRESENTATION, AST_REDIRECTING_TO_NUMBER_VALID, AST_REDIRECTING_TO_SUBADDRESS, AST_REDIRECTING_TO_SUBADDRESS_ODD_EVEN, AST_REDIRECTING_TO_SUBADDRESS_TYPE, AST_REDIRECTING_TO_SUBADDRESS_VALID, AST_REDIRECTING_TO_TAG, AST_REDIRECTING_VERSION, ast_party_name::char_set, ast_party_redirecting::count, ast_party_redirecting::from, LOG_DEBUG, LOG_WARNING, ast_party_id::name, ast_party_id::number, ast_party_subaddress::odd_even_indicator, ast_party_number::plan, ast_party_number::presentation, ast_party_name::presentation, ast_party_redirecting::reason, ast_party_subaddress::str, ast_party_number::str, ast_party_name::str, ast_party_id::subaddress, ast_party_id::tag, ast_party_redirecting::to, ast_party_subaddress::type, ast_party_subaddress::valid, ast_party_number::valid, ast_party_name::valid, and value.
Referenced by ast_channel_redirecting_macro(), and ast_indicate_data().
08727 { 08728 size_t pos; 08729 unsigned char ie_len; 08730 unsigned char ie_id; 08731 int32_t value; 08732 int frame_version = 1; 08733 int from_combined_presentation = 0; 08734 int got_from_combined_presentation = 0;/* TRUE if got a combined name and number presentation value. */ 08735 int to_combined_presentation = 0; 08736 int got_to_combined_presentation = 0;/* TRUE if got a combined name and number presentation value. */ 08737 08738 for (pos = 0; pos < datalen; pos += ie_len) { 08739 if (datalen < pos + sizeof(ie_id) + sizeof(ie_len)) { 08740 ast_log(LOG_WARNING, "Invalid redirecting update\n"); 08741 return -1; 08742 } 08743 ie_id = data[pos++]; 08744 ie_len = data[pos++]; 08745 if (datalen < pos + ie_len) { 08746 ast_log(LOG_WARNING, "Invalid redirecting update\n"); 08747 return -1; 08748 } 08749 08750 switch (ie_id) { 08751 /* Redirecting frame version */ 08752 case AST_REDIRECTING_VERSION: 08753 if (ie_len != 1) { 08754 ast_log(LOG_WARNING, "Invalid redirecting frame version (%u)\n", 08755 (unsigned) ie_len); 08756 break; 08757 } 08758 frame_version = data[pos]; 08759 break; 08760 /* Redirecting-from party id name */ 08761 case AST_REDIRECTING_FROM_NAME: 08762 ast_free(redirecting->from.name.str); 08763 redirecting->from.name.str = ast_malloc(ie_len + 1); 08764 if (redirecting->from.name.str) { 08765 memcpy(redirecting->from.name.str, data + pos, ie_len); 08766 redirecting->from.name.str[ie_len] = 0; 08767 } 08768 break; 08769 case AST_REDIRECTING_FROM_NAME_CHAR_SET: 08770 if (ie_len != 1) { 08771 ast_log(LOG_WARNING, "Invalid redirecting-from name char set (%u)\n", 08772 (unsigned) ie_len); 08773 break; 08774 } 08775 redirecting->from.name.char_set = data[pos]; 08776 break; 08777 case AST_REDIRECTING_FROM_NAME_PRESENTATION: 08778 if (ie_len != 1) { 08779 ast_log(LOG_WARNING, "Invalid redirecting-from name presentation (%u)\n", 08780 (unsigned) ie_len); 08781 break; 08782 } 08783 redirecting->from.name.presentation = data[pos]; 08784 break; 08785 case AST_REDIRECTING_FROM_NAME_VALID: 08786 if (ie_len != 1) { 08787 ast_log(LOG_WARNING, "Invalid redirecting-from name valid (%u)\n", 08788 (unsigned) ie_len); 08789 break; 08790 } 08791 redirecting->from.name.valid = data[pos]; 08792 break; 08793 /* Redirecting-from party id number */ 08794 case AST_REDIRECTING_FROM_NUMBER: 08795 ast_free(redirecting->from.number.str); 08796 redirecting->from.number.str = ast_malloc(ie_len + 1); 08797 if (redirecting->from.number.str) { 08798 memcpy(redirecting->from.number.str, data + pos, ie_len); 08799 redirecting->from.number.str[ie_len] = 0; 08800 } 08801 break; 08802 case AST_REDIRECTING_FROM_NUMBER_PLAN: 08803 if (ie_len != 1) { 08804 ast_log(LOG_WARNING, "Invalid redirecting-from numbering plan (%u)\n", 08805 (unsigned) ie_len); 08806 break; 08807 } 08808 redirecting->from.number.plan = data[pos]; 08809 break; 08810 case AST_REDIRECTING_FROM_NUMBER_PRESENTATION: 08811 if (ie_len != 1) { 08812 ast_log(LOG_WARNING, "Invalid redirecting-from number presentation (%u)\n", 08813 (unsigned) ie_len); 08814 break; 08815 } 08816 redirecting->from.number.presentation = data[pos]; 08817 break; 08818 case AST_REDIRECTING_FROM_NUMBER_VALID: 08819 if (ie_len != 1) { 08820 ast_log(LOG_WARNING, "Invalid redirecting-from number valid (%u)\n", 08821 (unsigned) ie_len); 08822 break; 08823 } 08824 redirecting->from.number.valid = data[pos]; 08825 break; 08826 /* Redirecting-from party id combined presentation */ 08827 case AST_REDIRECTING_FROM_ID_PRESENTATION: 08828 if (ie_len != 1) { 08829 ast_log(LOG_WARNING, "Invalid redirecting-from combined presentation (%u)\n", 08830 (unsigned) ie_len); 08831 break; 08832 } 08833 from_combined_presentation = data[pos]; 08834 got_from_combined_presentation = 1; 08835 break; 08836 /* Redirecting-from party id subaddress */ 08837 case AST_REDIRECTING_FROM_SUBADDRESS: 08838 ast_free(redirecting->from.subaddress.str); 08839 redirecting->from.subaddress.str = ast_malloc(ie_len + 1); 08840 if (redirecting->from.subaddress.str) { 08841 memcpy(redirecting->from.subaddress.str, data + pos, ie_len); 08842 redirecting->from.subaddress.str[ie_len] = 0; 08843 } 08844 break; 08845 case AST_REDIRECTING_FROM_SUBADDRESS_TYPE: 08846 if (ie_len != 1) { 08847 ast_log(LOG_WARNING, "Invalid redirecting-from type of subaddress (%u)\n", 08848 (unsigned) ie_len); 08849 break; 08850 } 08851 redirecting->from.subaddress.type = data[pos]; 08852 break; 08853 case AST_REDIRECTING_FROM_SUBADDRESS_ODD_EVEN: 08854 if (ie_len != 1) { 08855 ast_log(LOG_WARNING, 08856 "Invalid redirecting-from subaddress odd-even indicator (%u)\n", 08857 (unsigned) ie_len); 08858 break; 08859 } 08860 redirecting->from.subaddress.odd_even_indicator = data[pos]; 08861 break; 08862 case AST_REDIRECTING_FROM_SUBADDRESS_VALID: 08863 if (ie_len != 1) { 08864 ast_log(LOG_WARNING, "Invalid redirecting-from subaddress valid (%u)\n", 08865 (unsigned) ie_len); 08866 break; 08867 } 08868 redirecting->from.subaddress.valid = data[pos]; 08869 break; 08870 /* Redirecting-from party id tag */ 08871 case AST_REDIRECTING_FROM_TAG: 08872 ast_free(redirecting->from.tag); 08873 redirecting->from.tag = ast_malloc(ie_len + 1); 08874 if (redirecting->from.tag) { 08875 memcpy(redirecting->from.tag, data + pos, ie_len); 08876 redirecting->from.tag[ie_len] = 0; 08877 } 08878 break; 08879 /* Redirecting-to party id name */ 08880 case AST_REDIRECTING_TO_NAME: 08881 ast_free(redirecting->to.name.str); 08882 redirecting->to.name.str = ast_malloc(ie_len + 1); 08883 if (redirecting->to.name.str) { 08884 memcpy(redirecting->to.name.str, data + pos, ie_len); 08885 redirecting->to.name.str[ie_len] = 0; 08886 } 08887 break; 08888 case AST_REDIRECTING_TO_NAME_CHAR_SET: 08889 if (ie_len != 1) { 08890 ast_log(LOG_WARNING, "Invalid redirecting-to name char set (%u)\n", 08891 (unsigned) ie_len); 08892 break; 08893 } 08894 redirecting->to.name.char_set = data[pos]; 08895 break; 08896 case AST_REDIRECTING_TO_NAME_PRESENTATION: 08897 if (ie_len != 1) { 08898 ast_log(LOG_WARNING, "Invalid redirecting-to name presentation (%u)\n", 08899 (unsigned) ie_len); 08900 break; 08901 } 08902 redirecting->to.name.presentation = data[pos]; 08903 break; 08904 case AST_REDIRECTING_TO_NAME_VALID: 08905 if (ie_len != 1) { 08906 ast_log(LOG_WARNING, "Invalid redirecting-to name valid (%u)\n", 08907 (unsigned) ie_len); 08908 break; 08909 } 08910 redirecting->to.name.valid = data[pos]; 08911 break; 08912 /* Redirecting-to party id number */ 08913 case AST_REDIRECTING_TO_NUMBER: 08914 ast_free(redirecting->to.number.str); 08915 redirecting->to.number.str = ast_malloc(ie_len + 1); 08916 if (redirecting->to.number.str) { 08917 memcpy(redirecting->to.number.str, data + pos, ie_len); 08918 redirecting->to.number.str[ie_len] = 0; 08919 } 08920 break; 08921 case AST_REDIRECTING_TO_NUMBER_PLAN: 08922 if (ie_len != 1) { 08923 ast_log(LOG_WARNING, "Invalid redirecting-to numbering plan (%u)\n", 08924 (unsigned) ie_len); 08925 break; 08926 } 08927 redirecting->to.number.plan = data[pos]; 08928 break; 08929 case AST_REDIRECTING_TO_NUMBER_PRESENTATION: 08930 if (ie_len != 1) { 08931 ast_log(LOG_WARNING, "Invalid redirecting-to number presentation (%u)\n", 08932 (unsigned) ie_len); 08933 break; 08934 } 08935 redirecting->to.number.presentation = data[pos]; 08936 break; 08937 case AST_REDIRECTING_TO_NUMBER_VALID: 08938 if (ie_len != 1) { 08939 ast_log(LOG_WARNING, "Invalid redirecting-to number valid (%u)\n", 08940 (unsigned) ie_len); 08941 break; 08942 } 08943 redirecting->to.number.valid = data[pos]; 08944 break; 08945 /* Redirecting-to party id combined presentation */ 08946 case AST_REDIRECTING_TO_ID_PRESENTATION: 08947 if (ie_len != 1) { 08948 ast_log(LOG_WARNING, "Invalid redirecting-to combined presentation (%u)\n", 08949 (unsigned) ie_len); 08950 break; 08951 } 08952 to_combined_presentation = data[pos]; 08953 got_to_combined_presentation = 1; 08954 break; 08955 /* Redirecting-to party id subaddress */ 08956 case AST_REDIRECTING_TO_SUBADDRESS: 08957 ast_free(redirecting->to.subaddress.str); 08958 redirecting->to.subaddress.str = ast_malloc(ie_len + 1); 08959 if (redirecting->to.subaddress.str) { 08960 memcpy(redirecting->to.subaddress.str, data + pos, ie_len); 08961 redirecting->to.subaddress.str[ie_len] = 0; 08962 } 08963 break; 08964 case AST_REDIRECTING_TO_SUBADDRESS_TYPE: 08965 if (ie_len != 1) { 08966 ast_log(LOG_WARNING, "Invalid redirecting-to type of subaddress (%u)\n", 08967 (unsigned) ie_len); 08968 break; 08969 } 08970 redirecting->to.subaddress.type = data[pos]; 08971 break; 08972 case AST_REDIRECTING_TO_SUBADDRESS_ODD_EVEN: 08973 if (ie_len != 1) { 08974 ast_log(LOG_WARNING, 08975 "Invalid redirecting-to subaddress odd-even indicator (%u)\n", 08976 (unsigned) ie_len); 08977 break; 08978 } 08979 redirecting->to.subaddress.odd_even_indicator = data[pos]; 08980 break; 08981 case AST_REDIRECTING_TO_SUBADDRESS_VALID: 08982 if (ie_len != 1) { 08983 ast_log(LOG_WARNING, "Invalid redirecting-to subaddress valid (%u)\n", 08984 (unsigned) ie_len); 08985 break; 08986 } 08987 redirecting->to.subaddress.valid = data[pos]; 08988 break; 08989 /* Redirecting-to party id tag */ 08990 case AST_REDIRECTING_TO_TAG: 08991 ast_free(redirecting->to.tag); 08992 redirecting->to.tag = ast_malloc(ie_len + 1); 08993 if (redirecting->to.tag) { 08994 memcpy(redirecting->to.tag, data + pos, ie_len); 08995 redirecting->to.tag[ie_len] = 0; 08996 } 08997 break; 08998 /* Redirecting reason */ 08999 case AST_REDIRECTING_REASON: 09000 if (ie_len != sizeof(value)) { 09001 ast_log(LOG_WARNING, "Invalid redirecting reason (%u)\n", 09002 (unsigned) ie_len); 09003 break; 09004 } 09005 memcpy(&value, data + pos, sizeof(value)); 09006 redirecting->reason = ntohl(value); 09007 break; 09008 /* Redirecting count */ 09009 case AST_REDIRECTING_COUNT: 09010 if (ie_len != sizeof(value)) { 09011 ast_log(LOG_WARNING, "Invalid redirecting count (%u)\n", 09012 (unsigned) ie_len); 09013 break; 09014 } 09015 memcpy(&value, data + pos, sizeof(value)); 09016 redirecting->count = ntohl(value); 09017 break; 09018 /* Redirecting unknown element */ 09019 default: 09020 ast_log(LOG_DEBUG, "Unknown redirecting element: %u (%u)\n", 09021 (unsigned) ie_id, (unsigned) ie_len); 09022 break; 09023 } 09024 } 09025 09026 switch (frame_version) { 09027 case 1: 09028 /* 09029 * The other end is an earlier version that we need to adjust 09030 * for compatibility. 09031 */ 09032 redirecting->from.name.valid = 1; 09033 redirecting->from.name.char_set = AST_PARTY_CHAR_SET_ISO8859_1; 09034 redirecting->from.number.valid = 1; 09035 if (got_from_combined_presentation) { 09036 redirecting->from.name.presentation = from_combined_presentation; 09037 redirecting->from.number.presentation = from_combined_presentation; 09038 } 09039 09040 redirecting->to.name.valid = 1; 09041 redirecting->to.name.char_set = AST_PARTY_CHAR_SET_ISO8859_1; 09042 redirecting->to.number.valid = 1; 09043 if (got_to_combined_presentation) { 09044 redirecting->to.name.presentation = to_combined_presentation; 09045 redirecting->to.number.presentation = to_combined_presentation; 09046 } 09047 break; 09048 case 2: 09049 /* The other end is at the same level as we are. */ 09050 break; 09051 default: 09052 /* 09053 * The other end is newer than we are. 09054 * We need to assume that they are compatible with us. 09055 */ 09056 ast_log(LOG_DEBUG, "Redirecting frame has newer version: %u\n", 09057 (unsigned) frame_version); 09058 break; 09059 } 09060 09061 return 0; 09062 }
struct ast_channel* ast_request | ( | const char * | type, | |
format_t | format, | |||
const struct ast_channel * | requestor, | |||
void * | data, | |||
int * | status | |||
) |
Requests a channel.
type | type of channel to request | |
format | requested channel format (codec) | |
requestor | channel asking for data | |
data | data to pass to the channel requester | |
status | status |
NULL | failure | |
non-NULL | channel on success |
Definition at line 5385 of file channel.c.
References AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, AST_CAUSE_NOSUCHDRIVER, AST_CAUSE_NOTDEFINED, ast_channel_release(), AST_FORMAT_AUDIO_MASK, AST_FORMAT_TEXT_MASK, AST_FORMAT_VIDEO_MASK, ast_getformatname_multiple(), ast_log(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_translator_best_choice(), ast_channel_tech::capabilities, capabilities, chanlist::chan, chanlist::list, LOG_WARNING, ast_channel_tech::requester, set_security_requirements(), ast_channel::tech, and ast_channel_tech::type.
Referenced by __ast_request_and_dial(), ast_call_forward(), attempt_reconnect(), begin_dial_channel(), build_conf(), chanavail_exec(), conf_run(), connect_link(), dial_exec_full(), dial_transfer(), do_forward(), feature_request_and_dial(), findmeexec(), play_sound_file(), ring_entry(), rpt(), rpt_call(), rpt_exec(), and rpt_tele_thread().
05386 { 05387 struct chanlist *chan; 05388 struct ast_channel *c; 05389 format_t capabilities; 05390 format_t fmt; 05391 int res; 05392 int foo; 05393 format_t videoformat = format & AST_FORMAT_VIDEO_MASK; 05394 format_t textformat = format & AST_FORMAT_TEXT_MASK; 05395 05396 if (!cause) 05397 cause = &foo; 05398 *cause = AST_CAUSE_NOTDEFINED; 05399 05400 if (AST_RWLIST_RDLOCK(&backends)) { 05401 ast_log(LOG_WARNING, "Unable to lock technology backend list\n"); 05402 return NULL; 05403 } 05404 05405 AST_RWLIST_TRAVERSE(&backends, chan, list) { 05406 if (strcasecmp(type, chan->tech->type)) 05407 continue; 05408 05409 capabilities = chan->tech->capabilities; 05410 fmt = format & AST_FORMAT_AUDIO_MASK; 05411 if (fmt) { 05412 /* We have audio - is it possible to connect the various calls to each other? 05413 (Avoid this check for calls without audio, like text+video calls) 05414 */ 05415 res = ast_translator_best_choice(&fmt, &capabilities); 05416 if (res < 0) { 05417 char tmp1[256], tmp2[256]; 05418 ast_log(LOG_WARNING, "No translator path exists for channel type %s (native %s) to %s\n", type, 05419 ast_getformatname_multiple(tmp1, sizeof(tmp1), chan->tech->capabilities), 05420 ast_getformatname_multiple(tmp2, sizeof(tmp2), format)); 05421 *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL; 05422 AST_RWLIST_UNLOCK(&backends); 05423 return NULL; 05424 } 05425 } 05426 AST_RWLIST_UNLOCK(&backends); 05427 if (!chan->tech->requester) 05428 return NULL; 05429 05430 if (!(c = chan->tech->requester(type, capabilities | videoformat | textformat, requestor, data, cause))) 05431 return NULL; 05432 05433 if (set_security_requirements(requestor, c)) { 05434 ast_log(LOG_WARNING, "Setting security requirements failed\n"); 05435 c = ast_channel_release(c); 05436 *cause = AST_CAUSE_BEARERCAPABILITY_NOTAVAIL; 05437 return NULL; 05438 } 05439 05440 /* no need to generate a Newchannel event here; it is done in the channel_alloc call */ 05441 return c; 05442 } 05443 05444 ast_log(LOG_WARNING, "No channel type registered for '%s'\n", type); 05445 *cause = AST_CAUSE_NOSUCHDRIVER; 05446 AST_RWLIST_UNLOCK(&backends); 05447 05448 return NULL; 05449 }
struct ast_channel* ast_request_and_dial | ( | const char * | type, | |
format_t | format, | |||
const struct ast_channel * | requestor, | |||
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.
type | type of channel to request | |
format | requested channel format | |
requestor | channel asking for data | |
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) |
Definition at line 5340 of file channel.c.
References __ast_request_and_dial().
Referenced by ast_pbx_outgoing_exten(), and generic_recall().
05341 { 05342 return __ast_request_and_dial(type, format, requestor, data, timeout, outstate, cidnum, cidname, NULL); 05343 }
int ast_safe_sleep | ( | struct ast_channel * | chan, | |
int | ms | |||
) |
Wait for a specified amount of time, looking for hangups.
chan | channel to wait for | |
ms | length of time in milliseconds to sleep |
Definition at line 1822 of file channel.c.
References ast_safe_sleep_conditional(), and chanlist::chan.
Referenced by __analog_ss_thread(), alarmreceiver_exec(), analog_ss_thread(), ast_adsi_transmit_message_full(), ast_dtmf_stream(), ast_senddigit(), builtin_atxfer(), conf_run(), dictate_exec(), flash_exec(), function_ilink(), handle_callforward_button(), login_exec(), mgcp_ss(), milliwatt_exec(), misdn_check_l2l1(), old_milliwatt_exec(), park_call_exec(), parkcall_helper(), 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(), testclient_exec(), testserver_exec(), wait_for_hangup(), wait_interval(), wait_moh_exec(), waituntil_exec(), and zapateller_exec().
01823 { 01824 return ast_safe_sleep_conditional(chan, ms, NULL, NULL); 01825 }
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.
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 |
Definition at line 1755 of file channel.c.
References ast_channel_lock, ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), ast_channel_unlock, ast_frfree, ast_frisolate(), ast_is_deferrable_frame(), AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_HEAD_NOLOCK, AST_LIST_INSERT_HEAD, AST_LIST_REMOVE_HEAD, ast_opt_transmit_silence, ast_queue_frame_head(), ast_read(), ast_waitfor(), chanlist::chan, f, and ast_channel::generatordata.
Referenced by ast_safe_sleep(), and login_exec().
01756 { 01757 struct ast_frame *f; 01758 struct ast_silence_generator *silgen = NULL; 01759 int res = 0; 01760 AST_LIST_HEAD_NOLOCK(, ast_frame) deferred_frames; 01761 01762 AST_LIST_HEAD_INIT_NOLOCK(&deferred_frames); 01763 01764 /* If no other generator is present, start silencegen while waiting */ 01765 if (ast_opt_transmit_silence && !chan->generatordata) { 01766 silgen = ast_channel_start_silence_generator(chan); 01767 } 01768 01769 while (ms > 0) { 01770 struct ast_frame *dup_f = NULL; 01771 if (cond && ((*cond)(data) == 0)) { 01772 break; 01773 } 01774 ms = ast_waitfor(chan, ms); 01775 if (ms < 0) { 01776 res = -1; 01777 break; 01778 } 01779 if (ms > 0) { 01780 f = ast_read(chan); 01781 if (!f) { 01782 res = -1; 01783 break; 01784 } 01785 01786 if (!ast_is_deferrable_frame(f)) { 01787 ast_frfree(f); 01788 continue; 01789 } 01790 01791 if ((dup_f = ast_frisolate(f))) { 01792 if (dup_f != f) { 01793 ast_frfree(f); 01794 } 01795 AST_LIST_INSERT_HEAD(&deferred_frames, dup_f, frame_list); 01796 } 01797 } 01798 } 01799 01800 /* stop silgen if present */ 01801 if (silgen) { 01802 ast_channel_stop_silence_generator(chan, silgen); 01803 } 01804 01805 /* We need to free all the deferred frames, but we only need to 01806 * queue the deferred frames if there was no error and no 01807 * hangup was received 01808 */ 01809 ast_channel_lock(chan); 01810 while ((f = AST_LIST_REMOVE_HEAD(&deferred_frames, frame_list))) { 01811 if (!res) { 01812 ast_queue_frame_head(chan, f); 01813 } 01814 ast_frfree(f); 01815 } 01816 ast_channel_unlock(chan); 01817 01818 return res; 01819 }
int ast_say_character_str | ( | struct ast_channel * | chan, | |
const char * | str, | |||
const char * | ints, | |||
const char * | lang | |||
) |
Definition at line 7893 of file channel.c.
References ast_say_character_str_full.
Referenced by common_exec(), pbx_builtin_saycharacters(), play_mailbox_owner(), rpt_tele_thread(), saycharstr(), saynode(), and vmsayname_exec().
07895 { 07896 return ast_say_character_str_full(chan, str, ints, lang, -1, -1); 07897 }
int ast_say_digit_str | ( | struct ast_channel * | chan, | |
const char * | num, | |||
const char * | ints, | |||
const char * | lang | |||
) |
says digits of a string
chan | channel to act upon | |
num | string to speak | |
ints | which dtmf to interrupt on | |
lang | language to speak in |
0 | on succes | |
DTMF | if interrupted | |
-1 | on failure |
Definition at line 7887 of file channel.c.
References ast_say_digit_str_full.
Referenced by __analog_ss_thread(), forward_message(), invent_message(), mgcp_ss(), pbx_builtin_saydigits(), and play_message_callerid().
07889 { 07890 return ast_say_digit_str_full(chan, str, ints, lang, -1, -1); 07891 }
int ast_say_digits | ( | struct ast_channel * | chan, | |
int | num, | |||
const char * | ints, | |||
const char * | lang | |||
) |
says digits
chan | channel to act upon | |
num | number to speak | |
ints | which dtmf to interrupt on | |
lang | language to speak |
0 | on success | |
DTMF | if interrupted | |
-1 | on failure |
Definition at line 7881 of file channel.c.
References ast_say_digits_full().
Referenced by common_exec(), conf_exec(), conf_run(), park_call_full(), parkandannounce_exec(), and rpt_tele_thread().
07883 { 07884 return ast_say_digits_full(chan, num, ints, lang, -1, -1); 07885 }
int ast_say_digits_full | ( | struct ast_channel * | chan, | |
int | num, | |||
const char * | ints, | |||
const char * | lang, | |||
int | audiofd, | |||
int | ctrlfd | |||
) |
Definition at line 7905 of file channel.c.
References ast_say_digit_str_full.
Referenced by ast_say_digits(), ast_say_enumeration_full_da(), ast_say_enumeration_full_de(), ast_say_number_full_cs(), ast_say_number_full_da(), ast_say_number_full_de(), ast_say_number_full_en(), ast_say_number_full_en_GB(), ast_say_number_full_es(), ast_say_number_full_fr(), ast_say_number_full_he(), ast_say_number_full_hu(), ast_say_number_full_it(), ast_say_number_full_ka(), ast_say_number_full_nl(), ast_say_number_full_no(), ast_say_number_full_pt(), ast_say_number_full_ru(), ast_say_number_full_se(), ast_say_number_full_th(), ast_say_number_full_ur(), ast_say_number_full_vi(), ast_say_number_full_zh(), and say_init_mode().
07907 { 07908 char buf[256]; 07909 07910 snprintf(buf, sizeof(buf), "%d", num); 07911 07912 return ast_say_digit_str_full(chan, buf, ints, lang, audiofd, ctrlfd); 07913 }
int ast_say_enumeration | ( | struct ast_channel * | chan, | |
int | num, | |||
const char * | ints, | |||
const char * | lang, | |||
const char * | options | |||
) |
says an enumeration
chan | channel to say them enumeration on | |
num | number to say on the channel | |
ints | which dtmf to interrupt on | |
lang | language to speak the enumeration | |
options | set to 'f' for female, 'm' for male, 'c' for commune, 'n' for neuter, 'p' for plural |
0 | on success | |
DTMF | digit on interrupt | |
-1 | on failure |
Definition at line 7875 of file channel.c.
References ast_say_enumeration_full.
Referenced by ast_say_date_da(), ast_say_date_de(), ast_say_date_with_format_da(), ast_say_date_with_format_de(), ast_say_date_with_format_en(), ast_say_date_with_format_pl(), and ast_say_date_with_format_vi().
07877 { 07878 return ast_say_enumeration_full(chan, num, ints, language, options, -1, -1); 07879 }
int ast_say_number | ( | struct ast_channel * | chan, | |
int | num, | |||
const char * | ints, | |||
const char * | lang, | |||
const char * | options | |||
) |
says a number
chan | channel to say them number on | |
num | number to say on the channel | |
ints | which dtmf to interrupt on | |
lang | language to speak the number | |
options | set to 'f' for female, 'm' for male, 'c' for commune, 'n' for neuter, 'p' for plural |
0 | on success | |
DTMF | digit on interrupt | |
-1 | on failure |
Definition at line 7869 of file channel.c.
References ast_say_number_full.
Referenced by announce_user_count(), ast_say_date_da(), ast_say_date_de(), ast_say_date_en(), ast_say_date_fr(), ast_say_date_gr(), ast_say_date_he(), ast_say_date_hu(), ast_say_date_ka(), ast_say_date_nl(), ast_say_date_pt(), ast_say_date_th(), ast_say_date_with_format_da(), ast_say_date_with_format_de(), ast_say_date_with_format_en(), ast_say_date_with_format_es(), ast_say_date_with_format_fr(), ast_say_date_with_format_it(), ast_say_date_with_format_nl(), ast_say_date_with_format_pl(), ast_say_date_with_format_pt(), ast_say_date_with_format_th(), ast_say_date_with_format_vi(), ast_say_datetime_en(), ast_say_datetime_fr(), ast_say_datetime_from_now_en(), ast_say_datetime_from_now_fr(), ast_say_datetime_from_now_he(), ast_say_datetime_from_now_ka(), ast_say_datetime_from_now_pt(), ast_say_datetime_he(), ast_say_datetime_pt(), ast_say_datetime_th(), ast_say_datetime_zh(), ast_say_time_de(), ast_say_time_en(), ast_say_time_fr(), ast_say_time_gr(), ast_say_time_hu(), ast_say_time_ka(), ast_say_time_nl(), ast_say_time_pt(), ast_say_time_pt_BR(), ast_say_time_th(), ast_say_time_zh(), bridge_playfile(), conf_run(), count_exec(), dictate_exec(), get_folder(), gr_say_number_female(), pbx_builtin_saynumber(), play_message(), play_message_duration(), rpt_tele_thread(), say_and_wait(), say_position(), saynum(), vm_intro_gr(), vm_intro_he(), vm_intro_multilang(), vm_intro_pt(), and vm_intro_pt_BR().
07871 { 07872 return ast_say_number_full(chan, num, ints, language, options, -1, -1); 07873 }
int ast_say_phonetic_str | ( | struct ast_channel * | chan, | |
const char * | str, | |||
const char * | ints, | |||
const char * | lang | |||
) |
Definition at line 7899 of file channel.c.
References ast_say_phonetic_str_full.
Referenced by pbx_builtin_sayphonetic().
07901 { 07902 return ast_say_phonetic_str_full(chan, str, ints, lang, -1, -1); 07903 }
int ast_senddigit | ( | struct ast_channel * | chan, | |
char | digit, | |||
unsigned int | duration | |||
) |
Send a DTMF digit to a channel.
chan | channel to act upon | |
digit | the DTMF digit to send, encoded in ASCII | |
duration | the duration of the digit ending in ms |
Definition at line 4541 of file channel.c.
References AST_DEFAULT_EMULATE_DTMF_DURATION, ast_safe_sleep(), ast_senddigit_begin(), ast_senddigit_end(), chanlist::chan, 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().
04542 { 04543 if (chan->tech->send_digit_begin) { 04544 ast_senddigit_begin(chan, digit); 04545 ast_safe_sleep(chan, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION)); 04546 } 04547 04548 return ast_senddigit_end(chan, digit, (duration >= AST_DEFAULT_EMULATE_DTMF_DURATION ? duration : AST_DEFAULT_EMULATE_DTMF_DURATION)); 04549 }
int ast_senddigit_begin | ( | struct ast_channel * | chan, | |
char | digit | |||
) |
Send a DTMF digit to a channel.
chan | channel to act upon | |
digit | the DTMF digit to send, encoded in ASCII |
Definition at line 4483 of file channel.c.
References ast_debug, ast_playtones_start(), chanlist::chan, ast_channel::name, ast_channel_tech::send_digit_begin, and ast_channel::tech.
Referenced by agent_digit_begin(), ast_senddigit(), and ast_write().
04484 { 04485 /* Device does not support DTMF tones, lets fake 04486 * it by doing our own generation. */ 04487 static const char * const dtmf_tones[] = { 04488 "941+1336", /* 0 */ 04489 "697+1209", /* 1 */ 04490 "697+1336", /* 2 */ 04491 "697+1477", /* 3 */ 04492 "770+1209", /* 4 */ 04493 "770+1336", /* 5 */ 04494 "770+1477", /* 6 */ 04495 "852+1209", /* 7 */ 04496 "852+1336", /* 8 */ 04497 "852+1477", /* 9 */ 04498 "697+1633", /* A */ 04499 "770+1633", /* B */ 04500 "852+1633", /* C */ 04501 "941+1633", /* D */ 04502 "941+1209", /* * */ 04503 "941+1477" /* # */ 04504 }; 04505 04506 if (!chan->tech->send_digit_begin) 04507 return 0; 04508 04509 if (!chan->tech->send_digit_begin(chan, digit)) 04510 return 0; 04511 04512 if (digit >= '0' && digit <='9') 04513 ast_playtones_start(chan, 0, dtmf_tones[digit-'0'], 0); 04514 else if (digit >= 'A' && digit <= 'D') 04515 ast_playtones_start(chan, 0, dtmf_tones[digit-'A'+10], 0); 04516 else if (digit == '*') 04517 ast_playtones_start(chan, 0, dtmf_tones[14], 0); 04518 else if (digit == '#') 04519 ast_playtones_start(chan, 0, dtmf_tones[15], 0); 04520 else { 04521 /* not handled */ 04522 ast_debug(1, "Unable to generate DTMF tone '%c' for '%s'\n", digit, chan->name); 04523 } 04524 04525 return 0; 04526 }
int ast_senddigit_end | ( | struct ast_channel * | chan, | |
char | digit, | |||
unsigned int | duration | |||
) |
Send a DTMF digit to a channel.
chan | channel to act upon | |
digit | the DTMF digit to send, encoded in ASCII | |
duration | the duration of the digit ending in ms |
Definition at line 4528 of file channel.c.
References ast_playtones_stop(), chanlist::chan, ast_channel::generator, ast_channel_tech::send_digit_end, and ast_channel::tech.
Referenced by agent_digit_end(), ast_senddigit(), and ast_write().
04529 { 04530 int res = -1; 04531 04532 if (chan->tech->send_digit_end) 04533 res = chan->tech->send_digit_end(chan, digit, duration); 04534 04535 if (res && chan->generator) 04536 ast_playtones_stop(chan); 04537 04538 return 0; 04539 }
int ast_sendtext | ( | struct ast_channel * | chan, | |
const char * | text | |||
) |
Sends text to a channel.
chan | channel to act upon | |
text | string of text to send on the channel |
0 | on success | |
-1 | on failure |
Definition at line 4465 of file channel.c.
References ast_channel_lock, ast_channel_unlock, ast_check_hangup(), ast_clear_flag, AST_FLAG_BLOCKING, AST_FLAG_ZOMBIE, ast_test_flag, chanlist::chan, CHECK_BLOCKING, ast_channel_tech::send_text, and ast_channel::tech.
Referenced by action_sendtext(), agent_sendtext(), handle_sendtext(), send_newkey(), and sendtext_exec().
04466 { 04467 int res = 0; 04468 04469 ast_channel_lock(chan); 04470 /* Stop if we're a zombie or need a soft hangup */ 04471 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) { 04472 ast_channel_unlock(chan); 04473 return -1; 04474 } 04475 CHECK_BLOCKING(chan); 04476 if (chan->tech->send_text) 04477 res = chan->tech->send_text(chan, text); 04478 ast_clear_flag(chan, AST_FLAG_BLOCKING); 04479 ast_channel_unlock(chan); 04480 return res; 04481 }
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 and generate AMI event.
The channel does not need to be locked before calling this function.
Definition at line 6602 of file channel.c.
References ast_party_caller::ani, ast_cdr_setcid(), ast_channel_lock, ast_channel_unlock, ast_free, ast_strdup, ast_channel::caller, ast_channel::cdr, chanlist::chan, ast_party_caller::id, ast_party_id::name, ast_party_id::number, report_new_callerid(), ast_party_name::str, ast_party_number::str, ast_party_name::valid, and ast_party_number::valid.
Referenced by __analog_ss_thread(), __ast_request_and_dial(), analog_ss_thread(), ast_call_forward(), cb_events(), dial_exec_full(), do_forward(), findmeexec(), get_pai(), get_rpid(), handle_setcallerid(), mgcp_ss(), ring_entry(), rpt_exec(), skinny_newcall(), and socket_process().
06603 { 06604 ast_channel_lock(chan); 06605 06606 if (cid_num) { 06607 chan->caller.id.number.valid = 1; 06608 ast_free(chan->caller.id.number.str); 06609 chan->caller.id.number.str = ast_strdup(cid_num); 06610 } 06611 if (cid_name) { 06612 chan->caller.id.name.valid = 1; 06613 ast_free(chan->caller.id.name.str); 06614 chan->caller.id.name.str = ast_strdup(cid_name); 06615 } 06616 if (cid_ani) { 06617 chan->caller.ani.number.valid = 1; 06618 ast_free(chan->caller.ani.number.str); 06619 chan->caller.ani.number.str = ast_strdup(cid_ani); 06620 } 06621 if (chan->cdr) { 06622 ast_cdr_setcid(chan->cdr, chan); 06623 } 06624 06625 report_new_callerid(chan); 06626 06627 ast_channel_unlock(chan); 06628 }
void ast_set_hangupsource | ( | struct ast_channel * | chan, | |
const char * | source, | |||
int | force | |||
) |
Set the source of the hangup in this channel and it's bridge.
chan | channel to set the field on | |
source | a string describing the source of the hangup for this channel | |
force |
Definition at line 2664 of file channel.c.
References ast_bridged_channel(), ast_channel_lock, ast_channel_unlock, ast_string_field_set, ast_strlen_zero(), ast_channel::bridge, chanlist::chan, and ast_channel::hangupsource.
Referenced by __dahdi_exception(), func_channel_write_real(), handle_hangup(), handle_request_bye(), handle_request_cancel(), handle_response_invite(), pbx_builtin_hangup(), and set_hangup_source_and_cause().
02665 { 02666 struct ast_channel *bridge; 02667 02668 ast_channel_lock(chan); 02669 if (force || ast_strlen_zero(chan->hangupsource)) { 02670 ast_string_field_set(chan, hangupsource, source); 02671 } 02672 bridge = ast_bridged_channel(chan); 02673 ast_channel_unlock(chan); 02674 02675 if (bridge && (force || ast_strlen_zero(bridge->hangupsource))) { 02676 ast_channel_lock(bridge); 02677 ast_string_field_set(chan, hangupsource, source); 02678 ast_channel_unlock(bridge); 02679 } 02680 }
static void ast_set_owners_and_peers | ( | struct ast_channel * | chan1, | |
struct ast_channel * | chan2 | |||
) | [static] |
Definition at line 6083 of file channel.c.
References accountcode, ast_channel::accountcode, ast_log(), ast_string_field_set, ast_strlen_zero(), LOG_DEBUG, ast_channel::name, and ast_channel::peeraccount.
Referenced by ast_channel_bridge().
06085 { 06086 if (!ast_strlen_zero(chan1->accountcode) && ast_strlen_zero(chan2->peeraccount)) { 06087 ast_log(LOG_DEBUG, "setting peeraccount to %s for %s from data on channel %s\n", 06088 chan1->accountcode, chan2->name, chan1->name); 06089 ast_string_field_set(chan2, peeraccount, chan1->accountcode); 06090 } 06091 if (!ast_strlen_zero(chan2->accountcode) && ast_strlen_zero(chan1->peeraccount)) { 06092 ast_log(LOG_DEBUG, "setting peeraccount to %s for %s from data on channel %s\n", 06093 chan2->accountcode, chan1->name, chan2->name); 06094 ast_string_field_set(chan1, peeraccount, chan2->accountcode); 06095 } 06096 if (!ast_strlen_zero(chan1->peeraccount) && ast_strlen_zero(chan2->accountcode)) { 06097 ast_log(LOG_DEBUG, "setting accountcode to %s for %s from data on channel %s\n", 06098 chan1->peeraccount, chan2->name, chan1->name); 06099 ast_string_field_set(chan2, accountcode, chan1->peeraccount); 06100 } 06101 if (!ast_strlen_zero(chan2->peeraccount) && ast_strlen_zero(chan1->accountcode)) { 06102 ast_log(LOG_DEBUG, "setting accountcode to %s for %s from data on channel %s\n", 06103 chan2->peeraccount, chan1->name, chan2->name); 06104 ast_string_field_set(chan1, accountcode, chan2->peeraccount); 06105 } 06106 if (0 != strcmp(chan1->accountcode, chan2->peeraccount)) { 06107 ast_log(LOG_DEBUG, "changing peeraccount from %s to %s on %s to match channel %s\n", 06108 chan2->peeraccount, chan1->peeraccount, chan2->name, chan1->name); 06109 ast_string_field_set(chan2, peeraccount, chan1->accountcode); 06110 } 06111 if (0 != strcmp(chan2->accountcode, chan1->peeraccount)) { 06112 ast_log(LOG_DEBUG, "changing peeraccount from %s to %s on %s to match channel %s\n", 06113 chan1->peeraccount, chan2->peeraccount, chan1->name, chan2->name); 06114 ast_string_field_set(chan1, peeraccount, chan2->accountcode); 06115 } 06116 }
int ast_set_read_format | ( | struct ast_channel * | chan, | |
format_t | format | |||
) |
Sets read format on channel chan Set read format for channel to whichever component of "format" is best.
chan | channel to change | |
format | format to change to |
Definition at line 5052 of file channel.c.
References chanlist::chan, ast_channel::rawreadformat, ast_channel::readformat, ast_channel::readtrans, and set_format().
Referenced by __ast_play_and_record(), __oh323_update_info(), agent_call(), alarmreceiver_exec(), ast_adsi_transmit_message_full(), ast_channel_make_compatible_helper(), ast_do_masquerade(), attempt_reconnect(), background_detect_exec(), bridge_channel_join(), bridge_make_compatible(), build_conf(), conf_run(), connect_link(), dictate_exec(), do_waiting(), eagi_exec(), echo_exec(), generic_fax_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(), rpt(), rpt_exec(), setup_rtp_connection(), sip_rtp_read(), skinny_rtp_read(), socket_process(), speech_background(), transmit_audio(), and unistim_rtp_read().
05053 { 05054 return set_format(chan, fmt, &chan->rawreadformat, &chan->readformat, 05055 &chan->readtrans, 0); 05056 }
void ast_set_variables | ( | struct ast_channel * | chan, | |
struct ast_variable * | vars | |||
) |
adds a list of channel variables to a channel
chan | the channel | |
vars | a linked list of variables |
Definition at line 7756 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().
07757 { 07758 struct ast_variable *cur; 07759 07760 for (cur = vars; cur; cur = cur->next) 07761 pbx_builtin_setvar_helper(chan, cur->name, cur->value); 07762 }
int ast_set_write_format | ( | struct ast_channel * | chan, | |
format_t | format | |||
) |
Sets write format on channel chan Set write format for channel to whichever component of "format" is best.
chan | channel to change | |
format | new format for writing |
Definition at line 5058 of file channel.c.
References chanlist::chan, ast_channel::rawwriteformat, set_format(), ast_channel::writeformat, and ast_channel::writetrans.
Referenced by __oh323_update_info(), agent_call(), alarmreceiver_exec(), ast_adsi_transmit_message_full(), 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(), bridge_channel_join(), bridge_make_compatible(), build_conf(), chanspy_exec(), conf_run(), connect_link(), dahdiscan_exec(), echo_exec(), extenspy_exec(), generic_fax_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().
05059 { 05060 return set_format(chan, fmt, &chan->rawwriteformat, &chan->writeformat, 05061 &chan->writetrans, 1); 05062 }
int ast_setstate | ( | struct ast_channel * | chan, | |
enum ast_channel_state | state | |||
) |
Change the state of a channel.
Definition at line 6667 of file channel.c.
References ast_channel::_state, AST_CHANNEL_NAME, ast_copy_string(), AST_DEVICE_UNKNOWN, ast_devstate_changed_literal(), ast_manager_event, ast_state2str(), ast_channel::caller, chanlist::chan, EVENT_FLAG_CALL, ast_party_caller::id, ast_party_id::name, ast_channel::name, name, ast_party_id::number, S_COR, ast_party_name::str, ast_party_number::str, ast_channel::uniqueid, ast_party_name::valid, and ast_party_number::valid.
Referenced by __analog_handle_event(), __analog_ss_thread(), __ast_read(), __dahdi_exception(), __oh323_update_info(), agent_call(), alsa_answer(), analog_answer(), analog_call(), analog_exception(), analog_ss_thread(), 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(), local_queue_frame(), mgcp_answer(), mgcp_call(), mgcp_ss(), misdn_call(), misdn_indication(), my_set_waitingfordt(), nbs_call(), nbs_hangup(), oh323_answer(), oss_answer(), pbx_builtin_busy(), pbx_builtin_congestion(), phone_answer(), phone_call(), phone_exception(), phone_hangup(), phone_write(), pri_ss_thread(), release_chan(), release_chan_early(), sig_pri_answer(), sig_pri_call(), sig_pri_indicate(), sip_answer(), skinny_answer(), skinny_call(), skinny_newcall(), unistim_answer(), unistim_call(), unistim_new(), unistim_ss(), update_state(), usbradio_answer(), and usbradio_call().
06668 { 06669 int oldstate = chan->_state; 06670 char name[AST_CHANNEL_NAME], *dashptr; 06671 06672 if (oldstate == state) 06673 return 0; 06674 06675 ast_copy_string(name, chan->name, sizeof(name)); 06676 if ((dashptr = strrchr(name, '-'))) { 06677 *dashptr = '\0'; 06678 } 06679 06680 chan->_state = state; 06681 06682 /* We have to pass AST_DEVICE_UNKNOWN here because it is entirely possible that the channel driver 06683 * for this channel is using the callback method for device state. If we pass in an actual state here 06684 * we override what they are saying the state is and things go amuck. */ 06685 ast_devstate_changed_literal(AST_DEVICE_UNKNOWN, name); 06686 06687 /* setstate used to conditionally report Newchannel; this is no more */ 06688 ast_manager_event(chan, EVENT_FLAG_CALL, "Newstate", 06689 "Channel: %s\r\n" 06690 "ChannelState: %d\r\n" 06691 "ChannelStateDesc: %s\r\n" 06692 "CallerIDNum: %s\r\n" 06693 "CallerIDName: %s\r\n" 06694 "Uniqueid: %s\r\n", 06695 chan->name, chan->_state, ast_state2str(chan->_state), 06696 S_COR(chan->caller.id.number.valid, chan->caller.id.number.str, ""), 06697 S_COR(chan->caller.id.name.valid, chan->caller.id.name.str, ""), 06698 chan->uniqueid); 06699 06700 return 0; 06701 }
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.
c | channel | |
rate | number of timer ticks per second | |
func | callback function | |
data |
Definition at line 3406 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().
03407 { 03408 int res; 03409 unsigned int real_rate = rate, max_rate; 03410 03411 ast_channel_lock(c); 03412 03413 if (c->timingfd == -1) { 03414 ast_channel_unlock(c); 03415 return -1; 03416 } 03417 03418 if (!func) { 03419 rate = 0; 03420 data = NULL; 03421 } 03422 03423 if (rate && rate > (max_rate = ast_timer_get_max_rate(c->timer))) { 03424 real_rate = max_rate; 03425 } 03426 03427 ast_debug(1, "Scheduling timer at (%u requested / %u actual) timer ticks per second\n", rate, real_rate); 03428 03429 res = ast_timer_set_rate(c->timer, real_rate); 03430 03431 c->timingfunc = func; 03432 c->timingdata = data; 03433 03434 ast_channel_unlock(c); 03435 03436 return res; 03437 }
int ast_shutting_down | ( | void | ) |
Returns non-zero if Asterisk is being shut down.
Definition at line 795 of file channel.c.
Referenced by handle_request_options().
00796 { 00797 return shutting_down; 00798 }
int ast_softhangup | ( | struct ast_channel * | chan, | |
int | reason | |||
) |
Softly hangup up a channel.
chan | channel to be soft-hung-up | |
reason | an AST_SOFTHANGUP_* reason code |
Definition at line 2641 of file channel.c.
References ast_channel_lock, ast_channel_unlock, ast_softhangup_nolock(), and chanlist::chan.
Referenced by __analog_handle_event(), __ast_module_user_hangup_all(), __unload_module(), agent_hangup(), agent_logoff(), agent_read(), ast_channel_softhangup_cb(), ast_dial_join(), birdbath(), cc_generic_agent_stop_ringing(), conf_free(), connect_link(), dahdi_handle_event(), flush_telem(), function_ilink(), handle_hangup(), handle_link_data(), handle_softhangup(), login_exec(), manager_park(), mgcp_pktcgate_remove(), read_agent_config(), rpt(), rpt_call(), rpt_do_restart(), rpt_exec(), sla_handle_hold_event(), softhangup_exec(), start_spying(), startmon(), and unload_module().
02642 { 02643 int res; 02644 02645 ast_channel_lock(chan); 02646 res = ast_softhangup_nolock(chan, cause); 02647 ast_channel_unlock(chan); 02648 02649 return res; 02650 }
int ast_softhangup_nolock | ( | struct ast_channel * | chan, | |
int | reason | |||
) |
Softly hangup up a channel (no channel lock).
chan | channel to be soft-hung-up | |
reason | an AST_SOFTHANGUP_* reason code |
Definition at line 2628 of file channel.c.
References ast_channel::_softhangup, ast_debug, AST_FLAG_BLOCKING, ast_null_frame, ast_queue_frame(), ast_test_flag, ast_channel::blocker, chanlist::chan, and ast_channel::name.
Referenced by __analog_handle_event(), action_hangup(), ast_async_goto(), ast_softhangup(), attempt_transfer(), check_pendings(), check_rtp_timeout(), dahdi_softhangup_all(), oh323_indicate(), proc_session_timer(), sig_pri_indicate(), sip_indicate(), and skinny_indicate().
02629 { 02630 ast_debug(1, "Soft-Hanging up channel '%s'\n", chan->name); 02631 /* Inform channel driver that we need to be hung up, if it cares */ 02632 chan->_softhangup |= cause; 02633 ast_queue_frame(chan, &ast_null_frame); 02634 /* Interrupt any poll call or such */ 02635 if (ast_test_flag(chan, AST_FLAG_BLOCKING)) 02636 pthread_kill(chan->blocker, SIGURG); 02637 return 0; 02638 }
const char* ast_state2str | ( | enum ast_channel_state | state | ) |
Gives the string form of a given channel state.
Definition at line 937 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(), STATE2STR_BUFSIZE, and state2str_threadbuf.
Referenced by __ast_channel_alloc_ap(), action_coreshowchannels(), agent_hangup(), ast_channel_data_add_structure(), ast_do_masquerade(), ast_setstate(), attempt_transfer(), func_channel_read(), handle_chanlist(), handle_showchan(), local_attended_transfer(), mgcp_new(), serialize_showchan(), sip_hangup(), and update_connectedline().
00938 { 00939 char *buf; 00940 00941 switch (state) { 00942 case AST_STATE_DOWN: 00943 return "Down"; 00944 case AST_STATE_RESERVED: 00945 return "Rsrvd"; 00946 case AST_STATE_OFFHOOK: 00947 return "OffHook"; 00948 case AST_STATE_DIALING: 00949 return "Dialing"; 00950 case AST_STATE_RING: 00951 return "Ring"; 00952 case AST_STATE_RINGING: 00953 return "Ringing"; 00954 case AST_STATE_UP: 00955 return "Up"; 00956 case AST_STATE_BUSY: 00957 return "Busy"; 00958 case AST_STATE_DIALING_OFFHOOK: 00959 return "Dialing Offhook"; 00960 case AST_STATE_PRERING: 00961 return "Pre-ring"; 00962 default: 00963 if (!(buf = ast_threadstorage_get(&state2str_threadbuf, STATE2STR_BUFSIZE))) 00964 return "Unknown"; 00965 snprintf(buf, STATE2STR_BUFSIZE, "Unknown (%d)", state); 00966 return buf; 00967 } 00968 }
int ast_str2cause | ( | const char * | name | ) |
Convert the string form of a cause code to a number.
name | string form of the cause |
Definition at line 923 of file channel.c.
References ARRAY_LEN, and causes.
Referenced by pbx_builtin_hangup().
00924 { 00925 int x; 00926 00927 for (x = 0; x < ARRAY_LEN(causes); x++) 00928 if (!strncasecmp(causes[x].name, name, strlen(causes[x].name))) 00929 return causes[x].cause; 00930 00931 return -1; 00932 }
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 7476 of file channel.c.
References ast_frfree, ast_read(), ast_tonepair_start(), ast_waitfor(), f, and ast_channel::generatordata.
Referenced by zapateller_exec().
07477 { 07478 int res; 07479 07480 if ((res = ast_tonepair_start(chan, freq1, freq2, duration, vol))) 07481 return res; 07482 07483 /* Give us some wiggle room */ 07484 while (chan->generatordata && ast_waitfor(chan, 100) >= 0) { 07485 struct ast_frame *f = ast_read(chan); 07486 if (f) 07487 ast_frfree(f); 07488 else 07489 return -1; 07490 } 07491 return 0; 07492 }
int ast_tonepair_start | ( | struct ast_channel * | chan, | |
int | freq1, | |||
int | freq2, | |||
int | duration, | |||
int | vol | |||
) |
Start a tone going
Definition at line 7458 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().
07459 { 07460 struct tonepair_def d = { 0, }; 07461 07462 d.freq1 = freq1; 07463 d.freq2 = freq2; 07464 d.duration = duration; 07465 d.vol = (vol < 1) ? 8192 : vol; /* force invalid to 8192 */ 07466 if (ast_activate_generator(chan, &tonepair, &d)) 07467 return -1; 07468 return 0; 07469 }
void ast_tonepair_stop | ( | struct ast_channel * | chan | ) |
Stop a tone from playing
Definition at line 7471 of file channel.c.
References ast_deactivate_generator().
Referenced by sendnoise().
07472 { 07473 ast_deactivate_generator(chan); 07474 }
int ast_transfer | ( | struct ast_channel * | chan, | |
char * | dest | |||
) |
Transfer a channel (if supported).
Called by:
Definition at line 5478 of file channel.c.
References ast_channel_lock, ast_channel_unlock, ast_check_hangup(), AST_CONTROL_TRANSFER, AST_FLAG_ZOMBIE, AST_FRAME_CONTROL, ast_frfree, ast_read(), ast_test_flag, AST_TRANSFER_SUCCESS, ast_waitfor(), chanlist::chan, ast_channel::tech, and ast_channel_tech::transfer.
Referenced by transfer_exec().
05479 { 05480 int res = -1; 05481 05482 /* Stop if we're a zombie or need a soft hangup */ 05483 ast_channel_lock(chan); 05484 if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan)) { 05485 if (chan->tech->transfer) { 05486 res = chan->tech->transfer(chan, dest); 05487 if (!res) 05488 res = 1; 05489 } else 05490 res = 0; 05491 } 05492 ast_channel_unlock(chan); 05493 05494 if (res <= 0) { 05495 return res; 05496 } 05497 05498 for (;;) { 05499 struct ast_frame *fr; 05500 05501 res = ast_waitfor(chan, -1); 05502 05503 if (res < 0 || !(fr = ast_read(chan))) { 05504 res = -1; 05505 break; 05506 } 05507 05508 if (fr->frametype == AST_FRAME_CONTROL && fr->subclass.integer == AST_CONTROL_TRANSFER) { 05509 enum ast_control_transfer *message = fr->data.ptr; 05510 05511 if (*message == AST_TRANSFER_SUCCESS) { 05512 res = 1; 05513 } else { 05514 res = -1; 05515 } 05516 05517 ast_frfree(fr); 05518 break; 05519 } 05520 05521 ast_frfree(fr); 05522 } 05523 05524 return res; 05525 }
char* ast_transfercapability2str | ( | int | transfercapability | ) | const |
Gives the string form of a given transfer capability.
transfercapability | transfer capability to get the name of |
Definition at line 971 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 ast_channel_data_add_structure(), cb_events(), misdn_call(), oh323_call(), sig_pri_call(), and sig_pri_new_ast_channel().
00972 { 00973 switch (transfercapability) { 00974 case AST_TRANS_CAP_SPEECH: 00975 return "SPEECH"; 00976 case AST_TRANS_CAP_DIGITAL: 00977 return "DIGITAL"; 00978 case AST_TRANS_CAP_RESTRICTED_DIGITAL: 00979 return "RESTRICTED_DIGITAL"; 00980 case AST_TRANS_CAP_3_1K_AUDIO: 00981 return "3K1AUDIO"; 00982 case AST_TRANS_CAP_DIGITAL_W_TONES: 00983 return "DIGITAL_W_TONES"; 00984 case AST_TRANS_CAP_VIDEO: 00985 return "VIDEO"; 00986 default: 00987 return "UNKNOWN"; 00988 } 00989 }
void ast_uninstall_music_functions | ( | void | ) |
Definition at line 7539 of file channel.c.
References ast_moh_cleanup_ptr, ast_moh_start_ptr, and ast_moh_stop_ptr.
Referenced by unload_module().
07540 { 07541 ast_moh_start_ptr = NULL; 07542 ast_moh_stop_ptr = NULL; 07543 ast_moh_cleanup_ptr = NULL; 07544 }
int ast_waitfor | ( | struct ast_channel * | chan, | |
int | ms | |||
) |
Wait for input on a channel.
chan | channel to wait on | |
ms | length of time to wait on the channel |
< | 0 on failure | |
0 | if nothing ever arrived | |
the | # of ms remaining otherwise |
Definition at line 3390 of file channel.c.
References ast_waitfor_nandfds().
Referenced by __adsi_transmit_messages(), __analog_ss_thread(), __ast_answer(), __ast_play_and_record(), __ast_request_and_dial(), adsi_careful_send(), agent_ack_sleep(), analog_ss_thread(), ast_dtmf_stream(), ast_recvtext(), ast_safe_sleep_conditional(), ast_tonepair(), ast_transfer(), async_wait(), background_detect_exec(), channel_spy(), conf_flush(), dictate_exec(), disa_exec(), disable_t38(), 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(), receivefax_t38_init(), recordthread(), send_tone_burst(), send_waveform_to_channel(), sendfax_t38_init(), sendurl_exec(), speech_background(), transmit_audio(), transmit_t38(), wait_for_hangup(), waitforring_exec(), and waitstream_core().
03391 { 03392 int oldms = ms; /* -1 if no timeout */ 03393 03394 ast_waitfor_nandfds(&c, 1, NULL, 0, NULL, NULL, &ms); 03395 if ((ms < 0) && (oldms < 0)) 03396 ms = 0; 03397 return ms; 03398 }
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.
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 3385 of file channel.c.
References ast_waitfor_nandfds().
Referenced by ast_udptl_bridge(), autoservice_run(), dahdi_bridge(), dial_exec_full(), feature_request_and_dial(), generic_thread_loop(), misdn_bridge(), monitor_dial(), remote_bridge_loop(), rpt(), wait_for_answer(), and wait_for_winner().
03386 { 03387 return ast_waitfor_nandfds(c, n, NULL, 0, NULL, NULL, ms); 03388 }
int ast_waitfor_n_fd | ( | int * | fds, | |
int | n, | |||
int * | ms, | |||
int * | exception | |||
) |
Waits for input on an fd.
Definition at line 3026 of file channel.c.
References ast_waitfor_nandfds().
Referenced by dundi_lookup_internal(), dundi_precache_internal(), and softmix_bridge_thread().
03027 { 03028 int winner = -1; 03029 ast_waitfor_nandfds(NULL, 0, fds, n, exception, &winner, ms); 03030 return winner; 03031 }
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.
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 |
Definition at line 3038 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(), chanlist::chan, CHECK_BLOCKING, errno, and LOG_WARNING.
Referenced by ast_waitfor(), ast_waitfor_n(), ast_waitfor_n_fd(), ast_waitfordigit_full(), conf_run(), eivr_comm(), find_cache(), generic_fax_exec(), multiplexed_thread_function(), run_agi(), and waitstream_core().
03041 { 03042 struct timeval start = { 0 , 0 }; 03043 struct pollfd *pfds = NULL; 03044 int res; 03045 long rms; 03046 int x, y, max; 03047 int sz; 03048 struct timeval now = { 0, 0 }; 03049 struct timeval whentohangup = { 0, 0 }, diff; 03050 struct ast_channel *winner = NULL; 03051 struct fdmap { 03052 int chan; 03053 int fdno; 03054 } *fdmap = NULL; 03055 03056 if ((sz = n * AST_MAX_FDS + nfds)) { 03057 pfds = alloca(sizeof(*pfds) * sz); 03058 fdmap = alloca(sizeof(*fdmap) * sz); 03059 } 03060 03061 if (outfd) 03062 *outfd = -99999; 03063 if (exception) 03064 *exception = 0; 03065 03066 /* Perform any pending masquerades */ 03067 for (x = 0; x < n; x++) { 03068 if (c[x]->masq && ast_do_masquerade(c[x])) { 03069 ast_log(LOG_WARNING, "Masquerade failed\n"); 03070 *ms = -1; 03071 return NULL; 03072 } 03073 03074 ast_channel_lock(c[x]); 03075 if (!ast_tvzero(c[x]->whentohangup)) { 03076 if (ast_tvzero(whentohangup)) 03077 now = ast_tvnow(); 03078 diff = ast_tvsub(c[x]->whentohangup, now); 03079 if (diff.tv_sec < 0 || ast_tvzero(diff)) { 03080 /* Should already be hungup */ 03081 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT; 03082 ast_channel_unlock(c[x]); 03083 return c[x]; 03084 } 03085 if (ast_tvzero(whentohangup) || ast_tvcmp(diff, whentohangup) < 0) 03086 whentohangup = diff; 03087 } 03088 ast_channel_unlock(c[x]); 03089 } 03090 /* Wait full interval */ 03091 rms = *ms; 03092 /* INT_MAX, not LONG_MAX, because it matters on 64-bit */ 03093 if (!ast_tvzero(whentohangup) && whentohangup.tv_sec < INT_MAX / 1000) { 03094 rms = whentohangup.tv_sec * 1000 + whentohangup.tv_usec / 1000; /* timeout in milliseconds */ 03095 if (*ms >= 0 && *ms < rms) { /* original *ms still smaller */ 03096 rms = *ms; 03097 } 03098 } else if (!ast_tvzero(whentohangup) && rms < 0) { 03099 /* Tiny corner case... call would need to last >24 days */ 03100 rms = INT_MAX; 03101 } 03102 /* 03103 * Build the pollfd array, putting the channels' fds first, 03104 * followed by individual fds. Order is important because 03105 * individual fd's must have priority over channel fds. 03106 */ 03107 max = 0; 03108 for (x = 0; x < n; x++) { 03109 for (y = 0; y < AST_MAX_FDS; y++) { 03110 fdmap[max].fdno = y; /* fd y is linked to this pfds */ 03111 fdmap[max].chan = x; /* channel x is linked to this pfds */ 03112 max += ast_add_fd(&pfds[max], c[x]->fds[y]); 03113 } 03114 CHECK_BLOCKING(c[x]); 03115 } 03116 /* Add the individual fds */ 03117 for (x = 0; x < nfds; x++) { 03118 fdmap[max].chan = -1; 03119 max += ast_add_fd(&pfds[max], fds[x]); 03120 } 03121 03122 if (*ms > 0) 03123 start = ast_tvnow(); 03124 03125 if (sizeof(int) == 4) { /* XXX fix timeout > 600000 on linux x86-32 */ 03126 do { 03127 int kbrms = rms; 03128 if (kbrms > 600000) 03129 kbrms = 600000; 03130 res = ast_poll(pfds, max, kbrms); 03131 if (!res) 03132 rms -= kbrms; 03133 } while (!res && (rms > 0)); 03134 } else { 03135 res = ast_poll(pfds, max, rms); 03136 } 03137 for (x = 0; x < n; x++) 03138 ast_clear_flag(c[x], AST_FLAG_BLOCKING); 03139 if (res < 0) { /* Simulate a timeout if we were interrupted */ 03140 if (errno != EINTR) 03141 *ms = -1; 03142 return NULL; 03143 } 03144 if (!ast_tvzero(whentohangup)) { /* if we have a timeout, check who expired */ 03145 now = ast_tvnow(); 03146 for (x = 0; x < n; x++) { 03147 if (!ast_tvzero(c[x]->whentohangup) && ast_tvcmp(c[x]->whentohangup, now) <= 0) { 03148 c[x]->_softhangup |= AST_SOFTHANGUP_TIMEOUT; 03149 if (winner == NULL) 03150 winner = c[x]; 03151 } 03152 } 03153 } 03154 if (res == 0) { /* no fd ready, reset timeout and done */ 03155 *ms = 0; /* XXX use 0 since we may not have an exact timeout. */ 03156 return winner; 03157 } 03158 /* 03159 * Then check if any channel or fd has a pending event. 03160 * Remember to check channels first and fds last, as they 03161 * must have priority on setting 'winner' 03162 */ 03163 for (x = 0; x < max; x++) { 03164 res = pfds[x].revents; 03165 if (res == 0) 03166 continue; 03167 if (fdmap[x].chan >= 0) { /* this is a channel */ 03168 winner = c[fdmap[x].chan]; /* override previous winners */ 03169 if (res & POLLPRI) 03170 ast_set_flag(winner, AST_FLAG_EXCEPTION); 03171 else 03172 ast_clear_flag(winner, AST_FLAG_EXCEPTION); 03173 winner->fdno = fdmap[x].fdno; 03174 } else { /* this is an fd */ 03175 if (outfd) 03176 *outfd = pfds[x].fd; 03177 if (exception) 03178 *exception = (res & POLLPRI) ? -1 : 0; 03179 winner = NULL; 03180 } 03181 } 03182 if (*ms > 0) { 03183 *ms -= ast_tvdiff_ms(ast_tvnow(), start); 03184 if (*ms < 0) 03185 *ms = 0; 03186 } 03187 return winner; 03188 }
int ast_waitfordigit | ( | struct ast_channel * | c, | |
int | ms | |||
) |
Waits for a digit.
c | channel to wait for a digit on | |
ms | how many milliseconds to wait |
Definition at line 3401 of file channel.c.
References ast_waitfordigit_full().
Referenced by __analog_ss_thread(), _while_exec(), advanced_options(), analog_my_getsigstr(), analog_ss_thread(), ast_adsi_get_cpeid(), ast_adsi_get_cpeinfo(), ast_adsi_print(), ast_adsi_read_encoded_dtmf(), ast_adsi_transmit_message_full(), ast_app_dtget(), ast_control_streamfile(), ast_record_review(), bridge_channel_feature(), 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(), pri_ss_thread(), read_exec(), read_newoption(), readexten_exec(), retrydial_exec(), select_item_menu(), select_item_pause(), select_item_seq(), sendnoise(), testclient_exec(), testserver_exec(), vm_execmain(), vm_forwardoptions(), vm_instructions_en(), vm_options(), vm_tempgreeting(), and wait_a_bit().
03402 { 03403 return ast_waitfordigit_full(c, ms, -1, -1); 03404 }
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.
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 |
Definition at line 3439 of file channel.c.
References ast_check_hangup(), ast_clear_flag, AST_CONTROL_ANSWER, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_HANGUP, AST_CONTROL_REDIRECTING, AST_CONTROL_RINGING, AST_CONTROL_SRCCHANGE, 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(), errno, f, and LOG_WARNING.
Referenced by ast_readstring_full(), ast_waitfordigit(), handle_getoption(), and handle_waitfordigit().
03440 { 03441 /* Stop if we're a zombie or need a soft hangup */ 03442 if (ast_test_flag(c, AST_FLAG_ZOMBIE) || ast_check_hangup(c)) 03443 return -1; 03444 03445 /* Only look for the end of DTMF, don't bother with the beginning and don't emulate things */ 03446 ast_set_flag(c, AST_FLAG_END_DTMF_ONLY); 03447 03448 /* Wait for a digit, no more than ms milliseconds total. */ 03449 03450 while (ms) { 03451 struct ast_channel *rchan; 03452 int outfd=-1; 03453 03454 errno = 0; 03455 rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms); 03456 03457 if (!rchan && outfd < 0 && ms) { 03458 if (errno == 0 || errno == EINTR) 03459 continue; 03460 ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno)); 03461 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY); 03462 return -1; 03463 } else if (outfd > -1) { 03464 /* The FD we were watching has something waiting */ 03465 ast_log(LOG_WARNING, "The FD we were waiting for has something waiting. Waitfordigit returning numeric 1\n"); 03466 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY); 03467 return 1; 03468 } else if (rchan) { 03469 int res; 03470 struct ast_frame *f = ast_read(c); 03471 if (!f) 03472 return -1; 03473 03474 switch (f->frametype) { 03475 case AST_FRAME_DTMF_BEGIN: 03476 break; 03477 case AST_FRAME_DTMF_END: 03478 res = f->subclass.integer; 03479 ast_frfree(f); 03480 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY); 03481 return res; 03482 case AST_FRAME_CONTROL: 03483 switch (f->subclass.integer) { 03484 case AST_CONTROL_HANGUP: 03485 ast_frfree(f); 03486 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY); 03487 return -1; 03488 case AST_CONTROL_RINGING: 03489 case AST_CONTROL_ANSWER: 03490 case AST_CONTROL_SRCUPDATE: 03491 case AST_CONTROL_SRCCHANGE: 03492 case AST_CONTROL_CONNECTED_LINE: 03493 case AST_CONTROL_REDIRECTING: 03494 case -1: 03495 /* Unimportant */ 03496 break; 03497 default: 03498 ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", f->subclass.integer); 03499 break; 03500 } 03501 break; 03502 case AST_FRAME_VOICE: 03503 /* Write audio if appropriate */ 03504 if (audiofd > -1) { 03505 if (write(audiofd, f->data.ptr, f->datalen) < 0) { 03506 ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno)); 03507 } 03508 } 03509 default: 03510 /* Ignore */ 03511 break; 03512 } 03513 ast_frfree(f); 03514 } 03515 } 03516 03517 ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY); 03518 03519 return 0; /* Time is up */ 03520 }
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.
chan | destination channel of the frame | |
frame | frame that will be written |
Definition at line 4683 of file channel.c.
References ast_channel::_softhangup, apply_plc(), ast_audiohook_detach_list(), AST_AUDIOHOOK_DIRECTION_WRITE, ast_audiohook_write_list(), ast_audiohook_write_list_empty(), 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_rate(), AST_FORMAT_SLINEAR, 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_framehook_list_write_event(), ast_frfree, ast_frisolate(), AST_LIST_NEXT, ast_log(), AST_MONITOR_RUNNING, ast_opt_generic_plc, ast_seekstream(), ast_senddigit_begin(), ast_senddigit_end(), AST_SOFTHANGUP_DEV, ast_test_flag, ast_translate(), ast_writestream(), ast_channel::audiohooks, calc_monitor_jump(), chanlist::chan, CHECK_BLOCKING, ast_frame_subclass::codec, ast_frame::data, ast_frame::datalen, DEBUGCHAN_FLAG, f, ast_filestream::fmt, ast_format::format, ast_channel::fout, FRAMECOUNT_INC, ast_channel::framehooks, ast_frame::frametype, ast_channel::generatordata, ast_channel_tech::indicate, ast_channel::insmpl, ast_frame_subclass::integer, ast_frame::len, LOG_WARNING, ast_channel::masq, ast_channel::masqr, ast_channel::monitor, ast_channel::name, chanlist::next, ast_channel::outsmpl, ast_frame::ptr, ast_channel::rawwriteformat, ast_channel_monitor::read_stream, ast_frame::samples, SEEK_FORCECUR, send_dtmf_event(), ast_channel_tech::send_html, ast_channel_tech::send_text, ast_frame::src, 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_prod(), ast_readaudio_callback(), ast_readvideo_callback(), ast_udptl_bridge(), ast_write_video(), conf_queue_dtmf(), conf_run(), dahdi_bridge(), dictate_exec(), echo_exec(), fax_generator_generate(), feature_request_and_dial(), function_ilink(), gen_generate(), generic_fax_exec(), handle_jack_audio(), handle_link_data(), jb_get_and_deliver(), linear_generator(), milliwatt_generate(), misdn_bridge(), moh_files_generator(), moh_generate(), mp3_exec(), multiplexed_bridge_write(), NBScat_exec(), remote_bridge_loop(), rpt(), send_link_dtmf(), send_link_keyquery(), send_tone_burst(), send_usb_txt(), send_waveform_to_channel(), silence_generator_generate(), simple_bridge_write(), softmix_bridge_poke(), softmix_bridge_write(), spy_generate(), and t38_tx_packet_handler().
04684 { 04685 int res = -1; 04686 struct ast_frame *f = NULL; 04687 int count = 0; 04688 04689 /*Deadlock avoidance*/ 04690 while(ast_channel_trylock(chan)) { 04691 /*cannot goto done since the channel is not locked*/ 04692 if(count++ > 10) { 04693 ast_debug(1, "Deadlock avoided for write to channel '%s'\n", chan->name); 04694 return 0; 04695 } 04696 usleep(1); 04697 } 04698 /* Stop if we're a zombie or need a soft hangup */ 04699 if (ast_test_flag(chan, AST_FLAG_ZOMBIE) || ast_check_hangup(chan)) 04700 goto done; 04701 04702 /* Handle any pending masquerades */ 04703 if (chan->masq) { 04704 ast_channel_unlock(chan); 04705 if (ast_do_masquerade(chan)) { 04706 ast_log(LOG_WARNING, "Failed to perform masquerade\n"); 04707 return res; /* no need to goto done: chan is already unlocked for masq */ 04708 } 04709 ast_channel_lock(chan); 04710 } 04711 if (chan->masqr) { 04712 res = 0; /* XXX explain, why 0 ? */ 04713 goto done; 04714 } 04715 04716 /* Perform the framehook write event here. After the frame enters the framehook list 04717 * there is no telling what will happen, how awesome is that!!! */ 04718 if (!(fr = ast_framehook_list_write_event(chan->framehooks, fr))) { 04719 res = 0; 04720 goto done; 04721 } 04722 04723 if (chan->generatordata && (!fr->src || strcasecmp(fr->src, "ast_prod"))) { 04724 if (ast_test_flag(chan, AST_FLAG_WRITE_INT)) { 04725 ast_deactivate_generator(chan); 04726 } else { 04727 if (fr->frametype == AST_FRAME_DTMF_END) { 04728 /* There is a generator running while we're in the middle of a digit. 04729 * It's probably inband DTMF, so go ahead and pass it so it can 04730 * stop the generator */ 04731 ast_clear_flag(chan, AST_FLAG_BLOCKING); 04732 ast_channel_unlock(chan); 04733 res = ast_senddigit_end(chan, fr->subclass.integer, fr->len); 04734 ast_channel_lock(chan); 04735 CHECK_BLOCKING(chan); 04736 } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass.integer == AST_CONTROL_UNHOLD) { 04737 /* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */ 04738 res = (chan->tech->indicate == NULL) ? 0 : 04739 chan->tech->indicate(chan, fr->subclass.integer, fr->data.ptr, fr->datalen); 04740 } 04741 res = 0; /* XXX explain, why 0 ? */ 04742 goto done; 04743 } 04744 } 04745 /* High bit prints debugging */ 04746 if (chan->fout & DEBUGCHAN_FLAG) 04747 ast_frame_dump(chan->name, fr, ">>"); 04748 CHECK_BLOCKING(chan); 04749 switch (fr->frametype) { 04750 case AST_FRAME_CONTROL: 04751 res = (chan->tech->indicate == NULL) ? 0 : 04752 chan->tech->indicate(chan, fr->subclass.integer, fr->data.ptr, fr->datalen); 04753 break; 04754 case AST_FRAME_DTMF_BEGIN: 04755 if (chan->audiohooks) { 04756 struct ast_frame *old_frame = fr; 04757 fr = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr); 04758 if (old_frame != fr) 04759 f = fr; 04760 } 04761 send_dtmf_event(chan, "Sent", fr->subclass.integer, "Yes", "No"); 04762 ast_clear_flag(chan, AST_FLAG_BLOCKING); 04763 ast_channel_unlock(chan); 04764 res = ast_senddigit_begin(chan, fr->subclass.integer); 04765 ast_channel_lock(chan); 04766 CHECK_BLOCKING(chan); 04767 break; 04768 case AST_FRAME_DTMF_END: 04769 if (chan->audiohooks) { 04770 struct ast_frame *new_frame = fr; 04771 04772 new_frame = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, fr); 04773 if (new_frame != fr) { 04774 ast_frfree(new_frame); 04775 } 04776 } 04777 send_dtmf_event(chan, "Sent", fr->subclass.integer, "No", "Yes"); 04778 ast_clear_flag(chan, AST_FLAG_BLOCKING); 04779 ast_channel_unlock(chan); 04780 res = ast_senddigit_end(chan, fr->subclass.integer, fr->len); 04781 ast_channel_lock(chan); 04782 CHECK_BLOCKING(chan); 04783 break; 04784 case AST_FRAME_TEXT: 04785 if (fr->subclass.integer == AST_FORMAT_T140) { 04786 res = (chan->tech->write_text == NULL) ? 0 : 04787 chan->tech->write_text(chan, fr); 04788 } else { 04789 res = (chan->tech->send_text == NULL) ? 0 : 04790 chan->tech->send_text(chan, (char *) fr->data.ptr); 04791 } 04792 break; 04793 case AST_FRAME_HTML: 04794 res = (chan->tech->send_html == NULL) ? 0 : 04795 chan->tech->send_html(chan, fr->subclass.integer, (char *) fr->data.ptr, fr->datalen); 04796 break; 04797 case AST_FRAME_VIDEO: 04798 /* XXX Handle translation of video codecs one day XXX */ 04799 res = (chan->tech->write_video == NULL) ? 0 : 04800 chan->tech->write_video(chan, fr); 04801 break; 04802 case AST_FRAME_MODEM: 04803 res = (chan->tech->write == NULL) ? 0 : 04804 chan->tech->write(chan, fr); 04805 break; 04806 case AST_FRAME_VOICE: 04807 if (chan->tech->write == NULL) 04808 break; /*! \todo XXX should return 0 maybe ? */ 04809 04810 if (ast_opt_generic_plc && fr->subclass.codec == AST_FORMAT_SLINEAR) { 04811 apply_plc(chan, fr); 04812 } 04813 04814 /* If the frame is in the raw write format, then it's easy... just use the frame - otherwise we will have to translate */ 04815 if (fr->subclass.codec == chan->rawwriteformat) 04816 f = fr; 04817 else 04818 f = (chan->writetrans) ? ast_translate(chan->writetrans, fr, 0) : fr; 04819 04820 if (!f) { 04821 res = 0; 04822 break; 04823 } 04824 04825 if (chan->audiohooks) { 04826 struct ast_frame *prev = NULL, *new_frame, *cur, *dup; 04827 int freeoldlist = 0; 04828 04829 if (f != fr) { 04830 freeoldlist = 1; 04831 } 04832 04833 /* Since ast_audiohook_write may return a new frame, and the cur frame is 04834 * an item in a list of frames, create a new list adding each cur frame back to it 04835 * regardless if the cur frame changes or not. */ 04836 for (cur = f; cur; cur = AST_LIST_NEXT(cur, frame_list)) { 04837 new_frame = ast_audiohook_write_list(chan, chan->audiohooks, AST_AUDIOHOOK_DIRECTION_WRITE, cur); 04838 04839 /* if this frame is different than cur, preserve the end of the list, 04840 * free the old frames, and set cur to be the new frame */ 04841 if (new_frame != cur) { 04842 04843 /* doing an ast_frisolate here seems silly, but we are not guaranteed the new_frame 04844 * isn't part of local storage, meaning if ast_audiohook_write is called multiple 04845 * times it may override the previous frame we got from it unless we dup it */ 04846 if ((dup = ast_frisolate(new_frame))) { 04847 AST_LIST_NEXT(dup, frame_list) = AST_LIST_NEXT(cur, frame_list); 04848 if (freeoldlist) { 04849 AST_LIST_NEXT(cur, frame_list) = NULL; 04850 ast_frfree(cur); 04851 } 04852 if (new_frame != dup) { 04853 ast_frfree(new_frame); 04854 } 04855 cur = dup; 04856 } 04857 } 04858 04859 /* now, regardless if cur is new or not, add it to the new list, 04860 * if the new list has not started, cur will become the first item. */ 04861 if (prev) { 04862 AST_LIST_NEXT(prev, frame_list) = cur; 04863 } else { 04864 f = cur; /* set f to be the beginning of our new list */ 04865 } 04866 prev = cur; 04867 } 04868 } 04869 04870 /* If Monitor is running on this channel, then we have to write frames out there too */ 04871 /* the translator on chan->writetrans may have returned multiple frames 04872 from the single frame we passed in; if so, feed each one of them to the 04873 monitor */ 04874 if (chan->monitor && chan->monitor->write_stream) { 04875 struct ast_frame *cur; 04876 04877 for (cur = f; cur; cur = AST_LIST_NEXT(cur, frame_list)) { 04878 /* XXX must explain this code */ 04879 #ifndef MONITOR_CONSTANT_DELAY 04880 int jump = chan->insmpl - chan->outsmpl - 4 * cur->samples; 04881 if (jump >= 0) { 04882 jump = calc_monitor_jump((chan->insmpl - chan->outsmpl), ast_format_rate(f->subclass.codec), ast_format_rate(chan->monitor->read_stream->fmt->format)); 04883 if (ast_seekstream(chan->monitor->write_stream, jump, SEEK_FORCECUR) == -1) 04884 ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n"); 04885 chan->outsmpl += (chan->insmpl - chan->outsmpl) + cur->samples; 04886 } else { 04887 chan->outsmpl += cur->samples; 04888 } 04889 #else 04890 int jump = calc_monitor_jump((chan->insmpl - chan->outsmpl), ast_format_rate(f->subclass.codec), ast_format_rate(chan->monitor->read_stream->fmt->format)); 04891 if (jump - MONITOR_DELAY >= 0) { 04892 if (ast_seekstream(chan->monitor->write_stream, jump - cur->samples, SEEK_FORCECUR) == -1) 04893 ast_log(LOG_WARNING, "Failed to perform seek in monitoring write stream, synchronization between the files may be broken\n"); 04894 chan->outsmpl += chan->insmpl - chan->outsmpl; 04895 } else { 04896 chan->outsmpl += cur->samples; 04897 } 04898 #endif 04899 if (chan->monitor->state == AST_MONITOR_RUNNING) { 04900 if (ast_writestream(chan->monitor->write_stream, cur) < 0) 04901 ast_log(LOG_WARNING, "Failed to write data to channel monitor write stream\n"); 04902 } 04903 } 04904 } 04905 04906 /* the translator on chan->writetrans may have returned multiple frames 04907 from the single frame we passed in; if so, feed each one of them to the 04908 channel, freeing each one after it has been written */ 04909 if ((f != fr) && AST_LIST_NEXT(f, frame_list)) { 04910 struct ast_frame *cur, *next; 04911 unsigned int skip = 0; 04912 04913 for (cur = f, next = AST_LIST_NEXT(cur, frame_list); 04914 cur; 04915 cur = next, next = cur ? AST_LIST_NEXT(cur, frame_list) : NULL) { 04916 if (!skip) { 04917 if ((res = chan->tech->write(chan, cur)) < 0) { 04918 chan->_softhangup |= AST_SOFTHANGUP_DEV; 04919 skip = 1; 04920 } else if (next) { 04921 /* don't do this for the last frame in the list, 04922 as the code outside the loop will do it once 04923 */ 04924 chan->fout = FRAMECOUNT_INC(chan->fout); 04925 } 04926 } 04927 ast_frfree(cur); 04928 } 04929 04930 /* reset f so the code below doesn't attempt to free it */ 04931 f = NULL; 04932 } else { 04933 res = chan->tech->write(chan, f); 04934 } 04935 break; 04936 case AST_FRAME_NULL: 04937 case AST_FRAME_IAX: 04938 /* Ignore these */ 04939 res = 0; 04940 break; 04941 default: 04942 /* At this point, fr is the incoming frame and f is NULL. Channels do 04943 * not expect to get NULL as a frame pointer and will segfault. Hence, 04944 * we output the original frame passed in. */ 04945 res = chan->tech->write(chan, fr); 04946 break; 04947 } 04948 04949 if (f && f != fr) 04950 ast_frfree(f); 04951 ast_clear_flag(chan, AST_FLAG_BLOCKING); 04952 04953 /* Consider a write failure to force a soft hangup */ 04954 if (res < 0) { 04955 chan->_softhangup |= AST_SOFTHANGUP_DEV; 04956 } else { 04957 chan->fout = FRAMECOUNT_INC(chan->fout); 04958 } 04959 done: 04960 if (chan->audiohooks && ast_audiohook_write_list_empty(chan->audiohooks)) { 04961 /* The list gets recreated if audiohooks are added again later */ 04962 ast_audiohook_detach_list(chan->audiohooks); 04963 chan->audiohooks = NULL; 04964 } 04965 ast_channel_unlock(chan); 04966 return res; 04967 }
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.
chan | destination channel of the frame | |
frame | frame that will be written |
Definition at line 4568 of file channel.c.
References ast_write(), chanlist::chan, ast_channel::tech, and ast_channel_tech::write_video.
04569 { 04570 int res; 04571 if (!chan->tech->write_video) 04572 return 0; 04573 res = ast_write(chan, fr); 04574 if (!res) 04575 res = 1; 04576 return res; 04577 }
static void bridge_play_sounds | ( | struct ast_channel * | c0, | |
struct ast_channel * | c1 | |||
) | [static] |
Definition at line 7019 of file channel.c.
References ast_channel_lock, ast_channel_unlock, ast_strdupa, bridge_playfile(), pbx_builtin_getvar_helper(), and pbx_builtin_setvar_helper().
Referenced by ast_channel_bridge().
07020 { 07021 const char *s, *sound; 07022 07023 /* See if we need to play an audio file to any side of the bridge */ 07024 07025 ast_channel_lock(c0); 07026 if ((s = pbx_builtin_getvar_helper(c0, "BRIDGE_PLAY_SOUND"))) { 07027 sound = ast_strdupa(s); 07028 ast_channel_unlock(c0); 07029 bridge_playfile(c0, c1, sound, 0); 07030 pbx_builtin_setvar_helper(c0, "BRIDGE_PLAY_SOUND", NULL); 07031 } else { 07032 ast_channel_unlock(c0); 07033 } 07034 07035 ast_channel_lock(c1); 07036 if ((s = pbx_builtin_getvar_helper(c1, "BRIDGE_PLAY_SOUND"))) { 07037 sound = ast_strdupa(s); 07038 ast_channel_unlock(c1); 07039 bridge_playfile(c1, c0, sound, 0); 07040 pbx_builtin_setvar_helper(c1, "BRIDGE_PLAY_SOUND", NULL); 07041 } else { 07042 ast_channel_unlock(c1); 07043 } 07044 }
static void bridge_playfile | ( | struct ast_channel * | chan, | |
struct ast_channel * | peer, | |||
const char * | sound, | |||
int | remain | |||
) | [static] |
Definition at line 6713 of file channel.c.
References ast_autoservice_start(), ast_autoservice_stop(), AST_DIGIT_ANY, ast_say_number(), ast_stream_and_wait(), and chanlist::chan.
Referenced by ast_channel_bridge(), and bridge_play_sounds().
06714 { 06715 int min = 0, sec = 0, check; 06716 06717 check = ast_autoservice_start(peer); 06718 if (check) 06719 return; 06720 06721 if (remain > 0) { 06722 if (remain / 60 > 1) { 06723 min = remain / 60; 06724 sec = remain % 60; 06725 } else { 06726 sec = remain; 06727 } 06728 } 06729 06730 if (!strcmp(sound,"timeleft")) { /* Queue support */ 06731 ast_stream_and_wait(chan, "vm-youhave", ""); 06732 if (min) { 06733 ast_say_number(chan, min, AST_DIGIT_ANY, chan->language, NULL); 06734 ast_stream_and_wait(chan, "queue-minutes", ""); 06735 } 06736 if (sec) { 06737 ast_say_number(chan, sec, AST_DIGIT_ANY, chan->language, NULL); 06738 ast_stream_and_wait(chan, "queue-seconds", ""); 06739 } 06740 } else { 06741 ast_stream_and_wait(chan, sound, ""); 06742 } 06743 06744 ast_autoservice_stop(peer); 06745 }
static int calc_monitor_jump | ( | int | samples, | |
int | sample_rate, | |||
int | seek_rate | |||
) | [inline, static] |
calculates the number of samples to jump forward with in a monitor stream.
number | of samples to seek forward after rate conversion. |
Definition at line 3628 of file channel.c.
Referenced by __ast_read(), and ast_write().
03629 { 03630 int diff = sample_rate - seek_rate; 03631 03632 if (diff > 0) { 03633 samples = samples / (float) (sample_rate / seek_rate); 03634 } else if (diff < 0) { 03635 samples = samples * (float) (seek_rate / sample_rate); 03636 } 03637 03638 return samples; 03639 }
static void* channel_cc_params_copy | ( | void * | data | ) | [static] |
Definition at line 9169 of file channel.c.
References ast_cc_config_params_init, and ast_cc_copy_config_params().
09170 { 09171 const struct ast_cc_config_params *src = data; 09172 struct ast_cc_config_params *dest = ast_cc_config_params_init(); 09173 if (!dest) { 09174 return NULL; 09175 } 09176 ast_cc_copy_config_params(dest, src); 09177 return dest; 09178 }
static void channel_cc_params_destroy | ( | void * | data | ) | [static] |
Definition at line 9180 of file channel.c.
References ast_cc_config_params_destroy().
09181 { 09182 struct ast_cc_config_params *cc_params = data; 09183 ast_cc_config_params_destroy(cc_params); 09184 }
static void channel_data_add_flags | ( | struct ast_data * | tree, | |
struct ast_channel * | chan | |||
) | [static] |
Definition at line 268 of file channel.c.
References ast_data_add_bool(), AST_FLAG_ANSWERED_ELSEWHERE, AST_FLAG_BLOCKING, AST_FLAG_BRIDGE_HANGUP_DONT, AST_FLAG_BRIDGE_HANGUP_RUN, AST_FLAG_DEFER_DTMF, AST_FLAG_DISABLE_WORKAROUNDS, AST_FLAG_EMULATE_DTMF, AST_FLAG_END_DTMF_ONLY, AST_FLAG_EXCEPTION, AST_FLAG_IN_AUTOLOOP, AST_FLAG_IN_DTMF, AST_FLAG_MASQ_NOSTREAM, AST_FLAG_MOH, AST_FLAG_NBRIDGE, AST_FLAG_OUTGOING, AST_FLAG_SPYING, AST_FLAG_WRITE_INT, AST_FLAG_ZOMBIE, ast_test_flag, and chanlist::chan.
Referenced by ast_channel_data_add_structure().
00270 { 00271 ast_data_add_bool(tree, "DEFER_DTMF", ast_test_flag(chan, AST_FLAG_DEFER_DTMF)); 00272 ast_data_add_bool(tree, "WRITE_INT", ast_test_flag(chan, AST_FLAG_WRITE_INT)); 00273 ast_data_add_bool(tree, "BLOCKING", ast_test_flag(chan, AST_FLAG_BLOCKING)); 00274 ast_data_add_bool(tree, "ZOMBIE", ast_test_flag(chan, AST_FLAG_ZOMBIE)); 00275 ast_data_add_bool(tree, "EXCEPTION", ast_test_flag(chan, AST_FLAG_EXCEPTION)); 00276 ast_data_add_bool(tree, "MOH", ast_test_flag(chan, AST_FLAG_MOH)); 00277 ast_data_add_bool(tree, "SPYING", ast_test_flag(chan, AST_FLAG_SPYING)); 00278 ast_data_add_bool(tree, "NBRIDGE", ast_test_flag(chan, AST_FLAG_NBRIDGE)); 00279 ast_data_add_bool(tree, "IN_AUTOLOOP", ast_test_flag(chan, AST_FLAG_IN_AUTOLOOP)); 00280 ast_data_add_bool(tree, "OUTGOING", ast_test_flag(chan, AST_FLAG_OUTGOING)); 00281 ast_data_add_bool(tree, "IN_DTMF", ast_test_flag(chan, AST_FLAG_IN_DTMF)); 00282 ast_data_add_bool(tree, "EMULATE_DTMF", ast_test_flag(chan, AST_FLAG_EMULATE_DTMF)); 00283 ast_data_add_bool(tree, "END_DTMF_ONLY", ast_test_flag(chan, AST_FLAG_END_DTMF_ONLY)); 00284 ast_data_add_bool(tree, "ANSWERED_ELSEWHERE", ast_test_flag(chan, AST_FLAG_ANSWERED_ELSEWHERE)); 00285 ast_data_add_bool(tree, "MASQ_NOSTREAM", ast_test_flag(chan, AST_FLAG_MASQ_NOSTREAM)); 00286 ast_data_add_bool(tree, "BRIDGE_HANGUP_RUN", ast_test_flag(chan, AST_FLAG_BRIDGE_HANGUP_RUN)); 00287 ast_data_add_bool(tree, "BRIDGE_HANGUP_DONT", ast_test_flag(chan, AST_FLAG_BRIDGE_HANGUP_DONT)); 00288 ast_data_add_bool(tree, "DISABLE_WORKAROUNDS", ast_test_flag(chan, AST_FLAG_DISABLE_WORKAROUNDS)); 00289 }
static struct ast_channel_iterator* channel_iterator_search | ( | const char * | name, | |
size_t | name_len, | |||
const char * | exten, | |||
const char * | context | |||
) | [static] |
Definition at line 1567 of file channel.c.
References ao2_find, ast_calloc, ast_copy_string(), ast_free, ast_strlen_zero(), channels, ast_channel::context, ast_channel::exten, ast_channel::name, OBJ_MULTIPLE, and OBJ_POINTER.
Referenced by ast_channel_iterator_by_exten_new(), and ast_channel_iterator_by_name_new().
01570 { 01571 struct ast_channel_iterator *i; 01572 struct ast_channel tmp_chan = { 01573 .name = name, 01574 /* This is sort of a hack. Basically, we're using an arbitrary field 01575 * in ast_channel to pass the name_len for a prefix match. If this 01576 * gets changed, then the compare callback must be changed, too. */ 01577 .rings = name_len, 01578 }; 01579 01580 if (!(i = ast_calloc(1, sizeof(*i)))) { 01581 return NULL; 01582 } 01583 01584 if (exten) { 01585 ast_copy_string(tmp_chan.exten, exten, sizeof(tmp_chan.exten)); 01586 } 01587 01588 if (context) { 01589 ast_copy_string(tmp_chan.context, context, sizeof(tmp_chan.context)); 01590 } 01591 01592 if (!(i->active_iterator = ao2_find(channels, &tmp_chan, 01593 OBJ_MULTIPLE | ((!ast_strlen_zero(name) && (name_len == 0)) ? OBJ_POINTER : 0)))) { 01594 ast_free(i); 01595 return NULL; 01596 } 01597 01598 return i; 01599 }
const char* channelreloadreason2txt | ( | enum channelreloadreason | reason | ) |
Convert enum channelreloadreason to text string for manager event.
\ brief Convert channel reloadreason (ENUM) to text string for manager event
Definition at line 7844 of file channel.c.
References CHANNEL_CLI_RELOAD, CHANNEL_MODULE_LOAD, and CHANNEL_MODULE_RELOAD.
07845 { 07846 switch (reason) { 07847 case CHANNEL_MODULE_LOAD: 07848 return "LOAD (Channel module load)"; 07849 07850 case CHANNEL_MODULE_RELOAD: 07851 return "RELOAD (Channel module reload)"; 07852 07853 case CHANNEL_CLI_RELOAD: 07854 return "CLIRELOAD (Channel module reload by CLI command)"; 07855 07856 default: 07857 return "MANAGERRELOAD (Channel module reload by manager)"; 07858 } 07859 };
static void clone_variables | ( | struct ast_channel * | original, | |
struct ast_channel * | clonechan | |||
) | [static] |
Clone channel variables from 'clone' channel into 'original' channel.
All variables except those related to app_groupcount are cloned. Variables are actually _removed_ from 'clone' channel, presumably because it will subsequently be destroyed.
Definition at line 5945 of file channel.c.
References AST_LIST_APPEND_LIST, AST_LIST_FIRST, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_var_assign(), ast_var_t::entries, ast_var_t::name, ast_var_t::value, and ast_channel::varshead.
Referenced by ast_do_masquerade().
05946 { 05947 struct ast_var_t *current, *newvar; 05948 /* Append variables from clone channel into original channel */ 05949 /* XXX Is this always correct? We have to in order to keep MACROS working XXX */ 05950 if (AST_LIST_FIRST(&clonechan->varshead)) 05951 AST_LIST_APPEND_LIST(&original->varshead, &clonechan->varshead, entries); 05952 05953 /* then, dup the varshead list into the clone */ 05954 05955 AST_LIST_TRAVERSE(&original->varshead, current, entries) { 05956 newvar = ast_var_assign(current->name, current->value); 05957 if (newvar) 05958 AST_LIST_INSERT_TAIL(&clonechan->varshead, newvar, entries); 05959 } 05960 }
static char* complete_channeltypes | ( | struct ast_cli_args * | a | ) | [static] |
Definition at line 523 of file channel.c.
References AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strdup, chanlist::list, ast_cli_args::n, ast_cli_args::pos, chanlist::tech, ast_channel_tech::type, and ast_cli_args::word.
Referenced by handle_cli_core_show_channeltype().
00524 { 00525 struct chanlist *cl; 00526 int which = 0; 00527 int wordlen; 00528 char *ret = NULL; 00529 00530 if (a->pos != 3) 00531 return NULL; 00532 00533 wordlen = strlen(a->word); 00534 00535 AST_RWLIST_RDLOCK(&backends); 00536 AST_RWLIST_TRAVERSE(&backends, cl, list) { 00537 if (!strncasecmp(a->word, cl->tech->type, wordlen) && ++which > a->n) { 00538 ret = ast_strdup(cl->tech->type); 00539 break; 00540 } 00541 } 00542 AST_RWLIST_UNLOCK(&backends); 00543 00544 return ret; 00545 }
static int data_channels_provider_handler | ( | const struct ast_data_search * | search, | |
struct ast_data * | root | |||
) | [static] |
Definition at line 7603 of file channel.c.
References ast_channel_data_add_structure(), ast_channel_iterator_all_new(), ast_channel_iterator_destroy(), ast_channel_iterator_next(), ast_channel_lock, ast_channel_unlock, ast_channel_unref, ast_data_add_node(), ast_data_remove_node(), ast_data_search_match(), ast_log(), and LOG_ERROR.
07605 { 07606 struct ast_channel *c; 07607 struct ast_channel_iterator *iter = NULL; 07608 struct ast_data *data_channel; 07609 07610 for (iter = ast_channel_iterator_all_new(); 07611 iter && (c = ast_channel_iterator_next(iter)); ast_channel_unref(c)) { 07612 ast_channel_lock(c); 07613 07614 data_channel = ast_data_add_node(root, "channel"); 07615 if (!data_channel) { 07616 ast_channel_unlock(c); 07617 continue; 07618 } 07619 07620 if (ast_channel_data_add_structure(data_channel, c, 1) < 0) { 07621 ast_log(LOG_ERROR, "Unable to add channel structure for channel: %s\n", c->name); 07622 } 07623 07624 ast_channel_unlock(c); 07625 07626 if (!ast_data_search_match(search, data_channel)) { 07627 ast_data_remove_node(root, data_channel); 07628 } 07629 } 07630 if (iter) { 07631 ast_channel_iterator_destroy(iter); 07632 } 07633 07634 return 0; 07635 }
static int data_channeltypes_provider_handler | ( | const struct ast_data_search * | search, | |
struct ast_data * | data_root | |||
) | [static] |
Definition at line 7641 of file channel.c.
References ast_channel_tech::answer, ast_data_add_bool(), ast_data_add_codecs(), ast_data_add_node(), ast_data_add_str(), ast_data_remove_node(), ast_data_search_match(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_channel_tech::bridge, ast_channel_tech::bridged_channel, ast_channel_tech::call, ast_channel_tech::capabilities, ast_channel_tech::cc_callback, ast_channel_tech::description, ast_channel_tech::devicestate, ast_channel_tech::early_bridge, ast_channel_tech::exception, ast_channel_tech::fixup, ast_channel_tech::func_channel_read, ast_channel_tech::func_channel_write, ast_channel_tech::get_base_channel, ast_channel_tech::get_pvt_uniqueid, ast_channel_tech::hangup, ast_channel_tech::indicate, ast_channel_tech::queryoption, ast_channel_tech::read, ast_channel_tech::send_digit_begin, ast_channel_tech::send_digit_end, ast_channel_tech::send_html, ast_channel_tech::send_image, ast_channel_tech::send_text, ast_channel_tech::set_base_channel, ast_channel_tech::setoption, chanlist::tech, ast_channel_tech::transfer, ast_channel_tech::type, ast_channel_tech::write, ast_channel_tech::write_text, and ast_channel_tech::write_video.
07643 { 07644 struct chanlist *cl; 07645 struct ast_data *data_type; 07646 07647 AST_RWLIST_RDLOCK(&backends); 07648 AST_RWLIST_TRAVERSE(&backends, cl, list) { 07649 data_type = ast_data_add_node(data_root, "type"); 07650 if (!data_type) { 07651 continue; 07652 } 07653 ast_data_add_str(data_type, "name", cl->tech->type); 07654 ast_data_add_str(data_type, "description", cl->tech->description); 07655 ast_data_add_bool(data_type, "devicestate", cl->tech->devicestate ? 1 : 0); 07656 ast_data_add_bool(data_type, "indications", cl->tech->indicate ? 1 : 0); 07657 ast_data_add_bool(data_type, "transfer", cl->tech->transfer ? 1 : 0); 07658 ast_data_add_bool(data_type, "send_digit_begin", cl->tech->send_digit_begin ? 1 : 0); 07659 ast_data_add_bool(data_type, "send_digit_end", cl->tech->send_digit_end ? 1 : 0); 07660 ast_data_add_bool(data_type, "call", cl->tech->call ? 1 : 0); 07661 ast_data_add_bool(data_type, "hangup", cl->tech->hangup ? 1 : 0); 07662 ast_data_add_bool(data_type, "answer", cl->tech->answer ? 1 : 0); 07663 ast_data_add_bool(data_type, "read", cl->tech->read ? 1 : 0); 07664 ast_data_add_bool(data_type, "write", cl->tech->write ? 1 : 0); 07665 ast_data_add_bool(data_type, "send_text", cl->tech->send_text ? 1 : 0); 07666 ast_data_add_bool(data_type, "send_image", cl->tech->send_image ? 1 : 0); 07667 ast_data_add_bool(data_type, "send_html", cl->tech->send_html ? 1 : 0); 07668 ast_data_add_bool(data_type, "exception", cl->tech->exception ? 1 : 0); 07669 ast_data_add_bool(data_type, "bridge", cl->tech->bridge ? 1 : 0); 07670 ast_data_add_bool(data_type, "early_bridge", cl->tech->early_bridge ? 1 : 0); 07671 ast_data_add_bool(data_type, "fixup", cl->tech->fixup ? 1 : 0); 07672 ast_data_add_bool(data_type, "setoption", cl->tech->setoption ? 1 : 0); 07673 ast_data_add_bool(data_type, "queryoption", cl->tech->queryoption ? 1 : 0); 07674 ast_data_add_bool(data_type, "write_video", cl->tech->write_video ? 1 : 0); 07675 ast_data_add_bool(data_type, "write_text", cl->tech->write_text ? 1 : 0); 07676 ast_data_add_bool(data_type, "bridged_channel", cl->tech->bridged_channel ? 1 : 0); 07677 ast_data_add_bool(data_type, "func_channel_read", cl->tech->func_channel_read ? 1 : 0); 07678 ast_data_add_bool(data_type, "func_channel_write", cl->tech->func_channel_write ? 1 : 0); 07679 ast_data_add_bool(data_type, "get_base_channel", cl->tech->get_base_channel ? 1 : 0); 07680 ast_data_add_bool(data_type, "set_base_channel", cl->tech->set_base_channel ? 1 : 0); 07681 ast_data_add_bool(data_type, "get_pvt_uniqueid", cl->tech->get_pvt_uniqueid ? 1 : 0); 07682 ast_data_add_bool(data_type, "cc_callback", cl->tech->cc_callback ? 1 : 0); 07683 07684 ast_data_add_codecs(data_type, "capabilities", cl->tech->capabilities); 07685 07686 if (!ast_data_search_match(search, data_type)) { 07687 ast_data_remove_node(data_root, data_type); 07688 } 07689 } 07690 AST_RWLIST_UNLOCK(&backends); 07691 07692 return 0; 07693 }
static void free_translation | ( | struct ast_channel * | clonechan | ) | [static] |
Definition at line 2652 of file channel.c.
References ast_translator_free_path(), ast_channel::nativeformats, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel::readtrans, and ast_channel::writetrans.
Referenced by ast_do_masquerade(), and ast_hangup().
02653 { 02654 if (clonechan->writetrans) 02655 ast_translator_free_path(clonechan->writetrans); 02656 if (clonechan->readtrans) 02657 ast_translator_free_path(clonechan->readtrans); 02658 clonechan->writetrans = NULL; 02659 clonechan->readtrans = NULL; 02660 clonechan->rawwriteformat = clonechan->nativeformats; 02661 clonechan->rawreadformat = clonechan->nativeformats; 02662 }
static int generator_force | ( | const void * | data | ) | [static] |
Definition at line 2971 of file channel.c.
References ast_channel_lock, ast_channel_unlock, ast_deactivate_generator(), ast_debug, AST_FORMAT_AUDIO_MASK, ast_format_rate(), and chanlist::chan.
Referenced by ast_activate_generator(), and ast_read_generator_actions().
02972 { 02973 /* Called if generator doesn't have data */ 02974 void *tmp; 02975 int res; 02976 int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples) = NULL; 02977 struct ast_channel *chan = (struct ast_channel *)data; 02978 02979 ast_channel_lock(chan); 02980 tmp = chan->generatordata; 02981 chan->generatordata = NULL; 02982 if (chan->generator) 02983 generate = chan->generator->generate; 02984 ast_channel_unlock(chan); 02985 02986 if (!tmp || !generate) 02987 return 0; 02988 02989 res = generate(chan, tmp, 0, ast_format_rate(chan->writeformat & AST_FORMAT_AUDIO_MASK) / 50); 02990 02991 chan->generatordata = tmp; 02992 02993 if (res) { 02994 ast_debug(1, "Auto-deactivating generator\n"); 02995 ast_deactivate_generator(chan); 02996 } 02997 02998 return 0; 02999 }
static void handle_cause | ( | int | cause, | |
int * | outstate | |||
) | [static] |
Definition at line 5087 of file channel.c.
References AST_CAUSE_BUSY, AST_CAUSE_CONGESTION, AST_CONTROL_BUSY, and AST_CONTROL_CONGESTION.
05088 { 05089 if (outstate) { 05090 /* compute error and return */ 05091 if (cause == AST_CAUSE_BUSY) 05092 *outstate = AST_CONTROL_BUSY; 05093 else if (cause == AST_CAUSE_CONGESTION) 05094 *outstate = AST_CONTROL_CONGESTION; 05095 else 05096 *outstate = 0; 05097 } 05098 }
static char* handle_cli_core_show_channeltype | ( | struct ast_cli_entry * | e, | |
int | cmd, | |||
struct ast_cli_args * | a | |||
) | [static] |
Show details about a channel driver - CLI command.
Definition at line 548 of file channel.c.
References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_getformatname_multiple(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_channel_tech::capabilities, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_channeltypes(), ast_channel_tech::devicestate, ast_cli_args::fd, ast_channel_tech::indicate, chanlist::list, ast_channel_tech::send_digit_begin, ast_channel_tech::send_digit_end, ast_channel_tech::send_html, ast_channel_tech::send_image, ast_channel_tech::send_text, chanlist::tech, ast_channel_tech::transfer, ast_channel_tech::type, and ast_cli_entry::usage.
00549 { 00550 struct chanlist *cl = NULL; 00551 char buf[512]; 00552 00553 switch (cmd) { 00554 case CLI_INIT: 00555 e->command = "core show channeltype"; 00556 e->usage = 00557 "Usage: core show channeltype <name>\n" 00558 " Show details about the specified channel type, <name>.\n"; 00559 return NULL; 00560 case CLI_GENERATE: 00561 return complete_channeltypes(a); 00562 } 00563 00564 if (a->argc != 4) 00565 return CLI_SHOWUSAGE; 00566 00567 AST_RWLIST_RDLOCK(&backends); 00568 00569 AST_RWLIST_TRAVERSE(&backends, cl, list) { 00570 if (!strncasecmp(cl->tech->type, a->argv[3], strlen(cl->tech->type))) 00571 break; 00572 } 00573 00574 00575 if (!cl) { 00576 ast_cli(a->fd, "\n%s is not a registered channel driver.\n", a->argv[3]); 00577 AST_RWLIST_UNLOCK(&backends); 00578 return CLI_FAILURE; 00579 } 00580 00581 ast_cli(a->fd, 00582 "-- Info about channel driver: %s --\n" 00583 " Device State: %s\n" 00584 " Indication: %s\n" 00585 " Transfer : %s\n" 00586 " Capabilities: %s\n" 00587 " Digit Begin: %s\n" 00588 " Digit End: %s\n" 00589 " Send HTML : %s\n" 00590 " Image Support: %s\n" 00591 " Text Support: %s\n", 00592 cl->tech->type, 00593 (cl->tech->devicestate) ? "yes" : "no", 00594 (cl->tech->indicate) ? "yes" : "no", 00595 (cl->tech->transfer) ? "yes" : "no", 00596 ast_getformatname_multiple(buf, sizeof(buf), (cl->tech->capabilities) ? cl->tech->capabilities : -1), 00597 (cl->tech->send_digit_begin) ? "yes" : "no", 00598 (cl->tech->send_digit_end) ? "yes" : "no", 00599 (cl->tech->send_html) ? "yes" : "no", 00600 (cl->tech->send_image) ? "yes" : "no", 00601 (cl->tech->send_text) ? "yes" : "no" 00602 00603 ); 00604 00605 AST_RWLIST_UNLOCK(&backends); 00606 00607 return CLI_SUCCESS; 00608 }
static char* handle_cli_core_show_channeltypes | ( | struct ast_cli_entry * | e, | |
int | cmd, | |||
struct ast_cli_args * | a | |||
) | [static] |
Show channel types - CLI command.
Definition at line 482 of file channel.c.
References ast_cli_args::argc, ast_cli(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_channel_tech::description, ast_channel_tech::devicestate, ast_cli_args::fd, FORMAT, ast_channel_tech::indicate, chanlist::list, chanlist::tech, ast_channel_tech::transfer, ast_channel_tech::type, and ast_cli_entry::usage.
00483 { 00484 #define FORMAT "%-10.10s %-40.40s %-12.12s %-12.12s %-12.12s\n" 00485 struct chanlist *cl; 00486 int count_chan = 0; 00487 00488 switch (cmd) { 00489 case CLI_INIT: 00490 e->command = "core show channeltypes"; 00491 e->usage = 00492 "Usage: core show channeltypes\n" 00493 " Lists available channel types registered in your\n" 00494 " Asterisk server.\n"; 00495 return NULL; 00496 case CLI_GENERATE: 00497 return NULL; 00498 } 00499 00500 if (a->argc != 3) 00501 return CLI_SHOWUSAGE; 00502 00503 ast_cli(a->fd, FORMAT, "Type", "Description", "Devicestate", "Indications", "Transfer"); 00504 ast_cli(a->fd, FORMAT, "----------", "-----------", "-----------", "-----------", "--------"); 00505 00506 AST_RWLIST_RDLOCK(&backends); 00507 AST_RWLIST_TRAVERSE(&backends, cl, list) { 00508 ast_cli(a->fd, FORMAT, cl->tech->type, cl->tech->description, 00509 (cl->tech->devicestate) ? "yes" : "no", 00510 (cl->tech->indicate) ? "yes" : "no", 00511 (cl->tech->transfer) ? "yes" : "no"); 00512 count_chan++; 00513 } 00514 AST_RWLIST_UNLOCK(&backends); 00515 00516 ast_cli(a->fd, "----------\n%d channel drivers registered.\n", count_chan); 00517 00518 return CLI_SUCCESS; 00519 00520 #undef FORMAT 00521 }
static int attribute_const is_visible_indication | ( | enum ast_control_frame_type | condition | ) | [static] |
Definition at line 4189 of file channel.c.
References _XXX_AST_CONTROL_T38, AST_CONTROL_ANSWER, AST_CONTROL_AOC, AST_CONTROL_BUSY, AST_CONTROL_CC, AST_CONTROL_CONGESTION, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_END_OF_Q, 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_READ_ACTION, AST_CONTROL_REDIRECTING, AST_CONTROL_RING, AST_CONTROL_RINGING, AST_CONTROL_SRCCHANGE, AST_CONTROL_SRCUPDATE, AST_CONTROL_T38_PARAMETERS, AST_CONTROL_TAKEOFFHOOK, AST_CONTROL_TRANSFER, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, and AST_CONTROL_WINK.
Referenced by ast_indicate_data().
04190 { 04191 /* Don't include a default case here so that we get compiler warnings 04192 * when a new type is added. */ 04193 04194 switch (condition) { 04195 case AST_CONTROL_PROGRESS: 04196 case AST_CONTROL_PROCEEDING: 04197 case AST_CONTROL_VIDUPDATE: 04198 case AST_CONTROL_SRCUPDATE: 04199 case AST_CONTROL_SRCCHANGE: 04200 case AST_CONTROL_RADIO_KEY: 04201 case AST_CONTROL_RADIO_UNKEY: 04202 case AST_CONTROL_OPTION: 04203 case AST_CONTROL_WINK: 04204 case AST_CONTROL_FLASH: 04205 case AST_CONTROL_OFFHOOK: 04206 case AST_CONTROL_TAKEOFFHOOK: 04207 case AST_CONTROL_ANSWER: 04208 case AST_CONTROL_HANGUP: 04209 case AST_CONTROL_CONNECTED_LINE: 04210 case AST_CONTROL_REDIRECTING: 04211 case AST_CONTROL_TRANSFER: 04212 case AST_CONTROL_T38_PARAMETERS: 04213 case _XXX_AST_CONTROL_T38: 04214 case AST_CONTROL_CC: 04215 case AST_CONTROL_READ_ACTION: 04216 case AST_CONTROL_AOC: 04217 case AST_CONTROL_END_OF_Q: 04218 break; 04219 04220 case AST_CONTROL_CONGESTION: 04221 case AST_CONTROL_BUSY: 04222 case AST_CONTROL_RINGING: 04223 case AST_CONTROL_RING: 04224 case AST_CONTROL_HOLD: 04225 /* You can hear these */ 04226 return 1; 04227 04228 case AST_CONTROL_UNHOLD: 04229 /* This is a special case. You stop hearing this. */ 04230 break; 04231 } 04232 04233 return 0; 04234 }
static void manager_bridge_event | ( | int | onoff, | |
int | type, | |||
struct ast_channel * | c0, | |||
struct ast_channel * | c1 | |||
) | [static] |
Send manager event for bridge link and unlink events.
onoff | Link/Unlinked | |
type | 1 for core, 2 for native | |
c0 | first channel in bridge | |
c1 | second channel in bridge |
Definition at line 6962 of file channel.c.
References ast_manager_event_multichan, ast_channel::caller, EVENT_FLAG_CALL, ast_party_caller::id, ast_channel::name, ast_party_id::number, S_COR, ast_party_number::str, ast_channel::uniqueid, and ast_party_number::valid.
Referenced by ast_channel_bridge().
06963 { 06964 struct ast_channel *chans[2] = { c0, c1 }; 06965 ast_manager_event_multichan(EVENT_FLAG_CALL, "Bridge", 2, chans, 06966 "Bridgestate: %s\r\n" 06967 "Bridgetype: %s\r\n" 06968 "Channel1: %s\r\n" 06969 "Channel2: %s\r\n" 06970 "Uniqueid1: %s\r\n" 06971 "Uniqueid2: %s\r\n" 06972 "CallerID1: %s\r\n" 06973 "CallerID2: %s\r\n", 06974 onoff ? "Link" : "Unlink", 06975 type == 1 ? "core" : "native", 06976 c0->name, c1->name, 06977 c0->uniqueid, c1->uniqueid, 06978 S_COR(c0->caller.id.number.valid, c0->caller.id.number.str, ""), 06979 S_COR(c1->caller.id.number.valid, c1->caller.id.number.str, "")); 06980 }
static void masquerade_colp_transfer | ( | struct ast_channel * | transferee, | |
struct xfer_masquerade_ds * | colp | |||
) | [static] |
Definition at line 6151 of file channel.c.
References ast_channel_queue_connected_line_update(), ast_connected_line_build_data(), AST_CONTROL_READ_ACTION, AST_CONTROL_UNHOLD, AST_FRAME_READ_ACTION_CONNECTED_LINE_MACRO, ast_queue_control(), ast_queue_control_data(), frame_size, ast_control_read_action_payload::payload_size, xfer_masquerade_ds::target_held, xfer_masquerade_ds::target_id, and xfer_masquerade_ds::transferee_id.
Referenced by ast_do_masquerade().
06152 { 06153 struct ast_control_read_action_payload *frame_payload; 06154 int payload_size; 06155 int frame_size; 06156 unsigned char connected_line_data[1024]; 06157 06158 /* Release any hold on the target. */ 06159 if (colp->target_held) { 06160 ast_queue_control(transferee, AST_CONTROL_UNHOLD); 06161 } 06162 06163 /* 06164 * Since transferee may not actually be bridged to another channel, 06165 * there is no way for us to queue a frame so that its connected 06166 * line status will be updated. Instead, we use the somewhat 06167 * hackish approach of using a special control frame type that 06168 * instructs ast_read() to perform a specific action. In this 06169 * case, the frame we queue tells ast_read() to call the 06170 * connected line interception macro configured for transferee. 06171 */ 06172 payload_size = ast_connected_line_build_data(connected_line_data, 06173 sizeof(connected_line_data), &colp->target_id, NULL); 06174 if (payload_size != -1) { 06175 frame_size = payload_size + sizeof(*frame_payload); 06176 frame_payload = alloca(frame_size); 06177 frame_payload->action = AST_FRAME_READ_ACTION_CONNECTED_LINE_MACRO; 06178 frame_payload->payload_size = payload_size; 06179 memcpy(frame_payload->payload, connected_line_data, payload_size); 06180 ast_queue_control_data(transferee, AST_CONTROL_READ_ACTION, frame_payload, 06181 frame_size); 06182 } 06183 /* 06184 * In addition to queueing the read action frame so that the 06185 * connected line info on transferee will be updated, we also are 06186 * going to queue a plain old connected line update on transferee to 06187 * update the target. 06188 */ 06189 ast_channel_queue_connected_line_update(transferee, &colp->transferee_id, NULL); 06190 }
static const char* oldest_linkedid | ( | const char * | a, | |
const char * | b | |||
) | [static] |
Definition at line 5975 of file channel.c.
References ast_strlen_zero().
Referenced by ast_channel_set_linkgroup().
05976 { 05977 const char *satime, *saseq; 05978 const char *sbtime, *sbseq; 05979 const char *dash; 05980 05981 unsigned int atime, aseq, btime, bseq; 05982 05983 if (ast_strlen_zero(a)) 05984 return b; 05985 05986 if (ast_strlen_zero(b)) 05987 return a; 05988 05989 satime = a; 05990 sbtime = b; 05991 05992 /* jump over the system name */ 05993 if ((dash = strrchr(satime, '-'))) { 05994 satime = dash+1; 05995 } 05996 if ((dash = strrchr(sbtime, '-'))) { 05997 sbtime = dash+1; 05998 } 05999 06000 /* the sequence comes after the '.' */ 06001 saseq = strchr(satime, '.'); 06002 sbseq = strchr(sbtime, '.'); 06003 if (!saseq || !sbseq) 06004 return NULL; 06005 saseq++; 06006 sbseq++; 06007 06008 /* convert it all to integers */ 06009 atime = atoi(satime); /* note that atoi is ignoring the '.' after the time string */ 06010 btime = atoi(sbtime); /* note that atoi is ignoring the '.' after the time string */ 06011 aseq = atoi(saseq); 06012 bseq = atoi(sbseq); 06013 06014 /* and finally compare */ 06015 if (atime == btime) { 06016 return (aseq < bseq) ? a : b; 06017 } 06018 else { 06019 return (atime < btime) ? a : b; 06020 } 06021 }
static void party_connected_line_copy_transfer | ( | struct ast_party_connected_line * | dest, | |
const struct ast_party_connected_line * | src | |||
) | [static] |
Definition at line 5782 of file channel.c.
References AST_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER, ast_party_connected_line_copy(), chanlist::connected, and ast_party_connected_line::source.
Referenced by ast_channel_transfer_masquerade().
05783 { 05784 struct ast_party_connected_line connected; 05785 05786 connected = *((struct ast_party_connected_line *) src); 05787 connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER; 05788 05789 /* Make sure empty strings will be erased. */ 05790 if (!connected.id.name.str) { 05791 connected.id.name.str = ""; 05792 } 05793 if (!connected.id.number.str) { 05794 connected.id.number.str = ""; 05795 } 05796 if (!connected.id.subaddress.str) { 05797 connected.id.subaddress.str = ""; 05798 } 05799 if (!connected.id.tag) { 05800 connected.id.tag = ""; 05801 } 05802 05803 ast_party_connected_line_copy(dest, &connected); 05804 }
static int party_id_build_data | ( | unsigned char * | data, | |
size_t | datalen, | |||
const struct ast_party_id * | id, | |||
const char * | label, | |||
const struct ast_party_id_ies * | ies, | |||
const struct ast_set_party_id * | update | |||
) | [static] |
Definition at line 8194 of file channel.c.
References ast_log(), ast_party_id_presentation(), ast_party_id_ies::combined_presentation, id, LOG_WARNING, ast_party_id_ies::name, ast_party_id_ies::number, party_name_build_data(), party_number_build_data(), party_subaddress_build_data(), ast_party_id_ies::subaddress, ast_party_id_ies::tag, and update().
Referenced by ast_connected_line_build_data(), and ast_redirecting_build_data().
08197 { 08198 size_t length; 08199 size_t pos = 0; 08200 int res; 08201 08202 /* 08203 * The size of integer values must be fixed in case the frame is 08204 * shipped to another machine. 08205 */ 08206 08207 if (!update || update->name) { 08208 res = party_name_build_data(data + pos, datalen - pos, &id->name, label, 08209 &ies->name); 08210 if (res < 0) { 08211 return -1; 08212 } 08213 pos += res; 08214 } 08215 08216 if (!update || update->number) { 08217 res = party_number_build_data(data + pos, datalen - pos, &id->number, label, 08218 &ies->number); 08219 if (res < 0) { 08220 return -1; 08221 } 08222 pos += res; 08223 } 08224 08225 if (!update || update->subaddress) { 08226 res = party_subaddress_build_data(data + pos, datalen - pos, &id->subaddress, 08227 label, &ies->subaddress); 08228 if (res < 0) { 08229 return -1; 08230 } 08231 pos += res; 08232 } 08233 08234 /* *************** Party id user tag **************************** */ 08235 if (id->tag) { 08236 length = strlen(id->tag); 08237 if (datalen < pos + (sizeof(data[0]) * 2) + length) { 08238 ast_log(LOG_WARNING, "No space left for %s tag\n", label); 08239 return -1; 08240 } 08241 data[pos++] = ies->tag; 08242 data[pos++] = length; 08243 memcpy(data + pos, id->tag, length); 08244 pos += length; 08245 } 08246 08247 /* *************** Party id combined presentation *************** */ 08248 if (!update || update->number) { 08249 int presentation; 08250 08251 if (!update || update->name) { 08252 presentation = ast_party_id_presentation(id); 08253 } else { 08254 /* 08255 * We must compromise because not all the information is available 08256 * to determine a combined presentation value. 08257 * We will only send the number presentation instead. 08258 */ 08259 presentation = id->number.presentation; 08260 } 08261 08262 if (datalen < pos + (sizeof(data[0]) * 2) + 1) { 08263 ast_log(LOG_WARNING, "No space left for %s combined presentation\n", label); 08264 return -1; 08265 } 08266 data[pos++] = ies->combined_presentation; 08267 data[pos++] = 1; 08268 data[pos++] = presentation; 08269 } 08270 08271 return pos; 08272 }
static int party_name_build_data | ( | unsigned char * | data, | |
size_t | datalen, | |||
const struct ast_party_name * | name, | |||
const char * | label, | |||
const struct ast_party_name_ies * | ies | |||
) | [static] |
Definition at line 7968 of file channel.c.
References ast_log(), ast_party_name_ies::char_set, LOG_WARNING, name, ast_party_name_ies::presentation, ast_party_name_ies::str, and ast_party_name_ies::valid.
Referenced by party_id_build_data().
07969 { 07970 size_t length; 07971 size_t pos = 0; 07972 07973 /* 07974 * The size of integer values must be fixed in case the frame is 07975 * shipped to another machine. 07976 */ 07977 if (name->str) { 07978 length = strlen(name->str); 07979 if (datalen < pos + (sizeof(data[0]) * 2) + length) { 07980 ast_log(LOG_WARNING, "No space left for %s name\n", label); 07981 return -1; 07982 } 07983 data[pos++] = ies->str; 07984 data[pos++] = length; 07985 memcpy(data + pos, name->str, length); 07986 pos += length; 07987 } 07988 07989 if (datalen < pos + (sizeof(data[0]) * 2) + 1) { 07990 ast_log(LOG_WARNING, "No space left for %s name char set\n", label); 07991 return -1; 07992 } 07993 data[pos++] = ies->char_set; 07994 data[pos++] = 1; 07995 data[pos++] = name->char_set; 07996 07997 if (datalen < pos + (sizeof(data[0]) * 2) + 1) { 07998 ast_log(LOG_WARNING, "No space left for %s name presentation\n", label); 07999 return -1; 08000 } 08001 data[pos++] = ies->presentation; 08002 data[pos++] = 1; 08003 data[pos++] = name->presentation; 08004 08005 if (datalen < pos + (sizeof(data[0]) * 2) + 1) { 08006 ast_log(LOG_WARNING, "No space left for %s name valid\n", label); 08007 return -1; 08008 } 08009 data[pos++] = ies->valid; 08010 data[pos++] = 1; 08011 data[pos++] = name->valid; 08012 08013 return pos; 08014 }
static int party_number_build_data | ( | unsigned char * | data, | |
size_t | datalen, | |||
const struct ast_party_number * | number, | |||
const char * | label, | |||
const struct ast_party_number_ies * | ies | |||
) | [static] |
Definition at line 8042 of file channel.c.
References ast_log(), LOG_WARNING, ast_party_number::plan, ast_party_number_ies::plan, ast_party_number::presentation, ast_party_number_ies::presentation, ast_party_number_ies::str, ast_party_number::str, ast_party_number::valid, and ast_party_number_ies::valid.
Referenced by party_id_build_data().
08043 { 08044 size_t length; 08045 size_t pos = 0; 08046 08047 /* 08048 * The size of integer values must be fixed in case the frame is 08049 * shipped to another machine. 08050 */ 08051 if (number->str) { 08052 length = strlen(number->str); 08053 if (datalen < pos + (sizeof(data[0]) * 2) + length) { 08054 ast_log(LOG_WARNING, "No space left for %s number\n", label); 08055 return -1; 08056 } 08057 data[pos++] = ies->str; 08058 data[pos++] = length; 08059 memcpy(data + pos, number->str, length); 08060 pos += length; 08061 } 08062 08063 if (datalen < pos + (sizeof(data[0]) * 2) + 1) { 08064 ast_log(LOG_WARNING, "No space left for %s numbering plan\n", label); 08065 return -1; 08066 } 08067 data[pos++] = ies->plan; 08068 data[pos++] = 1; 08069 data[pos++] = number->plan; 08070 08071 if (datalen < pos + (sizeof(data[0]) * 2) + 1) { 08072 ast_log(LOG_WARNING, "No space left for %s number presentation\n", label); 08073 return -1; 08074 } 08075 data[pos++] = ies->presentation; 08076 data[pos++] = 1; 08077 data[pos++] = number->presentation; 08078 08079 if (datalen < pos + (sizeof(data[0]) * 2) + 1) { 08080 ast_log(LOG_WARNING, "No space left for %s number valid\n", label); 08081 return -1; 08082 } 08083 data[pos++] = ies->valid; 08084 data[pos++] = 1; 08085 data[pos++] = number->valid; 08086 08087 return pos; 08088 }
static int party_subaddress_build_data | ( | unsigned char * | data, | |
size_t | datalen, | |||
const struct ast_party_subaddress * | subaddress, | |||
const char * | label, | |||
const struct ast_party_subaddress_ies * | ies | |||
) | [static] |
Definition at line 8116 of file channel.c.
References ast_log(), LOG_WARNING, ast_party_subaddress::odd_even_indicator, ast_party_subaddress_ies::odd_even_indicator, ast_party_subaddress_ies::str, ast_party_subaddress::str, ast_party_subaddress::type, ast_party_subaddress_ies::type, ast_party_subaddress::valid, and ast_party_subaddress_ies::valid.
Referenced by party_id_build_data().
08117 { 08118 size_t length; 08119 size_t pos = 0; 08120 08121 /* 08122 * The size of integer values must be fixed in case the frame is 08123 * shipped to another machine. 08124 */ 08125 if (subaddress->str) { 08126 length = strlen(subaddress->str); 08127 if (datalen < pos + (sizeof(data[0]) * 2) + length) { 08128 ast_log(LOG_WARNING, "No space left for %s subaddress\n", label); 08129 return -1; 08130 } 08131 data[pos++] = ies->str; 08132 data[pos++] = length; 08133 memcpy(data + pos, subaddress->str, length); 08134 pos += length; 08135 } 08136 08137 if (datalen < pos + (sizeof(data[0]) * 2) + 1) { 08138 ast_log(LOG_WARNING, "No space left for %s type of subaddress\n", label); 08139 return -1; 08140 } 08141 data[pos++] = ies->type; 08142 data[pos++] = 1; 08143 data[pos++] = subaddress->type; 08144 08145 if (datalen < pos + (sizeof(data[0]) * 2) + 1) { 08146 ast_log(LOG_WARNING, 08147 "No space left for %s subaddress odd-even indicator\n", label); 08148 return -1; 08149 } 08150 data[pos++] = ies->odd_even_indicator; 08151 data[pos++] = 1; 08152 data[pos++] = subaddress->odd_even_indicator; 08153 08154 if (datalen < pos + (sizeof(data[0]) * 2) + 1) { 08155 ast_log(LOG_WARNING, "No space left for %s subaddress valid\n", label); 08156 return -1; 08157 } 08158 data[pos++] = ies->valid; 08159 data[pos++] = 1; 08160 data[pos++] = subaddress->valid; 08161 08162 return pos; 08163 }
static void plc_ds_destroy | ( | void * | data | ) | [static] |
Definition at line 4592 of file channel.c.
References ast_free, and plc_ds::samples_buf.
04593 { 04594 struct plc_ds *plc = data; 04595 ast_free(plc->samples_buf); 04596 ast_free(plc); 04597 }
static void queue_dtmf_readq | ( | struct ast_channel * | chan, | |
struct ast_frame * | f | |||
) | [inline, static] |
Definition at line 3583 of file channel.c.
References AST_FRAME_DTMF_END, ast_queue_frame(), chanlist::chan, ast_channel::dtmff, f, ast_frame::frametype, ast_frame_subclass::integer, ast_frame::len, and ast_frame::subclass.
Referenced by __ast_read().
03584 { 03585 struct ast_frame *fr = &chan->dtmff; 03586 03587 fr->frametype = AST_FRAME_DTMF_END; 03588 fr->subclass.integer = f->subclass.integer; 03589 fr->len = f->len; 03590 03591 /* The only time this function will be called is for a frame that just came 03592 * out of the channel driver. So, we want to stick it on the tail of the 03593 * readq. */ 03594 03595 ast_queue_frame(chan, fr); 03596 }
static void report_new_callerid | ( | struct ast_channel * | chan | ) | [static] |
Definition at line 6121 of file channel.c.
References ast_describe_caller_presentation(), ast_manager_event, ast_party_id_presentation(), ast_channel::caller, chanlist::chan, EVENT_FLAG_CALL, ast_party_caller::id, ast_party_id::name, ast_channel::name, ast_party_id::number, S_COR, ast_party_name::str, ast_party_number::str, ast_channel::uniqueid, ast_party_name::valid, and ast_party_number::valid.
Referenced by ast_channel_set_caller_event(), ast_do_masquerade(), and ast_set_callerid().
06122 { 06123 int pres; 06124 06125 pres = ast_party_id_presentation(&chan->caller.id); 06126 ast_manager_event(chan, EVENT_FLAG_CALL, "NewCallerid", 06127 "Channel: %s\r\n" 06128 "CallerIDNum: %s\r\n" 06129 "CallerIDName: %s\r\n" 06130 "Uniqueid: %s\r\n" 06131 "CID-CallingPres: %d (%s)\r\n", 06132 chan->name, 06133 S_COR(chan->caller.id.number.valid, chan->caller.id.number.str, ""), 06134 S_COR(chan->caller.id.name.valid, chan->caller.id.name.str, ""), 06135 chan->uniqueid, 06136 pres, 06137 ast_describe_caller_presentation(pres) 06138 ); 06139 }
static void send_dtmf_event | ( | struct ast_channel * | chan, | |
const char * | direction, | |||
const char | digit, | |||
const char * | begin, | |||
const char * | end | |||
) | [static] |
Definition at line 3522 of file channel.c.
References ast_manager_event, chanlist::chan, EVENT_FLAG_DTMF, ast_channel::name, and ast_channel::uniqueid.
Referenced by __ast_read(), and ast_write().
03523 { 03524 ast_manager_event(chan, EVENT_FLAG_DTMF, 03525 "DTMF", 03526 "Channel: %s\r\n" 03527 "Uniqueid: %s\r\n" 03528 "Digit: %c\r\n" 03529 "Direction: %s\r\n" 03530 "Begin: %s\r\n" 03531 "End: %s\r\n", 03532 chan->name, chan->uniqueid, digit, direction, begin, end); 03533 }
static int set_format | ( | struct ast_channel * | chan, | |
format_t | fmt, | |||
format_t * | rawformat, | |||
format_t * | format, | |||
struct ast_trans_pvt ** | trans, | |||
const int | direction | |||
) | [static] |
Definition at line 4969 of file channel.c.
References ast_best_codec(), ast_channel_lock, ast_channel_setoption(), ast_channel_unlock, ast_debug, AST_FORMAT_AUDIO_MASK, ast_getformatname(), ast_getformatname_multiple(), ast_log(), AST_OPTION_FORMAT_READ, AST_OPTION_FORMAT_WRITE, ast_translator_best_choice(), ast_translator_build_path(), ast_translator_free_path(), chanlist::chan, LOG_WARNING, ast_channel::name, and ast_channel::nativeformats.
Referenced by ast_set_read_format(), and ast_set_write_format().
04971 { 04972 format_t native, native_fmt = ast_best_codec(fmt); 04973 int res; 04974 char from[200], to[200]; 04975 04976 /* Make sure we only consider audio */ 04977 fmt &= AST_FORMAT_AUDIO_MASK; 04978 04979 native = chan->nativeformats; 04980 04981 if (!fmt || !native) /* No audio requested */ 04982 return 0; /* Let's try a call without any sounds (video, text) */ 04983 04984 /* See if the underlying channel driver is capable of performing transcoding for us */ 04985 if (!ast_channel_setoption(chan, direction ? AST_OPTION_FORMAT_WRITE : AST_OPTION_FORMAT_READ, &native_fmt, sizeof(int*), 0)) { 04986 ast_debug(1, "Channel driver natively set channel %s to %s format %s\n", chan->name, 04987 direction ? "write" : "read", ast_getformatname(native_fmt)); 04988 chan->nativeformats = *rawformat = *format = native_fmt; 04989 if (*trans) { 04990 ast_translator_free_path(*trans); 04991 } 04992 *trans = NULL; 04993 return 0; 04994 } 04995 04996 /* Find a translation path from the native format to one of the desired formats */ 04997 if (!direction) 04998 /* reading */ 04999 res = ast_translator_best_choice(&fmt, &native); 05000 else 05001 /* writing */ 05002 res = ast_translator_best_choice(&native, &fmt); 05003 05004 if (res < 0) { 05005 ast_log(LOG_WARNING, "Unable to find a codec translation path from %s to %s\n", 05006 ast_getformatname_multiple(from, sizeof(from), native), 05007 ast_getformatname_multiple(to, sizeof(to), fmt)); 05008 return -1; 05009 } 05010 05011 /* Now we have a good choice for both. */ 05012 ast_channel_lock(chan); 05013 05014 if ((*rawformat == native) && (*format == fmt) && ((*rawformat == *format) || (*trans))) { 05015 /* the channel is already in these formats, so nothing to do */ 05016 ast_channel_unlock(chan); 05017 return 0; 05018 } 05019 05020 *rawformat = native; 05021 /* User perspective is fmt */ 05022 *format = fmt; 05023 /* Free any read translation we have right now */ 05024 if (*trans) { 05025 ast_translator_free_path(*trans); 05026 *trans = NULL; 05027 } 05028 /* Build a translation path from the raw format to the desired format */ 05029 if (*format == *rawformat) { 05030 /* 05031 * If we were able to swap the native format to the format that 05032 * has been requested, then there is no need to try to build 05033 * a translation path. 05034 */ 05035 res = 0; 05036 } else { 05037 if (!direction) { 05038 /* reading */ 05039 *trans = ast_translator_build_path(*format, *rawformat); 05040 } else { 05041 /* writing */ 05042 *trans = ast_translator_build_path(*rawformat, *format); 05043 } 05044 res = *trans ? 0 : -1; 05045 } 05046 ast_channel_unlock(chan); 05047 ast_debug(1, "Set channel %s to %s format %s\n", chan->name, 05048 direction ? "write" : "read", ast_getformatname(fmt)); 05049 return res; 05050 }
static int set_security_requirements | ( | const struct ast_channel * | requestor, | |
struct ast_channel * | out | |||
) | [static] |
Definition at line 5345 of file channel.c.
References ast_channel_datastore_find(), ast_channel_lock, ast_channel_setoption(), ast_channel_unlock, AST_OPTION_SECURE_MEDIA, AST_OPTION_SECURE_SIGNALING, ast_datastore::data, ast_secure_call_store::media, secure_call_info, and ast_secure_call_store::signaling.
Referenced by ast_request().
05346 { 05347 int ops[2][2] = { 05348 {AST_OPTION_SECURE_SIGNALING, 0}, 05349 {AST_OPTION_SECURE_MEDIA, 0}, 05350 }; 05351 int i; 05352 struct ast_channel *r = (struct ast_channel *) requestor; /* UGLY */ 05353 struct ast_datastore *ds; 05354 05355 if (!requestor || !out) { 05356 return 0; 05357 } 05358 05359 ast_channel_lock(r); 05360 if ((ds = ast_channel_datastore_find(r, &secure_call_info, NULL))) { 05361 struct ast_secure_call_store *encrypt = ds->data; 05362 ops[0][1] = encrypt->signaling; 05363 ops[1][1] = encrypt->media; 05364 } else { 05365 ast_channel_unlock(r); 05366 return 0; 05367 } 05368 ast_channel_unlock(r); 05369 05370 for (i = 0; i < 2; i++) { 05371 if (ops[i][1]) { 05372 if (ast_channel_setoption(out, ops[i][0], &ops[i][1], sizeof(ops[i][1]), 0)) { 05373 /* We require a security feature, but the channel won't provide it */ 05374 return -1; 05375 } 05376 } else { 05377 /* We don't care if we can't clear the option on a channel that doesn't support it */ 05378 ast_channel_setoption(out, ops[i][0], &ops[i][1], sizeof(ops[i][1]), 0); 05379 } 05380 } 05381 05382 return 0; 05383 }
static int should_skip_dtmf | ( | struct ast_channel * | chan | ) | [inline, static] |
Determine whether or not we should ignore DTMF in the readq.
Definition at line 3601 of file channel.c.
References AST_FLAG_DEFER_DTMF, AST_FLAG_EMULATE_DTMF, AST_MIN_DTMF_GAP, ast_test_flag, ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), chanlist::chan, and ast_channel::dtmf_tv.
Referenced by __ast_read().
03602 { 03603 if (ast_test_flag(chan, AST_FLAG_DEFER_DTMF | AST_FLAG_EMULATE_DTMF)) { 03604 /* We're in the middle of emulating a digit, or DTMF has been 03605 * explicitly deferred. Skip this digit, then. */ 03606 return 1; 03607 } 03608 03609 if (!ast_tvzero(chan->dtmf_tv) && 03610 ast_tvdiff_ms(ast_tvnow(), chan->dtmf_tv) < AST_MIN_DTMF_GAP) { 03611 /* We're not in the middle of a digit, but it hasn't been long enough 03612 * since the last digit, so we'll have to skip DTMF for now. */ 03613 return 1; 03614 } 03615 03616 return 0; 03617 }
static void* silence_generator_alloc | ( | struct ast_channel * | chan, | |
void * | data | |||
) | [static] |
static int silence_generator_generate | ( | struct ast_channel * | chan, | |
void * | data, | |||
int | len, | |||
int | samples | |||
) | [static] |
Definition at line 7775 of file channel.c.
References AST_FORMAT_SLINEAR, AST_FRAME_VOICE, ast_write(), and ast_frame::frametype.
07776 { 07777 short buf[samples]; 07778 struct ast_frame frame = { 07779 .frametype = AST_FRAME_VOICE, 07780 .subclass.codec = AST_FORMAT_SLINEAR, 07781 .data.ptr = buf, 07782 .samples = samples, 07783 .datalen = sizeof(buf), 07784 }; 07785 07786 memset(buf, 0, sizeof(buf)); 07787 07788 if (ast_write(chan, &frame)) 07789 return -1; 07790 07791 return 0; 07792 }
static void silence_generator_release | ( | struct ast_channel * | chan, | |
void * | data | |||
) | [static] |
static void* tonepair_alloc | ( | struct ast_channel * | chan, | |
void * | params | |||
) | [static] |
Definition at line 7376 of file channel.c.
References ast_calloc, AST_FLAG_WRITE_INT, AST_FORMAT_SLINEAR, ast_log(), ast_set_flag, ast_set_write_format(), chanlist::chan, cos, tonepair_def::duration, tonepair_def::freq1, tonepair_def::freq2, LOG_WARNING, M_PI, ast_channel::name, tonepair_release(), tonepair_def::vol, and ast_channel::writeformat.
07377 { 07378 struct tonepair_state *ts; 07379 struct tonepair_def *td = params; 07380 07381 if (!(ts = ast_calloc(1, sizeof(*ts)))) 07382 return NULL; 07383 ts->origwfmt = chan->writeformat; 07384 if (ast_set_write_format(chan, AST_FORMAT_SLINEAR)) { 07385 ast_log(LOG_WARNING, "Unable to set '%s' to signed linear format (write)\n", chan->name); 07386 tonepair_release(NULL, ts); 07387 ts = NULL; 07388 } else { 07389 ts->fac1 = 2.0 * cos(2.0 * M_PI * (td->freq1 / 8000.0)) * 32768.0; 07390 ts->v1_1 = 0; 07391 ts->v2_1 = sin(-4.0 * M_PI * (td->freq1 / 8000.0)) * td->vol; 07392 ts->v3_1 = sin(-2.0 * M_PI * (td->freq1 / 8000.0)) * td->vol; 07393 ts->v2_1 = 0; 07394 ts->fac2 = 2.0 * cos(2.0 * M_PI * (td->freq2 / 8000.0)) * 32768.0; 07395 ts->v2_2 = sin(-4.0 * M_PI * (td->freq2 / 8000.0)) * td->vol; 07396 ts->v3_2 = sin(-2.0 * M_PI * (td->freq2 / 8000.0)) * td->vol; 07397 ts->duration = td->duration; 07398 ts->modulate = 0; 07399 } 07400 /* Let interrupts interrupt :) */ 07401 ast_set_flag(chan, AST_FLAG_WRITE_INT); 07402 return ts; 07403 }
static int tonepair_generator | ( | struct ast_channel * | chan, | |
void * | data, | |||
int | len, | |||
int | samples | |||
) | [static] |
Definition at line 7405 of file channel.c.
References ast_log(), tonepair_state::data, tonepair_state::f, tonepair_state::fac1, tonepair_state::fac2, LOG_WARNING, tonepair_state::modulate, tonepair_state::v1_1, tonepair_state::v1_2, tonepair_state::v2_1, tonepair_state::v2_2, tonepair_state::v3_1, and tonepair_state::v3_2.
07406 { 07407 struct tonepair_state *ts = data; 07408 int x; 07409 07410 /* we need to prepare a frame with 16 * timelen samples as we're 07411 * generating SLIN audio 07412 */ 07413 len = samples * 2; 07414 07415 if (len > sizeof(ts->data) / 2 - 1) { 07416 ast_log(LOG_WARNING, "Can't generate that much data!\n"); 07417 return -1; 07418 } 07419 memset(&ts->f, 0, sizeof(ts->f)); 07420 for (x=0;x<len/2;x++) { 07421 ts->v1_1 = ts->v2_1; 07422 ts->v2_1 = ts->v3_1; 07423 ts->v3_1 = (ts->fac1 * ts->v2_1 >> 15) - ts->v1_1; 07424 07425 ts->v1_2 = ts->v2_2; 07426 ts->v2_2 = ts->v3_2; 07427 ts->v3_2 = (ts->fac2 * ts->v2_2 >> 15) - ts->v1_2; 07428 if (ts->modulate) { 07429 int p; 07430 p = ts->v3_2 - 32768; 07431 if (p < 0) p = -p; 07432 p = ((p * 9) / 10) + 1; 07433 ts->data[x] = (ts->v3_1 * p) >> 15; 07434 } else 07435 ts->data[x] = ts->v3_1 + ts->v3_2; 07436 } 07437 ts->f.frametype = AST_FRAME_VOICE; 07438 ts->f.subclass.codec = AST_FORMAT_SLINEAR; 07439 ts->f.datalen = len; 07440 ts->f.samples = samples; 07441 ts->f.offset = AST_FRIENDLY_OFFSET; 07442 ts->f.data.ptr = ts->data; 07443 ast_write(chan, &ts->f); 07444 ts->pos += x; 07445 if (ts->duration > 0) { 07446 if (ts->pos >= ts->duration * 8) 07447 return -1; 07448 } 07449 return 0; 07450 }
static void tonepair_release | ( | struct ast_channel * | chan, | |
void * | params | |||
) | [static] |
Definition at line 7367 of file channel.c.
References ast_free, ast_set_write_format(), chanlist::chan, and tonepair_state::origwfmt.
Referenced by tonepair_alloc().
07368 { 07369 struct tonepair_state *ts = params; 07370 07371 if (chan) 07372 ast_set_write_format(chan, ts->origwfmt); 07373 ast_free(ts); 07374 }
static void update_bridge_vars | ( | struct ast_channel * | c0, | |
struct ast_channel * | c1 | |||
) | [static] |
Definition at line 6982 of file channel.c.
References ast_channel_lock, ast_channel_unlock, ast_strdupa, ast_strlen_zero(), ast_channel_tech::get_pvt_uniqueid, ast_channel::name, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), and ast_channel::tech.
Referenced by ast_channel_bridge().
06983 { 06984 const char *c0_name; 06985 const char *c1_name; 06986 const char *c0_pvtid = NULL; 06987 const char *c1_pvtid = NULL; 06988 06989 ast_channel_lock(c1); 06990 c1_name = ast_strdupa(c1->name); 06991 if (c1->tech->get_pvt_uniqueid) { 06992 c1_pvtid = ast_strdupa(c1->tech->get_pvt_uniqueid(c1)); 06993 } 06994 ast_channel_unlock(c1); 06995 06996 ast_channel_lock(c0); 06997 if (!ast_strlen_zero(pbx_builtin_getvar_helper(c0, "BRIDGEPEER"))) { 06998 pbx_builtin_setvar_helper(c0, "BRIDGEPEER", c1_name); 06999 } 07000 if (c1_pvtid) { 07001 pbx_builtin_setvar_helper(c0, "BRIDGEPVTCALLID", c1_pvtid); 07002 } 07003 c0_name = ast_strdupa(c0->name); 07004 if (c0->tech->get_pvt_uniqueid) { 07005 c0_pvtid = ast_strdupa(c0->tech->get_pvt_uniqueid(c0)); 07006 } 07007 ast_channel_unlock(c0); 07008 07009 ast_channel_lock(c1); 07010 if (!ast_strlen_zero(pbx_builtin_getvar_helper(c1, "BRIDGEPEER"))) { 07011 pbx_builtin_setvar_helper(c1, "BRIDGEPEER", c0_name); 07012 } 07013 if (c0_pvtid) { 07014 pbx_builtin_setvar_helper(c1, "BRIDGEPVTCALLID", c0_pvtid); 07015 } 07016 ast_channel_unlock(c1); 07017 }
static void xfer_ds_destroy | ( | void * | data | ) | [static] |
Definition at line 5827 of file channel.c.
References ast_free, ast_party_connected_line_free(), xfer_masquerade_ds::target_id, and xfer_masquerade_ds::transferee_id.
05828 { 05829 struct xfer_masquerade_ds *ds = data; 05830 05831 ast_party_connected_line_free(&ds->target_id); 05832 ast_party_connected_line_free(&ds->transferee_id); 05833 ast_free(ds); 05834 }
void(*) ast_moh_cleanup_ptr(struct ast_channel *) = NULL [static] |
Definition at line 7528 of file channel.c.
Referenced by ast_install_music_functions(), ast_moh_cleanup(), and ast_uninstall_music_functions().
int(*) ast_moh_start_ptr(struct ast_channel *, const char *, const char *) = NULL [static] |
Definition at line 7526 of file channel.c.
Referenced by ast_install_music_functions(), ast_moh_start(), and ast_uninstall_music_functions().
void(*) ast_moh_stop_ptr(struct ast_channel *) = NULL [static] |
Definition at line 7527 of file channel.c.
Referenced by ast_install_music_functions(), ast_moh_stop(), and ast_uninstall_music_functions().
int cause |
Definition at line 198 of file channel.c.
Referenced by __ast_read(), __ast_request_and_dial(), action_hangup(), ast_call_forward(), cb_events(), dial_exec_full(), dial_transfer(), do_forward(), dump_cause(), feature_request_and_dial(), oh323_hangup(), ospfinished_exec(), ospnext_exec(), parse_disconnect(), parse_release(), parse_release_complete(), parse_status(), pbx_builtin_hangup(), play_sound_file(), sig_pri_hangup(), sms_messagerx(), and sms_messagerx2().
struct { ... } causes[] [static] |
map AST_CAUSE's to readable string representations
Referenced by ast_cause2str(), ast_str2cause(), and dump_cause().
struct ast_datastore_info cc_channel_datastore_info [static] |
Initial value:
{ .type = "Call Completion", .duplicate = channel_cc_params_copy, .destroy = channel_cc_params_destroy, }
Definition at line 9186 of file channel.c.
Referenced by ast_channel_cc_params_init(), and ast_channel_get_cc_config_params().
struct ast_data_entry channel_providers[] [static] |
Initial value:
{ AST_DATA_ENTRY("/asterisk/core/channels", &channels_provider), AST_DATA_ENTRY("/asterisk/core/channeltypes", &channeltypes_provider), }
Definition at line 7713 of file channel.c.
Referenced by ast_channels_init().
struct ao2_container* channels [static] |
struct ast_data_handler channels_provider [static] |
Initial value:
{ .version = AST_DATA_HANDLER_VERSION, .get = data_channels_provider_handler }
struct ast_data_handler channeltypes_provider [static] |
Initial value:
{ .version = AST_DATA_HANDLER_VERSION, .get = data_channeltypes_provider_handler }
struct ast_cli_entry cli_channel[] [static] |
Initial value:
{ { .handler = handle_cli_core_show_channeltypes , .summary = "List available channel types" ,__VA_ARGS__ }, { .handler = handle_cli_core_show_channeltype , .summary = "Give more details on that channel type" ,__VA_ARGS__ } }
Definition at line 610 of file channel.c.
Referenced by ast_channels_init().
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 98 of file channel.c.
Referenced by handle_core_set_debug_channel().
unsigned long global_fout |
struct ast_channel_tech null_tech [static] |
Initial value:
{ .type = "NULL", .description = "Null channel (should not see this)", }
Definition at line 1050 of file channel.c.
Referenced by __ast_channel_alloc_ap(), and do_notify().
struct ast_datastore_info plc_ds_info [static] |
Initial value:
{ .type = "plc", .destroy = plc_ds_destroy, }
Definition at line 4599 of file channel.c.
Referenced by apply_plc().
int shutting_down [static] |
struct ast_generator silence_generator [static] |
Initial value:
{ .alloc = silence_generator_alloc, .release = silence_generator_release, .generate = silence_generator_generate, }
Definition at line 7794 of file channel.c.
Referenced by ast_channel_start_silence_generator().
struct ast_threadstorage state2str_threadbuf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_state2str_threadbuf , .custom_init = NULL , } [static] |
struct ast_generator tonepair [static] |
Initial value:
{ alloc: tonepair_alloc, release: tonepair_release, generate: tonepair_generator, }
Definition at line 7452 of file channel.c.
Referenced by ast_tonepair_start().
struct ast_datastore_info xfer_ds_info [static] |
Initial value:
{ .type = "xfer_colp", .destroy = xfer_ds_destroy, }
Definition at line 5836 of file channel.c.
Referenced by ast_channel_transfer_masquerade(), and ast_do_masquerade().