chan_dahdi.c File Reference

DAHDI for Pseudo TDM. More...

#include "asterisk.h"
#include <sys/sysmacros.h>
#include <signal.h>
#include <sys/stat.h>
#include <math.h>
#include "sig_analog.h"
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/file.h"
#include "asterisk/ulaw.h"
#include "asterisk/alaw.h"
#include "asterisk/callerid.h"
#include "asterisk/adsi.h"
#include "asterisk/cli.h"
#include "asterisk/pickup.h"
#include "asterisk/features.h"
#include "asterisk/musiconhold.h"
#include "asterisk/say.h"
#include "asterisk/tdd.h"
#include "asterisk/mwi.h"
#include "asterisk/dsp.h"
#include "asterisk/astdb.h"
#include "asterisk/manager.h"
#include "asterisk/causes.h"
#include "asterisk/term.h"
#include "asterisk/utils.h"
#include "asterisk/transcap.h"
#include "asterisk/stringfields.h"
#include "asterisk/abstract_jb.h"
#include "asterisk/smdi.h"
#include "asterisk/devicestate.h"
#include "asterisk/paths.h"
#include "asterisk/ccss.h"
#include "asterisk/features_config.h"
#include "asterisk/bridge.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/parking.h"
#include "asterisk/format_cache.h"
#include "chan_dahdi.h"
#include "dahdi/bridge_native_dahdi.h"

Include dependency graph for chan_dahdi.c:

Go to the source code of this file.

Data Structures
struct	dahdi_chan_conf
	Channel configuration from chan_dahdi.conf . This struct is used for parsing the [channels] section of chan_dahdi.conf. Generally there is a field here for every possible configuration item. More...
struct	dahdi_starting_point
struct	mwi_thread_data

Macros
#define	ASCII_BYTES_PER_CHAR   80
#define	AST_LAW(p)   (((p)->law == DAHDI_LAW_ALAW) ? ast_format_alaw : ast_format_ulaw)
#define	CALLPROGRESS_FAX   (CALLPROGRESS_FAX_INCOMING | CALLPROGRESS_FAX_OUTGOING)
#define	CALLPROGRESS_FAX_INCOMING   4
#define	CALLPROGRESS_FAX_OUTGOING   2
#define	CALLPROGRESS_PROGRESS   1
#define	CALLWAITING_REPEAT_SAMPLES   ((10000 * 8) / READ_SIZE)
#define	CALLWAITING_SILENT_SAMPLES   ((300 * 8) / READ_SIZE)
#define	CALLWAITING_SUPPRESS_SAMPLES   ((100 * 8) / READ_SIZE)
#define	CANBUSYDETECT(p)   (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __DAHDI_SIG_FXO) */)
#define	CANPROGRESSDETECT(p)   (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __DAHDI_SIG_FXO) */)
#define	CHAN_PSEUDO   -2
#define	CIDCW_EXPIRE_SAMPLES   ((500 * 8) / READ_SIZE)
#define	DEFAULT_CIDRINGS   1
	Typically, how many rings before we should send Caller*ID. More...
#define	DEFAULT_DIALTONE_DETECT_TIMEOUT   ((10000 * 8) / READ_SIZE)
#define	DEFAULT_RINGT   ((8000 * 8) / READ_SIZE)
#define	END_SILENCE_LEN   400
#define	FORMAT   "%7s %-15.15s %-15.15s %-10.10s %-20.20s %-10.10s %-10.10s %-32.32s\n"
#define	FORMAT   "%-40.40s %-7.7s %-6d %-6d %-6d %-3.3s %-4.4s %-8.8s %s\n"
#define	FORMAT2   "%7s %-15.15s %-15.15s %-10.10s %-20.20s %-10.10s %-10.10s %-32.32s\n"
#define	FORMAT2   "%-40.40s %-7.7s %-6.6s %-6.6s %-6.6s %-3.3s %-4.4s %-8.8s %s\n"
#define	gen_pvt_field_callback(type, field)
#define	GET_CHANNEL(p)   ((p)->channel)
#define	HANGUP   1
#define	HEADER_LEN   ((HEADER_MS + TRAILER_MS) * 8)
#define	HEADER_MS   50
#define	ISTRUNK(p)
#define	MASK_AVAIL   (1 << 0)
#define	MASK_INUSE   (1 << 1)
#define	MAX_CHANLIST_LEN   80
#define	MIN_MS_SINCE_FLASH   ((2000) )
#define	NEED_MFDETECT(p)   (((p)->sig == SIG_FEATDMF) || ((p)->sig == SIG_FEATDMF_TA) || ((p)->sig == SIG_E911) || ((p)->sig == SIG_FGC_CAMA) || ((p)->sig == SIG_FGC_CAMAMF) || ((p)->sig == SIG_FEATB))
	Signaling types that need to use MF detection should be placed in this macro. More...
#define	NUM_CADENCE_MAX   25
#define	NUM_SPANS   32
#define	POLARITY_IDLE   0
#define	POLARITY_REV   1
#define	PROC_DAHDI_OPT_NOCHAN   (1 << 0)
#define	PROC_DAHDI_OPT_NOWARN   (1 << 1)
#define	READ_SIZE   160
#define	REPORT_CHANNEL_ALARMS   1
#define	REPORT_SPAN_ALARMS   2
#define	sig2str   dahdi_sig2str
#define	SMDI_MD_WAIT_TIMEOUT   1500 /* 1.5 seconds */
#define	TRAILER_MS   5
#define	TRANSFER   0

Functions
static struct ast_frame *	__dahdi_exception (struct ast_channel *ast)
static void	__reg_module (void)
static int	__unload_module (void)
static void	__unreg_module (void)
int	_dahdi_get_index (struct ast_channel *ast, struct dahdi_pvt *p, int nullok, const char *fname, unsigned long line)
static int	action_dahdidialoffhook (struct mansession *s, const struct message *m)
static int	action_dahdidndoff (struct mansession *s, const struct message *m)
static int	action_dahdidndon (struct mansession *s, const struct message *m)
static int	action_dahdirestart (struct mansession *s, const struct message *m)
static int	action_dahdishowchannels (struct mansession *s, const struct message *m)
static int	action_transfer (struct mansession *s, const struct message *m)
static int	action_transferhangup (struct mansession *s, const struct message *m)
static char *	alarm2str (int alm)
static int	alloc_sub (struct dahdi_pvt *p, int x)
static void *	analog_ss_thread (void *data)
static int	analog_tone_to_dahditone (enum analog_tone tone)
static int	analogsub_to_dahdisub (enum analog_sub analogsub)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	attempt_transfer (struct dahdi_pvt *p)
static int	available (struct dahdi_pvt **pvt, int is_specific_channel)
static int	build_channels (struct dahdi_chan_conf *conf, const char *value, int reload, int lineno)
static int	bump_gains (struct dahdi_pvt *p)
static int	calc_energy (const unsigned char *buf, int len, struct ast_format *law)
static int	canmatch_featurecode (const char *pickupexten, const char *exten)
static int	check_for_conference (struct dahdi_pvt *p)
static int	conf_add (struct dahdi_pvt *p, struct dahdi_subchannel *c, int index, int slavechannel)
static int	conf_del (struct dahdi_pvt *p, struct dahdi_subchannel *c, int index)
static struct ast_str *	create_channel_name (struct dahdi_pvt *i)
static void	dahdi_ami_channel_event (struct dahdi_pvt *p, struct ast_channel *chan)
static int	dahdi_answer (struct ast_channel *ast)
static int	dahdi_call (struct ast_channel *ast, const char *rdest, int timeout)
static int	dahdi_callwait (struct ast_channel *ast)
static int	dahdi_cc_callback (struct ast_channel *inbound, const char *dest, ast_cc_callback_fn callback)
	Callback made when dial failed to get a channel out of dahdi_request(). More...
