packet-dvmrp.c

   1 /* packet-dvmrp.c   2001 Ronnie Sahlberg <rsahlber@bigpond.net.au>
   2  * Routines for IGMP/DVMRP packet disassembly
   3  *
   4  * $Id: packet-dvmrp.c,v 1.3 2001/10/30 21:31:15 guy Exp $
   5  *
   6  * Ethereal - Network traffic analyzer
   7  * By Gerald Combs <gerald@ethereal.com>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24 /*
  25
  26
  27                         DVMRP   DVMRP
  28         code            v1      v3
  29
  30         0x01            *       *
  31         0x02            *       *
  32         0x03            x
  33         0x04            x
  34         0x07                    x
  35         0x08                    x
  36         0x09                    x
  37
  38
  39         * V3 has len>=8 and byte[6]==0xff and byte[7]==0x03
  40
  41
  42         DVMRP is defined in the following RFCs
  43         RFC1075 Version 1
  44         draft-ietf-idmr-dvmrp-v3-10.txt Version 3
  45
  46         V1 and V3 can be distinguished by looking at bytes 6 and 7 in the
  47         IGMP/DVMRP header.
  48         If header[6]==0xff and header[7]==0x03 we have version 3.
  49
  50
  51         RFC1075 has typos in 3.12.2 and 3.12.4, see if you can spot them.
  52 */
  53
  54 #ifdef HAVE_CONFIG_H
  55 # include "config.h"
  56 #endif
  57
  58 #ifdef HAVE_SYS_TYPES_H
  59 # include <sys/types.h>
  60 #endif
  61
  62 #include <stdio.h>
  63 #include <string.h>
  64 #include <glib.h>
  65
  66 #include "packet.h"
  67 #include "ipproto.h"
  68 #include "in_cksum.h"
  69 #include "packet-dvmrp.h"
  70
  71 static int proto_dvmrp = -1;
  72 static int hf_version = -1;
  73 static int hf_type = -1;
  74 static int hf_code_v1 = -1;
  75 static int hf_checksum = -1;
  76 static int hf_checksum_bad = -1;
  77 static int hf_commands = -1;
  78 static int hf_command = -1;
  79 static int hf_count = -1;
  80 static int hf_afi = -1;
  81 static int hf_netmask = -1;
  82 static int hf_metric = -1;
  83 static int hf_dest_unr = -1;
  84 static int hf_split_horiz = -1;
  85 static int hf_infinity = -1;
  86 static int hf_daddr = -1;
  87 static int hf_maddr = -1;
  88 static int hf_hold = -1;
  89 static int hf_code_v3 = -1;
  90 static int hf_capabilities = -1;
  91 static int hf_cap_leaf = -1;
  92 static int hf_cap_prune = -1;
  93 static int hf_cap_genid = -1;
  94 static int hf_cap_mtrace = -1;
  95 static int hf_cap_snmp = -1;
  96 static int hf_cap_netmask = -1;
  97 static int hf_min_ver = -1;
  98 static int hf_maj_ver = -1;
  99 static int hf_genid = -1;
 100 static int hf_naddr = -1;
 101 static int hf_route = -1;
 102 static int hf_saddr = -1;
 103 static int hf_life = -1;
 104 static int hf_neighbor = -1;
 105
 106 static int ett_dvmrp = -1;
 107 static int ett_commands = -1;
 108 static int ett_capabilities = -1;
 109 static int ett_route = -1;
 110
 111
 112 #define DVMRP_TYPE                              0x13
 113 static const value_string dvmrp_type[] = {
 114         {DVMRP_TYPE,    "DVMRP" },
 115         {0,             NULL}
 116 };
 117
 118 #define DVMRP_V1_RESPONSE                       1
 119 #define DVMRP_V1_REQUEST                        2
 120 #define DVMRP_V1_NON_MEMBERSHIP_REPORT          3
 121 #define DVMRP_V1_NON_MEMBERSHIP_CANCELLATION    4
 122 static const value_string code_v1[] = {
 123         {DVMRP_V1_RESPONSE,                     "Response"                      },
 124         {DVMRP_V1_REQUEST,                      "Request"                       },
 125         {DVMRP_V1_NON_MEMBERSHIP_REPORT,        "Non-membership report"         },
 126         {DVMRP_V1_NON_MEMBERSHIP_CANCELLATION,  "Non-membership cancellation"   },
 127         {0,                                     NULL}
 128 };
 129
 130 #define DVMRP_V3_PROBE                          1
 131 #define DVMRP_V3_REPORT                         2
 132 #define DVMRP_V3_PRUNE                          7
 133 #define DVMRP_V3_GRAFT                          8
 134 #define DVMRP_V3_GRAFT_ACK                      9
 135 static const value_string code_v3[] = {
 136         {DVMRP_V3_PROBE,        "Probe"},
 137         {DVMRP_V3_REPORT,       "Report"},
 138         {DVMRP_V3_PRUNE,        "Prune"},
 139         {DVMRP_V3_GRAFT,        "Graft"},
 140         {DVMRP_V3_GRAFT_ACK,    "Graft ACK"},
 141         {0,                     NULL}
 142 };
 143
 144 #define DVMRP_V3_CAP_LEAF       0x01
 145 #define DVMRP_V3_CAP_PRUNE      0x02
 146 #define DVMRP_V3_CAP_GENID      0x04
 147 #define DVMRP_V3_CAP_MTRACE     0x08
 148 #define DVMRP_V3_CAP_SNMP       0x10
 149 #define DVMRP_V3_CAP_NETMASK    0x20
 150
 151
 152 #define V1_COMMAND_NULL         0
 153 #define V1_COMMAND_AFI          2
 154 #define V1_COMMAND_SUBNETMASK   3
 155 #define V1_COMMAND_METRIC       4
 156 #define V1_COMMAND_FLAGS0       5
 157 #define V1_COMMAND_INFINITY     6
 158 #define V1_COMMAND_DA           7
 159 #define V1_COMMAND_RDA          8
 160 #define V1_COMMAND_NMR          9
 161 #define V1_COMMAND_NMR_CANCEL   10
 162 static const value_string command[] = {
 163         {V1_COMMAND_NULL,       "NULL"  },
 164         {V1_COMMAND_AFI,        "Address Family Indicator"},
 165         {V1_COMMAND_SUBNETMASK, "Subnetmask"},
 166         {V1_COMMAND_METRIC,     "Metric"},
 167         {V1_COMMAND_FLAGS0,     "Flags0"},
 168         {V1_COMMAND_INFINITY,   "Infinity"},
 169         {V1_COMMAND_DA,         "Destination Address"},
 170         {V1_COMMAND_RDA,        "Requested Destination Address"},
 171         {V1_COMMAND_NMR,        "Non-Membership Report"},
 172         {V1_COMMAND_NMR_CANCEL, "Non-Membership Report Cancel"},
 173         {0,                     NULL}
 174 };
 175
 176 #define V1_AFI_IP               2
 177 static const value_string afi[] = {
 178         {V1_AFI_IP,     "IP v4 Family"},
 179         {0,             NULL}
 180 };
 181
 182 static const true_false_string tfs_dest_unreach = {
 183         "Destination Unreachable",
 184         "NOT Destination Unreachable"
 185 };
 186
 187 static const true_false_string tfs_split_horiz = {
 188         "Split Horizon concealed route",
 189         "NOT Split Horizon concealed route"
 190 };
 191
 192 static const true_false_string tfs_cap_leaf = {
 193         "Leaf",
 194         "NOT Leaf"
 195 };
 196 static const true_false_string tfs_cap_prune = {
 197         "Prune capable",
 198         "NOT Prune capable"
 199 };
 200 static const true_false_string tfs_cap_genid = {
 201         "Genid capable",
 202         "NOT Genid capable"
 203 };
 204 static const true_false_string tfs_cap_mtrace = {
 205         "Multicast Traceroute capable",
 206         "NOT Multicast Traceroute capable"
 207 };
 208 static const true_false_string tfs_cap_snmp = {
 209         "SNMP capable",
 210         "NOT SNMP capable"
 211 };
 212 static const true_false_string tfs_cap_netmask = {
 213         "Netmask capable",
 214         "NOT Netmask capable"
 215 };
 216
 217 static void dvmrp_checksum(proto_tree *tree,tvbuff_t *tvb, int len)
 218 {
 219         guint16 cksum,hdrcksum;
 220         vec_t cksum_vec[1];
 221
 222         cksum_vec[0].ptr = tvb_get_ptr(tvb, 0, len);
 223         cksum_vec[0].len = len;
 224
 225         hdrcksum = tvb_get_ntohs(tvb, 2);
 226         cksum = in_cksum(&cksum_vec[0],1);
 227
 228         if (cksum==0) {
 229                 proto_tree_add_uint_format(tree, hf_checksum, tvb, 2, 2, hdrcksum, "Header checksum: 0x%04x (correct)", hdrcksum);
 230         } else {
 231                 proto_tree_add_item_hidden(tree, hf_checksum_bad, tvb, 2, 2, TRUE);
 232                 proto_tree_add_uint_format(tree, hf_checksum, tvb, 2, 2, hdrcksum, "Header checksum: 0x%04x (incorrect, should be 0x%04x)", hdrcksum,in_cksum_shouldbe(hdrcksum,cksum));
 233         }
 234
 235         return;
 236 }
 237
 238
 239
 240 int
 241 dissect_v3_report(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset)
 242 {
 243         guint8 m0,m1,m2,m3;
 244         guint8 s0,s1,s2,s3;
 245         guint8 metric;
 246         guint32 ip;
 247
 248         while (tvb_reported_length_remaining(tvb, offset) > 0) {
 249                 proto_tree *tree;
 250                 proto_item *item;
 251                 int old_offset = offset;
 252
 253                 item = proto_tree_add_item(parent_tree, hf_route,
 254                                 tvb, offset, 0, FALSE);
 255                 tree = proto_item_add_subtree(item, ett_route);
 256
 257                 m0 = 0xff;
 258                 /* read the mask */
 259                 m1 = tvb_get_guint8(tvb, offset);
 260                 m2 = tvb_get_guint8(tvb, offset+1);
 261                 m3 = tvb_get_guint8(tvb, offset+2);
 262
 263                 ip = m3;
 264                 ip = (ip<<8)|m2;
 265                 ip = (ip<<8)|m1;
 266                 ip = (ip<<8)|m0;
 267                 proto_tree_add_ipv4(tree, hf_netmask, tvb, offset, 3, ip);
 268
 269                 offset += 3;
 270
 271                 /* read every srcnet, metric  pairs */
 272                 do {
 273                         int old_offset = offset;
 274                         m0 = 0xff;
 275
 276                         s0 = 0;
 277                         s1 = 0;
 278                         s2 = 0;
 279                         s3 = 0;
 280
 281                         s0 = tvb_get_guint8(tvb, offset);
 282                         offset += 1;
 283                         if (m1) {
 284                                 s1 = tvb_get_guint8(tvb, offset);
 285                                 offset += 1;
 286                         }
 287                         if (m2) {
 288                                 s2 = tvb_get_guint8(tvb, offset);
 289                                 offset += 1;
 290                         }
 291                         if (m3) {
 292                                 s3 = tvb_get_guint8(tvb, offset);
 293                                 offset += 1;
 294                         }
 295
 296                         /* handle special case for default route V3/3.4.3 */
 297                         if ((!m1)&&(!m2)&&(!m3)&&(!s0)) {
 298                                 m0 = 0;
 299                         }
 300
 301                         ip = s3;
 302                         ip = (ip<<8)|s2;
 303                         ip = (ip<<8)|s1;
 304                         ip = (ip<<8)|s0;
 305                         proto_tree_add_ipv4_format(tree, hf_saddr, tvb,
 306                                 old_offset, offset-old_offset, ip,
 307                                 "%s %d.%d.%d.%d (netmask %d.%d.%d.%d)",
 308                                 m0?"Source Network":"Default Route",
 309                                 s0,s1,s2,s3,m0,m1,m2,m3);
 310
 311                         metric = tvb_get_guint8(tvb, offset);
 312                         proto_tree_add_uint(tree, hf_metric, tvb,
 313                                 offset, 1, metric&0x7f);
 314                         offset += 1;
 315
 316
 317                 } while (!(metric&0x80));
 318
 319                 proto_item_set_len(item, offset-old_offset);
 320         }
 321
 322         return offset;
 323 }
 324
 325 int
 326 dissect_dvmrp_v3(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset)
 327 {
 328         guint8 code,count;
 329
 330         /* version */
 331         proto_tree_add_uint(parent_tree, hf_version, tvb, 0, 0, 3);
 332
 333         /* type of command */
 334         proto_tree_add_uint(parent_tree, hf_type, tvb, offset, 1, 0x13);
 335         offset += 1;
 336
 337         /* code */
 338         code = tvb_get_guint8(tvb, offset);
 339         proto_tree_add_uint(parent_tree, hf_code_v3, tvb, offset, 1, code);
 340         offset += 1;
 341         if (check_col(pinfo->fd, COL_INFO)) {
 342                 col_add_fstr(pinfo->fd, COL_INFO,
 343                         "V%d %s",3 ,val_to_str(code, code_v3,
 344                                 "Unknown Type:0x%02x"));
 345         }
 346
 347         /* checksum */
 348         dvmrp_checksum(parent_tree, tvb, tvb_length_remaining(tvb, 0));
 349         offset += 2;
 350
 351         /* skip unused byte */
 352         offset += 1;
 353
 354         /* PROBE packets have capabilities flags, unused for other packets */
 355         if (code==DVMRP_V3_PROBE) {
 356                 proto_tree *tree;
 357                 proto_item *item;
 358
 359                 item = proto_tree_add_item(parent_tree, hf_capabilities,
 360                                 tvb, offset, 1, FALSE);
 361                 tree = proto_item_add_subtree(item, ett_capabilities);
 362
 363                 count = tvb_get_guint8(tvb, offset);
 364                 proto_tree_add_boolean(tree, hf_cap_netmask, tvb, offset, 1, count);
 365                 proto_tree_add_boolean(tree, hf_cap_snmp, tvb, offset, 1, count);
 366                 proto_tree_add_boolean(tree, hf_cap_mtrace, tvb, offset, 1, count);
 367                 proto_tree_add_boolean(tree, hf_cap_genid, tvb, offset, 1, count);
 368                 proto_tree_add_boolean(tree, hf_cap_prune, tvb, offset, 1, count);
 369                 proto_tree_add_boolean(tree, hf_cap_leaf, tvb, offset, 1, count);
 370         }
 371         offset += 1;
 372
 373         /* minor version */
 374         proto_tree_add_item(parent_tree, hf_min_ver, tvb, offset, 1, FALSE);
 375         offset += 1;
 376
 377         /* major version */
 378         proto_tree_add_item(parent_tree, hf_maj_ver, tvb, offset, 1, FALSE);
 379         offset += 1;
 380
 381         switch (code) {
 382         case DVMRP_V3_PROBE:
 383                 /* generation id */
 384                 proto_tree_add_item(parent_tree, hf_genid, tvb,
 385                         offset, 4, FALSE);
 386                 offset += 4;
 387                 while (tvb_reported_length_remaining(tvb, offset) > 0) {
 388                         proto_tree_add_item(parent_tree, hf_neighbor,
 389                                 tvb, offset, 4, FALSE);
 390                         offset += 4;
 391                 }
 392                 break;
 393         case DVMRP_V3_REPORT:
 394                 offset = dissect_v3_report(tvb, pinfo, parent_tree, offset);
 395                 break;
 396         case DVMRP_V3_PRUNE:
 397                 /* source address */
 398                 proto_tree_add_item(parent_tree, hf_saddr,
 399                         tvb, offset, 4, FALSE);
 400                 offset += 4;
 401                 /* group address */
 402                 proto_tree_add_item(parent_tree, hf_maddr,
 403                         tvb, offset, 4, FALSE);
 404                 offset += 4;
 405                 /* prune lifetime */
 406                 proto_tree_add_item(parent_tree, hf_life,
 407                         tvb, offset, 4, FALSE);
 408                 offset += 4;
 409                 /* source netmask */
 410                 if (tvb_reported_length_remaining(tvb, offset)>=4) {
 411                         proto_tree_add_item(parent_tree, hf_netmask,
 412                                 tvb, offset, 4, FALSE);
 413                         offset += 4;
 414                 }
 415                 break;
 416         case DVMRP_V3_GRAFT:
 417                 /* source address */
 418                 proto_tree_add_item(parent_tree, hf_saddr,
 419                         tvb, offset, 4, FALSE);
 420                 offset += 4;
 421                 /* group address */
 422                 proto_tree_add_item(parent_tree, hf_maddr,
 423                         tvb, offset, 4, FALSE);
 424                 offset += 4;
 425                 /* source netmask */
 426                 if (tvb_reported_length_remaining(tvb, offset)>=4) {
 427                         proto_tree_add_item(parent_tree, hf_netmask,
 428                                 tvb, offset, 4, FALSE);
 429                         offset += 4;
 430                 }
 431                 break;
 432         case DVMRP_V3_GRAFT_ACK:
 433                 /* source address */
 434                 proto_tree_add_item(parent_tree, hf_saddr,
 435                         tvb, offset, 4, FALSE);
 436                 offset += 4;
 437                 /* group address */
 438                 proto_tree_add_item(parent_tree, hf_maddr,
 439                         tvb, offset, 4, FALSE);
 440                 offset += 4;
 441                 /* source netmask */
 442                 if (tvb_reported_length_remaining(tvb, offset)>=4) {
 443                         proto_tree_add_item(parent_tree, hf_netmask,
 444                                 tvb, offset, 4, FALSE);
 445                         offset += 4;
 446                 }
 447                 break;
 448         }
 449
 450         return offset;
 451 }
 452
 453
 454 int
 455 dissect_dvmrp_v1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset)
 456 {
 457         guint8 code;
 458         guint8 af=2; /* default */
 459
 460         /* version */
 461         proto_tree_add_uint(parent_tree, hf_version, tvb, 0, 0, 1);
 462
 463         /* type of command */
 464         proto_tree_add_uint(parent_tree, hf_type, tvb, offset, 1, 0x13);
 465         offset += 1;
 466
 467         /* code */
 468         code = tvb_get_guint8(tvb, offset);
 469         proto_tree_add_uint(parent_tree, hf_code_v1, tvb, offset, 1, code);
 470         offset += 1;
 471         if (check_col(pinfo->fd, COL_INFO)) {
 472                 col_add_fstr(pinfo->fd, COL_INFO,
 473                         "V%d %s",1 ,val_to_str(code, code_v1,
 474                                 "Unknown Type:0x%02x"));
 475         }
 476
 477         /* checksum */
 478         dvmrp_checksum(parent_tree, tvb, tvb_length_remaining(tvb, 0));
 479         offset += 2;
 480
 481         /* decode all the v1 commands */
 482         while (tvb_length_remaining(tvb, offset)) {
 483                 proto_tree *tree;
 484                 proto_item *item;
 485                 guint8 cmd,count;
 486                 int old_offset = offset;
 487
 488                 item = proto_tree_add_item(parent_tree, hf_commands,
 489                                 tvb, offset, 0, FALSE);
 490                 tree = proto_item_add_subtree(item, ett_commands);
 491
 492                 cmd = tvb_get_guint8(tvb, offset);
 493                 proto_tree_add_uint(tree, hf_command, tvb,
 494                         offset, 1, cmd);
 495                 offset += 1;
 496
 497                 switch (cmd){
 498                 case V1_COMMAND_NULL:
 499                         offset += 1; /* skip ignored/pad byte*/
 500                         if (item) {
 501                                 proto_item_set_text(item, "Command: NULL");
 502                         }
 503                         break;
 504                 case V1_COMMAND_AFI:
 505                         af = tvb_get_guint8(tvb, offset);
 506                         proto_tree_add_uint(tree, hf_afi, tvb,
 507                                 offset, 1, af);
 508                         offset += 1;
 509                         if (item) {
 510                                 proto_item_set_text(item, "%s: %s",
 511                                         val_to_str(cmd, command, "Unknown Command:0x%02x"),
 512                                         val_to_str(af, afi, "Unknown Family:0x%02x")
 513                                 );
 514                         }
 515                         break;
 516                 case V1_COMMAND_SUBNETMASK:
 517                         count = tvb_get_guint8(tvb, offset);
 518                         proto_tree_add_uint(tree, hf_count, tvb,
 519                                 offset, 1, count);
 520                         offset += 1;
 521                         if (count) { /* must be 0 or 1 */
 522                                 proto_tree_add_item(tree, hf_netmask,
 523                                         tvb, offset, 4, FALSE);
 524                                 if (item) {
 525                                         proto_item_set_text(item, "%s: %d.%d.%d.%d",
 526                                                 val_to_str(cmd, command, "Unknown Command:0x%02x"),
 527                                                 tvb_get_guint8(tvb, offset),
 528                                                 tvb_get_guint8(tvb, offset+1),
 529                                                 tvb_get_guint8(tvb, offset+2),
 530                                                 tvb_get_guint8(tvb, offset+3));
 531                                 }
 532                                 offset += 4;
 533                         } else {
 534                                 if (item) {
 535                                         proto_item_set_text(item, "%s: <no mask supplied>",
 536                                                 val_to_str(cmd, command, "Unknown Command:0x%02x"));
 537                                 }
 538                         }
 539                         break;
 540                 case V1_COMMAND_METRIC:
 541                         proto_tree_add_item(tree, hf_metric, tvb,
 542                                 offset, 1, FALSE);
 543                         if (item) {
 544                                 proto_item_set_text(item, "%s: %d",
 545                                         val_to_str(cmd, command, "Unknown Command:0x%02x"),
 546                                         tvb_get_guint8(tvb, offset));
 547                         }
 548                         offset += 1;
 549                         break;
 550                 case V1_COMMAND_FLAGS0:
 551                         count = tvb_get_guint8(tvb, offset);
 552                         proto_tree_add_boolean(tree, hf_dest_unr, tvb, offset, 1, count);
 553                         proto_tree_add_boolean(tree, hf_split_horiz, tvb, offset, 1, count);
 554                         if (item) {
 555                                 proto_item_set_text(item, "%s: 0x%02x",
 556                                         val_to_str(cmd, command, "Unknown Command:0x%02x"), count);
 557                         }
 558                         offset += 1;
 559                         break;
 560                 case V1_COMMAND_INFINITY:
 561                         proto_tree_add_item(tree, hf_infinity, tvb,
 562                                 offset, 1, FALSE);
 563                         if (item) {
 564                                 proto_item_set_text(item, "%s: %d",
 565                                         val_to_str(cmd, command, "Unknown Command:0x%02x"), tvb_get_guint8(tvb, offset));
 566                         }
 567                         offset += 1;
 568                         break;
 569                 case V1_COMMAND_DA:
 570                 case V1_COMMAND_RDA: /* same as DA */
 571                         count = tvb_get_guint8(tvb, offset);
 572                         proto_tree_add_uint(tree, hf_count, tvb,
 573                                 offset, 1, count);
 574                         offset += 1;
 575                         while (count--) {
 576                                 proto_tree_add_item(tree, hf_daddr,
 577                                         tvb, offset, 4, FALSE);
 578                                 offset += 4;
 579                         }
 580                         if (item) {
 581                                 proto_item_set_text(item, "%s",
 582                                         val_to_str(cmd, command, "Unknown Command:0x%02x"));
 583                         }
 584                         break;
 585                 case V1_COMMAND_NMR:
 586                         count = tvb_get_guint8(tvb, offset);
 587                         proto_tree_add_uint(tree, hf_count, tvb,
 588                                 offset, 1, count);
 589                         offset += 1;
 590                         while (count--) {
 591                                 proto_tree_add_item(tree, hf_maddr,
 592                                         tvb, offset, 4, FALSE);
 593                                 offset += 4;
 594                                 proto_tree_add_item(tree, hf_hold, tvb,
 595                                         offset, 4, FALSE);
 596                                 offset += 4;
 597                         }
 598                         if (item) {
 599                                 proto_item_set_text(item, "%s",
 600                                         val_to_str(cmd, command, "Unknown Command:0x%02x"));
 601                         }
 602                         break;
 603                 case V1_COMMAND_NMR_CANCEL:
 604                         count = tvb_get_guint8(tvb, offset);
 605                         proto_tree_add_uint(tree, hf_count, tvb,
 606                                 offset, 1, count);
 607                         offset += 1;
 608                         while (count--) {
 609                                 proto_tree_add_item(tree, hf_maddr,
 610                                         tvb, offset, 4, FALSE);
 611                                 offset += 4;
 612                         }
 613                         if (item) {
 614                                 proto_item_set_text(item, "%s",
 615                                         val_to_str(cmd, command, "Unknown Command:0x%02x"));
 616                         }
 617                         break;
 618                 }
 619
 620                 proto_item_set_len(item, offset-old_offset);
 621         }
 622
 623         return offset;
 624 }
 625
 626 /* This function is only called from the IGMP dissector */
 627 int
 628 dissect_dvmrp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, int offset)
 629 {
 630         proto_tree *tree;
 631         proto_item *item;
 632
 633         if (!proto_is_protocol_enabled(proto_dvmrp)) {
 634                 /* we are not enabled, skip entire packet to be nice
 635                    to the igmp layer. (so clicking on IGMP will display the data)
 636                  */
 637                 return offset+tvb_length_remaining(tvb, offset);
 638         }
 639
 640         item = proto_tree_add_item(parent_tree, proto_dvmrp, tvb, offset, 0, FALSE);
 641         tree = proto_item_add_subtree(item, ett_dvmrp);
 642
 643
 644         if (check_col(pinfo->fd, COL_PROTOCOL)) {
 645                 col_set_str(pinfo->fd, COL_PROTOCOL, "DVMRP");
 646         }
 647         if (check_col(pinfo->fd, COL_INFO)) {
 648                 col_clear(pinfo->fd, COL_INFO);
 649         }
 650
 651
 652         if ((tvb_length_remaining(tvb, offset)>=8)
 653          && (tvb_get_guint8(tvb, 6)==0xff)
 654          && (tvb_get_guint8(tvb, 7)==0x03)) {
 655                 offset = dissect_dvmrp_v3(tvb, pinfo, tree, offset);
 656                 proto_item_set_len(item, offset);
 657                 return offset;
 658         }
 659
 660
 661         offset = dissect_dvmrp_v1(tvb, pinfo, tree, offset);
 662         proto_item_set_len(item, offset);
 663         return offset;
 664 }
 665
 666 void
 667 proto_register_dvmrp(void)
 668 {
 669         static hf_register_info hf[] = {
 670                 { &hf_version,
 671                         { "DVMRP Version", "dvmrp.version", FT_UINT8, BASE_DEC,
 672                           NULL, 0, "DVMRP Version", HFILL }},
 673
 674                 { &hf_type,
 675                         { "Type", "dvmrp.type", FT_UINT8, BASE_HEX,
 676                           VALS(dvmrp_type), 0, "DVMRP Packet Type", HFILL }},
 677
 678                 { &hf_code_v1,
 679                         { "Code", "dvmrp.v1.code", FT_UINT8, BASE_HEX,
 680                           VALS(code_v1), 0, "DVMRP Packet Code", HFILL }},
 681
 682                 { &hf_checksum,
 683                         { "Checksum", "dvmrp.checksum", FT_UINT16, BASE_HEX,
 684                           NULL, 0, "DVMRP Checksum", HFILL }},
 685
 686                 { &hf_checksum_bad,
 687                         { "Bad Checksum", "dvmrp.checksum_bad", FT_BOOLEAN, BASE_NONE,
 688                           NULL, 0, "Bad DVMRP Checksum", HFILL }},
 689
 690                 { &hf_commands,
 691                         { "Commands", "dvmrp.commands", FT_NONE, BASE_NONE,
 692                           NULL, 0, "DVMRP V1 Commands", HFILL }},
 693
 694                 { &hf_command,
 695                         { "Command", "dvmrp.command", FT_UINT8, BASE_HEX,
 696                           VALS(command), 0, "DVMRP V1 Command", HFILL }},
 697
 698                 { &hf_afi,
 699                         { "Address Family", "dvmrp.afi", FT_UINT8, BASE_HEX,
 700                           VALS(afi), 0, "DVMRP Address Family Indicator", HFILL }},
 701
 702                 { &hf_count,
 703                         { "Count", "dvmrp.count", FT_UINT8, BASE_HEX,
 704                           NULL, 0, "Count", HFILL }},
 705
 706                 { &hf_netmask,
 707                         { "Netmask", "igmp.netmask", FT_IPv4, BASE_NONE,
 708                           NULL, 0, "DVMRP Netmask", HFILL }},
 709
 710                 { &hf_metric,
 711                         { "Metric", "dvmrp.metric", FT_UINT8, BASE_DEC,
 712                           NULL, 0, "DVMRP Metric", HFILL }},
 713
 714                 {&hf_dest_unr,
 715                         { "Destination Unreachable", "dvmrp.dest_unreach", FT_BOOLEAN, 8,
 716                         TFS(&tfs_dest_unreach), 0x01, "Destination Unreachable", HFILL }},
 717
 718                 {&hf_split_horiz,
 719                         { "Split Horizon", "dvmrp.split_horiz", FT_BOOLEAN, 8,
 720                         TFS(&tfs_split_horiz), 0x02, "Split Horizon concealed route", HFILL }},
 721
 722                 { &hf_infinity,
 723                         { "Infinity", "dvmrp.infinity", FT_UINT8, BASE_DEC,
 724                           NULL, 0, "DVMRP Infinity", HFILL }},
 725
 726                 { &hf_daddr,
 727                         { "Dest Addr", "igmp.daddr", FT_IPv4, BASE_NONE,
 728                           NULL, 0, "DVMRP Destination Address", HFILL }},
 729
 730                 { &hf_maddr,
 731                         { "Multicast Addr", "igmp.maddr", FT_IPv4, BASE_NONE,
 732                           NULL, 0, "DVMRP Multicast Address", HFILL }},
 733
 734                 { &hf_hold,
 735                         { "Hold Time", "dvmrp.hold", FT_UINT32, BASE_DEC,
 736                           NULL, 0, "DVMRP Hold Time in seconds", HFILL }},
 737
 738                 { &hf_code_v3,
 739                         { "Code", "dvmrp.v3.code", FT_UINT8, BASE_HEX,
 740                           VALS(code_v3), 0, "DVMRP Packet Code", HFILL }},
 741
 742                 { &hf_capabilities,
 743                         { "Capabilities", "dvmrp.capabilities", FT_NONE, BASE_NONE,
 744                           NULL, 0, "DVMRP V3 Capabilities", HFILL }},
 745
 746                 {&hf_cap_leaf,
 747                         { "Leaf", "dvmrp.cap.leaf", FT_BOOLEAN, 8,
 748                         TFS(&tfs_cap_leaf), DVMRP_V3_CAP_LEAF, "Leaf", HFILL }},
 749
 750                 {&hf_cap_prune,
 751                         { "Prune", "dvmrp.cap.prune", FT_BOOLEAN, 8,
 752                         TFS(&tfs_cap_prune), DVMRP_V3_CAP_PRUNE, "Prune capability", HFILL }},
 753
 754                 {&hf_cap_genid,
 755                         { "Genid", "dvmrp.cap.genid", FT_BOOLEAN, 8,
 756                         TFS(&tfs_cap_genid), DVMRP_V3_CAP_GENID, "Genid capability", HFILL }},
 757
 758                 {&hf_cap_mtrace,
 759                         { "Mtrace", "dvmrp.cap.mtrace", FT_BOOLEAN, 8,
 760                         TFS(&tfs_cap_mtrace), DVMRP_V3_CAP_MTRACE, "Mtrace capability", HFILL }},
 761
 762                 {&hf_cap_snmp,
 763                         { "SNMP", "dvmrp.cap.snmp", FT_BOOLEAN, 8,
 764                         TFS(&tfs_cap_snmp), DVMRP_V3_CAP_SNMP, "SNMP capability", HFILL }},
 765
 766                 {&hf_cap_netmask,
 767                         { "Netmask", "dvmrp.cap.netmask", FT_BOOLEAN, 8,
 768                         TFS(&tfs_cap_netmask), DVMRP_V3_CAP_NETMASK, "Netmask capability", HFILL }},
 769
 770                 { &hf_min_ver,
 771                         { "Minor Version", "dvmrp.min_ver", FT_UINT8, BASE_HEX,
 772                           NULL, 0, "DVMRP Minor Version", HFILL }},
 773
 774                 { &hf_maj_ver,
 775                         { "Major Version", "dvmrp.maj_ver", FT_UINT8, BASE_HEX,
 776                           NULL, 0, "DVMRP Major Version", HFILL }},
 777
 778                 { &hf_genid,
 779                         { "Generation ID", "dvmrp.genid", FT_UINT32, BASE_DEC,
 780                           NULL, 0, "DVMRP Generation ID", HFILL }},
 781
 782                 { &hf_naddr,
 783                         { "Neighbor Addr", "igmp.naddr", FT_IPv4, BASE_NONE,
 784                           NULL, 0, "DVMRP Neighbor Address", HFILL }},
 785
 786                 { &hf_route,
 787                         { "Route", "dvmrp.route", FT_NONE, BASE_NONE,
 788                           NULL, 0, "DVMRP V3 Route Report", HFILL }},
 789
 790                 { &hf_saddr,
 791                         { "Source Addr", "igmp.saddr", FT_IPv4, BASE_NONE,
 792                           NULL, 0, "DVMRP Source Address", HFILL }},
 793
 794                 { &hf_life,
 795                         { "Prune lifetime", "dvmrp.lifetime", FT_UINT32, BASE_DEC,
 796                           NULL, 0, "DVMRP Prune Lifetime", HFILL }},
 797
 798                 { &hf_neighbor,
 799                         { "Neighbor Addr", "igmp.neighbor", FT_IPv4, BASE_NONE,
 800                           NULL, 0, "DVMRP Neighbor Address", HFILL }},
 801
 802         };
 803         static gint *ett[] = {
 804                 &ett_dvmrp,
 805                 &ett_commands,
 806                 &ett_capabilities,
 807                 &ett_route,
 808         };
 809
 810         proto_dvmrp = proto_register_protocol("Distance Vector Multicast Routing Protocol",
 811             "DVMRP", "dvmrp");
 812         proto_register_field_array(proto_dvmrp, hf, array_length(hf));
 813         proto_register_subtree_array(ett, array_length(ett));
 814 }
 815