epan/dissectors/packet-sndcp.c

   1 /* packet-sndcp.c
   2  * Routines for Subnetwork Dependent Convergence Protocol (SNDCP) dissection
   3  * Copyright 2000, Christian Falckenberg <christian.falckenberg@nortelnetworks.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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24  */
  25
  26 #include "config.h"
  27
  28 #include <glib.h>
  29
  30 #include <epan/packet.h>
  31 #include <epan/reassemble.h>
  32
  33 /* Bitmasks for the bits in the address field
  34 */
  35 #define MASK_X      0x80
  36 #define MASK_F      0x40
  37 #define MASK_T      0x20
  38 #define MASK_M      0x10
  39
  40 /* Initialize the protocol and registered fields
  41 */
  42 static int proto_sndcp       = -1;
  43 static int hf_sndcp_x        = -1;
  44 static int hf_sndcp_f        = -1;
  45 static int hf_sndcp_t        = -1;
  46 static int hf_sndcp_m        = -1;
  47 static int hf_sndcp_nsapi    = -1;
  48 static int hf_sndcp_nsapib   = -1;
  49 static int hf_sndcp_dcomp    = -1;
  50 static int hf_sndcp_pcomp    = -1;
  51 static int hf_sndcp_segment  = -1;
  52 static int hf_sndcp_npdu1    = -1;
  53 static int hf_sndcp_npdu2    = -1;
  54
  55 /* These fields are used when reassembling N-PDU fragments
  56 */
  57 static int hf_npdu_fragments                    = -1;
  58 static int hf_npdu_fragment                     = -1;
  59 static int hf_npdu_fragment_overlap             = -1;
  60 static int hf_npdu_fragment_overlap_conflict    = -1;
  61 static int hf_npdu_fragment_multiple_tails      = -1;
  62 static int hf_npdu_fragment_too_long_fragment   = -1;
  63 static int hf_npdu_fragment_error               = -1;
  64 static int hf_npdu_fragment_count               = -1;
  65 static int hf_npdu_reassembled_in               = -1;
  66 static int hf_npdu_reassembled_length           = -1;
  67
  68 /* Initialize the subtree pointers
  69 */
  70 static gint ett_sndcp                   = -1;
  71 static gint ett_sndcp_address_field     = -1;
  72 static gint ett_sndcp_compression_field = -1;
  73 static gint ett_sndcp_npdu_field        = -1;
  74 static gint ett_npdu_fragment           = -1;
  75 static gint ett_npdu_fragments          = -1;
  76
  77 /* Structure needed for the fragmentation routines in reassemble.c
  78 */
  79 static const fragment_items npdu_frag_items = {
  80     &ett_npdu_fragment,
  81     &ett_npdu_fragments,
  82     &hf_npdu_fragments,
  83     &hf_npdu_fragment,
  84     &hf_npdu_fragment_overlap,
  85     &hf_npdu_fragment_overlap_conflict,
  86     &hf_npdu_fragment_multiple_tails,
  87     &hf_npdu_fragment_too_long_fragment,
  88     &hf_npdu_fragment_error,
  89     &hf_npdu_fragment_count,
  90     &hf_npdu_reassembled_in,
  91     &hf_npdu_reassembled_length,
  92     /* Reassembled data field */
  93     NULL,
  94     "fragments"
  95 };
  96
  97 /* dissectors for the data portion of this protocol
  98  */
  99 static dissector_handle_t data_handle;
 100 static dissector_handle_t ip_handle;
 101
 102 /* reassembly of N-PDU
 103  */
 104 static reassembly_table npdu_reassembly_table;
 105
 106 static void
 107 sndcp_defragment_init(void)
 108 {
 109   reassembly_table_init(&npdu_reassembly_table, &addresses_reassembly_table_functions);
 110 }
 111
 112 /* value strings
 113  */
 114 static const value_string nsapi_t[] = {
 115   {  0, "Escape mechanism for future extensions"},
 116   {  1, "Point-to-Multipoint (PTM-M) Information" },
 117   {  2, "Reserved for future use" },
 118   {  3, "Reserved for future use" },
 119   {  4, "Reserved for future use" },
 120   {  5, "Dynamically allocated"},
 121   {  6, "Dynamically allocated"},
 122   {  7, "Dynamically allocated"},
 123   {  8, "Dynamically allocated"},
 124   {  9, "Dynamically allocated"},
 125   { 10, "Dynamically allocated"},
 126   { 11, "Dynamically allocated"},
 127   { 12, "Dynamically allocated"},
 128   { 13, "Dynamically allocated"},
 129   { 14, "Dynamically allocated"},
 130   { 15, "Dynamically allocated"},
 131   {  0, NULL },
 132 };
 133
 134 static const value_string nsapi_abrv[] = {
 135   {  0, "0"},
 136   {  1, "PTM-M" },
 137   {  2, "2" },
 138   {  3, "3"},
 139   {  4, "4" },
 140   {  5, "DYN5" },
 141   {  6, "DYN6" },
 142   {  7, "DYN7" },
 143   {  8, "DYN8" },
 144   {  9, "DYN9" },
 145   { 10, "DYN10" },
 146   { 11, "DYN11" },
 147   { 12, "DYN12" },
 148   { 13, "DYN13" },
 149   { 14, "DYN14" },
 150   { 15, "DYN15" },
 151   {  0, NULL },
 152 };
 153
 154 static const value_string compression_vals[] = {
 155   {  0, "No compression"},
 156   {  1, "Pointer to selected protocol/data compression mechanism" },
 157   {  2, "Pointer to selected protocol/data compression mechanism" },
 158   {  3, "Pointer to selected protocol/data compression mechanism" },
 159   {  4, "Pointer to selected protocol/data compression mechanism" },
 160   {  5, "Pointer to selected protocol/data compression mechanism" },
 161   {  6, "Pointer to selected protocol/data compression mechanism" },
 162   {  7, "Pointer to selected protocol/data compression mechanism" },
 163   {  8, "Pointer to selected protocol/data compression mechanism" },
 164   {  9, "Pointer to selected protocol/data compression mechanism" },
 165   { 10, "Pointer to selected protocol/data compression mechanism" },
 166   { 11, "Pointer to selected protocol/data compression mechanism" },
 167   { 12, "Pointer to selected protocol/data compression mechanism" },
 168   { 13, "Pointer to selected protocol/data compression mechanism" },
 169   { 14, "Pointer to selected protocol/data compression mechanism" },
 170   { 15, "Pointer to selected protocol/data compression mechanism" },
 171   { 0, NULL },
 172 };
 173
 174 static const true_false_string x_bit = {
 175   "Invalid",
 176   "Set to 0 by transmitting SNDCP entity (ignored by receiver)"
 177 };
 178 static const true_false_string f_bit = {
 179   "This SN-PDU is the first segment of an N-PDU",
 180   "This SN-PDU is not the first segment of an N-PDU"
 181 };
 182 static const true_false_string t_bit = {
 183   "SN-UNITDATA PDU",
 184   "SN-DATA PDU"
 185 };
 186 static const true_false_string m_bit = {
 187   "Not the last segment of N-PDU, more segments to follow",
 188   "Last segment of N-PDU"
 189 };
 190
 191 /* Code to actually dissect the packets
 192 */
 193 static void
 194 dissect_sndcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 195 {
 196   guint8         addr_field, comp_field, npdu_field1, nsapi, dcomp=0, pcomp=0;
 197   guint16        offset=0, npdu=0, segment=0, npdu_field2;
 198   tvbuff_t      *next_tvb, *npdu_tvb;
 199   gint           len;
 200   gboolean       first, more_frags, unack;
 201
 202   /* Set up structures needed to add the protocol subtree and manage it
 203    */
 204   proto_item *ti, *address_field_item, *compression_field_item, *npdu_field_item;
 205   proto_tree *sndcp_tree = NULL, *address_field_tree, *compression_field_tree, *npdu_field_tree;
 206
 207   /* Make entries in Protocol column and clear Info column on summary display
 208    */
 209   col_set_str(pinfo->cinfo, COL_PROTOCOL, "SNDCP");
 210   col_clear(pinfo->cinfo, COL_INFO);
 211
 212   /* create display subtree for the protocol
 213    */
 214   if (tree) {
 215     ti         = proto_tree_add_item(tree, proto_sndcp, tvb, 0, -1, ENC_NA);
 216     sndcp_tree = proto_item_add_subtree(ti, ett_sndcp);
 217   }
 218
 219   /* get address field from next byte
 220    */
 221   addr_field = tvb_get_guint8(tvb,offset);
 222   nsapi      = addr_field & 0xF;
 223   first      = addr_field & MASK_F;
 224   more_frags = addr_field & MASK_M;
 225   unack      = addr_field & MASK_T;
 226
 227   /* add subtree for the address field
 228    */
 229   if (tree) {
 230     address_field_item = proto_tree_add_uint_format(sndcp_tree,hf_sndcp_nsapi,
 231                                                     tvb, offset,1, nsapi,
 232                                                     "Address field  NSAPI: %d", nsapi );
 233     address_field_tree = proto_item_add_subtree(address_field_item, ett_sndcp_address_field);
 234     proto_tree_add_boolean(address_field_tree, hf_sndcp_x, tvb,offset,1, addr_field );
 235     proto_tree_add_boolean(address_field_tree, hf_sndcp_f, tvb,offset,1, addr_field );
 236     proto_tree_add_boolean(address_field_tree, hf_sndcp_t, tvb,offset,1, addr_field );
 237     proto_tree_add_boolean(address_field_tree, hf_sndcp_m, tvb,offset,1, addr_field );
 238     proto_tree_add_uint(address_field_tree, hf_sndcp_nsapib, tvb, offset, 1, addr_field );
 239   }
 240   offset++;
 241
 242   /* get compression pointers from next byte if this is the first segment
 243    */
 244   if (first) {
 245     comp_field = tvb_get_guint8(tvb,offset);
 246     dcomp      = comp_field & 0xF0;
 247     pcomp      = comp_field & 0x0F;
 248
 249     /* add subtree for the compression field
 250      */
 251     if (tree) {
 252       if (!pcomp) {
 253         if (!dcomp) {
 254           compression_field_item = proto_tree_add_text(sndcp_tree, tvb, offset,1, "No compression");
 255         }
 256         else {
 257           compression_field_item = proto_tree_add_text(sndcp_tree, tvb, offset,1, "Data compression");
 258         }
 259       }
 260       else {
 261         if (!dcomp) {
 262           compression_field_item = proto_tree_add_text(sndcp_tree, tvb, offset,1, "Protocol compression");
 263         }
 264         else {
 265           compression_field_item = proto_tree_add_text(sndcp_tree, tvb, offset,1, "Data and Protocol compression");
 266         }
 267       }
 268       compression_field_tree = proto_item_add_subtree(compression_field_item, ett_sndcp_compression_field);
 269       proto_tree_add_uint(compression_field_tree, hf_sndcp_dcomp, tvb, offset, 1, comp_field );
 270       proto_tree_add_uint(compression_field_tree, hf_sndcp_pcomp, tvb, offset, 1, comp_field );
 271     }
 272     offset++;
 273
 274     /* get N-PDU number from next byte for acknowledged mode (only for first segment)
 275      */
 276     if (!unack) {
 277       npdu = npdu_field1 = tvb_get_guint8(tvb,offset);
 278       col_add_fstr(pinfo->cinfo, COL_INFO, "SN-DATA N-PDU %d", npdu_field1);
 279       if (tree) {
 280         npdu_field_item = proto_tree_add_text(sndcp_tree, tvb, offset,1, "Acknowledged mode, N-PDU %d", npdu_field1 );
 281         npdu_field_tree = proto_item_add_subtree(npdu_field_item, ett_sndcp_npdu_field);
 282         proto_tree_add_uint(npdu_field_tree, hf_sndcp_npdu1, tvb, offset, 1, npdu_field1 );
 283       }
 284       offset++;
 285     }
 286   }
 287
 288   /* get segment and N-PDU number from next two bytes for unacknowledged mode
 289    */
 290   if (unack) {
 291     npdu_field2     = tvb_get_ntohs(tvb, offset);
 292     segment         = (npdu_field2 & 0xF000) >> 12;
 293     npdu            = (npdu_field2 & 0x0FFF);
 294     col_add_fstr(pinfo->cinfo, COL_INFO, "SN-UNITDATA N-PDU %d (segment %d)", npdu, segment);
 295     if (tree) {
 296       npdu_field_item = proto_tree_add_text(sndcp_tree, tvb, offset,2, "Unacknowledged mode, N-PDU %d (segment %d)", npdu, segment );
 297       npdu_field_tree = proto_item_add_subtree(npdu_field_item, ett_sndcp_npdu_field);
 298       proto_tree_add_uint(npdu_field_tree, hf_sndcp_segment, tvb, offset, 2, npdu_field2 );
 299       proto_tree_add_uint(npdu_field_tree, hf_sndcp_npdu2, tvb, offset, 2, npdu_field2 );
 300     }
 301     offset         += 2;
 302   }
 303
 304   /* handle N-PDU data, reassemble if necessary
 305    */
 306   if (first && !more_frags) {
 307     next_tvb = tvb_new_subset_remaining (tvb, offset);
 308
 309     if (!dcomp && !pcomp) {
 310       call_dissector(ip_handle, next_tvb, pinfo, tree);
 311     }
 312     else {
 313       call_dissector(data_handle, next_tvb, pinfo, tree);
 314     }
 315   }
 316   else {
 317     /* Try reassembling fragments
 318      */
 319     fragment_head  *fd_npdu         = NULL;
 320     guint32         reassembled_in  = 0;
 321     gboolean        save_fragmented = pinfo->fragmented;
 322
 323     len = tvb_length_remaining(tvb, offset);
 324     if(len<=0){
 325         return;
 326     }
 327
 328     pinfo->fragmented = TRUE;
 329
 330     if (unack)
 331       fd_npdu  = fragment_add_seq_check(&npdu_reassembly_table, tvb, offset,
 332                                         pinfo, npdu, NULL, segment, len, more_frags);
 333     else
 334       fd_npdu  = fragment_add(&npdu_reassembly_table, tvb, offset, pinfo, npdu, NULL,
 335                               offset, len, more_frags);
 336
 337     npdu_tvb = process_reassembled_data(tvb, offset, pinfo,
 338                                         "Reassembled N-PDU", fd_npdu, &npdu_frag_items,
 339                                         NULL, sndcp_tree);
 340     if (fd_npdu) {
 341       /* Reassembled
 342        */
 343       reassembled_in = fd_npdu->reassembled_in;
 344       if (pinfo->fd->num == reassembled_in) {
 345         /* Reassembled in this very packet:
 346          * We can safely hand the tvb to the IP dissector
 347          */
 348         call_dissector(ip_handle, npdu_tvb, pinfo, tree);
 349       }
 350       else {
 351         /* Not reassembled in this packet
 352          */
 353         col_append_fstr(pinfo->cinfo, COL_INFO,
 354                           " (N-PDU payload reassembled in packet %u)",
 355                           fd_npdu->reassembled_in);
 356         if (tree) {
 357           proto_tree_add_text(sndcp_tree, tvb, offset, -1, "Payload");
 358         }
 359       }
 360     } else {
 361       /* Not reassembled yet, or not reassembled at all
 362        */
 363       if (unack)
 364         col_append_fstr(pinfo->cinfo, COL_INFO, " (Unreassembled fragment %u)", segment);
 365       else
 366         col_append_str(pinfo->cinfo, COL_INFO, " (Unreassembled fragment)");
 367
 368       if (tree) {
 369         proto_tree_add_text(sndcp_tree, tvb, offset, -1, "Payload");
 370       }
 371     }
 372     /* Now reset fragmentation information in pinfo
 373      */
 374     pinfo->fragmented = save_fragmented;
 375   }
 376 }
 377
 378
 379 /* Register the protocol with Wireshark
 380    this format is required because a script is used to build the C function
 381    that calls all the protocol registration.
 382 */
 383
 384 void
 385 proto_register_sndcp(void)
 386 {
 387   /* Setup list of header fields
 388    */
 389   static hf_register_info hf[] = {
 390     { &hf_sndcp_nsapi,
 391       { "NSAPI",
 392         "sndcp.nsapi",
 393         FT_UINT8, BASE_DEC, VALS(nsapi_abrv), 0x0,
 394         "Network Layer Service Access Point Identifier", HFILL
 395       }
 396     },
 397     { &hf_sndcp_x,
 398       { "Spare bit",
 399         "sndcp.x",
 400         FT_BOOLEAN,8, TFS(&x_bit), MASK_X,
 401         "Spare bit (should be 0)", HFILL
 402       }
 403     },
 404     { &hf_sndcp_f,
 405       { "First segment indicator bit",
 406         "sndcp.f",
 407         FT_BOOLEAN,8, TFS(&f_bit), MASK_F,
 408         NULL, HFILL
 409       }
 410     },
 411     { &hf_sndcp_t,
 412       { "Type",
 413         "sndcp.t",
 414         FT_BOOLEAN,8, TFS(&t_bit), MASK_T,
 415         "SN-PDU Type", HFILL
 416       }
 417     },
 418     { &hf_sndcp_m,
 419       { "More bit",
 420         "sndcp.m",
 421         FT_BOOLEAN,8, TFS(&m_bit), MASK_M,
 422         NULL, HFILL
 423       }
 424     },
 425     { &hf_sndcp_dcomp,
 426       { "DCOMP",
 427         "sndcp.dcomp",
 428         FT_UINT8, BASE_DEC, VALS(compression_vals), 0xF0,
 429         "Data compression coding", HFILL
 430       }
 431     },
 432     { &hf_sndcp_pcomp,
 433       { "PCOMP",
 434         "sndcp.pcomp",
 435         FT_UINT8, BASE_DEC, VALS(compression_vals), 0x0F,
 436         "Protocol compression coding", HFILL
 437       }
 438     },
 439     { &hf_sndcp_nsapib,
 440       { "NSAPI",
 441         "sndcp.nsapib",
 442         FT_UINT8, BASE_DEC , VALS(nsapi_t), 0xf,
 443         "Network Layer Service Access Point Identifier",HFILL
 444       }
 445     },
 446     { &hf_sndcp_segment,
 447       { "Segment",
 448         "sndcp.segment",
 449         FT_UINT16, BASE_DEC, NULL, 0xF000,
 450         "Segment number", HFILL
 451       }
 452     },
 453     { &hf_sndcp_npdu1,
 454       { "N-PDU",
 455         "sndcp.npdu",
 456         FT_UINT8, BASE_DEC, NULL, 0,
 457         NULL, HFILL
 458       }
 459     },
 460     { &hf_sndcp_npdu2,
 461       { "N-PDU",
 462         "sndcp.npdu",
 463         FT_UINT16, BASE_DEC, NULL, 0x0FFF,
 464         NULL, HFILL
 465       }
 466     },
 467
 468     /* Fragment fields
 469      */
 470     { &hf_npdu_fragment_overlap,
 471       { "Fragment overlap",
 472         "npdu.fragment.overlap",
 473         FT_BOOLEAN, BASE_NONE, NULL, 0x0,
 474         "Fragment overlaps with other fragments", HFILL
 475       }
 476     },
 477     { &hf_npdu_fragment_overlap_conflict,
 478       { "Conflicting data in fragment overlap",
 479         "npdu.fragment.overlap.conflict",
 480         FT_BOOLEAN, BASE_NONE, NULL, 0x0,
 481         "Overlapping fragments contained conflicting data", HFILL
 482       }
 483     },
 484     { &hf_npdu_fragment_multiple_tails,
 485       { "Multiple tail fragments found",
 486         "npdu.fragment.multipletails",
 487         FT_BOOLEAN, BASE_NONE, NULL, 0x0,
 488         "Several tails were found when defragmenting the packet", HFILL
 489       }
 490     },
 491     { &hf_npdu_fragment_too_long_fragment,
 492       { "Fragment too long",
 493         "npdu.fragment.toolongfragment",
 494         FT_BOOLEAN, BASE_NONE, NULL, 0x0,
 495         "Fragment contained data past end of packet", HFILL
 496       }
 497     },
 498     { &hf_npdu_fragment_error,
 499       { "Defragmentation error",
 500         "npdu.fragment.error",
 501         FT_FRAMENUM, BASE_NONE, NULL, 0x0,
 502         "Defragmentation error due to illegal fragments", HFILL
 503       }
 504     },
 505     { &hf_npdu_fragment_count,
 506       { "Fragment count",
 507         "npdu.fragment.count",
 508         FT_UINT32, BASE_DEC, NULL, 0x0,
 509         NULL, HFILL
 510       }
 511     },
 512     { &hf_npdu_reassembled_in,
 513       { "Reassembled in",
 514         "npdu.reassembled.in",
 515         FT_FRAMENUM, BASE_NONE, NULL, 0x0,
 516         "N-PDU fragments are reassembled in the given packet", HFILL
 517       }
 518     },
 519     { &hf_npdu_reassembled_length,
 520       { "Reassembled N-PDU length",
 521         "npdu.reassembled.length",
 522         FT_UINT32, BASE_DEC, NULL, 0x0,
 523         "The total length of the reassembled payload", HFILL
 524       }
 525     },
 526     { &hf_npdu_fragment,
 527       { "N-PDU Fragment",
 528         "npdu.fragment",
 529         FT_FRAMENUM, BASE_NONE, NULL, 0x0,
 530         NULL, HFILL
 531       }
 532     },
 533     { &hf_npdu_fragments,
 534       { "N-PDU Fragments",
 535         "npdu.fragments",
 536         FT_NONE, BASE_NONE, NULL, 0x0,
 537         NULL, HFILL
 538       }
 539     }
 540   };
 541
 542     /* Setup protocol subtree array */
 543   static gint *ett[] = {
 544     &ett_sndcp     ,
 545     &ett_sndcp_address_field,
 546     &ett_sndcp_compression_field,
 547     &ett_sndcp_npdu_field,
 548     &ett_npdu_fragment,
 549     &ett_npdu_fragments,
 550   };
 551
 552   /* Register the protocol name and description */
 553   proto_sndcp = proto_register_protocol("Subnetwork Dependent Convergence Protocol",
 554                                         "SNDCP", "sndcp");
 555
 556   /* Required function calls to register the header fields and subtrees used */
 557   proto_register_field_array(proto_sndcp, hf, array_length(hf));
 558   proto_register_subtree_array(ett, array_length(ett));
 559   register_dissector("sndcp", dissect_sndcp, proto_sndcp);
 560   register_init_routine(sndcp_defragment_init);
 561 }
 562
 563 /* If this dissector uses sub-dissector registration add a registration routine.
 564    This format is required because a script is used to find these routines and
 565    create the code that calls these routines.
 566 */
 567 void
 568 proto_reg_handoff_sndcp(void)
 569 {
 570   dissector_handle_t sndcp_handle;
 571
 572   sndcp_handle = find_dissector("sndcp");
 573
 574   /* Register SNDCP dissector with LLC layer for SAPI 3,5,9 and 11
 575    */
 576   dissector_add_uint("llcgprs.sapi",  3, sndcp_handle);
 577   dissector_add_uint("llcgprs.sapi",  5, sndcp_handle);
 578   dissector_add_uint("llcgprs.sapi",  9, sndcp_handle);
 579   dissector_add_uint("llcgprs.sapi", 11, sndcp_handle);
 580
 581   /* Find IP and data handle for upper layer dissectors
 582    */
 583   ip_handle   = find_dissector("ip");
 584   data_handle = find_dissector("data");
 585 }