static struct dahdi_chan_conf	dahdi_chan_conf_default (void)
static void	dahdi_close (int fd)
static void	dahdi_close_sub (struct dahdi_pvt *chan_pvt, int sub_num)
void	dahdi_conf_update (struct dahdi_pvt *p)
static int	dahdi_confmute (struct dahdi_pvt *p, int muted)
static int	dahdi_create_channel_range (int start, int end)
static char *	dahdi_create_channels (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	dahdi_destroy_channel_range (int start, int end)
static char *	dahdi_destroy_channels (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	dahdi_devicestate (const char *data)
static int	dahdi_dial_str (struct dahdi_pvt *pvt, int operation, const char *dial_str)
static int	dahdi_digit_begin (struct ast_channel *ast, char digit)
static int	dahdi_digit_end (struct ast_channel *ast, char digit, unsigned int duration)
static int	dahdi_dnd (struct dahdi_pvt *dahdichan, int flag)
	enable or disable the chan_dahdi Do-Not-Disturb mode for a DAHDI channel More...
void	dahdi_dtmf_detect_disable (struct dahdi_pvt *p)
void	dahdi_dtmf_detect_enable (struct dahdi_pvt *p)
void	dahdi_ec_disable (struct dahdi_pvt *p)
void	dahdi_ec_enable (struct dahdi_pvt *p)
static struct ast_frame *	dahdi_exception (struct ast_channel *ast)
static int	dahdi_fake_event (struct dahdi_pvt *p, int mode)
static int	dahdi_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
static int	dahdi_func_read (struct ast_channel *chan, const char *function, char *data, char *buf, size_t len)
static int	dahdi_func_write (struct ast_channel *chan, const char *function, char *data, const char *value)
static int	dahdi_get_event (int fd)
	Avoid the silly dahdi_getevent which ignores a bunch of events. More...
static void	dahdi_handle_dtmf (struct ast_channel *ast, int idx, struct ast_frame **dest)
static struct ast_frame *	dahdi_handle_event (struct ast_channel *ast)
static int	dahdi_hangup (struct ast_channel *ast)
static void	dahdi_iflist_extract (struct dahdi_pvt *pvt)
static void	dahdi_iflist_insert (struct dahdi_pvt *pvt)
static int	dahdi_indicate (struct ast_channel *chan, int condition, const void *data, size_t datalen)
static void	dahdi_lock_sub_owner (struct dahdi_pvt *pvt, int sub_idx)
void	dahdi_master_slave_link (struct dahdi_pvt *slave, struct dahdi_pvt *master)
void	dahdi_master_slave_unlink (struct dahdi_pvt *slave, struct dahdi_pvt *master, int needlock)
static struct ast_channel *	dahdi_new (struct dahdi_pvt *i, int state, int startpbx, int idx, int law, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, ast_callid callid)
static struct ast_channel *	dahdi_new_callid_clean (struct dahdi_pvt *i, int state, int startpbx, int idx, int law, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, ast_callid callid, int callid_created)
static int	dahdi_open (char *fn)
static int	dahdi_queryoption (struct ast_channel *chan, int option, void *data, int *datalen)
static void	dahdi_queue_frame (struct dahdi_pvt *p, struct ast_frame *f)
static struct ast_frame *	dahdi_read (struct ast_channel *ast)
static struct ast_channel *	dahdi_request (const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *data, int *cause)
static int	dahdi_restart (void)
static char *	dahdi_restart_cmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	dahdi_ring_phone (struct dahdi_pvt *p)
static int	dahdi_sendtext (struct ast_channel *c, const char *text)
static char *	dahdi_set_dnd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	dahdi_set_hook (int fd, int hs)
static char *	dahdi_set_hwgain (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dahdi_set_swgain (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	dahdi_setlinear (int dfd, int linear)
static int	dahdi_setoption (struct ast_channel *chan, int option, void *data, int datalen)
static char *	dahdi_show_channel (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dahdi_show_channels (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dahdi_show_status (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dahdi_show_version (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	dahdi_sig2str (int sig)
static void	dahdi_softhangup_all (void)
static void	dahdi_train_ec (struct dahdi_pvt *p)
static int	dahdi_wait_event (int fd)
	Avoid the silly dahdi_waitevent which ignores a bunch of events. More...
static int	dahdi_wink (struct dahdi_pvt *p, int index)
static int	dahdi_write (struct ast_channel *ast, struct ast_frame *frame)
static struct ast_manager_event_blob *	dahdichannel_to_ami (struct stasis_message *msg)
static enum analog_event	dahdievent_to_analogevent (int event)
static enum analog_sigtype	dahdisig_to_analogsig (int sig)
static void	deep_copy_dahdi_chan_conf (struct dahdi_chan_conf *dest, const struct dahdi_chan_conf *src)
static void	destroy_all_channels (void)
static void	destroy_channel (struct dahdi_pvt *cur, int now)
static void	destroy_dahdi_pvt (struct dahdi_pvt *pvt)
static struct dahdi_pvt *	determine_starting_point (const char *data, struct dahdi_starting_point *param)
static int	digit_to_dtmfindex (char digit)
static void *	do_monitor (void *data)
static int	drc_sample (int sample, float drc)
static struct dahdi_pvt *	duplicate_pseudo (struct dahdi_pvt *src)
static const char *	event2str (int event)
static void	fill_rxgain (struct dahdi_gains *g, float gain, float drc, int law)
static void	fill_txgain (struct dahdi_gains *g, float gain, float drc, int law)
static struct dahdi_pvt *	find_channel (int channel)
static struct dahdi_pvt *	find_channel_from_str (const char *channel)
static struct dahdi_pvt *	find_next_iface_in_span (struct dahdi_pvt *cur)
	gen_pvt_field_callback (int, firstdigit_timeout)
	gen_pvt_field_callback (int, interdigit_timeout)
	gen_pvt_field_callback (int, matchdigit_timeout)
static int	get_alarms (struct dahdi_pvt *p)
static void	handle_alarms (struct dahdi_pvt *p, int alms)
static void	handle_clear_alarms (struct dahdi_pvt *p)
static char *	handle_dahdi_show_cadences (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static struct dahdi_pvt *	handle_init_event (struct dahdi_pvt *i, int event)
static int	has_voicemail (struct dahdi_pvt *p)
static int	is_group_or_channel_match (struct dahdi_pvt *p, int span, ast_group_t groupmatch, int *groupmatched, int channelmatch, int *channelmatched)
static int	isourconf (struct dahdi_pvt *p, struct dahdi_subchannel *c)
static int	isslavenative (struct dahdi_pvt *p, struct dahdi_pvt **out)
static int	load_module (void)
	Load the module. More...
static struct dahdi_pvt *	mkintf (int channel, const struct dahdi_chan_conf *conf, int reloading)
static void	monitor_pfds_clean (void *arg)
static int	mwi_send_init (struct dahdi_pvt *pvt)
static int	mwi_send_process_buffer (struct dahdi_pvt *pvt, int num_read)
static int	mwi_send_process_event (struct dahdi_pvt *pvt, int event)
static void *	mwi_thread (void *data)
static void	my_all_subchannels_hungup (void *pvt)
static int	my_allocate_sub (void *pvt, enum analog_sub analogsub)
static void	my_answer_polarityswitch (void *pvt)
static int	my_callwait (void *pvt)
static void	my_cancel_cidspill (void *pvt)
static int	my_check_confirmanswer (void *pvt)
static int	my_check_for_conference (void *pvt)
static int	my_check_waitingfordt (void *pvt)
static int	my_complete_conference_update (void *pvt, int needconference)
static int	my_conf_add (void *pvt, enum analog_sub sub)
static int	my_conf_del (void *pvt, enum analog_sub sub)
static int	my_confmute (void *pvt, int mute)
static int	my_dahdi_write (struct dahdi_pvt *p, unsigned char *buf, int len, int idx, int linear)
static void	my_deadlock_avoidance_private (void *pvt)
static void	my_decrease_ss_count (void)
static int	my_dial_digits (void *pvt, enum analog_sub sub, struct analog_dialoperation *dop)
static int	my_distinctive_ring (struct ast_channel *chan, void *pvt, int idx, int *ringdata)
static int	my_dsp_reset_and_flush_digits (void *pvt)
static int	my_dsp_set_digitmode (void *pvt, enum analog_dsp_digitmode mode)
static int	my_flash (void *pvt)
static void	my_get_and_handle_alarms (void *pvt)
static int	my_get_callerid (void *pvt, char *namebuf, char *numbuf, enum analog_event *ev, size_t timeout)
static int	my_get_event (void *pvt)
static const char *	my_get_orig_dialstring (void *pvt)
static void *	my_get_sigpvt_bridged_channel (struct ast_channel *chan)
static int	my_get_sub_fd (void *pvt, enum analog_sub sub)
static int	my_getsigstr (struct ast_channel *chan, char *str, const char *term, int ms)
static void	my_handle_dtmf (void *pvt, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest)
static void	my_handle_notify_message (struct ast_channel *chan, void *pvt, int cid_flags, int neon_mwievent)
static void	my_hangup_polarityswitch (void *pvt)
static int	my_has_voicemail (void *pvt)
static int	my_have_progressdetect (void *pvt)
static void	my_increase_ss_count (void)
static int	my_is_dialing (void *pvt, enum analog_sub sub)
static int	my_is_off_hook (void *pvt)
static void	my_lock_private (void *pvt)
static struct ast_channel *	my_new_analog_ast_channel (void *pvt, int state, int startpbx, enum analog_sub sub, const struct ast_channel *requestor)
static int	my_off_hook (void *pvt)
static int	my_on_hook (void *pvt)
static int	my_play_tone (void *pvt, enum analog_sub sub, enum analog_tone tone)
static int	my_ring (void *pvt)
static int	my_send_callerid (void *pvt, int cwcid, struct ast_party_caller *caller)
static void	my_set_alarm (void *pvt, int in_alarm)
static void	my_set_cadence (void *pvt, int *cid_rings, struct ast_channel *ast)
static void	my_set_callwaiting (void *pvt, int callwaiting_enable)
static void	my_set_confirmanswer (void *pvt, int flag)
static void	my_set_dialing (void *pvt, int is_dialing)
static int	my_set_echocanceller (void *pvt, int enable)
static void	my_set_inthreeway (void *pvt, enum analog_sub sub, int inthreeway)
static int	my_set_linear_mode (void *pvt, enum analog_sub sub, int linear_mode)
static void	my_set_needringing (void *pvt, int value)
static void	my_set_new_owner (void *pvt, struct ast_channel *new_owner)
static void	my_set_outgoing (void *pvt, int is_outgoing)
static void	my_set_polarity (void *pvt, int value)
static void	my_set_pulsedial (void *pvt, int flag)
static void	my_set_ringtimeout (void *pvt, int ringt)
static void	my_set_waitingfordt (void *pvt, struct ast_channel *ast)
static int	my_start (void *pvt)
static int	my_start_cid_detect (void *pvt, int cid_signalling)
static void	my_start_polarityswitch (void *pvt)
static int	my_stop_callwait (void *pvt)
static int	my_stop_cid_detect (void *pvt)
static void	my_swap_subchannels (void *pvt, enum analog_sub a, struct ast_channel *ast_a, enum analog_sub b, struct ast_channel *ast_b)
static int	my_train_echocanceller (void *pvt)
static int	my_unallocate_sub (void *pvt, enum analog_sub analogsub)
static void	my_unlock_private (void *pvt)
static int	my_wait_event (void *pvt)
static int	my_wink (void *pvt, enum analog_sub sub)
static void	notify_message (char *mailbox, int thereornot)
	Send MWI state change. More...
static int	parse_buffers_policy (const char *parse, int *num_buffers, int *policy)
static void	parse_busy_pattern (struct ast_variable *v, struct ast_dsp_busy_pattern *busy_cadence)
static int	process_dahdi (struct dahdi_chan_conf *confp, const char *cat, struct ast_variable *v, int reload, int options)
static void	process_echocancel (struct dahdi_chan_conf *confp, const char *data, unsigned int line)
static void	publish_channel_alarm (int channel, const char *alarm_txt)
static void	publish_channel_alarm_clear (int channel)
static void	publish_dahdichannel (struct ast_channel *chan, ast_group_t group, int span, const char *dahdi_channel)
	Sends a DAHDIChannel channel blob used to produce DAHDIChannel AMI messages. More...
static void	publish_dnd_state (int channel, const char *status)
static void	publish_span_alarm (int span, const char *alarm_txt)
static void	publish_span_alarm_clear (int span)
static void	release_doomed_pris (void)
static int	reload (void)
static int	reset_conf (struct dahdi_pvt *p)
static int	restart_monitor (void)
static int	restore_conference (struct dahdi_pvt *p)
static int	restore_gains (struct dahdi_pvt *p)
static int	revert_fax_buffers (struct dahdi_pvt *p, struct ast_channel *ast)
static int	save_conference (struct dahdi_pvt *p)
static int	send_callerid (struct dahdi_pvt *p)
static int	send_cwcidspill (struct dahdi_pvt *p)
static int	set_actual_gain (int fd, float rxgain, float txgain, float rxdrc, float txdrc, int law)
static int	set_actual_rxgain (int fd, float gain, float drc, int law)
static int	set_actual_txgain (int fd, float gain, float drc, int law)
static int	set_hwgain (int fd, float gain, int tx_direction)
static int	setup_dahdi (int reload)
static int	setup_dahdi_int (int reload, struct dahdi_chan_conf *default_conf, struct dahdi_chan_conf *base_conf, struct dahdi_chan_conf *conf)
static int	sigtype_to_signalling (int sigtype)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (dahdichannel_type,.to_ami=dahdichannel_to_ami,)
static void	swap_subs (struct dahdi_pvt *p, int a, int b)
static int	unalloc_sub (struct dahdi_pvt *p, int x)
static int	unload_module (void)
static void	wakeup_sub (struct dahdi_pvt *p, int a)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = tdesc , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DRIVER, .requires = "ccss", .optional_modules = "res_smdi", }
struct {
int   alarm
char *   name
}	alarms []
struct analog_callback	analog_callbacks
static struct dahdi_ring_cadence	AS_RP_cadence = {{250, 10000}}
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct dahdi_ring_cadence	cadences [NUM_CADENCE_MAX]
static int	cidrings [NUM_CADENCE_MAX]
	cidrings says in which pause to transmit the cid information, where the first pause is 1, the second pause is 2 and so on. More...
static const char	config [] = "chan_dahdi.conf"
static struct ast_cli_entry	dahdi_cli []
static struct ast_channel_tech	dahdi_tech
static struct ast_jb_conf	default_jbconf
static char	defaultcic [64] = ""
static char	defaultozz [64] = ""
static int	distinctiveringaftercid = 0
static int	dtmfcid_level = 256
static const char *const	events []
static struct ast_jb_conf	global_jbconf
static int	has_pseudo
static int	ifcount = 0
static struct dahdi_pvt *	ifend = NULL
static struct dahdi_pvt *	iflist = NULL
static ast_mutex_t	iflock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
	Protect the interface list (of dahdi_pvt's) More...
static const char *const	lbostr []
static pthread_t	monitor_thread = AST_PTHREADT_NULL
	This is the thread for the monitor which checks for input on the channels which are not currently in use. More...
static ast_mutex_t	monlock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
	Protect the monitoring thread, so only one process can kill or start it, and not when it's doing something critical. More...
static int	mwilevel = 512
static char	mwimonitornotify [PATH_MAX] = ""
static int	mwisend_rpas = 0
static int	num_cadence = 4
static int	num_restart_pending = 0
static int	numbufs = 4
static char	progzone [10] = ""
static int	report_alarms = REPORT_CHANNEL_ALARMS
static ast_mutex_t	restart_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
static int	ringt_base = DEFAULT_RINGT
	Configured ring timeout base. More...
static struct dahdi_pvt *	round_robin [32]
static ast_cond_t	ss_thread_complete
static int	ss_thread_count = 0
static ast_mutex_t	ss_thread_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
const char *const	subnames []
static const char	tdesc [] = "DAHDI Telephony"
static int	usedistinctiveringdetection = 0
static int	user_has_defined_cadences = 0

Detailed Description

DAHDI for Pseudo TDM.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Connects to the DAHDI telephony library as well as libpri. Libpri is optional and needed only if you are going to use ISDN connections.

You need to install libraries before you attempt to compile and install the DAHDI channel.

Todo:

Deprecate the "musiconhold" configuration option post 1.4

Definition in file chan_dahdi.c.

Macro Definition Documentation

ASCII_BYTES_PER_CHAR

#define ASCII_BYTES_PER_CHAR   80

Referenced by dahdi_sendtext().

AST_LAW

#define AST_LAW

(

p

)

(((p)->law == DAHDI_LAW_ALAW) ? ast_format_alaw : ast_format_ulaw)

Definition at line 521 of file chan_dahdi.c.

Referenced by analog_ss_thread(), dahdi_callwait(), dahdi_sendtext(), do_monitor(), mwi_send_init(), mwi_thread(), my_callwait(), my_get_callerid(), my_send_callerid(), and send_cwcidspill().

CALLPROGRESS_FAX

#define CALLPROGRESS_FAX   (CALLPROGRESS_FAX_INCOMING | CALLPROGRESS_FAX_OUTGOING)

Definition at line 561 of file chan_dahdi.c.

Referenced by dahdi_handle_dtmf(), my_handle_dtmf(), and process_dahdi().

CALLPROGRESS_FAX_INCOMING

#define CALLPROGRESS_FAX_INCOMING   4

Definition at line 560 of file chan_dahdi.c.

Referenced by dahdi_new(), and process_dahdi().

CALLPROGRESS_FAX_OUTGOING

#define CALLPROGRESS_FAX_OUTGOING   2

Definition at line 559 of file chan_dahdi.c.

Referenced by dahdi_new(), and process_dahdi().

CALLPROGRESS_PROGRESS

#define CALLPROGRESS_PROGRESS   1

Definition at line 558 of file chan_dahdi.c.

Referenced by dahdi_handle_event(), dahdi_new(), my_have_progressdetect(), and process_dahdi().

CALLWAITING_REPEAT_SAMPLES

#define CALLWAITING_REPEAT_SAMPLES   ((10000 * 8) / READ_SIZE)

10,000 ms

Definition at line 679 of file chan_dahdi.c.

Referenced by dahdi_callwait(), and my_callwait().

CALLWAITING_SILENT_SAMPLES

#define CALLWAITING_SILENT_SAMPLES   ((300 * 8) / READ_SIZE)

300 ms

Definition at line 678 of file chan_dahdi.c.

CALLWAITING_SUPPRESS_SAMPLES

#define CALLWAITING_SUPPRESS_SAMPLES   ((100 * 8) / READ_SIZE)

100 ms

Definition at line 680 of file chan_dahdi.c.

Referenced by send_callerid().

CANBUSYDETECT

#define CANBUSYDETECT

(

p

)

(ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __DAHDI_SIG_FXO) */)

Definition at line 593 of file chan_dahdi.c.

Referenced by dahdi_new().

CANPROGRESSDETECT

#define CANPROGRESSDETECT

(

p

)

(ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __DAHDI_SIG_FXO) */)

Definition at line 594 of file chan_dahdi.c.

Referenced by dahdi_handle_event(), dahdi_new(), my_have_progressdetect(), and my_set_waitingfordt().

CHAN_PSEUDO

#define CHAN_PSEUDO   -2

Definition at line 556 of file chan_dahdi.c.

Referenced by available(), build_channels(), create_channel_name(), dahdi_ami_channel_event(), dahdi_dtmf_detect_enable(), dahdi_new(), dahdi_request(), determine_starting_point(), mkintf(), my_dsp_set_digitmode(), my_set_polarity(), and process_dahdi().

CIDCW_EXPIRE_SAMPLES

#define CIDCW_EXPIRE_SAMPLES   ((500 * 8) / READ_SIZE)

500 ms

Definition at line 681 of file chan_dahdi.c.

Referenced by send_callerid().

DEFAULT_CIDRINGS

#define DEFAULT_CIDRINGS   1

Typically, how many rings before we should send Caller*ID.

Note

Define ZHONE_HACK to cause us to go off hook and then back on hook when the user hangs up to reset the state machine so ring works properly. This is used to be able to support kewlstart by putting the zhone in groundstart mode since their forward disconnect supervision is entirely broken even though their documentation says it isn't and their support is entirely unwilling to provide any assistance with their channel banks even though their web site says they support their products for life.

Definition at line 519 of file chan_dahdi.c.

Referenced by dahdi_chan_conf_default().

DEFAULT_DIALTONE_DETECT_TIMEOUT

#define DEFAULT_DIALTONE_DETECT_TIMEOUT   ((10000 * 8) / READ_SIZE)

10,000 ms

Definition at line 684 of file chan_dahdi.c.

Referenced by process_dahdi().

DEFAULT_RINGT

#define DEFAULT_RINGT   ((8000 * 8) / READ_SIZE)

8,000 ms

Definition at line 683 of file chan_dahdi.c.

END_SILENCE_LEN

#define END_SILENCE_LEN   400

Referenced by dahdi_sendtext().

FORMAT [1/2]

#define FORMAT   "%7s %-15.15s %-15.15s %-10.10s %-20.20s %-10.10s %-10.10s %-32.32s\n"

Referenced by action_dahdishowchannels(), dahdi_cc_callback(), dahdi_show_channels(), and dahdi_show_status().

FORMAT [2/2]

#define FORMAT   "%-40.40s %-7.7s %-6d %-6d %-6d %-3.3s %-4.4s %-8.8s %s\n"

FORMAT2 [1/2]

#define FORMAT2   "%7s %-15.15s %-15.15s %-10.10s %-20.20s %-10.10s %-10.10s %-32.32s\n"

Referenced by action_dahdishowchannels(), dahdi_show_channels(), and dahdi_show_status().

FORMAT2 [2/2]

#define FORMAT2   "%-40.40s %-7.7s %-6.6s %-6.6s %-6.6s %-3.3s %-4.4s %-8.8s %s\n"

gen_pvt_field_callback

#define gen_pvt_field_callback	(		type,
			field
	)

Value:

static type my_get_##field(void *pvt) \
 { \
 struct dahdi_pvt *p = pvt; \
 return p->field; \
 }

Definition at line 3342 of file chan_dahdi.c.

GET_CHANNEL

#define GET_CHANNEL

(

p

)

((p)->channel)

Definition at line 1053 of file chan_dahdi.c.

Referenced by dahdi_conf_update(), and my_complete_conference_update().

HANGUP

#define HANGUP   1

Definition at line 16235 of file chan_dahdi.c.

Referenced by action_transferhangup(), and dahdi_fake_event().

HEADER_LEN

#define HEADER_LEN   ((HEADER_MS + TRAILER_MS) * 8)

Referenced by build_alerting(), build_connect(), build_connect_acknowledge(), build_disconnect(), build_facility(), build_information(), build_notify(), build_proceeding(), build_progress(), build_release(), build_release_complete(), build_restart(), build_retrieve_acknowledge(), build_setup(), build_setup_acknowledge(), dahdi_sendtext(), parse_alerting(), parse_connect(), parse_disconnect(), parse_facility(), parse_information(), parse_notify(), parse_proceeding(), parse_progress(), parse_release(), parse_release_complete(), parse_restart(), parse_setup(), parse_setup_acknowledge(), and parse_status().

HEADER_MS

#define HEADER_MS   50

Referenced by dahdi_sendtext().

ISTRUNK

#define ISTRUNK

(

p

)

Value:

((p->sig == SIG_FXSLS) || (p->sig == SIG_FXSKS) || \
 (p->sig == SIG_FXSGS) || (p->sig == SIG_PRI))

Definition at line 590 of file chan_dahdi.c.

Referenced by analog_ss_thread(), and dahdi_indicate().

MASK_AVAIL

#define MASK_AVAIL   (1 << 0)

Channel available for PRI use

Definition at line 675 of file chan_dahdi.c.

MASK_INUSE

#define MASK_INUSE   (1 << 1)

Channel currently in use

Definition at line 676 of file chan_dahdi.c.

MAX_CHANLIST_LEN

#define MAX_CHANLIST_LEN   80

The length of the parameters list of 'dahdichan'.

Todo:

Move definition of MAX_CHANLIST_LEN to a proper place.

Definition at line 17726 of file chan_dahdi.c.

MIN_MS_SINCE_FLASH

#define MIN_MS_SINCE_FLASH   ((2000) )

2000 ms

Definition at line 682 of file chan_dahdi.c.

Referenced by dahdi_handle_event().

NEED_MFDETECT

#define NEED_MFDETECT

(

p

)

(((p)->sig == SIG_FEATDMF) || ((p)->sig == SIG_FEATDMF_TA) || ((p)->sig == SIG_E911) || ((p)->sig == SIG_FGC_CAMA) || ((p)->sig == SIG_FGC_CAMAMF) || ((p)->sig == SIG_FEATB))

Signaling types that need to use MF detection should be placed in this macro.

Definition at line 525 of file chan_dahdi.c.

Referenced by analog_ss_thread(), and dahdi_new().

NUM_CADENCE_MAX

#define NUM_CADENCE_MAX   25

Definition at line 563 of file chan_dahdi.c.

Referenced by process_dahdi().

NUM_SPANS

#define NUM_SPANS   32

Definition at line 553 of file chan_dahdi.c.

Referenced by __unload_module(), action_dahdishowchannels(), dahdi_cc_callback(), dahdi_create_channel_range(), dahdi_restart(), destroy_all_channels(), load_module(), mkintf(), my_on_hook(), restart_monitor(), setup_dahdi_int(), and unload_module().

POLARITY_IDLE

#define POLARITY_IDLE   0

Definition at line 792 of file chan_dahdi.c.

Referenced by analog_ss_thread(), dahdi_handle_event(), dahdi_hangup(), and unalloc_sub().

POLARITY_REV

#define POLARITY_REV   1

Definition at line 793 of file chan_dahdi.c.

Referenced by analog_ss_thread(), dahdi_handle_event(), and handle_init_event().

PROC_DAHDI_OPT_NOCHAN

#define PROC_DAHDI_OPT_NOCHAN   (1 << 0)

process_dahdi() - ignore keyword 'channel' and similar

Definition at line 17861 of file chan_dahdi.c.

Referenced by process_dahdi(), and setup_dahdi_int().

PROC_DAHDI_OPT_NOWARN

#define PROC_DAHDI_OPT_NOWARN   (1 << 1)

process_dahdi() - No warnings on non-existing cofiguration keywords

Definition at line 17863 of file chan_dahdi.c.

Referenced by process_dahdi(), and setup_dahdi_int().

READ_SIZE

#define READ_SIZE   160

Chunk size to read – we use 20ms chunks to make things happy.

Definition at line 673 of file chan_dahdi.c.

Referenced by dahdi_callwait(), dahdi_open(), dahdi_read(), dahdi_sendtext(), dahdi_setoption(), my_callwait(), my_dahdi_write(), my_send_callerid(), process_dahdi(), and send_cwcidspill().

REPORT_CHANNEL_ALARMS

#define REPORT_CHANNEL_ALARMS   1

Definition at line 615 of file chan_dahdi.c.

Referenced by handle_alarms(), handle_clear_alarms(), and process_dahdi().

REPORT_SPAN_ALARMS

#define REPORT_SPAN_ALARMS   2

Definition at line 616 of file chan_dahdi.c.

Referenced by handle_alarms(), handle_clear_alarms(), and process_dahdi().

sig2str

#define sig2str   dahdi_sig2str

Definition at line 4455 of file chan_dahdi.c.

Referenced by action_dahdishowchannels(), analog_ss_thread(), build_channels(), dahdi_handle_event(), dahdi_show_channel(), handle_init_event(), and mkintf().

SMDI_MD_WAIT_TIMEOUT

#define SMDI_MD_WAIT_TIMEOUT   1500 /* 1.5 seconds */

Definition at line 482 of file chan_dahdi.c.

Referenced by analog_ss_thread().

TRAILER_MS

#define TRAILER_MS   5

Referenced by dahdi_sendtext().

TRANSFER

#define TRANSFER   0

Definition at line 16234 of file chan_dahdi.c.

Referenced by action_transfer(), and dahdi_fake_event().

Function Documentation

__dahdi_exception()

static struct ast_frame* __dahdi_exception ( struct ast_channel *  ast )

static

Definition at line 8281 of file chan_dahdi.c.

References ast_channel_fd(), ast_channel_lock, ast_channel_name(), ast_channel_tech_pvt(), ast_channel_unlock, ast_debug, AST_FRAME_NULL, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_queue_unhold(), ast_set_hangupsource(), ast_setstate(), AST_STATE_RINGING, AST_STATE_UP, ast_strdupa, ast_tv(), ast_tvnow(), ast_verb, dahdi_pvt::callwaitingrepeat, dahdi_pvt::channel, dahdi_pvt::cid_suppress_expire, dahdi_pvt::cidcwexpire, dahdi_conf_update(), dahdi_ec_disable(), dahdi_ec_enable(), dahdi_get_event(), dahdi_get_index, dahdi_handle_event(), dahdi_ring_phone(), dahdi_set_hook(), ast_frame::data, ast_frame::datalen, ast_frame::delivery, dahdi_subchannel::dfd, dahdi_pvt::dialing, event2str(), dahdi_subchannel::f, dahdi_pvt::fake_event, dahdi_pvt::flashtime, ast_frame::frametype, ast_frame_subclass::integer, dahdi_pvt::lock, LOG_WARNING, ast_frame::mallocd, name, dahdi_subchannel::needanswer, dahdi_subchannel::needunhold, NULL, ast_frame::offset, dahdi_pvt::oprmode, dahdi_subchannel::owner, dahdi_pvt::owner, ast_frame::ptr, dahdi_pvt::radio, ast_frame::samples, ast_frame::src, SUB_REAL, ast_frame::subclass, and dahdi_pvt::subs.

Referenced by dahdi_exception(), and dahdi_read().

{
 int res;
 int idx;
 struct ast_frame *f;
 int usedindex = -1;
 struct dahdi_pvt *p = ast_channel_tech_pvt(ast);

 if ((idx = dahdi_get_index(ast, p, 0)) < 0) {
 idx = SUB_REAL;
 }

 p->subs[idx].f.frametype = AST_FRAME_NULL;
 p->subs[idx].f.datalen = 0;
 p->subs[idx].f.samples = 0;
 p->subs[idx].f.mallocd = 0;
 p->subs[idx].f.offset = 0;
 p->subs[idx].f.subclass.integer = 0;
 p->subs[idx].f.delivery = ast_tv(0,0);
 p->subs[idx].f.src = "dahdi_exception";
 p->subs[idx].f.data.ptr = NULL;


 if ((!p->owner) && (!(p->radio || (p->oprmode < 0)))) {
 /* If nobody owns us, absorb the event appropriately, otherwise
 we loop indefinitely. This occurs when, during call waiting, the
 other end hangs up our channel so that it no longer exists, but we
 have neither FLASH'd nor ONHOOK'd to signify our desire to
 change to the other channel. */
 if (p->fake_event) {
 res = p->fake_event;
 p->fake_event = 0;
 } else
 res = dahdi_get_event(p->subs[SUB_REAL].dfd);
 /* Switch to real if there is one and this isn't something really silly... */
 if ((res != DAHDI_EVENT_RINGEROFF) && (res != DAHDI_EVENT_RINGERON) &&
 (res != DAHDI_EVENT_HOOKCOMPLETE)) {
 ast_debug(1, "Restoring owner of channel %d on event %d\n", p->channel, res);
 p->owner = p->subs[SUB_REAL].owner;
 if (p->owner) {
 ast_queue_unhold(p->owner);
 }
 p->subs[SUB_REAL].needunhold = 1;
 }
 switch (res) {
 case DAHDI_EVENT_ONHOOK:
 dahdi_ec_disable(p);
 if (p->owner) {
 ast_verb(3, "Channel %s still has call, ringing phone\n", ast_channel_name(p->owner));
 dahdi_ring_phone(p);
 p->callwaitingrepeat = 0;
 p->cidcwexpire = 0;
 p->cid_suppress_expire = 0;
 } else
 ast_log(LOG_WARNING, "Absorbed on hook, but nobody is left!?!?\n");
 dahdi_conf_update(p);
 break;
 case DAHDI_EVENT_RINGOFFHOOK:
 dahdi_ec_enable(p);
 dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK);
 if (p->owner && (ast_channel_state(p->owner) == AST_STATE_RINGING)) {
 p->subs[SUB_REAL].needanswer = 1;
 p->dialing = 0;
 }
 break;
 case DAHDI_EVENT_HOOKCOMPLETE:
 case DAHDI_EVENT_RINGERON:
 case DAHDI_EVENT_RINGEROFF:
 /* Do nothing */
 break;
 case DAHDI_EVENT_WINKFLASH:
 p->flashtime = ast_tvnow();
 if (p->owner) {
 ast_verb(3, "Channel %d flashed to other channel %s\n", p->channel, ast_channel_name(p->owner));
 if (ast_channel_state(p->owner) != AST_STATE_UP) {
 /* Answer if necessary */
 usedindex = dahdi_get_index(p->owner, p, 0);
 if (usedindex > -1) {
 p->subs[usedindex].needanswer = 1;
 }
 ast_setstate(p->owner, AST_STATE_UP);
 }
 p->callwaitingrepeat = 0;
 p->cidcwexpire = 0;
 p->cid_suppress_expire = 0;
 ast_queue_unhold(p->owner);
 p->subs[SUB_REAL].needunhold = 1;
 } else
 ast_log(LOG_WARNING, "Absorbed on hook, but nobody is left!?!?\n");
 dahdi_conf_update(p);
 break;
 default:
 ast_log(LOG_WARNING, "Don't know how to absorb event %s\n", event2str(res));
 }
 f = &p->subs[idx].f;
 return f;
 }
 if (!(p->radio || (p->oprmode < 0)))
 ast_debug(1, "Exception on %d, channel %d\n", ast_channel_fd(ast, 0), p->channel);
 /* If it's not us, return NULL immediately */
 if (ast != p->owner) {
 if (p->owner) {
 ast_log(LOG_WARNING, "We're %s, not %s\n", ast_channel_name(ast), ast_channel_name(p->owner));
 }
 f = &p->subs[idx].f;
 return f;
 }

 f = dahdi_handle_event(ast);
 if (!f) {
 const char *name = ast_strdupa(ast_channel_name(ast));

 /* Tell the CDR this DAHDI device hung up */
 ast_mutex_unlock(&p->lock);
 ast_channel_unlock(ast);
 ast_set_hangupsource(ast, name, 0);
 ast_channel_lock(ast);
 ast_mutex_lock(&p->lock);
 }
 return f;
}

__reg_module()

static void __reg_module ( void  )

static

Definition at line 19922 of file chan_dahdi.c.

__unload_module()

static int __unload_module ( void  )

static

Definition at line 17540 of file chan_dahdi.c.

References ao2_cleanup, ARRAY_LEN, ast_cc_agent_unregister(), ast_cc_monitor_unregister(), ast_channel_unregister(), ast_cli_unregister_multiple(), ast_cond_destroy, ast_manager_unregister(), ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, AST_PTHREADT_STOP, ast_softhangup(), AST_SOFTHANGUP_APPUNLOAD, ast_unregister_application(), ast_channel_tech::capabilities, dahdi_native_unload(), destroy_all_channels(), iflock, sig_pri_span::master, monitor_thread, monlock, dahdi_pvt::next, NULL, NUM_SPANS, dahdi_pvt::owner, SIG_PRI_NUM_DCHANS, sig_pri_stop_pri(), sig_pri_unload(), SIG_SS7_NUM_DCHANS, ss_thread_complete, and STASIS_MESSAGE_TYPE_CLEANUP.

Referenced by load_module(), and unload_module().

{
 struct dahdi_pvt *p;
#if defined(HAVE_PRI) || defined(HAVE_SS7)
 int i, j;
#endif /* defined(HAVE_PRI) || defined(HAVE_SS7) */

#ifdef HAVE_PRI
 for (i = 0; i < NUM_SPANS; i++) {
 if (pris[i].pri.master != AST_PTHREADT_NULL) {
 pthread_cancel(pris[i].pri.master);
 pthread_kill(pris[i].pri.master, SIGURG);
 }
 }
 ast_cli_unregister_multiple(dahdi_pri_cli, ARRAY_LEN(dahdi_pri_cli));
 ast_unregister_application(dahdi_send_keypad_facility_app);
#ifdef HAVE_PRI_PROG_W_CAUSE
 ast_unregister_application(dahdi_send_callrerouting_facility_app);
#endif
#endif
#if defined(HAVE_SS7)
 for (i = 0; i < NUM_SPANS; i++) {
 if (linksets[i].ss7.master != AST_PTHREADT_NULL) {
 pthread_cancel(linksets[i].ss7.master);
 pthread_kill(linksets[i].ss7.master, SIGURG);
 }
 }
 ast_cli_unregister_multiple(dahdi_ss7_cli, ARRAY_LEN(dahdi_ss7_cli));
#endif /* defined(HAVE_SS7) */
#if defined(HAVE_OPENR2)
 dahdi_r2_destroy_links();
 ast_cli_unregister_multiple(dahdi_mfcr2_cli, ARRAY_LEN(dahdi_mfcr2_cli));
 ast_unregister_application(dahdi_accept_r2_call_app);
#endif

 ast_cli_unregister_multiple(dahdi_cli, ARRAY_LEN(dahdi_cli));
 ast_manager_unregister("DAHDIDialOffhook");
 ast_manager_unregister("DAHDIHangup");
 ast_manager_unregister("DAHDITransfer");
 ast_manager_unregister("DAHDIDNDoff");
 ast_manager_unregister("DAHDIDNDon");
 ast_manager_unregister("DAHDIShowChannels");
 ast_manager_unregister("DAHDIRestart");
#if defined(HAVE_PRI)
 ast_manager_unregister("PRIShowSpans");
 ast_manager_unregister("PRIDebugSet");
 ast_manager_unregister("PRIDebugFileSet");
 ast_manager_unregister("PRIDebugFileUnset");
#endif /* defined(HAVE_PRI) */
 ast_channel_unregister(&dahdi_tech);

 /* Hangup all interfaces if they have an owner */
 ast_mutex_lock(&iflock);
 for (p = iflist; p; p = p->next) {
 if (p->owner)
 ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
 }
 ast_mutex_unlock(&iflock);

 ast_mutex_lock(&monlock);
 if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP) && (monitor_thread != AST_PTHREADT_NULL)) {
 pthread_cancel(monitor_thread);
 pthread_kill(monitor_thread, SIGURG);
 pthread_join(monitor_thread, NULL);
 }
 monitor_thread = AST_PTHREADT_STOP;
 ast_mutex_unlock(&monlock);

 destroy_all_channels();

#if defined(HAVE_PRI)
 for (i = 0; i < NUM_SPANS; i++) {
 if (pris[i].pri.master && (pris[i].pri.master != AST_PTHREADT_NULL)) {
 pthread_join(pris[i].pri.master, NULL);
 }
 for (j = 0; j < SIG_PRI_NUM_DCHANS; j++) {
 dahdi_close_pri_fd(&(pris[i]), j);
 }
 sig_pri_stop_pri(&pris[i].pri);
 }
#if defined(HAVE_PRI_CCSS)
 ast_cc_agent_unregister(&dahdi_pri_cc_agent_callbacks);
 ast_cc_monitor_unregister(&dahdi_pri_cc_monitor_callbacks);
#endif /* defined(HAVE_PRI_CCSS) */
 sig_pri_unload();
#endif

#if defined(HAVE_SS7)
 for (i = 0; i < NUM_SPANS; i++) {
 if (linksets[i].ss7.master && (linksets[i].ss7.master != AST_PTHREADT_NULL)) {
 pthread_join(linksets[i].ss7.master, NULL);
 }
 for (j = 0; j < SIG_SS7_NUM_DCHANS; j++) {
 dahdi_close_ss7_fd(&(linksets[i]), j);
 }
 if (linksets[i].ss7.ss7) {
 ss7_destroy(linksets[i].ss7.ss7);
 linksets[i].ss7.ss7 = NULL;
 }
 }
#endif /* defined(HAVE_SS7) */
 ast_cond_destroy(&ss_thread_complete);

 dahdi_native_unload();

 ao2_cleanup(dahdi_tech.capabilities);
 dahdi_tech.capabilities = NULL;
 STASIS_MESSAGE_TYPE_CLEANUP(dahdichannel_type);
 return 0;
}

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 19922 of file chan_dahdi.c.

_dahdi_get_index()

int _dahdi_get_index	(	struct ast_channel *	ast,
		struct dahdi_pvt *	p,
		int	nullok,
		const char *	fname,
		unsigned long	line
	)

Definition at line 3431 of file chan_dahdi.c.

References ast_channel_name(), ast_log, dahdi_pvt::channel, LOG_WARNING, dahdi_subchannel::owner, SUB_CALLWAIT, SUB_REAL, SUB_THREEWAY, and dahdi_pvt::subs.

{
 int res;
 if (p->subs[SUB_REAL].owner == ast)
 res = 0;
 else if (p->subs[SUB_CALLWAIT].owner == ast)
 res = 1;
 else if (p->subs[SUB_THREEWAY].owner == ast)
 res = 2;
 else {
 res = -1;
 if (!nullok)
 ast_log(LOG_WARNING,
 "Unable to get index for '%s' on channel %d (%s(), line %lu)\n",
 ast ? ast_channel_name(ast) : "", p->channel, fname, line);
 }
 return res;
}

action_dahdidialoffhook()

static int action_dahdidialoffhook ( struct mansession *  s, const struct message *  m  )

static

Definition at line 16372 of file chan_dahdi.c.

References AST_FRAME_DTMF, ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), dahdi_queue_frame(), find_channel_from_str(), and dahdi_pvt::owner.

Referenced by load_module().

{
 struct dahdi_pvt *p;
 const char *channel = astman_get_header(m, "DAHDIChannel");
 const char *number = astman_get_header(m, "Number");
 int i;

 if (ast_strlen_zero(channel)) {
 astman_send_error(s, m, "No channel specified");
 return 0;
 }
 if (ast_strlen_zero(number)) {
 astman_send_error(s, m, "No number specified");
 return 0;
 }
 p = find_channel_from_str(channel);
 if (!p) {
 astman_send_error(s, m, "No such channel");
 return 0;
 }
 if (!p->owner) {
 astman_send_error(s, m, "Channel does not have it's owner");
 return 0;
 }
 for (i = 0; i < strlen(number); i++) {
 struct ast_frame f = { AST_FRAME_DTMF, .subclass.integer = number[i] };
 dahdi_queue_frame(p, &f);
 }
 astman_send_ack(s, m, "DAHDIDialOffhook");
 return 0;
}

action_dahdidndoff()

static int action_dahdidndoff ( struct mansession *  s, const struct message *  m  )

static

Definition at line 16307 of file chan_dahdi.c.

References ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), dahdi_dnd(), and find_channel_from_str().

Referenced by load_module().

{
 struct dahdi_pvt *p;
 const char *channel = astman_get_header(m, "DAHDIChannel");

 if (ast_strlen_zero(channel)) {
 astman_send_error(s, m, "No channel specified");
 return 0;
 }
 p = find_channel_from_str(channel);
 if (!p) {
 astman_send_error(s, m, "No such channel");
 return 0;
 }
 dahdi_dnd(p, 0);
 astman_send_ack(s, m, "DND Disabled");
 return 0;
}

action_dahdidndon()

static int action_dahdidndon ( struct mansession *  s, const struct message *  m  )

static

Definition at line 16288 of file chan_dahdi.c.

References ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), dahdi_dnd(), and find_channel_from_str().

