Merge branch 'master' into waterfall

README.md

@@ -9,21 +9,20 @@ There now also is a [Matrix](https://matrix.to/#/#satdump:altillimity.com) room
 
 # Introduction
 
-*Note : This is a very basic "how-to" skipping details and assuming some knowledge of what you are doing. For more details and advanced usecases, please see the detailed documention.* 
+*Note : This is a very basic "how-to" skipping details and assuming some knowledge of what you are doing. For more details and advanced use cases, please see the detailed documentation.* 
 
 ## GUI Version
 
 ### Offline processing (recorded data)
-
-![Img](gui_example.png)
-
 Quick-Start :
-- Chose the appropriate pipeline for what you want to process
+- Choose the appropriate pipeline for what you want to process
 - Select the input file (baseband, frames, soft symbols...)
 - Set the appropriate input level (what your file is)
 - Check settings shown below are right (such as samplerate)
 - Press "Start"!
 
+![Img](gui_example.png)
+
 ![Img](gui_example2.png)  
 *SatDump demodulating a DVB-S2 Baseband*
 
@@ -31,8 +30,8 @@ Quick-Start :
 
 Quick-Start :
 - Go in the "Recorder" Tab
-- Select and start your SDR Devices
-- Chose a pipeline
+- Select and start your SDR Device
+- Choose a pipeline
 - Start it, and done!
 - For recording, use the recording tab instead. Both processing and recording can be used at once.
 
@@ -82,7 +81,7 @@ satdump record baseband_name --source airspy --samplerate 6e6 --frequency 1701.3
 
 ### Windows
 
-On Windows the recommend method of running SatDump is getting the latest pre-built release off the [Release](https://github.com/altillimity/SatDump/releases) page, which includes everything you will need to run it.  
+On Windows the recommended method of running SatDump is getting the latest pre-built release off the [Release](https://github.com/altillimity/SatDump/releases) page, which includes everything you will need to run it.  
 Those builds are made with Visual Studio 2019 for x64, so the appropriate Visual C++ Runtime will be required (though, likely to be already installed). You can get it [here](https://support.microsoft.com/en-us/topic/the-latest-supported-visual-c-downloads-2647da03-1eea-4433-9aff-95f26a218cc0).   
 
 From there, just run either satdump-ui.exe or satdump.exe (CLI) and everything will work.
@@ -99,7 +98,7 @@ Here are some generic (Debian-oriented) build instructions.
 ```
 # Linux: Install dependencies
 sudo apt install git build-essential cmake g++ pkgconf libfftw3-dev libvolk2-dev libpng-dev libluajit-5.1-dev # Core dependencies. If libvolk2-dev is not available, use libvolk1-dev
-sudo apt install libnng-dev                                                                                   # If this packages is not found, follow build instructions below for NNG
+sudo apt install libnng-dev                                                                                   # If this package is not found, follow build instructions below for NNG
 sudo apt install librtlsdr-dev libhackrf-dev libairspy-dev libairspyhf-dev                                    # All libraries required for live processing (optional)
 sudo apt install libglew-dev libglfw3-dev                                                                     # Only if you want to build the GUI Version (optional)
 sudo apt install libzstd-dev                                                                                  # Only if you want to build with ZIQ Recording compression 
@@ -167,7 +166,7 @@ On Android, the preferred source is F-Droid [INSERT LINK WHEN POSSIBLE].
 
 If this is not an option for you, APKs are also available on the [Release](https://github.com/altillimity/SatDump/releases) page.  
 
-Do keep in mind that while pretty much all features are perfectly function on Android, there may be some limitations (either due to the hardware) in some places. For example, not all SDR Devices can be used.  
+Do keep in mind that while pretty much all features perfectly function on Android, there may be some limitations (either due to the hardware) in some places. For example, not all SDR Devices can be used.  
 Supported SDR devices are :
 - RTL-SDR
 - Airspy

plugins/goes_support/goes/hrit/module_goes_lrit_data_decoder.cpp

@@ -227,7 +227,7 @@ namespace goes
 
                         hasImage = true;
 
-                        if (ImGui::BeginTabItem(std::string("Img " + std::to_string(decMap.first)).c_str()))
+                        if (ImGui::BeginTabItem(std::string("VCID " + std::to_string(decMap.first)).c_str()))
                         {
                             ImGui::Image((void *)(intptr_t)dec->textureID, {200 * ui_scale, 200 * ui_scale});
                             ImGui::SameLine();

plugins/goes_support/goes/hrit/module_goes_lrit_data_decoder_proc.cpp

@@ -243,22 +243,21 @@ namespace goes
 
                 if (file.hasHeader<SegmentIdentificationHeader>())
                 {
-
                     SegmentIdentificationHeader segment_id_header = file.getHeader<SegmentIdentificationHeader>();
 
-                    if (all_wip_images.count(segment_id_header.image_identifier) == 0)
-                        all_wip_images.insert({segment_id_header.image_identifier, std::make_unique<wip_images>()});
+                    if (all_wip_images.count(file.vcid) == 0)
+                        all_wip_images.insert({file.vcid, std::make_unique<wip_images>()});
 
-                    std::unique_ptr<wip_images> &wip_img = all_wip_images[segment_id_header.image_identifier];
+                    std::unique_ptr<wip_images> &wip_img = all_wip_images[file.vcid];
 
                     wip_img->imageStatus = RECEIVING;
 
-                    if (segmentedDecoders.count(segment_id_header.image_identifier) == 0)
-                        segmentedDecoders.insert({segment_id_header.image_identifier, SegmentedLRITImageDecoder()});
+                    if (segmentedDecoders.count(file.vcid) == 0)
+                        segmentedDecoders.insert({file.vcid, SegmentedLRITImageDecoder()});
 
-                    SegmentedLRITImageDecoder &segmentedDecoder = segmentedDecoders[segment_id_header.image_identifier];
+                    SegmentedLRITImageDecoder &segmentedDecoder = segmentedDecoders[file.vcid];
 
-                    if (segmentedDecoder.image_id != segment_id_header.image_identifier)
+                    if (segmentedDecoder.image_id != file.vcid)
                     {
                         if (segmentedDecoder.image_id != -1)
                         {
@@ -292,7 +291,7 @@ namespace goes
                         segmentedDecoder = SegmentedLRITImageDecoder(segment_id_header.max_segment,
                                                                      image_structure_record.columns_count,
                                                                      image_structure_record.lines_count,
-                                                                     segment_id_header.image_identifier);
+                                                                     file.vcid);
                         segmentedDecoder.filename = current_filename;
                     }
 

plugins/inmarsat_support/CMakeLists.txt

@@ -2,13 +2,13 @@ cmake_minimum_required(VERSION 3.0.0)
 project(inmarsat_support)
 
 
-file(GLOB_RECURSE inmarsat_support_CPPS *.cpp)
+file(GLOB_RECURSE inmarsat_support_CPPS *.cpp aero/libacars/*.c)
 add_library(inmarsat_support SHARED ${inmarsat_support_CPPS})
 target_link_libraries(inmarsat_support PUBLIC satdump_core)
-target_include_directories(inmarsat_support PUBLIC src)
+target_include_directories(inmarsat_support PUBLIC src .)
 
 if(MSVC)
-    target_link_libraries(inmarsat_support PUBLIC ws2_32)
+    target_link_libraries(inmarsat_support PUBLIC ws2_32 zlib.dll)
 endif()
 
 install(TARGETS inmarsat_support DESTINATION share/satdump/plugins)

plugins/inmarsat_support/aero/acars_parser.cpp

@@ -13,7 +13,7 @@ namespace inmarsat
                 return payload.size() > 16 && payload[0] == 0xFF && payload[1] == 0xFF;
             }
 
-            // Yes, I did end peeking in JAERO a bit to figure this
+            // Yes, I did end up peeking in JAERO a bit to figure this
             // part out. 0 documentation apparently!
             ACARSPacket::ACARSPacket(std::vector<uint8_t> pkt)
             {
@@ -47,8 +47,6 @@ namespace inmarsat
                     plane_reg += pkt[k] & 0x7F;
                 }
 
-                plane_reg.erase(std::remove(plane_reg.begin(), plane_reg.end(), '.'), plane_reg.end());
-
                 if (pkt[15] == 0x02)
                 {
                     has_text = true;
@@ -97,6 +95,20 @@ namespace inmarsat
                     return acar;
                 }
             }
+
+            nlohmann::json parse_libacars(ACARSPacket &pkt, la_msg_dir dir)
+            {
+                la_proto_node *node = la_acars_decode_apps(pkt.label.data(), pkt.message.data(), dir);
+                if (node != NULL)
+                {
+                    la_vstring *str = la_proto_tree_format_json(NULL, node);
+                    auto v = nlohmann::json::parse(std::string(str->str));
+                    la_vstring_destroy(str, true);
+                    return v;
+                }
+                la_proto_tree_destroy(node);
+                return nlohmann::json();
+            }
         }
     }
 }

plugins/inmarsat_support/aero/acars_parser.h

@@ -6,6 +6,10 @@
 #include "pkt_structs.h"
 #include <optional>
 
+#include "libacars/libacars.h"
+#include "libacars/acars.h"
+#include "libacars/vstring.h"
+
 namespace inmarsat
 {
     namespace aero
@@ -43,6 +47,8 @@ namespace inmarsat
             public:
                 std::optional<ACARSPacket> parse(std::vector<uint8_t> &payload);
             };
+
+            nlohmann::json parse_libacars(ACARSPacket &pkt, la_msg_dir dir);
         }
     }
 }

plugins/inmarsat_support/aero/libacars/acars.c

@@ -0,0 +1,595 @@
+/*
+ *  This file is a part of libacars
+ *
+ *  Copyright (c) 2018-2021 Tomasz Lemiech <szpajder@gmail.com>
+ */
+
+#include <string.h>                         // memcpy(), strdup()
+#ifdef WIN32
+#else
+#include <sys/time.h>                       // struct timeval
+#endif
+#include "config.h"                         // WITH_LIBXML2
+#ifdef WITH_LIBXML2
+#include <libxml/tree.h>                    // xmlBufferPtr, xmlBufferFree()
+#endif
+#include <aero/libacars/libacars.h>              // la_proto_node, la_proto_tree_find_protocol
+#include <aero/libacars/macros.h>                // la_assert, la_debug_print
+#include <aero/libacars/arinc.h>                 // la_arinc_parse()
+#include <aero/libacars/media-adv.h>             // la_media_adv_parse()
+#include <aero/libacars/miam.h>                  // la_miam_parse_and_reassemble()
+#include <aero/libacars/crc.h>                   // la_crc16_ccitt()
+#include <aero/libacars/vstring.h>               // la_vstring, LA_ISPRINTF()
+#include <aero/libacars/json.h>                  // la_json_append_*()
+#include <aero/libacars/util.h>                  // LA_XCALLOC, LA_XFREE, la_prettify_xml
+#include <aero/libacars/hash.h>                  // LA_HASH_INIT, la_hash_string()
+#include <aero/libacars/reassembly.h>
+#include <aero/libacars/acars.h>
+
+#define LA_ACARS_PREAMBLE_LEN    16         // including CRC and DEL, not including SOH
+#define DEL 0x7f
+#define STX 0x02
+#define ETX 0x03
+#define ETB 0x17
+#define ACK 0x06
+#define NAK 0x15
+#define IS_DOWNLINK_BLK(bid) ((bid) >= '0' && (bid) <= '9')
+
+#define LA_ACARS_REASM_TABLE_CLEANUP_INTERVAL 1000
+
+typedef struct {
+	struct timeval downlink, uplink;
+} la_acars_timeout_profile;
+
+// Reassembly timers for various ACARS radio bearers.
+static la_acars_timeout_profile const timeout_profiles[] = {
+	[LA_ACARS_BEARER_INVALID] = {
+		.downlink = { .tv_sec = 0,    .tv_usec = 0 },
+		.uplink   = { .tv_sec = 0,    .tv_usec = 0 }
+	},
+	// Note: LA_ACARS_BEARER_VHF applies both to PoA and VDL2.
+	// ARINC 618 specifies 420 and 90 seconds for VDL2, respectively,
+	// however these values are too small and would result in many
+	// incomplete reassemblies, especially in downlink direction.
+	// PoA timers seem to work better in practice.
+	[LA_ACARS_BEARER_VHF] = {
+		.downlink = { .tv_sec = 660,  .tv_usec = 0 },    // VGT4
+		.uplink   = { .tv_sec = 90,   .tv_usec = 0 }     // VAT4
+	},
+	[LA_ACARS_BEARER_HFDL] = {
+		.downlink = { .tv_sec = 1260, .tv_usec = 0 },    // HFGT4
+		.uplink   = { .tv_sec = 370,  .tv_usec = 0 }     // HFAT4
+	},
+	[LA_ACARS_BEARER_SATCOM] = {
+		.downlink = { .tv_sec = 1260, .tv_usec = 0 },    // SGT4
+		.uplink   = { .tv_sec = 280,  .tv_usec = 0 }     // SAT4
+	}
+};
+
+typedef struct {
+	char *reg, *label, *msg_num;
+} la_acars_key;
+
+static uint32_t la_acars_key_hash(void const *key) {
+	la_acars_key *k = (la_acars_key *)key;
+	uint32_t h = la_hash_string(k->reg, LA_HASH_INIT);
+	h = la_hash_string(k->label, h);
+	h = la_hash_string(k->msg_num, h);
+	return h;
+}
+
+static bool la_acars_key_compare(void const *key1, void const *key2) {
+	la_acars_key const *k1 = key1;
+	la_acars_key const *k2 = key2;
+	return (!strcmp(k1->reg, k2->reg) &&
+			!strcmp(k1->label, k2->label) &&
+			!strcmp(k1->msg_num, k2->msg_num));
+}
+
+static void la_acars_key_destroy(void *ptr) {
+	if(ptr == NULL) {
+		return;
+	}
+	la_acars_key *key = ptr;
+	la_debug_print(D_INFO, "DESTROY KEY %s %s %s\n", key->reg, key->label, key->msg_num);
+	LA_XFREE(key->reg);
+	LA_XFREE(key->label);
+	LA_XFREE(key->msg_num);
+	LA_XFREE(key);
+}
+
+static void *la_acars_tmp_key_get(void const *msg) {
+	la_assert(msg != NULL);
+	la_acars_msg const *amsg = msg;
+	LA_NEW(la_acars_key, key);
+	key->reg = (char *)amsg->reg;
+	key->label = (char *)amsg->label;
+	key->msg_num = (char *)amsg->msg_num;
+	return (void *)key;
+}
+
+static void *la_acars_key_get(void const *msg) {
+	la_assert(msg != NULL);
+	la_acars_msg const *amsg = msg;
+	LA_NEW(la_acars_key, key);
+	key->reg = strdup(amsg->reg);
+	key->label = strdup(amsg->label);
+	key->msg_num = strdup(amsg->msg_num);
+	la_debug_print(D_INFO, "ALLOC KEY %s %s %s\n", key->reg, key->label, key->msg_num);
+	return (void *)key;
+}
+
+static la_reasm_table_funcs acars_reasm_funcs = {
+	.get_key = la_acars_key_get,
+	.get_tmp_key = la_acars_tmp_key_get,
+	.hash_key = la_acars_key_hash,
+	.compare_keys = la_acars_key_compare,
+	.destroy_key = la_acars_key_destroy
+};
+
+la_proto_node *la_acars_apps_parse_and_reassemble(char const *reg,
+		char const *label, char const *txt, la_msg_dir msg_dir,
+		la_reasm_ctx *rtables, struct timeval rx_time) {
+	la_proto_node *ret = NULL;
+	if(label == NULL || txt == NULL) {
+		goto end;
+	}
+	switch(label[0]) {
+		case 'A':
+			switch(label[1]) {
+				case '6':
+				case 'A':
+					if((ret = la_arinc_parse(txt, msg_dir)) != NULL) {
+						goto end;
+					}
+					break;
+			}
+			break;
+		case 'B':
+			switch(label[1]) {
+				case '6':
+				case 'A':
+					if((ret = la_arinc_parse(txt, msg_dir)) != NULL) {
+						goto end;
+					}
+					break;
+			}
+			break;
+		case 'H':
+			switch(label[1]) {
+				case '1':
+					if((ret = la_arinc_parse(txt, msg_dir)) != NULL) {
+						goto end;
+					}
+					if((ret = la_miam_parse_and_reassemble(reg, txt, rtables, rx_time)) != NULL) {
+						goto end;
+					}
+					break;
+			}
+			break;
+		case 'M':
+			switch(label[1]) {
+				case 'A':
+					if((ret = la_miam_parse_and_reassemble(reg, txt, rtables, rx_time)) != NULL) {
+						goto end;
+					}
+					break;
+			}
+			break;
+		case 'S':
+			switch(label[1]) {
+				case 'A':
+					if((ret = la_media_adv_parse(txt)) != NULL) {
+						goto end;
+					}
+					break;
+			}
+			break;
+	}
+end:
+	return ret;
+}
+
+la_proto_node *la_acars_decode_apps(char const *label,
+		char const *txt, la_msg_dir msg_dir) {
+	return la_acars_apps_parse_and_reassemble(NULL, label, txt, msg_dir,
+			NULL, (struct timeval){ .tv_sec = 0, .tv_usec = 0 });
+}
+
+#define COPY_IF_NOT_NULL(d, s, l) do { \
+	if((d) != NULL && (s) != NULL) { \
+		memcpy((d), (s), (l)); \
+	} } while(0)
+
+#define BUF_CLEAR(p, l) do { \
+	if((p) != NULL) { \
+		memset((p), 0, (l)); \
+	} } while(0)
+
+int la_acars_extract_sublabel_and_mfi(char const *label, la_msg_dir msg_dir,
+		char const *txt, int len, char *sublabel, char *mfi) {
+
+	if(txt == NULL || label == NULL || strlen(label) < 2) {
+		return -1;
+	}
+	if(msg_dir != LA_MSG_DIR_AIR2GND && msg_dir != LA_MSG_DIR_GND2AIR) {
+		return -1;
+	}
+
+	int consumed = 0;
+	int remaining = len;
+	char const *ptr = txt;
+	char const *sublabel_ptr = NULL, *mfi_ptr = NULL;
+
+	BUF_CLEAR(sublabel, 3);
+	BUF_CLEAR(mfi, 3);
+
+	if(label[0] == 'H' && label[1] == '1') {
+		if(msg_dir == LA_MSG_DIR_GND2AIR) {
+			// Note: this algorithm works correctly only for service-related messages
+			// without SMT header. The header, if present, precedes the "- #" character
+			// sequence, while this algorithm expects this sequence to appear at the
+			// start of the message text. However this is not a big deal since the main
+			// purpose of this routine is to skip initial sublabel/MFI part and return
+			// a pointer to the beginning of the next layer application payload (eg.
+			// ARINC-622 ATS message). Right now libacars does not decode any application
+			// layer protocols transmitted with SMT headers, so it's not a huge issue.
+			if(remaining >= 5 && strncmp(ptr, "- #", 3) == 0) {
+				la_debug_print(D_INFO, "Uplink sublabel: %c%c\n", ptr[3], ptr[4]);
+				sublabel_ptr = ptr + 3;
+				ptr += 5; consumed += 5; remaining -= 5;
+			}
+		} else if(msg_dir == LA_MSG_DIR_AIR2GND) {
+			if(remaining >= 4 && ptr[0] == '#' && ptr[3] == 'B') {
+				la_debug_print(D_INFO, "Downlink sublabel: %c%c\n", ptr[1], ptr[2]);
+				sublabel_ptr = ptr + 1;
+				ptr += 4; consumed += 4; remaining -= 4;
+			}
+		}
+		// Look for MFI only if sublabel has been found
+		if(sublabel_ptr == NULL) {
+			goto end;
+		}
+		// MFI format is the same for both directions
+		if(remaining >= 4 && ptr[0] == '/' && ptr[3] == ' ') {
+			la_debug_print(D_INFO, "MFI: %c%c\n", ptr[1], ptr[2]);
+			mfi_ptr = ptr + 1;
+			ptr += 4; consumed += 4; remaining -= 4;
+		}
+	}
+end:
+	COPY_IF_NOT_NULL(sublabel, sublabel_ptr, 2);
+	COPY_IF_NOT_NULL(mfi, mfi_ptr, 2);
+	la_debug_print(D_INFO, "consumed %d bytes\n", consumed);
+	return consumed;
+}
+
+// Note: buf must contain raw ACARS bytes, NOT including initial SOH byte
+// (0x01) and including terminating DEL byte (0x7f).
+la_proto_node *la_acars_parse_and_reassemble(uint8_t const* buf, int len, la_msg_dir msg_dir,
+		la_reasm_ctx *rtables, struct timeval rx_time) {
+	if(buf == NULL) {
+		return NULL;
+	}
+
+	la_proto_node *node = la_proto_node_new();
+	LA_NEW(la_acars_msg, msg);
+	node->data = msg;
+	node->td = &la_DEF_acars_message;
+	char *buf2 = LA_XCALLOC(len, sizeof(char));
+
+	msg->err = false;
+	if(len < LA_ACARS_PREAMBLE_LEN) {
+		la_debug_print(D_ERROR, "Preamble too short: %u < %u\n", len, LA_ACARS_PREAMBLE_LEN);
+		goto fail;
+	}
+
+	if(buf[len-1] != DEL) {
+		la_debug_print(D_ERROR, "%02x: no DEL byte at end\n", buf[len-1]);
+		goto fail;
+	}
+	len--;
+
+	uint16_t crc = la_crc16_ccitt(buf, len, 0);
+	la_debug_print(D_INFO, "CRC check result: %04x\n", crc);
+	len -= 2;
+	msg->crc_ok = (crc == 0);
+
+	int i = 0;
+	for(i = 0; i < len; i++) {
+		buf2[i] = buf[i] & 0x7f;
+	}
+	la_debug_print_buf_hex(D_VERBOSE, buf2, len, "After CRC and parity bit removal:\n");
+	la_debug_print(D_INFO, "Length: %d\n", len);
+
+	if(buf2[len-1] == ETX) {
+		msg->final_block = true;
+	} else if(buf2[len-1] == ETB) {
+		msg->final_block = false;
+	} else {
+		la_debug_print(D_ERROR, "%02x: no ETX/ETB byte at end of text\n", buf2[len-1]);
+		goto fail;
+	}
+	len--;
+	// Here we have DEL, CRC and ETX/ETB bytes removed.
+	// There are at least 12 bytes remaining.
+
+	int remaining = len;
+	char *ptr = buf2;
+
+	msg->mode = *ptr;
+	ptr++; remaining--;
+
+	memcpy(msg->reg, ptr, 7);
+	msg->reg[7] = '\0';
+	ptr += 7; remaining -= 7;
+
+	msg->ack = *ptr;
+	ptr++; remaining--;
+
+	// change special values to something printable
+	if (msg->ack == NAK) {
+		msg->ack = '!';
+	} else if(msg->ack == ACK) {
+		msg->ack = '^';
+	}
+
+	msg->label[0] = *ptr++;
+	msg->label[1] = *ptr++;
+	remaining -= 2;
+
+	if (msg->label[1] == 0x7f) {
+		msg->label[1] = 'd';
+	}
+	msg->label[2] = '\0';
+
+	msg->block_id = *ptr;
+	ptr++; remaining--;
+
+	if (msg->block_id == 0) {
+		msg->block_id = ' ';
+	}
+	// If the message direction is unknown, guess it using the block ID character.
+	if(msg_dir == LA_MSG_DIR_UNKNOWN) {
+		if(IS_DOWNLINK_BLK(msg->block_id)) {
+			msg_dir = LA_MSG_DIR_AIR2GND;
+		} else {
+			msg_dir = LA_MSG_DIR_GND2AIR;
+		}
+		la_debug_print(D_ERROR, "Assuming msg_dir=%d\n", msg_dir);
+	}
+	if(remaining < 1) {
+		// ACARS preamble has been consumed up to this point.
+		// If this is an uplink with an empty message text, then we are done.
+		// XXX: we are skipping the reassembly stage here, is this 100% correct?
+		// If this ever needs to be changed, special care has to be taken for
+		// empty ACKs (label: _<7F> aka _d), because they have out-of-sequence
+		// block IDs (X, Y, Z, X, ...).
+		if(!IS_DOWNLINK_BLK(msg->block_id)) {
+			msg->txt = strdup("");
+			msg->reasm_status = LA_REASM_SKIPPED;
+			goto end;
+		} else {
+			la_debug_print(D_ERROR, "No text field in downlink message\n");
+			goto fail;
+		}
+	}
+	// Otherwise we expect STX here.
+	if(*ptr != STX) {
+		la_debug_print(D_ERROR, "%02x: No STX byte after preamble\n", *ptr);
+		goto fail;
+	}
+	ptr++; remaining--;
+
+	// Replace NULLs in message text to make it printable
+	// XXX: Should we replace all nonprintable chars here?
+	for(i = 0; i < remaining; i++) {
+		if(ptr[i] == 0) {
+			ptr[i] = '.';
+		}
+	}
+	// Extract downlink-specific fields from message text
+	if (IS_DOWNLINK_BLK(msg->block_id)) {
+		if(remaining < 10) {
+			la_debug_print(D_ERROR, "Downlink text field too short: %d < 10\n", remaining);
+			goto fail;
+		}
+		memcpy(msg->msg_num, ptr, 3);
+		msg->msg_num[3] = '\0';
+		msg->msg_num_seq = ptr[3];
+		ptr += 4; remaining -= 4;
+		memcpy(msg->flight_id, ptr, 6);
+		ptr += 6; remaining -= 6;
+	}
+
+	// Extract sublabel and MFI if present
+	int offset = la_acars_extract_sublabel_and_mfi(msg->label, msg_dir,
+			ptr, remaining, msg->sublabel, msg->mfi);
+	if(offset > 0) {
+		ptr += offset;
+		remaining -= offset;
+	}
+
+	la_reasm_table *acars_rtable = NULL;
+	if(rtables != NULL) {       // reassembly engine is enabled
+		acars_rtable = la_reasm_table_lookup(rtables, &la_DEF_acars_message);
+		if(acars_rtable == NULL) {
+			acars_rtable = la_reasm_table_new(rtables, &la_DEF_acars_message,
+					acars_reasm_funcs, LA_ACARS_REASM_TABLE_CLEANUP_INTERVAL);
+		}
+		bool down = IS_DOWNLINK_BLK(msg->block_id);
+
+		long int acars_bearer = LA_ACARS_BEARER_INVALID;
+		(void)la_config_get_int("acars_bearer", &acars_bearer);
+		if(acars_bearer < LA_ACARS_BEARER_MIN || acars_bearer > LA_ACARS_BEARER_MAX) {
+			// This bearer will cause reassembly to fail with LA_REASM_INVALID_ARGS
+			acars_bearer = LA_ACARS_BEARER_INVALID;
+		}
+		la_acars_timeout_profile const *timeout_profile = timeout_profiles + acars_bearer;
+		la_debug_print(D_VERBOSE, "Using timeout profile for bearer %ld (up: %lu dn: %lu)\n",
+				acars_bearer,
+				timeout_profile->uplink.tv_sec,
+				timeout_profile->downlink.tv_sec);
+
+		msg->reasm_status = la_reasm_fragment_add(acars_rtable,
+				&(la_reasm_fragment_info){
+				.msg_info = msg,
+				.msg_data = (uint8_t *)ptr,
+				.msg_data_len = remaining,
+				.total_pdu_len = 0,        // not used here
+				.seq_num = down ? msg->msg_num_seq - 'A' : msg->block_id - 'A',
+				.seq_num_first = down ? 0 : SEQ_FIRST_NONE,
+				.seq_num_wrap = down ? SEQ_WRAP_NONE : 'X' - 'A',
+				.is_final_fragment = msg->final_block,
+				.rx_time = rx_time,
+				.reasm_timeout = down ? timeout_profile->downlink : timeout_profile->uplink
+				});
+	}
+	uint8_t *reassembled_msg = NULL;
+	if(msg->reasm_status == LA_REASM_COMPLETE &&
+			la_reasm_payload_get(acars_rtable, msg, &reassembled_msg) > 0) {
+		// reassembled_msg is a newly allocated byte buffer, which is guaranteed to
+		// be NULL-terminated, so we can cast it to char * directly.
+		msg->txt = (char *)reassembled_msg;
+
+	} else {        // this will also trigger when reassembly engine is disabled
+		msg->txt = LA_XCALLOC(remaining + 1, sizeof(char));
+		if(remaining > 0) {
+			memcpy(msg->txt, ptr, remaining);
+		}
+	}
+
+	if(strlen(msg->txt) > 0) {
+		bool decode_apps = true;
+		// If reassembly is enabled and is now in progress (ie. the message is not yet complete),
+		// then decode_fragments config flag decides whether to decode apps in this message
+		// or not.
+		if(rtables != NULL && (msg->reasm_status == LA_REASM_IN_PROGRESS ||
+					msg->reasm_status == LA_REASM_DUPLICATE)) {
+			(void)la_config_get_bool("decode_fragments", &decode_apps);
+		}
+		if(decode_apps) {
+			node->next = la_acars_apps_parse_and_reassemble(msg->reg, msg->label,
+					msg->txt, msg_dir, rtables, rx_time);
+		}
+	}
+	goto end;
+fail:
+	msg->err = true;
+end:
+	LA_XFREE(buf2);
+	return node;
+}
+
+la_proto_node *la_acars_parse(uint8_t const *buf, int len, la_msg_dir msg_dir) {
+	return la_acars_parse_and_reassemble(buf, len, msg_dir, NULL,
+			(struct timeval){ .tv_sec = 0, .tv_usec = 0 });
+}
+
+void la_acars_format_text(la_vstring *vstr, void const *data, int indent) {
+	la_assert(vstr);
+	la_assert(data);
+	la_assert(indent >= 0);
+
+	la_acars_msg const *msg = data;
+	if(msg->err) {
+		LA_ISPRINTF(vstr, indent, "-- Unparseable ACARS message\n");
+		return;
+	}
+	LA_ISPRINTF(vstr, indent, "ACARS%s:\n", msg->crc_ok ? "" : " (warning: CRC error)");
+	indent++;
+
+	LA_ISPRINTF(vstr, indent, "Reassembly: %s\n", la_reasm_status_name_get(msg->reasm_status));
+	LA_ISPRINTF(vstr, indent, "Reg: %s", msg->reg);
+	if(IS_DOWNLINK_BLK(msg->block_id)) {
+		la_vstring_append_sprintf(vstr, " Flight: %s\n", msg->flight_id);
+	} else {
+		la_vstring_append_sprintf(vstr, "%s", "\n");
+	}
+
+	LA_ISPRINTF(vstr, indent, "Mode: %1c Label: %s Blk id: %c More: %d Ack: %c",
+			msg->mode, msg->label, msg->block_id, !msg->final_block, msg->ack);
+	if(IS_DOWNLINK_BLK(msg->block_id)) {
+		la_vstring_append_sprintf(vstr, " Msg num: %s%c\n", msg->msg_num, msg->msg_num_seq);
+	} else {
+		la_vstring_append_sprintf(vstr, "%s", "\n");
+	}
+	if(msg->sublabel[0] != '\0') {
+		LA_ISPRINTF(vstr, indent, "Sublabel: %s", msg->sublabel);
+		if(msg->mfi[0] != '\0') {
+			la_vstring_append_sprintf(vstr, " MFI: %s", msg->mfi);
+		}
+		la_vstring_append_sprintf(vstr, "%s", "\n");
+	}
+	if(msg->txt[0] != '\0') {
+		bool prettify_xml = false;
+#ifdef WITH_LIBXML2
+		(void)la_config_get_bool("prettify_xml", &prettify_xml);
+		if(prettify_xml == true) {
+			xmlBufferPtr xmlbufptr = NULL;
+			if((xmlbufptr = la_prettify_xml(msg->txt)) != NULL) {
+				LA_ISPRINTF(vstr, indent, "Message (reformatted):\n");
+				la_isprintf_multiline_text(vstr, indent + 1, (char *)xmlbufptr->content);
+				xmlBufferFree(xmlbufptr);
+			} else {
+				// Doesn't look like XML - print it as normal
+				prettify_xml = false;
+			}
+		}
+#endif
+		if(prettify_xml == false) {
+			LA_ISPRINTF(vstr, indent, "Message:\n");
+			la_isprintf_multiline_text(vstr, indent+1, msg->txt);
+		}
+	}
+}
+
+void la_acars_format_json(la_vstring *vstr, void const *data) {
+	la_assert(vstr);
+	la_assert(data);
+
+	la_acars_msg const *msg = data;
+	la_json_append_bool(vstr, "err", msg->err);
+	if(msg->err) {
+		return;
+	}
+	la_json_append_bool(vstr, "crc_ok", msg->crc_ok);
+	la_json_append_bool(vstr, "more", !msg->final_block);
+	la_json_append_string(vstr, "reg", msg->reg);
+	la_json_append_char(vstr, "mode", msg->mode);
+	la_json_append_string(vstr, "label", msg->label);
+	la_json_append_char(vstr, "blk_id", msg->block_id);
+	la_json_append_char(vstr, "ack", msg->ack);
+	if(IS_DOWNLINK_BLK(msg->block_id)) {
+		la_json_append_string(vstr, "flight", msg->flight_id);
+		la_json_append_string(vstr, "msg_num", msg->msg_num);
+		la_json_append_char(vstr, "msg_num_seq", msg->msg_num_seq);
+	}
+	if(msg->sublabel[0] != '\0') {
+		la_json_append_string(vstr, "sublabel", msg->sublabel);
+	}
+	if(msg->mfi[0] != '\0') {
+		la_json_append_string(vstr, "mfi", msg->mfi);
+	}
+	la_json_append_string(vstr, "msg_text", msg->txt);
+}
+
+void la_acars_destroy(void *data) {
+	if(data == NULL) {
+		return;
+	}
+	la_acars_msg *msg = data;
+	LA_XFREE(msg->txt);
+	LA_XFREE(data);
+}
+
+la_type_descriptor const la_DEF_acars_message = {
+	.format_text = la_acars_format_text,
+	.format_json = la_acars_format_json,
+	.json_key = "acars",
+	.destroy = la_acars_destroy
+};
+
+la_proto_node *la_proto_tree_find_acars(la_proto_node *root) {
+	return la_proto_tree_find_protocol(root, &la_DEF_acars_message);
+}

plugins/inmarsat_support/aero/libacars/acars.h

@@ -0,0 +1,77 @@
+/*
+ *  This file is a part of libacars
+ *
+ *  Copyright (c) 2018-2021 Tomasz Lemiech <szpajder@gmail.com>
+ */
+
+#ifndef LA_ACARS_H
+#define LA_ACARS_H 1
+#include <stdint.h>
+#include <stdbool.h>
+#include <aero/libacars/libacars.h>              // la_proto_node, la_type_descriptor
+#include <aero/libacars/vstring.h>               // la_vstring
+#include <aero/libacars/reassembly.h>            // la_reasm_ctx, la_reasm_status
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Supported radio link types
+// These are the allowed values of "acars_bearer" configuration option
+
+#define LA_ACARS_BEARER_INVALID   0         // do not use
+#define LA_ACARS_BEARER_VHF       1
+#define LA_ACARS_BEARER_HFDL      2
+#define LA_ACARS_BEARER_SATCOM    3
+
+#define LA_ACARS_BEARER_MIN       0
+#define LA_ACARS_BEARER_MAX       3
+
+typedef struct {
+	bool crc_ok;
+	bool err;
+	bool final_block;
+	char mode;
+	char reg[8];
+	char ack;
+	char label[3];
+	char sublabel[3];
+	char mfi[3];
+	char block_id;
+	char msg_num[4];
+	char msg_num_seq;
+	char flight_id[7];
+	la_reasm_status reasm_status;
+	char *txt;
+	// reserved for future use
+	void (*reserved0)(void);
+	void (*reserved1)(void);
+	void (*reserved2)(void);
+	void (*reserved3)(void);
+	void (*reserved4)(void);
+	void (*reserved5)(void);
+	void (*reserved6)(void);
+	void (*reserved7)(void);
+	void (*reserved8)(void);
+	void (*reserved9)(void);
+} la_acars_msg;
+
+// acars.c
+extern la_type_descriptor const la_DEF_acars_message;
+la_proto_node *la_acars_decode_apps(char const *label,
+		char const *txt, la_msg_dir msg_dir);
+la_proto_node *la_acars_apps_parse_and_reassemble(char const *reg,
+		char const *label, char const *txt, la_msg_dir msg_dir,
+		la_reasm_ctx *rtables, struct timeval rx_time);
+la_proto_node *la_acars_parse_and_reassemble(uint8_t const *buf, int len, la_msg_dir msg_dir,
+		la_reasm_ctx *rtables, struct timeval rx_time);
+la_proto_node *la_acars_parse(uint8_t const *buf, int len, la_msg_dir msg_dir);
+int la_acars_extract_sublabel_and_mfi(char const *label, la_msg_dir msg_dir,
+		char const *txt, int len, char *sublabel, char *mfi);
+void la_acars_format_text(la_vstring *vstr, void const *data, int indent);
+void la_acars_format_json(la_vstring *vstr, void const *data);
+la_proto_node *la_proto_tree_find_acars(la_proto_node *root);
+#ifdef __cplusplus
+}
+#endif
+#endif // !LA_ACARS_H

plugins/inmarsat_support/aero/libacars/adsc.h

@@ -0,0 +1,195 @@
+/*
+ *  This file is a part of libacars
+ *
+ *  Copyright (c) 2018-2021 Tomasz Lemiech <szpajder@gmail.com>
+ */
+
+#ifndef LA_ADSC_H
+#define LA_ADSC_H 1
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <aero/libacars/libacars.h>      // la_proto_node, la_type_descriptor
+#include <aero/libacars/arinc.h>         // la_arinc_imi
+#include <aero/libacars/list.h>          // la_list
+#include <aero/libacars/vstring.h>       // la_vstring
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+	la_vstring *vstr;
+	int indent;
+} la_adsc_formatter_ctx_t;
+
+typedef int(la_adsc_parser_fun)(void *dest, uint8_t const *buf, uint32_t len);
+typedef void(la_adsc_formatter_fun)(la_adsc_formatter_ctx_t *ctx, char const *label, void const *data);
+typedef void(la_adsc_destructor_fun)(void *data);
+
+typedef struct {
+	char const *label;
+	char const *json_key;
+	la_adsc_parser_fun *parse;
+	la_adsc_formatter_fun *format_text;
+	la_adsc_formatter_fun *format_json;
+	la_adsc_destructor_fun *destroy;
+	// reserved for future use
+	void (*reserved0)(void);
+	void (*reserved1)(void);
+	void (*reserved2)(void);
+	void (*reserved3)(void);
+} la_adsc_type_descriptor_t;
+
+// ADS-C message
+typedef struct {
+	bool err;
+	la_list *tag_list;
+	// reserved for future use
+	void (*reserved0)(void);
+	void (*reserved1)(void);
+	void (*reserved2)(void);
+	void (*reserved3)(void);
+} la_adsc_msg_t;
+
+// generic tag structure
+typedef struct {
+	uint8_t tag;
+	la_adsc_type_descriptor_t *type;
+	void *data;
+} la_adsc_tag_t;
+
+// Downlink tag structures
+
+// negative acknowledgement (tag 4)
+typedef struct {
+	uint8_t contract_req_num;
+	uint8_t reason;
+	uint8_t ext_data;
+} la_adsc_nack_t;
+#define LA_ADSC_NACK_MAX_REASON_CODE 13
+
+// description of a single non-compliant message group contained in the above notification
+typedef struct {
+	uint8_t noncomp_tag;                /* non-compliant tag value */
+	uint8_t is_unrecognized;            /* 1 - group unrecognized, 0 - group unavailable */
+	uint8_t is_whole_group_unavail;     /* 1 - entire group is unavailable
+	                                       0 - one or more group params is unavailable */
+	uint8_t param_cnt;                  /* number of unavailable params
+	                                       (used when is_whole_group_noncompliant==0) */
+	uint8_t params[15];                 /* a table of non-compliant parameter numbers */
+} la_adsc_noncomp_group_t;
+
+// noncompliance notification (tag 5)
+typedef struct {
+	uint8_t contract_req_num;           // contract request number
+	uint8_t group_cnt;                  // number of non-compliant groups
+	la_adsc_noncomp_group_t *groups;    // a table of non-compliant groups
+} la_adsc_noncomp_notify_t;
+
+// basic ADS group (downlink tags: 7, 9, 10, 18, 19, 20)
+typedef struct {
+	double lat, lon;
+	double timestamp;
+	int alt;
+	uint8_t redundancy, accuracy, tcas_health;
+} la_adsc_basic_report_t;
+
+// flight ID group (tag 12)
+typedef struct {
+	char id[9];
+} la_adsc_flight_id_t;
+
+// predicted route group (tag 13)
+typedef struct {
+	double lat_next, lon_next;
+	double lat_next_next, lon_next_next;
+	int alt_next, alt_next_next;
+	int eta_next;
+} la_adsc_predicted_route_t;
+
+// earth or air reference group (tags: 14, 15)
+typedef struct {
+	double heading;
+	double speed;
+	int vert_speed;
+	uint8_t heading_invalid;
+} la_adsc_earth_air_ref_t;
+
+// meteorological group (tag 16)
+typedef struct {
+	double wind_speed;
+	double wind_dir;
+	double temp;
+	uint8_t wind_dir_invalid;
+} la_adsc_meteo_t;
+
+// airframe ID group (tag 17)
+typedef struct {
+	uint8_t icao_hex[3];
+} la_adsc_airframe_id_t;
+
+// intermediate projected intent group (tag 22)
+typedef struct {
+	double distance;
+	double track;
+	int alt;
+	int eta;
+	uint8_t track_invalid;
+} la_adsc_intermediate_projection_t;
+
+// fixed projected intent group (tag 23)
+typedef struct {
+	double lat, lon;
+	int alt;
+	int eta;
+} la_adsc_fixed_projection_t;
+
+// Uplink tag structures
+
+// periodic and event contract requests (tags: 7, 8, 9)
+typedef struct {
+	uint8_t contract_num;           // contract number
+	la_list *req_tag_list;          // list of la_adsc_tag_t's describing requested report groups
+} la_adsc_req_t;
+
+// lateral deviation change (uplink tag 10)
+typedef struct {
+	double lat_dev_threshold;
+} la_adsc_lat_dev_chg_event_t;
+
+// reporting interval (uplink tag 11)
+typedef struct {
+	uint8_t scaling_factor;
+	uint8_t rate;
+} la_adsc_report_interval_req_t;
+
+// vertical speed change threshold (uplink tag 18)
+typedef struct {
+	int vspd_threshold;
+} la_adsc_vspd_chg_event_t;
+
+// altitude range change event (uplink tag 19)
+typedef struct {
+	int ceiling_alt, floor_alt;
+} la_adsc_alt_range_event_t;
+
+// aircraft intent group (uplink tag 21)
+typedef struct {
+	uint8_t modulus;
+	uint8_t acft_intent_projection_time;
+} la_adsc_acft_intent_group_req_t;
+
+// adsc.c
+extern la_type_descriptor const la_DEF_adsc_message;
+la_proto_node *la_adsc_parse(uint8_t const *buf, int len, la_msg_dir msg_dir, la_arinc_imi imi);
+void la_adsc_format_text(la_vstring *vstr, void const *data, int indent);
+void la_adsc_format_json(la_vstring *vstr, void const *data);
+void la_adsc_destroy(void *data);
+la_proto_node *la_proto_tree_find_adsc(la_proto_node *root);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !LA_ADSC_H

plugins/inmarsat_support/aero/libacars/arinc.c

@@ -0,0 +1,256 @@
+/*
+ *  This file is a part of libacars
+ *
+ *  Copyright (c) 2018-2021 Tomasz Lemiech <szpajder@gmail.com>
+ */
+
+#include <stdbool.h>
+#include <ctype.h>                      // isupper(), isdigit()
+#include <string.h>                     // strstr()
+#include <aero/libacars/libacars.h>          // la_proto_node, la_proto_tree_find_protocol
+#include <aero/libacars/arinc.h>             // la_arinc_msg, LA_ARINC_IMI_CNT
+#include <aero/libacars/crc.h>               // la_crc16_arinc()
+#include <aero/libacars/macros.h>            // la_debug_print()
+#include <aero/libacars/vstring.h>           // la_vstring_append_sprintf()
+#include <aero/libacars/util.h>              // la_slurp_hexstring()
+#include <aero/libacars/json.h>              // la_json_append_*()
+#include <aero/libacars/adsc.h>              // la_adsc_parse()
+#include <aero/libacars/cpdlc.h>             // la_cpdlc_parse()
+
+#define LA_ARINC_IMI_LEN        3
+#define LA_ARINC_AIR_REG_LEN    7
+#define LA_ARINC_CRC_LEN        2
+#define LA_CRC_ARINC_GOOD       0x1D0Fu
+
+typedef enum {
+	ARINC_APP_TYPE_UNKNOWN = 0,
+	ARINC_APP_TYPE_CHARACTER,
+	ARINC_APP_TYPE_BINARY
+} la_arinc_app_type;
+
+typedef struct {
+	char const *imi_string;
+	la_arinc_imi imi;
+} la_arinc_imi_map;
+
+typedef struct {
+	la_arinc_app_type app_type;
+	char const *description;
+	char const *json_key;
+} la_arinc_imi_props;
+
+static la_arinc_imi_map const imi_map[LA_ARINC_IMI_CNT] = {
+	{ .imi_string = ".AT1", .imi = ARINC_MSG_AT1 },
+	{ .imi_string = ".CR1", .imi = ARINC_MSG_CR1 },
+	{ .imi_string = ".CC1", .imi = ARINC_MSG_CC1 },
+	{ .imi_string = ".DR1", .imi = ARINC_MSG_DR1 },
+	{ .imi_string = ".ADS", .imi = ARINC_MSG_ADS },
+	{ .imi_string = ".DIS", .imi = ARINC_MSG_DIS },
+	{ .imi_string = NULL,   .imi = ARINC_MSG_UNKNOWN }
+};
+
+static la_arinc_imi_props const imi_props[LA_ARINC_IMI_CNT] = {
+	[ARINC_MSG_UNKNOWN] = {
+		.app_type = ARINC_APP_TYPE_UNKNOWN,
+		.description = "Unknown message type",
+		.json_key = "unknown"
+	},
+	[ARINC_MSG_AT1] = {
+		.app_type = ARINC_APP_TYPE_BINARY,
+		.description = "FANS-1/A CPDLC Message",
+		.json_key = "fans1a_cpdlc_msg",
+	},
+	[ARINC_MSG_CR1] = {
+		.app_type = ARINC_APP_TYPE_BINARY,
+		.description = "FANS-1/A CPDLC Connect Request",
+		.json_key = "fans1a_cpdlc_connect_request",
+	},
+	[ARINC_MSG_CC1] = {
+		.app_type = ARINC_APP_TYPE_BINARY,
+		.description = "FANS-1/A CPDLC Connect Confirm",
+		.json_key = "fans1a_cpdlc_connect_confirm",
+	},
+	[ARINC_MSG_DR1] = {
+		.app_type = ARINC_APP_TYPE_BINARY,
+		.description = "FANS-1/A CPDLC Disconnect Request",
+		.json_key = "fans1a_cpdlc_disconnect_request",
+	},
+	[ARINC_MSG_ADS] = {
+		.app_type = ARINC_APP_TYPE_BINARY,
+		.description = "ADS-C message",
+		.json_key = "adsc_msg",
+	},
+	[ARINC_MSG_DIS] = {
+		.app_type = ARINC_APP_TYPE_BINARY,
+		.description = "ADS-C disconnect request",
+		.json_key = "adsc_disconnect_request",
+	}
+};
+
+static bool is_numeric_or_uppercase(char const *str, size_t len) {
+	if(!str) return false;
+	for(size_t i = 0; i < len; i++) {
+		if((!isupper(str[i]) && !isdigit(str[i])) || str[i] == '\0') {
+			return false;
+		}
+	}
+	return true;
+}
+
+static char *guess_arinc_msg_type(char const *txt, la_arinc_msg *msg) {
+	if(txt == NULL) {
+		return NULL;
+	}
+	la_assert(msg);
+	la_arinc_imi imi = ARINC_MSG_UNKNOWN;
+
+	// H1 messages start with sublabel and MFI - these fields must be stripped
+	// before passing message text to this routine. This is done by
+	// la_acars_extract_sublabel_and_mfi(). In any case, message text
+	// must start with the ground address, optionally preceded by '/'.
+	if(txt[0] == '/') {
+		txt++;
+	}
+
+	char *imi_ptr = NULL;
+	for(la_arinc_imi_map const *p = imi_map; ; p++) {
+		if(p->imi_string == NULL) break;
+		if((imi_ptr = strstr(txt, p->imi_string)) != NULL) {
+			imi = p->imi;
+			break;
+		}
+	}
+	if(imi == ARINC_MSG_UNKNOWN) {
+		la_debug_print(D_INFO, "No known IMI found\n");
+		return NULL;
+	}
+	char *gs_addr = NULL;
+	size_t gs_addr_len = 0;
+	// Check for seven-character ground address ("AKLCDYA.AT1...")
+	if(imi_ptr - txt == 7) {
+		if(is_numeric_or_uppercase(imi_ptr - 7, 7)) {
+			gs_addr = imi_ptr - 7;
+			gs_addr_len = 7;
+			goto complete;
+		}
+		// Check for four-character ground address ("EDYY.AFN...")
+	} else if(imi_ptr - txt == 4) {
+		if(is_numeric_or_uppercase(imi_ptr - 4, 4)) {
+			gs_addr = imi_ptr - 4;
+			gs_addr_len = 4;
+			goto complete;
+		}
+	}
+	la_debug_print(D_ERROR, "IMI %d found but no GS address\n", imi);
+	return NULL;
+complete:
+	msg->imi = imi;
+	memcpy(msg->gs_addr, gs_addr, gs_addr_len);
+	msg->gs_addr[gs_addr_len] = '\0';
+	// Skip the dot before IMI and point to the start of the CRC-protected part
+	return imi_ptr + 1;
+}
+
+static bool la_is_crc_ok(char const *text_part, uint8_t const *binary_part, size_t binary_part_len) {
+	// compute CRC over IMI+air_reg+binary_part_with_CRC
+	size_t buflen = LA_ARINC_IMI_LEN + LA_ARINC_AIR_REG_LEN + binary_part_len;
+	uint8_t *buf = LA_XCALLOC(buflen, sizeof(uint8_t));
+	memcpy(buf, text_part, LA_ARINC_IMI_LEN + LA_ARINC_AIR_REG_LEN);
+	memcpy(buf + LA_ARINC_IMI_LEN + LA_ARINC_AIR_REG_LEN, binary_part, binary_part_len);
+	bool result = (la_crc16_arinc(buf, buflen, 0xFFFFu) == LA_CRC_ARINC_GOOD);
+	LA_XFREE(buf);
+	la_debug_print(D_INFO, "crc_ok? %d\n", result);
+	return result;
+}
+
+la_proto_node *la_arinc_parse(char const *txt, la_msg_dir msg_dir) {
+	if(txt == NULL) {
+		return NULL;
+	}
+	LA_NEW(la_arinc_msg, msg);
+	la_proto_node *node = NULL;
+	la_proto_node *next_node = NULL;
+
+	char *payload = guess_arinc_msg_type(txt, msg);
+	if(payload == NULL) {
+		goto cleanup;
+	}
+
+	if(imi_props[msg->imi].app_type == ARINC_APP_TYPE_BINARY) {
+		size_t payload_len = strlen(payload);
+		if(payload_len < LA_ARINC_IMI_LEN + LA_ARINC_AIR_REG_LEN + LA_ARINC_CRC_LEN * 2) {
+			la_debug_print(D_ERROR, "payload too short: %zu\n", payload_len);
+			goto cleanup;
+		}
+		memcpy(msg->air_reg, payload + LA_ARINC_IMI_LEN, LA_ARINC_AIR_REG_LEN);
+		msg->air_reg[LA_ARINC_AIR_REG_LEN] = '\0';
+		la_debug_print(D_INFO, "air_reg: %s\n", msg->air_reg);
+		uint8_t *buf = NULL;
+		size_t buflen = la_slurp_hexstring(payload + LA_ARINC_IMI_LEN + LA_ARINC_AIR_REG_LEN, &buf);
+		msg->crc_ok = la_is_crc_ok(payload, buf, buflen);
+		buflen -= LA_ARINC_CRC_LEN; // strip CRC
+		switch(msg->imi) {
+			case ARINC_MSG_CR1:
+			case ARINC_MSG_CC1:
+			case ARINC_MSG_DR1:
+			case ARINC_MSG_AT1:
+				next_node = la_cpdlc_parse(buf, buflen, msg_dir);
+				LA_XFREE(buf);
+				break;
+			case ARINC_MSG_ADS:
+			case ARINC_MSG_DIS:
+				next_node = la_adsc_parse(buf, buflen, msg_dir, msg->imi);
+				LA_XFREE(buf);
+				break;
+			default:
+				break;
+		}
+	}
+
+	node = la_proto_node_new();
+	node->data = msg;
+	node->td = &la_DEF_arinc_message;
+	node->next = next_node;
+	return node;
+cleanup:
+	LA_XFREE(msg);
+	LA_XFREE(node);
+	return NULL;
+}
+
+void la_arinc_format_text(la_vstring *vstr, void const *data, int indent) {
+	la_assert(vstr);
+	la_assert(data);
+	la_assert(indent >= 0);
+
+	la_arinc_msg const *msg = data;
+	LA_ISPRINTF(vstr, indent, "%s:\n", imi_props[msg->imi].description);
+	if(!msg->crc_ok) {
+		LA_ISPRINTF(vstr, indent + 1, "-- CRC check failed\n");
+	}
+}
+
+void la_arinc_format_json(la_vstring *vstr, void const *data) {
+	la_assert(vstr);
+	la_assert(data);
+
+	la_arinc_msg const *msg = data;
+	la_json_append_string(vstr, "msg_type", imi_props[msg->imi].json_key);
+	if(msg->imi == ARINC_MSG_UNKNOWN) {
+		return;
+	}
+	la_json_append_bool(vstr, "crc_ok", msg->crc_ok);
+	la_json_append_string(vstr, "gs_addr", msg->gs_addr);
+	la_json_append_string(vstr, "air_addr", msg->air_reg);
+}
+
+la_type_descriptor const la_DEF_arinc_message = {
+	.format_text = la_arinc_format_text,
+	.format_json = la_arinc_format_json,
+	.json_key = "arinc622",
+	.destroy = NULL
+};
+
+la_proto_node *la_proto_tree_find_arinc(la_proto_node *root) {
+	return la_proto_tree_find_protocol(root, &la_DEF_arinc_message);
+}

plugins/inmarsat_support/aero/libacars/arinc.h

@@ -0,0 +1,51 @@
+/*
+ *  This file is a part of libacars
+ *
+ *  Copyright (c) 2018-2021 Tomasz Lemiech <szpajder@gmail.com>
+ */
+
+#ifndef LA_ARINC_H
+#define LA_ARINC_H 1
+
+#include <stdint.h>
+#include <aero/libacars/libacars.h>      // la_type_descriptor, la_proto_node
+#include <aero/libacars/vstring.h>       // la_vstring
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+	ARINC_MSG_UNKNOWN = 0,
+	ARINC_MSG_CR1,
+	ARINC_MSG_CC1,
+	ARINC_MSG_DR1,
+	ARINC_MSG_AT1,
+	ARINC_MSG_ADS,
+	ARINC_MSG_DIS
+} la_arinc_imi;
+#define LA_ARINC_IMI_CNT 7
+
+typedef struct {
+	char gs_addr[8];
+	char air_reg[8];
+	la_arinc_imi imi;
+	bool crc_ok;
+	// reserved for future use
+	void (*reserved0)(void);
+	void (*reserved1)(void);
+	void (*reserved2)(void);
+	void (*reserved3)(void);
+} la_arinc_msg;
+
+la_proto_node *la_arinc_parse(char const *txt, la_msg_dir msg_dir);
+void la_arinc_format_text(la_vstring *vstr, void const *data, int indent);
+void la_arinc_format_json(la_vstring *vstr, void const *data);
+extern la_type_descriptor const la_DEF_arinc_message;
+la_proto_node *la_proto_tree_find_arinc(la_proto_node *root);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !LA_ARINC_H

plugins/inmarsat_support/aero/libacars/asn1-format-common.c

@@ -0,0 +1,363 @@
+/*
+ *  This file is a part of libacars
+ *
+ *  Copyright (c) 2018-2021 Tomasz Lemiech <szpajder@gmail.com>
+ */
+
+#include <aero/libacars/asn1/asn_application.h>      // asn_TYPE_descriptor_t, asn_sprintf
+#include <aero/libacars/asn1/OCTET_STRING.h>         // OCTET_STRING_t
+#include <aero/libacars/asn1/INTEGER.h>              // asn_INTEGER_enum_map_t, asn_INTEGER2long()
+#include <aero/libacars/asn1/BIT_STRING.h>           // BIT_STRING_t
+#include <aero/libacars/asn1/BOOLEAN.h>              // BOOLEAN_t
+#include <aero/libacars/asn1/constr_CHOICE.h>        // _fetch_present_idx()
+#include <aero/libacars/asn1/asn_SET_OF.h>           // _A_CSET_FROM_VOID()
+#include <aero/libacars/asn1-util.h>                 // LA_ASN1_FORMATTER_FUNC
+#include <aero/libacars/macros.h>                    // la_debug_print
+#include <aero/libacars/dict.h>                      // la_dict_search
+#include <aero/libacars/util.h>                      // la_reverse
+#include <aero/libacars/vstring.h>                   // la_vstring, la_vstring_append_sprintf(), LA_ISPRINTF
+#include <aero/libacars/json.h>                      // la_json_*()
+
+char const *la_asn1_value2enum(asn_TYPE_descriptor_t *td, long value) {
+	if(td == NULL) return NULL;
+	asn_INTEGER_enum_map_t const *enum_map = INTEGER_map_value2enum(td->specifics, value);
+	if(enum_map == NULL) return NULL;
+	return enum_map->enum_name;
+}
+
+void la_format_INTEGER_with_unit_as_text(la_asn1_formatter_params p,
+		char const *unit, double multiplier, int decimal_places) {
+	long const *val = p.sptr;
+	LA_ISPRINTF(p.vstr, p.indent, "%s: %.*f%s\n", p.label, decimal_places, (double)(*val) * multiplier, unit);
+}
+
+void la_format_INTEGER_with_unit_as_json(la_asn1_formatter_params p,
+		char const *unit, double multiplier) {
+	long const *val = p.sptr;
+	la_json_object_start(p.vstr, p.label);
+	la_json_append_double(p.vstr, "val", (double)(*val) * multiplier);
+	la_json_append_string(p.vstr, "unit", unit);
+	la_json_object_end(p.vstr);
+}
+
+void la_format_INTEGER_as_ENUM_as_text(la_asn1_formatter_params p, la_dict const *value_labels) {
+	long const *val = p.sptr;
+	char const *val_label = la_dict_search(value_labels, (int)(*val));
+	if(val_label != NULL) {
+		LA_ISPRINTF(p.vstr, p.indent, "%s: %s\n", p.label, val_label);
+	} else {
+		LA_ISPRINTF(p.vstr, p.indent, "%s: %ld (unknown)\n", p.label, *val);
+	}
+}
+
+void la_format_INTEGER_as_ENUM_as_json(la_asn1_formatter_params p, la_dict const *value_labels) {
+	long const *val = p.sptr;
+	la_json_object_start(p.vstr, p.label);
+	la_json_append_int64(p.vstr, "value", (int)(*val));
+	char const *val_label = la_dict_search(value_labels, (int)(*val));
+	if(val_label != NULL) {
+		la_json_append_string(p.vstr, "value_descr", val_label);
+	}
+	la_json_object_end(p.vstr);
+}
+
+void la_format_CHOICE_as_text(la_asn1_formatter_params p, la_dict const *choice_labels,
+		la_asn1_formatter_func cb) {
+	asn_CHOICE_specifics_t *specs = p.td->specifics;
+	int present = _fetch_present_idx(p.sptr, specs->pres_offset, specs->pres_size);
+	if(p.label != NULL) {
+		LA_ISPRINTF(p.vstr, p.indent, "%s:\n", p.label);
+		p.indent++;
+	}
+	if(choice_labels != NULL) {
+		char const *descr = la_dict_search(choice_labels, present);
+		if(descr != NULL) {
+			LA_ISPRINTF(p.vstr, p.indent, "%s\n", descr);
+		} else {
+			LA_ISPRINTF(p.vstr, p.indent, "<no description for CHOICE value %d>\n", present);
+		}
+		p.indent++;
+	}
+	if(present > 0 && present <= p.td->elements_count) {
+		asn_TYPE_member_t *elm = &p.td->elements[present-1];
+		void const *memb_ptr;
+
+		if(elm->flags & ATF_POINTER) {
+			memb_ptr = *(void const * const *)((char const *)p.sptr + elm->memb_offset);
+			if(!memb_ptr) {
+				LA_ISPRINTF(p.vstr, p.indent, "%s: <not present>\n", elm->name);
+				return;
+			}
+		} else {
+			memb_ptr = (void const *)((char const *)p.sptr + elm->memb_offset);
+		}
+
+		p.td = elm->type;
+		p.sptr = memb_ptr;
+		cb(p);
+	} else {
+		LA_ISPRINTF(p.vstr, p.indent, "-- %s: value %d out of range\n", p.td->name, present);
+	}
+}
+
+void la_format_CHOICE_as_json(la_asn1_formatter_params p, la_dict const *choice_labels,
+		la_asn1_formatter_func cb) {
+	asn_CHOICE_specifics_t const *specs = p.td->specifics;
+	int present = _fetch_present_idx(p.sptr, specs->pres_offset, specs->pres_size);
+	la_json_object_start(p.vstr, p.label);
+	if(choice_labels != NULL) {
+		char const *descr = la_dict_search(choice_labels, present);
+		la_json_append_string(p.vstr, "choice_label", descr != NULL ? descr : "");
+	}
+	if(present > 0 && present <= p.td->elements_count) {
+		asn_TYPE_member_t *elm = &p.td->elements[present-1];
+		void const *memb_ptr;
+
+		if(elm->flags & ATF_POINTER) {
+			memb_ptr = *(void const * const *)((char const *)p.sptr + elm->memb_offset);
+			if(!memb_ptr) {
+				goto end;
+			}
+		} else {
+			memb_ptr = (void const *)((char const *)p.sptr + elm->memb_offset);
+		}
+		la_json_append_string(p.vstr, "choice", elm->name);
+		la_json_object_start(p.vstr, "data");
+		p.td = elm->type;
+		p.sptr = memb_ptr;
+		cb(p);
+		la_json_object_end(p.vstr);
+	}
+end:
+	la_json_object_end(p.vstr);
+}
+
+void la_format_SEQUENCE_as_text(la_asn1_formatter_params p, la_asn1_formatter_func cb) {
+	if(p.label != NULL) {
+		LA_ISPRINTF(p.vstr, p.indent, "%s:\n", p.label);
+		p.indent++;
+	}
+	la_asn1_formatter_params cb_p = p;
+	for(int edx = 0; edx < p.td->elements_count; edx++) {
+		asn_TYPE_member_t *elm = &p.td->elements[edx];
+		void const *memb_ptr;
+
+		if(elm->flags & ATF_POINTER) {
+			memb_ptr = *(void const * const *)((char const *)p.sptr + elm->memb_offset);
+			if(!memb_ptr) {
+				continue;
+			}
+		} else {
+			memb_ptr = (void const *)((char const *)p.sptr + elm->memb_offset);
+		}
+		cb_p.td = elm->type;
+		cb_p.sptr = memb_ptr;
+		cb(cb_p);
+	}
+}
+
+// Prints ASN.1 SEQUENCE as JSON object.
+// All fields in the sequence must have unique types (and p.labels), otherwise
+// JSON keys will clash.
+void la_format_SEQUENCE_as_json(la_asn1_formatter_params p, la_asn1_formatter_func cb) {
+	la_asn1_formatter_params cb_p = p;
+	la_json_object_start(p.vstr, p.label);
+	for(int edx = 0; edx < p.td->elements_count; edx++) {
+		asn_TYPE_member_t *elm = &p.td->elements[edx];
+		void const *memb_ptr;
+
+		if(elm->flags & ATF_POINTER) {
+			memb_ptr = *(void const * const *)((char const *)p.sptr + elm->memb_offset);
+			if(!memb_ptr) {
+				continue;
+			}
+		} else {
+			memb_ptr = (void const *)((char const *)p.sptr + elm->memb_offset);
+		}
+		cb_p.td = elm->type;
+		cb_p.sptr = memb_ptr;
+		cb(cb_p);
+	}
+	la_json_object_end(p.vstr);
+}
+
+void la_format_SEQUENCE_OF_as_text(la_asn1_formatter_params p, la_asn1_formatter_func cb) {
+	if(p.label != NULL) {
+		LA_ISPRINTF(p.vstr, p.indent, "%s:\n", p.label);
+		p.indent++;
+	}
+	asn_TYPE_member_t *elm = p.td->elements;
+	asn_anonymous_set_ const *list = _A_CSET_FROM_VOID(p.sptr);
+	for(int i = 0; i < list->count; i++) {
+		void const *memb_ptr = list->array[i];
+		if(memb_ptr == NULL) {
+			continue;
+		}
+		p.td = elm->type;
+		p.sptr = memb_ptr;
+		cb(p);
+	}
+}
+
+void la_format_SEQUENCE_OF_as_json(la_asn1_formatter_params p, la_asn1_formatter_func cb) {
+	la_json_array_start(p.vstr, p.label);
+	asn_TYPE_member_t *elm = p.td->elements;
+	asn_anonymous_set_ const *list = _A_CSET_FROM_VOID(p.sptr);
+	for(int i = 0; i < list->count; i++) {
+		void const *memb_ptr = list->array[i];
+		if(memb_ptr == NULL) {
+			continue;
+		}
+		la_json_object_start(p.vstr, NULL);
+		p.td = elm->type;
+		p.sptr = memb_ptr;
+		cb(p);
+		la_json_object_end(p.vstr);
+	}
+	la_json_array_end(p.vstr);
+}
+
+// Handles bit string up to 32 bits long.
+// la_dict indices are bit numbers from 0 to bit_stream_len-1
+// Bit 0 is the MSB of the first octet in the buffer.
+void la_format_BIT_STRING_as_text(la_asn1_formatter_params p, la_dict const *bit_labels) {
+	BIT_STRING_t const *bs = p.sptr;
+	la_debug_print(D_INFO, "buf len: %d bits_unused: %d\n", bs->size, bs->bits_unused);
+	uint32_t val = 0;
+	int truncated = 0;
+	int len = bs->size;
+	int bits_unused = bs->bits_unused;
+
+	if(len > (int)sizeof(val)) {
+		la_debug_print(D_ERROR, "bit stream too long (%d octets), truncating to %zu octets\n",
+				len, sizeof(val));
+		truncated = len - sizeof(val);
+		len = sizeof(val);
+		bits_unused = 0;
+	}
+	if(p.label != NULL) {
+		LA_ISPRINTF(p.vstr, p.indent, "%s: ", p.label);
+	}
+	for(int i = 0; i < len; val = (val << 8) | bs->buf[i++])
+		;
+	la_debug_print(D_INFO, "val: 0x%08x\n", val);
+	val &= (~0u << bits_unused);    // zeroize unused bits
+	if(val == 0) {
+		la_vstring_append_sprintf(p.vstr, "none\n");
+		goto end;
+	}
+	val = la_reverse(val, len * 8);
+	bool first = true;
+	for(la_dict const *ptr = bit_labels; ptr->val != NULL; ptr++) {
+		uint32_t shift = (uint32_t)ptr->id;
+		if((val >> shift) & 1) {
+			la_vstring_append_sprintf(p.vstr, "%s%s",
+					(first ? "" : ", "), (char *)ptr->val);
+			first = false;
+		}
+	}
+	LA_EOL(p.vstr);
+end:
+	if(truncated > 0) {
+		LA_ISPRINTF(p.vstr, p.indent,
+				"-- Warning: bit string too long (%d bits), truncated to %d bits\n",
+				bs->size * 8 - bs->bits_unused, len * 8);
+	}
+}
+
+void la_format_BIT_STRING_as_json(la_asn1_formatter_params p, la_dict const *bit_labels) {
+	BIT_STRING_t const *bs = p.sptr;
+	la_debug_print(D_INFO, "buf len: %d bits_unused: %d\n", bs->size, bs->bits_unused);
+	uint32_t val = 0;
+	int len = bs->size;
+	int bits_unused = bs->bits_unused;
+
+	if(len > (int)sizeof(val)) {
+		la_debug_print(D_ERROR, "bit stream too long (%d octets), truncating to %zu octets\n",
+				len, sizeof(val));
+		len = sizeof(val);
+		bits_unused = 0;
+	}
+	la_json_array_start(p.vstr, p.label);
+	for(int i = 0; i < len; val = (val << 8) | bs->buf[i++])
+		;
+	la_debug_print(D_INFO, "val: 0x%08x\n", val);
+	val &= (~0u << bits_unused);    // zeroize unused bits
+	if(val == 0) {
+		goto end;
+	}
+	val = la_reverse(val, len * 8);
+	for(la_dict const *ptr = bit_labels; ptr->val != NULL; ptr++) {
+		uint32_t shift = (uint32_t)ptr->id;
+		if((val >> shift) & 1) {
+			la_json_append_string(p.vstr, NULL, (char *)ptr->val);
+		}
+	}
+end:
+	la_json_array_end(p.vstr);
+}
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_any_as_text) {
+	if(p.label != NULL) {
+		LA_ISPRINTF(p.vstr, p.indent, "%s: ", p.label);
+	} else {
+		LA_ISPRINTF(p.vstr, p.indent, "%s", "");
+	}
+	asn_sprintf(p.vstr, p.td, p.sptr, 1);
+	LA_EOL(p.vstr);
+}
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_any_as_string_as_json) {
+	la_vstring *tmp = la_vstring_new();
+	asn_sprintf(tmp, p.td, p.sptr, 0);
+	la_json_append_octet_string_as_string(p.vstr, p.label, (uint8_t const *)tmp->str, tmp->len);
+	la_vstring_destroy(tmp, true);
+}
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_label_only_as_text) {
+	if(p.label != NULL) {
+		LA_ISPRINTF(p.vstr, p.indent, "%s\n", p.label);
+	}
+}
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_label_only_as_json) {
+	if(p.label != NULL) {
+		la_json_object_start(p.vstr, p.label);
+		la_json_object_end(p.vstr);
+	}
+}
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_ENUM_as_text) {
+	long const value = *(long const *)p.sptr;
+	char const *s = la_asn1_value2enum(p.td, value);
+	if(s != NULL) {
+		LA_ISPRINTF(p.vstr, p.indent, "%s: %s\n", p.label, s);
+	} else {
+		LA_ISPRINTF(p.vstr, p.indent, "%s: %ld\n", p.label, value);
+	}
+}
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_ENUM_as_json) {
+	long const value = *(long const *)p.sptr;
+	char const *s = la_asn1_value2enum(p.td, value);
+	if(s != NULL) {
+		la_json_append_string(p.vstr, p.label, s);
+	} else {
+		la_json_append_int64(p.vstr, p.label, value);
+	}
+}
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_long_as_json) {
+	long const *valptr = p.sptr;
+	la_json_append_int64(p.vstr, p.label, *valptr);
+}
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_bool_as_json) {
+	BOOLEAN_t const *valptr = p.sptr;
+	la_json_append_bool(p.vstr, p.label, (*valptr) ? true : false);
+}
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_OCTET_STRING_as_json) {
+	OCTET_STRING_t const *valptr = p.sptr;
+	la_json_append_octet_string(p.vstr, p.label, valptr->buf, valptr->size);
+}

plugins/inmarsat_support/aero/libacars/asn1-format-common.h

@@ -0,0 +1,44 @@
+/*
+ *  This file is a part of libacars
+ *
+ *  Copyright (c) 2018-2021 Tomasz Lemiech <szpajder@gmail.com>
+ */
+
+#ifndef LA_ASN1_FORMAT_COMMON_H
+#define LA_ASN1_FORMAT_COMMON_H 1
+#include <aero/libacars/asn1/asn_application.h>  // asn_TYPE_descriptor_t
+#include <aero/libacars/asn1-util.h>             // LA_ASN1_FORMATTER_FUNC, la_asn1_formatter_params
+#include <aero/libacars/dict.h>                  // la_dict
+#include <aero/libacars/vstring.h>               // la_vstring
+
+char const *la_asn1_value2enum(asn_TYPE_descriptor_t *td, long value);
+void la_format_INTEGER_with_unit_as_text(la_asn1_formatter_params p,
+		char const *unit, double multiplier, int decimal_places);
+void la_format_CHOICE_as_text(la_asn1_formatter_params p, la_dict const *choice_labels,
+		la_asn1_formatter_func cb);
+void la_format_INTEGER_as_ENUM_as_text(la_asn1_formatter_params p, la_dict const *value_labels);
+void la_format_SEQUENCE_as_text(la_asn1_formatter_params p, la_asn1_formatter_func cb);
+void la_format_SEQUENCE_OF_as_text(la_asn1_formatter_params p, la_asn1_formatter_func cb);
+void la_format_BIT_STRING_as_text(la_asn1_formatter_params p, la_dict const *bit_labels);
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_any_as_text);
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_ENUM_as_text);
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_label_only_as_text);
+
+void la_format_INTEGER_with_unit_as_json(la_asn1_formatter_params p,
+		char const *unit, double multiplier);
+void la_format_CHOICE_as_json(la_asn1_formatter_params p, la_dict const *choice_labels,
+		la_asn1_formatter_func cb);
+void la_format_INTEGER_as_ENUM_as_json(la_asn1_formatter_params p, la_dict const *value_labels);
+void la_format_SEQUENCE_as_json(la_asn1_formatter_params p, la_asn1_formatter_func cb);
+void la_format_SEQUENCE_OF_as_json(la_asn1_formatter_params p, la_asn1_formatter_func cb);
+void la_format_BIT_STRING_as_json(la_asn1_formatter_params p, la_dict const *bit_labels);
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_any_as_string_as_json);
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_ENUM_as_json);
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_label_only_as_json);
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_long_as_json);
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_bool_as_json);
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_OCTET_STRING_as_json);
+
+#endif // !LA_ASN1_FORMAT_COMMON_H

plugins/inmarsat_support/aero/libacars/asn1-format-cpdlc-json.c

@@ -0,0 +1,432 @@
+/*
+ *  This file is a part of libacars
+ *
+ *  Copyright (c) 2018-2021 Tomasz Lemiech <szpajder@gmail.com>
+ */
+
+#include <aero/libacars/asn1/FANSATCDownlinkMessage.h>   /* FANSATCDownlinkMessage_t and dependencies */
+#include <aero/libacars/asn1/FANSATCUplinkMessage.h>     /* FANSATCUplinkMessage_t and dependencies */
+#include <aero/libacars/asn1-util.h>                     /* la_asn_formatter, la_asn1_output() */
+#include <aero/libacars/asn1-format-common.h>            /* common formatters and helper functions */
+#include <aero/libacars/asn1-format-cpdlc.h>             /* la_asn1_output_cpdlc_as_json(),
+                                                       FANSATCUplinkMsgElementId_labels,
+                                                       FANSATCDownlinkMsgElementId_labels */
+#include <aero/libacars/macros.h>                        /* LA_ISPRINTF */
+#include <aero/libacars/util.h>                          /* LA_XCALLOC, la_dict_search() */
+#include <aero/libacars/vstring.h>                       /* la_vstring */
+#include <aero/libacars/json.h>                          /* la_json_*() */
+
+// Forward declarations
+static la_asn1_formatter const la_asn1_cpdlc_json_formatter_table[209];
+static size_t la_asn1_cpdlc_json_formatter_table_len;
+
+/************************
+ * ASN.1 type formatters
+ ************************/
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_output_cpdlc_as_json) {
+	la_asn1_output(p, la_asn1_cpdlc_json_formatter_table, la_asn1_cpdlc_json_formatter_table_len, false);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_CHOICE_cpdlc_as_json) {
+	la_format_CHOICE_as_json(p, NULL, la_asn1_output_cpdlc_as_json);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_SEQUENCE_cpdlc_as_json) {
+	la_format_SEQUENCE_as_json(p, la_asn1_output_cpdlc_as_json);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_SEQUENCE_OF_cpdlc_as_json) {
+	la_format_SEQUENCE_OF_as_json(p, la_asn1_output_cpdlc_as_json);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSAltimeterEnglish_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "inHg", 0.01);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSAltimeterMetric_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "hPa", 0.1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSAltitudeGNSSFeet_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "ft", 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSAltitudeFlightLevelMetric_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "m", 10);
+}
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_Degrees_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "deg", 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSDistanceOffsetNm_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "nm", 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSDistanceMetric_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "km", 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSFeetX10_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "ft", 10);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSFrequencyhf_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "kHz", 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSFrequencykHzToMHz_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "MHz", 0.001);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSDistanceEnglish_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "nm", 0.1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSLegTime_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "min", 0.1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSLatitudeDegrees_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "deg", 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSLongitudeDegrees_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "deg", 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSMeters_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "m", 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSTemperatureC_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "C", 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSTemperatureF_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "F", 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSWindSpeedEnglish_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "kts", 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSWindSpeedMetric_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "km/h", 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSRTATolerance_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "min", 0.1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSSpeedEnglishX10_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "kts", 10);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSSpeedMetricX10_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "km/h", 10);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSSpeedMach_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "", 0.01);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSVerticalRateEnglish_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "ft/min", 100);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSVerticalRateMetric_as_json) {
+	la_format_INTEGER_with_unit_as_json(p, "m/min", 10);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSBeaconCode_as_json) {
+	FANSBeaconCode_t const *code = p.sptr;
+	long **cptr = code->list.array;
+	char str[5] = {
+		(char)(*cptr[0]) + '0',
+		(char)(*cptr[1]) + '0',
+		(char)(*cptr[2]) + '0',
+		(char)(*cptr[3]) + '0',
+		'\0'
+	};
+	la_json_append_string(p.vstr, p.label, str);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSTime_as_json) {
+	FANSTime_t const *t = p.sptr;
+	la_json_object_start(p.vstr, p.label);
+	la_json_append_int64(p.vstr, "hour", t->hours);
+	la_json_append_int64(p.vstr, "min", t->minutes);
+	la_json_object_end(p.vstr);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSTimestamp_as_json) {
+	FANSTimestamp_t const *t = p.sptr;
+	la_json_object_start(p.vstr, p.label);
+	la_json_append_int64(p.vstr, "hour", t->hours);
+	la_json_append_int64(p.vstr, "min", t->minutes);
+	la_json_append_int64(p.vstr, "sec", t->seconds);
+	la_json_object_end(p.vstr);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSLatitude_as_json) {
+	FANSLatitude_t const *lat = p.sptr;
+	long const ldir = lat->latitudeDirection;
+	char const *ldir_name = la_asn1_value2enum(&asn_DEF_FANSLatitudeDirection, ldir);
+	la_json_object_start(p.vstr, p.label);
+	la_json_append_int64(p.vstr, "deg", lat->latitudeDegrees);
+	if(lat->minutesLatLon != NULL) {
+		la_json_append_double(p.vstr, "min", *(long const *)(lat->minutesLatLon) / 10.0);
+	}
+	la_json_append_string(p.vstr, "dir", ldir_name);
+	la_json_object_end(p.vstr);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSLongitude_as_json) {
+	FANSLongitude_t const *lat = p.sptr;
+	long const ldir = lat->longitudeDirection;
+	char const *ldir_name = la_asn1_value2enum(&asn_DEF_FANSLongitudeDirection, ldir);
+	la_json_object_start(p.vstr, p.label);
+	la_json_append_int64(p.vstr, "deg", lat->longitudeDegrees);
+	if(lat->minutesLatLon != NULL) {
+		la_json_append_double(p.vstr, "min", *(long const *)(lat->minutesLatLon) / 10.0);
+	}
+	la_json_append_string(p.vstr, "dir", ldir_name);
+	la_json_object_end(p.vstr);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSATCDownlinkMsgElementId_as_json) {
+	la_format_CHOICE_as_json(p, FANSATCDownlinkMsgElementId_labels, la_asn1_output_cpdlc_as_json);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSATCUplinkMsgElementId_as_json) {
+	la_format_CHOICE_as_json(p, FANSATCUplinkMsgElementId_labels, la_asn1_output_cpdlc_as_json);
+}
+
+static la_asn1_formatter const la_asn1_cpdlc_json_formatter_table[209] = {
+	{ .type = &asn_DEF_FANSAircraftEquipmentCode, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "ac_equipment_code" },
+	{ .type = &asn_DEF_FANSAircraftFlightIdentification, .format = la_asn1_format_any_as_string_as_json, .label = "ac_flight_id" },
+	{ .type = &asn_DEF_FANSAircraftType, .format = la_asn1_format_any_as_string_as_json, .label = "ac_type" },
+	{ .type = &asn_DEF_FANSAirport, .format = la_asn1_format_any_as_string_as_json, .label = "airport" },
+	{ .type = &asn_DEF_FANSAirportDeparture, .format = la_asn1_format_any_as_string_as_json, .label = "airport_dep" },
+	{ .type = &asn_DEF_FANSAirportDestination, .format = la_asn1_format_any_as_string_as_json, .label = "airport_dst" },
+	{ .type = &asn_DEF_FANSAirwayIdentifier, .format = la_asn1_format_any_as_string_as_json, .label = "airway_id" },
+	{ .type = &asn_DEF_FANSAirwayIntercept, .format = la_asn1_format_any_as_string_as_json, .label = "airway_intercept" },
+	{ .type = &asn_DEF_FANSAltimeter, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "altimeter" },
+	{ .type = &asn_DEF_FANSAltimeterEnglish, .format = la_asn1_format_FANSAltimeterEnglish_as_json, .label = "altimeter_english" },
+	{ .type = &asn_DEF_FANSAltimeterMetric, .format = la_asn1_format_FANSAltimeterMetric_as_json, .label = "altimeter_metric" },
+	{ .type = &asn_DEF_FANSAltitude, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "alt" },
+	{ .type = &asn_DEF_FANSAltitudeAltitude, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "alt_alt" },
+	{ .type = &asn_DEF_FANSAltitudeFlightLevel, .format = la_asn1_format_long_as_json, .label = "flight_level" },
+	{ .type = &asn_DEF_FANSAltitudeFlightLevelMetric, .format = la_asn1_format_FANSAltitudeFlightLevelMetric_as_json, .label = "flight_level_metric" },
+	{ .type = &asn_DEF_FANSAltitudeGNSSFeet, .format = la_asn1_format_FANSAltitudeGNSSFeet_as_json, .label = "alt_gnss" },
+	{ .type = &asn_DEF_FANSAltitudeGNSSMeters, .format = la_asn1_format_FANSMeters_as_json, .label = "alt_gnss_meters" },
+	{ .type = &asn_DEF_FANSAltitudePosition, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "alt_pos" },
+	{ .type = &asn_DEF_FANSAltitudeQFE, .format = la_asn1_format_FANSFeetX10_as_json, .label = "alt_qfe" },
+	{ .type = &asn_DEF_FANSAltitudeQFEMeters, .format = la_asn1_format_FANSMeters_as_json, .label = "alt_qfe_meters" },
+	{ .type = &asn_DEF_FANSAltitudeQNH, .format = la_asn1_format_FANSFeetX10_as_json, .label = "alt_qnh" },
+	{ .type = &asn_DEF_FANSAltitudeQNHMeters, .format = la_asn1_format_FANSMeters_as_json, .label = "alt_qnh_meters" },
+	{ .type = &asn_DEF_FANSAltitudeRestriction, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "alt_restriction" },
+	{ .type = &asn_DEF_FANSAltitudeSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "alt_speed" },
+	{ .type = &asn_DEF_FANSAltitudeSpeedSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "alt_speed_speed" },
+	{ .type = &asn_DEF_FANSAltitudeTime, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "alt_time" },
+	{ .type = &asn_DEF_FANSATCDownlinkMessage, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "atc_downlink_msg" },
+	{ .type = &asn_DEF_FANSATCDownlinkMsgElementId, .format = la_asn1_format_FANSATCDownlinkMsgElementId_as_json, .label = "atc_downlink_msg_element_id" },
+	{ .type = &asn_DEF_FANSATCDownlinkMsgElementIdSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "atc_downlink_msg_element_id_seq" },
+	{ .type = &asn_DEF_FANSATCMessageHeader, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "header" },
+	{ .type = &asn_DEF_FANSATCUplinkMessage, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "atc_uplink_msg" },
+	{ .type = &asn_DEF_FANSATCUplinkMsgElementId, .format = la_asn1_format_FANSATCUplinkMsgElementId_as_json, .label = "atc_uplink_msg_element_id" },
+	{ .type = &asn_DEF_FANSATCUplinkMsgElementIdSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "atc_uplink_msg_element_id_seq" },
+	{ .type = &asn_DEF_FANSATISCode, .format = la_asn1_format_any_as_string_as_json, .label = "atis_code" },
+	{ .type = &asn_DEF_FANSATWAlongTrackWaypoint, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "atw_along_track_wpt" },
+	{ .type = &asn_DEF_FANSATWAlongTrackWaypointSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "atw_along_trk_wpt_seq" },
+	{ .type = &asn_DEF_FANSATWAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "atw_alt" },
+	{ .type = &asn_DEF_FANSATWAltitudeSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "atw_alt_seq" },
+	{ .type = &asn_DEF_FANSATWAltitudeTolerance, .format = la_asn1_format_ENUM_as_json, .label = "atw_alt_tolerance" },
+	{ .type = &asn_DEF_FANSATWDistance, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "atw_distance" },
+	{ .type = &asn_DEF_FANSATWDistanceTolerance, .format = la_asn1_format_ENUM_as_json, .label = "atw_dist_tolerance" },
+	{ .type = &asn_DEF_FANSBeaconCode, .format = la_asn1_format_FANSBeaconCode_as_json, .label = "beacon_code" },
+	{ .type = &asn_DEF_FANSCOMNAVApproachEquipmentAvailable, .format = la_asn1_format_bool_as_json, .label = "comm_nav_appr_equipment_avail" },
+	{ .type = &asn_DEF_FANSCOMNAVEquipmentStatus, .format = la_asn1_format_ENUM_as_json, .label = "comm_nav_equipment_status" },
+	{ .type = &asn_DEF_FANSCOMNAVEquipmentStatusSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "comm_nav_equipment_status_seq" },
+	{ .type = &asn_DEF_FANSDegreeIncrement, .format = la_asn1_format_Degrees_as_json, .label = "deg_increment" },
+	{ .type = &asn_DEF_FANSDegrees, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "deg" },
+	{ .type = &asn_DEF_FANSDegreesMagnetic, .format = la_asn1_format_Degrees_as_json, .label = "deg_mag" },
+	{ .type = &asn_DEF_FANSDegreesTrue, .format = la_asn1_format_Degrees_as_json, .label = "deg_true" },
+	{ .type = &asn_DEF_FANSDirection, .format = la_asn1_format_ENUM_as_json, .label = "dir" },
+	{ .type = &asn_DEF_FANSDirectionDegrees, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "dir_deg" },
+	{ .type = &asn_DEF_FANSDistance, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "dist" },
+	{ .type = &asn_DEF_FANSDistanceKm, .format = la_asn1_format_FANSDistanceMetric_as_json, .label = "dist_km" },
+	{ .type = &asn_DEF_FANSDistanceNm, .format = la_asn1_format_FANSDistanceEnglish_as_json, .label = "dist_nm" },
+	{ .type = &asn_DEF_FANSDistanceOffset, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "dist_offset" },
+	{ .type = &asn_DEF_FANSDistanceOffsetDirection, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "dist_offset_dir" },
+	{ .type = &asn_DEF_FANSDistanceOffsetKm, .format = la_asn1_format_FANSDistanceMetric_as_json, .label = "dist_offset_km" },
+	{ .type = &asn_DEF_FANSDistanceOffsetNm, .format = la_asn1_format_FANSDistanceOffsetNm_as_json, .label = "dist_offset_nm" },
+	{ .type = &asn_DEF_FANSEFCtime, .format = la_asn1_format_FANSTime_as_json, .label = "expect_further_clearance_at_time" },
+	{ .type = &asn_DEF_FANSErrorInformation, .format = la_asn1_format_ENUM_as_json, .label = "err_info" },
+	{ .type = &asn_DEF_FANSFixName, .format = la_asn1_format_any_as_string_as_json, .label = "fix" },
+	{ .type = &asn_DEF_FANSFixNext, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "next_fix" },
+	{ .type = &asn_DEF_FANSFixNextPlusOne, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "next_next_fix" },
+	{ .type = &asn_DEF_FANSFreeText, .format = la_asn1_format_any_as_string_as_json, .label = "free_text" },
+	{ .type = &asn_DEF_FANSFrequency, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "freq" },
+	{ .type = &asn_DEF_FANSFrequencyDeparture, .format = la_asn1_format_FANSFrequencykHzToMHz_as_json, .label = "freq_dep" },
+	{ .type = &asn_DEF_FANSFrequencyhf, .format = la_asn1_format_FANSFrequencyhf_as_json, .label = "hf" },
+	{ .type = &asn_DEF_FANSFrequencysatchannel, .format = la_asn1_format_any_as_string_as_json, .label = "sat_channel" },
+	{ .type = &asn_DEF_FANSFrequencyuhf, .format = la_asn1_format_FANSFrequencykHzToMHz_as_json, .label = "uhf" },
+	{ .type = &asn_DEF_FANSFrequencyvhf, .format = la_asn1_format_FANSFrequencykHzToMHz_as_json, .label = "vhf" },
+	{ .type = &asn_DEF_FANSHoldatwaypoint, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "hold_at_wpt" },
+	{ .type = &asn_DEF_FANSHoldatwaypointSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "hold_at_wpt_seq" },
+	{ .type = &asn_DEF_FANSHoldatwaypointSpeedHigh, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "hold_at_wpt_speed_high" },
+	{ .type = &asn_DEF_FANSHoldatwaypointSpeedLow, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "hold_at_wpt_speed_low" },
+	{ .type = &asn_DEF_FANSHoldClearance, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "hold_clearance" },
+	{ .type = &asn_DEF_FANSICAOfacilityDesignation, .format = la_asn1_format_any_as_string_as_json, .label = "icao_facility_designation" },
+	{ .type = &asn_DEF_FANSICAOFacilityDesignationTp4Table, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "icao_facility_designation_tp4_table" },
+	{ .type = &asn_DEF_FANSICAOFacilityFunction, .format = la_asn1_format_ENUM_as_json, .label = "icao_facility_function" },
+	{ .type = &asn_DEF_FANSICAOFacilityIdentification, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "icao_facility_id" },
+	{ .type = &asn_DEF_FANSICAOFacilityName, .format = la_asn1_format_any_as_string_as_json, .label = "icao_facility_name" },
+	{ .type = &asn_DEF_FANSICAOUnitName, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "icao_unit_name" },
+	{ .type = &asn_DEF_FANSICAOUnitNameFrequency, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "icao_unit_name_freq" },
+	{ .type = &asn_DEF_FANSIcing, .format = la_asn1_format_ENUM_as_json, .label = "icing" },
+	{ .type = &asn_DEF_FANSInterceptCourseFrom, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "intercept_course_from" },
+	{ .type = &asn_DEF_FANSInterceptCourseFromSelection, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "intercept_source_from_selection" },
+	{ .type = &asn_DEF_FANSInterceptCourseFromSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "intercept_source_from_sequence" },
+	{ .type = &asn_DEF_FANSLatitude, .format = la_asn1_format_FANSLatitude_as_json, .label = "lat" },
+	{ .type = &asn_DEF_FANSLatitudeDegrees, .format = la_asn1_format_FANSLatitudeDegrees_as_json, .label = "lat_deg" },
+	{ .type = &asn_DEF_FANSLatitudeDirection, .format = la_asn1_format_ENUM_as_json, .label = "lat_dir" },
+	{ .type = &asn_DEF_FANSLatitudeLongitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "lat_lon" },
+	{ .type = &asn_DEF_FANSLatitudeLongitudeSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "lat_lon_seq" },
+	{ .type = &asn_DEF_FANSLatitudeReportingPoints, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "reporting_points" },
+	{ .type = &asn_DEF_FANSLatLonReportingPoints, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "lat_lon_reporting_points" },
+	{ .type = &asn_DEF_FANSLegDistance, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "leg_dist" },
+	{ .type = &asn_DEF_FANSLegDistanceEnglish, .format = la_asn1_format_FANSDistanceEnglish_as_json, .label = "leg_dist_english" },
+	{ .type = &asn_DEF_FANSLegDistanceMetric, .format = la_asn1_format_FANSDistanceMetric_as_json, .label = "leg_dist_metric" },
+	{ .type = &asn_DEF_FANSLegTime, .format = la_asn1_format_FANSLegTime_as_json, .label = "leg_time" },
+	{ .type = &asn_DEF_FANSLegType, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "leg_type" },
+	{ .type = &asn_DEF_FANSLongitude, .format = la_asn1_format_FANSLongitude_as_json, .label = "lon" },
+	{ .type = &asn_DEF_FANSLongitudeDegrees, .format = la_asn1_format_FANSLongitudeDegrees_as_json, .label = "lon_deg" },
+	{ .type = &asn_DEF_FANSLongitudeDirection, .format = la_asn1_format_ENUM_as_json, .label = "lon_dir" },
+	{ .type = &asn_DEF_FANSLongitudeReportingPoints, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "lon_reporting_points" },
+	{ .type = &asn_DEF_FANSMsgIdentificationNumber, .format = la_asn1_format_long_as_json, .label = "msg_id" },
+	{ .type = &asn_DEF_FANSMsgReferenceNumber, .format = la_asn1_format_long_as_json, .label = "msg_ref" },
+	{ .type = &asn_DEF_FANSNavaid, .format = la_asn1_format_any_as_string_as_json, .label = "navaid" },
+	{ .type = &asn_DEF_FANSPDCrevision, .format = la_asn1_format_long_as_json, .label = "pdc_revision" },
+	{ .type = &asn_DEF_FANSPlaceBearing, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "place_bearing" },
+	{ .type = &asn_DEF_FANSPlaceBearingDistance, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "place_bearing_dist" },
+	{ .type = &asn_DEF_FANSPlaceBearingPlaceBearing, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "place_bearing_place_bearing" },
+	{ .type = &asn_DEF_FANSPosition, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "pos" },
+	{ .type = &asn_DEF_FANSPositionAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_alt" },
+	{ .type = &asn_DEF_FANSPositionAltitudeAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_alt_alt" },
+	{ .type = &asn_DEF_FANSPositionAltitudeSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_alt_speed" },
+	{ .type = &asn_DEF_FANSPositionCurrent, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "pos_current" },
+	{ .type = &asn_DEF_FANSPositionDegrees, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_deg" },
+	{ .type = &asn_DEF_FANSPositionDistanceOffsetDirection, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_dist_offset_dir" },
+	{ .type = &asn_DEF_FANSPositionICAOUnitNameFrequency, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_icao_unit_name_freq" },
+	{ .type = &asn_DEF_FANSPositionPosition, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "pos_pos" },
+	{ .type = &asn_DEF_FANSPositionProcedureName, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_procedure_name" },
+	{ .type = &asn_DEF_FANSPositionReport, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_report" },
+	{ .type = &asn_DEF_FANSPositionRouteClearance, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_rte_clearance" },
+	{ .type = &asn_DEF_FANSPositionSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_speed" },
+	{ .type = &asn_DEF_FANSPositionSpeedSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_speed_speed" },
+	{ .type = &asn_DEF_FANSPositionTime, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_time" },
+	{ .type = &asn_DEF_FANSPositionTimeAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_time_alt" },
+	{ .type = &asn_DEF_FANSPositionTimeTime, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "pos_time_time" },
+	{ .type = &asn_DEF_FANSPredepartureClearance, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "predeparture_clearance" },
+	{ .type = &asn_DEF_FANSProcedure, .format = la_asn1_format_any_as_string_as_json, .label = "procedure" },
+	{ .type = &asn_DEF_FANSProcedureApproach, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "procedure_appr" },
+	{ .type = &asn_DEF_FANSProcedureArrival, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "procedure_arr" },
+	{ .type = &asn_DEF_FANSProcedureDeparture, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "procedure_dep" },
+	{ .type = &asn_DEF_FANSProcedureName, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "procedure_name" },
+	{ .type = &asn_DEF_FANSProcedureTransition, .format = la_asn1_format_any_as_string_as_json, .label = "procedure_transition" },
+	{ .type = &asn_DEF_FANSProcedureType, .format = la_asn1_format_ENUM_as_json, .label = "procedure_type" },
+	{ .type = &asn_DEF_FANSPublishedIdentifier, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "published_identifier" },
+	{ .type = &asn_DEF_FANSRemainingFuel, .format = la_asn1_format_FANSTime_as_json, .label = "rem_fuel_time" },
+	{ .type = &asn_DEF_FANSRemainingFuelRemainingSouls, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "rem_fuel_persons_onboard" },
+	{ .type = &asn_DEF_FANSRemainingSouls, .format = la_asn1_format_long_as_json, .label = "persons_onboard" },
+	{ .type = &asn_DEF_FANSReportedWaypointAltitude, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "reported_wpt_alt" },
+	{ .type = &asn_DEF_FANSReportedWaypointPosition, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "reported_wpt_pos" },
+	{ .type = &asn_DEF_FANSReportedWaypointTime, .format = la_asn1_format_FANSTime_as_json, .label = "reported_wpt_time" },
+	{ .type = &asn_DEF_FANSReportingPoints, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "reporting_points" },
+	{ .type = &asn_DEF_FANSRouteClearance, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "rte_clearance" },
+	{ .type = &asn_DEF_FANSRouteInformation, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "rte_info" },
+	{ .type = &asn_DEF_FANSRouteInformationAdditional, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "rte_info_additional" },
+	{ .type = &asn_DEF_FANSRouteInformationSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "rte_info_seq" },
+	{ .type = &asn_DEF_FANSRTARequiredTimeArrival, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "rta_req_time_arrival" },
+	{ .type = &asn_DEF_FANSRTARequiredTimeArrivalSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "req_time_arrival_seq" },
+	{ .type = &asn_DEF_FANSRTATime, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "rta_time" },
+	{ .type = &asn_DEF_FANSRTATolerance, .format = la_asn1_format_FANSRTATolerance_as_json, .label = "rta_tolerance" },
+	{ .type = &asn_DEF_FANSRunway, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "runway" },
+	{ .type = &asn_DEF_FANSRunwayArrival, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "runway_arr" },
+	{ .type = &asn_DEF_FANSRunwayConfiguration, .format = la_asn1_format_ENUM_as_json, .label = "runway_config" },
+	{ .type = &asn_DEF_FANSRunwayDeparture, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "runway_dep" },
+	{ .type = &asn_DEF_FANSRunwayDirection, .format = la_asn1_format_long_as_json, .label = "runway_dir" },
+	{ .type = &asn_DEF_FANSSpeed, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "speed" },
+	{ .type = &asn_DEF_FANSSpeedGround, .format = la_asn1_format_FANSSpeedEnglishX10_as_json, .label = "speed_gnd" },
+	{ .type = &asn_DEF_FANSSpeedGroundMetric, .format = la_asn1_format_FANSSpeedMetricX10_as_json, .label = "speed_gnd_metric" },
+	{ .type = &asn_DEF_FANSSpeedIndicated, .format = la_asn1_format_FANSSpeedEnglishX10_as_json, .label = "speed_indicated" },
+	{ .type = &asn_DEF_FANSSpeedIndicatedMetric, .format = la_asn1_format_FANSSpeedMetricX10_as_json, .label = "speed_indicated_metric" },
+	{ .type = &asn_DEF_FANSSpeedMach, .format = la_asn1_format_FANSSpeedMach_as_json, .label = "speed_mach" },
+	{ .type = &asn_DEF_FANSSpeedMachLarge, .format = la_asn1_format_FANSSpeedMach_as_json, .label = "speed_mach_large" },
+	{ .type = &asn_DEF_FANSSpeedSpeed, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "speed_speed" },
+	{ .type = &asn_DEF_FANSSpeedTrue, .format = la_asn1_format_FANSSpeedEnglishX10_as_json, .label = "speed_true" },
+	{ .type = &asn_DEF_FANSSpeedTrueMetric, .format = la_asn1_format_FANSSpeedMetricX10_as_json, .label = "speed_true_metric" },
+	{ .type = &asn_DEF_FANSSSREquipmentAvailable, .format = la_asn1_format_ENUM_as_json, .label = "ssr_equipment_avail" },
+	{ .type = &asn_DEF_FANSSupplementaryInformation, .format = la_asn1_format_any_as_string_as_json, .label = "supplementary_info" },
+	{ .type = &asn_DEF_FANSTemperature, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "temp" },
+	{ .type = &asn_DEF_FANSTemperatureC, .format = la_asn1_format_FANSTemperatureC_as_json, .label = "temp_deg_c" },
+	{ .type = &asn_DEF_FANSTemperatureF, .format = la_asn1_format_FANSTemperatureF_as_json, .label = "temp_deg_f" },
+	{ .type = &asn_DEF_FANSTime, .format = la_asn1_format_FANSTime_as_json, .label = "time" },
+	{ .type = &asn_DEF_FANSTimeAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "time_alt" },
+	{ .type = &asn_DEF_FANSTimeAtPositionCurrent, .format = la_asn1_format_FANSTime_as_json, .label = "time_at_pos_current" },
+	{ .type = &asn_DEF_FANSTimeDepartureEdct, .format = la_asn1_format_FANSTime_as_json, .label = "est_dep_time" },
+	{ .type = &asn_DEF_FANSTimeDistanceOffsetDirection, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "dist_offset_dir" },
+	{ .type = &asn_DEF_FANSTimeDistanceToFromPosition, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "dist_to_from_pos" },
+	{ .type = &asn_DEF_FANSTimeEtaAtFixNext, .format = la_asn1_format_FANSTime_as_json, .label = "eta_at_fix_next" },
+	{ .type = &asn_DEF_FANSTimeEtaDestination, .format = la_asn1_format_FANSTime_as_json, .label = "eta_at_dest" },
+	{ .type = &asn_DEF_FANSTimeICAOunitnameFrequency, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "icao_unitname_freq" },
+	{ .type = &asn_DEF_FANSTimePosition, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "time_pos" },
+	{ .type = &asn_DEF_FANSTimePositionAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "time_pos_alt" },
+	{ .type = &asn_DEF_FANSTimePositionAltitudeSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "time_pos_alt_speed" },
+	{ .type = &asn_DEF_FANSTimeSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "time_speed" },
+	{ .type = &asn_DEF_FANSTimeSpeedSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "time_speed_speed" },
+	{ .type = &asn_DEF_FANSTimestamp, .format = la_asn1_format_FANSTimestamp_as_json, .label = "timestamp" },
+	{ .type = &asn_DEF_FANSTimeTime, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "time_time" },
+	{ .type = &asn_DEF_FANSTimeTolerance, .format = la_asn1_format_ENUM_as_json, .label = "time_tolerance" },
+	{ .type = &asn_DEF_FANSToFrom, .format = la_asn1_format_ENUM_as_json, .label = "to_from" },
+	{ .type = &asn_DEF_FANSToFromPosition, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "to_from_pos" },
+	{ .type = &asn_DEF_FANSTp4table, .format = la_asn1_format_ENUM_as_json, .label = "tp4table" },
+	{ .type = &asn_DEF_FANSTrackAngle, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "trk_angle" },
+	{ .type = &asn_DEF_FANSTrackDetail, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "trk_detail" },
+	{ .type = &asn_DEF_FANSTrackName, .format = la_asn1_format_any_as_string_as_json, .label = "trk_name" },
+	{ .type = &asn_DEF_FANSTrueheading, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "true_hdg" },
+	{ .type = &asn_DEF_FANSTurbulence, .format = la_asn1_format_ENUM_as_json, .label = "turbulence" },
+	{ .type = &asn_DEF_FANSVersionNumber, .format = la_asn1_format_long_as_json, .label = "ver_num" },
+	{ .type = &asn_DEF_FANSVerticalChange, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "vert_change" },
+	{ .type = &asn_DEF_FANSVerticalDirection, .format = la_asn1_format_ENUM_as_json, .label = "vert_dir" },
+	{ .type = &asn_DEF_FANSVerticalRate, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "vert_rate" },
+	{ .type = &asn_DEF_FANSVerticalRateEnglish, .format = la_asn1_format_FANSVerticalRateEnglish_as_json, .label = "vert_rate_english" },
+	{ .type = &asn_DEF_FANSVerticalRateMetric, .format = la_asn1_format_FANSVerticalRateMetric_as_json, .label = "vert_rate_metric" },
+	{ .type = &asn_DEF_FANSWaypointSpeedAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "wpt_speed_alt" },
+	{ .type = &asn_DEF_FANSWaypointSpeedAltitudesequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_json, .label = "wpt_speed_alt_seq" },
+	{ .type = &asn_DEF_FANSWindDirection, .format = la_asn1_format_Degrees_as_json, .label = "wind_dir" },
+	{ .type = &asn_DEF_FANSWinds, .format = la_asn1_format_SEQUENCE_cpdlc_as_json, .label = "winds" },
+	{ .type = &asn_DEF_FANSWindSpeed, .format = la_asn1_format_CHOICE_cpdlc_as_json, .label = "wind_speed" },
+	{ .type = &asn_DEF_FANSWindSpeedEnglish, .format = la_asn1_format_FANSWindSpeedEnglish_as_json, .label = "wind_speed_english" },
+	{ .type = &asn_DEF_FANSWindSpeedMetric, .format = la_asn1_format_FANSWindSpeedMetric_as_json, .label = "wind_speed_metric" },
+	{ .type = &asn_DEF_NULL, .format = NULL, .label = NULL }
+	// Formatters for the following simple types are not implemented - they are handled by formatters
+	// of complex types where these simple types are used.
+	//
+	// Handled by la_asn1_format_FANSTime_as_json
+	// { .type = &asn_DEF_FANSTimehours, .format = la_asn1_format_long_as_json, .label = "hour" },
+	// { .type = &asn_DEF_FANSTimeminutes, .format = la_asn1_format_long_as_json, .label = "minute" },
+	// Handled by &asn_DEF_FANSTimestamp
+	// { .type = &asn_DEF_FANSTimeSeconds, .format = la_asn1_format_long_as_json, .label = "second" },
+	// Handled by la_asn1_format_FANSBeaconCode_as_json
+	// { .type = &asn_DEF_FANSBeaconCodeOctalDigit, .format = , .label = "beacon_code_octal_digit" },
+	// Handled by la_asn1_format_FANSLatitude_as_json / la_asn1_format_FANSLongitude_as_json
+	// { .type = &asn_DEF_FANSMinutesLatLon, .format = , .label = "minutes_lat_lon" },
+};
+
+static size_t la_asn1_cpdlc_json_formatter_table_len =
+sizeof(la_asn1_cpdlc_json_formatter_table) / sizeof(la_asn1_formatter);

plugins/inmarsat_support/aero/libacars/asn1-format-cpdlc-text.c

@@ -0,0 +1,784 @@
+/*
+ *  This file is a part of libacars
+ *
+ *  Copyright (c) 2018-2021 Tomasz Lemiech <szpajder@gmail.com>
+ */
+
+#include <aero/libacars/asn1/FANSATCDownlinkMessage.h>       // FANSATCDownlinkMessage_t and dependencies
+#include <aero/libacars/asn1/FANSATCUplinkMessage.h>         // FANSATCUplinkMessage_t and dependencies
+#include <aero/libacars/asn1-util.h>                         // la_asn_formatter, la_asn1_output()
+#include <aero/libacars/asn1-format-common.h>                // common formatters and helper functions
+#include <aero/libacars/asn1-format-cpdlc.h>                 // la_asn1_output_cpdlc_as_text()
+#include <aero/libacars/macros.h>                            // LA_ISPRINTF
+#include <aero/libacars/util.h>                              // LA_XCALLOC, la_dict_search()
+#include <aero/libacars/vstring.h>                           // la_vstring
+
+// Forward declarations
+static la_asn1_formatter const la_asn1_cpdlc_text_formatter_table[209];
+static size_t la_asn1_cpdlc_text_formatter_table_len;
+
+la_dict const FANSATCUplinkMsgElementId_labels[] = {
+	{ FANSATCUplinkMsgElementId_PR_uM0NULL, "UNABLE" },
+	{ FANSATCUplinkMsgElementId_PR_uM1NULL, "STANDBY" },
+	{ FANSATCUplinkMsgElementId_PR_uM2NULL, "REQUEST DEFERRED" },
+	{ FANSATCUplinkMsgElementId_PR_uM3NULL, "ROGER" },
+	{ FANSATCUplinkMsgElementId_PR_uM4NULL, "AFFIRM" },
+	{ FANSATCUplinkMsgElementId_PR_uM5NULL, "NEGATIVE" },
+	{ FANSATCUplinkMsgElementId_PR_uM6Altitude, "EXPECT [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM7Time, "EXPECT CLIMB AT [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM8Position, "EXPECT CLIMB AT [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM9Time, "EXPECT DESCENT AT [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM10Position, "EXPECT DESCENT AT [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM11Time, "EXPECT CRUISE CLIMB AT [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM12Position, "EXPECT CRUISE CLIMB AT [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM13TimeAltitude, "AT [time] EXPECT CLIMB TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM14PositionAltitude, "AT [position] EXPECT CLIMB TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM15TimeAltitude, "AT [time] EXPECT DESCENT TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM16PositionAltitude, "AT [position] EXPECT DESCENT TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM17TimeAltitude, "AT [time] EXPECT CRUISE CLIMB TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM18PositionAltitude, "AT [position] EXPECT CRUISE CLIMB TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM19Altitude, "MAINTAIN [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM20Altitude, "CLIMB TO AND MAINTAIN [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM21TimeAltitude, "AT [time] CLIMB TO AND MAINTAIN [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM22PositionAltitude, "AT [position] CLIMB TO AND MAINTAIN [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM23Altitude, "DESCEND TO AND MAINTAIN [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM24TimeAltitude, "AT [time] DESCEND TO AND MAINTAIN [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM25PositionAltitude, "AT [position] DESCEND TO AND MAINTAIN [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM26AltitudeTime, "CLIMB TO REACH [altitude] BY [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM27AltitudePosition, "CLIMB TO REACH [altitude] BY [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM28AltitudeTime, "DESCEND TO REACH [altitude] BY [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM29AltitudePosition, "DESCEND TO REACH [altitude] BY [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM30AltitudeAltitude, "MAINTAIN BLOCK [altitude] TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM31AltitudeAltitude, "CLIMB TO AND MAINTAIN BLOCK [altitude] TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM32AltitudeAltitude, "DESCEND TO AND MAINTAIN BLOCK [altitude] TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM33Altitude, "CRUISE [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM34Altitude, "CRUISE CLIMB TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM35Altitude, "CRUISE CLIMB ABOVE [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM36Altitude, "EXPEDITE CLIMB TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM37Altitude, "EXPEDITE DESCENT TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM38Altitude, "IMMEDIATELY CLIMB TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM39Altitude, "IMMEDIATELY DESCEND TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM40Altitude, "IMMEDIATELY STOP CLIMB AT [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM41Altitude, "IMMEDIATELY STOP DESCENT AT [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM42PositionAltitude, "EXPECT TO CROSS [position] AT [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM43PositionAltitude, "EXPECT TO CROSS [position] AT OR ABOVE [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM44PositionAltitude, "EXPECT TO CROSS [position] AT OR BELOW [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM45PositionAltitude, "EXPECT TO CROSS [position] AT AND MAINTAIN [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM46PositionAltitude, "CROSS [position] AT [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM47PositionAltitude, "CROSS [position] AT OR ABOVE [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM48PositionAltitude, "CROSS [position] AT OR BELOW [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM49PositionAltitude, "CROSS [position] AT AND MAINTAIN [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM50PositionAltitudeAltitude, "CROSS [position] BETWEEN [altitude] AND [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM51PositionTime, "CROSS [position] AT [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM52PositionTime, "CROSS [position] AT OR BEFORE [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM53PositionTime, "CROSS [position] AT OR AFTER [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM54PositionTimeTime, "CROSS [position] BETWEEN [time] AND [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM55PositionSpeed, "CROSS [position] AT [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM56PositionSpeed, "CROSS [position] AT OR LESS THAN [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM57PositionSpeed, "CROSS [position] AT OR GREATER THAN [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM58PositionTimeAltitude, "CROSS [position] AT [time] AT [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM59PositionTimeAltitude, "CROSS [position] AT OR BEFORE [time] AT [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM60PositionTimeAltitude, "CROSS [position] AT OR AFTER [time] AT [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM61PositionAltitudeSpeed, "CROSS [position] AT AND MAINTAIN [altitude] AT [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM62TimePositionAltitude, "AT [time] CROSS [position] AT AND MAINTAIN [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM63TimePositionAltitudeSpeed, "AT [time] CROSS [position] AT AND MAINTAIN [altitude] AT [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM64DistanceOffsetDirection, "OFFSET [distanceoffset] [direction] OF ROUTE" },
+	{ FANSATCUplinkMsgElementId_PR_uM65PositionDistanceOffsetDirection, "AT [position] OFFSET [distanceoffset] [direction] OF ROUTE" },
+	{ FANSATCUplinkMsgElementId_PR_uM66TimeDistanceOffsetDirection, "AT [time] OFFSET [distanceoffset] [direction] OF ROUTE" },
+	{ FANSATCUplinkMsgElementId_PR_uM67NULL, "PROCEED BACK ON ROUTE" },
+	{ FANSATCUplinkMsgElementId_PR_uM68Position, "REJOIN ROUTE BY [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM69Time, "REJOIN ROUTE BY [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM70Position, "EXPECT BACK ON ROUTE BY [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM71Time, "EXPECT BACK ON ROUTE BY [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM72NULL, "RESUME OWN NAVIGATION" },
+	{ FANSATCUplinkMsgElementId_PR_uM73Predepartureclearance, "[predepartureclearance]" },
+	{ FANSATCUplinkMsgElementId_PR_uM74Position, "PROCEED DIRECT TO [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM75Position, "WHEN ABLE PROCEED DIRECT TO [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM76TimePosition, "AT [time] PROCEED DIRECT TO [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM77PositionPosition, "AT [position] PROCEED DIRECT TO [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM78AltitudePosition, "AT [altitude] PROCEED DIRECT TO [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM79PositionRouteClearance, "CLEARED TO [position] VIA [routeclearance]" },
+	{ FANSATCUplinkMsgElementId_PR_uM80RouteClearance, "CLEARED [routeclearance]" },
+	{ FANSATCUplinkMsgElementId_PR_uM81ProcedureName, "CLEARED [procedurename]" },
+	{ FANSATCUplinkMsgElementId_PR_uM82DistanceOffsetDirection, "CLEARED TO DEVIATE UP TO [distanceoffset] [direction] OF ROUTE" },
+	{ FANSATCUplinkMsgElementId_PR_uM83PositionRouteClearance, "AT [position] CLEARED [routeclearance]" },
+	{ FANSATCUplinkMsgElementId_PR_uM84PositionProcedureName, "AT [position] CLEARED [procedurename]" },
+	{ FANSATCUplinkMsgElementId_PR_uM85RouteClearance, "EXPECT [routeclearance]" },
+	{ FANSATCUplinkMsgElementId_PR_uM86PositionRouteClearance, "AT [position] EXPECT [routeclearance]" },
+	{ FANSATCUplinkMsgElementId_PR_uM87Position, "EXPECT DIRECT TO [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM88PositionPosition, "AT [position] EXPECT DIRECT TO [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM89TimePosition, "AT [time] EXPECT DIRECT TO [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM90AltitudePosition, "AT [altitude] EXPECT DIRECT TO [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM91HoldClearance, "HOLD AT [position] MAINTAIN [altitude] INBOUND TRACK [degrees] [direction] TURNS [legtype]" },
+	{ FANSATCUplinkMsgElementId_PR_uM92PositionAltitude, "HOLD AT [position] AS PUBLISHED MAINTAIN [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM93Time, "EXPECT FURTHER CLEARANCE AT [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM94DirectionDegrees, "TURN [direction] HEADING [degrees]" },
+	{ FANSATCUplinkMsgElementId_PR_uM95DirectionDegrees, "TURN [direction] GROUND TRACK [degrees]" },
+	{ FANSATCUplinkMsgElementId_PR_uM96NULL, "FLY PRESENT HEADING" },
+	{ FANSATCUplinkMsgElementId_PR_uM97PositionDegrees, "AT [position] FLY HEADING [degrees]" },
+	{ FANSATCUplinkMsgElementId_PR_uM98DirectionDegrees, "IMMEDIATELY TURN [direction] HEADING [degrees]" },
+	{ FANSATCUplinkMsgElementId_PR_uM99ProcedureName, "EXPECT [procedurename]" },
+	{ FANSATCUplinkMsgElementId_PR_uM100TimeSpeed, "AT [time] EXPECT [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM101PositionSpeed, "AT [position] EXPECT [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM102AltitudeSpeed, "AT [altitude] EXPECT [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM103TimeSpeedSpeed, "AT [time] EXPECT [speed] TO [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM104PositionSpeedSpeed, "AT [position] EXPECT [speed] TO [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM105AltitudeSpeedSpeed, "AT [altitude] EXPECT [speed] TO [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM106Speed, "MAINTAIN [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM107NULL, "MAINTAIN PRESENT SPEED" },
+	{ FANSATCUplinkMsgElementId_PR_uM108Speed, "MAINTAIN [speed] OR GREATER" },
+	{ FANSATCUplinkMsgElementId_PR_uM109Speed, "MAINTAIN [speed] OR LESS" },
+	{ FANSATCUplinkMsgElementId_PR_uM110SpeedSpeed, "MAINTAIN [speed] TO [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM111Speed, "INCREASE SPEED TO [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM112Speed, "INCREASE SPEED TO [speed] OR GREATER" },
+	{ FANSATCUplinkMsgElementId_PR_uM113Speed, "REDUCE SPEED TO [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM114Speed, "REDUCE SPEED TO [speed] OR LESS" },
+	{ FANSATCUplinkMsgElementId_PR_uM115Speed, "DO NOT EXCEED [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM116NULL, "RESUME NORMAL SPEED" },
+	{ FANSATCUplinkMsgElementId_PR_uM117ICAOunitnameFrequency, "CONTACT [icaounitname] [frequency]" },
+	{ FANSATCUplinkMsgElementId_PR_uM118PositionICAOunitnameFrequency, "AT [position] CONTACT [icaounitname] [frequency]" },
+	{ FANSATCUplinkMsgElementId_PR_uM119TimeICAOunitnameFrequency, "AT [time] CONTACT [icaounitname] [frequency]" },
+	{ FANSATCUplinkMsgElementId_PR_uM120ICAOunitnameFrequency, "MONITOR [icaounitname] [frequency]" },
+	{ FANSATCUplinkMsgElementId_PR_uM121PositionICAOunitnameFrequency, "AT [position] MONITOR [icaounitname] [frequency]" },
+	{ FANSATCUplinkMsgElementId_PR_uM122TimeICAOunitnameFrequency, "AT [time] MONITOR [icaounitname] [frequency]" },
+	{ FANSATCUplinkMsgElementId_PR_uM123BeaconCode, "SQUAWK [beaconcode]" },
+	{ FANSATCUplinkMsgElementId_PR_uM124NULL, "STOP SQUAWK" },
+	{ FANSATCUplinkMsgElementId_PR_uM125NULL, "SQUAWK ALTITUDE" },
+	{ FANSATCUplinkMsgElementId_PR_uM126NULL, "STOP ALTITUDE SQUAWK" },
+	{ FANSATCUplinkMsgElementId_PR_uM127NULL, "REPORT BACK ON ROUTE" },
+	{ FANSATCUplinkMsgElementId_PR_uM128Altitude, "REPORT LEAVING [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM129Altitude, "REPORT LEVEL [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM130Position, "REPORT PASSING [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM131NULL, "REPORT REMAINING FUEL AND SOULS ON BOARD" },
+	{ FANSATCUplinkMsgElementId_PR_uM132NULL, "CONFIRM POSITION" },
+	{ FANSATCUplinkMsgElementId_PR_uM133NULL, "CONFIRM ALTITUDE" },
+	{ FANSATCUplinkMsgElementId_PR_uM134NULL, "CONFIRM SPEED" },
+	{ FANSATCUplinkMsgElementId_PR_uM135NULL, "CONFIRM ASSIGNED ALTITUDE" },
+	{ FANSATCUplinkMsgElementId_PR_uM136NULL, "CONFIRM ASSIGNED SPEED" },
+	{ FANSATCUplinkMsgElementId_PR_uM137NULL, "CONFIRM ASSIGNED ROUTE" },
+	{ FANSATCUplinkMsgElementId_PR_uM138NULL, "CONFIRM TIME OVER REPORTED WAYPOINT" },
+	{ FANSATCUplinkMsgElementId_PR_uM139NULL, "CONFIRM REPORTED WAYPOINT" },
+	{ FANSATCUplinkMsgElementId_PR_uM140NULL, "CONFIRM NEXT WAYPOINT" },
+	{ FANSATCUplinkMsgElementId_PR_uM141NULL, "CONFIRM NEXT WAYPOINT ETA" },
+	{ FANSATCUplinkMsgElementId_PR_uM142NULL, "CONFIRM ENSUING WAYPOINT" },
+	{ FANSATCUplinkMsgElementId_PR_uM143NULL, "CONFIRM REQUEST" },
+	{ FANSATCUplinkMsgElementId_PR_uM144NULL, "CONFIRM SQUAWK" },
+	{ FANSATCUplinkMsgElementId_PR_uM145NULL, "CONFIRM HEADING" },
+	{ FANSATCUplinkMsgElementId_PR_uM146NULL, "CONFIRM GROUND TRACK" },
+	{ FANSATCUplinkMsgElementId_PR_uM147NULL, "REQUEST POSITION REPORT" },
+	{ FANSATCUplinkMsgElementId_PR_uM148Altitude, "WHEN CAN YOU ACCEPT [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM149AltitudePosition, "CAN YOU ACCEPT [altitude] AT [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM150AltitudeTime, "CAN YOU ACCEPT [altitude] AT [time]" },
+	{ FANSATCUplinkMsgElementId_PR_uM151Speed, "WHEN CAN YOU ACCEPT [speed]" },
+	{ FANSATCUplinkMsgElementId_PR_uM152DistanceOffsetDirection, "WHEN CAN YOU ACCEPT [distanceoffset] [direction] OFFSET" },
+	{ FANSATCUplinkMsgElementId_PR_uM153Altimeter, "ALTIMETER [altimeter]" },
+	{ FANSATCUplinkMsgElementId_PR_uM154NULL, "RADAR SERVICES TERMINATED" },
+	{ FANSATCUplinkMsgElementId_PR_uM155Position, "RADAR CONTACT [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM156NULL, "RADAR CONTACT LOST" },
+	{ FANSATCUplinkMsgElementId_PR_uM157Frequency, "CHECK STUCK MICROPHONE [frequency]" },
+	{ FANSATCUplinkMsgElementId_PR_uM158ATISCode, "ATIS [atiscode]" },
+	{ FANSATCUplinkMsgElementId_PR_uM159ErrorInformation, "ERROR [errorinformation]" },
+	{ FANSATCUplinkMsgElementId_PR_uM160ICAOfacilitydesignation, "NEXT DATA AUTHORITY [icaofacilitydesignation]" },
+	{ FANSATCUplinkMsgElementId_PR_uM161NULL, "END SERVICE" },
+	{ FANSATCUplinkMsgElementId_PR_uM162NULL, "SERVICE UNAVAILABLE" },
+	{ FANSATCUplinkMsgElementId_PR_uM163ICAOfacilitydesignationTp4table, "[icaofacilitydesignation] [tp4table]" },
+	{ FANSATCUplinkMsgElementId_PR_uM164NULL, "WHEN READY" },
+	{ FANSATCUplinkMsgElementId_PR_uM165NULL, "THEN" },
+	{ FANSATCUplinkMsgElementId_PR_uM166NULL, "DUE TO TRAFFIC" },
+	{ FANSATCUplinkMsgElementId_PR_uM167NULL, "DUE TO AIRSPACE RESTRICTION" },
+	{ FANSATCUplinkMsgElementId_PR_uM168NULL, "DISREGARD" },
+	{ FANSATCUplinkMsgElementId_PR_uM169FreeText, "[freetext]" },
+	{ FANSATCUplinkMsgElementId_PR_uM170FreeText, "[freetext]" },
+	{ FANSATCUplinkMsgElementId_PR_uM171VerticalRate, "CLIMB AT [verticalrate] MINIMUM" },
+	{ FANSATCUplinkMsgElementId_PR_uM172VerticalRate, "CLIMB AT [verticalrate] MAXIMUM" },
+	{ FANSATCUplinkMsgElementId_PR_uM173VerticalRate, "DESCEND AT [verticalrate] MINIMUM" },
+	{ FANSATCUplinkMsgElementId_PR_uM174VerticalRate, "DESCEND AT [verticalrate] MAXIMUM" },
+	{ FANSATCUplinkMsgElementId_PR_uM175Altitude, "REPORT REACHING [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM176NULL, "MAINTAIN OWN SEPARATION AND VMC" },
+	{ FANSATCUplinkMsgElementId_PR_uM177NULL, "AT PILOTS DISCRETION" },
+	{ FANSATCUplinkMsgElementId_PR_uM178NULL, "[trackdetailmsg-deleted]" },
+	{ FANSATCUplinkMsgElementId_PR_uM179NULL, "SQUAWK IDENT" },
+	{ FANSATCUplinkMsgElementId_PR_uM180AltitudeAltitude, "REPORT REACHING BLOCK [altitude] TO [altitude]" },
+	{ FANSATCUplinkMsgElementId_PR_uM181ToFromPosition, "REPORT DISTANCE [tofrom] [position]" },
+	{ FANSATCUplinkMsgElementId_PR_uM182NULL, "CONFIRM ATIS CODE" },
+	{ 0, NULL }
+};
+
+la_dict const FANSATCDownlinkMsgElementId_labels[] = {
+	{ FANSATCDownlinkMsgElementId_PR_dM0NULL, "WILCO" },
+	{ FANSATCDownlinkMsgElementId_PR_dM1NULL, "UNABLE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM2NULL, "STANDBY" },
+	{ FANSATCDownlinkMsgElementId_PR_dM3NULL, "ROGER" },
+	{ FANSATCDownlinkMsgElementId_PR_dM4NULL, "AFFIRM" },
+	{ FANSATCDownlinkMsgElementId_PR_dM5NULL, "NEGATIVE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM6Altitude, "REQUEST [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM7AltitudeAltitude, "REQUEST BLOCK [altitude] TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM8Altitude, "REQUEST CRUISE CLIMB TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM9Altitude, "REQUEST CLIMB TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM10Altitude, "REQUEST DESCENT TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM11PositionAltitude, "AT [position] REQUEST CLIMB TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM12PositionAltitude, "AT [position] REQUEST DESCENT TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM13TimeAltitude, "AT [time] REQUEST CLIMB TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM14TimeAltitude, "AT [time] REQUEST DESCENT TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM15DistanceOffsetDirection, "REQUEST OFFSET [distanceoffset] [direction] OF ROUTE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM16PositionDistanceOffsetDirection, "AT [position] REQUEST OFFSET [distanceoffset] [direction] OF ROUTE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM17TimeDistanceOffsetDirection, "AT [time] REQUEST OFFSET [distanceoffset] [direction] OF ROUTE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM18Speed, "REQUEST [speed]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM19SpeedSpeed, "REQUEST [speed] TO [speed]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM20NULL, "REQUEST VOICE CONTACT" },
+	{ FANSATCDownlinkMsgElementId_PR_dM21Frequency, "REQUEST VOICE CONTACT [frequency]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM22Position, "REQUEST DIRECT TO [position]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM23ProcedureName, "REQUEST [procedurename]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM24RouteClearance, "REQUEST [routeclearance]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM25NULL, "REQUEST CLEARANCE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM26PositionRouteClearance, "REQUEST WEATHER DEVIATION TO [position] VIA [routeclearance]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM27DistanceOffsetDirection, "REQUEST WEATHER DEVIATION UP TO [distanceoffset] [direction] OF ROUTE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM28Altitude, "LEAVING [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM29Altitude, "CLIMBING TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM30Altitude, "DESCENDING TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM31Position, "PASSING [position]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM32Altitude, "PRESENT ALTITUDE [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM33Position, "PRESENT POSITION [position]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM34Speed, "PRESENT SPEED [speed]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM35Degrees, "PRESENT HEADING [degrees]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM36Degrees, "PRESENT GROUND TRACK [degrees]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM37Altitude, "LEVEL [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM38Altitude, "ASSIGNED ALTITUDE [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM39Speed, "ASSIGNED SPEED [speed]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM40RouteClearance, "ASSIGNED ROUTE [routeclearance]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM41NULL, "BACK ON ROUTE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM42Position, "NEXT WAYPOINT [position]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM43Time, "NEXT WAYPOINT ETA [time]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM44Position, "ENSUING WAYPOINT [position]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM45Position, "REPORTED WAYPOINT [position]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM46Time, "REPORTED WAYPOINT [time]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM47BeaconCode, "SQUAWKING [beaconcode]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM48PositionReport, "POSITION REPORT [positionreport]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM49Speed, "WHEN CAN WE EXPECT [speed]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM50SpeedSpeed, "WHEN CAN WE EXPECT [speed] TO [speed]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM51NULL, "WHEN CAN WE EXPECT BACK ON ROUTE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM52NULL, "WHEN CAN WE EXPECT LOWER ALTITUDE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM53NULL, "WHEN CAN WE EXPECT HIGHER ALTITUDE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM54Altitude, "WHEN CAN WE EXPECT CRUISE CLIMB TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM55NULL, "PAN PAN PAN" },
+	{ FANSATCDownlinkMsgElementId_PR_dM56NULL, "MAYDAY MAYDAY MAYDAY" },
+	{ FANSATCDownlinkMsgElementId_PR_dM57RemainingFuelRemainingSouls, "[remainingfuel] OF FUEL REMAINING AND [remainingsouls] SOULS ON BOARD" },
+	{ FANSATCDownlinkMsgElementId_PR_dM58NULL, "CANCEL EMERGENCY" },
+	{ FANSATCDownlinkMsgElementId_PR_dM59PositionRouteClearance, "DIVERTING TO [position] VIA [routeclearance]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM60DistanceOffsetDirection, "OFFSETTING [distanceoffset] [direction] OF ROUTE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM61Altitude, "DESCENDING TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM62ErrorInformation, "ERROR [errorinformation]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM63NULL, "NOT CURRENT DATA AUTHORITY" },
+	{ FANSATCDownlinkMsgElementId_PR_dM64ICAOfacilitydesignation, "[icaofacilitydesignation]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM65NULL, "DUE TO WEATHER" },
+	{ FANSATCDownlinkMsgElementId_PR_dM66NULL, "DUE TO AIRCRAFT PERFORMANCE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM67FreeText, "[freetext]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM68FreeText, "[freetext]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM69NULL, "REQUEST VMC DESCENT" },
+	{ FANSATCDownlinkMsgElementId_PR_dM70Degrees, "REQUEST HEADING [degrees]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM71Degrees, "REQUEST GROUND TRACK [degrees]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM72Altitude, "REACHING [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM73VersionNumber, "[versionnumber]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM74NULL, "MAINTAIN OWN SEPARATION AND VMC" },
+	{ FANSATCDownlinkMsgElementId_PR_dM75NULL, "AT PILOTS DISCRETION" },
+	{ FANSATCDownlinkMsgElementId_PR_dM76AltitudeAltitude, "REACHING BLOCK [altitude] TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM77AltitudeAltitude, "ASSIGNED BLOCK [altitude] TO [altitude]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM78TimeDistanceToFromPosition, "AT [time] [distance] [tofrom] [position]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM79ATISCode, "ATIS [atiscode]" },
+	{ FANSATCDownlinkMsgElementId_PR_dM80DistanceOffsetDirection, "DEVIATING [distanceoffset][direction] OF ROUTE" },
+	{ FANSATCDownlinkMsgElementId_PR_dM81NULL, "(reserved: dM81NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM82NULL, "(reserved: dM82NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM83NULL, "(reserved: dM83NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM84NULL, "(reserved: dM84NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM85NULL, "(reserved: dM85NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM86NULL, "(reserved: dM86NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM87NULL, "(reserved: dM87NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM88NULL, "(reserved: dM88NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM89NULL, "(reserved: dM89NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM90NULL, "(reserved: dM90NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM91NULL, "(reserved: dM91NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM92NULL, "(reserved: dM92NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM93NULL, "(reserved: dM93NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM94NULL, "(reserved: dM94NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM95NULL, "(reserved: dM95NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM96NULL, "(reserved: dM96NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM97NULL, "(reserved: dM97NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM98NULL, "(reserved: dM98NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM99NULL, "(reserved: dM99NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM100NULL, "(reserved: dM100NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM101NULL, "(reserved: dM101NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM102NULL, "(reserved: dM102NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM103NULL, "(reserved: dM103NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM104NULL, "(reserved: dM104NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM105NULL, "(reserved: dM105NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM106NULL, "(reserved: dM106NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM107NULL, "(reserved: dM107NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM108NULL, "(reserved: dM108NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM109NULL, "(reserved: dM109NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM110NULL, "(reserved: dM110NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM111NULL, "(reserved: dM111NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM112NULL, "(reserved: dM112NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM113NULL, "(reserved: dM113NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM114NULL, "(reserved: dM114NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM115NULL, "(reserved: dM115NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM116NULL, "(reserved: dM116NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM117NULL, "(reserved: dM117NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM118NULL, "(reserved: dM118NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM119NULL, "(reserved: dM119NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM120NULL, "(reserved: dM120NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM121NULL, "(reserved: dM121NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM122NULL, "(reserved: dM122NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM123NULL, "(reserved: dM123NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM124NULL, "(reserved: dM124NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM125NULL, "(reserved: dM125NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM126NULL, "(reserved: dM126NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM127NULL, "(reserved: dM127NULL)" },
+	{ FANSATCDownlinkMsgElementId_PR_dM128NULL, "(reserved: dM128NULL)" },
+	{ 0, NULL }
+};
+
+/************************
+ * ASN.1 type formatters
+ ************************/
+
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_output_cpdlc_as_text) {
+	la_asn1_output(p, la_asn1_cpdlc_text_formatter_table, la_asn1_cpdlc_text_formatter_table_len, true);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_CHOICE_cpdlc_as_text) {
+	la_format_CHOICE_as_text(p, NULL, la_asn1_output_cpdlc_as_text);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_SEQUENCE_cpdlc_as_text) {
+	la_format_SEQUENCE_as_text(p, la_asn1_output_cpdlc_as_text);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_SEQUENCE_OF_cpdlc_as_text) {
+	la_format_SEQUENCE_OF_as_text(p, la_asn1_output_cpdlc_as_text);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSAltimeterEnglish_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " inHg", 0.01, 2);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSAltimeterMetric_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " hPa", 0.1, 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSAltitudeGNSSFeet_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " ft", 1, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSAltitudeFlightLevelMetric_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " m", 10, 0);
+}
+
+LA_ASN1_FORMATTER_FUNC(la_asn1_format_Degrees_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " deg", 1, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSDistanceOffsetNm_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " nm", 1, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSDistanceMetric_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " km", 1, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSFeetX10_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " ft", 10, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSFrequencyhf_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " kHz", 1, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSFrequencykHzToMHz_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " MHz", 0.001, 3);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSDistanceEnglish_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " nm", 0.1, 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSLegTime_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " min", 0.1, 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSMeters_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " m", 1, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSTemperatureC_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " C", 1, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSTemperatureF_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " F", 1, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSWindSpeedEnglish_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " kts", 1, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSWindSpeedMetric_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " km/h", 1, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSRTATolerance_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " min", 0.1, 1);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSSpeedEnglishX10_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " kts", 10, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSSpeedMetricX10_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " km/h", 10, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSSpeedMach_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, "", 0.01, 2);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSVerticalRateEnglish_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " ft/min", 100, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSVerticalRateMetric_as_text) {
+	la_format_INTEGER_with_unit_as_text(p, " m/min", 10, 0);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSBeaconCode_as_text) {
+	FANSBeaconCode_t const *code = p.sptr;
+	long **cptr = code->list.array;
+	LA_ISPRINTF(p.vstr, p.indent, "%s: %ld%ld%ld%ld\n",
+			p.label,
+			*cptr[0],
+			*cptr[1],
+			*cptr[2],
+			*cptr[3]
+			);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSTime_as_text) {
+	FANSTime_t const *t = p.sptr;
+	LA_ISPRINTF(p.vstr, p.indent, "%s: %02ld:%02ld\n", p.label, t->hours, t->minutes);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSTimestamp_as_text) {
+	FANSTimestamp_t const *t = p.sptr;
+	LA_ISPRINTF(p.vstr, p.indent, "%s: %02ld:%02ld:%02ld\n", p.label, t->hours, t->minutes, t->seconds);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSLatitude_as_text) {
+	FANSLatitude_t const *lat = p.sptr;
+	long const ldir = lat->latitudeDirection;
+	char const *ldir_name = la_asn1_value2enum(&asn_DEF_FANSLatitudeDirection, ldir);
+	if(lat->minutesLatLon != NULL) {
+		LA_ISPRINTF(p.vstr, p.indent, "%s:   %02ld %04.1f' %s\n",
+				p.label,
+				lat->latitudeDegrees,
+				*(long const *)(lat->minutesLatLon) / 10.0,
+				ldir_name
+				);
+	} else {
+		LA_ISPRINTF(p.vstr, p.indent, "%s:   %02ld deg %s\n",
+				p.label,
+				lat->latitudeDegrees,
+				ldir_name
+				);
+	}
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSLongitude_as_text) {
+	FANSLongitude_t const *lat = p.sptr;
+	long const ldir = lat->longitudeDirection;
+	char const *ldir_name = la_asn1_value2enum(&asn_DEF_FANSLongitudeDirection, ldir);
+	if(lat->minutesLatLon != NULL) {
+		LA_ISPRINTF(p.vstr, p.indent, "%s: %03ld %04.1f' %s\n",
+				p.label,
+				lat->longitudeDegrees,
+				*(long const *)(lat->minutesLatLon) / 10.0,
+				ldir_name
+				);
+	} else {
+		LA_ISPRINTF(p.vstr, p.indent, "%s: %03ld deg %s\n",
+				p.label,
+				lat->longitudeDegrees,
+				ldir_name
+				);
+	}
+}
+
+// Can't replace this with la_asn1_format_SEQUENCE_cpdlc_as_text, because the first msg element
+// is not a part of a SEQ-OF, hence we don't have any data type which we could
+// associate "Message data:" label with (nor we can't use FANSATCUplinkMsgElementId
+// for that because the same type is used inside the SEQ-OF which would cause
+// the label to be printed for each element in the sequence). The same applies
+// to la_asn1_format_FANSATCDownlinkMessage_as_text.
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSATCUplinkMessage_as_text) {
+	FANSATCUplinkMessage_t const *msg = p.sptr;
+	if(p.label != NULL) {
+		LA_ISPRINTF(p.vstr, p.indent, "%s:\n", p.label);
+		p.indent++;
+	}
+	p.td = &asn_DEF_FANSATCMessageHeader;
+	p.sptr = &msg->aTCMessageheader;
+	la_asn1_output_cpdlc_as_text(p);
+	LA_ISPRINTF(p.vstr, p.indent, "Message data:\n");
+	p.indent++;
+	p.td = &asn_DEF_FANSATCUplinkMsgElementId;
+	p.sptr = &msg->aTCuplinkmsgelementId;
+	la_asn1_output_cpdlc_as_text(p);
+	if(msg->aTCuplinkmsgelementid_seqOf != NULL) {
+		p.td = &asn_DEF_FANSATCUplinkMsgElementIdSequence;
+		p.sptr = msg->aTCuplinkmsgelementid_seqOf;
+		la_asn1_output_cpdlc_as_text(p);
+	}
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSATCDownlinkMessage_as_text) {
+	FANSATCDownlinkMessage_t const *msg = p.sptr;
+	if(p.label != NULL) {
+		LA_ISPRINTF(p.vstr, p.indent, "%s:\n", p.label);
+		p.indent++;
+	}
+	p.td = &asn_DEF_FANSATCMessageHeader;
+	p.sptr = &msg->aTCMessageheader;
+	la_asn1_output_cpdlc_as_text(p);
+	LA_ISPRINTF(p.vstr, p.indent, "Message data:\n");
+	p.indent++;
+	p.td = &asn_DEF_FANSATCDownlinkMsgElementId;
+	p.sptr = &msg->aTCDownlinkmsgelementid;
+	la_asn1_output_cpdlc_as_text(p);
+	if(msg->aTCdownlinkmsgelementid_seqOf != NULL) {
+		p.td = &asn_DEF_FANSATCDownlinkMsgElementIdSequence;
+		p.sptr = msg->aTCdownlinkmsgelementid_seqOf;
+		la_asn1_output_cpdlc_as_text(p);
+	}
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSATCDownlinkMsgElementId_as_text) {
+	la_format_CHOICE_as_text(p, FANSATCDownlinkMsgElementId_labels, la_asn1_output_cpdlc_as_text);
+}
+
+static LA_ASN1_FORMATTER_FUNC(la_asn1_format_FANSATCUplinkMsgElementId_as_text) {
+	la_format_CHOICE_as_text(p, FANSATCUplinkMsgElementId_labels, la_asn1_output_cpdlc_as_text);
+}
+
+static la_asn1_formatter const la_asn1_cpdlc_text_formatter_table[209] = {
+	{ .type = &asn_DEF_FANSAircraftEquipmentCode, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSAircraftFlightIdentification, .format = la_asn1_format_any_as_text, .label = "Flight ID" },
+	{ .type = &asn_DEF_FANSAircraftType, .format = la_asn1_format_any_as_text, .label = "Aircraft type" },
+	{ .type = &asn_DEF_FANSAirport, .format = la_asn1_format_any_as_text, .label = "Airport" },
+	{ .type = &asn_DEF_FANSAirportDeparture, .format = la_asn1_format_any_as_text, .label = "Departure airport" },
+	{ .type = &asn_DEF_FANSAirportDestination, .format = la_asn1_format_any_as_text, .label = "Destination airport" },
+	{ .type = &asn_DEF_FANSAirwayIdentifier, .format = la_asn1_format_any_as_text, .label = "Airway ID" },
+	{ .type = &asn_DEF_FANSAirwayIntercept, .format = la_asn1_format_any_as_text, .label = "Airway intercept" },
+	{ .type = &asn_DEF_FANSAltimeter, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSAltimeterEnglish, .format = la_asn1_format_FANSAltimeterEnglish_as_text, .label = "Altimeter" },
+	{ .type = &asn_DEF_FANSAltimeterMetric, .format = la_asn1_format_FANSAltimeterMetric_as_text, .label = "Altimeter" },
+	{ .type = &asn_DEF_FANSAltitude, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSAltitudeAltitude, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSAltitudeFlightLevel, .format = la_asn1_format_any_as_text, .label = "Flight level" },
+	{ .type = &asn_DEF_FANSAltitudeFlightLevelMetric, .format = la_asn1_format_FANSAltitudeFlightLevelMetric_as_text, .label = "Flight level" },
+	{ .type = &asn_DEF_FANSAltitudeGNSSFeet, .format = la_asn1_format_FANSAltitudeGNSSFeet_as_text, .label = "Altitude (GNSS)" },
+	{ .type = &asn_DEF_FANSAltitudeGNSSMeters, .format = la_asn1_format_FANSMeters_as_text, .label = "Altitude (GNSS)" },
+	{ .type = &asn_DEF_FANSAltitudePosition, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSAltitudeQFE, .format = la_asn1_format_FANSFeetX10_as_text, .label = "Altitude (QFE)" },
+	{ .type = &asn_DEF_FANSAltitudeQFEMeters, .format = la_asn1_format_FANSMeters_as_text, .label = "Altitude (QFE)" },
+	{ .type = &asn_DEF_FANSAltitudeQNH, .format = la_asn1_format_FANSFeetX10_as_text, .label = "Altitude (QNH)" },
+	{ .type = &asn_DEF_FANSAltitudeQNHMeters, .format = la_asn1_format_FANSMeters_as_text, .label = "Altitude (QNH)" },
+	{ .type = &asn_DEF_FANSAltitudeRestriction, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = "Altitude restriction" },
+	{ .type = &asn_DEF_FANSAltitudeSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSAltitudeSpeedSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSAltitudeTime, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSATCDownlinkMessage, .format = la_asn1_format_FANSATCDownlinkMessage_as_text, .label = "CPDLC Downlink Message" },
+	{ .type = &asn_DEF_FANSATCDownlinkMsgElementId, .format = la_asn1_format_FANSATCDownlinkMsgElementId_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSATCDownlinkMsgElementIdSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSATCMessageHeader, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = "Header" },
+	{ .type = &asn_DEF_FANSATCUplinkMessage, .format = la_asn1_format_FANSATCUplinkMessage_as_text, .label = "CPDLC Uplink Message" },
+	{ .type = &asn_DEF_FANSATCUplinkMsgElementId, .format = la_asn1_format_FANSATCUplinkMsgElementId_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSATCUplinkMsgElementIdSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSATISCode, .format = la_asn1_format_any_as_text, .label = "ATIS code" },
+	{ .type = &asn_DEF_FANSATWAlongTrackWaypoint, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSATWAlongTrackWaypointSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = "Along-track waypoints" },
+	{ .type = &asn_DEF_FANSATWAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSATWAltitudeSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSATWAltitudeTolerance, .format = la_asn1_format_ENUM_as_text, .label = "ATW altitude tolerance" },
+	{ .type = &asn_DEF_FANSATWDistance, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSATWDistanceTolerance, .format = la_asn1_format_ENUM_as_text, .label = "ATW distance tolerance" },
+	{ .type = &asn_DEF_FANSBeaconCode, .format = la_asn1_format_FANSBeaconCode_as_text, .label = "Code" },
+	{ .type = &asn_DEF_FANSCOMNAVApproachEquipmentAvailable, .format = la_asn1_format_any_as_text, .label = "COMM/NAV/Approach equipment available" },
+	{ .type = &asn_DEF_FANSCOMNAVEquipmentStatus, .format = la_asn1_format_ENUM_as_text, .label = "COMM/NAV equipment status" },
+	{ .type = &asn_DEF_FANSCOMNAVEquipmentStatusSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = "COMM/NAV Equipment status list" },
+	{ .type = &asn_DEF_FANSDegreeIncrement, .format = la_asn1_format_Degrees_as_text, .label = "Degree increment" },
+	{ .type = &asn_DEF_FANSDegrees, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSDegreesMagnetic, .format = la_asn1_format_Degrees_as_text, .label = "Degrees (magnetic)" },
+	{ .type = &asn_DEF_FANSDegreesTrue, .format = la_asn1_format_Degrees_as_text, .label = "Degrees (true)" },
+	{ .type = &asn_DEF_FANSDirection, .format = la_asn1_format_ENUM_as_text, .label = "Direction" },
+	{ .type = &asn_DEF_FANSDirectionDegrees, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSDistance, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSDistanceKm, .format = la_asn1_format_FANSDistanceMetric_as_text, .label = "Distance" },
+	{ .type = &asn_DEF_FANSDistanceNm, .format = la_asn1_format_FANSDistanceEnglish_as_text, .label = "Distance" },
+	{ .type = &asn_DEF_FANSDistanceOffset, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSDistanceOffsetDirection, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSDistanceOffsetKm, .format = la_asn1_format_FANSDistanceMetric_as_text, .label = "Offset" },
+	{ .type = &asn_DEF_FANSDistanceOffsetNm, .format = la_asn1_format_FANSDistanceOffsetNm_as_text, .label = "Offset" },
+	{ .type = &asn_DEF_FANSEFCtime, .format = la_asn1_format_FANSTime_as_text, .label = "Expect further clearance at" },
+	{ .type = &asn_DEF_FANSErrorInformation, .format = la_asn1_format_ENUM_as_text, .label = "Error information" },
+	{ .type = &asn_DEF_FANSFixName, .format = la_asn1_format_any_as_text, .label = "Fix" },
+	{ .type = &asn_DEF_FANSFixNext, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = "Next fix" },
+	{ .type = &asn_DEF_FANSFixNextPlusOne, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = "Next+1 fix" },
+	{ .type = &asn_DEF_FANSFreeText, .format = la_asn1_format_any_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSFrequency, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSFrequencyDeparture, .format = la_asn1_format_FANSFrequencykHzToMHz_as_text, .label = "Departure frequency" },
+	{ .type = &asn_DEF_FANSFrequencyhf, .format = la_asn1_format_FANSFrequencyhf_as_text, .label = "HF" },
+	{ .type = &asn_DEF_FANSFrequencysatchannel, .format = la_asn1_format_any_as_text, .label = "Satcom channel" },
+	{ .type = &asn_DEF_FANSFrequencyuhf, .format = la_asn1_format_FANSFrequencykHzToMHz_as_text, .label = "UHF" },
+	{ .type = &asn_DEF_FANSFrequencyvhf, .format = la_asn1_format_FANSFrequencykHzToMHz_as_text, .label = "VHF" },
+	{ .type = &asn_DEF_FANSHoldatwaypoint, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSHoldatwaypointSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = "Holding points" },
+	{ .type = &asn_DEF_FANSHoldatwaypointSpeedHigh, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = "Holding speed (max)" },
+	{ .type = &asn_DEF_FANSHoldatwaypointSpeedLow, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = "Holding speed (min)" },
+	{ .type = &asn_DEF_FANSHoldClearance, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSICAOfacilityDesignation, .format = la_asn1_format_any_as_text, .label = "Facility designation" },
+	{ .type = &asn_DEF_FANSICAOFacilityDesignationTp4Table, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSICAOFacilityFunction, .format = la_asn1_format_ENUM_as_text, .label = "Facility function" },
+	{ .type = &asn_DEF_FANSICAOFacilityIdentification, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSICAOFacilityName, .format = la_asn1_format_any_as_text, .label = "Facility Name" },
+	{ .type = &asn_DEF_FANSICAOUnitName, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSICAOUnitNameFrequency, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSIcing, .format = la_asn1_format_ENUM_as_text, .label = "Icing" },
+	{ .type = &asn_DEF_FANSInterceptCourseFrom, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSInterceptCourseFromSelection, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSInterceptCourseFromSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = "Intercept courses" },
+	{ .type = &asn_DEF_FANSLatitude, .format = la_asn1_format_FANSLatitude_as_text, .label = "Latitude" },
+	{ .type = &asn_DEF_FANSLatitudeDegrees, .format = la_asn1_format_Degrees_as_text, .label = "Latitude" },
+	{ .type = &asn_DEF_FANSLatitudeDirection, .format = la_asn1_format_ENUM_as_text, .label = "Direction" },
+	{ .type = &asn_DEF_FANSLatitudeLongitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSLatitudeLongitudeSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = "Coordinate list" },
+	{ .type = &asn_DEF_FANSLatitudeReportingPoints, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSLatLonReportingPoints, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSLegDistance, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSLegDistanceEnglish, .format = la_asn1_format_FANSDistanceEnglish_as_text, .label = "Leg distance" },
+	{ .type = &asn_DEF_FANSLegDistanceMetric, .format = la_asn1_format_FANSDistanceMetric_as_text, .label = "Leg distance" },
+	{ .type = &asn_DEF_FANSLegTime, .format = la_asn1_format_FANSLegTime_as_text, .label = "Leg time" },
+	{ .type = &asn_DEF_FANSLegType, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSLongitude, .format = la_asn1_format_FANSLongitude_as_text, .label = "Longitude" },
+	{ .type = &asn_DEF_FANSLongitudeDegrees, .format = la_asn1_format_Degrees_as_text, .label = "Longitude" },
+	{ .type = &asn_DEF_FANSLongitudeDirection, .format = la_asn1_format_ENUM_as_text, .label = "Direction" },
+	{ .type = &asn_DEF_FANSLongitudeReportingPoints, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSMsgIdentificationNumber, .format = la_asn1_format_any_as_text, .label = "Msg ID" },
+	{ .type = &asn_DEF_FANSMsgReferenceNumber, .format = la_asn1_format_any_as_text, .label = "Msg Ref" },
+	{ .type = &asn_DEF_FANSNavaid, .format = la_asn1_format_any_as_text, .label = "Navaid" },
+	{ .type = &asn_DEF_FANSPDCrevision, .format = la_asn1_format_any_as_text, .label = "Revision number" },
+	{ .type = &asn_DEF_FANSPlaceBearing, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPlaceBearingDistance, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPlaceBearingPlaceBearing, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPosition, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionAltitudeAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionAltitudeSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionCurrent, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionDegrees, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionDistanceOffsetDirection, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionICAOUnitNameFrequency, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionPosition, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionProcedureName, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionReport, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionRouteClearance, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionSpeedSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionTime, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionTimeAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPositionTimeTime, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSPredepartureClearance, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSProcedure, .format = la_asn1_format_any_as_text, .label = "Procedure name" },
+	{ .type = &asn_DEF_FANSProcedureApproach, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = "Approach procedure" },
+	{ .type = &asn_DEF_FANSProcedureArrival, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = "Arrival procedure" },
+	{ .type = &asn_DEF_FANSProcedureDeparture, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = "Departure procedure" },
+	{ .type = &asn_DEF_FANSProcedureName, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSProcedureTransition, .format = la_asn1_format_any_as_text, .label = "Procedure transition" },
+	{ .type = &asn_DEF_FANSProcedureType, .format = la_asn1_format_ENUM_as_text, .label = "Procedure type" },
+	{ .type = &asn_DEF_FANSPublishedIdentifier, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = "Published identifier" },
+	{ .type = &asn_DEF_FANSRemainingFuel, .format = la_asn1_format_FANSTime_as_text, .label = "Remaining fuel" },
+	{ .type = &asn_DEF_FANSRemainingFuelRemainingSouls, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSRemainingSouls, .format = la_asn1_format_any_as_text, .label = "Persons on board" },
+	{ .type = &asn_DEF_FANSReportedWaypointAltitude, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = "Reported waypoint altitude" },
+	{ .type = &asn_DEF_FANSReportedWaypointPosition, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = "Reported waypoint position" },
+	{ .type = &asn_DEF_FANSReportedWaypointTime, .format = la_asn1_format_FANSTime_as_text, .label = "Reported waypoint time" },
+	{ .type = &asn_DEF_FANSReportingPoints, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSRouteClearance, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSRouteInformation, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSRouteInformationAdditional, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSRouteInformationSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = "Route" },
+	{ .type = &asn_DEF_FANSRTARequiredTimeArrival, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSRTARequiredTimeArrivalSequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = "Required arrival times" },
+	{ .type = &asn_DEF_FANSRTATime, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSRTATolerance, .format = la_asn1_format_FANSRTATolerance_as_text, .label = "RTA tolerance" },
+	{ .type = &asn_DEF_FANSRunway, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSRunwayArrival, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = "Arrival runway" },
+	{ .type = &asn_DEF_FANSRunwayConfiguration, .format = la_asn1_format_ENUM_as_text, .label = "Runway configuration" },
+	{ .type = &asn_DEF_FANSRunwayDeparture, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = "Departure runway" },
+	{ .type = &asn_DEF_FANSRunwayDirection, .format = la_asn1_format_any_as_text, .label = "Runway direction" },
+	{ .type = &asn_DEF_FANSSpeed, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSSpeedGround, .format = la_asn1_format_FANSSpeedEnglishX10_as_text, .label = "Ground speed" },
+	{ .type = &asn_DEF_FANSSpeedGroundMetric, .format = la_asn1_format_FANSSpeedMetricX10_as_text, .label = "Ground speed" },
+	{ .type = &asn_DEF_FANSSpeedIndicated, .format = la_asn1_format_FANSSpeedEnglishX10_as_text, .label = "Indicated airspeed" },
+	{ .type = &asn_DEF_FANSSpeedIndicatedMetric, .format = la_asn1_format_FANSSpeedMetricX10_as_text, .label = "Indicated airspeed" },
+	{ .type = &asn_DEF_FANSSpeedMach, .format = la_asn1_format_FANSSpeedMach_as_text, .label = "Mach number" },
+	{ .type = &asn_DEF_FANSSpeedMachLarge, .format = la_asn1_format_FANSSpeedMach_as_text, .label = "Mach number" },
+	{ .type = &asn_DEF_FANSSpeedSpeed, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSSpeedTrue, .format = la_asn1_format_FANSSpeedEnglishX10_as_text, .label = "True airspeed" },
+	{ .type = &asn_DEF_FANSSpeedTrueMetric, .format = la_asn1_format_FANSSpeedMetricX10_as_text, .label = "True airspeed" },
+	{ .type = &asn_DEF_FANSSSREquipmentAvailable, .format = la_asn1_format_ENUM_as_text, .label = "SSR equipment available" },
+	{ .type = &asn_DEF_FANSSupplementaryInformation, .format = la_asn1_format_any_as_text, .label = "Supplementary information" },
+	{ .type = &asn_DEF_FANSTemperature, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTemperatureC, .format = la_asn1_format_FANSTemperatureC_as_text, .label = "Temperature" },
+	{ .type = &asn_DEF_FANSTemperatureF, .format = la_asn1_format_FANSTemperatureF_as_text, .label = "Temperature" },
+	{ .type = &asn_DEF_FANSTime, .format = la_asn1_format_FANSTime_as_text, .label = "Time" },
+	{ .type = &asn_DEF_FANSTimeAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTimeAtPositionCurrent, .format = la_asn1_format_FANSTime_as_text, .label = "Time at current position" },
+	{ .type = &asn_DEF_FANSTimeDepartureEdct, .format = la_asn1_format_FANSTime_as_text, .label = "Estimated departure time" },
+	{ .type = &asn_DEF_FANSTimeDistanceOffsetDirection, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTimeDistanceToFromPosition, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTimeEtaAtFixNext, .format = la_asn1_format_FANSTime_as_text, .label = "ETA at next fix" },
+	{ .type = &asn_DEF_FANSTimeEtaDestination, .format = la_asn1_format_FANSTime_as_text, .label = "ETA at destination" },
+	{ .type = &asn_DEF_FANSTimeICAOunitnameFrequency, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTimePosition, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTimePositionAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTimePositionAltitudeSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTimeSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTimeSpeedSpeed, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTimestamp, .format = la_asn1_format_FANSTimestamp_as_text, .label = "Timestamp" },
+	{ .type = &asn_DEF_FANSTimeTime, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTimeTolerance, .format = la_asn1_format_ENUM_as_text, .label = "Time tolerance" },
+	{ .type = &asn_DEF_FANSToFrom, .format = la_asn1_format_ENUM_as_text, .label = "To/From" },
+	{ .type = &asn_DEF_FANSToFromPosition, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTp4table, .format = la_asn1_format_ENUM_as_text, .label = "TP4 table" },
+	{ .type = &asn_DEF_FANSTrackAngle, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = "Track angle" },
+	{ .type = &asn_DEF_FANSTrackDetail, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSTrackName, .format = la_asn1_format_any_as_text, .label = "Track name" },
+	{ .type = &asn_DEF_FANSTrueheading, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = "True heading" },
+	{ .type = &asn_DEF_FANSTurbulence, .format = la_asn1_format_ENUM_as_text, .label = "Turbulence" },
+	{ .type = &asn_DEF_FANSVersionNumber, .format = la_asn1_format_any_as_text, .label = "Version number" },
+	{ .type = &asn_DEF_FANSVerticalChange, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSVerticalDirection, .format = la_asn1_format_ENUM_as_text, .label = "Vertical direction" },
+	{ .type = &asn_DEF_FANSVerticalRate, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSVerticalRateEnglish, .format = la_asn1_format_FANSVerticalRateEnglish_as_text, .label = "Vertical rate" },
+	{ .type = &asn_DEF_FANSVerticalRateMetric, .format = la_asn1_format_FANSVerticalRateMetric_as_text, .label = "Vertical rate" },
+	{ .type = &asn_DEF_FANSWaypointSpeedAltitude, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSWaypointSpeedAltitudesequence, .format = la_asn1_format_SEQUENCE_OF_cpdlc_as_text, .label = "Waypoints, speeds and altitudes" },
+	{ .type = &asn_DEF_FANSWindDirection, .format = la_asn1_format_Degrees_as_text, .label = "Wind direction" },
+	{ .type = &asn_DEF_FANSWinds, .format = la_asn1_format_SEQUENCE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSWindSpeed, .format = la_asn1_format_CHOICE_cpdlc_as_text, .label = NULL },
+	{ .type = &asn_DEF_FANSWindSpeedEnglish, .format = la_asn1_format_FANSWindSpeedEnglish_as_text, .label = "Wind speed" },
+	{ .type = &asn_DEF_FANSWindSpeedMetric, .format = la_asn1_format_FANSWindSpeedMetric_as_text, .label = "Wind speed" },
+	{ .type = &asn_DEF_NULL, .format = NULL, .label = NULL }
+};
+
+static size_t la_asn1_cpdlc_text_formatter_table_len =
+sizeof(la_asn1_cpdlc_text_formatter_table) / sizeof(la_asn1_formatter);

plugins/inmarsat_support/aero/libacars/asn1-format-cpdlc.h

@@ -0,0 +1,22 @@
+/*
+ *  This file is a part of libacars
+ *
+ *  Copyright (c) 2018-2021 Tomasz Lemiech <szpajder@gmail.com>
+ */
+
+#ifndef LA_ASN1_FORMAT_CPDLC_H
+#define LA_ASN1_FORMAT_CPDLC_H 1
+#include <aero/libacars/asn1/asn_application.h>      // asn_TYPE_descriptor_t
+#include <aero/libacars/vstring.h>                   // la_vstring
+#include <aero/libacars/dict.h>                      // la_dict
+#include <aero/libacars/asn1-util.h>                 // LA_ASN1_FORMATTER_FUNC
+
+// asn1-format-cpdlc-text.c
+LA_ASN1_FORMATTER_FUNC(la_asn1_output_cpdlc_as_text);
+extern la_dict const FANSATCUplinkMsgElementId_labels[];
+extern la_dict const FANSATCDownlinkMsgElementId_labels[];
+
+// asn1-format-cpdlc-json.c
+LA_ASN1_FORMATTER_FUNC(la_asn1_output_cpdlc_as_json);
+
+#endif // !LA_ASN1_FORMAT_CPDLC_H

plugins/inmarsat_support/aero/libacars/asn1-util.c

@@ -0,0 +1,62 @@
+/*
+ *  This file is a part of libacars
+ *
+ *  Copyright (c) 2018-2021 Tomasz Lemiech <szpajder@gmail.com>
+ */
+
+#include <stdint.h>
+#include <search.h>                         // lfind()
+#include <aero/libacars/asn1/asn_application.h>  // asn_TYPE_descriptor_t
+#include <aero/libacars/asn1-util.h>             // la_asn1_formatter
+#include <aero/libacars/macros.h>                // LA_ISPRINTF, la_debug_print
+#include <aero/libacars/vstring.h>               // la_vstring
+#include "config.h"                         // LFIND_NMEMB_SIZE_SIZE_T, LFIND_NMEMB_SIZE_UINT
+
+static int la_compare_fmtr(void const *k, void const *m) {
+	la_asn1_formatter const *memb = m;
+	return(k == memb->type ? 0 : 1);
+}
+
+int la_asn1_decode_as(asn_TYPE_descriptor_t *td, void **struct_ptr, uint8_t const *buf, int size) {
+	asn_dec_rval_t rval;
+	rval = uper_decode_complete(0, td, struct_ptr, buf, size);
+	if(rval.code != RC_OK) {
+		la_debug_print(D_ERROR, "uper_decode_complete failed: %d\n", rval.code);
+		return -1;
+	}
+	if(rval.consumed < (size_t)size) {
+		la_debug_print(D_ERROR, "uper_decode_complete left %zd unparsed octets\n", (size_t)size - rval.consumed);
+		return (int)((size_t)size - rval.consumed);
+	}
+#ifdef DEBUG
+	if(Debug >= D_VERBOSE) {
+		asn_fprint(stderr, td, *struct_ptr, 1);
+	}
+#endif
+	return 0;
+}
+
+void la_asn1_output(la_asn1_formatter_params p, la_asn1_formatter const *asn1_formatter_table,
+		size_t asn1_formatter_table_len, bool dump_unknown_types) {
+	if(p.td == NULL || p.sptr == NULL) return;
+#if defined LFIND_NMEMB_SIZE_SIZE_T
+	size_t table_len = asn1_formatter_table_len;
+#elif defined LFIND_NMEMB_SIZE_UINT
+	unsigned int table_len = (unsigned int)asn1_formatter_table_len;
+#endif
+	la_asn1_formatter *formatter = lfind(p.td, asn1_formatter_table, &table_len,
+			sizeof(la_asn1_formatter), &la_compare_fmtr);
+	if(formatter != NULL) {
+		// NULL formatting routine is allowed - it means the type should be silently omitted
+		if(formatter->format != NULL) {
+			p.label = formatter->label;
+			(*formatter->format)(p);
+		}
+	} else if(dump_unknown_types) {
+		LA_ISPRINTF(p.vstr, p.indent, "-- Formatter for type %s not found, ASN.1 dump follows:\n", p.td->name);
+		LA_ISPRINTF(p.vstr, p.indent, "%s", "");    // asn_sprintf does not indent the first line
+		asn_sprintf(p.vstr, p.td, p.sptr, p.indent+1);
+		LA_EOL(p.vstr);
+		LA_ISPRINTF(p.vstr, p.indent, "%s", "-- ASN.1 dump end\n");
+	}
+}

plugins/inmarsat_support/aero/libacars/asn1-util.h

@@ -0,0 +1,39 @@
+/*
+ *  This file is a part of libacars
+ *
+ *  Copyright (c) 2018-2021 Tomasz Lemiech <szpajder@gmail.com>
+ */
+
+#ifndef LA_ASN1_UTIL_H
+#define LA_ASN1_UTIL_H 1
+#include <stddef.h>                         // size_t
+#include <stdint.h>                         // uint8_t
+#include <aero/libacars/asn1/asn_application.h>  // asn_TYPE_descriptor_t
+#include <aero/libacars/vstring.h>               // la_vstring
+
+// Parameters to the formatter function
+typedef struct {
+	la_vstring *vstr;
+	char const *label;
+	asn_TYPE_descriptor_t *td;
+	void const *sptr;
+	int indent;
+} la_asn1_formatter_params;
+
+// Formatter function prototype
+typedef void (*la_asn1_formatter_func)(la_asn1_formatter_params);
+
+typedef struct {
+	asn_TYPE_descriptor_t *type;
+	la_asn1_formatter_func format;
+	char const *label;
+} la_asn1_formatter;
+
+#define LA_ASN1_FORMATTER_FUNC(x) \
+	void x(la_asn1_formatter_params p)
+
+// asn1-util.c
+int la_asn1_decode_as(asn_TYPE_descriptor_t *td, void **struct_ptr, uint8_t const *buf, int size);
+void la_asn1_output(la_asn1_formatter_params p, la_asn1_formatter const *asn1_formatter_table,
+		size_t asn1_formatter_table_len, bool dump_unknown_types);
+#endif // !LA_ASN1_UTIL_H

plugins/inmarsat_support/aero/libacars/asn1/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 const 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) 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)
+		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) 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) {
+	const char * const 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;
+}
+

plugins/inmarsat_support/aero/libacars/asn1/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_ */

plugins/inmarsat_support/aero/libacars/asn1/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 const 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);
+}

plugins/inmarsat_support/aero/libacars/asn1/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_ */

plugins/inmarsat_support/aero/libacars/asn1/CMakeLists.inc

@@ -0,0 +1,494 @@
+set(ASN_MODULE_HEADERS
+	FANSATCUplinkMessage.h
+	FANSATCUplinkMsgElementIdSequence.h
+	FANSATCMessageHeader.h
+	FANSMsgIdentificationNumber.h
+	FANSMsgReferenceNumber.h
+	FANSTimestamp.h
+	FANSTimehours.h
+	FANSTimeminutes.h
+	FANSTimeSeconds.h
+	FANSATCUplinkMsgElementId.h
+	FANSATCDownlinkMessage.h
+	FANSATCDownlinkMsgElementIdSequence.h
+	FANSATCDownlinkMsgElementId.h
+	FANSAirport.h
+	FANSAltimeter.h
+	FANSAltimeterEnglish.h
+	FANSAltimeterMetric.h
+	FANSAltitude.h
+	FANSAltitudeQNH.h
+	FANSAltitudeQNHMeters.h
+	FANSAltitudeQFE.h
+	FANSAltitudeQFEMeters.h
+	FANSAltitudeGNSSFeet.h
+	FANSAltitudeGNSSMeters.h
+	FANSAltitudeFlightLevel.h
+	FANSAltitudeFlightLevelMetric.h
+	FANSAltitudePosition.h
+	FANSAltitudeAltitude.h
+	FANSAltitudeSpeed.h
+	FANSAltitudeSpeedSpeed.h
+	FANSAltitudeTime.h
+	FANSATISCode.h
+	FANSATWAltitude.h
+	FANSATWAltitudeTolerance.h
+	FANSBeaconCode.h
+	FANSBeaconCodeOctalDigit.h
+	FANSDegrees.h
+	FANSDegreesMagnetic.h
+	FANSDegreesTrue.h
+	FANSDirection.h
+	FANSDirectionDegrees.h
+	FANSDistanceOffset.h
+	FANSDistanceOffsetNm.h
+	FANSDistanceOffsetKm.h
+	FANSDistanceOffsetDirection.h
+	FANSErrorInformation.h
+	FANSFixName.h
+	FANSFreeText.h
+	FANSFrequency.h
+	FANSFrequencyhf.h
+	FANSFrequencyvhf.h
+	FANSFrequencyuhf.h
+	FANSFrequencysatchannel.h
+	FANSHoldClearance.h
+	FANSICAOUnitName.h
+	FANSICAOFacilityIdentification.h
+	FANSICAOfacilityDesignation.h
+	FANSICAOFacilityName.h
+	FANSICAOFacilityFunction.h
+	FANSICAOUnitNameFrequency.h
+	FANSICAOFacilityDesignationTp4Table.h
+	FANSLatitudeLongitude.h
+	FANSLatitudeLongitudeSequence.h
+	FANSLatitude.h
+	FANSLatitudeDegrees.h
+	FANSMinutesLatLon.h
+	FANSLatitudeDirection.h
+	FANSLongitude.h
+	FANSLongitudeDegrees.h
+	FANSLongitudeDirection.h
+	FANSLegType.h
+	FANSLegDistance.h
+	FANSLegDistanceEnglish.h
+	FANSLegDistanceMetric.h
+	FANSLegTime.h
+	FANSPlaceBearingDistance.h
+	FANSDistance.h
+	FANSDistanceNm.h
+	FANSDistanceKm.h
+	FANSPosition.h
+	FANSNavaid.h
+	FANSPositionAltitude.h
+	FANSPositionAltitudeAltitude.h
+	FANSPositionAltitudeSpeed.h
+	FANSPositionDegrees.h
+	FANSPositionDistanceOffsetDirection.h
+	FANSPositionICAOUnitNameFrequency.h
+	FANSPositionPosition.h
+	FANSPositionProcedureName.h
+	FANSPositionReport.h
+	FANSPositionCurrent.h
+	FANSTimeAtPositionCurrent.h
+	FANSFixNext.h
+	FANSTimeEtaAtFixNext.h
+	FANSFixNextPlusOne.h
+	FANSTimeEtaDestination.h
+	FANSTemperature.h
+	FANSTemperatureC.h
+	FANSTemperatureF.h
+	FANSWinds.h
+	FANSWindDirection.h
+	FANSWindSpeed.h
+	FANSWindSpeedEnglish.h
+	FANSWindSpeedMetric.h
+	FANSTurbulence.h
+	FANSIcing.h
+	FANSVerticalChange.h
+	FANSVerticalDirection.h
+	FANSTrackAngle.h
+	FANSTrueheading.h
+	FANSSupplementaryInformation.h
+	FANSReportedWaypointPosition.h
+	FANSReportedWaypointTime.h
+	FANSReportedWaypointAltitude.h
+	FANSPositionRouteClearance.h
+	FANSPositionSpeed.h
+	FANSPositionSpeedSpeed.h
+	FANSPositionTime.h
+	FANSPositionTimeAltitude.h
+	FANSPositionTimeTime.h
+	FANSPredepartureClearance.h
+	FANSAircraftFlightIdentification.h
+	FANSAircraftType.h
+	FANSAircraftEquipmentCode.h
+	FANSCOMNAVApproachEquipmentAvailable.h
+	FANSCOMNAVEquipmentStatus.h
+	FANSCOMNAVEquipmentStatusSequence.h
+	FANSSSREquipmentAvailable.h
+	FANSTimeDepartureEdct.h
+	FANSAltitudeRestriction.h
+	FANSFrequencyDeparture.h
+	FANSPDCrevision.h
+	FANSProcedureName.h
+	FANSProcedureType.h
+	FANSProcedure.h
+	FANSProcedureTransition.h
+	FANSRemainingFuelRemainingSouls.h
+	FANSRemainingFuel.h
+	FANSRemainingSouls.h
+	FANSRouteClearance.h
+	FANSAirportDeparture.h
+	FANSAirportDestination.h
+	FANSRunwayDeparture.h
+	FANSRunway.h
+	FANSRunwayDirection.h
+	FANSRunwayConfiguration.h
+	FANSProcedureDeparture.h
+	FANSRunwayArrival.h
+	FANSProcedureApproach.h
+	FANSProcedureArrival.h
+	FANSAirwayIntercept.h
+	FANSRouteInformation.h
+	FANSRouteInformationSequence.h
+	FANSPublishedIdentifier.h
+	FANSPlaceBearing.h
+	FANSPlaceBearingPlaceBearing.h
+	FANSAirwayIdentifier.h
+	FANSTrackDetail.h
+	FANSTrackName.h
+	FANSATWAlongTrackWaypointSequence.h
+	FANSInterceptCourseFromSequence.h
+	FANSHoldatwaypointSequence.h
+	FANSWaypointSpeedAltitudesequence.h
+	FANSRTARequiredTimeArrivalSequence.h
+	FANSRouteInformationAdditional.h
+	FANSATWAltitudeSequence.h
+	FANSATWAlongTrackWaypoint.h
+	FANSATWDistance.h
+	FANSATWDistanceTolerance.h
+	FANSReportingPoints.h
+	FANSLatLonReportingPoints.h
+	FANSLatitudeReportingPoints.h
+	FANSLongitudeReportingPoints.h
+	FANSDegreeIncrement.h
+	FANSInterceptCourseFrom.h
+	FANSInterceptCourseFromSelection.h
+	FANSHoldatwaypointSpeedLow.h
+	FANSHoldatwaypointSpeedHigh.h
+	FANSEFCtime.h
+	FANSHoldatwaypoint.h
+	FANSWaypointSpeedAltitude.h
+	FANSRTARequiredTimeArrival.h
+	FANSRTATime.h
+	FANSTimeTolerance.h
+	FANSRTATolerance.h
+	FANSSpeed.h
+	FANSSpeedIndicated.h
+	FANSSpeedIndicatedMetric.h
+	FANSSpeedTrue.h
+	FANSSpeedTrueMetric.h
+	FANSSpeedGround.h
+	FANSSpeedGroundMetric.h
+	FANSSpeedMach.h
+	FANSSpeedMachLarge.h
+	FANSSpeedSpeed.h
+	FANSTime.h
+	FANSTimeAltitude.h
+	FANSTimeDistanceOffsetDirection.h
+	FANSTimeDistanceToFromPosition.h
+	FANSTimeTime.h
+	FANSToFrom.h
+	FANSTimeICAOunitnameFrequency.h
+	FANSTimePosition.h
+	FANSTimePositionAltitude.h
+	FANSTimePositionAltitudeSpeed.h
+	FANSTimeSpeed.h
+	FANSTimeSpeedSpeed.h
+	FANSToFromPosition.h
+	FANSTp4table.h
+	FANSVersionNumber.h
+	FANSVerticalRate.h
+	FANSVerticalRateEnglish.h
+	FANSVerticalRateMetric.h
+	BOOLEAN.h
+	INTEGER.h
+	NativeEnumerated.h
+	IA5String.h
+	NULL.h
+	NativeInteger.h
+	NumericString.h
+	asn_SEQUENCE_OF.h
+	asn_SET_OF.h
+	constr_CHOICE.h
+	constr_SEQUENCE.h
+	constr_SEQUENCE_OF.h
+	constr_SET_OF.h
+	asn_application.h
+	asn_system.h
+	asn_codecs.h
+	asn_internal.h
+	OCTET_STRING.h
+	BIT_STRING.h
+	asn_codecs_prim.h
+	ber_tlv_length.h
+	ber_tlv_tag.h
+	ber_decoder.h
+	der_encoder.h
+	constr_TYPE.h
+	constraints.h
+	xer_support.h
+	xer_decoder.h
+	xer_encoder.h
+	per_support.h
+	per_decoder.h
+	per_encoder.h
+	per_opentype.h
+)
+
+set(ASN_MODULE_SOURCES
+	FANSATCUplinkMessage.c
+	FANSATCUplinkMsgElementIdSequence.c
+	FANSATCMessageHeader.c
+	FANSMsgIdentificationNumber.c
+	FANSMsgReferenceNumber.c
+	FANSTimestamp.c
+	FANSTimehours.c
+	FANSTimeminutes.c
+	FANSTimeSeconds.c
+	FANSATCUplinkMsgElementId.c
+	FANSATCDownlinkMessage.c
+	FANSATCDownlinkMsgElementIdSequence.c
+	FANSATCDownlinkMsgElementId.c
+	FANSAirport.c
+	FANSAltimeter.c
+	FANSAltimeterEnglish.c
+	FANSAltimeterMetric.c
+	FANSAltitude.c
+	FANSAltitudeQNH.c
+	FANSAltitudeQNHMeters.c
+	FANSAltitudeQFE.c
+	FANSAltitudeQFEMeters.c
+	FANSAltitudeGNSSFeet.c
+	FANSAltitudeGNSSMeters.c
+	FANSAltitudeFlightLevel.c
+	FANSAltitudeFlightLevelMetric.c
+	FANSAltitudePosition.c
+	FANSAltitudeAltitude.c
+	FANSAltitudeSpeed.c
+	FANSAltitudeSpeedSpeed.c
+	FANSAltitudeTime.c
+	FANSATISCode.c
+	FANSATWAltitude.c
+	FANSATWAltitudeTolerance.c
+	FANSBeaconCode.c
+	FANSBeaconCodeOctalDigit.c
+	FANSDegrees.c
+	FANSDegreesMagnetic.c
+	FANSDegreesTrue.c
+	FANSDirection.c
+	FANSDirectionDegrees.c
+	FANSDistanceOffset.c
+	FANSDistanceOffsetNm.c
+	FANSDistanceOffsetKm.c
+	FANSDistanceOffsetDirection.c
+	FANSErrorInformation.c
+	FANSFixName.c
+	FANSFreeText.c
+	FANSFrequency.c
+	FANSFrequencyhf.c
+	FANSFrequencyvhf.c
+	FANSFrequencyuhf.c
+	FANSFrequencysatchannel.c
+	FANSHoldClearance.c
+	FANSICAOUnitName.c
+	FANSICAOFacilityIdentification.c
+	FANSICAOfacilityDesignation.c
+	FANSICAOFacilityName.c
+	FANSICAOFacilityFunction.c
+	FANSICAOUnitNameFrequency.c
+	FANSICAOFacilityDesignationTp4Table.c
+	FANSLatitudeLongitude.c
+	FANSLatitudeLongitudeSequence.c
+	FANSLatitude.c
+	FANSLatitudeDegrees.c
+	FANSMinutesLatLon.c
+	FANSLatitudeDirection.c
+	FANSLongitude.c
+	FANSLongitudeDegrees.c
+	FANSLongitudeDirection.c
+	FANSLegType.c
+	FANSLegDistance.c
+	FANSLegDistanceEnglish.c
+	FANSLegDistanceMetric.c
+	FANSLegTime.c
+	FANSPlaceBearingDistance.c
+	FANSDistance.c
+	FANSDistanceNm.c
+	FANSDistanceKm.c
+	FANSPosition.c
+	FANSNavaid.c
+	FANSPositionAltitude.c
+	FANSPositionAltitudeAltitude.c
+	FANSPositionAltitudeSpeed.c
+	FANSPositionDegrees.c
+	FANSPositionDistanceOffsetDirection.c
+	FANSPositionICAOUnitNameFrequency.c
+	FANSPositionPosition.c
+	FANSPositionProcedureName.c
+	FANSPositionReport.c
+	FANSPositionCurrent.c
+	FANSTimeAtPositionCurrent.c
+	FANSFixNext.c
+	FANSTimeEtaAtFixNext.c
+	FANSFixNextPlusOne.c
+	FANSTimeEtaDestination.c
+	FANSTemperature.c
+	FANSTemperatureC.c
+	FANSTemperatureF.c
+	FANSWinds.c
+	FANSWindDirection.c
+	FANSWindSpeed.c
+	FANSWindSpeedEnglish.c
+	FANSWindSpeedMetric.c
+	FANSTurbulence.c
+	FANSIcing.c
+	FANSVerticalChange.c
+	FANSVerticalDirection.c
+	FANSTrackAngle.c
+	FANSTrueheading.c
+	FANSSupplementaryInformation.c
+	FANSReportedWaypointPosition.c
+	FANSReportedWaypointTime.c
+	FANSReportedWaypointAltitude.c
+	FANSPositionRouteClearance.c
+	FANSPositionSpeed.c
+	FANSPositionSpeedSpeed.c
+	FANSPositionTime.c
+	FANSPositionTimeAltitude.c
+	FANSPositionTimeTime.c
+	FANSPredepartureClearance.c
+	FANSAircraftFlightIdentification.c
+	FANSAircraftType.c
+	FANSAircraftEquipmentCode.c
+	FANSCOMNAVApproachEquipmentAvailable.c
+	FANSCOMNAVEquipmentStatus.c
+	FANSCOMNAVEquipmentStatusSequence.c
+	FANSSSREquipmentAvailable.c
+	FANSTimeDepartureEdct.c
+	FANSAltitudeRestriction.c
+	FANSFrequencyDeparture.c
+	FANSPDCrevision.c
+	FANSProcedureName.c
+	FANSProcedureType.c
+	FANSProcedure.c
+	FANSProcedureTransition.c
+	FANSRemainingFuelRemainingSouls.c
+	FANSRemainingFuel.c
+	FANSRemainingSouls.c
+	FANSRouteClearance.c
+	FANSAirportDeparture.c
+	FANSAirportDestination.c
+	FANSRunwayDeparture.c
+	FANSRunway.c
+	FANSRunwayDirection.c
+	FANSRunwayConfiguration.c
+	FANSProcedureDeparture.c
+	FANSRunwayArrival.c
+	FANSProcedureApproach.c
+	FANSProcedureArrival.c
+	FANSAirwayIntercept.c
+	FANSRouteInformation.c
+	FANSRouteInformationSequence.c
+	FANSPublishedIdentifier.c
+	FANSPlaceBearing.c
+	FANSPlaceBearingPlaceBearing.c
+	FANSAirwayIdentifier.c
+	FANSTrackDetail.c
+	FANSTrackName.c
+	FANSATWAlongTrackWaypointSequence.c
+	FANSInterceptCourseFromSequence.c
+	FANSHoldatwaypointSequence.c
+	FANSWaypointSpeedAltitudesequence.c
+	FANSRTARequiredTimeArrivalSequence.c
+	FANSRouteInformationAdditional.c
+	FANSATWAltitudeSequence.c
+	FANSATWAlongTrackWaypoint.c
+	FANSATWDistance.c
+	FANSATWDistanceTolerance.c
+	FANSReportingPoints.c
+	FANSLatLonReportingPoints.c
+	FANSLatitudeReportingPoints.c
+	FANSLongitudeReportingPoints.c
+	FANSDegreeIncrement.c
+	FANSInterceptCourseFrom.c
+	FANSInterceptCourseFromSelection.c
+	FANSHoldatwaypointSpeedLow.c
+	FANSHoldatwaypointSpeedHigh.c
+	FANSEFCtime.c
+	FANSHoldatwaypoint.c
+	FANSWaypointSpeedAltitude.c
+	FANSRTARequiredTimeArrival.c
+	FANSRTATime.c
+	FANSTimeTolerance.c
+	FANSRTATolerance.c
+	FANSSpeed.c
+	FANSSpeedIndicated.c
+	FANSSpeedIndicatedMetric.c
+	FANSSpeedTrue.c
+	FANSSpeedTrueMetric.c
+	FANSSpeedGround.c
+	FANSSpeedGroundMetric.c
+	FANSSpeedMach.c
+	FANSSpeedMachLarge.c
+	FANSSpeedSpeed.c
+	FANSTime.c
+	FANSTimeAltitude.c
+	FANSTimeDistanceOffsetDirection.c
+	FANSTimeDistanceToFromPosition.c
+	FANSTimeTime.c
+	FANSToFrom.c
+	FANSTimeICAOunitnameFrequency.c
+	FANSTimePosition.c
+	FANSTimePositionAltitude.c
+	FANSTimePositionAltitudeSpeed.c
+	FANSTimeSpeed.c
+	FANSTimeSpeedSpeed.c
+	FANSToFromPosition.c
+	FANSTp4table.c
+	FANSVersionNumber.c
+	FANSVerticalRate.c
+	FANSVerticalRateEnglish.c
+	FANSVerticalRateMetric.c
+	BOOLEAN.c
+	IA5String.c
+	INTEGER.c
+	NULL.c
+	NativeEnumerated.c
+	NativeInteger.c
+	NumericString.c
+	asn_SEQUENCE_OF.c
+	asn_SET_OF.c
+	constr_CHOICE.c
+	constr_SEQUENCE.c
+	constr_SEQUENCE_OF.c
+	constr_SET_OF.c
+	OCTET_STRING.c
+	BIT_STRING.c
+	asn_codecs_prim.c
+	ber_tlv_length.c
+	ber_tlv_tag.c
+	ber_decoder.c
+	der_encoder.c
+	constr_TYPE.c
+	constraints.c
+	xer_support.c
+	xer_decoder.c
+	xer_encoder.c
+	per_support.c
+	per_decoder.c
+	per_encoder.c
+	per_opentype.c
+)
+

plugins/inmarsat_support/aero/libacars/asn1/CMakeLists.txt

@@ -0,0 +1,13 @@
+include (CMakeLists.inc)
+if (EMIT_ASN_DEBUG)
+	set (CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DEMIT_ASN_DEBUG=1")
+endif()
+
+# force inclusion of alloca.h from stdlib.h on macos
+remove_definitions(-D_XOPEN_SOURCE=600 -D_POSIX_C_SOURCE=200809L)
+
+add_library (asn1 OBJECT ${ASN_MODULE_SOURCES})
+set_property(TARGET asn1 PROPERTY POSITION_INDEPENDENT_CODE ON)
+
+install (FILES ${ASN_MODULE_HEADERS} DESTINATION
+	${CMAKE_INSTALL_INCLUDEDIR}/${LA_SUBDIR}/${PROJECT_NAME}/asn1)

plugins/inmarsat_support/aero/libacars/asn1/FANSATCDownlinkMessage.c

@@ -0,0 +1,210 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATCDownlinkMessage.h"
+
+static asn_TYPE_member_t asn_MBR_FANSATCDownlinkMessage_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSATCDownlinkMessage, aTCMessageheader),
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_FANSATCMessageHeader,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"aTCMessageheader"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSATCDownlinkMessage, aTCDownlinkmsgelementid),
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_FANSATCDownlinkMsgElementId,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"aTCDownlinkmsgelementid"
+		},
+	{ ATF_POINTER, 1, offsetof(struct FANSATCDownlinkMessage, aTCdownlinkmsgelementid_seqOf),
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_FANSATCDownlinkMsgElementIdSequence,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"aTCdownlinkmsgelementid-seqOf"
+		},
+};
+static const int asn_MAP_FANSATCDownlinkMessage_oms_1[] = { 2 };
+static const ber_tlv_tag_t asn_DEF_FANSATCDownlinkMessage_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_FANSATCDownlinkMessage_tag2el_1[] = {
+    { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* aTCMessageheader */
+    { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 }, /* aTCdownlinkmsgelementid-seqOf */
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 1, 0, 0 }, /* dM0NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* dM1NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 }, /* dM2NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 1, 0, 0 }, /* dM3NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 1, 0, 0 }, /* dM4NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 1, 0, 0 }, /* dM5NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 1, 0, 0 }, /* dM6Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 1, 0, 0 }, /* dM7AltitudeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 1, 0, 0 }, /* dM8Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 1, 0, 0 }, /* dM9Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (10 << 2)), 1, 0, 0 }, /* dM10Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (11 << 2)), 1, 0, 0 }, /* dM11PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (12 << 2)), 1, 0, 0 }, /* dM12PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (13 << 2)), 1, 0, 0 }, /* dM13TimeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (14 << 2)), 1, 0, 0 }, /* dM14TimeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (15 << 2)), 1, 0, 0 }, /* dM15DistanceOffsetDirection */
+    { (ASN_TAG_CLASS_CONTEXT | (16 << 2)), 1, 0, 0 }, /* dM16PositionDistanceOffsetDirection */
+    { (ASN_TAG_CLASS_CONTEXT | (17 << 2)), 1, 0, 0 }, /* dM17TimeDistanceOffsetDirection */
+    { (ASN_TAG_CLASS_CONTEXT | (18 << 2)), 1, 0, 0 }, /* dM18Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (19 << 2)), 1, 0, 0 }, /* dM19SpeedSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (20 << 2)), 1, 0, 0 }, /* dM20NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (21 << 2)), 1, 0, 0 }, /* dM21Frequency */
+    { (ASN_TAG_CLASS_CONTEXT | (22 << 2)), 1, 0, 0 }, /* dM22Position */
+    { (ASN_TAG_CLASS_CONTEXT | (23 << 2)), 1, 0, 0 }, /* dM23ProcedureName */
+    { (ASN_TAG_CLASS_CONTEXT | (24 << 2)), 1, 0, 0 }, /* dM24RouteClearance */
+    { (ASN_TAG_CLASS_CONTEXT | (25 << 2)), 1, 0, 0 }, /* dM25NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (26 << 2)), 1, 0, 0 }, /* dM26PositionRouteClearance */
+    { (ASN_TAG_CLASS_CONTEXT | (27 << 2)), 1, 0, 0 }, /* dM27DistanceOffsetDirection */
+    { (ASN_TAG_CLASS_CONTEXT | (28 << 2)), 1, 0, 0 }, /* dM28Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (29 << 2)), 1, 0, 0 }, /* dM29Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (30 << 2)), 1, 0, 0 }, /* dM30Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (31 << 2)), 1, 0, 0 }, /* dM31Position */
+    { (ASN_TAG_CLASS_CONTEXT | (32 << 2)), 1, 0, 0 }, /* dM32Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (33 << 2)), 1, 0, 0 }, /* dM33Position */
+    { (ASN_TAG_CLASS_CONTEXT | (34 << 2)), 1, 0, 0 }, /* dM34Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (35 << 2)), 1, 0, 0 }, /* dM35Degrees */
+    { (ASN_TAG_CLASS_CONTEXT | (36 << 2)), 1, 0, 0 }, /* dM36Degrees */
+    { (ASN_TAG_CLASS_CONTEXT | (37 << 2)), 1, 0, 0 }, /* dM37Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (38 << 2)), 1, 0, 0 }, /* dM38Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (39 << 2)), 1, 0, 0 }, /* dM39Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (40 << 2)), 1, 0, 0 }, /* dM40RouteClearance */
+    { (ASN_TAG_CLASS_CONTEXT | (41 << 2)), 1, 0, 0 }, /* dM41NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (42 << 2)), 1, 0, 0 }, /* dM42Position */
+    { (ASN_TAG_CLASS_CONTEXT | (43 << 2)), 1, 0, 0 }, /* dM43Time */
+    { (ASN_TAG_CLASS_CONTEXT | (44 << 2)), 1, 0, 0 }, /* dM44Position */
+    { (ASN_TAG_CLASS_CONTEXT | (45 << 2)), 1, 0, 0 }, /* dM45Position */
+    { (ASN_TAG_CLASS_CONTEXT | (46 << 2)), 1, 0, 0 }, /* dM46Time */
+    { (ASN_TAG_CLASS_CONTEXT | (47 << 2)), 1, 0, 0 }, /* dM47BeaconCode */
+    { (ASN_TAG_CLASS_CONTEXT | (48 << 2)), 1, 0, 0 }, /* dM48PositionReport */
+    { (ASN_TAG_CLASS_CONTEXT | (49 << 2)), 1, 0, 0 }, /* dM49Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (50 << 2)), 1, 0, 0 }, /* dM50SpeedSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (51 << 2)), 1, 0, 0 }, /* dM51NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (52 << 2)), 1, 0, 0 }, /* dM52NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (53 << 2)), 1, 0, 0 }, /* dM53NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (54 << 2)), 1, 0, 0 }, /* dM54Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (55 << 2)), 1, 0, 0 }, /* dM55NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (56 << 2)), 1, 0, 0 }, /* dM56NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (57 << 2)), 1, 0, 0 }, /* dM57RemainingFuelRemainingSouls */
+    { (ASN_TAG_CLASS_CONTEXT | (58 << 2)), 1, 0, 0 }, /* dM58NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (59 << 2)), 1, 0, 0 }, /* dM59PositionRouteClearance */
+    { (ASN_TAG_CLASS_CONTEXT | (60 << 2)), 1, 0, 0 }, /* dM60DistanceOffsetDirection */
+    { (ASN_TAG_CLASS_CONTEXT | (61 << 2)), 1, 0, 0 }, /* dM61Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (62 << 2)), 1, 0, 0 }, /* dM62ErrorInformation */
+    { (ASN_TAG_CLASS_CONTEXT | (63 << 2)), 1, 0, 0 }, /* dM63NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (64 << 2)), 1, 0, 0 }, /* dM64ICAOfacilitydesignation */
+    { (ASN_TAG_CLASS_CONTEXT | (65 << 2)), 1, 0, 0 }, /* dM65NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (66 << 2)), 1, 0, 0 }, /* dM66NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (67 << 2)), 1, 0, 0 }, /* dM67FreeText */
+    { (ASN_TAG_CLASS_CONTEXT | (68 << 2)), 1, 0, 0 }, /* dM68FreeText */
+    { (ASN_TAG_CLASS_CONTEXT | (69 << 2)), 1, 0, 0 }, /* dM69NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (70 << 2)), 1, 0, 0 }, /* dM70Degrees */
+    { (ASN_TAG_CLASS_CONTEXT | (71 << 2)), 1, 0, 0 }, /* dM71Degrees */
+    { (ASN_TAG_CLASS_CONTEXT | (72 << 2)), 1, 0, 0 }, /* dM72Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (73 << 2)), 1, 0, 0 }, /* dM73VersionNumber */
+    { (ASN_TAG_CLASS_CONTEXT | (74 << 2)), 1, 0, 0 }, /* dM74NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (75 << 2)), 1, 0, 0 }, /* dM75NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (76 << 2)), 1, 0, 0 }, /* dM76AltitudeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (77 << 2)), 1, 0, 0 }, /* dM77AltitudeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (78 << 2)), 1, 0, 0 }, /* dM78TimeDistanceToFromPosition */
+    { (ASN_TAG_CLASS_CONTEXT | (79 << 2)), 1, 0, 0 }, /* dM79ATISCode */
+    { (ASN_TAG_CLASS_CONTEXT | (80 << 2)), 1, 0, 0 }, /* dM80DistanceOffsetDirection */
+    { (ASN_TAG_CLASS_CONTEXT | (81 << 2)), 1, 0, 0 }, /* dM81NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (82 << 2)), 1, 0, 0 }, /* dM82NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (83 << 2)), 1, 0, 0 }, /* dM83NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (84 << 2)), 1, 0, 0 }, /* dM84NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (85 << 2)), 1, 0, 0 }, /* dM85NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (86 << 2)), 1, 0, 0 }, /* dM86NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (87 << 2)), 1, 0, 0 }, /* dM87NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (88 << 2)), 1, 0, 0 }, /* dM88NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (89 << 2)), 1, 0, 0 }, /* dM89NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (90 << 2)), 1, 0, 0 }, /* dM90NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (91 << 2)), 1, 0, 0 }, /* dM91NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (92 << 2)), 1, 0, 0 }, /* dM92NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (93 << 2)), 1, 0, 0 }, /* dM93NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (94 << 2)), 1, 0, 0 }, /* dM94NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (95 << 2)), 1, 0, 0 }, /* dM95NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (96 << 2)), 1, 0, 0 }, /* dM96NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (97 << 2)), 1, 0, 0 }, /* dM97NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (98 << 2)), 1, 0, 0 }, /* dM98NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (99 << 2)), 1, 0, 0 }, /* dM99NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (100 << 2)), 1, 0, 0 }, /* dM100NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (101 << 2)), 1, 0, 0 }, /* dM101NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (102 << 2)), 1, 0, 0 }, /* dM102NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (103 << 2)), 1, 0, 0 }, /* dM103NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (104 << 2)), 1, 0, 0 }, /* dM104NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (105 << 2)), 1, 0, 0 }, /* dM105NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (106 << 2)), 1, 0, 0 }, /* dM106NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (107 << 2)), 1, 0, 0 }, /* dM107NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (108 << 2)), 1, 0, 0 }, /* dM108NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (109 << 2)), 1, 0, 0 }, /* dM109NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (110 << 2)), 1, 0, 0 }, /* dM110NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (111 << 2)), 1, 0, 0 }, /* dM111NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (112 << 2)), 1, 0, 0 }, /* dM112NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (113 << 2)), 1, 0, 0 }, /* dM113NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (114 << 2)), 1, 0, 0 }, /* dM114NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (115 << 2)), 1, 0, 0 }, /* dM115NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (116 << 2)), 1, 0, 0 }, /* dM116NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (117 << 2)), 1, 0, 0 }, /* dM117NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (118 << 2)), 1, 0, 0 }, /* dM118NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (119 << 2)), 1, 0, 0 }, /* dM119NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (120 << 2)), 1, 0, 0 }, /* dM120NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (121 << 2)), 1, 0, 0 }, /* dM121NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (122 << 2)), 1, 0, 0 }, /* dM122NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (123 << 2)), 1, 0, 0 }, /* dM123NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (124 << 2)), 1, 0, 0 }, /* dM124NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (125 << 2)), 1, 0, 0 }, /* dM125NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (126 << 2)), 1, 0, 0 }, /* dM126NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (127 << 2)), 1, 0, 0 }, /* dM127NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (128 << 2)), 1, 0, 0 } /* dM128NULL */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_FANSATCDownlinkMessage_specs_1 = {
+	sizeof(struct FANSATCDownlinkMessage),
+	offsetof(struct FANSATCDownlinkMessage, _asn_ctx),
+	asn_MAP_FANSATCDownlinkMessage_tag2el_1,
+	131,	/* Count of tags in the map */
+	asn_MAP_FANSATCDownlinkMessage_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSATCDownlinkMessage = {
+	"FANSATCDownlinkMessage",
+	"FANSATCDownlinkMessage",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATCDownlinkMessage_tags_1,
+	sizeof(asn_DEF_FANSATCDownlinkMessage_tags_1)
+		/sizeof(asn_DEF_FANSATCDownlinkMessage_tags_1[0]), /* 1 */
+	asn_DEF_FANSATCDownlinkMessage_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATCDownlinkMessage_tags_1)
+		/sizeof(asn_DEF_FANSATCDownlinkMessage_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_FANSATCDownlinkMessage_1,
+	3,	/* Elements count */
+	&asn_SPC_FANSATCDownlinkMessage_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATCDownlinkMessage.h

@@ -0,0 +1,47 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATCDownlinkMessage_H_
+#define	_FANSATCDownlinkMessage_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "FANSATCMessageHeader.h"
+#include "FANSATCDownlinkMsgElementId.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct FANSATCDownlinkMsgElementIdSequence;
+
+/* FANSATCDownlinkMessage */
+typedef struct FANSATCDownlinkMessage {
+	FANSATCMessageHeader_t	 aTCMessageheader;
+	FANSATCDownlinkMsgElementId_t	 aTCDownlinkmsgelementid;
+	struct FANSATCDownlinkMsgElementIdSequence	*aTCdownlinkmsgelementid_seqOf	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSATCDownlinkMessage_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATCDownlinkMessage;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "FANSATCDownlinkMsgElementIdSequence.h"
+
+#endif	/* _FANSATCDownlinkMessage_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATCDownlinkMsgElementId.h

@@ -0,0 +1,328 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATCDownlinkMsgElementId_H_
+#define	_FANSATCDownlinkMsgElementId_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NULL.h"
+#include "FANSAltitude.h"
+#include "FANSAltitudeAltitude.h"
+#include "FANSPositionAltitude.h"
+#include "FANSTimeAltitude.h"
+#include "FANSDistanceOffsetDirection.h"
+#include "FANSPositionDistanceOffsetDirection.h"
+#include "FANSTimeDistanceOffsetDirection.h"
+#include "FANSSpeed.h"
+#include "FANSSpeedSpeed.h"
+#include "FANSFrequency.h"
+#include "FANSPosition.h"
+#include "FANSProcedureName.h"
+#include "FANSRouteClearance.h"
+#include "FANSPositionRouteClearance.h"
+#include "FANSDegrees.h"
+#include "FANSTime.h"
+#include "FANSBeaconCode.h"
+#include "FANSPositionReport.h"
+#include "FANSRemainingFuelRemainingSouls.h"
+#include "FANSErrorInformation.h"
+#include "FANSICAOfacilityDesignation.h"
+#include "FANSFreeText.h"
+#include "FANSVersionNumber.h"
+#include "FANSTimeDistanceToFromPosition.h"
+#include "FANSATISCode.h"
+#include "constr_CHOICE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum FANSATCDownlinkMsgElementId_PR {
+	FANSATCDownlinkMsgElementId_PR_NOTHING,	/* No components present */
+	FANSATCDownlinkMsgElementId_PR_dM0NULL,
+	FANSATCDownlinkMsgElementId_PR_dM1NULL,
+	FANSATCDownlinkMsgElementId_PR_dM2NULL,
+	FANSATCDownlinkMsgElementId_PR_dM3NULL,
+	FANSATCDownlinkMsgElementId_PR_dM4NULL,
+	FANSATCDownlinkMsgElementId_PR_dM5NULL,
+	FANSATCDownlinkMsgElementId_PR_dM6Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM7AltitudeAltitude,
+	FANSATCDownlinkMsgElementId_PR_dM8Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM9Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM10Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM11PositionAltitude,
+	FANSATCDownlinkMsgElementId_PR_dM12PositionAltitude,
+	FANSATCDownlinkMsgElementId_PR_dM13TimeAltitude,
+	FANSATCDownlinkMsgElementId_PR_dM14TimeAltitude,
+	FANSATCDownlinkMsgElementId_PR_dM15DistanceOffsetDirection,
+	FANSATCDownlinkMsgElementId_PR_dM16PositionDistanceOffsetDirection,
+	FANSATCDownlinkMsgElementId_PR_dM17TimeDistanceOffsetDirection,
+	FANSATCDownlinkMsgElementId_PR_dM18Speed,
+	FANSATCDownlinkMsgElementId_PR_dM19SpeedSpeed,
+	FANSATCDownlinkMsgElementId_PR_dM20NULL,
+	FANSATCDownlinkMsgElementId_PR_dM21Frequency,
+	FANSATCDownlinkMsgElementId_PR_dM22Position,
+	FANSATCDownlinkMsgElementId_PR_dM23ProcedureName,
+	FANSATCDownlinkMsgElementId_PR_dM24RouteClearance,
+	FANSATCDownlinkMsgElementId_PR_dM25NULL,
+	FANSATCDownlinkMsgElementId_PR_dM26PositionRouteClearance,
+	FANSATCDownlinkMsgElementId_PR_dM27DistanceOffsetDirection,
+	FANSATCDownlinkMsgElementId_PR_dM28Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM29Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM30Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM31Position,
+	FANSATCDownlinkMsgElementId_PR_dM32Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM33Position,
+	FANSATCDownlinkMsgElementId_PR_dM34Speed,
+	FANSATCDownlinkMsgElementId_PR_dM35Degrees,
+	FANSATCDownlinkMsgElementId_PR_dM36Degrees,
+	FANSATCDownlinkMsgElementId_PR_dM37Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM38Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM39Speed,
+	FANSATCDownlinkMsgElementId_PR_dM40RouteClearance,
+	FANSATCDownlinkMsgElementId_PR_dM41NULL,
+	FANSATCDownlinkMsgElementId_PR_dM42Position,
+	FANSATCDownlinkMsgElementId_PR_dM43Time,
+	FANSATCDownlinkMsgElementId_PR_dM44Position,
+	FANSATCDownlinkMsgElementId_PR_dM45Position,
+	FANSATCDownlinkMsgElementId_PR_dM46Time,
+	FANSATCDownlinkMsgElementId_PR_dM47BeaconCode,
+	FANSATCDownlinkMsgElementId_PR_dM48PositionReport,
+	FANSATCDownlinkMsgElementId_PR_dM49Speed,
+	FANSATCDownlinkMsgElementId_PR_dM50SpeedSpeed,
+	FANSATCDownlinkMsgElementId_PR_dM51NULL,
+	FANSATCDownlinkMsgElementId_PR_dM52NULL,
+	FANSATCDownlinkMsgElementId_PR_dM53NULL,
+	FANSATCDownlinkMsgElementId_PR_dM54Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM55NULL,
+	FANSATCDownlinkMsgElementId_PR_dM56NULL,
+	FANSATCDownlinkMsgElementId_PR_dM57RemainingFuelRemainingSouls,
+	FANSATCDownlinkMsgElementId_PR_dM58NULL,
+	FANSATCDownlinkMsgElementId_PR_dM59PositionRouteClearance,
+	FANSATCDownlinkMsgElementId_PR_dM60DistanceOffsetDirection,
+	FANSATCDownlinkMsgElementId_PR_dM61Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM62ErrorInformation,
+	FANSATCDownlinkMsgElementId_PR_dM63NULL,
+	FANSATCDownlinkMsgElementId_PR_dM64ICAOfacilitydesignation,
+	FANSATCDownlinkMsgElementId_PR_dM65NULL,
+	FANSATCDownlinkMsgElementId_PR_dM66NULL,
+	FANSATCDownlinkMsgElementId_PR_dM67FreeText,
+	FANSATCDownlinkMsgElementId_PR_dM68FreeText,
+	FANSATCDownlinkMsgElementId_PR_dM69NULL,
+	FANSATCDownlinkMsgElementId_PR_dM70Degrees,
+	FANSATCDownlinkMsgElementId_PR_dM71Degrees,
+	FANSATCDownlinkMsgElementId_PR_dM72Altitude,
+	FANSATCDownlinkMsgElementId_PR_dM73VersionNumber,
+	FANSATCDownlinkMsgElementId_PR_dM74NULL,
+	FANSATCDownlinkMsgElementId_PR_dM75NULL,
+	FANSATCDownlinkMsgElementId_PR_dM76AltitudeAltitude,
+	FANSATCDownlinkMsgElementId_PR_dM77AltitudeAltitude,
+	FANSATCDownlinkMsgElementId_PR_dM78TimeDistanceToFromPosition,
+	FANSATCDownlinkMsgElementId_PR_dM79ATISCode,
+	FANSATCDownlinkMsgElementId_PR_dM80DistanceOffsetDirection,
+	FANSATCDownlinkMsgElementId_PR_dM81NULL,
+	FANSATCDownlinkMsgElementId_PR_dM82NULL,
+	FANSATCDownlinkMsgElementId_PR_dM83NULL,
+	FANSATCDownlinkMsgElementId_PR_dM84NULL,
+	FANSATCDownlinkMsgElementId_PR_dM85NULL,
+	FANSATCDownlinkMsgElementId_PR_dM86NULL,
+	FANSATCDownlinkMsgElementId_PR_dM87NULL,
+	FANSATCDownlinkMsgElementId_PR_dM88NULL,
+	FANSATCDownlinkMsgElementId_PR_dM89NULL,
+	FANSATCDownlinkMsgElementId_PR_dM90NULL,
+	FANSATCDownlinkMsgElementId_PR_dM91NULL,
+	FANSATCDownlinkMsgElementId_PR_dM92NULL,
+	FANSATCDownlinkMsgElementId_PR_dM93NULL,
+	FANSATCDownlinkMsgElementId_PR_dM94NULL,
+	FANSATCDownlinkMsgElementId_PR_dM95NULL,
+	FANSATCDownlinkMsgElementId_PR_dM96NULL,
+	FANSATCDownlinkMsgElementId_PR_dM97NULL,
+	FANSATCDownlinkMsgElementId_PR_dM98NULL,
+	FANSATCDownlinkMsgElementId_PR_dM99NULL,
+	FANSATCDownlinkMsgElementId_PR_dM100NULL,
+	FANSATCDownlinkMsgElementId_PR_dM101NULL,
+	FANSATCDownlinkMsgElementId_PR_dM102NULL,
+	FANSATCDownlinkMsgElementId_PR_dM103NULL,
+	FANSATCDownlinkMsgElementId_PR_dM104NULL,
+	FANSATCDownlinkMsgElementId_PR_dM105NULL,
+	FANSATCDownlinkMsgElementId_PR_dM106NULL,
+	FANSATCDownlinkMsgElementId_PR_dM107NULL,
+	FANSATCDownlinkMsgElementId_PR_dM108NULL,
+	FANSATCDownlinkMsgElementId_PR_dM109NULL,
+	FANSATCDownlinkMsgElementId_PR_dM110NULL,
+	FANSATCDownlinkMsgElementId_PR_dM111NULL,
+	FANSATCDownlinkMsgElementId_PR_dM112NULL,
+	FANSATCDownlinkMsgElementId_PR_dM113NULL,
+	FANSATCDownlinkMsgElementId_PR_dM114NULL,
+	FANSATCDownlinkMsgElementId_PR_dM115NULL,
+	FANSATCDownlinkMsgElementId_PR_dM116NULL,
+	FANSATCDownlinkMsgElementId_PR_dM117NULL,
+	FANSATCDownlinkMsgElementId_PR_dM118NULL,
+	FANSATCDownlinkMsgElementId_PR_dM119NULL,
+	FANSATCDownlinkMsgElementId_PR_dM120NULL,
+	FANSATCDownlinkMsgElementId_PR_dM121NULL,
+	FANSATCDownlinkMsgElementId_PR_dM122NULL,
+	FANSATCDownlinkMsgElementId_PR_dM123NULL,
+	FANSATCDownlinkMsgElementId_PR_dM124NULL,
+	FANSATCDownlinkMsgElementId_PR_dM125NULL,
+	FANSATCDownlinkMsgElementId_PR_dM126NULL,
+	FANSATCDownlinkMsgElementId_PR_dM127NULL,
+	FANSATCDownlinkMsgElementId_PR_dM128NULL
+} FANSATCDownlinkMsgElementId_PR;
+
+/* FANSATCDownlinkMsgElementId */
+typedef struct FANSATCDownlinkMsgElementId {
+	FANSATCDownlinkMsgElementId_PR present;
+	union FANSATCDownlinkMsgElementId_u {
+		NULL_t	 dM0NULL;
+		NULL_t	 dM1NULL;
+		NULL_t	 dM2NULL;
+		NULL_t	 dM3NULL;
+		NULL_t	 dM4NULL;
+		NULL_t	 dM5NULL;
+		FANSAltitude_t	 dM6Altitude;
+		FANSAltitudeAltitude_t	 dM7AltitudeAltitude;
+		FANSAltitude_t	 dM8Altitude;
+		FANSAltitude_t	 dM9Altitude;
+		FANSAltitude_t	 dM10Altitude;
+		FANSPositionAltitude_t	 dM11PositionAltitude;
+		FANSPositionAltitude_t	 dM12PositionAltitude;
+		FANSTimeAltitude_t	 dM13TimeAltitude;
+		FANSTimeAltitude_t	 dM14TimeAltitude;
+		FANSDistanceOffsetDirection_t	 dM15DistanceOffsetDirection;
+		FANSPositionDistanceOffsetDirection_t	 dM16PositionDistanceOffsetDirection;
+		FANSTimeDistanceOffsetDirection_t	 dM17TimeDistanceOffsetDirection;
+		FANSSpeed_t	 dM18Speed;
+		FANSSpeedSpeed_t	 dM19SpeedSpeed;
+		NULL_t	 dM20NULL;
+		FANSFrequency_t	 dM21Frequency;
+		FANSPosition_t	 dM22Position;
+		FANSProcedureName_t	 dM23ProcedureName;
+		FANSRouteClearance_t	 dM24RouteClearance;
+		NULL_t	 dM25NULL;
+		FANSPositionRouteClearance_t	 dM26PositionRouteClearance;
+		FANSDistanceOffsetDirection_t	 dM27DistanceOffsetDirection;
+		FANSAltitude_t	 dM28Altitude;
+		FANSAltitude_t	 dM29Altitude;
+		FANSAltitude_t	 dM30Altitude;
+		FANSPosition_t	 dM31Position;
+		FANSAltitude_t	 dM32Altitude;
+		FANSPosition_t	 dM33Position;
+		FANSSpeed_t	 dM34Speed;
+		FANSDegrees_t	 dM35Degrees;
+		FANSDegrees_t	 dM36Degrees;
+		FANSAltitude_t	 dM37Altitude;
+		FANSAltitude_t	 dM38Altitude;
+		FANSSpeed_t	 dM39Speed;
+		FANSRouteClearance_t	 dM40RouteClearance;
+		NULL_t	 dM41NULL;
+		FANSPosition_t	 dM42Position;
+		FANSTime_t	 dM43Time;
+		FANSPosition_t	 dM44Position;
+		FANSPosition_t	 dM45Position;
+		FANSTime_t	 dM46Time;
+		FANSBeaconCode_t	 dM47BeaconCode;
+		FANSPositionReport_t	 dM48PositionReport;
+		FANSSpeed_t	 dM49Speed;
+		FANSSpeedSpeed_t	 dM50SpeedSpeed;
+		NULL_t	 dM51NULL;
+		NULL_t	 dM52NULL;
+		NULL_t	 dM53NULL;
+		FANSAltitude_t	 dM54Altitude;
+		NULL_t	 dM55NULL;
+		NULL_t	 dM56NULL;
+		FANSRemainingFuelRemainingSouls_t	 dM57RemainingFuelRemainingSouls;
+		NULL_t	 dM58NULL;
+		FANSPositionRouteClearance_t	 dM59PositionRouteClearance;
+		FANSDistanceOffsetDirection_t	 dM60DistanceOffsetDirection;
+		FANSAltitude_t	 dM61Altitude;
+		FANSErrorInformation_t	 dM62ErrorInformation;
+		NULL_t	 dM63NULL;
+		FANSICAOfacilityDesignation_t	 dM64ICAOfacilitydesignation;
+		NULL_t	 dM65NULL;
+		NULL_t	 dM66NULL;
+		FANSFreeText_t	 dM67FreeText;
+		FANSFreeText_t	 dM68FreeText;
+		NULL_t	 dM69NULL;
+		FANSDegrees_t	 dM70Degrees;
+		FANSDegrees_t	 dM71Degrees;
+		FANSAltitude_t	 dM72Altitude;
+		FANSVersionNumber_t	 dM73VersionNumber;
+		NULL_t	 dM74NULL;
+		NULL_t	 dM75NULL;
+		FANSAltitudeAltitude_t	 dM76AltitudeAltitude;
+		FANSAltitudeAltitude_t	 dM77AltitudeAltitude;
+		FANSTimeDistanceToFromPosition_t	 dM78TimeDistanceToFromPosition;
+		FANSATISCode_t	 dM79ATISCode;
+		FANSDistanceOffsetDirection_t	 dM80DistanceOffsetDirection;
+		NULL_t	 dM81NULL;
+		NULL_t	 dM82NULL;
+		NULL_t	 dM83NULL;
+		NULL_t	 dM84NULL;
+		NULL_t	 dM85NULL;
+		NULL_t	 dM86NULL;
+		NULL_t	 dM87NULL;
+		NULL_t	 dM88NULL;
+		NULL_t	 dM89NULL;
+		NULL_t	 dM90NULL;
+		NULL_t	 dM91NULL;
+		NULL_t	 dM92NULL;
+		NULL_t	 dM93NULL;
+		NULL_t	 dM94NULL;
+		NULL_t	 dM95NULL;
+		NULL_t	 dM96NULL;
+		NULL_t	 dM97NULL;
+		NULL_t	 dM98NULL;
+		NULL_t	 dM99NULL;
+		NULL_t	 dM100NULL;
+		NULL_t	 dM101NULL;
+		NULL_t	 dM102NULL;
+		NULL_t	 dM103NULL;
+		NULL_t	 dM104NULL;
+		NULL_t	 dM105NULL;
+		NULL_t	 dM106NULL;
+		NULL_t	 dM107NULL;
+		NULL_t	 dM108NULL;
+		NULL_t	 dM109NULL;
+		NULL_t	 dM110NULL;
+		NULL_t	 dM111NULL;
+		NULL_t	 dM112NULL;
+		NULL_t	 dM113NULL;
+		NULL_t	 dM114NULL;
+		NULL_t	 dM115NULL;
+		NULL_t	 dM116NULL;
+		NULL_t	 dM117NULL;
+		NULL_t	 dM118NULL;
+		NULL_t	 dM119NULL;
+		NULL_t	 dM120NULL;
+		NULL_t	 dM121NULL;
+		NULL_t	 dM122NULL;
+		NULL_t	 dM123NULL;
+		NULL_t	 dM124NULL;
+		NULL_t	 dM125NULL;
+		NULL_t	 dM126NULL;
+		NULL_t	 dM127NULL;
+		NULL_t	 dM128NULL;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSATCDownlinkMsgElementId_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATCDownlinkMsgElementId;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSATCDownlinkMsgElementId_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATCDownlinkMsgElementIdSequence.c

@@ -0,0 +1,58 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATCDownlinkMsgElementIdSequence.h"
+
+static asn_per_constraints_t asn_PER_type_FANSATCDownlinkMsgElementIdSequence_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 2,  2,  1,  4 }	/* (SIZE(1..4)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_FANSATCDownlinkMsgElementIdSequence_1[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_FANSATCDownlinkMsgElementId,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_FANSATCDownlinkMsgElementIdSequence_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_FANSATCDownlinkMsgElementIdSequence_specs_1 = {
+	sizeof(struct FANSATCDownlinkMsgElementIdSequence),
+	offsetof(struct FANSATCDownlinkMsgElementIdSequence, _asn_ctx),
+	2,	/* XER encoding is XMLValueList */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSATCDownlinkMsgElementIdSequence = {
+	"FANSATCDownlinkMsgElementIdSequence",
+	"FANSATCDownlinkMsgElementIdSequence",
+	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,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATCDownlinkMsgElementIdSequence_tags_1,
+	sizeof(asn_DEF_FANSATCDownlinkMsgElementIdSequence_tags_1)
+		/sizeof(asn_DEF_FANSATCDownlinkMsgElementIdSequence_tags_1[0]), /* 1 */
+	asn_DEF_FANSATCDownlinkMsgElementIdSequence_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATCDownlinkMsgElementIdSequence_tags_1)
+		/sizeof(asn_DEF_FANSATCDownlinkMsgElementIdSequence_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSATCDownlinkMsgElementIdSequence_constr_1,
+	asn_MBR_FANSATCDownlinkMsgElementIdSequence_1,
+	1,	/* Single element */
+	&asn_SPC_FANSATCDownlinkMsgElementIdSequence_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATCDownlinkMsgElementIdSequence.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATCDownlinkMsgElementIdSequence_H_
+#define	_FANSATCDownlinkMsgElementIdSequence_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 FANSATCDownlinkMsgElementId;
+
+/* FANSATCDownlinkMsgElementIdSequence */
+typedef struct FANSATCDownlinkMsgElementIdSequence {
+	A_SEQUENCE_OF(struct FANSATCDownlinkMsgElementId) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSATCDownlinkMsgElementIdSequence_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATCDownlinkMsgElementIdSequence;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "FANSATCDownlinkMsgElementId.h"
+
+#endif	/* _FANSATCDownlinkMsgElementIdSequence_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATCMessageHeader.c

@@ -0,0 +1,82 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATCMessageHeader.h"
+
+static asn_TYPE_member_t asn_MBR_FANSATCMessageHeader_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSATCMessageHeader, msgIdentificationNumber),
+		(ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
+		0,
+		&asn_DEF_FANSMsgIdentificationNumber,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"msgIdentificationNumber"
+		},
+	{ ATF_POINTER, 2, offsetof(struct FANSATCMessageHeader, msgReferenceNumber),
+		(ASN_TAG_CLASS_UNIVERSAL | (2 << 2)),
+		0,
+		&asn_DEF_FANSMsgReferenceNumber,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"msgReferenceNumber"
+		},
+	{ ATF_POINTER, 1, offsetof(struct FANSATCMessageHeader, timestamp),
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_FANSTimestamp,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"timestamp"
+		},
+};
+static const int asn_MAP_FANSATCMessageHeader_oms_1[] = { 1, 2 };
+static const ber_tlv_tag_t asn_DEF_FANSATCMessageHeader_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_FANSATCMessageHeader_tag2el_1[] = {
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 0, 0, 1 }, /* msgIdentificationNumber */
+    { (ASN_TAG_CLASS_UNIVERSAL | (2 << 2)), 1, -1, 0 }, /* msgReferenceNumber */
+    { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, 0, 0 } /* timestamp */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_FANSATCMessageHeader_specs_1 = {
+	sizeof(struct FANSATCMessageHeader),
+	offsetof(struct FANSATCMessageHeader, _asn_ctx),
+	asn_MAP_FANSATCMessageHeader_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_FANSATCMessageHeader_oms_1,	/* Optional members */
+	2, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSATCMessageHeader = {
+	"FANSATCMessageHeader",
+	"FANSATCMessageHeader",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATCMessageHeader_tags_1,
+	sizeof(asn_DEF_FANSATCMessageHeader_tags_1)
+		/sizeof(asn_DEF_FANSATCMessageHeader_tags_1[0]), /* 1 */
+	asn_DEF_FANSATCMessageHeader_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATCMessageHeader_tags_1)
+		/sizeof(asn_DEF_FANSATCMessageHeader_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_FANSATCMessageHeader_1,
+	3,	/* Elements count */
+	&asn_SPC_FANSATCMessageHeader_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATCMessageHeader.h

@@ -0,0 +1,47 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATCMessageHeader_H_
+#define	_FANSATCMessageHeader_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "FANSMsgIdentificationNumber.h"
+#include "FANSMsgReferenceNumber.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct FANSTimestamp;
+
+/* FANSATCMessageHeader */
+typedef struct FANSATCMessageHeader {
+	FANSMsgIdentificationNumber_t	 msgIdentificationNumber;
+	FANSMsgReferenceNumber_t	*msgReferenceNumber	/* OPTIONAL */;
+	struct FANSTimestamp	*timestamp	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSATCMessageHeader_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATCMessageHeader;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "FANSTimestamp.h"
+
+#endif	/* _FANSATCMessageHeader_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATCUplinkMessage.c

@@ -0,0 +1,264 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATCUplinkMessage.h"
+
+static asn_TYPE_member_t asn_MBR_FANSATCUplinkMessage_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSATCUplinkMessage, aTCMessageheader),
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_FANSATCMessageHeader,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"aTCMessageheader"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSATCUplinkMessage, aTCuplinkmsgelementId),
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_FANSATCUplinkMsgElementId,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"aTCuplinkmsgelementId"
+		},
+	{ ATF_POINTER, 1, offsetof(struct FANSATCUplinkMessage, aTCuplinkmsgelementid_seqOf),
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_FANSATCUplinkMsgElementIdSequence,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"aTCuplinkmsgelementid-seqOf"
+		},
+};
+static const int asn_MAP_FANSATCUplinkMessage_oms_1[] = { 2 };
+static const ber_tlv_tag_t asn_DEF_FANSATCUplinkMessage_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_FANSATCUplinkMessage_tag2el_1[] = {
+    { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 0, 0, 1 }, /* aTCMessageheader */
+    { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 2, -1, 0 }, /* aTCuplinkmsgelementid-seqOf */
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 1, 0, 0 }, /* uM0NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* uM1NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 }, /* uM2NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 1, 0, 0 }, /* uM3NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 1, 0, 0 }, /* uM4NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 1, 0, 0 }, /* uM5NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 1, 0, 0 }, /* uM6Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 1, 0, 0 }, /* uM7Time */
+    { (ASN_TAG_CLASS_CONTEXT | (8 << 2)), 1, 0, 0 }, /* uM8Position */
+    { (ASN_TAG_CLASS_CONTEXT | (9 << 2)), 1, 0, 0 }, /* uM9Time */
+    { (ASN_TAG_CLASS_CONTEXT | (10 << 2)), 1, 0, 0 }, /* uM10Position */
+    { (ASN_TAG_CLASS_CONTEXT | (11 << 2)), 1, 0, 0 }, /* uM11Time */
+    { (ASN_TAG_CLASS_CONTEXT | (12 << 2)), 1, 0, 0 }, /* uM12Position */
+    { (ASN_TAG_CLASS_CONTEXT | (13 << 2)), 1, 0, 0 }, /* uM13TimeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (14 << 2)), 1, 0, 0 }, /* uM14PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (15 << 2)), 1, 0, 0 }, /* uM15TimeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (16 << 2)), 1, 0, 0 }, /* uM16PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (17 << 2)), 1, 0, 0 }, /* uM17TimeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (18 << 2)), 1, 0, 0 }, /* uM18PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (19 << 2)), 1, 0, 0 }, /* uM19Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (20 << 2)), 1, 0, 0 }, /* uM20Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (21 << 2)), 1, 0, 0 }, /* uM21TimeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (22 << 2)), 1, 0, 0 }, /* uM22PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (23 << 2)), 1, 0, 0 }, /* uM23Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (24 << 2)), 1, 0, 0 }, /* uM24TimeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (25 << 2)), 1, 0, 0 }, /* uM25PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (26 << 2)), 1, 0, 0 }, /* uM26AltitudeTime */
+    { (ASN_TAG_CLASS_CONTEXT | (27 << 2)), 1, 0, 0 }, /* uM27AltitudePosition */
+    { (ASN_TAG_CLASS_CONTEXT | (28 << 2)), 1, 0, 0 }, /* uM28AltitudeTime */
+    { (ASN_TAG_CLASS_CONTEXT | (29 << 2)), 1, 0, 0 }, /* uM29AltitudePosition */
+    { (ASN_TAG_CLASS_CONTEXT | (30 << 2)), 1, 0, 0 }, /* uM30AltitudeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (31 << 2)), 1, 0, 0 }, /* uM31AltitudeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (32 << 2)), 1, 0, 0 }, /* uM32AltitudeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (33 << 2)), 1, 0, 0 }, /* uM33Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (34 << 2)), 1, 0, 0 }, /* uM34Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (35 << 2)), 1, 0, 0 }, /* uM35Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (36 << 2)), 1, 0, 0 }, /* uM36Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (37 << 2)), 1, 0, 0 }, /* uM37Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (38 << 2)), 1, 0, 0 }, /* uM38Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (39 << 2)), 1, 0, 0 }, /* uM39Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (40 << 2)), 1, 0, 0 }, /* uM40Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (41 << 2)), 1, 0, 0 }, /* uM41Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (42 << 2)), 1, 0, 0 }, /* uM42PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (43 << 2)), 1, 0, 0 }, /* uM43PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (44 << 2)), 1, 0, 0 }, /* uM44PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (45 << 2)), 1, 0, 0 }, /* uM45PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (46 << 2)), 1, 0, 0 }, /* uM46PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (47 << 2)), 1, 0, 0 }, /* uM47PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (48 << 2)), 1, 0, 0 }, /* uM48PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (49 << 2)), 1, 0, 0 }, /* uM49PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (50 << 2)), 1, 0, 0 }, /* uM50PositionAltitudeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (51 << 2)), 1, 0, 0 }, /* uM51PositionTime */
+    { (ASN_TAG_CLASS_CONTEXT | (52 << 2)), 1, 0, 0 }, /* uM52PositionTime */
+    { (ASN_TAG_CLASS_CONTEXT | (53 << 2)), 1, 0, 0 }, /* uM53PositionTime */
+    { (ASN_TAG_CLASS_CONTEXT | (54 << 2)), 1, 0, 0 }, /* uM54PositionTimeTime */
+    { (ASN_TAG_CLASS_CONTEXT | (55 << 2)), 1, 0, 0 }, /* uM55PositionSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (56 << 2)), 1, 0, 0 }, /* uM56PositionSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (57 << 2)), 1, 0, 0 }, /* uM57PositionSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (58 << 2)), 1, 0, 0 }, /* uM58PositionTimeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (59 << 2)), 1, 0, 0 }, /* uM59PositionTimeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (60 << 2)), 1, 0, 0 }, /* uM60PositionTimeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (61 << 2)), 1, 0, 0 }, /* uM61PositionAltitudeSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (62 << 2)), 1, 0, 0 }, /* uM62TimePositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (63 << 2)), 1, 0, 0 }, /* uM63TimePositionAltitudeSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (64 << 2)), 1, 0, 0 }, /* uM64DistanceOffsetDirection */
+    { (ASN_TAG_CLASS_CONTEXT | (65 << 2)), 1, 0, 0 }, /* uM65PositionDistanceOffsetDirection */
+    { (ASN_TAG_CLASS_CONTEXT | (66 << 2)), 1, 0, 0 }, /* uM66TimeDistanceOffsetDirection */
+    { (ASN_TAG_CLASS_CONTEXT | (67 << 2)), 1, 0, 0 }, /* uM67NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (68 << 2)), 1, 0, 0 }, /* uM68Position */
+    { (ASN_TAG_CLASS_CONTEXT | (69 << 2)), 1, 0, 0 }, /* uM69Time */
+    { (ASN_TAG_CLASS_CONTEXT | (70 << 2)), 1, 0, 0 }, /* uM70Position */
+    { (ASN_TAG_CLASS_CONTEXT | (71 << 2)), 1, 0, 0 }, /* uM71Time */
+    { (ASN_TAG_CLASS_CONTEXT | (72 << 2)), 1, 0, 0 }, /* uM72NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (73 << 2)), 1, 0, 0 }, /* uM73Predepartureclearance */
+    { (ASN_TAG_CLASS_CONTEXT | (74 << 2)), 1, 0, 0 }, /* uM74Position */
+    { (ASN_TAG_CLASS_CONTEXT | (75 << 2)), 1, 0, 0 }, /* uM75Position */
+    { (ASN_TAG_CLASS_CONTEXT | (76 << 2)), 1, 0, 0 }, /* uM76TimePosition */
+    { (ASN_TAG_CLASS_CONTEXT | (77 << 2)), 1, 0, 0 }, /* uM77PositionPosition */
+    { (ASN_TAG_CLASS_CONTEXT | (78 << 2)), 1, 0, 0 }, /* uM78AltitudePosition */
+    { (ASN_TAG_CLASS_CONTEXT | (79 << 2)), 1, 0, 0 }, /* uM79PositionRouteClearance */
+    { (ASN_TAG_CLASS_CONTEXT | (80 << 2)), 1, 0, 0 }, /* uM80RouteClearance */
+    { (ASN_TAG_CLASS_CONTEXT | (81 << 2)), 1, 0, 0 }, /* uM81ProcedureName */
+    { (ASN_TAG_CLASS_CONTEXT | (82 << 2)), 1, 0, 0 }, /* uM82DistanceOffsetDirection */
+    { (ASN_TAG_CLASS_CONTEXT | (83 << 2)), 1, 0, 0 }, /* uM83PositionRouteClearance */
+    { (ASN_TAG_CLASS_CONTEXT | (84 << 2)), 1, 0, 0 }, /* uM84PositionProcedureName */
+    { (ASN_TAG_CLASS_CONTEXT | (85 << 2)), 1, 0, 0 }, /* uM85RouteClearance */
+    { (ASN_TAG_CLASS_CONTEXT | (86 << 2)), 1, 0, 0 }, /* uM86PositionRouteClearance */
+    { (ASN_TAG_CLASS_CONTEXT | (87 << 2)), 1, 0, 0 }, /* uM87Position */
+    { (ASN_TAG_CLASS_CONTEXT | (88 << 2)), 1, 0, 0 }, /* uM88PositionPosition */
+    { (ASN_TAG_CLASS_CONTEXT | (89 << 2)), 1, 0, 0 }, /* uM89TimePosition */
+    { (ASN_TAG_CLASS_CONTEXT | (90 << 2)), 1, 0, 0 }, /* uM90AltitudePosition */
+    { (ASN_TAG_CLASS_CONTEXT | (91 << 2)), 1, 0, 0 }, /* uM91HoldClearance */
+    { (ASN_TAG_CLASS_CONTEXT | (92 << 2)), 1, 0, 0 }, /* uM92PositionAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (93 << 2)), 1, 0, 0 }, /* uM93Time */
+    { (ASN_TAG_CLASS_CONTEXT | (94 << 2)), 1, 0, 0 }, /* uM94DirectionDegrees */
+    { (ASN_TAG_CLASS_CONTEXT | (95 << 2)), 1, 0, 0 }, /* uM95DirectionDegrees */
+    { (ASN_TAG_CLASS_CONTEXT | (96 << 2)), 1, 0, 0 }, /* uM96NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (97 << 2)), 1, 0, 0 }, /* uM97PositionDegrees */
+    { (ASN_TAG_CLASS_CONTEXT | (98 << 2)), 1, 0, 0 }, /* uM98DirectionDegrees */
+    { (ASN_TAG_CLASS_CONTEXT | (99 << 2)), 1, 0, 0 }, /* uM99ProcedureName */
+    { (ASN_TAG_CLASS_CONTEXT | (100 << 2)), 1, 0, 0 }, /* uM100TimeSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (101 << 2)), 1, 0, 0 }, /* uM101PositionSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (102 << 2)), 1, 0, 0 }, /* uM102AltitudeSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (103 << 2)), 1, 0, 0 }, /* uM103TimeSpeedSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (104 << 2)), 1, 0, 0 }, /* uM104PositionSpeedSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (105 << 2)), 1, 0, 0 }, /* uM105AltitudeSpeedSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (106 << 2)), 1, 0, 0 }, /* uM106Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (107 << 2)), 1, 0, 0 }, /* uM107NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (108 << 2)), 1, 0, 0 }, /* uM108Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (109 << 2)), 1, 0, 0 }, /* uM109Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (110 << 2)), 1, 0, 0 }, /* uM110SpeedSpeed */
+    { (ASN_TAG_CLASS_CONTEXT | (111 << 2)), 1, 0, 0 }, /* uM111Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (112 << 2)), 1, 0, 0 }, /* uM112Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (113 << 2)), 1, 0, 0 }, /* uM113Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (114 << 2)), 1, 0, 0 }, /* uM114Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (115 << 2)), 1, 0, 0 }, /* uM115Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (116 << 2)), 1, 0, 0 }, /* uM116NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (117 << 2)), 1, 0, 0 }, /* uM117ICAOunitnameFrequency */
+    { (ASN_TAG_CLASS_CONTEXT | (118 << 2)), 1, 0, 0 }, /* uM118PositionICAOunitnameFrequency */
+    { (ASN_TAG_CLASS_CONTEXT | (119 << 2)), 1, 0, 0 }, /* uM119TimeICAOunitnameFrequency */
+    { (ASN_TAG_CLASS_CONTEXT | (120 << 2)), 1, 0, 0 }, /* uM120ICAOunitnameFrequency */
+    { (ASN_TAG_CLASS_CONTEXT | (121 << 2)), 1, 0, 0 }, /* uM121PositionICAOunitnameFrequency */
+    { (ASN_TAG_CLASS_CONTEXT | (122 << 2)), 1, 0, 0 }, /* uM122TimeICAOunitnameFrequency */
+    { (ASN_TAG_CLASS_CONTEXT | (123 << 2)), 1, 0, 0 }, /* uM123BeaconCode */
+    { (ASN_TAG_CLASS_CONTEXT | (124 << 2)), 1, 0, 0 }, /* uM124NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (125 << 2)), 1, 0, 0 }, /* uM125NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (126 << 2)), 1, 0, 0 }, /* uM126NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (127 << 2)), 1, 0, 0 }, /* uM127NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (128 << 2)), 1, 0, 0 }, /* uM128Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (129 << 2)), 1, 0, 0 }, /* uM129Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (130 << 2)), 1, 0, 0 }, /* uM130Position */
+    { (ASN_TAG_CLASS_CONTEXT | (131 << 2)), 1, 0, 0 }, /* uM131NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (132 << 2)), 1, 0, 0 }, /* uM132NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (133 << 2)), 1, 0, 0 }, /* uM133NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (134 << 2)), 1, 0, 0 }, /* uM134NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (135 << 2)), 1, 0, 0 }, /* uM135NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (136 << 2)), 1, 0, 0 }, /* uM136NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (137 << 2)), 1, 0, 0 }, /* uM137NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (138 << 2)), 1, 0, 0 }, /* uM138NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (139 << 2)), 1, 0, 0 }, /* uM139NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (140 << 2)), 1, 0, 0 }, /* uM140NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (141 << 2)), 1, 0, 0 }, /* uM141NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (142 << 2)), 1, 0, 0 }, /* uM142NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (143 << 2)), 1, 0, 0 }, /* uM143NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (144 << 2)), 1, 0, 0 }, /* uM144NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (145 << 2)), 1, 0, 0 }, /* uM145NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (146 << 2)), 1, 0, 0 }, /* uM146NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (147 << 2)), 1, 0, 0 }, /* uM147NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (148 << 2)), 1, 0, 0 }, /* uM148Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (149 << 2)), 1, 0, 0 }, /* uM149AltitudePosition */
+    { (ASN_TAG_CLASS_CONTEXT | (150 << 2)), 1, 0, 0 }, /* uM150AltitudeTime */
+    { (ASN_TAG_CLASS_CONTEXT | (151 << 2)), 1, 0, 0 }, /* uM151Speed */
+    { (ASN_TAG_CLASS_CONTEXT | (152 << 2)), 1, 0, 0 }, /* uM152DistanceOffsetDirection */
+    { (ASN_TAG_CLASS_CONTEXT | (153 << 2)), 1, 0, 0 }, /* uM153Altimeter */
+    { (ASN_TAG_CLASS_CONTEXT | (154 << 2)), 1, 0, 0 }, /* uM154NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (155 << 2)), 1, 0, 0 }, /* uM155Position */
+    { (ASN_TAG_CLASS_CONTEXT | (156 << 2)), 1, 0, 0 }, /* uM156NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (157 << 2)), 1, 0, 0 }, /* uM157Frequency */
+    { (ASN_TAG_CLASS_CONTEXT | (158 << 2)), 1, 0, 0 }, /* uM158ATISCode */
+    { (ASN_TAG_CLASS_CONTEXT | (159 << 2)), 1, 0, 0 }, /* uM159ErrorInformation */
+    { (ASN_TAG_CLASS_CONTEXT | (160 << 2)), 1, 0, 0 }, /* uM160ICAOfacilitydesignation */
+    { (ASN_TAG_CLASS_CONTEXT | (161 << 2)), 1, 0, 0 }, /* uM161NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (162 << 2)), 1, 0, 0 }, /* uM162NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (163 << 2)), 1, 0, 0 }, /* uM163ICAOfacilitydesignationTp4table */
+    { (ASN_TAG_CLASS_CONTEXT | (164 << 2)), 1, 0, 0 }, /* uM164NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (165 << 2)), 1, 0, 0 }, /* uM165NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (166 << 2)), 1, 0, 0 }, /* uM166NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (167 << 2)), 1, 0, 0 }, /* uM167NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (168 << 2)), 1, 0, 0 }, /* uM168NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (169 << 2)), 1, 0, 0 }, /* uM169FreeText */
+    { (ASN_TAG_CLASS_CONTEXT | (170 << 2)), 1, 0, 0 }, /* uM170FreeText */
+    { (ASN_TAG_CLASS_CONTEXT | (171 << 2)), 1, 0, 0 }, /* uM171VerticalRate */
+    { (ASN_TAG_CLASS_CONTEXT | (172 << 2)), 1, 0, 0 }, /* uM172VerticalRate */
+    { (ASN_TAG_CLASS_CONTEXT | (173 << 2)), 1, 0, 0 }, /* uM173VerticalRate */
+    { (ASN_TAG_CLASS_CONTEXT | (174 << 2)), 1, 0, 0 }, /* uM174VerticalRate */
+    { (ASN_TAG_CLASS_CONTEXT | (175 << 2)), 1, 0, 0 }, /* uM175Altitude */
+    { (ASN_TAG_CLASS_CONTEXT | (176 << 2)), 1, 0, 0 }, /* uM176NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (177 << 2)), 1, 0, 0 }, /* uM177NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (178 << 2)), 1, 0, 0 }, /* uM178NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (179 << 2)), 1, 0, 0 }, /* uM179NULL */
+    { (ASN_TAG_CLASS_CONTEXT | (180 << 2)), 1, 0, 0 }, /* uM180AltitudeAltitude */
+    { (ASN_TAG_CLASS_CONTEXT | (181 << 2)), 1, 0, 0 }, /* uM181ToFromPosition */
+    { (ASN_TAG_CLASS_CONTEXT | (182 << 2)), 1, 0, 0 } /* uM182NULL */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_FANSATCUplinkMessage_specs_1 = {
+	sizeof(struct FANSATCUplinkMessage),
+	offsetof(struct FANSATCUplinkMessage, _asn_ctx),
+	asn_MAP_FANSATCUplinkMessage_tag2el_1,
+	185,	/* Count of tags in the map */
+	asn_MAP_FANSATCUplinkMessage_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSATCUplinkMessage = {
+	"FANSATCUplinkMessage",
+	"FANSATCUplinkMessage",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATCUplinkMessage_tags_1,
+	sizeof(asn_DEF_FANSATCUplinkMessage_tags_1)
+		/sizeof(asn_DEF_FANSATCUplinkMessage_tags_1[0]), /* 1 */
+	asn_DEF_FANSATCUplinkMessage_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATCUplinkMessage_tags_1)
+		/sizeof(asn_DEF_FANSATCUplinkMessage_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_FANSATCUplinkMessage_1,
+	3,	/* Elements count */
+	&asn_SPC_FANSATCUplinkMessage_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATCUplinkMessage.h

@@ -0,0 +1,47 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATCUplinkMessage_H_
+#define	_FANSATCUplinkMessage_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "FANSATCMessageHeader.h"
+#include "FANSATCUplinkMsgElementId.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct FANSATCUplinkMsgElementIdSequence;
+
+/* FANSATCUplinkMessage */
+typedef struct FANSATCUplinkMessage {
+	FANSATCMessageHeader_t	 aTCMessageheader;
+	FANSATCUplinkMsgElementId_t	 aTCuplinkmsgelementId;
+	struct FANSATCUplinkMsgElementIdSequence	*aTCuplinkmsgelementid_seqOf	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSATCUplinkMessage_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATCUplinkMessage;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "FANSATCUplinkMsgElementIdSequence.h"
+
+#endif	/* _FANSATCUplinkMessage_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATCUplinkMsgElementId.h

@@ -0,0 +1,460 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATCUplinkMsgElementId_H_
+#define	_FANSATCUplinkMsgElementId_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NULL.h"
+#include "FANSAltitude.h"
+#include "FANSTime.h"
+#include "FANSPosition.h"
+#include "FANSTimeAltitude.h"
+#include "FANSPositionAltitude.h"
+#include "FANSAltitudeTime.h"
+#include "FANSAltitudePosition.h"
+#include "FANSAltitudeAltitude.h"
+#include "FANSPositionAltitudeAltitude.h"
+#include "FANSPositionTime.h"
+#include "FANSPositionTimeTime.h"
+#include "FANSPositionSpeed.h"
+#include "FANSPositionTimeAltitude.h"
+#include "FANSPositionAltitudeSpeed.h"
+#include "FANSTimePositionAltitude.h"
+#include "FANSTimePositionAltitudeSpeed.h"
+#include "FANSDistanceOffsetDirection.h"
+#include "FANSPositionDistanceOffsetDirection.h"
+#include "FANSTimeDistanceOffsetDirection.h"
+#include "FANSPredepartureClearance.h"
+#include "FANSTimePosition.h"
+#include "FANSPositionPosition.h"
+#include "FANSPositionRouteClearance.h"
+#include "FANSRouteClearance.h"
+#include "FANSProcedureName.h"
+#include "FANSPositionProcedureName.h"
+#include "FANSHoldClearance.h"
+#include "FANSDirectionDegrees.h"
+#include "FANSPositionDegrees.h"
+#include "FANSTimeSpeed.h"
+#include "FANSAltitudeSpeed.h"
+#include "FANSTimeSpeedSpeed.h"
+#include "FANSPositionSpeedSpeed.h"
+#include "FANSAltitudeSpeedSpeed.h"
+#include "FANSSpeed.h"
+#include "FANSSpeedSpeed.h"
+#include "FANSICAOUnitNameFrequency.h"
+#include "FANSPositionICAOUnitNameFrequency.h"
+#include "FANSTimeICAOunitnameFrequency.h"
+#include "FANSBeaconCode.h"
+#include "FANSAltimeter.h"
+#include "FANSFrequency.h"
+#include "FANSATISCode.h"
+#include "FANSErrorInformation.h"
+#include "FANSICAOfacilityDesignation.h"
+#include "FANSICAOFacilityDesignationTp4Table.h"
+#include "FANSFreeText.h"
+#include "FANSVerticalRate.h"
+#include "FANSToFromPosition.h"
+#include "constr_CHOICE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum FANSATCUplinkMsgElementId_PR {
+	FANSATCUplinkMsgElementId_PR_NOTHING,	/* No components present */
+	FANSATCUplinkMsgElementId_PR_uM0NULL,
+	FANSATCUplinkMsgElementId_PR_uM1NULL,
+	FANSATCUplinkMsgElementId_PR_uM2NULL,
+	FANSATCUplinkMsgElementId_PR_uM3NULL,
+	FANSATCUplinkMsgElementId_PR_uM4NULL,
+	FANSATCUplinkMsgElementId_PR_uM5NULL,
+	FANSATCUplinkMsgElementId_PR_uM6Altitude,
+	FANSATCUplinkMsgElementId_PR_uM7Time,
+	FANSATCUplinkMsgElementId_PR_uM8Position,
+	FANSATCUplinkMsgElementId_PR_uM9Time,
+	FANSATCUplinkMsgElementId_PR_uM10Position,
+	FANSATCUplinkMsgElementId_PR_uM11Time,
+	FANSATCUplinkMsgElementId_PR_uM12Position,
+	FANSATCUplinkMsgElementId_PR_uM13TimeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM14PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM15TimeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM16PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM17TimeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM18PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM19Altitude,
+	FANSATCUplinkMsgElementId_PR_uM20Altitude,
+	FANSATCUplinkMsgElementId_PR_uM21TimeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM22PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM23Altitude,
+	FANSATCUplinkMsgElementId_PR_uM24TimeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM25PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM26AltitudeTime,
+	FANSATCUplinkMsgElementId_PR_uM27AltitudePosition,
+	FANSATCUplinkMsgElementId_PR_uM28AltitudeTime,
+	FANSATCUplinkMsgElementId_PR_uM29AltitudePosition,
+	FANSATCUplinkMsgElementId_PR_uM30AltitudeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM31AltitudeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM32AltitudeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM33Altitude,
+	FANSATCUplinkMsgElementId_PR_uM34Altitude,
+	FANSATCUplinkMsgElementId_PR_uM35Altitude,
+	FANSATCUplinkMsgElementId_PR_uM36Altitude,
+	FANSATCUplinkMsgElementId_PR_uM37Altitude,
+	FANSATCUplinkMsgElementId_PR_uM38Altitude,
+	FANSATCUplinkMsgElementId_PR_uM39Altitude,
+	FANSATCUplinkMsgElementId_PR_uM40Altitude,
+	FANSATCUplinkMsgElementId_PR_uM41Altitude,
+	FANSATCUplinkMsgElementId_PR_uM42PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM43PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM44PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM45PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM46PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM47PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM48PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM49PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM50PositionAltitudeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM51PositionTime,
+	FANSATCUplinkMsgElementId_PR_uM52PositionTime,
+	FANSATCUplinkMsgElementId_PR_uM53PositionTime,
+	FANSATCUplinkMsgElementId_PR_uM54PositionTimeTime,
+	FANSATCUplinkMsgElementId_PR_uM55PositionSpeed,
+	FANSATCUplinkMsgElementId_PR_uM56PositionSpeed,
+	FANSATCUplinkMsgElementId_PR_uM57PositionSpeed,
+	FANSATCUplinkMsgElementId_PR_uM58PositionTimeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM59PositionTimeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM60PositionTimeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM61PositionAltitudeSpeed,
+	FANSATCUplinkMsgElementId_PR_uM62TimePositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM63TimePositionAltitudeSpeed,
+	FANSATCUplinkMsgElementId_PR_uM64DistanceOffsetDirection,
+	FANSATCUplinkMsgElementId_PR_uM65PositionDistanceOffsetDirection,
+	FANSATCUplinkMsgElementId_PR_uM66TimeDistanceOffsetDirection,
+	FANSATCUplinkMsgElementId_PR_uM67NULL,
+	FANSATCUplinkMsgElementId_PR_uM68Position,
+	FANSATCUplinkMsgElementId_PR_uM69Time,
+	FANSATCUplinkMsgElementId_PR_uM70Position,
+	FANSATCUplinkMsgElementId_PR_uM71Time,
+	FANSATCUplinkMsgElementId_PR_uM72NULL,
+	FANSATCUplinkMsgElementId_PR_uM73Predepartureclearance,
+	FANSATCUplinkMsgElementId_PR_uM74Position,
+	FANSATCUplinkMsgElementId_PR_uM75Position,
+	FANSATCUplinkMsgElementId_PR_uM76TimePosition,
+	FANSATCUplinkMsgElementId_PR_uM77PositionPosition,
+	FANSATCUplinkMsgElementId_PR_uM78AltitudePosition,
+	FANSATCUplinkMsgElementId_PR_uM79PositionRouteClearance,
+	FANSATCUplinkMsgElementId_PR_uM80RouteClearance,
+	FANSATCUplinkMsgElementId_PR_uM81ProcedureName,
+	FANSATCUplinkMsgElementId_PR_uM82DistanceOffsetDirection,
+	FANSATCUplinkMsgElementId_PR_uM83PositionRouteClearance,
+	FANSATCUplinkMsgElementId_PR_uM84PositionProcedureName,
+	FANSATCUplinkMsgElementId_PR_uM85RouteClearance,
+	FANSATCUplinkMsgElementId_PR_uM86PositionRouteClearance,
+	FANSATCUplinkMsgElementId_PR_uM87Position,
+	FANSATCUplinkMsgElementId_PR_uM88PositionPosition,
+	FANSATCUplinkMsgElementId_PR_uM89TimePosition,
+	FANSATCUplinkMsgElementId_PR_uM90AltitudePosition,
+	FANSATCUplinkMsgElementId_PR_uM91HoldClearance,
+	FANSATCUplinkMsgElementId_PR_uM92PositionAltitude,
+	FANSATCUplinkMsgElementId_PR_uM93Time,
+	FANSATCUplinkMsgElementId_PR_uM94DirectionDegrees,
+	FANSATCUplinkMsgElementId_PR_uM95DirectionDegrees,
+	FANSATCUplinkMsgElementId_PR_uM96NULL,
+	FANSATCUplinkMsgElementId_PR_uM97PositionDegrees,
+	FANSATCUplinkMsgElementId_PR_uM98DirectionDegrees,
+	FANSATCUplinkMsgElementId_PR_uM99ProcedureName,
+	FANSATCUplinkMsgElementId_PR_uM100TimeSpeed,
+	FANSATCUplinkMsgElementId_PR_uM101PositionSpeed,
+	FANSATCUplinkMsgElementId_PR_uM102AltitudeSpeed,
+	FANSATCUplinkMsgElementId_PR_uM103TimeSpeedSpeed,
+	FANSATCUplinkMsgElementId_PR_uM104PositionSpeedSpeed,
+	FANSATCUplinkMsgElementId_PR_uM105AltitudeSpeedSpeed,
+	FANSATCUplinkMsgElementId_PR_uM106Speed,
+	FANSATCUplinkMsgElementId_PR_uM107NULL,
+	FANSATCUplinkMsgElementId_PR_uM108Speed,
+	FANSATCUplinkMsgElementId_PR_uM109Speed,
+	FANSATCUplinkMsgElementId_PR_uM110SpeedSpeed,
+	FANSATCUplinkMsgElementId_PR_uM111Speed,
+	FANSATCUplinkMsgElementId_PR_uM112Speed,
+	FANSATCUplinkMsgElementId_PR_uM113Speed,
+	FANSATCUplinkMsgElementId_PR_uM114Speed,
+	FANSATCUplinkMsgElementId_PR_uM115Speed,
+	FANSATCUplinkMsgElementId_PR_uM116NULL,
+	FANSATCUplinkMsgElementId_PR_uM117ICAOunitnameFrequency,
+	FANSATCUplinkMsgElementId_PR_uM118PositionICAOunitnameFrequency,
+	FANSATCUplinkMsgElementId_PR_uM119TimeICAOunitnameFrequency,
+	FANSATCUplinkMsgElementId_PR_uM120ICAOunitnameFrequency,
+	FANSATCUplinkMsgElementId_PR_uM121PositionICAOunitnameFrequency,
+	FANSATCUplinkMsgElementId_PR_uM122TimeICAOunitnameFrequency,
+	FANSATCUplinkMsgElementId_PR_uM123BeaconCode,
+	FANSATCUplinkMsgElementId_PR_uM124NULL,
+	FANSATCUplinkMsgElementId_PR_uM125NULL,
+	FANSATCUplinkMsgElementId_PR_uM126NULL,
+	FANSATCUplinkMsgElementId_PR_uM127NULL,
+	FANSATCUplinkMsgElementId_PR_uM128Altitude,
+	FANSATCUplinkMsgElementId_PR_uM129Altitude,
+	FANSATCUplinkMsgElementId_PR_uM130Position,
+	FANSATCUplinkMsgElementId_PR_uM131NULL,
+	FANSATCUplinkMsgElementId_PR_uM132NULL,
+	FANSATCUplinkMsgElementId_PR_uM133NULL,
+	FANSATCUplinkMsgElementId_PR_uM134NULL,
+	FANSATCUplinkMsgElementId_PR_uM135NULL,
+	FANSATCUplinkMsgElementId_PR_uM136NULL,
+	FANSATCUplinkMsgElementId_PR_uM137NULL,
+	FANSATCUplinkMsgElementId_PR_uM138NULL,
+	FANSATCUplinkMsgElementId_PR_uM139NULL,
+	FANSATCUplinkMsgElementId_PR_uM140NULL,
+	FANSATCUplinkMsgElementId_PR_uM141NULL,
+	FANSATCUplinkMsgElementId_PR_uM142NULL,
+	FANSATCUplinkMsgElementId_PR_uM143NULL,
+	FANSATCUplinkMsgElementId_PR_uM144NULL,
+	FANSATCUplinkMsgElementId_PR_uM145NULL,
+	FANSATCUplinkMsgElementId_PR_uM146NULL,
+	FANSATCUplinkMsgElementId_PR_uM147NULL,
+	FANSATCUplinkMsgElementId_PR_uM148Altitude,
+	FANSATCUplinkMsgElementId_PR_uM149AltitudePosition,
+	FANSATCUplinkMsgElementId_PR_uM150AltitudeTime,
+	FANSATCUplinkMsgElementId_PR_uM151Speed,
+	FANSATCUplinkMsgElementId_PR_uM152DistanceOffsetDirection,
+	FANSATCUplinkMsgElementId_PR_uM153Altimeter,
+	FANSATCUplinkMsgElementId_PR_uM154NULL,
+	FANSATCUplinkMsgElementId_PR_uM155Position,
+	FANSATCUplinkMsgElementId_PR_uM156NULL,
+	FANSATCUplinkMsgElementId_PR_uM157Frequency,
+	FANSATCUplinkMsgElementId_PR_uM158ATISCode,
+	FANSATCUplinkMsgElementId_PR_uM159ErrorInformation,
+	FANSATCUplinkMsgElementId_PR_uM160ICAOfacilitydesignation,
+	FANSATCUplinkMsgElementId_PR_uM161NULL,
+	FANSATCUplinkMsgElementId_PR_uM162NULL,
+	FANSATCUplinkMsgElementId_PR_uM163ICAOfacilitydesignationTp4table,
+	FANSATCUplinkMsgElementId_PR_uM164NULL,
+	FANSATCUplinkMsgElementId_PR_uM165NULL,
+	FANSATCUplinkMsgElementId_PR_uM166NULL,
+	FANSATCUplinkMsgElementId_PR_uM167NULL,
+	FANSATCUplinkMsgElementId_PR_uM168NULL,
+	FANSATCUplinkMsgElementId_PR_uM169FreeText,
+	FANSATCUplinkMsgElementId_PR_uM170FreeText,
+	FANSATCUplinkMsgElementId_PR_uM171VerticalRate,
+	FANSATCUplinkMsgElementId_PR_uM172VerticalRate,
+	FANSATCUplinkMsgElementId_PR_uM173VerticalRate,
+	FANSATCUplinkMsgElementId_PR_uM174VerticalRate,
+	FANSATCUplinkMsgElementId_PR_uM175Altitude,
+	FANSATCUplinkMsgElementId_PR_uM176NULL,
+	FANSATCUplinkMsgElementId_PR_uM177NULL,
+	FANSATCUplinkMsgElementId_PR_uM178NULL,
+	FANSATCUplinkMsgElementId_PR_uM179NULL,
+	FANSATCUplinkMsgElementId_PR_uM180AltitudeAltitude,
+	FANSATCUplinkMsgElementId_PR_uM181ToFromPosition,
+	FANSATCUplinkMsgElementId_PR_uM182NULL
+} FANSATCUplinkMsgElementId_PR;
+
+/* FANSATCUplinkMsgElementId */
+typedef struct FANSATCUplinkMsgElementId {
+	FANSATCUplinkMsgElementId_PR present;
+	union FANSATCUplinkMsgElementId_u {
+		NULL_t	 uM0NULL;
+		NULL_t	 uM1NULL;
+		NULL_t	 uM2NULL;
+		NULL_t	 uM3NULL;
+		NULL_t	 uM4NULL;
+		NULL_t	 uM5NULL;
+		FANSAltitude_t	 uM6Altitude;
+		FANSTime_t	 uM7Time;
+		FANSPosition_t	 uM8Position;
+		FANSTime_t	 uM9Time;
+		FANSPosition_t	 uM10Position;
+		FANSTime_t	 uM11Time;
+		FANSPosition_t	 uM12Position;
+		FANSTimeAltitude_t	 uM13TimeAltitude;
+		FANSPositionAltitude_t	 uM14PositionAltitude;
+		FANSTimeAltitude_t	 uM15TimeAltitude;
+		FANSPositionAltitude_t	 uM16PositionAltitude;
+		FANSTimeAltitude_t	 uM17TimeAltitude;
+		FANSPositionAltitude_t	 uM18PositionAltitude;
+		FANSAltitude_t	 uM19Altitude;
+		FANSAltitude_t	 uM20Altitude;
+		FANSTimeAltitude_t	 uM21TimeAltitude;
+		FANSPositionAltitude_t	 uM22PositionAltitude;
+		FANSAltitude_t	 uM23Altitude;
+		FANSTimeAltitude_t	 uM24TimeAltitude;
+		FANSPositionAltitude_t	 uM25PositionAltitude;
+		FANSAltitudeTime_t	 uM26AltitudeTime;
+		FANSAltitudePosition_t	 uM27AltitudePosition;
+		FANSAltitudeTime_t	 uM28AltitudeTime;
+		FANSAltitudePosition_t	 uM29AltitudePosition;
+		FANSAltitudeAltitude_t	 uM30AltitudeAltitude;
+		FANSAltitudeAltitude_t	 uM31AltitudeAltitude;
+		FANSAltitudeAltitude_t	 uM32AltitudeAltitude;
+		FANSAltitude_t	 uM33Altitude;
+		FANSAltitude_t	 uM34Altitude;
+		FANSAltitude_t	 uM35Altitude;
+		FANSAltitude_t	 uM36Altitude;
+		FANSAltitude_t	 uM37Altitude;
+		FANSAltitude_t	 uM38Altitude;
+		FANSAltitude_t	 uM39Altitude;
+		FANSAltitude_t	 uM40Altitude;
+		FANSAltitude_t	 uM41Altitude;
+		FANSPositionAltitude_t	 uM42PositionAltitude;
+		FANSPositionAltitude_t	 uM43PositionAltitude;
+		FANSPositionAltitude_t	 uM44PositionAltitude;
+		FANSPositionAltitude_t	 uM45PositionAltitude;
+		FANSPositionAltitude_t	 uM46PositionAltitude;
+		FANSPositionAltitude_t	 uM47PositionAltitude;
+		FANSPositionAltitude_t	 uM48PositionAltitude;
+		FANSPositionAltitude_t	 uM49PositionAltitude;
+		FANSPositionAltitudeAltitude_t	 uM50PositionAltitudeAltitude;
+		FANSPositionTime_t	 uM51PositionTime;
+		FANSPositionTime_t	 uM52PositionTime;
+		FANSPositionTime_t	 uM53PositionTime;
+		FANSPositionTimeTime_t	 uM54PositionTimeTime;
+		FANSPositionSpeed_t	 uM55PositionSpeed;
+		FANSPositionSpeed_t	 uM56PositionSpeed;
+		FANSPositionSpeed_t	 uM57PositionSpeed;
+		FANSPositionTimeAltitude_t	 uM58PositionTimeAltitude;
+		FANSPositionTimeAltitude_t	 uM59PositionTimeAltitude;
+		FANSPositionTimeAltitude_t	 uM60PositionTimeAltitude;
+		FANSPositionAltitudeSpeed_t	 uM61PositionAltitudeSpeed;
+		FANSTimePositionAltitude_t	 uM62TimePositionAltitude;
+		FANSTimePositionAltitudeSpeed_t	 uM63TimePositionAltitudeSpeed;
+		FANSDistanceOffsetDirection_t	 uM64DistanceOffsetDirection;
+		FANSPositionDistanceOffsetDirection_t	 uM65PositionDistanceOffsetDirection;
+		FANSTimeDistanceOffsetDirection_t	 uM66TimeDistanceOffsetDirection;
+		NULL_t	 uM67NULL;
+		FANSPosition_t	 uM68Position;
+		FANSTime_t	 uM69Time;
+		FANSPosition_t	 uM70Position;
+		FANSTime_t	 uM71Time;
+		NULL_t	 uM72NULL;
+		FANSPredepartureClearance_t	 uM73Predepartureclearance;
+		FANSPosition_t	 uM74Position;
+		FANSPosition_t	 uM75Position;
+		FANSTimePosition_t	 uM76TimePosition;
+		FANSPositionPosition_t	 uM77PositionPosition;
+		FANSAltitudePosition_t	 uM78AltitudePosition;
+		FANSPositionRouteClearance_t	 uM79PositionRouteClearance;
+		FANSRouteClearance_t	 uM80RouteClearance;
+		FANSProcedureName_t	 uM81ProcedureName;
+		FANSDistanceOffsetDirection_t	 uM82DistanceOffsetDirection;
+		FANSPositionRouteClearance_t	 uM83PositionRouteClearance;
+		FANSPositionProcedureName_t	 uM84PositionProcedureName;
+		FANSRouteClearance_t	 uM85RouteClearance;
+		FANSPositionRouteClearance_t	 uM86PositionRouteClearance;
+		FANSPosition_t	 uM87Position;
+		FANSPositionPosition_t	 uM88PositionPosition;
+		FANSTimePosition_t	 uM89TimePosition;
+		FANSAltitudePosition_t	 uM90AltitudePosition;
+		FANSHoldClearance_t	 uM91HoldClearance;
+		FANSPositionAltitude_t	 uM92PositionAltitude;
+		FANSTime_t	 uM93Time;
+		FANSDirectionDegrees_t	 uM94DirectionDegrees;
+		FANSDirectionDegrees_t	 uM95DirectionDegrees;
+		NULL_t	 uM96NULL;
+		FANSPositionDegrees_t	 uM97PositionDegrees;
+		FANSDirectionDegrees_t	 uM98DirectionDegrees;
+		FANSProcedureName_t	 uM99ProcedureName;
+		FANSTimeSpeed_t	 uM100TimeSpeed;
+		FANSPositionSpeed_t	 uM101PositionSpeed;
+		FANSAltitudeSpeed_t	 uM102AltitudeSpeed;
+		FANSTimeSpeedSpeed_t	 uM103TimeSpeedSpeed;
+		FANSPositionSpeedSpeed_t	 uM104PositionSpeedSpeed;
+		FANSAltitudeSpeedSpeed_t	 uM105AltitudeSpeedSpeed;
+		FANSSpeed_t	 uM106Speed;
+		NULL_t	 uM107NULL;
+		FANSSpeed_t	 uM108Speed;
+		FANSSpeed_t	 uM109Speed;
+		FANSSpeedSpeed_t	 uM110SpeedSpeed;
+		FANSSpeed_t	 uM111Speed;
+		FANSSpeed_t	 uM112Speed;
+		FANSSpeed_t	 uM113Speed;
+		FANSSpeed_t	 uM114Speed;
+		FANSSpeed_t	 uM115Speed;
+		NULL_t	 uM116NULL;
+		FANSICAOUnitNameFrequency_t	 uM117ICAOunitnameFrequency;
+		FANSPositionICAOUnitNameFrequency_t	 uM118PositionICAOunitnameFrequency;
+		FANSTimeICAOunitnameFrequency_t	 uM119TimeICAOunitnameFrequency;
+		FANSICAOUnitNameFrequency_t	 uM120ICAOunitnameFrequency;
+		FANSPositionICAOUnitNameFrequency_t	 uM121PositionICAOunitnameFrequency;
+		FANSTimeICAOunitnameFrequency_t	 uM122TimeICAOunitnameFrequency;
+		FANSBeaconCode_t	 uM123BeaconCode;
+		NULL_t	 uM124NULL;
+		NULL_t	 uM125NULL;
+		NULL_t	 uM126NULL;
+		NULL_t	 uM127NULL;
+		FANSAltitude_t	 uM128Altitude;
+		FANSAltitude_t	 uM129Altitude;
+		FANSPosition_t	 uM130Position;
+		NULL_t	 uM131NULL;
+		NULL_t	 uM132NULL;
+		NULL_t	 uM133NULL;
+		NULL_t	 uM134NULL;
+		NULL_t	 uM135NULL;
+		NULL_t	 uM136NULL;
+		NULL_t	 uM137NULL;
+		NULL_t	 uM138NULL;
+		NULL_t	 uM139NULL;
+		NULL_t	 uM140NULL;
+		NULL_t	 uM141NULL;
+		NULL_t	 uM142NULL;
+		NULL_t	 uM143NULL;
+		NULL_t	 uM144NULL;
+		NULL_t	 uM145NULL;
+		NULL_t	 uM146NULL;
+		NULL_t	 uM147NULL;
+		FANSAltitude_t	 uM148Altitude;
+		FANSAltitudePosition_t	 uM149AltitudePosition;
+		FANSAltitudeTime_t	 uM150AltitudeTime;
+		FANSSpeed_t	 uM151Speed;
+		FANSDistanceOffsetDirection_t	 uM152DistanceOffsetDirection;
+		FANSAltimeter_t	 uM153Altimeter;
+		NULL_t	 uM154NULL;
+		FANSPosition_t	 uM155Position;
+		NULL_t	 uM156NULL;
+		FANSFrequency_t	 uM157Frequency;
+		FANSATISCode_t	 uM158ATISCode;
+		FANSErrorInformation_t	 uM159ErrorInformation;
+		FANSICAOfacilityDesignation_t	 uM160ICAOfacilitydesignation;
+		NULL_t	 uM161NULL;
+		NULL_t	 uM162NULL;
+		FANSICAOFacilityDesignationTp4Table_t	 uM163ICAOfacilitydesignationTp4table;
+		NULL_t	 uM164NULL;
+		NULL_t	 uM165NULL;
+		NULL_t	 uM166NULL;
+		NULL_t	 uM167NULL;
+		NULL_t	 uM168NULL;
+		FANSFreeText_t	 uM169FreeText;
+		FANSFreeText_t	 uM170FreeText;
+		FANSVerticalRate_t	 uM171VerticalRate;
+		FANSVerticalRate_t	 uM172VerticalRate;
+		FANSVerticalRate_t	 uM173VerticalRate;
+		FANSVerticalRate_t	 uM174VerticalRate;
+		FANSAltitude_t	 uM175Altitude;
+		NULL_t	 uM176NULL;
+		NULL_t	 uM177NULL;
+		NULL_t	 uM178NULL;
+		NULL_t	 uM179NULL;
+		FANSAltitudeAltitude_t	 uM180AltitudeAltitude;
+		FANSToFromPosition_t	 uM181ToFromPosition;
+		NULL_t	 uM182NULL;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSATCUplinkMsgElementId_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATCUplinkMsgElementId;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSATCUplinkMsgElementId_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATCUplinkMsgElementIdSequence.c

@@ -0,0 +1,58 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATCUplinkMsgElementIdSequence.h"
+
+static asn_per_constraints_t asn_PER_type_FANSATCUplinkMsgElementIdSequence_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 2,  2,  1,  4 }	/* (SIZE(1..4)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_FANSATCUplinkMsgElementIdSequence_1[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_FANSATCUplinkMsgElementId,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_FANSATCUplinkMsgElementIdSequence_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_FANSATCUplinkMsgElementIdSequence_specs_1 = {
+	sizeof(struct FANSATCUplinkMsgElementIdSequence),
+	offsetof(struct FANSATCUplinkMsgElementIdSequence, _asn_ctx),
+	2,	/* XER encoding is XMLValueList */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSATCUplinkMsgElementIdSequence = {
+	"FANSATCUplinkMsgElementIdSequence",
+	"FANSATCUplinkMsgElementIdSequence",
+	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,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATCUplinkMsgElementIdSequence_tags_1,
+	sizeof(asn_DEF_FANSATCUplinkMsgElementIdSequence_tags_1)
+		/sizeof(asn_DEF_FANSATCUplinkMsgElementIdSequence_tags_1[0]), /* 1 */
+	asn_DEF_FANSATCUplinkMsgElementIdSequence_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATCUplinkMsgElementIdSequence_tags_1)
+		/sizeof(asn_DEF_FANSATCUplinkMsgElementIdSequence_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSATCUplinkMsgElementIdSequence_constr_1,
+	asn_MBR_FANSATCUplinkMsgElementIdSequence_1,
+	1,	/* Single element */
+	&asn_SPC_FANSATCUplinkMsgElementIdSequence_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATCUplinkMsgElementIdSequence.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATCUplinkMsgElementIdSequence_H_
+#define	_FANSATCUplinkMsgElementIdSequence_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 FANSATCUplinkMsgElementId;
+
+/* FANSATCUplinkMsgElementIdSequence */
+typedef struct FANSATCUplinkMsgElementIdSequence {
+	A_SEQUENCE_OF(struct FANSATCUplinkMsgElementId) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSATCUplinkMsgElementIdSequence_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATCUplinkMsgElementIdSequence;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "FANSATCUplinkMsgElementId.h"
+
+#endif	/* _FANSATCUplinkMsgElementIdSequence_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATISCode.c

@@ -0,0 +1,162 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATISCode.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 <= 127)) return -1;
+	}
+	return 0;
+}
+
+int
+FANSATISCode_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)
+		 && !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
+FANSATISCode_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->check_constraints = asn_DEF_IA5String.check_constraints;
+	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
+FANSATISCode_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSATISCode_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSATISCode_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSATISCode_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSATISCode_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) {
+	FANSATISCode_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSATISCode_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) {
+	FANSATISCode_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSATISCode_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) {
+	FANSATISCode_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSATISCode_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) {
+	FANSATISCode_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSATISCode_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSATISCode_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSATISCode_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSATISCode_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSATISCode_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 7,  7,  0,  127 }	/* (0..127) */,
+	{ APC_CONSTRAINED,	 0,  0,  1,  1 }	/* (SIZE(1..1)) */,
+	0, 0	/* No PER character map necessary */
+};
+static const ber_tlv_tag_t asn_DEF_FANSATISCode_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSATISCode = {
+	"FANSATISCode",
+	"FANSATISCode",
+	FANSATISCode_free,
+	FANSATISCode_print,
+	FANSATISCode_constraint,
+	FANSATISCode_decode_ber,
+	FANSATISCode_encode_der,
+	FANSATISCode_decode_xer,
+	FANSATISCode_encode_xer,
+	FANSATISCode_decode_uper,
+	FANSATISCode_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATISCode_tags_1,
+	sizeof(asn_DEF_FANSATISCode_tags_1)
+		/sizeof(asn_DEF_FANSATISCode_tags_1[0]), /* 1 */
+	asn_DEF_FANSATISCode_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATISCode_tags_1)
+		/sizeof(asn_DEF_FANSATISCode_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSATISCode_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATISCode.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATISCode_H_
+#define	_FANSATISCode_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "IA5String.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSATISCode */
+typedef IA5String_t	 FANSATISCode_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATISCode;
+asn_struct_free_f FANSATISCode_free;
+asn_struct_print_f FANSATISCode_print;
+asn_constr_check_f FANSATISCode_constraint;
+ber_type_decoder_f FANSATISCode_decode_ber;
+der_type_encoder_f FANSATISCode_encode_der;
+xer_type_decoder_f FANSATISCode_decode_xer;
+xer_type_encoder_f FANSATISCode_encode_xer;
+per_type_decoder_f FANSATISCode_decode_uper;
+per_type_encoder_f FANSATISCode_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSATISCode_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATWAlongTrackWaypoint.c

@@ -0,0 +1,92 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATWAlongTrackWaypoint.h"
+
+static asn_TYPE_member_t asn_MBR_FANSATWAlongTrackWaypoint_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSATWAlongTrackWaypoint, position),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_FANSPosition,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"position"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSATWAlongTrackWaypoint, aTWdistance),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FANSATWDistance,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"aTWdistance"
+		},
+	{ ATF_POINTER, 2, offsetof(struct FANSATWAlongTrackWaypoint, speed),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_FANSSpeed,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"speed"
+		},
+	{ ATF_POINTER, 1, offsetof(struct FANSATWAlongTrackWaypoint, aTWaltitudesequence),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FANSATWAltitudeSequence,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"aTWaltitudesequence"
+		},
+};
+static const int asn_MAP_FANSATWAlongTrackWaypoint_oms_1[] = { 2, 3 };
+static const ber_tlv_tag_t asn_DEF_FANSATWAlongTrackWaypoint_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_FANSATWAlongTrackWaypoint_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* position */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* aTWdistance */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* speed */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 } /* aTWaltitudesequence */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_FANSATWAlongTrackWaypoint_specs_1 = {
+	sizeof(struct FANSATWAlongTrackWaypoint),
+	offsetof(struct FANSATWAlongTrackWaypoint, _asn_ctx),
+	asn_MAP_FANSATWAlongTrackWaypoint_tag2el_1,
+	4,	/* Count of tags in the map */
+	asn_MAP_FANSATWAlongTrackWaypoint_oms_1,	/* Optional members */
+	2, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSATWAlongTrackWaypoint = {
+	"FANSATWAlongTrackWaypoint",
+	"FANSATWAlongTrackWaypoint",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATWAlongTrackWaypoint_tags_1,
+	sizeof(asn_DEF_FANSATWAlongTrackWaypoint_tags_1)
+		/sizeof(asn_DEF_FANSATWAlongTrackWaypoint_tags_1[0]), /* 1 */
+	asn_DEF_FANSATWAlongTrackWaypoint_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATWAlongTrackWaypoint_tags_1)
+		/sizeof(asn_DEF_FANSATWAlongTrackWaypoint_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_FANSATWAlongTrackWaypoint_1,
+	4,	/* Elements count */
+	&asn_SPC_FANSATWAlongTrackWaypoint_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATWAlongTrackWaypoint.h

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATWAlongTrackWaypoint_H_
+#define	_FANSATWAlongTrackWaypoint_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "FANSPosition.h"
+#include "FANSATWDistance.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct FANSSpeed;
+struct FANSATWAltitudeSequence;
+
+/* FANSATWAlongTrackWaypoint */
+typedef struct FANSATWAlongTrackWaypoint {
+	FANSPosition_t	 position;
+	FANSATWDistance_t	 aTWdistance;
+	struct FANSSpeed	*speed	/* OPTIONAL */;
+	struct FANSATWAltitudeSequence	*aTWaltitudesequence	/* OPTIONAL */;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSATWAlongTrackWaypoint_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATWAlongTrackWaypoint;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "FANSSpeed.h"
+#include "FANSATWAltitudeSequence.h"
+
+#endif	/* _FANSATWAlongTrackWaypoint_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATWAlongTrackWaypointSequence.c

@@ -0,0 +1,58 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATWAlongTrackWaypointSequence.h"
+
+static asn_per_constraints_t asn_PER_type_FANSATWAlongTrackWaypointSequence_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 3,  3,  1,  8 }	/* (SIZE(1..8)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_FANSATWAlongTrackWaypointSequence_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_FANSATWAlongTrackWaypoint,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_FANSATWAlongTrackWaypointSequence_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_FANSATWAlongTrackWaypointSequence_specs_1 = {
+	sizeof(struct FANSATWAlongTrackWaypointSequence),
+	offsetof(struct FANSATWAlongTrackWaypointSequence, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSATWAlongTrackWaypointSequence = {
+	"FANSATWAlongTrackWaypointSequence",
+	"FANSATWAlongTrackWaypointSequence",
+	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,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATWAlongTrackWaypointSequence_tags_1,
+	sizeof(asn_DEF_FANSATWAlongTrackWaypointSequence_tags_1)
+		/sizeof(asn_DEF_FANSATWAlongTrackWaypointSequence_tags_1[0]), /* 1 */
+	asn_DEF_FANSATWAlongTrackWaypointSequence_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATWAlongTrackWaypointSequence_tags_1)
+		/sizeof(asn_DEF_FANSATWAlongTrackWaypointSequence_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSATWAlongTrackWaypointSequence_constr_1,
+	asn_MBR_FANSATWAlongTrackWaypointSequence_1,
+	1,	/* Single element */
+	&asn_SPC_FANSATWAlongTrackWaypointSequence_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATWAlongTrackWaypointSequence.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATWAlongTrackWaypointSequence_H_
+#define	_FANSATWAlongTrackWaypointSequence_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 FANSATWAlongTrackWaypoint;
+
+/* FANSATWAlongTrackWaypointSequence */
+typedef struct FANSATWAlongTrackWaypointSequence {
+	A_SEQUENCE_OF(struct FANSATWAlongTrackWaypoint) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSATWAlongTrackWaypointSequence_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATWAlongTrackWaypointSequence;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "FANSATWAlongTrackWaypoint.h"
+
+#endif	/* _FANSATWAlongTrackWaypointSequence_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATWAltitude.c

@@ -0,0 +1,77 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATWAltitude.h"
+
+static asn_TYPE_member_t asn_MBR_FANSATWAltitude_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSATWAltitude, aTWAltitudeTolerance),
+		(ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
+		0,
+		&asn_DEF_FANSATWAltitudeTolerance,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"aTWAltitudeTolerance"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSATWAltitude, altitude),
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_FANSAltitude,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altitude"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_FANSATWAltitude_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_FANSATWAltitude_tag2el_1[] = {
+    { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 0, 0, 0 }, /* aTWAltitudeTolerance */
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 1, 0, 0 }, /* altitudeQNH */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* altitudeQNHMeters */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, 0, 0 }, /* altitudeQFE */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 1, 0, 0 }, /* altitudeQFEMeters */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 1, 0, 0 }, /* altitudeGNSSFeet */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 1, 0, 0 }, /* altitudeGNSSMeters */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 1, 0, 0 }, /* altitudeFlightLevel */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 1, 0, 0 } /* altitudeFlightLevelMetric */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_FANSATWAltitude_specs_1 = {
+	sizeof(struct FANSATWAltitude),
+	offsetof(struct FANSATWAltitude, _asn_ctx),
+	asn_MAP_FANSATWAltitude_tag2el_1,
+	9,	/* 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_FANSATWAltitude = {
+	"FANSATWAltitude",
+	"FANSATWAltitude",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATWAltitude_tags_1,
+	sizeof(asn_DEF_FANSATWAltitude_tags_1)
+		/sizeof(asn_DEF_FANSATWAltitude_tags_1[0]), /* 1 */
+	asn_DEF_FANSATWAltitude_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATWAltitude_tags_1)
+		/sizeof(asn_DEF_FANSATWAltitude_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_FANSATWAltitude_1,
+	2,	/* Elements count */
+	&asn_SPC_FANSATWAltitude_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATWAltitude.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATWAltitude_H_
+#define	_FANSATWAltitude_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "FANSATWAltitudeTolerance.h"
+#include "FANSAltitude.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSATWAltitude */
+typedef struct FANSATWAltitude {
+	FANSATWAltitudeTolerance_t	 aTWAltitudeTolerance;
+	FANSAltitude_t	 altitude;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSATWAltitude_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATWAltitude;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSATWAltitude_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATWAltitudeSequence.c

@@ -0,0 +1,58 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATWAltitudeSequence.h"
+
+static asn_per_constraints_t asn_PER_type_FANSATWAltitudeSequence_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 1,  1,  1,  2 }	/* (SIZE(1..2)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_FANSATWAltitudeSequence_1[] = {
+	{ ATF_POINTER, 0, 0,
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_FANSATWAltitude,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_FANSATWAltitudeSequence_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_FANSATWAltitudeSequence_specs_1 = {
+	sizeof(struct FANSATWAltitudeSequence),
+	offsetof(struct FANSATWAltitudeSequence, _asn_ctx),
+	0,	/* XER encoding is XMLDelimitedItemList */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSATWAltitudeSequence = {
+	"FANSATWAltitudeSequence",
+	"FANSATWAltitudeSequence",
+	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,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATWAltitudeSequence_tags_1,
+	sizeof(asn_DEF_FANSATWAltitudeSequence_tags_1)
+		/sizeof(asn_DEF_FANSATWAltitudeSequence_tags_1[0]), /* 1 */
+	asn_DEF_FANSATWAltitudeSequence_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATWAltitudeSequence_tags_1)
+		/sizeof(asn_DEF_FANSATWAltitudeSequence_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSATWAltitudeSequence_constr_1,
+	asn_MBR_FANSATWAltitudeSequence_1,
+	1,	/* Single element */
+	&asn_SPC_FANSATWAltitudeSequence_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATWAltitudeSequence.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATWAltitudeSequence_H_
+#define	_FANSATWAltitudeSequence_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 FANSATWAltitude;
+
+/* FANSATWAltitudeSequence */
+typedef struct FANSATWAltitudeSequence {
+	A_SEQUENCE_OF(struct FANSATWAltitude) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSATWAltitudeSequence_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATWAltitudeSequence;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "FANSATWAltitude.h"
+
+#endif	/* _FANSATWAltitudeSequence_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATWAltitudeTolerance.c

@@ -0,0 +1,149 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATWAltitudeTolerance.h"
+
+int
+FANSATWAltitudeTolerance_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_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+FANSATWAltitudeTolerance_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+FANSATWAltitudeTolerance_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSATWAltitudeTolerance_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSATWAltitudeTolerance_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSATWAltitudeTolerance_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSATWAltitudeTolerance_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) {
+	FANSATWAltitudeTolerance_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSATWAltitudeTolerance_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) {
+	FANSATWAltitudeTolerance_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSATWAltitudeTolerance_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) {
+	FANSATWAltitudeTolerance_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSATWAltitudeTolerance_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) {
+	FANSATWAltitudeTolerance_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSATWAltitudeTolerance_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSATWAltitudeTolerance_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSATWAltitudeTolerance_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSATWAltitudeTolerance_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSATWAltitudeTolerance_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 2,  2,  0,  2 }	/* (0..2) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_FANSATWAltitudeTolerance_value2enum_1[] = {
+	{ 0,	2,	"at" },
+	{ 1,	9,	"atorabove" },
+	{ 2,	9,	"atorbelow" }
+};
+static const unsigned int asn_MAP_FANSATWAltitudeTolerance_enum2value_1[] = {
+	0,	/* at(0) */
+	1,	/* atorabove(1) */
+	2	/* atorbelow(2) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_FANSATWAltitudeTolerance_specs_1 = {
+	asn_MAP_FANSATWAltitudeTolerance_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_FANSATWAltitudeTolerance_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 const ber_tlv_tag_t asn_DEF_FANSATWAltitudeTolerance_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSATWAltitudeTolerance = {
+	"FANSATWAltitudeTolerance",
+	"FANSATWAltitudeTolerance",
+	FANSATWAltitudeTolerance_free,
+	FANSATWAltitudeTolerance_print,
+	FANSATWAltitudeTolerance_constraint,
+	FANSATWAltitudeTolerance_decode_ber,
+	FANSATWAltitudeTolerance_encode_der,
+	FANSATWAltitudeTolerance_decode_xer,
+	FANSATWAltitudeTolerance_encode_xer,
+	FANSATWAltitudeTolerance_decode_uper,
+	FANSATWAltitudeTolerance_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATWAltitudeTolerance_tags_1,
+	sizeof(asn_DEF_FANSATWAltitudeTolerance_tags_1)
+		/sizeof(asn_DEF_FANSATWAltitudeTolerance_tags_1[0]), /* 1 */
+	asn_DEF_FANSATWAltitudeTolerance_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATWAltitudeTolerance_tags_1)
+		/sizeof(asn_DEF_FANSATWAltitudeTolerance_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSATWAltitudeTolerance_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_FANSATWAltitudeTolerance_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATWAltitudeTolerance.h

@@ -0,0 +1,48 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATWAltitudeTolerance_H_
+#define	_FANSATWAltitudeTolerance_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeEnumerated.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum FANSATWAltitudeTolerance {
+	FANSATWAltitudeTolerance_at	= 0,
+	FANSATWAltitudeTolerance_atorabove	= 1,
+	FANSATWAltitudeTolerance_atorbelow	= 2
+} e_FANSATWAltitudeTolerance;
+
+/* FANSATWAltitudeTolerance */
+typedef long	 FANSATWAltitudeTolerance_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATWAltitudeTolerance;
+asn_struct_free_f FANSATWAltitudeTolerance_free;
+asn_struct_print_f FANSATWAltitudeTolerance_print;
+asn_constr_check_f FANSATWAltitudeTolerance_constraint;
+ber_type_decoder_f FANSATWAltitudeTolerance_decode_ber;
+der_type_encoder_f FANSATWAltitudeTolerance_encode_der;
+xer_type_decoder_f FANSATWAltitudeTolerance_decode_xer;
+xer_type_encoder_f FANSATWAltitudeTolerance_encode_xer;
+per_type_decoder_f FANSATWAltitudeTolerance_decode_uper;
+per_type_encoder_f FANSATWAltitudeTolerance_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSATWAltitudeTolerance_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATWDistance.c

@@ -0,0 +1,71 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATWDistance.h"
+
+static asn_TYPE_member_t asn_MBR_FANSATWDistance_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSATWDistance, atwDistanceTolerance),
+		(ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
+		0,
+		&asn_DEF_FANSATWDistanceTolerance,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"atwDistanceTolerance"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSATWDistance, distance),
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_FANSDistance,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"distance"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_FANSATWDistance_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_FANSATWDistance_tag2el_1[] = {
+    { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 0, 0, 0 }, /* atwDistanceTolerance */
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 1, 0, 0 }, /* distanceNm */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* distanceKm */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_FANSATWDistance_specs_1 = {
+	sizeof(struct FANSATWDistance),
+	offsetof(struct FANSATWDistance, _asn_ctx),
+	asn_MAP_FANSATWDistance_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_FANSATWDistance = {
+	"FANSATWDistance",
+	"FANSATWDistance",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATWDistance_tags_1,
+	sizeof(asn_DEF_FANSATWDistance_tags_1)
+		/sizeof(asn_DEF_FANSATWDistance_tags_1[0]), /* 1 */
+	asn_DEF_FANSATWDistance_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATWDistance_tags_1)
+		/sizeof(asn_DEF_FANSATWDistance_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_FANSATWDistance_1,
+	2,	/* Elements count */
+	&asn_SPC_FANSATWDistance_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATWDistance.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATWDistance_H_
+#define	_FANSATWDistance_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "FANSATWDistanceTolerance.h"
+#include "FANSDistance.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSATWDistance */
+typedef struct FANSATWDistance {
+	FANSATWDistanceTolerance_t	 atwDistanceTolerance;
+	FANSDistance_t	 distance;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSATWDistance_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATWDistance;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSATWDistance_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSATWDistanceTolerance.c

@@ -0,0 +1,147 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSATWDistanceTolerance.h"
+
+int
+FANSATWDistanceTolerance_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_NativeEnumerated.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using NativeEnumerated,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+FANSATWDistanceTolerance_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeEnumerated.free_struct;
+	td->print_struct   = asn_DEF_NativeEnumerated.print_struct;
+	td->check_constraints = asn_DEF_NativeEnumerated.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeEnumerated.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeEnumerated.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeEnumerated.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeEnumerated.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeEnumerated.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeEnumerated.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeEnumerated.per_constraints;
+	td->elements       = asn_DEF_NativeEnumerated.elements;
+	td->elements_count = asn_DEF_NativeEnumerated.elements_count;
+     /* td->specifics      = asn_DEF_NativeEnumerated.specifics;	// Defined explicitly */
+}
+
+void
+FANSATWDistanceTolerance_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSATWDistanceTolerance_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSATWDistanceTolerance_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSATWDistanceTolerance_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSATWDistanceTolerance_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) {
+	FANSATWDistanceTolerance_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSATWDistanceTolerance_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) {
+	FANSATWDistanceTolerance_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSATWDistanceTolerance_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) {
+	FANSATWDistanceTolerance_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSATWDistanceTolerance_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) {
+	FANSATWDistanceTolerance_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSATWDistanceTolerance_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSATWDistanceTolerance_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSATWDistanceTolerance_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSATWDistanceTolerance_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSATWDistanceTolerance_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 1,  1,  0,  1 }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const asn_INTEGER_enum_map_t asn_MAP_FANSATWDistanceTolerance_value2enum_1[] = {
+	{ 0,	4,	"plus" },
+	{ 1,	5,	"minus" }
+};
+static const unsigned int asn_MAP_FANSATWDistanceTolerance_enum2value_1[] = {
+	1,	/* minus(1) */
+	0	/* plus(0) */
+};
+static const asn_INTEGER_specifics_t asn_SPC_FANSATWDistanceTolerance_specs_1 = {
+	asn_MAP_FANSATWDistanceTolerance_value2enum_1,	/* "tag" => N; sorted by tag */
+	asn_MAP_FANSATWDistanceTolerance_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 const ber_tlv_tag_t asn_DEF_FANSATWDistanceTolerance_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSATWDistanceTolerance = {
+	"FANSATWDistanceTolerance",
+	"FANSATWDistanceTolerance",
+	FANSATWDistanceTolerance_free,
+	FANSATWDistanceTolerance_print,
+	FANSATWDistanceTolerance_constraint,
+	FANSATWDistanceTolerance_decode_ber,
+	FANSATWDistanceTolerance_encode_der,
+	FANSATWDistanceTolerance_decode_xer,
+	FANSATWDistanceTolerance_encode_xer,
+	FANSATWDistanceTolerance_decode_uper,
+	FANSATWDistanceTolerance_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSATWDistanceTolerance_tags_1,
+	sizeof(asn_DEF_FANSATWDistanceTolerance_tags_1)
+		/sizeof(asn_DEF_FANSATWDistanceTolerance_tags_1[0]), /* 1 */
+	asn_DEF_FANSATWDistanceTolerance_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSATWDistanceTolerance_tags_1)
+		/sizeof(asn_DEF_FANSATWDistanceTolerance_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSATWDistanceTolerance_constr_1,
+	0, 0,	/* Defined elsewhere */
+	&asn_SPC_FANSATWDistanceTolerance_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSATWDistanceTolerance.h

@@ -0,0 +1,47 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSATWDistanceTolerance_H_
+#define	_FANSATWDistanceTolerance_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeEnumerated.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum FANSATWDistanceTolerance {
+	FANSATWDistanceTolerance_plus	= 0,
+	FANSATWDistanceTolerance_minus	= 1
+} e_FANSATWDistanceTolerance;
+
+/* FANSATWDistanceTolerance */
+typedef long	 FANSATWDistanceTolerance_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSATWDistanceTolerance;
+asn_struct_free_f FANSATWDistanceTolerance_free;
+asn_struct_print_f FANSATWDistanceTolerance_print;
+asn_constr_check_f FANSATWDistanceTolerance_constraint;
+ber_type_decoder_f FANSATWDistanceTolerance_decode_ber;
+der_type_encoder_f FANSATWDistanceTolerance_encode_der;
+xer_type_decoder_f FANSATWDistanceTolerance_decode_xer;
+xer_type_encoder_f FANSATWDistanceTolerance_encode_xer;
+per_type_decoder_f FANSATWDistanceTolerance_decode_uper;
+per_type_encoder_f FANSATWDistanceTolerance_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSATWDistanceTolerance_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAircraftEquipmentCode.c

@@ -0,0 +1,82 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAircraftEquipmentCode.h"
+
+static asn_TYPE_member_t asn_MBR_FANSAircraftEquipmentCode_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAircraftEquipmentCode, cOMNAVApproachEquipmentAvailable),
+		(ASN_TAG_CLASS_UNIVERSAL | (1 << 2)),
+		0,
+		&asn_DEF_FANSCOMNAVApproachEquipmentAvailable,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"cOMNAVApproachEquipmentAvailable"
+		},
+	{ ATF_POINTER, 1, offsetof(struct FANSAircraftEquipmentCode, comnavequipmentstatus_seqOf),
+		(ASN_TAG_CLASS_UNIVERSAL | (16 << 2)),
+		0,
+		&asn_DEF_FANSCOMNAVEquipmentStatusSequence,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"comnavequipmentstatus-seqOf"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAircraftEquipmentCode, sSREquipmentAvailable),
+		(ASN_TAG_CLASS_UNIVERSAL | (10 << 2)),
+		0,
+		&asn_DEF_FANSSSREquipmentAvailable,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"sSREquipmentAvailable"
+		},
+};
+static const int asn_MAP_FANSAircraftEquipmentCode_oms_1[] = { 1 };
+static const ber_tlv_tag_t asn_DEF_FANSAircraftEquipmentCode_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_FANSAircraftEquipmentCode_tag2el_1[] = {
+    { (ASN_TAG_CLASS_UNIVERSAL | (1 << 2)), 0, 0, 0 }, /* cOMNAVApproachEquipmentAvailable */
+    { (ASN_TAG_CLASS_UNIVERSAL | (10 << 2)), 2, 0, 0 }, /* sSREquipmentAvailable */
+    { (ASN_TAG_CLASS_UNIVERSAL | (16 << 2)), 1, 0, 0 } /* comnavequipmentstatus-seqOf */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_FANSAircraftEquipmentCode_specs_1 = {
+	sizeof(struct FANSAircraftEquipmentCode),
+	offsetof(struct FANSAircraftEquipmentCode, _asn_ctx),
+	asn_MAP_FANSAircraftEquipmentCode_tag2el_1,
+	3,	/* Count of tags in the map */
+	asn_MAP_FANSAircraftEquipmentCode_oms_1,	/* Optional members */
+	1, 0,	/* Root/Additions */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAircraftEquipmentCode = {
+	"FANSAircraftEquipmentCode",
+	"FANSAircraftEquipmentCode",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAircraftEquipmentCode_tags_1,
+	sizeof(asn_DEF_FANSAircraftEquipmentCode_tags_1)
+		/sizeof(asn_DEF_FANSAircraftEquipmentCode_tags_1[0]), /* 1 */
+	asn_DEF_FANSAircraftEquipmentCode_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAircraftEquipmentCode_tags_1)
+		/sizeof(asn_DEF_FANSAircraftEquipmentCode_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_FANSAircraftEquipmentCode_1,
+	3,	/* Elements count */
+	&asn_SPC_FANSAircraftEquipmentCode_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAircraftEquipmentCode.h

@@ -0,0 +1,47 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAircraftEquipmentCode_H_
+#define	_FANSAircraftEquipmentCode_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "FANSCOMNAVApproachEquipmentAvailable.h"
+#include "FANSSSREquipmentAvailable.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct FANSCOMNAVEquipmentStatusSequence;
+
+/* FANSAircraftEquipmentCode */
+typedef struct FANSAircraftEquipmentCode {
+	FANSCOMNAVApproachEquipmentAvailable_t	 cOMNAVApproachEquipmentAvailable;
+	struct FANSCOMNAVEquipmentStatusSequence	*comnavequipmentstatus_seqOf	/* OPTIONAL */;
+	FANSSSREquipmentAvailable_t	 sSREquipmentAvailable;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSAircraftEquipmentCode_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAircraftEquipmentCode;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "FANSCOMNAVEquipmentStatusSequence.h"
+
+#endif	/* _FANSAircraftEquipmentCode_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAircraftFlightIdentification.c

@@ -0,0 +1,162 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAircraftFlightIdentification.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 <= 127)) return -1;
+	}
+	return 0;
+}
+
+int
+FANSAircraftFlightIdentification_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 >= 2 && size <= 7)
+		 && !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
+FANSAircraftFlightIdentification_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->check_constraints = asn_DEF_IA5String.check_constraints;
+	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
+FANSAircraftFlightIdentification_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAircraftFlightIdentification_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAircraftFlightIdentification_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAircraftFlightIdentification_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAircraftFlightIdentification_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) {
+	FANSAircraftFlightIdentification_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAircraftFlightIdentification_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) {
+	FANSAircraftFlightIdentification_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAircraftFlightIdentification_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) {
+	FANSAircraftFlightIdentification_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAircraftFlightIdentification_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) {
+	FANSAircraftFlightIdentification_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAircraftFlightIdentification_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAircraftFlightIdentification_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAircraftFlightIdentification_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAircraftFlightIdentification_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAircraftFlightIdentification_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 7,  7,  0,  127 }	/* (0..127) */,
+	{ APC_CONSTRAINED,	 3,  3,  2,  7 }	/* (SIZE(2..7)) */,
+	0, 0	/* No PER character map necessary */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAircraftFlightIdentification_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAircraftFlightIdentification = {
+	"FANSAircraftFlightIdentification",
+	"FANSAircraftFlightIdentification",
+	FANSAircraftFlightIdentification_free,
+	FANSAircraftFlightIdentification_print,
+	FANSAircraftFlightIdentification_constraint,
+	FANSAircraftFlightIdentification_decode_ber,
+	FANSAircraftFlightIdentification_encode_der,
+	FANSAircraftFlightIdentification_decode_xer,
+	FANSAircraftFlightIdentification_encode_xer,
+	FANSAircraftFlightIdentification_decode_uper,
+	FANSAircraftFlightIdentification_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAircraftFlightIdentification_tags_1,
+	sizeof(asn_DEF_FANSAircraftFlightIdentification_tags_1)
+		/sizeof(asn_DEF_FANSAircraftFlightIdentification_tags_1[0]), /* 1 */
+	asn_DEF_FANSAircraftFlightIdentification_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAircraftFlightIdentification_tags_1)
+		/sizeof(asn_DEF_FANSAircraftFlightIdentification_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAircraftFlightIdentification_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAircraftFlightIdentification.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAircraftFlightIdentification_H_
+#define	_FANSAircraftFlightIdentification_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "IA5String.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAircraftFlightIdentification */
+typedef IA5String_t	 FANSAircraftFlightIdentification_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAircraftFlightIdentification;
+asn_struct_free_f FANSAircraftFlightIdentification_free;
+asn_struct_print_f FANSAircraftFlightIdentification_print;
+asn_constr_check_f FANSAircraftFlightIdentification_constraint;
+ber_type_decoder_f FANSAircraftFlightIdentification_decode_ber;
+der_type_encoder_f FANSAircraftFlightIdentification_encode_der;
+xer_type_decoder_f FANSAircraftFlightIdentification_decode_xer;
+xer_type_encoder_f FANSAircraftFlightIdentification_encode_xer;
+per_type_decoder_f FANSAircraftFlightIdentification_decode_uper;
+per_type_encoder_f FANSAircraftFlightIdentification_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAircraftFlightIdentification_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAircraftType.c

@@ -0,0 +1,162 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAircraftType.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 <= 127)) return -1;
+	}
+	return 0;
+}
+
+int
+FANSAircraftType_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 >= 2 && size <= 5)
+		 && !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
+FANSAircraftType_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->check_constraints = asn_DEF_IA5String.check_constraints;
+	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
+FANSAircraftType_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAircraftType_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAircraftType_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAircraftType_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAircraftType_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) {
+	FANSAircraftType_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAircraftType_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) {
+	FANSAircraftType_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAircraftType_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) {
+	FANSAircraftType_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAircraftType_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) {
+	FANSAircraftType_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAircraftType_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAircraftType_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAircraftType_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAircraftType_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAircraftType_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 7,  7,  0,  127 }	/* (0..127) */,
+	{ APC_CONSTRAINED,	 2,  2,  2,  5 }	/* (SIZE(2..5)) */,
+	0, 0	/* No PER character map necessary */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAircraftType_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAircraftType = {
+	"FANSAircraftType",
+	"FANSAircraftType",
+	FANSAircraftType_free,
+	FANSAircraftType_print,
+	FANSAircraftType_constraint,
+	FANSAircraftType_decode_ber,
+	FANSAircraftType_encode_der,
+	FANSAircraftType_decode_xer,
+	FANSAircraftType_encode_xer,
+	FANSAircraftType_decode_uper,
+	FANSAircraftType_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAircraftType_tags_1,
+	sizeof(asn_DEF_FANSAircraftType_tags_1)
+		/sizeof(asn_DEF_FANSAircraftType_tags_1[0]), /* 1 */
+	asn_DEF_FANSAircraftType_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAircraftType_tags_1)
+		/sizeof(asn_DEF_FANSAircraftType_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAircraftType_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAircraftType.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAircraftType_H_
+#define	_FANSAircraftType_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "IA5String.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAircraftType */
+typedef IA5String_t	 FANSAircraftType_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAircraftType;
+asn_struct_free_f FANSAircraftType_free;
+asn_struct_print_f FANSAircraftType_print;
+asn_constr_check_f FANSAircraftType_constraint;
+ber_type_decoder_f FANSAircraftType_decode_ber;
+der_type_encoder_f FANSAircraftType_encode_der;
+xer_type_decoder_f FANSAircraftType_decode_xer;
+xer_type_encoder_f FANSAircraftType_encode_xer;
+per_type_decoder_f FANSAircraftType_decode_uper;
+per_type_encoder_f FANSAircraftType_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAircraftType_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAirport.c

@@ -0,0 +1,162 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAirport.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 <= 127)) return -1;
+	}
+	return 0;
+}
+
+int
+FANSAirport_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 == 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
+FANSAirport_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->check_constraints = asn_DEF_IA5String.check_constraints;
+	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
+FANSAirport_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAirport_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAirport_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAirport_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirport_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) {
+	FANSAirport_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAirport_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) {
+	FANSAirport_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirport_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) {
+	FANSAirport_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAirport_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) {
+	FANSAirport_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirport_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAirport_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAirport_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAirport_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAirport_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 7,  7,  0,  127 }	/* (0..127) */,
+	{ APC_CONSTRAINED,	 0,  0,  4,  4 }	/* (SIZE(4..4)) */,
+	0, 0	/* No PER character map necessary */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAirport_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAirport = {
+	"FANSAirport",
+	"FANSAirport",
+	FANSAirport_free,
+	FANSAirport_print,
+	FANSAirport_constraint,
+	FANSAirport_decode_ber,
+	FANSAirport_encode_der,
+	FANSAirport_decode_xer,
+	FANSAirport_encode_xer,
+	FANSAirport_decode_uper,
+	FANSAirport_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAirport_tags_1,
+	sizeof(asn_DEF_FANSAirport_tags_1)
+		/sizeof(asn_DEF_FANSAirport_tags_1[0]), /* 1 */
+	asn_DEF_FANSAirport_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAirport_tags_1)
+		/sizeof(asn_DEF_FANSAirport_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAirport_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAirport.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAirport_H_
+#define	_FANSAirport_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "IA5String.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAirport */
+typedef IA5String_t	 FANSAirport_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAirport;
+asn_struct_free_f FANSAirport_free;
+asn_struct_print_f FANSAirport_print;
+asn_constr_check_f FANSAirport_constraint;
+ber_type_decoder_f FANSAirport_decode_ber;
+der_type_encoder_f FANSAirport_encode_der;
+xer_type_decoder_f FANSAirport_decode_xer;
+xer_type_encoder_f FANSAirport_encode_xer;
+per_type_decoder_f FANSAirport_decode_uper;
+per_type_encoder_f FANSAirport_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAirport_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAirportDeparture.c

@@ -0,0 +1,157 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAirportDeparture.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 <= 127)) return -1;
+	}
+	return 0;
+}
+
+int
+FANSAirportDeparture_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const FANSAirport_t *st = (const FANSAirport_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)
+		 && !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 FANSAirport,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+FANSAirportDeparture_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_FANSAirport.free_struct;
+	td->print_struct   = asn_DEF_FANSAirport.print_struct;
+	td->check_constraints = asn_DEF_FANSAirport.check_constraints;
+	td->ber_decoder    = asn_DEF_FANSAirport.ber_decoder;
+	td->der_encoder    = asn_DEF_FANSAirport.der_encoder;
+	td->xer_decoder    = asn_DEF_FANSAirport.xer_decoder;
+	td->xer_encoder    = asn_DEF_FANSAirport.xer_encoder;
+	td->uper_decoder   = asn_DEF_FANSAirport.uper_decoder;
+	td->uper_encoder   = asn_DEF_FANSAirport.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_FANSAirport.per_constraints;
+	td->elements       = asn_DEF_FANSAirport.elements;
+	td->elements_count = asn_DEF_FANSAirport.elements_count;
+	td->specifics      = asn_DEF_FANSAirport.specifics;
+}
+
+void
+FANSAirportDeparture_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAirportDeparture_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAirportDeparture_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAirportDeparture_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirportDeparture_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) {
+	FANSAirportDeparture_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAirportDeparture_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) {
+	FANSAirportDeparture_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirportDeparture_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) {
+	FANSAirportDeparture_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAirportDeparture_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) {
+	FANSAirportDeparture_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirportDeparture_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAirportDeparture_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAirportDeparture_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAirportDeparture_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static const ber_tlv_tag_t asn_DEF_FANSAirportDeparture_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAirportDeparture = {
+	"FANSAirportDeparture",
+	"FANSAirportDeparture",
+	FANSAirportDeparture_free,
+	FANSAirportDeparture_print,
+	FANSAirportDeparture_constraint,
+	FANSAirportDeparture_decode_ber,
+	FANSAirportDeparture_encode_der,
+	FANSAirportDeparture_decode_xer,
+	FANSAirportDeparture_encode_xer,
+	FANSAirportDeparture_decode_uper,
+	FANSAirportDeparture_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAirportDeparture_tags_1,
+	sizeof(asn_DEF_FANSAirportDeparture_tags_1)
+		/sizeof(asn_DEF_FANSAirportDeparture_tags_1[0]), /* 1 */
+	asn_DEF_FANSAirportDeparture_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAirportDeparture_tags_1)
+		/sizeof(asn_DEF_FANSAirportDeparture_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAirportDeparture.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAirportDeparture_H_
+#define	_FANSAirportDeparture_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "FANSAirport.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAirportDeparture */
+typedef FANSAirport_t	 FANSAirportDeparture_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAirportDeparture;
+asn_struct_free_f FANSAirportDeparture_free;
+asn_struct_print_f FANSAirportDeparture_print;
+asn_constr_check_f FANSAirportDeparture_constraint;
+ber_type_decoder_f FANSAirportDeparture_decode_ber;
+der_type_encoder_f FANSAirportDeparture_encode_der;
+xer_type_decoder_f FANSAirportDeparture_decode_xer;
+xer_type_encoder_f FANSAirportDeparture_encode_xer;
+per_type_decoder_f FANSAirportDeparture_decode_uper;
+per_type_encoder_f FANSAirportDeparture_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAirportDeparture_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAirportDestination.c

@@ -0,0 +1,157 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAirportDestination.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 <= 127)) return -1;
+	}
+	return 0;
+}
+
+int
+FANSAirportDestination_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const FANSAirport_t *st = (const FANSAirport_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)
+		 && !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 FANSAirport,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+FANSAirportDestination_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_FANSAirport.free_struct;
+	td->print_struct   = asn_DEF_FANSAirport.print_struct;
+	td->check_constraints = asn_DEF_FANSAirport.check_constraints;
+	td->ber_decoder    = asn_DEF_FANSAirport.ber_decoder;
+	td->der_encoder    = asn_DEF_FANSAirport.der_encoder;
+	td->xer_decoder    = asn_DEF_FANSAirport.xer_decoder;
+	td->xer_encoder    = asn_DEF_FANSAirport.xer_encoder;
+	td->uper_decoder   = asn_DEF_FANSAirport.uper_decoder;
+	td->uper_encoder   = asn_DEF_FANSAirport.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_FANSAirport.per_constraints;
+	td->elements       = asn_DEF_FANSAirport.elements;
+	td->elements_count = asn_DEF_FANSAirport.elements_count;
+	td->specifics      = asn_DEF_FANSAirport.specifics;
+}
+
+void
+FANSAirportDestination_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAirportDestination_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAirportDestination_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAirportDestination_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirportDestination_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) {
+	FANSAirportDestination_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAirportDestination_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) {
+	FANSAirportDestination_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirportDestination_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) {
+	FANSAirportDestination_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAirportDestination_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) {
+	FANSAirportDestination_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirportDestination_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAirportDestination_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAirportDestination_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAirportDestination_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static const ber_tlv_tag_t asn_DEF_FANSAirportDestination_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAirportDestination = {
+	"FANSAirportDestination",
+	"FANSAirportDestination",
+	FANSAirportDestination_free,
+	FANSAirportDestination_print,
+	FANSAirportDestination_constraint,
+	FANSAirportDestination_decode_ber,
+	FANSAirportDestination_encode_der,
+	FANSAirportDestination_decode_xer,
+	FANSAirportDestination_encode_xer,
+	FANSAirportDestination_decode_uper,
+	FANSAirportDestination_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAirportDestination_tags_1,
+	sizeof(asn_DEF_FANSAirportDestination_tags_1)
+		/sizeof(asn_DEF_FANSAirportDestination_tags_1[0]), /* 1 */
+	asn_DEF_FANSAirportDestination_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAirportDestination_tags_1)
+		/sizeof(asn_DEF_FANSAirportDestination_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAirportDestination.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAirportDestination_H_
+#define	_FANSAirportDestination_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "FANSAirport.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAirportDestination */
+typedef FANSAirport_t	 FANSAirportDestination_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAirportDestination;
+asn_struct_free_f FANSAirportDestination_free;
+asn_struct_print_f FANSAirportDestination_print;
+asn_constr_check_f FANSAirportDestination_constraint;
+ber_type_decoder_f FANSAirportDestination_decode_ber;
+der_type_encoder_f FANSAirportDestination_encode_der;
+xer_type_decoder_f FANSAirportDestination_decode_xer;
+xer_type_encoder_f FANSAirportDestination_encode_xer;
+per_type_decoder_f FANSAirportDestination_decode_uper;
+per_type_encoder_f FANSAirportDestination_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAirportDestination_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAirwayIdentifier.c

@@ -0,0 +1,162 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAirwayIdentifier.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 <= 127)) return -1;
+	}
+	return 0;
+}
+
+int
+FANSAirwayIdentifier_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 <= 5)
+		 && !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
+FANSAirwayIdentifier_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->check_constraints = asn_DEF_IA5String.check_constraints;
+	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
+FANSAirwayIdentifier_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAirwayIdentifier_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAirwayIdentifier_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAirwayIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirwayIdentifier_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) {
+	FANSAirwayIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAirwayIdentifier_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) {
+	FANSAirwayIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirwayIdentifier_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) {
+	FANSAirwayIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAirwayIdentifier_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) {
+	FANSAirwayIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirwayIdentifier_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAirwayIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAirwayIdentifier_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAirwayIdentifier_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAirwayIdentifier_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 7,  7,  0,  127 }	/* (0..127) */,
+	{ APC_CONSTRAINED,	 3,  3,  1,  5 }	/* (SIZE(1..5)) */,
+	0, 0	/* No PER character map necessary */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAirwayIdentifier_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAirwayIdentifier = {
+	"FANSAirwayIdentifier",
+	"FANSAirwayIdentifier",
+	FANSAirwayIdentifier_free,
+	FANSAirwayIdentifier_print,
+	FANSAirwayIdentifier_constraint,
+	FANSAirwayIdentifier_decode_ber,
+	FANSAirwayIdentifier_encode_der,
+	FANSAirwayIdentifier_decode_xer,
+	FANSAirwayIdentifier_encode_xer,
+	FANSAirwayIdentifier_decode_uper,
+	FANSAirwayIdentifier_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAirwayIdentifier_tags_1,
+	sizeof(asn_DEF_FANSAirwayIdentifier_tags_1)
+		/sizeof(asn_DEF_FANSAirwayIdentifier_tags_1[0]), /* 1 */
+	asn_DEF_FANSAirwayIdentifier_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAirwayIdentifier_tags_1)
+		/sizeof(asn_DEF_FANSAirwayIdentifier_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAirwayIdentifier_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAirwayIdentifier.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAirwayIdentifier_H_
+#define	_FANSAirwayIdentifier_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "IA5String.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAirwayIdentifier */
+typedef IA5String_t	 FANSAirwayIdentifier_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAirwayIdentifier;
+asn_struct_free_f FANSAirwayIdentifier_free;
+asn_struct_print_f FANSAirwayIdentifier_print;
+asn_constr_check_f FANSAirwayIdentifier_constraint;
+ber_type_decoder_f FANSAirwayIdentifier_decode_ber;
+der_type_encoder_f FANSAirwayIdentifier_encode_der;
+xer_type_decoder_f FANSAirwayIdentifier_decode_xer;
+xer_type_encoder_f FANSAirwayIdentifier_encode_xer;
+per_type_decoder_f FANSAirwayIdentifier_decode_uper;
+per_type_encoder_f FANSAirwayIdentifier_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAirwayIdentifier_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAirwayIntercept.c

@@ -0,0 +1,162 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAirwayIntercept.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 <= 127)) return -1;
+	}
+	return 0;
+}
+
+int
+FANSAirwayIntercept_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 <= 5)
+		 && !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
+FANSAirwayIntercept_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->check_constraints = asn_DEF_IA5String.check_constraints;
+	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
+FANSAirwayIntercept_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAirwayIntercept_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAirwayIntercept_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAirwayIntercept_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirwayIntercept_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) {
+	FANSAirwayIntercept_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAirwayIntercept_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) {
+	FANSAirwayIntercept_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirwayIntercept_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) {
+	FANSAirwayIntercept_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAirwayIntercept_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) {
+	FANSAirwayIntercept_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAirwayIntercept_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAirwayIntercept_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAirwayIntercept_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAirwayIntercept_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAirwayIntercept_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 7,  7,  0,  127 }	/* (0..127) */,
+	{ APC_CONSTRAINED,	 3,  3,  1,  5 }	/* (SIZE(1..5)) */,
+	0, 0	/* No PER character map necessary */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAirwayIntercept_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (22 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAirwayIntercept = {
+	"FANSAirwayIntercept",
+	"FANSAirwayIntercept",
+	FANSAirwayIntercept_free,
+	FANSAirwayIntercept_print,
+	FANSAirwayIntercept_constraint,
+	FANSAirwayIntercept_decode_ber,
+	FANSAirwayIntercept_encode_der,
+	FANSAirwayIntercept_decode_xer,
+	FANSAirwayIntercept_encode_xer,
+	FANSAirwayIntercept_decode_uper,
+	FANSAirwayIntercept_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAirwayIntercept_tags_1,
+	sizeof(asn_DEF_FANSAirwayIntercept_tags_1)
+		/sizeof(asn_DEF_FANSAirwayIntercept_tags_1[0]), /* 1 */
+	asn_DEF_FANSAirwayIntercept_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAirwayIntercept_tags_1)
+		/sizeof(asn_DEF_FANSAirwayIntercept_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAirwayIntercept_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAirwayIntercept.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAirwayIntercept_H_
+#define	_FANSAirwayIntercept_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "IA5String.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAirwayIntercept */
+typedef IA5String_t	 FANSAirwayIntercept_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAirwayIntercept;
+asn_struct_free_f FANSAirwayIntercept_free;
+asn_struct_print_f FANSAirwayIntercept_print;
+asn_constr_check_f FANSAirwayIntercept_constraint;
+ber_type_decoder_f FANSAirwayIntercept_decode_ber;
+der_type_encoder_f FANSAirwayIntercept_encode_der;
+xer_type_decoder_f FANSAirwayIntercept_decode_xer;
+xer_type_encoder_f FANSAirwayIntercept_encode_xer;
+per_type_decoder_f FANSAirwayIntercept_decode_uper;
+per_type_encoder_f FANSAirwayIntercept_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAirwayIntercept_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltimeter.c

@@ -0,0 +1,71 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltimeter.h"
+
+static asn_per_constraints_t asn_PER_type_FANSAltimeter_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 1,  1,  0,  1 }	/* (0..1) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_FANSAltimeter_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAltimeter, choice.altimeterEnglish),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FANSAltimeterEnglish,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altimeterEnglish"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAltimeter, choice.altimeterMetric),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FANSAltimeterMetric,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altimeterMetric"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_FANSAltimeter_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* altimeterEnglish */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* altimeterMetric */
+};
+static asn_CHOICE_specifics_t asn_SPC_FANSAltimeter_specs_1 = {
+	sizeof(struct FANSAltimeter),
+	offsetof(struct FANSAltimeter, _asn_ctx),
+	offsetof(struct FANSAltimeter, present),
+	sizeof(((struct FANSAltimeter *)0)->present),
+	asn_MAP_FANSAltimeter_tag2el_1,
+	2,	/* Count of tags in the map */
+	0,
+	-1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltimeter = {
+	"FANSAltimeter",
+	"FANSAltimeter",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	CHOICE_decode_uper,
+	CHOICE_encode_uper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	&asn_PER_type_FANSAltimeter_constr_1,
+	asn_MBR_FANSAltimeter_1,
+	2,	/* Elements count */
+	&asn_SPC_FANSAltimeter_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltimeter.h

@@ -0,0 +1,50 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltimeter_H_
+#define	_FANSAltimeter_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "FANSAltimeterEnglish.h"
+#include "FANSAltimeterMetric.h"
+#include "constr_CHOICE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum FANSAltimeter_PR {
+	FANSAltimeter_PR_NOTHING,	/* No components present */
+	FANSAltimeter_PR_altimeterEnglish,
+	FANSAltimeter_PR_altimeterMetric
+} FANSAltimeter_PR;
+
+/* FANSAltimeter */
+typedef struct FANSAltimeter {
+	FANSAltimeter_PR present;
+	union FANSAltimeter_u {
+		FANSAltimeterEnglish_t	 altimeterEnglish;
+		FANSAltimeterMetric_t	 altimeterMetric;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSAltimeter_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltimeter;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltimeter_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltimeterEnglish.c

@@ -0,0 +1,147 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltimeterEnglish.h"
+
+int
+FANSAltimeterEnglish_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 >= 2200 && value <= 3200)) {
+		/* 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
+FANSAltimeterEnglish_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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
+FANSAltimeterEnglish_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAltimeterEnglish_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAltimeterEnglish_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAltimeterEnglish_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltimeterEnglish_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) {
+	FANSAltimeterEnglish_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAltimeterEnglish_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) {
+	FANSAltimeterEnglish_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltimeterEnglish_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) {
+	FANSAltimeterEnglish_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAltimeterEnglish_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) {
+	FANSAltimeterEnglish_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltimeterEnglish_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAltimeterEnglish_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAltimeterEnglish_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAltimeterEnglish_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAltimeterEnglish_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 10,  10,  2200,  3200 }	/* (2200..3200) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAltimeterEnglish_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltimeterEnglish = {
+	"FANSAltimeterEnglish",
+	"FANSAltimeterEnglish",
+	FANSAltimeterEnglish_free,
+	FANSAltimeterEnglish_print,
+	FANSAltimeterEnglish_constraint,
+	FANSAltimeterEnglish_decode_ber,
+	FANSAltimeterEnglish_encode_der,
+	FANSAltimeterEnglish_decode_xer,
+	FANSAltimeterEnglish_encode_xer,
+	FANSAltimeterEnglish_decode_uper,
+	FANSAltimeterEnglish_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAltimeterEnglish_tags_1,
+	sizeof(asn_DEF_FANSAltimeterEnglish_tags_1)
+		/sizeof(asn_DEF_FANSAltimeterEnglish_tags_1[0]), /* 1 */
+	asn_DEF_FANSAltimeterEnglish_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAltimeterEnglish_tags_1)
+		/sizeof(asn_DEF_FANSAltimeterEnglish_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAltimeterEnglish_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltimeterEnglish.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltimeterEnglish_H_
+#define	_FANSAltimeterEnglish_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAltimeterEnglish */
+typedef long	 FANSAltimeterEnglish_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltimeterEnglish;
+asn_struct_free_f FANSAltimeterEnglish_free;
+asn_struct_print_f FANSAltimeterEnglish_print;
+asn_constr_check_f FANSAltimeterEnglish_constraint;
+ber_type_decoder_f FANSAltimeterEnglish_decode_ber;
+der_type_encoder_f FANSAltimeterEnglish_encode_der;
+xer_type_decoder_f FANSAltimeterEnglish_decode_xer;
+xer_type_encoder_f FANSAltimeterEnglish_encode_xer;
+per_type_decoder_f FANSAltimeterEnglish_decode_uper;
+per_type_encoder_f FANSAltimeterEnglish_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltimeterEnglish_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltimeterMetric.c

@@ -0,0 +1,147 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltimeterMetric.h"
+
+int
+FANSAltimeterMetric_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 >= 7500 && value <= 12500)) {
+		/* 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
+FANSAltimeterMetric_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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
+FANSAltimeterMetric_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAltimeterMetric_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAltimeterMetric_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAltimeterMetric_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltimeterMetric_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) {
+	FANSAltimeterMetric_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAltimeterMetric_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) {
+	FANSAltimeterMetric_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltimeterMetric_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) {
+	FANSAltimeterMetric_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAltimeterMetric_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) {
+	FANSAltimeterMetric_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltimeterMetric_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAltimeterMetric_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAltimeterMetric_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAltimeterMetric_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAltimeterMetric_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 13,  13,  7500,  12500 }	/* (7500..12500) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAltimeterMetric_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltimeterMetric = {
+	"FANSAltimeterMetric",
+	"FANSAltimeterMetric",
+	FANSAltimeterMetric_free,
+	FANSAltimeterMetric_print,
+	FANSAltimeterMetric_constraint,
+	FANSAltimeterMetric_decode_ber,
+	FANSAltimeterMetric_encode_der,
+	FANSAltimeterMetric_decode_xer,
+	FANSAltimeterMetric_encode_xer,
+	FANSAltimeterMetric_decode_uper,
+	FANSAltimeterMetric_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAltimeterMetric_tags_1,
+	sizeof(asn_DEF_FANSAltimeterMetric_tags_1)
+		/sizeof(asn_DEF_FANSAltimeterMetric_tags_1[0]), /* 1 */
+	asn_DEF_FANSAltimeterMetric_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAltimeterMetric_tags_1)
+		/sizeof(asn_DEF_FANSAltimeterMetric_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAltimeterMetric_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltimeterMetric.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltimeterMetric_H_
+#define	_FANSAltimeterMetric_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAltimeterMetric */
+typedef long	 FANSAltimeterMetric_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltimeterMetric;
+asn_struct_free_f FANSAltimeterMetric_free;
+asn_struct_print_f FANSAltimeterMetric_print;
+asn_constr_check_f FANSAltimeterMetric_constraint;
+ber_type_decoder_f FANSAltimeterMetric_decode_ber;
+der_type_encoder_f FANSAltimeterMetric_encode_der;
+xer_type_decoder_f FANSAltimeterMetric_decode_xer;
+xer_type_encoder_f FANSAltimeterMetric_encode_xer;
+per_type_decoder_f FANSAltimeterMetric_decode_uper;
+per_type_encoder_f FANSAltimeterMetric_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltimeterMetric_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitude.c

@@ -0,0 +1,131 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltitude.h"
+
+static asn_per_constraints_t asn_PER_type_FANSAltitude_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 3,  3,  0,  7 }	/* (0..7) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_FANSAltitude_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAltitude, choice.altitudeQNH),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FANSAltitudeQNH,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altitudeQNH"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAltitude, choice.altitudeQNHMeters),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FANSAltitudeQNHMeters,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altitudeQNHMeters"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAltitude, choice.altitudeQFE),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FANSAltitudeQFE,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altitudeQFE"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAltitude, choice.altitudeQFEMeters),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FANSAltitudeQFEMeters,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altitudeQFEMeters"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAltitude, choice.altitudeGNSSFeet),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FANSAltitudeGNSSFeet,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altitudeGNSSFeet"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAltitude, choice.altitudeGNSSMeters),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FANSAltitudeGNSSMeters,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altitudeGNSSMeters"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAltitude, choice.altitudeFlightLevel),
+		(ASN_TAG_CLASS_CONTEXT | (6 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FANSAltitudeFlightLevel,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altitudeFlightLevel"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAltitude, choice.altitudeFlightLevelMetric),
+		(ASN_TAG_CLASS_CONTEXT | (7 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_FANSAltitudeFlightLevelMetric,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altitudeFlightLevelMetric"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_FANSAltitude_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* altitudeQNH */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* altitudeQNHMeters */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* altitudeQFE */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* altitudeQFEMeters */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* altitudeGNSSFeet */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* altitudeGNSSMeters */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 6, 0, 0 }, /* altitudeFlightLevel */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 7, 0, 0 } /* altitudeFlightLevelMetric */
+};
+static asn_CHOICE_specifics_t asn_SPC_FANSAltitude_specs_1 = {
+	sizeof(struct FANSAltitude),
+	offsetof(struct FANSAltitude, _asn_ctx),
+	offsetof(struct FANSAltitude, present),
+	sizeof(((struct FANSAltitude *)0)->present),
+	asn_MAP_FANSAltitude_tag2el_1,
+	8,	/* Count of tags in the map */
+	0,
+	-1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltitude = {
+	"FANSAltitude",
+	"FANSAltitude",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	CHOICE_decode_uper,
+	CHOICE_encode_uper,
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	&asn_PER_type_FANSAltitude_constr_1,
+	asn_MBR_FANSAltitude_1,
+	8,	/* Elements count */
+	&asn_SPC_FANSAltitude_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitude.h

@@ -0,0 +1,68 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltitude_H_
+#define	_FANSAltitude_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "FANSAltitudeQNH.h"
+#include "FANSAltitudeQNHMeters.h"
+#include "FANSAltitudeQFE.h"
+#include "FANSAltitudeQFEMeters.h"
+#include "FANSAltitudeGNSSFeet.h"
+#include "FANSAltitudeGNSSMeters.h"
+#include "FANSAltitudeFlightLevel.h"
+#include "FANSAltitudeFlightLevelMetric.h"
+#include "constr_CHOICE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum FANSAltitude_PR {
+	FANSAltitude_PR_NOTHING,	/* No components present */
+	FANSAltitude_PR_altitudeQNH,
+	FANSAltitude_PR_altitudeQNHMeters,
+	FANSAltitude_PR_altitudeQFE,
+	FANSAltitude_PR_altitudeQFEMeters,
+	FANSAltitude_PR_altitudeGNSSFeet,
+	FANSAltitude_PR_altitudeGNSSMeters,
+	FANSAltitude_PR_altitudeFlightLevel,
+	FANSAltitude_PR_altitudeFlightLevelMetric
+} FANSAltitude_PR;
+
+/* FANSAltitude */
+typedef struct FANSAltitude {
+	FANSAltitude_PR present;
+	union FANSAltitude_u {
+		FANSAltitudeQNH_t	 altitudeQNH;
+		FANSAltitudeQNHMeters_t	 altitudeQNHMeters;
+		FANSAltitudeQFE_t	 altitudeQFE;
+		FANSAltitudeQFEMeters_t	 altitudeQFEMeters;
+		FANSAltitudeGNSSFeet_t	 altitudeGNSSFeet;
+		FANSAltitudeGNSSMeters_t	 altitudeGNSSMeters;
+		FANSAltitudeFlightLevel_t	 altitudeFlightLevel;
+		FANSAltitudeFlightLevelMetric_t	 altitudeFlightLevelMetric;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSAltitude_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltitude;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltitude_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeAltitude.c

@@ -0,0 +1,58 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltitudeAltitude.h"
+
+static asn_per_constraints_t asn_PER_type_FANSAltitudeAltitude_constr_1 GCC_NOTUSED = {
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	{ APC_CONSTRAINED,	 0,  0,  2,  2 }	/* (SIZE(2..2)) */,
+	0, 0	/* No PER value map */
+};
+static asn_TYPE_member_t asn_MBR_FANSAltitudeAltitude_1[] = {
+	{ ATF_POINTER, 0, 0,
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_FANSAltitude,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		""
+		},
+};
+static const ber_tlv_tag_t asn_DEF_FANSAltitudeAltitude_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static asn_SET_OF_specifics_t asn_SPC_FANSAltitudeAltitude_specs_1 = {
+	sizeof(struct FANSAltitudeAltitude),
+	offsetof(struct FANSAltitudeAltitude, _asn_ctx),
+	2,	/* XER encoding is XMLValueList */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltitudeAltitude = {
+	"FANSAltitudeAltitude",
+	"FANSAltitudeAltitude",
+	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,
+	SEQUENCE_OF_decode_uper,
+	SEQUENCE_OF_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAltitudeAltitude_tags_1,
+	sizeof(asn_DEF_FANSAltitudeAltitude_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeAltitude_tags_1[0]), /* 1 */
+	asn_DEF_FANSAltitudeAltitude_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAltitudeAltitude_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeAltitude_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAltitudeAltitude_constr_1,
+	asn_MBR_FANSAltitudeAltitude_1,
+	1,	/* Single element */
+	&asn_SPC_FANSAltitudeAltitude_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeAltitude.h

@@ -0,0 +1,44 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltitudeAltitude_H_
+#define	_FANSAltitudeAltitude_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 FANSAltitude;
+
+/* FANSAltitudeAltitude */
+typedef struct FANSAltitudeAltitude {
+	A_SEQUENCE_OF(struct FANSAltitude) list;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSAltitudeAltitude_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltitudeAltitude;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "FANSAltitude.h"
+
+#endif	/* _FANSAltitudeAltitude_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeFlightLevel.c

@@ -0,0 +1,147 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltitudeFlightLevel.h"
+
+int
+FANSAltitudeFlightLevel_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 >= 30 && value <= 600)) {
+		/* 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
+FANSAltitudeFlightLevel_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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
+FANSAltitudeFlightLevel_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAltitudeFlightLevel_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAltitudeFlightLevel_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAltitudeFlightLevel_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeFlightLevel_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) {
+	FANSAltitudeFlightLevel_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAltitudeFlightLevel_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) {
+	FANSAltitudeFlightLevel_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeFlightLevel_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) {
+	FANSAltitudeFlightLevel_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAltitudeFlightLevel_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) {
+	FANSAltitudeFlightLevel_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeFlightLevel_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAltitudeFlightLevel_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAltitudeFlightLevel_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAltitudeFlightLevel_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAltitudeFlightLevel_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 10,  10,  30,  600 }	/* (30..600) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAltitudeFlightLevel_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltitudeFlightLevel = {
+	"FANSAltitudeFlightLevel",
+	"FANSAltitudeFlightLevel",
+	FANSAltitudeFlightLevel_free,
+	FANSAltitudeFlightLevel_print,
+	FANSAltitudeFlightLevel_constraint,
+	FANSAltitudeFlightLevel_decode_ber,
+	FANSAltitudeFlightLevel_encode_der,
+	FANSAltitudeFlightLevel_decode_xer,
+	FANSAltitudeFlightLevel_encode_xer,
+	FANSAltitudeFlightLevel_decode_uper,
+	FANSAltitudeFlightLevel_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAltitudeFlightLevel_tags_1,
+	sizeof(asn_DEF_FANSAltitudeFlightLevel_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeFlightLevel_tags_1[0]), /* 1 */
+	asn_DEF_FANSAltitudeFlightLevel_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAltitudeFlightLevel_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeFlightLevel_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAltitudeFlightLevel_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeFlightLevel.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltitudeFlightLevel_H_
+#define	_FANSAltitudeFlightLevel_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAltitudeFlightLevel */
+typedef long	 FANSAltitudeFlightLevel_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltitudeFlightLevel;
+asn_struct_free_f FANSAltitudeFlightLevel_free;
+asn_struct_print_f FANSAltitudeFlightLevel_print;
+asn_constr_check_f FANSAltitudeFlightLevel_constraint;
+ber_type_decoder_f FANSAltitudeFlightLevel_decode_ber;
+der_type_encoder_f FANSAltitudeFlightLevel_encode_der;
+xer_type_decoder_f FANSAltitudeFlightLevel_decode_xer;
+xer_type_encoder_f FANSAltitudeFlightLevel_encode_xer;
+per_type_decoder_f FANSAltitudeFlightLevel_decode_uper;
+per_type_encoder_f FANSAltitudeFlightLevel_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltitudeFlightLevel_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeFlightLevelMetric.c

@@ -0,0 +1,147 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltitudeFlightLevelMetric.h"
+
+int
+FANSAltitudeFlightLevelMetric_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 >= 100 && value <= 2000)) {
+		/* 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
+FANSAltitudeFlightLevelMetric_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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
+FANSAltitudeFlightLevelMetric_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAltitudeFlightLevelMetric_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAltitudeFlightLevelMetric_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAltitudeFlightLevelMetric_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeFlightLevelMetric_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) {
+	FANSAltitudeFlightLevelMetric_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAltitudeFlightLevelMetric_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) {
+	FANSAltitudeFlightLevelMetric_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeFlightLevelMetric_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) {
+	FANSAltitudeFlightLevelMetric_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAltitudeFlightLevelMetric_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) {
+	FANSAltitudeFlightLevelMetric_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeFlightLevelMetric_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAltitudeFlightLevelMetric_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAltitudeFlightLevelMetric_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAltitudeFlightLevelMetric_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAltitudeFlightLevelMetric_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 11,  11,  100,  2000 }	/* (100..2000) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAltitudeFlightLevelMetric_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltitudeFlightLevelMetric = {
+	"FANSAltitudeFlightLevelMetric",
+	"FANSAltitudeFlightLevelMetric",
+	FANSAltitudeFlightLevelMetric_free,
+	FANSAltitudeFlightLevelMetric_print,
+	FANSAltitudeFlightLevelMetric_constraint,
+	FANSAltitudeFlightLevelMetric_decode_ber,
+	FANSAltitudeFlightLevelMetric_encode_der,
+	FANSAltitudeFlightLevelMetric_decode_xer,
+	FANSAltitudeFlightLevelMetric_encode_xer,
+	FANSAltitudeFlightLevelMetric_decode_uper,
+	FANSAltitudeFlightLevelMetric_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAltitudeFlightLevelMetric_tags_1,
+	sizeof(asn_DEF_FANSAltitudeFlightLevelMetric_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeFlightLevelMetric_tags_1[0]), /* 1 */
+	asn_DEF_FANSAltitudeFlightLevelMetric_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAltitudeFlightLevelMetric_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeFlightLevelMetric_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAltitudeFlightLevelMetric_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeFlightLevelMetric.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltitudeFlightLevelMetric_H_
+#define	_FANSAltitudeFlightLevelMetric_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAltitudeFlightLevelMetric */
+typedef long	 FANSAltitudeFlightLevelMetric_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltitudeFlightLevelMetric;
+asn_struct_free_f FANSAltitudeFlightLevelMetric_free;
+asn_struct_print_f FANSAltitudeFlightLevelMetric_print;
+asn_constr_check_f FANSAltitudeFlightLevelMetric_constraint;
+ber_type_decoder_f FANSAltitudeFlightLevelMetric_decode_ber;
+der_type_encoder_f FANSAltitudeFlightLevelMetric_encode_der;
+xer_type_decoder_f FANSAltitudeFlightLevelMetric_decode_xer;
+xer_type_encoder_f FANSAltitudeFlightLevelMetric_encode_xer;
+per_type_decoder_f FANSAltitudeFlightLevelMetric_decode_uper;
+per_type_encoder_f FANSAltitudeFlightLevelMetric_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltitudeFlightLevelMetric_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeGNSSFeet.c

@@ -0,0 +1,147 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltitudeGNSSFeet.h"
+
+int
+FANSAltitudeGNSSFeet_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 >= 0 && value <= 150000)) {
+		/* 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
+FANSAltitudeGNSSFeet_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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
+FANSAltitudeGNSSFeet_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAltitudeGNSSFeet_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAltitudeGNSSFeet_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAltitudeGNSSFeet_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeGNSSFeet_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) {
+	FANSAltitudeGNSSFeet_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAltitudeGNSSFeet_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) {
+	FANSAltitudeGNSSFeet_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeGNSSFeet_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) {
+	FANSAltitudeGNSSFeet_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAltitudeGNSSFeet_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) {
+	FANSAltitudeGNSSFeet_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeGNSSFeet_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAltitudeGNSSFeet_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAltitudeGNSSFeet_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAltitudeGNSSFeet_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAltitudeGNSSFeet_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 18, -1,  0,  150000 }	/* (0..150000) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAltitudeGNSSFeet_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltitudeGNSSFeet = {
+	"FANSAltitudeGNSSFeet",
+	"FANSAltitudeGNSSFeet",
+	FANSAltitudeGNSSFeet_free,
+	FANSAltitudeGNSSFeet_print,
+	FANSAltitudeGNSSFeet_constraint,
+	FANSAltitudeGNSSFeet_decode_ber,
+	FANSAltitudeGNSSFeet_encode_der,
+	FANSAltitudeGNSSFeet_decode_xer,
+	FANSAltitudeGNSSFeet_encode_xer,
+	FANSAltitudeGNSSFeet_decode_uper,
+	FANSAltitudeGNSSFeet_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAltitudeGNSSFeet_tags_1,
+	sizeof(asn_DEF_FANSAltitudeGNSSFeet_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeGNSSFeet_tags_1[0]), /* 1 */
+	asn_DEF_FANSAltitudeGNSSFeet_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAltitudeGNSSFeet_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeGNSSFeet_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAltitudeGNSSFeet_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeGNSSFeet.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltitudeGNSSFeet_H_
+#define	_FANSAltitudeGNSSFeet_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAltitudeGNSSFeet */
+typedef long	 FANSAltitudeGNSSFeet_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltitudeGNSSFeet;
+asn_struct_free_f FANSAltitudeGNSSFeet_free;
+asn_struct_print_f FANSAltitudeGNSSFeet_print;
+asn_constr_check_f FANSAltitudeGNSSFeet_constraint;
+ber_type_decoder_f FANSAltitudeGNSSFeet_decode_ber;
+der_type_encoder_f FANSAltitudeGNSSFeet_encode_der;
+xer_type_decoder_f FANSAltitudeGNSSFeet_decode_xer;
+xer_type_encoder_f FANSAltitudeGNSSFeet_encode_xer;
+per_type_decoder_f FANSAltitudeGNSSFeet_decode_uper;
+per_type_encoder_f FANSAltitudeGNSSFeet_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltitudeGNSSFeet_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeGNSSMeters.c

@@ -0,0 +1,147 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltitudeGNSSMeters.h"
+
+int
+FANSAltitudeGNSSMeters_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 >= 0 && value <= 50000)) {
+		/* 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
+FANSAltitudeGNSSMeters_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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
+FANSAltitudeGNSSMeters_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAltitudeGNSSMeters_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAltitudeGNSSMeters_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAltitudeGNSSMeters_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeGNSSMeters_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) {
+	FANSAltitudeGNSSMeters_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAltitudeGNSSMeters_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) {
+	FANSAltitudeGNSSMeters_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeGNSSMeters_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) {
+	FANSAltitudeGNSSMeters_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAltitudeGNSSMeters_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) {
+	FANSAltitudeGNSSMeters_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeGNSSMeters_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAltitudeGNSSMeters_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAltitudeGNSSMeters_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAltitudeGNSSMeters_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAltitudeGNSSMeters_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 16,  16,  0,  50000 }	/* (0..50000) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAltitudeGNSSMeters_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltitudeGNSSMeters = {
+	"FANSAltitudeGNSSMeters",
+	"FANSAltitudeGNSSMeters",
+	FANSAltitudeGNSSMeters_free,
+	FANSAltitudeGNSSMeters_print,
+	FANSAltitudeGNSSMeters_constraint,
+	FANSAltitudeGNSSMeters_decode_ber,
+	FANSAltitudeGNSSMeters_encode_der,
+	FANSAltitudeGNSSMeters_decode_xer,
+	FANSAltitudeGNSSMeters_encode_xer,
+	FANSAltitudeGNSSMeters_decode_uper,
+	FANSAltitudeGNSSMeters_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAltitudeGNSSMeters_tags_1,
+	sizeof(asn_DEF_FANSAltitudeGNSSMeters_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeGNSSMeters_tags_1[0]), /* 1 */
+	asn_DEF_FANSAltitudeGNSSMeters_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAltitudeGNSSMeters_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeGNSSMeters_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAltitudeGNSSMeters_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeGNSSMeters.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltitudeGNSSMeters_H_
+#define	_FANSAltitudeGNSSMeters_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAltitudeGNSSMeters */
+typedef long	 FANSAltitudeGNSSMeters_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltitudeGNSSMeters;
+asn_struct_free_f FANSAltitudeGNSSMeters_free;
+asn_struct_print_f FANSAltitudeGNSSMeters_print;
+asn_constr_check_f FANSAltitudeGNSSMeters_constraint;
+ber_type_decoder_f FANSAltitudeGNSSMeters_decode_ber;
+der_type_encoder_f FANSAltitudeGNSSMeters_encode_der;
+xer_type_decoder_f FANSAltitudeGNSSMeters_decode_xer;
+xer_type_encoder_f FANSAltitudeGNSSMeters_encode_xer;
+per_type_decoder_f FANSAltitudeGNSSMeters_decode_uper;
+per_type_encoder_f FANSAltitudeGNSSMeters_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltitudeGNSSMeters_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudePosition.c

@@ -0,0 +1,81 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltitudePosition.h"
+
+static asn_TYPE_member_t asn_MBR_FANSAltitudePosition_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAltitudePosition, altitude),
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_FANSAltitude,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"altitude"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct FANSAltitudePosition, position),
+		-1 /* Ambiguous tag (CHOICE?) */,
+		0,
+		&asn_DEF_FANSPosition,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* No PER visible constraints */
+		0,
+		"position"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_FANSAltitudePosition_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_FANSAltitudePosition_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 1 }, /* altitudeQNH */
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 1, -1, 0 }, /* fixName */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 0, 0, 1 }, /* altitudeQNHMeters */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, -1, 0 }, /* navaid */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 0, 0, 1 }, /* altitudeQFE */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 1, -1, 0 }, /* airport */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 0, 0, 1 }, /* altitudeQFEMeters */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 1, -1, 0 }, /* latitudeLongitude */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 0, 0, 1 }, /* altitudeGNSSFeet */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 1, -1, 0 }, /* placeBearingDistance */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 0, 0, 0 }, /* altitudeGNSSMeters */
+    { (ASN_TAG_CLASS_CONTEXT | (6 << 2)), 0, 0, 0 }, /* altitudeFlightLevel */
+    { (ASN_TAG_CLASS_CONTEXT | (7 << 2)), 0, 0, 0 } /* altitudeFlightLevelMetric */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_FANSAltitudePosition_specs_1 = {
+	sizeof(struct FANSAltitudePosition),
+	offsetof(struct FANSAltitudePosition, _asn_ctx),
+	asn_MAP_FANSAltitudePosition_tag2el_1,
+	13,	/* 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_FANSAltitudePosition = {
+	"FANSAltitudePosition",
+	"FANSAltitudePosition",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	SEQUENCE_decode_uper,
+	SEQUENCE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAltitudePosition_tags_1,
+	sizeof(asn_DEF_FANSAltitudePosition_tags_1)
+		/sizeof(asn_DEF_FANSAltitudePosition_tags_1[0]), /* 1 */
+	asn_DEF_FANSAltitudePosition_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAltitudePosition_tags_1)
+		/sizeof(asn_DEF_FANSAltitudePosition_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_FANSAltitudePosition_1,
+	2,	/* Elements count */
+	&asn_SPC_FANSAltitudePosition_specs_1	/* Additional specs */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudePosition.h

@@ -0,0 +1,40 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltitudePosition_H_
+#define	_FANSAltitudePosition_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "FANSAltitude.h"
+#include "FANSPosition.h"
+#include "constr_SEQUENCE.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAltitudePosition */
+typedef struct FANSAltitudePosition {
+	FANSAltitude_t	 altitude;
+	FANSPosition_t	 position;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} FANSAltitudePosition_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltitudePosition;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltitudePosition_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeQFE.c

@@ -0,0 +1,147 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltitudeQFE.h"
+
+int
+FANSAltitudeQFE_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 >= 0 && value <= 2100)) {
+		/* 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
+FANSAltitudeQFE_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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
+FANSAltitudeQFE_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAltitudeQFE_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAltitudeQFE_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAltitudeQFE_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeQFE_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) {
+	FANSAltitudeQFE_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAltitudeQFE_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) {
+	FANSAltitudeQFE_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeQFE_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) {
+	FANSAltitudeQFE_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAltitudeQFE_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) {
+	FANSAltitudeQFE_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeQFE_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAltitudeQFE_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAltitudeQFE_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAltitudeQFE_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAltitudeQFE_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 12,  12,  0,  2100 }	/* (0..2100) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAltitudeQFE_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltitudeQFE = {
+	"FANSAltitudeQFE",
+	"FANSAltitudeQFE",
+	FANSAltitudeQFE_free,
+	FANSAltitudeQFE_print,
+	FANSAltitudeQFE_constraint,
+	FANSAltitudeQFE_decode_ber,
+	FANSAltitudeQFE_encode_der,
+	FANSAltitudeQFE_decode_xer,
+	FANSAltitudeQFE_encode_xer,
+	FANSAltitudeQFE_decode_uper,
+	FANSAltitudeQFE_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAltitudeQFE_tags_1,
+	sizeof(asn_DEF_FANSAltitudeQFE_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeQFE_tags_1[0]), /* 1 */
+	asn_DEF_FANSAltitudeQFE_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAltitudeQFE_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeQFE_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAltitudeQFE_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeQFE.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltitudeQFE_H_
+#define	_FANSAltitudeQFE_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAltitudeQFE */
+typedef long	 FANSAltitudeQFE_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltitudeQFE;
+asn_struct_free_f FANSAltitudeQFE_free;
+asn_struct_print_f FANSAltitudeQFE_print;
+asn_constr_check_f FANSAltitudeQFE_constraint;
+ber_type_decoder_f FANSAltitudeQFE_decode_ber;
+der_type_encoder_f FANSAltitudeQFE_encode_der;
+xer_type_decoder_f FANSAltitudeQFE_decode_xer;
+xer_type_encoder_f FANSAltitudeQFE_encode_xer;
+per_type_decoder_f FANSAltitudeQFE_decode_uper;
+per_type_encoder_f FANSAltitudeQFE_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltitudeQFE_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeQFEMeters.c

@@ -0,0 +1,147 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltitudeQFEMeters.h"
+
+int
+FANSAltitudeQFEMeters_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 >= 0 && value <= 7000)) {
+		/* 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
+FANSAltitudeQFEMeters_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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
+FANSAltitudeQFEMeters_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAltitudeQFEMeters_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAltitudeQFEMeters_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAltitudeQFEMeters_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeQFEMeters_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) {
+	FANSAltitudeQFEMeters_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAltitudeQFEMeters_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) {
+	FANSAltitudeQFEMeters_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeQFEMeters_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) {
+	FANSAltitudeQFEMeters_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAltitudeQFEMeters_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) {
+	FANSAltitudeQFEMeters_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeQFEMeters_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAltitudeQFEMeters_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAltitudeQFEMeters_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAltitudeQFEMeters_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAltitudeQFEMeters_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 13,  13,  0,  7000 }	/* (0..7000) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAltitudeQFEMeters_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltitudeQFEMeters = {
+	"FANSAltitudeQFEMeters",
+	"FANSAltitudeQFEMeters",
+	FANSAltitudeQFEMeters_free,
+	FANSAltitudeQFEMeters_print,
+	FANSAltitudeQFEMeters_constraint,
+	FANSAltitudeQFEMeters_decode_ber,
+	FANSAltitudeQFEMeters_encode_der,
+	FANSAltitudeQFEMeters_decode_xer,
+	FANSAltitudeQFEMeters_encode_xer,
+	FANSAltitudeQFEMeters_decode_uper,
+	FANSAltitudeQFEMeters_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAltitudeQFEMeters_tags_1,
+	sizeof(asn_DEF_FANSAltitudeQFEMeters_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeQFEMeters_tags_1[0]), /* 1 */
+	asn_DEF_FANSAltitudeQFEMeters_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAltitudeQFEMeters_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeQFEMeters_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAltitudeQFEMeters_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeQFEMeters.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltitudeQFEMeters_H_
+#define	_FANSAltitudeQFEMeters_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAltitudeQFEMeters */
+typedef long	 FANSAltitudeQFEMeters_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltitudeQFEMeters;
+asn_struct_free_f FANSAltitudeQFEMeters_free;
+asn_struct_print_f FANSAltitudeQFEMeters_print;
+asn_constr_check_f FANSAltitudeQFEMeters_constraint;
+ber_type_decoder_f FANSAltitudeQFEMeters_decode_ber;
+der_type_encoder_f FANSAltitudeQFEMeters_encode_der;
+xer_type_decoder_f FANSAltitudeQFEMeters_decode_xer;
+xer_type_encoder_f FANSAltitudeQFEMeters_encode_xer;
+per_type_decoder_f FANSAltitudeQFEMeters_decode_uper;
+per_type_encoder_f FANSAltitudeQFEMeters_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltitudeQFEMeters_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeQNH.c

@@ -0,0 +1,147 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltitudeQNH.h"
+
+int
+FANSAltitudeQNH_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 >= 0 && value <= 2500)) {
+		/* 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
+FANSAltitudeQNH_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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
+FANSAltitudeQNH_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAltitudeQNH_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAltitudeQNH_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAltitudeQNH_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeQNH_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) {
+	FANSAltitudeQNH_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAltitudeQNH_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) {
+	FANSAltitudeQNH_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeQNH_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) {
+	FANSAltitudeQNH_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAltitudeQNH_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) {
+	FANSAltitudeQNH_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeQNH_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAltitudeQNH_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAltitudeQNH_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAltitudeQNH_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAltitudeQNH_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 12,  12,  0,  2500 }	/* (0..2500) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAltitudeQNH_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltitudeQNH = {
+	"FANSAltitudeQNH",
+	"FANSAltitudeQNH",
+	FANSAltitudeQNH_free,
+	FANSAltitudeQNH_print,
+	FANSAltitudeQNH_constraint,
+	FANSAltitudeQNH_decode_ber,
+	FANSAltitudeQNH_encode_der,
+	FANSAltitudeQNH_decode_xer,
+	FANSAltitudeQNH_encode_xer,
+	FANSAltitudeQNH_decode_uper,
+	FANSAltitudeQNH_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAltitudeQNH_tags_1,
+	sizeof(asn_DEF_FANSAltitudeQNH_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeQNH_tags_1[0]), /* 1 */
+	asn_DEF_FANSAltitudeQNH_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAltitudeQNH_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeQNH_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAltitudeQNH_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeQNH.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltitudeQNH_H_
+#define	_FANSAltitudeQNH_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAltitudeQNH */
+typedef long	 FANSAltitudeQNH_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltitudeQNH;
+asn_struct_free_f FANSAltitudeQNH_free;
+asn_struct_print_f FANSAltitudeQNH_print;
+asn_constr_check_f FANSAltitudeQNH_constraint;
+ber_type_decoder_f FANSAltitudeQNH_decode_ber;
+der_type_encoder_f FANSAltitudeQNH_encode_der;
+xer_type_decoder_f FANSAltitudeQNH_decode_xer;
+xer_type_encoder_f FANSAltitudeQNH_encode_xer;
+per_type_decoder_f FANSAltitudeQNH_decode_uper;
+per_type_encoder_f FANSAltitudeQNH_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltitudeQNH_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeQNHMeters.c

@@ -0,0 +1,147 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltitudeQNHMeters.h"
+
+int
+FANSAltitudeQNHMeters_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 >= 0 && value <= 16000)) {
+		/* 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
+FANSAltitudeQNHMeters_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->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	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
+FANSAltitudeQNHMeters_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAltitudeQNHMeters_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAltitudeQNHMeters_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAltitudeQNHMeters_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeQNHMeters_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) {
+	FANSAltitudeQNHMeters_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAltitudeQNHMeters_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) {
+	FANSAltitudeQNHMeters_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeQNHMeters_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) {
+	FANSAltitudeQNHMeters_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAltitudeQNHMeters_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) {
+	FANSAltitudeQNHMeters_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeQNHMeters_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAltitudeQNHMeters_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAltitudeQNHMeters_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAltitudeQNHMeters_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAltitudeQNHMeters_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 14,  14,  0,  16000 }	/* (0..16000) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+static const ber_tlv_tag_t asn_DEF_FANSAltitudeQNHMeters_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltitudeQNHMeters = {
+	"FANSAltitudeQNHMeters",
+	"FANSAltitudeQNHMeters",
+	FANSAltitudeQNHMeters_free,
+	FANSAltitudeQNHMeters_print,
+	FANSAltitudeQNHMeters_constraint,
+	FANSAltitudeQNHMeters_decode_ber,
+	FANSAltitudeQNHMeters_encode_der,
+	FANSAltitudeQNHMeters_decode_xer,
+	FANSAltitudeQNHMeters_encode_xer,
+	FANSAltitudeQNHMeters_decode_uper,
+	FANSAltitudeQNHMeters_encode_uper,
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_FANSAltitudeQNHMeters_tags_1,
+	sizeof(asn_DEF_FANSAltitudeQNHMeters_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeQNHMeters_tags_1[0]), /* 1 */
+	asn_DEF_FANSAltitudeQNHMeters_tags_1,	/* Same as above */
+	sizeof(asn_DEF_FANSAltitudeQNHMeters_tags_1)
+		/sizeof(asn_DEF_FANSAltitudeQNHMeters_tags_1[0]), /* 1 */
+	&asn_PER_type_FANSAltitudeQNHMeters_constr_1,
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeQNHMeters.h

@@ -0,0 +1,41 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#ifndef	_FANSAltitudeQNHMeters_H_
+#define	_FANSAltitudeQNHMeters_H_
+
+
+#include "asn_application.h"
+
+/* Including external dependencies */
+#include "NativeInteger.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* FANSAltitudeQNHMeters */
+typedef long	 FANSAltitudeQNHMeters_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_FANSAltitudeQNHMeters;
+asn_struct_free_f FANSAltitudeQNHMeters_free;
+asn_struct_print_f FANSAltitudeQNHMeters_print;
+asn_constr_check_f FANSAltitudeQNHMeters_constraint;
+ber_type_decoder_f FANSAltitudeQNHMeters_decode_ber;
+der_type_encoder_f FANSAltitudeQNHMeters_encode_der;
+xer_type_decoder_f FANSAltitudeQNHMeters_decode_xer;
+xer_type_encoder_f FANSAltitudeQNHMeters_encode_xer;
+per_type_decoder_f FANSAltitudeQNHMeters_decode_uper;
+per_type_encoder_f FANSAltitudeQNHMeters_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _FANSAltitudeQNHMeters_H_ */
+#include "asn_internal.h"

plugins/inmarsat_support/aero/libacars/asn1/FANSAltitudeRestriction.c

@@ -0,0 +1,125 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "FANSACTwoWayDataLinkCommunications"
+ * 	found in "../../../libacars.asn1/fans-cpdlc.asn1"
+ * 	`asn1c -fcompound-names -fincludes-quoted -gen-PER`
+ */
+
+#include "FANSAltitudeRestriction.h"
+
+int
+FANSAltitudeRestriction_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_FANSAltitude.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using FANSAltitude,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+FANSAltitudeRestriction_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_FANSAltitude.free_struct;
+	td->print_struct   = asn_DEF_FANSAltitude.print_struct;
+	td->check_constraints = asn_DEF_FANSAltitude.check_constraints;
+	td->ber_decoder    = asn_DEF_FANSAltitude.ber_decoder;
+	td->der_encoder    = asn_DEF_FANSAltitude.der_encoder;
+	td->xer_decoder    = asn_DEF_FANSAltitude.xer_decoder;
+	td->xer_encoder    = asn_DEF_FANSAltitude.xer_encoder;
+	td->uper_decoder   = asn_DEF_FANSAltitude.uper_decoder;
+	td->uper_encoder   = asn_DEF_FANSAltitude.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_FANSAltitude.per_constraints;
+	td->elements       = asn_DEF_FANSAltitude.elements;
+	td->elements_count = asn_DEF_FANSAltitude.elements_count;
+	td->specifics      = asn_DEF_FANSAltitude.specifics;
+}
+
+void
+FANSAltitudeRestriction_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	FANSAltitudeRestriction_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+FANSAltitudeRestriction_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	FANSAltitudeRestriction_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeRestriction_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) {
+	FANSAltitudeRestriction_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+FANSAltitudeRestriction_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) {
+	FANSAltitudeRestriction_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeRestriction_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) {
+	FANSAltitudeRestriction_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+FANSAltitudeRestriction_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) {
+	FANSAltitudeRestriction_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+asn_dec_rval_t
+FANSAltitudeRestriction_decode_uper(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints, void **structure, asn_per_data_t *per_data) {
+	FANSAltitudeRestriction_1_inherit_TYPE_descriptor(td);
+	return td->uper_decoder(opt_codec_ctx, td, constraints, structure, per_data);
+}
+
+asn_enc_rval_t
+FANSAltitudeRestriction_encode_uper(asn_TYPE_descriptor_t *td,
+		asn_per_constraints_t *constraints,
+		void *structure, asn_per_outp_t *per_out) {
+	FANSAltitudeRestriction_1_inherit_TYPE_descriptor(td);
+	return td->uper_encoder(td, constraints, structure, per_out);
+}
+
+static asn_per_constraints_t asn_PER_type_FANSAltitudeRestriction_constr_1 GCC_NOTUSED = {
+	{ APC_CONSTRAINED,	 3,  3,  0,  7 }	/* (0..7) */,
+	{ APC_UNCONSTRAINED,	-1, -1,  0,  0 },
+	0, 0	/* No PER value map */
+};
+asn_TYPE_descriptor_t asn_DEF_FANSAltitudeRestriction = {
+	"FANSAltitudeRestriction",
+	"FANSAltitudeRestriction",
+	FANSAltitudeRestriction_free,
+	FANSAltitudeRestriction_print,
+	FANSAltitudeRestriction_constraint,
+	FANSAltitudeRestriction_decode_ber,
+	FANSAltitudeRestriction_encode_der,
+	FANSAltitudeRestriction_decode_xer,
+	FANSAltitudeRestriction_encode_xer,
+	FANSAltitudeRestriction_decode_uper,
+	FANSAltitudeRestriction_encode_uper,
+	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 */
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+