This commit introduces COLP/CONP and Redirecting party information into Asterisk.

The channel drivers which have been most heavily tested with these enhancements are
chan_sip and chan_misdn. Further work is being done to add Q.SIG support and will be
introduced in a later commit. chan_skinny has code added to it here, but according
to user pj, the support on chan_skinny is not working as of now. This will be fixed in
a later commit.

A special thanks goes out to bugtracker user gareth for getting the ball rolling and
providing the initial support for this work. Without his initial work on this, this would
not have been nearly as painless as it was.

This functionality has been tested by Digium's product quality department, as well as a
customer site running thousands of calls every day. In addition, many many many many bugtracker
users have tested this, too.

(closes issue #8824)
Reported by: gareth

Review: http://reviewboard.digium.com/r/201



git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@186525 65c4cc65-6c06-0410-ace0-fbb531ad65f3

1 files changed, 1147 insertions, 406 deletions

diff --git a/channels/chan_misdn.c b/channels/chan_misdn.c
index 599bcef82..52b8f1d9f 100644
--- a/channels/chan_misdn.c
+++ b/channels/chan_misdn.c
@@ -47,6 +47,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 #include <signal.h>
 #include <sys/file.h>
 #include <semaphore.h>
+#include <ctype.h>
 
 #include "asterisk/channel.h"
 #include "asterisk/config.h"
@@ -88,8 +89,6 @@ struct misdn_jb{
 	ast_mutex_t mutexjb;
 };
 
-
-
 /*! \brief allocates the jb-structure and initialize the elements */
 struct misdn_jb *misdn_jb_init(int size, int upper_threshold);
 
@@ -340,10 +339,6 @@ struct chan_list {
 	 */
 	char mohinterpret[MAX_MUSICCLASS];
 
-#if 0
-	int zero_read_cnt;	/* Not used */
-#endif
-
 	/*!
 	 * \brief Number of outgoing audio frames dropped since last debug gripe message.
 	 */
@@ -401,18 +396,10 @@ struct chan_list {
 	 */
 	struct timeval overlap_tv;
 
-#if 0
-	struct chan_list *peer;     /* Not used */
-#endif
-
 	/*!
 	 * \brief Next channel call record in the list.
 	 */
 	struct chan_list *next;
-#if 0
-	struct chan_list *prev;     /* Not used */
-	struct chan_list *first;    /* Not used */
-#endif
 };
 
 
@@ -423,13 +410,14 @@ void export_ch(struct ast_channel *chan, struct misdn_bchannel *bc, struct chan_
 void import_ch(struct ast_channel *chan, struct misdn_bchannel *bc, struct chan_list *ch);
 static struct ast_frame *process_ast_dsp(struct chan_list *tmp, struct ast_frame *frame);
 
-static struct robin_list {
+struct robin_list {
 	char *group;
 	int port;
 	int channel;
 	struct robin_list *next;
 	struct robin_list *prev;
-} *robin = NULL;
+};
+static struct robin_list *robin = NULL;
 
 
 static inline void free_robin_list_r(struct robin_list *r)
@@ -538,7 +526,7 @@ static int misdn_facility_exec(struct ast_channel *chan, void *data);
 
 int chan_misdn_jb_empty(struct misdn_bchannel *bc, char *buf, int len);
 
-void debug_numplan(int port, int numplan, char *type);
+void debug_numtype(int port, int numtype, char *type);
 
 int add_out_calls(int port);
 int add_in_calls(int port);
@@ -580,6 +568,534 @@ static struct chan_list * get_chan_by_ast_name(char *name)
 	return NULL;
 }
 
+/*!
+ * \internal
+ * \brief Convert the mISDN type of number code to a string
+ *
+ * \param number_type mISDN type of number code.
+ *
+ * \return The mISDN type of number code as a string
+ */
+static const char *misdn_to_str_ton(enum mISDN_NUMBER_TYPE number_type)
+{
+	const char *str;
+
+	switch (number_type) {
+	default:
+	case NUMTYPE_UNKNOWN:
+		str = "Unknown";
+		break;
+
+	case NUMTYPE_INTERNATIONAL:
+		str = "International";
+		break;
+
+	case NUMTYPE_NATIONAL:
+		str = "National";
+		break;
+
+	case NUMTYPE_NETWORK_SPECIFIC:
+		str = "Network Specific";
+		break;
+
+	case NUMTYPE_SUBSCRIBER:
+		str = "Subscriber";
+		break;
+
+	case NUMTYPE_ABBREVIATED:
+		str = "Abbreviated";
+		break;
+	}
+
+	return str;
+}
+
+/*!
+ * \internal
+ * \brief Convert the mISDN type of number code to Asterisk type of number code
+ *
+ * \param number_type mISDN type of number code.
+ *
+ * \return Asterisk type of number code
+ */
+static int misdn_to_ast_ton(enum mISDN_NUMBER_TYPE number_type)
+{
+	int ast_number_type;
+
+	switch (number_type) {
+	default:
+	case NUMTYPE_UNKNOWN:
+		ast_number_type = NUMTYPE_UNKNOWN << 4;
+		break;
+
+	case NUMTYPE_INTERNATIONAL:
+		ast_number_type = NUMTYPE_INTERNATIONAL << 4;
+		break;
+
+	case NUMTYPE_NATIONAL:
+		ast_number_type = NUMTYPE_NATIONAL << 4;
+		break;
+
+	case NUMTYPE_NETWORK_SPECIFIC:
+		ast_number_type = NUMTYPE_NETWORK_SPECIFIC << 4;
+		break;
+
+	case NUMTYPE_SUBSCRIBER:
+		ast_number_type = NUMTYPE_SUBSCRIBER << 4;
+		break;
+
+	case NUMTYPE_ABBREVIATED:
+		ast_number_type = NUMTYPE_ABBREVIATED << 4;
+		break;
+	}
+
+	return ast_number_type;
+}
+
+/*!
+ * \internal
+ * \brief Convert the Asterisk type of number code to mISDN type of number code
+ *
+ * \param ast_number_type Asterisk type of number code.
+ *
+ * \return mISDN type of number code
+ */
+static enum mISDN_NUMBER_TYPE ast_to_misdn_ton(unsigned ast_number_type)
+{
+	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;
+}
+
+/*!
+ * \internal
+ * \brief Convert the mISDN numbering plan code to a string
+ *
+ * \param number_plan mISDN numbering plan code.
+ *
+ * \return The mISDN numbering plan code as a string
+ */
+static const char *misdn_to_str_plan(enum mISDN_NUMBER_PLAN number_plan)
+{
+	const char *str;
+
+	switch (number_plan) {
+	default:
+	case NUMPLAN_UNKNOWN:
+		str = "Unknown";
+		break;
+
+	case NUMPLAN_ISDN:
+		str = "ISDN";
+		break;
+
+	case NUMPLAN_DATA:
+		str = "Data";
+		break;
+
+	case NUMPLAN_TELEX:
+		str = "Telex";
+		break;
+
+	case NUMPLAN_NATIONAL:
+		str = "National";
+		break;
+
+	case NUMPLAN_PRIVATE:
+		str = "Private";
+		break;
+	}
+
+	return str;
+}
+
+/*!
+ * \internal
+ * \brief Convert the mISDN numbering plan code to Asterisk numbering plan code
+ *
+ * \param number_plan mISDN numbering plan code.
+ *
+ * \return Asterisk numbering plan code
+ */
+static int misdn_to_ast_plan(enum mISDN_NUMBER_PLAN number_plan)
+{
+	int ast_number_plan;
+
+	switch (number_plan) {
+	default:
+	case NUMPLAN_UNKNOWN:
+		ast_number_plan = NUMPLAN_UNKNOWN;
+		break;
+
+	case NUMPLAN_ISDN:
+		ast_number_plan = NUMPLAN_ISDN;
+		break;
+
+	case NUMPLAN_DATA:
+		ast_number_plan = NUMPLAN_DATA;
+		break;
+
+	case NUMPLAN_TELEX:
+		ast_number_plan = NUMPLAN_TELEX;
+		break;
+
+	case NUMPLAN_NATIONAL:
+		ast_number_plan = NUMPLAN_NATIONAL;
+		break;
+
+	case NUMPLAN_PRIVATE:
+		ast_number_plan = NUMPLAN_PRIVATE;
+		break;
+	}
+
+	return ast_number_plan;
+}
+
+/*!
+ * \internal
+ * \brief Convert the Asterisk numbering plan code to mISDN numbering plan code
+ *
+ * \param ast_number_plan Asterisk numbering plan code.
+ *
+ * \return mISDN numbering plan code
+ */
+static enum mISDN_NUMBER_PLAN ast_to_misdn_plan(unsigned ast_number_plan)
+{
+	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;
+}
+
+/*!
+ * \internal
+ * \brief Convert the mISDN presentation code to a string
+ *
+ * \param presentation mISDN number presentation restriction code.
+ *
+ * \return The mISDN presentation code as a string
+ */
+static const char *misdn_to_str_pres(int presentation)
+{
+	const char *str;
+
+	switch (presentation) {
+	case 0:
+		str = "Allowed";
+		break;
+
+	case 1:
+		str = "Restricted";
+		break;
+
+	case 2:
+		str = "Unavailable";
+		break;
+
+	default:
+		str = "Unknown";
+		break;
+	}
+
+	return str;
+}
+
+/*!
+ * \internal
+ * \brief Convert the mISDN presentation code to Asterisk presentation code
+ *
+ * \param presentation mISDN number presentation restriction code.
+ *
+ * \return Asterisk presentation code
+ */
+static int misdn_to_ast_pres(int presentation)
+{
+	switch (presentation) {
+	default:
+	case 0:
+		presentation = AST_PRES_ALLOWED;
+		break;
+
+	case 1:
+		presentation = AST_PRES_RESTRICTED;
+		break;
+
+	case 2:
+		presentation = AST_PRES_UNAVAILABLE;
+		break;
+	}
+
+	return presentation;
+}
+
+/*!
+ * \internal
+ * \brief Convert the Asterisk presentation code to mISDN presentation code
+ *
+ * \param presentation Asterisk number presentation restriction code.
+ *
+ * \return mISDN presentation code
+ */
+static int ast_to_misdn_pres(int presentation)
+{
+	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;
+}
+
+/*!
+ * \internal
+ * \brief Convert the mISDN screening code to a string
+ *
+ * \param screening mISDN number screening code.
+ *
+ * \return The mISDN screening code as a string
+ */
+static const char *misdn_to_str_screen(int screening)
+{
+	const char *str;
+
+	switch (screening) {
+	case 0:
+		str = "Unscreened";
+		break;
+
+	case 1:
+		str = "Passed Screen";
+		break;
+
+	case 2:
+		str = "Failed Screen";
+		break;
+
+	case 3:
+		str = "Network Number";
+		break;
+
+	default:
+		str = "Unknown";
+		break;
+	}
+
+	return str;
+}
+
+/*!
+ * \internal
+ * \brief Convert the mISDN screening code to Asterisk screening code
+ *
+ * \param screening mISDN number screening code.
+ *
+ * \return Asterisk screening code
+ */
+static int misdn_to_ast_screen(int screening)
+{
+	switch (screening) {
+	default:
+	case 0:
+		screening = AST_PRES_USER_NUMBER_UNSCREENED;
+		break;
+
+	case 1:
+		screening = AST_PRES_USER_NUMBER_PASSED_SCREEN;
+		break;
+
+	case 2:
+		screening = AST_PRES_USER_NUMBER_FAILED_SCREEN;
+		break;
+
+	case 3:
+		screening = AST_PRES_NETWORK_NUMBER;
+		break;
+	}
+
+	return screening;
+}
+
+/*!
+ * \internal
+ * \brief Convert the Asterisk screening code to mISDN screening code
+ *
+ * \param screening Asterisk number screening code.
+ *
+ * \return mISDN screening code
+ */
+static int ast_to_misdn_screen(int screening)
+{
+	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;
+}
+
+/*!
+ * \internal
+ * \brief Convert Asterisk redirecting reason to mISDN redirecting reason code.
+ *
+ * \param ast Asterisk redirecting reason code.
+ *
+ * \return mISDN reason code
+ */
+static enum mISDN_REDIRECTING_REASON ast_to_misdn_reason(const enum AST_REDIRECTING_REASON 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;
+}
+
+/*!
+ * \internal
+ * \brief Convert the mISDN redirecting reason to Asterisk redirecting reason code
+ *
+ * \param q931 mISDN redirecting reason code.
+ *
+ * \return Asterisk redirecting reason code
+ */
+static enum AST_REDIRECTING_REASON misdn_to_ast_reason(const enum mISDN_REDIRECTING_REASON q931)
+{
+	enum AST_REDIRECTING_REASON ast;
+
+	switch (q931) {
+	default:
+	case mISDN_REDIRECTING_REASON_UNKNOWN:
+		ast = AST_REDIRECTING_REASON_UNKNOWN;
+		break;
+
+	case mISDN_REDIRECTING_REASON_CALL_FWD_BUSY:
+		ast = AST_REDIRECTING_REASON_USER_BUSY;
+		break;
+
+	case mISDN_REDIRECTING_REASON_NO_REPLY:
+		ast = AST_REDIRECTING_REASON_NO_ANSWER;
+		break;
+
+	case mISDN_REDIRECTING_REASON_DEFLECTION:
+		ast = AST_REDIRECTING_REASON_DEFLECTION;
+		break;
+
+	case mISDN_REDIRECTING_REASON_OUT_OF_ORDER:
+		ast = AST_REDIRECTING_REASON_OUT_OF_ORDER;
+		break;
+
+	case mISDN_REDIRECTING_REASON_CALL_FWD_DTE:
+		ast = AST_REDIRECTING_REASON_CALL_FWD_DTE;
+		break;
+
+	case mISDN_REDIRECTING_REASON_CALL_FWD:
+		ast = AST_REDIRECTING_REASON_UNCONDITIONAL;
+		break;
+	}
+
+	return ast;
+}
+
 
 
 struct allowed_bearers {
@@ -590,7 +1106,7 @@ struct allowed_bearers {
 };
 
 /* *INDENT-OFF* */
-static const struct allowed_bearers allowed_bearers_array[]= {
+static const struct allowed_bearers allowed_bearers_array[] = {
 	/* Name,                      Displayable Name       Bearer Capability,                    Deprecated */
 	{ "speech",                  "Speech",               INFO_CAPABILITY_SPEECH,               0 },
 	{ "3_1khz",                  "3.1KHz Audio",         INFO_CAPABILITY_AUDIO_3_1K,           0 },
@@ -609,7 +1125,7 @@ static const char *bearer2str(int cap)
 		if (allowed_bearers_array[index].cap == cap) {
 			return allowed_bearers_array[index].display;
 		}
-	}	/* end for */
+	}
 
 	return "Unknown Bearer";
 }
@@ -682,6 +1198,95 @@ static void print_bearer(struct misdn_bchannel *bc)
 	}
 }
 
