PageRenderTime 58ms CodeModel.GetById 18ms RepoModel.GetById 0ms 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

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

    

  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 (opt…
    1261.

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