diff options
author | Anders Broman <anders.broman@ericsson.com> | 2005-07-11 22:23:15 +0000 |
---|---|---|
committer | Anders Broman <anders.broman@ericsson.com> | 2005-07-11 22:23:15 +0000 |
commit | a063532343ff5e5f7d4795471ef2b29eaae9e43d (patch) | |
tree | 5939f89af9f4cfb3f31a494f853e89819e60c70a /epan | |
parent | eba6c1a70fdbf900255e5a0c45c90b7d98c443cf (diff) |
From Jeremy j Ouellette:
DIS dissection.
svn path=/trunk/; revision=14899
Diffstat (limited to 'epan')
-rw-r--r-- | epan/dissectors/packet-dis-enums.c | 295 | ||||
-rw-r--r-- | epan/dissectors/packet-dis-enums.h | 306 | ||||
-rw-r--r-- | epan/dissectors/packet-dis-fields.c | 503 | ||||
-rw-r--r-- | epan/dissectors/packet-dis-fields.h | 166 | ||||
-rw-r--r-- | epan/dissectors/packet-dis-pdus.c | 401 | ||||
-rw-r--r-- | epan/dissectors/packet-dis-pdus.h | 49 | ||||
-rw-r--r-- | epan/dissectors/packet-dis.c | 196 |
7 files changed, 1916 insertions, 0 deletions
diff --git a/epan/dissectors/packet-dis-enums.c b/epan/dissectors/packet-dis-enums.c new file mode 100644 index 0000000000..4795636ddc --- /dev/null +++ b/epan/dissectors/packet-dis-enums.c @@ -0,0 +1,295 @@ +/* packet-dis-enums.c + * String definitions for DIS enumerations. + * Copyright 2005, Scientific Research Corporation + * Initial implementation by Jeremy Ouellette <jouellet@scires.com> + * + * Ethereal - Network traffic analyzer + * By Gerald Combs <gerald@ethereal.com> + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "packet-dis-enums.h" +#include <epan/value_string.h> + +const value_string DIS_PDU_ProtocolVersion_Strings[] = +{ + { DIS_VERSION_OTHER, "Other" }, + { DIS_VERSION_1_0, "DIS PDU version 1.0 (May 92)" }, + { DIS_VERSION_IEEE_1278_1993, "IEEE 1278-1993" }, + { DIS_VERSION_2_0_3RD_DRAFT, "DIS PDU version 2.0 - third draft (May 93)" }, + { DIS_VERSION_2_0_4TH_DRAFT, "DIS PDU version 2.0 - fourth draft (revised) March 16, 1994" }, + { DIS_VERSION_IEEE_1278_1_1995, "IEEE 1278.1-1995" }, + { DIS_VERSION_IEEE_1278_1A_1998, "IEEE 1278.1A-1998" }, + { 0, NULL } +}; + +const value_string DIS_PDU_ProtocolFamily_Strings[] = +{ + { DIS_PROTOCOLFAMILY_OTHER, "Other" }, + { DIS_PROTOCOLFAMILY_ENTITY_INFORMATION_INTERACTION, "Entity information / interaction" }, + { DIS_PROTOCOLFAMILY_WARFARE, "Warfare" }, + { DIS_PROTOCOLFAMILY_LOGISTICS, "Logistics" }, + { DIS_PROTOCOLFAMILY_RADIO_COMMUNICATIONS, "Radio communications" }, + { DIS_PROTOCOLFAMILY_SIMULATION_MANAGEMENT, "Simulation management" }, + { DIS_PROTOCOLFAMILY_DISTRIBUTED_EMISSION_REGENERATION, "Distributed emission regeneration" }, + { DIS_PROTOCOLFAMILY_ENTITY_MANAGEMENT, "Entity management" }, + { DIS_PROTOCOLFAMILY_MINEFIELD, "Minefield" }, + { DIS_PROTOCOLFAMILY_SYNTHETIC_ENVIRONMENT, "Synthetic environment" }, + { DIS_PROTOCOLFAMILY_SIMULATION_MANAGEMENT_WITH_RELIABILITY, "Simulation management with reliability" }, + { DIS_PROTOCOLFAMILY_LIVE_ENTITY, "Live entity" }, + { DIS_PROTOCOLFAMILY_NON_REAL_TIME, "Non-real time" }, + { DIS_PROTOCOLFAMILY_EXPERIMENTAL_COMPUTER_GENERATED_FORCES, "Experimental - Computer Generated Forces" }, + { DIS_PROTOCOLFAMILY_PERSISTENT_OBJECT, "Persistent object" }, + { DIS_PROTOCOLFAMILY_EXPERIMENTAL, "Experimental" }, + { 0, NULL } +}; + +const value_string DIS_PDU_Type_Strings[] = +{ + { DIS_PDUTYPE_OTHER, "Other" }, + { DIS_PDUTYPE_ENTITY_STATE, "Entity State" }, + { DIS_PDUTYPE_FIRE, "Fire" }, + { DIS_PDUTYPE_DETONATION, "Detonation" }, + { DIS_PDUTYPE_COLLISION, "Collision" }, + { DIS_PDUTYPE_SERVICE_REQUEST, "Service Request" }, + { DIS_PDUTYPE_RESUPPLY_OFFER, "Resupply Offer" }, + { DIS_PDUTYPE_RESUPPLY_RECEIVED, "Resupply Received" }, + { DIS_PDUTYPE_RESUPPLY_CANCEL, "Resupply Cancel" }, + { DIS_PDUTYPE_REPAIR_COMPLETE, "Repair Complete" }, + { DIS_PDUTYPE_REPAIR_RESPONSE, "Repair Response" }, + { DIS_PDUTYPE_CREATE_ENTITY, "Create Entity" }, + { DIS_PDUTYPE_REMOVE_ENTITY, "Remove Entity" }, + { DIS_PDUTYPE_START_RESUME, "Start / Resume" }, + { DIS_PDUTYPE_STOP_FREEZE, "Stop / Freeze" }, + { DIS_PDUTYPE_ACKNOWLEDGE, "Acknowledge" }, + { DIS_PDUTYPE_ACTION_REQUEST, "Action Request" }, + { DIS_PDUTYPE_ACTION_RESPONSE, "Action Response" }, + { DIS_PDUTYPE_DATA_QUERY, "Data Query" }, + { DIS_PDUTYPE_SET_DATA, "Set Data" }, + { DIS_PDUTYPE_DATA, "Data" }, + { DIS_PDUTYPE_EVENT_REPORT, "Event Report" }, + { DIS_PDUTYPE_COMMENT, "Comment" }, + { DIS_PDUTYPE_ELECTROMAGNETIC_EMISSION, "Electromagnetic Emission" }, + { DIS_PDUTYPE_DESIGNATOR, "Designator" }, + { DIS_PDUTYPE_TRANSMITTER, "Transmitter" }, + { DIS_PDUTYPE_SIGNAL, "Signal" }, + { DIS_PDUTYPE_RECEIVER, "Receiver" }, + { DIS_PDUTYPE_IFF_ATC_NAVAIDS, "IFF / ATC / NAVAIDS" }, + { DIS_PDUTYPE_UNDERWATER_ACOUSTIC, "Underwater Acoustic" }, + { DIS_PDUTYPE_SUPPLEMENTAL_EMISSION_ENTITY_STATE, "Supplemental Emission Entity State" }, + { DIS_PDUTYPE_INTERCOM_SIGNAL, "Intercom Signal" }, + { DIS_PDUTYPE_INTERCOM_CONTROL, "Intercom Control" }, + { DIS_PDUTYPE_AGGREGATE_STATE, "Aggregate State" }, + { DIS_PDUTYPE_IS_GROUP_OF, "IsGroupOf" }, + { DIS_PDUTYPE_TRANSFER_CONTROL, "Transfer Control" }, + { DIS_PDUTYPE_IS_PART_OF, "IsPartOf" }, + { DIS_PDUTYPE_MINEFIELD_STATE, "Minefield State" }, + { DIS_PDUTYPE_MINEFIELD_QUERY, "Minefield Query" }, + { DIS_PDUTYPE_MINEFIELD_DATA, "Minefield Data" }, + { DIS_PDUTYPE_MINEFIELD_RESPONSE_NAK, "Minefield Response NAK" }, + { DIS_PDUTYPE_ENVIRONMENTAL_PROCESS, "Environmental Process" }, + { DIS_PDUTYPE_GRIDDED_DATA, "Gridded Data" }, + { DIS_PDUTYPE_POINT_OBJECT_STATE, "Point Object State" }, + { DIS_PDUTYPE_LINEAR_OBJECT_STATE, "Linear Object State" }, + { DIS_PDUTYPE_AREAL_OBJECT_STATE, "Areal Object State" }, + { DIS_PDUTYPE_TSPI, "TSPI" }, + { DIS_PDUTYPE_APPEARANCE, "Appearance" }, + { DIS_PDUTYPE_ARTICULATED_PARTS, "Articulated Parts" }, + { DIS_PDUTYPE_LE_FIRE, "LE Fire" }, + { DIS_PDUTYPE_LE_DETONATION, "LE Detonation" }, + { DIS_PDUTYPE_CREATE_ENTITY_R, "Create Entity-R" }, + { DIS_PDUTYPE_REMOVE_ENTITY_R, "Remove Entity-R" }, + { DIS_PDUTYPE_START_RESUME_R, "Start / Resume-R" }, + { DIS_PDUTYPE_STOP_FREEZE_R, "Stop / Freeze-R" }, + { DIS_PDUTYPE_ACKNOWLEDGE_R, "Acknowledge-R" }, + { DIS_PDUTYPE_ACTION_REQUEST_R, "Action Request-R" }, + { DIS_PDUTYPE_ACTION_RESPONSE_R, "Action Response-R" }, + { DIS_PDUTYPE_DATA_QUERY_R, "Data Query-R" }, + { DIS_PDUTYPE_SET_DATA_R, "Set Data-R" }, + { DIS_PDUTYPE_DATA_R, "Data-R" }, + { DIS_PDUTYPE_EVENT_REPORT_R, "Event Report-R" }, + { DIS_PDUTYPE_COMMENT_R, "Comment-R" }, + { DIS_PDUTYPE_RECORD_R, "Record-R" }, + { DIS_PDUTYPE_SET_RECORD_R, "Set Record-R" }, + { DIS_PDUTYPE_RECORD_QUERY_R, "Record Query-R" }, + { DIS_PDUTYPE_COLLISION_ELASTIC, "Collision Elastic" }, + { DIS_PDUTYPE_ENTITY_STATE_UPDATE, "Entity State Update" }, + { DIS_PDUTYPE_ANNOUNCE_OBJECT, "Announce Object" }, + { DIS_PDUTYPE_DELETE_OBJECT, "Delete Object" }, + { DIS_PDUTYPE_DESCRIBE_APPLICATION, "Describe Application" }, + { DIS_PDUTYPE_DESCRIBE_EVENT, "Describe Event" }, + { DIS_PDUTYPE_DESCRIBE_OBJECT, "Describe Object" }, + { DIS_PDUTYPE_REQUEST_EVENT, "Request Event" }, + { DIS_PDUTYPE_REQUEST_OBJECT, "Request Object" }, + { 0, NULL } +}; + +const value_string DIS_PDU_EntityKind_Strings[] = +{ + { DIS_ENTITYKIND_OTHER, "Other" }, + { DIS_ENTITYKIND_PLATFORM, "Platform" }, + { DIS_ENTITYKIND_MUNITION, "Munition" }, + { DIS_ENTITYKIND_LIFE_FORM, "Life form" }, + { DIS_ENTITYKIND_ENVIRONMENTAL, "Environmental" }, + { DIS_ENTITYKIND_CULTURAL_FEATURE, "Cultural feature" }, + { DIS_ENTITYKIND_SUPPLY, "Supply" }, + { DIS_ENTITYKIND_RADIO, "Radio" }, + { DIS_ENTITYKIND_EXPENDABLE, "Expendable" }, + { DIS_ENTITYKIND_SENSOR_EMITTER, "Sensor/Emitter" }, + { 0, NULL } +}; + +const value_string DIS_PDU_Domain_Strings[] = +{ + { DIS_DOMAIN_OTHER, "Other" }, + { DIS_DOMAIN_LAND, "Land" }, + { DIS_DOMAIN_AIR, "Air" }, + { DIS_DOMAIN_SURFACE, "Surface" }, + { DIS_DOMAIN_SUBSURFACE, "Sursurface" }, + { DIS_DOMAIN_SPACE, "Space" }, + { 0, NULL } +}; + +const value_string DIS_PDU_Category_LandPlatform_Strings[] = +{ + { DIS_CATEGORY_LANDPLATFORM_OTHER, "Other" }, + { DIS_CATEGORY_LANDPLATFORM_TANK, "Tank" }, + { DIS_CATEGORY_LANDPLATFORM_ARMORED_FIGHTING_VEHICLE, "Armored fighting vehicle" }, + { DIS_CATEGORY_LANDPLATFORM_ARMORED_UTILITY_VEHICLE, "Armored utility vehicle" }, + { DIS_CATEGORY_LANDPLATFORM_SELF_PROPELLED_ARTILLERY, "Self-propelled artillery" }, + { DIS_CATEGORY_LANDPLATFORM_TOWED_ARTILLERY, "Towed artillery" }, + { DIS_CATEGORY_LANDPLATFORM_SMALL_WHEELED_UTILITY_VEHICLE, "Small wheeled utility vehicle" }, + { DIS_CATEGORY_LANDPLATFORM_LARGE_WHEELED_UTILITY_VEHICLE, "Large wheeled utility vehicle" }, + { DIS_CATEGORY_LANDPLATFORM_SMALL_TRACKED_UTILITY_VEHICLE, "Small tracked utility vehicle" }, + { DIS_CATEGORY_LANDPLATFORM_LARGE_TRACKED_UTILITY_VEHICLE, "Large tracked utility vehicle" }, + { DIS_CATEGORY_LANDPLATFORM_MORTAR, "Mortar" }, + { DIS_CATEGORY_LANDPLATFORM_MINE_PLOW, "Mine plow" }, + { DIS_CATEGORY_LANDPLATFORM_MINE_RAKE, "Mine rake" }, + { DIS_CATEGORY_LANDPLATFORM_MINE_ROLLER, "Mine roller" }, + { DIS_CATEGORY_LANDPLATFORM_CARGO_TRAILER, "Cargo trailer" }, + { DIS_CATEGORY_LANDPLATFORM_FUEL_TRAILER, "Fuel trailer" }, + { DIS_CATEGORY_LANDPLATFORM_GENERATOR_TRAILER, "Generator trailer" }, + { DIS_CATEGORY_LANDPLATFORM_WATER_TRAILER, "Water trailer" }, + { DIS_CATEGORY_LANDPLATFORM_ENGINEER_EQUIPMENT, "Engineer equipment" }, + { DIS_CATEGORY_LANDPLATFORM_HEAVY_EQUIPMENT_TRANSPORT_TRAILER, "Heavy equipment transport trailer" }, + { DIS_CATEGORY_LANDPLATFORM_MAINTENANCE_EQUIPMENT_TRAILER, "Maintenance equipment trailer" }, + { DIS_CATEGORY_LANDPLATFORM_LIMBER, "Limber" }, + { DIS_CATEGORY_LANDPLATFORM_CHEMICAL_DECONTAMINATION_TRAILER, "Chemical decontamination trailer" }, + { DIS_CATEGORY_LANDPLATFORM_WARNING_SYSTEM, "Warning system" }, + { DIS_CATEGORY_LANDPLATFORM_TRAIN_ENGINE, "Train engine" }, + { DIS_CATEGORY_LANDPLATFORM_TRAIN_CAR, "Train car" }, + { DIS_CATEGORY_LANDPLATFORM_TRAIN_CABOOSE, "Train caboose" }, + { DIS_CATEGORY_LANDPLATFORM_CIVILIAN_VEHICLE, "Civilian vehicle" }, + { DIS_CATEGORY_LANDPLATFORM_AIR_DEFENSE_MISSILE_DEFENSE_UNIT_EQUIPMENT, "Air defense / missile defense unit equipment" }, + { DIS_CATEGORY_LANDPLATFORM_C3I_SYSTEM, "C3I system" }, + { DIS_CATEGORY_LANDPLATFORM_OPERATIONS_FACILITY, "Operations facility" }, + { DIS_CATEGORY_LANDPLATFORM_INTELLIGENCE_FACILITY, "Intelligence facility" }, + { DIS_CATEGORY_LANDPLATFORM_SURVEILLANCE_FACILITY, "Surveillance facility" }, + { DIS_CATEGORY_LANDPLATFORM_COMMUNICATIONS_FACILITY, "Communications facility" }, + { DIS_CATEGORY_LANDPLATFORM_COMMAND_FACILITY, "Command facility" }, + { DIS_CATEGORY_LANDPLATFORM_C4I_FACILITY, "C4I facility" }, + { DIS_CATEGORY_LANDPLATFORM_CONTROL_FACILITY, "Control facility" }, + { DIS_CATEGORY_LANDPLATFORM_FIRE_CONTROL_FACILITY, "Fire control facility" }, + { DIS_CATEGORY_LANDPLATFORM_MISSILE_DEFENSE_FACILITY, "Missile defense facility" }, + { DIS_CATEGORY_LANDPLATFORM_FIELD_COMMAND_POST, "Field command post" }, + { DIS_CATEGORY_LANDPLATFORM_OBSERVATION_POST, "Field observation post" }, + { 0, NULL } +}; + +const value_string DIS_PDU_Category_AirPlatform_Strings[] = +{ + { DIS_CATEGORY_AIRPLATFORM_OTHER, "Other" }, + { DIS_CATEGORY_AIRPLATFORM_FIGHTER_AIR_DEFENSE, "Fighter / air defense" }, + { DIS_CATEGORY_AIRPLATFORM_ATTACK_STRIKE, "Attack / strike" }, + { DIS_CATEGORY_AIRPLATFORM_BOMBER, "Bomber" }, + { DIS_CATEGORY_AIRPLATFORM_CARGO_TANKER, "Cargo tanker" }, + { DIS_CATEGORY_AIRPLATFORM_ASW_PATROL_OBSERVATION, "ASW / patrol / observation" }, + { DIS_CATEGORY_AIRPLATFORM_ELECTRONIC_WARFARE, "Electronic warfare" }, + { DIS_CATEGORY_AIRPLATFORM_RECONAISSANCE, "Reconaissance" }, + { DIS_CATEGORY_AIRPLATFORM_SURVEILLANCE_C2, "Surveillance / C2" }, + { DIS_CATEGORY_AIRPLATFORM_ATTACK_HELICOPTER, "Attack helicopter" }, + { DIS_CATEGORY_AIRPLATFORM_UTILITY_HELICOPTER, "Utility helicopter" }, + { DIS_CATEGORY_AIRPLATFORM_ANTISUB_WARFARE_PATROL_HELICOPTER, "Antisubmarine warfare / patrol helicopter" }, + { DIS_CATEGORY_AIRPLATFORM_CARGO_HELICOPTER, "Cargo helicopter" }, + { DIS_CATEGORY_AIRPLATFORM_OBSERVATION_HELICOPTER, "Observation helicopter" }, + { DIS_CATEGORY_AIRPLATFORM_SPECIAL_OPERATIONS_HELICOPTER, "Special operations helicopter" }, + { DIS_CATEGORY_AIRPLATFORM_TRAINER, "Trainer" }, + { DIS_CATEGORY_AIRPLATFORM_UNMANNED, "Unmanned" }, + { DIS_CATEGORY_AIRPLATFORM_NON_COMBATANT_COMMERCIAL_AIRCRAFT, "Non-combatant commercial aircraft" }, + { 0, NULL } +}; + +const value_string DIS_PDU_Category_SurfacePlatform_Strings[] = +{ + { DIS_CATEGORY_SURFACEPLATFORM_OTHER, "Other" }, + { 0, NULL} +}; + +const value_string DIS_PDU_Category_SubsurfacePlatform_Strings[] = +{ + { DIS_CATEGORY_SUBSURFACEPLATFORM_OTHER, "Other" }, + { 0, NULL } +}; + +const value_string DIS_PDU_Category_SpacePlatform_Strings[] = +{ + { DIS_CATEGORY_SPACEPLATFORM_OTHER, "Other" }, + { 0, NULL } +}; + +const value_string DIS_PDU_DetonationResult_Strings[] = +{ + { DIS_DETONATION_RESULT_OTHER, "Other" }, + { DIS_DETONATION_RESULT_ENTITY_IMPACT, "Entity impact" }, + { DIS_DETONATION_RESULT_ENTITY_PROXIMATE_DETONATION, "Entity proximate detonation" }, + { DIS_DETONATION_RESULT_GROUND_IMPACT, "Ground impact" }, + { DIS_DETONATION_RESULT_GROUND_PROXIMATE_DETONATION, "Ground proximate detonation" }, + { DIS_DETONATION_RESULT_DETONATION, "Detonation" }, + { DIS_DETONATION_RESULT_NONE_DUD, "None or no detonation (dud)" }, + { DIS_DETONATION_RESULT_HE_HIT_SMALL, "HE hit, small" }, + { DIS_DETONATION_RESULT_HE_HIT_MEDIUM, "HE hit, medium" }, + { DIS_DETONATION_RESULT_HE_HIT_LARGE, "HE hit, large" }, + { DIS_DETONATION_RESULT_ARMOR_PIERCING_HIT, "Armor-piercing hit" }, + { DIS_DETONATION_RESULT_DIRT_BLAST_SMALL, "Dirt blast, small" }, + { DIS_DETONATION_RESULT_DIRT_BLAST_MEDIUM, "Dirt blast, medium" }, + { DIS_DETONATION_RESULT_DIRT_BLAST_LARGE, "Dirt blast, large" }, + { DIS_DETONATION_RESULT_WATER_BLAST_SMALL, "Water blast, small" }, + { DIS_DETONATION_RESULT_WATER_BLAST_MEDIUM, "Water blast, medium" }, + { DIS_DETONATION_RESULT_WATER_BLAST_LARGE, "Water blast, large" }, + { DIS_DETONATION_RESULT_AIR_HIT, "Air hit" }, + { DIS_DETONATION_RESULT_BUILDING_HIT_SMALL, "Building hit, small" }, + { DIS_DETONATION_RESULT_BUILDING_HIT_MEDIUM, "Building hit, medium" }, + { DIS_DETONATION_RESULT_BUILDING_HIT_LARGE, "Building hit, large" }, + { DIS_DETONATION_RESULT_MINE_CLEARING_LINE_CHARGE, "Mine-clearing line charge" }, + { DIS_DETONATION_RESULT_ENVIRONMENT_OBJECT_IMPACT, "Environment object impact" }, + { DIS_DETONATION_RESULT_ENVIRONMENT_OBJECT_PROXIMATE_DETONATION, "Environment object proximate detonation" }, + { DIS_DETONATION_RESULT_WATER_IMPACT, "Water impact" }, + { DIS_DETONATION_RESULT_AIR_BURST, "Air burst" }, + { DIS_DETONATION_RESULT_KILL_WITH_FRAGMENT_TYPE_1, "Kill with fragment type 1" }, + { DIS_DETONATION_RESULT_KILL_WITH_FRAGMENT_TYPE_2, "Kill with fragment type 2" }, + { DIS_DETONATION_RESULT_KILL_WITH_FRAGMENT_TYPE_3, "Kill with fragment type 3" }, + { DIS_DETONATION_RESULT_KILL_WITH_FRAGMENT_TYPE_1_AFTER_FOF, "Kill with fragment type 1 after fly-out failure" }, + { DIS_DETONATION_RESULT_KILL_WITH_FRAGMENT_TYPE_2_AFTER_FOF, "Kill with fragment type 2 after fly-out failure" }, + { DIS_DETONATION_RESULT_MISS_DUE_TO_FOF, "Miss due to fly-out failure" }, + { DIS_DETONATION_RESULT_MISS_DUE_TO_ENDGAME_FAILURE, "Miss due to end-game failure" }, + { DIS_DETONATION_RESULT_MISS_DUE_TO_FOF_AND_ENDGAME_FAILURE, "Miss due to fly-out and end-game failure" }, + { 0, NULL } +}; diff --git a/epan/dissectors/packet-dis-enums.h b/epan/dissectors/packet-dis-enums.h new file mode 100644 index 0000000000..df13af5739 --- /dev/null +++ b/epan/dissectors/packet-dis-enums.h @@ -0,0 +1,306 @@ +/* packet-dis-enums.h + * Enumerated values and string array declarations for DIS enum parsing. + * Copyright 2005, Scientific Research Corporation + * Initial implementation by Jeremy Ouellette <jouellet@scires.com> + * + * Ethereal - Network traffic analyzer + * By Gerald Combs <gerald@ethereal.com> + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __PACKET_DIS_ENUMS_H__ +#define __PACKET_DIS_ENUMS_H__ + +#include <epan/value_string.h> + +typedef enum +{ + DIS_VERSION_OTHER = 0, + DIS_VERSION_1_0 = 1, + DIS_VERSION_IEEE_1278_1993 = 2, + DIS_VERSION_2_0_3RD_DRAFT = 3, + DIS_VERSION_2_0_4TH_DRAFT = 4, + DIS_VERSION_IEEE_1278_1_1995 = 5, + DIS_VERSION_IEEE_1278_1A_1998 = 6 +} DIS_PDU_ProtocolVersion; + +extern const value_string DIS_PDU_ProtocolVersion_Strings[]; + +typedef enum +{ + DIS_PROTOCOLFAMILY_OTHER = 0, + DIS_PROTOCOLFAMILY_ENTITY_INFORMATION_INTERACTION = 1, + DIS_PROTOCOLFAMILY_WARFARE = 2, + DIS_PROTOCOLFAMILY_LOGISTICS = 3, + DIS_PROTOCOLFAMILY_RADIO_COMMUNICATIONS = 4, + DIS_PROTOCOLFAMILY_SIMULATION_MANAGEMENT = 5, + DIS_PROTOCOLFAMILY_DISTRIBUTED_EMISSION_REGENERATION = 6, + DIS_PROTOCOLFAMILY_ENTITY_MANAGEMENT = 7, + DIS_PROTOCOLFAMILY_MINEFIELD = 8, + DIS_PROTOCOLFAMILY_SYNTHETIC_ENVIRONMENT = 9, + DIS_PROTOCOLFAMILY_SIMULATION_MANAGEMENT_WITH_RELIABILITY = 10, + DIS_PROTOCOLFAMILY_LIVE_ENTITY = 11, + DIS_PROTOCOLFAMILY_NON_REAL_TIME = 12, + DIS_PROTOCOLFAMILY_EXPERIMENTAL_COMPUTER_GENERATED_FORCES = 129, + DIS_PROTOCOLFAMILY_PERSISTENT_OBJECT = 140, + DIS_PROTOCOLFAMILY_EXPERIMENTAL = 150 +} DIS_PDU_ProtocolFamily; + +extern const value_string DIS_PDU_ProtocolFamily_Strings[]; + +typedef enum +{ + DIS_PDUTYPE_OTHER = 0, + DIS_PDUTYPE_ENTITY_STATE = 1, + DIS_PDUTYPE_FIRE = 2, + DIS_PDUTYPE_DETONATION = 3, + DIS_PDUTYPE_COLLISION = 4, + DIS_PDUTYPE_SERVICE_REQUEST = 5, + DIS_PDUTYPE_RESUPPLY_OFFER = 6, + DIS_PDUTYPE_RESUPPLY_RECEIVED = 7, + DIS_PDUTYPE_RESUPPLY_CANCEL = 8, + DIS_PDUTYPE_REPAIR_COMPLETE = 9, + DIS_PDUTYPE_REPAIR_RESPONSE = 10, + DIS_PDUTYPE_CREATE_ENTITY = 11, + DIS_PDUTYPE_REMOVE_ENTITY = 12, + DIS_PDUTYPE_START_RESUME = 13, + DIS_PDUTYPE_STOP_FREEZE = 14, + DIS_PDUTYPE_ACKNOWLEDGE = 15, + DIS_PDUTYPE_ACTION_REQUEST = 16, + DIS_PDUTYPE_ACTION_RESPONSE = 17, + DIS_PDUTYPE_DATA_QUERY = 18, + DIS_PDUTYPE_SET_DATA = 19, + DIS_PDUTYPE_DATA = 20, + DIS_PDUTYPE_EVENT_REPORT = 21, + DIS_PDUTYPE_COMMENT = 22, + DIS_PDUTYPE_ELECTROMAGNETIC_EMISSION = 23, + DIS_PDUTYPE_DESIGNATOR = 24, + DIS_PDUTYPE_TRANSMITTER = 25, + DIS_PDUTYPE_SIGNAL = 26, + DIS_PDUTYPE_RECEIVER = 27, + DIS_PDUTYPE_IFF_ATC_NAVAIDS = 28, + DIS_PDUTYPE_UNDERWATER_ACOUSTIC = 29, + DIS_PDUTYPE_SUPPLEMENTAL_EMISSION_ENTITY_STATE = 30, + DIS_PDUTYPE_INTERCOM_SIGNAL = 31, + DIS_PDUTYPE_INTERCOM_CONTROL = 32, + DIS_PDUTYPE_AGGREGATE_STATE = 33, + DIS_PDUTYPE_IS_GROUP_OF = 34, + DIS_PDUTYPE_TRANSFER_CONTROL = 35, + DIS_PDUTYPE_IS_PART_OF = 36, + DIS_PDUTYPE_MINEFIELD_STATE = 37, + DIS_PDUTYPE_MINEFIELD_QUERY = 38, + DIS_PDUTYPE_MINEFIELD_DATA = 39, + DIS_PDUTYPE_MINEFIELD_RESPONSE_NAK = 40, + DIS_PDUTYPE_ENVIRONMENTAL_PROCESS = 41, + DIS_PDUTYPE_GRIDDED_DATA = 42, + DIS_PDUTYPE_POINT_OBJECT_STATE = 43, + DIS_PDUTYPE_LINEAR_OBJECT_STATE = 44, + DIS_PDUTYPE_AREAL_OBJECT_STATE = 45, + DIS_PDUTYPE_TSPI = 46, + DIS_PDUTYPE_APPEARANCE = 47, + DIS_PDUTYPE_ARTICULATED_PARTS = 48, + DIS_PDUTYPE_LE_FIRE = 49, + DIS_PDUTYPE_LE_DETONATION = 50, + DIS_PDUTYPE_CREATE_ENTITY_R = 51, + DIS_PDUTYPE_REMOVE_ENTITY_R = 52, + DIS_PDUTYPE_START_RESUME_R = 53, + DIS_PDUTYPE_STOP_FREEZE_R = 54, + DIS_PDUTYPE_ACKNOWLEDGE_R = 55, + DIS_PDUTYPE_ACTION_REQUEST_R = 56, + DIS_PDUTYPE_ACTION_RESPONSE_R = 57, + DIS_PDUTYPE_DATA_QUERY_R = 58, + DIS_PDUTYPE_SET_DATA_R = 59, + DIS_PDUTYPE_DATA_R = 60, + DIS_PDUTYPE_EVENT_REPORT_R = 61, + DIS_PDUTYPE_COMMENT_R = 62, + DIS_PDUTYPE_RECORD_R = 63, + DIS_PDUTYPE_SET_RECORD_R = 64, + DIS_PDUTYPE_RECORD_QUERY_R = 65, + DIS_PDUTYPE_COLLISION_ELASTIC = 66, + DIS_PDUTYPE_ENTITY_STATE_UPDATE = 67, + DIS_PDUTYPE_ANNOUNCE_OBJECT = 129, + DIS_PDUTYPE_DELETE_OBJECT = 130, + DIS_PDUTYPE_DESCRIBE_APPLICATION = 131, + DIS_PDUTYPE_DESCRIBE_EVENT = 132, + DIS_PDUTYPE_DESCRIBE_OBJECT = 133, + DIS_PDUTYPE_REQUEST_EVENT = 134, + DIS_PDUTYPE_REQUEST_OBJECT = 135 +} DIS_PDU_Type; + +extern const value_string DIS_PDU_Type_Strings[]; + +typedef enum +{ + DIS_ENTITYKIND_OTHER = 0, + DIS_ENTITYKIND_PLATFORM = 1, + DIS_ENTITYKIND_MUNITION = 2, + DIS_ENTITYKIND_LIFE_FORM = 3, + DIS_ENTITYKIND_ENVIRONMENTAL = 4, + DIS_ENTITYKIND_CULTURAL_FEATURE = 5, + DIS_ENTITYKIND_SUPPLY = 6, + DIS_ENTITYKIND_RADIO = 7, + DIS_ENTITYKIND_EXPENDABLE = 8, + DIS_ENTITYKIND_SENSOR_EMITTER = 9 +} DIS_PDU_EntityKind; + +extern const value_string DIS_PDU_EntityKind_Strings[]; + +typedef enum +{ + DIS_DOMAIN_OTHER = 0, + DIS_DOMAIN_LAND = 1, + DIS_DOMAIN_AIR = 2, + DIS_DOMAIN_SURFACE = 3, + DIS_DOMAIN_SUBSURFACE = 4, + DIS_DOMAIN_SPACE = 5 +} DIS_PDU_Domain; + +extern const value_string DIS_PDU_Domain_Strings[]; + +typedef enum +{ + DIS_CATEGORY_LANDPLATFORM_OTHER = 0, + DIS_CATEGORY_LANDPLATFORM_TANK = 1, + DIS_CATEGORY_LANDPLATFORM_ARMORED_FIGHTING_VEHICLE = 2, + DIS_CATEGORY_LANDPLATFORM_ARMORED_UTILITY_VEHICLE = 3, + DIS_CATEGORY_LANDPLATFORM_SELF_PROPELLED_ARTILLERY = 4, + DIS_CATEGORY_LANDPLATFORM_TOWED_ARTILLERY = 5, + DIS_CATEGORY_LANDPLATFORM_SMALL_WHEELED_UTILITY_VEHICLE = 6, + DIS_CATEGORY_LANDPLATFORM_LARGE_WHEELED_UTILITY_VEHICLE = 7, + DIS_CATEGORY_LANDPLATFORM_SMALL_TRACKED_UTILITY_VEHICLE = 8, + DIS_CATEGORY_LANDPLATFORM_LARGE_TRACKED_UTILITY_VEHICLE = 9, + DIS_CATEGORY_LANDPLATFORM_MORTAR = 10, + DIS_CATEGORY_LANDPLATFORM_MINE_PLOW = 11, + DIS_CATEGORY_LANDPLATFORM_MINE_RAKE = 12, + DIS_CATEGORY_LANDPLATFORM_MINE_ROLLER = 13, + DIS_CATEGORY_LANDPLATFORM_CARGO_TRAILER = 14, + DIS_CATEGORY_LANDPLATFORM_FUEL_TRAILER = 15, + DIS_CATEGORY_LANDPLATFORM_GENERATOR_TRAILER = 16, + DIS_CATEGORY_LANDPLATFORM_WATER_TRAILER = 17, + DIS_CATEGORY_LANDPLATFORM_ENGINEER_EQUIPMENT = 18, + DIS_CATEGORY_LANDPLATFORM_HEAVY_EQUIPMENT_TRANSPORT_TRAILER = 19, + DIS_CATEGORY_LANDPLATFORM_MAINTENANCE_EQUIPMENT_TRAILER = 20, + DIS_CATEGORY_LANDPLATFORM_LIMBER = 21, + DIS_CATEGORY_LANDPLATFORM_CHEMICAL_DECONTAMINATION_TRAILER = 22, + DIS_CATEGORY_LANDPLATFORM_WARNING_SYSTEM = 23, + DIS_CATEGORY_LANDPLATFORM_TRAIN_ENGINE = 24, + DIS_CATEGORY_LANDPLATFORM_TRAIN_CAR = 25, + DIS_CATEGORY_LANDPLATFORM_TRAIN_CABOOSE = 26, + DIS_CATEGORY_LANDPLATFORM_CIVILIAN_VEHICLE = 27, + DIS_CATEGORY_LANDPLATFORM_AIR_DEFENSE_MISSILE_DEFENSE_UNIT_EQUIPMENT = 28, + DIS_CATEGORY_LANDPLATFORM_C3I_SYSTEM = 29, + DIS_CATEGORY_LANDPLATFORM_OPERATIONS_FACILITY = 30, + DIS_CATEGORY_LANDPLATFORM_INTELLIGENCE_FACILITY = 31, + DIS_CATEGORY_LANDPLATFORM_SURVEILLANCE_FACILITY = 32, + DIS_CATEGORY_LANDPLATFORM_COMMUNICATIONS_FACILITY = 33, + DIS_CATEGORY_LANDPLATFORM_COMMAND_FACILITY = 34, + DIS_CATEGORY_LANDPLATFORM_C4I_FACILITY = 35, + DIS_CATEGORY_LANDPLATFORM_CONTROL_FACILITY = 36, + DIS_CATEGORY_LANDPLATFORM_FIRE_CONTROL_FACILITY = 37, + DIS_CATEGORY_LANDPLATFORM_MISSILE_DEFENSE_FACILITY = 38, + DIS_CATEGORY_LANDPLATFORM_FIELD_COMMAND_POST = 39, + DIS_CATEGORY_LANDPLATFORM_OBSERVATION_POST = 40 +} DIS_PDU_Category_LandPlatform; + +extern const value_string DIS_PDU_Category_LandPlatform_Strings[]; + +typedef enum +{ + DIS_CATEGORY_AIRPLATFORM_OTHER = 0, + DIS_CATEGORY_AIRPLATFORM_FIGHTER_AIR_DEFENSE = 1, + DIS_CATEGORY_AIRPLATFORM_ATTACK_STRIKE = 2, + DIS_CATEGORY_AIRPLATFORM_BOMBER = 3, + DIS_CATEGORY_AIRPLATFORM_CARGO_TANKER = 4, + DIS_CATEGORY_AIRPLATFORM_ASW_PATROL_OBSERVATION = 5, + DIS_CATEGORY_AIRPLATFORM_ELECTRONIC_WARFARE = 6, + DIS_CATEGORY_AIRPLATFORM_RECONAISSANCE = 7, + DIS_CATEGORY_AIRPLATFORM_SURVEILLANCE_C2 = 8, + DIS_CATEGORY_AIRPLATFORM_ATTACK_HELICOPTER = 20, + DIS_CATEGORY_AIRPLATFORM_UTILITY_HELICOPTER = 21, + DIS_CATEGORY_AIRPLATFORM_ANTISUB_WARFARE_PATROL_HELICOPTER = 22, + DIS_CATEGORY_AIRPLATFORM_CARGO_HELICOPTER = 23, + DIS_CATEGORY_AIRPLATFORM_OBSERVATION_HELICOPTER = 24, + DIS_CATEGORY_AIRPLATFORM_SPECIAL_OPERATIONS_HELICOPTER = 25, + DIS_CATEGORY_AIRPLATFORM_TRAINER = 40, + DIS_CATEGORY_AIRPLATFORM_UNMANNED = 50, + DIS_CATEGORY_AIRPLATFORM_NON_COMBATANT_COMMERCIAL_AIRCRAFT = 57 +} DIS_PDU_Category_AirPlatform; + +extern const value_string DIS_PDU_Category_AirPlatform_Strings[]; + +typedef enum +{ + DIS_CATEGORY_SURFACEPLATFORM_OTHER = 0, +} DIS_PDU_Category_SurfacePlatform; + +extern const value_string DIS_PDU_Category_SurfacePlatform_Strings[]; + +typedef enum +{ + DIS_CATEGORY_SUBSURFACEPLATFORM_OTHER = 0 +} DIS_PDU_Category_SubsurfacePlatform; + +extern const value_string DIS_PDU_Category_SubsurfacePlatform_Strings[]; + +typedef enum +{ + DIS_CATEGORY_SPACEPLATFORM_OTHER = 0 +} DIS_PDU_Category_SpacePlatform; + +extern const value_string DIS_PDU_Category_SpacePlatform_Strings[]; + +typedef enum +{ + DIS_DETONATION_RESULT_OTHER = 0, + DIS_DETONATION_RESULT_ENTITY_IMPACT = 1, + DIS_DETONATION_RESULT_ENTITY_PROXIMATE_DETONATION = 2, + DIS_DETONATION_RESULT_GROUND_IMPACT = 3, + DIS_DETONATION_RESULT_GROUND_PROXIMATE_DETONATION = 4, + DIS_DETONATION_RESULT_DETONATION = 5, + DIS_DETONATION_RESULT_NONE_DUD = 6, + DIS_DETONATION_RESULT_HE_HIT_SMALL = 7, + DIS_DETONATION_RESULT_HE_HIT_MEDIUM = 8, + DIS_DETONATION_RESULT_HE_HIT_LARGE = 9, + DIS_DETONATION_RESULT_ARMOR_PIERCING_HIT = 10, + DIS_DETONATION_RESULT_DIRT_BLAST_SMALL = 11, + DIS_DETONATION_RESULT_DIRT_BLAST_MEDIUM = 12, + DIS_DETONATION_RESULT_DIRT_BLAST_LARGE = 13, + DIS_DETONATION_RESULT_WATER_BLAST_SMALL = 14, + DIS_DETONATION_RESULT_WATER_BLAST_MEDIUM = 15, + DIS_DETONATION_RESULT_WATER_BLAST_LARGE = 16, + DIS_DETONATION_RESULT_AIR_HIT = 17, + DIS_DETONATION_RESULT_BUILDING_HIT_SMALL = 18, + DIS_DETONATION_RESULT_BUILDING_HIT_MEDIUM = 19, + DIS_DETONATION_RESULT_BUILDING_HIT_LARGE = 20, + DIS_DETONATION_RESULT_MINE_CLEARING_LINE_CHARGE = 21, + DIS_DETONATION_RESULT_ENVIRONMENT_OBJECT_IMPACT = 22, + DIS_DETONATION_RESULT_ENVIRONMENT_OBJECT_PROXIMATE_DETONATION = 23, + DIS_DETONATION_RESULT_WATER_IMPACT = 24, + DIS_DETONATION_RESULT_AIR_BURST = 25, + DIS_DETONATION_RESULT_KILL_WITH_FRAGMENT_TYPE_1 = 26, + DIS_DETONATION_RESULT_KILL_WITH_FRAGMENT_TYPE_2 = 27, + DIS_DETONATION_RESULT_KILL_WITH_FRAGMENT_TYPE_3 = 28, + DIS_DETONATION_RESULT_KILL_WITH_FRAGMENT_TYPE_1_AFTER_FOF = 29, + DIS_DETONATION_RESULT_KILL_WITH_FRAGMENT_TYPE_2_AFTER_FOF = 30, + DIS_DETONATION_RESULT_MISS_DUE_TO_FOF = 31, + DIS_DETONATION_RESULT_MISS_DUE_TO_ENDGAME_FAILURE = 32, + DIS_DETONATION_RESULT_MISS_DUE_TO_FOF_AND_ENDGAME_FAILURE = 33 +} DIS_PDU_DetonationResult; + +extern const value_string DIS_PDU_DetonationResult_Strings[]; + +#endif /* packet-dis-enums.h */ diff --git a/epan/dissectors/packet-dis-fields.c b/epan/dissectors/packet-dis-fields.c new file mode 100644 index 0000000000..52e34b7e3a --- /dev/null +++ b/epan/dissectors/packet-dis-fields.c @@ -0,0 +1,503 @@ +/* packet-dis-fields.c + * Routines and definitions for DIS field parsing. + * Copyright 2005, Scientific Research Corporation + * Initial implementation by Jeremy Ouellette <jouellet@scires.com> + * + * Ethereal - Network traffic analyzer + * By Gerald Combs <gerald@ethereal.com> + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <string.h> +#include <epan/packet.h> +#include "packet-dis-fields.h" +#include "packet-dis-enums.h" + +guint32 pduType; +guint32 entityKind; +guint32 entityDomain; + +DIS_ParserNode DIS_FIELDS_PDU_HEADER[] = +{ + { DIS_FIELDTYPE_PROTOCOL_VERSION, "Protocol Version",0,0,0 }, + { DIS_FIELDTYPE_UINT8, "Exercise ID",0,0,0 }, + { DIS_FIELDTYPE_PDU_TYPE, "PDU Type",0,0,&pduType }, + { DIS_FIELDTYPE_PROTOCOL_FAMILY, "Protocol Family",0,0,0 }, + { DIS_FIELDTYPE_TIMESTAMP, "Timestamp",0,0,0 }, + { DIS_FIELDTYPE_UINT16, "Length",0,0,0 }, + { DIS_FIELDTYPE_PAD16, "Padding",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +DIS_ParserNode DIS_FIELDS_ENTITY_ID[] = +{ + { DIS_FIELDTYPE_UINT16, "Site",0,0,0 }, + { DIS_FIELDTYPE_UINT16, "Application",0,0,0 }, + { DIS_FIELDTYPE_UINT16, "Entity",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +DIS_ParserNode DIS_FIELDS_ENTITY_TYPE[] = +{ + { DIS_FIELDTYPE_ENTITY_KIND, "Entity Kind",0,0,&entityKind }, + { DIS_FIELDTYPE_DOMAIN, "Domain",0,0,&entityDomain }, + { DIS_FIELDTYPE_COUNTRY, "Country",0,0,0 }, + { DIS_FIELDTYPE_CATEGORY, "Category",0,0,0 }, + { DIS_FIELDTYPE_SUBCATEGORY, "Subcategory",0,0,0 }, + { DIS_FIELDTYPE_SPECIFIC, "Specific",0,0,0 }, + { DIS_FIELDTYPE_EXTRA, "Extra",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +DIS_ParserNode DIS_FIELDS_EVENT_ID[] = +{ + { DIS_FIELDTYPE_UINT16, "Site",0,0,0 }, + { DIS_FIELDTYPE_UINT16, "Application",0,0,0 }, + { DIS_FIELDTYPE_UINT16, "Event Number",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +DIS_ParserNode DIS_FIELDS_LINEAR_VELOCITY[] = +{ + { DIS_FIELDTYPE_FLOAT32, "X",0,0,0 }, + { DIS_FIELDTYPE_FLOAT32, "Y",0,0,0 }, + { DIS_FIELDTYPE_FLOAT32, "Z",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +DIS_ParserNode DIS_FIELDS_LOCATION_WORLD[] = +{ + { DIS_FIELDTYPE_FLOAT64, "X",0,0,0 }, + { DIS_FIELDTYPE_FLOAT64, "Y",0,0,0 }, + { DIS_FIELDTYPE_FLOAT64, "Z",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +DIS_ParserNode DIS_FIELDS_LOCATION_ENTITY[] = +{ + { DIS_FIELDTYPE_FLOAT32, "X",0,0,0 }, + { DIS_FIELDTYPE_FLOAT32, "Y",0,0,0 }, + { DIS_FIELDTYPE_FLOAT32, "Z",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +DIS_ParserNode DIS_FIELDS_ORIENTATION[] = +{ + { DIS_FIELDTYPE_FLOAT32, "Psi",0,0,0 }, + { DIS_FIELDTYPE_FLOAT32, "Theta",0,0,0 }, + { DIS_FIELDTYPE_FLOAT32, "Phi",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +DIS_ParserNode DIS_FIELDS_BURST_DESCRIPTOR[] = +{ + { DIS_FIELDTYPE_ENTITY_TYPE, "Munition",0,0,0 }, + { DIS_FIELDTYPE_WARHEAD, "Warhead",0,0,0 }, + { DIS_FIELDTYPE_FUSE, "Fuse",0,0,0 }, + { DIS_FIELDTYPE_UINT16, "Quantity",0,0,0 }, + { DIS_FIELDTYPE_UINT16, "Rate",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +DIS_ParserNode DIS_FIELDS_ARTICULATION_PARAMETER[] = +{ + { DIS_FIELDTYPE_ARTIC_PARAM_TYPE_DESIGNATOR, "Parameter Type Designator",0,0,0 }, + { DIS_FIELDTYPE_UINT8, "Change",0,0,0 }, + { DIS_FIELDTYPE_UINT16, "Part Attached To ID",0,0,0 }, + { DIS_FIELDTYPE_ARTIC_PARAM_TYPE, "Parameter Type",0,0,0 }, + { DIS_FIELDTYPE_UINT64, "Parameter Value",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +DIS_ParserNode DIS_FIELDS_NONE[] = +{ + { DIS_FIELDTYPE_END, NULL, 0,0,0 } +}; + +DIS_BitMask DIS_APPEARANCE_LANDPLATFORM[] = +{ + { 0x00000001, 0, "Paint Scheme", { + { 0, "Uniform color" }, + { 1, "Camouflage" }, + { 0,0 } + } }, + { 0x00000002, 1, "Mobility", { + { 0, "No mobility kill" }, + { 1, "Mobility kill" }, + { 0,0 } + } }, + { 0x00000004, 2, "Fire Power", { + { 0, "No fire-power kill" }, + { 1, "Fire-power kill" }, + { 0,0 } + } }, + { 0x00000018, 3, "Damage", { + { 0, "No damage" }, + { 1, "Slight damage" }, + { 2, "Moderate damage" }, + { 3, "Destroyed" }, + { 0,0 } + } }, + { 0, 0, 0, { + { 0, 0 } + } } +}; + +DIS_BitMask DIS_APPEARANCE_LIFEFORM[] = +{ + { 0x00000001, 0, "Paint Scheme", { + { 0, "Uniform color" }, + { 1, "Camouflage" }, + { 0,0 } + } }, + { 0x00000018, 3, "Health", { + { 0, "No injury" }, + { 1, "Slight injury" }, + { 2, "Moderate injury" }, + { 3, "Fatal injury" }, + { 0,0 } + } }, + { 0, 0, 0, { + { 0, 0 } + } } +}; + +/* Adjust an offset variable for proper alignment for a specified field length. + */ +gint alignOffset(gint offset, guint fieldLength) +{ + gint remainder = offset % fieldLength; + if (remainder != 0) + { + offset += fieldLength - remainder; + } + return offset; +} + +/* Parse a field consisting of a specified number of bytes. This field parser + * doesn't perform any alignment. + */ +gint parseField_Bytes(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode, guint numBytes) +{ + proto_tree_add_text(tree, tvb, offset, numBytes, "%s (%d bytes)", + parserNode.fieldLabel, numBytes); + offset += numBytes; + return offset; +} + +/* Parse a bitmask field. + */ +gint parseField_Bitmask(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode, guint numBytes) +{ + DIS_BitMask *bitMask = 0; + guint64 uintVal = 0; + + offset = alignOffset(offset, numBytes); + + switch(numBytes) + { + case 1: + uintVal = tvb_get_guint8(tvb, offset); + break; + case 2: + uintVal = tvb_get_ntohs(tvb, offset); + break; + case 4: + uintVal = tvb_get_ntohl(tvb, offset); + break; + case 8: + uintVal = tvb_get_ntoh64(tvb, offset); + break; + default: + /* assert */ + break; + } + + switch(parserNode.fieldType) + { + case DIS_FIELDTYPE_APPEARANCE: + if ((entityKind == DIS_ENTITYKIND_PLATFORM) && + (entityDomain == DIS_DOMAIN_LAND)) + { + bitMask = DIS_APPEARANCE_LANDPLATFORM; + } + else if (entityKind == DIS_ENTITYKIND_LIFE_FORM) + { + bitMask = DIS_APPEARANCE_LIFEFORM; + } + break; + default: + break; + } + + if (bitMask != 0) + { + int maskIndex = 0; + while (bitMask[maskIndex].maskBits != 0) + { + int mapIndex = 0; + DIS_BitMaskMapping *bitMaskMap = bitMask[maskIndex].bitMappings; + + while (bitMaskMap[mapIndex].label != 0) + { + if (((bitMask[maskIndex].maskBits & uintVal) >> bitMask[maskIndex].shiftBits) == + bitMaskMap[mapIndex].value) + { + proto_tree_add_text(tree, tvb, offset, numBytes, + "%s = %s", bitMask[maskIndex].label, + bitMaskMap[mapIndex].label); + break; + } + ++mapIndex; + } + ++maskIndex; + } + } + else + { + proto_tree_add_text(tree, tvb, offset, numBytes, + "Unknown Appearance Type (%" PRIu64 ")", uintVal); + } + + offset += numBytes; + + return offset; +} + +/* Parse an unsigned integer field of a specified number of bytes. + */ +gint parseField_UInt(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode, guint numBytes) +{ + guint64 uintVal = 0; + + offset = alignOffset(offset, numBytes); + + switch(numBytes) + { + case 1: + uintVal = tvb_get_guint8(tvb, offset); + break; + case 2: + uintVal = tvb_get_ntohs(tvb, offset); + break; + case 4: + uintVal = tvb_get_ntohl(tvb, offset); + break; + case 8: + uintVal = tvb_get_ntoh64(tvb, offset); + break; + default: + /* assert */ + break; + } + + proto_tree_add_text(tree, tvb, offset, numBytes, "%s = %" PRIu64, + parserNode.fieldLabel, uintVal); + + if (parserNode.outputVar != 0) + { + *(parserNode.outputVar) = (guint32)uintVal; + } + + offset += numBytes; + + return offset; +} + +/* Parse a signed integer field of a specified number of bytes. + */ +gint parseField_Int(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode, guint numBytes) +{ + guint64 uintVal = 0; + + offset = alignOffset(offset, numBytes); + + switch(numBytes) + { + case 1: + uintVal = tvb_get_guint8(tvb, offset); + break; + case 2: + uintVal = tvb_get_ntohs(tvb, offset); + break; + case 4: + uintVal = tvb_get_ntohl(tvb, offset); + break; + case 8: + uintVal = tvb_get_ntoh64(tvb, offset); + break; + default: + /* assert */ + break; + } + + proto_tree_add_text(tree, tvb, offset, numBytes, "%s = %" PRId64, + parserNode.fieldLabel, uintVal); + + offset += numBytes; + + return offset; +} + +/* Parse a field that explicitly specified a number of pad bytes (vs implicit + * padding, which occurs whenever padding is inserted to properly align the + * field. + */ +gint parseField_Pad(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode, guint numBytes) +{ + proto_tree_add_text(tree, tvb, offset, numBytes, + "Explicit Padding (%d bytes)", numBytes); + + offset += numBytes; + + return offset; +} + +/* Parse an enumerated type field. + */ +gint parseField_Enum(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode, guint numBytes) +{ + const value_string *enumStrings = 0; + guint32 enumVal = 0; + const gchar *enumStr = 0; + + offset = alignOffset(offset, numBytes); + + switch(parserNode.fieldType) + { + case DIS_FIELDTYPE_PROTOCOL_VERSION: + enumStrings = DIS_PDU_ProtocolVersion_Strings; + break; + case DIS_FIELDTYPE_PROTOCOL_FAMILY: + enumStrings = DIS_PDU_ProtocolFamily_Strings; + break; + case DIS_FIELDTYPE_PDU_TYPE: + enumStrings = DIS_PDU_Type_Strings; + break; + case DIS_FIELDTYPE_ENTITY_KIND: + enumStrings = DIS_PDU_EntityKind_Strings; + break; + case DIS_FIELDTYPE_DOMAIN: + enumStrings = DIS_PDU_Domain_Strings; + break; + case DIS_FIELDTYPE_DETONATION_RESULT: + enumStrings = DIS_PDU_DetonationResult_Strings; + break; + case DIS_FIELDTYPE_CATEGORY: + if (entityKind == DIS_ENTITYKIND_PLATFORM) + { + switch(entityDomain) + { + case DIS_DOMAIN_LAND: + enumStrings = DIS_PDU_Category_LandPlatform_Strings; + break; + case DIS_DOMAIN_AIR: + enumStrings = DIS_PDU_Category_AirPlatform_Strings; + break; + case DIS_DOMAIN_SURFACE: + enumStrings = DIS_PDU_Category_SurfacePlatform_Strings; + break; + case DIS_DOMAIN_SUBSURFACE: + enumStrings = DIS_PDU_Category_SubsurfacePlatform_Strings; + break; + case DIS_DOMAIN_SPACE: + enumStrings = DIS_PDU_Category_SpacePlatform_Strings; + break; + default: + enumStrings = 0; + break; + } + } + break; + default: + enumStrings = 0; + break; + } + + switch(numBytes) + { + case 1: + enumVal = tvb_get_guint8(tvb, offset); + break; + case 2: + enumVal = tvb_get_ntohs(tvb, offset); + break; + case 4: + enumVal = tvb_get_ntohl(tvb, offset); + break; + default: + /* assert */ + break; + } + + if (enumStrings != 0) + { + enumStr = val_to_str(enumVal, enumStrings, "Unknown Enum Value"); + } + else + { + enumStr = "Unknown Enum Type"; + } + + proto_tree_add_text(tree, tvb, offset, numBytes, "%s = %s", + parserNode.fieldLabel, enumStr); + + if (parserNode.outputVar != 0) + { + *(parserNode.outputVar) = enumVal; + } + + offset += numBytes; + + return offset; +} + +/* Parse a 4-byte floating-point value. + */ +gint parseField_Float(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode) +{ + gfloat floatVal; + + offset = alignOffset(offset, 4); + floatVal = tvb_get_ntohieee_float(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 4, "%s = %f", + parserNode.fieldLabel, 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) +{ + gdouble doubleVal; + + offset = alignOffset(offset, 8); + doubleVal = tvb_get_ntohieee_double(tvb, offset); + proto_tree_add_text(tree, tvb, offset, 8, "%s = %lf", + parserNode.fieldLabel, doubleVal); + + offset += 8; + + return offset; +} diff --git a/epan/dissectors/packet-dis-fields.h b/epan/dissectors/packet-dis-fields.h new file mode 100644 index 0000000000..71dfbd8c30 --- /dev/null +++ b/epan/dissectors/packet-dis-fields.h @@ -0,0 +1,166 @@ +/* packet-dis-fields.h + * Declarations for DIS field parsing. + * Copyright 2005, Scientific Research Corporation + * Initial implementation by Jeremy Ouellette <jouellet@scires.com> + * + * Ethereal - Network traffic analyzer + * By Gerald Combs <gerald@ethereal.com> + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __PACKET_DIS_FIELDPARSERS_H__ +#define __PACKET_DIS_FIELDPARSERS_H__ + +#include <epan/packet.h> + +/* enumeration of all field types used for DIS parsing. */ +typedef enum +{ + /* end marker to indicate the end of a parser sequence */ + DIS_FIELDTYPE_END = 0, + + /* basic numeric types */ + DIS_FIELDTYPE_INT8, + DIS_FIELDTYPE_INT16, + DIS_FIELDTYPE_INT32, + DIS_FIELDTYPE_INT64, + DIS_FIELDTYPE_UINT8, + DIS_FIELDTYPE_UINT16, + DIS_FIELDTYPE_UINT32, + DIS_FIELDTYPE_UINT64, + DIS_FIELDTYPE_FLOAT32, + DIS_FIELDTYPE_FLOAT64, + + /* padding */ + DIS_FIELDTYPE_PAD8, + DIS_FIELDTYPE_PAD16, + DIS_FIELDTYPE_PAD32, + + /* other atomic types, including enumerations */ + DIS_FIELDTYPE_APPEARANCE, + DIS_FIELDTYPE_ARTIC_PARAM_TYPE_DESIGNATOR, + DIS_FIELDTYPE_ARTIC_PARAM_TYPE, + DIS_FIELDTYPE_CAPABILITIES, + DIS_FIELDTYPE_CATEGORY, + DIS_FIELDTYPE_COUNTRY, + DIS_FIELDTYPE_DEAD_RECKONING_PARAMS, + DIS_FIELDTYPE_DEAD_RECKONING_ALGORITHM, + DIS_FIELDTYPE_DEAD_RECKONING_OTHER_PARAMS, + DIS_FIELDTYPE_DETONATION_RESULT, + DIS_FIELDTYPE_DOMAIN, + DIS_FIELDTYPE_ENTITY_KIND, + DIS_FIELDTYPE_ENTITY_MARKING, + DIS_FIELDTYPE_EXTRA, + DIS_FIELDTYPE_FORCE_ID, + DIS_FIELDTYPE_FUSE, + DIS_FIELDTYPE_ORIENTATION, + DIS_FIELDTYPE_PDU_TYPE, + DIS_FIELDTYPE_PROTOCOL_FAMILY, + DIS_FIELDTYPE_PROTOCOL_VERSION, + DIS_FIELDTYPE_SPECIFIC, + DIS_FIELDTYPE_SUBCATEGORY, + DIS_FIELDTYPE_TIMESTAMP, + DIS_FIELDTYPE_WARHEAD, + + /* composite types */ + DIS_FIELDTYPE_ARTICULATION_PARAMETERS, + DIS_FIELDTYPE_BURST_DESCRIPTOR, + DIS_FIELDTYPE_ENTITY_ID, + DIS_FIELDTYPE_ENTITY_TYPE, + DIS_FIELDTYPE_EVENT_ID, + DIS_FIELDTYPE_LINEAR_VELOCITY, + DIS_FIELDTYPE_LOCATION_WORLD, + DIS_FIELDTYPE_LOCATION_ENTITY +} DIS_FieldType; + +/* Struct which contains the data needed to parse a single DIS field. + */ +typedef struct DIS_ParserNode_T +{ + DIS_FieldType fieldType; + const char *fieldLabel; + int ettVar; + struct DIS_ParserNode_T *children; + guint32 *outputVar; +} DIS_ParserNode; + +/* Struct which associates a name with a particular bit combination. + */ +typedef struct +{ + guint32 value; + const char *label; +} DIS_BitMaskMapping; + +/* Struct which specifies all possible bit mappings associated with + * a particular bit mask. + */ +typedef struct +{ + guint32 maskBits; + guint32 shiftBits; + const char *label; + DIS_BitMaskMapping bitMappings[33]; +} DIS_BitMask; + +extern DIS_ParserNode DIS_FIELDS_PDU_HEADER[]; + +extern DIS_ParserNode DIS_FIELDS_ENTITY_ID[]; + +extern DIS_ParserNode DIS_FIELDS_ENTITY_TYPE[]; + +extern DIS_ParserNode DIS_FIELDS_EVENT_ID[]; + +extern DIS_ParserNode DIS_FIELDS_LINEAR_VELOCITY[]; + +extern DIS_ParserNode DIS_FIELDS_LOCATION_WORLD[]; + +extern DIS_ParserNode DIS_FIELDS_LOCATION_ENTITY[]; + +extern DIS_ParserNode DIS_FIELDS_BURST_DESCRIPTOR[]; + +extern DIS_ParserNode DIS_FIELDS_ARTICULATION_PARAMETER[]; + +extern DIS_ParserNode DIS_FIELDS_ORIENTATION[]; + +extern DIS_ParserNode DIS_FIELDS_NONE[]; + +extern DIS_BitMask DIS_APPEARANCE_LANDPLATFORM[]; + +extern DIS_BitMask DIS_APPEARANCE_LIFEFORM[]; + +gint parseField_Bytes(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode, guint numBytes); + +gint parseField_Bitmask(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode, guint numBytes); + +gint parseField_UInt(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode, guint numBytes); + +gint parseField_Int(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode, guint numBytes); + +gint parseField_Enum(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode, guint numBytes); + +gint parseField_Pad(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode, guint numBytes); + +gint parseField_Float(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode); + +gint parseField_Double(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNode); + +extern guint32 pduType; +extern guint32 entityKind; +extern guint32 entityDomain; + +#endif /* packet-dis-fieldparsers.h */ diff --git a/epan/dissectors/packet-dis-pdus.c b/epan/dissectors/packet-dis-pdus.c new file mode 100644 index 0000000000..fb66a8b8d1 --- /dev/null +++ b/epan/dissectors/packet-dis-pdus.c @@ -0,0 +1,401 @@ +/* packet-dis-pdus.c + * Routines and definitions for DIS PDU parsing. + * Copyright 2005, Scientific Research Corporation + * Initial implementation by Jeremy Ouellette <jouellet@scires.com> + * + * Ethereal - Network traffic analyzer + * By Gerald Combs <gerald@ethereal.com> + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <string.h> +#include "packet-dis-pdus.h" +#include "packet-dis-fields.h" + +guint32 numArticulations; +gint ettArticulations[DIS_PDU_MAX_ARTICULATIONS]; + +DIS_ParserNode DIS_PARSER_ENTITY_STATE_PDU[] = +{ + { DIS_FIELDTYPE_ENTITY_ID, "Entity ID",0,0,0 }, + { DIS_FIELDTYPE_FORCE_ID, "Force ID",0,0,0 }, + { DIS_FIELDTYPE_UINT8, "Number of Articulation Parameters",0,0,&numArticulations }, + { DIS_FIELDTYPE_ENTITY_TYPE, "Entity Type",0,0,0 }, + { DIS_FIELDTYPE_ENTITY_TYPE, "Alternative Entity Type",0,0,0 }, + { DIS_FIELDTYPE_LINEAR_VELOCITY, "Entity Linear Velocity",0,0,0 }, + { DIS_FIELDTYPE_LOCATION_WORLD, "Entity Location",0,0,0 }, + { DIS_FIELDTYPE_ORIENTATION, "Entity Orientation",0,0,0 }, + { DIS_FIELDTYPE_APPEARANCE, "Entity Appearance",0,0,0 }, + { DIS_FIELDTYPE_DEAD_RECKONING_PARAMS, "Dead Reckoning Parameters",0,0,0 }, + { DIS_FIELDTYPE_ENTITY_MARKING, "Entity Marking",0,0,0 }, + { DIS_FIELDTYPE_CAPABILITIES, "Capabilities",0,0,0 }, + { DIS_FIELDTYPE_ARTICULATION_PARAMETERS, "Articulation Parameters",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +DIS_ParserNode DIS_PARSER_FIRE_PDU[] = +{ + { DIS_FIELDTYPE_ENTITY_ID, "Firing Entity ID",0,0,0 }, + { DIS_FIELDTYPE_ENTITY_ID, "Target Entity ID",0,0,0 }, + { DIS_FIELDTYPE_ENTITY_ID, "Munition ID",0,0,0 }, + { DIS_FIELDTYPE_EVENT_ID, "Event ID",0,0,0 }, + { DIS_FIELDTYPE_UINT32, "Fire Mission Index",0,0,0 }, + { DIS_FIELDTYPE_LOCATION_WORLD, "Location in World Coordinates",0,0,0 }, + { DIS_FIELDTYPE_BURST_DESCRIPTOR, "Burst Descriptor",0,0,0 }, + { DIS_FIELDTYPE_LINEAR_VELOCITY, "Velocity",0,0,0 }, + { DIS_FIELDTYPE_FLOAT32, "Range",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +DIS_ParserNode DIS_PARSER_DETONATION_PDU[] = +{ + { DIS_FIELDTYPE_ENTITY_ID, "Firing Entity ID",0,0,0 }, + { DIS_FIELDTYPE_ENTITY_ID, "Target Entity ID",0,0,0 }, + { DIS_FIELDTYPE_ENTITY_ID, "Munition ID",0,0,0 }, + { DIS_FIELDTYPE_EVENT_ID, "Event ID",0,0,0 }, + { DIS_FIELDTYPE_LINEAR_VELOCITY, "Velocity",0,0,0 }, + { DIS_FIELDTYPE_LOCATION_WORLD, "Location in World Coordinates",0,0,0 }, + { DIS_FIELDTYPE_BURST_DESCRIPTOR, "Burst Descriptor",0,0,0 }, + { DIS_FIELDTYPE_LOCATION_ENTITY, "Location in Entity Coordinates",0,0,0 }, + { DIS_FIELDTYPE_DETONATION_RESULT, "Detonation Result",0,0,0 }, + { DIS_FIELDTYPE_UINT8, "Number of Articulation Parameters",0,0,0 }, + { DIS_FIELDTYPE_PAD16, "Padding",0,0,0 }, + { DIS_FIELDTYPE_ARTICULATION_PARAMETERS, "Articulation Parameters",0,0,0 }, + { DIS_FIELDTYPE_END, NULL,0,0,0 } +}; + +/* Initialize the parsers for each PDU type and the standard DIS header. + */ +void initializeParsers(void) +{ + initializeParser(DIS_PARSER_ENTITY_STATE_PDU); + initializeParser(DIS_PARSER_FIRE_PDU); + initializeParser(DIS_PARSER_DETONATION_PDU); + initializeParser(DIS_FIELDS_PDU_HEADER); +} + +/* Create a specific subtree for a PDU or a composite PDU field. + */ +DIS_ParserNode *createSubtree(DIS_ParserNode parserNodes[], gint *ettVar) +{ + guint fieldIndex = 0; + guint fieldCount; + gint *ett[1]; + DIS_ParserNode *newSubtree; + + while (parserNodes[fieldIndex].fieldType != DIS_FIELDTYPE_END) + { + ++fieldIndex; + } + + fieldCount = fieldIndex + 1; + + newSubtree = (DIS_ParserNode*)g_malloc(sizeof(DIS_ParserNode) * fieldCount); + + memcpy(newSubtree, parserNodes, sizeof(DIS_ParserNode) * fieldCount); + + initializeParser(newSubtree); + + ett[0] = ettVar; + proto_register_subtree_array(ett, array_length(ett)); + + return newSubtree; +} + +/* Initialize an array of parser nodes. + */ +void initializeParser(DIS_ParserNode parserNodes[]) +{ + guint parserIndex = 0; + + /* Create the parser subtrees for each of the composite field types. + */ + while (parserNodes[parserIndex].fieldType != DIS_FIELDTYPE_END) + { + switch (parserNodes[parserIndex].fieldType) + { + case DIS_FIELDTYPE_APPEARANCE: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_NONE, + &parserNodes[parserIndex].ettVar); + break; + case DIS_FIELDTYPE_ARTICULATION_PARAMETERS: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_ARTICULATION_PARAMETER, + &parserNodes[parserIndex].ettVar); + break; + case DIS_FIELDTYPE_BURST_DESCRIPTOR: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_BURST_DESCRIPTOR, + &parserNodes[parserIndex].ettVar); + break; + case DIS_FIELDTYPE_ENTITY_ID: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_ENTITY_ID, + &parserNodes[parserIndex].ettVar); + break; + case DIS_FIELDTYPE_ENTITY_TYPE: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_ENTITY_TYPE, + &parserNodes[parserIndex].ettVar); + break; + case DIS_FIELDTYPE_EVENT_ID: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_EVENT_ID, + &parserNodes[parserIndex].ettVar); + break; + case DIS_FIELDTYPE_LINEAR_VELOCITY: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_LINEAR_VELOCITY, + &parserNodes[parserIndex].ettVar); + break; + case DIS_FIELDTYPE_LOCATION_WORLD: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_LOCATION_WORLD, + &parserNodes[parserIndex].ettVar); + break; + case DIS_FIELDTYPE_LOCATION_ENTITY: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_LOCATION_ENTITY, + &parserNodes[parserIndex].ettVar); + break; + case DIS_FIELDTYPE_ORIENTATION: + parserNodes[parserIndex].children = createSubtree( + DIS_FIELDS_ORIENTATION, + &parserNodes[parserIndex].ettVar); + break; + default: + break; + } + ++parserIndex; + } +} + +/* Parse packet data based on a specified array of DIS_ParserNodes. + */ +gint parseFields(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNodes[]) +{ + guint fieldIndex = 0; + + while (parserNodes[fieldIndex].fieldType != DIS_FIELDTYPE_END) + { + proto_item *newField = 0; + switch(parserNodes[fieldIndex].fieldType) + { + case DIS_FIELDTYPE_INT8: + offset = parseField_Int(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_INT16: + offset = parseField_Int(tvb, tree, offset, + parserNodes[fieldIndex], 2); + break; + case DIS_FIELDTYPE_INT32: + offset = parseField_Int(tvb, tree, offset, + parserNodes[fieldIndex], 4); + break; + case DIS_FIELDTYPE_INT64: + offset = parseField_Int(tvb, tree, offset, + parserNodes[fieldIndex], 8); + break; + case DIS_FIELDTYPE_UINT8: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_UINT16: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 2); + break; + case DIS_FIELDTYPE_UINT32: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 4); + break; + case DIS_FIELDTYPE_UINT64: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 8); + break; + case DIS_FIELDTYPE_FLOAT32: + offset = parseField_Float(tvb, tree, offset, + parserNodes[fieldIndex]); + break; + case DIS_FIELDTYPE_FLOAT64: + offset = parseField_Double(tvb, tree, offset, + parserNodes[fieldIndex]); + break; + case DIS_FIELDTYPE_PAD8: + offset = parseField_Pad(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_PAD16: + offset = parseField_Pad(tvb, tree, offset, + parserNodes[fieldIndex], 2); + break; + case DIS_FIELDTYPE_PAD32: + offset = parseField_Pad(tvb, tree, offset, + parserNodes[fieldIndex], 4); + break; + case DIS_FIELDTYPE_APPEARANCE: + { + proto_item *newSubtree; + newField = proto_tree_add_text(tree, tvb, offset, 4, + parserNodes[fieldIndex].fieldLabel); + newSubtree = proto_item_add_subtree(newField, + parserNodes[fieldIndex].ettVar); + offset = parseField_Bitmask(tvb, newSubtree, offset, + parserNodes[fieldIndex], 4); + } + break; + case DIS_FIELDTYPE_ARTIC_PARAM_TYPE_DESIGNATOR: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_ARTIC_PARAM_TYPE: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 4); + break; + case DIS_FIELDTYPE_CAPABILITIES: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 4); + break; + case DIS_FIELDTYPE_CATEGORY: + offset = parseField_Enum(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_COUNTRY: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 2); + break; + case DIS_FIELDTYPE_DEAD_RECKONING_PARAMS: + /* This is really a struct... needs a field parser. + * For now, just skip the 12 bytes. + */ + offset = parseField_Bytes(tvb, tree, offset, + parserNodes[fieldIndex], 40); + break; + case DIS_FIELDTYPE_DETONATION_RESULT: + offset = parseField_Enum(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_DOMAIN: + offset = parseField_Enum(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_ENTITY_KIND: + offset = parseField_Enum(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_ENTITY_MARKING: + /* This is really a struct... needs a field parser. + * For now, just skip the 12 bytes. + */ + offset = parseField_Bytes(tvb, tree, offset, + parserNodes[fieldIndex], 12); + break; + case DIS_FIELDTYPE_EXTRA: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_FORCE_ID: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_FUSE: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 2); + break; + case DIS_FIELDTYPE_PDU_TYPE: + offset = parseField_Enum(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_PROTOCOL_FAMILY: + offset = parseField_Enum(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_PROTOCOL_VERSION: + offset = parseField_Enum(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_SPECIFIC: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_SUBCATEGORY: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 1); + break; + case DIS_FIELDTYPE_TIMESTAMP: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 4); + break; + case DIS_FIELDTYPE_WARHEAD: + offset = parseField_UInt(tvb, tree, offset, + parserNodes[fieldIndex], 2); + break; + case DIS_FIELDTYPE_BURST_DESCRIPTOR: + case DIS_FIELDTYPE_ENTITY_ID: + case DIS_FIELDTYPE_EVENT_ID: + case DIS_FIELDTYPE_LINEAR_VELOCITY: + case DIS_FIELDTYPE_LOCATION_WORLD: + case DIS_FIELDTYPE_LOCATION_ENTITY: + case DIS_FIELDTYPE_ENTITY_TYPE: + case DIS_FIELDTYPE_ORIENTATION: + newField = proto_tree_add_text(tree, tvb, offset, -1, + parserNodes[fieldIndex].fieldLabel); + if (parserNodes[fieldIndex].children != 0) + { + proto_item *newSubtree = proto_item_add_subtree(newField, + parserNodes[fieldIndex].ettVar); + offset = parseFields(tvb, newSubtree, offset, + parserNodes[fieldIndex].children); + } + proto_item_set_end(newField, tvb, offset); + break; + case DIS_FIELDTYPE_ARTICULATION_PARAMETERS: + { + guint i; + + if (numArticulations > DIS_PDU_MAX_ARTICULATIONS) + { + numArticulations = DIS_PDU_MAX_ARTICULATIONS; + } + + for (i = 0; i < numArticulations; ++i) + { + proto_item *newSubtree; + newField = proto_tree_add_text(tree, tvb, offset, -1, + parserNodes[fieldIndex].fieldLabel); + newSubtree = proto_item_add_subtree(newField, + ettArticulations[i]); + offset = parseFields(tvb, newSubtree, offset, + parserNodes[fieldIndex].children); + proto_item_set_end(newField, tvb, offset); + } + } + break; + default: + break; + } + + ++fieldIndex; + } + + return offset; +} diff --git a/epan/dissectors/packet-dis-pdus.h b/epan/dissectors/packet-dis-pdus.h new file mode 100644 index 0000000000..4222bac5fc --- /dev/null +++ b/epan/dissectors/packet-dis-pdus.h @@ -0,0 +1,49 @@ +/* packet-dis-pdus.h + * Declarations for DIS PDU parsing. + * Copyright 2005, Scientific Research Corporation + * Initial implementation by Jeremy Ouellette <jouellet@scires.com> + * + * Ethereal - Network traffic analyzer + * By Gerald Combs <gerald@ethereal.com> + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __PACKET_DIS_PDUPARSERS_H__ +#define __PACKET_DIS_PDUPARSERS_H__ + +#include "packet-dis-fields.h" + +extern DIS_ParserNode DIS_PARSER_ENTITY_STATE_PDU[]; + +extern DIS_ParserNode DIS_PARSER_FIRE_PDU[]; + +extern DIS_ParserNode DIS_PARSER_DETONATION_PDU[]; + +DIS_ParserNode *createSubtree(DIS_ParserNode parserNodes[], gint *ettVar); + +void initializeParser(DIS_ParserNode parserNodes[]); + +void initializeParsers(void); + +gint parseFields(tvbuff_t *tvb, proto_tree *tree, gint offset, DIS_ParserNode parserNodes[]); + +extern guint32 numArticulations; +extern int ettArticulations[]; + +#define DIS_PDU_MAX_ARTICULATIONS 16 + +#endif /* packet-dis-pduparsers.h */ diff --git a/epan/dissectors/packet-dis.c b/epan/dissectors/packet-dis.c new file mode 100644 index 0000000000..d2e2b43aa6 --- /dev/null +++ b/epan/dissectors/packet-dis.c @@ -0,0 +1,196 @@ +/* packet-dis.c + * Routines for Distributed Interactive Simulation packet + * disassembly (IEEE-1278). + * Copyright 2005, Scientific Research Corporation + * Initial implementation by Jeremy Ouellette <jouellet@scires.com> + * + * Ethereal - Network traffic analyzer + * By Gerald Combs <gerald@ethereal.com> + * Copyright 1998 Gerald Combs + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +/* TODO / NOTES: + * Field handling isn't ideal; this dissector should probably register + * each individual field via the proto_register_field_array mechanism. + * This would lead to better PDML output (instead of requiring the end user + * to manually parse out the key/value pairs) and better searchability in + * interactive mode. + * + * Lots more PDUs to implement. Only the basic engagement events are currently + * handled (Fire, Detonation, Entity State). Most of the basic field types are + * complete, however, so declaring new PDUs should be fairly simple. + * + * Lots more enumerations to implement. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdio.h> +#include <epan/packet.h> +#include <epan/value_string.h> +#include <epan/prefs.h> +#include "packet-dis-enums.h" +#include "packet-dis-pdus.h" +#include "packet-dis-fields.h" + +#define DEFAULT_DIS_UDP_PORT 3000 + +static gint proto_dis = -1; +static gint ett_dis = -1; +static gint ett_dis_header = -1; +static gint ett_dis_payload = -1; + +static dissector_handle_t dis_dissector_handle; +static guint dis_udp_port = DEFAULT_DIS_UDP_PORT; + +static char* dis_proto_name = "Distributed Interactive Simulation"; +static char* dis_proto_name_short = "DIS"; + +/* Main dissector routine to be invoked for a DIS PDU. + */ +static void dissect_dis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) +{ + proto_item *dis_tree = 0; + proto_item *dis_node = 0; + proto_item *dis_header_tree = 0; + proto_item *dis_header_node = 0; + proto_item *dis_payload_tree = 0; + proto_item *dis_payload_node = 0; + gint offset = 0; + const gchar *pduString = 0; + DIS_ParserNode *pduParser = 0; + + /* Reset the global PDU type variable -- this will be parsed as part of + * the DIS header. + */ + pduType = DIS_PDUTYPE_OTHER; + numArticulations = 0; + + if (check_col(pinfo->cinfo, COL_PROTOCOL)) + { + 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. + */ + dis_node = proto_tree_add_protocol_format(tree, proto_dis, tvb, offset, + -1, "Distributed Interactive Simulation"); + dis_tree = proto_item_add_subtree(dis_node, ett_dis); + + /* Add a node to contain the DIS header fields. + */ + 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 appropriate PDU parser, if type is known. + */ + switch (pduType) + { + case DIS_PDUTYPE_ENTITY_STATE: + pduParser = DIS_PARSER_ENTITY_STATE_PDU; + break; + case DIS_PDUTYPE_FIRE: + pduParser = DIS_PARSER_FIRE_PDU; + break; + case DIS_PDUTYPE_DETONATION: + pduParser = DIS_PARSER_DETONATION_PDU; + break; + default: + pduParser = 0; + break; + } + + /* 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. + */ + dis_payload_node = proto_tree_add_text(dis_tree, tvb, offset, -1, + "%s PDU", pduString); + + /* If a parser was located, invoke it on the data packet. + */ + if (pduParser != 0) + { + 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); + } +} + +/* Register handoff routine for DIS dissector. This will be invoked initially + * and when the preferences are changed, to handle changing the UDP port for + * which this dissector is registered. + */ +void proto_reg_handoff_dis(void) +{ + static gboolean dis_prefs_initialized = FALSE; + + if (!dis_prefs_initialized) + { + dis_dissector_handle = create_dissector_handle(dissect_dis, proto_dis); + } + else + { + dissector_delete("udp.port", dis_udp_port, dis_dissector_handle); + } + + dissector_add("udp.port", dis_udp_port, dis_dissector_handle); +} + +/* Registration routine for the DIS protocol. + */ +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. + */ + static gint *ett[] = + { + &ett_dis, + &ett_dis_header, + &ett_dis_payload + }; + + module_t *dis_module; + + proto_dis = proto_register_protocol(dis_proto_name, dis_proto_name_short, + "dis"); + proto_register_subtree_array(ett, array_length(ett)); + + dis_module = prefs_register_protocol(proto_dis, proto_reg_handoff_dis); + + /* Create an unsigned integer preference to allow the user to specify the + * UDP port on which to capture DIS packets. + */ + prefs_register_uint_preference(dis_module, "udp.port", + "DIS UDP Port", + "Set the UDP port for DIS messages", + 10, &dis_udp_port); + + /* Perform the one-time initialization of the DIS parsers. + */ + initializeParsers(); +} |