+/*!
+ * \internal
+ * \brief Prefix a string to another string in place.
+ *
+ * \param str_prefix String to prefix to the main string.
+ * \param str_main String to get the prefix added to it.
+ * \param size Buffer size of the main string (Includes null terminator).
+ *
+ * \note The str_main buffer size must be greater than one.
+ *
+ * \return Nothing
+ */
+static void misdn_prefix_string(const char *str_prefix, char *str_main, size_t size)
+{
+	size_t len_over;
+	size_t len_total;
+	size_t len_main;
+	size_t len_prefix;
+
+	len_prefix = strlen(str_prefix);
+	if (!len_prefix) {
+		/* There is no prefix to prepend. */
+		return;
+	}
+	len_main = strlen(str_main);
+	len_total = len_prefix + len_main;
+	if (size <= len_total) {
+		/* We need to truncate since the buffer is too small. */
+		len_over = len_total + 1 - size;
+		if (len_over <= len_main) {
+			len_main -= len_over;
+		} else {
+			len_over -= len_main;
+			len_main = 0;
+			len_prefix -= len_over;
+		}
+	}
+	if (len_main) {
+		memmove(str_main + len_prefix, str_main, len_main);
+	}
+	memcpy(str_main, str_prefix, len_prefix);
+	str_main[len_prefix + len_main] = '\0';
+}
+
+/*!
+ * \internal
+ * \brief Add a configured prefix to the given number.
+ *
+ * \param port Logical port number
+ * \param number_type Type-of-number passed in.
+ * \param number Given number string to add prefix
+ * \param size Buffer size number string occupies.
+ *
+ * \return Nothing
+ */
+static void misdn_add_number_prefix(int port, enum mISDN_NUMBER_TYPE number_type, char *number, size_t size)
+{
+	enum misdn_cfg_elements type_prefix;
+	char num_prefix[MISDN_MAX_NUMBER_LEN];
+
+	/* Get prefix string. */
+	switch (number_type) {
+	case NUMTYPE_UNKNOWN:
+		type_prefix = MISDN_CFG_TON_PREFIX_UNKNOWN;
+		break;
+	case NUMTYPE_INTERNATIONAL:
+		type_prefix = MISDN_CFG_TON_PREFIX_INTERNATIONAL;
+		break;
+	case NUMTYPE_NATIONAL:
+		type_prefix = MISDN_CFG_TON_PREFIX_NATIONAL;
+		break;
+	case NUMTYPE_NETWORK_SPECIFIC:
+		type_prefix = MISDN_CFG_TON_PREFIX_NETWORK_SPECIFIC;
+		break;
+	case NUMTYPE_SUBSCRIBER:
+		type_prefix = MISDN_CFG_TON_PREFIX_SUBSCRIBER;
+		break;
+	case NUMTYPE_ABBREVIATED:
+		type_prefix = MISDN_CFG_TON_PREFIX_ABBREVIATED;
+		break;
+	default:
+		/* Type-of-number does not have a prefix that can be added. */
+		return;
+	}
+	misdn_cfg_get(port, type_prefix, num_prefix, sizeof(num_prefix));
+
+	misdn_prefix_string(num_prefix, number, size);
+}
+
 static void export_aoc_vars(int originator, struct ast_channel *ast, struct misdn_bchannel *bc)
 {
 	char buf[128];
@@ -691,7 +1296,8 @@ static void export_aoc_vars(int originator, struct ast_channel *ast, struct misd
 	}
 
 	if (originator == ORG_AST) {
-		if (!(ast = ast_bridged_channel(ast))) {
+		ast = ast_bridged_channel(ast);
+		if (!ast) {
 			return;
 		}
 	}
@@ -745,7 +1351,8 @@ static void export_aoc_vars(int originator, struct ast_channel *ast, struct misd
 /*************** Helpers END *************/
 
 static void sighandler(int sig)
-{}
+{
+}
 
 static void *misdn_tasks_thread_func(void *data)
 {
@@ -840,6 +1447,7 @@ static void misdn_tasks_remove(int task_id)
 static int misdn_l1_task(const void *vdata)
 {
 	const int *data = vdata;
+
 	misdn_lib_isdn_l1watcher(*data);
 	chan_misdn_log(5, *data, "L1watcher timeout\n");
 	return 1;
@@ -866,21 +1474,22 @@ static int misdn_overlap_dial_task(const void *data)
 	tv_end.tv_sec += ch->overlap_dial;
 	tv_now = ast_tvnow();
 
-	if ((diff = ast_tvdiff_ms(tv_end, tv_now)) > 100) {
+	diff = ast_tvdiff_ms(tv_end, tv_now);
+	if (100 < diff) {
 		return diff;
 	}
 
 	/* if we are 100ms near the timeout, we are satisfied.. */
 	stop_indicate(ch);
 
-	if (ast_strlen_zero(ch->bc->dad)) {
+	if (ast_strlen_zero(ch->bc->dialed.number)) {
 		dad = "s";
-		ast_copy_string(ch->ast->exten, "s", sizeof(ch->ast->exten));
+		strcpy(ch->ast->exten, dad);
 	} else {
-		dad = ch->bc->dad;
+		dad = ch->bc->dialed.number;
 	}
 
-	if (ast_exists_extension(ch->ast, ch->context, dad, 1, ch->bc->oad)) {
+	if (ast_exists_extension(ch->ast, ch->context, dad, 1, ch->bc->caller.number)) {
 		ch->state = MISDN_DIALING;
 		if (pbx_start_chan(ch) < 0) {
 			chan_misdn_log(-1, ch->bc->port, "ast_pbx_start returned < 0 in misdn_overlap_dial_task\n");
@@ -957,8 +1566,10 @@ static char *handle_cli_misdn_set_debug(struct ast_cli_entry *e, int cmd, struct
 		level = 1;
 	} else if (!strcasecmp(a->argv[3], "off")) {
 		level = 0;
-	} else {
+	} else if (isdigit(a->argv[3][0])) {
 		level = atoi(a->argv[3]);
+	} else {
+		return CLI_SHOWUSAGE;
 	}
 
 	switch (a->argc) {
@@ -1293,27 +1904,29 @@ struct state_struct {
 };
 
 static struct state_struct state_array[] = {
+/* *INDENT-OFF* */
 	{ MISDN_NOTHING,             "NOTHING" },             /* at beginning */
-	{ MISDN_WAITING4DIGS,        "WAITING4DIGS" },        /*  when waiting for infos */
-	{ MISDN_EXTCANTMATCH,        "EXTCANTMATCH" },        /*  when asterisk couldn't match our ext */
-	{ MISDN_INCOMING_SETUP,      "INCOMING SETUP" },      /*  when pbx_start */
-	{ MISDN_DIALING,             "DIALING" },             /*  when pbx_start */
-	{ MISDN_PROGRESS,            "PROGRESS" },            /*  when pbx_start */
-	{ MISDN_PROCEEDING,          "PROCEEDING" },          /*  when pbx_start */
-	{ MISDN_CALLING,             "CALLING" },             /*  when misdn_call is called */
-	{ MISDN_CALLING_ACKNOWLEDGE, "CALLING_ACKNOWLEDGE" }, /*  when misdn_call is called */
-	{ MISDN_ALERTING,            "ALERTING" },            /*  when Alerting */
-	{ MISDN_BUSY,                "BUSY" },                /*  when BUSY */
-	{ MISDN_CONNECTED,           "CONNECTED" },           /*  when connected */
-	{ MISDN_PRECONNECTED,        "PRECONNECTED" },        /*  when connected */
-	{ MISDN_DISCONNECTED,        "DISCONNECTED" },        /*  when connected */
-	{ MISDN_RELEASED,            "RELEASED" },            /*  when connected */
-	{ MISDN_BRIDGED,             "BRIDGED" },             /*  when bridged */
+	{ MISDN_WAITING4DIGS,        "WAITING4DIGS" },        /* when waiting for infos */
+	{ MISDN_EXTCANTMATCH,        "EXTCANTMATCH" },        /* when asterisk couldn't match our ext */
+	{ MISDN_INCOMING_SETUP,      "INCOMING SETUP" },      /* when pbx_start */
+	{ MISDN_DIALING,             "DIALING" },             /* when pbx_start */
+	{ MISDN_PROGRESS,            "PROGRESS" },            /* when pbx_start */
+	{ MISDN_PROCEEDING,          "PROCEEDING" },          /* when pbx_start */
+	{ MISDN_CALLING,             "CALLING" },             /* when misdn_call is called */
+	{ MISDN_CALLING_ACKNOWLEDGE, "CALLING_ACKNOWLEDGE" }, /* when misdn_call is called */
+	{ MISDN_ALERTING,            "ALERTING" },            /* when Alerting */
+	{ MISDN_BUSY,                "BUSY" },                /* when BUSY */
+	{ MISDN_CONNECTED,           "CONNECTED" },           /* when connected */
+	{ MISDN_PRECONNECTED,        "PRECONNECTED" },        /* when connected */
+	{ MISDN_DISCONNECTED,        "DISCONNECTED" },        /* when connected */
+	{ MISDN_RELEASED,            "RELEASED" },            /* when connected */
+	{ MISDN_BRIDGED,             "BRIDGED" },             /* when bridged */
 	{ MISDN_CLEANING,            "CLEANING" },            /* when hangup from * but we were connected before */
-	{ MISDN_HUNGUP_FROM_MISDN,   "HUNGUP_FROM_MISDN" },   /* when DISCONNECT/RELEASE/REL_COMP  came from misdn */
-	{ MISDN_HOLDED,              "HOLDED" },              /* when DISCONNECT/RELEASE/REL_COMP  came from misdn */
-	{ MISDN_HOLD_DISCONNECT,     "HOLD_DISCONNECT" },     /* when DISCONNECT/RELEASE/REL_COMP  came from misdn */
+	{ MISDN_HUNGUP_FROM_MISDN,   "HUNGUP_FROM_MISDN" },   /* when DISCONNECT/RELEASE/REL_COMP came from misdn */
+	{ MISDN_HOLDED,              "HOLDED" },              /* when DISCONNECT/RELEASE/REL_COMP came from misdn */
+	{ MISDN_HOLD_DISCONNECT,     "HOLD_DISCONNECT" },     /* when DISCONNECT/RELEASE/REL_COMP came from misdn */
 	{ MISDN_HUNGUP_FROM_AST,     "HUNGUP_FROM_AST" },     /* when DISCONNECT/RELEASE/REL_COMP came out of misdn_hangup */
+/* *INDENT-ON* */
 };
 
 static const char *misdn_get_ch_state(struct chan_list *p)
@@ -1384,18 +1997,24 @@ static char *handle_cli_misdn_reload(struct ast_cli_entry *e, int cmd, struct as
 static void print_bc_info (int fd, struct chan_list *help, struct misdn_bchannel *bc)
 {
 	struct ast_channel *ast = help->ast;
-	ast_cli(fd,
-		"* Pid:%d Prt:%d Ch:%d Mode:%s Org:%s dad:%s oad:%s rad:%s ctx:%s state:%s\n",
 
-		bc->pid, bc->port, bc->channel,
+	ast_cli(fd,
+		"* Pid:%d Port:%d Ch:%d Mode:%s Orig:%s dialed:%s\n"
+		"  --> caller:\"%s\" <%s>\n"
+		"  --> redirecting:\"%s\" <%s>\n"
+		"  --> context:%s state:%s\n",
+		bc->pid,
+		bc->port,
+		bc->channel,
 		bc->nt ? "NT" : "TE",
 		help->originator == ORG_AST ? "*" : "I",
-		ast ? ast->exten : NULL,
-		ast ? ast->cid.cid_num : NULL,
-		bc->rad,
-		ast ? ast->context : NULL,
-		misdn_get_ch_state(help)
-		);
+		ast ? ast->exten : "",
+		(ast && ast->cid.cid_name) ? ast->cid.cid_name : "",
+		(ast && ast->cid.cid_num) ? ast->cid.cid_num : "",
+		bc->redirecting.from.name,
+		bc->redirecting.from.number,
+		ast ? ast->context : "",
+		misdn_get_ch_state(help));
 	if (misdn_debug[bc->port] > 0) {
 		ast_cli(fd,
 			"  --> astname: %s\n"
@@ -1418,21 +2037,18 @@ static void print_bc_info (int fd, struct chan_list *help, struct misdn_bchannel
 			help->l3id,
 			help->addr,
 			bc->addr,
-			bc ? bc->l3_id : -1,
+			bc->l3_id,
 			bc->display,
-
 			bc->active,
 			bc_state2str(bc->bc_state),
 			bearer2str(bc->capability),
 #ifdef MISDN_1_2
 			bc->pipeline,
 #else
- 			bc->ec_enable,
+			bc->ec_enable,
 #endif
-
 			help->norxtone, help->notxtone,
-			bc->holded
-			);
+			bc->holded);
 	}
 }
 
@@ -1480,15 +2096,17 @@ static char *handle_cli_misdn_show_channels(struct ast_cli_entry *e, int cmd, st
 			if (help->state == MISDN_HOLDED) {
 				ast_cli(a->fd, "ITS A HOLDED BC:\n");
 				ast_cli(a->fd, " --> l3_id: %x\n"
-						" --> dad:%s oad:%s\n"
-						" --> hold_port: %d\n"
-						" --> hold_channel: %d\n",
-						help->l3id,
-						ast->exten,
-						ast->cid.cid_num,
-						help->hold_info.port,
-						help->hold_info.channel
-						);
+					" --> dialed:%s\n"
+					" --> caller:\"%s\" <%s>\n"
+					" --> hold_port: %d\n"
+					" --> hold_channel: %d\n",
+					help->l3id,
+					ast->exten,
+					ast->cid.cid_name ? ast->cid.cid_name : "",
+					ast->cid.cid_num ? ast->cid.cid_num : "",
+					help->hold_info.port,
+					help->hold_info.channel
+					);
 			} else {
 				ast_cli(a->fd, "* Channel in unknown STATE !!! Exten:%s, Callerid:%s\n", ast->exten, ast->cid.cid_num);
 			}
@@ -1693,7 +2311,7 @@ static char *handle_cli_misdn_send_facility(struct ast_cli_entry *e, int cmd, st
 			return 0;
 		}
 		tmp->bc->fac_out.Function = Fac_CD;
-		ast_copy_string((char *)tmp->bc->fac_out.u.CDeflection.DeflectedToNumber, nr, sizeof(tmp->bc->fac_out.u.CDeflection.DeflectedToNumber));
+		ast_copy_string((char *) tmp->bc->fac_out.u.CDeflection.DeflectedToNumber, nr, sizeof(tmp->bc->fac_out.u.CDeflection.DeflectedToNumber));
 		misdn_lib_send_event(tmp->bc, EVENT_FACILITY);
 	} else if (strstr(a->argv[3], "CFActivate")) {
 		if (a->argc < 7) {
@@ -1718,7 +2336,7 @@ static char *handle_cli_misdn_send_facility(struct ast_cli_entry *e, int cmd, st
 	} else if (strstr(a->argv[3], "CFDeactivate")) {
 
 		if (a->argc < 6) {
-			ast_verbose("CFActivate requires 1 arg: FromNumber\n\n");
+			ast_verbose("CFDeactivate requires 1 arg: FromNumber\n\n");
 			return 0;
 		}
 		port = atoi(a->argv[4]);
@@ -1728,10 +2346,10 @@ static char *handle_cli_misdn_send_facility(struct ast_cli_entry *e, int cmd, st
 		ast_verbose("Sending CFDeactivate  Port:(%d) FromNr. (%s)\n", port, served_nr);
 
 		bc->fac_out.Function = Fac_CFDeactivate;
-		bc->fac_out.u.CFDeactivate.BasicService = 0; //All Services
-		bc->fac_out.u.CFDeactivate.Procedure = 0; //Unconditional
+		bc->fac_out.u.CFDeactivate.BasicService = 0; /* All Services */
+		bc->fac_out.u.CFDeactivate.Procedure = 0; /* Unconditional */
+		ast_copy_string((char *) bc->fac_out.u.CFActivate.ServedUserNumber, served_nr, sizeof(bc->fac_out.u.CFActivate.ServedUserNumber));
 
-		ast_copy_string((char *)bc->fac_out.u.CFActivate.ServedUserNumber, served_nr, sizeof(bc->fac_out.u.CFActivate.ServedUserNumber));
 		misdn_lib_send_event(bc, EVENT_FACILITY);
 	}
 
@@ -2009,23 +2627,25 @@ static struct ast_cli_entry chan_misdn_clis[] = {
 };
 
 /*! \brief Updates caller ID information from config */
-static int update_config(struct chan_list *ch, int orig)
+static void update_config(struct chan_list *ch)
 {
 	struct ast_channel *ast;
 	struct misdn_bchannel *bc;
-	int port, hdlc = 0;
-	int pres, screen;
+	int port;
+	int hdlc = 0;
+	int pres;
+	int screen;
 
 	if (!ch) {
 		ast_log(LOG_WARNING, "Cannot configure without chanlist\n");
-		return -1;
+		return;
 	}
 
 	ast = ch->ast;
 	bc = ch->bc;
 	if (! ast || ! bc) {
 		ast_log(LOG_WARNING, "Cannot configure without ast || bc\n");
-		return -1;
+		return;
 	}
 
 	port = bc->port;
@@ -2033,7 +2653,6 @@ static int update_config(struct chan_list *ch, int orig)
 	chan_misdn_log(7, port, "update_config: Getting Config\n");
 
 	misdn_cfg_get(port, MISDN_CFG_HDLC, &hdlc, sizeof(int));
-
 	if (hdlc) {
 		switch (bc->capability) {
 		case INFO_CAPABILITY_DIGITAL_UNRESTRICTED:
@@ -2050,48 +2669,17 @@ static int update_config(struct chan_list *ch, int orig)
 	chan_misdn_log(2, port, " --> pres: %d screen: %d\n", pres, screen);
 
 	if (pres < 0 || screen < 0) {
-		chan_misdn_log(2, port, " --> pres: %x\n", ast->cid.cid_pres);
+		chan_misdn_log(2, port, " --> pres: %x\n", ast->connected.id.number_presentation);
 
-		switch (ast->cid.cid_pres & 0x60) {
-		case AST_PRES_RESTRICTED:
-			bc->pres = 1;
-			chan_misdn_log(2, port, " --> PRES: Restricted (1)\n");
-			break;
-		case AST_PRES_UNAVAILABLE:
-			bc->pres = 2;
-			chan_misdn_log(2, port, " --> PRES: Unavailable (2)\n");
-			break;
-		default:
-			bc->pres = 0;
-			chan_misdn_log(2, port, " --> PRES: Allowed (0)\n");
-			break;
-		}
+		bc->caller.presentation = ast_to_misdn_pres(ast->connected.id.number_presentation);
+		chan_misdn_log(2, port, " --> PRES: %s(%d)\n", misdn_to_str_pres(bc->caller.presentation), bc->caller.presentation);
 
-		switch (ast->cid.cid_pres & 0x3) {
-		default:
-		case AST_PRES_USER_NUMBER_UNSCREENED:
-			bc->screen = 0;
-			chan_misdn_log(2, port, " --> SCREEN: Unscreened (0)\n");
-			break;
-		case AST_PRES_USER_NUMBER_PASSED_SCREEN:
-			bc->screen = 1;
-			chan_misdn_log(2, port, " --> SCREEN: Passed Screen (1)\n");
-			break;
-		case AST_PRES_USER_NUMBER_FAILED_SCREEN:
-			bc->screen = 2;
-			chan_misdn_log(2, port, " --> SCREEN: Failed Screen (2)\n");
-			break;
-		case AST_PRES_NETWORK_NUMBER:
-			bc->screen = 3;
-			chan_misdn_log(2, port, " --> SCREEN: Network Nr. (3)\n");
-			break;
-		}
+		bc->caller.screening = ast_to_misdn_screen(ast->connected.id.number_presentation);
+		chan_misdn_log(2, port, " --> SCREEN: %s(%d)\n", misdn_to_str_screen(bc->caller.screening), bc->caller.screening);
 	} else {
-		bc->screen = screen;
-		bc->pres = pres;
+		bc->caller.screening = screen;
+		bc->caller.presentation = pres;
 	}
-
-	return 0;
 }
 
 
@@ -2130,20 +2718,26 @@ static void config_jitterbuffer(struct chan_list *ch)
 }
 
 
-void debug_numplan(int port, int numplan, char *type)
+void debug_numtype(int port, int numtype, char *type)
 {
-	switch (numplan) {
-	case NUMPLAN_INTERNATIONAL:
+	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 NUMPLAN_NATIONAL:
+	case NUMTYPE_NATIONAL:
 		chan_misdn_log(2, port, " --> %s: National\n", type);
 		break;
-	case NUMPLAN_SUBSCRIBER:
+	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 NUMPLAN_UNKNOWN:
-		chan_misdn_log(2, port, " --> %s: Unknown\n", type);
+	case NUMTYPE_ABBREVIATED:
+		chan_misdn_log(2, port, " --> %s: Abbreviated\n", type);
 		break;
 		/* Maybe we should cut off the prefix if present ? */
 	default:
@@ -2193,7 +2787,7 @@ static int update_ec_config(struct misdn_bchannel *bc)
 #endif
 
 
-static int read_config(struct chan_list *ch, int orig)
+static int read_config(struct chan_list *ch)
 {
 	struct ast_channel *ast;
 	struct misdn_bchannel *bc;
@@ -2234,7 +2828,6 @@ static int read_config(struct chan_list *ch, int orig)
 	misdn_cfg_get(port, MISDN_CFG_SENDDTMF, &bc->send_dtmf, sizeof(bc->send_dtmf));
 
 	misdn_cfg_get(port, MISDN_CFG_ASTDTMF, &ch->ast_dsp, sizeof(int));
-
 	if (ch->ast_dsp) {
 		ch->ignore_dtmf = 1;
 	}
@@ -2251,7 +2844,6 @@ static int read_config(struct chan_list *ch, int orig)
   	misdn_cfg_get(port, MISDN_CFG_FAXDETECT, faxdetect, sizeof(faxdetect));
 
 	misdn_cfg_get(port, MISDN_CFG_HDLC, &hdlc, sizeof(hdlc));
-
 	if (hdlc) {
 		switch (bc->capability) {
 		case INFO_CAPABILITY_DIGITAL_UNRESTRICTED:
@@ -2280,14 +2872,16 @@ static int read_config(struct chan_list *ch, int orig)
 
 	misdn_cfg_get(bc->port, MISDN_CFG_EARLY_BCONNECT, &bc->early_bconnect, sizeof(bc->early_bconnect));
 
+	misdn_cfg_get(port, MISDN_CFG_DISPLAY_CONNECTED, &bc->display_connected, sizeof(bc->display_connected));
+	misdn_cfg_get(port, MISDN_CFG_DISPLAY_SETUP, &bc->display_setup, sizeof(bc->display_setup));
+
 	misdn_cfg_get(port, MISDN_CFG_PICKUPGROUP, &pg, sizeof(pg));
 	misdn_cfg_get(port, MISDN_CFG_CALLGROUP, &cg, sizeof(cg));
-
 	chan_misdn_log(5, port, " --> * CallGrp:%s PickupGrp:%s\n", ast_print_group(buf, sizeof(buf), cg), ast_print_group(buf2, sizeof(buf2), pg));
 	ast->pickupgroup = pg;
 	ast->callgroup = cg;
 
-	if (orig == ORG_AST) {
+	if (ch->originator == ORG_AST) {
 		char callerid[BUFFERSIZE + 1];
 
 		/* ORIGINATOR Asterisk (outgoing call) */
@@ -2300,80 +2894,46 @@ static int read_config(struct chan_list *ch, int orig)
 
 		misdn_cfg_get(port, MISDN_CFG_CALLERID, callerid, sizeof(callerid));
 		if (!ast_strlen_zero(callerid)) {
-			chan_misdn_log(1, port, " --> * Setting Cid to %s\n", callerid);
-			ast_copy_string(bc->oad, callerid, sizeof(bc->oad));
+			char *cid_name = NULL;
+			char *cid_num = NULL;
+
+			ast_callerid_parse(callerid, &cid_name, &cid_num);
+			if (cid_name) {
+				ast_copy_string(bc->caller.name, cid_name, sizeof(bc->caller.name));
+			} else {
+				bc->caller.name[0] = '\0';
+			}
+			if (cid_num) {
+				ast_copy_string(bc->caller.number, cid_num, sizeof(bc->caller.number));
+			} else {
+				bc->caller.number[0] = '\0';
+			}
+			chan_misdn_log(1, port, " --> * Setting caller to \"%s\" <%s>\n", bc->caller.name, bc->caller.number);
 		}
 
-		misdn_cfg_get(port, MISDN_CFG_DIALPLAN, &bc->dnumplan, sizeof(bc->dnumplan));
-		misdn_cfg_get(port, MISDN_CFG_LOCALDIALPLAN, &bc->onumplan, sizeof(bc->onumplan));
-		misdn_cfg_get(port, MISDN_CFG_CPNDIALPLAN, &bc->cpnnumplan, sizeof(bc->cpnnumplan));
-		debug_numplan(port, bc->dnumplan, "TON");
-		debug_numplan(port, bc->onumplan, "LTON");
-		debug_numplan(port, bc->cpnnumplan, "CTON");
+		misdn_cfg_get(port, MISDN_CFG_DIALPLAN, &bc->dialed.number_type, sizeof(bc->dialed.number_type));
+		bc->dialed.number_plan = NUMPLAN_ISDN;
+		debug_numtype(port, bc->dialed.number_type, "TON");
 
 		ch->overlap_dial = 0;
 	} else {
 		/* ORIGINATOR MISDN (incoming call) */
-		char prefix[BUFFERSIZE + 1] = "";
 
  		if (strstr(faxdetect, "incoming") || strstr(faxdetect, "both")) {
  			ch->faxdetect = (strstr(faxdetect, "nojump")) ? 2 : 1;
  		}
 
-		misdn_cfg_get(port, MISDN_CFG_CPNDIALPLAN, &bc->cpnnumplan, sizeof(bc->cpnnumplan));
-		debug_numplan(port, bc->cpnnumplan, "CTON");
-
-		switch (bc->onumplan) {
-		case NUMPLAN_INTERNATIONAL:
-			misdn_cfg_get(bc->port, MISDN_CFG_INTERNATPREFIX, prefix, sizeof(prefix));
-			break;
+		/* Add configured prefix to caller.number */
+		misdn_add_number_prefix(bc->port, bc->caller.number_type, bc->caller.number, sizeof(bc->caller.number));
 
-		case NUMPLAN_NATIONAL:
-			misdn_cfg_get(bc->port, MISDN_CFG_NATPREFIX, prefix, sizeof(prefix));
-			break;
-		default:
-			break;
-		}
-
-		ast_copy_string(buf, bc->oad, sizeof(buf));
-		snprintf(bc->oad, sizeof(bc->oad), "%s%s", prefix, buf);
-
-		if (!ast_strlen_zero(bc->dad)) {
-			ast_copy_string(bc->orig_dad, bc->dad, sizeof(bc->orig_dad));
+		if (ast_strlen_zero(bc->dialed.number) && !ast_strlen_zero(bc->keypad)) {
+			ast_copy_string(bc->dialed.number, bc->keypad, sizeof(bc->dialed.number));
 		}
 
-		if (ast_strlen_zero(bc->dad) && !ast_strlen_zero(bc->keypad)) {
-			ast_copy_string(bc->dad, bc->keypad, sizeof(bc->dad));
-		}
+		/* Add configured prefix to dialed.number */
+		misdn_add_number_prefix(bc->port, bc->dialed.number_type, bc->dialed.number, sizeof(bc->dialed.number));
 
-		prefix[0] = 0;
-
-		switch (bc->dnumplan) {
-		case NUMPLAN_INTERNATIONAL:
-			misdn_cfg_get(bc->port, MISDN_CFG_INTERNATPREFIX, prefix, sizeof(prefix));
-			break;
-		case NUMPLAN_NATIONAL:
-			misdn_cfg_get(bc->port, MISDN_CFG_NATPREFIX, prefix, sizeof(prefix));
-			break;
-		default:
-			break;
-		}
-
-		ast_copy_string(buf, bc->dad, sizeof(buf));
-		snprintf(bc->dad, sizeof(bc->dad), "%s%s", prefix, buf);
-
-		if (strcmp(bc->dad, ast->exten)) {
-			ast_copy_string(ast->exten, bc->dad, sizeof(ast->exten));
-		}
-
-		ast_set_callerid(ast, bc->oad, NULL, bc->oad);
-
-		if ( !ast_strlen_zero(bc->rad) ) {
-			if (ast->cid.cid_rdnis) {
-				ast_free(ast->cid.cid_rdnis);
-			}
-			ast->cid.cid_rdnis = ast_strdup(bc->rad);
-		}
+		ast_copy_string(ast->exten, bc->dialed.number, sizeof(ast->exten));
 
 		misdn_cfg_get(bc->port, MISDN_CFG_OVERLAP_DIAL, &ch->overlap_dial, sizeof(ch->overlap_dial));
 		ast_mutex_init(&ch->overlap_tv_lock);
@@ -2400,6 +2960,79 @@ static int read_config(struct chan_list *ch, int orig)
 	return 0;
 }
 
+/*!
+ * \internal
+ * \brief Notify peer that the connected line has changed.
+ *
+ * \param ast Current Asterisk channel
+ * \param bc Associated B channel
+ * \param originator Who originally created this channel. ORG_AST or ORG_MISDN
+ *
+ * \return Nothing
+ */
+static void misdn_update_connected_line(struct ast_channel *ast, struct misdn_bchannel *bc, int originator)
+{
+	int number_type;
+
+	if (originator == ORG_MISDN) {
+		/* ORIGINATOR MISDN (incoming call) */
+
+		ast_copy_string(bc->connected.name, S_OR(ast->connected.id.name, ""), sizeof(bc->connected.name));
+		ast_copy_string(bc->connected.number, S_OR(ast->connected.id.number, ""), sizeof(bc->connected.number));
+		bc->connected.presentation = ast_to_misdn_pres(ast->connected.id.number_presentation);
+		bc->connected.screening = ast_to_misdn_screen(ast->connected.id.number_presentation);
+
+		misdn_cfg_get(bc->port, MISDN_CFG_CPNDIALPLAN, &number_type, sizeof(number_type));
+		if (number_type < 0) {
+			bc->connected.number_type = ast_to_misdn_ton(ast->connected.id.number_type);
+			bc->connected.number_plan = ast_to_misdn_plan(ast->connected.id.number_type);
+		} else {
+			/* Force us to send in CONNECT message */
+			bc->connected.number_type = number_type;
+			bc->connected.number_plan = NUMPLAN_ISDN;
+		}
+		debug_numtype(bc->port, bc->connected.number_type, "CTON");
+	} else {
+		/* ORIGINATOR Asterisk (outgoing call) */
+
+		ast_copy_string(bc->caller.name, S_OR(ast->connected.id.name, ""), sizeof(bc->caller.name));
+		ast_copy_string(bc->caller.number, S_OR(ast->connected.id.number, ""), sizeof(bc->caller.number));
+		bc->caller.presentation = ast_to_misdn_pres(ast->connected.id.number_presentation);
+		bc->caller.screening = ast_to_misdn_screen(ast->connected.id.number_presentation);
+
+		misdn_cfg_get(bc->port, MISDN_CFG_LOCALDIALPLAN, &number_type, sizeof(number_type));
+		if (number_type < 0) {
+			bc->caller.number_type = ast_to_misdn_ton(ast->connected.id.number_type);
+			bc->caller.number_plan = ast_to_misdn_plan(ast->connected.id.number_type);
+		} else {
+			/* Force us to send in SETUP message */
+			bc->caller.number_type = number_type;
+			bc->caller.number_plan = NUMPLAN_ISDN;
+		}
+		debug_numtype(bc->port, bc->caller.number_type, "LTON");
+	}
+}
+
+/*!
+ * \internal
+ * \brief Copy the redirecting info out of the Asterisk channel
+ *
+ * \param bc Associated B channel
+ * \param ast Current Asterisk channel
+ *
+ * \return Nothing
+ */
+static void misdn_copy_redirecting_from_ast(struct misdn_bchannel *bc, struct ast_channel *ast)
+{
+	ast_copy_string(bc->redirecting.from.name, S_OR(ast->redirecting.from.name, ""), sizeof(bc->redirecting.from.name));
+	ast_copy_string(bc->redirecting.from.number, S_OR(ast->cid.cid_rdnis, ""), sizeof(bc->redirecting.from.number));
+	bc->redirecting.from.presentation = ast_to_misdn_pres(ast->redirecting.from.number_presentation);
+	bc->redirecting.from.screening = ast_to_misdn_screen(ast->redirecting.from.number_presentation);
+	bc->redirecting.from.number_type = ast_to_misdn_ton(ast->redirecting.from.number_type);
+	bc->redirecting.from.number_plan = ast_to_misdn_plan(ast->redirecting.from.number_type);
+	bc->redirecting.reason = ast_to_misdn_reason(ast->redirecting.reason);
+}
+
 
 /*****************************/
 /*** AST Indications Start ***/
@@ -2411,22 +3044,17 @@ static int misdn_call(struct ast_channel *ast, char *dest, int timeout)
 	int r;
 	int exceed;
 	int bridging;
-	struct chan_list *ch = MISDN_ASTERISK_TECH_PVT(ast);
+	int number_type;
+	struct chan_list *ch;
 	struct misdn_bchannel *newbc;
-	char *dest_cp = ast_strdupa(dest);
+	char *dest_cp;
+
 	AST_DECLARE_APP_ARGS(args,
-		AST_APP_ARG(type);
-		AST_APP_ARG(ext);
-		AST_APP_ARG(opts);
+		AST_APP_ARG(intf);	/* The interface token is discarded. */
+		AST_APP_ARG(ext);	/* extension token */
+		AST_APP_ARG(opts);	/* options token */
 	);
 
-	AST_NONSTANDARD_APP_ARGS(args, dest_cp, '/');
-
-	if (ast_strlen_zero(args.ext)) {
-		chan_misdn_log(0, 0, "misdn_call: No Extension given!\n");
-		return -1;
-	}
-
 	if (!ast) {
 		ast_log(LOG_WARNING, " --> ! misdn_call called on ast_channel *ast where ast == NULL\n");
 		return -1;
@@ -2439,47 +3067,74 @@ static int misdn_call(struct ast_channel *ast, char *dest, int timeout)
 		return -1;
 	}
 
+	ch = MISDN_ASTERISK_TECH_PVT(ast);
 	if (!ch) {
-		ast_log(LOG_WARNING, " --> ! misdn_call called on %s, neither down nor reserved (or dest==NULL)\n", ast->name);
+		ast_log(LOG_WARNING, " --> ! misdn_call called on %s, chan_list *ch==NULL\n", ast->name);
 		ast->hangupcause = AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
 		ast_setstate(ast, AST_STATE_DOWN);
 		return -1;
 	}
 
 	newbc = ch->bc;
-
 	if (!newbc) {
-		ast_log(LOG_WARNING, " --> ! misdn_call called on %s, neither down nor reserved (or dest==NULL)\n", ast->name);
+		ast_log(LOG_WARNING, " --> ! misdn_call called on %s, newbc==NULL\n", ast->name);
 		ast->hangupcause = AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
 		ast_setstate(ast, AST_STATE_DOWN);
 		return -1;
 	}
 
+	/*
+	 * dest is ---v
+	 * Dial(mISDN/g:group_name[/extension[/options]])
+	 * Dial(mISDN/port[:preselected_channel][/extension[/options]])
+	 *
+	 * The dial extension could be empty if you are using MISDN_KEYPAD
+	 * to control ISDN provider features.
+	 */
+	dest_cp = ast_strdupa(dest);
+	AST_NONSTANDARD_APP_ARGS(args, dest_cp, '/');
+	if (!args.ext) {
+		args.ext = "";
+	}
+
 	port = newbc->port;
 
-	if ((exceed = add_out_calls(port))) {
+	exceed = add_out_calls(port);
+	if (exceed != 0) {
 		char tmp[16];
 		snprintf(tmp, sizeof(tmp), "%d", exceed);
 		pbx_builtin_setvar_helper(ast, "MAX_OVERFLOW", tmp);
+		ast->hangupcause = AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
+		ast_setstate(ast, AST_STATE_DOWN);
 		return -1;
 	}
 
 	chan_misdn_log(1, port, "* CALL: %s\n", dest);
 
-	chan_misdn_log(2, port, " --> * dad:%s tech:%s ctx:%s\n", ast->exten, ast->name, ast->context);
+	chan_misdn_log(2, port, " --> * dialed:%s tech:%s context:%s\n", args.ext, ast->name, ast->context);
 
-	chan_misdn_log(3, port, " --> * adding2newbc ext %s\n", ast->exten);
-	if (ast->exten) {
-		ast_copy_string(ast->exten, args.ext, sizeof(ast->exten));
-		ast_copy_string(newbc->dad, args.ext, sizeof(newbc->dad));
-	}
+	ast_copy_string(ast->exten, args.ext, sizeof(ast->exten));
+	ast_copy_string(newbc->dialed.number, args.ext, sizeof(newbc->dialed.number));
 
-	ast_copy_string(newbc->rad, S_OR(ast->cid.cid_rdnis, ""), sizeof(newbc->rad));
+	if (ast_strlen_zero(newbc->caller.name)	&& !ast_strlen_zero(ast->connected.id.name)) {
+		ast_copy_string(newbc->caller.name, ast->connected.id.name, sizeof(newbc->caller.name));
+		chan_misdn_log(3, port, " --> * set caller:\"%s\" <%s>\n", newbc->caller.name, newbc->caller.number);
+	}
+	if (ast_strlen_zero(newbc->caller.number) && !ast_strlen_zero(ast->connected.id.number)) {
+		ast_copy_string(newbc->caller.number, ast->connected.id.number, sizeof(newbc->caller.number));
+		chan_misdn_log(3, port, " --> * set caller:\"%s\" <%s>\n", newbc->caller.name, newbc->caller.number);
+	}
 
-	chan_misdn_log(3, port, " --> * adding2newbc callerid %s\n", ast->cid.cid_num);
-	if (ast_strlen_zero(newbc->oad) && !ast_strlen_zero(ast->cid.cid_num)) {
-		ast_copy_string(newbc->oad, ast->cid.cid_num, sizeof(newbc->oad));
+	misdn_cfg_get(port, MISDN_CFG_LOCALDIALPLAN, &number_type, sizeof(number_type));
+	if (number_type < 0) {
+		newbc->caller.number_type = ast_to_misdn_ton(ast->connected.id.number_type);
+		newbc->caller.number_plan = ast_to_misdn_plan(ast->connected.id.number_type);
+	} else {
+		/* Force us to send in SETUP message */
+		newbc->caller.number_type = number_type;
+		newbc->caller.number_plan = NUMPLAN_ISDN;
 	}
+	debug_numtype(port, newbc->caller.number_type, "LTON");
 
 	newbc->capability = ast->transfercapability;
 	pbx_builtin_setvar_helper(ast, "TRANSFERCAPABILITY", ast_transfercapability2str(newbc->capability));
@@ -2487,10 +3142,10 @@ static int misdn_call(struct ast_channel *ast, char *dest, int timeout)
 		chan_misdn_log(2, port, " --> * Call with flag Digital\n");
 	}
 
-	/* update screening and presentation */
-	update_config(ch, ORG_AST);
+	/* update caller screening and presentation */
+	update_config(ch);
 
-	/* fill in some ies from channel vary */
+	/* fill in some ies from channel dialplan variables */
 	import_ch(ast, newbc, ch);
 
 	/* Finally The Options Override Everything */
@@ -2499,6 +3154,11 @@ static int misdn_call(struct ast_channel *ast, char *dest, int timeout)
 	} else {
 		chan_misdn_log(2, port, "NO OPTS GIVEN\n");
 	}
+	if (newbc->set_presentation) {
+		newbc->caller.presentation = newbc->presentation;
+	}
+
+	misdn_copy_redirecting_from_ast(newbc, ast);
 
 	/*check for bridging*/
 	misdn_cfg_get(0, MISDN_GEN_BRIDGING, &bridging, sizeof(bridging));
@@ -2519,7 +3179,7 @@ static int misdn_call(struct ast_channel *ast, char *dest, int timeout)
 	/** we should have l3id after sending setup **/
 	ch->l3id = newbc->l3_id;
 
-	if (r == -ENOCHAN ) {
+	if (r == -ENOCHAN) {
 		chan_misdn_log(0, port, " --> * Theres no Channel at the moment .. !\n");
 		chan_misdn_log(1, port, " --> * SEND: State Down pid:%d\n", newbc ? newbc->pid : -1);
 		ast->hangupcause = AST_CAUSE_NORMAL_CIRCUIT_CONGESTION;
@@ -2585,9 +3245,19 @@ static int misdn_answer(struct ast_channel *ast)
 	p->state = MISDN_CONNECTED;
 	stop_indicate(p);
 
-	if ( ast_strlen_zero(p->bc->cad) ) {
-		chan_misdn_log(2, p->bc->port, " --> empty cad using dad\n");
-		ast_copy_string(p->bc->cad, p->bc->dad, sizeof(p->bc->cad));
+	if (ast_strlen_zero(p->bc->connected.number)) {
+		chan_misdn_log(2,p->bc->port," --> empty connected number using dialed number\n");
+		ast_copy_string(p->bc->connected.number, p->bc->dialed.number, sizeof(p->bc->connected.number));
+
+		/*
+		 * Use the misdn_set_opt() application to set the presentation
+		 * before we answer or you can use the CONECTEDLINE() function
+		 * to set everything before using the Answer() application.
+		 */
+		p->bc->connected.presentation = p->bc->presentation;
+		p->bc->connected.screening = 0;	/* unscreened */
+		p->bc->connected.number_type = p->bc->dialed.number_type;
+		p->bc->connected.number_plan = p->bc->dialed.number_plan;
 	}
 
 	misdn_lib_send_event(p->bc, EVENT_CONNECT);
@@ -2628,15 +3298,15 @@ static int misdn_digit_end(struct ast_channel *ast, char digit, unsigned int dur
 		break;
 	case MISDN_CALLING_ACKNOWLEDGE:
 		ast_copy_string(bc->info_dad, buf, sizeof(bc->info_dad));
-		if (strlen(bc->dad) < sizeof(bc->dad) - 1) {
-			strncat(bc->dad, buf, sizeof(bc->dad) - strlen(bc->dad) - 1);
+		if (strlen(bc->dialed.number) < sizeof(bc->dialed.number) - 1) {
+			strncat(bc->dialed.number, buf, sizeof(bc->dialed.number) - strlen(bc->dialed.number) - 1);
 		}
-		ast_copy_string(p->ast->exten, bc->dad, sizeof(p->ast->exten));
+		ast_copy_string(p->ast->exten, bc->dialed.number, sizeof(p->ast->exten));
 		misdn_lib_send_event(bc, EVENT_INFORMATION);
 		break;
 	default:
 		/* Do not send Digits in CONNECTED State, when
-		 * the other side is too mISDN. */
+		 * the other side is also mISDN. */
 		if (p->other_ch) {
 			return 0;
 		}
@@ -2687,7 +3357,7 @@ static int misdn_indication(struct ast_channel *ast, int cond, const void *data,
 
 	switch (cond) {
 	case AST_CONTROL_BUSY:
-		chan_misdn_log(1, p->bc->port, "* IND :\tbusy pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, "* IND :\tbusy pid:%d\n", p->bc->pid);
 		ast_setstate(ast, AST_STATE_BUSY);
 
 		p->bc->out_cause = AST_CAUSE_USER_BUSY;
@@ -2699,20 +3369,20 @@ static int misdn_indication(struct ast_channel *ast, int cond, const void *data,
 		}
 		return -1;
 	case AST_CONTROL_RING:
-		chan_misdn_log(1, p->bc->port, "* IND :\tring pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, "* IND :\tring pid:%d\n", p->bc->pid);
 		return -1;
 	case AST_CONTROL_RINGING:
-		chan_misdn_log(1, p->bc->port, "* IND :\tringing pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, "* IND :\tringing pid:%d\n", p->bc->pid);
 		switch (p->state) {
 		case MISDN_ALERTING:
-			chan_misdn_log(2, p->bc->port, " --> * IND :\tringing pid:%d but I was Ringing before, so ignoring it\n", p->bc ? p->bc->pid : -1);
+			chan_misdn_log(2, p->bc->port, " --> * IND :\tringing pid:%d but I was Ringing before, so ignoring it\n", p->bc->pid);
 			break;
 		case MISDN_CONNECTED:
-			chan_misdn_log(2, p->bc->port, " --> * IND :\tringing pid:%d but Connected, so just send TONE_ALERTING without state changes \n", p->bc ? p->bc->pid : -1);
+			chan_misdn_log(2, p->bc->port, " --> * IND :\tringing pid:%d but Connected, so just send TONE_ALERTING without state changes \n", p->bc->pid);
 			return -1;
 		default:
 			p->state = MISDN_ALERTING;
-			chan_misdn_log(2, p->bc->port, " --> * IND :\tringing pid:%d\n", p->bc ? p->bc->pid : -1);
+			chan_misdn_log(2, p->bc->port, " --> * IND :\tringing pid:%d\n", p->bc->pid);
 			misdn_lib_send_event( p->bc, EVENT_ALERTING);
 
 			if (p->other_ch && p->other_ch->bc) {
@@ -2727,7 +3397,7 @@ static int misdn_indication(struct ast_channel *ast, int cond, const void *data,
 				}
 			}
 
-			chan_misdn_log(3, p->bc->port, " --> * SEND: State Ring pid:%d\n", p->bc ? p->bc->pid : -1);
+			chan_misdn_log(3, p->bc->port, " --> * SEND: State Ring pid:%d\n", p->bc->pid);
 			ast_setstate(ast, AST_STATE_RING);
 
 			if (!p->bc->nt && (p->originator == ORG_MISDN) && !p->incoming_early_audio) {
@@ -2738,28 +3408,28 @@ static int misdn_indication(struct ast_channel *ast, int cond, const void *data,
 		}
 		break;
 	case AST_CONTROL_ANSWER:
-		chan_misdn_log(1, p->bc->port, " --> * IND :\tanswer pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, " --> * IND :\tanswer pid:%d\n", p->bc->pid);
 		start_bc_tones(p);
 		break;
 	case AST_CONTROL_TAKEOFFHOOK:
-		chan_misdn_log(1, p->bc->port, " --> *\ttakeoffhook pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, " --> *\ttakeoffhook pid:%d\n", p->bc->pid);
 		return -1;
 	case AST_CONTROL_OFFHOOK:
-		chan_misdn_log(1, p->bc->port, " --> *\toffhook pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, " --> *\toffhook pid:%d\n", p->bc->pid);
 		return -1;
 	case AST_CONTROL_FLASH:
-		chan_misdn_log(1, p->bc->port, " --> *\tflash pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, " --> *\tflash pid:%d\n", p->bc->pid);
 		break;
 	case AST_CONTROL_PROGRESS:
-		chan_misdn_log(1, p->bc->port, " --> * IND :\tprogress pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, " --> * IND :\tprogress pid:%d\n", p->bc->pid);
 		misdn_lib_send_event( p->bc, EVENT_PROGRESS);
 		break;
 	case AST_CONTROL_PROCEEDING:
-		chan_misdn_log(1, p->bc->port, " --> * IND :\tproceeding pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, " --> * IND :\tproceeding pid:%d\n", p->bc->pid);
 		misdn_lib_send_event( p->bc, EVENT_PROCEEDING);
 		break;
 	case AST_CONTROL_CONGESTION:
-		chan_misdn_log(1, p->bc->port, " --> * IND :\tcongestion pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, " --> * IND :\tcongestion pid:%d\n", p->bc->pid);
 
 		p->bc->out_cause = AST_CAUSE_SWITCH_CONGESTION;
 		start_bc_tones(p);
@@ -2770,7 +3440,7 @@ static int misdn_indication(struct ast_channel *ast, int cond, const void *data,
 		}
 		break;
 	case -1 :
-		chan_misdn_log(1, p->bc->port, " --> * IND :\t-1! (stop indication) pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, " --> * IND :\t-1! (stop indication) pid:%d\n", p->bc->pid);
 
 		stop_indicate(p);
 
@@ -2780,14 +3450,23 @@ static int misdn_indication(struct ast_channel *ast, int cond, const void *data,
 		break;
 	case AST_CONTROL_HOLD:
 		ast_moh_start(ast, data, p->mohinterpret);
-		chan_misdn_log(1, p->bc->port, " --> *\tHOLD pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, " --> *\tHOLD pid:%d\n", p->bc->pid);
 		break;
 	case AST_CONTROL_UNHOLD:
 		ast_moh_stop(ast);
-		chan_misdn_log(1, p->bc->port, " --> *\tUNHOLD pid:%d\n", p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, " --> *\tUNHOLD pid:%d\n", p->bc->pid);
+		break;
+	case AST_CONTROL_CONNECTED_LINE:
+		chan_misdn_log(1, p->bc->port, "* IND :\tconnected line update pid:%d\n", p->bc->pid);
+		misdn_update_connected_line(ast, p->bc, p->originator);
+		break;
+	case AST_CONTROL_REDIRECTING:
+		chan_misdn_log(1, p->bc->port, "* IND :\tredirecting info update pid:%d\n", p->bc->pid);
+		misdn_copy_redirecting_from_ast(p->bc, ast);
 		break;
 	default:
-		chan_misdn_log(1, p->bc->port, " --> * Unknown Indication:%d pid:%d\n", cond, p->bc ? p->bc->pid : -1);
+		chan_misdn_log(1, p->bc->port, " --> * Unknown Indication:%d pid:%d\n", cond, p->bc->pid);
+		break;
 	}
 
 	return 0;
@@ -2814,8 +3493,10 @@ static int misdn_hangup(struct ast_channel *ast)
 
 	if (bc) {
 		const char *tmp;
+
 		ast_channel_lock(ast);
-		if ((tmp = pbx_builtin_getvar_helper(ast, "MISDN_USERUSER"))) {
+		tmp = pbx_builtin_getvar_helper(ast, "MISDN_USERUSER");
+		if (tmp) {
 			ast_log(LOG_NOTICE, "MISDN_USERUSER: %s\n", tmp);
 			strcpy(bc->uu, tmp);
 			bc->uulen = strlen(bc->uu);
@@ -2875,11 +3556,17 @@ static int misdn_hangup(struct ast_channel *ast)
 	}
 	ast_channel_unlock(ast);
 
-	chan_misdn_log(1, bc->port, "* IND : HANGUP\tpid:%d ctx:%s dad:%s oad:%s State:%s\n", p->bc ? p->bc->pid : -1, ast->context, ast->exten, ast->cid.cid_num, misdn_get_ch_state(p));
+	chan_misdn_log(1, bc->port,
+		"* IND : HANGUP\tpid:%d context:%s dialed:%s caller:\"%s\" <%s> State:%s\n",
+		p->bc ? p->bc->pid : -1,
+		ast->context,
+		ast->exten,
+		ast->cid.cid_name ? ast->cid.cid_name : "",
+		ast->cid.cid_num ? ast->cid.cid_num : "",
+		misdn_get_ch_state(p));
 	chan_misdn_log(3, bc->port, " --> l3id:%x\n", p->l3id);
 	chan_misdn_log(3, bc->port, " --> cause:%d\n", bc->cause);
 	chan_misdn_log(2, bc->port, " --> out_cause:%d\n", bc->out_cause);
-	chan_misdn_log(2, bc->port, " --> state:%s\n", misdn_get_ch_state(p));
 
 	switch (p->state) {
 	case MISDN_INCOMING_SETUP:
@@ -3034,7 +3721,7 @@ static struct ast_frame *process_ast_dsp(struct chan_list *tmp, struct ast_frame
  							ast_log(LOG_WARNING, "Failed to async goto '%s' into fax of '%s'\n", ast->name, context);
 						}
   					} else {
- 						ast_log(LOG_NOTICE, "Fax detected, but no fax extension ctx:%s exten:%s\n", context, ast->exten);
+ 						ast_log(LOG_NOTICE, "Fax detected but no fax extension, context:%s exten:%s\n", context, ast->exten);
 					}
  				} else {
 					ast_debug(1, "Already in a fax extension, not redirecting\n");
@@ -3081,7 +3768,8 @@ static struct ast_frame *misdn_read(struct ast_channel *ast)
 	FD_ZERO(&rrfs);
 	FD_SET(tmp->pipe[0], &rrfs);
 
-	if (!(t = select(FD_SETSIZE, &rrfs, NULL, NULL, &tv))) {
+	t = select(FD_SETSIZE, &rrfs, NULL, NULL, &tv);
+	if (!t) {
 		chan_misdn_log(3, tmp->bc->port, "read Select Timed out\n");
 		len = 160;
 	}
@@ -3249,15 +3937,11 @@ static int misdn_write(struct ast_channel *ast, struct ast_frame *frame)
 	return 0;
 }
 
-
-
-
-static enum ast_bridge_result  misdn_bridge (struct ast_channel *c0,
-				      struct ast_channel *c1, int flags,
-				      struct ast_frame **fo,
-				      struct ast_channel **rc,
-				      int timeoutms)
-
+static enum ast_bridge_result misdn_bridge(struct ast_channel *c0,
+	struct ast_channel *c1, int flags,
+	struct ast_frame **fo,
+	struct ast_channel **rc,
+	int timeoutms)
 {
 	struct chan_list *ch1, *ch2;
 	struct ast_channel *carr[2], *who;
@@ -3293,7 +3977,11 @@ static enum ast_bridge_result  misdn_bridge (struct ast_channel *c0,
 
 	ast_verb(3, "Native bridging %s and %s\n", c0->name, c1->name);
 
-	chan_misdn_log(1, ch1->bc->port, "* Making Native Bridge between %s and %s\n", ch1->bc->oad, ch2->bc->oad);
+	chan_misdn_log(1, ch1->bc->port, "* Making Native Bridge between \"%s\" <%s> and \"%s\" <%s>\n",
+		ch1->bc->caller.name,
+		ch1->bc->caller.number,
+		ch2->bc->caller.name,
+		ch2->bc->caller.number);
 
 	if (! (flags & AST_BRIDGE_DTMF_CHANNEL_0) ) {
 		ch1->ignore_dtmf = 1;
@@ -3342,7 +4030,7 @@ static enum ast_bridge_result  misdn_bridge (struct ast_channel *c0,
 		}
 #endif
 
-		ast_write(who == c0 ? c1 : c0, f);
+		ast_write((who == c0) ? c1 : c0, f);
 	}
 
 	chan_misdn_log(1, ch1->bc->port, "I SEND: Splitting conference with Number:%d\n", ch1->bc->pid + 1);
@@ -3437,7 +4125,8 @@ static struct chan_list *init_chan_list(int orig)
 {
 	struct chan_list *cl;
 
-	if (!(cl = ast_calloc(1, sizeof(*cl)))) {
+	cl = ast_calloc(1, sizeof(*cl));
+	if (!cl) {
 		chan_misdn_log(-1, 0, "misdn_request: malloc failed!");
 		return NULL;
 	}
@@ -3455,38 +4144,54 @@ static struct ast_channel *misdn_request(const char *type, int format, void *dat
 {
 	struct ast_channel *tmp = NULL;
 	char group[BUFFERSIZE + 1] = "";
-	char buf[128];
-	char *buf2 = ast_strdupa(data), *ext = NULL, *port_str;
-	char *tokb = NULL, *p = NULL;
-	int channel = 0, port = 0;
+	char dial_str[128];
+	char *dest_cp;
+	char *p = NULL;
+	int channel = 0;
+	int port = 0;
 	struct misdn_bchannel *newbc = NULL;
 	int dec = 0;
+	struct chan_list *cl;
 
-	struct chan_list *cl = init_chan_list(ORG_AST);
-
-	snprintf(buf, sizeof(buf), "%s/%s", misdn_type, (char*)data);
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(intf);	/* interface token */
+		AST_APP_ARG(ext);	/* extension token */
+		AST_APP_ARG(opts);	/* options token */
+	);
 
-	port_str = strtok_r(buf2, "/", &tokb);
+	snprintf(dial_str, sizeof(dial_str), "%s/%s", misdn_type, (char *) data);
 
-	ext = strtok_r(NULL, "/", &tokb);
+	/*
+	 * data is ---v
+	 * Dial(mISDN/g:group_name[/extension[/options]])
+	 * Dial(mISDN/port[:preselected_channel][/extension[/options]])
+	 *
+	 * The dial extension could be empty if you are using MISDN_KEYPAD
+	 * to control ISDN provider features.
+	 */
+	dest_cp = ast_strdupa(data);
+	AST_NONSTANDARD_APP_ARGS(args, dest_cp, '/');
+	if (!args.ext) {
+		args.ext = "";
+	}
 
-	if (port_str) {
-		if (port_str[0] == 'g' && port_str[1] == ':' ) {
+	if (!ast_strlen_zero(args.intf)) {
+		if (args.intf[0] == 'g' && args.intf[1] == ':' ) {
 			/* We make a group call lets checkout which ports are in my group */
-			port_str += 2;
-			ast_copy_string(group, port_str, sizeof(group));
+			args.intf += 2;
+			ast_copy_string(group, args.intf, sizeof(group));
 			chan_misdn_log(2, 0, " --> Group Call group: %s\n", group);
-		} else if ((p = strchr(port_str, ':'))) {
+		} else if ((p = strchr(args.intf, ':'))) {
 			/* we have a preselected channel */
-			*p = 0;
-			channel = atoi(++p);
-			port = atoi(port_str);
+			*p++ = 0;
+			channel = atoi(p);
+			port = atoi(args.intf);
 			chan_misdn_log(2, port, " --> Call on preselected Channel (%d).\n", channel);
 		} else {
-			port = atoi(port_str);
+			port = atoi(args.intf);
 		}
 	} else {
-		ast_log(LOG_WARNING, " --> ! IND : CALL dad:%s WITHOUT PORT/Group, check extensions.conf\n", ext);
+		ast_log(LOG_WARNING, " --> ! IND : Dial(%s) WITHOUT Port or Group, check extensions.conf\n", dial_str);
 		return NULL;
 	}
 
@@ -3579,7 +4284,8 @@ static struct ast_channel *misdn_request(const char *type, int format, void *dat
 					chan_misdn_log(4, port, "portup:%d\n", port_up);
 
 					if (port_up > 0) {
-						if ((newbc = misdn_lib_get_free_bc(port, 0, 0, dec))) {
+						newbc = misdn_lib_get_free_bc(port, 0, 0, dec);
+						if (newbc) {
 							break;
 						}
 					}
@@ -3602,18 +4308,22 @@ static struct ast_channel *misdn_request(const char *type, int format, void *dat
 			chan_misdn_log(1, port, " --> preselected_channel: %d\n", channel);
 		}
 		newbc = misdn_lib_get_free_bc(port, channel, 0, dec);
-
 		if (!newbc) {
-			ast_log(LOG_WARNING, "Could not create channel on port:%d with extensions:%s\n", port, ext);
+			ast_log(LOG_WARNING, "Could not create channel on port:%d for Dial(%s)\n", port, dial_str);
 			return NULL;
 		}
 	}
 
 
 	/* create ast_channel and link all the objects together */
+	cl = init_chan_list(ORG_AST);
+	if (!cl) {
+		ast_log(LOG_WARNING, "Could not create Asterisk channel for Dial(%s)\n", dial_str);
+		return NULL;
+	}
 	cl->bc = newbc;
 
-	tmp = misdn_new(cl, AST_STATE_RESERVED, ext, NULL, format, port, channel);
+	tmp = misdn_new(cl, AST_STATE_RESERVED, args.ext, NULL, format, port, channel);
 	if (!tmp) {
 		ast_log(LOG_ERROR, "Could not create Asterisk object\n");
 		return NULL;
@@ -3625,7 +4335,7 @@ static struct ast_channel *misdn_request(const char *type, int format, void *dat
 	cl_queue_chan(&cl_te, cl);
 
 	/* fill in the config into the objects */
-	read_config(cl, ORG_AST);
+	read_config(cl);
 
 	/* important */
 	cl->need_hangup = 0;
@@ -3736,7 +4446,7 @@ static struct ast_channel *misdn_new(struct chan_list *chlist, int state,  char
 
 	tmp = ast_channel_alloc(1, state, cid_num, cid_name, "", exten, "", 0, "%s/%s%d-u%d", misdn_type, c ? "" : "tmp", chan_offset + c, glob_channel++);
 	if (tmp) {
-		chan_misdn_log(2, 0, " --> * NEW CHANNEL dad:%s oad:%s\n", exten, callerid);
+		chan_misdn_log(2, 0, " --> * NEW CHANNEL dialed:%s caller:%s\n", exten, callerid);
 
 		tmp->nativeformats = prefformat;
 
@@ -3791,7 +4501,11 @@ static struct chan_list *find_chan_by_bc(struct chan_list *list, struct misdn_bc
 		}
 	}
 
-	chan_misdn_log(6, bc->port, "$$$ find_chan: No channel found for oad:%s dad:%s\n", bc->oad, bc->dad);
+	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;
 }
@@ -3805,7 +4519,7 @@ static struct chan_list *find_chan_by_pid(struct chan_list *list, int pid)
 		}
 	}
 
-	chan_misdn_log(6, 0, "$$$ find_chan: No channel found for pid:%d\n", pid);
+	chan_misdn_log(6, 0, "$$$ find_chan_by_pid: No channel found for pid:%d\n", pid);
 
 	return NULL;
 }
@@ -3818,7 +4532,11 @@ static struct chan_list *find_holded(struct chan_list *list, struct misdn_bchann
 		return NULL;
 	}
 
-	chan_misdn_log(6, bc->port, "$$$ find_holded: channel:%d oad:%s dad:%s\n", bc->channel, bc->oad, bc->dad);
+	chan_misdn_log(6, bc->port, "$$$ find_holded: channel:%d dialed:%s caller:\"%s\" <%s>\n",
+		bc->channel,
+		bc->dialed.number,
+		bc->caller.name,
+		bc->caller.number);
 	for (; help; help = help->next) {
 		chan_misdn_log(4, bc->port, "$$$ find_holded: --> holded:%d channel:%d\n", help->state == MISDN_HOLDED, help->hold_info.channel);
 		if ((help->state == MISDN_HOLDED) &&
@@ -3826,7 +4544,11 @@ static struct chan_list *find_holded(struct chan_list *list, struct misdn_bchann
 			return help;
 		}
 	}
-	chan_misdn_log(6, bc->port, "$$$ find_chan: No channel found for oad:%s dad:%s\n", bc->oad, bc->dad);
+	chan_misdn_log(6, bc->port,
+		"$$$ find_holded: No channel found for dialed:%s caller:\"%s\" <%s>\n",
+		bc->dialed.number,
+		bc->caller.name,
+		bc->caller.number);
 
 	return NULL;
 }
@@ -3947,12 +4669,14 @@ static void hangup_chan(struct chan_list *ch)
 }
 
 /** Isdn asks us to release channel, pendant to misdn_hangup **/
-static void release_chan(struct misdn_bchannel *bc) {
+static void release_chan(struct misdn_bchannel *bc)
+{
 	struct ast_channel *ast = NULL;
 	struct chan_list *ch;
 
 	ast_mutex_lock(&release_lock);
-	if (!(ch = find_chan_by_bc(cl_te, bc))) {
+	ch = find_chan_by_bc(cl_te, bc);
+	if (!ch) {
 		chan_misdn_log(1, bc->port, "release_chan: Ch not found!\n");
 		ast_mutex_unlock(&release_lock);
 		return;
@@ -3965,7 +4689,7 @@ static void release_chan(struct misdn_bchannel *bc) {
 	chan_misdn_log(5, bc->port, "release_chan: bc with l3id: %x\n", bc->l3_id);
 
 	/* releasing jitterbuffer */
-	if (ch->jb ) {
+	if (ch->jb) {
 		misdn_jb_destroy(ch->jb);
 		ch->jb = NULL;
 	} else {
@@ -3993,7 +4717,14 @@ static void release_chan(struct misdn_bchannel *bc) {
 		close(ch->pipe[1]);
 
 		if (ast && MISDN_ASTERISK_TECH_PVT(ast)) {
-			chan_misdn_log(1, bc->port, "* RELEASING CHANNEL pid:%d ctx:%s dad:%s oad:%s state: %s\n", bc ? bc->pid : -1, ast->context, ast->exten, ast->cid.cid_num, misdn_get_ch_state(ch));
+			chan_misdn_log(1, bc->port,
+				"* RELEASING CHANNEL pid:%d context:%s dialed:%s caller:\"%s\" <%s> state: %s\n",
+				bc->pid,
+				ast->context,
+				ast->exten,
+				ast->cid.cid_name ? ast->cid.cid_name : "",
+				ast->cid.cid_num ? ast->cid.cid_num : "",
+				misdn_get_ch_state(ch));
 			chan_misdn_log(3, bc->port, " --> * State Down\n");
 			MISDN_ASTERISK_TECH_PVT(ast) = NULL;
 
@@ -4053,9 +4784,14 @@ static void do_immediate_setup(struct misdn_bchannel *bc, struct chan_list *ch,
 		ch->state = MISDN_INCOMING_SETUP;
 	}
 
-	chan_misdn_log(1, bc->port, "* Starting Ast ctx:%s dad:%s oad:%s with 's' extension\n", ast->context, ast->exten, ast->cid.cid_num);
+	chan_misdn_log(1, bc->port,
+		"* Starting Ast context:%s dialed:%s caller:\"%s\" <%s> with 's' extension\n",
+		ast->context,
+		ast->exten,
+		ast->cid.cid_name ? ast->cid.cid_name : "",
+		ast->cid.cid_num ? ast->cid.cid_num : "");
 
-	strncpy(ast->exten, "s", 2);
+	strcpy(ast->exten, "s");
 
 	if (pbx_start_chan(ch) < 0) {
 		ast = NULL;
@@ -4183,6 +4919,7 @@ void import_ch(struct ast_channel *chan, struct misdn_bchannel *bc, struct chan_
 void export_ch(struct ast_channel *chan, struct misdn_bchannel *bc, struct chan_list *ch)
 {
 	char tmp[32];
+
 	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);
@@ -4237,7 +4974,8 @@ int add_out_calls(int port)
 	return 0;
 }
 
-static void start_pbx(struct chan_list *ch, struct misdn_bchannel *bc, struct ast_channel *chan) {
+static void start_pbx(struct chan_list *ch, struct misdn_bchannel *bc, struct ast_channel *chan)
+{
 	if (pbx_start_chan(ch) < 0) {
 		hangup_chan(ch);
 		chan_misdn_log(-1, bc->port, "ast_pbx_start returned <0 in SETUP\n");
@@ -4250,10 +4988,11 @@ static void start_pbx(struct chan_list *ch, struct misdn_bchannel *bc, struct as
 	}
 }
 
-static void wait_for_digits(struct chan_list *ch, struct misdn_bchannel *bc, struct ast_channel *chan) {
+static void wait_for_digits(struct chan_list *ch, struct misdn_bchannel *bc, struct ast_channel *chan)
+{
 	ch->state = MISDN_WAITING4DIGS;
 	misdn_lib_send_event(bc, EVENT_SETUP_ACKNOWLEDGE );
-	if (bc->nt && !bc->dad[0]) {
+	if (bc->nt && !bc->dialed.number[0]) {
 		dialtone_indicate(ch);
 	}
 }
@@ -4273,7 +5012,14 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 			debuglevel = 5;
 		}
 
-		chan_misdn_log(debuglevel, bc->port, "I IND :%s oad:%s dad:%s pid:%d state:%s\n", manager_isdn_get_info(event), bc->oad, bc->dad, bc->pid, ch ? misdn_get_ch_state(ch) : "none");
+		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));
@@ -4407,25 +5153,23 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 				ast_copy_string(bc->info_dad, bc->keypad, sizeof(bc->info_dad));
 			}
 
-			strncat(bc->dad, bc->info_dad, sizeof(bc->dad) - strlen(bc->dad) - 1);
-			ast_copy_string(ch->ast->exten, bc->dad, sizeof(ch->ast->exten));
+			strncat(bc->dialed.number, bc->info_dad, sizeof(bc->dialed.number) - strlen(bc->dialed.number) - 1);
+			ast_copy_string(ch->ast->exten, bc->dialed.number, sizeof(ch->ast->exten));
 
 			/* Check for Pickup Request first */
 			if (!strcmp(ch->ast->exten, ast_pickup_ext())) {
 				if (ast_pickup_call(ch->ast)) {
 					hangup_chan(ch);
 				} else {
-					struct ast_channel *chan = ch->ast;
 					ch->state = MISDN_CALLING_ACKNOWLEDGE;
-					ast_setstate(chan, AST_STATE_DOWN);
 					hangup_chan(ch);
 					ch->ast = NULL;
 					break;
 				}
 			}
 
-			if (!ast_canmatch_extension(ch->ast, ch->context, bc->dad, 1, bc->oad)) {
-				if (ast_exists_extension(ch->ast, ch->context, "i", 1, bc->oad)) {
+			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 can never match, So jumping to 'i' extension. port(%d)\n", bc->port);
 					strcpy(ch->ast->exten, "i");
 
@@ -4459,7 +5203,7 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 				break;
 			}
 
-			if (ast_exists_extension(ch->ast, ch->context, bc->dad, 1, bc->oad))  {
+			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);
 			}
@@ -4482,8 +5226,8 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 			misdn_cfg_get(0, MISDN_GEN_APPEND_DIGITS2EXTEN, &digits, sizeof(digits));
 			if (ch->state != MISDN_CONNECTED ) {
 				if (digits) {
-					strncat(bc->dad, bc->info_dad, sizeof(bc->dad) - strlen(bc->dad) - 1);
-					ast_copy_string(ch->ast->exten, bc->dad, sizeof(ch->ast->exten));
+					strncat(bc->dialed.number, bc->info_dad, sizeof(bc->dialed.number) - strlen(bc->dialed.number) - 1);
+					ast_copy_string(ch->ast->exten, bc->dialed.number, sizeof(ch->ast->exten));
 					ast_cdr_update(ch->ast);
 				}
 
@@ -4494,10 +5238,9 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 	case EVENT_SETUP:
 	{
 		struct chan_list *ch = find_chan_by_bc(cl_te, bc);
-		int msn_valid = misdn_cfg_is_msn_valid(bc->port, bc->dad);
+		int msn_valid = misdn_cfg_is_msn_valid(bc->port, bc->dialed.number);
 		struct ast_channel *chan;
 		int exceed;
-		int pres, screen;
 		int ai;
 		int im;
 
@@ -4537,10 +5280,8 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 		ch->bc = bc;
 		ch->l3id = bc->l3_id;
 		ch->addr = bc->addr;
-		ch->originator = ORG_MISDN;
-
-		chan = misdn_new(ch, AST_STATE_RESERVED, bc->dad, bc->oad, AST_FORMAT_ALAW, bc->port, bc->channel);
 
+		chan = misdn_new(ch, AST_STATE_RESERVED, bc->dialed.number, bc->caller.number, AST_FORMAT_ALAW, bc->port, bc->channel);
 		if (!chan) {
 			misdn_lib_send_event(bc,EVENT_RELEASE_COMPLETE);
 			ast_log(LOG_ERROR, "cb_events: misdn_new failed !\n");
@@ -4555,49 +5296,44 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 			pbx_builtin_setvar_helper(chan, "MAX_OVERFLOW", tmp);
 		}
 
-		read_config(ch, ORG_MISDN);
+		read_config(ch);
 
 		export_ch(chan, bc, ch);
 
 		ch->ast->rings = 1;
 		ast_setstate(ch->ast, AST_STATE_RINGING);
 
-		switch (bc->pres) {
-		case 1:
-			pres = AST_PRES_RESTRICTED;
-			chan_misdn_log(2, bc->port, " --> PRES: Restricted (1)\n");
-			break;
-		case 2:
-			pres = AST_PRES_UNAVAILABLE;
-			chan_misdn_log(2, bc->port, " --> PRES: Unavailable (2)\n");
-			break;
-		default:
-			pres = AST_PRES_ALLOWED;
-			chan_misdn_log(2, bc->port, " --> PRES: Allowed (%d)\n", bc->pres);
-			break;
-		}
+		/* 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);
+		chan->cid.cid_ton = misdn_to_ast_ton(bc->caller.number_type)
+			| misdn_to_ast_plan(bc->caller.number_plan);
 
-		switch (bc->screen) {
-		default:
-		case 0:
-			screen = AST_PRES_USER_NUMBER_UNSCREENED;
-			chan_misdn_log(2, bc->port, " --> SCREEN: Unscreened (%d)\n", bc->screen);
-			break;
-		case 1:
-			screen = AST_PRES_USER_NUMBER_PASSED_SCREEN;
-			chan_misdn_log(2, bc->port, " --> SCREEN: Passed screen (1)\n");
-			break;
-		case 2:
-			screen = AST_PRES_USER_NUMBER_FAILED_SCREEN;
-			chan_misdn_log(2, bc->port, " --> SCREEN: failed screen (2)\n");
-			break;
-		case 3:
-			screen = AST_PRES_NETWORK_NUMBER;
-			chan_misdn_log(2, bc->port, " --> SCREEN: Network Number (3)\n");
-			break;
-		}
+		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);
+		chan->cid.cid_pres = 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);
+
+		if (!ast_strlen_zero(bc->redirecting.from.number)) {
+			struct ast_party_redirecting redirecting;
 
-		chan->cid.cid_pres = pres | screen;
+			/* 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 */
+			ast_party_redirecting_set_init(&redirecting, &chan->redirecting);
+			redirecting.from.number = bc->redirecting.from.number;
+			redirecting.from.number_type =
+				misdn_to_ast_ton(bc->redirecting.from.number_type)
+				| misdn_to_ast_plan(bc->redirecting.from.number_plan);
+			redirecting.from.number_presentation =
+				misdn_to_ast_pres(bc->redirecting.from.presentation)
+				| misdn_to_ast_screen(bc->redirecting.from.screening);
+			redirecting.reason = misdn_to_ast_reason(bc->redirecting.reason);
+			ast_channel_set_redirecting(chan, &redirecting);
+		}
 
 		pbx_builtin_setvar_helper(chan, "TRANSFERCAPABILITY", ast_transfercapability2str(bc->capability));
 		chan->transfercapability = bc->capability;
@@ -4627,7 +5363,7 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 						break;
 					}
 				}
-			}	/* end for */
+			}
 			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",
@@ -4652,7 +5388,6 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 				hangup_chan(ch);
 			} else {
 				ch->state = MISDN_CALLING_ACKNOWLEDGE;
-				ast_setstate(chan, AST_STATE_DOWN);
 				hangup_chan(ch);
 				ch->ast = NULL;
 				break;
@@ -4669,16 +5404,16 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 			break;
 		}
 
-		/* check if we should jump into s when we have no dad */
+		/* 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->dad)) {
+		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->dad, 1, bc->oad)) {
-			if (ast_exists_extension(ch->ast, ch->context, "i", 1, bc->oad)) {
+		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 can never match, So jumping to 'i' extension. port(%d)\n", bc->port);
 				strcpy(ch->ast->exten, "i");
 				misdn_lib_send_event(bc, EVENT_SETUP_ACKNOWLEDGE);
@@ -4722,7 +5457,7 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 		 * the number is empty, we wait for the ISDN timeout
 		 * instead of our own timer.
 		 */
-		if (ch->overlap_dial && bc->nt && !bc->dad[0] ) {
+		if (ch->overlap_dial && bc->nt && !bc->dialed.number[0] ) {
 			wait_for_digits(ch, bc, chan);
 			break;
 		}
@@ -4747,7 +5482,7 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 		/* 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->dad, 1, bc->oad))  {
+		if (!ast_exists_extension(ch->ast, ch->context, bc->dialed.number, 1, bc->caller.number))  {
 			wait_for_digits(ch, bc, chan);
 			break;
 		}
@@ -4755,29 +5490,30 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 		/*
 		 * If the extension exists let's just jump into it.
 		 * */
-		if (ast_exists_extension(ch->ast, ch->context, bc->dad, 1, bc->oad)) {
+		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;
+	}
 
 	case EVENT_SETUP_ACKNOWLEDGE:
 		ch->state = MISDN_CALLING_ACKNOWLEDGE;
 
-		if (bc->channel)
+		if (bc->channel) {
 			update_name(ch->ast,bc->port,bc->channel);
+		}
 
 		if (!ast_strlen_zero(bc->infos_pending)) {
 			/* TX Pending Infos */
-			strncat(bc->dad, bc->infos_pending, sizeof(bc->dad) - strlen(bc->dad) - 1);
+			strncat(bc->dialed.number, bc->infos_pending, sizeof(bc->dialed.number) - strlen(bc->dialed.number) - 1);
 
 			if (!ch->ast) {
 				break;
 			}
-			ast_copy_string(ch->ast->exten, bc->dad, sizeof(ch->ast->exten));
+			ast_copy_string(ch->ast->exten, bc->dialed.number, sizeof(ch->ast->exten));
 			ast_copy_string(bc->info_dad, bc->infos_pending, sizeof(bc->info_dad));
 			ast_copy_string(bc->infos_pending, "", sizeof(bc->infos_pending));
 
@@ -4842,29 +5578,31 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 		}
 		break;
 	case EVENT_CONNECT:
-		{
-			struct ast_channel *bridged;
+	{
+		struct ast_party_connected_line connected;
 
-			/*we answer when we've got our very new L3 ID from the NT stack */
-			misdn_lib_send_event(bc, EVENT_CONNECT_ACKNOWLEDGE);
+		/* 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;
-			}
+		if (!ch->ast) {
+			break;
+		}
 
-			bridged = ast_bridged_channel(ch->ast);
-			stop_indicate(ch);
+		stop_indicate(ch);
 
-			if (bridged && !strcasecmp(bridged->tech->type, "mISDN")) {
-				struct chan_list *bridged_ch = MISDN_ASTERISK_TECH_PVT(bridged);
+		/* 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 */
+		ast_party_connected_line_init(&connected);
+		connected.id.number = bc->connected.number;
+		connected.id.number_type = misdn_to_ast_ton(bc->connected.number_type)
+			| misdn_to_ast_plan(bc->connected.number_plan);
+		connected.id.number_presentation = misdn_to_ast_pres(bc->connected.presentation)
+			| misdn_to_ast_screen(bc->connected.screening);
+		connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
+		ast_channel_queue_connected_line_update(ch->ast, &connected);
 
-				chan_misdn_log(1, bc->port, " --> copying cpndialplan:%d and cad:%s to the A-Channel\n", bc->cpnnumplan, bc->cad);
-				if (bridged_ch) {
-					bridged_ch->bc->cpnnumplan = bc->cpnnumplan;
-					ast_copy_string(bridged_ch->bc->cad, bc->cad, sizeof(bridged_ch->bc->cad));
-				}
-			}
-		}
 		ch->l3id = bc->l3_id;
 		ch->addr = bc->addr;
 
@@ -4874,6 +5612,7 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 
 		ast_queue_control(ch->ast, AST_CONTROL_ANSWER);
 		break;
+	}
 	case EVENT_CONNECT_ACKNOWLEDGE:
 		ch->l3id = bc->l3_id;
 		ch->addr = bc->addr;
@@ -4947,8 +5686,9 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 		stop_bc_tones(ch);
 		hangup_chan(ch);
 
-		if (ch)
+		if (ch) {
 			ch->state = MISDN_CLEANING;
+		}
 
 		release_chan(bc);
 		break;
@@ -5003,16 +5743,16 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 		} 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*/
+
+			/* In Data Modes we queue frames */
 			frame.frametype = AST_FRAME_VOICE; /* we have no data frames yet */
 			frame.subclass = AST_FORMAT_ALAW;
 			frame.datalen = bc->bframe_len;
@@ -5023,8 +5763,9 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 			frame.src = NULL;
 			frame.data.ptr = bc->bframe;
 
-			if (ch->ast)
+			if (ch->ast) {
 				ast_queue_frame(ch->ast, &frame);
+			}
 		} else {
 			fd_set wrfs;
 			struct timeval tv = { 0, 0 };
@@ -5099,6 +5840,7 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 			break;
 		default:
 			misdn_lib_send_event(bc, EVENT_RELEASE_COMPLETE);
+			break;
 		}
 		break;
 
@@ -5137,8 +5879,8 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 			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;
@@ -5171,8 +5913,8 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 			misdn_lib_send_event(bc, EVENT_HOLD_REJECT);
 			chan_misdn_log(0, bc->port, "We aren't bridged to anybody\n");
 		}
-	}
 		break;
+	}
 	case EVENT_FACILITY:
 		print_facility(&(bc->fac_in), bc);
 
@@ -5189,7 +5931,7 @@ cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data)
 					ch_br = MISDN_ASTERISK_TECH_PVT(bridged);
 					/*ch->state = MISDN_FACILITY_DEFLECTED;*/
 					if (ch_br->bc) {
-						if (ast_exists_extension(bridged, ch->context, (char *)bc->fac_in.u.CDeflection.DeflectedToNumber, 1, bc->oad)) {
+						if (ast_exists_extension(bridged, ch->context, (char *) bc->fac_in.u.CDeflection.DeflectedToNumber, 1, bc->caller.number)) {
 							ch_br->state = MISDN_DIALING;
 							if (pbx_start_chan(ch_br) < 0) {
 								chan_misdn_log(-1, ch_br->bc->port, "ast_pbx_start returned < 0 in misdn_overlap_dial_task\n");
@@ -5461,6 +6203,7 @@ static int misdn_facility_exec(struct ast_channel *chan, void *data)
 {
 	struct chan_list *ch = MISDN_ASTERISK_TECH_PVT(chan);
 	char *parse;
+
 	AST_DECLARE_APP_ARGS(args,
 		AST_APP_ARG(facility_type);
 		AST_APP_ARG(arg)[99];
@@ -5473,7 +6216,7 @@ static int misdn_facility_exec(struct ast_channel *chan, void *data)
 		return -1;
 	}
 
-	if (ast_strlen_zero((char *)data)) {
+	if (ast_strlen_zero((char *) data)) {
 		ast_log(LOG_WARNING, "misdn_facility requires arguments: facility_type[,<args>]\n");
 		return -1;
 	}
@@ -5492,7 +6235,9 @@ static int misdn_facility_exec(struct ast_channel *chan, void *data)
 		}
 
 		if (strlen(args.arg[0]) >= sizeof(ch->bc->fac_out.u.CDeflection.DeflectedToNumber)) {
-			ast_log(LOG_WARNING, "Facility: Number argument too long (up to %d digits are allowed). Ignoring.\n", (int)sizeof(ch->bc->fac_out.u.CDeflection.DeflectedToNumber));
+			ast_log(LOG_WARNING,
+				"Facility: Number argument too long (up to %d digits are allowed). Ignoring.\n",
+				(int) sizeof(ch->bc->fac_out.u.CDeflection.DeflectedToNumber));
 			return 0;
 		}
 		ch->bc->fac_out.Function = Fac_CD;
@@ -5516,11 +6261,11 @@ static int misdn_check_l2l1(struct ast_channel *chan, void *data)
 	int port_up;
 
 	AST_DECLARE_APP_ARGS(args,
-			AST_APP_ARG(grouppar);
-			AST_APP_ARG(timeout);
+		AST_APP_ARG(grouppar);
+		AST_APP_ARG(timeout);
 	);
 
-	if (ast_strlen_zero((char *)data)) {
+	if (ast_strlen_zero((char *) data)) {
 		ast_log(LOG_WARNING, "misdn_check_l2l1 Requires arguments\n");
 		return -1;
 	}
@@ -5543,7 +6288,7 @@ static int misdn_check_l2l1(struct ast_channel *chan, void *data)
 		ast_copy_string(group, port_str, sizeof(group));
 		chan_misdn_log(2, 0, "Checking Ports in group: %s\n", group);
 
-		for (	port = misdn_cfg_get_next_port(port);
+		for (port = misdn_cfg_get_next_port(port);
 			port > 0;
 			port = misdn_cfg_get_next_port(port)) {
 			char cfg_group[BUFFERSIZE + 1];
@@ -5554,7 +6299,6 @@ static int misdn_check_l2l1(struct ast_channel *chan, void *data)
 
 			if (!strcasecmp(cfg_group, group)) {
 				port_up = misdn_lib_port_up(port, 1);
-
 				if (!port_up) {
 					chan_misdn_log(2, 0, " --> port '%d'\n", port);
 					misdn_lib_get_port_up(port);
@@ -5752,12 +6496,15 @@ static int misdn_set_opt_exec(struct ast_channel *chan, void *data)
 			chan_misdn_log(1, ch->bc->port, "SETOPT: callerpres: %s\n", &tok[1]);
 			/* CRICH: callingpres!!! */
 			if (strstr(tok, "allowed")) {
-				ch->bc->pres = 0;
+				ch->bc->presentation = 0;
+				ch->bc->set_presentation = 1;
 			} else if (strstr(tok, "restricted")) {
-				ch->bc->pres = 1;
+				ch->bc->presentation = 1;
+				ch->bc->set_presentation = 1;
 			} else if (strstr(tok, "not_screened")) {
 				chan_misdn_log(0, ch->bc->port, "SETOPT: callerpres: not_screened is deprecated\n");
-				ch->bc->pres = 1;
+				ch->bc->presentation = 1;
+				ch->bc->set_presentation = 1;
 			}
 			break;
 	  	case 'i' :
@@ -5975,16 +6722,10 @@ int misdn_jb_empty(struct misdn_jb *jb, char *data, int len)
 	return read;
 }
 
-
-
-
 /*******************************************************/
 /*************** JITTERBUFFER  END *********************/
 /*******************************************************/
 
-
-
-
 static void chan_misdn_log(int level, int port, char *tmpl, ...)
 {
 	va_list ap;
@@ -6005,7 +6746,6 @@ static void chan_misdn_log(int level, int port, char *tmpl, ...)
 
 	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]) {
@@ -6021,7 +6761,8 @@ static void chan_misdn_log(int level, int port, char *tmpl, ...)
 
 		FILE *fp = fopen(global_tracefile, "a+");
 
-		if ((p = strchr(tmp, '\n'))) {
+		p = strchr(tmp, '\n');
+		if (p) {
 			*p = ':';
 		}