Referenced by load_module().

{
 struct dahdi_pvt *p;
 const char *channel = astman_get_header(m, "DAHDIChannel");

 if (ast_strlen_zero(channel)) {
 astman_send_error(s, m, "No channel specified");
 return 0;
 }
 p = find_channel_from_str(channel);
 if (!p) {
 astman_send_error(s, m, "No such channel");
 return 0;
 }
 dahdi_dnd(p, 1);
 astman_send_ack(s, m, "DND Enabled");
 return 0;
}

action_dahdirestart()

static int action_dahdirestart ( struct mansession *  s, const struct message *  m  )

static

Definition at line 15562 of file chan_dahdi.c.

References astman_send_ack(), astman_send_error(), and dahdi_restart().

Referenced by load_module().

{
 if (dahdi_restart() != 0) {
 astman_send_error(s, m, "Failed rereading DAHDI configuration");
 return 1;
 }
 astman_send_ack(s, m, "DAHDIRestart: Success");
 return 0;
}

action_dahdishowchannels()

static int action_dahdishowchannels ( struct mansession *  s, const struct message *  m  )

static

Definition at line 16404 of file chan_dahdi.c.

References alarm2str(), ast_cli_args::argc, ast_cli_args::argv, ARRAY_LEN, ast_assert, ast_channel_accountcode(), ast_channel_name(), ast_channel_tech(), ast_channel_tech_pvt(), ast_channel_uniqueid(), ast_cli(), AST_CLI_DEFINE, ast_log, ast_module_ref, ast_module_unref, ast_mutex_lock, ast_mutex_unlock, AST_PTHREADT_NULL, ast_strlen_zero, astman_append(), astman_get_header(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), sig_ss7_linkset::called_nai, sig_ss7_linkset::calling_nai, sig_ss7_chan::chan_pvt, sig_ss7_chan::channel, dahdi_pvt::channel, sig_ss7_chan::cic, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, dahdi_pvt::context, dahdi_dnd(), dahdi_sig_pri_lib_handles(), dahdi_pvt::description, sig_ss7_chan::dpc, errno, ast_cli_args::fd, sig_ss7_linkset::flags, FORMAT, FORMAT2, get_alarms(), iflock, dahdi_pvt::inservice, sig_ss7_linkset::internationalprefix, sig_ss7_linkset::LINKSET_STATE_UP, dahdi_pvt::locallyblocked, LOG_ERROR, sig_ss7_linkset::nationalprefix, sig_ss7_linkset::networkroutedprefix, dahdi_pvt::next, NULL, NUM_SPANS, sig_ss7_linkset::numchans, dahdi_pvt::owner, sig_ss7_chan::owner, sig_ss7_linkset::pvts, dahdi_pvt::remotelyblocked, ast_module_info::self, dahdi_pvt::sig, sig2str, sig_pri_ami_show_spans(), sig_pri_cc_agent_callee_available(), sig_pri_cc_agent_destructor(), sig_pri_cc_agent_init(), sig_pri_cc_agent_party_b_free(), sig_pri_cc_agent_req_rsp(), sig_pri_cc_agent_start_monitoring(), sig_pri_cc_agent_start_offer_timer(), sig_pri_cc_agent_status_req(), sig_pri_cc_agent_stop_offer_timer(), sig_pri_cc_agent_stop_ringing(), sig_pri_cc_monitor_cancel_available_timer(), sig_pri_cc_monitor_destructor(), sig_pri_cc_monitor_req_cc(), sig_pri_cc_monitor_status_rsp(), sig_pri_cc_monitor_suspend(), sig_pri_cc_monitor_unsuspend(), dahdi_pvt::sig_pvt, sig_ss7_add_sigchan(), sig_ss7_cic_blocking(), sig_ss7_cli_show_channels(), sig_ss7_cli_show_channels_header(), SIG_SS7_DEBUG, sig_ss7_find_cic(), sig_ss7_find_cic_range(), sig_ss7_group_blocking(), SIG_SS7_NUM_DCHANS, sig_ss7_reset_cic(), sig_ss7_reset_group(), sig_ss7_linkset::ss7, SS7_BLOCKED_HARDWARE, SS7_BLOCKED_MAINTENANCE, sig_ss7_chan::ss7call, sig_ss7_linkset::state, state, sig_ss7_linkset::subscriberprefix, tmp(), type, ast_cc_monitor_callbacks::type, ast_cc_agent_callbacks::type, sig_ss7_linkset::unknownprefix, and ast_cli_entry::usage.

