diff options
| -rw-r--r-- | epan/dissectors/packet-dis-enums.c | 322 | ||||
| -rw-r--r-- | epan/dissectors/packet-dis-enums.h | 164 | ||||
| -rw-r--r-- | epan/dissectors/packet-dis-fields.c | 140 | ||||
| -rw-r--r-- | epan/dissectors/packet-dis-fields.h | 131 | ||||
| -rw-r--r-- | epan/dissectors/packet-dis-pdus.c | 405 | ||||
| -rw-r--r-- | epan/dissectors/packet-dis-pdus.h | 5 | ||||
| -rw-r--r-- | epan/dissectors/packet-dis.c | 427 |
7 files changed, 1543 insertions, 51 deletions
diff --git a/epan/dissectors/packet-dis-enums.c b/epan/dissectors/packet-dis-enums.c index 4a4b0441c2..e0372c0eab 100644 --- a/epan/dissectors/packet-dis-enums.c +++ b/epan/dissectors/packet-dis-enums.c @@ -267,6 +267,328 @@ const value_string DIS_PDU_Category_SpacePlatform_Strings[] = { 0, NULL } }; +const value_string DIS_PDU_Encoding_Class_Strings[] = +{ + { DIS_ENCODING_CLASS_ENCODED_AUDIO, "Encoded Audio" }, + { DIS_ENCODING_CLASS_RAW_BINARY_DATA, "Raw Binary Data" }, + { DIS_ENCODING_CLASS_APPL_SPEC_DATA, "Application-Specific Data" }, + { DIS_ENCODING_CLASS_DB_INDEX, "Database index" }, + { 0, NULL } +}; + +const value_string DIS_PDU_Encoding_Type_Strings[] = +{ + { DIS_ENCODING_TYPE_OTHER, "Other" }, + { DIS_ENCODING_TYPE_MU_LAW, "8-bit mu-law" }, + { DIS_ENCODING_TYPE_CVSD, "CVSD per MIL-STD-188-113" }, + { DIS_ENCODING_TYPE_ADPCM_G721, "ADPCM per CCITT G.721" }, + { DIS_ENCODING_TYPE_16BIT_LINEAR_PCM, "16-bit linear PCM" }, + { DIS_ENCODING_TYPE_8BIT_LINEAR_PCM, "8-bit linear PCM" }, + { DIS_ENCODING_TYPE_VECTOR_QUANTIZATION, "VQ (Vector Quantization" }, + { 0, NULL } +}; + +const value_string DIS_PDU_TDL_Type_Strings[] = +{ + {DIS_TDL_TYPE_OTHER, "Other" }, + {DIS_TDL_TYPE_PADIL, "PADIL" }, + {DIS_TDL_TYPE_NATO_LINK1, "NATO Link-1" }, + {DIS_TDL_TYPE_ATDL1, "ATDL-1" }, + {DIS_TDL_TYPE_LINK_11B, "Link 11B (TADIL B)" }, + {DIS_TDL_TYPE_SADL, "Situational Awareness Data Link (SADL)" }, + {DIS_TDL_TYPE_JTIDS_TADIL_J, "Link 16 Legacy Format (JTIDS/TADIL-J) " }, + {DIS_TDL_TYPE_JTIDS_FDL_TADIL_J, "Link 16 Legacy Format (JTIDS/FDL/TADIL-J)" }, + {DIS_TDL_TYPE_LINK_11A, "Link 11A (TADIL A)" }, + {DIS_TDL_TYPE_IJMS, "IJMS" }, + {DIS_TDL_TYPE_LINK_4A, "Link 4A (TADIL C)" }, + {DIS_TDL_TYPE_LINK_4C, "Link 4C" }, + {DIS_TDL_TYPE_TIBS, "TIBS" }, + {DIS_TDL_TYPE_ATL, "ATL" }, + {DIS_TDL_TYPE_CONSTANT_SRC, "Constant Source" }, + {DIS_TDL_TYPE_ABBRV_CC, "Abbreviated Command and Control" }, + {DIS_TDL_TYPE_MILSTAR, "MILSTAR" }, + {DIS_TDL_TYPE_ATHS, "ATHS" }, + {DIS_TDL_TYPE_OTHGOLD, "OTHGOLD" }, + {DIS_TDL_TYPE_TACELINT, "TACELINT" }, + {DIS_TDL_TYPE_AWW13, "Weapons Data Link (AWW-13)" }, + {DIS_TDL_TYPE_ABBRV_CC_2, "Abbreviated Command and Control" }, + {DIS_TDL_TYPE_EPLRS, "Enhanced Position Location Reporting System (EPLRS)" }, + {DIS_TDL_TYPE_PLRS, "Position Location Reporting System (PLRS)" }, + {DIS_TDL_TYPE_SINCGARS, "SINCGARS" }, + {DIS_TDL_TYPE_HAVE_QUICK_I, "Have Quick I" }, + {DIS_TDL_TYPE_HAVE_QUICK_II, "Have Quick II" }, + {DIS_TDL_TYPE_HAVE_QUICK_IIA, "Have Quick IIA (Saturn)" }, + {DIS_TDL_TYPE_IFDL1, "Intra-Flight Data Link 1" }, + {DIS_TDL_TYPE_IFDL2, "Intra-Flight Data Link 2" }, + {DIS_TDL_TYPE_IDM, "Improved Data Modem (IDM)" }, + {DIS_TDL_TYPE_AFAPD, "Air Force Application Program Development (AFAPD)" }, + {DIS_TDL_TYPE_CEC, "Cooperative Engagement Capability (CEC)" }, + {DIS_TDL_TYPE_FAAD_FDL, "Forward Area Air Defense (FAAD) Data Link (FDL)" }, + {DIS_TDL_TYPE_GBDL, "Ground Based Data Link (GBDL)" }, + {DIS_TDL_TYPE_IVIS, "Intra Vehicular Info System (IVIS)" }, + {DIS_TDL_TYPE_MTS, "Marine Tactical System (MTS)" }, + {DIS_TDL_TYPE_TACFIRE, "Tactical Fire Direction System (TACFIRE)" }, + {DIS_TDL_TYPE_IBS, "Integrated Broadcast Service (IBS)" }, + {DIS_TDL_TYPE_ABIT, "Airborne Information Transfer (ABIT)" }, + {DIS_TDL_TYPE_ATARS, "Advanced Tactical Airborne Reconnaissance System (ATARS) Data Link" }, + {DIS_TDL_TYPE_BGPHES, "Battle Group Passive Horizon Extension System (BGPHES) Data Link" }, + {DIS_TDL_TYPE_CHBDL, "Common High Bandwidth Data Link (CHBDL)" }, + {DIS_TDL_TYPE_GUARDRAIL_IDL, "Guardrail Interoperable Data Link (IDL)" }, + {DIS_TDL_TYPE_GUARDRAIL_CSS1, "Guardrail Common Sensor System One (CSS1) Data Link" }, + {DIS_TDL_TYPE_GUARDRAIL_CSS2, "Guardrail Common Sensor System Two (CSS2) Data Link" }, + {DIS_TDL_TYPE_GUARDRAIL_CSS2_MRDL, "Guardrail CSS2 Multi-Role Data Link (MRDL)" }, + {DIS_TDL_TYPE_GUARDRAIL_CSS2_DASR, "Guardrail CSS2 Direct Air to Satellite Relay (DASR) Data Link" }, + {DIS_TDL_TYPE_LOS_TETHER, "Line of Sight (LOS) Data Link Implementation (LOS tether)" }, + {DIS_TDL_TYPE_LWCDL, "Lightweight CDL (LWCDL)" }, + {DIS_TDL_TYPE_L_52M, "L-52M (SR-71)" }, + {DIS_TDL_TYPE_RR_ROWL_DL, "Rivet Reach/Rivet Owl Data Link" }, + {DIS_TDL_TYPE_SENIOR_SPAN, "Senior Span" }, + {DIS_TDL_TYPE_SENIOR_SPUR, "Senior Spur" }, + {DIS_TDL_TYPE_SENIOR_STRETCH, "Senior Stretch." }, + {DIS_TDL_TYPE_SENIOR_YEAR_IDL, "Senior Year Interoperable Data Link (IDL)" }, + {DIS_TDL_TYPE_SPACE_CDL, "Space CDL" }, + {DIS_TDL_TYPE_TR_1_MIST_ADL, "TR-1 mode MIST Airborne Data Link" }, + {DIS_TDL_TYPE_KU_BAND_SATCOM, "Ku-band SATCOM Data Link Implementation (UAV)" }, + {DIS_TDL_TYPE_MECDL, "Mission Equipment Control Data link (MECDL)" }, + {DIS_TDL_TYPE_RADAR_DATA_TSDL, "Radar Data Transmitting Set Data Link" }, + {DIS_TDL_TYPE_SCDL, "Surveillance and Control Data Link (SCDL)" }, + {DIS_TDL_TYPE_TACTICAL_UAV_VIDEO, "Tactical UAV Video" }, + {DIS_TDL_TYPE_UHF_SATCOM, "UHF SATCOM Data Link Implementation (UAV)" }, + {DIS_TDL_TYPE_TCDL, "Tactical Common Data Link (TCDL)" }, + {DIS_TDL_TYPE_LLAPI, "Low Level Air Picture Interface (LLAPI)" }, + {DIS_TDL_TYPE_WEAPONS_DL, "Weapons Data Link (AGM-130)" }, + {DIS_TDL_TYPE_GC3, "GC3" }, + {DIS_TDL_TYPE_LINK16_STD, "Link 16 Standardized Format (JTIDS/MIDS/TADIL J)" }, + {DIS_TDL_TYPE_LINK16_EDR, "Link 16 Enhanced Data Rate (EDR JTIDS/MIDS/TADIL-J)" }, + {DIS_TDL_TYPE_JTIDS_NET_DATA_LOAD, "JTIDS/MIDS Net Data Load (TIMS/TOMS)" }, + {DIS_TDL_TYPE_LINK22, "Link 22" }, + {DIS_TDL_TYPE_AFIWC_IADS, "AFIWC IADS Communications Links" }, + { 0, NULL } +}; + +const value_string DIS_PDU_RadioCategory_Strings[] = +{ + {0, "Other" }, + {1, "Voice Transmission/Reception" }, + {2, "Data Link Transmission/Reception" }, + {3, "Voice and Data Link Transmission/Reception" }, + {4, "Instrumented Landing System (ILS) Glideslope Transmitter" }, + {5, "Instrumented Landing System (ILS) Localizer Transmitter" }, + {6, "Instrumented Landing System (ILS) Outer Marker Beacon" }, + {7, "Instrumented Landing System (ILS) Middle Marker Beacon" }, + {8, "Instrumented Landing System (ILS) Inner Marker Beacon" }, + {9, "Instrumented Landing System (ILS) Receiver (Platform Radio)" }, + {10, "Tactical Air Navigation (TACAN) Transmitter (Ground Fixed Equipment)" }, + {11, "Tactical Air Navigation (TACAN) Receiver (Moving Platform Equipment)" }, + {12, "Tactical Air Navigation (TACAN) Transmitter/Receiver (Moving Platform Equipment)" }, + {13, "Variable Omni-Ranging (VOR) Transmitter (Ground Fixed Equipment)" }, + {14, "Variable Omni-Ranging (VOR) with Distance Measuring Equipment (DME) Transmitter (Ground Fixed Equipment)" }, + {15, "Combined VOR/ILS Receiver (Moving Platform Equipment)" }, + {16, "Combined VOR & TACAN (VORTAC) Transmitter" }, + {17, "Non-Directional Beacon (NDB) Transmitter" }, + {18, "Non-Directional Beacon (NDB) Receiver" }, + {19, "Non-Directional Beacon (NDB) with Distance Measuring Equipment (DME) Transmitter" }, + {20, "Distance Measuring Equipment (DME)" }, + {0, NULL } +}; + +const value_string DIS_PDU_NomenclatureVersion_Strings[] = +{ + {0, "Other" }, + {1, "Joint Electronics Type Designation System (JETDS) Nomenclature (AN/ per Mil-STD-196)" }, + {2, "Manufacturer Designation" }, + {3, "National Designation" }, + {0, NULL } +}; + +const value_string DIS_PDU_Nomenclature_Strings[] = +{ + {0, "Other" }, + {1, "AN/ARN-118" }, + {2, "AN/ARN-139" }, + {3, "Generic Ground Fixed Transmitter" }, + {4, "Generic Ground Mobile Transmitter" }, + {0, NULL } +}; + +const value_string DIS_PDU_RadioTransmitState_Strings[] = +{ + {0, "Off" }, + {1, "On but not transmitting" }, + {2, "On and transmitting" }, + {0, NULL } +}; + +const value_string DIS_PDU_RadioInputSource_Strings[] = +{ + {0, "Other" }, + {1, "Pilot" }, + {2, "Copilot" }, + {3, "First Officer" }, + {4, "Driver" }, + {5, "Loader" }, + {6, "Gunner" }, + {7, "Commander" }, + {8, "Digital Data Device" }, + {9, "Intercom" }, + {0, NULL } +}; + +const value_string DIS_PDU_AntennaPatternType_Strings[] = +{ + {0, "Omni-directional" }, + {1, "Beam" }, + {2, "Spherical harmonic" }, + {0, NULL } +}; + +const value_string DIS_PDU_MajorModulation_Strings[] = +{ + {DIS_MAJOR_MOD_OTHER, "Other" }, + {DIS_MAJOR_MOD_AMPLITUDE, "Amplitude" }, + {DIS_MAJOR_MOD_AMPLITUDE_AND_ANGLE, "Amplitude and Angle" }, + {DIS_MAJOR_MOD_ANGLE, "Angle" }, + {DIS_MAJOR_MOD_COMBINATION, "Combination" }, + {DIS_MAJOR_MOD_PULSE, "Pulse" }, + {DIS_MAJOR_MOD_UNMODULATED, "Unmodulated" }, + {DIS_MAJOR_MOD_CPSM, "Carrier Phase Shift Modulation (CPSM)" }, + {0, NULL } +}; + +const value_string DIS_PDU_DetailModulationAmplitude_Strings[] = +{ + {0, "Other" }, + {1, "AFSK (Audio Frequency Shift Keying)" }, + {2, "AM (Amplitude Modulation)" }, + {3, "CW (Continuous Wave Modulation)" }, + {4, "DSB (Double Sideband)" }, + {5, "ISB (Independent Sideband)" }, + {6, "LSB (Single Band Suppressed Carrier, Lower Sideband Mode)" }, + {7, "SSB-Full (Single Sideband Full Carrier)" }, + {8, "SSB-Reduc (Single Band Reduced Carrier)" }, + {9, "USB (Single Band Suppressed Carrier, Upper Sideband Mode)" }, + {10, "VSB (Vestigial Sideband)" }, + {0, NULL } +}; + +const value_string DIS_PDU_DetailModulationAmpAndAngle_Strings[] = +{ + {0, "Other" }, + {1, "Amplitude and Angle" }, + {0, NULL } +}; + +const value_string DIS_PDU_DetailModulationAngle_Strings[] = +{ + {0, "Other" }, + {1, "FM (Frequency Modulation)" }, + {2, "FSK (Frequency Shift Keying)" }, + {3, "PM (Phase Modulation)" }, + {0, NULL } +}; + +const value_string DIS_PDU_DetailModulationCombination_Strings[] = +{ + {0, "Other" }, + {1, "Amplitude-Angle-Pulse" }, + {0, NULL } +}; + +const value_string DIS_PDU_DetailModulationPulse_Strings[] = +{ + {0, "Other" }, + {1, "Pulse" }, + {2, "X Band TACAN Pulse" }, + {3, "Y Band TACAN Pulse" }, + {0, NULL } +}; + +const value_string DIS_PDU_DetailModulationUnmodulated_Strings[] = +{ + {0, "Other" }, + {1, "Continuous Wave emission of an unmodulated carrier" }, + {0, NULL } +}; + +const value_string DIS_PDU_DetailModulationCPSM_Strings[] = +{ + {0, "Other" }, + {0, NULL } +}; + +const value_string DIS_PDU_ModParamMsgStart_Strings[] = +{ + {0, "Not start of message" }, + {1, "Start of Message" }, + {0, NULL } +}; + +const value_string DIS_PDU_ModParamClrChannel_Strings[] = +{ + {0, "Not clear channel" }, + {1, "Clear channel" }, + {0, NULL } +}; + +const value_string DIS_PDU_TSAllocationFidelity_Strings[] = +{ + {0, "Time Slot Allocation Fidelity Level 0" }, + {1, "Time Slot Allocation Fidelity Level 1" }, + {2, "Time Slot Allocation Fidelity Level 2" }, + {3, "Time Slot Allocation Fidelity Level 3" }, + {4, "Time Slot Allocation Fidelity Level 4" }, + {0, NULL } +}; + +const value_string DIS_PDU_TerminalPrimaryMode_Strings[] = +{ + {0, "NTR" }, + {1, "JTIDS Unit Participant" }, + {0, NULL } +}; + +const value_string DIS_PDU_TerminalSecondaryMode_Strings[] = +{ + {0, "None" }, + {1, "Net Position Reference" }, + {2, "Primary Navigation Controller" }, + {3, "Secondary Navigation Controller" }, + {0, NULL } +}; + +const value_string DIS_PDU_ModParamSyncState_Strings[] = +{ + {0, "Undefined" }, + {1, "Coarse Synchronization" }, + {1, "Fine Synchronization" }, + {0, NULL } +}; + + +const value_string DIS_PDU_SystemModulation_Strings[] = +{ + {0, "Other" }, + {1, "Generic" }, + {2, "HQ" }, + {3, "HQII" }, + {4, "HQIIA" }, + {5, "SINCGARS" }, + {6, "CCTT SINCGARS" }, + {7, "EPLRS (Enhanced Position Location Reporting System)" }, + {8, "JTIDS/MIDS" }, + {0, NULL } +}; + +const value_string DIS_PDU_CryptoSystem_Strings[] = +{ + {0, "Other" }, + {1, "KY-28" }, + {2, "VINSON (KY-57, KY-58, SINCGARS ICOM)" }, + {3, "Narrow Spectrum Secure Voice (NSVE)" }, + {4, "Wide Spectrum Secure Voice (WSVE)" }, + {0, NULL } +}; + const value_string DIS_PDU_AcknowledgeFlag_Strings[] = { { DIS_ACKNOWLEDGE_FLAG_CREATE_ENTITY, "Create Entity" }, diff --git a/epan/dissectors/packet-dis-enums.h b/epan/dissectors/packet-dis-enums.h index 4ccded648f..f0def50f4e 100644 --- a/epan/dissectors/packet-dis-enums.h +++ b/epan/dissectors/packet-dis-enums.h @@ -29,6 +29,29 @@ #include <epan/value_string.h> +extern const value_string DIS_PDU_RadioCategory_Strings[]; +extern const value_string DIS_PDU_NomenclatureVersion_Strings[]; +extern const value_string DIS_PDU_Nomenclature_Strings[]; +extern const value_string DIS_PDU_RadioTransmitState_Strings[]; +extern const value_string DIS_PDU_RadioInputSource_Strings[]; +extern const value_string DIS_PDU_MajorModulation_Strings[]; +extern const value_string DIS_PDU_DetailModulationAmplitude_Strings[]; +extern const value_string DIS_PDU_DetailModulationAmpAndAngle_Strings[]; +extern const value_string DIS_PDU_DetailModulationAngle_Strings[]; +extern const value_string DIS_PDU_DetailModulationCombination_Strings[]; +extern const value_string DIS_PDU_DetailModulationPulse_Strings[]; +extern const value_string DIS_PDU_DetailModulationUnmodulated_Strings[]; +extern const value_string DIS_PDU_DetailModulationCPSM_Strings[]; +extern const value_string DIS_PDU_SystemModulation_Strings[]; +extern const value_string DIS_PDU_CryptoSystem_Strings[]; +extern const value_string DIS_PDU_ModParamMsgStart_Strings[]; +extern const value_string DIS_PDU_ModParamClrChannel_Strings[]; +extern const value_string DIS_PDU_TSAllocationFidelity_Strings[]; +extern const value_string DIS_PDU_TerminalPrimaryMode_Strings[]; +extern const value_string DIS_PDU_TerminalSecondaryMode_Strings[]; +extern const value_string DIS_PDU_ModParamSyncState_Strings[]; + + typedef enum { DIS_VERSION_OTHER = 0, @@ -277,6 +300,147 @@ extern const value_string DIS_PDU_Category_SpacePlatform_Strings[]; typedef enum { + DIS_ENCODING_CLASS_ENCODED_AUDIO = 0, + DIS_ENCODING_CLASS_RAW_BINARY_DATA = 1, + DIS_ENCODING_CLASS_APPL_SPEC_DATA = 2, + DIS_ENCODING_CLASS_DB_INDEX = 3 +} DIS_PDU_Encoding_Class; + +extern const value_string DIS_PDU_Encoding_Class_Strings[]; + +typedef enum +{ + DIS_ENCODING_TYPE_OTHER = 0, + DIS_ENCODING_TYPE_MU_LAW = 1, + DIS_ENCODING_TYPE_CVSD = 2, + DIS_ENCODING_TYPE_ADPCM_G721 = 3, + DIS_ENCODING_TYPE_16BIT_LINEAR_PCM = 4, + DIS_ENCODING_TYPE_8BIT_LINEAR_PCM = 5, + DIS_ENCODING_TYPE_VECTOR_QUANTIZATION = 6 +} DIS_PDU_Encoding_Type; + +extern const value_string DIS_PDU_Encoding_Type_Strings[]; + +typedef enum +{ + DIS_TDL_TYPE_OTHER = 0, + DIS_TDL_TYPE_PADIL = 1, + DIS_TDL_TYPE_NATO_LINK1 = 2, + DIS_TDL_TYPE_ATDL1 = 3, + DIS_TDL_TYPE_LINK_11B = 4, + DIS_TDL_TYPE_SADL = 5, + DIS_TDL_TYPE_JTIDS_TADIL_J = 6, + DIS_TDL_TYPE_JTIDS_FDL_TADIL_J = 7, + DIS_TDL_TYPE_LINK_11A = 8, + DIS_TDL_TYPE_IJMS = 9, + DIS_TDL_TYPE_LINK_4A = 10, + DIS_TDL_TYPE_LINK_4C = 11, + DIS_TDL_TYPE_TIBS = 12, + DIS_TDL_TYPE_ATL = 13, + DIS_TDL_TYPE_CONSTANT_SRC = 14, + DIS_TDL_TYPE_ABBRV_CC = 15, + DIS_TDL_TYPE_MILSTAR = 16, + DIS_TDL_TYPE_ATHS = 17, + DIS_TDL_TYPE_OTHGOLD = 18, + DIS_TDL_TYPE_TACELINT = 19, + DIS_TDL_TYPE_AWW13 = 20, + DIS_TDL_TYPE_ABBRV_CC_2 = 21, + DIS_TDL_TYPE_EPLRS = 22, + DIS_TDL_TYPE_PLRS = 23, + DIS_TDL_TYPE_SINCGARS = 24, + DIS_TDL_TYPE_HAVE_QUICK_I = 25, + DIS_TDL_TYPE_HAVE_QUICK_II = 26, + DIS_TDL_TYPE_HAVE_QUICK_IIA = 27, + DIS_TDL_TYPE_IFDL1 = 28, + DIS_TDL_TYPE_IFDL2 = 29, + DIS_TDL_TYPE_IDM = 30, + DIS_TDL_TYPE_AFAPD = 31, + DIS_TDL_TYPE_CEC = 32, + DIS_TDL_TYPE_FAAD_FDL = 33, + DIS_TDL_TYPE_GBDL = 34, + DIS_TDL_TYPE_IVIS = 35, + DIS_TDL_TYPE_MTS = 36, + DIS_TDL_TYPE_TACFIRE = 37, + DIS_TDL_TYPE_IBS = 38, + DIS_TDL_TYPE_ABIT = 39, + DIS_TDL_TYPE_ATARS = 40, + DIS_TDL_TYPE_BGPHES = 41, + DIS_TDL_TYPE_CHBDL = 42, + DIS_TDL_TYPE_GUARDRAIL_IDL = 43, + DIS_TDL_TYPE_GUARDRAIL_CSS1 = 44, + DIS_TDL_TYPE_GUARDRAIL_CSS2 = 45, + DIS_TDL_TYPE_GUARDRAIL_CSS2_MRDL = 46, + DIS_TDL_TYPE_GUARDRAIL_CSS2_DASR = 47, + DIS_TDL_TYPE_LOS_TETHER = 48, + DIS_TDL_TYPE_LWCDL = 49, + DIS_TDL_TYPE_L_52M = 50, + DIS_TDL_TYPE_RR_ROWL_DL = 51, + DIS_TDL_TYPE_SENIOR_SPAN = 52, + DIS_TDL_TYPE_SENIOR_SPUR = 53, + DIS_TDL_TYPE_SENIOR_STRETCH = 54, + DIS_TDL_TYPE_SENIOR_YEAR_IDL = 55, + DIS_TDL_TYPE_SPACE_CDL = 56, + DIS_TDL_TYPE_TR_1_MIST_ADL = 57, + DIS_TDL_TYPE_KU_BAND_SATCOM = 58, + DIS_TDL_TYPE_MECDL = 59, + DIS_TDL_TYPE_RADAR_DATA_TSDL = 60, + DIS_TDL_TYPE_SCDL = 61, + DIS_TDL_TYPE_TACTICAL_UAV_VIDEO = 62, + DIS_TDL_TYPE_UHF_SATCOM = 63, + DIS_TDL_TYPE_TCDL = 64, + DIS_TDL_TYPE_LLAPI = 65, + DIS_TDL_TYPE_WEAPONS_DL = 66, + DIS_TDL_TYPE_GC3 = 99, + DIS_TDL_TYPE_LINK16_STD = 100, + DIS_TDL_TYPE_LINK16_EDR = 101, + DIS_TDL_TYPE_JTIDS_NET_DATA_LOAD = 102, + DIS_TDL_TYPE_LINK22 = 103, + DIS_TDL_TYPE_AFIWC_IADS = 104 +} DIS_PDU_TDL_Type; + +extern const value_string DIS_PDU_TDL_Type_Strings[]; + +typedef enum +{ + DIS_PATTERN_OMNI_DIRECTIONAL = 0, + DIS_PATTERN_BEAM = 1, + DIS_PATTERN_SPHERICAL_HARMONIC = 2 +} DIS_PDU_AntennaPattern_Type; + +extern const value_string DIS_PDU_AntennaPatternType_Strings[]; + +typedef enum +{ + DIS_SYSTEM_MOD_OTHER = 0, + DIS_SYSTEM_MOD_GENERIC = 1, + DIS_SYSTEM_MOD_HQ = 2, + DIS_SYSTEM_MOD_HQII = 3, + DIS_SYSTEM_MOD_HQIIA = 4, + DIS_SYSTEM_MOD_SINCGARS = 5, + DIS_SYSTEM_MOD_CCTT_SINCGARS = 6, + DIS_SYSTEM_MOD_EPLRS = 7, + DIS_SYSTEM_MOD_JTIDS_MIDS = 8 +} DIS_PDU_SYSTEM_MODULATION_TYPE; + +extern const value_string DIS_PDU_SystemModulation_Strings[]; + +typedef enum +{ + DIS_MAJOR_MOD_OTHER = 0, + DIS_MAJOR_MOD_AMPLITUDE = 1, + DIS_MAJOR_MOD_AMPLITUDE_AND_ANGLE = 2, + DIS_MAJOR_MOD_ANGLE = 3, + DIS_MAJOR_MOD_COMBINATION = 4, + DIS_MAJOR_MOD_PULSE = 5, + DIS_MAJOR_MOD_UNMODULATED = 6, + DIS_MAJOR_MOD_CPSM = 7 +} DIS_PDU_MAJOR_MODULATION_TYPE; + +extern const value_string DIS_PDU_MajorModulation_Strings[]; + + +typedef enum +{ DIS_ACKNOWLEDGE_FLAG_CREATE_ENTITY = 1, DIS_ACKNOWLEDGE_FLAG_REMOVE_ENTITY = 2, DIS_ACKNOWLEDGE_FLAG_START_RESUME = 3, diff --git a/epan/dissectors/packet-dis-fields.c b/epan/dissectors/packet-dis-fields.c index eb8f99dc44..c6e6020121 100644 --- a/epan/dissectors/packet-dis-fields.c +++ b/epan/dissectors/packet-dis-fields.c @@ -34,29 +34,39 @@ #include "packet-dis-enums.h" #include "packet-dis-pdus.h" -guint32 protocolVersion; +/* all of these variables are assigned by reference */ +/* *(parserNode.outputVar) = value */ +guint32 disProtocolVersion; guint32 pduType; guint32 protocolFamily; guint32 persistentObjectPduType; guint32 entityKind; guint32 entityDomain; +guint32 radioID; +guint32 disRadioTransmitState; +guint32 encodingScheme; +guint32 numSamples; guint32 numFixed; guint32 numVariable; guint32 variableDatumLength; guint32 variableParameterType; guint32 variableRecordLength; guint32 variableRecordType; +guint32 majorModulation; +guint32 systemModulation; +guint32 modulationParamLength; +guint32 disAntennaPattern; /* Headers */ DIS_ParserNode DIS_FIELDS_PDU_HEADER[] = { - { DIS_FIELDTYPE_PROTOCOL_VERSION, "Protocol Version",0,0,0,&protocolVersion }, - { DIS_FIELDTYPE_UINT8, "Exercise ID",0,0,0,0 }, + { DIS_FIELDTYPE_PROTOCOL_VERSION, "Protocol Version",0,0,0,&disProtocolVersion }, + { DIS_FIELDTYPE_EXERCISE_ID, "Exercise ID",0,0,0,0 }, { DIS_FIELDTYPE_PDU_TYPE, "PDU Type",0,0,0,&pduType }, { DIS_FIELDTYPE_PROTOCOL_FAMILY, "Protocol Family",0,0,0,&protocolFamily }, { DIS_FIELDTYPE_TIMESTAMP, "Timestamp",0,0,0,0 }, - { DIS_FIELDTYPE_UINT16, "Length",0,0,0,0 }, + { DIS_FIELDTYPE_PDU_LENGTH, "Length",0,0,0,0 }, { DIS_FIELDTYPE_PAD16, "Padding",0,0,0,0 }, { DIS_FIELDTYPE_END, NULL,0,0,0,0 } }; @@ -74,6 +84,7 @@ DIS_ParserNode DIS_FIELDS_PERSISTENT_OBJECT_HEADER[] = /* Composite types */ + DIS_ParserNode DIS_FIELDS_BURST_DESCRIPTOR[] = { { DIS_FIELDTYPE_ENTITY_TYPE, "Munition",0,0,0,0 }, @@ -93,10 +104,10 @@ DIS_ParserNode DIS_FIELDS_CLOCK_TIME[] = DIS_ParserNode DIS_FIELDS_ENTITY_ID[] = { - { DIS_FIELDTYPE_UINT16, "Site",0,0,0,0 }, - { DIS_FIELDTYPE_UINT16, "Application",0,0,0,0 }, - { DIS_FIELDTYPE_UINT16, "Entity",0,0,0,0 }, - { DIS_FIELDTYPE_END, NULL,0,0,0,0 } + { DIS_FIELDTYPE_SITE, "Site",0,0,0,0 }, + { DIS_FIELDTYPE_APPLICATION, "Application",0,0,0,0 }, + { DIS_FIELDTYPE_ENTITY, "Entity",0,0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0,0 } }; DIS_ParserNode DIS_FIELDS_ENTITY_TYPE[] = @@ -111,6 +122,26 @@ DIS_ParserNode DIS_FIELDS_ENTITY_TYPE[] = { DIS_FIELDTYPE_END, NULL,0,0,0,0 } }; +DIS_ParserNode DIS_FIELDS_RADIO_ENTITY_TYPE[] = +{ + { DIS_FIELDTYPE_ENTITY_KIND, "Entity Kind",0,0,0,&entityKind }, + { DIS_FIELDTYPE_DOMAIN, "Domain",0,0,0,&entityDomain }, + { DIS_FIELDTYPE_COUNTRY, "Country",0,0,0,0 }, + { DIS_FIELDTYPE_RADIO_CATEGORY, "Radio Category",0,0,0,0 }, + { DIS_FIELDTYPE_NOMENCLATURE_VERSION, "Nomenclature Version",0,0,0,0 }, + { DIS_FIELDTYPE_NOMENCLATURE, "Nomenclature",0,0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0,0 } +}; + +DIS_ParserNode DIS_FIELDS_MODULATION_TYPE[] = +{ + { DIS_FIELDTYPE_SPREAD_SPECTRUM, "Spread Spectrum",0,0,0,0 }, + { DIS_FIELDTYPE_MODULATION_MAJOR, "Major",0,0,0,&majorModulation }, + { DIS_FIELDTYPE_MODULATION_DETAIL, "Detail",0,0,0,0 }, + { DIS_FIELDTYPE_MODULATION_SYSTEM, "System",0,0,0,&systemModulation }, + { DIS_FIELDTYPE_END, NULL,0,0,0,0 } +}; + DIS_ParserNode DIS_FIELDS_EVENT_ID[] = { { DIS_FIELDTYPE_UINT16, "Site",0,0,0,0 }, @@ -150,6 +181,30 @@ DIS_ParserNode DIS_FIELDS_VECTOR_FLOAT_64[] = { DIS_FIELDTYPE_END, NULL,0,0,0,0 } }; +DIS_ParserNode DIS_FIELDS_MOD_PARAMS_CCTT_SINCGARS[] = +{ + { DIS_FIELDTYPE_FH_NETWORK_ID, "Frequency Hopping Network ID",0,0,0,0 }, + { DIS_FIELDTYPE_FH_SET_ID, "Frequency Set ID",0,0,0,0 }, + { DIS_FIELDTYPE_LO_SET_ID, "Lockout Set ID",0,0,0,0 }, + { DIS_FIELDTYPE_FH_MSG_START, "Frequency Hopping Message Start",0,0,0,0 }, + { DIS_FIELDTYPE_RESERVED, "Reserved",0,0,0,0 }, + { DIS_FIELDTYPE_FH_SYNC_TIME_OFFSET, "FH Synchronization Time Offset",0,0,0,0 }, + { DIS_FIELDTYPE_FH_SECURITY_KEY, "Transmission Security Key",0,0,0,0 }, + { DIS_FIELDTYPE_FH_CLEAR_CHANNEL, "Clear Channel",0,0,0,0 }, + { DIS_FIELDTYPE_PAD8, "Padding",0,0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0,0 } +}; + +DIS_ParserNode DIS_FIELDS_MOD_PARAMS_JTIDS_MIDS[] = +{ + { DIS_FIELDTYPE_TS_ALLOCATION_MODE, "Time Slot Allocaton Mode",0,0,0,0 }, + { DIS_FIELDTYPE_TRANSMITTER_PRIMARY_MODE, "Transmitter Primary Mode",0,0,0,0 }, + { DIS_FIELDTYPE_TRANSMITTER_SECONDARY_MODE, "Transmitter Secondary Mode",0,0,0,0 }, + { DIS_FIELDTYPE_JTIDS_SYNC_STATE, "Synchronization State",0,0,0,0 }, + { DIS_FIELDTYPE_NETWORK_SYNC_ID, "Network Sync ID",0,0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0,0 } +}; + /* Array records */ DIS_ParserNode DIS_FIELDS_FIXED_DATUM[] = @@ -322,6 +377,9 @@ void initializeFieldParsers() initializeParser(DIS_FIELDS_VR_APPLICATION_HEALTH_STATUS); initializeParser(DIS_FIELDS_VR_APPLICATION_INITIALIZATION); initializeParser(DIS_FIELDS_VR_DATA_QUERY); + initializeParser(DIS_FIELDS_MOD_PARAMS_CCTT_SINCGARS); + initializeParser(DIS_FIELDS_MOD_PARAMS_JTIDS_MIDS); + } /* Adjust an offset variable for proper alignment for a specified field length. @@ -522,6 +580,8 @@ gint parseField_Enum(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNod const value_string *enumStrings = 0; guint32 enumVal = 0; const gchar *enumStr = 0; + proto_item *pi = NULL; + int dis_hf_id = -1; offset = alignOffset(offset, numBytes); @@ -547,12 +607,15 @@ gint parseField_Enum(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNod break; case DIS_FIELDTYPE_PROTOCOL_VERSION: enumStrings = DIS_PDU_ProtocolVersion_Strings; + dis_hf_id = hf_dis_proto_ver; break; case DIS_FIELDTYPE_PROTOCOL_FAMILY: enumStrings = DIS_PDU_ProtocolFamily_Strings; + dis_hf_id = hf_dis_proto_fam; break; case DIS_FIELDTYPE_PDU_TYPE: enumStrings = DIS_PDU_Type_Strings; + dis_hf_id = hf_dis_pdu_type; break; case DIS_FIELDTYPE_ENTITY_KIND: enumStrings = DIS_PDU_EntityKind_Strings; @@ -566,6 +629,15 @@ gint parseField_Enum(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNod case DIS_FIELDTYPE_FROZEN_BEHAVIOR: enumStrings = DIS_PDU_FrozenBehavior_Strings; break; + case DIS_FIELDTYPE_RADIO_CATEGORY: + enumStrings = DIS_PDU_RadioCategory_Strings; + break; + case DIS_FIELDTYPE_NOMENCLATURE_VERSION: + enumStrings = DIS_PDU_NomenclatureVersion_Strings; + break; + case DIS_FIELDTYPE_NOMENCLATURE: + enumStrings = DIS_PDU_Nomenclature_Strings; + break; case DIS_FIELDTYPE_CATEGORY: if (entityKind == DIS_ENTITYKIND_PLATFORM) { @@ -613,6 +685,33 @@ gint parseField_Enum(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNod case DIS_FIELDTYPE_RESPONSE_FLAG: enumStrings = DIS_PDU_DisResponseFlag_Strings; break; + case DIS_FIELDTYPE_MODULATION_DETAIL: + switch (majorModulation) { + case DIS_MAJOR_MOD_AMPLITUDE: + enumStrings = DIS_PDU_DetailModulationAmplitude_Strings; + break; + case DIS_MAJOR_MOD_AMPLITUDE_AND_ANGLE: + enumStrings = DIS_PDU_DetailModulationAmpAndAngle_Strings; + break; + case DIS_MAJOR_MOD_ANGLE: + enumStrings = DIS_PDU_DetailModulationAngle_Strings; + break; + case DIS_MAJOR_MOD_COMBINATION: + enumStrings = DIS_PDU_DetailModulationCombination_Strings; + break; + case DIS_MAJOR_MOD_PULSE: + enumStrings = DIS_PDU_DetailModulationPulse_Strings; + break; + case DIS_MAJOR_MOD_UNMODULATED: + enumStrings = DIS_PDU_DetailModulationUnmodulated_Strings; + break; + case DIS_MAJOR_MOD_CPSM: /* CPSM only has "other" defined */ + case DIS_MAJOR_MOD_OTHER: + default: + enumStrings = DIS_PDU_DetailModulationCPSM_Strings; + break; + } + break; default: enumStrings = 0; break; @@ -643,8 +742,13 @@ gint parseField_Enum(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNod enumStr = "Unknown Enum Type"; } - proto_tree_add_text(tree, tvb, offset, numBytes, "%s = %s", - parserNode.fieldLabel, enumStr); + if (dis_hf_id != -1) { + pi = proto_tree_add_item(tree, dis_hf_id, tvb, offset, 1, FALSE); +/* proto_item_set_text(pi, "%s = %s", parserNode.fieldLabel, enumStr); */ + } + else + proto_tree_add_text(tree, tvb, offset, numBytes, "%s = %s", + parserNode.fieldLabel, enumStr); if (parserNode.outputVar != 0) { @@ -672,6 +776,22 @@ gint parseField_Float(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNo return offset; } +/* Parse a 4-byte floating-point value, given text label. + */ +gint parseField_Float_Text(tvbuff_t *tvb, proto_tree *tree, gint offset, gchar *charStr) +{ + gfloat floatVal; + + offset = alignOffset(offset, 4); + floatVal = tvb_get_ntohieee_float(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 4, "%s = %f", + charStr, floatVal); + + offset += 4; + + return offset; +} + /* Parse an 8-byte floating-point value. */ gint parseField_Double(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode) diff --git a/epan/dissectors/packet-dis-fields.h b/epan/dissectors/packet-dis-fields.h index 4c01288e46..e97ade8ab3 100644 --- a/epan/dissectors/packet-dis-fields.h +++ b/epan/dissectors/packet-dis-fields.h @@ -29,6 +29,64 @@ #include <epan/packet.h> +extern int hf_dis_proto_ver; +extern int hf_dis_exercise_id; +extern int hf_dis_pdu_type; +extern int hf_dis_proto_fam; +extern int hf_dis_pdu_length; +extern int hf_dis_entity_id_site; +extern int hf_dis_entity_id_application; +extern int hf_dis_entity_id_entity; +extern int hf_dis_num_art_params; +extern int hf_dis_radio_id; +extern int hf_dis_ens; +extern int hf_dis_ens_class; +extern int hf_dis_ens_type; +extern int hf_dis_tdl_type; +extern int hf_dis_sample_rate; +extern int hf_dis_data_length; +extern int hf_dis_num_of_samples; +extern int hf_dis_signal_data; +extern int hf_dis_radio_category; +extern int hf_dis_nomenclature_version; +extern int hf_dis_nomenclature; +extern int hf_dis_radio_transmit_state; +extern int hf_dis_radio_input_source; +extern int hf_dis_antenna_pattern_type; +extern int hf_dis_antenna_pattern_length; +extern int hf_dis_transmit_frequency; +extern int hf_dis_spread_spectrum_usage; +extern int hf_dis_frequency_hopping; +extern int hf_dis_pseudo_noise_modulation; +extern int hf_dis_time_hopping; +extern int hf_dis_modulation_major; +extern int hf_dis_modulation_system; +extern int hf_dis_crypto_system; +extern int hf_dis_crypto_key; +extern int hf_dis_encryption_mode; +extern int hf_dis_key_identifier; +extern int hf_dis_modulation_parameter_length; +extern int hf_dis_mod_param_fh_net_id; +extern int hf_dis_mod_param_fh_set_id; +extern int hf_dis_mod_param_fh_lo_set_id; +extern int hf_dis_mod_param_fh_msg_start; +extern int hf_dis_mod_param_fh_reserved; +extern int hf_dis_mod_param_fh_sync_time_offset; +extern int hf_dis_mod_param_fh_security_key; +extern int hf_dis_mod_param_fh_clear_channel; +extern int hf_dis_mod_param_dump; +extern int hf_dis_mod_param_ts_allocation_mode; +extern int hf_dis_mod_param_transmitter_prim_mode; +extern int hf_dis_mod_param_transmitter_second_mode; +extern int hf_dis_mod_param_sync_state; +extern int hf_dis_mod_param_network_sync_id; +extern int hf_dis_antenna_pattern_parameter_dump; + +extern int ett_dis_ens; +extern int ett_dis_crypto_key; + + + /* enumeration of all field types used for DIS parsing. */ typedef enum { @@ -50,6 +108,7 @@ typedef enum /* padding */ DIS_FIELDTYPE_PAD8, DIS_FIELDTYPE_PAD16, + DIS_FIELDTYPE_PAD24, DIS_FIELDTYPE_PAD32, /* enumerations */ @@ -74,8 +133,25 @@ typedef enum DIS_FIELDTYPE_REQUEST_STATUS, DIS_FIELDTYPE_REQUIRED_RELIABILITY_SERVICE, DIS_FIELDTYPE_RESPONSE_FLAG, - + DIS_FIELDTYPE_TDL_TYPE, + DIS_FIELDTYPE_RADIO_CATEGORY, + DIS_FIELDTYPE_NOMENCLATURE_VERSION, + DIS_FIELDTYPE_NOMENCLATURE, + DIS_FIELDTYPE_RADIO_TRANSMIT_STATE, + DIS_FIELDTYPE_RADIO_INPUT_SOURCE, + DIS_FIELDTYPE_ANTENNA_PATTERN_TYPE, + DIS_FIELDTYPE_SPREAD_SPECTRUM, + DIS_FIELDTYPE_MODULATION_MAJOR, + DIS_FIELDTYPE_MODULATION_DETAIL, + DIS_FIELDTYPE_MODULATION_SYSTEM, + DIS_FIELDTYPE_CRYPTO_SYSTEM, + /* other atomic types */ + DIS_FIELDTYPE_PDU_LENGTH, + DIS_FIELDTYPE_EXERCISE_ID, + DIS_FIELDTYPE_SITE, + DIS_FIELDTYPE_APPLICATION, + DIS_FIELDTYPE_ENTITY, DIS_FIELDTYPE_APPEARANCE, DIS_FIELDTYPE_ARTIC_PARAM_TYPE, DIS_FIELDTYPE_CAPABILITIES, @@ -99,12 +175,34 @@ typedef enum DIS_FIELDTYPE_TIME_INTERVAL, DIS_FIELDTYPE_TIMESTAMP, DIS_FIELDTYPE_WARHEAD, + DIS_FIELDTYPE_RADIO_ID, + DIS_FIELDTYPE_SAMPLE_RATE, + DIS_FIELDTYPE_DATA_LENGTH, + DIS_FIELDTYPE_NUMBER_OF_SAMPLES, + DIS_FIELDTYPE_NUM_ARTICULATION_PARAMS, + DIS_FIELDTYPE_ANTENNA_PATTERN_LENGTH, + DIS_FIELDTYPE_TRANSMIT_FREQUENCY, + DIS_FIELDTYPE_MODULATION_PARAMETER_LENGTH, + DIS_FIELDTYPE_FH_NETWORK_ID, + DIS_FIELDTYPE_FH_SET_ID, + DIS_FIELDTYPE_LO_SET_ID, + DIS_FIELDTYPE_FH_MSG_START, + DIS_FIELDTYPE_RESERVED, + DIS_FIELDTYPE_FH_SYNC_TIME_OFFSET, + DIS_FIELDTYPE_FH_SECURITY_KEY, + DIS_FIELDTYPE_FH_CLEAR_CHANNEL, + DIS_FIELDTYPE_TS_ALLOCATION_MODE, + DIS_FIELDTYPE_TRANSMITTER_PRIMARY_MODE, + DIS_FIELDTYPE_TRANSMITTER_SECONDARY_MODE, + DIS_FIELDTYPE_JTIDS_SYNC_STATE, + DIS_FIELDTYPE_NETWORK_SYNC_ID, - /* composite types */ + /* composite types */ DIS_FIELDTYPE_BURST_DESCRIPTOR, DIS_FIELDTYPE_CLOCK_TIME, DIS_FIELDTYPE_ENTITY_ID, DIS_FIELDTYPE_ENTITY_TYPE, + DIS_FIELDTYPE_RADIO_ENTITY_TYPE, DIS_FIELDTYPE_EVENT_ID, DIS_FIELDTYPE_LINEAR_VELOCITY, DIS_FIELDTYPE_LOCATION_ENTITY, @@ -114,14 +212,24 @@ typedef enum DIS_FIELDTYPE_VARIABLE_DATUM_VALUE, DIS_FIELDTYPE_VECTOR_32, DIS_FIELDTYPE_VECTOR_64, - + DIS_FIELDTYPE_ENCODING_SCHEME, + DIS_FIELDTYPE_ANTENNA_LOCATION, + DIS_FIELDTYPE_REL_ANTENNA_LOCATON, + DIS_FIELDTYPE_MODULATION_TYPE, + DIS_FIELDTYPE_CRYPTO_KEY_ID, + DIS_FIELDTYPE_MODULATION_PARAMETERS, + DIS_FIELDTYPE_ANTENNA_PATTERN_PARAMETERS, + DIS_FIELDTYPE_MOD_PARAMS_CCTT_SINCGARS, + DIS_FIELDTYPE_MOD_PARAMS_JTIDS_MIDS, + /* arrays */ DIS_FIELDTYPE_FIXED_DATUMS, DIS_FIELDTYPE_FIXED_DATUM_IDS, DIS_FIELDTYPE_VARIABLE_DATUMS, DIS_FIELDTYPE_VARIABLE_DATUM_IDS, DIS_FIELDTYPE_VARIABLE_PARAMETERS, - DIS_FIELDTYPE_VARIABLE_RECORDS + DIS_FIELDTYPE_VARIABLE_RECORDS, + DIS_FIELDTYPE_RADIO_DATA } DIS_FieldType; @@ -165,11 +273,15 @@ extern DIS_ParserNode DIS_FIELDS_BURST_DESCRIPTOR[]; extern DIS_ParserNode DIS_FIELDS_CLOCK_TIME[]; extern DIS_ParserNode DIS_FIELDS_ENTITY_ID[]; extern DIS_ParserNode DIS_FIELDS_ENTITY_TYPE[]; +extern DIS_ParserNode DIS_FIELDS_RADIO_ENTITY_TYPE[]; +extern DIS_ParserNode DIS_FIELDS_MODULATION_TYPE[]; extern DIS_ParserNode DIS_FIELDS_EVENT_ID[]; extern DIS_ParserNode DIS_FIELDS_ORIENTATION[]; extern DIS_ParserNode DIS_FIELDS_SIMULATION_ADDRESS[]; extern DIS_ParserNode DIS_FIELDS_VECTOR_FLOAT_32[]; extern DIS_ParserNode DIS_FIELDS_VECTOR_FLOAT_64[]; +extern DIS_ParserNode DIS_FIELDS_MOD_PARAMS_CCTT_SINCGARS[]; +extern DIS_ParserNode DIS_FIELDS_MOD_PARAMS_JTIDS_MIDS[]; /* Array records */ extern DIS_ParserNode DIS_FIELDS_FIXED_DATUM[]; @@ -207,15 +319,24 @@ extern gint parseField_VariableParameter(tvbuff_t *tvb, proto_tree *tree, gint o extern gint parseField_VariableRecord(tvbuff_t *tvb, proto_tree *tree, gint offset); -extern guint32 protocolVersion; +extern guint32 disProtocolVersion; extern guint32 pduType; extern guint32 protocolFamily; extern guint32 persistentObjectPduType; extern guint32 entityKind; extern guint32 entityDomain; +extern guint32 radioID; +extern guint32 disRadioTransmitState; +extern guint32 encodingScheme; +extern guint32 numSamples; extern guint32 numFixed; extern guint32 numVariable; extern guint32 variableDatumLength; extern guint32 variableRecordLength; +extern guint32 majorModulation; +extern guint32 systemModulation; +extern guint32 modulationParamLength; +extern guint32 disAntennaPattern; + #endif /* packet-dis-fieldparsers.h */ diff --git a/epan/dissectors/packet-dis-pdus.c b/epan/dissectors/packet-dis-pdus.c index 69bc67d3ec..172205b042 100644 --- a/epan/dissectors/packet-dis-pdus.c +++ b/epan/dissectors/packet-dis-pdus.c @@ -31,10 +31,12 @@ #include <string.h> #include "packet-dis-pdus.h" #include "packet-dis-fields.h" +#include "packet-dis-enums.h" #define DIS_PDU_MAX_VARIABLE_PARAMETERS 16 #define DIS_PDU_MAX_VARIABLE_RECORDS 16 + gint ettVariableParameters[DIS_PDU_MAX_VARIABLE_PARAMETERS]; gint ettVariableRecords[DIS_PDU_MAX_VARIABLE_RECORDS]; @@ -47,7 +49,7 @@ DIS_ParserNode DIS_PARSER_ENTITY_STATE_PDU[] = { { DIS_FIELDTYPE_ENTITY_ID, "Entity ID",0,0,0,0 }, { DIS_FIELDTYPE_FORCE_ID, "Force ID",0,0,0,0 }, - { DIS_FIELDTYPE_UINT8, "Number of Variable Parameters",0,0,0,&numVariable }, + { DIS_FIELDTYPE_NUM_ARTICULATION_PARAMS, "Number of Articulation Parameters",0,0,0,&numVariable }, { DIS_FIELDTYPE_ENTITY_TYPE, "Entity Type",0,0,0,0 }, { DIS_FIELDTYPE_ENTITY_TYPE, "Alternative Entity Type",0,0,0,0 }, { DIS_FIELDTYPE_LINEAR_VELOCITY, "Entity Linear Velocity",0,0,0,0 }, @@ -61,6 +63,47 @@ DIS_ParserNode DIS_PARSER_ENTITY_STATE_PDU[] = { DIS_FIELDTYPE_END, NULL,0,0,0,0 } }; + +/* DIS Radio Communications protocol (RCP) family PDUs + */ +DIS_ParserNode DIS_PARSER_TRANSMITTER_PDU[] = +{ + { DIS_FIELDTYPE_ENTITY_ID, "Entity ID",0,0,0,0 }, + { DIS_FIELDTYPE_RADIO_ID, "Radio ID",0,0,0,&radioID }, + { DIS_FIELDTYPE_RADIO_ENTITY_TYPE, "Radio Entity Type",0,0,0,0 }, + { DIS_FIELDTYPE_RADIO_TRANSMIT_STATE, "Radio Transmit State",0,0,0,&disRadioTransmitState }, + { DIS_FIELDTYPE_RADIO_INPUT_SOURCE, "Radio Input Source",0,0,0,0 }, + { DIS_FIELDTYPE_PAD16, "Padding",0,0,0,0 }, + { DIS_FIELDTYPE_ANTENNA_LOCATION, "Antenna Location",0,0,0,0 }, + { DIS_FIELDTYPE_REL_ANTENNA_LOCATON, "Relative Antenna Location",0,0,0,0 }, + { DIS_FIELDTYPE_ANTENNA_PATTERN_TYPE, "Antenna Pattern Type",0,0,0,&disAntennaPattern }, + { DIS_FIELDTYPE_ANTENNA_PATTERN_LENGTH, "Antenna Pattern Length",0,0,0,0 }, + { DIS_FIELDTYPE_TRANSMIT_FREQUENCY, "Transmit Frequency",0,0,0,0 }, + { DIS_FIELDTYPE_FLOAT32, "Transmit Frequency Bandwidth",0,0,0,0 }, + { DIS_FIELDTYPE_FLOAT32, "Transmit Power",0,0,0,0 }, + { DIS_FIELDTYPE_MODULATION_TYPE, "Modulation Type",0,0,0,0 }, + { DIS_FIELDTYPE_CRYPTO_SYSTEM, "Crypto System",0,0,0,0 }, + { DIS_FIELDTYPE_CRYPTO_KEY_ID, "Crypto Key ID",0,0,0,0 }, + { DIS_FIELDTYPE_MODULATION_PARAMETER_LENGTH, "Modulation Parameter Length",0,0,0,&modulationParamLength }, + { DIS_FIELDTYPE_PAD24, "Padding",0,0,0,0 }, + { DIS_FIELDTYPE_MODULATION_PARAMETERS, "Modulation Parameters",0,0,0,0 }, + /* need to finish decoding this PDU */ + { DIS_FIELDTYPE_END, NULL,0,0,0,0 } +}; + +DIS_ParserNode DIS_PARSER_SIGNAL_PDU[] = +{ + { DIS_FIELDTYPE_ENTITY_ID, "Entity ID",0,0,0,0 }, + { DIS_FIELDTYPE_RADIO_ID, "Radio ID",0,0,0,&radioID }, + { DIS_FIELDTYPE_ENCODING_SCHEME, "Encoding Scheme",0,0,0,&encodingScheme }, + { DIS_FIELDTYPE_TDL_TYPE, "TDL Type",0,0,0,0 }, + { DIS_FIELDTYPE_SAMPLE_RATE, "Sample Rate",0,0,0,0 }, + { DIS_FIELDTYPE_DATA_LENGTH, "Data Length",0,0,0,0 }, + { DIS_FIELDTYPE_NUMBER_OF_SAMPLES, "Number of Samples",0,0,0,&numSamples }, + { DIS_FIELDTYPE_RADIO_DATA, "Radio Data",0,0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0,0 } +}; + /* DIS Warfare PDUs */ DIS_ParserNode DIS_PARSER_FIRE_PDU[] = @@ -88,7 +131,7 @@ DIS_ParserNode DIS_PARSER_DETONATION_PDU[] = { DIS_FIELDTYPE_BURST_DESCRIPTOR, "Burst Descriptor",0,0,0,0 }, { DIS_FIELDTYPE_LOCATION_ENTITY, "Location in Entity Coordinates",0,0,0,0 }, { DIS_FIELDTYPE_DETONATION_RESULT, "Detonation Result",0,0,0,0 }, - { DIS_FIELDTYPE_UINT8, "Number of Variable Parameters",0,0,0,&numVariable }, + { DIS_FIELDTYPE_NUM_ARTICULATION_PARAMS, "Number of Articulation Parameters",0,0,0,&numVariable }, { DIS_FIELDTYPE_PAD16, "Padding",0,0,0,0 }, { DIS_FIELDTYPE_VARIABLE_PARAMETERS, "Variable Parameter",0,0,0,0 }, { DIS_FIELDTYPE_END, NULL,0,0,0,0 } @@ -384,6 +427,10 @@ void initializeParsers(void) /* DIS Entity Information / Interaction PDUs */ initializeParser(DIS_PARSER_ENTITY_STATE_PDU); + /* DIS Radio Communications protocol (RCP) family PDUs */ + initializeParser(DIS_PARSER_TRANSMITTER_PDU); + initializeParser(DIS_PARSER_SIGNAL_PDU); + /* DIS Warfare PDUs */ initializeParser(DIS_PARSER_FIRE_PDU); initializeParser(DIS_PARSER_DETONATION_PDU); @@ -486,6 +533,17 @@ void initializeParser(DIS_ParserNode parserNodes[]) break; /* Composite types */ + case DIS_FIELDTYPE_MOD_PARAMS_CCTT_SINCGARS: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_MOD_PARAMS_CCTT_SINCGARS, + &parserNodes[parserIndex].ettVar); + break; + case DIS_FIELDTYPE_MOD_PARAMS_JTIDS_MIDS: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_MOD_PARAMS_JTIDS_MIDS, + &parserNodes[parserIndex].ettVar); + break; + case DIS_FIELDTYPE_BURST_DESCRIPTOR: parserNodes[parserIndex].children = createSubtree( DIS_FIELDS_BURST_DESCRIPTOR, @@ -506,6 +564,11 @@ void initializeParser(DIS_ParserNode parserNodes[]) DIS_FIELDS_ENTITY_TYPE, &parserNodes[parserIndex].ettVar); break; + case DIS_FIELDTYPE_RADIO_ENTITY_TYPE: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_RADIO_ENTITY_TYPE, + &parserNodes[parserIndex].ettVar); + break; case DIS_FIELDTYPE_EVENT_ID: parserNodes[parserIndex].children = createSubtree( DIS_FIELDS_EVENT_ID, @@ -523,18 +586,25 @@ void initializeParser(DIS_ParserNode parserNodes[]) break; case DIS_FIELDTYPE_LINEAR_VELOCITY: case DIS_FIELDTYPE_LOCATION_ENTITY: + case DIS_FIELDTYPE_REL_ANTENNA_LOCATON: case DIS_FIELDTYPE_VECTOR_32: parserNodes[parserIndex].children = createSubtree( DIS_FIELDS_VECTOR_FLOAT_32, &parserNodes[parserIndex].ettVar); break; case DIS_FIELDTYPE_LOCATION_WORLD: + case DIS_FIELDTYPE_ANTENNA_LOCATION: case DIS_FIELDTYPE_VECTOR_64: parserNodes[parserIndex].children = createSubtree( DIS_FIELDS_VECTOR_FLOAT_64, &parserNodes[parserIndex].ettVar); break; - + case DIS_FIELDTYPE_MODULATION_TYPE: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_MODULATION_TYPE, + &parserNodes[parserIndex].ettVar); + break; + /* Array records */ case DIS_FIELDTYPE_FIXED_DATUMS: parserNodes[parserIndex].children = createSubtree( @@ -575,8 +645,18 @@ gint parseFields(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode pa { guint fieldIndex = 0; guint fieldRepeatLen = 0; + guint64 uintVal = 0; + proto_item *pi = NULL; + proto_tree *sub_tree = NULL; + tvbuff_t *newtvb = NULL; + gint length = 0; + guint16 spread_spectrum = 0; - while (parserNodes[fieldIndex].fieldType != DIS_FIELDTYPE_END) + + length = tvb_length_remaining(tvb, offset); + + while ((parserNodes[fieldIndex].fieldType != DIS_FIELDTYPE_END) + && (length > 0 ) ) { proto_item *newField = 0; @@ -626,7 +706,244 @@ gint parseFields(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode pa offset = parseField_Double(tvb, tree, offset, parserNodes[fieldIndex]); break; + case DIS_FIELDTYPE_EXERCISE_ID: + pi = proto_tree_add_item(tree, hf_dis_exercise_id, tvb, offset, 1, FALSE); + offset += 1; + break; + case DIS_FIELDTYPE_NUM_ARTICULATION_PARAMS: + uintVal = tvb_get_guint8(tvb, offset); + pi = proto_tree_add_item(tree, hf_dis_num_art_params, tvb, offset, 1, FALSE); + offset += 1; + *(parserNodes[fieldIndex].outputVar) = (guint32)uintVal; + break; + case DIS_FIELDTYPE_PDU_LENGTH: + uintVal = tvb_get_ntohs(tvb, offset); + pi = proto_tree_add_item(tree, hf_dis_pdu_length, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_SITE: + uintVal = tvb_get_ntohs(tvb, offset); + pi = proto_tree_add_item(tree, hf_dis_entity_id_site, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_APPLICATION: + uintVal = tvb_get_ntohs(tvb, offset); + pi = proto_tree_add_item(tree, hf_dis_entity_id_application, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_ENTITY: + uintVal = tvb_get_ntohs(tvb, offset); + pi = proto_tree_add_item(tree, hf_dis_entity_id_entity, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_RADIO_ID: + uintVal = tvb_get_ntohs(tvb, offset); + pi = proto_tree_add_item(tree, hf_dis_radio_id, tvb, offset, 2, FALSE); + *(parserNodes[fieldIndex].outputVar) = (guint32)uintVal; + offset += 2; + break; + case DIS_FIELDTYPE_ENCODING_SCHEME: + uintVal = tvb_get_ntohs(tvb, offset); + pi = proto_tree_add_item(tree, hf_dis_ens, tvb, offset, 2, FALSE); + sub_tree = proto_item_add_subtree(pi, ett_dis_ens); + proto_tree_add_item(sub_tree, hf_dis_ens_class, tvb, offset, 2, FALSE); + proto_tree_add_item(sub_tree, hf_dis_ens_type, tvb, offset, 2, FALSE); + proto_item_set_end(pi, tvb, offset); + *(parserNodes[fieldIndex].outputVar) = (guint32)uintVal; + offset += 2; + break; + case DIS_FIELDTYPE_TDL_TYPE: + proto_tree_add_item(tree, hf_dis_tdl_type, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_SAMPLE_RATE: + proto_tree_add_item(tree, hf_dis_sample_rate, tvb, offset, 4, FALSE); + offset += 4; + break; + case DIS_FIELDTYPE_DATA_LENGTH: + proto_tree_add_item(tree, hf_dis_data_length, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_NUMBER_OF_SAMPLES: + uintVal = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(tree, hf_dis_num_of_samples, tvb, offset, 2, FALSE); + *(parserNodes[fieldIndex].outputVar) = (guint32)uintVal; + offset += 2; + break; + case DIS_FIELDTYPE_RADIO_DATA: + newtvb = tvb_new_subset(tvb, offset, + tvb_length_remaining(tvb, offset), + tvb_reported_length_remaining(tvb, offset) + ); + proto_tree_add_item(tree, hf_dis_signal_data, newtvb, 0, -1, FALSE ); + /* ****ck******* need to look for padding bytes */ + break; + case DIS_FIELDTYPE_RADIO_CATEGORY: + proto_tree_add_item(tree, hf_dis_radio_category, tvb, offset, 1, FALSE); + offset += 1; + break; + case DIS_FIELDTYPE_NOMENCLATURE_VERSION: + proto_tree_add_item(tree, hf_dis_nomenclature_version, tvb, offset, 1, FALSE); + offset += 1; + break; + case DIS_FIELDTYPE_NOMENCLATURE: + proto_tree_add_item(tree, hf_dis_nomenclature, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_RADIO_TRANSMIT_STATE: + uintVal = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_dis_radio_transmit_state, tvb, offset, 1, FALSE); + *(parserNodes[fieldIndex].outputVar) = (guint32)uintVal; + offset += 1; + break; + case DIS_FIELDTYPE_RADIO_INPUT_SOURCE: + proto_tree_add_item(tree, hf_dis_radio_input_source, tvb, offset, 1, FALSE); + offset += 1; + break; + case DIS_FIELDTYPE_ANTENNA_PATTERN_TYPE: + uintVal = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(tree, hf_dis_antenna_pattern_type, tvb, offset, 2, FALSE); + *(parserNodes[fieldIndex].outputVar) = (guint32)uintVal; + offset += 2; + break; + case DIS_FIELDTYPE_ANTENNA_PATTERN_LENGTH: + proto_tree_add_item(tree, hf_dis_antenna_pattern_length, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_TRANSMIT_FREQUENCY: + proto_tree_add_item(tree, hf_dis_transmit_frequency, tvb, offset, 8, FALSE); + offset += 8; + break; + case DIS_FIELDTYPE_SPREAD_SPECTRUM: + spread_spectrum = tvb_get_ntohs(tvb, offset); + proto_tree_add_boolean(tree, hf_dis_spread_spectrum_usage, tvb, offset, 2, spread_spectrum); + proto_tree_add_boolean(tree, hf_dis_frequency_hopping, tvb, offset, 2, spread_spectrum); + proto_tree_add_boolean(tree, hf_dis_pseudo_noise_modulation, tvb, offset, 2, spread_spectrum); + proto_tree_add_boolean(tree, hf_dis_time_hopping, tvb, offset, 2, spread_spectrum); + offset += 2; + break; + case DIS_FIELDTYPE_MODULATION_MAJOR: + uintVal = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(tree, hf_dis_modulation_major, tvb, offset, 2, FALSE); + *(parserNodes[fieldIndex].outputVar) = (guint32)uintVal; + offset += 2; + break; + case DIS_FIELDTYPE_MODULATION_SYSTEM: + uintVal = tvb_get_ntohs(tvb, offset); + proto_tree_add_item(tree, hf_dis_modulation_system, tvb, offset, 2, FALSE); + *(parserNodes[fieldIndex].outputVar) = (guint32)uintVal; + offset += 2; + break; + case DIS_FIELDTYPE_CRYPTO_SYSTEM: + proto_tree_add_item(tree, hf_dis_crypto_system, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_CRYPTO_KEY_ID: + pi = proto_tree_add_item(tree, hf_dis_crypto_key, tvb, offset, 2, FALSE); + sub_tree = proto_item_add_subtree(pi, ett_dis_crypto_key); + proto_tree_add_item(sub_tree, hf_dis_encryption_mode, tvb, offset, 2, FALSE); + proto_tree_add_item(sub_tree, hf_dis_key_identifier, tvb, offset, 2, FALSE); + proto_item_set_end(pi, tvb, offset); + offset += 2; + break; + case DIS_FIELDTYPE_MODULATION_PARAMETER_LENGTH: + uintVal = tvb_get_guint8(tvb, offset); + proto_tree_add_item(tree, hf_dis_modulation_parameter_length, tvb, offset, 1, FALSE); + *(parserNodes[fieldIndex].outputVar) = (guint32)uintVal; + offset += 1; + break; + case DIS_FIELDTYPE_FH_NETWORK_ID: + proto_tree_add_item(tree, hf_dis_mod_param_fh_net_id, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_FH_SET_ID: + proto_tree_add_item(tree, hf_dis_mod_param_fh_set_id, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_LO_SET_ID: + proto_tree_add_item(tree, hf_dis_mod_param_fh_lo_set_id, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_FH_MSG_START: + proto_tree_add_item(tree, hf_dis_mod_param_fh_msg_start, tvb, offset, 1, FALSE); + offset += 1; + break; + case DIS_FIELDTYPE_RESERVED: + proto_tree_add_item(tree, hf_dis_mod_param_fh_reserved, tvb, offset, 1, FALSE); + offset += 1; + break; + case DIS_FIELDTYPE_FH_SYNC_TIME_OFFSET: + proto_tree_add_item(tree, hf_dis_mod_param_fh_sync_time_offset, tvb, offset, 4, FALSE); + offset += 4; + break; + case DIS_FIELDTYPE_FH_SECURITY_KEY: + proto_tree_add_item(tree, hf_dis_mod_param_fh_security_key, tvb, offset, 2, FALSE); + offset += 2; + break; + case DIS_FIELDTYPE_FH_CLEAR_CHANNEL: + proto_tree_add_item(tree, hf_dis_mod_param_fh_clear_channel, tvb, offset, 1, FALSE); + offset += 1; + break; + case DIS_FIELDTYPE_TS_ALLOCATION_MODE: + proto_tree_add_item(tree, hf_dis_mod_param_ts_allocation_mode, tvb, offset, 1, FALSE); + offset += 1; + break; + case DIS_FIELDTYPE_TRANSMITTER_PRIMARY_MODE: + proto_tree_add_item(tree, hf_dis_mod_param_transmitter_prim_mode, tvb, offset, 1, FALSE); + offset += 1; + break; + case DIS_FIELDTYPE_TRANSMITTER_SECONDARY_MODE: + proto_tree_add_item(tree, hf_dis_mod_param_transmitter_second_mode, tvb, offset, 1, FALSE); + offset += 1; + break; + case DIS_FIELDTYPE_JTIDS_SYNC_STATE: + proto_tree_add_item(tree, hf_dis_mod_param_sync_state, tvb, offset, 1, FALSE); + offset += 1; + break; + case DIS_FIELDTYPE_NETWORK_SYNC_ID: + proto_tree_add_item(tree, hf_dis_mod_param_network_sync_id, tvb, offset, 4, FALSE); + offset += 4; + break; + case DIS_FIELDTYPE_MODULATION_PARAMETERS: + /* need to check to see if mod parms length > 0 */ + /* could get here when there are antenna pattern parameter but no mod params */ + if (modulationParamLength > 0 ) { /* we do have a mod param */ + if (systemModulation == DIS_SYSTEM_MOD_CCTT_SINCGARS) + { + pi = proto_tree_add_text(tree, tvb, offset, -1, "%s", + parserNodes[fieldIndex].fieldLabel); + sub_tree = proto_item_add_subtree(pi, parserNodes[fieldIndex].ettVar); + offset = parseFields(tvb, sub_tree, offset, DIS_FIELDS_MOD_PARAMS_CCTT_SINCGARS); + proto_item_set_end(pi, tvb, offset); + break; + } + else if (systemModulation == DIS_SYSTEM_MOD_JTIDS_MIDS) { + pi = proto_tree_add_text(tree, tvb, offset, -1, "%s", + parserNodes[fieldIndex].fieldLabel); + sub_tree = proto_item_add_subtree(pi, parserNodes[fieldIndex].ettVar); + offset = parseFields(tvb, sub_tree, offset, DIS_FIELDS_MOD_PARAMS_JTIDS_MIDS); + proto_item_set_end(pi, tvb, offset); + break; + } + else { /* just dump what is available */ + newtvb = tvb_new_subset(tvb, offset,modulationParamLength, modulationParamLength); + proto_tree_add_item(tree, hf_dis_mod_param_dump, newtvb, 0, -1, FALSE ); + offset += modulationParamLength; + break; + } + } /* else, leave offset alone, and then check antenna pattern param field */ + break; + case DIS_FIELDTYPE_ANTENNA_PATTERN_PARAMETERS: + /* just dump the bytes for now. Need to do finish */ + newtvb = tvb_new_subset(tvb, offset, + tvb_length_remaining(tvb, offset), + tvb_reported_length_remaining(tvb, offset) + ); + proto_tree_add_item(tree, hf_dis_antenna_pattern_parameter_dump, newtvb, 0, -1, FALSE ); + break; + + /* padding */ case DIS_FIELDTYPE_PAD8: offset = parseField_Pad(tvb, tree, offset, @@ -636,6 +953,10 @@ gint parseFields(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode pa offset = parseField_Pad(tvb, tree, offset, parserNodes[fieldIndex], 2 * fieldRepeatLen); break; + case DIS_FIELDTYPE_PAD24: + offset = parseField_Pad(tvb, tree, offset, + parserNodes[fieldIndex], 3 * fieldRepeatLen); + break; case DIS_FIELDTYPE_PAD32: offset = parseField_Pad(tvb, tree, offset, parserNodes[fieldIndex], 4 * fieldRepeatLen); @@ -666,6 +987,7 @@ gint parseFields(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode pa case DIS_FIELDTYPE_APPLICATION_STATUS_TYPE: case DIS_FIELDTYPE_APPLICATION_TYPE: case DIS_FIELDTYPE_RESPONSE_FLAG: + case DIS_FIELDTYPE_MODULATION_DETAIL: offset = parseField_Enum(tvb, tree, offset, parserNodes[fieldIndex], 2); break; @@ -776,6 +1098,9 @@ gint parseFields(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode pa case DIS_FIELDTYPE_CLOCK_TIME: case DIS_FIELDTYPE_ENTITY_ID: case DIS_FIELDTYPE_ENTITY_TYPE: + case DIS_FIELDTYPE_RADIO_ENTITY_TYPE: + case DIS_FIELDTYPE_ANTENNA_LOCATION: + case DIS_FIELDTYPE_REL_ANTENNA_LOCATON: case DIS_FIELDTYPE_EVENT_ID: case DIS_FIELDTYPE_LINEAR_VELOCITY: case DIS_FIELDTYPE_LOCATION_ENTITY: @@ -784,6 +1109,7 @@ gint parseFields(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode pa case DIS_FIELDTYPE_SIMULATION_ADDRESS: case DIS_FIELDTYPE_VECTOR_32: case DIS_FIELDTYPE_VECTOR_64: + case DIS_FIELDTYPE_MODULATION_TYPE: newField = proto_tree_add_text(tree, tvb, offset, -1, "%s", parserNodes[fieldIndex].fieldLabel); if (parserNodes[fieldIndex].children != 0) @@ -819,14 +1145,23 @@ gint parseFields(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode pa for (i = 0; i < numFixed; ++i) { - proto_item *newSubtree; - newField = proto_tree_add_text(tree, tvb, offset, -1, "%s", - parserNodes[fieldIndex].fieldLabel); - newSubtree = proto_item_add_subtree(newField, ettFixedData); - offset = parseFields - (tvb, newSubtree, offset, - parserNodes[fieldIndex].children); - proto_item_set_end(newField, tvb, offset); + /* is remaining length large enough for another fixed datum (ID & value) */ + length = tvb_length_remaining(tvb, offset); + if ( length >= 8 ) + { + proto_item *newSubtree; + newField = proto_tree_add_text(tree, tvb, offset, -1, "%s", + parserNodes[fieldIndex].fieldLabel); + newSubtree = proto_item_add_subtree(newField, ettFixedData); + offset = parseFields + (tvb, newSubtree, offset, + parserNodes[fieldIndex].children); + proto_item_set_end(newField, tvb, offset); + } + else { + THROW(ReportedBoundsError); + break; + } } } break; @@ -847,9 +1182,17 @@ gint parseFields(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode pa for (i = 0; i < numFixed; ++i) { - offset = parseFields - (tvb, newSubtree, offset, - parserNodes[fieldIndex].children); + /* is remaining length large enough for another fixed datum ID (32 bit int) */ + if (tvb_length_remaining(tvb, offset) >= 4 ) + { + offset = parseFields + (tvb, newSubtree, offset, + parserNodes[fieldIndex].children); + } + else { + THROW(ReportedBoundsError); + break; + } } proto_item_set_end(newField, tvb, offset); } @@ -937,17 +1280,26 @@ gint parseFields(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode pa for (i = 0; i < numVariable; ++i) { - proto_item *newSubtree; - newField = proto_tree_add_text(tree, tvb, offset, -1, "%s", - parserNodes[fieldIndex].fieldLabel); - newSubtree = proto_item_add_subtree(newField, - ettVariableRecords[i]); - offset = parseFields - (tvb, newSubtree, offset, - parserNodes[fieldIndex].children); - offset = parseField_VariableRecord - (tvb, newSubtree, offset); - proto_item_set_end(newField, tvb, offset); + /* simple check to detect malformed, field parsers will detect specifics */ + length = tvb_length_remaining(tvb, offset); + if ( length > 0 ) + { + proto_item *newSubtree; + newField = proto_tree_add_text(tree, tvb, offset, -1, "%s", + parserNodes[fieldIndex].fieldLabel); + newSubtree = proto_item_add_subtree(newField, + ettVariableRecords[i]); + offset = parseFields + (tvb, newSubtree, offset, + parserNodes[fieldIndex].children); + offset = parseField_VariableRecord + (tvb, newSubtree, offset); + proto_item_set_end(newField, tvb, offset); + } + else { + THROW(ReportedBoundsError); + break; + } } } break; @@ -956,6 +1308,7 @@ gint parseFields(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode pa } ++fieldIndex; + length = tvb_length_remaining(tvb, offset); } return offset; diff --git a/epan/dissectors/packet-dis-pdus.h b/epan/dissectors/packet-dis-pdus.h index 06da1f7c24..a9cd01e21d 100644 --- a/epan/dissectors/packet-dis-pdus.h +++ b/epan/dissectors/packet-dis-pdus.h @@ -31,11 +31,16 @@ /* DIS Entity Information / Interaction PDUs */ extern DIS_ParserNode DIS_PARSER_ENTITY_STATE_PDU[]; +/* extern DIS_ParserNode DIS_PARSER_COLLISION_PDU[]; */ /* DIS Warfare PDUs */ extern DIS_ParserNode DIS_PARSER_FIRE_PDU[]; extern DIS_ParserNode DIS_PARSER_DETONATION_PDU[]; +/* DIS Radio Communications protocol (RCP) family PDUs */ +extern DIS_ParserNode DIS_PARSER_TRANSMITTER_PDU[]; +extern DIS_ParserNode DIS_PARSER_SIGNAL_PDU[]; + /* DIS Simulation Management PDUs */ extern DIS_ParserNode DIS_PARSER_START_RESUME_PDU[]; extern DIS_ParserNode DIS_PARSER_STOP_FREEZE_PDU[]; diff --git a/epan/dissectors/packet-dis.c b/epan/dissectors/packet-dis.c index e164f7a954..397a6afbb0 100644 --- a/epan/dissectors/packet-dis.c +++ b/epan/dissectors/packet-dis.c @@ -52,11 +52,96 @@ #define DEFAULT_DIS_UDP_PORT 3000 +/* Encoding type the last 14 bits */ +#define DIS_ENCODING_TYPE(word) ((word) & 0x3FFF) + + static gint proto_dis = -1; +int hf_dis_proto_ver = -1; +int hf_dis_exercise_id = -1; +int hf_dis_pdu_type = -1; +int hf_dis_proto_fam = -1; +int hf_dis_pdu_length = -1; +int hf_dis_entity_id_site = -1; +int hf_dis_entity_id_application = -1; +int hf_dis_entity_id_entity = -1; +int hf_dis_num_art_params = -1; +int hf_dis_radio_id = -1; +int hf_dis_ens = -1; +int hf_dis_ens_class = -1; +int hf_dis_ens_type = -1; +int hf_dis_tdl_type = -1; +int hf_dis_sample_rate = -1; +int hf_dis_data_length = -1; +int hf_dis_num_of_samples = -1; +int hf_dis_signal_data = -1; +int hf_dis_radio_category = -1; +int hf_dis_nomenclature_version = -1; +int hf_dis_nomenclature = -1; +int hf_dis_radio_transmit_state = -1; +int hf_dis_radio_input_source = -1; +int hf_dis_antenna_pattern_type = -1; +int hf_dis_antenna_pattern_length = -1; +int hf_dis_transmit_frequency = -1; +int hf_dis_spread_spectrum_usage = -1; +int hf_dis_frequency_hopping = -1; +int hf_dis_pseudo_noise_modulation = -1; +int hf_dis_time_hopping = -1; +int hf_dis_modulation_major = -1; +int hf_dis_modulation_system = -1; +int hf_dis_crypto_system = -1; +int hf_dis_crypto_key = -1; +int hf_dis_encryption_mode = -1; +int hf_dis_key_identifier = -1; +int hf_dis_modulation_parameter_length = -1; +int hf_dis_mod_param_fh_net_id = -1; +int hf_dis_mod_param_fh_set_id = -1; +int hf_dis_mod_param_fh_lo_set_id = -1; +int hf_dis_mod_param_fh_msg_start = -1; +int hf_dis_mod_param_fh_reserved = -1; +int hf_dis_mod_param_fh_sync_time_offset = -1; +int hf_dis_mod_param_fh_security_key = -1; +int hf_dis_mod_param_fh_clear_channel = -1; +int hf_dis_mod_param_dump = -1; +int hf_dis_mod_param_ts_allocation_mode = -1; +int hf_dis_mod_param_transmitter_prim_mode = -1; +int hf_dis_mod_param_transmitter_second_mode = -1; +int hf_dis_mod_param_sync_state = -1; +int hf_dis_mod_param_network_sync_id = -1; +int hf_dis_antenna_pattern_parameter_dump = -1; + +/* Initialize the subtree pointers */ static gint ett_dis = -1; static gint ett_dis_header = -1; static gint ett_dis_po_header = -1; static gint ett_dis_payload = -1; +int ett_dis_ens = -1; +int ett_dis_crypto_key = -1; + +static const true_false_string dis_modulation_spread_spectrum = { + "Spread Spectrum modulation in use", + "Spread Spectrum modulation not in use" +}; + +static const true_false_string dis_frequency_hopping_value = { + "Frequency hopping modulation used", + "Frequency hopping modulation not used" +}; + +static const true_false_string dis_encryption_mode_value = { + "diphase encryption mode", + "baseband encryption mode" +}; + +static const true_false_string dis_pseudo_noise_value = { + "Pseudo Noise modulation used", + "Pseudo Noise modulation not used" +}; + +static const true_false_string dis_time_hopping_value = { + "Time hopping modulation used", + "Time hopping modulation not used" +}; static guint dis_udp_port = DEFAULT_DIS_UDP_PORT; @@ -73,6 +158,7 @@ static gint dissect_dis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) proto_item *dis_header_node = 0; proto_item *dis_payload_tree = 0; proto_item *dis_payload_node = 0; + const gchar *infoStrings = 0; gint offset = 0; const gchar *pduString = 0; DIS_ParserNode *pduParser = 0; @@ -93,9 +179,10 @@ static gint dissect_dis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) pduType = DIS_PDUTYPE_OTHER; protocolFamily = DIS_PROTOCOLFAMILY_OTHER; persistentObjectPduType = DIS_PERSISTENT_OBJECT_TYPE_OTHER; - + + /* set the protocol column */ col_set_str(pinfo->cinfo, COL_PROTOCOL, dis_proto_name_short); - + /* Add the top-level DIS node under which the rest of the fields will be * displayed. */ @@ -108,8 +195,14 @@ static gint dissect_dis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) dis_header_node = proto_tree_add_text(dis_tree, tvb, offset, -1, "Header"); dis_header_tree = proto_item_add_subtree(dis_header_node, ett_dis_header); offset = parseFields(tvb, dis_header_tree, offset, DIS_FIELDS_PDU_HEADER); + proto_item_set_end(dis_header_node, tvb, offset); + /* Locate the string name for the PDU type enumeration, + * or default to "Unknown". + */ + pduString = val_to_str(pduType, DIS_PDU_Type_Strings, "Unknown"); + /* Locate the appropriate PDU parser, if type is known. */ switch (protocolFamily) @@ -173,10 +266,6 @@ static gint dissect_dis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) } break; default: - /* Locate the string name for the PDU type enumeration, - * or default to "Unknown". - */ - pduString = val_to_str(pduType, DIS_PDU_Type_Strings, "Unknown"); /* Add a node to contain the DIS PDU fields. */ @@ -190,12 +279,20 @@ static gint dissect_dis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) pduParser = DIS_PARSER_ENTITY_STATE_PDU; break; + /* DIS Radio Communications protocol (RCP) family PDUs */ + case DIS_PDUTYPE_TRANSMITTER: + pduParser = DIS_PARSER_TRANSMITTER_PDU; + break; + case DIS_PDUTYPE_SIGNAL: + pduParser = DIS_PARSER_SIGNAL_PDU; + break; + /* DIS Warfare PDUs */ case DIS_PDUTYPE_FIRE: pduParser = DIS_PARSER_FIRE_PDU; break; case DIS_PDUTYPE_DETONATION: - if ( protocolVersion < DIS_VERSION_IEEE_1278_1_200X ) + if ( disProtocolVersion < DIS_VERSION_IEEE_1278_1_200X ) { pduParser = DIS_PARSER_DETONATION_PDU; } @@ -289,8 +386,51 @@ static gint dissect_dis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) dis_payload_tree = proto_item_add_subtree(dis_payload_node, ett_dis_payload); offset = parseFields(tvb, dis_payload_tree, offset, pduParser); + proto_item_set_end(dis_payload_node, tvb, offset); } + + /* add detail to the INFO column if avalaible */ + if ( check_col( pinfo->cinfo, COL_INFO) ) { + + switch (pduType) + { + /* DIS Entity Information / Interaction PDUs */ + case DIS_PDUTYPE_ENTITY_STATE: + col_add_fstr( pinfo->cinfo, COL_INFO, + "PDUType: %s, %s, %s", + pduString, + val_to_str(entityKind, DIS_PDU_EntityKind_Strings, "Unknown Entity Kind"), + val_to_str(entityDomain, DIS_PDU_Domain_Strings, "Unknown Entity Domain") + ); + break; + + case DIS_PDUTYPE_SIGNAL: + col_add_fstr( pinfo->cinfo, COL_INFO, + "PDUType: %s, RadioID=%u, Encoding Type=%s, Number of Samples=%u", + pduString, + radioID, + val_to_str(DIS_ENCODING_TYPE(encodingScheme), DIS_PDU_Encoding_Type_Strings, "Unknown Encoding Type"), + numSamples + ); + break; + case DIS_PDUTYPE_TRANSMITTER: + col_add_fstr( pinfo->cinfo, COL_INFO, + "PDUType: %s, RadioID=%u, Transmit State=%s", + pduString, + radioID, + val_to_str(disRadioTransmitState, DIS_PDU_RadioTransmitState_Strings, "Unknown Transmit State") + ); + break; + default: + /* set the basic info column (pdu type) */ + col_add_fstr( pinfo->cinfo, COL_INFO, + "PDUType: %s", + pduString); + break; + } + } + return tvb_length(tvb); } @@ -300,20 +440,287 @@ void proto_reg_handoff_dis(void); void proto_register_dis(void) { - /* Only these 3 ett variables will be present for every DIS PDU -- - * the rest are dynamic based on PDU type. - */ + +/* registration with the filtering engine */ + static hf_register_info hf[] = + { + { &hf_dis_proto_ver, + { "Proto version", "dis.proto_ver", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_ProtocolVersion_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_exercise_id, + { "Excercise ID", "dis.exer_id", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_pdu_type, + { "PDU type", "dis.pdu_type", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_Type_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_proto_fam, + { "Proto Family", "dis.proto_fam", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_ProtocolFamily_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_pdu_length, + { "PDU Length", "dis.pdu_length", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_entity_id_site, + { "Entity ID Site", "dis.entity_id_site", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_entity_id_application, + { "Entity ID Application", "dis.entity_id_application", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_entity_id_entity, + { "Entity ID Entity", "dis.entity_id_entity", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_num_art_params, + { "Number of Articulation Parameters", "dis.num_articulation_params", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_radio_id, + { "Radio ID", "dis.radio.radio_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_ens, + { "Encoding Scheme", "dis.radio.encoding_scheme", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_ens_class, + { "Encoding Class", "dis.radio.encoding_class", + FT_UINT16, BASE_DEC, VALS(DIS_PDU_Encoding_Class_Strings), 0xc000, + NULL, HFILL } + }, + { &hf_dis_ens_type, + { "Encoding Type", "dis.radio.encoding_type", + FT_UINT16, BASE_DEC, VALS(DIS_PDU_Encoding_Type_Strings), 0x3fff, + NULL, HFILL } + }, + { &hf_dis_tdl_type, + { "TDL Type", "dis.radio.tdl_type", + FT_UINT16, BASE_DEC, VALS(DIS_PDU_TDL_Type_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_sample_rate, + { "Sample Rate", "dis.radio.sample_rate", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_data_length, + { "Data Length", "dis.radio.data_length", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_num_of_samples, + { "Number of Samples", "dis.radio.num_of_samples", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_signal_data, + {"Data", "dis.radio.signal_data", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL} + }, + { &hf_dis_radio_category, + { "Radio Category", "dis.radio.radio_category", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_RadioCategory_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_nomenclature_version, + { "Nomenclature Version", "dis.radio.nomenclature_version", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_NomenclatureVersion_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_nomenclature, + { "Nomenclature", "dis.radio.nomenclature", + FT_UINT16, BASE_DEC, VALS(DIS_PDU_Nomenclature_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_radio_transmit_state, + { "Radio Transmit State", "dis.radio.transmit_state", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_RadioTransmitState_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_radio_input_source, + { "Radio Input Source", "dis.radio.input_source", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_RadioInputSource_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_antenna_pattern_type, + { "Antenna Pattern Type", "dis.radio.antenna_pattern_type", + FT_UINT16, BASE_DEC, VALS(DIS_PDU_AntennaPatternType_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_antenna_pattern_length, + { "Antenna Pattern Length", "dis.radio.antenna_pattern_length", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_transmit_frequency, + { "Transmit Frequency (Hz)", "dis.radio.frequency", + FT_UINT64, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_spread_spectrum_usage, + { "Spread Spectrum", "dis.radio.mod_type.spread_spectrum_usage", + FT_BOOLEAN, 16, TFS(&dis_modulation_spread_spectrum),0xFFFF, + NULL, HFILL } + }, + { &hf_dis_frequency_hopping, + { "Frequency Hopping modulation", "dis.radio.mod_type.frequency_hopping", + FT_BOOLEAN, 16, TFS(&dis_frequency_hopping_value),0x0001, + NULL, HFILL } + }, + { &hf_dis_pseudo_noise_modulation, + { "Psuedo noise modulation", "dis.radio.mod_type.pseudo_noise_modulation", + FT_BOOLEAN, 16, TFS(&dis_pseudo_noise_value),0x0002, + NULL, HFILL } + }, + { &hf_dis_time_hopping, + { "Time Hopping modulation", "dis.radio.mod_type.time_hopping", + FT_BOOLEAN, 16, TFS(&dis_time_hopping_value),0x0004, + NULL, HFILL } + }, + { &hf_dis_modulation_major, + { "Major Modulation", "dis.radio.mod_type.major", + FT_UINT16, BASE_DEC, VALS(DIS_PDU_MajorModulation_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_modulation_system, + { "System Modulation", "dis.radio.mod_type.system", + FT_UINT16, BASE_DEC, VALS(DIS_PDU_SystemModulation_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_crypto_system, + { "Crypto System", "dis.radio.crypto_system", + FT_UINT16, BASE_DEC, VALS(DIS_PDU_CryptoSystem_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_crypto_key, + { "Encryption Key", "dis.radio.encryption_key", + FT_UINT16, BASE_HEX, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_encryption_mode, + { "Encryption Mode", "dis.radio.encryption_key.mode", + FT_BOOLEAN, 16, TFS(&dis_encryption_mode_value),0x8000, + NULL, HFILL } + }, + { &hf_dis_key_identifier, + { "Encryption Key ID", "dis.radio.encryption_key.id", + FT_UINT16, BASE_DEC, NULL,0x7FFF, + NULL, HFILL } + }, + { &hf_dis_modulation_parameter_length, + { "Modulation Parameter Length", "dis.radio.mod_param.length", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_fh_net_id, + { "Frequency Hopping Network ID", "dis.radio.mod_param.cctt_cingars.fh_nw_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_fh_set_id, + { "Frequency Set ID", "dis.radio.mod_param.cctt_cingars.fh_set_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_fh_lo_set_id, + { "Frequency Lockout Set ID", "dis.radio.mod_param.cctt_cingars.fh_lo_set_id", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_fh_msg_start, + { "Start of Message", "dis.radio.mod_param.cctt_cingars.fh_msg_start", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_ModParamMsgStart_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_fh_reserved, + { "Reserved", "dis.radio.mod_param.cctt_cingars.fh_reserved", + FT_UINT8, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_fh_sync_time_offset, + { "Sync Time Offset (Seconds)", "dis.radio.mod_param.cctt_cingars.fh_sync_offset", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_fh_security_key, + { "Transmission Security Key", "dis.radio.mod_param.cctt_cingars.fh_securit_key", + FT_UINT16, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_fh_clear_channel, + { "Clear Channel", "dis.radio.mod_param.cctt_cingars.fh_clr_channel", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_ModParamClrChannel_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_dump, + {"Modulation Parameter All", "dis.radio.mod_param.all", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL} + }, + { &hf_dis_mod_param_ts_allocation_mode, + { "Time Slot Allocaton Mode", "dis.radio.mod_param.jtids.ts_alloc_mode", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_TSAllocationFidelity_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_transmitter_prim_mode, + { "Transmitter Primary Mode", "dis.radio.mod_param.jtids.transmitter_primary_mode", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_TerminalPrimaryMode_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_transmitter_second_mode, + { "Transmitter Primary Mode", "dis.radio.mod_param.jtids.transmitter_secondary_mode", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_TerminalSecondaryMode_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_sync_state, + { "Synchronization State", "dis.radio.mod_param.jtids.sync_state", + FT_UINT8, BASE_DEC, VALS(DIS_PDU_ModParamSyncState_Strings), 0x0, + NULL, HFILL } + }, + { &hf_dis_mod_param_network_sync_id, + { "Network Sync ID", "dis.radio.mod_param.jtids.network_sync_id", + FT_UINT32, BASE_DEC, NULL, 0x0, + NULL, HFILL } + }, + { &hf_dis_antenna_pattern_parameter_dump, + {"Antenna Pattern Parameter", "dis.radio.antenna_parameter", + FT_BYTES, BASE_NONE, NULL, 0x0, + NULL, HFILL} + }, + }; + + /* Setup protocol subtree array */ static gint *ett[] = { &ett_dis, &ett_dis_header, &ett_dis_po_header, + &ett_dis_ens, + &ett_dis_crypto_key, &ett_dis_payload }; module_t *dis_module; proto_dis = proto_register_protocol(dis_proto_name, dis_proto_name_short, "dis"); + proto_register_field_array(proto_dis, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); dis_module = prefs_register_protocol(proto_dis, proto_reg_handoff_dis); |