packet-trmac.c

   1 /* packet-trmac.c
   2  * Routines for Token-Ring Media Access Control
   3  * Gilbert Ramirez <gram@alumni.rice.edu>
   4  *
   5  * $Id: packet-trmac.c,v 1.38 2002/08/28 21:00:36 jmayer Exp $
   6  *
   7  * Ethereal - Network traffic analyzer
   8  * By Gerald Combs <gerald@ethereal.com>
   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 #include <string.h>
  31 #include <glib.h>
  32 #include <epan/packet.h>
  33 #include "packet-frame.h"
  34
  35 static int proto_trmac = -1;
  36 static int hf_trmac_mv = -1;
  37 static int hf_trmac_length = -1;
  38 static int hf_trmac_srcclass = -1;
  39 static int hf_trmac_dstclass = -1;
  40 static int hf_trmac_sv = -1;
  41 static int hf_trmac_errors_iso = -1;
  42 static int hf_trmac_errors_line = -1;
  43 static int hf_trmac_errors_internal = -1;
  44 static int hf_trmac_errors_burst = -1;
  45 static int hf_trmac_errors_ac = -1;
  46 static int hf_trmac_errors_abort = -1;
  47 static int hf_trmac_errors_noniso = -1;
  48 static int hf_trmac_errors_lost = -1;
  49 static int hf_trmac_errors_congestion = -1;
  50 static int hf_trmac_errors_fc = -1;
  51 static int hf_trmac_errors_freq = -1;
  52 static int hf_trmac_errors_token = -1;
  53 static int hf_trmac_naun = -1;
  54
  55 static gint ett_tr_mac = -1;
  56 static gint ett_tr_ierr_cnt = -1;
  57 static gint ett_tr_nerr_cnt = -1;
  58
  59 /* Major Vector */
  60 static value_string major_vector_vs[] = {
  61                 { 0x00, "Response" },
  62                 { 0x02, "Beacon" },
  63                 { 0x03, "Claim Token" },
  64                 { 0x04, "Ring Purge" },
  65                 { 0x05, "Active Monitor Present" },
  66                 { 0x06, "Standby Monitor Present" },
  67                 { 0x07, "Duplicate Address Test" },
  68                 { 0x09, "Transmit Forward" },
  69                 { 0x0B, "Remove Ring Station" },
  70                 { 0x0C, "Change Parameters" },
  71                 { 0x0D, "Initialize Ring Station" },
  72                 { 0x0E, "Request Ring Station Address" },
  73                 { 0x0F, "Request Ring Station Address" },
  74                 { 0x10, "Request Ring Station Attachments" },
  75                 { 0x20, "Request Initialization" },
  76                 { 0x22, "Report Ring Station Address" },
  77                 { 0x23, "Report Ring Station State" },
  78                 { 0x24, "Report Ring Station Attachments" },
  79                 { 0x25, "Report New Active Monitor" },
  80                 { 0x26, "Report NAUN Change" },
  81                 { 0x27, "Report Poll Error" },
  82                 { 0x28, "Report Monitor Errors" },
  83                 { 0x29, "Report Error" },
  84                 { 0x2A, "Report Transmit Forward" },
  85                 { 0x00, NULL }
  86 };
  87
  88 /* Src. and Dest. Classes */
  89 static value_string classes_vs[] = {
  90         { 0x00, "Ring Station" },
  91         { 0x01, "LLC Manager" },
  92         { 0x04, "Configuration Report Server" },
  93         { 0x05, "Ring Parameter Server" },
  94         { 0x06, "Ring Error Monitor" },
  95         { 0x00, NULL }
  96 };
  97
  98
  99 /* Sub-vectors */
 100 static int
 101 sv_text(tvbuff_t *tvb, int svoff, proto_tree *tree)
 102 {
 103         int     sv_length = tvb_get_guint8(tvb, svoff+0);
 104         guint16 beacon_type, ring;
 105
 106         char *beacon[] = {"Recovery mode set", "Signal loss error",
 107                 "Streaming signal not Claim Token MAC frame",
 108                 "Streaming signal, Claim Token MAC frame"};
 109
 110         proto_tree      *sv_tree;
 111         proto_item      *ti;
 112
 113         guchar          errors[6];      /* isolating or non-isolating */
 114
 115         /* Check the SV length.
 116            XXX - Should we do this in each case statement below, e.g. to force
 117            an SV length of 6 for the NAUN address? */
 118         if (sv_length < 1) {
 119                 proto_tree_add_protocol_format(tree, proto_malformed, tvb, svoff+0, 1,
 120                         "Invalid subvector length: %d bytes", sv_length);
 121                 return sv_length;
 122         }
 123
 124         /* this just adds to the clutter on the screen...
 125         proto_tree_add_text(tree, tvb, svoff, 1,
 126                 "Subvector Length: %d bytes", sv_length);*/
 127
 128         proto_tree_add_uint_hidden(tree, hf_trmac_sv, tvb, svoff+1, 1, tvb_get_guint8(tvb, svoff+1));
 129
 130         switch(tvb_get_guint8(tvb, svoff+1)) {
 131                 case 0x01: /* Beacon Type */
 132                         beacon_type = tvb_get_ntohs(tvb, svoff+2);
 133                         if (beacon_type < array_length(beacon)) {
 134                                 proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 135                                         "Beacon Type: %s", beacon[beacon_type] );
 136                         } else {
 137                                 proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 138                                         "Beacon Type: Illegal value: %d", beacon_type );
 139                         }
 140                         break;
 141
 142                 case 0x02: /* NAUN */
 143                         proto_tree_add_ether(tree, hf_trmac_naun, tvb, svoff+1, sv_length-1,
 144                                         tvb_get_ptr(tvb, svoff+2, 6));
 145                         break;
 146
 147                 case 0x03: /* Local Ring Number */
 148                         ring = tvb_get_ntohs(tvb, svoff+2);
 149                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 150                                 "Local Ring Number: 0x%04X (%d)", ring, ring);
 151                         break;
 152
 153                 case 0x04: /* Assign Physical Location */
 154                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 155                                 "Assign Physical Location: 0x%08X", tvb_get_ntohl(tvb, svoff+2) );
 156                         break;
 157
 158                 case 0x05: /* Soft Error Report Value */
 159                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 160                                 "Soft Error Report Value: %d ms", 10 * tvb_get_ntohs(tvb, svoff+2) );
 161                         break;
 162
 163                 case 0x06: /* Enabled Function Classes */
 164                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 165                                 "Enabled Function Classes: %04X",  tvb_get_ntohs(tvb, svoff+2) );
 166                         break;
 167
 168                 case 0x07: /* Allowed Access Priority */
 169                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 170                                 "Allowed Access Priority: %04X",  tvb_get_ntohs(tvb, svoff+2) );
 171                         break;
 172
 173                 case 0x09: /* Correlator */
 174                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 175                                 "Correlator: %04X",  tvb_get_ntohs(tvb, svoff+2) );
 176                         break;
 177
 178                 case 0x0A: /* Address of last neighbor notification */
 179                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 180                                 "Address of Last Neighbor Notification: %s",
 181                                 ether_to_str(tvb_get_ptr(tvb, svoff+2, 6)));
 182                         break;
 183
 184                 case 0x0B: /* Physical Location */
 185                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 186                                 "Physical Location: 0x%08X", tvb_get_ntohl(tvb, svoff+2) );
 187                         break;
 188
 189                 case 0x20: /* Response Code */
 190                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 191                                 "Response Code: 0x%04X 0x%04X", tvb_get_ntohl(tvb, svoff+2),
 192                                 tvb_get_ntohl(tvb, svoff+4) );
 193                         break;
 194
 195                 case 0x21: /* Reserved */
 196                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 197                                 "Reserved: 0x%04X", tvb_get_ntohs(tvb, svoff+2) );
 198                         break;
 199
 200                 case 0x22: /* Product Instance ID */
 201                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 202                                 "Product Instance ID: ...");
 203                         break;
 204
 205                 case 0x23: /* Ring Station Microcode Level */
 206                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 207                                 "Ring Station Microcode Level: ...");
 208                         break;
 209
 210                 case 0x26: /* Wrap data */
 211                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 212                                 "Wrap Data: ... (%d bytes)", sv_length - 2);
 213                         break;
 214
 215                 case 0x27: /* Frame Forward */
 216                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 217                                 "Frame Forward: ... (%d bytes)", sv_length - 2);
 218                         break;
 219
 220                 case 0x29: /* Ring Station Status Subvector */
 221                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 222                                 "Ring Station Status Subvector: ...");
 223                         break;
 224
 225                 case 0x2A: /* Transmit Status Code */
 226                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 227                                 "Transmit Status Code: %04X", tvb_get_ntohs(tvb, svoff+2) );
 228                         break;
 229
 230                 case 0x2B: /* Group Address */
 231                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 232                                 "Group Address: %08X", tvb_get_ntohl(tvb, svoff+2) );
 233                         break;
 234
 235                 case 0x2C: /* Functional Address */
 236                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 237                                 "Functional Address: %08X", tvb_get_ntohl(tvb, svoff+2) );
 238                         break;
 239
 240                 case 0x2D: /* Isolating Error Counts */
 241                         memcpy(errors, tvb_get_ptr(tvb, svoff+2, 6), 6);
 242                         ti = proto_tree_add_uint(tree, hf_trmac_errors_iso, tvb, svoff+1, sv_length-1,
 243                                 errors[0] + errors[1] + errors[2] + errors[3] + errors[4]);
 244                         sv_tree = proto_item_add_subtree(ti, ett_tr_ierr_cnt);
 245
 246                         proto_tree_add_uint(sv_tree, hf_trmac_errors_line, tvb, svoff+2, 1, errors[0]);
 247                         proto_tree_add_uint(sv_tree, hf_trmac_errors_internal, tvb, svoff+3, 1, errors[1]);
 248                         proto_tree_add_uint(sv_tree, hf_trmac_errors_burst, tvb, svoff+4, 1, errors[2]);
 249                         proto_tree_add_uint(sv_tree, hf_trmac_errors_ac, tvb, svoff+5, 1, errors[3]);
 250                         proto_tree_add_uint(sv_tree, hf_trmac_errors_abort, tvb, svoff+6, 1, errors[4]);
 251
 252                         break;
 253
 254                 case 0x2E: /* Non-Isolating Error Counts */
 255                         memcpy(errors, tvb_get_ptr(tvb, svoff+2, 6), 6);
 256                         ti = proto_tree_add_uint(tree, hf_trmac_errors_noniso, tvb, svoff+1, sv_length-1,
 257                                 errors[0] + errors[1] + errors[2] + errors[3] + errors[4]);
 258                         sv_tree = proto_item_add_subtree(ti, ett_tr_nerr_cnt);
 259
 260                         proto_tree_add_uint(sv_tree, hf_trmac_errors_lost, tvb, svoff+2, 1, errors[0]);
 261                         proto_tree_add_uint(sv_tree, hf_trmac_errors_congestion, tvb, svoff+3, 1, errors[1]);
 262                         proto_tree_add_uint(sv_tree, hf_trmac_errors_fc, tvb, svoff+4, 1, errors[2]);
 263                         proto_tree_add_uint(sv_tree, hf_trmac_errors_freq, tvb, svoff+5, 1, errors[3]);
 264                         proto_tree_add_uint(sv_tree, hf_trmac_errors_token, tvb, svoff+6, 1, errors[4]);
 265                         break;
 266
 267                 case 0x30: /* Error Code */
 268                         proto_tree_add_text(tree, tvb, svoff+1, sv_length-1,
 269                                 "Error Code: %04X", tvb_get_ntohs(tvb, svoff+2) );
 270                         break;
 271
 272                 default: /* Unknown */
 273                         proto_tree_add_text(tree, tvb, svoff+1, 1,
 274                                 "Unknown Sub-Vector: 0x%02X", tvb_get_guint8(tvb, svoff+1));
 275         }
 276         return sv_length;
 277 }
 278
 279 static void
 280 dissect_trmac(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 281 {
 282         proto_tree      *mac_tree = NULL;
 283         proto_item      *ti;
 284         int             mv_length, sv_offset, sv_additional;
 285         guint8          mv_val;
 286         char            *mv_text;
 287
 288         if (check_col(pinfo->cinfo, COL_PROTOCOL))
 289                 col_set_str(pinfo->cinfo, COL_PROTOCOL, "TR MAC");
 290         if (check_col(pinfo->cinfo, COL_INFO))
 291                 col_clear(pinfo->cinfo, COL_INFO);
 292
 293         mv_val = tvb_get_guint8(tvb, 3);
 294
 295         /* Interpret the major vector */
 296         mv_text = val_to_str(mv_val, major_vector_vs, "Unknown Major Vector: %d\n");
 297
 298         if (check_col(pinfo->cinfo, COL_INFO))
 299                 col_add_str(pinfo->cinfo, COL_INFO, mv_text);
 300
 301         if (tree) {
 302                 mv_length = tvb_get_ntohs(tvb, 0);
 303                 ti = proto_tree_add_item(tree, proto_trmac, tvb, 0, mv_length, FALSE);
 304                 mac_tree = proto_item_add_subtree(ti, ett_tr_mac);
 305
 306                 proto_tree_add_uint(mac_tree, hf_trmac_mv, tvb, 3, 1, mv_val);
 307                 proto_tree_add_uint_format(mac_tree, hf_trmac_length, tvb, 0, 2, mv_length,
 308                                 "Total Length: %d bytes", mv_length);
 309                 proto_tree_add_uint(mac_tree, hf_trmac_srcclass, tvb, 2, 1, tvb_get_guint8(tvb, 2) & 0x0f);
 310                 proto_tree_add_uint(mac_tree, hf_trmac_dstclass, tvb, 2, 1, tvb_get_guint8(tvb, 2) >> 4 );
 311
 312                 /* interpret the subvectors */
 313                 sv_offset = 4;
 314                 while (sv_offset < mv_length) {
 315                         sv_additional = sv_text(tvb, sv_offset, mac_tree);
 316
 317                         /* if this is a bad packet, we could get a 0-length added here,
 318                          * looping forever */
 319                         if (sv_additional > 0)
 320                                 sv_offset += sv_additional;
 321                         else
 322                                 break;
 323                 }
 324         }
 325 }
 326
 327 void
 328 proto_register_trmac(void)
 329 {
 330         static hf_register_info hf[] = {
 331                 { &hf_trmac_mv,
 332                 { "Major Vector",                       "trmac.mvec", FT_UINT8, BASE_HEX, major_vector_vs, 0x0,
 333                         "", HFILL }},
 334
 335                 { &hf_trmac_length,
 336                 { "Total Length",                       "trmac.length", FT_UINT8, BASE_DEC, NULL, 0x0,
 337                         "", HFILL }},
 338
 339                 { &hf_trmac_srcclass,
 340                 { "Source Class",                       "trmac.srcclass", FT_UINT8, BASE_HEX, classes_vs, 0x0,
 341                         "", HFILL }},
 342
 343                 { &hf_trmac_dstclass,
 344                 { "Destination Class",                  "trmac.dstclass", FT_UINT8, BASE_HEX, classes_vs, 0x0,
 345                         "", HFILL }},
 346
 347                 { &hf_trmac_sv,
 348                 { "Sub-Vector",                         "trmac.svec", FT_UINT8, BASE_HEX, NULL, 0x0,
 349                         "", HFILL }},
 350
 351                 { &hf_trmac_errors_iso,
 352                 { "Isolating Errors",                   "trmac.errors.iso", FT_UINT16, BASE_DEC, NULL, 0x0,
 353                         "", HFILL }},
 354
 355                 { &hf_trmac_errors_line,
 356                 { "Line Errors",                        "trmac.errors.line", FT_UINT8, BASE_DEC, NULL, 0x0,
 357                         "", HFILL }},
 358
 359                 { &hf_trmac_errors_internal,
 360                 { "Internal Errors",                    "trmac.errors.internal", FT_UINT8, BASE_DEC, NULL, 0x0,
 361                         "", HFILL }},
 362
 363                 { &hf_trmac_errors_burst,
 364                 { "Burst Errors",                       "trmac.errors.burst", FT_UINT8, BASE_DEC, NULL, 0x0,
 365                         "", HFILL }},
 366
 367                 { &hf_trmac_errors_ac,
 368                 { "A/C Errors",                         "trmac.errors.ac", FT_UINT8, BASE_DEC, NULL, 0x0,
 369                         "", HFILL }},
 370
 371                 { &hf_trmac_errors_abort,
 372                 { "Abort Delimiter Transmitted Errors", "trmac.errors.abort", FT_UINT8, BASE_DEC, NULL, 0x0,
 373                         "", HFILL }},
 374
 375                 { &hf_trmac_errors_noniso,
 376                 { "Non-Isolating Errors",               "trmac.errors.noniso", FT_UINT16, BASE_DEC, NULL, 0x0,
 377                         "", HFILL }},
 378
 379                 { &hf_trmac_errors_lost,
 380                 { "Lost Frame Errors",                  "trmac.errors.lost", FT_UINT8, BASE_DEC, NULL, 0x0,
 381                         "", HFILL }},
 382
 383                 { &hf_trmac_errors_congestion,
 384                 { "Receiver Congestion Errors",         "trmac.errors.congestion", FT_UINT8, BASE_DEC, NULL, 0x0,
 385                         "", HFILL }},
 386
 387                 { &hf_trmac_errors_fc,
 388                 { "Frame-Copied Errors",                "trmac.errors.fc", FT_UINT8, BASE_DEC, NULL, 0x0,
 389                         "", HFILL }},
 390
 391                 { &hf_trmac_errors_freq,
 392                 { "Frequency Errors",                   "trmac.errors.freq", FT_UINT8, BASE_DEC, NULL, 0x0,
 393                         "", HFILL }},
 394
 395                 { &hf_trmac_errors_token,
 396                 { "Token Errors",                       "trmac.errors.token", FT_UINT8, BASE_DEC, NULL, 0x0,
 397                         "", HFILL }},
 398
 399                 { &hf_trmac_naun,
 400                 { "NAUN",                               "trmac.naun", FT_ETHER, BASE_DEC, NULL, 0x0,
 401                         "", HFILL }},
 402         };
 403         static gint *ett[] = {
 404                 &ett_tr_mac,
 405                 &ett_tr_ierr_cnt,
 406                 &ett_tr_nerr_cnt,
 407         };
 408
 409         proto_trmac = proto_register_protocol("Token-Ring Media Access Control",
 410             "TR MAC", "trmac");
 411         proto_register_field_array(proto_trmac, hf, array_length(hf));
 412         proto_register_subtree_array(ett, array_length(ett));
 413
 414         register_dissector("trmac", dissect_trmac, proto_trmac);
 415 }