Referenced by load_module().

{
 struct dahdi_pvt *tmp = NULL;
 const char *id = astman_get_header(m, "ActionID");
 const char *dahdichannel = astman_get_header(m, "DAHDIChannel");
 char idText[256];
 int channels = 0;
 int dahdichanquery;

 if (!dahdichannel || sscanf(dahdichannel, "%30d", &dahdichanquery) != 1) {
 /* Not numeric string. */
 dahdichanquery = -1;
 }

 idText[0] = '\0';
 if (!ast_strlen_zero(id)) {
 snprintf(idText, sizeof(idText), "ActionID: %s\r\n", id);
 }

 astman_send_listack(s, m, "DAHDI channel status will follow", "start");

 ast_mutex_lock(&iflock);

 for (tmp = iflist; tmp; tmp = tmp->next) {
 if (tmp->channel > 0) {
 int alm;

 /* If a specific channel is queried for, only deliver status for that channel */
 if (dahdichanquery > 0 && tmp->channel != dahdichanquery)
 continue;

 alm = get_alarms(tmp);
 channels++;
 if (tmp->owner) {
 /* Add data if we have a current call */
 astman_append(s,
 "Event: DAHDIShowChannels\r\n"
 "DAHDIChannel: %d\r\n"
 "Channel: %s\r\n"
 "Uniqueid: %s\r\n"
 "AccountCode: %s\r\n"
 "Signalling: %s\r\n"
 "SignallingCode: %d\r\n"
 "Context: %s\r\n"
 "DND: %s\r\n"
 "Alarm: %s\r\n"
 "Description: %s\r\n"
 "%s"
 "\r\n",
 tmp->channel,
 ast_channel_name(tmp->owner),
 ast_channel_uniqueid(tmp->owner),
 ast_channel_accountcode(tmp->owner),
 sig2str(tmp->sig),
 tmp->sig,
 tmp->context,
 dahdi_dnd(tmp, -1) ? "Enabled" : "Disabled",
 alarm2str(alm),
 tmp->description, idText);
 } else {
 astman_append(s,
 "Event: DAHDIShowChannels\r\n"
 "DAHDIChannel: %d\r\n"
 "Signalling: %s\r\n"
 "SignallingCode: %d\r\n"
 "Context: %s\r\n"
 "DND: %s\r\n"
 "Alarm: %s\r\n"
 "Description: %s\r\n"
 "%s"
 "\r\n",
 tmp->channel, sig2str(tmp->sig), tmp->sig,
 tmp->context,
 dahdi_dnd(tmp, -1) ? "Enabled" : "Disabled",
 alarm2str(alm),
 tmp->description, idText);
 }
 }
 }

 ast_mutex_unlock(&iflock);

 astman_send_list_complete_start(s, m, "DAHDIShowChannelsComplete", channels);
 astman_append(s, "Items: %d\r\n", channels);
 astman_send_list_complete_end(s);
 return 0;
}

action_transfer()

static int action_transfer ( struct mansession *  s, const struct message *  m  )

static

Definition at line 16326 of file chan_dahdi.c.

References ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), dahdi_analog_lib_handles(), dahdi_fake_event(), find_channel_from_str(), dahdi_pvt::sig, and TRANSFER.

Referenced by load_module().

{
 struct dahdi_pvt *p;
 const char *channel = astman_get_header(m, "DAHDIChannel");

 if (ast_strlen_zero(channel)) {
 astman_send_error(s, m, "No channel specified");
 return 0;
 }
 p = find_channel_from_str(channel);
 if (!p) {
 astman_send_error(s, m, "No such channel");
 return 0;
 }
 if (!dahdi_analog_lib_handles(p->sig, 0, 0)) {
 astman_send_error(s, m, "Channel signaling is not analog");
 return 0;
 }
 dahdi_fake_event(p,TRANSFER);
 astman_send_ack(s, m, "DAHDITransfer");
 return 0;
}

action_transferhangup()

static int action_transferhangup ( struct mansession *  s, const struct message *  m  )

static

Definition at line 16349 of file chan_dahdi.c.

References ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), dahdi_analog_lib_handles(), dahdi_fake_event(), find_channel_from_str(), HANGUP, and dahdi_pvt::sig.

Referenced by load_module().

{
 struct dahdi_pvt *p;
 const char *channel = astman_get_header(m, "DAHDIChannel");

 if (ast_strlen_zero(channel)) {
 astman_send_error(s, m, "No channel specified");
 return 0;
 }
 p = find_channel_from_str(channel);
 if (!p) {
 astman_send_error(s, m, "No such channel");
 return 0;
 }
 if (!dahdi_analog_lib_handles(p->sig, 0, 0)) {
 astman_send_error(s, m, "Channel signaling is not analog");
 return 0;
 }
 dahdi_fake_event(p,HANGUP);
 astman_send_ack(s, m, "DAHDIHangup");
 return 0;
}

alarm2str()

static char* alarm2str ( int  alm )

static

Definition at line 4372 of file chan_dahdi.c.

References alarm, alarms, and ARRAY_LEN.

Referenced by action_dahdishowchannels(), and handle_alarms().

{
 int x;
 for (x = 0; x < ARRAY_LEN(alarms); x++) {
 if (alarms[x].alarm & alm)
 return alarms[x].name;
 }
 return alm ? "Unknown Alarm" : "No Alarm";
}

alloc_sub()

static int alloc_sub ( struct dahdi_pvt *  p, int  x  )

static

Definition at line 4167 of file chan_dahdi.c.

References ast_debug, ast_log, dahdi_pvt::buf_no, dahdi_pvt::buf_policy, dahdi_subchannel::chan, dahdi_pvt::channel, dahdi_close_sub(), dahdi_open(), dahdi_subchannel::dfd, errno, LOG_WARNING, subnames, and dahdi_pvt::subs.

Referenced by analog_ss_thread(), dahdi_handle_event(), my_allocate_sub(), and my_unallocate_sub().

{
 struct dahdi_bufferinfo bi;
 int res;
 if (p->subs[x].dfd >= 0) {
 ast_log(LOG_WARNING, "%s subchannel of %d already in use\n", subnames[x], p->channel);
 return -1;
 }

 p->subs[x].dfd = dahdi_open("/dev/dahdi/pseudo");
 if (p->subs[x].dfd <= -1) {
 ast_log(LOG_WARNING, "Unable to open pseudo channel: %s\n", strerror(errno));
 return -1;
 }

 res = ioctl(p->subs[x].dfd, DAHDI_GET_BUFINFO, &bi);
 if (!res) {
 bi.txbufpolicy = p->buf_policy;
 bi.rxbufpolicy = p->buf_policy;
 bi.numbufs = p->buf_no;
 res = ioctl(p->subs[x].dfd, DAHDI_SET_BUFINFO, &bi);
 if (res < 0) {
 ast_log(LOG_WARNING, "Unable to set buffer policy on channel %d: %s\n", x, strerror(errno));
 }
 } else
 ast_log(LOG_WARNING, "Unable to check buffer policy on channel %d: %s\n", x, strerror(errno));

 if (ioctl(p->subs[x].dfd, DAHDI_CHANNO, &p->subs[x].chan) == 1) {
 ast_log(LOG_WARNING, "Unable to get channel number for pseudo channel on FD %d: %s\n", p->subs[x].dfd, strerror(errno));
 dahdi_close_sub(p, x);
 p->subs[x].dfd = -1;
 return -1;
 }
 ast_debug(1, "Allocated %s subchannel on FD %d channel %d\n", subnames[x], p->subs[x].dfd, p->subs[x].chan);
 return 0;
}

analog_ss_thread()

static void * analog_ss_thread ( void *  data )

static

Definition at line 9512 of file chan_dahdi.c.

References alloc_sub(), ao2_cleanup, ao2_ref, ARRAY_LEN, ast_canmatch_extension(), ast_channel_bridge_peer(), ast_channel_caller(), ast_channel_cleanup, ast_channel_context(), ast_channel_context_set(), ast_channel_exten_set(), ast_channel_flags(), ast_channel_get_bridge_channel(), ast_channel_language(), ast_channel_lock, ast_channel_name(), ast_channel_rings_set(), ast_channel_tech(), ast_channel_tech_pvt(), ast_channel_unlock, ast_clear_flag, ast_cond_signal, ast_copy_string(), ast_debug, ast_dsp_digitreset(), ast_dsp_free(), ast_dsp_set_digitmode(), ast_exists_extension(), AST_FLAG_END_DTMF_ONLY, AST_FRAME_DTMF, ast_frfree, ast_get_chan_features_pickup_config(), ast_hangup(), ast_ignore_pattern(), AST_LAW, ast_log, ast_matchmore_extension(), AST_MAX_EXTENSION, ast_mutex_lock, ast_mutex_unlock, ast_parking_blind_transfer_park(), ast_parking_is_exten_park(), ast_parking_provider_registered(), ast_party_name_free(), ast_party_name_init(), ast_party_number_free(), ast_party_number_init(), ast_pbx_run(), ast_pickup_call(), ast_queue_unhold(), ast_read(), ast_remaining_ms(), ast_safe_sleep(), ast_set_callerid(), ast_set_flag, ast_setstate(), ast_shrink_phone_number(), ast_smdi_md_message_wait(), AST_STATE_PRERING, AST_STATE_RING, AST_STATE_RINGING, ast_strdupa, ast_streamfile(), ast_strlen_zero, ast_tvnow(), ast_verb, ast_waitfor(), ast_waitfordigit(), ast_waitstream(), buf, bump_gains(), dahdi_pvt::call_forward, callerid_feed(), callerid_feed_jp(), callerid_free(), callerid_get(), callerid_get_dtmf(), callerid_new(), ast_smdi_md_message::calling_st, dahdi_pvt::callreturn, dahdi_pvt::callwaiting, dahdi_pvt::cancallforward, canmatch_featurecode(), dahdi_pvt::canpark, dahdi_pvt::channel, dahdi_pvt::cid_name, dahdi_pvt::cid_num, CID_SIG_DTMF, CID_SIG_SMDI, CID_SIG_V23, CID_SIG_V23_JP, dahdi_pvt::cid_signalling, dahdi_pvt::cid_start, CID_START_DTMF_NOALERT, CID_START_POLARITY, CID_START_POLARITY_IN, CID_START_RING, dahdi_pvt::context, ringContextData::contextData, dahdi_dnd(), dahdi_ec_enable(), dahdi_get_event(), dahdi_get_index, dahdi_set_hook(), dahdi_setlinear(), dahdi_wait_event(), dahdi_wink(), ast_channel::data, dahdi_pvt::defcontext, dahdi_subchannel::dfd, distinctiveringaftercid, dahdi_pvt::dop, dahdi_pvt::drings, dahdi_pvt::dsp, DSP_DIGITMODE_DTMF, DSP_DIGITMODE_MF, dahdi_pvt::dtmfrelax, errno, event2str(), exten, dahdi_pvt::firstdigit_timeout, ast_frame::frametype, ast_smdi_md_message::fwd_st, dahdi_pvt::hanguponpolarityswitch, dahdi_pvt::hardwaredtmf, dahdi_pvt::hidecallerid, dahdi_pvt::immediate, dahdi_pvt::inalarm, ast_frame_subclass::integer, dahdi_pvt::interdigit_timeout, ISTRUNK, len(), dahdi_subchannel::linear, dahdi_pvt::lock, LOG_ERROR, LOG_NOTICE, LOG_WARNING, dahdi_pvt::matchdigit_timeout, my_getsigstr(), my_handle_notify_message(), name, NEED_MFDETECT, NULL, dahdi_subchannel::owner, dahdi_pvt::owner, pbx_builtin_setvar_helper(), dahdi_pvt::polarity, POLARITY_IDLE, POLARITY_REV, RAII_VAR, distRingData::range, restore_gains(), distRingData::ring, dahdi_distRings::ringContext, dahdi_distRings::ringnum, dahdi_pvt::ringt, dahdi_pvt::ringt_base, S_COR, S_OR, dahdi_pvt::sig, sig2str, SIG_E911, SIG_EM, SIG_EM_E1, SIG_EMWINK, SIG_FEATB, SIG_FEATD, SIG_FEATDMF, SIG_FEATDMF_TA, SIG_FGC_CAMA, SIG_FGC_CAMAMF, SIG_FXOGS, SIG_FXOKS, SIG_FXOLS, SIG_FXSGS, SIG_FXSKS, SIG_FXSLS, SIG_SF, SIG_SF_FEATB, SIG_SF_FEATD, SIG_SF_FEATDMF, SIG_SFWINK, dahdi_pvt::smdi_iface, SMDI_MD_WAIT_TIMEOUT, ss_thread_complete, ss_thread_count, ss_thread_lock, strsep(), SUB_CALLWAIT, SUB_REAL, SUB_THREEWAY, ast_frame::subclass, dahdi_pvt::subs, swap_subs(), timeout, dahdi_pvt::transfer, ast_smdi_md_message::type, unalloc_sub(), dahdi_pvt::use_callerid, dahdi_pvt::use_smdi, and dahdi_pvt::usedistinctiveringdetection.

Referenced by dahdi_handle_event(), dahdi_ring_phone(), do_monitor(), handle_init_event(), and mwi_thread().

