plugins/docsis/packet-dcd.c

   1 /* packet-dcd.c
   2  * Routines for DCD Message dissection
   3  * Copyright 2004, Darryl Hymel <darryl.hymel[AT]arrisi.com>
   4  *
   5  * $Id$
   6  *
   7  * Wireshark - Network traffic analyzer
   8  * By Gerald Combs <gerald@wireshark.org>
   9  * Copyright 1998 Gerald Combs
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU General Public License
  13  * as published by the Free Software Foundation; either version 2
  14  * of the License, or (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30
  31 #include "moduleinfo.h"
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36
  37 #include <gmodule.h>
  38
  39 #include <epan/packet.h>
  40
  41 #define DCD_DOWN_CLASSIFIER 23
  42 #define DCD_DSG_RULE 50
  43 #define DCD_DSG_CONFIG 51
  44
  45 /* Define Downstrean Classifier subtypes
  46  * These are subtype of DCD_DOWN_CLASSIFIER (23)
  47  */
  48
  49 #define DCD_CFR_ID 2
  50 #define DCD_CFR_RULE_PRI 5
  51 #define DCD_CFR_IP_CLASSIFIER 9
  52
  53 /* Define IP Classifier sub-subtypes
  54  * These are subtypes of DCD_CFR_IP_CLASSIFIER (23.9)
  55  */
  56 #define DCD_CFR_IP_SOURCE_ADDR 3
  57 #define DCD_CFR_IP_SOURCE_MASK 4
  58 #define DCD_CFR_IP_DEST_ADDR 5
  59 #define DCD_CFR_IP_DEST_MASK 6
  60 #define DCD_CFR_TCPUDP_SRCPORT_START 7
  61 #define DCD_CFR_TCPUDP_SRCPORT_END 8
  62 #define DCD_CFR_TCPUDP_DSTPORT_START 9
  63 #define DCD_CFR_TCPUDP_DSTPORT_END 10
  64
  65 /* Define DSG Rule subtypes
  66  * These are subtype of DCD_DSG_RULE (50)
  67  */
  68
  69 #define DCD_RULE_ID 1
  70 #define DCD_RULE_PRI 2
  71 #define DCD_RULE_UCID_RNG 3
  72 #define DCD_RULE_CLIENT_ID 4
  73 #define DCD_RULE_TUNL_ADDR 5
  74 #define DCD_RULE_CFR_ID 6
  75 #define DCD_RULE_VENDOR_SPEC 43
  76 /* Define DSG Rule Client ID sub-subtypes
  77  * These are subtypes of DCD_RULE_CLIENT_ID (50.4)
  78  */
  79 #define DCD_CLID_BCAST_ID 1
  80 #define DCD_CLID_KNOWN_MAC_ADDR 2
  81 #define DCD_CLID_CA_SYS_ID 3
  82 #define DCD_CLID_APP_ID 4
  83
  84 /* Define DSG Configuration subtypes
  85  * These are subtype of DCD_DSG_CONFIG (51)
  86  */
  87
  88 #define DCD_CFG_CHAN_LST 1
  89 #define DCD_CFG_TDSG1 2
  90 #define DCD_CFG_TDSG2 3
  91 #define DCD_CFG_TDSG3 4
  92 #define DCD_CFG_TDSG4 5
  93 #define DCD_CFG_VENDOR_SPEC 43
  94
  95 /* Initialize the protocol and registered fields */
  96 static int proto_docsis_dcd = -1;
  97
  98 static int hf_docsis_dcd_config_ch_cnt = -1;
  99 static int hf_docsis_dcd_num_of_frag = -1;
 100 static int hf_docsis_dcd_frag_sequence_num = -1;
 101 static int hf_docsis_dcd_cfr_id = -1;
 102 static int hf_docsis_dcd_cfr_rule_pri = -1;
 103 static int hf_docsis_dcd_cfr_ip_source_addr = -1;
 104 static int hf_docsis_dcd_cfr_ip_source_mask = -1;
 105 static int hf_docsis_dcd_cfr_ip_dest_addr = -1;
 106 static int hf_docsis_dcd_cfr_ip_dest_mask = -1;
 107 static int hf_docsis_dcd_cfr_tcpudp_srcport_start = -1;
 108 static int hf_docsis_dcd_cfr_tcpudp_srcport_end = -1;
 109 static int hf_docsis_dcd_cfr_tcpudp_dstport_start = -1;
 110 static int hf_docsis_dcd_cfr_tcpudp_dstport_end = -1;
 111 static int hf_docsis_dcd_rule_id = -1;
 112 static int hf_docsis_dcd_rule_pri = -1;
 113 static int hf_docsis_dcd_rule_ucid_list = -1;
 114 static int hf_docsis_dcd_clid_known_mac_addr = -1;
 115 static int hf_docsis_dcd_clid_ca_sys_id = -1;
 116 static int hf_docsis_dcd_clid_app_id = -1;
 117 static int hf_docsis_dcd_rule_tunl_addr = -1;
 118 static int hf_docsis_dcd_rule_cfr_id = -1;
 119 static int hf_docsis_dcd_rule_vendor_spec = -1;
 120 static int hf_docsis_dcd_cfg_chan = -1;
 121 static int hf_docsis_dcd_cfg_tdsg1 = -1;
 122 static int hf_docsis_dcd_cfg_tdsg2 = -1;
 123 static int hf_docsis_dcd_cfg_tdsg3 = -1;
 124 static int hf_docsis_dcd_cfg_tdsg4 = -1;
 125 static int hf_docsis_dcd_cfg_vendor_spec = -1;
 126
 127 /* Initialize the subtree pointers */
 128 static gint ett_docsis_dcd = -1;
 129 static gint ett_docsis_dcd_cfr = -1;
 130 static gint ett_docsis_dcd_cfr_ip = -1;
 131 static gint ett_docsis_dcd_rule = -1;
 132 static gint ett_docsis_dcd_clid = -1;
 133 static gint ett_docsis_dcd_cfg = -1;
 134
 135 /* Code to actually dissect the packets */
 136 static void
 137 dissect_dcd_dsg_cfg (tvbuff_t * tvb, proto_tree * tree, int start, guint16 len)
 138 {
 139   guint8 type, length;
 140   proto_item *dcd_item;
 141   proto_tree *dcd_tree;
 142   int pos;
 143
 144   pos = start;
 145   dcd_item = proto_tree_add_text ( tree, tvb, start, len, "51 DCD DSG Config Encodings (Length = %u)", len);
 146   dcd_tree = proto_item_add_subtree ( dcd_item , ett_docsis_dcd_cfg);
 147
 148   while ( pos < ( start + len) )
 149     {
 150         type = tvb_get_guint8 (tvb, pos++);
 151         length = tvb_get_guint8 (tvb, pos++);
 152
 153         switch (type)
 154           {
 155             case DCD_CFG_CHAN_LST:
 156               if (length == 4)
 157                 {
 158                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfg_chan, tvb,
 159                                        pos, length, FALSE);
 160                 }
 161               else
 162                 {
 163                   THROW (ReportedBoundsError);
 164                 }
 165               break;
 166             case DCD_CFG_TDSG1:
 167               if (length == 2)
 168                 {
 169                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfg_tdsg1, tvb,
 170                                    pos, length, FALSE);
 171                 }
 172               else
 173                 {
 174                   THROW (ReportedBoundsError);
 175                 }
 176               break;
 177             case DCD_CFG_TDSG2:
 178               if (length == 2)
 179                 {
 180                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfg_tdsg2, tvb,
 181                                    pos, length, FALSE);
 182                 }
 183               else
 184                 {
 185                   THROW (ReportedBoundsError);
 186                 }
 187               break;
 188             case DCD_CFG_TDSG3:
 189               if (length == 2)
 190                 {
 191                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfg_tdsg3, tvb,
 192                                    pos, length, FALSE);
 193                 }
 194               else
 195                 {
 196                   THROW (ReportedBoundsError);
 197                 }
 198               break;
 199             case DCD_CFG_TDSG4:
 200               if (length == 2)
 201                 {
 202                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfg_tdsg4, tvb,
 203                                    pos, length, FALSE);
 204                 }
 205               else
 206                 {
 207                   THROW (ReportedBoundsError);
 208                 }
 209               break;
 210             case DCD_CFG_VENDOR_SPEC:
 211                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfg_vendor_spec, tvb,
 212                                    pos, length, FALSE);
 213               break;
 214
 215             }
 216           pos = pos + length;
 217       }
 218 }
 219 static void
 220 dissect_dcd_down_classifier_ip (tvbuff_t * tvb, proto_tree * tree, int start, guint16 len)
 221 {
 222   guint8 type, length;
 223   proto_item *dcd_item;
 224   proto_tree *dcd_tree;
 225   int pos;
 226
 227   pos = start;
 228   dcd_item = proto_tree_add_text ( tree, tvb, start, len, "23.9 DCD_CFR_IP Encodings (Length = %u)", len);
 229   dcd_tree = proto_item_add_subtree ( dcd_item , ett_docsis_dcd_cfr_ip);
 230
 231   while ( pos < ( start + len) )
 232     {
 233         type = tvb_get_guint8 (tvb, pos++);
 234         length = tvb_get_guint8 (tvb, pos++);
 235
 236         switch (type)
 237           {
 238             case DCD_CFR_IP_SOURCE_ADDR:
 239               if (length == 4)
 240                 {
 241                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfr_ip_source_addr, tvb,
 242                                        pos, length, FALSE);
 243                 }
 244               else
 245                 {
 246                   THROW (ReportedBoundsError);
 247                 }
 248               break;
 249             case DCD_CFR_IP_SOURCE_MASK:
 250               if (length == 4)
 251                 {
 252                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfr_ip_source_mask, tvb,
 253                                        pos, length, FALSE);
 254                 }
 255               else
 256                 {
 257                   THROW (ReportedBoundsError);
 258                 }
 259               break;
 260             case DCD_CFR_IP_DEST_ADDR:
 261               if (length == 4)
 262                 {
 263                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfr_ip_dest_addr, tvb,
 264                                        pos, length, FALSE);
 265                 }
 266               else
 267                 {
 268                   THROW (ReportedBoundsError);
 269                 }
 270                 break;
 271             case DCD_CFR_IP_DEST_MASK:
 272               if (length == 4)
 273                 {
 274                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfr_ip_dest_mask, tvb,
 275                                        pos, length, FALSE);
 276                 }
 277               else
 278                 {
 279                   THROW (ReportedBoundsError);
 280                 }
 281                 break;
 282             case DCD_CFR_TCPUDP_SRCPORT_START:
 283               if (length == 2)
 284                 {
 285                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfr_tcpudp_srcport_start, tvb,
 286                                        pos, length, FALSE);
 287                 }
 288               else
 289                 {
 290                   THROW (ReportedBoundsError);
 291                 }
 292                 break;
 293             case DCD_CFR_TCPUDP_SRCPORT_END:
 294               if (length == 2)
 295                 {
 296                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfr_tcpudp_srcport_end, tvb,
 297                                        pos, length, FALSE);
 298                 }
 299               else
 300                 {
 301                   THROW (ReportedBoundsError);
 302                 }
 303                 break;
 304             case DCD_CFR_TCPUDP_DSTPORT_START:
 305               if (length == 2)
 306                 {
 307                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfr_tcpudp_dstport_start, tvb,
 308                                        pos, length, FALSE);
 309                 }
 310               else
 311                 {
 312                   THROW (ReportedBoundsError);
 313                 }
 314                 break;
 315             case DCD_CFR_TCPUDP_DSTPORT_END:
 316               if (length == 2)
 317                 {
 318                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfr_tcpudp_dstport_end, tvb,
 319                                        pos, length, FALSE);
 320                 }
 321               else
 322                 {
 323                   THROW (ReportedBoundsError);
 324                 }
 325                 break;
 326             }
 327           pos = pos + length;
 328       }
 329 }
 330 static void
 331 dissect_dcd_clid (tvbuff_t * tvb, proto_tree * tree, int start, guint16 len)
 332 {
 333   guint8 type, length;
 334   proto_item *dcd_item;
 335   proto_tree *dcd_tree;
 336   int pos;
 337
 338   pos = start;
 339   dcd_item = proto_tree_add_text ( tree, tvb, start, len, "50.4 DCD Rule ClientID Encodings (Length = %u)", len);
 340   dcd_tree = proto_item_add_subtree ( dcd_item , ett_docsis_dcd_clid);
 341
 342   while ( pos < ( start + len) )
 343     {
 344         type = tvb_get_guint8 (tvb, pos++);
 345         length = tvb_get_guint8 (tvb, pos++);
 346
 347         switch (type)
 348           {
 349             case DCD_CLID_KNOWN_MAC_ADDR:
 350               if (length == 6)
 351                 {
 352                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_clid_known_mac_addr, tvb,
 353                                        pos, length, FALSE);
 354                 }
 355               else
 356                 {
 357                   THROW (ReportedBoundsError);
 358                 }
 359               break;
 360             case DCD_CLID_CA_SYS_ID:
 361               if (length == 2)
 362                 {
 363                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_clid_ca_sys_id, tvb,
 364                                        pos, length, FALSE);
 365                 }
 366               else
 367                 {
 368                   THROW (ReportedBoundsError);
 369                 }
 370               break;
 371             case DCD_CLID_APP_ID:
 372               if (length == 2)
 373                 {
 374                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_clid_app_id, tvb,
 375                                        pos, length, FALSE);
 376                 }
 377               else
 378                 {
 379                   THROW (ReportedBoundsError);
 380                 }
 381                 break;
 382             }
 383           pos = pos + length;
 384       }
 385 }
 386 static void
 387 dissect_dcd_dsg_rule (tvbuff_t * tvb, proto_tree * tree, int start, guint16 len)
 388 {
 389   guint8 type, length;
 390   proto_item *dcd_item;
 391   proto_tree *dcd_tree;
 392   int pos;
 393
 394   pos = start;
 395   dcd_item = proto_tree_add_text ( tree, tvb, start, len, "50 DCD DSG Rule Encodings (Length = %u)", len);
 396   dcd_tree = proto_item_add_subtree ( dcd_item , ett_docsis_dcd_rule);
 397
 398   while ( pos < ( start + len) )
 399     {
 400         type = tvb_get_guint8 (tvb, pos++);
 401         length = tvb_get_guint8 (tvb, pos++);
 402
 403         switch (type)
 404           {
 405             case DCD_RULE_ID:
 406               if (length == 1)
 407                 {
 408                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_rule_id, tvb,
 409                                        pos, length, FALSE);
 410                 }
 411               else
 412                 {
 413                   THROW (ReportedBoundsError);
 414                 }
 415               break;
 416             case DCD_RULE_PRI:
 417               if (length == 1)
 418                 {
 419                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_rule_pri, tvb,
 420                                    pos, length, FALSE);
 421                 }
 422               else
 423                 {
 424                   THROW (ReportedBoundsError);
 425                 }
 426               break;
 427             case DCD_RULE_UCID_RNG:
 428                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_rule_ucid_list, tvb,
 429                                    pos, length, FALSE);
 430               break;
 431             case DCD_RULE_CLIENT_ID:
 432               dissect_dcd_clid (tvb , dcd_tree , pos , length );
 433               break;
 434             case DCD_RULE_TUNL_ADDR:
 435               if (length == 6)
 436                 {
 437                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_rule_tunl_addr, tvb,
 438                                    pos, length, FALSE);
 439                 }
 440               else
 441                 {
 442                   THROW (ReportedBoundsError);
 443                 }
 444               break;
 445             case DCD_RULE_CFR_ID:
 446               if (length == 2)
 447                 {
 448                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_rule_cfr_id, tvb,
 449                                    pos, length, FALSE);
 450                 }
 451               else
 452                 {
 453                   THROW (ReportedBoundsError);
 454                 }
 455               break;
 456             case DCD_RULE_VENDOR_SPEC:
 457                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_rule_vendor_spec, tvb,
 458                                    pos, length, FALSE);
 459               break;
 460
 461             }
 462           pos = pos + length;
 463       }
 464 }
 465 static void
 466 dissect_dcd_down_classifier (tvbuff_t * tvb, proto_tree * tree, int start, guint16 len)
 467 {
 468   guint8 type, length;
 469   proto_item *dcd_item;
 470   proto_tree *dcd_tree;
 471   int pos;
 472
 473   pos = start;
 474   dcd_item = proto_tree_add_text ( tree, tvb, start, len, "23 DCD_CFR Encodings (Length = %u)", len);
 475   dcd_tree = proto_item_add_subtree ( dcd_item , ett_docsis_dcd_cfr);
 476
 477   while ( pos < ( start + len) )
 478     {
 479         type = tvb_get_guint8 (tvb, pos++);
 480         length = tvb_get_guint8 (tvb, pos++);
 481
 482         switch (type)
 483           {
 484             case DCD_CFR_ID:
 485               if (length == 2)
 486                 {
 487                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfr_id, tvb,
 488                                        pos, length, FALSE);
 489                 }
 490               else
 491                 {
 492                   THROW (ReportedBoundsError);
 493                 }
 494               break;
 495             case DCD_CFR_RULE_PRI:
 496               if (length == 1)
 497                 {
 498                   proto_tree_add_item (dcd_tree, hf_docsis_dcd_cfr_rule_pri, tvb,
 499                                    pos, length, FALSE);
 500                 }
 501               else
 502                 {
 503                   THROW (ReportedBoundsError);
 504                 }
 505               break;
 506             case DCD_CFR_IP_CLASSIFIER:
 507               dissect_dcd_down_classifier_ip (tvb , dcd_tree , pos , length );
 508               break;
 509
 510             }
 511           pos = pos + length;
 512       }
 513 }
 514 static void
 515 dissect_dcd (tvbuff_t * tvb, packet_info * pinfo, proto_tree * tree)
 516 {
 517   guint16 pos;
 518   guint8 type, length;
 519   proto_tree *dcd_tree;
 520   proto_item *dcd_item;
 521   guint16 len;
 522
 523   len = tvb_length_remaining (tvb, 0);
 524
 525   if (check_col (pinfo->cinfo, COL_INFO))
 526     {
 527       col_clear (pinfo->cinfo, COL_INFO);
 528       col_add_fstr (pinfo->cinfo, COL_INFO,"DCD Message: ");
 529     }
 530
 531   if (tree)
 532     {
 533       dcd_item =
 534         proto_tree_add_protocol_format (tree, proto_docsis_dcd, tvb, 0,
 535                                         tvb_length_remaining (tvb, 0),
 536                                         "DCD Message");
 537       dcd_tree = proto_item_add_subtree (dcd_item, ett_docsis_dcd);
 538       proto_tree_add_item (dcd_tree, hf_docsis_dcd_config_ch_cnt, tvb, 0, 1, FALSE);
 539       proto_tree_add_item (dcd_tree, hf_docsis_dcd_num_of_frag, tvb, 1, 1, FALSE);
 540       proto_tree_add_item (dcd_tree, hf_docsis_dcd_frag_sequence_num, tvb, 2, 1, FALSE);
 541
 542       pos = 3;
 543       while (pos < len)
 544         {
 545           type = tvb_get_guint8 (tvb, pos++);
 546           length = tvb_get_guint8 (tvb, pos++);
 547           switch (type)
 548             {
 549             case DCD_DOWN_CLASSIFIER:
 550               dissect_dcd_down_classifier (tvb , dcd_tree , pos , length );
 551               break;
 552             case DCD_DSG_RULE:
 553               dissect_dcd_dsg_rule (tvb , dcd_tree , pos , length );
 554               break;
 555             case DCD_DSG_CONFIG:
 556               dissect_dcd_dsg_cfg (tvb , dcd_tree , pos , length );
 557               break;
 558             }                   /* switch(type) */
 559           pos = pos + length;
 560         }                       /* while (pos < len) */
 561     }                           /* if (tree) */
 562
 563 }
 564 /* Register the protocol with Wireshark */
 565
 566 /* this format is require because a script is used to build the C function
 567    that calls all the protocol registration.
 568 */
 569
 570
 571 void
 572 proto_register_docsis_dcd (void)
 573 {
 574 /* Setup list of header fields  See Section 1.6.1 for details*/
 575   static hf_register_info hf[] = {
 576     {&hf_docsis_dcd_config_ch_cnt,
 577       {
 578       "Configuration Change Count",
 579       "docsis_dcd.config_ch_cnt",
 580       FT_UINT8, BASE_DEC, NULL, 0x0,
 581       NULL,
 582       HFILL
 583       }
 584     },
 585     {&hf_docsis_dcd_num_of_frag,
 586       {
 587       "Number of Fragments",
 588       "docsis_dcd.num_of_frag",
 589       FT_UINT8, BASE_DEC, NULL, 0x0,
 590       NULL,
 591       HFILL
 592       }
 593     },
 594     {&hf_docsis_dcd_frag_sequence_num,
 595       {
 596       "Fragment Sequence Number",
 597       "docsis_dcd.frag_sequence_num",
 598       FT_UINT8, BASE_DEC, NULL, 0x0,
 599       NULL,
 600       HFILL
 601       }
 602     },
 603     {&hf_docsis_dcd_cfr_id,
 604       {
 605       "Downstream Classifier Id",
 606       "docsis_dcd.cfr_id",
 607       FT_UINT16, BASE_DEC, NULL, 0x0,
 608       NULL,
 609       HFILL
 610       }
 611     },
 612     {&hf_docsis_dcd_cfr_rule_pri,
 613       {
 614       "Downstream Classifier Rule Priority",
 615       "docsis_dcd.cfr_rule_pri",
 616       FT_UINT8, BASE_DEC, NULL, 0x0,
 617       NULL,
 618       HFILL
 619       }
 620     },
 621     {&hf_docsis_dcd_cfr_ip_source_addr,
 622       {
 623       "Downstream Classifier IP Source Address",
 624       "docsis_dcd.cfr_ip_source_addr",
 625       FT_IPv4, BASE_NONE, NULL, 0x0,
 626       NULL,
 627       HFILL
 628       }
 629     },
 630     {&hf_docsis_dcd_cfr_ip_source_mask,
 631       {
 632       "Downstream Classifier IP Source Mask",
 633       "docsis_dcd.cfr_ip_source_mask",
 634       FT_IPv4, BASE_NONE, NULL, 0x0,
 635       NULL,
 636       HFILL
 637       }
 638     },
 639     {&hf_docsis_dcd_cfr_ip_dest_addr,
 640       {
 641       "Downstream Classifier IP Destination Address",
 642       "docsis_dcd.cfr_ip_dest_addr",
 643       FT_IPv4, BASE_NONE, NULL, 0x0,
 644       NULL,
 645       HFILL
 646       }
 647     },
 648     {&hf_docsis_dcd_cfr_ip_dest_mask,
 649       {
 650       "Downstream Classifier IP Destination Mask",
 651       "docsis_dcd.cfr_ip_dest_mask",
 652       FT_IPv4, BASE_NONE, NULL, 0x0,
 653       "Downstream Classifier IP Destination Address",
 654       HFILL
 655       }
 656     },
 657     {&hf_docsis_dcd_cfr_tcpudp_srcport_start,
 658       {
 659       "Downstream Classifier IP TCP/UDP Source Port Start",
 660       "docsis_dcd.cfr_ip_tcpudp_srcport_start",
 661       FT_UINT16, BASE_DEC, NULL, 0x0,
 662       NULL,
 663       HFILL
 664       }
 665     },
 666     {&hf_docsis_dcd_cfr_tcpudp_srcport_end,
 667       {
 668       "Downstream Classifier IP TCP/UDP Source Port End",
 669       "docsis_dcd.cfr_ip_tcpudp_srcport_end",
 670       FT_UINT16, BASE_DEC, NULL, 0x0,
 671       NULL,
 672       HFILL
 673       }
 674     },
 675     {&hf_docsis_dcd_cfr_tcpudp_dstport_start,
 676       {
 677       "Downstream Classifier IP TCP/UDP Destination Port Start",
 678       "docsis_dcd.cfr_ip_tcpudp_dstport_start",
 679       FT_UINT16, BASE_DEC, NULL, 0x0,
 680       NULL,
 681       HFILL
 682       }
 683     },
 684     {&hf_docsis_dcd_cfr_tcpudp_dstport_end,
 685       {
 686       "Downstream Classifier IP TCP/UDP Destination Port End",
 687       "docsis_dcd.cfr_ip_tcpudp_dstport_end",
 688       FT_UINT16, BASE_DEC, NULL, 0x0,
 689       NULL,
 690       HFILL
 691       }
 692     },
 693     {&hf_docsis_dcd_rule_id,
 694       {
 695       "DSG Rule Id",
 696       "docsis_dcd.rule_id",
 697       FT_UINT8, BASE_DEC, NULL, 0x0,
 698       NULL,
 699       HFILL
 700       }
 701     },
 702     {&hf_docsis_dcd_rule_pri,
 703       {
 704       "DSG Rule Priority",
 705       "docsis_dcd.rule_pri",
 706       FT_UINT8, BASE_DEC, NULL, 0x0,
 707       NULL,
 708       HFILL
 709       }
 710     },
 711     {&hf_docsis_dcd_rule_ucid_list,
 712       {
 713       "DSG Rule UCID Range",
 714       "docsis_dcd.rule_ucid_list",
 715       FT_BYTES, BASE_NONE, NULL, 0x0,
 716       NULL,
 717       HFILL
 718       }
 719     },
 720     {&hf_docsis_dcd_clid_known_mac_addr,
 721       {
 722       "DSG Rule Client ID Known MAC Address",
 723       "docsis_dcd.clid_known_mac_addr",
 724       FT_ETHER, BASE_DEC, NULL, 0x0,
 725       NULL,
 726       HFILL
 727       }
 728     },
 729     {&hf_docsis_dcd_clid_ca_sys_id,
 730       {
 731       "DSG Rule Client ID CA System ID",
 732       "docsis_dcd.clid_ca_sys_id",
 733       FT_UINT16, BASE_DEC, NULL, 0x0,
 734       NULL,
 735       HFILL
 736       }
 737     },
 738     {&hf_docsis_dcd_clid_app_id,
 739       {
 740       "DSG Rule Client ID Application ID",
 741       "docsis_dcd.clid_app_id",
 742       FT_UINT16, BASE_DEC, NULL, 0x0,
 743       NULL,
 744       HFILL
 745       }
 746     },
 747     {&hf_docsis_dcd_rule_tunl_addr,
 748       {
 749       "DSG Rule Tunnel MAC Address",
 750       "docsis_dcd.rule_tunl_addr",
 751       FT_ETHER, BASE_DEC, NULL, 0x0,
 752       NULL,
 753       HFILL
 754       }
 755     },
 756     {&hf_docsis_dcd_rule_cfr_id,
 757       {
 758       "DSG Rule Classifier ID",
 759       "docsis_dcd.rule_cfr_id",
 760       FT_UINT16, BASE_DEC, NULL, 0x0,
 761       NULL,
 762       HFILL
 763       }
 764     },
 765     {&hf_docsis_dcd_rule_vendor_spec,
 766       {
 767       "DSG Rule Vendor Specific Parameters",
 768       "docsis_dcd.rule_vendor_spec",
 769       FT_BYTES, BASE_NONE, NULL, 0x0,
 770       NULL,
 771       HFILL
 772       }
 773     },
 774     {&hf_docsis_dcd_cfg_chan,
 775       {
 776       "DSG Configuration Channel",
 777       "docsis_dcd.cfg_chan",
 778       FT_UINT32, BASE_DEC, NULL, 0x0,
 779       NULL,
 780       HFILL
 781       }
 782     },
 783     {&hf_docsis_dcd_cfg_tdsg1,
 784       {
 785       "DSG Initialization Timeout (Tdsg1)",
 786       "docsis_dcd.cfg_tdsg1",
 787       FT_UINT16, BASE_DEC, NULL, 0x0,
 788       NULL,
 789       HFILL
 790       }
 791     },
 792     {&hf_docsis_dcd_cfg_tdsg2,
 793       {
 794       "DSG Operational Timeout (Tdsg2)",
 795       "docsis_dcd.cfg_tdsg2",
 796       FT_UINT16, BASE_DEC, NULL, 0x0,
 797       NULL,
 798       HFILL
 799       }
 800     },
 801     {&hf_docsis_dcd_cfg_tdsg3,
 802       {
 803       "DSG Two-Way Retry Timer (Tdsg3)",
 804       "docsis_dcd.cfg_tdsg3",
 805       FT_UINT16, BASE_DEC, NULL, 0x0,
 806       NULL,
 807       HFILL
 808       }
 809     },
 810     {&hf_docsis_dcd_cfg_tdsg4,
 811       {
 812       "DSG One-Way Retry Timer (Tdsg4)",
 813       "docsis_dcd.cfg_tdsg4",
 814       FT_UINT16, BASE_DEC, NULL, 0x0,
 815       NULL,
 816       HFILL
 817       }
 818     },
 819     {&hf_docsis_dcd_cfg_vendor_spec,
 820       {
 821       "DSG Configuration Vendor Specific Parameters",
 822       "docsis_dcd.cfg_vendor_spec",
 823       FT_BYTES, BASE_NONE, NULL, 0x0,
 824       NULL,
 825       HFILL
 826       }
 827     },
 828
 829   };
 830
 831 /* Setup protocol subtree array */
 832   static gint *ett[] = {
 833     &ett_docsis_dcd,
 834     &ett_docsis_dcd_cfr,
 835     &ett_docsis_dcd_cfr_ip,
 836     &ett_docsis_dcd_rule,
 837     &ett_docsis_dcd_clid,
 838     &ett_docsis_dcd_cfg,
 839   };
 840
 841 /* Register the protocol name and description */
 842   proto_docsis_dcd =
 843     proto_register_protocol ("DOCSIS Downstream Channel Descriptor ",
 844                              "DOCSIS DCD", "docsis_dcd");
 845
 846 /* Required function calls to register the header fields and subtrees used */
 847   proto_register_field_array (proto_docsis_dcd, hf, array_length (hf));
 848   proto_register_subtree_array (ett, array_length (ett));
 849
 850   register_dissector ("docsis_dcd", dissect_dcd, proto_docsis_dcd);
 851 }
 852
 853
 854 /* If this dissector uses sub-dissector registration add a registration routine.
 855    This format is required because a script is used to find these routines and
 856    create the code that calls these routines.
 857 */
 858 void
 859 proto_reg_handoff_docsis_dcd (void)
 860 {
 861   dissector_handle_t docsis_dcd_handle;
 862
 863   docsis_dcd_handle = find_dissector ("docsis_dcd");
 864   dissector_add ("docsis_mgmt", 0x20, docsis_dcd_handle);
 865
 866 }