PageRenderTime 111ms CodeModel.GetById 22ms RepoModel.GetById 1ms app.codeStats 2ms

/epan/dissectors/packet-ansi_a.c

https://github.com/labx-technologies-llc/wireshark
C | 12314 lines | 8618 code | 2590 blank | 1106 comment | 392 complexity | 0e55385666d58e100917bf601fb15a56 MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause 
    

  1. /* packet-ansi_a.c
    2. 

  2.  * Routines for ANSI A Interface (IS-634/IOS) dissection
    3. 

  3.  *
    4. 

  4.  * Copyright 2003, Michael Lum <mlum [AT] telostech.com>
    5. 

  5.  * In association with Telos Technology Inc.
    6. 

  6.  * Copyright 2008, Michael Lum <michael.lum [AT] utstar.com>
    7. 

  7.  * In association with UTStarcom Inc.
    8. 

  8.  * Copyright 2008, Michael Lum <michael.lum [AT] starsolutions.com>
    9. 

  9.  * In association with Star Solutions
    10. 

  10.  *
    11. 

  11.  * Title                3GPP2                   Other
    12. 

  12.  *
    13. 

  13.  *   Inter-operability Specification (IOS) for CDMA
    14. 

  14.  *   2000 Access Network Interfaces
    15. 

  15.  *                      3GPP2 A.S0001-1         TIA/EIA-2001
    16. 

  16.  *
    17. 

  17.  * $Id$
    18. 

  18.  *
    19. 

  19.  * Wireshark - Network traffic analyzer
    20. 

  20.  * By Gerald Combs <gerald@wireshark.org>
    21. 

  21.  * Copyright 1998 Gerald Combs
    22. 

  22.  *
    23. 

  23.  * This program is free software; you can redistribute it and/or
    24. 

  24.  * modify it under the terms of the GNU General Public License
    25. 

  25.  * as published by the Free Software Foundation; either version 2
    26. 

  26.  * of the License, or (at your option) any later version.
    27. 

  27.  *
    28. 

  28.  * This program is distributed in the hope that it will be useful,
    29. 

  29.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    30. 

  30.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    31. 

  31.  * GNU General Public License for more details.
    32. 

  32.  *
    33. 

  33.  * You should have received a copy of the GNU General Public License
    34. 

  34.  * along with this program; if not, write to the Free Software
    35. 

  35.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
    36. 

  36.  */
    37. 

  37. 

  38. #include "config.h"
    39. 

  39. 

  40. #include <string.h>
    41. 

  41. 

  42. #include <epan/packet.h>
    43. 

  43. #include <epan/prefs.h>
    44. 

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

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

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

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

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

  49. 

  50. #include "packet-rtp.h"
    51. 

  51. #include "packet-bssap.h"
    52. 

  52. #include "packet-ansi_a.h"
    53. 

  53. 

  54. 

  55. /*
    56. 

  56.  * IOS 4, probably most common
    57. 

  57.  */
    58. 

  58. static gint global_a_variant = A_VARIANT_IOS401;
    59. 

  59. 

  60. 

  61. /* PROTOTYPES/FORWARDS */
    62. 

  62. 

  63. void proto_register_ansi_a(void);
    64. 

  64. void proto_reg_handoff_ansi_a(void);
    65. 

  65. 

  66. static const gchar *
    67. 

  67. my_try_val_to_str_idx(guint32 val, const ext_value_string_t *vs, gint *dec_idx)
    68. 

  68. {
    69. 

  69.     gint i = 0;
    70. 

  70. 

  71.     while (vs[i].strptr)
    72. 

  72.     {
    73. 

  73.         if (vs[i].value == val)
    74. 

  74.         {
    75. 

  75.             *dec_idx = vs[i].dec_index;
    76. 

  76.             return(vs[i].strptr);
    77. 

  77.         }
    78. 

  78. 

  79.         i++;
    80. 

  80.     }
    81. 

  81. 

  82.     *dec_idx = -1;
    83. 

  83.     return(NULL);
    84. 

  84. }
    85. 

  85. 

  86. const ext_value_string_t ansi_a_ios401_bsmap_strings[] =
    87. 

  87. {
    88. 

  88.     { 0x69,     "Additional Service Notification",      0 },
    89. 

  89.     { 0x65,     "ADDS Page",    1 },
    90. 

  90.     { 0x66,     "ADDS Page Ack",        2 },
    91. 

  91.     { 0x67,     "ADDS Transfer",        3 },
    92. 

  92.     { 0x68,     "ADDS Transfer Ack",    4 },
    93. 

  93.     { 0x02,     "Assignment Complete",  5 },
    94. 

  94.     { 0x03,     "Assignment Failure",   6 },
    95. 

  95.     { 0x01,     "Assignment Request",   7 },
    96. 

  96.     { 0x45,     "Authentication Request",       8 },
    97. 

  97.     { 0x46,     "Authentication Response",      9 },
    98. 

  98.     { 0x48,     "Base Station Challenge",       10 },
    99. 

  99.     { 0x49,     "Base Station Challenge Response",      11 },
    100. 

  100.     { 0x40,     "Block",        12 },
    101. 

  101.     { 0x41,     "Block Acknowledge",    13 },
    102. 

  102.     { 0x09,     "BS Service Request",   14 },
    103. 

  103.     { 0x0A,     "BS Service Response",  15 },
    104. 

  104.     { 0x20,     "Clear Command",        16 },
    105. 

  105.     { 0x21,     "Clear Complete",       17 },
    106. 

  106.     { 0x22,     "Clear Request",        18 },
    107. 

  107.     { 0x57,     "Complete Layer 3 Information", 19 },
    108. 

  108.     { 0x60,     "Feature Notification", 20 },
    109. 

  109.     { 0x61,     "Feature Notification Ack",     21 },
    110. 

  110.     { 0x13,     "Handoff Command",      22 },
    111. 

  111.     { 0x15,     "Handoff Commenced",    23 },
    112. 

  112.     { 0x14,     "Handoff Complete",     24 },
    113. 

  113.     { 0x16,     "Handoff Failure",      25 },
    114. 

  114.     { 0x17,     "Handoff Performed",    26 },
    115. 

  115.     { 0x10,     "Handoff Request",      27 },
    116. 

  116.     { 0x12,     "Handoff Request Acknowledge",  28 },
    117. 

  117.     { 0x11,     "Handoff Required",     29 },
    118. 

  118.     { 0x1A,     "Handoff Required Reject",      30 },
    119. 

  119.     { 0x6C,     "PACA Command", 31 },
    120. 

  120.     { 0x6D,     "PACA Command Ack",     32 },
    121. 

  121.     { 0x6E,     "PACA Update",  33 },
    122. 

  122.     { 0x6F,     "PACA Update Ack",      34 },
    123. 

  123.     { 0x52,     "Paging Request",       35 },
    124. 

  124.     { 0x53,     "Privacy Mode Command", 36 },
    125. 

  125.     { 0x55,     "Privacy Mode Complete",        37 },
    126. 

  126.     { 0x23,     "Radio Measurements for Position Request",      38 },
    127. 

  127.     { 0x25,     "Radio Measurements for Position Response",     39 },
    128. 

  128.     { 0x56,     "Rejection",    40 },
    129. 

  129.     { 0x05,     "Registration Request", 41 },
    130. 

  130.     { 0x30,     "Reset",        42 },
    131. 

  131.     { 0x31,     "Reset Acknowledge",    43 },
    132. 

  132.     { 0x34,     "Reset Circuit",        44 },
    133. 

  133.     { 0x35,     "Reset Circuit Acknowledge",    45 },
    134. 

  134.     { 0x47,     "SSD Update Request",   46 },
    135. 

  135.     { 0x4A,     "SSD Update Response",  47 },
    136. 

  136.     { 0x6A,     "Status Request",       48 },
    137. 

  137.     { 0x6B,     "Status Response",      49 },
    138. 

  138.     { 0x39,     "Transcoder Control Acknowledge",       50 },
    139. 

  139.     { 0x38,     "Transcoder Control Request",   51 },
    140. 

  140.     { 0x42,     "Unblock",      52 },
    141. 

  141.     { 0x43,     "Unblock Acknowledge",  53 },
    142. 

  142.     { 0x0B,     "User Zone Reject",     54 },
    143. 

  143.     { 0x04,     "User Zone Update",     55 },
    144. 

  144.     { 0, NULL, 0 }
    145. 

  145. };
    146. 

  146. 

  147. const ext_value_string_t ansi_a_ios401_dtap_strings[] =
    148. 

  148. {
    149. 

  149.     { 0x62,     "Additional Service Request",   0 },
    150. 

  150.     { 0x53,     "ADDS Deliver", 1 },
    151. 

  151.     { 0x54,     "ADDS Deliver Ack",     2 },
    152. 

  152.     { 0x26,     "Alert With Information",       3 },
    153. 

  153.     { 0x45,     "Authentication Request",       4 },
    154. 

  154.     { 0x46,     "Authentication Response",      5 },
    155. 

  155.     { 0x48,     "Base Station Challenge",       6 },
    156. 

  156.     { 0x49,     "Base Station Challenge Response",      7 },
    157. 

  157.     { 0x24,     "CM Service Request",   8 },
    158. 

  158.     { 0x25,     "CM Service Request Continuation",      9 },
    159. 

  159.     { 0x07,     "Connect",      10 },
    160. 

  160.     { 0x10,     "Flash with Information",       11 },
    161. 

  161.     { 0x50,     "Flash with Information Ack",   12 },
    162. 

  162.     { 0x02,     "Location Updating Accept",     13 },
    163. 

  163.     { 0x04,     "Location Updating Reject",     14 },
    164. 

  164.     { 0x08,     "Location Updating Request",    15 },
    165. 

  165.     { 0x27,     "Paging Response",      16 },
    166. 

  166.     { 0x2B,     "Parameter Update Confirm",     17 },
    167. 

  167.     { 0x2C,     "Parameter Update Request",     18 },
    168. 

  168.     { 0x56,     "Rejection",    19 },
    169. 

  169.     { 0x03,     "Progress",     20 },
    170. 

  170.     { 0x70,     "Service Redirection",  21 },
    171. 

  171.     { 0x2E,     "Service Release",      22 },
    172. 

  172.     { 0x2F,     "Service Release Complete",     23 },
    173. 

  173.     { 0x47,     "SSD Update Request",   24 },
    174. 

  174.     { 0x4A,     "SSD Update Response",  25 },
    175. 

  175.     { 0x6A,     "Status Request",       26 },
    176. 

  176.     { 0x6B,     "Status Response",      27 },
    177. 

  177.     { 0x0B,     "User Zone Reject",     28 },
    178. 

  178.     { 0x0C,     "User Zone Update",     29 },
    179. 

  179.     { 0x0D,     "User Zone Update Request",     30 },
    180. 

  180.     { 0, NULL, 0 }
    181. 

  181. };
    182. 

  182. 

  183. const ext_value_string_t ansi_a_ios401_elem_1_strings[] =
    184. 

  184. {
    185. 

  185.     { 0x20,     "Access Network Identifiers",   0 },
    186. 

  186.     { 0x3D,     "ADDS User Part",       1 },
    187. 

  187.     { 0x25,     "AMPS Hard Handoff Parameters", 2 },
    188. 

  188.     { 0x30,     "Anchor PDSN Address",  3 },
    189. 

  189.     { 0x7C,     "Anchor P-P Address",   4 },
    190. 

  190.     { 0x41,     "Authentication Challenge Parameter",   5 },
    191. 

  191.     { 0x28,     "Authentication Confirmation Parameter (RANDC)",        6 },
    192. 

  192.     { 0x59,     "Authentication Data",  7 },
    193. 

  193.     { 0x4A,     "Authentication Event", 8 },
    194. 

  194.     { 0x40,     "Authentication Parameter COUNT",       9 },
    195. 

  195.     { 0x42,     "Authentication Response Parameter",    10 },
    196. 

  196.     { 0x37,     "Band Class",   11 },
    197. 

  197.     { 0x5B,     "Called Party ASCII Number",    12 },
    198. 

  198.     { 0x5E,     "Called Party BCD Number",      13 },
    199. 

  199.     { 0x4B,     "Calling Party ASCII Number",   14 },
    200. 

  200.     { 0x04,     "Cause",        15 },
    201. 

  201.     { 0x08,     "Cause Layer 3",        16 },
    202. 

  202.     { 0x0C,     "CDMA Serving One Way Delay",   17 },
    203. 

  203.     { 0x05,     "Cell Identifier",      18 },
    204. 

  204.     { 0x1A,     "Cell Identifier List", 19 },
    205. 

  205.     { 0x23,     "Channel Number",       20 },
    206. 

  206.     { 0x0B,     "Channel Type", 21 },
    207. 

  207.     { 0x19,     "Circuit Group",        22 },
    208. 

  208.     { 0x01,     "Circuit Identity Code",        23 },
    209. 

  209.     { 0x24,     "Circuit Identity Code Extension",      24 },
    210. 

  210.     { 0x12,     "Classmark Information Type 2", 25 },
    211. 

  211.     { 0x29,     "Downlink Radio Environment",   26 },
    212. 

  212.     { 0x2B,     "Downlink Radio Environment List",      27 },
    213. 

  213.     { 0x0A,     "Encryption Information",       28 },
    214. 

  214.     { 0x10,     "Extended Handoff Direction Parameters",        29 },
    215. 

  215.     { 0x2C,     "Geographic Location",  30 },
    216. 

  216.     { 0x5A,     "Special Service Call Indicator",       31 },
    217. 

  217.     { 0x26,     "Handoff Power Level",  32 },
    218. 

  218.     { 0x16,     "Hard Handoff Parameters",      33 },
    219. 

  219.     { 0x2E,     "Information Element Requested",        34 },
    220. 

  220.     { 0x09,     "IS-2000 Channel Identity",     35 },
    221. 

  221.     { 0x27,     "IS-2000 Channel Identity 3X",  36 },
    222. 

  222.     { 0x11,     "IS-2000 Mobile Capabilities",  37 },
    223. 

  223.     { 0x0F,     "IS-2000 Non-Negotiable Service Configuration Record",  38 },
    224. 

  224.     { 0x0E,     "IS-2000 Service Configuration Record", 39 },
    225. 

  225.     { 0x62,     "IS-95/IS-2000 Cause Value",    40 },
    226. 

  226.     { 0x67,     "IS-2000 Redirection Record",   41 },
    227. 

  227.     { 0x22,     "IS-95 Channel Identity",       42 },
    228. 

  228.     { 0x64,     "IS-95 MS Measured Channel Identity",   43 },
    229. 

  229.     { 0x17,     "Layer 3 Information",  44 },
    230. 

  230.     { 0x13,     "Location Area Information",    45 },
    231. 

  231.     { 0x38,     "Message Waiting Indication",   46 },
    232. 

  232.     { 0x0D,     "Mobile Identity",      47 },
    233. 

  233.     { 0x15,     "MS Information Records (Forward)",     48 },
    234. 

  234.     { 0xA0,     "Origination Continuation Indicator",   49 },
    235. 

  235.     { 0x5F,     "PACA Order",   50 },
    236. 

  236.     { 0x60,     "PACA Reorigination Indicator", 51 },
    237. 

  237.     { 0x4E,     "PACA Timestamp",       52 },
    238. 

  238.     { 0x70,     "Packet Session Parameters",    53 },
    239. 

  239.     { 0x14,     "PDSN IP Address",      54 },
    240. 

  240.     { 0xA2,     "Power Down Indicator", 55 },
    241. 

  241.     { 0x06,     "Priority",     56 },
    242. 

  242.     { 0x3B,     "Protocol Revision",    57 },
    243. 

  243.     { 0x18,     "Protocol Type",        58 },
    244. 

  244.     { 0x2D,     "PSMM Count",   59 },
    245. 

  245.     { 0x07,     "Quality of Service Parameters",        60 },
    246. 

  246.     { 0x1D,     "Radio Environment and Resources",      61 },
    247. 

  247.     { 0x1F,     "Registration Type",    62 },
    248. 

  248.     { 0x44,     "Reject Cause", 63 },
    249. 

  249.     { 0x1B,     "Response Request",     64 },
    250. 

  250.     { 0x68,     "Return Cause", 65 },
    251. 

  251.     { 0x21,     "RF Channel Identity",  66 },
    252. 

  252.     { 0x03,     "Service Option",       67 },
    253. 

  253.     { 0x1E,     "Service Option Connection Identifier (SOCI)",  68 },
    254. 

  254.     { 0x2A,     "Service Option List",  69 },
    255. 

  255.     { 0x69,     "Service Redirection Info",     70 },
    256. 

  256.     { 0x71,     "Service Reference Identifier (SR_ID)", 71 },
    257. 

  257.     { 0x32,     "SID",  72 },
    258. 

  258.     { 0x34,     "Signal",       73 },
    259. 

  259.     { 0x35,     "Slot Cycle Index",     74 },
    260. 

  260.     { 0x31,     "Software Version",     75 },
    261. 

  261.     { 0x39,     "Source RNC to Target RNC Transparent Container",       76 },
    262. 

  262.     { 0x14,     "Source PDSN Address",  77 },
    263. 

  263.     { 0x33,     "Tag",  78 },
    264. 

  264.     { 0x3A,     "Target RNC to Source RNC Transparent Container",       79 },
    265. 

  265.     { 0x36,     "Transcoder Mode",      80 }, /* XXX 0x1C in IOS 4.0.1 */
    266. 

  266.     { 0x02,     "User Zone ID", 81 },
    267. 

  267.     { 0xA1,     "Voice Privacy Request",        82 },
    268. 

  268.     { 0x15,     "MS Information Records (Reverse)",     88 },
    269. 

  269.     { 0, NULL, 0 }
    270. 

  270. };
    271. 

  271. 

  272. const ext_value_string_t ansi_a_ios501_bsmap_strings[] =
    273. 

  273. {
    274. 

  274.     { 0x69,     "Additional Service Notification",      0 },
    275. 

  275.     { 0x65,     "ADDS Page",    1 },
    276. 

  276.     { 0x66,     "ADDS Page Ack",        2 },
    277. 

  277.     { 0x67,     "ADDS Transfer",        3 },
    278. 

  278.     { 0x68,     "ADDS Transfer Ack",    4 },
    279. 

  279.     { 0x02,     "Assignment Complete",  5 },
    280. 

  280.     { 0x03,     "Assignment Failure",   6 },
    281. 

  281.     { 0x01,     "Assignment Request",   7 },
    282. 

  282.     { 0x45,     "Authentication Request",       8 },
    283. 

  283.     { 0x46,     "Authentication Response",      9 },
    284. 

  284.     { 0x48,     "Base Station Challenge",       10 },
    285. 

  285.     { 0x49,     "Base Station Challenge Response",      11 },
    286. 

  286.     { 0x40,     "Block",        12 },
    287. 

  287.     { 0x41,     "Block Acknowledge",    13 },
    288. 

  288.     { 0x09,     "BS Service Request",   14 },
    289. 

  289.     { 0x0A,     "BS Service Response",  15 },
    290. 

  290.     { 0x20,     "Clear Command",        16 },
    291. 

  291.     { 0x21,     "Clear Complete",       17 },
    292. 

  292.     { 0x22,     "Clear Request",        18 },
    293. 

  293.     { 0x57,     "Complete Layer 3 Information", 19 },
    294. 

  294.     { 0x60,     "Feature Notification", 20 },
    295. 

  295.     { 0x61,     "Feature Notification Ack",     21 },
    296. 

  296.     { 0x13,     "Handoff Command",      22 },
    297. 

  297.     { 0x15,     "Handoff Commenced",    23 },
    298. 

  298.     { 0x14,     "Handoff Complete",     24 },
    299. 

  299.     { 0x16,     "Handoff Failure",      25 },
    300. 

  300.     { 0x17,     "Handoff Performed",    26 },
    301. 

  301.     { 0x10,     "Handoff Request",      27 },
    302. 

  302.     { 0x12,     "Handoff Request Acknowledge",  28 },
    303. 

  303.     { 0x11,     "Handoff Required",     29 },
    304. 

  304.     { 0x1A,     "Handoff Required Reject",      30 },
    305. 

  305.     { 0x6C,     "PACA Command", 31 },
    306. 

  306.     { 0x6D,     "PACA Command Ack",     32 },
    307. 

  307.     { 0x6E,     "PACA Update",  33 },
    308. 

  308.     { 0x6F,     "PACA Update Ack",      34 },
    309. 

  309.     { 0x52,     "Paging Request",       35 },
    310. 

  310.     { 0x53,     "Privacy Mode Command", 36 },
    311. 

  311.     { 0x55,     "Privacy Mode Complete",        37 },
    312. 

  312.     { 0x23,     "Radio Measurements for Position Request",      38 },
    313. 

  313.     { 0x25,     "Radio Measurements for Position Response",     39 },
    314. 

  314.     { 0x56,     "Rejection",    40 },
    315. 

  315.     { 0x05,     "Registration Request", 41 },
    316. 

  316.     { 0x30,     "Reset",        42 },
    317. 

  317.     { 0x31,     "Reset Acknowledge",    43 },
    318. 

  318.     { 0x34,     "Reset Circuit",        44 },
    319. 

  319.     { 0x35,     "Reset Circuit Acknowledge",    45 },
    320. 

  320.     { 0x47,     "SSD Update Request",   46 },
    321. 

  321.     { 0x4A,     "SSD Update Response",  47 },
    322. 

  322.     { 0x6A,     "Status Request",       48 },
    323. 

  323.     { 0x6B,     "Status Response",      49 },
    324. 

  324.     { 0x39,     "Transcoder Control Acknowledge",       50 },
    325. 

  325.     { 0x38,     "Transcoder Control Request",   51 },
    326. 

  326.     { 0x42,     "Unblock",      52 },
    327. 

  327.     { 0x43,     "Unblock Acknowledge",  53 },
    328. 

  328.     { 0x0B,     "User Zone Reject",     54 },
    329. 

  329.     { 0x04,     "User Zone Update",     55 },
    330. 

  330.     { 0x58,     "Bearer Update Request",        56 },
    331. 

  331.     { 0x59,     "Bearer Update Response",       58 },
    332. 

  332.     { 0x5A,     "Bearer Update Required",       57 },
    333. 

  333.     { 0x71,     "Mobile Station Registered Notification",       59 },
    334. 

  334.     { 0x07,     "BS Authentication Request",    60 },
    335. 

  335.     { 0x08,     "BS Authentication Request Ack",        61 },
    336. 

  336.     { 0, NULL, 0 }
    337. 

  337. };
    338. 

  338. 

  339. const ext_value_string_t ansi_a_ios501_dtap_strings[] =
    340. 

  340. {
    341. 

  341.     { 0x62,     "Additional Service Request",   0 },
    342. 

  342.     { 0x53,     "ADDS Deliver", 1 },
    343. 

  343.     { 0x54,     "ADDS Deliver Ack",     2 },
    344. 

  344.     { 0x26,     "Alert With Information",       3 },
    345. 

  345.     { 0x45,     "Authentication Request",       4 },
    346. 

  346.     { 0x46,     "Authentication Response",      5 },
    347. 

  347.     { 0x48,     "Base Station Challenge",       6 },
    348. 

  348.     { 0x49,     "Base Station Challenge Response",      7 },
    349. 

  349.     { 0x24,     "CM Service Request",   8 },
    350. 

  350.     { 0x25,     "CM Service Request Continuation",      9 },
    351. 

  351.     { 0x07,     "Connect",      10 },
    352. 

  352.     { 0x10,     "Flash with Information",       11 },
    353. 

  353.     { 0x50,     "Flash with Information Ack",   12 },
    354. 

  354.     { 0x02,     "Location Updating Accept",     13 },
    355. 

  355.     { 0x04,     "Location Updating Reject",     14 },
    356. 

  356.     { 0x08,     "Location Updating Request",    15 },
    357. 

  357.     { 0x27,     "Paging Response",      16 },
    358. 

  358.     { 0x2B,     "Parameter Update Confirm",     17 },
    359. 

  359.     { 0x2C,     "Parameter Update Request",     18 },
    360. 

  360.     { 0x56,     "Rejection",    19 },
    361. 

  361.     { 0x03,     "Progress",     20 },
    362. 

  362.     { 0x70,     "Service Redirection",  21 },
    363. 

  363.     { 0x2E,     "Service Release",      22 },
    364. 

  364.     { 0x2F,     "Service Release Complete",     23 },
    365. 

  365.     { 0x47,     "SSD Update Request",   24 },
    366. 

  366.     { 0x4A,     "SSD Update Response",  25 },
    367. 

  367.     { 0x6A,     "Status Request",       26 },
    368. 

  368.     { 0x6B,     "Status Response",      27 },
    369. 

  369.     { 0x0B,     "User Zone Reject",     28 },
    370. 

  370.     { 0x0C,     "User Zone Update",     29 },
    371. 

  371.     { 0x0D,     "User Zone Update Request",     30 },
    372. 

  372.     { 0, NULL, 0 }
    373. 

  373. };
    374. 

  374. 

  375. /*
    376. 

  376.  * ORDER MUST MATCH
    377. 

  377.  * ansi_a_ios401_elem_1_strings when the same element
    378. 

  378.  * is being described.
    379. 

  379.  */
    380. 

  380. const ext_value_string_t ansi_a_ios501_elem_1_strings[] =
    381. 

  381. {
    382. 

  382.     { 0x20,     "Access Network Identifiers",   0 },
    383. 

  383.     { 0x3D,     "ADDS User Part",       1 },
    384. 

  384.     { 0x25,     "AMPS Hard Handoff Parameters", 2 },
    385. 

  385.     { 0x30,     "Anchor PDSN Address",  3 },
    386. 

  386.     { 0x7C,     "Anchor P-P Address",   4 },
    387. 

  387.     { 0x41,     "Authentication Challenge Parameter",   5 },
    388. 

  388.     { 0x28,     "Authentication Confirmation Parameter (RANDC)",        6 },
    389. 

  389.     { 0x59,     "Authentication Data",  7 },
    390. 

  390.     { 0x4A,     "Authentication Event", 8 },
    391. 

  391.     { 0x40,     "Authentication Parameter COUNT",       9 },
    392. 

  392.     { 0x42,     "Authentication Response Parameter",    10 },
    393. 

  393.     { 0x37,     "Band Class",   11 },
    394. 

  394.     { 0x5B,     "Called Party ASCII Number",    12 },
    395. 

  395.     { 0x5E,     "Called Party BCD Number",      13 },
    396. 

  396.     { 0x4B,     "Calling Party ASCII Number",   14 },
    397. 

  397.     { 0x04,     "Cause",        15 },
    398. 

  398.     { 0x08,     "Cause Layer 3",        16 },
    399. 

  399.     { 0x0C,     "CDMA Serving One Way Delay",   17 },
    400. 

  400.     { 0x05,     "Cell Identifier",      18 },
    401. 

  401.     { 0x1A,     "Cell Identifier List", 19 },
    402. 

  402.     { 0x23,     "Channel Number",       20 },
    403. 

  403.     { 0x0B,     "Channel Type", 21 },
    404. 

  404.     { 0x19,     "Circuit Group",        22 },
    405. 

  405.     { 0x01,     "Circuit Identity Code",        23 },
    406. 

  406.     { 0x24,     "Circuit Identity Code Extension",      24 },
    407. 

  407.     { 0x12,     "Classmark Information Type 2", 25 },
    408. 

  408.     { 0x29,     "Downlink Radio Environment",   26 },
    409. 

  409.     { 0x2B,     "Downlink Radio Environment List",      27 },
    410. 

  410.     { 0x0A,     "Encryption Information",       28 },
    411. 

  411.     { 0x10,     "Extended Handoff Direction Parameters",        29 },
    412. 

  412.     { 0x2C,     "Geographic Location",  30 },
    413. 

  413.     { 0x5A,     "Special Service Call Indicator",       31 },
    414. 

  414.     { 0x26,     "Handoff Power Level",  32 },
    415. 

  415.     { 0x16,     "Hard Handoff Parameters",      33 },
    416. 

  416.     { 0x2E,     "Information Element Requested",        34 },
    417. 

  417.     { 0x09,     "IS-2000 Channel Identity",     35 },
    418. 

  418.     { 0x27,     "IS-2000 Channel Identity 3X",  36 },
    419. 

  419.     { 0x11,     "IS-2000 Mobile Capabilities",  37 },
    420. 

  420.     { 0x0F,     "IS-2000 Non-Negotiable Service Configuration Record",  38 },
    421. 

  421.     { 0x0E,     "IS-2000 Service Configuration Record", 39 },
    422. 

  422.     { 0x62,     "IS-95/IS-2000 Cause Value",    40 },
    423. 

  423.     { 0x67,     "IS-2000 Redirection Record",   41 },
    424. 

  424.     { 0x22,     "IS-95 Channel Identity",       42 },
    425. 

  425.     { 0x64,     "IS-95 MS Measured Channel Identity",   43 },
    426. 

  426.     { 0x17,     "Layer 3 Information",  44 },
    427. 

  427.     { 0x13,     "Location Area Information",    45 },
    428. 

  428.     { 0x38,     "Message Waiting Indication",   46 },
    429. 

  429.     { 0x0D,     "Mobile Identity",      47 },
    430. 

  430.     { 0x15,     "MS Information Records (Forward)",     48 },
    431. 

  431.     { 0xA0,     "Origination Continuation Indicator",   49 },
    432. 

  432.     { 0x5F,     "PACA Order",   50 },
    433. 

  433.     { 0x60,     "PACA Reorigination Indicator", 51 },
    434. 

  434.     { 0x4E,     "PACA Timestamp",       52 },
    435. 

  435.     { 0x70,     "Packet Session Parameters",    53 },
    436. 

  436.     { 0x14,     "PDSN IP Address",      54 },
    437. 

  437.     { 0xA2,     "Power Down Indicator", 55 },
    438. 

  438.     { 0x06,     "Priority",     56 },
    439. 

  439.     { 0x3B,     "Protocol Revision",    57 },
    440. 

  440.     { 0x18,     "Protocol Type",        58 },
    441. 

  441.     { 0x2D,     "PSMM Count",   59 },
    442. 

  442.     { 0x07,     "Quality of Service Parameters",        60 },
    443. 

  443.     { 0x1D,     "Radio Environment and Resources",      61 },
    444. 

  444.     { 0x1F,     "Registration Type",    62 },
    445. 

  445.     { 0x44,     "Reject Cause", 63 },
    446. 

  446.     { 0x1B,     "Response Request",     64 },
    447. 

  447.     { 0x68,     "Return Cause", 65 },
    448. 

  448.     { 0x21,     "RF Channel Identity",  66 },
    449. 

  449.     { 0x03,     "Service Option",       67 },
    450. 

  450.     { 0x1E,     "Service Option Connection Identifier (SOCI)",  68 },
    451. 

  451.     { 0x2A,     "Service Option List",  69 },
    452. 

  452.     { 0x69,     "Service Redirection Info",     70 },
    453. 

  453.     { 0x71,     "Service Reference Identifier (SR_ID)", 71 },
    454. 

  454.     { 0x32,     "SID",  72 },
    455. 

  455.     { 0x34,     "Signal",       73 },
    456. 

  456.     { 0x35,     "Slot Cycle Index",     74 },
    457. 

  457.     { 0x31,     "Software Version",     75 },
    458. 

  458.     { 0x39,     "Source RNC to Target RNC Transparent Container",       76 },
    459. 

  459.     { 0x14,     "Source PDSN Address",  77 },
    460. 

  460.     { 0x33,     "Tag",  78 },
    461. 

  461.     { 0x3A,     "Target RNC to Source RNC Transparent Container",       79 },
    462. 

  462.     { 0x36,     "Transcoder Mode",      80 }, /* XXX 0x1C in IOS 4.0.1 */
    463. 

  463.     { 0x02,     "User Zone ID", 81 },
    464. 

  464.     { 0xA1,     "Voice Privacy Request",        82 },
    465. 

  465.     { 0x45,     "A2p Bearer Session-Level Parameters",  83 },
    466. 

  466.     { 0x46,     "A2p Bearer Format-Specific Parameters",        84 },
    467. 

  467.     { 0x73,     "MS Designated Frequency",      85 },
    468. 

  468.     { 0x7D,     "Mobile Subscription Information",      86 },
    469. 

  469.     { 0x72,     "Public Long Code Mask Identification", 87 },
    470. 

  470.     { 0x15,     "MS Information Records (Reverse)",     88 },
    471. 

  471.     { 0, NULL, 0 }
    472. 

  472. };
    473. 

  473. 

  474. /*
    475. 

  475.  * From Table 3.7.5-1 C.S0005-D v1.0 L3
    476. 

  476.  */
    477. 

  477. #define ANSI_FWD_MS_INFO_REC_DISPLAY            0x01
    478. 

  478. #define ANSI_FWD_MS_INFO_REC_CLD_PN             0x02
    479. 

  479. #define ANSI_FWD_MS_INFO_REC_CLG_PN             0x03
    480. 

  480. #define ANSI_FWD_MS_INFO_REC_CONN_N             0x04
    481. 

  481. #define ANSI_FWD_MS_INFO_REC_SIGNAL             0x05
    482. 

  482. #define ANSI_FWD_MS_INFO_REC_MW                 0x06
    483. 

  483. #define ANSI_FWD_MS_INFO_REC_SC                 0x07
    484. 

  484. #define ANSI_FWD_MS_INFO_REC_CLD_PSA            0x08
    485. 

  485. #define ANSI_FWD_MS_INFO_REC_CLG_PSA            0x09
    486. 

  486. #define ANSI_FWD_MS_INFO_REC_CONN_SA            0x0a
    487. 

  487. #define ANSI_FWD_MS_INFO_REC_RED_N              0x0b
    488. 

  488. #define ANSI_FWD_MS_INFO_REC_RED_SA             0x0c
    489. 

  489. #define ANSI_FWD_MS_INFO_REC_MP                 0x0d
    490. 

  490. #define ANSI_FWD_MS_INFO_REC_PA                 0x0e
    491. 

  491. #define ANSI_FWD_MS_INFO_REC_LC                 0x0f
    492. 

  492. #define ANSI_FWD_MS_INFO_REC_EDISPLAY           0x10
    493. 

  493. #define ANSI_FWD_MS_INFO_REC_NNSC               0x13
    494. 

  494. #define ANSI_FWD_MS_INFO_REC_MC_EDISPLAY        0x14
    495. 

  495. #define ANSI_FWD_MS_INFO_REC_CWI                0x15
    496. 

  496. #define ANSI_FWD_MS_INFO_REC_EMC_EDISPLAY       0x16
    497. 

  497. #define ANSI_FWD_MS_INFO_REC_ERTI               0xfe
    498. 

  498. 

  499. static const value_string ansi_fwd_ms_info_rec_str[] = {
    500. 

  500.     { ANSI_FWD_MS_INFO_REC_DISPLAY,             "Display" },
    501. 

  501.     { ANSI_FWD_MS_INFO_REC_CLD_PN,              "Called Party Number" },
    502. 

  502.     { ANSI_FWD_MS_INFO_REC_CLG_PN,              "Calling Party Number" },
    503. 

  503.     { ANSI_FWD_MS_INFO_REC_CONN_N,              "Connected Number" },
    504. 

  504.     { ANSI_FWD_MS_INFO_REC_SIGNAL,              "Signal" },
    505. 

  505.     { ANSI_FWD_MS_INFO_REC_MW,                  "Message Waiting" },
    506. 

  506.     { ANSI_FWD_MS_INFO_REC_SC,                  "Service Configuration" },
    507. 

  507.     { ANSI_FWD_MS_INFO_REC_CLD_PSA,             "Called Party Subaddress" },
    508. 

  508.     { ANSI_FWD_MS_INFO_REC_CLG_PSA,             "Calling Party Subaddress" },
    509. 

  509.     { ANSI_FWD_MS_INFO_REC_CONN_SA,             "Connected Subaddress" },
    510. 

  510.     { ANSI_FWD_MS_INFO_REC_RED_N,               "Redirecting Number" },
    511. 

  511.     { ANSI_FWD_MS_INFO_REC_RED_SA,              "Redirecting Subaddress" },
    512. 

  512.     { ANSI_FWD_MS_INFO_REC_MP,                  "Meter Pulses" },
    513. 

  513.     { ANSI_FWD_MS_INFO_REC_PA,                  "Parametric Alerting" },
    514. 

  514.     { ANSI_FWD_MS_INFO_REC_LC,                  "Line Control" },
    515. 

  515.     { ANSI_FWD_MS_INFO_REC_EDISPLAY,            "Extended Display" },
    516. 

  516.     { ANSI_FWD_MS_INFO_REC_NNSC,                "Non-Negotiable Service Configuration" },
    517. 

  517.     { ANSI_FWD_MS_INFO_REC_MC_EDISPLAY,         "Multiple Character Extended Display" },
    518. 

  518.     { ANSI_FWD_MS_INFO_REC_CWI,                 "Call Waiting Indicator" },
    519. 

  519.     { ANSI_FWD_MS_INFO_REC_EMC_EDISPLAY,        "Enhanced Multiple Character Extended Display" },
    520. 

  520.     { ANSI_FWD_MS_INFO_REC_ERTI,                "Extended Record Type International" },
    521. 

  521.     { 0, NULL }
    522. 

  522. };
    523. 

  523. #define NUM_FWD_MS_INFO_REC (sizeof(ansi_fwd_ms_info_rec_str)/sizeof(value_string))
    524. 

  524. static gint ett_ansi_fwd_ms_info_rec[NUM_FWD_MS_INFO_REC];
    525. 

  525. 

  526. /*
    527. 

  527.  * From Table 2.7.4-1 C.S0005-D v1.0 L3
    528. 

  528.  */
    529. 

  529. #define ANSI_REV_MS_INFO_REC_KEYPAD_FAC         0x03
    530. 

  530. #define ANSI_REV_MS_INFO_REC_CLD_PN             0x04
    531. 

  531. #define ANSI_REV_MS_INFO_REC_CLG_PN             0x05
    532. 

  532. #define ANSI_REV_MS_INFO_REC_CALL_MODE          0x07
    533. 

  533. #define ANSI_REV_MS_INFO_REC_TERM_INFO          0x08
    534. 

  534. #define ANSI_REV_MS_INFO_REC_ROAM_INFO          0x09
    535. 

  535. #define ANSI_REV_MS_INFO_REC_SECUR_STS          0x0a
    536. 

  536. #define ANSI_REV_MS_INFO_REC_CONN_N             0x0b
    537. 

  537. #define ANSI_REV_MS_INFO_REC_IMSI               0x0c
    538. 

  538. #define ANSI_REV_MS_INFO_REC_ESN                0x0d
    539. 

  539. #define ANSI_REV_MS_INFO_REC_BAND_INFO          0x0e
    540. 

  540. #define ANSI_REV_MS_INFO_REC_POWER_INFO         0x0f
    541. 

  541. #define ANSI_REV_MS_INFO_REC_OP_MODE_INFO       0x10
    542. 

  542. #define ANSI_REV_MS_INFO_REC_SO_INFO            0x11
    543. 

  543. #define ANSI_REV_MS_INFO_REC_MO_INFO            0x12
    544. 

  544. #define ANSI_REV_MS_INFO_REC_SC_INFO            0x13
    545. 

  545. #define ANSI_REV_MS_INFO_REC_CLD_PSA            0x14
    546. 

  546. #define ANSI_REV_MS_INFO_REC_CLG_PSA            0x15
    547. 

  547. #define ANSI_REV_MS_INFO_REC_CONN_SA            0x16
    548. 

  548. #define ANSI_REV_MS_INFO_REC_PCI                0x17
    549. 

  549. #define ANSI_REV_MS_INFO_REC_IMSI_M             0x18
    550. 

  550. #define ANSI_REV_MS_INFO_REC_IMSI_T             0x19
    551. 

  551. #define ANSI_REV_MS_INFO_REC_CAP_INFO           0x1a
    552. 

  552. #define ANSI_REV_MS_INFO_REC_CCC_INFO           0x1b
    553. 

  553. #define ANSI_REV_MS_INFO_REC_EMO_INFO           0x1c
    554. 

  554. #define ANSI_REV_MS_INFO_REC_GEO_CAP            0x1e
    555. 

  555. #define ANSI_REV_MS_INFO_REC_BAND_SUB           0x1f
    556. 

  556. #define ANSI_REV_MS_INFO_REC_GECO               0x20
    557. 

  557. #define ANSI_REV_MS_INFO_REC_HOOK               0x21
    558. 

  558. #define ANSI_REV_MS_INFO_REC_QOS_PARAM          0x22
    559. 

  559. #define ANSI_REV_MS_INFO_REC_ENCRYPT_CAP        0x23
    560. 

  560. #define ANSI_REV_MS_INFO_REC_SMI_CAP            0x24
    561. 

  561. #define ANSI_REV_MS_INFO_REC_UIM_ID             0x25
    562. 

  562. #define ANSI_REV_MS_INFO_REC_ESN_ME             0x26
    563. 

  563. #define ANSI_REV_MS_INFO_REC_MEID               0x27
    564. 

  564. #define ANSI_REV_MS_INFO_REC_EKEYPAD_FAC        0x28
    565. 

  565. #define ANSI_REV_MS_INFO_REC_SYNC_ID            0x29
    566. 

  566. #define ANSI_REV_MS_INFO_REC_ERTI               0xfe
    567. 

  567. 

  568. static const value_string ansi_rev_ms_info_rec_str[] = {
    569. 

  569.     { ANSI_REV_MS_INFO_REC_KEYPAD_FAC,          "Keypad Facility" },
    570. 

  570.     { ANSI_REV_MS_INFO_REC_CLD_PN,              "Called Party Number" },
    571. 

  571.     { ANSI_REV_MS_INFO_REC_CLG_PN,              "Calling Party Number" },
    572. 

  572.     { ANSI_REV_MS_INFO_REC_CALL_MODE,           "Call Mode" },
    573. 

  573.     { ANSI_REV_MS_INFO_REC_TERM_INFO,           "Terminal Information" },
    574. 

  574.     { ANSI_REV_MS_INFO_REC_ROAM_INFO,           "Roaming Information" },
    575. 

  575.     { ANSI_REV_MS_INFO_REC_SECUR_STS,           "Security Status" },
    576. 

  576.     { ANSI_REV_MS_INFO_REC_CONN_N,              "Connected Number" },
    577. 

  577.     { ANSI_REV_MS_INFO_REC_IMSI,                "IMSI" },
    578. 

  578.     { ANSI_REV_MS_INFO_REC_ESN,                 "ESN" },
    579. 

  579.     { ANSI_REV_MS_INFO_REC_BAND_INFO,           "Band Class Information" },
    580. 

  580.     { ANSI_REV_MS_INFO_REC_POWER_INFO,          "Power Class Information" },
    581. 

  581.     { ANSI_REV_MS_INFO_REC_OP_MODE_INFO,        "Operating Mode Information" },
    582. 

  582.     { ANSI_REV_MS_INFO_REC_SO_INFO,             "Service Option Information" },
    583. 

  583.     { ANSI_REV_MS_INFO_REC_MO_INFO,             "Multiplex Option Information" },
    584. 

  584.     { ANSI_REV_MS_INFO_REC_SC_INFO,             "Service Configuration Information" },
    585. 

  585.     { ANSI_REV_MS_INFO_REC_CLD_PSA,             "Called Party Subaddress" },
    586. 

  586.     { ANSI_REV_MS_INFO_REC_CLG_PSA,             "Calling Party Subaddress" },
    587. 

  587.     { ANSI_REV_MS_INFO_REC_CONN_SA,             "Connected Subaddress" },
    588. 

  588.     { ANSI_REV_MS_INFO_REC_PCI,                 "Power Control Information" },
    589. 

  589.     { ANSI_REV_MS_INFO_REC_IMSI_M,              "IMSI_M" },
    590. 

  590.     { ANSI_REV_MS_INFO_REC_IMSI_T,              "IMSI_T" },
    591. 

  591.     { ANSI_REV_MS_INFO_REC_CAP_INFO,            "Capability Information" },
    592. 

  592.     { ANSI_REV_MS_INFO_REC_CCC_INFO,            "Channel Configuration Capability Information" },
    593. 

  593.     { ANSI_REV_MS_INFO_REC_EMO_INFO,            "Extended Multiplex Option Information" },
    594. 

  594.     { ANSI_REV_MS_INFO_REC_GEO_CAP,             "Geo-Location Capability" },
    595. 

  595.     { ANSI_REV_MS_INFO_REC_BAND_SUB,            "Band Subclass Information" },
    596. 

  596.     { ANSI_REV_MS_INFO_REC_GECO,                "Global Emergency Call" },
    597. 

  597.     { ANSI_REV_MS_INFO_REC_HOOK,                "Hook Status" },
    598. 

  598.     { ANSI_REV_MS_INFO_REC_QOS_PARAM,           "QoS Parameters" },
    599. 

  599.     { ANSI_REV_MS_INFO_REC_ENCRYPT_CAP,         "Encryption Capability" },
    600. 

  600.     { ANSI_REV_MS_INFO_REC_SMI_CAP,             "Signaling Message Integrity Capability" },
    601. 

  601.     { ANSI_REV_MS_INFO_REC_UIM_ID,              "UIM_ID" },
    602. 

  602.     { ANSI_REV_MS_INFO_REC_ESN_ME,              "ESN_ME" },
    603. 

  603.     { ANSI_REV_MS_INFO_REC_MEID,                "MEID" },
    604. 

  604.     { ANSI_REV_MS_INFO_REC_EKEYPAD_FAC,         "Extended Keypad Facility" },
    605. 

  605.     { ANSI_REV_MS_INFO_REC_SYNC_ID,             "SYNC_ID" },
    606. 

  606.     { ANSI_REV_MS_INFO_REC_ERTI,                "Extended Record Type International" },
    607. 

  607.     { 0, NULL }
    608. 

  608. };
    609. 

  609. #define NUM_REV_MS_INFO_REC (sizeof(ansi_rev_ms_info_rec_str)/sizeof(value_string))
    610. 

  610. static gint ett_ansi_rev_ms_info_rec[NUM_REV_MS_INFO_REC];
    611. 

  611. 

  612. /*
    613. 

  613.  * C.S0057 Table 1.5-1
    614. 

  614.  */
    615. 

  615. static const gchar *band_class_str[] = {
    616. 

  616.     "800 MHz Cellular System",
    617. 

  617.     "1.850 to 1.990 GHz Broadband PCS",
    618. 

  618.     "872 to 960 MHz TACS Band",
    619. 

  619.     "832 to 925 MHz JTACS Band",
    620. 

  620.     "1.750 to 1.870 GHz Korean PCS",
    621. 

  621.     "450 MHz NMT",
    622. 

  622.     "2 GHz IMT-2000",
    623. 

  623.     "Upper 700 MHz",
    624. 

  624.     "1.710 to 1.880 GHz PCS",
    625. 

  625.     "880 to 960 MHz",
    626. 

  626.     "Secondary 800 MHz",
    627. 

  627.     "400 MHz European PAMR",
    628. 

  628.     "800 MHz European PAMR",
    629. 

  629.     "2.5 GHz IMT-2000 Extension",
    630. 

  630.     "US PCS 1.9 GHz",
    631. 

  631.     "AWS",
    632. 

  632.     "US 2.5 GHz",
    633. 

  633.     "US 2.5 GHz Forward Link Only",
    634. 

  634.     "700 MHz Public Safety",
    635. 

  635.     "Lower 700 MHz"
    636. 

  636. };
    637. 

  637. #define NUM_BAND_CLASS_STR      (sizeof(band_class_str)/sizeof(gchar *))
    638. 

  638. 

  639. static const gchar *cell_disc_str[] = {
    640. 

  640.     "whole Cell Global Identification (CGI)",
    641. 

  641.     "LAC/CI",
    642. 

  642.     "Cell Identity (CI)",
    643. 

  643.     "None",
    644. 

  644.     "Location Area Identification (LAI)",
    645. 

  645.     "Location Area Code (LAC)",
    646. 

  646.     "ALL",
    647. 

  647.     "IS-41 whole Cell Global Identification (ICGI)",
    648. 

  648.     "Enhanced whole Cell Global Identification (ECGI)"
    649. 

  649. };
    650. 

  650. #define NUM_CELL_DISC_STR       (sizeof(cell_disc_str)/sizeof(gchar *))
    651. 

  651. 

  652. /* Initialize the protocol and registered fields */
    653. 

  653. static int proto_a_bsmap = -1;
    654. 

  654. static int proto_a_dtap = -1;
    655. 

  655. 

  656. const ext_value_string_t *ansi_a_bsmap_strings = NULL;
    657. 

  657. const ext_value_string_t *ansi_a_dtap_strings = NULL;
    658. 

  658. const ext_value_string_t *ansi_a_elem_1_strings = NULL;
    659. 

  659. 

  660. static int ansi_a_tap = -1;
    661. 

  661. 

  662. /* static int hf_ansi_a_none = -1; */
    663. 

  663. static int hf_ansi_a_bsmap_msgtype = -1;
    664. 

  664. static int hf_ansi_a_dtap_msgtype = -1;
    665. 

  665. static int hf_ansi_a_length = -1;
    666. 

  666. static int hf_ansi_a_elem_id = -1;
    667. 

  667. static int hf_ansi_a_esn = -1;
    668. 

  668. static int hf_ansi_a_imsi = -1;
    669. 

  669. static int hf_ansi_a_min = -1;
    670. 

  670. static int hf_ansi_a_meid = -1;
    671. 

  671. static int hf_ansi_a_cld_party_bcd_num = -1;
    672. 

  672. #ifdef MAYBE_USED_FOR_OLDER_CODECS
    673. 

  673. static int hf_ansi_a_clg_party_bcd_num = -1;
    674. 

  674. #endif
    675. 

  675. static int hf_ansi_a_cld_party_ascii_num = -1;
    676. 

  676. static int hf_ansi_a_clg_party_ascii_num = -1;
    677. 

  677. static int hf_ansi_a_cell_ci = -1;
    678. 

  678. static int hf_ansi_a_cell_lac = -1;
    679. 

  679. static int hf_ansi_a_cell_mscid = -1;
    680. 

  680. static int hf_ansi_a_pdsn_ip_addr = -1;
    681. 

  681. static int hf_ansi_a_s_pdsn_ip_addr = -1;
    682. 

  682. static int hf_ansi_a_anchor_ip_addr = -1;
    683. 

  683. static int hf_ansi_a_anchor_pp_ip_addr = -1;
    684. 

  684. static int hf_ansi_a_a2p_bearer_ipv4_addr = -1;
    685. 

  685. static int hf_ansi_a_a2p_bearer_ipv6_addr = -1;
    686. 

  686. static int hf_ansi_a_a2p_bearer_udp_port = -1;
    687. 

  687. static int hf_ansi_a_so = -1;
    688. 

  688. static int hf_ansi_a_cause_1 = -1;      /* 1 octet cause */
    689. 

  689. static int hf_ansi_a_cause_2 = -1;      /* 2 octet cause */
    690. 

  690. static int hf_ansi_a_meid_configured = -1;
    691. 

  691. 

  692. 

  693. /* Initialize the subtree pointers */
    694. 

  694. static gint ett_bsmap = -1;
    695. 

  695. static gint ett_dtap = -1;
    696. 

  696. static gint ett_elems = -1;
    697. 

  697. static gint ett_elem = -1;
    698. 

  698. static gint ett_dtap_oct_1 = -1;
    699. 

  699. static gint ett_cm_srvc_type = -1;
    700. 

  700. static gint ett_ansi_ms_info_rec_reserved = -1;
    701. 

  701. static gint ett_ansi_enc_info = -1;
    702. 

  702. static gint ett_scm = -1;
    703. 

  703. static gint ett_cell_list = -1;
    704. 

  704. static gint ett_bearer_list = -1;
    705. 

  705. static gint ett_re_list = -1;
    706. 

  706. static gint ett_so_list = -1;
    707. 

  707. static gint ett_adds_user_part = -1;
    708. 

  708. static gint ett_scr = -1;
    709. 

  709. static gint ett_srvc_con_rec = -1;
    710. 

  710. static gint ett_cm2_band_class = -1;
    711. 

  711. static gint ett_vp_algs = -1;
    712. 

  712. 

  713. static expert_field ei_ansi_a_extraneous_data = EI_INIT;
    714. 

  714. 

  715. static char a_bigbuf[1024];
    716. 

  716. static dissector_handle_t rtp_handle=NULL;
    717. 

  717. static dissector_handle_t data_handle;
    718. 

  718. static dissector_handle_t dtap_handle;
    719. 

  719. static dissector_table_t is637_dissector_table; /* IS-637-A Transport Layer (SMS) */
    720. 

  720. static dissector_table_t is683_dissector_table; /* IS-683-A (OTA) */
    721. 

  721. static dissector_table_t is801_dissector_table; /* IS-801 (PLD) */
    722. 

  722. static proto_tree *g_tree;
    723. 

  723. static address rtp_src_addr;
    724. 

  724. static guint32 rtp_ipv4_addr;
    725. 

  725. static struct e_in6_addr rtp_ipv6_addr;
    726. 

  726. static guint16 rtp_port;
    727. 

  727. static gboolean a_meid_configured = FALSE;
    728. 

  728. 

  729. 

  730. typedef struct ansi_a_dgt_set_t
    731. 

  731. {
    732. 

  732.     /*
    733. 

  733.      * would typically be 15 but to allow MEID decoding this
    734. 

  734.      * needs to have room for full hexadecimal representation
    735. 

  735.      */
    736. 

  736.     unsigned char out[16];
    737. 

  737. }
    738. 

  738. ansi_a_dgt_set_t;
    739. 

  739. 

  740. /*
    741. 

  741.  * As per A.S0001 Called Party BCD Number
    742. 

  742.  */
    743. 

  743. static ansi_a_dgt_set_t Dgt_tbcd = {
    744. 

  744.     {
    745. 

  745.   /*  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e   f */
    746. 

  746.      '0','1','2','3','4','5','6','7','8','9','*','#','a','b','c', 0
    747. 

  747.     }
    748. 

  748. };
    749. 

  749. 

  750. static ansi_a_dgt_set_t Dgt_msid = {
    751. 

  751.     {
    752. 

  752.   /*  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e   f */
    753. 

  753.      '0','1','2','3','4','5','6','7','8','9','?','?','?','?','?', 0
    754. 

  754.     }
    755. 

  755. };
    756. 

  756. 

  757. static ansi_a_dgt_set_t Dgt_meid = {
    758. 

  758.     {
    759. 

  759.   /*  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e   f */
    760. 

  760.      '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
    761. 

  761.     }
    762. 

  762. };
    763. 

  763. 

  764. /* FUNCTIONS */
    765. 

  765. 

  766. /*
    767. 

  767.  * Unpack BCD input pattern into output ASCII pattern
    768. 

  768.  *
    769. 

  769.  * Input Pattern is supplied using the same format as the digits
    770. 

  770.  *
    771. 

  771.  * Returns: length of unpacked pattern
    772. 

  772.  */
    773. 

  773. static int
    774. 

  774. my_dgt_tbcd_unpack(
    775. 

  775.     char        *out,           /* ASCII pattern out */
    776. 

  776.     guchar      *in,            /* packed pattern in */
    777. 

  777.     int         num_octs,       /* Number of octets to unpack */
    778. 

  778.     ansi_a_dgt_set_t   *dgt            /* Digit definitions */
    779. 

  779.     )
    780. 

  780. {
    781. 

  781.     int cnt = 0;
    782. 

  782.     unsigned char i;
    783. 

  783. 

  784.     while (num_octs)
    785. 

  785.     {
    786. 

  786.         /*
    787. 

  787.          * unpack first value in byte
    788. 

  788.          */
    789. 

  789.         i = *in++;
    790. 

  790.         *out++ = dgt->out[i & 0x0f];
    791. 

  791.         cnt++;
    792. 

  792. 

  793.         /*
    794. 

  794.          * unpack second value in byte
    795. 

  795.          */
    796. 

  796.         i >>= 4;
    797. 

  797. 

  798.         if ((num_octs == 1) && (i == 0x0f))  /* odd number bytes - hit filler */
    799. 

  799.             break;
    800. 

  800. 

  801.         *out++ = dgt->out[i];
    802. 

  802.         cnt++;
    803. 

  803.         num_octs--;
    804. 

  804.     }
    805. 

  805. 

  806.     *out = '\0';
    807. 

  807. 

  808.     return(cnt);
    809. 

  809. }
    810. 

  810. 

  811. static const gchar *
    812. 

  812. ansi_a_so_int_to_str(
    813. 

  813.     gint32      so)
    814. 

  814. {
    815. 

  815.     const gchar *str = NULL;
    816. 

  816. 

  817.     switch (so)
    818. 

  818.     {
    819. 

  819.     case 1: str = "Basic Variable Rate Voice Service (8 kbps)"; break;
    820. 

  820.     case 2: str = "Mobile Station Loopback (8 kbps)"; break;
    821. 

  821.     case 3: str = "(EVRC) Enhanced Variable Rate Voice Service (8 kbps)"; break;
    822. 

  822.     case 4: str = "Asynchronous Data Service (9.6 kbps)"; break;
    823. 

  823.     case 5: str = "Group 3 Facsimile (9.6 kbps)"; break;
    824. 

  824.     case 6: str = "Short Message Services (Rate Set 1)"; break;
    825. 

  825.     case 7: str = "Packet Data Service: Internet or ISO Protocol Stack (9.6 kbps)"; break;
    826. 

  826.     case 8: str = "Packet Data Service: CDPD Protocol Stack (9.6 kbps)"; break;
    827. 

  827.     case 9: str = "Mobile Station Loopback (13 kbps)"; break;
    828. 

  828.     case 10: str = "STU-III Transparent Service"; break;
    829. 

  829.     case 11: str = "STU-III Non-Transparent Service"; break;
    830. 

  830.     case 12: str = "Asynchronous Data Service (14.4 or 9.6 kbps)"; break;
    831. 

  831.     case 13: str = "Group 3 Facsimile (14.4 or 9.6 kbps)"; break;
    832. 

  832.     case 14: str = "Short Message Services (Rate Set 2)"; break;
    833. 

  833.     case 15: str = "Packet Data Service: Internet or ISO Protocol Stack (14.4 kbps)"; break;
    834. 

  834.     case 16: str = "Packet Data Service: CDPD Protocol Stack (14.4 kbps)"; break;
    835. 

  835.     case 17: str = "High Rate Voice Service (13 kbps)"; break;
    836. 

  836.     case 32768: str = "QCELP (13 kbps)"; break;
    837. 

  837.     case 32798: /* 0x801e */ str = "Qualcomm Loopback"; break;
    838. 

  838.     case 32799: /* 0x801f */ str = "Qualcomm Markov 8 kbps Loopback"; break;
    839. 

  839.     case 32800: /* 0x8020 */ str = "Qualcomm Packet Data"; break;
    840. 

  840.     case 32801: /* 0x8021 */ str = "Qualcomm Async Data"; break;
    841. 

  841.     case 18: str = "Over-the-Air Parameter Administration (Rate Set 1)"; break;
    842. 

  842.     case 19: str = "Over-the-Air Parameter Administration (Rate Set 2)"; break;
    843. 

  843.     case 20: str = "Group 3 Analog Facsimile (Rate Set 1)"; break;
    844. 

  844.     case 21: str = "Group 3 Analog Facsimile (Rate Set 2)"; break;
    845. 

  845.     case 22: str = "High Speed Packet Data Service: Internet or ISO Protocol Stack (RS1 forward, RS1 reverse)"; break;
    846. 

  846.     case 23: str = "High Speed Packet Data Service: Internet or ISO Protocol Stack (RS1 forward, RS2 reverse)"; break;
    847. 

  847.     case 24: str = "High Speed Packet Data Service: Internet or ISO Protocol Stack (RS2 forward, RS1 reverse)"; break;
    848. 

  848.     case 25: str = "High Speed Packet Data Service: Internet or ISO Protocol Stack (RS2 forward, RS2 reverse)"; break;
    849. 

  849.     case 26: str = "High Speed Packet Data Service: CDPD Protocol Stack (RS1 forward, RS1 reverse)"; break;
    850. 

  850.     case 27: str = "High Speed Packet Data Service: CDPD Protocol Stack (RS1 forward, RS2 reverse)"; break;
    851. 

  851.     case 28: str = "High Speed Packet Data Service: CDPD Protocol Stack (RS2 forward, RS1 reverse)"; break;
    852. 

  852.     case 29: str = "High Speed Packet Data Service: CDPD Protocol Stack (RS2 forward, RS2 reverse)"; break;
    853. 

  853.     case 30: str = "Supplemental Channel Loopback Test for Rate Set 1"; break;
    854. 

  854.     case 31: str = "Supplemental Channel Loopback Test for Rate Set 2"; break;
    855. 

  855.     case 32: str = "Test Data Service Option (TDSO)"; break;
    856. 

  856.     case 33: str = "cdma2000 High Speed Packet Data Service, Internet or ISO Protocol Stack"; break;
    857. 

  857.     case 34: str = "cdma2000 High Speed Packet Data Service, CDPD Protocol Stack"; break;
    858. 

  858.     case 35: str = "Location Services (PDS), Rate Set 1 (9.6 kbps)"; break;
    859. 

  859.     case 36: str = "Location Services (PDS), Rate Set 2 (14.4 kbps)"; break;
    860. 

  860.     case 37: str = "ISDN Interworking Service (64 kbps)"; break;
    861. 

  861.     case 38: str = "GSM Voice"; break;
    862. 

  862.     case 39: str = "GSM Circuit Data"; break;
    863. 

  863.     case 40: str = "GSM Packet Data"; break;
    864. 

  864.     case 41: str = "GSM Short Message Service"; break;
    865. 

  865.     case 42: str = "None Reserved for MC-MAP standard service options"; break;
    866. 

  866.     case 54: str = "Markov Service Option (MSO)"; break;
    867. 

  867.     case 55: str = "Loopback Service Option (LSO)"; break;
    868. 

  868.     case 56: str = "Selectable Mode Vocoder"; break;
    869. 

  869.     case 57: str = "32 kbps Circuit Video Conferencing"; break;
    870. 

  870.     case 58: str = "64 kbps Circuit Video Conferencing"; break;
    871. 

  871.     case 59: str = "HRPD Accounting Records Identifier"; break;
    872. 

  872.     case 60: str = "Link Layer Assisted Robust Header Compression (LLA ROHC) - Header Removal"; break;
    873. 

  873.     case 61: str = "Link Layer Assisted Robust Header Compression (LLA ROHC) - Header Compression"; break;
    874. 

  874.     case 62: str = "- 4099 None Reserved for standard service options"; break;
    875. 

  875.     case 68: str = "(EVRC-B NB) Enhanced Variable Rate Voice Service"; break;
    876. 

  876.     case 70: str = "(EVRC-B WB) Enhanced Variable Rate Voice Service"; break;
    877. 

  877.     case 73: str = "(EVRC-NW) Enhanced Variable Rate Voice Service"; break;
    878. 

  878.     case 4100: str = "Asynchronous Data Service, Revision 1 (9.6 or 14.4 kbps)"; break;
    879. 

  879.     case 4101: str = "Group 3 Facsimile, Revision 1 (9.6 or 14.4 kbps)"; break;
    880. 

  880.     case 4102: str = "Reserved for standard service option"; break;
    881. 

  881.     case 4103: str = "Packet Data Service: Internet or ISO Protocol Stack, Revision 1 (9.6 or 14.4 kbps)"; break;
    882. 

  882.     case 4104: str = "Packet Data Service: CDPD Protocol Stack, Revision 1 (9.6 or 14.4 kbps)"; break;
    883. 

  883.     default:
    884. 

  884.         if ((so >= 4105) && (so <= 32767)) { str = "Reserved for standard service options"; }
    885. 

  885.         else if ((so >= 32769) && (so <= 32771)) { str = "Proprietary QUALCOMM Incorporated"; }
    886. 

  886.         else if ((so >= 32772) && (so <= 32775)) { str = "Proprietary OKI Telecom"; }
    887. 

  887.         else if ((so >= 32776) && (so <= 32779)) { str = "Proprietary Lucent Technologies"; }
    888. 

  888.         else if ((so >= 32780) && (so <=32783)) { str = "Nokia"; }
    889. 

  889.         else if ((so >= 32784) && (so <=32787)) { str = "NORTEL NETWORKS"; }
    890. 

  890.         else if ((so >= 32788) && (so <=32791)) { str = "Sony Electronics Inc."; }
    891. 

  891.         else if ((so >= 32792) && (so <=32795)) { str = "Motorola"; }
    892. 

  892.         else if ((so >= 32796) && (so <=32799)) { str = "QUALCOMM Incorporated"; }
    893. 

  893.         else if ((so >= 32800) && (so <=32803)) { str = "QUALCOMM Incorporated"; }
    894. 

  894.         else if ((so >= 32804) && (so <=32807)) { str = "QUALCOMM Incorporated"; }
    895. 

  895.         else if ((so >= 32808) && (so <=32811)) { str = "QUALCOMM Incorporated"; }
    896. 

  896.         else if ((so >= 32812) && (so <=32815)) { str = "Lucent Technologies"; }
    897. 

  897.         else if ((so >= 32816) && (so <=32819)) { str = "Denso International"; }
    898. 

  898.         else if ((so >= 32820) && (so <=32823)) { str = "Motorola"; }
    899. 

  899.         else if ((so >= 32824) && (so <=32827)) { str = "Denso International"; }
    900. 

  900.         else if ((so >= 32828) && (so <=32831)) { str = "Denso International"; }
    901. 

  901.         else if ((so >= 32832) && (so <=32835)) { str = "Denso International"; }
    902. 

  902.         else if ((so >= 32836) && (so <=32839)) { str = "NEC America"; }
    903. 

  903.         else if ((so >= 32840) && (so <=32843)) { str = "Samsung Electronics"; }
    904. 

  904.         else if ((so >= 32844) && (so <=32847)) { str = "Texas Instruments Incorporated"; }
    905. 

  905.         else if ((so >= 32848) && (so <=32851)) { str = "Toshiba Corporation"; }
    906. 

  906.         else if ((so >= 32852) && (so <=32855)) { str = "LG Electronics Inc."; }
    907. 

  907.         else if ((so >= 32856) && (so <=32859)) { str = "VIA Telecom Inc."; }
    908. 

  908.         else { str = "Reserved"; }
    909. 

  909.         break;
    910. 

  910.     }
    911. 

  911. 

  912.     return(str);
    913. 

  913. }
    914. 

  914. 

  915. 

  916. /* ELEMENT FUNCTIONS */
    917. 

  917. 

  918. #define EXTRANEOUS_DATA_CHECK(edc_len, edc_max_len) \
    919. 

  919.     if ((edc_len) > (edc_max_len)) \
    920. 

  920.     { \
    921. 

  921.         proto_tree_add_text(tree, tvb, \
    922. 

  922.             curr_offset, (edc_len) - (edc_max_len), "Extraneous Data"); \
    923. 

  923.         curr_offset += ((edc_len) - (edc_max_len)); \
    924. 

  924.     }
    925. 

  925. 

  926. #define EXTRANEOUS_DATA_CHECK_EXPERT(edc_len, edc_max_len) \
    927. 

  927.     if ((edc_len) > (edc_max_len)) \
    928. 

  928.     { \
    929. 

  929.         proto_tree_add_expert(tree, pinfo, &ei_ansi_a_extraneous_data, \
    930. 

  930.             tvb, curr_offset, (edc_len) - (edc_max_len)); \
    931. 

  931.         curr_offset += ((edc_len) - (edc_max_len)); \
    932. 

  932.     }
    933. 

  933. 

  934. #define SHORT_DATA_CHECK(sdc_len, sdc_min_len) \
    935. 

  935.     if ((sdc_len) < (sdc_min_len)) \
    936. 

  936.     { \
    937. 

  937.         proto_tree_add_text(tree, tvb, \
    938. 

  938.             curr_offset, (sdc_len), "Short Data (?)"); \
    939. 

  939.         curr_offset += (sdc_len); \
    940. 

  940.         return(curr_offset - offset); \
    941. 

  941.     }
    942. 

  942. 

  943. #define EXACT_DATA_CHECK(edc_len, edc_eq_len) \
    944. 

  944.     if ((edc_len) != (edc_eq_len)) \
    945. 

  945.     { \
    946. 

  946.         proto_tree_add_text(tree, tvb, \
    947. 

  947.             asn1->offset, (edc_len), "Unexpected Data Length"); \
    948. 

  948.         asn1->offset += (edc_len); \
    949. 

  949.         return; \
    950. 

  950.     }
    951. 

  951. 

  952. #define NO_MORE_DATA_CHECK(nmdc_len) \
    953. 

  953.     if ((nmdc_len) == (curr_offset - offset)) return(nmdc_len);
    954. 

  954. 

  955. 

  956. /*
    957. 

  957.  * IOS 6.2.2.6
    958. 

  958.  */
    959. 

  959. static guint8
    960. 

  960. elem_chan_num(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    961. 

  961. {
    962. 

  962.     guint32     value;
    963. 

  963.     guint32     curr_offset;
    964. 

  964. 

  965.     curr_offset = offset;
    966. 

  966. 

  967.     value = tvb_get_ntohs(tvb, curr_offset);
    968. 

  968. 

  969.     switch (global_a_variant)
    970. 

  970.     {
    971. 

  971.     case A_VARIANT_IOS401:
    972. 

  972.         proto_tree_add_text(tree,
    973. 

  973.             tvb, curr_offset, 2,
    974. 

  974.             "Channel Number: %u",
    975. 

  975.             value);
    976. 

  976. 

  977.         g_snprintf(add_string, string_len, " - (%u)", value);
    978. 

  978.         break;
    979. 

  979. 

  980.     case A_VARIANT_IOS501:
    981. 

  981.         other_decode_bitfield_value(a_bigbuf, value >> 8, 0xf8, 8);
    982. 

  982.         proto_tree_add_text(tree,
    983. 

  983.             tvb, curr_offset, 1,
    984. 

  984.             "%s :  Reserved",
    985. 

  985.             a_bigbuf);
    986. 

  986. 

  987.         other_decode_bitfield_value(a_bigbuf, value >> 8, 0x07, 8);
    988. 

  988.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    989. 

  989.             "%s :  ARFCN (MSB): %u",
    990. 

  990.             a_bigbuf,
    991. 

  991.             value & 0x07ff);
    992. 

  992. 

  993.         other_decode_bitfield_value(a_bigbuf, value & 0x00ff, 0xff, 8);
    994. 

  994.         proto_tree_add_text(tree, tvb, curr_offset + 1, 1,
    995. 

  995.             "%s :  ARFCN (LSB)",
    996. 

  996.             a_bigbuf);
    997. 

  997. 

  998.         g_snprintf(add_string, string_len, " - (ARFCN: %u)", value & 0x07ff);
    999. 

  999.         break;
    1000. 

  1000.     }
    1001. 

  1001. 

  1002.     curr_offset += 2;
    1003. 

  1003. 

  1004.     /* no length check possible */
    1005. 

  1005. 

  1006.     return(curr_offset - offset);
    1007. 

  1007. }
    1008. 

  1008. 

  1009. /*
    1010. 

  1010.  * IOS 6.2.2.7
    1011. 

  1011.  */
    1012. 

  1012. static guint8
    1013. 

  1013. elem_chan_type(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    1014. 

  1014. {
    1015. 

  1015.     guint8      oct;
    1016. 

  1016.     guint32     curr_offset;
    1017. 

  1017.     const gchar *str = NULL;
    1018. 

  1018.     gboolean    data;
    1019. 

  1019. 

  1020.     curr_offset = offset;
    1021. 

  1021.     data = FALSE;
    1022. 

  1022. 

  1023.     oct = tvb_get_guint8(tvb, curr_offset);
    1024. 

  1024. 

  1025.     switch (oct)
    1026. 

  1026.     {
    1027. 

  1027.     case 0: str = "No Alert"; break;
    1028. 

  1028.     case 1: str = "Speech"; break;
    1029. 

  1029.     case 2: str = "Data"; data = TRUE; break;
    1030. 

  1030.     case 3: str = "Signaling"; break;
    1031. 

  1031.     default:
    1032. 

  1032.         str = "Unknown";
    1033. 

  1033.         break;
    1034. 

  1034.     }
    1035. 

  1035. 

  1036.     proto_tree_add_text(tree,
    1037. 

  1037.         tvb, curr_offset, 1,
    1038. 

  1038.         "Speech or Data Indicator: %s",
    1039. 

  1039.         str);
    1040. 

  1040. 

  1041.     g_snprintf(add_string, string_len, " - (%s)", str);
    1042. 

  1042. 

  1043.     curr_offset++;
    1044. 

  1044. 

  1045.     NO_MORE_DATA_CHECK(len);
    1046. 

  1046. 

  1047.     oct = tvb_get_guint8(tvb, curr_offset);
    1048. 

  1048. 

  1049.     switch (oct)
    1050. 

  1050.     {
    1051. 

  1051.     case 0: str = "Reserved (invalid)"; break;
    1052. 

  1052.     case 1: str = "DCCH"; break;
    1053. 

  1053.     case 2: str = "Reserved for future use (invalid)"; break;
    1054. 

  1054.     case 8: str = "Full rate TCH channel Bm"; break;
    1055. 

  1055.     case 9: str = "Half rate TCH channel Lm"; break;
    1056. 

  1056.     default:
    1057. 

  1057.         str = "Unknown";
    1058. 

  1058.         break;
    1059. 

  1059.     }
    1060. 

  1060. 

  1061.     proto_tree_add_text(tree,
    1062. 

  1062.         tvb, curr_offset, 1,
    1063. 

  1063.         "Channel Rate and Type: %s",
    1064. 

  1064.         str);
    1065. 

  1065. 

  1066.     curr_offset++;
    1067. 

  1067. 

  1068.     NO_MORE_DATA_CHECK(len);
    1069. 

  1069. 

  1070.     oct = tvb_get_guint8(tvb, curr_offset);
    1071. 

  1071. 

  1072.     if (data)
    1073. 

  1073.     {
    1074. 

  1074.         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    1075. 

  1075.         proto_tree_add_text(tree,
    1076. 

  1076.             tvb, curr_offset, 1,
    1077. 

  1077.             "%s :  Extension",
    1078. 

  1078.             a_bigbuf);
    1079. 

  1079. 

  1080.         other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
    1081. 

  1081.         proto_tree_add_text(tree,
    1082. 

  1082.             tvb, curr_offset, 1,
    1083. 

  1083.             "%s :  %sTransparent service",
    1084. 

  1084.             a_bigbuf,
    1085. 

  1085.             (oct & 0x40) ? "Non-" : "");
    1086. 

  1086. 

  1087.         other_decode_bitfield_value(a_bigbuf, oct, 0x3f, 8);
    1088. 

  1088.         proto_tree_add_text(tree,
    1089. 

  1089.             tvb, curr_offset, 1,
    1090. 

  1090.             "%s :  Reserved",
    1091. 

  1091.             a_bigbuf);
    1092. 

  1092.     }
    1093. 

  1093.     else
    1094. 

  1094.     {
    1095. 

  1095.         switch (oct)
    1096. 

  1096.         {
    1097. 

  1097.         case 0: str = "No Resources Required (invalid)"; break;
    1098. 

  1098.         case 1: str = "Reserved"; break;
    1099. 

  1099.         case 2: str = "Reserved"; break;
    1100. 

  1100.         case 3: str = "TIA/EIA-IS-2000 8 kb/s vocoder"; break;
    1101. 

  1101.         case 4: str = "8 kb/s enhanced vocoder (EVRC)"; break;
    1102. 

  1102.         case 5: str = "13 kb/s vocoder"; break;
    1103. 

  1103.         case 6: str = "ADPCM"; break;
    1104. 

  1104.         default:
    1105. 

  1105.             str = "Reserved";
    1106. 

  1106.             break;
    1107. 

  1107.         }
    1108. 

  1108. 

  1109.         proto_tree_add_text(tree,
    1110. 

  1110.             tvb, curr_offset, 1,
    1111. 

  1111.             "Speech Encoding Algorithm/data rate + Transparency Indicator: %s",
    1112. 

  1112.             str);
    1113. 

  1113.     }
    1114. 

  1114. 

  1115.     curr_offset++;
    1116. 

  1116. 

  1117.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    1118. 

  1118. 

  1119.     return(curr_offset - offset);
    1120. 

  1120. }
    1121. 

  1121. 

  1122. /*
    1123. 

  1123.  * IOS 5 4.2.83
    1124. 

  1124.  */
    1125. 

  1125. static guint8
    1126. 

  1126. elem_return_cause(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string _U_, int string_len _U_)
    1127. 

  1127. {
    1128. 

  1128.     guint8      oct;
    1129. 

  1129.     const gchar *str;
    1130. 

  1130.     guint32     curr_offset;
    1131. 

  1131. 

  1132.     curr_offset = offset;
    1133. 

  1133. 

  1134.     oct = tvb_get_guint8(tvb, curr_offset);
    1135. 

  1135. 

  1136.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    1137. 

  1137.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1138. 

  1138.         "%s :  Reserved",
    1139. 

  1139.         a_bigbuf);
    1140. 

  1140. 

  1141.     switch (oct & 0x0f)
    1142. 

  1142.     {
    1143. 

  1143.     case 0: str = "Normal access"; break;
    1144. 

  1144.     case 1: str = "Service redirection failed as a result of system not found"; break;
    1145. 

  1145.     case 2: str = "Service redirection failed as a result of protocol mismatch"; break;
    1146. 

  1146.     case 3: str = "Service redirection failed as a result of registration rejection"; break;
    1147. 

  1147.     case 4: str = "Service redirection failed as a result of wrong SID"; break;
    1148. 

  1148.     case 5: str = "Service redirection failed as a result of wrong NID"; break;
    1149. 

  1149.     default:
    1150. 

  1150.         str = "Reserved";
    1151. 

  1151.         break;
    1152. 

  1152.     }
    1153. 

  1153. 

  1154.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    1155. 

  1155.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1156. 

  1156.         "%s :  Return Cause: %s",
    1157. 

  1157.         a_bigbuf,
    1158. 

  1158.         str);
    1159. 

  1159. 

  1160.     curr_offset++;
    1161. 

  1161. 

  1162.     /* no length check possible */
    1163. 

  1163. 

  1164.     return(curr_offset - offset);
    1165. 

  1165. }
    1166. 

  1166. 

  1167. /*
    1168. 

  1168.  * IOS 6.2.2.8
    1169. 

  1169.  */
    1170. 

  1170. static guint8
    1171. 

  1171. elem_rf_chan_id(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    1172. 

  1172. {
    1173. 

  1173.     guint8      oct;
    1174. 

  1174.     guint32     value;
    1175. 

  1175.     guint32     curr_offset;
    1176. 

  1176. 

  1177.     curr_offset = offset;
    1178. 

  1178. 

  1179.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1180. 

  1180.         "Color Code");
    1181. 

  1181. 

  1182.     curr_offset++;
    1183. 

  1183. 

  1184.     oct = tvb_get_guint8(tvb, curr_offset);
    1185. 

  1185. 

  1186.     other_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8);
    1187. 

  1187.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1188. 

  1188.         "%s :  Reserved",
    1189. 

  1189.         a_bigbuf);
    1190. 

  1190. 

  1191.     other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
    1192. 

  1192.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1193. 

  1193.         "%s :  N-AMPS",
    1194. 

  1194.         a_bigbuf);
    1195. 

  1195. 

  1196.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    1197. 

  1197.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1198. 

  1198.         "%s :  ANSI/EIA/TIA-553",
    1199. 

  1199.         a_bigbuf);
    1200. 

  1200. 

  1201.     curr_offset++;
    1202. 

  1202. 

  1203.     oct = tvb_get_guint8(tvb, curr_offset);
    1204. 

  1204. 

  1205.     other_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8);
    1206. 

  1206.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1207. 

  1207.         "%s :  Reserved",
    1208. 

  1208.         a_bigbuf);
    1209. 

  1209. 

  1210.     other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
    1211. 

  1211.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1212. 

  1212.         "%s :  Timeslot Number",
    1213. 

  1213.         a_bigbuf);
    1214. 

  1214. 

  1215.     curr_offset++;
    1216. 

  1216. 

  1217.     value = tvb_get_ntohs(tvb, curr_offset);
    1218. 

  1218. 

  1219.     other_decode_bitfield_value(a_bigbuf, value >> 8, 0xf8, 8);
    1220. 

  1220.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1221. 

  1221.         "%s :  Reserved",
    1222. 

  1222.         a_bigbuf);
    1223. 

  1223. 

  1224.     other_decode_bitfield_value(a_bigbuf, value >> 8, 0x07, 8);
    1225. 

  1225.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1226. 

  1226.         "%s :  ARFCN (MSB): %u",
    1227. 

  1227.         a_bigbuf,
    1228. 

  1228.         value & 0x07ff);
    1229. 

  1229. 

  1230.     other_decode_bitfield_value(a_bigbuf, value & 0x00ff, 0xff, 8);
    1231. 

  1231.     proto_tree_add_text(tree, tvb, curr_offset + 1, 1,
    1232. 

  1232.         "%s :  ARFCN (LSB)",
    1233. 

  1233.         a_bigbuf);
    1234. 

  1234. 

  1235.     g_snprintf(add_string, string_len, " - (ARFCN: %u)", value & 0x07ff);
    1236. 

  1236. 

  1237.     curr_offset += 2;
    1238. 

  1238. 

  1239.     /* no length check possible */
    1240. 

  1240. 

  1241.     return(curr_offset - offset);
    1242. 

  1242. }
    1243. 

  1243. 

  1244. /*
    1245. 

  1245.  * IOS 5 4.2.86
    1246. 

  1246.  */
    1247. 

  1247. static guint8
    1248. 

  1248. elem_sr_id(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    1249. 

  1249. {
    1250. 

  1250.     guint8      oct;
    1251. 

  1251.     guint32     curr_offset;
    1252. 

  1252. 

  1253.     curr_offset = offset;
    1254. 

  1254. 

  1255.     oct = tvb_get_guint8(tvb, curr_offset);
    1256. 

  1256. 

  1257.     other_decode_bitfield_value(a_bigbuf, oct, 0xf8, 8);
    1258. 

  1258.     proto_tree_add_text(tree,
    1259. 

  1259.         tvb, curr_offset, 1,
    1260. 

  1260.         "%s :  Reserved",
    1261. 

  1261.         a_bigbuf);
    1262. 

  1262. 

  1263.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    1264. 

  1264.     proto_tree_add_text(tree,
    1265. 

  1265.         tvb, curr_offset, 1,
    1266. 

  1266.         "%s :  SR_ID: %u",
    1267. 

  1267.         a_bigbuf,
    1268. 

  1268.         oct & 0x07);
    1269. 

  1269. 

  1270.     g_snprintf(add_string, string_len, " - (%u)", oct);
    1271. 

  1271. 

  1272.     curr_offset++;
    1273. 

  1273. 

  1274.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    1275. 

  1275. 

  1276.     return(curr_offset - offset);
    1277. 

  1277. }
    1278. 

  1278. 

  1279. /*
    1280. 

  1280.  * IOS 6.2.2.9
    1281. 

  1281.  */
    1282. 

  1282. static guint8
    1283. 

  1283. elem_sid(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    1284. 

  1284. {
    1285. 

  1285.     guint32     value;
    1286. 

  1286.     guint32     curr_offset;
    1287. 

  1287. 

  1288.     curr_offset = offset;
    1289. 

  1289. 

  1290.     value = tvb_get_ntohs(tvb, curr_offset);
    1291. 

  1291. 

  1292.     other_decode_bitfield_value(a_bigbuf, value >> 8, 0x80, 8);
    1293. 

  1293.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1294. 

  1294.         "%s :  Reserved",
    1295. 

  1295.         a_bigbuf);
    1296. 

  1296. 

  1297.     other_decode_bitfield_value(a_bigbuf, value >> 8, 0x7f, 8);
    1298. 

  1298.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1299. 

  1299.         "%s :  SID (MSB), %u",
    1300. 

  1300.         a_bigbuf,
    1301. 

  1301.         value & 0x7fff);
    1302. 

  1302. 

  1303.     other_decode_bitfield_value(a_bigbuf, value & 0x00ff, 0xff, 8);
    1304. 

  1304.     proto_tree_add_text(tree, tvb, curr_offset + 1, 1,
    1305. 

  1305.         "%s :  SID (LSB)",
    1306. 

  1306.         a_bigbuf);
    1307. 

  1307. 

  1308.     g_snprintf(add_string, string_len, " - (SID: %u)", value & 0x7fff);
    1309. 

  1309. 

  1310.     curr_offset += 2;
    1311. 

  1311. 

  1312.     /* no length check possible */
    1313. 

  1313. 

  1314.     return(curr_offset - offset);
    1315. 

  1315. }
    1316. 

  1316. 

  1317. /*
    1318. 

  1318.  * IOS 6.2.2.10
    1319. 

  1319.  */
    1320. 

  1320. static guint8
    1321. 

  1321. elem_is95_chan_id(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    1322. 

  1322. {
    1323. 

  1323.     guint8      oct;
    1324. 

  1324.     guint32     value;
    1325. 

  1325.     guint32     curr_offset;
    1326. 

  1326. 

  1327.     curr_offset = offset;
    1328. 

  1328. 

  1329.     oct = tvb_get_guint8(tvb, curr_offset);
    1330. 

  1330. 

  1331.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    1332. 

  1332.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1333. 

  1333.         "%s :  Hard Handoff",
    1334. 

  1334.         a_bigbuf);
    1335. 

  1335. 

  1336.     other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
    1337. 

  1337.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1338. 

  1338.         "%s :  Number of Channels to Add: %u",
    1339. 

  1339.         a_bigbuf,
    1340. 

  1340.         (oct & 0x70) >> 4);
    1341. 

  1341. 

  1342.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    1343. 

  1343.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1344. 

  1344.         "%s :  Frame Offset: (%u), %.2f ms",
    1345. 

  1345.         a_bigbuf,
    1346. 

  1346.         oct & 0x0f,
    1347. 

  1347.         (oct & 0x0f) * 1.25);
    1348. 

  1348. 

  1349.     curr_offset++;
    1350. 

  1350. 

  1351.     NO_MORE_DATA_CHECK(len);
    1352. 

  1352. 

  1353.     SHORT_DATA_CHECK(len - (curr_offset - offset), 4);
    1354. 

  1354. 

  1355.     do
    1356. 

  1356.     {
    1357. 

  1357.         oct = tvb_get_guint8(tvb, curr_offset);
    1358. 

  1358. 

  1359.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    1360. 

  1360.             "Walsh Code Channel Index: %u",
    1361. 

  1361.             oct);
    1362. 

  1362. 

  1363.         curr_offset++;
    1364. 

  1364. 

  1365.         oct = tvb_get_guint8(tvb, curr_offset);
    1366. 

  1366. 

  1367.         other_decode_bitfield_value(a_bigbuf, oct, 0xff, 8);
    1368. 

  1368.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    1369. 

  1369.             "%s :  Pilot PN Code (LSB)",
    1370. 

  1370.             a_bigbuf);
    1371. 

  1371. 

  1372.         curr_offset++;
    1373. 

  1373. 

  1374.         value = oct;
    1375. 

  1375.         oct = tvb_get_guint8(tvb, curr_offset);
    1376. 

  1376.         value |= ((guint32) (oct & 0x80)) << 1;
    1377. 

  1377. 

  1378.         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    1379. 

  1379.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    1380. 

  1380.             "%s :  Pilot PN Code (MSB): %u",
    1381. 

  1381.             a_bigbuf,
    1382. 

  1382.             value);
    1383. 

  1383. 

  1384.         other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
    1385. 

  1385.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    1386. 

  1386.             "%s :  Power Combined",
    1387. 

  1387.             a_bigbuf);
    1388. 

  1388. 

  1389.         other_decode_bitfield_value(a_bigbuf, oct, 0x20, 8);
    1390. 

  1390.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    1391. 

  1391.             "%s :  Frequency Included",
    1392. 

  1392.             a_bigbuf);
    1393. 

  1393. 

  1394.         other_decode_bitfield_value(a_bigbuf, oct, 0x18, 8);
    1395. 

  1395.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    1396. 

  1396.             "%s :  Reserved",
    1397. 

  1397.             a_bigbuf);
    1398. 

  1398. 

  1399.         value = tvb_get_guint8(tvb, curr_offset + 1) | ((oct & 0x07) << 8);
    1400. 

  1400. 

  1401.         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    1402. 

  1402.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    1403. 

  1403.             "%s :  ARFCN (MSB): %u",
    1404. 

  1404.             a_bigbuf,
    1405. 

  1405.             value);
    1406. 

  1406. 

  1407.         curr_offset++;
    1408. 

  1408. 

  1409.         other_decode_bitfield_value(a_bigbuf, value & 0x00ff, 0xff, 8);
    1410. 

  1410.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    1411. 

  1411.             "%s :  ARFCN (LSB)",
    1412. 

  1412.             a_bigbuf);
    1413. 

  1413. 

  1414.         if (add_string[0] == '\0')
    1415. 

  1415.         {
    1416. 

  1416.             g_snprintf(add_string, string_len, " - (ARFCN: %u)", value);
    1417. 

  1417.         }
    1418. 

  1418. 

  1419.         curr_offset++;
    1420. 

  1420.     }
    1421. 

  1421.     while ((len - (curr_offset - offset)) >= 4);
    1422. 

  1422. 

  1423.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    1424. 

  1424. 

  1425.     return(curr_offset - offset);
    1426. 

  1426. }
    1427. 

  1427. 

  1428. /*
    1429. 

  1429.  * IOS 6.2.2.11
    1430. 

  1430.  * UNUSED
    1431. 

  1431.  */
    1432. 

  1432. 

  1433. /*
    1434. 

  1434.  * IOS 6.2.2.12
    1435. 

  1435.  */
    1436. 

  1436. static guint8
    1437. 

  1437. elem_enc_info(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    1438. 

  1438. {
    1439. 

  1439.     guint8      oct;
    1440. 

  1440.     guint8      oct_len;
    1441. 

  1441.     guint32     curr_offset;
    1442. 

  1442.     const gchar *str;
    1443. 

  1443.     guint8      num_recs;
    1444. 

  1444.     proto_tree  *subtree;
    1445. 

  1445.     proto_item  *item;
    1446. 

  1446. 

  1447.     curr_offset = offset;
    1448. 

  1448. 

  1449.     num_recs = 0;
    1450. 

  1450. 

  1451.     while ((len - (curr_offset - offset)) >= 2)
    1452. 

  1452.     {
    1453. 

  1453.         num_recs++;
    1454. 

  1454. 

  1455.         oct = tvb_get_guint8(tvb, curr_offset);
    1456. 

  1456. 

  1457.         switch ((oct & 0x7c) >> 2)
    1458. 

  1458.         {
    1459. 

  1459.         case 0: str = "Not Used - Invalid value"; break;
    1460. 

  1460.         case 1: str = "SME Key: Signaling Message Encryption Key"; break;
    1461. 

  1461.         case 2: str = "Reserved (VPM: Voice Privacy Mask)"; break;
    1462. 

  1462.         case 3: str = "Reserved"; break;
    1463. 

  1463.         case 4: str = "Private Longcode"; break;
    1464. 

  1464.         case 5: str = "Data Key (ORYX)"; break;
    1465. 

  1465.         case 6: str = "Initial RAND"; break;
    1466. 

  1466.         default:
    1467. 

  1467.             str = "Reserved";
    1468. 

  1468.             break;
    1469. 

  1469.         }
    1470. 

  1470. 

  1471.         item =
    1472. 

  1472.             proto_tree_add_text(tree,
    1473. 

  1473.                 tvb, curr_offset, 1,
    1474. 

  1474.                 "Encryption Info [%u]: (%u) %s",
    1475. 

  1475.                 num_recs,
    1476. 

  1476.                 (oct & 0x7c) >> 2,
    1477. 

  1477.                 str);
    1478. 

  1478. 

  1479.         subtree = proto_item_add_subtree(item, ett_ansi_enc_info);
    1480. 

  1480. 

  1481.         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    1482. 

  1482.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    1483. 

  1483.             "%s :  Extension",
    1484. 

  1484.             a_bigbuf);
    1485. 

  1485. 

  1486.         other_decode_bitfield_value(a_bigbuf, oct, 0x7c, 8);
    1487. 

  1487.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    1488. 

  1488.             "%s :  Encryption Parameter Identifier: (%u) %s",
    1489. 

  1489.             a_bigbuf,
    1490. 

  1490.             (oct & 0x7c) >> 2,
    1491. 

  1491.             str);
    1492. 

  1492. 

  1493.         other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
    1494. 

  1494.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    1495. 

  1495.             "%s :  Status: %s",
    1496. 

  1496.             a_bigbuf,
    1497. 

  1497.             (oct & 0x02) ? "active" : "inactive");
    1498. 

  1498. 

  1499.         other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    1500. 

  1500.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    1501. 

  1501.             "%s :  Available: algorithm is %savailable",
    1502. 

  1502.             a_bigbuf,
    1503. 

  1503.             (oct & 0x01) ? "" : "not ");
    1504. 

  1504. 

  1505.         curr_offset++;
    1506. 

  1506. 

  1507.         oct_len = tvb_get_guint8(tvb, curr_offset);
    1508. 

  1508. 

  1509.         proto_tree_add_uint(subtree, hf_ansi_a_length, tvb,
    1510. 

  1510.             curr_offset, 1, oct_len);
    1511. 

  1511. 

  1512.         curr_offset++;
    1513. 

  1513. 

  1514.         if (oct_len > 0)
    1515. 

  1515.         {
    1516. 

  1516.             SHORT_DATA_CHECK(len - (curr_offset - offset), oct_len);
    1517. 

  1517. 

  1518.             proto_tree_add_text(subtree, tvb, curr_offset, oct_len,
    1519. 

  1519.                 "Encryption Parameter value");
    1520. 

  1520. 

  1521.             curr_offset += oct_len;
    1522. 

  1522.         }
    1523. 

  1523.     }
    1524. 

  1524. 

  1525.     g_snprintf(add_string, string_len, " - %u record%s",
    1526. 

  1526.         num_recs, plurality(num_recs, "", "s"));
    1527. 

  1527. 

  1528.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    1529. 

  1529. 

  1530.     return(curr_offset - offset);
    1531. 

  1531. }
    1532. 

  1532. 

  1533. /*
    1534. 

  1534.  * IOS 6.2.2.13
    1535. 

  1535.  * NO ASSOCIATED DATA
    1536. 

  1536.  */
    1537. 

  1537. 

  1538. /*
    1539. 

  1539.  * IOS 6.2.2.14
    1540. 

  1540.  * A3/A7
    1541. 

  1541.  */
    1542. 

  1542. 

  1543. /*
    1544. 

  1544.  * IOS 6.2.2.15
    1545. 

  1545.  */
    1546. 

  1546. static guint8
    1547. 

  1547. elem_cm_info_type_2(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    1548. 

  1548. {
    1549. 

  1549.     guint8      oct, oct2;
    1550. 

  1550.     guint8      num_bands, band_class_count;
    1551. 

  1551.     guint32     curr_offset;
    1552. 

  1552.     gint        band_class;
    1553. 

  1553.     proto_tree  *subtree;
    1554. 

  1554.     proto_item  *item;
    1555. 

  1555.     const gchar *str;
    1556. 

  1556. 

  1557.     curr_offset = offset;
    1558. 

  1558. 

  1559.     oct = tvb_get_guint8(tvb, curr_offset);
    1560. 

  1560. 

  1561.     other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    1562. 

  1562.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1563. 

  1563.         "%s :  Mobile P_REV: %u",
    1564. 

  1564.         a_bigbuf,
    1565. 

  1565.         (oct & 0xe0) >> 5);
    1566. 

  1566. 

  1567.     g_snprintf(add_string, string_len, " - P_REV (%u)", (oct & 0xe0) >> 5);
    1568. 

  1568. 

  1569.     other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
    1570. 

  1570.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1571. 

  1571.         "%s :  Reserved",
    1572. 

  1572.         a_bigbuf);
    1573. 

  1573. 

  1574.     other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    1575. 

  1575.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1576. 

  1576.         "%s :  See List of Entries",
    1577. 

  1577.         a_bigbuf);
    1578. 

  1578. 

  1579.     switch (oct & 0x07)
    1580. 

  1580.     {
    1581. 

  1581.     case 0: str = "Class 1, vehicle and portable"; break;
    1582. 

  1582.     case 1: str = "Class 2, portable"; break;
    1583. 

  1583.     case 2: str = "Class 3, handheld"; break;
    1584. 

  1584.     case 3: str = "Class 4, handheld"; break;
    1585. 

  1585.     case 4: str = "Class 5, handheld"; break;
    1586. 

  1586.     case 5: str = "Class 6, handheld"; break;
    1587. 

  1587.     case 6: str = "Class 7, handheld"; break;
    1588. 

  1588.     default:
    1589. 

  1589.         str = "Class 8, handheld";
    1590. 

  1590.         break;
    1591. 

  1591.     }
    1592. 

  1592. 

  1593.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    1594. 

  1594.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1595. 

  1595.         "%s :  RF Power Capability: %s",
    1596. 

  1596.         a_bigbuf,
    1597. 

  1597.         str);
    1598. 

  1598. 

  1599.     curr_offset++;
    1600. 

  1600. 

  1601.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1602. 

  1602.         "Reserved");
    1603. 

  1603. 

  1604.     curr_offset++;
    1605. 

  1605. 

  1606.     oct = tvb_get_guint8(tvb, curr_offset);
    1607. 

  1607. 

  1608.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    1609. 

  1609.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1610. 

  1610.         "%s :  NAR_AN_CAP: N-AMPS %ssupported",
    1611. 

  1611.         a_bigbuf,
    1612. 

  1612.         (oct & 0x80) ? "" : "not ");
    1613. 

  1613. 

  1614.     other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
    1615. 

  1615.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1616. 

  1616.         "%s :  IS-95: %ssupported",
    1617. 

  1617.         a_bigbuf,
    1618. 

  1618.         (oct & 0x40) ? "" : "not ");
    1619. 

  1619. 

  1620.     other_decode_bitfield_value(a_bigbuf, oct, 0x20, 8);
    1621. 

  1621.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1622. 

  1622.         "%s :  Slotted: mobile is %sin slotted mode",
    1623. 

  1623.         a_bigbuf,
    1624. 

  1624.         (oct & 0x20) ? "" : "not ");
    1625. 

  1625. 

  1626.     other_decode_bitfield_value(a_bigbuf, oct, 0x18, 8);
    1627. 

  1627.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1628. 

  1628.         "%s :  Reserved",
    1629. 

  1629.         a_bigbuf);
    1630. 

  1630. 

  1631.     other_decode_bitfield_value(a_bigbuf, oct, 0x04, 8);
    1632. 

  1632.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1633. 

  1633.         "%s :  DTX: mobile is %scapable of DTX",
    1634. 

  1634.         a_bigbuf,
    1635. 

  1635.         (oct & 0x04) ? "" : "not ");
    1636. 

  1636. 

  1637.     other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
    1638. 

  1638.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1639. 

  1639.         "%s :  Mobile Term: mobile is %scapable of receiving incoming calls",
    1640. 

  1640.         a_bigbuf,
    1641. 

  1641.         (oct & 0x02) ? "" : "not ");
    1642. 

  1642. 

  1643.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    1644. 

  1644.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1645. 

  1645.         "%s :  Reserved",
    1646. 

  1646.         a_bigbuf);
    1647. 

  1647. 

  1648.     curr_offset++;
    1649. 

  1649. 

  1650.     NO_MORE_DATA_CHECK(len);
    1651. 

  1651. 

  1652.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1653. 

  1653.         "Reserved");
    1654. 

  1654. 

  1655.     curr_offset++;
    1656. 

  1656. 

  1657.     NO_MORE_DATA_CHECK(len);
    1658. 

  1658. 

  1659.     oct = tvb_get_guint8(tvb, curr_offset);
    1660. 

  1660. 

  1661.     other_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8);
    1662. 

  1662.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1663. 

  1663.         "%s :  Reserved",
    1664. 

  1664.         a_bigbuf);
    1665. 

  1665. 

  1666.     other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
    1667. 

  1667.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1668. 

  1668.         "%s :  Mobile Term: mobile is %scapable of receiving incoming calls",
    1669. 

  1669.         a_bigbuf,
    1670. 

  1670.         (oct & 0x02) ? "" : "not ");
    1671. 

  1671. 

  1672.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    1673. 

  1673.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1674. 

  1674.         "%s :  PACA Supported Indicator (PSI): mobile station %s PACA",
    1675. 

  1675.         a_bigbuf,
    1676. 

  1676.         (oct & 0x01) ? "supports" : "does not support");
    1677. 

  1677. 

  1678.     curr_offset++;
    1679. 

  1679. 

  1680.     NO_MORE_DATA_CHECK(len);
    1681. 

  1681. 

  1682.     oct = tvb_get_guint8(tvb, curr_offset);
    1683. 

  1683. 

  1684.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1685. 

  1685.         "SCM Length: %u",
    1686. 

  1686.         oct);
    1687. 

  1687. 

  1688.     curr_offset++;
    1689. 

  1689. 

  1690.     oct = tvb_get_guint8(tvb, curr_offset);
    1691. 

  1691. 

  1692.     item =
    1693. 

  1693.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    1694. 

  1694.             "Station Class Mark: %u",
    1695. 

  1695.             oct);
    1696. 

  1696. 

  1697.     /*
    1698. 

  1698.      * following SCM decode is from:
    1699. 

  1699.      *  3GPP2 C.S0005-0 section 2.3.3
    1700. 

  1700.      *  3GPP2 C.S0072-0 section 2.1.2
    1701. 

  1701.      */
    1702. 

  1702.     subtree = proto_item_add_subtree(item, ett_scm);
    1703. 

  1703. 

  1704.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    1705. 

  1705.     proto_tree_add_text(subtree, tvb, curr_offset, 1,
    1706. 

  1706.         "%s :  Extended SCM Indicator: %s",
    1707. 

  1707.         a_bigbuf,
    1708. 

  1708.         (oct & 0x80) ? "Band Classes 1,4" : "Other bands");
    1709. 

  1709. 

  1710.     other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
    1711. 

  1711.     proto_tree_add_text(subtree, tvb, curr_offset, 1,
    1712. 

  1712.         "%s :  %s",
    1713. 

  1713.         a_bigbuf,
    1714. 

  1714.         (oct & 0x40) ? "Dual Mode" : "CDMA Only");
    1715. 

  1715. 

  1716.     other_decode_bitfield_value(a_bigbuf, oct, 0x20, 8);
    1717. 

  1717.     proto_tree_add_text(subtree, tvb, curr_offset, 1,
    1718. 

  1718.         "%s :  %s",
    1719. 

  1719.         a_bigbuf,
    1720. 

  1720.         (oct & 0x20) ? "Slotted" : "Non-Slotted");
    1721. 

  1721. 

  1722.     if (oct & 0x10)
    1723. 

  1723.     {
    1724. 

  1724.         str = "";
    1725. 

  1725.         g_strlcat(add_string, " (MEID configured)", string_len);
    1726. 

  1726.         a_meid_configured = TRUE;
    1727. 

  1727.     }
    1728. 

  1728.     else
    1729. 

  1729.     {
    1730. 

  1730.         str = "not ";
    1731. 

  1731.     }
    1732. 

  1732. 

  1733.     other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
    1734. 

  1734.     proto_tree_add_boolean_format(subtree, hf_ansi_a_meid_configured, tvb,
    1735. 

  1735.         curr_offset, 1, a_meid_configured,
    1736. 

  1736.         "%s :  MEID %sconfigured",
    1737. 

  1737.         a_bigbuf,
    1738. 

  1738.         str);
    1739. 

  1739. 

  1740.     other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    1741. 

  1741.     proto_tree_add_text(subtree, tvb, curr_offset, 1,
    1742. 

  1742.         "%s :  25 MHz Bandwidth",
    1743. 

  1743.         a_bigbuf);
    1744. 

  1744. 

  1745.     other_decode_bitfield_value(a_bigbuf, oct, 0x04, 8);
    1746. 

  1746.     proto_tree_add_text(subtree, tvb, curr_offset, 1,
    1747. 

  1747.         "%s :  %s Transmission",
    1748. 

  1748.         a_bigbuf,
    1749. 

  1749.         (oct & 0x04) ? "Discontinuous" : "Continuous");
    1750. 

  1750. 

  1751.     switch (oct & 0x03)
    1752. 

  1752.     {
    1753. 

  1753.     case 0x00: str = "Class I"; break;
    1754. 

  1754.     case 0x01: str = "Class II"; break;
    1755. 

  1755.     case 0x02: str = "Class III"; break;
    1756. 

  1756.     case 0x03: str = "Reserved"; break;
    1757. 

  1757.     }
    1758. 

  1758. 

  1759.     other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
    1760. 

  1760.     proto_tree_add_text(subtree, tvb, curr_offset, 1,
    1761. 

  1761.         "%s :  Power Class for Band Class 0 Analog Operation: %s",
    1762. 

  1762.         a_bigbuf,
    1763. 

  1763.         str);
    1764. 

  1764. 

  1765.     curr_offset++;
    1766. 

  1766. 

  1767.     NO_MORE_DATA_CHECK(len);
    1768. 

  1768. 

  1769.     band_class_count = tvb_get_guint8(tvb, curr_offset);
    1770. 

  1770. 

  1771.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1772. 

  1772.         "Count of Band Class Entries: %u",
    1773. 

  1773.         band_class_count);
    1774. 

  1774. 

  1775.     curr_offset++;
    1776. 

  1776. 

  1777.     oct = tvb_get_guint8(tvb, curr_offset);
    1778. 

  1778. 

  1779.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    1780. 

  1780.         "Band Class Entry Length: %u",
    1781. 

  1781.         oct);
    1782. 

  1782. 

  1783.     curr_offset++;
    1784. 

  1784. 

  1785.     NO_MORE_DATA_CHECK(len);
    1786. 

  1786. 

  1787.     if (oct > 0)
    1788. 

  1788.     {
    1789. 

  1789.         SHORT_DATA_CHECK(len - (curr_offset - offset), 3);
    1790. 

  1790. 

  1791.         num_bands = 0;
    1792. 

  1792.         do
    1793. 

  1793.         {
    1794. 

  1794.             item =
    1795. 

  1795.                 proto_tree_add_text(tree, tvb, curr_offset, 3,
    1796. 

  1796.                     "Band Class Entry [%u]",
    1797. 

  1797.                     num_bands + 1);
    1798. 

  1798. 

  1799.             subtree = proto_item_add_subtree(item, ett_cm2_band_class);
    1800. 

  1800. 

  1801.             oct = tvb_get_guint8(tvb, curr_offset);
    1802. 

  1802. 

  1803.             other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    1804. 

  1804.             proto_tree_add_text(subtree,
    1805. 

  1805.                 tvb, curr_offset, 1,
    1806. 

  1806.                 "%s :  Reserved",
    1807. 

  1807.                 a_bigbuf);
    1808. 

  1808. 

  1809.             band_class = oct & 0x1f;
    1810. 

  1810.             if ((band_class < 0) || (band_class >= (gint) NUM_BAND_CLASS_STR))
    1811. 

  1811.             {
    1812. 

  1812.                 str = "Reserved";
    1813. 

  1813.             }
    1814. 

  1814.             else
    1815. 

  1815.             {
    1816. 

  1816.                 str = band_class_str[band_class];
    1817. 

  1817.             }
    1818. 

  1818. 

  1819.             other_decode_bitfield_value(a_bigbuf, oct, 0x1f, 8);
    1820. 

  1820.             proto_tree_add_text(subtree,
    1821. 

  1821.                 tvb, curr_offset, 1,
    1822. 

  1822.                 "%s :  Band Class: %s",
    1823. 

  1823.                 a_bigbuf,
    1824. 

  1824.                 str);
    1825. 

  1825. 

  1826.             curr_offset++;
    1827. 

  1827. 

  1828.             oct2 = tvb_get_guint8(tvb, curr_offset);
    1829. 

  1829.             oct = tvb_get_guint8(tvb, curr_offset+1);
    1830. 

  1830. 

  1831.             if (oct < 4)
    1832. 

  1832.             {
    1833. 

  1833.                 other_decode_bitfield_value(a_bigbuf, oct2, 0x80, 8);
    1834. 

  1834.                 proto_tree_add_text(subtree,
    1835. 

  1835.                     tvb, curr_offset, 1,
    1836. 

  1836.                     "%s :  Band Class Air Interfaces OP_MODE0 (CDMA mode in Band Class 1 and Band Class 4)",
    1837. 

  1837.                     a_bigbuf);
    1838. 

  1838. 

  1839.                 other_decode_bitfield_value(a_bigbuf, oct2, 0x40, 8);
    1840. 

  1840.                 proto_tree_add_text(subtree,
    1841. 

  1841.                     tvb, curr_offset, 1,
    1842. 

  1842.                     "%s :  Band Class Air Interfaces OP_MODE1 (CDMA mode in Band Class 0 and Band Class 3)",
    1843. 

  1843.                     a_bigbuf);
    1844. 

  1844. 

  1845.                 other_decode_bitfield_value(a_bigbuf, oct2, 0x20, 8);
    1846. 

  1846.                 proto_tree_add_text(subtree,
    1847. 

  1847.                     tvb, curr_offset, 1,
    1848. 

  1848.                     "%s :  Band Class Air Interfaces OP_MODE2 (Analog mode)",
    1849. 

  1849.                     a_bigbuf);
    1850. 

  1850. 

  1851.                 other_decode_bitfield_value(a_bigbuf, oct2, 0x10, 8);
    1852. 

  1852.                 proto_tree_add_text(subtree,
    1853. 

  1853.                     tvb, curr_offset, 1,
    1854. 

  1854.                     "%s :  Band Class Air Interfaces OP_MODE3 (Wide analog mode)",
    1855. 

  1855.                     a_bigbuf);
    1856. 

  1856. 

  1857.                 other_decode_bitfield_value(a_bigbuf, oct2, 0x08, 8);
    1858. 

  1858.                 proto_tree_add_text(subtree,
    1859. 

  1859.                     tvb, curr_offset, 1,
    1860. 

  1860.                     "%s :  Band Class Air Interfaces OP_MODE4 (Narrow analog mode)",
    1861. 

  1861.                     a_bigbuf);
    1862. 

  1862.             }
    1863. 

  1863.             else
    1864. 

  1864.             {
    1865. 

  1865.                 other_decode_bitfield_value(a_bigbuf, oct2, 0x80, 8);
    1866. 

  1866.                 proto_tree_add_text(subtree,
    1867. 

  1867.                     tvb, curr_offset, 1,
    1868. 

  1868.                     "%s :  Band Class Air Interfaces OP_MODE0 (CDMA mode)",
    1869. 

  1869.                     a_bigbuf);
    1870. 

  1870. 

  1871.                 other_decode_bitfield_value(a_bigbuf, oct2, 0x40, 8);
    1872. 

  1872.                 proto_tree_add_text(subtree,
    1873. 

  1873.                     tvb, curr_offset, 1,
    1874. 

  1874.                     "%s :  Band Class Air Interfaces OP_MODE1 (CDMA mode)",
    1875. 

  1875.                     a_bigbuf);
    1876. 

  1876. 

  1877.                 other_decode_bitfield_value(a_bigbuf, oct2, 0x20, 8);
    1878. 

  1878.                 proto_tree_add_text(subtree,
    1879. 

  1879.                     tvb, curr_offset, 1,
    1880. 

  1880.                     "%s :  Band Class Air Interfaces OP_MODE2 (Analog mode)",
    1881. 

  1881.                     a_bigbuf);
    1882. 

  1882. 

  1883.                 other_decode_bitfield_value(a_bigbuf, oct2, 0x10, 8);
    1884. 

  1884.                 proto_tree_add_text(subtree,
    1885. 

  1885.                     tvb, curr_offset, 1,
    1886. 

  1886.                     "%s :  Band Class Air Interfaces OP_MODE3 (Wide analog mode)",
    1887. 

  1887.                     a_bigbuf);
    1888. 

  1888. 

  1889.                 other_decode_bitfield_value(a_bigbuf, oct2, 0x08, 8);
    1890. 

  1890.                 proto_tree_add_text(subtree,
    1891. 

  1891.                     tvb, curr_offset, 1,
    1892. 

  1892.                     "%s :  Band Class Air Interfaces OP_MODE4 (Narrow analog mode)",
    1893. 

  1893.                     a_bigbuf);
    1894. 

  1894.             }
    1895. 

  1895. 

  1896.             other_decode_bitfield_value(a_bigbuf, oct2, 0x07, 8);
    1897. 

  1897.             proto_tree_add_text(subtree,
    1898. 

  1898.                 tvb, curr_offset, 1,
    1899. 

  1899.                 "%s :  Reserved",
    1900. 

  1900.                 a_bigbuf);
    1901. 

  1901. 

  1902.             curr_offset++;
    1903. 

  1903. 

  1904.             proto_tree_add_text(subtree,
    1905. 

  1905.                 tvb, curr_offset, 1,
    1906. 

  1906.                 "Band Class MS Protocol Level: %u",
    1907. 

  1907.                 oct);
    1908. 

  1908. 

  1909.             curr_offset++;
    1910. 

  1910. 

  1911.             proto_item_append_text(item, ": (%d)", band_class);
    1912. 

  1912. 

  1913.             num_bands++;
    1914. 

  1914.         }
    1915. 

  1915.         while (((len - (curr_offset - offset)) >= 3) &&
    1916. 

  1916.             (num_bands < band_class_count));
    1917. 

  1917.     }
    1918. 

  1918. 

  1919.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    1920. 

  1920. 

  1921.     return(curr_offset - offset);
    1922. 

  1922. }
    1923. 

  1923. 

  1924. /*
    1925. 

  1925.  * IOS 6.2.2.16
    1926. 

  1926.  */
    1927. 

  1927. static guint8
    1928. 

  1928. elem_mid(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    1929. 

  1929. {
    1930. 

  1930.     guint8      oct;
    1931. 

  1931.     guint8      *poctets;
    1932. 

  1932.     guint32     value;
    1933. 

  1933.     guint32     curr_offset;
    1934. 

  1934.     const gchar *str;
    1935. 

  1935. 

  1936.     curr_offset = offset;
    1937. 

  1937. 

  1938.     oct = tvb_get_guint8(tvb, curr_offset);
    1939. 

  1939. 

  1940.     switch (oct & 0x07)
    1941. 

  1941.     {
    1942. 

  1942.     case 1:
    1943. 

  1943.         other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    1944. 

  1944.         proto_tree_add_text(tree,
    1945. 

  1945.             tvb, curr_offset, 1,
    1946. 

  1946.             "%s :  MEID Hex Digit 1: %X",
    1947. 

  1947.             a_bigbuf,
    1948. 

  1948.             (oct & 0xf0) >> 4);
    1949. 

  1949. 

  1950.         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    1951. 

  1951.         proto_tree_add_text(tree,
    1952. 

  1952.             tvb, curr_offset, 1,
    1953. 

  1953.             "%s :  Odd/Even Indicator: %s",
    1954. 

  1954.             a_bigbuf,
    1955. 

  1955.             (oct & 0x08) ? "ODD" : "EVEN");
    1956. 

  1956. 

  1957.         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    1958. 

  1958.         proto_tree_add_text(tree,
    1959. 

  1959.             tvb, curr_offset, 1,
    1960. 

  1960.             "%s :  Type of Identity: MEID",
    1961. 

  1961.             a_bigbuf);
    1962. 

  1962. 

  1963.         a_bigbuf[0] = Dgt_meid.out[(oct & 0xf0) >> 4];
    1964. 

  1964.         curr_offset++;
    1965. 

  1965. 

  1966.         poctets = tvb_get_ephemeral_string(tvb, curr_offset, len - (curr_offset - offset));
    1967. 

  1967. 

  1968.         my_dgt_tbcd_unpack(&a_bigbuf[1], poctets, len - (curr_offset - offset),
    1969. 

  1969.             &Dgt_meid);
    1970. 

  1970. 

  1971.         curr_offset += len - (curr_offset - offset);
    1972. 

  1972. 

  1973.         proto_tree_add_string_format(tree,
    1974. 

  1974.             hf_ansi_a_meid,
    1975. 

  1975.             tvb, offset + 1, len - 1,
    1976. 

  1976.             a_bigbuf,
    1977. 

  1977.             "MEID: %s",
    1978. 

  1978.             a_bigbuf);
    1979. 

  1979. 

  1980.         g_snprintf(add_string, string_len, " - %s (%s)",
    1981. 

  1981.             "MEID",
    1982. 

  1982.             a_bigbuf);
    1983. 

  1983.         break;
    1984. 

  1984. 

  1985.     case 2:
    1986. 

  1986.         other_decode_bitfield_value(a_bigbuf, oct, 0xf8, 8);
    1987. 

  1987.         proto_tree_add_text(tree,
    1988. 

  1988.             tvb, curr_offset, 1,
    1989. 

  1989.             "%s :  Reserved",
    1990. 

  1990.             a_bigbuf);
    1991. 

  1991. 

  1992.         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    1993. 

  1993.         proto_tree_add_text(tree,
    1994. 

  1994.             tvb, curr_offset, 1,
    1995. 

  1995.             "%s :  Type of Identity: Broadcast",
    1996. 

  1996.             a_bigbuf);
    1997. 

  1997. 

  1998.         curr_offset++;
    1999. 

  1999. 

  2000.         oct = tvb_get_guint8(tvb, curr_offset);
    2001. 

  2001. 

  2002.         switch ((oct & 0xc0) >> 6)
    2003. 

  2003.         {
    2004. 

  2004.         case 0: str = "Normal"; break;
    2005. 

  2005.         case 1: str = "Interactive"; break;
    2006. 

  2006.         case 2: str = "Urgent"; break;
    2007. 

  2007.         default:
    2008. 

  2008.             str = "Emergency";
    2009. 

  2009.             break;
    2010. 

  2010.         }
    2011. 

  2011. 

  2012.         other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
    2013. 

  2013.         proto_tree_add_text(tree,
    2014. 

  2014.             tvb, curr_offset, 1,
    2015. 

  2015.             "%s :  Priority: %s",
    2016. 

  2016.             a_bigbuf,
    2017. 

  2017.             str);
    2018. 

  2018. 

  2019.         other_decode_bitfield_value(a_bigbuf, oct, 0x3f, 8);
    2020. 

  2020.         proto_tree_add_text(tree,
    2021. 

  2021.             tvb, curr_offset, 1,
    2022. 

  2022.             "%s :  Message ID: %u",
    2023. 

  2023.             a_bigbuf,
    2024. 

  2024.             oct & 0x3f);
    2025. 

  2025. 

  2026.         curr_offset++;
    2027. 

  2027. 

  2028.         oct = tvb_get_guint8(tvb, curr_offset);
    2029. 

  2029. 

  2030.         proto_tree_add_text(tree,
    2031. 

  2031.             tvb, curr_offset, 1,
    2032. 

  2032.             "Zone ID: %u",
    2033. 

  2033.             oct);
    2034. 

  2034. 

  2035.         g_snprintf(add_string, string_len, " - Broadcast (Zone ID: %u)", oct);
    2036. 

  2036. 

  2037.         curr_offset++;
    2038. 

  2038. 

  2039.         value = tvb_get_ntohs(tvb, curr_offset);
    2040. 

  2040. 

  2041.         switch (value)
    2042. 

  2042.         {
    2043. 

  2043.         case 0x0000: str = "Unknown or unspecified"; break;
    2044. 

  2044.         case 0x0001: str = "Emergency Broadcasts"; break;
    2045. 

  2045.         case 0x0002: str = "Administrative"; break;
    2046. 

  2046.         case 0x0003: str = "Maintenance"; break;
    2047. 

  2047.         case 0x0004: str = "General News - Local"; break;
    2048. 

  2048.         case 0x0005: str = "General News - Regional"; break;
    2049. 

  2049.         case 0x0006: str = "General News - National"; break;
    2050. 

  2050.         case 0x0007: str = "General News - International"; break;
    2051. 

  2051.         case 0x0008: str = "Business/Financial News - Local"; break;
    2052. 

  2052.         case 0x0009: str = "Business/Financial News - Regional"; break;
    2053. 

  2053.         case 0x000A: str = "Business/Financial News - National"; break;
    2054. 

  2054.         case 0x000B: str = "Business/Financial News - International"; break;
    2055. 

  2055.         case 0x000C: str = "Sports News - Local"; break;
    2056. 

  2056.         case 0x000D: str = "Sports News - Regional"; break;
    2057. 

  2057.         case 0x000E: str = "Sports News - National"; break;
    2058. 

  2058.         case 0x000F: str = "Sports News - International"; break;
    2059. 

  2059.         case 0x0010: str = "Entertainment News - Local"; break;
    2060. 

  2060.         case 0x0011: str = "Entertainment News - Regional"; break;
    2061. 

  2061.         case 0x0012: str = "Entertainment News - National"; break;
    2062. 

  2062.         case 0x0013: str = "Entertainment News - International"; break;
    2063. 

  2063.         case 0x0014: str = "Local Weather"; break;
    2064. 

  2064.         case 0x0015: str = "Area Traffic Reports"; break;
    2065. 

  2065.         case 0x0016: str = "Local Airport Flight Schedules"; break;
    2066. 

  2066.         case 0x0017: str = "Restaurants"; break;
    2067. 

  2067.         case 0x0018: str = "Lodgings"; break;
    2068. 

  2068.         case 0x0019: str = "Retail Directory"; break;
    2069. 

  2069.         case 0x001A: str = "Advertisements"; break;
    2070. 

  2070.         case 0x001B: str = "Stock Quotes"; break;
    2071. 

  2071.         case 0x001C: str = "Employment Opportunities"; break;
    2072. 

  2072.         case 0x001D: str = "Medical/Health/Hospitals"; break;
    2073. 

  2073.         case 0x001E: str = "Technology News"; break;
    2074. 

  2074.         case 0x001F: str = "Multi-category"; break;
    2075. 

  2075.         default:
    2076. 

  2076.             if ((value >= 0x0020) && (value <= 0x8000)) { str = "Reserved for standard service categories"; }
    2077. 

  2077.             else { str = "Reserved for proprietary service categories"; }
    2078. 

  2078.             break;
    2079. 

  2079.         }
    2080. 

  2080. 

  2081.         proto_tree_add_text(tree,
    2082. 

  2082.             tvb, curr_offset, 2,
    2083. 

  2083.             "Service: (%u) %s",
    2084. 

  2084.             value,
    2085. 

  2085.             str);
    2086. 

  2086. 

  2087.         curr_offset += 2;
    2088. 

  2088. 

  2089.         oct = tvb_get_guint8(tvb, curr_offset);
    2090. 

  2090. 

  2091.         switch (oct)
    2092. 

  2092.         {
    2093. 

  2093.         case 0: str = "Unknown or unspecified"; break;
    2094. 

  2094.         case 1: str = "English"; break;
    2095. 

  2095.         case 2: str = "French"; break;
    2096. 

  2096.         case 3: str = "Spanish"; break;
    2097. 

  2097.         case 4: str = "Japanese"; break;
    2098. 

  2098.         case 5: str = "Korean"; break;
    2099. 

  2099.         case 6: str = "Chinese"; break;
    2100. 

  2100.         case 7: str = "Hebrew"; break;
    2101. 

  2101.         default:
    2102. 

  2102.             str = "Reserved";
    2103. 

  2103.             break;
    2104. 

  2104.         }
    2105. 

  2105. 

  2106.         proto_tree_add_text(tree,
    2107. 

  2107.             tvb, curr_offset, 1,
    2108. 

  2108.             "Language: (%u) %s",
    2109. 

  2109.             oct,
    2110. 

  2110.             str);
    2111. 

  2111. 

  2112.         curr_offset++;
    2113. 

  2113.         break;
    2114. 

  2114. 

  2115.     case 0:
    2116. 

  2116.         other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    2117. 

  2117.         proto_tree_add_text(tree,
    2118. 

  2118.             tvb, curr_offset, 1,
    2119. 

  2119.             "%s :  Unused",
    2120. 

  2120.             a_bigbuf);
    2121. 

  2121. 

  2122.         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    2123. 

  2123.         proto_tree_add_text(tree,
    2124. 

  2124.             tvb, curr_offset, 1,
    2125. 

  2125.             "%s :  Odd/Even Indicator: %s",
    2126. 

  2126.             a_bigbuf,
    2127. 

  2127.             (oct & 0x08) ? "ODD" : "EVEN");
    2128. 

  2128. 

  2129.         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    2130. 

  2130.         proto_tree_add_text(tree,
    2131. 

  2131.             tvb, curr_offset, 1,
    2132. 

  2132.             "%s :  Type of Identity: No Identity Code",
    2133. 

  2133.             a_bigbuf);
    2134. 

  2134. 

  2135.         g_snprintf(add_string, string_len, " - No Identity Code");
    2136. 

  2136. 

  2137.         curr_offset++;
    2138. 

  2138. 

  2139.         if (len > 1)
    2140. 

  2140.         {
    2141. 

  2141.             proto_tree_add_text(tree, tvb, curr_offset, len - 1,
    2142. 

  2142.                 "Format not supported");
    2143. 

  2143.         }
    2144. 

  2144. 

  2145.         curr_offset += len - 1;
    2146. 

  2146.         break;
    2147. 

  2147. 

  2148.     case 6:
    2149. 

  2149.         other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    2150. 

  2150.         proto_tree_add_text(tree,
    2151. 

  2151.             tvb, curr_offset, 1,
    2152. 

  2152.             "%s :  Identity Digit 1: %c",
    2153. 

  2153.             a_bigbuf,
    2154. 

  2154.             Dgt_msid.out[(oct & 0xf0) >> 4]);
    2155. 

  2155. 

  2156.         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    2157. 

  2157.         proto_tree_add_text(tree,
    2158. 

  2158.             tvb, curr_offset, 1,
    2159. 

  2159.             "%s :  Odd/Even Indicator: %s",
    2160. 

  2160.             a_bigbuf,
    2161. 

  2161.             (oct & 0x08) ? "ODD" : "EVEN");
    2162. 

  2162. 

  2163.         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    2164. 

  2164.         proto_tree_add_text(tree,
    2165. 

  2165.             tvb, curr_offset, 1,
    2166. 

  2166.             "%s :  Type of Identity: %s",
    2167. 

  2167.             a_bigbuf,
    2168. 

  2168.             ((oct & 0x07) == 1) ? "MIN" : "IMSI");
    2169. 

  2169. 

  2170.         a_bigbuf[0] = Dgt_msid.out[(oct & 0xf0) >> 4];
    2171. 

  2171.         curr_offset++;
    2172. 

  2172. 

  2173.         poctets = tvb_get_ephemeral_string(tvb, curr_offset, len - (curr_offset - offset));
    2174. 

  2174. 

  2175.         my_dgt_tbcd_unpack(&a_bigbuf[1], poctets, len - (curr_offset - offset),
    2176. 

  2176.             &Dgt_msid);
    2177. 

  2177. 

  2178.         proto_tree_add_string_format(tree,
    2179. 

  2179.             ((oct & 0x07) == 1) ? hf_ansi_a_min : hf_ansi_a_imsi,
    2180. 

  2180.             tvb, curr_offset, len - (curr_offset - offset),
    2181. 

  2181.             a_bigbuf,
    2182. 

  2182.             "BCD Digits: %s",
    2183. 

  2183.             a_bigbuf);
    2184. 

  2184. 

  2185.         g_snprintf(add_string, string_len, " - %s (%s)",
    2186. 

  2186.             ((oct & 0x07) == 1) ? "MIN" : "IMSI",
    2187. 

  2187.             a_bigbuf);
    2188. 

  2188. 

  2189.         curr_offset += len - (curr_offset - offset);
    2190. 

  2190.         break;
    2191. 

  2191. 

  2192.     case 3:
    2193. 

  2193.         other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    2194. 

  2194.         proto_tree_add_text(tree,
    2195. 

  2195.             tvb, curr_offset, 1,
    2196. 

  2196.             "%s :  Unused",
    2197. 

  2197.             a_bigbuf);
    2198. 

  2198. 

  2199.         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    2200. 

  2200.         proto_tree_add_text(tree,
    2201. 

  2201.             tvb, curr_offset, 1,
    2202. 

  2202.             "%s :  Odd/Even Indicator: %s",
    2203. 

  2203.             a_bigbuf,
    2204. 

  2204.             (oct & 0x08) ? "ODD" : "EVEN");
    2205. 

  2205. 

  2206.         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    2207. 

  2207.         proto_tree_add_text(tree,
    2208. 

  2208.             tvb, curr_offset, 1,
    2209. 

  2209.             "%s :  Type of Identity: Interface Directory Number",
    2210. 

  2210.             a_bigbuf);
    2211. 

  2211. 

  2212.         g_snprintf(add_string, string_len, " - Interface Directory Number");
    2213. 

  2213. 

  2214.         curr_offset++;
    2215. 

  2215. 

  2216.         if (len > 1)
    2217. 

  2217.         {
    2218. 

  2218.             proto_tree_add_text(tree, tvb, curr_offset, len - 1,
    2219. 

  2219.                 "Format not supported");
    2220. 

  2220.         }
    2221. 

  2221. 

  2222.         curr_offset += len - 1;
    2223. 

  2223.         break;
    2224. 

  2224. 

  2225.     case 4:
    2226. 

  2226.         other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    2227. 

  2227.         proto_tree_add_text(tree,
    2228. 

  2228.             tvb, curr_offset, 1,
    2229. 

  2229.             "%s :  Unused",
    2230. 

  2230.             a_bigbuf);
    2231. 

  2231. 

  2232.         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    2233. 

  2233.         proto_tree_add_text(tree,
    2234. 

  2234.             tvb, curr_offset, 1,
    2235. 

  2235.             "%s :  Odd/Even Indicator: %s",
    2236. 

  2236.             a_bigbuf,
    2237. 

  2237.             (oct & 0x08) ? "ODD" : "EVEN");
    2238. 

  2238. 

  2239.         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    2240. 

  2240.         proto_tree_add_text(tree,
    2241. 

  2241.             tvb, curr_offset, 1,
    2242. 

  2242.             "%s :  Type of Identity: TMSI",
    2243. 

  2243.             a_bigbuf);
    2244. 

  2244. 

  2245.         g_snprintf(add_string, string_len, " - TMSI");
    2246. 

  2246. 

  2247.         curr_offset++;
    2248. 

  2248. 

  2249.         if (len > 1)
    2250. 

  2250.         {
    2251. 

  2251.             proto_tree_add_text(tree, tvb, curr_offset, len - 1,
    2252. 

  2252.                 "Format not supported");
    2253. 

  2253.         }
    2254. 

  2254. 

  2255.         curr_offset += len - 1;
    2256. 

  2256.         break;
    2257. 

  2257. 

  2258.     case 5:
    2259. 

  2259.         other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    2260. 

  2260.         proto_tree_add_text(tree,
    2261. 

  2261.             tvb, curr_offset, 1,
    2262. 

  2262.             "%s :  Unused",
    2263. 

  2263.             a_bigbuf);
    2264. 

  2264. 

  2265.         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    2266. 

  2266.         proto_tree_add_text(tree,
    2267. 

  2267.             tvb, curr_offset, 1,
    2268. 

  2268.             "%s :  Odd/Even Indicator: %s",
    2269. 

  2269.             a_bigbuf,
    2270. 

  2270.             (oct & 0x08) ? "ODD" : "EVEN");
    2271. 

  2271. 

  2272.         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    2273. 

  2273.         proto_tree_add_text(tree,
    2274. 

  2274.             tvb, curr_offset, 1,
    2275. 

  2275.             "%s :  Type of Identity: ESN",
    2276. 

  2276.             a_bigbuf);
    2277. 

  2277. 

  2278.         curr_offset++;
    2279. 

  2279. 

  2280.         value = tvb_get_ntohl(tvb, curr_offset);
    2281. 

  2281. 

  2282.         proto_tree_add_uint(tree, hf_ansi_a_esn,
    2283. 

  2283.             tvb, curr_offset, 4,
    2284. 

  2284.             value);
    2285. 

  2285. 

  2286.         g_snprintf(add_string, string_len, " - %sESN (0x%04x)",
    2287. 

  2287.             a_meid_configured ? "p" : "",
    2288. 

  2288.             value);
    2289. 

  2289. 

  2290.         curr_offset += 4;
    2291. 

  2291.         break;
    2292. 

  2292. 

  2293.     default:
    2294. 

  2294.         proto_tree_add_text(tree, tvb, curr_offset, len,
    2295. 

  2295.             "Format Unknown");
    2296. 

  2296. 

  2297.         g_snprintf(add_string, string_len, " - Format Unknown");
    2298. 

  2298. 

  2299.         curr_offset += len;
    2300. 

  2300.         break;
    2301. 

  2301.     }
    2302. 

  2302. 

  2303.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    2304. 

  2304. 

  2305.     return(curr_offset - offset);
    2306. 

  2306. }
    2307. 

  2307. 

  2308. /*
    2309. 

  2309.  * IOS 6.2.2.17
    2310. 

  2310.  */
    2311. 

  2311. static guint8
    2312. 

  2312. elem_sci(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    2313. 

  2313. {
    2314. 

  2314.     guint8      oct;
    2315. 

  2315.     guint32     curr_offset;
    2316. 

  2316. 

  2317.     curr_offset = offset;
    2318. 

  2318. 

  2319.     oct = tvb_get_guint8(tvb, curr_offset);
    2320. 

  2320. 

  2321.     other_decode_bitfield_value(a_bigbuf, oct, 0xf8, 8);
    2322. 

  2322.     proto_tree_add_text(tree,
    2323. 

  2323.         tvb, curr_offset, 1,
    2324. 

  2324.         "%s :  Reserved",
    2325. 

  2325.         a_bigbuf);
    2326. 

  2326. 

  2327.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    2328. 

  2328.     proto_tree_add_text(tree,
    2329. 

  2329.         tvb, curr_offset, 1,
    2330. 

  2330.         "%s :  Slot Cycle Index: %u",
    2331. 

  2331.         a_bigbuf,
    2332. 

  2332.         oct & 0x07);
    2333. 

  2333. 

  2334.     g_snprintf(add_string, string_len, " - (%u)", oct & 0x07);
    2335. 

  2335. 

  2336.     curr_offset++;
    2337. 

  2337. 

  2338.     /* no length check possible */
    2339. 

  2339. 

  2340.     return(curr_offset - offset);
    2341. 

  2341. }
    2342. 

  2342. 

  2343. /*
    2344. 

  2344.  * IOS 6.2.2.18
    2345. 

  2345.  */
    2346. 

  2346. static guint8
    2347. 

  2347. elem_prio(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    2348. 

  2348. {
    2349. 

  2349.     guint8      oct;
    2350. 

  2350.     guint32     curr_offset;
    2351. 

  2351. 

  2352.     curr_offset = offset;
    2353. 

  2353. 

  2354.     oct = tvb_get_guint8(tvb, curr_offset);
    2355. 

  2355. 

  2356.     other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
    2357. 

  2357.     proto_tree_add_text(tree,
    2358. 

  2358.         tvb, curr_offset, 1,
    2359. 

  2359.         "%s :  Reserved",
    2360. 

  2360.         a_bigbuf);
    2361. 

  2361. 

  2362.     other_decode_bitfield_value(a_bigbuf, oct, 0x3c, 8);
    2363. 

  2363.     proto_tree_add_text(tree,
    2364. 

  2364.         tvb, curr_offset, 1,
    2365. 

  2365.         "%s :  Call Priority Level: %u",
    2366. 

  2366.         a_bigbuf,
    2367. 

  2367.         (oct & 0x3c) >> 2);
    2368. 

  2368. 

  2369.     other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
    2370. 

  2370.     proto_tree_add_text(tree,
    2371. 

  2371.         tvb, curr_offset, 1,
    2372. 

  2372.         "%s :  Queuing %sallowed",
    2373. 

  2373.         a_bigbuf,
    2374. 

  2374.         (oct & 0x02) ? "" : "not ");
    2375. 

  2375. 

  2376.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    2377. 

  2377.     proto_tree_add_text(tree,
    2378. 

  2378.         tvb, curr_offset, 1,
    2379. 

  2379.         "%s :  Preemption %sallowed",
    2380. 

  2380.         a_bigbuf,
    2381. 

  2381.         (oct & 0x01) ? "" : "not ");
    2382. 

  2382. 

  2383.     g_snprintf(add_string, string_len, " - (%u)", (oct & 0x3c) >> 2);
    2384. 

  2384. 

  2385.     curr_offset++;
    2386. 

  2386. 

  2387.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    2388. 

  2388. 

  2389.     return(curr_offset - offset);
    2390. 

  2390. }
    2391. 

  2391. 

  2392. /*
    2393. 

  2393.  * IOS 5 4.2.79
    2394. 

  2394.  */
    2395. 

  2395. static guint8
    2396. 

  2396. elem_p_rev(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    2397. 

  2397. {
    2398. 

  2398.     guint8      oct;
    2399. 

  2399.     guint32     curr_offset;
    2400. 

  2400. 

  2401.     curr_offset = offset;
    2402. 

  2402. 

  2403.     oct = tvb_get_guint8(tvb, curr_offset);
    2404. 

  2404. 

  2405.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    2406. 

  2406.         "MOB_P_REV");
    2407. 

  2407. 

  2408.     g_snprintf(add_string, string_len, " - (%u)", oct);
    2409. 

  2409. 

  2410.     curr_offset++;
    2411. 

  2411. 

  2412.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    2413. 

  2413. 

  2414.     return(curr_offset - offset);
    2415. 

  2415. }
    2416. 

  2416. 

  2417. /*
    2418. 

  2418.  * IOS 6.2.2.19
    2419. 

  2419.  */
    2420. 

  2420. static guint8
    2421. 

  2421. elem_cause(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    2422. 

  2422. {
    2423. 

  2423.     guint8      oct;
    2424. 

  2424.     guint32     value;
    2425. 

  2425.     guint32     curr_offset;
    2426. 

  2426.     const gchar *str = NULL;
    2427. 

  2427. 

  2428.     curr_offset = offset;
    2429. 

  2429. 

  2430.     oct = tvb_get_guint8(tvb, curr_offset);
    2431. 

  2431. 

  2432.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    2433. 

  2433.     proto_tree_add_text(tree,
    2434. 

  2434.         tvb, curr_offset, 1,
    2435. 

  2435.         "%s :  Extension",
    2436. 

  2436.         a_bigbuf);
    2437. 

  2437. 

  2438.     if (oct & 0x80)
    2439. 

  2439.     {
    2440. 

  2440.         /* 2 octet cause */
    2441. 

  2441. 

  2442.         if ((oct & 0x0f) == 0x00)
    2443. 

  2443.         {
    2444. 

  2444.             /* national cause */
    2445. 

  2445.             switch ((oct & 0x70) >> 4)
    2446. 

  2446.             {
    2447. 

  2447.             case 0: str = "Normal Event"; break;
    2448. 

  2448.             case 1: str = "Normal Event"; break;
    2449. 

  2449.             case 2: str = "Resource Unavailable"; break;
    2450. 

  2450.             case 3: str = "Service or option not available"; break;
    2451. 

  2451.             case 4: str = "Service or option not implemented"; break;
    2452. 

  2452.             case 5: str = "Invalid message (e.g., parameter out of range)"; break;
    2453. 

  2453.             case 6: str = "Protocol error"; break;
    2454. 

  2454.             default:
    2455. 

  2455.                 str = "Interworking";
    2456. 

  2456.                 break;
    2457. 

  2457.             }
    2458. 

  2458. 

  2459.             other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
    2460. 

  2460.             proto_tree_add_text(tree,
    2461. 

  2461.                 tvb, curr_offset, 1,
    2462. 

  2462.                 "%s :  Cause Class: %s",
    2463. 

  2463.                 a_bigbuf,
    2464. 

  2464.                 str);
    2465. 

  2465. 

  2466.             other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    2467. 

  2467.             proto_tree_add_text(tree,
    2468. 

  2468.                 tvb, curr_offset, 1,
    2469. 

  2469.                 "%s :  National Cause",
    2470. 

  2470.                 a_bigbuf);
    2471. 

  2471. 

  2472.             curr_offset++;
    2473. 

  2473. 

  2474.             value = tvb_get_guint8(tvb, curr_offset);
    2475. 

  2475. 

  2476.             proto_tree_add_uint_format(tree, hf_ansi_a_cause_2, tvb,
    2477. 

  2477.                 curr_offset, 1,
    2478. 

  2478.                 ((oct & 0x7f) << 8) | value,
    2479. 

  2479.                 "Cause Value");
    2480. 

  2480. 

  2481.             curr_offset++;
    2482. 

  2482. 

  2483.             g_snprintf(add_string, string_len, " - (National Cause)");
    2484. 

  2484.         }
    2485. 

  2485.         else
    2486. 

  2486.         {
    2487. 

  2487.             value = tvb_get_guint8(tvb, curr_offset + 1);
    2488. 

  2488. 

  2489.             other_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8);
    2490. 

  2490. 

  2491.             proto_tree_add_uint_format(tree, hf_ansi_a_cause_2, tvb,
    2492. 

  2492.                 curr_offset, 1,
    2493. 

  2493.                 ((oct & 0x7f) << 8) | value,
    2494. 

  2494.                 "%s :  Cause (MSB): %u",
    2495. 

  2495.                 a_bigbuf,
    2496. 

  2496.                 ((oct & 0x7f) << 8) | value);
    2497. 

  2497. 

  2498.             curr_offset++;
    2499. 

  2499. 

  2500.             other_decode_bitfield_value(a_bigbuf, value, 0xff, 8);
    2501. 

  2501.             proto_tree_add_text(tree, tvb, curr_offset, 1,
    2502. 

  2502.                 "%s :  Cause (LSB)",
    2503. 

  2503.                 a_bigbuf);
    2504. 

  2504. 

  2505.             curr_offset++;
    2506. 

  2506.         }
    2507. 

  2507.     }
    2508. 

  2508.     else
    2509. 

  2509.     {
    2510. 

  2510.         switch (oct)
    2511. 

  2511.         {
    2512. 

  2512.         case 0x00: str = "Radio interface message failure"; break;
    2513. 

  2513.         case 0x01: str = "Radio interface failure"; break;
    2514. 

  2514.         case 0x02: str = "Uplink Quality"; break;
    2515. 

  2515.         case 0x03: str = "Uplink strength"; break;
    2516. 

  2516.         case 0x04: str = "Downlink quality"; break;
    2517. 

  2517.         case 0x05: str = "Downlink strength"; break;
    2518. 

  2518.         case 0x06: str = "Distance"; break;
    2519. 

  2519.         case 0x07: str = "OAM&P intervention"; break;
    2520. 

  2520.         case 0x08: str = "MS busy"; break;
    2521. 

  2521.         case 0x09: str = "Call processing"; break;
    2522. 

  2522.         case 0x0A: str = "Reversion to old channel"; break;
    2523. 

  2523.         case 0x0B: str = "Handoff successful"; break;
    2524. 

  2524.         case 0x0C: str = "No response from MS"; break;
    2525. 

  2525.         case 0x0D: str = "Timer expired"; break;
    2526. 

  2526.         case 0x0E: str = "Better cell (power budget)"; break;
    2527. 

  2527.         case 0x0F: str = "Interference"; break;
    2528. 

  2528.         case 0x10: str = "Packet call going dormant"; break;
    2529. 

  2529.         case 0x11: str = "Service option not available"; break;
    2530. 

  2530. 

  2531.         case 0x12: str = "Invalid Call"; break;
    2532. 

  2532.         case 0x13: str = "Successful operation"; break;
    2533. 

  2533.         case 0x14: str = "Normal call release"; break;
    2534. 

  2534. 

  2535.         /* IOS 5 */
    2536. 

  2536.         case 0x15: str = "Short data burst authentication failure"; break;
    2537. 

  2537.         case 0x17: str = "Time critical relocation/handoff"; break;
    2538. 

  2538.         case 0x18: str = "Network optimization"; break;
    2539. 

  2539.         case 0x19: str = "Power down from dormant state"; break;
    2540. 

  2540.         case 0x1A: str = "Authentication failure"; break;
    2541. 

  2541. 

  2542.         case 0x1B: str = "Inter-BS Soft Handoff Drop Target"; break;
    2543. 

  2543.         case 0x1D: str = "Intra-BS Soft Handoff Drop Target"; break;
    2544. 

  2544. 

  2545.         /* IOS 5 */
    2546. 

  2546.         case 0x1E: str = "Autonomous Registration by the Network"; break;
    2547. 

  2547. 

  2548.         case 0x20: str = "Equipment failure"; break;
    2549. 

  2549.         case 0x21: str = "No radio resource available"; break;
    2550. 

  2550.         case 0x22: str = "Requested terrestrial resource unavailable"; break;
    2551. 

  2551. 

  2552.         /* IOS 5 */
    2553. 

  2553.         case 0x23: str = "A2p RTP Payload Type not available"; break;
    2554. 

  2554.         case 0x24: str = "A2p Bearer Format Address Type not available"; break;
    2555. 

  2555. 

  2556.         case 0x25: str = "BS not equipped"; break;
    2557. 

  2557.         case 0x26: str = "MS not equipped (or incapable)"; break;
    2558. 

  2558. 

  2559.         /* IOS 5 */
    2560. 

  2560.         case 0x27: str = "2G only sector"; break;
    2561. 

  2561.         case 0x28: str = "3G only sector"; break;
    2562. 

  2562. 

  2563.         case 0x29: str = "PACA Call Queued"; break;
    2564. 

  2564. 

  2565.         /* IOS 5 */
    2566. 

  2566.         case 0x2A: str = "Handoff Blocked"; break;
    2567. 

  2567. 

  2568.         case 0x2B: str = "Alternate signaling type reject"; break;
    2569. 

  2569. 

  2570.         /* IOS 5 */
    2571. 

  2571.         case 0x2C: str = "A2p Resource not available"; break;
    2572. 

  2572. 

  2573.         case 0x2D: str = "PACA Queue Overflow"; break;
    2574. 

  2574.         case 0x2E: str = "PACA Cancel Request Rejected"; break;
    2575. 

  2575.         case 0x30: str = "Requested transcoding/rate adaptation unavailable"; break;
    2576. 

  2576.         case 0x31: str = "Lower priority radio resources not available"; break;
    2577. 

  2577.         case 0x32: str = "PCF resources not available"; break;  /* IOS 4 */
    2578. 

  2578.         case 0x33: str = "TFO Control request Failed"; break;
    2579. 

  2579. 

  2580.         /* IOS 5 */
    2581. 

  2581.         case 0x34: str = "MS rejected order"; break;
    2582. 

  2582. 

  2583.         case 0x40: str = "Ciphering algorithm not supported"; break;
    2584. 

  2584.         case 0x41: str = "Private Long Code not available or not supported."; break;
    2585. 

  2585.         case 0x42: str = "Requested MUX option or rates not available."; break;
    2586. 

  2586.         case 0x43: str = "Requested Privacy Configuration unavailable"; break;
    2587. 

  2587. 

  2588.         /* IOS 5 */
    2589. 

  2589.         case 0x45: str = "PDS-related capability not available or not supported"; break;
    2590. 

  2590. 

  2591.         case 0x50: str = "Terrestrial circuit already allocated"; break;
    2592. 

  2592.         case 0x60: str = "Protocol Error between BS and MSC"; break;
    2593. 

  2593.         case 0x71: str = "ADDS message too long for delivery on the paging channel"; break;
    2594. 

  2594.         case 0x72: str = "MS-to-IWF TCP connection failure"; break;
    2595. 

  2595.         case 0x73: str = "ATH0 (Modem hang up) Command"; break;
    2596. 

  2596.         case 0x74: str = "+FSH/+FHNG (Fax session ended) Command"; break;
    2597. 

  2597.         case 0x75: str = "No carrier"; break;
    2598. 

  2598.         case 0x76: str = "PPP protocol failure"; break;
    2599. 

  2599.         case 0x77: str = "PPP session closed by the MS"; break;
    2600. 

  2600.         case 0x78: str = "Do not notify MS"; break;
    2601. 

  2601.         case 0x79: str = "PCF (or PDSN) resources are not available"; break;
    2602. 

  2602.         case 0x7A: str = "Data ready to send"; break;
    2603. 

  2603. 

  2604.         /* IOS 5 */
    2605. 

  2605.         case 0x7B: str = "Concurrent authentication"; break;
    2606. 

  2606. 

  2607.         case 0x7F: str = "Handoff procedure time-out"; break;
    2608. 

  2608.         default:
    2609. 

  2609.             str = "Reserved for future use";
    2610. 

  2610.             break;
    2611. 

  2611.         }
    2612. 

  2612. 

  2613.         other_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8);
    2614. 

  2614.         proto_tree_add_uint_format(tree, hf_ansi_a_cause_1, tvb,
    2615. 

  2615.             curr_offset, 1, oct,
    2616. 

  2616.             "%s :  Cause: (%u) %s",
    2617. 

  2617.             a_bigbuf,
    2618. 

  2618.             oct & 0x7f,
    2619. 

  2619.             str);
    2620. 

  2620. 

  2621.         curr_offset++;
    2622. 

  2622. 

  2623.         g_snprintf(add_string, string_len, " - (%u) %s", oct & 0x7f, str);
    2624. 

  2624.     }
    2625. 

  2625. 

  2626.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    2627. 

  2627. 

  2628.     return(curr_offset - offset);
    2629. 

  2629. }
    2630. 

  2630. 

  2631. /*
    2632. 

  2632.  * IOS 6.2.2.20
    2633. 

  2633.  * Formats everything after the discriminator, shared function.
    2634. 

  2634.  */
    2635. 

  2635. static guint8
    2636. 

  2636. elem_cell_id_aux(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len, guint8 disc)
    2637. 

  2637. {
    2638. 

  2638.     guint32     value;
    2639. 

  2639.     guint32     market_id;
    2640. 

  2640.     guint32     switch_num;
    2641. 

  2641.     guint32     curr_offset;
    2642. 

  2642. 

  2643.     curr_offset = offset;
    2644. 

  2644. 

  2645.     switch (disc)
    2646. 

  2646.     {
    2647. 

  2647.     case 0x02:
    2648. 

  2648.         value = tvb_get_ntohs(tvb, curr_offset);
    2649. 

  2649. 

  2650.         proto_tree_add_uint(tree, hf_ansi_a_cell_ci, tvb,
    2651. 

  2651.             curr_offset, 2, value);
    2652. 

  2652. 

  2653.         curr_offset += 2;
    2654. 

  2654. 

  2655.         g_snprintf(add_string, string_len, " - CI (%u)", value);
    2656. 

  2656.         break;
    2657. 

  2657. 

  2658.     case 0x05:
    2659. 

  2659.         value = tvb_get_ntohs(tvb, curr_offset);
    2660. 

  2660. 

  2661.         proto_tree_add_uint(tree, hf_ansi_a_cell_lac, tvb,
    2662. 

  2662.             curr_offset, 2, value);
    2663. 

  2663. 

  2664.         curr_offset += 2;
    2665. 

  2665. 

  2666.         g_snprintf(add_string, string_len, " - LAC (%u)", value);
    2667. 

  2667.         break;
    2668. 

  2668. 

  2669.     case 0x07:
    2670. 

  2670.         market_id = tvb_get_ntohs(tvb, curr_offset);
    2671. 

  2671.         switch_num = tvb_get_guint8(tvb, curr_offset + 2);
    2672. 

  2672. 

  2673.         value = tvb_get_ntoh24(tvb, curr_offset);
    2674. 

  2674. 

  2675.         proto_tree_add_uint_format(tree, hf_ansi_a_cell_mscid, tvb,
    2676. 

  2676.             curr_offset, 3, value,
    2677. 

  2677.             "Market ID %u  Switch Number %u",
    2678. 

  2678.             market_id, switch_num);
    2679. 

  2679. 

  2680.         curr_offset += 3;
    2681. 

  2681. 

  2682.         value = tvb_get_ntohs(tvb, curr_offset);
    2683. 

  2683. 

  2684.         proto_tree_add_uint(tree, hf_ansi_a_cell_ci, tvb,
    2685. 

  2685.             curr_offset, 2, value);
    2686. 

  2686. 

  2687.         curr_offset += 2;
    2688. 

  2688. 

  2689.         g_snprintf(add_string, string_len, " - Market ID (%u) Switch Number (%u) CI (%u)",
    2690. 

  2690.             market_id,
    2691. 

  2691.             switch_num,
    2692. 

  2692.             value);
    2693. 

  2693.         break;
    2694. 

  2694. 

  2695.     default:
    2696. 

  2696.         proto_tree_add_text(tree, tvb, curr_offset, len,
    2697. 

  2697.             "Cell ID - Non IOS format");
    2698. 

  2698. 

  2699.         curr_offset += len;
    2700. 

  2700.         break;
    2701. 

  2701.     }
    2702. 

  2702. 

  2703.     return(curr_offset - offset);
    2704. 

  2704. }
    2705. 

  2705. 

  2706. static guint8
    2707. 

  2707. elem_cell_id(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    2708. 

  2708. {
    2709. 

  2709.     guint8      oct;
    2710. 

  2710.     guint32     curr_offset;
    2711. 

  2711.     const gchar *str = NULL;
    2712. 

  2712. 

  2713.     curr_offset = offset;
    2714. 

  2714. 

  2715.     oct = tvb_get_guint8(tvb, curr_offset);
    2716. 

  2716. 

  2717.     if (oct >= (gint) NUM_CELL_DISC_STR)
    2718. 

  2718.     {
    2719. 

  2719.         str = "Unknown";
    2720. 

  2720.     }
    2721. 

  2721.     else
    2722. 

  2722.     {
    2723. 

  2723.         str = cell_disc_str[oct];
    2724. 

  2724.     }
    2725. 

  2725. 

  2726.     proto_tree_add_text(tree,
    2727. 

  2727.         tvb, curr_offset, 1,
    2728. 

  2728.         "Cell Identification Discriminator: (%u) %s",
    2729. 

  2729.         oct,
    2730. 

  2730.         str);
    2731. 

  2731. 

  2732.     curr_offset++;
    2733. 

  2733. 

  2734.     curr_offset +=
    2735. 

  2735.         elem_cell_id_aux(tvb, tree, curr_offset, len - (curr_offset - offset), add_string, string_len, oct);
    2736. 

  2736. 

  2737.     /* no length check possible */
    2738. 

  2738. 

  2739.     return(curr_offset - offset);
    2740. 

  2740. }
    2741. 

  2741. 

  2742. /*
    2743. 

  2743.  * IOS 6.2.2.21
    2744. 

  2744.  */
    2745. 

  2745. static guint8
    2746. 

  2746. elem_cell_id_list(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    2747. 

  2747. {
    2748. 

  2748.     guint8      oct;
    2749. 

  2749.     guint16     consumed;
    2750. 

  2750.     guint8      num_cells;
    2751. 

  2751.     guint32     curr_offset;
    2752. 

  2752.     proto_item  *item = NULL;
    2753. 

  2753.     proto_tree  *subtree = NULL;
    2754. 

  2754.     const gchar *str = NULL;
    2755. 

  2755. 

  2756.     curr_offset = offset;
    2757. 

  2757. 

  2758.     oct = tvb_get_guint8(tvb, curr_offset);
    2759. 

  2759. 

  2760.     if (oct >= (gint) NUM_CELL_DISC_STR)
    2761. 

  2761.     {
    2762. 

  2762.         str = "Unknown";
    2763. 

  2763.     }
    2764. 

  2764.     else
    2765. 

  2765.     {
    2766. 

  2766.         str = cell_disc_str[oct];
    2767. 

  2767.     }
    2768. 

  2768. 

  2769.     proto_tree_add_text(tree,
    2770. 

  2770.         tvb, curr_offset, 1,
    2771. 

  2771.         "Cell Identification Discriminator: (%u) %s",
    2772. 

  2772.         oct,
    2773. 

  2773.         str);
    2774. 

  2774. 

  2775.     curr_offset++;
    2776. 

  2776. 

  2777.     NO_MORE_DATA_CHECK(len);
    2778. 

  2778. 

  2779.     num_cells = 0;
    2780. 

  2780.     do
    2781. 

  2781.     {
    2782. 

  2782.         item =
    2783. 

  2783.             proto_tree_add_text(tree,
    2784. 

  2784.                 tvb, curr_offset, -1,
    2785. 

  2785.                 "Cell [%u]",
    2786. 

  2786.                 num_cells + 1);
    2787. 

  2787. 

  2788.         subtree = proto_item_add_subtree(item, ett_cell_list);
    2789. 

  2789. 

  2790.         add_string[0] = '\0';
    2791. 

  2791.         consumed =
    2792. 

  2792.             elem_cell_id_aux(tvb, subtree, curr_offset, len - (curr_offset - offset), add_string, string_len, oct);
    2793. 

  2793. 

  2794.         if (add_string[0] != '\0')
    2795. 

  2795.         {
    2796. 

  2796.             proto_item_append_text(item, "%s", add_string);
    2797. 

  2797.         }
    2798. 

  2798. 

  2799.         proto_item_set_len(item, consumed);
    2800. 

  2800. 

  2801.         curr_offset += consumed;
    2802. 

  2802. 

  2803.         num_cells++;
    2804. 

  2804.     }
    2805. 

  2805.     while ((len - (curr_offset - offset)) > 0);
    2806. 

  2806. 

  2807.     g_snprintf(add_string, string_len, " - %u cell%s",
    2808. 

  2808.         num_cells, plurality(num_cells, "", "s"));
    2809. 

  2809. 

  2810.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    2811. 

  2811. 

  2812.     return(curr_offset - offset);
    2813. 

  2813. }
    2814. 

  2814. 

  2815. /*
    2816. 

  2816.  * IOS 6.2.2.22
    2817. 

  2817.  */
    2818. 

  2818. static guint8
    2819. 

  2819. elem_cic(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    2820. 

  2820. {
    2821. 

  2821.     guint32     value;
    2822. 

  2822.     guint32     curr_offset;
    2823. 

  2823. 

  2824.     curr_offset = offset;
    2825. 

  2825. 

  2826.     value = tvb_get_ntohs(tvb, curr_offset);
    2827. 

  2827. 

  2828.     other_decode_bitfield_value(a_bigbuf, value, 0xffe0, 16);
    2829. 

  2829.     proto_tree_add_text(tree,
    2830. 

  2830.         tvb, curr_offset, 2,
    2831. 

  2831.         "%s :  PCM Multiplexer: %u",
    2832. 

  2832.         a_bigbuf,
    2833. 

  2833.         (value & 0xffe0) >> 5);
    2834. 

  2834. 

  2835.     other_decode_bitfield_value(a_bigbuf, value, 0x001f, 16);
    2836. 

  2836.     proto_tree_add_text(tree,
    2837. 

  2837.         tvb, curr_offset, 2,
    2838. 

  2838.         "%s :  Timeslot: %u",
    2839. 

  2839.         a_bigbuf,
    2840. 

  2840.         value & 0x001f);
    2841. 

  2841. 

  2842.     curr_offset += 2;
    2843. 

  2843. 

  2844.     g_snprintf(add_string, string_len, " - (%u) (0x%04x)", value, value);
    2845. 

  2845. 

  2846.     /* no length check possible */
    2847. 

  2847. 

  2848.     return(curr_offset - offset);
    2849. 

  2849. }
    2850. 

  2850. 

  2851. /*
    2852. 

  2852.  * IOS 6.2.2.23
    2853. 

  2853.  */
    2854. 

  2854. static guint8
    2855. 

  2855. elem_cic_ext(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    2856. 

  2856. {
    2857. 

  2857.     guint8      oct;
    2858. 

  2858.     guint32     value;
    2859. 

  2859.     guint32     curr_offset;
    2860. 

  2860.     const gchar *str;
    2861. 

  2861. 

  2862.     curr_offset = offset;
    2863. 

  2863. 

  2864.     value = tvb_get_ntohs(tvb, curr_offset);
    2865. 

  2865. 

  2866.     other_decode_bitfield_value(a_bigbuf, value, 0xffe0, 16);
    2867. 

  2867.     proto_tree_add_text(tree,
    2868. 

  2868.         tvb, curr_offset, 2,
    2869. 

  2869.         "%s :  PCM Multiplexer: %u",
    2870. 

  2870.         a_bigbuf,
    2871. 

  2871.         (value & 0xffe0) >> 5);
    2872. 

  2872. 

  2873.     other_decode_bitfield_value(a_bigbuf, value, 0x001f, 16);
    2874. 

  2874.     proto_tree_add_text(tree,
    2875. 

  2875.         tvb, curr_offset, 2,
    2876. 

  2876.         "%s :  Timeslot: %u",
    2877. 

  2877.         a_bigbuf,
    2878. 

  2878.         value & 0x001f);
    2879. 

  2879. 

  2880.     curr_offset += 2;
    2881. 

  2881. 

  2882.     g_snprintf(add_string, string_len, " - (%u) (0x%04x)", value, value);
    2883. 

  2883. 

  2884.     oct = tvb_get_guint8(tvb, curr_offset);
    2885. 

  2885. 

  2886.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    2887. 

  2887.     proto_tree_add_text(tree,
    2888. 

  2888.         tvb, curr_offset, 1,
    2889. 

  2889.         "%s :  Reserved",
    2890. 

  2890.         a_bigbuf);
    2891. 

  2891. 

  2892.     switch (oct & 0x0f)
    2893. 

  2893.     {
    2894. 

  2894.     case 0x00: str = "Full-rate"; break;
    2895. 

  2895.     default:
    2896. 

  2896.         str = "Reserved";
    2897. 

  2897.         break;
    2898. 

  2898.     }
    2899. 

  2899. 

  2900.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    2901. 

  2901.     proto_tree_add_text(tree,
    2902. 

  2902.         tvb, curr_offset, 1,
    2903. 

  2903.         "%s :  Circuit Mode: %s",
    2904. 

  2904.         a_bigbuf,
    2905. 

  2905.         str);
    2906. 

  2906. 

  2907.     curr_offset++;
    2908. 

  2908. 

  2909.     /* no length check possible */
    2910. 

  2910. 

  2911.     return(curr_offset - offset);
    2912. 

  2912. }
    2913. 

  2913. 

  2914. /*
    2915. 

  2915.  * IOS 5 4.2.21
    2916. 

  2916.  */
    2917. 

  2917. static guint8
    2918. 

  2918. elem_ssci(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    2919. 

  2919. {
    2920. 

  2920.     guint8      oct;
    2921. 

  2921.     guint32     curr_offset;
    2922. 

  2922. 

  2923.     curr_offset = offset;
    2924. 

  2924. 

  2925.     oct = tvb_get_guint8(tvb, curr_offset);
    2926. 

  2926. 

  2927.     other_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8);
    2928. 

  2928.     proto_tree_add_text(tree,
    2929. 

  2929.         tvb, curr_offset, 1,
    2930. 

  2930.         "%s :  Reserved",
    2931. 

  2931.         a_bigbuf);
    2932. 

  2932. 

  2933.     other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
    2934. 

  2934.     proto_tree_add_text(tree,
    2935. 

  2935.         tvb, curr_offset, 1,
    2936. 

  2936.         "%s :  Mobile Originated Position Determination",
    2937. 

  2937.         a_bigbuf);
    2938. 

  2938. 

  2939.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    2940. 

  2940.     proto_tree_add_text(tree,
    2941. 

  2941.         tvb, curr_offset, 1,
    2942. 

  2942.         "%s :  Global Emergency Call Indication",
    2943. 

  2943.         a_bigbuf);
    2944. 

  2944. 

  2945.     curr_offset++;
    2946. 

  2946. 

  2947.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    2948. 

  2948. 

  2949.     return(curr_offset - offset);
    2950. 

  2950. }
    2951. 

  2951. 

  2952. /*
    2953. 

  2953.  * IOS 6.2.2.24
    2954. 

  2954.  * UNUSED
    2955. 

  2955.  */
    2956. 

  2956. 

  2957. #define ANSI_A_CELL_ID_LEN(_disc) ((_disc == 7) ? 5 : 2)
    2958. 

  2958. 

  2959. /*
    2960. 

  2960.  * IOS 6.2.2.25
    2961. 

  2961.  * Formats everything no length check
    2962. 

  2962.  */
    2963. 

  2963. static guint8
    2964. 

  2964. elem_downlink_re_aux(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    2965. 

  2965. {
    2966. 

  2966.     guint8      oct;
    2967. 

  2967.     guint8      disc;
    2968. 

  2968.     guint16     consumed;
    2969. 

  2969.     guint8      num_cells;
    2970. 

  2970.     guint8      curr_cell;
    2971. 

  2971.     guint32     value;
    2972. 

  2972.     guint32     curr_offset;
    2973. 

  2973.     proto_item  *item = NULL;
    2974. 

  2974.     proto_tree  *subtree = NULL;
    2975. 

  2975.     const gchar *str;
    2976. 

  2976. 

  2977.     curr_offset = offset;
    2978. 

  2978. 

  2979.     num_cells = tvb_get_guint8(tvb, curr_offset);
    2980. 

  2980. 

  2981.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    2982. 

  2982.         "Number of Cells: %u",
    2983. 

  2983.         num_cells);
    2984. 

  2984. 

  2985.     curr_offset++;
    2986. 

  2986. 

  2987.     NO_MORE_DATA_CHECK(len);
    2988. 

  2988. 

  2989.     disc = tvb_get_guint8(tvb, curr_offset);
    2990. 

  2990. 

  2991.     if (disc >= (gint) NUM_CELL_DISC_STR)
    2992. 

  2992.     {
    2993. 

  2993.         str = "Unknown";
    2994. 

  2994.     }
    2995. 

  2995.     else
    2996. 

  2996.     {
    2997. 

  2997.         str = cell_disc_str[disc];
    2998. 

  2998.     }
    2999. 

  2999. 

  3000.     proto_tree_add_text(tree,
    3001. 

  3001.         tvb, curr_offset, 1,
    3002. 

  3002.         "Cell Identification Discriminator: (%u) %s",
    3003. 

  3003.         disc,
    3004. 

  3004.         str);
    3005. 

  3005. 

  3006.     curr_offset++;
    3007. 

  3007. 

  3008.     NO_MORE_DATA_CHECK(len);
    3009. 

  3009. 

  3010.     SHORT_DATA_CHECK(len - (curr_offset - offset), (guint32) 3 + ANSI_A_CELL_ID_LEN(disc));
    3011. 

  3011. 

  3012.     curr_cell = 0;
    3013. 

  3013. 

  3014.     do
    3015. 

  3015.     {
    3016. 

  3016.         curr_cell++;
    3017. 

  3017. 

  3018.         item =
    3019. 

  3019.             proto_tree_add_text(tree,
    3020. 

  3020.                 tvb, curr_offset, -1,
    3021. 

  3021.                 "Cell [%u]",
    3022. 

  3022.                 curr_cell);
    3023. 

  3023. 

  3024.         subtree = proto_item_add_subtree(item, ett_cell_list);
    3025. 

  3025. 

  3026.         add_string[0] = '\0';
    3027. 

  3027.         consumed =
    3028. 

  3028.             elem_cell_id_aux(tvb, subtree, curr_offset,
    3029. 

  3029.                 len - (curr_offset - offset), add_string, string_len, disc);
    3030. 

  3030. 

  3031.         if (add_string[0] != '\0')
    3032. 

  3032.         {
    3033. 

  3033.             proto_item_append_text(item, "%s", add_string);
    3034. 

  3034.         }
    3035. 

  3035. 

  3036.         proto_item_set_len(item, consumed);
    3037. 

  3037. 

  3038.         curr_offset += consumed;
    3039. 

  3039. 

  3040.         oct = tvb_get_guint8(tvb, curr_offset);
    3041. 

  3041. 

  3042.         other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
    3043. 

  3043.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3044. 

  3044.             "%s :  Reserved",
    3045. 

  3045.             a_bigbuf);
    3046. 

  3046. 

  3047.         other_decode_bitfield_value(a_bigbuf, oct, 0x3f, 8);
    3048. 

  3048.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3049. 

  3049.             "%s :  Downlink Signal Strength Raw: %u",
    3050. 

  3050.             a_bigbuf,
    3051. 

  3051.             oct & 0x3f);
    3052. 

  3052. 

  3053.         curr_offset++;
    3054. 

  3054. 

  3055.         value = tvb_get_ntohs(tvb, curr_offset);
    3056. 

  3056. 

  3057.         proto_tree_add_text(tree,
    3058. 

  3058.             tvb, curr_offset, 2,
    3059. 

  3059.             "CDMA Target One Way Delay: %u",
    3060. 

  3060.             value);
    3061. 

  3061. 

  3062.         curr_offset += 2;
    3063. 

  3063.     }
    3064. 

  3064.     while (curr_cell < num_cells);
    3065. 

  3065. 

  3066.     g_snprintf(add_string, string_len, " - %u cell%s",
    3067. 

  3067.         num_cells, plurality(num_cells, "", "s"));
    3068. 

  3068. 

  3069.     return(curr_offset - offset);
    3070. 

  3070. }
    3071. 

  3071. 

  3072. /*
    3073. 

  3073.  * IOS 6.2.2.25
    3074. 

  3074.  */
    3075. 

  3075. static guint8
    3076. 

  3076. elem_downlink_re(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    3077. 

  3077. {
    3078. 

  3078.     guint32     curr_offset;
    3079. 

  3079. 

  3080.     curr_offset = offset;
    3081. 

  3081. 

  3082.     curr_offset +=
    3083. 

  3083.         elem_downlink_re_aux(tvb, tree, offset, len, add_string, string_len);
    3084. 

  3084. 

  3085.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3086. 

  3086. 

  3087.     return(curr_offset - offset);
    3088. 

  3088. }
    3089. 

  3089. 

  3090. /*
    3091. 

  3091.  * IOS 6.2.2.140
    3092. 

  3092.  */
    3093. 

  3093. static guint8
    3094. 

  3094. elem_downlink_re_list(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    3095. 

  3095. {
    3096. 

  3096.     guint16     consumed;
    3097. 

  3097.     guint8      num_envs;
    3098. 

  3098.     guint8      oct_len;
    3099. 

  3099.     guint32     curr_offset;
    3100. 

  3100.     proto_item  *item = NULL;
    3101. 

  3101.     proto_tree  *subtree = NULL;
    3102. 

  3102. 

  3103.     curr_offset = offset;
    3104. 

  3104. 

  3105.     num_envs = 0;
    3106. 

  3106. 

  3107.     while ((len - (curr_offset - offset)) > 0)
    3108. 

  3108.     {
    3109. 

  3109.         num_envs++;
    3110. 

  3110. 

  3111.         item =
    3112. 

  3112.             proto_tree_add_text(tree,
    3113. 

  3113.                 tvb, curr_offset, -1,
    3114. 

  3114.                 "Environment [%u]",
    3115. 

  3115.                 num_envs);
    3116. 

  3116. 

  3117.         subtree = proto_item_add_subtree(item, ett_re_list);
    3118. 

  3118. 

  3119.         oct_len = tvb_get_guint8(tvb, curr_offset);
    3120. 

  3120. 

  3121.         proto_tree_add_text(subtree,
    3122. 

  3122.             tvb, curr_offset, 1,
    3123. 

  3123.             "Environment Length: %u",
    3124. 

  3124.             oct_len);
    3125. 

  3125. 

  3126.         curr_offset++;
    3127. 

  3127. 

  3128.         add_string[0] = '\0';
    3129. 

  3129.         consumed =
    3130. 

  3130.             elem_downlink_re_aux(tvb, subtree, curr_offset, len - (curr_offset - offset), add_string, string_len);
    3131. 

  3131. 

  3132.         if (add_string[0] != '\0')
    3133. 

  3133.         {
    3134. 

  3134.             proto_item_append_text(item, "%s", add_string);
    3135. 

  3135.         }
    3136. 

  3136. 

  3137.         /*
    3138. 

  3138.          * +1 is for environment length
    3139. 

  3139.          */
    3140. 

  3140.         proto_item_set_len(item, consumed + 1);
    3141. 

  3141. 

  3142.         curr_offset += consumed;
    3143. 

  3143.     }
    3144. 

  3144. 

  3145.     g_snprintf(add_string, string_len, " - %u environment%s",
    3146. 

  3146.         num_envs, plurality(num_envs, "", "s"));
    3147. 

  3147. 

  3148.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3149. 

  3149. 

  3150.     return(curr_offset - offset);
    3151. 

  3151. }
    3152. 

  3152. 

  3153. /*
    3154. 

  3154.  * IOS 6.2.2.26
    3155. 

  3155.  * UNUSED
    3156. 

  3156.  */
    3157. 

  3157. 

  3158. /*
    3159. 

  3159.  * IOS 6.2.2.27
    3160. 

  3160.  * UNUSED
    3161. 

  3161.  */
    3162. 

  3162. 

  3163. /*
    3164. 

  3164.  * IOS 6.2.2.28
    3165. 

  3165.  * UNUSED
    3166. 

  3166.  */
    3167. 

  3167. 

  3168. /*
    3169. 

  3169.  * IOS 6.2.2.29
    3170. 

  3170.  * UNUSED
    3171. 

  3171.  */
    3172. 

  3172. 

  3173. /*
    3174. 

  3174.  * IOS 6.2.2.30
    3175. 

  3175.  */
    3176. 

  3176. static guint8
    3177. 

  3177. elem_pdsn_ip_addr(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    3178. 

  3178. {
    3179. 

  3179.     guint32     curr_offset;
    3180. 

  3180. 

  3181.     curr_offset = offset;
    3182. 

  3182. 

  3183.     proto_tree_add_item(tree, hf_ansi_a_pdsn_ip_addr, tvb, curr_offset, len, ENC_BIG_ENDIAN);
    3184. 

  3184. 

  3185.     curr_offset += len;
    3186. 

  3186. 

  3187.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3188. 

  3188. 

  3189.     return(curr_offset - offset);
    3190. 

  3190. }
    3191. 

  3191. 

  3192. /*
    3193. 

  3193.  * IOS 5 4.2.24
    3194. 

  3194.  */
    3195. 

  3195. static guint8
    3196. 

  3196. elem_s_pdsn_ip_addr(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    3197. 

  3197. {
    3198. 

  3198.     guint32     curr_offset;
    3199. 

  3199. 

  3200.     curr_offset = offset;
    3201. 

  3201. 

  3202.     proto_tree_add_item(tree, hf_ansi_a_s_pdsn_ip_addr, tvb, curr_offset, len, ENC_BIG_ENDIAN);
    3203. 

  3203. 

  3204.     curr_offset += len;
    3205. 

  3205. 

  3206.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3207. 

  3207. 

  3208.     return(curr_offset - offset);
    3209. 

  3209. }
    3210. 

  3210. 

  3211. /*
    3212. 

  3212.  * IOS 6.2.2.31
    3213. 

  3213.  */
    3214. 

  3214. static guint8
    3215. 

  3215. elem_ho_pow_lev(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    3216. 

  3216. {
    3217. 

  3217.     guint8      oct;
    3218. 

  3218.     guint16     consumed;
    3219. 

  3219.     guint8      num_cells;
    3220. 

  3220.     proto_item  *item = NULL;
    3221. 

  3221.     proto_tree  *subtree = NULL;
    3222. 

  3222.     guint32     curr_offset;
    3223. 

  3223. 

  3224.     curr_offset = offset;
    3225. 

  3225. 

  3226.     oct = tvb_get_guint8(tvb, curr_offset);
    3227. 

  3227. 

  3228.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    3229. 

  3229.         "Number of Cells: %u",
    3230. 

  3230.         oct);
    3231. 

  3231. 

  3232.     curr_offset++;
    3233. 

  3233. 

  3234.     SHORT_DATA_CHECK(len - (curr_offset - offset), (guint32) 6);
    3235. 

  3235. 

  3236.     oct = tvb_get_guint8(tvb, curr_offset);
    3237. 

  3237. 

  3238.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    3239. 

  3239.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    3240. 

  3240.         "%s :  Reserved",
    3241. 

  3241.         a_bigbuf);
    3242. 

  3242. 

  3243.     other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
    3244. 

  3244.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    3245. 

  3245.         "%s :  ID Type: %u",
    3246. 

  3246.         a_bigbuf,
    3247. 

  3247.         (oct & 0x60) >> 5);
    3248. 

  3248. 

  3249.     other_decode_bitfield_value(a_bigbuf, oct, 0x1f, 8);
    3250. 

  3250.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    3251. 

  3251.         "%s :  Handoff Power Level: %u",
    3252. 

  3252.         a_bigbuf,
    3253. 

  3253.         oct & 0x1f);
    3254. 

  3254. 

  3255.     curr_offset++;
    3256. 

  3256. 

  3257.     item =
    3258. 

  3258.         proto_tree_add_text(tree,
    3259. 

  3259.             tvb, curr_offset, -1,
    3260. 

  3260.             "Cell [1]");
    3261. 

  3261. 

  3262.     subtree = proto_item_add_subtree(item, ett_cell_list);
    3263. 

  3263. 

  3264.     add_string[0] = '\0';
    3265. 

  3265.     consumed =
    3266. 

  3266.         elem_cell_id_aux(tvb, subtree, curr_offset,
    3267. 

  3267.             len - (curr_offset - offset), add_string, string_len, 0x7);
    3268. 

  3268. 

  3269.     if (add_string[0] != '\0')
    3270. 

  3270.     {
    3271. 

  3271.         proto_item_append_text(item, "%s", add_string);
    3272. 

  3272.     }
    3273. 

  3273. 

  3274.     proto_item_set_len(item, consumed);
    3275. 

  3275. 

  3276.     curr_offset += consumed;
    3277. 

  3277. 

  3278.     num_cells = 1;
    3279. 

  3279. 

  3280.     while ((len - (curr_offset - offset)) >= 3)
    3281. 

  3281.     {
    3282. 

  3282.         num_cells++;
    3283. 

  3283. 

  3284.         oct = tvb_get_guint8(tvb, curr_offset);
    3285. 

  3285. 

  3286.         other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    3287. 

  3287.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3288. 

  3288.             "%s :  Reserved",
    3289. 

  3289.             a_bigbuf);
    3290. 

  3290. 

  3291.         other_decode_bitfield_value(a_bigbuf, oct, 0x1f, 8);
    3292. 

  3292.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3293. 

  3293.             "%s :  Handoff Power Level: %u",
    3294. 

  3294.             a_bigbuf,
    3295. 

  3295.             oct & 0x1f);
    3296. 

  3296. 

  3297.         curr_offset++;
    3298. 

  3298. 

  3299.         item =
    3300. 

  3300.             proto_tree_add_text(tree,
    3301. 

  3301.                 tvb, curr_offset, -1,
    3302. 

  3302.                 "Cell [%u]",
    3303. 

  3303.                 num_cells);
    3304. 

  3304. 

  3305.         subtree = proto_item_add_subtree(item, ett_cell_list);
    3306. 

  3306. 

  3307.         add_string[0] = '\0';
    3308. 

  3308.         consumed =
    3309. 

  3309.             elem_cell_id_aux(tvb, subtree, curr_offset,
    3310. 

  3310.                 len - (curr_offset - offset), add_string, string_len, 0x2);
    3311. 

  3311. 

  3312.         if (add_string[0] != '\0')
    3313. 

  3313.         {
    3314. 

  3314.             proto_item_append_text(item, "%s", add_string);
    3315. 

  3315.         }
    3316. 

  3316. 

  3317.         proto_item_set_len(item, consumed);
    3318. 

  3318. 

  3319.         curr_offset += consumed;
    3320. 

  3320.     }
    3321. 

  3321. 

  3322.     g_snprintf(add_string, string_len, " - %u cell%s",
    3323. 

  3323.         num_cells, plurality(num_cells, "", "s"));
    3324. 

  3324. 

  3325.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3326. 

  3326. 

  3327.     return(curr_offset - offset);
    3328. 

  3328. }
    3329. 

  3329. 

  3330. /*
    3331. 

  3331.  * IOS 6.2.2.32
    3332. 

  3332.  */
    3333. 

  3333. static guint8
    3334. 

  3334. elem_uz_id(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    3335. 

  3335. {
    3336. 

  3336.     guint32     value;
    3337. 

  3337.     guint32     curr_offset;
    3338. 

  3338. 

  3339.     curr_offset = offset;
    3340. 

  3340. 

  3341.     value = tvb_get_ntohs(tvb, curr_offset);
    3342. 

  3342. 

  3343.     proto_tree_add_text(tree, tvb, curr_offset, 2,
    3344. 

  3344.         "UZID: %u",
    3345. 

  3345.         value);
    3346. 

  3346. 

  3347.     curr_offset += 2;
    3348. 

  3348. 

  3349.     g_snprintf(add_string, string_len, " - (%u)", value);
    3350. 

  3350. 

  3351.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3352. 

  3352. 

  3353.     return(curr_offset - offset);
    3354. 

  3354. }
    3355. 

  3355. 

  3356. /*
    3357. 

  3357.  * IOS 6.2.2.33
    3358. 

  3358.  * UNUSED
    3359. 

  3359.  */
    3360. 

  3360. 

  3361. /*
    3362. 

  3362.  * IOS 5 4.2.77
    3363. 

  3363.  */
    3364. 

  3364. static guint8
    3365. 

  3365. elem_info_rec_req(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    3366. 

  3366. {
    3367. 

  3367.     guint8      rec_type;
    3368. 

  3368.     guint8      num_recs;
    3369. 

  3369.     guint32     curr_offset;
    3370. 

  3370.     const gchar *str;
    3371. 

  3371.     gint        idx;
    3372. 

  3372. 

  3373.     curr_offset = offset;
    3374. 

  3374. 

  3375.     num_recs = 0;
    3376. 

  3376. 

  3377.     while ((len - (curr_offset - offset)) > 0)
    3378. 

  3378.     {
    3379. 

  3379.         num_recs++;
    3380. 

  3380. 

  3381.         rec_type = tvb_get_guint8(tvb, curr_offset);
    3382. 

  3382. 

  3383.         str = try_val_to_str_idx((guint32) rec_type, ansi_rev_ms_info_rec_str, &idx);
    3384. 

  3384. 

  3385.         if (str == NULL)
    3386. 

  3386.         {
    3387. 

  3387.             str = "Reserved";
    3388. 

  3388.         }
    3389. 

  3389. 

  3390.         proto_tree_add_text(tree,
    3391. 

  3391.             tvb, curr_offset, 1,
    3392. 

  3392.             "Information Record Type - %u: (%u) %s",
    3393. 

  3393.             num_recs,
    3394. 

  3394.             rec_type,
    3395. 

  3395.             str);
    3396. 

  3396. 

  3397.         curr_offset++;
    3398. 

  3398.     }
    3399. 

  3399. 

  3400.     g_snprintf(add_string, string_len, " - %u request%s",
    3401. 

  3401.         num_recs, plurality(num_recs, "", "s"));
    3402. 

  3402. 

  3403.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3404. 

  3404. 

  3405.     return(curr_offset - offset);
    3406. 

  3406. }
    3407. 

  3407. 

  3408. /*
    3409. 

  3409.  * IOS 6.2.2.34
    3410. 

  3410.  */
    3411. 

  3411. static guint8
    3412. 

  3412. elem_is2000_chan_id(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    3413. 

  3413. {
    3414. 

  3414.     guint8      oct;
    3415. 

  3415.     guint8      num_chan;
    3416. 

  3416.     guint32     value;
    3417. 

  3417.     guint32     curr_offset;
    3418. 

  3418.     const gchar *str;
    3419. 

  3419. 

  3420.     curr_offset = offset;
    3421. 

  3421. 

  3422.     oct = tvb_get_guint8(tvb, curr_offset);
    3423. 

  3423. 

  3424.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    3425. 

  3425.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    3426. 

  3426.         "%s :  OTD: Mobile will %sbe using OTD",
    3427. 

  3427.         a_bigbuf,
    3428. 

  3428.         (oct & 0x80) ? "" : "not ");
    3429. 

  3429. 

  3430.     num_chan = (oct & 0x70) >> 4;
    3431. 

  3431. 

  3432.     other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
    3433. 

  3433.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    3434. 

  3434.         "%s :  Channel Count: %u",
    3435. 

  3435.         a_bigbuf,
    3436. 

  3436.         num_chan);
    3437. 

  3437. 

  3438.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    3439. 

  3439.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    3440. 

  3440.         "%s :  Frame Offset: (%u), %.2f ms",
    3441. 

  3441.         a_bigbuf,
    3442. 

  3442.         oct & 0x0f,
    3443. 

  3443.         (oct & 0x0f) * 1.25);
    3444. 

  3444. 

  3445.     curr_offset++;
    3446. 

  3446. 

  3447.     NO_MORE_DATA_CHECK(len);
    3448. 

  3448. 

  3449.     SHORT_DATA_CHECK(len - (curr_offset - offset), 6);
    3450. 

  3450. 

  3451.     do
    3452. 

  3452.     {
    3453. 

  3453.         oct = tvb_get_guint8(tvb, curr_offset);
    3454. 

  3454. 

  3455.         switch (oct)
    3456. 

  3456.         {
    3457. 

  3457.         case 0x01: str = "Fundamental Channel (FCH) TIA/EIA/IS-2000"; break;
    3458. 

  3458.         case 0x02: str = "Dedicated Control Channel (DCCH) TIA/EIA/IS-2000"; break;
    3459. 

  3459.         case 0x03: str = "Supplemental Channel (SCH) TIA/EIA/IS-2000"; break;
    3460. 

  3460.         default:
    3461. 

  3461.             if ((oct >= 0x80) && (oct <= 0x9f)) { str = "Reserved for UMTS"; }
    3462. 

  3462.             else { str = "Reserved"; }
    3463. 

  3463.             break;
    3464. 

  3464.         }
    3465. 

  3465. 

  3466.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3467. 

  3467.             "Physical Channel Type: %s",
    3468. 

  3468.             str);
    3469. 

  3469. 

  3470.         curr_offset++;
    3471. 

  3471. 

  3472.         oct = tvb_get_guint8(tvb, curr_offset);
    3473. 

  3473. 

  3474.         switch (global_a_variant)
    3475. 

  3475.         {
    3476. 

  3476.         case A_VARIANT_IOS401:
    3477. 

  3477.             other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    3478. 

  3478.             proto_tree_add_text(tree, tvb, curr_offset, 1,
    3479. 

  3479.                 "%s :  Reserved",
    3480. 

  3480.                 a_bigbuf);
    3481. 

  3481.             break;
    3482. 

  3482. 

  3483.         case A_VARIANT_IOS501:
    3484. 

  3484.             other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    3485. 

  3485.             proto_tree_add_text(tree, tvb, curr_offset, 1,
    3486. 

  3486.                 "%s :  Rev_FCH_Gating",
    3487. 

  3487.                 a_bigbuf);
    3488. 

  3488.             break;
    3489. 

  3489.         }
    3490. 

  3490. 

  3491.         switch ((oct & 0x60) >> 5)
    3492. 

  3492.         {
    3493. 

  3493.         case 0: str = "Gating rate 1"; break;
    3494. 

  3494.         case 1: str = "Gating rate 1/2"; break;
    3495. 

  3495.         case 2: str = "Gating rate 1/4"; break;
    3496. 

  3496.         default:
    3497. 

  3497.             str = "Reserved";
    3498. 

  3498.             break;
    3499. 

  3499.         }
    3500. 

  3500. 

  3501.         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
    3502. 

  3502.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3503. 

  3503.             "%s :  Pilot Gating Rate: %s",
    3504. 

  3504.             a_bigbuf,
    3505. 

  3505.             str);
    3506. 

  3506. 

  3507.         other_decode_bitfield_value(a_bigbuf, oct, 0x18, 8);
    3508. 

  3508.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3509. 

  3509.             "%s :  QOF Mask",
    3510. 

  3510.             a_bigbuf);
    3511. 

  3511. 

  3512.         value = tvb_get_guint8(tvb, curr_offset + 1);
    3513. 

  3513. 

  3514.         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    3515. 

  3515.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3516. 

  3516.             "%s :  Walsh Code Channel Index (MSB): %u",
    3517. 

  3517.             a_bigbuf,
    3518. 

  3518.             ((guint32) (oct & 0x07) << 8) | value);
    3519. 

  3519. 

  3520.         curr_offset++;
    3521. 

  3521. 

  3522.         other_decode_bitfield_value(a_bigbuf, value, 0xff, 8);
    3523. 

  3523.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3524. 

  3524.             "%s :  Walsh Code Channel Index (LSB)",
    3525. 

  3525.             a_bigbuf);
    3526. 

  3526. 

  3527.         curr_offset++;
    3528. 

  3528. 

  3529.         oct = tvb_get_guint8(tvb, curr_offset);
    3530. 

  3530. 

  3531.         other_decode_bitfield_value(a_bigbuf, oct, 0xff, 8);
    3532. 

  3532.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3533. 

  3533.             "%s :  Pilot PN Code (LSB)",
    3534. 

  3534.             a_bigbuf);
    3535. 

  3535. 

  3536.         curr_offset++;
    3537. 

  3537. 

  3538.         value = oct;
    3539. 

  3539.         oct = tvb_get_guint8(tvb, curr_offset);
    3540. 

  3540.         value |= ((guint32) (oct & 0x80)) << 1;
    3541. 

  3541. 

  3542.         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    3543. 

  3543.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3544. 

  3544.             "%s :  Pilot PN Code (MSB): %u",
    3545. 

  3545.             a_bigbuf,
    3546. 

  3546.             value);
    3547. 

  3547. 

  3548.         switch (global_a_variant)
    3549. 

  3549.         {
    3550. 

  3550.         case A_VARIANT_IOS401:
    3551. 

  3551.             other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
    3552. 

  3552.             proto_tree_add_text(tree, tvb, curr_offset, 1,
    3553. 

  3553.                 "%s :  Reserved",
    3554. 

  3554.                 a_bigbuf);
    3555. 

  3555.             break;
    3556. 

  3556. 

  3557.         case A_VARIANT_IOS501:
    3558. 

  3558.             other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
    3559. 

  3559.             proto_tree_add_text(tree, tvb, curr_offset, 1,
    3560. 

  3560.                 "%s :  Reserved",
    3561. 

  3561.                 a_bigbuf);
    3562. 

  3562. 

  3563.             other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
    3564. 

  3564.             proto_tree_add_text(tree, tvb, curr_offset, 1,
    3565. 

  3565.                 "%s :  Power Combined",
    3566. 

  3566.                 a_bigbuf);
    3567. 

  3567.             break;
    3568. 

  3568.         }
    3569. 

  3569. 

  3570.         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    3571. 

  3571.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3572. 

  3572.             "%s :  Frequency Included",
    3573. 

  3573.             a_bigbuf);
    3574. 

  3574. 

  3575.         value = tvb_get_guint8(tvb, curr_offset + 1) | ((oct & 0x07) << 8);
    3576. 

  3576. 

  3577.         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    3578. 

  3578.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3579. 

  3579.             "%s :  ARFCN (MSB): %u",
    3580. 

  3580.             a_bigbuf,
    3581. 

  3581.             value);
    3582. 

  3582. 

  3583.         curr_offset++;
    3584. 

  3584. 

  3585.         other_decode_bitfield_value(a_bigbuf, value & 0x00ff, 0xff, 8);
    3586. 

  3586.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3587. 

  3587.             "%s :  ARFCN (LSB)",
    3588. 

  3588.             a_bigbuf);
    3589. 

  3589. 

  3590.         curr_offset++;
    3591. 

  3591.     }
    3592. 

  3592.     while ((len - (curr_offset - offset)) >= 6);
    3593. 

  3593. 

  3594.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3595. 

  3595. 

  3596.     return(curr_offset - offset);
    3597. 

  3597. }
    3598. 

  3598. 

  3599. /*
    3600. 

  3600.  * IOS 6.2.2.35
    3601. 

  3601.  * NO ASSOCIATED DATA
    3602. 

  3602.  */
    3603. 

  3603. 

  3604. /*
    3605. 

  3605.  * IOS 6.2.2.36
    3606. 

  3606.  */
    3607. 

  3607. static guint8
    3608. 

  3608. elem_is95_ms_meas_chan_id(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    3609. 

  3609. {
    3610. 

  3610.     guint8      oct;
    3611. 

  3611.     guint32     value;
    3612. 

  3612.     gint        temp_int;
    3613. 

  3613.     guint32     curr_offset;
    3614. 

  3614.     const gchar *str;
    3615. 

  3615. 

  3616.     curr_offset = offset;
    3617. 

  3617. 

  3618.     oct = tvb_get_guint8(tvb, curr_offset);
    3619. 

  3619. 

  3620.     temp_int = (oct & 0xf8) >> 3;
    3621. 

  3621.     if ((temp_int < 0) || (temp_int >= (gint) NUM_BAND_CLASS_STR))
    3622. 

  3622.     {
    3623. 

  3623.         str = "Reserved";
    3624. 

  3624.     }
    3625. 

  3625.     else
    3626. 

  3626.     {
    3627. 

  3627.         str = band_class_str[temp_int];
    3628. 

  3628.     }
    3629. 

  3629. 

  3630.     other_decode_bitfield_value(a_bigbuf, oct, 0xf8, 8);
    3631. 

  3631.     proto_tree_add_text(tree,
    3632. 

  3632.         tvb, curr_offset, 1,
    3633. 

  3633.         "%s :  Band Class: %s",
    3634. 

  3634.         a_bigbuf,
    3635. 

  3635.         str);
    3636. 

  3636. 

  3637.     value = tvb_get_guint8(tvb, curr_offset + 1) | ((oct & 0x07) << 8);
    3638. 

  3638. 

  3639.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    3640. 

  3640.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    3641. 

  3641.         "%s :  ARFCN (MSB): %u",
    3642. 

  3642.         a_bigbuf,
    3643. 

  3643.         value);
    3644. 

  3644. 

  3645.     curr_offset++;
    3646. 

  3646. 

  3647.     other_decode_bitfield_value(a_bigbuf, value & 0x00ff, 0xff, 8);
    3648. 

  3648.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    3649. 

  3649.         "%s :  ARFCN (LSB)",
    3650. 

  3650.         a_bigbuf);
    3651. 

  3651. 

  3652.     g_snprintf(add_string, string_len, " - (ARFCN: %u)", value);
    3653. 

  3653. 

  3654.     curr_offset++;
    3655. 

  3655. 

  3656.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3657. 

  3657. 

  3658.     return(curr_offset - offset);
    3659. 

  3659. }
    3660. 

  3660. 

  3661. /*
    3662. 

  3662.  * IOS 6.2.2.37
    3663. 

  3663.  */
    3664. 

  3664. static guint8
    3665. 

  3665. elem_clg_party_ascii_num(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    3666. 

  3666. {
    3667. 

  3667.     guint8      oct;
    3668. 

  3668.     guint32     curr_offset;
    3669. 

  3669.     guint8      *poctets;
    3670. 

  3670.     const gchar *str;
    3671. 

  3671. 

  3672.     curr_offset = offset;
    3673. 

  3673. 

  3674.     oct = tvb_get_guint8(tvb, curr_offset);
    3675. 

  3675. 

  3676.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    3677. 

  3677.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    3678. 

  3678.         "%s :  Extension: %s",
    3679. 

  3679.         a_bigbuf,
    3680. 

  3680.         (oct & 0x80) ? "Not extended" : "Extended");
    3681. 

  3681. 

  3682.     switch ((oct & 0x70) >> 4)
    3683. 

  3683.     {
    3684. 

  3684.     case 0: str = "Unknown"; break;
    3685. 

  3685.     case 1: str = "International number"; break;
    3686. 

  3686.     case 2: str = "National number"; break;
    3687. 

  3687.     case 3: str = "Network-specific number"; break;
    3688. 

  3688.     case 4: str = "Dedicated PAD access, short code"; break;
    3689. 

  3689.     case 5: str = "Reserved"; break;
    3690. 

  3690.     case 6: str = "Reserved"; break;
    3691. 

  3691.     default:
    3692. 

  3692.         str = "Reserved for extension";
    3693. 

  3693.         break;
    3694. 

  3694.     }
    3695. 

  3695. 

  3696.     other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
    3697. 

  3697.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    3698. 

  3698.         "%s :  Type of Number: %s",
    3699. 

  3699.         a_bigbuf,
    3700. 

  3700.         str);
    3701. 

  3701. 

  3702.     switch (oct & 0x0f)
    3703. 

  3703.     {
    3704. 

  3704.     case 0x00: str = "Unknown"; break;
    3705. 

  3705.     case 0x01: str = "ISDN/Telephony Numbering (ITU recommendation E.164/E.163)"; break;
    3706. 

  3706.     case 0x03: str = "Data Numbering (ITU-T Rec. X.121)"; break;
    3707. 

  3707.     case 0x04: str = "Telex Numbering (ITU-T Rec. F.69)"; break;
    3708. 

  3708.     case 0x07: str = "Reserved for extension"; break;
    3709. 

  3709.     case 0x08: str = "National Numbering"; break;
    3710. 

  3710.     case 0x09: str = "Private Numbering"; break;
    3711. 

  3711.     default:
    3712. 

  3712.         str = "Reserved";
    3713. 

  3713.         break;
    3714. 

  3714.     }
    3715. 

  3715. 

  3716.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    3717. 

  3717.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    3718. 

  3718.         "%s :  Number Plan Identification: %s",
    3719. 

  3719.         a_bigbuf,
    3720. 

  3720.         str);
    3721. 

  3721. 

  3722.     curr_offset++;
    3723. 

  3723. 

  3724.     if (!(oct & 0x80))
    3725. 

  3725.     {
    3726. 

  3726.         /* octet 3a */
    3727. 

  3727. 

  3728.         oct = tvb_get_guint8(tvb, curr_offset);
    3729. 

  3729. 

  3730.         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    3731. 

  3731.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3732. 

  3732.             "%s :  Extension",
    3733. 

  3733.             a_bigbuf);
    3734. 

  3734. 

  3735.         switch ((oct & 0x60) >> 5)
    3736. 

  3736.         {
    3737. 

  3737.         case 0: str = "Presentation allowed"; break;
    3738. 

  3738.         case 1: str = "Presentation restricted"; break;
    3739. 

  3739.         case 2: str = "Number not available due to interworking"; break;
    3740. 

  3740.         default:
    3741. 

  3741.             str = "Reserved";
    3742. 

  3742.             break;
    3743. 

  3743.         }
    3744. 

  3744. 

  3745.         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
    3746. 

  3746.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3747. 

  3747.             "%s :  Presentation Indicator: %s",
    3748. 

  3748.             a_bigbuf,
    3749. 

  3749.             str);
    3750. 

  3750. 

  3751.         switch (oct & 0x03)
    3752. 

  3752.         {
    3753. 

  3753.         case 0: str = "User-provided, not screened"; break;
    3754. 

  3754.         case 1: str = "User-provided, verified and passed"; break;
    3755. 

  3755.         case 2: str = "User-provided, verified and failed"; break;
    3756. 

  3756.         default:
    3757. 

  3757.             str = "Network-provided";
    3758. 

  3758.             break;
    3759. 

  3759.         }
    3760. 

  3760. 

  3761.         other_decode_bitfield_value(a_bigbuf, oct, 0x1c, 8);
    3762. 

  3762.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3763. 

  3763.             "%s :  Reserved",
    3764. 

  3764.             a_bigbuf);
    3765. 

  3765. 

  3766.         other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
    3767. 

  3767.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    3768. 

  3768.             "%s :  Screening Indicator: %s",
    3769. 

  3769.             a_bigbuf,
    3770. 

  3770.             str);
    3771. 

  3771. 

  3772.         curr_offset++;
    3773. 

  3773.     }
    3774. 

  3774. 

  3775.     poctets = tvb_get_ephemeral_string(tvb, curr_offset, len - (curr_offset - offset));
    3776. 

  3776. 

  3777.     proto_tree_add_string_format(tree, hf_ansi_a_clg_party_ascii_num,
    3778. 

  3778.         tvb, curr_offset, len - (curr_offset - offset),
    3779. 

  3779.         (gchar *) poctets,
    3780. 

  3780.         "Digits: %s",
    3781. 

  3781.         (gchar *) format_text(poctets, len - (curr_offset - offset)));
    3782. 

  3782. 

  3783.     curr_offset += len - (curr_offset - offset);
    3784. 

  3784. 

  3785.     g_snprintf(add_string, string_len, " - (%s)", poctets);
    3786. 

  3786. 

  3787.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3788. 

  3788. 

  3789.     return(curr_offset - offset);
    3790. 

  3790. }
    3791. 

  3791. 

  3792. /*
    3793. 

  3793.  * IOS 6.2.2.38
    3794. 

  3794.  */
    3795. 

  3795. static guint8
    3796. 

  3796. elem_l3_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    3797. 

  3797. {
    3798. 

  3798.     guint32     curr_offset;
    3799. 

  3799.     tvbuff_t    *l3_tvb;
    3800. 

  3800. 

  3801.     curr_offset = offset;
    3802. 

  3802. 

  3803.     proto_tree_add_text(tree, tvb, curr_offset, len,
    3804. 

  3804.         "Layer 3 Information");
    3805. 

  3805. 

  3806.     /*
    3807. 

  3807.      * dissect the embedded DTAP message
    3808. 

  3808.      */
    3809. 

  3809.     l3_tvb = tvb_new_subset(tvb, curr_offset, len, len);
    3810. 

  3810. 

  3811.     call_dissector(dtap_handle, l3_tvb, pinfo, g_tree);
    3812. 

  3812. 

  3813.     curr_offset += len;
    3814. 

  3814. 

  3815.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3816. 

  3816. 

  3817.     return(curr_offset - offset);
    3818. 

  3818. }
    3819. 

  3819. 

  3820. /*
    3821. 

  3821.  * IOS 6.2.2.39
    3822. 

  3822.  * Protocol Discriminator
    3823. 

  3823.  */
    3824. 

  3824. 

  3825. /*
    3826. 

  3826.  * IOS 6.2.2.40
    3827. 

  3827.  * Reserved Octet
    3828. 

  3828.  */
    3829. 

  3829. 

  3830. /*
    3831. 

  3831.  * IOS 6.2.2.41
    3832. 

  3832.  * Location Updating Type
    3833. 

  3833.  * UNUSED in SPEC!
    3834. 

  3834.  */
    3835. 

  3835. 

  3836. /*
    3837. 

  3837.  * IOS 6.2.2.42
    3838. 

  3838.  * Simple data no decode required
    3839. 

  3839.  */
    3840. 

  3840. 

  3841. /*
    3842. 

  3842.  * IOS 6.2.2.43
    3843. 

  3843.  */
    3844. 

  3844. static guint8
    3845. 

  3845. elem_lai(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string _U_, int string_len _U_)
    3846. 

  3846. {
    3847. 

  3847.     guint8      oct;
    3848. 

  3848.     guint16     value;
    3849. 

  3849.     guint32     curr_offset;
    3850. 

  3850.     gchar       mcc[4];
    3851. 

  3851.     gchar       mnc[4];
    3852. 

  3852. 

  3853.     curr_offset = offset;
    3854. 

  3854. 

  3855.     oct = tvb_get_guint8(tvb, curr_offset);
    3856. 

  3856. 

  3857.     mcc[0] = Dgt_tbcd.out[oct & 0x0f];
    3858. 

  3858.     mcc[1] = Dgt_tbcd.out[(oct & 0xf0) >> 4];
    3859. 

  3859. 

  3860.     oct = tvb_get_guint8(tvb, curr_offset+1);
    3861. 

  3861. 

  3862.     mcc[2] = Dgt_tbcd.out[(oct & 0x0f)];
    3863. 

  3863.     mcc[3] = '\0';
    3864. 

  3864. 

  3865.     mnc[2] = Dgt_tbcd.out[(oct & 0xf0) >> 4];
    3866. 

  3866. 

  3867.     oct = tvb_get_guint8(tvb, curr_offset+2);
    3868. 

  3868. 

  3869.     mnc[0] = Dgt_tbcd.out[(oct & 0x0f)];
    3870. 

  3870.     mnc[1] = Dgt_tbcd.out[(oct & 0xf0) >> 4];
    3871. 

  3871.     mnc[3] = '\0';
    3872. 

  3872. 

  3873.     proto_tree_add_text(tree,
    3874. 

  3874.         tvb, curr_offset, 3,
    3875. 

  3875.         "Mobile Country Code (MCC): %s, Mobile Network Code (MNC): %s",
    3876. 

  3876.         mcc,
    3877. 

  3877.         mnc);
    3878. 

  3878. 

  3879.     curr_offset += 3;
    3880. 

  3880. 

  3881.     value = tvb_get_ntohs(tvb, curr_offset);
    3882. 

  3882. 

  3883.     proto_tree_add_text(tree,
    3884. 

  3884.         tvb, curr_offset, 2,
    3885. 

  3885.         "Location Area Code (LAC): 0x%04x (%u)",
    3886. 

  3886.         value,
    3887. 

  3887.         value);
    3888. 

  3888. 

  3889.     curr_offset += 2;
    3890. 

  3890. 

  3891.     /* no length check possible */
    3892. 

  3892. 

  3893.     return(curr_offset - offset);
    3894. 

  3894. }
    3895. 

  3895. 

  3896. /*
    3897. 

  3897.  * IOS 6.2.2.44
    3898. 

  3898.  */
    3899. 

  3899. static guint8
    3900. 

  3900. elem_rej_cause(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    3901. 

  3901. {
    3902. 

  3902.     guint8      oct;
    3903. 

  3903.     guint32     curr_offset;
    3904. 

  3904.     const gchar *str;
    3905. 

  3905. 

  3906.     curr_offset = offset;
    3907. 

  3907. 

  3908.     oct = tvb_get_guint8(tvb, curr_offset);
    3909. 

  3909. 

  3910.     switch (oct)
    3911. 

  3911.     {
    3912. 

  3912.     case 0x01: str = "Reserved"; break;
    3913. 

  3913.     case 0x02: str = "MIN/IMSI unknown in HLR"; break;
    3914. 

  3914.     case 0x03: str = "Illegal MS"; break;
    3915. 

  3915.     case 0x04: str = "TMSI/IMSI/MIN unknown in VLR"; break;
    3916. 

  3916.     case 0x05: str = "Reserved"; break;
    3917. 

  3917.     case 0x0b: str = "Roaming not allowed"; break;
    3918. 

  3918.     case 0x0c: str = "Location area not allowed"; break;
    3919. 

  3919.     case 0x20: str = "Service option not supported"; break;
    3920. 

  3920.     case 0x21: str = "Requested service option not subscribed"; break;
    3921. 

  3921.     case 0x22: str = "Service option temporarily out of order"; break;
    3922. 

  3922.     case 0x26: str = "Call cannot be identified"; break;
    3923. 

  3923.     case 0x51: str = "Network failure"; break;
    3924. 

  3924.     case 0x56: str = "Congestion"; break;
    3925. 

  3925.     case 0x62: str = "Message type non-existent or not implemented"; break;
    3926. 

  3926.     case 0x63: str = "Information element non-existent or not implemented"; break;
    3927. 

  3927.     case 0x64: str = "Invalid information element contents"; break;
    3928. 

  3928.     case 0x65: str = "Message not compatible with the call state"; break;
    3929. 

  3929.     case 0x66: str = "Protocol error, unspecified"; break;
    3930. 

  3930.     case 0x6e: str = "Invalid message, unspecified"; break;
    3931. 

  3931.     case 0x6f: str = "Mandatory information element error"; break;
    3932. 

  3932.     default:
    3933. 

  3933.         str = "Reserved";
    3934. 

  3934.         break;
    3935. 

  3935.     }
    3936. 

  3936. 

  3937.     proto_tree_add_text(tree,
    3938. 

  3938.         tvb, curr_offset, 1,
    3939. 

  3939.         "Reject Cause Value: (%u) %s",
    3940. 

  3940.         oct,
    3941. 

  3941.         str);
    3942. 

  3942. 

  3943.     curr_offset++;
    3944. 

  3944. 

  3945.     g_snprintf(add_string, string_len, " - (%s)", str);
    3946. 

  3946. 

  3947.     /* no length check possible */
    3948. 

  3948. 

  3949.     return(curr_offset - offset);
    3950. 

  3950. }
    3951. 

  3951. 

  3952. /*
    3953. 

  3953.  * IOS 5 4.2.78
    3954. 

  3954.  */
    3955. 

  3955. static guint8
    3956. 

  3956. elem_anchor_pdsn_addr(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    3957. 

  3957. {
    3958. 

  3958.     guint32     curr_offset;
    3959. 

  3959. 

  3960.     curr_offset = offset;
    3961. 

  3961. 

  3962.     proto_tree_add_item(tree, hf_ansi_a_anchor_ip_addr, tvb, curr_offset, len, ENC_BIG_ENDIAN);
    3963. 

  3963. 

  3964.     curr_offset += len;
    3965. 

  3965. 

  3966.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3967. 

  3967. 

  3968.     return(curr_offset - offset);
    3969. 

  3969. }
    3970. 

  3970. 

  3971. /*
    3972. 

  3972.  * IOS 5 4.2.80
    3973. 

  3973.  */
    3974. 

  3974. static guint8
    3975. 

  3975. elem_anchor_pp_addr(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    3976. 

  3976. {
    3977. 

  3977.     guint32     curr_offset;
    3978. 

  3978. 

  3979.     curr_offset = offset;
    3980. 

  3980. 

  3981.     proto_tree_add_item(tree, hf_ansi_a_anchor_pp_ip_addr, tvb, curr_offset, len, ENC_BIG_ENDIAN);
    3982. 

  3982. 

  3983.     curr_offset += len;
    3984. 

  3984. 

  3985.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    3986. 

  3986. 

  3987.     return(curr_offset - offset);
    3988. 

  3988. }
    3989. 

  3989. 

  3990. /*
    3991. 

  3991.  * IOS 6.2.2.45
    3992. 

  3992.  */
    3993. 

  3993. static guint8
    3994. 

  3994. elem_auth_chlg_param(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    3995. 

  3995. {
    3996. 

  3996.     guint8      oct;
    3997. 

  3997.     guint32     curr_offset;
    3998. 

  3998.     const gchar *str;
    3999. 

  3999. 

  4000.     curr_offset = offset;
    4001. 

  4001. 

  4002.     oct = tvb_get_guint8(tvb, curr_offset);
    4003. 

  4003. 

  4004.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    4005. 

  4005.     proto_tree_add_text(tree,
    4006. 

  4006.         tvb, curr_offset, 1,
    4007. 

  4007.         "%s :  Reserved",
    4008. 

  4008.         a_bigbuf);
    4009. 

  4009. 

  4010.     switch (oct & 0x0f)
    4011. 

  4011.     {
    4012. 

  4012.     case 1: str = "RAND 32 bits"; break;
    4013. 

  4013.     case 2: str = "RANDU 24 bits"; break;
    4014. 

  4014.     case 4: str = "RANDSSD 56 bits"; break;
    4015. 

  4015.     case 8: str = "RANDBS 32 bits"; break;
    4016. 

  4016.     default:
    4017. 

  4017.         str = "Reserved";
    4018. 

  4018.         break;
    4019. 

  4019.     }
    4020. 

  4020. 

  4021.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    4022. 

  4022.     proto_tree_add_text(tree,
    4023. 

  4023.         tvb, curr_offset, 1,
    4024. 

  4024.         "%s :  Random Number Type: (%u) %s",
    4025. 

  4025.         a_bigbuf,
    4026. 

  4026.         oct & 0x0f,
    4027. 

  4027.         str);
    4028. 

  4028. 

  4029.     curr_offset++;
    4030. 

  4030. 

  4031.     proto_tree_add_text(tree,
    4032. 

  4032.         tvb, curr_offset, len - (curr_offset - offset),
    4033. 

  4033.         "RAND/RANDU/RANDBS/RANDSSD Value");
    4034. 

  4034. 

  4035.     g_snprintf(add_string, string_len, " - (%s)", str);
    4036. 

  4036. 

  4037.     curr_offset += len - (curr_offset - offset);
    4038. 

  4038. 

  4039.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    4040. 

  4040. 

  4041.     return(curr_offset - offset);
    4042. 

  4042. }
    4043. 

  4043. 

  4044. /*
    4045. 

  4045.  * IOS 6.2.2.46
    4046. 

  4046.  */
    4047. 

  4047. static guint8
    4048. 

  4048. elem_auth_resp_param(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    4049. 

  4049. {
    4050. 

  4050.     guint8      oct;
    4051. 

  4051.     guint32     curr_offset;
    4052. 

  4052.     const gchar *str;
    4053. 

  4053. 

  4054.     curr_offset = offset;
    4055. 

  4055. 

  4056.     oct = tvb_get_guint8(tvb, curr_offset);
    4057. 

  4057. 

  4058.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    4059. 

  4059.     proto_tree_add_text(tree,
    4060. 

  4060.         tvb, curr_offset, 1,
    4061. 

  4061.         "%s :  Reserved",
    4062. 

  4062.         a_bigbuf);
    4063. 

  4063. 

  4064.     switch (oct & 0x0f)
    4065. 

  4065.     {
    4066. 

  4066.     case 1: str = "AUTHR"; break;
    4067. 

  4067.     case 2: str = "AUTHU"; break;
    4068. 

  4068.     case 4: str = "AUTHBS"; break;
    4069. 

  4069.     default:
    4070. 

  4070.         str = "Reserved";
    4071. 

  4071.         break;
    4072. 

  4072.     }
    4073. 

  4073. 

  4074.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    4075. 

  4075.     proto_tree_add_text(tree,
    4076. 

  4076.         tvb, curr_offset, 1,
    4077. 

  4077.         "%s :  Auth Signature Type: (%u) %s",
    4078. 

  4078.         a_bigbuf,
    4079. 

  4079.         oct & 0x0f,
    4080. 

  4080.         str);
    4081. 

  4081. 

  4082.     curr_offset++;
    4083. 

  4083. 

  4084.     proto_tree_add_text(tree,
    4085. 

  4085.         tvb, curr_offset, len - (curr_offset - offset),
    4086. 

  4086.         "Auth Signature");
    4087. 

  4087. 

  4088.     g_snprintf(add_string, string_len, " - (%s)", str);
    4089. 

  4089. 

  4090.     curr_offset += len - (curr_offset - offset);
    4091. 

  4091. 

  4092.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    4093. 

  4093. 

  4094.     return(curr_offset - offset);
    4095. 

  4095. }
    4096. 

  4096. 

  4097. /*
    4098. 

  4098.  * IOS 6.2.2.47
    4099. 

  4099.  */
    4100. 

  4100. static guint8
    4101. 

  4101. elem_auth_param_count(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    4102. 

  4102. {
    4103. 

  4103.     guint8      oct;
    4104. 

  4104.     guint32     curr_offset;
    4105. 

  4105. 

  4106.     curr_offset = offset;
    4107. 

  4107. 

  4108.     oct = tvb_get_guint8(tvb, curr_offset);
    4109. 

  4109. 

  4110.     other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
    4111. 

  4111.     proto_tree_add_text(tree,
    4112. 

  4112.         tvb, curr_offset, 1,
    4113. 

  4113.         "%s :  Reserved",
    4114. 

  4114.         a_bigbuf);
    4115. 

  4115. 

  4116.     other_decode_bitfield_value(a_bigbuf, oct, 0x3f, 8);
    4117. 

  4117.     proto_tree_add_text(tree,
    4118. 

  4118.         tvb, curr_offset, 1,
    4119. 

  4119.         "%s :  Count: %u",
    4120. 

  4120.         a_bigbuf,
    4121. 

  4121.         oct & 0x3f);
    4122. 

  4122. 

  4123.     curr_offset++;
    4124. 

  4124. 

  4125.     g_snprintf(add_string, string_len, " - (%u)", oct & 0x3f);
    4126. 

  4126. 

  4127.     /* no length check possible */
    4128. 

  4128. 

  4129.     return(curr_offset - offset);
    4130. 

  4130. }
    4131. 

  4131. 

  4132. /*
    4133. 

  4133.  * IOS 6.2.2.48
    4134. 

  4134.  */
    4135. 

  4135. static guint8
    4136. 

  4136. elem_mwi(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    4137. 

  4137. {
    4138. 

  4138.     guint8      oct;
    4139. 

  4139.     guint32     curr_offset;
    4140. 

  4140. 

  4141.     curr_offset = offset;
    4142. 

  4142. 

  4143.     oct = tvb_get_guint8(tvb, curr_offset);
    4144. 

  4144. 

  4145.     proto_tree_add_text(tree,
    4146. 

  4146.         tvb, curr_offset, 1,
    4147. 

  4147.         "Number of Messages: %u",
    4148. 

  4148.         oct);
    4149. 

  4149. 

  4150.     curr_offset++;
    4151. 

  4151. 

  4152.     g_snprintf(add_string, string_len, " - (%u)", oct);
    4153. 

  4153. 

  4154.     /* no length check possible */
    4155. 

  4155. 

  4156.     return(curr_offset - offset);
    4157. 

  4157. }
    4158. 

  4158. 

  4159. /*
    4160. 

  4160.  * IOS 6.2.2.49
    4161. 

  4161.  * Progress
    4162. 

  4162.  * UNUSED in SPEC and no IEI!
    4163. 

  4163.  */
    4164. 

  4164. 

  4165. /*
    4166. 

  4166.  * IOS 6.2.2.50
    4167. 

  4167.  */
    4168. 

  4168. static guint8
    4169. 

  4169. elem_signal(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    4170. 

  4170. {
    4171. 

  4171.     guint8      oct;
    4172. 

  4172.     guint32     curr_offset;
    4173. 

  4173.     const gchar *str;
    4174. 

  4174. 

  4175.     curr_offset = offset;
    4176. 

  4176. 

  4177.     oct = tvb_get_guint8(tvb, curr_offset);
    4178. 

  4178. 

  4179.     switch (oct)
    4180. 

  4180.     {
    4181. 

  4181.     case 0x00: str = "Dial tone on"; break;
    4182. 

  4182.     case 0x01: str = "Ring back tone on"; break;
    4183. 

  4183.     case 0x02: str = "Intercept tone on"; break;
    4184. 

  4184.     case 0x03: str = "Network congestion (reorder) tone on"; break;
    4185. 

  4185.     case 0x04: str = "Busy tone on"; break;
    4186. 

  4186.     case 0x05: str = "Confirm tone on"; break;
    4187. 

  4187.     case 0x06: str = "Answer tone on"; break;
    4188. 

  4188.     case 0x07: str = "Call waiting tone on"; break;
    4189. 

  4189.     case 0x08: str = "Off-hook warning tone on"; break;
    4190. 

  4190.     case 0x3f: str = "Tones off"; break;
    4191. 

  4191.     case 0x40: str = "Normal Alerting"; break;
    4192. 

  4192.     case 0x41: str = "Inter-group Alerting"; break;
    4193. 

  4193.     case 0x42: str = "Special/Priority Alerting"; break;
    4194. 

  4194.     case 0x43: str = "Reserved (ISDN Alerting pattern 3)"; break;
    4195. 

  4195.     case 0x44: str = "Ping Ring (abbreviated alert)"; break;
    4196. 

  4196.     case 0x45: str = "Reserved (ISDN Alerting pattern 5)"; break;
    4197. 

  4197.     case 0x46: str = "Reserved (ISDN Alerting pattern 6)"; break;
    4198. 

  4198.     case 0x47: str = "Reserved (ISDN Alerting pattern 7)"; break;
    4199. 

  4199.     case 0x63: str = "Abbreviated intercept"; break;
    4200. 

  4200.     case 0x65: str = "Abbreviated reorder"; break;
    4201. 

  4201.     case 0x4f: str = "Alerting off"; break;
    4202. 

  4202.     default:
    4203. 

  4203.         str = "Unknown";
    4204. 

  4204.         break;
    4205. 

  4205.     }
    4206. 

  4206. 

  4207.     proto_tree_add_text(tree,
    4208. 

  4208.         tvb, curr_offset, 1,
    4209. 

  4209.         "Signal Value: (%u) %s",
    4210. 

  4210.         oct,
    4211. 

  4211.         str);
    4212. 

  4212. 

  4213.     g_snprintf(add_string, string_len, " - (%s)", str);
    4214. 

  4214. 

  4215.     curr_offset++;
    4216. 

  4216. 

  4217.     oct = tvb_get_guint8(tvb, curr_offset);
    4218. 

  4218. 

  4219.     other_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8);
    4220. 

  4220.     proto_tree_add_text(tree,
    4221. 

  4221.         tvb, curr_offset, 1,
    4222. 

  4222.         "%s :  Reserved",
    4223. 

  4223.         a_bigbuf);
    4224. 

  4224. 

  4225.     switch (oct & 0x03)
    4226. 

  4226.     {
    4227. 

  4227.     case 0: str = "Medium pitch (standard alert)"; break;
    4228. 

  4228.     case 1: str = "High pitch"; break;
    4229. 

  4229.     case 2: str = "Low pitch"; break;
    4230. 

  4230.     default:
    4231. 

  4231.         str = "Reserved";
    4232. 

  4232.         break;
    4233. 

  4233.     }
    4234. 

  4234. 

  4235.     proto_tree_add_text(tree,
    4236. 

  4236.         tvb, curr_offset, 1,
    4237. 

  4237.         "%s : Alert Pitch: %s",
    4238. 

  4238.         a_bigbuf,
    4239. 

  4239.         str);
    4240. 

  4240. 

  4241.     curr_offset++;
    4242. 

  4242. 

  4243.     /* no length check possible */
    4244. 

  4244. 

  4245.     return(curr_offset - offset);
    4246. 

  4246. }
    4247. 

  4247. 

  4248. /*
    4249. 

  4249.  * IOS 6.2.2.51
    4250. 

  4250.  * CM Service Type
    4251. 

  4251.  */
    4252. 

  4252. 

  4253. /*
    4254. 

  4254.  * IOS 6.2.2.52
    4255. 

  4255.  */
    4256. 

  4256. static guint8
    4257. 

  4257. elem_cld_party_bcd_num(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    4258. 

  4258. {
    4259. 

  4259.     guint8      oct;
    4260. 

  4260.     guint8      *poctets;
    4261. 

  4261.     guint32     curr_offset;
    4262. 

  4262.     const gchar *str;
    4263. 

  4263. 

  4264.     curr_offset = offset;
    4265. 

  4265. 

  4266.     oct = tvb_get_guint8(tvb, curr_offset);
    4267. 

  4267. 

  4268.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    4269. 

  4269.     proto_tree_add_text(tree,
    4270. 

  4270.         tvb, curr_offset, 1,
    4271. 

  4271.         "%s :  Extension",
    4272. 

  4272.         a_bigbuf);
    4273. 

  4273. 

  4274.     switch ((oct & 0x70) >> 4)
    4275. 

  4275.     {
    4276. 

  4276.     case 0: str = "Unknown"; break;
    4277. 

  4277.     case 1: str = "International number"; break;
    4278. 

  4278.     case 2: str = "National number"; break;
    4279. 

  4279.     case 3: str = "Network specific number"; break;
    4280. 

  4280.     case 4: str = "Dedicated PAD access, short code"; break;
    4281. 

  4281.     case 7: str = "Reserved for extension"; break;
    4282. 

  4282.     default:
    4283. 

  4283.         str = "Reserved";
    4284. 

  4284.         break;
    4285. 

  4285.     }
    4286. 

  4286. 

  4287.     other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
    4288. 

  4288.     proto_tree_add_text(tree,
    4289. 

  4289.         tvb, curr_offset, 1,
    4290. 

  4290.         "%s :  Type of Number: %s",
    4291. 

  4291.         a_bigbuf,
    4292. 

  4292.         str);
    4293. 

  4293. 

  4294.     switch (oct & 0x0f)
    4295. 

  4295.     {
    4296. 

  4296.     case 0x00: str = "Unknown"; break;
    4297. 

  4297.     case 0x01: str = "ISDN/telephony number plan (ITU recommendation E.164/E.163)"; break;
    4298. 

  4298.     case 0x03: str = "Data number plan (ITU recommendation X.121)"; break;
    4299. 

  4299.     case 0x04: str = "Telex numbering plan (ITU recommendation F.69)"; break;
    4300. 

  4300.     case 0x07: str = "Reserved for extension"; break;
    4301. 

  4301.     case 0x08: str = "National numbering plan"; break;
    4302. 

  4302.     case 0x09: str = "Private numbering plan"; break;
    4303. 

  4303.     default:
    4304. 

  4304.         str = "Reserved";
    4305. 

  4305.         break;
    4306. 

  4306.     }
    4307. 

  4307. 

  4308.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    4309. 

  4309.     proto_tree_add_text(tree,
    4310. 

  4310.         tvb, curr_offset, 1,
    4311. 

  4311.         "%s :  Numbering Plan Identification: %s",
    4312. 

  4312.         a_bigbuf,
    4313. 

  4313.         str);
    4314. 

  4314. 

  4315.     curr_offset++;
    4316. 

  4316. 

  4317.     poctets = tvb_get_ephemeral_string(tvb, curr_offset, len - (curr_offset - offset));
    4318. 

  4318. 

  4319.     my_dgt_tbcd_unpack(a_bigbuf, poctets, len - (curr_offset - offset),
    4320. 

  4320.         &Dgt_tbcd);
    4321. 

  4321. 

  4322.     proto_tree_add_string_format(tree, hf_ansi_a_cld_party_bcd_num,
    4323. 

  4323.         tvb, curr_offset, len - (curr_offset - offset),
    4324. 

  4324.         a_bigbuf,
    4325. 

  4325.         "BCD Digits: %s",
    4326. 

  4326.         a_bigbuf);
    4327. 

  4327. 

  4328.     g_snprintf(add_string, string_len, " - (%s)", a_bigbuf);
    4329. 

  4329. 

  4330.     curr_offset += len - (curr_offset - offset);
    4331. 

  4331. 

  4332.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    4333. 

  4333. 

  4334.     return(curr_offset - offset);
    4335. 

  4335. }
    4336. 

  4336. 

  4337. /*
    4338. 

  4338.  * IOS 6.2.2.53
    4339. 

  4339.  * UNUSED in SPEC and no IEI!
    4340. 

  4340.  */
    4341. 

  4341. #ifdef MAYBE_USED_FOR_OLDER_CODECS
    4342. 

  4342. static guint8
    4343. 

  4343. elem_clg_party_bcd_num(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    4344. 

  4344. {
    4345. 

  4345.     guint8      oct;
    4346. 

  4346.     guint8      *poctets;
    4347. 

  4347.     guint32     curr_offset;
    4348. 

  4348.     const gchar *str;
    4349. 

  4349. 

  4350.     curr_offset = offset;
    4351. 

  4351. 

  4352.     oct = tvb_get_guint8(tvb, curr_offset);
    4353. 

  4353. 

  4354.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    4355. 

  4355.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    4356. 

  4356.         "%s :  Extension: %s",
    4357. 

  4357.         a_bigbuf,
    4358. 

  4358.         (oct & 0x80) ? "Not extended" : "Extended");
    4359. 

  4359. 

  4360.     switch ((oct & 0x70) >> 4)
    4361. 

  4361.     {
    4362. 

  4362.     case 0: str = "Unknown"; break;
    4363. 

  4363.     case 1: str = "International number"; break;
    4364. 

  4364.     case 2: str = "National number"; break;
    4365. 

  4365.     case 3: str = "Network specific number"; break;
    4366. 

  4366.     case 4: str = "Dedicated PAD access, short code"; break;
    4367. 

  4367.     case 7: str = "Reserved for extension"; break;
    4368. 

  4368.     default:
    4369. 

  4369.         str = "Reserved";
    4370. 

  4370.         break;
    4371. 

  4371.     }
    4372. 

  4372. 

  4373.     other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
    4374. 

  4374.     proto_tree_add_text(tree,
    4375. 

  4375.         tvb, curr_offset, 1,
    4376. 

  4376.         "%s :  Type of Number: %s",
    4377. 

  4377.         a_bigbuf,
    4378. 

  4378.         str);
    4379. 

  4379. 

  4380.     switch (oct & 0x0f)
    4381. 

  4381.     {
    4382. 

  4382.     case 0x00: str = "Unknown"; break;
    4383. 

  4383.     case 0x01: str = "ISDN/telephony number plan (ITU recommendation E.164/E.163)"; break;
    4384. 

  4384.     case 0x03: str = "Data number plan (ITU recommendation X.121)"; break;
    4385. 

  4385.     case 0x04: str = "Telex numbering plan (ITU recommendation F.69)"; break;
    4386. 

  4386.     case 0x07: str = "Reserved for extension"; break;
    4387. 

  4387.     case 0x08: str = "National numbering plan"; break;
    4388. 

  4388.     case 0x09: str = "Private numbering plan"; break;
    4389. 

  4389.     default:
    4390. 

  4390.         str = "Reserved";
    4391. 

  4391.         break;
    4392. 

  4392.     }
    4393. 

  4393. 

  4394.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    4395. 

  4395.     proto_tree_add_text(tree,
    4396. 

  4396.         tvb, curr_offset, 1,
    4397. 

  4397.         "%s :  Numbering Plan Identification: %s",
    4398. 

  4398.         a_bigbuf,
    4399. 

  4399.         str);
    4400. 

  4400. 

  4401.     curr_offset++;
    4402. 

  4402. 

  4403.     if (!(oct & 0x80))
    4404. 

  4404.     {
    4405. 

  4405.         /* octet 3a */
    4406. 

  4406. 

  4407.         oct = tvb_get_guint8(tvb, curr_offset);
    4408. 

  4408. 

  4409.         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    4410. 

  4410.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    4411. 

  4411.             "%s :  Extension",
    4412. 

  4412.             a_bigbuf);
    4413. 

  4413. 

  4414.         switch ((oct & 0x60) >> 5)
    4415. 

  4415.         {
    4416. 

  4416.         case 0: str = "Presentation allowed"; break;
    4417. 

  4417.         case 1: str = "Presentation restricted"; break;
    4418. 

  4418.         case 2: str = "Number not available due to interworking"; break;
    4419. 

  4419.         default:
    4420. 

  4420.             str = "Reserved";
    4421. 

  4421.             break;
    4422. 

  4422.         }
    4423. 

  4423. 

  4424.         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
    4425. 

  4425.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    4426. 

  4426.             "%s :  Presentation Indicator: %s",
    4427. 

  4427.             a_bigbuf,
    4428. 

  4428.             str);
    4429. 

  4429. 

  4430.         switch (oct & 0x03)
    4431. 

  4431.         {
    4432. 

  4432.         case 0: str = "User-provided, not screened"; break;
    4433. 

  4433.         case 1: str = "User-provided, verified and passed"; break;
    4434. 

  4434.         case 2: str = "User-provided, verified and failed"; break;
    4435. 

  4435.         default:
    4436. 

  4436.             str = "Network-provided";
    4437. 

  4437.             break;
    4438. 

  4438.         }
    4439. 

  4439. 

  4440.         other_decode_bitfield_value(a_bigbuf, oct, 0x1c, 8);
    4441. 

  4441.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    4442. 

  4442.             "%s :  Reserved",
    4443. 

  4443.             a_bigbuf);
    4444. 

  4444. 

  4445.         other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
    4446. 

  4446.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    4447. 

  4447.             "%s :  Screening Indicator: %s",
    4448. 

  4448.             a_bigbuf,
    4449. 

  4449.             str);
    4450. 

  4450. 

  4451.         curr_offset++;
    4452. 

  4452.     }
    4453. 

  4453. 

  4454.     poctets = tvb_get_ephemeral_string(tvb, curr_offset, len - (curr_offset - offset));
    4455. 

  4455. 

  4456.     my_dgt_tbcd_unpack(a_bigbuf, poctets, len - (curr_offset - offset),
    4457. 

  4457.         &Dgt_tbcd);
    4458. 

  4458. 

  4459.     proto_tree_add_string_format(tree, hf_ansi_a_clg_party_bcd_num,
    4460. 

  4460.         tvb, curr_offset, len - (curr_offset - offset),
    4461. 

  4461.         a_bigbuf,
    4462. 

  4462.         "BCD Digits: %s",
    4463. 

  4463.         a_bigbuf);
    4464. 

  4464. 

  4465.     g_snprintf(add_string, string_len, " - (%s)", a_bigbuf);
    4466. 

  4466. 

  4467.     curr_offset += len - (curr_offset - offset);
    4468. 

  4468. 

  4469.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    4470. 

  4470. 

  4471.     return(curr_offset - offset);
    4472. 

  4472. }
    4473. 

  4473. #endif
    4474. 

  4474. 

  4475. /*
    4476. 

  4476.  * IOS 6.2.2.54
    4477. 

  4477.  */
    4478. 

  4478. static guint8
    4479. 

  4479. elem_qos_params(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    4480. 

  4480. {
    4481. 

  4481.     guint8      oct;
    4482. 

  4482.     guint32     curr_offset;
    4483. 

  4483. 

  4484.     curr_offset = offset;
    4485. 

  4485. 

  4486.     oct = tvb_get_guint8(tvb, curr_offset);
    4487. 

  4487. 

  4488.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    4489. 

  4489.     proto_tree_add_text(tree,
    4490. 

  4490.         tvb, curr_offset, 1,
    4491. 

  4491.         "%s :  Reserved",
    4492. 

  4492.         a_bigbuf);
    4493. 

  4493. 

  4494.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    4495. 

  4495.     proto_tree_add_text(tree,
    4496. 

  4496.         tvb, curr_offset, 1,
    4497. 

  4497.         "%s :  Packet Priority: %u",
    4498. 

  4498.         a_bigbuf,
    4499. 

  4499.         oct & 0x0f);
    4500. 

  4500. 

  4501.     g_snprintf(add_string, string_len, " - (%u)", oct & 0x0f);
    4502. 

  4502. 

  4503.     curr_offset++;
    4504. 

  4504. 

  4505.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    4506. 

  4506. 

  4507.     return(curr_offset - offset);
    4508. 

  4508. }
    4509. 

  4509. 

  4510. /*
    4511. 

  4511.  * IOS 6.2.2.55
    4512. 

  4512.  */
    4513. 

  4513. static guint8
    4514. 

  4514. elem_cause_l3(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    4515. 

  4515. {
    4516. 

  4516.     guint8      oct;
    4517. 

  4517.     guint32     curr_offset;
    4518. 

  4518.     const gchar *str = NULL;
    4519. 

  4519. 

  4520.     curr_offset = offset;
    4521. 

  4521. 

  4522.     oct = tvb_get_guint8(tvb, curr_offset);
    4523. 

  4523. 

  4524.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    4525. 

  4525.     proto_tree_add_text(tree,
    4526. 

  4526.         tvb, curr_offset, 1,
    4527. 

  4527.         "%s :  Extension",
    4528. 

  4528.         a_bigbuf);
    4529. 

  4529. 

  4530.     switch ((oct & 0x60) >> 5)
    4531. 

  4531.     {
    4532. 

  4532.     case 0: str = "Standard as described in ITU Recommendation Q.931"; break;
    4533. 

  4533.     case 1: str = "Reserved for other international standards"; break;
    4534. 

  4534.     case 2: str = "National standard"; break;
    4535. 

  4535.     default:
    4536. 

  4536.         str = "Reserved for other international standards";
    4537. 

  4537.         break;
    4538. 

  4538.     }
    4539. 

  4539. 

  4540.     other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
    4541. 

  4541.     proto_tree_add_text(tree,
    4542. 

  4542.         tvb, curr_offset, 1,
    4543. 

  4543.         "%s :  Coding Standard: %s",
    4544. 

  4544.         a_bigbuf,
    4545. 

  4545.         str);
    4546. 

  4546. 

  4547.     other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
    4548. 

  4548.     proto_tree_add_text(tree,
    4549. 

  4549.         tvb, curr_offset, 1,
    4550. 

  4550.         "%s :  Reserved",
    4551. 

  4551.         a_bigbuf);
    4552. 

  4552. 

  4553.     switch (oct & 0x0f)
    4554. 

  4554.     {
    4555. 

  4555.     case 0: str = "User"; break;
    4556. 

  4556.     case 1: str = "Private network serving the local user"; break;
    4557. 

  4557.     case 2: str = "Public network serving the local user"; break;
    4558. 

  4558.     case 3: str = "Transit network"; break;
    4559. 

  4559.     case 4: str = "Public network serving the remote user"; break;
    4560. 

  4560.     case 5: str = "Private network serving the remote user"; break;
    4561. 

  4561.     case 7: str = "International network"; break;
    4562. 

  4562.     case 10: str = "Network beyond interworking point"; break;
    4563. 

  4563.     default:
    4564. 

  4564.         str = "Reserved";
    4565. 

  4565.         break;
    4566. 

  4566.     }
    4567. 

  4567. 

  4568.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    4569. 

  4569.     proto_tree_add_text(tree,
    4570. 

  4570.         tvb, curr_offset, 1,
    4571. 

  4571.         "%s :  Location: %s",
    4572. 

  4572.         a_bigbuf,
    4573. 

  4573.         str);
    4574. 

  4574. 

  4575.     curr_offset++;
    4576. 

  4576. 

  4577.     oct = tvb_get_guint8(tvb, curr_offset);
    4578. 

  4578. 

  4579.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    4580. 

  4580.     proto_tree_add_text(tree,
    4581. 

  4581.         tvb, curr_offset, 1,
    4582. 

  4582.         "%s :  Extension",
    4583. 

  4583.         a_bigbuf);
    4584. 

  4584. 

  4585.     switch ((oct & 0x70) >> 4)
    4586. 

  4586.     {
    4587. 

  4587.     case 0: str = "normal event"; break;
    4588. 

  4588.     case 1: str = "normal event"; break;
    4589. 

  4589.     case 2: str = "resource unavailable"; break;
    4590. 

  4590.     case 3: str = "service or option not available"; break;
    4591. 

  4591.     case 4: str = "service or option not implemented"; break;
    4592. 

  4592.     case 5: str = "invalid message (e.g., parameter out of range)"; break;
    4593. 

  4593.     case 6: str = "protocol error (e.g., unknown message)"; break;
    4594. 

  4594.     default:
    4595. 

  4595.         str = "interworking";
    4596. 

  4596.         break;
    4597. 

  4597.     }
    4598. 

  4598. 

  4599.     other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
    4600. 

  4600.     proto_tree_add_text(tree,
    4601. 

  4601.         tvb, curr_offset, 1,
    4602. 

  4602.         "%s :  Class: (%u) %s",
    4603. 

  4603.         a_bigbuf,
    4604. 

  4604.         (oct & 0x70) >> 4,
    4605. 

  4605.         str);
    4606. 

  4606. 

  4607.     switch (oct & 0x7f)
    4608. 

  4608.     {
    4609. 

  4609.     case 0x01: str = "Unassigned (unallocated) number"; break;
    4610. 

  4610.     case 0x03: str = "No route to destination"; break;
    4611. 

  4611.     case 0x06: str = "Channel unacceptable"; break;
    4612. 

  4612.     case 0x0F: str = "Procedure failed"; break;
    4613. 

  4613.     case 0x10: str = "Normal Clearing"; break;
    4614. 

  4614.     case 0x11: str = "User busy"; break;
    4615. 

  4615.     case 0x12: str = "No user responding"; break;
    4616. 

  4616.     case 0x13: str = "User alerting, no answer"; break;
    4617. 

  4617.     case 0x15: str = "Call rejected"; break;
    4618. 

  4618.     case 0x16: str = "Number changed New destination"; break;
    4619. 

  4619.     case 0x1A: str = "Non selected user clearing"; break;
    4620. 

  4620.     case 0x1B: str = "Destination out of order"; break;
    4621. 

  4621.     case 0x1C: str = "Invalid number format (incomplete number)"; break;
    4622. 

  4622.     case 0x1D: str = "Facility rejected"; break;
    4623. 

  4623.     case 0x1F: str = "Normal, unspecified"; break;
    4624. 

  4624.     case 0x22: str = "No circuit/channel available"; break;
    4625. 

  4625.     case 0x26: str = "Network out of order"; break;
    4626. 

  4626.     case 0x29: str = "Temporary failure"; break;
    4627. 

  4627.     case 0x2A: str = "Switching equipment congestion"; break;
    4628. 

  4628.     case 0x2B: str = "Access information discarded information element ids"; break;
    4629. 

  4629.     case 0x2C: str = "requested circuit/channel not available"; break;
    4630. 

  4630.     case 0x2F: str = "Resources unavailable, unspecified"; break;
    4631. 

  4631.     case 0x31: str = "Quality of service unavailable"; break;
    4632. 

  4632.     case 0x32: str = "Requested facility not subscribed"; break;
    4633. 

  4633.     case 0x33: str = "Request MUX option or rates unavailable"; break;
    4634. 

  4634.     case 0x39: str = "Bearer capability not authorized"; break;
    4635. 

  4635.     case 0x3A: str = "Bearer capability not presently available"; break;
    4636. 

  4636.     case 0x3B: str = "SSD Update Rejected"; break;
    4637. 

  4637.     case 0x3F: str = "Service or option not available, unspecified"; break;
    4638. 

  4638.     case 0x41: str = "Bearer service not implemented"; break;
    4639. 

  4639.     case 0x45: str = "Requested facility not implement"; break;
    4640. 

  4640.     case 0x46: str = "Only restricted digital information bearer capability is available"; break;
    4641. 

  4641.     case 0x4F: str = "Service or option not implemented, unspecified"; break;
    4642. 

  4642.     case 0x51: str = "Reserved"; break;
    4643. 

  4643.     case 0x58: str = "Incompatible destination incompatible parameter"; break;
    4644. 

  4644.     case 0x5B: str = "Invalid transit network selection"; break;
    4645. 

  4645.     case 0x5F: str = "Invalid message, unspecified"; break;
    4646. 

  4646.     case 0x60: str = "Mandatory information element error information element identifier(s)"; break;
    4647. 

  4647.     case 0x61: str = "Message type nonexistent or not implemented message type"; break;
    4648. 

  4648.     case 0x62: str = "Message not compatible with control state message type or message type nonexistent or not implemented"; break;
    4649. 

  4649.     case 0x64: str = "Invalid information element contents Information element Identifier(s)"; break;
    4650. 

  4650.     case 0x65: str = "Message not compatible with call state message type"; break;
    4651. 

  4651.     case 0x6F: str = "Protocol error, unspecified"; break;
    4652. 

  4652.     case 0x7F: str = "Interworking, unspecified"; break;
    4653. 

  4653.     default:
    4654. 

  4654.         str = "Reserved";
    4655. 

  4655.         break;
    4656. 

  4656.     }
    4657. 

  4657. 

  4658.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    4659. 

  4659.     proto_tree_add_text(tree,
    4660. 

  4660.         tvb, curr_offset, 1,
    4661. 

  4661.         "%s :  Value: (%u)",
    4662. 

  4662.         a_bigbuf,
    4663. 

  4663.         oct & 0x0f);
    4664. 

  4664. 

  4665.     g_snprintf(add_string, string_len, " - (%u) %s", oct & 0x7f, str);
    4666. 

  4666. 

  4667.     curr_offset++;
    4668. 

  4668. 

  4669.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    4670. 

  4670. 

  4671.     return(curr_offset - offset);
    4672. 

  4672. }
    4673. 

  4673. 

  4674. /*
    4675. 

  4675.  * IOS 6.2.2.56
    4676. 

  4676.  * A3/A7
    4677. 

  4677.  */
    4678. 

  4678. 

  4679. /*
    4680. 

  4680.  * IOS 6.2.2.57
    4681. 

  4681.  * A3/A7
    4682. 

  4682.  */
    4683. 

  4683. 

  4684. /*
    4685. 

  4685.  * IOS 6.2.2.58
    4686. 

  4686.  */
    4687. 

  4687. static guint8
    4688. 

  4688. elem_xmode(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    4689. 

  4689. {
    4690. 

  4690.     guint8      oct;
    4691. 

  4691.     guint32     curr_offset;
    4692. 

  4692. 

  4693.     curr_offset = offset;
    4694. 

  4694. 

  4695.     oct = tvb_get_guint8(tvb, curr_offset);
    4696. 

  4696. 

  4697.     other_decode_bitfield_value(a_bigbuf, oct, 0xfe, 8);
    4698. 

  4698.     proto_tree_add_text(tree,
    4699. 

  4699.         tvb, curr_offset, 1,
    4700. 

  4700.         "%s :  Reserved",
    4701. 

  4701.         a_bigbuf);
    4702. 

  4702. 

  4703.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    4704. 

  4704.     proto_tree_add_text(tree,
    4705. 

  4705.         tvb, curr_offset, 1,
    4706. 

  4706.         "%s :  TFO Mode: %s",
    4707. 

  4707.         a_bigbuf,
    4708. 

  4708.         (oct & 0x01) ? "TFO" : "tandem");
    4709. 

  4709. 

  4710.     g_snprintf(add_string, string_len, " - (%s)",
    4711. 

  4711.         (oct & 0x01) ? "TFO" : "tandem");
    4712. 

  4712. 

  4713.     curr_offset++;
    4714. 

  4714. 

  4715.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    4716. 

  4716. 

  4717.     return(curr_offset - offset);
    4718. 

  4718. }
    4719. 

  4719. 

  4720. /*
    4721. 

  4721.  * IOS 6.2.2.59
    4722. 

  4722.  * UNUSED
    4723. 

  4723.  */
    4724. 

  4724. 

  4725. /*
    4726. 

  4726.  * IOS 6.2.2.60
    4727. 

  4727.  * NO ASSOCIATED DATA
    4728. 

  4728.  */
    4729. 

  4729. 

  4730. /*
    4731. 

  4731.  * IOS 6.2.2.61
    4732. 

  4732.  */
    4733. 

  4733. static guint8
    4734. 

  4734. elem_reg_type(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    4735. 

  4735. {
    4736. 

  4736.     guint8      oct;
    4737. 

  4737.     guint32     curr_offset;
    4738. 

  4738.     const gchar *str;
    4739. 

  4739. 

  4740.     curr_offset = offset;
    4741. 

  4741. 

  4742.     oct = tvb_get_guint8(tvb, curr_offset);
    4743. 

  4743. 

  4744.     switch (oct)
    4745. 

  4745.     {
    4746. 

  4746.     case 0x00: str = "Timer-based"; break;
    4747. 

  4747.     case 0x01: str = "Power-up"; break;
    4748. 

  4748.     case 0x02: str = "Zone-based"; break;
    4749. 

  4749.     case 0x03: str = "Power-down"; break;
    4750. 

  4750.     case 0x04: str = "Parameter-change"; break;
    4751. 

  4751.     case 0x05: str = "Ordered"; break;
    4752. 

  4752.     case 0x06: str = "Distance-based"; break;
    4753. 

  4753.     case 0x07: str = "User Zone-based"; break;
    4754. 

  4754.     case 0x09: str = "BCMC Registration"; break;
    4755. 

  4755.     default:
    4756. 

  4756.         str = "Reserved";
    4757. 

  4757.         break;
    4758. 

  4758.     }
    4759. 

  4759. 

  4760.     proto_tree_add_text(tree,
    4761. 

  4761.         tvb, curr_offset, 1,
    4762. 

  4762.         "Location Registration Type: %s",
    4763. 

  4763.         str);
    4764. 

  4764. 

  4765.     g_snprintf(add_string, string_len, " - (%s)", str);
    4766. 

  4766. 

  4767.     curr_offset++;
    4768. 

  4768. 

  4769.     /* no length check possible */
    4770. 

  4770. 

  4771.     return(curr_offset - offset);
    4772. 

  4772. }
    4773. 

  4773. 

  4774. /*
    4775. 

  4775.  * IOS 6.2.2.62
    4776. 

  4776.  */
    4777. 

  4777. static guint8
    4778. 

  4778. elem_tag(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    4779. 

  4779. {
    4780. 

  4780.     guint32     value;
    4781. 

  4781.     guint32     curr_offset;
    4782. 

  4782. 

  4783.     curr_offset = offset;
    4784. 

  4784. 

  4785.     value = tvb_get_ntohl(tvb, curr_offset);
    4786. 

  4786. 

  4787.     proto_tree_add_text(tree,
    4788. 

  4788.         tvb, curr_offset, 4,
    4789. 

  4789.         "Tag Value: %u",
    4790. 

  4790.         value);
    4791. 

  4791. 

  4792.     g_snprintf(add_string, string_len, " - (%u)", value);
    4793. 

  4793. 

  4794.     curr_offset += 4;
    4795. 

  4795. 

  4796.     /* no length check possible */
    4797. 

  4797. 

  4798.     return(curr_offset - offset);
    4799. 

  4799. }
    4800. 

  4800. 

  4801. /*
    4802. 

  4802.  * IOS 6.2.2.63
    4803. 

  4803.  */
    4804. 

  4804. static guint8
    4805. 

  4805. elem_hho_params(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    4806. 

  4806. {
    4807. 

  4807.     guint8      oct;
    4808. 

  4808.     gint        temp_int;
    4809. 

  4809.     guint32     curr_offset;
    4810. 

  4810.     const gchar *str;
    4811. 

  4811. 

  4812.     curr_offset = offset;
    4813. 

  4813. 

  4814.     oct = tvb_get_guint8(tvb, curr_offset);
    4815. 

  4815. 

  4816.     other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    4817. 

  4817.     proto_tree_add_text(tree,
    4818. 

  4818.         tvb, curr_offset, 1,
    4819. 

  4819.         "%s :  Reserved",
    4820. 

  4820.         a_bigbuf);
    4821. 

  4821. 

  4822.     temp_int = oct & 0x1f;
    4823. 

  4823.     if ((temp_int < 0) || (temp_int >= (gint) NUM_BAND_CLASS_STR))
    4824. 

  4824.     {
    4825. 

  4825.         str = "Reserved";
    4826. 

  4826.     }
    4827. 

  4827.     else
    4828. 

  4828.     {
    4829. 

  4829.         str = band_class_str[temp_int];
    4830. 

  4830.     }
    4831. 

  4831. 

  4832.     other_decode_bitfield_value(a_bigbuf, oct, 0x1f, 8);
    4833. 

  4833.     proto_tree_add_text(tree,
    4834. 

  4834.         tvb, curr_offset, 1,
    4835. 

  4835.         "%s :  Band Class: %s",
    4836. 

  4836.         a_bigbuf,
    4837. 

  4837.         str);
    4838. 

  4838. 

  4839.     curr_offset++;
    4840. 

  4840. 

  4841.     g_snprintf(add_string, string_len, " - (%s)", str);
    4842. 

  4842. 

  4843.     oct = tvb_get_guint8(tvb, curr_offset);
    4844. 

  4844. 

  4845.     other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    4846. 

  4846.     proto_tree_add_text(tree,
    4847. 

  4847.         tvb, curr_offset, 1,
    4848. 

  4848.         "%s :  Number of Preamble Frames: %u",
    4849. 

  4849.         a_bigbuf,
    4850. 

  4850.         (oct & 0xe0) >> 5);
    4851. 

  4851. 

  4852.     other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
    4853. 

  4853.     proto_tree_add_text(tree,
    4854. 

  4854.         tvb, curr_offset, 1,
    4855. 

  4855.         "%s :  Reset L2: %s Layer 2 Acknowledgement",
    4856. 

  4856.         a_bigbuf,
    4857. 

  4857.         (oct & 0x10) ? "Reset" : "Do not reset");
    4858. 

  4858. 

  4859.     other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    4860. 

  4860.     proto_tree_add_text(tree,
    4861. 

  4861.         tvb, curr_offset, 1,
    4862. 

  4862.         "%s :  Reset FPC: %s counters",
    4863. 

  4863.         a_bigbuf,
    4864. 

  4864.         (oct & 0x10) ? "Reset" : "Do not reset");
    4865. 

  4865. 

  4866.     switch ((oct & 0x06) >> 1)
    4867. 

  4867.     {
    4868. 

  4868.     case 0: str = "Encryption disabled"; break;
    4869. 

  4869.     case 1: str = "Encryption enabled"; break;
    4870. 

  4870.     default:
    4871. 

  4871.         str = "Unknown";
    4872. 

  4872.         break;
    4873. 

  4873.     }
    4874. 

  4874. 

  4875.     other_decode_bitfield_value(a_bigbuf, oct, 0x06, 8);
    4876. 

  4876.     proto_tree_add_text(tree,
    4877. 

  4877.         tvb, curr_offset, 1,
    4878. 

  4878.         "%s :  Encryption Mode: %s",
    4879. 

  4879.         a_bigbuf,
    4880. 

  4880.         str);
    4881. 

  4881. 

  4882.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    4883. 

  4883.     proto_tree_add_text(tree,
    4884. 

  4884.         tvb, curr_offset, 1,
    4885. 

  4885.         "%s :  Private LCM: %s Private Long Code Mask",
    4886. 

  4886.         a_bigbuf,
    4887. 

  4887.         (oct & 0x01) ? "Use" : "Do not use");
    4888. 

  4888. 

  4889.     curr_offset++;
    4890. 

  4890. 

  4891.     oct = tvb_get_guint8(tvb, curr_offset);
    4892. 

  4892. 

  4893.     switch (global_a_variant)
    4894. 

  4894.     {
    4895. 

  4895.     case A_VARIANT_IOS401:
    4896. 

  4896.         other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    4897. 

  4897.         proto_tree_add_text(tree,
    4898. 

  4898.             tvb, curr_offset, 1,
    4899. 

  4899.             "%s :  Reserved",
    4900. 

  4900.             a_bigbuf);
    4901. 

  4901.         break;
    4902. 

  4902. 

  4903.     case A_VARIANT_IOS501:
    4904. 

  4904.         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    4905. 

  4905.         proto_tree_add_text(tree,
    4906. 

  4906.             tvb, curr_offset, 1,
    4907. 

  4907.             "%s :  Rev_Pwr_Cntl_Delay_Incl",
    4908. 

  4908.             a_bigbuf);
    4909. 

  4909. 

  4910.         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
    4911. 

  4911.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    4912. 

  4912.             "%s :  Rev_Pwr_Cntl_Delay",
    4913. 

  4913.             a_bigbuf);
    4914. 

  4914.         break;
    4915. 

  4915.     }
    4916. 

  4916. 

  4917.     other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
    4918. 

  4918.     proto_tree_add_text(tree,
    4919. 

  4919.         tvb, curr_offset, 1,
    4920. 

  4920.         "%s :  Nom_Pwr_Ext",
    4921. 

  4921.         a_bigbuf);
    4922. 

  4922. 

  4923.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    4924. 

  4924.     proto_tree_add_text(tree,
    4925. 

  4925.         tvb, curr_offset, 1,
    4926. 

  4926.         "%s :  Nom_Pwr: %u",
    4927. 

  4927.         a_bigbuf,
    4928. 

  4928.         oct & 0x0f);
    4929. 

  4929. 

  4930.     curr_offset++;
    4931. 

  4931. 

  4932.     oct = tvb_get_guint8(tvb, curr_offset);
    4933. 

  4933. 

  4934.     other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
    4935. 

  4935.     proto_tree_add_text(tree,
    4936. 

  4936.         tvb, curr_offset, 1,
    4937. 

  4937.         "%s :  Reserved",
    4938. 

  4938.         a_bigbuf);
    4939. 

  4939. 

  4940.     other_decode_bitfield_value(a_bigbuf, oct, 0x3e, 8);
    4941. 

  4941.     proto_tree_add_text(tree,
    4942. 

  4942.         tvb, curr_offset, 1,
    4943. 

  4943.         "%s :  FPC Subchannel Information: %u",
    4944. 

  4944.         a_bigbuf,
    4945. 

  4945.         (oct & 0x3e) >> 1);
    4946. 

  4946. 

  4947.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    4948. 

  4948.     proto_tree_add_text(tree,
    4949. 

  4949.         tvb, curr_offset, 1,
    4950. 

  4950.         "%s :  FPC Subchannel Information Included",
    4951. 

  4951.         a_bigbuf);
    4952. 

  4952. 

  4953.     curr_offset++;
    4954. 

  4954. 

  4955.     oct = tvb_get_guint8(tvb, curr_offset);
    4956. 

  4956. 

  4957.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    4958. 

  4958.     proto_tree_add_text(tree,
    4959. 

  4959.         tvb, curr_offset, 1,
    4960. 

  4960.         "%s :  Reserved",
    4961. 

  4961.         a_bigbuf);
    4962. 

  4962. 

  4963.     other_decode_bitfield_value(a_bigbuf, oct, 0x0e, 8);
    4964. 

  4964.     proto_tree_add_text(tree,
    4965. 

  4965.         tvb, curr_offset, 1,
    4966. 

  4966.         "%s :  Power Control Step: %u",
    4967. 

  4967.         a_bigbuf,
    4968. 

  4968.         (oct & 0x0e) >> 1);
    4969. 

  4969. 

  4970.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    4971. 

  4971.     proto_tree_add_text(tree,
    4972. 

  4972.         tvb, curr_offset, 1,
    4973. 

  4973.         "%s :  Power Control Step Included",
    4974. 

  4974.         a_bigbuf);
    4975. 

  4975. 

  4976.     curr_offset++;
    4977. 

  4977. 

  4978.     /* no length check possible */
    4979. 

  4979. 

  4980.     return(curr_offset - offset);
    4981. 

  4981. }
    4982. 

  4982. 

  4983. /*
    4984. 

  4984.  * IOS 6.2.2.64
    4985. 

  4985.  * UNUSED
    4986. 

  4986.  */
    4987. 

  4987. 

  4988. /*
    4989. 

  4989.  * IOS 6.2.2.65
    4990. 

  4990.  */
    4991. 

  4991. static guint8
    4992. 

  4992. elem_sw_ver(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    4993. 

  4993. {
    4994. 

  4994.     guint8      major, minor, point;
    4995. 

  4995.     guint32     curr_offset;
    4996. 

  4996. 

  4997.     curr_offset = offset;
    4998. 

  4998. 

  4999.     major = tvb_get_guint8(tvb, curr_offset);
    5000. 

  5000. 

  5001.     proto_tree_add_text(tree,
    5002. 

  5002.         tvb, curr_offset, 1,
    5003. 

  5003.         "IOS Major Revision Level: %u",
    5004. 

  5004.         major);
    5005. 

  5005. 

  5006.     curr_offset++;
    5007. 

  5007. 

  5008.     minor = tvb_get_guint8(tvb, curr_offset);
    5009. 

  5009. 

  5010.     proto_tree_add_text(tree,
    5011. 

  5011.         tvb, curr_offset, 1,
    5012. 

  5012.         "IOS Minor Revision Level: %u",
    5013. 

  5013.         minor);
    5014. 

  5014. 

  5015.     curr_offset++;
    5016. 

  5016. 

  5017.     point = tvb_get_guint8(tvb, curr_offset);
    5018. 

  5018. 

  5019.     proto_tree_add_text(tree,
    5020. 

  5020.         tvb, curr_offset, 1,
    5021. 

  5021.         "IOS Point Revision Level: %u",
    5022. 

  5022.         point);
    5023. 

  5023. 

  5024.     curr_offset++;
    5025. 

  5025. 

  5026.     g_snprintf(add_string, string_len, " - (IOS %u.%u.%u)", major, minor, point);
    5027. 

  5027. 

  5028.     if (len > 3)
    5029. 

  5029.     {
    5030. 

  5030.         proto_tree_add_text(tree, tvb, curr_offset, len - 3,
    5031. 

  5031.             "Manufacturer/Carrier Software Information");
    5032. 

  5032. 

  5033.         curr_offset += len - 3;
    5034. 

  5034.     }
    5035. 

  5035. 

  5036.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    5037. 

  5037. 

  5038.     return(curr_offset - offset);
    5039. 

  5039. }
    5040. 

  5040. 

  5041. /*
    5042. 

  5042.  * IOS 6.2.2.66
    5043. 

  5043.  */
    5044. 

  5044. static guint8
    5045. 

  5045. elem_so(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
    5046. 

  5046. {
    5047. 

  5047.     guint16     value;
    5048. 

  5048.     guint32     curr_offset;
    5049. 

  5049. 

  5050.     curr_offset = offset;
    5051. 

  5051. 

  5052.     value = tvb_get_ntohs(tvb, curr_offset);
    5053. 

  5053. 

  5054.     other_decode_bitfield_value(a_bigbuf, value, 0x8000, 16);
    5055. 

  5055.     proto_tree_add_text(tree,
    5056. 

  5056.         tvb, curr_offset, 2,
    5057. 

  5057.         "%s :  Proprietary Indicator",
    5058. 

  5058.         a_bigbuf);
    5059. 

  5059. 

  5060.     other_decode_bitfield_value(a_bigbuf, value, 0x7000, 16);
    5061. 

  5061.     proto_tree_add_text(tree,
    5062. 

  5062.         tvb, curr_offset, 2,
    5063. 

  5063.         "%s :  Service Option Revision",
    5064. 

  5064.         a_bigbuf);
    5065. 

  5065. 

  5066.     other_decode_bitfield_value(a_bigbuf, value, 0x0fff, 16);
    5067. 

  5067.     proto_tree_add_text(tree,
    5068. 

  5068.         tvb, curr_offset, 2,
    5069. 

  5069.         "%s :  Base Service Option Number",
    5070. 

  5070.         a_bigbuf);
    5071. 

  5071. 

  5072.     g_snprintf(add_string, string_len, " - (%u) (0x%04x)", value, value);
    5073. 

  5073. 

  5074.     proto_tree_add_uint_format(tree, hf_ansi_a_so, tvb,
    5075. 

  5075.         curr_offset, 2, value,
    5076. 

  5076.         "%s %s",
    5077. 

  5077.         &add_string[3],
    5078. 

  5078.         ansi_a_so_int_to_str(value));
    5079. 

  5079. 

  5080.     curr_offset += 2;
    5081. 

  5081. 

  5082.     /* no length check possible */
    5083. 

  5083. 

  5084.     return(curr_offset - offset);
    5085. 

  5085. }
    5086. 

  5086. 

  5087. /*
    5088. 

  5088.  * IOS 5 4.2.73
    5089. 

  5089.  */
    5090. 

  5090. static guint8
    5091. 

  5091. elem_soci(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    5092. 

  5092. {
    5093. 

  5093.     guint8      oct;
    5094. 

  5094.     guint32     curr_offset;
    5095. 

  5095. 

  5096.     curr_offset = offset;
    5097. 

  5097. 

  5098.     oct = tvb_get_guint8(tvb, curr_offset);
    5099. 

  5099. 

  5100.     other_decode_bitfield_value(a_bigbuf, oct, 0xf8, 8);
    5101. 

  5101.     proto_tree_add_text(tree,
    5102. 

  5102.         tvb, curr_offset, 1,
    5103. 

  5103.         "%s :  Reserved",
    5104. 

  5104.         a_bigbuf);
    5105. 

  5105. 

  5106.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    5107. 

  5107.     proto_tree_add_text(tree,
    5108. 

  5108.         tvb, curr_offset, 1,
    5109. 

  5109.         "%s :  SOCI: %u",
    5110. 

  5110.         a_bigbuf,
    5111. 

  5111.         oct & 0x07);
    5112. 

  5112. 

  5113.     g_snprintf(add_string, string_len, " - (%u)", oct);
    5114. 

  5114. 

  5115.     curr_offset++;
    5116. 

  5116. 

  5117.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    5118. 

  5118. 

  5119.     return(curr_offset - offset);
    5120. 

  5120. }
    5121. 

  5121. 

  5122. /*
    5123. 

  5123.  * IOS 5 4.2.74
    5124. 

  5124.  */
    5125. 

  5125. static guint8
    5126. 

  5126. elem_so_list(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    5127. 

  5127. {
    5128. 

  5128.     guint8      oct;
    5129. 

  5129.     guint8      num_so;
    5130. 

  5130.     guint8      inst;
    5131. 

  5131.     guint32     curr_offset;
    5132. 

  5132.     proto_item  *item;
    5133. 

  5133.     proto_tree  *subtree;
    5134. 

  5134. 

  5135.     curr_offset = offset;
    5136. 

  5136. 

  5137.     num_so = tvb_get_guint8(tvb, curr_offset);
    5138. 

  5138. 

  5139.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5140. 

  5140.         "Number of Service Option instances: %u",
    5141. 

  5141.         num_so);
    5142. 

  5142. 

  5143.     /*
    5144. 

  5144.      * this is in case we leave the function before the
    5145. 

  5145.      * loop through the instances
    5146. 

  5146.      */
    5147. 

  5147.     g_snprintf(add_string, string_len, " - %u service options", num_so);
    5148. 

  5148. 

  5149.     curr_offset++;
    5150. 

  5150. 

  5151.     NO_MORE_DATA_CHECK(len);
    5152. 

  5152. 

  5153.     SHORT_DATA_CHECK(len - (curr_offset - offset), 3);
    5154. 

  5154. 

  5155.     inst = 1;
    5156. 

  5156. 

  5157.     do
    5158. 

  5158.     {
    5159. 

  5159.         item =
    5160. 

  5160.             proto_tree_add_text(tree,
    5161. 

  5161.                 tvb, curr_offset, 1,
    5162. 

  5162.                 "Service Option Instance [%u]",
    5163. 

  5163.                 inst);
    5164. 

  5164. 

  5165.         subtree = proto_item_add_subtree(item, ett_so_list);
    5166. 

  5166. 

  5167.         oct = tvb_get_guint8(tvb, curr_offset);
    5168. 

  5168. 

  5169.         other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
    5170. 

  5170.         proto_tree_add_text(subtree,
    5171. 

  5171.             tvb, curr_offset, 1,
    5172. 

  5172.             "%s :  Reserved",
    5173. 

  5173.             a_bigbuf);
    5174. 

  5174. 

  5175.         other_decode_bitfield_value(a_bigbuf, oct, 0x38, 8);
    5176. 

  5176.         proto_tree_add_text(subtree,
    5177. 

  5177.             tvb, curr_offset, 1,
    5178. 

  5178.             "%s :  SR_ID: %u",
    5179. 

  5179.             a_bigbuf,
    5180. 

  5180.             (oct & 0x38) >> 3);
    5181. 

  5181. 

  5182.         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    5183. 

  5183.         proto_tree_add_text(subtree,
    5184. 

  5184.             tvb, curr_offset, 1,
    5185. 

  5185.             "%s :  SOCI: %u",
    5186. 

  5186.             a_bigbuf,
    5187. 

  5187.             oct & 0x07);
    5188. 

  5188. 

  5189.         curr_offset++;
    5190. 

  5190. 

  5191.         curr_offset += elem_so(tvb, pinfo, subtree, curr_offset, len, add_string, string_len);
    5192. 

  5192.         add_string[0] = '\0';
    5193. 

  5193. 

  5194.         inst++;
    5195. 

  5195.     }
    5196. 

  5196.     while ((len - (curr_offset - offset)) >= 3);
    5197. 

  5197. 

  5198.     /*
    5199. 

  5199.      * this is because 'add_string' was used by 'elem_so()'
    5200. 

  5200.      */
    5201. 

  5201.     g_snprintf(add_string, string_len, " - %u service options", num_so);
    5202. 

  5202. 

  5203.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    5204. 

  5204. 

  5205.     return(curr_offset - offset);
    5206. 

  5206. }
    5207. 

  5207. 

  5208. /*
    5209. 

  5209.  * IOS 5 4.2.70
    5210. 

  5210.  */
    5211. 

  5211. static guint8
    5212. 

  5212. elem_acc_net_id(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    5213. 

  5213. {
    5214. 

  5214.     guint32     value;
    5215. 

  5215.     guint32     sid, nid, pzid;
    5216. 

  5216.     guint32     curr_offset;
    5217. 

  5217. 

  5218.     curr_offset = offset;
    5219. 

  5219. 

  5220.     value = tvb_get_ntohs(tvb, curr_offset);
    5221. 

  5221.     sid = value & 0x7fff;
    5222. 

  5222. 

  5223.     other_decode_bitfield_value(a_bigbuf, value >> 8, 0x80, 8);
    5224. 

  5224.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5225. 

  5225.         "%s :  Reserved",
    5226. 

  5226.         a_bigbuf);
    5227. 

  5227. 

  5228.     other_decode_bitfield_value(a_bigbuf, value >> 8, 0x7f, 8);
    5229. 

  5229.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5230. 

  5230.         "%s :  SID (MSB), %u",
    5231. 

  5231.         a_bigbuf,
    5232. 

  5232.         sid);
    5233. 

  5233. 

  5234.     other_decode_bitfield_value(a_bigbuf, value & 0x00ff, 0xff, 8);
    5235. 

  5235.     proto_tree_add_text(tree, tvb, curr_offset + 1, 1,
    5236. 

  5236.         "%s :  SID (LSB)",
    5237. 

  5237.         a_bigbuf);
    5238. 

  5238. 

  5239.     curr_offset += 2;
    5240. 

  5240. 

  5241.     nid = tvb_get_ntohs(tvb, curr_offset);
    5242. 

  5242. 

  5243.     proto_tree_add_text(tree,
    5244. 

  5244.         tvb, curr_offset, 2,
    5245. 

  5245.         "NID: %u",
    5246. 

  5246.         nid);
    5247. 

  5247. 

  5248.     curr_offset += 2;
    5249. 

  5249. 

  5250.     pzid = tvb_get_ntohs(tvb, curr_offset);
    5251. 

  5251. 

  5252.     proto_tree_add_text(tree,
    5253. 

  5253.         tvb, curr_offset, 2,
    5254. 

  5254.         "PZID: %u",
    5255. 

  5255.         pzid);
    5256. 

  5256. 

  5257.     curr_offset += 2;
    5258. 

  5258. 

  5259.     g_snprintf(add_string, string_len, " - (SID/NID/PZID: %u/%u/%u)", sid, nid, pzid);
    5260. 

  5260. 

  5261.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    5262. 

  5262. 

  5263.     return(curr_offset - offset);
    5264. 

  5264. }
    5265. 

  5265. 

  5266. 

  5267. #define ADDS_APP_UNKNOWN        0x00
    5268. 

  5268. #define ADDS_APP_ADS            0x01
    5269. 

  5269. #define ADDS_APP_FAX            0x02
    5270. 

  5270. #define ADDS_APP_SMS            0x03
    5271. 

  5271. #define ADDS_APP_OTA            0x04
    5272. 

  5272. #define ADDS_APP_PDS            0x05            /* aka PLD */
    5273. 

  5273. #define ADDS_APP_SDB            0x06
    5274. 

  5274. #define ADDS_APP_HRPD           0x07
    5275. 

  5275. #define ADDS_APP_EXT_INTL       0x3E
    5276. 

  5276. #define ADDS_APP_EXT            0x3F
    5277. 

  5277. 

  5278. static const value_string ansi_a_adds_strings[] = {
    5279. 

  5279.     { ADDS_APP_UNKNOWN,         "UNKNOWN" },
    5280. 

  5280.     { ADDS_APP_ADS,             "ADS" },
    5281. 

  5281.     { ADDS_APP_FAX,             "FAX" },
    5282. 

  5282.     { ADDS_APP_SMS,             "SMS" },
    5283. 

  5283.     { ADDS_APP_OTA,             "OTA" },
    5284. 

  5284.     { ADDS_APP_PDS,             "PDS" },
    5285. 

  5285.     { ADDS_APP_SDB,             "SDB" },
    5286. 

  5286.     { ADDS_APP_HRPD,            "HRPD" },
    5287. 

  5287.     { ADDS_APP_EXT_INTL,        "EXT_INTL" },
    5288. 

  5288.     { ADDS_APP_EXT,             "EXT" },
    5289. 

  5289.     { 0,                        NULL}
    5290. 

  5290. };
    5291. 

  5291. 

  5292. /*
    5293. 

  5293.  * IOS 6.2.2.67
    5294. 

  5294.  */
    5295. 

  5295. static guint8
    5296. 

  5296. elem_adds_user_part(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    5297. 

  5297. {
    5298. 

  5298.     guint8      oct;
    5299. 

  5299.     guint32     value;
    5300. 

  5300.     guint8      adds_app;
    5301. 

  5301.     guint32     curr_offset;
    5302. 

  5302.     const gchar *str;
    5303. 

  5303.     tvbuff_t    *adds_tvb;
    5304. 

  5304.     gint        idx;
    5305. 

  5305.     proto_tree  *subtree;
    5306. 

  5306.     proto_item  *item;
    5307. 

  5307. 

  5308.     curr_offset = offset;
    5309. 

  5309. 

  5310.     oct = tvb_get_guint8(tvb, curr_offset);
    5311. 

  5311. 

  5312.     other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
    5313. 

  5313.     proto_tree_add_text(tree,
    5314. 

  5314.         tvb, curr_offset, 1,
    5315. 

  5315.         "%s :  Reserved",
    5316. 

  5316.         a_bigbuf);
    5317. 

  5317. 

  5318.     adds_app = oct & 0x3f;
    5319. 

  5319. 

  5320.     str = try_val_to_str_idx((guint32) adds_app, ansi_a_adds_strings, &idx);
    5321. 

  5321.     if (str == NULL)
    5322. 

  5322.     {
    5323. 

  5323.         str = "Reserved";
    5324. 

  5324.     }
    5325. 

  5325.     g_snprintf(add_string, string_len, " - (%s)", str);
    5326. 

  5326. 

  5327.     other_decode_bitfield_value(a_bigbuf, oct, 0x3f, 8);
    5328. 

  5328.     proto_tree_add_text(tree,
    5329. 

  5329.         tvb, curr_offset, 1,
    5330. 

  5330.         "%s :  Data Burst Type: %s",
    5331. 

  5331.         a_bigbuf,
    5332. 

  5332.         str);
    5333. 

  5333. 

  5334.     curr_offset++;
    5335. 

  5335. 

  5336.     item =
    5337. 

  5337.         proto_tree_add_text(tree, tvb, curr_offset, len - 1,
    5338. 

  5338.             "Application Data Message");
    5339. 

  5339. 

  5340.     subtree = proto_item_add_subtree(item, ett_adds_user_part);
    5341. 

  5341. 

  5342.     switch (adds_app)
    5343. 

  5343.     {
    5344. 

  5344.     case ADDS_APP_SMS:
    5345. 

  5345.         adds_tvb = tvb_new_subset(tvb, curr_offset, len - 1, len - 1);
    5346. 

  5346. 

  5347.         dissector_try_uint(is637_dissector_table,
    5348. 

  5348.             0, adds_tvb, pinfo, g_tree);
    5349. 

  5349. 

  5350.         curr_offset += (len - 1);
    5351. 

  5351.         break;
    5352. 

  5352. 

  5353.     case ADDS_APP_OTA:
    5354. 

  5354.         adds_tvb = tvb_new_subset(tvb, curr_offset, len - 1, len - 1);
    5355. 

  5355. 

  5356.         dissector_try_uint(is683_dissector_table,
    5357. 

  5357.             (pinfo->p2p_dir == P2P_DIR_RECV), adds_tvb, pinfo, g_tree);
    5358. 

  5358. 

  5359.         curr_offset += (len - 1);
    5360. 

  5360.         break;
    5361. 

  5361. 

  5362.     case ADDS_APP_PDS:
    5363. 

  5363.         adds_tvb = tvb_new_subset(tvb, curr_offset, len - 1, len - 1);
    5364. 

  5364. 

  5365.         dissector_try_uint(is801_dissector_table,
    5366. 

  5366.             (pinfo->p2p_dir == P2P_DIR_RECV), adds_tvb, pinfo, g_tree);
    5367. 

  5367. 

  5368.         curr_offset += (len - 1);
    5369. 

  5369.         break;
    5370. 

  5370. 

  5371.     case ADDS_APP_SDB:
    5372. 

  5372.         /*
    5373. 

  5373.          * no SDB dissector, push to GRE/A11 dissector ?
    5374. 

  5374.          */
    5375. 

  5375.         curr_offset += (len - 1);
    5376. 

  5376.         break;
    5377. 

  5377. 

  5378.     case ADDS_APP_EXT_INTL:
    5379. 

  5379.         /*
    5380. 

  5380.          * no generic External International dissector
    5381. 

  5381.          */
    5382. 

  5382.         value = tvb_get_ntohs(tvb, curr_offset);
    5383. 

  5383. 

  5384.         proto_tree_add_text(subtree,
    5385. 

  5385.             tvb, curr_offset, 2,
    5386. 

  5386.             "Extended Burst Type - International: 0x%04x", value);
    5387. 

  5387. 

  5388.         curr_offset += 2;
    5389. 

  5389. 

  5390.         proto_tree_add_text(tree, tvb, curr_offset, len - (curr_offset - offset),
    5391. 

  5391.             "Data");
    5392. 

  5392. 

  5393.         curr_offset += len - (curr_offset - offset);
    5394. 

  5394.         break;
    5395. 

  5395. 

  5396.     case ADDS_APP_EXT:
    5397. 

  5397.         value = tvb_get_ntohs(tvb, curr_offset);
    5398. 

  5398. 

  5399.         proto_tree_add_text(subtree,
    5400. 

  5400.             tvb, curr_offset, 2,
    5401. 

  5401.             "Extended Burst Type: 0x%04x", value);
    5402. 

  5402. 

  5403.         curr_offset += 2;
    5404. 

  5404. 

  5405.         proto_tree_add_text(subtree, tvb, curr_offset, len - (curr_offset - offset),
    5406. 

  5406.             "Data");
    5407. 

  5407. 

  5408.         curr_offset += len - (curr_offset - offset);
    5409. 

  5409.         break;
    5410. 

  5410. 

  5411.     default:
    5412. 

  5412.         /*
    5413. 

  5413.          * no sub-dissectors
    5414. 

  5414.          */
    5415. 

  5415.         curr_offset += (len - 1);
    5416. 

  5416.         break;
    5417. 

  5417.     }
    5418. 

  5418. 

  5419.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    5420. 

  5420. 

  5421.     return(curr_offset - offset);
    5422. 

  5422. }
    5423. 

  5423. 

  5424. /*
    5425. 

  5425.  * IOS 5 4.2.75
    5426. 

  5426.  */
    5427. 

  5427. static guint8
    5428. 

  5428. elem_amps_hho_param(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    5429. 

  5429. {
    5430. 

  5430.     guint8      oct;
    5431. 

  5431.     guint32     curr_offset;
    5432. 

  5432. 

  5433.     curr_offset = offset;
    5434. 

  5434. 

  5435.     oct = tvb_get_guint8(tvb, curr_offset);
    5436. 

  5436. 

  5437.     other_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8);
    5438. 

  5438.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5439. 

  5439.         "%s :  Reserved",
    5440. 

  5440.         a_bigbuf);
    5441. 

  5441. 

  5442.     other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
    5443. 

  5443.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5444. 

  5444.         "%s :  Encryption Mode: (%u) %s",
    5445. 

  5445.         a_bigbuf,
    5446. 

  5446.         oct & 0x03,
    5447. 

  5447.         (oct & 0x03) ? "enabled" : "disabled");
    5448. 

  5448. 

  5449.     curr_offset++;
    5450. 

  5450. 

  5451.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    5452. 

  5452. 

  5453.     return(curr_offset - offset);
    5454. 

  5454. }
    5455. 

  5455. 

  5456. /*
    5457. 

  5457.  * IOS 6.2.2.68
    5458. 

  5458.  */
    5459. 

  5459. static guint8
    5460. 

  5460. elem_is2000_scr(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    5461. 

  5461. {
    5462. 

  5462.     guint8      oct, num_con_rec, ii;
    5463. 

  5463.     guint8      bit_mask, bit_offset;
    5464. 

  5464.     guint32     curr_offset, saved_offset;
    5465. 

  5465.     guint32     value;
    5466. 

  5466.     guint       is2000_portion_len;
    5467. 

  5467.     proto_tree  *scr_subtree, *subtree;
    5468. 

  5468.     proto_item  *item = NULL;
    5469. 

  5469.     const gchar *str = NULL;
    5470. 

  5470. 

  5471.     curr_offset = offset;
    5472. 

  5472. 

  5473.     oct = tvb_get_guint8(tvb, curr_offset);
    5474. 

  5474. 

  5475.     other_decode_bitfield_value(a_bigbuf, oct, 0xf8, 8);
    5476. 

  5476.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5477. 

  5477.         "%s :  Reserved",
    5478. 

  5478.         a_bigbuf);
    5479. 

  5479. 

  5480.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    5481. 

  5481.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5482. 

  5482.         "%s :  Bit-Exact Length Fill Bits: %u",
    5483. 

  5483.         a_bigbuf,
    5484. 

  5484.         oct & 0x07);
    5485. 

  5485. 

  5486.     curr_offset++;
    5487. 

  5487. 

  5488.     is2000_portion_len = len - (curr_offset - offset);
    5489. 

  5489. 

  5490.     /*
    5491. 

  5491.      * the following decode was modified from the packet-ansi_map.c version
    5492. 

  5492.      */
    5493. 

  5493. 

  5494.     SHORT_DATA_CHECK(is2000_portion_len, 7);
    5495. 

  5495. 

  5496.     saved_offset = curr_offset;
    5497. 

  5497. 

  5498.     item =
    5499. 

  5499.         proto_tree_add_text(tree, tvb, curr_offset,
    5500. 

  5500.             is2000_portion_len,
    5501. 

  5501.             "IS-2000 Service Configuration Record Content");
    5502. 

  5502. 

  5503.     scr_subtree =
    5504. 

  5504.         proto_item_add_subtree(item, ett_scr);
    5505. 

  5505. 

  5506.     proto_tree_add_text(scr_subtree, tvb,
    5507. 

  5507.         curr_offset, 2,
    5508. 

  5508.         "FOR_MUX_OPTION:  Forward Traffic Channel multiplex option");
    5509. 

  5509. 

  5510.     curr_offset += 2;
    5511. 

  5511. 

  5512.     proto_tree_add_text(scr_subtree, tvb,
    5513. 

  5513.         curr_offset, 2,
    5514. 

  5514.         "REV_MUX_OPTION:  Reverse Traffic Channel multiplex option");
    5515. 

  5515. 

  5516.     curr_offset += 2;
    5517. 

  5517. 

  5518.     proto_tree_add_text(scr_subtree, tvb,
    5519. 

  5519.         curr_offset, 1,
    5520. 

  5520.         "FOR_RATES:  Transmission rates of the Forward Fundamental Channel");
    5521. 

  5521. 

  5522.     curr_offset += 1;
    5523. 

  5523. 

  5524.     proto_tree_add_text(scr_subtree, tvb,
    5525. 

  5525.         curr_offset, 1,
    5526. 

  5526.         "REV_RATES:  Transmission rates of the Reverse Fundamental Channel");
    5527. 

  5527. 

  5528.     curr_offset += 1;
    5529. 

  5529. 

  5530.     num_con_rec = tvb_get_guint8(tvb, curr_offset);
    5531. 

  5531. 

  5532.     proto_tree_add_text(scr_subtree, tvb,
    5533. 

  5533.         curr_offset, 1,
    5534. 

  5534.         "NUM_CON_REC:  Number of service option connection records, %u",
    5535. 

  5535.         num_con_rec);
    5536. 

  5536. 

  5537.     curr_offset += 1;
    5538. 

  5538. 

  5539.     for (ii=0; ii < num_con_rec; ii++)
    5540. 

  5540.     {
    5541. 

  5541.         oct = tvb_get_guint8(tvb, curr_offset);
    5542. 

  5542. 

  5543.         item =
    5544. 

  5544.             proto_tree_add_text(scr_subtree, tvb,
    5545. 

  5545.                 curr_offset, oct /* oct already includes the length octet itself */,
    5546. 

  5546.                 "Service option connection record [%u]", ii+1);
    5547. 

  5547. 

  5548.         subtree =
    5549. 

  5549.             proto_item_add_subtree(item, ett_srvc_con_rec);
    5550. 

  5550. 

  5551.         curr_offset += 1;
    5552. 

  5552. 

  5553.         oct = tvb_get_guint8(tvb, curr_offset);
    5554. 

  5554. 

  5555.         proto_tree_add_text(subtree, tvb,
    5556. 

  5556.             curr_offset, 1,
    5557. 

  5557.             "CON_REF:  Service option connection reference, %u",
    5558. 

  5558.             oct);
    5559. 

  5559. 

  5560.         curr_offset += 1;
    5561. 

  5561. 

  5562.         value = tvb_get_ntohs(tvb, curr_offset);
    5563. 

  5563. 

  5564.         proto_tree_add_text(subtree, tvb,
    5565. 

  5565.             curr_offset, 2,
    5566. 

  5566.             "SERVICE_OPTION:  %s",
    5567. 

  5567.             ansi_a_so_int_to_str(value));
    5568. 

  5568. 

  5569.         curr_offset += 2;
    5570. 

  5570. 

  5571.         oct = tvb_get_guint8(tvb, curr_offset);
    5572. 

  5572. 

  5573.         switch ((oct & 0xf0) >> 4)
    5574. 

  5574.         {
    5575. 

  5575.         case 0x00: str = "The service option connection does not use Forward Traffic Channel traffic."; break;
    5576. 

  5576.         case 0x01: str = "The service option connection uses primary traffic on the Forward Traffic Channel."; break;
    5577. 

  5577.         case 0x02: str = "The service option connection uses secondary traffic on the Forward Traffic Channel."; break;
    5578. 

  5578.         default: str = "Reserved"; break;
    5579. 

  5579.         }
    5580. 

  5580. 

  5581.         other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    5582. 

  5582.         proto_tree_add_text(subtree, tvb,
    5583. 

  5583.             curr_offset, 1,
    5584. 

  5584.             "%s :  FOR_TRAFFIC:  Forward Traffic Channel traffic type, %s",
    5585. 

  5585.             a_bigbuf,
    5586. 

  5586.             str);
    5587. 

  5587. 

  5588.         switch (oct & 0x0f)
    5589. 

  5589.         {
    5590. 

  5590.         case 0x00: str = "The service option connection does not use Reverse Traffic Channel traffic."; break;
    5591. 

  5591.         case 0x01: str = "The service option connection uses primary traffic on the Reverse Traffic Channel."; break;
    5592. 

  5592.         case 0x02: str = "The service option connection uses secondary traffic on the Reverse Traffic Channel."; break;
    5593. 

  5593.         default: str = "Reserved"; break;
    5594. 

  5594.         }
    5595. 

  5595. 

  5596.         other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    5597. 

  5597.         proto_tree_add_text(subtree, tvb,
    5598. 

  5598.             curr_offset, 1,
    5599. 

  5599.             "%s :  REV_TRAFFIC:  Reverse Traffic Channel traffic type, %s",
    5600. 

  5600.             a_bigbuf,
    5601. 

  5601.             str);
    5602. 

  5602. 

  5603.         curr_offset += 1;
    5604. 

  5604. 

  5605.         oct = tvb_get_guint8(tvb, curr_offset);
    5606. 

  5606. 

  5607.         other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    5608. 

  5608.         proto_tree_add_text(subtree, tvb,
    5609. 

  5609.             curr_offset, 1,
    5610. 

  5610.             "%s :  UI_ENCRYPT_MODE:  Encryption mode indicator for user information privacy",
    5611. 

  5611.             a_bigbuf);
    5612. 

  5612. 

  5613.         other_decode_bitfield_value(a_bigbuf, oct, 0x1c, 8);
    5614. 

  5614.         proto_tree_add_text(subtree, tvb,
    5615. 

  5615.             curr_offset, 1,
    5616. 

  5616.             "%s :  SR_ID:  Service reference identifier",
    5617. 

  5617.             a_bigbuf);
    5618. 

  5618. 

  5619.         other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
    5620. 

  5620.         proto_tree_add_text(subtree, tvb,
    5621. 

  5621.             curr_offset, 1,
    5622. 

  5622.             "%s :  RLP_INFO_INCL:  RLP information included indicator",
    5623. 

  5623.             a_bigbuf);
    5624. 

  5624. 

  5625.         if (oct & 0x02)
    5626. 

  5626.         {
    5627. 

  5627.             value = (oct & 0x01) << 3;
    5628. 

  5628.             other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    5629. 

  5629. 

  5630.             curr_offset += 1;
    5631. 

  5631. 

  5632.             oct = tvb_get_guint8(tvb, curr_offset);
    5633. 

  5633. 

  5634.             value |= (oct & 0xe0) >> 5;
    5635. 

  5635. 

  5636.             proto_tree_add_text(subtree, tvb,
    5637. 

  5637.                 curr_offset - 1, 1,
    5638. 

  5638.                 "%s :  RLP_BLOB_LEN (MSB), %u",
    5639. 

  5639.                 a_bigbuf,
    5640. 

  5640.                 value);
    5641. 

  5641. 

  5642.             other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    5643. 

  5643.             proto_tree_add_text(subtree, tvb,
    5644. 

  5644.                 curr_offset, 1,
    5645. 

  5645.                 "%s :  RLP_BLOB_LEN (LSB)",
    5646. 

  5646.                 a_bigbuf);
    5647. 

  5647. 

  5648.             other_decode_bitfield_value(a_bigbuf, oct, 0x1f, 8);
    5649. 

  5649.             proto_tree_add_text(subtree, tvb,
    5650. 

  5650.                 curr_offset, 1,
    5651. 

  5651.                 "%s :  RLP_BLOB (MSB)",
    5652. 

  5652.                 a_bigbuf);
    5653. 

  5653. 

  5654.             curr_offset += 1;
    5655. 

  5655. 

  5656.             if (value > 1)
    5657. 

  5657.             {
    5658. 

  5658.                 proto_tree_add_text(subtree, tvb,
    5659. 

  5659.                     curr_offset, value - 1,
    5660. 

  5660.                     "RLP_BLOB");
    5661. 

  5661. 

  5662.                 curr_offset += value - 1;
    5663. 

  5663.             }
    5664. 

  5664. 

  5665.             oct = tvb_get_guint8(tvb, curr_offset);
    5666. 

  5666. 

  5667.             other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    5668. 

  5668.             proto_tree_add_text(subtree, tvb,
    5669. 

  5669.                 curr_offset, 1,
    5670. 

  5670.                 "%s :  RLP_BLOB (LSB)",
    5671. 

  5671.                 a_bigbuf);
    5672. 

  5672. 

  5673.             other_decode_bitfield_value(a_bigbuf, oct, 0x1f, 8);
    5674. 

  5674.             proto_tree_add_text(subtree, tvb,
    5675. 

  5675.                 curr_offset, 1,
    5676. 

  5676.                 "%s :  Reserved",
    5677. 

  5677.                 a_bigbuf);
    5678. 

  5678.         }
    5679. 

  5679.         else
    5680. 

  5680.         {
    5681. 

  5681.             other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    5682. 

  5682.             proto_tree_add_text(subtree, tvb,
    5683. 

  5683.                 curr_offset, 1,
    5684. 

  5684.                 "%s :  Reserved",
    5685. 

  5685.                 a_bigbuf);
    5686. 

  5686.         }
    5687. 

  5687. 

  5688.         curr_offset += 1;
    5689. 

  5689.     }
    5690. 

  5690. 

  5691.     oct = tvb_get_guint8(tvb, curr_offset);
    5692. 

  5692. 

  5693.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    5694. 

  5694.     proto_tree_add_text(scr_subtree, tvb,
    5695. 

  5695.         curr_offset, 1,
    5696. 

  5696.         "%s :  FCH_CC_INCL:  Channel configuration for the Fundamental Channel included indicator",
    5697. 

  5697.         a_bigbuf);
    5698. 

  5698. 

  5699.     if (oct & 0x80)
    5700. 

  5700.     {
    5701. 

  5701.         other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
    5702. 

  5702.         proto_tree_add_text(scr_subtree, tvb,
    5703. 

  5703.             curr_offset, 1,
    5704. 

  5704.             "%s :  FCH_FRAME_SIZE:  Fundamental Channel frame size supported indicator",
    5705. 

  5705.             a_bigbuf);
    5706. 

  5706. 

  5707.         other_decode_bitfield_value(a_bigbuf, oct, 0x3e, 8);
    5708. 

  5708.         proto_tree_add_text(scr_subtree, tvb,
    5709. 

  5709.             curr_offset, 1,
    5710. 

  5710.             "%s :  FOR_FCH_RC:  Forward Fundamental Channel Radio Configuration, %u",
    5711. 

  5711.             a_bigbuf,
    5712. 

  5712.             (oct & 0x3e) >> 1);
    5713. 

  5713. 

  5714.         other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    5715. 

  5715.         value = (oct & 0x01) << 4;
    5716. 

  5716. 

  5717.         curr_offset += 1;
    5718. 

  5718. 

  5719.         oct = tvb_get_guint8(tvb, curr_offset);
    5720. 

  5720. 

  5721.         value |= (oct & 0xf0) >> 4;
    5722. 

  5722. 

  5723.         proto_tree_add_text(scr_subtree, tvb,
    5724. 

  5724.             curr_offset - 1, 1,
    5725. 

  5725.             "%s :  REV_FCH_RC:  Reverse Fundamental Channel Radio Configuration (MSB), %u",
    5726. 

  5726.             a_bigbuf,
    5727. 

  5727.             value);
    5728. 

  5728. 

  5729.         other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    5730. 

  5730.         proto_tree_add_text(scr_subtree, tvb,
    5731. 

  5731.             curr_offset, 1,
    5732. 

  5732.             "%s :  REV_FCH_RC:  (LSB)",
    5733. 

  5733.             a_bigbuf);
    5734. 

  5734. 

  5735.         bit_mask = 0x08;
    5736. 

  5736.         bit_offset = 3;
    5737. 

  5737.     }
    5738. 

  5738.     else
    5739. 

  5739.     {
    5740. 

  5740.         bit_mask = 0x40;
    5741. 

  5741.         bit_offset = 6;
    5742. 

  5742.     }
    5743. 

  5743. 

  5744.     other_decode_bitfield_value(a_bigbuf, oct, bit_mask, 8);
    5745. 

  5745.     proto_tree_add_text(scr_subtree, tvb,
    5746. 

  5746.         curr_offset, 1,
    5747. 

  5747.         "%s :  DCCH_CC_INCL:  Channel configuration for the Dedicated Control Channel included indicator",
    5748. 

  5748.         a_bigbuf);
    5749. 

  5749. 

  5750.     if (oct & bit_mask)
    5751. 

  5751.     {
    5752. 

  5752.         /* can't be bothered to do the rest of the decode */
    5753. 

  5753. 

  5754.         proto_tree_add_text(scr_subtree, tvb,
    5755. 

  5755.             curr_offset, (is2000_portion_len - (curr_offset - saved_offset)),
    5756. 

  5756.             "DCCH + ? + Reserved");
    5757. 

  5757. 

  5758.         curr_offset += (is2000_portion_len - (curr_offset - saved_offset));
    5759. 

  5759.     }
    5760. 

  5760.     else
    5761. 

  5761.     {
    5762. 

  5762.         bit_mask >>= 1;
    5763. 

  5763.         bit_offset--;
    5764. 

  5764. 

  5765.         other_decode_bitfield_value(a_bigbuf, oct, bit_mask, 8);
    5766. 

  5766.         proto_tree_add_text(scr_subtree, tvb,
    5767. 

  5767.             curr_offset, 1,
    5768. 

  5768.             "%s :  FOR_SCH_CC_INCL:  Channel configuration for the Dedicated Control Channel included indicator",
    5769. 

  5769.             a_bigbuf);
    5770. 

  5770. 

  5771.         if (oct & bit_mask)
    5772. 

  5772.         {
    5773. 

  5773.             /* can't be bothered to do the rest of the decode */
    5774. 

  5774. 

  5775.             proto_tree_add_text(scr_subtree, tvb,
    5776. 

  5776.                 curr_offset, (is2000_portion_len - (curr_offset - saved_offset)),
    5777. 

  5777.                 "FOR_SCH + ? + Reserved");
    5778. 

  5778. 

  5779.             curr_offset += (is2000_portion_len - (curr_offset - saved_offset));
    5780. 

  5780.         }
    5781. 

  5781.         else
    5782. 

  5782.         {
    5783. 

  5783.             bit_mask >>= 1;
    5784. 

  5784.             bit_offset--;
    5785. 

  5785. 

  5786.             other_decode_bitfield_value(a_bigbuf, oct, bit_mask, 8);
    5787. 

  5787.             proto_tree_add_text(scr_subtree, tvb,
    5788. 

  5788.                 curr_offset, 1,
    5789. 

  5789.                 "%s :  REV_SCH_CC_INCL:  Channel configuration for the Dedicated Control Channel included indicator",
    5790. 

  5790.                 a_bigbuf);
    5791. 

  5791. 

  5792.             if (oct & bit_mask)
    5793. 

  5793.             {
    5794. 

  5794.                 /* can't be bothered to do the rest of the decode */
    5795. 

  5795. 

  5796.                 proto_tree_add_text(scr_subtree, tvb,
    5797. 

  5797.                     curr_offset, (is2000_portion_len - (curr_offset - saved_offset)),
    5798. 

  5798.                     "REV_SCH + ? + Reserved");
    5799. 

  5799. 

  5800.                 curr_offset += (is2000_portion_len - (curr_offset - saved_offset));
    5801. 

  5801.             }
    5802. 

  5802.             else
    5803. 

  5803.             {
    5804. 

  5804.                 bit_mask = (0xff << (8 - bit_offset));
    5805. 

  5805.                 bit_mask >>= (8 - bit_offset);
    5806. 

  5806. 

  5807.                 other_decode_bitfield_value(a_bigbuf, oct, bit_mask, 8);
    5808. 

  5808.                 proto_tree_add_text(scr_subtree, tvb,
    5809. 

  5809.                     curr_offset, 1,
    5810. 

  5810.                     "%s :  Reserved",
    5811. 

  5811.                     a_bigbuf);
    5812. 

  5812. 

  5813.                 curr_offset += 1;
    5814. 

  5814.             }
    5815. 

  5815.         }
    5816. 

  5816.     }
    5817. 

  5817. 

  5818.     EXTRANEOUS_DATA_CHECK_EXPERT(len, curr_offset - offset);
    5819. 

  5819. 

  5820.     return(curr_offset - offset);
    5821. 

  5821. }
    5822. 

  5822. 

  5823. /*
    5824. 

  5824.  * IOS 6.2.2.69
    5825. 

  5825.  */
    5826. 

  5826. static guint8
    5827. 

  5827. elem_is2000_nn_scr(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    5828. 

  5828. {
    5829. 

  5829.     guint8      oct;
    5830. 

  5830.     guint32     curr_offset;
    5831. 

  5831. #ifndef MLUM
    5832. 

  5832.     guint       is2000_portion_len;
    5833. 

  5833. #endif
    5834. 

  5834. 

  5835.     curr_offset = offset;
    5836. 

  5836. 

  5837.     oct = tvb_get_guint8(tvb, curr_offset);
    5838. 

  5838. 

  5839.     other_decode_bitfield_value(a_bigbuf, oct, 0xf8, 8);
    5840. 

  5840.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5841. 

  5841.         "%s :  Reserved",
    5842. 

  5842.         a_bigbuf);
    5843. 

  5843. 

  5844.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    5845. 

  5845.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5846. 

  5846.         "%s :  Bit-Exact Length Fill Bits: %u",
    5847. 

  5847.         a_bigbuf,
    5848. 

  5848.         oct & 0x07);
    5849. 

  5849. 

  5850.     curr_offset++;
    5851. 

  5851. 

  5852. #ifndef MLUM
    5853. 

  5853. 

  5854.     is2000_portion_len = len - (curr_offset - offset);
    5855. 

  5855. 

  5856.     NO_MORE_DATA_CHECK(len);
    5857. 

  5857. 

  5858.     if (is2000_portion_len > 0)
    5859. 

  5859.     {
    5860. 

  5860.         SHORT_DATA_CHECK(len - (curr_offset - offset), is2000_portion_len);
    5861. 

  5861. 

  5862.         proto_tree_add_text(tree, tvb, curr_offset, is2000_portion_len,
    5863. 

  5863.             "IS-2000 Non-Negotiable Service Configuration Record Content");
    5864. 

  5864. 

  5865.         curr_offset += is2000_portion_len;
    5866. 

  5866.     }
    5867. 

  5867. 

  5868. #else
    5869. 

  5869. 

  5870. 

  5871. #endif
    5872. 

  5872. 

  5873.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    5874. 

  5874. 

  5875.     return(curr_offset - offset);
    5876. 

  5876. }
    5877. 

  5877. 

  5878. /*
    5879. 

  5879.  * IOS 6.2.2.70
    5880. 

  5880.  */
    5881. 

  5881. static guint8
    5882. 

  5882. elem_is2000_mob_cap(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    5883. 

  5883. {
    5884. 

  5884.     guint8      oct;
    5885. 

  5885.     guint8      oct_len;
    5886. 

  5886.     guint32     curr_offset;
    5887. 

  5887.     proto_tree  *subtree;
    5888. 

  5888.     proto_item  *item = NULL;
    5889. 

  5889.     const gchar *str;
    5890. 

  5890. 

  5891.     curr_offset = offset;
    5892. 

  5892. 

  5893.     oct = tvb_get_guint8(tvb, curr_offset);
    5894. 

  5894. 

  5895.     switch (global_a_variant)
    5896. 

  5896.     {
    5897. 

  5897.     case A_VARIANT_IOS401:
    5898. 

  5898.         other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    5899. 

  5899.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    5900. 

  5900.             "%s :  Reserved",
    5901. 

  5901.             a_bigbuf);
    5902. 

  5902.         break;
    5903. 

  5903. 

  5904.     case A_VARIANT_IOS501:
    5905. 

  5905.         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    5906. 

  5906.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    5907. 

  5907.             "%s :  REV_PDCH Supported: IS-2000 R-PDCH %ssupported",
    5908. 

  5908.             a_bigbuf,
    5909. 

  5909.             (oct & 0x80) ? "" : "not ");
    5910. 

  5910. 

  5911.         other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
    5912. 

  5912.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    5913. 

  5913.             "%s :  FOR_PDCH Supported: IS-2000 F-PDCH %ssupported",
    5914. 

  5914.             a_bigbuf,
    5915. 

  5915.             (oct & 0x40) ? "" : "not ");
    5916. 

  5916. 

  5917.         other_decode_bitfield_value(a_bigbuf, oct, 0x20, 8);
    5918. 

  5918.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    5919. 

  5919.             "%s :  ERAM Supported: Enhanced Rate Adaptation Mode %ssupported",
    5920. 

  5920.             a_bigbuf,
    5921. 

  5921.             (oct & 0x20) ? "" : "not ");
    5922. 

  5922.         break;
    5923. 

  5923.     }
    5924. 

  5924. 

  5925.     other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
    5926. 

  5926.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5927. 

  5927.         "%s :  DCCH Supported: IS-2000 DCCH %ssupported",
    5928. 

  5928.         a_bigbuf,
    5929. 

  5929.         (oct & 0x10) ? "" : "not ");
    5930. 

  5930. 

  5931.     other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    5932. 

  5932.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5933. 

  5933.         "%s :  FCH Supported: IS-2000 FCH %ssupported",
    5934. 

  5934.         a_bigbuf,
    5935. 

  5935.         (oct & 0x08) ? "" : "not ");
    5936. 

  5936. 

  5937.     other_decode_bitfield_value(a_bigbuf, oct, 0x04, 8);
    5938. 

  5938.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5939. 

  5939.         "%s :  OTD Supported: Orthogonal Transmit Diversity %ssupported",
    5940. 

  5940.         a_bigbuf,
    5941. 

  5941.         (oct & 0x04) ? "" : "not ");
    5942. 

  5942. 

  5943.     other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
    5944. 

  5944.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5945. 

  5945.         "%s :  Enhanced RC CFG Supported: Radio configuration in radio class 2 %ssupported",
    5946. 

  5946.         a_bigbuf,
    5947. 

  5947.         (oct & 0x02) ? "" : "not ");
    5948. 

  5948. 

  5949.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    5950. 

  5950.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5951. 

  5951.         "%s :  QPCH Supported: Quick Paging Channel %ssupported",
    5952. 

  5952.         a_bigbuf,
    5953. 

  5953.         (oct & 0x01) ? "" : "not ");
    5954. 

  5954. 

  5955.     curr_offset++;
    5956. 

  5956. 

  5957.     NO_MORE_DATA_CHECK(len);
    5958. 

  5958. 

  5959.     oct_len = tvb_get_guint8(tvb, curr_offset);
    5960. 

  5960. 

  5961.     proto_tree_add_text(tree,
    5962. 

  5962.         tvb, curr_offset, 1,
    5963. 

  5963.         "FCH Information: Bit-Exact Length Octet Count: %u",
    5964. 

  5964.         oct_len);
    5965. 

  5965. 

  5966.     curr_offset++;
    5967. 

  5967. 

  5968.     NO_MORE_DATA_CHECK(len);
    5969. 

  5969. 

  5970.     oct = tvb_get_guint8(tvb, curr_offset);
    5971. 

  5971. 

  5972.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    5973. 

  5973.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5974. 

  5974.         "%s :  Reserved",
    5975. 

  5975.         a_bigbuf);
    5976. 

  5976. 

  5977.     switch ((oct & 0x70) >> 4)
    5978. 

  5978.     {
    5979. 

  5979.     case 0: str = "No mobile assisted geo-location capabilities"; break;
    5980. 

  5980.     case 1: str = "IS801 capable (Advanced Forward Link Triangulation only (AFLT))"; break;
    5981. 

  5981.     case 2: str = "IS801 capable (Advanced Forward Link Triangulation and Global Positioning Systems"; break;
    5982. 

  5982.     case 3: str = "Global Positioning Systems Only"; break;
    5983. 

  5983.     default:
    5984. 

  5984.         str = "Reserved";
    5985. 

  5985.         break;
    5986. 

  5986.     }
    5987. 

  5987. 

  5988.     other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
    5989. 

  5989.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5990. 

  5990.         "%s :  Geo Location Type: %s",
    5991. 

  5991.         a_bigbuf,
    5992. 

  5992.         str);
    5993. 

  5993. 

  5994.     other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    5995. 

  5995.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    5996. 

  5996.         "%s :  Geo Location Included",
    5997. 

  5997.         a_bigbuf);
    5998. 

  5998. 

  5999.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    6000. 

  6000.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6001. 

  6001.         "%s :  FCH Information: Bit-Exact Length Fill Bits: %u",
    6002. 

  6002.         a_bigbuf,
    6003. 

  6003.         oct & 0x07);
    6004. 

  6004. 

  6005.     curr_offset++;
    6006. 

  6006. 

  6007.     NO_MORE_DATA_CHECK(len);
    6008. 

  6008. 

  6009.     if (oct_len > 0)
    6010. 

  6010.     {
    6011. 

  6011.         SHORT_DATA_CHECK(len - (curr_offset - offset), oct_len);
    6012. 

  6012. 

  6013.         proto_tree_add_text(tree, tvb, curr_offset, oct_len,
    6014. 

  6014.             "FCH Information Content");
    6015. 

  6015. 

  6016.         curr_offset += oct_len;
    6017. 

  6017. 

  6018.         NO_MORE_DATA_CHECK(len);
    6019. 

  6019.     }
    6020. 

  6020. 

  6021.     /*
    6022. 

  6022.      * DCCH
    6023. 

  6023.      */
    6024. 

  6024.     oct_len = tvb_get_guint8(tvb, curr_offset);
    6025. 

  6025. 

  6026.     proto_tree_add_text(tree,
    6027. 

  6027.         tvb, curr_offset, 1,
    6028. 

  6028.         "DCCH Information: Bit-Exact Length Octet Count: %u",
    6029. 

  6029.         oct_len);
    6030. 

  6030. 

  6031.     curr_offset++;
    6032. 

  6032. 

  6033.     NO_MORE_DATA_CHECK(len);
    6034. 

  6034. 

  6035.     oct = tvb_get_guint8(tvb, curr_offset);
    6036. 

  6036. 

  6037.     other_decode_bitfield_value(a_bigbuf, oct, 0xf8, 8);
    6038. 

  6038.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6039. 

  6039.         "%s :  Reserved",
    6040. 

  6040.         a_bigbuf);
    6041. 

  6041. 

  6042.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    6043. 

  6043.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6044. 

  6044.         "%s :  DCCH Information: Bit-Exact Length Fill Bits: %u",
    6045. 

  6045.         a_bigbuf,
    6046. 

  6046.         oct & 0x07);
    6047. 

  6047. 

  6048.     curr_offset++;
    6049. 

  6049. 

  6050.     NO_MORE_DATA_CHECK(len);
    6051. 

  6051. 

  6052.     if (oct_len > 0)
    6053. 

  6053.     {
    6054. 

  6054.         SHORT_DATA_CHECK(len - (curr_offset - offset), oct_len);
    6055. 

  6055. 

  6056.         proto_tree_add_text(tree, tvb, curr_offset, oct_len,
    6057. 

  6057.             "DCCH Information Content");
    6058. 

  6058. 

  6059.         curr_offset += oct_len;
    6060. 

  6060. 

  6061.         NO_MORE_DATA_CHECK(len);
    6062. 

  6062.     }
    6063. 

  6063. 

  6064.     /*
    6065. 

  6065.      * FOR_PDCH
    6066. 

  6066.      */
    6067. 

  6067.     oct_len = tvb_get_guint8(tvb, curr_offset);
    6068. 

  6068. 

  6069.     proto_tree_add_text(tree,
    6070. 

  6070.         tvb, curr_offset, 1,
    6071. 

  6071.         "FOR_PDCH Information: Bit-Exact Length Octet Count: %u",
    6072. 

  6072.         oct_len);
    6073. 

  6073. 

  6074.     curr_offset++;
    6075. 

  6075. 

  6076.     NO_MORE_DATA_CHECK(len);
    6077. 

  6077. 

  6078.     oct = tvb_get_guint8(tvb, curr_offset);
    6079. 

  6079. 

  6080.     other_decode_bitfield_value(a_bigbuf, oct, 0xf8, 8);
    6081. 

  6081.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6082. 

  6082.         "%s :  Reserved",
    6083. 

  6083.         a_bigbuf);
    6084. 

  6084. 

  6085.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    6086. 

  6086.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6087. 

  6087.         "%s :  FOR_PDCH Information: Bit-Exact Length Fill Bits: %u",
    6088. 

  6088.         a_bigbuf,
    6089. 

  6089.         oct & 0x07);
    6090. 

  6090. 

  6091.     curr_offset++;
    6092. 

  6092. 

  6093.     NO_MORE_DATA_CHECK(len);
    6094. 

  6094. 

  6095.     if (oct_len > 0)
    6096. 

  6096.     {
    6097. 

  6097.         SHORT_DATA_CHECK(len - (curr_offset - offset), oct_len);
    6098. 

  6098. 

  6099.         proto_tree_add_text(tree, tvb, curr_offset, oct_len,
    6100. 

  6100.             "FOR_PDCH Information Content");
    6101. 

  6101. 

  6102.         curr_offset += oct_len;
    6103. 

  6103. 

  6104.         NO_MORE_DATA_CHECK(len);
    6105. 

  6105.     }
    6106. 

  6106. 

  6107.     /*
    6108. 

  6108.      * REV_PDCH
    6109. 

  6109.      */
    6110. 

  6110.     oct_len = tvb_get_guint8(tvb, curr_offset);
    6111. 

  6111. 

  6112.     proto_tree_add_text(tree,
    6113. 

  6113.         tvb, curr_offset, 1,
    6114. 

  6114.         "REV_PDCH Information: Bit-Exact Length Octet Count: %u",
    6115. 

  6115.         oct_len);
    6116. 

  6116. 

  6117.     curr_offset++;
    6118. 

  6118. 

  6119.     NO_MORE_DATA_CHECK(len);
    6120. 

  6120. 

  6121.     oct = tvb_get_guint8(tvb, curr_offset);
    6122. 

  6122. 

  6123.     other_decode_bitfield_value(a_bigbuf, oct, 0xf8, 8);
    6124. 

  6124.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6125. 

  6125.         "%s :  Reserved",
    6126. 

  6126.         a_bigbuf);
    6127. 

  6127. 

  6128.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    6129. 

  6129.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6130. 

  6130.         "%s :  REV_PDCH Information: Bit-Exact Length Fill Bits: %u",
    6131. 

  6131.         a_bigbuf,
    6132. 

  6132.         oct & 0x07);
    6133. 

  6133. 

  6134.     curr_offset++;
    6135. 

  6135. 

  6136.     NO_MORE_DATA_CHECK(len);
    6137. 

  6137. 

  6138.     if (oct_len > 0)
    6139. 

  6139.     {
    6140. 

  6140.         SHORT_DATA_CHECK(len - (curr_offset - offset), oct_len);
    6141. 

  6141. 

  6142.         proto_tree_add_text(tree, tvb, curr_offset, oct_len,
    6143. 

  6143.             "REV_PDCH Information Content");
    6144. 

  6144. 

  6145.         curr_offset += oct_len;
    6146. 

  6146. 

  6147.         NO_MORE_DATA_CHECK(len);
    6148. 

  6148.     }
    6149. 

  6149. 

  6150.     oct = tvb_get_guint8(tvb, curr_offset);
    6151. 

  6151. 

  6152.     item =
    6153. 

  6153.         proto_tree_add_text(tree, tvb,
    6154. 

  6154.             curr_offset, 1,
    6155. 

  6155.             "VP Algorithms Supported%s",
    6156. 

  6156.             oct ? "" : ":  No voice privacy supported");
    6157. 

  6157. 

  6158.     if (oct)
    6159. 

  6159.     {
    6160. 

  6160.         subtree =
    6161. 

  6161.             proto_item_add_subtree(item, ett_vp_algs);
    6162. 

  6162. 

  6163.         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    6164. 

  6164.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6165. 

  6165.             "%s :  %s",
    6166. 

  6166.             a_bigbuf,
    6167. 

  6167.             (oct & 0x80) ? "No extension" : "Extended");
    6168. 

  6168. 

  6169.         other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
    6170. 

  6170.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6171. 

  6171.             "%s :  A7:  Reserved",
    6172. 

  6172.             a_bigbuf);
    6173. 

  6173. 

  6174.         other_decode_bitfield_value(a_bigbuf, oct, 0x20, 8);
    6175. 

  6175.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6176. 

  6176.             "%s :  A6:  Reserved",
    6177. 

  6177.             a_bigbuf);
    6178. 

  6178. 

  6179.         other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
    6180. 

  6180.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6181. 

  6181.             "%s :  A5:  Reserved",
    6182. 

  6182.             a_bigbuf);
    6183. 

  6183. 

  6184.         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
    6185. 

  6185.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6186. 

  6186.             "%s :  A4:  Reserved",
    6187. 

  6187.             a_bigbuf);
    6188. 

  6188. 

  6189.         other_decode_bitfield_value(a_bigbuf, oct, 0x04, 8);
    6190. 

  6190.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6191. 

  6191.             "%s :  A3:  Reserved",
    6192. 

  6192.             a_bigbuf);
    6193. 

  6193. 

  6194.         other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
    6195. 

  6195.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6196. 

  6196.             "%s :  A2:  Advanced Encryption Standard (AES)",
    6197. 

  6197.             a_bigbuf);
    6198. 

  6198. 

  6199.         other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    6200. 

  6200.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6201. 

  6201.             "%s :  A1:  Private long code",
    6202. 

  6202.             a_bigbuf);
    6203. 

  6203.     }
    6204. 

  6204. 

  6205.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    6206. 

  6206. 

  6207.     return(curr_offset - offset);
    6208. 

  6208. }
    6209. 

  6209. 

  6210. /*
    6211. 

  6211.  * IOS 6.2.2.71
    6212. 

  6212.  */
    6213. 

  6213. static guint8
    6214. 

  6214. elem_ptype(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    6215. 

  6215. {
    6216. 

  6216.     guint32     value;
    6217. 

  6217.     guint32     curr_offset;
    6218. 

  6218.     const gchar *str;
    6219. 

  6219. 

  6220.     curr_offset = offset;
    6221. 

  6221. 

  6222.     value = tvb_get_ntohs(tvb, curr_offset);
    6223. 

  6223. 

  6224.     switch (value)
    6225. 

  6225.     {
    6226. 

  6226.     case 0x880b: str = "PPP"; break;
    6227. 

  6227.     case 0x8881: str = "Unstructured Byte Stream"; break;
    6228. 

  6228.     default:
    6229. 

  6229.         str = "Unknown";
    6230. 

  6230.         break;
    6231. 

  6231.     }
    6232. 

  6232. 

  6233.     proto_tree_add_text(tree,
    6234. 

  6234.         tvb, curr_offset, 2,
    6235. 

  6235.         "(%u) %s",
    6236. 

  6236.         value,
    6237. 

  6237.         str);
    6238. 

  6238. 

  6239.     g_snprintf(add_string, string_len, " - (%s)", str);
    6240. 

  6240. 

  6241.     curr_offset += 2;
    6242. 

  6242. 

  6243.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    6244. 

  6244. 

  6245.     return(curr_offset - offset);
    6246. 

  6246. }
    6247. 

  6247. 

  6248. /*
    6249. 

  6249.  * IOS 6.2.2.72
    6250. 

  6250.  */
    6251. 

  6251. static guint8
    6252. 

  6252. elem_fwd_ms_info_recs(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    6253. 

  6253. {
    6254. 

  6254.     guint8      oct;
    6255. 

  6255.     guint8      oct_len;
    6256. 

  6256.     guint8      rec_type;
    6257. 

  6257.     guint8      num_recs;
    6258. 

  6258.     guint32     value;
    6259. 

  6259.     guint32     curr_offset;
    6260. 

  6260.     const gchar *str;
    6261. 

  6261.     gint        ett_elem_idx, idx, i;
    6262. 

  6262.     proto_tree  *subtree;
    6263. 

  6263.     proto_item  *item;
    6264. 

  6264. 

  6265.     curr_offset = offset;
    6266. 

  6266. 

  6267.     num_recs = 0;
    6268. 

  6268. 

  6269.     while ((len - (curr_offset - offset)) >= 2)
    6270. 

  6270.     {
    6271. 

  6271.         num_recs++;
    6272. 

  6272. 

  6273.         rec_type = tvb_get_guint8(tvb, curr_offset);
    6274. 

  6274. 

  6275.         str = try_val_to_str_idx((guint32) rec_type, ansi_fwd_ms_info_rec_str, &idx);
    6276. 

  6276. 

  6277.         if (str == NULL)
    6278. 

  6278.         {
    6279. 

  6279.             str = "Reserved";
    6280. 

  6280.             ett_elem_idx = ett_ansi_ms_info_rec_reserved;
    6281. 

  6281.         }
    6282. 

  6282.         else
    6283. 

  6283.         {
    6284. 

  6284.             ett_elem_idx = ett_ansi_fwd_ms_info_rec[idx];
    6285. 

  6285.         }
    6286. 

  6286. 

  6287.         item =
    6288. 

  6288.             proto_tree_add_text(tree,
    6289. 

  6289.                 tvb, curr_offset, 1,
    6290. 

  6290.                 "Information Record Type [%u]: (%u) %s",
    6291. 

  6291.                 num_recs,
    6292. 

  6292.                 rec_type,
    6293. 

  6293.                 str);
    6294. 

  6294. 

  6295.         subtree = proto_item_add_subtree(item, ett_elem_idx);
    6296. 

  6296. 

  6297.         curr_offset++;
    6298. 

  6298. 

  6299.         oct_len = tvb_get_guint8(tvb, curr_offset);
    6300. 

  6300. 

  6301.         proto_tree_add_uint(subtree, hf_ansi_a_length, tvb,
    6302. 

  6302.             curr_offset, 1, oct_len);
    6303. 

  6303. 

  6304.         curr_offset++;
    6305. 

  6305. 

  6306.         if (oct_len > 0)
    6307. 

  6307.         {
    6308. 

  6308.             SHORT_DATA_CHECK(len - (curr_offset - offset), oct_len);
    6309. 

  6309. 

  6310.             switch (rec_type)
    6311. 

  6311.             {
    6312. 

  6312.             case ANSI_FWD_MS_INFO_REC_CLD_PN:
    6313. 

  6313.                 oct = tvb_get_guint8(tvb, curr_offset);
    6314. 

  6314. 

  6315.                 switch ((oct & 0xe0) >> 5)
    6316. 

  6316.                 {
    6317. 

  6317.                 case 0: str = "Unknown"; break;
    6318. 

  6318.                 case 1: str = "International number"; break;
    6319. 

  6319.                 case 2: str = "National number"; break;
    6320. 

  6320.                 case 3: str = "Network-specific number"; break;
    6321. 

  6321.                 case 4: str = "Subscriber number"; break;
    6322. 

  6322.                 case 5: str = "Reserved"; break;
    6323. 

  6323.                 case 6: str = "Abbreviated number"; break;
    6324. 

  6324.                 default:
    6325. 

  6325.                     str = "Reserved for extension";
    6326. 

  6326.                     break;
    6327. 

  6327.                 }
    6328. 

  6328. 

  6329.                 other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    6330. 

  6330.                 proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6331. 

  6331.                     "%s :  Number Type: %s",
    6332. 

  6332.                     a_bigbuf,
    6333. 

  6333.                     str);
    6334. 

  6334. 

  6335.                 switch ((oct & 0x1e) >> 1)
    6336. 

  6336.                 {
    6337. 

  6337.                 case 0x00: str = "Unknown"; break;
    6338. 

  6338.                 case 0x01: str = "ISDN/Telephony Numbering"; break;
    6339. 

  6339.                 case 0x03: str = "Data Numbering (ITU-T Rec. X.121)"; break;
    6340. 

  6340.                 case 0x04: str = "Telex Numbering (ITU-T Rec. F.69)"; break;
    6341. 

  6341.                 case 0x09: str = "Private Numbering"; break;
    6342. 

  6342.                 case 0x0f: str = "Reserved for extension"; break;
    6343. 

  6343.                 default:
    6344. 

  6344.                     str = "Reserved";
    6345. 

  6345.                     break;
    6346. 

  6346.                 }
    6347. 

  6347. 

  6348.                 other_decode_bitfield_value(a_bigbuf, oct, 0x1e, 8);
    6349. 

  6349.                 proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6350. 

  6350.                     "%s :  Number Plan: %s",
    6351. 

  6351.                     a_bigbuf,
    6352. 

  6352.                     str);
    6353. 

  6353. 

  6354.                 if (oct_len > 1)
    6355. 

  6355.                 {
    6356. 

  6356.                     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    6357. 

  6357.                     proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6358. 

  6358.                         "%s :  MSB of first digit",
    6359. 

  6359.                         a_bigbuf);
    6360. 

  6360. 

  6361.                     curr_offset++;
    6362. 

  6362. 

  6363.                     for (i=0; i < (oct_len - 1); i++)
    6364. 

  6364.                     {
    6365. 

  6365.                         a_bigbuf[i] = (oct & 0x01) << 7;
    6366. 

  6366. 

  6367.                         oct = tvb_get_guint8(tvb, curr_offset + i);
    6368. 

  6368. 

  6369.                         a_bigbuf[i] |= (oct & 0xfe) >> 1;
    6370. 

  6370.                     }
    6371. 

  6371.                     a_bigbuf[i] = '\0';
    6372. 

  6372. 

  6373.                     proto_tree_add_text(subtree, tvb, curr_offset, oct_len - 1,
    6374. 

  6374.                         "Digits: %s",
    6375. 

  6375.                         a_bigbuf);
    6376. 

  6376. 

  6377.                     curr_offset += (oct_len - 2);
    6378. 

  6378.                 }
    6379. 

  6379. 

  6380.                 other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    6381. 

  6381.                 proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6382. 

  6382.                     "%s :  Reserved",
    6383. 

  6383.                     a_bigbuf);
    6384. 

  6384. 

  6385.                 curr_offset++;
    6386. 

  6386.                 break;
    6387. 

  6387. 

  6388.             case ANSI_FWD_MS_INFO_REC_CLG_PN:
    6389. 

  6389.                 value = tvb_get_ntohs(tvb, curr_offset);
    6390. 

  6390. 

  6391.                 oct = (value & 0xff00) >> 8;
    6392. 

  6392. 

  6393.                 switch ((oct & 0xe0) >> 5)
    6394. 

  6394.                 {
    6395. 

  6395.                 case 0: str = "Unknown"; break;
    6396. 

  6396.                 case 1: str = "International number"; break;
    6397. 

  6397.                 case 2: str = "National number"; break;
    6398. 

  6398.                 case 3: str = "Network-specific number"; break;
    6399. 

  6399.                 case 4: str = "Subscriber number"; break;
    6400. 

  6400.                 case 5: str = "Reserved"; break;
    6401. 

  6401.                 case 6: str = "Abbreviated number"; break;
    6402. 

  6402.                 default:
    6403. 

  6403.                     str = "Reserved for extension";
    6404. 

  6404.                     break;
    6405. 

  6405.                 }
    6406. 

  6406. 

  6407.                 other_decode_bitfield_value(a_bigbuf, value, 0xe000, 16);
    6408. 

  6408.                 proto_tree_add_text(subtree, tvb, curr_offset, 2,
    6409. 

  6409.                     "%s :  Number Type: %s",
    6410. 

  6410.                     a_bigbuf,
    6411. 

  6411.                     str);
    6412. 

  6412. 

  6413.                 switch ((oct & 0x1e) >> 1)
    6414. 

  6414.                 {
    6415. 

  6415.                 case 0x00: str = "Unknown"; break;
    6416. 

  6416.                 case 0x01: str = "ISDN/Telephony Numbering"; break;
    6417. 

  6417.                 case 0x03: str = "Data Numbering (ITU-T Rec. X.121)"; break;
    6418. 

  6418.                 case 0x04: str = "Telex Numbering (ITU-T Rec. F.69)"; break;
    6419. 

  6419.                 case 0x09: str = "Private Numbering"; break;
    6420. 

  6420.                 case 0x0f: str = "Reserved for extension"; break;
    6421. 

  6421.                 default:
    6422. 

  6422.                     str = "Reserved";
    6423. 

  6423.                     break;
    6424. 

  6424.                 }
    6425. 

  6425. 

  6426.                 other_decode_bitfield_value(a_bigbuf, value, 0x1e00, 16);
    6427. 

  6427.                 proto_tree_add_text(subtree, tvb, curr_offset, 2,
    6428. 

  6428.                     "%s :  Number Plan: %s",
    6429. 

  6429.                     a_bigbuf,
    6430. 

  6430.                     str);
    6431. 

  6431. 

  6432.                 switch ((value & 0x0180) >> 7)
    6433. 

  6433.                 {
    6434. 

  6434.                 case 0: str = "Presentation allowed"; break;
    6435. 

  6435.                 case 1: str = "Presentation restricted"; break;
    6436. 

  6436.                 case 2: str = "Number not available"; break;
    6437. 

  6437.                 default:
    6438. 

  6438.                     str = "Reserved";
    6439. 

  6439.                     break;
    6440. 

  6440.                 }
    6441. 

  6441. 

  6442.                 other_decode_bitfield_value(a_bigbuf, value, 0x0180, 16);
    6443. 

  6443.                 proto_tree_add_text(subtree, tvb, curr_offset, 2,
    6444. 

  6444.                     "%s :  Presentation Indicator (PI): %s",
    6445. 

  6445.                     a_bigbuf,
    6446. 

  6446.                     str);
    6447. 

  6447. 

  6448.                 switch ((value & 0x0060) >> 5)
    6449. 

  6449.                 {
    6450. 

  6450.                 case 0: str = "User-provided, not screened"; break;
    6451. 

  6451.                 case 1: str = "User-provided, verified and passed"; break;
    6452. 

  6452.                 case 2: str = "User-provided, verified and failed"; break;
    6453. 

  6453.                 default:
    6454. 

  6454.                     str = "Network-provided";
    6455. 

  6455.                     break;
    6456. 

  6456.                 }
    6457. 

  6457. 

  6458.                 other_decode_bitfield_value(a_bigbuf, value, 0x0060, 16);
    6459. 

  6459.                 proto_tree_add_text(subtree, tvb, curr_offset, 2,
    6460. 

  6460.                     "%s :  Screening Indicator (SI): %s",
    6461. 

  6461.                     a_bigbuf,
    6462. 

  6462.                     str);
    6463. 

  6463. 

  6464.                 if (oct_len > 2)
    6465. 

  6465.                 {
    6466. 

  6466.                     oct = (value & 0x00ff);
    6467. 

  6467. 

  6468.                     other_decode_bitfield_value(a_bigbuf, value, 0x001f, 16);
    6469. 

  6469.                     proto_tree_add_text(subtree, tvb, curr_offset, 2,
    6470. 

  6470.                         "%s :  MSB of first digit",
    6471. 

  6471.                         a_bigbuf);
    6472. 

  6472. 

  6473.                     curr_offset += 2;
    6474. 

  6474. 

  6475.                     for (i=0; i < (oct_len - 2); i++)
    6476. 

  6476.                     {
    6477. 

  6477.                         a_bigbuf[i] = (oct & 0x1f) << 3;
    6478. 

  6478. 

  6479.                         oct = tvb_get_guint8(tvb, curr_offset + i);
    6480. 

  6480. 

  6481.                         a_bigbuf[i] |= (oct & 0xe0) >> 5;
    6482. 

  6482.                     }
    6483. 

  6483.                     a_bigbuf[i] = '\0';
    6484. 

  6484. 

  6485.                     proto_tree_add_text(subtree, tvb, curr_offset, oct_len - 2,
    6486. 

  6486.                         "Digits: %s",
    6487. 

  6487.                         a_bigbuf);
    6488. 

  6488. 

  6489.                     curr_offset += (oct_len - 3);
    6490. 

  6490. 

  6491.                     other_decode_bitfield_value(a_bigbuf, oct, 0x1f, 8);
    6492. 

  6492.                     proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6493. 

  6493.                         "%s :  Reserved",
    6494. 

  6494.                         a_bigbuf);
    6495. 

  6495. 

  6496.                     curr_offset++;
    6497. 

  6497.                 }
    6498. 

  6498.                 else
    6499. 

  6499.                 {
    6500. 

  6500.                     other_decode_bitfield_value(a_bigbuf, value, 0x001f, 16);
    6501. 

  6501.                     proto_tree_add_text(subtree, tvb, curr_offset, 2,
    6502. 

  6502.                         "%s :  Reserved",
    6503. 

  6503.                         a_bigbuf);
    6504. 

  6504. 

  6505.                     curr_offset += 2;
    6506. 

  6506.                 }
    6507. 

  6507.                 break;
    6508. 

  6508. 

  6509.             case ANSI_FWD_MS_INFO_REC_MW:
    6510. 

  6510.                 oct = tvb_get_guint8(tvb, curr_offset);
    6511. 

  6511. 

  6512.                 proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6513. 

  6513.                     "Number of messages waiting: %u",
    6514. 

  6514.                     oct);
    6515. 

  6515. 

  6516.                 curr_offset++;
    6517. 

  6517.                 break;
    6518. 

  6518. 

  6519.             default:
    6520. 

  6520.                 proto_tree_add_text(subtree,
    6521. 

  6521.                     tvb, curr_offset, oct_len,
    6522. 

  6522.                     "Record Content");
    6523. 

  6523. 

  6524.                 curr_offset += oct_len;
    6525. 

  6525.                 break;
    6526. 

  6526.             }
    6527. 

  6527.         }
    6528. 

  6528.     }
    6529. 

  6529. 

  6530.     g_snprintf(add_string, string_len, " - %u record%s",
    6531. 

  6531.         num_recs, plurality(num_recs, "", "s"));
    6532. 

  6532. 

  6533.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    6534. 

  6534. 

  6535.     return(curr_offset - offset);
    6536. 

  6536. }
    6537. 

  6537. 

  6538. /*
    6539. 

  6539.  * IOS 6.2.2.72
    6540. 

  6540.  */
    6541. 

  6541. static guint8
    6542. 

  6542. elem_rev_ms_info_recs(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    6543. 

  6543. {
    6544. 

  6544.     guint8      oct;
    6545. 

  6545.     guint8      oct_len;
    6546. 

  6546.     guint8      rec_type;
    6547. 

  6547.     guint8      num_recs;
    6548. 

  6548.     guint32     value;
    6549. 

  6549.     guint32     curr_offset, saved_offset;
    6550. 

  6550.     const gchar *str;
    6551. 

  6551.     gint        ett_elem_idx, idx, i;
    6552. 

  6552.     proto_tree  *subtree, *subtree2;
    6553. 

  6553.     proto_item  *item;
    6554. 

  6554.     guint8      *poctets;
    6555. 

  6555. 

  6556.     curr_offset = offset;
    6557. 

  6557. 

  6558.     num_recs = 0;
    6559. 

  6559. 

  6560.     while ((len - (curr_offset - offset)) >= 2)
    6561. 

  6561.     {
    6562. 

  6562.         num_recs++;
    6563. 

  6563. 

  6564.         rec_type = tvb_get_guint8(tvb, curr_offset);
    6565. 

  6565. 

  6566.         str = try_val_to_str_idx((guint32) rec_type, ansi_rev_ms_info_rec_str, &idx);
    6567. 

  6567. 

  6568.         if (str == NULL)
    6569. 

  6569.         {
    6570. 

  6570.             str = "Reserved";
    6571. 

  6571.             ett_elem_idx = ett_ansi_ms_info_rec_reserved;
    6572. 

  6572.         }
    6573. 

  6573.         else
    6574. 

  6574.         {
    6575. 

  6575.             ett_elem_idx = ett_ansi_rev_ms_info_rec[idx];
    6576. 

  6576.         }
    6577. 

  6577. 

  6578.         item =
    6579. 

  6579.             proto_tree_add_text(tree,
    6580. 

  6580.                 tvb, curr_offset, 1,
    6581. 

  6581.                 "Information Record Type [%u]: (%u) %s",
    6582. 

  6582.                 num_recs,
    6583. 

  6583.                 rec_type,
    6584. 

  6584.                 str);
    6585. 

  6585. 

  6586.         subtree = proto_item_add_subtree(item, ett_elem_idx);
    6587. 

  6587. 

  6588.         curr_offset++;
    6589. 

  6589. 

  6590.         oct_len = tvb_get_guint8(tvb, curr_offset);
    6591. 

  6591. 

  6592.         proto_tree_add_uint(subtree, hf_ansi_a_length, tvb,
    6593. 

  6593.             curr_offset, 1, oct_len);
    6594. 

  6594. 

  6595.         curr_offset++;
    6596. 

  6596. 

  6597.         if (oct_len > 0)
    6598. 

  6598.         {
    6599. 

  6599.             SHORT_DATA_CHECK(len - (curr_offset - offset), oct_len);
    6600. 

  6600. 

  6601.             switch (rec_type)
    6602. 

  6602.             {
    6603. 

  6603.             case ANSI_REV_MS_INFO_REC_KEYPAD_FAC:
    6604. 

  6604.                 poctets = tvb_get_ephemeral_string(tvb, curr_offset, oct_len);
    6605. 

  6605. 

  6606.                 proto_tree_add_string_format(subtree, hf_ansi_a_cld_party_ascii_num,
    6607. 

  6607.                     tvb, curr_offset, oct_len,
    6608. 

  6608.                     (gchar *) poctets,
    6609. 

  6609.                     "Digits: %s",
    6610. 

  6610.                     (gchar *) format_text(poctets, oct_len));
    6611. 

  6611. 

  6612.                 curr_offset += oct_len;
    6613. 

  6613.                 break;
    6614. 

  6614. 

  6615.             case ANSI_REV_MS_INFO_REC_CLD_PN:
    6616. 

  6616.                 oct = tvb_get_guint8(tvb, curr_offset);
    6617. 

  6617. 

  6618.                 switch ((oct & 0xe0) >> 5)
    6619. 

  6619.                 {
    6620. 

  6620.                 case 0: str = "Unknown"; break;
    6621. 

  6621.                 case 1: str = "International number"; break;
    6622. 

  6622.                 case 2: str = "National number"; break;
    6623. 

  6623.                 case 3: str = "Network-specific number"; break;
    6624. 

  6624.                 case 4: str = "Subscriber number"; break;
    6625. 

  6625.                 case 5: str = "Reserved"; break;
    6626. 

  6626.                 case 6: str = "Abbreviated number"; break;
    6627. 

  6627.                 default:
    6628. 

  6628.                     str = "Reserved for extension";
    6629. 

  6629.                     break;
    6630. 

  6630.                 }
    6631. 

  6631. 

  6632.                 other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    6633. 

  6633.                 proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6634. 

  6634.                     "%s :  Number Type: %s",
    6635. 

  6635.                     a_bigbuf,
    6636. 

  6636.                     str);
    6637. 

  6637. 

  6638.                 switch ((oct & 0x1e) >> 1)
    6639. 

  6639.                 {
    6640. 

  6640.                 case 0x00: str = "Unknown"; break;
    6641. 

  6641.                 case 0x01: str = "ISDN/Telephony Numbering"; break;
    6642. 

  6642.                 case 0x03: str = "Data Numbering (ITU-T Rec. X.121)"; break;
    6643. 

  6643.                 case 0x04: str = "Telex Numbering (ITU-T Rec. F.69)"; break;
    6644. 

  6644.                 case 0x09: str = "Private Numbering"; break;
    6645. 

  6645.                 case 0x0f: str = "Reserved for extension"; break;
    6646. 

  6646.                 default:
    6647. 

  6647.                     str = "Reserved";
    6648. 

  6648.                     break;
    6649. 

  6649.                 }
    6650. 

  6650. 

  6651.                 other_decode_bitfield_value(a_bigbuf, oct, 0x1e, 8);
    6652. 

  6652.                 proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6653. 

  6653.                     "%s :  Number Plan: %s",
    6654. 

  6654.                     a_bigbuf,
    6655. 

  6655.                     str);
    6656. 

  6656. 

  6657.                 if (oct_len > 1)
    6658. 

  6658.                 {
    6659. 

  6659.                     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    6660. 

  6660.                     proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6661. 

  6661.                         "%s :  MSB of first digit",
    6662. 

  6662.                         a_bigbuf);
    6663. 

  6663. 

  6664.                     curr_offset++;
    6665. 

  6665. 

  6666.                     for (i=0; i < (oct_len - 1); i++)
    6667. 

  6667.                     {
    6668. 

  6668.                         a_bigbuf[i] = (oct & 0x01) << 7;
    6669. 

  6669. 

  6670.                         oct = tvb_get_guint8(tvb, curr_offset + i);
    6671. 

  6671. 

  6672.                         a_bigbuf[i] |= (oct & 0xfe) >> 1;
    6673. 

  6673.                     }
    6674. 

  6674.                     a_bigbuf[i] = '\0';
    6675. 

  6675. 

  6676.                     proto_tree_add_text(subtree, tvb, curr_offset, oct_len - 1,
    6677. 

  6677.                         "Digits: %s",
    6678. 

  6678.                         a_bigbuf);
    6679. 

  6679. 

  6680.                     curr_offset += (oct_len - 2);
    6681. 

  6681.                 }
    6682. 

  6682. 

  6683.                 other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    6684. 

  6684.                 proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6685. 

  6685.                     "%s :  Reserved",
    6686. 

  6686.                     a_bigbuf);
    6687. 

  6687. 

  6688.                 curr_offset++;
    6689. 

  6689.                 break;
    6690. 

  6690. 

  6691.             case ANSI_REV_MS_INFO_REC_CLG_PN:
    6692. 

  6692.                 value = tvb_get_ntohs(tvb, curr_offset);
    6693. 

  6693. 

  6694.                 oct = (value & 0xff00) >> 8;
    6695. 

  6695. 

  6696.                 switch ((oct & 0xe0) >> 5)
    6697. 

  6697.                 {
    6698. 

  6698.                 case 0: str = "Unknown"; break;
    6699. 

  6699.                 case 1: str = "International number"; break;
    6700. 

  6700.                 case 2: str = "National number"; break;
    6701. 

  6701.                 case 3: str = "Network-specific number"; break;
    6702. 

  6702.                 case 4: str = "Subscriber number"; break;
    6703. 

  6703.                 case 5: str = "Reserved"; break;
    6704. 

  6704.                 case 6: str = "Abbreviated number"; break;
    6705. 

  6705.                 default:
    6706. 

  6706.                     str = "Reserved for extension";
    6707. 

  6707.                     break;
    6708. 

  6708.                 }
    6709. 

  6709. 

  6710.                 other_decode_bitfield_value(a_bigbuf, value, 0xe000, 16);
    6711. 

  6711.                 proto_tree_add_text(subtree, tvb, curr_offset, 2,
    6712. 

  6712.                     "%s :  Number Type: %s",
    6713. 

  6713.                     a_bigbuf,
    6714. 

  6714.                     str);
    6715. 

  6715. 

  6716.                 switch ((oct & 0x1e) >> 1)
    6717. 

  6717.                 {
    6718. 

  6718.                 case 0x00: str = "Unknown"; break;
    6719. 

  6719.                 case 0x01: str = "ISDN/Telephony Numbering"; break;
    6720. 

  6720.                 case 0x03: str = "Data Numbering (ITU-T Rec. X.121)"; break;
    6721. 

  6721.                 case 0x04: str = "Telex Numbering (ITU-T Rec. F.69)"; break;
    6722. 

  6722.                 case 0x09: str = "Private Numbering"; break;
    6723. 

  6723.                 case 0x0f: str = "Reserved for extension"; break;
    6724. 

  6724.                 default:
    6725. 

  6725.                     str = "Reserved";
    6726. 

  6726.                     break;
    6727. 

  6727.                 }
    6728. 

  6728. 

  6729.                 other_decode_bitfield_value(a_bigbuf, value, 0x1e00, 16);
    6730. 

  6730.                 proto_tree_add_text(subtree, tvb, curr_offset, 2,
    6731. 

  6731.                     "%s :  Number Plan: %s",
    6732. 

  6732.                     a_bigbuf,
    6733. 

  6733.                     str);
    6734. 

  6734. 

  6735.                 switch ((value & 0x0180) >> 7)
    6736. 

  6736.                 {
    6737. 

  6737.                 case 0: str = "Presentation allowed"; break;
    6738. 

  6738.                 case 1: str = "Presentation restricted"; break;
    6739. 

  6739.                 case 2: str = "Number not available"; break;
    6740. 

  6740.                 default:
    6741. 

  6741.                     str = "Reserved";
    6742. 

  6742.                     break;
    6743. 

  6743.                 }
    6744. 

  6744. 

  6745.                 other_decode_bitfield_value(a_bigbuf, value, 0x0180, 16);
    6746. 

  6746.                 proto_tree_add_text(subtree, tvb, curr_offset, 2,
    6747. 

  6747.                     "%s :  Presentation Indicator (PI): %s",
    6748. 

  6748.                     a_bigbuf,
    6749. 

  6749.                     str);
    6750. 

  6750. 

  6751.                 switch ((value & 0x0060) >> 5)
    6752. 

  6752.                 {
    6753. 

  6753.                 case 0: str = "User-provided, not screened"; break;
    6754. 

  6754.                 case 1: str = "User-provided, verified and passed"; break;
    6755. 

  6755.                 case 2: str = "User-provided, verified and failed"; break;
    6756. 

  6756.                 default:
    6757. 

  6757.                     str = "Network-provided";
    6758. 

  6758.                     break;
    6759. 

  6759.                 }
    6760. 

  6760. 

  6761.                 other_decode_bitfield_value(a_bigbuf, value, 0x0060, 16);
    6762. 

  6762.                 proto_tree_add_text(subtree, tvb, curr_offset, 2,
    6763. 

  6763.                     "%s :  Screening Indicator (SI): %s",
    6764. 

  6764.                     a_bigbuf,
    6765. 

  6765.                     str);
    6766. 

  6766. 

  6767.                 if (oct_len > 2)
    6768. 

  6768.                 {
    6769. 

  6769.                     oct = (value & 0x00ff);
    6770. 

  6770. 

  6771.                     other_decode_bitfield_value(a_bigbuf, value, 0x001f, 16);
    6772. 

  6772.                     proto_tree_add_text(subtree, tvb, curr_offset, 2,
    6773. 

  6773.                         "%s :  MSB of first digit",
    6774. 

  6774.                         a_bigbuf);
    6775. 

  6775. 

  6776.                     curr_offset += 2;
    6777. 

  6777. 

  6778.                     for (i=0; i < (oct_len - 2); i++)
    6779. 

  6779.                     {
    6780. 

  6780.                         a_bigbuf[i] = (oct & 0x1f) << 3;
    6781. 

  6781. 

  6782.                         oct = tvb_get_guint8(tvb, curr_offset + i);
    6783. 

  6783. 

  6784.                         a_bigbuf[i] |= (oct & 0xe0) >> 5;
    6785. 

  6785.                     }
    6786. 

  6786.                     a_bigbuf[i] = '\0';
    6787. 

  6787. 

  6788.                     proto_tree_add_text(subtree, tvb, curr_offset, oct_len - 2,
    6789. 

  6789.                         "Digits: %s",
    6790. 

  6790.                         a_bigbuf);
    6791. 

  6791. 

  6792.                     curr_offset += (oct_len - 3);
    6793. 

  6793. 

  6794.                     other_decode_bitfield_value(a_bigbuf, oct, 0x1f, 8);
    6795. 

  6795.                     proto_tree_add_text(subtree, tvb, curr_offset, 1,
    6796. 

  6796.                         "%s :  Reserved",
    6797. 

  6797.                         a_bigbuf);
    6798. 

  6798. 

  6799.                     curr_offset++;
    6800. 

  6800.                 }
    6801. 

  6801.                 else
    6802. 

  6802.                 {
    6803. 

  6803.                     other_decode_bitfield_value(a_bigbuf, value, 0x001f, 16);
    6804. 

  6804.                     proto_tree_add_text(subtree, tvb, curr_offset, 2,
    6805. 

  6805.                         "%s :  Reserved",
    6806. 

  6806.                         a_bigbuf);
    6807. 

  6807. 

  6808.                     curr_offset += 2;
    6809. 

  6809.                 }
    6810. 

  6810.                 break;
    6811. 

  6811. 

  6812.             case ANSI_REV_MS_INFO_REC_SO_INFO:
    6813. 

  6813.                 i = 0;
    6814. 

  6814.                 saved_offset = curr_offset;
    6815. 

  6815. 

  6816.                 while ((oct_len - (curr_offset - saved_offset)) > 2)
    6817. 

  6817.                 {
    6818. 

  6818.                     item =
    6819. 

  6819.                         proto_tree_add_text(subtree,
    6820. 

  6820.                             tvb, curr_offset, 3,
    6821. 

  6821.                             "Service Option [%u]",
    6822. 

  6822.                             i + 1);
    6823. 

  6823. 

  6824.                     subtree2 = proto_item_add_subtree(item, ett_so_list);
    6825. 

  6825. 

  6826.                     oct = tvb_get_guint8(tvb, curr_offset);
    6827. 

  6827. 

  6828.                     other_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8);
    6829. 

  6829.                     proto_tree_add_text(subtree2, tvb, curr_offset, 1,
    6830. 

  6830.                         "%s :  Reserved",
    6831. 

  6831.                         a_bigbuf);
    6832. 

  6832. 

  6833.                     other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
    6834. 

  6834.                     proto_tree_add_text(subtree2, tvb, curr_offset, 1,
    6835. 

  6835.                         "%s :  Forward Support: %s",
    6836. 

  6836.                         a_bigbuf,
    6837. 

  6837.                         (oct & 0x02) ? "TRUE" : "FALSE");
    6838. 

  6838. 

  6839.                     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    6840. 

  6840.                     proto_tree_add_text(subtree2, tvb, curr_offset, 1,
    6841. 

  6841.                         "%s :  Reverse Support: %s",
    6842. 

  6842.                         a_bigbuf,
    6843. 

  6843.                         (oct & 0x01) ? "TRUE" : "FALSE");
    6844. 

  6844. 

  6845.                     curr_offset++;
    6846. 

  6846. 

  6847.                     value = tvb_get_ntohs(tvb, curr_offset);
    6848. 

  6848. 

  6849.                     str = ansi_a_so_int_to_str(value);
    6850. 

  6850.                     proto_tree_add_text(subtree2, tvb, curr_offset, 2,
    6851. 

  6851.                         "Service Option:  %s (%u)",
    6852. 

  6852.                         str,
    6853. 

  6853.                         value);
    6854. 

  6854. 

  6855.                     proto_item_append_text(item, " - (%u) %s", value, str);
    6856. 

  6856. 

  6857.                     i++;
    6858. 

  6858.                     curr_offset += 2;
    6859. 

  6859.                 }
    6860. 

  6860.                 break;
    6861. 

  6861. 

  6862.             default:
    6863. 

  6863.                 proto_tree_add_text(subtree,
    6864. 

  6864.                     tvb, curr_offset, oct_len,
    6865. 

  6865.                     "Record Content");
    6866. 

  6866. 

  6867.                 curr_offset += oct_len;
    6868. 

  6868.                 break;
    6869. 

  6869.             }
    6870. 

  6870.         }
    6871. 

  6871.     }
    6872. 

  6872. 

  6873.     g_snprintf(add_string, string_len, " - %u record%s",
    6874. 

  6874.         num_recs, plurality(num_recs, "", "s"));
    6875. 

  6875. 

  6876.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    6877. 

  6877. 

  6878.     return(curr_offset - offset);
    6879. 

  6879. }
    6880. 

  6880. 

  6881. /*
    6882. 

  6882.  * IOS 6.2.2.73
    6883. 

  6883.  */
    6884. 

  6884. static guint8
    6885. 

  6885. elem_ext_ho_dir_params(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    6886. 

  6886. {
    6887. 

  6887.     guint8      oct;
    6888. 

  6888.     guint32     value;
    6889. 

  6889.     guint32     curr_offset;
    6890. 

  6890.     const gchar *str;
    6891. 

  6891. 

  6892.     curr_offset = offset;
    6893. 

  6893. 

  6894.     oct = tvb_get_guint8(tvb, curr_offset);
    6895. 

  6895. 

  6896.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    6897. 

  6897.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6898. 

  6898.         "%s :  Search Window A Size (Srch_Win_A): %u",
    6899. 

  6899.         a_bigbuf,
    6900. 

  6900.         (oct & 0xf0) >> 4);
    6901. 

  6901. 

  6902.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    6903. 

  6903.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6904. 

  6904.         "%s :  Search Window N Size (Srch_Win_N): %u",
    6905. 

  6905.         a_bigbuf,
    6906. 

  6906.         oct & 0x0f);
    6907. 

  6907. 

  6908.     curr_offset++;
    6909. 

  6909. 

  6910.     NO_MORE_DATA_CHECK(len);
    6911. 

  6911. 

  6912.     oct = tvb_get_guint8(tvb, curr_offset);
    6913. 

  6913. 

  6914.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    6915. 

  6915.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6916. 

  6916.         "%s :  Search Window R Size (Srch_Win_R): %u",
    6917. 

  6917.         a_bigbuf,
    6918. 

  6918.         (oct & 0xf0) >> 4);
    6919. 

  6919. 

  6920.     value = tvb_get_guint8(tvb, curr_offset + 1);
    6921. 

  6921. 

  6922.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    6923. 

  6923.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6924. 

  6924.         "%s :  Add Pilot Threshold (T_Add) (MSB): %u",
    6925. 

  6925.         a_bigbuf,
    6926. 

  6926.         (oct & 0x0f) << 2 | (value & 0xc0) >> 6);
    6927. 

  6927. 

  6928.     curr_offset++;
    6929. 

  6929. 

  6930.     oct = value;
    6931. 

  6931. 

  6932.     other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
    6933. 

  6933.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6934. 

  6934.         "%s :  Add Pilot Threshold (T_Add) (LSB)",
    6935. 

  6935.         a_bigbuf);
    6936. 

  6936. 

  6937.     other_decode_bitfield_value(a_bigbuf, oct, 0x3f, 8);
    6938. 

  6938.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6939. 

  6939.         "%s :  Drop Pilot Threshold (T_Drop): %u",
    6940. 

  6940.         a_bigbuf,
    6941. 

  6941.         oct & 0x3f);
    6942. 

  6942. 

  6943.     curr_offset++;
    6944. 

  6944. 

  6945.     NO_MORE_DATA_CHECK(len);
    6946. 

  6946. 

  6947.     oct = tvb_get_guint8(tvb, curr_offset);
    6948. 

  6948. 

  6949.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    6950. 

  6950.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6951. 

  6951.         "%s :  Compare Threshold (T_Comp): %u",
    6952. 

  6952.         a_bigbuf,
    6953. 

  6953.         (oct & 0xf0) >> 4);
    6954. 

  6954. 

  6955.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    6956. 

  6956.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6957. 

  6957.         "%s :  Drop Timer Value (T_TDrop): %u",
    6958. 

  6958.         a_bigbuf,
    6959. 

  6959.         oct & 0x0f);
    6960. 

  6960. 

  6961.     curr_offset++;
    6962. 

  6962. 

  6963.     NO_MORE_DATA_CHECK(len);
    6964. 

  6964. 

  6965.     oct = tvb_get_guint8(tvb, curr_offset);
    6966. 

  6966. 

  6967.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    6968. 

  6968.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    6969. 

  6969.         "%s :  Neighbor Max Age (Nghbor_Max_AGE): %u",
    6970. 

  6970.         a_bigbuf,
    6971. 

  6971.         (oct & 0xf0) >> 4);
    6972. 

  6972. 

  6973.     switch (global_a_variant)
    6974. 

  6974.     {
    6975. 

  6975.     case A_VARIANT_IOS401:
    6976. 

  6976.         other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    6977. 

  6977.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    6978. 

  6978.             "%s :  Reserved",
    6979. 

  6979.             a_bigbuf);
    6980. 

  6980.         break;
    6981. 

  6981. 

  6982.     case A_VARIANT_IOS501:
    6983. 

  6983.         other_decode_bitfield_value(a_bigbuf, oct, 0x0c, 8);
    6984. 

  6984.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    6985. 

  6985.             "%s :  Reserved",
    6986. 

  6986.             a_bigbuf);
    6987. 

  6987. 

  6988.         switch (oct & 0x03)
    6989. 

  6989.         {
    6990. 

  6990.         case 0: str = "Only Search Window A Size is valid"; break;
    6991. 

  6991.         case 1: str = "Subset is valid"; break;
    6992. 

  6992.         case 2: str = "All fields valid"; break;
    6993. 

  6993.         default:
    6994. 

  6994.             str = "Reserved";
    6995. 

  6995.             break;
    6996. 

  6996.         }
    6997. 

  6997. 

  6998.         other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
    6999. 

  6999.         proto_tree_add_text(tree, tvb, curr_offset, 1,
    7000. 

  7000.             "%s :  Target BS Values Included: %s",
    7001. 

  7001.             a_bigbuf,
    7002. 

  7002.             str);
    7003. 

  7003.         break;
    7004. 

  7004.     }
    7005. 

  7005. 

  7006.     curr_offset++;
    7007. 

  7007. 

  7008.     NO_MORE_DATA_CHECK(len);
    7009. 

  7009. 

  7010.     oct = tvb_get_guint8(tvb, curr_offset);
    7011. 

  7011. 

  7012.     other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
    7013. 

  7013.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    7014. 

  7014.         "%s :  Reserved",
    7015. 

  7015.         a_bigbuf);
    7016. 

  7016. 

  7017.     other_decode_bitfield_value(a_bigbuf, oct, 0x3f, 8);
    7018. 

  7018.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    7019. 

  7019.         "%s :  SOFT_SLOPE: %u",
    7020. 

  7020.         a_bigbuf,
    7021. 

  7021.         oct & 0x3f);
    7022. 

  7022. 

  7023.     curr_offset++;
    7024. 

  7024. 

  7025.     NO_MORE_DATA_CHECK(len);
    7026. 

  7026. 

  7027.     oct = tvb_get_guint8(tvb, curr_offset);
    7028. 

  7028. 

  7029.     other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
    7030. 

  7030.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    7031. 

  7031.         "%s :  Reserved",
    7032. 

  7032.         a_bigbuf);
    7033. 

  7033. 

  7034.     other_decode_bitfield_value(a_bigbuf, oct, 0x3f, 8);
    7035. 

  7035.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    7036. 

  7036.         "%s :  ADD_INTERCEPT: %u",
    7037. 

  7037.         a_bigbuf,
    7038. 

  7038.         oct & 0x3f);
    7039. 

  7039. 

  7040.     curr_offset++;
    7041. 

  7041. 

  7042.     NO_MORE_DATA_CHECK(len);
    7043. 

  7043. 

  7044.     oct = tvb_get_guint8(tvb, curr_offset);
    7045. 

  7045. 

  7046.     other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
    7047. 

  7047.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    7048. 

  7048.         "%s :  Reserved",
    7049. 

  7049.         a_bigbuf);
    7050. 

  7050. 

  7051.     other_decode_bitfield_value(a_bigbuf, oct, 0x3f, 8);
    7052. 

  7052.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    7053. 

  7053.         "%s :  DROP_INTERCEPT: %u",
    7054. 

  7054.         a_bigbuf,
    7055. 

  7055.         oct & 0x3f);
    7056. 

  7056. 

  7057.     curr_offset++;
    7058. 

  7058. 

  7059.     NO_MORE_DATA_CHECK(len);
    7060. 

  7060. 

  7061.     oct = tvb_get_guint8(tvb, curr_offset);
    7062. 

  7062. 

  7063.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    7064. 

  7064.         "Target BS P_REV: %u",
    7065. 

  7065.         oct);
    7066. 

  7066. 

  7067.     curr_offset++;
    7068. 

  7068. 

  7069.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    7070. 

  7070. 

  7071.     return(curr_offset - offset);
    7072. 

  7072. }
    7073. 

  7073. 

  7074. /*
    7075. 

  7075.  * IOS 6.2.2.74
    7076. 

  7076.  * UNUSED in SPEC and no IEI!
    7077. 

  7077.  */
    7078. 

  7078. 

  7079. /*
    7080. 

  7080.  * IOS 6.2.2.75
    7081. 

  7081.  * UNUSED in SPEC and no IEI!
    7082. 

  7082.  */
    7083. 

  7083. 

  7084. /*
    7085. 

  7085.  * IOS 6.2.2.76
    7086. 

  7086.  * UNUSED
    7087. 

  7087.  */
    7088. 

  7088. 

  7089. /*
    7090. 

  7090.  * IOS 6.2.2.77
    7091. 

  7091.  * UNUSED in SPEC and no IEI!
    7092. 

  7092.  */
    7093. 

  7093. 

  7094. /*
    7095. 

  7095.  * IOS 6.2.2.78
    7096. 

  7096.  * UNUSED in SPEC and no IEI!
    7097. 

  7097.  */
    7098. 

  7098. 

  7099. /*
    7100. 

  7100.  * IOS 6.2.2.79
    7101. 

  7101.  */
    7102. 

  7102. static guint8
    7103. 

  7103. elem_cdma_sowd(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    7104. 

  7104. {
    7105. 

  7105.     guint8      oct;
    7106. 

  7106.     guint32     value;
    7107. 

  7107.     guint32     curr_offset;
    7108. 

  7108.     const gchar *str = NULL;
    7109. 

  7109. 

  7110.     curr_offset = offset;
    7111. 

  7111. 

  7112.     curr_offset += elem_cell_id(tvb, pinfo, tree, offset, len, add_string, string_len);
    7113. 

  7113.     add_string[0] = '\0';
    7114. 

  7114. 

  7115.     value = tvb_get_ntohs(tvb, curr_offset);
    7116. 

  7116. 

  7117.     proto_tree_add_text(tree,
    7118. 

  7118.         tvb, curr_offset, 2,
    7119. 

  7119.         "CDMA Serving One Way Delay: %u",
    7120. 

  7120.         value);
    7121. 

  7121. 

  7122.     curr_offset += 2;
    7123. 

  7123. 

  7124.     oct = tvb_get_guint8(tvb, curr_offset);
    7125. 

  7125. 

  7126.     other_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8);
    7127. 

  7127.     proto_tree_add_text(tree,
    7128. 

  7128.         tvb, curr_offset, 1,
    7129. 

  7129.         "%s :  Reserved",
    7130. 

  7130.         a_bigbuf);
    7131. 

  7131. 

  7132.     switch (oct & 0x03)
    7133. 

  7133.     {
    7134. 

  7134.     case 0: str = "100 nsec"; break;
    7135. 

  7135.     case 1: str = "50 nsec"; break;
    7136. 

  7136.     case 2: str = "1/16 CDMA PN Chip"; break;
    7137. 

  7137.     case 3: str = "Reserved"; break;
    7138. 

  7138.     }
    7139. 

  7139. 

  7140.     other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
    7141. 

  7141.     proto_tree_add_text(tree,
    7142. 

  7142.         tvb, curr_offset, 1,
    7143. 

  7143.         "%s :  Resolution: %s",
    7144. 

  7144.         a_bigbuf,
    7145. 

  7145.         str);
    7146. 

  7146. 

  7147.     curr_offset++;
    7148. 

  7148. 

  7149.     if ((len - (curr_offset - offset)) > 1)
    7150. 

  7150.     {
    7151. 

  7151.         proto_tree_add_text(tree,
    7152. 

  7152.             tvb, curr_offset, 2,
    7153. 

  7153.             "Timestamp");
    7154. 

  7154. 

  7155.         curr_offset += 2;
    7156. 

  7156.     }
    7157. 

  7157. 

  7158.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    7159. 

  7159. 

  7160.     return(curr_offset - offset);
    7161. 

  7161. }
    7162. 

  7162. 

  7163. /*
    7164. 

  7164.  * IOS 6.2.2.80
    7165. 

  7165.  * UNUSED
    7166. 

  7166.  */
    7167. 

  7167. 

  7168. /*
    7169. 

  7169.  * IOS 6.2.2.81
    7170. 

  7170.  * UNUSED
    7171. 

  7171.  */
    7172. 

  7172. 

  7173. /*
    7174. 

  7174.  * IOS 6.2.2.82
    7175. 

  7175.  */
    7176. 

  7176. static guint8
    7177. 

  7177. elem_re_res(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string _U_, int string_len _U_)
    7178. 

  7178. {
    7179. 

  7179.     guint8      oct;
    7180. 

  7180.     guint32     curr_offset;
    7181. 

  7181.     const gchar *str;
    7182. 

  7182. 

  7183.     curr_offset = offset;
    7184. 

  7184. 

  7185.     oct = tvb_get_guint8(tvb, curr_offset);
    7186. 

  7186. 

  7187.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    7188. 

  7188.     proto_tree_add_text(tree,
    7189. 

  7189.         tvb, curr_offset, 1,
    7190. 

  7190.         "%s :  Reserved",
    7191. 

  7191.         a_bigbuf);
    7192. 

  7192. 

  7193.     other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
    7194. 

  7194.     proto_tree_add_text(tree,
    7195. 

  7195.         tvb, curr_offset, 1,
    7196. 

  7196.         "%s :  Include Priority: MSC %s include priority in Assignment Request",
    7197. 

  7197.         a_bigbuf,
    7198. 

  7198.         (oct & 0x40) ? "should" : "does not need to");
    7199. 

  7199. 

  7200.     switch ((oct & 0x30) >> 4)
    7201. 

  7201.     {
    7202. 

  7202.     case 0: str = "Not reported"; break;
    7203. 

  7203.     case 1: str = "radio environment is acceptable"; break;
    7204. 

  7204.     case 2: str = "radio environment is marginally acceptable"; break;
    7205. 

  7205.     default:
    7206. 

  7206.         str = "radio environment is poor";
    7207. 

  7207.         break;
    7208. 

  7208.     }
    7209. 

  7209. 

  7210.     other_decode_bitfield_value(a_bigbuf, oct, 0x30, 8);
    7211. 

  7211.     proto_tree_add_text(tree,
    7212. 

  7212.         tvb, curr_offset, 1,
    7213. 

  7213.         "%s :  Forward: %s",
    7214. 

  7214.         a_bigbuf,
    7215. 

  7215.         str);
    7216. 

  7216. 

  7217.     switch ((oct & 0x0c) >> 2)
    7218. 

  7218.     {
    7219. 

  7219.     case 0: str = "Not reported"; break;
    7220. 

  7220.     case 1: str = "radio environment is acceptable"; break;
    7221. 

  7221.     case 2: str = "radio environment is marginally acceptable"; break;
    7222. 

  7222.     default:
    7223. 

  7223.         str = "radio environment is poor";
    7224. 

  7224.         break;
    7225. 

  7225.     }
    7226. 

  7226. 

  7227.     other_decode_bitfield_value(a_bigbuf, oct, 0x0c, 8);
    7228. 

  7228.     proto_tree_add_text(tree,
    7229. 

  7229.         tvb, curr_offset, 1,
    7230. 

  7230.         "%s :  Reverse: %s",
    7231. 

  7231.         a_bigbuf,
    7232. 

  7232.         str);
    7233. 

  7233. 

  7234.     other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
    7235. 

  7235.     proto_tree_add_text(tree,
    7236. 

  7236.         tvb, curr_offset, 1,
    7237. 

  7237.         "%s :  Alloc: resources are %sallocated",
    7238. 

  7238.         a_bigbuf,
    7239. 

  7239.         (oct & 0x02) ? "" : "not ");
    7240. 

  7240. 

  7241.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    7242. 

  7242.     proto_tree_add_text(tree,
    7243. 

  7243.         tvb, curr_offset, 1,
    7244. 

  7244.         "%s :  Avail: resources are %savailable",
    7245. 

  7245.         a_bigbuf,
    7246. 

  7246.         (oct & 0x01) ? "" : "not ");
    7247. 

  7247. 

  7248.     curr_offset++;
    7249. 

  7249. 

  7250.     /* no length check possible */
    7251. 

  7251. 

  7252.     return(curr_offset - offset);
    7253. 

  7253. }
    7254. 

  7254. 

  7255. /*
    7256. 

  7256.  * IOS 6.2.2.83
    7257. 

  7257.  * UNUSED in SPEC and no IEI!
    7258. 

  7258.  */
    7259. 

  7259. 

  7260. /*
    7261. 

  7261.  * IOS 6.2.2.84
    7262. 

  7262.  * UNUSED
    7263. 

  7263.  */
    7264. 

  7264. 

  7265. /*
    7266. 

  7266.  * IOS 6.2.2.85
    7267. 

  7267.  * UNUSED
    7268. 

  7268.  */
    7269. 

  7269. 

  7270. /*
    7271. 

  7271.  * IOS 6.2.2.86
    7272. 

  7272.  * UNUSED
    7273. 

  7273.  */
    7274. 

  7274. 

  7275. /*
    7276. 

  7276.  * IOS 6.2.2.87
    7277. 

  7277.  * UNUSED
    7278. 

  7278.  */
    7279. 

  7279. 

  7280. /*
    7281. 

  7281.  * IOS 6.2.2.88
    7282. 

  7282.  * UNUSED
    7283. 

  7283.  */
    7284. 

  7284. 

  7285. /*
    7286. 

  7286.  * IOS 6.2.2.89
    7287. 

  7287.  * A3/A7
    7288. 

  7288.  */
    7289. 

  7289. 

  7290. /*
    7291. 

  7291.  * IOS 6.2.2.90
    7292. 

  7292.  * UNUSED in SPEC and no IEI!
    7293. 

  7293.  */
    7294. 

  7294. 

  7295. /*
    7296. 

  7296.  * IOS 6.2.2.91
    7297. 

  7297.  * A3/A7
    7298. 

  7298.  */
    7299. 

  7299. 

  7300. /*
    7301. 

  7301.  * IOS 6.2.2.92
    7302. 

  7302.  * UNUSED
    7303. 

  7303.  */
    7304. 

  7304. 

  7305. /*
    7306. 

  7306.  * IOS 6.2.2.93
    7307. 

  7307.  * UNUSED
    7308. 

  7308.  */
    7309. 

  7309. 

  7310. /*
    7311. 

  7311.  * IOS 6.2.2.94
    7312. 

  7312.  * UNUSED
    7313. 

  7313.  */
    7314. 

  7314. 

  7315. /*
    7316. 

  7316.  * IOS 6.2.2.95
    7317. 

  7317.  * UNUSED
    7318. 

  7318.  */
    7319. 

  7319. 

  7320. /*
    7321. 

  7321.  * IOS 6.2.2.96
    7322. 

  7322.  * A3/A7
    7323. 

  7323.  */
    7324. 

  7324. 

  7325. /*
    7326. 

  7326.  * IOS 6.2.2.97
    7327. 

  7327.  * A3/A7
    7328. 

  7328.  */
    7329. 

  7329. 

  7330. /*
    7331. 

  7331.  * IOS 6.2.2.98
    7332. 

  7332.  * A3/A7
    7333. 

  7333.  */
    7334. 

  7334. 

  7335. /*
    7336. 

  7336.  * IOS 6.2.2.99
    7337. 

  7337.  * A3/A7
    7338. 

  7338.  */
    7339. 

  7339. 

  7340. /*
    7341. 

  7341.  * IOS 6.2.2.100
    7342. 

  7342.  * UNUSED
    7343. 

  7343.  */
    7344. 

  7344. 

  7345. /*
    7346. 

  7346.  * IOS 6.2.2.101
    7347. 

  7347.  * UNUSED
    7348. 

  7348.  */
    7349. 

  7349. 

  7350. /*
    7351. 

  7351.  * IOS 6.2.2.102
    7352. 

  7352.  * UNUSED
    7353. 

  7353.  */
    7354. 

  7354. 

  7355. /*
    7356. 

  7356.  * IOS 6.2.2.103
    7357. 

  7357.  * UNUSED
    7358. 

  7358.  */
    7359. 

  7359. 

  7360. /*
    7361. 

  7361.  * IOS 6.2.2.104
    7362. 

  7362.  * UNUSED
    7363. 

  7363.  */
    7364. 

  7364. 

  7365. /*
    7366. 

  7366.  * IOS 6.2.2.105
    7367. 

  7367.  */
    7368. 

  7368. static guint8
    7369. 

  7369. elem_cld_party_ascii_num(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    7370. 

  7370. {
    7371. 

  7371.     guint8      oct;
    7372. 

  7372.     guint32     curr_offset;
    7373. 

  7373.     guint8      *poctets;
    7374. 

  7374.     const gchar *str;
    7375. 

  7375. 

  7376.     curr_offset = offset;
    7377. 

  7377. 

  7378.     oct = tvb_get_guint8(tvb, curr_offset);
    7379. 

  7379. 

  7380.     other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    7381. 

  7381.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    7382. 

  7382.         "%s :  Extension",
    7383. 

  7383.         a_bigbuf);
    7384. 

  7384. 

  7385.     switch ((oct & 0x70) >> 4)
    7386. 

  7386.     {
    7387. 

  7387.     case 0: str = "Unknown"; break;
    7388. 

  7388.     case 1: str = "International number"; break;
    7389. 

  7389.     case 2: str = "National number"; break;
    7390. 

  7390.     case 3: str = "Network specific number"; break;
    7391. 

  7391.     case 4: str = "Dedicated PAD access, short code"; break;
    7392. 

  7392.     case 7: str = "Reserved for extension"; break;
    7393. 

  7393.     default:
    7394. 

  7394.         str = "Reserved";
    7395. 

  7395.         break;
    7396. 

  7396.     }
    7397. 

  7397. 

  7398.     other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
    7399. 

  7399.     proto_tree_add_text(tree,
    7400. 

  7400.         tvb, curr_offset, 1,
    7401. 

  7401.         "%s :  Type of Number: %s",
    7402. 

  7402.         a_bigbuf,
    7403. 

  7403.         str);
    7404. 

  7404. 

  7405.     switch (oct & 0x0f)
    7406. 

  7406.     {
    7407. 

  7407.     case 0x00: str = "Unknown"; break;
    7408. 

  7408.     case 0x01: str = "ISDN/telephony number plan (ITU recommendation E.164/E.163)"; break;
    7409. 

  7409.     case 0x03: str = "Data number plan (ITU recommendation X.121)"; break;
    7410. 

  7410.     case 0x04: str = "Telex numbering plan (ITU recommendation F.69)"; break;
    7411. 

  7411.     case 0x07: str = "Reserved for extension"; break;
    7412. 

  7412.     case 0x08: str = "National numbering plan"; break;
    7413. 

  7413.     case 0x09: str = "Private numbering plan"; break;
    7414. 

  7414.     default:
    7415. 

  7415.         str = "Reserved";
    7416. 

  7416.         break;
    7417. 

  7417.     }
    7418. 

  7418. 

  7419.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    7420. 

  7420.     proto_tree_add_text(tree,
    7421. 

  7421.         tvb, curr_offset, 1,
    7422. 

  7422.         "%s :  Numbering Plan Identification: %s",
    7423. 

  7423.         a_bigbuf,
    7424. 

  7424.         str);
    7425. 

  7425. 

  7426.     curr_offset++;
    7427. 

  7427. 

  7428.     poctets = tvb_get_ephemeral_string(tvb, curr_offset, len - (curr_offset - offset));
    7429. 

  7429. 

  7430.     proto_tree_add_string_format(tree, hf_ansi_a_cld_party_ascii_num,
    7431. 

  7431.         tvb, curr_offset, len - (curr_offset - offset),
    7432. 

  7432.         (gchar *) poctets,
    7433. 

  7433.         "Digits: %s",
    7434. 

  7434.         (gchar *) format_text(poctets, len - (curr_offset - offset)));
    7435. 

  7435. 

  7436.     curr_offset += len - (curr_offset - offset);
    7437. 

  7437. 

  7438.     g_snprintf(add_string, string_len, " - (%s)", poctets);
    7439. 

  7439. 

  7440.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    7441. 

  7441. 

  7442.     return(curr_offset - offset);
    7443. 

  7443. }
    7444. 

  7444. 

  7445. /*
    7446. 

  7446.  * IOS 6.2.2.106
    7447. 

  7447.  */
    7448. 

  7448. static guint8
    7449. 

  7449. elem_band_class(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    7450. 

  7450. {
    7451. 

  7451.     guint8      oct;
    7452. 

  7452.     guint32     curr_offset;
    7453. 

  7453.     gint        temp_int;
    7454. 

  7454.     const gchar *str;
    7455. 

  7455. 

  7456.     curr_offset = offset;
    7457. 

  7457. 

  7458.     oct = tvb_get_guint8(tvb, curr_offset);
    7459. 

  7459. 

  7460.     other_decode_bitfield_value(a_bigbuf, oct, 0xe0, 8);
    7461. 

  7461.     proto_tree_add_text(tree,
    7462. 

  7462.         tvb, curr_offset, 1,
    7463. 

  7463.         "%s :  Reserved",
    7464. 

  7464.         a_bigbuf);
    7465. 

  7465. 

  7466.     temp_int = oct & 0x1f;
    7467. 

  7467.     if ((temp_int < 0) || (temp_int >= (gint) NUM_BAND_CLASS_STR))
    7468. 

  7468.     {
    7469. 

  7469.         str = "Reserved";
    7470. 

  7470.     }
    7471. 

  7471.     else
    7472. 

  7472.     {
    7473. 

  7473.         str = band_class_str[temp_int];
    7474. 

  7474.     }
    7475. 

  7475. 

  7476.     other_decode_bitfield_value(a_bigbuf, oct, 0x1f, 8);
    7477. 

  7477.     proto_tree_add_text(tree,
    7478. 

  7478.         tvb, curr_offset, 1,
    7479. 

  7479.         "%s :  Band Class: %s",
    7480. 

  7480.         a_bigbuf,
    7481. 

  7481.         str);
    7482. 

  7482. 

  7483.     curr_offset++;
    7484. 

  7484. 

  7485.     g_snprintf(add_string, string_len, " - (%s)", str);
    7486. 

  7486. 

  7487.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    7488. 

  7488. 

  7489.     return(curr_offset - offset);
    7490. 

  7490. }
    7491. 

  7491. 

  7492. /*
    7493. 

  7493.  * IOS 6.2.2.107
    7494. 

  7494.  * UNUSED
    7495. 

  7495.  */
    7496. 

  7496. 

  7497. /*
    7498. 

  7498.  * IOS 6.2.2.108
    7499. 

  7499.  * A3/A7
    7500. 

  7500.  */
    7501. 

  7501. 

  7502. /*
    7503. 

  7503.  * IOS 6.2.2.109
    7504. 

  7504.  * A3/A7
    7505. 

  7505.  */
    7506. 

  7506. 

  7507. /*
    7508. 

  7508.  * IOS 6.2.2.110
    7509. 

  7509.  */
    7510. 

  7510. static guint8
    7511. 

  7511. elem_is2000_cause(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    7512. 

  7512. {
    7513. 

  7513.     guint32     curr_offset;
    7514. 

  7514. 

  7515.     curr_offset = offset;
    7516. 

  7516. 

  7517.     proto_tree_add_text(tree, tvb, curr_offset, len, "IS-95/IS-2000 Cause Information");
    7518. 

  7518. 

  7519.     curr_offset += len;
    7520. 

  7520. 

  7521.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    7522. 

  7522. 

  7523.     return(curr_offset - offset);
    7524. 

  7524. }
    7525. 

  7525. 

  7526. /*
    7527. 

  7527.  * IOS 6.2.2.111
    7528. 

  7528.  * UNUSED
    7529. 

  7529.  */
    7530. 

  7530. 

  7531. /*
    7532. 

  7532.  * IOS 6.2.2.112
    7533. 

  7533.  * UNUSED
    7534. 

  7534.  */
    7535. 

  7535. 

  7536. /*
    7537. 

  7537.  * IOS 6.2.2.113
    7538. 

  7538.  * UNUSED
    7539. 

  7539.  */
    7540. 

  7540. 

  7541. /*
    7542. 

  7542.  * IOS 6.2.2.114
    7543. 

  7543.  */
    7544. 

  7544. static guint8
    7545. 

  7545. elem_auth_event(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    7546. 

  7546. {
    7547. 

  7547.     guint8      oct;
    7548. 

  7548.     guint32     curr_offset;
    7549. 

  7549.     const gchar *str;
    7550. 

  7550. 

  7551.     curr_offset = offset;
    7552. 

  7552. 

  7553.     if (len == 1)
    7554. 

  7554.     {
    7555. 

  7555.         oct = tvb_get_guint8(tvb, curr_offset);
    7556. 

  7556. 

  7557.         switch (oct)
    7558. 

  7558.         {
    7559. 

  7559.         case 0x01: str = "Event: Authentication parameters were NOT received from mobile"; break;
    7560. 

  7560.         case 0x02: str = "Event: RANDC mis-match"; break;
    7561. 

  7561.         case 0x03: str = "Event: Recently requested"; break;
    7562. 

  7562.         case 0x04: str = "Event: Direct channel assignment"; break;
    7563. 

  7563.         default:
    7564. 

  7564.             str = "Event";
    7565. 

  7565.             break;
    7566. 

  7566.         }
    7567. 

  7567. 

  7568.         proto_tree_add_text(tree, tvb, curr_offset, len,
    7569. 

  7569.             "%s", str);
    7570. 

  7570.     }
    7571. 

  7571.     else
    7572. 

  7572.     {
    7573. 

  7573.         proto_tree_add_text(tree, tvb, curr_offset, len, "Event");
    7574. 

  7574.     }
    7575. 

  7575. 

  7576.     curr_offset += len;
    7577. 

  7577. 

  7578.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    7579. 

  7579. 

  7580.     return(curr_offset - offset);
    7581. 

  7581. }
    7582. 

  7582. 

  7583. /*
    7584. 

  7584.  * IOS 6.2.2.115
    7585. 

  7585.  * UNUSED
    7586. 

  7586.  */
    7587. 

  7587. 

  7588. /*
    7589. 

  7589.  * IOS 6.2.2.116
    7590. 

  7590.  * UNUSED
    7591. 

  7591.  */
    7592. 

  7592. 

  7593. /*
    7594. 

  7594.  * IOS 6.2.2.117
    7595. 

  7595.  * UNUSED
    7596. 

  7596.  */
    7597. 

  7597. 

  7598. /*
    7599. 

  7599.  * IOS 6.2.2.118
    7600. 

  7600.  * UNUSED
    7601. 

  7601.  */
    7602. 

  7602. 

  7603. /*
    7604. 

  7604.  * IOS 6.2.2.119
    7605. 

  7605.  * A3/A7
    7606. 

  7606.  */
    7607. 

  7607. 

  7608. /*
    7609. 

  7609.  * IOS 6.2.2.120
    7610. 

  7610.  * A3/A7
    7611. 

  7611.  */
    7612. 

  7612. 

  7613. /*
    7614. 

  7614.  * IOS 6.2.2.121
    7615. 

  7615.  * A3/A7
    7616. 

  7616.  */
    7617. 

  7617. 

  7618. /*
    7619. 

  7619.  * IOS 6.2.2.122
    7620. 

  7620.  * UNUSED
    7621. 

  7621.  */
    7622. 

  7622. 

  7623. /*
    7624. 

  7624.  * IOS 6.2.2.123
    7625. 

  7625.  * UNUSED
    7626. 

  7626.  */
    7627. 

  7627. 

  7628. /*
    7629. 

  7629.  * IOS 6.2.2.124
    7630. 

  7630.  * UNUSED
    7631. 

  7631.  */
    7632. 

  7632. 

  7633. /*
    7634. 

  7634.  * IOS 6.2.2.125
    7635. 

  7635.  * A3/A7
    7636. 

  7636.  */
    7637. 

  7637. 

  7638. /*
    7639. 

  7639.  * IOS 6.2.2.126
    7640. 

  7640.  * UNUSED
    7641. 

  7641.  */
    7642. 

  7642. 

  7643. /*
    7644. 

  7644.  * IOS 6.2.2.127
    7645. 

  7645.  * UNUSED
    7646. 

  7646.  */
    7647. 

  7647. 

  7648. /*
    7649. 

  7649.  * IOS 6.2.2.128
    7650. 

  7650.  * A3/A7
    7651. 

  7651.  */
    7652. 

  7652. 

  7653. /*
    7654. 

  7654.  * IOS 6.2.2.129
    7655. 

  7655.  * UNUSED
    7656. 

  7656.  */
    7657. 

  7657. 

  7658. /*
    7659. 

  7659.  * IOS 6.2.2.130
    7660. 

  7660.  * UNUSED
    7661. 

  7661.  */
    7662. 

  7662. 

  7663. /*
    7664. 

  7664.  * IOS 6.2.2.131
    7665. 

  7665.  * UNUSED
    7666. 

  7666.  */
    7667. 

  7667. 

  7668. /*
    7669. 

  7669.  * IOS 6.2.2.132
    7670. 

  7670.  * A3/A7
    7671. 

  7671.  */
    7672. 

  7672. 

  7673. /*
    7674. 

  7674.  * IOS 6.2.2.133
    7675. 

  7675.  * UNUSED
    7676. 

  7676.  */
    7677. 

  7677. 

  7678. /*
    7679. 

  7679.  * IOS 6.2.2.134
    7680. 

  7680.  * A3/A7
    7681. 

  7681.  */
    7682. 

  7682. 

  7683. /*
    7684. 

  7684.  * IOS 6.2.2.135
    7685. 

  7685.  * UNUSED
    7686. 

  7686.  */
    7687. 

  7687. 

  7688. /*
    7689. 

  7689.  * IOS 6.2.2.136
    7690. 

  7690.  * UNUSED
    7691. 

  7691.  */
    7692. 

  7692. 

  7693. /*
    7694. 

  7694.  * IOS 6.2.2.137
    7695. 

  7695.  * Generic decode is good enough
    7696. 

  7696.  */
    7697. 

  7697. 

  7698. /*
    7699. 

  7699.  * IOS 6.2.2.138
    7700. 

  7700.  */
    7701. 

  7701. static guint8
    7702. 

  7702. elem_psmm_count(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    7703. 

  7703. {
    7704. 

  7704.     guint8      oct;
    7705. 

  7705.     guint32     curr_offset;
    7706. 

  7706. 

  7707.     curr_offset = offset;
    7708. 

  7708. 

  7709.     oct = tvb_get_guint8(tvb, curr_offset);
    7710. 

  7710. 

  7711.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    7712. 

  7712.     proto_tree_add_text(tree,
    7713. 

  7713.         tvb, curr_offset, 1,
    7714. 

  7714.         "%s :  Reserved",
    7715. 

  7715.         a_bigbuf);
    7716. 

  7716. 

  7717.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    7718. 

  7718.     proto_tree_add_text(tree,
    7719. 

  7719.         tvb, curr_offset, 1,
    7720. 

  7720.         "%s :  PSMM Count: %u",
    7721. 

  7721.         a_bigbuf,
    7722. 

  7722.         oct & 0x0f);
    7723. 

  7723. 

  7724.     curr_offset++;
    7725. 

  7725. 

  7726.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    7727. 

  7727. 

  7728.     return(curr_offset - offset);
    7729. 

  7729. }
    7730. 

  7730. 

  7731. /*
    7732. 

  7732.  * IOS 6.2.2.139
    7733. 

  7733.  */
    7734. 

  7734. static guint8
    7735. 

  7735. elem_geo_loc(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    7736. 

  7736. {
    7737. 

  7737.     guint32     curr_offset;
    7738. 

  7738. 

  7739.     curr_offset = offset;
    7740. 

  7740. 

  7741.     proto_tree_add_text(tree, tvb, curr_offset, len, "Calling Geodetic Location");
    7742. 

  7742. 

  7743.     curr_offset += len;
    7744. 

  7744. 

  7745.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    7746. 

  7746. 

  7747.     return(curr_offset - offset);
    7748. 

  7748. }
    7749. 

  7749. 

  7750. /*
    7751. 

  7751.  * IOS 6.2.2.140
    7752. 

  7752.  * UNUSED
    7753. 

  7753.  */
    7754. 

  7754. 

  7755. /*
    7756. 

  7756.  * IOS 6.2.2.141
    7757. 

  7757.  * A3/A7
    7758. 

  7758.  */
    7759. 

  7759. 

  7760. /*
    7761. 

  7761.  * IOS 6.2.2.142
    7762. 

  7762.  * A3/A7
    7763. 

  7763.  */
    7764. 

  7764. 

  7765. /*
    7766. 

  7766.  * IOS 6.2.2.143
    7767. 

  7767.  * A3/A7
    7768. 

  7768.  */
    7769. 

  7769. 

  7770. /*
    7771. 

  7771.  * IOS 6.2.2.144
    7772. 

  7772.  * A3/A7
    7773. 

  7773.  */
    7774. 

  7774. 

  7775. /*
    7776. 

  7776.  * IOS 6.2.2.145
    7777. 

  7777.  * A3/A7
    7778. 

  7778.  */
    7779. 

  7779. 

  7780. /*
    7781. 

  7781.  * IOS 6.2.2.146
    7782. 

  7782.  * A3/A7
    7783. 

  7783.  */
    7784. 

  7784. 

  7785. /*
    7786. 

  7786.  * IOS 6.2.2.147
    7787. 

  7787.  * A3/A7
    7788. 

  7788.  */
    7789. 

  7789. 

  7790. /*
    7791. 

  7791.  * IOS 6.2.2.148
    7792. 

  7792.  */
    7793. 

  7793. static guint8
    7794. 

  7794. elem_cct_group(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    7795. 

  7795. {
    7796. 

  7796.     guint8      oct;
    7797. 

  7797.     guint32     value;
    7798. 

  7798.     guint32     curr_offset;
    7799. 

  7799. 

  7800.     curr_offset = offset;
    7801. 

  7801. 

  7802.     oct = tvb_get_guint8(tvb, curr_offset);
    7803. 

  7803. 

  7804.     other_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8);
    7805. 

  7805.     proto_tree_add_text(tree,
    7806. 

  7806.         tvb, curr_offset, 1,
    7807. 

  7807.         "%s :  Reserved",
    7808. 

  7808.         a_bigbuf);
    7809. 

  7809. 

  7810.     other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
    7811. 

  7811.     proto_tree_add_text(tree,
    7812. 

  7812.         tvb, curr_offset, 1,
    7813. 

  7813.         "%s :  All Circuits",
    7814. 

  7814.         a_bigbuf);
    7815. 

  7815. 

  7816.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    7817. 

  7817.     proto_tree_add_text(tree,
    7818. 

  7818.         tvb, curr_offset, 1,
    7819. 

  7819.         "%s :  Inclusive",
    7820. 

  7820.         a_bigbuf);
    7821. 

  7821. 

  7822.     curr_offset++;
    7823. 

  7823. 

  7824.     NO_MORE_DATA_CHECK(len);
    7825. 

  7825. 

  7826.     oct = tvb_get_guint8(tvb, curr_offset);
    7827. 

  7827. 

  7828.     proto_tree_add_text(tree,
    7829. 

  7829.         tvb, curr_offset, 1,
    7830. 

  7830.         "Count: %u circuit%s",
    7831. 

  7831.         oct, plurality(oct, "", "s"));
    7832. 

  7832. 

  7833.     g_snprintf(add_string, string_len, " - %u circuit%s",
    7834. 

  7834.         oct, plurality(oct, "", "s"));
    7835. 

  7835. 

  7836.     curr_offset++;
    7837. 

  7837. 

  7838.     value = tvb_get_ntohs(tvb, curr_offset);
    7839. 

  7839. 

  7840.     other_decode_bitfield_value(a_bigbuf, value, 0xffe0, 16);
    7841. 

  7841.     proto_tree_add_text(tree,
    7842. 

  7842.         tvb, curr_offset, 2,
    7843. 

  7843.         "%s :  PCM Multiplexer: %u",
    7844. 

  7844.         a_bigbuf,
    7845. 

  7845.         (value & 0xffe0) >> 5);
    7846. 

  7846. 

  7847.     other_decode_bitfield_value(a_bigbuf, value, 0x001f, 16);
    7848. 

  7848.     proto_tree_add_text(tree,
    7849. 

  7849.         tvb, curr_offset, 2,
    7850. 

  7850.         "%s :  Timeslot: %u",
    7851. 

  7851.         a_bigbuf,
    7852. 

  7852.         value & 0x001f);
    7853. 

  7853. 

  7854.     curr_offset += 2;
    7855. 

  7855. 

  7856.     NO_MORE_DATA_CHECK(len);
    7857. 

  7857. 

  7858.     proto_tree_add_text(tree,
    7859. 

  7859.         tvb, curr_offset, len - (curr_offset - offset),
    7860. 

  7860.         "Circuit Bitmap");
    7861. 

  7861. 

  7862.     curr_offset += len - (curr_offset - offset);
    7863. 

  7863. 

  7864.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    7865. 

  7865. 

  7866.     return(curr_offset - offset);
    7867. 

  7867. }
    7868. 

  7868. 

  7869. /*
    7870. 

  7870.  * IOS 6.2.2.149
    7871. 

  7871.  */
    7872. 

  7872. static guint8
    7873. 

  7873. elem_paca_ts(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    7874. 

  7874. {
    7875. 

  7875.     guint32     curr_offset;
    7876. 

  7876. 

  7877.     curr_offset = offset;
    7878. 

  7878. 

  7879.     proto_tree_add_text(tree, tvb, curr_offset, len, "PACA Queuing Time");
    7880. 

  7880. 

  7881.     curr_offset += len;
    7882. 

  7882. 

  7883.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    7884. 

  7884. 

  7885.     return(curr_offset - offset);
    7886. 

  7886. }
    7887. 

  7887. 

  7888. /*
    7889. 

  7889.  * IOS 6.2.2.150
    7890. 

  7890.  */
    7891. 

  7891. static guint8
    7892. 

  7892. elem_paca_order(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    7893. 

  7893. {
    7894. 

  7894.     guint8      oct;
    7895. 

  7895.     guint32     curr_offset;
    7896. 

  7896.     const gchar *str;
    7897. 

  7897. 

  7898.     curr_offset = offset;
    7899. 

  7899. 

  7900.     oct = tvb_get_guint8(tvb, curr_offset);
    7901. 

  7901. 

  7902.     other_decode_bitfield_value(a_bigbuf, oct, 0xf8, 8);
    7903. 

  7903.     proto_tree_add_text(tree,
    7904. 

  7904.         tvb, curr_offset, 1,
    7905. 

  7905.         "%s :  Reserved",
    7906. 

  7906.         a_bigbuf);
    7907. 

  7907. 

  7908.     switch (oct & 0x07)
    7909. 

  7909.     {
    7910. 

  7910.     case 0: str = "Reserved"; break;
    7911. 

  7911.     case 1: str = "Update Queue Position and notify MS"; break;
    7912. 

  7912.     case 2: str = "Remove MS from the queue and release MS"; break;
    7913. 

  7913.     case 3: str = "Remove MS from the queue"; break;
    7914. 

  7914.     case 4: str = "MS Requested PACA Cancel"; break;
    7915. 

  7915.     case 5: str = "BS Requested PACA Cancel"; break;
    7916. 

  7916.     default:
    7917. 

  7917.         str = "Reserved";
    7918. 

  7918.         break;
    7919. 

  7919.     }
    7920. 

  7920. 

  7921.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    7922. 

  7922.     proto_tree_add_text(tree,
    7923. 

  7923.         tvb, curr_offset, 1,
    7924. 

  7924.         "%s :  PACA Action Required: %s",
    7925. 

  7925.         a_bigbuf,
    7926. 

  7926.         str);
    7927. 

  7927. 

  7928.     curr_offset++;
    7929. 

  7929. 

  7930.     g_snprintf(add_string, string_len, " - (%s)", str);
    7931. 

  7931. 

  7932.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    7933. 

  7933. 

  7934.     return(curr_offset - offset);
    7935. 

  7935. }
    7936. 

  7936. 

  7937. /*
    7938. 

  7938.  * IOS 6.2.2.151
    7939. 

  7939.  */
    7940. 

  7940. static guint8
    7941. 

  7941. elem_paca_reoi(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    7942. 

  7942. {
    7943. 

  7943.     guint8      oct;
    7944. 

  7944.     guint32     curr_offset;
    7945. 

  7945. 

  7946.     curr_offset = offset;
    7947. 

  7947. 

  7948.     oct = tvb_get_guint8(tvb, curr_offset);
    7949. 

  7949. 

  7950.     other_decode_bitfield_value(a_bigbuf, oct, 0xfe, 8);
    7951. 

  7951.     proto_tree_add_text(tree,
    7952. 

  7952.         tvb, curr_offset, 1,
    7953. 

  7953.         "%s :  Reserved",
    7954. 

  7954.         a_bigbuf);
    7955. 

  7955. 

  7956.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    7957. 

  7957.     proto_tree_add_text(tree,
    7958. 

  7958.         tvb, curr_offset, 1,
    7959. 

  7959.         "%s :  PACA Reorigination Indicator (PRI)",
    7960. 

  7960.         a_bigbuf);
    7961. 

  7961. 

  7962.     curr_offset++;
    7963. 

  7963. 

  7964.     g_snprintf(add_string, string_len, " - (%sReorigination)", (oct & 0x01) ? "" : "Not ");
    7965. 

  7965. 

  7966.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    7967. 

  7967. 

  7968.     return(curr_offset - offset);
    7969. 

  7969. }
    7970. 

  7970. 

  7971. /*
    7972. 

  7972.  * IOS 5 4.2.89
    7973. 

  7973.  */
    7974. 

  7974. static guint8
    7975. 

  7975. elem_a2p_bearer_session(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    7976. 

  7976. {
    7977. 

  7977.     guint8      oct;
    7978. 

  7978.     guint32     curr_offset;
    7979. 

  7979. 

  7980.     curr_offset = offset;
    7981. 

  7981. 

  7982.     oct = tvb_get_guint8(tvb, curr_offset);
    7983. 

  7983. 

  7984.     other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
    7985. 

  7985.     proto_tree_add_text(tree,
    7986. 

  7986.         tvb, curr_offset, 1,
    7987. 

  7987.         "%s :  Reserved",
    7988. 

  7988.         a_bigbuf);
    7989. 

  7989. 

  7990.     other_decode_bitfield_value(a_bigbuf, oct, 0x38, 8);
    7991. 

  7991.     proto_tree_add_text(tree,
    7992. 

  7992.         tvb, curr_offset, 1,
    7993. 

  7993.         "%s :  Max Frames: %u",
    7994. 

  7994.         a_bigbuf,
    7995. 

  7995.         (oct & 0x38) >> 3);
    7996. 

  7996. 

  7997.     other_decode_bitfield_value(a_bigbuf, oct, 0x06, 8);
    7998. 

  7998.     proto_tree_add_text(tree,
    7999. 

  7999.         tvb, curr_offset, 1,
    8000. 

  8000.         "%s :  Session IP Address Type: Internet Protocol IPv%s",
    8001. 

  8001.         a_bigbuf,
    8002. 

  8002.         ((oct & 0x06) >> 1) ? "6" : "4");
    8003. 

  8003. 

  8004.     other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    8005. 

  8005.     proto_tree_add_text(tree,
    8006. 

  8006.         tvb, curr_offset, 1,
    8007. 

  8007.         "%s :  Session Address Flag",
    8008. 

  8008.         a_bigbuf);
    8009. 

  8009. 

  8010.     curr_offset++;
    8011. 

  8011. 

  8012.     if (oct & 0x01)
    8013. 

  8013.     {
    8014. 

  8014.         /* session address included */
    8015. 

  8015. 

  8016.         if ((oct & 0x06) >> 1)
    8017. 

  8017.         {
    8018. 

  8018.             SHORT_DATA_CHECK(len - (curr_offset - offset), 18);
    8019. 

  8019. 

  8020.             proto_tree_add_item(tree, hf_ansi_a_a2p_bearer_ipv6_addr,
    8021. 

  8021.                 tvb, curr_offset, 16, ENC_NA);
    8022. 

  8022. 

  8023.             rtp_src_addr.type = AT_IPv6;
    8024. 

  8024.             rtp_src_addr.len = 16;
    8025. 

  8025.             rtp_src_addr.data = (guint8 *) &rtp_ipv6_addr;
    8026. 

  8026. 

  8027.             tvb_get_ipv6(tvb, curr_offset, &rtp_ipv6_addr);
    8028. 

  8028. 

  8029.             curr_offset += 16;
    8030. 

  8030.         }
    8031. 

  8031.         else
    8032. 

  8032.         {
    8033. 

  8033.             SHORT_DATA_CHECK(len - (curr_offset - offset), 6);
    8034. 

  8034. 

  8035.             proto_tree_add_item(tree, hf_ansi_a_a2p_bearer_ipv4_addr,
    8036. 

  8036.                 tvb, curr_offset, 4, ENC_BIG_ENDIAN);
    8037. 

  8037. 

  8038.             rtp_src_addr.type = AT_IPv4;
    8039. 

  8039.             rtp_src_addr.len = 4;
    8040. 

  8040.             rtp_src_addr.data = (guint8 *) &rtp_ipv4_addr;
    8041. 

  8041. 

  8042.             rtp_ipv4_addr = tvb_get_ipv4(tvb, curr_offset);
    8043. 

  8043. 

  8044.             curr_offset += 4;
    8045. 

  8045.         }
    8046. 

  8046. 

  8047.         proto_tree_add_item(tree, hf_ansi_a_a2p_bearer_udp_port,
    8048. 

  8048.             tvb, curr_offset, 2, ENC_BIG_ENDIAN);
    8049. 

  8049. 

  8050.         rtp_port = tvb_get_ntohs(tvb, curr_offset);
    8051. 

  8051. 

  8052.         curr_offset += 2;
    8053. 

  8053.     }
    8054. 

  8054. 

  8055.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    8056. 

  8056. 

  8057.     return(curr_offset - offset);
    8058. 

  8058. }
    8059. 

  8059. 

  8060. /*
    8061. 

  8061.  * IOS 5 4.2.90
    8062. 

  8062.  */
    8063. 

  8063. static guint8
    8064. 

  8064. elem_a2p_bearer_format(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    8065. 

  8065. {
    8066. 

  8066.     guint8                              oct;
    8067. 

  8067.     proto_item                          *item;
    8068. 

  8068.     proto_tree                          *subtree;
    8069. 

  8069.     guint8                              num_bearers;
    8070. 

  8070.     guint32                             curr_offset, orig_offset;
    8071. 

  8071.     guint8                              ip_addr_type;
    8072. 

  8072.     gboolean                            ext;
    8073. 

  8073.     guint8                              ext_len;
    8074. 

  8074.     const gchar                         *str;
    8075. 

  8075.     const gchar                         *mime_type;
    8076. 

  8076.     int                                 sample_rate;
    8077. 

  8077.     gboolean                            format_assigned;
    8078. 

  8078.     gboolean                            in_band_format_assigned;
    8079. 

  8079.     gboolean                            first_assigned_found;
    8080. 

  8080.     gboolean                            rtp_dyn_payload_used;
    8081. 

  8081.     guint8                              rtp_payload_type;
    8082. 

  8082.     GHashTable                          *rtp_dyn_payload;
    8083. 

  8083.     gint                                *key;
    8084. 

  8084.     encoding_name_and_rate_t            *encoding_name_and_rate;
    8085. 

  8085. 

  8086.     rtp_dyn_payload = g_hash_table_new(g_int_hash, g_int_equal);
    8087. 

  8087.     rtp_dyn_payload_used = FALSE;
    8088. 

  8088. 

  8089.     first_assigned_found = FALSE;
    8090. 

  8090. 

  8091.     curr_offset = offset;
    8092. 

  8092. 

  8093.     oct = tvb_get_guint8(tvb, curr_offset);
    8094. 

  8094. 

  8095.     other_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8);
    8096. 

  8096.     proto_tree_add_text(tree,
    8097. 

  8097.         tvb, curr_offset, 1,
    8098. 

  8098.         "%s :  Number of Bearer Formats: %u",
    8099. 

  8099.         a_bigbuf,
    8100. 

  8100.         (oct & 0xfc) >> 2);
    8101. 

  8101. 

  8102.     other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
    8103. 

  8103.     proto_tree_add_text(tree,
    8104. 

  8104.         tvb, curr_offset, 1,
    8105. 

  8105.         "%s :  Session IP Address Type: Internet Protocol IPv%s",
    8106. 

  8106.         a_bigbuf,
    8107. 

  8107.         (oct & 0x03) ? "6" : "4");
    8108. 

  8108. 

  8109.     ip_addr_type = (oct & 0x03);
    8110. 

  8110. 

  8111.     curr_offset++;
    8112. 

  8112. 

  8113.     num_bearers = 0;
    8114. 

  8114. 

  8115.     while ((len - (curr_offset - offset)) > 0)
    8116. 

  8116.     {
    8117. 

  8117.         orig_offset = curr_offset;
    8118. 

  8118. 

  8119.         item =
    8120. 

  8120.             proto_tree_add_text(tree,
    8121. 

  8121.                 tvb, curr_offset, -1,
    8122. 

  8122.                 "Bearer Format [%u]",
    8123. 

  8123.                 num_bearers + 1);
    8124. 

  8124. 

  8125.         subtree = proto_item_add_subtree(item, ett_bearer_list);
    8126. 

  8126. 

  8127.         oct = tvb_get_guint8(tvb, curr_offset);
    8128. 

  8128. 

  8129.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    8130. 

  8130.             "Bearer Format Length: %u",
    8131. 

  8131.             oct);
    8132. 

  8132. 

  8133.         curr_offset++;
    8134. 

  8134. 

  8135.         NO_MORE_DATA_CHECK(len);
    8136. 

  8136. 

  8137.         oct = tvb_get_guint8(tvb, curr_offset);
    8138. 

  8138. 

  8139.         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
    8140. 

  8140.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    8141. 

  8141.             "%s :  Extension",
    8142. 

  8142.             a_bigbuf);
    8143. 

  8143. 

  8144.         ext = (oct & 0x80) ? TRUE : FALSE;
    8145. 

  8145. 

  8146.         format_assigned = FALSE;
    8147. 

  8147.         in_band_format_assigned = FALSE;
    8148. 

  8148. 

  8149.         switch ((oct & 0x70) >> 4)
    8150. 

  8150.         {
    8151. 

  8151.         case 0: str = "Unknown"; break;
    8152. 

  8152.         case 1:
    8153. 

  8153.             str = "In-band signaling";
    8154. 

  8154.             in_band_format_assigned = TRUE;
    8155. 

  8155.             break;
    8156. 

  8156.         case 2:
    8157. 

  8157.             str = "Assigned";
    8158. 

  8158.             format_assigned = TRUE;
    8159. 

  8159.             break;
    8160. 

  8160.         case 3: str = "Unassigned"; break;
    8161. 

  8161.         case 4: str = "Transcoded"; break;
    8162. 

  8162.         default:
    8163. 

  8163.             str = "Reserved";
    8164. 

  8164.             break;
    8165. 

  8165.         }
    8166. 

  8166. 

  8167.         other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
    8168. 

  8168.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    8169. 

  8169.             "%s :  Bearer Format Tag Type: %s",
    8170. 

  8170.             a_bigbuf,
    8171. 

  8171.             str);
    8172. 

  8172. 

  8173.         /*
    8174. 

  8174.          * assuming default sampling rate of 8000Hz
    8175. 

  8175.          */
    8176. 

  8176.         sample_rate = 8000;
    8177. 

  8177. 

  8178.         switch (oct & 0x0f)
    8179. 

  8179.         {
    8180. 

  8180.         case 0: mime_type = str = "PCMU"; break;
    8181. 

  8181.         case 1: mime_type = str = "PCMA"; break;
    8182. 

  8182.         case 2:
    8183. 

  8183.             str = "13K Vocoder";
    8184. 

  8184.             mime_type = "QCELP";
    8185. 

  8185.             break;
    8186. 

  8186.         case 3: mime_type = str = "EVRC"; break;
    8187. 

  8187.         case 4: mime_type = str = "EVRC0"; break;
    8188. 

  8188.         case 5: mime_type = str = "SMV"; break;
    8189. 

  8189.         case 6: mime_type = str = "SMV0"; break;
    8190. 

  8190.         case 7: mime_type = str = "telephone-event"; break;
    8191. 

  8191.         case 8: mime_type = str = "EVRCB"; break;
    8192. 

  8192.         case 9: mime_type = str = "EVRCB0"; break;
    8193. 

  8193.         case 10: mime_type = str = "EVRCWB"; sample_rate = 16000; break;
    8194. 

  8194.         case 11: mime_type = str = "EVRCWB0"; sample_rate = 16000; break;
    8195. 

  8195.         case 12: mime_type = str = "EVRCNW"; sample_rate = 16000; break;
    8196. 

  8196.         case 13: mime_type = str = "EVRCNW0"; sample_rate = 16000; break;
    8197. 

  8197.         default:
    8198. 

  8198.             mime_type = str = "Reserved";
    8199. 

  8199.             break;
    8200. 

  8200.         }
    8201. 

  8201. 

  8202.         other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    8203. 

  8203.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    8204. 

  8204.             "%s :  Bearer Format ID: %s",
    8205. 

  8205.             a_bigbuf,
    8206. 

  8206.             str);
    8207. 

  8207. 

  8208.         proto_item_append_text(item, " - (%s)", str);
    8209. 

  8209. 

  8210.         curr_offset++;
    8211. 

  8211. 

  8212.         NO_MORE_DATA_CHECK(len);
    8213. 

  8213. 

  8214.         oct = tvb_get_guint8(tvb, curr_offset);
    8215. 

  8215. 

  8216.         rtp_payload_type = (oct & 0xfe) >> 1;
    8217. 

  8217. 

  8218.         other_decode_bitfield_value(a_bigbuf, oct, 0xfe, 8);
    8219. 

  8219.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    8220. 

  8220.             "%s :  RTP Payload Type: %u",
    8221. 

  8221.             a_bigbuf,
    8222. 

  8222.             rtp_payload_type);
    8223. 

  8223. 

  8224.         other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
    8225. 

  8225.         proto_tree_add_text(subtree, tvb, curr_offset, 1,
    8226. 

  8226.             "%s :  Bearer Address Flag",
    8227. 

  8227.             a_bigbuf);
    8228. 

  8228. 

  8229.         curr_offset++;
    8230. 

  8230. 

  8231.         if (oct & 0x01)
    8232. 

  8232.         {
    8233. 

  8233.             /* bearer address included */
    8234. 

  8234. 

  8235.             if (ip_addr_type != 0)
    8236. 

  8236.             {
    8237. 

  8237.                 SHORT_DATA_CHECK(len - (curr_offset - offset), 18);
    8238. 

  8238. 

  8239.                 proto_tree_add_item(subtree, hf_ansi_a_a2p_bearer_ipv6_addr,
    8240. 

  8240.                     tvb, curr_offset, 16, ENC_NA);
    8241. 

  8241. 

  8242.                 if (format_assigned)
    8243. 

  8243.                 {
    8244. 

  8244.                     rtp_src_addr.type = AT_IPv6;
    8245. 

  8245.                     rtp_src_addr.len = 16;
    8246. 

  8246.                     rtp_src_addr.data = (guint8 *) &rtp_ipv6_addr;
    8247. 

  8247. 

  8248.                     tvb_get_ipv6(tvb, curr_offset, &rtp_ipv6_addr);
    8249. 

  8249.                 }
    8250. 

  8250. 

  8251.                 curr_offset += 16;
    8252. 

  8252.             }
    8253. 

  8253.             else
    8254. 

  8254.             {
    8255. 

  8255.                 SHORT_DATA_CHECK(len - (curr_offset - offset), 6);
    8256. 

  8256. 

  8257.                 proto_tree_add_item(subtree, hf_ansi_a_a2p_bearer_ipv4_addr,
    8258. 

  8258.                     tvb, curr_offset, 4, ENC_BIG_ENDIAN);
    8259. 

  8259. 

  8260.                 if (format_assigned)
    8261. 

  8261.                 {
    8262. 

  8262.                     rtp_src_addr.type = AT_IPv4;
    8263. 

  8263.                     rtp_src_addr.len = 4;
    8264. 

  8264.                     rtp_src_addr.data = (guint8 *) &rtp_ipv4_addr;
    8265. 

  8265. 

  8266.                     rtp_ipv4_addr = tvb_get_ipv4(tvb, curr_offset);
    8267. 

  8267.                 }
    8268. 

  8268. 

  8269.                 curr_offset += 4;
    8270. 

  8270.             }
    8271. 

  8271. 

  8272.             proto_tree_add_item(subtree, hf_ansi_a_a2p_bearer_udp_port,
    8273. 

  8273.                 tvb, curr_offset, 2, ENC_BIG_ENDIAN);
    8274. 

  8274. 

  8275.             if (format_assigned)
    8276. 

  8276.             {
    8277. 

  8277.                 rtp_port = tvb_get_ntohs(tvb, curr_offset);
    8278. 

  8278.             }
    8279. 

  8279. 

  8280.             curr_offset += 2;
    8281. 

  8281.         }
    8282. 

  8282. 

  8283.         if (ext)
    8284. 

  8284.         {
    8285. 

  8285.             SHORT_DATA_CHECK(len - (curr_offset - offset), 1);
    8286. 

  8286. 

  8287.             oct = tvb_get_guint8(tvb, curr_offset);
    8288. 

  8288. 

  8289.             ext_len = (oct & 0xf0) >> 4;
    8290. 

  8290. 

  8291.             other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    8292. 

  8292.             proto_tree_add_text(subtree, tvb, curr_offset, 1,
    8293. 

  8293.                 "%s :  Extension Length: %u",
    8294. 

  8294.                 a_bigbuf,
    8295. 

  8295.                 ext_len);
    8296. 

  8296. 

  8297.             other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    8298. 

  8298.             proto_tree_add_text(subtree, tvb, curr_offset, 1,
    8299. 

  8299.                 "%s :  Extension ID: %u",
    8300. 

  8300.                 a_bigbuf,
    8301. 

  8301.                 (oct & 0x0f));
    8302. 

  8302. 

  8303.             curr_offset++;
    8304. 

  8304. 

  8305.             if (ext_len > 0)
    8306. 

  8306.             {
    8307. 

  8307.                 SHORT_DATA_CHECK(len - (curr_offset - offset), ext_len);
    8308. 

  8308. 

  8309.                 proto_tree_add_text(subtree, tvb, curr_offset, ext_len,
    8310. 

  8310.                     "Extension Parameter value");
    8311. 

  8311. 

  8312.                 curr_offset += ext_len;
    8313. 

  8313.             }
    8314. 

  8314.         }
    8315. 

  8315. 

  8316.         proto_item_set_len(item, curr_offset - orig_offset);
    8317. 

  8317. 

  8318.         if (rtp_handle &&
    8319. 

  8319.             format_assigned &&
    8320. 

  8320.             (first_assigned_found == FALSE))
    8321. 

  8321.         {
    8322. 

  8322.             key  = wmem_new(wmem_file_scope(), gint);
    8323. 

  8323.             *key = rtp_payload_type;
    8324. 

  8324. 

  8325.             encoding_name_and_rate = wmem_new(wmem_file_scope(), encoding_name_and_rate_t);
    8326. 

  8326.             encoding_name_and_rate->encoding_name = wmem_strdup(wmem_file_scope(), mime_type);
    8327. 

  8327.             encoding_name_and_rate->sample_rate = sample_rate;
    8328. 

  8328. 

  8329.             g_hash_table_insert(rtp_dyn_payload, key, encoding_name_and_rate);
    8330. 

  8330.             rtp_dyn_payload_used = TRUE;
    8331. 

  8331. 

  8332.             first_assigned_found = TRUE;
    8333. 

  8333.             rtp_add_address(pinfo, &rtp_src_addr, rtp_port, 0, "IOS5",
    8334. 

  8334.                 pinfo->fd->num, FALSE, rtp_dyn_payload);
    8335. 

  8335.         }
    8336. 

  8336. 

  8337.         if (in_band_format_assigned)
    8338. 

  8338.         {
    8339. 

  8339.             key = (gint *) wmem_alloc(wmem_file_scope(), sizeof(gint));
    8340. 

  8340.             *key = rtp_payload_type;
    8341. 

  8341. 

  8342.             encoding_name_and_rate = wmem_new(wmem_file_scope(), encoding_name_and_rate_t);
    8343. 

  8343.             encoding_name_and_rate->encoding_name = wmem_strdup(wmem_file_scope(), "telephone-event");
    8344. 

  8344.             encoding_name_and_rate->sample_rate = sample_rate;
    8345. 

  8345. 

  8346.             g_hash_table_insert(rtp_dyn_payload, key, encoding_name_and_rate);
    8347. 

  8347.             rtp_dyn_payload_used = TRUE;
    8348. 

  8348.         }
    8349. 

  8349. 

  8350.         num_bearers++;
    8351. 

  8351.     }
    8352. 

  8352. 

  8353.     if (rtp_dyn_payload_used == FALSE)
    8354. 

  8354.     {
    8355. 

  8355.         rtp_free_hash_dyn_payload(rtp_dyn_payload);
    8356. 

  8356.     }
    8357. 

  8357. 

  8358.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    8359. 

  8359. 

  8360.     return(curr_offset - offset);
    8361. 

  8361. }
    8362. 

  8362. 

  8363. /*
    8364. 

  8364.  * IOS 5 4.2.88
    8365. 

  8365.  */
    8366. 

  8366. static guint8
    8367. 

  8367. elem_ms_des_freq(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
    8368. 

  8368. {
    8369. 

  8369.     guint8      oct;
    8370. 

  8370.     guint32     value;
    8371. 

  8371.     gint        temp_int;
    8372. 

  8372.     guint32     curr_offset;
    8373. 

  8373.     const gchar *str;
    8374. 

  8374. 

  8375.     curr_offset = offset;
    8376. 

  8376. 

  8377.     oct = tvb_get_guint8(tvb, curr_offset);
    8378. 

  8378. 

  8379.     temp_int = (oct & 0xf8) >> 3;
    8380. 

  8380.     if ((temp_int < 0) || (temp_int >= (gint) NUM_BAND_CLASS_STR))
    8381. 

  8381.     {
    8382. 

  8382.         str = "Reserved";
    8383. 

  8383.     }
    8384. 

  8384.     else
    8385. 

  8385.     {
    8386. 

  8386.         str = band_class_str[temp_int];
    8387. 

  8387.     }
    8388. 

  8388. 

  8389.     other_decode_bitfield_value(a_bigbuf, oct, 0xf8, 8);
    8390. 

  8390.     proto_tree_add_text(tree,
    8391. 

  8391.         tvb, curr_offset, 1,
    8392. 

  8392.         "%s :  Band Class: %s",
    8393. 

  8393.         a_bigbuf,
    8394. 

  8394.         str);
    8395. 

  8395. 

  8396.     value = tvb_get_guint8(tvb, curr_offset + 1) | ((oct & 0x07) << 8);
    8397. 

  8397. 

  8398.     other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
    8399. 

  8399.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    8400. 

  8400.         "%s :  CDMA Channel (MSB): %u",
    8401. 

  8401.         a_bigbuf,
    8402. 

  8402.         value);
    8403. 

  8403. 

  8404.     curr_offset++;
    8405. 

  8405. 

  8406.     other_decode_bitfield_value(a_bigbuf, value & 0x00ff, 0xff, 8);
    8407. 

  8407.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    8408. 

  8408.         "%s :  CDMA Channel (LSB)",
    8409. 

  8409.         a_bigbuf);
    8410. 

  8410. 

  8411.     g_snprintf(add_string, string_len, " - (CDMA Channel: %u)", value);
    8412. 

  8412. 

  8413.     curr_offset++;
    8414. 

  8414. 

  8415.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    8416. 

  8416. 

  8417.     return(curr_offset - offset);
    8418. 

  8418. }
    8419. 

  8419. 

  8420. /*
    8421. 

  8421.  * IOS 5 4.2.87
    8422. 

  8422.  */
    8423. 

  8423. static guint8
    8424. 

  8424. elem_plcm_id(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
    8425. 

  8425. {
    8426. 

  8426.     guint8      oct;
    8427. 

  8427.     guint32     curr_offset;
    8428. 

  8428.     const gchar *str;
    8429. 

  8429. 

  8430.     curr_offset = offset;
    8431. 

  8431. 

  8432.     oct = tvb_get_guint8(tvb, curr_offset);
    8433. 

  8433. 

  8434.     /*
    8435. 

  8435.      * from C.S0005-D v1.0 L3 Table 3.7.2.3.2.21-5
    8436. 

  8436.      */
    8437. 

  8437.     switch ((oct & 0xf0) >> 4)
    8438. 

  8438.     {
    8439. 

  8439.     case 0x00: str = "PLCM derived from ESN or MEID"; break;
    8440. 

  8440.     case 0x01: str = "PLCM specified by the base station"; break;
    8441. 

  8441.     case 0x02: str = "PLCM derived from IMSI_O_S when IMSI_O is derived from IMSI_M"; break;
    8442. 

  8442.     case 0x03: str = "PLCM derived from IMSI_O_S when IMSI_O is derived from IMSI_T"; break;
    8443. 

  8443.     default:
    8444. 

  8444.         str = "Reserved";
    8445. 

  8445.         break;
    8446. 

  8446.     }
    8447. 

  8447. 

  8448.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    8449. 

  8449.     proto_tree_add_text(tree,
    8450. 

  8450.         tvb, curr_offset, 1,
    8451. 

  8451.         "%s :  PLCM_TYPE: %s",
    8452. 

  8452.         a_bigbuf,
    8453. 

  8453.         str);
    8454. 

  8454. 

  8455.     other_decode_bitfield_value(a_bigbuf, oct, 0x0c, 8);
    8456. 

  8456.     proto_tree_add_text(tree,
    8457. 

  8457.         tvb, curr_offset, 1,
    8458. 

  8458.         "%s :  Reserved",
    8459. 

  8459.         a_bigbuf);
    8460. 

  8460. 

  8461.     other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
    8462. 

  8462.     proto_tree_add_text(tree, tvb, curr_offset, 1,
    8463. 

  8463.         "%s :  PLCM_42 (MSB)",
    8464. 

  8464.         a_bigbuf);
    8465. 

  8465. 

  8466.     curr_offset++;
    8467. 

  8467. 

  8468.     proto_tree_add_text(tree, tvb, curr_offset, 5, "PLCM_42");
    8469. 

  8469. 

  8470.     curr_offset += 5;
    8471. 

  8471. 

  8472.     EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
    8473. 

  8473. 

  8474.     return(curr_offset - offset);
    8475. 

  8475. }
    8476. 

  8476. 

  8477. /*
    8478. 

  8478.  * IOS 6.2.2.152
    8479. 

  8479.  * A3/A7
    8480. 

  8480.  */
    8481. 

  8481. 

  8482. /*
    8483. 

  8483.  * IOS 6.2.2.153
    8484. 

  8484.  * A3/A7
    8485. 

  8485.  */
    8486. 

  8486. 

  8487. /*
    8488. 

  8488.  * ORDER MUST BE MAINTAINED
    8489. 

  8489.  *
    8490. 

  8490.  * The value of this enum is used as an index into
    8491. 

  8491.  * elem_1_fcn[]
    8492. 

  8492.  *
    8493. 

  8493.  */
    8494. 

  8494. typedef enum
    8495. 

  8495. {
    8496. 

  8496.     ANSI_A_E_ACC_NET_ID,            /* Access Network Identifiers */
    8497. 

  8497.     ANSI_A_E_ADDS_USER_PART,        /* ADDS User Part */
    8498. 

  8498.     ANSI_A_E_AMPS_HHO_PARAM,        /* AMPS Hard Handoff Parameters */
    8499. 

  8499.     ANSI_A_E_ANCH_PDSN_ADDR,        /* Anchor PDSN Address */
    8500. 

  8500.     ANSI_A_E_ANCH_PP_ADDR,          /* Anchor P-P Address */
    8501. 

  8501.     ANSI_A_E_AUTH_CHLG_PARAM,       /* Authentication Challenge Parameter */
    8502. 

  8502.     ANSI_A_E_AUTH_CNF_PARAM,        /* Authentication Confirmation Parameter (RANDC) */
    8503. 

  8503.     ANSI_A_E_AUTH_DATA,             /* Authentication Data */
    8504. 

  8504.     ANSI_A_E_AUTH_EVENT,            /* Authentication Event */
    8505. 

  8505.     ANSI_A_E_AUTH_PARAM_COUNT,      /* Authentication Parameter COUNT */
    8506. 

  8506.     ANSI_A_E_AUTH_RESP_PARAM,       /* Authentication Response Parameter */
    8507. 

  8507.     ANSI_A_E_BAND_CLASS,            /* Band Class */
    8508. 

  8508.     ANSI_A_E_CLD_PARTY_ASCII_NUM,   /* Called Party ASCII Number */
    8509. 

  8509.     ANSI_A_E_CLD_PARTY_BCD_NUM,     /* Called Party BCD Number */
    8510. 

  8510.     ANSI_A_E_CLG_PARTY_ASCII_NUM,   /* Calling Party ASCII Number */
    8511. 

  8511.     ANSI_A_E_CAUSE,                 /* Cause */
    8512. 

  8512.     ANSI_A_E_CAUSE_L3,              /* Cause Layer 3 */
    8513. 

  8513.     ANSI_A_E_CDMA_SOWD,             /* CDMA Serving One Way Delay */
    8514. 

  8514.     ANSI_A_E_CELL_ID,               /* Cell Identifier */
    8515. 

  8515.     ANSI_A_E_CELL_ID_LIST,          /* Cell Identifier List */
    8516. 

  8516.     ANSI_A_E_CHAN_NUM,              /* Channel Number */
    8517. 

  8517.     ANSI_A_E_CHAN_TYPE,             /* Channel Type */
    8518. 

  8518.     ANSI_A_E_CCT_GROUP,             /* Circuit Group */
    8519. 

  8519.     ANSI_A_E_CIC,                   /* Circuit Identity Code */
    8520. 

  8520.     ANSI_A_E_CIC_EXT,               /* Circuit Identity Code Extension */
    8521. 

  8521.     ANSI_A_E_CM_INFO_TYPE_2,        /* Classmark Information Type 2 */
    8522. 

  8522.     ANSI_A_E_DOWNLINK_RE,           /* Downlink Radio Environment */
    8523. 

  8523.     ANSI_A_E_DOWNLINK_RE_LIST,      /* Downlink Radio Environment List */
    8524. 

  8524.     ANSI_A_E_ENC_INFO,              /* Encryption Information */
    8525. 

  8525.     ANSI_A_E_EXT_HO_DIR_PARAMS,     /* Extended Handoff Direction Parameters */
    8526. 

  8526.     ANSI_A_E_GEO_LOC,               /* Geographic Location */
    8527. 

  8527.     ANSI_A_E_SSCI,                  /* Special Service Call Indicator */
    8528. 

  8528.     ANSI_A_E_HO_POW_LEV,            /* Handoff Power Level */
    8529. 

  8529.     ANSI_A_E_HHO_PARAMS,            /* Hard Handoff Parameters */
    8530. 

  8530.     ANSI_A_E_IE_REQD,               /* Information Element Requested */
    8531. 

  8531.     ANSI_A_E_IS2000_CHAN_ID,        /* IS-2000 Channel Identity */
    8532. 

  8532.     ANSI_A_E_IS2000_CHAN_ID_3X,     /* IS-2000 Channel Identity 3X */
    8533. 

  8533.     ANSI_A_E_IS2000_MOB_CAP,        /* IS-2000 Mobile Capabilities */
    8534. 

  8534.     ANSI_A_E_IS2000_NN_SCR,         /* IS-2000 Non-Negotiable Service Configuration Record */
    8535. 

  8535.     ANSI_A_E_IS2000_SCR,            /* IS-2000 Service Configuration Record */
    8536. 

  8536.     ANSI_A_E_IS2000_CAUSE,          /* IS-95/IS-2000 Cause Value */
    8537. 

  8537.     ANSI_A_E_IS2000_RED_RECORD,     /* IS-2000 Redirection Record */
    8538. 

  8538.     ANSI_A_E_IS95_CHAN_ID,          /* IS-95 Channel Identity */
    8539. 

  8539.     ANSI_A_E_IS95_MS_MEAS_CHAN_ID,  /* IS-95 MS Measured Channel Identity */
    8540. 

  8540.     ANSI_A_E_L3_INFO,               /* Layer 3 Information */
    8541. 

  8541.     ANSI_A_E_LAI,                   /* Location Area Information */
    8542. 

  8542.     ANSI_A_E_MWI,                   /* Message Waiting Indication */
    8543. 

  8543.     ANSI_A_E_MID,                   /* Mobile Identity */
    8544. 

  8544.     ANSI_A_E_FWD_MS_INFO_RECS,      /* (Forward) MS Information Records */
    8545. 

  8545.     ANSI_A_E_ORIG_CI,               /* Origination Continuation Indicator */
    8546. 

  8546.     ANSI_A_E_PACA_ORDER,            /* PACA Order */
    8547. 

  8547.     ANSI_A_E_PACA_REOI,             /* PACA Reorigination Indicator */
    8548. 

  8548.     ANSI_A_E_PACA_TS,               /* PACA Timestamp */
    8549. 

  8549.     ANSI_A_E_PSP,                   /* Packet Session Parameters */
    8550. 

  8550.     ANSI_A_E_PDSN_IP_ADDR,          /* PDSN IP Address */
    8551. 

  8551.     ANSI_A_E_PDI,                   /* Power Down Indicator */
    8552. 

  8552.     ANSI_A_E_PRIO,                  /* Priority */
    8553. 

  8553.     ANSI_A_E_P_REV,                 /* Protocol Revision */
    8554. 

  8554.     ANSI_A_E_PTYPE,                 /* Protocol Type */
    8555. 

  8555.     ANSI_A_E_PSMM_COUNT,            /* PSMM Count */
    8556. 

  8556.     ANSI_A_E_QOS_PARAMS,            /* Quality of Service Parameters */
    8557. 

  8557.     ANSI_A_E_RE_RES,                /* Radio Environment and Resources */
    8558. 

  8558.     ANSI_A_E_REG_TYPE,              /* Registration Type */
    8559. 

  8559.     ANSI_A_E_REJ_CAUSE,             /* Reject Cause */
    8560. 

  8560.     ANSI_A_E_RESP_REQ,              /* Response Request */
    8561. 

  8561.     ANSI_A_E_RETURN_CAUSE,          /* Return Cause */
    8562. 

  8562.     ANSI_A_E_RF_CHAN_ID,            /* RF Channel Identity */
    8563. 

  8563.     ANSI_A_E_SO,                    /* Service Option */
    8564. 

  8564.     ANSI_A_E_SOCI,                  /* Service Option Connection Identifier (SOCI) */
    8565. 

  8565.     ANSI_A_E_SO_LIST,               /* Service Option List */
    8566. 

  8566.     ANSI_A_E_S_RED_INFO,            /* Service Redirection Info */
    8567. 

  8567.     ANSI_A_E_SR_ID,                 /* Service Reference Identifier (SR_ID) */
    8568. 

  8568.     ANSI_A_E_SID,                   /* SID */
    8569. 

  8569.     ANSI_A_E_SIGNAL,                /* Signal */
    8570. 

  8570.     ANSI_A_E_SCI,                   /* Slot Cycle Index */
    8571. 

  8571.     ANSI_A_E_SW_VER,                /* Software Version */
    8572. 

  8572.     ANSI_A_E_SRNC_TRNC_TC,          /* Source RNC to Target RNC Transparent Container */
    8573. 

  8573.     ANSI_A_E_S_PDSN_ADDR,           /* Source PDSN Address */
    8574. 

  8574.     ANSI_A_E_TAG,                   /* Tag */
    8575. 

  8575.     ANSI_A_E_TRNC_SRNC_TC,          /* Target RNC to Source RNC Transparent Container */
    8576. 

  8576.     ANSI_A_E_XMODE,                 /* Transcoder Mode */
    8577. 

  8577.     ANSI_A_E_UZ_ID,                 /* User Zone ID */
    8578. 

  8578.     ANSI_A_E_VP_REQ,                /* Voice Privacy Request */
    8579. 

  8579.     ANSI_A_E_A2P_BEARER_SESSION,    /* A2p Bearer Session-Level Parameters */
    8580. 

  8580.     ANSI_A_E_A2P_BEARER_FORMAT,     /* A2p Bearer Format-Specific Parameters */
    8581. 

  8581.     ANSI_A_E_MS_DES_FREQ,           /* MS Designated Frequency */
    8582. 

  8582.     ANSI_A_E_MOB_SUB_INFO,          /* Mobile Subscription Information */
    8583. 

  8583.     ANSI_A_E_PLCM_ID,               /* Public Long Code Mask Identifier */
    8584. 

  8584.     ANSI_A_E_REV_MS_INFO_RECS,      /* (Reverse) MS Information Records */
    8585. 

  8585.     ANSI_A_E_NONE        /* NONE */
    8586. 

  8586. }
    8587. 

  8587. elem_idx_t;
    8588. 

  8588. static elem_idx_t ansi_a_elem_1_max = (elem_idx_t)0;
    8589. 

  8589. 

  8590. #define MAX_IOS401_NUM_ELEM_1 (sizeof(ansi_a_ios401_elem_1_strings)/sizeof(ext_value_string_t))
    8591. 

  8591. #define MAX_IOS501_NUM_ELEM_1 (sizeof(ansi_a_ios501_elem_1_strings)/sizeof(ext_value_string_t))
    8592. 

  8592. static gint ett_ansi_elem_1[MAX(MAX_IOS401_NUM_ELEM_1, MAX_IOS501_NUM_ELEM_1)];
    8593. 

  8593. static guint8 (*elem_1_fcn[])(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len) =
    8594. 

  8594. {
    8595. 

  8595.     elem_acc_net_id,                /* Access Network Identifiers */
    8596. 

  8596.     elem_adds_user_part,            /* ADDS User Part */
    8597. 

  8597.     elem_amps_hho_param,            /* AMPS Hard Handoff Parameters */
    8598. 

  8598.     elem_anchor_pdsn_addr,          /* Anchor PDSN Address */
    8599. 

  8599.     elem_anchor_pp_addr,            /* Anchor P-P Address */
    8600. 

  8600.     elem_auth_chlg_param,           /* Authentication Challenge Parameter */
    8601. 

  8601.     NULL /* no decode required */,  /* Authentication Confirmation Parameter (RANDC) */
    8602. 

  8602.     NULL /* no decode required */,  /* Authentication Data */
    8603. 

  8603.     elem_auth_event,                /* Authentication Event */
    8604. 

  8604.     elem_auth_param_count,          /* Authentication Parameter COUNT */
    8605. 

  8605.     elem_auth_resp_param,           /* Authentication Response Parameter */
    8606. 

  8606.     elem_band_class,                /* Band Class */
    8607. 

  8607.     elem_cld_party_ascii_num,       /* Called Party ASCII Number */
    8608. 

  8608.     elem_cld_party_bcd_num,         /* Called Party BCD Number */
    8609. 

  8609.     elem_clg_party_ascii_num,       /* Calling Party ASCII Number */
    8610. 

  8610.     elem_cause,                     /* Cause */
    8611. 

  8611.     elem_cause_l3,                  /* Cause Layer 3 */
    8612. 

  8612.     elem_cdma_sowd,                 /* CDMA Serving One Way Delay */
    8613. 

  8613.     elem_cell_id,                   /* Cell Identifier */
    8614. 

  8614.     elem_cell_id_list,              /* Cell Identifier List */
    8615. 

  8615.     elem_chan_num,                  /* Channel Number */
    8616. 

  8616.     elem_chan_type,                 /* Channel Type */
    8617. 

  8617.     elem_cct_group,                 /* Circuit Group */
    8618. 

  8618.     elem_cic,                       /* Circuit Identity Code */
    8619. 

  8619.     elem_cic_ext,                   /* Circuit Identity Code Extension */
    8620. 

  8620.     elem_cm_info_type_2,            /* Classmark Information Type 2 */
    8621. 

  8621.     elem_downlink_re,               /* Downlink Radio Environment */
    8622. 

  8622.     elem_downlink_re_list,          /* Downlink Radio Environment List */
    8623. 

  8623.     elem_enc_info,                  /* Encryption Information */
    8624. 

  8624.     elem_ext_ho_dir_params,         /* Extended Handoff Direction Parameters */
    8625. 

  8625.     elem_geo_loc,                   /* Geographic Location */
    8626. 

  8626.     elem_ssci,                      /* Special Service Call Indicator */
    8627. 

  8627.     elem_ho_pow_lev,                /* Handoff Power Level */
    8628. 

  8628.     elem_hho_params,                /* Hard Handoff Parameters */
    8629. 

  8629.     elem_info_rec_req,              /* Information Element Requested */
    8630. 

  8630.     elem_is2000_chan_id,            /* IS-2000 Channel Identity */
    8631. 

  8631.     NULL,                           /* IS-2000 Channel Identity 3X */
    8632. 

  8632.     elem_is2000_mob_cap,            /* IS-2000 Mobile Capabilities */
    8633. 

  8633.     elem_is2000_nn_scr,             /* IS-2000 Non-Negotiable Service Configuration Record */
    8634. 

  8634.     elem_is2000_scr,                /* IS-2000 Service Configuration Record */
    8635. 

  8635.     elem_is2000_cause,              /* IS-95/IS-2000 Cause Value */
    8636. 

  8636.     NULL,                           /* IS-2000 Redirection Record */
    8637. 

  8637.     elem_is95_chan_id,              /* IS-95 Channel Identity */
    8638. 

  8638.     elem_is95_ms_meas_chan_id,      /* IS-95 MS Measured Channel Identity */
    8639. 

  8639.     elem_l3_info,                   /* Layer 3 Information */
    8640. 

  8640.     elem_lai,                       /* Location Area Information */
    8641. 

  8641.     elem_mwi,                       /* Message Waiting Indication */
    8642. 

  8642.     elem_mid,                       /* Mobile Identity */
    8643. 

  8643.     elem_fwd_ms_info_recs,          /* (Forward) MS Information Records */
    8644. 

  8644.     NULL /* no associated data */,  /* Origination Continuation Indicator */
    8645. 

  8645.     elem_paca_order,                /* PACA Order */
    8646. 

  8646.     elem_paca_reoi,                 /* PACA Reorigination Indicator */
    8647. 

  8647.     elem_paca_ts,                   /* PACA Timestamp */
    8648. 

  8648.     NULL,                           /* Packet Session Parameters */
    8649. 

  8649.     elem_pdsn_ip_addr,              /* PDSN IP Address */
    8650. 

  8650.     NULL /* no associated data */,  /* Power Down Indicator */
    8651. 

  8651.     elem_prio,                      /* Priority */
    8652. 

  8652.     elem_p_rev,                     /* Protocol Revision */
    8653. 

  8653.     elem_ptype,                     /* Protocol Type */
    8654. 

  8654.     elem_psmm_count,                /* PSMM Count */
    8655. 

  8655.     elem_qos_params,                /* Quality of Service Parameters */
    8656. 

  8656.     elem_re_res,                    /* Radio Environment and Resources */
    8657. 

  8657.     elem_reg_type,                  /* Registration Type */
    8658. 

  8658.     elem_rej_cause,                 /* Reject Cause */
    8659. 

  8659.     NULL /* no associated data */,  /* Response Request */
    8660. 

  8660.     elem_return_cause,              /* Return Cause */
    8661. 

  8661.     elem_rf_chan_id,                /* RF Channel Identity */
    8662. 

  8662.     elem_so,                        /* Service Option */
    8663. 

  8663.     elem_soci,                      /* Service Option Connection Identifier (SOCI) */
    8664. 

  8664.     elem_so_list,                   /* Service Option List */
    8665. 

  8665.     NULL,                           /* Service Redirection Info */
    8666. 

  8666.     elem_sr_id,                     /* Service Reference Identifier (SR_ID) */
    8667. 

  8667.     elem_sid,                       /* SID */
    8668. 

  8668.     elem_signal,                    /* Signal */
    8669. 

  8669.     elem_sci,                       /* Slot Cycle Index */
    8670. 

  8670.     elem_sw_ver,                    /* Software Version */
    8671. 

  8671.     NULL /* transparent */,         /* Source RNC to Target RNC Transparent Container */
    8672. 

  8672.     elem_s_pdsn_ip_addr,            /* Source PDSN Address */
    8673. 

  8673.     elem_tag,                       /* Tag */
    8674. 

  8674.     NULL /* transparent */,         /* Target RNC to Source RNC Transparent Container */
    8675. 

  8675.     elem_xmode,                     /* Transcoder Mode */
    8676. 

  8676.     elem_uz_id,                     /* User Zone ID */
    8677. 

  8677.     NULL /* no associated data */,  /* Voice Privacy Request */
    8678. 

  8678.     elem_a2p_bearer_session,        /* A2p Bearer Session-Level Parameters */
    8679. 

  8679.     elem_a2p_bearer_format,         /* A2p Bearer Format-Specific Parameters */
    8680. 

  8680.     elem_ms_des_freq,               /* MS Designated Frequency */
    8681. 

  8681.     NULL,                           /* Mobile Subscription Information */
    8682. 

  8682.     elem_plcm_id,                   /* Public Long Code Mask Identification */
    8683. 

  8683.     elem_rev_ms_info_recs,          /* (Reverse) MS Information Records */
    8684. 

  8684.     NULL,        /* NONE */
    8685. 

  8685. };
    8686. 

  8686. 

  8687. /* MESSAGE FUNCTIONS */
    8688. 

  8688. 

  8689. /*
    8690. 

  8690.  * Type Length Value (TLV) element dissector
    8691. 

  8691.  */
    8692. 

  8692. static guint16
    8693. 

  8693. elem_tlv(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, elem_idx_t idx, guint32 offset, guint len _U_, const gchar *name_add)
    8694. 

  8694. {
    8695. 

  8695.     guint8      oct, parm_len;
    8696. 

  8696.     guint16     consumed;
    8697. 

  8697.     guint32     curr_offset;
    8698. 

  8698.     proto_tree  *subtree;
    8699. 

  8699.     proto_item  *item;
    8700. 

  8700.     gint        dec_idx;
    8701. 

  8701. 

  8702.     curr_offset = offset;
    8703. 

  8703.     consumed = 0;
    8704. 

  8704. 

  8705.     if ((int)idx < 0 || idx >= ansi_a_elem_1_max-1)
    8706. 

  8706.     {
    8707. 

  8707.         /* Unknown index, skip the element */
    8708. 

  8708.         return tvb_length_remaining(tvb, offset) ;
    8709. 

  8709.     }
    8710. 

  8710. 

  8711.     oct = tvb_get_guint8(tvb, curr_offset);
    8712. 

  8712. 

  8713.     if (oct == (guint8) ansi_a_elem_1_strings[idx].value)
    8714. 

  8714.     {
    8715. 

  8715.         dec_idx = ansi_a_elem_1_strings[idx].dec_index;
    8716. 

  8716. 

  8717.         parm_len = tvb_get_guint8(tvb, curr_offset + 1);
    8718. 

  8718. 

  8719.         item =
    8720. 

  8720.             proto_tree_add_text(tree,
    8721. 

  8721.                 tvb, curr_offset, parm_len + 2,
    8722. 

  8722.                 "%s%s",
    8723. 

  8723.                 ansi_a_elem_1_strings[idx].strptr,
    8724. 

  8724.                 (name_add == NULL) || (name_add[0] == '\0') ? "" : name_add);
    8725. 

  8725. 

  8726.         subtree = proto_item_add_subtree(item, ett_ansi_elem_1[idx]);
    8727. 

  8727. 

  8728.         proto_tree_add_uint_format(subtree, hf_ansi_a_elem_id, tvb,
    8729. 

  8729.             curr_offset, 1, oct,
    8730. 

  8730.             "Element ID");
    8731. 

  8731. 

  8732.         proto_tree_add_uint(subtree, hf_ansi_a_length, tvb,
    8733. 

  8733.             curr_offset + 1, 1, parm_len);
    8734. 

  8734. 

  8735.         if (parm_len > 0)
    8736. 

  8736.         {
    8737. 

  8737.             if (elem_1_fcn[dec_idx] == NULL)
    8738. 

  8738.             {
    8739. 

  8739.                 proto_tree_add_text(subtree,
    8740. 

  8740.                     tvb, curr_offset + 2, parm_len,
    8741. 

  8741.                     "Element Value");
    8742. 

  8742. 

  8743.                 consumed = parm_len;
    8744. 

  8744.             }
    8745. 

  8745.             else
    8746. 

  8746.             {
    8747. 

  8747.                 gchar *a_add_string;
    8748. 

  8748. 

  8749.                 a_add_string = (gchar *) wmem_alloc(wmem_packet_scope(), 1024);
    8750. 

  8750.                 a_add_string[0] = '\0';
    8751. 

  8751.                 consumed =
    8752. 

  8752.                     (*elem_1_fcn[dec_idx])(tvb, pinfo, subtree, curr_offset + 2,
    8753. 

  8753.                         parm_len, a_add_string, 1024);
    8754. 

  8754. 

  8755.                 if (a_add_string[0] != '\0')
    8756. 

  8756.                 {
    8757. 

  8757.                     proto_item_append_text(item, "%s", a_add_string);
    8758. 

  8758.                 }
    8759. 

  8759.             }
    8760. 

  8760.         }
    8761. 

  8761. 

  8762.         consumed += 2;
    8763. 

  8763.     }
    8764. 

  8764. 

  8765.     return(consumed);
    8766. 

  8766. }
    8767. 

  8767. 

  8768. /*
    8769. 

  8769.  * Type Value (TV) element dissector
    8770. 

  8770.  *
    8771. 

  8771.  * Length cannot be used in these functions, big problem if a element dissector
    8772. 

  8772.  * is not defined for these.
    8773. 

  8773.  */
    8774. 

  8774. static guint16
    8775. 

  8775. elem_tv(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, elem_idx_t idx, guint32 offset, const gchar *name_add)
    8776. 

  8776. {
    8777. 

  8777.     guint8      oct;
    8778. 

  8778.     guint16     consumed;
    8779. 

  8779.     guint32     curr_offset;
    8780. 

  8780.     proto_tree  *subtree;
    8781. 

  8781.     proto_item  *item;
    8782. 

  8782.     gint        dec_idx;
    8783. 

  8783. 

  8784. 

  8785.     curr_offset = offset;
    8786. 

  8786.     consumed = 0;
    8787. 

  8787. 

  8788.     if ((int)idx < 0 || idx >= ansi_a_elem_1_max-1)
    8789. 

  8789.     {
    8790. 

  8790.         /* Unknown index, skip the element */
    8791. 

  8791.         return tvb_length_remaining(tvb, offset) ;
    8792. 

  8792.     }
    8793. 

  8793. 

  8794.     oct = tvb_get_guint8(tvb, curr_offset);
    8795. 

  8795. 

  8796.     if (oct == (guint8) ansi_a_elem_1_strings[idx].value)
    8797. 

  8797.     {
    8798. 

  8798.         dec_idx = ansi_a_elem_1_strings[idx].dec_index;
    8799. 

  8799. 

  8800.         item =
    8801. 

  8801.             proto_tree_add_text(tree,
    8802. 

  8802.                 tvb, curr_offset, -1,
    8803. 

  8803.                 "%s%s",
    8804. 

  8804.                 ansi_a_elem_1_strings[idx].strptr,
    8805. 

  8805.                 (name_add == NULL) || (name_add[0] == '\0') ? "" : name_add);
    8806. 

  8806. 

  8807.         subtree = proto_item_add_subtree(item, ett_ansi_elem_1[idx]);
    8808. 

  8808. 

  8809.         proto_tree_add_uint_format(subtree, hf_ansi_a_elem_id, tvb,
    8810. 

  8810.             curr_offset, 1, oct,
    8811. 

  8811.             "Element ID");
    8812. 

  8812. 

  8813.         if (elem_1_fcn[dec_idx] == NULL)
    8814. 

  8814.         {
    8815. 

  8815.             /* BAD THING, CANNOT DETERMINE LENGTH */
    8816. 

  8816. 

  8817.             proto_tree_add_text(subtree,
    8818. 

  8818.                 tvb, curr_offset + 1, 1,
    8819. 

  8819.                 "No element dissector, rest of dissection may be incorrect");
    8820. 

  8820. 

  8821.             consumed = 1;
    8822. 

  8822.         }
    8823. 

  8823.         else
    8824. 

  8824.         {
    8825. 

  8825.             gchar *a_add_string;
    8826. 

  8826. 

  8827.             a_add_string = (gchar *) wmem_alloc(wmem_packet_scope(), 1024);
    8828. 

  8828.             a_add_string[0] = '\0';
    8829. 

  8829.             consumed = (*elem_1_fcn[dec_idx])(tvb, pinfo, subtree, curr_offset + 1, -1, a_add_string, 1024);
    8830. 

  8830. 

  8831.             if (a_add_string[0] != '\0')
    8832. 

  8832.             {
    8833. 

  8833.                 proto_item_append_text(item, "%s", a_add_string);
    8834. 

  8834.             }
    8835. 

  8835.         }
    8836. 

  8836. 

  8837.         consumed++;
    8838. 

  8838. 

  8839.         proto_item_set_len(item, consumed);
    8840. 

  8840.     }
    8841. 

  8841. 

  8842.     return(consumed);
    8843. 

  8843. }
    8844. 

  8844. 

  8845. /*
    8846. 

  8846.  * Type (T) element dissector
    8847. 

  8847.  *
    8848. 

  8848.  * Length cannot be used in these functions, big problem if a element dissector
    8849. 

  8849.  * is not defined for these.
    8850. 

  8850.  */
    8851. 

  8851. static guint16
    8852. 

  8852. elem_t(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, elem_idx_t idx, guint32 offset, const gchar *name_add)
    8853. 

  8853. {
    8854. 

  8854.     guint8      oct;
    8855. 

  8855.     guint32     curr_offset;
    8856. 

  8856.     guint16     consumed;
    8857. 

  8857. 

  8858. 

  8859.     curr_offset = offset;
    8860. 

  8860.     consumed = 0;
    8861. 

  8861. 

  8862.     if ((int)idx < 0 || idx >= ansi_a_elem_1_max-1)
    8863. 

  8863.     {
    8864. 

  8864.         /* Unknown index, skip the element */
    8865. 

  8865.         return tvb_length_remaining(tvb, offset) ;
    8866. 

  8866.     }
    8867. 

  8867. 

  8868.     oct = tvb_get_guint8(tvb, curr_offset);
    8869. 

  8869. 

  8870.     if (oct == (guint8) ansi_a_elem_1_strings[idx].value)
    8871. 

  8871.     {
    8872. 

  8872.         proto_tree_add_uint_format(tree, hf_ansi_a_elem_id, tvb, curr_offset, 1, oct,
    8873. 

  8873.             "%s%s",
    8874. 

  8874.             ansi_a_elem_1_strings[idx].strptr,
    8875. 

  8875.             (name_add == NULL) || (name_add[0] == '\0') ? "" : name_add);
    8876. 

  8876. 

  8877.         consumed = 1;
    8878. 

  8878.     }
    8879. 

  8879. 

  8880.     return(consumed);
    8881. 

  8881. }
    8882. 

  8882. 

  8883. /*
    8884. 

  8884.  * Length Value (LV) element dissector
    8885. 

  8885.  */
    8886. 

  8886. static guint16
    8887. 

  8887. elem_lv(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, elem_idx_t idx, guint32 offset, guint len _U_, const gchar *name_add)
    8888. 

  8888. {
    8889. 

  8889.     guint8      parm_len;
    8890. 

  8890.     guint16     consumed;
    8891. 

  8891.     guint32     curr_offset;
    8892. 

  8892.     proto_tree  *subtree;
    8893. 

  8893.     proto_item  *item;
    8894. 

  8894.     gint        dec_idx;
    8895. 

  8895. 

  8896. 

  8897.     curr_offset = offset;
    8898. 

  8898.     consumed = 0;
    8899. 

  8899. 

  8900.     if ((int)idx < 0 || idx >= ansi_a_elem_1_max-1)
    8901. 

  8901.     {
    8902. 

  8902.         /* Unknown index, skip the element */
    8903. 

  8903.         return tvb_length_remaining(tvb, offset) ;
    8904. 

  8904.     }
    8905. 

  8905. 

  8906.     dec_idx = ansi_a_elem_1_strings[idx].dec_index;
    8907. 

  8907. 

  8908.     parm_len = tvb_get_guint8(tvb, curr_offset);
    8909. 

  8909. 

  8910.     item =
    8911. 

  8911.         proto_tree_add_text(tree,
    8912. 

  8912.             tvb, curr_offset, parm_len + 1,
    8913. 

  8913.             "%s%s",
    8914. 

  8914.             ansi_a_elem_1_strings[idx].strptr,
    8915. 

  8915.             (name_add == NULL) || (name_add[0] == '\0') ? "" : name_add);
    8916. 

  8916. 

  8917.     subtree = proto_item_add_subtree(item, ett_ansi_elem_1[idx]);
    8918. 

  8918. 

  8919.     proto_tree_add_uint(subtree, hf_ansi_a_length, tvb,
    8920. 

  8920.         curr_offset, 1, parm_len);
    8921. 

  8921. 

  8922.     if (parm_len > 0)
    8923. 

  8923.     {
    8924. 

  8924.         if (elem_1_fcn[dec_idx] == NULL)
    8925. 

  8925.         {
    8926. 

  8926.             proto_tree_add_text(subtree,
    8927. 

  8927.                 tvb, curr_offset + 1, parm_len,
    8928. 

  8928.                 "Element Value");
    8929. 

  8929. 

  8930.             consumed = parm_len;
    8931. 

  8931.         }
    8932. 

  8932.         else
    8933. 

  8933.         {
    8934. 

  8934.             gchar *a_add_string;
    8935. 

  8935. 

  8936.             a_add_string = (gchar *) wmem_alloc(wmem_packet_scope(), 1024);
    8937. 

  8937.             a_add_string[0] = '\0';
    8938. 

  8938.             consumed =
    8939. 

  8939.                 (*elem_1_fcn[dec_idx])(tvb, pinfo, subtree, curr_offset + 1,
    8940. 

  8940.                     parm_len, a_add_string, 1024);
    8941. 

  8941. 

  8942.             if (a_add_string[0] != '\0')
    8943. 

  8943.             {
    8944. 

  8944.                 proto_item_append_text(item, "%s", a_add_string);
    8945. 

  8945.             }
    8946. 

  8946.         }
    8947. 

  8947.     }
    8948. 

  8948. 

  8949.     return(consumed + 1);
    8950. 

  8950. }
    8951. 

  8951. 

  8952. /*
    8953. 

  8953.  * Value (V) element dissector
    8954. 

  8954.  *
    8955. 

  8955.  * Length cannot be used in these functions, big problem if a element dissector
    8956. 

  8956.  * is not defined for these.
    8957. 

  8957.  */
    8958. 

  8958. static guint16
    8959. 

  8959. elem_v(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, elem_idx_t idx, guint32 offset)
    8960. 

  8960. {
    8961. 

  8961.     guint16     consumed;
    8962. 

  8962.     guint32     curr_offset;
    8963. 

  8963.     gint        dec_idx;
    8964. 

  8964. 

  8965.     curr_offset = offset;
    8966. 

  8966. 

  8967.     if ((int)idx < 0 || idx >= ansi_a_elem_1_max-1)
    8968. 

  8968.     {
    8969. 

  8969.         /* Unknown index, skip the element */
    8970. 

  8970.         return tvb_length_remaining(tvb, offset) ;
    8971. 

  8971.     }
    8972. 

  8972. 

  8973.     dec_idx = ansi_a_elem_1_strings[idx].dec_index;
    8974. 

  8974. 

  8975.     if (elem_1_fcn[dec_idx] == NULL)
    8976. 

  8976.     {
    8977. 

  8977.         /* BAD THING, CANNOT DETERMINE LENGTH */
    8978. 

  8978. 

  8979.         proto_tree_add_text(tree,
    8980. 

  8980.             tvb, curr_offset, 1,
    8981. 

  8981.             "No element dissector, rest of dissection may be incorrect");
    8982. 

  8982. 

  8983.         consumed = 1;
    8984. 

  8984.     }
    8985. 

  8985.     else
    8986. 

  8986.     {
    8987. 

  8987.         gchar *a_add_string;
    8988. 

  8988. 

  8989.         a_add_string = (gchar *) wmem_alloc(wmem_packet_scope(), 1024);
    8990. 

  8990.         a_add_string[0] = '\0';
    8991. 

  8991.         consumed = (*elem_1_fcn[dec_idx])(tvb, pinfo, tree, curr_offset, -1, a_add_string, 1024);
    8992. 

  8992.     }
    8993. 

  8993. 

  8994.     return(consumed);
    8995. 

  8995. }
    8996. 

  8996. 

  8997. 

  8998. #define ELEM_MAND_TLV(elem_idx, elem_name_addition) \
    8999. 

  8999. {\
    9000. 

  9000.     if ((consumed = elem_tlv(tvb, pinfo, tree, elem_idx, curr_offset, curr_len, elem_name_addition)) > 0) \
    9001. 

  9001.     { \
    9002. 

  9002.         curr_offset += consumed; \
    9003. 

  9003.         curr_len -= consumed; \
    9004. 

  9004.     } \
    9005. 

  9005.     else \
    9006. 

  9006.     { \
    9007. 

  9007.         proto_tree_add_text(tree, \
    9008. 

  9008.             tvb, curr_offset, 0, \
    9009. 

  9009.             "Missing Mandatory element (0x%02x) %s%s, rest of dissection is suspect", \
    9010. 

  9010.                 ansi_a_elem_1_strings[elem_idx].value, \
    9011. 

  9011.                 ansi_a_elem_1_strings[elem_idx].strptr, \
    9012. 

  9012.                 (elem_name_addition == NULL) || (elem_name_addition[0] == '\0') ? "" : elem_name_addition \
    9013. 

  9013.             ); \
    9014. 

  9014.     } \
    9015. 

  9015.     if (curr_len <= 0) return; \
    9016. 

  9016. }
    9017. 

  9017. 

  9018. #define ELEM_OPT_TLV(elem_idx, elem_name_addition) \
    9019. 

  9019. {\
    9020. 

  9020.     if ((consumed = elem_tlv(tvb, pinfo, tree, elem_idx, curr_offset, curr_len, elem_name_addition)) > 0) \
    9021. 

  9021.     { \
    9022. 

  9022.         curr_offset += consumed; \
    9023. 

  9023.         curr_len -= consumed; \
    9024. 

  9024.     } \
    9025. 

  9025.     if (curr_len <= 0) return; \
    9026. 

  9026. }
    9027. 

  9027. 

  9028. #define ELEM_MAND_TV(elem_idx, elem_name_addition) \
    9029. 

  9029. {\
    9030. 

  9030.     if ((consumed = elem_tv(tvb, pinfo, tree, elem_idx, curr_offset, elem_name_addition)) > 0) \
    9031. 

  9031.     { \
    9032. 

  9032.         curr_offset += consumed; \
    9033. 

  9033.         curr_len -= consumed; \
    9034. 

  9034.     } \
    9035. 

  9035.     else \
    9036. 

  9036.     { \
    9037. 

  9037.         proto_tree_add_text(tree, \
    9038. 

  9038.             tvb, curr_offset, 0, \
    9039. 

  9039.             "Missing Mandatory element (0x%02x) %s%s, rest of dissection is suspect", \
    9040. 

  9040.                 ansi_a_elem_1_strings[elem_idx].value, \
    9041. 

  9041.                 ansi_a_elem_1_strings[elem_idx].strptr, \
    9042. 

  9042.                 (elem_name_addition == NULL) || (elem_name_addition[0] == '\0') ? "" : elem_name_addition \
    9043. 

  9043.             ); \
    9044. 

  9044.     } \
    9045. 

  9045.     if (curr_len <= 0) return; \
    9046. 

  9046. }
    9047. 

  9047. 

  9048. #define ELEM_OPT_TV(elem_idx, elem_name_addition) \
    9049. 

  9049. {\
    9050. 

  9050.     if ((consumed = elem_tv(tvb, pinfo, tree, elem_idx, curr_offset, elem_name_addition)) > 0) \
    9051. 

  9051.     { \
    9052. 

  9052.         curr_offset += consumed; \
    9053. 

  9053.         curr_len -= consumed; \
    9054. 

  9054.     } \
    9055. 

  9055.     if (curr_len <= 0) return; \
    9056. 

  9056. }
    9057. 

  9057. 

  9058. #define ELEM_OPT_T(elem_idx, elem_name_addition) \
    9059. 

  9059. {\
    9060. 

  9060.     if ((consumed = elem_t(tvb, pinfo, tree, elem_idx, curr_offset, elem_name_addition)) > 0) \
    9061. 

  9061.     { \
    9062. 

  9062.         curr_offset += consumed; \
    9063. 

  9063.         curr_len -= consumed; \
    9064. 

  9064.     } \
    9065. 

  9065.     if (curr_len <= 0) return; \
    9066. 

  9066. }
    9067. 

  9067. 

  9068. #define ELEM_MAND_LV(elem_idx, elem_name_addition) \
    9069. 

  9069. {\
    9070. 

  9070.     if ((consumed = (GPOINTER_TO_UINT(pinfo->private_data) ? \
    9071. 

  9071.                          elem_tlv(tvb, pinfo, tree, elem_idx, curr_offset, curr_len, elem_name_addition) : \
    9072. 

  9072.                          elem_lv(tvb, pinfo, tree, elem_idx, curr_offset, curr_len, elem_name_addition))) > 0) \
    9073. 

  9073.     { \
    9074. 

  9074.         curr_offset += consumed; \
    9075. 

  9075.         curr_len -= consumed; \
    9076. 

  9076.     } \
    9077. 

  9077.     else \
    9078. 

  9078.     { \
    9079. 

  9079.         /* Mandatory, but nothing we can do */ \
    9080. 

  9080.     } \
    9081. 

  9081.     if (curr_len <= 0) return; \
    9082. 

  9082. }
    9083. 

  9083. 

  9084. #define ELEM_MAND_V(elem_idx) \
    9085. 

  9085. {\
    9086. 

  9086.     if ((consumed = (GPOINTER_TO_UINT(pinfo->private_data) ? \
    9087. 

  9087.                          elem_tv(tvb, pinfo, tree, elem_idx, curr_offset, "") : \
    9088. 

  9088.                          elem_v(tvb, pinfo, tree, elem_idx, curr_offset))) > 0) \
    9089. 

  9089.     { \
    9090. 

  9090.         curr_offset += consumed; \
    9091. 

  9091.         curr_len -= consumed; \
    9092. 

  9092.     } \
    9093. 

  9093.     else \
    9094. 

  9094.     { \
    9095. 

  9095.         /* Mandatory, but nothing we can do */ \
    9096. 

  9096.     } \
    9097. 

  9097.     if (curr_len <= 0) return; \
    9098. 

  9098. }
    9099. 

  9099. 

  9100. 

  9101. /*
    9102. 

  9102.  * IOS 6.1.2.1
    9103. 

  9103.  */
    9104. 

  9104. static void
    9105. 

  9105. bsmap_cl3_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9106. 

  9106. {
    9107. 

  9107.     guint16      consumed;
    9108. 

  9108.     guint32     curr_offset;
    9109. 

  9109.     guint       curr_len;
    9110. 

  9110. 

  9111.     curr_offset = offset;
    9112. 

  9112.     curr_len = len;
    9113. 

  9113. 

  9114.     ELEM_MAND_TLV(ANSI_A_E_CELL_ID, "");
    9115. 

  9115. 

  9116.     ELEM_MAND_TLV(ANSI_A_E_L3_INFO, "");
    9117. 

  9117. 

  9118.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9119. 

  9119. }
    9120. 

  9120. 

  9121. /*
    9122. 

  9122.  * IOS 6.1.2.2
    9123. 

  9123.  */
    9124. 

  9124. static void
    9125. 

  9125. dtap_cm_srvc_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9126. 

  9126. {
    9127. 

  9127.     guint32     curr_offset;
    9128. 

  9128.     guint32     consumed;
    9129. 

  9129.     guint       curr_len;
    9130. 

  9130.     guint8      oct;
    9131. 

  9131.     proto_tree  *subtree;
    9132. 

  9132.     proto_item  *item;
    9133. 

  9133.     const gchar *str;
    9134. 

  9134. 

  9135.     curr_offset = offset;
    9136. 

  9136.     curr_len = len;
    9137. 

  9137. 

  9138.     /*
    9139. 

  9139.      * special dissection for CM Service Type
    9140. 

  9140.      */
    9141. 

  9141.     oct = tvb_get_guint8(tvb, curr_offset);
    9142. 

  9142. 

  9143.     switch (oct & 0x0f)
    9144. 

  9144.     {
    9145. 

  9145.     case 0x01: str = "Mobile Originating Call"; break;
    9146. 

  9146.     default:
    9147. 

  9147.         str = "Unknown";
    9148. 

  9148.         break;
    9149. 

  9149.     }
    9150. 

  9150. 

  9151.     item =
    9152. 

  9152.         proto_tree_add_text(tree,
    9153. 

  9153.             tvb, curr_offset, 1,
    9154. 

  9154.             "CM Service Type: %s",
    9155. 

  9155.             str);
    9156. 

  9156. 

  9157.     subtree = proto_item_add_subtree(item, ett_cm_srvc_type);
    9158. 

  9158. 

  9159.     other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
    9160. 

  9160.     proto_tree_add_text(subtree,
    9161. 

  9161.         tvb, curr_offset, 1,
    9162. 

  9162.         "%s :  Element ID",
    9163. 

  9163.         a_bigbuf);
    9164. 

  9164. 

  9165.     other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
    9166. 

  9166.     proto_tree_add_text(subtree,
    9167. 

  9167.         tvb, curr_offset, 1,
    9168. 

  9168.         "%s :  Service Type: (%u) %s",
    9169. 

  9169.         a_bigbuf,
    9170. 

  9170.         oct & 0x0f,
    9171. 

  9171.         str);
    9172. 

  9172. 

  9173.     curr_offset++;
    9174. 

  9174.     curr_len--;
    9175. 

  9175. 

  9176.     ELEM_MAND_LV(ANSI_A_E_CM_INFO_TYPE_2, "");
    9177. 

  9177. 

  9178.     ELEM_MAND_LV(ANSI_A_E_MID, "");
    9179. 

  9179. 

  9180.     ELEM_OPT_TLV(ANSI_A_E_CLD_PARTY_BCD_NUM, "");
    9181. 

  9181. 

  9182.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9183. 

  9183. 

  9184.     ELEM_OPT_TV(ANSI_A_E_SCI, "");
    9185. 

  9185. 

  9186.     ELEM_OPT_TLV(ANSI_A_E_AUTH_RESP_PARAM, "");
    9187. 

  9187. 

  9188.     ELEM_OPT_TV(ANSI_A_E_AUTH_CNF_PARAM, "");
    9189. 

  9189. 

  9190.     ELEM_OPT_TV(ANSI_A_E_AUTH_PARAM_COUNT, "");
    9191. 

  9191. 

  9192.     ELEM_OPT_TLV(ANSI_A_E_AUTH_CHLG_PARAM, "");
    9193. 

  9193. 

  9194.     ELEM_OPT_TV(ANSI_A_E_SO, "");
    9195. 

  9195. 

  9196.     ELEM_OPT_T(ANSI_A_E_VP_REQ, "");
    9197. 

  9197. 

  9198.     ELEM_OPT_TV(ANSI_A_E_RE_RES, "");
    9199. 

  9199. 

  9200.     ELEM_OPT_TLV(ANSI_A_E_CLD_PARTY_ASCII_NUM, "");
    9201. 

  9201. 

  9202.     ELEM_OPT_TV(ANSI_A_E_CIC, "");
    9203. 

  9203. 

  9204.     ELEM_OPT_TLV(ANSI_A_E_AUTH_EVENT, "");
    9205. 

  9205. 

  9206.     ELEM_OPT_TLV(ANSI_A_E_AUTH_DATA, "");
    9207. 

  9207. 

  9208.     ELEM_OPT_TLV(ANSI_A_E_PACA_REOI, "");
    9209. 

  9209. 

  9210.     ELEM_OPT_TLV(ANSI_A_E_UZ_ID, "");
    9211. 

  9211. 

  9212.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    9213. 

  9213. 

  9214.     ELEM_OPT_TLV(ANSI_A_E_CDMA_SOWD, "");
    9215. 

  9215. 

  9216.     switch (global_a_variant)
    9217. 

  9217.     {
    9218. 

  9218.     case A_VARIANT_IOS501:
    9219. 

  9219.         ELEM_OPT_TLV(ANSI_A_E_SSCI, "");
    9220. 

  9220. 

  9221.         ELEM_OPT_TLV(ANSI_A_E_SOCI, "");
    9222. 

  9222. 

  9223.         ELEM_OPT_T(ANSI_A_E_ORIG_CI, "");
    9224. 

  9224. 

  9225.         ELEM_OPT_TV(ANSI_A_E_RETURN_CAUSE, "");
    9226. 

  9226. 

  9227.         ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9228. 

  9228. 

  9229.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_SESSION, "");
    9230. 

  9230. 

  9231.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_FORMAT, "");
    9232. 

  9232. 

  9233.         ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    9234. 

  9234.         break;
    9235. 

  9235.     }
    9236. 

  9236. 

  9237.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9238. 

  9238. }
    9239. 

  9239. 

  9240. /*
    9241. 

  9241.  * IOS 5 3.1.3
    9242. 

  9242.  */
    9243. 

  9243. static void
    9244. 

  9244. dtap_cm_srvc_req_cont(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9245. 

  9245. {
    9246. 

  9246.     guint32     curr_offset;
    9247. 

  9247.     guint32     consumed;
    9248. 

  9248.     guint       curr_len;
    9249. 

  9249. 

  9250.     curr_offset = offset;
    9251. 

  9251.     curr_len = len;
    9252. 

  9252. 

  9253.     ELEM_OPT_TLV(ANSI_A_E_CLD_PARTY_BCD_NUM, "");
    9254. 

  9254. 

  9255.     ELEM_OPT_TLV(ANSI_A_E_CLD_PARTY_ASCII_NUM, "");
    9256. 

  9256. 

  9257.     ELEM_OPT_TLV(ANSI_A_E_REV_MS_INFO_RECS, "");
    9258. 

  9258. 

  9259.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9260. 

  9260. }
    9261. 

  9261. 

  9262. /*
    9263. 

  9263.  * IOS 6.1.2.3
    9264. 

  9264.  */
    9265. 

  9265. static void
    9266. 

  9266. bsmap_page_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9267. 

  9267. {
    9268. 

  9268.     guint32     curr_offset;
    9269. 

  9269.     guint32     consumed;
    9270. 

  9270.     guint       curr_len;
    9271. 

  9271. 

  9272.     curr_offset = offset;
    9273. 

  9273.     curr_len = len;
    9274. 

  9274. 

  9275.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    9276. 

  9276. 

  9277.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    9278. 

  9278. 

  9279.     ELEM_OPT_TLV(ANSI_A_E_CELL_ID_LIST, "");
    9280. 

  9280. 

  9281.     ELEM_OPT_TV(ANSI_A_E_SCI, "");
    9282. 

  9282. 

  9283.     ELEM_OPT_TV(ANSI_A_E_SO, "");
    9284. 

  9284. 

  9285.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    9286. 

  9286. 

  9287.     switch (global_a_variant)
    9288. 

  9288.     {
    9289. 

  9289.     case A_VARIANT_IOS501:
    9290. 

  9290.         ELEM_OPT_TLV(ANSI_A_E_P_REV, "");
    9291. 

  9291. 

  9292.         ELEM_OPT_TLV(ANSI_A_E_MS_DES_FREQ, "");
    9293. 

  9293. 

  9294.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_FORMAT, "");
    9295. 

  9295. 

  9296.         ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9297. 

  9297. 

  9298.         ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    9299. 

  9299.         break;
    9300. 

  9300.     }
    9301. 

  9301. 

  9302.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9303. 

  9303. }
    9304. 

  9304. 

  9305. /*
    9306. 

  9306.  * IOS 6.1.2.4
    9307. 

  9307.  */
    9308. 

  9308. static void
    9309. 

  9309. dtap_page_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9310. 

  9310. {
    9311. 

  9311.     guint32     curr_offset;
    9312. 

  9312.     guint32     consumed;
    9313. 

  9313.     guint       curr_len;
    9314. 

  9314. 

  9315.     curr_offset = offset;
    9316. 

  9316.     curr_len = len;
    9317. 

  9317. 

  9318.     ELEM_MAND_LV(ANSI_A_E_CM_INFO_TYPE_2, "");
    9319. 

  9319. 

  9320.     ELEM_MAND_LV(ANSI_A_E_MID, "");
    9321. 

  9321. 

  9322.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    9323. 

  9323. 

  9324.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9325. 

  9325. 

  9326.     ELEM_OPT_TV(ANSI_A_E_SCI, "");
    9327. 

  9327. 

  9328.     ELEM_OPT_TLV(ANSI_A_E_AUTH_RESP_PARAM, "");
    9329. 

  9329. 

  9330.     ELEM_OPT_TV(ANSI_A_E_AUTH_CNF_PARAM, "");
    9331. 

  9331. 

  9332.     ELEM_OPT_TV(ANSI_A_E_AUTH_PARAM_COUNT, "");
    9333. 

  9333. 

  9334.     ELEM_OPT_TLV(ANSI_A_E_AUTH_CHLG_PARAM, "");
    9335. 

  9335. 

  9336.     ELEM_OPT_TV(ANSI_A_E_SO, "");
    9337. 

  9337. 

  9338.     ELEM_OPT_T(ANSI_A_E_VP_REQ, "");
    9339. 

  9339. 

  9340.     ELEM_OPT_TV(ANSI_A_E_CIC, "");
    9341. 

  9341. 

  9342.     ELEM_OPT_TLV(ANSI_A_E_AUTH_EVENT, "");
    9343. 

  9343. 

  9344.     ELEM_OPT_TV(ANSI_A_E_RE_RES, "");
    9345. 

  9345. 

  9346.     ELEM_OPT_TLV(ANSI_A_E_UZ_ID, "");
    9347. 

  9347. 

  9348.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    9349. 

  9349. 

  9350.     ELEM_OPT_TLV(ANSI_A_E_CDMA_SOWD, "");
    9351. 

  9351. 

  9352.     switch (global_a_variant)
    9353. 

  9353.     {
    9354. 

  9354.     case A_VARIANT_IOS501:
    9355. 

  9355.         ELEM_OPT_TLV(ANSI_A_E_SOCI, "");
    9356. 

  9356. 

  9357.         ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9358. 

  9358. 

  9359.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_SESSION, "");
    9360. 

  9360. 

  9361.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_FORMAT, "");
    9362. 

  9362.         break;
    9363. 

  9363.     }
    9364. 

  9364. 

  9365.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9366. 

  9366. }
    9367. 

  9367. 

  9368. /*
    9369. 

  9369.  * IOS 6.1.2.12
    9370. 

  9370.  */
    9371. 

  9371. static void
    9372. 

  9372. dtap_progress(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9373. 

  9373. {
    9374. 

  9374.     guint32     curr_offset;
    9375. 

  9375.     guint32     consumed;
    9376. 

  9376.     guint       curr_len;
    9377. 

  9377. 

  9378.     curr_offset = offset;
    9379. 

  9379.     curr_len = len;
    9380. 

  9380. 

  9381.     ELEM_OPT_TV(ANSI_A_E_SIGNAL, "");
    9382. 

  9382. 

  9383.     ELEM_OPT_TLV(ANSI_A_E_FWD_MS_INFO_RECS, "");
    9384. 

  9384. 

  9385.     ELEM_OPT_TLV(ANSI_A_E_SOCI, "");
    9386. 

  9386. 

  9387.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9388. 

  9388. }
    9389. 

  9389. 

  9390. /*
    9391. 

  9391.  * IOS 5 3.8.1
    9392. 

  9392.  */
    9393. 

  9393. static void
    9394. 

  9394. dtap_srvc_redirection(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9395. 

  9395. {
    9396. 

  9396.     guint32     curr_offset;
    9397. 

  9397.     guint32     consumed;
    9398. 

  9398.     guint       curr_len;
    9399. 

  9399. 

  9400.     curr_offset = offset;
    9401. 

  9401.     curr_len = len;
    9402. 

  9402. 

  9403.     ELEM_MAND_TLV(ANSI_A_E_IS2000_RED_RECORD, "");
    9404. 

  9404. 

  9405.     ELEM_MAND_TLV(ANSI_A_E_S_RED_INFO, "");
    9406. 

  9406. 

  9407.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    9408. 

  9408. 

  9409.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9410. 

  9410. 

  9411.     ELEM_OPT_TLV(ANSI_A_E_P_REV, "");
    9412. 

  9412. 

  9413.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9414. 

  9414. 

  9415.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9416. 

  9416. }
    9417. 

  9417. 

  9418. /*
    9419. 

  9419.  * IOS 5 3.1.11
    9420. 

  9420.  */
    9421. 

  9421. static void
    9422. 

  9422. dtap_srvc_release(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9423. 

  9423. {
    9424. 

  9424.     guint32     curr_offset;
    9425. 

  9425.     guint32     consumed;
    9426. 

  9426.     guint       curr_len;
    9427. 

  9427. 

  9428.     curr_offset = offset;
    9429. 

  9429.     curr_len = len;
    9430. 

  9430. 

  9431.     ELEM_MAND_TLV(ANSI_A_E_SOCI, "");
    9432. 

  9432. 

  9433.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    9434. 

  9434. 

  9435.     ELEM_OPT_TLV(ANSI_A_E_CAUSE_L3, "");
    9436. 

  9436. 

  9437.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9438. 

  9438. }
    9439. 

  9439. 

  9440. /*
    9441. 

  9441.  * IOS 5 3.1.12
    9442. 

  9442.  */
    9443. 

  9443. static void
    9444. 

  9444. dtap_srvc_release_complete(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9445. 

  9445. {
    9446. 

  9446.     guint32     curr_offset;
    9447. 

  9447.     guint32     consumed;
    9448. 

  9448.     guint       curr_len;
    9449. 

  9449. 

  9450.     curr_offset = offset;
    9451. 

  9451.     curr_len = len;
    9452. 

  9452. 

  9453.     ELEM_MAND_TLV(ANSI_A_E_SOCI, "");
    9454. 

  9454. 

  9455.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9456. 

  9456. }
    9457. 

  9457. 

  9458. /*
    9459. 

  9459.  * IOS 6.1.2.15
    9460. 

  9460.  */
    9461. 

  9461. static void
    9462. 

  9462. bsmap_ass_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9463. 

  9463. {
    9464. 

  9464.     guint16      consumed;
    9465. 

  9465.     guint32     curr_offset;
    9466. 

  9466.     guint       curr_len;
    9467. 

  9467. 

  9468.     curr_offset = offset;
    9469. 

  9469.     curr_len = len;
    9470. 

  9470. 

  9471.     ELEM_MAND_TLV(ANSI_A_E_CHAN_TYPE, "");
    9472. 

  9472. 

  9473.     ELEM_OPT_TV(ANSI_A_E_CIC, "");
    9474. 

  9474. 

  9475.     ELEM_OPT_TLV(ANSI_A_E_ENC_INFO, "");
    9476. 

  9476. 

  9477.     ELEM_OPT_TV(ANSI_A_E_SO, "");
    9478. 

  9478. 

  9479.     ELEM_OPT_TV(ANSI_A_E_SIGNAL, "");
    9480. 

  9480. 

  9481.     ELEM_OPT_TLV(ANSI_A_E_CLG_PARTY_ASCII_NUM, "");
    9482. 

  9482. 

  9483.     ELEM_OPT_TLV(ANSI_A_E_FWD_MS_INFO_RECS, "");
    9484. 

  9484. 

  9485.     ELEM_OPT_TLV(ANSI_A_E_PRIO, "");
    9486. 

  9486. 

  9487.     ELEM_OPT_TLV(ANSI_A_E_PACA_TS, "");
    9488. 

  9488. 

  9489.     ELEM_OPT_TLV(ANSI_A_E_QOS_PARAMS, "");
    9490. 

  9490. 

  9491.     switch (global_a_variant)
    9492. 

  9492.     {
    9493. 

  9493.     case A_VARIANT_IOS501:
    9494. 

  9494.         ELEM_OPT_TLV(ANSI_A_E_SOCI, "");
    9495. 

  9495. 

  9496.         ELEM_OPT_TLV(ANSI_A_E_SR_ID, "");
    9497. 

  9497. 

  9498.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_SESSION, "");
    9499. 

  9499. 

  9500.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_FORMAT, "");
    9501. 

  9501. 

  9502.         ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9503. 

  9503. 

  9504.         ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    9505. 

  9505.         break;
    9506. 

  9506.     }
    9507. 

  9507. 

  9508.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9509. 

  9509. }
    9510. 

  9510. 

  9511. /*
    9512. 

  9512.  * IOS 6.1.2.16
    9513. 

  9513.  */
    9514. 

  9514. static void
    9515. 

  9515. bsmap_ass_complete(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9516. 

  9516. {
    9517. 

  9517.     guint16     consumed;
    9518. 

  9518.     guint32     curr_offset;
    9519. 

  9519.     guint       curr_len;
    9520. 

  9520. 

  9521.     curr_offset = offset;
    9522. 

  9522.     curr_len = len;
    9523. 

  9523. 

  9524.     ELEM_MAND_TV(ANSI_A_E_CHAN_NUM, "");
    9525. 

  9525. 

  9526.     ELEM_OPT_TLV(ANSI_A_E_ENC_INFO, "");
    9527. 

  9527. 

  9528.     ELEM_OPT_TV(ANSI_A_E_SO, "");
    9529. 

  9529. 

  9530.     switch (global_a_variant)
    9531. 

  9531.     {
    9532. 

  9532.     case A_VARIANT_IOS501:
    9533. 

  9533.         ELEM_OPT_TLV(ANSI_A_E_SOCI, "");
    9534. 

  9534. 

  9535.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_SESSION, "");
    9536. 

  9536. 

  9537.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_FORMAT, "");
    9538. 

  9538. 

  9539.         ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9540. 

  9540.         break;
    9541. 

  9541.     }
    9542. 

  9542. 

  9543.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9544. 

  9544. }
    9545. 

  9545. 

  9546. /*
    9547. 

  9547.  * IOS 6.1.2.17
    9548. 

  9548.  */
    9549. 

  9549. static void
    9550. 

  9550. bsmap_ass_failure(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9551. 

  9551. {
    9552. 

  9552.     guint16     consumed;
    9553. 

  9553.     guint32     curr_offset;
    9554. 

  9554.     guint       curr_len;
    9555. 

  9555. 

  9556.     curr_offset = offset;
    9557. 

  9557.     curr_len = len;
    9558. 

  9558. 

  9559.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    9560. 

  9560. 

  9561.     ELEM_OPT_TLV(ANSI_A_E_SOCI, "");
    9562. 

  9562. 

  9563.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9564. 

  9564. }
    9565. 

  9565. 

  9566. /*
    9567. 

  9567.  * IOS 6.1.2.20
    9568. 

  9568.  */
    9569. 

  9569. static void
    9570. 

  9570. bsmap_clr_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9571. 

  9571. {
    9572. 

  9572.     guint16     consumed;
    9573. 

  9573.     guint32     curr_offset;
    9574. 

  9574.     guint       curr_len;
    9575. 

  9575. 

  9576.     curr_offset = offset;
    9577. 

  9577.     curr_len = len;
    9578. 

  9578. 

  9579.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    9580. 

  9580. 

  9581.     ELEM_OPT_TLV(ANSI_A_E_CAUSE_L3, "");
    9582. 

  9582. 

  9583.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9584. 

  9584. }
    9585. 

  9585. 

  9586. /*
    9587. 

  9587.  * IOS 6.1.2.21
    9588. 

  9588.  */
    9589. 

  9589. static void
    9590. 

  9590. bsmap_clr_command(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9591. 

  9591. {
    9592. 

  9592.     guint16     consumed;
    9593. 

  9593.     guint32     curr_offset;
    9594. 

  9594.     guint       curr_len;
    9595. 

  9595. 

  9596.     curr_offset = offset;
    9597. 

  9597.     curr_len = len;
    9598. 

  9598. 

  9599.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    9600. 

  9600. 

  9601.     ELEM_OPT_TLV(ANSI_A_E_CAUSE_L3, "");
    9602. 

  9602. 

  9603.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9604. 

  9604. }
    9605. 

  9605. 

  9606. /*
    9607. 

  9607.  * IOS 6.1.2.22
    9608. 

  9608.  */
    9609. 

  9609. static void
    9610. 

  9610. bsmap_clr_complete(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9611. 

  9611. {
    9612. 

  9612.     guint16     consumed;
    9613. 

  9613.     guint32     curr_offset;
    9614. 

  9614.     guint       curr_len;
    9615. 

  9615. 

  9616.     curr_offset = offset;
    9617. 

  9617.     curr_len = len;
    9618. 

  9618. 

  9619.     ELEM_OPT_T(ANSI_A_E_PDI, "");
    9620. 

  9620. 

  9621.     ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    9622. 

  9622. 

  9623.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9624. 

  9624. }
    9625. 

  9625. 

  9626. /*
    9627. 

  9627.  * IOS 6.1.2.24
    9628. 

  9628.  */
    9629. 

  9629. static void
    9630. 

  9630. dtap_alert_with_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9631. 

  9631. {
    9632. 

  9632.     guint32     curr_offset;
    9633. 

  9633.     guint32     consumed;
    9634. 

  9634.     guint       curr_len;
    9635. 

  9635. 

  9636.     curr_offset = offset;
    9637. 

  9637.     curr_len = len;
    9638. 

  9638. 

  9639.     ELEM_OPT_TLV(ANSI_A_E_FWD_MS_INFO_RECS, "");
    9640. 

  9640. 

  9641.     ELEM_OPT_TLV(ANSI_A_E_SOCI, "");
    9642. 

  9642. 

  9643.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9644. 

  9644. }
    9645. 

  9645. 

  9646. /*
    9647. 

  9647.  * IOS 6.1.2.28
    9648. 

  9648.  */
    9649. 

  9649. static void
    9650. 

  9650. bsmap_bs_srvc_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9651. 

  9651. {
    9652. 

  9652.     guint32     curr_offset;
    9653. 

  9653.     guint32     consumed;
    9654. 

  9654.     guint       curr_len;
    9655. 

  9655. 

  9656.     curr_offset = offset;
    9657. 

  9657.     curr_len = len;
    9658. 

  9658. 

  9659.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    9660. 

  9660. 

  9661.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9662. 

  9662. 

  9663.     ELEM_OPT_TV(ANSI_A_E_SO, "");
    9664. 

  9664. 

  9665.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    9666. 

  9666. 

  9667.     ELEM_OPT_TLV(ANSI_A_E_ADDS_USER_PART, "");
    9668. 

  9668. 

  9669.     ELEM_OPT_TLV(ANSI_A_E_SR_ID, "");
    9670. 

  9670. 

  9671.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9672. 

  9672. 

  9673.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9674. 

  9674. }
    9675. 

  9675. 

  9676. /*
    9677. 

  9677.  * IOS 6.1.2.29
    9678. 

  9678.  */
    9679. 

  9679. static void
    9680. 

  9680. bsmap_bs_srvc_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9681. 

  9681. {
    9682. 

  9682.     guint32     curr_offset;
    9683. 

  9683.     guint32     consumed;
    9684. 

  9684.     guint       curr_len;
    9685. 

  9685. 

  9686.     curr_offset = offset;
    9687. 

  9687.     curr_len = len;
    9688. 

  9688. 

  9689.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    9690. 

  9690. 

  9691.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9692. 

  9692. 

  9693.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    9694. 

  9694. 

  9695.     ELEM_OPT_TLV(ANSI_A_E_CAUSE, "");
    9696. 

  9696. 

  9697.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9698. 

  9698. 

  9699.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9700. 

  9700. }
    9701. 

  9701. 

  9702. /*
    9703. 

  9703.  * IOS 5 3.1.19
    9704. 

  9704.  */
    9705. 

  9705. static void
    9706. 

  9706. bsmap_add_srvc_noti(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9707. 

  9707. {
    9708. 

  9708.     guint32     curr_offset;
    9709. 

  9709.     guint32     consumed;
    9710. 

  9710.     guint       curr_len;
    9711. 

  9711. 

  9712.     curr_offset = offset;
    9713. 

  9713.     curr_len = len;
    9714. 

  9714. 

  9715.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    9716. 

  9716. 

  9717.     ELEM_MAND_TV(ANSI_A_E_SO, "");
    9718. 

  9718. 

  9719.     ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_SESSION, "");
    9720. 

  9720. 

  9721.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9722. 

  9722. }
    9723. 

  9723. 

  9724. /*
    9725. 

  9725.  * IOS 5 3.1.20
    9726. 

  9726.  */
    9727. 

  9727. static void
    9728. 

  9728. dtap_add_srvc_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9729. 

  9729. {
    9730. 

  9730.     guint32     curr_offset;
    9731. 

  9731.     guint32     consumed;
    9732. 

  9732.     guint       curr_len;
    9733. 

  9733. 

  9734.     curr_offset = offset;
    9735. 

  9735.     curr_len = len;
    9736. 

  9736. 

  9737.     ELEM_MAND_TLV(ANSI_A_E_SOCI, "");
    9738. 

  9738. 

  9739.     ELEM_OPT_TLV(ANSI_A_E_CLD_PARTY_BCD_NUM, "");
    9740. 

  9740. 

  9741.     ELEM_MAND_TV(ANSI_A_E_SO, "");
    9742. 

  9742. 

  9743.     ELEM_OPT_T(ANSI_A_E_VP_REQ, "");
    9744. 

  9744. 

  9745.     ELEM_OPT_TLV(ANSI_A_E_CLD_PARTY_ASCII_NUM, "");
    9746. 

  9746. 

  9747.     ELEM_OPT_TV(ANSI_A_E_CIC, "");
    9748. 

  9748. 

  9749.     ELEM_OPT_TLV(ANSI_A_E_SSCI, "");
    9750. 

  9750. 

  9751.     ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_SESSION, "");
    9752. 

  9752. 

  9753.     ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_FORMAT, "");
    9754. 

  9754. 

  9755.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9756. 

  9756. }
    9757. 

  9757. 

  9758. /*
    9759. 

  9759.  * IOS 5 3.1.10
    9760. 

  9760.  */
    9761. 

  9761. static void
    9762. 

  9762. dtap_connect(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9763. 

  9763. {
    9764. 

  9764.     guint32     curr_offset;
    9765. 

  9765.     guint32     consumed;
    9766. 

  9766.     guint       curr_len;
    9767. 

  9767. 

  9768.     curr_offset = offset;
    9769. 

  9769.     curr_len = len;
    9770. 

  9770. 

  9771.     ELEM_OPT_TLV(ANSI_A_E_SOCI, "");
    9772. 

  9772. 

  9773.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9774. 

  9774. }
    9775. 

  9775. 

  9776. /*
    9777. 

  9777.  * IOS 6.1.3.7
    9778. 

  9778.  */
    9779. 

  9779. static void
    9780. 

  9780. dtap_flash_with_info(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9781. 

  9781. {
    9782. 

  9782.     guint32     curr_offset;
    9783. 

  9783.     guint32     consumed;
    9784. 

  9784.     guint       curr_len;
    9785. 

  9785. 

  9786.     curr_offset = offset;
    9787. 

  9787.     curr_len = len;
    9788. 

  9788. 

  9789.     ELEM_OPT_TLV(ANSI_A_E_CLD_PARTY_BCD_NUM, "");
    9790. 

  9790. 

  9791.     ELEM_OPT_TV(ANSI_A_E_SIGNAL, "");
    9792. 

  9792. 

  9793.     ELEM_OPT_TV(ANSI_A_E_MWI, "");
    9794. 

  9794. 

  9795.     ELEM_OPT_TLV(ANSI_A_E_CLG_PARTY_ASCII_NUM, "");
    9796. 

  9796. 

  9797.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    9798. 

  9798. 

  9799.     if (pinfo->p2p_dir == P2P_DIR_RECV)
    9800. 

  9800.     {
    9801. 

  9801.         ELEM_OPT_TLV(ANSI_A_E_REV_MS_INFO_RECS, "");
    9802. 

  9802.     }
    9803. 

  9803.     else
    9804. 

  9804.     {
    9805. 

  9805.         ELEM_OPT_TLV(ANSI_A_E_FWD_MS_INFO_RECS, "");
    9806. 

  9806.     }
    9807. 

  9807. 

  9808.     ELEM_OPT_TLV(ANSI_A_E_SSCI, "");
    9809. 

  9809. 

  9810.     ELEM_OPT_TLV(ANSI_A_E_SOCI, "");
    9811. 

  9811. 

  9812.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9813. 

  9813. }
    9814. 

  9814. 

  9815. /*
    9816. 

  9816.  * IOS 6.1.3.8
    9817. 

  9817.  */
    9818. 

  9818. static void
    9819. 

  9819. dtap_flash_with_info_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9820. 

  9820. {
    9821. 

  9821.     guint32     curr_offset;
    9822. 

  9822.     guint32     consumed;
    9823. 

  9823.     guint       curr_len;
    9824. 

  9824. 

  9825.     curr_offset = offset;
    9826. 

  9826.     curr_len = len;
    9827. 

  9827. 

  9828.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    9829. 

  9829. 

  9830.     ELEM_OPT_TLV(ANSI_A_E_SOCI, "");
    9831. 

  9831. 

  9832.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9833. 

  9833. }
    9834. 

  9834. 

  9835. /*
    9836. 

  9836.  * IOS 6.1.3.9
    9837. 

  9837.  */
    9838. 

  9838. static void
    9839. 

  9839. bsmap_feat_noti(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9840. 

  9840. {
    9841. 

  9841.     guint32     curr_offset;
    9842. 

  9842.     guint32     consumed;
    9843. 

  9843.     guint       curr_len;
    9844. 

  9844. 

  9845.     curr_offset = offset;
    9846. 

  9846.     curr_len = len;
    9847. 

  9847. 

  9848.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    9849. 

  9849. 

  9850.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    9851. 

  9851. 

  9852.     ELEM_OPT_TLV(ANSI_A_E_CELL_ID_LIST, "");
    9853. 

  9853. 

  9854.     ELEM_OPT_TV(ANSI_A_E_SCI, "");
    9855. 

  9855. 

  9856.     ELEM_OPT_TV(ANSI_A_E_SIGNAL, "");
    9857. 

  9857. 

  9858.     ELEM_OPT_TV(ANSI_A_E_MWI, "");
    9859. 

  9859. 

  9860.     ELEM_OPT_TLV(ANSI_A_E_CLG_PARTY_ASCII_NUM, "");
    9861. 

  9861. 

  9862.     ELEM_OPT_TLV(ANSI_A_E_FWD_MS_INFO_RECS, "");
    9863. 

  9863. 

  9864.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    9865. 

  9865. 

  9866.     ELEM_OPT_TLV(ANSI_A_E_P_REV, "");
    9867. 

  9867. 

  9868.     ELEM_OPT_TLV(ANSI_A_E_MS_DES_FREQ, "");
    9869. 

  9869. 

  9870.     ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    9871. 

  9871. 

  9872.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9873. 

  9873. }
    9874. 

  9874. 

  9875. /*
    9876. 

  9876.  * IOS 6.1.3.10
    9877. 

  9877.  */
    9878. 

  9878. static void
    9879. 

  9879. bsmap_feat_noti_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9880. 

  9880. {
    9881. 

  9881.     guint32     curr_offset;
    9882. 

  9882.     guint32     consumed;
    9883. 

  9883.     guint       curr_len;
    9884. 

  9884. 

  9885.     curr_offset = offset;
    9886. 

  9886.     curr_len = len;
    9887. 

  9887. 

  9888.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    9889. 

  9889. 

  9890.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    9891. 

  9891. 

  9892.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9893. 

  9893. }
    9894. 

  9894. 

  9895. /*
    9896. 

  9896.  * IOS 6.1.3.11
    9897. 

  9897.  */
    9898. 

  9898. static void
    9899. 

  9899. bsmap_paca_command(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9900. 

  9900. {
    9901. 

  9901.     guint32     curr_offset;
    9902. 

  9902.     guint32     consumed;
    9903. 

  9903.     guint       curr_len;
    9904. 

  9904. 

  9905.     curr_offset = offset;
    9906. 

  9906.     curr_len = len;
    9907. 

  9907. 

  9908.     ELEM_OPT_TLV(ANSI_A_E_PRIO, "");
    9909. 

  9909. 

  9910.     ELEM_OPT_TLV(ANSI_A_E_PACA_TS, "");
    9911. 

  9911. 

  9912.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9913. 

  9913. }
    9914. 

  9914. 

  9915. /*
    9916. 

  9916.  * IOS 6.1.3.12
    9917. 

  9917.  */
    9918. 

  9918. static void
    9919. 

  9919. bsmap_paca_command_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9920. 

  9920. {
    9921. 

  9921.     guint32     curr_offset;
    9922. 

  9922.     guint32     consumed;
    9923. 

  9923.     guint       curr_len;
    9924. 

  9924. 

  9925.     curr_offset = offset;
    9926. 

  9926.     curr_len = len;
    9927. 

  9927. 

  9928.     ELEM_OPT_TLV(ANSI_A_E_CAUSE, "");
    9929. 

  9929. 

  9930.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9931. 

  9931. }
    9932. 

  9932. 

  9933. /*
    9934. 

  9934.  * IOS 6.1.3.13
    9935. 

  9935.  */
    9936. 

  9936. static void
    9937. 

  9937. bsmap_paca_update(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9938. 

  9938. {
    9939. 

  9939.     guint32     curr_offset;
    9940. 

  9940.     guint32     consumed;
    9941. 

  9941.     guint       curr_len;
    9942. 

  9942. 

  9943.     curr_offset = offset;
    9944. 

  9944.     curr_len = len;
    9945. 

  9945. 

  9946.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9947. 

  9947. 

  9948.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9949. 

  9949. 

  9950.     ELEM_OPT_TLV(ANSI_A_E_PACA_ORDER, "");
    9951. 

  9951. 

  9952.     ELEM_OPT_TLV(ANSI_A_E_PRIO, "");
    9953. 

  9953. 

  9954.     ELEM_OPT_TLV(ANSI_A_E_AUTH_RESP_PARAM, "");
    9955. 

  9955. 

  9956.     ELEM_OPT_TV(ANSI_A_E_AUTH_CNF_PARAM, "");
    9957. 

  9957. 

  9958.     ELEM_OPT_TV(ANSI_A_E_AUTH_PARAM_COUNT, "");
    9959. 

  9959. 

  9960.     ELEM_OPT_TLV(ANSI_A_E_AUTH_CHLG_PARAM, "");
    9961. 

  9961. 

  9962.     ELEM_OPT_TLV(ANSI_A_E_AUTH_EVENT, "");
    9963. 

  9963. 

  9964.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9965. 

  9965. 

  9966.     ELEM_OPT_TLV(ANSI_A_E_MS_DES_FREQ, "");
    9967. 

  9967. 

  9968.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9969. 

  9969. }
    9970. 

  9970. 

  9971. /*
    9972. 

  9972.  * IOS 6.1.3.14
    9973. 

  9973.  */
    9974. 

  9974. static void
    9975. 

  9975. bsmap_paca_update_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9976. 

  9976. {
    9977. 

  9977.     guint32     curr_offset;
    9978. 

  9978.     guint32     consumed;
    9979. 

  9979.     guint       curr_len;
    9980. 

  9980. 

  9981.     curr_offset = offset;
    9982. 

  9982.     curr_len = len;
    9983. 

  9983. 

  9984.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    9985. 

  9985. 

  9986.     ELEM_OPT_TLV(ANSI_A_E_PRIO, "");
    9987. 

  9987. 

  9988.     ELEM_OPT_TLV(ANSI_A_E_CAUSE, "");
    9989. 

  9989. 

  9990.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    9991. 

  9991. }
    9992. 

  9992. 

  9993. /*
    9994. 

  9994.  * IOS 5 3.2.9
    9995. 

  9995.  */
    9996. 

  9996. static void
    9997. 

  9997. bsmap_rm_pos_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    9998. 

  9998. {
    9999. 

  9999.     guint32     curr_offset;
    10000. 

  10000.     guint32     consumed;
    10001. 

  10001.     guint       curr_len;
    10002. 

  10002. 

  10003.     curr_offset = offset;
    10004. 

  10004.     curr_len = len;
    10005. 

  10005. 

  10006.     ELEM_MAND_TLV(ANSI_A_E_PSMM_COUNT, "");
    10007. 

  10007. 

  10008.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10009. 

  10009. }
    10010. 

  10010. 

  10011. /*
    10012. 

  10012.  * IOS 5 3.2.10
    10013. 

  10013.  */
    10014. 

  10014. static void
    10015. 

  10015. bsmap_rm_pos_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10016. 

  10016. {
    10017. 

  10017.     guint32     curr_offset;
    10018. 

  10018.     guint32     consumed;
    10019. 

  10019.     guint       curr_len;
    10020. 

  10020. 

  10021.     curr_offset = offset;
    10022. 

  10022.     curr_len = len;
    10023. 

  10023. 

  10024.     ELEM_OPT_TLV(ANSI_A_E_CDMA_SOWD, "");
    10025. 

  10025. 

  10026.     ELEM_OPT_TLV(ANSI_A_E_CAUSE, "");
    10027. 

  10027. 

  10028.     ELEM_OPT_TLV(ANSI_A_E_DOWNLINK_RE_LIST, "");
    10029. 

  10029. 

  10030.     ELEM_OPT_TLV(ANSI_A_E_GEO_LOC, "");
    10031. 

  10031. 

  10032.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10033. 

  10033. }
    10034. 

  10034. 

  10035. /*
    10036. 

  10036.  * IOS 6.1.4.1
    10037. 

  10037.  */
    10038. 

  10038. static void
    10039. 

  10039. bsmap_auth_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10040. 

  10040. {
    10041. 

  10041.     guint32     curr_offset;
    10042. 

  10042.     guint32     consumed;
    10043. 

  10043.     guint       curr_len;
    10044. 

  10044. 

  10045.     curr_offset = offset;
    10046. 

  10046.     curr_len = len;
    10047. 

  10047. 

  10048.     ELEM_MAND_TLV(ANSI_A_E_AUTH_CHLG_PARAM, "");
    10049. 

  10049. 

  10050.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10051. 

  10051. 

  10052.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    10053. 

  10053. 

  10054.     ELEM_OPT_TLV(ANSI_A_E_CELL_ID_LIST, "");
    10055. 

  10055. 

  10056.     ELEM_OPT_TV(ANSI_A_E_SCI, "");
    10057. 

  10057. 

  10058.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    10059. 

  10059. 

  10060.     ELEM_OPT_TLV(ANSI_A_E_P_REV, "");
    10061. 

  10061. 

  10062.     ELEM_OPT_TLV(ANSI_A_E_MS_DES_FREQ, "");
    10063. 

  10063. 

  10064.     ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    10065. 

  10065. 

  10066.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10067. 

  10067. }
    10068. 

  10068. 

  10069. static void
    10070. 

  10070. dtap_auth_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10071. 

  10071. {
    10072. 

  10072.     guint32     curr_offset;
    10073. 

  10073.     guint32     consumed;
    10074. 

  10074.     guint       curr_len;
    10075. 

  10075. 

  10076.     curr_offset = offset;
    10077. 

  10077.     curr_len = len;
    10078. 

  10078. 

  10079.     ELEM_MAND_LV(ANSI_A_E_AUTH_CHLG_PARAM, "");
    10080. 

  10080. 

  10081.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    10082. 

  10082. 

  10083.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10084. 

  10084. }
    10085. 

  10085. 

  10086. /*
    10087. 

  10087.  * IOS 6.1.4.2
    10088. 

  10088.  */
    10089. 

  10089. static void
    10090. 

  10090. bsmap_auth_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10091. 

  10091. {
    10092. 

  10092.     guint32     curr_offset;
    10093. 

  10093.     guint32     consumed;
    10094. 

  10094.     guint       curr_len;
    10095. 

  10095. 

  10096.     curr_offset = offset;
    10097. 

  10097.     curr_len = len;
    10098. 

  10098. 

  10099.     ELEM_MAND_TLV(ANSI_A_E_AUTH_RESP_PARAM, "");
    10100. 

  10100. 

  10101.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    10102. 

  10102. 

  10103.     ELEM_MAND_TV(ANSI_A_E_TAG, "");
    10104. 

  10104. 

  10105.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10106. 

  10106. 

  10107.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10108. 

  10108. 

  10109.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10110. 

  10110. }
    10111. 

  10111. 

  10112. /*
    10113. 

  10113.  * IOS 5
    10114. 

  10114.  * Section 3.1.21
    10115. 

  10115.  */
    10116. 

  10116. static void
    10117. 

  10117. bsmap_bearer_upd_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10118. 

  10118. {
    10119. 

  10119.     guint32     curr_offset;
    10120. 

  10120.     guint32     consumed;
    10121. 

  10121.     guint       curr_len;
    10122. 

  10122. 

  10123.     curr_offset = offset;
    10124. 

  10124.     curr_len = len;
    10125. 

  10125. 

  10126.     ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_SESSION, "");
    10127. 

  10127. 

  10128.     ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_FORMAT, "");
    10129. 

  10129. 

  10130.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10131. 

  10131. }
    10132. 

  10132. 

  10133. /*
    10134. 

  10134.  * IOS 5
    10135. 

  10135.  * Section 3.1.22
    10136. 

  10136.  */
    10137. 

  10137. static void
    10138. 

  10138. bsmap_bearer_upd_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10139. 

  10139. {
    10140. 

  10140.     guint32     curr_offset;
    10141. 

  10141.     guint32     consumed;
    10142. 

  10142.     guint       curr_len;
    10143. 

  10143. 

  10144.     curr_offset = offset;
    10145. 

  10145.     curr_len = len;
    10146. 

  10146. 

  10147.     ELEM_OPT_TLV(ANSI_A_E_CAUSE, "");
    10148. 

  10148. 

  10149.     ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_SESSION, "");
    10150. 

  10150. 

  10151.     ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_FORMAT, "");
    10152. 

  10152. 

  10153.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10154. 

  10154. }
    10155. 

  10155. 

  10156. /*
    10157. 

  10157.  * IOS 5
    10158. 

  10158.  * Section 3.1.23
    10159. 

  10159.  */
    10160. 

  10160. static void
    10161. 

  10161. bsmap_bearer_upd_reqd(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10162. 

  10162. {
    10163. 

  10163.     guint32     curr_offset;
    10164. 

  10164.     guint32     consumed;
    10165. 

  10165.     guint       curr_len;
    10166. 

  10166. 

  10167.     curr_offset = offset;
    10168. 

  10168.     curr_len = len;
    10169. 

  10169. 

  10170.     ELEM_OPT_TLV(ANSI_A_E_CAUSE, "");
    10171. 

  10171. 

  10172.     ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_SESSION, "");
    10173. 

  10173. 

  10174.     ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_FORMAT, "");
    10175. 

  10175. 

  10176.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10177. 

  10177. }
    10178. 

  10178. 

  10179. static void
    10180. 

  10180. dtap_auth_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10181. 

  10181. {
    10182. 

  10182.     guint32     curr_offset;
    10183. 

  10183.     guint32     consumed;
    10184. 

  10184.     guint       curr_len;
    10185. 

  10185. 

  10186.     curr_offset = offset;
    10187. 

  10187.     curr_len = len;
    10188. 

  10188. 

  10189.     ELEM_MAND_LV(ANSI_A_E_AUTH_RESP_PARAM, "");
    10190. 

  10190. 

  10191.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10192. 

  10192. }
    10193. 

  10193. 

  10194. /*
    10195. 

  10195.  * IOS 6.1.4.3
    10196. 

  10196.  */
    10197. 

  10197. static void
    10198. 

  10198. bsmap_user_zone_update(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10199. 

  10199. {
    10200. 

  10200.     guint32     curr_offset;
    10201. 

  10201.     guint32     consumed;
    10202. 

  10202.     guint       curr_len;
    10203. 

  10203. 

  10204.     curr_offset = offset;
    10205. 

  10205.     curr_len = len;
    10206. 

  10206. 

  10207.     ELEM_OPT_TLV(ANSI_A_E_UZ_ID, "");
    10208. 

  10208. 

  10209.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10210. 

  10210. }
    10211. 

  10211. 

  10212. /*
    10213. 

  10213.  * IOS 5 3.3.16
    10214. 

  10214.  */
    10215. 

  10215. static void
    10216. 

  10216. dtap_user_zone_update_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10217. 

  10217. {
    10218. 

  10218.     guint32     curr_offset;
    10219. 

  10219.     guint32     consumed;
    10220. 

  10220.     guint       curr_len;
    10221. 

  10221. 

  10222.     curr_offset = offset;
    10223. 

  10223.     curr_len = len;
    10224. 

  10224. 

  10225.     ELEM_MAND_TLV(ANSI_A_E_UZ_ID, "");
    10226. 

  10226. 

  10227.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10228. 

  10228. }
    10229. 

  10229. 

  10230. /*
    10231. 

  10231.  * IOS 5 3.3.17
    10232. 

  10232.  */
    10233. 

  10233. static void
    10234. 

  10234. dtap_user_zone_update(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10235. 

  10235. {
    10236. 

  10236.     guint32     curr_offset;
    10237. 

  10237.     guint32     consumed;
    10238. 

  10238.     guint       curr_len;
    10239. 

  10239. 

  10240.     curr_offset = offset;
    10241. 

  10241.     curr_len = len;
    10242. 

  10242. 

  10243.     ELEM_MAND_TLV(ANSI_A_E_UZ_ID, "");
    10244. 

  10244. 

  10245.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10246. 

  10246. }
    10247. 

  10247. 

  10248. /*
    10249. 

  10249.  * IOS 5 3.3.18
    10250. 

  10250.  */
    10251. 

  10251. static void
    10252. 

  10252. bsmap_user_zone_reject(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10253. 

  10253. {
    10254. 

  10254.     guint32     curr_offset;
    10255. 

  10255.     guint32     consumed;
    10256. 

  10256.     guint       curr_len;
    10257. 

  10257. 

  10258.     curr_offset = offset;
    10259. 

  10259.     curr_len = len;
    10260. 

  10260. 

  10261.     ELEM_OPT_TLV(ANSI_A_E_UZ_ID, "");
    10262. 

  10262. 

  10263.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    10264. 

  10264. 

  10265.     ELEM_OPT_TLV(ANSI_A_E_CELL_ID_LIST, "");
    10266. 

  10266. 

  10267.     ELEM_OPT_TV(ANSI_A_E_SCI, "");
    10268. 

  10268. 

  10269.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    10270. 

  10270. 

  10271.     ELEM_OPT_TLV(ANSI_A_E_P_REV, "");
    10272. 

  10272. 

  10273.     ELEM_OPT_TLV(ANSI_A_E_MS_DES_FREQ, "");
    10274. 

  10274. 

  10275.     ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    10276. 

  10276. 

  10277.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10278. 

  10278. }
    10279. 

  10279. 

  10280. /*
    10281. 

  10281.  * IOS 5 3.3.18
    10282. 

  10282.  */
    10283. 

  10283. static void
    10284. 

  10284. dtap_user_zone_reject(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10285. 

  10285. {
    10286. 

  10286.     guint32     curr_offset;
    10287. 

  10287.     guint32     consumed;
    10288. 

  10288.     guint       curr_len;
    10289. 

  10289. 

  10290.     curr_offset = offset;
    10291. 

  10291.     curr_len = len;
    10292. 

  10292. 

  10293.     ELEM_OPT_TLV(ANSI_A_E_UZ_ID, "");
    10294. 

  10294. 

  10295.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10296. 

  10296. }
    10297. 

  10297. 

  10298. /*
    10299. 

  10299.  * IOS 5 3.3.19
    10300. 

  10300.  */
    10301. 

  10301. static void
    10302. 

  10302. bsmap_reg_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10303. 

  10303. {
    10304. 

  10304.     guint32     curr_offset;
    10305. 

  10305.     guint32     consumed;
    10306. 

  10306.     guint       curr_len;
    10307. 

  10307. 

  10308.     curr_offset = offset;
    10309. 

  10309.     curr_len = len;
    10310. 

  10310. 

  10311.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    10312. 

  10312. 

  10313.     ELEM_OPT_TLV(ANSI_A_E_CELL_ID_LIST, "");
    10314. 

  10314. 

  10315.     ELEM_OPT_TV(ANSI_A_E_SCI, "");
    10316. 

  10316. 

  10317.     ELEM_OPT_TLV(ANSI_A_E_P_REV, "");
    10318. 

  10318. 

  10319.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    10320. 

  10320. 

  10321.     ELEM_OPT_TLV(ANSI_A_E_MS_DES_FREQ, "");
    10322. 

  10322. 

  10323.     ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    10324. 

  10324. 

  10325.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10326. 

  10326. }
    10327. 

  10327. 

  10328. /*
    10329. 

  10329.  * IOS 5 3.3.20
    10330. 

  10330.  */
    10331. 

  10331. static void
    10332. 

  10332. bsmap_ms_reg_noti(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10333. 

  10333. {
    10334. 

  10334.     guint32     curr_offset;
    10335. 

  10335.     guint32     consumed;
    10336. 

  10336.     guint       curr_len;
    10337. 

  10337. 

  10338.     curr_offset = offset;
    10339. 

  10339.     curr_len = len;
    10340. 

  10340. 

  10341.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    10342. 

  10342. 

  10343.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10344. 

  10344. }
    10345. 

  10345. 

  10346. /*
    10347. 

  10347.  * IOS 5 3.3.21
    10348. 

  10348.  */
    10349. 

  10349. static void
    10350. 

  10350. bsmap_bs_auth_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10351. 

  10351. {
    10352. 

  10352.     guint32     curr_offset;
    10353. 

  10353.     guint32     consumed;
    10354. 

  10354.     guint       curr_len;
    10355. 

  10355. 

  10356.     curr_offset = offset;
    10357. 

  10357.     curr_len = len;
    10358. 

  10358. 

  10359.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    10360. 

  10360. 

  10361.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10362. 

  10362. }
    10363. 

  10363. 

  10364. /*
    10365. 

  10365.  * IOS 5 3.3.22
    10366. 

  10366.  */
    10367. 

  10367. static void
    10368. 

  10368. bsmap_bs_auth_req_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10369. 

  10369. {
    10370. 

  10370.     guint32     curr_offset;
    10371. 

  10371.     guint32     consumed;
    10372. 

  10372.     guint       curr_len;
    10373. 

  10373. 

  10374.     curr_offset = offset;
    10375. 

  10375.     curr_len = len;
    10376. 

  10376. 

  10377.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    10378. 

  10378. 

  10379.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10380. 

  10380. }
    10381. 

  10381. 

  10382. /*
    10383. 

  10383.  * IOS 6.1.4.4
    10384. 

  10384.  */
    10385. 

  10385. static void
    10386. 

  10386. dtap_ssd_update_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10387. 

  10387. {
    10388. 

  10388.     guint32     curr_offset;
    10389. 

  10389.     guint32     consumed;
    10390. 

  10390.     guint       curr_len;
    10391. 

  10391. 

  10392.     curr_offset = offset;
    10393. 

  10393.     curr_len = len;
    10394. 

  10394. 

  10395.     ELEM_MAND_LV(ANSI_A_E_AUTH_CHLG_PARAM, "");
    10396. 

  10396. 

  10397.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10398. 

  10398. }
    10399. 

  10399. 

  10400. /*
    10401. 

  10401.  * IOS 6.1.4.5
    10402. 

  10402.  */
    10403. 

  10403. static void
    10404. 

  10404. dtap_bs_challenge(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10405. 

  10405. {
    10406. 

  10406.     guint32     curr_offset;
    10407. 

  10407.     guint32     consumed;
    10408. 

  10408.     guint       curr_len;
    10409. 

  10409. 

  10410.     curr_offset = offset;
    10411. 

  10411.     curr_len = len;
    10412. 

  10412. 

  10413.     ELEM_MAND_LV(ANSI_A_E_AUTH_CHLG_PARAM, "");
    10414. 

  10414. 

  10415.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10416. 

  10416. }
    10417. 

  10417. 

  10418. /*
    10419. 

  10419.  * IOS 6.1.4.6
    10420. 

  10420.  */
    10421. 

  10421. static void
    10422. 

  10422. dtap_bs_challenge_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10423. 

  10423. {
    10424. 

  10424.     guint32     curr_offset;
    10425. 

  10425.     guint32     consumed;
    10426. 

  10426.     guint       curr_len;
    10427. 

  10427. 

  10428.     curr_offset = offset;
    10429. 

  10429.     curr_len = len;
    10430. 

  10430. 

  10431.     ELEM_MAND_LV(ANSI_A_E_AUTH_RESP_PARAM, "");
    10432. 

  10432. 

  10433.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10434. 

  10434. }
    10435. 

  10435. 

  10436. /*
    10437. 

  10437.  * IOS 6.1.4.7
    10438. 

  10438.  */
    10439. 

  10439. static void
    10440. 

  10440. dtap_ssd_update_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10441. 

  10441. {
    10442. 

  10442.     guint32     curr_offset;
    10443. 

  10443.     guint32     consumed;
    10444. 

  10444.     guint       curr_len;
    10445. 

  10445. 

  10446.     curr_offset = offset;
    10447. 

  10447.     curr_len = len;
    10448. 

  10448. 

  10449.     ELEM_OPT_TLV(ANSI_A_E_CAUSE_L3, "");
    10450. 

  10450. 

  10451.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10452. 

  10452. }
    10453. 

  10453. 

  10454. /*
    10455. 

  10455.  * IOS 6.1.4.8
    10456. 

  10456.  */
    10457. 

  10457. static void
    10458. 

  10458. dtap_lu_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10459. 

  10459. {
    10460. 

  10460.     guint32     curr_offset;
    10461. 

  10461.     guint32     consumed;
    10462. 

  10462.     guint       curr_len;
    10463. 

  10463. 

  10464.     curr_offset = offset;
    10465. 

  10465.     curr_len = len;
    10466. 

  10466. 

  10467.     ELEM_MAND_LV(ANSI_A_E_MID, "");
    10468. 

  10468. 

  10469.     ELEM_OPT_TV(ANSI_A_E_LAI, "");
    10470. 

  10470. 

  10471.     ELEM_OPT_TLV(ANSI_A_E_CM_INFO_TYPE_2, "");
    10472. 

  10472. 

  10473.     ELEM_OPT_TV(ANSI_A_E_REG_TYPE, "");
    10474. 

  10474. 

  10475.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10476. 

  10476. 

  10477.     ELEM_OPT_TV(ANSI_A_E_SCI, "");
    10478. 

  10478. 

  10479.     ELEM_OPT_TLV(ANSI_A_E_AUTH_RESP_PARAM, "");
    10480. 

  10480. 

  10481.     ELEM_OPT_TV(ANSI_A_E_AUTH_CNF_PARAM, "");
    10482. 

  10482. 

  10483.     ELEM_OPT_TV(ANSI_A_E_AUTH_PARAM_COUNT, "");
    10484. 

  10484. 

  10485.     ELEM_OPT_TLV(ANSI_A_E_AUTH_CHLG_PARAM, "");
    10486. 

  10486. 

  10487.     ELEM_OPT_TLV(ANSI_A_E_AUTH_EVENT, "");
    10488. 

  10488. 

  10489.     ELEM_OPT_TLV(ANSI_A_E_UZ_ID, "");
    10490. 

  10490. 

  10491.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    10492. 

  10492. 

  10493.     ELEM_OPT_TV(ANSI_A_E_RETURN_CAUSE, "");
    10494. 

  10494. 

  10495.     ELEM_OPT_TLV(ANSI_A_E_MS_DES_FREQ, "");
    10496. 

  10496. 

  10497.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10498. 

  10498. 

  10499.     ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    10500. 

  10500. 

  10501.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10502. 

  10502. }
    10503. 

  10503. 

  10504. /*
    10505. 

  10505.  * IOS 6.1.4.9
    10506. 

  10506.  */
    10507. 

  10507. static void
    10508. 

  10508. dtap_lu_accept(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10509. 

  10509. {
    10510. 

  10510.     guint32     curr_offset;
    10511. 

  10511.     guint32     consumed;
    10512. 

  10512.     guint       curr_len;
    10513. 

  10513. 

  10514.     curr_offset = offset;
    10515. 

  10515.     curr_len = len;
    10516. 

  10516. 

  10517.     switch (global_a_variant)
    10518. 

  10518.     {
    10519. 

  10519.     case A_VARIANT_IOS401:
    10520. 

  10520.         ELEM_OPT_TV(ANSI_A_E_LAI, "");
    10521. 

  10521.         break;
    10522. 

  10522. 

  10523.     case A_VARIANT_IOS501:
    10524. 

  10524.         ELEM_OPT_TLV(ANSI_A_E_CAUSE, "");
    10525. 

  10525. 

  10526.         ELEM_OPT_TLV(ANSI_A_E_P_REV, "");
    10527. 

  10527. 

  10528.         ELEM_OPT_TLV(ANSI_A_E_MS_DES_FREQ, "");
    10529. 

  10529.         break;
    10530. 

  10530.     }
    10531. 

  10531. 

  10532.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10533. 

  10533. }
    10534. 

  10534. 

  10535. /*
    10536. 

  10536.  * IOS 6.1.4.10
    10537. 

  10537.  */
    10538. 

  10538. static void
    10539. 

  10539. dtap_lu_reject(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10540. 

  10540. {
    10541. 

  10541.     guint32     curr_offset;
    10542. 

  10542.     guint32     consumed;
    10543. 

  10543.     guint       curr_len;
    10544. 

  10544. 

  10545.     curr_offset = offset;
    10546. 

  10546.     curr_len = len;
    10547. 

  10547. 

  10548.     ELEM_MAND_V(ANSI_A_E_REJ_CAUSE);
    10549. 

  10549. 

  10550.     switch (global_a_variant)
    10551. 

  10551.     {
    10552. 

  10552.     case A_VARIANT_IOS501:
    10553. 

  10553.         ELEM_OPT_TLV(ANSI_A_E_P_REV, "");
    10554. 

  10554. 

  10555.         ELEM_OPT_TLV(ANSI_A_E_MS_DES_FREQ, "");
    10556. 

  10556.         break;
    10557. 

  10557.     }
    10558. 

  10558. 

  10559.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10560. 

  10560. }
    10561. 

  10561. 

  10562. /*
    10563. 

  10563.  * IOS 6.1.4.18
    10564. 

  10564.  */
    10565. 

  10565. static void
    10566. 

  10566. bsmap_priv_mode_command(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10567. 

  10567. {
    10568. 

  10568.     guint32     curr_offset;
    10569. 

  10569.     guint32     consumed;
    10570. 

  10570.     guint       curr_len;
    10571. 

  10571. 

  10572.     curr_offset = offset;
    10573. 

  10573.     curr_len = len;
    10574. 

  10574. 

  10575.     ELEM_MAND_TLV(ANSI_A_E_ENC_INFO, "");
    10576. 

  10576. 

  10577.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10578. 

  10578. }
    10579. 

  10579. 

  10580. /*
    10581. 

  10581.  * IOS 6.1.4.19
    10582. 

  10582.  */
    10583. 

  10583. static void
    10584. 

  10584. bsmap_priv_mode_complete(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10585. 

  10585. {
    10586. 

  10586.     guint32     curr_offset;
    10587. 

  10587.     guint32     consumed;
    10588. 

  10588.     guint       curr_len;
    10589. 

  10589. 

  10590.     curr_offset = offset;
    10591. 

  10591.     curr_len = len;
    10592. 

  10592. 

  10593.     ELEM_OPT_TLV(ANSI_A_E_ENC_INFO, "");
    10594. 

  10594. 

  10595.     ELEM_OPT_T(ANSI_A_E_VP_REQ, "");
    10596. 

  10596. 

  10597.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10598. 

  10598. }
    10599. 

  10599. 

  10600. /*
    10601. 

  10601.  * IOS 5 3.3.14
    10602. 

  10602.  */
    10603. 

  10603. static void
    10604. 

  10604. bsmap_status_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10605. 

  10605. {
    10606. 

  10606.     guint32     curr_offset;
    10607. 

  10607.     guint32     consumed;
    10608. 

  10608.     guint       curr_len;
    10609. 

  10609. 

  10610.     curr_offset = offset;
    10611. 

  10611.     curr_len = len;
    10612. 

  10612. 

  10613.     ELEM_MAND_TLV(ANSI_A_E_IE_REQD, "");
    10614. 

  10614. 

  10615.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10616. 

  10616. 

  10617.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10618. 

  10618. 

  10619.     ELEM_OPT_TV(ANSI_A_E_SCI, "");
    10620. 

  10620. 

  10621.     ELEM_OPT_TLV(ANSI_A_E_CELL_ID_LIST, "");
    10622. 

  10622. 

  10623.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    10624. 

  10624. 

  10625.     ELEM_OPT_TLV(ANSI_A_E_P_REV, "");
    10626. 

  10626. 

  10627.     ELEM_OPT_TLV(ANSI_A_E_MS_DES_FREQ, "");
    10628. 

  10628. 

  10629.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10630. 

  10630. 

  10631.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    10632. 

  10632. 

  10633.     ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    10634. 

  10634. 

  10635.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10636. 

  10636. }
    10637. 

  10637. 

  10638. /*
    10639. 

  10639.  * IOS 5 3.3.14
    10640. 

  10640.  */
    10641. 

  10641. static void
    10642. 

  10642. dtap_status_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10643. 

  10643. {
    10644. 

  10644.     guint32     curr_offset;
    10645. 

  10645.     guint32     consumed;
    10646. 

  10646.     guint       curr_len;
    10647. 

  10647. 

  10648.     curr_offset = offset;
    10649. 

  10649.     curr_len = len;
    10650. 

  10650. 

  10651.     ELEM_MAND_LV(ANSI_A_E_IE_REQD, "");
    10652. 

  10652. 

  10653.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10654. 

  10654. }
    10655. 

  10655. 

  10656. 

  10657. /*
    10658. 

  10658.  * IOS 5 3.3.15
    10659. 

  10659.  */
    10660. 

  10660. static void
    10661. 

  10661. bsmap_status_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10662. 

  10662. {
    10663. 

  10663.     guint32     curr_offset;
    10664. 

  10664.     guint32     consumed;
    10665. 

  10665.     guint       curr_len;
    10666. 

  10666. 

  10667.     curr_offset = offset;
    10668. 

  10668.     curr_len = len;
    10669. 

  10669. 

  10670.     ELEM_MAND_TLV(ANSI_A_E_REV_MS_INFO_RECS, "");
    10671. 

  10671. 

  10672.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10673. 

  10673. 

  10674.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10675. 

  10675. 

  10676.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10677. 

  10677. 

  10678.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    10679. 

  10679. 

  10680.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10681. 

  10681. }
    10682. 

  10682. 

  10683. /*
    10684. 

  10684.  * IOS 5 3.3.15
    10685. 

  10685.  */
    10686. 

  10686. static void
    10687. 

  10687. dtap_status_resp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10688. 

  10688. {
    10689. 

  10689.     guint32     curr_offset;
    10690. 

  10690.     guint32     consumed;
    10691. 

  10691.     guint       curr_len;
    10692. 

  10692. 

  10693.     curr_offset = offset;
    10694. 

  10694.     curr_len = len;
    10695. 

  10695. 

  10696.     ELEM_MAND_LV(ANSI_A_E_REV_MS_INFO_RECS, "");
    10697. 

  10697. 

  10698.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10699. 

  10699. }
    10700. 

  10700. 

  10701. /*
    10702. 

  10702.  * IOS 6.1.5.4
    10703. 

  10703.  */
    10704. 

  10704. static void
    10705. 

  10705. bsmap_ho_reqd(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10706. 

  10706. {
    10707. 

  10707.     guint32     curr_offset;
    10708. 

  10708.     guint32     consumed;
    10709. 

  10709.     guint       curr_len;
    10710. 

  10710. 

  10711.     curr_offset = offset;
    10712. 

  10712.     curr_len = len;
    10713. 

  10713. 

  10714.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    10715. 

  10715. 

  10716.     ELEM_MAND_TLV(ANSI_A_E_CELL_ID_LIST, " (Target)");
    10717. 

  10717. 

  10718.     ELEM_OPT_TLV(ANSI_A_E_CM_INFO_TYPE_2, "");
    10719. 

  10719. 

  10720.     ELEM_OPT_T(ANSI_A_E_RESP_REQ, "");
    10721. 

  10721. 

  10722.     ELEM_OPT_TLV(ANSI_A_E_ENC_INFO, "");
    10723. 

  10723. 

  10724.     ELEM_OPT_TLV(ANSI_A_E_IS95_CHAN_ID, "");
    10725. 

  10725. 

  10726.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10727. 

  10727. 

  10728.     ELEM_OPT_TLV(ANSI_A_E_DOWNLINK_RE, "");
    10729. 

  10729. 

  10730.     ELEM_OPT_TV(ANSI_A_E_SO, "");
    10731. 

  10731. 

  10732.     ELEM_OPT_TLV(ANSI_A_E_CDMA_SOWD, "");
    10733. 

  10733. 

  10734.     ELEM_OPT_TLV(ANSI_A_E_IS95_MS_MEAS_CHAN_ID, "");
    10735. 

  10735. 

  10736.     ELEM_OPT_TLV(ANSI_A_E_IS2000_CHAN_ID, "");
    10737. 

  10737. 

  10738.     ELEM_OPT_TLV(ANSI_A_E_QOS_PARAMS, "");
    10739. 

  10739. 

  10740.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    10741. 

  10741. 

  10742.     ELEM_OPT_TLV(ANSI_A_E_IS2000_SCR, "");
    10743. 

  10743. 

  10744.     switch (global_a_variant)
    10745. 

  10745.     {
    10746. 

  10746.     case A_VARIANT_IOS401:
    10747. 

  10747.         ELEM_OPT_TLV(ANSI_A_E_PDSN_IP_ADDR, "");
    10748. 

  10748.         break;
    10749. 

  10749. 

  10750.     case A_VARIANT_IOS501:
    10751. 

  10751.         ELEM_OPT_TLV(ANSI_A_E_S_PDSN_ADDR, "");
    10752. 

  10752.         break;
    10753. 

  10753.     }
    10754. 

  10754. 

  10755.     ELEM_OPT_TLV(ANSI_A_E_PTYPE, "");
    10756. 

  10756. 

  10757.     ELEM_OPT_TLV(ANSI_A_E_SRNC_TRNC_TC, "");
    10758. 

  10758. 

  10759.     ELEM_OPT_TV(ANSI_A_E_SCI, "");
    10760. 

  10760. 

  10761.     ELEM_OPT_TV(ANSI_A_E_ACC_NET_ID, "");
    10762. 

  10762. 

  10763.     ELEM_OPT_TLV(ANSI_A_E_SO_LIST, "");
    10764. 

  10764. 

  10765.     ELEM_OPT_TLV(ANSI_A_E_IS2000_CHAN_ID_3X, "");
    10766. 

  10766. 

  10767.     ELEM_OPT_TLV(ANSI_A_E_IS2000_NN_SCR, "");
    10768. 

  10768. 

  10769.     ELEM_OPT_TLV(ANSI_A_E_ANCH_PDSN_ADDR, "");
    10770. 

  10770. 

  10771.     ELEM_OPT_TLV(ANSI_A_E_ANCH_PP_ADDR, "");
    10772. 

  10772. 

  10773.     ELEM_OPT_TLV(ANSI_A_E_PSP, "");
    10774. 

  10774. 

  10775.     ELEM_OPT_TLV(ANSI_A_E_PLCM_ID, "");
    10776. 

  10776. 

  10777.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10778. 

  10778. 

  10779.     ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    10780. 

  10780. 

  10781.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10782. 

  10782. }
    10783. 

  10783. 

  10784. /*
    10785. 

  10785.  * IOS 6.1.5.5
    10786. 

  10786.  */
    10787. 

  10787. static void
    10788. 

  10788. bsmap_ho_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10789. 

  10789. {
    10790. 

  10790.     guint32     curr_offset;
    10791. 

  10791.     guint32     consumed;
    10792. 

  10792.     guint       curr_len;
    10793. 

  10793. 

  10794.     curr_offset = offset;
    10795. 

  10795.     curr_len = len;
    10796. 

  10796. 

  10797.     ELEM_MAND_TLV(ANSI_A_E_CHAN_TYPE, "");
    10798. 

  10798. 

  10799.     ELEM_MAND_TLV(ANSI_A_E_ENC_INFO, "");
    10800. 

  10800. 

  10801.     ELEM_MAND_TLV(ANSI_A_E_CM_INFO_TYPE_2, "");
    10802. 

  10802. 

  10803.     ELEM_MAND_TLV(ANSI_A_E_CELL_ID_LIST, "(Target)");
    10804. 

  10804. 

  10805.     ELEM_OPT_TLV(ANSI_A_E_CIC_EXT, "");
    10806. 

  10806. 

  10807.     ELEM_OPT_TLV(ANSI_A_E_IS95_CHAN_ID, "");
    10808. 

  10808. 

  10809.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10810. 

  10810. 

  10811.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10812. 

  10812. 

  10813.     ELEM_OPT_TLV(ANSI_A_E_DOWNLINK_RE, "");
    10814. 

  10814. 

  10815.     ELEM_OPT_TV(ANSI_A_E_SO, "");
    10816. 

  10816. 

  10817.     ELEM_OPT_TLV(ANSI_A_E_CDMA_SOWD, "");
    10818. 

  10818. 

  10819.     ELEM_OPT_TLV(ANSI_A_E_IS95_MS_MEAS_CHAN_ID, "");
    10820. 

  10820. 

  10821.     ELEM_OPT_TLV(ANSI_A_E_IS2000_CHAN_ID, "");
    10822. 

  10822. 

  10823.     ELEM_OPT_TLV(ANSI_A_E_QOS_PARAMS, "");
    10824. 

  10824. 

  10825.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    10826. 

  10826. 

  10827.     ELEM_OPT_TLV(ANSI_A_E_IS2000_SCR, "");
    10828. 

  10828. 

  10829.     switch (global_a_variant)
    10830. 

  10830.     {
    10831. 

  10831.     case A_VARIANT_IOS401:
    10832. 

  10832.         ELEM_OPT_TLV(ANSI_A_E_PDSN_IP_ADDR, "");
    10833. 

  10833.         break;
    10834. 

  10834. 

  10835.     case A_VARIANT_IOS501:
    10836. 

  10836.         ELEM_OPT_TLV(ANSI_A_E_S_PDSN_ADDR, "");
    10837. 

  10837.         break;
    10838. 

  10838.     }
    10839. 

  10839. 

  10840.     ELEM_OPT_TLV(ANSI_A_E_PTYPE, "");
    10841. 

  10841. 

  10842.     switch (global_a_variant)
    10843. 

  10843.     {
    10844. 

  10844.     case A_VARIANT_IOS501:
    10845. 

  10845.         ELEM_OPT_TLV(ANSI_A_E_SRNC_TRNC_TC, "");
    10846. 

  10846. 

  10847.         ELEM_OPT_TV(ANSI_A_E_SCI, "");
    10848. 

  10848. 

  10849.         ELEM_OPT_TV(ANSI_A_E_ACC_NET_ID, "");
    10850. 

  10850. 

  10851.         ELEM_OPT_TLV(ANSI_A_E_SO_LIST, "");
    10852. 

  10852. 

  10853.         ELEM_OPT_TLV(ANSI_A_E_IS2000_CHAN_ID_3X, "");
    10854. 

  10854. 

  10855.         ELEM_OPT_TLV(ANSI_A_E_IS2000_NN_SCR, "");
    10856. 

  10856. 

  10857.         ELEM_OPT_TLV(ANSI_A_E_ANCH_PDSN_ADDR, "");
    10858. 

  10858. 

  10859.         ELEM_OPT_TLV(ANSI_A_E_ANCH_PP_ADDR, "");
    10860. 

  10860. 

  10861.         ELEM_OPT_TLV(ANSI_A_E_PSP, "");
    10862. 

  10862. 

  10863.         ELEM_OPT_TLV(ANSI_A_E_PLCM_ID, "");
    10864. 

  10864. 

  10865.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_SESSION, "");
    10866. 

  10866. 

  10867.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_FORMAT, "");
    10868. 

  10868. 

  10869.         ELEM_OPT_TLV(ANSI_A_E_MID, "");
    10870. 

  10870. 

  10871.         ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    10872. 

  10872.         break;
    10873. 

  10873.     }
    10874. 

  10874. 

  10875.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10876. 

  10876. }
    10877. 

  10877. 

  10878. /*
    10879. 

  10879.  * IOS 6.1.5.6
    10880. 

  10880.  */
    10881. 

  10881. static void
    10882. 

  10882. bsmap_ho_req_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10883. 

  10883. {
    10884. 

  10884.     guint32     curr_offset;
    10885. 

  10885.     guint32     consumed;
    10886. 

  10886.     guint       curr_len;
    10887. 

  10887. 

  10888.     curr_offset = offset;
    10889. 

  10889.     curr_len = len;
    10890. 

  10890. 

  10891.     ELEM_OPT_TLV(ANSI_A_E_IS95_CHAN_ID, "");
    10892. 

  10892. 

  10893.     ELEM_OPT_TLV(ANSI_A_E_CELL_ID_LIST, "");
    10894. 

  10894. 

  10895.     ELEM_OPT_TLV(ANSI_A_E_EXT_HO_DIR_PARAMS, "");
    10896. 

  10896. 

  10897.     ELEM_OPT_TV(ANSI_A_E_HHO_PARAMS, "");
    10898. 

  10898. 

  10899.     ELEM_OPT_TLV(ANSI_A_E_IS2000_CHAN_ID, "");
    10900. 

  10900. 

  10901.     ELEM_OPT_TLV(ANSI_A_E_IS2000_SCR, "");
    10902. 

  10902. 

  10903.     ELEM_OPT_TLV(ANSI_A_E_IS2000_NN_SCR, "");
    10904. 

  10904. 

  10905.     switch (global_a_variant)
    10906. 

  10906.     {
    10907. 

  10907.     case A_VARIANT_IOS501:
    10908. 

  10908.         ELEM_OPT_TLV(ANSI_A_E_TRNC_SRNC_TC, "");
    10909. 

  10909. 

  10910.         ELEM_OPT_TLV(ANSI_A_E_SO_LIST, "");
    10911. 

  10911. 

  10912.         ELEM_OPT_TLV(ANSI_A_E_CAUSE, "");
    10913. 

  10913. 

  10914.         ELEM_OPT_TLV(ANSI_A_E_IS2000_CHAN_ID_3X, "");
    10915. 

  10915. 

  10916.         ELEM_OPT_TLV(ANSI_A_E_PLCM_ID, "");
    10917. 

  10917. 

  10918.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_SESSION, "");
    10919. 

  10919. 

  10920.         ELEM_OPT_TLV(ANSI_A_E_A2P_BEARER_FORMAT, "");
    10921. 

  10921.         break;
    10922. 

  10922.     }
    10923. 

  10923. 

  10924.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10925. 

  10925. }
    10926. 

  10926. 

  10927. /*
    10928. 

  10928.  * IOS 6.1.5.7
    10929. 

  10929.  */
    10930. 

  10930. static void
    10931. 

  10931. bsmap_ho_failure(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10932. 

  10932. {
    10933. 

  10933.     guint32     curr_offset;
    10934. 

  10934.     guint32     consumed;
    10935. 

  10935.     guint       curr_len;
    10936. 

  10936. 

  10937.     curr_offset = offset;
    10938. 

  10938.     curr_len = len;
    10939. 

  10939. 

  10940.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    10941. 

  10941. 

  10942.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10943. 

  10943. }
    10944. 

  10944. 

  10945. /*
    10946. 

  10946.  * IOS 6.1.5.8
    10947. 

  10947.  */
    10948. 

  10948. static void
    10949. 

  10949. bsmap_ho_command(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    10950. 

  10950. {
    10951. 

  10951.     guint32     curr_offset;
    10952. 

  10952.     guint32     consumed;
    10953. 

  10953.     guint       curr_len;
    10954. 

  10954. 

  10955.     curr_offset = offset;
    10956. 

  10956.     curr_len = len;
    10957. 

  10957. 

  10958.     ELEM_OPT_TV(ANSI_A_E_RF_CHAN_ID, "");
    10959. 

  10959. 

  10960.     ELEM_OPT_TLV(ANSI_A_E_IS95_CHAN_ID, "");
    10961. 

  10961. 

  10962.     ELEM_OPT_TLV(ANSI_A_E_CELL_ID_LIST, "");
    10963. 

  10963. 

  10964.     ELEM_OPT_TLV(ANSI_A_E_HO_POW_LEV, "");
    10965. 

  10965. 

  10966.     ELEM_OPT_TV(ANSI_A_E_SID, "");
    10967. 

  10967. 

  10968.     ELEM_OPT_TLV(ANSI_A_E_EXT_HO_DIR_PARAMS, "");
    10969. 

  10969. 

  10970.     ELEM_OPT_TV(ANSI_A_E_HHO_PARAMS, "");
    10971. 

  10971. 

  10972.     ELEM_OPT_TLV(ANSI_A_E_IS2000_CHAN_ID, "");
    10973. 

  10973. 

  10974.     ELEM_OPT_TLV(ANSI_A_E_IS2000_SCR, "");
    10975. 

  10975. 

  10976.     ELEM_OPT_TLV(ANSI_A_E_IS2000_NN_SCR, "");
    10977. 

  10977. 

  10978.     switch (global_a_variant)
    10979. 

  10979.     {
    10980. 

  10980.     case A_VARIANT_IOS501:
    10981. 

  10981.         ELEM_OPT_TLV(ANSI_A_E_TRNC_SRNC_TC, "");
    10982. 

  10982. 

  10983.         ELEM_OPT_TLV(ANSI_A_E_SO_LIST, "");
    10984. 

  10984. 

  10985.         ELEM_OPT_TLV(ANSI_A_E_CAUSE, "");
    10986. 

  10986. 

  10987.         ELEM_OPT_TLV(ANSI_A_E_AMPS_HHO_PARAM, "");
    10988. 

  10988. 

  10989.         ELEM_OPT_TLV(ANSI_A_E_IS2000_CHAN_ID_3X, "");
    10990. 

  10990. 

  10991.         ELEM_OPT_TLV(ANSI_A_E_PLCM_ID, "");
    10992. 

  10992.         break;
    10993. 

  10993.     }
    10994. 

  10994. 

  10995.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    10996. 

  10996. }
    10997. 

  10997. 

  10998. /*
    10999. 

  10999.  * IOS 5 3.4.6
    11000. 

  11000.  */
    11001. 

  11001. static void
    11002. 

  11002. bsmap_ho_complete(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11003. 

  11003. {
    11004. 

  11004.     guint32     curr_offset;
    11005. 

  11005.     guint32     consumed;
    11006. 

  11006.     guint       curr_len;
    11007. 

  11007. 

  11008.     curr_offset = offset;
    11009. 

  11009.     curr_len = len;
    11010. 

  11010. 

  11011.     ELEM_OPT_TV(ANSI_A_E_SO, "");
    11012. 

  11012. 

  11013.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11014. 

  11014. }
    11015. 

  11015. 

  11016. /*
    11017. 

  11017.  * IOS 6.1.5.9
    11018. 

  11018.  */
    11019. 

  11019. static void
    11020. 

  11020. bsmap_ho_reqd_rej(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11021. 

  11021. {
    11022. 

  11022.     guint32     curr_offset;
    11023. 

  11023.     guint32     consumed;
    11024. 

  11024.     guint       curr_len;
    11025. 

  11025. 

  11026.     curr_offset = offset;
    11027. 

  11027.     curr_len = len;
    11028. 

  11028. 

  11029.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    11030. 

  11030. 

  11031.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11032. 

  11032. }
    11033. 

  11033. 

  11034. /*
    11035. 

  11035.  * IOS 6.1.5.12
    11036. 

  11036.  */
    11037. 

  11037. static void
    11038. 

  11038. bsmap_ho_performed(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11039. 

  11039. {
    11040. 

  11040.     guint32     curr_offset;
    11041. 

  11041.     guint32     consumed;
    11042. 

  11042.     guint       curr_len;
    11043. 

  11043. 

  11044.     curr_offset = offset;
    11045. 

  11045.     curr_len = len;
    11046. 

  11046. 

  11047.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    11048. 

  11048. 

  11049.     ELEM_OPT_TLV(ANSI_A_E_CELL_ID_LIST, "");
    11050. 

  11050. 

  11051.     ELEM_OPT_TV(ANSI_A_E_CHAN_NUM, "");
    11052. 

  11052. 

  11053.     ELEM_OPT_TLV(ANSI_A_E_BAND_CLASS, "");
    11054. 

  11054. 

  11055.     ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    11056. 

  11056. 

  11057.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11058. 

  11058. }
    11059. 

  11059. 

  11060. /*
    11061. 

  11061.  * IOS 6.1.6.2
    11062. 

  11062.  */
    11063. 

  11063. static void
    11064. 

  11064. bsmap_block(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11065. 

  11065. {
    11066. 

  11066.     guint32     curr_offset;
    11067. 

  11067.     guint32     consumed;
    11068. 

  11068.     guint       curr_len;
    11069. 

  11069. 

  11070.     curr_offset = offset;
    11071. 

  11071.     curr_len = len;
    11072. 

  11072. 

  11073.     ELEM_MAND_TV(ANSI_A_E_CIC, "");
    11074. 

  11074. 

  11075.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    11076. 

  11076. 

  11077.     ELEM_OPT_TLV(ANSI_A_E_CCT_GROUP, "");
    11078. 

  11078. 

  11079.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11080. 

  11080. }
    11081. 

  11081. 

  11082. /*
    11083. 

  11083.  * IOS 6.1.6.3
    11084. 

  11084.  */
    11085. 

  11085. static void
    11086. 

  11086. bsmap_block_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11087. 

  11087. {
    11088. 

  11088.     guint32     curr_offset;
    11089. 

  11089.     guint32     consumed;
    11090. 

  11090.     guint       curr_len;
    11091. 

  11091. 

  11092.     curr_offset = offset;
    11093. 

  11093.     curr_len = len;
    11094. 

  11094. 

  11095.     ELEM_MAND_TV(ANSI_A_E_CIC, "");
    11096. 

  11096. 

  11097.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11098. 

  11098. }
    11099. 

  11099. 

  11100. /*
    11101. 

  11101.  * IOS 6.1.6.4
    11102. 

  11102.  */
    11103. 

  11103. static void
    11104. 

  11104. bsmap_unblock(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11105. 

  11105. {
    11106. 

  11106.     guint32     curr_offset;
    11107. 

  11107.     guint32     consumed;
    11108. 

  11108.     guint       curr_len;
    11109. 

  11109. 

  11110.     curr_offset = offset;
    11111. 

  11111.     curr_len = len;
    11112. 

  11112. 

  11113.     ELEM_MAND_TV(ANSI_A_E_CIC, "");
    11114. 

  11114. 

  11115.     ELEM_OPT_TLV(ANSI_A_E_CCT_GROUP, "");
    11116. 

  11116. 

  11117.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11118. 

  11118. }
    11119. 

  11119. 

  11120. /*
    11121. 

  11121.  * IOS 6.1.6.5
    11122. 

  11122.  */
    11123. 

  11123. static void
    11124. 

  11124. bsmap_unblock_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11125. 

  11125. {
    11126. 

  11126.     guint32     curr_offset;
    11127. 

  11127.     guint32     consumed;
    11128. 

  11128.     guint       curr_len;
    11129. 

  11129. 

  11130.     curr_offset = offset;
    11131. 

  11131.     curr_len = len;
    11132. 

  11132. 

  11133.     ELEM_MAND_TV(ANSI_A_E_CIC, "");
    11134. 

  11134. 

  11135.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11136. 

  11136. }
    11137. 

  11137. 

  11138. /*
    11139. 

  11139.  * IOS 6.1.6.6
    11140. 

  11140.  */
    11141. 

  11141. static void
    11142. 

  11142. bsmap_reset(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11143. 

  11143. {
    11144. 

  11144.     guint32     curr_offset;
    11145. 

  11145.     guint32     consumed;
    11146. 

  11146.     guint       curr_len;
    11147. 

  11147. 

  11148.     curr_offset = offset;
    11149. 

  11149.     curr_len = len;
    11150. 

  11150. 

  11151.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    11152. 

  11152. 

  11153.     ELEM_OPT_TLV(ANSI_A_E_SW_VER, "");
    11154. 

  11154. 

  11155.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11156. 

  11156. }
    11157. 

  11157. 

  11158. /*
    11159. 

  11159.  * IOS 6.1.6.7
    11160. 

  11160.  */
    11161. 

  11161. static void
    11162. 

  11162. bsmap_reset_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11163. 

  11163. {
    11164. 

  11164.     guint32     curr_offset;
    11165. 

  11165.     guint32     consumed;
    11166. 

  11166.     guint       curr_len;
    11167. 

  11167. 

  11168.     curr_offset = offset;
    11169. 

  11169.     curr_len = len;
    11170. 

  11170. 

  11171.     ELEM_OPT_TLV(ANSI_A_E_SW_VER, "");
    11172. 

  11172. 

  11173.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11174. 

  11174. }
    11175. 

  11175. 

  11176. /*
    11177. 

  11177.  * IOS 6.1.6.8
    11178. 

  11178.  */
    11179. 

  11179. static void
    11180. 

  11180. bsmap_reset_cct(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11181. 

  11181. {
    11182. 

  11182.     guint32     curr_offset;
    11183. 

  11183.     guint32     consumed;
    11184. 

  11184.     guint       curr_len;
    11185. 

  11185. 

  11186.     curr_offset = offset;
    11187. 

  11187.     curr_len = len;
    11188. 

  11188. 

  11189.     ELEM_MAND_TV(ANSI_A_E_CIC, "");
    11190. 

  11190. 

  11191.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    11192. 

  11192. 

  11193.     ELEM_OPT_TLV(ANSI_A_E_CCT_GROUP, "");
    11194. 

  11194. 

  11195.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11196. 

  11196. }
    11197. 

  11197. 

  11198. /*
    11199. 

  11199.  * IOS 6.1.6.9
    11200. 

  11200.  */
    11201. 

  11201. static void
    11202. 

  11202. bsmap_reset_cct_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11203. 

  11203. {
    11204. 

  11204.     guint32     curr_offset;
    11205. 

  11205.     guint32     consumed;
    11206. 

  11206.     guint       curr_len;
    11207. 

  11207. 

  11208.     curr_offset = offset;
    11209. 

  11209.     curr_len = len;
    11210. 

  11210. 

  11211.     ELEM_MAND_TV(ANSI_A_E_CIC, "");
    11212. 

  11212. 

  11213.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11214. 

  11214. }
    11215. 

  11215. 

  11216. /*
    11217. 

  11217.  * IOS 6.1.6.10
    11218. 

  11218.  */
    11219. 

  11219. static void
    11220. 

  11220. bsmap_xmode_req(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11221. 

  11221. {
    11222. 

  11222.     guint32     curr_offset;
    11223. 

  11223.     guint32     consumed;
    11224. 

  11224.     guint       curr_len;
    11225. 

  11225. 

  11226.     curr_offset = offset;
    11227. 

  11227.     curr_len = len;
    11228. 

  11228. 

  11229.     ELEM_MAND_TLV(ANSI_A_E_XMODE, "");
    11230. 

  11230. 

  11231.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11232. 

  11232. }
    11233. 

  11233. 

  11234. /*
    11235. 

  11235.  * IOS 6.1.6.11
    11236. 

  11236.  */
    11237. 

  11237. static void
    11238. 

  11238. bsmap_xmode_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11239. 

  11239. {
    11240. 

  11240.     guint32     curr_offset;
    11241. 

  11241.     guint32     consumed;
    11242. 

  11242.     guint       curr_len;
    11243. 

  11243. 

  11244.     curr_offset = offset;
    11245. 

  11245.     curr_len = len;
    11246. 

  11246. 

  11247.     ELEM_MAND_TLV(ANSI_A_E_CAUSE, "");
    11248. 

  11248. 

  11249.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11250. 

  11250. }
    11251. 

  11251. 

  11252. /*
    11253. 

  11253.  * IOS 6.1.7.1
    11254. 

  11254.  */
    11255. 

  11255. static void
    11256. 

  11256. bsmap_adds_page(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11257. 

  11257. {
    11258. 

  11258.     guint32     curr_offset;
    11259. 

  11259.     guint32     consumed;
    11260. 

  11260.     guint       curr_len;
    11261. 

  11261. 

  11262.     curr_offset = offset;
    11263. 

  11263.     curr_len = len;
    11264. 

  11264. 

  11265.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    11266. 

  11266. 

  11267.     ELEM_MAND_TLV(ANSI_A_E_ADDS_USER_PART, "");
    11268. 

  11268. 

  11269.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    11270. 

  11270. 

  11271.     ELEM_OPT_TLV(ANSI_A_E_CELL_ID_LIST, "");
    11272. 

  11272. 

  11273.     ELEM_OPT_TV(ANSI_A_E_SCI, "");
    11274. 

  11274. 

  11275.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    11276. 

  11276. 

  11277.     ELEM_OPT_TLV(ANSI_A_E_P_REV, "");
    11278. 

  11278. 

  11279.     ELEM_OPT_TLV(ANSI_A_E_MS_DES_FREQ, "");
    11280. 

  11280. 

  11281.     ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    11282. 

  11282. 

  11283.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11284. 

  11284. }
    11285. 

  11285. 

  11286. /*
    11287. 

  11287.  * IOS 6.1.7.2
    11288. 

  11288.  */
    11289. 

  11289. static void
    11290. 

  11290. bsmap_adds_transfer(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11291. 

  11291. {
    11292. 

  11292.     guint32     curr_offset;
    11293. 

  11293.     guint32     consumed;
    11294. 

  11294.     guint       curr_len;
    11295. 

  11295. 

  11296.     curr_offset = offset;
    11297. 

  11297.     curr_len = len;
    11298. 

  11298. 

  11299.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    11300. 

  11300. 

  11301.     ELEM_MAND_TLV(ANSI_A_E_ADDS_USER_PART, "");
    11302. 

  11302. 

  11303.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    11304. 

  11304. 

  11305.     ELEM_OPT_TLV(ANSI_A_E_AUTH_RESP_PARAM, "");
    11306. 

  11306. 

  11307.     ELEM_OPT_TV(ANSI_A_E_AUTH_CNF_PARAM, "");
    11308. 

  11308. 

  11309.     ELEM_OPT_TV(ANSI_A_E_AUTH_PARAM_COUNT, "");
    11310. 

  11310. 

  11311.     ELEM_OPT_TLV(ANSI_A_E_AUTH_CHLG_PARAM, "");
    11312. 

  11312. 

  11313.     ELEM_OPT_TLV(ANSI_A_E_AUTH_EVENT, "");
    11314. 

  11314. 

  11315.     ELEM_OPT_TLV(ANSI_A_E_CELL_ID, "");
    11316. 

  11316. 

  11317.     ELEM_OPT_TLV(ANSI_A_E_CDMA_SOWD, "");
    11318. 

  11318. 

  11319.     ELEM_OPT_TLV(ANSI_A_E_AUTH_DATA, "");
    11320. 

  11320. 

  11321.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    11322. 

  11322. 

  11323.     ELEM_OPT_TLV(ANSI_A_E_CM_INFO_TYPE_2, "");
    11324. 

  11324. 

  11325.     ELEM_OPT_TV(ANSI_A_E_SCI, "");
    11326. 

  11326. 

  11327.     ELEM_OPT_TV(ANSI_A_E_SO, "");
    11328. 

  11328. 

  11329.     ELEM_OPT_TLV(ANSI_A_E_UZ_ID, "");
    11330. 

  11330. 

  11331.     ELEM_OPT_TLV(ANSI_A_E_IS2000_MOB_CAP, "");
    11332. 

  11332. 

  11333.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    11334. 

  11334. 

  11335.     ELEM_OPT_TLV(ANSI_A_E_MOB_SUB_INFO, "");
    11336. 

  11336. 

  11337.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11338. 

  11338. }
    11339. 

  11339. 

  11340. /*
    11341. 

  11341.  * IOS 5 3.6.4
    11342. 

  11342.  */
    11343. 

  11343. static void
    11344. 

  11344. bsmap_adds_transfer_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11345. 

  11345. {
    11346. 

  11346.     guint32     curr_offset;
    11347. 

  11347.     guint32     consumed;
    11348. 

  11348.     guint       curr_len;
    11349. 

  11349. 

  11350.     curr_offset = offset;
    11351. 

  11351.     curr_len = len;
    11352. 

  11352. 

  11353.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    11354. 

  11354. 

  11355.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    11356. 

  11356. 

  11357.     ELEM_OPT_TLV(ANSI_A_E_CAUSE, "");
    11358. 

  11358. 

  11359.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11360. 

  11360. }
    11361. 

  11361. 

  11362. /*
    11363. 

  11363.  * IOS 6.1.7.3
    11364. 

  11364.  */
    11365. 

  11365. static void
    11366. 

  11366. dtap_adds_deliver(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11367. 

  11367. {
    11368. 

  11368.     guint32     curr_offset;
    11369. 

  11369.     guint32     consumed;
    11370. 

  11370.     guint       curr_len;
    11371. 

  11371. 

  11372.     curr_offset = offset;
    11373. 

  11373.     curr_len = len;
    11374. 

  11374. 

  11375.     ELEM_MAND_LV(ANSI_A_E_ADDS_USER_PART, "");
    11376. 

  11376. 

  11377.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    11378. 

  11378. 

  11379.     ELEM_OPT_TLV(ANSI_A_E_CDMA_SOWD, "");
    11380. 

  11380. 

  11381.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11382. 

  11382. }
    11383. 

  11383. 

  11384. /*
    11385. 

  11385.  * IOS 6.1.7.4
    11386. 

  11386.  */
    11387. 

  11387. static void
    11388. 

  11388. bsmap_adds_page_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11389. 

  11389. {
    11390. 

  11390.     guint32     curr_offset;
    11391. 

  11391.     guint32     consumed;
    11392. 

  11392.     guint       curr_len;
    11393. 

  11393. 

  11394.     curr_offset = offset;
    11395. 

  11395.     curr_len = len;
    11396. 

  11396. 

  11397.     ELEM_MAND_TLV(ANSI_A_E_MID, "");
    11398. 

  11398. 

  11399.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    11400. 

  11400. 

  11401.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    11402. 

  11402. 

  11403.     ELEM_OPT_TLV(ANSI_A_E_CAUSE, "");
    11404. 

  11404. 

  11405.     ELEM_OPT_TLV(ANSI_A_E_CELL_ID, "");
    11406. 

  11406. 

  11407.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    11408. 

  11408. 

  11409.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11410. 

  11410. }
    11411. 

  11411. 

  11412. /*
    11413. 

  11413.  * IOS 6.1.7.5
    11414. 

  11414.  */
    11415. 

  11415. static void
    11416. 

  11416. dtap_adds_deliver_ack(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11417. 

  11417. {
    11418. 

  11418.     guint32     curr_offset;
    11419. 

  11419.     guint32     consumed;
    11420. 

  11420.     guint       curr_len;
    11421. 

  11421. 

  11422.     curr_offset = offset;
    11423. 

  11423.     curr_len = len;
    11424. 

  11424. 

  11425.     ELEM_OPT_TV(ANSI_A_E_TAG, "");
    11426. 

  11426. 

  11427.     ELEM_OPT_TLV(ANSI_A_E_CAUSE, "");
    11428. 

  11428. 

  11429.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11430. 

  11430. }
    11431. 

  11431. 

  11432. /*
    11433. 

  11433.  * IOS 6.1.8.1
    11434. 

  11434.  */
    11435. 

  11435. static void
    11436. 

  11436. bsmap_rejection(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11437. 

  11437. {
    11438. 

  11438.     guint32     curr_offset;
    11439. 

  11439.     guint32     consumed;
    11440. 

  11440.     guint       curr_len;
    11441. 

  11441. 

  11442.     curr_offset = offset;
    11443. 

  11443.     curr_len = len;
    11444. 

  11444. 

  11445.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    11446. 

  11446. 

  11447.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    11448. 

  11448. 

  11449.     ELEM_OPT_TLV(ANSI_A_E_IS2000_CAUSE, "");
    11450. 

  11450. 

  11451.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    11452. 

  11452. 

  11453.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11454. 

  11454. }
    11455. 

  11455. 

  11456. static void
    11457. 

  11457. dtap_rejection(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11458. 

  11458. {
    11459. 

  11459.     guint32     curr_offset;
    11460. 

  11460.     guint32     consumed;
    11461. 

  11461.     guint       curr_len;
    11462. 

  11462. 

  11463.     curr_offset = offset;
    11464. 

  11464.     curr_len = len;
    11465. 

  11465. 

  11466.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    11467. 

  11467. 

  11468.     ELEM_OPT_TLV(ANSI_A_E_IS2000_CAUSE, "");
    11469. 

  11469. 

  11470.     ELEM_OPT_TLV(ANSI_A_E_SOCI, "");
    11471. 

  11471. 

  11472.     ELEM_OPT_TLV(ANSI_A_E_MID, "");
    11473. 

  11473. 

  11474.     EXTRANEOUS_DATA_CHECK(curr_len, 0);
    11475. 

  11475. }
    11476. 

  11476. 

  11477. #define ANSI_A_IOS401_BSMAP_NUM_MSG (sizeof(ansi_a_ios401_bsmap_strings)/sizeof(ext_value_string_t))
    11478. 

  11478. #define ANSI_A_IOS501_BSMAP_NUM_MSG (sizeof(ansi_a_ios501_bsmap_strings)/sizeof(ext_value_string_t))
    11479. 

  11479. static gint ett_bsmap_msg[MAX(ANSI_A_IOS401_BSMAP_NUM_MSG, ANSI_A_IOS501_BSMAP_NUM_MSG)];
    11480. 

  11480. static void (*bsmap_msg_fcn[])(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len) =
    11481. 

  11481. {
    11482. 

  11482.     bsmap_add_srvc_noti,            /* Additional Service Notification */
    11483. 

  11483.     bsmap_adds_page,                /* ADDS Page */
    11484. 

  11484.     bsmap_adds_page_ack,            /* ADDS Page Ack */
    11485. 

  11485.     bsmap_adds_transfer,            /* ADDS Transfer */
    11486. 

  11486.     bsmap_adds_transfer_ack,        /* ADDS Transfer Ack */
    11487. 

  11487.     bsmap_ass_complete,             /* Assignment Complete */
    11488. 

  11488.     bsmap_ass_failure,              /* Assignment Failure */
    11489. 

  11489.     bsmap_ass_req,                  /* Assignment Request */
    11490. 

  11490.     bsmap_auth_req,                 /* Authentication Request */
    11491. 

  11491.     bsmap_auth_resp,                /* Authentication Response */
    11492. 

  11492.     NULL /* no BSMAP definition */, /* Base Station Challenge */
    11493. 

  11493.     NULL /* no BSMAP definition */, /* Base Station Challenge Response */
    11494. 

  11494.     bsmap_block,                    /* Block */
    11495. 

  11495.     bsmap_block_ack,                /* Block Acknowledge */
    11496. 

  11496.     bsmap_bs_srvc_req,              /* BS Service Request */
    11497. 

  11497.     bsmap_bs_srvc_resp,             /* BS Service Response */
    11498. 

  11498.     bsmap_clr_command,              /* Clear Command */
    11499. 

  11499.     bsmap_clr_complete,             /* Clear Complete */
    11500. 

  11500.     bsmap_clr_req,                  /* Clear Request */
    11501. 

  11501.     bsmap_cl3_info,                 /* Complete Layer 3 Information */
    11502. 

  11502.     bsmap_feat_noti,                /* Feature Notification */
    11503. 

  11503.     bsmap_feat_noti_ack,            /* Feature Notification Ack */
    11504. 

  11504.     bsmap_ho_command,               /* Handoff Command */
    11505. 

  11505.     NULL /* no associated data */,  /* Handoff Commenced */
    11506. 

  11506.     bsmap_ho_complete,              /* Handoff Complete */
    11507. 

  11507.     bsmap_ho_failure,               /* Handoff Failure */
    11508. 

  11508.     bsmap_ho_performed,             /* Handoff Performed */
    11509. 

  11509.     bsmap_ho_req,                   /* Handoff Request */
    11510. 

  11510.     bsmap_ho_req_ack,               /* Handoff Request Acknowledge */
    11511. 

  11511.     bsmap_ho_reqd,                  /* Handoff Required */
    11512. 

  11512.     bsmap_ho_reqd_rej,              /* Handoff Required Reject */
    11513. 

  11513.     bsmap_paca_command,             /* PACA Command */
    11514. 

  11514.     bsmap_paca_command_ack,         /* PACA Command Ack */
    11515. 

  11515.     bsmap_paca_update,              /* PACA Update */
    11516. 

  11516.     bsmap_paca_update_ack,          /* PACA Update Ack */
    11517. 

  11517.     bsmap_page_req,                 /* Paging Request */
    11518. 

  11518.     bsmap_priv_mode_command,        /* Privacy Mode Command */
    11519. 

  11519.     bsmap_priv_mode_complete,       /* Privacy Mode Complete */
    11520. 

  11520.     bsmap_rm_pos_req,               /* Radio Measurements for Position Request */
    11521. 

  11521.     bsmap_rm_pos_resp,              /* Radio Measurements for Position Response */
    11522. 

  11522.     bsmap_rejection,                /* Rejection */
    11523. 

  11523.     bsmap_reg_req,                  /* Registration Request */
    11524. 

  11524.     bsmap_reset,                    /* Reset */
    11525. 

  11525.     bsmap_reset_ack,                /* Reset Acknowledge */
    11526. 

  11526.     bsmap_reset_cct,                /* Reset Circuit */
    11527. 

  11527.     bsmap_reset_cct_ack,            /* Reset Circuit Acknowledge */
    11528. 

  11528.     NULL /* no BSMAP definition */, /* SSD Update Request */
    11529. 

  11529.     NULL /* no BSMAP definition */, /* SSD Update Response */
    11530. 

  11530.     bsmap_status_req,               /* Status Request */
    11531. 

  11531.     bsmap_status_resp,              /* Status Response */
    11532. 

  11532.     bsmap_xmode_ack,                /* Transcoder Control Acknowledge */
    11533. 

  11533.     bsmap_xmode_req,                /* Transcoder Control Request */
    11534. 

  11534.     bsmap_unblock,                  /* Unblock */
    11535. 

  11535.     bsmap_unblock_ack,              /* Unblock Acknowledge */
    11536. 

  11536.     bsmap_user_zone_reject,         /* User Zone Reject */
    11537. 

  11537.     bsmap_user_zone_update,         /* User Zone Update */
    11538. 

  11538.     bsmap_bearer_upd_req,           /* Bearer Update Request *//* IOS 5.0.1 */
    11539. 

  11539.     bsmap_bearer_upd_resp,          /* Bearer Update Response *//* IOS 5.0.1 */
    11540. 

  11540.     bsmap_bearer_upd_reqd,          /* Bearer Update Required *//* IOS 5.0.1 */
    11541. 

  11541.     bsmap_ms_reg_noti,              /* Mobile Station Registered Notification *//* IOS 5.0.1 */
    11542. 

  11542.     bsmap_bs_auth_req,              /* BS Authentication Request *//* IOS 5.0.1 */
    11543. 

  11543.     bsmap_bs_auth_req_ack,          /* BS Authentication Request Ack *//* IOS 5.0.1 */
    11544. 

  11544.     NULL,        /* NONE */
    11545. 

  11545. };
    11546. 

  11546. 

  11547. #define ANSI_A_IOS401_DTAP_NUM_MSG (sizeof(ansi_a_ios401_dtap_strings)/sizeof(ext_value_string_t))
    11548. 

  11548. #define ANSI_A_IOS501_DTAP_NUM_MSG (sizeof(ansi_a_ios501_dtap_strings)/sizeof(ext_value_string_t))
    11549. 

  11549. static gint ett_dtap_msg[MAX(ANSI_A_IOS401_DTAP_NUM_MSG, ANSI_A_IOS501_DTAP_NUM_MSG)];
    11550. 

  11550. static void (*dtap_msg_fcn[])(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 offset, guint len) =
    11551. 

  11551. {
    11552. 

  11552.     dtap_add_srvc_req,              /* Additional Service Request */
    11553. 

  11553.     dtap_adds_deliver,              /* ADDS Deliver */
    11554. 

  11554.     dtap_adds_deliver_ack,          /* ADDS Deliver Ack */
    11555. 

  11555.     dtap_alert_with_info,           /* Alert With Information */
    11556. 

  11556.     dtap_auth_req,                  /* Authentication Request */
    11557. 

  11557.     dtap_auth_resp,                 /* Authentication Response */
    11558. 

  11558.     dtap_bs_challenge,              /* Base Station Challenge */
    11559. 

  11559.     dtap_bs_challenge_resp,         /* Base Station Challenge Response */
    11560. 

  11560.     dtap_cm_srvc_req,               /* CM Service Request */
    11561. 

  11561.     dtap_cm_srvc_req_cont,          /* CM Service Request Continuation */
    11562. 

  11562.     dtap_connect,                   /* Connect */
    11563. 

  11563.     dtap_flash_with_info,           /* Flash with Information */
    11564. 

  11564.     dtap_flash_with_info_ack,       /* Flash with Information Ack */
    11565. 

  11565.     dtap_lu_accept,                 /* Location Updating Accept */
    11566. 

  11566.     dtap_lu_reject,                 /* Location Updating Reject */
    11567. 

  11567.     dtap_lu_req,                    /* Location Updating Request */
    11568. 

  11568.     dtap_page_resp,                 /* Paging Response */
    11569. 

  11569.     NULL /* no associated data */,  /* Parameter Update Confirm */
    11570. 

  11570.     NULL /* no associated data */,  /* Parameter Update Request */
    11571. 

  11571.     dtap_rejection,                 /* Rejection */
    11572. 

  11572.     dtap_progress,                  /* Progress */
    11573. 

  11573.     dtap_srvc_redirection,          /* Service Redirection */
    11574. 

  11574.     dtap_srvc_release,              /* Service Release */
    11575. 

  11575.     dtap_srvc_release_complete,     /* Service Release Complete */
    11576. 

  11576.     dtap_ssd_update_req,            /* SSD Update Request */
    11577. 

  11577.     dtap_ssd_update_resp,           /* SSD Update Response */
    11578. 

  11578.     dtap_status_req,                /* Status Request */
    11579. 

  11579.     dtap_status_resp,               /* Status Response */
    11580. 

  11580.     dtap_user_zone_reject,          /* User Zone Reject */
    11581. 

  11581.     dtap_user_zone_update,          /* User Zone Update */
    11582. 

  11582.     dtap_user_zone_update_req,      /* User Zone Update Request */
    11583. 

  11583.     NULL,       /* NONE */
    11584. 

  11584. };
    11585. 

  11585. 

  11586. /* Utillity function to dissect CDMA200 A1 elements in ANSI MAP messages */
    11587. 

  11587. void
    11588. 

  11588. dissect_cdma2000_a1_elements(tvbuff_t *tvb, _U_ packet_info *pinfo, proto_tree *tree, guint32 offset, guint len)
    11589. 

  11589. {
    11590. 

  11590.     guint32     curr_offset;
    11591. 

  11591.     guint32     consumed;
    11592. 

  11592.     guint       curr_len;
    11593. 

  11593.     unsigned    idx;
    11594. 

  11594.     guint8      oct;
    11595. 

  11595. 

  11596.     curr_offset = offset;
    11597. 

  11597.     curr_len = len;
    11598. 

  11598. 

  11599.     /*
    11600. 

  11600.      * require at least 2 octets for T(ype) and L(ength)
    11601. 

  11601.      */
    11602. 

  11602.     while (curr_len > 1)
    11603. 

  11603.     {
    11604. 

  11604.         /*
    11605. 

  11605.          * peeking at T(ype)
    11606. 

  11606.          */
    11607. 

  11607.         oct = tvb_get_guint8(tvb, curr_offset);
    11608. 

  11608. 

  11609.         for (idx=0; idx < (unsigned)ansi_a_elem_1_max; idx++)
    11610. 

  11610.         {
    11611. 

  11611.             if (oct == (guint8) ansi_a_elem_1_strings[idx].value)
    11612. 

  11612.             {
    11613. 

  11613.                 ELEM_OPT_TLV((elem_idx_t)idx, "");
    11614. 

  11614.                 break;
    11615. 

  11615.             }
    11616. 

  11616.         }
    11617. 

  11617. 

  11618.         if (idx == (elem_idx_t)ansi_a_elem_1_max)
    11619. 

  11619.         {
    11620. 

  11620.             /*
    11621. 

  11621.              * didn't recognize the T(ype)
    11622. 

  11622.              * assuming it is in TLV form, step over
    11623. 

  11623.              */
    11624. 

  11624.             consumed = 2 + tvb_get_guint8(tvb, curr_offset + 1);
    11625. 

  11625.             curr_offset += consumed;
    11626. 

  11626.             curr_len -= consumed;
    11627. 

  11627.         }
    11628. 

  11628.     }
    11629. 

  11629. 

  11630.     EXTRANEOUS_DATA_CHECK_EXPERT(curr_len, 0);
    11631. 

  11631. }
    11632. 

  11632. 

  11633. /* GENERIC DISSECTOR FUNCTIONS */
    11634. 

  11634. 

  11635. static void
    11636. 

  11636. dissect_bsmap_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean from_sip)
    11637. 

  11637. {
    11638. 

  11638.     static ansi_a_tap_rec_t     tap_rec[16];
    11639. 

  11639.     static ansi_a_tap_rec_t     *tap_p;
    11640. 

  11640.     static int                  tap_current=0;
    11641. 

  11641.     guint8                      oct;
    11642. 

  11642.     guint32                     offset, saved_offset;
    11643. 

  11643.     guint32                     len;
    11644. 

  11644.     gint                        dec_idx;
    11645. 

  11645.     proto_item                  *bsmap_item = NULL;
    11646. 

  11646.     proto_tree                  *bsmap_tree = NULL;
    11647. 

  11647.     const gchar                 *msg_str;
    11648. 

  11648.     void                        *pd_save;
    11649. 

  11649. 

  11650. 

  11651.     col_append_str(pinfo->cinfo, COL_INFO, "(BSMAP) ");
    11652. 

  11652. 

  11653.     /*
    11654. 

  11654.      * set tap record pointer
    11655. 

  11655.      */
    11656. 

  11656.     tap_current++;
    11657. 

  11657.     if (tap_current == array_length(tap_rec))
    11658. 

  11658.     {
    11659. 

  11659.         tap_current = 0;
    11660. 

  11660.     }
    11661. 

  11661.     tap_p = &tap_rec[tap_current];
    11662. 

  11662. 

  11663. 

  11664.     offset = 0;
    11665. 

  11665.     saved_offset = offset;
    11666. 

  11666. 

  11667.     g_tree = tree;
    11668. 

  11668. 

  11669.     len = tvb_length(tvb);
    11670. 

  11670. 

  11671.     /*
    11672. 

  11672.      * add BSMAP message name
    11673. 

  11673.      */
    11674. 

  11674.     oct = tvb_get_guint8(tvb, offset++);
    11675. 

  11675. 

  11676.     msg_str = my_try_val_to_str_idx((guint32) oct, ansi_a_bsmap_strings, &dec_idx);
    11677. 

  11677. 

  11678.     /*
    11679. 

  11679.      * create the a protocol tree
    11680. 

  11680.      */
    11681. 

  11681.     if (msg_str == NULL)
    11682. 

  11682.     {
    11683. 

  11683.         bsmap_item =
    11684. 

  11684.             proto_tree_add_protocol_format(tree, proto_a_bsmap, tvb, 0, len,
    11685. 

  11685.                 "ANSI A-I/F BSMAP - Unknown BSMAP Message Type (%u)",
    11686. 

  11686.                 oct);
    11687. 

  11687. 

  11688.         bsmap_tree = proto_item_add_subtree(bsmap_item, ett_bsmap);
    11689. 

  11689.     }
    11690. 

  11690.     else
    11691. 

  11691.     {
    11692. 

  11692.         bsmap_item =
    11693. 

  11693.             proto_tree_add_protocol_format(tree, proto_a_bsmap, tvb, 0, -1,
    11694. 

  11694.                 "ANSI A-I/F BSMAP - %s",
    11695. 

  11695.                 msg_str);
    11696. 

  11696. 

  11697.         bsmap_tree = proto_item_add_subtree(bsmap_item, ett_bsmap_msg[dec_idx]);
    11698. 

  11698. 

  11699.         col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", msg_str);
    11700. 

  11700.     }
    11701. 

  11701. 

  11702.     /*
    11703. 

  11703.      * add BSMAP message name
    11704. 

  11704.      */
    11705. 

  11705.     proto_tree_add_uint_format(bsmap_tree, hf_ansi_a_bsmap_msgtype,
    11706. 

  11706.         tvb, saved_offset, 1, oct, "Message Type");
    11707. 

  11707. 

  11708.     tap_p->pdu_type = BSSAP_PDU_TYPE_BSMAP;
    11709. 

  11709.     tap_p->message_type = oct;
    11710. 

  11710. 

  11711.     tap_queue_packet(ansi_a_tap, pinfo, tap_p);
    11712. 

  11712. 

  11713.     if (msg_str == NULL) return;
    11714. 

  11714. 

  11715.     if ((len - offset) <= 0) return;
    11716. 

  11716. 

  11717.     a_meid_configured = FALSE;
    11718. 

  11718.     pd_save = pinfo->private_data;
    11719. 

  11719.     pinfo->private_data = GUINT_TO_POINTER((guint)from_sip);
    11720. 

  11720. 

  11721.     /*
    11722. 

  11722.      * decode elements
    11723. 

  11723.      */
    11724. 

  11724.     if (bsmap_msg_fcn[dec_idx] == NULL)
    11725. 

  11725.     {
    11726. 

  11726.         proto_tree_add_text(bsmap_tree,
    11727. 

  11727.             tvb, offset, len - offset,
    11728. 

  11728.             "Message Elements");
    11729. 

  11729.     }
    11730. 

  11730.     else
    11731. 

  11731.     {
    11732. 

  11732.         (*bsmap_msg_fcn[dec_idx])(tvb, pinfo, bsmap_tree, offset, len - offset);
    11733. 

  11733.     }
    11734. 

  11734. 

  11735.     pinfo->private_data = pd_save;
    11736. 

  11736. }
    11737. 

  11737. 

  11738. static void
    11739. 

  11739. dissect_bsmap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
    11740. 

  11740. {
    11741. 

  11741.     dissect_bsmap_common(tvb, pinfo, tree, FALSE);
    11742. 

  11742. }
    11743. 

  11743. 

  11744. static void
    11745. 

  11745. dissect_dtap_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean from_sip)
    11746. 

  11746. {
    11747. 

  11747.     static ansi_a_tap_rec_t     tap_rec[16];
    11748. 

  11748.     static ansi_a_tap_rec_t     *tap_p;
    11749. 

  11749.     static int                  tap_current=0;
    11750. 

  11750.     guint8                      oct;
    11751. 

  11751.     guint32                     offset, saved_offset;
    11752. 

  11752.     guint32                     len;
    11753. 

  11753.     guint32                     oct_1=0, oct_2=0;
    11754. 

  11754.     gint                        dec_idx;
    11755. 

  11755.     proto_item                  *dtap_item = NULL;
    11756. 

  11756.     proto_tree                  *dtap_tree = NULL;
    11757. 

  11757.     proto_item                  *oct_1_item = NULL;
    11758. 

  11758.     proto_tree                  *oct_1_tree = NULL;
    11759. 

  11759.     const gchar                 *msg_str;
    11760. 

  11760.     const gchar                 *str;
    11761. 

  11761.     void                        *pd_save;
    11762. 

  11762. 

  11763.     len = tvb_length(tvb);
    11764. 

  11764. 

  11765.     if ((len < 3) && !from_sip)
    11766. 

  11766.     {
    11767. 

  11767.         /*
    11768. 

  11768.          * too short to be DTAP
    11769. 

  11769.          */
    11770. 

  11770.         call_dissector(data_handle, tvb, pinfo, tree);
    11771. 

  11771.         return;
    11772. 

  11772.     }
    11773. 

  11773. 

  11774.     col_append_str(pinfo->cinfo, COL_INFO, "(DTAP) ");
    11775. 

  11775. 

  11776.     /*
    11777. 

  11777.      * set tap record pointer
    11778. 

  11778.      */
    11779. 

  11779.     tap_current++;
    11780. 

  11780.     if (tap_current == array_length(tap_rec))
    11781. 

  11781.     {
    11782. 

  11782.         tap_current = 0;
    11783. 

  11783.     }
    11784. 

  11784.     tap_p = &tap_rec[tap_current];
    11785. 

  11785. 

  11786. 

  11787.     offset = 0;
    11788. 

  11788.     saved_offset = offset;
    11789. 

  11789. 

  11790.     g_tree = tree;
    11791. 

  11791. 

  11792.     /*
    11793. 

  11793.      * get protocol discriminator
    11794. 

  11794.      */
    11795. 

  11795.     if (!from_sip) {
    11796. 

  11796.         oct_1 = tvb_get_guint8(tvb, offset++);
    11797. 

  11797.         oct_2 = tvb_get_guint8(tvb, offset++);
    11798. 

  11798.     }
    11799. 

  11799. 

  11800.     /*
    11801. 

  11801.      * add DTAP message name
    11802. 

  11802.      */
    11803. 

  11803.     oct = tvb_get_guint8(tvb, offset++);
    11804. 

  11804. 

  11805.     msg_str = my_try_val_to_str_idx((guint32) oct, ansi_a_dtap_strings, &dec_idx);
    11806. 

  11806. 

  11807.     /*
    11808. 

  11808.      * create the a protocol tree
    11809. 

  11809.      */
    11810. 

  11810.     if (msg_str == NULL)
    11811. 

  11811.     {
    11812. 

  11812.         dtap_item =
    11813. 

  11813.             proto_tree_add_protocol_format(tree, proto_a_dtap, tvb, 0, len,
    11814. 

  11814.                 "ANSI A-I/F DTAP - Unknown DTAP Message Type (%u)",
    11815. 

  11815.                 oct);
    11816. 

  11816. 

  11817.         dtap_tree = proto_item_add_subtree(dtap_item, ett_dtap);
    11818. 

  11818.     }
    11819. 

  11819.     else
    11820. 

  11820.     {
    11821. 

  11821.         dtap_item =
    11822. 

  11822.             proto_tree_add_protocol_format(tree, proto_a_dtap, tvb, 0, -1,
    11823. 

  11823.                 "ANSI A-I/F DTAP - %s",
    11824. 

  11824.                 msg_str);
    11825. 

  11825. 

  11826.         dtap_tree = proto_item_add_subtree(dtap_item, ett_dtap_msg[dec_idx]);
    11827. 

  11827. 

  11828.         col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", msg_str);
    11829. 

  11829.     }
    11830. 

  11830. 

  11831.     if (!from_sip) {
    11832. 

  11832.         /*
    11833. 

  11833.          * octet 1
    11834. 

  11834.          */
    11835. 

  11835.         switch (oct_1 & 0x0f)
    11836. 

  11836.         {
    11837. 

  11837.         case 3: str = "Call Control, call related SS"; break;
    11838. 

  11838.         case 5: str = "Mobility Management"; break;
    11839. 

  11839.         case 6: str = "Radio Resource Management"; break;
    11840. 

  11840.         case 9: str = "Facility Management"; break;
    11841. 

  11841.         case 11: str = "Other Signaling Procedures"; break;
    11842. 

  11842.         case 15: str = "Reserved for tests"; break;
    11843. 

  11843.         default:
    11844. 

  11844.             str = "Unknown";
    11845. 

  11845.             break;
    11846. 

  11846.         }
    11847. 

  11847. 

  11848.         oct_1_item =
    11849. 

  11849.             proto_tree_add_text(dtap_tree,
    11850. 

  11850.                 tvb, 0, 1,
    11851. 

  11851.                 "Protocol Discriminator: %s",
    11852. 

  11852.                 str);
    11853. 

  11853. 

  11854.         oct_1_tree = proto_item_add_subtree(oct_1_item, ett_dtap_oct_1);
    11855. 

  11855. 

  11856.         other_decode_bitfield_value(a_bigbuf, oct_1, 0xf0, 8);
    11857. 

  11857.         proto_tree_add_text(oct_1_tree,
    11858. 

  11858.             tvb, 0, 1,
    11859. 

  11859.             "%s :  Reserved",
    11860. 

  11860.             a_bigbuf);
    11861. 

  11861. 

  11862.         other_decode_bitfield_value(a_bigbuf, oct_1, 0x0f, 8);
    11863. 

  11863.         proto_tree_add_text(oct_1_tree,
    11864. 

  11864.             tvb, 0, 1,
    11865. 

  11865.             "%s :  Protocol Discriminator: %u",
    11866. 

  11866.             a_bigbuf,
    11867. 

  11867.             oct_1 & 0x0f);
    11868. 

  11868. 

  11869.         /*
    11870. 

  11870.          * octet 2
    11871. 

  11871.          */
    11872. 

  11872.         switch (global_a_variant)
    11873. 

  11873.         {
    11874. 

  11874.         case A_VARIANT_IS634:
    11875. 

  11875.             other_decode_bitfield_value(a_bigbuf, oct_2, 0x80, 8);
    11876. 

  11876.             proto_tree_add_text(dtap_tree,
    11877. 

  11877.                 tvb, 1, 1,
    11878. 

  11878.                 "%s :  Transaction Identifier (TI) Flag: %s",
    11879. 

  11879.                 a_bigbuf,
    11880. 

  11880.                 ((oct_2 & 0x80) ?  "allocated by receiver" : "allocated by sender"));
    11881. 

  11881. 

  11882.             other_decode_bitfield_value(a_bigbuf, oct_2, 0x70, 8);
    11883. 

  11883.             proto_tree_add_text(dtap_tree,
    11884. 

  11884.                 tvb, 1, 1,
    11885. 

  11885.                 "%s :  Transaction Identifier (TI): %u",
    11886. 

  11886.                 a_bigbuf,
    11887. 

  11887.                 (oct_2 & 0x70) >> 4);
    11888. 

  11888. 

  11889.             other_decode_bitfield_value(a_bigbuf, oct_2, 0x0f, 8);
    11890. 

  11890.             proto_tree_add_text(dtap_tree,
    11891. 

  11891.                 tvb, 1, 1,
    11892. 

  11892.                 "%s :  Reserved",
    11893. 

  11893.                 a_bigbuf);
    11894. 

  11894.             break;
    11895. 

  11895. 

  11896.         default:
    11897. 

  11897.             proto_tree_add_text(dtap_tree,
    11898. 

  11898.                 tvb, 1, 1,
    11899. 

  11899.                 "Reserved Octet");
    11900. 

  11900.             break;
    11901. 

  11901.         }
    11902. 

  11902.     }
    11903. 

  11903. 

  11904.     /*
    11905. 

  11905.      * add DTAP message name
    11906. 

  11906.      */
    11907. 

  11907.     proto_tree_add_uint_format(dtap_tree, hf_ansi_a_dtap_msgtype,
    11908. 

  11908.         tvb, saved_offset, 1, oct,
    11909. 

  11909.         "Message Type");
    11910. 

  11910. 

  11911.     tap_p->pdu_type = BSSAP_PDU_TYPE_DTAP;
    11912. 

  11912.     tap_p->message_type = oct;
    11913. 

  11913. 

  11914.     tap_queue_packet(ansi_a_tap, pinfo, tap_p);
    11915. 

  11915. 

  11916.     if (msg_str == NULL) return;
    11917. 

  11917. 

  11918.     if ((len - offset) <= 0) return;
    11919. 

  11919. 

  11920.     a_meid_configured = FALSE;
    11921. 

  11921.     pd_save = pinfo->private_data;
    11922. 

  11922.     pinfo->private_data = GUINT_TO_POINTER((guint)from_sip);
    11923. 

  11923. 

  11924.     /*
    11925. 

  11925.      * decode elements
    11926. 

  11926.      */
    11927. 

  11927.     if (dtap_msg_fcn[dec_idx] == NULL)
    11928. 

  11928.     {
    11929. 

  11929.         proto_tree_add_text(dtap_tree,
    11930. 

  11930.             tvb, offset, len - offset,
    11931. 

  11931.             "Message Elements");
    11932. 

  11932.     }
    11933. 

  11933.     else
    11934. 

  11934.     {
    11935. 

  11935.         (*dtap_msg_fcn[dec_idx])(tvb, pinfo, dtap_tree, offset, len - offset);
    11936. 

  11936.     }
    11937. 

  11937. 

  11938.     pinfo->private_data = pd_save;
    11939. 

  11939. }
    11940. 

  11940. 

  11941. static void
    11942. 

  11942. dissect_dtap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
    11943. 

  11943. {
    11944. 

  11944.     dissect_dtap_common(tvb, pinfo, tree, FALSE);
    11945. 

  11945. }
    11946. 

  11946. 

  11947. static void
    11948. 

  11948. dissect_sip_dtap_bsmap(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
    11949. 

  11949. {
    11950. 

  11950.     gint linelen, offset, next_offset, begin;
    11951. 

  11951.     guint8 *msg_type;
    11952. 

  11952.     tvbuff_t *ansi_a_tvb;
    11953. 

  11953.     gboolean is_dtap = TRUE;
    11954. 

  11954. 

  11955.     offset = 0;
    11956. 

  11956.     if ((linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, TRUE)) > 0) {
    11957. 

  11957.         if (linelen >= 2) {
    11958. 

  11958.             ansi_a_tvb = tvb_new_composite();
    11959. 

  11959.             msg_type = (guint8*)wmem_alloc(pinfo->pool, 1);
    11960. 

  11960.             msg_type[0] = (guint8)strtoul(tvb_get_ephemeral_string(tvb, offset, 2), NULL, 16);
    11961. 

  11961.             if ((begin = tvb_find_guint8(tvb, offset, linelen, '"')) > 0) {
    11962. 

  11962.                 if (tvb_get_guint8(tvb, begin + 1) == '1') {
    11963. 

  11963.                     is_dtap = FALSE;
    11964. 

  11964.                 }
    11965. 

  11965.             } else {
    11966. 

  11966.                 if (my_try_val_to_str_idx((guint32) msg_type[0], ansi_a_dtap_strings, &linelen) == NULL) {
    11967. 

  11967.                     is_dtap = FALSE;
    11968. 

  11968.                 }
    11969. 

  11969.             }
    11970. 

  11970.             tvb_composite_append(ansi_a_tvb, tvb_new_child_real_data(tvb, msg_type, 1, 1));
    11971. 

  11971.             offset = next_offset;
    11972. 

  11972.             while ((linelen = tvb_find_line_end(tvb, offset, -1, &next_offset, TRUE)) > 0) {
    11973. 

  11973.                 if ((begin = tvb_find_guint8(tvb, offset, linelen, '=')) > 0) {
    11974. 

  11974.                     begin++;
    11975. 

  11975.                     tvb_composite_append(ansi_a_tvb, base64_to_tvb(tvb, tvb_get_ephemeral_string(tvb, begin, offset + linelen - begin)));
    11976. 

  11976.                 }
    11977. 

  11977.                 offset = next_offset;
    11978. 

  11978.             }
    11979. 

  11979.             tvb_composite_finalize(ansi_a_tvb);
    11980. 

  11980.             if (is_dtap) {
    11981. 

  11981.                 add_new_data_source(pinfo, ansi_a_tvb, "ANSI DTAP");
    11982. 

  11982.                 dissect_dtap_common(ansi_a_tvb, pinfo, tree, TRUE);
    11983. 

  11983.             } else {
    11984. 

  11984.                 add_new_data_source(pinfo, ansi_a_tvb, "ANSI BSMAP");
    11985. 

  11985.                 dissect_bsmap_common(ansi_a_tvb, pinfo, tree, TRUE);
    11986. 

  11986.             }
    11987. 

  11987.        }
    11988. 

  11988.     }
    11989. 

  11989. }
    11990. 

  11990. 

  11991. /* Register the protocol with Wireshark */
    11992. 

  11992. void
    11993. 

  11993. proto_register_ansi_a(void)
    11994. 

  11994. {
    11995. 

  11995.     module_t            *ansi_a_module;
    11996. 

  11996.     guint               i;
    11997. 

  11997.     gint                last_offset;
    11998. 

  11998. 

  11999.     /* Setup list of header fields */
    12000. 

  12000. 

  12001.     static hf_register_info hf[] =
    12002. 

  12002.     {
    12003. 

  12003.         { &hf_ansi_a_bsmap_msgtype,
    12004. 

  12004.             { "BSMAP Message Type",     "ansi_a_bsmap.msgtype",
    12005. 

  12005.             FT_UINT8, BASE_HEX, NULL, 0x0,
    12006. 

  12006.             NULL, HFILL }
    12007. 

  12007.         },
    12008. 

  12008.         { &hf_ansi_a_dtap_msgtype,
    12009. 

  12009.             { "DTAP Message Type",      "ansi_a_bsmap.dtap_msgtype",
    12010. 

  12010.             FT_UINT8, BASE_HEX, NULL, 0x0,
    12011. 

  12011.             NULL, HFILL }
    12012. 

  12012.         },
    12013. 

  12013.         { &hf_ansi_a_elem_id,
    12014. 

  12014.             { "Element ID",     "ansi_a_bsmap.elem_id",
    12015. 

  12015.             FT_UINT8, BASE_DEC, NULL, 0,
    12016. 

  12016.             NULL, HFILL }
    12017. 

  12017.         },
    12018. 

  12018.         { &hf_ansi_a_length,
    12019. 

  12019.             { "Length",         "ansi_a_bsmap.len",
    12020. 

  12020.             FT_UINT8, BASE_DEC, NULL, 0,
    12021. 

  12021.             NULL, HFILL }
    12022. 

  12022.         },
    12023. 

  12023. #if 0
    12024. 

  12024.         { &hf_ansi_a_none,
    12025. 

  12025.             { "Sub tree",       "ansi_a_bsmap.none",
    12026. 

  12026.             FT_NONE, BASE_NONE, 0, 0,
    12027. 

  12027.             NULL, HFILL }
    12028. 

  12028.         },
    12029. 

  12029. #endif
    12030. 

  12030.         { &hf_ansi_a_esn,
    12031. 

  12031.             { "ESN",    "ansi_a_bsmap.esn",
    12032. 

  12032.             FT_UINT32, BASE_HEX, 0, 0x0,
    12033. 

  12033.             NULL, HFILL }
    12034. 

  12034.         },
    12035. 

  12035.         { &hf_ansi_a_imsi,
    12036. 

  12036.             { "IMSI",   "ansi_a_bsmap.imsi",
    12037. 

  12037.             FT_STRING, BASE_NONE, 0, 0,
    12038. 

  12038.             NULL, HFILL }
    12039. 

  12039.         },
    12040. 

  12040.         { &hf_ansi_a_min,
    12041. 

  12041.             { "MIN",    "ansi_a_bsmap.min",
    12042. 

  12042.             FT_STRING, BASE_NONE, 0, 0,
    12043. 

  12043.             NULL, HFILL }
    12044. 

  12044.         },
    12045. 

  12045.         { &hf_ansi_a_meid,
    12046. 

  12046.             { "MEID",   "ansi_a_bsmap.meid",
    12047. 

  12047.             FT_STRING, BASE_NONE, 0, 0,
    12048. 

  12048.             NULL, HFILL }
    12049. 

  12049.         },
    12050. 

  12050.         { &hf_ansi_a_cld_party_bcd_num,
    12051. 

  12051.             { "Called Party BCD Number",        "ansi_a_bsmap.cld_party_bcd_num",
    12052. 

  12052.             FT_STRING, BASE_NONE, 0, 0,
    12053. 

  12053.             NULL, HFILL }
    12054. 

  12054.         },
    12055. 

  12055. #ifdef MAYBE_USED_FOR_OLDER_CODECS
    12056. 

  12056.         { &hf_ansi_a_clg_party_bcd_num,
    12057. 

  12057.             { "Calling Party BCD Number",       "ansi_a_bsmap.clg_party_bcd_num",
    12058. 

  12058.             FT_STRING, BASE_NONE, 0, 0,
    12059. 

  12059.             NULL, HFILL }
    12060. 

  12060.         },
    12061. 

  12061. #endif
    12062. 

  12062.         { &hf_ansi_a_cld_party_ascii_num,
    12063. 

  12063.             { "Called Party ASCII Number",      "ansi_a_bsmap.cld_party_ascii_num",
    12064. 

  12064.             FT_STRING, BASE_NONE, 0, 0,
    12065. 

  12065.             NULL, HFILL }
    12066. 

  12066.         },
    12067. 

  12067.         { &hf_ansi_a_clg_party_ascii_num,
    12068. 

  12068.             { "Calling Party ASCII Number",     "ansi_a_bsmap.clg_party_ascii_num",
    12069. 

  12069.             FT_STRING, BASE_NONE, 0, 0,
    12070. 

  12070.             NULL, HFILL }
    12071. 

  12071.         },
    12072. 

  12072.         { &hf_ansi_a_cell_ci,
    12073. 

  12073.             { "Cell CI",        "ansi_a_bsmap.cell_ci",
    12074. 

  12074.             FT_UINT16, BASE_HEX, 0, 0x0,
    12075. 

  12075.             NULL, HFILL }
    12076. 

  12076.         },
    12077. 

  12077.         { &hf_ansi_a_cell_lac,
    12078. 

  12078.             { "Cell LAC",       "ansi_a_bsmap.cell_lac",
    12079. 

  12079.             FT_UINT16, BASE_HEX, 0, 0x0,
    12080. 

  12080.             NULL, HFILL }
    12081. 

  12081.         },
    12082. 

  12082.         { &hf_ansi_a_cell_mscid,
    12083. 

  12083.             { "Cell MSCID",     "ansi_a_bsmap.cell_mscid",
    12084. 

  12084.             FT_UINT24, BASE_HEX, 0, 0x0,
    12085. 

  12085.             NULL, HFILL }
    12086. 

  12086.         },
    12087. 

  12087.         { &hf_ansi_a_pdsn_ip_addr,
    12088. 

  12088.             { "PDSN IP Address", "ansi_a_bsmap.pdsn_ip_addr",
    12089. 

  12089.             FT_IPv4, BASE_NONE, NULL, 0,
    12090. 

  12090.             "IP Address", HFILL }
    12091. 

  12091.         },
    12092. 

  12092.         { &hf_ansi_a_s_pdsn_ip_addr,
    12093. 

  12093.             { "Source PDSN Address", "ansi_a_bsmap.s_pdsn_ip_addr",
    12094. 

  12094.             FT_IPv4, BASE_NONE, NULL, 0,
    12095. 

  12095.             "IP Address", HFILL }
    12096. 

  12096.         },
    12097. 

  12097.         { &hf_ansi_a_anchor_ip_addr,
    12098. 

  12098.             { "Anchor PDSN Address", "ansi_a_bsmap.anchor_pdsn_ip_addr",
    12099. 

  12099.             FT_IPv4, BASE_NONE, NULL, 0,
    12100. 

  12100.             "IP Address", HFILL }
    12101. 

  12101.         },
    12102. 

  12102.         { &hf_ansi_a_anchor_pp_ip_addr,
    12103. 

  12103.             { "Anchor P-P Address", "ansi_a_bsmap.anchor_pp_ip_addr",
    12104. 

  12104.             FT_IPv4, BASE_NONE, NULL, 0,
    12105. 

  12105.             "IP Address", HFILL }
    12106. 

  12106.         },
    12107. 

  12107.         { &hf_ansi_a_a2p_bearer_ipv4_addr,
    12108. 

  12108.             { "A2p Bearer IP Address", "ansi_a_bsmap.a2p_bearer_ipv4_addr",
    12109. 

  12109.             FT_IPv4, BASE_NONE, NULL, 0,
    12110. 

  12110.             NULL, HFILL }
    12111. 

  12111.         },
    12112. 

  12112.         { &hf_ansi_a_a2p_bearer_ipv6_addr,
    12113. 

  12113.             { "A2p Bearer IP Address", "ansi_a_bsmap.a2p_bearer_ipv6_addr",
    12114. 

  12114.             FT_IPv6, BASE_NONE, NULL, 0,
    12115. 

  12115.             NULL, HFILL }
    12116. 

  12116.         },
    12117. 

  12117.         { &hf_ansi_a_a2p_bearer_udp_port,
    12118. 

  12118.             { "A2p Bearer UDP Port", "ansi_a_bsmap.a2p_bearer_udp_port",
    12119. 

  12119.             FT_UINT16, BASE_DEC, NULL, 0,
    12120. 

  12120.             NULL, HFILL }
    12121. 

  12121.         },
    12122. 

  12122.         { &hf_ansi_a_so,
    12123. 

  12123.             { "Service Option", "ansi_a_bsmap.so",
    12124. 

  12124.             FT_UINT16, BASE_DEC, NULL, 0,
    12125. 

  12125.             NULL, HFILL }
    12126. 

  12126.         },
    12127. 

  12127.         { &hf_ansi_a_cause_1,
    12128. 

  12128.             { "Cause",  "ansi_a_bsmap.cause_1",
    12129. 

  12129.             FT_UINT8, BASE_DEC, NULL, 0,
    12130. 

  12130.             NULL, HFILL }
    12131. 

  12131.         },
    12132. 

  12132.         { &hf_ansi_a_cause_2,
    12133. 

  12133.             { "Cause",  "ansi_a_bsmap.cause_2",
    12134. 

  12134.             FT_UINT16, BASE_DEC, NULL, 0,
    12135. 

  12135.             NULL, HFILL }
    12136. 

  12136.         },
    12137. 

  12137.         { &hf_ansi_a_meid_configured,
    12138. 

  12138.             { "Is MEID configured",  "ansi_a_bsmap.meid_configured",
    12139. 

  12139.             FT_BOOLEAN, BASE_NONE, NULL, 0x0,
    12140. 

  12140.             NULL, HFILL }
    12141. 

  12141.         }
    12142. 

  12142.     };
    12143. 

  12143. 

  12144.     static ei_register_info ei[] = {
    12145. 

  12145.         { &ei_ansi_a_extraneous_data, { "ansi_a.extraneous_data", PI_PROTOCOL, PI_NOTE, "Extraneous Data, dissector bug or later version spec(report to wireshark.org)", EXPFILL }},
    12146. 

  12146.     };
    12147. 

  12147. 

  12148.     expert_module_t* expert_a_bsmap;
    12149. 

  12149. 

  12150.     static const enum_val_t a_variant_options[] = {
    12151. 

  12151.             { "is-634-rev0",    "IS-634 rev. 0",        A_VARIANT_IS634 },
    12152. 

  12152.             { "tsb-80",         "TSB-80",               A_VARIANT_TSB80 },
    12153. 

  12153.             { "is-634-a",       "IS-634-A",             A_VARIANT_IS634A },
    12154. 

  12154.             { "ios-2.x",        "IOS 2.x",              A_VARIANT_IOS2 },
    12155. 

  12155.             { "ios-3.x",        "IOS 3.x",              A_VARIANT_IOS3 },
    12156. 

  12156.             { "ios-4.0.1",      "IOS 4.0.1",            A_VARIANT_IOS401 },
    12157. 

  12157.             { "ios-5.0.1",      "IOS 5.0.1",            A_VARIANT_IOS501 },
    12158. 

  12158.             { NULL,             NULL,                   0 }
    12159. 

  12159. 

  12160.     };
    12161. 

  12161. 

  12162.     /* Setup protocol subtree array */
    12163. 

  12163. #define MAX_NUM_DTAP_MSG        MAX(ANSI_A_IOS401_DTAP_NUM_MSG, ANSI_A_IOS501_DTAP_NUM_MSG)
    12164. 

  12164. #define MAX_NUM_BSMAP_MSG       MAX(ANSI_A_IOS401_BSMAP_NUM_MSG, ANSI_A_IOS501_BSMAP_NUM_MSG)
    12165. 

  12165. #define MAX_NUM_ELEM_1          MAX(MAX_IOS401_NUM_ELEM_1, MAX_IOS501_NUM_ELEM_1)
    12166. 

  12166. #define NUM_INDIVIDUAL_ELEMS    18
    12167. 

  12167.     gint **ett;
    12168. 

  12168.     gint ett_len = (NUM_INDIVIDUAL_ELEMS+MAX_NUM_DTAP_MSG+MAX_NUM_BSMAP_MSG+MAX_NUM_ELEM_1+NUM_FWD_MS_INFO_REC+NUM_REV_MS_INFO_REC) * sizeof(gint *);
    12169. 

  12169. 

  12170.     /*
    12171. 

  12171.      * XXX - at least one version of the HP C compiler apparently doesn't
    12172. 

  12172.      * recognize constant expressions using the "?" operator as being
    12173. 

  12173.      * constant expressions, so you can't use the expression that
    12174. 

  12174.      * initializes "ett_let" as an array size.  Therefore, we dynamically
    12175. 

  12175.      * allocate the array instead.
    12176. 

  12176.      */
    12177. 

  12177.     ett = (gint **) g_malloc(ett_len);
    12178. 

  12178. 

  12179.     memset((void *) ett_dtap_msg, -1, sizeof(ett_dtap_msg));
    12180. 

  12180.     memset((void *) ett_bsmap_msg, -1, sizeof(ett_bsmap_msg));
    12181. 

  12181.     memset((void *) ett_ansi_elem_1, -1, sizeof(ett_ansi_elem_1));
    12182. 

  12182.     memset((void *) ett_ansi_fwd_ms_info_rec, -1, sizeof(gint) * NUM_FWD_MS_INFO_REC);
    12183. 

  12183.     memset((void *) ett_ansi_rev_ms_info_rec, -1, sizeof(gint) * NUM_REV_MS_INFO_REC);
    12184. 

  12184. 

  12185.     ett[0] = &ett_bsmap;
    12186. 

  12186.     ett[1] = &ett_dtap;
    12187. 

  12187.     ett[2] = &ett_elems;
    12188. 

  12188.     ett[3] = &ett_elem;
    12189. 

  12189.     ett[4] = &ett_dtap_oct_1;
    12190. 

  12190.     ett[5] = &ett_cm_srvc_type;
    12191. 

  12191.     ett[6] = &ett_ansi_ms_info_rec_reserved;
    12192. 

  12192.     ett[7] = &ett_ansi_enc_info;
    12193. 

  12193.     ett[8] = &ett_cell_list;
    12194. 

  12194.     ett[9] = &ett_bearer_list;
    12195. 

  12195.     ett[10] = &ett_re_list;
    12196. 

  12196.     ett[11] = &ett_so_list;
    12197. 

  12197.     ett[12] = &ett_scm;
    12198. 

  12198.     ett[13] = &ett_adds_user_part;
    12199. 

  12199.     ett[14] = &ett_scr;
    12200. 

  12200.     ett[15] = &ett_srvc_con_rec;
    12201. 

  12201.     ett[16] = &ett_cm2_band_class;
    12202. 

  12202.     ett[17] = &ett_vp_algs;
    12203. 

  12203. 

  12204.     last_offset = NUM_INDIVIDUAL_ELEMS;
    12205. 

  12205. 

  12206.     for (i=0; i < MAX_NUM_DTAP_MSG; i++, last_offset++)
    12207. 

  12207.     {
    12208. 

  12208.         ett[last_offset] = &ett_dtap_msg[i];
    12209. 

  12209.     }
    12210. 

  12210. 

  12211.     for (i=0; i < MAX_NUM_BSMAP_MSG; i++, last_offset++)
    12212. 

  12212.     {
    12213. 

  12213.         ett[last_offset] = &ett_bsmap_msg[i];
    12214. 

  12214.     }
    12215. 

  12215. 

  12216.     for (i=0; i < MAX_NUM_ELEM_1; i++, last_offset++)
    12217. 

  12217.     {
    12218. 

  12218.         ett[last_offset] = &ett_ansi_elem_1[i];
    12219. 

  12219.     }
    12220. 

  12220. 

  12221.     for (i=0; i < NUM_FWD_MS_INFO_REC; i++, last_offset++)
    12222. 

  12222.     {
    12223. 

  12223.         ett[last_offset] = &ett_ansi_fwd_ms_info_rec[i];
    12224. 

  12224.     }
    12225. 

  12225. 

  12226.     for (i=0; i < NUM_REV_MS_INFO_REC; i++, last_offset++)
    12227. 

  12227.     {
    12228. 

  12228.         ett[last_offset] = &ett_ansi_rev_ms_info_rec[i];
    12229. 

  12229.     }
    12230. 

  12230. 

  12231.     /* Register the protocol name and description */
    12232. 

  12232. 

  12233.     proto_a_bsmap =
    12234. 

  12234.         proto_register_protocol("ANSI A-I/F BSMAP", "ANSI BSMAP", "ansi_a_bsmap");
    12235. 

  12235. 

  12236.     proto_register_field_array(proto_a_bsmap, hf, array_length(hf));
    12237. 

  12237.     expert_a_bsmap = expert_register_protocol(proto_a_bsmap);
    12238. 

  12238.     expert_register_field_array(expert_a_bsmap, ei, array_length(ei));
    12239. 

  12239. 

  12240.     proto_a_dtap =
    12241. 

  12241.         proto_register_protocol("ANSI A-I/F DTAP", "ANSI DTAP", "ansi_a_dtap");
    12242. 

  12242. 

  12243.     is637_dissector_table =
    12244. 

  12244.         register_dissector_table("ansi_a.sms", "IS-637-A (SMS)",
    12245. 

  12245.         FT_UINT8, BASE_DEC);
    12246. 

  12246. 

  12247.     is683_dissector_table =
    12248. 

  12248.         register_dissector_table("ansi_a.ota", "IS-683-A (OTA)",
    12249. 

  12249.         FT_UINT8, BASE_DEC);
    12250. 

  12250. 

  12251.     is801_dissector_table =
    12252. 

  12252.         register_dissector_table("ansi_a.pld", "IS-801 (PLD)",
    12253. 

  12253.         FT_UINT8, BASE_DEC);
    12254. 

  12254. 

  12255.     proto_register_subtree_array(ett, ett_len / (int)sizeof(gint *));
    12256. 

  12256. 

  12257.     ansi_a_tap = register_tap("ansi_a");
    12258. 

  12258. 

  12259.     /*
    12260. 

  12260.      * setup for preferences
    12261. 

  12261.      */
    12262. 

  12262.     ansi_a_module = prefs_register_protocol(proto_a_bsmap, proto_reg_handoff_ansi_a);
    12263. 

  12263. 

  12264.     prefs_register_enum_preference(ansi_a_module,
    12265. 

  12265.         "global_variant",
    12266. 

  12266.         "Dissect PDU as",
    12267. 

  12267.         "(if other than the default of IOS 4.0.1)",
    12268. 

  12268.         &global_a_variant,
    12269. 

  12269.         a_variant_options,
    12270. 

  12270.         FALSE);
    12271. 

  12271. 

  12272.     g_free(ett);
    12273. 

  12273. }
    12274. 

  12274. 

  12275. 

  12276. void
    12277. 

  12277. proto_reg_handoff_ansi_a(void)
    12278. 

  12278. {
    12279. 

  12279.     static gboolean ansi_a_prefs_initialized = FALSE;
    12280. 

  12280. 

  12281.     if (!ansi_a_prefs_initialized)
    12282. 

  12282.     {
    12283. 

  12283.         dissector_handle_t bsmap_handle, sip_dtap_bsmap_handle;
    12284. 

  12284.         bsmap_handle = create_dissector_handle(dissect_bsmap, proto_a_bsmap);
    12285. 

  12285.         dtap_handle = create_dissector_handle(dissect_dtap, proto_a_dtap);
    12286. 

  12286.         sip_dtap_bsmap_handle = create_dissector_handle(dissect_sip_dtap_bsmap, proto_a_dtap);
    12287. 

  12287.         data_handle = find_dissector("data");
    12288. 

  12288.         rtp_handle = find_dissector("rtp");
    12289. 

  12289. 

  12290.         dissector_add_uint("bsap.pdu_type",  BSSAP_PDU_TYPE_BSMAP, bsmap_handle);
    12291. 

  12291.         dissector_add_uint("bsap.pdu_type",  BSSAP_PDU_TYPE_DTAP, dtap_handle);
    12292. 

  12292.         dissector_add_string("media_type", "application/femtointerfacemsg", sip_dtap_bsmap_handle); 
    12293. 

  12293.         dissector_add_string("media_type", "application/vnd.3gpp2.femtointerfacemsg", sip_dtap_bsmap_handle); 
    12294. 

  12294. 

  12295.         ansi_a_prefs_initialized = TRUE;
    12296. 

  12296.     }
    12297. 

  12297. 

  12298.     switch (global_a_variant)
    12299. 

  12299.     {
    12300. 

  12300.     case A_VARIANT_IOS501:
    12301. 

  12301.         ansi_a_bsmap_strings = ansi_a_ios501_bsmap_strings;
    12302. 

  12302.         ansi_a_dtap_strings = ansi_a_ios501_dtap_strings;
    12303. 

  12303.         ansi_a_elem_1_strings = ansi_a_ios501_elem_1_strings;
    12304. 

  12304.         ansi_a_elem_1_max = (elem_idx_t)MAX_IOS501_NUM_ELEM_1;
    12305. 

  12305.         break;
    12306. 

  12306. 

  12307.     default:
    12308. 

  12308.         ansi_a_bsmap_strings = ansi_a_ios401_bsmap_strings;
    12309. 

  12309.         ansi_a_dtap_strings = ansi_a_ios401_dtap_strings;
    12310. 

  12310.         ansi_a_elem_1_strings = ansi_a_ios401_elem_1_strings;
    12311. 

  12311.         ansi_a_elem_1_max = (elem_idx_t)MAX_IOS401_NUM_ELEM_1;
    12312. 

  12312.         break;
    12313. 

  12313.     }
    12314. 

  12314. }
    12315. 

  12315.