{
 struct ast_channel *chan = data;
 struct dahdi_pvt *p = ast_channel_tech_pvt(chan);
 char exten[AST_MAX_EXTENSION] = "";
 char exten2[AST_MAX_EXTENSION] = "";
 unsigned char buf[256];
 char dtmfcid[300];
 char dtmfbuf[300];
 struct callerid_state *cs = NULL;
 char *name = NULL, *number = NULL;
 int distMatches;
 int curRingData[3];
 int receivedRingT;
 int counter1;
 int counter;
 int samples = 0;
 struct ast_smdi_md_message *smdi_msg = NULL;
 int flags = 0;
 int i;
 int timeout;
 int getforward = 0;
 char *s1, *s2;
 int len = 0;
 int res;
 int idx;
 RAII_VAR(struct ast_features_pickup_config *, pickup_cfg, NULL, ao2_cleanup);
 const char *pickupexten;

 ast_mutex_lock(&ss_thread_lock);
 ss_thread_count++;
 ast_mutex_unlock(&ss_thread_lock);
 /* in the bizarre case where the channel has become a zombie before we
 even get started here, abort safely
 */
 if (!p) {
 ast_log(LOG_WARNING, "Channel became a zombie before simple switch could be started (%s)\n", ast_channel_name(chan));
 ast_hangup(chan);
 goto quit;
 }
 ast_verb(3, "Starting simple switch on '%s'\n", ast_channel_name(chan));
 idx = dahdi_get_index(chan, p, 1);
 if (idx < 0) {
 ast_log(LOG_WARNING, "Huh?\n");
 ast_hangup(chan);
 goto quit;
 }

 ast_channel_lock(chan);
 pickup_cfg = ast_get_chan_features_pickup_config(chan);
 if (!pickup_cfg) {
 ast_log(LOG_ERROR, "Unable to retrieve pickup configuration options. Unable to detect call pickup extension\n");
 pickupexten = "";
 } else {
 pickupexten = ast_strdupa(pickup_cfg->pickupexten);
 }
 ast_channel_unlock(chan);

 if (p->dsp)
 ast_dsp_digitreset(p->dsp);
 switch (p->sig) {
 case SIG_FEATD:
 case SIG_FEATDMF:
 case SIG_FEATDMF_TA:
 case SIG_E911:
 case SIG_FGC_CAMAMF:
 case SIG_FEATB:
 case SIG_EMWINK:
 case SIG_SF_FEATD:
 case SIG_SF_FEATDMF:
 case SIG_SF_FEATB:
 case SIG_SFWINK:
 if (dahdi_wink(p, idx))
 goto quit;
 /* Fall through */
 case SIG_EM:
 case SIG_EM_E1:
 case SIG_SF:
 case SIG_FGC_CAMA:
 res = tone_zone_play_tone(p->subs[idx].dfd, -1);
 if (p->dsp)
 ast_dsp_digitreset(p->dsp);
 /* set digit mode appropriately */
 if (p->dsp) {
 if (NEED_MFDETECT(p))
 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_MF | p->dtmfrelax);
 else
 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_DTMF | p->dtmfrelax);
 }
 memset(dtmfbuf, 0, sizeof(dtmfbuf));
 /* Wait for the first digit only if immediate=no */
 if (!p->immediate)
 /* Wait for the first digit (up to 5 seconds). */
 res = ast_waitfordigit(chan, 5000);
 else
 res = 0;
 if (res > 0) {
 /* save first char */
 dtmfbuf[0] = res;
 switch (p->sig) {
 case SIG_FEATD:
 case SIG_SF_FEATD:
 res = my_getsigstr(chan, dtmfbuf + 1, "*", 3000);
 if (res > 0)
 res = my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf), "*", 3000);
 if ((res < 1) && (p->dsp)) ast_dsp_digitreset(p->dsp);
 break;
 case SIG_FEATDMF_TA:
 res = my_getsigstr(chan, dtmfbuf + 1, "#", 3000);
 if ((res < 1) && (p->dsp)) ast_dsp_digitreset(p->dsp);
 if (dahdi_wink(p, idx)) goto quit;
 dtmfbuf[0] = 0;
 /* Wait for the first digit (up to 5 seconds). */
 res = ast_waitfordigit(chan, 5000);
 if (res <= 0) break;
 dtmfbuf[0] = res;
 /* fall through intentionally */
 case SIG_FEATDMF:
 case SIG_E911:
 case SIG_FGC_CAMAMF:
 case SIG_SF_FEATDMF:
 res = my_getsigstr(chan, dtmfbuf + 1, "#", 3000);
 /* if international caca, do it again to get real ANO */
 if ((p->sig == SIG_FEATDMF) && (dtmfbuf[1] != '0') && (strlen(dtmfbuf) != 14))
 {
 if (dahdi_wink(p, idx)) goto quit;
 dtmfbuf[0] = 0;
 /* Wait for the first digit (up to 5 seconds). */
 res = ast_waitfordigit(chan, 5000);
 if (res <= 0) break;
 dtmfbuf[0] = res;
 res = my_getsigstr(chan, dtmfbuf + 1, "#", 3000);
 }
 if (res > 0) {
 /* if E911, take off hook */
 if (p->sig == SIG_E911)
 dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK);
 res = my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf), "#", 3000);
 }
 if ((res < 1) && (p->dsp)) ast_dsp_digitreset(p->dsp);
 break;
 case SIG_FEATB:
 case SIG_SF_FEATB:
 res = my_getsigstr(chan, dtmfbuf + 1, "#", 3000);
 if ((res < 1) && (p->dsp)) ast_dsp_digitreset(p->dsp);
 break;
 case SIG_EMWINK:
 /* if we received a '*', we are actually receiving Feature Group D
 dial syntax, so use that mode; otherwise, fall through to normal
 mode
 */
 if (res == '*') {
 res = my_getsigstr(chan, dtmfbuf + 1, "*", 3000);
 if (res > 0)
 res = my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf), "*", 3000);
 if ((res < 1) && (p->dsp)) ast_dsp_digitreset(p->dsp);
 break;
 }
 default:
 /* If we got the first digit, get the rest */
 len = 1;
 dtmfbuf[len] = '\0';
 while ((len < AST_MAX_EXTENSION-1) && ast_matchmore_extension(chan, ast_channel_context(chan), dtmfbuf, 1, p->cid_num)) {
 if (ast_exists_extension(chan, ast_channel_context(chan), dtmfbuf, 1, p->cid_num)) {
 timeout = p->matchdigit_timeout;
 } else {
 timeout = p->interdigit_timeout;
 }
 res = ast_waitfordigit(chan, timeout);
 if (res < 0) {
 ast_debug(1, "waitfordigit returned < 0...\n");
 ast_hangup(chan);
 goto quit;
 } else if (res) {
 dtmfbuf[len++] = res;
 dtmfbuf[len] = '\0';
 } else {
 break;
 }
 }
 break;
 }
 }
 if (res == -1) {
 ast_log(LOG_WARNING, "getdtmf on channel %d: %s\n", p->channel, strerror(errno));
 ast_hangup(chan);
 goto quit;
 } else if (res < 0) {
 ast_debug(1, "Got hung up before digits finished\n");
 ast_hangup(chan);
 goto quit;
 }

 if (p->sig == SIG_FGC_CAMA) {
 char anibuf[100];

 if (ast_safe_sleep(chan,1000) == -1) {
 ast_hangup(chan);
 goto quit;
 }
 dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK);
 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_MF | p->dtmfrelax);
 res = my_getsigstr(chan, anibuf, "#", 10000);
 if ((res > 0) && (strlen(anibuf) > 2)) {
 if (anibuf[strlen(anibuf) - 1] == '#')
 anibuf[strlen(anibuf) - 1] = 0;
 ast_set_callerid(chan, anibuf + 2, NULL, anibuf + 2);
 }
 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_DTMF | p->dtmfrelax);
 }

 ast_copy_string(exten, dtmfbuf, sizeof(exten));
 if (ast_strlen_zero(exten))
 ast_copy_string(exten, "s", sizeof(exten));
 if (p->sig == SIG_FEATD || p->sig == SIG_EMWINK) {
 /* Look for Feature Group D on all E&M Wink and Feature Group D trunks */
 if (exten[0] == '*') {
 char *stringp=NULL;
 ast_copy_string(exten2, exten, sizeof(exten2));
 /* Parse out extension and callerid */
 stringp=exten2 +1;
 s1 = strsep(&stringp, "*");
 s2 = strsep(&stringp, "*");
 if (s2) {
 if (!ast_strlen_zero(p->cid_num))
 ast_set_callerid(chan, p->cid_num, NULL, p->cid_num);
 else
 ast_set_callerid(chan, s1, NULL, s1);
 ast_copy_string(exten, s2, sizeof(exten));
 } else
 ast_copy_string(exten, s1, sizeof(exten));
 } else if (p->sig == SIG_FEATD)
 ast_log(LOG_WARNING, "Got a non-Feature Group D input on channel %d. Assuming E&M Wink instead\n", p->channel);
 }
 if ((p->sig == SIG_FEATDMF) || (p->sig == SIG_FEATDMF_TA)) {
 if (exten[0] == '*') {
 char *stringp=NULL;
 ast_copy_string(exten2, exten, sizeof(exten2));
 /* Parse out extension and callerid */
 stringp=exten2 +1;
 s1 = strsep(&stringp, "#");
 s2 = strsep(&stringp, "#");
 if (s2) {
 if (!ast_strlen_zero(p->cid_num))
 ast_set_callerid(chan, p->cid_num, NULL, p->cid_num);
 else
 if (*(s1 + 2))
 ast_set_callerid(chan, s1 + 2, NULL, s1 + 2);
 ast_copy_string(exten, s2 + 1, sizeof(exten));
 } else
 ast_copy_string(exten, s1 + 2, sizeof(exten));
 } else
 ast_log(LOG_WARNING, "Got a non-Feature Group D input on channel %d. Assuming E&M Wink instead\n", p->channel);
 }
 if ((p->sig == SIG_E911) || (p->sig == SIG_FGC_CAMAMF)) {
 if (exten[0] == '*') {
 char *stringp=NULL;
 ast_copy_string(exten2, exten, sizeof(exten2));
 /* Parse out extension and callerid */
 stringp=exten2 +1;
 s1 = strsep(&stringp, "#");
 s2 = strsep(&stringp, "#");
 if (s2 && (*(s2 + 1) == '0')) {
 if (*(s2 + 2))
 ast_set_callerid(chan, s2 + 2, NULL, s2 + 2);
 }
 if (s1) ast_copy_string(exten, s1, sizeof(exten));
 else ast_copy_string(exten, "911", sizeof(exten));
 } else
 ast_log(LOG_WARNING, "Got a non-E911/FGC CAMA input on channel %d. Assuming E&M Wink instead\n", p->channel);
 }
 if (p->sig == SIG_FEATB) {
 if (exten[0] == '*') {
 char *stringp=NULL;
 ast_copy_string(exten2, exten, sizeof(exten2));
 /* Parse out extension and callerid */
 stringp=exten2 +1;
 s1 = strsep(&stringp, "#");
 ast_copy_string(exten, exten2 + 1, sizeof(exten));
 } else
 ast_log(LOG_WARNING, "Got a non-Feature Group B input on channel %d. Assuming E&M Wink instead\n", p->channel);
 }
 if ((p->sig == SIG_FEATDMF) || (p->sig == SIG_FEATDMF_TA)) {
 dahdi_wink(p, idx);
 /* some switches require a minimum guard time between
 the last FGD wink and something that answers
 immediately. This ensures it */
 if (ast_safe_sleep(chan, 100)) {
 ast_hangup(chan);
 goto quit;
 }
 }
 dahdi_ec_enable(p);
 if (NEED_MFDETECT(p)) {
 if (p->dsp) {
 if (!p->hardwaredtmf)
 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_DTMF | p->dtmfrelax);
 else {
 ast_dsp_free(p->dsp);
 p->dsp = NULL;
 }
 }
 }

 if (ast_exists_extension(chan, ast_channel_context(chan), exten, 1,
 S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL))) {
 ast_channel_exten_set(chan, exten);
 if (p->dsp) ast_dsp_digitreset(p->dsp);
 res = ast_pbx_run(chan);
 if (res) {
 ast_log(LOG_WARNING, "PBX exited non-zero\n");
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_CONGESTION);
 }
 goto quit;
 } else {
 ast_verb(2, "Unknown extension '%s' in context '%s' requested\n", exten, ast_channel_context(chan));
 sleep(2);
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_INFO);
 if (res < 0)
 ast_log(LOG_WARNING, "Unable to start special tone on %d\n", p->channel);
 else
 sleep(1);
 res = ast_streamfile(chan, "ss-noservice", ast_channel_language(chan));
 if (res >= 0)
 ast_waitstream(chan, "");
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_CONGESTION);
 ast_hangup(chan);
 goto quit;
 }
 break;
 case SIG_FXOLS:
 case SIG_FXOGS:
 case SIG_FXOKS:
 /* Read the first digit */
 timeout = p->firstdigit_timeout;
 /* If starting a threeway call, never timeout on the first digit so someone
 can use flash-hook as a "hold" feature */
 if (p->subs[SUB_THREEWAY].owner)
 timeout = INT_MAX;
 while (len < AST_MAX_EXTENSION-1) {
 int is_exten_parking = 0;

 /* Read digit unless it's supposed to be immediate, in which case the
 only answer is 's' */
 if (p->immediate)
 res = 's';
 else
 res = ast_waitfordigit(chan, timeout);
 timeout = 0;
 if (res < 0) {
 ast_debug(1, "waitfordigit returned < 0...\n");
 res = tone_zone_play_tone(p->subs[idx].dfd, -1);
 ast_hangup(chan);
 goto quit;
 } else if (res) {
 ast_debug(1,"waitfordigit returned '%c' (%d), timeout = %d\n", res, res, timeout);
 exten[len++]=res;
 exten[len] = '\0';
 }
 if (!ast_ignore_pattern(ast_channel_context(chan), exten)) {
 tone_zone_play_tone(p->subs[idx].dfd, -1);
 } else {
 tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_DIALTONE);
 }
 if (ast_parking_provider_registered()) {
 is_exten_parking = ast_parking_is_exten_park(ast_channel_context(chan), exten);
 }
 if (ast_exists_extension(chan, ast_channel_context(chan), exten, 1, p->cid_num) && !is_exten_parking) {
 if (!res || !ast_matchmore_extension(chan, ast_channel_context(chan), exten, 1, p->cid_num)) {
 if (getforward) {
 /* Record this as the forwarding extension */
 ast_copy_string(p->call_forward, exten, sizeof(p->call_forward));
 ast_verb(3, "Setting call forward to '%s' on channel %d\n", p->call_forward, p->channel);
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_DIALRECALL);
 if (res)
 break;
 usleep(500000);
 res = tone_zone_play_tone(p->subs[idx].dfd, -1);
 sleep(1);
 memset(exten, 0, sizeof(exten));
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_DIALTONE);
 len = 0;
 getforward = 0;
 } else {
 res = tone_zone_play_tone(p->subs[idx].dfd, -1);
 ast_channel_lock(chan);
 ast_channel_exten_set(chan, exten);
 if (!ast_strlen_zero(p->cid_num)) {
 if (!p->hidecallerid)
 ast_set_callerid(chan, p->cid_num, NULL, p->cid_num);
 else
 ast_set_callerid(chan, NULL, NULL, p->cid_num);
 }
 if (!ast_strlen_zero(p->cid_name)) {
 if (!p->hidecallerid)
 ast_set_callerid(chan, NULL, p->cid_name, NULL);
 }
 ast_setstate(chan, AST_STATE_RING);
 ast_channel_unlock(chan);
 dahdi_ec_enable(p);
 res = ast_pbx_run(chan);
 if (res) {
 ast_log(LOG_WARNING, "PBX exited non-zero\n");
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_CONGESTION);
 }
 goto quit;
 }
 } else {
 /* It's a match, but they just typed a digit, and there is an ambiguous match,
 so just set the timeout to matchdigit_timeout and wait some more */
 timeout = p->matchdigit_timeout;
 }
 } else if (res == 0) {
 ast_debug(1, "not enough digits (and no ambiguous match)...\n");
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_CONGESTION);
 dahdi_wait_event(p->subs[idx].dfd);
 ast_hangup(chan);
 goto quit;
 } else if (p->callwaiting && !strcmp(exten, "*70")) {
 ast_verb(3, "Disabling call waiting on %s\n", ast_channel_name(chan));
 /* Disable call waiting if enabled */
 p->callwaiting = 0;
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_DIALRECALL);
 if (res) {
 ast_log(LOG_WARNING, "Unable to do dial recall on channel %s: %s\n",
 ast_channel_name(chan), strerror(errno));
 }
 len = 0;
 ioctl(p->subs[idx].dfd,DAHDI_CONFDIAG,&len);
 memset(exten, 0, sizeof(exten));
 timeout = p->firstdigit_timeout;

 } else if (!strcmp(exten, pickupexten)) {
 /* Scan all channels and see if there are any
 * ringing channels that have call groups
 * that equal this channels pickup group
 */
 if (idx == SUB_REAL) {
 /* Switch us from Third call to Call Wait */
 if (p->subs[SUB_THREEWAY].owner) {
 /* If you make a threeway call and the *8# a call, it should actually
 look like a callwait */
 alloc_sub(p, SUB_CALLWAIT);
 swap_subs(p, SUB_CALLWAIT, SUB_THREEWAY);
 unalloc_sub(p, SUB_THREEWAY);
 }
 dahdi_ec_enable(p);
 if (ast_pickup_call(chan)) {
 ast_debug(1, "No call pickup possible...\n");
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_CONGESTION);
 dahdi_wait_event(p->subs[idx].dfd);
 }
 ast_hangup(chan);
 goto quit;
 } else {
 ast_log(LOG_WARNING, "Huh? Got *8# on call not on real\n");
 ast_hangup(chan);
 goto quit;
 }

 } else if (!p->hidecallerid && !strcmp(exten, "*67")) {
 ast_verb(3, "Disabling Caller*ID on %s\n", ast_channel_name(chan));
 /* Disable Caller*ID if enabled */
 p->hidecallerid = 1;
 ast_party_number_free(&ast_channel_caller(chan)->id.number);
 ast_party_number_init(&ast_channel_caller(chan)->id.number);
 ast_party_name_free(&ast_channel_caller(chan)->id.name);
 ast_party_name_init(&ast_channel_caller(chan)->id.name);
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_DIALRECALL);
 if (res) {
 ast_log(LOG_WARNING, "Unable to do dial recall on channel %s: %s\n",
 ast_channel_name(chan), strerror(errno));
 }
 len = 0;
 memset(exten, 0, sizeof(exten));
 timeout = p->firstdigit_timeout;
 } else if (p->callreturn && !strcmp(exten, "*69")) {
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_DIALRECALL);
 break;
 } else if (!strcmp(exten, "*78")) {
 dahdi_dnd(p, 1);
 /* Do not disturb */
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_DIALRECALL);
 getforward = 0;
 memset(exten, 0, sizeof(exten));
 len = 0;
 } else if (!strcmp(exten, "*79")) {
 dahdi_dnd(p, 0);
 /* Do not disturb */
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_DIALRECALL);
 getforward = 0;
 memset(exten, 0, sizeof(exten));
 len = 0;
 } else if (p->cancallforward && !strcmp(exten, "*72")) {
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_DIALRECALL);
 getforward = 1;
 memset(exten, 0, sizeof(exten));
 len = 0;
 } else if (p->cancallforward && !strcmp(exten, "*73")) {
 ast_verb(3, "Cancelling call forwarding on channel %d\n", p->channel);
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_DIALRECALL);
 memset(p->call_forward, 0, sizeof(p->call_forward));
 getforward = 0;
 memset(exten, 0, sizeof(exten));
 len = 0;
 } else if ((p->transfer || p->canpark) && is_exten_parking
 && p->subs[SUB_THREEWAY].owner) {
 struct ast_bridge_channel *bridge_channel;

 /*
 * This is a three way call, the main call being a real channel,
 * and we're parking the first call.
 */
 ast_channel_lock(p->subs[SUB_THREEWAY].owner);
 bridge_channel = ast_channel_get_bridge_channel(p->subs[SUB_THREEWAY].owner);
 ast_channel_unlock(p->subs[SUB_THREEWAY].owner);
 if (bridge_channel) {
 if (!ast_parking_blind_transfer_park(bridge_channel, ast_channel_context(chan), exten, NULL, NULL)) {
 /*
 * Swap things around between the three-way and real call so we
 * can hear where the channel got parked.
 */
 ast_mutex_lock(&p->lock);
 p->owner = p->subs[SUB_THREEWAY].owner;
 swap_subs(p, SUB_THREEWAY, SUB_REAL);
 ast_mutex_unlock(&p->lock);

 ast_verb(3, "%s: Parked call\n", ast_channel_name(chan));
 ast_hangup(chan);
 ao2_ref(bridge_channel, -1);
 goto quit;
 }
 ao2_ref(bridge_channel, -1);
 }
 break;
 } else if (p->hidecallerid && !strcmp(exten, "*82")) {
 ast_verb(3, "Enabling Caller*ID on %s\n", ast_channel_name(chan));
 /* Enable Caller*ID if enabled */
 p->hidecallerid = 0;
 ast_set_callerid(chan, p->cid_num, p->cid_name, NULL);
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_DIALRECALL);
 if (res) {
 ast_log(LOG_WARNING, "Unable to do dial recall on channel %s: %s\n",
 ast_channel_name(chan), strerror(errno));
 }
 len = 0;
 memset(exten, 0, sizeof(exten));
 timeout = p->firstdigit_timeout;
 } else if (!strcmp(exten, "*0")) {
 struct ast_channel *nbridge =
 p->subs[SUB_THREEWAY].owner;
 struct dahdi_pvt *pbridge = NULL;
 RAII_VAR(struct ast_channel *, bridged, nbridge ? ast_channel_bridge_peer(nbridge) : NULL, ast_channel_cleanup);

 /* set up the private struct of the bridged one, if any */
 if (nbridge && bridged) {
 pbridge = ast_channel_tech_pvt(bridged);
 }
 if (nbridge && pbridge &&
 (ast_channel_tech(nbridge) == &dahdi_tech) &&
 (ast_channel_tech(bridged) == &dahdi_tech) &&
 ISTRUNK(pbridge)) {
 int func = DAHDI_FLASH;
 /* Clear out the dial buffer */
 p->dop.dialstr[0] = '\0';
 /* flash hookswitch */
 if ((ioctl(pbridge->subs[SUB_REAL].dfd,DAHDI_HOOK,&func) == -1) && (errno != EINPROGRESS)) {
 ast_log(LOG_WARNING, "Unable to flash external trunk on channel %s: %s\n",
 ast_channel_name(nbridge), strerror(errno));
 }
 swap_subs(p, SUB_REAL, SUB_THREEWAY);
 unalloc_sub(p, SUB_THREEWAY);
 p->owner = p->subs[SUB_REAL].owner;
 ast_queue_unhold(p->subs[SUB_REAL].owner);
 ast_hangup(chan);
 goto quit;
 } else {
 tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_CONGESTION);
 dahdi_wait_event(p->subs[idx].dfd);
 tone_zone_play_tone(p->subs[idx].dfd, -1);
 swap_subs(p, SUB_REAL, SUB_THREEWAY);
 unalloc_sub(p, SUB_THREEWAY);
 p->owner = p->subs[SUB_REAL].owner;
 ast_hangup(chan);
 goto quit;
 }
 } else if (!ast_canmatch_extension(chan, ast_channel_context(chan), exten, 1,
 S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL))
 && !canmatch_featurecode(pickupexten, exten)) {
 ast_debug(1, "Can't match %s from '%s' in context %s\n", exten,
 S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, "<Unknown Caller>"),
 ast_channel_context(chan));
 break;
 }
 if (!timeout)
 timeout = p->interdigit_timeout;
 if (len && !ast_ignore_pattern(ast_channel_context(chan), exten))
 tone_zone_play_tone(p->subs[idx].dfd, -1);
 }
 break;
 case SIG_FXSLS:
 case SIG_FXSGS:
 case SIG_FXSKS:
 /* check for SMDI messages */
 if (p->use_smdi && p->smdi_iface) {
 smdi_msg = ast_smdi_md_message_wait(p->smdi_iface, SMDI_MD_WAIT_TIMEOUT);

 if (smdi_msg != NULL) {
 ast_channel_exten_set(chan, smdi_msg->fwd_st);

 if (smdi_msg->type == 'B')
 pbx_builtin_setvar_helper(chan, "_SMDI_VM_TYPE", "b");
 else if (smdi_msg->type == 'N')
 pbx_builtin_setvar_helper(chan, "_SMDI_VM_TYPE", "u");

 ast_debug(1, "Received SMDI message on %s\n", ast_channel_name(chan));
 } else {
 ast_log(LOG_WARNING, "SMDI enabled but no SMDI message present\n");
 }
 }

 if (p->use_callerid && (p->cid_signalling == CID_SIG_SMDI && smdi_msg)) {
 number = smdi_msg->calling_st;

 /* If we want caller id, we're in a prering state due to a polarity reversal
 * and we're set to use a polarity reversal to trigger the start of caller id,
 * grab the caller id and wait for ringing to start... */
 } else if (p->use_callerid && (ast_channel_state(chan) == AST_STATE_PRERING &&
 (p->cid_start == CID_START_POLARITY || p->cid_start == CID_START_POLARITY_IN || p->cid_start == CID_START_DTMF_NOALERT))) {
 /* If set to use DTMF CID signalling, listen for DTMF */
 if (p->cid_signalling == CID_SIG_DTMF) {
 int k = 0;
 int off_ms;
 struct timeval start = ast_tvnow();
 int ms;
 cs = NULL;
 ast_debug(1, "Receiving DTMF cid on channel %s\n", ast_channel_name(chan));
 dahdi_setlinear(p->subs[idx].dfd, 0);
 /*
 * We are the only party interested in the Rx stream since
 * we have not answered yet. We don't need or even want DTMF
 * emulation. The DTMF digits can come so fast that emulation
 * can drop some of them.
 */
 ast_channel_lock(chan);
 ast_set_flag(ast_channel_flags(chan), AST_FLAG_END_DTMF_ONLY);
 ast_channel_unlock(chan);
 off_ms = 4000;/* This is a typical OFF time between rings. */
 for (;;) {
 struct ast_frame *f;

 ms = ast_remaining_ms(start, off_ms);
 res = ast_waitfor(chan, ms);
 if (res <= 0) {
 /*
 * We do not need to restore the dahdi_setlinear()
 * or AST_FLAG_END_DTMF_ONLY flag settings since we
 * are hanging up the channel.
 */
 ast_log(LOG_WARNING, "DTMFCID timed out waiting for ring. "
 "Exiting simple switch\n");
 ast_hangup(chan);
 goto quit;
 }
 f = ast_read(chan);
 if (!f)
 break;
 if (f->frametype == AST_FRAME_DTMF) {
 if (k < ARRAY_LEN(dtmfbuf) - 1) {
 dtmfbuf[k++] = f->subclass.integer;
 }
 ast_debug(1, "CID got digit '%c'\n", f->subclass.integer);
 start = ast_tvnow();
 }
 ast_frfree(f);
 if (ast_channel_state(chan) == AST_STATE_RING ||
 ast_channel_state(chan) == AST_STATE_RINGING)
 break; /* Got ring */
 }
 ast_channel_lock(chan);
 ast_clear_flag(ast_channel_flags(chan), AST_FLAG_END_DTMF_ONLY);
 ast_channel_unlock(chan);
 dtmfbuf[k] = '\0';
 dahdi_setlinear(p->subs[idx].dfd, p->subs[idx].linear);
 /* Got cid and ring. */
 ast_debug(1, "CID got string '%s'\n", dtmfbuf);
 callerid_get_dtmf(dtmfbuf, dtmfcid, &flags);
 ast_debug(1, "CID is '%s', flags %d\n", dtmfcid, flags);
 /* If first byte is NULL, we have no cid */
 if (!ast_strlen_zero(dtmfcid))
 number = dtmfcid;
 else
 number = NULL;
 /* If set to use V23 Signalling, launch our FSK gubbins and listen for it */
 } else if ((p->cid_signalling == CID_SIG_V23) || (p->cid_signalling == CID_SIG_V23_JP)) {
 cs = callerid_new(p->cid_signalling);
 if (cs) {
 int off_ms;
 struct timeval start;
 int ms;
 samples = 0;
#if 1
 bump_gains(p);
#endif
 /* Take out of linear mode for Caller*ID processing */
 dahdi_setlinear(p->subs[idx].dfd, 0);

 /* First we wait and listen for the Caller*ID */
 for (;;) {
 i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
 if ((res = ioctl(p->subs[idx].dfd, DAHDI_IOMUX, &i))) {
 ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
 callerid_free(cs);
 ast_hangup(chan);
 goto quit;
 }
 if (i & DAHDI_IOMUX_SIGEVENT) {
 res = dahdi_get_event(p->subs[idx].dfd);
 ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
 if (res == DAHDI_EVENT_NOALARM) {
 p->inalarm = 0;
 }

 if (p->cid_signalling == CID_SIG_V23_JP) {
 if (res == DAHDI_EVENT_RINGBEGIN) {
 res = dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK);
 usleep(1);
 }
 } else {
 res = 0;
 break;
 }
 } else if (i & DAHDI_IOMUX_READ) {
 res = read(p->subs[idx].dfd, buf, sizeof(buf));
 if (res < 0) {
 if (errno != ELAST) {
 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
 callerid_free(cs);
 ast_hangup(chan);
 goto quit;
 }
 break;
 }
 samples += res;

 if (p->cid_signalling == CID_SIG_V23_JP) {
 res = callerid_feed_jp(cs, buf, res, AST_LAW(p));
 } else {
 res = callerid_feed(cs, buf, res, AST_LAW(p));
 }
 if (res < 0) {
 /*
 * The previous diagnostic message output likely
 * explains why it failed.
 */
 ast_log(LOG_WARNING,
 "Failed to decode CallerID on channel '%s'\n",
 ast_channel_name(chan));
 break;
 } else if (res)
 break;
 else if (samples > (8000 * 10))
 break;
 }
 }
 if (res == 1) {
 callerid_get(cs, &name, &number, &flags);
 ast_log(LOG_NOTICE, "CallerID number: %s, name: %s, flags=%d\n", number, name, flags);
 }

 if (p->cid_signalling == CID_SIG_V23_JP) {
 res = dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_ONHOOK);
 usleep(1);
 }

 /* Finished with Caller*ID, now wait for a ring to make sure there really is a call coming */
 start = ast_tvnow();
 off_ms = 4000;/* This is a typical OFF time between rings. */
 for (;;) {
 struct ast_frame *f;

 ms = ast_remaining_ms(start, off_ms);
 res = ast_waitfor(chan, ms);
 if (res <= 0) {
 ast_log(LOG_WARNING, "CID timed out waiting for ring. "
 "Exiting simple switch\n");
 ast_hangup(chan);
 goto quit;
 }
 if (!(f = ast_read(chan))) {
 ast_log(LOG_WARNING, "Hangup received waiting for ring. Exiting simple switch\n");
 ast_hangup(chan);
 goto quit;
 }
 ast_frfree(f);
 if (ast_channel_state(chan) == AST_STATE_RING ||
 ast_channel_state(chan) == AST_STATE_RINGING)
 break; /* Got ring */
 }

 /* We must have a ring by now, so, if configured, lets try to listen for
 * distinctive ringing */
 if (p->usedistinctiveringdetection) {
 len = 0;
 distMatches = 0;
 /* Clear the current ring data array so we don't have old data in it. */
 for (receivedRingT = 0; receivedRingT < ARRAY_LEN(curRingData); receivedRingT++)
 curRingData[receivedRingT] = 0;
 receivedRingT = 0;
 counter = 0;
 counter1 = 0;
 /* Check to see if context is what it should be, if not set to be. */
 if (strcmp(p->context,p->defcontext) != 0) {
 ast_copy_string(p->context, p->defcontext, sizeof(p->context));
 ast_channel_context_set(chan, p->defcontext);
 }

 for (;;) {
 i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
 if ((res = ioctl(p->subs[idx].dfd, DAHDI_IOMUX, &i))) {
 ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
 callerid_free(cs);
 ast_hangup(chan);
 goto quit;
 }
 if (i & DAHDI_IOMUX_SIGEVENT) {
 res = dahdi_get_event(p->subs[idx].dfd);
 ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
 if (res == DAHDI_EVENT_NOALARM) {
 p->inalarm = 0;
 }
 res = 0;
 /* Let us detect distinctive ring */

 curRingData[receivedRingT] = p->ringt;

 if (p->ringt < p->ringt_base/2)
 break;
 /* Increment the ringT counter so we can match it against
 values in chan_dahdi.conf for distinctive ring */
 if (++receivedRingT == ARRAY_LEN(curRingData))
 break;
 } else if (i & DAHDI_IOMUX_READ) {
 res = read(p->subs[idx].dfd, buf, sizeof(buf));
 if (res < 0) {
 if (errno != ELAST) {
 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
 callerid_free(cs);
 ast_hangup(chan);
 goto quit;
 }
 break;
 }
 if (p->ringt > 0) {
 if (!(--p->ringt)) {
 res = -1;
 break;
 }
 }
 }
 }
 /* this only shows up if you have n of the dring patterns filled in */
 ast_verb(3, "Detected ring pattern: %d,%d,%d\n",curRingData[0],curRingData[1],curRingData[2]);
 for (counter = 0; counter < 3; counter++) {
 /* Check to see if the rings we received match any of the ones in chan_dahdi.conf for this
 channel */
 distMatches = 0;
 for (counter1 = 0; counter1 < 3; counter1++) {
 ast_verb(3, "Ring pattern check range: %d\n", p->drings.ringnum[counter].range);
 if (p->drings.ringnum[counter].ring[counter1] == -1) {
 ast_verb(3, "Pattern ignore (-1) detected, so matching pattern %d regardless.\n",
 curRingData[counter1]);
 distMatches++;
 } else if (curRingData[counter1] <= (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range) &&
 curRingData[counter1] >= (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range)) {
 ast_verb(3, "Ring pattern matched in range: %d to %d\n",
 (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range),
 (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range));
 distMatches++;
 }
 }

 if (distMatches == 3) {
 /* The ring matches, set the context to whatever is for distinctive ring.. */
 ast_copy_string(p->context, S_OR(p->drings.ringContext[counter].contextData, p->defcontext), sizeof(p->context));
 ast_channel_context_set(chan, S_OR(p->drings.ringContext[counter].contextData, p->defcontext));
 ast_verb(3, "Distinctive Ring matched context %s\n",p->context);
 break;
 }
 }
 }
 /* Restore linear mode (if appropriate) for Caller*ID processing */
 dahdi_setlinear(p->subs[idx].dfd, p->subs[idx].linear);
#if 1
 restore_gains(p);
#endif
 } else
 ast_log(LOG_WARNING, "Unable to get caller ID space\n");
 } else {
 ast_log(LOG_WARNING, "Channel %s in prering "
 "state, but I have nothing to do. "
 "Terminating simple switch, should be "
 "restarted by the actual ring.\n",
 ast_channel_name(chan));
 ast_hangup(chan);
 goto quit;
 }
 } else if (p->use_callerid && p->cid_start == CID_START_RING) {
 if (p->cid_signalling == CID_SIG_DTMF) {
 int k = 0;
 int off_ms;
 struct timeval start;
 int ms;
 cs = NULL;
 dahdi_setlinear(p->subs[idx].dfd, 0);
 off_ms = 2000;
 start = ast_tvnow();
 for (;;) {
 struct ast_frame *f;

 ms = ast_remaining_ms(start, off_ms);
 res = ast_waitfor(chan, ms);
 if (res <= 0) {
 ast_log(LOG_WARNING, "DTMFCID timed out waiting for ring. "
 "Exiting simple switch\n");
 ast_hangup(chan);
 goto quit;
 }
 f = ast_read(chan);
 if (!f) {
 /* Hangup received waiting for DTMFCID. Exiting simple switch. */
 ast_hangup(chan);
 goto quit;
 }
 if (f->frametype == AST_FRAME_DTMF) {
 dtmfbuf[k++] = f->subclass.integer;
 ast_debug(1, "CID got digit '%c'\n", f->subclass.integer);
 start = ast_tvnow();
 }
 ast_frfree(f);

 if (p->ringt_base == p->ringt)
 break;
 }
 dtmfbuf[k] = '\0';
 dahdi_setlinear(p->subs[idx].dfd, p->subs[idx].linear);
 /* Got cid and ring. */
 callerid_get_dtmf(dtmfbuf, dtmfcid, &flags);
 ast_debug(1, "CID is '%s', flags %d\n",
 dtmfcid, flags);
 /* If first byte is NULL, we have no cid */
 if (!ast_strlen_zero(dtmfcid))
 number = dtmfcid;
 else
 number = NULL;
 /* If set to use V23 Signalling, launch our FSK gubbins and listen for it */
 } else {
 /* FSK Bell202 callerID */
 cs = callerid_new(p->cid_signalling);
 if (cs) {
#if 1
 bump_gains(p);
#endif
 samples = 0;
 len = 0;
 distMatches = 0;
 /* Clear the current ring data array so we don't have old data in it. */
 for (receivedRingT = 0; receivedRingT < ARRAY_LEN(curRingData); receivedRingT++)
 curRingData[receivedRingT] = 0;
 receivedRingT = 0;
 counter = 0;
 counter1 = 0;
 /* Check to see if context is what it should be, if not set to be. */
 if (strcmp(p->context,p->defcontext) != 0) {
 ast_copy_string(p->context, p->defcontext, sizeof(p->context));
 ast_channel_context_set(chan, p->defcontext);
 }

 /* Take out of linear mode for Caller*ID processing */
 dahdi_setlinear(p->subs[idx].dfd, 0);
 for (;;) {
 i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
 if ((res = ioctl(p->subs[idx].dfd, DAHDI_IOMUX, &i))) {
 ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
 callerid_free(cs);
 ast_hangup(chan);
 goto quit;
 }
 if (i & DAHDI_IOMUX_SIGEVENT) {
 res = dahdi_get_event(p->subs[idx].dfd);
 ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
 if (res == DAHDI_EVENT_NOALARM) {
 p->inalarm = 0;
 }
 /* If we get a PR event, they hung up while processing calerid */
 if ( res == DAHDI_EVENT_POLARITY && p->hanguponpolarityswitch && p->polarity == POLARITY_REV) {
 ast_debug(1, "Hanging up due to polarity reversal on channel %d while detecting callerid\n", p->channel);
 p->polarity = POLARITY_IDLE;
 callerid_free(cs);
 ast_hangup(chan);
 goto quit;
 }
 res = 0;
 /* Let us detect callerid when the telco uses distinctive ring */

 curRingData[receivedRingT] = p->ringt;

 if (p->ringt < p->ringt_base/2)
 break;
 /* Increment the ringT counter so we can match it against
 values in chan_dahdi.conf for distinctive ring */
 if (++receivedRingT == ARRAY_LEN(curRingData))
 break;
 } else if (i & DAHDI_IOMUX_READ) {
 res = read(p->subs[idx].dfd, buf, sizeof(buf));
 if (res < 0) {
 if (errno != ELAST) {
 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
 callerid_free(cs);
 ast_hangup(chan);
 goto quit;
 }
 break;
 }
 if (p->ringt > 0) {
 if (!(--p->ringt)) {
 res = -1;
 break;
 }
 }
 samples += res;
 res = callerid_feed(cs, buf, res, AST_LAW(p));
 if (res < 0) {
 /*
 * The previous diagnostic message output likely
 * explains why it failed.
 */
 ast_log(LOG_WARNING,
 "Failed to decode CallerID on channel '%s'\n",
 ast_channel_name(chan));
 break;
 } else if (res)
 break;
 else if (samples > (8000 * 10))
 break;
 }
 }
 if (res == 1) {
 callerid_get(cs, &name, &number, &flags);
 ast_debug(1, "CallerID number: %s, name: %s, flags=%d\n", number, name, flags);
 }
 if (distinctiveringaftercid == 1) {
 /* Clear the current ring data array so we don't have old data in it. */
 for (receivedRingT = 0; receivedRingT < 3; receivedRingT++) {
 curRingData[receivedRingT] = 0;
 }
 receivedRingT = 0;
 ast_verb(3, "Detecting post-CID distinctive ring\n");
 for (;;) {
 i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
 if ((res = ioctl(p->subs[idx].dfd, DAHDI_IOMUX, &i))) {
 ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
 callerid_free(cs);
 ast_hangup(chan);
 goto quit;
 }
 if (i & DAHDI_IOMUX_SIGEVENT) {
 res = dahdi_get_event(p->subs[idx].dfd);
 ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
 if (res == DAHDI_EVENT_NOALARM) {
 p->inalarm = 0;
 }
 res = 0;
 /* Let us detect callerid when the telco uses distinctive ring */

 curRingData[receivedRingT] = p->ringt;

 if (p->ringt < p->ringt_base/2)
 break;
 /* Increment the ringT counter so we can match it against
 values in chan_dahdi.conf for distinctive ring */
 if (++receivedRingT == ARRAY_LEN(curRingData))
 break;
 } else if (i & DAHDI_IOMUX_READ) {
 res = read(p->subs[idx].dfd, buf, sizeof(buf));
 if (res < 0) {
 if (errno != ELAST) {
 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
 callerid_free(cs);
 ast_hangup(chan);
 goto quit;
 }
 break;
 }
 if (p->ringt > 0) {
 if (!(--p->ringt)) {
 res = -1;
 break;
 }
 }
 }
 }
 }
 if (p->usedistinctiveringdetection) {
 /* this only shows up if you have n of the dring patterns filled in */
 ast_verb(3, "Detected ring pattern: %d,%d,%d\n",curRingData[0],curRingData[1],curRingData[2]);

 for (counter = 0; counter < 3; counter++) {
 /* Check to see if the rings we received match any of the ones in chan_dahdi.conf for this
 channel */
 /* this only shows up if you have n of the dring patterns filled in */
 ast_verb(3, "Checking %d,%d,%d\n",
 p->drings.ringnum[counter].ring[0],
 p->drings.ringnum[counter].ring[1],
 p->drings.ringnum[counter].ring[2]);
 distMatches = 0;
 for (counter1 = 0; counter1 < 3; counter1++) {
 ast_verb(3, "Ring pattern check range: %d\n", p->drings.ringnum[counter].range);
 if (p->drings.ringnum[counter].ring[counter1] == -1) {
 ast_verb(3, "Pattern ignore (-1) detected, so matching pattern %d regardless.\n",
 curRingData[counter1]);
 distMatches++;
 }
 else if (curRingData[counter1] <= (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range) &&
 curRingData[counter1] >= (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range)) {
 ast_verb(3, "Ring pattern matched in range: %d to %d\n",
 (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range),
 (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range));
 distMatches++;
 }
 }
 if (distMatches == 3) {
 /* The ring matches, set the context to whatever is for distinctive ring.. */
 ast_copy_string(p->context, S_OR(p->drings.ringContext[counter].contextData, p->defcontext), sizeof(p->context));
 ast_channel_context_set(chan, S_OR(p->drings.ringContext[counter].contextData, p->defcontext));
 ast_verb(3, "Distinctive Ring matched context %s\n",p->context);
 break;
 }
 }
 }
 /* Restore linear mode (if appropriate) for Caller*ID processing */
 dahdi_setlinear(p->subs[idx].dfd, p->subs[idx].linear);
#if 1
 restore_gains(p);
#endif
 if (res < 0) {
 ast_log(LOG_WARNING, "CallerID returned with error on channel '%s'\n", ast_channel_name(chan));
 }
 } else
 ast_log(LOG_WARNING, "Unable to get caller ID space\n");
 }
 } else
 cs = NULL;

 if (number)
 ast_shrink_phone_number(number);
 ast_set_callerid(chan, number, name, number);

 ao2_cleanup(smdi_msg);

 if (cs)
 callerid_free(cs);

 my_handle_notify_message(chan, p, flags, -1);

 ast_channel_lock(chan);
 ast_setstate(chan, AST_STATE_RING);
 ast_channel_rings_set(chan, 1);
 ast_channel_unlock(chan);
 p->ringt = p->ringt_base;
 res = ast_pbx_run(chan);
 if (res) {
 ast_hangup(chan);
 ast_log(LOG_WARNING, "PBX exited non-zero\n");
 }
 goto quit;
 default:
 ast_log(LOG_WARNING, "Don't know how to handle simple switch with signalling %s on channel %d\n", sig2str(p->sig), p->channel);
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_CONGESTION);
 if (res < 0)
 ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", p->channel);
 }
 res = tone_zone_play_tone(p->subs[idx].dfd, DAHDI_TONE_CONGESTION);
 if (res < 0)
 ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", p->channel);
 ast_hangup(chan);
