epan/dissectors/packet-bat.c

   1 /* packet-bat.c
   2  * Routines for B.A.T.M.A.N. Layer 3 dissection
   3  * Copyright 2008-2010 Sven Eckelmann <sven@narfation.org>
   4  *
   5  * Wireshark - Network traffic analyzer
   6  * By Gerald Combs <gerald@wireshark.org>
   7  * Copyright 1998 Gerald Combs
   8  *
   9  * SPDX-License-Identifier: GPL-2.0-or-later
  10  */
  11
  12 #include "config.h"
  13
  14 #include <epan/packet.h>
  15 #include <epan/tap.h>
  16 #include <epan/addr_resolv.h>
  17 #include <epan/tfs.h>
  18 #include <epan/unit_strings.h>
  19
  20 void proto_register_bat(void);
  21 void proto_reg_handoff_bat(void);
  22
  23 static dissector_handle_t batman_handle;
  24 static dissector_handle_t gw_handle;
  25 static dissector_handle_t vis_handle;
  26
  27 #define BAT_BATMAN_PORT  4305
  28 #define BAT_GW_PORT  4306 /* Not IANA registered */
  29 #define BAT_VIS_PORT  4307 /* Not IANA registered */
  30
  31 #define UNIDIRECTIONAL 0x80
  32 #define DIRECTLINK 0x40
  33
  34 struct batman_packet_v5 {
  35         uint8_t version;  /* batman version field */
  36         uint8_t flags;    /* 0x80: UNIDIRECTIONAL link, 0x40: DIRECTLINK flag, ... */
  37         uint8_t ttl;
  38         uint8_t gwflags;  /* flags related to gateway functions: gateway class */
  39         uint16_t seqno;
  40         uint16_t gwport;
  41         address orig;
  42         address old_orig;
  43         uint8_t tq;
  44         uint8_t hna_len;
  45 };
  46 #define BATMAN_PACKET_V5_SIZE 18
  47
  48 struct gw_packet {
  49         uint8_t type;
  50 };
  51 #define GW_PACKET_SIZE 1
  52
  53 #define TUNNEL_DATA              0x01
  54 #define TUNNEL_IP_REQUEST        0x02
  55 #define TUNNEL_IP_INVALID        0x03
  56 #define TUNNEL_KEEPALIVE_REQUEST 0x04
  57 #define TUNNEL_KEEPALIVE_REPLY   0x05
  58
  59 #define DATA_TYPE_NEIGH  1
  60 #define DATA_TYPE_SEC_IF 2
  61 #define DATA_TYPE_HNA    3
  62
  63 struct vis_packet_v22 {
  64         address sender_ip;
  65         uint8_t version;
  66         uint8_t gw_class;
  67         uint16_t tq_max;
  68 };
  69 #define VIS_PACKET_V22_SIZE 8
  70
  71 struct vis_data_v22 {
  72         uint8_t type;
  73         uint16_t data;
  74         address ip;
  75 };
  76 #define VIS_PACKET_V22_DATA_SIZE 7
  77
  78 struct vis_packet_v23 {
  79         address sender_ip;
  80         uint8_t version;
  81         uint8_t gw_class;
  82         uint8_t tq_max;
  83 };
  84 #define VIS_PACKET_V23_SIZE 7
  85
  86 struct vis_data_v23 {
  87         uint8_t type;
  88         uint8_t data;
  89         address ip;
  90 };
  91 #define VIS_PACKET_V23_DATA_SIZE 6
  92 /* End content from packet-bat.h */
  93
  94 /* trees */
  95 static int ett_bat_batman;
  96 static int ett_bat_batman_flags;
  97 static int ett_bat_batman_gwflags;
  98 static int ett_bat_batman_hna;
  99 static int ett_bat_gw;
 100 static int ett_bat_vis;
 101 static int ett_bat_vis_entry;
 102
 103 /* hfs */
 104 static int hf_bat_batman_version;
 105 static int hf_bat_batman_flags;
 106 static int hf_bat_batman_ttl;
 107 static int hf_bat_batman_gwflags;
 108 static int hf_bat_batman_gwflags_dl_speed;
 109 static int hf_bat_batman_gwflags_ul_speed;
 110 static int hf_bat_batman_seqno;
 111 static int hf_bat_batman_gwport;
 112 static int hf_bat_batman_orig;
 113 static int hf_bat_batman_old_orig;
 114 static int hf_bat_batman_tq;
 115 static int hf_bat_batman_hna_len;
 116 static int hf_bat_batman_hna_network;
 117 static int hf_bat_batman_hna_netmask;
 118
 119 static int hf_bat_gw_type;
 120 static int hf_bat_gw_ip;
 121
 122 static int hf_bat_vis_vis_orig;
 123 static int hf_bat_vis_version;
 124 static int hf_bat_vis_gwflags;
 125 static int hf_bat_max_tq_v22;
 126 static int hf_bat_max_tq_v23;
 127 static int hf_bat_vis_data_type;
 128 static int hf_bat_vis_netmask;
 129 static int hf_bat_vis_tq_v22;
 130 static int hf_bat_vis_tq_v23;
 131 static int hf_bat_vis_data_ip;
 132
 133 /* flags */
 134 static int hf_bat_batman_flags_unidirectional;
 135 static int hf_bat_batman_flags_directlink;
 136
 137 static const value_string gw_packettypenames[] = {
 138         { TUNNEL_DATA,              "DATA" },
 139         { TUNNEL_IP_REQUEST,        "IP_REQUEST" },
 140         { TUNNEL_IP_INVALID,        "IP_INVALID" },
 141         { TUNNEL_KEEPALIVE_REQUEST, "KEEPALIVE_REQUEST" },
 142         { TUNNEL_KEEPALIVE_REPLY,   "KEEPALIVE_REPLY" },
 143         { 0, NULL }
 144 };
 145
 146 static const value_string vis_packettypenames[] = {
 147         { DATA_TYPE_NEIGH,  "NEIGH" },
 148         { DATA_TYPE_SEC_IF, "SEC_IF" },
 149         { DATA_TYPE_HNA,    "HNA" },
 150         { 0, NULL }
 151 };
 152
 153 /* supported packet dissectors */
 154 static int dissect_bat_batman_v5(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree);
 155
 156
 157 static void dissect_bat_vis_v22(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 158 static void dissect_vis_entry_v22(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 159 static void dissect_bat_vis_v23(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 160 static void dissect_vis_entry_v23(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 161
 162 static void dissect_bat_hna(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 163
 164 /* other dissectors */
 165 static dissector_handle_t ip_handle;
 166
 167 static int proto_bat_plugin;
 168 static int proto_bat_gw;
 169 static int proto_bat_vis;
 170
 171 /* tap */
 172 static int bat_tap;
 173 static int bat_follow_tap;
 174
 175 static int dissect_bat_batman(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
 176 {
 177         uint8_t version;
 178         int offset = 0;
 179
 180         /* set protocol name */
 181         col_set_str(pinfo->cinfo, COL_PROTOCOL, "BAT_BATMAN");
 182         col_clear(pinfo->cinfo, COL_INFO);
 183
 184         version = tvb_get_uint8(tvb, 0);
 185         switch (version) {
 186         case 5:
 187                 while (tvb_reported_length_remaining(tvb, offset) > 0) {
 188                         offset = dissect_bat_batman_v5(tvb, offset, pinfo, tree);
 189                 }
 190                 break;
 191         default:
 192                 col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
 193                 call_data_dissector(tvb, pinfo, tree);
 194                 break;
 195         }
 196         return tvb_captured_length(tvb);
 197 }
 198
 199 static void dissect_bat_gwflags(tvbuff_t *tvb, uint8_t gwflags, int offset, proto_item *tgw)
 200 {
 201         proto_tree *gwflags_tree;
 202         uint8_t s = (gwflags & 0x80) >> 7;
 203         uint8_t downbits = (gwflags & 0x78) >> 3;
 204         uint8_t upbits = (gwflags & 0x07);
 205         unsigned  down, up;
 206
 207         down = 32 * (s + 2) * (1 << downbits);
 208         up = ((upbits + 1) * down) / 8;
 209
 210         gwflags_tree =  proto_item_add_subtree(tgw, ett_bat_batman_gwflags);
 211         proto_tree_add_uint(gwflags_tree, hf_bat_batman_gwflags_dl_speed, tvb, offset, 1, down);
 212         proto_tree_add_uint(gwflags_tree, hf_bat_batman_gwflags_ul_speed, tvb, offset, 1, up);
 213
 214 }
 215
 216 static int dissect_bat_batman_v5(tvbuff_t *tvb, int offset, packet_info *pinfo, proto_tree *tree)
 217 {
 218         proto_item *tgw;
 219         proto_tree *bat_batman_tree = NULL;
 220         struct batman_packet_v5 *batman_packeth;
 221         uint32_t old_orig, orig;
 222         int i;
 223         static int * const batman_flags[] = {
 224                 &hf_bat_batman_flags_unidirectional,
 225                 &hf_bat_batman_flags_directlink,
 226                 NULL
 227         };
 228
 229         tvbuff_t *next_tvb;
 230
 231         batman_packeth = wmem_new(pinfo->pool, struct batman_packet_v5);
 232
 233         batman_packeth->version = tvb_get_uint8(tvb, offset+0);
 234         batman_packeth->flags = tvb_get_uint8(tvb, offset+1);
 235         batman_packeth->ttl = tvb_get_uint8(tvb, offset+2);
 236         batman_packeth->gwflags = tvb_get_uint8(tvb, offset+3);
 237         batman_packeth->seqno = tvb_get_ntohs(tvb, offset+4);
 238         batman_packeth->gwport = tvb_get_ntohs(tvb, offset+6);
 239         orig = tvb_get_ipv4(tvb, offset+8);
 240         set_address_tvb(&batman_packeth->orig, AT_IPv4, 4, tvb, offset+8);
 241         old_orig = tvb_get_ipv4(tvb, offset+12);
 242         set_address_tvb(&batman_packeth->old_orig, AT_IPv4, 4, tvb, offset+12);
 243         batman_packeth->tq = tvb_get_uint8(tvb, offset+16);
 244         batman_packeth->hna_len = tvb_get_uint8(tvb, offset+17);
 245
 246         /* Set info column */
 247         col_add_fstr(pinfo->cinfo, COL_INFO, "Seq=%u", batman_packeth->seqno);
 248
 249         /* Set tree info */
 250         if (tree) {
 251                 proto_item *ti;
 252
 253                 ti = proto_tree_add_protocol_format(tree, proto_bat_plugin, tvb, offset, BATMAN_PACKET_V5_SIZE,
 254                                                             "B.A.T.M.A.N., Orig: %s",
 255                                                             address_with_resolution_to_str(pinfo->pool, &batman_packeth->orig));
 256                 bat_batman_tree = proto_item_add_subtree(ti, ett_bat_batman);
 257         }
 258
 259         /* items */
 260         proto_tree_add_item(bat_batman_tree, hf_bat_batman_version, tvb, offset, 1, ENC_BIG_ENDIAN);
 261         offset += 1;
 262
 263         proto_tree_add_bitmask(bat_batman_tree, tvb, offset, hf_bat_batman_flags,
 264                                         ett_bat_batman_flags, batman_flags, ENC_NA);
 265         offset += 1;
 266
 267         proto_tree_add_item(bat_batman_tree, hf_bat_batman_ttl, tvb, offset, 1, ENC_BIG_ENDIAN);
 268         offset += 1;
 269
 270         tgw = proto_tree_add_item(bat_batman_tree, hf_bat_batman_gwflags, tvb, offset, 1, ENC_BIG_ENDIAN);
 271         dissect_bat_gwflags(tvb, batman_packeth->gwflags, offset, tgw);
 272         offset += 1;
 273
 274         proto_tree_add_item(bat_batman_tree, hf_bat_batman_seqno, tvb, offset, 2, ENC_BIG_ENDIAN);
 275         offset += 2;
 276
 277         proto_tree_add_item(bat_batman_tree, hf_bat_batman_gwport, tvb, offset, 2, ENC_BIG_ENDIAN);
 278         offset += 2;
 279
 280         proto_tree_add_ipv4(bat_batman_tree, hf_bat_batman_orig, tvb, offset, 4, orig);
 281         offset += 4;
 282
 283         proto_tree_add_ipv4(bat_batman_tree, hf_bat_batman_old_orig, tvb, offset, 4,  old_orig);
 284         offset += 4;
 285
 286         proto_tree_add_item(bat_batman_tree, hf_bat_batman_tq, tvb, offset, 1, ENC_BIG_ENDIAN);
 287         offset += 1;
 288
 289         proto_tree_add_item(bat_batman_tree, hf_bat_batman_hna_len, tvb, offset, 1, ENC_BIG_ENDIAN);
 290         offset += 1;
 291
 292         tap_queue_packet(bat_tap, pinfo, batman_packeth);
 293
 294         for (i = 0; i < batman_packeth->hna_len; i++) {
 295                 next_tvb = tvb_new_subset_length(tvb, offset, 5);
 296
 297                 if (have_tap_listener(bat_follow_tap)) {
 298                         tap_queue_packet(bat_follow_tap, pinfo, next_tvb);
 299                 }
 300
 301                 dissect_bat_hna(next_tvb, pinfo, bat_batman_tree);
 302                 offset += 5;
 303         }
 304
 305         return offset;
 306 }
 307
 308 static void dissect_bat_hna(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree)
 309 {
 310         uint32_t hna;
 311         uint8_t hna_netmask;
 312
 313         hna = tvb_get_ipv4(tvb, 0);
 314         hna_netmask = tvb_get_uint8(tvb, 4);
 315
 316
 317         /* Set tree info */
 318         if (tree) {
 319                 proto_item *ti;
 320                 proto_tree *bat_batman_hna_tree;
 321
 322                 if (PTREE_DATA(tree)->visible) {
 323                         ti = proto_tree_add_protocol_format(tree, proto_bat_plugin, tvb, 0, 5,
 324                                                             "B.A.T.M.A.N. HNA: %s/%d",
 325                                                             tvb_ip_to_str(pinfo->pool, tvb, 0), hna_netmask);
 326                 } else {
 327                         ti = proto_tree_add_item(tree, proto_bat_plugin, tvb, 0, 5, ENC_NA);
 328                 }
 329                 bat_batman_hna_tree = proto_item_add_subtree(ti, ett_bat_batman_hna);
 330
 331                 proto_tree_add_ipv4(bat_batman_hna_tree, hf_bat_batman_hna_network, tvb, 0, 4, hna);
 332                 proto_tree_add_item(bat_batman_hna_tree, hf_bat_batman_hna_netmask, tvb, 4, 1, ENC_BIG_ENDIAN);
 333         }
 334 }
 335
 336
 337 static int dissect_bat_gw(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
 338 {
 339         struct gw_packet *gw_packeth;
 340         uint32_t ip;
 341         int ip_pos;
 342
 343         tvbuff_t *next_tvb;
 344         int length_remaining;
 345         int offset = 0;
 346
 347         gw_packeth = wmem_new(pinfo->pool, struct gw_packet);
 348         gw_packeth->type = tvb_get_uint8(tvb, 0);
 349
 350         switch (gw_packeth->type) {
 351                 case TUNNEL_IP_INVALID:
 352                         ip_pos = 13;
 353                         break;
 354                 default:
 355                         ip_pos = 1;
 356         }
 357         ip = tvb_get_ipv4(tvb, ip_pos);
 358
 359         /* set protocol name */
 360         col_set_str(pinfo->cinfo, COL_PROTOCOL, "BAT_GW");
 361
 362         /* Set info column */
 363         col_add_fstr(pinfo->cinfo, COL_INFO, "Type=%s",
 364                      val_to_str(gw_packeth->type, gw_packettypenames, "Unknown (0x%02x)"));
 365         if (ip != 0) {
 366                 col_append_fstr(pinfo->cinfo, COL_INFO, " IP: %s",
 367                                 tvb_address_with_resolution_to_str(pinfo->pool, tvb, AT_IPv4, ip_pos));
 368         }
 369
 370
 371         /* Set tree info */
 372         if (tree) {
 373                 proto_item *ti;
 374                 proto_tree *bat_gw_entry_tree;
 375
 376                 ti = proto_tree_add_protocol_format(tree, proto_bat_gw, tvb, 0, 1,
 377                                                         "B.A.T.M.A.N. GW [%s]",
 378                                                         val_to_str(gw_packeth->type, gw_packettypenames, "Unknown (0x%02x)"));
 379                 bat_gw_entry_tree = proto_item_add_subtree(ti, ett_bat_gw);
 380
 381                 proto_tree_add_item(bat_gw_entry_tree, hf_bat_gw_type, tvb, offset, 1, ENC_BIG_ENDIAN);
 382                 /*offset += 1;*/
 383
 384                 if (gw_packeth->type != TUNNEL_DATA && ip != 0) {
 385                         proto_tree_add_ipv4(bat_gw_entry_tree, hf_bat_gw_ip, tvb, ip_pos, 4, ip);
 386                         /*offset = ip_pos + 4;*/
 387                 }
 388         }
 389
 390         /* Calculate offset even when we got no tree */
 391         offset = 1;
 392         if (gw_packeth->type != TUNNEL_DATA && ip != 0)
 393                 offset = ip_pos + 4;
 394
 395         length_remaining = tvb_reported_length_remaining(tvb, offset);
 396         if (length_remaining > 0) {
 397                 next_tvb = tvb_new_subset_remaining(tvb, offset);
 398
 399                 if (have_tap_listener(bat_follow_tap)) {
 400                         tap_queue_packet(bat_follow_tap, pinfo, next_tvb);
 401                 }
 402
 403                 if (gw_packeth->type == TUNNEL_DATA) {
 404                         call_dissector(ip_handle, next_tvb, pinfo, tree);
 405                 } else {
 406                         call_data_dissector(next_tvb, pinfo, tree);
 407                 }
 408         }
 409         return tvb_captured_length(tvb);
 410 }
 411
 412 static int dissect_bat_vis(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
 413 {
 414         uint8_t version;
 415
 416         /* set protocol name */
 417         col_set_str(pinfo->cinfo, COL_PROTOCOL, "BAT_VIS");
 418
 419         version = tvb_get_uint8(tvb, 4);
 420         switch (version) {
 421         case 22:
 422                 dissect_bat_vis_v22(tvb, pinfo, tree);
 423                 break;
 424         case 23:
 425                 dissect_bat_vis_v23(tvb, pinfo, tree);
 426                 break;
 427         default:
 428                 col_add_fstr(pinfo->cinfo, COL_INFO, "Unsupported Version %d", version);
 429                 call_data_dissector(tvb, pinfo, tree);
 430                 break;
 431         }
 432         return tvb_captured_length(tvb);
 433 }
 434
 435 static void dissect_bat_vis_v22(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 436 {
 437         struct vis_packet_v22 *vis_packeth;
 438         uint32_t sender_ip;
 439         proto_tree *bat_vis_tree = NULL;
 440
 441         tvbuff_t *next_tvb;
 442         int length_remaining, i;
 443         int offset = 0;
 444
 445         vis_packeth = wmem_new(pinfo->pool, struct vis_packet_v22);
 446
 447         sender_ip = tvb_get_ipv4(tvb, 0);
 448         set_address_tvb(&vis_packeth->sender_ip, AT_IPv4, 4, tvb, 0);
 449         vis_packeth->version = tvb_get_uint8(tvb, 4);
 450         vis_packeth->gw_class = tvb_get_uint8(tvb, 5);
 451         vis_packeth->tq_max = tvb_get_ntohs(tvb, 6);
 452
 453         /* set protocol name */
 454         col_set_str(pinfo->cinfo, COL_PROTOCOL, "BAT_VIS");
 455
 456         /* Set info column */
 457         col_add_fstr(pinfo->cinfo, COL_INFO, "Src: %s",
 458                      address_with_resolution_to_str(pinfo->pool, &vis_packeth->sender_ip));
 459
 460         /* Set tree info */
 461         if (tree) {
 462                 proto_item *ti;
 463
 464                 ti = proto_tree_add_protocol_format(tree, proto_bat_vis, tvb, 0, VIS_PACKET_V22_SIZE,
 465                                                             "B.A.T.M.A.N. Vis, Src: %s",
 466                                                             address_with_resolution_to_str(pinfo->pool, &vis_packeth->sender_ip));
 467                 bat_vis_tree = proto_item_add_subtree(ti, ett_bat_vis);
 468
 469                 /* items */
 470                 proto_tree_add_ipv4(bat_vis_tree, hf_bat_vis_vis_orig, tvb, offset, 4, sender_ip);
 471                 offset += 4;
 472
 473                 proto_tree_add_item(bat_vis_tree, hf_bat_vis_version, tvb, offset, 1, ENC_BIG_ENDIAN);
 474                 offset += 1;
 475
 476                 proto_tree_add_item(bat_vis_tree, hf_bat_vis_gwflags, tvb, offset, 1, ENC_BIG_ENDIAN);
 477                 offset += 1;
 478
 479                 proto_tree_add_item(bat_vis_tree, hf_bat_max_tq_v22, tvb, offset, 2, ENC_BIG_ENDIAN);
 480                 /*offset += 2;*/
 481         }
 482
 483         /* Calculate offset even when we got no tree */
 484         offset = VIS_PACKET_V22_SIZE;
 485
 486         tap_queue_packet(bat_tap, pinfo, vis_packeth);
 487
 488         length_remaining = tvb_reported_length_remaining(tvb, offset);
 489
 490         for (i = 0; i < length_remaining; i += VIS_PACKET_V22_DATA_SIZE) {
 491                 next_tvb = tvb_new_subset_length(tvb, offset, VIS_PACKET_V22_DATA_SIZE);
 492
 493                 if (have_tap_listener(bat_follow_tap)) {
 494                         tap_queue_packet(bat_follow_tap, pinfo, next_tvb);
 495                 }
 496
 497                 if (bat_vis_tree != NULL) {
 498                         dissect_vis_entry_v22(next_tvb, pinfo, tree);
 499                 }
 500
 501                 offset += VIS_PACKET_V22_DATA_SIZE;
 502         }
 503
 504         length_remaining = tvb_reported_length_remaining(tvb, offset);
 505         if (length_remaining > 0) {
 506                 next_tvb = tvb_new_subset_remaining(tvb, offset);
 507
 508                 if (have_tap_listener(bat_follow_tap)) {
 509                         tap_queue_packet(bat_follow_tap, pinfo, next_tvb);
 510                 }
 511
 512                 call_data_dissector(next_tvb, pinfo, tree);
 513         }
 514 }
 515
 516 static void dissect_vis_entry_v22(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree)
 517 {
 518         struct vis_data_v22 *vis_datah;
 519         uint32_t ip;
 520
 521         vis_datah = wmem_new(pinfo->pool, struct vis_data_v22);
 522         vis_datah->type = tvb_get_uint8(tvb, 0);
 523         vis_datah->data = tvb_get_ntohs(tvb, 1);
 524         ip = tvb_get_ipv4(tvb, 3);
 525         set_address_tvb(&vis_datah->ip, AT_IPv4, 4, tvb, 3);
 526
 527
 528         /* Set tree info */
 529         if (tree) {
 530                 proto_item *ti;
 531                 proto_tree *bat_vis_entry_tree;
 532
 533                 ti = proto_tree_add_protocol_format(tree, proto_bat_plugin, tvb, 0, 7,
 534                                                             "VIS Entry: [%s] %s",
 535                                                             val_to_str(vis_datah->type, vis_packettypenames, "Unknown (0x%02x)"),
 536                                                             address_with_resolution_to_str(pinfo->pool, &vis_datah->ip));
 537                 bat_vis_entry_tree = proto_item_add_subtree(ti, ett_bat_vis_entry);
 538
 539                 proto_tree_add_item(bat_vis_entry_tree, hf_bat_vis_data_type, tvb, 0, 1, ENC_BIG_ENDIAN);
 540
 541                 switch (vis_datah->type) {
 542                 case DATA_TYPE_NEIGH:
 543                         proto_tree_add_item(bat_vis_entry_tree, hf_bat_vis_tq_v22, tvb, 1, 2, ENC_BIG_ENDIAN);
 544                         break;
 545                 case DATA_TYPE_HNA:
 546                         proto_tree_add_item(bat_vis_entry_tree, hf_bat_vis_netmask, tvb, 1, 1, ENC_BIG_ENDIAN);
 547                         break;
 548                 case DATA_TYPE_SEC_IF:
 549                 default:
 550                         break;
 551                 }
 552                 proto_tree_add_ipv4(bat_vis_entry_tree, hf_bat_vis_data_ip, tvb, 3, 4,  ip);
 553         }
 554 }
 555
 556 static void dissect_bat_vis_v23(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 557 {
 558         struct vis_packet_v23 *vis_packeth;
 559         uint32_t sender_ip;
 560         proto_tree *bat_vis_tree = NULL;
 561
 562         tvbuff_t *next_tvb;
 563         int length_remaining, i;
 564         int offset = 0;
 565
 566         vis_packeth = wmem_new(pinfo->pool, struct vis_packet_v23);
 567
 568         sender_ip = tvb_get_ipv4(tvb, 0);
 569         set_address_tvb(&vis_packeth->sender_ip, AT_IPv4, 4, tvb, 0);
 570         vis_packeth->version = tvb_get_uint8(tvb, 4);
 571         vis_packeth->gw_class = tvb_get_uint8(tvb, 5);
 572         vis_packeth->tq_max = tvb_get_uint8(tvb, 6);
 573
 574         /* set protocol name */
 575         col_set_str(pinfo->cinfo, COL_PROTOCOL, "BAT_VIS");
 576
 577         /* Set info column */
 578         col_add_fstr(pinfo->cinfo, COL_INFO, "Src: %s",
 579                      address_with_resolution_to_str(pinfo->pool, &vis_packeth->sender_ip));
 580
 581         /* Set tree info */
 582         if (tree) {
 583                 proto_item *ti;
 584
 585                 ti = proto_tree_add_protocol_format(tree, proto_bat_vis, tvb, 0, VIS_PACKET_V23_SIZE,
 586                                                             "B.A.T.M.A.N. Vis, Src: %s",
 587                                                             address_with_resolution_to_str(pinfo->pool, &vis_packeth->sender_ip));
 588                 bat_vis_tree = proto_item_add_subtree(ti, ett_bat_vis);
 589
 590                 /* items */
 591                 proto_tree_add_ipv4(bat_vis_tree, hf_bat_vis_vis_orig, tvb, offset, 4, sender_ip);
 592                 offset += 4;
 593
 594                 proto_tree_add_item(bat_vis_tree, hf_bat_vis_version, tvb, offset, 1, ENC_BIG_ENDIAN);
 595                 offset += 1;
 596
 597                 proto_tree_add_item(bat_vis_tree, hf_bat_vis_gwflags, tvb, offset, 1, ENC_BIG_ENDIAN);
 598                 offset += 1;
 599
 600                 proto_tree_add_item(bat_vis_tree, hf_bat_max_tq_v23, tvb, offset, 1, ENC_BIG_ENDIAN);
 601                 /*offset += 1;*/
 602         }
 603
 604         /* Calculate offset even when we got no tree */
 605         offset = VIS_PACKET_V23_SIZE;
 606
 607         tap_queue_packet(bat_tap, pinfo, vis_packeth);
 608
 609         length_remaining = tvb_reported_length_remaining(tvb, offset);
 610
 611         for (i = 0; i < length_remaining; i += VIS_PACKET_V23_DATA_SIZE) {
 612                 next_tvb = tvb_new_subset_length(tvb, offset, VIS_PACKET_V23_DATA_SIZE);
 613
 614                 if (have_tap_listener(bat_follow_tap)) {
 615                         tap_queue_packet(bat_follow_tap, pinfo, next_tvb);
 616                 }
 617
 618                 if (bat_vis_tree != NULL) {
 619                         dissect_vis_entry_v23(next_tvb, pinfo, tree);
 620                 }
 621
 622                 offset += VIS_PACKET_V23_DATA_SIZE;
 623         }
 624
 625         length_remaining = tvb_reported_length_remaining(tvb, offset);
 626         if (length_remaining > 0) {
 627                 next_tvb = tvb_new_subset_remaining(tvb, offset);
 628
 629                 if (have_tap_listener(bat_follow_tap)) {
 630                         tap_queue_packet(bat_follow_tap, pinfo, next_tvb);
 631                 }
 632
 633                 call_data_dissector(next_tvb, pinfo, tree);
 634         }
 635 }
 636
 637 static void dissect_vis_entry_v23(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree)
 638 {
 639         struct vis_data_v23 *vis_datah;
 640         uint32_t ip;
 641
 642         vis_datah = wmem_new(pinfo->pool, struct vis_data_v23);
 643         vis_datah->type = tvb_get_uint8(tvb, 0);
 644         vis_datah->data = tvb_get_uint8(tvb, 1);
 645         ip = tvb_get_ipv4(tvb, 2);
 646         set_address_tvb(&vis_datah->ip, AT_IPv4, 4, tvb, 2);
 647
 648
 649         /* Set tree info */
 650         if (tree) {
 651                 proto_item *ti;
 652                 proto_tree *bat_vis_entry_tree;
 653
 654                 ti = proto_tree_add_protocol_format(tree, proto_bat_plugin, tvb, 0, 7,
 655                                                             "VIS Entry: [%s] %s",
 656                                                             val_to_str(vis_datah->type, vis_packettypenames, "Unknown (0x%02x)"),
 657                                                             address_with_resolution_to_str(pinfo->pool, &vis_datah->ip));
 658                 bat_vis_entry_tree = proto_item_add_subtree(ti, ett_bat_vis_entry);
 659
 660                 proto_tree_add_item(bat_vis_entry_tree, hf_bat_vis_data_type, tvb, 0, 1, ENC_BIG_ENDIAN);
 661
 662                 switch (vis_datah->type) {
 663                 case DATA_TYPE_NEIGH:
 664                         proto_tree_add_item(bat_vis_entry_tree, hf_bat_vis_tq_v23, tvb, 1, 1, ENC_BIG_ENDIAN);
 665                         break;
 666                 case DATA_TYPE_HNA:
 667                         proto_tree_add_item(bat_vis_entry_tree, hf_bat_vis_netmask, tvb, 1, 1, ENC_BIG_ENDIAN);
 668                         break;
 669                 case DATA_TYPE_SEC_IF:
 670                 default:
 671                         break;
 672                 }
 673                 proto_tree_add_ipv4(bat_vis_entry_tree, hf_bat_vis_data_ip, tvb, 2, 4,  ip);
 674         }
 675 }
 676
 677 void proto_register_bat(void)
 678 {
 679         static hf_register_info hf[] = {
 680                 { &hf_bat_batman_version,
 681                   { "Version", "bat.batman.version",
 682                     FT_UINT8, BASE_DEC, NULL, 0x0,
 683                     NULL, HFILL }
 684                 },
 685                 { &hf_bat_batman_flags,
 686                   { "Flags", "bat.batman.flags",
 687                     FT_UINT8, BASE_HEX, NULL, 0x0,
 688                     NULL, HFILL }
 689                 },
 690                 { &hf_bat_batman_ttl,
 691                   { "Time to Live", "bat.batman.ttl",
 692                     FT_UINT8, BASE_DEC, NULL, 0x0,
 693                     NULL, HFILL }
 694                 },
 695                 { &hf_bat_batman_gwflags,
 696                   { "Gateway Flags", "bat.batman.gwflags",
 697                     FT_UINT8, BASE_HEX, NULL, 0x0,
 698                     NULL, HFILL }
 699                 },
 700                 { &hf_bat_batman_gwflags_dl_speed,
 701                   { "Download Speed", "bat.batman.gwflags.dl_speed",
 702                     FT_UINT32, BASE_DEC|BASE_UNIT_STRING, UNS(&units_kbit), 0x0,
 703                     NULL, HFILL }
 704                 },
 705                 { &hf_bat_batman_gwflags_ul_speed,
 706                   { "Upload Speed", "bat.batman.gwflags.ul_speed",
 707                     FT_UINT32, BASE_DEC|BASE_UNIT_STRING, UNS(&units_kbit), 0x0,
 708                     NULL, HFILL }
 709                 },
 710                 { &hf_bat_batman_seqno,
 711                   { "Sequence number", "bat.batman.seq",
 712                     FT_UINT16, BASE_DEC, NULL, 0x0,
 713                     NULL, HFILL }
 714                 },
 715                 { &hf_bat_batman_gwport,
 716                   { "Gateway Port", "bat.batman.gwport",
 717                     FT_UINT16, BASE_DEC, NULL, 0x0,
 718                     NULL, HFILL }
 719                 },
 720                 { &hf_bat_batman_orig,
 721                   { "Originator", "bat.batman.orig",
 722                     FT_IPv4, BASE_NONE, NULL, 0x0,
 723                     NULL, HFILL }
 724                 },
 725                 { &hf_bat_batman_old_orig,
 726                   { "Received from", "bat.batman.old_orig",
 727                     FT_IPv4, BASE_NONE, NULL, 0x0,
 728                     NULL, HFILL }
 729                 },
 730                 { &hf_bat_batman_tq,
 731                   { "Transmission Quality", "bat.batman.tq",
 732                     FT_UINT8, BASE_DEC, NULL, 0x0,
 733                     NULL, HFILL }
 734                 },
 735                 { &hf_bat_batman_hna_len,
 736                   { "Number of HNAs", "bat.batman.hna_len",
 737                     FT_UINT8, BASE_DEC, NULL, 0x0,
 738                     NULL, HFILL }
 739                 },
 740                 { &hf_bat_batman_flags_unidirectional,
 741                   { "Unidirectional", "bat.batman.flags.unidirectional",
 742                     FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x80,
 743                     NULL, HFILL }
 744                 },
 745                 { &hf_bat_batman_flags_directlink,
 746                   { "DirectLink", "bat.batman.flags.directlink",
 747                     FT_BOOLEAN, 8, TFS(&tfs_set_notset), 0x40,
 748                     NULL, HFILL }
 749                 },
 750                 { &hf_bat_batman_hna_network,
 751                   { "HNA Network", "bat.batman.hna_network",
 752                     FT_IPv4, BASE_NONE, NULL, 0x0,
 753                     NULL, HFILL }
 754                 },
 755                 { &hf_bat_batman_hna_netmask,
 756                   { "HNA Netmask", "bat.batman.hna_netmask",
 757                     FT_UINT8, BASE_DEC, NULL, 0x0,
 758                     NULL, HFILL }
 759                 },
 760                 { &hf_bat_gw_type,
 761                   { "Type", "bat.gw.type",
 762                     FT_UINT8, BASE_DEC, VALS(gw_packettypenames), 0x0,
 763                     NULL, HFILL }
 764                 },
 765                 { &hf_bat_gw_ip,
 766                   { "IP", "bat.gw.ip",
 767                     FT_IPv4, BASE_NONE, NULL, 0x0,
 768                     NULL, HFILL }
 769                 },
 770                 { &hf_bat_vis_vis_orig,
 771                   { "Originator", "bat.vis.sender_ip",
 772                     FT_IPv4, BASE_NONE, NULL, 0x0,
 773                     NULL, HFILL }
 774                 },
 775                 { &hf_bat_vis_version,
 776                   { "Version", "bat.vis.version",
 777                     FT_UINT8, BASE_DEC, NULL, 0x0,
 778                     NULL, HFILL }
 779                 },
 780                 { &hf_bat_vis_gwflags,
 781                   { "Gateway Flags", "bat.vis.gwflags",
 782                     FT_UINT8, BASE_HEX, NULL, 0x0,
 783                     NULL, HFILL }
 784                 },
 785                 { &hf_bat_max_tq_v22,
 786                   { "Maximum Transmission Quality", "bat.vis.tq_max",
 787                     FT_UINT16, BASE_DEC, NULL, 0x0,
 788                     NULL, HFILL }
 789                 },
 790                 { &hf_bat_max_tq_v23,
 791                   { "Maximum Transmission Quality", "bat.vis.tq_max",
 792                     FT_UINT8, BASE_DEC, NULL, 0x0,
 793                     NULL, HFILL }
 794                 },
 795                 { &hf_bat_vis_data_type,
 796                   { "Type", "bat.vis.data_type",
 797                     FT_UINT8, BASE_DEC, VALS(vis_packettypenames), 0x0,
 798                     NULL, HFILL }
 799                 },
 800                 { &hf_bat_vis_tq_v22,
 801                   { "Transmission Quality", "bat.vis.tq",
 802                     FT_UINT16, BASE_DEC, NULL, 0x0,
 803                     NULL, HFILL}
 804                 },
 805                 { &hf_bat_vis_tq_v23,
 806                   { "Transmission Quality", "bat.vis.tq",
 807                     FT_UINT8, BASE_DEC, NULL, 0x0,
 808                     NULL, HFILL}
 809                 },
 810                 { &hf_bat_vis_netmask,
 811                   { "Netmask", "bat.vis.netmask",
 812                     FT_UINT8, BASE_DEC, NULL, 0x0,
 813                     NULL, HFILL}
 814                 },
 815                 { &hf_bat_vis_data_ip,
 816                   { "IP", "bat.vis.data_ip",
 817                     FT_IPv4, BASE_NONE, NULL, 0x0,
 818                     NULL, HFILL }
 819                 }
 820         };
 821
 822         /* Setup protocol subtree array */
 823         static int *ett[] = {
 824                 &ett_bat_batman,
 825                 &ett_bat_batman_flags,
 826                 &ett_bat_batman_gwflags,
 827                 &ett_bat_batman_hna,
 828                 &ett_bat_gw,
 829                 &ett_bat_vis,
 830                 &ett_bat_vis_entry
 831         };
 832
 833         proto_bat_plugin = proto_register_protocol("B.A.T.M.A.N. Layer 3 Protocol", "BAT", "bat");
 834         proto_bat_gw = proto_register_protocol("B.A.T.M.A.N. GW", "BAT GW", "bat.gw");
 835         proto_bat_vis = proto_register_protocol("B.A.T.M.A.N. Vis", "BAT VIS", "bat.vis");
 836
 837         batman_handle = register_dissector("bat", dissect_bat_batman, proto_bat_plugin);
 838         gw_handle = register_dissector("bat.gw", dissect_bat_gw, proto_bat_gw);
 839         vis_handle = register_dissector("bat.vis", dissect_bat_vis, proto_bat_vis);
 840
 841         proto_register_field_array(proto_bat_plugin, hf, array_length(hf));
 842         proto_register_subtree_array(ett, array_length(ett));
 843
 844         bat_tap = register_tap("batman");
 845         bat_follow_tap = register_tap("batman_follow");
 846 }
 847
 848 void proto_reg_handoff_bat(void)
 849 {
 850         ip_handle = find_dissector_add_dependency("ip", proto_bat_gw);
 851
 852         dissector_add_uint_with_preference("udp.port", BAT_BATMAN_PORT, batman_handle);
 853         dissector_add_uint_with_preference("udp.port", BAT_GW_PORT, gw_handle);
 854         dissector_add_uint_with_preference("udp.port", BAT_VIS_PORT, vis_handle);
 855 }
 856
 857 /*
 858  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 859  *
 860  * Local variables:
 861  * c-basic-offset: 8
 862  * tab-width: 8
 863  * indent-tabs-mode: t
 864  * End:
 865  *
 866  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 867  * :indentSize=8:tabSize=8:noTabs=false:
 868  */