PageRenderTime 38ms CodeModel.GetById 15ms RepoModel.GetById 1ms app.codeStats 1ms

/epan/dissectors/packet-ipv6.c

https://github.com/labx-technologies-llc/wireshark
C | 2899 lines | 2426 code | 305 blank | 168 comment | 169 complexity | 2808ed312cbe5e2ce39bfb3744b7a63c MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause 
    

  1. /* packet-ipv6.c
    2. 

  2.  * Routines for IPv6 packet disassembly
    3. 

  3.  *
    4. 

  4.  * $Id$
    5. 

  5.  *
    6. 

  6.  * Wireshark - Network traffic analyzer
    7. 

  7.  * By Gerald Combs <gerald@wireshark.org>
    8. 

  8.  * Copyright 1998 Gerald Combs
    9. 

  9.  *
    10. 

  10.  * SHIM6 support added by Matthijs Mekking <matthijs@NLnetLabs.nl>
    11. 

  11.  *
    12. 

  12.  * MobileIPv6 support added by Tomislav Borosa <tomislav.borosa@siemens.hr>
    13. 

  13.  *
    14. 

  14.  * This program is free software; you can redistribute it and/or
    15. 

  15.  * modify it under the terms of the GNU General Public License
    16. 

  16.  * as published by the Free Software Foundation; either version 2
    17. 

  17.  * of the License, or (at your option) any later version.
    18. 

  18.  *
    19. 

  19.  * This program is distributed in the hope that it will be useful,
    20. 

  20.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    21. 

  21.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    22. 

  22.  * GNU General Public License for more details.
    23. 

  23.  *
    24. 

  24.  * You should have received a copy of the GNU General Public License
    25. 

  25.  * along with this program; if not, write to the Free Software
    26. 

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

  27.  */
    28. 

  28. 

  29. #include "config.h"
    30. 

  30. 

  31. #include <math.h>
    32. 

  32. #include <glib.h>
    33. 

  33. #include <epan/packet.h>
    34. 

  34. #include <epan/expert.h>
    35. 

  35. #include <epan/ip_opts.h>
    36. 

  36. #include <epan/addr_resolv.h>
    37. 

  37. #include <epan/prefs.h>
    38. 

  38. #include <epan/reassemble.h>
    39. 

  39. #include <epan/ipproto.h>
    40. 

  40. #include <epan/ipv6-utils.h>
    41. 

  41. #include <epan/etypes.h>
    42. 

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

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

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

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

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

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

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

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

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

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

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

  53. 

  54. #ifdef HAVE_GEOIP_V6
    55. 

  55. #include <GeoIP.h>
    56. 

  56. #include <epan/geoip_db.h>
    57. 

  57. #endif /* HAVE_GEOIP_V6 */
    58. 

  58. 

  59. /* Differentiated Services Field. See RFCs 2474, 2597 and 2598. */
    60. 

  60. #define IPDSFIELD_DSCP_MASK     0xFC
    61. 

  61. #define IPDSFIELD_ECN_MASK      0x03
    62. 

  62. #define IPDSFIELD_DSCP_SHIFT    2
    63. 

  63. #define IPDSFIELD_DSCP(dsfield) (((dsfield)&IPDSFIELD_DSCP_MASK)>>IPDSFIELD_DSCP_SHIFT)
    64. 

  64. #define IPDSFIELD_ECN(dsfield)  ((dsfield)&IPDSFIELD_ECN_MASK)
    65. 

  65. #define IPDSFIELD_DSCP_DEFAULT  0x00
    66. 

  66. #define IPDSFIELD_DSCP_CS1      0x08
    67. 

  67. #define IPDSFIELD_DSCP_CS2      0x10
    68. 

  68. #define IPDSFIELD_DSCP_CS3      0x18
    69. 

  69. #define IPDSFIELD_DSCP_CS4      0x20
    70. 

  70. #define IPDSFIELD_DSCP_CS5      0x28
    71. 

  71. #define IPDSFIELD_DSCP_CS6      0x30
    72. 

  72. #define IPDSFIELD_DSCP_CS7      0x38
    73. 

  73. #define IPDSFIELD_DSCP_AF11     0x0A
    74. 

  74. #define IPDSFIELD_DSCP_AF12     0x0C
    75. 

  75. #define IPDSFIELD_DSCP_AF13     0x0E
    76. 

  76. #define IPDSFIELD_DSCP_AF21     0x12
    77. 

  77. #define IPDSFIELD_DSCP_AF22     0x14
    78. 

  78. #define IPDSFIELD_DSCP_AF23     0x16
    79. 

  79. #define IPDSFIELD_DSCP_AF31     0x1A
    80. 

  80. #define IPDSFIELD_DSCP_AF32     0x1C
    81. 

  81. #define IPDSFIELD_DSCP_AF33     0x1E
    82. 

  82. #define IPDSFIELD_DSCP_AF41     0x22
    83. 

  83. #define IPDSFIELD_DSCP_AF42     0x24
    84. 

  84. #define IPDSFIELD_DSCP_AF43     0x26
    85. 

  85. #define IPDSFIELD_DSCP_EF       0x2E
    86. 

  86. #define IPDSFIELD_ECT_MASK      0x02
    87. 

  87. #define IPDSFIELD_CE_MASK       0x01
    88. 

  88. 

  89. /* RPL Routing header */
    90. 

  90. #define IP6RRPL_BITMASK_CMPRI     0xF0000000
    91. 

  91. #define IP6RRPL_BITMASK_CMPRE     0x0F000000
    92. 

  92. #define IP6RRPL_BITMASK_PAD       0x00F00000
    93. 

  93. #define IP6RRPL_BITMASK_RESERVED  0x000FFFFF
    94. 

  94. 

  95. static int ipv6_tap = -1;
    96. 

  96. 

  97. static int proto_ipv6                           = -1;
    98. 

  98. static int hf_ipv6_version                      = -1;
    99. 

  99. static int hf_ip_version                        = -1;
    100. 

  100. static int hf_ipv6_class                        = -1;
    101. 

  101. static int hf_ipv6_flow                         = -1;
    102. 

  102. static int hf_ipv6_plen                         = -1;
    103. 

  103. static int hf_ipv6_nxt                          = -1;
    104. 

  104. static int hf_ipv6_hlim                         = -1;
    105. 

  105. static int hf_ipv6_src                          = -1;
    106. 

  106. static int hf_ipv6_src_host                     = -1;
    107. 

  107. static int hf_ipv6_src_sa_mac                   = -1;
    108. 

  108. static int hf_ipv6_src_isatap_ipv4              = -1;
    109. 

  109. static int hf_ipv6_src_6to4_gateway_ipv4        = -1;
    110. 

  110. static int hf_ipv6_src_6to4_sla_id              = -1;
    111. 

  111. static int hf_ipv6_src_teredo_server_ipv4       = -1;
    112. 

  112. static int hf_ipv6_src_teredo_port              = -1;
    113. 

  113. static int hf_ipv6_src_teredo_client_ipv4       = -1;
    114. 

  114. static int hf_ipv6_dst                          = -1;
    115. 

  115. static int hf_ipv6_dst_host                     = -1;
    116. 

  116. static int hf_ipv6_dst_sa_mac                   = -1;
    117. 

  117. static int hf_ipv6_dst_isatap_ipv4              = -1;
    118. 

  118. static int hf_ipv6_dst_6to4_gateway_ipv4        = -1;
    119. 

  119. static int hf_ipv6_dst_6to4_sla_id              = -1;
    120. 

  120. static int hf_ipv6_dst_teredo_server_ipv4       = -1;
    121. 

  121. static int hf_ipv6_dst_teredo_port              = -1;
    122. 

  122. static int hf_ipv6_dst_teredo_client_ipv4       = -1;
    123. 

  123. static int hf_ipv6_addr                         = -1;
    124. 

  124. static int hf_ipv6_host                         = -1;
    125. 

  125. static int hf_ipv6_sa_mac                       = -1;
    126. 

  126. static int hf_ipv6_isatap_ipv4                  = -1;
    127. 

  127. static int hf_ipv6_6to4_gateway_ipv4            = -1;
    128. 

  128. static int hf_ipv6_6to4_sla_id                  = -1;
    129. 

  129. static int hf_ipv6_teredo_server_ipv4           = -1;
    130. 

  130. static int hf_ipv6_teredo_port                  = -1;
    131. 

  131. static int hf_ipv6_teredo_client_ipv4           = -1;
    132. 

  132. static int hf_ipv6_opt                          = -1;
    133. 

  133. static int hf_ipv6_opt_type                     = -1;
    134. 

  134. static int hf_ipv6_opt_length                   = -1;
    135. 

  135. static int hf_ipv6_opt_pad1                     = -1;
    136. 

  136. static int hf_ipv6_opt_padn                     = -1;
    137. 

  137. static int hf_ipv6_opt_tel                      = -1;
    138. 

  138. static int hf_ipv6_opt_rtalert                  = -1;
    139. 

  139. static int hf_ipv6_opt_jumbo                    = -1;
    140. 

  140. static int hf_ipv6_opt_calipso_doi              = -1;
    141. 

  141. static int hf_ipv6_opt_calipso_cmpt_length      = -1;
    142. 

  142. static int hf_ipv6_opt_calipso_sens_level       = -1;
    143. 

  143. static int hf_ipv6_opt_calipso_checksum         = -1;
    144. 

  144. static int hf_ipv6_opt_calipso_cmpt_bitmap      = -1;
    145. 

  145. static int hf_ipv6_opt_qs_func                  = -1;
    146. 

  146. static int hf_ipv6_opt_qs_rate                  = -1;
    147. 

  147. static int hf_ipv6_opt_qs_ttl                   = -1;
    148. 

  148. static int hf_ipv6_opt_qs_ttl_diff              = -1;
    149. 

  149. static int hf_ipv6_opt_qs_unused                = -1;
    150. 

  150. static int hf_ipv6_opt_qs_nonce                 = -1;
    151. 

  151. static int hf_ipv6_opt_qs_reserved              = -1;
    152. 

  152. static int hf_ipv6_opt_rpl_flag                 = -1;
    153. 

  153. static int hf_ipv6_opt_rpl_flag_o               = -1;
    154. 

  154. static int hf_ipv6_opt_rpl_flag_r               = -1;
    155. 

  155. static int hf_ipv6_opt_rpl_flag_f               = -1;
    156. 

  156. static int hf_ipv6_opt_rpl_flag_rsv             = -1;
    157. 

  157. static int hf_ipv6_opt_rpl_instance_id          = -1;
    158. 

  158. static int hf_ipv6_opt_rpl_senderrank           = -1;
    159. 

  159. static int hf_ipv6_opt_experimental             = -1;
    160. 

  160. static int hf_ipv6_opt_unknown                  = -1;
    161. 

  161. static int hf_ipv6_dst_opt                      = -1;
    162. 

  162. static int hf_ipv6_hop_opt                      = -1;
    163. 

  163. static int hf_ipv6_unk_hdr                      = -1;
    164. 

  164. static int hf_ipv6_routing_hdr_opt              = -1;
    165. 

  165. static int hf_ipv6_routing_hdr_type             = -1;
    166. 

  166. static int hf_ipv6_routing_hdr_left             = -1;
    167. 

  167. static int hf_ipv6_routing_hdr_addr             = -1;
    168. 

  168. static int hf_ipv6_frag_nxt                     = -1;
    169. 

  169. static int hf_ipv6_frag_reserved                = -1;
    170. 

  170. static int hf_ipv6_frag_offset                  = -1;
    171. 

  171. static int hf_ipv6_frag_reserved_bits           = -1;
    172. 

  172. static int hf_ipv6_frag_more                    = -1;
    173. 

  173. static int hf_ipv6_frag_id                      = -1;
    174. 

  174. static int hf_ipv6_fragments                    = -1;
    175. 

  175. static int hf_ipv6_fragment                     = -1;
    176. 

  176. static int hf_ipv6_fragment_overlap             = -1;
    177. 

  177. static int hf_ipv6_fragment_overlap_conflict    = -1;
    178. 

  178. static int hf_ipv6_fragment_multiple_tails      = -1;
    179. 

  179. static int hf_ipv6_fragment_too_long_fragment   = -1;
    180. 

  180. static int hf_ipv6_fragment_error               = -1;
    181. 

  181. static int hf_ipv6_fragment_count               = -1;
    182. 

  182. static int hf_ipv6_reassembled_in               = -1;
    183. 

  183. static int hf_ipv6_reassembled_length           = -1;
    184. 

  184. static int hf_ipv6_reassembled_data             = -1;
    185. 

  185. 

  186. static int hf_ipv6_mipv6_home_address           = -1;
    187. 

  187. 

  188. static int hf_ipv6_routing_hdr_rpl_cmprI  = -1;
    189. 

  189. static int hf_ipv6_routing_hdr_rpl_cmprE  = -1;
    190. 

  190. static int hf_ipv6_routing_hdr_rpl_pad    = -1;
    191. 

  191. static int hf_ipv6_routing_hdr_rpl_reserved = -1;
    192. 

  192. static int hf_ipv6_routing_hdr_rpl_segments = -1;
    193. 

  193. static int hf_ipv6_routing_hdr_rpl_addr = -1;
    194. 

  194. static int hf_ipv6_routing_hdr_rpl_fulladdr = -1;
    195. 

  195. 

  196. static int hf_ipv6_shim6                = -1;
    197. 

  197. static int hf_ipv6_shim6_nxt            = -1;
    198. 

  198. static int hf_ipv6_shim6_len            = -1;
    199. 

  199. static int hf_ipv6_shim6_p              = -1;
    200. 

  200. /* context tag is 49 bits, cannot be used for filter yet */
    201. 

  201. static int hf_ipv6_shim6_ct             = -1;
    202. 

  202. static int hf_ipv6_shim6_type           = -1;
    203. 

  203. static int hf_ipv6_shim6_proto          = -1;
    204. 

  204. static int hf_ipv6_shim6_checksum       = -1;
    205. 

  205. static int hf_ipv6_shim6_checksum_bad   = -1;
    206. 

  206. static int hf_ipv6_shim6_checksum_good  = -1;
    207. 

  207. static int hf_ipv6_shim6_inonce         = -1; /* also for request nonce */
    208. 

  208. static int hf_ipv6_shim6_rnonce         = -1;
    209. 

  209. static int hf_ipv6_shim6_precvd         = -1;
    210. 

  210. static int hf_ipv6_shim6_psent          = -1;
    211. 

  211. static int hf_ipv6_shim6_psrc           = -1;
    212. 

  212. static int hf_ipv6_shim6_pdst           = -1;
    213. 

  213. static int hf_ipv6_shim6_pnonce         = -1;
    214. 

  214. static int hf_ipv6_shim6_pdata          = -1;
    215. 

  215. static int hf_ipv6_shim6_sulid          = -1;
    216. 

  216. static int hf_ipv6_shim6_rulid          = -1;
    217. 

  217. static int hf_ipv6_shim6_reap           = -1;
    218. 

  218. static int hf_ipv6_shim6_opt_type       = -1;
    219. 

  219. static int hf_ipv6_shim6_opt_len        = -1;
    220. 

  220. static int hf_ipv6_shim6_opt_total_len  = -1;
    221. 

  221. static int hf_ipv6_shim6_opt_loc_verif_methods = -1;
    222. 

  222. static int hf_ipv6_shim6_opt_critical   = -1;
    223. 

  223. static int hf_ipv6_shim6_opt_loclist    = -1;
    224. 

  224. static int hf_ipv6_shim6_locator        = -1;
    225. 

  225. static int hf_ipv6_shim6_loc_flag       = -1;
    226. 

  226. static int hf_ipv6_shim6_loc_prio       = -1;
    227. 

  227. static int hf_ipv6_shim6_loc_weight     = -1;
    228. 

  228. static int hf_ipv6_shim6_opt_locnum     = -1;
    229. 

  229. static int hf_ipv6_shim6_opt_elemlen    = -1;
    230. 

  230. static int hf_ipv6_shim6_opt_fii        = -1;
    231. 

  231. static int hf_ipv6_traffic_class_dscp   = -1;
    232. 

  232. static int hf_ipv6_traffic_class_ect    = -1;
    233. 

  233. static int hf_ipv6_traffic_class_ce     = -1;
    234. 

  234. 

  235. #ifdef HAVE_GEOIP_V6
    236. 

  236. static int hf_geoip_country             = -1;
    237. 

  237. static int hf_geoip_city                = -1;
    238. 

  238. static int hf_geoip_org                 = -1;
    239. 

  239. static int hf_geoip_isp                 = -1;
    240. 

  240. static int hf_geoip_asnum               = -1;
    241. 

  241. static int hf_geoip_lat                 = -1;
    242. 

  242. static int hf_geoip_lon                 = -1;
    243. 

  243. static int hf_geoip_src_country         = -1;
    244. 

  244. static int hf_geoip_src_city            = -1;
    245. 

  245. static int hf_geoip_src_org             = -1;
    246. 

  246. static int hf_geoip_src_isp             = -1;
    247. 

  247. static int hf_geoip_src_asnum           = -1;
    248. 

  248. static int hf_geoip_src_lat             = -1;
    249. 

  249. static int hf_geoip_src_lon             = -1;
    250. 

  250. static int hf_geoip_dst_country         = -1;
    251. 

  251. static int hf_geoip_dst_city            = -1;
    252. 

  252. static int hf_geoip_dst_org             = -1;
    253. 

  253. static int hf_geoip_dst_isp             = -1;
    254. 

  254. static int hf_geoip_dst_asnum           = -1;
    255. 

  255. static int hf_geoip_dst_lat             = -1;
    256. 

  256. static int hf_geoip_dst_lon             = -1;
    257. 

  257. #endif /* HAVE_GEOIP_V6 */
    258. 

  258. 

  259. static gint ett_ipv6                    = -1;
    260. 

  260. static gint ett_ipv6_opt                = -1;
    261. 

  261. static gint ett_ipv6_opt_flag           = -1;
    262. 

  262. static gint ett_ipv6_version            = -1;
    263. 

  263. static gint ett_ipv6_shim6              = -1;
    264. 

  264. static gint ett_ipv6_shim6_option       = -1;
    265. 

  265. static gint ett_ipv6_shim6_locators     = -1;
    266. 

  266. static gint ett_ipv6_shim6_verif_methods = -1;
    267. 

  267. static gint ett_ipv6_shim6_loc_pref     = -1;
    268. 

  268. static gint ett_ipv6_shim6_probes_sent  = -1;
    269. 

  269. static gint ett_ipv6_shim6_probe_sent   = -1;
    270. 

  270. static gint ett_ipv6_shim6_probes_rcvd  = -1;
    271. 

  271. static gint ett_ipv6_shim6_probe_rcvd   = -1;
    272. 

  272. static gint ett_ipv6_shim6_cksum        = -1;
    273. 

  273. static gint ett_ipv6_fragments          = -1;
    274. 

  274. static gint ett_ipv6_fragment           = -1;
    275. 

  275. static gint ett_ipv6_traffic_class      = -1;
    276. 

  276. 

  277. #ifdef HAVE_GEOIP_V6
    278. 

  278. static gint ett_geoip_info              = -1;
    279. 

  279. #endif /* HAVE_GEOIP_V6 */
    280. 

  280. 

  281. static expert_field ei_ipv6_dst_addr_not_multicast = EI_INIT;
    282. 

  282. static expert_field ei_ipv6_src_route_list_mult_inst_same_addr = EI_INIT;
    283. 

  283. static expert_field ei_ipv6_src_route_list_src_addr = EI_INIT;
    284. 

  284. static expert_field ei_ipv6_src_route_list_dst_addr = EI_INIT;
    285. 

  285. static expert_field ei_ipv6_src_route_list_multicast_addr = EI_INIT;
    286. 

  286. static expert_field ei_ipv6_cmpri_cmpre_pad = EI_INIT;
    287. 

  287. static expert_field ei_ipv6_routing_hdr_rpl_reserved = EI_INIT;
    288. 

  288. static expert_field ei_ipv6_opt_tel_invalid_len = EI_INIT;
    289. 

  289. static expert_field ei_ipv6_opt_jumbo_invalid_len = EI_INIT;
    290. 

  290. static expert_field ei_ipv6_opt_rtalert_invalid_len = EI_INIT;
    291. 

  291. static expert_field ei_ipv6_mipv6_home_address_invalid_len = EI_INIT;
    292. 

  292. static expert_field ei_ipv6_shim6_opt_elemlen_invalid = EI_INIT;
    293. 

  293. static expert_field ei_ipv6_shim6_checksum_bad = EI_INIT;
    294. 

  294. static expert_field ei_ipv6_routing_hdr_rpl_segments_ge0 = EI_INIT;
    295. 

  295. 

  296. static const fragment_items ipv6_frag_items = {
    297. 

  297.         &ett_ipv6_fragment,
    298. 

  298.         &ett_ipv6_fragments,
    299. 

  299.         &hf_ipv6_fragments,
    300. 

  300.         &hf_ipv6_fragment,
    301. 

  301.         &hf_ipv6_fragment_overlap,
    302. 

  302.         &hf_ipv6_fragment_overlap_conflict,
    303. 

  303.         &hf_ipv6_fragment_multiple_tails,
    304. 

  304.         &hf_ipv6_fragment_too_long_fragment,
    305. 

  305.         &hf_ipv6_fragment_error,
    306. 

  306.         &hf_ipv6_fragment_count,
    307. 

  307.         &hf_ipv6_reassembled_in,
    308. 

  308.         &hf_ipv6_reassembled_length,
    309. 

  309.         &hf_ipv6_reassembled_data,
    310. 

  310.         "IPv6 fragments"
    311. 

  311. };
    312. 

  312. 

  313. static dissector_handle_t data_handle;
    314. 

  314. 

  315. static dissector_table_t ip_dissector_table;
    316. 

  316. 

  317. /* Reassemble fragmented datagrams */
    318. 

  318. static gboolean ipv6_reassemble = TRUE;
    319. 

  319. 

  320. /* Place IPv6 summary in proto tree */
    321. 

  321. static gboolean ipv6_summary_in_tree = TRUE;
    322. 

  322. 

  323. #ifdef HAVE_GEOIP_V6
    324. 

  324. /* Look up addresses in GeoIP */
    325. 

  325. static gboolean ipv6_use_geoip = TRUE;
    326. 

  326. #endif /* HAVE_GEOIP_V6 */
    327. 

  327. 

  328. /* Perform strict RFC adherence checking */
    329. 

  329. static gboolean g_ipv6_rpl_srh_strict_rfc_checking = FALSE;
    330. 

  330. 

  331. #ifndef offsetof
    332. 

  332. #define offsetof(type, member)  ((size_t)(&((type *)0)->member))
    333. 

  333. #endif
    334. 

  334. 

  335. /*
    336. 

  336.  * defragmentation of IPv6
    337. 

  337.  */
    338. 

  338. static reassembly_table ipv6_reassembly_table;
    339. 

  339. 

  340. /* http://www.iana.org/assignments/icmpv6-parameters (last updated 2012-12-22) */
    341. 

  341. static const value_string ipv6_opt_vals[] = {
    342. 

  342.     { IP6OPT_PAD1, "Pad1" },
    343. 

  343.     { IP6OPT_PADN, "PadN" },
    344. 

  344.     { IP6OPT_TEL, "Tunnel Encapsulation Limit" },
    345. 

  345.     { IP6OPT_RTALERT, "Router Alert" },
    346. 

  346.     { IP6OPT_CALIPSO, "Calipso" },
    347. 

  347.     { IP6OPT_QUICKSTART, "Quick Start" },
    348. 

  348.     { IP6OPT_ENDI, "Endpoint Identification" },
    349. 

  349.     { IP6OPT_EXP_1E, "Experimental (0x1E)" },
    350. 

  350.     { IP6OPT_EXP_3E, "Experimental (0x3E)" },
    351. 

  351.     { IP6OPT_EXP_5E, "Experimental (0x5E)" },
    352. 

  352.     { IP6OPT_RPL, "RPL Option" },
    353. 

  353.     { IP6OPT_EXP_7E, "Experimental (0x7E)" },
    354. 

  354.     { IP6OPT_EXP_9E, "Experimental (0x9E)" },
    355. 

  355.     { IP6OPT_EXP_BE, "Experimental (0xBE)" },
    356. 

  356.     { IP6OPT_JUMBO, "Jumbo" },
    357. 

  357.     { IP6OPT_HOME_ADDRESS, "Home Address" },
    358. 

  358.     { IP6OPT_EXP_DE, "Experimental (0xDE)" },
    359. 

  359.     { IP6OPT_EXP_FE, "Experimental (0xFE)" },
    360. 

  360.     { 0, NULL }
    361. 

  361. };
    362. 

  362. 

  363. 

  364. void
    365. 

  365. capture_ipv6(const guchar *pd, int offset, int len, packet_counts *ld)
    366. 

  366. {
    367. 

  367.   guint8 nxt;
    368. 

  368.   int advance;
    369. 

  369. 

  370.   if (!BYTES_ARE_IN_FRAME(offset, len, 4+4+16+16)) {
    371. 

  371.     ld->other++;
    372. 

  372.     return;
    373. 

  373.   }
    374. 

  374.   nxt = pd[offset+6];           /* get the "next header" value */
    375. 

  375.   offset += 4+4+16+16;          /* skip past the IPv6 header */
    376. 

  376. 

  377. again:
    378. 

  378.    switch (nxt) {
    379. 

  379.    case IP_PROTO_HOPOPTS:
    380. 

  380.    case IP_PROTO_ROUTING:
    381. 

  381.    case IP_PROTO_DSTOPTS:
    382. 

  382.      if (!BYTES_ARE_IN_FRAME(offset, len, 2)) {
    383. 

  383.        ld->other++;
    384. 

  384.        return;
    385. 

  385.      }
    386. 

  386.      nxt = pd[offset];
    387. 

  387.      advance = (pd[offset+1] + 1) << 3;
    388. 

  388.      if (!BYTES_ARE_IN_FRAME(offset, len, advance)) {
    389. 

  389.        ld->other++;
    390. 

  390.        return;
    391. 

  391.      }
    392. 

  392.      offset += advance;
    393. 

  393.      goto again;
    394. 

  394.    case IP_PROTO_FRAGMENT:
    395. 

  395.      if (!BYTES_ARE_IN_FRAME(offset, len, 2)) {
    396. 

  396.        ld->other++;
    397. 

  397.        return;
    398. 

  398.      }
    399. 

  399.      nxt = pd[offset];
    400. 

  400.      advance = 8;
    401. 

  401.      if (!BYTES_ARE_IN_FRAME(offset, len, advance)) {
    402. 

  402.        ld->other++;
    403. 

  403.        return;
    404. 

  404.      }
    405. 

  405.      offset += advance;
    406. 

  406.      goto again;
    407. 

  407.    case IP_PROTO_AH:
    408. 

  408.      if (!BYTES_ARE_IN_FRAME(offset, len, 2)) {
    409. 

  409.        ld->other++;
    410. 

  410.        return;
    411. 

  411.      }
    412. 

  412.      nxt = pd[offset];
    413. 

  413.      advance = 8 + ((pd[offset+1] - 1) << 2);
    414. 

  414.      if (!BYTES_ARE_IN_FRAME(offset, len, advance)) {
    415. 

  415.        ld->other++;
    416. 

  416.        return;
    417. 

  417.      }
    418. 

  418.      offset += advance;
    419. 

  419.      goto again;
    420. 

  420.    case IP_PROTO_SHIM6:
    421. 

  421.    case IP_PROTO_SHIM6_OLD:
    422. 

  422.      if (!BYTES_ARE_IN_FRAME(offset, len, 2)) {
    423. 

  423.        ld->other++;
    424. 

  424.        return;
    425. 

  425.      }
    426. 

  426.      nxt = pd[offset];
    427. 

  427.      advance = (pd[offset+1] + 1) << 3;
    428. 

  428.      if (!BYTES_ARE_IN_FRAME(offset, len, advance)) {
    429. 

  429.        ld->other++;
    430. 

  430.        return;
    431. 

  431.      }
    432. 

  432.      offset += advance;
    433. 

  433.      goto again;
    434. 

  434.    }
    435. 

  435. 

  436.   switch(nxt) {
    437. 

  437.     case IP_PROTO_SCTP:
    438. 

  438.       ld->sctp++;
    439. 

  439.       break;
    440. 

  440.     case IP_PROTO_TCP:
    441. 

  441.       ld->tcp++;
    442. 

  442.       break;
    443. 

  443.     case IP_PROTO_UDP:
    444. 

  444.     case IP_PROTO_UDPLITE:
    445. 

  445.       ld->udp++;
    446. 

  446.       break;
    447. 

  447.     case IP_PROTO_ICMP:
    448. 

  448.     case IP_PROTO_ICMPV6:       /* XXX - separate counters? */
    449. 

  449.       ld->icmp++;
    450. 

  450.       break;
    451. 

  451.     case IP_PROTO_OSPF:
    452. 

  452.       ld->ospf++;
    453. 

  453.       break;
    454. 

  454.     case IP_PROTO_GRE:
    455. 

  455.       ld->gre++;
    456. 

  456.       break;
    457. 

  457.     case IP_PROTO_VINES:
    458. 

  458.       ld->vines++;
    459. 

  459.       break;
    460. 

  460.     default:
    461. 

  461.       ld->other++;
    462. 

  462.   }
    463. 

  463. }
    464. 

  464. 

  465. #ifdef HAVE_GEOIP_V6
    466. 

  466. static void
    467. 

  467. add_geoip_info_entry(proto_tree *geoip_info_item, tvbuff_t *tvb, gint offset, const struct e_in6_addr *ip, int isdst)
    468. 

  468. {
    469. 

  469.   proto_tree *geoip_info_tree;
    470. 

  470. 

  471.   guint num_dbs = geoip_db_num_dbs();
    472. 

  472.   guint item_cnt = 0;
    473. 

  473.   guint dbnum;
    474. 

  474. 

  475.   geoip_info_tree = proto_item_add_subtree(geoip_info_item, ett_geoip_info);
    476. 

  476. 

  477.   for (dbnum = 0; dbnum < num_dbs; dbnum++) {
    478. 

  478.     const char *geoip_str = geoip_db_lookup_ipv6(dbnum, *ip, NULL);
    479. 

  479.     int db_type = geoip_db_type(dbnum);
    480. 

  480. 

  481.     int geoip_hf, geoip_local_hf;
    482. 

  482. 

  483.     switch (db_type) {
    484. 

  484.       case GEOIP_COUNTRY_EDITION_V6:
    485. 

  485.         geoip_hf = hf_geoip_country;
    486. 

  486.         geoip_local_hf = (isdst) ? hf_geoip_dst_country : hf_geoip_src_country;
    487. 

  487.         break;
    488. 

  488. #if NUM_DB_TYPES > 31
    489. 

  489.       case GEOIP_CITY_EDITION_REV0_V6:
    490. 

  490.       case GEOIP_CITY_EDITION_REV1_V6:
    491. 

  491.         geoip_hf = hf_geoip_city;
    492. 

  492.         geoip_local_hf = (isdst) ? hf_geoip_dst_city : hf_geoip_src_city;
    493. 

  493.         break;
    494. 

  494.       case GEOIP_ORG_EDITION_V6:
    495. 

  495.         geoip_hf = hf_geoip_org;
    496. 

  496.         geoip_local_hf = (isdst) ? hf_geoip_dst_org : hf_geoip_src_org;
    497. 

  497.         break;
    498. 

  498.       case GEOIP_ISP_EDITION_V6:
    499. 

  499.         geoip_hf = hf_geoip_isp;
    500. 

  500.         geoip_local_hf = (isdst) ? hf_geoip_dst_isp : hf_geoip_src_isp;
    501. 

  501.         break;
    502. 

  502.       case GEOIP_ASNUM_EDITION_V6:
    503. 

  503.         geoip_hf = hf_geoip_asnum;
    504. 

  504.         geoip_local_hf = (isdst) ? hf_geoip_dst_asnum : hf_geoip_src_asnum;
    505. 

  505.         break;
    506. 

  506. #endif /* DB_NUM_TYPES */
    507. 

  507.       case WS_LAT_FAKE_EDITION:
    508. 

  508.         geoip_hf = hf_geoip_lat;
    509. 

  509.         geoip_local_hf = (isdst) ? hf_geoip_dst_lat : hf_geoip_src_lat;
    510. 

  510.         break;
    511. 

  511.       case WS_LON_FAKE_EDITION:
    512. 

  512.         geoip_hf = hf_geoip_lon;
    513. 

  513.         geoip_local_hf = (isdst) ? hf_geoip_dst_lon : hf_geoip_src_lon;
    514. 

  514.         break;
    515. 

  515.       default:
    516. 

  516.         continue;
    517. 

  517.         break;
    518. 

  518.     }
    519. 

  519. 

  520.     if (geoip_str) {
    521. 

  521.       proto_item *item;
    522. 

  522.       if (db_type == WS_LAT_FAKE_EDITION || db_type == WS_LON_FAKE_EDITION) {
    523. 

  523.         /* Convert latitude, longitude to double. Fix bug #5077 */
    524. 

  524.         item = proto_tree_add_double_format_value(geoip_info_tree, geoip_local_hf, tvb,
    525. 

  525.           offset, 16, g_ascii_strtod(geoip_str, NULL), "%s", geoip_str);
    526. 

  526.         PROTO_ITEM_SET_GENERATED(item);
    527. 

  527.         item  = proto_tree_add_double_format_value(geoip_info_tree, geoip_hf, tvb,
    528. 

  528.           offset, 16, g_ascii_strtod(geoip_str, NULL), "%s", geoip_str);
    529. 

  529.         PROTO_ITEM_SET_GENERATED(item);
    530. 

  530.         PROTO_ITEM_SET_HIDDEN(item);
    531. 

  531.       } else {
    532. 

  532.         item = proto_tree_add_unicode_string(geoip_info_tree, geoip_local_hf, tvb,
    533. 

  533.           offset, 16, geoip_str);
    534. 

  534.         PROTO_ITEM_SET_GENERATED(item);
    535. 

  535.         item  = proto_tree_add_unicode_string(geoip_info_tree, geoip_hf, tvb,
    536. 

  536.           offset, 16, geoip_str);
    537. 

  537.         PROTO_ITEM_SET_GENERATED(item);
    538. 

  538.         PROTO_ITEM_SET_HIDDEN(item);
    539. 

  539.       }
    540. 

  540. 

  541.       item_cnt++;
    542. 

  542.       proto_item_append_text(geoip_info_item, "%s%s", plurality(item_cnt, "", ", "), geoip_str);
    543. 

  543.     }
    544. 

  544.   }
    545. 

  545. 

  546.   if (item_cnt == 0)
    547. 

  547.     proto_item_append_text(geoip_info_item, "Unknown");
    548. 

  548. }
    549. 

  549. 

  550. static void
    551. 

  551. add_geoip_info(proto_tree *tree, tvbuff_t *tvb, gint offset, const struct e_in6_addr *src, const struct e_in6_addr *dst)
    552. 

  552. {
    553. 

  553.   guint num_dbs;
    554. 

  554.   proto_item *geoip_info_item;
    555. 

  555. 

  556.   num_dbs = geoip_db_num_dbs();
    557. 

  557.   if (num_dbs < 1)
    558. 

  558.         return;
    559. 

  559. 

  560.   geoip_info_item = proto_tree_add_text(tree, tvb, offset + IP6H_SRC, 16, "Source GeoIP: ");
    561. 

  561.   PROTO_ITEM_SET_GENERATED(geoip_info_item);
    562. 

  562.   add_geoip_info_entry(geoip_info_item, tvb, offset + IP6H_SRC, src, 0);
    563. 

  563. 

  564.   geoip_info_item = proto_tree_add_text(tree, tvb, offset + IP6H_DST, 16, "Destination GeoIP: ");
    565. 

  565.   PROTO_ITEM_SET_GENERATED(geoip_info_item);
    566. 

  566.   add_geoip_info_entry(geoip_info_item, tvb, offset + IP6H_DST, dst, 1);
    567. 

  567. }
    568. 

  568. #endif /* HAVE_GEOIP_V6 */
    569. 

  569. 

  570. static void
    571. 

  571. ipv6_reassemble_init(void)
    572. 

  572. {
    573. 

  573.   reassembly_table_init(&ipv6_reassembly_table,
    574. 

  574.                         &addresses_reassembly_table_functions);
    575. 

  575. }
    576. 

  576. 

  577. enum {
    578. 

  578.   IPv6_RT_HEADER_SOURCE_ROUTING=0,
    579. 

  579.   IPv6_RT_HEADER_NIMROD,
    580. 

  580.   IPv6_RT_HEADER_MobileIP,
    581. 

  581.   IPv6_RT_HEADER_RPL
    582. 

  582. };
    583. 

  583. 

  584. /* Routing Header Types */
    585. 

  585. static const value_string routing_header_type[] = {
    586. 

  586.   { IPv6_RT_HEADER_SOURCE_ROUTING, "IPv6 Source Routing" },
    587. 

  587.   { IPv6_RT_HEADER_NIMROD, "Nimrod" },
    588. 

  588.   { IPv6_RT_HEADER_MobileIP, "Mobile IP" },
    589. 

  589.   { IPv6_RT_HEADER_RPL, "RPL" },
    590. 

  590.   { 0, NULL }
    591. 

  591. };
    592. 

  592. 

  593. static int
    594. 

  594. dissect_routing6(tvbuff_t *tvb, int offset, proto_tree *tree, packet_info *pinfo) {
    595. 

  595.     struct ip6_rthdr rt;
    596. 

  596.     guint len, seg_left;
    597. 

  597.     proto_tree *rthdr_tree;
    598. 

  598.     proto_item *ti;
    599. 

  599.     guint8 buf[sizeof(struct ip6_rthdr0) + sizeof(struct e_in6_addr) * 23];
    600. 

  600. 

  601.     tvb_memcpy(tvb, (guint8 *)&rt, offset, sizeof(rt));
    602. 

  602.     len = (rt.ip6r_len + 1) << 3;
    603. 

  603. 

  604.     /* Assigning seg_left and the if (seg_left) {} blocks of code that follow,
    605. 

  605.      * along with any expert_add_info() calls, all need to execute when
    606. 

  606.      * appropriate, regardless of whether the tree is NULL or not. */
    607. 

  607.     if (1) {
    608. 

  608.         /* !!! specify length */
    609. 

  609.         ti = proto_tree_add_uint_format(tree, hf_ipv6_routing_hdr_opt, tvb,
    610. 

  610.                       offset, len, rt.ip6r_type,
    611. 

  611.                       "Routing Header, Type : %s (%u)",
    612. 

  612.                       val_to_str_const(rt.ip6r_type, routing_header_type, "Unknown"),
    613. 

  613.                       rt.ip6r_type);
    614. 

  614.         rthdr_tree = proto_item_add_subtree(ti, ett_ipv6);
    615. 

  615. 

  616.         proto_tree_add_text(rthdr_tree, tvb,
    617. 

  617.             offset + (int)offsetof(struct ip6_rthdr, ip6r_nxt), 1,
    618. 

  618.             "Next header: %s (%u)", ipprotostr(rt.ip6r_nxt), rt.ip6r_nxt);
    619. 

  619. 

  620.         proto_tree_add_text(rthdr_tree, tvb,
    621. 

  621.             offset + (int)offsetof(struct ip6_rthdr, ip6r_len), 1,
    622. 

  622.             "Length: %u (%d bytes)", rt.ip6r_len, len);
    623. 

  623. 

  624.         proto_tree_add_item(rthdr_tree, hf_ipv6_routing_hdr_type, tvb,
    625. 

  625.                   offset + (int)offsetof(struct ip6_rthdr, ip6r_type), 1, ENC_BIG_ENDIAN);
    626. 

  626. 

  627.         proto_tree_add_item(rthdr_tree, hf_ipv6_routing_hdr_left, tvb,
    628. 

  628.                   offset + (int)offsetof(struct ip6_rthdr, ip6r_segleft), 1, ENC_BIG_ENDIAN);
    629. 

  629. 

  630.         seg_left = tvb_get_guint8(tvb, offset + (int)offsetof(struct ip6_rthdr, ip6r_segleft));
    631. 

  631. 

  632.         if (rt.ip6r_type == IPv6_RT_HEADER_SOURCE_ROUTING && len <= sizeof(buf)) {
    633. 

  633.             struct e_in6_addr *a;
    634. 

  634.             int n;
    635. 

  635.             struct ip6_rthdr0 *rt0;
    636. 

  636. 

  637.             tvb_memcpy(tvb, buf, offset, len);
    638. 

  638.             rt0 = (struct ip6_rthdr0 *)buf;
    639. 

  639. 

  640.             for (a = rt0->ip6r0_addr, n = 0;
    641. 

  641.                     a < (struct e_in6_addr *)(buf + len); a++, n++) {
    642. 

  642. 

  643.               proto_tree_add_item(rthdr_tree, hf_ipv6_routing_hdr_addr, tvb,
    644. 

  644.                               offset + (int)(offsetof(struct ip6_rthdr0, ip6r0_addr)
    645. 

  645.                                      + n * sizeof(struct e_in6_addr)),
    646. 

  646.                               (int)sizeof(struct e_in6_addr), ENC_NA);
    647. 

  647.               if (seg_left)
    648. 

  648.                   TVB_SET_ADDRESS(&pinfo->dst, AT_IPv6, tvb,
    649. 

  649.                                   offset + (int)offsetof(struct ip6_rthdr0, ip6r0_addr) + n * (int)sizeof(struct e_in6_addr), 16);
    650. 

  650.             }
    651. 

  651.         }
    652. 

  652.         if (rt.ip6r_type == IPv6_RT_HEADER_MobileIP) {
    653. 

  653.             proto_tree_add_item(rthdr_tree, hf_ipv6_mipv6_home_address, tvb,
    654. 

  654.                               offset + 8, 16, ENC_NA);
    655. 

  655.             if (seg_left)
    656. 

  656.                 TVB_SET_ADDRESS(&pinfo->dst, AT_IPv6, tvb, offset + 8, 16);
    657. 

  657.         }
    658. 

  658.         if (rt.ip6r_type == IPv6_RT_HEADER_RPL) {
    659. 

  659.             guint8 cmprI;
    660. 

  660.             guint8 cmprE;
    661. 

  661.             guint8 pad;
    662. 

  662.             guint32 reserved;
    663. 

  663.             gint segments;
    664. 

  664. 

  665.             /* IPv6 destination address used for elided bytes */
    666. 

  666.             struct e_in6_addr dstAddr;
    667. 

  667.             /* IPv6 source address used for strict checking */
    668. 

  668.             struct e_in6_addr srcAddr;
    669. 

  669.             offset += 4;
    670. 

  670.             memcpy((guint8 *)&dstAddr, (guint8 *)pinfo->dst.data, pinfo->dst.len);
    671. 

  671.             memcpy((guint8 *)&srcAddr, (guint8 *)pinfo->src.data, pinfo->src.len);
    672. 

  672. 

  673.             /* from RFC6554: Multicast addresses MUST NOT appear in the IPv6 Destination Address field */
    674. 

  674.             if(g_ipv6_rpl_srh_strict_rfc_checking && E_IN6_IS_ADDR_MULTICAST(&dstAddr)){
    675. 

  675.                 expert_add_info(pinfo, ti, &ei_ipv6_dst_addr_not_multicast);
    676. 

  676.             }
    677. 

  677. 

  678.             proto_tree_add_item(rthdr_tree, hf_ipv6_routing_hdr_rpl_cmprI, tvb, offset, 4, ENC_BIG_ENDIAN);
    679. 

  679.             proto_tree_add_item(rthdr_tree, hf_ipv6_routing_hdr_rpl_cmprE, tvb, offset, 4, ENC_BIG_ENDIAN);
    680. 

  680.             proto_tree_add_item(rthdr_tree, hf_ipv6_routing_hdr_rpl_pad, tvb, offset, 4, ENC_BIG_ENDIAN);
    681. 

  681. 

  682.             cmprI = tvb_get_guint8(tvb, offset) & 0xF0;
    683. 

  683.             cmprE = tvb_get_guint8(tvb, offset) & 0x0F;
    684. 

  684.             pad   = tvb_get_guint8(tvb, offset + 1) & 0xF0;
    685. 

  685. 

  686.             /* Shift bytes over */
    687. 

  687.             cmprI >>= 4;
    688. 

  688.             pad >>= 4;
    689. 

  689. 

  690.             /* from RFC6554: when CmprI and CmprE are both 0, Pad MUST carry a value of 0 */
    691. 

  691.             if(g_ipv6_rpl_srh_strict_rfc_checking && (cmprI == 0 && cmprE == 0 && pad != 0)){
    692. 

  692.                 expert_add_info_format_text(pinfo, ti, &ei_ipv6_cmpri_cmpre_pad, "When cmprI equals 0 and cmprE equals 0, pad MUST equal 0 but instead was %d", pad);
    693. 

  693.             }
    694. 

  694. 

  695.             proto_tree_add_item(rthdr_tree, hf_ipv6_routing_hdr_rpl_reserved, tvb, offset, 4, ENC_BIG_ENDIAN);
    696. 

  696.             reserved = tvb_get_bits32(tvb, ((offset + 1) * 8) + 4, 20, ENC_BIG_ENDIAN);
    697. 

  697. 

  698.             if(g_ipv6_rpl_srh_strict_rfc_checking && reserved != 0){
    699. 

  699.                 expert_add_info_format_text(pinfo, ti, &ei_ipv6_routing_hdr_rpl_reserved, "Reserved field must equal 0 but instead was %d", reserved);
    700. 

  700.             }
    701. 

  701. 

  702.             /* from RFC6554:
    703. 

  703.             n = (((Hdr Ext Len * 8) - Pad - (16 - CmprE)) / (16 - CmprI)) + 1 */
    704. 

  704.             segments = (((rt.ip6r_len * 8) - pad - (16 - cmprE)) / (16 - cmprI)) + 1;
    705. 

  705.             ti = proto_tree_add_int(rthdr_tree, hf_ipv6_routing_hdr_rpl_segments, tvb, offset, 2, segments);
    706. 

  706.             PROTO_ITEM_SET_GENERATED(ti);
    707. 

  707. 

  708.             if (segments < 0) {
    709. 

  709.                 /* This error should always be reported */
    710. 

  710.                 expert_add_info_format_text(pinfo, ti, &ei_ipv6_routing_hdr_rpl_segments_ge0, "Calculated total segments must be greater than or equal to 0, instead was %d", segments);
    711. 

  711.             } else {
    712. 

  712. 

  713.                 offset += 4;
    714. 

  714. 

  715.                 /* We use cmprI for internal (e.g.: not last) address for how many bytes to elide, so actual bytes present = 16-CmprI */
    716. 

  716.                 while(segments > 1) {
    717. 

  717.                     struct e_in6_addr addr;
    718. 

  718. 

  719.                     proto_tree_add_item(rthdr_tree, hf_ipv6_routing_hdr_rpl_addr, tvb, offset, (16-cmprI), ENC_NA);
    720. 

  720.                     /* Display Full Address */
    721. 

  721.                     memcpy((guint8 *)&addr, (guint8 *)&dstAddr, sizeof(dstAddr));
    722. 

  722.                     tvb_memcpy(tvb, (guint8 *)&addr + cmprI, offset, (16-cmprI));
    723. 

  723.                     ti = proto_tree_add_ipv6(rthdr_tree, hf_ipv6_routing_hdr_rpl_fulladdr, tvb, offset, (16-cmprI), (guint8 *)&addr);
    724. 

  724.                     PROTO_ITEM_SET_GENERATED(ti);
    725. 

  725.                     offset += (16-cmprI);
    726. 

  726.                     segments--;
    727. 

  727. 

  728.                     if(g_ipv6_rpl_srh_strict_rfc_checking){
    729. 

  729.                         /* from RFC6554: */
    730. 

  730.                         /* The SRH MUST NOT specify a path that visits a node more than once. */
    731. 

  731.                         /* To do this, we will just check the current 'addr' against the next addresses */
    732. 

  732.                         gint tempSegments;
    733. 

  733.                         gint tempOffset;
    734. 

  734.                         tempSegments = segments; /* Has already been decremented above */
    735. 

  735.                         tempOffset = offset; /* Has already been moved */
    736. 

  736.                         while(tempSegments > 1) {
    737. 

  737.                             struct e_in6_addr tempAddr;
    738. 

  738.                             memcpy((guint8 *)&tempAddr, (guint8 *)&dstAddr, sizeof(dstAddr));
    739. 

  739.                             tvb_memcpy(tvb, (guint8 *)&tempAddr + cmprI, tempOffset, (16-cmprI));
    740. 

  740.                             /* Compare the addresses */
    741. 

  741.                             if (memcmp(addr.bytes, tempAddr.bytes, 16) == 0) {
    742. 

  742.                                 /* Found a later address that is the same */
    743. 

  743.                                 expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_mult_inst_same_addr);
    744. 

  744.                                 break;
    745. 

  745.                             }
    746. 

  746.                             tempOffset += (16-cmprI);
    747. 

  747.                             tempSegments--;
    748. 

  748.                         }
    749. 

  749.                         if (tempSegments == 1) {
    750. 

  750.                             struct e_in6_addr tempAddr;
    751. 

  751. 

  752.                             memcpy((guint8 *)&tempAddr, (guint8 *)&dstAddr, sizeof(dstAddr));
    753. 

  753.                             tvb_memcpy(tvb, (guint8 *)&tempAddr + cmprE, tempOffset, (16-cmprE));
    754. 

  754.                             /* Compare the addresses */
    755. 

  755.                             if (memcmp(addr.bytes, tempAddr.bytes, 16) == 0) {
    756. 

  756.                                 /* Found a later address that is the same */
    757. 

  757.                                 expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_mult_inst_same_addr);
    758. 

  758.                             }
    759. 

  759.                         }
    760. 

  760.                         /* IPv6 Source and Destination addresses of the encapsulating datagram (MUST) not appear in the SRH*/
    761. 

  761.                         if (memcmp(addr.bytes, srcAddr.bytes, 16) == 0) {
    762. 

  762.                             expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_src_addr);
    763. 

  763.                         }
    764. 

  764. 

  765.                         if (memcmp(addr.bytes, dstAddr.bytes, 16) == 0) {
    766. 

  766.                             expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_dst_addr);
    767. 

  767.                         }
    768. 

  768. 

  769.                         /* Multicast addresses MUST NOT appear in the in SRH */
    770. 

  770.                         if(E_IN6_IS_ADDR_MULTICAST(&addr)){
    771. 

  771.                             expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_multicast_addr);
    772. 

  772.                         }
    773. 

  773.                     }
    774. 

  774.                 }
    775. 

  775. 

  776.                 /* We use cmprE for last address for how many bytes to elide, so actual bytes present = 16-CmprE */
    777. 

  777.                 if (segments == 1) {
    778. 

  778.                     struct e_in6_addr addr;
    779. 

  779. 

  780.                     proto_tree_add_item(rthdr_tree, hf_ipv6_routing_hdr_rpl_addr, tvb, offset, (16-cmprI), ENC_NA);
    781. 

  781.                     /* Display Full Address */
    782. 

  782.                     memcpy((guint8 *)&addr, (guint8 *)&dstAddr, sizeof(dstAddr));
    783. 

  783.                     tvb_memcpy(tvb, (guint8 *)&addr + cmprE, offset, (16-cmprE));
    784. 

  784.                     ti = proto_tree_add_ipv6(rthdr_tree, hf_ipv6_routing_hdr_rpl_fulladdr, tvb, offset, (16-cmprE), (guint8 *)&addr);
    785. 

  785.                     PROTO_ITEM_SET_GENERATED(ti);
    786. 

  786.                     /* offset += (16-cmprE); */
    787. 

  787. 

  788.                     if(g_ipv6_rpl_srh_strict_rfc_checking){
    789. 

  789.                         /* IPv6 Source and Destination addresses of the encapsulating datagram (MUST) not appear in the SRH*/
    790. 

  790.                         if (memcmp(addr.bytes, srcAddr.bytes, 16) == 0) {
    791. 

  791.                             expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_src_addr);
    792. 

  792.                         }
    793. 

  793. 

  794.                         if (memcmp(addr.bytes, dstAddr.bytes, 16) == 0) {
    795. 

  795.                             expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_dst_addr);
    796. 

  796.                         }
    797. 

  797. 

  798.                         /* Multicast addresses MUST NOT appear in the in SRH */
    799. 

  799.                         if(E_IN6_IS_ADDR_MULTICAST(&addr)){
    800. 

  800.                             expert_add_info(pinfo, ti, &ei_ipv6_src_route_list_multicast_addr);
    801. 

  801.                         }
    802. 

  802.                     }
    803. 

  803.                 }
    804. 

  804.             }
    805. 

  805.         }
    806. 

  806.     }
    807. 

  807. 

  808.     return len;
    809. 

  809. }
    810. 

  810. 

  811. static int
    812. 

  812. dissect_frag6(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree,
    813. 

  813.     guint16 *offlg, guint32 *ident) {
    814. 

  814.     struct ip6_frag frag;
    815. 

  815.     int len;
    816. 

  816.     proto_item *ti;
    817. 

  817.     proto_tree *rthdr_tree;
    818. 

  818. 

  819.     tvb_memcpy(tvb, (guint8 *)&frag, offset, sizeof(frag));
    820. 

  820.     len = sizeof(frag);
    821. 

  821.     frag.ip6f_offlg = g_ntohs(frag.ip6f_offlg);
    822. 

  822.     frag.ip6f_ident = g_ntohl(frag.ip6f_ident);
    823. 

  823.     *offlg = frag.ip6f_offlg;
    824. 

  824.     *ident = frag.ip6f_ident;
    825. 

  825.     col_add_fstr(pinfo->cinfo, COL_INFO,
    826. 

  826.             "IPv6 fragment (nxt=%s (%u) off=%u id=0x%x)",
    827. 

  827.             ipprotostr(frag.ip6f_nxt), frag.ip6f_nxt,
    828. 

  828.             (frag.ip6f_offlg & IP6F_OFF_MASK) >> IP6F_OFF_SHIFT, frag.ip6f_ident);
    829. 

  829. 

  830.     if (tree) {
    831. 

  831.            ti = proto_tree_add_text(tree, tvb, offset, len,
    832. 

  832.                            "Fragmentation Header");
    833. 

  833.            rthdr_tree = proto_item_add_subtree(ti, ett_ipv6);
    834. 

  834. 

  835.            proto_tree_add_item(rthdr_tree, hf_ipv6_frag_nxt, tvb,
    836. 

  836.                          offset + (int)offsetof(struct ip6_frag, ip6f_nxt), 1,
    837. 

  837.                          ENC_BIG_ENDIAN);
    838. 

  838. 

  839.            proto_tree_add_item(rthdr_tree, hf_ipv6_frag_reserved, tvb,
    840. 

  840.                          offset + (int)offsetof(struct ip6_frag, ip6f_reserved), 1,
    841. 

  841.                          ENC_BIG_ENDIAN);
    842. 

  842. 

  843.            proto_tree_add_item(rthdr_tree, hf_ipv6_frag_offset, tvb,
    844. 

  844.                     offset + (int)offsetof(struct ip6_frag, ip6f_offlg), 2, ENC_BIG_ENDIAN);
    845. 

  845.            proto_tree_add_item(rthdr_tree, hf_ipv6_frag_reserved_bits, tvb,
    846. 

  846.                     offset + (int)offsetof(struct ip6_frag, ip6f_offlg), 2, ENC_BIG_ENDIAN);
    847. 

  847.            proto_tree_add_item(rthdr_tree, hf_ipv6_frag_more, tvb,
    848. 

  848.                     offset + (int)offsetof(struct ip6_frag, ip6f_offlg), 2, ENC_BIG_ENDIAN);
    849. 

  849.            proto_tree_add_item(rthdr_tree, hf_ipv6_frag_id, tvb,
    850. 

  850.                     offset + (int)offsetof(struct ip6_frag, ip6f_ident), 4, ENC_BIG_ENDIAN);
    851. 

  851.     }
    852. 

  852.     return len;
    853. 

  853. }
    854. 

  854. 

  855. static const value_string rtalertvals[] = {
    856. 

  856.     { IP6OPT_RTALERT_MLD, "MLD" },
    857. 

  857.     { IP6OPT_RTALERT_RSVP, "RSVP" },
    858. 

  858.     { IP6OPT_RTALERT_ACTNET, "Active Network" },
    859. 

  859.     { 0, NULL }
    860. 

  860. };
    861. 

  861. 

  862. static int
    863. 

  863. dissect_unknown_option(tvbuff_t *tvb, int offset, proto_tree *tree)
    864. 

  864. {
    865. 

  865.     int len;
    866. 

  866.     proto_tree *unkopt_tree;
    867. 

  867.     proto_item *ti, *ti_len;
    868. 

  868. 

  869.     len = (tvb_get_guint8(tvb, offset + 1) + 1) << 3;
    870. 

  870. 

  871.     if (tree) {
    872. 

  872.         /* !!! specify length */
    873. 

  873.         ti = proto_tree_add_item(tree, hf_ipv6_unk_hdr, tvb, offset, len, ENC_NA);
    874. 

  874. 

  875.         unkopt_tree = proto_item_add_subtree(ti, ett_ipv6);
    876. 

  876. 

  877.         proto_tree_add_item(unkopt_tree, hf_ipv6_nxt, tvb, offset, 1, ENC_NA);
    878. 

  878.         offset += 1;
    879. 

  879. 

  880.         ti_len = proto_tree_add_item(unkopt_tree, hf_ipv6_opt_length, tvb, offset, 1, ENC_NA);
    881. 

  881.         proto_item_append_text(ti_len, " (%d byte%s)", len, plurality(len, "", "s"));
    882. 

  882.         /* offset += 1; */
    883. 

  883.     }
    884. 

  884.     return len;
    885. 

  885. }
    886. 

  886. 

  887. static int
    888. 

  888. dissect_opts(tvbuff_t *tvb, int offset, proto_tree *tree, packet_info * pinfo, const int hf_option_item)
    889. 

  889. {
    890. 

  890.     int len;
    891. 

  891.     int offset_end;
    892. 

  892.     proto_tree *dstopt_tree, *opt_tree;
    893. 

  893.     proto_item *ti, *ti_len, *ti_opt, *ti_opt_len;
    894. 

  894.     guint8 opt_len, opt_type;
    895. 

  895. 

  896.     len = (tvb_get_guint8(tvb, offset + 1) + 1) << 3;
    897. 

  897.     offset_end = offset + len;
    898. 

  898. 

  899.     if (tree) {
    900. 

  900.         /* !!! specify length */
    901. 

  901.         ti = proto_tree_add_item(tree, hf_option_item, tvb, offset, len, ENC_NA);
    902. 

  902. 

  903.         dstopt_tree = proto_item_add_subtree(ti, ett_ipv6);
    904. 

  904. 

  905.         proto_tree_add_item(dstopt_tree, hf_ipv6_nxt, tvb, offset, 1, ENC_NA);
    906. 

  906.         offset += 1;
    907. 

  907. 

  908.         ti_len = proto_tree_add_item(dstopt_tree, hf_ipv6_opt_length, tvb, offset, 1, ENC_NA);
    909. 

  909.         proto_item_append_text(ti_len, " (%d byte%s)", len, plurality(len, "", "s"));
    910. 

  910.         offset += 1;
    911. 

  911. 

  912.         while (offset_end > offset) {
    913. 

  913.             /* there are more options */
    914. 

  914. 

  915.             /* IPv6 Option */
    916. 

  916.             ti_opt = proto_tree_add_item(dstopt_tree, hf_ipv6_opt, tvb, offset, 1, ENC_NA);
    917. 

  917.             opt_tree = proto_item_add_subtree(ti_opt, ett_ipv6_opt);
    918. 

  918. 

  919.             /* Option type */
    920. 

  920.             proto_tree_add_item(opt_tree, hf_ipv6_opt_type, tvb, offset, 1, ENC_BIG_ENDIAN);
    921. 

  921.             opt_type = tvb_get_guint8(tvb, offset);
    922. 

  922. 

  923.             /* Add option name to option root label */
    924. 

  924.             proto_item_append_text(ti_opt, " (%s", val_to_str(opt_type, ipv6_opt_vals, "Unknown %d"));
    925. 

  925. 

  926.             /* The Pad1 option is a special case, and contains no data. */
    927. 

  927.             if (opt_type == IP6OPT_PAD1) {
    928. 

  928.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_pad1, tvb, offset, 1, ENC_NA);
    929. 

  929.                 offset += 1;
    930. 

  930.                 proto_item_append_text(ti_opt, ")");
    931. 

  931.                 continue;
    932. 

  932.             }
    933. 

  933.             offset += 1;
    934. 

  934. 

  935.             /* Option length */
    936. 

  936.             ti_opt_len = proto_tree_add_item(opt_tree, hf_ipv6_opt_length, tvb, offset, 1, ENC_BIG_ENDIAN);
    937. 

  937.             opt_len = tvb_get_guint8(tvb, offset);
    938. 

  938.             proto_item_set_len(ti_opt, opt_len + 2);
    939. 

  939.             offset += 1;
    940. 

  940. 

  941.             switch (opt_type) {
    942. 

  942.             case IP6OPT_PADN:
    943. 

  943.                 /* RFC 2460 states :
    944. 

  944.                  * "The PadN option is used to insert two or more octets of
    945. 

  945.                  * padding into the Options area of a header.  For N octets of
    946. 

  946.                  * padding, the Opt Data Len field contains the value N-2, and
    947. 

  947.                  * the Option Data consists of N-2 zero-valued octets."
    948. 

  948.                  */
    949. 

  949.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_padn, tvb,
    950. 

  950.                                             offset, opt_len, ENC_NA);
    951. 

  951.                 offset += opt_len;
    952. 

  952.                 break;
    953. 

  953.             case IP6OPT_TEL:
    954. 

  954.                 if (opt_len != 1) {
    955. 

  955.                     expert_add_info_format_text(pinfo, ti_opt_len, &ei_ipv6_opt_tel_invalid_len,
    956. 

  956.                         "Tunnel Encapsulation Limit: Invalid length (%u bytes)", opt_len);
    957. 

  957.                 }
    958. 

  958.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_tel, tvb,
    959. 

  959.                                             offset, 1, ENC_BIG_ENDIAN);
    960. 

  960.                 offset += 1;
    961. 

  961.                 break;
    962. 

  962.             case IP6OPT_JUMBO:
    963. 

  963.                 if (opt_len != 4) {
    964. 

  964.                     expert_add_info_format_text(pinfo, ti_opt_len, &ei_ipv6_opt_jumbo_invalid_len,
    965. 

  965.                         "Jumbo payload: Invalid length (%u bytes)", opt_len);
    966. 

  966.                 }
    967. 

  967.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_jumbo, tvb,
    968. 

  968.                                             offset, 4, ENC_BIG_ENDIAN);
    969. 

  969.                 offset += 4;
    970. 

  970.                 break;
    971. 

  971.             case IP6OPT_RTALERT:
    972. 

  972.               {
    973. 

  973.                 if (opt_len != 2) {
    974. 

  974.                     expert_add_info_format_text(pinfo, ti_opt_len, &ei_ipv6_opt_rtalert_invalid_len,
    975. 

  975.                             "Router alert: Invalid Length (%u bytes)",
    976. 

  976.                             opt_len + 2);
    977. 

  977.                 }
    978. 

  978.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_rtalert, tvb,
    979. 

  979.                                             offset, 2, ENC_BIG_ENDIAN);
    980. 

  980.                 offset += 2;
    981. 

  981.                 break;
    982. 

  982.               }
    983. 

  983.             case IP6OPT_HOME_ADDRESS:
    984. 

  984.                 if (opt_len != 16) {
    985. 

  985.                     expert_add_info_format_text(pinfo, ti_opt_len, &ei_ipv6_mipv6_home_address_invalid_len,
    986. 

  986.                         "Home Address: Invalid length (%u bytes)", opt_len);
    987. 

  987.                 }
    988. 

  988.                 proto_tree_add_item(opt_tree, hf_ipv6_mipv6_home_address, tvb,
    989. 

  989.                                     offset, 16, ENC_NA);
    990. 

  990.                 TVB_SET_ADDRESS(&pinfo->src, AT_IPv6, tvb, offset, 16);
    991. 

  991.                 offset += 16;
    992. 

  992.                 break;
    993. 

  993.             case IP6OPT_CALIPSO:
    994. 

  994.               {
    995. 

  995.                 guint8 cmpt_length;
    996. 

  996.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_calipso_doi, tvb,
    997. 

  997.                                             offset, 4, ENC_BIG_ENDIAN);
    998. 

  998.                 offset += 4;
    999. 

  999.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_calipso_cmpt_length, tvb,
    1000. 

  1000.                                             offset, 1, ENC_BIG_ENDIAN);
    1001. 

  1001.                 cmpt_length = tvb_get_guint8(tvb, offset);
    1002. 

  1002.                 offset += 1;
    1003. 

  1003.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_calipso_sens_level, tvb,
    1004. 

  1004.                                             offset, 1, ENC_BIG_ENDIAN);
    1005. 

  1005.                 offset += 1;
    1006. 

  1006.                 /* Need to add Check Checksum..*/
    1007. 

  1007.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_calipso_checksum, tvb,
    1008. 

  1008.                                             offset, 2, ENC_BIG_ENDIAN);
    1009. 

  1009.                 offset += 2;
    1010. 

  1010.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_calipso_cmpt_bitmap, tvb,
    1011. 

  1011.                                               offset, cmpt_length, ENC_NA);
    1012. 

  1012.                 offset += cmpt_length;
    1013. 

  1013.                 break;
    1014. 

  1014.               }
    1015. 

  1015.             case IP6OPT_QUICKSTART:
    1016. 

  1016.               {
    1017. 

  1017. 

  1018.                 guint8 command = tvb_get_guint8(tvb, offset);
    1019. 

  1019.                 guint8 function = command >> 4;
    1020. 

  1020.                 guint8 rate = command & QS_RATE_MASK;
    1021. 

  1021.                 guint8 ttl_diff;
    1022. 

  1022. 

  1023.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_qs_func, tvb, offset, 1, ENC_NA);
    1024. 

  1024. 

  1025.                 if (function == QS_RATE_REQUEST) {
    1026. 

  1026.                   proto_tree_add_item(opt_tree, hf_ipv6_opt_qs_rate, tvb, offset, 1, ENC_NA);
    1027. 

  1027.                   offset += 1;
    1028. 

  1028.                   proto_tree_add_item(opt_tree, hf_ipv6_opt_qs_ttl, tvb, offset, 1, ENC_NA);
    1029. 

  1029.                   ttl_diff = (pinfo->ip_ttl - tvb_get_guint8(tvb, offset) % 256);
    1030. 

  1030.                   offset += 1;
    1031. 

  1031.                   ti = proto_tree_add_uint_format_value(opt_tree, hf_ipv6_opt_qs_ttl_diff,
    1032. 

  1032.                                                         tvb, offset, 1, ttl_diff,
    1033. 

  1033.                                                         "%u", ttl_diff);
    1034. 

  1034.                   PROTO_ITEM_SET_GENERATED(ti);
    1035. 

  1035.                   proto_item_append_text(ti_opt, ", %s, QS TTL %u, QS TTL diff %u",
    1036. 

  1036.                                          val_to_str_ext(rate, &qs_rate_vals_ext, "Unknown (%u)"),
    1037. 

  1037.                                          tvb_get_guint8(tvb, offset), ttl_diff);
    1038. 

  1038.                   offset += 1;
    1039. 

  1039.                   proto_tree_add_item(opt_tree, hf_ipv6_opt_qs_nonce, tvb, offset, 4, ENC_NA);
    1040. 

  1040.                   proto_tree_add_item(opt_tree, hf_ipv6_opt_qs_reserved, tvb, offset, 4, ENC_NA);
    1041. 

  1041.                   offset += 4;
    1042. 

  1042.                 } else if (function == QS_RATE_REPORT) {
    1043. 

  1043.                   proto_tree_add_item(opt_tree, hf_ipv6_opt_qs_rate, tvb, offset, 1, ENC_NA);
    1044. 

  1044.                   offset += 1;
    1045. 

  1045.                   proto_item_append_text(ti_opt, ", %s",
    1046. 

  1046.                                          val_to_str_ext(rate, &qs_rate_vals_ext, "Unknown (%u)"));
    1047. 

  1047.                   proto_tree_add_item(opt_tree, hf_ipv6_opt_qs_unused, tvb, offset, 1, ENC_NA);
    1048. 

  1048.                   offset += 1;
    1049. 

  1049.                   proto_tree_add_item(opt_tree, hf_ipv6_opt_qs_nonce, tvb, offset, 4, ENC_NA);
    1050. 

  1050.                   proto_tree_add_item(opt_tree, hf_ipv6_opt_qs_reserved, tvb, offset, 4, ENC_NA);
    1051. 

  1051.                   offset += 4;
    1052. 

  1052.                 }
    1053. 

  1053. 

  1054.               }
    1055. 

  1055.               break;
    1056. 

  1056.             case IP6OPT_RPL:
    1057. 

  1057.               {
    1058. 

  1058.                 proto_tree *flag_tree;
    1059. 

  1059.                 proto_item *ti_flag;
    1060. 

  1060. 

  1061.                 ti_flag = proto_tree_add_item(opt_tree, hf_ipv6_opt_rpl_flag, tvb, offset, 1, ENC_BIG_ENDIAN);
    1062. 

  1062.                 flag_tree = proto_item_add_subtree(ti_flag, ett_ipv6_opt_flag);
    1063. 

  1063.                 proto_tree_add_item(flag_tree, hf_ipv6_opt_rpl_flag_o, tvb, offset, 1, ENC_BIG_ENDIAN);
    1064. 

  1064.                 proto_tree_add_item(flag_tree, hf_ipv6_opt_rpl_flag_r, tvb, offset, 1, ENC_BIG_ENDIAN);
    1065. 

  1065.                 proto_tree_add_item(flag_tree, hf_ipv6_opt_rpl_flag_f, tvb, offset, 1, ENC_BIG_ENDIAN);
    1066. 

  1066.                 proto_tree_add_item(flag_tree, hf_ipv6_opt_rpl_flag_rsv, tvb, offset, 1, ENC_BIG_ENDIAN);
    1067. 

  1067.                 offset +=1;
    1068. 

  1068. 

  1069.                 proto_tree_add_item(flag_tree, hf_ipv6_opt_rpl_instance_id, tvb, offset, 1, ENC_BIG_ENDIAN);
    1070. 

  1070.                 offset +=1;
    1071. 

  1071. 

  1072.                 proto_tree_add_item(flag_tree, hf_ipv6_opt_rpl_senderrank, tvb, offset, 2, ENC_BIG_ENDIAN);
    1073. 

  1073.                 offset +=2;
    1074. 

  1074. 

  1075.                 /* TODO: Add dissector of sub TLV */
    1076. 

  1076.               }
    1077. 

  1077.               break;
    1078. 

  1078.             case IP6OPT_EXP_1E:
    1079. 

  1079.             case IP6OPT_EXP_3E:
    1080. 

  1080.             case IP6OPT_EXP_5E:
    1081. 

  1081.             case IP6OPT_EXP_7E:
    1082. 

  1082.             case IP6OPT_EXP_9E:
    1083. 

  1083.             case IP6OPT_EXP_BE:
    1084. 

  1084.             case IP6OPT_EXP_DE:
    1085. 

  1085.             case IP6OPT_EXP_FE:
    1086. 

  1086.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_experimental, tvb,
    1087. 

  1087.                                     offset, opt_len, ENC_NA);
    1088. 

  1088.                 offset += opt_len;
    1089. 

  1089.               break;
    1090. 

  1090.             default:
    1091. 

  1091.                 proto_tree_add_item(opt_tree, hf_ipv6_opt_unknown, tvb,
    1092. 

  1092.                                     offset, opt_len, ENC_NA);
    1093. 

  1093.                 offset += opt_len;
    1094. 

  1094.                 break;
    1095. 

  1095.             }
    1096. 

  1096.         /* Close the ) to option root label */
    1097. 

  1097.         proto_item_append_text(ti_opt, ")");
    1098. 

  1098.         }
    1099. 

  1099. 

  1100.     }
    1101. 

  1101.     return len;
    1102. 

  1102. }
    1103. 

  1103. 

  1104. static int
    1105. 

  1105. dissect_hopopts(tvbuff_t *tvb, int offset, proto_tree *tree, packet_info * pinfo)
    1106. 

  1106. {
    1107. 

  1107.     return dissect_opts(tvb, offset, tree, pinfo, hf_ipv6_hop_opt);
    1108. 

  1108. }
    1109. 

  1109. 

  1110. static int
    1111. 

  1111. dissect_dstopts(tvbuff_t *tvb, int offset, proto_tree *tree, packet_info * pinfo)
    1112. 

  1112. {
    1113. 

  1113.     return dissect_opts(tvb, offset, tree, pinfo, hf_ipv6_dst_opt);
    1114. 

  1114. }
    1115. 

  1115. 

  1116. /* START SHIM6 PART */
    1117. 

  1117. static guint16 shim_checksum(const guint8 *ptr, int len)
    1118. 

  1118. {
    1119. 

  1119.         vec_t cksum_vec[1];
    1120. 

  1120. 

  1121.         cksum_vec[0].ptr = ptr;
    1122. 

  1122.         cksum_vec[0].len = len;
    1123. 

  1123.         return in_cksum(&cksum_vec[0], 1);
    1124. 

  1124. }
    1125. 

  1125. 

  1126. static int
    1127. 

  1127. dissect_shim_hex(tvbuff_t *tvb, int offset, int len, const char *itemname, guint8 bitmask, proto_tree *tree)
    1128. 

  1128. {
    1129. 

  1129.     proto_item *ti;
    1130. 

  1130.     int count;
    1131. 

  1131.     gint p;
    1132. 

  1132. 

  1133.     p = offset;
    1134. 

  1134. 

  1135.     ti = proto_tree_add_text(tree, tvb, offset, len, "%s", itemname);
    1136. 

  1136. 

  1137.     proto_item_append_text(ti, " 0x%02x", tvb_get_guint8(tvb, p) & bitmask);
    1138. 

  1138.     for (count=1; count<len; count++)
    1139. 

  1139.       proto_item_append_text(ti, "%02x", tvb_get_guint8(tvb, p+count));
    1140. 

  1140. 

  1141.     return len;
    1142. 

  1142. }
    1143. 

  1143. 

  1144. static const value_string shimoptvals[] = {
    1145. 

  1145.     { SHIM6_OPT_RESPVAL,  "Responder Validator Option" },
    1146. 

  1146.     { SHIM6_OPT_LOCLIST,  "Locator List Option" },
    1147. 

  1147.     { SHIM6_OPT_LOCPREF,  "Locator Preferences Option" },
    1148. 

  1148.     { SHIM6_OPT_CGAPDM,   "CGA Parameter Data Structure Option" },
    1149. 

  1149.     { SHIM6_OPT_CGASIG,   "CGA Signature Option" },
    1150. 

  1150.     { SHIM6_OPT_ULIDPAIR, "ULID Pair Option" },
    1151. 

  1151.     { SHIM6_OPT_FII,      "Forked Instance Identifier Option" },
    1152. 

  1152.     { 0, NULL }
    1153. 

  1153. };
    1154. 

  1154. 

  1155. static const value_string shimverifmethods[] = {
    1156. 

  1156.     { SHIM6_VERIF_HBA, "HBA" },
    1157. 

  1157.     { SHIM6_VERIF_CGA, "CGA" },
    1158. 

  1158.     { 0, NULL }
    1159. 

  1159. };
    1160. 

  1160. 

  1161. static const value_string shimflags[] _U_ = {
    1162. 

  1162.     { SHIM6_FLAG_BROKEN,    "BROKEN" },
    1163. 

  1163.     { SHIM6_FLAG_TEMPORARY, "TEMPORARY" },
    1164. 

  1164.     { 0, NULL }
    1165. 

  1165. };
    1166. 

  1166. 

  1167. static const value_string shimreapstates[] = {
    1168. 

  1168.     { SHIM6_REAP_OPERATIONAL, "Operational" },
    1169. 

  1169.     { SHIM6_REAP_EXPLORING,   "Exploring" },
    1170. 

  1170.     { SHIM6_REAP_INBOUNDOK,   "InboundOK" },
    1171. 

  1171.     { 0, NULL }
    1172. 

  1172. };
    1173. 

  1173. 

  1174. static const value_string shim6_protocol[] = {
    1175. 

  1175.   { 0, "SHIM6" },
    1176. 

  1176.   { 1, "HIP" },
    1177. 

  1177.   { 0, NULL }
    1178. 

  1178. };
    1179. 

  1179. 

  1180. 

  1181. static void
    1182. 

  1182. dissect_shim6_opt_loclist(proto_tree * opt_tree, tvbuff_t * tvb, gint *offset)
    1183. 

  1183. {
    1184. 

  1184.   proto_item * it;
    1185. 

  1185.   proto_tree * subtree;
    1186. 

  1186.   guint count;
    1187. 

  1187.   guint optlen;
    1188. 

  1188.   int p = *offset;
    1189. 

  1189. 

  1190.   proto_tree_add_item(opt_tree, hf_ipv6_shim6_opt_loclist, tvb, p, 4, ENC_BIG_ENDIAN);
    1191. 

  1191.   p += 4;
    1192. 

  1192. 

  1193.   optlen = tvb_get_guint8(tvb, p);
    1194. 

  1194.   proto_tree_add_item(opt_tree, hf_ipv6_shim6_opt_locnum, tvb, p, 1, ENC_BIG_ENDIAN);
    1195. 

  1195.   p++;
    1196. 

  1196. 

  1197.   /* Verification Methods */
    1198. 

  1198.   it = proto_tree_add_text(opt_tree, tvb, p, optlen,
    1199. 

  1199.                             "Locator Verification Methods");
    1200. 

  1200.   subtree = proto_item_add_subtree(it, ett_ipv6_shim6_verif_methods);
    1201. 

  1201. 

  1202.   for (count=0; count < optlen; count++)
    1203. 

  1203.     proto_tree_add_item(subtree, hf_ipv6_shim6_opt_loc_verif_methods, tvb,
    1204. 

  1204.                             p+count, 1, ENC_BIG_ENDIAN);
    1205. 

  1205.   p += optlen;
    1206. 

  1206. 

  1207.   /* Padding, included in length field */
    1208. 

  1208.   if ((7 - optlen % 8) > 0) {
    1209. 

  1209.       proto_tree_add_text(opt_tree, tvb, p, (7 - optlen % 8), "Padding");
    1210. 

  1210.       p += (7 - optlen % 8);
    1211. 

  1211.   }
    1212. 

  1212. 

  1213.   /* Locators */
    1214. 

  1214.   it = proto_tree_add_text(opt_tree, tvb, p, 16 * optlen, "Locators");
    1215. 

  1215.   subtree = proto_item_add_subtree(it, ett_ipv6_shim6_locators);
    1216. 

  1216. 

  1217.   for (count=0; count < optlen; count++) {
    1218. 

  1218.       proto_tree_add_item(subtree, hf_ipv6_shim6_locator, tvb, p, 16, ENC_NA);
    1219. 

  1219.       p += 16;
    1220. 

  1220.   }
    1221. 

  1221.   *offset = p;
    1222. 

  1222. }
    1223. 

  1223. 

  1224. static void
    1225. 

  1225. dissect_shim6_opt_loc_pref(proto_tree * opt_tree, tvbuff_t * tvb, gint *offset, gint len, packet_info *pinfo)
    1226. 

  1226. {
    1227. 

  1227.   proto_tree * subtree;
    1228. 

  1228.   proto_item * it;
    1229. 

  1229. 

  1230.   gint p;
    1231. 

  1231.   gint optlen;
    1232. 

  1232.   gint count;
    1233. 

  1233. 

  1234.   p = *offset;
    1235. 

  1235. 

  1236.   proto_tree_add_item(opt_tree, hf_ipv6_shim6_opt_loclist, tvb, p, 4, ENC_BIG_ENDIAN);
    1237. 

  1237.   p += 4;
    1238. 

  1238. 

  1239.   optlen = tvb_get_guint8(tvb, p);
    1240. 

  1240.   proto_tree_add_item(opt_tree, hf_ipv6_shim6_opt_elemlen, tvb, p, 1, ENC_BIG_ENDIAN);
    1241. 

  1241. 

  1242.   if (optlen < 1 || optlen > 3) {
    1243. 

  1243.     proto_tree_add_expert_format(opt_tree, pinfo, &ei_ipv6_shim6_opt_elemlen_invalid, tvb, p, 1,
    1244. 

  1244.       "Invalid element length: %u", optlen);
    1245. 

  1245.     return;
    1246. 

  1246.   }
    1247. 

  1247. 

  1248.   p++;
    1249. 

  1249. 

  1250.   /* Locator Preferences */
    1251. 

  1251.   count = 1;
    1252. 

  1252.   while (p < len) {
    1253. 

  1253.     it = proto_tree_add_text(opt_tree, tvb, p, optlen, "Locator Preferences %u", count);
    1254. 

  1254.     subtree = proto_item_add_subtree(it, ett_ipv6_shim6_loc_pref);
    1255. 

  1255. 

  1256.     /* Flags */
    1257. 

  1257.     if (optlen >= 1)
    1258. 

  1258.       proto_tree_add_item(subtree, hf_ipv6_shim6_loc_flag, tvb, p, 1, ENC_BIG_ENDIAN);
    1259. 

  1259.     /* Priority */
    1260. 

  1260.     if (optlen >= 2)
    1261. 

  1261.       proto_tree_add_item(subtree, hf_ipv6_shim6_loc_prio, tvb, p+1, 1, ENC_BIG_ENDIAN);
    1262. 

  1262.     /* Weight */
    1263. 

  1263.     if (optlen >= 3)
    1264. 

  1264.       proto_tree_add_item(subtree, hf_ipv6_shim6_loc_weight, tvb, p+2, 1, ENC_BIG_ENDIAN);
    1265. 

  1265.     /*
    1266. 

  1266.      * Shim6 Draft 08 doesn't specify the format when the Element length is
    1267. 

  1267.      * more than three, except that any such formats MUST be defined so that
    1268. 

  1268.      * the first three octets are the same as in the above case, that is, a
    1269. 

  1269.      * of a 1 octet flags field followed by a 1 octet priority field, and a
    1270. 

  1270.      * 1 octet weight field.
    1271. 

  1271.      */
    1272. 

  1272.     p += optlen;
    1273. 

  1273.     count++;
    1274. 

  1274.   }
    1275. 

  1275.   *offset = p;
    1276. 

  1276. }
    1277. 

  1277. 

  1278. 

  1279. static int
    1280. 

  1280. dissect_shimopts(tvbuff_t *tvb, int offset, proto_tree *tree, packet_info *pinfo)
    1281. 

  1281. {
    1282. 

  1282.     int len, total_len;
    1283. 

  1283.     gint p;
    1284. 

  1284.     gint padding;
    1285. 

  1285.     proto_tree *opt_tree;
    1286. 

  1286.     proto_item *ti;
    1287. 

  1287.     const gchar *ctype;
    1288. 

  1288. 

  1289. 

  1290.     p = offset;
    1291. 

  1291. 

  1292.     p += 4;
    1293. 

  1293. 

  1294.     len = tvb_get_ntohs(tvb, offset+2);
    1295. 

  1295.     padding = 7 - ((len + 3) % 8);
    1296. 

  1296.     total_len = 4 + len + padding;
    1297. 

  1297. 

  1298.     if (tree)
    1299. 

  1299.     {
    1300. 

  1300.         /* Option Type */
    1301. 

  1301.         ctype = val_to_str_const( (tvb_get_ntohs(tvb, offset) & SHIM6_BITMASK_OPT_TYPE) >> 1, shimoptvals, "Unknown Option Type");
    1302. 

  1302.         ti = proto_tree_add_text(tree, tvb, offset, total_len, "%s", ctype);
    1303. 

  1303.         opt_tree = proto_item_add_subtree(ti, ett_ipv6_shim6_option);
    1304. 

  1304. 

  1305.         proto_tree_add_item(opt_tree, hf_ipv6_shim6_opt_type, tvb, offset, 2, ENC_BIG_ENDIAN);
    1306. 

  1306. 

  1307.         /* Critical */
    1308. 

  1308.         proto_tree_add_item(opt_tree, hf_ipv6_shim6_opt_critical, tvb, offset+1, 1, ENC_BIG_ENDIAN);
    1309. 

  1309. 

  1310.         /* Content Length */
    1311. 

  1311.         proto_tree_add_item(opt_tree, hf_ipv6_shim6_opt_len, tvb, offset + 2, 2, ENC_BIG_ENDIAN);
    1312. 

  1312.         ti = proto_tree_add_uint_format(opt_tree, hf_ipv6_shim6_opt_total_len, tvb, offset+2, 2,
    1313. 

  1313.             total_len, "Total Length: %u", total_len);
    1314. 

  1314.         PROTO_ITEM_SET_GENERATED(ti);
    1315. 

  1315. 

  1316.         /* Option Type Specific */
    1317. 

  1317.         switch (tvb_get_ntohs(tvb, offset) >> 1)
    1318. 

  1318.         {
    1319. 

  1319.             case SHIM6_OPT_RESPVAL:
    1320. 

  1320.                 p += dissect_shim_hex(tvb, p, len, "Validator:", 0xff, opt_tree);
    1321. 

  1321.                 if (total_len-(len+4) > 0)
    1322. 

  1322.                     proto_tree_add_text(opt_tree, tvb, p, total_len-(len+4), "Padding");
    1323. 

  1323.                 break;
    1324. 

  1324.             case SHIM6_OPT_LOCLIST:
    1325. 

  1325.                 dissect_shim6_opt_loclist(opt_tree, tvb, &p);
    1326. 

  1326.                 break;
    1327. 

  1327.             case SHIM6_OPT_LOCPREF:
    1328. 

  1328.                 dissect_shim6_opt_loc_pref(opt_tree, tvb, &p, offset+len+4, pinfo);
    1329. 

  1329.                 if (total_len-(len+4) > 0)
    1330. 

  1330.                   proto_tree_add_text(opt_tree, tvb, p, total_len-(len+4), "Padding");
    1331. 

  1331.                 break;
    1332. 

  1332.             case SHIM6_OPT_CGAPDM:
    1333. 

  1333.                 p += dissect_shim_hex(tvb, p, len, "CGA Parameter Data Structure:", 0xff, opt_tree);
    1334. 

  1334.                 if (total_len-(len+4) > 0)
    1335. 

  1335.                     proto_tree_add_text(opt_tree, tvb, p, total_len-(len+4), "Padding");
    1336. 

  1336.                 break;
    1337. 

  1337.             case SHIM6_OPT_CGASIG:
    1338. 

  1338.                 p += dissect_shim_hex(tvb, p, len, "CGA Signature:", 0xff, opt_tree);
    1339. 

  1339.                 if (total_len-(len+4) > 0)
    1340. 

  1340.                     proto_tree_add_text(opt_tree, tvb, p, total_len-(len+4), "Padding");
    1341. 

  1341.                 break;
    1342. 

  1342.             case SHIM6_OPT_ULIDPAIR:
    1343. 

  1343.                 proto_tree_add_text(opt_tree, tvb, p, 4, "Reserved");
    1344. 

  1344.                 p += 4;
    1345. 

  1345.                 proto_tree_add_item(opt_tree, hf_ipv6_shim6_sulid, tvb, p, 16, ENC_NA);
    1346. 

  1346.                 p += 16;
    1347. 

  1347.                 proto_tree_add_item(opt_tree, hf_ipv6_shim6_rulid, tvb, p, 16, ENC_NA);
    1348. 

  1348.                 p += 16;
    1349. 

  1349.                 break;
    1350. 

  1350.             case SHIM6_OPT_FII:
    1351. 

  1351.                 proto_tree_add_item(opt_tree, hf_ipv6_shim6_opt_fii, tvb, p, 4, ENC_BIG_ENDIAN);
    1352. 

  1352.                 p += 4;
    1353. 

  1353.                 break;
    1354. 

  1354.             default:
    1355. 

  1355.                 break;
    1356. 

  1356.         }
    1357. 

  1357.     }
    1358. 

  1358.     return total_len;
    1359. 

  1359. }
    1360. 

  1360. 

  1361. static void
    1362. 

  1362. dissect_shim6_ct(proto_tree * shim_tree, gint hf_item, tvbuff_t * tvb, gint offset, const guchar * label)
    1363. 

  1363. {
    1364. 

  1364.   guint8 tmp[6];
    1365. 

  1365.   guchar * ct_str;
    1366. 

  1366. 

  1367.   tmp[0] = tvb_get_guint8(tvb, offset++);
    1368. 

  1368.   tmp[1] = tvb_get_guint8(tvb, offset++);
    1369. 

  1369.   tmp[2] = tvb_get_guint8(tvb, offset++);
    1370. 

  1370.   tmp[3] = tvb_get_guint8(tvb, offset++);
    1371. 

  1371.   tmp[4] = tvb_get_guint8(tvb, offset++);
    1372. 

  1372.   tmp[5] = tvb_get_guint8(tvb, offset++);
    1373. 

  1373. 

  1374.   ct_str = ep_strdup_printf("%s: %02X %02X %02X %02X %02X %02X", label,
    1375. 

  1375.                               tmp[0] & SHIM6_BITMASK_CT, tmp[1], tmp[2],
    1376. 

  1376.                               tmp[3], tmp[4], tmp[5]
    1377. 

  1377.                             );
    1378. 

  1378.   proto_tree_add_none_format(shim_tree, hf_item, tvb, offset - 6, 6, "%s", ct_str);
    1379. 

  1379. }
    1380. 

  1380. 

  1381. static void
    1382. 

  1382. dissect_shim6_probes(proto_tree * shim_tree, tvbuff_t * tvb, gint offset,
    1383. 

  1383.                      const guchar * label, guint nbr_probe,
    1384. 

  1384.                      gboolean probes_rcvd)
    1385. 

  1385. {
    1386. 

  1386.   proto_tree * probes_tree;
    1387. 

  1387.   proto_tree * probe_tree;
    1388. 

  1388.   proto_item * it;
    1389. 

  1389.   gint ett_probes;
    1390. 

  1390.   gint ett_probe;
    1391. 

  1391.   guint count;
    1392. 

  1392. 

  1393.   if (probes_rcvd) {
    1394. 

  1394.     ett_probes = ett_ipv6_shim6_probes_rcvd;
    1395. 

  1395.     ett_probe = ett_ipv6_shim6_probe_rcvd;
    1396. 

  1396.   } else {
    1397. 

  1397.     ett_probes = ett_ipv6_shim6_probes_sent;
    1398. 

  1398.     ett_probe = ett_ipv6_shim6_probe_sent;
    1399. 

  1399.   }
    1400. 

  1400.   it = proto_tree_add_text(shim_tree, tvb, offset, 40 * nbr_probe, "%s", label);
    1401. 

  1401.   probes_tree = proto_item_add_subtree(it, ett_probes);
    1402. 

  1402. 

  1403.   for (count=0; count < nbr_probe; count++) {
    1404. 

  1404.     it = proto_tree_add_text(probes_tree, tvb, offset, 40, "Probe %u", count+1);
    1405. 

  1405.     probe_tree = proto_item_add_subtree(it, ett_probe);
    1406. 

  1406. 

  1407.     proto_tree_add_item(probe_tree, hf_ipv6_shim6_psrc, tvb, offset, 16, ENC_NA);
    1408. 

  1408.     offset += 16;
    1409. 

  1409.     proto_tree_add_item(probe_tree, hf_ipv6_shim6_pdst, tvb, offset, 16, ENC_NA);
    1410. 

  1410.     offset += 16;
    1411. 

  1411. 

  1412.     proto_tree_add_item(probe_tree, hf_ipv6_shim6_pnonce, tvb, offset, 4, ENC_BIG_ENDIAN);
    1413. 

  1413.     offset += 4;
    1414. 

  1414. 

  1415.     proto_tree_add_item(probe_tree, hf_ipv6_shim6_pdata, tvb, offset, 4, ENC_BIG_ENDIAN);
    1416. 

  1416.     offset += 4;
    1417. 

  1417.   }
    1418. 

  1418. }
    1419. 

  1419. 

  1420. /* Dissect SHIM6 data: control messages */
    1421. 

  1421. static int
    1422. 

  1422. dissect_shimctrl(tvbuff_t *tvb, gint offset, guint type, proto_tree *shim_tree)
    1423. 

  1423. {
    1424. 

  1424.   gint p;
    1425. 

  1425.   guint8 tmp;
    1426. 

  1426.   const gchar *sta;
    1427. 

  1427.   guint probes_sent;
    1428. 

  1428.   guint probes_rcvd;
    1429. 

  1429. 

  1430.     p = offset;
    1431. 

  1431. 

  1432.     switch (type)
    1433. 

  1433.     {
    1434. 

  1434.         case SHIM6_TYPE_I1:
    1435. 

  1435.             dissect_shim6_ct(shim_tree, hf_ipv6_shim6_ct, tvb, p, "Initiator Context Tag");
    1436. 

  1436.             p += 6;
    1437. 

  1437.             proto_tree_add_item(shim_tree, hf_ipv6_shim6_inonce, tvb, p, 4, ENC_BIG_ENDIAN);
    1438. 

  1438.             p += 4;
    1439. 

  1439.             break;
    1440. 

  1440.         case SHIM6_TYPE_R1:
    1441. 

  1441.             proto_tree_add_text(shim_tree, tvb, p, 2, "Reserved2");
    1442. 

  1442.             p += 2;
    1443. 

  1443.             proto_tree_add_item(shim_tree, hf_ipv6_shim6_inonce, tvb, p, 4, ENC_BIG_ENDIAN);
    1444. 

  1444.             p += 4;
    1445. 

  1445.             proto_tree_add_item(shim_tree, hf_ipv6_shim6_rnonce, tvb, p, 4, ENC_BIG_ENDIAN);
    1446. 

  1446.             p += 4;
    1447. 

  1447.             break;
    1448. 

  1448.         case SHIM6_TYPE_I2:
    1449. 

  1449.             dissect_shim6_ct(shim_tree, hf_ipv6_shim6_ct, tvb, p, "Initiator Context Tag");
    1450. 

  1450.             p += 6;
    1451. 

  1451.             proto_tree_add_item(shim_tree, hf_ipv6_shim6_inonce, tvb, p, 4, ENC_BIG_ENDIAN);
    1452. 

  1452.             p += 4;
    1453. 

  1453.             proto_tree_add_item(shim_tree, hf_ipv6_shim6_rnonce, tvb, p, 4, ENC_BIG_ENDIAN);
    1454. 

  1454.             p += 4;
    1455. 

  1455.             proto_tree_add_text(shim_tree, tvb, p, 4, "Reserved2");
    1456. 

  1456.             p += 4;
    1457. 

  1457.             break;
    1458. 

  1458.         case SHIM6_TYPE_R2:
    1459. 

  1459.             dissect_shim6_ct(shim_tree, hf_ipv6_shim6_ct, tvb, p, "Responder Context Tag");
    1460. 

  1460.             p += 6;
    1461. 

  1461.             proto_tree_add_item(shim_tree, hf_ipv6_shim6_inonce, tvb, p, 4, ENC_BIG_ENDIAN);
    1462. 

  1462.             p += 4;
    1463. 

  1463.             break;
    1464. 

  1464.         case SHIM6_TYPE_R1BIS:
    1465. 

  1465.             dissect_shim6_ct(shim_tree, hf_ipv6_shim6_ct, tvb, p, "Packet Context Tag");
    1466. 

  1466.             p += 6;
    1467. 

  1467.             proto_tree_add_item(shim_tree, hf_ipv6_shim6_rnonce, tvb, p, 4, ENC_BIG_ENDIAN);
    1468. 

  1468.             p += 4;
    1469. 

  1469.             break;
    1470. 

  1470.         case SHIM6_TYPE_I2BIS:
    1471. 

  1471.             dissect_shim6_ct(shim_tree, hf_ipv6_shim6_ct, tvb, p, "Initiator Context Tag");
    1472. 

  1472.             p += 6;
    1473. 

  1473.             proto_tree_add_item(shim_tree, hf_ipv6_shim6_inonce, tvb, p, 4, ENC_BIG_ENDIAN);
    1474. 

  1474.             p += 4;
    1475. 

  1475.             proto_tree_add_item(shim_tree, hf_ipv6_shim6_rnonce, tvb, p, 4, ENC_BIG_ENDIAN);
    1476. 

  1476.             p += 4;
    1477. 

  1477.             proto_tree_add_text(shim_tree, tvb, p, 6, "Reserved2");
    1478. 

  1478.             p += 6;
    1479. 

  1479.             dissect_shim6_ct(shim_tree, hf_ipv6_shim6_ct, tvb, p, "Initiator Context Tag");
    1480. 

  1480.             p += 6;
    1481. 

  1481.             break;
    1482. 

  1482.         case SHIM6_TYPE_UPD_REQ:
    1483. 

  1483.         case SHIM6_TYPE_UPD_ACK:
    1484. 

  1484.             dissect_shim6_ct(shim_tree, hf_ipv6_shim6_ct, tvb, p, "Receiver Context Tag");
    1485. 

  1485.             p += 6;
    1486. 

  1486.             proto_tree_add_item(shim_tree, hf_ipv6_shim6_rnonce, tvb, p, 4, ENC_BIG_ENDIAN);
    1487. 

  1487.             p += 4;
    1488. 

  1488.             break;
    1489. 

  1489.         case SHIM6_TYPE_KEEPALIVE:
    1490. 

  1490.             dissect_shim6_ct(shim_tree, hf_ipv6_shim6_ct, tvb, p, "Receiver Context Tag");
    1491. 

  1491.             p += 6;
    1492. 

  1492.             proto_tree_add_text(shim_tree, tvb, p, 4, "Reserved2");
    1493. 

  1493.             p += 4;
    1494. 

  1494.             break;
    1495. 

  1495.         case SHIM6_TYPE_PROBE:
    1496. 

  1496.             dissect_shim6_ct(shim_tree, hf_ipv6_shim6_ct, tvb, p, "Receiver Context Tag");
    1497. 

  1497.             p += 6;
    1498. 

  1498. 

  1499.             tmp = tvb_get_guint8(tvb, p);
    1500. 

  1500.             probes_sent = tmp & SHIM6_BITMASK_PSENT;
    1501. 

  1501.             probes_rcvd = (tmp & SHIM6_BITMASK_PRECVD) >> 4;
    1502. 

  1502. 

  1503.             proto_tree_add_uint_format(shim_tree, hf_ipv6_shim6_psent, tvb,
    1504. 

  1504.                                         p, 1, probes_sent,
    1505. 

  1505.                                         "Probes Sent: %u", probes_sent);
    1506. 

  1506.             proto_tree_add_uint_format(shim_tree, hf_ipv6_shim6_precvd, tvb,
    1507. 

  1507.                                         p, 1, probes_rcvd,
    1508. 

  1508.                                         "Probes Received: %u", probes_rcvd);
    1509. 

  1509.             p++;
    1510. 

  1510. 

  1511.             sta = val_to_str_const((tvb_get_guint8(tvb, p) & SHIM6_BITMASK_STA) >> 6,
    1512. 

  1512.                                         shimreapstates, "Unknown REAP State");
    1513. 

  1513.             proto_tree_add_uint_format(shim_tree, hf_ipv6_shim6_reap, tvb,
    1514. 

  1514.                 p, 1, (tvb_get_guint8(tvb, p) & SHIM6_BITMASK_STA) >> 6,
    1515. 

  1515.                 "REAP State: %s", sta);
    1516. 

  1516. 

  1517.             proto_tree_add_text(shim_tree, tvb, p, 3, "Reserved2");
    1518. 

  1518.             p += 3;
    1519. 

  1519. 

  1520.             /* Probes Sent */
    1521. 

  1521.             if (probes_sent) {
    1522. 

  1522.               dissect_shim6_probes(shim_tree, tvb, p, "Probes Sent",
    1523. 

  1523.                                                           probes_sent, FALSE);
    1524. 

  1524.               p += 40 * probes_sent;
    1525. 

  1525.             }
    1526. 

  1526. 

  1527.            /* Probes Received */
    1528. 

  1528.             if (probes_rcvd) {
    1529. 

  1529.               dissect_shim6_probes(shim_tree, tvb, p, "Probes Received",
    1530. 

  1530.                                                           probes_rcvd, TRUE);
    1531. 

  1531.               p += 40 * probes_rcvd;
    1532. 

  1532.             }
    1533. 

  1533.            break;
    1534. 

  1534.         default:
    1535. 

  1535.            break;
    1536. 

  1536.     }
    1537. 

  1537.     return p-offset;
    1538. 

  1538. }
    1539. 

  1539. 

  1540. /* Dissect SHIM6 data: payload, common part, options */
    1541. 

  1541. static const value_string shimctrlvals[] = {
    1542. 

  1542.     { SHIM6_TYPE_I1,        "I1" },
    1543. 

  1543.     { SHIM6_TYPE_R1,        "R1" },
    1544. 

  1544.     { SHIM6_TYPE_I2,        "I2" },
    1545. 

  1545.     { SHIM6_TYPE_R2,        "R2" },
    1546. 

  1546.     { SHIM6_TYPE_R1BIS,     "R1bis" },
    1547. 

  1547.     { SHIM6_TYPE_I2BIS,     "I2bis" },
    1548. 

  1548.     { SHIM6_TYPE_UPD_REQ,   "Update Request" },
    1549. 

  1549.     { SHIM6_TYPE_UPD_ACK,   "Update Acknowledgment" },
    1550. 

  1550.     { SHIM6_TYPE_KEEPALIVE, "Keepalive" },
    1551. 

  1551.     { SHIM6_TYPE_PROBE,     "Probe" },
    1552. 

  1552.     { 0, NULL }
    1553. 

  1553. };
    1554. 

  1554. 

  1555. static void ipv6_shim6_checkum_additional_info(tvbuff_t * tvb, packet_info * pinfo,
    1556. 

  1556.     proto_item * it_cksum, int offset, gboolean is_cksum_correct)
    1557. 

  1557. {
    1558. 

  1558.         proto_tree * checksum_tree;
    1559. 

  1559.         proto_item * item;
    1560. 

  1560. 

  1561.         checksum_tree = proto_item_add_subtree(it_cksum, ett_ipv6_shim6_cksum);
    1562. 

  1562.         item = proto_tree_add_boolean(checksum_tree, hf_ipv6_shim6_checksum_good, tvb,
    1563. 

  1563.            offset, 2, is_cksum_correct);
    1564. 

  1564.         PROTO_ITEM_SET_GENERATED(item);
    1565. 

  1565.         item = proto_tree_add_boolean(checksum_tree, hf_ipv6_shim6_checksum_bad, tvb,
    1566. 

  1566.            offset, 2, !is_cksum_correct);
    1567. 

  1567.         PROTO_ITEM_SET_GENERATED(item);
    1568. 

  1568.         if (!is_cksum_correct) {
    1569. 

  1569.           expert_add_info(pinfo, item, &ei_ipv6_shim6_checksum_bad);
    1570. 

  1570.           col_append_str(pinfo->cinfo, COL_INFO, " [Shim6 CHECKSUM INCORRECT]");
    1571. 

  1571.         }
    1572. 

  1572. }
    1573. 

  1573. 

  1574. static int
    1575. 

  1575. dissect_shim6(tvbuff_t *tvb, int offset, proto_tree *tree, packet_info * pinfo)
    1576. 

  1576. {
    1577. 

  1577.     struct ip6_shim shim;
    1578. 

  1578.     int len;
    1579. 

  1579.     gint p;
    1580. 

  1580.     proto_tree *shim_tree;
    1581. 

  1581.     proto_item *ti;
    1582. 

  1582.     guint8 tmp[5];
    1583. 

  1583. 

  1584.     tvb_memcpy(tvb, (guint8 *)&shim, offset, sizeof(shim));
    1585. 

  1585.     len = (shim.ip6s_len + 1) << 3;
    1586. 

  1586. 

  1587.     if (tree)
    1588. 

  1588.     {
    1589. 

  1589.         ti = proto_tree_add_item(tree, hf_ipv6_shim6, tvb, offset, len, ENC_NA);
    1590. 

  1590.         shim_tree = proto_item_add_subtree(ti, ett_ipv6_shim6);
    1591. 

  1591. 

  1592.         /* Next Header */
    1593. 

  1593.         proto_tree_add_uint_format(shim_tree, hf_ipv6_shim6_nxt, tvb,
    1594. 

  1594.             offset + (int)offsetof(struct ip6_shim, ip6s_nxt), 1, shim.ip6s_nxt,
    1595. 

  1595.             "Next header: %s (%u)", ipprotostr(shim.ip6s_nxt), shim.ip6s_nxt);
    1596. 

  1596. 

  1597.         /* Header Extension Length */
    1598. 

  1598.         proto_tree_add_uint_format(shim_tree, hf_ipv6_shim6_len, tvb,
    1599. 

  1599.             offset + (int)offsetof(struct ip6_shim, ip6s_len), 1, shim.ip6s_len,
    1600. 

  1600.             "Header Ext Length: %u (%d bytes)", shim.ip6s_len, len);
    1601. 

  1601. 

  1602.         /* P Field */
    1603. 

  1603.         proto_tree_add_item(shim_tree, hf_ipv6_shim6_p, tvb,
    1604. 

  1604.                               offset + (int)offsetof(struct ip6_shim, ip6s_p), 1, ENC_BIG_ENDIAN);
    1605. 

  1605. 

  1606.         /* skip the first 2 bytes (nxt hdr, hdr ext len, p+7bits) */
    1607. 

  1607.         p = offset + 3;
    1608. 

  1608. 

  1609.         if (shim.ip6s_p & SHIM6_BITMASK_P)
    1610. 

  1610.         {
    1611. 

  1611.             tmp[0] = tvb_get_guint8(tvb, p++);
    1612. 

  1612.             tmp[1] = tvb_get_guint8(tvb, p++);
    1613. 

  1613.             tmp[2] = tvb_get_guint8(tvb, p++);
    1614. 

  1614.             tmp[3] = tvb_get_guint8(tvb, p++);
    1615. 

  1615.             tmp[4] = tvb_get_guint8(tvb, p++);
    1616. 

  1616. 

  1617.             /* Payload Extension Header */
    1618. 

  1618.             proto_tree_add_none_format(shim_tree, hf_ipv6_shim6_ct, tvb,
    1619. 

  1619.                 offset + (int)offsetof(struct ip6_shim, ip6s_p), 6,
    1620. 

  1620.                 "Receiver Context Tag: %02x %02x %02x %02x %02x %02x",
    1621. 

  1621.                 shim.ip6s_p & SHIM6_BITMASK_CT, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4]);
    1622. 

  1622.         }
    1623. 

  1623.         else
    1624. 

  1624.         {
    1625. 

  1625.             /* Control Message */
    1626. 

  1626.             guint16 csum;
    1627. 

  1627.             int advance;
    1628. 

  1628. 

  1629.             /* Message Type */
    1630. 

  1630.             proto_tree_add_item(shim_tree, hf_ipv6_shim6_type, tvb,
    1631. 

  1631.                                 offset + (int)offsetof(struct ip6_shim, ip6s_p), 1,
    1632. 

  1632.                                 ENC_BIG_ENDIAN
    1633. 

  1633.                                 );
    1634. 

  1634. 

  1635.             /* Protocol bit (Must be zero for SHIM6) */
    1636. 

  1636.             proto_tree_add_item(shim_tree, hf_ipv6_shim6_proto, tvb, p, 1, ENC_BIG_ENDIAN);
    1637. 

  1637.             p++;
    1638. 

  1638. 

  1639.             /* Checksum */
    1640. 

  1640.             csum = shim_checksum(tvb_get_ptr(tvb, offset, len), len);
    1641. 

  1641. 

  1642.             if (csum == 0) {
    1643. 

  1643.                 ti = proto_tree_add_uint_format(shim_tree, hf_ipv6_shim6_checksum, tvb, p, 2,
    1644. 

  1644.                     tvb_get_ntohs(tvb, p), "Checksum: 0x%04x [correct]", tvb_get_ntohs(tvb, p));
    1645. 

  1645.                 ipv6_shim6_checkum_additional_info(tvb, pinfo, ti, p, TRUE);
    1646. 

  1646.             } else {
    1647. 

  1647.                 ti = proto_tree_add_uint_format(shim_tree, hf_ipv6_shim6_checksum, tvb, p, 2,
    1648. 

  1648.                     tvb_get_ntohs(tvb, p), "Checksum: 0x%04x [incorrect: should be 0x%04x]",
    1649. 

  1649.                     tvb_get_ntohs(tvb, p), in_cksum_shouldbe(tvb_get_ntohs(tvb, p), csum));
    1650. 

  1650.                 ipv6_shim6_checkum_additional_info(tvb, pinfo, ti, p, FALSE);
    1651. 

  1651.             }
    1652. 

  1652.             p += 2;
    1653. 

  1653. 

  1654.             /* Type specific data */
    1655. 

  1655.             advance = dissect_shimctrl(tvb, p, shim.ip6s_p & SHIM6_BITMASK_TYPE, shim_tree);
    1656. 

  1656.             p += advance;
    1657. 

  1657. 

  1658.             /* Options */
    1659. 

  1659.             while (p < offset+len) {
    1660. 

  1660.               p += dissect_shimopts(tvb, p, shim_tree, pinfo);
    1661. 

  1661.             }
    1662. 

  1662.         }
    1663. 

  1663.     }
    1664. 

  1664.     return len;
    1665. 

  1665. }
    1666. 

  1666. 

  1667. /* END SHIM6 PART */
    1668. 

  1668. 

  1669. static void
    1670. 

  1670. dissect_ipv6(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
    1671. 

  1671. {
    1672. 

  1672.   proto_tree *ipv6_tree = NULL;
    1673. 

  1673.   proto_item *ipv6_item = NULL, *ti;
    1674. 

  1674.   guint8 nxt;
    1675. 

  1675.   guint8 stype=0;
    1676. 

  1676.   int advance;
    1677. 

  1677.   guint16 plen;
    1678. 

  1678.   gboolean hopopts, routing, frag, ah, shim6, dstopts;
    1679. 

  1679.   guint16 offlg;
    1680. 

  1680.   guint32 ident;
    1681. 

  1681.   int offset;
    1682. 

  1682.   fragment_head *ipfd_head;
    1683. 

  1683.   tvbuff_t   *next_tvb;
    1684. 

  1684.   gboolean update_col_info = TRUE;
    1685. 

  1685.   gboolean save_fragmented = FALSE;
    1686. 

  1686.   const char *sep = "IPv6 ";
    1687. 

  1687.   guint8 *mac_addr;
    1688. 

  1688. 

  1689.   struct ip6_hdr ipv6;
    1690. 

  1690. 

  1691.   col_set_str(pinfo->cinfo, COL_PROTOCOL, "IPv6");
    1692. 

  1692.   col_clear(pinfo->cinfo, COL_INFO);
    1693. 

  1693. 

  1694.   offset = 0;
    1695. 

  1695.   tvb_memcpy(tvb, (guint8 *)&ipv6, offset, sizeof(ipv6));
    1696. 

  1696. 

  1697.   /* Get extension header and payload length */
    1698. 

  1698.   plen = g_ntohs(ipv6.ip6_plen);
    1699. 

  1699. 

  1700.   /* Adjust the length of this tvbuff to include only the IPv6 datagram. */
    1701. 

  1701.   set_actual_length(tvb, plen + (guint)sizeof (struct ip6_hdr));
    1702. 

  1702. 

  1703.   TVB_SET_ADDRESS(&pinfo->net_src, AT_IPv6, tvb, offset + IP6H_SRC, 16);
    1704. 

  1704.   TVB_SET_ADDRESS(&pinfo->src, AT_IPv6,     tvb, offset + IP6H_SRC, 16);
    1705. 

  1705.   TVB_SET_ADDRESS(&pinfo->net_dst, AT_IPv6, tvb, offset + IP6H_DST, 16);
    1706. 

  1706.   TVB_SET_ADDRESS(&pinfo->dst, AT_IPv6,     tvb, offset + IP6H_DST, 16);
    1707. 

  1707. 

  1708.   if (tree) {
    1709. 

  1709.     proto_tree* pt;
    1710. 

  1710.     proto_item* pi;
    1711. 

  1711.     proto_tree *ipv6_tc_tree;
    1712. 

  1712.     proto_item *ipv6_tc;
    1713. 

  1713.     const char *name;
    1714. 

  1714. 

  1715.     ipv6_item = proto_tree_add_item(tree, proto_ipv6, tvb, offset, -1, ENC_NA);
    1716. 

  1716.     ipv6_tree = proto_item_add_subtree(ipv6_item, ett_ipv6);
    1717. 

  1717. 

  1718.     /* !!! warning: (4-bit) version, (6-bit) DSCP, (1-bit) ECN-ECT, (1-bit) ECN-CE and (20-bit) Flow */
    1719. 

  1719.     pi = proto_tree_add_item(ipv6_tree, hf_ipv6_version, tvb,
    1720. 

  1720.                         offset + (int)offsetof(struct ip6_hdr, ip6_vfc), 1, ENC_BIG_ENDIAN);
    1721. 

  1721.     pt = proto_item_add_subtree(pi,ett_ipv6_version);
    1722. 

  1722.     pi = proto_tree_add_item(pt, hf_ip_version, tvb,
    1723. 

  1723.                         offset + (int)offsetof(struct ip6_hdr, ip6_vfc), 1, ENC_BIG_ENDIAN);
    1724. 

  1724.     PROTO_ITEM_SET_GENERATED(pi);
    1725. 

  1725. 

  1726.     ipv6_tc = proto_tree_add_item(ipv6_tree, hf_ipv6_class, tvb,
    1727. 

  1727.                         offset + (int)offsetof(struct ip6_hdr, ip6_flow), 4, ENC_BIG_ENDIAN);
    1728. 

  1728. 

  1729.     ipv6_tc_tree = proto_item_add_subtree(ipv6_tc, ett_ipv6_traffic_class);
    1730. 

  1730. 

  1731.     proto_tree_add_item(ipv6_tc_tree, hf_ipv6_traffic_class_dscp, tvb,
    1732. 

  1732.                         offset + (int)offsetof(struct ip6_hdr, ip6_flow), 4, ENC_BIG_ENDIAN);
    1733. 

  1733.     proto_tree_add_item(ipv6_tc_tree, hf_ipv6_traffic_class_ect, tvb,
    1734. 

  1734.                         offset + (int)offsetof(struct ip6_hdr, ip6_flow), 4, ENC_BIG_ENDIAN);
    1735. 

  1735. 

  1736.     proto_tree_add_item(ipv6_tc_tree, hf_ipv6_traffic_class_ce, tvb,
    1737. 

  1737.                         offset + (int)offsetof(struct ip6_hdr, ip6_flow), 4, ENC_BIG_ENDIAN);
    1738. 

  1738. 

  1739.     proto_tree_add_item(ipv6_tree, hf_ipv6_flow, tvb,
    1740. 

  1740.                         offset + (int)offsetof(struct ip6_hdr, ip6_flow), 4, ENC_BIG_ENDIAN);
    1741. 

  1741. 

  1742.     proto_tree_add_item(ipv6_tree, hf_ipv6_plen, tvb,
    1743. 

  1743.                         offset + (int)offsetof(struct ip6_hdr, ip6_plen), 2, ENC_BIG_ENDIAN);
    1744. 

  1744. 

  1745.     proto_tree_add_uint_format(ipv6_tree, hf_ipv6_nxt, tvb,
    1746. 

  1746.                 offset + (int)offsetof(struct ip6_hdr, ip6_nxt), 1,
    1747. 

  1747.                 ipv6.ip6_nxt,
    1748. 

  1748.                 "Next header: %s (%u)",
    1749. 

  1749.                 ipprotostr(ipv6.ip6_nxt), ipv6.ip6_nxt);
    1750. 

  1750. 

  1751.     proto_tree_add_item(ipv6_tree, hf_ipv6_hlim, tvb,
    1752. 

  1752.                         offset + (int)offsetof(struct ip6_hdr, ip6_hlim), 1, ENC_BIG_ENDIAN);
    1753. 

  1753.     /* Yes, there is not TTL in IPv6 Header... but it is the same of Hop Limit...*/
    1754. 

  1754.     pinfo->ip_ttl = tvb_get_guint8(tvb, offset + (int)offsetof(struct ip6_hdr, ip6_hlim));
    1755. 

  1755. 

  1756.     /* Add the different items for the source address */
    1757. 

  1757.     proto_tree_add_item(ipv6_tree, hf_ipv6_src, tvb,
    1758. 

  1758.                         offset + (int)offsetof(struct ip6_hdr, ip6_src), 16, ENC_NA);
    1759. 

  1759.     ti = proto_tree_add_ipv6(ipv6_tree, hf_ipv6_addr, tvb,
    1760. 

  1760.                               offset + (int)offsetof(struct ip6_hdr, ip6_src),
    1761. 

  1761.                               16, (guint8 *)&ipv6.ip6_src);
    1762. 

  1762.     PROTO_ITEM_SET_HIDDEN(ti);
    1763. 

  1763.     name = get_addr_name(&pinfo->src);
    1764. 

  1764.     if (ipv6_summary_in_tree) {
    1765. 

  1765.       proto_item_append_text(ipv6_item, ", Src: %s (%s)", name, ip6_to_str(&ipv6.ip6_src));
    1766. 

  1766.     }
    1767. 

  1767.     ti = proto_tree_add_string(ipv6_tree, hf_ipv6_src_host, tvb,
    1768. 

  1768.                               offset + (int)offsetof(struct ip6_hdr, ip6_src),
    1769. 

  1769.                               16, name);
    1770. 

  1770.     PROTO_ITEM_SET_GENERATED(ti);
    1771. 

  1771.     PROTO_ITEM_SET_HIDDEN(ti);
    1772. 

  1772.     ti = proto_tree_add_string(ipv6_tree, hf_ipv6_host, tvb,
    1773. 

  1773.                               offset + (int)offsetof(struct ip6_hdr, ip6_src),
    1774. 

  1774.                               16, name);
    1775. 

  1775.     PROTO_ITEM_SET_GENERATED(ti);
    1776. 

  1776.     PROTO_ITEM_SET_HIDDEN(ti);
    1777. 

  1777. 

  1778.     /* Extract embedded (IPv6 and MAC) address information */
    1779. 

  1779.     if (tvb_get_ntohs(tvb, offset + IP6H_SRC) == 0x2002) { /* RFC 3056 section 2 */
    1780. 

  1780.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_src_6to4_gateway_ipv4, tvb,
    1781. 

  1781.                                 offset + IP6H_SRC + 2, 4, ENC_BIG_ENDIAN);
    1782. 

  1782.       PROTO_ITEM_SET_GENERATED(ti);
    1783. 

  1783.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_src_6to4_sla_id, tvb,
    1784. 

  1784.                                 offset + IP6H_SRC + 6, 2, ENC_BIG_ENDIAN);
    1785. 

  1785.       PROTO_ITEM_SET_GENERATED(ti);
    1786. 

  1786.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_6to4_gateway_ipv4, tvb,
    1787. 

  1787.                                 offset + IP6H_SRC + 2, 4, ENC_BIG_ENDIAN);
    1788. 

  1788.       PROTO_ITEM_SET_GENERATED(ti);
    1789. 

  1789.       PROTO_ITEM_SET_HIDDEN(ti);
    1790. 

  1790.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_6to4_sla_id, tvb,
    1791. 

  1791.                                 offset + IP6H_SRC + 6, 2, ENC_BIG_ENDIAN);
    1792. 

  1792.       PROTO_ITEM_SET_GENERATED(ti);
    1793. 

  1793.       PROTO_ITEM_SET_HIDDEN(ti);
    1794. 

  1794.     } else if (tvb_get_ntohl(tvb, offset + IP6H_SRC) == 0x20010000) { /* RFC 4380 section 4 */
    1795. 

  1795.       guint16 mapped_port = tvb_get_ntohs(tvb, offset + IP6H_SRC + 10) ^ 0xffff;
    1796. 

  1796.       guint32 client_v4 = tvb_get_ipv4(tvb, offset + IP6H_SRC + 12) ^ 0xffffffff;
    1797. 

  1797. 

  1798.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_src_teredo_server_ipv4, tvb,
    1799. 

  1799.                                 offset + IP6H_SRC + 4, 4, ENC_BIG_ENDIAN);
    1800. 

  1800.       PROTO_ITEM_SET_GENERATED(ti);
    1801. 

  1801.       ti = proto_tree_add_uint(ipv6_tree, hf_ipv6_src_teredo_port, tvb,
    1802. 

  1802.                                 offset + IP6H_SRC + 10, 2, mapped_port);
    1803. 

  1803.       PROTO_ITEM_SET_GENERATED(ti);
    1804. 

  1804.       ti = proto_tree_add_ipv4(ipv6_tree, hf_ipv6_src_teredo_client_ipv4, tvb,
    1805. 

  1805.                                 offset + IP6H_SRC + 12, 4, client_v4);
    1806. 

  1806.       PROTO_ITEM_SET_GENERATED(ti);
    1807. 

  1807.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_teredo_server_ipv4, tvb,
    1808. 

  1808.                                 offset + IP6H_SRC + 4, 4, ENC_BIG_ENDIAN);
    1809. 

  1809.       PROTO_ITEM_SET_GENERATED(ti);
    1810. 

  1810.       PROTO_ITEM_SET_HIDDEN(ti);
    1811. 

  1811.       ti = proto_tree_add_uint(ipv6_tree, hf_ipv6_teredo_port, tvb,
    1812. 

  1812.                                 offset + IP6H_SRC + 10, 2, mapped_port);
    1813. 

  1813.       PROTO_ITEM_SET_GENERATED(ti);
    1814. 

  1814.       PROTO_ITEM_SET_HIDDEN(ti);
    1815. 

  1815.       ti = proto_tree_add_ipv4(ipv6_tree, hf_ipv6_teredo_client_ipv4, tvb,
    1816. 

  1816.                                 offset + IP6H_SRC + 12, 4, client_v4);
    1817. 

  1817.       PROTO_ITEM_SET_GENERATED(ti);
    1818. 

  1818.       PROTO_ITEM_SET_HIDDEN(ti);
    1819. 

  1819.     }
    1820. 

  1820. 

  1821.     if (tvb_get_guint8(tvb, offset + IP6H_SRC + 8) & 0x02 && tvb_get_ntohs(tvb, offset + IP6H_SRC + 11) == 0xfffe) {  /* RFC 4291 appendix A */
    1822. 

  1822.       mac_addr = (guint8 *)ep_alloc(6);
    1823. 

  1823.       tvb_memcpy(tvb, mac_addr, offset + IP6H_SRC + 8, 3);
    1824. 

  1824.       tvb_memcpy(tvb, mac_addr+3, offset+ IP6H_SRC + 13, 3);
    1825. 

  1825.       mac_addr[0] &= ~0x02;
    1826. 

  1826.       ti = proto_tree_add_ether(ipv6_tree, hf_ipv6_src_sa_mac, tvb,
    1827. 

  1827.                                 offset + IP6H_SRC + 8, 6, mac_addr);
    1828. 

  1828.       PROTO_ITEM_SET_GENERATED(ti);
    1829. 

  1829.       ti = proto_tree_add_ether(ipv6_tree, hf_ipv6_sa_mac, tvb,
    1830. 

  1830.                                 offset + IP6H_SRC + 8, 6, mac_addr);
    1831. 

  1831.       PROTO_ITEM_SET_GENERATED(ti);
    1832. 

  1832.       PROTO_ITEM_SET_HIDDEN(ti);
    1833. 

  1833.     } else if ((tvb_get_ntohl(tvb, offset + IP6H_SRC + 8) & 0xfcffffff) == 0x00005efe) { /* RFC 5214 section 6.1 */
    1834. 

  1834.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_src_isatap_ipv4, tvb,
    1835. 

  1835.                                 offset + IP6H_SRC + 12, 4, ENC_BIG_ENDIAN);
    1836. 

  1836.       PROTO_ITEM_SET_GENERATED(ti);
    1837. 

  1837.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_isatap_ipv4, tvb,
    1838. 

  1838.                                 offset + IP6H_SRC + 12, 4, ENC_BIG_ENDIAN);
    1839. 

  1839.       PROTO_ITEM_SET_GENERATED(ti);
    1840. 

  1840.       PROTO_ITEM_SET_HIDDEN(ti);
    1841. 

  1841.     }
    1842. 

  1842. 

  1843.     /* Add different items for the destination address */
    1844. 

  1844.     proto_tree_add_item(ipv6_tree, hf_ipv6_dst, tvb,
    1845. 

  1845.                         offset + (int)offsetof(struct ip6_hdr, ip6_dst), 16, ENC_NA);
    1846. 

  1846.     ti = proto_tree_add_ipv6(ipv6_tree, hf_ipv6_addr, tvb,
    1847. 

  1847.                               offset + (int)offsetof(struct ip6_hdr, ip6_dst),
    1848. 

  1848.                               16, (guint8 *)&ipv6.ip6_dst);
    1849. 

  1849.     PROTO_ITEM_SET_HIDDEN(ti);
    1850. 

  1850.     name = get_addr_name(&pinfo->dst);
    1851. 

  1851.     if (ipv6_summary_in_tree) {
    1852. 

  1852.       proto_item_append_text(ipv6_item, ", Dst: %s (%s)", name, ip6_to_str(&ipv6.ip6_dst));
    1853. 

  1853.     }
    1854. 

  1854.     ti = proto_tree_add_string(ipv6_tree, hf_ipv6_dst_host, tvb,
    1855. 

  1855.                               offset + (int)offsetof(struct ip6_hdr, ip6_dst),
    1856. 

  1856.                               16, name);
    1857. 

  1857.     PROTO_ITEM_SET_GENERATED(ti);
    1858. 

  1858.     PROTO_ITEM_SET_HIDDEN(ti);
    1859. 

  1859.     ti = proto_tree_add_string(ipv6_tree, hf_ipv6_host, tvb,
    1860. 

  1860.                               offset + (int)offsetof(struct ip6_hdr, ip6_dst),
    1861. 

  1861.                               16, name);
    1862. 

  1862.     PROTO_ITEM_SET_GENERATED(ti);
    1863. 

  1863.     PROTO_ITEM_SET_HIDDEN(ti);
    1864. 

  1864. 

  1865.     /* Extract embedded (IPv6 and MAC) address information */
    1866. 

  1866.     if (tvb_get_ntohs(tvb, offset + IP6H_DST) == 0x2002) { /* RFC 3056 section 2 */
    1867. 

  1867.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_dst_6to4_gateway_ipv4, tvb,
    1868. 

  1868.                                 offset + IP6H_DST + 2, 4, ENC_BIG_ENDIAN);
    1869. 

  1869.       PROTO_ITEM_SET_GENERATED(ti);
    1870. 

  1870.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_dst_6to4_sla_id, tvb,
    1871. 

  1871.                                 offset + IP6H_DST + 6, 2, ENC_BIG_ENDIAN);
    1872. 

  1872.       PROTO_ITEM_SET_GENERATED(ti);
    1873. 

  1873.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_6to4_gateway_ipv4, tvb,
    1874. 

  1874.                                 offset + IP6H_DST + 2, 4, ENC_BIG_ENDIAN);
    1875. 

  1875.       PROTO_ITEM_SET_GENERATED(ti);
    1876. 

  1876.       PROTO_ITEM_SET_HIDDEN(ti);
    1877. 

  1877.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_6to4_sla_id, tvb,
    1878. 

  1878.                                 offset + IP6H_DST + 6, 2, ENC_BIG_ENDIAN);
    1879. 

  1879.       PROTO_ITEM_SET_GENERATED(ti);
    1880. 

  1880.       PROTO_ITEM_SET_HIDDEN(ti);
    1881. 

  1881.     } else if (tvb_get_ntohl(tvb, offset + IP6H_DST) == 0x20010000) { /* RFC 4380 section 4 */
    1882. 

  1882.       guint16 mapped_port = tvb_get_ntohs(tvb, offset + IP6H_DST + 10) ^ 0xffff;
    1883. 

  1883.       guint32 client_v4 = tvb_get_ipv4(tvb, offset + IP6H_DST + 12) ^ 0xffffffff;
    1884. 

  1884. 

  1885.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_dst_teredo_server_ipv4, tvb,
    1886. 

  1886.                                 offset + IP6H_DST + 4, 4, ENC_BIG_ENDIAN);
    1887. 

  1887.       PROTO_ITEM_SET_GENERATED(ti);
    1888. 

  1888.       ti = proto_tree_add_uint(ipv6_tree, hf_ipv6_dst_teredo_port, tvb,
    1889. 

  1889.                                 offset + IP6H_DST + 10, 2, mapped_port);
    1890. 

  1890.       PROTO_ITEM_SET_GENERATED(ti);
    1891. 

  1891.       ti = proto_tree_add_ipv4(ipv6_tree, hf_ipv6_dst_teredo_client_ipv4, tvb,
    1892. 

  1892.                                 offset + IP6H_DST + 12, 4, client_v4);
    1893. 

  1893.       PROTO_ITEM_SET_GENERATED(ti);
    1894. 

  1894.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_teredo_server_ipv4, tvb,
    1895. 

  1895.                                 offset + IP6H_DST + 4, 4, ENC_BIG_ENDIAN);
    1896. 

  1896.       PROTO_ITEM_SET_GENERATED(ti);
    1897. 

  1897.       PROTO_ITEM_SET_HIDDEN(ti);
    1898. 

  1898.       ti = proto_tree_add_uint(ipv6_tree, hf_ipv6_teredo_port, tvb,
    1899. 

  1899.                                 offset + IP6H_DST + 10, 2, mapped_port);
    1900. 

  1900.       PROTO_ITEM_SET_GENERATED(ti);
    1901. 

  1901.       PROTO_ITEM_SET_HIDDEN(ti);
    1902. 

  1902.       ti = proto_tree_add_ipv4(ipv6_tree, hf_ipv6_teredo_client_ipv4, tvb,
    1903. 

  1903.                                 offset + IP6H_DST + 12, 4, client_v4);
    1904. 

  1904.       PROTO_ITEM_SET_GENERATED(ti);
    1905. 

  1905.       PROTO_ITEM_SET_HIDDEN(ti);
    1906. 

  1906.     }
    1907. 

  1907. 

  1908.     if (tvb_get_guint8(tvb, offset + IP6H_DST + 8) & 0x02 && tvb_get_ntohs(tvb, offset + IP6H_DST + 11) == 0xfffe) { /* RFC 4291 appendix A */
    1909. 

  1909.       mac_addr = (guint8 *)ep_alloc(6);
    1910. 

  1910.       tvb_memcpy(tvb, mac_addr, offset + IP6H_DST + 8, 3);
    1911. 

  1911.       tvb_memcpy(tvb, mac_addr+3, offset+ IP6H_DST + 13, 3);
    1912. 

  1912.       mac_addr[0] &= ~0x02;
    1913. 

  1913.       ti = proto_tree_add_ether(ipv6_tree, hf_ipv6_dst_sa_mac, tvb,
    1914. 

  1914.                                 offset + IP6H_DST + 8, 6, mac_addr);
    1915. 

  1915.       PROTO_ITEM_SET_GENERATED(ti);
    1916. 

  1916.       ti = proto_tree_add_ether(ipv6_tree, hf_ipv6_sa_mac, tvb,
    1917. 

  1917.                                 offset + IP6H_DST + 8, 6, mac_addr);
    1918. 

  1918.       PROTO_ITEM_SET_GENERATED(ti);
    1919. 

  1919.       PROTO_ITEM_SET_HIDDEN(ti);
    1920. 

  1920.     } else if ((tvb_get_ntohl(tvb, offset + IP6H_DST + 8) & 0xfcffffff) == 0x00005efe) { /* RFC 5214 section 6.1 */
    1921. 

  1921.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_dst_isatap_ipv4, tvb,
    1922. 

  1922.                                 offset + IP6H_DST + 12, 4, ENC_BIG_ENDIAN);
    1923. 

  1923.       PROTO_ITEM_SET_GENERATED(ti);
    1924. 

  1924.       ti = proto_tree_add_item(ipv6_tree, hf_ipv6_isatap_ipv4, tvb,
    1925. 

  1925.                                 offset + IP6H_DST + 12, 4, ENC_BIG_ENDIAN);
    1926. 

  1926.       PROTO_ITEM_SET_GENERATED(ti);
    1927. 

  1927.       PROTO_ITEM_SET_HIDDEN(ti);
    1928. 

  1928.     }
    1929. 

  1929.   }
    1930. 

  1930. 

  1931. #ifdef HAVE_GEOIP_V6
    1932. 

  1932.   if (tree && ipv6_use_geoip) {
    1933. 

  1933.     add_geoip_info(ipv6_tree, tvb, offset, &ipv6.ip6_src, &ipv6.ip6_dst);
    1934. 

  1934.   }
    1935. 

  1935. #endif
    1936. 

  1936. 

  1937.   /* start of the new header (could be a extension header) */
    1938. 

  1938.   nxt = tvb_get_guint8(tvb, offset + 6);
    1939. 

  1939.   offset += (int)sizeof(struct ip6_hdr);
    1940. 

  1940.   offlg = 0;
    1941. 

  1941.   ident = 0;
    1942. 

  1942. 

  1943. /* start out assuming this isn't fragmented, and has none of the other
    1944. 

  1944.    non-final headers */
    1945. 

  1945.   hopopts = FALSE;
    1946. 

  1946.   routing = FALSE;
    1947. 

  1947.   ah = FALSE;
    1948. 

  1948.   shim6 = FALSE;
    1949. 

  1949.   dstopts = FALSE;
    1950. 

  1950. 

  1951. again:
    1952. 

  1952.    switch (nxt) {
    1953. 

  1953. 

  1954.    case IP_PROTO_HOPOPTS:
    1955. 

  1955.       hopopts = TRUE;
    1956. 

  1956.       advance = dissect_hopopts(tvb, offset, ipv6_tree, pinfo);
    1957. 

  1957.       nxt = tvb_get_guint8(tvb, offset);
    1958. 

  1958.       offset += advance;
    1959. 

  1959.       plen -= advance;
    1960. 

  1960.       goto again;
    1961. 

  1961. 

  1962.     case IP_PROTO_ROUTING:
    1963. 

  1963.       routing = TRUE;
    1964. 

  1964.       advance = dissect_routing6(tvb, offset, ipv6_tree, pinfo);
    1965. 

  1965.       nxt = tvb_get_guint8(tvb, offset);
    1966. 

  1966.       offset += advance;
    1967. 

  1967.       plen -= advance;
    1968. 

  1968.       goto again;
    1969. 

  1969. 

  1970.     case IP_PROTO_FRAGMENT:
    1971. 

  1971.       advance = dissect_frag6(tvb, offset, pinfo, ipv6_tree,
    1972. 

  1972.           &offlg, &ident);
    1973. 

  1973.       nxt = tvb_get_guint8(tvb, offset);
    1974. 

  1974.       offset += advance;
    1975. 

  1975.       plen -= advance;
    1976. 

  1976.       frag = offlg & (IP6F_OFF_MASK | IP6F_MORE_FRAG);
    1977. 

  1977.       save_fragmented |= frag;
    1978. 

  1978.       if (ipv6_reassemble && frag && tvb_bytes_exist(tvb, offset, plen)) {
    1979. 

  1979.         ipfd_head = fragment_add_check(&ipv6_reassembly_table,
    1980. 

  1980.           tvb, offset, pinfo, ident, NULL,
    1981. 

  1981.           offlg & IP6F_OFF_MASK,
    1982. 

  1982.           plen,
    1983. 

  1983.           offlg & IP6F_MORE_FRAG);
    1984. 

  1984.         next_tvb = process_reassembled_data(tvb, offset, pinfo, "Reassembled IPv6",
    1985. 

  1985.         ipfd_head, &ipv6_frag_items, &update_col_info, ipv6_tree);
    1986. 

  1986.         if (next_tvb) {  /* Process post-fragment headers after reassembly... */
    1987. 

  1987.           offset= 0;
    1988. 

  1988.           offlg = 0;
    1989. 

  1989.           tvb = next_tvb;
    1990. 

  1990.           goto again;
    1991. 

  1991.         }
    1992. 

  1992.       }
    1993. 

  1993.       if (!(offlg & IP6F_OFF_MASK)) /*...or in the first fragment */
    1994. 

  1994.         goto again;
    1995. 

  1995.       break;
    1996. 

  1996. 

  1997.     case IP_PROTO_AH:
    1998. 

  1998.       ah = TRUE;
    1999. 

  1999.       advance = dissect_ah_header(tvb_new_subset_remaining(tvb, offset),
    2000. 

  2000.                                   pinfo, ipv6_tree, NULL, NULL);
    2001. 

  2001.       nxt = tvb_get_guint8(tvb, offset);
    2002. 

  2002.       offset += advance;
    2003. 

  2003.       plen -= advance;
    2004. 

  2004.       goto again;
    2005. 

  2005. 

  2006.     case IP_PROTO_SHIM6:
    2007. 

  2007.     case IP_PROTO_SHIM6_OLD:
    2008. 

  2008.       shim6 = TRUE;
    2009. 

  2009.       advance = dissect_shim6(tvb, offset, ipv6_tree, pinfo);
    2010. 

  2010.       nxt = tvb_get_guint8(tvb, offset);
    2011. 

  2011.       stype = tvb_get_guint8(tvb, offset+2);
    2012. 

  2012.       offset += advance;
    2013. 

  2013.       plen -= advance;
    2014. 

  2014.       goto again;
    2015. 

  2015. 

  2016.     case IP_PROTO_DSTOPTS:
    2017. 

  2017.       dstopts = TRUE;
    2018. 

  2018.       advance = dissect_dstopts(tvb, offset, ipv6_tree, pinfo);
    2019. 

  2019.       nxt = tvb_get_guint8(tvb, offset);
    2020. 

  2020.       offset += advance;
    2021. 

  2021.       plen -= advance;
    2022. 

  2022.       goto again;
    2023. 

  2023. 

  2024.     case IP_PROTO_NONE:
    2025. 

  2025.       break;
    2026. 

  2026. 

  2027.     default:
    2028. 

  2028.       /* Since we did not recognize this IPv6 option, check
    2029. 

  2029.        * whether it is a known protocol. If not, then it
    2030. 

  2030.        * is an unknown IPv6 option
    2031. 

  2031.        */
    2032. 

  2032.       if (!dissector_get_uint_handle(ip_dissector_table, nxt)) {
    2033. 

  2033.         advance = dissect_unknown_option(tvb, offset, ipv6_tree);
    2034. 

  2034.         nxt = tvb_get_guint8(tvb, offset);
    2035. 

  2035.         offset += advance;
    2036. 

  2036.         plen -= advance;
    2037. 

  2037.         goto again;
    2038. 

  2038.       }
    2039. 

  2039.     }
    2040. 

  2040. 

  2041.   proto_item_set_len (ipv6_item, offset);
    2042. 

  2042. 

  2043.   /* collect packet info */
    2044. 

  2044.   pinfo->ipproto = nxt;
    2045. 

  2045.   pinfo->iplen = (int)sizeof(ipv6) + plen + offset;
    2046. 

  2046.   pinfo->iphdrlen = offset;
    2047. 

  2047.   tap_queue_packet(ipv6_tap, pinfo, &ipv6);
    2048. 

  2048. 

  2049.   if (offlg & IP6F_OFF_MASK || (ipv6_reassemble && offlg & IP6F_MORE_FRAG)) {
    2050. 

  2050.     /* Not the first fragment, or the first when we are reassembling and there are more. */
    2051. 

  2051.     /* Don't dissect it; just show this as a fragment. */
    2052. 

  2052.     /* COL_INFO was filled in by "dissect_frag6()" */
    2053. 

  2053.     call_dissector(data_handle, tvb_new_subset_remaining(tvb, offset), pinfo, tree);
    2054. 

  2054.     return;
    2055. 

  2055.   } else {
    2056. 

  2056.     /* First fragment, not fragmented, or already reassembled.  Dissect what we have here. */
    2057. 

  2057. 

  2058.     /* Get a tvbuff for the payload. */
    2059. 

  2059.     next_tvb = tvb_new_subset_remaining(tvb, offset);
    2060. 

  2060. 

  2061.     /*
    2062. 

  2062.      * If this is the first fragment, but not the only fragment,
    2063. 

  2063.      * tell the next protocol that.
    2064. 

  2064.      */
    2065. 

  2065.     if (offlg & IP6F_MORE_FRAG)
    2066. 

  2066.       pinfo->fragmented = TRUE;
    2067. 

  2067.     else
    2068. 

  2068.       pinfo->fragmented = FALSE;
    2069. 

  2069.   }
    2070. 

  2070. 

  2071. 

  2072.   /* do lookup with the subdissector table */
    2073. 

  2073.   if (!dissector_try_uint(ip_dissector_table, nxt, next_tvb, pinfo, tree)) {
    2074. 

  2074.     /* Unknown protocol.
    2075. 

  2075.        Handle "no next header" specially. */
    2076. 

  2076.     if (nxt == IP_PROTO_NONE) {
    2077. 

  2077.         /* If we had an Authentication Header, the AH dissector already
    2078. 

  2078.            put something in the Info column; leave it there. */
    2079. 

  2079.         if (!ah) {
    2080. 

  2080.           if (hopopts || routing || dstopts || shim6) {
    2081. 

  2081.             if (hopopts) {
    2082. 

  2082.               col_append_fstr(pinfo->cinfo, COL_INFO, "%shop-by-hop options",
    2083. 

  2083.                              sep);
    2084. 

  2084.               sep = ", ";
    2085. 

  2085.             }
    2086. 

  2086.             if (routing) {
    2087. 

  2087.               col_append_fstr(pinfo->cinfo, COL_INFO, "%srouting", sep);
    2088. 

  2088.               sep = ", ";
    2089. 

  2089.             }
    2090. 

  2090.             if (dstopts) {
    2091. 

  2091.               col_append_fstr(pinfo->cinfo, COL_INFO, "%sdestination options",
    2092. 

  2092.                               sep);
    2093. 

  2093.             }
    2094. 

  2094.             if (shim6) {
    2095. 

  2095.               if (stype & SHIM6_BITMASK_P) {
    2096. 

  2096.                 col_append_str(pinfo->cinfo, COL_INFO, "Shim6 (Payload)");
    2097. 

  2097.               }
    2098. 

  2098.               else {
    2099. 

  2099.                 col_append_fstr(pinfo->cinfo, COL_INFO, "Shim6 (%s)",
    2100. 

  2100.                    val_to_str_const(stype & SHIM6_BITMASK_TYPE, shimctrlvals, "Unknown"));
    2101. 

  2101.               }
    2102. 

  2102.             }
    2103. 

  2103.           } else
    2104. 

  2104.             col_set_str(pinfo->cinfo, COL_INFO, "IPv6 no next header");
    2105. 

  2105.         }
    2106. 

  2106.     } else {
    2107. 

  2107.         col_add_fstr(pinfo->cinfo, COL_INFO, "%s (%u)", ipprotostr(nxt), nxt);
    2108. 

  2108.     }
    2109. 

  2109.     call_dissector(data_handle, next_tvb, pinfo, tree);
    2110. 

  2110.   }
    2111. 

  2111.   pinfo->fragmented = save_fragmented;
    2112. 

  2112. }
    2113. 

  2113. 

  2114. void
    2115. 

  2115. proto_register_ipv6(void)
    2116. 

  2116. {
    2117. 

  2117.   static hf_register_info hf[] = {
    2118. 

  2118.     { &hf_ipv6_version,
    2119. 

  2119.       { "Version",              "ipv6.version",
    2120. 

  2120.                                 FT_UINT8, BASE_DEC, NULL, 0xF0, NULL, HFILL }},
    2121. 

  2121.     { &hf_ip_version,
    2122. 

  2122.       { "This field makes the filter \"ip.version == 6\" possible",             "ip.version",
    2123. 

  2123.                                 FT_UINT8, BASE_DEC, NULL, 0xF0, NULL, HFILL }},
    2124. 

  2124.     { &hf_ipv6_class,
    2125. 

  2125.       { "Traffic class",        "ipv6.class",
    2126. 

  2126.                                 FT_UINT32, BASE_HEX, NULL, 0x0FF00000, NULL, HFILL }},
    2127. 

  2127.     { &hf_ipv6_flow,
    2128. 

  2128.       { "Flowlabel",            "ipv6.flow",
    2129. 

  2129.                                 FT_UINT32, BASE_HEX, NULL, 0x000FFFFF, NULL, HFILL }},
    2130. 

  2130.     { &hf_ipv6_plen,
    2131. 

  2131.       { "Payload length",       "ipv6.plen",
    2132. 

  2132.                                 FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL }},
    2133. 

  2133.     { &hf_ipv6_nxt,
    2134. 

  2134.       { "Next header",          "ipv6.nxt",
    2135. 

  2135.                                 FT_UINT8, BASE_DEC | BASE_EXT_STRING, &ipproto_val_ext, 0x0, NULL, HFILL }},
    2136. 

  2136.     { &hf_ipv6_hlim,
    2137. 

  2137.       { "Hop limit",            "ipv6.hlim",
    2138. 

  2138.                                 FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
    2139. 

  2139.     { &hf_ipv6_src,
    2140. 

  2140.       { "Source",               "ipv6.src",
    2141. 

  2141.                                 FT_IPv6, BASE_NONE, NULL, 0x0,
    2142. 

  2142.                                 "Source IPv6 Address", HFILL }},
    2143. 

  2143.     { &hf_ipv6_src_host,
    2144. 

  2144.       { "Source Host",          "ipv6.src_host",
    2145. 

  2145.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2146. 

  2146.                                 "Source IPv6 Host", HFILL }},
    2147. 

  2147.     { &hf_ipv6_src_sa_mac,
    2148. 

  2148.       { "Source SA MAC",                "ipv6.src_sa_mac",
    2149. 

  2149.                                 FT_ETHER, BASE_NONE, NULL, 0x0,
    2150. 

  2150.                                 "Source IPv6 Stateless Autoconfiguration MAC Address", HFILL }},
    2151. 

  2151.     { &hf_ipv6_src_isatap_ipv4,
    2152. 

  2152.       { "Source ISATAP IPv4",           "ipv6.src_isatap_ipv4",
    2153. 

  2153.                                 FT_IPv4, BASE_NONE, NULL, 0x0,
    2154. 

  2154.                                 "Source IPv6 ISATAP Encapsulated IPv4 Address", HFILL }},
    2155. 

  2155.     { &hf_ipv6_src_6to4_gateway_ipv4,
    2156. 

  2156.       { "Source 6to4 Gateway IPv4",     "ipv6.src_6to4_gw_ipv4",
    2157. 

  2157.                                 FT_IPv4, BASE_NONE, NULL, 0x0,
    2158. 

  2158.                                 "Source IPv6 6to4 Gateway IPv4 Address", HFILL }},
    2159. 

  2159.     { &hf_ipv6_src_6to4_sla_id,
    2160. 

  2160.       { "Source 6to4 SLA ID",           "ipv6.src_6to4_sla_id",
    2161. 

  2161.                                 FT_UINT16, BASE_DEC, NULL, 0x0,
    2162. 

  2162.                                 "Source IPv6 6to4 SLA ID", HFILL }},
    2163. 

  2163.     { &hf_ipv6_src_teredo_server_ipv4,
    2164. 

  2164.       { "Source Teredo Server IPv4",    "ipv6.src_ts_ipv4",
    2165. 

  2165.                                 FT_IPv4, BASE_NONE, NULL, 0x0,
    2166. 

  2166.                                 "Source IPv6 Teredo Server Encapsulated IPv4 Address", HFILL }},
    2167. 

  2167.     { &hf_ipv6_src_teredo_port,
    2168. 

  2168.       { "Source Teredo Port",           "ipv6.src_tc_port",
    2169. 

  2169.                                 FT_UINT16, BASE_DEC, NULL, 0x0,
    2170. 

  2170.                                 "Source IPv6 Teredo Client Mapped Port", HFILL }},
    2171. 

  2171.     { &hf_ipv6_src_teredo_client_ipv4,
    2172. 

  2172.       { "Source Teredo Client IPv4",    "ipv6.src_tc_ipv4",
    2173. 

  2173.                                 FT_IPv4, BASE_NONE, NULL, 0x0,
    2174. 

  2174.                                 "Source IPv6 Teredo Client Encapsulated IPv4 Address", HFILL }},
    2175. 

  2175.     { &hf_ipv6_dst,
    2176. 

  2176.       { "Destination",          "ipv6.dst",
    2177. 

  2177.                                 FT_IPv6, BASE_NONE, NULL, 0x0,
    2178. 

  2178.                                 "Destination IPv6 Address", HFILL }},
    2179. 

  2179.     { &hf_ipv6_dst_host,
    2180. 

  2180.       { "Destination Host",     "ipv6.dst_host",
    2181. 

  2181.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2182. 

  2182.                                 "Destination IPv6 Host", HFILL }},
    2183. 

  2183.     { &hf_ipv6_dst_sa_mac,
    2184. 

  2184.       { "Destination SA MAC",                   "ipv6.dst_sa_mac",
    2185. 

  2185.                                 FT_ETHER, BASE_NONE, NULL, 0x0,
    2186. 

  2186.                                 "Destination IPv6 Stateless Autoconfiguration MAC Address", HFILL }},
    2187. 

  2187.     { &hf_ipv6_dst_isatap_ipv4,
    2188. 

  2188.       { "Destination ISATAP IPv4",              "ipv6.dst_isatap_ipv4",
    2189. 

  2189.                                 FT_IPv4, BASE_NONE, NULL, 0x0,
    2190. 

  2190.                                 "Destination IPv6 ISATAP Encapsulated IPv4 Address", HFILL }},
    2191. 

  2191.     { &hf_ipv6_dst_6to4_gateway_ipv4,
    2192. 

  2192.       { "Destination 6to4 Gateway IPv4",        "ipv6.dst_6to4_gw_ipv4",
    2193. 

  2193.                                 FT_IPv4, BASE_NONE, NULL, 0x0,
    2194. 

  2194.                                 "Destination IPv6 6to4 Gateway IPv4 Address", HFILL }},
    2195. 

  2195.     { &hf_ipv6_dst_6to4_sla_id,
    2196. 

  2196.       { "Destination 6to4 SLA ID",               "ipv6.dst_6to4_sla_id",
    2197. 

  2197.                                 FT_UINT16, BASE_DEC, NULL, 0x0,
    2198. 

  2198.                                 "Destination IPv6 6to4 SLA ID", HFILL }},
    2199. 

  2199.     { &hf_ipv6_dst_teredo_server_ipv4,
    2200. 

  2200.       { "Destination Teredo Server IPv4",         "ipv6.dst_ts_ipv4",
    2201. 

  2201.                                 FT_IPv4, BASE_NONE, NULL, 0x0,
    2202. 

  2202.                                 "Destination IPv6 Teredo Server Encapsulated IPv4 Address", HFILL }},
    2203. 

  2203.     { &hf_ipv6_dst_teredo_port,
    2204. 

  2204.       { "Destination Teredo Port",                "ipv6.dst_tc_port",
    2205. 

  2205.                                 FT_UINT16, BASE_DEC, NULL, 0x0,
    2206. 

  2206.                                 "Destination IPv6 Teredo Client Mapped Port", HFILL }},
    2207. 

  2207.     { &hf_ipv6_dst_teredo_client_ipv4,
    2208. 

  2208.       { "Destination Teredo Client IPv4",         "ipv6.dst_tc_ipv4",
    2209. 

  2209.                                 FT_IPv4, BASE_NONE, NULL, 0x0,
    2210. 

  2210.                                 "Destination IPv6 Teredo Client Encapsulated IPv4 Address", HFILL }},
    2211. 

  2211.     { &hf_ipv6_addr,
    2212. 

  2212.       { "Source or Destination Address",          "ipv6.addr",
    2213. 

  2213.                                 FT_IPv6, BASE_NONE, NULL, 0x0,
    2214. 

  2214.                                 NULL, HFILL }},
    2215. 

  2215.     { &hf_ipv6_host,
    2216. 

  2216.       { "Source or Destination Host",             "ipv6.host",
    2217. 

  2217.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2218. 

  2218.                                 NULL, HFILL }},
    2219. 

  2219. 

  2220.     { &hf_ipv6_sa_mac,
    2221. 

  2221.       { "SA MAC",               "ipv6.sa_mac",
    2222. 

  2222.                                 FT_ETHER, BASE_NONE, NULL, 0x0,
    2223. 

  2223.                                 "IPv6 Stateless Autoconfiguration MAC Address", HFILL }},
    2224. 

  2224.     { &hf_ipv6_isatap_ipv4,
    2225. 

  2225.       { "ISATAP IPv4",          "ipv6.isatap_ipv4",
    2226. 

  2226.                                 FT_IPv4, BASE_NONE, NULL, 0x0,
    2227. 

  2227.                                 "IPv6 ISATAP Encapsulated IPv4 Address", HFILL }},
    2228. 

  2228.     { &hf_ipv6_6to4_gateway_ipv4,
    2229. 

  2229.       { "6to4 Gateway IPv4",    "ipv6.6to4_gw_ipv4",
    2230. 

  2230.                                 FT_IPv4, BASE_NONE, NULL, 0x0,
    2231. 

  2231.                                 "IPv6 6to4 Gateway IPv4 Address", HFILL }},
    2232. 

  2232.     { &hf_ipv6_6to4_sla_id,
    2233. 

  2233.       { "6to4 SLA ID",          "ipv6.6to4_sla_id",
    2234. 

  2234.                                 FT_UINT16, BASE_DEC, NULL, 0x0,
    2235. 

  2235.                                 "IPv6 6to4 SLA ID", HFILL }},
    2236. 

  2236.     { &hf_ipv6_teredo_server_ipv4,
    2237. 

  2237.       { "Teredo Server IPv4",   "ipv6.ts_ipv4",
    2238. 

  2238.                                 FT_IPv4, BASE_NONE, NULL, 0x0,
    2239. 

  2239.                                 "IPv6 Teredo Server Encapsulated IPv4 Address", HFILL }},
    2240. 

  2240.     { &hf_ipv6_teredo_port,
    2241. 

  2241.       { "Teredo Port",          "ipv6.tc_port",
    2242. 

  2242.                                 FT_UINT16, BASE_DEC, NULL, 0x0,
    2243. 

  2243.                                 "IPv6 Teredo Client Mapped Port", HFILL }},
    2244. 

  2244.     { &hf_ipv6_teredo_client_ipv4,
    2245. 

  2245.       { "Teredo Client IPv4",   "ipv6.tc_ipv4",
    2246. 

  2246.                                 FT_IPv4, BASE_NONE, NULL, 0x0,
    2247. 

  2247.                                 "IPv6 Teredo Client Encapsulated IPv4 Address", HFILL }},
    2248. 

  2248. #ifdef HAVE_GEOIP_V6
    2249. 

  2249.     { &hf_geoip_country,
    2250. 

  2250.       { "Source or Destination GeoIP Country", "ipv6.geoip.country",
    2251. 

  2251.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2252. 

  2252.                                 NULL, HFILL }},
    2253. 

  2253.     { &hf_geoip_city,
    2254. 

  2254.       { "Source or Destination GeoIP City", "ipv6.geoip.city",
    2255. 

  2255.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2256. 

  2256.                                 NULL, HFILL }},
    2257. 

  2257.     { &hf_geoip_org,
    2258. 

  2258.       { "Source or Destination GeoIP Organization", "ipv6.geoip.org",
    2259. 

  2259.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2260. 

  2260.                                 NULL, HFILL }},
    2261. 

  2261.     { &hf_geoip_isp,
    2262. 

  2262.       { "Source or Destination GeoIP ISP", "ipv6.geoip.isp",
    2263. 

  2263.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2264. 

  2264.                                 NULL, HFILL }},
    2265. 

  2265.     { &hf_geoip_asnum,
    2266. 

  2266.       { "Source or Destination GeoIP AS Number", "ipv6.geoip.asnum",
    2267. 

  2267.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2268. 

  2268.                                 NULL, HFILL }},
    2269. 

  2269.     { &hf_geoip_lat,
    2270. 

  2270.       { "Source or Destination GeoIP Latitude", "ipv6.geoip.lat",
    2271. 

  2271.                                 FT_DOUBLE, BASE_NONE, NULL, 0x0,
    2272. 

  2272.                                 NULL, HFILL }},
    2273. 

  2273.     { &hf_geoip_lon,
    2274. 

  2274.       { "Source or Destination GeoIP Longitude", "ipv6.geoip.lon",
    2275. 

  2275.                                 FT_DOUBLE, BASE_NONE, NULL, 0x0,
    2276. 

  2276.                                 NULL, HFILL }},
    2277. 

  2277.     { &hf_geoip_src_country,
    2278. 

  2278.       { "Source GeoIP Country", "ipv6.geoip.src_country",
    2279. 

  2279.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2280. 

  2280.                                 NULL, HFILL }},
    2281. 

  2281.     { &hf_geoip_src_city,
    2282. 

  2282.       { "Source GeoIP City", "ipv6.geoip.src_city",
    2283. 

  2283.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2284. 

  2284.                                 NULL, HFILL }},
    2285. 

  2285.     { &hf_geoip_src_org,
    2286. 

  2286.       { "Source GeoIP Organization", "ipv6.geoip.src_org",
    2287. 

  2287.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2288. 

  2288.                                 NULL, HFILL }},
    2289. 

  2289.     { &hf_geoip_src_isp,
    2290. 

  2290.       { "Source GeoIP ISP", "ipv6.geoip.src_isp",
    2291. 

  2291.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2292. 

  2292.                                 NULL, HFILL }},
    2293. 

  2293.     { &hf_geoip_src_asnum,
    2294. 

  2294.       { "Source GeoIP AS Number", "ipv6.geoip.src_asnum",
    2295. 

  2295.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2296. 

  2296.                                 NULL, HFILL }},
    2297. 

  2297.     { &hf_geoip_src_lat,
    2298. 

  2298.       { "Source GeoIP Latitude", "ipv6.geoip.src_lat",
    2299. 

  2299.                                 FT_DOUBLE, BASE_NONE, NULL, 0x0,
    2300. 

  2300.                                 NULL, HFILL }},
    2301. 

  2301.     { &hf_geoip_src_lon,
    2302. 

  2302.       { "Source GeoIP Longitude", "ipv6.geoip.src_lon",
    2303. 

  2303.                                 FT_DOUBLE, BASE_NONE, NULL, 0x0,
    2304. 

  2304.                                 NULL, HFILL }},
    2305. 

  2305.     { &hf_geoip_dst_country,
    2306. 

  2306.       { "Destination GeoIP Country", "ipv6.geoip.dst_country",
    2307. 

  2307.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2308. 

  2308.                                 NULL, HFILL }},
    2309. 

  2309.     { &hf_geoip_dst_city,
    2310. 

  2310.       { "Destination GeoIP City", "ipv6.geoip.dst_city",
    2311. 

  2311.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2312. 

  2312.                                 NULL, HFILL }},
    2313. 

  2313.     { &hf_geoip_dst_org,
    2314. 

  2314.       { "Destination GeoIP Organization", "ipv6.geoip.dst_org",
    2315. 

  2315.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2316. 

  2316.                                 NULL, HFILL }},
    2317. 

  2317.     { &hf_geoip_dst_isp,
    2318. 

  2318.       { "Destination GeoIP ISP", "ipv6.geoip.dst_isp",
    2319. 

  2319.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2320. 

  2320.                                 NULL, HFILL }},
    2321. 

  2321.     { &hf_geoip_dst_asnum,
    2322. 

  2322.       { "Destination GeoIP AS Number", "ipv6.geoip.dst_asnum",
    2323. 

  2323.                                 FT_STRING, BASE_NONE, NULL, 0x0,
    2324. 

  2324.                                 NULL, HFILL }},
    2325. 

  2325.     { &hf_geoip_dst_lat,
    2326. 

  2326.       { "Destination GeoIP Latitude", "ipv6.geoip.dst_lat",
    2327. 

  2327.                                 FT_DOUBLE, BASE_NONE, NULL, 0x0,
    2328. 

  2328.                                 NULL, HFILL }},
    2329. 

  2329.     { &hf_geoip_dst_lon,
    2330. 

  2330.       { "Destination GeoIP Longitude", "ipv6.geoip.dst_lon",
    2331. 

  2331.                                 FT_DOUBLE, BASE_NONE, NULL, 0x0,
    2332. 

  2332.                                 NULL, HFILL }},
    2333. 

  2333. #endif /* HAVE_GEOIP_V6 */
    2334. 

  2334. 

  2335. 

  2336.     { &hf_ipv6_dst_opt,
    2337. 

  2337.       { "Destination Option",   "ipv6.dst_opt",
    2338. 

  2338.                                 FT_NONE, BASE_NONE, NULL, 0x0,
    2339. 

  2339.                                 NULL, HFILL }},
    2340. 

  2340.     { &hf_ipv6_hop_opt,
    2341. 

  2341.       { "Hop-by-Hop Option",    "ipv6.hop_opt",
    2342. 

  2342.                                 FT_NONE, BASE_NONE, NULL, 0x0,
    2343. 

  2343.                                 NULL, HFILL }},
    2344. 

  2344.     { &hf_ipv6_unk_hdr,
    2345. 

  2345.       { "Unknown Extension Header",     "ipv6.unknown_hdr",
    2346. 

  2346.                                 FT_NONE, BASE_NONE, NULL, 0x0,
    2347. 

  2347.                                 NULL, HFILL }},
    2348. 

  2348.     { &hf_ipv6_opt,
    2349. 

  2349.       { "IPv6 Option",          "ipv6.opt",
    2350. 

  2350.                                   FT_NONE, BASE_NONE, NULL, 0x0,
    2351. 

  2351.                                   "Option", HFILL }},
    2352. 

  2352.     { &hf_ipv6_opt_type,
    2353. 

  2353.       { "Type",                   "ipv6.opt.type",
    2354. 

  2354.                                   FT_UINT8, BASE_DEC, VALS(ipv6_opt_vals), 0x0,
    2355. 

  2355.                                   "Options type", HFILL }},
    2356. 

  2356.     { &hf_ipv6_opt_length,
    2357. 

  2357.       { "Length",                 "ipv6.opt.length",
    2358. 

  2358.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2359. 

  2359.                                 "Length in units of 8 octets", HFILL }},
    2360. 

  2360.     { &hf_ipv6_opt_pad1,
    2361. 

  2361.       { "Pad1",                 "ipv6.opt.pad1",
    2362. 

  2362.                                 FT_NONE, BASE_NONE, NULL, 0x0,
    2363. 

  2363.                                 "Pad1 Option", HFILL }},
    2364. 

  2364.     { &hf_ipv6_opt_padn,
    2365. 

  2365.       { "PadN",                 "ipv6.opt.padn",
    2366. 

  2366.                                 FT_BYTES, BASE_NONE, NULL, 0x0,
    2367. 

  2367.                                 "PadN Option", HFILL }},
    2368. 

  2368.     { &hf_ipv6_opt_rtalert,
    2369. 

  2369.       { "Router Alert",         "ipv6.opt.router_alert",
    2370. 

  2370.                                 FT_UINT16, BASE_DEC, VALS(rtalertvals), 0x0,
    2371. 

  2371.                                 NULL, HFILL }},
    2372. 

  2372.     { &hf_ipv6_opt_tel,
    2373. 

  2373.       { "Tunnel Encapsulation Limit", "ipv6.opt.tel",
    2374. 

  2374.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2375. 

  2375.                                 "How many further levels of encapsulation are permitted", HFILL }},
    2376. 

  2376.     { &hf_ipv6_opt_jumbo,
    2377. 

  2377.       { "Jumbo",                "ipv6.opt.jumbo",
    2378. 

  2378.                                 FT_UINT32, BASE_DEC, NULL, 0x0,
    2379. 

  2379.                                 "Length of the IPv6 packet in octets", HFILL }},
    2380. 

  2380.     { &hf_ipv6_opt_calipso_doi,
    2381. 

  2381.       { "CALIPSO Domain of Interpretation","ipv6.opt.calipso.doi",
    2382. 

  2382.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2383. 

  2383.                                 NULL, HFILL }},
    2384. 

  2384.     { &hf_ipv6_opt_calipso_cmpt_length,
    2385. 

  2385.       { "Compartment Length","ipv6.opt.calipso.cmpt.length",
    2386. 

  2386.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2387. 

  2387.                                 NULL, HFILL }},
    2388. 

  2388.     { &hf_ipv6_opt_calipso_sens_level,
    2389. 

  2389.       { "Sensitivity Level","ipv6.opt.calipso.sens_level",
    2390. 

  2390.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2391. 

  2391.                                 NULL, HFILL }},
    2392. 

  2392.     { &hf_ipv6_opt_calipso_checksum,
    2393. 

  2393.       { "Checksum","ipv6.opt.calipso.checksum",
    2394. 

  2394.                                 FT_UINT16, BASE_HEX, NULL, 0x0,
    2395. 

  2395.                                 NULL, HFILL }},
    2396. 

  2396.     { &hf_ipv6_opt_calipso_cmpt_bitmap,
    2397. 

  2397.       { "Compartment Bitmap","ipv6.opt.calipso.cmpt_bitmap",
    2398. 

  2398.                                 FT_BYTES, BASE_NONE, NULL, 0x0,
    2399. 

  2399.                                 NULL, HFILL }},
    2400. 

  2400.     { &hf_ipv6_opt_qs_func,
    2401. 

  2401.       { "Function",             "ipv6.opt.qs_func",
    2402. 

  2402.                                 FT_UINT8, BASE_DEC, VALS(qs_func_vals), QS_FUNC_MASK,
    2403. 

  2403.                                 NULL, HFILL }},
    2404. 

  2404.     { &hf_ipv6_opt_qs_rate,
    2405. 

  2405.       { "Rate",                 "ipv6.opt.qs_rate",
    2406. 

  2406.                                 FT_UINT8, BASE_DEC | BASE_EXT_STRING, &qs_rate_vals_ext, QS_RATE_MASK,
    2407. 

  2407.                                 NULL, HFILL }},
    2408. 

  2408.     { &hf_ipv6_opt_qs_ttl,
    2409. 

  2409.       { "QS TTL",               "ipv6.opt.qs_ttl",
    2410. 

  2410.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2411. 

  2411.                                 NULL, HFILL }},
    2412. 

  2412.     { &hf_ipv6_opt_qs_ttl_diff,
    2413. 

  2413.       { "TTL Diff",             "ipv6.opt.qs_ttl_diff",
    2414. 

  2414.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2415. 

  2415.                                 NULL, HFILL }},
    2416. 

  2416.     { &hf_ipv6_opt_qs_unused,
    2417. 

  2417.       { "Not Used",             "ipv6.opt.qs_unused",
    2418. 

  2418.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2419. 

  2419.                                 NULL, HFILL }},
    2420. 

  2420.     { &hf_ipv6_opt_qs_nonce,
    2421. 

  2421.       { "QS Nonce",             "ipv6.opt.qs_nonce",
    2422. 

  2422.                                 FT_UINT32, BASE_HEX, NULL, 0xFFFFFFFC,
    2423. 

  2423.                                 NULL, HFILL }},
    2424. 

  2424.     { &hf_ipv6_opt_qs_reserved,
    2425. 

  2425.       { "Reserved",             "ipv6.opt.qs_reserved",
    2426. 

  2426.                                 FT_UINT32, BASE_HEX, NULL, 0x0003,
    2427. 

  2427.                                 NULL, HFILL }},
    2428. 

  2428.     { &hf_ipv6_opt_rpl_flag,
    2429. 

  2429.       { "Flag",                 "ipv6.opt.rpl.flag",
    2430. 

  2430.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2431. 

  2431.                                 NULL, HFILL }},
    2432. 

  2432.     { &hf_ipv6_opt_rpl_flag_o,
    2433. 

  2433.       { "Down",                 "ipv6.opt.rpl.flag.o",
    2434. 

  2434.                                 FT_BOOLEAN, 8, NULL, 0x80,
    2435. 

  2435.                                 "The packet is expected to progress Up or Down", HFILL }},
    2436. 

  2436.     { &hf_ipv6_opt_rpl_flag_r,
    2437. 

  2437.       { "Rank Error",           "ipv6.opt.rpl.flag.r",
    2438. 

  2438.                                 FT_BOOLEAN, 8, NULL, 0x40,
    2439. 

  2439.                                 "Indicating whether a rank error was detected", HFILL }},
    2440. 

  2440.     { &hf_ipv6_opt_rpl_flag_f,
    2441. 

  2441.       { "Forwarding Error",     "ipv6.opt.rpl.flag.f",
    2442. 

  2442.                                 FT_BOOLEAN, 8, NULL, 0x20,
    2443. 

  2443.                                 "Indicating that this node can not forward the packet further towards the destination", HFILL }},
    2444. 

  2444.     { &hf_ipv6_opt_rpl_flag_rsv,
    2445. 

  2445.       { "Reserved",     "ipv6.opt.rpl.flag.rsv",
    2446. 

  2446.                                 FT_UINT8, BASE_HEX, NULL, 0x1F,
    2447. 

  2447.                                 "Reserved (Must Be Zero)", HFILL }},
    2448. 

  2448.     { &hf_ipv6_opt_rpl_instance_id,
    2449. 

  2449.       { "RPLInstanceID",        "ipv6.opt.rpl.instance_id",
    2450. 

  2450.                                 FT_UINT8, BASE_HEX, NULL, 0x0,
    2451. 

  2451.                                 "Indicating the DODAG instance along which the packet is sent", HFILL }},
    2452. 

  2452.     { &hf_ipv6_opt_rpl_senderrank,
    2453. 

  2453.       { "Sender Rank",          "ipv6.opt.rpl.sender_rank",
    2454. 

  2454.                                 FT_UINT16, BASE_HEX, NULL, 0x0,
    2455. 

  2455.                                 "Set to zero by the source and to DAGRank(rank) by a router that forwards inside the RPL network", HFILL }},
    2456. 

  2456.     { &hf_ipv6_opt_experimental,
    2457. 

  2457.       { "Experimental Option","ipv6.opt.experimental",
    2458. 

  2458.                                 FT_BYTES, BASE_NONE, NULL, 0x0,
    2459. 

  2459.                                 NULL, HFILL }},
    2460. 

  2460.     { &hf_ipv6_opt_unknown,
    2461. 

  2461.       { "Unknown Option Payload","ipv6.opt.unknown",
    2462. 

  2462.                                 FT_BYTES, BASE_NONE, NULL, 0x0,
    2463. 

  2463.                                 NULL, HFILL }},
    2464. 

  2464.     { &hf_ipv6_routing_hdr_opt,
    2465. 

  2465.       { "Routing Header, Type","ipv6.routing_hdr",
    2466. 

  2466.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2467. 

  2467.                                 "Routing Header Option", HFILL }},
    2468. 

  2468.     { &hf_ipv6_routing_hdr_type,
    2469. 

  2469.       { "Type",                 "ipv6.routing_hdr.type",
    2470. 

  2470.                                 FT_UINT8, BASE_DEC, VALS(routing_header_type), 0x0,
    2471. 

  2471.                                 "Routing Header Type", HFILL }},
    2472. 

  2472.     { &hf_ipv6_routing_hdr_left,
    2473. 

  2473.       { "Segments Left",        "ipv6.routing_hdr.left",
    2474. 

  2474.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2475. 

  2475.                                 "Routing Header Segments Left", HFILL }},
    2476. 

  2476.     { &hf_ipv6_routing_hdr_addr,
    2477. 

  2477.       { "Address",              "ipv6.routing_hdr.addr",
    2478. 

  2478.                                 FT_IPv6, BASE_NONE, NULL, 0x0,
    2479. 

  2479.                                 "Routing Header Address", HFILL }},
    2480. 

  2480.     { &hf_ipv6_frag_nxt,
    2481. 

  2481.       { "Next header", "ipv6.fragment.nxt",
    2482. 

  2482.                                 FT_UINT16, BASE_DEC | BASE_EXT_STRING, &ipproto_val_ext, 0x0,
    2483. 

  2483.                                 "Fragment next header", HFILL }},
    2484. 

  2484.     { &hf_ipv6_frag_reserved,
    2485. 

  2485.       { "Reserved octet", "ipv6.fragment.reserved_octet",
    2486. 

  2486.                                 FT_UINT16, BASE_HEX, NULL, 0x0,
    2487. 

  2487.                                 "Should always be 0", HFILL }},
    2488. 

  2488.     { &hf_ipv6_frag_offset,
    2489. 

  2489.       { "Offset",               "ipv6.fragment.offset",
    2490. 

  2490.                                 FT_UINT16, BASE_DEC_HEX, NULL, IP6F_OFF_MASK,
    2491. 

  2491.                                 "Fragment Offset", HFILL }},
    2492. 

  2492.     { &hf_ipv6_frag_reserved_bits,
    2493. 

  2493.       { "Reserved bits",        "ipv6.fragment.reserved_bits",
    2494. 

  2494.                                 FT_UINT16, BASE_DEC_HEX, NULL, IP6F_RESERVED_MASK,
    2495. 

  2495.                                 NULL, HFILL }},
    2496. 

  2496.     { &hf_ipv6_frag_more,
    2497. 

  2497.       { "More Fragment",        "ipv6.fragment.more",
    2498. 

  2498.                                 FT_BOOLEAN, 16, TFS(&tfs_yes_no), IP6F_MORE_FRAG,
    2499. 

  2499.                                 "More Fragments", HFILL }},
    2500. 

  2500.     { &hf_ipv6_frag_id,
    2501. 

  2501.       { "Identification",        "ipv6.fragment.id",
    2502. 

  2502.                                 FT_UINT32, BASE_HEX, NULL, 0x0,
    2503. 

  2503.                                 "Fragment Identification", HFILL }},
    2504. 

  2504.     { &hf_ipv6_fragment_overlap,
    2505. 

  2505.       { "Fragment overlap",     "ipv6.fragment.overlap",
    2506. 

  2506.                                 FT_BOOLEAN, BASE_NONE, NULL, 0x0,
    2507. 

  2507.                                 "Fragment overlaps with other fragments", HFILL }},
    2508. 

  2508. 

  2509.     { &hf_ipv6_fragment_overlap_conflict,
    2510. 

  2510.       { "Conflicting data in fragment overlap", "ipv6.fragment.overlap.conflict",
    2511. 

  2511.                                 FT_BOOLEAN, BASE_NONE, NULL, 0x0,
    2512. 

  2512.                                 "Overlapping fragments contained conflicting data", HFILL }},
    2513. 

  2513. 

  2514.     { &hf_ipv6_fragment_multiple_tails,
    2515. 

  2515.       { "Multiple tail fragments found", "ipv6.fragment.multipletails",
    2516. 

  2516.                                 FT_BOOLEAN, BASE_NONE, NULL, 0x0,
    2517. 

  2517.                                 "Several tails were found when defragmenting the packet", HFILL }},
    2518. 

  2518. 

  2519.     { &hf_ipv6_fragment_too_long_fragment,
    2520. 

  2520.       { "Fragment too long",    "ipv6.fragment.toolongfragment",
    2521. 

  2521.                                 FT_BOOLEAN, BASE_NONE, NULL, 0x0,
    2522. 

  2522.                                 "Fragment contained data past end of packet", HFILL }},
    2523. 

  2523. 

  2524.     { &hf_ipv6_fragment_error,
    2525. 

  2525.       { "Defragmentation error", "ipv6.fragment.error",
    2526. 

  2526.                                 FT_FRAMENUM, BASE_NONE, NULL, 0x0,
    2527. 

  2527.                                 "Defragmentation error due to illegal fragments", HFILL }},
    2528. 

  2528. 

  2529.     { &hf_ipv6_fragment_count,
    2530. 

  2530.       { "Fragment count",       "ipv6.fragment.count",
    2531. 

  2531.                                 FT_UINT32, BASE_DEC, NULL, 0x0,
    2532. 

  2532.                                 NULL, HFILL }},
    2533. 

  2533. 

  2534.     { &hf_ipv6_fragment,
    2535. 

  2535.       { "IPv6 Fragment",        "ipv6.fragment",
    2536. 

  2536.                                 FT_FRAMENUM, BASE_NONE, NULL, 0x0,
    2537. 

  2537.                                 NULL, HFILL }},
    2538. 

  2538. 

  2539.     { &hf_ipv6_fragments,
    2540. 

  2540.       { "IPv6 Fragments",       "ipv6.fragments",
    2541. 

  2541.                                 FT_NONE, BASE_NONE, NULL, 0x0,
    2542. 

  2542.                                 NULL, HFILL }},
    2543. 

  2543. 

  2544.     { &hf_ipv6_reassembled_in,
    2545. 

  2545.       { "Reassembled IPv6 in frame", "ipv6.reassembled_in",
    2546. 

  2546.                                 FT_FRAMENUM, BASE_NONE, NULL, 0x0,
    2547. 

  2547.                                 "This IPv6 packet is reassembled in this frame", HFILL }},
    2548. 

  2548. 

  2549.     { &hf_ipv6_reassembled_length,
    2550. 

  2550.       { "Reassembled IPv6 length", "ipv6.reassembled.length",
    2551. 

  2551.                                 FT_UINT32, BASE_DEC, NULL, 0x0,
    2552. 

  2552.                                 "The total length of the reassembled payload", HFILL }},
    2553. 

  2553. 

  2554.     { &hf_ipv6_reassembled_data,
    2555. 

  2555.       { "Reassembled IPv6 data", "ipv6.reassembled.data",
    2556. 

  2556.                                 FT_BYTES, BASE_NONE, NULL, 0x0,
    2557. 

  2557.                                 "The reassembled payload", HFILL }},
    2558. 

  2558.     /* RPL Routing Header */
    2559. 

  2559.     { &hf_ipv6_routing_hdr_rpl_cmprI,
    2560. 

  2560.       { "Compressed Internal Octets (CmprI)", "ipv6.routing_hdr.rpl.cmprI",
    2561. 

  2561.         FT_UINT32, BASE_DEC, NULL, IP6RRPL_BITMASK_CMPRI,
    2562. 

  2562.         "Elided octets from all but last segment", HFILL }},
    2563. 

  2563. 

  2564.     { &hf_ipv6_routing_hdr_rpl_cmprE,
    2565. 

  2565.       { "Compressed Final Octets (CmprE)", "ipv6.routing_hdr.rpl.cmprE",
    2566. 

  2566.         FT_UINT32, BASE_DEC, NULL, IP6RRPL_BITMASK_CMPRE,
    2567. 

  2567.         "Elided octets from last segment address", HFILL }},
    2568. 

  2568. 

  2569.     { &hf_ipv6_routing_hdr_rpl_pad,
    2570. 

  2570.       { "Padding Bytes", "ipv6.routing_hdr.rpl.pad",
    2571. 

  2571.         FT_UINT32, BASE_DEC, NULL, IP6RRPL_BITMASK_PAD,
    2572. 

  2572.         NULL, HFILL }},
    2573. 

  2573. 

  2574.     { &hf_ipv6_routing_hdr_rpl_reserved,
    2575. 

  2575.       { "Reserved", "ipv6.routing_hdr.rpl.reserved",
    2576. 

  2576.         FT_UINT32, BASE_DEC, NULL, IP6RRPL_BITMASK_RESERVED,
    2577. 

  2577.         "Must be Zero", HFILL }},
    2578. 

  2578. 

  2579.     { &hf_ipv6_routing_hdr_rpl_segments,
    2580. 

  2580.       { "Total Segments", "ipv6.routing_hdr.rpl.segments",
    2581. 

  2581.         FT_INT32, BASE_DEC, NULL, 0,
    2582. 

  2582.         NULL, HFILL }},
    2583. 

  2583. 

  2584.     { &hf_ipv6_routing_hdr_rpl_addr,
    2585. 

  2585.       { "Address", "ipv6.routing_hdr.rpl.address",
    2586. 

  2586.         FT_BYTES, BASE_NONE, NULL, 0,
    2587. 

  2587.         NULL, HFILL }},
    2588. 

  2588. 

  2589.     { &hf_ipv6_routing_hdr_rpl_fulladdr,
    2590. 

  2590.       { "Full Address", "ipv6.routing_hdr.rpl.full_address",
    2591. 

  2591.         FT_IPv6, BASE_NONE, NULL, 0,
    2592. 

  2592.         "Uncompressed IPv6 Address", HFILL }},
    2593. 

  2593. 

  2594.     /* Mobile IPv6 */
    2595. 

  2595.     { &hf_ipv6_mipv6_home_address,
    2596. 

  2596.       { "Home Address", "ipv6.mipv6_home_address",
    2597. 

  2597.                                 FT_IPv6, BASE_NONE, NULL, 0x0,
    2598. 

  2598.                                 NULL, HFILL }},
    2599. 

  2599. 

  2600.     /* SHIM6 */
    2601. 

  2601.     { &hf_ipv6_shim6,
    2602. 

  2602.       { "SHIM6",                "ipv6.shim6",
    2603. 

  2603.                                 FT_NONE, BASE_NONE, NULL, 0x0,
    2604. 

  2604.                                 NULL, HFILL }},
    2605. 

  2605. 

  2606.     { &hf_ipv6_shim6_nxt,
    2607. 

  2607.       { "Next Header",          "ipv6.shim6.nxt",
    2608. 

  2608.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2609. 

  2609.                                 NULL, HFILL }},
    2610. 

  2610. 

  2611.     { &hf_ipv6_shim6_len,
    2612. 

  2612.       { "Header Ext Length",    "ipv6.shim6.len",
    2613. 

  2613.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2614. 

  2614.                                 NULL, HFILL }},
    2615. 

  2615. 

  2616.     { &hf_ipv6_shim6_p,
    2617. 

  2617.       { "P Bit",                "ipv6.shim6.p",
    2618. 

  2618.                                 FT_BOOLEAN, 8, NULL, SHIM6_BITMASK_P,
    2619. 

  2619.                                 NULL, HFILL }},
    2620. 

  2620. 

  2621.     { &hf_ipv6_shim6_ct,
    2622. 

  2622.       { "Context Tag",          "ipv6.shim6.ct",
    2623. 

  2623.                                 FT_NONE, BASE_NONE, NULL, 0x0,
    2624. 

  2624.                                 NULL, HFILL }},
    2625. 

  2625. 

  2626.     { &hf_ipv6_shim6_type,
    2627. 

  2627.       { "Message Type",         "ipv6.shim6.type",
    2628. 

  2628.                                 FT_UINT8, BASE_DEC,
    2629. 

  2629.                                 VALS(shimctrlvals), SHIM6_BITMASK_TYPE,
    2630. 

  2630.                                 NULL, HFILL }},
    2631. 

  2631. 

  2632.     { &hf_ipv6_shim6_proto,
    2633. 

  2633.       { "Protocol",             "ipv6.shim6.proto",
    2634. 

  2634.                                 FT_UINT8, BASE_DEC,
    2635. 

  2635.                                 VALS(shim6_protocol), SHIM6_BITMASK_PROTOCOL,
    2636. 

  2636.                                 NULL, HFILL }},
    2637. 

  2637. 

  2638.     { &hf_ipv6_shim6_checksum,
    2639. 

  2639.       { "Checksum",             "ipv6.shim6.checksum",
    2640. 

  2640.                                 FT_UINT16, BASE_HEX, NULL, 0x0,
    2641. 

  2641.                                 "Shim6 Checksum", HFILL }},
    2642. 

  2642.     { &hf_ipv6_shim6_checksum_bad,
    2643. 

  2643.       { "Bad Checksum",         "ipv6.shim6.checksum_bad",
    2644. 

  2644.                                 FT_BOOLEAN, BASE_NONE, NULL, 0x0,
    2645. 

  2645.                                 "Shim6 Bad Checksum", HFILL }},
    2646. 

  2646. 

  2647.     { &hf_ipv6_shim6_checksum_good,
    2648. 

  2648.       { "Good Checksum",        "ipv6.shim6.checksum_good",
    2649. 

  2649.                                 FT_BOOLEAN, BASE_NONE, NULL, 0x0,
    2650. 

  2650.                                 NULL, HFILL }},
    2651. 

  2651. 

  2652.     { &hf_ipv6_shim6_inonce,
    2653. 

  2653.       { "Initiator Nonce",      "ipv6.shim6.inonce",
    2654. 

  2654.                                 FT_UINT32, BASE_DEC_HEX, NULL, 0x0,
    2655. 

  2655.                                 NULL, HFILL }},
    2656. 

  2656. 

  2657.     { &hf_ipv6_shim6_rnonce,
    2658. 

  2658.       { "Responder Nonce",      "ipv6.shim6.rnonce",
    2659. 

  2659.                                 FT_UINT32, BASE_DEC_HEX, NULL, 0x0,
    2660. 

  2660.                                 NULL, HFILL }},
    2661. 

  2661. 

  2662.     { &hf_ipv6_shim6_precvd,
    2663. 

  2663.       { "Probes Received",      "ipv6.shim6.precvd",
    2664. 

  2664.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2665. 

  2665.                                 NULL, HFILL }},
    2666. 

  2666. 

  2667.     { &hf_ipv6_shim6_psent,
    2668. 

  2668.       { "Probes Sent",          "ipv6.shim6.psent",
    2669. 

  2669.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2670. 

  2670.                                 NULL, HFILL }},
    2671. 

  2671. 

  2672.     { &hf_ipv6_shim6_psrc,
    2673. 

  2673.       { "Source Address",       "ipv6.shim6.psrc",
    2674. 

  2674.                                 FT_IPv6, BASE_NONE, NULL, 0x0,
    2675. 

  2675.                                 "Shim6 Probe Source Address", HFILL }},
    2676. 

  2676. 

  2677.     { &hf_ipv6_shim6_pdst,
    2678. 

  2678.       { "Destination Address",  "ipv6.shim6.pdst",
    2679. 

  2679.                                 FT_IPv6, BASE_NONE, NULL, 0x0,
    2680. 

  2680.                                 "Shim6 Probe Destination Address", HFILL }},
    2681. 

  2681. 

  2682.     { &hf_ipv6_shim6_pnonce,
    2683. 

  2683.       { "Nonce",                "ipv6.shim6.pnonce",
    2684. 

  2684.                                 FT_UINT32, BASE_DEC_HEX, NULL, 0x0,
    2685. 

  2685.                                 "Shim6 Probe Nonce", HFILL }},
    2686. 

  2686. 

  2687.     { &hf_ipv6_shim6_pdata,
    2688. 

  2688.       { "Data",                 "ipv6.shim6.pdata",
    2689. 

  2689.                                 FT_UINT32, BASE_HEX, NULL, 0x0,
    2690. 

  2690.                                 "Shim6 Probe Data", HFILL }},
    2691. 

  2691. 

  2692.     { &hf_ipv6_shim6_sulid,
    2693. 

  2693.       { "Sender ULID",          "ipv6.shim6.sulid",
    2694. 

  2694.                                 FT_IPv6, BASE_NONE, NULL, 0x0,
    2695. 

  2695.                                 "Shim6 Sender ULID", HFILL }},
    2696. 

  2696. 

  2697.     { &hf_ipv6_shim6_rulid,
    2698. 

  2698.       { "Receiver ULID",        "ipv6.shim6.rulid",
    2699. 

  2699.                                 FT_IPv6, BASE_NONE, NULL, 0x0,
    2700. 

  2700.                                 "Shim6 Receiver ULID", HFILL }},
    2701. 

  2701. 

  2702.     { &hf_ipv6_shim6_reap,
    2703. 

  2703.       { "REAP State",           "ipv6.shim6.reap",
    2704. 

  2704.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2705. 

  2705.                                 NULL, HFILL }},
    2706. 

  2706. 

  2707.     { &hf_ipv6_shim6_opt_type,
    2708. 

  2708.       { "Option Type",          "ipv6.shim6.opt.type",
    2709. 

  2709.                                 FT_UINT16, BASE_DEC,
    2710. 

  2710.                                 VALS(shimoptvals), SHIM6_BITMASK_OPT_TYPE,
    2711. 

  2711.                                 "Shim6 Option Type", HFILL }},
    2712. 

  2712. 

  2713.     { &hf_ipv6_shim6_opt_critical,
    2714. 

  2714.       { "Option Critical Bit",  "ipv6.shim6.opt.critical",
    2715. 

  2715.                                 FT_BOOLEAN, 8,
    2716. 

  2716.                                 TFS(&tfs_yes_no),
    2717. 

  2717.                                 SHIM6_BITMASK_CRITICAL,
    2718. 

  2718.                                 "TRUE : option is critical, FALSE: option is not critical",
    2719. 

  2719.                                 HFILL }},
    2720. 

  2720. 

  2721.     { &hf_ipv6_shim6_opt_len,
    2722. 

  2722.       { "Content Length",       "ipv6.shim6.opt.len",
    2723. 

  2723.                                 FT_UINT16, BASE_DEC, NULL, 0x0,
    2724. 

  2724.                                 "Content Length Option", HFILL }},
    2725. 

  2725. 

  2726.     { &hf_ipv6_shim6_opt_total_len,
    2727. 

  2727.       { "Total Length",         "ipv6.shim6.opt.total_len",
    2728. 

  2728.                                 FT_UINT16, BASE_DEC, NULL, 0x0,
    2729. 

  2729.                                 "Total Option Length", HFILL }},
    2730. 

  2730. 

  2731.     { &hf_ipv6_shim6_opt_loc_verif_methods,
    2732. 

  2732.       { "Verification Method",  "ipv6.shim6.opt.verif_method",
    2733. 

  2733.                                 FT_UINT8, BASE_DEC,
    2734. 

  2734.                                 VALS(shimverifmethods), 0x0,
    2735. 

  2735.                                 "Locator Verification Method", HFILL }},
    2736. 

  2736. 

  2737.     { &hf_ipv6_shim6_opt_loclist,
    2738. 

  2738.       { "Locator List Generation", "ipv6.shim6.opt.loclist",
    2739. 

  2739.                                 FT_UINT32, BASE_DEC_HEX, NULL, 0x0,
    2740. 

  2740.                                 NULL, HFILL }},
    2741. 

  2741. 

  2742.     { &hf_ipv6_shim6_locator,
    2743. 

  2743.       { "Locator",              "ipv6.shim6.locator",
    2744. 

  2744.                                 FT_IPv6, BASE_NONE, NULL, 0x0,
    2745. 

  2745.                                 "Shim6 Locator", HFILL }},
    2746. 

  2746. 

  2747.     { &hf_ipv6_shim6_opt_locnum,
    2748. 

  2748.       { "Num Locators",         "ipv6.shim6.opt.locnum",
    2749. 

  2749.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2750. 

  2750.                                 "Number of Locators in Locator List", HFILL }},
    2751. 

  2751. 

  2752.     { &hf_ipv6_shim6_opt_elemlen,
    2753. 

  2753.       { "Element Length",       "ipv6.shim6.opt.elemlen",
    2754. 

  2754.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2755. 

  2755.                                 "Length of Elements in Locator Preferences Option", HFILL }},
    2756. 

  2756.     { &hf_ipv6_shim6_loc_flag,
    2757. 

  2757.       { "Flags",                "ipv6.shim6.loc.flags",
    2758. 

  2758.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2759. 

  2759.                                 "Locator Preferences Flags", HFILL }},
    2760. 

  2760. 

  2761.     { &hf_ipv6_shim6_loc_prio,
    2762. 

  2762.       { "Priority",             "ipv6.shim6.loc.prio",
    2763. 

  2763.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2764. 

  2764.                                 "Locator Preferences Priority", HFILL }},
    2765. 

  2765. 

  2766.     { &hf_ipv6_shim6_loc_weight,
    2767. 

  2767.       { "Weight",               "ipv6.shim6.loc.weight",
    2768. 

  2768.                                 FT_UINT8, BASE_DEC, NULL, 0x0,
    2769. 

  2769.                                 "Locator Preferences Weight", HFILL }},
    2770. 

  2770. 

  2771.     { &hf_ipv6_shim6_opt_fii,
    2772. 

  2772.       { "Forked Instance Identifier", "ipv6.shim6.opt.fii",
    2773. 

  2773.                                 FT_UINT32, BASE_DEC_HEX, NULL, 0x0,
    2774. 

  2774.                                 NULL, HFILL }},
    2775. 

  2775. 

  2776.     { &hf_ipv6_traffic_class_dscp,
    2777. 

  2777.       { "Differentiated Services Field", "ipv6.traffic_class.dscp",
    2778. 

  2778.                                 FT_UINT32, BASE_HEX | BASE_EXT_STRING, &dscp_vals_ext, 0x0FC00000, NULL, HFILL }},
    2779. 

  2779. 

  2780.     { &hf_ipv6_traffic_class_ect,
    2781. 

  2781.       { "ECN-Capable Transport (ECT)", "ipv6.traffic_class.ect",
    2782. 

  2782.                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x0200000, NULL, HFILL }},
    2783. 

  2783. 

  2784.     { &hf_ipv6_traffic_class_ce,
    2785. 

  2785.       { "ECN-CE",               "ipv6.traffic_class.ce",
    2786. 

  2786.                                 FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x0100000, NULL, HFILL }},
    2787. 

  2787.   };
    2788. 

  2788.   static gint *ett[] = {
    2789. 

  2789.     &ett_ipv6,
    2790. 

  2790.     &ett_ipv6_opt,
    2791. 

  2791.     &ett_ipv6_opt_flag,
    2792. 

  2792.     &ett_ipv6_version,
    2793. 

  2793.     &ett_ipv6_shim6,
    2794. 

  2794.     &ett_ipv6_shim6_option,
    2795. 

  2795.     &ett_ipv6_shim6_locators,
    2796. 

  2796.     &ett_ipv6_shim6_verif_methods,
    2797. 

  2797.     &ett_ipv6_shim6_loc_pref,
    2798. 

  2798.     &ett_ipv6_shim6_probes_sent,
    2799. 

  2799.     &ett_ipv6_shim6_probes_rcvd,
    2800. 

  2800.     &ett_ipv6_shim6_probe_sent,
    2801. 

  2801.     &ett_ipv6_shim6_probe_rcvd,
    2802. 

  2802.     &ett_ipv6_shim6_cksum,
    2803. 

  2803.     &ett_ipv6_fragments,
    2804. 

  2804.     &ett_ipv6_fragment,
    2805. 

  2805.     &ett_ipv6_traffic_class,
    2806. 

  2806. #ifdef HAVE_GEOIP_V6
    2807. 

  2807.     &ett_geoip_info
    2808. 

  2808. #endif /* HAVE_GEOIP_V6 */
    2809. 

  2809.   };
    2810. 

  2810.   static ei_register_info ei[] = {
    2811. 

  2811.      { &ei_ipv6_dst_addr_not_multicast, { "ipv6.dst_addr.not_multicast", PI_PROTOCOL, PI_WARN, "Destination address must not be a multicast address", EXPFILL }},
    2812. 

  2812.      { &ei_ipv6_src_route_list_mult_inst_same_addr, { "ipv6.src_route_list.mult_inst_same_addr", PI_PROTOCOL, PI_ERROR, "Multiple instances of the same address must not appear in the source route list", EXPFILL }},
    2813. 

  2813.      { &ei_ipv6_src_route_list_src_addr, { "ipv6.src_route_list.src_addr", PI_PROTOCOL, PI_ERROR, "Source address must not appear in the source route list", EXPFILL }},
    2814. 

  2814.      { &ei_ipv6_src_route_list_dst_addr, { "ipv6.src_route_list.dst_addr", PI_PROTOCOL, PI_ERROR, "Destination address must not appear in the source route list", EXPFILL }},
    2815. 

  2815.      { &ei_ipv6_src_route_list_multicast_addr, { "ipv6.src_route_list.multicast_addr", PI_PROTOCOL, PI_ERROR, "Multicast addresses must not appear in the source route list", EXPFILL }},
    2816. 

  2816.      { &ei_ipv6_cmpri_cmpre_pad, { "ipv6.routing_hdr.rpl.cmprI.cmprE.pad", PI_PROTOCOL, PI_WARN, "When cmprI equals 0 and cmprE equals 0, pad MUST equal 0 but instead was X", EXPFILL }},
    2817. 

  2817.      { &ei_ipv6_routing_hdr_rpl_reserved, { "ipv6.routing_hdr.rpl.reserved.not0", PI_PROTOCOL, PI_WARN, "Reserved field must equal 0 but instead was X", EXPFILL }},
    2818. 

  2818.      { &ei_ipv6_opt_tel_invalid_len, { "ipv6.opt.tel.invalid_len", PI_MALFORMED, PI_ERROR, "Tunnel Encapsulation Limit: Invalid length", EXPFILL }},
    2819. 

  2819.      { &ei_ipv6_opt_jumbo_invalid_len, { "ipv6.opt.jumbo.invalid_len", PI_MALFORMED, PI_ERROR, "Jumbo payload: Invalid length", EXPFILL }},
    2820. 

  2820.      { &ei_ipv6_opt_rtalert_invalid_len, { "ipv6.opt.router_alert.invalid_len", PI_MALFORMED, PI_ERROR, "Router alert: Invalid Length", EXPFILL }},
    2821. 

  2821.      { &ei_ipv6_mipv6_home_address_invalid_len, { "ipv6.mipv6_home_address.invalid_len", PI_MALFORMED, PI_ERROR, "Home Address: Invalid length", EXPFILL }},
    2822. 

  2822.      { &ei_ipv6_shim6_opt_elemlen_invalid, { "ipv6.shim6.opt.elemlen.invalid", PI_MALFORMED, PI_ERROR, "Invalid element length", EXPFILL }},
    2823. 

  2823.      { &ei_ipv6_shim6_checksum_bad, { "ipv6.shim6.checksum_bad.expert", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }},
    2824. 

  2824.      { &ei_ipv6_routing_hdr_rpl_segments_ge0, { "ipv6.routing_hdr.rpl.segments.ge0", PI_MALFORMED, PI_ERROR, "Calculated total segments must be greater than or equal to 0, instead was X", EXPFILL }},
    2825. 

  2825.   };
    2826. 

  2826. 

  2827.   module_t *ipv6_module;
    2828. 

  2828.   expert_module_t* expert_ipv6;
    2829. 

  2829. 

  2830.   proto_ipv6 = proto_register_protocol("Internet Protocol Version 6", "IPv6", "ipv6");
    2831. 

  2831.   proto_register_field_array(proto_ipv6, hf, array_length(hf));
    2832. 

  2832.   proto_register_subtree_array(ett, array_length(ett));
    2833. 

  2833.   expert_ipv6 = expert_register_protocol(proto_ipv6);
    2834. 

  2834.   expert_register_field_array(expert_ipv6, ei, array_length(ei));
    2835. 

  2835. 

  2836.   /* Register configuration options */
    2837. 

  2837.   ipv6_module = prefs_register_protocol(proto_ipv6, NULL);
    2838. 

  2838.   prefs_register_bool_preference(ipv6_module, "defragment",
    2839. 

  2839.         "Reassemble fragmented IPv6 datagrams",
    2840. 

  2840.         "Whether fragmented IPv6 datagrams should be reassembled",
    2841. 

  2841.         &ipv6_reassemble);
    2842. 

  2842.   prefs_register_bool_preference(ipv6_module, "summary_in_tree",
    2843. 

  2843.         "Show IPv6 summary in protocol tree",
    2844. 

  2844.         "Whether the IPv6 summary line should be shown in the protocol tree",
    2845. 

  2845.         &ipv6_summary_in_tree);
    2846. 

  2846. #ifdef HAVE_GEOIP_V6
    2847. 

  2847.         prefs_register_bool_preference(ipv6_module, "use_geoip" ,
    2848. 

  2848.                   "Enable GeoIP lookups",
    2849. 

  2849.                   "Whether to look up IPv6 addresses in each GeoIP database we have loaded",
    2850. 

  2850.                   &ipv6_use_geoip);
    2851. 

  2851. #endif /* HAVE_GEOIP_V6 */
    2852. 

  2852. 

  2853.   /* RPL Strict Header Checking */
    2854. 

  2854.   prefs_register_bool_preference(ipv6_module, "perform_strict_rpl_srh_rfc_checking",
    2855. 

  2855.         "Perform strict checking for adherence to the RFC for RPL Source Routing Headers (RFC 6554)",
    2856. 

  2856.         "Whether to check that all RPL Source Routing Headers adhere to RFC 6554",
    2857. 

  2857.         &g_ipv6_rpl_srh_strict_rfc_checking);
    2858. 

  2858. 

  2859.   register_dissector("ipv6", dissect_ipv6, proto_ipv6);
    2860. 

  2860.   register_init_routine(ipv6_reassemble_init);
    2861. 

  2861.   ipv6_tap = register_tap("ipv6");
    2862. 

  2862. }
    2863. 

  2863. 

  2864. void
    2865. 

  2865. proto_reg_handoff_ipv6(void)
    2866. 

  2866. {
    2867. 

  2867.   dissector_handle_t ipv6_handle;
    2868. 

  2868. 

  2869.   data_handle = find_dissector("data");
    2870. 

  2870.   ipv6_handle = find_dissector("ipv6");
    2871. 

  2871.   dissector_add_uint("ethertype", ETHERTYPE_IPv6, ipv6_handle);
    2872. 

  2872.   dissector_add_uint("ppp.protocol", PPP_IPV6, ipv6_handle);
    2873. 

  2873.   dissector_add_uint("ppp.protocol", ETHERTYPE_IPv6, ipv6_handle);
    2874. 

  2874.   dissector_add_uint("gre.proto", ETHERTYPE_IPv6, ipv6_handle);
    2875. 

  2875.   dissector_add_uint("ip.proto", IP_PROTO_IPV6, ipv6_handle);
    2876. 

  2876.   dissector_add_uint("null.type", BSD_AF_INET6_BSD, ipv6_handle);
    2877. 

  2877.   dissector_add_uint("null.type", BSD_AF_INET6_FREEBSD, ipv6_handle);
    2878. 

  2878.   dissector_add_uint("null.type", BSD_AF_INET6_DARWIN, ipv6_handle);
    2879. 

  2879.   dissector_add_uint("chdlctype", ETHERTYPE_IPv6, ipv6_handle);
    2880. 

  2880.   dissector_add_uint("fr.ietf", NLPID_IP6, ipv6_handle);
    2881. 

  2881.   dissector_add_uint("osinl.excl", NLPID_IP6, ipv6_handle);
    2882. 

  2882.   dissector_add_uint("x.25.spi", NLPID_IP6, ipv6_handle);
    2883. 

  2883.   dissector_add_uint("arcnet.protocol_id", ARCNET_PROTO_IPv6, ipv6_handle);
    2884. 

  2884. 

  2885.   ip_dissector_table = find_dissector_table("ip.proto");
    2886. 

  2886. }
    2887. 

  2887. 

  2888. /*
    2889. 

  2889.  * Editor modelines
    2890. 

  2890.  *
    2891. 

  2891.  * Local Variables:
    2892. 

  2892.  * c-basic-offset: 2
    2893. 

  2893.  * tab-width: 8
    2894. 

  2894.  * indent-tabs-mode: nil
    2895. 

  2895.  * End:
    2896. 

  2896.  *
    2897. 

  2897.  * ex: set shiftwidth=2 tabstop=8 expandtab:
    2898. 

  2898.  * :indentSize=2:tabSize=8:noTabs=true:
    2899. 

  2899.  */
    2900. 

  2900.