quit:
 ast_mutex_lock(&ss_thread_lock);
 ss_thread_count--;
 ast_cond_signal(&ss_thread_complete);
 ast_mutex_unlock(&ss_thread_lock);
 return NULL;
}

analog_tone_to_dahditone()

static int analog_tone_to_dahditone ( enum analog_tone  tone )

static

Definition at line 1106 of file chan_dahdi.c.

References ANALOG_TONE_CONGESTION, ANALOG_TONE_DIALRECALL, ANALOG_TONE_DIALTONE, ANALOG_TONE_INFO, ANALOG_TONE_RINGTONE, and ANALOG_TONE_STUTTER.

Referenced by my_play_tone().

{
 switch (tone) {
 case ANALOG_TONE_RINGTONE:
 return DAHDI_TONE_RINGTONE;
 case ANALOG_TONE_STUTTER:
 return DAHDI_TONE_STUTTER;
 case ANALOG_TONE_CONGESTION:
 return DAHDI_TONE_CONGESTION;
 case ANALOG_TONE_DIALTONE:
 return DAHDI_TONE_DIALTONE;
 case ANALOG_TONE_DIALRECALL:
 return DAHDI_TONE_DIALRECALL;
 case ANALOG_TONE_INFO:
 return DAHDI_TONE_INFO;
 default:
 return -1;
 }
}

