moved extra/* to main/

and fixed misc build issues

3 files changed, 5722 insertions, 0 deletions

diff --git a/main/libpri/APKBUILD b/main/libpri/APKBUILD
new file mode 100644
index 00000000000..d4d90a81038
--- /dev/null
+++ b/main/libpri/APKBUILD
@@ -0,0 +1,33 @@
+# Contributor: Timo Teras <timo.teras@iki.fi>
+# Maintainer: Timo Teras <timo.teras@iki.fi>
+pkgname=libpri
+pkgver=1.4.9
+pkgrel=1
+pkgdesc="Primary Rate ISDN (PRI) library"
+url="http://www.asterisk.orig"
+license="GPL"
+depends=""
+makedepends=""
+install=
+subpackages="$pkgname-dev"
+source="http://downloads.digium.com/pub/telephony/libpri/releases/$pkgname-$pkgver.tar.gz
+	libpri-cflags.patch
+	libpri-1.4.9-i14292.patch"
+
+build() {
+	cd "$srcdir/$pkgname-$pkgver"
+	for i in ../*.patch; do
+		msg "Applying $i"
+		patch -p1 < $i || return 1;
+	done
+
+	make LDCONFIG="echo" || return 1
+	make LDCONFIG="echo" INSTALL_PREFIX="$pkgdir" install
+
+	# install -m755 -D "$srcdir"/$pkgname.initd "$pkgdir"/etc/init.d/$pkgname
+	# install -m644 -D "$srcdir"/$pkgname.confd "$pkgdir"/etc/conf.d/$pkgname
+}
+
+md5sums="97332edeaa2de0320d85fda88afb96f9  libpri-1.4.9.tar.gz
+8df2ca48ce7db4f1a8604b0904bc9394  libpri-cflags.patch
+240e4057980c88f2c2576c5c25744c70  libpri-1.4.9-i14292.patch"
diff --git a/main/libpri/libpri-1.4.9-i14292.patch b/main/libpri/libpri-1.4.9-i14292.patch
new file mode 100644
index 00000000000..27ed1b8d432
--- /dev/null
+++ b/main/libpri/libpri-1.4.9-i14292.patch
@@ -0,0 +1,5668 @@
+Index: .version
+===================================================================
+--- a/.version	(.../tags/1.4.9)	(revision 700)
++++ b/.version	(.../team/group/issue14292)	(revision 700)
+@@ -1 +1 @@
+-1.4.9
++1.4.9-issue14292
+Index: pri_facility.c
+===================================================================
+--- a/pri_facility.c	(.../tags/1.4.9)	(revision 700)
++++ b/pri_facility.c	(.../team/group/issue14292)	(revision 700)
+@@ -171,7 +171,7 @@
+ 
+ struct addressingdataelements_presentednumberunscreened {
+ 	char partyaddress[21];
+-	char partysubaddress[21];
++	char notused[21];
+ 	int  npi;       /* Numbering Plan Indicator */
+ 	int  ton;       /* Type Of Number */
+ 	int  pres;      /* Presentation */
+@@ -179,6 +179,15 @@
+ 
+ struct addressingdataelements_presentednumberscreened {
+ 	char partyaddress[21];
++	char notused[21];
++	int  npi;       /* Numbering Plan Indicator */
++	int  ton;       /* Type Of Number */
++	int  pres;      /* Presentation */
++	int  scrind;    /* Screening Indicator */
++};
++
++struct addressingdataelements_presentedaddressscreened {
++	char partyaddress[21];
+ 	char partysubaddress[21];
+ 	int  npi;       /* Numbering Plan Indicator */
+ 	int  ton;       /* Type Of Number */
+@@ -186,6 +195,35 @@
+ 	int  scrind;    /* Screening Indicator */
+ };
+ 
++struct addressingdataelements_addressscreened {
++	char partyaddress[21];
++	char partysubaddress[21];
++	int  npi;       /* Numbering Plan Indicator */
++	int  ton;       /* Type Of Number */
++	int  notused;
++	int  scrind;    /* Screening Indicator */
++};
++
++struct addressingdataelements_partysubaddress {
++	char notused[21];
++	char partysubaddress[21];
++};
++
++struct nameelements_name {
++	char name[51];
++	int  characterset;
++	int  namepres;
++};
++
++struct nameelements_nameset {
++	char name[51];
++	int  characterset;
++};
++
++struct nameelements_namedata {
++	char name[51];
++};
++
+ #define PRI_CHECKOVERFLOW(size) \
+ 		if (msgptr - message + (size) >= sizeof(message)) { \
+ 			*msgptr = '\0'; \
+@@ -225,6 +263,92 @@
+ }
+ #undef PRI_CHECKOVERFLOW
+ 
++static const char *namepres_to_str(int namepres)
++{
++	return (namepres == 0) ? "Restricted" : "Allowed";
++}
++
++static const char *characterset_to_str(int characterset)
++{
++	switch (characterset) {
++	case CHARACTER_SET_UNKNOWN:
++		return "Unknown";
++	case CHARACTER_SET_ISO8859_1:
++		return "ISO8859-1";
++	case CHARACTER_SET_ISO8859_2:
++		return "ISO8859-2";
++	case CHARACTER_SET_ISO8859_3:
++		return "ISO8859-3";
++	case CHARACTER_SET_ISO8859_4:
++		return "ISO8859-4";
++	case CHARACTER_SET_ISO8859_5:
++		return "ISO8859-5";
++	case CHARACTER_SET_ISO8859_7:
++		return "ISO8859-7";
++	default:
++		return "illegal value";
++	}
++}
++
++static const char *diversionreason_to_str(struct pri *pri, int diversionreason)
++{
++	if (pri->switchtype == PRI_SWITCH_QSIG) {
++		switch (diversionreason) {
++		case QSIG_DIVERT_REASON_UNKNOWN:
++			return "Unknown";
++		case QSIG_DIVERT_REASON_CFU:
++			return "Call Forwarding Unconditional";
++		case QSIG_DIVERT_REASON_CFB:
++			return "Call Forwarding Busy";
++		case QSIG_DIVERT_REASON_CFNR:
++			return "Call Forwarding No Reply";
++		default:
++			return "invalid value";
++		}
++	} else {
++		switch(diversionreason) {
++		case Q952_DIVERT_REASON_UNKNOWN:
++			return "Unknown";
++		case Q952_DIVERT_REASON_CFU:
++			return "Call Forwarding Unconditional";
++		case Q952_DIVERT_REASON_CFB:
++			return "Call Forwarding Busy";
++		case Q952_DIVERT_REASON_CFNR:
++			return "Call Forwarding No Reply";
++		case Q952_DIVERT_REASON_CD:
++			return "Call Deflection";
++		case Q952_DIVERT_REASON_IMMEDIATE:
++			return "Call Deflection Immediate";
++		default:
++			return "invalid value";
++		}
++	}
++}
++
++static const char *callstatus_to_str(int callstatus)
++{
++	switch (callstatus) {
++	case 0:
++		return "answered";
++	case 1:
++		return "alerting";
++	default:
++		return "illegal value";
++	}
++}
++
++static const char *enddesignation_to_str(int enddesignation)
++{
++	switch (enddesignation) {
++	case 0:
++		return "primaryEnd";
++	case 1:
++		return "secondaryEnd";
++	default:
++		return "illegal value";
++	}
++}
++
+ int redirectingreason_from_q931(struct pri *pri, int redirectingreason)
+ {
+ 	switch(pri->switchtype) {
+@@ -350,8 +474,25 @@
+ 	}
+ }
+ 
+-int asn1_name_decode(void * data, int len, char *namebuf, int buflen)
++static int presentation_to_subscription(struct pri *pri, int presentation)
+ {
++	/* derive subscription value from presentation value */
++
++	switch (presentation & PRES_RESTRICTION) {
++	case PRES_ALLOWED:
++		return QSIG_NOTIFICATION_WITH_DIVERTED_TO_NR;
++	case PRES_RESTRICTED:
++		return QSIG_NOTIFICATION_WITHOUT_DIVERTED_TO_NR;
++	case PRES_UNAVAILABLE:			/* Number not available due to interworking */
++		return QSIG_NOTIFICATION_WITHOUT_DIVERTED_TO_NR;	/* ?? QSIG_NO_NOTIFICATION */
++	default:
++		pri_message(pri, "!! Unknown Q.SIG presentationIndicator 0x%02x\n", presentation);
++		return QSIG_NOTIFICATION_WITHOUT_DIVERTED_TO_NR;
++	}
++}
++
++int asn1_name_decode(void *data, int len, char *namebuf, int buflen)
++{
+ 	struct rose_component *comp = (struct rose_component*)data;
+ 	int datalen = 0, res = 0;
+ 
+@@ -361,11 +502,13 @@
+ 	} else
+ 		datalen = res = comp->len;
+ 
+-	if (datalen > buflen) {
++	if (datalen > buflen - 1) {
+ 		/* Truncate */
+ 		datalen = buflen;
+ 	}
+ 	memcpy(namebuf, comp->data, datalen);
++	namebuf[datalen] = '\0';
++
+ 	return res + 2;
+ }
+ 
+@@ -407,42 +550,230 @@
+ 	return res;
+ }
+ 
+-static int rose_number_digits_decode(struct pri *pri, q931_call *call, unsigned char *data, int len, struct addressingdataelements_presentednumberunscreened *value)
++static int rose_namedata_decode(struct pri *pri, unsigned char *data, int len, int implicit, struct nameelements_namedata *value)
+ {
+ 	int i = 0;
+ 	struct rose_component *comp = NULL;
+ 	unsigned char *vdata = data;
+-	int datalen = 0;
+-	int res = 0;
++	int res;
+ 
+ 	do {
++		/* NameData */
++		if (!implicit) {
++			GET_COMPONENT(comp, i, vdata, len);
++			CHECK_COMPONENT(comp, ASN1_OCTETSTRING, "Don't know what to do if NameData is of type 0x%x\n");
++
++			data = comp->data;
++			if (comp->len == ASN1_LEN_INDEF) {
++				len = strlen((char *)comp->data);
++				res = len + 2 + 2;
++			} else {
++				len = comp->len;
++				res = len + 2;
++			}
++		} else
++			res = len;
++
++		if (len > sizeof(value->name)-1) {
++			pri_message(pri, "!! Oversized NameData component (%d)\n", len);
++			return -1;
++		}
++
++		memcpy(value->name, data, len);
++		value->name[len] = '\0';
++
++		return res;
++	}
++	while(0);
++
++	return -1;
++}
++
++static int rose_namedata_encode(struct pri *pri, unsigned char *dst, int implicit, char *name)
++{
++	int size = 0;
++	struct rose_component *comp;
++	int namesize;
++
++	namesize = strlen(name);
++	if (namesize > 50 ) {
++		pri_message(pri, "!! Encoding of oversized NameData component failed (%d)\n", namesize);
++		return -1;
++	} else if (namesize == 0){
++		pri_message(pri, "!! Encoding of undersized NameData component failed (%d)\n", namesize);
++		return -1;
++	}
++
++	if (!implicit) {
++		/* constructor component  (0x04,len) */
++		comp = (struct rose_component *)dst;
++		comp->type = ASN1_OCTETSTRING;
++		comp->len = 2 + namesize;
++		size += 2;
++		dst += 2;
++	}
++
++	memcpy(dst, name, namesize);
++	size += namesize;
++
++	return size;
++}
++
++static int rose_nameset_decode(struct pri *pri, unsigned char *data, int len, int implicit, struct nameelements_nameset *value)
++{
++	int size;
++	int i = 0;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = data;
++ 	int characterset;
++
++	value->characterset = CHARACTER_SET_ISO8859_1;
++
++	do {
++		/* NameSet */
++		if (!implicit) {
++			GET_COMPONENT(comp, i, vdata, len);
++			CHECK_COMPONENT(comp, ASN1_SEQUENCE, "Don't know what to do if NameSet is of type 0x%x\n");
++			SUB_COMPONENT(comp, i);
++		}
++
++		/* nameData NameData */
+ 		GET_COMPONENT(comp, i, vdata, len);
+-		CHECK_COMPONENT(comp, ASN1_NUMERICSTRING, "Don't know what to do with PublicPartyNumber ROSE component type 0x%x\n");
+-		if(comp->len > 20 && comp->len != ASN1_LEN_INDEF) {
+-			pri_message(pri, "!! Oversized NumberDigits component (%d)\n", comp->len);
++		size = rose_namedata_decode(pri, (u_int8_t *)comp, len, 0, (struct nameelements_namedata *)value);
++		if (size < 0)
+ 			return -1;
++		i += size;
++
++		if (i < len) {
++			/* characterSet CharacterSet OPTIONAL */
++			GET_COMPONENT(comp, i, vdata, len);
++			CHECK_COMPONENT(comp, ASN1_INTEGER, "Don't know what to do if CharacterSet is of type 0x%x\n");
++			ASN1_GET_INTEGER(comp, characterset);
++			NEXT_COMPONENT(comp, i);
++			if (pri->debug & PRI_DEBUG_APDU)
++				pri_message(pri, "     NameSet: Received characterSet=%s(%d)\n", characterset_to_str(characterset), characterset);
++			value->characterset = characterset;
+ 		}
+-		if (comp->len == ASN1_LEN_INDEF) {
+-			datalen = strlen((char *)comp->data);
+-			res = datalen + 2;
+-		} else
+-			res = datalen = comp->len;
+-			
+-		memcpy(value->partyaddress, comp->data, datalen);
+-		value->partyaddress[datalen] = '\0';
+ 
+-		return res + 2;
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "     NameSet: '%s', characterSet=%s(%d) i=%d len=%d\n", value->name, characterset_to_str(value->characterset), value->characterset, i, len);
++
++		return i;
+ 	}
+ 	while(0);
+ 	
+ 	return -1;
+ }
+ 
+-static int rose_public_party_number_decode(struct pri *pri, q931_call *call, unsigned char *data, int len, struct addressingdataelements_presentednumberunscreened *value)
++static int rose_name_decode(struct pri *pri, unsigned char *data, int len, struct nameelements_name *value)
+ {
+ 	int i = 0;
++	int size = 0;
+ 	struct rose_component *comp = NULL;
+ 	unsigned char *vdata = data;
++
++	value->name[0] = '\0';
++	value->characterset = CHARACTER_SET_UNKNOWN;
++	value->namepres = -1;
++
++	do {
++		GET_COMPONENT(comp, i, vdata, len);
++
++		switch(comp->type) {
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0):			/* [0] namePresentationAllowedSimple */
++			size = rose_namedata_decode(pri, comp->data, comp->len, 1, (struct nameelements_namedata *)value);
++			if (size < 0)
++				return -1;
++			i += (size + 2);
++			value->characterset = CHARACTER_SET_ISO8859_1;
++			value->namepres = 1;
++			break;
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1):	/* [1] namePresentationAllowedExtended */
++			size = rose_nameset_decode(pri, comp->data, comp->len, 1, (struct nameelements_nameset *)value);
++			if (size < 0)
++				return -1;
++			i += (size + 2);
++			value->namepres = 1;
++			break;
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2):			/* [2] namePresentationRestrictedSimple */
++			size = rose_namedata_decode(pri, comp->data, comp->len, 1, (struct nameelements_namedata *)value);
++			if (size < 0)
++				return -1;
++			i += (size + 2);
++			value->characterset = CHARACTER_SET_ISO8859_1;
++			value->namepres = 0;
++			break;
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_3):	/* [3] namePresentationRestrictedExtended */
++			size = rose_nameset_decode(pri, comp->data, comp->len, 1, (struct nameelements_nameset *)value);
++			if (size < 0)
++				return -1;
++			i += (size + 2);
++			value->namepres = 0;
++			break;
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_4):			/* [4] nameNotAvailable */
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_7):			/* [7] namePresentationRestrictedNull */
++			i += (comp->len + 2);
++			value->name[0] = '\0';
++			value->characterset = CHARACTER_SET_UNKNOWN;
++			value->namepres = 0;
++			break;
++		default:
++			pri_message(pri, "!! Unknown Name component received 0x%x\n", comp->type);
++			return -1;
++		}
++
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "     Name: '%s' i=%d len=%d\n", value->name, i, len);
++		return i;
++	}
++	while (0);
++
++	return -1;
++}
++
++static int rose_number_digits_decode(struct pri *pri, unsigned char *data, int len, int implicit, struct addressingdataelements_presentednumberunscreened *value)
++{
++	int i = 0;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = data;
++	int res = 0;
++
++	do {
++		if (!implicit) {
++			GET_COMPONENT(comp, i, vdata, len);
++			CHECK_COMPONENT(comp, ASN1_NUMERICSTRING, "Don't know what to do with NumberDigits ROSE component type 0x%x\n");
++
++			data = comp->data;
++			if (comp->len == ASN1_LEN_INDEF) {
++				len = strlen((char *)comp->data);
++				res = len + 2 + 2;
++			} else {
++				len = comp->len;
++				res = len + 2;
++			}
++		} else
++			res = len;
++
++		if (len > sizeof(value->partyaddress)-1) {
++			pri_message(pri, "!! Oversized NumberDigits component (%d)\n", len);
++			return -1;
++		}
++
++		memcpy(value->partyaddress, data, len);
++		value->partyaddress[len] = '\0';
++
++		return res;
++	}
++	while(0);
++
++	return -1;
++}
++
++static int rose_public_party_number_decode(struct pri *pri, unsigned char *data, int len, int implicit, struct addressingdataelements_presentednumberunscreened *value)
++{
++	int i = 0;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = data;
+ 	int ton;
+ 	int res = 0;
+ 
+@@ -450,13 +781,19 @@
+ 		return -1;
+ 
+ 	do {
++		if (!implicit) {
++			GET_COMPONENT(comp, i, vdata, len);
++			CHECK_COMPONENT(comp, ASN1_SEQUENCE, "Don't know what to do if PublicPartyNumber is of type 0x%x\n");
++			SUB_COMPONENT(comp, i);
++		}
++
+ 		GET_COMPONENT(comp, i, vdata, len);
+ 		CHECK_COMPONENT(comp, ASN1_ENUMERATED, "Don't know what to do with PublicPartyNumber ROSE component type 0x%x\n");
+ 		ASN1_GET_INTEGER(comp, ton);
+ 		NEXT_COMPONENT(comp, i);
+ 		ton = typeofnumber_for_q931(pri, ton);
+ 
+-		res = rose_number_digits_decode(pri, call, &vdata[i], len-i, value);
++		res = rose_number_digits_decode(pri, &vdata[i], len-i, 0, value);
+ 		if (res < 0)
+ 			return -1;
+ 		value->ton = ton;
+@@ -467,8 +804,48 @@
+ 	return -1;
+ }
+ 
+-static int rose_private_party_number_decode(struct pri *pri, q931_call *call, unsigned char *data, int len, struct addressingdataelements_presentednumberunscreened *value)
++static int rose_public_party_number_encode(struct pri *pri, unsigned char *dst, int implicit, unsigned char ton, char *num)
+ {
++	int i = 0, compsp = 0;
++	struct rose_component *comp, *compstk[10];
++	int numsize;
++
++	numsize = strlen(num);
++	if (numsize > 20 ) {
++		pri_message(pri, "!! Encoding of oversized PublicPartyNumber component failed (%d)\n", numsize);
++		return -1;
++	}
++
++	if (!implicit) {
++		/* constructor component  (0x30,len) */
++		ASN1_ADD_SIMPLE(comp, (ASN1_CONSTRUCTOR | ASN1_SEQUENCE), dst, i);
++		ASN1_PUSH(compstk, compsp, comp);
++	} else
++		comp = (struct rose_component *)dst;
++
++	/* publicTypeOfNumber   (0x0a,0x01,ton)*/
++	ASN1_ADD_BYTECOMP(comp, ASN1_ENUMERATED, dst, i, ton);
++
++	/* publicNumberDigits */
++
++	/* tag component NumericString  (0x12,len) */
++	ASN1_ADD_SIMPLE(comp, ASN1_NUMERICSTRING, dst, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* NumericString */
++	memcpy(comp->data, num, numsize);
++	i += numsize;
++
++	ASN1_FIXUP(compstk, compsp, dst, i);
++
++	if (!implicit)
++		ASN1_FIXUP(compstk, compsp, dst, i);
++
++	return i;
++}
++
++static int rose_private_party_number_decode(struct pri *pri, unsigned char *data, int len, int implicit, struct addressingdataelements_presentednumberunscreened *value)
++{
+ 	int i = 0;
+ 	struct rose_component *comp = NULL;
+ 	unsigned char *vdata = data;
+@@ -476,18 +853,24 @@
+ 	int res = 0;
+ 
+ 	if (len < 2)
+-	return -1;
++		return -1;
+ 
+ 	do {
++		if (!implicit) {
++			GET_COMPONENT(comp, i, vdata, len);
++			CHECK_COMPONENT(comp, ASN1_SEQUENCE, "Don't know what to do if PrivatePartyNumber is of type 0x%x\n");
++			SUB_COMPONENT(comp, i);
++		}
++
+ 		GET_COMPONENT(comp, i, vdata, len);
+ 		CHECK_COMPONENT(comp, ASN1_ENUMERATED, "Don't know what to do with PrivatePartyNumber ROSE component type 0x%x\n");
+ 		ASN1_GET_INTEGER(comp, ton);
+ 		NEXT_COMPONENT(comp, i);
+ 		ton = typeofnumber_for_q931(pri, ton);
+ 
+-		res = rose_number_digits_decode(pri, call, &vdata[i], len-i, value);
++		res = rose_number_digits_decode(pri, &vdata[i], len-i, 0, value);
+ 		if (res < 0)
+-		  return -1;
++			return -1;
+ 		value->ton = ton;
+ 
+ 		return res + 3;
+@@ -496,7 +879,7 @@
+ 	return -1;
+ }
+ 
+-static int rose_address_decode(struct pri *pri, q931_call *call, unsigned char *data, int len, struct addressingdataelements_presentednumberunscreened *value)
++static int rose_address_decode(struct pri *pri, unsigned char *data, int len, struct addressingdataelements_presentednumberunscreened *value)
+ {
+ 	int i = 0;
+ 	struct rose_component *comp = NULL;
+@@ -506,65 +889,59 @@
+ 	do {
+ 		GET_COMPONENT(comp, i, vdata, len);
+ 
++		/* PartyNumber */
+ 		switch(comp->type) {
+-		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0):	/* [0] unknownPartyNumber */
+-			res = rose_number_digits_decode(pri, call, comp->data, comp->len, value);
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0):	/* [0] unknownPartyNumber, IMPLICIT NumberDigits */
++			res = rose_number_digits_decode(pri, comp->data, comp->len, 1, value);
+ 			if (res < 0)
+ 				return -1;
+ 			value->npi = PRI_NPI_UNKNOWN;
+ 			value->ton = PRI_TON_UNKNOWN;
+ 			break;
+-		case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0):	/* [0] unknownPartyNumber */
+-			res = asn1_copy_string(value->partyaddress, sizeof(value->partyaddress), comp);
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1):	/* [1] publicPartyNumber, IMPLICIT PublicPartyNumber */
++			res = rose_public_party_number_decode(pri, comp->data, comp->len, 1, value);
+ 			if (res < 0)
+ 				return -1;
+-			value->npi = PRI_NPI_UNKNOWN;
+-			value->ton = PRI_TON_UNKNOWN;
++			value->npi = PRI_NPI_E163_E164;
+ 			break;
+-		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1):	/* [1] publicPartyNumber */
+-			res = rose_public_party_number_decode(pri, call, comp->data, comp->len, value);
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_3):	/* [3] dataPartyNumber, IMPLICIT NumberDigits */
++			res = rose_number_digits_decode(pri, comp->data, comp->len, 1, value);
+ 			if (res < 0)
+ 				return -1;
+-			value->npi = PRI_NPI_E163_E164;
+-			break;
+-		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_2):	/* [2] nsapEncodedNumber */
+-			pri_message(pri, "!! NsapEncodedNumber isn't handled\n");
+-			return -1;
+-		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_3):	/* [3] dataPartyNumber */
+-			if(rose_number_digits_decode(pri, call, comp->data, comp->len, value))
+-				return -1;
+ 			value->npi = PRI_NPI_X121 /* ??? */;
+ 			value->ton = PRI_TON_UNKNOWN /* ??? */;
+ 			pri_message(pri, "!! dataPartyNumber isn't handled\n");
+ 			return -1;
+-		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_4):	/* [4] telexPartyNumber */
+-			res = rose_number_digits_decode(pri, call, comp->data, comp->len, value);
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_4):	/* [4] telexPartyNumber, IMPLICIT NumberDigits */
++			res = rose_number_digits_decode(pri, comp->data, comp->len, 1, value);
+ 			if (res < 0)
+ 				return -1;
+ 			value->npi = PRI_NPI_F69 /* ??? */;
+ 			value->ton = PRI_TON_UNKNOWN /* ??? */;
+ 			pri_message(pri, "!! telexPartyNumber isn't handled\n");
+ 			return -1;
+-		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_5):	/* [5] priavePartyNumber */
+-			res = rose_private_party_number_decode(pri, call, comp->data, comp->len, value);
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_5):	/* [5] privatePartyNumber, IMPLICIT PrivatePartyNumber */
++			res = rose_private_party_number_decode(pri, comp->data, comp->len, 1, value);
+ 			if (res < 0)
+-			return -1;
++				return -1;
+ 			value->npi = PRI_NPI_PRIVATE;
+ 			break;
+-		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_8):	/* [8] nationalStandardPartyNumber */
+-			res = rose_number_digits_decode(pri, call, comp->data, comp->len, value);
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_8):	/* [8] nationalStandardPartyNumber, IMPLICIT NumberDigits */
++			res = rose_number_digits_decode(pri, comp->data, comp->len, 1, value);
+ 			if (res < 0)
+ 				return -1;
+ 			value->npi = PRI_NPI_NATIONAL;
+ 			value->ton = PRI_TON_NATIONAL;
+ 			break;
+ 		default:
+-			pri_message(pri, "!! Unknown Party number component received 0x%X\n", comp->type);
++			pri_message(pri, "!! Unknown PartyNumber component received 0x%X\n", comp->type);
+ 			return -1;
+ 		}
+ 		ASN1_FIXUP_LEN(comp, res);
+ 		NEXT_COMPONENT(comp, i);
+-		if(i < len)
++
++		/* PartySubaddress OPTIONAL */
++		if (i < len)
+ 			pri_message(pri, "!! not all information is handled from Address component\n");
+ 		return res + 2;
+ 	}
+@@ -573,14 +950,176 @@
+ 	return -1;
+ }
+ 
+-static int rose_presented_number_unscreened_decode(struct pri *pri, q931_call *call, unsigned char *data, int len, struct addressingdataelements_presentednumberunscreened *value)
++static int rose_party_number_encode(struct pri *pri, unsigned char *dst, unsigned char ton, char *num)
+ {
++	int i = 0, compsp = 0;
++	struct rose_component *comp, *compstk[10];
++	int numsize, size;
++
++	numsize = strlen(num);
++	if (numsize > 20 ) {
++		pri_message(pri, "!! Encoding of oversized PartyNumber component failed (%d)\n", numsize);
++		return -1;
++	}
++
++#if 0
++	/* tag component unknownPartyNumber  (0x80,len) */
++	ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), dst, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* unknownPartyNumber, implicid NumberDigits */
++	memcpy(comp->data, num, numsize);
++	i += numsize;
++
++	ASN1_FIXUP(compstk, compsp, dst, i);
++#endif
++
++	/* tag component publicPartyNumber  (0xa1,len) */
++	ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1), dst, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* publicPartyNumber, implicid PublicPartyNumber */
++	size = rose_public_party_number_encode(pri, comp->data, 1, ton, num);
++	if (size < 0)
++		return -1;
++	i += size;
++
++	ASN1_FIXUP(compstk, compsp, dst, i);
++
++	return i;
++}
++
++static int rose_party_number_decode(struct pri *pri, unsigned char *data, int len, struct addressingdataelements_presentednumberunscreened *value)
++{
+ 	int i = 0;
+ 	int size = 0;
+ 	struct rose_component *comp = NULL;
+ 	unsigned char *vdata = data;
+ 
++	do {
++		GET_COMPONENT(comp, i, vdata, len);
++
++		switch(comp->type) {
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0):   /* [0] IMPLICIT NumberDigits -- default: unknownPartyNumber */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PartyNumber: UnknownPartyNumber len=%d\n", len);
++				size = rose_number_digits_decode(pri, comp->data, comp->len, 1, value);
++				if (size < 0)
++					return -1;
++				value->npi = PRI_NPI_UNKNOWN;
++				value->ton = PRI_TON_UNKNOWN;
++				break;
++
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1):   /* [1] IMPLICIT PublicPartyNumber */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PartyNumber: PublicPartyNumber len=%d\n", len);
++				size = rose_public_party_number_decode(pri, comp->data, comp->len, 1, value);
++				if (size < 0)
++					return -1;
++				value->npi = PRI_NPI_E163_E164;
++				break;
++
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_3):   /* [3] IMPLICIT NumberDigits -- not used: dataPartyNumber */
++				pri_message(pri, "!! PartyNumber: dataPartyNumber is reserved!\n");
++				size = rose_number_digits_decode(pri, comp->data, comp->len, 1, value);
++				if (size < 0)
++					return -1;
++				value->npi = PRI_NPI_X121 /* ??? */;
++				value->ton = PRI_TON_UNKNOWN /* ??? */;
++				break;
++
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_4):   /* [4] IMPLICIT NumberDigits -- not used: telexPartyNumber */
++				pri_message(pri, "!! PartyNumber: telexPartyNumber is reserved!\n");
++				size = rose_number_digits_decode(pri, comp->data, comp->len, 1, value);
++				if (size < 0)
++					return -1;
++				value->npi = PRI_NPI_F69 /* ??? */;
++				value->ton = PRI_TON_UNKNOWN /* ??? */;
++				break;
++
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_5):   /* [5] IMPLICIT PrivatePartyNumber */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PartyNumber: PrivatePartyNumber len=%d\n", len);
++				size = rose_private_party_number_decode(pri, comp->data, comp->len, 1, value);
++				if (size < 0)
++					return -1;
++ 				value->npi = PRI_NPI_PRIVATE;
++				break;
++
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_8):   /* [8] IMPLICIT NumberDigits -- not used: nationalStandatdPartyNumber */
++				pri_message(pri, "!! PartyNumber: nationalStandardPartyNumber is reserved!\n");
++				size = rose_number_digits_decode(pri, comp->data, comp->len, 1, value);
++				if (size < 0)
++					return -1;
++				value->npi = PRI_NPI_NATIONAL;
++				value->ton = PRI_TON_NATIONAL;
++				break;
++
++			default:
++				pri_message(pri, "Invalid PartyNumber component 0x%X\n", comp->type);
++				return -1;
++		}
++		ASN1_FIXUP_LEN(comp, size);
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "     PartyNumber: '%s' size=%d len=%d\n", value->partyaddress, size, len);
++		return size;
++	}
++	while (0);
++
++	return -1;
++}
++
++static int rose_presented_number_unscreened_encode(struct pri *pri, unsigned char *dst, unsigned char presentation, unsigned char ton, char *num)
++{
++	int i = 0, compsp = 0;
++	struct rose_component *comp, *compstk[10];
++	int numsize, size;
++
++	numsize = strlen(num);
++	if (numsize > 20 ) {
++		pri_message(pri, "!! Encoding of oversized PresentedNumberUnscreened component failed (%d)\n", numsize);
++		return -1;
++	}
++
++	switch (presentation & PRES_RESTRICTION) {
++		case PRES_ALLOWED:
++			/* tag component [0] presentationAllowedAddress (0xa0,len) */
++			ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0), dst, i);
++			ASN1_PUSH(compstk, compsp, comp);
++
++			/* PartyNumber */
++			size = rose_party_number_encode(pri, comp->data, ton, num);
++			if (size < 0)
++				return -1;
++			i += size;
++			ASN1_FIXUP(compstk, compsp, dst, i);
++			break;
++		case PRES_RESTRICTED:
++			/* tag component [1] presentationRestricted (0x81,len) */
++			ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_1), dst, i);
++			break;
++		case PRES_UNAVAILABLE:
++			/* tag component [2] numberNotAvailableDueToInterworking (0x82,len) */
++			ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2), dst, i);
++			/* ASN1_FIXUP(compstk, compsp, dst, i); */
++			break;
++		default:
++			pri_message(pri, "!! Undefined presentation value for PresentedNumberUnscreened: 0x%x\n", presentation);
++			return -1;
++	}
++
++	return i;
++}
++
++static int rose_presented_number_unscreened_decode(struct pri *pri, unsigned char *data, int len, struct addressingdataelements_presentednumberunscreened *value)
++{
++	int i = 0;
++	int size = 0;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = data;
++
+ 	/* Fill in default values */
++	value->partyaddress[0] = '\0';
+ 	value->ton = PRI_TON_UNKNOWN;
+ 	value->npi = PRI_NPI_E163_E164;
+ 	value->pres = -1;	/* Data is not available */
+@@ -591,7 +1130,7 @@
+ 		switch(comp->type) {
+ 		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0):		/* [0] presentationAllowedNumber */
+ 			value->pres = PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
+-			size = rose_address_decode(pri, call, comp->data, comp->len, value);
++			size = rose_address_decode(pri, comp->data, comp->len, value);
+ 			ASN1_FIXUP_LEN(comp, size);
+ 			return size + 2;
+ 		case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_1):		/* [1] IMPLICIT presentationRestricted */
+@@ -610,7 +1149,7 @@
+ 			return 2;
+ 		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_3):		/* [3] presentationRestrictedNumber */
+ 			value->pres = PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
+-			size = rose_address_decode(pri, call, comp->data, comp->len, value) + 2;
++			size = rose_address_decode(pri, comp->data, comp->len, value) + 2;
+ 			ASN1_FIXUP_LEN(comp, size);
+ 			return size + 2;
+ 		default:
+@@ -623,17 +1162,482 @@
+ 	return -1;
+ }
+ 
++static int rose_number_screened_encode(struct pri *pri, unsigned char *dst, int implicit, unsigned char ton, unsigned char screenind, char *num)
++{
++	int i = 0, compsp = 0;
++	struct rose_component *comp, *compstk[10];
++	int numsize, size;
++
++	numsize = strlen(num);
++	if (numsize > 20 ) {
++		pri_message(pri, "!! Encoding of oversized NumberScreened component failed (%d)\n", numsize);
++		return -1;
++	}
++
++	if (!implicit) {
++		/* constructor component  (0x30,len) */
++		ASN1_ADD_SIMPLE(comp, (ASN1_CONSTRUCTOR | ASN1_SEQUENCE), dst, i);
++		ASN1_PUSH(compstk, compsp, comp);
++	} else
++		comp = (struct rose_component *)dst;
++
++	/* PartyNumber */
++	size = rose_party_number_encode(pri, (u_int8_t *)comp, ton, num);
++	if (size < 0)
++		return -1;
++	i += size;
++
++	/* ScreeningIndicator  (0x0a,0x01,screenind) */
++	ASN1_ADD_BYTECOMP(comp, ASN1_ENUMERATED, dst, i, screenind);
++
++	if (!implicit)
++		ASN1_FIXUP(compstk, compsp, dst, i);
++
++	return i;
++}
++
++static int rose_number_screened_decode(struct pri *pri, unsigned char *data, int len, struct addressingdataelements_presentednumberscreened *value)
++{
++	int i = 0;
++	int size = 0;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = data;
++
++	int scrind = -1;
++
++	do {
++		/* Party Number */
++		GET_COMPONENT(comp, i, vdata, len);
++		size = rose_party_number_decode(pri, (u_int8_t *)comp, comp->len + 2, (struct addressingdataelements_presentednumberunscreened*) value);
++		if (size < 0)
++			return -1;
++		comp->len = size;
++		NEXT_COMPONENT(comp, i);
++
++		/* Screening Indicator */
++		GET_COMPONENT(comp, i, vdata, len);
++		CHECK_COMPONENT(comp, ASN1_ENUMERATED, "Don't know what to do with NumberScreened ROSE component type 0x%x\n");
++		ASN1_GET_INTEGER(comp, scrind);
++		// Todo: scrind = screeningindicator_for_q931(pri, scrind);
++		NEXT_COMPONENT(comp, i);
++
++		value->scrind = scrind;
++
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "     NumberScreened: '%s' ScreeningIndicator=%d  i=%d  len=%d\n", value->partyaddress, scrind, i, len);
++
++		return i-2;  // We do not have a sequence header here.
++	}
++	while (0);
++
++	return -1;
++}
++
++static int rose_presented_number_screened_decode(struct pri *pri, unsigned char *data, int len, struct addressingdataelements_presentednumberscreened *value)
++{
++	int i = 0;
++	int size = 0;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = data;
++
++	/* Fill in default values */
++	value->partyaddress[0] = '\0';
++	value->ton = PRI_TON_UNKNOWN;
++	value->npi = PRI_NPI_UNKNOWN;
++	value->pres = -1; /* Data is not available */
++	value->scrind = 0;
++
++	do {
++		GET_COMPONENT(comp, i, vdata, len);
++
++		switch(comp->type) {
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0):   /* [0] IMPLICIT presentationAllowedNumber */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PresentedNumberScreened: presentationAllowedNumber comp->len=%d\n", comp->len);
++				value->pres = PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
++				size = rose_number_screened_decode(pri, comp->data, comp->len, value);
++				if (size < 0)
++					return -1;
++				ASN1_FIXUP_LEN(comp, size);
++				return size + 2;
++
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_1):    /* [1] IMPLICIT presentationRestricted */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PresentedNumberScreened: presentationRestricted comp->len=%d\n", comp->len);
++				if (comp->len != 0) { /* must be NULL */
++					pri_error(pri, "!! Invalid PresentationRestricted component received (len != 0)\n");
++					return -1;
++				}
++				value->pres = PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
++				return 2;
++
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2):    /* [2] IMPLICIT numberNotAvailableDueToInterworking */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PresentedNumberScreened: NumberNotAvailableDueToInterworking comp->len=%d\n", comp->len);
++				if (comp->len != 0) { /* must be NULL */
++					pri_error(pri, "!! Invalid NumberNotAvailableDueToInterworking component received (len != 0)\n");
++					return -1;
++				}
++				value->pres = PRES_NUMBER_NOT_AVAILABLE;
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PresentedNumberScreened: numberNotAvailableDueToInterworking Type=0x%X  i=%d len=%d size=%d\n", comp->type, i, len);
++				return 2;
++
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_3):    /* [3] IMPLICIT presentationRestrictedNumber */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PresentedNumberScreened: presentationRestrictedNumber comp->len=%d\n", comp->len);
++				value->pres = PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
++				size = rose_number_screened_decode(pri, comp->data, comp->len, value);
++				if (size < 0)
++					return -1;
++				ASN1_FIXUP_LEN(comp, size);
++				return size + 2;
++
++			default:
++				pri_message(pri, "Invalid PresentedNumberScreened component 0x%X\n", comp->type);
++		}
++		return -1;
++	}
++	while (0);
++
++	return -1;
++}
++
++static int rose_partysubaddress_decode(struct pri *pri, unsigned char *data, int len, struct addressingdataelements_partysubaddress *value)
++{
++	int i = 0;
++	int size = 0;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = data;
++
++	int odd_count_indicator = -1;
++	value->partysubaddress[0] = '\0';
++
++	do {
++		GET_COMPONENT(comp, i, vdata, len);
++
++		switch(comp->type) {
++		case (ASN1_CONSTRUCTOR | ASN1_SEQUENCE):    /* UserSpecifiedSubaddress */
++			/* SubaddressInformation */
++			SUB_COMPONENT(comp, i);
++			GET_COMPONENT(comp, i, vdata, len);
++			CHECK_COMPONENT(comp, ASN1_OCTETSTRING, "Don't know what to do if SubaddressInformation is of type 0x%x\n");
++			size = asn1_name_decode(comp->data, comp->len, value->partysubaddress, sizeof(value->partysubaddress));
++			if (size < 0)
++				return -1;
++			i += size;
++
++			/* oddCountIndicator BOOLEAN OPTIONAL */
++			if (i < len) {
++				GET_COMPONENT(comp, i, vdata, len);
++				CHECK_COMPONENT(comp, ASN1_BOOLEAN, "Don't know what to do if SubaddressInformation is of type 0x%x\n");
++
++				ASN1_GET_INTEGER(comp, odd_count_indicator);
++				NEXT_COMPONENT(comp, i);
++			}
++		case (ASN1_OCTETSTRING):    /* NSAPSubaddress */
++			size = asn1_name_decode((u_int8_t *)comp, comp->len + 2, value->partysubaddress, sizeof(value->partysubaddress));
++			if (size < 0)
++				return -1;
++			i += size;
++			break;
++		default:
++			pri_message(pri, "Invalid PartySubaddress component 0x%X\n", comp->type);
++			return -1;
++		}
++
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "     PartySubaddress: '%s', oddCountIndicator=%d, i=%d len=%d\n", value->partysubaddress, odd_count_indicator, i, len);
++
++		return i;
++	}
++	while (0);
++
++	return -1;
++}
++
++static int rose_address_screened_decode(struct pri *pri, unsigned char *data, int len, struct addressingdataelements_addressscreened *value)
++{
++	int i = 0;
++	int size = 0;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = data;
++
++	int scrind;
++	value->partysubaddress[0] = '\0';
++
++	/* SEQUENCE AddressScreened */
++	do {
++		/* PartyNumber */
++		GET_COMPONENT(comp, i, vdata, len);
++		size = rose_party_number_decode(pri, (u_int8_t *)comp, comp->len + 2, (struct addressingdataelements_presentednumberunscreened *)value);
++		if (size < 0)
++			return -1;
++		comp->len = size;
++		NEXT_COMPONENT(comp, i);
++
++		/* ScreeningIndicator */
++		GET_COMPONENT(comp, i, vdata, len);
++		CHECK_COMPONENT(comp, ASN1_ENUMERATED, "Don't know what to do with AddressScreened ROSE component type 0x%x\n");
++		ASN1_GET_INTEGER(comp, scrind);
++		NEXT_COMPONENT(comp, i);
++
++		if (i < len) {
++			/* PartySubaddress OPTIONAL */
++			GET_COMPONENT(comp, i, vdata, len);
++			size = rose_partysubaddress_decode(pri, (u_int8_t *)comp, comp->len + 2, (struct addressingdataelements_partysubaddress *)value);
++			if (size < 0)
++				return -1;
++			i += size;
++		}
++
++		value->scrind = scrind;
++
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "     AddressScreened: '%s' ScreeningIndicator=%d  i=%d  len=%d\n", value->partyaddress, scrind, i, len);
++
++		return i-2;
++	}
++	while (0);
++
++	return -1;
++}
++
++static int rose_presented_address_screened_decode(struct pri *pri, unsigned char *data, int len, struct addressingdataelements_presentedaddressscreened *value)
++{
++	int i = 0;
++	int size = 0;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = data;
++
++	/* Fill in default values */
++	value->partyaddress[0] = '\0';
++	value->partysubaddress[0] = '\0';
++	value->npi = PRI_NPI_UNKNOWN;
++	value->ton = PRI_TON_UNKNOWN;
++	value->pres = -1; /* Data is not available */
++	value->scrind = 0;
++
++	do {
++		GET_COMPONENT(comp, i, vdata, len);
++
++		switch(comp->type) {
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0):   /* [0] IMPLICIT presentationAllowedAddress */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PresentedAddressScreened: presentationAllowedAddress comp->len=%d\n", comp->len);
++				value->pres = PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
++				size = rose_address_screened_decode(pri, comp->data, comp->len, (struct addressingdataelements_addressscreened *)value);
++				if (size < 0)
++					return -1;
++				ASN1_FIXUP_LEN(comp, size);
++				return size + 2;
++
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_1):    /* [1] IMPLICIT presentationRestricted */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PresentedAddressScreened: presentationRestricted comp->len=%d\n", comp->len);
++				if (comp->len != 0) { /* must be NULL */
++					pri_error(pri, "!! Invalid PresentationRestricted component received (len != 0)\n");
++					return -1;
++				}
++				value->pres = PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
++				return 2;
++
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2):    /* [2] IMPLICIT numberNotAvailableDueToInterworking */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PresentedAddressScreened: NumberNotAvailableDueToInterworking comp->len=%d\n", comp->len);
++				if (comp->len != 0) { /* must be NULL */
++					pri_error(pri, "!! Invalid NumberNotAvailableDueToInterworking component received (len != 0)\n");
++					return -1;
++				}
++				value->pres = PRES_NUMBER_NOT_AVAILABLE;
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PresentedAddressScreened: numberNotAvailableDueToInterworking Type=0x%X  i=%d len=%d size=%d\n", comp->type, i, len);
++				return 2;
++
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_3):    /* [3] IMPLICIT presentationRestrictedAddress */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     PresentedAddressScreened: presentationRestrictedAddress comp->len=%d\n", comp->len);
++				value->pres = PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
++				size = rose_address_screened_decode(pri, comp->data, comp->len, (struct addressingdataelements_addressscreened *)value);
++				if (size < 0)
++					return -1;
++				ASN1_FIXUP_LEN(comp, size);
++				return size + 2;
++
++			default:
++				pri_message(pri, "Invalid PresentedAddressScreened component 0x%X\n", comp->type);
++		}
++		return -1;
++	}
++	while (0);
++
++	return -1;
++}
++
++static int rose_diverting_leg_information1_decode(struct pri *pri, q931_call *call, struct rose_component *sequence, int len)
++{
++	int i = 0;
++	struct addressingdataelements_presentednumberunscreened nominatednr;
++	int diversion_reason;
++	int subscription_option;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = sequence->data;
++	int size = 0;
++	memset(&nominatednr, 0, sizeof(nominatednr));
++
++	/* Data checks */
++	if (sequence->type != (ASN1_CONSTRUCTOR | ASN1_SEQUENCE)) { /* Constructed Sequence */
++		pri_message(pri, "Invalid DivertingLegInformation1Type argument\n");
++		return -1;
++	}
++
++	if (sequence->len == ASN1_LEN_INDEF) {
++		len -= 4;   /* For the 2 extra characters at the end
++		               and two characters of header */
++	} else
++		len -= 2;
++
++	do {
++		/* diversionReason DiversionReason */
++		GET_COMPONENT(comp, i, vdata, len);
++		CHECK_COMPONENT(comp, ASN1_ENUMERATED, "Invalid diversionReason type 0x%X of ROSE divertingLegInformation1 component received\n");
++		ASN1_GET_INTEGER(comp, diversion_reason);
++		NEXT_COMPONENT(comp, i);
++
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "    Received diversionReason: %s(%d)\n", diversionreason_to_str(pri, diversion_reason), diversion_reason);
++
++		diversion_reason = redirectingreason_for_q931(pri, diversion_reason);
++
++		/* subscriptionOption SubscriptionOption */
++		GET_COMPONENT(comp, i, vdata, len);
++		CHECK_COMPONENT(comp, ASN1_ENUMERATED, "Invalid subscriptionOption type 0x%X of ROSE divertingLegInformation1 component received\n");
++		ASN1_GET_INTEGER(comp, subscription_option);
++		NEXT_COMPONENT(comp, i);
++
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "    Received subscriptionOption: %d\n", subscription_option);
++
++		/* nominatedNr PartyNumber */
++		GET_COMPONENT(comp, i, vdata, len);
++		size = rose_party_number_decode(pri, (u_int8_t *)comp, comp->len + 2, &nominatednr);
++		if (size < 0)
++			return -1;
++
++		if (pri->debug & PRI_DEBUG_APDU) {
++			pri_message(pri, "    Received nominatedNr '%s'\n", nominatednr.partyaddress);
++			pri_message(pri, "      ton = %d, npi = %d\n\n", nominatednr.ton, nominatednr.npi);
++		}
++
++		call->divleginfo1activeflag = 1;
++		if (subscription_option == QSIG_NOTIFICATION_WITH_DIVERTED_TO_NR) {
++			libpri_copy_string(call->divertedtonum, nominatednr.partyaddress, sizeof(call->divertedtonum));
++		} else {
++			call->divertedtonum[0] = '\0';
++		}
++		call->divertedtopres = (subscription_option == QSIG_NOTIFICATION_WITH_DIVERTED_TO_NR) ? PRES_ALLOWED_USER_NUMBER_NOT_SCREENED : PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
++		call->divertedtoplan = ((nominatednr.ton & 0x07) << 4) | (nominatednr.npi & 0x0f);
++		call->divertedtoreason = diversion_reason;
++		call->divertedtocount++;
++
++		return 0;
++	}
++	while (0);
++
++	return -1;
++}
++
++int rose_diverting_leg_information1_encode(struct pri *pri, q931_call *call)
++{
++	int i = 0, compsp = 0;
++	struct rose_component *comp, *compstk[10];
++	unsigned char buffer[256];
++	int size;
++
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "    Encode divertingLegInformation1\n");
++
++	/* Protocol Profile = 0x1f (Networking Extensions)  (0x9f) */
++	buffer[i++] = (ASN1_CONTEXT_SPECIFIC | Q932_PROTOCOL_EXTENSIONS);
++
++	/* Network Facility Extension */
++	if (pri->switchtype == PRI_SWITCH_QSIG) {
++		/* tag component NetworkFacilityExtension (0xaa, len ) */
++		ASN1_ADD_SIMPLE(comp, COMP_TYPE_NFE, buffer, i);
++		ASN1_PUSH(compstk, compsp, comp);
++
++		/* sourceEntity  (0x80,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i, 0);	/* endPINX(0) */
++
++		/* destinationEntity  (0x82,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2), buffer, i, 0);	/* endPINX(0) */
++		ASN1_FIXUP(compstk, compsp, buffer, i);
++	}
++
++	/* Network Protocol Profile */
++	/*  - not included - */
++
++	/* Interpretation APDU  (0x8b,0x01,0x00) */
++	ASN1_ADD_BYTECOMP(comp, COMP_TYPE_INTERPRETATION, buffer, i, 0);	/* discardAnyUnrecognisedInvokePdu(0) */
++
++	/* Service APDU(s): */
++
++	/* ROSE InvokePDU  (0xa1,len) */
++	ASN1_ADD_SIMPLE(comp, COMP_TYPE_INVOKE, buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* ROSE InvokeID  (0x02,0x01,invokeid) */
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, get_invokeid(pri));
++
++	/* ROSE operationId  (0x02,0x01,0x14)*/
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, ROSE_DIVERTING_LEG_INFORMATION1);
++
++	/* constructor component  (0x30,len) */
++	ASN1_ADD_SIMPLE(comp, (ASN1_CONSTRUCTOR | ASN1_SEQUENCE), buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* diversionReason  (0x0a,0x01,diversionreason) */
++	ASN1_ADD_BYTECOMP(comp, ASN1_ENUMERATED, buffer, i, redirectingreason_from_q931(pri, call->divertedtoreason));
++
++	/* subscriptionOption  (0x0a,0x01,subscriptionoption) */
++	ASN1_ADD_BYTECOMP(comp, ASN1_ENUMERATED, buffer, i, presentation_to_subscription(pri, call->divertedtopres));
++
++	/* nominatedNr */
++
++	/* tag component publicPartyNumber  (0xa1,len) */
++	ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1), buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* publicPartyNumber, implicid PublicPartyNumber */
++	size = rose_public_party_number_encode(pri, &buffer[i], 1, (call->divertedtoplan & 0x70) >> 4, call->divertedtonum);
++	if (size < 0)
++		return -1;
++	i += size;
++
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++
++	if (pri_call_apdu_queue(call, Q931_FACILITY, buffer, i, NULL, NULL))
++		return -1;
++
++	return 0;
++}
++
+ static int rose_diverting_leg_information2_decode(struct pri *pri, q931_call *call, struct rose_component *sequence, int len)
+ {
+ 	int i = 0;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = sequence->data;
++	int size = 0;
++
+ 	int diversion_counter;
+ 	int diversion_reason;
+-	char origcalledname[50] = "", redirectingname[50] = "";
++	int original_diversion_reason = QSIG_DIVERT_REASON_UNKNOWN;
++	struct nameelements_name redirectingname = { "", CHARACTER_SET_UNKNOWN, 0 };
++	struct nameelements_name origcalledname = { "", CHARACTER_SET_UNKNOWN, 0 };;
+ 	struct addressingdataelements_presentednumberunscreened divertingnr;
+- 	struct addressingdataelements_presentednumberunscreened originalcallednr;
+-	struct rose_component *comp = NULL;
+-	unsigned char *vdata = sequence->data;
+-	int res = 0;
++	struct addressingdataelements_presentednumberunscreened originalcallednr;
+ 	memset(&divertingnr, 0, sizeof(divertingnr));
+ 	memset(&originalcallednr, 0, sizeof(originalcallednr));
+ 
+@@ -644,249 +1648,429 @@
+ 	}
+ 
+ 	if (sequence->len == ASN1_LEN_INDEF) {
+-		len -= 4; /* For the 2 extra characters at the end
+-                           * and two characters of header */
++		len -= 4;   /* For the 2 extra characters at the end
++		               and two characters of header */
+ 	} else
+ 		len -= 2;
+ 
+ 	do {
+-		/* diversionCounter stuff */
++		/* diversionCounter */
+ 		GET_COMPONENT(comp, i, vdata, len);
+-		CHECK_COMPONENT(comp, ASN1_INTEGER, "Don't know what to do it diversionCounter is of type 0x%x\n");
++		CHECK_COMPONENT(comp, ASN1_INTEGER, "Don't know what to do if diversionCounter is of type 0x%x\n");
+ 		ASN1_GET_INTEGER(comp, diversion_counter);
+ 		NEXT_COMPONENT(comp, i);
+ 
+-		/* diversionReason stuff */
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "    Received diversionCounter: %d\n",  diversion_counter);
++
++		/* diversionReason DiversionReason */
+ 		GET_COMPONENT(comp, i, vdata, len);
+ 		CHECK_COMPONENT(comp, ASN1_ENUMERATED, "Invalid diversionReason type 0x%X of ROSE divertingLegInformation2 component received\n");
+ 		ASN1_GET_INTEGER(comp, diversion_reason);
+ 		NEXT_COMPONENT(comp, i);
+ 
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "    Received diversionReason: %s(%d)\n", diversionreason_to_str(pri, diversion_reason), diversion_reason);
++
+ 		diversion_reason = redirectingreason_for_q931(pri, diversion_reason);
+-	
+-		if(pri->debug & PRI_DEBUG_APDU)
+-			pri_message(pri, "    Redirection reason: %d, total diversions: %d\n", diversion_reason, diversion_counter);
+-		pri_message(NULL, "Length of message is %d\n", len);
+ 
+-		for(; i < len; NEXT_COMPONENT(comp, i)) {
++		/* Type SEQUENCE specifies an ordered list of component types.           *
++		 * We decode all components but for simplicity we don't check the order. */
++		while (i < len) {
+ 			GET_COMPONENT(comp, i, vdata, len);
++
+ 			switch(comp->type) {
+ 			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0):
+-				call->origredirectingreason = redirectingreason_for_q931(pri, comp->data[0]);
++				/* originalDiversionReason */
++				ASN1_GET_INTEGER(comp, original_diversion_reason);
++				NEXT_COMPONENT(comp,i);
+ 				if (pri->debug & PRI_DEBUG_APDU)
+-					pri_message(pri, "    Received reason for original redirection %d\n", call->origredirectingreason);
++					pri_message(pri, "    Received originalDiversionReason: %s(%d)\n", diversionreason_to_str(pri, original_diversion_reason), original_diversion_reason);
++				original_diversion_reason = redirectingreason_for_q931(pri, original_diversion_reason);
+ 				break;
+ 			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1):
+-				res = rose_presented_number_unscreened_decode(pri, call, comp->data, comp->len, &divertingnr);
+-				/* TODO: Fix indefinite length form hacks */
+-				ASN1_FIXUP_LEN(comp, res);
+-				comp->len = res;
+-				if (res < 0)
++				/* divertingNr */
++				size = rose_presented_number_unscreened_decode(pri, comp->data, comp->len, &divertingnr);
++				if (size < 0)
+ 					return -1;
++				ASN1_FIXUP_LEN(comp, size);
++				comp->len = size;
++				NEXT_COMPONENT(comp,i);
+ 				if (pri->debug & PRI_DEBUG_APDU) {
+ 					pri_message(pri, "    Received divertingNr '%s'\n", divertingnr.partyaddress);
+ 					pri_message(pri, "      ton = %d, pres = %d, npi = %d\n", divertingnr.ton, divertingnr.pres, divertingnr.npi);
+ 				}
+ 				break;
+ 			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_2):
+-				res = rose_presented_number_unscreened_decode(pri, call, comp->data, comp->len, &originalcallednr);
+-				if (res < 0)
++				/* originalCalledNr */
++				size = rose_presented_number_unscreened_decode(pri, comp->data, comp->len, &originalcallednr);
++				if (size < 0)
+ 					return -1;
+-				ASN1_FIXUP_LEN(comp, res);
+-				comp->len = res;
++				ASN1_FIXUP_LEN(comp, size);
++				comp->len = size;
++				NEXT_COMPONENT(comp,i);
+ 				if (pri->debug & PRI_DEBUG_APDU) {
+-					pri_message(pri, "    Received originalcallednr '%s'\n", originalcallednr.partyaddress);
++					pri_message(pri, "    Received originalCalledNr '%s'\n", originalcallednr.partyaddress);
+ 					pri_message(pri, "      ton = %d, pres = %d, npi = %d\n", originalcallednr.ton, originalcallednr.pres, originalcallednr.npi);
+ 				}
+ 				break;
+ 			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_3):
+-				res = asn1_name_decode(comp->data, comp->len, redirectingname, sizeof(redirectingname));
+-				if (res < 0)
++				/* redirectingName */
++				size = rose_name_decode(pri, comp->data, comp->len, &redirectingname);
++				if (size < 0)
+ 					return -1;
+-				ASN1_FIXUP_LEN(comp, res);
+-				comp->len = res;
++				i += (size + 2);
+ 				if (pri->debug & PRI_DEBUG_APDU)
+-					pri_message(pri, "    Received RedirectingName '%s'\n", redirectingname);
++					pri_message(pri, "     Received RedirectingName '%s', namepres %s(%d), characterset %s(%d)\n",
++						        redirectingname.name, namepres_to_str(redirectingname.namepres), redirectingname.namepres,
++						        characterset_to_str(redirectingname.characterset), redirectingname.characterset);
+ 				break;
+ 			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_4):
+-				res = asn1_name_decode(comp->data, comp->len, origcalledname, sizeof(origcalledname));
+-				if (res < 0)
++				/* originalCalledName */
++				size = rose_name_decode(pri, comp->data, comp->len, &origcalledname);
++				if (size < 0)
+ 					return -1;
+-				ASN1_FIXUP_LEN(comp, res);
+-				comp->len = res;
++				i += (size + 2);
+ 				if (pri->debug & PRI_DEBUG_APDU)
+-					pri_message(pri, "    Received Originally Called Name '%s'\n", origcalledname);
++					pri_message(pri, "     Received OriginalCalledName '%s', namepres %s(%d), characterset %s(%d)\n",
++						        origcalledname.name, namepres_to_str(origcalledname.namepres), origcalledname.namepres,
++						        characterset_to_str(origcalledname.characterset), origcalledname.characterset);
+ 				break;
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_5):
+-				pri_message(pri, "!! Ignoring DivertingLegInformation2 component 0x%X\n", comp->type);
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_5):	/* [5] IMPLICIT Extension */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_6):	/* [6] IMPLICIT SEQUENCE OF Extension */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "!!     Ignoring DivertingLegInformation2 component 0x%X\n", comp->type);
++				NEXT_COMPONENT(comp, i);
+ 				break;
+ 			default:
+-				if (comp->type == 0 && comp->len == 0) {
+-					break; /* Found termination characters */
+-				}
+-				pri_message(pri, "!! Invalid DivertingLegInformation2 component received 0x%X\n", comp->type);
++				pri_message(pri, "!!     Invalid DivertingLegInformation2 component received 0x%X\n", comp->type);
+ 				return -1;
+ 			}
+ 		}
+ 
+ 		if (divertingnr.pres >= 0) {
+-			call->redirectingplan = divertingnr.npi;
++			call->redirectingplan = ((divertingnr.ton & 0x07) << 4) | (divertingnr.npi & 0x0f);
+ 			call->redirectingpres = divertingnr.pres;
+ 			call->redirectingreason = diversion_reason;
+ 			libpri_copy_string(call->redirectingnum, divertingnr.partyaddress, sizeof(call->redirectingnum));
+-			pri_message(pri, "    Received redirectingnum '%s' (%d)\n", call->redirectingnum, (int)call->redirectingnum[0]);
+ 		}
+ 		if (originalcallednr.pres >= 0) {
+-			call->origcalledplan = originalcallednr.npi;
++			call->origcalledplan = ((originalcallednr.ton & 0x07) << 4) | (originalcallednr.npi & 0x0f);
+ 			call->origcalledpres = originalcallednr.pres;
+ 			libpri_copy_string(call->origcallednum, originalcallednr.partyaddress, sizeof(call->origcallednum));
+-			pri_message(pri, "    Received origcallednum '%s' (%d)\n", call->origcallednum, (int)call->origcallednum[0]);
+ 		}
+-		libpri_copy_string(call->redirectingname, redirectingname, sizeof(call->redirectingname));
+-		libpri_copy_string(call->origcalledname, origcalledname, sizeof(call->origcalledname));
++
++		if (redirectingname.namepres != 0) {
++			libpri_copy_string(call->redirectingname, redirectingname.name, sizeof(call->redirectingname));
++		} else {
++			call->redirectingname[0] = '\0';
++		}
++
++		if (origcalledname.namepres != 0) {
++			libpri_copy_string(call->origcalledname, origcalledname.name, sizeof(call->origcalledname));
++		} else {
++			call->origcalledname[0] = '\0';
++		}
++
++		call->origredirectingreason = original_diversion_reason;
++		call->redirectingcount = diversion_counter;
++
+ 		return 0;
+ 	}
+ 	while (0);
+ 
+ 	return -1;
+ }
+-				
++
+ static int rose_diverting_leg_information2_encode(struct pri *pri, q931_call *call)
+ {
+-	int i = 0, j, compsp = 0;
++	int i = 0, compsp = 0;
+ 	struct rose_component *comp, *compstk[10];
+ 	unsigned char buffer[256];
+-	int len = 253;
+-	
+-#if 0	/* This is not required by specifications */
+-	if (!strlen(call->callername)) {
+-		return -1;
++	int size;
++
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "    Encode divertingLegInformation2\n");
++
++	/* Protocol Profile = 0x1f (Networking Extensions)  (0x9f) */
++	buffer[i++] = (ASN1_CONTEXT_SPECIFIC | Q932_PROTOCOL_EXTENSIONS);
++
++	/* Network Facility Extension */
++	if (pri->switchtype == PRI_SWITCH_QSIG) {
++		/* tag component NetworkFacilityExtension (0xaa, len ) */
++		ASN1_ADD_SIMPLE(comp, COMP_TYPE_NFE, buffer, i);
++		ASN1_PUSH(compstk, compsp, comp);
++
++		/* sourceEntity  (0x80,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i, 0);	/* endPINX(0) */
++
++		/* destinationEntity  (0x82,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2), buffer, i, 0);	/* endPINX(0) */
++		ASN1_FIXUP(compstk, compsp, buffer, i);
+ 	}
+-#endif
+ 
+-	buffer[i] = (ASN1_CONTEXT_SPECIFIC | Q932_PROTOCOL_EXTENSIONS);
+-	i++;
+-	/* Interpretation component */
+-	ASN1_ADD_BYTECOMP(comp, COMP_TYPE_INTERPRETATION, buffer, i, 0x00 /* Discard unrecognized invokes */);
+-	
++	/* Network Protocol Profile */
++	/*  - not included - */
++
++	/* Interpretation APDU  (0x8b,0x01,0x00) */
++	ASN1_ADD_BYTECOMP(comp, COMP_TYPE_INTERPRETATION, buffer, i, 0);	/* discardAnyUnrecognisedInvokePdu(0) */
++
++	/* Service APDU(s): */
++
++	/* ROSE InvokePDU  (0xa1,len) */
+ 	ASN1_ADD_SIMPLE(comp, COMP_TYPE_INVOKE, buffer, i);
+-	
+ 	ASN1_PUSH(compstk, compsp, comp);
+-	/* Invoke component contents */
+-	/*	Invoke ID */
++
++	/* ROSE InvokeID  (0x02,0x01,invokeid) */
+ 	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, get_invokeid(pri));
+-	/*	Operation Tag */
+-	
+-	/* ROSE operationId component */
++
++	/* ROSE operationId  (0x02,0x01,0x15)*/
+ 	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, ROSE_DIVERTING_LEG_INFORMATION2);
+ 
+-	/* ROSE ARGUMENT component */
++	/* constructor component  (0x30,len) */
+ 	ASN1_ADD_SIMPLE(comp, (ASN1_CONSTRUCTOR | ASN1_SEQUENCE), buffer, i);
+ 	ASN1_PUSH(compstk, compsp, comp);
+-	/* ROSE DivertingLegInformation2.diversionCounter component */
+-	/* Always is 1 because other isn't available in the current design */
++
++	/* diversionCounter always is 1 because other isn't available in the current design */
++	/* diversionCounter  (0x02,0x01,0x01) */
+ 	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, 1);
+-	
+-	/* ROSE DivertingLegInformation2.diversionReason component */
++
++	/* diversionReason  (0x0a,0x01,redirectingreason) */
+ 	ASN1_ADD_BYTECOMP(comp, ASN1_ENUMERATED, buffer, i, redirectingreason_from_q931(pri, call->redirectingreason));
+-		
+-	/* ROSE DivertingLegInformation2.divertingNr component */
++
++	/* originalDiversionReason */
++	/*  - not included - */
++
++	/* divertingNr */
++
++	/* tag component divertingNr  (0xa1,len) */
+ 	ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1), buffer, i);
+-	
+ 	ASN1_PUSH(compstk, compsp, comp);
+-		/* Redirecting information always not screened */
+-	
+-	switch(call->redirectingpres) {
+-		case PRES_ALLOWED_USER_NUMBER_NOT_SCREENED:
+-		case PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN:
+-			if (call->redirectingnum && strlen(call->redirectingnum)) {
+-				ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0), buffer, i);
+-				ASN1_PUSH(compstk, compsp, comp);
+-					/* NPI of redirected number is not supported in the current design */
+-				ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1), buffer, i);
+-				ASN1_PUSH(compstk, compsp, comp);
+-					ASN1_ADD_BYTECOMP(comp, ASN1_ENUMERATED, buffer, i, typeofnumber_from_q931(pri, call->redirectingplan >> 4));
+-					j = asn1_string_encode(ASN1_NUMERICSTRING, &buffer[i], len - i, 20, call->redirectingnum, strlen(call->redirectingnum));
+-				if (j < 0)
+-					return -1;
+-					
+-				i += j;
+-				ASN1_FIXUP(compstk, compsp, buffer, i);
+-				ASN1_FIXUP(compstk, compsp, buffer, i);
+-				break;
+-			}
+-			/* fall through */
+-		case PRES_PROHIB_USER_NUMBER_PASSED_SCREEN:
+-		case PRES_PROHIB_USER_NUMBER_NOT_SCREENED:
+-			ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_1), buffer, i);
+-			break;
+-		/* Don't know how to handle this */
+-		case PRES_ALLOWED_NETWORK_NUMBER:
+-		case PRES_PROHIB_NETWORK_NUMBER:
+-		case PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN:
+-		case PRES_PROHIB_USER_NUMBER_FAILED_SCREEN:
+-			ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_1), buffer, i);
+-			break;
+-		default:
+-			pri_message(pri, "!! Undefined presentation value for redirecting number: %d\n", call->redirectingpres);
+-		case PRES_NUMBER_NOT_AVAILABLE:
+-			ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2), buffer, i);
+-			break;
+-	}
++
++	size = rose_presented_number_unscreened_encode(pri, &buffer[i], call->redirectingpres, typeofnumber_from_q931(pri, (call->redirectingplan & 0x70) >> 4), call->redirectingnum);
++	if (size < 0)
++		return -1;
++	i += size;
+ 	ASN1_FIXUP(compstk, compsp, buffer, i);
+ 
+-	/* ROSE DivertingLegInformation2.originalCalledNr component */
+-	/* This information isn't supported by current design - duplicate divertingNr */
++	/* originalCalledNr */
++	/*  - not included - */
++
++#if 0
++	/* The originalCalledNr is unknown here. Its the same as divertingNr if the call *
++	 * is diverted only once but we don't know if its diverted one ore more times.   */
++
++	/* originalCalledNr */
++
++	/* tag component originalCalledNr  (0xa2,len) */
+ 	ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_2), buffer, i);
+ 	ASN1_PUSH(compstk, compsp, comp);
+-		/* Redirecting information always not screened */
+-	switch(call->redirectingpres) {
+-		case PRES_ALLOWED_USER_NUMBER_NOT_SCREENED:
+-		case PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN:
+-			if (call->redirectingnum && strlen(call->redirectingnum)) {
+-				ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0), buffer, i);
+-				ASN1_PUSH(compstk, compsp, comp);
+-				ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1), buffer, i);
+-				ASN1_PUSH(compstk, compsp, comp);
+-				ASN1_ADD_BYTECOMP(comp, ASN1_ENUMERATED, buffer, i, typeofnumber_from_q931(pri, call->redirectingplan >> 4));
+-	
+-				j = asn1_string_encode(ASN1_NUMERICSTRING, &buffer[i], len - i, 20, call->redirectingnum, strlen(call->redirectingnum));
+-				if (j < 0)
++
++	size = rose_presented_number_unscreened_encode(pri, &buffer[i], call->redirectingpres, typeofnumber_from_q931(pri, (call->redirectingplan & 0x70) >> 4), call->redirectingnum);
++	if (size < 0)
++		return -1;
++	i += size;
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++#endif
++
++	/* redirectingName */
++	if (call->redirectingname[0]) {
++		/* tag component redirectingName  (0xa3,len) */
++		ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_3), buffer, i);
++		ASN1_PUSH(compstk, compsp, comp);
++
++		/* tag component namePresentationAllowedSimple  (0x80,len) */
++		ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i);
++		ASN1_PUSH(compstk, compsp, comp);
++
++		/* namePresentationAllowedSimple, implicid NameData */
++		size = rose_namedata_encode(pri, &buffer[i], 1, call->redirectingname);
++		if (size < 0)
++			return -1;
++		i += size;
++
++		ASN1_FIXUP(compstk, compsp, buffer, i);
++		ASN1_FIXUP(compstk, compsp, buffer, i);
++	}
++
++	/* originalCalledName */
++	/*  - not included - */
++
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++
++	if (pri_call_apdu_queue(call, Q931_SETUP, buffer, i, NULL, NULL))
++		return -1;
++
++	return 0;
++}
++
++static int rose_diverting_leg_information3_decode(struct pri *pri, q931_call *call, struct rose_component *sequence, int len)
++{
++	int i = 0;
++	struct nameelements_name redirectionname = { "", CHARACTER_SET_UNKNOWN, 0 };
++	int presentation_allowed_indicator;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = sequence->data;
++	int size = 0;
++
++	/* Data checks */
++	if (sequence->type != (ASN1_CONSTRUCTOR | ASN1_SEQUENCE)) { /* Constructed Sequence */
++		pri_message(pri, "Invalid DivertingLegInformation3Type argument\n");
++		return -1;
++	}
++
++	if (sequence->len == ASN1_LEN_INDEF) {
++		len -= 4;   /* For the 2 extra characters at the end
++		               and two characters of header */
++	} else
++		len -= 2;
++
++	do {
++		/* presentationAllowedIndicator */
++		GET_COMPONENT(comp, i, vdata, len);
++		CHECK_COMPONENT(comp, ASN1_BOOLEAN, "Don't know what to do if presentationAllowedIndicator is of type 0x%x\n");
++		ASN1_GET_INTEGER(comp, presentation_allowed_indicator);
++		NEXT_COMPONENT(comp, i);
++
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "    Received presentationAllowedIndicator: %d\n", presentation_allowed_indicator);
++
++		/* Type SEQUENCE specifies an ordered list of component types.           *
++		 * We decode all components but for simplicity we don't check the order. */
++		while (i < len) {
++			GET_COMPONENT(comp, i, vdata, len);
++
++			switch(comp->type) {
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0):
++				/* redirectionName */
++				size = rose_name_decode(pri, comp->data, comp->len, &redirectionname);
++				if (size < 0)
+ 					return -1;
+-				
+-				i += j;
+-				ASN1_FIXUP(compstk, compsp, buffer, i);
+-				ASN1_FIXUP(compstk, compsp, buffer, i);
++				i += (size + 2);
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     Received RedirectionName '%s', namepres %s(%d), characterset %s(%d)\n",
++					            redirectionname.name, namepres_to_str(redirectionname.namepres), redirectionname.namepres,
++					            characterset_to_str(redirectionname.characterset), redirectionname.characterset);
+ 				break;
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1):	/* [1] IMPLICIT Extension */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_2):	/* [2] IMPLICIT SEQUENCE OF Extension */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "!!     Ignoring DivertingLegInformation3 component 0x%X\n", comp->type);
++				NEXT_COMPONENT(comp, i);
++				break;
++			default:
++				pri_message(pri, "!! Invalid DivertingLegInformation3 component received 0x%X\n", comp->type);
++				return -1;
+ 			}
+-				/* fall through */
+-		case PRES_PROHIB_USER_NUMBER_PASSED_SCREEN:
+-		case PRES_PROHIB_USER_NUMBER_NOT_SCREENED:
+-			ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_1), buffer, i);
+-			break;
+-		/* Don't know how to handle this */
+-		case PRES_ALLOWED_NETWORK_NUMBER:
+-		case PRES_PROHIB_NETWORK_NUMBER:
+-		case PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN:
+-		case PRES_PROHIB_USER_NUMBER_FAILED_SCREEN:
+-			ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_1), buffer, i);
+-			break;
+-		default:
+-			pri_message(pri, "!! Undefined presentation value for redirecting number: %d\n", call->redirectingpres);
+-		case PRES_NUMBER_NOT_AVAILABLE:
+-			ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2), buffer, i);
+-			break;
++		}
++
++		call->divleginfo3activeflag = 1;
++		if ((redirectionname.namepres != 0) && (presentation_allowed_indicator != 0)) {
++			libpri_copy_string(call->divertedtoname, redirectionname.name, sizeof(call->divertedtoname));
++		} else {
++			call->divertedtoname[0] = '\0';
++		}
++
++		return 0;
+ 	}
+-	ASN1_FIXUP(compstk, compsp, buffer, i);
+-		
+-	/* Fix length of stacked components */
+-	while(compsp > 0) {
++	while (0);
++
++	return -1;
++}
++
++int rose_diverting_leg_information3_encode(struct pri *pri, q931_call *call, int messagetype)
++{
++	int i = 0, compsp = 0;
++	struct rose_component *comp, *compstk[10];
++	unsigned char buffer[256];
++	int size;
++
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "    Encode divertingLegInformation3\n");
++
++	/* Protocol Profile = 0x1f (Networking Extensions)  (0x9f) */
++	buffer[i++] = (ASN1_CONTEXT_SPECIFIC | Q932_PROTOCOL_EXTENSIONS);
++
++	/* Network Facility Extension */
++	if (pri->switchtype == PRI_SWITCH_QSIG) {
++		/* tag component NetworkFacilityExtension (0xaa, len ) */
++		ASN1_ADD_SIMPLE(comp, COMP_TYPE_NFE, buffer, i);
++		ASN1_PUSH(compstk, compsp, comp);
++
++		/* sourceEntity  (0x80,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i, 0);	/* endPINX(0) */
++
++		/* destinationEntity  (0x82,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2), buffer, i, 0);	/* endPINX(0) */
+ 		ASN1_FIXUP(compstk, compsp, buffer, i);
+ 	}
+-	
+-	if (pri_call_apdu_queue(call, Q931_SETUP, buffer, i, NULL, NULL))
++
++	/* Network Protocol Profile */
++	/*  - not included - */
++
++	/* Interpretation APDU  (0x8b,0x01,0x00) */
++	ASN1_ADD_BYTECOMP(comp, COMP_TYPE_INTERPRETATION, buffer, i, 0);	/* discardAnyUnrecognisedInvokePdu(0) */
++
++	/* Service APDU(s): */
++
++	/* ROSE InvokePDU  (0xa1,len) */
++	ASN1_ADD_SIMPLE(comp, COMP_TYPE_INVOKE, buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* ROSE InvokeID  (0x02,0x01,invokeid) */
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, get_invokeid(pri));
++
++	/* ROSE operationId  (0x02,0x01,0x16)*/
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, ROSE_DIVERTING_LEG_INFORMATION3);
++
++	/* constructor component  (0x30,len) */
++	ASN1_ADD_SIMPLE(comp, (ASN1_CONSTRUCTOR | ASN1_SEQUENCE), buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* 'connectedpres' also indicates if name presentation is allowed */
++	if (((call->divertedtopres & 0x60) >> 5) == 0) {
++		/* presentation allowed */
++
++		/* presentationAllowedIndicator  (0x01,0x01,0xff) */
++		ASN1_ADD_BYTECOMP(comp, ASN1_BOOLEAN, buffer, i, 0xff);			/* true(255) */
++
++		/* redirectionName */
++
++		/* tag component redirectionName  (0xa0,len) */
++		ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0), buffer, i);
++		ASN1_PUSH(compstk, compsp, comp);
++
++		if (call->divertedtoname[0]) {
++			/* tag component namePresentationAllowedSimple  (0x80,len) */
++			ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i);
++			ASN1_PUSH(compstk, compsp, comp);
++
++			/* namePresentationAllowedSimple, implicid NameData */
++			size = rose_namedata_encode(pri, &buffer[i], 1, call->divertedtoname);
++			if (size < 0)
++				return -1;
++			i += size;
++
++			ASN1_FIXUP(compstk, compsp, buffer, i);
++		}
++
++		ASN1_FIXUP(compstk, compsp, buffer, i);
++	} else {
++		/* presentation restricted */
++
++		/* presentationAllowedIndicator  (0x01,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, ASN1_BOOLEAN, buffer, i, 0);			/* false(0) */
++
++		/* - don't include redirectionName, component is optional - */
++	}
++
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++
++	if (pri_call_apdu_queue(call, messagetype, buffer, i, NULL, NULL))
+ 		return -1;
+-		
++
+ 	return 0;
+ }
+ 
+@@ -1644,7 +2828,7 @@
+ 		switch (comp1->type) {
+ 			/* TODO: charged number is untested - please report! */
+ 			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0): /* chargedNumber (0xA0) */
+-				if(rose_presented_number_unscreened_decode(pri, call, comp1->data, comp1->len, &chargednr) != 0)
++				if(rose_presented_number_unscreened_decode(pri, comp1->data, comp1->len, &chargednr) != 0)
+ 					return -1;
+ 				pri_message(pri, "!! not handled: Received ChargedNr '%s' \n", chargednr.partyaddress);
+ 				pri_message(pri, "  ton = %d, pres = %d, npi = %d\n", chargednr.ton, chargednr.pres, chargednr.npi);
+@@ -1740,302 +2924,407 @@
+ }
+ /* End AOC */
+ 
+-static int rose_calling_name_decode(struct pri *pri, q931_call *call, struct rose_component *choice, int len)
++/* ===== Call Transfer Supplementary Service (ECMA-178) ===== */
++
++static int rose_call_transfer_complete_decode(struct pri *pri, q931_call *call, struct rose_component *sequence, int len)
+ {
+ 	int i = 0;
+ 	struct rose_component *comp = NULL;
+-	unsigned char *vdata = choice->data;
+-	int characterSet = 1;
+-	switch (choice->type) {
+-		case ROSE_NAME_PRESENTATION_ALLOWED_SIMPLE:
+-			memcpy(call->callername, choice->data, choice->len);
+-			call->callername[choice->len] = 0;
+-			if (pri->debug & PRI_DEBUG_APDU)
+-				pri_message(pri, "    Received simple calling name '%s'\n", call->callername);
+-			return 0;
++	unsigned char *vdata = sequence->data;
++	int size = 0;
+ 
+-		case ROSE_NAME_PRESENTATION_ALLOWED_EXTENDED:
+-			do {
+-				GET_COMPONENT(comp, i, vdata, len);
+-				CHECK_COMPONENT(comp, ASN1_OCTETSTRING, "Don't know what to do if nameData is of type 0x%x\n");
+-				memcpy(call->callername, comp->data, comp->len);
+-				call->callername[comp->len] = 0;
+-				NEXT_COMPONENT(comp, i);
++	struct addressingdataelements_presentednumberscreened redirection_number;
++	struct nameelements_name redirectionname = { "", CHARACTER_SET_UNKNOWN, 0 };
++	char basiccallinfoelements[257] = "";
++	int call_status = 0;	/* answered(0) */
++	int end_designation;
+ 
+-				GET_COMPONENT(comp, i, vdata, len);
+-				CHECK_COMPONENT(comp, ASN1_INTEGER, "Don't know what to do if CharacterSet is of type 0x%x\n");
+-				ASN1_GET_INTEGER(comp, characterSet);
+-			}
+-			while (0);
+-
+-			if (pri->debug & PRI_DEBUG_APDU)
+-				pri_message(pri, "    Received extended calling name '%s', characterset %d\n", call->callername, characterSet);
+-			return 0;
+-		case ROSE_NAME_PRESENTATION_RESTRICTED_SIMPLE:
+-		case ROSE_NAME_PRESENTATION_RESTRICTED_EXTENDED:
+-		case ROSE_NAME_PRESENTATION_RESTRICTED_NULL:
+-		case ROSE_NAME_NOT_AVAIL:
+-		default:
+-			if (pri->debug & PRI_DEBUG_APDU)
+-				pri_message(pri, "Do not handle argument of type 0x%X\n", choice->type);
+-			return -1;
++	/* Data checks */
++	if (sequence->type != (ASN1_CONSTRUCTOR | ASN1_SEQUENCE)) { /* Constructed Sequence */
++		pri_message(pri, "Invalid callTransferComplete argument. (Not a sequence)\n");
++		return -1;
+ 	}
+-}
+-/* ===== Call Transfer Supplementary Service (ECMA-178) ===== */
+ 
+-static int rose_party_number_decode(struct pri *pri, q931_call *call, unsigned char *data, int len, struct addressingdataelements_presentednumberunscreened *value)
+-{
+-	int i = 0;
+-	int size = 0;
+-	struct rose_component *comp = NULL;
+-	unsigned char *vdata = data;
++	if (sequence->len == ASN1_LEN_INDEF) {
++		len -= 4;   /* For the 2 extra characters at the end
++		               and two characters of header */
++	} else
++		len -= 2;
+ 
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "     CT-Complete: len=%d\n", len);
+ 
++	/* CTCompleteArg SEQUENCE */
+ 	do {
++		/* endDesignation EndDesignation */
+ 		GET_COMPONENT(comp, i, vdata, len);
++		CHECK_COMPONENT(comp, ASN1_ENUMERATED, "Invalid endDesignation type 0x%X of ROSE callTransferComplete component received\n");
++		ASN1_GET_INTEGER(comp, end_designation);
++		NEXT_COMPONENT(comp, i);
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "     CT-Complete: Received endDesignation=%s(%d)\n", enddesignation_to_str(end_designation), end_designation);
+ 
+-		switch(comp->type) {
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0):   /* [0] IMPLICIT NumberDigits -- default: unknownPartyNumber */
+-				if (pri->debug & PRI_DEBUG_APDU)
+-					pri_message(pri, "     PartyNumber: UnknownPartyNumber len=%d\n", len);
+-				size = rose_number_digits_decode(pri, call, comp->data, comp->len, value);
+-				if (size < 0)
+-					return -1;
+-				value->npi = PRI_NPI_UNKNOWN;
+-				value->ton = PRI_TON_UNKNOWN;
+-				break;
++		/* redirectionNumber PresentedNumberScreened */
++		GET_COMPONENT(comp, i, vdata, len);
++		size = rose_presented_number_screened_decode(pri, (u_int8_t *)comp, comp->len + 2, &redirection_number);
++		if (size < 0)
++			return -1;
++		comp->len = size;
++		NEXT_COMPONENT(comp, i);
++		if (pri->debug & PRI_DEBUG_APDU)
++			pri_message(pri, "     CT-Complete: Received redirectionNumber=%s\n", redirection_number.partyaddress);
+ 
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1):   /* [1] IMPLICIT PublicPartyNumber */
+-				if (pri->debug & PRI_DEBUG_APDU)
+-					pri_message(pri, "     PartyNumber: PublicPartyNumber len=%d\n", len);
+-				size = rose_public_party_number_decode(pri, call, comp->data, comp->len, value);
+-				if (size < 0)
+-					return -1;
+-				value->npi = PRI_NPI_E163_E164;
+-				break;
++		/* Type SEQUENCE specifies an ordered list of component types.           *
++		 * We decode all components but for simplicity we don't check the order. */
++		while (i < len) {
++			GET_COMPONENT(comp, i, vdata, len);
+ 
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_3):   /* [3] IMPLICIT NumberDigits -- not used: dataPartyNumber */
+-				pri_message(pri, "!! PartyNumber: dataPartyNumber is reserved!\n");
+-				size = rose_number_digits_decode(pri, call, comp->data, comp->len, value);
++			switch(comp->type) {
++ 			case (ASN1_APPLICATION):
++				/* basicCallInfoElements PSS1InformationElement OPTIONAL */
++				size = asn1_name_decode((u_int8_t *)comp, comp->len + 2, basiccallinfoelements, sizeof(basiccallinfoelements));
+ 				if (size < 0)
+ 					return -1;
+-				value->npi = PRI_NPI_X121 /* ??? */;
+-				value->ton = PRI_TON_UNKNOWN /* ??? */;
++				i += size;
++				if (pri->debug & PRI_DEBUG_APDU) {
++					int j;
++					pri_message(pri, "     CT-Complete: Received basicCallInfoElements\n");
++					pri_message(pri, "                  ");
++					for (j = 0; basiccallinfoelements[j] != '\0'; j++)
++						pri_message(pri, "%02x ", (u_int8_t)basiccallinfoelements[j]);
++					pri_message(pri, "\n");
++				}
+ 				break;
+-
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_4):   /* [4] IMPLICIT NumberDigits -- not used: telexPartyNumber */
+-				pri_message(pri, "!! PartyNumber: telexPartyNumber is reserved!\n");
+-				size = rose_number_digits_decode(pri, call, comp->data, comp->len, value);
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0):                      /* [0] namePresentationAllowedSimple */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1):   /* [1] namePresentationAllowedExtended */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2):                      /* [2] namePresentationRestrictedSimple */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_3):   /* [3] namePresentationRestrictedExtended */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_4):                      /* [4] nameNotAvailable */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_7):                      /* [7] namePresentationRestrictedNull */
++				/* redirectionName Name OPTIONAL */
++				size = rose_name_decode(pri, (u_int8_t *)comp, comp->len + 2, &redirectionname);
+ 				if (size < 0)
+ 					return -1;
+-				value->npi = PRI_NPI_F69 /* ??? */;
+-				value->ton = PRI_TON_UNKNOWN /* ??? */;
++				i += size;
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     CT-Complete: Received RedirectionName '%s', namepres %s(%d), characterset %s(%d)\n",
++						    redirectionname.name, namepres_to_str(redirectionname.namepres), redirectionname.namepres,
++						    characterset_to_str(redirectionname.characterset), redirectionname.characterset);
+ 				break;
+-
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_5):   /* [5] IMPLICIT PrivatePartyNumber */
++			case (ASN1_ENUMERATED):
++				/* callStatus CallStatus DEFAULT answered */
++				ASN1_GET_INTEGER(comp, call_status);
++				NEXT_COMPONENT(comp,i);
+ 				if (pri->debug & PRI_DEBUG_APDU)
+-					pri_message(pri, "     PartyNumber: PrivatePartyNumber len=%d\n", len);
+-				size = rose_private_party_number_decode(pri, call, comp->data, comp->len, value);
+-				if (size < 0)
+-					return -1;
+- 				value->npi = PRI_NPI_PRIVATE;
++					pri_message(pri, "     CT-Complete: Received callStatus=%s(%d)\n", callstatus_to_str(call_status), call_status);
+ 				break;
+-
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_8):   /* [8] IMPLICIT NumberDigits -- not used: nationalStandatdPartyNumber */
+-				pri_message(pri, "!! PartyNumber: nationalStandardPartyNumber is reserved!\n");
+-				size = rose_number_digits_decode(pri, call, comp->data, comp->len, value);
+-				if (size < 0)
+-					return -1;
+-				value->npi = PRI_NPI_NATIONAL;
+-				value->ton = PRI_TON_NATIONAL;
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_9):	/* [9] IMPLICIT Extension */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_10):	/* [10] IMPLICIT SEQUENCE OF Extension */
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "!!     CT-Complete: Ignoring CallTransferComplete component 0x%X\n", comp->type);
++				NEXT_COMPONENT(comp, i);
+ 				break;
+-
+ 			default:
+-				pri_message(pri, "Invalid PartyNumber component 0x%X\n", comp->type);
++				pri_message(pri, "!!     CT-Complete: Invalid CallTransferComplete component received 0x%X\n", comp->type);
+ 				return -1;
++			}
+ 		}
+-		ASN1_FIXUP_LEN(comp, size);
++
+ 		if (pri->debug & PRI_DEBUG_APDU)
+-			pri_message(pri, "     PartyNumber: '%s' size=%d len=%d\n", value->partyaddress, size, len);
+-		return size;
++			pri_message(pri, "     CT-Complete: callStatus=%s(%d)\n", callstatus_to_str(call_status), call_status);
++
++		call->ctcompleteflag = 1;
++		if ((redirection_number.pres & PRES_RESTRICTION) == PRES_ALLOWED) {
++			libpri_copy_string(call->ctcompletenum, redirection_number.partyaddress, sizeof(call->ctcompletenum));
++		} else {
++			call->ctcompletenum[0] = '\0';
++		}
++		call->ctcompletepres = redirection_number.pres;
++		call->ctcompleteplan = ((redirection_number.ton & 0x07) << 4) | (redirection_number.npi & 0x0f);
++		call->ctcompletecallstatus = call_status;
++
++		if (redirectionname.namepres != 0) {
++			libpri_copy_string(call->ctcompletename, redirectionname.name, sizeof(call->ctcompletename));
++		} else {
++			call->ctcompletename[0] = '\0';
++		}
++
++		return 0;
+ 	}
+ 	while (0);
+ 
+ 	return -1;
+ }
+ 
+-
+-static int rose_number_screened_decode(struct pri *pri, q931_call *call, unsigned char *data, int len, struct addressingdataelements_presentednumberscreened *value)
++static int rose_call_transfer_complete_encode(struct pri *pri, q931_call *call, int call_status)
+ {
+-	int i = 0;
+-	int size = 0;
+-	struct rose_component *comp = NULL;
+-	unsigned char *vdata = data;
++	int i = 0, compsp = 0;
++	struct rose_component *comp, *compstk[10];
++	unsigned char buffer[256];
++	int size;
+ 
+-	int scrind = -1;
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "    Encode CallTransferComplete\n");
+ 
+-	do {
+-		/* Party Number */
+-		GET_COMPONENT(comp, i, vdata, len);
+-		size = rose_party_number_decode(pri, call, (u_int8_t *)comp, comp->len + 2, (struct addressingdataelements_presentednumberunscreened*) value);
++	/* Protocol Profile = 0x1f (Networking Extensions)  (0x9f) */
++	buffer[i++] = (ASN1_CONTEXT_SPECIFIC | Q932_PROTOCOL_EXTENSIONS);
++
++	/* Network Facility Extension */
++	if (pri->switchtype == PRI_SWITCH_QSIG) {
++		/* tag component NetworkFacilityExtension (0xaa, len ) */
++		ASN1_ADD_SIMPLE(comp, COMP_TYPE_NFE, buffer, i);
++		ASN1_PUSH(compstk, compsp, comp);
++
++		/* sourceEntity  (0x80,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i, 0);	/* endPINX(0) */
++
++		/* destinationEntity  (0x82,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2), buffer, i, 0);	/* endPINX(0) */
++		ASN1_FIXUP(compstk, compsp, buffer, i);
++	}
++
++	/* Network Protocol Profile */
++	/*  - not included - */
++
++	/* Interpretation APDU  (0x8b,0x01,0x00) */
++	ASN1_ADD_BYTECOMP(comp, COMP_TYPE_INTERPRETATION, buffer, i, 0);	/* discardAnyUnrecognisedInvokePdu(0) */
++
++	/* Service APDU(s): */
++
++	/* ROSE InvokePDU  (0xa1,len) */
++	ASN1_ADD_SIMPLE(comp, COMP_TYPE_INVOKE, buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* ROSE InvokeID  (0x02,0x01,invokeid) */
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, get_invokeid(pri));
++
++	/* ROSE operationId  (0x02,0x01,0x0c)*/
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, ROSE_CALL_TRANSFER_COMPLETE);
++
++
++	/* CTCompleteArg */
++
++	/* constructor component  (0x30,len) */
++	ASN1_ADD_SIMPLE(comp, (ASN1_CONSTRUCTOR | ASN1_SEQUENCE), buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++
++	/* endDesignation  (0x0a,0x01,0x00) */
++	ASN1_ADD_BYTECOMP(comp, ASN1_ENUMERATED, buffer, i, 0);		/* primaryEnd(0) */
++
++
++	/* redirectionNumber PresentedNumberScreened */
++
++	/* tag component presentationAllowedAddress  (0xa0,len) */
++	ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0), buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* presentationAllowedAddress, implicit NumberScreened */
++	size = rose_number_screened_encode(pri, &buffer[i], 1, typeofnumber_from_q931(pri, (call->connectedplan & 0x70) >> 4), call->connectedpres & 0x03, call->connectednum);
++	if (size < 0)
++		return -1;
++	i += size;
++
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++
++	/* basicCallInfoElements */
++	/*  - not included -  */
++
++#if 0
++	/* basicCallInfoElements  (0x40,0x00) */
++	ASN1_ADD_SIMPLE(comp, (ASN1_APPLICATION| ASN1_TAG_0), buffer, i);
++#endif
++
++	/* redirectionName */
++	if (call->connectedname[0]) {
++		/* tag component namePresentationAllowedSimple  (0x80,len) */
++		ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i);
++		ASN1_PUSH(compstk, compsp, comp);
++
++		/* namePresentationAllowedSimple, implicid NameData */
++		size = rose_namedata_encode(pri, &buffer[i], 1, call->connectedname);
+ 		if (size < 0)
+ 			return -1;
+-		comp->len = size;
+-		NEXT_COMPONENT(comp, i);
++		i += size;
+ 
+-		/* Screening Indicator */
+-		GET_COMPONENT(comp, i, vdata, len);
+-		CHECK_COMPONENT(comp, ASN1_ENUMERATED, "Don't know what to do with NumberScreened ROSE component type 0x%x\n");
+-		ASN1_GET_INTEGER(comp, scrind);
+-		// Todo: scrind = screeningindicator_for_q931(pri, scrind);
+-		NEXT_COMPONENT(comp, i);
++		ASN1_FIXUP(compstk, compsp, buffer, i);
++	}
+ 
+-		value->scrind = scrind;
++	if (call_status) {
++		/* callStatus  (0x0a,0x01,0x01) */
++		ASN1_ADD_BYTECOMP(comp, ASN1_ENUMERATED, buffer, i, 1);		/* alerting(1) */
++	} else {
++		/* callStatus */
++		/*  - not included, default: answered(0) -  */
++#if 0
++		/* callStatus  (0x0a,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, ASN1_ENUMERATED, buffer, i, 0);		/* answered(0) */
++#endif
++	}
+ 
+-		if (pri->debug & PRI_DEBUG_APDU)
+-			pri_message(pri, "     NumberScreened: '%s' ScreeningIndicator=%d  i=%d  len=%d\n", value->partyaddress, scrind, i, len);
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++	ASN1_FIXUP(compstk, compsp, buffer, i);
+ 
+-		return i-2;  // We do not have a sequence header here.
+-	}
+-	while (0);
++	if (pri_call_apdu_queue(call, Q931_FACILITY, buffer, i, NULL, NULL))
++		return -1;
+ 
+-	return -1;
++	return 0;
+ }
+ 
+-
+-static int rose_presented_number_screened_decode(struct pri *pri, q931_call *call, unsigned char *data, int len, struct addressingdataelements_presentednumberscreened *value)
++static int rose_call_transfer_active_decode(struct pri *pri, q931_call *call, struct rose_component *sequence, int len)
+ {
+ 	int i = 0;
++	struct rose_component *comp = NULL;
++	unsigned char *vdata = sequence->data;
+ 	int size = 0;
+-	struct rose_component *comp = NULL;
+-	unsigned char *vdata = data;
+ 
+-	/* Fill in default values */
+-	value->ton = PRI_TON_UNKNOWN;
+-	value->npi = PRI_NPI_UNKNOWN;
+-	value->pres = -1; /* Data is not available */
++	struct addressingdataelements_presentedaddressscreened connectedaddress;
++	struct nameelements_name connectedname = { "", CHARACTER_SET_UNKNOWN, 0 };
++	char basiccallinfoelements[257] = "";
+ 
++	/* Data checks */
++	if (sequence->type != (ASN1_CONSTRUCTOR | ASN1_SEQUENCE)) { /* Constructed Sequence */
++		pri_message(pri, "Invalid callTransferActive argument. (Not a sequence)\n");
++		return -1;
++	}
++
++	if (sequence->len == ASN1_LEN_INDEF) {
++		len -= 4;   /* For the 2 extra characters at the end
++		               and two characters of header */
++	} else
++		len -= 2;
++
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "     CT-Active: len=%d\n", len);
++
++	/* CTActiveArg SEQUENCE */
+ 	do {
++		/* connectedAddress PresentedAddressScreened */
+ 		GET_COMPONENT(comp, i, vdata, len);
++		size = rose_presented_address_screened_decode(pri, (u_int8_t *)comp, comp->len + 2, &connectedaddress);
++		if (size < 0)
++			return -1;
++		comp->len = size;
++		NEXT_COMPONENT(comp, i);
++		if (pri->debug & PRI_DEBUG_APDU) {
++			pri_message(pri, "     CT-Active: Received connectedAddress=%s\n", connectedaddress.partyaddress);
++		}
+ 
+-		switch(comp->type) {
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0):   /* [0] IMPLICIT presentationAllowedNumber */
+-				if (pri->debug & PRI_DEBUG_APDU)
+-					pri_message(pri, "     PresentedNumberScreened: presentationAllowedNumber comp->len=%d\n", comp->len);
+-				value->pres = PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
+-				size = rose_number_screened_decode(pri, call, comp->data, comp->len, value);
++		/* Type SEQUENCE specifies an ordered list of component types.           *
++		 * We decode all components but for simplicity we don't check the order. */
++		while (i < len) {
++			GET_COMPONENT(comp, i, vdata, len);
++
++			switch(comp->type) {
++ 			case (ASN1_APPLICATION):
++				/* basiccallinfoelements PSS1InformationElement OPTIONAL */
++				size = asn1_name_decode((u_int8_t *)comp, comp->len + 2, basiccallinfoelements, sizeof(basiccallinfoelements));
+ 				if (size < 0)
+ 					return -1;
+-				ASN1_FIXUP_LEN(comp, size);
+-				return size + 2;
+-
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_1):    /* [1] IMPLICIT presentationRestricted */
+-				if (pri->debug & PRI_DEBUG_APDU)
+-					pri_message(pri, "     PresentedNumberScreened: presentationRestricted comp->len=%d\n", comp->len);
+-				if (comp->len != 0) { /* must be NULL */
+-					pri_error(pri, "!! Invalid PresentationRestricted component received (len != 0)\n");
+-					return -1;
++				i += size;
++				if (pri->debug & PRI_DEBUG_APDU) {
++					int j;
++					pri_message(pri, "     CT-Active: Received basicCallInfoElements\n");
++					pri_message(pri, "                ");
++					for (j = 0; basiccallinfoelements[j] != '\0'; j++)
++						pri_message(pri, "%02x ", (u_int8_t)basiccallinfoelements[j]);
++					pri_message(pri, "\n");
+ 				}
+-				value->pres = PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
+-				return 2;
+-
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2):    /* [2] IMPLICIT numberNotAvailableDueToInterworking */
+-				if (pri->debug & PRI_DEBUG_APDU)
+-					pri_message(pri, "     PresentedNumberScreened: NumberNotAvailableDueToInterworking comp->len=%d\n", comp->len);
+-				if (comp->len != 0) { /* must be NULL */
+-					pri_error(pri, "!! Invalid NumberNotAvailableDueToInterworking component received (len != 0)\n");
++				break;
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0):                      /* [0] namePresentationAllowedSimple */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1):   /* [1] namePresentationAllowedExtended */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2):                      /* [2] namePresentationRestrictedSimple */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_3):   /* [3] namePresentationRestrictedExtended */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_4):                      /* [4] nameNotAvailable */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_7):                      /* [7] namePresentationRestrictedNull */
++				/* connectedName Name OPTIONAL */
++				size = rose_name_decode(pri, (u_int8_t *)comp, comp->len + 2, &connectedname);
++				if (size < 0)
+ 					return -1;
+-				}
+-				value->pres = PRES_NUMBER_NOT_AVAILABLE;
++				i += size;
+ 				if (pri->debug & PRI_DEBUG_APDU)
+-					pri_message(pri, "     PresentedNumberScreened: numberNotAvailableDueToInterworking Type=0x%X  i=%d len=%d size=%d\n", comp->type, i, len);
+-				return 2;
+-
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_3):    /* [3] IMPLICIT presentationRestrictedNumber */
++					pri_message(pri, "     CT-Active: Received ConnectedName '%s', namepres %s(%d), characterset %s(%d)\n",
++						    connectedname.name, namepres_to_str(connectedname.namepres), connectedname.namepres,
++						    characterset_to_str(connectedname.characterset), connectedname.characterset);
++				break;
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_9):   /* [9] IMPLICIT Extension */
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_10):  /* [10] IMPLICIT SEQUENCE OF Extension */
+ 				if (pri->debug & PRI_DEBUG_APDU)
+-					pri_message(pri, "     PresentedNumberScreened: presentationRestrictedNumber comp->len=%d\n", comp->len);
+-				value->pres = PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
+-				size = rose_number_screened_decode(pri, call, comp->data, comp->len, value);
+-				if (size < 0)
+-					return -1;
+-				ASN1_FIXUP_LEN(comp, size);
+-				return size + 2;
++					pri_message(pri, "!!     CT-Active: Ignoring CallTransferActive component 0x%X\n", comp->type);
++				NEXT_COMPONENT(comp, i);
++				break;
++ 			default:
++ 				pri_message(pri, "!!     CT-Active: Invalid CallTransferActive component received 0x%X\n", comp->type);
++ 				return -1;
++ 			}
++		}
+ 
+-			default:
+-				pri_message(pri, "Invalid PresentedNumberScreened component 0x%X\n", comp->type);
++		call->ctactiveflag = 1;
++		if ((connectedaddress.pres & PRES_RESTRICTION) == PRES_ALLOWED) {
++			libpri_copy_string(call->ctactivenum, connectedaddress.partyaddress, sizeof(call->ctactivenum));
++		} else {
++			call->ctactivenum[0] = '\0';
+ 		}
+-		return -1;
++		call->ctactivepres = connectedaddress.pres;
++		call->ctactiveplan = ((connectedaddress.ton & 0x07) << 4) | (connectedaddress.npi & 0x0f);
++
++		if (connectedname.namepres != 0) {
++			libpri_copy_string(call->ctactivename, connectedname.name, sizeof(call->ctactivename));
++		} else {
++			call->ctactivename[0] = '\0';
++		}
++
++		return 0;
+ 	}
+ 	while (0);
+ 
+ 	return -1;
+ }
+ 
+-
+-static int rose_call_transfer_complete_decode(struct pri *pri, q931_call *call, struct rose_component *sequence, int len)
++#if 0
++static int rose_call_transfer_update_decode(struct pri *pri, q931_call *call, struct rose_component *sequence, int len)
+ {
+ 	int i = 0;
+ 	struct rose_component *comp = NULL;
+ 	unsigned char *vdata = sequence->data;
+ 	int res = 0;
+ 
+-	int end_designation = 0;
+ 	struct addressingdataelements_presentednumberscreened redirection_number;
+-	char redirection_name[50] = "";
+-	int call_status = 0;
+ 	redirection_number.partyaddress[0] = 0;
+-	redirection_number.partysubaddress[0] = 0;
++	char redirection_name[51] = "";
+ 	call->callername[0] = 0;
+ 	call->callernum[0] = 0;
+ 
+-
+ 	/* Data checks */
+ 	if (sequence->type != (ASN1_CONSTRUCTOR | ASN1_SEQUENCE)) { /* Constructed Sequence */
+-		pri_message(pri, "Invalid callTransferComplete argument. (Not a sequence)\n");
++		pri_message(pri, "Invalid callTransferUpdate argument. (Not a sequence)\n");
+ 		return -1;
+ 	}
+ 
+ 	if (sequence->len == ASN1_LEN_INDEF) {
+-		len -= 4; /* For the 2 extra characters at the end
+-					   * and two characters of header */
++		len -= 4;   /* For the 2 extra characters at the end
++		               and two characters of header */
+ 	} else
+ 		len -= 2;
+ 
+ 	if (pri->debug & PRI_DEBUG_APDU)
+-		pri_message(pri, "     CT-Complete: len=%d\n", len);
++		pri_message(pri, "     CT-Update: len=%d\n", len);
+ 
+ 	do {
+-		/* End Designation */
+-		GET_COMPONENT(comp, i, vdata, len);
+-		CHECK_COMPONENT(comp, ASN1_ENUMERATED, "Invalid endDesignation type 0x%X of ROSE callTransferComplete component received\n");
+-		ASN1_GET_INTEGER(comp, end_designation);
+-		NEXT_COMPONENT(comp, i);
+-		if (pri->debug & PRI_DEBUG_APDU)
+-			pri_message(pri, "     CT-Complete: Received endDesignation=%d\n", end_designation);
+-
+-
+ 		/* Redirection Number */
+ 		GET_COMPONENT(comp, i, vdata, len);
+-		res = rose_presented_number_screened_decode(pri, call, (u_int8_t *)comp, comp->len + 2, &redirection_number);
++		res = rose_presented_number_screened_decode(pri, (u_int8_t *)comp, comp->len + 2, &redirection_number);
+ 		if (res < 0)
+ 			return -1;
+ 		comp->len = res;
+ 		if (res > 2) {
+ 			if (pri->debug & PRI_DEBUG_APDU)
+-				pri_message(pri, "     CT-Complete: Received redirectionNumber=%s\n", redirection_number.partyaddress);
++				pri_message(pri, "     CT-Update: Received redirectionNumber=%s\n", redirection_number.partyaddress);
+ 			strncpy(call->callernum, redirection_number.partyaddress, 20);
+ 			call->callernum[20] = 0;
+ 		}
+ 		NEXT_COMPONENT(comp, i);
+ 
+-
+-#if 0 /* This one is optional. How do we check if it is there? */
+-		/* Basic Call Info Elements */
+-		GET_COMPONENT(comp, i, vdata, len);
+-		NEXT_COMPONENT(comp, i);
+-#endif
+-
+-
+ 		/* Redirection Name */
+ 		GET_COMPONENT(comp, i, vdata, len);
+ 		res = asn1_name_decode((u_int8_t *)comp, comp->len + 2, redirection_name, sizeof(redirection_name));
+@@ -2047,16 +3336,14 @@
+ 		comp->len = res;
+ 		NEXT_COMPONENT(comp, i);
+ 		if (pri->debug & PRI_DEBUG_APDU)
+-			pri_message(pri, "     CT-Complete: Received redirectionName '%s'\n", redirection_name);
++			pri_message(pri, "     CT-Update: Received redirectionName '%s'\n", redirection_name);
+ 
+ 
+-		/* Call Status */
++#if 0 /* This one is optional. How do we check if it is there? */
++		/* Basic Call Info Elements */
+ 		GET_COMPONENT(comp, i, vdata, len);
+-		CHECK_COMPONENT(comp, ASN1_ENUMERATED, "Invalid callStatus type 0x%X of ROSE callTransferComplete component received\n");
+-		ASN1_GET_INTEGER(comp, call_status);
+ 		NEXT_COMPONENT(comp, i);
+-		if (pri->debug & PRI_DEBUG_APDU)
+-			pri_message(pri, "     CT-Complete: Received callStatus=%d\n", call_status);
++#endif
+ 
+ 
+ 		/* Argument Extension */
+@@ -2078,8 +3365,8 @@
+ 				comp->len = res;
+ 
+ 			default:
+-			pri_message(pri, "     CT-Complete: !! Unknown argumentExtension received 0x%X\n", comp->type);
+-			return -1;
++				pri_message(pri, "     CT-Update: !! Unknown argumentExtension received 0x%X\n", comp->type);
++				return -1;
+ 		}
+ #else
+ 		GET_COMPONENT(comp, i, vdata, len);
+@@ -2088,7 +3375,7 @@
+ #endif
+ 
+ 		if(i < len)
+-			pri_message(pri, "     CT-Complete: !! not all information is handled !! i=%d / len=%d\n", i, len);
++			pri_message(pri, "     CT-Update: !! not all information is handled !! i=%d / len=%d\n", i, len);
+ 
+ 		return 0;
+ 	}
+@@ -2096,26 +3383,422 @@
+ 
+ 	return -1;
+ }
++#endif
+ 
++/* ===== End Call Transfer Supplementary Service (ECMA-178) ===== */
+ 
+-static int rose_call_transfer_update_decode(struct pri *pri, q931_call *call, struct rose_component *sequence, int len)
++
++
++static int rose_calling_name_decode(struct pri *pri, q931_call *call, struct rose_component *sequence, int len)
+ {
++	struct nameelements_name callingname;
++	int res;
++
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "    Handle callingName\n");
++
++	res = rose_name_decode(pri, (u_int8_t *)sequence, sequence->len + 2, &callingname);
++	if (res < 0)
++		return -1;
++
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "     Received CallingName '%s', namepres: %s(%d), characterset %s(%d)\n",
++		            callingname.name, namepres_to_str(callingname.namepres), callingname.namepres,
++		            characterset_to_str(callingname.characterset), callingname.characterset);
++
++	if (callingname.namepres >= 0) {
++		libpri_copy_string(call->callername, callingname.name, sizeof(call->callername));
++	}
++
++	return 0;
++}
++
++static int rose_called_name_decode(struct pri *pri, q931_call *call, struct rose_component *sequence, int len)
++{
++	struct nameelements_name calledname;
++	int res;
++
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "    Handle calledName\n");
++
++	res = rose_name_decode(pri, (u_int8_t *)sequence, sequence->len + 2, &calledname);
++	if (res < 0)
++		return -1;
++
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "     Received CalledName '%s', namepres %s(%d), characterset %s(%d)\n",
++		            calledname.name, namepres_to_str(calledname.namepres), calledname.namepres,
++		            characterset_to_str(calledname.characterset), calledname.characterset);
++
++	if (calledname.namepres != 0) {
++		libpri_copy_string(call->calledname, calledname.name, sizeof(call->calledname));
++	} else {
++		call->calledname[0] = '\0';
++	}
++
++	return 0;
++}
++
++int rose_called_name_encode(struct pri *pri, q931_call *call, int messagetype)
++{
++	int i = 0, compsp = 0;
++	struct rose_component *comp, *compstk[10];
++	unsigned char buffer[256];
++	int size;
++
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "    Encode calledName\n");
++
++	/* Protocol Profile = 0x1f (Networking Extensions)  (0x9f) */
++	buffer[i++] = (ASN1_CONTEXT_SPECIFIC | Q932_PROTOCOL_EXTENSIONS);
++
++	/* Network Facility Extension */
++	if (pri->switchtype == PRI_SWITCH_QSIG) {
++		/* tag component NetworkFacilityExtension (0xaa, len ) */
++		ASN1_ADD_SIMPLE(comp, COMP_TYPE_NFE, buffer, i);
++		ASN1_PUSH(compstk, compsp, comp);
++
++		/* sourceEntity  (0x80,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i, 0);	/* endPINX(0) */
++
++		/* destinationEntity  (0x82,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2), buffer, i, 0);	/* endPINX(0) */
++		ASN1_FIXUP(compstk, compsp, buffer, i);
++	}
++
++	/* Network Protocol Profile */
++	/*  - not included - */
++
++	/* Interpretation APDU  (0x8b,0x01,0x00) */
++	ASN1_ADD_BYTECOMP(comp, COMP_TYPE_INTERPRETATION, buffer, i, 0);	/* discardAnyUnrecognisedInvokePdu(0) */
++
++	/* Service APDU(s): */
++
++	/* ROSE InvokePDU  (0xa1,len) */
++	ASN1_ADD_SIMPLE(comp, COMP_TYPE_INVOKE, buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* ROSE InvokeID  (0x02,0x01,invokeid) */
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, get_invokeid(pri));
++
++	/* ROSE operationId  (0x02,0x01,0x02)*/
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, SS_CNOP_CALLEDNAME);
++
++	/* tag component namePresentationAllowedSimple  (0x80,len) */
++	ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* namePresentationAllowedSimple, implicid NameData */
++	size = rose_namedata_encode(pri, &buffer[i], 1, call->connectedname);
++	if (size < 0)
++		return -1;
++	i += size;
++
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++
++	if (pri_call_apdu_queue(call, messagetype, buffer, i, NULL, NULL))
++		return -1;
++
++	return 0;
++}
++
++static int rose_connected_name_decode(struct pri *pri, q931_call *call, struct rose_component *sequence, int len)
++{
++	struct nameelements_name connectedname;
++	int res;
++
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "    Handle connectedName\n");
++
++	res = rose_name_decode(pri, (u_int8_t *)sequence, sequence->len + 2, &connectedname);
++	if (res < 0)
++		return -1;
++
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "     Received ConnectedName '%s', namepres %s(%d), characterset %s(%d)\n",
++		            connectedname.name, namepres_to_str(connectedname.namepres), connectedname.namepres,
++		            characterset_to_str(connectedname.characterset), connectedname.characterset);
++
++	if (connectedname.namepres != 0) {
++		libpri_copy_string(call->connectedname, connectedname.name, sizeof(call->connectedname));
++	} else {
++		call->connectedname[0] = '\0';
++	}
++
++	return 0;
++}
++
++int rose_connected_name_encode(struct pri *pri, q931_call *call, int messagetype)
++{
++	int i = 0, compsp = 0;
++	struct rose_component *comp, *compstk[10];
++	unsigned char buffer[256];
++	int size;
++
++	if (pri->debug & PRI_DEBUG_APDU)
++		pri_message(pri, "    Encode connectedName\n");
++
++	/* Protocol Profile = 0x1f (Networking Extensions)  (0x9f) */
++	buffer[i++] = (ASN1_CONTEXT_SPECIFIC | Q932_PROTOCOL_EXTENSIONS);
++
++	/* Network Facility Extension */
++	if (pri->switchtype == PRI_SWITCH_QSIG) {
++		/* tag component NetworkFacilityExtension (0xaa, len ) */
++		ASN1_ADD_SIMPLE(comp, COMP_TYPE_NFE, buffer, i);
++		ASN1_PUSH(compstk, compsp, comp);
++
++		/* sourceEntity  (0x80,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i, 0);	/* endPINX(0) */
++
++		/* destinationEntity  (0x82,0x01,0x00) */
++		ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2), buffer, i, 0);	/* endPINX(0) */
++		ASN1_FIXUP(compstk, compsp, buffer, i);
++	}
++
++	/* Network Protocol Profile */
++	/*  - not included - */
++
++	/* Interpretation APDU  (0x8b,0x01,0x00) */
++	ASN1_ADD_BYTECOMP(comp, COMP_TYPE_INTERPRETATION, buffer, i, 0);	/* discardAnyUnrecognisedInvokePdu(0) */
++
++	/* Service APDU(s): */
++
++	/* ROSE InvokePDU  (0xa1,len) */
++	ASN1_ADD_SIMPLE(comp, COMP_TYPE_INVOKE, buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* ROSE InvokeID  (0x02,0x01,invokeid) */
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, get_invokeid(pri));
++
++	/* ROSE operationId  (0x02,0x01,0x02)*/
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, SS_CNOP_CONNECTEDNAME);
++
++	/* tag component namePresentationAllowedSimple  (0x80,len) */
++	ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* namePresentationAllowedSimple, implicid NameData */
++	size = rose_namedata_encode(pri, &buffer[i], 1, call->connectedname);
++	if (size < 0)
++		return -1;
++	i += size;
++
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++
++	if (pri_call_apdu_queue(call, messagetype, buffer, i, NULL, NULL))
++		return -1;
++
++	return 0;
++}
++
++/* ===== Begin Call Completion Supplementary Service (ETS 300 366/ECMA 186) ===== */
++/* operationId e.g. QSIG_CCBSRINGOUT, QSIG_CC_CANCEL */
++int add_qsigCcInv_facility_ie (struct pri *pri, q931_call *c, int messagetype)
++{
+ 	int i = 0;
++	unsigned char buffer[256];
++	struct rose_component *comp = NULL, *compstk[10];
++	int compsp = 0;
++	u_int8_t operationId = c->ccoperation;
++
++	/* 1 Byte 	   0x80 | 0x1F = 9F	 Protocol Profile */
++	buffer[i++] = (ASN1_CONTEXT_SPECIFIC | Q932_PROTOCOL_EXTENSIONS);
++
++	/* Interpretation component */
++	ASN1_ADD_SIMPLE(comp, COMP_TYPE_NFE, buffer, i); /* 2. Byte NEtwork Facility Extension 0xAA = ASN1_CONTEXT_SPECIFIC(0x80) | (ASN1_CONSTRUCTOR 0x20)  0x0A (Tag laut Standard) */
++	ASN1_PUSH(compstk, compsp, comp);
++	ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i, 0);	/* (0x80, 0x01(len), 0x00) endPTNX */
++	ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2), buffer, i, 0);	/* (0x82, 0x01(len), 0x00) endPTNX */
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++
++	ASN1_ADD_BYTECOMP(comp, COMP_TYPE_INTERPRETATION, buffer, i, 0);   /* 0x8B, 0x01(len), 0x00 discard */
++	ASN1_ADD_SIMPLE(comp, COMP_TYPE_INVOKE, buffer, i);			 /* 0xA1, 0xXX (len of Invoke Sequenz) invoke APDU */
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* Invoke ID */
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, get_invokeid(pri));   /* 0x02 0x01 0xXX */
++
++	/* Operation ID: QSIG_CCBSRINGOUT, QSIG_CC_CANCEL */
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, operationId); /* 0x02 0x01 0x1f/0x1c */
++
++	/* CcExtension */
++	ASN1_ADD_SIMPLE(comp, ASN1_NULL, buffer, i); /* 0x05 0x00 */
++
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++
++	if (pri_call_apdu_queue(c, messagetype, buffer, i, NULL, NULL))
++		return -1;
++	
++	return 0;
++}
++
++static int rose_cc_ringout_inv_decode(struct pri *pri, struct qsig_cc_extension *cc_extension, struct rose_component *choice, int len) {
++	int i = 0;
++	cc_extension->cc_extension_tag = 0;
++
++	do {
++		switch(choice->type) {
++		case (ASN1_NULL):   /* none NULL */
++			cc_extension->cc_extension_tag = ASN1_NULL;
++			return 0;
++
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_14):   /* single [14] IMPLICIT Extension */
++			cc_extension->cc_extension_tag = ASN1_TAG_14;
++			return 0;
++
++
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_15):   /* multiple [15] IMPLICIT SEQUENCE OF Extension */
++			cc_extension->cc_extension_tag = ASN1_TAG_15;
++			return 0;
++
++		default:
++			if (choice->type == 0 && choice->len == 0) {
++				return 0;
++			}
++			pri_message(pri, "!! Invalid ss-cc-optional-Arg component received 0x%X\n", choice->type);
++			return -1;
++		}
++
++		if (i < len)
++			pri_message(pri, "     ss-cc-extension: !! not all information is handled !! i=%d / len=%d\n", i, len);
++
++		return 0;
++	}
++	while (0);
++
++	return -1;
++}
++
++static int rose_cc_optional_arg_decode(struct pri *pri, q931_call *call, struct qsig_cc_optional_arg *cc_optional_arg , struct rose_component *choice, int len) {
++	int i = 0;
++	int res = 0;
+ 	struct rose_component *comp = NULL;
++	unsigned char *vdata = choice->data;
++	struct addressingdataelements_presentednumberunscreened numberA;
++	struct addressingdataelements_presentednumberunscreened numberB;
++
++	cc_optional_arg->cc_extension.cc_extension_tag = 0;
++	cc_optional_arg->number_A[0] = '\0';
++	cc_optional_arg->number_B[0] = '\0';
++
++	do {
++		switch(choice->type) {
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_0):   /* fullArg [0] IMPLICIT SEQUENCE */
++			if (pri->debug & PRI_DEBUG_APDU)
++				pri_message(pri, "     ss-cc-optional-Arg: len=%d\n", len);
++
++			numberA.partyaddress[0] = '\0';
++
++			/* numberA */
++			GET_COMPONENT(comp, i, vdata, len);
++			res += rose_party_number_decode(pri, (u_int8_t *)comp, comp->len + 2, &numberA);
++			if (res < 0)
++				return -1;
++			comp->len = res;
++			if (res > 2) {
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     ss-cc-optional-Arg: Received numberA=%s\n", numberA.partyaddress);
++				strncpy(cc_optional_arg->number_A, numberA.partyaddress, 20);
++				cc_optional_arg->number_A[20] = '\0';
++			}
++			NEXT_COMPONENT(comp, i);
++
++			numberB.partyaddress[0] = '\0';
++
++			/* numberB */
++			GET_COMPONENT(comp, i, vdata, len);
++			res = rose_party_number_decode(pri, (u_int8_t *)comp, comp->len + 2, &numberB);
++			if (res < 0)
++				return -1;
++			comp->len = res;
++			if (res > 2) {
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     ss-cc-optional-Arg: Received numberB=%s\n", numberB.partyaddress);
++				strncpy(cc_optional_arg->number_B, numberB.partyaddress, 20);
++				cc_optional_arg->number_B[20] = '\0';
++			}
++			NEXT_COMPONENT(comp, i);
++
++			/* service */ /* PSS1InformationElement */
++			GET_COMPONENT(comp, i, vdata, len);
++			NEXT_COMPONENT(comp, i);
++
++			/* optional */
++			for (; i < len; NEXT_COMPONENT(comp, i)) {
++				GET_COMPONENT(comp, i, vdata, len);
++				switch(comp->type) {
++				case (ASN1_NULL):   /*  */
++					cc_optional_arg->cc_extension.cc_extension_tag = ASN1_NULL;
++					NEXT_COMPONENT(comp, i);
++					break;
++				case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_14):   /*  */
++					NEXT_COMPONENT(comp, i);
++					break;
++				case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_15):   /*  */
++					NEXT_COMPONENT(comp, i);
++					break;
++				default:
++					if (comp->type == 0 && comp->len == 0) {
++						return 0;
++						break; /* Found termination characters */
++					}
++					pri_message(pri, "!! Invalid ss-cc-optional-Arg component received 0x%X\n", comp->type);
++					return -1;
++				}
++			}
++
++			if (i < len)
++				pri_message(pri, "     ss-cc-optional-Arg: !! not all information is handled !! i=%d / len=%d\n", i, len);
++
++			return 0;
++
++		/* extArg CcExtension */
++		case (ASN1_NULL):   /* none NULL */
++			cc_optional_arg->cc_extension.cc_extension_tag = ASN1_NULL;
++			return 0;
++
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_14):   /* single [14] IMPLICIT Extension */
++			cc_optional_arg->cc_extension.cc_extension_tag = ASN1_TAG_14;
++			return 0;
++
++
++		case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_15):   /* multiple [15] IMPLICIT SEQUENCE OF Extension */
++			cc_optional_arg->cc_extension.cc_extension_tag = ASN1_TAG_15;
++			return 0;
++
++		default:
++			if (choice->type == 0 && choice->len == 0) {
++				return 0;
++			}
++			pri_message(pri, "!! Invalid ss-cc-optional-Arg component received 0x%X\n", choice->type);
++			return -1;
++		}
++
++		if (i < len)
++			pri_message(pri, "     ss-cc-optional-Arg: !! not all information is handled !! i=%d / len=%d\n", i, len);
++
++		return 0;
++	}
++	while (0);
++
++	return -1;
++}
++
++static int rose_cc_request_result_decode(struct pri *pri, struct qsig_cc_request_res *cc_request_res , struct rose_component *sequence, int len)
++{
++	int i = 0;
++	struct rose_component *comp = NULL;
+ 	unsigned char *vdata = sequence->data;
+-	int res = 0;
+ 
+-	struct addressingdataelements_presentednumberscreened redirection_number;
+-	redirection_number.partyaddress[0] = 0;
+-	redirection_number.partysubaddress[0] = 0;
+-	char redirection_name[50] = "";
+-	call->callername[0] = 0;
+-	call->callernum[0] = 0;
++	cc_request_res->no_path_reservation           = 0;  /* Default FALSE */
++	cc_request_res->retain_service                = 0;  /* Default FALSE */
++	cc_request_res->cc_extension.cc_extension_tag = 0;
+ 
+-
+ 	/* Data checks */
+ 	if (sequence->type != (ASN1_CONSTRUCTOR | ASN1_SEQUENCE)) { /* Constructed Sequence */
+-		pri_message(pri, "Invalid callTransferComplete argument. (Not a sequence)\n");
++		pri_message(pri, "Invalid cc request result argument. (Not a sequence)\n");
+ 		return -1;
+ 	}
+ 
+@@ -2126,75 +3809,55 @@
+ 		len -= 2;
+ 
+ 	if (pri->debug & PRI_DEBUG_APDU)
+-		pri_message(pri, "     CT-Complete: len=%d\n", len);
++		pri_message(pri, "     CC-request-Return-Result: len=%d\n", len);
+ 
+ 	do {
+-		/* Redirection Number */
+-		GET_COMPONENT(comp, i, vdata, len);
+-		res = rose_presented_number_screened_decode(pri, call, (u_int8_t *)comp, comp->len + 2, &redirection_number);
+-		if (res < 0)
+-			return -1;
+-		comp->len = res;
+-		if (res > 2) {
+-			if (pri->debug & PRI_DEBUG_APDU)
+-				pri_message(pri, "     CT-Complete: Received redirectionNumber=%s\n", redirection_number.partyaddress);
+-			strncpy(call->callernum, redirection_number.partyaddress, 20);
+-			call->callernum[20] = 0;
+-		}
+-		NEXT_COMPONENT(comp, i);
++		/* defaults and optional */
++		for (; i < len; NEXT_COMPONENT(comp, i)) {
++			GET_COMPONENT(comp, i, vdata, len);
++			switch(comp->type) {
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0):
++				/* no-path-reservation */
++				ASN1_GET_INTEGER(comp, cc_request_res->no_path_reservation);
++				NEXT_COMPONENT(comp, i);
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     cc request result: Received noPathReservation=%d\n", cc_request_res->no_path_reservation);
++				break;
+ 
+-		/* Redirection Name */
+-		GET_COMPONENT(comp, i, vdata, len);
+-		res = asn1_name_decode((u_int8_t *)comp, comp->len + 2, redirection_name, sizeof(redirection_name));
+-		if (res < 0)
+-			return -1;
+-		memcpy(call->callername, comp->data, comp->len);
+-		call->callername[comp->len] = 0;
+-		ASN1_FIXUP_LEN(comp, res);
+-		comp->len = res;
+-		NEXT_COMPONENT(comp, i);
+-		if (pri->debug & PRI_DEBUG_APDU)
+-			pri_message(pri, "     CT-Complete: Received redirectionName '%s'\n", redirection_name);
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_1):
++				/* retain_service */
++				ASN1_GET_INTEGER(comp, cc_request_res->retain_service);
++				NEXT_COMPONENT(comp, i);
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "     cc request result: Received retainService=%d\n", cc_request_res->retain_service);
++				break;
+ 
++			case (ASN1_NULL):   /*  */
++				cc_request_res->cc_extension.cc_extension_tag = ASN1_NULL;
++				NEXT_COMPONENT(comp, i);
++				break;
+ 
+-#if 0 /* This one is optional. How do we check if it is there? */
+-		/* Basic Call Info Elements */
+-		GET_COMPONENT(comp, i, vdata, len);
+-		NEXT_COMPONENT(comp, i);
+-#endif
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_14):
++				cc_request_res->cc_extension.cc_extension_tag = ASN1_TAG_14;
++				NEXT_COMPONENT(comp, i);
++				break;
+ 
++			case (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_15):
++				cc_request_res->cc_extension.cc_extension_tag = ASN1_TAG_15;
++				NEXT_COMPONENT(comp, i);
++				break;
+ 
+-		/* Argument Extension */
+-#if 0 /* Not supported */
+-		GET_COMPONENT(comp, i, vdata, len);
+-		switch (comp->type) {
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_9):   /* [9] IMPLICIT Extension */
+-				res = rose_extension_decode(pri, call, comp->data, comp->len, &redirection_number);
+-				if (res < 0)
+-					return -1;
+-				ASN1_FIXUP_LEN(comp, res);
+-				comp->len = res;
+-
+-			case (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_10):    /* [10] IMPLICIT SEQUENCE OF Extension */
+-				res = rose_sequence_of_extension_decode(pri, call, comp->data, comp->len, &redirection_number);
+-				if (res < 0)
+-					return -1;
+-				ASN1_FIXUP_LEN(comp, res);
+-				comp->len = res;
+-
+ 			default:
+-				pri_message(pri, "     CT-Complete: !! Unknown argumentExtension received 0x%X\n", comp->type);
++				if (comp->type == 0 && comp->len == 0) {
++					break; /* Found termination characters */
++				}
++				pri_message(pri, "!! Invalid ss-cc-optional-Arg component received 0x%X\n", comp->type);
+ 				return -1;
++			}
+ 		}
+-#else
+-		GET_COMPONENT(comp, i, vdata, len);
+-		ASN1_FIXUP_LEN(comp, res);
+-		NEXT_COMPONENT(comp, i);
+-#endif
+ 
+-		if(i < len)
+-			pri_message(pri, "     CT-Complete: !! not all information is handled !! i=%d / len=%d\n", i, len);
+-
++		if (i < len)
++			pri_message(pri, "     ss-cc-optional-Arg: !! not all information is handled !! i=%d / len=%d\n", i, len);
+ 		return 0;
+ 	}
+ 	while (0);
+@@ -2202,11 +3865,18 @@
+ 	return -1;
+ }
+ 
++static int rose_ccbs_request_result_decode(struct pri *pri, struct qsig_cc_request_res *cc_request_res , struct rose_component *sequence, int len)
++{
++	return rose_cc_request_result_decode(pri, cc_request_res , sequence, len);
++}
+ 
+-/* ===== End Call Transfer Supplementary Service (ECMA-178) ===== */
++static int rose_ccnr_request_result_decode(struct pri *pri, struct qsig_cc_request_res *cc_request_res , struct rose_component *sequence, int len)
++{
++	return rose_cc_request_result_decode(pri, cc_request_res , sequence, len);
++}
++/* ===== End Call Completion Supplementary Service (ETS 300 366/ECMA 186) ===== */
+ 
+ 
+-
+ int rose_reject_decode(struct pri *pri, q931_call *call, q931_ie *ie, unsigned char *data, int len)
+ {
+ 	int i = 0;
+@@ -2267,7 +3937,7 @@
+ 
+ 			return 0;
+ 		} else {
+-			pri_message(pri, "Unable to handle return result on switchtype %d!\n", pri->switchtype);
++			pri_message(pri, "Unable to handle reject on switchtype %d!\n", pri->switchtype);
+ 			return -1;
+ 		}
+ 
+@@ -2275,6 +3945,20 @@
+ 	
+ 	return -1;
+ }
++
++
++static struct subcommand *get_ptr_subcommand(struct subcommands *sub)
++{
++	if (sub->counter_subcmd < MAX_SUBCOMMANDS) {
++		int count = sub->counter_subcmd;
++		sub->counter_subcmd++;
++		return &sub->subcmd[count];
++	}
++
++	return NULL;
++}
++
++
+ int rose_return_error_decode(struct pri *pri, q931_call *call, q931_ie *ie, unsigned char *data, int len)
+ {
+ 	int i = 0;
+@@ -2283,6 +3967,7 @@
+ 	unsigned char *vdata = data;
+ 	struct rose_component *comp = NULL;
+ 	char *invokeidstr, *errorstr;
++	struct subcommand *c_subcmd;
+ 	
+ 	do {
+ 		/* Invoke ID stuff */
+@@ -2329,9 +4014,39 @@
+ 			pri_error(pri, "\tERROR: %s\n", errorstr);
+ 
+ 			return 0;
++		} else if (pri->switchtype == PRI_SWITCH_QSIG) {
++			switch (errorvalue) {
++			case 1008:
++				errorstr = "Unspecified";
++				break;
++			case 1012:
++				errorstr = "Remote user busy again";
++				break;
++			case 1013:
++				errorstr = "Failure to match";
++				break;
++			default:
++				errorstr = "Unknown";
++			}
++
++			c_subcmd = get_ptr_subcommand(&call->subcmds);
++			if (!c_subcmd) {
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE RETURN ERROR %i - more than %d facilities !\n", errorvalue, MAX_SUBCOMMANDS);
++				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				return -1;
++			}
++
++			if (pri->debug & PRI_DEBUG_APDU)
++			{
++				pri_message(pri, "ROSE RETURN RESULT %i:   %s\n", errorvalue, errorstr);
++				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++			}
++			c_subcmd->cmd = CMD_CC_ERROR;
++			c_subcmd->cc_error.error_value = errorvalue;
++			return 0;
+ 		} else {
+-			pri_message(pri, "Unable to handle return result on switchtype %d!\n", pri->switchtype);
+-			return -1;
++			pri_message(pri, "Unable to handle return error on switchtype %d!\n", pri->switchtype);
+ 		}
+ 
+ 	} while(0);
+@@ -2346,6 +4061,8 @@
+ 	int invokeidvalue = -1;
+ 	unsigned char *vdata = data;
+ 	struct rose_component *comp = NULL;
++	int res;
++	struct subcommand *c_subcmd;
+ 	
+ 	do {
+ 		/* Invoke ID stuff */
+@@ -2392,11 +4109,90 @@
+ 				return -1;
+ 			}
+ 		} else if (pri->switchtype == PRI_SWITCH_QSIG) {
+-			switch (invokeidvalue) {
+-			case 0x13:
+-				if (pri->debug & PRI_DEBUG_APDU) pri_message(pri, "Successfully completed QSIG CF callRerouting!\n");
++			int operation_tag;
++
++			/* sequence is optional */
++			if (i >= len) 
+ 				return 0;
++
++			/* Data checks, sequence is optional */
++			GET_COMPONENT(comp, i, vdata, len);
++			if (comp->type != (ASN1_CONSTRUCTOR | ASN1_SEQUENCE)) { /* Constructed Sequence */
++				pri_message(pri, "No arguments on cc-return result\n");
++				return 0;
+ 			}
++
++			if (comp->len == ASN1_LEN_INDEF) {
++				len -= 2; /* For the 2 extra characters at the end*/
++			}
++
++			/* Traverse the contents of this sequence */
++			SUB_COMPONENT(comp, i);
++
++			/* Operation Tag */
++			GET_COMPONENT(comp, i, vdata, len);
++			CHECK_COMPONENT(comp, ASN1_INTEGER, "Don't know what to do if second ROSE component is of type 0x%x\n");
++			ASN1_GET_INTEGER(comp, operation_tag);
++			NEXT_COMPONENT(comp, i);
++
++			/* No argument - return with error */
++			if (i >= len) 
++				return -1;
++
++			/* Arguement Tag */
++			GET_COMPONENT(comp, i, vdata, len);
++			if (!comp->type)
++				return -1;
++
++			if (pri->debug & PRI_DEBUG_APDU)
++				pri_message(pri, "  [ Handling operation %d ]\n", operation_tag);
++			switch (operation_tag) {
++			case QSIG_CF_CALLREROUTING:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "Successfully completed QSIG CF callRerouting!\n");
++				return 0;
++
++			case QSIG_CC_CCBSREQUEST:
++				c_subcmd = get_ptr_subcommand(&call->subcmds);
++				if (!c_subcmd) {
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "ROSE %i:  return_result CcCcbsRequest - more than %d facilities !\n", operation_tag, MAX_SUBCOMMANDS);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++					return -1;
++				}
++				if (pri->debug & PRI_DEBUG_APDU)
++				{
++					pri_message(pri, "ROSE %i:   Handle CcCcbsRequest\n", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				c_subcmd->cmd = CMD_CC_CCBSREQUEST_RR;
++				res = rose_ccbs_request_result_decode(pri, &c_subcmd->cc_ccbs_rr.cc_request_res, comp, len-i);
++				return res;
++
++			case QSIG_CC_CCNRREQUEST:
++				c_subcmd = get_ptr_subcommand(&call->subcmds);
++				if (!c_subcmd) {
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "ROSE %i:  return_result CcCcnrRequest - more than %d facilities !\n", operation_tag, MAX_SUBCOMMANDS);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++					return -1;
++				}
++				if (pri->debug & PRI_DEBUG_APDU)
++				{
++					pri_message(pri, "ROSE %i:   Handle CcCcnrRequest\n", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				c_subcmd->cmd = CMD_CC_CCNRREQUEST_RR;
++				res = rose_ccnr_request_result_decode(pri, &c_subcmd->cc_ccnr_rr.cc_request_res, comp, len-i);
++				return res;
++
++			default:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "!! Unable to handle ROSE operation %d", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return -1;
++			}
+ 		} else {
+ 			pri_message(pri, "Unable to handle return result on switchtype %d!\n", pri->switchtype);
+ 			return -1;
+@@ -2414,6 +4210,7 @@
+ 	int operation_tag;
+ 	unsigned char *vdata = data;
+ 	struct rose_component *comp = NULL, *invokeid = NULL, *operationid = NULL;
++	struct subcommand *c_subcmd;
+ 	
+ 	do {
+ 		/* Invoke ID stuff */
+@@ -2444,126 +4241,294 @@
+ 
+ 		if (pri->debug & PRI_DEBUG_APDU)
+ 			pri_message(pri, "  [ Handling operation %d ]\n", operation_tag);
+-		switch (operation_tag) {
+-		case SS_CNID_CALLINGNAME:
+-			if (pri->debug & PRI_DEBUG_APDU)
+-				pri_message(pri, "  Handle Name display operation\n");
+- 			return rose_calling_name_decode(pri, call, comp, len-i);
+-		case ROSE_CALL_TRANSFER_IDENTIFY:
+-			if (pri->debug & PRI_DEBUG_APDU)
+-				pri_message(pri, "ROSE %i:   CallTransferIdentify - not handled!\n", operation_tag);
+-			dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			return -1;
+-		case ROSE_CALL_TRANSFER_ABANDON:
+-			if (pri->debug & PRI_DEBUG_APDU)
+-				pri_message(pri, "ROSE %i:   CallTransferAbandon - not handled!\n", operation_tag);
+-			dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			return -1;
+-		case ROSE_CALL_TRANSFER_INITIATE:
+-			if (pri->debug & PRI_DEBUG_APDU)
+-				pri_message(pri, "ROSE %i:   CallTransferInitiate - not handled!\n", operation_tag);
+-			dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			return -1;
+-		case ROSE_CALL_TRANSFER_SETUP:
+-			if (pri->debug & PRI_DEBUG_APDU)
+-				pri_message(pri, "ROSE %i:   CallTransferSetup - not handled!\n", operation_tag);
+-			dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			return -1;
+-		case ROSE_CALL_TRANSFER_ACTIVE:
+-			if (pri->debug & PRI_DEBUG_APDU)
+-				pri_message(pri, "ROSE %i:   CallTransferActive - not handled!\n", operation_tag);
+-			dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			return -1;
+-		case ROSE_CALL_TRANSFER_COMPLETE:
+-			if (pri->debug & PRI_DEBUG_APDU)
+-			{
+-				pri_message(pri, "ROSE %i:   Handle CallTransferComplete\n", operation_tag);
++
++		if (pri->switchtype == PRI_SWITCH_QSIG) {
++
++			switch (operation_tag) {
++			case SS_CNID_CALLINGNAME:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "ROSE %i:   Handle CallingName\n", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return rose_calling_name_decode(pri, call, comp, len-i);
++			case SS_CNOP_CALLEDNAME:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "ROSE %i:   Handle CalledName\n", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return rose_called_name_decode(pri, call, comp, len-i);
++			case SS_CNOP_CONNECTEDNAME:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "ROSE %i:   Handle ConnectedName\n", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return rose_connected_name_decode(pri, call, comp, len-i);
++			case ROSE_CALL_TRANSFER_IDENTIFY:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   CallTransferIdentify - not handled!\n", operation_tag);
+ 				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			}
+-			return rose_call_transfer_complete_decode(pri, call, comp, len-i);
+-		case ROSE_CALL_TRANSFER_UPDATE:
+-			if (pri->debug & PRI_DEBUG_APDU)
+-			{
+-				pri_message(pri, "ROSE %i:    Handle CallTransferUpdate\n", operation_tag);
++				return -1;
++			case ROSE_CALL_TRANSFER_ABANDON:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   CallTransferAbandon - not handled!\n", operation_tag);
+ 				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			}
+-			return rose_call_transfer_update_decode(pri, call, comp, len-i);
+-		case ROSE_SUBADDRESS_TRANSFER:
+-			if (pri->debug & PRI_DEBUG_APDU)
+-				pri_message(pri, "ROSE %i:   SubaddressTransfer - not handled!\n", operation_tag);
+-			dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			return -1;
+-		case ROSE_DIVERTING_LEG_INFORMATION2:
+-			if (pri->debug & PRI_DEBUG_APDU) {
+- 				pri_message(pri, "ROSE %i:   Handle CallingName\n", operation_tag);
+- 				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-  			}
+-			return rose_diverting_leg_information2_decode(pri, call, comp, len-i);
+-		case ROSE_AOC_NO_CHARGING_INFO_AVAILABLE:
+-			if (pri->debug & PRI_DEBUG_APDU) {
+-				pri_message(pri, "ROSE %i: AOC No Charging Info Available - not handled!", operation_tag);
+-				dump_apdu (pri, comp->data, comp->len);
+-			}
+-			return -1;
+-		case ROSE_AOC_CHARGING_REQUEST:
+-			return aoc_aoce_charging_request_decode(pri, call, (u_int8_t *)comp, comp->len + 2);
+-		case ROSE_AOC_AOCS_CURRENCY:
+-			if (pri->debug & PRI_DEBUG_APDU) {
+-				pri_message(pri, "ROSE %i: AOC-S Currency - not handled!", operation_tag);
++				return -1;
++			case ROSE_CALL_TRANSFER_INITIATE:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   CallTransferInitiate - not handled!\n", operation_tag);
+ 				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			}
+-			return -1;
+-		case ROSE_AOC_AOCS_SPECIAL_ARR:
+-			if (pri->debug & PRI_DEBUG_APDU) {
+-				pri_message(pri, "ROSE %i: AOC-S Special Array - not handled!", operation_tag);
++				return -1;
++			case ROSE_CALL_TRANSFER_SETUP:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   CallTransferSetup - not handled!\n", operation_tag);
+ 				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			}
+-			return -1;
+-		case ROSE_AOC_AOCD_CURRENCY:
+-			if (pri->debug & PRI_DEBUG_APDU) {
+-				pri_message(pri, "ROSE %i: AOC-D Currency - not handled!", operation_tag);
++				return -1;
++			case ROSE_CALL_TRANSFER_ACTIVE:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   Handle CallTransferActive\n", operation_tag);
+ 				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			}
+-			return -1;
+-		case ROSE_AOC_AOCD_CHARGING_UNIT:
+-			if (pri->debug & PRI_DEBUG_APDU) {
+-				pri_message(pri, "ROSE %i: AOC-D Charging Unit - not handled!", operation_tag);
++				return rose_call_transfer_active_decode(pri, call, comp, len-i);
++			case ROSE_CALL_TRANSFER_COMPLETE:
++				if (pri->debug & PRI_DEBUG_APDU)
++				{
++					pri_message(pri, "ROSE %i:   Handle CallTransferComplete\n", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return rose_call_transfer_complete_decode(pri, call, comp, len-i);
++			case ROSE_CALL_TRANSFER_UPDATE:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   CallTransferUpdate - not handled!\n", operation_tag);
+ 				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			}
+-			return -1;
+-		case ROSE_AOC_AOCE_CURRENCY:
+-			if (pri->debug & PRI_DEBUG_APDU) {
+-				pri_message(pri, "ROSE %i: AOC-E Currency - not handled!", operation_tag);
++				return -1;
++			case ROSE_SUBADDRESS_TRANSFER:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   SubaddressTransfer - not handled!\n", operation_tag);
+ 				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
+-			}
+-			return -1;
+-		case ROSE_AOC_AOCE_CHARGING_UNIT:
+-			return aoc_aoce_charging_unit_decode(pri, call, (u_int8_t *)comp, comp->len + 2);
+-			if (0) { /* the following function is currently not used - just to make the compiler happy */
+-				aoc_aoce_charging_unit_encode(pri, call, call->aoc_units); /* use this function to forward the aoc-e on a bridged channel */ 
++				return -1;
++			case ROSE_DIVERTING_LEG_INFORMATION1:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "  Handle DivertingLegInformation1\n");
++				return rose_diverting_leg_information1_decode(pri, call, comp, len-i);
++			case ROSE_DIVERTING_LEG_INFORMATION2:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "  Handle DivertingLegInformation2\n");
++				return rose_diverting_leg_information2_decode(pri, call, comp, len-i);
++			case ROSE_DIVERTING_LEG_INFORMATION3:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "  Handle DivertingLegInformation3\n");
++				return rose_diverting_leg_information3_decode(pri, call, comp, len-i);
++			case SS_ANFPR_PATHREPLACEMENT:
++				/* Clear Queue */
++				res = pri_call_apdu_queue_cleanup(call->bridged_call);
++				if (res) {
++					pri_message(pri, "Could not Clear queue ADPU\n");
++					return -1;
++				}
++				anfpr_pathreplacement_respond(pri, call, ie);
++				break;
++			case QSIG_CC_CCBSREQUEST:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:  invoke CcbsRequest - not handled!\n", operation_tag);
++				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				return -1;
++			case QSIG_CC_CCNRREQUEST:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:  invoke CcnrRequest - not handled!\n", operation_tag);
++				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				return -1;
++			case QSIG_CC_CANCEL:
++				c_subcmd = get_ptr_subcommand(&call->subcmds);
++				if (!c_subcmd) {
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "ROSE %i:  invoke CcCancel - more than %d facilities !\n", operation_tag, MAX_SUBCOMMANDS);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++					return -1;
++				}
++				if (pri->debug & PRI_DEBUG_APDU)
++				{
++					pri_message(pri, "ROSE %i:   Handle CcCancel\n", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				c_subcmd->cmd = CMD_CC_CANCEL_INV;
++				res = rose_cc_optional_arg_decode(pri, call, &c_subcmd->cc_cancel_inv.cc_optional_arg, comp, len-i);
++				return res;
++			case QSIG_CC_EXECPOSIBLE:
++				c_subcmd = get_ptr_subcommand(&call->subcmds);
++				if (!c_subcmd) {
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "ROSE %i:  invoke CcExecposible - more than %d facilities !\n", operation_tag, MAX_SUBCOMMANDS);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++					return -1;
++				}
++				if (pri->debug & PRI_DEBUG_APDU)
++				{
++					pri_message(pri, "ROSE %i:   Handle CcExecposible\n", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				c_subcmd->cmd = CMD_CC_EXECPOSIBLE_INV;
++				res = rose_cc_optional_arg_decode(pri, call, &c_subcmd->cc_execposible_inv.cc_optional_arg, comp, len-i);
++				return res;
++			case QSIG_CC_PATHRESERVE:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:  invoke CcPathreserve - not handled!\n", operation_tag);
++				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				return -1;
++			case QSIG_CC_RINGOUT:
++				c_subcmd = get_ptr_subcommand(&call->subcmds);
++				if (!c_subcmd) {
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "ROSE %i:  invoke CcRingout - more than %d facilities !\n", operation_tag, MAX_SUBCOMMANDS);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++					return -1;
++				}
++				if (pri->debug & PRI_DEBUG_APDU)
++				{
++					pri_message(pri, "ROSE %i:   Handle CcRingout\n", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				c_subcmd->cmd = CMD_CC_RINGOUT_INV;
++				res = rose_cc_ringout_inv_decode(pri, &c_subcmd->cc_ringout_inv.cc_extension, comp, len-i);
++				return res;
++			case QSIG_CC_SUSPEND:
++				if (pri->debug & PRI_DEBUG_APDU)
++				{
++					pri_message(pri, "ROSE %i:   Handle CcSuspend\n", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
+ 				return 0;
+-			}
+-		case ROSE_AOC_IDENTIFICATION_OF_CHARGE:
+-			if (pri->debug & PRI_DEBUG_APDU) {
+-				pri_message(pri, "ROSE %i: AOC Identification Of Charge - not handled!", operation_tag);
++			case QSIG_CC_RESUME:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:  invoke CcResume - not handled!\n", operation_tag);
+ 				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				return -1;
++			default:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "!! Unable to handle ROSE operation %d", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return -1;
+ 			}
+-			return -1;
+-                case SS_ANFPR_PATHREPLACEMENT:
+-			/* Clear Queue */
+-			res = pri_call_apdu_queue_cleanup(call->bridged_call);
+-			if (res) {
+-			        pri_message(pri, "Could not Clear queue ADPU\n");
+-			        return -1;
+-			}
+-			anfpr_pathreplacement_respond(pri, call, ie);
+-                        break;
+-		default:
+-			if (pri->debug & PRI_DEBUG_APDU) {
+-				pri_message(pri, "!! Unable to handle ROSE operation %d", operation_tag);
++		} else { /* pri->switchtype == PRI_SWITCH_QSIG */
++
++			switch (operation_tag) {
++			case SS_CNID_CALLINGNAME:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "ROSE %i:   Handle CallingName\n", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return rose_calling_name_decode(pri, call, comp, len-i);
++			case ROSE_CALL_TRANSFER_IDENTIFY:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   CallTransferIdentify - not handled!\n", operation_tag);
+ 				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				return -1;
++			case ROSE_CALL_TRANSFER_ABANDON:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   CallTransferAbandon - not handled!\n", operation_tag);
++				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				return -1;
++			case ROSE_CALL_TRANSFER_INITIATE:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   CallTransferInitiate - not handled!\n", operation_tag);
++				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				return -1;
++			case ROSE_CALL_TRANSFER_SETUP:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   CallTransferSetup - not handled!\n", operation_tag);
++				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				return -1;
++			case ROSE_CALL_TRANSFER_ACTIVE:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   Handle CallTransferActive\n", operation_tag);
++				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				return rose_call_transfer_active_decode(pri, call, comp, len-i);
++			case ROSE_CALL_TRANSFER_COMPLETE:
++				if (pri->debug & PRI_DEBUG_APDU)
++				{
++					pri_message(pri, "ROSE %i:   Handle CallTransferComplete\n", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return rose_call_transfer_complete_decode(pri, call, comp, len-i);
++			case ROSE_CALL_TRANSFER_UPDATE:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   CallTransferUpdate - not handled!\n", operation_tag);
++				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				return -1;
++			case ROSE_SUBADDRESS_TRANSFER:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "ROSE %i:   SubaddressTransfer - not handled!\n", operation_tag);
++				dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				return -1;
++			case ROSE_DIVERTING_LEG_INFORMATION2:
++				if (pri->debug & PRI_DEBUG_APDU)
++					pri_message(pri, "  Handle DivertingLegInformation2\n");
++				return rose_diverting_leg_information2_decode(pri, call, comp, len-i);
++			case ROSE_AOC_NO_CHARGING_INFO_AVAILABLE:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "ROSE %i: AOC No Charging Info Available - not handled!", operation_tag);
++					dump_apdu (pri, comp->data, comp->len);
++				}
++				return -1;
++			case ROSE_AOC_CHARGING_REQUEST:
++				return aoc_aoce_charging_request_decode(pri, call, (u_int8_t *)comp, comp->len + 2);
++			case ROSE_AOC_AOCS_CURRENCY:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "ROSE %i: AOC-S Currency - not handled!", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return -1;
++			case ROSE_AOC_AOCS_SPECIAL_ARR:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "ROSE %i: AOC-S Special Array - not handled!", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return -1;
++			case ROSE_AOC_AOCD_CURRENCY:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "ROSE %i: AOC-D Currency - not handled!", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return -1;
++			case ROSE_AOC_AOCD_CHARGING_UNIT:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "ROSE %i: AOC-D Charging Unit - not handled!", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return -1;
++			case ROSE_AOC_AOCE_CURRENCY:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "ROSE %i: AOC-E Currency - not handled!", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return -1;
++			case ROSE_AOC_AOCE_CHARGING_UNIT:
++				return aoc_aoce_charging_unit_decode(pri, call, (u_int8_t *)comp, comp->len + 2);
++				if (0) { /* the following function is currently not used - just to make the compiler happy */
++					aoc_aoce_charging_unit_encode(pri, call, call->aoc_units); /* use this function to forward the aoc-e on a bridged channel */
++					return 0;
++				}
++			case ROSE_AOC_IDENTIFICATION_OF_CHARGE:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "ROSE %i: AOC Identification Of Charge - not handled!", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return -1;
++			case SS_ANFPR_PATHREPLACEMENT:
++				/* Clear Queue */
++				res = pri_call_apdu_queue_cleanup(call->bridged_call);
++				if (res) {
++					pri_message(pri, "Could not Clear queue ADPU\n");
++					return -1;
++				}
++				anfpr_pathreplacement_respond(pri, call, ie);
++				break;
++			default:
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "!! Unable to handle ROSE operation %d", operation_tag);
++					dump_apdu (pri, (u_int8_t *)comp, comp->len + 2);
++				}
++				return -1;
+ 			}
+-			return -1;
+ 		}
+ 	} while(0);
+ 	
+@@ -2619,15 +4584,119 @@
+ 	return 0;
+ }
+ 
++/* ===== Begin Call Completion Supplementary Service (ETS 300 366/ECMA 186) ===== */
++/* operationId e.g. QSIG_CC_CCBS_REQUEST and QSIG_CC_CCNR_REQUEST */
++static int add_qsigCcRequestArg_facility_ie (struct pri *pri, q931_call *c)
++{
++	int size = 0;
++	int i = 0;
++	unsigned char buffer[256];
++	struct rose_component *comp = NULL, *compstk[10];
++	int compsp = 0;
++	u_int8_t operationId = c->ccoperation;
++	char *numberA = c->callernum;
++	char *numberB = c->callednum;
++ 
++	/* 1 Byte 	   0x80 | 0x1F = 9F	 Protocol Profile (0x93 wäre altes QSIG oder DDS1) */
++	buffer[i++] = (ASN1_CONTEXT_SPECIFIC | Q932_PROTOCOL_EXTENSIONS);
++
++	/* Interpretation component */
++	ASN1_ADD_SIMPLE(comp, COMP_TYPE_NFE, buffer, i); /* 2. Byte NEtwork Facility Extension 0xAA = ASN1_CONTEXT_SPECIFIC(0x80) | (ASN1_CONSTRUCTOR 0x20)  0x0A (Tag laut Standard) */
++	ASN1_PUSH(compstk, compsp, comp);
++
++	ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_0), buffer, i, 0);	/* (0x80, 0x01(len), 0x00) endPTNX */
++	ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_2), buffer, i, 0);	/* (0x82, 0x01(len), 0x00) endPTNX */
++
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++
++#if 0
++	ASN1_ADD_BYTECOMP(comp, COMP_TYPE_INTERPRETATION, buffer, i, 0);   /* 0x8B, 0x01(len), 0x00 discard */
++#endif
++	ASN1_ADD_SIMPLE(comp, COMP_TYPE_INVOKE, buffer, i);			 /* 0xA1, 0xXX (len of Invoke Sequenz) invoke APDU */
++	ASN1_PUSH(compstk, compsp, comp);
++
++	/* Invoke ID */
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, get_invokeid(pri));   /* InvokeID 0x02 0x01 0xXX */
++
++	/*CcbsRequest ::= 40 or CcnrRequest ::= 27 */
++	/* Operation ID: CCBS/CCNR */
++	ASN1_ADD_BYTECOMP(comp, ASN1_INTEGER, buffer, i, operationId); /* 0x02 0x01 0x28/0x1b */
++
++	/* ccbs/ccnr request argument */
++	/* PresentedNumberUnscreened */
++	ASN1_ADD_SIMPLE(comp, (ASN1_CONSTRUCTOR | ASN1_SEQUENCE), buffer, i); /*0x30 0xXX (len)*/
++	ASN1_PUSH(compstk, compsp, comp);
++	/* (0xA0, 0x01(len)) presentationAlloweAddress  [0] PartyNumber */
++	/* (0xA1, 0xXX (len) publicPartyNumber [1] IMPLICIT PublicPartyNumber */
++	/* (0x0A, 0x01, 0x00 ) type of public party number = subscriber number */
++	/* (0x12, 0xXX (len), 0xXX .. 0xXX) numeric string */
++	size = rose_presented_number_unscreened_encode(pri, &buffer[i], PRES_ALLOWED, Q932_TON_UNKNOWN, numberA);
++	if (size < 0)
++		return -1;
++	i += size;
++
++	/* (0xA1, 0xXX (len) [1] IMPLICIT PublicPartyNumber */
++	ASN1_ADD_SIMPLE(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTOR | ASN1_TAG_1), buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++	/* (0x0A, 0x01, 0x00 ) type of public party number = subscriber number */
++	/* (0x12, 0xXX (len), 0xXX .. 0xXX) numeric string */
++	size = rose_public_party_number_encode(pri, comp->data, 1, Q932_TON_UNKNOWN, numberB);
++	if (size < 0)
++		return -1;
++	i += size;
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++
++	/* (0x40, 0xXX (len), 0xXX .. 0xXX) pSS1InfoElement */
++	ASN1_ADD_SIMPLE(comp, (ASN1_APPLICATION | ASN1_TAG_0 ), buffer, i);
++	ASN1_PUSH(compstk, compsp, comp);
++	buffer[i++] = (0x04);	/*  add Bearer Capability IE */
++	buffer[i++] = (0x03);	/* len*/
++	buffer[i++] = (0x80);	/* ETSI Standard, Speech */
++	buffer[i++] = (0x90);	/* circuit mode, 64kbit/s */
++	buffer[i++] = (0xa3);	/* level1 protocol, a-law */
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++#if 0
++	/* can-retain-service [12] IMPLICIT BOOLEAN DEFAULT FALSE,*/
++	ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_12), buffer, i, 0);   /* 0x1C, 0x01(len), 0x00 false */
++#endif
++	/* retain-sig-connection [13] IMPLICIT BOOLEAN OPTIONAL, --TRUE: sign. connection to be retained */	 
++	ASN1_ADD_BYTECOMP(comp, (ASN1_CONTEXT_SPECIFIC | ASN1_TAG_13), buffer, i, 1);   /* 0x1D, 0x01(len), 0x01 true */
++
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++
++	ASN1_FIXUP(compstk, compsp, buffer, i);
++
++	if (pri_call_apdu_queue(c, Q931_SETUP, buffer, i, NULL, NULL))
++		return -1;
++	
++	return 0;
++}
++/* ===== End Call Completion Supplementary Service (ETS 300 366/ECMA 186) ===== */
++
+ int pri_call_add_standard_apdus(struct pri *pri, q931_call *call)
+ {
+ 	if (!pri->sendfacility)
+ 		return 0;
+ 
+ 	if (pri->switchtype == PRI_SWITCH_QSIG) { /* For Q.SIG it does network and cpe operations */
+-		if (call->redirectingnum[0]) 
++		if (call->redirectingnum[0])
+ 			rose_diverting_leg_information2_encode(pri, call);
+ 		add_callername_facility_ies(pri, call, 1);
++		if (call->ccoperation) {
++			switch(call->ccoperation) {
++			case 0:
++				break;
++			case QSIG_CC_CCBSREQUEST:
++			case QSIG_CC_CCNRREQUEST:
++				add_qsigCcRequestArg_facility_ie(pri, call);
++				break;
++			case QSIG_CC_RINGOUT:
++				add_qsigCcInv_facility_ie(pri, call, Q931_SETUP);
++				break;
++			default:
++				break;
++			}
++		}
+ 		return 0;
+ 	}
+ 
+@@ -2665,3 +4734,26 @@
+ 	return 0;
+ }
+ 
++int qsig_initiate_diverting_leg_information1(struct pri *pri, q931_call *call)
++{
++	rose_diverting_leg_information1_encode(pri, call);
++
++	if (q931_facility(pri, call)) {
++		pri_message(pri, "Could not schedule facility message for divertingLegInfo1\n");
++		return -1;
++	}
++
++	return 0;
++}
++
++int qsig_initiate_call_transfer_complete(struct pri *pri, q931_call *call, int call_status)
++{
++	rose_call_transfer_complete_encode(pri, call, call_status);
++
++	if (q931_facility(pri, call)) {
++		pri_message(pri, "Could not schedule facility message for callTransferComplete\n");
++		return -1;
++	}
++
++	return 0;
++}
+Index: pri_timers.h
+===================================================================
+--- a/pri_timers.h	(.../tags/1.4.9)	(revision 700)
++++ b/pri_timers.h	(.../team/group/issue14292)	(revision 700)
+@@ -62,6 +62,7 @@
+ 				-1,		/* T322 */ \
+ 				2500,	/* TM20 - Q.921 Appendix IV */ \
+ 				3,		/* NM20 - Q.921 Appendix IV */ \
++				45*60*1000	/* CC-Timer2 45 min */\
+ 			}
+ 
+ /* XXX Only our default timers are setup now XXX */
+Index: pri_facility.h
+===================================================================
+--- a/pri_facility.h	(.../tags/1.4.9)	(revision 700)
++++ b/pri_facility.h	(.../team/group/issue14292)	(revision 700)
+@@ -38,14 +38,6 @@
+ #define Q932_PROTOCOL_GAT			0x16
+ #define Q932_PROTOCOL_EXTENSIONS	0x1F
+ 
+-/* Argument values */
+-#define ROSE_NAME_PRESENTATION_ALLOWED_SIMPLE	0x80
+-#define ROSE_NAME_PRESENTATION_RESTRICTED_NULL	0x87
+-#define ROSE_NAME_PRESENTATION_ALLOWED_EXTENDED    0xA1
+-#define ROSE_NAME_PRESENTATION_RESTRICTED_SIMPLE   0xA2
+-#define ROSE_NAME_PRESENTATION_RESTRICTED_EXTENDED 0xA3
+-#define ROSE_NAME_NOT_AVAIL			0x84
+-
+ /* Component types */
+ #define COMP_TYPE_INTERPRETATION			0x8B
+ #define COMP_TYPE_NETWORK_PROTOCOL_PROFILE	0x92
+@@ -65,10 +57,11 @@
+ #define ROSE_CALL_TRANSFER_COMPLETE			12
+ #define ROSE_CALL_TRANSFER_UPDATE			13
+ #define ROSE_SUBADDRESS_TRANSFER 			14
++#define QSIG_CF_CALLREROUTING 				19
+ /* Q.952 ROSE operations (Diverting) */
+-#define ROSE_DIVERTING_LEG_INFORMATION1		18
+-#define ROSE_DIVERTING_LEG_INFORMATION2		0x15
+-#define ROSE_DIVERTING_LEG_INFORMATION3		19
++#define ROSE_DIVERTING_LEG_INFORMATION1			20
++#define ROSE_DIVERTING_LEG_INFORMATION2			21
++#define ROSE_DIVERTING_LEG_INFORMATION3			22
+ /* Q.956 ROSE operations (Advice Of Charge) */
+ #define ROSE_AOC_NO_CHARGING_INFO_AVAILABLE	26
+ #define ROSE_AOC_CHARGING_REQUEST			30
+@@ -81,12 +74,27 @@
+ #define ROSE_AOC_IDENTIFICATION_OF_CHARGE	37
+ /* Q.SIG operations */
+ #define SS_CNID_CALLINGNAME					0
++#define SS_CNOP_CALLEDNAME			 		1
++#define SS_CNOP_CONNECTEDNAME					2
+ #define SS_ANFPR_PATHREPLACEMENT                                4
+-#define SS_DIVERTING_LEG_INFORMATION2		21
+ #define SS_MWI_ACTIVATE						80
+ #define SS_MWI_DEACTIVATE					81
+ #define SS_MWI_INTERROGATE					82
+ 
++/* ECMA 186 */
++#define QSIG_CC_CCNRREQUEST		PRI_CC_CCNRREQUEST /* 27 */
++#define QSIG_CC_CANCEL				PRI_CC_CANCEL      /* 28 */
++#define QSIG_CC_EXECPOSIBLE		29
++#define QSIG_CC_PATHRESERVE		30
++#define QSIG_CC_RINGOUT				31
++#define QSIG_CC_SUSPEND				32
++#define QSIG_CC_RESUME				33
++#define QSIG_CC_CCBSREQUEST		PRI_CC_CCBSREQUEST /* 40 */
++
++#define QSIG_CC_UNSPECIFIED				1008
++#define QSIG_CC_REMOTE_USER_BUSY_AGAIN	1012
++#define QSIG_CC_FAILURE_TO_MATCH			1013
++
+ /* ROSE definitions and data structures */
+ #define INVOKE_IDENTIFIER			0x02
+ #define INVOKE_LINKED_IDENTIFIER	0x80
+@@ -128,6 +136,12 @@
+ #define ASN1_TAG_7				0x07
+ #define ASN1_TAG_8				0x08
+ #define ASN1_TAG_9				0x09
++#define ASN1_TAG_10				0x0a
++#define ASN1_TAG_11				0x0b
++#define ASN1_TAG_12				0x0c
++#define ASN1_TAG_13				0x0d
++#define ASN1_TAG_14				0x0e
++#define ASN1_TAG_15				0x0f
+ 
+ /* ASN.1 Identifier Octet - Primitive/Constructor Bit */
+ #define ASN1_PC_MASK			0x20
+@@ -169,6 +183,20 @@
+ #define Q932_TON_SUBSCRIBER				0x04
+ #define Q932_TON_ABBREVIATED			0x06
+ 
++/* Q.SIG Character Sets. Listed in ISO/IEC 8859 */
++#define CHARACTER_SET_UNKNOWN			0x00
++#define CHARACTER_SET_ISO8859_1			0x01
++#define CHARACTER_SET_ISO8859_2			0x03
++#define CHARACTER_SET_ISO8859_3			0x04
++#define CHARACTER_SET_ISO8859_4			0x05
++#define CHARACTER_SET_ISO8859_5			0x06
++#define CHARACTER_SET_ISO8859_7			0x07
++
++/* Q.SIG Subscription Option. Listed in ECMA-174 */
++#define QSIG_NO_NOTIFICATION						0x00
++#define QSIG_NOTIFICATION_WITHOUT_DIVERTED_TO_NR	0x01
++#define QSIG_NOTIFICATION_WITH_DIVERTED_TO_NR		0x02
++
+ /* RLT related Operations */
+ #define RLT_SERVICE_ID		0x3e
+ #define RLT_OPERATION_IND	0x01
+@@ -314,6 +342,18 @@
+ /* starts a QSIG Path Replacement */
+ int anfpr_initiate_transfer(struct pri *pri, q931_call *c1, q931_call *c2);
+ 
++int qsig_initiate_diverting_leg_information1(struct pri *pri, q931_call *call);
++
++int qsig_initiate_call_transfer_complete(struct pri *pri, q931_call *call, int call_status);
++
++int rose_diverting_leg_information1_encode(struct pri *pri, q931_call *call);
++
++int rose_diverting_leg_information3_encode(struct pri *pri, q931_call *call, int messagetype);
++
++int rose_connected_name_encode(struct pri *pri, q931_call *call, int messagetype);
++
++int rose_called_name_encode(struct pri *pri, q931_call *call, int messagetype);
++
+ /* Use this function to queue a facility-IE born APDU onto a call
+  * call is the call to use, messagetype is any one of the Q931 messages,
+  * apdu is the apdu data, apdu_len is the length of the apdu data  */
+@@ -325,6 +365,8 @@
+ /* Adds the "standard" APDUs to a call */
+ int pri_call_add_standard_apdus(struct pri *pri, q931_call *call);
+ 
++int add_qsigCcInv_facility_ie (struct pri *pri, q931_call *c, int messagetype);
++
+ int asn1_dump(struct pri *pri, void *comp, int len);
+ 
+ #endif /* _PRI_FACILITY_H */
+Index: libpri.h
+===================================================================
+--- a/libpri.h	(.../tags/1.4.9)	(revision 700)
++++ b/libpri.h	(.../team/group/issue14292)	(revision 700)
+@@ -81,6 +81,7 @@
+ #define PRI_EVENT_NOTIFY		16	/* Notification received */
+ #define PRI_EVENT_PROGRESS		17	/* When we get CALL_PROCEEDING or PROGRESS */
+ #define PRI_EVENT_KEYPAD_DIGIT		18	/* When we receive during ACTIVE state */
++#define PRI_EVENT_FACILITY		19	/* Facility received */
+ 
+ /* Simple states */
+ #define PRI_STATE_DOWN		0
+@@ -135,16 +136,45 @@
+ #define PRI_UNKNOWN					0x0
+ 
+ /* Presentation */
+-#define PRES_ALLOWED_USER_NUMBER_NOT_SCREENED	0x00
+-#define PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN	0x01
+-#define PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN	0x02
+-#define PRES_ALLOWED_NETWORK_NUMBER				0x03
+-#define PRES_PROHIB_USER_NUMBER_NOT_SCREENED	0x20
+-#define PRES_PROHIB_USER_NUMBER_PASSED_SCREEN	0x21
+-#define PRES_PROHIB_USER_NUMBER_FAILED_SCREEN	0x22
+-#define PRES_PROHIB_NETWORK_NUMBER				0x23
+-#define PRES_NUMBER_NOT_AVAILABLE				0x43
++#define PRES_NUMBER_TYPE					0x03
++#define PRES_USER_NUMBER_UNSCREENED			0x00
++#define PRES_USER_NUMBER_PASSED_SCREEN		0x01
++#define PRES_USER_NUMBER_FAILED_SCREEN		0x02
++#define PRES_NETWORK_NUMBER					0x03
+ 
++#define PRES_RESTRICTION					0x60
++#define PRES_ALLOWED						0x00
++#define PRES_RESTRICTED						0x20
++#define PRES_UNAVAILABLE					0x40
++#define PRES_RESERVED						0x60
++
++#define PRES_ALLOWED_USER_NUMBER_NOT_SCREENED \
++	(PRES_ALLOWED | PRES_USER_NUMBER_UNSCREENED)
++
++#define PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN \
++	(PRES_ALLOWED | PRES_USER_NUMBER_PASSED_SCREEN)
++
++#define PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN \
++	(PRES_ALLOWED | PRES_USER_NUMBER_FAILED_SCREEN)
++
++#define PRES_ALLOWED_NETWORK_NUMBER	\
++	(PRES_ALLOWED | PRES_NETWORK_NUMBER)
++
++#define PRES_PROHIB_USER_NUMBER_NOT_SCREENED \
++	(PRES_RESTRICTED | PRES_USER_NUMBER_UNSCREENED)
++
++#define PRES_PROHIB_USER_NUMBER_PASSED_SCREEN \
++	(PRES_RESTRICTED | PRES_USER_NUMBER_PASSED_SCREEN)
++
++#define PRES_PROHIB_USER_NUMBER_FAILED_SCREEN \
++	(PRES_RESTRICTED | PRES_USER_NUMBER_FAILED_SCREEN)
++
++#define PRES_PROHIB_NETWORK_NUMBER \
++	(PRES_RESTRICTED | PRES_NETWORK_NUMBER)
++
++#define PRES_NUMBER_NOT_AVAILABLE \
++	(PRES_UNAVAILABLE | PRES_NETWORK_NUMBER)
++
+ /* Causes for disconnection */
+ #define PRI_CAUSE_UNALLOCATED					1
+ #define PRI_CAUSE_NO_ROUTE_TRANSIT_NET			2	/* !Q.SIG */
+@@ -303,8 +333,141 @@
+ #define PRI_NSF_ATT_MULTIQUEST         0xF0
+ #define PRI_NSF_CALL_REDIRECTION_SERVICE       0xF7
+ 
++/* ECMA 186 */
++#define PRI_CC_CCNRREQUEST		27
++#define PRI_CC_CANCEL			28
++#define PRI_CC_CCBSREQUEST		40
++
+ typedef struct q931_call q931_call;
+ 
++/* Connected line update source code */
++enum PRI_CONNECTED_LINE_UPDATE_SOURCE {
++	PRI_CONNECTED_LINE_UPDATE_SOURCE_UNKNOWN,   /* Update for unknown reason (May be interpreted to mean from answer) */
++	PRI_CONNECTED_LINE_UPDATE_SOURCE_ANSWER,    /* Update from normal call answering */
++	PRI_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER,   /* Update from call transfer(active) (Party has already answered) */
++	PRI_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER_ALERTING   /* Update from call transfer(alerting) (Party has not answered yet) */
++};
++
++/* Information needed to identify an endpoint in a call. */
++struct pri_party_id {
++	char number[256];			/* Subscriber phone number */
++	char name[256];				/* Subscriber name */
++	int number_type;			/* Q.931 encoded "type of number" and "numbering plan identification" */
++	int number_presentation;	/* Q.931 encoded "presentation indicator" and "screening indicator" */
++};
++
++/* Connected Line/Party information */
++struct pri_party_connected_line {
++	struct pri_party_id id;		/* Connected party ID */
++	int source;					/* Information about the source of an update .
++	 							 * enum PRI_CONNECTED_LINE_UPDATE_SOURCE values
++	 							 * for Normal-Answer, Call-transfer */
++};
++
++/* Redirecting Line information.
++ * RDNIS (Redirecting Directory Number Information Service)
++ * Where a call diversion or transfer was invoked. */
++struct pri_party_redirecting {
++	struct pri_party_id from;	/* Who is redirecting the call (Sent to the party the call is redirected toward) */
++	struct pri_party_id to;		/* Call is redirecting to a new party (Sent to the caller) */
++	int count;					/* Number of times the call was redirected */
++	int reason;					/* Redirection reasons */
++};
++
++/* Structures for qsig_cc_facilities */
++struct qsig_cc_extension {
++	int	cc_extension_tag;
++	char extension[256];
++};
++
++struct qsig_cc_optional_arg {
++	char number_A[256];
++	char number_B[256];
++	int	service;
++	struct qsig_cc_extension cc_extension;
++};
++
++struct qsig_cc_request_res {
++	int	no_path_reservation;
++	int	retain_service;
++	struct qsig_cc_extension cc_extension;
++};
++
++/* Command derived from Facility */
++#define CMD_REDIRECTING         1
++#define CMD_CONNECTEDLINE       2
++#define CMD_CC_CCBSREQUEST_RR   3
++#define CMD_CC_CCNRREQUEST_RR   4
++#define CMD_CC_CANCEL_INV       5
++#define CMD_CC_EXECPOSIBLE_INV  6
++#define CMD_CC_RINGOUT_INV      7
++#define CMD_CC_SUSPEND_INV      8
++#define CMD_CC_ERROR            9
++
++#define CCERROR_UNSPECIFIED		1008
++#define CCERROR_REMOTE_USER_BUSY_AGAIN	1012
++#define CCERROR_FAILURE_TO_MATCH	1013
++
++struct cmd_connectedline {
++	struct pri_party_connected_line connected;
++};
++
++struct cmd_redirecting {
++	struct pri_party_redirecting redirecting;
++};
++
++struct cmd_cc_ccbs_rr {
++	struct qsig_cc_request_res	cc_request_res;
++};
++
++struct cmd_cc_ccnr_rr {
++	struct qsig_cc_request_res	cc_request_res;
++};
++
++struct cmd_cc_cancel_inv {
++	struct qsig_cc_optional_arg	cc_optional_arg;
++};
++
++struct cmd_cc_execposible_inv {
++	struct qsig_cc_optional_arg	cc_optional_arg;
++};
++
++struct cmd_cc_suspend_inv {
++	struct qsig_cc_extension	cc_extension;
++};
++
++struct cmd_cc_ringout_inv {
++	struct qsig_cc_extension	cc_extension;
++};
++
++struct cmd_cc_error {
++	int	error_value;
++};
++
++struct subcommand {
++	int cmd;
++	union {
++		struct cmd_connectedline      connectedline;
++		struct cmd_redirecting        redirecting;
++		struct cmd_cc_ccbs_rr         cc_ccbs_rr;
++		struct cmd_cc_ccnr_rr         cc_ccnr_rr;
++		struct cmd_cc_cancel_inv      cc_cancel_inv;
++		struct cmd_cc_execposible_inv cc_execposible_inv;
++		struct cmd_cc_suspend_inv     cc_suspend_inv;
++		struct cmd_cc_ringout_inv     cc_ringout_inv;
++		struct cmd_cc_error           cc_error;
++	};
++};
++
++/* Max number of subcommands per event message */
++#define MAX_SUBCOMMANDS	4
++
++struct subcommands {
++	int counter_subcmd;
++	struct subcommand subcmd[MAX_SUBCOMMANDS];
++};
++
++
+ typedef struct pri_event_generic {
+ 	/* Events with no additional information fall in this category */
+ 	int e;
+@@ -328,6 +491,11 @@
+ 	int progressmask;
+ 	q931_call *call;
+ 	char useruserinfo[260];		/* User->User info */
++	char calledname[256];
++	char callednum[256];
++	int calledpres;
++	int calledplan;
++	struct subcommands subcmds;
+ } pri_event_ringing;
+ 
+ typedef struct pri_event_answer {
+@@ -338,6 +506,12 @@
+ 	int progressmask;
+ 	q931_call *call;
+ 	char useruserinfo[260];		/* User->User info */
++	char connectednum[256];
++	char connectedname[256];
++	int connectedpres;
++	int connectedplan;
++	int source;
++	struct subcommands subcmds;
+ } pri_event_answer;
+ 
+ typedef struct pri_event_facname {
+@@ -351,6 +525,14 @@
+ 	int callingplan;			/* Dialing plan of Calling entity */
+ } pri_event_facname;
+ 
++struct pri_event_facility {
++	int e;
++	int channel;
++	int cref;
++	q931_call *call;
++	struct subcommands subcmds;
++};
++
+ #define PRI_CALLINGPLANANI
+ #define PRI_CALLINGPLANRDNIS
+ typedef struct pri_event_ring {
+@@ -383,6 +565,9 @@
+ 	char origcallednum[256];
+ 	int callingplanorigcalled;		/* Dialing plan of Originally Called Number */
+ 	int origredirectingreason;
++	int redirectingpres;
++	int redirectingcount;
++	struct subcommands subcmds;
+ } pri_event_ring;
+ 
+ typedef struct pri_event_hangup {
+@@ -393,6 +578,7 @@
+ 	q931_call *call;			/* Opaque call pointer */
+ 	long aoc_units;				/* Advise of Charge number of charged units */
+ 	char useruserinfo[260];		/* User->User info */
++	struct subcommands subcmds;
+ } pri_event_hangup;	
+ 
+ typedef struct pri_event_restart_ack {
+@@ -445,6 +631,7 @@
+ 	pri_event_setup_ack   setup_ack;	/* SETUP_ACKNOWLEDGE structure */
+ 	pri_event_notify notify;		/* Notification */
+ 	pri_event_keypad_digit digit;			/* Digits that come during a call */
++	struct pri_event_facility facility;
+ } pri_event;
+ 
+ struct pri;
+@@ -531,6 +718,12 @@
+    Set non-isdn to non-zero if you are not connecting to ISDN equipment */
+ int pri_answer(struct pri *pri, q931_call *call, int channel, int nonisdn);
+ 
++/* Give connected line information to a call */
++int pri_connected_line_update(struct pri *pri, q931_call *call, struct pri_party_connected_line *connected);
++
++/* Give redirection information to a call */
++int pri_redirecting_update(struct pri *pri, q931_call *call, struct pri_party_redirecting *redirecting);
++
+ /* Set CRV reference for GR-303 calls */
+ 
+ 
+@@ -558,7 +751,12 @@
+ 
+ /* Create a new call */
+ q931_call *pri_new_call(struct pri *pri);
++q931_call *pri_new_nochannel_call(struct pri *pri, int *cr);
+ 
++q931_call *pri_find_call(struct pri *pri, int cr);
++
++void pri_call_set_cc_operation(q931_call *call, int cc_operation);
++
+ /* Retrieve CRV reference for GR-303 calls.  Returns >0 on success. */
+ int pri_get_crv(struct pri *pri, q931_call *call, int *callmode);
+ 
+@@ -584,6 +782,11 @@
+ int pri_sr_set_called(struct pri_sr *sr, char *called, int calledplan, int complete);
+ int pri_sr_set_caller(struct pri_sr *sr, char *caller, char *callername, int callerplan, int callerpres);
+ int pri_sr_set_redirecting(struct pri_sr *sr, char *num, int plan, int pres, int reason);
++void pri_sr_set_redirecting_name(struct pri_sr *sr, char *name);
++
++int pri_sr_set_ccringout(struct pri_sr *sr, int ccringout);
++int pri_sr_set_ccbsnr(struct pri_sr *sr, int ccbsnr);
++
+ #define PRI_USER_USER_TX
+ /* Set the user user field.  Warning!  don't send binary data accross this field */
+ void pri_sr_set_useruser(struct pri_sr *sr, const char *userchars);
+@@ -595,7 +798,10 @@
+ /* Set a call has a call indpendent signalling connection (i.e. no bchan) */
+ int pri_sr_set_connection_call_independent(struct pri_sr *req);
+ 
+-/* Send an MWI indication to a remote location.  If activate is non zero, activates, if zero, decativates */
++/* Set a no channel call (i.e. QSIG-CCBS/CCNR) */
++int pri_sr_set_no_channel_call(struct pri_sr *req);
++
++/* Send an MWI indication to a remote location.  If activate is non zero, activates, if zero, deactivates */
+ int pri_mwi_activate(struct pri *pri, q931_call *c, char *caller, int callerplan, char *callername, int callerpres, char *called, int calledplan);
+ 
+ /* Send an MWI deactivate request to a remote location */
+@@ -698,6 +904,7 @@
+ #define PRI_TIMER_TM20	28	/* maximum time avaiting XID response */
+ #define PRI_TIMER_NM20	29	/* number of XID retransmits */
+ 
++#define PRI_TIMER_CCBST2	30	/* maximum time on completion of CC Call */
+ /* Get PRI version */
+ const char *pri_get_version(void);
+ 
+Index: pri.c
+===================================================================
+--- a/pri.c	(.../tags/1.4.9)	(revision 700)
++++ b/pri.c	(.../team/group/issue14292)	(revision 700)
+@@ -166,6 +166,8 @@
+ 		return PRI_TIMER_T321;
+ 	else if (!strcasecmp(timer, "T322"))
+ 		return PRI_TIMER_T322;
++	else if (!strcasecmp(timer, "CCT2"))
++		return PRI_TIMER_CCBST2;
+ 	else
+ 		return -1;
+ }
+@@ -348,6 +350,8 @@
+ 		return "Restart ACK";
+ 	case PRI_EVENT_FACNAME:
+ 		return "FacName";
++	case PRI_EVENT_FACILITY:
++		return "Facility";
+ 	case PRI_EVENT_INFO_RECEIVED:
+ 		return "Info Received";
+ 	case PRI_EVENT_PROCEEDING:
+@@ -551,6 +555,131 @@
+ 	return q931_connect(pri, call, channel, nonisdn);
+ }
+ 
++int pri_connected_line_update(struct pri *pri, q931_call *call, struct pri_party_connected_line *connected)
++{
++	if (!pri || !call)
++		return -1;
++
++	libpri_copy_string(call->connectednum, connected->id.number, sizeof(call->connectednum));
++	libpri_copy_string(call->connectedname, connected->id.name, sizeof(call->connectedname));
++	call->connectedplan = connected->id.number_type;
++	call->connectedpres = connected->id.number_presentation;
++
++	if (pri->switchtype == PRI_SWITCH_QSIG) {
++		switch (call->ourcallstate) {
++		case Q931_CALL_STATE_ACTIVE:
++			/* immediately send callTransferComplete APDU, callStatus=answered(0) */
++			qsig_initiate_call_transfer_complete(pri, call, 0);
++			break;
++		case Q931_CALL_STATE_OVERLAP_RECEIVING:
++		case Q931_CALL_STATE_INCOMING_CALL_PROCEEDING:
++			/* queue updates for next ALERTING */
++			if (call->connectedname[0]) {
++				/* queue connectedName to be send with next Q931_ALERTING */
++				rose_called_name_encode(pri, call, Q931_ALERTING);
++			}
++
++			if (call->divertedstate != DIVERTEDSTATE_NONE) {
++				libpri_copy_string(call->divertedtonum, connected->id.number, sizeof(call->divertedtonum));
++				libpri_copy_string(call->divertedtoname, connected->id.name, sizeof(call->divertedtoname));
++				call->divertedtoplan = connected->id.number_type;
++				call->divertedtopres = connected->id.number_presentation;
++
++				if ((call->divertedstate == DIVERTEDSTATE_DIVERTED) && call->divertedtonum[0]) {
++					/* immediately send divertingLegInformation1 APDU  */
++					qsig_initiate_diverting_leg_information1(pri, call);
++					call->divertedstate = DIVERTEDSTATE_DIVLEGINFO1SEND;
++				}
++				if ((call->divertedstate == DIVERTEDSTATE_DIVLEGINFO1SEND) && call->divertedtoname[0]) {
++					/* queue divertingLegInformation3 to be send with next Q931_ALERTING */
++					rose_diverting_leg_information3_encode(pri, call, Q931_ALERTING);
++					call->divertedstate = DIVERTEDSTATE_DIVLEGINFO3SEND;
++				}
++			}
++			break;
++		case Q931_CALL_STATE_CALL_RECEIVED:
++			/* queue updates for next CONNECT */
++			if (call->connectedname[0] && ((call->divertedstate == DIVERTEDSTATE_NONE) || (call->divertedstate == DIVERTEDSTATE_DIVLEGINFO3SEND))) {
++				/* queue connectedName to be send with next Q931_CONNECT */
++				rose_connected_name_encode(pri, call, Q931_CONNECT);
++			}
++
++			if (call->divertedstate != DIVERTEDSTATE_NONE) {
++				libpri_copy_string(call->divertedtonum, connected->id.number, sizeof(call->divertedtonum));
++				libpri_copy_string(call->divertedtoname, connected->id.name, sizeof(call->divertedtoname));
++				call->divertedtoplan = connected->id.number_type;
++				call->divertedtopres = connected->id.number_presentation;
++
++				if ((call->divertedstate == DIVERTEDSTATE_DIVERTED) && call->divertedtonum[0]) {
++					/* queue divertingLegInformation1 to be send with next Q931_FACILITY */
++					rose_diverting_leg_information1_encode(pri, call);
++					call->divertedstate = DIVERTEDSTATE_DIVLEGINFO1SEND;
++
++					if (call->divertedtoname[0]) {
++						/* queue divertingLegInformation3 to be send with next Q931_FACILITY */
++						rose_diverting_leg_information3_encode(pri, call, Q931_FACILITY);
++						call->divertedstate = DIVERTEDSTATE_DIVLEGINFO3SEND;
++					}
++
++					/* immediately send Q931_FACILITY */
++					if (q931_facility(pri, call)) {
++						pri_message(pri, "Could not schedule facility message for divertingLegInfo1+3\n");
++					}
++				}
++				if ((call->divertedstate == DIVERTEDSTATE_DIVLEGINFO1SEND) && call->divertedtoname[0]) {
++					/* queue divertingLegInformation3 to be send with next Q931_CONNECT */
++					rose_diverting_leg_information3_encode(pri, call, Q931_CONNECT);
++					call->divertedstate = DIVERTEDSTATE_DIVLEGINFO3SEND;
++				}
++			}
++			break;
++		}
++	}
++
++	return 0;
++}
++
++int pri_redirecting_update(struct pri *pri, q931_call *call, struct pri_party_redirecting *redirecting)
++{
++	if (!pri || !call)
++		return -1;
++
++	libpri_copy_string(call->divertedtonum, redirecting->to.number, sizeof(call->divertedtonum));
++	libpri_copy_string(call->divertedtoname, redirecting->to.name, sizeof(call->divertedtoname));
++	call->divertedtoplan = redirecting->to.number_type;
++	call->divertedtopres = redirecting->to.number_presentation;
++	call->divertedtoreason = redirecting->reason;
++
++	if (pri->switchtype == PRI_SWITCH_QSIG) {
++		switch (call->ourcallstate) {
++		case Q931_CALL_STATE_ACTIVE:
++			/* immediately send callTransferComplete APDU, callStatus=alerting(1) */
++			qsig_initiate_call_transfer_complete(pri, call, 1);
++			break;
++		case Q931_CALL_STATE_OVERLAP_RECEIVING:
++		case Q931_CALL_STATE_INCOMING_CALL_PROCEEDING:
++			call->divertedstate = DIVERTEDSTATE_DIVERTED;
++
++			if (call->divertedtonum[0]) {
++				/* immediately send divertingLegInformation1 APDU */
++				qsig_initiate_diverting_leg_information1(pri, call);
++				call->divertedstate = DIVERTEDSTATE_DIVLEGINFO1SEND;
++			}
++			if ((call->divertedstate == DIVERTEDSTATE_DIVLEGINFO1SEND) && call->divertedtoname[0]) {
++				/* queue divertingLegInformation3 to be send with next Q931_ALERTING */
++				rose_diverting_leg_information3_encode(pri, call, Q931_ALERTING);
++				call->divertedstate = DIVERTEDSTATE_DIVLEGINFO3SEND;
++			}
++			break;
++		default:
++			pri_message(pri, "Redirecting update in state %d\n", call->ourcallstate);
++			break;
++		}
++	}
++
++	return 0;
++}
++
+ #if 0
+ /* deprecated routines, use pri_hangup */
+ int pri_release(struct pri *pri, q931_call *call, int cause)
+@@ -637,6 +766,17 @@
+ 	return q931_new_call(pri);
+ }
+ 
++q931_call *pri_new_nochannel_call(struct pri *pri, int *cr)
++{
++	q931_call *call;
++	if (!pri)
++		return NULL;
++	call = q931_new_call(pri);
++	if (cr)
++		*cr = call->cr;
++	return call;
++}
++
+ void pri_dump_event(struct pri *pri, pri_event *e)
+ {
+ 	if (!pri || !e)
+@@ -679,6 +819,15 @@
+ 	return 0;
+ }
+ 
++int pri_sr_set_no_channel_call(struct pri_sr *req)
++{
++	if (!req)
++		return -1;
++
++	req->nochannelsignalling = 1;
++	return 0;
++}
++
+ /* Don't call any other pri functions on this */
+ int pri_mwi_activate(struct pri *pri, q931_call *c, char *caller, int callerplan, char *callername, int callerpres, char *called,
+ 					int calledplan)
+@@ -829,6 +978,10 @@
+ 	struct q921_frame *f;
+ 	int q921outstanding = 0;
+ #endif
++	q931_call *cur, *prev;
++	struct pri *master;
++	int counter = 0;
++
+ 	if (!pri)
+ 		return NULL;
+ 
+@@ -862,10 +1015,57 @@
+ 	len += sprintf(buf + len, "T309 Timer: %d\n", pri->timers[PRI_TIMER_T309]);
+ 	len += sprintf(buf + len, "T313 Timer: %d\n", pri->timers[PRI_TIMER_T313]);
+ 	len += sprintf(buf + len, "N200 Counter: %d\n", pri->timers[PRI_TIMER_N200]);
++	len += sprintf(buf + len, "CCT2 Timer: %d\n", pri->timers[PRI_TIMER_CCBST2]);
++	/* Find the master  - He has the call pool */
++	if (pri->master)
++		master = pri->master;
++	else
++		master = pri;
+ 
++	cur = *master->callpool;
++	prev = NULL;
++	while(cur) {
++		if (cur->cctimer2) {
++			struct timeval tv;
++			int time_ms_to_go, time_to_go_min, time_to_go_sec;
++			gettimeofday(&tv, NULL);
++			time_ms_to_go = (pri->pri_sched[cur->cctimer2].when.tv_sec - tv.tv_sec)*1000;
++			time_to_go_min = time_ms_to_go/1000/60;
++			time_to_go_sec = (time_ms_to_go-(time_to_go_min*60*1000))/1000;
++
++			len += sprintf(buf + len, "%d. Active Q.931 Call: %p cr=%d: (%dmin %dsec)\n",
++				++counter, cur, cur->cr,
++				time_to_go_min, time_to_go_sec);
++		} else {
++			len += sprintf(buf + len, "%d. Active Q.931 Call: %p cr=%d\n", ++counter, cur, cur->cr);
++		}
++		cur = cur->next;
++	}
++
+ 	return strdup(buf);
+ }
+ 
++q931_call *pri_find_call(struct pri *pri, int cr)
++{
++	q931_call *cur;
++	struct pri *master;
++
++	/* Find the master  - He has the call pool */
++	if (pri->master)
++		master = pri->master;
++	else
++		master = pri;
++	
++	cur = *master->callpool;
++	while(cur) {
++		if (cur->cr == cr)
++			return cur;
++		cur = cur->next;
++	}
++
++	return NULL;
++}
++
+ int pri_get_crv(struct pri *pri, q931_call *call, int *callmode)
+ {
+ 	return q931_call_getcrv(pri, call, callmode);
+@@ -936,3 +1136,25 @@
+ 	sr->redirectingreason = reason;
+ 	return 0;
+ }
++
++void pri_sr_set_redirecting_name(struct pri_sr *sr, char *name)
++{
++	sr->redirectingname = name;
++}
++
++int pri_sr_set_ccringout(struct pri_sr *sr, int ccringout)
++{
++	sr->ccringout = ccringout;
++	return 0;
++}
++
++int pri_sr_set_ccbsnr(struct pri_sr *sr, int ccbsnr)
++{
++	sr->ccbsnr = ccbsnr;
++	return 0;
++}
++
++void pri_call_set_cc_operation(q931_call *call, int cc_operation)
++{
++	call->ccoperation = cc_operation;
++}
+Index: pri_internal.h
+===================================================================
+--- a/pri_internal.h	(.../tags/1.4.9)	(revision 700)
++++ b/pri_internal.h	(.../team/group/issue14292)	(revision 700)
+@@ -36,6 +36,12 @@
+ #define DBGHEAD __FILE__ ":%d %s: "
+ #define DBGINFO __LINE__,__PRETTY_FUNCTION__
+ 
++/* divertedstate */
++#define DIVERTEDSTATE_NONE				0
++#define DIVERTEDSTATE_DIVERTED			1
++#define DIVERTEDSTATE_DIVLEGINFO1SEND	2
++#define DIVERTEDSTATE_DIVLEGINFO3SEND	3
++
+ struct pri_sched {
+ 	struct timeval when;
+ 	void (*callback)(void *data);
+@@ -47,7 +53,7 @@
+ enum q931_mode;
+ 
+ /* No more than 128 scheduled events */
+-#define MAX_SCHED 128
++#define MAX_SCHED 128+256 /* 256 ccT2 timer events*/
+ 
+ #define MAX_TIMERS 32
+ 
+@@ -142,13 +148,17 @@
+ 	int calledplan;
+ 	int userl1;
+ 	int numcomplete;
++	char *redirectingname;
+ 	char *redirectingnum;
+ 	int redirectingplan;
+ 	int redirectingpres;
+ 	int redirectingreason;
+ 	int justsignalling;
++	int nochannelsignalling;
++	int ccbsnr;
+ 	const char *useruserinfo;
+ 	int transferable;
++	int ccringout;
+ };
+ 
+ /* Internal switch types */
+@@ -202,6 +212,7 @@
+ 	
+ 	int sentchannel;
+ 	int justsignalling;		/* for a signalling-only connection */
++	int nochannelsignalling;
+ 
+ 	int progcode;			/* Progress coding */
+ 	int progloc;			/* Progress Location */	
+@@ -225,12 +236,19 @@
+ 	char callernum[256];
+ 	char callername[256];
+ 
++	int ccoperation;		/* QSIG_CCBSREQUEST/QSIG_CCNRREQUEST */
++	int ccrequestresult;
++	int cctimer2;			/* Timer for QSIG-timer2 */
++	/* QSIG cc infos (receive) */
++	struct subcommands subcmds;
++
+ 	char keypad_digits[64];		/* Buffer for digits that come in KEYPAD_FACILITY */
+ 
+ 	int ani2;               /* ANI II */
+ 	
+ 	int calledplan;
+ 	int nonisdn;
++	char calledname[256];
+ 	char callednum[256];	/* Called Number */
+ 	int complete;			/* no more digits coming */
+ 	int newcall;			/* if the received message has a new call reference value */
+@@ -241,6 +259,7 @@
+ 	int redirectingplan;
+ 	int redirectingpres;
+ 	int redirectingreason;	      
++	int redirectingcount;
+ 	char redirectingnum[256];	/* Number of redirecting party */
+ 	char redirectingname[256];	/* Name of redirecting party */
+ 
+@@ -251,6 +270,39 @@
+ 	char origcalledname[256];	/* Original name of person being called */
+ 	char origcallednum[256];	/* Orignal number of person being called */
+ 
++	int connectedplan;
++	int connectedpres;
++	char connectednum[256];
++	char connectedname[256];
++
++	/* divertingLegInformation1 */
++	int divleginfo1activeflag;
++	int divertedtoplan;
++	int divertedtopres;
++	int divertedtoreason;
++	char divertedtonum[256];
++	int divertedtocount;
++
++	/* divertingLegInformation3 */
++	int divleginfo3activeflag;
++	char divertedtoname[256];
++	int divertedstate;
++
++	/* callTransferComplete */
++	int ctcompleteflag;
++	int ctcompletepres;
++	int ctcompleteplan;
++	char ctcompletenum[256];
++	char ctcompletename[256];
++	int ctcompletecallstatus;
++
++	/* callTransferActive */
++	int ctactiveflag;
++	int ctactivepres;
++	int ctactiveplan;
++	char ctactivenum[256];
++	char ctactivename[256];
++
+ 	int useruserprotocoldisc;
+ 	char useruserinfo[256];
+ 	char callingsubaddr[256];	/* Calling parties sub address */
+Index: q921.c
+===================================================================
+--- a/q921.c	(.../tags/1.4.9)	(revision 700)
++++ b/q921.c	(.../team/group/issue14292)	(revision 700)
+@@ -268,12 +268,31 @@
+ 	pri->t203_timer = pri_schedule_event(pri, pri->timers[PRI_TIMER_T203], t203_expire, pri);
+ }
+ 
++static void q921_send_queued_iframes(struct pri *pri)
++{
++	struct q921_frame *f;
++
++	f = pri->txqueue;
++	while(f && (pri->windowlen < pri->window)) {
++		if (!f->transmitted) {
++			/* Send it now... */
++			if (pri->debug & PRI_DEBUG_Q921_DUMP)
++				pri_message(pri, "-- Finally transmitting %d, since window opened up (%d)\n", f->h.n_s, pri->windowlen);
++			f->transmitted++;
++			pri->windowlen++;
++			f->h.n_r = pri->v_r;
++			f->h.p_f = 0;
++			q921_transmit(pri, (q921_h *)(&f->h), f->len);
++		}
++		f = f->next;
++	}
++}
++
+ static pri_event *q921_ack_rx(struct pri *pri, int ack, int send_untransmitted_frames)
+ {
+ 	int x;
+ 	int cnt=0;
+ 	pri_event *ev;
+-	struct q921_frame *f;
+ 	/* Make sure the ACK was within our window */
+ 	for (x=pri->v_a; (x != pri->v_s) && (x != ack); Q921_INC(x));
+ 	if (x != ack) {
+@@ -309,20 +328,7 @@
+ 		if (!pri->busy && send_untransmitted_frames) {
+ 			pri->retrans = 0;
+ 			/* Search for something to send */
+-			f = pri->txqueue;
+-			while(f && (pri->windowlen < pri->window)) {
+-				if (!f->transmitted) {
+-					/* Send it now... */
+-					if (pri->debug & PRI_DEBUG_Q921_DUMP)
+-						pri_message(pri, "-- Finally transmitting %d, since window opened up (%d)\n", f->h.n_s, pri->windowlen);
+-					f->transmitted++;
+-					pri->windowlen++;
+-					f->h.n_r = pri->v_r;
+-					f->h.p_f = 0;
+-					q921_transmit(pri, (q921_h *)(&f->h), f->len);
+-				}
+-				f = f->next;
+-			}
++			q921_send_queued_iframes(pri);
+ 		}
+ 		if (pri->debug & PRI_DEBUG_Q921_DUMP)
+ 			pri_message(pri, "-- Waiting for acknowledge, restarting T200 counter\n");		
+@@ -515,7 +521,7 @@
+ 			pri->txqueue = f;
+ 		/* Immediately transmit unless we're in a recovery state, or the window
+ 		   size is too big */
+-		if (!pri->retrans && !pri->busy) {
++		if ((pri->q921_state == Q921_LINK_CONNECTION_ESTABLISHED) && (!pri->retrans && !pri->busy)) {
+ 			if (pri->windowlen < pri->window) {
+ 				pri->windowlen++;
+ 				q921_transmit(pri, (q921_h *)(&f->h), f->len);
+@@ -532,9 +538,14 @@
+ 			pri_schedule_del(pri, pri->t203_timer);
+ 			pri->t203_timer = 0;
+ 		}
+-		if (pri->debug & PRI_DEBUG_Q921_DUMP)
+-			pri_message(pri, "Starting T_200 timer\n");
+-		reschedule_t200(pri);		
++
++		/* Check this so that we don't try to send frames while multi frame mode is down */
++		if (pri->q921_state == Q921_LINK_CONNECTION_ESTABLISHED) {
++			if (pri->debug & PRI_DEBUG_Q921_DUMP)
++				pri_message(pri, "Starting T_200 timer\n");
++
++			reschedule_t200(pri);		
++		}
+ 	} else {
+ 		pri_error(pri, "!! Out of memory for Q.921 transmit\n");
+ 		return -1;
+@@ -776,9 +787,6 @@
+ 
+ static pri_event *q921_dchannel_up(struct pri *pri)
+ {
+-	/* Reset counters, etc */
+-	q921_reset(pri);
+-	
+ 	/* Stop any SABME retransmissions */
+ 	if (pri->sabme_timer) {
+ 		pri_schedule_del(pri, pri->sabme_timer);
+@@ -799,6 +807,8 @@
+ 	/* Notify Layer 3 */
+ 	q931_dl_indication(pri, PRI_EVENT_DCHAN_UP);
+ 
++	q921_send_queued_iframes(pri);
++
+ 	/* Report event that D-Channel is now up */
+ 	pri->ev.gen.e = PRI_EVENT_DCHAN_UP;
+ 	return &pri->ev;
+Index: q931.c
+===================================================================
+--- a/q931.c	(.../tags/1.4.9)	(revision 700)
++++ b/q931.c	(.../team/group/issue14292)	(revision 700)
+@@ -362,6 +362,11 @@
+ 	/* We are ready to transmit single IE only */
+ 	if (order > 1)
+ 		return 0;
++
++	if (call->nochannelsignalling) {
++		ie->data[pos++] = 0xac;
++		return pos + 2;
++	}
+ 	
+ 	if (call->justsignalling) {
+ 		ie->data[pos++] = 0xac; /* Read the standards docs to figure this out
+@@ -804,7 +809,13 @@
+ 		ie->data[1] = 0x90;
+ 		return 4;
+ 	}
+-	
++
++	if (call->nochannelsignalling) {
++		ie->data[0] = 0xa8;
++		ie->data[1] = 0x80;
++		return 4;
++	}
++
+ 	if (call->justsignalling) {
+ 		ie->data[0] = 0xa8;
+ 		ie->data[1] = 0x80;
+@@ -992,12 +1003,45 @@
+ 				prefix, ie->data[2] >> 7, redirection_reason2str(ie->data[2] & 0x7f), ie->data[2] & 0x7f);
+ 			break;
+ 		}
+-	}
+-	while(!(ie->data[i++]& 0x80));
++	} while(!(ie->data[i++]& 0x80));
+ 	q931_get_number(cnum, sizeof(cnum), ie->data + i, ie->len - i);
+ 	pri_message(pri, "  '%s' ]\n", cnum);
+ }
+ 
++static FUNC_RECV(receive_connected_number)
++{
++	int i = 0;
++
++	/* To follow Q.931 (4.5.1), we must search for start of octet 4 by
++	   walking through all bytes until one with ext bit (8) set to 1 */
++	do {
++		switch(i) {
++		case 0:
++			call->connectedplan = ie->data[i] & 0x7f;
++			break;
++		case 1:
++			call->connectedpres = ie->data[i] & 0x7f;
++			break;
++		}
++	} while(!(ie->data[i++] & 0x80));
++	q931_get_number((unsigned char *) call->connectednum, sizeof(call->connectednum), ie->data + i, ie->len - i);
++
++	return 0;
++}
++
++static FUNC_SEND(transmit_connected_number)
++{
++	int datalen = strlen(call->connectednum);
++	if (datalen > 0) {
++		ie->data[0] = call->connectedplan;
++		ie->data[1] = 0x80 | call->connectedpres;
++		memcpy(ie->data + 2, call->connectednum, strlen(call->connectednum));
++		return datalen + 4;
++	}
++
++	return 0;
++}
++
+ static FUNC_DUMP(dump_connected_number)
+ {
+ 	unsigned char cnum[256];
+@@ -1015,8 +1059,7 @@
+ 				prefix, ie->data[1] >> 7, pri_pres2str(ie->data[1] & 0x7f), ie->data[1] & 0x7f);
+ 			break;
+ 		}
+-	}
+-	while(!(ie->data[i++]& 0x80));
++	} while(!(ie->data[i++]& 0x80));
+ 	q931_get_number(cnum, sizeof(cnum), ie->data + i, ie->len - i);
+ 	pri_message(pri, "  '%s' ]\n", cnum);
+ }
+@@ -1040,8 +1083,7 @@
+ 			call->redirectingreason = ie->data[i] & 0x0f;
+ 			break;
+ 		}
+-	}
+-	while(!(ie->data[i++] & 0x80));
++	} while(!(ie->data[i++] & 0x80));
+ 	q931_get_number((unsigned char *) call->redirectingnum, sizeof(call->redirectingnum), ie->data + i, ie->len - i);
+ 	return 0;
+ }
+@@ -2183,7 +2225,7 @@
+ 	{ 1, Q931_IE_CALL_STATUS, "Call Status" },
+ 	{ 1, Q931_IE_CHANGE_STATUS, "Change Status" },
+ 	{ 1, Q931_IE_CONNECTED_ADDR, "Connected Number", dump_connected_number },
+-	{ 1, Q931_IE_CONNECTED_NUM, "Connected Number", dump_connected_number },
++	{ 1, Q931_IE_CONNECTED_NUM, "Connected Number", dump_connected_number, receive_connected_number, transmit_connected_number },
+ 	{ 1, Q931_IE_ORIGINAL_CALLED_NUMBER, "Original Called Number", dump_redirecting_number, receive_redirecting_number, transmit_redirecting_number },
+ 	{ 1, Q931_IE_USER_USER_FACILITY, "User-User Facility" },
+ 	{ 1, Q931_IE_UPDATE, "Update" },
+@@ -2478,8 +2520,7 @@
+ 						maxlen -= res;
+ 						iet = (q931_ie *)((char *)iet + res);
+ 					}
+-				}
+-				while (res > 0 && order < ies_count);
++				} while (res > 0 && order < ies_count);
+ 				if (have_shift && total_res) {
+ 					if (Q931_IE_CODESET(ies[x].ie))
+ 						*codeset = Q931_IE_CODESET(ies[x].ie);
+@@ -2820,9 +2861,9 @@
+ 	return send_message(pri, c, Q931_CALL_PROCEEDING, call_proceeding_ies);
+ }
+ #ifndef ALERTING_NO_PROGRESS
+-static int alerting_ies[] = { Q931_PROGRESS_INDICATOR, Q931_IE_USER_USER,  -1 };
++static int alerting_ies[] = { Q931_PROGRESS_INDICATOR, Q931_IE_USER_USER, Q931_IE_FACILITY, -1 };
+ #else
+-static int alerting_ies[] = { -1 };
++static int alerting_ies[] = { Q931_IE_FACILITY, -1 };
+ #endif
+ 
+ int q931_alerting(struct pri *pri, q931_call *c, int channel, int info)
+@@ -2841,7 +2882,7 @@
+ 	return send_message(pri, c, Q931_ALERTING, alerting_ies);
+ }
+ 
+-static int connect_ies[] = {  Q931_CHANNEL_IDENT, Q931_PROGRESS_INDICATOR, -1 };
++static int connect_ies[] = {  Q931_CHANNEL_IDENT, Q931_PROGRESS_INDICATOR, Q931_IE_CONNECTED_NUM, Q931_IE_FACILITY, -1 };
+  
+ int q931_setup_ack(struct pri *pri, q931_call *c, int channel, int nonisdn)
+ {
+@@ -2923,6 +2964,18 @@
+ 	q931_release(pri, c, PRI_CAUSE_NORMAL_CLEARING);
+ }
+ 
++static void pri_cctimer2_timeout(void *data)
++{
++	int cause = 16;
++	struct q931_call *c = data;
++	struct pri *pri = c->pri;
++	if (pri->debug & PRI_DEBUG_Q931_STATE)
++		pri_message(pri, "Timed out no-channel call\n");
++	c->ccoperation = QSIG_CC_CANCEL;
++	/* normal clear cause */
++	q931_hangup(pri, c, cause);
++}
++
+ int q931_connect(struct pri *pri, q931_call *c, int channel, int nonisdn)
+ {
+ 	if (channel) { 
+@@ -2954,7 +3007,7 @@
+ 	return send_message(pri, c, Q931_CONNECT, connect_ies);
+ }
+ 
+-static int release_ies[] = { Q931_CAUSE, Q931_IE_USER_USER, -1 };
++static int release_ies[] = { Q931_CAUSE, Q931_IE_USER_USER, Q931_IE_FACILITY, -1 };
+ 
+ int q931_release(struct pri *pri, q931_call *c, int cause)
+ {
+@@ -3002,7 +3055,7 @@
+ 	return send_message(pri, c, Q931_RESTART, restart_ies);
+ }
+ 
+-static int disconnect_ies[] = { Q931_CAUSE, Q931_IE_USER_USER, -1 };
++static int disconnect_ies[] = { Q931_CAUSE, Q931_IE_USER_USER, Q931_IE_FACILITY, -1 };
+ 
+ int q931_disconnect(struct pri *pri, q931_call *c, int cause)
+ {
+@@ -3030,6 +3083,8 @@
+ 
+ static int cis_setup_ies[] = { Q931_BEARER_CAPABILITY, Q931_CHANNEL_IDENT, Q931_IE_FACILITY, Q931_CALLED_PARTY_NUMBER, -1 };
+ 
++static int nochannel_setup_ies[] = { Q931_BEARER_CAPABILITY, Q931_CHANNEL_IDENT, Q931_IE_FACILITY, Q931_CALLING_PARTY_NUMBER, Q931_CALLED_PARTY_NUMBER, Q931_SENDING_COMPLETE, -1 };
++
+ int q931_setup(struct pri *pri, q931_call *c, struct pri_sr *req)
+ {
+ 	int res;
+@@ -3055,6 +3110,7 @@
+ 	c->nonisdn = req->nonisdn;
+ 	c->newcall = 0;
+ 	c->justsignalling = req->justsignalling;		
++	c->nochannelsignalling = req->nochannelsignalling;		
+ 	c->complete = req->numcomplete; 
+ 	if (req->exclusive) 
+ 		c->chanflags = FLAG_EXCLUSIVE;
+@@ -3082,6 +3138,10 @@
+ 	}
+ 	if (req->redirectingnum) {
+ 		libpri_copy_string(c->redirectingnum, req->redirectingnum, sizeof(c->redirectingnum));
++		if (req->redirectingname)
++			libpri_copy_string(c->redirectingname, req->redirectingname, sizeof(c->redirectingname));
++		else
++			c->redirectingname[0] = '\0';
+ 		c->redirectingplan = req->redirectingplan;
+ 		if ((pri->switchtype == PRI_SWITCH_DMS100) ||
+ 		    (pri->switchtype == PRI_SWITCH_ATT4ESS)) {
+@@ -3092,6 +3152,7 @@
+ 		c->redirectingpres = req->redirectingpres;
+ 		c->redirectingreason = req->redirectingreason;
+ 	} else {
++		c->redirectingname[0] = '\0';
+ 		c->redirectingnum[0] = '\0';
+ 		c->redirectingplan = PRI_UNKNOWN;
+ 		c->redirectingpres = PRES_NUMBER_NOT_AVAILABLE;
+@@ -3113,12 +3174,19 @@
+ 	else
+ 		c->progressmask = 0;
+ 
++	if (req->ccringout)
++		c->ccoperation = QSIG_CC_RINGOUT;
++	if (req->ccbsnr)
++		c->ccoperation = req->ccbsnr;
++
+ 	pri_call_add_standard_apdus(pri, c);
+ 
+ 	if (pri->subchannel && !pri->bri)
+ 		res = send_message(pri, c, Q931_SETUP, gr303_setup_ies);
+ 	else if (c->justsignalling)
+ 		res = send_message(pri, c, Q931_SETUP, cis_setup_ies);
++	else if (c->nochannelsignalling)
++		res = send_message(pri, c, Q931_SETUP, nochannel_setup_ies);
+ 	else
+ 		res = send_message(pri, c, Q931_SETUP, setup_ies);
+ 	if (!res) {
+@@ -3132,7 +3200,7 @@
+ 	
+ }
+ 
+-static int release_complete_ies[] = { Q931_IE_USER_USER, -1 };
++static int release_complete_ies[] = { Q931_IE_USER_USER, Q931_IE_FACILITY, -1 };
+ 
+ static int q931_release_complete(struct pri *pri, q931_call *c, int cause)
+ {
+@@ -3187,6 +3255,18 @@
+ 		/* We'll send RELEASE with these causes */
+ 		disconnect = 0;
+ 	}
++	if (c->nochannelsignalling) {
++		if (c->ccoperation == QSIG_CC_CANCEL) {
++			add_qsigCcInv_facility_ie(pri, c, Q931_RELEASE);
++		}
++		if (c->cctimer2) {
++			pri_schedule_del(pri, c->cctimer2);
++			c->cctimer2 = 0;
++			pri_message(pri, "NEW_HANGUP DEBUG: stop CC-Timer2\n");
++		}
++		disconnect = 0;
++	}
++
+ 	/* All other causes we send with DISCONNECT */
+ 	switch(c->ourcallstate) {
+ 	case Q931_CALL_STATE_NULL:
+@@ -3227,6 +3307,10 @@
+ 		break;
+ 	case Q931_CALL_STATE_ACTIVE:
+ 		/* received CONNECT */
++		if (c->nochannelsignalling) {
++			q931_release(pri,c,cause);
++			break;
++		}
+ 		q931_disconnect(pri,c,cause);
+ 		break;
+ 	case Q931_CALL_STATE_DISCONNECT_REQUEST:
+@@ -3260,6 +3344,132 @@
+ 	return 0;
+ }
+ 
++static void clr_subcommands(struct subcommands *sub)
++{
++	sub->counter_subcmd = 0;
++}
++
++static struct subcommand *get_ptr_subcommand(struct subcommands *sub)
++{
++	if (sub->counter_subcmd < MAX_SUBCOMMANDS) {
++		int count = sub->counter_subcmd;
++		sub->counter_subcmd++;
++		return &sub->subcmd[count];
++	}
++
++	return NULL;
++}
++
++static struct subcommand *get_ptr_q931_subcommand_by_index(struct subcommands *sub, int index)
++{
++	if (index < MAX_SUBCOMMANDS) {
++		sub->counter_subcmd--;
++		return &sub->subcmd[index];
++	}
++
++	return NULL;
++}
++
++static int q931_facilities2eventfacilities(struct pri *pri, q931_call *c, struct subcommands *subcmds)
++{
++	int facilitypos;
++	int facility_number;
++	struct subcommand *c_subcmd;
++	struct subcommand *e_subcmd;
++
++	if (c->subcmds.counter_subcmd) {
++		facility_number = c->subcmds.counter_subcmd;
++
++		for (facilitypos = 0; facilitypos < facility_number; facilitypos++) {
++			c->subcmds.counter_subcmd--;
++			c_subcmd = get_ptr_q931_subcommand_by_index(&c->subcmds, facilitypos);
++			e_subcmd = get_ptr_subcommand(subcmds);
++			if (c_subcmd && e_subcmd) {
++				switch (c_subcmd->cmd) {
++				case CMD_CC_CCBSREQUEST_RR:
++					e_subcmd->cmd = c_subcmd->cmd;
++					memcpy(&c_subcmd->cc_ccbs_rr, &e_subcmd->cc_ccbs_rr, sizeof(c_subcmd->cc_ccbs_rr));
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "facility(QSIG_CC_CCBSREQUEST) (%d/%d)\n",
++										e_subcmd->cc_ccbs_rr.cc_request_res.no_path_reservation,
++										e_subcmd->cc_ccbs_rr.cc_request_res.retain_service);
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "counter_subcmd(%d)\n", subcmds->counter_subcmd);
++					c->ccrequestresult = 1;
++					break;
++				case CMD_CC_CCNRREQUEST_RR:
++					e_subcmd->cmd = c_subcmd->cmd;
++					memcpy(&c_subcmd->cc_ccnr_rr, &e_subcmd->cc_ccnr_rr, sizeof(c_subcmd->cc_ccnr_rr));
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "facility(QSIG_CC_CCNRREQUEST) (%d/%d)\n",
++										e_subcmd->cc_ccnr_rr.cc_request_res.no_path_reservation,
++										e_subcmd->cc_ccnr_rr.cc_request_res.retain_service);
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "counter_subcmd(%d)\n", subcmds->counter_subcmd);
++					c->ccrequestresult = 1;
++					break;
++				case CMD_CC_CANCEL_INV:
++					e_subcmd->cmd = c_subcmd->cmd;
++					memcpy(&c_subcmd->cc_cancel_inv, &e_subcmd->cc_cancel_inv, sizeof(c_subcmd->cc_cancel_inv));
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "facility(QSIG_CC_CANCEL) (%s/%s)\n",
++										e_subcmd->cc_cancel_inv.cc_optional_arg.number_A,
++										e_subcmd->cc_cancel_inv.cc_optional_arg.number_B);
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "counter_subcmd(%d)\n", subcmds->counter_subcmd);
++					break;
++				case CMD_CC_EXECPOSIBLE_INV:
++					e_subcmd->cmd = c_subcmd->cmd;
++					memcpy(&c_subcmd->cc_execposible_inv, &e_subcmd->cc_execposible_inv, sizeof(c_subcmd->cc_execposible_inv));
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "facility(QSIG_CC_EXECPOSIBLE) (%s/%s)\n",
++										e_subcmd->cc_execposible_inv.cc_optional_arg.number_A,
++										e_subcmd->cc_execposible_inv.cc_optional_arg.number_B);
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "counter_subcmd(%d)\n", subcmds->counter_subcmd);
++					break;
++				case CMD_CC_RINGOUT_INV:
++					e_subcmd->cmd = c_subcmd->cmd;
++					memcpy(&c_subcmd->cc_ringout_inv, &e_subcmd->cc_ringout_inv, sizeof(c_subcmd->cc_ringout_inv));
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "facility(QSIG_CC_RINGOUT) (%d)\n",
++										e_subcmd->cc_ringout_inv.cc_extension.cc_extension_tag);
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "counter_subcmd(%d)\n", subcmds->counter_subcmd);
++					break;
++				case CMD_CC_SUSPEND_INV:
++					e_subcmd->cmd = c_subcmd->cmd;
++					memcpy(&c_subcmd->cc_suspend_inv, &e_subcmd->cc_suspend_inv, sizeof(c_subcmd->cc_suspend_inv));
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "facility(QSIG_CC_SUSPEND) (%d)\n",
++										e_subcmd->cc_suspend_inv.cc_extension.cc_extension_tag);
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "counter_subcmd(%d)\n", subcmds->counter_subcmd);
++					break;
++				case CMD_CC_ERROR:
++					e_subcmd->cmd = c_subcmd->cmd;
++					memcpy(&c_subcmd->cc_error, &e_subcmd->cc_error, sizeof(c_subcmd->cc_error));
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "facility(QSIG_CC_ERROR) (%d)\n",
++										e_subcmd->cc_error.error_value);
++					if (pri->debug & PRI_DEBUG_APDU)
++						pri_message(pri, "counter_subcmd(%d)\n", subcmds->counter_subcmd);
++					break;
++				default:
++					pri_error(pri, "Don't know how to handle Facility subcmd %d\n", c_subcmd->cmd);
++					break;
++				}
++			}
++		}
++#if 0
++	} else {
++		pri_message(pri, "No facilities specified\n");
++#endif
++	}
++	return 0;
++}
++
++
+ int q931_receive(struct pri *pri, q931_h *h, int len)
+ {
+ 	q931_mh *mh;
+@@ -3312,6 +3522,7 @@
+ 		break;
+ 	case Q931_FACILITY:
+ 		c->callername[0] = '\0';
++		c->subcmds.counter_subcmd = 0;
+ 		break;
+ 	case Q931_SETUP:
+ 		if (pri->debug & PRI_DEBUG_Q931_STATE)
+@@ -3339,6 +3550,7 @@
+ 		c->redirectingplan = -1;
+ 		c->redirectingpres = -1;
+ 		c->redirectingreason = -1;
++		c->redirectingcount = 0;
+ 		c->origcalledplan = -1;
+ 		c->origcalledpres = -1;
+ 		c->origredirectingreason = -1;
+@@ -3346,6 +3558,29 @@
+ 		c->origcallednum[0] = '\0';
+ 		c->redirectingname[0] = '\0';
+ 		c->origcalledname[0] = '\0';
++		c->connectedplan = -1;
++		c->connectedpres = -1;
++		c->connectednum[0] = '\0';
++		c->connectedname[0] = '\0';
++		c->divleginfo1activeflag = 0;
++		c->divertedtocount = 0;
++		c->divertedtoplan = -1;
++		c->divertedtopres = -1;
++		c->divertedtoreason = -1;
++		c->divertedtonum[0] = '\0';
++		c->divleginfo3activeflag = 0;
++		c->divertedtoname[0] = '\0';
++		c->divertedstate = DIVERTEDSTATE_NONE;
++		c->ctcompleteflag = 0;
++		c->ctcompleteplan = -1;
++		c->ctcompletepres = -1;
++		c->ctcompletenum[0] = '\0';
++		c->ctcompletename[0] = '\0';
++		c->ctactiveflag = 0;
++		c->ctactiveplan = -1;
++		c->ctactivepres = -1;
++		c->ctactivenum[0] = '\0';
++		c->ctactivename[0] = '\0';
+ 		c->useruserprotocoldisc = -1; 
+ 		c->useruserinfo[0] = '\0';
+ 		c->complete = 0;
+@@ -3353,7 +3588,9 @@
+ 		c->aoc_units = -1;
+ 		/* Fall through */
+ 	case Q931_CONNECT:
++		c->ccrequestresult = 0;
+ 	case Q931_ALERTING:
++		c->subcmds.counter_subcmd = 0;
+ 	case Q931_PROGRESS:
+ 		c->useruserinfo[0] = '\0';
+ 		c->cause = -1;
+@@ -3369,6 +3606,7 @@
+ 		break;
+ 	case Q931_RELEASE:
+ 	case Q931_DISCONNECT:
++		c->subcmds.counter_subcmd = 0;
+ 		c->cause = -1;
+ 		c->causecode = -1;
+ 		c->causeloc = -1;
+@@ -3383,6 +3621,7 @@
+ 			pri_schedule_del(pri, c->retranstimer);
+ 		c->retranstimer = 0;
+ 		c->useruserinfo[0] = '\0';
++		c->subcmds.counter_subcmd = 0;
+ 		/* Fall through */
+ 	case Q931_STATUS:
+ 		c->cause = -1;
+@@ -3539,6 +3778,9 @@
+ 		if (!c->newcall) {
+ 			break;
+ 		}
++
++		clr_subcommands(&pri->ev.ring.subcmds);
++
+ 		if (c->progressmask & PRI_PROG_CALLER_NOT_ISDN)
+ 			c->nonisdn = 1;
+ 		c->newcall = 0;
+@@ -3570,7 +3812,9 @@
+ 		libpri_copy_string(pri->ev.ring.redirectingname, c->redirectingname, sizeof(pri->ev.ring.redirectingname));
+ 		libpri_copy_string(pri->ev.ring.useruserinfo, c->useruserinfo, sizeof(pri->ev.ring.useruserinfo));
+ 		c->useruserinfo[0] = '\0';
++		pri->ev.ring.redirectingpres = c->redirectingpres;
+ 		pri->ev.ring.redirectingreason = c->redirectingreason;
++		pri->ev.ring.redirectingcount = c->redirectingcount;
+ 		pri->ev.ring.origredirectingreason = c->origredirectingreason;
+ 		pri->ev.ring.flexible = ! (c->chanflags & FLAG_EXCLUSIVE);
+ 		pri->ev.ring.cref = c->cr;
+@@ -3578,15 +3822,21 @@
+ 		pri->ev.ring.layer1 = c->userl1;
+ 		pri->ev.ring.complete = c->complete; 
+ 		pri->ev.ring.ctype = c->transcapability;
+-		pri->ev.ring.redirectingreason = c->redirectingreason;
+ 		pri->ev.ring.progress = c->progress;
+ 		pri->ev.ring.progressmask = c->progressmask;
++		if (pri->debug & PRI_DEBUG_APDU) {
++			pri_message(pri, "Sending ring event (%d) nochannelsignalling (%d) facility_number (%d)\n",
++									pri->ev.ring.cref, c->nochannelsignalling, pri->ev.ring.subcmds.counter_subcmd);
++		}
++		q931_facilities2eventfacilities(pri, c, &pri->ev.ring.subcmds);
+ 		return Q931_RES_HAVEEVENT;
+ 	case Q931_ALERTING:
+ 		if (c->newcall) {
+ 			q931_release_complete(pri,c,PRI_CAUSE_INVALID_CALL_REFERENCE);
+ 			break;
+ 		}
++		clr_subcommands(&pri->ev.ringing.subcmds);
++
+ 		UPDATE_OURCALLSTATE(pri, c, Q931_CALL_STATE_CALL_DELIVERED);
+ 		c->peercallstate = Q931_CALL_STATE_CALL_RECEIVED;
+ 		pri->ev.e = PRI_EVENT_RINGING;
+@@ -3595,8 +3845,26 @@
+ 		pri->ev.ringing.call = c;
+ 		pri->ev.ringing.progress = c->progress;
+ 		pri->ev.ringing.progressmask = c->progressmask;
++
++		if (c->divleginfo3activeflag) {
++			c->divleginfo3activeflag = 0;
++			libpri_copy_string(pri->ev.ringing.calledname, c->divertedtoname, sizeof(pri->ev.ringing.calledname));
++			libpri_copy_string(pri->ev.ringing.callednum, (c->divertedtonum[0]) ? c->divertedtonum : c->callednum, sizeof(pri->ev.ringing.callednum));
++			pri->ev.ringing.calledpres = c->divertedtopres;
++			pri->ev.ringing.calledplan = c->divertedtoplan;
++		} else {
++			libpri_copy_string(pri->ev.ringing.calledname, c->calledname, sizeof(pri->ev.ringing.calledname));
++			libpri_copy_string(pri->ev.ringing.callednum, (c->divertedtonum[0]) ? c->divertedtonum : c->callednum, sizeof(pri->ev.ringing.callednum));
++			pri->ev.ringing.calledpres = PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
++			pri->ev.ringing.calledplan = c->calledplan;
++		}
+ 		libpri_copy_string(pri->ev.ringing.useruserinfo, c->useruserinfo, sizeof(pri->ev.ringing.useruserinfo));
+ 		c->useruserinfo[0] = '\0';
++		if (pri->debug & PRI_DEBUG_APDU) {
++			pri_message(pri, "Sending ringing event (%d) nochannelsignalling (%d) facility_number (%d)\n",
++									pri->ev.ringing.cref, c->nochannelsignalling, pri->ev.ringing.subcmds.counter_subcmd);
++		}
++		q931_facilities2eventfacilities(pri, c, &pri->ev.ringing.subcmds);
+ 
+ 		cur = c->apdus;
+ 		while (cur) {
+@@ -3617,6 +3885,8 @@
+ 			q931_status(pri, c, PRI_CAUSE_WRONG_MESSAGE);
+ 			break;
+ 		}
++		clr_subcommands(&pri->ev.answer.subcmds);
++
+ 		UPDATE_OURCALLSTATE(pri, c, Q931_CALL_STATE_ACTIVE);
+ 		c->peercallstate = Q931_CALL_STATE_CONNECT_REQUEST;
+ 		pri->ev.e = PRI_EVENT_ANSWER;
+@@ -3625,31 +3895,166 @@
+ 		pri->ev.answer.call = c;
+ 		pri->ev.answer.progress = c->progress;
+ 		pri->ev.answer.progressmask = c->progressmask;
++		libpri_copy_string(pri->ev.answer.connectednum, c->connectednum, sizeof(pri->ev.answer.connectednum));
++		libpri_copy_string(pri->ev.answer.connectedname, c->connectedname, sizeof(pri->ev.answer.connectedname));
++		pri->ev.answer.connectedpres = c->connectedpres;
++		pri->ev.answer.connectedplan = c->connectedplan;
++		pri->ev.answer.source = PRI_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
+ 		libpri_copy_string(pri->ev.answer.useruserinfo, c->useruserinfo, sizeof(pri->ev.answer.useruserinfo));
+ 		c->useruserinfo[0] = '\0';
++		if (pri->debug & PRI_DEBUG_APDU) {
++			pri_message(pri, "Sending answer event (%d) nochannelsignalling (%d) facility_number (%d)\n",
++									pri->ev.answer.cref, c->nochannelsignalling, pri->ev.answer.subcmds.counter_subcmd);
++		}
++		q931_facilities2eventfacilities(pri, c, &pri->ev.answer.subcmds);
+ 		q931_connect_acknowledge(pri, c);
++		if (c->nochannelsignalling) {
++			if (c->ccrequestresult) {
++				pri_message(pri, "Q931_CONNECT: start CC-Timer2\n");
++				c->cctimer2 = pri_schedule_event(pri, pri->timers[PRI_TIMER_CCBST2], pri_cctimer2_timeout, c);
++			}
++			return Q931_RES_HAVEEVENT;
++		}
+ 		if (c->justsignalling) {  /* Make sure WE release when we initiatie a signalling only connection */
+ 			q931_release(pri, c, PRI_CAUSE_NORMAL_CLEARING);
+ 			break;
+ 		} else
+ 			return Q931_RES_HAVEEVENT;
+ 	case Q931_FACILITY:
+-		if (c->newcall) {
+-			q931_release_complete(pri,c,PRI_CAUSE_INVALID_CALL_REFERENCE);
+-			break;
++		{
++			int haveevent = 0;
++			clr_subcommands(&pri->ev.facility.subcmds);
++
++			if (c->newcall) {
++				q931_release_complete(pri,c,PRI_CAUSE_INVALID_CALL_REFERENCE);
++				break;
++			}
++			if (c->subcmds.counter_subcmd) {
++				pri->ev.e = PRI_EVENT_FACILITY;
++				pri->ev.facility.channel = c->channelno | (c->ds1no << 8) | (c->ds1explicit << 16);
++				pri->ev.facility.cref = c->cr;
++				pri->ev.facility.call = c;
++
++				if (pri->debug & PRI_DEBUG_APDU) {
++					pri_message(pri, "Sending facility event (%d) nochannelsignalling (%d) facility_number (%d)\n",
++											pri->ev.facility.cref, c->nochannelsignalling, pri->ev.facility.subcmds.counter_subcmd);
++				}
++				q931_facilities2eventfacilities(pri, c, &pri->ev.facility.subcmds);
++				haveevent = 1;
++			}
++			if (c->ctcompleteflag) {
++				c->ctcompleteflag = 0;
++
++				if (c->ctcompletecallstatus == 0) {
++					/* answered(0) */
++					struct subcommand *subcmd;
++
++					pri_message(pri, "Got CT-Complete, callStatus = answered(0)\n");
++					pri->ev.e = PRI_EVENT_FACILITY;
++					pri->ev.facility.channel = c->channelno | (c->ds1no << 8) | (c->ds1explicit << 16);
++					pri->ev.facility.call = c;
++
++					subcmd = get_ptr_subcommand(&pri->ev.facility.subcmds);
++					if (subcmd) {
++						struct cmd_connectedline *cmdcl = &subcmd->connectedline;
++
++						subcmd->cmd = CMD_CONNECTEDLINE;
++						libpri_copy_string(cmdcl->connected.id.number, c->ctcompletenum, sizeof(cmdcl->connected.id.number));
++						libpri_copy_string(cmdcl->connected.id.name, c->ctcompletename, sizeof(cmdcl->connected.id.name));
++						cmdcl->connected.id.number_type = c->ctcompleteplan;
++						cmdcl->connected.id.number_presentation = c->ctcompletepres;
++						cmdcl->connected.source = PRI_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER;
++						haveevent = 1;
++						pri_message(pri, "CT-Complete, sending facility/CMD_CONNECTEDLINE (%s/%s)\n", cmdcl->connected.id.name, cmdcl->connected.id.number);
++					}
++				} else if (c->ctcompletecallstatus == 1) {
++					/* alerting(1) */
++					struct subcommand *subcmd;
++
++					pri_message(pri, "Got CT-Complete, callStatus = alerting(1)\n");
++					pri->ev.e = PRI_EVENT_FACILITY;
++					pri->ev.facility.channel = c->channelno | (c->ds1no << 8) | (c->ds1explicit << 16);
++					pri->ev.facility.call = c;
++
++					subcmd = get_ptr_subcommand(&pri->ev.facility.subcmds);
++					if (subcmd) {
++						struct cmd_redirecting *cmdr = &subcmd->redirecting;
++
++						subcmd->cmd = CMD_REDIRECTING;
++						libpri_copy_string(cmdr->redirecting.from.number, c->connectednum, sizeof(cmdr->redirecting.from.number));
++						libpri_copy_string(cmdr->redirecting.from.name, c->connectedname, sizeof(cmdr->redirecting.from.name));
++						cmdr->redirecting.from.number_type = c->connectedplan;
++						cmdr->redirecting.from.number_presentation = c->connectedpres;
++						libpri_copy_string(cmdr->redirecting.to.number, c->ctcompletenum, sizeof(cmdr->redirecting.to.number));
++						libpri_copy_string(cmdr->redirecting.to.name, c->ctcompletename, sizeof(cmdr->redirecting.to.name));
++						cmdr->redirecting.to.number_type = c->ctcompleteplan;
++						cmdr->redirecting.to.number_presentation = c->ctcompletepres;
++						cmdr->redirecting.count = 0;
++						cmdr->redirecting.reason = PRI_REDIR_UNKNOWN;
++						haveevent = 1;
++						pri_message(pri, "CT-Complete, sending facility/CMD_REDIRECTING (%s/%s)\n", cmdr->redirecting.to.name, cmdr->redirecting.to.number);
++					}
++				} else {
++					pri_message(pri, "illegal value for callStatus=%d\n", c->ctcompletecallstatus);
++				}
++			} else if (c->ctactiveflag) {
++				struct subcommand *subcmd;
++
++				c->ctactiveflag = 0;
++
++				pri_message(pri, "Got CT-Active\n");
++				pri->ev.e = PRI_EVENT_FACILITY;
++				pri->ev.facility.channel = c->channelno | (c->ds1no << 8) | (c->ds1explicit << 16);
++				pri->ev.facility.call = c;
++
++				subcmd = get_ptr_subcommand(&pri->ev.facility.subcmds);
++				if (subcmd) {
++					struct cmd_connectedline *cmdcl = &subcmd->connectedline;
++
++					subcmd->cmd = CMD_CONNECTEDLINE;
++					libpri_copy_string(cmdcl->connected.id.number, c->ctcompletenum, sizeof(cmdcl->connected.id.number));
++					libpri_copy_string(cmdcl->connected.id.name, c->ctcompletename, sizeof(cmdcl->connected.id.name));
++					cmdcl->connected.id.number_type = c->ctcompleteplan;
++					cmdcl->connected.id.number_presentation = c->ctcompletepres;
++					cmdcl->connected.source = PRI_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER;
++					haveevent = 1;
++					pri_message(pri, "CT-Active, sending facility CMD_CONNECTEDLINE (%s/%s)\n", cmdcl->connected.id.name, cmdcl->connected.id.number);
++				}
++			}
++			else if (c->divleginfo1activeflag) {
++				struct subcommand *subcmd;
++
++				c->divleginfo1activeflag = 0;
++
++				pri_message(pri, "Got DivertingLegInformation1\n");
++				pri->ev.e = PRI_EVENT_FACILITY;
++				pri->ev.facility.channel = c->channelno | (c->ds1no << 8) | (c->ds1explicit << 16);
++				pri->ev.facility.call = c;
++
++				subcmd = get_ptr_subcommand(&pri->ev.facility.subcmds);
++				if (subcmd) {
++					struct cmd_redirecting *cmdr = &subcmd->redirecting;
++
++					subcmd->cmd = CMD_REDIRECTING;
++					libpri_copy_string(cmdr->redirecting.from.number, c->callednum, sizeof(cmdr->redirecting.from.number));
++					cmdr->redirecting.from.name[0] = '\0';
++					cmdr->redirecting.from.number_type = c->calledplan;
++					cmdr->redirecting.from.number_presentation = PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
++					libpri_copy_string(cmdr->redirecting.to.number, c->divertedtonum, sizeof(cmdr->redirecting.to.number));
++					cmdr->redirecting.to.name[0] = '\0';
++					cmdr->redirecting.to.number_type = c->divertedtoplan;
++					cmdr->redirecting.to.number_presentation = c->divertedtopres;
++					cmdr->redirecting.count = c->divertedtocount;
++					cmdr->redirecting.reason = c->divertedtoreason;
++					haveevent = 1;
++					pri_message(pri, "DivertingLegInformation1, sending facility/CMD_REDIRECTING (%s/%s)\n", cmdr->redirecting.to.name, cmdr->redirecting.to.number);
++				}
++			}
++
++			if (haveevent)
++				return Q931_RES_HAVEEVENT;
+ 		}
+-		pri->ev.e = PRI_EVENT_FACNAME;
+-		libpri_copy_string(pri->ev.facname.callingname, c->callername, sizeof(pri->ev.facname.callingname));
+-		libpri_copy_string(pri->ev.facname.callingnum, c->callernum, sizeof(pri->ev.facname.callingnum));
+-		pri->ev.facname.channel = c->channelno | (c->ds1no << 8) | (c->ds1explicit << 16);
+-		pri->ev.facname.callingpres = c->callerpres;
+-		pri->ev.facname.callingplan = c->callerplan;
+-		pri->ev.facname.cref = c->cr;
+-		pri->ev.facname.call = c;
+-#if 0
+-		pri_message(pri, "Sending facility event (%s/%s)\n", pri->ev.facname.callingname, pri->ev.facname.callingnum);
+-#endif
+-		return Q931_RES_HAVEEVENT;
++		break;
+ 	case Q931_PROGRESS:
+ 		if (missingmand) {
+ 			q931_status(pri, c, PRI_CAUSE_MANDATORY_IE_MISSING);
+@@ -3757,6 +4162,8 @@
+ 		}
+ 		break;
+ 	case Q931_RELEASE_COMPLETE:
++		clr_subcommands(&pri->ev.hangup.subcmds);
++
+ 		UPDATE_OURCALLSTATE(pri, c, Q931_CALL_STATE_NULL);
+ 		c->peercallstate = Q931_CALL_STATE_NULL;
+ 		pri->ev.hangup.channel = c->channelno | (c->ds1no << 8) | (c->ds1explicit << 16);
+@@ -3766,6 +4173,11 @@
+ 		pri->ev.hangup.aoc_units = c->aoc_units;
+ 		libpri_copy_string(pri->ev.hangup.useruserinfo, c->useruserinfo, sizeof(pri->ev.hangup.useruserinfo));
+ 		c->useruserinfo[0] = '\0';
++		if (pri->debug & PRI_DEBUG_APDU) {
++			pri_message(pri, "Sending hangup event (%d) nochannelsignalling (%d) facility_number (%d)\n",
++									pri->ev.hangup.cref, c->nochannelsignalling, pri->ev.hangup.subcmds.counter_subcmd);
++		}
++		q931_facilities2eventfacilities(pri, c, &pri->ev.hangup.subcmds);
+ 		/* Free resources */
+ 		if (c->alive) {
+ 			pri->ev.e = PRI_EVENT_HANGUP;
+@@ -3783,6 +4195,8 @@
+ 			q931_hangup(pri,c,c->cause);
+ 		break;
+ 	case Q931_RELEASE:
++		clr_subcommands(&pri->ev.hangup.subcmds);
++
+ 		if (missingmand) {
+ 			/* Force cause to be mandatory IE missing */
+ 			c->cause = PRI_CAUSE_MANDATORY_IE_MISSING;
+@@ -3801,6 +4215,11 @@
+ 		pri->ev.hangup.aoc_units = c->aoc_units;
+ 		libpri_copy_string(pri->ev.hangup.useruserinfo, c->useruserinfo, sizeof(pri->ev.hangup.useruserinfo));
+ 		c->useruserinfo[0] = '\0';
++		if (pri->debug & PRI_DEBUG_APDU) {
++			pri_message(pri, "Sending hangup event (%d) nochannelsignalling (%d) facility_number (%d)\n",
++									pri->ev.hangup.cref, c->nochannelsignalling, pri->ev.hangup.subcmds.counter_subcmd);
++		}
++		q931_facilities2eventfacilities(pri, c, &pri->ev.hangup.subcmds);
+ 		/* Don't send release complete if they send us release 
+ 		   while we sent it, assume a NULL state */
+ 		if (c->newcall)
+@@ -3809,6 +4228,8 @@
+ 			return Q931_RES_HAVEEVENT;
+ 		break;
+ 	case Q931_DISCONNECT:
++		clr_subcommands(&pri->ev.hangup.subcmds);
++
+ 		if (missingmand) {
+ 			/* Still let user call release */
+ 			c->cause = PRI_CAUSE_MANDATORY_IE_MISSING;
+@@ -3835,6 +4256,11 @@
+ 		pri->ev.hangup.aoc_units = c->aoc_units;
+ 		libpri_copy_string(pri->ev.hangup.useruserinfo, c->useruserinfo, sizeof(pri->ev.hangup.useruserinfo));
+ 		c->useruserinfo[0] = '\0';
++		if (pri->debug & PRI_DEBUG_APDU) {
++			pri_message(pri, "Sending hangup event (%d) nochannelsignalling (%d) facility_number (%d)\n",
++									pri->ev.hangup.cref, c->nochannelsignalling, pri->ev.hangup.subcmds.counter_subcmd);
++		}
++		q931_facilities2eventfacilities(pri, c, &pri->ev.hangup.subcmds);
+ 		if (c->alive)
+ 			return Q931_RES_HAVEEVENT;
+ 		else
+
+Property changes on: .
+___________________________________________________________________
+Added: automerge
+   + *
+Added: automerge-propname
+   + issue14292-integrated
+Added: svnmerge-integrated
+   + /branches/1.4:1-688
+Added: automerge-email
+   + rmudgett@digium.com
+Added: issue14292-integrated
+   + /team/group/issue14068:1-699
+
diff --git a/main/libpri/libpri-cflags.patch b/main/libpri/libpri-cflags.patch
new file mode 100644
index 00000000000..7bf31c7ac1b
--- /dev/null
+++ b/main/libpri/libpri-cflags.patch
@@ -0,0 +1,21 @@
+Index: Makefile
+===================================================================
+--- a/Makefile	(revision 650)
++++ b/Makefile	(working copy)
+@@ -43,7 +43,7 @@
+ DYNAMIC_LIBRARY:=libpri.so.$(SONAME)
+ STATIC_OBJS=copy_string.o pri.o q921.o prisched.o q931.o pri_facility.o version.o
+ DYNAMIC_OBJS=copy_string.lo pri.lo q921.lo prisched.lo q931.lo pri_facility.lo version.lo
+-CFLAGS=-Wall -Werror -Wstrict-prototypes -Wmissing-prototypes -g -fPIC $(ALERTING) $(LIBPRI_COUNTERS)
++CFLAGS+=-Wall -Werror -Wstrict-prototypes -Wmissing-prototypes -g -fPIC $(ALERTING) $(LIBPRI_COUNTERS)
+ INSTALL_PREFIX=$(DESTDIR)
+ INSTALL_BASE=/usr
+ libdir?=$(INSTALL_BASE)/lib
+@@ -102,7 +102,6 @@
+ ifneq (${OSARCH},SunOS)
+ 	install -m 644 libpri.h $(INSTALL_PREFIX)$(INSTALL_BASE)/include
+ 	install -m 755 $(DYNAMIC_LIBRARY) $(INSTALL_PREFIX)$(libdir)
+-	if [ -x /usr/sbin/sestatus ] && ( /usr/sbin/sestatus | grep "SELinux status:" | grep -q "enabled"); then /sbin/restorecon -v $(INSTALL_PREFIX)$(libdir)/$(DYNAMIC_LIBRARY); fi
+ 	( cd $(INSTALL_PREFIX)$(libdir) ; ln -sf libpri.so.$(SONAME) libpri.so)
+ 	install -m 644 $(STATIC_LIBRARY) $(INSTALL_PREFIX)$(libdir)
+ 	if test $$(id -u) = 0; then $(LDCONFIG) $(LDCONFIG_FLAGS) $(INSTALL_PREFIX)$(libdir); fi