PageRenderTime 59ms CodeModel.GetById 18ms RepoModel.GetById 1ms app.codeStats 0ms

/epan/dissectors/packet-dmp.c

https://github.com/labx-technologies-llc/wireshark
C | 5101 lines | 4232 code | 540 blank | 329 comment | 754 complexity | 84d246a4d8276feb832171e8cb46bcc6 MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. /* packet-dmp.c
    2. 

  2.  *
    3. 

  3.  * Routines for STANAG 4406 Direct Message Profile packet disassembly.
    4. 

  4.  * A protocol for optimised transfer of time-critical short messages
    5. 

  5.  * for use with a reliable bearer service.  Checksum and retransmission
    6. 

  6.  * mechanisms are activated when using unreliable bearer services.
    7. 

  7.  *
    8. 

  8.  * Copyright 2006, Stig Bjorlykke <stig@bjorlykke.org>, Thales Norway AS
    9. 

  9.  *
    10. 

  10.  * $Id$
    11. 

  11.  *
    12. 

  12.  * Wireshark - Network traffic analyzer
    13. 

  13.  * By Gerald Combs <gerald@wireshark.org>
    14. 

  14.  * Copyright 1998 Gerald Combs
    15. 

  15.  *
    16. 

  16.  * This program is free software; you can redistribute it and/or
    17. 

  17.  * modify it under the terms of the GNU General Public License
    18. 

  18.  * as published by the Free Software Foundation; either version 2
    19. 

  19.  * of the License, or (at your option) any later version.
    20. 

  20.  *
    21. 

  21.  * This program is distributed in the hope that it will be useful,
    22. 

  22.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    23. 

  23.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    24. 

  24.  * GNU General Public License for more details.
    25. 

  25.  *
    26. 

  26.  * You should have received a copy of the GNU General Public License along
    27. 

  27.  * with this program; if not, write to the Free Software Foundation, Inc.,
    28. 

  28.  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
    29. 

  29.  *
    30. 

  30.  * Ref:  http://jcs.dtic.mil/j6/cceb/acps/acp123/
    31. 

  31.  */
    32. 

  32. 

  33. /*
    34. 

  34.  * TODO:
    35. 

  35.  * - Dissect extended Restrictive security categories
    36. 

  36.  * - Add Transmission/Retransmission statistics
    37. 

  37.  */
    38. 

  38. 

  39. #include "config.h"
    40. 

  40. 

  41. #include <string.h>
    42. 

  42. #include <math.h>
    43. 

  43. 

  44. #include <epan/packet.h>
    45. 

  45. #include <epan/address.h>
    46. 

  46. #include <epan/addr_resolv.h>
    47. 

  47. #include <epan/to_str.h>
    48. 

  48. #include <epan/prefs.h>
    49. 

  49. #include <epan/emem.h>
    50. 

  50. #include <epan/expert.h>
    51. 

  51. #include <epan/crc16-tvb.h>
    52. 

  52. #include <epan/asn1.h>
    53. 

  53. #include <epan/strutil.h>
    54. 

  54. #include <epan/uat.h>
    55. 

  55. 

  56. #include "packet-p1.h"
    57. 

  57. #include "packet-p22.h"
    58. 

  58. 

  59. #define PNAME  "Direct Message Profile"
    60. 

  60. #define PSNAME "DMP"
    61. 

  61. #define PFNAME "dmp"
    62. 

  62. 

  63. /* Default UDP Port Number */
    64. 

  64. #define DEFAULT_DMP_PORT_RANGE "5031"
    65. 

  65. 

  66. /* Protocol Identifier */
    67. 

  67. #define PROT_NAT 0x0D
    68. 

  68. #define PROT_DMP 0x1D
    69. 

  69. 

  70. /* Versions supported */
    71. 

  71. #define DMP_VERSION_1  1
    72. 

  72. #define DMP_VERSION_2  2
    73. 

  73. 

  74. /* Message Type (dmp.msg_type) */
    75. 

  75. #define STANAG   0x0
    76. 

  76. #define IPM      0x1
    77. 

  77. #define REPORT   0x2
    78. 

  78. #define NOTIF    0x3
    79. 

  79. #define ACK      0x4
    80. 

  80. 

  81. /* Message Identifier Type (dmp.msg_id_type) */
    82. 

  82. #define ONLY_DMP_ID  0x0
    83. 

  83. #define X400_MSG_ID  0x1
    84. 

  84. #define NAT_MSG_ID   0x2
    85. 

  85. 

  86. /* Report Type (dmp.report_type) */
    87. 

  87. #define DR       0x0
    88. 

  88. #define NDR      0x1
    89. 

  89. 

  90. /* Notification Type (dmp.notif_type) */
    91. 

  91. #define RN       0x0
    92. 

  92. #define NRN      0x1
    93. 

  93. #define ON       0x2
    94. 

  94. 

  95. /* Address Encoding (dmp.addr_enc) */
    96. 

  96. #define DIRECT_ADDR   0x0
    97. 

  97. #define EXTENDED_ADDR 0x1
    98. 

  98. 

  99. /* Address type (internal values) */
    100. 

  100. #define ORIGINATOR   1
    101. 

  101. #define P1_ADDRESS   2
    102. 

  102. #define P2_ADDRESS   3
    103. 

  103. #define ORIG_P2_ADDRESS   4
    104. 

  104. 

  105. /* Extended Address Form (dmp_addr_form) */
    106. 

  106. #define P1_DIRECT             0x0
    107. 

  107. #define P2_DIRECT             0x1
    108. 

  108. #define P1_EXTENDED           0x2
    109. 

  109. #define P2_EXTENDED           0x3
    110. 

  110. #define P1_P2_DIRECT          0x4
    111. 

  111. #define P1_DIRECT_P2_EXTENDED 0x5
    112. 

  112. #define P1_EXTENDED_P2_DIRECT 0x6
    113. 

  113. #define P1_P2_EXTENDED        0x7
    114. 

  114. 

  115. /* Extended Address Type */
    116. 

  116. #define ASN1_BER 0x0
    117. 

  117. #define ASN1_PER 0x1
    118. 

  118. 

  119. /* Security Policy (dmp_sec_pol) */
    120. 

  120. #define NATO              0x4
    121. 

  121. #define NATIONAL          0x5
    122. 

  122. #define EXTENDED_NATIONAL 0x6
    123. 

  123. #define EXTENDED_MISSION  0x7
    124. 

  124. 

  125. #define SEC_CAT_EXT_NONE        0x0
    126. 

  126. #define SEC_CAT_EXT_PERMISSIVE  0x1
    127. 

  127. #define SEC_CAT_EXT_RESTRICTIVE 0x2
    128. 

  128. 

  129. /* Body Format (dmp.body_format) */
    130. 

  130. #define FREE_TEXT         0x0
    131. 

  131. #define FREE_TEXT_SUBJECT 0x1
    132. 

  132. #define STRUCTURED        0x2
    133. 

  133. 

  134. /* Encoded Information Types */
    135. 

  135. #define EIT_BILATERAL     0x3
    136. 

  136. 

  137. /* Compression Algorithm */
    138. 

  138. #define ALGORITHM_NONE    0x0
    139. 

  139. #define ALGORITHM_ZLIB    0x1
    140. 

  140. 

  141. /* Type of structured id to print */
    142. 

  142. #define STRUCT_ID_NONE     0
    143. 

  143. #define STRUCT_ID_UINT8    1
    144. 

  144. #define STRUCT_ID_UINT16   2
    145. 

  145. #define STRUCT_ID_UINT32   3
    146. 

  146. #define STRUCT_ID_UINT64   4
    147. 

  147. #define STRUCT_ID_STRING   5
    148. 

  148. #define STRUCT_ID_ZSTRING  6
    149. 

  149. 

  150. #define NAT_DECODE_NONE    0
    151. 

  151. #define NAT_DECODE_DMP     1
    152. 

  152. #define NAT_DECODE_THALES  2
    153. 

  153. 

  154. #define IPM_MODIFIER_X400  0
    155. 

  155. 

  156. /* Internal values for not present and reserved time values */
    157. 

  157. #define DMP_TIME_NOT_PRESENT  -1
    158. 

  158. #define DMP_TIME_RESERVED     -2
    159. 

  159. 

  160. #define ILLEGAL_FORMAT "<Illegal format>"
    161. 

  161. 

  162. /* Maximum lengths */
    163. 

  163. #define MAX_SIC_LEN         30
    164. 

  164. 

  165. void proto_reg_handoff_dmp (void);
    166. 

  166. 

  167. static int proto_dmp = -1;
    168. 

  168. 

  169. static int hf_dmp_id = -1;
    170. 

  170. static int hf_mts_id = -1;
    171. 

  171. static int hf_ipm_id = -1;
    172. 

  172. 

  173. static int hf_envelope = -1;
    174. 

  174. static int hf_envelope_protocol_id = -1;
    175. 

  175. static int hf_envelope_version = -1;
    176. 

  176. static int hf_envelope_version_value = -1;
    177. 

  177. static int hf_envelope_hop_count = -1;
    178. 

  178. static int hf_envelope_hop_count_value = -1;
    179. 

  179. static int hf_envelope_rec_present = -1;
    180. 

  180. static int hf_envelope_addr_enc = -1;
    181. 

  181. static int hf_envelope_checksum = -1;
    182. 

  182. static int hf_envelope_extensions = -1;
    183. 

  183. static int hf_envelope_msg_id_type = -1;
    184. 

  184. static int hf_envelope_msg_id_length = -1;
    185. 

  185. static int hf_envelope_mts_id_length = -1;
    186. 

  186. static int hf_envelope_ipm_id_modifier = -1;
    187. 

  187. static int hf_envelope_ipm_id_length = -1;
    188. 

  188. static int hf_envelope_mts_id = -1;
    189. 

  189. static int hf_envelope_ipm_id = -1;
    190. 

  190. static int hf_envelope_type = -1;
    191. 

  191. static int hf_envelope_msg_id = -1;
    192. 

  192. static int hf_envelope_msg_id_12bit = -1;
    193. 

  193. static int hf_envelope_subm_time = -1;
    194. 

  194. static int hf_envelope_subm_time_value = -1;
    195. 

  195. static int hf_envelope_time_diff_present = -1;
    196. 

  196. static int hf_envelope_time_diff = -1;
    197. 

  197. static int hf_envelope_time_diff_value = -1;
    198. 

  198. static int hf_envelope_flags = -1;
    199. 

  199. static int hf_envelope_content_id_discarded = -1;
    200. 

  200. static int hf_envelope_recip_reassign_prohib = -1;
    201. 

  201. static int hf_envelope_dl_expansion_prohib = -1;
    202. 

  202. static int hf_envelope_recipients = -1;
    203. 

  203. static int hf_envelope_ext_recipients = -1;
    204. 

  204. 

  205. static int hf_thales_ipm_id_modifier = -1;
    206. 

  206. 

  207. static int hf_extensions = -1;
    208. 

  208. static int hf_extension = -1;
    209. 

  209. static int hf_extension_header = -1;
    210. 

  210. static int hf_extension_more = -1;
    211. 

  211. static int hf_extension_length = -1;
    212. 

  212. static int hf_extension_data = -1;
    213. 

  213. 

  214. static int hf_message_content = -1;
    215. 

  215. static int hf_report_content = -1;
    216. 

  216. static int hf_notif_content = -1;
    217. 

  217. 

  218. static int hf_addr_recipient = -1;
    219. 

  219. static int hf_addr_originator = -1;
    220. 

  220. static int hf_addr_reporting_name = -1;
    221. 

  221. static int hf_addr_dl_expanded = -1;
    222. 

  222. static int hf_addr_int_rec = -1;
    223. 

  223. static int hf_addr_dir_addr_ext = -1;
    224. 

  224. static int hf_addr_dir_rec_no = -1;
    225. 

  225. static int hf_addr_dir_rec_no1 = -1;
    226. 

  226. static int hf_addr_dir_rec_no2 = -1;
    227. 

  227. static int hf_addr_dir_rec_no3 = -1;
    228. 

  228. static int hf_addr_dir_rec_no_generated = -1;
    229. 

  229. static int hf_addr_dir_rep_req1 = -1;
    230. 

  230. static int hf_addr_dir_rep_req2 = -1;
    231. 

  231. static int hf_addr_dir_rep_req3 = -1;
    232. 

  232. static int hf_addr_dir_not_req1 = -1;
    233. 

  233. static int hf_addr_dir_not_req2 = -1;
    234. 

  234. static int hf_addr_dir_not_req3 = -1;
    235. 

  235. static int hf_addr_dir_action = -1;
    236. 

  236. static int hf_addr_dir_address = -1;
    237. 

  237. static int hf_addr_dir_address1 = -1;
    238. 

  238. static int hf_addr_dir_address2 = -1;
    239. 

  239. static int hf_addr_dir_address3 = -1;
    240. 

  240. static int hf_addr_dir_address_generated = -1;
    241. 

  241. 

  242. static int hf_addr_ext_form = -1;
    243. 

  243. static int hf_addr_ext_form_orig_v1 = -1;
    244. 

  244. static int hf_addr_ext_form_orig = -1;
    245. 

  245. static int hf_addr_ext_action = -1;
    246. 

  246. static int hf_addr_ext_rep_req = -1;
    247. 

  247. static int hf_addr_ext_not_req = -1;
    248. 

  248. static int hf_addr_ext_rec_ext = -1;
    249. 

  249. static int hf_addr_ext_rec_no = -1;
    250. 

  250. static int hf_addr_ext_rec_no1 = -1;
    251. 

  251. static int hf_addr_ext_rec_no2 = -1;
    252. 

  252. static int hf_addr_ext_rec_no_generated = -1;
    253. 

  253. static int hf_addr_ext_address = -1;
    254. 

  254. static int hf_addr_ext_type = -1;
    255. 

  255. static int hf_addr_ext_type_ext = -1;
    256. 

  256. static int hf_addr_ext_length = -1;
    257. 

  257. static int hf_addr_ext_length1 = -1;
    258. 

  258. static int hf_addr_ext_length2 = -1;
    259. 

  259. static int hf_addr_ext_length_generated = -1;
    260. 

  260. static int hf_addr_ext_asn1_ber = -1;
    261. 

  261. static int hf_addr_ext_asn1_per = -1;
    262. 

  262. static int hf_addr_ext_unknown = -1;
    263. 

  263. 

  264. static int hf_message_body = -1;
    265. 

  265. static int hf_message_st_type = -1;
    266. 

  266. static int hf_message_precedence = -1;
    267. 

  267. static int hf_message_importance = -1;
    268. 

  268. static int hf_message_body_format = -1;
    269. 

  269. static int hf_message_sec_class_val = -1;
    270. 

  270. static int hf_message_sec_pol = -1;
    271. 

  271. static int hf_message_heading_flags = -1;
    272. 

  272. static int hf_message_auth_users = -1;
    273. 

  273. static int hf_message_subject_disc = -1;
    274. 

  274. static int hf_message_national_policy_id = -1;
    275. 

  275. static int hf_message_mission_policy_id = -1;
    276. 

  276. static int hf_message_sec_label = -1;
    277. 

  277. static int hf_message_sec_cat_nat = -1;
    278. 

  278. static int hf_message_sec_cat_val = -1;
    279. 

  279. static int hf_message_sec_cat_cl = -1;
    280. 

  280. static int hf_message_sec_cat_cs = -1;
    281. 

  281. static int hf_message_sec_cat_ex = -1;
    282. 

  282. static int hf_message_sec_cat_ne = -1;
    283. 

  283. static int hf_message_sec_cat_permissive = -1;
    284. 

  284. static int hf_message_sec_cat_country_code = -1;
    285. 

  285. static int hf_message_sec_cat_restrictive = -1;
    286. 

  286. static int hf_message_sec_cat_extended = -1;
    287. 

  287. static int hf_message_sec_cat_bit0 = -1;
    288. 

  288. static int hf_message_sec_cat_bit1 = -1;
    289. 

  289. static int hf_message_sec_cat_bit2 = -1;
    290. 

  290. static int hf_message_sec_cat_bit3 = -1;
    291. 

  291. static int hf_message_sec_cat_bit4 = -1;
    292. 

  292. static int hf_message_sec_cat_bit5 = -1;
    293. 

  293. static int hf_message_sec_cat_bit6 = -1;
    294. 

  294. static int hf_message_sec_cat_bit7 = -1;
    295. 

  295. static int hf_message_exp_time = -1;
    296. 

  296. static int hf_message_exp_time_val = -1;
    297. 

  297. static int hf_message_dtg = -1;
    298. 

  298. static int hf_message_dtg_sign = -1;
    299. 

  299. static int hf_message_dtg_val = -1;
    300. 

  300. static int hf_message_sic = -1;
    301. 

  301. static int hf_message_sic_key = -1;
    302. 

  302. static int hf_message_sic_key_values = -1;
    303. 

  303. static int hf_message_sic_key_type = -1;
    304. 

  304. static int hf_message_sic_key_chars = -1;
    305. 

  305. static int hf_message_sic_key_num = -1;
    306. 

  306. static int hf_message_sic_bitmap = -1;
    307. 

  307. static int hf_message_sic_bits = -1;
    308. 

  308. static int hf_message_sic_bits_any = -1;
    309. 

  309. static int hf_message_subj_id = -1;
    310. 

  310. static int hf_message_subj_mts_id = -1;
    311. 

  311. static int hf_message_subj_ipm_id = -1;
    312. 

  312. 

  313. static int hf_message_subject = -1;
    314. 

  314. static int hf_message_eit = -1;
    315. 

  315. static int hf_message_compr = -1;
    316. 

  316. static int hf_message_body_data = -1;
    317. 

  317. static int hf_message_body_plain = -1;
    318. 

  318. static int hf_message_bodyid_uint8 = -1;
    319. 

  319. static int hf_message_bodyid_uint16 = -1;
    320. 

  320. static int hf_message_bodyid_uint32 = -1;
    321. 

  321. static int hf_message_bodyid_uint64 = -1;
    322. 

  322. static int hf_message_bodyid_string = -1;
    323. 

  323. static int hf_message_bodyid_zstring = -1;
    324. 

  324. static int hf_message_body_structured = -1;
    325. 

  325. static int hf_message_body_uncompr = -1;
    326. 

  326. static int hf_message_body_uncompressed = -1;
    327. 

  327. 

  328. static int hf_delivery_report = -1;
    329. 

  329. static int hf_non_delivery_report = -1;
    330. 

  330. static int hf_report_type = -1;
    331. 

  331. static int hf_report_info_present_dr = -1;
    332. 

  332. static int hf_report_addr_enc_dr = -1;
    333. 

  333. static int hf_report_del_time = -1;
    334. 

  334. static int hf_report_del_time_val = -1;
    335. 

  335. static int hf_report_addr_enc_ndr = -1;
    336. 

  336. static int hf_report_reason = -1;
    337. 

  337. static int hf_report_info_present_ndr = -1;
    338. 

  338. static int hf_report_diagn = -1;
    339. 

  339. static int hf_report_suppl_info_len = -1;
    340. 

  340. static int hf_report_suppl_info = -1;
    341. 

  341. 

  342. static int hf_receipt_notif = -1;
    343. 

  343. static int hf_non_receipt_notif = -1;
    344. 

  344. static int hf_other_notif = -1;
    345. 

  345. static int hf_notif_type = -1;
    346. 

  346. static int hf_notif_rec_time = -1;
    347. 

  347. static int hf_notif_rec_time_val = -1;
    348. 

  348. static int hf_notif_suppl_info_len = -1;
    349. 

  349. static int hf_notif_suppl_info = -1;
    350. 

  350. static int hf_notif_non_rec_reason = -1;
    351. 

  351. static int hf_notif_discard_reason = -1;
    352. 

  352. static int hf_notif_on_type = -1;
    353. 

  353. static int hf_notif_acp127 = -1;
    354. 

  354. static int hf_notif_acp127recip = -1;
    355. 

  355. 

  356. static int hf_ack = -1;
    357. 

  357. static int hf_ack_reason = -1;
    358. 

  358. static int hf_ack_diagnostic = -1;
    359. 

  359. static int hf_ack_recips = -1;
    360. 

  360. 

  361. static int hf_checksum = -1;
    362. 

  362. static int hf_checksum_good = -1;
    363. 

  363. static int hf_checksum_bad = -1;
    364. 

  364. 

  365. static int hf_analysis_ack_time = -1;
    366. 

  366. static int hf_analysis_total_time = -1;
    367. 

  367. static int hf_analysis_retrans_time = -1;
    368. 

  368. static int hf_analysis_total_retrans_time = -1;
    369. 

  369. static int hf_analysis_msg_num = -1;
    370. 

  370. static int hf_analysis_msg_missing = -1;
    371. 

  371. static int hf_analysis_retrans_no = -1;
    372. 

  372. static int hf_analysis_ack_num = -1;
    373. 

  373. static int hf_analysis_ack_missing = -1;
    374. 

  374. static int hf_analysis_ack_dup_no = -1;
    375. 

  375. static int hf_analysis_rep_num = -1;
    376. 

  376. static int hf_analysis_rep_time = -1;
    377. 

  377. static int hf_analysis_not_num = -1;
    378. 

  378. static int hf_analysis_not_time = -1;
    379. 

  379. static int hf_analysis_msg_resend_from = -1;
    380. 

  380. static int hf_analysis_rep_resend_from = -1;
    381. 

  381. static int hf_analysis_not_resend_from = -1;
    382. 

  382. static int hf_analysis_ack_resend_from = -1;
    383. 

  383. 

  384. static int hf_reserved_0x01 = -1;
    385. 

  385. static int hf_reserved_0x02 = -1;
    386. 

  386. static int hf_reserved_0x04 = -1;
    387. 

  387. static int hf_reserved_0x07 = -1;
    388. 

  388. static int hf_reserved_0x08 = -1;
    389. 

  389. static int hf_reserved_0x0F = -1;
    390. 

  390. static int hf_reserved_0x1F = -1;
    391. 

  391. static int hf_reserved_0x20 = -1;
    392. 

  392. static int hf_reserved_0x40 = -1;
    393. 

  393. static int hf_reserved_0xC0 = -1;
    394. 

  394. static int hf_reserved_0xE0 = -1;
    395. 

  395. static int hf_reserved_0x8000 = -1;
    396. 

  396. 

  397. static gint ett_dmp = -1;
    398. 

  398. static gint ett_envelope = -1;
    399. 

  399. static gint ett_envelope_version = -1;
    400. 

  400. static gint ett_envelope_hop_count = -1;
    401. 

  401. static gint ett_envelope_rec_present = -1;
    402. 

  402. static gint ett_envelope_addr_enc = -1;
    403. 

  403. static gint ett_envelope_checksum = -1;
    404. 

  404. static gint ett_envelope_extensions = -1;
    405. 

  405. static gint ett_envelope_msg_id_type = -1;
    406. 

  406. static gint ett_envelope_msg_id = -1;
    407. 

  407. static gint ett_envelope_mts_id_length = -1;
    408. 

  408. static gint ett_envelope_ipm_id_length = -1;
    409. 

  409. static gint ett_envelope_cont_type = -1;
    410. 

  410. static gint ett_envelope_subm_time = -1;
    411. 

  411. static gint ett_envelope_time_diff = -1;
    412. 

  412. static gint ett_envelope_flags = -1;
    413. 

  413. static gint ett_envelope_recipients = -1;
    414. 

  414. static gint ett_envelope_ext_recipients = -1;
    415. 

  415. static gint ett_envelope_addresses = -1;
    416. 

  416. 

  417. static gint ett_address = -1;
    418. 

  418. static gint ett_address_direct = -1;
    419. 

  419. static gint ett_address_rec_no = -1;
    420. 

  420. static gint ett_address_extended = -1;
    421. 

  421. static gint ett_address_ext_form = -1;
    422. 

  422. static gint ett_address_ext_rec_no = -1;
    423. 

  423. static gint ett_address_ext_action = -1;
    424. 

  424. static gint ett_address_ext_rep_req = -1;
    425. 

  425. static gint ett_address_ext_not_req = -1;
    426. 

  426. static gint ett_address_ext_type = -1;
    427. 

  427. static gint ett_address_ext_length = -1;
    428. 

  428. 

  429. static gint ett_extensions = -1;
    430. 

  430. static gint ett_extension = -1;
    431. 

  431. static gint ett_extension_header = -1;
    432. 

  432. 

  433. static gint ett_content = -1;
    434. 

  434. 

  435. static gint ett_message = -1;
    436. 

  436. static gint ett_message_st_type = -1;
    437. 

  437. static gint ett_message_reserved = -1;
    438. 

  438. static gint ett_message_precedence = -1;
    439. 

  439. static gint ett_message_importance = -1;
    440. 

  440. static gint ett_message_body_format = -1;
    441. 

  441. static gint ett_message_sec_class = -1;
    442. 

  442. static gint ett_message_sec_pol = -1;
    443. 

  443. static gint ett_message_sec_cat = -1;
    444. 

  444. static gint ett_message_heading_flags = -1;
    445. 

  445. static gint ett_message_exp_time = -1;
    446. 

  446. static gint ett_message_dtg = -1;
    447. 

  447. static gint ett_message_sic = -1;
    448. 

  448. static gint ett_message_sic_key = -1;
    449. 

  449. static gint ett_message_sic_bitmap = -1;
    450. 

  450. static gint ett_message_sic_bits = -1;
    451. 

  451. static gint ett_message_eit = -1;
    452. 

  452. static gint ett_message_compr = -1;
    453. 

  453. static gint ett_message_body_reserved = -1;
    454. 

  454. static gint ett_message_body = -1;
    455. 

  455. static gint ett_message_body_uncompr = -1;
    456. 

  456. 

  457. static gint ett_report = -1;
    458. 

  458. static gint ett_report_type = -1;
    459. 

  459. static gint ett_report_info_present_dr = -1;
    460. 

  460. static gint ett_report_info_present_ndr = -1;
    461. 

  461. static gint ett_report_addr_enc_dr = -1;
    462. 

  462. static gint ett_report_addr_enc_ndr = -1;
    463. 

  463. static gint ett_report_reserved = -1;
    464. 

  464. static gint ett_report_del_time = -1;
    465. 

  465. static gint ett_report_reason = -1;
    466. 

  466. static gint ett_report_suppl_info = -1;
    467. 

  467. static gint ett_report_diagn = -1;
    468. 

  468. 

  469. static gint ett_notif = -1;
    470. 

  470. static gint ett_notif_type = -1;
    471. 

  471. static gint ett_notif_rec_time = -1;
    472. 

  472. static gint ett_notif_suppl_info = -1;
    473. 

  473. static gint ett_notif_acp127recip = -1;
    474. 

  474. 

  475. static gint ett_ack = -1;
    476. 

  476. static gint ett_ack_recips = -1;
    477. 

  477. 

  478. static gint ett_checksum = -1;
    479. 

  479. 

  480. static gint ett_analysis = -1;
    481. 

  481. 

  482. static expert_field ei_reserved_value = EI_INIT;
    483. 

  483. static expert_field ei_message_sic_illegal = EI_INIT;
    484. 

  484. 

  485. static dissector_handle_t dmp_handle;
    486. 

  486. 

  487. typedef struct _dmp_id_key {
    488. 

  488.   guint   id;
    489. 

  489.   address src;
    490. 

  490.   address dst;
    491. 

  491. } dmp_id_key;
    492. 

  492. 

  493. typedef struct _dmp_id_val {
    494. 

  494.   gint     msg_type;                   /* Message type                   */
    495. 

  495.   guint    prev_msg_id;                /* Previous message package num   */
    496. 

  496.   guint    msg_id;                     /* Message package num            */
    497. 

  497.   guint    ack_id;                     /* Acknowledgement package num    */
    498. 

  498.   guint    rep_id;                     /* Report package num             */
    499. 

  499.   guint    not_id;                     /* Notification package num       */
    500. 

  500.   nstime_t msg_time;                   /* Message receive time           */
    501. 

  501.   nstime_t first_msg_time;             /* First message receive time     */
    502. 

  502.   nstime_t prev_msg_time;              /* Previous message receive time  */
    503. 

  503.   nstime_t rep_not_msg_time;           /* Report or Notification time    */
    504. 

  504.   guint32  msg_resend_count;           /* Message resend counter         */
    505. 

  505.   guint32  ack_resend_count;           /* Acknowledgement resend counter */
    506. 

  506. } dmp_id_val;
    507. 

  507. 

  508. static GHashTable *dmp_id_hash_table = NULL;
    509. 

  509. static GHashTable *dmp_long_id_hash_table = NULL;
    510. 

  510. 

  511. /* Global values used in several functions */
    512. 

  512. static struct dmp_data {
    513. 

  513.   gint     version;
    514. 

  514.   gint     prot_id;
    515. 

  515.   gint     addr_enc;
    516. 

  516.   gint     checksum;
    517. 

  517.   gint     msg_type;
    518. 

  518.   gint     st_type;
    519. 

  519.   gint     prec;
    520. 

  520.   gint     body_format;
    521. 

  521.   gint     notif_type;
    522. 

  522.   guchar  *struct_id;
    523. 

  523.   gint32   subm_time;
    524. 

  524.   guint8   msg_id_type;
    525. 

  525.   guint8   mts_id_length;
    526. 

  526.   proto_item *mts_id_item;
    527. 

  527.   guint8   ack_reason;
    528. 

  528.   guint16  msg_id;
    529. 

  529.   guint16  subj_id;
    530. 

  530.   gboolean extensions;
    531. 

  531.   gboolean dr;
    532. 

  532.   gboolean ndr;
    533. 

  533.   gboolean notif_req;
    534. 

  534.   gboolean ack_rec_present;
    535. 

  535.   dmp_id_val *id_val;
    536. 

  536. } dmp;
    537. 

  537. 

  538. /* User definable values */
    539. 

  539. static range_t *global_dmp_port_range;
    540. 

  540. static gint     dmp_nat_decode = NAT_DECODE_DMP;
    541. 

  541. static gint     dmp_local_nation = 0;
    542. 

  542. static gboolean use_seq_ack_analysis = TRUE;
    543. 

  543. static gboolean dmp_align = FALSE;
    544. 

  544. static gboolean dmp_subject_as_id = FALSE;
    545. 

  545. static gint     dmp_struct_format = STRUCT_ID_NONE;
    546. 

  546. static guint    dmp_struct_offset = 0;
    547. 

  547. static guint    dmp_struct_length = 1;
    548. 

  548. 

  549. typedef struct _dmp_security_class_t {
    550. 

  550.   guint nation;
    551. 

  551.   guint sec_class;
    552. 

  552.   char *name;
    553. 

  553. } dmp_security_class_t;
    554. 

  554. 

  555. static dmp_security_class_t *dmp_security_classes;
    556. 

  556. static guint num_dmp_security_classes;
    557. 

  557. 

  558. static const true_false_string addr_enc = {
    559. 

  559.   "Use Extended Encoding", "Use Direct Encoding"
    560. 

  560. };
    561. 

  561. 

  562. static const true_false_string dtg_sign = {
    563. 

  563.   "Future", "Past"
    564. 

  564. };
    565. 

  565. 

  566. static const true_false_string report_type = {
    567. 

  567.   "Non-Delivery Report", "Delivery Report"
    568. 

  568. };
    569. 

  569. 

  570. static const value_string version_vals[] = {
    571. 

  571.   { 0x0, "1"       },
    572. 

  572.   { 0x1, "2"       },
    573. 

  573.   { 0x2, "Unknown" },
    574. 

  574.   { 0x3, "Unknown" },
    575. 

  575.   { 0x4, "Unknown" },
    576. 

  576.   { 0x5, "Unknown" },
    577. 

  577.   { 0x6, "Unknown" },
    578. 

  578.   { 0x7, "Unknown" },
    579. 

  579.   { 0,   NULL } };
    580. 

  580. 

  581. static const value_string type_vals[] = {
    582. 

  582.   { 0x0, "Message"          },
    583. 

  583.   { 0x1, "Message (E-Mail)" },
    584. 

  584.   { 0x2, "Report"           },
    585. 

  585.   { 0x3, "Notification"     },
    586. 

  586.   { 0x4, "Acknowledgement"  },
    587. 

  587.   { 0x5, "Unknown Content"  },
    588. 

  588.   { 0x6, "Unknown Content"  },
    589. 

  589.   { 0x7, "Unknown Content"  },
    590. 

  590.   { 0,   NULL } };
    591. 

  591. 

  592. static const value_string msg_id_type_vals[] = {
    593. 

  593.   { 0x0, "DMP Identifiers only"      },
    594. 

  594.   { 0x1, "X.400 Message Identifiers" },
    595. 

  595.   { 0x2, "Nationally-defined"        },
    596. 

  596.   { 0x3, "Reserved"                  },
    597. 

  597.   { 0,   NULL } };
    598. 

  598. 

  599. static const value_string msg_id_length_vals[] = {
    600. 

  600.   { 0x0, "Full (16 bits)"  },
    601. 

  601.   { 0x1, "Short (12 bits)" },
    602. 

  602.   { 0,   NULL } };
    603. 

  603. 

  604. static const value_string report_vals[] = {
    605. 

  605.   { 0x0, "No Report"           },
    606. 

  606.   { 0x1, "Non-Delivery Report" },
    607. 

  607.   { 0x2, "Delivery Report"     },
    608. 

  608.   { 0x3, "Reserved"            },
    609. 

  609.   { 0,   NULL } };
    610. 

  610. 

  611. static const value_string report_vals_ext[] = {
    612. 

  612.   { 0x0, "No Report"                 },
    613. 

  613.   { 0x1, "Non-Delivery Report"       },
    614. 

  614.   { 0x2, "Delivery Report"           },
    615. 

  615.   { 0x3, "Recipient Number Extended" },
    616. 

  616.   { 0,   NULL } };
    617. 

  617. 

  618. /* Note the space in front of these values */
    619. 

  619. static const value_string report_vals_short[] = {
    620. 

  620.   { 0x1, " NDR" },
    621. 

  621.   { 0x2, " DR"  },
    622. 

  622.   { 0,   NULL } };
    623. 

  623. 

  624. static const value_string notif_vals[] = {
    625. 

  625.   { 0x0, "No Notification"          },
    626. 

  626.   { 0x1, "Non-Receipt Notification" },
    627. 

  627.   { 0x2, "Receipt Notification"     },
    628. 

  628.   { 0x3, "Reserved"                 },
    629. 

  629.   { 0,   NULL } };
    630. 

  630. 

  631. static const value_string notif_vals_ext[] = {
    632. 

  632.   { 0x0, "No Notification"          },
    633. 

  633.   { 0x1, "Non-Receipt Notification" },
    634. 

  634.   { 0x2, "Receipt Notification"     },
    635. 

  635.   { 0x3, "Direct Address Extended"  },
    636. 

  636.   { 0,   NULL } };
    637. 

  637. 

  638. /* Note the space in front of these values */
    639. 

  639. static const value_string notif_vals_short[] = {
    640. 

  640.   { 0x1, " NRN" },
    641. 

  641.   { 0x2, " RN"  },
    642. 

  642.   { 0,   NULL } };
    643. 

  643. 

  644. static const value_string notif_type [] = {
    645. 

  645.   { 0x0, "Receipt Notification (RN)"      },
    646. 

  646.   { 0x1, "Non-Receipt Notification (NRN)" },
    647. 

  647.   { 0x2, "Other Notification (ON)"        },
    648. 

  648.   { 0x3, "Unknown Notification"           },
    649. 

  649.   { 0,   NULL } };
    650. 

  650. 

  651. /* Note the space behind these values */
    652. 

  652. static const value_string addr_type_str [] = {
    653. 

  653.   { ORIGINATOR,      ""          },
    654. 

  654.   { P1_ADDRESS,      "P1 "       },
    655. 

  655.   { P2_ADDRESS,      "P22/P772 " },
    656. 

  656.   { ORIG_P2_ADDRESS, "P22 "      },
    657. 

  657.   { 0,          NULL } };
    658. 

  658. 

  659. static const value_string addr_form [] = {
    660. 

  660.   { 0x0, "P1 Direct"                       },
    661. 

  661.   { 0x1, "P22/P772 Direct"                 },
    662. 

  662.   { 0x2, "P1 Extended"                     },
    663. 

  663.   { 0x3, "P22/P772 Extended"               },
    664. 

  664.   { 0x4, "P1 and P22/P772 Direct"          },
    665. 

  665.   { 0x5, "P1 Direct and P22/P772 Extended" },
    666. 

  666.   { 0x6, "P1 Extended and P22/P772 Direct" },
    667. 

  667.   { 0x7, "P1 and P22/P772 Extended"        },
    668. 

  668.   { 0,   NULL } };
    669. 

  669. 

  670. static const value_string addr_form_orig_v1 [] = {
    671. 

  671.   { 0x0, "Direct"                             },
    672. 

  672.   { 0x1, "Reserved"                           },
    673. 

  673.   { 0x2, "Extended"                           },
    674. 

  674.   { 0x3, "Reserved"                           },
    675. 

  675.   { 0x4, "Reserved"                           },
    676. 

  676.   { 0x5, "Reserved"                           },
    677. 

  677.   { 0x6, "Reserved"                           },
    678. 

  678.   { 0x7, "Reserved"                           },
    679. 

  679.   { 0,   NULL } };
    680. 

  680. 

  681. static const value_string addr_form_orig [] = {
    682. 

  682.   { 0x0, "Direct"                             },
    683. 

  683.   { 0x1, "Reserved"                           },
    684. 

  684.   { 0x2, "Extended"                           },
    685. 

  685.   { 0x3, "Reserved"                           },
    686. 

  686.   { 0x4, "Originator and P2 Direct"           },
    687. 

  687.   { 0x5, "Originator Direct and P2 Extended"  },
    688. 

  688.   { 0x6, "Originator Extended and P2 Direct"  },
    689. 

  689.   { 0x7, "Originator and P2 Extended"         },
    690. 

  690.   { 0,   NULL } };
    691. 

  691. 

  692. static const value_string ext_addr_type [] = {
    693. 

  693.   { 0x0, "ASN.1 BER-encoded OR-name" },
    694. 

  694.   { 0x1, "ASN.1 PER-encoded OR-name" },
    695. 

  695.   { 0x2, "Reserved" },
    696. 

  696.   { 0x3, "Reserved" },
    697. 

  697.   { 0x4, "Reserved" },
    698. 

  698.   { 0x5, "Reserved" },
    699. 

  699.   { 0x6, "Reserved" },
    700. 

  700.   { 0x7, "Address Length Extended" },
    701. 

  701.   { 0,   NULL } };
    702. 

  702. 

  703. static const value_string ext_addr_type_ext [] = {
    704. 

  704.   { 0x0, "ASN.1 BER-encoded OR-name" },
    705. 

  705.   { 0x1, "ASN.1 PER-encoded OR-name" },
    706. 

  706.   { 0x2, "Reserved" },
    707. 

  707.   { 0x3, "Reserved" },
    708. 

  708.   { 0x4, "Reserved" },
    709. 

  709.   { 0x5, "Reserved" },
    710. 

  710.   { 0x6, "Reserved" },
    711. 

  711.   { 0x7, "Reserved" },
    712. 

  712.   { 0,   NULL } };
    713. 

  713. 

  714. static const value_string ext_addr_type_short [] = {
    715. 

  715.   { 0x0, "OR-name (BER)" },
    716. 

  716.   { 0x1, "OR-name (PER)" },
    717. 

  717.   { 0x2, "Reserved" },
    718. 

  718.   { 0x3, "Reserved" },
    719. 

  719.   { 0x4, "Reserved" },
    720. 

  720.   { 0x5, "Reserved" },
    721. 

  721.   { 0x6, "Reserved" },
    722. 

  722.   { 0x7, "Reserved" },
    723. 

  723.   { 0,   NULL } };
    724. 

  724. 

  725. static const value_string message_type_vals[] = {
    726. 

  726.   { 0x0, "Operation" },
    727. 

  727.   { 0x1, "Project"   },
    728. 

  728.   { 0x2, "Exercise"  },
    729. 

  729.   { 0x3, "Drill"     },
    730. 

  730.   { 0,   NULL } };
    731. 

  731. 

  732. static const value_string precedence[] = {
    733. 

  733.   { 0x0, "Deferred"  },
    734. 

  734.   { 0x1, "Routine"   },
    735. 

  735.   { 0x2, "Priority"  },
    736. 

  736.   { 0x3, "Immediate" },
    737. 

  737.   { 0x4, "Flash"     },
    738. 

  738.   { 0x5, "Override"  },
    739. 

  739.   { 0x6, "Priority, Info Precedence: Routine"   },
    740. 

  740.   { 0x7, "Immediate, Info Precedence: Routine"  },
    741. 

  741.   { 0,   NULL } };
    742. 

  742. 

  743. static const value_string importance[] = {
    744. 

  744.   { 0x0, "Low"      },
    745. 

  745.   { 0x1, "Reserved" },
    746. 

  746.   { 0x2, "Normal"   },
    747. 

  747.   { 0x3, "Reserved" },
    748. 

  748.   { 0x4, "High"     },
    749. 

  749.   { 0x5, "Reserved" },
    750. 

  750.   { 0x6, "Reserved" },
    751. 

  751.   { 0x7, "Reserved" },
    752. 

  752.   { 0,   NULL } };
    753. 

  753. 

  754. static const value_string sec_class[] = {
    755. 

  755.   { 0x0, "Unmarked"     },
    756. 

  756.   { 0x1, "Unclassified" },
    757. 

  757. /* { 0x2, "Reserved"     }, */
    758. 

  758.   { 0x3, "Restricted"   },
    759. 

  759. /* { 0x4, "Reserved"     }, */
    760. 

  760.   { 0x5, "Confidential" },
    761. 

  761.   { 0x6, "Secret"       },
    762. 

  762.   { 0x7, "Top secret"   },
    763. 

  763.   { 0,   NULL } };
    764. 

  764. 

  765. static const value_string sec_pol[] = {
    766. 

  766.   { 0x0, "Network defined"                   },
    767. 

  767.   { 0x1, "Network defined"                   },
    768. 

  768.   { 0x2, "Network defined"                   },
    769. 

  769.   { 0x3, "Network defined"                   },
    770. 

  770.   { 0x4, "NATO"                              },
    771. 

  771.   { 0x5, "National (nation of local server)" },
    772. 

  772.   { 0x6, "Extended, National"                },
    773. 

  773.   { 0x7, "Extended, Mission Defined"         },
    774. 

  774.   { 0,   NULL } };
    775. 

  775. 

  776. #define MAX_NATIONAL_VALUES 56
    777. 

  777. /* Will be built in build_national_strings() */
    778. 

  778. static value_string nat_pol_id[MAX_NATIONAL_VALUES+1];
    779. 

  779. 

  780. /* For name we use the ISO 3166-1 Alfa-3 value for the country,
    781. 

  781.  * for description we use the Country Name and
    782. 

  782.  * for value we use the DMP value for National Policy Identifier.
    783. 

  783.  */
    784. 

  784. static const enum_val_t dmp_national_values[MAX_NATIONAL_VALUES+1] = {
    785. 

  785.   { "???",  "None", 0x00 },
    786. 

  786.   { "alb",  "Albania", 0x1B },
    787. 

  787.   { "arm",  "Armenia", 0x20 },
    788. 

  788.   { "aut",  "Austria", 0x21 },
    789. 

  789.   { "aze",  "Azerbaijan", 0x22 },
    790. 

  790.   { "blr",  "Belarus", 0x23 },
    791. 

  791.   { "bel",  "Belgium", 0x01 },
    792. 

  792.   { "bih",  "Bosnia and Hercegowina", 0x24 },
    793. 

  793.   { "bgr",  "Bulgaria", 0x02 },
    794. 

  794.   { "can",  "Canada", 0x03 },
    795. 

  795.   { "hrv",  "Croatia", 0x1C },
    796. 

  796.   { "cze",  "Czech Republic", 0x04 },
    797. 

  797.   { "dnk",  "Denmark", 0x05 },
    798. 

  798.   { "est",  "Estonia", 0x06 },
    799. 

  799.   { "eapc", "Euro-Atlantic Partnership Council (EAPC)", 0x3A },
    800. 

  800.   { "eu",   "European Union (EU)", 0x3B },
    801. 

  801.   { "fin",  "Finland", 0x25 },
    802. 

  802.   { "mkd",  "Former Yugoslav Republic of Macedonia", 0x26 },
    803. 

  803.   { "fra",  "France", 0x07 },
    804. 

  804.   { "geo",  "Georgia", 0x27 },
    805. 

  805.   { "deu",  "Germany", 0x08 },
    806. 

  806.   { "grc",  "Greece", 0x09 },
    807. 

  807.   { "hun",  "Hungary", 0x0A },
    808. 

  808.   { "isl",  "Iceland", 0x0B },
    809. 

  809.   { "isaf", "International Security Assistance Force (ISAF)", 0x3C },
    810. 

  810.   { "irl",  "Ireland", 0x28 },
    811. 

  811.   { "ita",  "Italy", 0x0C },
    812. 

  812.   { "kaz",  "Kazakhstan", 0x29 },
    813. 

  813.   { "kgz",  "Kyrgyztan", 0x2A },
    814. 

  814.   { "lva",  "Latvia", 0x0D },
    815. 

  815.   { "ltu",  "Lithuania", 0x0E },
    816. 

  816.   { "lux",  "Luxembourg", 0x0F },
    817. 

  817.   { "mlt",  "Malta", 0x2B },
    818. 

  818.   { "mda",  "Moldova", 0x2C },
    819. 

  819.   { "mne",  "Montenegro", 0x2D },
    820. 

  820.   { "nld",  "Netherlands", 0x10 },
    821. 

  821.   { "nor",  "Norway", 0x11 },
    822. 

  822.   { "pfp",  "Partnership for Peace (PfP)", 0x3D },
    823. 

  823.   { "pol",  "Poland", 0x12 },
    824. 

  824.   { "ptr",  "Portugal", 0x13 },
    825. 

  825.   { "rou",  "Romania", 0x14 },
    826. 

  826.   { "rus",  "Russian Federation", 0x2E },
    827. 

  827.   { "srb",  "Serbia", 0x2F },
    828. 

  828.   { "svk",  "Slovakia", 0x15 },
    829. 

  829.   { "svn",  "Slovenia", 0x16 },
    830. 

  830.   { "esp",  "Spain", 0x17 },
    831. 

  831.   { "swe",  "Sweden", 0x30 },
    832. 

  832.   { "che",  "Switzerland", 0x31 },
    833. 

  833.   { "tjk",  "Tajikistan", 0x32 },
    834. 

  834.   { "tur",  "Turkey", 0x18 },
    835. 

  835.   { "tkm",  "Turkmenistan", 0x33 },
    836. 

  836.   { "gbr",  "United Kingdom", 0x19 },
    837. 

  837.   { "usa",  "United States", 0x1A },
    838. 

  838.   { "ukr",  "Ukraine", 0x34 },
    839. 

  839.   { "uzb",  "Uzbekistan", 0x35 },
    840. 

  840.   { "weu",  "Western European Union (WEU)", 0x3E },
    841. 

  841.   { NULL, NULL, 0 }
    842. 

  842. };
    843. 

  843. 

  844. static const value_string ext_sec_cat[] = {
    845. 

  845.   { 0x0, "Not present"                  },
    846. 

  846.   { 0x1, "Permissive category follows"  },
    847. 

  847.   { 0x2, "Restrictive category follows" },
    848. 

  848.   { 0x3, "Reserved"                     },
    849. 

  849.   { 0,   NULL } };
    850. 

  850. 

  851. static const value_string sic_key_type[] = {
    852. 

  852.   { 0xc, "2 or more 3-character SICs"      },
    853. 

  853.   { 0xd, "1 or more 3-to-8 character SICs" },
    854. 

  854.   { 0,   NULL } };
    855. 

  855. 

  856. static const true_false_string sic_key_chars = {
    857. 

  857.   "Any", "[A-Z0-9] only"
    858. 

  858. };
    859. 

  859. 

  860. static const value_string sic_key_num[] = {
    861. 

  861.   { 0, "1"  },
    862. 

  862.   { 1, "2"  },
    863. 

  863.   { 2, "3"  },
    864. 

  864.   { 3, "4"  },
    865. 

  865.   { 4, "5"  },
    866. 

  866.   { 5, "6"  },
    867. 

  867.   { 6, "7"  },
    868. 

  868.   { 7, "8"  },
    869. 

  869.   { 0, NULL } };
    870. 

  870. 

  871. 

  872. static const value_string sic_bit_vals[] = {
    873. 

  873.   { 0,   "length:6, bytes:4" },
    874. 

  874.   { 1,   "length:6, bytes:4" },
    875. 

  875.   { 2,   "length:6, bytes:4" },
    876. 

  876.   { 3,   "length:6, bytes:4" },
    877. 

  877.   { 4,   "length:6, bytes:4" },
    878. 

  878.   { 5,   "length:6, bytes:4" },
    879. 

  879.   { 6,   "length:6, bytes:4" },
    880. 

  880.   { 7,   "length:6, bytes:4" },
    881. 

  881.   { 8,   "length:6, bytes:4" },
    882. 

  882.   { 9,   "reserved"          },
    883. 

  883.   { 10,  "length:5, bytes:4" },
    884. 

  884.   { 11,  "length:8, bytes:6" },
    885. 

  885.   { 12,  "length:4, bytes:3" },
    886. 

  886.   { 13,  "length:4, bytes:3" },
    887. 

  887.   { 14,  "length:7, bytes:5" },
    888. 

  888.   { 15,  "length:7, bytes:5" },
    889. 

  889.   { 0,   NULL } };
    890. 

  890. 

  891. static const value_string sic_bit_any_vals[] = {
    892. 

  892.   { 0,   "length:5, bytes:4" },
    893. 

  893.   { 1,   "length:5, bytes:4" },
    894. 

  894.   { 2,   "length:5, bytes:4" },
    895. 

  895.   { 3,   "length:5, bytes:4" },
    896. 

  896.   { 4,   "length:5, bytes:4" },
    897. 

  897.   { 5,   "length:5, bytes:4" },
    898. 

  898.   { 6,   "length:5, bytes:4" },
    899. 

  899.   { 7,   "length:5, bytes:4" },
    900. 

  900.   { 8,   "length:5, bytes:4" },
    901. 

  901.   { 9,   "length:8, bytes:7" },
    902. 

  902.   { 10,  "length:4, bytes:4" },
    903. 

  903.   { 11,  "length:7, bytes:6" },
    904. 

  904.   { 12,  "length:6, bytes:5" },
    905. 

  905.   { 13,  "length:6, bytes:5" },
    906. 

  906.   { 14,  "length:6, bytes:5" },
    907. 

  907.   { 15,  "length:6, bytes:5" },
    908. 

  908.   { 0,   NULL } };
    909. 

  909. 

  910. static const value_string body_format_vals[] = {
    911. 

  911.   { 0x0, "Free text"                    },
    912. 

  912.   { 0x1, "Free text including subject"  },
    913. 

  913.   { 0x2, "Structured"                   },
    914. 

  914.   { 0x3, "Reserved"                     },
    915. 

  915.   { 0,   NULL } };
    916. 

  916. 

  917. static const value_string eit_vals[] = {
    918. 

  918.   { 0x0, "Empty"                             },
    919. 

  919.   { 0x1, "IA5-text"                          },
    920. 

  920.   { 0x2, "General text"                      },
    921. 

  921.   { 0x3, "Bilaterally defined (binary data)" },
    922. 

  922.   { 0x4, "AdatP-3"                           },
    923. 

  923.   { 0x5, "Reserved"                          },
    924. 

  924.   { 0x6, "Reserved"                          },
    925. 

  925.   { 0x7, "Reserved"                          },
    926. 

  926.   { 0,   NULL } };
    927. 

  927. 

  928. static const value_string compression_vals[] = {
    929. 

  929.   { 0x0, "No compression"  },
    930. 

  930.   { 0x1, "ZLib compressed" },
    931. 

  931.   { 0x2, "Reserved"        },
    932. 

  932.   { 0x3, "Reserved"        },
    933. 

  933.   { 0,   NULL } };
    934. 

  934. 

  935. static const value_string ack_reason [] = {
    936. 

  936.   { 0x00, "Successful, positive acknowledgement" },
    937. 

  937.   { 0x01, "Unspecified error"                    },
    938. 

  938.   { 0x02, "Checksum incorrect"                   },
    939. 

  939.   { 0,    NULL } };
    940. 

  940. 

  941. static const value_string non_del_reason [] = {
    942. 

  942.   { 0x3D, "Unknown reason"                     },
    943. 

  943.   { 0x3E, "Reason code greater than 0x3c (60)" },
    944. 

  944.   { 0x3F, "Reserved"                           },
    945. 

  945.   { 0,    NULL } };
    946. 

  946. 

  947. static const value_string non_del_diagn [] = {
    948. 

  948.   { 0x7C, "Diagnostic not specified"                },
    949. 

  949.   { 0x7D, "Unknown diagnostic"                      },
    950. 

  950.   { 0x7E, "Diagnostic code greater than 0x7b (123)" },
    951. 

  951.   { 0x7F, "Reserved"                                },
    952. 

  952.   { 0,    NULL } };
    953. 

  953. 

  954. static const value_string discard_reason [] = {
    955. 

  955.   { 0xFE, "Discard Reason absent" },
    956. 

  956.   { 0xFF, "Reserved"              },
    957. 

  957.   { 0,    NULL } };
    958. 

  958. 

  959. static const value_string on_type [] = {
    960. 

  960.   { 0x00, "acp127-nn" },
    961. 

  961.   { 0x01, "acp127-pn" },
    962. 

  962.   { 0x02, "acp127-tn" },
    963. 

  963.   { 0,    NULL } };
    964. 

  964. 

  965. static const value_string ack_msg_type [] = {
    966. 

  966.   { STANAG, " (message)" },
    967. 

  967.   { IPM,    " (e-mail)"  },
    968. 

  968.   { REPORT, " (report)"  },
    969. 

  969.   { NOTIF,  " (notif)"   },
    970. 

  970.   { ACK,    " (ack)"     },
    971. 

  971.   { 0,      NULL } };
    972. 

  972. 

  973. static const enum_val_t struct_id_options[] = {
    974. 

  974.   { "none",    "None",                        STRUCT_ID_NONE     },
    975. 

  975.   { "1byte",   "1 Byte value",                STRUCT_ID_UINT8    },
    976. 

  976.   { "2byte",   "2 Byte value",                STRUCT_ID_UINT16   },
    977. 

  977.   { "4byte",   "4 Byte value",                STRUCT_ID_UINT32   },
    978. 

  978.   { "8byte",   "8 Byte value",                STRUCT_ID_UINT64   },
    979. 

  979.   { "fstring", "Fixed text string",           STRUCT_ID_STRING   },
    980. 

  980.   { "zstring", "Zero terminated text string", STRUCT_ID_ZSTRING  },
    981. 

  981.   { NULL,      NULL,                          0                  }
    982. 

  982. };
    983. 

  983. 

  984. static const enum_val_t national_decoding[] = {
    985. 

  985.   { "none",    "None (raw data)", NAT_DECODE_NONE   },
    986. 

  986.   { "dmp",     "As for regular",  NAT_DECODE_DMP    },
    987. 

  987.   { "thales",  "Thales XOmail",   NAT_DECODE_THALES },
    988. 

  988.   { NULL,      NULL, 0 }
    989. 

  989. };
    990. 

  990. 

  991. static const value_string ipm_id_modifier[] = {
    992. 

  992.   { 0x0,  "X.400 IPM Identifier" },
    993. 

  993.   { 0x1,  "Nationally-defined"   },
    994. 

  994.   { 0x2,  "Nationally-defined"   },
    995. 

  995.   { 0x3,  "Nationally-defined"   },
    996. 

  996.   { 0, NULL }
    997. 

  997. };
    998. 

  998. 

  999. static const value_string thales_ipm_id_modifier[] = {
    1000. 

  1000.   { 0x0,  "X.400 IPM Identifier" },
    1001. 

  1001.   { 0x1,  "3 or 5 digits"        },
    1002. 

  1002.   { 0x2,  "4 digits"             },
    1003. 

  1003.   { 0x3,  "5 digits"             },
    1004. 

  1004.   { 0, NULL }
    1005. 

  1005. };
    1006. 

  1006. 

  1007. UAT_VS_DEF(dmp_security_class, nation, dmp_security_class_t, guint, 0, "None")
    1008. 

  1008. UAT_DEC_CB_DEF(dmp_security_class, sec_class, dmp_security_class_t)
    1009. 

  1009. UAT_CSTRING_CB_DEF(dmp_security_class, name, dmp_security_class_t)
    1010. 

  1010. 

  1011. static void *
    1012. 

  1012. dmp_class_copy_cb(void *dest, const void *orig, size_t len _U_)
    1013. 

  1013. {
    1014. 

  1014.   dmp_security_class_t *u = (dmp_security_class_t *)dest;
    1015. 

  1015.   const dmp_security_class_t *o = (const dmp_security_class_t *)orig;
    1016. 

  1016. 

  1017.   u->nation = o->nation;
    1018. 

  1018.   u->sec_class = o->sec_class;
    1019. 

  1019.   u->name = g_strdup(o->name);
    1020. 

  1020. 

  1021.   return dest;
    1022. 

  1022. }
    1023. 

  1023. 

  1024. static void
    1025. 

  1025. dmp_class_free_cb(void *r)
    1026. 

  1026. {
    1027. 

  1027.   dmp_security_class_t *u = (dmp_security_class_t *)r;
    1028. 

  1028. 

  1029.   g_free(u->name);
    1030. 

  1030. }
    1031. 

  1031. 

  1032. static gchar *dmp_national_sec_class (guint nation, guint dmp_sec_class)
    1033. 

  1033. {
    1034. 

  1034.   guint i;
    1035. 

  1035. 

  1036.   for (i = 0; i < num_dmp_security_classes; i++) {
    1037. 

  1037.     dmp_security_class_t *u = &(dmp_security_classes[i]);
    1038. 

  1038. 

  1039.     if (u->nation == nation && u->sec_class == dmp_sec_class) {
    1040. 

  1040.       return u->name;
    1041. 

  1041.     }
    1042. 

  1042.   }
    1043. 

  1043. 

  1044.   return NULL;
    1045. 

  1045. }
    1046. 

  1046. 

  1047. static void build_national_strings (void)
    1048. 

  1048. {
    1049. 

  1049.   gint i = 0;
    1050. 

  1050. 

  1051.   /*
    1052. 

  1052.   ** We use values from dmp_national_values to build value_string for nat_pol_id.
    1053. 

  1053.   */
    1054. 

  1054.   while (dmp_national_values[i].name && i < MAX_NATIONAL_VALUES) {
    1055. 

  1055.     nat_pol_id[i].value  = dmp_national_values[i].value;
    1056. 

  1056.     nat_pol_id[i].strptr = dmp_national_values[i].description;
    1057. 

  1057.     i++;
    1058. 

  1058.   }
    1059. 

  1059.   nat_pol_id[i].value = 0;
    1060. 

  1060.   nat_pol_id[i].strptr = NULL;
    1061. 

  1061. }
    1062. 

  1062. 

  1063. static const gchar *get_nat_pol_id_short (gint nation)
    1064. 

  1064. {
    1065. 

  1065.   gint i = 0;
    1066. 

  1066.   while (dmp_national_values[i].name) {
    1067. 

  1067.     if (dmp_national_values[i].value == nation) {
    1068. 

  1068.       return dmp_national_values[i].name;
    1069. 

  1069.     }
    1070. 

  1070.     i++;
    1071. 

  1071.   }
    1072. 

  1072. 

  1073.   return "???";
    1074. 

  1074. }
    1075. 

  1075. 

  1076. static const gchar *msg_type_to_str (void)
    1077. 

  1077. {
    1078. 

  1078.   const gchar *msg_type;
    1079. 

  1079.   gboolean     have_msg = FALSE;
    1080. 

  1080. 

  1081.   switch (dmp.msg_type) {
    1082. 

  1082. 

  1083.   case STANAG:
    1084. 

  1084.     /* Include message type and precedence */
    1085. 

  1085.     msg_type = ep_strdup_printf ("%s (%s) [%s]",
    1086. 

  1086.                 val_to_str_const (dmp.msg_type, type_vals, "Unknown"),
    1087. 

  1087.                 val_to_str_const (dmp.st_type, message_type_vals, "Unknown"),
    1088. 

  1088.                 (dmp.prec == 0x6 || dmp.prec == 0x7) ?
    1089. 

  1089.                 val_to_str_const (dmp.prec-4, precedence, "Unknown") :
    1090. 

  1090.                 val_to_str_const (dmp.prec, precedence, "Unknown"));
    1091. 

  1091.     break;
    1092. 

  1092. 

  1093.   case IPM:
    1094. 

  1094.     /* Include importance */
    1095. 

  1095.     msg_type = ep_strdup_printf ("%s [%s]",
    1096. 

  1096.                 val_to_str_const (dmp.msg_type, type_vals, "Unknown"),
    1097. 

  1097.                 val_to_str_const (dmp.prec, importance, "Unknown"));
    1098. 

  1098.     break;
    1099. 

  1099. 

  1100.   case REPORT:
    1101. 

  1101.     /* Include report types included */
    1102. 

  1102.     msg_type = ep_strdup_printf ("Report (%s%s%s)",
    1103. 

  1103.                 dmp.dr ? "DR" : "", (dmp.dr && dmp.ndr) ? " and " : "",
    1104. 

  1104.                 dmp.ndr ? "NDR" : "");
    1105. 

  1105.     break;
    1106. 

  1106. 

  1107.   case NOTIF:
    1108. 

  1108.     msg_type = val_to_str_const (dmp.notif_type, notif_type, "Unknown");
    1109. 

  1109.     break;
    1110. 

  1110. 

  1111.   case ACK:
    1112. 

  1112.     /* If we have msg_time we have a matching packet */
    1113. 

  1113.     have_msg = (dmp.id_val &&
    1114. 

  1114.                 (dmp.id_val->msg_time.secs>0 || dmp.id_val->msg_time.nsecs>0));
    1115. 

  1115.     msg_type = ep_strdup_printf ( "Acknowledgement%s%s",
    1116. 

  1116.                 have_msg ? val_to_str (dmp.id_val->msg_type, ack_msg_type,
    1117. 

  1117.                                        " (unknown:%d)") : "",
    1118. 

  1118.                 dmp.ack_reason ? " [negative]" : "");
    1119. 

  1119.     break;
    1120. 

  1120. 

  1121.   default:
    1122. 

  1122.     msg_type = "Unknown";
    1123. 

  1123.     break;
    1124. 

  1124.   }
    1125. 

  1125. 

  1126.   return msg_type;
    1127. 

  1127. }
    1128. 

  1128. 

  1129. static const gchar *non_del_reason_str (guint32 value)
    1130. 

  1130. {
    1131. 

  1131.   if (value < 0x3D) {
    1132. 

  1132.     /* Standard values according to P1 */
    1133. 

  1133.     return val_to_str_const (value, p1_NonDeliveryReasonCode_vals, "Unknown");
    1134. 

  1134.   } else {
    1135. 

  1135.     return val_to_str_const (value, non_del_reason, "Unknown");
    1136. 

  1136.   }
    1137. 

  1137. }
    1138. 

  1138. 

  1139. static const gchar *non_del_diagn_str (guint32 value)
    1140. 

  1140. {
    1141. 

  1141.   if (value < 0x7C) {
    1142. 

  1142.     /* Standard values according to P1 */
    1143. 

  1143.     return val_to_str_const (value, p1_NonDeliveryDiagnosticCode_vals, "Unknown");
    1144. 

  1144.   } else {
    1145. 

  1145.     return val_to_str_const (value, non_del_diagn, "Unknown");
    1146. 

  1146.   }
    1147. 

  1147. }
    1148. 

  1148. 

  1149. static const gchar *nrn_reason_str (guint32 value)
    1150. 

  1150. {
    1151. 

  1151.   /* Standard values according to P22 */
    1152. 

  1152.   return val_to_str_const (value, p22_NonReceiptReasonField_vals, "Reserved");
    1153. 

  1153. }
    1154. 

  1154. 

  1155. static const gchar *discard_reason_str (guint32 value)
    1156. 

  1156. {
    1157. 

  1157.   if (value < 0xFE) {
    1158. 

  1158.     /* Standard values according to P22 */
    1159. 

  1159.     return val_to_str_const (value, p22_DiscardReasonField_vals, "Reserved");
    1160. 

  1160.   } else {
    1161. 

  1161.     return val_to_str_const (value, discard_reason, "Unknown");
    1162. 

  1162.   }
    1163. 

  1163. }
    1164. 

  1164. 

  1165. /* Ref chapter 6.2.8.10 TimeDifference */
    1166. 

  1166. static gint32 dmp_dec_time_diff (guint8 dmp_time_diff)
    1167. 

  1167. {
    1168. 

  1168.   gint32 time_diff = 0;
    1169. 

  1169. 

  1170.   if (dmp_time_diff <= 0x01) {
    1171. 

  1171.     /* Reserved - low value */
    1172. 

  1172.     time_diff = DMP_TIME_RESERVED;
    1173. 

  1173.   } else if (dmp_time_diff <= 0x1D) {
    1174. 

  1174.     /* Number of 2-second units (2-58 seconds) */
    1175. 

  1175.     time_diff = dmp_time_diff * 2;
    1176. 

  1176.   } else if (dmp_time_diff <= 0x91) {
    1177. 

  1177.     /* Number of 15-second units (1 min - 29 min 45 sec) */
    1178. 

  1178.     time_diff = (dmp_time_diff - 0x1D + 3) * 15;
    1179. 

  1179.   } else if (dmp_time_diff  <= 0xDF) {
    1180. 

  1180.     /* Number of 5-minute units (30 min - 6 hours 55 min) */
    1181. 

  1181.     time_diff = (dmp_time_diff - 0x91 + 5) * 5*60;
    1182. 

  1182.   } else if (dmp_time_diff <= 0xF7) {
    1183. 

  1183.     /* Number of 30-minute units (7 hours - 18 hours 30 min) */
    1184. 

  1184.     time_diff = (dmp_time_diff - 0xDF + 7) * 30*60;
    1185. 

  1185.   } else {
    1186. 

  1186.     /* Reserved - high value */
    1187. 

  1187.     time_diff = DMP_TIME_RESERVED;
    1188. 

  1188.   }
    1189. 

  1189. 

  1190.   return time_diff;
    1191. 

  1191. }
    1192. 

  1192. 

  1193. /*
    1194. 

  1194.  * Ref chapter 6.3.7.2.10 ExpiryTime
    1195. 

  1195.  * and chapter 6.3.9.2.2  DeliveryTime
    1196. 

  1196.  */
    1197. 

  1197. static gint32 dmp_dec_exp_del_time (guint8 timev, gboolean expiry_time)
    1198. 

  1198. {
    1199. 

  1199.   gint32 time_value = 0;
    1200. 

  1200. 

  1201.   if (expiry_time && (timev == 0x00)) {
    1202. 

  1202.     /* No expiry time */
    1203. 

  1203.     time_value = DMP_TIME_NOT_PRESENT;
    1204. 

  1204.   } else if (timev <= 0x1D) {
    1205. 

  1205.     /* Number of 2-second units (2-58 seconds) */
    1206. 

  1206.     time_value = timev * 2;
    1207. 

  1207.   } else if (timev <= 0x91) {
    1208. 

  1208.     /* Number of 15-second units (1 min - 29 min 45 sec) */
    1209. 

  1209.     time_value = (timev - 0x1D + 3) * 15;
    1210. 

  1210.   } else if (timev <= 0xBB) {
    1211. 

  1211.     /* Number of 5-minute units (30 min - 3 hours 55 min) */
    1212. 

  1212.     time_value = (timev - 0x91 + 5) * 5*60;
    1213. 

  1213.   } else if (timev <= 0xE3) {
    1214. 

  1214.     /* Number of 30-minute units (4 hours - 23 hours 30 min) */
    1215. 

  1215.     time_value = (timev - 0xBB + 7) * 30*60;
    1216. 

  1216.   } else if (timev < 0xFF) {
    1217. 

  1217.     /* Number of 2-hour units (24 - 78 hours) */
    1218. 

  1218.     time_value = (timev - 0xE3 + 11) * 2*3600;
    1219. 

  1219.   } else {
    1220. 

  1220.     /* Reserved */
    1221. 

  1221.     time_value = DMP_TIME_RESERVED;
    1222. 

  1222.   }
    1223. 

  1223. 

  1224.   return time_value;
    1225. 

  1225. }
    1226. 

  1226. 

  1227. static gint32 dmp_dec_exp_time (guint8 expiry_time)
    1228. 

  1228. {
    1229. 

  1229.   return dmp_dec_exp_del_time (expiry_time, TRUE);
    1230. 

  1230. }
    1231. 

  1231. 

  1232. static gint32 dmp_dec_del_time (guint8 delivery_time)
    1233. 

  1233. {
    1234. 

  1234.   return dmp_dec_exp_del_time (delivery_time, FALSE);
    1235. 

  1235. }
    1236. 

  1236. 

  1237. /* Ref chapter 6.3.7.2.11 DTG */
    1238. 

  1238. static gint32 dmp_dec_dtg (guint32 dtg)
    1239. 

  1239. {
    1240. 

  1240.   gint32 value;
    1241. 

  1241. 

  1242.   if (dtg == 0x00) {
    1243. 

  1243.     /* Not present */
    1244. 

  1244.     value = DMP_TIME_NOT_PRESENT;
    1245. 

  1245.   } else if (dtg <= 0x3C) {
    1246. 

  1246.     /* Number of minutes (0-59 min) */
    1247. 

  1247.     value = (dtg - 1) * 60;
    1248. 

  1248.   } else if (dtg <= 0x64) {
    1249. 

  1249.     /* Number of 15-minute units (1 hour - 10 hours 45 min) */
    1250. 

  1250.     value = (dtg - 0x3C + 3) * 15 * 60;
    1251. 

  1251.   } else if (dtg < 0x7F) {
    1252. 

  1252.     /* Number of hours (11-36 hours) */
    1253. 

  1253.     value = (dtg - 0x64 + 10) * 3600;
    1254. 

  1254.   } else {
    1255. 

  1255.     /* Reserved */
    1256. 

  1256.     value = DMP_TIME_RESERVED;
    1257. 

  1257.   }
    1258. 

  1258. 

  1259.   return value;
    1260. 

  1260. }
    1261. 

  1261. 

  1262. /*
    1263. 

  1263.  * Ref chapter 7.10.11.1 Submission time
    1264. 

  1264.  *
    1265. 

  1265.  * start_time                 (current time)
    1266. 

  1266.  * delta1     = E             (encoded submission time)
    1267. 

  1267.  * delta2     = C             (encoded current time)
    1268. 

  1268.  * 0x01C2     = Pn + 15min    (maximum point for S1)
    1269. 

  1269.  * 0x7E38     = Pn+1 - 15min  (minimum point for S3)
    1270. 

  1270.  * 0x7FF8     = Pn+1          (length of P (period))
    1271. 

  1271.  */
    1272. 

  1272. static gint32 dmp_dec_subm_time (guint16 delta1, gint32 start_time)
    1273. 

  1273. {
    1274. 

  1274.   gint32  subm_time = start_time;
    1275. 

  1275.   guint16 delta2;
    1276. 

  1276. 

  1277.   delta2 = (guint16) ((subm_time / 2) % 0x7FF8);
    1278. 

  1278. 

  1279.   if ((delta1 < 0x01C2) && (delta2 >= delta1 + 0x7E38)) {
    1280. 

  1280.     subm_time += 2 * (0x7FF8 - delta2 + delta1);
    1281. 

  1281.   } else if ((delta1 >= 0x01C2) && (delta2 < delta1 - 0x01C2)) {
    1282. 

  1282.     subm_time -= 2 * (0x7FF8 - delta1 + delta2);
    1283. 

  1283.   } else {
    1284. 

  1284.     subm_time -= 2 * (delta2 - delta1);
    1285. 

  1285.   }
    1286. 

  1286. 

  1287.   return subm_time;
    1288. 

  1288. }
    1289. 

  1289. 

  1290. /* Ref chapter 6.3.7.2.12 SIC */
    1291. 

  1291. static gboolean dmp_dec_xbyte_sic (guint64 bin, gchar *sic,
    1292. 

  1292.                                    guint8 no_char, gboolean any)
    1293. 

  1293. {
    1294. 

  1294.   gboolean failure = FALSE;
    1295. 

  1295.   gdouble  multiplier;
    1296. 

  1296.   guint8   i;
    1297. 

  1297.   guint64  p, tmp;
    1298. 

  1298. 

  1299.   if (no_char >= MAX_SIC_LEN) {
    1300. 

  1300.     /* Illegal length */
    1301. 

  1301.     g_snprintf (sic, MAX_SIC_LEN, "Illegal length: %d", no_char);
    1302. 

  1302.     return TRUE;
    1303. 

  1303.   }
    1304. 

  1304. 

  1305.   if (any) {
    1306. 

  1306.     multiplier = 74.0;
    1307. 

  1307.   } else {
    1308. 

  1308.     multiplier = 36.0;
    1309. 

  1309.   }
    1310. 

  1310. 

  1311.   for (i = 0; i < no_char; i++) {
    1312. 

  1312.     p = (guint64) pow (multiplier, no_char - 1 - i);
    1313. 

  1313.     tmp = bin / p;
    1314. 

  1314.     bin -= tmp * p;
    1315. 

  1315.     sic[i] = (gchar) tmp;
    1316. 

  1316.     if (sic[i] <= 9) {
    1317. 

  1317.       sic[i] += '0';
    1318. 

  1318.     } else if (sic[i] <= 35) {
    1319. 

  1319.       sic[i] += ('A' - 10);
    1320. 

  1320.     } else if (!any) {
    1321. 

  1321.       sic[i] = '*';
    1322. 

  1322.       failure = TRUE;
    1323. 

  1323.     } else if (sic[i] <= 61) {
    1324. 

  1324.       sic[i] += ('a' - 36);
    1325. 

  1325.     } else if (sic[i] == 62) {
    1326. 

  1326.       sic[i] = '\'';
    1327. 

  1327.     } else if (sic[i] == 63) {
    1328. 

  1328.       sic[i] = '(';
    1329. 

  1329.     } else if (sic[i] == 64) {
    1330. 

  1330.       sic[i] = ')';
    1331. 

  1331.     } else if (sic[i] == 65) {
    1332. 

  1332.       sic[i] = '+';
    1333. 

  1333.     } else if (sic[i] == 66) {
    1334. 

  1334.       sic[i] = ',';
    1335. 

  1335.     } else if (sic[i] == 67) {
    1336. 

  1336.       sic[i] = '-';
    1337. 

  1337.     } else if (sic[i] == 68) {
    1338. 

  1338.       sic[i] = '.';
    1339. 

  1339.     } else if (sic[i] == 69) {
    1340. 

  1340.       sic[i] = '/';
    1341. 

  1341.     } else if (sic[i] == 70) {
    1342. 

  1342.       sic[i] = ':';
    1343. 

  1343.     } else if (sic[i] == 71) {
    1344. 

  1344.       sic[i] = '=';
    1345. 

  1345.     } else if (sic[i] == 72) {
    1346. 

  1346.       sic[i] = '?';
    1347. 

  1347.     } else if (sic[i] == 73) {
    1348. 

  1348.       sic[i] = ' ';
    1349. 

  1349.     } else {
    1350. 

  1350.       sic[i] = '*';
    1351. 

  1351.       failure = TRUE;
    1352. 

  1352.     }
    1353. 

  1353.   }
    1354. 

  1354.   sic[i] = '\0';
    1355. 

  1355. 

  1356.   return failure;
    1357. 

  1357. }
    1358. 

  1358. 

  1359. static guint dmp_id_hash (gconstpointer k)
    1360. 

  1360. {
    1361. 

  1361.   dmp_id_key *dmpx=(dmp_id_key *)k;
    1362. 

  1362.   return dmpx->id;
    1363. 

  1363. }
    1364. 

  1364. 

  1365. static gint dmp_id_hash_equal (gconstpointer k1, gconstpointer k2)
    1366. 

  1366. {
    1367. 

  1367.   dmp_id_key *dmp1=(dmp_id_key *)k1;
    1368. 

  1368.   dmp_id_key *dmp2=(dmp_id_key *)k2;
    1369. 

  1369.   if (dmp1->id != dmp2->id)
    1370. 

  1370.     return 0;
    1371. 

  1371. 

  1372.   return (ADDRESSES_EQUAL (&dmp1->src, &dmp2->src) &&
    1373. 

  1373.           ADDRESSES_EQUAL (&dmp1->dst, &dmp2->dst));
    1374. 

  1374. }
    1375. 

  1375. 

  1376. static void register_dmp_id (packet_info *pinfo, guint8 reason)
    1377. 

  1377. {
    1378. 

  1378.   dmp_id_val *dmp_data = NULL, *pkg_data = NULL;
    1379. 

  1379.   dmp_id_key *dmp_key = NULL;
    1380. 

  1380.   nstime_t    msg_time;
    1381. 

  1381.   guint       msg_id = 0;
    1382. 

  1382. 

  1383.   if (pinfo->flags.in_error_pkt) {
    1384. 

  1384.     /* No analysis of error packets */
    1385. 

  1385.     return;
    1386. 

  1386.   }
    1387. 

  1387. 

  1388.   nstime_set_zero(&msg_time);
    1389. 

  1389. 

  1390.   dmp_key = se_new (dmp_id_key);
    1391. 

  1391. 

  1392.   if (!pinfo->fd->flags.visited &&
    1393. 

  1393.       (dmp.msg_type == REPORT || dmp.msg_type == NOTIF))
    1394. 

  1394.   {
    1395. 

  1395.     /* Try to match corresponding message */
    1396. 

  1396.     dmp_key->id = (guint) dmp.subj_id;
    1397. 

  1397.     SE_COPY_ADDRESS(&dmp_key->src, &(pinfo->dst));
    1398. 

  1398.     SE_COPY_ADDRESS(&dmp_key->dst, &(pinfo->src));
    1399. 

  1399. 

  1400.     dmp_data = (dmp_id_val *) g_hash_table_lookup (dmp_id_hash_table, dmp_key);
    1401. 

  1401. 

  1402.     if (dmp_data) {
    1403. 

  1403.       /* Found message */
    1404. 

  1404.       if (dmp_data->prev_msg_id > 0) {
    1405. 

  1405.         msg_id = dmp_data->prev_msg_id;
    1406. 

  1406.       } else {
    1407. 

  1407.         msg_id = dmp_data->msg_id;
    1408. 

  1408.       }
    1409. 

  1409.       msg_time = dmp_data->msg_time;
    1410. 

  1410.     }
    1411. 

  1411.   }
    1412. 

  1412. 

  1413.   if (dmp.msg_type == ACK) {
    1414. 

  1414.     dmp_key->id = (guint) dmp.subj_id;
    1415. 

  1415.     SE_COPY_ADDRESS(&dmp_key->src, &(pinfo->dst));
    1416. 

  1416.     SE_COPY_ADDRESS(&dmp_key->dst, &(pinfo->src));
    1417. 

  1417.   } else {
    1418. 

  1418.     dmp_key->id = (guint) dmp.msg_id;
    1419. 

  1419.     SE_COPY_ADDRESS(&dmp_key->src, &(pinfo->src));
    1420. 

  1420.     SE_COPY_ADDRESS(&dmp_key->dst, &(pinfo->dst));
    1421. 

  1421.   }
    1422. 

  1422. 

  1423.   dmp_data = (dmp_id_val *) g_hash_table_lookup (dmp_id_hash_table, dmp_key);
    1424. 

  1424. 

  1425.   if (!pinfo->fd->flags.visited) {
    1426. 

  1426.     if (dmp_data) {
    1427. 

  1427.       if (dmp.msg_type == ACK) {
    1428. 

  1428.         /* Only save this data if positive ack */
    1429. 

  1429.         if (reason == 0) {
    1430. 

  1430.           if (dmp_data->ack_id == 0) {
    1431. 

  1431.             /* Only save reference to first ACK */
    1432. 

  1432.             dmp_data->ack_id = pinfo->fd->num;
    1433. 

  1433.           } else {
    1434. 

  1434.             /* Only count when resending */
    1435. 

  1435.             dmp_data->ack_resend_count++;
    1436. 

  1436.           }
    1437. 

  1437.         }
    1438. 

  1438.       } else {
    1439. 

  1439.         /* Message resent */
    1440. 

  1440.         dmp_data->msg_resend_count++;
    1441. 

  1441.         dmp_data->prev_msg_id = pinfo->fd->num;
    1442. 

  1442.         dmp_data->prev_msg_time = dmp_data->msg_time;
    1443. 

  1443.         dmp_data->msg_time = pinfo->fd->abs_ts;
    1444. 

  1444.       }
    1445. 

  1445.     } else {
    1446. 

  1446.       /* New message */
    1447. 

  1447.       dmp_data = se_new0 (dmp_id_val);
    1448. 

  1448.       dmp_data->msg_type = dmp.msg_type;
    1449. 

  1449. 

  1450.       if (dmp.msg_type == ACK) {
    1451. 

  1451.         /* No matching message for this ack */
    1452. 

  1452.         dmp_data->ack_id = pinfo->fd->num;
    1453. 

  1453.       } else {
    1454. 

  1454.         dmp_data->first_msg_time = pinfo->fd->abs_ts;
    1455. 

  1455.         dmp_data->msg_time = pinfo->fd->abs_ts;
    1456. 

  1456. 

  1457.         if (dmp.msg_type == REPORT) {
    1458. 

  1458.           dmp_data->rep_id = pinfo->fd->num;
    1459. 

  1459.           dmp_data->msg_id = msg_id;
    1460. 

  1460.           dmp_data->rep_not_msg_time = msg_time;
    1461. 

  1461.         } else if (dmp.msg_type == NOTIF) {
    1462. 

  1462.           dmp_data->not_id = pinfo->fd->num;
    1463. 

  1463.           dmp_data->msg_id = msg_id;
    1464. 

  1464.           dmp_data->rep_not_msg_time = msg_time;
    1465. 

  1465.         } else {
    1466. 

  1466.           dmp_data->msg_id = pinfo->fd->num;
    1467. 

  1467.         }
    1468. 

  1468. 

  1469.         g_hash_table_insert (dmp_id_hash_table, dmp_key, dmp_data);
    1470. 

  1470.       }
    1471. 

  1471.     }
    1472. 

  1472. 

  1473.     pkg_data = se_new (dmp_id_val);
    1474. 

  1474.     *pkg_data = *dmp_data;
    1475. 

  1475.     p_add_proto_data (pinfo->fd, proto_dmp, 0, pkg_data);
    1476. 

  1476.   } else {
    1477. 

  1477.     /* Fetch last values from data saved in packet */
    1478. 

  1478.     pkg_data = (dmp_id_val *)p_get_proto_data (pinfo->fd, proto_dmp, 0);
    1479. 

  1479. 

  1480.     if (dmp_data && pkg_data && dmp.msg_type != ACK && pkg_data->ack_id == 0) {
    1481. 

  1481.       pkg_data->ack_id = dmp_data->ack_id;
    1482. 

  1482.     }
    1483. 

  1483.   }
    1484. 

  1484. 

  1485.   DISSECTOR_ASSERT (pkg_data);
    1486. 

  1486.   dmp.id_val = pkg_data;
    1487. 

  1487. }
    1488. 

  1488. 

  1489. static void dmp_add_seq_ack_analysis (tvbuff_t *tvb, packet_info *pinfo,
    1490. 

  1490.                                       proto_tree *dmp_tree, gint offset)
    1491. 

  1491. {
    1492. 

  1492.   proto_tree *analysis_tree = NULL;
    1493. 

  1493.   proto_item *en = NULL, *eh = NULL;
    1494. 

  1494.   nstime_t    ns;
    1495. 

  1495. 

  1496.   if (dmp.msg_type > ACK || (dmp.msg_type < ACK && !dmp.checksum) ||
    1497. 

  1497.       dmp.id_val == NULL || pinfo->flags.in_error_pkt)
    1498. 

  1498.   {
    1499. 

  1499.     /* No need for seq/ack analysis */
    1500. 

  1500.     return;
    1501. 

  1501.   }
    1502. 

  1502. 

  1503.   en = proto_tree_add_text (dmp_tree, tvb, 0, 0, "SEQ/ACK analysis");
    1504. 

  1504.   PROTO_ITEM_SET_GENERATED (en);
    1505. 

  1505.   analysis_tree = proto_item_add_subtree (en, ett_analysis);
    1506. 

  1506. 

  1507.   if ((dmp.msg_type == STANAG) || (dmp.msg_type == IPM) ||
    1508. 

  1508.       (dmp.msg_type == REPORT) || (dmp.msg_type == NOTIF)) {
    1509. 

  1509.     if (dmp.id_val->ack_id) {
    1510. 

  1510.       en = proto_tree_add_uint (analysis_tree, hf_analysis_ack_num, tvb,
    1511. 

  1511.                                 0, 0, dmp.id_val->ack_id);
    1512. 

  1512.       PROTO_ITEM_SET_GENERATED (en);
    1513. 

  1513.       if (!dmp.checksum) {
    1514. 

  1514.         proto_item_append_text (en, " (unexpected)");
    1515. 

  1515.         expert_add_info_format (pinfo, en, PI_SEQUENCE, PI_NOTE,
    1516. 

  1516.                                 "Unexpected ACK");
    1517. 

  1517.       }
    1518. 

  1518.     } else if (dmp.checksum && !dmp.id_val->msg_resend_count) {
    1519. 

  1519.       en = proto_tree_add_item (analysis_tree, hf_analysis_ack_missing, tvb, offset, 0, ENC_NA);
    1520. 

  1520.       if (pinfo->fd->flags.visited) {
    1521. 

  1521.         /* We do not know this on first visit and we do not want to
    1522. 

  1522.            add a entry in the "Expert Severity Info" for this note */
    1523. 

  1523.         expert_add_info_format (pinfo, en, PI_SEQUENCE, PI_NOTE,
    1524. 

  1524.                                 "Acknowledgement missing");
    1525. 

  1525.         PROTO_ITEM_SET_GENERATED (en);
    1526. 

  1526.       }
    1527. 

  1527.     }
    1528. 

  1528. 

  1529.     if (dmp.msg_type == REPORT) {
    1530. 

  1530.       if (dmp.id_val->msg_id) {
    1531. 

  1531.         en = proto_tree_add_uint (analysis_tree, hf_analysis_msg_num,
    1532. 

  1532.                                   tvb, 0, 0, dmp.id_val->msg_id);
    1533. 

  1533.         PROTO_ITEM_SET_GENERATED (en);
    1534. 

  1534. 

  1535.         nstime_delta (&ns, &pinfo->fd->abs_ts, &dmp.id_val->rep_not_msg_time);
    1536. 

  1536.         en = proto_tree_add_time (analysis_tree, hf_analysis_rep_time,
    1537. 

  1537.                                   tvb, 0, 0, &ns);
    1538. 

  1538.         PROTO_ITEM_SET_GENERATED (en);
    1539. 

  1539.       } else {
    1540. 

  1540.         en = proto_tree_add_item (analysis_tree, hf_analysis_msg_missing, tvb, 0, 0, ENC_NA);
    1541. 

  1541.         PROTO_ITEM_SET_GENERATED (en);
    1542. 

  1542. 

  1543.         expert_add_info_format (pinfo, en, PI_SEQUENCE, PI_NOTE,
    1544. 

  1544.                                 "Message missing");
    1545. 

  1545.       }
    1546. 

  1546.     } else if (dmp.msg_type == NOTIF) {
    1547. 

  1547.       if (dmp.id_val->msg_id) {
    1548. 

  1548.         en = proto_tree_add_uint (analysis_tree, hf_analysis_msg_num,
    1549. 

  1549.                                   tvb, 0, 0, dmp.id_val->msg_id);
    1550. 

  1550.         PROTO_ITEM_SET_GENERATED (en);
    1551. 

  1551. 

  1552.         nstime_delta (&ns, &pinfo->fd->abs_ts, &dmp.id_val->rep_not_msg_time);
    1553. 

  1553.         en = proto_tree_add_time (analysis_tree, hf_analysis_not_time,
    1554. 

  1554.                                   tvb, 0, 0, &ns);
    1555. 

  1555.         PROTO_ITEM_SET_GENERATED (en);
    1556. 

  1556.       } else {
    1557. 

  1557.         en = proto_tree_add_item (analysis_tree, hf_analysis_msg_missing, tvb, 0, 0, ENC_NA);
    1558. 

  1558.         PROTO_ITEM_SET_GENERATED (en);
    1559. 

  1559. 

  1560.         expert_add_info_format (pinfo, en, PI_SEQUENCE, PI_NOTE,
    1561. 

  1561.                                 "Message missing");
    1562. 

  1562.       }
    1563. 

  1563.     }
    1564. 

  1564. 

  1565.     if (dmp.id_val->msg_resend_count) {
    1566. 

  1566.       en = proto_tree_add_uint (analysis_tree, hf_analysis_retrans_no,
    1567. 

  1567.                                 tvb, 0, 0, dmp.id_val->msg_resend_count);
    1568. 

  1568.       PROTO_ITEM_SET_GENERATED (en);
    1569. 

  1569. 

  1570.       expert_add_info_format (pinfo, en, PI_SEQUENCE, PI_NOTE,
    1571. 

  1571.                               "Retransmission #%d",
    1572. 

  1572.                               dmp.id_val->msg_resend_count);
    1573. 

  1573. 

  1574.       if (dmp.msg_type == REPORT) {
    1575. 

  1575.         en = proto_tree_add_uint (analysis_tree, hf_analysis_rep_resend_from,
    1576. 

  1576.                                   tvb, 0, 0, dmp.id_val->rep_id);
    1577. 

  1577.       } else if (dmp.msg_type == NOTIF) {
    1578. 

  1578.         en = proto_tree_add_uint (analysis_tree, hf_analysis_not_resend_from,
    1579. 

  1579.                                   tvb, 0, 0, dmp.id_val->not_id);
    1580. 

  1580.       } else {
    1581. 

  1581.         en = proto_tree_add_uint (analysis_tree, hf_analysis_msg_resend_from,
    1582. 

  1582.                                   tvb, 0, 0, dmp.id_val->msg_id);
    1583. 

  1583.       }
    1584. 

  1584.       PROTO_ITEM_SET_GENERATED (en);
    1585. 

  1585. 

  1586.       nstime_delta (&ns, &pinfo->fd->abs_ts, &dmp.id_val->prev_msg_time);
    1587. 

  1587.       en = proto_tree_add_time (analysis_tree, hf_analysis_retrans_time,
    1588. 

  1588.                                 tvb, 0, 0, &ns);
    1589. 

  1589.       PROTO_ITEM_SET_GENERATED (en);
    1590. 

  1590. 

  1591.       nstime_delta (&ns, &pinfo->fd->abs_ts, &dmp.id_val->first_msg_time);
    1592. 

  1592.       eh = proto_tree_add_time (analysis_tree, hf_analysis_total_retrans_time,
    1593. 

  1593.                                 tvb, 0, 0, &ns);
    1594. 

  1594.       PROTO_ITEM_SET_GENERATED (eh);
    1595. 

  1595. 

  1596.       if (dmp.id_val->first_msg_time.secs == dmp.id_val->prev_msg_time.secs &&
    1597. 

  1597.           dmp.id_val->first_msg_time.nsecs == dmp.id_val->prev_msg_time.nsecs) {
    1598. 

  1598.         /* Time values does not differ, hide the total time */
    1599. 

  1599.         PROTO_ITEM_SET_HIDDEN (eh);
    1600. 

  1600.       }
    1601. 

  1601.     }
    1602. 

  1602.   } else if (dmp.msg_ty…
    1603.

Large files files are truncated, but you can click here to view the full file