diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-10 20:34:10 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-10 20:34:10 +0000 |
| commit | e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc (patch) | |
| tree | 68cb5ef9081156392f1dd62a00c6ccc1451b93df /epan/dissectors/asn1/atn-cpdlc | |
| parent | Initial commit. (diff) | |
| download | wireshark-e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc.tar.xz wireshark-e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc.zip | |
Adding upstream version 4.2.2.upstream/4.2.2
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'epan/dissectors/asn1/atn-cpdlc')
| -rw-r--r-- | epan/dissectors/asn1/atn-cpdlc/CMakeLists.txt | 40 | ||||
| -rw-r--r-- | epan/dissectors/asn1/atn-cpdlc/atn-cpdlc.asn | 2793 | ||||
| -rw-r--r-- | epan/dissectors/asn1/atn-cpdlc/atn-cpdlc.cnf | 134 | ||||
| -rw-r--r-- | epan/dissectors/asn1/atn-cpdlc/packet-atn-cpdlc-template.c | 352 |
4 files changed, 3319 insertions, 0 deletions
diff --git a/epan/dissectors/asn1/atn-cpdlc/CMakeLists.txt b/epan/dissectors/asn1/atn-cpdlc/CMakeLists.txt new file mode 100644 index 00000000..12e357c5 --- /dev/null +++ b/epan/dissectors/asn1/atn-cpdlc/CMakeLists.txt @@ -0,0 +1,40 @@ +# CMakeLists.txt +# +# Wireshark - Network traffic analyzer +# By Gerald Combs <gerald@wireshark.org> +# Copyright 1998 Gerald Combs +# +# SPDX-License-Identifier: GPL-2.0-or-later +# + +set( PROTOCOL_NAME atn-cpdlc ) + +set( PROTO_OPT ) + +set( EXPORT_FILES +) + +set( EXT_ASN_FILE_LIST +) + +set( ASN_FILE_LIST + ${PROTOCOL_NAME}.asn +) + +set( EXTRA_DIST + ${ASN_FILE_LIST} + packet-${PROTOCOL_NAME}-template.c + ${PROTOCOL_NAME}.cnf +) + +set( SRC_FILES + ${EXTRA_DIST} + ${EXT_ASN_FILE_LIST} +) + +set( A2W_FLAGS -u ) + +set( EXTRA_CNF +) + +ASN2WRS() diff --git a/epan/dissectors/asn1/atn-cpdlc/atn-cpdlc.asn b/epan/dissectors/asn1/atn-cpdlc/atn-cpdlc.asn new file mode 100644 index 00000000..546fa8ef --- /dev/null +++ b/epan/dissectors/asn1/atn-cpdlc/atn-cpdlc.asn @@ -0,0 +1,2793 @@ +-- Sub-Volume IV ASN.1 reference definitions for ICAO Doc. 9705, +-- Second Edition +-- Version 1.1, 03 Oct 2001 + +-- protected mode PDR's +-- 2011-10-25 Doc 9705 Draft Ed 3 (ICAO web site - 11/00) including "9705 PDRS FOR CPDLC" +-- based on "ACP WGN SG/N2 Version 1.1 (Output Montreal - May 2005)" + + +-- plain old CPDLC +CPDLCAPDUsVersion1 DEFINITIONS ::= +BEGIN + +IMPORTS + ATCUplinkMessage, ATCDownlinkMessage + FROM PMCPDLCMessageSetVersion1 + ATCForwardMessage, ATCForwardResponse + FROM PMCPDLCAPDUsVersion1; + +-- ---------------------------------------------------------------------------------- +-- Ground Generated Messages - Top level +-- ---------------------------------------------------------------------------------- +GroundPDUs ::= CHOICE +{ + abortUser [0] CPDLCUserAbortReason, + abortProvider [1] CPDLCProviderAbortReason, + startup [2] UplinkMessage, + send [3] ATCUplinkMessage, + forward [4] ATCForwardMessage, + forwardresponse [5] ATCForwardResponse, + ... +} + +UplinkMessage ::= CHOICE +{ + noMessage [0] NULL, + aTCUplinkMessage [1] ATCUplinkMessage +} + +AircraftPDUs::= CHOICE +{ + abortUser [0] CPDLCUserAbortReason, + abortProvider [1] CPDLCProviderAbortReason, + startdown [2] StartDownMessage, + send [3] ATCDownlinkMessage, + ... +} + +StartDownMessage ::= SEQUENCE +{ + mode Mode DEFAULT cpdlc, + startDownlinkMessage DownlinkMessage +} + +Mode ::= ENUMERATED +{ + cpdlc (0), + dsc (1) +} + +DownlinkMessage ::= CHOICE +{ + noMessage [0] NULL, + aTCDownlinkMessage [1] ATCDownlinkMessage +} + +CPDLCUserAbortReason ::= ENUMERATED +{ + undefined (0), + no-message-identification-numbers-available (1), + duplicate-message-identification-numbers (2), + no-longer-next-data-authority (3), + current-data-authority-abort (4), + commanded-termination (5), + invalid-response (6), + ... +} + + +CPDLCProviderAbortReason ::= ENUMERATED +{ + timer-expired (0), + undefined-error (1), + invalid-PDU (2), + protocol-error (3), + communication-service-error (4), + communication-service-failure (5), + invalid-QOS-parameter (6), + expected-PDU-missing (7), + ... + } + +END + +-- protected mode PMCPDLC +PMCPDLCAPDUsVersion1 DEFINITIONS::= +BEGIN + +IMPORTS +DateTimeGroup, +AircraftFlightIdentification, +AircraftAddress +FROM PMCPDLCMessageSetVersion1; + +-- ---------------------------------------------------------------------------------- +-- Ground Generated Messages - Top level +-- ---------------------------------------------------------------------------------- +ProtectedGroundPDUs ::= CHOICE +{ + abortUser [0] PMCPDLCUserAbortReason, + abortProvider [1] PMCPDLCProviderAbortReason, + startup [2] ProtectedUplinkMessage, + send [3] ProtectedUplinkMessage, + forward [4] ATCForwardMessage, + forwardresponse [5] ATCForwardResponse, + ... +} + +ProtectedUplinkMessage::= SEQUENCE +{ + algorithmIdentifier [0] AlgorithmIdentifier OPTIONAL, + protectedMessage [1] CPDLCMessage OPTIONAL, +-- PER encoded ATCUplinkMessage +-- (see Module PMCPDLCMessageSetVersion1) + integrityCheck [2] BIT STRING, + ... +} + +ATCForwardMessage ::= SEQUENCE +{ + forwardHeader ForwardHeader, + forwardMessage ForwardMessage +} + +ForwardHeader ::= SEQUENCE +{ + dateTime DateTimeGroup, + aircraftID AircraftFlightIdentification, + aircraftAddress AircraftAddress +} + +ForwardMessage ::= CHOICE +{ + upElementIDs [0] BIT STRING, +--PER encoded ATCUplinkMessageData, +-- (see Module PMCPDLCMessageSetVersion1) + downElementIDs [1] BIT STRING +--PER encoded ATCDownlinkMessageData, +-- (see Module PMCPDLCMessageSetVersion1) +} + +ATCForwardResponse ::= ENUMERATED +{ + success (0), + service-not-supported (1), + version-not-equal (2), + ... +} +-- ---------------------------------------------------------------------------------- +-- Aircraft Generated Messages - Top level +-- ---------------------------------------------------------------------------------- +ProtectedAircraftPDUs::= CHOICE +{ + abortUser [0] PMCPDLCUserAbortReason, + abortProvider [1] PMCPDLCProviderAbortReason, + startdown [2] ProtectedStartDownMessage, + send [3] ProtectedDownlinkMessage, + ... +} + + +ProtectedStartDownMessage ::= SEQUENCE +{ + mode ProtectedMode DEFAULT cpdlc, + startDownlinkMessage ProtectedDownlinkMessage +} + +ProtectedMode ::= ENUMERATED +{ + cpdlc (0), + dsc (1) +} + +ProtectedDownlinkMessage::= SEQUENCE +{ + algorithmIdentifier [0] AlgorithmIdentifier OPTIONAL, + protectedMessage [1] CPDLCMessage OPTIONAL, +--PER encoded ATCDownlinkMessage, +-- (see Module PMCPDLCMessageSetVersion1) + integrityCheck [2] BIT STRING, + ... +} + +-- ---------------------------------------------------------------------------------- +-- Uplink and Downlink messages - Common Elements +-- ---------------------------------------------------------------------------------- +AlgorithmIdentifier ::= RELATIVE-OID +--root is {icao-arc atn-algorithms(9)} + +CPDLCMessage ::= BIT STRING + +PMCPDLCUserAbortReason ::= ENUMERATED +{ + undefined (0), + no-message-identification-numbers-available (1), + duplicate-message-identification-numbers (2), + no-longer-next-data-authority (3), + current-data-authority-abort (4), + commanded-termination (5), + invalid-response (6), + time-out-of-synchronisation (7), + unknown-integrity-check (8), + validation-failure (9), + unable-to-decode-message (10), + invalid-pdu (11), + invalid-CPDLC-message (12), + ... +} + +PMCPDLCProviderAbortReason ::= ENUMERATED +{ + timer-expired (0), + undefined-error (1), + invalid-PDU (2), + protocol-error (3), + communication-service-error (4), + communication-service-failure (5), + invalid-QOS-parameter (6), + expected-PDU-missing (7), + ... +} + +END + +PMCPDLCMessageSetVersion1 DEFINITIONS::= +BEGIN + +ATCUplinkMessage ::= SEQUENCE +{ + header ATCMessageHeader, + messageData ATCUplinkMessageData +} + +ATCUplinkMessageData ::= SEQUENCE +{ + elementIds SEQUENCE SIZE (1..5) OF ATCUplinkMsgElementId, + constrainedData SEQUENCE + { + routeClearanceData SEQUENCE SIZE (1..2) OF RouteClearance OPTIONAL, + ... + } OPTIONAL +} + +ATCDownlinkMessage ::= SEQUENCE +{ + header ATCMessageHeader, + messageData ATCDownlinkMessageData +} + +ATCDownlinkMessageData ::= SEQUENCE +{ + elementIds SEQUENCE SIZE (1..5) OF ATCDownlinkMsgElementId, + constrainedData SEQUENCE + { + routeClearanceData SEQUENCE SIZE (1..2) OF RouteClearance OPTIONAL, + ... + } OPTIONAL +} + +-- ---------------------------------------------------------------------------------- +-- Uplink and Downlink messages - Common Elements +-- ---------------------------------------------------------------------------------- +ATCMessageHeader ::= SEQUENCE +{ + messageIdNumber [0] MsgIdentificationNumber, + messageRefNumber [1] MsgReferenceNumber OPTIONAL, + dateTime [2] DateTimeGroup, + logicalAck [3] LogicalAck DEFAULT notRequired +} + +MsgIdentificationNumber ::= INTEGER (0..63) + +MsgReferenceNumber ::= INTEGER (0..63) + +LogicalAck ::= ENUMERATED +{ + required (0), + notRequired (1) +} + +-- ---------------------------------------------------------------------------------- +-- Uplink message element +-- ---------------------------------------------------------------------------------- +ATCUplinkMsgElementId ::= CHOICE +{ + -- UNABLE + -- Urg(N)/Alr(M)/Resp(N) + uM0NULL [0] NULL, + + -- STANDBY + -- Urg(N)/Alr(L)/Resp(N) + uM1NULL [1] NULL, + + -- REQUEST DEFERRED + -- Urg(N)/Alr(L)/Resp(N) + uM2NULL [2] NULL, + + -- ROGER + -- Urg(N)/Alr(L)/Resp(N) + uM3NULL [3] NULL, + + -- AFFIRM + -- Urg(N)/Alr(L)/Resp(N) + uM4NULL [4] NULL, + + -- NEGATIVE Urg(N)/Alr(L)/Resp(N) + uM5NULL [5] NULL, + + -- EXPECT [level] Urg(L)/Alr(L)/Resp(R) + uM6Level [6] Level, + + -- EXPECT CLIMB AT [time] + -- Urg(L)/Alr(L)/Resp(R) + uM7Time [7] Time, + + -- EXPECT CLIMB AT [position] + -- Urg(L)/Alr(L)/Resp(R) + uM8Position [8] Position, + + -- EXPECT DESCENT AT [time] + -- Urg(L)/Alr(L)/Resp(R) + uM9Time [9] Time, + + -- EXPECT DESCENT AT [position] + -- Urg(L)/Alr(L)/Resp(R) + uM10Position [10] Position, + + -- EXPECT CRUISE CLIMB AT [time] + -- Urg(L)/Alr(L)/Resp(R) + uM11Time [11] Time, + + -- EXPECT CRUISE CLIMB AT [position] + -- Urg(L)/Alr(L)/Resp(R) + uM12Position [12] Position, + + -- AT [time] EXPECT CLIMB TO [level] + -- Urg(L)/Alr(L)/Resp(R) + uM13TimeLevel [13] TimeLevel, + + -- AT [position] EXPECT CLIMB TO [level] + -- Urg(L)/Alr(L)/Resp(R) + uM14PositionLevel [14] PositionLevel, + + -- AT [time] EXPECT DESCENT TO [level] + -- Urg(L)/Alr(L)/Resp(R) + uM15TimeLevel [15] TimeLevel, + + -- AT [position] EXPECT DESCENT TO [level] + -- Urg(L)/Alr(L)/Resp(R) + uM16PositionLevel [16] PositionLevel, + + -- AT [time] EXPECT CRUISE CLIMB TO [level] + -- Urg(L)/Alr(L)/Resp(R) + uM17TimeLevel [17] TimeLevel, + + -- AT [position] EXPECT CRUISE CLIMB TO [level] + -- Urg(L)/Alr(L)/Resp(R) + uM18PositionLevel [18] PositionLevel, + + -- MAINTAIN [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM19Level [19] Level, + + -- CLIMB TO [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM20Level [20] Level, + + -- AT [time] CLIMB TO [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM21TimeLevel [21] TimeLevel, + + -- AT [position] CLIMB TO [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM22PositionLevel [22] PositionLevel, + + -- DESCEND TO [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM23Level [23] Level, + + -- AT [time] DESCEND TO [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM24TimeLevel [24] TimeLevel, + + -- AT [position] DESCEND TO [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM25PositionLevel [25] PositionLevel, + + -- CLIMB TO REACH [level] BY [time] + -- Urg(N)/Alr(M)/Resp(W/U) + uM26LevelTime [26] LevelTime, + + -- CLIMB TO REACH [level] BY [position] + -- Urg(N)/Alr(M)/Resp(W/U) + uM27LevelPosition [27] LevelPosition, + + -- DESCEND TO REACH [level] BY [time] + -- Urg(N)/Alr(M)/Resp(W/U) + uM28LevelTime [28] LevelTime, + + -- DESCEND TO REACH [level] BY [position] + -- Urg(N)/Alr(M)/Resp(W/U) + uM29LevelPosition [29] LevelPosition, + + -- MAINTAIN BLOCK [level] TO [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM30LevelLevel [30] LevelLevel, + + -- CLIMB TO AND MAINTAIN BLOCK [level] TO [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM31LevelLevel [31] LevelLevel, + + -- DESCEND TO AND MAINTAIN BLOCK [level] TO [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM32LevelLevel [32] LevelLevel, + + -- Reserved + -- Urg(L)/Alr(L)/Resp(Y) + uM33NULL [33] NULL, + + -- CRUISE CLIMB TO [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM34Level [34] Level, + + -- CRUISE CLIMB ABOVE [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM35Level [35] Level, + + -- EXPEDITE CLIMB TO [level] + -- Urg(U)/Alr(M)/Resp(W/U) + uM36Level [36] Level, + + -- EXPEDITE DESCENT TO [level] + -- Urg(U)/Alr(M)/Resp(W/U) + uM37Level [37] Level, + + -- IMMEDIATELY CLIMB TO [level] + -- Urg(D)/Alr(H)/Resp(W/U) + uM38Level [38] Level, + + -- IMMEDIATELY DESCEND TO [level] + -- Urg(D)/Alr(H)/Resp(W/U) + uM39Level [39] Level, + + -- Reserved + -- Urg(L)/Alr(L)/Resp(Y) + uM40NULL [40] NULL, + + -- Reserved Urg(L)/Alr(L)/Resp(Y) + uM41NULL [41] NULL, + + -- EXPECT TO CROSS [position] AT [level] + -- Urg(L)/Alr(L)/Resp(R) + uM42PositionLevel [42] PositionLevel, + + -- EXPECT TO CROSS [position] AT OR ABOVE [level] + -- Urg(L)/Alr(L)/Resp(R) + uM43PositionLevel [43] PositionLevel, + + -- EXPECT TO CROSS [position] AT OR BELOW [level] + -- Urg(L)/Alr(L)/Resp(R) + uM44PositionLevel [44] PositionLevel, + + -- EXPECT TO CROSS [position] AT AND MAINTAIN [level] + -- Urg(L)/Alr(L)/Resp(R) + uM45PositionLevel [45] PositionLevel, + + -- CROSS [position] AT [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM46PositionLevel [46] PositionLevel, + + -- CROSS [position] AT OR ABOVE [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM47PositionLevel [47] PositionLevel, + + -- CROSS [position] AT OR BELOW [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM48PositionLevel [48] PositionLevel, + + -- CROSS [position] AT AND MAINTAIN [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM49PositionLevel [49] PositionLevel, + + -- CROSS [position] BETWEEN [level] AND [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM50PositionLevelLevel [50] PositionLevelLevel, + + -- CROSS [position] AT [time] + -- Urg(N)/Alr(M)/Resp(W/U) + uM51PositionTime [51] PositionTime, + + -- CROSS [position] AT OR BEFORE [time] + -- Urg(N)/Alr(M)/Resp(W/U) + uM52PositionTime [52] PositionTime, + + -- CROSS [position] AT OR AFTER [time] + -- Urg(N)/Alr(M)/Resp(W/U) + uM53PositionTime [53] PositionTime, + + -- CROSS [position] BETWEEN [time] AND [time] + -- Urg(N)/Alr(M)/Resp(W/U) + uM54PositionTimeTime [54] PositionTimeTime, + + -- CROSS [position] AT [speed] + -- Urg(N)/Alr(M)/Resp(W/U) + uM55PositionSpeed [55] PositionSpeed, + + -- CROSS [position] AT OR LESS THAN [speed] + -- Urg(N)/Alr(M)/Resp(W/U) + uM56PositionSpeed [56] PositionSpeed, + + -- CROSS [position] AT OR GREATER THAN [speed] + -- Urg(N)/Alr(M)/Resp(W/U) + uM57PositionSpeed [57] PositionSpeed, + + -- CROSS [position] AT [time] AT [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM58PositionTimeLevel [58] PositionTimeLevel, + + -- CROSS [position] AT OR BEFORE [time] AT [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM59PositionTimeLevel [59] PositionTimeLevel, + + -- CROSS [position] AT OR AFTER [time] AT [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM60PositionTimeLevel [60] PositionTimeLevel, + + -- CROSS [position] AT AND MAINTAIN [level] AT [speed] + -- Urg(N)/Alr(M)/Resp(W/U) + uM61PositionLevelSpeed [61] PositionLevelSpeed, + + -- AT [time] CROSS [position] AT AND MAINTAIN [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM62TimePositionLevel [62] TimePositionLevel, + + -- AT [time] CROSS [position] AT AND MAINTAIN [level] AT [speed] + -- Urg(N)/Alr(M)/Resp(W/U) + uM63TimePositionLevelSpeed [63] TimePositionLevelSpeed, + + -- OFFSET [specifiedDistance] [direction] OF ROUTE + -- Urg(N)/Alr(M)/Resp(W/U) + uM64DistanceSpecifiedDirection [64] DistanceSpecifiedDirection, + + -- AT [position] OFFSET [specifiedDistance] [direction] OF ROUTE + -- Urg(N)/Alr(M)/Resp(W/U) + uM65PositionDistanceSpecifiedDirection[65] PositionDistanceSpecifiedDirection, + + -- AT [time] OFFSET [specifiedDistance] [direction] OF ROUTE + -- Urg(N)/Alr(M)/Resp(W/U) + uM66TimeDistanceSpecifiedDirection [66] TimeDistanceSpecifiedDirection, + + -- PROCEED BACK ON ROUTE + -- Urg(N)/Alr(M)/Resp(W/U) + uM67NULL [67] NULL, + + -- REJOIN ROUTE BY [position] + -- Urg(N)/Alr(M)/Resp(W/U) + uM68Position [68] Position, + + -- REJOIN ROUTE BY [time] + -- Urg(N)/Alr(M)/Resp(W/U) + uM69Time [69] Time, + + -- EXPECT BACK ON ROUTE BY [position] + -- Urg(L)/Alr(L)/Resp(R) + uM70Position [70] Position, + + -- EXPECT BACK ON ROUTE BY [time] + -- Urg(L)/Alr(L)/Resp(R) + uM71Time [71] Time, + + -- RESUME OWN NAVIGATION + -- Urg(N)/Alr(M)/Resp(W/U) + uM72NULL [72] NULL, + + -- [DepartureClearance] + -- Urg(N)/Alr(M)/Resp(W/U) + uM73DepartureClearance [73] DepartureClearance, + + -- PROCEED DIRECT TO [position] + -- Urg(N)/Alr(M)/Resp(W/U) + uM74Position [74] Position, + + -- WHEN ABLE PROCEED DIRECT TO [position] + -- Urg(N)/Alr(M)/Resp(W/U) + uM75Position [75] Position, + + -- AT [time] PROCEED DIRECT TO [position] + -- Urg(N)/Alr(M)/Resp(W/U) + uM76TimePosition [76] TimePosition, + + -- AT [position] PROCEED DIRECT TO [position] + -- Urg(N)/Alr(M)/Resp(W/U) + uM77PositionPosition [77] PositionPosition, + + -- AT [level] PROCEED DIRECT TO [position] + -- Urg(N)/Alr(M)/Resp(W/U) + uM78LevelPosition [78] LevelPosition, + + -- CLEARED TO [position] VIA [routeClearance] + -- Urg(N)/Alr(M)/Resp(W/U) + uM79PositionRouteClearance [79] PositionRouteClearanceIndex, + + -- CLEARED [routeClearance] + -- Urg(N)/Alr(M)/Resp(W/U) + uM80RouteClearance [80] RouteClearanceIndex, + + -- CLEARED [procedureName] + -- Urg(N)/Alr(M)/Resp(W/U) + uM81ProcedureName [81] ProcedureName, + + -- CLEARED TO DEVIATE UP TO [specifiedDistance] [direction] OF ROUTE + -- Urg(N)/Alr(M)/Resp(W/U) + uM82DistanceSpecifiedDirection [82] DistanceSpecifiedDirection, + + -- AT [position] CLEARED [routeClearance] + -- Urg(N)/Alr(M)/Resp(W/U) + uM83PositionRouteClearance [83] PositionRouteClearanceIndex, + + -- AT [position] CLEARED [procedureName] + -- Urg(N)/Alr(M)/Resp(W/U) + uM84PositionProcedureName [84] PositionProcedureName, + + -- EXPECT [routeClearance] + -- Urg(L)/Alr(L)/Resp(R) + uM85RouteClearance [85] RouteClearanceIndex, + + -- AT [position] EXPECT [routeClearance] + -- Urg(L)/Alr(L)/Resp(R) + uM86PositionRouteClearance [86] PositionRouteClearanceIndex, + + -- EXPECT DIRECT TO [position] + -- Urg(L)/Alr(L)/Resp(R) + uM87Position [87] Position, + + -- AT [position] EXPECT DIRECT TO [position] + -- Urg(L)/Alr(L)/Resp(R) + uM88PositionPosition [88]PositionPosition, + + -- AT [time] EXPECT DIRECT TO [position] + -- Urg(L)/Alr(L)/Resp(R) + uM89TimePosition [89] TimePosition, + + + -- AT [level] EXPECT DIRECT TO [position] + -- Urg(L)/Alr(L)/Resp(R) + uM90LevelPosition [90] LevelPosition, + + -- HOLD AT [position] MAINTAIN [level] INBOUND TRACK [degrees][direction] TURNS [legtype] + -- Urg(N)/Alr(M)/Resp(W/U) + uM91HoldClearance [91] HoldClearance, + + -- HOLD AT [position] AS PUBLISHED MAINTAIN [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM92PositionLevel [92] PositionLevel, + + -- EXPECT FURTHER CLEARANCE AT [time] + -- Urg(L)/Alr(L)/Resp(R) + uM93Time [93] Time, + + -- TURN [direction] HEADING [degrees] + -- Urg(N)/Alr(M)/Resp(W/U) + uM94DirectionDegrees [94] DirectionDegrees, + + -- TURN [direction] GROUND TRACK [degrees] + -- Urg(N)/Alr(M)/Resp(W/U) + uM95DirectionDegrees [95] DirectionDegrees, + + -- CONTINUE PRESENT HEADING + -- Urg(N)/Alr(M)/Resp(W/U) + uM96NULL [96] NULL, + + -- AT [position] FLY HEADING [degrees] + -- Urg(N)/Alr(M)/Resp(W/U) + uM97PositionDegrees [97] PositionDegrees, + + -- IMMEDIATELY TURN [direction] HEADING [degrees] + -- Urg(D)/Alr(H)/Resp(W/U) + uM98DirectionDegrees [98] DirectionDegrees, + + -- EXPECT [procedureName] + -- Urg(L)/Alr(L)/Resp(R) + uM99ProcedureName [99] ProcedureName, + + -- AT [time] EXPECT [speed] + -- Urg(L)/Alr(L)/Resp(R) + uM100TimeSpeed [100] TimeSpeed, + + -- AT [position] EXPECT [speed] + -- Urg(L)/Alr(L)/Resp(R) + uM101PositionSpeed [101] PositionSpeed, + + -- AT [level] EXPECT [speed] + -- Urg(L)/Alr(L)/Resp(R) + uM102LevelSpeed [102] LevelSpeed, + + -- AT [time] EXPECT [speed] TO [speed] + -- Urg(L)/Alr(L)/Resp(R) + uM103TimeSpeedSpeed [103] TimeSpeedSpeed, + + -- AT [position] EXPECT [speed] TO [speed] + -- Urg(L)/Alr(L)/Resp(R) + uM104PositionSpeedSpeed [104] PositionSpeedSpeed, + + -- AT [level] EXPECT [speed] TO [speed] + -- Urg(L)/Alr(L)/Resp(R) + uM105LevelSpeedSpeed [105] LevelSpeedSpeed, + + -- MAINTAIN [speed] + -- Urg(N)/Alr(M)/Resp(W/U) + uM106Speed [106] Speed, + + -- MAINTAIN PRESENT SPEED + -- Urg(N)/Alr(M)/Resp(W/U) + uM107NULL [107] NULL, + + -- MAINTAIN [speed] OR GREATER + -- Urg(N)/Alr(M)/Resp(W/U) + uM108Speed [108] Speed, + + -- MAINTAIN [speed] OR LESS + -- Urg(N)/Alr(M)/Resp(W/U) + uM109Speed [109] Speed, + + -- MAINTAIN [speed] TO [speed] + -- Urg(N)/Alr(M)/Resp(W/U) + uM110SpeedSpeed [110] SpeedSpeed, + + -- INCREASE SPEED TO [speed] + -- Urg(N)/Alr(M)/Resp(W/U) + uM111Speed [111] Speed, + + -- INCREASE SPEED TO [speed] OR GREATER + -- Urg(N)/Alr(M)/Resp(W/U) + uM112Speed [112] Speed, + + -- REDUCE SPEED TO [speed] + -- Urg(N)/Alr(M)/Resp(W/U) + uM113Speed [113] Speed, + + -- REDUCE SPEED TO [speed] OR LESS + -- Urg(N)/Alr(M)/Resp(W/U) + uM114Speed [114] Speed, + + -- DO NOT EXCEED [speed] + -- Urg(N)/Alr(M)/Resp(W/U) + uM115Speed [115] Speed, + + -- RESUME NORMAL SPEED + -- Urg(N)/Alr(M)/Resp(W/U) + uM116NULL [116] NULL, + + -- CONTACT [unitname] [frequency] + -- Urg(N)/Alr(M)/Resp(W/U) + uM117UnitNameFrequency [117] UnitNameFrequency, + + -- AT [position] CONTACT [unitname] [frequency] + -- Urg(N)/Alr(M)/Resp(W/U) + uM118PositionUnitNameFrequency [118] PositionUnitNameFrequency, + + -- AT [time] CONTACT [unitname] [frequency] + -- Urg(N)/Alr(M)/Resp(W/U) + uM119TimeUnitNameFrequency [119] TimeUnitNameFrequency, + + -- MONITOR [unitname] [frequency] + -- Urg(N)/Alr(M)/Resp(W/U) + uM120UnitNameFrequency [120] UnitNameFrequency, + + -- AT [position] MONITOR [unitname] [frequency] + -- Urg(N)/Alr(M)/Resp(W/U) + uM121PositionUnitNameFrequency [121] PositionUnitNameFrequency, + + -- AT [time] MONITOR [unitname] [frequency] + -- Urg(N)/Alr(M)/Resp(W/U) + uM122TimeUnitNameFrequency [122] TimeUnitNameFrequency, + + -- SQUAWK [code] + -- Urg(N)/Alr(M)/Resp(W/U) + uM123Code [123] Code, + + -- STOP SQUAWK + -- Urg(N)/Alr(M)/Resp(W/U) + uM124NULL [124] NULL, + + -- SQUAWK MODE CHARLIE + -- Urg(N)/Alr(M)/Resp(W/U) + uM125NULL [125] NULL, + + -- STOP SQUAWK MODE CHARLIE + -- Urg(N)/Alr(M)/Resp(W/U) + uM126NULL [126] NULL, + + -- REPORT BACK ON ROUTE + -- Urg(N)/Alr(L)/Resp(W/U) + uM127NULL [127] NULL, + + -- REPORT LEAVING [level] + -- Urg(N)/Alr(L)/Resp(W/U) + uM128Level [128] Level, + + -- REPORT MAINTAINING [level] + -- Urg(N)/Alr(L)/Resp(W/U) + uM129Level [129] Level, + + -- REPORT PASSING [position] + -- Urg(N)/Alr(L)/Resp(W/U) + uM130Position [130] Position, + + -- REPORT REMAINING FUEL AND PERSONS ON BOARD + -- Urg(U)/Alr(M)/Resp(Y) + uM131NULL [131] NULL, + + -- REPORT POSITION + -- Urg(N)/Alr(M)/Resp(Y) + uM132NULL [132] NULL, + + -- REPORT PRESENT LEVEL + -- Urg(N)/Alr(M)/Resp(Y) + uM133NULL [133] NULL, + + -- REPORT [speedtype] [speedtype] [speedtype]SPEED + -- Urg(N)/Alr(M)/Resp(Y) + uM134SpeedTypeSpeedTypeSpeedType [134] SpeedTypeSpeedTypeSpeedType, + + -- CONFIRM ASSIGNED LEVEL + -- Urg(N)/Alr(L)/Resp(Y) + uM135NULL [135] NULL, + + -- CONFIRM ASSIGNED SPEED + -- Urg(N)/Alr(L)/Resp(Y) + uM136NULL [136] NULL, + + -- CONFIRM ASSIGNED ROUTE + -- Urg(N)/Alr(L)/Resp(Y) + uM137NULL [137] NULL, + + -- CONFIRM TIME OVER REPORTED WAYPOINT + -- Urg(N)/Alr(L)/Resp(Y) + uM138NULL [138] NULL, + + -- CONFIRM REPORTED WAYPOINT + -- Urg(N)/Alr(L)/Resp(Y) + uM139NULL [139] NULL, + + -- CONFIRM NEXT WAYPOINT + -- Urg(N)/Alr(L)/Resp(Y) + uM140NULL [140] NULL, + + -- CONFIRM NEXT WAYPOINT ETA + -- Urg(N)/Alr(L)/Resp(Y) + uM141NULL [141] NULL, + + -- CONFIRM ENSUING WAYPOINT + -- Urg(N)/Alr(L)/Resp(Y) + uM142NULL [142] NULL, + + -- CONFIRM REQUEST + -- Urg(N)/Alr(L)/Resp(Y) + uM143NULL [143] NULL, + + -- CONFIRM SQUAWK + -- Urg(N)/Alr(L)/Resp(Y) + uM144NULL [144] NULL, + + -- REPORT HEADING + -- Urg(N)/Alr(M)/Resp(Y) + uM145NULL [145] NULL, + + -- REPORT GROUND TRACK + -- Urg(N)/Alr(M)/Resp(Y) + uM146NULL [146] NULL, + + -- REQUEST POSITION REPORT + -- Urg(N)/Alr(M)/Resp(Y ) + uM147NULL [147] NULL, + + -- WHEN CAN YOU ACCEPT [level] + -- Urg(N)/Alr(L)/Resp(Y) + uM148Level [148] Level, + + -- CAN YOU ACCEPT [level] AT [position] + -- Urg(N)/Alr(L)/Resp(A/N) + uM149LevelPosition [149] LevelPosition, + + -- CAN YOU ACCEPT [level] AT [time] + -- Urg(N)/Alr(L)/Resp(A/N) + uM150LevelTime [150] LevelTime, + + -- WHEN CAN YOU ACCEPT [speed] + -- Urg(N)/Alr(L)/Resp(Y) + uM151Speed [151] Speed, + + -- WHEN CAN YOU ACCEPT [specifiedDistance] [direction] OFFSET + -- Urg(N)/Alr(L)/Resp(Y) + uM152DistanceSpecifiedDirection [152] DistanceSpecifiedDirection, + + -- ALTIMETER [altimeter] + -- Urg(N)/Alr(L)/Resp(R) + uM153Altimeter [153] Altimeter, + + -- RADAR SERVICE TERMINATED + -- Urg(N)/Alr(L)/Resp(R) + uM154NULL [154] NULL, + + -- RADAR CONTACT [position] + -- Urg(N)/Alr(M)/Resp(R) + uM155Position [155] Position, + + -- RADAR CONTACT LOST + -- Urg(N)/Alr(M)/Resp(R) + uM156NULL [156] NULL, + + -- CHECK STUCK MICROPHONE [frequency] + -- Urg(U)/Alr(M)/Resp(N) + uM157Frequency [157] Frequency, + + -- ATIS [atiscode] + -- Urg(N)/Alr(L)/Resp(R) + uM158AtisCode [158] ATISCode, + + -- ERROR [errorInformation] + -- Urg(U)/Alr(M)/Resp(N) + uM159ErrorInformation [159] ErrorInformation, + + -- NEXT DATA AUTHORITY [facility] + -- Urg(L)/Alr(N)/Resp(N) + uM160Facility [160] Facility, + + -- END SERVICE + -- Urg(L)/Alr(N)/Resp(N) + uM161NULL [161] NULL, + + -- SERVICE UNAVAILABLE + -- Urg(L)/Alr(L)/Resp(N ) + uM162NULL [162] NULL, + + -- [facilitydesignation] + -- Urg(L)/Alr(N)/Resp(N) + uM163FacilityDesignation [163] FacilityDesignation, + + -- WHEN READY + -- Urg(L)/Alr(N)/Resp(N) + uM164NULL [164] NULL, + + -- THEN + -- Urg(L)/Alr(N)/Resp(N) + uM165NULL [165] NULL, + + -- DUE TO [traffictype]TRAFFIC + -- Urg(L)/Alr(N)/Resp(N) + uM166TrafficType [166] TrafficType, + + -- DUE TO AIRSPACE RESTRICTION + -- Urg(L)/Alr(N)/Resp(N) + uM167NULL [167] NULL, + + -- DISREGARD + -- Urg(U)/Alr(M)/Resp(R) + uM168NULL [168] NULL, + + -- [freetext] + -- Urg(N)/Alr(L)/Resp(R) + uM169FreeText [169] FreeText, + + -- [freetext] + -- Urg(D)/Alr(H)/Resp(R) + uM170FreeText [170] FreeText, + + -- CLIMB AT [verticalRate] MINIMUM + -- Urg(N)/Alr(M)/Resp(W/U) + uM171VerticalRate [171] VerticalRate, + + -- CLIMB AT [verticalRate] MAXIMUM + -- Urg(N)/Alr(M)/Resp(W/U) + uM172VerticalRate [172] VerticalRate, + + -- DESCEND AT [verticalRate] MINIMUM + -- Urg(N)/Alr(M)/Resp(W/U) + uM173VerticalRate [173] VerticalRate, + + -- DESCEND AT [verticalRate] MAXIMUM + -- Urg(N)/Alr(M)/Resp(W/U) + uM174VerticalRate [174] VerticalRate, + + -- REPORT REACHING [level] + -- Urg(N)/Alr(L)/Resp(W/U) + uM175Level [175] Level, + + -- MAINTAIN OWN SEPARATION AND VMC + -- Urg(N)/Alr(M)/Resp(W/U) + uM176NULL [176] NULL, + + -- AT PILOTS DISCRETION + -- Urg(L)/Alr(L)/Resp(N) + uM177NULL [177] NULL, + + -- Reserved + -- Urg(L)/Alr(L)/Resp(Y) + uM178NULL [178] NULL, + + -- SQUAWK IDENT + -- Urg(N)/Alr(M)/Resp(W/U) + uM179NULL [179] NULL, + + -- REPORT REACHING BLOCK [level] TO [level] + -- Urg(N)/Alr(L)/Resp(W/U) + uM180LevelLevel [180] LevelLevel, + + -- REPORT DISTANCE [tofrom] [position] + -- Urg(N)/Alr(M)/Resp(Y) + uM181ToFromPosition [181] ToFromPosition, + + -- CONFIRM ATIS CODE + -- Urg(N)/Alr(L)/Resp(Y) + uM182NULL [182] NULL, + + -- [freetext] + -- Urg(N)/Alr(M)/Resp(N) + uM183FreeText [183] FreeText, + + -- AT [time] REPORT DISTANCE [tofrom] [position] + -- Urg(N)/Alr(L)/Resp(Y) + uM184TimeToFromPosition [184] TimeToFromPosition, + + -- AFTER PASSING [position] CLIMB TO [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM185PositionLevel [185] PositionLevel, + + -- AFTER PASSING [position] DESCEND TO [level] + -- Urg(N)/Alr(M)/Resp(W/U) + uM186PositionLevel [186] PositionLevel, + + -- [freetext] + -- Urg(L)/Alr(N)/Resp(N) + uM187FreeText [187] FreeText, + + -- AFTER PASSING [position] MAINTAIN [speed] + -- Urg(N)/Alr(M)/Resp(W/U) + uM188PositionSpeed [188] PositionSpeed, + + -- ADJUST SPEED TO [speed] + -- Urg(N)/Alr(M)/Resp(W/U) + uM189Speed [189] Speed, + + -- FLY HEADING [degrees] + -- Urg(N)/Alr(M)/Resp(W/U) + uM190Degrees [190] Degrees, + + -- ALL ATS TERMINATED + -- Urg(N)/Alr(M)/Resp(R) + uM191NULL [191] NULL, + + -- REACH [level] BY [time] + -- Urg(N)/Alr(M)/Resp(W/U) + uM192LevelTime [192] LevelTime, + + -- IDENTIFICATION LOST + -- Urg(N)/Alr(M)/Resp(R) + uM193NULL [193] NULL, + + -- [freetext] + -- Urg(N)/Alr(L)/Resp(Y) + uM194FreeText [194] FreeText, + + -- [freetext] + -- Urg(L)/Alr(L)/Resp(R) + uM195FreeText [195] FreeText, + + -- [freetext] + -- Urg(N)/Alr(M)/Resp + uM196FreeText [196] FreeText, + + -- [freetext] + -- Urg(U)/Alr(M)/Resp(W/U) + uM197FreeText [197] FreeText, + + -- [freetext] + -- Urg(D)/Alr(H)/Resp(W/U) + uM198FreeText [198] FreeText, + + -- [freetext] + -- Urg(N)/Alr(L)/Resp(N) + uM199FreeText [199] FreeText, + + -- REPORT REACHING + -- Urg(N)/Alr(L)/Resp(W/U) + uM200NULL [200] NULL, + + -- Not Used + -- Urg(L)/Alr(L)/Resp(N) + uM201NULL [201] NULL, + + -- Not Used + -- Urg(L)/Alr(L)/Resp(N) + uM202NULL [202] NULL, + + -- [freetext] + -- Urg(N)/Alr(M)/Resp(R) + uM203FreeText [203] FreeText, + + -- [freetext] + -- Urg(N)/Alr(M)/Resp(Y) + uM204FreeText [204] FreeText, + + -- [freetext] + -- Urg(N)/Alr(M)/Resp(A/N) + uM205FreeText [205] FreeText, + + -- [freetext] + -- Urg(L)/Alr(N)/Resp(Y) + uM206FreeText [206] FreeText, + + -- [freetext] + -- Urg(L)/Alr(L)/Resp(Y) + uM207FreeText [207] FreeText, + + -- [freetext] + -- Urg(L)/Alr(L)/Resp(N) + uM208FreeText [208] FreeText, + + -- REACH [level] BY [position] + -- Urg(N)/Alr(M)/Resp(W/U) + uM209LevelPosition [209] LevelPosition, + + -- IDENTIFIED [position] + -- Urg(N)/Alr(M)/Resp(R) + uM210Position [210] Position, + + -- REQUEST FORWARDED + -- Urg(N)/Alr(L)/Resp(N) + uM211NULL [211] NULL, + + -- [facilitydesignation] ATIS [atiscode] CURRENT + -- Urg(N)/Alr(L)/Resp(R) + uM212FacilityDesignationATISCode [212] FacilityDesignationATISCode, + + -- [facilitydesignation] ALTIMETER [altimeter] + -- Urg(N)/Alr(L)/Resp(R) + uM213FacilityDesignationAltimeter [213] FacilityDesignationAltimeter, + + -- RVR RUNWAY [runway] [rvr] + -- Urg(N)/Alr(M)/Resp(R) + uM214RunwayRVR [214] RunwayRVR, + + -- TURN [direction][degrees] + -- Urg(N)/Alr(M)/Resp(W/U) + uM215DirectionDegrees [215] DirectionDegrees, + + -- REQUEST FLIGHT PLAN + -- Urg(N)/Alr(M)/Resp(Y) + uM216NULL [216] NULL, + + -- REPORT ARRIVAL + -- Urg(N)/Alr(M)/Resp(Y) + uM217NULL [217] NULL, + + -- REQUEST ALREADY RECEIVED + -- Urg(L)/Alr(N)/Resp(N) + uM218NULL [218] NULL, + + -- STOP CLIMB AT [level] + -- Urg(U)/Alr(M)/Resp(W/U) + uM219Level [219] Level, + + -- STOP DESCENT AT [level] + -- Urg(U)/Alr(M)/Resp(W/U) + uM220Level [220] Level, + + -- STOP TURN HEADING [degrees] + -- Urg(U)/Alr(M)/Resp(W/U) + uM221Degrees [221] Degrees, + + -- NO SPEED RESTRICTION + -- Urg(L)/Alr(L)/Resp(R) + uM222NULL [222] NULL, + + -- REDUCE TO MINIMUM APPROACH SPEED + -- Urg(N)/Alr(M)/Resp(W/U) + uM223NULL [223] NULL, + + -- NO DELAY EXPECTED + -- Urg(N)/Alr(L)/Resp(R) + uM224NULL [224] NULL, + + -- DELAY NOT DETERMINED + -- Urg(N)/Alr(L)/Resp(R) + uM225NULL [225] NULL, + + -- EXPECTED APPROACH TIME [time] + -- Urg(N)/Alr(L)/Resp(R) + uM226Time [226] Time, + + -- LOGICAL ACKNOWLEDGMENT + -- Urg(N)/Alr(M)/Resp(N) + uM227NULL [227] NULL, + + -- REPORT ETA [position] + --Urg(L)/Alr(L)/Resp(Y) + uM228Position [228] Position, + + -- REPORT ALTERNATE AERODROME + -- Urg(L)/Alr(L)/Resp(Y) + uM229NULL [229] NULL, + + -- IMMEDIATELY + -- Urg(D)/Alr(H)/Resp(N) + uM230NULL [230] NULL, + + -- STATE PREFERRED LEVEL + -- Urg(L)/Alr(L)/Resp(Y) + uM231NULL [231] NULL, + + -- STATE TOP OF DESCENT + -- Urg(L)/Alr(L)/Resp(Y) + uM232NULL [232] NULL, + + -- USE OF LOGICAL ACKNOWLEDGMENT PROHIBITED + -- Urg(N)/Alr(M)/Resp(N) + uM233NULL [233] NULL, + + -- FLIGHT PLAN NOT HELD + -- Urg(L)/Alr(L)/Resp(N) + uM234NULL [234] NULL, + + -- ROGER 7500 + -- Urg(U)/Alr(H)/Resp(N) + uM235NULL [235] NULL, + + -- LEAVE CONTROLLED AIRSPACE + -- Urg(N)/Alr(M)/Resp(W/U) + uM236NULL [236] NULL, + ..., + + -- REQUEST AGAIN WITH NEXT UNIT + -- Urg(N)/Alr(L)/Resp(N) + uM237NULL [237]NULL +} + +------------------------------------------------------------------------------------ +-- Downlink message element +-- ---------------------------------------------------------------------------------- +ATCDownlinkMsgElementId ::= CHOICE +{ + -- WILCO + -- Urg(N)/Alr(M)/Resp(N) + dM0NULL [0] NULL, + + --UNABLE + -- Urg(N)/Alr(M)/Resp(N) + dM1NULL [1] NULL, + + -- STANDBY + -- Urg(N)/Alr(M)/Resp(N) + dM2NULL [2] NULL, + + -- ROGER + -- Urg(N)/Alr(M)/Resp(N) + dM3NULL [3] NULL, + + -- AFFIRM + -- Urg(N)/Alr(M)/Resp(N) + dM4NULL [4] NULL, + + -- NEGATIVE + -- Urg(N)/Alr(M)/Resp(N) + dM5NULL [5] NULL, + + -- REQUEST [level] + -- Urg(N)/Alr(L)/Resp(Y) + dM6Level [6] Level, + + -- REQUEST BLOCK [level] TO [level] + -- Urg(N)/Alr(L)/Resp(Y) + dM7LevelLevel [7] LevelLevel, + + -- REQUEST CRUISE CLIMB TO [level] + -- Urg(N)/Alr(L)/Resp(Y) + dM8Level [8] Level, + + -- REQUEST CLIMB TO [level] + -- Urg(N)/Alr(L)/Resp(Y) + dM9Level [9] Level, + + -- REQUEST DESCENT TO [level] + -- Urg(N)/Alr(L)/Resp(Y) + dM10Level [10] Level, + + -- AT [position] REQUEST CLIMB TO [level] + -- Urg(N)/Alr(L)/Resp(Y) + dM11PositionLevel [11] PositionLevel, + + -- AT [position] REQUEST DESCENT TO [level] + -- Urg(N)/Alr(L)/Resp(Y) + dM12PositionLevel [12] PositionLevel, + + -- AT [time] REQUEST CLIMB TO [level] + -- Urg(N)/Alr(L)/Resp(Y) + dM13TimeLevel [13] TimeLevel, + + -- AT [time] REQUEST DESCENT TO [level] + -- Urg(N)/Alr(L)/Resp(Y) + dM14TimeLevel [14] TimeLevel, + + -- REQUEST OFFSET [specifiedDistance] [direction] OF ROUTE + -- Urg(N)/Alr(L)/Resp(Y) + dM15DistanceSpecifiedDirection [15] DistanceSpecifiedDirection, + + -- AT [position] REQUEST OFFSET [specifiedDistance] [direction] OF ROUTE + -- Urg(N)/Alr(L)/Resp(Y) + dM16PositionDistanceSpecifiedDirection [16] PositionDistanceSpecifiedDirection, + + -- AT [time] REQUEST OFFSET [specifiedDistance] [direction] OF ROUTE + -- Urg(N)/Alr(L)/Resp(Y) + dM17TimeDistanceSpecifiedDirection [17] TimeDistanceSpecifiedDirection, + + -- REQUEST [speed] + -- Urg(N)/Alr(L)/Resp(Y) + dM18Speed [18] Speed, + + -- REQUEST [speed] TO [speed] + -- Urg(N)/Alr(L)/Resp(Y) + dM19SpeedSpeed [19] SpeedSpeed, + + -- REQUEST VOICE CONTACT + -- Urg(N)/Alr(L)/Resp(Y) + dM20NULL [20] NULL, + + -- REQUEST VOICE CONTACT [frequency] + -- Urg(N)/Alr(L)/Resp(Y) + dM21Frequency [21] Frequency, + + -- REQUEST DIRECT TO [position] + -- Urg(N)/Alr(L)/Resp(Y) + dM22Position [22] Position, + + -- REQUEST [procedureName] + -- Urg(N)/Alr(L)/Resp(Y) + dM23ProcedureName [23] ProcedureName, + + -- REQUEST CLEARANCE [routeClearance] + -- Urg(N)/Alr(L)/Resp(Y) + dM24RouteClearance [24] RouteClearanceIndex, + + -- REQUEST [clearanceType] CLEARANCE + -- Urg(N)/Alr(L)/Resp(Y) + dM25ClearanceType [25] ClearanceType, + + -- REQUEST WEATHER DEVIATION TO [position] VIA [routeClearance] + -- Urg(N)/Alr(M)/Resp(Y) + dM26PositionRouteClearance [26] PositionRouteClearanceIndex, + + -- REQUEST WEATHER DEVIATION UP TO [specifiedDistance] [direction] OF ROUTE + -- Urg(N)/Alr(M)/Resp(Y) + dM27DistanceSpecifiedDirection [27] DistanceSpecifiedDirection, + + -- LEAVING [level] + -- Urg(N)/Alr(L)/Resp(N) + dM28Level [28] Level, + + -- CLIMBING TO [level] + -- Urg(N)/Alr(L)/Resp(N) + dM29Level [29]Level, + + -- DESCENDING TO [level] + -- Urg(N)/Alr(L)/Resp(N) + dM30Level [30] Level, + + -- PASSING [position] + -- Urg(N)/Alr(L)/Resp(N) + dM31Position [31] Position, + + -- PRESENT LEVEL [level] + -- Urg(N)/Alr(L)/Resp(N) + dM32Level [32] Level, + + -- PRESENT POSITION [position] + -- Urg(N)/Alr(L)/Resp(N) + dM33Position [33] Position, + + -- PRESENT SPEED [speed] + -- Urg(N)/Alr(L)/Resp(N) + dM34Speed [34] Speed, + + -- PRESENT HEADING [degrees] + -- Urg(N)/Alr(L)/Resp(N) + dM35Degrees [35] Degrees, + + -- PRESENT GROUND TRACK [degrees] + -- Urg(N)/Alr(L)/Resp(N) + dM36Degrees [36] Degrees, + + -- MAINTAINING [level] + -- Urg(N)/Alr(L)/Resp(N) + dM37Level [37] Level, + + -- ASSIGNED LEVEL [level] + -- Urg(N)/Alr(M)/Resp(N) + dM38Level [38] Level, + + -- ASSIGNED SPEED [speed] + -- Urg(N)/Alr(M)/Resp(N) + dM39Speed [39] Speed, + + -- ASSIGNED ROUTE [routeClearance] + -- Urg(N)/Alr(M)/Resp(N) + dM40RouteClearance [40] RouteClearanceIndex, + + -- BACK ON ROUTE + -- Urg(N)/Alr(M)/Resp(N) + dM41NULL [41] NULL, + + -- NEXT WAYPOINT [position] + -- Urg(N)/Alr(L)/Resp(N) + dM42Position [42] Position, + + -- NEXT WAYPOINT ETA [time] + -- Urg(N)/Alr(L)/Resp(N) + dM43Time [43] Time, + + -- ENSUING WAYPOINT [position] + -- Urg(N)/Alr(L)/Resp(N) + dM44Position [44] Position, + + -- REPORTED WAYPOINT [position] + -- Urg(N)/Alr(L)/Resp(N) + dM45Position [45] Position, + + -- REPORTED WAYPOINT [time] + -- Urg(N)/Alr(L)/Resp(N) + dM46Time [46] Time, + + -- SQUAWKING [code] + -- Urg(N)/Alr(L)/Resp(N) + dM47Code [47] Code, + + -- POSITION REPORT [positionreport] + -- Urg(N)/Alr(M)/Resp(N) + dM48PositionReport [48] PositionReport, + + -- WHEN CAN WE EXPECT [speed] + -- Urg(L)/Alr(L)/Resp(Y) + dM49Speed [49] Speed, + + -- WHEN CAN WE EXPECT [speed] TO [speed] + -- Urg(L)/Alr(L)/Resp(Y) + dM50SpeedSpeed [50] SpeedSpeed, + + -- WHEN CAN WE EXPECT BACK ON ROUTE + -- Urg(L)/Alr(L)/Resp(Y) + dM51NULL [51] NULL, + + -- WHEN CAN WE EXPECT LOWER LEVEL + -- Urg(L)/Alr(L)/Resp(Y) + dM52NULL [52] NULL, + + -- WHEN CAN WE EXPECT HIGHER LEVEL Urg(L)/Alr(L)/Resp(Y) + dM53NULL [53] NULL, + + -- WHEN CAN WE EXPECT CRUISE CLIMB TO [level] + -- Urg(L)/Alr(L)/Resp(Y) + dM54Level [54] Level, + + -- PAN PAN PAN + -- Urg(U)/Alr(H)/Resp(Y) + dM55NULL [55] NULL, + + -- MAYDAY MAYDAY MAYDAY + -- Urg(D)/Alr(H)/Resp(Y) + dM56NULL [56] NULL, + + -- [remainingFuel] OF FUEL REMAINING AND [personsonboard] PERSONS ON BOARD + -- Urg(U)/Alr(H)/Resp(Y) + dM57RemainingFuelPersonsOnBoard [57] RemainingFuelPersonsOnBoard, + + -- CANCEL EMERGENCY + -- Urg(U)/Alr(M)/Resp(Y) + dM58NULL [58] NULL, + + -- DIVERTING TO [position] VIA [routeClearance] + -- Urg(U)/Alr(H)/Resp(Y) + dM59PositionRouteClearance [59] PositionRouteClearanceIndex, + + -- OFFSETTING [specifiedDistance] [direction] OF ROUTE + -- Urg(U)/Alr(H)/Resp(Y) + dM60DistanceSpecifiedDirection [60] DistanceSpecifiedDirection, + + -- DESCENDING TO [level] + -- Urg(U)/Alr(H)/Resp(Y) + dM61Level [61] Level, + + -- ERROR [errorInformation] + -- Urg(U)/Alr(L)/Resp(N) + dM62ErrorInformation [62] ErrorInformation, + + -- NOT CURRENT DATA AUTHORITY + -- Urg(L)/Alr(L)/Resp(N) + dM63NULL [63] NULL, + + -- [facilitydesignation] + -- Urg(L)/Alr(L)/Resp(N) + dM64FacilityDesignation [64] FacilityDesignation, + + -- DUE TO WEATHER + -- Urg(L)/Alr(L)/Resp(N) + dM65NULL [65] NULL, + + -- DUE TO AIRCRAFT PERFORMANCE + -- Urg(L)/Alr(L)/Resp(N) + dM66NULL [66] NULL, + + -- [freetext] + -- Urg(N)/Alr(L)/Resp(N) + dM67FreeText [67] FreeText, + + -- [freetext] + -- Urg(D)/Alr(H)/Resp(Y) + dM68FreeText [68] FreeText, + + -- REQUEST VMC DESCENT + -- Urg(N)/Alr(L)/Resp(Y) + dM69NULL [69] NULL, + + -- REQUEST HEADING [degrees] + -- Urg(N)/Alr(L)/Resp(Y) + dM70Degrees [70] Degrees, + + -- REQUEST GROUND TRACK [degrees] + -- Urg(N)/Alr(L)/Resp(Y) + dM71Degrees [71] Degrees, + + -- REACHING [level] + -- Urg(N)/Alr(L)/Resp(N) + dM72Level [72] Level, + + -- [versionnumber] + -- Urg(L)/Alr(L)/Resp(N) + dM73Versionnumber [73] VersionNumber, + + -- REQUEST TO MAINTAIN OWN SEPARATION AND VMC + -- Urg(L)/Alr(L)/Resp(Y) + dM74NULL [74] NULL, + + -- AT PILOTS DISCRETION + -- Urg(L)/Alr(L)/Resp(N) + dM75NULL [75] NULL, + + -- REACHING BLOCK [level] TO [level] + -- Urg(N)/Alr(L)/Resp(N) + dM76LevelLevel [76] LevelLevel, + + -- ASSIGNED BLOCK [level] TO [level] + -- Urg(N)/Alr(M)/Resp(N) + dM77LevelLevel [77] LevelLevel, + + -- AT [time] [distance] [tofrom] [position] + -- Urg(N)/Alr(L)/Resp(N) + dM78TimeDistanceToFromPosition [78] TimeDistanceToFromPosition, + + -- ATIS [atiscode] + -- Urg(N)/Alr(L)/Resp(N) + dM79AtisCode [79] ATISCode, + + -- DEVIATING UP TO [specifiedDistance] [direction] OF ROUTE + -- Urg(U)/Alr(H)/Resp(Y) + dM80DistanceSpecifiedDirection [80] DistanceSpecifiedDirection, + + -- WE CAN ACCEPT [level] AT [time] + -- Urg(L)/Alr(L)/Resp(N) + dM81LevelTime [81] LevelTime, + + -- WE CANNOT ACCEPT [level] + -- Urg(L)/Alr(L)/Resp(N) + dM82Level [82] Level, + + -- WE CAN ACCEPT [speed] AT [time] + -- Urg(L)/Alr(L)/Resp(N) + dM83SpeedTime [83] SpeedTime, + + -- WE CANNOT ACCEPT [speed] + -- Urg(L)/Alr(L)/Resp(N) + dM84Speed [84] Speed, + + -- WE CAN ACCEPT [specifiedDistance] [direction] AT [time] + -- Urg(L)/Alr(L)/Resp(N) + dM85DistanceSpecifiedDirectionTime [85] DistanceSpecifiedDirectionTime, + + -- WE CANNOT ACCEPT [specifiedDistance] [direction] + -- Urg(L)/Alr(L)/Resp(N) + dM86DistanceSpecifiedDirection [86] DistanceSpecifiedDirection, + + -- WHEN CAN WE EXPECT CLIMB TO [level] + -- Urg(L)/Alr(L)/Resp(Y) + dM87Level [87] Level, + + -- WHEN CAN WE EXPECT DESCENT TO [level] + --Urg(L)/Alr(L)/Resp(Y) + dM88Level [88] Level, + + -- MONITORING [unitname] [frequency] + -- Urg(U)/Alr(M)/Resp(N) + dM89UnitnameFrequency [89] UnitNameFrequency, + + -- [freetext] + -- Urg(N)/Alr(M)/Resp(N) + dM90FreeText [90] FreeText, + + -- [freetext] + -- Urg(N)/Alr(L)/Resp(Y) + dM91FreeText [91] FreeText, + + -- [freetext] + -- Urg(L)/Alr(L)/Resp(Y) + dM92FreeText [92] FreeText, + + -- [freetext] + -- Urg(U)/Alr(H)/Resp(N) + dM93FreeText [93] FreeText, + + -- [freetext] + -- Urg(D)/Alr(H)/Resp(N) + dM94FreeText [94] FreeText, + + -- [freetext] + -- Urg(U)/Alr(M)/Resp(N) + dM95FreeText [95] FreeText, + + -- [freetext] + -- Urg(U)/Alr(L)/Resp(N) + dM96FreeText [96] FreeText, + + -- [freetext] + -- Urg(L)/Alr(L)/Resp(N) + dM97FreeText [97] FreeText, + + -- [freetext] + -- Urg(N)/Alr(N)/Resp(N) + dM98FreeText [98] FreeText, + + -- CURRENT DATA AUTHORITY + -- Urg(L)/Alr(L)/Resp(N) + dM99NULL [99] NULL, + + -- LOGICAL ACKNOWLEDGMENT + -- Urg(N)/Alr(M)/Resp(N) + dM100NULL [100] NULL, + + -- REQUEST END OF SERVICE + -- Urg(L)/Alr(L)/Resp(Y) + dM101NULL [101] NULL, + + -- LANDING REPORT + -- Urg(N)/Alr(N)/Resp(N) + dM102NULL [102] NULL, + + -- CANCELLING IFR + -- Urg(N)/Alr(L)/Resp(Y) + dM103NULL [103] NULL, + + -- ETA[position][time] + -- Urg(L)/Alr(L)/Resp(N) + dM104PositionTime [104] PositionTime, + + -- ALTERNATE AERODROME[airport] + -- Urg(L)/Alr(L)/Resp(N) + dM105Airport [105] Airport, + + -- PREFERRED LEVEL[level] + -- Urg(L)/Alr(L)/Resp(N) + dM106Level [106] Level, + + -- NOT AUTHORIZED NEXT DATA AUTHORITY + -- Urg(L)/Alr(L)/Resp(N) + dM107NULL [107] NULL, + + -- DE-ICING COMPLETE + -- Urg(L)/Alr(L)/Resp(N) + dM108NULL [108] NULL, + + -- TOP OF DESCENT [time] + -- Urg(L)/Alr(L)/Resp(N) + dM109Time [109] Time, + + -- TOP OF DESCENT [position] + -- Urg(L)/Alr(L)/Resp(N) + dM110Position [110] Position, + + -- TOP OF DESCENT [time] [position] + -- Urg(L)/Alr(L)/Resp(N) + dM111TimePosition [111] TimePosition, + + -- SQUAWKING 7500 + -- Urg(U)/Alr(H)/Resp(N) + dM112NULL [112] NULL, + + -- [speedType] [speedType] [speedType] SPEED [speed] + -- Urg(N)/Alr(L)/Resp(N) + dM113SpeedTypeSpeedTypeSpeedTypeSpeed [113] SpeedTypeSpeedTypeSpeedTypeSpeed, + + ... +} + +AircraftAddress ::= BIT STRING (SIZE(24)) + +AircraftFlightIdentification ::= IA5String (SIZE (2..8)) + +Airport ::= IA5String (SIZE (4)) + +Altimeter ::= CHOICE +{ + altimeterEnglish [0] AltimeterEnglish, + altimeterMetric [1] AltimeterMetric +} + +AltimeterEnglish ::= INTEGER (2200..3200) +-- unit = Inches Mercury, Range (22.00 .. 32.00), resolution = 0.01 + +AltimeterMetric ::= INTEGER (7500..12500) +-- unit = Hectopascal, Range (750.0..1250.0), resolution = 0.1 + +ATISCode ::= IA5String (SIZE (1)) + +ATSRouteDesignator ::= IA5String (SIZE (2..7)) + +ATWAlongTrackWaypoint ::= SEQUENCE +{ + position [0] Position, + aTWDistance [1] ATWDistance, + speed [2] Speed OPTIONAL, + aTWLevels [3] ATWLevelSequence OPTIONAL +} + +ATWLevel ::= SEQUENCE +{ + atw ATWLevelTolerance, + level Level +} + +ATWLevelSequence ::= SEQUENCE SIZE (1..2) OF ATWLevel + +ATWLevelTolerance ::= ENUMERATED +{ + at (0), + atorabove (1), + atorbelow (2) +} + +ATWDistance ::= SEQUENCE +{ + atwDistanceTolerance ATWDistanceTolerance, + distance Distance +} + +ATWDistanceTolerance ::= ENUMERATED +{ + plus (0), + minus (1) +} + +ClearanceType ::= ENUMERATED +{ + noneSpecified (0), + approach (1), + departure (2), + further (3), + start-up (4), + pushback (5), + taxi (6), + take-off (7), + landing (8), + oceanic (9), + en-route (10), + downstream (11), + ... +} + +Code ::= SEQUENCE SIZE (4) OF CodeOctalDigit + +CodeOctalDigit ::= INTEGER (0..7) + +ControlledTime ::= SEQUENCE +{ + time Time, + timeTolerance TimeTolerance +} + +Date ::= SEQUENCE +{ + year Year, + month Month, + day Day +} + +DateTimeGroup ::= SEQUENCE +{ + date Date, + timehhmmss Timehhmmss +} + +Day ::= INTEGER (1..31) +--unit = Day, Range (1..31), resolution = 1 + +DegreeIncrement ::= INTEGER (1..20) +--unit = Degree, Range (1..20), resolution = 1 + +Degrees ::= CHOICE +{ + degreesMagnetic [0] DegreesMagnetic, + degreesTrue [1] DegreesTrue +} + +DegreesMagnetic ::= INTEGER (1..360) +--unit = degree, Range (1..360), resolution = 1 + +DegreesTrue ::= INTEGER (1..360) +--unit = degree, Range (1..360), resolution = 1 + +DepartureClearance ::= SEQUENCE +{ + aircraftFlightIdentification [0] AircraftFlightIdentification, + clearanceLimit [1] Position, + flightInformation [2] FlightInformation OPTIONAL, + furtherInstructions [3] FurtherInstructions OPTIONAL +} + +DepartureMinimumInterval ::= INTEGER (1..150) +--unit = Minute, Range (0.1..15.0), resolution = 0.1 + +Direction ::= ENUMERATED +{ + left (0), + right (1), + eitherSide (2), + north (3), + south (4), + east (5), + west (6), + northEast (7), + northWest (8), + southEast (9), + southWest (10) +} + +DirectionDegrees ::= SEQUENCE +{ + direction Direction, + degrees Degrees +} + +Distance ::= CHOICE +{ + distanceNm [0] DistanceNm, + distanceKm [1] DistanceKm +} + + +DistanceKm ::= INTEGER (0..8000) +-- unit = Kilometer, Range (0..2000), resolution = 0.25 + +DistanceNm ::= INTEGER (0..9999) +-- unit = Nautical Mile, Range (0..999.9), resolution = 0.1 + +DistanceSpecified ::= CHOICE +{ + distanceSpecifiedNm [0] DistanceSpecifiedNm, + distanceSpecifiedKm [1] DistanceSpecifiedKm +} + + +DistanceSpecifiedDirection ::= SEQUENCE +{ + distanceSpecified DistanceSpecified, + direction Direction +} + +DistanceSpecifiedDirectionTime ::= SEQUENCE +{ + distanceSpecifiedDirection DistanceSpecifiedDirection, + time Time +} + +DistanceSpecifiedKm ::= INTEGER (1..500) +-- unit = Kilometer, Range (1..500), resolution = 1 + +DistanceSpecifiedNm ::= INTEGER (1..250) +-- unit = Nautical Mile, Range (1..250), resolution = 1 + +ErrorInformation ::= ENUMERATED +{ + unrecognizedMsgReferenceNumber (0), + logicalAcknowledgmentNotAccepted (1), + insufficientResources (2), + invalidMessageElementCombination (3), + invalidMessageElement (4), + ... +} + +Facility ::= CHOICE{ + noFacility [0] NULL, + facilityDesignation [1] FacilityDesignation +} + +FacilityDesignation ::= IA5String (SIZE (4..8)) + +FacilityFunction ::= ENUMERATED +{ + center (0), + approach (1), + tower (2), + final (3), + groundControl (4), + clearanceDelivery (5), + departure (6), + control (7), + radio (8), + ... +} + +FacilityDesignationAltimeter ::= SEQUENCE +{ + facilityDesignation FacilityDesignation, + altimeter Altimeter +} + +FacilityDesignationATISCode ::= SEQUENCE +{ + facilityDesignation FacilityDesignation, + aTISCode ATISCode +} + +FacilityName ::= IA5String (SIZE (3..18)) + +Fix ::= IA5String (SIZE (1..5)) + +FixName ::= SEQUENCE +{ + name [0] Fix, + latlon [1] LatitudeLongitude OPTIONAL +} + +FlightInformation ::= CHOICE +{ + routeOfFlight [0] RouteInformation, + levelsOfFlight [1] LevelsOfFlight, + routeAndLevels [2] RouteAndLevels +} + +FreeText ::= IA5String (SIZE (1..256)) + +Frequency ::= CHOICE +{ + frequencyhf [0] Frequencyhf, + frequencyvhf [1] Frequencyvhf, + frequencyuhf [2] Frequencyuhf, + frequencysatchannel [3] Frequencysatchannel +} + +Frequencyhf ::= INTEGER (2850..28000) +-- unit = Kilohertz, Range (2850..28000), resolution = 1 + +Frequencysatchannel ::= NumericString (SIZE (12)) +-- Frequencysatchannel corresponds to a 12 digit telephone number + +Frequencyuhf ::= INTEGER (9000..15999) +-- unit = Megahertz, Range (225.000..399.975), resolution = 0.025 + +Frequencyvhf ::= INTEGER (23600..27398) +-- unit = Megahertz, Range (118.000..136.990), resolution = 0.005 + +FurtherInstructions ::= SEQUENCE +{ + code [0] Code OPTIONAL, + frequencyDeparture [1] UnitNameFrequency OPTIONAL, + clearanceExpiryTime [2] Time OPTIONAL, + airportDeparture [3] Airport OPTIONAL, + airportDestination [4] Airport OPTIONAL, + timeDeparture [5] TimeDeparture OPTIONAL, + runwayDeparture [6] Runway OPTIONAL, + revisionNumber [7] RevisionNumber OPTIONAL, + aTISCode [8] ATISCode OPTIONAL +} + + +Holdatwaypoint ::= SEQUENCE +{ + position [0] Position, + holdatwaypointspeedlow [1] Speed OPTIONAL, + aTWlevel [2] ATWLevel OPTIONAL, + holdatwaypointspeedhigh [3] Speed OPTIONAL, + direction [4] Direction OPTIONAL, + degrees [5] Degrees OPTIONAL, + eFCtime [6] Time OPTIONAL, + legtype [7] LegType OPTIONAL +} + +HoldClearance ::= SEQUENCE +{ + position [0] Position, + level [1] Level, + degrees [2] Degrees, + direction [3] Direction, + legType [4] LegType OPTIONAL +} + + +Humidity ::= INTEGER (0..100) +-- unit = Percent humidity, Range (0..100), resolution = 1 + +InterceptCourseFrom ::= SEQUENCE +{ + fromSelection InterceptCourseFromSelection, + degrees Degrees +} + +InterceptCourseFromSelection ::= CHOICE +{ + publishedIdentifier [0] PublishedIdentifier, + latitudeLongitude [1] LatitudeLongitude, + placeBearingPlaceBearing [2] PlaceBearingPlaceBearing, + placeBearingDistance [3] PlaceBearingDistance +} + +Icing ::= ENUMERATED +{ + reserved (0), + light (1), + moderate (2), + severe (3) +} + + +Latitude ::= SEQUENCE +{ + latitudeType LatitudeType, + latitudeDirection LatitudeDirection +} + +LatitudeDegrees ::= INTEGER (0..90000) +-- unit = Degree, Range (0..90), resolution = 0.001 + +LatitudeDegreesMinutes ::= SEQUENCE +{ + latitudeWholeDegrees LatitudeWholeDegrees, + minutesLatLon MinutesLatLon +} + +LatitudeDegreesMinutesSeconds ::= SEQUENCE +{ + latitudeWholeDegrees LatitudeWholeDegrees, + latlonWholeMinutes LatLonWholeMinutes, + secondsLatLon SecondsLatLon +} + +LatitudeDirection ::= ENUMERATED +{ + north (0), + south (1) +} + +LatitudeWholeDegrees ::= INTEGER (0..89) +-- unit = Degree, Range (0..89), resolution = 1 + +LatitudeLongitude ::= SEQUENCE +{ + latitude [0] Latitude OPTIONAL, + longitude [1] Longitude OPTIONAL +} + +LatitudeReportingPoints ::= SEQUENCE +{ + latitudeDirection LatitudeDirection, + latitudeDegrees LatitudeDegrees +} + +LatitudeType ::= CHOICE +{ + latitudeDegrees [0] LatitudeDegrees, + latitudeDegreesMinutes [1] LatitudeDegreesMinutes, + latitudeDMS [2] LatitudeDegreesMinutesSeconds +} + +LatLonWholeMinutes ::= INTEGER (0..59) +-- unit = Minute, Range (0..59), resolution = 1 + +LatLonReportingPoints ::= CHOICE +{ + latitudeReportingPoints [0] LatitudeReportingPoints, + longitudeReportingPoints [1] LongitudeReportingPoints +} + +LegDistance ::= CHOICE +{ + legDistanceEnglish [0] LegDistanceEnglish, + legDistanceMetric [1] LegDistanceMetric +} + +LegDistanceEnglish ::= INTEGER (0..50) +-- unit = Nautical Mile, Range (0..50), resolution = 1 + +LegDistanceMetric ::= INTEGER (1..128) +-- unit = Kilometer, Range (1..128), resolution = 1 + +LegTime ::= INTEGER (0..10) +--unit = Minute, Range (0..10), resolution = 1 + +LegType ::= CHOICE +{ + legDistance [0] LegDistance, + legTime [1] LegTime +} + +Level ::= CHOICE +{ + singleLevel [0] LevelType, + blockLevel [1] SEQUENCE SIZE (2) OF LevelType +} + +LevelFeet ::= INTEGER (-60..7000) +--unit = Feet, Range (-600..70000), resolution = 10 + +LevelFlightLevel ::= INTEGER (30..700) +--unit = Level (100 Feet), Range (030..700), resolution = 1 + +LevelFlightLevelMetric ::= INTEGER (100..2500) +--unit = Level (10 Meters), Range (100..2500), resolution = 1 +LevelLevel ::= SEQUENCE SIZE (2) OF Level +LevelMeters ::= INTEGER (-30..25000) +--unit = Meter, Range (-30..25000), resolution = 1 + +LevelPosition ::= SEQUENCE +{ + level Level, + position Position +} + +LevelProcedureName ::= SEQUENCE +{ + level Level, + procedureName ProcedureName +} + +LevelsOfFlight ::= CHOICE +{ + level [0] Level, + procedureName [1] ProcedureName, + levelProcedureName [2] LevelProcedureName +} + +LevelSpeed ::= SEQUENCE +{ + level Level, + speed SpeedSpeed +} + +LevelSpeedSpeed ::= SEQUENCE +{ + level Level, + speeds SpeedSpeed +} + +LevelTime ::= SEQUENCE +{ + level Level, + time Time +} + +LevelType ::= CHOICE +{ + levelFeet [0] LevelFeet, + levelMeters [1] LevelMeters, + levelFlightLevel [2] LevelFlightLevel, + levelFlightLevelMetric [3] LevelFlightLevelMetric +} + +Longitude ::= SEQUENCE +{ + longitudeType LongitudeType, + longitudeDirection LongitudeDirection +} + +LongitudeDegrees ::= INTEGER (0..180000) +--unit = Degree, Range (0..180), resolution = 0.001 + +LongitudeDegreesMinutes ::= SEQUENCE +{ + longitudeWholeDegrees LongitudeWholeDegrees, + minutesLatLon MinutesLatLon +} + +LongitudeDegreesMinutesSeconds ::= SEQUENCE +{ + longitudeWholeDegrees LongitudeWholeDegrees, + latLonWholeMinutes LatLonWholeMinutes, + secondsLatLon SecondsLatLon +} + +LongitudeDirection ::= ENUMERATED +{ + east (0), + west (1) +} + +LongitudeWholeDegrees ::= INTEGER (0..179) +-- unit = Degree, Range (0..179), resolution = 1 + +LongitudeReportingPoints ::= SEQUENCE +{ + longitudeDirection LongitudeDirection, + longitudeDegrees LongitudeDegrees +} + +LongitudeType ::= CHOICE +{ + longitudeDegrees [0] LongitudeDegrees, + longitudeDegreesMinutes [1] LongitudeDegreesMinutes, + longitudeDMS [2] LongitudeDegreesMinutesSeconds +} + +MinutesLatLon ::= INTEGER (0..5999) +--unit = Minute, Range (0..59.99), resolution = 0.01 + +Month ::= INTEGER (1..12) +--unit = 1 Month, Range (1..12), resolution = 1 + +Navaid ::= SEQUENCE +{ + name [0] NavaidName, + latlon [1] LatitudeLongitude OPTIONAL +} + +NavaidName ::= IA5String (SIZE (1..4)) + +PersonsOnBoard ::= INTEGER (1..1024) + +PlaceBearing ::= SEQUENCE +{ + publishedIdentifier PublishedIdentifier, + degrees Degrees +} + +PlaceBearingDistance ::= SEQUENCE +{ + publishedIdentifier PublishedIdentifier, + degrees Degrees, + distance Distance +} + +PlaceBearingPlaceBearing ::= SEQUENCE SIZE (2) OF PlaceBearing + +Position ::= CHOICE +{ + fixName [0] FixName, + navaid [1] Navaid, + airport [2] Airport, + latitudeLongitude [3] LatitudeLongitude, + placeBearingDistance [4] PlaceBearingDistance +} + +PositionDegrees ::= SEQUENCE +{ + position Position, + degrees Degrees +} + + +PositionDistanceSpecifiedDirection ::= SEQUENCE +{ + position Position, + distanceSpecifiedDirection DistanceSpecifiedDirection +} + +PositionLevel ::= SEQUENCE +{ + position Position, + level Level +} + +PositionLevelLevel ::= SEQUENCE +{ + position Position, + levels LevelLevel +} + +PositionLevelSpeed ::= SEQUENCE +{ + positionlevel PositionLevel, + speed Speed +} + +PositionPosition ::= SEQUENCE SIZE (2) OF Position + +PositionProcedureName ::= SEQUENCE +{ + position Position, + procedureName ProcedureName +} + +PositionReport ::= SEQUENCE +{ + positioncurrent [0] Position, + timeatpositioncurrent [1] Time, + level [2] Level, + fixnext [3] Position OPTIONAL, + timeetaatfixnext [4] Time OPTIONAL, + fixnextplusone [5] Position OPTIONAL, + timeetaatdestination [6] Time OPTIONAL, + remainingFuel [7] RemainingFuel OPTIONAL, + temperature [8] Temperature OPTIONAL, + winds [9] Winds OPTIONAL, + turbulence [10] Turbulence OPTIONAL, + icing [11] Icing OPTIONAL, + speed [12] Speed OPTIONAL, + speedground [13] SpeedGround OPTIONAL, + verticalChange [14] VerticalChange OPTIONAL, + trackAngle [15] Degrees OPTIONAL, + heading [16] Degrees OPTIONAL, + distance [17] Distance OPTIONAL, + humidity [18] Humidity OPTIONAL, + reportedWaypointPosition[19] Position OPTIONAL, + reportedWaypointTime [20] Time OPTIONAL, + reportedWaypointLevel [21] Level OPTIONAL +} + +PositionRouteClearanceIndex ::= SEQUENCE +{ + position Position, + routeClearanceIndex RouteClearanceIndex +} + +PositionSpeed ::= SEQUENCE +{ + position Position, + speed Speed +} + +PositionSpeedSpeed ::= SEQUENCE +{ + position Position, + speeds SpeedSpeed +} + +PositionTime ::= SEQUENCE +{ + position Position, + time Time +} + +PositionTimeLevel ::= SEQUENCE +{ + positionTime PositionTime, + level Level +} + +PositionTimeTime ::= SEQUENCE +{ + position Position, + times TimeTime +} + +PositionUnitNameFrequency ::= SEQUENCE +{ + position Position, + unitname UnitName, + frequency Frequency +} + +Procedure ::= IA5String (SIZE (1..20)) + +ProcedureName ::= SEQUENCE +{ + type [0] ProcedureType, + procedure [1] Procedure, + transition [2] ProcedureTransition OPTIONAL +} + +ProcedureTransition ::= IA5String (SIZE (1..5)) + +ProcedureType ::= ENUMERATED +{ + arrival (0), + approach (1), + departure (2) +} + +PublishedIdentifier ::= CHOICE +{ + fixName [0] FixName, + navaid [1] Navaid +} + +RemainingFuel ::= Time + +RemainingFuelPersonsOnBoard ::= SEQUENCE +{ + remainingFuel RemainingFuel, + personsOnBoard PersonsOnBoard +} + +ReportingPoints ::= SEQUENCE +{ + latLonReportingPoints [0] LatLonReportingPoints, + degreeIncrement [1] DegreeIncrement OPTIONAL +} + +RevisionNumber ::= INTEGER (1..16) + +RouteAndLevels ::= SEQUENCE +{ + routeOfFlight RouteInformation, + levelsOfFlight LevelsOfFlight +} + +RouteClearance ::= SEQUENCE +{ + airportDeparture [0] Airport OPTIONAL, + airportDestination [1] Airport OPTIONAL, + runwayDeparture [2] Runway OPTIONAL, + procedureDeparture [3] ProcedureName OPTIONAL, + runwayArrival [4] Runway OPTIONAL, + procedureApproach [5] ProcedureName OPTIONAL, + procedureArrival [6] ProcedureName OPTIONAL, + routeInformations [7] SEQUENCE SIZE (1..128) OF RouteInformation OPTIONAL, + routeInformationAdditional [8] RouteInformationAdditional OPTIONAL +} + +RouteClearanceIndex ::= INTEGER (1..2) +-- RouteClearanceIndex identifies the position of the RouteClearance data +-- in the ASN.1 type for +-- ATC UplinkMessage, constrained Data, routeClearance Data +-- ATC DownlinkMessage, constrained Data, routeClearance Data + +RouteInformation ::= CHOICE +{ + publishedIdentifier [0] PublishedIdentifier, + latitudeLongitude [1] LatitudeLongitude, + placeBearingPlaceBearing [2] PlaceBearingPlaceBearing, + placeBearingDistance [3] PlaceBearingDistance, + aTSRouteDesignator [4] ATSRouteDesignator +} + + +RouteInformationAdditional ::= SEQUENCE +{ + aTWAlongTrackWaypoints [0] SEQUENCE SIZE (1..8) OF ATWAlongTrackWaypoint OPTIONAL, + reportingpoints [1] ReportingPoints OPTIONAL, + interceptCourseFroms [2] SEQUENCE SIZE (1..4) OF InterceptCourseFrom OPTIONAL, + holdAtWaypoints [3] SEQUENCE SIZE (1..8) OF Holdatwaypoint OPTIONAL, + waypointSpeedLevels [4] SEQUENCE SIZE (1..32) OF WaypointSpeedLevel OPTIONAL, + rTARequiredTimeArrivals [5] SEQUENCE SIZE (1..32) OF RTARequiredTimeArrival OPTIONAL +} + +RTARequiredTimeArrival ::= SEQUENCE +{ + position [0] Position, + rTATime [1] RTATime, + rTATolerance [2] RTATolerance OPTIONAL +} + +RTATime ::= SEQUENCE +{ + time Time, + timeTolerance TimeTolerance +} + +RTATolerance ::= INTEGER (1..150) +--unit= Minute, Range (0.1..15.0), resolution = 0.1 + +Runway ::= SEQUENCE +{ + direction RunwayDirection, + configuration RunwayConfiguration +} + +RunwayDirection ::= INTEGER (1..36) + +RunwayConfiguration ::= ENUMERATED +{ + left (0), + right (1), + center (2), + none (3) +} + +RunwayRVR ::= SEQUENCE +{ + runway Runway, + rVR RVR +} + +RVR ::= CHOICE +{ + rVRFeet [0] RVRFeet, + rVRMeters [1] RVRMeters +} + +RVRFeet ::= INTEGER (0..6100) +-- unit = Feet, Range (0..6100), resolution = 1 + +RVRMeters ::= INTEGER (0..1500) +-- unit = Meters (0..1500), resolution = 1 + +SecondsLatLon ::= INTEGER (0..59) +--unit = Second, Range (0.. 59), resolution = 1 + +Speed ::= CHOICE +{ + speedIndicated [0] SpeedIndicated, + speedIndicatedMetric [1] SpeedIndicatedMetric, + speedTrue [2] SpeedTrue, + speedTrueMetric [3] SpeedTrueMetric, + speedGround [4] SpeedGround, + speedGroundMetric [5] SpeedGroundMetric, + speedMach [6] SpeedMach +} + +SpeedIndicated ::= INTEGER (0..400) +-- unit = Knots, Range (0..400), resolution = 1 + +SpeedIndicatedMetric ::= INTEGER (0..800) +-- unit = Kilometers/Hour, Range (0..800), resolution = 1 + +SpeedGround ::= INTEGER (-50..2000) +-- unit = Knots, Range (-50..2000), resolution = 1 + +SpeedGroundMetric ::= INTEGER (-100..4000) +-- unit = Kilometers/Hour, Range (-100..4000), resolution = 1 + +SpeedMach ::= INTEGER (500..4000) +-- unit = Mach Range (0.5 to 4.0), resolution = 0.001 + +SpeedSpeed ::= SEQUENCE SIZE (2) OF Speed +SpeedTime ::= SEQUENCE +{ + speed Speed, + time Time +} + +SpeedTrue ::= INTEGER (0..2000) +-- unit = Knots, Range (0..2000), resolution = 1 + +SpeedTrueMetric ::= INTEGER (0..4000) +-- unit = Kilometers/Hour, Range (0..4000), resolution = 1 + +SpeedType ::= ENUMERATED +{ + noneSpecified (0), + indicated (1), + true (2), + ground (3), + mach (4), + approach (5), + cruise (6), + minimum (7), + maximum (8), + ... +} + +SpeedTypeSpeedTypeSpeedType ::= SEQUENCE SIZE (3) OF SpeedType + +SpeedTypeSpeedTypeSpeedTypeSpeed ::= SEQUENCE +{ + speedTypes SpeedTypeSpeedTypeSpeedType, + speed Speed +} + +Temperature ::= INTEGER (-100..100) +-- unit = Degree Celsius, Range (-100..100), resolution = 1 + +Time ::= SEQUENCE +{ + hours TimeHours, + minutes TimeMinutes +} + +TimeLevel ::= SEQUENCE +{ + time Time, + level Level +} + +TimeDeparture ::= SEQUENCE +{ + timeDepartureAllocated [0] Time OPTIONAL, + timeDepartureControlled [1] ControlledTime OPTIONAL, + timeDepartureClearanceExpected [2] Time OPTIONAL, + departureMinimumInterval [3] DepartureMinimumInterval OPTIONAL +} + + +TimeDistanceSpecifiedDirection ::= SEQUENCE +{ + time Time, + distanceSpecifiedDirection DistanceSpecifiedDirection +} + +TimeDistanceToFromPosition ::= SEQUENCE +{ + time Time, + distance Distance, + tofrom ToFrom, + position Position +} + +Timehhmmss ::= SEQUENCE +{ + hoursminutes Time, + seconds TimeSeconds +} + +TimeHours ::= INTEGER (0..23) +-- unit = Hour, Range (0..23), resolution = 1 + +TimeUnitNameFrequency ::= SEQUENCE +{ + time Time, + unitName UnitName, + frequency Frequency +} + +TimeMinutes ::= INTEGER (0..59) +-- unit = Minute, Range (0..59), resolution = 1 + +TimePosition ::= SEQUENCE +{ + time Time, + position Position +} + +TimePositionLevel ::= SEQUENCE +{ + timeposition TimePosition, + level Level +} + +TimePositionLevelSpeed ::= SEQUENCE +{ + timeposition TimePosition, + levelspeed LevelSpeed +} + +TimeSeconds ::= INTEGER (0..59) +-- unit = Second, Range (0..59), resolution = 1 + +TimeSpeed ::= SEQUENCE +{ + time Time, + speed Speed +} + +TimeSpeedSpeed ::= SEQUENCE +{ + time Time, + speedspeed SpeedSpeed +} + +TimeTime ::= SEQUENCE SIZE (2) OF Time + +TimeToFromPosition ::= SEQUENCE +{ + time Time, + tofrom ToFrom, + position Position +} +TimeTolerance ::= ENUMERATED +{ + at (0), + atorafter (1), + atorbefore(2) +} + +ToFrom ::= ENUMERATED +{ + to (0), + from (1) +} + +ToFromPosition ::= SEQUENCE +{ + toFrom ToFrom, + position Position +} + +TrafficType ::= ENUMERATED +{ + noneSpecified (0), + oppositeDirection (1), + sameDirection (2), + converging (3), + crossing (4), + diverging (5), + ... +} + +Turbulence ::= ENUMERATED +{ + light (0), + moderate (1), + severe (2) +} + +UnitName ::= SEQUENCE +{ + facilityDesignation [0] FacilityDesignation, + facilityName [1] FacilityName OPTIONAL, + facilityFunction [2] FacilityFunction +} + +UnitNameFrequency ::= SEQUENCE +{ + unitName UnitName, + frequency Frequency +} + +VersionNumber ::= INTEGER (0..15) + +VerticalChange ::= SEQUENCE +{ + direction VerticalDirection, + rate VerticalRate +} + +VerticalDirection ::= ENUMERATED +{ + up (0), + down (1) +} + +VerticalRate ::= CHOICE +{ + verticalRateEnglish [0] VerticalRateEnglish, + verticalRateMetric [1] VerticalRateMetric +} + +VerticalRateEnglish ::= INTEGER (0..3000) +-- unit = Feet/Minute, Range (0..30000), resolution = 10 + +VerticalRateMetric ::= INTEGER (0..1000) +-- unit = Meters/Minute, Range (0..10000), resolution = 10 + +WaypointSpeedLevel ::= SEQUENCE +{ + position [0] Position, + speed [1] Speed OPTIONAL, + aTWLevels [2] ATWLevelSequence OPTIONAL +} + +WindDirection ::= INTEGER (1..360) +-- unit = Degree, Range (1..360), resolution = 1 + +Winds ::= SEQUENCE +{ + direction WindDirection, + speed WindSpeed +} + +WindSpeed ::= CHOICE +{ + windSpeedEnglish [0] WindSpeedEnglish, + windSpeedMetric [1] WindSpeedMetric +} + +WindSpeedEnglish ::= INTEGER (0..255) +-- unit = Knot, Range (0..255), resolution = 1 + +WindSpeedMetric ::= INTEGER (0..511) +-- unit = Kilometer/Hour, Range (0..511), resolution = 1 + +Year ::= INTEGER (1996..2095) +-- unit = Year, Range (1996..2095), resolution = 1 + +END + + +-- +-- Editor modelines - https://www.wireshark.org/tools/modelines.html +-- +-- Local variables: +-- c-basic-offset: 4 +-- tab-width: 8 +-- indent-tabs-mode: nil +-- End: +-- +-- vi: set shiftwidth=4 tabstop=8 expandtab: +-- :indentSize=4:tabSize=8:noTabs=true: +-- diff --git a/epan/dissectors/asn1/atn-cpdlc/atn-cpdlc.cnf b/epan/dissectors/asn1/atn-cpdlc/atn-cpdlc.cnf new file mode 100644 index 00000000..ca700443 --- /dev/null +++ b/epan/dissectors/asn1/atn-cpdlc/atn-cpdlc.cnf @@ -0,0 +1,134 @@ +#.MODULE_IMPORT +#.END + +#.EXPORTS +#.END + +#.OMIT_ASSIGNMENT +#.END + +#.PDU + AircraftPDUs + GroundPDUs + ProtectedAircraftPDUs + ProtectedGroundPDUs +#.END + + +#.FIELD_RENAME +AircraftPDUs/send aircraftpdus_send +GroundPDUs/send groundpdus_send +ATCUplinkMessageData/constrainedData atcuplinkmessagedata_constraineddata +ATCDownlinkMessageData/constrainedData atcdownlinkmessagedata_constraineddata +ATCDownlinkMessageData/elementIds/_item atcdownlinkmessagedata_elementids_item +ATCUplinkMessageData/elementIds/_item atcuplinkmessagedata_elementids_item +ATCDownlinkMessageData/elementIds atcdownlinkmessagedata_elementids +ATCUplinkMessageData/elementIds atcuplinkmessagedata_elementids +ATCUplinkMessage/messageData atcuplinkmessage_messagedata +ATCDownlinkMessage/messageData atcdownlinkmessage_messagedata +Runway/direction runway_direction +Winds/direction winds_direction +DirectionDegrees/direction direction +DistanceSpecifiedDirection/direction direction +Holdatwaypoint/direction direction +HoldClearance/direction direction +VerticalChange/direction vertical_direction +FixName/name fixname_name +Navaid/name navaid_name +Winds/speed winds_speed +LevelSpeed/speed levelspeed_speed +ProtectedGroundPDUs/abortProvider pmcpdlcproviderabortreason +ProtectedAircraftPDUs/abortProvider pmcpdlcproviderabortreason +ProtectedGroundPDUs/abortUser pmcpdlcuserabortreason +ProtectedAircraftPDUs/abortUser pmcpdlcuserabortreason +ProtectedStartDownMessage/mode protectedmode +ProtectedGroundPDUs/send protecteduplinkmessage +ProtectedStartDownMessage/startDownlinkMessage protecteddownlinkmessage +ProtectedGroundPDUs/startup protecteduplinkmessage +ProtectedAircraftPDUs/startdown protectedstartDownmessage +#.END + + +#.FN_BODY CPDLCMessage + tvbuff_t *tvb_usr = NULL; + + offset = dissect_per_bit_string(tvb, offset, actx, tree, hf_index, NO_BOUND, NO_BOUND, FALSE, NULL, 0, &tvb_usr, NULL); + + if (tvb_usr) { + switch(check_heur_msg_type(actx->pinfo)){ + case dm: + dissect_atn_cpdlc_ATCDownlinkMessage(tvb_new_subset_remaining(tvb_usr, 0), 0, actx, tree, hf_index); + break; + case um: + dissect_atn_cpdlc_ATCUplinkMessage(tvb_new_subset_remaining(tvb_usr, 0), 0, actx , tree, hf_index); + break; + default: + break; + } + } + +#.END + +#.FN_BODY AlgorithmIdentifier + proto_tree *top_tree=NULL; + + offset=call_ber_oid_callback(object_identifier_id, tvb, offset, actx->pinfo, top_tree, NULL); + +#.END + +#.FN_BODY AircraftFlightIdentification + offset = dissect_per_restricted_character_string(tvb, offset, actx, tree, hf_index,2, 8, FALSE, ia5alpha , 127, NULL); +#.END + +#.FN_BODY Airport + offset = dissect_per_restricted_character_string(tvb, offset, actx, tree, hf_index,4, 4, FALSE, ia5alpha , 127, NULL); +#.END + +#.FN_BODY FacilityDesignation + offset = dissect_per_restricted_character_string(tvb, offset, actx, tree, hf_index,4, 8, FALSE, ia5alpha , 127, NULL); +#.END + +#.FN_BODY FreeText + offset = dissect_per_restricted_character_string(tvb, offset, actx, tree, hf_index,1, 256, FALSE, ia5alpha , 127, NULL); +#.END + +#.FN_BODY NavaidName + offset = dissect_per_restricted_character_string(tvb, offset, actx, tree, hf_index,1, 4, FALSE, ia5alpha , 127, NULL); +#.END + +#.FN_BODY Procedure + offset = dissect_per_restricted_character_string(tvb, offset, actx, tree, hf_index,1, 20, FALSE, ia5alpha , 127, NULL); +#.END + +#.FN_BODY ProcedureTransition + offset = dissect_per_restricted_character_string(tvb, offset, actx, tree, hf_index,1, 5, FALSE, ia5alpha , 127, NULL); +#.END + +#.FN_BODY Fix + offset = dissect_per_restricted_character_string(tvb, offset, actx, tree, hf_index,1, 5, FALSE, ia5alpha , 127, NULL); +#.END + +#.FN_BODY ATISCode + offset = dissect_per_restricted_character_string(tvb, offset, actx, tree, hf_index,1, 1, FALSE, ia5alpha , 127, NULL); +#.END + +#.FN_BODY ATSRouteDesignator + offset = dissect_per_restricted_character_string(tvb, offset, actx, tree, hf_index,2, 7, FALSE, ia5alpha , 127, NULL); +#.END + +#.FN_BODY FacilityName + offset = dissect_per_restricted_character_string(tvb, offset, actx, tree, hf_index,3, 18, FALSE, ia5alpha , 127, NULL); +#.END + +# +# Editor modelines - https://www.wireshark.org/tools/modelines.html +# +# Local variables: +# c-basic-offset: 4 +# tab-width: 8 +# indent-tabs-mode: nil +# End: +# +# vi: set shiftwidth=4 tabstop=8 expandtab: +# :indentSize=4:tabSize=8:noTabs=true: +# diff --git a/epan/dissectors/asn1/atn-cpdlc/packet-atn-cpdlc-template.c b/epan/dissectors/asn1/atn-cpdlc/packet-atn-cpdlc-template.c new file mode 100644 index 00000000..0e8bca4d --- /dev/null +++ b/epan/dissectors/asn1/atn-cpdlc/packet-atn-cpdlc-template.c @@ -0,0 +1,352 @@ +/* packet-atn-cpdlc-template.c + * By Mathias Guettler <guettler@web.de> + * Copyright 2013 + * + * Routines for ATN Cpdlcc protocol packet disassembly + + * details see: + * http://en.wikipedia.org/wiki/CPDLC + * http://members.optusnet.com.au/~cjr/introduction.htm + + * standards: + * http://legacy.icao.int/anb/panels/acp/repository.cfm + + * note: + * We are dealing with ATN/CPDLC aka ICAO Doc 9705 Ed2 here + * (CPDLC may also be transmitted via ACARS/AOA aka "FANS-1/A "). + + * + * Wireshark - Network traffic analyzer + * By Gerald Combs <gerald@wireshark.org> + * Copyright 1998 Gerald Combs + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + +/* + developper comments: + Which CPDLC messages are supported ? + Protected Mode CPDLC (AeQualifier 22) and Plain Old CPDLC (AeQualifier 2) + The dissector has been tested with ICAO doc9705 Edition2 compliant traffic. +*/ + +#include "config.h" + +#include <epan/packet.h> +#include <epan/exceptions.h> +#include <epan/conversation.h> +#include "packet-ber.h" +#include "packet-per.h" +#include "packet-atn-ulcs.h" + +#define ATN_CPDLC_PROTO "ICAO Doc9705 CPDLC" + +void proto_register_atn_cpdlc(void); +void proto_reg_handoff_atn_cpdlc(void); + +static const char *object_identifier_id; + +/* IA5 charset (7-bit) for PER IA5 decoding */ +static const gchar ia5alpha[] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, \ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, \ + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, \ + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, \ + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, \ + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, \ + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, \ + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, \ + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, '\0' +}; + +/* forward declarations */ +static int dissect_GroundPDUs_PDU( + tvbuff_t *tvb _U_, + packet_info *pinfo _U_, + proto_tree *tree _U_, + void *data _U_); +static int dissect_AircraftPDUs_PDU( + tvbuff_t *tvb _U_, + packet_info *pinfo _U_, + proto_tree *tree _U_, + void *data _U_); +static int dissect_ProtectedGroundPDUs_PDU( + tvbuff_t *tvb _U_, + packet_info *pinfo _U_, + proto_tree *tree _U_, + void *data _U_); +static int dissect_ProtectedAircraftPDUs_PDU( + tvbuff_t *tvb _U_, + packet_info *pinfo _U_, + proto_tree *tree _U_, + void *data _U_); + +#include "packet-atn-cpdlc-hf.c" + +#include "packet-atn-cpdlc-ett.c" +static gint ett_atn_cpdlc = -1; + +#include "packet-atn-cpdlc-fn.c" + +/* Wireshark ID of CPDLC protocol */ +static int proto_atn_cpdlc = -1; + + +static int +dissect_atn_cpdlc( + tvbuff_t *tvb, + packet_info *pinfo, + proto_tree *tree, + void *data _U_) +{ + /* note: */ + /* there are two co-existing applications of CPDLC: */ + /* "plain old" (ae-qualifier 2) and */ + /* "protected mode" (ae-qualifier 22) CPDLC. */ + /* "protected mode" was introduced to cope with a */ + /* safety issue in which a message would sent to the wrong aircraft. */ + + /* note:*/ + /* The protection is an additional checksum and covers the message content, */ + /* the 24-bit address of the aircraft, the current flight id and */ + /* the current ground facility so that an aircraft would be able to reject */ + /* messages which are unexpected (i.e. messages to another flight or */ + /* messages from the wrong center). */ + + /*note:*/ + /* although "plain old" CPDLC is more or less deprecated */ + /* many aircraft cannot perform */ + /* "protected mode" for this largely depends on */ + /* upgraded avionics packages */ + + /*note:*/ + /* The use of CPDLC is *optional* as the pilot */ + /* may always use a voice radio channel to talk to the controller.*/ + + proto_tree *atn_cpdlc_tree = NULL; + atn_conversation_t *atn_cv = NULL; + + /* note: */ + /* we need the ae qualifier stored within the conversation */ + /* to decode "plain old cpdlc" or */ + /* "protected mode cpdlc correctly " */ + + /* DT: dstref present, srcref is always zero */ + if((pinfo->clnp_dstref) && (!pinfo->clnp_srcref)){ + atn_cv = find_atn_conversation( + &pinfo->dst, + pinfo->clnp_dstref, + &pinfo->src ); + } + /* CR: srcref present, dstref is always zero */ + if((!pinfo->clnp_dstref) && (pinfo->clnp_srcref)){ + atn_cv = find_atn_conversation( + &pinfo->src, + pinfo->clnp_srcref, + &pinfo->dst ); + } + /* CC: srcref and dstref present, always use src/srcref & dst */ + if((pinfo->clnp_dstref) && (pinfo->clnp_srcref)){ + atn_cv = find_atn_conversation( + &pinfo->src, + pinfo->clnp_srcref, + &pinfo->dst ); + } + + if(!atn_cv){ /* atn conversation not found */ + return 0; } + + atn_cpdlc_tree = proto_tree_add_subtree( + tree, tvb, 0, -1, ett_atn_cpdlc, NULL, + ATN_CPDLC_PROTO ); + + switch(atn_cv->ae_qualifier){ + case pmcpdlc: + if( check_heur_msg_type(pinfo) == um ) { + /* uplink PDU's = Ground PDU's */ + dissect_ProtectedGroundPDUs_PDU( + tvb, + pinfo, + atn_cpdlc_tree, NULL); + }else { /* downlink PDU's = Aircraft PDU's */ + dissect_ProtectedAircraftPDUs_PDU( + tvb, + pinfo, + atn_cpdlc_tree, NULL); + } + break; + case cpdlc: + if( check_heur_msg_type(pinfo) == um ) { + /* uplink PDU's = Ground PDU's */ + dissect_GroundPDUs_PDU( + tvb, + pinfo, + atn_cpdlc_tree, NULL); + }else { /* downlink PDU's = Aircraft PDU's */ + dissect_AircraftPDUs_PDU( + tvb, + pinfo, + atn_cpdlc_tree, NULL); + } + break; + default: + break; + } + return tvb_reported_length_remaining(tvb, 0); +} + +static gboolean +dissect_atn_cpdlc_heur( + tvbuff_t *tvb, + packet_info *pinfo, + proto_tree *tree, + void *data _U_) +{ + atn_conversation_t *volatile atn_cv = NULL; + volatile gboolean is_atn_cpdlc = FALSE; + volatile gboolean is_pm = FALSE; + int type; + + type = check_heur_msg_type(pinfo); + + switch(type){ + case um: + TRY { + dissect_ProtectedGroundPDUs_PDU(tvb, pinfo, NULL, NULL); + is_atn_cpdlc = TRUE; + is_pm = TRUE;} + CATCH_ALL{ + is_atn_cpdlc = FALSE; + is_pm = FALSE;} + ENDTRY; + if (is_atn_cpdlc) { + break; + } + TRY { + dissect_GroundPDUs_PDU(tvb, pinfo, NULL, NULL); + is_pm = FALSE; + is_atn_cpdlc = TRUE;} + CATCH_ALL{ + is_atn_cpdlc = FALSE; + is_pm = FALSE;} + ENDTRY; + break; + case dm: + TRY { + dissect_ProtectedAircraftPDUs_PDU(tvb, pinfo, NULL, NULL); + is_atn_cpdlc = TRUE; + is_pm = TRUE;} + CATCH_ALL { + is_atn_cpdlc = FALSE; + is_pm = FALSE; } + ENDTRY; + if (is_atn_cpdlc) { + break; + } + TRY{ + dissect_AircraftPDUs_PDU(tvb, pinfo, NULL, NULL); + is_atn_cpdlc = TRUE; + is_pm = FALSE;} + CATCH_ALL{ + is_atn_cpdlc = FALSE; + is_pm = FALSE;} + ENDTRY; + break; + default: + break; + } + + if(is_atn_cpdlc){ + /* note: */ + /* all subsequent PDU's belonging to this conversation */ + /* are considered CPDLC */ + /* if the first CPDLC PDU has been decoded successfully */ + /* (This is done in "atn-ulcs" by using "call_dissector_with_data()") */ + + /* DT: dstref present, srcref is always zero */ + if((pinfo->clnp_dstref) && (!pinfo->clnp_srcref)){ + atn_cv = find_atn_conversation(&pinfo->dst, + pinfo->clnp_dstref, + &pinfo->src ); + } + /* CR: srcref present, dstref is always zero */ + if((!pinfo->clnp_dstref) && (pinfo->clnp_srcref)){ + atn_cv = find_atn_conversation(&pinfo->src, + pinfo->clnp_srcref, + &pinfo->dst ); + } + /* CC: srcref and dstref present, always use src/srcref & dst */ + if((pinfo->clnp_dstref) && (pinfo->clnp_srcref)){ + atn_cv = find_atn_conversation(&pinfo->src, + pinfo->clnp_srcref, + &pinfo->dst ); + } + + if(atn_cv){ /* atn conversation found */ + if(is_pm == TRUE) { + atn_cv->ae_qualifier = pmcpdlc; } + else { + atn_cv->ae_qualifier = cpdlc; } + dissect_atn_cpdlc(tvb, pinfo, tree, NULL); + } + }else { /* there should *always* be an atn conversation */ + is_atn_cpdlc = FALSE; + } + + return is_atn_cpdlc; +} + + + +void proto_register_atn_cpdlc (void) +{ + static hf_register_info hf_atn_cpdlc[] = { + #include "packet-atn-cpdlc-hfarr.c" + }; + + static gint *ett[] = { + #include "packet-atn-cpdlc-ettarr.c" + &ett_atn_cpdlc + }; + + /* register CPDLC */ + proto_atn_cpdlc = proto_register_protocol(ATN_CPDLC_PROTO, "ATN-CPDLC", "atn-cpdlc"); + + proto_register_field_array( + proto_atn_cpdlc, + hf_atn_cpdlc, + array_length(hf_atn_cpdlc)); + + proto_register_subtree_array( + ett, + array_length(ett)); + + register_dissector( + "atn-cpdlc", + dissect_atn_cpdlc, + proto_atn_cpdlc); +} + +void proto_reg_handoff_atn_cpdlc(void) +{ + /* add session dissector to atn dissector list dissector list*/ + heur_dissector_add( + "atn-ulcs", + dissect_atn_cpdlc_heur, + "ATN-CPDLC over ATN-ULCS", + "atn-cpdlc-ulcs", + proto_atn_cpdlc, HEURISTIC_ENABLE); +} + +/* + * Editor modelines - https://www.wireshark.org/tools/modelines.html + * + * Local variables: + * c-basic-offset: 4 + * tab-width: 8 + * indent-tabs-mode: nil + * End: + * + * vi: set shiftwidth=4 tabstop=8 expandtab: + * :indentSize=4:tabSize=8:noTabs=true: + */ |