chan_misdn.c File Reference

the chan_misdn channel driver for Asterisk More...

#include "asterisk.h"
#include <pthread.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <signal.h>
#include <sys/file.h>
#include <semaphore.h>
#include <ctype.h>
#include <time.h>
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/io.h"
#include "asterisk/frame.h"
#include "asterisk/translate.h"
#include "asterisk/cli.h"
#include "asterisk/musiconhold.h"
#include "asterisk/dsp.h"
#include "asterisk/file.h"
#include "asterisk/callerid.h"
#include "asterisk/indications.h"
#include "asterisk/app.h"
#include "asterisk/features.h"
#include "asterisk/term.h"
#include "asterisk/sched.h"
#include "asterisk/stringfields.h"
#include "asterisk/abstract_jb.h"
#include "asterisk/causes.h"
#include "asterisk/format.h"
#include "asterisk/format_cap.h"
#include "asterisk/features_config.h"
#include "asterisk/bridge.h"
#include "asterisk/pickup.h"
#include "asterisk/format_cache.h"
#include "chan_misdn_config.h"
#include "isdn_lib.h"
#include "asterisk/strings.h"

Include dependency graph for chan_misdn.c:

Go to the source code of this file.

Data Structures
struct	allowed_bearers
struct	chan_list
	Channel call record structure. More...
struct	hold_info
struct	misdn_jb
struct	robin_list
struct	state_struct

Macros
#define	chan_list_ref(obj, debug)   ao2_t_ref((obj), +1, (debug))
#define	chan_list_unref(obj, debug)   ao2_t_ref((obj), -1, (debug))
#define	MISDN_ASTERISK_TECH_PVT(ast)   ast_channel_tech_pvt(ast)
#define	MISDN_ASTERISK_TECH_PVT_SET(ast, value)   ast_channel_tech_pvt_set(ast, value)
#define	ORG_AST   1
#define	ORG_MISDN   2
#define	TRANSFER_ON_HELD_CALL_HANGUP   1

Enumerations
enum	misdn_chan_state {   MISDN_NOTHING = 0, MISDN_WAITING4DIGS, MISDN_EXTCANTMATCH, MISDN_INCOMING_SETUP,   MISDN_DIALING, MISDN_PROGRESS, MISDN_PROCEEDING, MISDN_CALLING,   MISDN_CALLING_ACKNOWLEDGE, MISDN_ALERTING, MISDN_BUSY, MISDN_CONNECTED,   MISDN_DISCONNECTED, MISDN_CLEANING }
enum	misdn_hold_state { MISDN_HOLD_IDLE, MISDN_HOLD_ACTIVE, MISDN_HOLD_TRANSFER, MISDN_HOLD_DISCONNECT }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static int	_misdn_tasks_add_variable (int timeout, ast_sched_cb callback, const void *data, int variable)
int	add_in_calls (int port)
int	add_out_calls (int port)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static enum mISDN_NUMBER_PLAN	ast_to_misdn_plan (unsigned ast_number_plan)
static int	ast_to_misdn_pres (int presentation)
static enum mISDN_REDIRECTING_REASON	ast_to_misdn_reason (const enum AST_REDIRECTING_REASON ast)
static int	ast_to_misdn_screen (int screening)
static enum mISDN_NUMBER_TYPE	ast_to_misdn_ton (unsigned ast_number_type)
static const char *	bearer2str (int cap)
static enum event_response_e	cb_events (enum event_e event, struct misdn_bchannel *bc, void *user_data)
static void	chan_list_destructor (void *obj)
static struct chan_list *	chan_list_init (int orig)
int	chan_misdn_jb_empty (struct misdn_bchannel *bc, char *buf, int len)
static void	chan_misdn_log (int level, int port, char *tmpl,...)
static int	cl_dequeue_chan (struct chan_list *chan)
static void	cl_queue_chan (struct chan_list *chan)
static char *	complete_ch (struct ast_cli_args *a)
static char *	complete_debug_port (struct ast_cli_args *a)
static char *	complete_show_config (struct ast_cli_args *a)
static void	config_jitterbuffer (struct chan_list *ch)
void	debug_numtype (int port, int numtype, char *type)
static int	dialtone_indicate (struct chan_list *cl)
static void	do_immediate_setup (struct misdn_bchannel *bc, struct chan_list *ch, struct ast_channel *ast)
static void	export_aoc_vars (int originator, struct ast_channel *ast, struct misdn_bchannel *bc)
void	export_ch (struct ast_channel *chan, struct misdn_bchannel *bc, struct chan_list *ch)
	Export parameters to the dialplan environment variables. More...
