epan/dissectors/packet-geneve.c

   1 /* packet-geneve.c
   2  * Routines for Geneve - Generic Network Virtualization Encapsulation
   3  * https://tools.ietf.org/html/draft-ietf-nvo3-geneve
   4  *
   5  * Copyright (c) 2024 cPacket Networks, Inc. All Rights Reserved.
   6  * Author: Martin Greenberg <mgreenberg@cpacket.com>
   7  *
   8  * Copyright (c) 2014 VMware, Inc. All Rights Reserved.
   9  * Author: Jesse Gross <jesse@nicira.com>
  10  *
  11  * Copyright 2021, Atul Sharma <asharm37@ncsu.edu>
  12  *
  13  * Wireshark - Network traffic analyzer
  14  * By Gerald Combs <gerald@wireshark.org>
  15  * Copyright 1998 Gerald Combs
  16  *
  17  * SPDX-License-Identifier: GPL-2.0-or-later
  18  */
  19
  20
  21 #include "config.h"
  22
  23 #include <epan/packet.h>
  24 #include <epan/etypes.h>
  25 #include <epan/expert.h>
  26 #include <epan/value_string.h>
  27 #include <epan/tfs.h>
  28 #include <epan/unit_strings.h>
  29
  30 #define UDP_PORT_GENEVE  6081
  31 #define GENEVE_VER 0
  32
  33 #define VER_SHIFT 6
  34 #define HDR_OPTS_LEN_MASK 0x3F
  35
  36 #define FLAG_OAM (1 << 7)
  37
  38 #define OPT_TYPE_CRITICAL (1 << 7)
  39 #define OPT_FLAGS_SHIFT 5
  40 #define OPT_LEN_MASK 0x1F
  41
  42 static const range_string class_id_names[] = {
  43     { 0, 0xFF, "Standard" },
  44     { 0x0100, 0x0100, "Linux" },
  45     { 0x0101, 0x0101, "Open vSwitch" },
  46     { 0x0102, 0x0102, "Open Virtual Networking (OVN)" },
  47     { 0x0103, 0x0103, "In-band Network Telemetry (INT)" },
  48     { 0x0104, 0x0104, "VMware" },
  49     { 0x0105, 0x0105, "Amazon.com, Inc."},
  50     { 0x0106, 0x0106, "Cisco Systems, Inc." },
  51     { 0x0107, 0x0107, "Oracle Corporation" },
  52     { 0x0108, 0x0110, "Amazon.com, Inc." },
  53     { 0x0111, 0x0118, "IBM" },
  54     { 0x0119, 0x0128, "Ericsson" },
  55     { 0x0129, 0x0129, "Oxide Computer Company" },
  56     { 0x0130, 0x0131, "Cisco Systems, Inc." },
  57     { 0x0132, 0x0135, "Google LLC" },
  58     { 0x0136, 0x0136, "InfoQuick Global Connection Tech Ltd." },
  59     { 0x0137, 0x0163, "Unssigned" },
  60     { 0x0164, 0x0164, "cPacket Networks, Inc." },
  61     { 0x0165, 0xFEFF, "Unassigned" },
  62     { 0xFFF0, 0xFFFF, "Experimental" },
  63     { 0, 0, NULL }
  64 };
  65
  66 #define GENEVE_GCP_VNID     0x013201
  67 #define GENEVE_GCP_ENDPOINT 0x013202
  68 #define GENEVE_GCP_PROFILE  0x013203
  69 #define GENEVE_CPACKET_METADATA  0x016400
  70
  71 static const val64_string option_names[] = {
  72   { GENEVE_GCP_VNID,     "GCP Virtual Network ID" },
  73   { GENEVE_GCP_ENDPOINT, "GCP Endpoint ID" },
  74   { GENEVE_GCP_PROFILE,  "GCP Profile ID" },
  75   { GENEVE_CPACKET_METADATA,  "cPacket Meta-data" },
  76   { 0, NULL }
  77 };
  78
  79 void proto_register_geneve(void);
  80 void proto_reg_handoff_geneve(void);
  81
  82 static dissector_handle_t geneve_handle;
  83
  84 static int proto_geneve;
  85
  86 static int hf_geneve_version;
  87 static int hf_geneve_flags;
  88 static int hf_geneve_flag_oam;
  89 static int hf_geneve_flag_critical;
  90 static int hf_geneve_flag_reserved;
  91 static int hf_geneve_proto_type;
  92 static int hf_geneve_vni;
  93 static int hf_geneve_reserved;
  94 static int hf_geneve_options;
  95 static int hf_geneve_option_class;
  96 static int hf_geneve_option_type;
  97 static int hf_geneve_option_type_critical;
  98 static int hf_geneve_option_flags;
  99 static int hf_geneve_option_flags_reserved;
 100 static int hf_geneve_option_length;
 101 static int hf_geneve_option;
 102 static int hf_geneve_opt_gcp_vnid;
 103 static int hf_geneve_opt_gcp_reserved;
 104 static int hf_geneve_opt_gcp_direction;
 105 static int hf_geneve_opt_gcp_endpoint;
 106 static int hf_geneve_opt_gcp_profile;
 107 static int hf_geneve_opt_cpkt_seqnum;
 108 static int hf_geneve_opt_cpkt_origlen;
 109 static int hf_geneve_opt_cpkt_reserved;
 110 static int hf_geneve_opt_cpkt_timestamp;
 111 static int hf_geneve_opt_cpkt_ts_sec;
 112 static int hf_geneve_opt_cpkt_ts_nsec;
 113 static int hf_geneve_opt_cpkt_ts_fracns;
 114 static int hf_geneve_opt_cpkt_version;
 115 static int hf_geneve_opt_cpkt_devid;
 116 static int hf_geneve_opt_cpkt_portid;
 117
 118 static int hf_geneve_opt_unknown_data;
 119
 120 static int ett_geneve;
 121 static int ett_geneve_flags;
 122 static int ett_geneve_opt_flags;
 123 static int ett_geneve_options;
 124 static int ett_geneve_opt_data;
 125
 126 static expert_field ei_geneve_ver_unknown;
 127 static expert_field ei_geneve_opt_len_invalid;
 128
 129 static dissector_table_t ethertype_dissector_table;
 130
 131 static const struct true_false_string tfs_geneve_gcp_direction = {
 132   "Egress",
 133   "Ingress"
 134 };
 135
 136 static const char *
 137 format_option_name(wmem_allocator_t *scope, uint16_t opt_class, uint8_t opt_type)
 138 {
 139     const char *name;
 140
 141     name = wmem_strdup_printf(scope,
 142                               "%s, Class: %s (0x%04x) Type: 0x%02x",
 143                               val64_to_str_const(((uint64_t)opt_class << 8) | opt_type,
 144                                                  option_names, "Unknown"),
 145                               rval_to_str_const(opt_class, class_id_names, "Unknown"),
 146                               opt_class, opt_type);
 147
 148     return name;
 149 }
 150
 151 static void
 152 dissect_option(wmem_allocator_t *scope, tvbuff_t *tvb, proto_tree *opts_tree, int offset,
 153                uint16_t opt_class, uint8_t opt_type, int len)
 154 {
 155     proto_item *opt_item, *type_item, *hidden_item, *flag_item;
 156     proto_tree *opt_tree, *flag_tree;
 157     const char *critical;
 158     uint8_t flags;
 159
 160     critical = opt_type & OPT_TYPE_CRITICAL ? "Critical" : "Non-critical";
 161
 162     opt_item = proto_tree_add_item(opts_tree, hf_geneve_option,
 163                                    tvb, offset, len, ENC_NA);
 164     proto_item_set_text(opt_item, "%s (%s)",
 165                         format_option_name(scope, opt_class, opt_type),
 166                         critical);
 167
 168     opt_tree = proto_item_add_subtree(opt_item, ett_geneve_opt_data);
 169
 170     proto_tree_add_item(opt_tree, hf_geneve_option_class, tvb,
 171                         offset, 2, ENC_BIG_ENDIAN);
 172     offset += 2;
 173
 174     type_item = proto_tree_add_item(opt_tree, hf_geneve_option_type, tvb,
 175                                     offset, 1, ENC_BIG_ENDIAN);
 176     proto_item_append_text(type_item, " (%s)", critical);
 177     hidden_item = proto_tree_add_item(opt_tree, hf_geneve_option_type_critical,
 178                                       tvb, offset, 1, ENC_BIG_ENDIAN);
 179     proto_item_set_hidden(hidden_item);
 180     offset += 1;
 181
 182     flags = tvb_get_uint8(tvb, offset) >> OPT_FLAGS_SHIFT;
 183     flag_item = proto_tree_add_uint(opt_tree, hf_geneve_option_flags, tvb,
 184                                     offset, 1, flags);
 185     flag_tree = proto_item_add_subtree(flag_item, ett_geneve_opt_flags);
 186     proto_tree_add_item(flag_tree, hf_geneve_option_flags_reserved, tvb,
 187                         offset, 1, ENC_BIG_ENDIAN);
 188     if (flags) {
 189         proto_item_append_text(flag_item, " (RSVD)");
 190     } else {
 191         proto_item_set_hidden(flag_item);
 192     }
 193
 194     proto_tree_add_uint(opt_tree, hf_geneve_option_length, tvb, offset, 1, len);
 195     offset += 1;
 196
 197     switch (((uint64_t)opt_class << 8) | opt_type) {
 198         case GENEVE_GCP_VNID:
 199             proto_tree_add_bits_item(opt_tree, hf_geneve_opt_gcp_vnid, tvb, offset * 8,
 200                                      28, ENC_BIG_ENDIAN);
 201             proto_tree_add_item(opt_tree, hf_geneve_opt_gcp_direction, tvb, offset,
 202                                 4, ENC_NA);
 203             proto_tree_add_item(opt_tree, hf_geneve_opt_gcp_reserved, tvb, offset,
 204                                 4, ENC_NA);
 205             break;
 206         case GENEVE_GCP_ENDPOINT:
 207             proto_tree_add_item(opt_tree, hf_geneve_opt_gcp_endpoint, tvb, offset,
 208                                 len - 4, ENC_NA);
 209             break;
 210         case GENEVE_GCP_PROFILE:
 211             proto_tree_add_item(opt_tree, hf_geneve_opt_gcp_profile, tvb, offset,
 212                                 len - 4, ENC_BIG_ENDIAN);
 213             break;
 214         case GENEVE_CPACKET_METADATA:
 215             proto_tree_add_item(opt_tree, hf_geneve_opt_cpkt_seqnum, tvb, offset,
 216                                 4, ENC_BIG_ENDIAN);
 217             offset += 4;
 218             proto_tree_add_item(opt_tree, hf_geneve_opt_cpkt_origlen, tvb, offset,
 219                                 2, ENC_BIG_ENDIAN);
 220             offset += 2;
 221             proto_tree_add_item(opt_tree, hf_geneve_opt_cpkt_reserved, tvb, offset,
 222                                 1, ENC_BIG_ENDIAN);
 223             offset += 1;
 224             proto_tree_add_item(opt_tree, hf_geneve_opt_cpkt_version, tvb, offset,
 225                                 1, ENC_BIG_ENDIAN);
 226             offset += 1;
 227             // PTPv2 timestamp has more resolution than NStime supports/displays,
 228             // but parse appropriate subsection of into NStime for user convenience
 229             proto_tree_add_time_item(opt_tree, hf_geneve_opt_cpkt_timestamp, tvb, offset+2, 8,
 230                                      ENC_TIME_SECS_NSECS, NULL, NULL, NULL);
 231             proto_tree_add_item(opt_tree, hf_geneve_opt_cpkt_ts_sec, tvb, offset,
 232                                 6, ENC_BIG_ENDIAN);
 233             offset += 6;
 234             proto_tree_add_item(opt_tree, hf_geneve_opt_cpkt_ts_nsec, tvb, offset,
 235                                 4, ENC_BIG_ENDIAN);
 236             offset += 4;
 237             proto_tree_add_item(opt_tree, hf_geneve_opt_cpkt_ts_fracns, tvb, offset,
 238                                 2, ENC_BIG_ENDIAN);
 239             offset += 2;
 240             proto_tree_add_item(opt_tree, hf_geneve_opt_cpkt_devid, tvb, offset,
 241                                 2, ENC_BIG_ENDIAN);
 242             offset += 2;
 243             proto_tree_add_item(opt_tree, hf_geneve_opt_cpkt_portid, tvb, offset,
 244                                 2, ENC_BIG_ENDIAN);
 245             break;
 246         default:
 247             proto_tree_add_item(opt_tree, hf_geneve_opt_unknown_data, tvb, offset,
 248                                 len - 4, ENC_NA);
 249             break;
 250     }
 251 }
 252
 253 static void
 254 dissect_geneve_options(tvbuff_t *tvb, packet_info *pinfo,
 255                        proto_tree *geneve_tree, int offset, int len)
 256 {
 257     proto_item *opts_item;
 258     proto_tree *opts_tree;
 259     uint16_t opt_class;
 260     uint8_t opt_type;
 261     uint8_t opt_len;
 262
 263     opts_item = proto_tree_add_item(geneve_tree, hf_geneve_options, tvb,
 264                                     offset, len, ENC_NA);
 265     proto_item_set_text(opts_item, "Options: (%u bytes)", len);
 266     opts_tree = proto_item_add_subtree(opts_item, ett_geneve_options);
 267
 268     while (len > 0) {
 269         opt_class = tvb_get_ntohs(tvb, offset);
 270         opt_type = tvb_get_uint8(tvb, offset + 2);
 271         opt_len = 4 + ((tvb_get_uint8(tvb, offset + 3) & OPT_LEN_MASK) * 4);
 272
 273         if (opt_len > len) {
 274             proto_tree_add_expert_format(opts_tree, pinfo,
 275                                          &ei_geneve_opt_len_invalid, tvb,
 276                                          offset + 3, 1,
 277                                          "%s (length of %u is past end of options)",
 278                                          format_option_name(pinfo->pool, opt_class, opt_type),
 279                                          opt_len);
 280             return;
 281         }
 282
 283         dissect_option(pinfo->pool, tvb, opts_tree, offset, opt_class, opt_type, opt_len);
 284
 285         offset += opt_len;
 286         len -= opt_len;
 287     };
 288 }
 289
 290 static int
 291 dissect_geneve(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
 292 {
 293     proto_item *ti, *rsvd_item;
 294     proto_tree *geneve_tree;
 295     tvbuff_t *next_tvb;
 296     int offset = 0;
 297     uint8_t ver_opt;
 298     uint8_t ver;
 299     uint8_t flags;
 300     uint16_t proto_type;
 301     int opts_len;
 302     static int * const flag_fields[] = {
 303         &hf_geneve_flag_oam,
 304         &hf_geneve_flag_critical,
 305         &hf_geneve_flag_reserved,
 306         NULL
 307     };
 308
 309     col_set_str(pinfo->cinfo, COL_PROTOCOL, "Geneve");
 310     col_clear(pinfo->cinfo, COL_INFO);
 311
 312     ti = proto_tree_add_item(tree, proto_geneve, tvb, offset, -1, ENC_NA);
 313     geneve_tree = proto_item_add_subtree(ti, ett_geneve);
 314
 315     /* Version. */
 316     ver_opt = tvb_get_uint8(tvb, offset);
 317     ver = ver_opt >> VER_SHIFT;
 318     proto_tree_add_uint(geneve_tree, hf_geneve_version, tvb,
 319                         offset, 1, ver);
 320
 321     if (ver != GENEVE_VER) {
 322         proto_tree_add_expert_format(geneve_tree, pinfo,
 323                                      &ei_geneve_ver_unknown, tvb, offset, 1,
 324                                      "Unknown version %u", ver);
 325         col_add_fstr(pinfo->cinfo, COL_INFO, "Unknown Geneve version %u", ver);
 326     }
 327
 328     /* Option length. */
 329     opts_len = (ver_opt & HDR_OPTS_LEN_MASK) * 4;
 330     proto_tree_add_uint(geneve_tree, hf_geneve_option_length, tvb,
 331                                      offset, 1, opts_len);
 332     offset += 1;
 333
 334     /* Flags. */
 335     flags = tvb_get_uint8(tvb, offset);
 336     proto_tree_add_bitmask(geneve_tree, tvb, offset, hf_geneve_flags, ett_geneve_flags, flag_fields, ENC_BIG_ENDIAN);
 337     offset += 1;
 338
 339     /* Protocol Type. */
 340     proto_tree_add_item(geneve_tree, hf_geneve_proto_type, tvb,
 341                         offset, 2, ENC_BIG_ENDIAN);
 342
 343     proto_type = tvb_get_ntohs(tvb, offset);
 344     col_add_fstr(pinfo->cinfo, COL_INFO, "Encapsulated %s",
 345                  val_to_str(proto_type, etype_vals, "0x%04x (unknown)"));
 346
 347     offset += 2;
 348
 349     /* VNI. */
 350     proto_tree_add_item(geneve_tree, hf_geneve_vni, tvb, offset, 3,
 351                         ENC_BIG_ENDIAN);
 352     proto_item_append_text(ti, ", VNI: 0x%06x%s", tvb_get_ntoh24(tvb, offset),
 353                            flags & FLAG_OAM ? ", OAM" : "");
 354     offset += 3;
 355
 356     /* Reserved. */
 357     rsvd_item = proto_tree_add_item(geneve_tree, hf_geneve_reserved, tvb,
 358                                     offset, 1, ENC_BIG_ENDIAN);
 359     if (!tvb_get_uint8(tvb, offset)) {
 360         proto_item_set_hidden(rsvd_item);
 361     }
 362     offset += 1;
 363
 364     /* Options. */
 365     if (tree && opts_len) {
 366         dissect_geneve_options(tvb, pinfo, geneve_tree, offset, opts_len);
 367     }
 368     offset += opts_len;
 369
 370     proto_item_set_len(ti, offset);
 371
 372     next_tvb = tvb_new_subset_remaining(tvb, offset);
 373     if (!dissector_try_uint(ethertype_dissector_table, proto_type, next_tvb, pinfo, tree))
 374         call_data_dissector(next_tvb, pinfo, tree);
 375
 376     return tvb_captured_length(tvb);
 377 }
 378
 379 /* Register Geneve with Wireshark */
 380 void
 381 proto_register_geneve(void)
 382 {
 383     static hf_register_info hf[] = {
 384         { &hf_geneve_version,
 385           { "Version", "geneve.version",
 386             FT_UINT8, BASE_DEC, NULL, 0x00,
 387             NULL, HFILL }
 388         },
 389         { &hf_geneve_flags,
 390           { "Flags", "geneve.flags",
 391             FT_UINT8, BASE_HEX, NULL, 0x00,
 392             NULL, HFILL }
 393         },
 394         { &hf_geneve_flag_oam,
 395           { "Operations, Administration and Management Frame", "geneve.flags.oam",
 396             FT_BOOLEAN, 8, NULL, 0x80,
 397             NULL, HFILL }
 398         },
 399         { &hf_geneve_flag_critical,
 400           { "Critical Options Present", "geneve.flags.critical",
 401             FT_BOOLEAN, 8, NULL, 0x40,
 402             NULL, HFILL }
 403         },
 404         { &hf_geneve_flag_reserved,
 405           { "Reserved", "geneve.flags.reserved",
 406             FT_BOOLEAN, 8, NULL, 0x3F,
 407             NULL, HFILL }
 408         },
 409         { &hf_geneve_proto_type,
 410           { "Protocol Type", "geneve.proto_type",
 411             FT_UINT16, BASE_HEX, VALS(etype_vals), 0x0,
 412             NULL, HFILL }
 413         },
 414         { &hf_geneve_vni,
 415           { "Virtual Network Identifier (VNI)", "geneve.vni",
 416             FT_UINT24, BASE_HEX_DEC, NULL, 0x0,
 417             NULL, HFILL }
 418         },
 419         { &hf_geneve_reserved,
 420           { "Reserved", "geneve.reserved",
 421             FT_UINT8, BASE_HEX, NULL, 0x00,
 422             NULL, HFILL }
 423         },
 424         { &hf_geneve_options,
 425           { "Geneve Options", "geneve.options",
 426             FT_BYTES, BASE_NONE, NULL, 0x00,
 427             NULL, HFILL }
 428         },
 429         { &hf_geneve_option_class,
 430           { "Class", "geneve.option.class",
 431             FT_UINT16, BASE_HEX | BASE_RANGE_STRING, RVALS(class_id_names), 0x00,
 432             NULL, HFILL }
 433         },
 434         { &hf_geneve_option_type,
 435           { "Type", "geneve.option.type",
 436             FT_UINT8, BASE_HEX, NULL, 0x00,
 437             NULL, HFILL }
 438         },
 439         { &hf_geneve_option_type_critical,
 440           { "Critical Option", "geneve.option.type.critical",
 441             FT_BOOLEAN, 8, NULL, 0x80,
 442             NULL, HFILL }
 443         },
 444         { &hf_geneve_option_flags,
 445           { "Flags", "geneve.option.flags",
 446             FT_UINT8, BASE_HEX, NULL, 0x00,
 447             NULL, HFILL }
 448         },
 449         { &hf_geneve_option_flags_reserved,
 450           { "Reserved", "geneve.option.flags.reserved",
 451             FT_BOOLEAN, 8, NULL, 0xE0,
 452             NULL, HFILL }
 453         },
 454         { &hf_geneve_option_length,
 455           { "Length", "geneve.option.length",
 456             FT_UINT8, BASE_DEC|BASE_UNIT_STRING, UNS(&units_byte_bytes), 0x00,
 457             NULL, HFILL }
 458         },
 459         { &hf_geneve_option,
 460           { "Option", "geneve.option",
 461             FT_BYTES, BASE_NONE, NULL, 0x00,
 462             NULL, HFILL }
 463         },
 464         { &hf_geneve_opt_gcp_vnid,
 465           { "GCP Virtual Network ID", "geneve.option.gcp.vnid",
 466             FT_UINT32, BASE_DEC, NULL, 0x00,
 467             NULL, HFILL }
 468         },
 469         { &hf_geneve_opt_gcp_reserved,
 470           { "GCP Reserved bits", "geneve.option.gcp.reserved",
 471             FT_BOOLEAN, 32, NULL, 0x0000000E,
 472             NULL, HFILL }
 473         },
 474         { &hf_geneve_opt_gcp_direction,
 475           { "GCP Traffic Direction", "geneve.option.gcp.direction",
 476             FT_BOOLEAN, 32, TFS(&tfs_geneve_gcp_direction), 0x00000001,
 477             NULL, HFILL }
 478         },
 479         { &hf_geneve_opt_gcp_endpoint,
 480           { "GCP Endpoint ID", "geneve.option.gcp.endpoint",
 481             FT_BYTES, BASE_NONE, NULL, 0x00,
 482             NULL, HFILL }
 483         },
 484         { &hf_geneve_opt_gcp_profile,
 485           { "GCP Profile ID", "geneve.option.gcp.profile",
 486             FT_UINT64, BASE_DEC, NULL, 0x00,
 487             NULL, HFILL }
 488         },
 489         { &hf_geneve_opt_cpkt_seqnum,
 490          { "cPacket Packet ID", "geneve.option.cPacket.packetid",
 491            FT_UINT32, BASE_DEC, NULL, 0x00,
 492            NULL, HFILL }
 493         },
 494         { &hf_geneve_opt_cpkt_origlen,
 495          { "cPacket Original length", "geneve.option.cPacket.orig_len",
 496            FT_UINT16, BASE_DEC, NULL, 0x00,
 497            NULL, HFILL }
 498         },
 499         { &hf_geneve_opt_cpkt_reserved,
 500          { "cPacket Reserved", "geneve.option.cPacket.reserved",
 501            FT_UINT8, BASE_HEX, NULL, 0x00,
 502            NULL, HFILL }
 503         },
 504         { &hf_geneve_opt_cpkt_version,
 505          { "cPacket Metadata version", "geneve.option.cPacket.version",
 506            FT_UINT8, BASE_DEC, NULL, 0x00,
 507            NULL, HFILL }
 508         },
 509         { &hf_geneve_opt_cpkt_timestamp,
 510          { "cPacket Timestamp", "geneve.option.cPacket.timestamp",
 511            FT_ABSOLUTE_TIME, ABSOLUTE_TIME_UTC, NULL, 0x00,
 512            NULL, HFILL }
 513         },
 514         { &hf_geneve_opt_cpkt_ts_sec,
 515          { "cPacket Timestamp (s)", "geneve.option.cPacket.ts_sec",
 516            FT_UINT48, BASE_DEC, NULL, 0x00,
 517            NULL, HFILL }
 518         },
 519         { &hf_geneve_opt_cpkt_ts_nsec,
 520          { "cPacket Timestamp (ns)", "geneve.option.cPacket.ts_nsec",
 521            FT_UINT32, BASE_DEC, NULL, 0x00,
 522            NULL, HFILL }
 523         },
 524         { &hf_geneve_opt_cpkt_ts_fracns,
 525          { "cPacket Timestamp (frac. ns)", "geneve.option.cPacket.ts_fracns",
 526            FT_UINT16, BASE_DEC, NULL, 0x00,
 527            NULL, HFILL }
 528         },
 529         { &hf_geneve_opt_cpkt_devid,
 530          { "cPacket Device ID", "geneve.option.cPacket.device_id",
 531            FT_UINT16, BASE_DEC, NULL, 0x00,
 532            NULL, HFILL }
 533         },
 534         { &hf_geneve_opt_cpkt_portid,
 535          { "cPacket Port ID", "geneve.option.cPacket.port_id",
 536            FT_UINT16, BASE_DEC, NULL, 0x00,
 537            NULL, HFILL }
 538         },
 539         { &hf_geneve_opt_unknown_data,
 540           { "Unknown Option Data", "geneve.option.unknown.data",
 541             FT_BYTES, BASE_NONE, NULL, 0x00,
 542             NULL, HFILL }
 543         },
 544     };
 545
 546     static int *ett[] = {
 547         &ett_geneve,
 548         &ett_geneve_flags,
 549         &ett_geneve_options,
 550         &ett_geneve_opt_flags,
 551         &ett_geneve_opt_data,
 552     };
 553
 554     static ei_register_info ei[] = {
 555        { &ei_geneve_ver_unknown, { "geneve.version.unknown",
 556          PI_PROTOCOL, PI_WARN, "Unknown version", EXPFILL }},
 557        { &ei_geneve_opt_len_invalid, { "geneve.option.length.invalid",
 558          PI_PROTOCOL, PI_WARN, "Invalid length for option", EXPFILL }},
 559     };
 560
 561     expert_module_t *expert_geneve;
 562
 563     /* Register the protocol name and description */
 564     proto_geneve = proto_register_protocol("Generic Network Virtualization Encapsulation",
 565                                           "Geneve", "geneve");
 566
 567     proto_register_field_array(proto_geneve, hf, array_length(hf));
 568     proto_register_subtree_array(ett, array_length(ett));
 569
 570     expert_geneve = expert_register_protocol(proto_geneve);
 571     expert_register_field_array(expert_geneve, ei, array_length(ei));
 572
 573     geneve_handle = register_dissector("geneve", dissect_geneve, proto_geneve);
 574 }
 575
 576 void
 577 proto_reg_handoff_geneve(void)
 578 {
 579     dissector_add_uint_with_preference("udp.port", UDP_PORT_GENEVE, geneve_handle);
 580
 581     ethertype_dissector_table = find_dissector_table("ethertype");
 582 }
 583
 584 /*
 585  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 586  *
 587  * Local variables:
 588  * c-basic-offset: 4
 589  * tab-width: 8
 590  * indent-tabs-mode: nil
 591  * End:
 592  *
 593  * vi: set shiftwidth=4 tabstop=8 expandtab:
 594  * :indentSize=4:tabSize=8:noTabs=true:
 595  */