committing current state of things

Makefile

@@ -0,0 +1,11 @@
+# stub
+
+
+.PHONY: all regenerate-asn1
+
+all:
+	exit 1
+
+regenerate-asn1:
+	rm -f asn1-compiled/*
+	(cd asn1-compiled && asn1c -fskeletons-copy ../asn1/tcap.asn)

asn1-compiled/AALParameters.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "AALParameters.h"
+
+int
+AALParameters_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+AALParameters_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+AALParameters_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	AALParameters_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+AALParameters_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	AALParameters_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+AALParameters_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	AALParameters_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+AALParameters_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AALParameters_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+AALParameters_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	AALParameters_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+AALParameters_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AALParameters_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_AALParameters_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_AALParameters = {
+	"AALParameters",
+	"AALParameters",
+	AALParameters_free,
+	AALParameters_print,
+	AALParameters_constraint,
+	AALParameters_decode_ber,
+	AALParameters_encode_der,
+	AALParameters_decode_xer,
+	AALParameters_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AALParameters_tags_1,
+	sizeof(asn_DEF_AALParameters_tags_1)
+		/sizeof(asn_DEF_AALParameters_tags_1[0]), /* 1 */
+	asn_DEF_AALParameters_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AALParameters_tags_1)
+		/sizeof(asn_DEF_AALParameters_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/AALParameters.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_AALParameters_H_
+#define	_AALParameters_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AALParameters */
+typedef OCTET_STRING_t	 AALParameters_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AALParameters;
+asn_struct_free_f AALParameters_free;
+asn_struct_print_f AALParameters_print;
+asn_constr_check_f AALParameters_constraint;
+ber_type_decoder_f AALParameters_decode_ber;
+der_type_encoder_f AALParameters_encode_der;
+xer_type_decoder_f AALParameters_decode_xer;
+xer_type_encoder_f AALParameters_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AALParameters_H_ */
+#include <asn_internal.h>

asn1-compiled/AARE-apdu.c

@@ -0,0 +1,89 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "AARE-apdu.h"
+
+static asn_TYPE_member_t asn_MBR_AARE_apdu_1[] = {
+	{ ATF_POINTER, 1, offsetof(struct AARE_apdu, protocol_versionRE),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"protocol-versionRE"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AARE_apdu, application_context_name),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_OBJECT_IDENTIFIER,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"application-context-name"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AARE_apdu, result),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_Associate_result,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"result"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AARE_apdu, result_source_diagnostic),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_Associate_source_diagnostic,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"result-source-diagnostic"
+		},
+};
+static ber_tlv_tag_t asn_DEF_AARE_apdu_tags_1[] = {
+	(ASN_TAG_CLASS_APPLICATION | (1 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AARE_apdu_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* protocol-versionRE at 29 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* application-context-name at 30 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* result at 31 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* result-source-diagnostic at 33 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AARE_apdu_specs_1 = {
+	sizeof(struct AARE_apdu),
+	offsetof(struct AARE_apdu, _asn_ctx),
+	asn_MAP_AARE_apdu_tag2el_1,
+	4,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AARE_apdu = {
+	"AARE-apdu",
+	"AARE-apdu",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AARE_apdu_tags_1,
+	sizeof(asn_DEF_AARE_apdu_tags_1)
+		/sizeof(asn_DEF_AARE_apdu_tags_1[0]) - 1, /* 1 */
+	asn_DEF_AARE_apdu_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AARE_apdu_tags_1)
+		/sizeof(asn_DEF_AARE_apdu_tags_1[0]), /* 2 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AARE_apdu_1,
+	4,	/* Elements count */
+	&asn_SPC_AARE_apdu_specs_1	/* Additional specs */
+};
+

asn1-compiled/AARE-apdu.h

@@ -0,0 +1,48 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_AARE_apdu_H_
+#define	_AARE_apdu_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+#include <OBJECT_IDENTIFIER.h>
+#include "Associate-result.h"
+#include "Associate-source-diagnostic.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum protocol_versionRE {
+	protocol_versionRE_version1	= 0
+} e_protocol_versionRE;
+
+/* AARE-apdu */
+typedef struct AARE_apdu {
+	BIT_STRING_t	*protocol_versionRE	/* DEFAULT {version1} */;
+	OBJECT_IDENTIFIER_t	 application_context_name;
+	Associate_result_t	 result;
+	Associate_source_diagnostic_t	 result_source_diagnostic;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AARE_apdu_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AARE_apdu;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AARE_apdu_H_ */
+#include <asn_internal.h>

asn1-compiled/AARQ-apdu.c

@@ -0,0 +1,69 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "AARQ-apdu.h"
+
+static asn_TYPE_member_t asn_MBR_AARQ_apdu_1[] = {
+	{ ATF_POINTER, 1, offsetof(struct AARQ_apdu, protocol_versionRQ),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_BIT_STRING,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"protocol-versionRQ"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct AARQ_apdu, application_context_name),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_OBJECT_IDENTIFIER,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"application-context-name"
+		},
+};
+static ber_tlv_tag_t asn_DEF_AARQ_apdu_tags_1[] = {
+	(ASN_TAG_CLASS_APPLICATION | (0 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_AARQ_apdu_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* protocol-versionRQ at 23 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* application-context-name at 24 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_AARQ_apdu_specs_1 = {
+	sizeof(struct AARQ_apdu),
+	offsetof(struct AARQ_apdu, _asn_ctx),
+	asn_MAP_AARQ_apdu_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_AARQ_apdu = {
+	"AARQ-apdu",
+	"AARQ-apdu",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AARQ_apdu_tags_1,
+	sizeof(asn_DEF_AARQ_apdu_tags_1)
+		/sizeof(asn_DEF_AARQ_apdu_tags_1[0]) - 1, /* 1 */
+	asn_DEF_AARQ_apdu_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AARQ_apdu_tags_1)
+		/sizeof(asn_DEF_AARQ_apdu_tags_1[0]), /* 2 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AARQ_apdu_1,
+	2,	/* Elements count */
+	&asn_SPC_AARQ_apdu_specs_1	/* Additional specs */
+};
+

asn1-compiled/AARQ-apdu.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_AARQ_apdu_H_
+#define	_AARQ_apdu_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+#include <OBJECT_IDENTIFIER.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum protocol_versionRQ {
+	protocol_versionRQ_version1	= 0
+} e_protocol_versionRQ;
+
+/* AARQ-apdu */
+typedef struct AARQ_apdu {
+	BIT_STRING_t	*protocol_versionRQ	/* DEFAULT {version1} */;
+	OBJECT_IDENTIFIER_t	 application_context_name;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AARQ_apdu_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AARQ_apdu;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AARQ_apdu_H_ */
+#include <asn_internal.h>

asn1-compiled/ABRT-apdu.c

@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "ABRT-apdu.h"
+
+static asn_TYPE_member_t asn_MBR_ABRT_apdu_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct ABRT_apdu, abort_source),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ABRT_source,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"abort-source"
+		},
+};
+static ber_tlv_tag_t asn_DEF_ABRT_apdu_tags_1[] = {
+	(ASN_TAG_CLASS_APPLICATION | (4 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_ABRT_apdu_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* abort-source at 36 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_ABRT_apdu_specs_1 = {
+	sizeof(struct ABRT_apdu),
+	offsetof(struct ABRT_apdu, _asn_ctx),
+	asn_MAP_ABRT_apdu_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_ABRT_apdu = {
+	"ABRT-apdu",
+	"ABRT-apdu",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ABRT_apdu_tags_1,
+	sizeof(asn_DEF_ABRT_apdu_tags_1)
+		/sizeof(asn_DEF_ABRT_apdu_tags_1[0]) - 1, /* 1 */
+	asn_DEF_ABRT_apdu_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ABRT_apdu_tags_1)
+		/sizeof(asn_DEF_ABRT_apdu_tags_1[0]), /* 2 */
+	0,	/* No PER visible constraints */
+	asn_MBR_ABRT_apdu_1,
+	1,	/* Elements count */
+	&asn_SPC_ABRT_apdu_specs_1	/* Additional specs */
+};
+

asn1-compiled/ABRT-apdu.h

@@ -0,0 +1,37 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_ABRT_apdu_H_
+#define	_ABRT_apdu_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "ABRT-source.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ABRT-apdu */
+typedef struct ABRT_apdu {
+	ABRT_source_t	 abort_source;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ABRT_apdu_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ABRT_apdu;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ABRT_apdu_H_ */
+#include <asn_internal.h>

asn1-compiled/ABRT-source.c

@@ -0,0 +1,107 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "ABRT-source.h"
+
+int
+ABRT_source_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_INTEGER.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+ABRT_source_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_INTEGER.free_struct;
+	td->print_struct   = asn_DEF_INTEGER.print_struct;
+	td->ber_decoder    = asn_DEF_INTEGER.ber_decoder;
+	td->der_encoder    = asn_DEF_INTEGER.der_encoder;
+	td->xer_decoder    = asn_DEF_INTEGER.xer_decoder;
+	td->xer_encoder    = asn_DEF_INTEGER.xer_encoder;
+	td->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	td->uper_encoder   = asn_DEF_INTEGER.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+ABRT_source_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	ABRT_source_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+ABRT_source_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	ABRT_source_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+ABRT_source_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	ABRT_source_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+ABRT_source_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ABRT_source_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+ABRT_source_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	ABRT_source_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+ABRT_source_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ABRT_source_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_ABRT_source_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_ABRT_source = {
+	"ABRT-source",
+	"ABRT-source",
+	ABRT_source_free,
+	ABRT_source_print,
+	ABRT_source_constraint,
+	ABRT_source_decode_ber,
+	ABRT_source_encode_der,
+	ABRT_source_decode_xer,
+	ABRT_source_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ABRT_source_tags_1,
+	sizeof(asn_DEF_ABRT_source_tags_1)
+		/sizeof(asn_DEF_ABRT_source_tags_1[0]), /* 1 */
+	asn_DEF_ABRT_source_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ABRT_source_tags_1)
+		/sizeof(asn_DEF_ABRT_source_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+

asn1-compiled/ABRT-source.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_ABRT_source_H_
+#define	_ABRT_source_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <INTEGER.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum ABRT_source {
+	ABRT_source_dialogue_service_user	= 0,
+	ABRT_source_dialogue_service_provider	= 1
+} e_ABRT_source;
+
+/* ABRT-source */
+typedef INTEGER_t	 ABRT_source_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ABRT_source;
+asn_struct_free_f ABRT_source_free;
+asn_struct_print_f ABRT_source_print;
+asn_constr_check_f ABRT_source_constraint;
+ber_type_decoder_f ABRT_source_decode_ber;
+der_type_encoder_f ABRT_source_encode_der;
+xer_type_decoder_f ABRT_source_decode_xer;
+xer_type_encoder_f ABRT_source_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ABRT_source_H_ */
+#include <asn_internal.h>

asn1-compiled/AESACalledParty.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "AESACalledParty.h"
+
+int
+AESACalledParty_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+AESACalledParty_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+AESACalledParty_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	AESACalledParty_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+AESACalledParty_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	AESACalledParty_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+AESACalledParty_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	AESACalledParty_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+AESACalledParty_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AESACalledParty_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+AESACalledParty_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	AESACalledParty_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+AESACalledParty_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AESACalledParty_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_AESACalledParty_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_AESACalledParty = {
+	"AESACalledParty",
+	"AESACalledParty",
+	AESACalledParty_free,
+	AESACalledParty_print,
+	AESACalledParty_constraint,
+	AESACalledParty_decode_ber,
+	AESACalledParty_encode_der,
+	AESACalledParty_decode_xer,
+	AESACalledParty_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AESACalledParty_tags_1,
+	sizeof(asn_DEF_AESACalledParty_tags_1)
+		/sizeof(asn_DEF_AESACalledParty_tags_1[0]), /* 1 */
+	asn_DEF_AESACalledParty_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AESACalledParty_tags_1)
+		/sizeof(asn_DEF_AESACalledParty_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/AESACalledParty.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_AESACalledParty_H_
+#define	_AESACalledParty_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AESACalledParty */
+typedef OCTET_STRING_t	 AESACalledParty_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AESACalledParty;
+asn_struct_free_f AESACalledParty_free;
+asn_struct_print_f AESACalledParty_print;
+asn_constr_check_f AESACalledParty_constraint;
+ber_type_decoder_f AESACalledParty_decode_ber;
+der_type_encoder_f AESACalledParty_encode_der;
+xer_type_decoder_f AESACalledParty_decode_xer;
+xer_type_encoder_f AESACalledParty_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AESACalledParty_H_ */
+#include <asn_internal.h>

asn1-compiled/AESACallingParty.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "AESACallingParty.h"
+
+int
+AESACallingParty_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+AESACallingParty_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+AESACallingParty_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	AESACallingParty_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+AESACallingParty_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	AESACallingParty_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+AESACallingParty_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	AESACallingParty_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+AESACallingParty_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AESACallingParty_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+AESACallingParty_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	AESACallingParty_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+AESACallingParty_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AESACallingParty_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_AESACallingParty_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_AESACallingParty = {
+	"AESACallingParty",
+	"AESACallingParty",
+	AESACallingParty_free,
+	AESACallingParty_print,
+	AESACallingParty_constraint,
+	AESACallingParty_decode_ber,
+	AESACallingParty_encode_der,
+	AESACallingParty_decode_xer,
+	AESACallingParty_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AESACallingParty_tags_1,
+	sizeof(asn_DEF_AESACallingParty_tags_1)
+		/sizeof(asn_DEF_AESACallingParty_tags_1[0]), /* 1 */
+	asn_DEF_AESACallingParty_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AESACallingParty_tags_1)
+		/sizeof(asn_DEF_AESACallingParty_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/AESACallingParty.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_AESACallingParty_H_
+#define	_AESACallingParty_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AESACallingParty */
+typedef OCTET_STRING_t	 AESACallingParty_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AESACallingParty;
+asn_struct_free_f AESACallingParty_free;
+asn_struct_print_f AESACallingParty_print;
+asn_constr_check_f AESACallingParty_constraint;
+ber_type_decoder_f AESACallingParty_decode_ber;
+der_type_encoder_f AESACallingParty_encode_der;
+xer_type_decoder_f AESACallingParty_decode_xer;
+xer_type_encoder_f AESACallingParty_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AESACallingParty_H_ */
+#include <asn_internal.h>

asn1-compiled/ANY.c

@@ -0,0 +1,158 @@
+/*-
+ * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <ANY.h>
+#include <errno.h>
+
+static asn_OCTET_STRING_specifics_t asn_DEF_ANY_specs = {
+	sizeof(ANY_t),
+	offsetof(ANY_t, _asn_ctx),
+	ASN_OSUBV_ANY
+};
+asn_TYPE_descriptor_t asn_DEF_ANY = {
+	"ANY",
+	"ANY",
+	OCTET_STRING_free,
+	OCTET_STRING_print,
+	asn_generic_no_constraint,
+	OCTET_STRING_decode_ber,
+	OCTET_STRING_encode_der,
+	OCTET_STRING_decode_xer_hex,
+	ANY_encode_xer,
+	0, 0,
+	0, /* Use generic outmost tag fetcher */
+	0, 0, 0, 0,
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	&asn_DEF_ANY_specs,
+};
+
+
+asn_enc_rval_t
+ANY_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+
+	if(flags & XER_F_CANONICAL) {
+		/*
+		 * Canonical XER-encoding of ANY type is not supported.
+		 */
+		_ASN_ENCODE_FAILED;
+	}
+
+	/* Dump as binary */
+	return OCTET_STRING_encode_xer(td, sptr, ilevel, flags, cb, app_key);
+}
+
+struct _callback_arg {
+	uint8_t *buffer;
+	size_t offset;
+	size_t size;
+};
+
+static int ANY__consume_bytes(const void *buffer, size_t size, void *key);
+
+int
+ANY_fromType(ANY_t *st, asn_TYPE_descriptor_t *td, void *sptr) {
+	struct _callback_arg arg;
+	asn_enc_rval_t erval;
+
+	if(!st || !td) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if(!sptr) {
+		if(st->buf) FREEMEM(st->buf);
+		st->size = 0;
+		return 0;
+	}
+
+	arg.offset = arg.size = 0;
+	arg.buffer = 0;
+
+	erval = der_encode(td, sptr, ANY__consume_bytes, &arg);
+	if(erval.encoded == -1) {
+		if(arg.buffer) FREEMEM(arg.buffer);
+		return -1;
+	}
+	assert((size_t)erval.encoded == arg.offset);
+
+	if(st->buf) FREEMEM(st->buf);
+	st->buf = arg.buffer;
+	st->size = arg.offset;
+
+	return 0;
+}
+
+ANY_t *
+ANY_new_fromType(asn_TYPE_descriptor_t *td, void *sptr) {
+	ANY_t tmp;
+	ANY_t *st;
+
+	if(!td || !sptr) {
+		errno = EINVAL;
+		return 0;
+	}
+
+	memset(&tmp, 0, sizeof(tmp));
+
+	if(ANY_fromType(&tmp, td, sptr)) return 0;
+
+	st = (ANY_t *)CALLOC(1, sizeof(ANY_t));
+	if(st) {
+		*st = tmp;
+		return st;
+	} else {
+		FREEMEM(tmp.buf);
+		return 0;
+	}
+}
+
+int
+ANY_to_type(ANY_t *st, asn_TYPE_descriptor_t *td, void **struct_ptr) {
+	asn_dec_rval_t rval;
+	void *newst = 0;
+
+	if(!st || !td || !struct_ptr) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if(st->buf == 0) {
+		/* Nothing to convert, make it empty. */
+		*struct_ptr = (void *)0;
+		return 0;
+	}
+
+	rval = ber_decode(0, td, (void **)&newst, st->buf, st->size);
+	if(rval.code == RC_OK) {
+		*struct_ptr = newst;
+		return 0;
+	} else {
+		/* Remove possibly partially decoded data. */
+		ASN_STRUCT_FREE(*td, newst);
+		return -1;
+	}
+}
+
+static int ANY__consume_bytes(const void *buffer, size_t size, void *key) {
+	struct _callback_arg *arg = (struct _callback_arg *)key;
+
+	if((arg->offset + size) >= arg->size) {
+		size_t nsize = (arg->size ? arg->size << 2 : 16) + size;
+		void *p = REALLOC(arg->buffer, nsize);
+		if(!p) return -1;
+		arg->buffer = (uint8_t *)p;
+		arg->size = nsize;
+	}
+
+	memcpy(arg->buffer + arg->offset, buffer, size);
+	arg->offset += size;
+	assert(arg->offset < arg->size);
+
+	return 0;
+}
+

asn1-compiled/ANY.h

@@ -0,0 +1,48 @@
+/*-
+ * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef ASN_TYPE_ANY_H
+#define ASN_TYPE_ANY_H
+
+#include <OCTET_STRING.h>	/* Implemented via OCTET STRING type */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ANY {
+	uint8_t *buf;	/* BER-encoded ANY contents */
+	int size;	/* Size of the above buffer */
+
+	asn_struct_ctx_t _asn_ctx;	/* Parsing across buffer boundaries */
+} ANY_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_ANY;
+
+asn_struct_free_f ANY_free;
+asn_struct_print_f ANY_print;
+ber_type_decoder_f ANY_decode_ber;
+der_type_encoder_f ANY_encode_der;
+xer_type_encoder_f ANY_encode_xer;
+
+/******************************
+ * Handy conversion routines. *
+ ******************************/
+
+/* Convert another ASN.1 type into the ANY. This implies DER encoding. */
+int ANY_fromType(ANY_t *, asn_TYPE_descriptor_t *td, void *struct_ptr);
+ANY_t *ANY_new_fromType(asn_TYPE_descriptor_t *td, void *struct_ptr);
+
+/* Convert the contents of the ANY type into the specified type. */
+int ANY_to_type(ANY_t *, asn_TYPE_descriptor_t *td, void **struct_ptr);
+
+#define	ANY_fromBuf(s, buf, size)	OCTET_STRING_fromBuf((s), (buf), (size))
+#define	ANY_new_fromBuf(buf, size)	OCTET_STRING_new_fromBuf(	\
+						&asn_DEF_ANY, (buf), (size))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* ASN_TYPE_ANY_H */

asn1-compiled/ATMCellRate.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "ATMCellRate.h"
+
+int
+ATMCellRate_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+ATMCellRate_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+ATMCellRate_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	ATMCellRate_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+ATMCellRate_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	ATMCellRate_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+ATMCellRate_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	ATMCellRate_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+ATMCellRate_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ATMCellRate_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+ATMCellRate_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	ATMCellRate_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+ATMCellRate_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ATMCellRate_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_ATMCellRate_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_ATMCellRate = {
+	"ATMCellRate",
+	"ATMCellRate",
+	ATMCellRate_free,
+	ATMCellRate_print,
+	ATMCellRate_constraint,
+	ATMCellRate_decode_ber,
+	ATMCellRate_encode_der,
+	ATMCellRate_decode_xer,
+	ATMCellRate_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ATMCellRate_tags_1,
+	sizeof(asn_DEF_ATMCellRate_tags_1)
+		/sizeof(asn_DEF_ATMCellRate_tags_1[0]), /* 1 */
+	asn_DEF_ATMCellRate_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ATMCellRate_tags_1)
+		/sizeof(asn_DEF_ATMCellRate_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/ATMCellRate.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_ATMCellRate_H_
+#define	_ATMCellRate_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ATMCellRate */
+typedef OCTET_STRING_t	 ATMCellRate_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ATMCellRate;
+asn_struct_free_f ATMCellRate_free;
+asn_struct_print_f ATMCellRate_print;
+asn_constr_check_f ATMCellRate_constraint;
+ber_type_decoder_f ATMCellRate_decode_ber;
+der_type_encoder_f ATMCellRate_encode_der;
+xer_type_decoder_f ATMCellRate_decode_xer;
+xer_type_encoder_f ATMCellRate_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ATMCellRate_H_ */
+#include <asn_internal.h>

asn1-compiled/Abort.c

@@ -0,0 +1,69 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "Abort.h"
+
+static asn_TYPE_member_t asn_MBR_Abort_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Abort, dtid),
+		(ASN_TAG_CLASS_APPLICATION | (9 << 2)),
+		0,
+		&asn_DEF_DestTransactionID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"dtid"
+		},
+	{ ATF_POINTER, 1, offsetof(struct Abort, reason),
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_Reason,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"reason"
+		},
+};
+static ber_tlv_tag_t asn_DEF_Abort_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_Abort_tag2el_1[] = {
+    { (ASN_TAG_CLASS_APPLICATION | (9 << 2)), 0, 0, 0 }, /* dtid at 87 */
+    { (ASN_TAG_CLASS_APPLICATION | (10 << 2)), 1, 0, 0 }, /* p-abortCause at 92 */
+    { (ASN_TAG_CLASS_APPLICATION | (11 << 2)), 1, 0, 0 } /* u-abortCause at 94 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_Abort_specs_1 = {
+	sizeof(struct Abort),
+	offsetof(struct Abort, _asn_ctx),
+	asn_MAP_Abort_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_Abort = {
+	"Abort",
+	"Abort",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Abort_tags_1,
+	sizeof(asn_DEF_Abort_tags_1)
+		/sizeof(asn_DEF_Abort_tags_1[0]), /* 1 */
+	asn_DEF_Abort_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Abort_tags_1)
+		/sizeof(asn_DEF_Abort_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Abort_1,
+	2,	/* Elements count */
+	&asn_SPC_Abort_specs_1	/* Additional specs */
+};
+

asn1-compiled/Abort.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_Abort_H_
+#define	_Abort_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "DestTransactionID.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct Reason;
+
+/* Abort */
+typedef struct Abort {
+	DestTransactionID_t	 dtid;
+	struct Reason	*reason	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Abort_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Abort;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "Reason.h"
+
+#endif	/* _Abort_H_ */
+#include <asn_internal.h>

asn1-compiled/AdditionalATMCellRate.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "AdditionalATMCellRate.h"
+
+int
+AdditionalATMCellRate_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+AdditionalATMCellRate_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+AdditionalATMCellRate_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	AdditionalATMCellRate_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+AdditionalATMCellRate_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	AdditionalATMCellRate_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+AdditionalATMCellRate_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	AdditionalATMCellRate_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+AdditionalATMCellRate_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AdditionalATMCellRate_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+AdditionalATMCellRate_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	AdditionalATMCellRate_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+AdditionalATMCellRate_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AdditionalATMCellRate_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_AdditionalATMCellRate_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_AdditionalATMCellRate = {
+	"AdditionalATMCellRate",
+	"AdditionalATMCellRate",
+	AdditionalATMCellRate_free,
+	AdditionalATMCellRate_print,
+	AdditionalATMCellRate_constraint,
+	AdditionalATMCellRate_decode_ber,
+	AdditionalATMCellRate_encode_der,
+	AdditionalATMCellRate_decode_xer,
+	AdditionalATMCellRate_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AdditionalATMCellRate_tags_1,
+	sizeof(asn_DEF_AdditionalATMCellRate_tags_1)
+		/sizeof(asn_DEF_AdditionalATMCellRate_tags_1[0]), /* 1 */
+	asn_DEF_AdditionalATMCellRate_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AdditionalATMCellRate_tags_1)
+		/sizeof(asn_DEF_AdditionalATMCellRate_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/AdditionalATMCellRate.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_AdditionalATMCellRate_H_
+#define	_AdditionalATMCellRate_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AdditionalATMCellRate */
+typedef OCTET_STRING_t	 AdditionalATMCellRate_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AdditionalATMCellRate;
+asn_struct_free_f AdditionalATMCellRate_free;
+asn_struct_print_f AdditionalATMCellRate_print;
+asn_constr_check_f AdditionalATMCellRate_constraint;
+ber_type_decoder_f AdditionalATMCellRate_decode_ber;
+der_type_encoder_f AdditionalATMCellRate_encode_der;
+xer_type_decoder_f AdditionalATMCellRate_decode_xer;
+xer_type_encoder_f AdditionalATMCellRate_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AdditionalATMCellRate_H_ */
+#include <asn_internal.h>

asn1-compiled/AdditionalCallingPartyNumber.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "AdditionalCallingPartyNumber.h"
+
+int
+AdditionalCallingPartyNumber_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const Digits_t *st = (const Digits_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 2 && size <= 16)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using Digits,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+AdditionalCallingPartyNumber_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_Digits.free_struct;
+	td->print_struct   = asn_DEF_Digits.print_struct;
+	td->ber_decoder    = asn_DEF_Digits.ber_decoder;
+	td->der_encoder    = asn_DEF_Digits.der_encoder;
+	td->xer_decoder    = asn_DEF_Digits.xer_decoder;
+	td->xer_encoder    = asn_DEF_Digits.xer_encoder;
+	td->uper_decoder   = asn_DEF_Digits.uper_decoder;
+	td->uper_encoder   = asn_DEF_Digits.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_Digits.per_constraints;
+	td->elements       = asn_DEF_Digits.elements;
+	td->elements_count = asn_DEF_Digits.elements_count;
+	td->specifics      = asn_DEF_Digits.specifics;
+}
+
+void
+AdditionalCallingPartyNumber_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	AdditionalCallingPartyNumber_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+AdditionalCallingPartyNumber_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	AdditionalCallingPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+AdditionalCallingPartyNumber_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	AdditionalCallingPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+AdditionalCallingPartyNumber_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AdditionalCallingPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+AdditionalCallingPartyNumber_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	AdditionalCallingPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+AdditionalCallingPartyNumber_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AdditionalCallingPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_AdditionalCallingPartyNumber_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_AdditionalCallingPartyNumber = {
+	"AdditionalCallingPartyNumber",
+	"AdditionalCallingPartyNumber",
+	AdditionalCallingPartyNumber_free,
+	AdditionalCallingPartyNumber_print,
+	AdditionalCallingPartyNumber_constraint,
+	AdditionalCallingPartyNumber_decode_ber,
+	AdditionalCallingPartyNumber_encode_der,
+	AdditionalCallingPartyNumber_decode_xer,
+	AdditionalCallingPartyNumber_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AdditionalCallingPartyNumber_tags_1,
+	sizeof(asn_DEF_AdditionalCallingPartyNumber_tags_1)
+		/sizeof(asn_DEF_AdditionalCallingPartyNumber_tags_1[0]), /* 1 */
+	asn_DEF_AdditionalCallingPartyNumber_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AdditionalCallingPartyNumber_tags_1)
+		/sizeof(asn_DEF_AdditionalCallingPartyNumber_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/AdditionalCallingPartyNumber.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_AdditionalCallingPartyNumber_H_
+#define	_AdditionalCallingPartyNumber_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "Digits.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AdditionalCallingPartyNumber */
+typedef Digits_t	 AdditionalCallingPartyNumber_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AdditionalCallingPartyNumber;
+asn_struct_free_f AdditionalCallingPartyNumber_free;
+asn_struct_print_f AdditionalCallingPartyNumber_print;
+asn_constr_check_f AdditionalCallingPartyNumber_constraint;
+ber_type_decoder_f AdditionalCallingPartyNumber_decode_ber;
+der_type_encoder_f AdditionalCallingPartyNumber_encode_der;
+xer_type_decoder_f AdditionalCallingPartyNumber_decode_xer;
+xer_type_encoder_f AdditionalCallingPartyNumber_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AdditionalCallingPartyNumber_H_ */
+#include <asn_internal.h>

asn1-compiled/AlertingPattern.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "AlertingPattern.h"
+
+int
+AlertingPattern_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 3)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+AlertingPattern_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+AlertingPattern_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	AlertingPattern_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+AlertingPattern_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	AlertingPattern_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+AlertingPattern_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	AlertingPattern_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+AlertingPattern_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AlertingPattern_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+AlertingPattern_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	AlertingPattern_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+AlertingPattern_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AlertingPattern_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_AlertingPattern_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_AlertingPattern = {
+	"AlertingPattern",
+	"AlertingPattern",
+	AlertingPattern_free,
+	AlertingPattern_print,
+	AlertingPattern_constraint,
+	AlertingPattern_decode_ber,
+	AlertingPattern_encode_der,
+	AlertingPattern_decode_xer,
+	AlertingPattern_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AlertingPattern_tags_1,
+	sizeof(asn_DEF_AlertingPattern_tags_1)
+		/sizeof(asn_DEF_AlertingPattern_tags_1[0]), /* 1 */
+	asn_DEF_AlertingPattern_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AlertingPattern_tags_1)
+		/sizeof(asn_DEF_AlertingPattern_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/AlertingPattern.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_AlertingPattern_H_
+#define	_AlertingPattern_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AlertingPattern */
+typedef OCTET_STRING_t	 AlertingPattern_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AlertingPattern;
+asn_struct_free_f AlertingPattern_free;
+asn_struct_print_f AlertingPattern_print;
+asn_constr_check_f AlertingPattern_constraint;
+ber_type_decoder_f AlertingPattern_decode_ber;
+der_type_encoder_f AlertingPattern_encode_der;
+xer_type_decoder_f AlertingPattern_decode_xer;
+xer_type_encoder_f AlertingPattern_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AlertingPattern_H_ */
+#include <asn_internal.h>

asn1-compiled/AlternativeATMTrafficDescriptor.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "AlternativeATMTrafficDescriptor.h"
+
+int
+AlternativeATMTrafficDescriptor_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+AlternativeATMTrafficDescriptor_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+AlternativeATMTrafficDescriptor_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	AlternativeATMTrafficDescriptor_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+AlternativeATMTrafficDescriptor_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	AlternativeATMTrafficDescriptor_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+AlternativeATMTrafficDescriptor_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	AlternativeATMTrafficDescriptor_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+AlternativeATMTrafficDescriptor_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AlternativeATMTrafficDescriptor_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+AlternativeATMTrafficDescriptor_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	AlternativeATMTrafficDescriptor_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+AlternativeATMTrafficDescriptor_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	AlternativeATMTrafficDescriptor_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_AlternativeATMTrafficDescriptor_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_AlternativeATMTrafficDescriptor = {
+	"AlternativeATMTrafficDescriptor",
+	"AlternativeATMTrafficDescriptor",
+	AlternativeATMTrafficDescriptor_free,
+	AlternativeATMTrafficDescriptor_print,
+	AlternativeATMTrafficDescriptor_constraint,
+	AlternativeATMTrafficDescriptor_decode_ber,
+	AlternativeATMTrafficDescriptor_encode_der,
+	AlternativeATMTrafficDescriptor_decode_xer,
+	AlternativeATMTrafficDescriptor_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AlternativeATMTrafficDescriptor_tags_1,
+	sizeof(asn_DEF_AlternativeATMTrafficDescriptor_tags_1)
+		/sizeof(asn_DEF_AlternativeATMTrafficDescriptor_tags_1[0]), /* 1 */
+	asn_DEF_AlternativeATMTrafficDescriptor_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AlternativeATMTrafficDescriptor_tags_1)
+		/sizeof(asn_DEF_AlternativeATMTrafficDescriptor_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/AlternativeATMTrafficDescriptor.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_AlternativeATMTrafficDescriptor_H_
+#define	_AlternativeATMTrafficDescriptor_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* AlternativeATMTrafficDescriptor */
+typedef OCTET_STRING_t	 AlternativeATMTrafficDescriptor_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AlternativeATMTrafficDescriptor;
+asn_struct_free_f AlternativeATMTrafficDescriptor_free;
+asn_struct_print_f AlternativeATMTrafficDescriptor_print;
+asn_constr_check_f AlternativeATMTrafficDescriptor_constraint;
+ber_type_decoder_f AlternativeATMTrafficDescriptor_decode_ber;
+der_type_encoder_f AlternativeATMTrafficDescriptor_encode_der;
+xer_type_decoder_f AlternativeATMTrafficDescriptor_decode_xer;
+xer_type_encoder_f AlternativeATMTrafficDescriptor_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AlternativeATMTrafficDescriptor_H_ */
+#include <asn_internal.h>

asn1-compiled/AlternativeIdentities.c

@@ -0,0 +1,51 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "AlternativeIdentities.h"
+
+static asn_TYPE_member_t asn_MBR_AlternativeIdentities_1[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_AlternativeIdentity,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		""
+		},
+};
+static ber_tlv_tag_t asn_DEF_AlternativeIdentities_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_AlternativeIdentities_specs_1 = {
+	sizeof(struct AlternativeIdentities),
+	offsetof(struct AlternativeIdentities, _asn_ctx),
+	2,	/* XER encoding is XMLValueList */
+};
+asn_TYPE_descriptor_t asn_DEF_AlternativeIdentities = {
+	"AlternativeIdentities",
+	"AlternativeIdentities",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_AlternativeIdentities_tags_1,
+	sizeof(asn_DEF_AlternativeIdentities_tags_1)
+		/sizeof(asn_DEF_AlternativeIdentities_tags_1[0]), /* 1 */
+	asn_DEF_AlternativeIdentities_tags_1,	/* Same as above */
+	sizeof(asn_DEF_AlternativeIdentities_tags_1)
+		/sizeof(asn_DEF_AlternativeIdentities_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_AlternativeIdentities_1,
+	1,	/* Single element */
+	&asn_SPC_AlternativeIdentities_specs_1	/* Additional specs */
+};
+

asn1-compiled/AlternativeIdentities.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_AlternativeIdentities_H_
+#define	_AlternativeIdentities_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct AlternativeIdentity;
+
+/* AlternativeIdentities */
+typedef struct AlternativeIdentities {
+	A_SEQUENCE_OF(struct AlternativeIdentity) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AlternativeIdentities_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AlternativeIdentities;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "AlternativeIdentity.h"
+
+#endif	/* _AlternativeIdentities_H_ */
+#include <asn_internal.h>

asn1-compiled/AlternativeIdentity.c

@@ -0,0 +1,94 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "AlternativeIdentity.h"
+
+static int check_permitted_alphabet_2(const void *sptr) {
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!(cv <= 127)) return -1;
+	}
+	return 0;
+}
+
+static int
+memb_url_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 512)
+		 && !check_permitted_alphabet_2(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_TYPE_member_t asn_MBR_AlternativeIdentity_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct AlternativeIdentity, choice.url),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_IA5String,
+		memb_url_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"url"
+		},
+};
+static asn_TYPE_tag2member_t asn_MAP_AlternativeIdentity_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* url at 526 */
+};
+static asn_CHOICE_specifics_t asn_SPC_AlternativeIdentity_specs_1 = {
+	sizeof(struct AlternativeIdentity),
+	offsetof(struct AlternativeIdentity, _asn_ctx),
+	offsetof(struct AlternativeIdentity, present),
+	sizeof(((struct AlternativeIdentity *)0)->present),
+	asn_MAP_AlternativeIdentity_tag2el_1,
+	1,	/* Count of tags in the map */
+	0,
+	-1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_AlternativeIdentity = {
+	"AlternativeIdentity",
+	"AlternativeIdentity",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
+	asn_MBR_AlternativeIdentity_1,
+	1,	/* Elements count */
+	&asn_SPC_AlternativeIdentity_specs_1	/* Additional specs */
+};
+

asn1-compiled/AlternativeIdentity.h

@@ -0,0 +1,46 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_AlternativeIdentity_H_
+#define	_AlternativeIdentity_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <IA5String.h>
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum AlternativeIdentity_PR {
+	AlternativeIdentity_PR_NOTHING,	/* No components present */
+	AlternativeIdentity_PR_url
+} AlternativeIdentity_PR;
+
+/* AlternativeIdentity */
+typedef struct AlternativeIdentity {
+	AlternativeIdentity_PR present;
+	union AlternativeIdentity_u {
+		IA5String_t	 url;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} AlternativeIdentity_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_AlternativeIdentity;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _AlternativeIdentity_H_ */
+#include <asn_internal.h>

asn1-compiled/Associate-result.c

@@ -0,0 +1,107 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "Associate-result.h"
+
+int
+Associate_result_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_INTEGER.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Associate_result_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_INTEGER.free_struct;
+	td->print_struct   = asn_DEF_INTEGER.print_struct;
+	td->ber_decoder    = asn_DEF_INTEGER.ber_decoder;
+	td->der_encoder    = asn_DEF_INTEGER.der_encoder;
+	td->xer_decoder    = asn_DEF_INTEGER.xer_decoder;
+	td->xer_encoder    = asn_DEF_INTEGER.xer_encoder;
+	td->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	td->uper_encoder   = asn_DEF_INTEGER.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+Associate_result_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Associate_result_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Associate_result_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Associate_result_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Associate_result_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Associate_result_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Associate_result_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Associate_result_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Associate_result_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Associate_result_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Associate_result_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Associate_result_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_Associate_result_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Associate_result = {
+	"Associate-result",
+	"Associate-result",
+	Associate_result_free,
+	Associate_result_print,
+	Associate_result_constraint,
+	Associate_result_decode_ber,
+	Associate_result_encode_der,
+	Associate_result_decode_xer,
+	Associate_result_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Associate_result_tags_1,
+	sizeof(asn_DEF_Associate_result_tags_1)
+		/sizeof(asn_DEF_Associate_result_tags_1[0]), /* 1 */
+	asn_DEF_Associate_result_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Associate_result_tags_1)
+		/sizeof(asn_DEF_Associate_result_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+

asn1-compiled/Associate-result.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_Associate_result_H_
+#define	_Associate_result_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <INTEGER.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum Associate_result {
+	Associate_result_accepted	= 0,
+	Associate_result_reject_permanent	= 1
+} e_Associate_result;
+
+/* Associate-result */
+typedef INTEGER_t	 Associate_result_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Associate_result;
+asn_struct_free_f Associate_result_free;
+asn_struct_print_f Associate_result_print;
+asn_constr_check_f Associate_result_constraint;
+ber_type_decoder_f Associate_result_decode_ber;
+der_type_encoder_f Associate_result_encode_der;
+xer_type_decoder_f Associate_result_decode_xer;
+xer_type_encoder_f Associate_result_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Associate_result_H_ */
+#include <asn_internal.h>

asn1-compiled/Associate-source-diagnostic.c

@@ -0,0 +1,64 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "Associate-source-diagnostic.h"
+
+static asn_TYPE_member_t asn_MBR_Associate_source_diagnostic_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Associate_source_diagnostic, choice.dialogue_service_user),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_INTEGER,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"dialogue-service-user"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Associate_source_diagnostic, choice.dialogue_service_provider),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_INTEGER,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"dialogue-service-provider"
+		},
+};
+static asn_TYPE_tag2member_t asn_MAP_Associate_source_diagnostic_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* dialogue-service-user at 42 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 } /* dialogue-service-provider at 45 */
+};
+static asn_CHOICE_specifics_t asn_SPC_Associate_source_diagnostic_specs_1 = {
+	sizeof(struct Associate_source_diagnostic),
+	offsetof(struct Associate_source_diagnostic, _asn_ctx),
+	offsetof(struct Associate_source_diagnostic, present),
+	sizeof(((struct Associate_source_diagnostic *)0)->present),
+	asn_MAP_Associate_source_diagnostic_tag2el_1,
+	2,	/* Count of tags in the map */
+	0,
+	-1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_Associate_source_diagnostic = {
+	"Associate-source-diagnostic",
+	"Associate-source-diagnostic",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
+	asn_MBR_Associate_source_diagnostic_1,
+	2,	/* Elements count */
+	&asn_SPC_Associate_source_diagnostic_specs_1	/* Additional specs */
+};
+

asn1-compiled/Associate-source-diagnostic.h

@@ -0,0 +1,58 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_Associate_source_diagnostic_H_
+#define	_Associate_source_diagnostic_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <INTEGER.h>
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum Associate_source_diagnostic_PR {
+	Associate_source_diagnostic_PR_NOTHING,	/* No components present */
+	Associate_source_diagnostic_PR_dialogue_service_user,
+	Associate_source_diagnostic_PR_dialogue_service_provider
+} Associate_source_diagnostic_PR;
+typedef enum dialogue_service_user {
+	dialogue_service_user_null	= 0,
+	dialogue_service_user_no_reason_given	= 1,
+	dialogue_service_user_application_context_name_not_supported	= 2
+} e_dialogue_service_user;
+typedef enum dialogue_service_provider {
+	dialogue_service_provider_null	= 0,
+	dialogue_service_provider_no_reason_given	= 1,
+	dialogue_service_provider_no_common_dialogue_portion	= 2
+} e_dialogue_service_provider;
+
+/* Associate-source-diagnostic */
+typedef struct Associate_source_diagnostic {
+	Associate_source_diagnostic_PR present;
+	union Associate_source_diagnostic_u {
+		INTEGER_t	 dialogue_service_user;
+		INTEGER_t	 dialogue_service_provider;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Associate_source_diagnostic_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Associate_source_diagnostic;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Associate_source_diagnostic_H_ */
+#include <asn_internal.h>

asn1-compiled/BISDNParameters.c

@@ -0,0 +1,148 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "BISDNParameters.h"
+
+static asn_TYPE_member_t asn_MBR_BISDNParameters_1[] = {
+	{ ATF_POINTER, 10, offsetof(struct BISDNParameters, aALParameters),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_AALParameters,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"aALParameters"
+		},
+	{ ATF_POINTER, 9, offsetof(struct BISDNParameters, additionalATMCellRate),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_AdditionalATMCellRate,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"additionalATMCellRate"
+		},
+	{ ATF_POINTER, 8, offsetof(struct BISDNParameters, aESACalledParty),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_AESACalledParty,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"aESACalledParty"
+		},
+	{ ATF_POINTER, 7, offsetof(struct BISDNParameters, aESACallingParty),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_AESACallingParty,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"aESACallingParty"
+		},
+	{ ATF_POINTER, 6, offsetof(struct BISDNParameters, alternativeATMTrafficDescriptor),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_AlternativeATMTrafficDescriptor,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"alternativeATMTrafficDescriptor"
+		},
+	{ ATF_POINTER, 5, offsetof(struct BISDNParameters, aTMCellRate),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_ATMCellRate,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"aTMCellRate"
+		},
+	{ ATF_POINTER, 4, offsetof(struct BISDNParameters, cDVTDescriptor),
+		(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_CDVTDescriptor,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"cDVTDescriptor"
+		},
+	{ ATF_POINTER, 3, offsetof(struct BISDNParameters, cumulativeTransitDelay),
+		(ASN_TAG_CLASS_CONTEXT | (7 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_CumulativeTransitDelay,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"cumulativeTransitDelay"
+		},
+	{ ATF_POINTER, 2, offsetof(struct BISDNParameters, endToEndTransitDelay),
+		(ASN_TAG_CLASS_CONTEXT | (8 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_EndToEndTransitDelay,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"endToEndTransitDelay"
+		},
+	{ ATF_POINTER, 1, offsetof(struct BISDNParameters, minAcceptableATMTrafficDescriptor),
+		(ASN_TAG_CLASS_CONTEXT | (9 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_MinAcceptableATMTrafficDescriptor,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"minAcceptableATMTrafficDescriptor"
+		},
+};
+static ber_tlv_tag_t asn_DEF_BISDNParameters_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_BISDNParameters_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* aALParameters at 501 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* additionalATMCellRate at 502 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* aESACalledParty at 503 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* aESACallingParty at 504 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* alternativeATMTrafficDescriptor at 506 */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* aTMCellRate at 507 */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* cDVTDescriptor at 508 */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 }, /* cumulativeTransitDelay at 509 */
+    { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 8, 0, 0 }, /* endToEndTransitDelay at 510 */
+    { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 9, 0, 0 } /* minAcceptableATMTrafficDescriptor at 512 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_BISDNParameters_specs_1 = {
+	sizeof(struct BISDNParameters),
+	offsetof(struct BISDNParameters, _asn_ctx),
+	asn_MAP_BISDNParameters_tag2el_1,
+	10,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	9,	/* Start extensions */
+	11	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_BISDNParameters = {
+	"BISDNParameters",
+	"BISDNParameters",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_BISDNParameters_tags_1,
+	sizeof(asn_DEF_BISDNParameters_tags_1)
+		/sizeof(asn_DEF_BISDNParameters_tags_1[0]), /* 1 */
+	asn_DEF_BISDNParameters_tags_1,	/* Same as above */
+	sizeof(asn_DEF_BISDNParameters_tags_1)
+		/sizeof(asn_DEF_BISDNParameters_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_BISDNParameters_1,
+	10,	/* Elements count */
+	&asn_SPC_BISDNParameters_specs_1	/* Additional specs */
+};
+

asn1-compiled/BISDNParameters.h

@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_BISDNParameters_H_
+#define	_BISDNParameters_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "AALParameters.h"
+#include "AdditionalATMCellRate.h"
+#include "AESACalledParty.h"
+#include "AESACallingParty.h"
+#include "AlternativeATMTrafficDescriptor.h"
+#include "ATMCellRate.h"
+#include "CDVTDescriptor.h"
+#include "CumulativeTransitDelay.h"
+#include "EndToEndTransitDelay.h"
+#include "MinAcceptableATMTrafficDescriptor.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BISDNParameters */
+typedef struct BISDNParameters {
+	AALParameters_t	*aALParameters	/* OPTIONAL */;
+	AdditionalATMCellRate_t	*additionalATMCellRate	/* OPTIONAL */;
+	AESACalledParty_t	*aESACalledParty	/* OPTIONAL */;
+	AESACallingParty_t	*aESACallingParty	/* OPTIONAL */;
+	AlternativeATMTrafficDescriptor_t	*alternativeATMTrafficDescriptor	/* OPTIONAL */;
+	ATMCellRate_t	*aTMCellRate	/* OPTIONAL */;
+	CDVTDescriptor_t	*cDVTDescriptor	/* OPTIONAL */;
+	CumulativeTransitDelay_t	*cumulativeTransitDelay	/* OPTIONAL */;
+	EndToEndTransitDelay_t	*endToEndTransitDelay	/* OPTIONAL */;
+	MinAcceptableATMTrafficDescriptor_t	*minAcceptableATMTrafficDescriptor	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} BISDNParameters_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BISDNParameters;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BISDNParameters_H_ */
+#include <asn_internal.h>

asn1-compiled/BIT_STRING.c

@@ -0,0 +1,189 @@
+/*-
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <BIT_STRING.h>
+#include <asn_internal.h>
+
+/*
+ * BIT STRING basic type description.
+ */
+static ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+static asn_OCTET_STRING_specifics_t asn_DEF_BIT_STRING_specs = {
+	sizeof(BIT_STRING_t),
+	offsetof(BIT_STRING_t, _asn_ctx),
+	ASN_OSUBV_BIT
+};
+asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {
+	"BIT STRING",
+	"BIT_STRING",
+	OCTET_STRING_free,         /* Implemented in terms of OCTET STRING */
+	BIT_STRING_print,
+	BIT_STRING_constraint,
+	OCTET_STRING_decode_ber,   /* Implemented in terms of OCTET STRING */
+	OCTET_STRING_encode_der,   /* Implemented in terms of OCTET STRING */
+	OCTET_STRING_decode_xer_binary,
+	BIT_STRING_encode_xer,
+	OCTET_STRING_decode_uper,	/* Unaligned PER decoder */
+	OCTET_STRING_encode_uper,	/* Unaligned PER encoder */
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_BIT_STRING_tags,
+	sizeof(asn_DEF_BIT_STRING_tags)
+	  / sizeof(asn_DEF_BIT_STRING_tags[0]),
+	asn_DEF_BIT_STRING_tags,	/* Same as above */
+	sizeof(asn_DEF_BIT_STRING_tags)
+	  / sizeof(asn_DEF_BIT_STRING_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	&asn_DEF_BIT_STRING_specs
+};
+
+/*
+ * BIT STRING generic constraint.
+ */
+int
+BIT_STRING_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+		asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+
+	if(st && st->buf) {
+		if((st->size == 0 && st->bits_unused)
+		|| st->bits_unused < 0 || st->bits_unused > 7) {
+			_ASN_CTFAIL(app_key, td, sptr,
+				"%s: invalid padding byte (%s:%d)",
+				td->name, __FILE__, __LINE__);
+			return -1;
+		}
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+
+	return 0;
+}
+
+static char *_bit_pattern[16] = {
+	"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
+	"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"
+};
+
+asn_enc_rval_t
+BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_enc_rval_t er;
+	char scratch[128];
+	char *p = scratch;
+	char *scend = scratch + (sizeof(scratch) - 10);
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	int xcan = (flags & XER_F_CANONICAL);
+	uint8_t *buf;
+	uint8_t *end;
+
+	if(!st || !st->buf)
+		_ASN_ENCODE_FAILED;
+
+	er.encoded = 0;
+
+	buf = st->buf;
+	end = buf + st->size - 1;	/* Last byte is special */
+
+	/*
+	 * Binary dump
+	 */
+	for(; buf < end; buf++) {
+		int v = *buf;
+		int nline = xcan?0:(((buf - st->buf) % 8) == 0);
+		if(p >= scend || nline) {
+			er.encoded += p - scratch;
+			_ASN_CALLBACK(scratch, p - scratch);
+			p = scratch;
+			if(nline) _i_ASN_TEXT_INDENT(1, ilevel);
+		}
+		memcpy(p + 0, _bit_pattern[v >> 4], 4);
+		memcpy(p + 4, _bit_pattern[v & 0x0f], 4);
+		p += 8;
+	}
+
+	if(!xcan && ((buf - st->buf) % 8) == 0)
+		_i_ASN_TEXT_INDENT(1, ilevel);
+	er.encoded += p - scratch;
+	_ASN_CALLBACK(scratch, p - scratch);
+	p = scratch;
+
+	if(buf == end) {
+		int v = *buf;
+		int ubits = st->bits_unused;
+		int i;
+		for(i = 7; i >= ubits; i--)
+			*p++ = (v & (1 << i)) ? 0x31 : 0x30;
+		er.encoded += p - scratch;
+		_ASN_CALLBACK(scratch, p - scratch);
+	}
+
+	if(!xcan) _i_ASN_TEXT_INDENT(1, ilevel - 1);
+
+	_ASN_ENCODED_OK(er);
+cb_failed:
+	_ASN_ENCODE_FAILED;
+}
+
+
+/*
+ * BIT STRING specific contents printer.
+ */
+int
+BIT_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	static const char *h2c = "0123456789ABCDEF";
+	char scratch[64];
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	uint8_t *buf;
+	uint8_t *end;
+	char *p = scratch;
+
+	(void)td;	/* Unused argument */
+
+	if(!st || !st->buf)
+		return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+
+	ilevel++;
+	buf = st->buf;
+	end = buf + st->size;
+
+	/*
+	 * Hexadecimal dump.
+	 */
+	for(; buf < end; buf++) {
+		if((buf - st->buf) % 16 == 0 && (st->size > 16)
+				&& buf != st->buf) {
+			_i_INDENT(1);
+			/* Dump the string */
+			if(cb(scratch, p - scratch, app_key) < 0) return -1;
+			p = scratch;
+		}
+		*p++ = h2c[*buf >> 4];
+		*p++ = h2c[*buf & 0x0F];
+		*p++ = 0x20;
+	}
+
+	if(p > scratch) {
+		p--;	/* Eat the tailing space */
+
+		if((st->size > 16)) {
+			_i_INDENT(1);
+		}
+
+		/* Dump the incomplete 16-bytes row */
+		if(cb(scratch, p - scratch, app_key) < 0)
+			return -1;
+	}
+
+	return 0;
+}
+

asn1-compiled/BIT_STRING.h

@@ -0,0 +1,33 @@
+/*-
+ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_BIT_STRING_H_
+#define	_BIT_STRING_H_
+
+#include <OCTET_STRING.h>	/* Some help from OCTET STRING */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct BIT_STRING_s {
+	uint8_t *buf;	/* BIT STRING body */
+	int size;	/* Size of the above buffer */
+
+	int bits_unused;/* Unused trailing bits in the last octet (0..7) */
+
+	asn_struct_ctx_t _asn_ctx;	/* Parsing across buffer boundaries */
+} BIT_STRING_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_BIT_STRING;
+
+asn_struct_print_f BIT_STRING_print;	/* Human-readable output */
+asn_constr_check_f BIT_STRING_constraint;
+xer_type_encoder_f BIT_STRING_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BIT_STRING_H_ */

asn1-compiled/BOOLEAN.c

@@ -0,0 +1,282 @@
+/*-
+ * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <asn_codecs_prim.h>
+#include <BOOLEAN.h>
+
+/*
+ * BOOLEAN basic type description.
+ */
+static ber_tlv_tag_t asn_DEF_BOOLEAN_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (1 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_BOOLEAN = {
+	"BOOLEAN",
+	"BOOLEAN",
+	BOOLEAN_free,
+	BOOLEAN_print,
+	asn_generic_no_constraint,
+	BOOLEAN_decode_ber,
+	BOOLEAN_encode_der,
+	BOOLEAN_decode_xer,
+	BOOLEAN_encode_xer,
+	BOOLEAN_decode_uper,	/* Unaligned PER decoder */
+	BOOLEAN_encode_uper,	/* Unaligned PER encoder */
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_BOOLEAN_tags,
+	sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
+	asn_DEF_BOOLEAN_tags,	/* Same as above */
+	sizeof(asn_DEF_BOOLEAN_tags) / sizeof(asn_DEF_BOOLEAN_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+/*
+ * Decode BOOLEAN type.
+ */
+asn_dec_rval_t
+BOOLEAN_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
+		asn_TYPE_descriptor_t *td,
+		void **bool_value, const void *buf_ptr, size_t size,
+		int tag_mode) {
+	BOOLEAN_t *st = (BOOLEAN_t *)*bool_value;
+	asn_dec_rval_t rval;
+	ber_tlv_len_t length;
+	ber_tlv_len_t lidx;
+
+	if(st == NULL) {
+		st = (BOOLEAN_t *)(*bool_value = CALLOC(1, sizeof(*st)));
+		if(st == NULL) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+			return rval;
+		}
+	}
+
+	ASN_DEBUG("Decoding %s as BOOLEAN (tm=%d)",
+		td->name, tag_mode);
+
+	/*
+	 * Check tags.
+	 */
+	rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
+		tag_mode, 0, &length, 0);
+	if(rval.code != RC_OK)
+		return rval;
+
+	ASN_DEBUG("Boolean length is %d bytes", (int)length);
+
+	buf_ptr = ((const char *)buf_ptr) + rval.consumed;
+	size -= rval.consumed;
+	if(length > (ber_tlv_len_t)size) {
+		rval.code = RC_WMORE;
+		rval.consumed = 0;
+		return rval;
+	}
+
+	/*
+	 * Compute boolean value.
+	 */
+	for(*st = 0, lidx = 0;
+		(lidx < length) && *st == 0; lidx++) {
+		/*
+		 * Very simple approach: read bytes until the end or
+		 * value is already TRUE.
+		 * BOOLEAN is not supposed to contain meaningful data anyway.
+		 */
+		*st |= ((const uint8_t *)buf_ptr)[lidx];
+	}
+
+	rval.code = RC_OK;
+	rval.consumed += length;
+
+	ASN_DEBUG("Took %ld/%ld bytes to encode %s, value=%d",
+		(long)rval.consumed, (long)length,
+		td->name, *st);
+	
+	return rval;
+}
+
+asn_enc_rval_t
+BOOLEAN_encode_der(asn_TYPE_descriptor_t *td, void *sptr,
+	int tag_mode, ber_tlv_tag_t tag,
+	asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_enc_rval_t erval;
+	BOOLEAN_t *st = (BOOLEAN_t *)sptr;
+
+	erval.encoded = der_write_tags(td, 1, tag_mode, 0, tag, cb, app_key);
+	if(erval.encoded == -1) {
+		erval.failed_type = td;
+		erval.structure_ptr = sptr;
+		return erval;
+	}
+
+	if(cb) {
+		uint8_t bool_value;
+
+		bool_value = *st ? 0xff : 0; /* 0xff mandated by DER */
+
+		if(cb(&bool_value, 1, app_key) < 0) {
+			erval.encoded = -1;
+			erval.failed_type = td;
+			erval.structure_ptr = sptr;
+			return erval;
+		}
+	}
+
+	erval.encoded += 1;
+
+	_ASN_ENCODED_OK(erval);
+}
+
+
+/*
+ * Decode the chunk of XML text encoding INTEGER.
+ */
+static enum xer_pbd_rval
+BOOLEAN__xer_body_decode(asn_TYPE_descriptor_t *td, void *sptr, const void *chunk_buf, size_t chunk_size) {
+	BOOLEAN_t *st = (BOOLEAN_t *)sptr;
+	const char *p = (const char *)chunk_buf;
+
+	(void)td;
+
+	if(chunk_size && p[0] == 0x3c /* '<' */) {
+		switch(xer_check_tag(chunk_buf, chunk_size, "false")) {
+		case XCT_BOTH:
+			/* "<false/>" */
+			*st = 0;
+			break;
+		case XCT_UNKNOWN_BO:
+			if(xer_check_tag(chunk_buf, chunk_size, "true")
+					!= XCT_BOTH)
+				return XPBD_BROKEN_ENCODING;
+			/* "<true/>" */
+			*st = 1;	/* Or 0xff as in DER?.. */
+			break;
+		default:
+			return XPBD_BROKEN_ENCODING;
+		}
+		return XPBD_BODY_CONSUMED;
+	} else {
+		return XPBD_BROKEN_ENCODING;
+	}
+}
+
+
+asn_dec_rval_t
+BOOLEAN_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
+		const void *buf_ptr, size_t size) {
+
+	return xer_decode_primitive(opt_codec_ctx, td,
+		sptr, sizeof(BOOLEAN_t), opt_mname, buf_ptr, size,
+		BOOLEAN__xer_body_decode);
+}
+
+asn_enc_rval_t
+BOOLEAN_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	asn_enc_rval_t er;
+
+	(void)ilevel;
+	(void)flags;
+
+	if(!st) _ASN_ENCODE_FAILED;
+
+	if(*st) {
+		_ASN_CALLBACK("<true/>", 7);
+		er.encoded = 7;
+	} else {
+		_ASN_CALLBACK("<false/>", 8);
+		er.encoded = 8;
+	}
+
+	_ASN_ENCODED_OK(er);
+cb_failed:
+	_ASN_ENCODE_FAILED;
+}
+
+int
+BOOLEAN_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+	asn_app_consume_bytes_f *cb, void *app_key) {
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	const char *buf;
+	size_t buflen;
+
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
+	if(st) {
+		if(*st) {
+			buf = "TRUE";
+			buflen = 4;
+		} else {
+			buf = "FALSE";
+			buflen = 5;
+		}
+	} else {
+		buf = "<absent>";
+		buflen = 8;
+	}
+
+	return (cb(buf, buflen, app_key) < 0) ? -1 : 0;
+}
+
+void
+BOOLEAN_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
+	if(td && ptr && !contents_only) {
+		FREEMEM(ptr);
+	}
+}
+
+asn_dec_rval_t
+BOOLEAN_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+	asn_dec_rval_t rv;
+	BOOLEAN_t *st = (BOOLEAN_t *)*sptr;
+
+	(void)opt_codec_ctx;
+	(void)constraints;
+
+	if(!st) {
+		st = (BOOLEAN_t *)(*sptr = MALLOC(sizeof(*st)));
+		if(!st) _ASN_DECODE_FAILED;
+	}
+
+	/*
+	 * Extract a single bit
+	 */
+	switch(per_get_few_bits(pd, 1)) {
+	case 1: *st = 1; break;
+	case 0: *st = 0; break;
+	case -1: default: _ASN_DECODE_STARVED;
+	}
+
+	ASN_DEBUG("%s decoded as %s", td->name, *st ? "TRUE" : "FALSE");
+
+	rv.code = RC_OK;
+	rv.consumed = 1;
+	return rv;
+}
+
+
+asn_enc_rval_t
+BOOLEAN_encode_uper(asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+	const BOOLEAN_t *st = (const BOOLEAN_t *)sptr;
+	asn_enc_rval_t er = { 0, 0, 0 };
+
+	(void)constraints;
+
+	if(!st) _ASN_ENCODE_FAILED;
+
+	if(per_put_few_bits(po, *st ? 1 : 0, 1))
+		_ASN_ENCODE_FAILED;
+
+	_ASN_ENCODED_OK(er);
+}

asn1-compiled/BOOLEAN.h

@@ -0,0 +1,36 @@
+/*-
+ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_BOOLEAN_H_
+#define	_BOOLEAN_H_
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * The underlying integer may contain various values, but everything
+ * non-zero is capped to 0xff by the DER encoder. The BER decoder may
+ * yield non-zero values different from 1, beware.
+ */
+typedef int BOOLEAN_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_BOOLEAN;
+
+asn_struct_free_f BOOLEAN_free;
+asn_struct_print_f BOOLEAN_print;
+ber_type_decoder_f BOOLEAN_decode_ber;
+der_type_encoder_f BOOLEAN_encode_der;
+xer_type_decoder_f BOOLEAN_decode_xer;
+xer_type_encoder_f BOOLEAN_encode_xer;
+per_type_decoder_f BOOLEAN_decode_uper;
+per_type_encoder_f BOOLEAN_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BOOLEAN_H_ */

asn1-compiled/BackwardGVNS.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "BackwardGVNS.h"
+
+int
+BackwardGVNS_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+BackwardGVNS_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+BackwardGVNS_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	BackwardGVNS_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+BackwardGVNS_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	BackwardGVNS_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+BackwardGVNS_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	BackwardGVNS_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+BackwardGVNS_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	BackwardGVNS_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+BackwardGVNS_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	BackwardGVNS_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+BackwardGVNS_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	BackwardGVNS_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_BackwardGVNS_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_BackwardGVNS = {
+	"BackwardGVNS",
+	"BackwardGVNS",
+	BackwardGVNS_free,
+	BackwardGVNS_print,
+	BackwardGVNS_constraint,
+	BackwardGVNS_decode_ber,
+	BackwardGVNS_encode_der,
+	BackwardGVNS_decode_xer,
+	BackwardGVNS_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_BackwardGVNS_tags_1,
+	sizeof(asn_DEF_BackwardGVNS_tags_1)
+		/sizeof(asn_DEF_BackwardGVNS_tags_1[0]), /* 1 */
+	asn_DEF_BackwardGVNS_tags_1,	/* Same as above */
+	sizeof(asn_DEF_BackwardGVNS_tags_1)
+		/sizeof(asn_DEF_BackwardGVNS_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/BackwardGVNS.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_BackwardGVNS_H_
+#define	_BackwardGVNS_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BackwardGVNS */
+typedef OCTET_STRING_t	 BackwardGVNS_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BackwardGVNS;
+asn_struct_free_f BackwardGVNS_free;
+asn_struct_print_f BackwardGVNS_print;
+asn_constr_check_f BackwardGVNS_constraint;
+ber_type_decoder_f BackwardGVNS_decode_ber;
+der_type_encoder_f BackwardGVNS_encode_der;
+xer_type_decoder_f BackwardGVNS_decode_xer;
+xer_type_encoder_f BackwardGVNS_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BackwardGVNS_H_ */
+#include <asn_internal.h>

asn1-compiled/BackwardServiceInteractionInd.c

@@ -0,0 +1,192 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "BackwardServiceInteractionInd.h"
+
+static int
+memb_conferenceTreatmentIndicator_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 1)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_callCompletionTreatmentIndicator_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 1)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_holdTreatmentIndicator_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 1)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_ectTreatmentIndicator_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 1)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_TYPE_member_t asn_MBR_BackwardServiceInteractionInd_1[] = {
+	{ ATF_POINTER, 4, offsetof(struct BackwardServiceInteractionInd, conferenceTreatmentIndicator),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_conferenceTreatmentIndicator_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"conferenceTreatmentIndicator"
+		},
+	{ ATF_POINTER, 3, offsetof(struct BackwardServiceInteractionInd, callCompletionTreatmentIndicator),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_callCompletionTreatmentIndicator_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"callCompletionTreatmentIndicator"
+		},
+	{ ATF_POINTER, 2, offsetof(struct BackwardServiceInteractionInd, holdTreatmentIndicator),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_holdTreatmentIndicator_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"holdTreatmentIndicator"
+		},
+	{ ATF_POINTER, 1, offsetof(struct BackwardServiceInteractionInd, ectTreatmentIndicator),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_ectTreatmentIndicator_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"ectTreatmentIndicator"
+		},
+};
+static ber_tlv_tag_t asn_DEF_BackwardServiceInteractionInd_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_BackwardServiceInteractionInd_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* conferenceTreatmentIndicator at 359 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 }, /* callCompletionTreatmentIndicator at 363 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* holdTreatmentIndicator at 367 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 3, 0, 0 } /* ectTreatmentIndicator at 371 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_BackwardServiceInteractionInd_specs_1 = {
+	sizeof(struct BackwardServiceInteractionInd),
+	offsetof(struct BackwardServiceInteractionInd, _asn_ctx),
+	asn_MAP_BackwardServiceInteractionInd_tag2el_1,
+	4,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	3,	/* Start extensions */
+	5	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_BackwardServiceInteractionInd = {
+	"BackwardServiceInteractionInd",
+	"BackwardServiceInteractionInd",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_BackwardServiceInteractionInd_tags_1,
+	sizeof(asn_DEF_BackwardServiceInteractionInd_tags_1)
+		/sizeof(asn_DEF_BackwardServiceInteractionInd_tags_1[0]), /* 1 */
+	asn_DEF_BackwardServiceInteractionInd_tags_1,	/* Same as above */
+	sizeof(asn_DEF_BackwardServiceInteractionInd_tags_1)
+		/sizeof(asn_DEF_BackwardServiceInteractionInd_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_BackwardServiceInteractionInd_1,
+	4,	/* Elements count */
+	&asn_SPC_BackwardServiceInteractionInd_specs_1	/* Additional specs */
+};
+

asn1-compiled/BackwardServiceInteractionInd.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_BackwardServiceInteractionInd_H_
+#define	_BackwardServiceInteractionInd_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BackwardServiceInteractionInd */
+typedef struct BackwardServiceInteractionInd {
+	OCTET_STRING_t	*conferenceTreatmentIndicator	/* OPTIONAL */;
+	OCTET_STRING_t	*callCompletionTreatmentIndicator	/* OPTIONAL */;
+	OCTET_STRING_t	*holdTreatmentIndicator	/* OPTIONAL */;
+	OCTET_STRING_t	*ectTreatmentIndicator	/* OPTIONAL */;
+	/*
+	 * This type is extensible,
+	 * possible extensions are below.
+	 */
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} BackwardServiceInteractionInd_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BackwardServiceInteractionInd;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BackwardServiceInteractionInd_H_ */
+#include <asn_internal.h>

asn1-compiled/BearerCapability.c

@@ -0,0 +1,152 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "BearerCapability.h"
+
+static int
+memb_bearerCap_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 2 && size <= 14)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_tmr_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 1)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_broadbandBearerCap_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 14)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_TYPE_member_t asn_MBR_BearerCapability_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct BearerCapability, choice.bearerCap),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_bearerCap_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"bearerCap"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct BearerCapability, choice.tmr),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_tmr_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"tmr"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct BearerCapability, choice.broadbandBearerCap),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_broadbandBearerCap_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"broadbandBearerCap"
+		},
+};
+static asn_TYPE_tag2member_t asn_MAP_BearerCapability_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* bearerCap at 483 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* tmr at 484 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* broadbandBearerCap at 486 */
+};
+static asn_CHOICE_specifics_t asn_SPC_BearerCapability_specs_1 = {
+	sizeof(struct BearerCapability),
+	offsetof(struct BearerCapability, _asn_ctx),
+	offsetof(struct BearerCapability, present),
+	sizeof(((struct BearerCapability *)0)->present),
+	asn_MAP_BearerCapability_tag2el_1,
+	3,	/* Count of tags in the map */
+	0,
+	-1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_BearerCapability = {
+	"BearerCapability",
+	"BearerCapability",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
+	asn_MBR_BearerCapability_1,
+	3,	/* Elements count */
+	&asn_SPC_BearerCapability_specs_1	/* Additional specs */
+};
+

asn1-compiled/BearerCapability.h

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_BearerCapability_H_
+#define	_BearerCapability_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum BearerCapability_PR {
+	BearerCapability_PR_NOTHING,	/* No components present */
+	BearerCapability_PR_bearerCap,
+	BearerCapability_PR_tmr,
+	BearerCapability_PR_broadbandBearerCap
+} BearerCapability_PR;
+
+/* BearerCapability */
+typedef struct BearerCapability {
+	BearerCapability_PR present;
+	union BearerCapability_u {
+		OCTET_STRING_t	 bearerCap;
+		OCTET_STRING_t	 tmr;
+		OCTET_STRING_t	 broadbandBearerCap;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} BearerCapability_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BearerCapability;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BearerCapability_H_ */
+#include <asn_internal.h>

asn1-compiled/Begin.c

@@ -0,0 +1,78 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "Begin.h"
+
+static asn_TYPE_member_t asn_MBR_Begin_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Begin, otid),
+		(ASN_TAG_CLASS_APPLICATION | (8 << 2)),
+		0,
+		&asn_DEF_OrigTransactionID,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"otid"
+		},
+	{ ATF_POINTER, 2, offsetof(struct Begin, dialoguePortion),
+		(ASN_TAG_CLASS_APPLICATION | (11 << 2)),
+		0,
+		&asn_DEF_DialoguePortion,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"dialoguePortion"
+		},
+	{ ATF_POINTER, 1, offsetof(struct Begin, components),
+		(ASN_TAG_CLASS_APPLICATION | (12 << 2)),
+		0,
+		&asn_DEF_ComponentPortion,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"components"
+		},
+};
+static ber_tlv_tag_t asn_DEF_Begin_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_TYPE_tag2member_t asn_MAP_Begin_tag2el_1[] = {
+    { (ASN_TAG_CLASS_APPLICATION | (8 << 2)), 0, 0, 0 }, /* otid at 67 */
+    { (ASN_TAG_CLASS_APPLICATION | (11 << 2)), 1, 0, 0 }, /* dialoguePortion at 68 */
+    { (ASN_TAG_CLASS_APPLICATION | (12 << 2)), 2, 0, 0 } /* components at 69 */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_Begin_specs_1 = {
+	sizeof(struct Begin),
+	offsetof(struct Begin, _asn_ctx),
+	asn_MAP_Begin_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_Begin = {
+	"Begin",
+	"Begin",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Begin_tags_1,
+	sizeof(asn_DEF_Begin_tags_1)
+		/sizeof(asn_DEF_Begin_tags_1[0]), /* 1 */
+	asn_DEF_Begin_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Begin_tags_1)
+		/sizeof(asn_DEF_Begin_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Begin_1,
+	3,	/* Elements count */
+	&asn_SPC_Begin_specs_1	/* Additional specs */
+};
+

asn1-compiled/Begin.h

@@ -0,0 +1,47 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_Begin_H_
+#define	_Begin_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "OrigTransactionID.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct ExternalPDU;
+struct ComponentPortion;
+
+/* Begin */
+typedef struct Begin {
+	OrigTransactionID_t	 otid;
+	struct ExternalPDU	*dialoguePortion	/* OPTIONAL */;
+	struct ComponentPortion	*components	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Begin_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Begin;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "DialoguePortion.h"
+#include "ComponentPortion.h"
+
+#endif	/* _Begin_H_ */
+#include <asn_internal.h>

asn1-compiled/BothwayThroughConnectionInd.c

@@ -0,0 +1,124 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "BothwayThroughConnectionInd.h"
+
+int
+BothwayThroughConnectionInd_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_ENUMERATED.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+BothwayThroughConnectionInd_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
+	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
+	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	td->uper_encoder   = asn_DEF_ENUMERATED.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+void
+BothwayThroughConnectionInd_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	BothwayThroughConnectionInd_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+BothwayThroughConnectionInd_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	BothwayThroughConnectionInd_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+BothwayThroughConnectionInd_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	BothwayThroughConnectionInd_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+BothwayThroughConnectionInd_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	BothwayThroughConnectionInd_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+BothwayThroughConnectionInd_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	BothwayThroughConnectionInd_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+BothwayThroughConnectionInd_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	BothwayThroughConnectionInd_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static asn_INTEGER_enum_map_t asn_MAP_BothwayThroughConnectionInd_value2enum_1[] = {
+	{ 0,	19,	"bothwayPathRequired" },
+	{ 1,	22,	"bothwayPathNotRequired" }
+};
+static unsigned int asn_MAP_BothwayThroughConnectionInd_enum2value_1[] = {
+	1,	/* bothwayPathNotRequired(1) */
+	0	/* bothwayPathRequired(0) */
+};
+static asn_INTEGER_specifics_t asn_SPC_BothwayThroughConnectionInd_specs_1 = {
+	asn_MAP_BothwayThroughConnectionInd_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_BothwayThroughConnectionInd_enum2value_1,	/* N => "tag"; sorted by N */
+	2,	/* Number of elements in the maps */
+	0,	/* Enumeration is not extensible */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static ber_tlv_tag_t asn_DEF_BothwayThroughConnectionInd_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_BothwayThroughConnectionInd = {
+	"BothwayThroughConnectionInd",
+	"BothwayThroughConnectionInd",
+	BothwayThroughConnectionInd_free,
+	BothwayThroughConnectionInd_print,
+	BothwayThroughConnectionInd_constraint,
+	BothwayThroughConnectionInd_decode_ber,
+	BothwayThroughConnectionInd_encode_der,
+	BothwayThroughConnectionInd_decode_xer,
+	BothwayThroughConnectionInd_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_BothwayThroughConnectionInd_tags_1,
+	sizeof(asn_DEF_BothwayThroughConnectionInd_tags_1)
+		/sizeof(asn_DEF_BothwayThroughConnectionInd_tags_1[0]), /* 1 */
+	asn_DEF_BothwayThroughConnectionInd_tags_1,	/* Same as above */
+	sizeof(asn_DEF_BothwayThroughConnectionInd_tags_1)
+		/sizeof(asn_DEF_BothwayThroughConnectionInd_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_BothwayThroughConnectionInd_specs_1	/* Additional specs */
+};
+

asn1-compiled/BothwayThroughConnectionInd.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_BothwayThroughConnectionInd_H_
+#define	_BothwayThroughConnectionInd_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <ENUMERATED.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum BothwayThroughConnectionInd {
+	BothwayThroughConnectionInd_bothwayPathRequired	= 0,
+	BothwayThroughConnectionInd_bothwayPathNotRequired	= 1
+} e_BothwayThroughConnectionInd;
+
+/* BothwayThroughConnectionInd */
+typedef ENUMERATED_t	 BothwayThroughConnectionInd_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_BothwayThroughConnectionInd;
+asn_struct_free_f BothwayThroughConnectionInd_free;
+asn_struct_print_f BothwayThroughConnectionInd_print;
+asn_constr_check_f BothwayThroughConnectionInd_constraint;
+ber_type_decoder_f BothwayThroughConnectionInd_decode_ber;
+der_type_encoder_f BothwayThroughConnectionInd_encode_der;
+xer_type_decoder_f BothwayThroughConnectionInd_decode_xer;
+xer_type_encoder_f BothwayThroughConnectionInd_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BothwayThroughConnectionInd_H_ */
+#include <asn_internal.h>

asn1-compiled/CCSS.c

@@ -0,0 +1,107 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CCSS.h"
+
+int
+CCSS_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_BOOLEAN.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using BOOLEAN,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CCSS_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_BOOLEAN.free_struct;
+	td->print_struct   = asn_DEF_BOOLEAN.print_struct;
+	td->ber_decoder    = asn_DEF_BOOLEAN.ber_decoder;
+	td->der_encoder    = asn_DEF_BOOLEAN.der_encoder;
+	td->xer_decoder    = asn_DEF_BOOLEAN.xer_decoder;
+	td->xer_encoder    = asn_DEF_BOOLEAN.xer_encoder;
+	td->uper_decoder   = asn_DEF_BOOLEAN.uper_decoder;
+	td->uper_encoder   = asn_DEF_BOOLEAN.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_BOOLEAN.per_constraints;
+	td->elements       = asn_DEF_BOOLEAN.elements;
+	td->elements_count = asn_DEF_BOOLEAN.elements_count;
+	td->specifics      = asn_DEF_BOOLEAN.specifics;
+}
+
+void
+CCSS_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CCSS_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CCSS_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CCSS_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CCSS_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CCSS_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CCSS_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CCSS_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CCSS_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CCSS_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CCSS_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CCSS_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CCSS_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (1 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CCSS = {
+	"CCSS",
+	"CCSS",
+	CCSS_free,
+	CCSS_print,
+	CCSS_constraint,
+	CCSS_decode_ber,
+	CCSS_encode_der,
+	CCSS_decode_xer,
+	CCSS_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CCSS_tags_1,
+	sizeof(asn_DEF_CCSS_tags_1)
+		/sizeof(asn_DEF_CCSS_tags_1[0]), /* 1 */
+	asn_DEF_CCSS_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CCSS_tags_1)
+		/sizeof(asn_DEF_CCSS_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CCSS.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CCSS_H_
+#define	_CCSS_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BOOLEAN.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CCSS */
+typedef BOOLEAN_t	 CCSS_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CCSS;
+asn_struct_free_f CCSS_free;
+asn_struct_print_f CCSS_print;
+asn_constr_check_f CCSS_constraint;
+ber_type_decoder_f CCSS_decode_ber;
+der_type_encoder_f CCSS_encode_der;
+xer_type_decoder_f CCSS_decode_xer;
+xer_type_encoder_f CCSS_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CCSS_H_ */
+#include <asn_internal.h>

asn1-compiled/CDVTDescriptor.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CDVTDescriptor.h"
+
+int
+CDVTDescriptor_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CDVTDescriptor_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+CDVTDescriptor_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CDVTDescriptor_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CDVTDescriptor_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CDVTDescriptor_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CDVTDescriptor_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CDVTDescriptor_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CDVTDescriptor_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CDVTDescriptor_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CDVTDescriptor_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CDVTDescriptor_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CDVTDescriptor_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CDVTDescriptor_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CDVTDescriptor_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CDVTDescriptor = {
+	"CDVTDescriptor",
+	"CDVTDescriptor",
+	CDVTDescriptor_free,
+	CDVTDescriptor_print,
+	CDVTDescriptor_constraint,
+	CDVTDescriptor_decode_ber,
+	CDVTDescriptor_encode_der,
+	CDVTDescriptor_decode_xer,
+	CDVTDescriptor_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CDVTDescriptor_tags_1,
+	sizeof(asn_DEF_CDVTDescriptor_tags_1)
+		/sizeof(asn_DEF_CDVTDescriptor_tags_1[0]), /* 1 */
+	asn_DEF_CDVTDescriptor_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CDVTDescriptor_tags_1)
+		/sizeof(asn_DEF_CDVTDescriptor_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CDVTDescriptor.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CDVTDescriptor_H_
+#define	_CDVTDescriptor_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CDVTDescriptor */
+typedef OCTET_STRING_t	 CDVTDescriptor_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CDVTDescriptor;
+asn_struct_free_f CDVTDescriptor_free;
+asn_struct_print_f CDVTDescriptor_print;
+asn_constr_check_f CDVTDescriptor_constraint;
+ber_type_decoder_f CDVTDescriptor_decode_ber;
+der_type_encoder_f CDVTDescriptor_encode_der;
+xer_type_decoder_f CDVTDescriptor_decode_xer;
+xer_type_encoder_f CDVTDescriptor_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CDVTDescriptor_H_ */
+#include <asn_internal.h>

asn1-compiled/CGEncountered.c

@@ -0,0 +1,126 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CGEncountered.h"
+
+int
+CGEncountered_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_ENUMERATED.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CGEncountered_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
+	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
+	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	td->uper_encoder   = asn_DEF_ENUMERATED.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+void
+CGEncountered_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CGEncountered_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CGEncountered_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CGEncountered_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CGEncountered_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CGEncountered_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CGEncountered_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CGEncountered_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CGEncountered_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CGEncountered_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CGEncountered_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CGEncountered_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static asn_INTEGER_enum_map_t asn_MAP_CGEncountered_value2enum_1[] = {
+	{ 0,	15,	"noCGencountered" },
+	{ 1,	19,	"manualCGencountered" },
+	{ 2,	11,	"sCPOverload" }
+};
+static unsigned int asn_MAP_CGEncountered_enum2value_1[] = {
+	1,	/* manualCGencountered(1) */
+	0,	/* noCGencountered(0) */
+	2	/* sCPOverload(2) */
+};
+static asn_INTEGER_specifics_t asn_SPC_CGEncountered_specs_1 = {
+	asn_MAP_CGEncountered_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_CGEncountered_enum2value_1,	/* N => "tag"; sorted by N */
+	3,	/* Number of elements in the maps */
+	0,	/* Enumeration is not extensible */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static ber_tlv_tag_t asn_DEF_CGEncountered_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CGEncountered = {
+	"CGEncountered",
+	"CGEncountered",
+	CGEncountered_free,
+	CGEncountered_print,
+	CGEncountered_constraint,
+	CGEncountered_decode_ber,
+	CGEncountered_encode_der,
+	CGEncountered_decode_xer,
+	CGEncountered_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CGEncountered_tags_1,
+	sizeof(asn_DEF_CGEncountered_tags_1)
+		/sizeof(asn_DEF_CGEncountered_tags_1[0]), /* 1 */
+	asn_DEF_CGEncountered_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CGEncountered_tags_1)
+		/sizeof(asn_DEF_CGEncountered_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_CGEncountered_specs_1	/* Additional specs */
+};
+

asn1-compiled/CGEncountered.h

@@ -0,0 +1,45 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CGEncountered_H_
+#define	_CGEncountered_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <ENUMERATED.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum CGEncountered {
+	CGEncountered_noCGencountered	= 0,
+	CGEncountered_manualCGencountered	= 1,
+	CGEncountered_sCPOverload	= 2
+} e_CGEncountered;
+
+/* CGEncountered */
+typedef ENUMERATED_t	 CGEncountered_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CGEncountered;
+asn_struct_free_f CGEncountered_free;
+asn_struct_print_f CGEncountered_print;
+asn_constr_check_f CGEncountered_constraint;
+ber_type_decoder_f CGEncountered_decode_ber;
+der_type_encoder_f CGEncountered_encode_der;
+xer_type_decoder_f CGEncountered_decode_xer;
+xer_type_encoder_f CGEncountered_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CGEncountered_H_ */
+#include <asn_internal.h>

asn1-compiled/CNInfo.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CNInfo.h"
+
+int
+CNInfo_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CNInfo_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+CNInfo_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CNInfo_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CNInfo_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CNInfo_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CNInfo_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CNInfo_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CNInfo_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CNInfo_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CNInfo_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CNInfo_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CNInfo_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CNInfo_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CNInfo_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CNInfo = {
+	"CNInfo",
+	"CNInfo",
+	CNInfo_free,
+	CNInfo_print,
+	CNInfo_constraint,
+	CNInfo_decode_ber,
+	CNInfo_encode_der,
+	CNInfo_decode_xer,
+	CNInfo_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CNInfo_tags_1,
+	sizeof(asn_DEF_CNInfo_tags_1)
+		/sizeof(asn_DEF_CNInfo_tags_1[0]), /* 1 */
+	asn_DEF_CNInfo_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CNInfo_tags_1)
+		/sizeof(asn_DEF_CNInfo_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CNInfo.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CNInfo_H_
+#define	_CNInfo_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CNInfo */
+typedef OCTET_STRING_t	 CNInfo_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CNInfo;
+asn_struct_free_f CNInfo_free;
+asn_struct_print_f CNInfo_print;
+asn_constr_check_f CNInfo_constraint;
+ber_type_decoder_f CNInfo_decode_ber;
+der_type_encoder_f CNInfo_encode_der;
+xer_type_decoder_f CNInfo_decode_xer;
+xer_type_encoder_f CNInfo_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CNInfo_H_ */
+#include <asn_internal.h>

asn1-compiled/CSAID.c

@@ -0,0 +1,124 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CSAID.h"
+
+int
+CSAID_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 1 && value <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CSAID_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+CSAID_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CSAID_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CSAID_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CSAID_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CSAID_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CSAID_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CSAID_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CSAID_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CSAID_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CSAID_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CSAID_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CSAID_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CSAID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CSAID = {
+	"CSAID",
+	"CSAID",
+	CSAID_free,
+	CSAID_print,
+	CSAID_constraint,
+	CSAID_decode_ber,
+	CSAID_encode_der,
+	CSAID_decode_xer,
+	CSAID_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CSAID_tags_1,
+	sizeof(asn_DEF_CSAID_tags_1)
+		/sizeof(asn_DEF_CSAID_tags_1[0]), /* 1 */
+	asn_DEF_CSAID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CSAID_tags_1)
+		/sizeof(asn_DEF_CSAID_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CSAID.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CSAID_H_
+#define	_CSAID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CSAID */
+typedef long	 CSAID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CSAID;
+asn_struct_free_f CSAID_free;
+asn_struct_print_f CSAID_print;
+asn_constr_check_f CSAID_constraint;
+ber_type_decoder_f CSAID_decode_ber;
+der_type_encoder_f CSAID_encode_der;
+xer_type_decoder_f CSAID_decode_xer;
+xer_type_encoder_f CSAID_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CSAID_H_ */
+#include <asn_internal.h>

asn1-compiled/CUG-Index.c

@@ -0,0 +1,139 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CUG-Index.h"
+
+static int check_permitted_alphabet_1(const void *sptr) {
+	/* The underlying type is IA5String */
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	const uint8_t *ch = st->buf;
+	const uint8_t *end = ch + st->size;
+	
+	for(; ch < end; ch++) {
+		uint8_t cv = *ch;
+		if(!(cv >= 48 && cv <= 57)) return -1;
+	}
+	return 0;
+}
+
+int
+CUG_Index_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const IA5String_t *st = (const IA5String_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 4)
+		 && !check_permitted_alphabet_1(st)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using IA5String,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CUG_Index_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_IA5String.free_struct;
+	td->print_struct   = asn_DEF_IA5String.print_struct;
+	td->ber_decoder    = asn_DEF_IA5String.ber_decoder;
+	td->der_encoder    = asn_DEF_IA5String.der_encoder;
+	td->xer_decoder    = asn_DEF_IA5String.xer_decoder;
+	td->xer_encoder    = asn_DEF_IA5String.xer_encoder;
+	td->uper_decoder   = asn_DEF_IA5String.uper_decoder;
+	td->uper_encoder   = asn_DEF_IA5String.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_IA5String.per_constraints;
+	td->elements       = asn_DEF_IA5String.elements;
+	td->elements_count = asn_DEF_IA5String.elements_count;
+	td->specifics      = asn_DEF_IA5String.specifics;
+}
+
+void
+CUG_Index_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CUG_Index_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CUG_Index_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CUG_Index_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CUG_Index_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CUG_Index_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CUG_Index_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CUG_Index_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CUG_Index_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CUG_Index_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CUG_Index_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CUG_Index_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CUG_Index_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CUG_Index = {
+	"CUG-Index",
+	"CUG-Index",
+	CUG_Index_free,
+	CUG_Index_print,
+	CUG_Index_constraint,
+	CUG_Index_decode_ber,
+	CUG_Index_encode_der,
+	CUG_Index_decode_xer,
+	CUG_Index_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CUG_Index_tags_1,
+	sizeof(asn_DEF_CUG_Index_tags_1)
+		/sizeof(asn_DEF_CUG_Index_tags_1[0]), /* 1 */
+	asn_DEF_CUG_Index_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CUG_Index_tags_1)
+		/sizeof(asn_DEF_CUG_Index_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CUG-Index.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CUG_Index_H_
+#define	_CUG_Index_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <IA5String.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CUG-Index */
+typedef IA5String_t	 CUG_Index_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CUG_Index;
+asn_struct_free_f CUG_Index_free;
+asn_struct_print_f CUG_Index_print;
+asn_constr_check_f CUG_Index_constraint;
+ber_type_decoder_f CUG_Index_decode_ber;
+der_type_encoder_f CUG_Index_encode_der;
+xer_type_decoder_f CUG_Index_decode_xer;
+xer_type_encoder_f CUG_Index_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CUG_Index_H_ */
+#include <asn_internal.h>

asn1-compiled/CUG-Interlock.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CUG-Interlock.h"
+
+int
+CUG_Interlock_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 4)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CUG_Interlock_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+CUG_Interlock_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CUG_Interlock_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CUG_Interlock_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CUG_Interlock_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CUG_Interlock_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CUG_Interlock_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CUG_Interlock_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CUG_Interlock_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CUG_Interlock_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CUG_Interlock_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CUG_Interlock_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CUG_Interlock_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CUG_Interlock_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CUG_Interlock = {
+	"CUG-Interlock",
+	"CUG-Interlock",
+	CUG_Interlock_free,
+	CUG_Interlock_print,
+	CUG_Interlock_constraint,
+	CUG_Interlock_decode_ber,
+	CUG_Interlock_encode_der,
+	CUG_Interlock_decode_xer,
+	CUG_Interlock_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CUG_Interlock_tags_1,
+	sizeof(asn_DEF_CUG_Interlock_tags_1)
+		/sizeof(asn_DEF_CUG_Interlock_tags_1[0]), /* 1 */
+	asn_DEF_CUG_Interlock_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CUG_Interlock_tags_1)
+		/sizeof(asn_DEF_CUG_Interlock_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CUG-Interlock.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CUG_Interlock_H_
+#define	_CUG_Interlock_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CUG-Interlock */
+typedef OCTET_STRING_t	 CUG_Interlock_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CUG_Interlock;
+asn_struct_free_f CUG_Interlock_free;
+asn_struct_print_f CUG_Interlock_print;
+asn_constr_check_f CUG_Interlock_constraint;
+ber_type_decoder_f CUG_Interlock_decode_ber;
+der_type_encoder_f CUG_Interlock_encode_der;
+xer_type_decoder_f CUG_Interlock_decode_xer;
+xer_type_encoder_f CUG_Interlock_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CUG_Interlock_H_ */
+#include <asn_internal.h>

asn1-compiled/CallReference.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CallReference.h"
+
+int
+CallReference_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 1 && size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CallReference_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+CallReference_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CallReference_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CallReference_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CallReference_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CallReference_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CallReference_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CallReference_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallReference_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CallReference_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CallReference_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CallReference_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallReference_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CallReference_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CallReference = {
+	"CallReference",
+	"CallReference",
+	CallReference_free,
+	CallReference_print,
+	CallReference_constraint,
+	CallReference_decode_ber,
+	CallReference_encode_der,
+	CallReference_decode_xer,
+	CallReference_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CallReference_tags_1,
+	sizeof(asn_DEF_CallReference_tags_1)
+		/sizeof(asn_DEF_CallReference_tags_1[0]), /* 1 */
+	asn_DEF_CallReference_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CallReference_tags_1)
+		/sizeof(asn_DEF_CallReference_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CallReference.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CallReference_H_
+#define	_CallReference_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CallReference */
+typedef OCTET_STRING_t	 CallReference_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CallReference;
+asn_struct_free_f CallReference_free;
+asn_struct_print_f CallReference_print;
+asn_constr_check_f CallReference_constraint;
+ber_type_decoder_f CallReference_decode_ber;
+der_type_encoder_f CallReference_encode_der;
+xer_type_decoder_f CallReference_decode_xer;
+xer_type_encoder_f CallReference_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CallReference_H_ */
+#include <asn_internal.h>

asn1-compiled/CallSegmentID.c

@@ -0,0 +1,124 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CallSegmentID.h"
+
+int
+CallSegmentID_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	long value;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	value = *(const long *)sptr;
+	
+	if((value >= 1 && value <= 127)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CallSegmentID_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+	td->specifics      = asn_DEF_NativeInteger.specifics;
+}
+
+void
+CallSegmentID_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CallSegmentID_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CallSegmentID_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CallSegmentID_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CallSegmentID_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CallSegmentID_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CallSegmentID_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallSegmentID_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CallSegmentID_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CallSegmentID_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CallSegmentID_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallSegmentID_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CallSegmentID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CallSegmentID = {
+	"CallSegmentID",
+	"CallSegmentID",
+	CallSegmentID_free,
+	CallSegmentID_print,
+	CallSegmentID_constraint,
+	CallSegmentID_decode_ber,
+	CallSegmentID_encode_der,
+	CallSegmentID_decode_xer,
+	CallSegmentID_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CallSegmentID_tags_1,
+	sizeof(asn_DEF_CallSegmentID_tags_1)
+		/sizeof(asn_DEF_CallSegmentID_tags_1[0]), /* 1 */
+	asn_DEF_CallSegmentID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CallSegmentID_tags_1)
+		/sizeof(asn_DEF_CallSegmentID_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CallSegmentID.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CallSegmentID_H_
+#define	_CallSegmentID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CallSegmentID */
+typedef long	 CallSegmentID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CallSegmentID;
+asn_struct_free_f CallSegmentID_free;
+asn_struct_print_f CallSegmentID_print;
+asn_constr_check_f CallSegmentID_constraint;
+ber_type_decoder_f CallSegmentID_decode_ber;
+der_type_encoder_f CallSegmentID_encode_der;
+xer_type_decoder_f CallSegmentID_decode_xer;
+xer_type_encoder_f CallSegmentID_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CallSegmentID_H_ */
+#include <asn_internal.h>

asn1-compiled/CalledDirectoryNumber.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CalledDirectoryNumber.h"
+
+int
+CalledDirectoryNumber_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 2 && size <= 14)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CalledDirectoryNumber_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+CalledDirectoryNumber_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CalledDirectoryNumber_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CalledDirectoryNumber_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CalledDirectoryNumber_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CalledDirectoryNumber_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CalledDirectoryNumber_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CalledDirectoryNumber_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CalledDirectoryNumber_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CalledDirectoryNumber_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CalledDirectoryNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CalledDirectoryNumber_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CalledDirectoryNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CalledDirectoryNumber_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CalledDirectoryNumber = {
+	"CalledDirectoryNumber",
+	"CalledDirectoryNumber",
+	CalledDirectoryNumber_free,
+	CalledDirectoryNumber_print,
+	CalledDirectoryNumber_constraint,
+	CalledDirectoryNumber_decode_ber,
+	CalledDirectoryNumber_encode_der,
+	CalledDirectoryNumber_decode_xer,
+	CalledDirectoryNumber_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CalledDirectoryNumber_tags_1,
+	sizeof(asn_DEF_CalledDirectoryNumber_tags_1)
+		/sizeof(asn_DEF_CalledDirectoryNumber_tags_1[0]), /* 1 */
+	asn_DEF_CalledDirectoryNumber_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CalledDirectoryNumber_tags_1)
+		/sizeof(asn_DEF_CalledDirectoryNumber_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CalledDirectoryNumber.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CalledDirectoryNumber_H_
+#define	_CalledDirectoryNumber_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CalledDirectoryNumber */
+typedef OCTET_STRING_t	 CalledDirectoryNumber_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CalledDirectoryNumber;
+asn_struct_free_f CalledDirectoryNumber_free;
+asn_struct_print_f CalledDirectoryNumber_print;
+asn_constr_check_f CalledDirectoryNumber_constraint;
+ber_type_decoder_f CalledDirectoryNumber_decode_ber;
+der_type_encoder_f CalledDirectoryNumber_encode_der;
+xer_type_decoder_f CalledDirectoryNumber_decode_xer;
+xer_type_encoder_f CalledDirectoryNumber_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CalledDirectoryNumber_H_ */
+#include <asn_internal.h>

asn1-compiled/CalledPartyNumber.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CalledPartyNumber.h"
+
+int
+CalledPartyNumber_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 2 && size <= 18)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CalledPartyNumber_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+CalledPartyNumber_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CalledPartyNumber_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CalledPartyNumber_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CalledPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CalledPartyNumber_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CalledPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CalledPartyNumber_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CalledPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CalledPartyNumber_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CalledPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CalledPartyNumber_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CalledPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CalledPartyNumber_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CalledPartyNumber = {
+	"CalledPartyNumber",
+	"CalledPartyNumber",
+	CalledPartyNumber_free,
+	CalledPartyNumber_print,
+	CalledPartyNumber_constraint,
+	CalledPartyNumber_decode_ber,
+	CalledPartyNumber_encode_der,
+	CalledPartyNumber_decode_xer,
+	CalledPartyNumber_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CalledPartyNumber_tags_1,
+	sizeof(asn_DEF_CalledPartyNumber_tags_1)
+		/sizeof(asn_DEF_CalledPartyNumber_tags_1[0]), /* 1 */
+	asn_DEF_CalledPartyNumber_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CalledPartyNumber_tags_1)
+		/sizeof(asn_DEF_CalledPartyNumber_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CalledPartyNumber.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CalledPartyNumber_H_
+#define	_CalledPartyNumber_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CalledPartyNumber */
+typedef OCTET_STRING_t	 CalledPartyNumber_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CalledPartyNumber;
+asn_struct_free_f CalledPartyNumber_free;
+asn_struct_print_f CalledPartyNumber_print;
+asn_constr_check_f CalledPartyNumber_constraint;
+ber_type_decoder_f CalledPartyNumber_decode_ber;
+der_type_encoder_f CalledPartyNumber_encode_der;
+xer_type_decoder_f CalledPartyNumber_decode_xer;
+xer_type_encoder_f CalledPartyNumber_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CalledPartyNumber_H_ */
+#include <asn_internal.h>

asn1-compiled/CalledPartySubaddress.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CalledPartySubaddress.h"
+
+int
+CalledPartySubaddress_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CalledPartySubaddress_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+CalledPartySubaddress_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CalledPartySubaddress_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CalledPartySubaddress_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CalledPartySubaddress_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CalledPartySubaddress_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CalledPartySubaddress_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CalledPartySubaddress_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CalledPartySubaddress_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CalledPartySubaddress_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CalledPartySubaddress_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CalledPartySubaddress_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CalledPartySubaddress_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CalledPartySubaddress_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CalledPartySubaddress = {
+	"CalledPartySubaddress",
+	"CalledPartySubaddress",
+	CalledPartySubaddress_free,
+	CalledPartySubaddress_print,
+	CalledPartySubaddress_constraint,
+	CalledPartySubaddress_decode_ber,
+	CalledPartySubaddress_encode_der,
+	CalledPartySubaddress_decode_xer,
+	CalledPartySubaddress_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CalledPartySubaddress_tags_1,
+	sizeof(asn_DEF_CalledPartySubaddress_tags_1)
+		/sizeof(asn_DEF_CalledPartySubaddress_tags_1[0]), /* 1 */
+	asn_DEF_CalledPartySubaddress_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CalledPartySubaddress_tags_1)
+		/sizeof(asn_DEF_CalledPartySubaddress_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CalledPartySubaddress.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CalledPartySubaddress_H_
+#define	_CalledPartySubaddress_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CalledPartySubaddress */
+typedef OCTET_STRING_t	 CalledPartySubaddress_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CalledPartySubaddress;
+asn_struct_free_f CalledPartySubaddress_free;
+asn_struct_print_f CalledPartySubaddress_print;
+asn_constr_check_f CalledPartySubaddress_constraint;
+ber_type_decoder_f CalledPartySubaddress_decode_ber;
+der_type_encoder_f CalledPartySubaddress_encode_der;
+xer_type_decoder_f CalledPartySubaddress_decode_xer;
+xer_type_encoder_f CalledPartySubaddress_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CalledPartySubaddress_H_ */
+#include <asn_internal.h>

asn1-compiled/CallingGeodeticLocation.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CallingGeodeticLocation.h"
+
+int
+CallingGeodeticLocation_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CallingGeodeticLocation_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+CallingGeodeticLocation_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CallingGeodeticLocation_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CallingGeodeticLocation_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingGeodeticLocation_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CallingGeodeticLocation_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CallingGeodeticLocation_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CallingGeodeticLocation_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingGeodeticLocation_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CallingGeodeticLocation_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CallingGeodeticLocation_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CallingGeodeticLocation_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingGeodeticLocation_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CallingGeodeticLocation_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CallingGeodeticLocation = {
+	"CallingGeodeticLocation",
+	"CallingGeodeticLocation",
+	CallingGeodeticLocation_free,
+	CallingGeodeticLocation_print,
+	CallingGeodeticLocation_constraint,
+	CallingGeodeticLocation_decode_ber,
+	CallingGeodeticLocation_encode_der,
+	CallingGeodeticLocation_decode_xer,
+	CallingGeodeticLocation_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CallingGeodeticLocation_tags_1,
+	sizeof(asn_DEF_CallingGeodeticLocation_tags_1)
+		/sizeof(asn_DEF_CallingGeodeticLocation_tags_1[0]), /* 1 */
+	asn_DEF_CallingGeodeticLocation_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CallingGeodeticLocation_tags_1)
+		/sizeof(asn_DEF_CallingGeodeticLocation_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CallingGeodeticLocation.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CallingGeodeticLocation_H_
+#define	_CallingGeodeticLocation_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CallingGeodeticLocation */
+typedef OCTET_STRING_t	 CallingGeodeticLocation_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CallingGeodeticLocation;
+asn_struct_free_f CallingGeodeticLocation_free;
+asn_struct_print_f CallingGeodeticLocation_print;
+asn_constr_check_f CallingGeodeticLocation_constraint;
+ber_type_decoder_f CallingGeodeticLocation_decode_ber;
+der_type_encoder_f CallingGeodeticLocation_encode_der;
+xer_type_decoder_f CallingGeodeticLocation_decode_xer;
+xer_type_encoder_f CallingGeodeticLocation_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CallingGeodeticLocation_H_ */
+#include <asn_internal.h>

asn1-compiled/CallingPartyBusinessGroupID.c

@@ -0,0 +1,107 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CallingPartyBusinessGroupID.h"
+
+int
+CallingPartyBusinessGroupID_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_OCTET_STRING.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CallingPartyBusinessGroupID_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+CallingPartyBusinessGroupID_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CallingPartyBusinessGroupID_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CallingPartyBusinessGroupID_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingPartyBusinessGroupID_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CallingPartyBusinessGroupID_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CallingPartyBusinessGroupID_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CallingPartyBusinessGroupID_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingPartyBusinessGroupID_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CallingPartyBusinessGroupID_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CallingPartyBusinessGroupID_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CallingPartyBusinessGroupID_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingPartyBusinessGroupID_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CallingPartyBusinessGroupID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CallingPartyBusinessGroupID = {
+	"CallingPartyBusinessGroupID",
+	"CallingPartyBusinessGroupID",
+	CallingPartyBusinessGroupID_free,
+	CallingPartyBusinessGroupID_print,
+	CallingPartyBusinessGroupID_constraint,
+	CallingPartyBusinessGroupID_decode_ber,
+	CallingPartyBusinessGroupID_encode_der,
+	CallingPartyBusinessGroupID_decode_xer,
+	CallingPartyBusinessGroupID_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CallingPartyBusinessGroupID_tags_1,
+	sizeof(asn_DEF_CallingPartyBusinessGroupID_tags_1)
+		/sizeof(asn_DEF_CallingPartyBusinessGroupID_tags_1[0]), /* 1 */
+	asn_DEF_CallingPartyBusinessGroupID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CallingPartyBusinessGroupID_tags_1)
+		/sizeof(asn_DEF_CallingPartyBusinessGroupID_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CallingPartyBusinessGroupID.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CallingPartyBusinessGroupID_H_
+#define	_CallingPartyBusinessGroupID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CallingPartyBusinessGroupID */
+typedef OCTET_STRING_t	 CallingPartyBusinessGroupID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CallingPartyBusinessGroupID;
+asn_struct_free_f CallingPartyBusinessGroupID_free;
+asn_struct_print_f CallingPartyBusinessGroupID_print;
+asn_constr_check_f CallingPartyBusinessGroupID_constraint;
+ber_type_decoder_f CallingPartyBusinessGroupID_decode_ber;
+der_type_encoder_f CallingPartyBusinessGroupID_encode_der;
+xer_type_decoder_f CallingPartyBusinessGroupID_decode_xer;
+xer_type_encoder_f CallingPartyBusinessGroupID_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CallingPartyBusinessGroupID_H_ */
+#include <asn_internal.h>

asn1-compiled/CallingPartyNumber.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CallingPartyNumber.h"
+
+int
+CallingPartyNumber_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 2 && size <= 10)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CallingPartyNumber_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+CallingPartyNumber_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CallingPartyNumber_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CallingPartyNumber_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CallingPartyNumber_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CallingPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CallingPartyNumber_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CallingPartyNumber_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CallingPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CallingPartyNumber_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingPartyNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CallingPartyNumber_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CallingPartyNumber = {
+	"CallingPartyNumber",
+	"CallingPartyNumber",
+	CallingPartyNumber_free,
+	CallingPartyNumber_print,
+	CallingPartyNumber_constraint,
+	CallingPartyNumber_decode_ber,
+	CallingPartyNumber_encode_der,
+	CallingPartyNumber_decode_xer,
+	CallingPartyNumber_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CallingPartyNumber_tags_1,
+	sizeof(asn_DEF_CallingPartyNumber_tags_1)
+		/sizeof(asn_DEF_CallingPartyNumber_tags_1[0]), /* 1 */
+	asn_DEF_CallingPartyNumber_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CallingPartyNumber_tags_1)
+		/sizeof(asn_DEF_CallingPartyNumber_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CallingPartyNumber.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CallingPartyNumber_H_
+#define	_CallingPartyNumber_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CallingPartyNumber */
+typedef OCTET_STRING_t	 CallingPartyNumber_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CallingPartyNumber;
+asn_struct_free_f CallingPartyNumber_free;
+asn_struct_print_f CallingPartyNumber_print;
+asn_constr_check_f CallingPartyNumber_constraint;
+ber_type_decoder_f CallingPartyNumber_decode_ber;
+der_type_encoder_f CallingPartyNumber_encode_der;
+xer_type_decoder_f CallingPartyNumber_decode_xer;
+xer_type_encoder_f CallingPartyNumber_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CallingPartyNumber_H_ */
+#include <asn_internal.h>

asn1-compiled/CallingPartySubaddress.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CallingPartySubaddress.h"
+
+int
+CallingPartySubaddress_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 16)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CallingPartySubaddress_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+CallingPartySubaddress_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CallingPartySubaddress_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CallingPartySubaddress_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingPartySubaddress_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CallingPartySubaddress_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CallingPartySubaddress_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CallingPartySubaddress_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingPartySubaddress_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CallingPartySubaddress_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CallingPartySubaddress_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CallingPartySubaddress_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingPartySubaddress_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CallingPartySubaddress_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CallingPartySubaddress = {
+	"CallingPartySubaddress",
+	"CallingPartySubaddress",
+	CallingPartySubaddress_free,
+	CallingPartySubaddress_print,
+	CallingPartySubaddress_constraint,
+	CallingPartySubaddress_decode_ber,
+	CallingPartySubaddress_encode_der,
+	CallingPartySubaddress_decode_xer,
+	CallingPartySubaddress_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CallingPartySubaddress_tags_1,
+	sizeof(asn_DEF_CallingPartySubaddress_tags_1)
+		/sizeof(asn_DEF_CallingPartySubaddress_tags_1[0]), /* 1 */
+	asn_DEF_CallingPartySubaddress_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CallingPartySubaddress_tags_1)
+		/sizeof(asn_DEF_CallingPartySubaddress_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CallingPartySubaddress.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CallingPartySubaddress_H_
+#define	_CallingPartySubaddress_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CallingPartySubaddress */
+typedef OCTET_STRING_t	 CallingPartySubaddress_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CallingPartySubaddress;
+asn_struct_free_f CallingPartySubaddress_free;
+asn_struct_print_f CallingPartySubaddress_print;
+asn_constr_check_f CallingPartySubaddress_constraint;
+ber_type_decoder_f CallingPartySubaddress_decode_ber;
+der_type_encoder_f CallingPartySubaddress_encode_der;
+xer_type_decoder_f CallingPartySubaddress_decode_xer;
+xer_type_encoder_f CallingPartySubaddress_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CallingPartySubaddress_H_ */
+#include <asn_internal.h>

asn1-compiled/CallingPartysCategory.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "CallingPartysCategory.h"
+
+int
+CallingPartysCategory_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 1)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+CallingPartysCategory_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+CallingPartysCategory_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	CallingPartysCategory_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+CallingPartysCategory_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingPartysCategory_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+CallingPartysCategory_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	CallingPartysCategory_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+CallingPartysCategory_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingPartysCategory_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+CallingPartysCategory_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	CallingPartysCategory_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+CallingPartysCategory_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	CallingPartysCategory_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_CallingPartysCategory_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_CallingPartysCategory = {
+	"CallingPartysCategory",
+	"CallingPartysCategory",
+	CallingPartysCategory_free,
+	CallingPartysCategory_print,
+	CallingPartysCategory_constraint,
+	CallingPartysCategory_decode_ber,
+	CallingPartysCategory_encode_der,
+	CallingPartysCategory_decode_xer,
+	CallingPartysCategory_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CallingPartysCategory_tags_1,
+	sizeof(asn_DEF_CallingPartysCategory_tags_1)
+		/sizeof(asn_DEF_CallingPartysCategory_tags_1[0]), /* 1 */
+	asn_DEF_CallingPartysCategory_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CallingPartysCategory_tags_1)
+		/sizeof(asn_DEF_CallingPartysCategory_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/CallingPartysCategory.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_CallingPartysCategory_H_
+#define	_CallingPartysCategory_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CallingPartysCategory */
+typedef OCTET_STRING_t	 CallingPartysCategory_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_CallingPartysCategory;
+asn_struct_free_f CallingPartysCategory_free;
+asn_struct_print_f CallingPartysCategory_print;
+asn_constr_check_f CallingPartysCategory_constraint;
+ber_type_decoder_f CallingPartysCategory_decode_ber;
+der_type_encoder_f CallingPartysCategory_encode_der;
+xer_type_decoder_f CallingPartysCategory_decode_xer;
+xer_type_encoder_f CallingPartysCategory_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CallingPartysCategory_H_ */
+#include <asn_internal.h>

asn1-compiled/Carrier.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "Carrier.h"
+
+int
+Carrier_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 4)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Carrier_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+Carrier_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Carrier_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Carrier_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Carrier_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Carrier_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Carrier_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Carrier_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Carrier_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Carrier_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Carrier_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Carrier_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Carrier_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_Carrier_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Carrier = {
+	"Carrier",
+	"Carrier",
+	Carrier_free,
+	Carrier_print,
+	Carrier_constraint,
+	Carrier_decode_ber,
+	Carrier_encode_der,
+	Carrier_decode_xer,
+	Carrier_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Carrier_tags_1,
+	sizeof(asn_DEF_Carrier_tags_1)
+		/sizeof(asn_DEF_Carrier_tags_1[0]), /* 1 */
+	asn_DEF_Carrier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Carrier_tags_1)
+		/sizeof(asn_DEF_Carrier_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/Carrier.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_Carrier_H_
+#define	_Carrier_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Carrier */
+typedef OCTET_STRING_t	 Carrier_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Carrier;
+asn_struct_free_f Carrier_free;
+asn_struct_print_f Carrier_print;
+asn_constr_check_f Carrier_constraint;
+ber_type_decoder_f Carrier_decode_ber;
+der_type_encoder_f Carrier_encode_der;
+xer_type_decoder_f Carrier_decode_xer;
+xer_type_encoder_f Carrier_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Carrier_H_ */
+#include <asn_internal.h>

asn1-compiled/Cause.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "Cause.h"
+
+int
+Cause_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size <= 255)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using OCTET_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+Cause_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_OCTET_STRING.free_struct;
+	td->print_struct   = asn_DEF_OCTET_STRING.print_struct;
+	td->ber_decoder    = asn_DEF_OCTET_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_OCTET_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_OCTET_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_OCTET_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_OCTET_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_OCTET_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_OCTET_STRING.per_constraints;
+	td->elements       = asn_DEF_OCTET_STRING.elements;
+	td->elements_count = asn_DEF_OCTET_STRING.elements_count;
+	td->specifics      = asn_DEF_OCTET_STRING.specifics;
+}
+
+void
+Cause_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	Cause_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+Cause_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	Cause_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+Cause_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	Cause_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+Cause_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Cause_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+Cause_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	Cause_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+Cause_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	Cause_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_Cause_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_Cause = {
+	"Cause",
+	"Cause",
+	Cause_free,
+	Cause_print,
+	Cause_constraint,
+	Cause_decode_ber,
+	Cause_encode_der,
+	Cause_decode_xer,
+	Cause_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Cause_tags_1,
+	sizeof(asn_DEF_Cause_tags_1)
+		/sizeof(asn_DEF_Cause_tags_1[0]), /* 1 */
+	asn_DEF_Cause_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Cause_tags_1)
+		/sizeof(asn_DEF_Cause_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/Cause.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_Cause_H_
+#define	_Cause_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Cause */
+typedef OCTET_STRING_t	 Cause_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Cause;
+asn_struct_free_f Cause_free;
+asn_struct_print_f Cause_print;
+asn_constr_check_f Cause_constraint;
+ber_type_decoder_f Cause_decode_ber;
+der_type_encoder_f Cause_encode_der;
+xer_type_decoder_f Cause_decode_xer;
+xer_type_encoder_f Cause_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Cause_H_ */
+#include <asn_internal.h>

asn1-compiled/ChargeNumber.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "ChargeNumber.h"
+
+int
+ChargeNumber_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const LocationNumber_t *st = (const LocationNumber_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size >= 2 && size <= 10)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		_ASN_CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+/*
+ * This type is implemented using LocationNumber,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+ChargeNumber_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_LocationNumber.free_struct;
+	td->print_struct   = asn_DEF_LocationNumber.print_struct;
+	td->ber_decoder    = asn_DEF_LocationNumber.ber_decoder;
+	td->der_encoder    = asn_DEF_LocationNumber.der_encoder;
+	td->xer_decoder    = asn_DEF_LocationNumber.xer_decoder;
+	td->xer_encoder    = asn_DEF_LocationNumber.xer_encoder;
+	td->uper_decoder   = asn_DEF_LocationNumber.uper_decoder;
+	td->uper_encoder   = asn_DEF_LocationNumber.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_LocationNumber.per_constraints;
+	td->elements       = asn_DEF_LocationNumber.elements;
+	td->elements_count = asn_DEF_LocationNumber.elements_count;
+	td->specifics      = asn_DEF_LocationNumber.specifics;
+}
+
+void
+ChargeNumber_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	ChargeNumber_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+ChargeNumber_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	ChargeNumber_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+ChargeNumber_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	ChargeNumber_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+ChargeNumber_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ChargeNumber_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+ChargeNumber_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	ChargeNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+ChargeNumber_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ChargeNumber_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_ChargeNumber_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (4 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_ChargeNumber = {
+	"ChargeNumber",
+	"ChargeNumber",
+	ChargeNumber_free,
+	ChargeNumber_print,
+	ChargeNumber_constraint,
+	ChargeNumber_decode_ber,
+	ChargeNumber_encode_der,
+	ChargeNumber_decode_xer,
+	ChargeNumber_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ChargeNumber_tags_1,
+	sizeof(asn_DEF_ChargeNumber_tags_1)
+		/sizeof(asn_DEF_ChargeNumber_tags_1[0]), /* 1 */
+	asn_DEF_ChargeNumber_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ChargeNumber_tags_1)
+		/sizeof(asn_DEF_ChargeNumber_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/ChargeNumber.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_ChargeNumber_H_
+#define	_ChargeNumber_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "LocationNumber.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ChargeNumber */
+typedef LocationNumber_t	 ChargeNumber_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ChargeNumber;
+asn_struct_free_f ChargeNumber_free;
+asn_struct_print_f ChargeNumber_print;
+asn_constr_check_f ChargeNumber_constraint;
+ber_type_decoder_f ChargeNumber_decode_ber;
+der_type_encoder_f ChargeNumber_encode_der;
+xer_type_decoder_f ChargeNumber_decode_xer;
+xer_type_encoder_f ChargeNumber_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ChargeNumber_H_ */
+#include <asn_internal.h>

asn1-compiled/Component.c

@@ -0,0 +1,94 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "Component.h"
+
+static asn_TYPE_member_t asn_MBR_Component_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Component, choice.invoke),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Invoke,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"invoke"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Component, choice.returnResultLast),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ReturnResult,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"returnResultLast"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Component, choice.returnError),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ReturnError,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"returnError"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Component, choice.reject),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Reject,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"reject"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Component, choice.returnResultNotLast),
+		(ASN_TAG_CLASS_CONTEXT | (7 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ReturnResult,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"returnResultNotLast"
+		},
+};
+static asn_TYPE_tag2member_t asn_MAP_Component_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 0 }, /* invoke at 135 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 }, /* returnResultLast at 136 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 2, 0, 0 }, /* returnError at 137 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 3, 0, 0 }, /* reject at 138 */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 4, 0, 0 } /* returnResultNotLast at 140 */
+};
+static asn_CHOICE_specifics_t asn_SPC_Component_specs_1 = {
+	sizeof(struct Component),
+	offsetof(struct Component, _asn_ctx),
+	offsetof(struct Component, present),
+	sizeof(((struct Component *)0)->present),
+	asn_MAP_Component_tag2el_1,
+	5,	/* Count of tags in the map */
+	0,
+	-1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_Component = {
+	"Component",
+	"Component",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
+	asn_MBR_Component_1,
+	5,	/* Elements count */
+	&asn_SPC_Component_specs_1	/* Additional specs */
+};
+

asn1-compiled/Component.h

@@ -0,0 +1,57 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_Component_H_
+#define	_Component_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "Invoke.h"
+#include "ReturnResult.h"
+#include "ReturnError.h"
+#include "Reject.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum Component_PR {
+	Component_PR_NOTHING,	/* No components present */
+	Component_PR_invoke,
+	Component_PR_returnResultLast,
+	Component_PR_returnError,
+	Component_PR_reject,
+	Component_PR_returnResultNotLast
+} Component_PR;
+
+/* Component */
+typedef struct Component {
+	Component_PR present;
+	union Component_u {
+		Invoke_t	 invoke;
+		ReturnResult_t	 returnResultLast;
+		ReturnError_t	 returnError;
+		Reject_t	 reject;
+		ReturnResult_t	 returnResultNotLast;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Component_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Component;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Component_H_ */
+#include <asn_internal.h>

asn1-compiled/ComponentCorrelationID.c

@@ -0,0 +1,107 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "ComponentCorrelationID.h"
+
+int
+ComponentCorrelationID_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_INTEGER.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using INTEGER,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+ComponentCorrelationID_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_INTEGER.free_struct;
+	td->print_struct   = asn_DEF_INTEGER.print_struct;
+	td->ber_decoder    = asn_DEF_INTEGER.ber_decoder;
+	td->der_encoder    = asn_DEF_INTEGER.der_encoder;
+	td->xer_decoder    = asn_DEF_INTEGER.xer_decoder;
+	td->xer_encoder    = asn_DEF_INTEGER.xer_encoder;
+	td->uper_decoder   = asn_DEF_INTEGER.uper_decoder;
+	td->uper_encoder   = asn_DEF_INTEGER.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_INTEGER.per_constraints;
+	td->elements       = asn_DEF_INTEGER.elements;
+	td->elements_count = asn_DEF_INTEGER.elements_count;
+	td->specifics      = asn_DEF_INTEGER.specifics;
+}
+
+void
+ComponentCorrelationID_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	ComponentCorrelationID_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+ComponentCorrelationID_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	ComponentCorrelationID_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+ComponentCorrelationID_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	ComponentCorrelationID_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+ComponentCorrelationID_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ComponentCorrelationID_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+ComponentCorrelationID_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	ComponentCorrelationID_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+ComponentCorrelationID_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ComponentCorrelationID_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static ber_tlv_tag_t asn_DEF_ComponentCorrelationID_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_ComponentCorrelationID = {
+	"ComponentCorrelationID",
+	"ComponentCorrelationID",
+	ComponentCorrelationID_free,
+	ComponentCorrelationID_print,
+	ComponentCorrelationID_constraint,
+	ComponentCorrelationID_decode_ber,
+	ComponentCorrelationID_encode_der,
+	ComponentCorrelationID_decode_xer,
+	ComponentCorrelationID_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ComponentCorrelationID_tags_1,
+	sizeof(asn_DEF_ComponentCorrelationID_tags_1)
+		/sizeof(asn_DEF_ComponentCorrelationID_tags_1[0]), /* 1 */
+	asn_DEF_ComponentCorrelationID_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ComponentCorrelationID_tags_1)
+		/sizeof(asn_DEF_ComponentCorrelationID_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

asn1-compiled/ComponentCorrelationID.h

@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_ComponentCorrelationID_H_
+#define	_ComponentCorrelationID_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <INTEGER.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ComponentCorrelationID */
+typedef INTEGER_t	 ComponentCorrelationID_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ComponentCorrelationID;
+asn_struct_free_f ComponentCorrelationID_free;
+asn_struct_print_f ComponentCorrelationID_print;
+asn_constr_check_f ComponentCorrelationID_constraint;
+ber_type_decoder_f ComponentCorrelationID_decode_ber;
+der_type_encoder_f ComponentCorrelationID_encode_der;
+xer_type_decoder_f ComponentCorrelationID_decode_xer;
+xer_type_encoder_f ComponentCorrelationID_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ComponentCorrelationID_H_ */
+#include <asn_internal.h>

asn1-compiled/ComponentPortion.c

@@ -0,0 +1,52 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "ComponentPortion.h"
+
+static asn_TYPE_member_t asn_MBR_ComponentPortion_1[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_Component,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		""
+		},
+};
+static ber_tlv_tag_t asn_DEF_ComponentPortion_tags_1[] = {
+	(ASN_TAG_CLASS_APPLICATION | (12 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_ComponentPortion_specs_1 = {
+	sizeof(struct ComponentPortion),
+	offsetof(struct ComponentPortion, _asn_ctx),
+	2,	/* XER encoding is XMLValueList */
+};
+asn_TYPE_descriptor_t asn_DEF_ComponentPortion = {
+	"ComponentPortion",
+	"ComponentPortion",
+	SEQUENCE_OF_free,
+	SEQUENCE_OF_print,
+	SEQUENCE_OF_constraint,
+	SEQUENCE_OF_decode_ber,
+	SEQUENCE_OF_encode_der,
+	SEQUENCE_OF_decode_xer,
+	SEQUENCE_OF_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ComponentPortion_tags_1,
+	sizeof(asn_DEF_ComponentPortion_tags_1)
+		/sizeof(asn_DEF_ComponentPortion_tags_1[0]) - 1, /* 1 */
+	asn_DEF_ComponentPortion_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ComponentPortion_tags_1)
+		/sizeof(asn_DEF_ComponentPortion_tags_1[0]), /* 2 */
+	0,	/* No PER visible constraints */
+	asn_MBR_ComponentPortion_1,
+	1,	/* Single element */
+	&asn_SPC_ComponentPortion_specs_1	/* Additional specs */
+};
+

asn1-compiled/ComponentPortion.h

@@ -0,0 +1,43 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#ifndef	_ComponentPortion_H_
+#define	_ComponentPortion_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <asn_SEQUENCE_OF.h>
+#include <constr_SEQUENCE_OF.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct Component;
+
+/* ComponentPortion */
+typedef struct ComponentPortion {
+	A_SEQUENCE_OF(struct Component) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} ComponentPortion_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ComponentPortion;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "Component.h"
+
+#endif	/* _ComponentPortion_H_ */
+#include <asn_internal.h>

asn1-compiled/ComponentType.c

@@ -0,0 +1,130 @@
+/*
+ * Generated by asn1c-0.9.24 (http://lionet.info/asn1c)
+ * From ASN.1 module "TCAPMessages"
+ * 	found in "../asn1/tcap.asn"
+ */
+
+#include "ComponentType.h"
+
+int
+ComponentType_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_ENUMERATED.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using ENUMERATED,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+ComponentType_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_ENUMERATED.free_struct;
+	td->print_struct   = asn_DEF_ENUMERATED.print_struct;
+	td->ber_decoder    = asn_DEF_ENUMERATED.ber_decoder;
+	td->der_encoder    = asn_DEF_ENUMERATED.der_encoder;
+	td->xer_decoder    = asn_DEF_ENUMERATED.xer_decoder;
+	td->xer_encoder    = asn_DEF_ENUMERATED.xer_encoder;
+	td->uper_decoder   = asn_DEF_ENUMERATED.uper_decoder;
+	td->uper_encoder   = asn_DEF_ENUMERATED.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_ENUMERATED.per_constraints;
+	td->elements       = asn_DEF_ENUMERATED.elements;
+	td->elements_count = asn_DEF_ENUMERATED.elements_count;
+     /* td->specifics      = asn_DEF_ENUMERATED.specifics;	// Defined explicitly */
+}
+
+void
+ComponentType_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	ComponentType_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+ComponentType_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	ComponentType_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+ComponentType_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	ComponentType_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+ComponentType_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ComponentType_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+ComponentType_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	ComponentType_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+ComponentType_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ComponentType_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static asn_INTEGER_enum_map_t asn_MAP_ComponentType_value2enum_1[] = {
+	{ 0,	3,	"any" },
+	{ 1,	6,	"invoke" },
+	{ 2,	7,	"rResult" },
+	{ 3,	6,	"rError" },
+	{ 4,	7,	"rReject" }
+};
+static unsigned int asn_MAP_ComponentType_enum2value_1[] = {
+	0,	/* any(0) */
+	1,	/* invoke(1) */
+	3,	/* rError(3) */
+	4,	/* rReject(4) */
+	2	/* rResult(2) */
+};
+static asn_INTEGER_specifics_t asn_SPC_ComponentType_specs_1 = {
+	asn_MAP_ComponentType_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_ComponentType_enum2value_1,	/* N => "tag"; sorted by N */
+	5,	/* Number of elements in the maps */
+	0,	/* Enumeration is not extensible */
+	1,	/* Strict enumeration */
+	0,	/* Native long size */
+	0
+};
+static ber_tlv_tag_t asn_DEF_ComponentType_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_ComponentType = {
+	"ComponentType",
+	"ComponentType",
+	ComponentType_free,
+	ComponentType_print,
+	ComponentType_constraint,
+	ComponentType_decode_ber,
+	ComponentType_encode_der,
+	ComponentType_decode_xer,
+	ComponentType_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ComponentType_tags_1,
+	sizeof(asn_DEF_ComponentType_tags_1)
+		/sizeof(asn_DEF_ComponentType_tags_1[0]), /* 1 */
+	asn_DEF_ComponentType_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ComponentType_tags_1)
+		/sizeof(asn_DEF_ComponentType_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_ComponentType_specs_1	/* Additional specs */
+};
+