static struct chan_list *	find_chan_by_bc (struct misdn_bchannel *bc)
static struct chan_list *	find_hold_active_call (struct misdn_bchannel *bc)
static struct chan_list *	find_hold_call (struct misdn_bchannel *bc)
static struct chan_list *	find_hold_call_l3 (unsigned long l3_id)
static void	free_robin_list (void)
static struct chan_list *	get_chan_by_ast_name (const char *name)
static struct robin_list *	get_robin_position (char *group)
static char *	handle_cli_misdn_port_block (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_port_down (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_port_unblock (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_port_up (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_restart_pid (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_restart_port (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_send_digit (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_send_display (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_send_facility (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_send_restart (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_set_crypt_debug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_set_debug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_set_tics (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_show_channel (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_show_channels (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_show_config (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_show_port (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_show_ports_stats (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_show_stacks (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_misdn_toggle_echocancel (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static void	hangup_chan (struct chan_list *ch, struct misdn_bchannel *bc)
static void	hanguptone_indicate (struct chan_list *cl)
void	import_ch (struct ast_channel *chan, struct misdn_bchannel *bc, struct chan_list *ch)
	Import parameters from the dialplan environment variables. More...
static int	load_module (void)
	Load the module. More...
static void	misdn_add_number_prefix (int port, enum mISDN_NUMBER_TYPE number_type, char *number, size_t size)
static int	misdn_answer (struct ast_channel *ast)
static int	misdn_attempt_transfer (struct chan_list *active_ch, struct chan_list *held_ch)
static int	misdn_call (struct ast_channel *ast, const char *dest, int timeout)
static int	misdn_chan_is_valid (struct chan_list *ch)
static int	misdn_check_l2l1 (struct ast_channel *chan, const char *data)
static void	misdn_copy_redirecting_from_ast (struct misdn_bchannel *bc, struct ast_channel *ast)
static void	misdn_copy_redirecting_to_ast (struct ast_channel *ast, const struct misdn_party_redirecting *redirect, char *tag)
static int	misdn_digit_begin (struct ast_channel *chan, char digit)
static int	misdn_digit_end (struct ast_channel *ast, char digit, unsigned int duration)
static int	misdn_facility_exec (struct ast_channel *chan, const char *data)
static void	misdn_facility_ie_handler (enum event_e event, struct misdn_bchannel *bc, struct chan_list *ch)
static int	misdn_fixup (struct ast_channel *oldast, struct ast_channel *ast)
static const char *	misdn_get_ch_state (struct chan_list *p)
static void	misdn_get_connected_line (struct ast_channel *ast, struct misdn_bchannel *bc, int originator)
static int	misdn_hangup (struct ast_channel *ast)
static int	misdn_indication (struct ast_channel *ast, int cond, const void *data, size_t datalen)
static int	misdn_is_msn_valid (int port, const struct misdn_party_dialing *dialed)
void	misdn_jb_destroy (struct misdn_jb *jb)
	frees the data and destroys the given jitterbuffer struct More...
int	misdn_jb_empty (struct misdn_jb *jb, char *data, int len)
	gets len bytes out of the jitterbuffer if available, else only the available data is returned and the return value indicates the number of data. More...
int	misdn_jb_fill (struct misdn_jb *jb, const char *data, int len)
	fills the jitterbuffer with len data returns < 0 if there was an error (buffer overrun). More...
struct misdn_jb *	misdn_jb_init (int size, int upper_threshold)
	allocates the jb-structure and initialize the elements More...
static int	misdn_l1_task (const void *vdata)
static struct ast_channel *	misdn_new (struct chan_list *cl, int state, char *exten, char *callerid, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, int port, int c)
static int	misdn_overlap_dial_task (const void *data)
static void	misdn_prefix_string (const char *str_prefix, char *str_main, size_t size)
static void	misdn_queue_connected_line_update (struct ast_channel *ast, const struct misdn_party_id *id, enum AST_CONNECTED_LINE_UPDATE_SOURCE source, char *cid_tag)
static struct ast_frame *	misdn_read (struct ast_channel *ast)
static struct ast_channel *	misdn_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	misdn_send_text (struct ast_channel *chan, const char *text)
static int	misdn_set_opt_exec (struct ast_channel *chan, const char *data)
static int	misdn_tasks_add (int timeout, ast_sched_cb callback, const void *data)
static int	misdn_tasks_add_variable (int timeout, ast_sched_cb callback, const void *data)
static void	misdn_tasks_destroy (void)
static void	misdn_tasks_init (void)
static void	misdn_tasks_remove (int task_id)
static void *	misdn_tasks_thread_func (void *data)
static void	misdn_tasks_wakeup (void)
static int	misdn_to_ast_plan (enum mISDN_NUMBER_PLAN number_plan)
static int	misdn_to_ast_pres (int presentation)
static enum AST_REDIRECTING_REASON	misdn_to_ast_reason (const enum mISDN_REDIRECTING_REASON q931)
static int	misdn_to_ast_screen (int screening)
static int	misdn_to_ast_ton (enum mISDN_NUMBER_TYPE number_type)
static const char *	misdn_to_str_plan (enum mISDN_NUMBER_PLAN number_plan)
static const char *	misdn_to_str_pres (int presentation)
static const char *	misdn_to_str_screen (int screening)
static const char *	misdn_to_str_ton (enum mISDN_NUMBER_TYPE number_type)
static void	misdn_update_caller_id (struct ast_channel *ast, const struct misdn_party_id *id, char *cid_tag)
static void	misdn_update_connected_line (struct ast_channel *ast, struct misdn_bchannel *bc, int originator)
static void	misdn_update_redirecting (struct ast_channel *ast, struct misdn_bchannel *bc, int originator)
static void	misdn_update_remote_party (struct ast_channel *ast, const struct misdn_party_id *id, enum AST_CONNECTED_LINE_UPDATE_SOURCE source, char *cid_tag)
static int	misdn_write (struct ast_channel *ast, struct ast_frame *frame)
static int	pbx_start_chan (struct chan_list *ch)
static void	print_bc_info (int fd, struct chan_list *help, struct misdn_bchannel *bc)
static void	print_bearer (struct misdn_bchannel *bc)
static void	print_facility (const struct FacParm *fac, const struct misdn_bchannel *bc)
static struct ast_frame *	process_ast_dsp (struct chan_list *tmp, struct ast_frame *frame)
static int	read_config (struct chan_list *ch)
static void	release_chan (struct chan_list *ch, struct misdn_bchannel *bc)
static void	release_chan_early (struct chan_list *ch)
static int	reload (void)
static void	reload_config (void)
static int	send_cause2ast (struct ast_channel *ast, struct misdn_bchannel *bc, struct chan_list *ch)
static void	send_digit_to_chan (struct chan_list *cl, char digit)
static void	show_config_description (int fd, enum misdn_cfg_elements elem)
static void	sighandler (int sig)
static int	start_bc_tones (struct chan_list *cl)
static void	start_pbx (struct chan_list *ch, struct misdn_bchannel *bc, struct ast_channel *chan)
static int	stop_bc_tones (struct chan_list *cl)
static int	stop_indicate (struct chan_list *cl)
static int	unload_module (void)
static void	update_config (struct chan_list *ch)
	Updates caller ID information from config. More...
static int	update_ec_config (struct misdn_bchannel *bc)
static void	update_name (struct ast_channel *tmp, int port, int c)
static void	wait_for_digits (struct chan_list *ch, struct misdn_bchannel *bc, struct ast_channel *chan)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Channel driver for mISDN Support (BRI/PRI)" , .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_DEPRECATED, .load = load_module, .unload = unload_module, .reload = reload, .load_pri = AST_MODPRI_CHANNEL_DRIVER, }
static const struct allowed_bearers	allowed_bearers_array []
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_cli_entry	chan_misdn_clis []
static struct chan_list *	cl_te =NULL
	Global channel call record list head. More...
static ast_mutex_t	cl_te_lock
static int	g_config_initialized = 0
static int	glob_channel = 0
static char	global_tracefile [BUFFERSIZE+1]
static int	max_ports
int	MAXTICS = 8
static int *	misdn_debug
static int *	misdn_debug_only
static int *	misdn_in_calls
static int *	misdn_out_calls
static int *	misdn_ports
static struct ast_sched_context *	misdn_tasks = NULL
	the main schedule context for stuff like l1 watcher, overlap dial, ... More...
static pthread_t	misdn_tasks_thread
static struct ast_channel_tech	misdn_tech
static const char	misdn_type [] = "mISDN"
static ast_mutex_t	release_lock
static struct robin_list *	robin = NULL
static const struct state_struct	state_array []
static int	tracing = 0

Detailed Description

the chan_misdn channel driver for Asterisk

Author

Christian Richter crich.nosp@m.@ber.nosp@m.onet..nosp@m.com

MISDN http://www.misdn.org/

Definition in file chan_misdn.c.

Macro Definition Documentation

chan_list_ref

#define chan_list_ref	(		obj,
			debug
	)		ao2_t_ref((obj), +1, (debug))

Definition at line 371 of file chan_misdn.c.

Referenced by cl_queue_chan(), find_chan_by_bc(), find_hold_active_call(), find_hold_call(), find_hold_call_l3(), get_chan_by_ast_name(), misdn_chan_is_valid(), and misdn_new().

chan_list_unref

#define chan_list_unref	(		obj,
			debug
	)		ao2_t_ref((obj), -1, (debug))

Definition at line 372 of file chan_misdn.c.

Referenced by cb_events(), chan_misdn_jb_empty(), cl_dequeue_chan(), handle_cli_misdn_send_digit(), handle_cli_misdn_send_display(), handle_cli_misdn_send_facility(), handle_cli_misdn_toggle_echocancel(), misdn_hangup(), misdn_request(), misdn_write(), release_chan(), and release_chan_early().

MISDN_ASTERISK_TECH_PVT

#define MISDN_ASTERISK_TECH_PVT

(

ast

)

ast_channel_tech_pvt(ast)

Definition at line 683 of file chan_misdn.c.

Referenced by cb_events(), do_immediate_setup(), misdn_answer(), misdn_call(), misdn_digit_end(), misdn_facility_exec(), misdn_fixup(), misdn_hangup(), misdn_indication(), misdn_read(), misdn_send_text(), misdn_set_opt_exec(), misdn_update_connected_line(), misdn_write(), release_chan(), and release_chan_early().

MISDN_ASTERISK_TECH_PVT_SET

#define MISDN_ASTERISK_TECH_PVT_SET	(		ast,
			value
	)		ast_channel_tech_pvt_set(ast, value)

Definition at line 684 of file chan_misdn.c.

Referenced by misdn_hangup(), misdn_new(), release_chan(), and release_chan_early().

ORG_AST

#define ORG_AST   1

Asterisk created the channel (outgoing call)

Definition at line 343 of file chan_misdn.c.

Referenced by cb_events(), export_aoc_vars(), misdn_hangup(), misdn_request(), print_bc_info(), read_config(), release_chan(), and release_chan_early().

ORG_MISDN

#define ORG_MISDN   2

mISDN created the channel (incoming call)

Definition at line 345 of file chan_misdn.c.

Referenced by cb_events(), misdn_get_connected_line(), misdn_indication(), misdn_update_connected_line(), and misdn_update_redirecting().

TRANSFER_ON_HELD_CALL_HANGUP

#define TRANSFER_ON_HELD_CALL_HANGUP   1

Definition at line 8334 of file chan_misdn.c.

Enumeration Type Documentation

misdn_chan_state

enum misdn_chan_state

Enumerator
MISDN_NOTHING	at beginning
MISDN_WAITING4DIGS	when waiting for info
MISDN_EXTCANTMATCH	when asterisk couldn't match our ext
MISDN_INCOMING_SETUP	for incoming setup
MISDN_DIALING	when pbx_start
MISDN_PROGRESS	we have progress
MISDN_PROCEEDING	we have progress
MISDN_CALLING	when misdn_call is called
MISDN_CALLING_ACKNOWLEDGE	when we get SETUP_ACK
MISDN_ALERTING	when Alerting
MISDN_BUSY	when BUSY
MISDN_CONNECTED	when connected
MISDN_DISCONNECTED	when connected
MISDN_CLEANING	when hangup from * but we were connected before

Definition at line 325 of file chan_misdn.c.

 {
 MISDN_NOTHING = 0, /*!< at beginning */
 MISDN_WAITING4DIGS, /*!< when waiting for info */
 MISDN_EXTCANTMATCH, /*!< when asterisk couldn't match our ext */
 MISDN_INCOMING_SETUP, /*!< for incoming setup */
 MISDN_DIALING, /*!< when pbx_start */
 MISDN_PROGRESS, /*!< we have progress */
 MISDN_PROCEEDING, /*!< we have progress */
 MISDN_CALLING, /*!< when misdn_call is called */
 MISDN_CALLING_ACKNOWLEDGE, /*!< when we get SETUP_ACK */
 MISDN_ALERTING, /*!< when Alerting */
 MISDN_BUSY, /*!< when BUSY */
 MISDN_CONNECTED, /*!< when connected */
 MISDN_DISCONNECTED, /*!< when connected */
 MISDN_CLEANING, /*!< when hangup from * but we were connected before */
};

misdn_hold_state

enum misdn_hold_state

Enumerator
MISDN_HOLD_IDLE	HOLD not active
MISDN_HOLD_ACTIVE	Call is held
MISDN_HOLD_TRANSFER	Held call is being transferred
MISDN_HOLD_DISCONNECT	Held call is being disconnected

Definition at line 347 of file chan_misdn.c.

 {
 MISDN_HOLD_IDLE, /*!< HOLD not active */
 MISDN_HOLD_ACTIVE, /*!< Call is held */
 MISDN_HOLD_TRANSFER, /*!< Held call is being transferred */
 MISDN_HOLD_DISCONNECT, /*!< Held call is being disconnected */
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 12838 of file chan_misdn.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 12838 of file chan_misdn.c.

_misdn_tasks_add_variable()

static int _misdn_tasks_add_variable ( int  timeout, ast_sched_cb  callback, const void *  data, int  variable  )

inlinestatic

Definition at line 3591 of file chan_misdn.c.

References ast_sched_add_variable(), misdn_tasks_init(), and misdn_tasks_wakeup().

Referenced by misdn_tasks_add(), and misdn_tasks_add_variable().

{
 int task_id;

 if (!misdn_tasks) {
 misdn_tasks_init();
 }
 task_id = ast_sched_add_variable(misdn_tasks, timeout, callback, data, variable);
 misdn_tasks_wakeup();

 return task_id;
}

add_in_calls()

int add_in_calls

(

int

port

)

Definition at line 8844 of file chan_misdn.c.

References ast_log, LOG_NOTICE, misdn_cfg_get(), and MISDN_CFG_MAX_IN.

Referenced by cb_events().

{
 int max_in_calls;

 misdn_cfg_get(port, MISDN_CFG_MAX_IN, &max_in_calls, sizeof(max_in_calls));
 misdn_in_calls[port]++;

 if (max_in_calls >= 0 && max_in_calls < misdn_in_calls[port]) {
 ast_log(LOG_NOTICE, "Marking Incoming Call on port[%d]\n", port);
 return misdn_in_calls[port] - max_in_calls;
 }

 return 0;
}

add_out_calls()

int add_out_calls

(

int

port

)

Definition at line 8859 of file chan_misdn.c.

References ast_log, LOG_NOTICE, misdn_cfg_get(), and MISDN_CFG_MAX_OUT.

Referenced by misdn_call().

{
 int max_out_calls;

 misdn_cfg_get(port, MISDN_CFG_MAX_OUT, &max_out_calls, sizeof(max_out_calls));

 if (max_out_calls >= 0 && max_out_calls <= misdn_out_calls[port]) {
 ast_log(LOG_NOTICE, "Rejecting Outgoing Call on port[%d]\n", port);
 return (misdn_out_calls[port] + 1) - max_out_calls;
 }

 misdn_out_calls[port]++;

 return 0;
}

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 12838 of file chan_misdn.c.

ast_to_misdn_plan()

static enum mISDN_NUMBER_PLAN ast_to_misdn_plan ( unsigned  ast_number_plan )

static

Definition at line 2042 of file chan_misdn.c.

References NUMPLAN_DATA, NUMPLAN_ISDN, NUMPLAN_NATIONAL, NUMPLAN_PRIVATE, NUMPLAN_TELEX, and NUMPLAN_UNKNOWN.

Referenced by misdn_call(), misdn_copy_redirecting_from_ast(), and misdn_get_connected_line().

{
 enum mISDN_NUMBER_PLAN number_plan;

 switch (ast_number_plan & 0x0F) {
 default:
 case NUMPLAN_UNKNOWN:
 number_plan = NUMPLAN_UNKNOWN;
 break;

 case NUMPLAN_ISDN:
 number_plan = NUMPLAN_ISDN;
 break;

 case NUMPLAN_DATA:
 number_plan = NUMPLAN_DATA;
 break;

 case NUMPLAN_TELEX:
 number_plan = NUMPLAN_TELEX;
 break;

 case NUMPLAN_NATIONAL:
 number_plan = NUMPLAN_NATIONAL;
 break;

 case NUMPLAN_PRIVATE:
 number_plan = NUMPLAN_PRIVATE;
 break;
 }

 return number_plan;
}

ast_to_misdn_pres()

static int ast_to_misdn_pres ( int  presentation )

static

Definition at line 2145 of file chan_misdn.c.

References AST_PRES_ALLOWED, AST_PRES_RESTRICTED, AST_PRES_RESTRICTION, and AST_PRES_UNAVAILABLE.

Referenced by misdn_copy_redirecting_from_ast(), misdn_get_connected_line(), and update_config().

{
 switch (presentation & AST_PRES_RESTRICTION) {
 default:
 case AST_PRES_ALLOWED:
 presentation = 0;
 break;

 case AST_PRES_RESTRICTED:
 presentation = 1;
 break;

 case AST_PRES_UNAVAILABLE:
 presentation = 2;
 break;
 }

 return presentation;
}

ast_to_misdn_reason()

static enum mISDN_REDIRECTING_REASON ast_to_misdn_reason ( const enum AST_REDIRECTING_REASON  ast )

static

Definition at line 2274 of file chan_misdn.c.

References ARRAY_LEN, AST_REDIRECTING_REASON_AWAY, AST_REDIRECTING_REASON_CALL_FWD_DTE, AST_REDIRECTING_REASON_DEFLECTION, AST_REDIRECTING_REASON_DO_NOT_DISTURB, AST_REDIRECTING_REASON_FOLLOW_ME, AST_REDIRECTING_REASON_NO_ANSWER, AST_REDIRECTING_REASON_OUT_OF_ORDER, AST_REDIRECTING_REASON_TIME_OF_DAY, AST_REDIRECTING_REASON_UNAVAILABLE, AST_REDIRECTING_REASON_UNCONDITIONAL, AST_REDIRECTING_REASON_UNKNOWN, AST_REDIRECTING_REASON_USER_BUSY, mISDN_REDIRECTING_REASON_CALL_FWD, mISDN_REDIRECTING_REASON_CALL_FWD_BUSY, mISDN_REDIRECTING_REASON_CALL_FWD_DTE, mISDN_REDIRECTING_REASON_DEFLECTION, mISDN_REDIRECTING_REASON_NO_REPLY, mISDN_REDIRECTING_REASON_OUT_OF_ORDER, and mISDN_REDIRECTING_REASON_UNKNOWN.

Referenced by misdn_copy_redirecting_from_ast().

{
 unsigned index;

 static const struct misdn_reasons {
 enum AST_REDIRECTING_REASON ast;
 enum mISDN_REDIRECTING_REASON q931;
 } misdn_reason_table[] = {
 /* *INDENT-OFF* */
 { AST_REDIRECTING_REASON_UNKNOWN, mISDN_REDIRECTING_REASON_UNKNOWN },
 { AST_REDIRECTING_REASON_USER_BUSY, mISDN_REDIRECTING_REASON_CALL_FWD_BUSY },
 { AST_REDIRECTING_REASON_NO_ANSWER, mISDN_REDIRECTING_REASON_NO_REPLY },
 { AST_REDIRECTING_REASON_UNAVAILABLE, mISDN_REDIRECTING_REASON_NO_REPLY },
 { AST_REDIRECTING_REASON_UNCONDITIONAL, mISDN_REDIRECTING_REASON_CALL_FWD },
 { AST_REDIRECTING_REASON_TIME_OF_DAY, mISDN_REDIRECTING_REASON_UNKNOWN },
 { AST_REDIRECTING_REASON_DO_NOT_DISTURB, mISDN_REDIRECTING_REASON_UNKNOWN },
 { AST_REDIRECTING_REASON_DEFLECTION, mISDN_REDIRECTING_REASON_DEFLECTION },
 { AST_REDIRECTING_REASON_FOLLOW_ME, mISDN_REDIRECTING_REASON_UNKNOWN },
 { AST_REDIRECTING_REASON_OUT_OF_ORDER, mISDN_REDIRECTING_REASON_OUT_OF_ORDER },
 { AST_REDIRECTING_REASON_AWAY, mISDN_REDIRECTING_REASON_UNKNOWN },
 { AST_REDIRECTING_REASON_CALL_FWD_DTE, mISDN_REDIRECTING_REASON_CALL_FWD_DTE }
 /* *INDENT-ON* */
 };

 for (index = 0; index < ARRAY_LEN(misdn_reason_table); ++index) {
 if (misdn_reason_table[index].ast == ast) {
 return misdn_reason_table[index].q931;
 }
 }
 return mISDN_REDIRECTING_REASON_UNKNOWN;
}

ast_to_misdn_screen()

static int ast_to_misdn_screen ( int  screening )

static

Definition at line 2242 of file chan_misdn.c.

References AST_PRES_NETWORK_NUMBER, AST_PRES_NUMBER_TYPE, AST_PRES_USER_NUMBER_FAILED_SCREEN, AST_PRES_USER_NUMBER_PASSED_SCREEN, and AST_PRES_USER_NUMBER_UNSCREENED.

Referenced by misdn_copy_redirecting_from_ast(), misdn_get_connected_line(), and update_config().

{
 switch (screening & AST_PRES_NUMBER_TYPE) {
 default:
 case AST_PRES_USER_NUMBER_UNSCREENED:
 screening = 0;
 break;

 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
 screening = 1;
 break;

 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
 screening = 2;
 break;

 case AST_PRES_NETWORK_NUMBER:
 screening = 3;
 break;
 }

 return screening;
}

ast_to_misdn_ton()

static enum mISDN_NUMBER_TYPE ast_to_misdn_ton ( unsigned  ast_number_type )

static

Definition at line 1916 of file chan_misdn.c.

References NUMTYPE_ABBREVIATED, NUMTYPE_INTERNATIONAL, NUMTYPE_NATIONAL, NUMTYPE_NETWORK_SPECIFIC, NUMTYPE_SUBSCRIBER, and NUMTYPE_UNKNOWN.

Referenced by misdn_call(), misdn_copy_redirecting_from_ast(), and misdn_get_connected_line().

{
 enum mISDN_NUMBER_TYPE number_type;

 switch ((ast_number_type >> 4) & 0x07) {
 default:
 case NUMTYPE_UNKNOWN:
 number_type = NUMTYPE_UNKNOWN;
 break;

 case NUMTYPE_INTERNATIONAL:
 number_type = NUMTYPE_INTERNATIONAL;
 break;

 case NUMTYPE_NATIONAL:
 number_type = NUMTYPE_NATIONAL;
 break;

 case NUMTYPE_NETWORK_SPECIFIC:
 number_type = NUMTYPE_NETWORK_SPECIFIC;
 break;

 case NUMTYPE_SUBSCRIBER:
 number_type = NUMTYPE_SUBSCRIBER;
 break;

 case NUMTYPE_ABBREVIATED:
 number_type = NUMTYPE_ABBREVIATED;
 break;
 }

 return number_type;
}

bearer2str()

static const char* bearer2str ( int  cap )

static

Definition at line 2373 of file chan_misdn.c.

References ARRAY_LEN, ast_copy_string(), chan_misdn_log(), allowed_bearers::display, misdn_party_id::number, misdn_party_id::number_plan, misdn_party_id::number_type, NUMPLAN_ISDN, NUMTYPE_UNKNOWN, misdn_bchannel::port, and misdn_party_id::presentation.

Referenced by cb_events(), print_bc_info(), and print_bearer().

{
 unsigned index;

 for (index = 0; index < ARRAY_LEN(allowed_bearers_array); ++index) {
 if (allowed_bearers_array[index].cap == cap) {
 return allowed_bearers_array[index].display;
 }
 }

 return "Unknown Bearer";
}

cb_events()

static enum event_response_e cb_events ( enum event_e  event, struct misdn_bchannel *  bc, void *  user_data  )

static

queue new chan

Supplementary Services

Definition at line 9917 of file chan_misdn.c.

References add_in_calls(), misdn_bchannel::addr, chan_list::addr, chan_list::allowed_bearers, ao2_cleanup, ao2_ref, misdn_bchannel::AOCD_need_export, args, ARRAY_LEN, chan_list::ast, AST_APP_ARG, ast_canmatch_extension(), AST_CAUSE_DESTINATION_OUT_OF_ORDER, AST_CAUSE_INCOMPATIBLE_DESTINATION, AST_CAUSE_NORMAL_CLEARING, AST_CAUSE_UNALLOCATED, AST_CAUSE_USER_BUSY, ast_channel_bridge_peer(), ast_channel_caller(), ast_channel_cleanup, ast_channel_exten(), ast_channel_exten_set(), ast_channel_generator(), ast_channel_generatordata(), ast_channel_generatordata_set(), ast_channel_hangupcause_set(), ast_channel_lock, ast_channel_queue_redirecting_update(), ast_channel_redirecting(), ast_channel_rings_set(), ast_channel_transfercapability_set(), ast_channel_unlock, AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER, AST_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER, AST_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER_ALERTING, AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, ast_copy_string(), ast_deactivate_generator(), AST_DECLARE_APP_ARGS, ast_exists_extension(), ast_format_alaw, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, AST_FRAME_DTMF, AST_FRAME_VOICE, ast_get_chan_features_pickup_config(), AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_named_caller_presentation(), ast_party_id_reset(), ast_party_redirecting_copy(), ast_party_redirecting_free(), ast_party_redirecting_init(), ast_pickup_call(), ast_poll, AST_PRES_RESTRICTED, AST_PRES_USER_NUMBER_UNSCREENED, ast_queue_control(), ast_queue_frame(), ast_queue_hold(), ast_queue_unhold(), ast_set_callerid(), ast_setstate(), AST_STANDARD_APP_ARGS, AST_STATE_RESERVED, AST_STATE_RINGING, ast_strdup, ast_strdupa, ast_strlen_zero, ast_transfercapability2str(), ast_tv(), ast_tvnow(), bc, chan_list::bc, misdn_bchannel::bc_state, bc_state2str(), bearer2str(), misdn_bchannel::bframe, misdn_bchannel::bframe_len, buf, misdn_bchannel::caller, misdn_bchannel::capability, misdn_bchannel::cause, cb_log, chan_list_init(), chan_list_unref, chan_misdn_log(), hold_info::channel, misdn_bchannel::channel, cl_queue_chan(), misdn_bchannel::connected, chan_list::context, misdn_bchannel::cw, ast_frame::data, ast_frame::datalen, ast_frame::delivery, misdn_bchannel::dialed, do_immediate_setup(), misdn_bchannel::dtmf, misdn_bchannel::dummy, errno, EVENT_ALERTING, EVENT_BCHAN_ACTIVATED, EVENT_BCHAN_DATA, EVENT_BCHAN_ERROR, EVENT_CLEANUP, EVENT_CONNECT, EVENT_CONNECT_ACKNOWLEDGE, EVENT_DISCONNECT, EVENT_DTMF_TONE, EVENT_FACILITY, EVENT_HOLD, EVENT_HOLD_ACKNOWLEDGE, EVENT_HOLD_REJECT, EVENT_INFORMATION, EVENT_NEW_BC, EVENT_NEW_CHANNEL, EVENT_NEW_L3ID, EVENT_NOTIFY, EVENT_PORT_ALARM, EVENT_PROCEEDING, EVENT_PROGRESS, EVENT_REGISTER, EVENT_RELEASE, EVENT_RELEASE_COMPLETE, EVENT_RESTART, EVENT_RETRIEVE, EVENT_RETRIEVE_ACKNOWLEDGE, EVENT_RETRIEVE_REJECT, EVENT_SETUP, EVENT_SETUP_ACKNOWLEDGE, EVENT_STATUS, EVENT_TIMEOUT, EVENT_TONE_GENERATE, export_aoc_vars(), export_ch(), misdn_bchannel::fac_in, misdn_bchannel::fac_out, chan_list::far_alerting, find_chan_by_bc(), find_hold_active_call(), find_hold_call(), find_hold_call_l3(), ast_frame_subclass::format, ast_frame::frametype, misdn_party_redirecting::from, ast_generator::generate, hangup_chan(), hanguptone_indicate(), chan_list::hold, ast_party_caller::id, chan_list::ignore_dtmf, misdn_bchannel::incoming_cid_tag, INFO_CAPABILITY_DIGITAL_UNRESTRICTED, misdn_bchannel::info_dad, INFO_PI_INBAND_AVAILABLE, misdn_bchannel::infos_pending, ast_frame_subclass::integer, misdn_bchannel::keypad, misdn_bchannel::l3_id, chan_list::l3id, LOG_ERROR, LOG_NOTICE, LOG_WARNING, ast_frame::mallocd, manager_isdn_get_info(), misdn_add_number_prefix(), MISDN_ALERTING, MISDN_ASTERISK_TECH_PVT, misdn_attempt_transfer(), MISDN_CALLING, MISDN_CALLING_ACKNOWLEDGE, misdn_cap_is_speech(), MISDN_CFG_ALARM_BLOCK, MISDN_CFG_ALWAYS_IMMEDIATE, MISDN_CFG_APPEND_MSN_TO_CALLERID_TAG, misdn_cfg_get(), MISDN_CFG_HOLD_ALLOWED, MISDN_CFG_IMMEDIATE, MISDN_CFG_REJECT_CAUSE, MISDN_CLEANING, MISDN_CONNECTED, misdn_copy_redirecting_to_ast(), MISDN_DIALING, MISDN_DISCONNECTED, MISDN_EXTCANTMATCH, misdn_facility_ie_handler(), MISDN_GEN_APPEND_DIGITS2EXTEN, misdn_get_ch_state(), MISDN_HOLD_ACTIVE, MISDN_HOLD_DISCONNECT, MISDN_HOLD_IDLE, misdn_inband_avail(), MISDN_INCOMING_SETUP, misdn_is_msn_valid(), misdn_lib_is_ptp(), misdn_lib_log_ies(), misdn_lib_port_block(), misdn_lib_send_event(), misdn_new(), MISDN_NOTHING, mISDN_NOTIFY_CODE_CALL_IS_DIVERTING, mISDN_NOTIFY_CODE_CALL_TRANSFER_ACTIVE, mISDN_NOTIFY_CODE_CALL_TRANSFER_ALERTING, mISDN_NOTIFY_CODE_DIVERSION_ACTIVATED, mISDN_NOTIFY_CODE_INVALID, misdn_overlap_dial_task(), MISDN_PROCEEDING, MISDN_PROGRESS, mISDN_REDIRECTING_REASON_NO_REPLY, mISDN_REDIRECTING_REASON_UNKNOWN, misdn_tasks_add_variable(), misdn_to_ast_plan(), misdn_to_ast_pres(), misdn_to_ast_screen(), misdn_to_ast_ton(), misdn_to_str_plan(), misdn_to_str_pres(), misdn_to_str_screen(), misdn_to_str_ton(), misdn_update_remote_party(), MISDN_WAITING4DIGS, ast_custom_function::name, misdn_party_id::name, allowed_bearers::name, chan_list::need_busy, misdn_bchannel::need_disconnect, misdn_bchannel::need_more_infos, misdn_bchannel::need_release, misdn_bchannel::need_release_complete, chan_list::noautorespond_on_setup, misdn_bchannel::notify_description_code, misdn_bchannel::nt, chan_list::nttimeout, NULL, misdn_party_dialing::number, misdn_party_id::number, ast_party_id::number, misdn_party_id::number_plan, misdn_party_id::number_type, ast_frame::offset, ORG_AST, ORG_MISDN, chan_list::originator, misdn_bchannel::out_cause, chan_list::overlap_dial, chan_list::overlap_dial_task, chan_list::overlap_tv, chan_list::overlap_tv_lock, parse(), pbx_builtin_setvar_helper(), misdn_bchannel::pid, chan_list::pipe, ast_party_number::plan, hold_info::port, misdn_bchannel::port, misdn_party_id::presentation, ast_party_number::presentation, print_bearer(), ast_party_redirecting::priv_from, ast_party_redirecting::priv_orig, ast_party_redirecting::priv_to, misdn_bchannel::progress_indicator, ast_frame::ptr, RAII_VAR, read_config(), misdn_party_redirecting::reason, misdn_bchannel::redirecting, release_chan(), RESPONSE_ERR, RESPONSE_IGNORE_SETUP, RESPONSE_IGNORE_SETUP_WITHOUT_CLOSE, RESPONSE_OK, RESPONSE_RELEASE_SETUP, misdn_jb::samples, ast_frame::samples, misdn_party_id::screening, misdn_bchannel::sending_complete, misdn_jb::size, ast_frame::src, start_bc_tones(), start_pbx(), hold_info::state, chan_list::state, stop_bc_tones(), stop_indicate(), ast_frame::subclass, ast_party_id::tag, tmp(), misdn_party_redirecting::to, ast_party_redirecting::to, misdn_party_redirecting::to_changed, misdn_bchannel::tone_cnt, update_name(), and wait_for_digits().

Referenced by load_module().

{
#if defined(AST_MISDN_ENHANCEMENTS)
 struct misdn_cc_record *cc_record;
#endif /* defined(AST_MISDN_ENHANCEMENTS) */
 struct chan_list *held_ch;
 struct chan_list *ch = find_chan_by_bc(bc);

 if (event != EVENT_BCHAN_DATA && event != EVENT_TONE_GENERATE) {
 int debuglevel = 1;

 /* Debug Only Non-Bchan */
 if (event == EVENT_CLEANUP && !user_data) {
 debuglevel = 5;
 }

 chan_misdn_log(debuglevel, bc->port,
 "I IND :%s caller:\"%s\" <%s> dialed:%s pid:%d state:%s\n",
 manager_isdn_get_info(event),
 bc->caller.name,
 bc->caller.number,
 bc->dialed.number,
 bc->pid,
 ch ? misdn_get_ch_state(ch) : "none");
 if (debuglevel == 1) {
 misdn_lib_log_ies(bc);
 chan_misdn_log(4, bc->port, " --> bc_state:%s\n", bc_state2str(bc->bc_state));
 }
 }

 if (!ch) {
 switch(event) {
 case EVENT_SETUP:
 case EVENT_DISCONNECT:
 case EVENT_RELEASE:
 case EVENT_RELEASE_COMPLETE:
 case EVENT_PORT_ALARM:
 case EVENT_RETRIEVE:
 case EVENT_NEW_BC:
 case EVENT_FACILITY:
 case EVENT_REGISTER:
 break;
 case EVENT_CLEANUP:
 case EVENT_TONE_GENERATE:
 case EVENT_BCHAN_DATA:
 return -1;
 default:
 chan_misdn_log(1, bc->port, "Chan not existing at the moment bc->l3id:%x bc:%p event:%s port:%d channel:%d\n", bc->l3_id, bc, manager_isdn_get_info(event), bc->port, bc->channel);
 return -1;
 }
 } else {
 switch (event) {
 case EVENT_TONE_GENERATE:
 break;
 case EVENT_DISCONNECT:
 case EVENT_RELEASE:
 case EVENT_RELEASE_COMPLETE:
 case EVENT_CLEANUP:
 case EVENT_TIMEOUT:
 if (!ch->ast) {
 chan_misdn_log(3, bc->port, "ast_hangup already called, so we have no ast ptr anymore in event(%s)\n", manager_isdn_get_info(event));
 }
 break;
 default:
 if (!ch->ast || !MISDN_ASTERISK_TECH_PVT(ch->ast)) {
 if (event != EVENT_BCHAN_DATA) {
 ast_log(LOG_NOTICE, "No Ast or No private Pointer in Event (%d:%s)\n", event, manager_isdn_get_info(event));
 }
 chan_list_unref(ch, "No Ast or Ast private pointer");
 return -1;
 }
 break;
 }
 }


 switch (event) {
 case EVENT_PORT_ALARM:
 {
 int boa = 0;
 misdn_cfg_get(bc->port, MISDN_CFG_ALARM_BLOCK, &boa, sizeof(boa));
 if (boa) {
 cb_log(1, bc->port, " --> blocking\n");
 misdn_lib_port_block(bc->port);
 }
 }
 break;
 case EVENT_BCHAN_ACTIVATED:
 break;

 case EVENT_NEW_CHANNEL:
 update_name(ch->ast,bc->port,bc->channel);
 break;

 case EVENT_NEW_L3ID:
 ch->l3id=bc->l3_id;
 ch->addr=bc->addr;
 break;

 case EVENT_NEW_BC:
 if (!ch) {
 ch = find_hold_call(bc);
 }

 if (!ch) {
 ast_log(LOG_WARNING, "NEW_BC without chan_list?\n");
 break;
 }

 if (bc) {
 ch->bc = (struct misdn_bchannel *) user_data;
 }
 break;

 case EVENT_DTMF_TONE:
 {
 /* sending INFOS as DTMF-Frames :) */
 struct ast_frame fr;

 memset(&fr, 0, sizeof(fr));
 fr.frametype = AST_FRAME_DTMF;
 fr.subclass.integer = bc->dtmf ;
 fr.src = NULL;
 fr.data.ptr = NULL;
 fr.datalen = 0;
 fr.samples = 0;
 fr.mallocd = 0;
 fr.offset = 0;
 fr.delivery = ast_tv(0,0);

 if (!ch->ignore_dtmf) {
 chan_misdn_log(2, bc->port, " --> DTMF:%c\n", bc->dtmf);
 ast_queue_frame(ch->ast, &fr);
 } else {
 chan_misdn_log(2, bc->port, " --> Ignoring DTMF:%c due to bridge flags\n", bc->dtmf);
 }
 break;
 }
 case EVENT_STATUS:
 break;

 case EVENT_INFORMATION:
 if (ch->state != MISDN_CONNECTED) {
 stop_indicate(ch);
 }

 if (!ch->ast) {
 break;
 }

 if (ch->state == MISDN_WAITING4DIGS) {
 RAII_VAR(struct ast_features_pickup_config *, pickup_cfg, NULL, ao2_cleanup);
 const char *pickupexten;

 /* Ok, incomplete Setup, waiting till extension exists */
 if (ast_strlen_zero(bc->info_dad) && ! ast_strlen_zero(bc->keypad)) {
 chan_misdn_log(1, bc->port, " --> using keypad as info\n");
 ast_copy_string(bc->info_dad, bc->keypad, sizeof(bc->info_dad));
 }

 strncat(bc->dialed.number, bc->info_dad, sizeof(bc->dialed.number) - strlen(bc->dialed.number) - 1);
 ast_channel_exten_set(ch->ast, bc->dialed.number);

 ast_channel_lock(ch->ast);
 pickup_cfg = ast_get_chan_features_pickup_config(ch->ast);
 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(ch->ast);

 /* Check for Pickup Request first */
 if (!strcmp(ast_channel_exten(ch->ast), pickupexten)) {
 if (ast_pickup_call(ch->ast)) {
 hangup_chan(ch, bc);
 } else {
 ch->state = MISDN_CALLING_ACKNOWLEDGE;
 hangup_chan(ch, bc);
 ch->ast = NULL;
 break;
 }
 }

 if (!ast_canmatch_extension(ch->ast, ch->context, bc->dialed.number, 1, bc->caller.number)) {
 if (ast_exists_extension(ch->ast, ch->context, "i", 1, bc->caller.number)) {
 ast_log(LOG_WARNING,
 "Extension '%s@%s' can never match. Jumping to 'i' extension. port:%d\n",
 bc->dialed.number, ch->context, bc->port);
 pbx_builtin_setvar_helper(ch->ast, "INVALID_EXTEN", bc->dialed.number);
 ast_channel_exten_set(ch->ast, "i");
 ch->state = MISDN_DIALING;
 start_pbx(ch, bc, ch->ast);
 break;
 }

 ast_log(LOG_WARNING,
 "Extension '%s@%s' can never match. Disconnecting. port:%d\n"
 "\tMaybe you want to add an 'i' extension to catch this case.\n",
 bc->dialed.number, ch->context, bc->port);

 if (bc->nt) {
 hanguptone_indicate(ch);
 }
 ch->state = MISDN_EXTCANTMATCH;
 bc->out_cause = AST_CAUSE_UNALLOCATED;

 misdn_lib_send_event(bc, EVENT_DISCONNECT);
 break;
 }

 if (ch->overlap_dial) {
 ast_mutex_lock(&ch->overlap_tv_lock);
 ch->overlap_tv = ast_tvnow();
 ast_mutex_unlock(&ch->overlap_tv_lock);
 if (ch->overlap_dial_task == -1) {
 ch->overlap_dial_task =
 misdn_tasks_add_variable(ch->overlap_dial, misdn_overlap_dial_task, ch);
 }
 break;
 }

 if (ast_exists_extension(ch->ast, ch->context, bc->dialed.number, 1, bc->caller.number)) {
 ch->state = MISDN_DIALING;
 start_pbx(ch, bc, ch->ast);
 }
 } else {
 /* sending INFOS as DTMF-Frames :) */
 struct ast_frame fr;
 int digits;

 memset(&fr, 0, sizeof(fr));
 fr.frametype = AST_FRAME_DTMF;
 fr.subclass.integer = bc->info_dad[0] ;
 fr.src = NULL;
 fr.data.ptr = NULL;
 fr.datalen = 0;
 fr.samples = 0;
 fr.mallocd = 0;
 fr.offset = 0;
 fr.delivery = ast_tv(0,0);

 misdn_cfg_get(0, MISDN_GEN_APPEND_DIGITS2EXTEN, &digits, sizeof(digits));
 if (ch->state != MISDN_CONNECTED) {
 if (digits) {
 strncat(bc->dialed.number, bc->info_dad, sizeof(bc->dialed.number) - strlen(bc->dialed.number) - 1);
 ast_channel_exten_set(ch->ast, bc->dialed.number);
 }

 ast_queue_frame(ch->ast, &fr);
 }
 }
 break;
 case EVENT_SETUP:
 {
 struct ast_channel *chan;
 int exceed;
 int ai;
 int im;
 int append_msn = 0;
 RAII_VAR(struct ast_features_pickup_config *, pickup_cfg, NULL, ao2_cleanup);
 const char *pickupexten;

 if (ch) {
 switch (ch->state) {
 case MISDN_NOTHING:
 chan_list_unref(ch, "Ignore found ch. Is it for an outgoing call?");
 ch = NULL;
 break;
 default:
 chan_list_unref(ch, "Already have a call.");
 chan_misdn_log(1, bc->port, " --> Ignoring Call we have already one\n");
 return RESPONSE_IGNORE_SETUP_WITHOUT_CLOSE; /* Ignore MSNs which are not in our List */
 }
 }

 if (!bc->nt && !misdn_is_msn_valid(bc->port, &bc->dialed)) {
 chan_misdn_log(1, bc->port, " --> Ignoring Call, its not in our MSN List\n");
 return RESPONSE_IGNORE_SETUP; /* Ignore MSNs which are not in our List */
 }

 if (bc->cw) {
 int cause;
 chan_misdn_log(0, bc->port, " --> Call Waiting on PMP sending RELEASE_COMPLETE\n");
 misdn_cfg_get(bc->port, MISDN_CFG_REJECT_CAUSE, &cause, sizeof(cause));
 bc->out_cause = cause ? cause : AST_CAUSE_NORMAL_CLEARING;
 return RESPONSE_RELEASE_SETUP;
 }

 print_bearer(bc);

 ch = chan_list_init(ORG_MISDN);
 if (!ch) {
 chan_misdn_log(-1, bc->port, "cb_events: malloc for chan_list failed!\n");
 return RESPONSE_RELEASE_SETUP;
 }

 ch->bc = bc;
 ch->l3id = bc->l3_id;
 ch->addr = bc->addr;

 {
 struct ast_format_cap *cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
 if (!(cap)) {
 return RESPONSE_ERR;
 }
 ast_format_cap_append(cap, ast_format_alaw, 0);
 chan = misdn_new(ch, AST_STATE_RESERVED, bc->dialed.number, bc->caller.number, cap, NULL, NULL, bc->port, bc->channel);
 ao2_ref(cap, -1);
 }
 if (!chan) {
 chan_list_unref(ch, "Failed to create a new channel");
 ast_log(LOG_ERROR, "cb_events: misdn_new failed!\n");
 return RESPONSE_RELEASE_SETUP;
 }

 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 ((exceed = add_in_calls(bc->port))) {
 char tmp[16];
 snprintf(tmp, sizeof(tmp), "%d", exceed);
 pbx_builtin_setvar_helper(chan, "MAX_OVERFLOW", tmp);
 }

 read_config(ch);

 export_ch(chan, bc, ch);

 ast_channel_lock(ch->ast);
 ast_channel_rings_set(ch->ast, 1);
 ast_setstate(ch->ast, AST_STATE_RINGING);
 ast_channel_unlock(ch->ast);

 /* Update asterisk channel caller information */
 chan_misdn_log(2, bc->port, " --> TON: %s(%d)\n", misdn_to_str_ton(bc->caller.number_type), bc->caller.number_type);
 chan_misdn_log(2, bc->port, " --> PLAN: %s(%d)\n", misdn_to_str_plan(bc->caller.number_plan), bc->caller.number_plan);
 ast_channel_caller(chan)->id.number.plan = misdn_to_ast_ton(bc->caller.number_type)
 | misdn_to_ast_plan(bc->caller.number_plan);

 chan_misdn_log(2, bc->port, " --> PRES: %s(%d)\n", misdn_to_str_pres(bc->caller.presentation), bc->caller.presentation);
 chan_misdn_log(2, bc->port, " --> SCREEN: %s(%d)\n", misdn_to_str_screen(bc->caller.screening), bc->caller.screening);
 ast_channel_caller(chan)->id.number.presentation = misdn_to_ast_pres(bc->caller.presentation)
 | misdn_to_ast_screen(bc->caller.screening);

 ast_set_callerid(chan, bc->caller.number, NULL, bc->caller.number);

 misdn_cfg_get(bc->port, MISDN_CFG_APPEND_MSN_TO_CALLERID_TAG, &append_msn, sizeof(append_msn));
 if (append_msn) {
 strncat(bc->incoming_cid_tag, "_", sizeof(bc->incoming_cid_tag) - strlen(bc->incoming_cid_tag) - 1);
 strncat(bc->incoming_cid_tag, bc->dialed.number, sizeof(bc->incoming_cid_tag) - strlen(bc->incoming_cid_tag) - 1);
 }

 ast_channel_lock(chan);
 ast_channel_caller(chan)->id.tag = ast_strdup(bc->incoming_cid_tag);
 ast_channel_unlock(chan);

 if (!ast_strlen_zero(bc->redirecting.from.number)) {
 /* Add configured prefix to redirecting.from.number */
 misdn_add_number_prefix(bc->port, bc->redirecting.from.number_type, bc->redirecting.from.number, sizeof(bc->redirecting.from.number));

 /* Update asterisk channel redirecting information */
 misdn_copy_redirecting_to_ast(chan, &bc->redirecting, bc->incoming_cid_tag);
 }

 pbx_builtin_setvar_helper(chan, "TRANSFERCAPABILITY", ast_transfercapability2str(bc->capability));
 ast_channel_transfercapability_set(chan, bc->capability);

 switch (bc->capability) {
 case INFO_CAPABILITY_DIGITAL_UNRESTRICTED:
 pbx_builtin_setvar_helper(chan, "CALLTYPE", "DIGITAL");
 break;
 default:
 pbx_builtin_setvar_helper(chan, "CALLTYPE", "SPEECH");
 break;
 }

 if (!strstr(ch->allowed_bearers, "all")) {
 int i;

 for (i = 0; i < ARRAY_LEN(allowed_bearers_array); ++i) {
 if (allowed_bearers_array[i].cap == bc->capability) {
 if (strstr(ch->allowed_bearers, allowed_bearers_array[i].name)) {
 /* The bearer capability is allowed */
 if (allowed_bearers_array[i].deprecated) {
 chan_misdn_log(0, bc->port, "%s in allowed_bearers list is deprecated\n",
 allowed_bearers_array[i].name);
 }
 break;
 }
 }
 }
 if (i == ARRAY_LEN(allowed_bearers_array)) {
 /* We did not find the bearer capability */
 chan_misdn_log(0, bc->port, "Bearer capability not allowed: %s(%d)\n",
 bearer2str(bc->capability), bc->capability);

 ch->state = MISDN_EXTCANTMATCH;
 chan_list_unref(ch, "BC not allowed, releasing call");
 bc->out_cause = AST_CAUSE_INCOMPATIBLE_DESTINATION;
 return RESPONSE_RELEASE_SETUP;
 }
 }

 /** queue new chan **/
 cl_queue_chan(ch);

 if (bc->fac_in.Function != Fac_None) {
 misdn_facility_ie_handler(event, bc, ch);
 }

 /* Check for Pickup Request first */
 if (!strcmp(ast_channel_exten(chan), pickupexten)) {
 if (!ch->noautorespond_on_setup) {
 /* Sending SETUP_ACK */
 misdn_lib_send_event(bc, EVENT_SETUP_ACKNOWLEDGE);
 } else {
 ch->state = MISDN_INCOMING_SETUP;
 }
 if (ast_pickup_call(chan)) {
 hangup_chan(ch, bc);
 } else {
 ch->state = MISDN_CALLING_ACKNOWLEDGE;
 hangup_chan(ch, bc);
 ch->ast = NULL;
 break;
 }
 }

 /*
 * added support for s extension hope it will help those poor cretains
 * which haven't overlap dial.
 */
 misdn_cfg_get(bc->port, MISDN_CFG_ALWAYS_IMMEDIATE, &ai, sizeof(ai));
 if (ai) {
 do_immediate_setup(bc, ch, chan);
 break;
 }

 /* check if we should jump into s when we have no dialed.number */
 misdn_cfg_get(bc->port, MISDN_CFG_IMMEDIATE, &im, sizeof(im));
 if (im && ast_strlen_zero(bc->dialed.number)) {
 do_immediate_setup(bc, ch, chan);
 break;
 }

 chan_misdn_log(5, bc->port, "CONTEXT:%s\n", ch->context);
 if (!ast_canmatch_extension(ch->ast, ch->context, bc->dialed.number, 1, bc->caller.number)) {
 if (ast_exists_extension(ch->ast, ch->context, "i", 1, bc->caller.number)) {
 ast_log(LOG_WARNING,
 "Extension '%s@%s' can never match. Jumping to 'i' extension. port:%d\n",
 bc->dialed.number, ch->context, bc->port);
 pbx_builtin_setvar_helper(ch->ast, "INVALID_EXTEN", bc->dialed.number);
 ast_channel_exten_set(ch->ast, "i");
 misdn_lib_send_event(bc, EVENT_SETUP_ACKNOWLEDGE);
 ch->state = MISDN_DIALING;
 start_pbx(ch, bc, chan);
 break;
 }

 ast_log(LOG_WARNING,
 "Extension '%s@%s' can never match. Disconnecting. port:%d\n"
 "\tMaybe you want to add an 'i' extension to catch this case.\n",
 bc->dialed.number, ch->context, bc->port);
 if (bc->nt) {
 hanguptone_indicate(ch);
 }

 ch->state = MISDN_EXTCANTMATCH;
 bc->out_cause = AST_CAUSE_UNALLOCATED;

 misdn_lib_send_event(bc, bc->nt ? EVENT_RELEASE_COMPLETE : EVENT_RELEASE);
 break;
 }

 /* Whatever happens, when sending_complete is set or we are PTMP TE, we will definitely
 * jump into the dialplan, when the dialed extension does not exist, the 's' extension
 * will be used by Asterisk automatically. */
 if (bc->sending_complete || (!bc->nt && !misdn_lib_is_ptp(bc->port))) {
 if (!ch->noautorespond_on_setup) {
 ch->state=MISDN_DIALING;
 misdn_lib_send_event(bc, EVENT_PROCEEDING);
 } else {
 ch->state = MISDN_INCOMING_SETUP;
 }
 start_pbx(ch, bc, chan);
 break;
 }


 /*
 * When we are NT and overlapdial is set and if
 * the number is empty, we wait for the ISDN timeout
 * instead of our own timer.
 */
 if (ch->overlap_dial && bc->nt && !bc->dialed.number[0]) {
 wait_for_digits(ch, bc, chan);
 break;
 }

 /*
 * If overlapdial we will definitely send a SETUP_ACKNOWLEDGE and wait for more
 * Infos with a Interdigit Timeout.
 * */
 if (ch->overlap_dial) {
 ast_mutex_lock(&ch->overlap_tv_lock);
 ch->overlap_tv = ast_tvnow();
 ast_mutex_unlock(&ch->overlap_tv_lock);

 wait_for_digits(ch, bc, chan);
 if (ch->overlap_dial_task == -1) {
 ch->overlap_dial_task =
 misdn_tasks_add_variable(ch->overlap_dial, misdn_overlap_dial_task, ch);
 }
 break;
 }

 /* If the extension does not exist and we're not TE_PTMP we wait for more digits
 * without interdigit timeout.
 * */
 if (!ast_exists_extension(ch->ast, ch->context, bc->dialed.number, 1, bc->caller.number)) {
 wait_for_digits(ch, bc, chan);
 break;
 }

 /*
 * If the extension exists let's just jump into it.
 * */
 if (ast_exists_extension(ch->ast, ch->context, bc->dialed.number, 1, bc->caller.number)) {
 misdn_lib_send_event(bc, bc->need_more_infos ? EVENT_SETUP_ACKNOWLEDGE : EVENT_PROCEEDING);
 ch->state = MISDN_DIALING;
 start_pbx(ch, bc, chan);
 break;
 }
 break;
 }
#if defined(AST_MISDN_ENHANCEMENTS)
 case EVENT_REGISTER:
 if (bc->fac_in.Function != Fac_None) {
 misdn_facility_ie_handler(event, bc, ch);
 }
 /*
 * Shut down this connection immediately.
 * The current design of chan_misdn data structures
 * does not allow the proper handling of inbound call records
 * without an assigned B channel. Therefore, we cannot
 * be the CCBS User-B party in a point-to-point setup.
 */
 bc->fac_out.Function = Fac_None;
 bc->out_cause = AST_CAUSE_NORMAL_CLEARING;
 misdn_lib_send_event(bc, EVENT_RELEASE_COMPLETE);
 break;
#endif /* defined(AST_MISDN_ENHANCEMENTS) */
 case EVENT_SETUP_ACKNOWLEDGE:
 ch->state = MISDN_CALLING_ACKNOWLEDGE;

 if (bc->channel) {
 update_name(ch->ast,bc->port,bc->channel);
 }

 if (bc->fac_in.Function != Fac_None) {
 misdn_facility_ie_handler(event, bc, ch);
 }

 if (!ast_strlen_zero(bc->infos_pending)) {
 /* TX Pending Infos */
 strncat(bc->dialed.number, bc->infos_pending, sizeof(bc->dialed.number) - strlen(bc->dialed.number) - 1);

 if (!ch->ast) {
 break;
 }
 ast_channel_exten_set(ch->ast, bc->dialed.number);
 ast_copy_string(bc->info_dad, bc->infos_pending, sizeof(bc->info_dad));
 ast_copy_string(bc->infos_pending, "", sizeof(bc->infos_pending));

 misdn_lib_send_event(bc, EVENT_INFORMATION);
 }
 break;
 case EVENT_PROCEEDING:
 if (misdn_cap_is_speech(bc->capability) &&
 misdn_inband_avail(bc)) {
 start_bc_tones(ch);
 }

 ch->state = MISDN_PROCEEDING;

 if (bc->fac_in.Function != Fac_None) {
 misdn_facility_ie_handler(event, bc, ch);
 }

 if (!ch->ast) {
 break;
 }

 ast_queue_control(ch->ast, AST_CONTROL_PROCEEDING);
 break;
 case EVENT_PROGRESS:
 if (bc->channel) {
 update_name(ch->ast, bc->port, bc->channel);
 }

 if (bc->fac_in.Function != Fac_None) {
 misdn_facility_ie_handler(event, bc, ch);
 }

 if (!bc->nt) {
 if (misdn_cap_is_speech(bc->capability) &&
 misdn_inband_avail(bc)) {
 start_bc_tones(ch);
 }

 ch->state = MISDN_PROGRESS;

 if (!ch->ast) {
 break;
 }
 ast_queue_control(ch->ast, AST_CONTROL_PROGRESS);
 }
 break;
 case EVENT_ALERTING:
 ch->state = MISDN_ALERTING;

 if (!ch->ast) {
 break;
 }

 if (bc->fac_in.Function != Fac_None) {
 misdn_facility_ie_handler(event, bc, ch);
 }

 ast_queue_control(ch->ast, AST_CONTROL_RINGING);
 ast_channel_lock(ch->ast);
 ast_setstate(ch->ast, AST_STATE_RINGING);
 ast_channel_unlock(ch->ast);

 cb_log(7, bc->port, " --> Set State Ringing\n");

 if (misdn_cap_is_speech(bc->capability) && misdn_inband_avail(bc)) {
 cb_log(1, bc->port, "Starting Tones, we have inband Data\n");
 start_bc_tones(ch);
 } else {
 cb_log(3, bc->port, " --> We have no inband Data, the other end must create ringing\n");
 if (ch->far_alerting) {
 cb_log(1, bc->port, " --> The other end can not do ringing eh ?.. we must do all ourself..");
 start_bc_tones(ch);
 /*tone_indicate(ch, TONE_FAR_ALERTING);*/
 }
 }
 break;
 case EVENT_CONNECT:
 if (bc->fac_in.Function != Fac_None) {
 misdn_facility_ie_handler(event, bc, ch);
 }
#if defined(AST_MISDN_ENHANCEMENTS)
 if (bc->div_leg_3_rx_wanted) {
 bc->div_leg_3_rx_wanted = 0;

 if (ch->ast) {
 struct ast_party_redirecting redirecting;

 ast_channel_redirecting(ch->ast)->to.number.presentation =
 AST_PRES_RESTRICTED | AST_PRES_USER_NUMBER_UNSCREENED;
 ast_party_redirecting_init(&redirecting);
 ast_party_redirecting_copy(&redirecting, ast_channel_redirecting(ch->ast));

 /*
 * Reset any earlier private redirecting id representations and
 * make sure that it is invalidated at the remote end.
 */
 ast_party_id_reset(&redirecting.priv_orig);
 ast_party_id_reset(&redirecting.priv_from);
 ast_party_id_reset(&redirecting.priv_to);

 ast_channel_queue_redirecting_update(ch->ast, &redirecting, NULL);
 ast_party_redirecting_free(&redirecting);
 }
 }
#endif /* defined(AST_MISDN_ENHANCEMENTS) */

 /* we answer when we've got our very new L3 ID from the NT stack */
 misdn_lib_send_event(bc, EVENT_CONNECT_ACKNOWLEDGE);

 if (!ch->ast) {
 break;
 }

 stop_indicate(ch);

#if defined(AST_MISDN_ENHANCEMENTS)
 if (ch->record_id != -1) {
 /*
 * We will delete the associated call completion
 * record since we now have a completed call.
 * We will not wait/depend on the network to tell
 * us to delete it.
 */
 AST_LIST_LOCK(&misdn_cc_records_db);
 cc_record = misdn_cc_find_by_id(ch->record_id);
 if (cc_record) {
 if (cc_record->ptp && cc_record->mode.ptp.bc) {
 /* Close the call-completion signaling link */
 cc_record->mode.ptp.bc->fac_out.Function = Fac_None;
 cc_record->mode.ptp.bc->out_cause = AST_CAUSE_NORMAL_CLEARING;
 misdn_lib_send_event(cc_record->mode.ptp.bc, EVENT_RELEASE_COMPLETE);
 }
 misdn_cc_delete(cc_record);
 }
 AST_LIST_UNLOCK(&misdn_cc_records_db);
 ch->record_id = -1;
 if (ch->peer) {
 misdn_cc_set_peer_var(ch->peer, MISDN_CC_RECORD_ID, "");

 ao2_ref(ch->peer, -1);
 ch->peer = NULL;
 }
 }
#endif /* defined(AST_MISDN_ENHANCEMENTS) */

 if (!ast_strlen_zero(bc->connected.number)) {
 /* Add configured prefix to connected.number */
 misdn_add_number_prefix(bc->port, bc->connected.number_type, bc->connected.number, sizeof(bc->connected.number));

 /* Update the connected line information on the other channel */
 misdn_update_remote_party(ch->ast, &bc->connected, AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER, bc->incoming_cid_tag);
 }

 ch->l3id = bc->l3_id;
 ch->addr = bc->addr;

 start_bc_tones(ch);

 ch->state = MISDN_CONNECTED;

 ast_queue_control(ch->ast, AST_CONTROL_ANSWER);
 break;
 case EVENT_CONNECT_ACKNOWLEDGE:
 ch->l3id = bc->l3_id;
 ch->addr = bc->addr;

 start_bc_tones(ch);

 ch->state = MISDN_CONNECTED;
 break;
 case EVENT_DISCONNECT:
 /* we might not have an ch->ast ptr here anymore */
 if (ch) {
 if (bc->fac_in.Function != Fac_None) {
 misdn_facility_ie_handler(event, bc, ch);
 }

 chan_misdn_log(3, bc->port, " --> org:%d nt:%d, inbandavail:%d state:%d\n", ch->originator, bc->nt, misdn_inband_avail(bc), ch->state);
 if (ch->originator == ORG_AST && !bc->nt && misdn_inband_avail(bc) && ch->state != MISDN_CONNECTED) {
 /* If there's inband information available (e.g. a
 recorded message saying what was wrong with the
 dialled number, or perhaps even giving an
 alternative number, then play it instead of
 immediately releasing the call */
 chan_misdn_log(1, bc->port, " --> Inband Info Avail, not sending RELEASE\n");

 ch->state = MISDN_DISCONNECTED;
 start_bc_tones(ch);

 if (ch->ast) {
 ast_channel_hangupcause_set(ch->ast, bc->cause);
 if (bc->cause == AST_CAUSE_USER_BUSY) {
 ast_queue_control(ch->ast, AST_CONTROL_BUSY);
 }
 }
 ch->need_busy = 0;
 break;
 }

 bc->need_disconnect = 0;
 stop_bc_tones(ch);

 /* Check for held channel, to implement transfer */
 held_ch = find_hold_call(bc);
 if (!held_ch || !ch->ast || misdn_attempt_transfer(ch, held_ch)) {
 hangup_chan(ch, bc);
 }
 } else {
 held_ch = find_hold_call_l3(bc->l3_id);
 if (held_ch) {
 if (bc->fac_in.Function != Fac_None) {
 misdn_facility_ie_handler(event, bc, held_ch);
 }

 if (held_ch->hold.state == MISDN_HOLD_ACTIVE) {
 bc->need_disconnect = 0;

#if defined(TRANSFER_ON_HELD_CALL_HANGUP)
 /*
 * Some phones disconnect the held call and the active call at the
 * same time to do the transfer. Unfortunately, either call could
 * be disconnected first.
 */
 ch = find_hold_active_call(bc);
 if (!ch || misdn_attempt_transfer(ch, held_ch)) {
 held_ch->hold.state = MISDN_HOLD_DISCONNECT;
 hangup_chan(held_ch, bc);
 }
#else
 hangup_chan(held_ch, bc);
#endif /* defined(TRANSFER_ON_HELD_CALL_HANGUP) */
 }
 }
 }
 if (held_ch) {
 chan_list_unref(held_ch, "Done with held call");
 }
 bc->out_cause = -1;
 if (bc->need_release) {
 misdn_lib_send_event(bc, EVENT_RELEASE);
 }
 break;
 case EVENT_RELEASE:
 if (!ch) {
 ch = find_hold_call_l3(bc->l3_id);
 if (!ch) {
 chan_misdn_log(1, bc->port,
 " --> no Ch, so we've already released. (%s)\n",
 manager_isdn_get_info(event));
 return -1;
 }
 }
 if (bc->fac_in.Function != Fac_None) {
 misdn_facility_ie_handler(event, bc, ch);
 }

 bc->need_disconnect = 0;
 bc->need_release = 0;

 hangup_chan(ch, bc);
 release_chan(ch, bc);
 break;
 case EVENT_RELEASE_COMPLETE:
 if (!ch) {
 ch = find_hold_call_l3(bc->l3_id);
 }

 bc->need_disconnect = 0;
 bc->need_release = 0;
 bc->need_release_complete = 0;

 if (ch) {
 if (bc->fac_in.Function != Fac_None) {
 misdn_facility_ie_handler(event, bc, ch);
 }

 stop_bc_tones(ch);
 hangup_chan(ch, bc);
 release_chan(ch, bc);
 } else {
#if defined(AST_MISDN_ENHANCEMENTS)
 /*
 * A call-completion signaling link established with
 * REGISTER does not have a struct chan_list record
 * associated with it.
 */
 AST_LIST_LOCK(&misdn_cc_records_db);
 cc_record = misdn_cc_find_by_bc(bc);
 if (cc_record) {
 /* The call-completion signaling link is closed. */
 misdn_cc_delete(cc_record);
 }
 AST_LIST_UNLOCK(&misdn_cc_records_db);
#endif /* defined(AST_MISDN_ENHANCEMENTS) */

 chan_misdn_log(1, bc->port,
 " --> no Ch, so we've already released. (%s)\n",
 manager_isdn_get_info(event));
 }
 break;
 case EVENT_BCHAN_ERROR:
 case EVENT_CLEANUP:
 stop_bc_tones(ch);

 switch (ch->state) {
 case MISDN_CALLING:
 bc->cause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
 break;
 default:
 break;
 }

 hangup_chan(ch, bc);
 release_chan(ch, bc);
 break;
 case EVENT_TONE_GENERATE:
 {
 int tone_len = bc->tone_cnt;
 struct ast_channel *ast = ch->ast;
 void *tmp;
 int res;
 int (*generate)(struct ast_channel *chan, void *tmp, int datalen, int samples);

 chan_misdn_log(9, bc->port, "TONE_GEN: len:%d\n", tone_len);

 if (!ast) {
 break;
 }

 if (!ast_channel_generator(ast)) {
 break;
 }

 tmp = ast_channel_generatordata(ast);
 ast_channel_generatordata_set(ast, NULL);
 generate = ast_channel_generator(ast)->generate;

 if (tone_len < 0 || tone_len > 512) {
 ast_log(LOG_NOTICE, "TONE_GEN: len was %d, set to 128\n", tone_len);
 tone_len = 128;
 }

 res = generate(ast, tmp, tone_len, tone_len);
 ast_channel_generatordata_set(ast, tmp);

 if (res) {
 ast_log(LOG_WARNING, "Auto-deactivating generator\n");
 ast_deactivate_generator(ast);
 } else {
 bc->tone_cnt = 0;
 }
 break;
 }
 case EVENT_BCHAN_DATA:
 if (ch->bc->AOCD_need_export) {
 export_aoc_vars(ch->originator, ch->ast, ch->bc);
 }
 if (!misdn_cap_is_speech(ch->bc->capability)) {
 struct ast_frame frame;

 /* In Data Modes we queue frames */
 memset(&frame, 0, sizeof(frame));
 frame.frametype = AST_FRAME_VOICE; /* we have no data frames yet */
 frame.subclass.format = ast_format_alaw;
 frame.datalen = bc->bframe_len;
 frame.samples = bc->bframe_len;
 frame.mallocd = 0;
 frame.offset = 0;
 frame.delivery = ast_tv(0, 0);
 frame.src = NULL;
 frame.data.ptr = bc->bframe;

 if (ch->ast) {
 ast_queue_frame(ch->ast, &frame);
 }
 } else {
 struct pollfd pfd = { .fd = ch->pipe[1], .events = POLLOUT };
 int t;

 t = ast_poll(&pfd, 1, 0);

 if (t < 0) {
 chan_misdn_log(-1, bc->port, "poll() error (err=%s)\n", strerror(errno));
 break;
 }
 if (!t) {
 chan_misdn_log(9, bc->port, "poll() timed out\n");
 break;
 }

 if (pfd.revents & POLLOUT) {
 chan_misdn_log(9, bc->port, "writing %d bytes to asterisk\n", bc->bframe_len);
 if (write(ch->pipe[1], bc->bframe, bc->bframe_len) <= 0) {
 chan_misdn_log(0, bc->port, "Write returned <=0 (err=%s) --> hanging up channel\n", strerror(errno));

 stop_bc_tones(ch);
 hangup_chan(ch, bc);
 release_chan(ch, bc);
 }
 } else {
 chan_misdn_log(1, bc->port, "Write Pipe full!\n");
 }
 }
 break;
 case EVENT_TIMEOUT:
 if (ch && bc) {
 chan_misdn_log(1, bc->port, "--> state: %s\n", misdn_get_ch_state(ch));
 }

 switch (ch->state) {
 case MISDN_DIALING:
 case MISDN_PROGRESS:
 if (bc->nt && !ch->nttimeout) {
 break;
 }
 /* fall-through */
 case MISDN_CALLING:
 case MISDN_ALERTING:
 case MISDN_PROCEEDING:
 case MISDN_CALLING_ACKNOWLEDGE:
 if (bc->nt) {
 bc->progress_indicator = INFO_PI_INBAND_AVAILABLE;
 hanguptone_indicate(ch);
 }

 bc->out_cause = AST_CAUSE_UNALLOCATED;
 misdn_lib_send_event(bc, EVENT_DISCONNECT);
 break;
 case MISDN_WAITING4DIGS:
 if (bc->nt) {
 bc->progress_indicator = INFO_PI_INBAND_AVAILABLE;
 bc->out_cause = AST_CAUSE_UNALLOCATED;
 hanguptone_indicate(ch);
 misdn_lib_send_event(bc, EVENT_DISCONNECT);
 } else {
 bc->out_cause = AST_CAUSE_NORMAL_CLEARING;
 misdn_lib_send_event(bc, EVENT_RELEASE);
 }
 break;
 case MISDN_CLEANING:
 chan_misdn_log(1, bc->port, " --> in state cleaning .. so ignoring, the stack should clean it for us\n");
 break;
 default:
 misdn_lib_send_event(bc, EVENT_RELEASE_COMPLETE);
 break;
 }
 break;

 /****************************/
 /** Supplementary Services **/
 /****************************/
 case EVENT_RETRIEVE:
 if (!ch) {
 chan_misdn_log(4, bc->port, " --> no CH, searching for held call\n");
 ch = find_hold_call_l3(bc->l3_id);
 if (!ch || ch->hold.state != MISDN_HOLD_ACTIVE) {
 ast_log(LOG_WARNING, "No held call found, cannot Retrieve\n");
 misdn_lib_send_event(bc, EVENT_RETRIEVE_REJECT);
 break;
 }
 }

 /* remember the channel again */
 ch->bc = bc;

 ch->hold.state = MISDN_HOLD_IDLE;
 ch->hold.port = 0;
 ch->hold.channel = 0;

 ast_queue_unhold(ch->ast);

 if (misdn_lib_send_event(bc, EVENT_RETRIEVE_ACKNOWLEDGE) < 0) {
 chan_misdn_log(4, bc->port, " --> RETRIEVE_ACK failed\n");
 misdn_lib_send_event(bc, EVENT_RETRIEVE_REJECT);
 }
 break;
 case EVENT_HOLD:
 {
 int hold_allowed;
 RAII_VAR(struct ast_channel *, bridged, NULL, ast_channel_cleanup);

 misdn_cfg_get(bc->port, MISDN_CFG_HOLD_ALLOWED, &hold_allowed, sizeof(hold_allowed));
 if (!hold_allowed) {
 chan_misdn_log(-1, bc->port, "Hold not allowed this port.\n");
 misdn_lib_send_event(bc, EVENT_HOLD_REJECT);
 break;
 }

 bridged = ast_channel_bridge_peer(ch->ast);
 if (bridged) {
 chan_misdn_log(2, bc->port, "Bridge Partner is of type: %s\n", ast_channel_tech(bridged)->type);
 ch->l3id = bc->l3_id;

 /* forget the channel now */
 ch->bc = NULL;
 ch->hold.state = MISDN_HOLD_ACTIVE;
 ch->hold.port = bc->port;
 ch->hold.channel = bc->channel;

 ast_queue_hold(ch->ast, NULL);

 misdn_lib_send_event(bc, EVENT_HOLD_ACKNOWLEDGE);
 } else {
 misdn_lib_send_event(bc, EVENT_HOLD_REJECT);
 chan_misdn_log(0, bc->port, "We aren't bridged to anybody\n");
 }
 break;
 }
 case EVENT_NOTIFY:
 if (bc->redirecting.to_changed) {
 /* Add configured prefix to redirecting.to.number */
 misdn_add_number_prefix(bc->port, bc->redirecting.to.number_type,
 bc->redirecting.to.number, sizeof(bc->redirecting.to.number));
 }
 switch (bc->notify_description_code) {
 case mISDN_NOTIFY_CODE_DIVERSION_ACTIVATED:
 /* Ignore for now. */
 bc->redirecting.to_changed = 0;
 break;
 case mISDN_NOTIFY_CODE_CALL_IS_DIVERTING:
 {
 struct ast_party_redirecting redirecting;

 if (!bc->redirecting.to_changed) {
 break;
 }
 bc->redirecting.to_changed = 0;
 if (!ch || !ch->ast) {
 break;
 }
 switch (ch->state) {
 case MISDN_ALERTING:
 /* Call is deflecting after we have seen an ALERTING message */
 bc->redirecting.reason = mISDN_REDIRECTING_REASON_NO_REPLY;
 break;
 default:
 /* Call is deflecting for call forwarding unconditional or busy reason. */
 bc->redirecting.reason = mISDN_REDIRECTING_REASON_UNKNOWN;
 break;
 }
 misdn_copy_redirecting_to_ast(ch->ast, &bc->redirecting, bc->incoming_cid_tag);
 ast_party_redirecting_init(&redirecting);
 ast_party_redirecting_copy(&redirecting, ast_channel_redirecting(ch->ast));

 /*
 * Reset any earlier private redirecting id representations and
 * make sure that it is invalidated at the remote end.
 */
 ast_party_id_reset(&redirecting.priv_orig);
 ast_party_id_reset(&redirecting.priv_from);
 ast_party_id_reset(&redirecting.priv_to);

 ast_channel_queue_redirecting_update(ch->ast, &redirecting, NULL);
 ast_party_redirecting_free(&redirecting);
 break;
 }
 case mISDN_NOTIFY_CODE_CALL_TRANSFER_ALERTING:
 /*
 * It would be preferable to update the connected line information
 * only when the message callStatus is active. However, the
 * optional redirection number may not be present in the active
 * message if an alerting message were received earlier.
 *
 * The consequences if we wind up sending two updates is benign.
 * The other end will think that it got transferred twice.
 */
 if (!bc->redirecting.to_changed) {
 break;
 }
 bc->redirecting.to_changed = 0;
 if (!ch || !ch->ast) {
 break;
 }
 misdn_update_remote_party(ch->ast, &bc->redirecting.to,
 AST_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER_ALERTING,
 bc->incoming_cid_tag);
 break;
 case mISDN_NOTIFY_CODE_CALL_TRANSFER_ACTIVE:
 if (!bc->redirecting.to_changed) {
 break;
 }
 bc->redirecting.to_changed = 0;
 if (!ch || !ch->ast) {
 break;
 }
 misdn_update_remote_party(ch->ast, &bc->redirecting.to,
 AST_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER, bc->incoming_cid_tag);
 break;
 default:
 bc->redirecting.to_changed = 0;
 chan_misdn_log(0, bc->port," --> not yet handled: notify code:0x%02X\n",
 bc->notify_description_code);
 break;
 }
 bc->notify_description_code = mISDN_NOTIFY_CODE_INVALID;
 break;
 case EVENT_FACILITY:
 if (bc->fac_in.Function == Fac_None) {
 /* This is a FACILITY message so we MUST have a facility ie */
 chan_misdn_log(0, bc->port," --> Missing facility ie or unknown facility ie contents.\n");
 } else {
 misdn_facility_ie_handler(event, bc, ch);
 }

 /* In case it came in on a FACILITY message and we did not handle it. */
 bc->redirecting.to_changed = 0;
 bc->notify_description_code = mISDN_NOTIFY_CODE_INVALID;
 break;
 case EVENT_RESTART:
 if (!bc->dummy) {
 stop_bc_tones(ch);
 release_chan(ch, bc);
 }
 break;
 default:
 chan_misdn_log(1, 0, "Got Unknown Event\n");
 break;
 }

 if (ch) {
 chan_list_unref(ch, "cb_event complete OK");
 }
 return RESPONSE_OK;
}

chan_list_destructor()

static void chan_list_destructor ( void *  obj )

static

Definition at line 7792 of file chan_misdn.c.

References ao2_ref, ast_dsp_free(), ast_mutex_destroy, chan_list::dsp, chan_list::jb, misdn_jb_destroy(), misdn_tasks_remove(), NULL, chan_list::overlap_dial, chan_list::overlap_dial_task, chan_list::overlap_tv_lock, and chan_list::pipe.

Referenced by chan_list_init().

{
 struct chan_list *ch = obj;

#if defined(AST_MISDN_ENHANCEMENTS)
 if (ch->peer) {
 ao2_ref(ch->peer, -1);
 ch->peer = NULL;
 }
#endif /* AST_MISDN_ENHANCEMENTS */

 if (ch->dsp) {
 ast_dsp_free(ch->dsp);
 ch->dsp = NULL;
 }

 /* releasing jitterbuffer */
 if (ch->jb) {
 misdn_jb_destroy(ch->jb);
 ch->jb = NULL;
 }

 if (ch->overlap_dial) {
 if (ch->overlap_dial_task != -1) {
 misdn_tasks_remove(ch->overlap_dial_task);
 ch->overlap_dial_task = -1;
 }
 ast_mutex_destroy(&ch->overlap_tv_lock);
 }

 if (-1 < ch->pipe[0]) {
 close(ch->pipe[0]);
 }
 if (-1 < ch->pipe[1]) {
 close(ch->pipe[1]);
 }
}

chan_list_init()

static struct chan_list* chan_list_init ( int  orig )

static

Returns a reference to the new chan_list.

Definition at line 7831 of file chan_misdn.c.

References ao2_alloc, chan_list_destructor(), chan_misdn_log(), chan_list::need_busy, chan_list::need_hangup, chan_list::need_queue_hangup, NULL, chan_list::originator, chan_list::overlap_dial_task, and chan_list::pipe.

Referenced by cb_events(), and misdn_request().

{
 struct chan_list *cl;

 cl = ao2_alloc(sizeof(*cl), chan_list_destructor);
 if (!cl) {
 chan_misdn_log(-1, 0, "misdn_request: malloc failed!");
 return NULL;
 }

 cl->originator = orig;
 cl->need_queue_hangup = 1;
 cl->need_hangup = 1;
 cl->need_busy = 1;
 cl->overlap_dial_task = -1;
#if defined(AST_MISDN_ENHANCEMENTS)
 cl->record_id = -1;
#endif /* defined(AST_MISDN_ENHANCEMENTS) */
 cl->pipe[0] = -1;
 cl->pipe[1] = -1;

 return cl;
}

chan_misdn_jb_empty()

int chan_misdn_jb_empty	(	struct misdn_bchannel *	bc,
		char *	buf,
		int	len
	)

Definition at line 12574 of file chan_misdn.c.

References chan_list_unref, find_chan_by_bc(), chan_list::jb, and misdn_jb_empty().

Referenced by load_module().

{
 struct chan_list *ch;
 int res;

 ch = find_chan_by_bc(bc);
 if (!ch) {
 return 0;
 }

 if (ch->jb) {
 res = misdn_jb_empty(ch->jb, buf, len);
 } else {
 res = 0;
 }
 chan_list_unref(ch, "Done emptying jb");

 return res;
}

chan_misdn_log()

static void chan_misdn_log ( int  level, int  port, char *  tmpl,   ...  )

static

Definition at line 12768 of file chan_misdn.c.

References ast_log, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_CHANNEL_DRIVER, AST_MODULE_INFO(), AST_MODULE_SUPPORT_DEPRECATED, ast_strlen_zero, ast_verbose(), ASTERISK_GPL_KEY, errno, global_tracefile, load_module(), LOG_WARNING, NULL, reload(), tmp(), and unload_module().

Referenced by bearer2str(), cb_events(), chan_list_init(), cl_queue_chan(), config_jitterbuffer(), debug_numtype(), dialtone_indicate(), do_immediate_setup(), export_ch(), find_chan_by_bc(), find_hold_call(), get_chan_by_ast_name(), load_module(), misdn_answer(), misdn_attempt_transfer(), misdn_call(), misdn_check_l2l1(), misdn_digit_end(), misdn_facility_exec(), misdn_facility_ie_handler(), misdn_fixup(), misdn_hangup(), misdn_indication(), misdn_jb_empty(), misdn_jb_fill(), misdn_jb_init(), misdn_l1_task(), misdn_new(), misdn_overlap_dial_task(), misdn_read(), misdn_request(), misdn_set_opt_exec(), misdn_tasks_destroy(), misdn_tasks_init(), misdn_tasks_thread_func(), misdn_write(), print_bearer(), print_facility(), process_ast_dsp(), read_config(), release_chan(), send_cause2ast(), start_pbx(), stop_indicate(), update_config(), update_name(), and wait_for_digits().

{
 va_list ap;
 char buf[1024];
 char port_buf[8];

 if (!(0 <= port && port <= max_ports)) {
 ast_log(LOG_WARNING, "chan_misdn_log called with out-of-range port number! (%d)\n", port);
 port = 0;
 level = -1;
 } else if (!(level == -1
 || (misdn_debug_only[port]
 ? (level == 1 && misdn_debug[port]) || level == misdn_debug[port]
 : level <= misdn_debug[port])
 || (level <= misdn_debug[0] && !ast_strlen_zero(global_tracefile)))) {
 /*
 * We are not going to print anything so lets not
 * go to all the work of generating a string.
 */
 return;
 }

 snprintf(port_buf, sizeof(port_buf), "P[%2d] ", port);
 va_start(ap, tmpl);
 vsnprintf(buf, sizeof(buf), tmpl, ap);
 va_end(ap);

 if (level == -1) {
 ast_log(LOG_WARNING, "%s", buf);
 } else if (misdn_debug_only[port]
 ? (level == 1 && misdn_debug[port]) || level == misdn_debug[port]
 : level <= misdn_debug[port]) {
 ast_verbose("%s%s", port_buf, buf);
 }

 if (level <= misdn_debug[0] && !ast_strlen_zero(global_tracefile)) {
 char ctimebuf[30];
 time_t tm;
 char *tmp;
 char *p;
 FILE *fp;

 fp = fopen(global_tracefile, "a+");
 if (!fp) {
 ast_verbose("Error opening Tracefile: [ %s ] %s\n", global_tracefile, strerror(errno));
 return;
 }

 tm = time(NULL);
 tmp = ctime_r(&tm, ctimebuf);
 p = strchr(tmp, '\n');
 if (p) {
 *p = ':';
 }
 fputs(tmp, fp);
 fputs(" ", fp);
 fputs(port_buf, fp);
 fputs(" ", fp);
 fputs(buf, fp);

 fclose(fp);
 }
}

cl_dequeue_chan()

static int cl_dequeue_chan ( struct chan_list *  chan )

static

Definition at line 8398 of file chan_misdn.c.

References ast_mutex_lock, ast_mutex_unlock, chan_list_unref, and chan_list::next.

Referenced by release_chan(), and release_chan_early().

{
 int found_it;
 struct chan_list *help;

 ast_mutex_lock(&cl_te_lock);
 if (!cl_te) {
 /* List is empty. */
 ast_mutex_unlock(&cl_te_lock);
 return 0;
 }

 if (cl_te == chan) {
 /* What we want is the head of the list. */
 cl_te = cl_te->next;
 ast_mutex_unlock(&cl_te_lock);
 chan_list_unref(chan, "Removed chan_list from list head");
 return 1;
 }

 found_it = 0;
 for (help = cl_te; help->next; help = help->next) {
 if (help->next == chan) {
 /* Found it in the list. */
 help->next = help->next->next;
 found_it = 1;
 break;
 }
 }

 ast_mutex_unlock(&cl_te_lock);
 if (found_it) {
 chan_list_unref(chan, "Removed chan_list from list");
 }
 return found_it;
}

cl_queue_chan()

static void cl_queue_chan ( struct chan_list *  chan )

static

Definition at line 8377 of file chan_misdn.c.

References ast_mutex_lock, ast_mutex_unlock, chan_list::bc, chan_list_ref, chan_misdn_log(), chan_list::next, NULL, and misdn_bchannel::port.

Referenced by cb_events(), and misdn_request().

{
 chan_misdn_log(4, chan->bc ? chan->bc->port : 0, "* Queuing chan %p\n", chan);

 chan_list_ref(chan, "Adding chan_list to list");
 ast_mutex_lock(&cl_te_lock);
 chan->next = NULL;
 if (!cl_te) {
 /* List is empty, make head of list. */
 cl_te = chan;
 } else {
 struct chan_list *help;

 /* Put at end of list. */
 for (help = cl_te; help->next; help = help->next) {
 }
 help->next = chan;
 }
 ast_mutex_unlock(&cl_te_lock);
}

complete_ch()

static char * complete_ch ( struct ast_cli_args *  a )

static

Definition at line 5654 of file chan_misdn.c.

References ast_complete_channels(), ast_cli_args::line, ast_cli_args::n, ast_cli_args::pos, and ast_cli_args::word.

Referenced by handle_cli_misdn_send_digit(), handle_cli_misdn_send_display(), handle_cli_misdn_send_facility(), handle_cli_misdn_show_channel(), and handle_cli_misdn_toggle_echocancel().

{
 return ast_complete_channels(a->line, a->word, a->pos, a->n, 3);
}

complete_debug_port()

static char * complete_debug_port ( struct ast_cli_args *  a )

static

Definition at line 5659 of file chan_misdn.c.

References ast_strdup, ast_cli_args::n, NULL, ast_cli_args::pos, and ast_cli_args::word.

Referenced by handle_cli_misdn_set_debug().

{
 if (a->n) {
 return NULL;
 }

 switch (a->pos) {
 case 4:
 if (a->word[0] == 'p') {
 return ast_strdup("port");
 } else if (a->word[0] == 'o') {
 return ast_strdup("only");
 }
 break;
 case 6:
 if (a->word[0] == 'o') {
 return ast_strdup("only");
 }
 break;
 }
 return NULL;
}

complete_show_config()

static char * complete_show_config ( struct ast_cli_args *  a )

static

Definition at line 5682 of file chan_misdn.c.

References ast_strdup, BUFFERSIZE, ast_cli_args::line, MISDN_CFG_FIRST, misdn_cfg_get_name(), misdn_cfg_get_next_port(), MISDN_CFG_LAST, MISDN_GEN_FIRST, MISDN_GEN_LAST, ast_cli_args::n, NULL, ast_cli_args::pos, and ast_cli_args::word.

Referenced by handle_cli_misdn_show_config().

{
 char buffer[BUFFERSIZE];
 enum misdn_cfg_elements elem;
 int wordlen = strlen(a->word);
 int which = 0;
 int port = 0;

 switch (a->pos) {
 case 3:
 if ((!strncmp(a->word, "description", wordlen)) && (++which > a->n)) {
 return ast_strdup("description");
 }
 if ((!strncmp(a->word, "descriptions", wordlen)) && (++which > a->n)) {
 return ast_strdup("descriptions");
 }
 if ((!strncmp(a->word, "0", wordlen)) && (++which > a->n)) {
 return ast_strdup("0");
 }
 while ((port = misdn_cfg_get_next_port(port)) != -1) {
 snprintf(buffer, sizeof(buffer), "%d", port);
 if ((!strncmp(a->word, buffer, wordlen)) && (++which > a->n)) {
 return ast_strdup(buffer);
 }
 }
 break;
 case 4:
 if (strstr(a->line, "description ")) {
 for (elem = MISDN_CFG_FIRST + 1; elem < MISDN_GEN_LAST; ++elem) {
 if ((elem == MISDN_CFG_LAST) || (elem == MISDN_GEN_FIRST)) {
 continue;
 }
 misdn_cfg_get_name(elem, buffer, sizeof(buffer));
 if (!wordlen || !strncmp(a->word, buffer, wordlen)) {
 if (++which > a->n) {
 return ast_strdup(buffer);
 }
 }
 }
 } else if (strstr(a->line, "descriptions ")) {
 if ((!wordlen || !strncmp(a->word, "general", wordlen)) && (++which > a->n)) {
 return ast_strdup("general");
 }
 if ((!wordlen || !strncmp(a->word, "ports", wordlen)) && (++which > a->n)) {
 return ast_strdup("ports");
 }
 }
 break;
 }
 return NULL;
}

config_jitterbuffer()

static void config_jitterbuffer ( struct chan_list *  ch )

static

Definition at line 5817 of file chan_misdn.c.

References chan_list::bc, cb_log, chan_misdn_log(), chan_list::jb, chan_list::jb_len, chan_list::jb_upper_threshold, len(), misdn_jb_destroy(), misdn_jb_init(), misdn_bchannel::nojitter, NULL, and misdn_bchannel::port.

Referenced by misdn_set_opt_exec(), and read_config().

{
 struct misdn_bchannel *bc = ch->bc;
 int len = ch->jb_len;
 int threshold = ch->jb_upper_threshold;

 chan_misdn_log(5, bc->port, "config_jb: Called\n");

 if (!len) {
 chan_misdn_log(1, bc->port, "config_jb: Deactivating Jitterbuffer\n");
 bc->nojitter = 1;
 } else {
 if (len <= 100 || len > 8000) {
 chan_misdn_log(0, bc->port, "config_jb: Jitterbuffer out of Bounds, setting to 1000\n");
 len = 1000;
 }

 if (threshold > len) {
 chan_misdn_log(0, bc->port, "config_jb: Jitterbuffer Threshold > Jitterbuffer setting to Jitterbuffer -1\n");
 }

 if (ch->jb) {
 cb_log(0, bc->port, "config_jb: We've got a Jitterbuffer Already on this port.\n");
 misdn_jb_destroy(ch->jb);
 ch->jb = NULL;
 }

 ch->jb = misdn_jb_init(len, threshold);

 if (!ch->jb) {
 bc->nojitter = 1;
 }
 }
}

debug_numtype()

void debug_numtype	(	int	port,
		int	numtype,
		char *	type
	)

Definition at line 5853 of file chan_misdn.c.

References ast_copy_string(), chan_misdn_log(), MISDN_CFG_ECHOCANCEL, misdn_cfg_get(), NUMTYPE_ABBREVIATED, NUMTYPE_INTERNATIONAL, NUMTYPE_NATIONAL, NUMTYPE_NETWORK_SPECIFIC, NUMTYPE_SUBSCRIBER, NUMTYPE_UNKNOWN, and misdn_bchannel::port.

Referenced by misdn_call(), misdn_get_connected_line(), and read_config().

{
 switch (numtype) {
 case NUMTYPE_UNKNOWN:
 chan_misdn_log(2, port, " --> %s: Unknown\n", type);
 break;
 case NUMTYPE_INTERNATIONAL:
 chan_misdn_log(2, port, " --> %s: International\n", type);
 break;
 case NUMTYPE_NATIONAL:
 chan_misdn_log(2, port, " --> %s: National\n", type);
 break;
 case NUMTYPE_NETWORK_SPECIFIC:
 chan_misdn_log(2, port, " --> %s: Network Specific\n", type);
 break;
 case NUMTYPE_SUBSCRIBER:
 chan_misdn_log(2, port, " --> %s: Subscriber\n", type);
 break;
 case NUMTYPE_ABBREVIATED:
 chan_misdn_log(2, port, " --> %s: Abbreviated\n", type);
 break;
 /* Maybe we should cut off the prefix if present ? */
 default:
 chan_misdn_log(0, port, " --> !!!! Wrong dialplan setting, please see the misdn.conf sample file\n ");
 break;
 }
}

dialtone_indicate()

static int dialtone_indicate ( struct chan_list *  cl )

static

AST INDICATIONS END

Definition at line 7707 of file chan_misdn.c.

References chan_list::ast, ast_channel_zone(), ast_get_indication_tone(), ast_playtones_start(), chan_list::bc, chan_misdn_log(), ast_tone_zone_sound::data, misdn_cfg_get(), MISDN_CFG_NODIALTONE, chan_list::norxtone, chan_list::notxtone, misdn_bchannel::port, and chan_list::ts.

Referenced by wait_for_digits().

{
 struct ast_channel *ast = cl->ast;
 int nd = 0;

 if (!ast) {
 chan_misdn_log(0, cl->bc->port, "No Ast in dialtone_indicate\n");
 return -1;
 }

 misdn_cfg_get(cl->bc->port, MISDN_CFG_NODIALTONE, &nd, sizeof(nd));

 if (nd) {
 chan_misdn_log(1, cl->bc->port, "Not sending Dialtone, because config wants it\n");
 return 0;
 }

 chan_misdn_log(3, cl->bc->port, " --> Dial\n");

 cl->ts = ast_get_indication_tone(ast_channel_zone(ast), "dial");

 if (cl->ts) {
 cl->notxtone = 0;
 cl->norxtone = 0;
 /* This prods us in misdn_write */
 ast_playtones_start(ast, 0, cl->ts->data, 0);
 }

 return 0;
}

do_immediate_setup()

static void do_immediate_setup ( struct misdn_bchannel *  bc, struct chan_list *  ch, struct ast_channel *  ast  )

static

Definition at line 8659 of file chan_misdn.c.

References chan_list::ast, ast_canmatch_extension(), AST_CAUSE_UNALLOCATED, ast_channel_caller(), ast_channel_context(), ast_channel_exten(), ast_channel_exten_set(), AST_FRAME_DTMF, ast_queue_frame(), ast_strdupa, ast_strlen_zero, ast_tv(), misdn_bchannel::caller, chan_misdn_log(), ast_frame::data, ast_frame::datalen, ast_frame::delivery, EVENT_DISCONNECT, EVENT_PROCEEDING, EVENT_RELEASE_COMPLETE, EVENT_SETUP_ACKNOWLEDGE, ast_frame::frametype, hangup_chan(), hanguptone_indicate(), ast_frame_subclass::integer, ast_frame::mallocd, MISDN_ASTERISK_TECH_PVT, MISDN_DIALING, MISDN_INCOMING_SETUP, misdn_lib_is_ptp(), misdn_lib_send_event(), name, chan_list::noautorespond_on_setup, misdn_bchannel::nt, NULL, misdn_party_id::number, ast_frame::offset, misdn_bchannel::out_cause, pbx_start_chan(), misdn_bchannel::port, ast_frame::ptr, ast_frame::samples, ast_frame::src, chan_list::state, and ast_frame::subclass.

Referenced by cb_events().

{
 char *predial;
 struct ast_frame fr;

 predial = ast_strdupa(ast_channel_exten(ast));

 ch->state = MISDN_DIALING;

 if (!ch->noautorespond_on_setup) {
 if (bc->nt) {
 misdn_lib_send_event(bc, EVENT_SETUP_ACKNOWLEDGE);
 } else {
 if (misdn_lib_is_ptp(bc->port)) {
 misdn_lib_send_event(bc, EVENT_SETUP_ACKNOWLEDGE);
 } else {
 misdn_lib_send_event(bc, EVENT_PROCEEDING);
 }
 }
 } else {
 ch->state = MISDN_INCOMING_SETUP;
 }

 chan_misdn_log(1, bc->port,
 "* Starting Ast context:%s dialed:%s caller:\"%s\" <%s> with 's' extension\n",
 ast_channel_context(ast),
 ast_channel_exten(ast),
 (ast_channel_caller(ast)->id.name.valid && ast_channel_caller(ast)->id.name.str)
 ? ast_channel_caller(ast)->id.name.str : "",
 (ast_channel_caller(ast)->id.number.valid && ast_channel_caller(ast)->id.number.str)
 ? ast_channel_caller(ast)->id.number.str : "");

 ast_channel_exten_set(ast, "s");

 if (!ast_canmatch_extension(ast, ast_channel_context(ast), ast_channel_exten(ast), 1, bc->caller.number) || pbx_start_chan(ch) < 0) {
 ast = NULL;
 bc->out_cause = AST_CAUSE_UNALLOCATED;
 hangup_chan(ch, bc);
 hanguptone_indicate(ch);

 misdn_lib_send_event(bc, bc->nt ? EVENT_RELEASE_COMPLETE : EVENT_DISCONNECT);
 }


 while (!ast_strlen_zero(predial)) {
 fr.frametype = AST_FRAME_DTMF;
 fr.subclass.integer = *predial;
 fr.src = NULL;
 fr.data.ptr = NULL;
 fr.datalen = 0;
 fr.samples = 0;
 fr.mallocd = 0;
 fr.offset = 0;
 fr.delivery = ast_tv(0,0);

 if (ch->ast && MISDN_ASTERISK_TECH_PVT(ch->ast)) {
 ast_queue_frame(ch->ast, &fr);
 }
 predial++;
 }
}

export_aoc_vars()

static void export_aoc_vars ( int  originator, struct ast_channel *  ast, struct misdn_bchannel *  bc  )

static

Definition at line 3458 of file chan_misdn.c.

References misdn_bchannel::AOCD, misdn_bchannel::AOCD_need_export, misdn_bchannel::AOCDtype, ast_channel_bridge_peer(), ast_channel_cleanup, ast_channel_ref, buf, misdn_bchannel::chargingUnit, misdn_bchannel::currency, NULL, ORG_AST, pbx_builtin_setvar_helper(), and RAII_VAR.

Referenced by cb_events(), and misdn_facility_ie_handler().

{
 RAII_VAR(struct ast_channel *, chan, NULL, ast_channel_cleanup);
 char buf[128];

 if (!bc->AOCD_need_export || !ast) {
 return;
 }

 if (originator == ORG_AST) {
 chan = ast_channel_bridge_peer(ast);
 if (!chan) {
 return;
 }
 } else {
 chan = ast_channel_ref(ast);
 }

 switch (bc->AOCDtype) {
 case Fac_AOCDCurrency:
 pbx_builtin_setvar_helper(chan, "AOCD_Type", "currency");
 if (bc->AOCD.currency.chargeNotAvailable) {
 pbx_builtin_setvar_helper(chan, "AOCD_ChargeAvailable", "no");
 } else {
 pbx_builtin_setvar_helper(chan, "AOCD_ChargeAvailable", "yes");
 if (bc->AOCD.currency.freeOfCharge) {
 pbx_builtin_setvar_helper(chan, "AOCD_FreeOfCharge", "yes");
 } else {
 pbx_builtin_setvar_helper(chan, "AOCD_FreeOfCharge", "no");
 if (snprintf(buf, sizeof(buf), "%d %s", bc->AOCD.currency.currencyAmount * bc->AOCD.currency.multiplier, bc->AOCD.currency.currency) < sizeof(buf)) {
 pbx_builtin_setvar_helper(chan, "AOCD_Amount", buf);
 if (bc->AOCD.currency.billingId >= 0 && snprintf(buf, sizeof(buf), "%d", bc->AOCD.currency.billingId) < sizeof(buf)) {
 pbx_builtin_setvar_helper(chan, "AOCD_BillingId", buf);
 }
 }
 }
 }
 break;
 case Fac_AOCDChargingUnit:
 pbx_builtin_setvar_helper(chan, "AOCD_Type", "charging_unit");
 if (bc->AOCD.chargingUnit.chargeNotAvailable) {
 pbx_builtin_setvar_helper(chan, "AOCD_ChargeAvailable", "no");
 } else {
 pbx_builtin_setvar_helper(chan, "AOCD_ChargeAvailable", "yes");
 if (bc->AOCD.chargingUnit.freeOfCharge) {
 pbx_builtin_setvar_helper(chan, "AOCD_FreeOfCharge", "yes");
 } else {
 pbx_builtin_setvar_helper(chan, "AOCD_FreeOfCharge", "no");
 if (snprintf(buf, sizeof(buf), "%d", bc->AOCD.chargingUnit.recordedUnits) < sizeof(buf)) {
 pbx_builtin_setvar_helper(chan, "AOCD_RecordedUnits", buf);
 if (bc->AOCD.chargingUnit.billingId >= 0 && snprintf(buf, sizeof(buf), "%d", bc->AOCD.chargingUnit.billingId) < sizeof(buf)) {
 pbx_builtin_setvar_helper(chan, "AOCD_BillingId", buf);
 }
 }
 }
 }
 break;
 default:
 break;
 }

 bc->AOCD_need_export = 0;
}

export_ch()

void export_ch	(	struct ast_channel *	chan,
		struct misdn_bchannel *	bc,
		struct chan_list *	ch
	)

Export parameters to the dialplan environment variables.

Definition at line 8811 of file chan_misdn.c.

References ast_strlen_zero, chan_misdn_log(), misdn_bchannel::keypad, pbx_builtin_setvar_helper(), misdn_bchannel::pid, misdn_bchannel::port, misdn_bchannel::sending_complete, tmp(), misdn_bchannel::urate, misdn_bchannel::uu, and misdn_bchannel::uulen.

Referenced by cb_events().

{
 char tmp[32];

 /*
 * The only use for MISDN_PID is if there is a problem and you
 * have to use the "misdn restart pid" CLI command. Otherwise,
 * the pid is not used by anyone. The internal use of MISDN_PID
 * has been deleted.
 */
 chan_misdn_log(3, bc->port, " --> EXPORT_PID: pid:%d\n", bc->pid);
 snprintf(tmp, sizeof(tmp), "%d", bc->pid);
 pbx_builtin_setvar_helper(chan, "_MISDN_PID", tmp);

 if (bc->sending_complete) {
 snprintf(tmp, sizeof(tmp), "%d", bc->sending_complete);
 pbx_builtin_setvar_helper(chan, "MISDN_ADDRESS_COMPLETE", tmp);
 }

 if (bc->urate) {
 snprintf(tmp, sizeof(tmp), "%d", bc->urate);
 pbx_builtin_setvar_helper(chan, "MISDN_URATE", tmp);
 }

 if (bc->uulen) {
 pbx_builtin_setvar_helper(chan, "MISDN_USERUSER", bc->uu);
 }

 if (!ast_strlen_zero(bc->keypad)) {
 pbx_builtin_setvar_helper(chan, "MISDN_KEYPAD", bc->keypad);
 }
}

find_chan_by_bc()

static struct chan_list* find_chan_by_bc ( struct misdn_bchannel *  bc )

static

Returns a reference to the found chan_list.

Definition at line 8259 of file chan_misdn.c.

References ast_mutex_lock, ast_mutex_unlock, chan_list::bc, misdn_bchannel::caller, chan_list_ref, chan_misdn_log(), misdn_bchannel::dialed, misdn_party_id::name, chan_list::next, NULL, misdn_party_dialing::number, misdn_party_id::number, and misdn_bchannel::port.

Referenced by cb_events(), and chan_misdn_jb_empty().

{
 struct chan_list *help;

 ast_mutex_lock(&cl_te_lock);
 for (help = cl_te; help; help = help->next) {
 if (help->bc == bc) {
 chan_list_ref(help, "Found chan_list by bc");
 ast_mutex_unlock(&cl_te_lock);
 return help;
 }
 }
 ast_mutex_unlock(&cl_te_lock);

 chan_misdn_log(6, bc->port,
 "$$$ find_chan_by_bc: No channel found for dialed:%s caller:\"%s\" <%s>\n",
 bc->dialed.number,
 bc->caller.name,
 bc->caller.number);

 return NULL;
}

find_hold_active_call()

static struct chan_list* find_hold_active_call ( struct misdn_bchannel *  bc )

static

Definition at line 8351 of file chan_misdn.c.

References chan_list::ast, ast_mutex_lock, ast_mutex_unlock, chan_list::bc, chan_list_ref, chan_list::hold, MISDN_ALERTING, MISDN_CONNECTED, MISDN_HOLD_IDLE, MISDN_PROCEEDING, MISDN_PROGRESS, chan_list::next, NULL, misdn_bchannel::port, hold_info::state, and chan_list::state.

Referenced by cb_events().

{
 struct chan_list *list;

 ast_mutex_lock(&cl_te_lock);
 for (list = cl_te; list; list = list->next) {
 if (list->hold.state == MISDN_HOLD_IDLE && list->bc && list->bc->port == bc->port
 && list->ast) {
 switch (list->state) {
 case MISDN_PROCEEDING:
 case MISDN_PROGRESS:
 case MISDN_ALERTING:
 case MISDN_CONNECTED:
 chan_list_ref(list, "Found chan_list hold active call");
 ast_mutex_unlock(&cl_te_lock);
 return list;
 default:
 break;
 }
 }
 }
 ast_mutex_unlock(&cl_te_lock);
 return NULL;
}

find_hold_call()

static struct chan_list* find_hold_call ( struct misdn_bchannel *  bc )

static

Returns a reference to the found chan_list.

Definition at line 8283 of file chan_misdn.c.

References ast_mutex_lock, ast_mutex_unlock, misdn_bchannel::caller, chan_list_ref, chan_misdn_log(), hold_info::channel, misdn_bchannel::channel, misdn_bchannel::dialed, chan_list::hold, MISDN_HOLD_ACTIVE, misdn_party_id::name, chan_list::next, NULL, misdn_party_dialing::number, misdn_party_id::number, hold_info::port, misdn_bchannel::port, misdn_bchannel::pri, and hold_info::state.

Referenced by cb_events().

{
 struct chan_list *help;

 if (bc->pri) {
 return NULL;
 }

 chan_misdn_log(6, bc->port, "$$$ find_hold_call: channel:%d dialed:%s caller:\"%s\" <%s>\n",
 bc->channel,
 bc->dialed.number,
 bc->caller.name,
 bc->caller.number);
 ast_mutex_lock(&cl_te_lock);
 for (help = cl_te; help; help = help->next) {
 chan_misdn_log(4, bc->port, "$$$ find_hold_call: --> hold:%d channel:%d\n", help->hold.state, help->hold.channel);
 if (help->hold.state == MISDN_HOLD_ACTIVE && help->hold.port == bc->port) {
 chan_list_ref(help, "Found chan_list hold call");
 ast_mutex_unlock(&cl_te_lock);
 return help;
 }
 }
 ast_mutex_unlock(&cl_te_lock);
 chan_misdn_log(6, bc->port,
 "$$$ find_hold_call: No channel found for dialed:%s caller:\"%s\" <%s>\n",
 bc->dialed.number,
 bc->caller.name,
 bc->caller.number);

 return NULL;
}

find_hold_call_l3()

static struct chan_list* find_hold_call_l3 ( unsigned long  l3_id )

static

Returns a reference to the found chan_list.

Definition at line 8317 of file chan_misdn.c.

References ast_mutex_lock, ast_mutex_unlock, chan_list_ref, chan_list::hold, chan_list::l3id, MISDN_HOLD_IDLE, chan_list::next, NULL, and hold_info::state.

Referenced by cb_events().

{
 struct chan_list *help;

 ast_mutex_lock(&cl_te_lock);
 for (help = cl_te; help; help = help->next) {
 if (help->hold.state != MISDN_HOLD_IDLE && help->l3id == l3_id) {
 chan_list_ref(help, "Found chan_list hold call l3");
 ast_mutex_unlock(&cl_te_lock);
 return help;
 }
 }
 ast_mutex_unlock(&cl_te_lock);

 return NULL;
}

free_robin_list()

static void free_robin_list ( void  )

static

Definition at line 629 of file chan_misdn.c.

References ast_free, robin_list::group, robin_list::next, and NULL.

Referenced by reload_config(), and unload_module().

{
 struct robin_list *r;
 struct robin_list *next;

 for (r = robin, robin = NULL; r; r = next) {
 next = r->next;
 ast_free(r->group);
 ast_free(r);
 }
}

get_chan_by_ast_name()

static struct chan_list* get_chan_by_ast_name ( const char *  name )

static

Returns a reference to the found chan_list.

Definition at line 786 of file chan_misdn.c.

References ao2_lock, ao2_ref, ao2_unlock, ARRAY_LEN, chan_list::ast, ast_calloc, AST_CAUSE_NORMAL_CLEARING, ast_channel_datastore_find(), ast_channel_lock, ast_channel_name(), ast_channel_trylock, ast_channel_unlock, ast_free, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_REMOVE_HEAD, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_mutex_lock, ast_mutex_unlock, ast_safe_sleep_conditional(), bc, chan_list_ref, chan_misdn_log(), ast_datastore::data, EVENT_RELEASE_COMPLETE, misdn_lib_send_event(), mISDN_REDIRECTING_REASON_CALL_FWD, mISDN_REDIRECTING_REASON_CALL_FWD_BUSY, mISDN_REDIRECTING_REASON_NO_REPLY, mISDN_REDIRECTING_REASON_UNKNOWN, name, chan_list::next, NULL, NUMPLAN_DATA, NUMPLAN_ISDN, NUMPLAN_NATIONAL, NUMPLAN_PRIVATE, NUMPLAN_TELEX, NUMPLAN_UNKNOWN, NUMTYPE_ABBREVIATED, NUMTYPE_INTERNATIONAL, NUMTYPE_NATIONAL, NUMTYPE_NETWORK_SPECIFIC, NUMTYPE_SUBSCRIBER, NUMTYPE_UNKNOWN, pbx_builtin_setvar_helper(), tmp(), ast_datastore_info::type, type, value, and var.

Referenced by handle_cli_misdn_send_digit(), handle_cli_misdn_send_display(), handle_cli_misdn_send_facility(), and handle_cli_misdn_toggle_echocancel().

{
 struct chan_list *tmp;

 ast_mutex_lock(&cl_te_lock);
 for (tmp = cl_te; tmp; tmp = tmp->next) {
 if (tmp->ast && strcmp(ast_channel_name(tmp->ast), name) == 0) {
 chan_list_ref(tmp, "Found chan_list by ast name");
 ast_mutex_unlock(&cl_te_lock);
 return tmp;
 }
 }
 ast_mutex_unlock(&cl_te_lock);

 return NULL;
}

get_robin_position()

static struct robin_list* get_robin_position ( char *  group )

static

Definition at line 641 of file chan_misdn.c.

References ast_calloc, ast_free, ast_strdup, robin_list::group, robin_list::next, NULL, robin_list::prev, and robin.

Referenced by misdn_request().

{
 struct robin_list *new;
 struct robin_list *iter = robin;
 for (; iter; iter = iter->next) {
 if (!strcasecmp(iter->group, group)) {
 return iter;
 }
 }
 new = ast_calloc(1, sizeof(*new));
 if (!new) {
 return NULL;
 }
 new->group = ast_strdup(group);
 if (!new->group) {
 ast_free(new);
 return NULL;
 }
 new->channel = 1;
 if (robin) {
 new->next = robin;
 robin->prev = new;
 }
 robin = new;
 return robin;
}

handle_cli_misdn_port_block()

static char* handle_cli_misdn_port_block ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 3830 of file chan_misdn.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, misdn_lib_port_block(), NULL, and ast_cli_entry::usage.

{
 switch (cmd) {
 case CLI_INIT:
 e->command = "misdn port block";
 e->usage =
 "Usage: misdn port block <port>\n"
 " Block the specified port by <port>.\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }

 if (a->argc != 4) {
 return CLI_SHOWUSAGE;
 }

 misdn_lib_port_block(atoi(a->argv[3]));

 return CLI_SUCCESS;
}

handle_cli_misdn_port_down()

static char* handle_cli_misdn_port_down ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 3940 of file chan_misdn.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, misdn_lib_get_port_down(), NULL, and ast_cli_entry::usage.

{
 switch (cmd) {
 case CLI_INIT:
 e->command = "misdn port down";
 e->usage =
 "Usage: misdn port down <port>\n"
 " Try to deactivate the L1 on the given port.\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }

 if (a->argc != 4) {
 return CLI_SHOWUSAGE;
 }

 misdn_lib_get_port_down(atoi(a->argv[3]));

 return CLI_SUCCESS;
}

handle_cli_misdn_port_unblock()

static char* handle_cli_misdn_port_unblock ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 3852 of file chan_misdn.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, misdn_lib_port_unblock(), NULL, and ast_cli_entry::usage.

{
 switch (cmd) {
 case CLI_INIT:
 e->command = "misdn port unblock";
 e->usage =
 "Usage: misdn port unblock <port>\n"
 " Unblock the port specified by <port>.\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }

 if (a->argc != 4) {
 return CLI_SHOWUSAGE;
 }

 misdn_lib_port_unblock(atoi(a->argv[3]));

 return CLI_SUCCESS;
}

handle_cli_misdn_port_up()

static char* handle_cli_misdn_port_up ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 3918 of file chan_misdn.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, misdn_lib_get_port_up(), NULL, and ast_cli_entry::usage.

{
 switch (cmd) {
 case CLI_INIT:
 e->command = "misdn port up";
 e->usage =
 "Usage: misdn port up <port>\n"
 " Try to establish L1 on the given port.\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }

 if (a->argc != 4) {
 return CLI_SHOWUSAGE;
 }

 misdn_lib_get_port_up(atoi(a->argv[3]));

 return CLI_SUCCESS;
}

handle_cli_misdn_reload()

static char* handle_cli_misdn_reload ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 4144 of file chan_misdn.c.

References ast_cli_args::argc, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, NULL, reload_config(), and ast_cli_entry::usage.

{
 switch (cmd) {
 case CLI_INIT:
 e->command = "misdn reload";
 e->usage =
 "Usage: misdn reload\n"
 " Reload internal mISDN config, read from the config\n"
 " file.\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }

 if (a->argc != 2) {
 return CLI_SHOWUSAGE;
 }

 ast_cli(a->fd, "Reloading mISDN configuration\n");
 reload_config();
 return CLI_SUCCESS;
}

handle_cli_misdn_restart_pid()

static char* handle_cli_misdn_restart_pid ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 3896 of file chan_misdn.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, misdn_lib_pid_restart(), NULL, and ast_cli_entry::usage.

{
 switch (cmd) {
 case CLI_INIT:
 e->command = "misdn restart pid";
 e->usage =
 "Usage: misdn restart pid <pid>\n"
 " Restart the given pid\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }

 if (a->argc != 4) {
 return CLI_SHOWUSAGE;
 }

 misdn_lib_pid_restart(atoi(a->argv[3]));

 return CLI_SUCCESS;
}

handle_cli_misdn_restart_port()

static char* handle_cli_misdn_restart_port ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 3874 of file chan_misdn.c.

References ast_cli_args::argc, ast_cli_args::argv, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, misdn_lib_port_restart(), NULL, and ast_cli_entry::usage.

{
 switch (cmd) {
 case CLI_INIT:
 e->command = "misdn restart port";
 e->usage =
 "Usage: misdn restart port <port>\n"
 " Restart the given port.\n";
 return NULL;
 case CLI_GENERATE:
 return NULL;
 }

 if (a->argc != 4) {
 return CLI_SHOWUSAGE;
 }

 misdn_lib_port_restart(atoi(a->argv[3]));

 return CLI_SUCCESS;
}

handle_cli_misdn_send_digit()

static char* handle_cli_misdn_send_digit ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 5509 of file chan_misdn.c.

References ast_cli_args::argc, ast_cli_args::argv, chan_list::ast, ast_cli(), ast_dtmf_stream(), chan_list_unref, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_ch(), ast_cli_args::fd, get_chan_by_ast_name(), NULL, send_digit_to_chan(), tmp(), and ast_cli_entry::usage.

{
 const char *channame;
 const char *msg;
 struct chan_list *tmp;
 int i, msglen;

 switch (cmd) {
 case CLI_INIT:
 e->command = "misdn send digit";
 e->usage =
 "Usage: misdn send digit <channel> \"<msg>\" \n"
 " Send <digit> to <channel> as DTMF Tone\n"
 " when channel is a mISDN channel\n";
 return NULL;
 case CLI_GENERATE:
 return complete_ch(a);
 }

 if (a->argc != 5) {
 return CLI_SHOWUSAGE;
 }

 channame = a->argv[3];
 msg = a->argv[4];
 msglen = strlen(msg);

 ast_cli(a->fd, "Sending %s to %s\n", msg, channame);

 tmp = get_chan_by_ast_name(channame);
 if (!tmp) {
 ast_cli(a->fd, "Sending %s to %s failed Channel does not exist\n", msg, channame);
 return CLI_SUCCESS;
 }
#if 1
 for (i = 0; i < msglen; i++) {
 if (!tmp->ast) {
 break;
 }
 ast_cli(a->fd, "Sending: %c\n", msg[i]);
 send_digit_to_chan(tmp, msg[i]);
 /* res = ast_safe_sleep(tmp->ast, 250); */
 usleep(250000);
 /* res = ast_waitfor(tmp->ast,100); */
 }
#else
 if (tmp->ast) {
 ast_dtmf_stream(tmp->ast, NULL, msg, 250);
 }
#endif
 chan_list_unref(tmp, "Digit(s) sent");

 return CLI_SUCCESS;
}

handle_cli_misdn_send_display()

static char* handle_cli_misdn_send_display ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 5611 of file chan_misdn.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_copy_string(), chan_list::bc, chan_list_unref, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_ch(), misdn_bchannel::display, EVENT_INFORMATION, ast_cli_args::fd, get_chan_by_ast_name(), misdn_lib_send_event(), NULL, tmp(), and ast_cli_entry::usage.

{
 const char *channame;
 const char *msg;
 struct chan_list *tmp;

 switch (cmd) {
 case CLI_INIT:
 e->command = "misdn send display";
 e->usage =
 "Usage: misdn send display <channel> \"<msg>\" \n"
 " Send <msg> to <channel> as Display Message\n"
 " when channel is a mISDN channel\n";
 return NULL;
 case CLI_GENERATE:
 return complete_ch(a);
 }

 if (a->argc != 5) {
 return CLI_SHOWUSAGE;
 }

 channame = a->argv[3];
 msg = a->argv[4];

 ast_cli(a->fd, "Sending %s to %s\n", msg, channame);

 tmp = get_chan_by_ast_name(channame);
 if (tmp && tmp->bc) {
 ast_copy_string(tmp->bc->display, msg, sizeof(tmp->bc->display));
 misdn_lib_send_event(tmp->bc, EVENT_INFORMATION);
 chan_list_unref(tmp, "Done sending display");
 } else {
 if (tmp) {
 chan_list_unref(tmp, "Display failed");
 }
 ast_cli(a->fd, "No such channel %s\n", channame);
 return CLI_SUCCESS;
 }

 return CLI_SUCCESS;
}