PageRenderTime 65ms CodeModel.GetById 12ms RepoModel.GetById 0ms app.codeStats 1ms

/epan/dissectors/packet-megaco.c

https://github.com/labx-technologies-llc/wireshark
C | 3664 lines | 2589 code | 639 blank | 436 comment | 452 complexity | d1120d55ed35d3d68e137e2bcfb78ea8 MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause 
    

  1. /* packet-megaco.c
    2. 

  2. * Routines for megaco packet disassembly
    3. 

  3. * RFC 3015
    4. 

  4. *
    5. 

  5. * $Id$
    6. 

  6. *
    7. 

  7. * Christian Falckenberg, 2002/10/17
    8. 

  8. * Copyright (c) 2002 by Christian Falckenberg
    9. 

  9. *                       <christian.falckenberg@nortelnetworks.com>
    10. 

  10. *
    11. 

  11. * Christoph Wiest,      2003/06/28
    12. 

  12. * Modified 2003 by      Christoph Wiest
    13. 

  13. *                       <ch.wiest@tesionmail.de>
    14. 

  14. * Modified 2004 by      Anders Broman
    15. 

  15. *                       <anders.broman@ericsson.com>
    16. 

  16. * To handle TPKT headers if over TCP
    17. 

  17. * Modified 2005 by      Karl Knoebl
    18. 

  18. *                       <karl.knoebl@siemens.com>
    19. 

  19. *   provide info to COL_INFO and some "prettification"
    20. 

  20. *
    21. 

  21. * Copyright (c) 2006 Anders Broman <anders.broman@ericsson.com>
    22. 

  22. *
    23. 

  23. * Wireshark - Network traffic analyzer
    24. 

  24. * By Gerald Combs <gerald@wireshark.org>
    25. 

  25. * Copyright 1999 Gerald Combs
    26. 

  26. *
    27. 

  27. * This program is free software; you can redistribute it and/or
    28. 

  28. * modify it under the terms of the GNU General Public License
    29. 

  29. * as published by the Free Software Foundation; either version 2
    30. 

  30. * of the License, or (at your option) any later version.
    31. 

  31. *
    32. 

  32. * This program is distributed in the hope that it will be useful,
    33. 

  33. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    34. 

  34. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    35. 

  35. * GNU General Public License for more details.
    36. 

  36. *
    37. 

  37. * You should have received a copy of the GNU General Public License
    38. 

  38. * along with this program; if not, write to the Free Software
    39. 

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

  40. */
    41. 

  41. 

  42. 

  43. #include "config.h"
    44. 

  44. 

  45. #include <stdlib.h>
    46. 

  46. #include <ctype.h>
    47. 

  47. 

  48. #include <glib.h>
    49. 

  49. 

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

  51. #include <epan/wmem/wmem.h>
    52. 

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

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

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

  55. #include <epan/sctpppids.h>
    56. 

  56. #include <epan/dissectors/packet-tpkt.h>
    57. 

  57. #include <epan/asn1.h>
    58. 

  58. #include <epan/dissectors/packet-per.h>
    59. 

  59. #include <epan/dissectors/packet-h245.h>
    60. 

  60. #include <epan/dissectors/packet-ip.h>
    61. 

  61. #include <epan/dissectors/packet-ber.h>
    62. 

  62. 

  63. #include <epan/gcp.h>
    64. 

  64. #include <epan/tap.h>
    65. 

  65. 

  66. #define PORT_MEGACO_TXT 2944
    67. 

  67. #define PORT_MEGACO_BIN 2945
    68. 

  68. 

  69. /* Define the megaco proto */
    70. 

  70. static int proto_megaco         = -1;
    71. 

  71. 

  72. /* Define headers for megaco */
    73. 

  73. static int hf_megaco_version        = -1;
    74. 

  74. static int hf_megaco_transaction    = -1;
    75. 

  75. static int hf_megaco_transid        = -1;
    76. 

  76. static int hf_megaco_Context        = -1;
    77. 

  77. /* static int hf_megaco_command_line   = -1; */
    78. 

  78. static int hf_megaco_command        = -1;
    79. 

  79. static int hf_megaco_termid         = -1;
    80. 

  80. 

  81. 

  82. 

  83. /* Define headers in subtree for megaco */
    84. 

  84. static int hf_megaco_modem_descriptor           = -1;
    85. 

  85. static int hf_megaco_multiplex_descriptor       = -1;
    86. 

  86. /* static int hf_megaco_media_descriptor           = -1; */
    87. 

  87. /* static int hf_megaco_events_descriptor          = -1; */
    88. 

  88. /* static int hf_megaco_signal_descriptor          = -1; */
    89. 

  89. static int hf_megaco_audit_descriptor           = -1;
    90. 

  90. /* static int hf_megaco_servicechange_descriptor   = -1; */
    91. 

  91. static int hf_megaco_digitmap_descriptor        = -1;
    92. 

  92. static int hf_megaco_statistics_descriptor      = -1;
    93. 

  93. /* static int hf_megaco_observedevents_descriptor  = -1; */
    94. 

  94. static int hf_megaco_topology_descriptor        = -1;
    95. 

  95. static int hf_megaco_error_descriptor           = -1;
    96. 

  96. /* static int hf_megaco_TerminationState_descriptor= -1; */
    97. 

  97. /* static int hf_megaco_Remote_descriptor          = -1; */
    98. 

  98. /* static int hf_megaco_Local_descriptor           = -1; */
    99. 

  99. /* static int hf_megaco_LocalControl_descriptor    = -1; */
    100. 

  100. static int hf_megaco_packages_descriptor        = -1;
    101. 

  101. static int hf_megaco_error_Frame                = -1;
    102. 

  102. static int hf_megaco_Service_State              = -1;
    103. 

  103. static int hf_megaco_Event_Buffer_Control       = -1;
    104. 

  104. static int hf_megaco_mode                       = -1;
    105. 

  105. static int hf_megaco_reserve_group              = -1;
    106. 

  106. static int hf_megaco_h324_muxtbl_in             = -1;
    107. 

  107. static int hf_megaco_h324_muxtbl_out            = -1;
    108. 

  108. static int hf_megaco_ds_dscp                    = -1;
    109. 

  109. static int hf_megaco_h324_h223capr              = -1;
    110. 

  110. static int hf_megaco_reserve_value              = -1;
    111. 

  111. static int hf_megaco_streamid                   = -1;
    112. 

  112. static int hf_megaco_requestid                  = -1;
    113. 

  113. static int hf_megaco_pkgdname                   = -1;
    114. 

  114. static int hf_megaco_mId                        = -1;
    115. 

  115. /* static int hf_megaco_h245                       = -1; */
    116. 

  116. static int hf_megaco_h223Capability             = -1;
    117. 

  117. static int hf_megaco_audititem                  = -1;
    118. 

  118. 

  119. /* Define the trees for megaco */
    120. 

  120. static int ett_megaco                           = -1;
    121. 

  121. static int ett_megaco_message                   = -1;
    122. 

  122. static int ett_megaco_message_body              = -1;
    123. 

  123. static int ett_megaco_context                   = -1;
    124. 

  124. static int ett_megaco_command_line              = -1;
    125. 

  125. static int ett_megaco_mediadescriptor           = -1;
    126. 

  126. static int ett_megaco_descriptors               = -1;
    127. 

  127. static int ett_megaco_TerminationState          = -1;
    128. 

  128. static int ett_megaco_Localdescriptor           = -1;
    129. 

  129. static int ett_megaco_Remotedescriptor          = -1;
    130. 

  130. static int ett_megaco_LocalControldescriptor    = -1;
    131. 

  131. static int ett_megaco_auditdescriptor           = -1;
    132. 

  132. static int ett_megaco_eventsdescriptor          = -1;
    133. 

  133. static int ett_megaco_observedeventsdescriptor  = -1;
    134. 

  134. static int ett_megaco_observedevent             = -1;
    135. 

  135. static int ett_megaco_packagesdescriptor        = -1;
    136. 

  136. static int ett_megaco_requestedevent            = -1;
    137. 

  137. static int ett_megaco_signalsdescriptor         = -1;
    138. 

  138. static int ett_megaco_requestedsignal           = -1;
    139. 

  139. static int ett_megaco_h245                      = -1;
    140. 

  140. 

  141. static gcp_hf_ett_t megaco_ctx_ids = {{-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1}};
    142. 

  142. 

  143. static expert_field ei_megaco_errored_command = EI_INIT;
    144. 

  144. 

  145. static dissector_handle_t megaco_text_handle;
    146. 

  146. 

  147. static int megaco_tap = -1;
    148. 

  148. 

  149. /*
    150. 

  150. * Here are the global variables associated with
    151. 

  151. * the various user definable characteristics of the dissection
    152. 

  152. *
    153. 

  153. * MEGACO has two kinds of message formats: text and binary
    154. 

  154. *
    155. 

  155. * global_megaco_raw_text determines whether we are going to display
    156. 

  156. * the raw text of the megaco message, much like the HTTP dissector does.
    157. 

  157. *
    158. 

  158. * global_megaco_dissect_tree determines whether we are going to display
    159. 

  159. * a detailed tree that expresses a somewhat more semantically meaningful
    160. 

  160. * decode.
    161. 

  161. */
    162. 

  162. static guint global_megaco_txt_sctp_port = PORT_MEGACO_TXT;
    163. 

  163. static guint global_megaco_txt_tcp_port = PORT_MEGACO_TXT;
    164. 

  164. static guint global_megaco_txt_udp_port = PORT_MEGACO_TXT;
    165. 

  165. #if 0
    166. 

  166. static guint global_megaco_bin_sctp_port = PORT_MEGACO_BIN;
    167. 

  167. static guint global_megaco_bin_tcp_port = PORT_MEGACO_BIN;
    168. 

  168. static guint global_megaco_bin_udp_port = PORT_MEGACO_BIN;
    169. 

  169. #endif
    170. 

  170. static gboolean global_megaco_raw_text = TRUE;
    171. 

  171. static gboolean global_megaco_dissect_tree = TRUE;
    172. 

  172. 

  173. /* Some basic utility functions that are specific to this dissector */
    174. 

  174. static gint megaco_tvb_skip_wsp(tvbuff_t* tvb, gint offset);
    175. 

  175. static gint megaco_tvb_skip_wsp_return(tvbuff_t* tvb, gint offset);
    176. 

  176. /*
    177. 

  177. * The various functions that either dissect some
    178. 

  178. * subpart of MEGACO.  These aren't really proto dissectors but they
    179. 

  179. * are written in the same style.
    180. 

  180. *
    181. 

  181. */
    182. 

  182. static void
    183. 

  183. dissect_megaco_descriptors(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, gint tvb_descriptors_start_offset, gint tvb_descriptors_end_offset);
    184. 

  184. static void
    185. 

  185. dissect_megaco_modemdescriptor(tvbuff_t *tvb, proto_tree *tree, gint tvb_RBRKT, gint tvb_previous_offset);
    186. 

  186. static void
    187. 

  187. dissect_megaco_multiplexdescriptor(tvbuff_t *tvb, proto_tree *tree, gint tvb_RBRKT, gint tvb_previous_offset);
    188. 

  188. static void
    189. 

  189. dissect_megaco_mediadescriptor(tvbuff_t *tvb, proto_tree *tree,packet_info *pinfo, gint tvb_RBRKT, gint tvb_previous_offset);
    190. 

  190. static void
    191. 

  191. dissect_megaco_eventsdescriptor(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gint tvb_RBRKT, gint tvb_previous_offset);
    192. 

  192. static void
    193. 

  193. dissect_megaco_signaldescriptor(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gint tvb_RBRKT, gint tvb_previous_offset);
    194. 

  194. static void
    195. 

  195. dissect_megaco_auditdescriptor(tvbuff_t *tvb, proto_tree *tree,packet_info *pinfo, gint tvb_RBRKT, gint tvb_previous_offset);
    196. 

  196. static void
    197. 

  197. dissect_megaco_servicechangedescriptor(tvbuff_t *tvb, proto_tree *tree, gint tvb_RBRKT, gint tvb_previous_offset);
    198. 

  198. static void
    199. 

  199. dissect_megaco_digitmapdescriptor(tvbuff_t *tvb, proto_tree *tree, gint tvb_RBRKT, gint tvb_previous_offset);
    200. 

  200. static void
    201. 

  201. dissect_megaco_statisticsdescriptor(tvbuff_t *tvb, proto_tree *tree, gint tvb_RBRKT, gint tvb_previous_offset);
    202. 

  202. static void
    203. 

  203. dissect_megaco_observedeventsdescriptor(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gint tvb_RBRKT, gint tvb_previous_offset);
    204. 

  204. static void
    205. 

  205. dissect_megaco_topologydescriptor(tvbuff_t *tvb, proto_tree *tree, gint tvb_RBRKT, gint tvb_previous_offset);
    206. 

  206. static void
    207. 

  207. dissect_megaco_errordescriptor(tvbuff_t *tvb, proto_tree *tree, gint tvb_RBRKT, gint tvb_previous_offset);
    208. 

  208. static void
    209. 

  209. dissect_megaco_TerminationStatedescriptor(tvbuff_t *tvb, proto_tree *tree, gint tvb_next_offset, gint tvb_current_offset);
    210. 

  210. static void
    211. 

  211. dissect_megaco_Localdescriptor(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, gint tvb_next_offset, gint tvb_current_offset);
    212. 

  212. static void
    213. 

  213. dissect_megaco_LocalControldescriptor(tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo, gint tvb_next_offset, gint tvb_current_offset);
    214. 

  214. static void
    215. 

  215. dissect_megaco_Packagesdescriptor(tvbuff_t *tvb, proto_tree *tree, gint tvb_next_offset, gint tvb_current_offset);
    216. 

  216. static void
    217. 

  217. tvb_raw_text_add(tvbuff_t *tvb, proto_tree *tree);
    218. 

  218. static void
    219. 

  219. dissect_megaco_text(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
    220. 

  220. static gint
    221. 

  221. megaco_tvb_find_token(tvbuff_t* tvb, gint offset, gint maxlenght);
    222. 

  222. static dissector_handle_t data_handle;
    223. 

  223. static dissector_handle_t sdp_handle;
    224. 

  224. static dissector_handle_t h245_handle;
    225. 

  225. static dissector_handle_t h248_handle;
    226. 

  226. static dissector_handle_t h248_otp_handle;
    227. 

  227. 

  228. static gboolean keep_persistent_data = FALSE;
    229. 

  229. 

  230. static proto_tree *top_tree;
    231. 

  231. /*
    232. 

  232.  * dissect_megaco_text over TCP, there will be a TPKT header there
    233. 

  233.  *
    234. 

  234.  */
    235. 

  235. static void dissect_megaco_text_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
    236. 

  236. {
    237. 

  237.     int lv_tpkt_len;
    238. 

  238. 

  239.     /* This code is copied from the Q.931 dissector, some parts skipped.
    240. 

  240.      * Check whether this looks like a TPKT-encapsulated
    241. 

  241.      * MEGACO packet.
    242. 

  242.      *
    243. 

  243.      * The minimum length of a MEGACO message is 6?:
    244. 

  244.      * Re-assembly ?
    245. 

  245.      */
    246. 

  246.     lv_tpkt_len = is_tpkt(tvb, 6);
    247. 

  247.     if (lv_tpkt_len == -1) {
    248. 

  248.         /*
    249. 

  249.          * It's not a TPKT packet;
    250. 

  250.          * Is in MEGACO ?
    251. 

  251.          */
    252. 

  252.         dissect_megaco_text(tvb, pinfo, tree);
    253. 

  253.     }
    254. 

  254.     dissect_tpkt_encap(tvb, pinfo, tree, TRUE,
    255. 

  255.         megaco_text_handle);
    256. 

  256. }
    257. 

  257. 

  258. #define ERRORTOKEN          1
    259. 

  259. #define TRANSTOKEN          2
    260. 

  260. #define REPLYTOKEN          3
    261. 

  261. #define PENDINGTOKEN        4
    262. 

  262. #define RESPONSEACKTOKEN    5
    263. 

  263. 

  264. typedef struct {
    265. 

  265.     const char *name;
    266. 

  266.     const char *compact_name;
    267. 

  267. } megaco_tokens_t;
    268. 

  268. 

  269. static const megaco_tokens_t megaco_messageBody_names[] = {
    270. 

  270.     { "Unknown-token",              NULL }, /* 0 Pad so that the real headers start at index 1 */
    271. 

  271.     { "Error",                      "ER" }, /* 1 */
    272. 

  272.     { "Transaction",                "T" },  /* 2 */
    273. 

  273.     { "Reply",                      "P" },  /* 3 */
    274. 

  274.     { "Pending",                    "PN" }, /* 4 */
    275. 

  275.     { "TransactionResponseAck",     "K" },  /* 5 */
    276. 

  276. };
    277. 

  277. 

  278. /* Returns index of megaco_tokens_t */
    279. 

  279. static gint find_megaco_messageBody_names(tvbuff_t *tvb, int offset, guint header_len)
    280. 

  280. {
    281. 

  281.     guint i;
    282. 

  282. 

  283.     for (i = 1; i < array_length(megaco_messageBody_names); i++) {
    284. 

  284.         if (header_len == strlen(megaco_messageBody_names[i].name) &&
    285. 

  285.             tvb_strncaseeql(tvb, offset, megaco_messageBody_names[i].name, header_len) == 0)
    286. 

  286.             return i;
    287. 

  287.         if (megaco_messageBody_names[i].compact_name != NULL &&
    288. 

  288.             header_len == strlen(megaco_messageBody_names[i].compact_name) &&
    289. 

  289.             tvb_strncaseeql(tvb, offset, megaco_messageBody_names[i].compact_name, header_len) == 0)
    290. 

  290.             return i;
    291. 

  291.     }
    292. 

  292. 

  293.     return -1;
    294. 

  294. }
    295. 

  295. 

  296. static proto_item *
    297. 

  297. my_proto_tree_add_string(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    298. 

  298.              gint start, gint length, const char *value)
    299. 

  299. {
    300. 

  300.     proto_item *pi;
    301. 

  301. 

  302.     pi = proto_tree_add_string(tree, hfindex, tvb, start, length, value);
    303. 

  303.     if (!global_megaco_dissect_tree) {
    304. 

  304.         PROTO_ITEM_SET_HIDDEN(pi);
    305. 

  305.     }
    306. 

  306. 

  307.     return(pi);
    308. 

  308. }
    309. 

  309. /*
    310. 

  310.  * dissect_megaco_text - The dissector for the MEGACO Protocol, using
    311. 

  311.  * text encoding.
    312. 

  312.  */
    313. 

  313. static void
    314. 

  314. dissect_megaco_text(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
    315. 

  315. {
    316. 

  316.     gint        tvb_len, len;
    317. 

  317.     gint        tvb_offset,tvb_current_offset,tvb_previous_offset,tvb_next_offset,tokenlen;
    318. 

  318.     gint        line_start_offset, ver_offset, ver_length, mId_offset, mId_length;
    319. 

  319.     gint        tvb_command_start_offset, tvb_command_end_offset;
    320. 

  320.     gint        tvb_descriptors_start_offset, tvb_descriptors_end_offset;
    321. 

  321.     gint        tvb_transaction_end_offset;
    322. 

  322.     proto_tree  *megaco_tree, *message_tree, *message_body_tree, *megaco_context_tree, *megaco_tree_command_line, *ti, *sub_ti;
    323. 

  323. 

  324.     guint8      word[7];
    325. 

  325.     guint8      TermID[30];
    326. 

  326.     guint8      tempchar;
    327. 

  327.     gint        tvb_RBRKT, tvb_LBRKT,  RBRKT_counter, LBRKT_counter;
    328. 

  328.     guint       token_index=0;
    329. 

  329.     guint32     dword;
    330. 

  330.     guchar      needle;
    331. 

  331.     guint8      first;
    332. 

  332. 

  333.     gcp_msg_t* msg = NULL;
    334. 

  334.     gcp_trx_t* trx = NULL;
    335. 

  335.     gcp_ctx_t* ctx = NULL;
    336. 

  336.     gcp_cmd_t* cmd = NULL;
    337. 

  337.     gcp_term_t* term = NULL;
    338. 

  338.     gcp_trx_type_t trx_type = GCP_TRX_NONE;
    339. 

  339.     guint32 trx_id = 0;
    340. 

  340.     guint32 ctx_id = 0;
    341. 

  341.     gcp_cmd_type_t cmd_type = GCP_CMD_NONE;
    342. 

  342.     gcp_wildcard_t wild_term = GCP_WILDCARD_NONE;
    343. 

  343.     proto_item *hidden_item;
    344. 

  344. 

  345.     top_tree=tree;
    346. 

  346.     /* Initialize variables */
    347. 

  347.     tvb_len                     = tvb_length(tvb);
    348. 

  348.     megaco_tree                 = NULL;
    349. 

  349.     ti                          = NULL;
    350. 

  350.     tvb_offset                  = 0;
    351. 

  351.     tvb_next_offset             = 0;
    352. 

  352.     RBRKT_counter               = 0;
    353. 

  353.     LBRKT_counter               = 0;
    354. 

  354. 

  355.     /* Check if H.248 in otp(Erlang) internal format
    356. 

  356.      * XXX Needs improvement?
    357. 

  357.      * Ref:
    358. 

  358.      * http://www.erlang.org/doc/apps/megaco/part_frame.html
    359. 

  359.      * 4.1 Internal form of messages
    360. 

  360.      * 4.2 The different encodings
    361. 

  361.      */
    362. 

  362.     dword = tvb_get_ntoh24(tvb,0);
    363. 

  363.     if ((dword == 0x836803)&&(h248_otp_handle)){
    364. 

  364.         call_dissector(h248_otp_handle, tvb, pinfo, tree);
    365. 

  365.         return;
    366. 

  366.     }
    367. 

  367. 

  368.     msg = gcp_msg(pinfo, tvb_raw_offset(tvb), keep_persistent_data);
    369. 

  369. 

  370.     /*
    371. 

  371.      * Check to see whether we're really dealing with MEGACO by looking
    372. 

  372.      * for the "MEGACO" string or a "!".This needs to be improved when supporting
    373. 

  373.      * binary encodings. Bugfix add skipping of leading spaces.
    374. 

  374.      */
    375. 

  375.     tvb_offset = megaco_tvb_skip_wsp(tvb, tvb_offset);
    376. 

  376.     line_start_offset = tvb_offset;
    377. 

  377.     /* Quick fix for MEGACO not following the RFC, hopefully not breaking any thing
    378. 

  378.      * Turned out to be TPKT in case of TCP, added some code to handle that.
    379. 

  379.      *
    380. 

  380.      * tvb_offset = tvb_find_guint8(tvb, tvb_offset, 5, 'M');
    381. 

  381.      */
    382. 

  382.     if(!tvb_get_nstringz0(tvb,tvb_offset,sizeof(word),word)) return;
    383. 

  383. 

  384. 

  385. 

  386. 

  387.     if (g_ascii_strncasecmp(word, "MEGACO", 6) != 0 && tvb_get_guint8(tvb, tvb_offset ) != '!'){
    388. 

  388.         gint8 ber_class;
    389. 

  389.         gboolean pc;
    390. 

  390.         gint32 tag;
    391. 

  391.         dissector_handle_t handle = data_handle;
    392. 

  392. 

  393.         get_ber_identifier(tvb, 0, &ber_class, &pc, &tag);
    394. 

  394. 

  395.         if (ber_class == BER_CLASS_UNI && pc && tag == BER_UNI_TAG_SEQUENCE ) {
    396. 

  396.             handle = h248_handle;
    397. 

  397.         }
    398. 

  398. 

  399.         call_dissector(handle,tvb,pinfo,tree);
    400. 

  400. 

  401.         return;
    402. 

  402.     }
    403. 

  403. 

  404. 

  405.     /* Display MEGACO in protocol column */
    406. 

  406.     col_set_str(pinfo->cinfo, COL_PROTOCOL, "MEGACO");
    407. 

  407. 

  408.     /* Build the info tree if we've been given a root */
    409. 

  409.     /* Create megaco subtree */
    410. 

  410.     ti = proto_tree_add_item(tree,proto_megaco,tvb, 0, -1, ENC_NA);
    411. 

  411.     megaco_tree = proto_item_add_subtree(ti, ett_megaco);
    412. 

  412. 

  413.     /*  Format of 'message' is = MegacopToken SLASH Version SEP mId SEP messageBody */
    414. 

  414.     /*  MegacopToken = "MEGACO" or "!"                      */
    415. 

  415.     /*  According to H248.1-200205 Annex B Text encoding ( protocol version 2 )     */
    416. 

  416. 

  417.     /* Find version */
    418. 

  418.     tvb_previous_offset = tvb_find_guint8(tvb, 0,
    419. 

  419.         tvb_len, '/');
    420. 

  420.     if (tvb_previous_offset == -1) {
    421. 

  421.         expert_add_info_format(pinfo, ti, PI_MALFORMED, PI_ERROR,
    422. 

  422.             "Sorry, no \"/\" in the MEGACO header, I can't parse this packet");
    423. 

  423.         return;
    424. 

  424.     }
    425. 

  425. 

  426.     /* skip / */
    427. 

  427.     tvb_previous_offset++;
    428. 

  428. 

  429.     /* assume at least one digit in version */
    430. 

  430.     tvb_current_offset = tvb_previous_offset + 1;
    431. 

  431. 

  432.     if (isdigit(tvb_get_guint8(tvb, tvb_current_offset))) {
    433. 

  433.         /* 2-digit version */
    434. 

  434.         tvb_current_offset++;
    435. 

  435.     }
    436. 

  436. 

  437.     tokenlen = tvb_current_offset - tvb_previous_offset;
    438. 

  438.     ver_offset = tvb_previous_offset;
    439. 

  439.     ver_length = tokenlen;
    440. 

  440. 

  441.     tvb_previous_offset = tvb_current_offset;
    442. 

  442.     tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_previous_offset);
    443. 

  443. 

  444.     if (tvb_previous_offset == tvb_current_offset) {
    445. 

  445.         expert_add_info_format(pinfo, ti, PI_MALFORMED, PI_ERROR,
    446. 

  446.             "[ Parse error: missing SEP in MEGACO header ]");
    447. 

  447.         return;
    448. 

  448.     }
    449. 

  449. 

  450.     tvb_previous_offset = tvb_current_offset;
    451. 

  451. 

  452.     /* mId should follow here,
    453. 

  453.      * mId = (( domainAddress / domainName ) [":" portNumber]) / mtpAddress / deviceName
    454. 

  454.      * domainAddress = "[" (IPv4address / IPv6address) "]"
    455. 

  455.      * domainName = "<" (ALPHA / DIGIT) *63(ALPHA / DIGIT / "-" /".") ">"
    456. 

  456.      * mtpAddress = MTPToken LBRKT 4*8 (HEXDIG) RBRKT
    457. 

  457.      * MTPToken = ("MTP")
    458. 

  458.      * deviceName = pathNAME
    459. 

  459.      * pathNAME = ["*"] NAME *("/" / "*"/ ALPHA / DIGIT /"_" / "$" )["@" pathDomainName ]
    460. 

  460.      */
    461. 

  461. 

  462.     tvb_current_offset = tvb_pbrk_guint8(tvb, tvb_current_offset, -1, " \t\r\n", &needle);
    463. 

  463.     if (tvb_current_offset == -1) {
    464. 

  464.         expert_add_info_format(pinfo, ti, PI_MALFORMED, PI_ERROR,
    465. 

  465.             "[ Parse error: no body in MEGACO message (missing SEP after mId) ]");
    466. 

  466.         return;
    467. 

  467.     }
    468. 

  468. 

  469.     tokenlen = tvb_current_offset - tvb_previous_offset;
    470. 

  470.     tvb_next_offset = megaco_tvb_skip_wsp(tvb, tvb_current_offset);
    471. 

  471. 

  472.    /* At this point we should point to the "\n" ending the mId element
    473. 

  473.     * or to the next character after white space SEP
    474. 

  474.     */
    475. 

  475.     mId_offset = tvb_previous_offset;
    476. 

  476.     mId_length = tokenlen;
    477. 

  477. 

  478.     /* Add the first line to the tree */
    479. 

  479.     tokenlen = tvb_next_offset - line_start_offset - 1;
    480. 

  480.     ti = proto_tree_add_text(megaco_tree, tvb, line_start_offset, tokenlen,
    481. 

  481.             "%s",tvb_format_text(tvb,line_start_offset,tokenlen));
    482. 

  482.     message_tree = proto_item_add_subtree(ti, ett_megaco_message);
    483. 

  483.     if (tree){
    484. 

  484.         if(global_megaco_dissect_tree){
    485. 

  485.             proto_tree_add_item(message_tree, hf_megaco_version,tvb, ver_offset, ver_length, ENC_ASCII|ENC_NA);
    486. 

  486.             proto_tree_add_item(message_tree, hf_megaco_mId,tvb, mId_offset, mId_length, ENC_ASCII|ENC_NA);
    487. 

  487.         }else{
    488. 

  488.             hidden_item = proto_tree_add_item(message_tree, hf_megaco_version,tvb, ver_offset, ver_length, ENC_ASCII|ENC_NA);
    489. 

  489.             PROTO_ITEM_SET_HIDDEN(hidden_item);
    490. 

  490.             hidden_item = proto_tree_add_item(message_tree, hf_megaco_mId,tvb, mId_offset, mId_length, ENC_ASCII|ENC_NA);
    491. 

  491.             PROTO_ITEM_SET_HIDDEN(hidden_item);
    492. 

  492.         }
    493. 

  493.     }
    494. 

  494.     col_clear(pinfo->cinfo, COL_INFO);
    495. 

  495.     first = 1;
    496. 

  496.     do{
    497. 

  497.     tvb_previous_offset = tvb_next_offset;
    498. 

  498. 

  499. /* Next part is
    500. 

  500.  *  : messageBody = ( errorDescriptor / transactionList )
    501. 

  501.  *      errorDescriptor = ErrorToken EQUAL ErrorCode LBRKT [quotedString] RBRKT
    502. 

  502.  *          ErrorToken = ("Error" / "ER")
    503. 

  503.  *
    504. 

  504.  *      transactionList = 1*( transactionRequest / transactionReply /
    505. 

  505.  *                  transactionPending / transactionResponseAck )
    506. 

  506.  *
    507. 

  507.  *      transactionResponseAck = ResponseAckToken LBRKT
    508. 

  508.  *          transactionAck*(COMMA transactionAck) RBRKT
    509. 

  509.  *              ResponseAckToken = ("TransactionResponseAck"/ "K")
    510. 

  510.  *
    511. 

  511.  *      transactionPending = PendingToken EQUAL TransactionID LBRKT RBRKT
    512. 

  512.  *          PendingToken = ("Pending" / "PN")
    513. 

  513.  *
    514. 

  514.  *      transactionReply = ReplyToken EQUAL TransactionID LBRKT
    515. 

  515.  *          [ ImmAckRequiredToken COMMA]( errorDescriptor / actionReplyList ) RBRKT
    516. 

  516.  *          ReplyToken = ("Reply" / "P")
    517. 

  517.  *
    518. 

  518.  *      transactionRequest = TransToken EQUAL TransactionID LBRKT
    519. 

  519.  *          actionRequest *(COMMA actionRequest) RBRKT
    520. 

  520.  *          TransToken = ("Transaction" / "T")
    521. 

  521.  */
    522. 

  522. 

  523.     /* Find token length */
    524. 

  524.     for (tvb_offset=tvb_previous_offset; tvb_offset < tvb_len-1; tvb_offset++){
    525. 

  525.         if (!isalpha(tvb_get_guint8(tvb, tvb_offset ))){
    526. 

  526.             break;
    527. 

  527.         }
    528. 

  528.     }
    529. 

  529.     tokenlen = tvb_offset - tvb_previous_offset;
    530. 

  530.     token_index = find_megaco_messageBody_names(tvb, tvb_previous_offset, tokenlen);
    531. 

  531.     /* Debug code
    532. 

  532.         g_warning("token_index %u",token_index);
    533. 

  533.     */
    534. 

  534. 

  535.     tvb_LBRKT  = tvb_find_guint8(tvb, tvb_offset, tvb_len, '{');
    536. 

  536.     tvb_current_offset = tvb_LBRKT;
    537. 

  537.     tvb_transaction_end_offset = megaco_tvb_find_token(tvb, tvb_LBRKT - 1, tvb_len);
    538. 

  538. 

  539.     switch ( token_index ){
    540. 

  540.         /* errorDescriptor */
    541. 

  541.         case ERRORTOKEN:
    542. 

  542.             col_set_str(pinfo->cinfo, COL_INFO, "Error  ");
    543. 

  543. 

  544.             tvb_current_offset = megaco_tvb_find_token(tvb, tvb_offset, tvb_len); /*tvb_find_guint8(tvb, tvb_offset+1, tvb_len, '}');*/
    545. 

  545. 

  546.             ti = proto_tree_add_text(megaco_tree, tvb, tvb_previous_offset, tvb_current_offset-tvb_previous_offset,
    547. 

  547.                     "%s",tvb_format_text(tvb, tvb_previous_offset, tvb_current_offset-tvb_previous_offset));
    548. 

  548.             message_body_tree = proto_item_add_subtree(ti, ett_megaco_message_body);
    549. 

  549. 

  550.             if (tree) {
    551. 

  551.                 my_proto_tree_add_string(message_body_tree, hf_megaco_transaction, tvb,
    552. 

  552.                 tvb_previous_offset, tokenlen,
    553. 

  553.                 "Error" );
    554. 

  554. 

  555.                 tvb_command_start_offset = tvb_previous_offset;
    556. 

  556.                 dissect_megaco_errordescriptor(tvb, megaco_tree, tvb_len-1, tvb_command_start_offset);
    557. 

  557.             }
    558. 

  558.             return;
    559. 

  559.             /* transactionResponseAck
    560. 

  560.              * transactionResponseAck = ResponseAckToken LBRKT transactionAck
    561. 

  561.              *                           *(COMMA transactionAck) RBRKT
    562. 

  562.              * transactionAck = transactionID / (transactionID "-" transactionID)
    563. 

  563.              */
    564. 

  564.         case RESPONSEACKTOKEN:
    565. 

  565.             tvb_LBRKT  = tvb_find_guint8(tvb, tvb_offset, tvb_transaction_end_offset, '{');
    566. 

  566.             tvb_offset = tvb_LBRKT;
    567. 

  567. 

  568.             ti = proto_tree_add_text(megaco_tree, tvb, tvb_previous_offset, tvb_offset-tvb_previous_offset,
    569. 

  569.                 "%s",tvb_format_text(tvb, tvb_previous_offset, tvb_offset-tvb_previous_offset+1));
    570. 

  570.             message_body_tree = proto_item_add_subtree(ti, ett_megaco_message_body);
    571. 

  571. 

  572.             my_proto_tree_add_string(message_body_tree, hf_megaco_transaction, tvb,
    573. 

  573.                 tvb_previous_offset, tokenlen,
    574. 

  574.                 "TransactionResponseAck" );
    575. 

  575. 

  576.             tvb_previous_offset = megaco_tvb_skip_wsp(tvb, tvb_offset+1);
    577. 

  577.             tvb_current_offset = tvb_find_guint8(tvb, tvb_offset+1, tvb_len, '}');
    578. 

  578.             /*tvb_current_offset = megaco_tvb_find_token(tvb, tvb_offset, tvb_transaction_end_offset);*/
    579. 

  579.             tvb_current_offset = megaco_tvb_skip_wsp_return(tvb, tvb_current_offset)-1; /* cut last RBRKT */
    580. 

  580.             len = tvb_current_offset - tvb_previous_offset;
    581. 

  581. 

  582.             if (!first) {
    583. 

  583.               col_append_str(pinfo->cinfo, COL_INFO, " ");
    584. 

  584.             }
    585. 

  585.             col_append_fstr(pinfo->cinfo, COL_INFO, "%s TransactionResponseAck",
    586. 

  586.                 tvb_format_text(tvb,tvb_previous_offset,len));
    587. 

  587. 

  588.             if(tree)
    589. 

  589.                 my_proto_tree_add_string(message_body_tree, hf_megaco_transid, tvb,
    590. 

  590.                 tvb_previous_offset, len,
    591. 

  591.                 tvb_format_text(tvb,tvb_previous_offset,len));
    592. 

  592. 

  593.                 if(global_megaco_raw_text){
    594. 

  594.                     tvb_raw_text_add(tvb, megaco_tree);
    595. 

  595.                 }
    596. 

  596.             return;
    597. 

  597.         /* Pe and PN is transactionPending, P+"any char" is transactionReply */
    598. 

  598.         case PENDINGTOKEN:
    599. 

  599. 

  600.             tvb_offset  = tvb_find_guint8(tvb, tvb_previous_offset, tvb_transaction_end_offset, '=')+1;
    601. 

  601.             tvb_offset = megaco_tvb_skip_wsp(tvb, tvb_offset);
    602. 

  602.             tvb_LBRKT  = tvb_find_guint8(tvb, tvb_offset, tvb_transaction_end_offset, '{');
    603. 

  603.             tvb_current_offset = tvb_LBRKT;
    604. 

  604.             ti = proto_tree_add_text(megaco_tree, tvb, tvb_previous_offset, tvb_current_offset-tvb_previous_offset,
    605. 

  605.                 "%s",tvb_format_text(tvb, tvb_previous_offset, tvb_current_offset-tvb_previous_offset+1));
    606. 

  606.             message_body_tree = proto_item_add_subtree(ti, ett_megaco_message_body);
    607. 

  607. 

  608.             tvb_current_offset  = megaco_tvb_skip_wsp_return(tvb, tvb_current_offset-1);
    609. 

  609.             len = tvb_current_offset - tvb_offset;
    610. 

  610.             if (tree)
    611. 

  611.                 my_proto_tree_add_string(message_body_tree, hf_megaco_transaction, tvb,
    612. 

  612.                     tvb_previous_offset, tokenlen,
    613. 

  613.                     "Pending" );
    614. 

  614. 

  615.             if (!first) {
    616. 

  616.               col_append_str(pinfo->cinfo, COL_INFO, " ");
    617. 

  617.             }
    618. 

  618.             col_append_fstr(pinfo->cinfo, COL_INFO, "%s Pending",
    619. 

  619.                 tvb_format_text(tvb,tvb_offset,len));
    620. 

  620. 

  621.             if(tree)
    622. 

  622.                 my_proto_tree_add_string(message_body_tree, hf_megaco_transid, tvb,
    623. 

  623.                 tvb_offset, len,
    624. 

  624.                 tvb_format_text(tvb,tvb_offset,len));
    625. 

  625.             return;
    626. 

  626. 

  627.         /* transactionReply */
    628. 

  628.         case REPLYTOKEN:
    629. 

  629.             trx_type = GCP_TRX_REPLY;
    630. 

  630.             tvb_LBRKT  = tvb_find_guint8(tvb, tvb_offset, tvb_transaction_end_offset, '{');
    631. 

  631.             ti = proto_tree_add_text(megaco_tree, tvb, tvb_previous_offset, tvb_LBRKT-tvb_previous_offset,
    632. 

  632.                     "%s",tvb_format_text(tvb, tvb_previous_offset, tvb_LBRKT-tvb_previous_offset+1));
    633. 

  633.             message_body_tree = proto_item_add_subtree(ti, ett_megaco_message_body);
    634. 

  634. 

  635.             if (tree)
    636. 

  636.                 my_proto_tree_add_string(message_body_tree, hf_megaco_transaction, tvb,
    637. 

  637.                     tvb_previous_offset, tokenlen,
    638. 

  638.                     "Reply" );
    639. 

  639. 

  640.             tvb_offset  = tvb_find_guint8(tvb, tvb_previous_offset, tvb_transaction_end_offset, '=')+1;
    641. 

  641.             tvb_offset = megaco_tvb_skip_wsp(tvb, tvb_offset);
    642. 

  642.             tvb_current_offset  = megaco_tvb_skip_wsp_return(tvb, tvb_LBRKT-1);
    643. 

  643.             len = tvb_current_offset - tvb_offset;
    644. 

  644. 

  645.             col_add_fstr(pinfo->cinfo, COL_INFO, "%s Reply  ",
    646. 

  646.                   tvb_format_text(tvb,tvb_offset,len));
    647. 

  647.             trx_id = (guint)strtoul(tvb_format_text(tvb,tvb_offset,len),NULL,10);
    648. 

  648. 

  649.             if(tree)
    650. 

  650.                 my_proto_tree_add_string(message_body_tree, hf_megaco_transid, tvb,
    651. 

  651.                     tvb_offset, len, tvb_format_text(tvb,tvb_offset,len));
    652. 

  652. 

  653.             /* Find if we have a errorDescriptor or actionReplyList */
    654. 

  654.             tvb_offset = megaco_tvb_skip_wsp(tvb, tvb_LBRKT+1);
    655. 

  655.             tempchar = tvb_get_guint8(tvb,tvb_offset);
    656. 

  656.             if ((tempchar == 'E')||(tempchar == 'e')){
    657. 

  657.                 dissect_megaco_errordescriptor(tvb, megaco_tree, tvb_transaction_end_offset-1, tvb_offset);
    658. 

  658.                 return;
    659. 

  659.             }
    660. 

  660.             /* Offset should be at first printable char after { */
    661. 

  661.             tvb_previous_offset = tvb_offset;
    662. 

  662.             break;
    663. 

  663.         case TRANSTOKEN:
    664. 

  664.             /* TransactionRequest   */
    665. 

  665.             trx_type = GCP_TRX_REQUEST;
    666. 

  666.             ti = proto_tree_add_text(megaco_tree, tvb, tvb_previous_offset, tvb_current_offset-tvb_previous_offset,
    667. 

  667.                     "%s",tvb_format_text(tvb, tvb_previous_offset, tvb_current_offset-tvb_previous_offset+1));
    668. 

  668.             message_body_tree = proto_item_add_subtree(ti, ett_megaco_message_body);
    669. 

  669. 

  670.             if(tree)
    671. 

  671.                 my_proto_tree_add_string(message_body_tree, hf_megaco_transaction, tvb,
    672. 

  672.                     tvb_previous_offset, tokenlen,
    673. 

  673.                     "Request" );
    674. 

  674.             tvb_offset  = tvb_find_guint8(tvb, tvb_offset, tvb_transaction_end_offset, '=')+1;
    675. 

  675.             tvb_offset = megaco_tvb_skip_wsp(tvb, tvb_offset);
    676. 

  676.             tvb_current_offset  = megaco_tvb_skip_wsp_return(tvb, tvb_current_offset-1);
    677. 

  677.             len = tvb_current_offset - tvb_offset;
    678. 

  678.             if (!first) {
    679. 

  679.               col_append_str(pinfo->cinfo, COL_INFO, " ");
    680. 

  680.             }
    681. 

  681.             col_append_fstr(pinfo->cinfo, COL_INFO, "%s Request",
    682. 

  682.                   tvb_format_text(tvb,tvb_offset,len));
    683. 

  683.             trx_id = (guint)strtoul(tvb_format_text(tvb,tvb_offset,len),NULL,10);
    684. 

  684.             if(tree)
    685. 

  685.                 my_proto_tree_add_string(message_body_tree, hf_megaco_transid, tvb, tvb_offset,len,
    686. 

  686.                     tvb_format_text(tvb,tvb_offset,len));
    687. 

  687.             /* Offset should be at first printable char after { */
    688. 

  688.             tvb_previous_offset = megaco_tvb_skip_wsp(tvb, tvb_LBRKT+1);
    689. 

  689. 

  690.             break;
    691. 

  691.         default :
    692. 

  692.             ti = proto_tree_add_item(tree,proto_megaco,tvb, 0, -1, ENC_NA);
    693. 

  693.             expert_add_info_format(pinfo, ti, PI_MALFORMED, PI_ERROR,
    694. 

  694.                     "Sorry, can't understand errorDescriptor / transactionList = %s, can't parse it pos %u",
    695. 

  695.                         tvb_format_text(tvb,tvb_previous_offset,2),tvb_previous_offset);
    696. 

  696.             return;
    697. 

  697.         } /* end switch */
    698. 

  698. /*      Only these remains now
    699. 

  699.  *      transactionReply = ReplyToken EQUAL TransactionID LBRKT
    700. 

  700.  *          [ ImmAckRequiredToken COMMA]( errorDescriptor / actionReplyList ) RBRKT
    701. 

  701.  *          ReplyToken = ("Reply" / "P")
    702. 

  702.  *
    703. 

  703.  *      errorDescriptor   = ErrorToken EQUAL ErrorCode
    704. 

  704.  *                     LBRKT [quotedString] RBRKT
    705. 

  705.  *
    706. 

  706.  *      transactionRequest = TransToken EQUAL TransactionID LBRKT
    707. 

  707.  *          actionRequest *(COMMA actionRequest) RBRKT
    708. 

  708.  *          TransToken = ("Transaction" / "T")
    709. 

  709.  */
    710. 

  710. 

  711.         trx = gcp_trx(msg , trx_id , trx_type, keep_persistent_data);
    712. 

  712. 

  713.         /* Find Context */
    714. 

  714. nextcontext:
    715. 

  715. 

  716. 

  717. 

  718. 

  719.         tvb_next_offset = tvb_find_guint8(tvb, tvb_previous_offset, tvb_transaction_end_offset, '{');
    720. 

  720.         ti = proto_tree_add_text(megaco_tree, tvb, tvb_previous_offset, tvb_next_offset-tvb_previous_offset+1,
    721. 

  721.                 "%s", tvb_format_text(tvb, tvb_previous_offset, tvb_next_offset-tvb_previous_offset+1));
    722. 

  722.         megaco_context_tree = proto_item_add_subtree(ti, ett_megaco_context);
    723. 

  723. 

  724.         tvb_previous_offset = tvb_find_guint8(tvb, tvb_current_offset,
    725. 

  725.             tvb_transaction_end_offset, '=')+1;
    726. 

  726.         tvb_previous_offset = megaco_tvb_skip_wsp(tvb, tvb_previous_offset);
    727. 

  727.         if (tvb_current_offset >= tvb_next_offset) {
    728. 

  728.             expert_add_info_format(pinfo, ti, PI_MALFORMED, PI_ERROR, "[ Parse error: Invalid offset ]");
    729. 

  729.             return;
    730. 

  730.         }
    731. 

  731.         tvb_current_offset = tvb_next_offset;
    732. 

  732. 

  733. 

  734.         tokenlen = tvb_current_offset - tvb_previous_offset;
    735. 

  735.         tempchar = tvb_get_guint8(tvb, tvb_previous_offset );
    736. 

  736. 

  737.         if (tvb_get_guint8(tvb, tvb_current_offset-1 ) == ' '){
    738. 

  738.             tokenlen--;
    739. 

  739.         }
    740. 

  740. 

  741. 

  742.         switch ( tempchar ){
    743. 

  743.         case '$':
    744. 

  744.             ctx_id = CHOOSE_CONTEXT;
    745. 

  745.             my_proto_tree_add_string(megaco_context_tree, hf_megaco_Context, tvb,
    746. 

  746.                 tvb_previous_offset, 1,
    747. 

  747.                 "Choose one");
    748. 

  748.             col_append_str(pinfo->cinfo, COL_INFO, " |=Choose one");
    749. 

  749.             break;
    750. 

  750.         case '*':
    751. 

  751.             ctx_id = ALL_CONTEXTS;
    752. 

  752.             my_proto_tree_add_string(megaco_context_tree, hf_megaco_Context, tvb,
    753. 

  753.                 tvb_previous_offset, 1,
    754. 

  754.                 "All");
    755. 

  755.             col_append_str(pinfo->cinfo, COL_INFO, " |=All");
    756. 

  756.             break;
    757. 

  757.         case '-':
    758. 

  758.             ctx_id = NULL_CONTEXT;
    759. 

  759.             proto_tree_add_text(megaco_context_tree, tvb, tvb_previous_offset, tokenlen, "Context: NULL" );
    760. 

  760.             col_append_str(pinfo->cinfo, COL_INFO, " |=NULL");
    761. 

  761.             break;
    762. 

  762.         default:
    763. 

  763.             my_proto_tree_add_string(megaco_context_tree, hf_megaco_Context, tvb,
    764. 

  764.                 tvb_previous_offset, tokenlen,
    765. 

  765.                 tvb_format_text(tvb, tvb_previous_offset,
    766. 

  766.                 tokenlen));
    767. 

  767.             ctx_id = (guint)strtoul(tvb_format_text(tvb, tvb_previous_offset, tokenlen),NULL,10);
    768. 

  768. 

  769.             col_append_fstr(pinfo->cinfo, COL_INFO, " |=%s",tvb_format_text(tvb, tvb_previous_offset,tokenlen));
    770. 

  770.         }
    771. 

  771. 

  772.         ctx = gcp_ctx(msg,trx,ctx_id,keep_persistent_data);
    773. 

  773. 

  774.         /* Find Commands */
    775. 

  775. 

  776.         /* If Transaction is is Request, Reply or Pending */
    777. 

  777.         tvb_command_start_offset = megaco_tvb_skip_wsp(tvb, tvb_current_offset +1);
    778. 

  778.         tvb_command_end_offset = tvb_command_start_offset;
    779. 

  779. 

  780.         tvb_LBRKT = tvb_command_start_offset;
    781. 

  781.         tvb_RBRKT = tvb_command_start_offset;
    782. 

  782. 

  783.         /* The following loop find the individual contexts, commands and call the for every Descriptor a subroutine */
    784. 

  784. 

  785.         do {
    786. 

  786.             tvb_command_end_offset = tvb_find_guint8(tvb, tvb_command_end_offset +1,
    787. 

  787.                 tvb_transaction_end_offset, ',');
    788. 

  788. 

  789.             if ( tvb_command_end_offset == -1 || tvb_command_end_offset > tvb_transaction_end_offset){
    790. 

  790.                 tvb_command_end_offset = tvb_transaction_end_offset ;
    791. 

  791. 

  792.             }
    793. 

  793. 

  794.             /* checking how many left brackets are before the next comma */
    795. 

  795. 

  796.             while ( tvb_find_guint8(tvb, tvb_LBRKT+1,tvb_transaction_end_offset, '{') != -1
    797. 

  797.                 && (tvb_find_guint8(tvb, tvb_LBRKT+1,tvb_transaction_end_offset, '{') < tvb_command_end_offset)){
    798. 

  798. 

  799.                 tvb_LBRKT = tvb_find_guint8(tvb, tvb_LBRKT+1,
    800. 

  800.                     tvb_transaction_end_offset, '{');
    801. 

  801. 

  802.                 LBRKT_counter++;
    803. 

  803.             }
    804. 

  804. 

  805.             /* checking how many right brackets are before the next comma */
    806. 

  806. 

  807.             while ( (tvb_find_guint8(tvb, tvb_RBRKT+1,tvb_transaction_end_offset, '}') != -1 )
    808. 

  808.                     && (tvb_find_guint8(tvb, tvb_RBRKT+1,tvb_transaction_end_offset, '}') <= tvb_command_end_offset)
    809. 

  809.                 && LBRKT_counter != 0){
    810. 

  810. 

  811.                 tvb_RBRKT = tvb_find_guint8(tvb, tvb_RBRKT+1,
    812. 

  812.                     tvb_transaction_end_offset, '}');
    813. 

  813.                 RBRKT_counter++;
    814. 

  814. 

  815. 

  816.             }
    817. 

  817. 

  818.             /* If equal or more right brackets before the comma, one command is complete */
    819. 

  819. 

  820.             if ( LBRKT_counter <= RBRKT_counter ){
    821. 

  821. 

  822.                 tvb_current_offset  = tvb_find_guint8(tvb, tvb_command_start_offset,
    823. 

  823.                     tvb_transaction_end_offset, '{');
    824. 

  824. 

  825. 

  826.                 /* includes no descriptors */
    827. 

  827. 

  828.                 if ( LBRKT_counter == 0 ){
    829. 

  829. 

  830.                     tvb_current_offset = tvb_command_end_offset;
    831. 

  831. 

  832.                     /* the last command in a context */
    833. 

  833. 

  834.                     if ( tvb_find_guint8(tvb, tvb_command_start_offset, tvb_transaction_end_offset, '}') < tvb_current_offset
    835. 

  835.                         && tvb_find_guint8(tvb, tvb_command_start_offset, tvb_transaction_end_offset, '}') != -1){
    836. 

  836. 

  837.                         tvb_previous_offset  = tvb_find_guint8(tvb, tvb_command_start_offset,
    838. 

  838.                             tvb_transaction_end_offset, '}');
    839. 

  839. 

  840.                         len = tvb_previous_offset - tvb_command_start_offset;
    841. 

  841. 

  842.                         tvb_previous_offset = megaco_tvb_skip_wsp_return(tvb, tvb_previous_offset -1);
    843. 

  843. 

  844.                         tokenlen =  tvb_previous_offset - tvb_command_start_offset;
    845. 

  845. 

  846.                     }
    847. 

  847. 

  848.                     /* not the last command in a context*/
    849. 

  849. 

  850.                     else{
    851. 

  851.                         len =  tvb_current_offset - tvb_command_start_offset;
    852. 

  852.                         tvb_current_offset = megaco_tvb_skip_wsp_return(tvb, tvb_current_offset -1);
    853. 

  853. 

  854.                         tokenlen =  tvb_current_offset - tvb_command_start_offset;
    855. 

  855.                     }
    856. 

  856.                 }
    857. 

  857. 

  858.                 /* command includes descriptors */
    859. 

  859. 

  860.                 else{
    861. 

  861.                     len =  tvb_current_offset - tvb_command_start_offset;
    862. 

  862.                     tvb_current_offset = megaco_tvb_skip_wsp_return(tvb, tvb_current_offset -1);
    863. 

  863. 

  864.                     tokenlen =  tvb_current_offset - tvb_command_start_offset;
    865. 

  865.                 }
    866. 

  866. 

  867.                 /* if a next context is specified */
    868. 

  868. 

  869.                 if ( tvb_get_guint8(tvb, tvb_command_start_offset ) == 'C'){
    870. 

  870.                     tvb_current_offset = tvb_command_start_offset;
    871. 

  871.                     tvb_previous_offset = tvb_command_start_offset;
    872. 

  872.                     LBRKT_counter = 0;
    873. 

  873.                     RBRKT_counter = 0;
    874. 

  874.                     goto nextcontext;
    875. 

  875.                 }
    876. 

  876. 

  877.                 sub_ti = proto_tree_add_text(megaco_tree, tvb, tvb_command_start_offset, len+1,
    878. 

  878.                         "%s", tvb_format_text(tvb, tvb_command_start_offset, len+1));
    879. 

  879.                 megaco_tree_command_line = proto_item_add_subtree(sub_ti, ett_megaco_command_line);
    880. 

  880.                 /* creation of the megaco_tree_command_line additionally Command and Transaction ID will be printed in this line */
    881. 

  881.                 /* Changed to use the lines above. this code is saved if there is complaints
    882. 

  882.                 sub_ti = proto_tree_add_item(megaco_tree,hf_megaco_command_line,tvb,tvb_command_start_offset,tokenlen, ENC_ASCII|ENC_NA);
    883. 

  883.                 megaco_tree_command_line = proto_item_add_subtree(sub_ti, ett_megaco_command_line);
    884. 

  884.                 */
    885. 

  885. 

  886.                 tvb_next_offset = tvb_command_start_offset + tokenlen;
    887. 

  887. 

  888.                 /* Try to dissect Topology Descriptor before the command */
    889. 

  889. 				tempchar = tvb_get_guint8(tvb, tvb_command_start_offset);
    890. 

  890. 				if ( (tempchar >= 'a')&& (tempchar <= 'z')){
    891. 

  891.                     tempchar = tempchar - 0x20;
    892. 

  892. 				}
    893. 

  893.                 if ( tempchar == 'T') {
    894. 

  894.                     tempchar = tvb_get_guint8(tvb, tvb_command_start_offset+1);
    895. 

  895. 

  896.                     if ( (tempchar >= 'a')&& (tempchar <= 'z'))
    897. 

  897.                         tempchar = tempchar - 0x20;
    898. 

  898. 

  899.                     if ( tempchar == 'P' || tempchar == 'O'){
    900. 

  900.                         gint tvb_topology_end_offset = tvb_find_guint8(tvb, tvb_command_start_offset, tvb_transaction_end_offset, '}');
    901. 

  901.                         if ( tvb_topology_end_offset == -1 ){
    902. 

  902.                             expert_add_info_format(pinfo, sub_ti, PI_MALFORMED, PI_ERROR, "[ Parse error: Missing \"}\" ]");
    903. 

  903.                             return;
    904. 

  904.                         }
    905. 

  905. 

  906.                         tvb_command_start_offset = tvb_find_guint8(tvb, tvb_command_start_offset, tvb_transaction_end_offset, '{');
    907. 

  907.                         if ( tvb_command_start_offset == -1 ){
    908. 

  908.                             expert_add_info_format(pinfo, sub_ti, PI_MALFORMED, PI_ERROR, "[ Parse error: Missing \"{\" ]");
    909. 

  909.                             return;
    910. 

  910.                         }
    911. 

  911.                         dissect_megaco_topologydescriptor(tvb, megaco_tree_command_line, tvb_topology_end_offset-1, tvb_command_start_offset+1);
    912. 

  912. 

  913.                         /* Command after Topology Descriptor */
    914. 

  914.                         tvb_command_start_offset = tvb_find_guint8(tvb, tvb_topology_end_offset + 1,
    915. 

  915.                             tvb_transaction_end_offset, ',');
    916. 

  916. 

  917.                         if ( tvb_command_start_offset == -1 ){
    918. 

  918.                             /* No Command present after Topology Descriptor */
    919. 

  919.                             break;
    920. 

  920. 

  921.                         } else {
    922. 

  922.                             /* Try to find the first char of the command */
    923. 

  923.                             tvb_command_start_offset =  megaco_tvb_skip_wsp(tvb, tvb_command_start_offset + 1);
    924. 

  924.                             tvb_next_offset = tvb_find_guint8(tvb, tvb_command_start_offset, tvb_transaction_end_offset, '{');
    925. 

  925.                             continue;
    926. 

  926.                         }
    927. 

  927. 

  928.                     }
    929. 

  929.                 }
    930. 

  930. 

  931.                 /* Additional value */
    932. 

  932. 

  933.                 if ( tvb_get_guint8(tvb, tvb_command_start_offset ) == 'O'){
    934. 

  934. 

  935.                     proto_tree_add_text(megaco_tree_command_line, tvb, tvb_command_start_offset, 2, "O- indicates an optional command" );
    936. 

  936.                     tvb_command_start_offset = tvb_command_start_offset+2;
    937. 

  937. 

  938.                 }
    939. 

  939. 

  940.                 /* Additional value */
    941. 

  941. 

  942.                 if ( tvb_get_guint8(tvb, tvb_command_start_offset ) == 'W'){
    943. 

  943. 

  944.                     proto_tree_add_text(megaco_tree_command_line, tvb, tvb_command_start_offset, 2, "W- indicates a wildcarded response to a command" );
    945. 

  945.                     tvb_command_start_offset = tvb_command_start_offset+2;
    946. 

  946. 

  947.                 }
    948. 

  948. 

  949. 

  950. 

  951.                 tvb_offset  = tvb_find_guint8(tvb, tvb_command_start_offset,
    952. 

  952.                     tvb_transaction_end_offset, '=');
    953. 

  953.                 if (tvb_offset == -1 ) {
    954. 

  954.                     expert_add_info_format(pinfo, sub_ti, PI_MALFORMED, PI_ERROR, "[ Parse error: Missing \"=\" ]");
    955. 

  955.                     return;
    956. 

  956.                 }
    957. 

  957.                 tvb_offset = megaco_tvb_skip_wsp_return(tvb, tvb_offset -1);
    958. 

  958.                 tokenlen = tvb_offset - tvb_command_start_offset;
    959. 

  959. 

  960.                 tempchar = tvb_get_guint8(tvb, tvb_command_start_offset);
    961. 

  961.                 if ( (tempchar >= 'a')&& (tempchar <= 'z'))
    962. 

  962.                     tempchar = tempchar - 0x20;
    963. 

  963. 

  964.                 if ( tempchar != 'E' ){
    965. 

  965. 

  966. 					/* Short form used */
    967. 

  967.                     if ( tvb_get_guint8(tvb, 0 ) == '!'){
    968. 

  968. 

  969.                         switch ( tempchar ){
    970. 

  970. 

  971.                         case 'A':
    972. 

  972. 

  973.                             tempchar = tvb_get_guint8(tvb, tvb_command_start_offset+1);
    974. 

  974.                             if ( (tempchar >= 'a')&& (tempchar <= 'z'))
    975. 

  975.                                 tempchar = tempchar - 0x20;
    976. 

  976. 

  977.                             switch ( tempchar ){
    978. 

  978. 

  979.                             case 'V':
    980. 

  980.                                 switch(trx_type) {
    981. 

  981.                                     case GCP_TRX_REQUEST: cmd_type = GCP_CMD_AUDITVAL_REPLY; break;
    982. 

  982.                                     case GCP_TRX_REPLY: cmd_type = GCP_CMD_AUDITVAL_REQ; break;
    983. 

  983.                                     default: cmd_type = GCP_CMD_NONE; break;
    984. 

  984.                                 }
    985. 

  985. 

  986.                                 my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    987. 

  987.                                     tvb_command_start_offset, tokenlen,
    988. 

  988.                                     "AuditValue");
    989. 

  989.                                 col_append_str(pinfo->cinfo, COL_INFO, " AuditValue");
    990. 

  990.                                 break;
    991. 

  991. 

  992.                             case 'C':
    993. 

  993.                                 switch(trx_type) {
    994. 

  994.                                     case GCP_TRX_REQUEST: cmd_type = GCP_CMD_AUDITCAP_REQ; break;
    995. 

  995.                                     case GCP_TRX_REPLY: cmd_type = GCP_CMD_AUDITCAP_REPLY; break;
    996. 

  996.                                     default: cmd_type = GCP_CMD_NONE; break;
    997. 

  997.                                 }
    998. 

  998.                                 my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    999. 

  999.                                     tvb_command_start_offset, tokenlen,
    1000. 

  1000.                                     "AuditCapability");
    1001. 

  1001.                                 col_append_str(pinfo->cinfo, COL_INFO, " AuditCapability");
    1002. 

  1002.                                 break;
    1003. 

  1003. 

  1004.                             default:
    1005. 

  1005.                                 switch(trx_type) {
    1006. 

  1006.                                     case GCP_TRX_REQUEST: cmd_type = GCP_CMD_ADD_REQ; break;
    1007. 

  1007.                                     case GCP_TRX_REPLY: cmd_type = GCP_CMD_ADD_REPLY; break;
    1008. 

  1008.                                     default: cmd_type = GCP_CMD_NONE; break;
    1009. 

  1009.                                 }
    1010. 

  1010. 

  1011.                                 my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    1012. 

  1012.                                     tvb_command_start_offset, tokenlen,
    1013. 

  1013.                                     "Add");
    1014. 

  1014.                                 col_append_str(pinfo->cinfo, COL_INFO, " Add");
    1015. 

  1015.                                 break;
    1016. 

  1016.                             }
    1017. 

  1017.                             break;
    1018. 

  1018. 

  1019.                         case 'N':
    1020. 

  1020.                             switch(trx_type) {
    1021. 

  1021.                                 case GCP_TRX_REQUEST: cmd_type = GCP_CMD_NOTIFY_REQ; break;
    1022. 

  1022.                                 case GCP_TRX_REPLY: cmd_type = GCP_CMD_NOTIFY_REPLY; break;
    1023. 

  1023.                                 default: cmd_type = GCP_CMD_NONE; break;
    1024. 

  1024.                             }
    1025. 

  1025. 

  1026.                             my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    1027. 

  1027.                                 tvb_command_start_offset, tokenlen,
    1028. 

  1028.                                 "Notify");
    1029. 

  1029.                                 col_append_str(pinfo->cinfo, COL_INFO, " Notify");
    1030. 

  1030.                             break;
    1031. 

  1031. 

  1032.                         case 'M':
    1033. 

  1033. 

  1034.                             tempchar = tvb_get_guint8(tvb, tvb_command_start_offset+1);
    1035. 

  1035.                             if ( (tempchar >= 'a')&& (tempchar <= 'z'))
    1036. 

  1036.                                 tempchar = tempchar - 0x20;
    1037. 

  1037. 

  1038.                             switch ( tempchar ){
    1039. 

  1039.                             case 'F':
    1040. 

  1040.                                 switch(trx_type) {
    1041. 

  1041.                                     case GCP_TRX_REQUEST: cmd_type = GCP_CMD_MOD_REQ; break;
    1042. 

  1042.                                     case GCP_TRX_REPLY: cmd_type = GCP_CMD_MOD_REPLY; break;
    1043. 

  1043.                                     default: cmd_type = GCP_CMD_NONE; break;
    1044. 

  1044.                                 }
    1045. 

  1045. 

  1046.                                 my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    1047. 

  1047.                                     tvb_command_start_offset, tokenlen,
    1048. 

  1048.                                     "Modify");
    1049. 

  1049.                                 col_append_str(pinfo->cinfo, COL_INFO, " Modify");
    1050. 

  1050.                                 break;
    1051. 

  1051. 

  1052.                             case 'V':
    1053. 

  1053.                                 switch(trx_type) {
    1054. 

  1054.                                     case GCP_TRX_REQUEST: cmd_type = GCP_CMD_MOVE_REQ; break;
    1055. 

  1055.                                     case GCP_TRX_REPLY: cmd_type = GCP_CMD_MOVE_REPLY; break;
    1056. 

  1056.                                     default: cmd_type = GCP_CMD_NONE; break;
    1057. 

  1057.                                 }
    1058. 

  1058.                                 my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    1059. 

  1059.                                     tvb_command_start_offset, tokenlen,
    1060. 

  1060.                                     "Move");
    1061. 

  1061.                                 col_append_str(pinfo->cinfo, COL_INFO, " Move");
    1062. 

  1062.                                 break;
    1063. 

  1063.                             }
    1064. 

  1064.                             break;
    1065. 

  1065. 

  1066.                         case 'P':
    1067. 

  1067.                             cmd_type = GCP_CMD_NONE;
    1068. 

  1068.                             /*
    1069. 

  1069.                             PackagesToken   = ("Packages"   / "PG")
    1070. 

  1070.                             PendingToken    = ("Pending"    / "PN")
    1071. 

  1071.                             PriorityToken   = ("Priority"   / "PR")
    1072. 

  1072.                             ProfileToken    = ("Profile"    / "PF")
    1073. 

  1073.                             */
    1074. 

  1074.                             tempchar = tvb_get_guint8(tvb, tvb_command_start_offset+1);
    1075. 

  1075.                             if ( (tempchar >= 'a')&& (tempchar <= 'z'))
    1076. 

  1076.                                 tempchar = tempchar - 0x20;
    1077. 

  1077. 

  1078.                             switch ( tempchar ){
    1079. 

  1079.                             case 'G':
    1080. 

  1080.                                 my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    1081. 

  1081.                                     tvb_command_start_offset, tokenlen,
    1082. 

  1082.                                     "Packages");
    1083. 

  1083.                                 break;
    1084. 

  1084.                             case 'N':
    1085. 

  1085.                                 my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    1086. 

  1086.                                     tvb_command_start_offset, tokenlen,
    1087. 

  1087.                                     "Pending");
    1088. 

  1088.                                 break;
    1089. 

  1089.                             case 'R':
    1090. 

  1090.                                 my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    1091. 

  1091.                                     tvb_command_start_offset, tokenlen,
    1092. 

  1092.                                     "Priority");
    1093. 

  1093.                                 break;
    1094. 

  1094.                             case 'F':
    1095. 

  1095.                                 my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    1096. 

  1096.                                     tvb_command_start_offset, tokenlen,
    1097. 

  1097.                                     "Profile");
    1098. 

  1098.                                 break;
    1099. 

  1099.                             }
    1100. 

  1100.                             break;
    1101. 

  1101. 

  1102.                         case 'S':
    1103. 

  1103.                             tempchar = tvb_get_guint8(tvb, tvb_command_start_offset+1);
    1104. 

  1104.                             if ( (tempchar >= 'a')&& (tempchar <= 'z'))
    1105. 

  1105.                                 tempchar = tempchar - 0x20;
    1106. 

  1106. 

  1107.                             switch ( tempchar ){
    1108. 

  1108. 

  1109.                             case 'C':
    1110. 

  1110.                                 switch(trx_type) {
    1111. 

  1111.                                     case GCP_TRX_REQUEST: cmd_type = GCP_CMD_SVCCHG_REQ; break;
    1112. 

  1112.                                     case GCP_TRX_REPLY: cmd_type = GCP_CMD_SVCCHG_REPLY; break;
    1113. 

  1113.                                     default: cmd_type = GCP_CMD_NONE; break;
    1114. 

  1114.                                 }
    1115. 

  1115.                                 my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    1116. 

  1116.                                     tvb_command_start_offset, tokenlen,
    1117. 

  1117.                                     "ServiceChange");
    1118. 

  1118.                                 break;
    1119. 

  1119. 

  1120.                             default:
    1121. 

  1121.                                 switch(trx_type) {
    1122. 

  1122.                                     case GCP_TRX_REQUEST: cmd_type = GCP_CMD_SUB_REQ; break;
    1123. 

  1123.                                     case GCP_TRX_REPLY: cmd_type = GCP_CMD_SUB_REPLY; break;
    1124. 

  1124.                                     default: cmd_type = GCP_CMD_NONE; break;
    1125. 

  1125.                                 }
    1126. 

  1126.                                 my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    1127. 

  1127.                                     tvb_command_start_offset, tokenlen,
    1128. 

  1128.                                     "Subtract");
    1129. 

  1129.                                 col_append_str(pinfo->cinfo, COL_INFO, " Subtract");
    1130. 

  1130.                                 break;
    1131. 

  1131.                             }
    1132. 

  1132.                             break;
    1133. 

  1133. 

  1134.                         default:
    1135. 

  1135. 							{
    1136. 

  1136. 								proto_item *item;
    1137. 

  1137. 

  1138. 								tokenlen =  (tvb_RBRKT+1) - tvb_previous_offset;
    1139. 

  1139. 								tvb_ensure_bytes_exist(tvb, tvb_previous_offset, tokenlen);
    1140. 

  1140. 								item = proto_tree_add_string(megaco_tree, hf_megaco_error_Frame, tvb,
    1141. 

  1141. 									tvb_previous_offset, tokenlen,
    1142. 

  1142. 									"No Command detectable !");
    1143. 

  1143. 								proto_item_append_text(item,"[ tempchar 0x%x ]", tempchar);
    1144. 

  1144. 								return;
    1145. 

  1145. 							}
    1146. 

  1146.                         }
    1147. 

  1147.                     }
    1148. 

  1148.                     else{
    1149. 

  1149.                         gchar* command = tvb_format_text(tvb, tvb_command_start_offset, tokenlen);
    1150. 

  1150. 

  1151.                         if ( g_str_equal(command,"Subtract") ) {
    1152. 

  1152.                             switch(trx_type) {
    1153. 

  1153.                                 case GCP_TRX_REQUEST: cmd_type = GCP_CMD_SUB_REQ; break;
    1154. 

  1154.                                 case GCP_TRX_REPLY: cmd_type = GCP_CMD_SUB_REPLY; break;
    1155. 

  1155.                                 default: cmd_type = GCP_CMD_NONE; break;
    1156. 

  1156.                             }
    1157. 

  1157.                         } else if ( g_str_equal(command,"AuditValue") ) {
    1158. 

  1158.                             switch(trx_type) {
    1159. 

  1159.                                 case GCP_TRX_REQUEST: cmd_type = GCP_CMD_AUDITVAL_REPLY; break;
    1160. 

  1160.                                 case GCP_TRX_REPLY: cmd_type = GCP_CMD_AUDITVAL_REQ; break;
    1161. 

  1161.                                 default: cmd_type = GCP_CMD_NONE; break;
    1162. 

  1162.                             }
    1163. 

  1163.                         } else if ( g_str_equal(command,"AuditCapability") ) {
    1164. 

  1164.                             switch(trx_type) {
    1165. 

  1165.                                 case GCP_TRX_REQUEST: cmd_type = GCP_CMD_AUDITCAP_REQ; break;
    1166. 

  1166.                                 case GCP_TRX_REPLY: cmd_type = GCP_CMD_AUDITCAP_REPLY; break;
    1167. 

  1167.                                 default: cmd_type = GCP_CMD_NONE; break;
    1168. 

  1168.                             }
    1169. 

  1169.                         } else if ( g_str_equal(command,"Add") ) {
    1170. 

  1170.                             switch(trx_type) {
    1171. 

  1171.                                 case GCP_TRX_REQUEST: cmd_type = GCP_CMD_ADD_REQ; break;
    1172. 

  1172.                                 case GCP_TRX_REPLY: cmd_type = GCP_CMD_ADD_REPLY; break;
    1173. 

  1173.                                 default: cmd_type = GCP_CMD_NONE; break;
    1174. 

  1174.                             }
    1175. 

  1175.                         } else if ( g_str_equal(command,"Notify") ) {
    1176. 

  1176.                             switch(trx_type) {
    1177. 

  1177.                                 case GCP_TRX_REQUEST: cmd_type = GCP_CMD_NOTIFY_REQ; break;
    1178. 

  1178.                                 case GCP_TRX_REPLY: cmd_type = GCP_CMD_NOTIFY_REPLY; break;
    1179. 

  1179.                                 default: cmd_type = GCP_CMD_NONE; break;
    1180. 

  1180.                             }
    1181. 

  1181.                         } else if ( g_str_equal(command,"Modify") ) {
    1182. 

  1182.                             switch(trx_type) {
    1183. 

  1183.                                 case GCP_TRX_REQUEST: cmd_type = GCP_CMD_MOD_REQ; break;
    1184. 

  1184.                                 case GCP_TRX_REPLY: cmd_type = GCP_CMD_MOD_REPLY; break;
    1185. 

  1185.                                 default: cmd_type = GCP_CMD_NONE; break;
    1186. 

  1186.                             }
    1187. 

  1187.                         } else if ( g_str_equal(command,"Move") ) {
    1188. 

  1188.                             switch(trx_type) {
    1189. 

  1189.                                 case GCP_TRX_REQUEST: cmd_type = GCP_CMD_MOVE_REQ; break;
    1190. 

  1190.                                 case GCP_TRX_REPLY: cmd_type = GCP_CMD_MOVE_REPLY; break;
    1191. 

  1191.                                 default: cmd_type = GCP_CMD_NONE; break;
    1192. 

  1192.                             }
    1193. 

  1193.                         } else if ( g_str_equal(command,"ServiceChange") ) {
    1194. 

  1194.                             switch(trx_type) {
    1195. 

  1195.                                 case GCP_TRX_REQUEST: cmd_type = GCP_CMD_SVCCHG_REQ; break;
    1196. 

  1196.                                 case GCP_TRX_REPLY: cmd_type = GCP_CMD_SVCCHG_REPLY; break;
    1197. 

  1197.                                 default: cmd_type = GCP_CMD_NONE; break;
    1198. 

  1198.                             }
    1199. 

  1199.                         } else if ( g_str_equal(command,"Subtract") ) {
    1200. 

  1200.                             switch(trx_type) {
    1201. 

  1201.                                 case GCP_TRX_REQUEST: cmd_type = GCP_CMD_SUB_REQ; break;
    1202. 

  1202.                                 case GCP_TRX_REPLY: cmd_type = GCP_CMD_SUB_REPLY; break;
    1203. 

  1203.                                 default: cmd_type = GCP_CMD_NONE; break;
    1204. 

  1204.                             }
    1205. 

  1205.                         } else {
    1206. 

  1206.                             switch(trx_type) {
    1207. 

  1207.                                 case GCP_TRX_REQUEST: cmd_type = GCP_CMD_OTHER_REQ; break;
    1208. 

  1208.                                 case GCP_TRX_REPLY: cmd_type = GCP_CMD_REPLY; break;
    1209. 

  1209.                                 default: cmd_type = GCP_CMD_NONE; break;
    1210. 

  1210.                             }
    1211. 

  1211.                         }
    1212. 

  1212. 

  1213. 

  1214.                         my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_command, tvb,
    1215. 

  1215.                             tvb_command_start_offset, tokenlen,
    1216. 

  1216.                             tvb_format_text(tvb, tvb_command_start_offset,
    1217. 

  1217.                             tokenlen));
    1218. 

  1218.                             col_append_fstr(pinfo->cinfo, COL_INFO, " %s",command);
    1219. 

  1219.                     }
    1220. 

  1220. 

  1221.                     if (cmd_type == GCP_CMD_NONE && trx_type == GCP_TRX_REPLY) {
    1222. 

  1222.                         cmd_type = GCP_CMD_REPLY;
    1223. 

  1223.                     }
    1224. 

  1224. 

  1225.                     if (cmd_type != GCP_CMD_NONE) {
    1226. 

  1226.                         cmd = gcp_cmd(msg, trx, ctx, cmd_type, tvb_command_start_offset, keep_persistent_data);
    1227. 

  1227.                         tap_queue_packet(megaco_tap, pinfo, cmd);
    1228. 

  1228.                     }
    1229. 

  1229. 

  1230.                     tvb_offset  = tvb_find_guint8(tvb, tvb_command_start_offset,
    1231. 

  1231.                         tvb_transaction_end_offset, '=');
    1232. 

  1232.                     if (tvb_offset == -1 ) {
    1233. 

  1233.                         expert_add_info_format(pinfo, sub_ti, PI_MALFORMED, PI_ERROR, "[ Parse error: Missing \"=\" ]");
    1234. 

  1234.                         return;
    1235. 

  1235.                     }
    1236. 

  1236.                     tvb_offset = megaco_tvb_skip_wsp(tvb, tvb_offset+1);
    1237. 

  1237.                     tokenlen = tvb_next_offset - tvb_offset;
    1238. 

  1238.                     if (tokenlen+1 <= 0) {
    1239. 

  1239.                         expert_add_info_format(pinfo, sub_ti, PI_MALFORMED, PI_ERROR, "[ Parse error: Invalid token length (%d) ]", tokenlen+1);
    1240. 

  1240.                         return;
    1241. 

  1241.                     }
    1242. 

  1242. 

  1243.                     tempchar = tvb_get_guint8(tvb, tvb_offset);
    1244. 

  1244.                     if ( (tempchar >= 'a')&& (tempchar <= 'z'))
    1245. 

  1245.                         tempchar = tempchar - 0x20;
    1246. 

  1246. 

  1247.                     term = wmem_new0(wmem_packet_scope(), gcp_term_t);
    1248. 

  1248.                     wild_term = GCP_WILDCARD_NONE;
    1249. 

  1249.                     term->type = GCP_TERM_TYPE_UNKNOWN;
    1250. 

  1250. 

  1251.                     switch ( tempchar ){
    1252. 

  1252. 

  1253.                     case 'E':
    1254. 

  1254.                         if ((tokenlen+1 > (int) sizeof(TermID))) {
    1255. 

  1255.                             expert_add_info_format(pinfo, sub_ti, PI_MALFORMED, PI_ERROR, "[ Parse error: Invalid TermID length (%d) ]", tokenlen+1);
    1256. 

  1256.                             return;
    1257. 

  1257.                         }
    1258. 

  1258.                         tvb_get_nstringz0(tvb,tvb_offset,tokenlen+1,TermID);
    1259. 

  1259.                         TermID[0] = 'e';
    1260. 

  1260. 

  1261.                         term->len = tokenlen;
    1262. 

  1262.                         term->str = (const gchar*)(term->buffer = TermID);
    1263. 

  1263. 

  1264.                         gcp_cmd_add_term(msg, trx, cmd, term, wild_term, keep_persistent_data);
    1265. 

  1265. 

  1266.                         /*** TERM ***/
    1267. 

  1267.                         my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_termid, tvb,
    1268. 

  1268.                             tvb_offset, tokenlen,
    1269. 

  1269.                             TermID);
    1270. 

  1270.                         break;
    1271. 

  1271. 

  1272.                     case '*':
    1273. 

  1273.                         wild_term = GCP_WILDCARD_ALL;
    1274. 

  1274.                         term->len = 1;
    1275. 

  1275.                         term->buffer = (const guint8*)(term->str = "*");
    1276. 

  1276. 

  1277.                         gcp_cmd_add_term(msg, trx, cmd, term, wild_term, keep_persistent_data);
    1278. 

  1278. 

  1279.                         my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_termid, tvb,
    1280. 

  1280.                             tvb_offset, tokenlen,
    1281. 

  1281.                             "WildCard all");
    1282. 

  1282.                             col_append_str(pinfo->cinfo, COL_INFO, "=*");
    1283. 

  1283.                         break;
    1284. 

  1284. 

  1285.                     case '$':
    1286. 

  1286.                         wild_term = GCP_WILDCARD_CHOOSE;
    1287. 

  1287. 

  1288.                         term->len = 1;
    1289. 

  1289.                         term->buffer = (term->str = "$");
    1290. 

  1290. 

  1291.                         gcp_cmd_add_term(msg, trx, cmd, term, wild_term, keep_persistent_data);
    1292. 

  1292. 

  1293.                         my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_termid, tvb,
    1294. 

  1294.                             tvb_offset, tokenlen,
    1295. 

  1295.                             "WildCard any");
    1296. 

  1296.                             col_append_str(pinfo->cinfo, COL_INFO, "=$");
    1297. 

  1297.                         break;
    1298. 

  1298. 

  1299.                     default:
    1300. 

  1300.                         /*** TERM ***/
    1301. 

  1301.                         my_proto_tree_add_string(megaco_tree_command_line, hf_megaco_termid, tvb,
    1302. 

  1302.                             tvb_offset, tokenlen,
    1303. 

  1303.                             tvb_format_text(tvb, tvb_offset,
    1304. 

  1304.                             tokenlen));
    1305. 

  1305. 

  1306.                         term->len = tokenlen;
    1307. 

  1307.                         term->buffer = (const guint8*)(term->str = tvb_format_text(tvb, tvb_offset, tokenlen));
    1308. 

  1308. 

  1309.                         gcp_cmd_add_term(msg, trx, cmd, term, wild_term, keep_persistent_data);
    1310. 

  1310. 

  1311.                         col_append_fstr(pinfo->cinfo, COL_INFO, "=%s",tvb_format_text(tvb, tvb_offset,tokenlen));
    1312. 

  1312.                         break;
    1313. 

  1313.                     }
    1314. 

  1314. 

  1315.             }
    1316. 

  1316.             /* Dissect the Descriptors */
    1317. 

  1317. 

  1318. 

  1319.             if ( LBRKT_counter != 0 && tvb_current_offset != tvb_command_end_offset){
    1320. 

  1320. 

  1321.                 tvb_descriptors_start_offset  = tvb_find_guint8(tvb, tvb_command_start_offset,
    1322. 

  1322.                     tvb_transaction_end_offset, '{');
    1323. 

  1323. 

  1324.                 tvb_descriptors_end_offset = tvb_descriptors_start_offset;
    1325. 

  1325.                 if ( tvb_descriptors_end_offset > tvb_transaction_end_offset )
    1326. 

  1326.                     tvb_descriptors_end_offset = tvb_transaction_end_offset;
    1327. 

  1327. 

  1328.                 while ( LBRKT_counter > 0 ){
    1329. 

  1329. 

  1330.                     tvb_descriptors_end_offset = tvb_find_guint8(tvb, tvb_descriptors_end_offset+1,
    1331. 

  1331.                         tvb_transaction_end_offset, '}');
    1332. 

  1332. 

  1333.                     LBRKT_counter--;
    1334. 

  1334. 

  1335.                 }
    1336. 

  1336. 

  1337.                 tempchar = tvb_get_guint8(tvb, tvb_command_start_offset);
    1338. 

  1338. 

  1339.                 if ( tempchar == 'E'|| tempchar == 'e'){
    1340. 

  1340.                     dissect_megaco_descriptors(tvb, megaco_tree, pinfo, tvb_command_start_offset-1,tvb_descriptors_end_offset);
    1341. 

  1341.                 }
    1342. 

  1342.                 else {
    1343. 

  1343.                     dissect_megaco_descriptors(tvb, megaco_tree, pinfo, tvb_descriptors_start_offset,tvb_descriptors_end_offset);
    1344. 

  1344.                 }
    1345. 

  1345.             }
    1346. 

  1346.             RBRKT_counter = 0;
    1347. 

  1347.             LBRKT_counter = 0;
    1348. 

  1348.             tvb_command_start_offset = megaco_tvb_skip_wsp(tvb, tvb_command_end_offset +1);
    1349. 

  1349.             tvb_LBRKT = tvb_command_start_offset;
    1350. 

  1350.             tvb_RBRKT = tvb_command_start_offset;
    1351. 

  1351. 

  1352.             }
    1353. 

  1353. 

  1354.         } while ( tvb_command_end_offset < tvb_transaction_end_offset );
    1355. 

  1355. 

  1356.         if (keep_persistent_data) {
    1357. 

  1357.             gcp_msg_to_str(msg,keep_persistent_data);
    1358. 

  1358.             gcp_analyze_msg(megaco_tree, pinfo, tvb, msg, &megaco_ctx_ids, &ei_megaco_errored_command);
    1359. 

  1359.         }
    1360. 

  1360. 

  1361.         tvb_next_offset = tvb_transaction_end_offset;
    1362. 

  1362. 

  1363.     first = 0;
    1364. 

  1364.     }
    1365. 

  1365.     while( tvb_transaction_end_offset < tvb_len - 2);
    1366. 

  1366. 

  1367.     if(global_megaco_raw_text){
    1368. 

  1368.         tvb_raw_text_add(tvb, megaco_tree);
    1369. 

  1369.     }
    1370. 

  1370. }
    1371. 

  1371. 

  1372. #define MEGACO_MODEM_TOKEN          1
    1373. 

  1373. #define MEGACO_MUX_TOKEN            2
    1374. 

  1374. #define MEGACO_MEDIA_TOKEN          3
    1375. 

  1375. #define MEGACO_SIGNALS_TOKEN        4
    1376. 

  1376. #define MEGACO_SERVICES_TOKEN       5
    1377. 

  1377. #define MEGACO_STATS_TOKEN          6
    1378. 

  1378. #define MEGACO_ERROR_TOKEN          7
    1379. 

  1379. #define MEGACO_EVENTS_TOKEN         8
    1380. 

  1380. #define MEGACO_AUDIT_TOKEN          9
    1381. 

  1381. #define MEGACO_DIGITMAP_TOKEN       10
    1382. 

  1382. #define MEGACO_OE_TOKEN             11
    1383. 

  1383. #define MEGACO_TOPOLOGY_TOKEN       12
    1384. 

  1384. #define MEGACO_PACKAGES_TOKEN       13
    1385. 

  1385. 

  1386. static const megaco_tokens_t megaco_descriptors_names[] = {
    1387. 

  1387.     { "Unknown-token",              NULL }, /* 0 Pad so that the real headers start at index 1 */
    1388. 

  1388.     { "Modem",                      "MD" }, /* 1 */
    1389. 

  1389.     { "Mux",                        "MX" }, /* 2 */
    1390. 

  1390.     { "Media",                      "M" },  /* 3 */
    1391. 

  1391.     { "Signals",                    "SG" }, /* 4 */
    1392. 

  1392.     { "Services",                   "SV" }, /* 5 */
    1393. 

  1393.     { "Statistics",                 "SA" }, /* 6 */
    1394. 

  1394.     { "Error",                      "ER" }, /* 7 */
    1395. 

  1395.     { "Events",                     "E" },  /* 8 */
    1396. 

  1396.     { "Audit",                      "AT" }, /* 9 */
    1397. 

  1397.     { "DigitMap",                   "DM" }, /* 10 */
    1398. 

  1398.     { "ObservedEvents",             "OE" }, /* 11 */
    1399. 

  1399.     { "Topology",                   "TP" }, /* 12 */
    1400. 

  1400.     { "Packages",                   "PG" }, /* 13 */
    1401. 

  1401. };
    1402. 

  1402. 

  1403. /* Returns index of megaco_tokens_t */
    1404. 

  1404. /* note - also called by dissect_megaco_auditdescriptor */
    1405. 

  1405. static gint find_megaco_descriptors_names(tvbuff_t *tvb, int offset, guint header_len)
    1406. 

  1406. {
    1407. 

  1407.     guint i;
    1408. 

  1408. 

  1409.     for (i = 1; i < array_length(megaco_descriptors_names); i++) {
    1410. 

  1410.         if (header_len == strlen(megaco_descriptors_names[i].name) &&
    1411. 

  1411.             tvb_strncaseeql(tvb, offset, megaco_descriptors_names[i].name, header_len) == 0)
    1412. 

  1412.             return i;
    1413. 

  1413.         if (megaco_descriptors_names[i].compact_name != NULL &&
    1414. 

  1414.             header_len == strlen(megaco_descriptors_names[i].compact_name) &&
    1415. 

  1415.             tvb_strncaseeql(tvb, offset, megaco_descriptors_names[i].compact_name, header_len) == 0)
    1416. 

  1416.             return i;
    1417. 

  1417.     }
    1418. 

  1418.     return -1;
    1419. 

  1419. }
    1420. 

  1420. 

  1421. static void
    1422. 

  1422. dissect_megaco_descriptors(tvbuff_t *tvb, proto_tree *megaco_tree_command_line, packet_info *pinfo, gint tvb_descriptors_start_offset, gint tvb_descriptors_end_offset)
    1423. 

  1423. {
    1424. 

  1424.     gint        tvb_len, token_index, tvb_offset, temp_offset;
    1425. 

  1425.     gint        tvb_current_offset,tvb_previous_offset,tokenlen;
    1426. 

  1426.     gint        tvb_RBRKT, tvb_LBRKT;
    1427. 

  1427. 

  1428.     tvb_len     = tvb_length(tvb);
    1429. 

  1429. 

  1430. 

  1431.     tvb_LBRKT = megaco_tvb_skip_wsp(tvb, tvb_descriptors_start_offset +1);
    1432. 

  1432. 

  1433.     tvb_previous_offset = tvb_LBRKT;
    1434. 

  1434.     tvb_RBRKT = tvb_descriptors_start_offset;
    1435. 

  1435. 

  1436. 

  1437.     do {
    1438. 

  1438. 

  1439.         tvb_RBRKT = tvb_find_guint8(tvb, tvb_RBRKT+1,
    1440. 

  1440.             tvb_len, '}');
    1441. 

  1441.         tvb_LBRKT = tvb_find_guint8(tvb, tvb_LBRKT,
    1442. 

  1442.             tvb_len, '{');
    1443. 

  1443. 

  1444.         tvb_current_offset  = tvb_find_guint8(tvb, tvb_previous_offset,
    1445. 

  1445.             tvb_len, ',');
    1446. 

  1446. 

  1447.         if (tvb_current_offset == -1 || tvb_current_offset > tvb_descriptors_end_offset){
    1448. 

  1448.             tvb_current_offset = tvb_descriptors_end_offset;
    1449. 

  1449. 

  1450.         }
    1451. 

  1451.         if (tvb_current_offset <= tvb_previous_offset) {
    1452. 

  1452.             expert_add_info_format(pinfo, megaco_tree_command_line, PI_MALFORMED, PI_ERROR, "[ Parse error: Invalid offset ]");
    1453. 

  1453.             return;
    1454. 

  1454.         }
    1455. 

  1455. 

  1456. 

  1457. 

  1458.         /* Descriptor includes no parameters */
    1459. 

  1459. 

  1460.         if ( tvb_LBRKT > tvb_current_offset || tvb_LBRKT == -1 ){
    1461. 

  1461. 

  1462.             if ( tvb_current_offset > tvb_RBRKT ){
    1463. 

  1463.                 tvb_current_offset = tvb_RBRKT;
    1464. 

  1464.             }
    1465. 

  1465. 

  1466.             tvb_RBRKT = megaco_tvb_skip_wsp_return(tvb, tvb_current_offset-1)-1;
    1467. 

  1467.         }
    1468. 

  1468. 

  1469.         /* Descriptor includes Parameters */
    1470. 

  1470.         if ( (tvb_current_offset > tvb_LBRKT && tvb_LBRKT != -1)){
    1471. 

  1471. 

  1472.             while ( tvb_LBRKT != -1 && tvb_RBRKT > tvb_LBRKT ){
    1473. 

  1473. 

  1474. 

  1475.                 tvb_LBRKT  = tvb_find_guint8(tvb, tvb_LBRKT+1,
    1476. 

  1476.                     tvb_len, '{');
    1477. 

  1477.                 if ( tvb_LBRKT < tvb_RBRKT && tvb_LBRKT != -1)
    1478. 

  1478.                     tvb_RBRKT  = tvb_find_guint8(tvb, tvb_RBRKT+1,tvb_len, '}');
    1479. 

  1479.             }
    1480. 

  1480. 

  1481.         }
    1482. 

  1482. 

  1483.         /* Find token length */
    1484. 

  1484.         for (tvb_offset=tvb_previous_offset; tvb_offset < tvb_descriptors_end_offset -1; tvb_offset++){
    1485. 

  1485.             if (!isalpha(tvb_get_guint8(tvb, tvb_offset ))){
    1486. 

  1486.                 break;
    1487. 

  1487.             }
    1488. 

  1488.         }
    1489. 

  1489.         tokenlen =  tvb_offset - tvb_previous_offset;
    1490. 

  1490.         token_index = find_megaco_descriptors_names(tvb, tvb_previous_offset, tokenlen);
    1491. 

  1491.         if (tvb_RBRKT > tvb_descriptors_end_offset) tvb_RBRKT = tvb_descriptors_end_offset;
    1492. 

  1492.         switch ( token_index ){
    1493. 

  1493.         case MEGACO_MODEM_TOKEN:
    1494. 

  1494.             dissect_megaco_modemdescriptor(tvb, megaco_tree_command_line, tvb_RBRKT, tvb_previous_offset);
    1495. 

  1495.             break;
    1496. 

  1496.         case MEGACO_MUX_TOKEN:
    1497. 

  1497.             dissect_megaco_multiplexdescriptor(tvb, megaco_tree_command_line, tvb_RBRKT, tvb_previous_offset);
    1498. 

  1498.             break;
    1499. 

  1499.         case MEGACO_MEDIA_TOKEN:
    1500. 

  1500.             /*TODO: Move this to the top when all branches fixed !!!*/
    1501. 

  1501.             temp_offset = tvb_find_guint8(tvb, tvb_previous_offset,tvb_descriptors_end_offset, '{');
    1502. 

  1502.             tokenlen =  temp_offset - tvb_previous_offset+1;
    1503. 

  1503.             proto_tree_add_text(megaco_tree_command_line, tvb, tvb_previous_offset, tokenlen,
    1504. 

  1504.                 "%s", tvb_format_text(tvb, tvb_previous_offset, tokenlen));
    1505. 

  1505. 

  1506.             tvb_previous_offset = megaco_tvb_skip_wsp(tvb, temp_offset +1);
    1507. 

  1507.             dissect_megaco_mediadescriptor(tvb, megaco_tree_command_line, pinfo, tvb_RBRKT, tvb_previous_offset);
    1508. 

  1508.             break;
    1509. 

  1509.         case MEGACO_SIGNALS_TOKEN:
    1510. 

  1510.             dissect_megaco_signaldescriptor(tvb, pinfo, megaco_tree_command_line, tvb_RBRKT, tvb_previous_offset);
    1511. 

  1511.             break;
    1512. 

  1512.         case MEGACO_SERVICES_TOKEN:
    1513. 

  1513.             dissect_megaco_servicechangedescriptor(tvb, megaco_tree_command_line, tvb_RBRKT, tvb_previous_offset);
    1514. 

  1514.             break;
    1515. 

  1515.         case MEGACO_STATS_TOKEN:
    1516. 

  1516.             dissect_megaco_statisticsdescriptor(tvb, megaco_tree_command_line, tvb_RBRKT, tvb_previous_offset);
    1517. 

  1517.             break;
    1518. 

  1518.         case MEGACO_ERROR_TOKEN:
    1519. 

  1519.             dissect_megaco_errordescriptor(tvb, megaco_tree_command_line, tvb_RBRKT, tvb_previous_offset);
    1520. 

  1520.             break;
    1521. 

  1521.         case MEGACO_EVENTS_TOKEN:
    1522. 

  1522.             dissect_megaco_eventsdescriptor(tvb, pinfo, megaco_tree_command_line, tvb_RBRKT, tvb_previous_offset);
    1523. 

  1523.             break;
    1524. 

  1524.         case MEGACO_AUDIT_TOKEN:
    1525. 

  1525.             dissect_megaco_auditdescriptor(tvb, megaco_tree_command_line, pinfo, tvb_RBRKT, tvb_previous_offset);
    1526. 

  1526.             break;
    1527. 

  1527.         case MEGACO_DIGITMAP_TOKEN:
    1528. 

  1528.             dissect_megaco_digitmapdescriptor(tvb, megaco_tree_command_line, tvb_RBRKT, tvb_previous_offset);
    1529. 

  1529.             break;
    1530. 

  1530.         case MEGACO_OE_TOKEN:
    1531. 

  1531.             /* ObservedEventsToken */
    1532. 

  1532.             dissect_megaco_observedeventsdescriptor(tvb, pinfo, megaco_tree_command_line, tvb_RBRKT, tvb_previous_offset);
    1533. 

  1533.             break;
    1534. 

  1534.         case MEGACO_TOPOLOGY_TOKEN:
    1535. 

  1535.             dissect_megaco_topologydescriptor(tvb, megaco_tree_command_line, tvb_RBRKT, tvb_previous_offset);
    1536. 

  1536.             break;
    1537. 

  1537.         case MEGACO_PACKAGES_TOKEN:
    1538. 

  1538.             dissect_megaco_Packagesdescriptor(tvb, megaco_tree_command_line, tvb_RBRKT, tvb_previous_offset);
    1539. 

  1539.             break;
    1540. 

  1540.         default:
    1541. 

  1541.             tokenlen =  (tvb_RBRKT+1) - tvb_previous_offset;
    1542. 

  1542.             proto_tree_add_string(megaco_tree_command_line, hf_megaco_error_Frame, tvb,
    1543. 

  1543.                 tvb_previous_offset, tokenlen,
    1544. 

  1544.                 "No Descriptor detectable !");
    1545. 

  1545.             break;
    1546. 

  1546.         }
    1547. 

  1547. 

  1548.         tvb_current_offset      = tvb_find_guint8(tvb, tvb_RBRKT, tvb_len, ',');
    1549. 

  1549.         if (tvb_current_offset == -1 || tvb_descriptors_end_offset < tvb_current_offset){
    1550. 

  1550.             tvb_current_offset = tvb_descriptors_end_offset;
    1551. 

  1551.         }
    1552. 

  1552.         tvb_previous_offset = megaco_tvb_skip_wsp(tvb, tvb_current_offset+1);
    1553. 

  1553.         tvb_LBRKT = tvb_previous_offset;
    1554. 

  1554.         tvb_RBRKT = tvb_previous_offset;
    1555. 

  1555. 

  1556.     } while ( tvb_current_offset < tvb_descriptors_end_offset );
    1557. 

  1557. 

  1558. }
    1559. 

  1559. 

  1560. static void
    1561. 

  1561. dissect_megaco_modemdescriptor(tvbuff_t *tvb, proto_tree *megaco_tree_command_line,  gint tvb_RBRKT, gint tvb_previous_offset)
    1562. 

  1562. {
    1563. 

  1563. 

  1564.     gint    tokenlen;
    1565. 

  1565. 

  1566.     tokenlen =  (tvb_RBRKT+1) - tvb_previous_offset;
    1567. 

  1567.     proto_tree_add_string(megaco_tree_command_line, hf_megaco_modem_descriptor, tvb,
    1568. 

  1568.                             tvb_previous_offset, tokenlen,
    1569. 

  1569.                             tvb_format_text(tvb, tvb_previous_offset,
    1570. 

  1570.                             tokenlen));
    1571. 

  1571. 

  1572. }
    1573. 

  1573. static void
    1574. 

  1574. dissect_megaco_multiplexdescriptor(tvbuff_t *tvb, proto_tree *megaco_tree_command_line,  gint tvb_RBRKT, gint tvb_previous_offset)
    1575. 

  1575. {
    1576. 

  1576. 

  1577.     gint    tokenlen;
    1578. 

  1578. 

  1579.     tokenlen =  (tvb_RBRKT+1) - tvb_previous_offset;
    1580. 

  1580.     proto_tree_add_string(megaco_tree_command_line, hf_megaco_multiplex_descriptor, tvb,
    1581. 

  1581.                             tvb_previous_offset, tokenlen,
    1582. 

  1582.                             tvb_format_text(tvb, tvb_previous_offset,
    1583. 

  1583.                             tokenlen));
    1584. 

  1584. 

  1585. }
    1586. 

  1586. 

  1587. /* mediaDescriptor = MediaToken LBRKT mediaParm *(COMMA mediaParm) RBRKT
    1588. 

  1588.  *  MediaToken = ("Media" / "M")
    1589. 

  1589.  *
    1590. 

  1590.  *      mediaParm = (streamParm / streamDescriptor /terminationStateDescriptor)
    1591. 

  1591.  *
    1592. 

  1592.  *  ; at-most one terminationStateDescriptor
    1593. 

  1593.  *  ; and either streamParm(s) or streamDescriptor(s) but not both
    1594. 

  1594.  *          streamParm = ( localDescriptor / remoteDescriptor /localControlDescriptor )
    1595. 

  1595.  *              localDescriptor = LocalToken LBRKT octetString RBRKT
    1596. 

  1596.  *                          LocalToken = ("Local" / "L")
    1597. 

  1597.  *                          octetString = *(nonEscapeChar)
    1598. 

  1598.  *                                  nonEscapeChar = ( "\}" / %x01-7C / %x7E-FF )
    1599. 

  1599.  *              remoteDescriptor = RemoteToken LBRKT octetString RBRKT
    1600. 

  1600.  *                          RemoteToken = ("Remote" / "R")
    1601. 

  1601.  *              localControlDescriptor = LocalControlToken LBRKT localParm*(COMMA localParm) RBRKT
    1602. 

  1602.  *                          LocalControlToken = ("LocalControl" / "O")
    1603. 

  1603.  *                          localParm = ( streamMode / propertyParm / reservedValueMode
    1604. 

  1604.  *          streamDescriptor = StreamToken EQUAL StreamID LBRKT streamParm*(COMMA streamParm) RBRKT
    1605. 

  1605.  *                          StreamToken = ("Stream" / "ST")
    1606. 

  1606.  *          terminationStateDescriptor = TerminationStateToken LBRKTterminationStateParm
    1607. 

  1607.  *                              *( COMMA terminationStateParm ) RBRKT
    1608. 

  1608.  *                          TerminationStateToken = ("TerminationState" / "TS")
    1609. 

  1609.  *                          terminationStateParm =(propertyParm / serviceStates / eventBufferControl )
    1610. 

  1610.  */
    1611. 

  1611. 

  1612. #define MEGACO_LOCAL_TOKEN              1
    1613. 

  1613. #define MEGACO_REMOTE_TOKEN             2
    1614. 

  1614. #define MEGACO_LOCAL_CONTROL_TOKEN      3
    1615. 

  1615. #define MEGACO_STREAM_TOKEN             4
    1616. 

  1616. #define MEGACO_TERMINATION_STATE_DESC   5
    1617. 

  1617. 

  1618. static const megaco_tokens_t megaco_mediaParm_names[] = {
    1619. 

  1619.     { "Unknown-token",              NULL }, /* 0 Pad so that the real headers start at index 1 */
    1620. 

  1620.     { "Local",                      "L" },  /* 1 */
    1621. 

  1621.     { "Remote",                     "R" },  /* 2 */
    1622. 

  1622.     { "LocalControl",               "O" },  /* 3 */
    1623. 

  1623.     { "Stream",                     "ST" }, /* 4 */
    1624. 

  1624.     { "TerminationState",           "TS" }, /* 5 */
    1625. 

  1625. };
    1626. 

  1626. 

  1627. /* Returns index of megaco_tokens_t */
    1628. 

  1628. static gint find_megaco_mediaParm_names(tvbuff_t *tvb, int offset, guint header_len)
    1629. 

  1629. {
    1630. 

  1630.     guint i;
    1631. 

  1631. 

  1632.     for (i = 1; i < array_length(megaco_mediaParm_names); i++) {
    1633. 

  1633.         if (header_len == strlen(megaco_mediaParm_names[i].name) &&
    1634. 

  1634.             tvb_strncaseeql(tvb, offset, megaco_mediaParm_names[i].name, header_len) == 0)
    1635. 

  1635.             return i;
    1636. 

  1636.         if (megaco_mediaParm_names[i].compact_name != NULL &&
    1637. 

  1637.             header_len == strlen(megaco_mediaParm_names[i].compact_name) &&
    1638. 

  1638.             tvb_strncaseeql(tvb, offset, megaco_mediaParm_names[i].compact_name, header_len) == 0)
    1639. 

  1639.             return i;
    1640. 

  1640.     }
    1641. 

  1641. 

  1642.     return -1;
    1643. 

  1643. }
    1644. 

  1644. 

  1645. static void
    1646. 

  1646. dissect_megaco_mediadescriptor(tvbuff_t *tvb, proto_tree *megaco_tree_command_line,packet_info *pinfo,  gint tvb_last_RBRKT, gint tvb_previous_offset)
    1647. 

  1647. {
    1648. 

  1648. 

  1649.     gint    tokenlen, tvb_LBRKT, tvb_RBRKT;
    1650. 

  1650.     gint    tvb_next_offset, tvb_current_offset, tvb_offset,  equal_offset;
    1651. 

  1651.     gint    mediaParm;
    1652. 

  1652. 

  1653. 

  1654.     proto_tree  *megaco_mediadescriptor_tree, *megaco_mediadescriptor_ti;
    1655. 

  1655. 

  1656.     /*
    1657. 

  1657.     megaco_mediadescriptor_ti = proto_tree_add_text(megaco_tree_command_line,tvb,tvb_previous_offset,tokenlen,"Media Descriptor");
    1658. 

  1658.     megaco_mediadescriptor_tree = proto_item_add_subtree(megaco_mediadescriptor_ti, ett_megaco_mediadescriptor);
    1659. 

  1659.     */
    1660. 

  1660.     while ( tvb_previous_offset < tvb_last_RBRKT){
    1661. 

  1661.         /* Start of token */
    1662. 

  1662.         tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_previous_offset);
    1663. 

  1663. 

  1664.         /* Find token length */
    1665. 

  1665.         for (tvb_next_offset=tvb_current_offset; tvb_next_offset < tvb_last_RBRKT; tvb_next_offset++){
    1666. 

  1666.                 if (!isalpha(tvb_get_guint8(tvb, tvb_next_offset ))){
    1667. 

  1667.                 break;
    1668. 

  1668.             }
    1669. 

  1669.         }
    1670. 

  1670.         tokenlen = tvb_next_offset - tvb_current_offset;
    1671. 

  1671. 

  1672.         mediaParm = find_megaco_mediaParm_names(tvb, tvb_current_offset, tokenlen);
    1673. 

  1673. 

  1674.         tvb_LBRKT = tvb_find_guint8(tvb, tvb_next_offset , tvb_last_RBRKT, '{');
    1675. 

  1675.         tvb_next_offset = tvb_find_guint8(tvb, tvb_current_offset+1 , tvb_last_RBRKT, '}');
    1676. 

  1676.         tvb_RBRKT = tvb_next_offset;
    1677. 

  1677. 

  1678.         tokenlen = tvb_LBRKT - tvb_current_offset +1;
    1679. 

  1679.         megaco_mediadescriptor_ti = proto_tree_add_text(megaco_tree_command_line,tvb,tvb_current_offset,
    1680. 

  1680.                 tokenlen,"%s",tvb_format_text(tvb, tvb_current_offset,tokenlen));
    1681. 

  1681. 

  1682.         switch ( mediaParm ){
    1683. 

  1683.         case MEGACO_LOCAL_TOKEN:
    1684. 

  1684.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_LBRKT+1);
    1685. 

  1685.             dissect_megaco_Localdescriptor(tvb,megaco_tree_command_line , pinfo,
    1686. 

  1686.                 tvb_RBRKT, tvb_current_offset);
    1687. 

  1687.             tvb_current_offset = tvb_RBRKT;
    1688. 

  1688.             break;
    1689. 

  1689.         case MEGACO_REMOTE_TOKEN:
    1690. 

  1690.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_LBRKT+1);
    1691. 

  1691.             dissect_megaco_Localdescriptor(tvb,megaco_tree_command_line , pinfo,
    1692. 

  1692.                 tvb_RBRKT, tvb_current_offset);
    1693. 

  1693.             tvb_current_offset = tvb_RBRKT;
    1694. 

  1694.             break;
    1695. 

  1695.         case MEGACO_LOCAL_CONTROL_TOKEN:
    1696. 

  1696.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_LBRKT+1);
    1697. 

  1697.             dissect_megaco_LocalControldescriptor(tvb,megaco_tree_command_line, pinfo ,
    1698. 

  1698.                 tvb_RBRKT, tvb_current_offset);
    1699. 

  1699.             tvb_current_offset = tvb_RBRKT;
    1700. 

  1700.             break;
    1701. 

  1701.         case MEGACO_STREAM_TOKEN:
    1702. 

  1702.             megaco_mediadescriptor_tree = proto_item_add_subtree(megaco_mediadescriptor_ti, ett_megaco_mediadescriptor);
    1703. 

  1703. 

  1704.             equal_offset = tvb_find_guint8(tvb, tvb_previous_offset, tvb_last_RBRKT, '=');
    1705. 

  1705.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, equal_offset+1);
    1706. 

  1706.             tvb_offset = megaco_tvb_skip_wsp_return(tvb, tvb_LBRKT-1);
    1707. 

  1707.             tokenlen =  tvb_offset - tvb_current_offset;
    1708. 

  1708. 

  1709.             proto_tree_add_string(megaco_mediadescriptor_tree, hf_megaco_streamid, tvb,
    1710. 

  1710.                 tvb_current_offset, tokenlen, tvb_format_text(tvb, tvb_current_offset,tokenlen));
    1711. 

  1711.             tvb_previous_offset = tvb_LBRKT+1;
    1712. 

  1712.             continue;
    1713. 

  1713.         case MEGACO_TERMINATION_STATE_DESC:
    1714. 

  1714.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_LBRKT+1);
    1715. 

  1715.             dissect_megaco_TerminationStatedescriptor(tvb,megaco_tree_command_line ,
    1716. 

  1716.                 tvb_RBRKT, tvb_current_offset);
    1717. 

  1717.             tvb_current_offset = tvb_RBRKT;
    1718. 

  1718.             break;
    1719. 

  1719.         default:
    1720. 

  1720.             break;
    1721. 

  1721.         };
    1722. 

  1722.         /* more parameters ? */
    1723. 

  1723.         tvb_next_offset = tvb_find_guint8(tvb, tvb_current_offset+1 , tvb_last_RBRKT, ',');
    1724. 

  1724.         if (tvb_next_offset > tvb_last_RBRKT) tvb_next_offset = tvb_last_RBRKT;
    1725. 

  1725.         if ( tvb_next_offset != -1 ){
    1726. 

  1726.             tokenlen = tvb_next_offset - tvb_RBRKT+1;
    1727. 

  1727.             proto_tree_add_text(megaco_tree_command_line, tvb, tvb_RBRKT, tokenlen,
    1728. 

  1728.                 "%s", tvb_format_text(tvb, tvb_RBRKT, tokenlen));
    1729. 

  1729.             tvb_previous_offset = tvb_next_offset+1;
    1730. 

  1730.         }else{
    1731. 

  1731.             /* Add the trailing '}'*/
    1732. 

  1732.             proto_tree_add_text(megaco_tree_command_line, tvb, tvb_RBRKT, 1,
    1733. 

  1733.                 "%s", tvb_format_text(tvb, tvb_RBRKT, 1));
    1734. 

  1734.             tvb_previous_offset = tvb_last_RBRKT;
    1735. 

  1735.         }
    1736. 

  1736. 

  1737.     } /* End while */
    1738. 

  1738. }
    1739. 

  1739. 

  1740. static void
    1741. 

  1741. dissect_megaco_h245(tvbuff_t *tvb, packet_info *pinfo, proto_tree *megaco_tree, gint offset, gint len, gchar *msg)
    1742. 

  1742. {
    1743. 

  1743.     /*proto_item *item;*/
    1744. 

  1744.     /*proto_tree *tree;*/
    1745. 

  1745. 

  1746.     /*item=proto_tree_add_string(megaco_tree, hf_megaco_h245, tvb,
    1747. 

  1747.         offset, len, msg );
    1748. 

  1748.         */
    1749. 

  1749.     /*item = */proto_tree_add_text(megaco_tree, tvb, offset, len, "%s", msg);
    1750. 

  1750. 

  1751.     /*tree = proto_item_add_subtree(item, ett_megaco_h245); */
    1752. 

  1752. 

  1753.     /* arbitrary maximum length */
    1754. 

  1754.     if(len<20480){
    1755. 

  1755.         int i;
    1756. 

  1756.         tvbuff_t *h245_tvb;
    1757. 

  1757.         guint8 *buf = (guint8 *)wmem_alloc(pinfo->pool, 10240);
    1758. 

  1758. 

  1759.         /* first, skip to where the encoded pdu starts, this is
    1760. 

  1760.            the first hex digit after the '=' char.
    1761. 

  1761.         */
    1762. 

  1762.         while(1){
    1763. 

  1763.             if((*msg==0)||(*msg=='\n')){
    1764. 

  1764.                 return;
    1765. 

  1765.             }
    1766. 

  1766.             if(*msg=='='){
    1767. 

  1767.                 msg++;
    1768. 

  1768.                 break;
    1769. 

  1769.             }
    1770. 

  1770.             msg++;
    1771. 

  1771.         }
    1772. 

  1772.         while(1){
    1773. 

  1773.             if((*msg==0)||(*msg=='\n')){
    1774. 

  1774.                 return;
    1775. 

  1775.             }
    1776. 

  1776.             if( ((*msg>='0')&&(*msg<='9'))
    1777. 

  1777.             ||  ((*msg>='a')&&(*msg<='f'))
    1778. 

  1778.             ||  ((*msg>='A')&&(*msg<='F'))){
    1779. 

  1779.                 break;
    1780. 

  1780.             }
    1781. 

  1781.             msg++;
    1782. 

  1782.         }
    1783. 

  1783.         i=0;
    1784. 

  1784.         while( ((*msg>='0')&&(*msg<='9'))
    1785. 

  1785.              ||((*msg>='a')&&(*msg<='f'))
    1786. 

  1786.              ||((*msg>='A')&&(*msg<='F'))  ){
    1787. 

  1787.             int val;
    1788. 

  1788.             if((*msg>='0')&&(*msg<='9')){
    1789. 

  1789.                 val=(*msg)-'0';
    1790. 

  1790.             } else if((*msg>='a')&&(*msg<='f')){
    1791. 

  1791.                 val=(*msg)-'a'+10;
    1792. 

  1792.             } else if((*msg>='A')&&(*msg<='F')){
    1793. 

  1793.                 val=(*msg)-'A'+10;
    1794. 

  1794.             } else {
    1795. 

  1795.                 return;
    1796. 

  1796.             }
    1797. 

  1797.             val<<=4;
    1798. 

  1798.             msg++;
    1799. 

  1799.             if((*msg>='0')&&(*msg<='9')){
    1800. 

  1800.                 val|=(*msg)-'0';
    1801. 

  1801.             } else if((*msg>='a')&&(*msg<='f')){
    1802. 

  1802.                 val|=(*msg)-'a'+10;
    1803. 

  1803.             } else if((*msg>='A')&&(*msg<='F')){
    1804. 

  1804.                 val|=(*msg)-'A'+10;
    1805. 

  1805.             } else {
    1806. 

  1806.                 return;
    1807. 

  1807.             }
    1808. 

  1808.             msg++;
    1809. 

  1809. 

  1810.             buf[i]=(guint8)val;
    1811. 

  1811.             i++;
    1812. 

  1812.         }
    1813. 

  1813.         if(i==0){
    1814. 

  1814.             return;
    1815. 

  1815.         }
    1816. 

  1816.         h245_tvb = tvb_new_child_real_data(tvb, buf,i,i);
    1817. 

  1817.         add_new_data_source(pinfo, h245_tvb, "H.245 over MEGACO");
    1818. 

  1818.         /* should go through a handle, however,  the two h245 entry
    1819. 

  1819.            points are different, one is over tpkt and the other is raw
    1820. 

  1820.         */
    1821. 

  1821.         call_dissector(h245_handle, h245_tvb, pinfo, top_tree);
    1822. 

  1822. /*      dissect_h245_MultimediaSystemControlMessage(h245_tvb, pinfo, tree);*/
    1823. 

  1823.     }
    1824. 

  1824. }
    1825. 

  1825. 

  1826. static void
    1827. 

  1827. dissect_megaco_h324_h223caprn(tvbuff_t *tvb, packet_info *pinfo, proto_tree *megaco_tree, gint offset _U_, gint len, gchar *msg)
    1828. 

  1828. {
    1829. 

  1829.     asn1_ctx_t actx;
    1830. 

  1830. 

  1831.     /* arbitrary maximum length */
    1832. 

  1832.     if(len<20480){
    1833. 

  1833.         int i;
    1834. 

  1834.         tvbuff_t *h245_tvb;
    1835. 

  1835.         guint8 *buf = (guint8 *)wmem_alloc(pinfo->pool, 10240);
    1836. 

  1836. 

  1837.         /* first, skip to where the encoded pdu starts, this is
    1838. 

  1838.            the first hex digit after the '=' char.
    1839. 

  1839.         */
    1840. 

  1840.         while(1){
    1841. 

  1841.             if((*msg==0)||(*msg=='\n')){
    1842. 

  1842.                 return;
    1843. 

  1843.             }
    1844. 

  1844.             if(*msg=='='){
    1845. 

  1845.                 msg++;
    1846. 

  1846.                 break;
    1847. 

  1847.             }
    1848. 

  1848.             msg++;
    1849. 

  1849.         }
    1850. 

  1850.         while(1){
    1851. 

  1851.             if((*msg==0)||(*msg=='\n')){
    1852. 

  1852.                 return;
    1853. 

  1853.             }
    1854. 

  1854.             if( ((*msg>='0')&&(*msg<='9'))
    1855. 

  1855.             ||  ((*msg>='a')&&(*msg<='f'))
    1856. 

  1856.             ||  ((*msg>='A')&&(*msg<='F'))){
    1857. 

  1857.                 break;
    1858. 

  1858.             }
    1859. 

  1859.             msg++;
    1860. 

  1860.         }
    1861. 

  1861.         i=0;
    1862. 

  1862.         while( ((*msg>='0')&&(*msg<='9'))
    1863. 

  1863.              ||((*msg>='a')&&(*msg<='f'))
    1864. 

  1864.              ||((*msg>='A')&&(*msg<='F'))  ){
    1865. 

  1865.             int val;
    1866. 

  1866.             if((*msg>='0')&&(*msg<='9')){
    1867. 

  1867.                 val=(*msg)-'0';
    1868. 

  1868.             } else if((*msg>='a')&&(*msg<='f')){
    1869. 

  1869.                 val=(*msg)-'a'+10;
    1870. 

  1870.             } else if((*msg>='A')&&(*msg<='F')){
    1871. 

  1871.                 val=(*msg)-'A'+10;
    1872. 

  1872.             } else {
    1873. 

  1873.                 return;
    1874. 

  1874.             }
    1875. 

  1875.             val<<=4;
    1876. 

  1876.             msg++;
    1877. 

  1877.             if((*msg>='0')&&(*msg<='9')){
    1878. 

  1878.                 val|=(*msg)-'0';
    1879. 

  1879.             } else if((*msg>='a')&&(*msg<='f')){
    1880. 

  1880.                 val|=(*msg)-'a'+10;
    1881. 

  1881.             } else if((*msg>='A')&&(*msg<='F')){
    1882. 

  1882.                 val|=(*msg)-'A'+10;
    1883. 

  1883.             } else {
    1884. 

  1884.                 return;
    1885. 

  1885.             }
    1886. 

  1886.             msg++;
    1887. 

  1887. 

  1888.             buf[i]=(guint8)val;
    1889. 

  1889.             i++;
    1890. 

  1890.         }
    1891. 

  1891.         if(i==0){
    1892. 

  1892.             return;
    1893. 

  1893.         }
    1894. 

  1894.         h245_tvb = tvb_new_child_real_data(tvb, buf,i,i);
    1895. 

  1895.         add_new_data_source(pinfo, h245_tvb, "H.245 over MEGACO");
    1896. 

  1896.         /* should go through a handle, however,  the two h245 entry
    1897. 

  1897.            points are different, one is over tpkt and the other is raw
    1898. 

  1898.         */
    1899. 

  1899.         asn1_ctx_init(&actx, ASN1_ENC_PER, TRUE, pinfo);
    1900. 

  1900.         dissect_h245_H223Capability(h245_tvb, 0, &actx, megaco_tree, hf_megaco_h223Capability);
    1901. 

  1901.     }
    1902. 

  1902. }
    1903. 

  1903. 

  1904. static void
    1905. 

  1905. dissect_megaco_eventsdescriptor(tvbuff_t *tvb, packet_info *pinfo, proto_tree *megaco_tree_command_line,  gint tvb_RBRKT, gint tvb_previous_offset)
    1906. 

  1906. {
    1907. 

  1907. 

  1908.     gint tokenlen, tvb_current_offset, tvb_next_offset, tvb_help_offset;
    1909. 

  1909.     gint tvb_events_end_offset, tvb_LBRKT;
    1910. 

  1910.     proto_tree  *megaco_eventsdescriptor_tree, *megaco_eventsdescriptor_ti;
    1911. 

  1911. 

  1912.     guint8 tempchar;
    1913. 

  1913.     gint requested_event_start_offset, requested_event_end_offset;
    1914. 

  1914.     proto_tree  *megaco_requestedevent_tree, *megaco_requestedevent_ti;
    1915. 

  1915. 

  1916.     requested_event_start_offset    = 0;
    1917. 

  1917.     requested_event_end_offset      = 0;
    1918. 

  1918. 

  1919.     tokenlen =  (tvb_RBRKT+1) - tvb_previous_offset;
    1920. 

  1920. 

  1921.     megaco_eventsdescriptor_ti = proto_tree_add_text(megaco_tree_command_line, tvb, tvb_previous_offset, tokenlen,
    1922. 

  1922.         "%s", tvb_format_text(tvb, tvb_previous_offset, tokenlen));
    1923. 

  1923. 

  1924.     /*
    1925. 

  1925.     megaco_eventsdescriptor_ti = proto_tree_add_item(megaco_tree_command_line,hf_megaco_events_descriptor,tvb,tvb_previous_offset,tokenlen, ENC_ASCII|ENC_NA);
    1926. 

  1926.     */
    1927. 

  1927.     megaco_eventsdescriptor_tree = proto_item_add_subtree(megaco_eventsdescriptor_ti, ett_megaco_eventsdescriptor);
    1928. 

  1928. 

  1929.     tvb_current_offset = tvb_find_guint8(tvb, tvb_previous_offset, tvb_RBRKT, '=');
    1930. 

  1930.     tvb_next_offset = tvb_find_guint8(tvb, tvb_previous_offset, tvb_RBRKT, '{');
    1931. 

  1931. 

  1932.     if ( tvb_current_offset < tvb_RBRKT && tvb_current_offset != -1 ){
    1933. 

  1933. 

  1934.         tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_current_offset +1);
    1935. 

  1935.         tvb_help_offset = megaco_tvb_skip_wsp_return(tvb, tvb_next_offset-1);
    1936. 

  1936. 

  1937.         tokenlen =  tvb_help_offset - tvb_current_offset;
    1938. 

  1938. 

  1939.         proto_tree_add_string(megaco_eventsdescriptor_tree, hf_megaco_requestid, tvb,
    1940. 

  1940.             tvb_current_offset, tokenlen,
    1941. 

  1941.             tvb_format_text(tvb, tvb_current_offset,
    1942. 

  1942.             tokenlen));
    1943. 

  1943. 

  1944.         tvb_events_end_offset   = tvb_RBRKT;
    1945. 

  1945. 

  1946.         tvb_RBRKT = tvb_next_offset+1;
    1947. 

  1947.         tvb_LBRKT = tvb_next_offset+1;
    1948. 

  1948.         tvb_previous_offset = megaco_tvb_skip_wsp(tvb, tvb_next_offset+1);
    1949. 

  1949. 

  1950. 

  1951.         do {
    1952. 

  1952. 

  1953.             tvb_RBRKT = tvb_find_guint8(tvb, tvb_RBRKT+1,
    1954. 

  1954.                 tvb_events_end_offset, '}');
    1955. 

  1955.             tvb_LBRKT = tvb_find_guint8(tvb, tvb_LBRKT,
    1956. 

  1956.                 tvb_events_end_offset, '{');
    1957. 

  1957. 

  1958.             tvb_current_offset  = tvb_find_guint8(tvb, tvb_previous_offset,
    1959. 

  1959.                 tvb_events_end_offset, ',');
    1960. 

  1960. 

  1961.             if (tvb_current_offset == -1 || tvb_current_offset > tvb_events_end_offset){
    1962. 

  1962.                 tvb_current_offset = tvb_events_end_offset;
    1963. 

  1963.             }
    1964. 

  1964. 

  1965. 

  1966.             /* Descriptor includes no parameters */
    1967. 

  1967. 

  1968.             if ( tvb_LBRKT > tvb_current_offset || tvb_LBRKT == -1 ){
    1969. 

  1969. 

  1970.                 tvb_RBRKT = megaco_tvb_skip_wsp_return(tvb, tvb_current_offset-1)-1;
    1971. 

  1971.             }
    1972. 

  1972. 

  1973.             /* Descriptor includes Parameters */
    1974. 

  1974. 

  1975.             if ( (tvb_current_offset > tvb_LBRKT && tvb_LBRKT != -1)){
    1976. 

  1976. 

  1977.                 while ( tvb_LBRKT != -1 && tvb_RBRKT > tvb_LBRKT ){
    1978. 

  1978. 

  1979.                     tvb_LBRKT  = tvb_find_guint8(tvb, tvb_LBRKT+1,
    1980. 

  1980.                         tvb_events_end_offset, '{');
    1981. 

  1981.                     if ( tvb_LBRKT < tvb_RBRKT && tvb_LBRKT != -1)
    1982. 

  1982.                         tvb_RBRKT  = tvb_find_guint8(tvb, tvb_RBRKT+1,
    1983. 

  1983.                         tvb_events_end_offset, '}');
    1984. 

  1984.                 }
    1985. 

  1985. 

  1986.             }
    1987. 

  1987. 

  1988.             tvb_help_offset = tvb_find_guint8(tvb, tvb_previous_offset, tvb_events_end_offset, '{');
    1989. 

  1989. 

  1990.             /* if there are eventparameter  */
    1991. 

  1991. 

  1992.             if ( tvb_help_offset < tvb_RBRKT && tvb_help_offset != -1 ){
    1993. 

  1993. 

  1994.                 requested_event_start_offset = tvb_help_offset;
    1995. 

  1995.                 requested_event_end_offset   = tvb_RBRKT;
    1996. 

  1996.                 tvb_help_offset = megaco_tvb_skip_wsp_return(tvb, tvb_help_offset-1);
    1997. 

  1997.                 tokenlen = tvb_help_offset - tvb_previous_offset;
    1998. 

  1998.             }
    1999. 

  1999.             /* no parameters */
    2000. 

  2000.             else {
    2001. 

  2001.                 tokenlen = tvb_RBRKT+1 - tvb_previous_offset;
    2002. 

  2002.             }
    2003. 

  2003. 

  2004.             megaco_requestedevent_ti = proto_tree_add_item(megaco_eventsdescriptor_tree,hf_megaco_pkgdname,tvb,tvb_previous_offset,tokenlen, ENC_ASCII|ENC_NA);
    2005. 

  2005.             megaco_requestedevent_tree = proto_item_add_subtree(megaco_requestedevent_ti, ett_megaco_requestedevent);
    2006. 

  2006. 

  2007.             if ( tvb_help_offset < tvb_RBRKT && tvb_help_offset != -1 ){
    2008. 

  2008. 

  2009.                 tvb_help_offset = megaco_tvb_skip_wsp(tvb, requested_event_start_offset +1);
    2010. 

  2010.                 tempchar = tvb_get_guint8(tvb, tvb_help_offset);
    2011. 

  2011. 

  2012.                 requested_event_start_offset = megaco_tvb_skip_wsp(tvb, requested_event_start_offset +1);
    2013. 

  2013.                 requested_event_end_offset = megaco_tvb_skip_wsp_return(tvb, requested_event_end_offset-1);
    2014. 

  2014. 

  2015.                 if ( tempchar == 'D' || tempchar == 'd'){
    2016. 

  2016.                     dissect_megaco_digitmapdescriptor(tvb, megaco_requestedevent_tree, requested_event_end_offset, requested_event_start_offset);
    2017. 

  2017.                 }
    2018. 

  2018.                 else{
    2019. 

  2019.                     gchar *msg;
    2020. 

  2020. 

  2021.                     tokenlen =  requested_event_end_offset - requested_event_start_offset;
    2022. 

  2022.                     msg=tvb_format_text(tvb,requested_event_start_offset, tokenlen);
    2023. 

  2023.                     if(!strncmp("h245", msg, 4)){
    2024. 

  2024.                         dissect_megaco_h245(tvb, pinfo, megaco_requestedevent_tree, requested_event_start_offset, tokenlen, msg);
    2025. 

  2025.                     } else {
    2026. 

  2026.                         proto_tree_add_text(megaco_requestedevent_tree, tvb, requested_event_start_offset, tokenlen,
    2027. 

  2027.                             "%s", msg);
    2028. 

  2028.                     }
    2029. 

  2029.                 }
    2030. 

  2030. 

  2031.             }
    2032. 

  2032. 

  2033.             tvb_previous_offset = tvb_current_offset;
    2034. 

  2034.             tvb_current_offset  = tvb_find_guint8(tvb, tvb_RBRKT,
    2035. 

  2035.                 tvb_events_end_offset, ',');
    2036. 

  2036. 

  2037.             if (tvb_current_offset == -1 || tvb_current_offset > tvb_events_end_offset || tvb_current_offset < tvb_previous_offset ) {
    2038. 

  2038.                 tvb_current_offset = tvb_events_end_offset;
    2039. 

  2039.             }
    2040. 

  2040. 

  2041.             tvb_previous_offset = megaco_tvb_skip_wsp(tvb, tvb_current_offset+1);
    2042. 

  2042. 

  2043.             tvb_LBRKT = tvb_previous_offset;
    2044. 

  2044.             tvb_RBRKT = tvb_previous_offset;
    2045. 

  2045. 

  2046.         } while ( tvb_current_offset < tvb_events_end_offset );
    2047. 

  2047.     }
    2048. 

  2048. }
    2049. 

  2049. 

  2050. static void
    2051. 

  2051. dissect_megaco_signaldescriptor(tvbuff_t *tvb, packet_info *pinfo, proto_tree *megaco_tree_command_line,  gint tvb_RBRKT, gint tvb_previous_offset)
    2052. 

  2052. {
    2053. 

  2053. 

  2054.     gint tokenlen, pkg_tokenlen, tvb_current_offset, tvb_next_offset, tvb_help_offset;
    2055. 

  2055.     gint tvb_signals_end_offset, tvb_signals_start_offset, tvb_LBRKT;
    2056. 

  2056.     /*proto_tree  *megaco_signalsdescriptor_tree, *megaco_signalsdescriptor_ti;*/
    2057. 

  2057. 

  2058.     gint requested_signal_start_offset, requested_signal_end_offset;
    2059. 

  2059.     proto_tree  *megaco_requestedsignal_tree, *megaco_requestedsignal_ti;
    2060. 

  2060. 

  2061.     requested_signal_start_offset   = 0;
    2062. 

  2062.     requested_signal_end_offset     = 0;
    2063. 

  2063. 

  2064.     tvb_signals_end_offset   = tvb_RBRKT;
    2065. 

  2065.     tvb_signals_start_offset = tvb_previous_offset;
    2066. 

  2066. 

  2067.     if(toupper(tvb_get_guint8(tvb, tvb_previous_offset+1))=='G')
    2068. 

  2068.       tokenlen = 2;                             /* token is compact text (SG) */
    2069. 

  2069.     else
    2070. 

  2070.       tokenlen = 7;                             /* token must be verbose text (Signals) */
    2071. 

  2071. 

  2072.     tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_previous_offset+tokenlen);
    2073. 

  2073. 

  2074.     if(tvb_get_guint8(tvb, tvb_current_offset)!='{') {          /* {} has been omitted */
    2075. 

  2075. 

  2076.       proto_tree_add_text(megaco_tree_command_line, tvb, tvb_signals_start_offset, tokenlen,
    2077. 

  2077.                 "%s", "Empty Signal Descriptor");
    2078. 

  2078. 

  2079.       col_append_str(pinfo->cinfo, COL_INFO, " (Signal:none)");     /* then say so */
    2080. 

  2080. 

  2081.       return;                               /* and return */
    2082. 

  2082.     }
    2083. 

  2083. 

  2084.     tvb_LBRKT = tvb_find_guint8(tvb, tvb_previous_offset, tvb_signals_end_offset, '{');
    2085. 

  2085.     tokenlen =  (tvb_LBRKT+1) - tvb_signals_start_offset;
    2086. 

  2086. 

  2087.     proto_tree_add_text(megaco_tree_command_line, tvb, tvb_signals_start_offset, tokenlen,
    2088. 

  2088.         "%s", tvb_format_text(tvb, tvb_signals_start_offset, tokenlen));
    2089. 

  2089. 

  2090.     /*
    2091. 

  2091.     megaco_signalsdescriptor_ti = proto_tree_add_item(megaco_tree_command_line,hf_megaco_signal_descriptor,tvb,tvb_previous_offset,tokenlen, ENC_ASCII|ENC_NA);
    2092. 

  2092.     megaco_signalsdescriptor_tree = proto_item_add_subtree(megaco_signalsdescriptor_ti, ett_megaco_signalsdescriptor);
    2093. 

  2093.     */
    2094. 

  2094. 

  2095.     tvb_current_offset = tvb_LBRKT;
    2096. 

  2096.     tvb_next_offset = megaco_tvb_skip_wsp(tvb, tvb_current_offset+1);
    2097. 

  2097.     col_append_fstr(pinfo->cinfo, COL_INFO, " (Signal:%s)",tvb_format_text(tvb, tvb_current_offset,tokenlen-tvb_current_offset+tvb_previous_offset));
    2098. 

  2098. 

  2099. 

  2100.     if ( tvb_current_offset < tvb_signals_end_offset && tvb_current_offset != -1 && tvb_next_offset != tvb_signals_end_offset){
    2101. 

  2101. 

  2102. 

  2103.         tvb_RBRKT = tvb_next_offset+1;
    2104. 

  2104.         tvb_LBRKT = tvb_next_offset+1;
    2105. 

  2105.         tvb_previous_offset = tvb_next_offset;
    2106. 

  2106. 

  2107. 

  2108.         do {
    2109. 

  2109. 

  2110.             tvb_RBRKT = tvb_find_guint8(tvb, tvb_RBRKT+1,
    2111. 

  2111.                 tvb_signals_end_offset, '}');
    2112. 

  2112.             tvb_LBRKT = tvb_find_guint8(tvb, tvb_LBRKT,
    2113. 

  2113.                 tvb_signals_end_offset, '{');
    2114. 

  2114. 

  2115.             tvb_current_offset  = tvb_find_guint8(tvb, tvb_previous_offset,
    2116. 

  2116.                 tvb_signals_end_offset, ',');
    2117. 

  2117. 

  2118.             if (tvb_current_offset == -1 || tvb_current_offset > tvb_signals_end_offset){
    2119. 

  2119.                 tvb_current_offset = tvb_signals_end_offset;
    2120. 

  2120.             }
    2121. 

  2121. 

  2122. 

  2123.             /* Descriptor includes no parameters */
    2124. 

  2124. 

  2125.             if ( tvb_LBRKT > tvb_current_offset || tvb_LBRKT == -1 ){
    2126. 

  2126. 

  2127.                 tvb_RBRKT = megaco_tvb_skip_wsp_return(tvb, tvb_current_offset-1)-1;
    2128. 

  2128.             }
    2129. 

  2129. 

  2130.             /* Descriptor includes Parameters */
    2131. 

  2131. 

  2132.             if ( (tvb_current_offset > tvb_LBRKT && tvb_LBRKT != -1)){
    2133. 

  2133. 

  2134.                 while ( tvb_LBRKT != -1 && tvb_RBRKT > tvb_LBRKT ){
    2135. 

  2135. 

  2136.                     tvb_LBRKT  = tvb_find_guint8(tvb, tvb_LBRKT+1,
    2137. 

  2137.                         tvb_signals_end_offset, '{');
    2138. 

  2138.                     if ( tvb_LBRKT < tvb_RBRKT && tvb_LBRKT != -1)
    2139. 

  2139.                         tvb_RBRKT  = tvb_find_guint8(tvb, tvb_RBRKT+1,
    2140. 

  2140.                         tvb_signals_end_offset, '}');
    2141. 

  2141.                 }
    2142. 

  2142. 

  2143.             }
    2144. 

  2144. 

  2145.             tvb_help_offset = tvb_LBRKT = tvb_find_guint8(tvb, tvb_previous_offset, tvb_signals_end_offset, '{');
    2146. 

  2146. 

  2147.             /* if there are signalparameter  */
    2148. 

  2148. 

  2149.             if ( tvb_help_offset < tvb_RBRKT && tvb_help_offset != -1 ){
    2150. 

  2150. 

  2151.                 requested_signal_start_offset = tvb_help_offset;
    2152. 

  2152.                 requested_signal_end_offset  = tvb_RBRKT;
    2153. 

  2153.                 tvb_help_offset = megaco_tvb_skip_wsp_return(tvb, tvb_help_offset-1);
    2154. 

  2154.                 pkg_tokenlen = tvb_help_offset - tvb_previous_offset;
    2155. 

  2155.                 tokenlen = tvb_LBRKT+1 - tvb_previous_offset;
    2156. 

  2156.             }
    2157. 

  2157.             /* no parameters */
    2158. 

  2158.             else {
    2159. 

  2159.                 tokenlen = pkg_tokenlen = tvb_RBRKT+1 - tvb_previous_offset;
    2160. 

  2160.             }
    2161. 

  2161. 

  2162.             megaco_requestedsignal_ti = proto_tree_add_text(megaco_tree_command_line, tvb, tvb_previous_offset, tokenlen,
    2163. 

  2163.                 "%s", tvb_format_text(tvb, tvb_previous_offset, tokenlen));
    2164. 

  2164.             megaco_requestedsignal_tree = proto_item_add_subtree(megaco_requestedsignal_ti, ett_megaco_requestedsignal);
    2165. 

  2165. 

  2166.             proto_tree_add_item(megaco_requestedsignal_tree,hf_megaco_pkgdname,tvb,tvb_previous_offset,pkg_tokenlen, ENC_ASCII|ENC_NA);
    2167. 

  2167. 

  2168.             if ( tvb_help_offset < tvb_RBRKT && tvb_help_offset != -1 ){
    2169. 

  2169.                 gchar *msg;
    2170. 

  2170. 

  2171.                 requested_signal_start_offset = megaco_tvb_skip_wsp(tvb, requested_signal_start_offset +1);
    2172. 

  2172.                 requested_signal_end_offset = megaco_tvb_skip_wsp_return(tvb, requested_signal_end_offset-1);
    2173. 

  2173. 

  2174.                 tokenlen =  requested_signal_end_offset - requested_signal_start_offset;
    2175. 

  2175. 

  2176.                 msg=tvb_format_text(tvb,requested_signal_start_offset, tokenlen+1);
    2177. 

  2177.                 if(!strncmp("h245", msg, 4)){
    2178. 

  2178.                     dissect_megaco_h245(tvb, pinfo, megaco_tree_command_line, requested_signal_start_offset, tokenlen, msg);
    2179. 

  2179.                 } else {
    2180. 

  2180.                     proto_tree_add_text(megaco_tree_command_line, tvb, requested_signal_start_offset, tokenlen,
    2181. 

  2181.                         "%s", msg);
    2182. 

  2182.                 }
    2183. 

  2183.                 /* Print the trailing '}' */
    2184. 

  2184.                 proto_tree_add_text(megaco_tree_command_line, tvb, tvb_RBRKT, 1,
    2185. 

  2185.                     "%s", tvb_format_text(tvb, tvb_RBRKT, 1));
    2186. 

  2186.             }
    2187. 

  2187. 

  2188.             tvb_current_offset  = tvb_find_guint8(tvb, tvb_RBRKT,
    2189. 

  2189.                 tvb_signals_end_offset, ',');
    2190. 

  2190. 

  2191.             if (tvb_current_offset == -1 || tvb_current_offset > tvb_signals_end_offset || tvb_current_offset < tvb_previous_offset){
    2192. 

  2192.                 tvb_current_offset = tvb_signals_end_offset;
    2193. 

  2193.             }
    2194. 

  2194. 

  2195.             tvb_previous_offset = megaco_tvb_skip_wsp(tvb, tvb_current_offset+1);
    2196. 

  2196. 

  2197.             tvb_LBRKT = tvb_previous_offset;
    2198. 

  2198.             tvb_RBRKT = tvb_previous_offset;
    2199. 

  2199.             /* Print the trailing '}' */
    2200. 

  2200.             proto_tree_add_text(megaco_tree_command_line, tvb, tvb_signals_end_offset, 1,
    2201. 

  2201.                 "%s", tvb_format_text(tvb, tvb_signals_end_offset, 1));
    2202. 

  2202. 

  2203.         } while ( tvb_current_offset < tvb_signals_end_offset );
    2204. 

  2204.     }else{
    2205. 

  2205.         /* signals{}*/
    2206. 

  2206.         proto_tree_add_text(megaco_tree_command_line, tvb, tvb_signals_end_offset, 1,
    2207. 

  2207.                 "%s", tvb_format_text(tvb, tvb_signals_end_offset, 1));
    2208. 

  2208.     }
    2209. 

  2209. 

  2210. 

  2211. }
    2212. 

  2212. 

  2213. /*
    2214. 

  2214.    auditDescriptor      = AuditToken LBRKT [ auditItem *(COMMA auditItem) ] RBRKT
    2215. 

    2216. 

  2216.    auditItem            = ( MuxToken / ModemToken / MediaToken /
    2217. 

  2217.                            SignalsToken / EventBufferToken /
    2218. 

  2218.                            DigitMapToken / StatsToken / EventsToken /
    2219. 

  2219.                            ObservedEventsToken / PackagesToken )                     */
    2220. 

  2220. static void
    2221. 

  2221. dissect_megaco_auditdescriptor(tvbuff_t *tvb, proto_tree *megaco_tree, packet_info *pinfo _U_,  gint tvb_stop, gint tvb_offset)
    2222. 

  2222. {
    2223. 

  2223.     gint        tokenlen, tvb_end, tvb_next, token_index;
    2224. 

  2224.     proto_tree  *megaco_auditdescriptor_tree, *megaco_auditdescriptor_ti;
    2225. 

  2225. 

  2226.     tvb_next  = tvb_find_guint8(tvb, tvb_offset, tvb_stop, '{');           /* find opening LBRKT - is this already checked by caller?*/
    2227. 

  2227.     if( tvb_next == -1 )                                                   /* complain and give up if not there */
    2228. 

  2228.     {
    2229. 

  2229.         expert_add_info_format(pinfo, megaco_tree, PI_MALFORMED, PI_ERROR, "Badly constructed audit descriptor (no { )");
    2230. 

  2230.         return;
    2231. 

  2231.     }
    2232. 

  2232.     tokenlen = (tvb_stop + 1) - tvb_offset;
    2233. 

  2233. 

  2234.     megaco_auditdescriptor_ti = proto_tree_add_none_format( megaco_tree, hf_megaco_audit_descriptor,
    2235. 

  2235.                                 tvb, tvb_offset, tokenlen, "Audit descriptor" );
    2236. 

  2236. 

  2237.     megaco_auditdescriptor_tree = proto_item_add_subtree( megaco_auditdescriptor_ti, ett_megaco_auditdescriptor );
    2238. 

  2238. 

  2239.     tokenlen = tvb_next + 1 - tvb_offset;
    2240. 

  2240. 

  2241.     proto_tree_add_text( megaco_auditdescriptor_tree, tvb, tvb_offset, tokenlen, "Audit token {" );
    2242. 

  2242. 

  2243.     tvb_offset = tvb_next;
    2244. 

  2244. 

  2245.     while( tvb_offset < tvb_stop )
    2246. 

  2246.     {
    2247. 

  2247.         tvb_offset = megaco_tvb_skip_wsp(tvb, tvb_offset+1);                                          /* find start of an auditItem */
    2248. 

  2248.                 if( tvb_get_guint8(tvb, tvb_offset) != '}' )                                                  /* got something */
    2249. 

  2249.                 {
    2250. 

  2250.             tvb_next = tvb_find_guint8(tvb, tvb_offset, tvb_stop, ',');                           /* end of an auditItem */
    2251. 

  2251.                     if (tvb_next == -1)  tvb_next = tvb_stop;                                             /* last item doesn't have a comma */
    2252. 

  2252.             tvb_end = megaco_tvb_skip_wsp_return(tvb, tvb_next-1);                                /* trim any trailing whitespace */
    2253. 

  2253.             tokenlen =  tvb_end - tvb_offset;                                                     /* get length of token */
    2254. 

  2254. 

  2255.             token_index = find_megaco_descriptors_names(tvb, tvb_offset, tokenlen);               /* lookup the token */
    2256. 

  2256.             if( token_index == -1 )  token_index = 0;                                             /* if not found then 0 => Unknown */
    2257. 

  2257. 

  2258.             proto_tree_add_string(megaco_auditdescriptor_tree, hf_megaco_audititem, tvb,
    2259. 

  2259.                     tvb_offset, tokenlen, megaco_descriptors_names[token_index].name);    /* and display the long form */
    2260. 

  2260. 

  2261.             tvb_offset = tvb_next;                                                                /* advance pointer */
    2262. 

  2262.         }
    2263. 

  2263.     }
    2264. 

  2264.     proto_tree_add_text(megaco_auditdescriptor_tree, tvb, tvb_stop, 1, "}");                              /* End of auditDescriptor */
    2265. 

  2265. }
    2266. 

  2266. 

  2267. /*
    2268. 

  2268.  *    serviceChangeDescriptor = ServicesToken LBRKT serviceChangeParm
    2269. 

  2269.  *                          *(COMMA serviceChangeParm) RBRKT
    2270. 

  2270.  *
    2271. 

  2271.  *    ServicesToken              = ("Services"              / "SV")
    2272. 

  2272.  *
    2273. 

  2273.  *    serviceChangeParm    = (serviceChangeMethod / serviceChangeReason /
    2274. 

  2274.  *                        serviceChangeDelay / serviceChangeAddress /
    2275. 

  2275.  *                       serviceChangeProfile / extension / TimeStamp /
    2276. 

  2276.  *                        serviceChangeMgcId / serviceChangeVersion )
    2277. 

  2277.  *
    2278. 

  2278.  */
    2279. 

  2279. #define MEGACO_REASON_TOKEN     1
    2280. 

  2280. #define MEGACO_DELAY_TOKEN      2
    2281. 

  2281. #define MEGACO_SC_ADDR_TOKEN    3
    2282. 

  2282. #define MEGACO_MGC_ID_TOKEN     4
    2283. 

  2283. #define MEGACO_PROFILE_TOKEN    5
    2284. 

  2284. #define MEGACO_VERSION_TOKEN    6
    2285. 

  2285. #define MEGACO_METHOD_TOKEN     7
    2286. 

  2286. 

  2287. static const megaco_tokens_t megaco_serviceChangeParm_names[] = {
    2288. 

  2288.     { "Unknown-token",              NULL }, /* 0 Pad so that the real headers start at index 1 */
    2289. 

  2289.     /* streamMode */
    2290. 

  2290.     { "Reason",                     "RE" }, /* 1 ReasonToken*/
    2291. 

  2291.     { "Delay",                      "DL" }, /* 2 DelayToken */
    2292. 

  2292.     { "ServiceChangeAddress",       "AD" }, /* 3 ServiceChangeAddressToken */
    2293. 

  2293.     { "MgcIdToTry",                 "MG" }, /* 4 MgcIdToken */
    2294. 

  2294.     { "Profile",                    "PF" }, /* 5 ProfileToken */
    2295. 

  2295.     { "Version",                    "V"  }, /* 6 VersionToken */
    2296. 

  2296.     { "Method",                     "MT" }, /* 7  MethodToken */
    2297. 

  2297. };
    2298. 

  2298. 

  2299. /* Returns index of megaco_tokens_t */
    2300. 

  2300. static gint find_megaco_megaco_serviceChangeParm_names(tvbuff_t *tvb, int offset, guint header_len)
    2301. 

  2301. {
    2302. 

  2302.     guint i;
    2303. 

  2303. 

  2304.     for (i = 1; i < array_length(megaco_serviceChangeParm_names); i++) {
    2305. 

  2305.         if (header_len == strlen(megaco_serviceChangeParm_names[i].name) &&
    2306. 

  2306.             tvb_strncaseeql(tvb, offset, megaco_serviceChangeParm_names[i].name, header_len) == 0)
    2307. 

  2307.             return i;
    2308. 

  2308.         if (megaco_serviceChangeParm_names[i].compact_name != NULL &&
    2309. 

  2309.             header_len == strlen(megaco_serviceChangeParm_names[i].compact_name) &&
    2310. 

  2310.             tvb_strncaseeql(tvb, offset, megaco_serviceChangeParm_names[i].compact_name, header_len) == 0)
    2311. 

  2311.             return i;
    2312. 

  2312.     }
    2313. 

  2313. 

  2314.     return -1;
    2315. 

  2315. }
    2316. 

  2316. /*
    2317. 

  2317.  * ServiceChangeReasons                                    References
    2318. 

  2318.  * --------------------                                    ----------
    2319. 

  2319.  */
    2320. 

  2320. static const value_string MEGACO_ServiceChangeReasons_vals[] = {
    2321. 

  2321.     {900, "Service Restored"},
    2322. 

  2322.     {901, "Cold Boot"},
    2323. 

  2323.     {902, "Warm Boot"},
    2324. 

  2324.     {903, "MGC Directed Change"},
    2325. 

  2325.     {904, "Termination malfunctioning"},
    2326. 

  2326.     {905, "Termination taken out of service"},
    2327. 

  2327.     {906, "Loss of lower layer connectivity (e.g. downstream sync)"},
    2328. 

  2328.     {907, "Transmission Failure"},
    2329. 

  2329.     {908, "MG Impending Failure"},
    2330. 

  2330.     {909, "MGC Impending Failure"},
    2331. 

  2331.     {910, "Media Capability Failure"},
    2332. 

  2332.     {911, "Modem Capability Failure"},
    2333. 

  2333.     {912, "Mux Capability Failure"},
    2334. 

  2334.     {913, "Signal Capability Failure"},
    2335. 

  2335.     {914, "Event Capability Failure"},
    2336. 

  2336.     {915, "State Loss"},
    2337. 

  2337.     {916, "Packages Change"},
    2338. 

  2338.     {917, "Capabilities Change"},
    2339. 

  2339.     {918, "Cancel Graceful"},
    2340. 

  2340.     {919, "Warm Failover"},
    2341. 

  2341.     {920, "Cold Failover"},
    2342. 

  2342.     {  0, NULL }
    2343. 

  2343. };
    2344. 

  2344. 

  2345. static void
    2346. 

  2346. dissect_megaco_servicechangedescriptor(tvbuff_t *tvb, proto_tree *megaco_tree,  gint tvb_RBRKT, gint tvb_previous_offset)
    2347. 

  2347. {
    2348. 

  2348. 

  2349.     gint        tokenlen, tvb_LBRKT, tvb_offset;
    2350. 

  2350.     gint        token_index;
    2351. 

  2351.     gint        tvb_current_offset;
    2352. 

  2352.     gboolean    more_params = TRUE;
    2353. 

  2353.     proto_item* item;
    2354. 

  2354.     gint                reason;
    2355. 

  2355.     guint8              ServiceChangeReason_str[4];
    2356. 

  2356. 

  2357.     tvb_LBRKT  = tvb_find_guint8(tvb, tvb_previous_offset, tvb_RBRKT, '{');
    2358. 

  2358.     /*
    2359. 

  2359.     if (tvb_LBRKT == -1)
    2360. 

  2360.         return;
    2361. 

  2361.         */
    2362. 

  2362.     tokenlen = (tvb_LBRKT + 1) - tvb_previous_offset;
    2363. 

  2363.     proto_tree_add_text(megaco_tree, tvb, tvb_previous_offset, tokenlen,
    2364. 

  2364.                 "%s", tvb_format_text(tvb, tvb_previous_offset, tokenlen));
    2365. 

  2365. 

  2366. 

  2367.     /* Start dissecting serviceChangeParm */
    2368. 

  2368.     tvb_previous_offset = tvb_LBRKT + 1;
    2369. 

  2369.     while (more_params){
    2370. 

  2370.         tvb_previous_offset = megaco_tvb_skip_wsp(tvb, tvb_previous_offset);
    2371. 

  2371.         /* Find token length */
    2372. 

  2372.         for (tvb_offset=tvb_previous_offset; tvb_offset < tvb_RBRKT; tvb_offset++){
    2373. 

  2373.             if (!isalpha(tvb_get_guint8(tvb, tvb_offset ))){
    2374. 

  2374.                 break;
    2375. 

  2375.             }
    2376. 

  2376.         }
    2377. 

  2377.         tokenlen = tvb_offset - tvb_previous_offset;
    2378. 

  2378.         token_index = find_megaco_megaco_serviceChangeParm_names(tvb, tvb_previous_offset, tokenlen);
    2379. 

  2379. 

  2380.         tvb_offset  = tvb_find_guint8(tvb, tvb_offset, tvb_RBRKT, ',');
    2381. 

  2381.         if ((tvb_offset == -1)||(tvb_offset >=tvb_RBRKT)){
    2382. 

  2382.             more_params = FALSE;
    2383. 

  2383.             tvb_offset = megaco_tvb_skip_wsp_return(tvb, tvb_RBRKT-1);
    2384. 

  2384.         }
    2385. 

  2385.         tokenlen = tvb_offset - tvb_previous_offset;
    2386. 

  2386.         if (more_params == TRUE )
    2387. 

  2387.             /* Include ',' */
    2388. 

  2388.             tokenlen++;
    2389. 

  2389.         switch(token_index){
    2390. 

  2390.         case MEGACO_REASON_TOKEN:
    2391. 

  2391.             /* ReasonToken  EQUAL VALUE
    2392. 

  2392.              * VALUE                = quotedString / 1*(SafeChar)
    2393. 

  2393.              */
    2394. 

  2394.             item = proto_tree_add_text(megaco_tree, tvb, tvb_previous_offset, tokenlen,
    2395. 

  2395.                 "%s", tvb_format_text(tvb, tvb_previous_offset, tokenlen));
    2396. 

  2396. 

  2397.             /* As the reason code ( if a digit ) can be in quoted string or 'just' digit
    2398. 

  2398.              * look for a nine and hope for the best.
    2399. 

  2399.              */
    2400. 

  2400.             tvb_current_offset = tvb_find_guint8(tvb, tvb_previous_offset, tvb_RBRKT, '9');
    2401. 

  2401.             if ( tvb_current_offset == -1)
    2402. 

  2402.                 break;
    2403. 

  2403. 

  2404.             tvb_get_nstringz0(tvb,tvb_current_offset,4,ServiceChangeReason_str);
    2405. 

  2405.             reason = atoi(ServiceChangeReason_str);
    2406. 

  2406. 

  2407.             proto_item_append_text(item,"[ %s ]", val_to_str(reason, MEGACO_ServiceChangeReasons_vals,"Unknown (%u)"));
    2408. 

  2408.             break;
    2409. 

  2409.         case MEGACO_DELAY_TOKEN:
    2410. 

  2410.         case MEGACO_SC_ADDR_TOKEN:
    2411. 

  2411.         case MEGACO_MGC_ID_TOKEN:
    2412. 

  2412.         case MEGACO_PROFILE_TOKEN:
    2413. 

  2413.         case MEGACO_VERSION_TOKEN:
    2414. 

  2414.         case MEGACO_METHOD_TOKEN:
    2415. 

  2415.             /* No special dissection: fall trough */
    2416. 

  2416.         default:
    2417. 

  2417.         /* Unknown or:
    2418. 

  2418.          * extension            = extensionParameter parmValue
    2419. 

  2419.          * extensionParameter   = "X"  ("-" / "+") 1*6(ALPHA / DIGIT)
    2420. 

  2420.          */
    2421. 

  2421.             proto_tree_add_text(megaco_tree, tvb, tvb_previous_offset, tokenlen,
    2422. 

  2422.                 "%s", tvb_format_text(tvb, tvb_previous_offset, tokenlen));
    2423. 

  2423.             break;
    2424. 

  2424.         }
    2425. 

  2425. 

  2426.         tvb_previous_offset = tvb_offset +1;
    2427. 

  2427. 

  2428.     }/*End while */
    2429. 

  2429. 

  2430.     /* extension            = extensionParameter parmValue
    2431. 

  2431.      * extensionParameter   = "X"  ("-" / "+") 1*6(ALPHA / DIGIT)
    2432. 

  2432.      */
    2433. 

  2433. 

  2434.      /*
    2435. 

  2435.     tokenlen =  (tvb_RBRKT+1) - tvb_previous_offset;
    2436. 

  2436.     proto_tree_add_string(megaco_tree_command_line, hf_megaco_servicechange_descriptor, tvb,
    2437. 

  2437.                             tvb_previous_offset, tokenlen,
    2438. 

  2438.                             tvb_format_text(tvb, tvb_previous_offset,
    2439. 

  2439.                             tokenlen));
    2440. 

  2440.     */
    2441. 

  2441.     proto_tree_add_text(megaco_tree, tvb, tvb_RBRKT, 1,"%s", tvb_format_text(tvb, tvb_RBRKT, 1));
    2442. 

  2442. 

  2443. }
    2444. 

  2444. static void
    2445. 

  2445. dissect_megaco_digitmapdescriptor(tvbuff_t *tvb, proto_tree *megaco_tree_command_line,  gint tvb_RBRKT, gint tvb_previous_offset)
    2446. 

  2446. {
    2447. 

  2447. 

  2448.     gint    tokenlen;
    2449. 

  2449. 

  2450.     tokenlen =  tvb_RBRKT - tvb_previous_offset;
    2451. 

  2451.     proto_tree_add_string(megaco_tree_command_line, hf_megaco_digitmap_descriptor, tvb,
    2452. 

  2452.                             tvb_previous_offset, tokenlen,
    2453. 

  2453.                             tvb_format_text(tvb, tvb_previous_offset,
    2454. 

  2454.                             tokenlen));
    2455. 

  2455. 

  2456. }
    2457. 

  2457. static void
    2458. 

  2458. dissect_megaco_statisticsdescriptor(tvbuff_t *tvb, proto_tree *megaco_tree_command_line,  gint tvb_RBRKT, gint tvb_previous_offset)
    2459. 

  2459. {
    2460. 

  2460. 

  2461.     gint    tokenlen;
    2462. 

  2462. 

  2463.     tokenlen =  (tvb_RBRKT+1) - tvb_previous_offset;
    2464. 

  2464.     proto_tree_add_string(megaco_tree_command_line, hf_megaco_statistics_descriptor, tvb,
    2465. 

  2465.                             tvb_previous_offset, tokenlen,
    2466. 

  2466.                             tvb_format_text(tvb, tvb_previous_offset,
    2467. 

  2467.                             tokenlen));
    2468. 

  2468. 

  2469. }
    2470. 

  2470. static void
    2471. 

  2471. dissect_megaco_observedeventsdescriptor(tvbuff_t *tvb, packet_info *pinfo, proto_tree *megaco_tree_command_line,  gint tvb_RBRKT, gint tvb_previous_offset)
    2472. 

  2472. {
    2473. 

  2473. 

  2474.     gint tokenlen, pkg_tokenlen, tvb_current_offset, tvb_next_offset, tvb_help_offset;
    2475. 

  2475.     gint tvb_observedevents_end_offset, tvb_LBRKT;
    2476. 

  2476.     proto_tree  *megaco_observedeventsdescriptor_tree, *megaco_observedeventsdescriptor_ti;
    2477. 

  2477. 

  2478.     gint requested_event_start_offset, requested_event_end_offset, param_start_offset, param_end_offset;
    2479. 

  2479.     proto_tree  *megaco_observedevent_tree, *megaco_observedevent_ti;
    2480. 

  2480. 

  2481.     requested_event_start_offset    = 0;
    2482. 

  2482.     requested_event_end_offset  = 0;
    2483. 

  2483. 

  2484. 

  2485.     tvb_LBRKT = tvb_find_guint8(tvb, tvb_previous_offset, tvb_RBRKT, '{');
    2486. 

  2486.     tvb_next_offset = tvb_LBRKT;
    2487. 

  2487.     tokenlen =  (tvb_next_offset+1) - tvb_previous_offset;
    2488. 

  2488. 

  2489.     /*
    2490. 

  2490.     megaco_observedeventsdescriptor_ti = proto_tree_add_item(megaco_tree_command_line,hf_megaco_observedevents_descriptor,tvb,tvb_previous_offset,tokenlen, ENC_ASCII|ENC_NA);
    2491. 

  2491.     megaco_observedeventsdescriptor_tree = proto_item_add_subtree(megaco_observedeventsdescriptor_ti, ett_megaco_observedeventsdescriptor);
    2492. 

  2492.     */
    2493. 

  2493. 

  2494.     megaco_observedeventsdescriptor_ti = proto_tree_add_text(megaco_tree_command_line, tvb, tvb_previous_offset, tokenlen,
    2495. 

  2495.         "%s", tvb_format_text(tvb, tvb_previous_offset, tokenlen));
    2496. 

  2496.     megaco_observedeventsdescriptor_tree = proto_item_add_subtree(megaco_observedeventsdescriptor_ti, ett_megaco_observedeventsdescriptor);
    2497. 

  2497. 

  2498.     tvb_current_offset = tvb_find_guint8(tvb, tvb_previous_offset, tvb_RBRKT, '=');
    2499. 

  2499.     tvb_next_offset = tvb_find_guint8(tvb, tvb_previous_offset, tvb_RBRKT, '{');
    2500. 

  2500. 

  2501.     if ( tvb_current_offset < tvb_RBRKT && tvb_current_offset != -1 ){
    2502. 

  2502. 

  2503.         tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_current_offset +1);
    2504. 

  2504.         tvb_help_offset = megaco_tvb_skip_wsp_return(tvb, tvb_next_offset-1);
    2505. 

  2505. 

  2506.         tokenlen =  tvb_help_offset - tvb_current_offset;
    2507. 

  2507. 

  2508.         proto_tree_add_string(megaco_observedeventsdescriptor_tree, hf_megaco_requestid, tvb,
    2509. 

  2509.             tvb_current_offset, tokenlen,
    2510. 

  2510.             tvb_format_text(tvb, tvb_current_offset,
    2511. 

  2511.             tokenlen));
    2512. 

  2512. 

  2513.         tvb_observedevents_end_offset   = tvb_RBRKT;
    2514. 

  2514. 

  2515.         tvb_RBRKT = tvb_next_offset+1;
    2516. 

  2516.         tvb_LBRKT = tvb_next_offset+1;
    2517. 

  2517.         tvb_previous_offset = megaco_tvb_skip_wsp(tvb, tvb_next_offset+1);
    2518. 

  2518. 

  2519. 

  2520.         do {
    2521. 

  2521. 

  2522.             tvb_RBRKT = tvb_find_guint8(tvb, tvb_RBRKT+1,
    2523. 

  2523.                 tvb_observedevents_end_offset, '}');
    2524. 

  2524.             tvb_LBRKT = tvb_find_guint8(tvb, tvb_LBRKT,
    2525. 

  2525.                 tvb_observedevents_end_offset, '{');
    2526. 

  2526. 

  2527.             tvb_current_offset  = tvb_find_guint8(tvb, tvb_previous_offset,
    2528. 

  2528.                 tvb_observedevents_end_offset, ',');
    2529. 

  2529. 

  2530.             if (tvb_current_offset == -1 || tvb_current_offset > tvb_observedevents_end_offset){
    2531. 

  2531.                 tvb_current_offset = tvb_observedevents_end_offset;
    2532. 

  2532.             }
    2533. 

  2533. 

  2534. 

  2535.             /* Descriptor includes no parameters */
    2536. 

  2536. 

  2537.             if ( tvb_LBRKT > tvb_current_offset || tvb_LBRKT == -1 ){
    2538. 

  2538. 

  2539.                 tvb_RBRKT = megaco_tvb_skip_wsp_return(tvb, tvb_current_offset-1)-1;
    2540. 

  2540.             }
    2541. 

  2541. 

  2542.             /* Descriptor includes Parameters */
    2543. 

  2543. 

  2544.             if ( (tvb_current_offset > tvb_LBRKT && tvb_LBRKT != -1)){
    2545. 

  2545. 

  2546.                 while ( tvb_LBRKT != -1 && tvb_RBRKT > tvb_LBRKT ){
    2547. 

  2547. 

  2548.                     tvb_LBRKT  = tvb_find_guint8(tvb, tvb_LBRKT+1,
    2549. 

  2549.                         tvb_observedevents_end_offset, '{');
    2550. 

  2550.                     if ( tvb_LBRKT < tvb_RBRKT && tvb_LBRKT != -1){
    2551. 

  2551.                         tvb_RBRKT  = tvb_find_guint8(tvb, tvb_RBRKT+1,
    2552. 

  2552.                             tvb_observedevents_end_offset, '}');
    2553. 

  2553.                     }
    2554. 

  2554.                 }
    2555. 

  2555. 

  2556.             }
    2557. 

  2557. 

  2558.             tvb_LBRKT = tvb_help_offset = tvb_find_guint8(tvb, tvb_previous_offset, tvb_observedevents_end_offset, '{');
    2559. 

  2559. 

  2560.             /* if there are eventparameter  */
    2561. 

  2561. 

  2562.             if ( tvb_help_offset < tvb_RBRKT && tvb_help_offset != -1 ){
    2563. 

  2563. 

  2564.                 requested_event_start_offset = tvb_help_offset;
    2565. 

  2565.                 requested_event_end_offset   = tvb_RBRKT;
    2566. 

  2566.                 tvb_help_offset = megaco_tvb_skip_wsp_return(tvb, tvb_help_offset-1);
    2567. 

  2567.                 pkg_tokenlen = tvb_help_offset - tvb_previous_offset;
    2568. 

  2568.                 tokenlen = tvb_LBRKT+1 - tvb_previous_offset;
    2569. 

  2569.             }
    2570. 

  2570.             /* no parameters */
    2571. 

  2571.             else {
    2572. 

  2572.                 tokenlen = pkg_tokenlen = tvb_RBRKT+1 - tvb_previous_offset;
    2573. 

  2573.             }
    2574. 

  2574. 

  2575.             megaco_observedevent_ti = proto_tree_add_text(megaco_tree_command_line, tvb, tvb_previous_offset, tokenlen,
    2576. 

  2576.                 "%s", tvb_format_text(tvb, tvb_previous_offset, tokenlen));
    2577. 

  2577. 

  2578.             megaco_observedevent_tree = proto_item_add_subtree(megaco_observedevent_ti, ett_megaco_observedevent);
    2579. 

  2579. 

  2580.             proto_tree_add_item(megaco_observedevent_tree,hf_megaco_pkgdname,tvb,tvb_previous_offset,pkg_tokenlen, ENC_ASCII|ENC_NA);
    2581. 

  2581. 

  2582.             if ( tvb_help_offset < tvb_RBRKT && tvb_help_offset != -1 ){
    2583. 

  2583. 

  2584.                 requested_event_start_offset = megaco_tvb_skip_wsp(tvb, requested_event_start_offset +1)-1;
    2585. 

  2585.                 requested_event_end_offset = megaco_tvb_skip_wsp_return(tvb, requested_event_end_offset-1);
    2586. 

  2586. 

  2587.                 tvb_help_offset = requested_event_start_offset;
    2588. 

  2588. 

  2589.                 do {
    2590. 

  2590.                     gchar *msg;
    2591. 

  2591. 

  2592.                     param_start_offset = megaco_tvb_skip_wsp(tvb, tvb_help_offset+1);
    2593. 

  2593. 

  2594.                     tvb_help_offset = tvb_find_guint8(tvb, tvb_help_offset+1,requested_event_end_offset, ',');
    2595. 

  2595. 

  2596.                     if ( tvb_help_offset > requested_event_end_offset || tvb_help_offset == -1){
    2597. 

  2597.                         tvb_help_offset = requested_event_end_offset;
    2598. 

  2598.                     }
    2599. 

  2599. 

  2600.                     param_end_offset = megaco_tvb_skip_wsp(tvb, tvb_help_offset-1);
    2601. 

  2601. 

  2602.                     tokenlen =  param_end_offset - param_start_offset+1;
    2603. 

  2603.                     msg=tvb_format_text(tvb,param_start_offset, tokenlen);
    2604. 

  2604.                     if(!strncmp("h245", msg, 4)){
    2605. 

  2605.                         dissect_megaco_h245(tvb, pinfo, megaco_tree_command_line, param_start_offset, tokenlen, msg);
    2606. 

  2606.                     } else {
    2607. 

  2607.                         proto_tree_add_text(megaco_tree_command_line, tvb, param_start_offset, tokenlen,
    2608. 

  2608.                             "%s", msg);
    2609. 

  2609.                     }
    2610. 

  2610. 

  2611. 

  2612.                 } while ( tvb_help_offset < requested_event_end_offset );
    2613. 

  2613.             }
    2614. 

  2614. 

  2615.             tvb_previous_offset = tvb_current_offset;
    2616. 

  2616.             tvb_current_offset  = tvb_find_guint8(tvb, tvb_RBRKT,
    2617. 

  2617.                 tvb_observedevents_end_offset, ',');
    2618. 

  2618. 

  2619.             if (tvb_current_offset == -1 || tvb_current_offset > tvb_observedevents_end_offset ){
    2620. 

  2620.                 tvb_current_offset = tvb_observedevents_end_offset;
    2621. 

  2621.             }
    2622. 

  2622.             if (tvb_current_offset < tvb_previous_offset) {
    2623. 

  2623.                 expert_add_info_format(pinfo, megaco_observedevent_ti, PI_MALFORMED, PI_ERROR, "[ Parse error: Invalid offset ]");
    2624. 

  2624.                 return;
    2625. 

  2625.             }
    2626. 

  2626. 

  2627.             tvb_previous_offset = megaco_tvb_skip_wsp(tvb, tvb_current_offset+1);
    2628. 

  2628. 

  2629.             tvb_LBRKT = tvb_previous_offset;
    2630. 

  2630.             tvb_RBRKT = tvb_previous_offset;
    2631. 

  2631.             /* Print the trailing '}' */
    2632. 

  2632.             proto_tree_add_text(megaco_tree_command_line, tvb, tvb_observedevents_end_offset, 1,
    2633. 

  2633.                 "%s", tvb_format_text(tvb, tvb_observedevents_end_offset, 1));
    2634. 

  2634. 

  2635.         } while ( tvb_current_offset < tvb_observedevents_end_offset );
    2636. 

  2636.     }
    2637. 

  2637. }
    2638. 

  2638. static void
    2639. 

  2639. dissect_megaco_topologydescriptor(tvbuff_t *tvb, proto_tree *megaco_tree_command_line,  gint tvb_RBRKT, gint tvb_previous_offset)
    2640. 

  2640. {
    2641. 

  2641. 

  2642.     gint    tokenlen;
    2643. 

  2643. 

  2644.     tokenlen =  (tvb_RBRKT+1) - tvb_previous_offset;
    2645. 

  2645.     proto_tree_add_string(megaco_tree_command_line, hf_megaco_topology_descriptor, tvb,
    2646. 

  2646.                             tvb_previous_offset, tokenlen,
    2647. 

  2647.                             tvb_format_text_wsp(tvb, tvb_previous_offset,
    2648. 

  2648.                             tokenlen));
    2649. 

  2649. 

  2650. }
    2651. 

  2651. static void
    2652. 

  2652. dissect_megaco_Packagesdescriptor(tvbuff_t *tvb, proto_tree *megaco_tree_command_line,  gint tvb_RBRKT, gint tvb_previous_offset)
    2653. 

  2653. {
    2654. 

  2654. 

  2655.     gint tokenlen, tvb_current_offset, tvb_next_offset, tvb_help_offset;
    2656. 

  2656.     gint tvb_packages_end_offset, tvb_LBRKT;
    2657. 

  2657.     proto_tree  *megaco_packagesdescriptor_tree, *megaco_packagesdescriptor_ti;
    2658. 

  2658. 

  2659.     tokenlen =  (tvb_RBRKT+1) - tvb_previous_offset;
    2660. 

  2660. 

  2661.     megaco_packagesdescriptor_ti = proto_tree_add_item(megaco_tree_command_line,hf_megaco_packages_descriptor,tvb,tvb_previous_offset,tokenlen, ENC_ASCII|ENC_NA);
    2662. 

  2662.     megaco_packagesdescriptor_tree = proto_item_add_subtree(megaco_packagesdescriptor_ti, ett_megaco_packagesdescriptor);
    2663. 

  2663. 

  2664. 

  2665. 

  2666.     tvb_current_offset = tvb_find_guint8(tvb, tvb_previous_offset, tvb_RBRKT, '=');
    2667. 

  2667.     tvb_next_offset = tvb_find_guint8(tvb, tvb_previous_offset, tvb_RBRKT, '{');
    2668. 

  2668. 

  2669.     if ( tvb_current_offset < tvb_RBRKT && tvb_current_offset != -1 ){
    2670. 

  2670. 

  2671.         tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_current_offset +1);
    2672. 

  2672.         tvb_help_offset = megaco_tvb_skip_wsp_return(tvb, tvb_next_offset-1);
    2673. 

  2673. 

  2674.         tokenlen =  tvb_help_offset - tvb_current_offset;
    2675. 

  2675. 

  2676.         proto_tree_add_string(megaco_packagesdescriptor_tree, hf_megaco_requestid, tvb,
    2677. 

  2677.             tvb_current_offset, tokenlen,
    2678. 

  2678.             tvb_format_text(tvb, tvb_current_offset,
    2679. 

  2679.             tokenlen));
    2680. 

  2680. 

  2681.         tvb_packages_end_offset   = tvb_RBRKT;
    2682. 

  2682. 

  2683.         tvb_RBRKT = tvb_next_offset+1;
    2684. 

  2684.         tvb_LBRKT = tvb_next_offset+1;
    2685. 

  2685.         tvb_previous_offset = megaco_tvb_skip_wsp(tvb, tvb_next_offset+1);
    2686. 

  2686. 

  2687. 

  2688.         do {
    2689. 

  2689. 

  2690.             tvb_RBRKT = tvb_find_guint8(tvb, tvb_RBRKT+1,
    2691. 

  2691.                 tvb_packages_end_offset, '}');
    2692. 

  2692.             tvb_LBRKT = tvb_find_guint8(tvb, tvb_LBRKT,
    2693. 

  2693.                 tvb_packages_end_offset, '{');
    2694. 

  2694. 

  2695.             tvb_current_offset  = tvb_find_guint8(tvb, tvb_previous_offset,
    2696. 

  2696.                 tvb_packages_end_offset, ',');
    2697. 

  2697. 

  2698.             if (tvb_current_offset == -1 || tvb_current_offset > tvb_packages_end_offset){
    2699. 

  2699.                 tvb_current_offset = tvb_packages_end_offset;
    2700. 

  2700.             }
    2701. 

  2701. 

  2702. 

  2703.             /* Descriptor includes no parameters */
    2704. 

  2704. 

  2705.             if ( tvb_LBRKT > tvb_current_offset || tvb_LBRKT == -1 ){
    2706. 

  2706. 

  2707.                 tvb_RBRKT = megaco_tvb_skip_wsp_return(tvb, tvb_current_offset-1)-1;
    2708. 

  2708.             }
    2709. 

  2709. 

  2710.             /* Descriptor includes Parameters */
    2711. 

  2711. 

  2712.             if ( (tvb_current_offset > tvb_LBRKT && tvb_LBRKT != -1)){
    2713. 

  2713. 

  2714.                 while ( tvb_LBRKT != -1 && tvb_RBRKT > tvb_LBRKT ){
    2715. 

  2715. 

  2716.                     tvb_LBRKT  = tvb_find_guint8(tvb, tvb_LBRKT+1,
    2717. 

  2717.                         tvb_packages_end_offset, '{');
    2718. 

  2718.                     if ( tvb_LBRKT < tvb_RBRKT && tvb_LBRKT != -1)
    2719. 

  2719.                         tvb_RBRKT  = tvb_find_guint8(tvb, tvb_RBRKT+1,
    2720. 

  2720.                         tvb_packages_end_offset, '}');
    2721. 

  2721.                 }
    2722. 

  2722. 

  2723.             }
    2724. 

  2724. 

  2725.             tokenlen = tvb_RBRKT+1 - tvb_previous_offset;
    2726. 

  2726. 

  2727.             proto_tree_add_text(megaco_packagesdescriptor_tree, tvb, tvb_previous_offset, tokenlen,
    2728. 

  2728.                 "%s", tvb_format_text(tvb,tvb_previous_offset,
    2729. 

  2729.                 tokenlen));
    2730. 

  2730. 

  2731. 

  2732.             tvb_current_offset      = tvb_find_guint8(tvb, tvb_RBRKT,
    2733. 

  2733.                 tvb_packages_end_offset, ',');
    2734. 

  2734. 

  2735.             if (tvb_current_offset == -1 || tvb_current_offset > tvb_packages_end_offset ){
    2736. 

  2736.                 tvb_current_offset = tvb_packages_end_offset;
    2737. 

  2737.             }
    2738. 

  2738. 

  2739.             tvb_previous_offset = megaco_tvb_skip_wsp(tvb, tvb_current_offset+1);
    2740. 

  2740. 

  2741.             tvb_LBRKT = tvb_previous_offset;
    2742. 

  2742.             tvb_RBRKT = tvb_previous_offset;
    2743. 

  2743. 

  2744.         } while ( tvb_current_offset < tvb_packages_end_offset );
    2745. 

  2745.     }
    2746. 

  2746. 

  2747. }
    2748. 

  2748. /* The list of error code values is fetched from http://www.iana.org/assignments/megaco-h248    */
    2749. 

  2749. /* 2003-08-28                                           */
    2750. 

  2750. 

  2751. static const value_string MEGACO_error_code_vals[] = {
    2752. 

  2752. 

  2753.     {400, "Syntax error in message"},
    2754. 

  2754.     {401, "Protocol Error"},
    2755. 

  2755.     {402, "Unauthorized"},
    2756. 

  2756.     {403, "Syntax error in transaction request"},
    2757. 

  2757.     {406, "Version Not Supported"},
    2758. 

  2758.     {410, "Incorrect identifier"},
    2759. 

  2759.     {411, "The transaction refers to an unknown ContextId"},
    2760. 

  2760.     {412, "No ContextIDs available"},
    2761. 

  2761.     {421, "Unknown action or illegal combination of actions"},
    2762. 

  2762.     {422, "Syntax Error in Action"},
    2763. 

  2763.     {430, "Unknown TerminationID"},
    2764. 

  2764.     {431, "No TerminationID matched a wildcard"},
    2765. 

  2765.     {432, "Out of TerminationIDs or No TerminationID available"},
    2766. 

  2766.     {433, "TerminationID is already in a Context"},
    2767. 

  2767.     {434, "Max number of Terminations in a Context exceeded"},
    2768. 

  2768.     {435, "Termination ID is not in specified Context"},
    2769. 

  2769.     {440, "Unsupported or unknown Package"},
    2770. 

  2770.     {441, "Missing Remote or Local Descriptor"},
    2771. 

  2771.     {442, "Syntax Error in Command"},
    2772. 

  2772.     {443, "Unsupported or Unknown Command"},
    2773. 

  2773.     {444, "Unsupported or Unknown Descriptor"},
    2774. 

  2774.     {445, "Unsupported or Unknown Property"},
    2775. 

  2775.     {446, "Unsupported or Unknown Parameter"},
    2776. 

  2776.     {447, "Descriptor not legal in this command"},
    2777. 

  2777.     {448, "Descriptor appears twice in a command"},
    2778. 

  2778.     {450, "No such property in this package"},
    2779. 

  2779.     {451, "No such event in this package"},
    2780. 

  2780.     {452, "No such signal in this package"},
    2781. 

  2781.     {453, "No such statistic in this package"},
    2782. 

  2782.     {454, "No such parameter value in this package"},
    2783. 

  2783.     {455, "Property illegal in this Descriptor"},
    2784. 

  2784.     {456, "Property appears twice in this Descriptor"},
    2785. 

  2785.     {457, "Missing parameter in signal or event"},
    2786. 

  2786.     {458, "Unexpected Event/Request ID"},
    2787. 

  2787.     {459, "Unsupported or Unknown Profile"},
    2788. 

  2788.     {471, "Implied Add for Multiplex failure"},
    2789. 

  2789. 

  2790.     {500, "Internal software Failure in MG"},
    2791. 

  2791.     {501, "Not Implemented"},
    2792. 

  2792.     {502, "Not ready."},
    2793. 

  2793.     {503, "Service Unavailable"},
    2794. 

  2794.     {504, "Command Received from unauthorized entity"},
    2795. 

  2795.     {505, "Transaction Request Received before a Service Change Reply has been received"},
    2796. 

  2796.     {506, "Number of Transaction Pendings Exceeded"},
    2797. 

  2797.     {510, "Insufficient resources"},
    2798. 

  2798.     {512, "Media Gateway unequipped to detect requested Event"},
    2799. 

  2799.     {513, "Media Gateway unequipped to generate requested Signals"},
    2800. 

  2800.     {514, "Media Gateway cannot send the specified announcement"},
    2801. 

  2801.     {515, "Unsupported Media Type"},
    2802. 

  2802.     {517, "Unsupported or invalid mode"},
    2803. 

  2803.     {518, "Event buffer full"},
    2804. 

  2804.     {519, "Out of space to store digit map"},
    2805. 

  2805.     {520, "Digit Map undefined in the MG"},
    2806. 

  2806.     {521, "Termination is ServiceChanging"},
    2807. 

  2807.     {526, "Insufficient bandwidth"},
    2808. 

  2808.     {529, "Internal hardware failure in MG"},
    2809. 

  2809.     {530, "Temporary Network failure"},
    2810. 

  2810.     {531, "Permanent Network failure"},
    2811. 

  2811.     {532, "Audited Property, Statistic, Event or Signal does not exist"},
    2812. 

  2812.     {533, "Response exceeds maximum transport PDU size"},
    2813. 

  2813.     {534, "Illegal write or read only property"},
    2814. 

  2814.     {540, "Unexpected initial hook state"},
    2815. 

  2815.     {581, "Does Not Exist"},
    2816. 

  2816. 

  2817.     {600, "Illegal syntax within an announcement specification"},
    2818. 

  2818.     {601, "Variable type not supported"},
    2819. 

  2819.     {602, "Variable value out of range"},
    2820. 

  2820.     {603, "Category not supported"},
    2821. 

  2821.     {604, "Selector type not supported"},
    2822. 

  2822.     {605, "Selector value not supported"},
    2823. 

  2823.     {606, "Unknown segment ID"},
    2824. 

  2824.     {607, "Mismatch between play specification and provisioned data"},
    2825. 

  2825.     {608, "Provisioning error"},
    2826. 

  2826.     {609, "Invalid offset"},
    2827. 

  2827.     {610, "No free segment IDs"},
    2828. 

  2828.     {611, "Temporary segment not found"},
    2829. 

  2829.     {612, "Segment in use"},
    2830. 

  2830.     {613, "ISP port limit overrun"},
    2831. 

  2831.     {614, "No modems available"},
    2832. 

  2832.     {615, "Calling number unacceptable"},
    2833. 

  2833.     {616, "Called number unacceptable"},
    2834. 

  2834.     {  0, NULL }
    2835. 

  2835. };
    2836. 

  2836. 

  2837. 

  2838. 

  2839. static void
    2840. 

  2840. dissect_megaco_errordescriptor(tvbuff_t *tvb, proto_tree *megaco_tree_command_line,  gint tvb_RBRKT, gint tvb_previous_offset)
    2841. 

  2841. {
    2842. 

  2842. 

  2843.     gint                tokenlen;
    2844. 

  2844.     gint                error_code;
    2845. 

  2845.     guint8              error[4];
    2846. 

  2846.     gint                tvb_current_offset;
    2847. 

  2847.     proto_item*         item;
    2848. 

  2848.     proto_item*         hidden_item;
    2849. 

  2849. 

  2850.     tvb_current_offset = tvb_find_guint8(tvb, tvb_previous_offset , tvb_RBRKT, '=');
    2851. 

  2851.     tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_current_offset +1);
    2852. 

  2852.     tvb_get_nstringz0(tvb,tvb_current_offset,4,error);
    2853. 

  2853.     error_code = atoi(error);
    2854. 

  2854.     hidden_item = proto_tree_add_string(megaco_tree_command_line, hf_megaco_error_descriptor, tvb,
    2855. 

  2855.                             tvb_current_offset, 3,
    2856. 

  2856.                             tvb_format_text(tvb, tvb_current_offset,
    2857. 

  2857.                             3));
    2858. 

  2858.     PROTO_ITEM_SET_HIDDEN(hidden_item);
    2859. 

  2859. 

  2860.     tokenlen =  (tvb_RBRKT) - tvb_previous_offset+1;
    2861. 

  2861. 

  2862. 

  2863.     proto_tree_add_string(megaco_tree_command_line, hf_megaco_error_descriptor, tvb,
    2864. 

  2864.                             tvb_previous_offset, tokenlen,
    2865. 

  2865.                             tvb_format_text(tvb, tvb_previous_offset,
    2866. 

  2866.                             tokenlen));
    2867. 

  2867. 

  2868.     item = proto_tree_add_text(megaco_tree_command_line, tvb, tvb_current_offset, 3,
    2869. 

  2869.         "Error code: %s",
    2870. 

  2870.         val_to_str(error_code, MEGACO_error_code_vals,
    2871. 

  2871.           "Unknown (%u)"));
    2872. 

  2872. 

  2873.     PROTO_ITEM_SET_GENERATED(item);
    2874. 

  2874. 

  2875. }
    2876. 

  2876. static void
    2877. 

  2877. dissect_megaco_TerminationStatedescriptor(tvbuff_t *tvb, proto_tree *megaco_mediadescriptor_tree,  gint tvb_next_offset, gint tvb_current_offset)
    2878. 

  2878. {
    2879. 

  2879.     gint tokenlen;
    2880. 

  2880.     gint tvb_offset;
    2881. 

  2881.     guint8 tempchar;
    2882. 

  2882. 

  2883.     proto_tree  *megaco_TerminationState_tree, *megaco_TerminationState_ti;
    2884. 

  2884. 

  2885.     tvb_offset = tvb_find_guint8(tvb, tvb_current_offset , tvb_next_offset, '=');
    2886. 

  2886. 

  2887.     tokenlen = tvb_next_offset - tvb_current_offset;
    2888. 

  2888.     /*
    2889. 

  2889.     megaco_TerminationState_ti = proto_tree_add_item(megaco_mediadescriptor_tree,hf_megaco_TerminationState_descriptor,tvb,tvb_current_offset,tokenlen, ENC_ASCII|ENC_NA);
    2890. 

  2890.     megaco_TerminationState_tree = proto_item_add_subtree(megaco_TerminationState_ti, ett_megaco_TerminationState);
    2891. 

  2891.     */
    2892. 

  2892.     megaco_TerminationState_ti = proto_tree_add_text(megaco_mediadescriptor_tree, tvb, tvb_current_offset, tokenlen,
    2893. 

  2893.                                     "%s", tvb_format_text(tvb, tvb_current_offset, tokenlen));
    2894. 

  2894.     megaco_TerminationState_tree = proto_item_add_subtree(megaco_TerminationState_ti, ett_megaco_TerminationState);
    2895. 

  2895. 

  2896.     while ( tvb_offset < tvb_next_offset && tvb_offset != -1 ){
    2897. 

  2897. 

  2898.         tempchar = tvb_get_guint8(tvb, tvb_current_offset);
    2899. 

  2899.         tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    2900. 

  2900.         if ( (tempchar >= 'a')&& (tempchar <= 'z'))
    2901. 

  2901.             tempchar = tempchar - 0x20;
    2902. 

  2902. 

  2903.         switch ( tempchar ){
    2904. 

  2904. 

  2905.         case 'S':
    2906. 

  2906.             tvb_offset = tvb_find_guint8(tvb, tvb_current_offset , tvb_offset, ',');
    2907. 

  2907.             if ( tvb_offset == -1 || tvb_offset > tvb_next_offset ){
    2908. 

  2908.                 tvb_offset = tvb_next_offset;
    2909. 

  2909.             }
    2910. 

  2910. 

  2911.             tokenlen = tvb_offset - tvb_current_offset;
    2912. 

  2912. 

  2913.             proto_tree_add_string(megaco_TerminationState_tree, hf_megaco_Service_State, tvb,
    2914. 

  2914.                 tvb_current_offset, tokenlen,
    2915. 

  2915.                 tvb_format_text(tvb, tvb_current_offset,
    2916. 

  2916.                 tokenlen));
    2917. 

  2917. 

  2918.             break;
    2919. 

  2919. 

  2920.         case 'B':
    2921. 

  2921. 

  2922.             tvb_offset = tvb_find_guint8(tvb, tvb_current_offset , tvb_offset, ',');
    2923. 

  2923.             if ( tvb_offset == -1 || tvb_offset > tvb_next_offset ){
    2924. 

  2924.                 tvb_offset = tvb_next_offset;
    2925. 

  2925.             }
    2926. 

  2926. 

  2927.             tokenlen = tvb_offset - tvb_current_offset;
    2928. 

  2928. 

  2929.             proto_tree_add_string(megaco_TerminationState_tree, hf_megaco_Event_Buffer_Control, tvb,
    2930. 

  2930.                 tvb_current_offset, tokenlen,
    2931. 

  2931.                 tvb_format_text(tvb, tvb_current_offset,
    2932. 

  2932.                 tokenlen));
    2933. 

  2933. 

  2934.             break;
    2935. 

  2935. 

  2936.         case 'E':
    2937. 

  2937.             tvb_offset = tvb_find_guint8(tvb, tvb_current_offset , tvb_offset, ',');
    2938. 

  2938.             if ( tvb_offset == -1 || tvb_offset > tvb_next_offset ){
    2939. 

  2939.                 tvb_offset = tvb_next_offset;
    2940. 

  2940.             }
    2941. 

  2941. 

  2942.             tokenlen = tvb_offset - tvb_current_offset;
    2943. 

  2943. 

  2944.             proto_tree_add_string(megaco_TerminationState_tree, hf_megaco_Event_Buffer_Control, tvb,
    2945. 

  2945.                 tvb_current_offset, tokenlen,
    2946. 

  2946.                 tvb_format_text(tvb, tvb_current_offset,
    2947. 

  2947.                 tokenlen));
    2948. 

  2948. 

  2949.             break;
    2950. 

  2950. 

  2951.         default:
    2952. 

  2952.             tvb_offset = tvb_find_guint8(tvb, tvb_current_offset , tvb_offset, ',');
    2953. 

  2953.             if ( tvb_offset == -1 || tvb_offset > tvb_next_offset ){
    2954. 

  2954.                 tvb_offset = tvb_next_offset;
    2955. 

  2955.             }
    2956. 

  2956. 

  2957.             tokenlen = tvb_offset - tvb_current_offset;
    2958. 

  2958. 

  2959.             proto_tree_add_text(megaco_TerminationState_tree, tvb, tvb_current_offset, tokenlen,
    2960. 

  2960.                 "%s", tvb_format_text(tvb,tvb_current_offset,tokenlen));
    2961. 

  2961.             break;
    2962. 

  2962.         }
    2963. 

  2963. 

  2964. 

  2965.         tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    2966. 

  2966.         tvb_offset = tvb_find_guint8(tvb, tvb_current_offset , tvb_next_offset, '=');
    2967. 

  2967. 

  2968.     }
    2969. 

  2969.     proto_tree_add_text(megaco_mediadescriptor_tree, tvb, tvb_next_offset, 1,
    2970. 

  2970.             "%s", tvb_format_text(tvb, tvb_next_offset, 1));
    2971. 

  2971. 

  2972. }
    2973. 

  2973. 

  2974. static void
    2975. 

  2975. dissect_megaco_Localdescriptor(tvbuff_t *tvb, proto_tree *megaco_mediadescriptor_tree,packet_info *pinfo, gint tvb_next_offset, gint tvb_current_offset)
    2976. 

  2976. {
    2977. 

  2977.     gint tokenlen;
    2978. 

  2978.     tvbuff_t *next_tvb;
    2979. 

  2979. 

  2980.     proto_tree  *megaco_localdescriptor_tree, *megaco_localdescriptor_ti;
    2981. 

  2981. 

  2982.     tokenlen = tvb_next_offset - tvb_current_offset;
    2983. 

  2983. 

  2984. 

  2985.     /*
    2986. 

  2986.     megaco_localdescriptor_ti = proto_tree_add_item(megaco_mediadescriptor_tree,hf_megaco_Local_descriptor,tvb,tvb_current_offset,tokenlen, ENC_ASCII|ENC_NA);
    2987. 

  2987.     */
    2988. 

  2988.     megaco_localdescriptor_ti = proto_tree_add_text(megaco_mediadescriptor_tree, tvb, tvb_current_offset, tokenlen,
    2989. 

  2989.         "%s", tvb_format_text(tvb, tvb_current_offset, tokenlen));
    2990. 

  2990.     megaco_localdescriptor_tree = proto_item_add_subtree(megaco_localdescriptor_ti, ett_megaco_Localdescriptor);
    2991. 

  2991. 

  2992.     tokenlen = tvb_next_offset - tvb_current_offset;
    2993. 

  2993.     if ( tokenlen > 3 ){
    2994. 

  2994.         next_tvb = tvb_new_subset(tvb, tvb_current_offset, tokenlen, tokenlen);
    2995. 

  2995.         call_dissector(sdp_handle, next_tvb, pinfo, megaco_localdescriptor_tree);
    2996. 

  2996.     }
    2997. 

  2997. }
    2998. 

  2998. 

  2999. /*
    3000. 

  3000.  *   localControlDescriptor = LocalControlToken LBRKT localParm
    3001. 

  3001.  *                          *(COMMA localParm) RBRKT
    3002. 

  3002.  *   ; at-most-once per item
    3003. 

  3003.  *   localParm            = ( streamMode / propertyParm / reservedValueMode / reservedGroupMode )
    3004. 

  3004.  */
    3005. 

  3005. 

  3006. #define MEGACO_MODETOKEN            1
    3007. 

  3007. #define MEGACO_RESERVEDVALUETOKEN   2
    3008. 

  3008. #define MEGACO_RESERVEDGROUPTOKEN   3
    3009. 

  3009. #define MEGACO_H324_H223CAPR        4
    3010. 

  3010. #define MEGACO_H324_MUXTBL_IN       5
    3011. 

  3011. #define MEGACO_H324_MUXTBL_OUT      6
    3012. 

  3012. #define MEGACO_DS_DSCP              7
    3013. 

  3013. #define MEGACO_GM_SAF               8
    3014. 

  3014. #define MEGACO_GM_SAM               9
    3015. 

  3015. #define MEGACO_GM_SPF               10
    3016. 

  3016. #define MEGACO_GM_SPR               11
    3017. 

  3017. #define MEGACO_GM_ESAS              12
    3018. 

  3018. #define MEGACO_GM_LSA               13
    3019. 

  3019. #define MEGACO_GM_ESPS              14
    3020. 

  3020. #define MEGACO_GM_LSP               15
    3021. 

  3021. #define MEGACO_GM_RSB               16
    3022. 

  3022. 

  3023. static const megaco_tokens_t megaco_localParam_names[] = {
    3024. 

  3024.     { "Unknown-token",              NULL }, /* 0 Pad so that the real headers start at index 1 */
    3025. 

  3025.     /* streamMode */
    3026. 

  3026.     { "Mode",                       "MO" }, /* 1 */
    3027. 

  3027.     { "ReservedValue",              "RV" }, /* 2 */
    3028. 

  3028.     { "ReservedGroup",              "RG" }, /* 3 */
    3029. 

  3029.     /* propertyParm         = pkgdName parmValue
    3030. 

  3030.      * Add more package names as needed.
    3031. 

  3031.      */
    3032. 

  3032.     { "h324/h223capr",              NULL }, /* 4 */
    3033. 

  3033.     { "h324/muxtbl_in",             NULL }, /* 5 */
    3034. 

  3034.     { "h324/muxtbl_out",            NULL }, /* 6 */
    3035. 

  3035.     { "ds/dscp",                    NULL }, /* 7 */
    3036. 

  3036.     { "gm/saf",                     NULL }, /* 8 */
    3037. 

  3037.     { "gm/sam",                     NULL }, /* 9 */
    3038. 

  3038.     { "gm/spf",                     NULL }, /* 10 */
    3039. 

  3039.     { "gm/spr",                     NULL }, /* 11 */
    3040. 

  3040.     { "gm/esas",                    NULL }, /* 12 */
    3041. 

  3041.     { "gm/lsa",                     NULL }, /* 13 */
    3042. 

  3042.     { "gm/esps",                    NULL }, /* 14 */
    3043. 

  3043.     { "gm/lsp",                     NULL }, /* 15 */
    3044. 

  3044.     { "gm/rsb",                     NULL }, /* 16 */
    3045. 

  3045. };
    3046. 

  3046. 

  3047. /* Returns index of megaco_tokens_t */
    3048. 

  3048. static gint find_megaco_localParam_names(tvbuff_t *tvb, int offset, guint header_len)
    3049. 

  3049. {
    3050. 

  3050.     guint i;
    3051. 

  3051. 

  3052.     for (i = 1; i < array_length(megaco_localParam_names); i++) {
    3053. 

  3053.         if (header_len == strlen(megaco_localParam_names[i].name) &&
    3054. 

  3054.             tvb_strncaseeql(tvb, offset, megaco_localParam_names[i].name, header_len) == 0)
    3055. 

  3055.             return i;
    3056. 

  3056.         if (megaco_localParam_names[i].compact_name != NULL &&
    3057. 

  3057.             header_len == strlen(megaco_localParam_names[i].compact_name) &&
    3058. 

  3058.             tvb_strncaseeql(tvb, offset, megaco_localParam_names[i].compact_name, header_len) == 0)
    3059. 

  3059.             return i;
    3060. 

  3060.     }
    3061. 

  3061. 

  3062.     return -1;
    3063. 

  3063. }
    3064. 

  3064. 

  3065. static void
    3066. 

  3066. dissect_megaco_LocalControldescriptor(tvbuff_t *tvb, proto_tree *megaco_mediadescriptor_tree, packet_info *pinfo,  gint tvb_next_offset, gint tvb_current_offset)
    3067. 

  3067. {
    3068. 

  3068.     gint tokenlen;
    3069. 

  3069.     guint token_name_len;
    3070. 

  3070.     gint tvb_offset,tvb_help_offset;
    3071. 

  3071.     gint token_index = 0;
    3072. 

  3072.     gchar *msg;
    3073. 

  3073.     proto_item* item;
    3074. 

  3074.     guint8              code_str[3];
    3075. 

  3075. 

  3076.     /*proto_tree  *megaco_LocalControl_tree, *megaco_LocalControl_ti; */
    3077. 

  3077. 

  3078.     tvb_offset      = 0;
    3079. 

  3079. 

  3080.     /*
    3081. 

  3081.     tokenlen = tvb_next_offset - tvb_current_offset;
    3082. 

    3083. 

  3083.     megaco_LocalControl_ti = proto_tree_add_item(megaco_mediadescriptor_tree,hf_megaco_LocalControl_descriptor,tvb,tvb_current_offset,tokenlen, ENC_ASCII|ENC_NA);
    3084. 

  3084.     megaco_LocalControl_tree = proto_item_add_subtree(megaco_LocalControl_ti, ett_megaco_LocalControldescriptor);
    3085. 

  3085.     */
    3086. 

  3086.     while ( tvb_offset < tvb_next_offset && tvb_offset != -1 ){
    3087. 

  3087. 

  3088.         tvb_help_offset = tvb_current_offset;
    3089. 

  3089. 

  3090.         /*
    3091. 

  3091.          * Find local parameter name
    3092. 

  3092.          * localParm            = ( streamMode / propertyParm / reservedValueMode / reservedGroupMode )
    3093. 

  3093.          * pkgdName             = (PackageName SLASH ItemID) ;specific item
    3094. 

  3094.          *                    / (PackageName SLASH "*") ;all events in package
    3095. 

  3095.          *                    / ("*" SLASH "*") ; all events supported by the MG
    3096. 

  3096.          */
    3097. 

  3097.         /* Find token length */
    3098. 

  3098.         for (tvb_offset=tvb_current_offset; tvb_offset < tvb_next_offset; tvb_offset++){
    3099. 

  3099.             guint8 octet;
    3100. 

  3100.             octet = tvb_get_guint8(tvb, tvb_offset);
    3101. 

  3101.             if (!isalnum(octet)){
    3102. 

  3102.                 if ((octet!='/')&&(octet!='_')){
    3103. 

  3103.                     break;
    3104. 

  3104.                 }
    3105. 

  3105.             }
    3106. 

  3106.         }
    3107. 

  3107.         token_name_len = tvb_offset - tvb_current_offset;
    3108. 

  3108.         /* Debug Code
    3109. 

  3109.         proto_tree_add_text(megaco_LocalControl_tree, tvb, tvb_current_offset, token_name_len,
    3110. 

  3110.                 "%s", tvb_format_text(tvb,tvb_current_offset,token_name_len));
    3111. 

    3112. 

  3112.          */
    3113. 

  3113.         token_index = find_megaco_localParam_names(tvb, tvb_current_offset, token_name_len);
    3114. 

  3114.         /* Find start of parameter value */
    3115. 

  3115.         tvb_offset = tvb_find_guint8(tvb, tvb_offset , tvb_next_offset, '=');
    3116. 

  3116.         if (tvb_offset == -1)
    3117. 

  3117.             THROW(ReportedBoundsError);
    3118. 

  3118.         /* Start search after '=' in case there is no SP*/
    3119. 

  3119.         tvb_offset++;
    3120. 

  3120.         tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset);
    3121. 

  3121. 

  3122.         /* find if there are more parameters or not */
    3123. 

  3123.         tvb_offset = tvb_find_guint8(tvb, tvb_current_offset , tvb_offset, ',');
    3124. 

  3124.         if ( tvb_offset < 0 || tvb_offset > tvb_next_offset ){
    3125. 

  3125.             tvb_offset = tvb_next_offset;
    3126. 

  3126.         }
    3127. 

  3127. 

  3128.         tokenlen = megaco_tvb_skip_wsp_return(tvb,tvb_offset-1) - tvb_current_offset;
    3129. 

  3129.         /* Debug Code
    3130. 

  3130.         proto_tree_add_text(megaco_LocalControl_tree, tvb, tvb_current_offset, tokenlen,
    3131. 

  3131.                 "%s", tvb_format_text(tvb,tvb_current_offset,tokenlen));
    3132. 

    3133. 

  3133.          */
    3134. 

  3134.         switch ( token_index ){
    3135. 

  3135. 

  3136.         case MEGACO_MODETOKEN: /* Mode */
    3137. 

  3137.             proto_tree_add_string(megaco_mediadescriptor_tree, hf_megaco_mode, tvb,
    3138. 

  3138.                 tvb_current_offset, tokenlen,
    3139. 

  3139.                 tvb_format_text(tvb, tvb_current_offset,
    3140. 

  3140.                 tokenlen));
    3141. 

  3141.             col_append_fstr(pinfo->cinfo, COL_INFO, " (Mode:%s)",tvb_format_text(tvb, tvb_current_offset,tokenlen));
    3142. 

  3142.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3143. 

  3143.             break;
    3144. 

  3144. 

  3145.         case MEGACO_RESERVEDVALUETOKEN: /* ReservedValue */
    3146. 

  3146.             proto_tree_add_string(megaco_mediadescriptor_tree, hf_megaco_reserve_value, tvb,
    3147. 

  3147.                     tvb_current_offset, tokenlen,
    3148. 

  3148.                     tvb_format_text(tvb, tvb_current_offset,
    3149. 

  3149.                     tokenlen));
    3150. 

  3150. 

  3151.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3152. 

  3152.             break;
    3153. 

  3153.         case MEGACO_RESERVEDGROUPTOKEN: /* ReservedGroup */
    3154. 

  3154.             proto_tree_add_string(megaco_mediadescriptor_tree, hf_megaco_reserve_group, tvb,
    3155. 

  3155.                 tvb_current_offset, tokenlen,
    3156. 

  3156.                 tvb_format_text(tvb, tvb_current_offset,
    3157. 

  3157.                 tokenlen));
    3158. 

  3158.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3159. 

  3159.             break;
    3160. 

  3160. 

  3161.         case MEGACO_H324_H223CAPR: /* h324/h223capr */
    3162. 

  3162.             proto_tree_add_string(megaco_mediadescriptor_tree, hf_megaco_h324_h223capr, tvb,
    3163. 

  3163.                 tvb_current_offset, tokenlen,
    3164. 

  3164.                 tvb_format_text(tvb, tvb_current_offset,
    3165. 

  3165.                 tokenlen));
    3166. 

  3166. 

  3167.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3168. 

  3168.             tokenlen = tvb_offset - tvb_help_offset;
    3169. 

  3169.             msg=tvb_format_text(tvb,tvb_help_offset, tokenlen);
    3170. 

  3170.             dissect_megaco_h324_h223caprn(tvb, pinfo, megaco_mediadescriptor_tree, tvb_help_offset, tokenlen, msg);
    3171. 

  3171. 

  3172.             break;
    3173. 

  3173. 

  3174.         case MEGACO_H324_MUXTBL_IN: /* h324/muxtbl_in */
    3175. 

  3175. 

  3176.             proto_tree_add_string(megaco_mediadescriptor_tree, hf_megaco_h324_muxtbl_in, tvb,
    3177. 

  3177.                 tvb_current_offset, tokenlen,
    3178. 

  3178.                 tvb_format_text(tvb, tvb_current_offset,
    3179. 

  3179.                 tokenlen));
    3180. 

  3180. 

  3181.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3182. 

  3182. 

  3183.             tokenlen = tvb_offset - tvb_help_offset;
    3184. 

  3184.             msg=tvb_format_text(tvb,tvb_help_offset, tokenlen);
    3185. 

  3185.             /* Call the existing routine with tree = NULL to avoid an entry to the tree */
    3186. 

  3186.             dissect_megaco_h245(tvb, pinfo, NULL, tvb_help_offset, tokenlen, msg);
    3187. 

  3187. 

  3188.             break;
    3189. 

  3189. 

  3190.         case MEGACO_H324_MUXTBL_OUT:
    3191. 

  3191. 

  3192.             proto_tree_add_string(megaco_mediadescriptor_tree, hf_megaco_h324_muxtbl_out, tvb,
    3193. 

  3193.                 tvb_current_offset, tokenlen,
    3194. 

  3194.                 tvb_format_text(tvb, tvb_current_offset,
    3195. 

  3195.                 tokenlen));
    3196. 

  3196. 

  3197.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3198. 

  3198. 

  3199.             tokenlen = tvb_offset - tvb_help_offset;
    3200. 

  3200.             msg=tvb_format_text(tvb,tvb_help_offset, tokenlen);
    3201. 

  3201.             /* Call the existing routine with tree = NULL to avoid an entry to the tree */
    3202. 

  3202.             dissect_megaco_h245(tvb, pinfo, NULL, tvb_help_offset, tokenlen, msg);
    3203. 

  3203. 

  3204.             break;
    3205. 

  3205. 

  3206.         case MEGACO_DS_DSCP:
    3207. 

  3207.             item = proto_tree_add_string(megaco_mediadescriptor_tree, hf_megaco_ds_dscp, tvb,
    3208. 

  3208.                 tvb_current_offset, tokenlen,
    3209. 

  3209.                 tvb_format_text(tvb, tvb_current_offset,
    3210. 

  3210.                 tokenlen));
    3211. 

  3211. 

  3212.             tvb_get_nstringz0(tvb,tvb_current_offset,3,code_str);
    3213. 

  3213.             proto_item_append_text(item,"[ %s ]",
    3214. 

  3214.                                    val_to_str_ext((guint32)strtoul(code_str,NULL,16), &dscp_vals_ext,"Unknown (%u)"));
    3215. 

  3215. 

  3216.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3217. 

  3217.             break;
    3218. 

  3218. 

  3219.         case MEGACO_GM_SAF:
    3220. 

  3220.             tokenlen = tvb_offset - tvb_help_offset;
    3221. 

  3221.             item = proto_tree_add_text(megaco_mediadescriptor_tree, tvb, tvb_help_offset, tokenlen,
    3222. 

  3222.                 "%s", tvb_format_text(tvb,tvb_help_offset,
    3223. 

  3223.                 tokenlen));
    3224. 

  3224.             proto_item_append_text(item," [Remote Source Address Filtering]");
    3225. 

  3225.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3226. 

  3226.             break;
    3227. 

  3227.         case MEGACO_GM_SAM:
    3228. 

  3228.             tokenlen = tvb_offset - tvb_help_offset;
    3229. 

  3229.             item = proto_tree_add_text(megaco_mediadescriptor_tree, tvb, tvb_help_offset, tokenlen,
    3230. 

  3230.                 "%s", tvb_format_text(tvb,tvb_help_offset,
    3231. 

  3231.                 tokenlen));
    3232. 

  3232.             proto_item_append_text(item," [Remote Source Address Mask]");
    3233. 

  3233.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3234. 

  3234.             break;
    3235. 

  3235.         case MEGACO_GM_SPF:
    3236. 

  3236.             tokenlen = tvb_offset - tvb_help_offset;
    3237. 

  3237.             item = proto_tree_add_text(megaco_mediadescriptor_tree, tvb, tvb_help_offset, tokenlen,
    3238. 

  3238.                 "%s", tvb_format_text(tvb,tvb_help_offset,
    3239. 

  3239.                 tokenlen));
    3240. 

  3240.             proto_item_append_text(item," [Remote Source Port Filtering]");
    3241. 

  3241.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3242. 

  3242.             break;
    3243. 

  3243.         case MEGACO_GM_SPR:
    3244. 

  3244.             tokenlen = tvb_offset - tvb_help_offset;
    3245. 

  3245.             item = proto_tree_add_text(megaco_mediadescriptor_tree, tvb, tvb_help_offset, tokenlen,
    3246. 

  3246.                 "%s", tvb_format_text(tvb,tvb_help_offset,
    3247. 

  3247.                 tokenlen));
    3248. 

  3248.             proto_item_append_text(item," [Remote Source Port Range]");
    3249. 

  3249.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3250. 

  3250.             break;
    3251. 

  3251.         case MEGACO_GM_ESAS:
    3252. 

  3252.             tokenlen = tvb_offset - tvb_help_offset;
    3253. 

  3253.             item = proto_tree_add_text(megaco_mediadescriptor_tree, tvb, tvb_help_offset, tokenlen,
    3254. 

  3254.                 "%s", tvb_format_text(tvb,tvb_help_offset,
    3255. 

  3255.                 tokenlen));
    3256. 

  3256.             proto_item_append_text(item," [Explicit Source Address Setting]");
    3257. 

  3257.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3258. 

  3258.             break;
    3259. 

  3259.         default:
    3260. 

  3260.             tokenlen = tvb_offset - tvb_help_offset;
    3261. 

  3261.             proto_tree_add_text(megaco_mediadescriptor_tree, tvb, tvb_help_offset, tokenlen,
    3262. 

  3262.                 "%s", tvb_format_text(tvb,tvb_help_offset,
    3263. 

  3263.                 tokenlen));
    3264. 

  3264.             tvb_current_offset = megaco_tvb_skip_wsp(tvb, tvb_offset +1);
    3265. 

  3265. 

  3266.             break;
    3267. 

  3267.         }
    3268. 

  3268.     }
    3269. 

  3269. }
    3270. 

  3270. /* Copied from MGCP dissector, prints whole message in raw text */
    3271. 

  3271. 

  3272. static void tvb_raw_text_add(tvbuff_t *tvb, proto_tree *tree){
    3273. 

  3273. 

  3274.     gint tvb_linebegin,tvb_lineend,tvb_len,linelen;
    3275. 

  3275. 

  3276.     tvb_linebegin = 0;
    3277. 

  3277.     tvb_len = tvb_length(tvb);
    3278. 

  3278. 

  3279.     proto_tree_add_text(tree, tvb, 0, -1,"-------------- (RAW text output) ---------------");
    3280. 

  3280. 

  3281.     do {
    3282. 

  3282.         linelen = tvb_find_line_end(tvb,tvb_linebegin,-1,&tvb_lineend,FALSE);
    3283. 

  3283.         proto_tree_add_text(tree, tvb, tvb_linebegin, linelen,
    3284. 

  3284.                             "%s", tvb_format_text_wsp(tvb,tvb_linebegin,
    3285. 

  3285.                                                       linelen));
    3286. 

  3286.         tvb_linebegin = tvb_lineend;
    3287. 

  3287.     } while ( tvb_lineend < tvb_len );
    3288. 

  3288. }
    3289. 

  3289. 

  3290. /*
    3291. 

  3291. * megaco_tvb_skip_wsp - Returns the position in tvb of the first non-whitespace
    3292. 

  3292. *        character following offset or offset + maxlength -1 whichever
    3293. 

  3293. *        is smaller.
    3294. 

  3294. *
    3295. 

  3295. * Parameters:
    3296. 

  3296. * tvb - The tvbuff in which we are skipping whitespaces, tab and end_of_line characters.
    3297. 

  3297. * offset - The offset in tvb from which we begin trying to skip whitespace.
    3298. 

  3298. *
    3299. 

  3299. * Returns: The position in tvb of the first non-whitespace
    3300. 

  3300. */
    3301. 

  3301. static gint megaco_tvb_skip_wsp(tvbuff_t* tvb, gint offset ){
    3302. 

  3302.     gint counter = offset;
    3303. 

  3303.     gint end,tvb_len;
    3304. 

  3304.     guint8 tempchar;
    3305. 

  3305.     tvb_len = tvb_length(tvb);
    3306. 

  3306.     end = tvb_len;
    3307. 

  3307. 

  3308.     for(counter = offset; counter < end &&
    3309. 

  3309.         ((tempchar = tvb_get_guint8(tvb,counter)) == ' ' ||
    3310. 

  3310.         tempchar == '\t' || tempchar == '\n' || tempchar == '\r'); counter++);
    3311. 

  3311.     return (counter);
    3312. 

  3312. }
    3313. 

  3313. 

  3314. static gint megaco_tvb_skip_wsp_return(tvbuff_t* tvb, gint offset){
    3315. 

  3315.     gint counter = offset;
    3316. 

  3316.     gint end;
    3317. 

  3317.     guint8 tempchar;
    3318. 

  3318.     end = 0;
    3319. 

  3319. 

  3320.     for(counter = offset; counter > end &&
    3321. 

  3321.         ((tempchar = tvb_get_guint8(tvb,counter)) == ' ' ||
    3322. 

  3322.         tempchar == '\t' || tempchar == '\n' || tempchar == '\r'); counter--);
    3323. 

  3323.     counter++;
    3324. 

  3324.     return (counter);
    3325. 

  3325. }
    3326. 

  3326. 

  3327. static gint megaco_tvb_find_token(tvbuff_t* tvb, gint offset, gint maxlength){
    3328. 

  3328.     gint counter = 0;
    3329. 

  3329.     gint pos = offset;
    3330. 

  3330.     guchar needle;
    3331. 

  3331. 

  3332.     do {
    3333. 

  3333.         pos = tvb_pbrk_guint8(tvb, pos + 1, maxlength, "{}", &needle);
    3334. 

  3334.         if(pos == -1)
    3335. 

  3335.             return -1;
    3336. 

  3336.         switch(needle){
    3337. 

  3337.         case '{':
    3338. 

  3338.             counter++;
    3339. 

  3339.             break;
    3340. 

  3340.         case '}':
    3341. 

  3341.             counter--;
    3342. 

  3342.             break;
    3343. 

  3343.         default:
    3344. 

  3344.             break;
    3345. 

  3345.         }
    3346. 

  3346.     } while (counter>0);
    3347. 

  3347.     if(counter<0)
    3348. 

  3348.         return -1;
    3349. 

  3349.     else
    3350. 

  3350.     {
    3351. 

  3351.         pos = megaco_tvb_skip_wsp(tvb,pos+1);
    3352. 

  3352.         return pos;
    3353. 

  3353.     }
    3354. 

  3354. }
    3355. 

  3355. 

  3356. void proto_reg_handoff_megaco(void);
    3357. 

  3357. 

  3358. void
    3359. 

  3359. proto_register_megaco(void)
    3360. 

  3360. {
    3361. 

  3361.     static hf_register_info hf[] = {
    3362. 

  3362.         { &hf_megaco_audititem,
    3363. 

  3363.           { "Audit Item", "megaco.audititem", FT_STRING, BASE_NONE, NULL, 0x0,
    3364. 

  3364.             "Identity of item to be audited", HFILL }},
    3365. 

  3365.         { &hf_megaco_audit_descriptor,
    3366. 

  3366.           { "Audit Descriptor", "megaco.audit", FT_NONE, BASE_NONE, NULL, 0x0,
    3367. 

  3367.             "Audit Descriptor of the megaco Command", HFILL }},
    3368. 

  3368. #if 0
    3369. 

  3369.         { &hf_megaco_command_line,
    3370. 

  3370.           { "Command line", "megaco.command_line", FT_STRING, BASE_NONE, NULL, 0x0,
    3371. 

  3371.             "Commands of this message", HFILL }},
    3372. 

  3372. #endif
    3373. 

  3373.         { &hf_megaco_command,
    3374. 

  3374.           { "Command", "megaco.command", FT_STRING, BASE_NONE, NULL, 0x0,
    3375. 

  3375.             "Command of this message", HFILL }},
    3376. 

  3376.         { &hf_megaco_Context,
    3377. 

  3377.           { "Context", "megaco.context", FT_STRING, BASE_NONE, NULL, 0x0,
    3378. 

  3378.             "Context ID of this message", HFILL }},
    3379. 

  3379.         { &hf_megaco_digitmap_descriptor,
    3380. 

  3380.           { "DigitMap Descriptor", "megaco.digitmap", FT_STRING, BASE_NONE, NULL, 0x0,
    3381. 

  3381.             "DigitMap Descriptor of the megaco Command", HFILL }},
    3382. 

  3382.         { &hf_megaco_error_descriptor,
    3383. 

  3383.           { "ERROR Descriptor", "megaco.error", FT_STRING, BASE_NONE, NULL, 0x0,
    3384. 

  3384.             "Error Descriptor of the megaco Command", HFILL }},
    3385. 

  3385.         { &hf_megaco_error_Frame,
    3386. 

  3386.           { "ERROR frame", "megaco.error_frame", FT_STRING, BASE_NONE, NULL, 0x0,
    3387. 

  3387.             "Syntax error", HFILL }},
    3388. 

  3388.         { &hf_megaco_Event_Buffer_Control,
    3389. 

  3389.           { "Event Buffer Control", "megaco.eventbuffercontrol", FT_STRING, BASE_NONE, NULL, 0x0,
    3390. 

  3390.             "Event Buffer Control in Termination State Descriptor", HFILL }},
    3391. 

  3391. #if 0
    3392. 

  3392.         { &hf_megaco_events_descriptor,
    3393. 

  3393.           { "Events Descriptor", "megaco.events", FT_STRING, BASE_NONE, NULL, 0x0,
    3394. 

  3394.             "Events Descriptor of the megaco Command", HFILL }},
    3395. 

  3395. #endif
    3396. 

  3396. #if 0
    3397. 

  3397.         { &hf_megaco_Local_descriptor,
    3398. 

  3398.           { "Local Descriptor", "megaco.localdescriptor", FT_STRING, BASE_NONE, NULL, 0x0,
    3399. 

  3399.             "Local Descriptor in Media Descriptor", HFILL }},
    3400. 

  3400. #endif
    3401. 

  3401. #if 0
    3402. 

  3402.         { &hf_megaco_LocalControl_descriptor,
    3403. 

  3403.           { "Local Control Descriptor", "megaco.localcontroldescriptor", FT_STRING, BASE_NONE, NULL, 0x0,
    3404. 

  3404.             "Local Control Descriptor in Media Descriptor", HFILL }},
    3405. 

  3405. #endif
    3406. 

  3406. #if 0
    3407. 

  3407.         { &hf_megaco_media_descriptor,
    3408. 

  3408.           { "Media Descriptor", "megaco.media", FT_STRING, BASE_NONE, NULL, 0x0,
    3409. 

  3409.             "Media Descriptor of the megaco Command", HFILL }},
    3410. 

  3410. #endif
    3411. 

  3411.         { &hf_megaco_modem_descriptor,
    3412. 

  3412.           { "Modem Descriptor", "megaco.modem", FT_STRING, BASE_NONE, NULL, 0x0,
    3413. 

  3413.             "Modem Descriptor of the megaco Command", HFILL }},
    3414. 

  3414.         { &hf_megaco_mode,
    3415. 

  3415.           { "Mode", "megaco.mode", FT_STRING, BASE_NONE, NULL, 0x0,
    3416. 

  3416.             "Mode  sendonly/receiveonly/inactive/loopback", HFILL }},
    3417. 

  3417.         { &hf_megaco_multiplex_descriptor,
    3418. 

  3418.           { "Multiplex Descriptor", "megaco.multiplex", FT_STRING, BASE_NONE, NULL, 0x0,
    3419. 

  3419.             "Multiplex Descriptor of the megaco Command", HFILL }},
    3420. 

  3420. #if 0
    3421. 

  3421.         { &hf_megaco_observedevents_descriptor,
    3422. 

  3422.           { "Observed Events Descriptor", "megaco.observedevents", FT_STRING, BASE_NONE, NULL, 0x0,
    3423. 

  3423.             "Observed Events Descriptor of the megaco Command", HFILL }},
    3424. 

  3424. #endif
    3425. 

  3425.         { &hf_megaco_packages_descriptor,
    3426. 

  3426.           { "Packages Descriptor", "megaco.packagesdescriptor", FT_STRING, BASE_NONE, NULL, 0x0,
    3427. 

  3427.             NULL, HFILL }},
    3428. 

  3428.         { &hf_megaco_pkgdname,
    3429. 

  3429.           { "pkgdName", "megaco.pkgdname", FT_STRING, BASE_NONE, NULL, 0x0,
    3430. 

  3430.             "PackageName SLASH ItemID", HFILL }},
    3431. 

  3431. #if 0
    3432. 

  3432.         { &hf_megaco_Remote_descriptor,
    3433. 

  3433.           { "Remote Descriptor", "megaco.remotedescriptor", FT_STRING, BASE_NONE, NULL, 0x0,
    3434. 

  3434.             "Remote Descriptor in Media Descriptor", HFILL }},
    3435. 

  3435. #endif
    3436. 

  3436.         { &hf_megaco_reserve_group,
    3437. 

  3437.           { "Reserve Group", "megaco.reservegroup", FT_STRING, BASE_NONE, NULL, 0x0,
    3438. 

  3438.             "Reserve Group on or off", HFILL }},
    3439. 

  3439.         { &hf_megaco_h324_muxtbl_in,
    3440. 

  3440.           { "h324/muxtbl_in", "megaco.h324_muxtbl_in", FT_STRING, BASE_NONE, NULL, 0x0,
    3441. 

  3441.             NULL, HFILL }},
    3442. 

  3442.         { &hf_megaco_h324_muxtbl_out,
    3443. 

  3443.           { "h324/muxtbl_out", "megaco.h324_muxtbl_out", FT_STRING, BASE_NONE, NULL, 0x0,
    3444. 

  3444.             NULL, HFILL }},
    3445. 

  3445.         { &hf_megaco_ds_dscp,
    3446. 

  3446.           { "ds/dscp", "megaco.ds_dscp", FT_STRING, BASE_NONE, NULL, 0x0,
    3447. 

  3447.             "ds/dscp Differentiated Services Code Point", HFILL }},
    3448. 

  3448.         { &hf_megaco_h324_h223capr,
    3449. 

  3449.           { "h324/h223capr", "megaco.h324_h223capr", FT_STRING, BASE_NONE, NULL, 0x0,
    3450. 

  3450.             NULL, HFILL }},
    3451. 

  3451.         { &hf_megaco_reserve_value,
    3452. 

  3452.           { "Reserve Value", "megaco.reservevalue", FT_STRING, BASE_NONE, NULL, 0x0,
    3453. 

  3453.             "Reserve Value on or off", HFILL }},
    3454. 

  3454.         { &hf_megaco_requestid,
    3455. 

  3455.           { "RequestID", "megaco.requestid", FT_STRING, BASE_NONE, NULL, 0x0,
    3456. 

  3456.             "RequestID in Events or Observedevents Descriptor", HFILL }},
    3457. 

  3457. #if 0
    3458. 

  3458.         { &hf_megaco_servicechange_descriptor,
    3459. 

  3459.           { "Service Change Descriptor", "megaco.servicechange", FT_STRING, BASE_NONE, NULL, 0x0,
    3460. 

  3460.             "Service Change Descriptor of the megaco Command", HFILL }},
    3461. 

  3461. #endif
    3462. 

  3462.         { &hf_megaco_Service_State,
    3463. 

  3463.           { "Service State", "megaco.servicestates", FT_STRING, BASE_NONE, NULL, 0x0,
    3464. 

  3464.             "Service States in Termination State Descriptor", HFILL }},
    3465. 

  3465. #if 0
    3466. 

  3466.         { &hf_megaco_signal_descriptor,
    3467. 

  3467.           { "Signal Descriptor", "megaco.signal", FT_STRING, BASE_NONE, NULL, 0x0,
    3468. 

  3468.             "Signal Descriptor of the megaco Command", HFILL }},
    3469. 

  3469. #endif
    3470. 

  3470.         { &hf_megaco_statistics_descriptor,
    3471. 

  3471.           { "Statistics Descriptor", "megaco.statistics", FT_STRING, BASE_NONE, NULL, 0x0,
    3472. 

  3472.             "Statistics Descriptor of the megaco Command", HFILL }},
    3473. 

  3473.         { &hf_megaco_streamid,
    3474. 

  3474.           { "StreamID", "megaco.streamid", FT_STRING, BASE_NONE, NULL, 0x0,
    3475. 

  3475.             "StreamID in the Media Descriptor", HFILL }},
    3476. 

  3476.         { &hf_megaco_termid,
    3477. 

  3477.           { "Termination ID", "megaco.termid", FT_STRING, BASE_NONE, NULL, 0x0,
    3478. 

  3478.             "Termination ID of this Command", HFILL }},
    3479. 

  3479. #if 0
    3480. 

  3480.         { &hf_megaco_TerminationState_descriptor,
    3481. 

  3481.           { "Termination State Descriptor", "megaco.terminationstate", FT_STRING, BASE_NONE, NULL, 0x0,
    3482. 

  3482.             "Termination State Descriptor in Media Descriptor", HFILL }},
    3483. 

  3483. #endif
    3484. 

  3484.         { &hf_megaco_topology_descriptor,
    3485. 

  3485.           { "Topology Descriptor", "megaco.topology", FT_STRING, BASE_NONE, NULL, 0x0,
    3486. 

  3486.             "Topology Descriptor of the megaco Command", HFILL }},
    3487. 

  3487.         { &hf_megaco_transaction,
    3488. 

  3488.           { "Transaction", "megaco.transaction", FT_STRING, BASE_NONE, NULL, 0x0,
    3489. 

  3489.             "Message Originator", HFILL }},
    3490. 

  3490.         { &hf_megaco_transid,
    3491. 

  3491.           { "Transaction ID", "megaco.transid", FT_STRING, BASE_NONE, NULL, 0x0,
    3492. 

  3492.             "Transaction ID of this message", HFILL }},
    3493. 

  3493.         { &hf_megaco_mId,
    3494. 

  3494.           { "MediagatewayID", "megaco.mId", FT_STRING, BASE_NONE, NULL, 0x0,
    3495. 

  3495.             "Mediagateway ID", HFILL }},
    3496. 

  3496.         { &hf_megaco_version,
    3497. 

  3497.           { "Version", "megaco.version", FT_STRING, BASE_NONE, NULL, 0x0,
    3498. 

  3498.             NULL, HFILL }},
    3499. 

  3499. #if 0
    3500. 

  3500.         { &hf_megaco_h245,
    3501. 

  3501.           { "h245", "megaco.h245", FT_STRING, BASE_NONE, NULL, 0x0,
    3502. 

  3502.             "Embedded H.245 message", HFILL }},
    3503. 

  3503. #endif
    3504. 

  3504.         { &hf_megaco_h223Capability,
    3505. 

  3505.           { "h223Capability", "megaco.h245.h223Capability", FT_NONE, BASE_NONE, NULL, 0,
    3506. 

  3506.             "megaco.h245.H223Capability", HFILL }},
    3507. 

  3507. 

  3508.         GCP_HF_ARR_ELEMS("megaco",megaco_ctx_ids),
    3509. 

  3509. 

  3510.         /* Add more fields here */
    3511. 

  3511.     };
    3512. 

  3512.     static gint *ett[] = {
    3513. 

  3513.         &ett_megaco,
    3514. 

  3514.         &ett_megaco_message,
    3515. 

  3515.         &ett_megaco_message_body,
    3516. 

  3516.         &ett_megaco_context,
    3517. 

  3517.         &ett_megaco_command_line,
    3518. 

  3518.         &ett_megaco_descriptors,
    3519. 

  3519.         &ett_megaco_mediadescriptor,
    3520. 

  3520.         &ett_megaco_TerminationState,
    3521. 

  3521.         &ett_megaco_Remotedescriptor,
    3522. 

  3522.         &ett_megaco_Localdescriptor,
    3523. 

  3523.         &ett_megaco_LocalControldescriptor,
    3524. 

  3524.         &ett_megaco_auditdescriptor,
    3525. 

  3525.         &ett_megaco_eventsdescriptor,
    3526. 

  3526.         &ett_megaco_observedeventsdescriptor,
    3527. 

  3527.         &ett_megaco_observedevent,
    3528. 

  3528.         &ett_megaco_packagesdescriptor,
    3529. 

  3529.         &ett_megaco_requestedevent,
    3530. 

  3530.         &ett_megaco_signalsdescriptor,
    3531. 

  3531.         &ett_megaco_requestedsignal,
    3532. 

  3532.         &ett_megaco_h245,
    3533. 

  3533.         GCP_ETT_ARR_ELEMS(megaco_ctx_ids),
    3534. 

  3534.     };
    3535. 

  3535. 

  3536.     static ei_register_info ei[] = {
    3537. 

  3537.         { &ei_megaco_errored_command, { "megaco.errored_command", PI_RESPONSE_CODE, PI_WARN, "Errored Command", EXPFILL }},
    3538. 

  3538.     };
    3539. 

  3539. 

  3540.     module_t *megaco_module;
    3541. 

  3541.     expert_module_t* expert_megaco;
    3542. 

  3542. 

  3543.     proto_megaco = proto_register_protocol("MEGACO",
    3544. 

  3544.                                            "MEGACO", "megaco");
    3545. 

  3545. 

  3546.     register_dissector("megaco", dissect_megaco_text, proto_megaco);
    3547. 

  3547. 

  3548.     proto_register_field_array(proto_megaco, hf, array_length(hf));
    3549. 

  3549.     proto_register_subtree_array(ett, array_length(ett));
    3550. 

  3550.     expert_megaco = expert_register_protocol(proto_megaco);
    3551. 

  3551.     expert_register_field_array(expert_megaco, ei, array_length(ei));
    3552. 

  3552. 

  3553.     /* Register our configuration options, particularly our ports */
    3554. 

  3554. 

  3555.     megaco_module = prefs_register_protocol(proto_megaco, proto_reg_handoff_megaco);
    3556. 

  3556. 

  3557.     prefs_register_uint_preference(megaco_module, "sctp.txt_port",
    3558. 

  3558.                                    "MEGACO Text SCTP Port",
    3559. 

  3559.                                    "Set the SCTP port for MEGACO text messages",
    3560. 

  3560.                                    10, &global_megaco_txt_sctp_port);
    3561. 

  3561. 

  3562.     prefs_register_uint_preference(megaco_module, "tcp.txt_port",
    3563. 

  3563.                                    "MEGACO Text TCP Port",
    3564. 

  3564.                                    "Set the TCP port for MEGACO text messages",
    3565. 

  3565.                                    10, &global_megaco_txt_tcp_port);
    3566. 

  3566. 

  3567.     prefs_register_uint_preference(megaco_module, "udp.txt_port",
    3568. 

  3568.                                    "MEGACO Text UDP Port",
    3569. 

  3569.                                    "Set the UDP port for MEGACO text messages",
    3570. 

  3570.                                    10, &global_megaco_txt_udp_port);
    3571. 

  3571. 

  3572. #if 0
    3573. 

  3573.     prefs_register_uint_preference(megaco_module, "sctp.bin_port",
    3574. 

  3574.                                    "MEGACO Binary SCTP Port",
    3575. 

  3575.                                    "Set the SCTP port for MEGACO binary messages",
    3576. 

  3576.                                    10, &global_megaco_bin_sctp_port);
    3577. 

  3577. 

  3578.     prefs_register_uint_preference(megaco_module, "tcp.bin_port",
    3579. 

  3579.                                    "MEGACO Binary TCP Port",
    3580. 

  3580.                                    "Set the TCP port for MEGACO binary messages",
    3581. 

  3581.                                    10, &global_megaco_bin_tcp_port);
    3582. 

  3582. 

  3583.     prefs_register_uint_preference(megaco_module, "udp.bin_port",
    3584. 

  3584.                                    "MEGACO Binary UDP Port",
    3585. 

  3585.                                    "Set the UDP port for MEGACO binary messages",
    3586. 

  3586.                                    10, &global_megaco_bin_udp_port);
    3587. 

  3587. #endif
    3588. 

  3588. 

  3589.     prefs_register_bool_preference(megaco_module, "display_raw_text",
    3590. 

  3590.                                    "Display raw text for MEGACO message",
    3591. 

  3591.                                    "Specifies that the raw text of the "
    3592. 

  3592.                                    "MEGACO message should be displayed "
    3593. 

  3593.                                    "instead of (or in addition to) the "
    3594. 

  3594.                                    "dissection tree",
    3595. 

  3595.                                    &global_megaco_raw_text);
    3596. 

  3596. 

  3597.     prefs_register_bool_preference(megaco_module, "display_dissect_tree",
    3598. 

  3598.                                    "Display tree dissection for MEGACO message",
    3599. 

  3599.                                    "Specifies that the dissection tree of the "
    3600. 

  3600.                                    "MEGACO message should be displayed "
    3601. 

  3601.                                    "instead of (or in addition to) the "
    3602. 

  3602.                                    "raw text",
    3603. 

  3603.                                    &global_megaco_dissect_tree);
    3604. 

  3604.     prefs_register_bool_preference(megaco_module, "ctx_info",
    3605. 

  3605.                                    "Track Context",
    3606. 

  3606.                                    "Maintain relationships between transactions and contexts "
    3607. 

  3607.                                    "and display an extra tree showing context data",
    3608. 

  3608.                                    &keep_persistent_data);
    3609. 

  3609. 

  3610.     megaco_tap = register_tap("megaco");
    3611. 

  3611. 

  3612. }
    3613. 

  3613. 

  3614. /* Register all the bits needed with the filtering engine */
    3615. 

  3615. /* The registration hand-off routine */
    3616. 

  3616. void
    3617. 

  3617. proto_reg_handoff_megaco(void)
    3618. 

  3618. {
    3619. 

  3619.     static gboolean megaco_prefs_initialized = FALSE;
    3620. 

  3620.     static dissector_handle_t megaco_text_tcp_handle;
    3621. 

  3621.     /*
    3622. 

  3622.     * Variables to allow for proper deletion of dissector registration when
    3623. 

  3623.     * the user changes port from the gui.
    3624. 

  3624.     */
    3625. 

  3625.     static guint txt_sctp_port;
    3626. 

  3626.     static guint txt_tcp_port;
    3627. 

  3627.     static guint txt_udp_port;
    3628. 

  3628. #if 0
    3629. 

  3629.     static guint bin_sctp_port;
    3630. 

  3630.     static guint bin_tcp_port;
    3631. 

  3631.     static guint bin_udp_port;
    3632. 

  3632. #endif
    3633. 

  3633. 

  3634.     if (!megaco_prefs_initialized) {
    3635. 

  3635.         sdp_handle = find_dissector("sdp");
    3636. 

  3636.         h245_handle = find_dissector("h245dg");
    3637. 

  3637.         h248_handle = find_dissector("h248");
    3638. 

  3638.         h248_otp_handle = find_dissector("h248_otp");
    3639. 

  3639.         data_handle = find_dissector("data");
    3640. 

  3640. 

  3641.         megaco_text_handle = find_dissector("megaco");
    3642. 

  3642.         megaco_text_tcp_handle = create_dissector_handle(dissect_megaco_text_tcp, proto_megaco);
    3643. 

  3643. 

  3644.         dissector_add_uint("sctp.ppi", H248_PAYLOAD_PROTOCOL_ID,   megaco_text_handle);
    3645. 

  3645. 

  3646.         megaco_prefs_initialized = TRUE;
    3647. 

  3647.     } else {
    3648. 

  3648.         dissector_delete_uint("sctp.port", txt_sctp_port, megaco_text_handle);
    3649. 

  3649.         dissector_delete_uint("tcp.port", txt_tcp_port, megaco_text_tcp_handle);
    3650. 

  3650.         dissector_delete_uint("udp.port", txt_udp_port, megaco_text_handle);
    3651. 

  3651.     }
    3652. 

  3652. 

  3653.     /* Set our port number for future use */
    3654. 

  3654. 

  3655.     txt_sctp_port = global_megaco_txt_sctp_port;
    3656. 

  3656.     txt_tcp_port = global_megaco_txt_tcp_port;
    3657. 

  3657.     txt_udp_port = global_megaco_txt_udp_port;
    3658. 

  3658. 

  3659.     dissector_add_uint("sctp.port", global_megaco_txt_sctp_port, megaco_text_handle);
    3660. 

  3660.     dissector_add_uint("tcp.port", global_megaco_txt_tcp_port, megaco_text_tcp_handle);
    3661. 

  3661.     dissector_add_uint("udp.port", global_megaco_txt_udp_port, megaco_text_handle);
    3662. 

  3662. 

  3663. }
    3664. 

  3664. 

  3665.