analogsub_to_dahdisub()

static int analogsub_to_dahdisub ( enum analog_sub  analogsub )

static

Definition at line 1126 of file chan_dahdi.c.

References ANALOG_SUB_CALLWAIT, ANALOG_SUB_REAL, ANALOG_SUB_THREEWAY, ast_log, LOG_ERROR, SUB_CALLWAIT, SUB_REAL, and SUB_THREEWAY.

Referenced by my_allocate_sub(), my_conf_add(), my_conf_del(), my_get_sub_fd(), my_handle_dtmf(), my_is_dialing(), my_new_analog_ast_channel(), my_play_tone(), my_set_inthreeway(), my_set_linear_mode(), my_swap_subchannels(), my_unallocate_sub(), and my_wink().

{
 int index;

 switch (analogsub) {
 case ANALOG_SUB_REAL:
 index = SUB_REAL;
 break;
 case ANALOG_SUB_CALLWAIT:
 index = SUB_CALLWAIT;
 break;
 case ANALOG_SUB_THREEWAY:
 index = SUB_THREEWAY;
 break;
 default:
 ast_log(LOG_ERROR, "Unidentified sub!\n");
 index = SUB_REAL;
 }

 return index;
}

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 19922 of file chan_dahdi.c.

attempt_transfer()

static int attempt_transfer ( struct dahdi_pvt *  p )

static

Definition at line 7145 of file chan_dahdi.c.

References ast_bridge_transfer_attended(), AST_BRIDGE_TRANSFER_SUCCESS, ast_channel_lock, ast_channel_name(), ast_channel_ref, ast_channel_unlock, ast_channel_unref, ast_mutex_lock, ast_mutex_unlock, ast_softhangup(), AST_SOFTHANGUP_DEV, ast_verb, dahdi_pvt::lock, dahdi_subchannel::owner, SUB_REAL, SUB_THREEWAY, and dahdi_pvt::subs.

Referenced by dahdi_handle_event().

{
 struct ast_channel *owner_real;
 struct ast_channel *owner_3way;
 enum ast_transfer_result xfer_res;
 int res = 0;

 owner_real = ast_channel_ref(p->subs[SUB_REAL].owner);
 owner_3way = ast_channel_ref(p->subs[SUB_THREEWAY].owner);

 ast_verb(3, "TRANSFERRING %s to %s\n",
 ast_channel_name(owner_3way), ast_channel_name(owner_real));

 ast_channel_unlock(owner_real);
 ast_channel_unlock(owner_3way);
 ast_mutex_unlock(&p->lock);

 xfer_res = ast_bridge_transfer_attended(owner_3way, owner_real);
 if (xfer_res != AST_BRIDGE_TRANSFER_SUCCESS) {
 ast_softhangup(owner_3way, AST_SOFTHANGUP_DEV);
 res = -1;
 }

 /* Must leave with these locked. */
 ast_channel_lock(owner_real);
 ast_mutex_lock(&p->lock);

 ast_channel_unref(owner_real);
 ast_channel_unref(owner_3way);

 return res;
}

available()

static int available ( struct dahdi_pvt **  pvt, int  is_specific_channel  )

static

Definition at line 13058 of file chan_dahdi.c.

References analog_available(), ARRAY_LEN, ast_calloc, ast_cc_config_params_init, ast_copy_string(), ast_free, ast_log, ast_mutex_init, dahdi_pvt::buf_no, dahdi_pvt::buf_policy, dahdi_pvt::bufsize, dahdi_pvt::cc_params, CHAN_PSEUDO, sig_pri_chan::chan_pvt, sig_pri_chan::channel, dahdi_pvt::channel, dahdi_pvt::context, dahdi_analog_lib_handles(), dahdi_open(), destroy_dahdi_pvt(), dahdi_subchannel::dfd, errno, dahdi_pvt::faxbuf_no, dahdi_pvt::faxbuf_policy, dahdi_pvt::hidecallerid, dahdi_pvt::hidecalleridname, dahdi_pvt::immediate, dahdi_pvt::inalarm, dahdi_pvt::law_default, dahdi_pvt::locallyblocked, dahdi_pvt::lock, LOG_ERROR, LOG_WARNING, dahdi_pvt::mohinterpret, sig_pri_chan::no_b_channel, NULL, sig_pri_span::numchans, dahdi_pvt::oprmode, dahdi_pvt::outsigmod, dahdi_pvt::owner, dahdi_pvt::priexclusive, dahdi_pvt::priindication_oob, sig_pri_span::pvts, dahdi_pvt::radio, dahdi_pvt::remotelyblocked, dahdi_pvt::sig, sig_pri_span::sig, sig_pri_available(), sig_pri_chan_new(), SIG_PRI_LIB_HANDLE_CASES, dahdi_pvt::sig_pvt, SIG_SS7, sig_ss7_available(), dahdi_pvt::span, sig_pri_span::span, dahdi_pvt::stripmsd, SUB_REAL, dahdi_pvt::subs, dahdi_pvt::use_callerid, and dahdi_pvt::use_callingpres.

Referenced by __ast_string_field_ptr_build_va(), ast_logger_register_level(), dahdi_request(), is_member_available(), and logger_register_level().

{
 struct dahdi_pvt *p = *pvt;

 if (p->inalarm)
 return 0;

 if (dahdi_analog_lib_handles(p->sig, p->radio, p->oprmode))
 return analog_available(p->sig_pvt);

 switch (p->sig) {
#if defined(HAVE_PRI)
 case SIG_PRI_LIB_HANDLE_CASES:
 {
 struct sig_pri_chan *pvt_chan;
 int res;

 pvt_chan = p->sig_pvt;
 res = sig_pri_available(&pvt_chan, is_specific_channel);
 *pvt = pvt_chan->chan_pvt;
 return res;
 }
#endif /* defined(HAVE_PRI) */
#if defined(HAVE_SS7)
 case SIG_SS7:
 return sig_ss7_available(p->sig_pvt);
#endif /* defined(HAVE_SS7) */
 default:
 break;
 }

 if (p->locallyblocked || p->remotelyblocked) {
 return 0;
 }

 /* If no owner definitely available */
 if (!p->owner) {
#ifdef HAVE_OPENR2
 /* Trust MFC/R2 */
 if (p->mfcr2) {
 if (p->mfcr2call) {
 return 0;
 } else {
 return 1;
 }
 }
#endif
 return 1;
 }

 return 0;
}

build_channels()

static int build_channels ( struct dahdi_chan_conf *  conf, const char *  value, int  reload, int  lineno  )

static

Definition at line 17667 of file chan_dahdi.c.

References ast_log, ast_strdupa, ast_verb, c, dahdi_chan_conf::chan, CHAN_PSEUDO, has_pseudo, dahdi_chan_conf::is_sig_auto, LOG_ERROR, LOG_WARNING, mkintf(), dahdi_pvt::sig, sig2str, strsep(), tmp(), dahdi_chan_conf::wanted_channels_end, and dahdi_chan_conf::wanted_channels_start.

Referenced by process_dahdi().

{
 char *c, *chan;
 int x, start, finish;
 struct dahdi_pvt *tmp;

 if ((reload == 0) && (conf->chan.sig < 0) && !conf->is_sig_auto) {
 ast_log(LOG_ERROR, "Signalling must be specified before any channels are.\n");
 return -1;
 }

 c = ast_strdupa(value);

 while ((chan = strsep(&c, ","))) {
 if (sscanf(chan, "%30d-%30d", &start, &finish) == 2) {
 /* Range */
 } else if (sscanf(chan, "%30d", &start)) {
 /* Just one */
 finish = start;
 } else if (!strcasecmp(chan, "pseudo")) {
 finish = start = CHAN_PSEUDO;
 } else {
 ast_log(LOG_ERROR, "Syntax error parsing '%s' at '%s'\n", value, chan);
 return -1;
 }
 if (finish < start) {
 ast_log(LOG_WARNING, "Sillyness: %d < %d\n", start, finish);
 x = finish;
 finish = start;
 start = x;
 }

 for (x = start; x <= finish; x++) {
 if (conf->wanted_channels_start &&
 (x < conf->wanted_channels_start ||
 x > conf->wanted_channels_end)
 ) {
 continue;
 }
 tmp = mkintf(x, conf, reload);

 if (tmp) {
 ast_verb(3, "%s channel %d, %s signalling\n", reload ? "Reconfigured" : "Registered", x, sig2str(tmp->sig));
 } else {
 ast_log(LOG_ERROR, "Unable to %s channel '%s'\n",
 (reload == 1) ? "reconfigure" : "register", value);
 return -1;
 }
 if (x == CHAN_PSEUDO) {
 has_pseudo = 1;
 }
 }
 }

 return 0;
}

bump_gains()

static int bump_gains ( struct dahdi_pvt *  p )

static

Definition at line 4895 of file chan_dahdi.c.

References ast_log, dahdi_pvt::cid_rxgain, dahdi_subchannel::dfd, errno, dahdi_pvt::law, LOG_WARNING, dahdi_pvt::rxdrc, dahdi_pvt::rxgain, set_actual_gain(), SUB_REAL, dahdi_pvt::subs, dahdi_pvt::txdrc, and dahdi_pvt::txgain.

Referenced by analog_ss_thread(), dahdi_dial_str(), mwi_thread(), and my_start_cid_detect().

{
 int res;

 /* Bump receive gain by value stored in cid_rxgain */
 res = set_actual_gain(p->subs[SUB_REAL].dfd, p->rxgain + p->cid_rxgain, p->txgain, p->rxdrc, p->txdrc, p->law);
 if (res) {
 ast_log(LOG_WARNING, "Unable to bump gain: %s\n", strerror(errno));
 return -1;
 }

 return 0;
}

calc_energy()

static int calc_energy ( const unsigned char *  buf, int  len, struct ast_format *  law  )

static

Definition at line 10712 of file chan_dahdi.c.

References abs, AST_ALAW, ast_format_ulaw, AST_MULAW, and len().

Referenced by do_monitor(), and mwi_thread().

{
 int x;
 int sum = 0;

 if (!len)
 return 0;

 for (x = 0; x < len; x++)
 sum += abs(law == ast_format_ulaw ? AST_MULAW(buf[x]) : AST_ALAW(buf[x]));

 return sum / len;
}

canmatch_featurecode()

static int canmatch_featurecode ( const char *  pickupexten, const char *  exten  )

static

Definition at line 9485 of file chan_dahdi.c.

Referenced by analog_ss_thread().

{
 int extlen = strlen(exten);

 if (!extlen) {
 return 1;
 }

 if (extlen < strlen(pickupexten) && !strncmp(pickupexten, exten, extlen)) {
 return 1;
 }
 /* hardcoded features are *60, *67, *69, *70, *72, *73, *78, *79, *82, *0 */
 if (exten[0] == '*' && extlen < 3) {
 if (extlen == 1) {
 return 1;
 }
 /* "*0" should be processed before it gets here */
 switch (exten[1]) {
 case '6':
 case '7':
 case '8':
 return 1;
 }
 }
 return 0;
}

check_for_conference()

static int check_for_conference ( struct dahdi_pvt *  p )

static

Definition at line 7178 of file chan_dahdi.c.

References ast_log, ast_verb, dahdi_pvt::channel, dahdi_pvt::confno, dahdi_subchannel::curconf, dahdi_subchannel::dfd, errno, LOG_WARNING, dahdi_pvt::master, SUB_REAL, and dahdi_pvt::subs.

Referenced by dahdi_handle_event(), my_check_for_conference(), and my_complete_conference_update().

{
 struct dahdi_confinfo ci;
 /* Fine if we already have a master, etc */
 if (p->master || (p->confno > -1))
 return 0;
 memset(&ci, 0, sizeof(ci));
 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_GETCONF, &ci)) {
 ast_log(LOG_WARNING, "Failed to get conference info on channel %d: %s\n", p->channel, strerror(errno));
 return 0;
 }
 /* If we have no master and don't have a confno, then
 if we're in a conference, it's probably a MeetMe room or
 some such, so don't let us 3-way out! */
 if ((p->subs[SUB_REAL].curconf.confno != ci.confno) || (p->subs[SUB_REAL].curconf.confmode != ci.confmode)) {
 ast_verb(3, "Avoiding 3-way call when in an external conference\n");
 return 1;
 }
 return 0;
}

conf_add()

static int conf_add ( struct dahdi_pvt *  p, struct dahdi_subchannel *  c, int  index, int  slavechannel  )

static

Definition at line 4457 of file chan_dahdi.c.

References ast_debug, ast_log, dahdi_pvt::confno, dahdi_subchannel::curconf, dahdi_subchannel::dfd, errno, and LOG_WARNING.

Referenced by dahdi_conf_update(), my_complete_conference_update(), my_conf_add(), and my_conf_del().

{
 /* If the conference already exists, and we're already in it
 don't bother doing anything */
 struct dahdi_confinfo zi;

 memset(&zi, 0, sizeof(zi));
 zi.chan = 0;

 if (slavechannel > 0) {
 /* If we have only one slave, do a digital mon */
 zi.confmode = DAHDI_CONF_DIGITALMON;
 zi.confno = slavechannel;
 } else {
 if (!idx) {
 /* Real-side and pseudo-side both participate in conference */
 zi.confmode = DAHDI_CONF_REALANDPSEUDO | DAHDI_CONF_TALKER | DAHDI_CONF_LISTENER |
 DAHDI_CONF_PSEUDO_TALKER | DAHDI_CONF_PSEUDO_LISTENER;
 } else
 zi.confmode = DAHDI_CONF_CONF | DAHDI_CONF_TALKER | DAHDI_CONF_LISTENER;
 zi.confno = p->confno;
 }
 if ((zi.confno == c->curconf.confno) && (zi.confmode == c->curconf.confmode))
 return 0;
 if (c->dfd < 0)
 return 0;
 if (ioctl(c->dfd, DAHDI_SETCONF, &zi)) {
 ast_log(LOG_WARNING, "Failed to add %d to conference %d/%d: %s\n", c->dfd, zi.confmode, zi.confno, strerror(errno));
 return -1;
 }
 if (slavechannel < 1) {
 p->confno = zi.confno;
 }
 c->curconf = zi;
 ast_debug(1, "Added %d to conference %d/%d\n", c->dfd, c->curconf.confmode, c->curconf.confno);
 return 0;
}

conf_del()

static int conf_del ( struct dahdi_pvt *  p, struct dahdi_subchannel *  c, int  index  )

static

Definition at line 4506 of file chan_dahdi.c.

References ast_debug, ast_log, dahdi_subchannel::curconf, dahdi_subchannel::dfd, errno, isourconf(), and LOG_WARNING.

Referenced by dahdi_conf_update(), dahdi_master_slave_unlink(), my_all_subchannels_hungup(), and my_conf_del().

{
 struct dahdi_confinfo zi;
 if (/* Can't delete if there's no dfd */
 (c->dfd < 0) ||
 /* Don't delete from the conference if it's not our conference */
 !isourconf(p, c)
 /* Don't delete if we don't think it's conferenced at all (implied) */
 ) return 0;
 memset(&zi, 0, sizeof(zi));
 if (ioctl(c->dfd, DAHDI_SETCONF, &zi)) {
 ast_log(LOG_WARNING, "Failed to drop %d from conference %d/%d: %s\n", c->dfd, c->curconf.confmode, c->curconf.confno, strerror(errno));
 return -1;
 }
 ast_debug(1, "Removed %d from conference %d/%d\n", c->dfd, c->curconf.confmode, c->curconf.confno);
 memcpy(&c->curconf, &zi, sizeof(c->curconf));
 return 0;
}

create_channel_name()

static struct ast_str* create_channel_name ( struct dahdi_pvt *  i )

static

Definition at line 9099 of file chan_dahdi.c.

References ast_channel_name(), ast_mutex_lock, ast_mutex_unlock, ast_random(), ast_str_buffer(), ast_str_create, ast_str_set(), ast_strlen_zero, CHAN_PSEUDO, dahdi_pvt::channel, dahdi_pvt::cid_num, dahdi_pvt::cid_subaddr, dahdi_pvt::lock, NULL, dahdi_subchannel::owner, dahdi_pvt::span, and dahdi_pvt::subs.

Referenced by dahdi_cc_callback(), dahdi_indicate(), and dahdi_new().

{
 struct ast_str *chan_name;
 int x, y;

 /* Create the new channel name tail. */
 if (!(chan_name = ast_str_create(32))) {
 return NULL;
 }
 if (i->channel == CHAN_PSEUDO) {
 ast_str_set(&chan_name, 0, "pseudo-%ld", ast_random());
#if defined(HAVE_PRI)
 } else if (i->pri) {
 ast_mutex_lock(&i->pri->lock);
 y = ++i->pri->new_chan_seq;
 if (is_outgoing) {
 ast_str_set(&chan_name, 0, "i%d/%s-%x", i->pri->span, address, (unsigned)y);
 address[0] = '\0';
 } else if (ast_strlen_zero(i->cid_subaddr)) {
 /* Put in caller-id number only since there is no subaddress. */
 ast_str_set(&chan_name, 0, "i%d/%s-%x", i->pri->span, i->cid_num, (unsigned)y);
 } else {
 /* Put in caller-id number and subaddress. */
 ast_str_set(&chan_name, 0, "i%d/%s:%s-%x", i->pri->span, i->cid_num,
 i->cid_subaddr, (unsigned)y);
 }
 ast_mutex_unlock(&i->pri->lock);
#endif /* defined(HAVE_PRI) */
 } else {
 y = 1;
 do {
 ast_str_set(&chan_name, 0, "%d-%d", i->channel, y);
 for (x = 0; x < 3; ++x) {
 if (i->subs[x].owner && !strcasecmp(ast_str_buffer(chan_name),
 ast_channel_name(i->subs[x].owner) + 6)) {
 break;
 }
 }
 ++y;
 } while (x < 3);
 }
 return chan_name;
}

dahdi_ami_channel_event()

static void dahdi_ami_channel_event ( struct dahdi_pvt *  p, struct ast_channel *  chan  )

static

Definition at line 1801 of file chan_dahdi.c.

References CHAN_PSEUDO, dahdi_pvt::channel, dahdi_pvt::group, publish_dahdichannel(), and dahdi_pvt::span.

Referenced by dahdi_new().

{
 char ch_name[23];

 if (p->channel < CHAN_PSEUDO) {
 /* No B channel */
 snprintf(ch_name, sizeof(ch_name), "no-media (%d)", p->channel);
 } else if (p->channel == CHAN_PSEUDO) {
 /* Pseudo channel */
 strcpy(ch_name, "pseudo");
 } else {
 /* Real channel */
 snprintf(ch_name, sizeof(ch_name), "%d", p->channel);
 }
 publish_dahdichannel(chan, p->group, p->span, ch_name);
}

dahdi_answer()

static int dahdi_answer ( struct ast_channel *  ast )

static

Todo:

XXX this is redundantly set by the analog and PRI submodules!

Definition at line 6409 of file chan_dahdi.c.

References analog_answer(), ast_channel_tech_pvt(), ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_setstate(), AST_STATE_UP, dahdi_pvt::channel, dahdi_analog_lib_handles(), dahdi_get_index, dahdi_pvt::lock, LOG_WARNING, dahdi_pvt::oprmode, dahdi_pvt::radio, dahdi_pvt::sig, SIG_MFCR2, sig_pri_answer(), SIG_PRI_LIB_HANDLE_CASES, dahdi_pvt::sig_pvt, SIG_SS7, sig_ss7_answer(), and SUB_REAL.

Referenced by dahdi_chan_conf_default().

{
 struct dahdi_pvt *p = ast_channel_tech_pvt(ast);
 int res = 0;
 int idx;
 ast_setstate(ast, AST_STATE_UP);/*! \todo XXX this is redundantly set by the analog and PRI submodules! */
 ast_mutex_lock(&p->lock);
 idx = dahdi_get_index(ast, p, 0);
 if (idx < 0)
 idx = SUB_REAL;
 /* nothing to do if a radio channel */
 if ((p->radio || (p->oprmode < 0))) {
 ast_mutex_unlock(&p->lock);
 return 0;
 }

 if (dahdi_analog_lib_handles(p->sig, p->radio, p->oprmode)) {
 res = analog_answer(p->sig_pvt, ast);
 ast_mutex_unlock(&p->lock);
 return res;
 }

 switch (p->sig) {
#if defined(HAVE_PRI)
 case SIG_PRI_LIB_HANDLE_CASES:
 res = sig_pri_answer(p->sig_pvt, ast);
 break;
#endif /* defined(HAVE_PRI) */
#if defined(HAVE_SS7)
 case SIG_SS7:
 res = sig_ss7_answer(p->sig_pvt, ast);
 break;
#endif /* defined(HAVE_SS7) */
#ifdef HAVE_OPENR2
 case SIG_MFCR2:
 if (!p->mfcr2_call_accepted) {
 /* The call was not accepted on offer nor the user, so it must be accepted now before answering,
 openr2_chan_answer_call will be called when the callback on_call_accepted is executed */
 p->mfcr2_answer_pending = 1;
 if (p->mfcr2_charge_calls) {
 ast_debug(1, "Accepting MFC/R2 call with charge before answering on chan %d\n", p->channel);
 openr2_chan_accept_call(p->r2chan, OR2_CALL_WITH_CHARGE);
 } else {
 ast_debug(1, "Accepting MFC/R2 call with no charge before answering on chan %d\n", p->channel);
 openr2_chan_accept_call(p->r2chan, OR2_CALL_NO_CHARGE);
 }
 } else {
 ast_debug(1, "Answering MFC/R2 call on chan %d\n", p->channel);
 dahdi_r2_answer(p);
 }
 break;
#endif
 case 0:
 ast_mutex_unlock(&p->lock);
 return 0;
 default:
 ast_log(LOG_WARNING, "Don't know how to answer signalling %d (channel %d)\n", p->sig, p->channel);
 res = -1;
 break;
 }
 ast_mutex_unlock(&p->lock);
 return res;
}

dahdi_call()

static int dahdi_call ( struct ast_channel *  ast, const char *  rdest, int  timeout  )

static

Definition at line 5121 of file chan_dahdi.c.

References analog_call(), args, AST_APP_ARG, ast_channel_connected(), ast_channel_name(), ast_channel_tech_pvt(), ast_channel_transfercapability(), ast_copy_string(), ast_debug, AST_DECLARE_APP_ARGS, ast_log, ast_mutex_lock, ast_mutex_unlock, AST_NONSTANDARD_APP_ARGS, ast_setstate(), AST_STATE_BUSY, AST_STATE_DIALING, AST_STATE_DOWN, AST_STATE_RESERVED, AST_STATE_UP, ast_strdupa, c, dahdi_pvt::callwaitrings, dahdi_pvt::channel, dahdi_analog_lib_handles(), dahdi_sig_pri_lib_handles(), dahdi_subchannel::dfd, dahdi_pvt::dialdest, dahdi_pvt::dialednone, dahdi_pvt::dialing, errno, ext, dahdi_pvt::exten, dahdi_pvt::hidecallerid, ast_party_connected_line::id, IS_DIGITAL, dahdi_pvt::law, dahdi_pvt::lock, LOG_ERROR, LOG_WARNING, dahdi_subchannel::needbusy, NULL, ast_party_id::number, dahdi_pvt::oprmode, dahdi_pvt::outgoing, dahdi_pvt::outsigmod, dahdi_pvt::radio, dahdi_pvt::rxdrc, dahdi_pvt::rxgain, set_actual_gain(), dahdi_pvt::sig, SIG_MFCR2, sig_pri_call(), sig_pri_extract_called_num_subaddr(), dahdi_pvt::sig_pvt, SIG_SS7, sig_ss7_call(), ast_party_number::str, dahdi_pvt::stripmsd, SUB_REAL, dahdi_pvt::subs, dahdi_pvt::txdrc, dahdi_pvt::txgain, ast_party_number::valid, and dahdi_pvt::waitingfordt.

Referenced by dahdi_chan_conf_default().

{
 struct dahdi_pvt *p = ast_channel_tech_pvt(ast);
 int x, res, mysig;
 char *dest;
 AST_DECLARE_APP_ARGS(args,
 AST_APP_ARG(group); /* channel/group token */
 AST_APP_ARG(ext); /* extension token */
 //AST_APP_ARG(opts); /* options token */
 AST_APP_ARG(other); /* Any remining unused arguments */
 );

 ast_mutex_lock(&p->lock);
 ast_copy_string(p->dialdest, rdest, sizeof(p->dialdest));

 /* Split the dialstring */
 dest = ast_strdupa(rdest);
 AST_NONSTANDARD_APP_ARGS(args, dest, '/');
 if (!args.ext) {
 args.ext = "";
 }

#if defined(HAVE_PRI)
 if (dahdi_sig_pri_lib_handles(p->sig)) {
 char *subaddr;

 sig_pri_extract_called_num_subaddr(p->sig_pvt, rdest, p->exten, sizeof(p->exten));

 /* Remove any subaddress for uniformity with incoming calls. */
 subaddr = strchr(p->exten, ':');
 if (subaddr) {
 *subaddr = '\0';
 }
 } else
#endif /* defined(HAVE_PRI) */
 {
 ast_copy_string(p->exten, args.ext, sizeof(p->exten));
 }

 if ((ast_channel_state(ast) == AST_STATE_BUSY)) {
 p->subs[SUB_REAL].needbusy = 1;
 ast_mutex_unlock(&p->lock);
 return 0;
 }
 if ((ast_channel_state(ast) != AST_STATE_DOWN) && (ast_channel_state(ast) != AST_STATE_RESERVED)) {
 ast_log(LOG_WARNING, "dahdi_call called on %s, neither down nor reserved\n", ast_channel_name(ast));
 ast_mutex_unlock(&p->lock);
 return -1;
 }
 p->waitingfordt.tv_sec = 0;
 p->dialednone = 0;
 if ((p->radio || (p->oprmode < 0))) /* if a radio channel, up immediately */
 {
 /* Special pseudo -- automatically up */
 ast_setstate(ast, AST_STATE_UP);
 ast_mutex_unlock(&p->lock);
 return 0;
 }
 x = DAHDI_FLUSH_READ | DAHDI_FLUSH_WRITE;
 res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_FLUSH, &x);
 if (res)
 ast_log(LOG_WARNING, "Unable to flush input on channel %d: %s\n", p->channel, strerror(errno));
 p->outgoing = 1;

 if (IS_DIGITAL(ast_channel_transfercapability(ast))){
 set_actual_gain(p->subs[SUB_REAL].dfd, 0, 0, p->rxdrc, p->txdrc, p->law);
 } else {
 set_actual_gain(p->subs[SUB_REAL].dfd, p->rxgain, p->txgain, p->rxdrc, p->txdrc, p->law);
 }

#ifdef HAVE_PRI
 if (dahdi_sig_pri_lib_handles(p->sig)) {
 res = sig_pri_call(p->sig_pvt, ast, rdest, timeout,
 (p->law == DAHDI_LAW_ALAW) ? PRI_LAYER_1_ALAW : PRI_LAYER_1_ULAW);
 ast_mutex_unlock(&p->lock);
 return res;
 }
#endif

#if defined(HAVE_SS7)
 if (p->sig == SIG_SS7) {
 res = sig_ss7_call(p->sig_pvt, ast, rdest);
 ast_mutex_unlock(&p->lock);
 return res;
 }
#endif /* defined(HAVE_SS7) */

 /* If this is analog signalling we can exit here */
 if (dahdi_analog_lib_handles(p->sig, p->radio, p->oprmode)) {
 p->callwaitrings = 0;
 res = analog_call(p->sig_pvt, ast, rdest, timeout);
 ast_mutex_unlock(&p->lock);
 return res;
 }

 mysig = p->outsigmod > -1 ? p->outsigmod : p->sig;
 switch (mysig) {
 case 0:
 /* Special pseudo -- automatically up*/
 ast_setstate(ast, AST_STATE_UP);
 break;
 case SIG_MFCR2:
 break;
 default:
 ast_debug(1, "not yet implemented\n");
 ast_mutex_unlock(&p->lock);
 return -1;
 }

#ifdef HAVE_OPENR2
 if (p->mfcr2) {
 openr2_calling_party_category_t chancat;
 int callres = 0;
 char *c, *l;

 /* We'll get it in a moment -- but use dialdest to store pre-setup_ack digits */
 p->dialdest[0] = '\0';

 c = args.ext;
 if (!p->hidecallerid) {
 l = ast_channel_connected(ast)->id.number.valid ? ast_channel_connected(ast)->id.number.str : NULL;
 } else {
 l = NULL;
 }
 if (strlen(c) < p->stripmsd) {
 ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
 ast_mutex_unlock(&p->lock);
 return -1;
 }
 p->dialing = 1;
 chancat = dahdi_r2_get_channel_category(ast);
 callres = openr2_chan_make_call(p->r2chan, l, (c + p->stripmsd), chancat);
 if (-1 == callres) {
 ast_mutex_unlock(&p->