packet-vines.c

   1 /* packet-vines.c
   2  * Routines for Banyan VINES protocol packet disassembly
   3  *
   4  * $Id: packet-vines.c,v 1.22 2001/01/06 08:44:03 guy Exp $
   5  *
   6  * Don Lafontaine <lafont02@cn.ca>
   7  *
   8  * Ethereal - Network traffic analyzer
   9  * By Gerald Combs <gerald@zing.org>
  10  * Copyright 1998 Gerald Combs
  11  * Joerg Mayer <jmayer@telemation.de>
  12  *
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  27  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #ifdef HAVE_SYS_TYPES_H
  34 #include <sys/types.h>
  35 #endif
  36
  37 #ifdef HAVE_NETINET_IN_H
  38 #include <netinet/in.h>
  39 #endif
  40
  41 #include <string.h>
  42 #include <glib.h>
  43 #include "etypes.h"
  44 #include "ppptypes.h"
  45 #include "packet.h"
  46 #include "packet-vines.h"
  47 #include "packet-ip.h"
  48
  49 #define UDP_PORT_VINES  573
  50
  51 static int proto_vines = -1;
  52 static int hf_vines_protocol = -1;
  53
  54 static gint ett_vines = -1;
  55
  56 static int proto_vines_frp = -1;
  57
  58 static gint ett_vines_frp = -1;
  59
  60 static int proto_vines_spp = -1;
  61
  62 static gint ett_vines_spp = -1;
  63
  64 static void dissect_vines_frp(tvbuff_t *, packet_info *, proto_tree *);
  65 #if 0
  66 static void dissect_vines_arp(tvbuff_t *, packet_info *, proto_tree *);
  67 static void dissect_vines_icp(tvbuff_t *, packet_info *, proto_tree *);
  68 static void dissect_vines_ipc(tvbuff_t *, packet_info *, proto_tree *);
  69 static void dissect_vines_rtp(tvbuff_t *, packet_info *, proto_tree *);
  70 #endif
  71 static void dissect_vines_spp(tvbuff_t *, packet_info *, proto_tree *);
  72 static void dissect_vines(tvbuff_t *, packet_info *, proto_tree *);
  73
  74 void
  75 capture_vines(const u_char *pd, int offset, packet_counts *ld)
  76 {
  77         ld->vines++;
  78 }
  79
  80 /* AFAIK Vines FRP (Fragmentation Protocol) is used on all media except
  81  * Ethernet and TR (and probably FDDI) - Fragmentation on these media types
  82  * is not possible
  83  * FIXME: Do we need to use this header with PPP too?
  84  */
  85 static void
  86 dissect_vines_frp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
  87 {
  88         guint8   vines_frp_ctrl;
  89         proto_tree *vines_frp_tree;
  90         proto_item *ti;
  91         gchar   frp_flags_str[32];
  92         tvbuff_t *next_tvb;
  93
  94         CHECK_DISPLAY_AS_DATA(proto_vines_frp, tvb, pinfo, tree);
  95
  96         pinfo->current_proto = "Vines FRP";
  97
  98         if (check_col(pinfo->fd, COL_PROTOCOL))
  99                 col_set_str(pinfo->fd, COL_PROTOCOL, "Vines FRP");
 100         if (check_col(pinfo->fd, COL_INFO))
 101                 col_clear(pinfo->fd, COL_INFO);
 102
 103         if (tree) {
 104                 ti = proto_tree_add_item(tree, proto_vines_frp, tvb, 0, 2,
 105                     FALSE);
 106                 vines_frp_tree = proto_item_add_subtree(ti, ett_vines_frp);
 107
 108                 vines_frp_ctrl = tvb_get_guint8(tvb, 0);
 109
 110                 /*
 111                  * 1: first fragment of vines packet
 112                  * 2: last fragment of vines packet
 113                  * 4 ... 80: unused
 114                  */
 115                 switch (vines_frp_ctrl) {
 116
 117                 case 0:
 118                         strcpy(frp_flags_str, "middle");
 119                         break;
 120
 121                 case 1:
 122                         strcpy(frp_flags_str, "first");
 123                         break;
 124
 125                 case 2:
 126                         strcpy(frp_flags_str, "last");
 127                         break;
 128
 129                 case 3:
 130                         strcpy(frp_flags_str, "only");
 131                         break;
 132
 133                 default:
 134                         strcpy(frp_flags_str, "please report: unknown");
 135                         break;
 136                 }
 137
 138                 proto_tree_add_text(vines_frp_tree, tvb, 0, 1,
 139                                     "Control Flags: 0x%02x = %s fragment",
 140                                     vines_frp_ctrl, frp_flags_str);
 141
 142                 proto_tree_add_text(vines_frp_tree, tvb, 1, 1,
 143                                     "Sequence Number: 0x%02x",
 144                                     tvb_get_guint8(tvb, 1));
 145         }
 146
 147         /* Decode the "real" Vines now */
 148         next_tvb = tvb_new_subset(tvb, 2, -1, -1);
 149         dissect_vines(tvb, pinfo, tree);
 150 }
 151
 152 void
 153 proto_register_vines_frp(void)
 154 {
 155         static gint *ett[] = {
 156                 &ett_vines_frp,
 157         };
 158
 159         proto_vines_frp = proto_register_protocol(
 160             "Banyan Vines Fragmentation Protocol", "Vines FRP", "vines_frp");
 161         proto_register_subtree_array(ett, array_length(ett));
 162 }
 163
 164 void
 165 proto_reg_handoff_vines_frp(void)
 166 {
 167         dissector_add("ip.proto", IP_PROTO_VINES, dissect_vines_frp);
 168
 169         /* XXX: AFAIK, src and dst port must be the same; should
 170            the dissector check for that? */
 171         dissector_add("udp.port", UDP_PORT_VINES, dissect_vines_frp);
 172 }
 173
 174 gchar *
 175 vines_addr_to_str(const guint8 *addrp)
 176 {
 177   static gchar  str[3][214];
 178   static gchar  *cur;
 179
 180   if (cur == &str[0][0]) {
 181     cur = &str[1][0];
 182   } else if (cur == &str[1][0]) {
 183     cur = &str[2][0];
 184   } else {
 185     cur = &str[0][0];
 186   }
 187
 188   sprintf(cur, "%08x.%04x", pntohl(&addrp[0]), pntohs(&addrp[4]));
 189   return cur;
 190 }
 191
 192 static void
 193 dissect_vines(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 194 {
 195         int         offset = 0;
 196         e_vip       viph;
 197         proto_tree *vip_tree;
 198         proto_item *ti;
 199 /*      gchar      tos_str[32]; */
 200         guint8     *dst_addr, *src_addr;
 201         int  is_broadcast = 0;
 202         int  hops = 0;
 203         tvbuff_t *next_tvb;
 204
 205         CHECK_DISPLAY_AS_DATA(proto_vines, tvb, pinfo, tree);
 206
 207         pinfo->current_proto = "Vines";
 208
 209         if (check_col(pinfo->fd, COL_PROTOCOL))
 210                 col_set_str(pinfo->fd, COL_PROTOCOL, "Vines");
 211         if (check_col(pinfo->fd, COL_INFO))
 212                 col_clear(pinfo->fd, COL_INFO);
 213
 214         /* To do: check for runts, errs, etc. */
 215
 216         /* Avoids alignment problems on many architectures. */
 217         tvb_memcpy(tvb, (guint8 *)&viph, offset, sizeof(e_vip));
 218
 219         viph.vip_chksum = ntohs(viph.vip_chksum);
 220         viph.vip_pktlen = ntohs(viph.vip_pktlen);
 221         viph.vip_dnet = ntohl(viph.vip_dnet);
 222         viph.vip_dsub = ntohs(viph.vip_dsub);
 223         viph.vip_snet = ntohl(viph.vip_snet);
 224         viph.vip_ssub = ntohs(viph.vip_ssub);
 225
 226         switch (viph.vip_proto) {
 227         case VIP_PROTO_IPC:
 228                 if (check_col(pinfo->fd, COL_PROTOCOL))
 229                         col_set_str(pinfo->fd, COL_PROTOCOL, "Vines IPC");
 230                 if (check_col(pinfo->fd, COL_INFO))
 231                         col_add_fstr(pinfo->fd, COL_INFO, "IPC (%02x)", viph.vip_proto);
 232                 break;
 233         case VIP_PROTO_SPP:
 234                 if (check_col(pinfo->fd, COL_PROTOCOL))
 235                         col_set_str(pinfo->fd, COL_PROTOCOL, "Vines SPP");
 236                 if (check_col(pinfo->fd, COL_INFO))
 237                         col_add_fstr(pinfo->fd, COL_INFO, "SPP (%02x)", viph.vip_proto);
 238                 break;
 239         case VIP_PROTO_ARP:
 240                 if (check_col(pinfo->fd, COL_PROTOCOL))
 241                         col_set_str(pinfo->fd, COL_PROTOCOL, "Vines ARP");
 242                 if (check_col(pinfo->fd, COL_INFO))
 243                         col_add_fstr(pinfo->fd, COL_INFO, "ARP (%02x)", viph.vip_proto);
 244                 break;
 245         case VIP_PROTO_RTP:
 246                 if (check_col(pinfo->fd, COL_PROTOCOL))
 247                         col_set_str(pinfo->fd, COL_PROTOCOL, "Vines RTP");
 248                 if (check_col(pinfo->fd, COL_INFO))
 249                         col_add_fstr(pinfo->fd, COL_INFO, "RTP (%02x)", viph.vip_proto);
 250                 break;
 251         case VIP_PROTO_ICP:
 252                 if (check_col(pinfo->fd, COL_PROTOCOL))
 253                         col_set_str(pinfo->fd, COL_PROTOCOL, "Vines ICP");
 254                 if (check_col(pinfo->fd, COL_INFO))
 255                         col_add_fstr(pinfo->fd, COL_INFO, "ICP (%02x)", viph.vip_proto);
 256                 break;
 257         default:
 258                 if (check_col(pinfo->fd, COL_PROTOCOL))
 259                         col_set_str(pinfo->fd, COL_PROTOCOL, "Vines IP");
 260                 if (check_col(pinfo->fd, COL_INFO))
 261                         col_add_fstr(pinfo->fd, COL_INFO, "Unknown VIP protocol (%02x)",
 262                                      viph.vip_proto);
 263         }
 264
 265         src_addr = tvb_get_ptr(tvb, offset+12, VINES_ADDR_LEN);
 266         SET_ADDRESS(&pinfo->net_src, AT_VINES, VINES_ADDR_LEN, src_addr);
 267         SET_ADDRESS(&pinfo->src, AT_VINES, VINES_ADDR_LEN, src_addr);
 268         dst_addr = tvb_get_ptr(tvb, offset+6, VINES_ADDR_LEN);
 269         SET_ADDRESS(&pinfo->net_dst, AT_VINES, VINES_ADDR_LEN,dst_addr);
 270         SET_ADDRESS(&pinfo->dst, AT_VINES, VINES_ADDR_LEN, dst_addr);
 271
 272         /* helpers to decode flags */
 273         /* FIXME: Not used yet */
 274         if ((viph.vip_dnet == 0xffffffff) && (viph.vip_dsub == 0xffff)) {
 275                 is_broadcast = 1;
 276         }
 277         hops = viph.vip_tctl & 0xf;
 278
 279         /*
 280         viph.ip_tos = IPTOS_TOS(viph.ip_tos);
 281         switch (viph.ip_tos) {
 282         case IPTOS_NONE:
 283                 strcpy(tos_str, "None");
 284                 break;
 285         case IPTOS_LOWDELAY:
 286                 strcpy(tos_str, "Minimize delay");
 287                 break;
 288         case IPTOS_THROUGHPUT:
 289                 strcpy(tos_str, "Maximize throughput");
 290                 break;
 291         case IPTOS_RELIABILITY:
 292                 strcpy(tos_str, "Maximize reliability");
 293                 break;
 294         case IPTOS_LOWCOST:
 295                 strcpy(tos_str, "Minimize cost");
 296                 break;
 297         default:
 298                 strcpy(tos_str, "Unknon.  Malformed?");
 299                 break;
 300         }
 301         */
 302
 303         if (tree) {
 304                 ti = proto_tree_add_protocol_format(tree, proto_vines, tvb,
 305                                                     offset, (viph.vip_pktlen),
 306                                                     "Vines IP");
 307                 vip_tree = proto_item_add_subtree(ti, ett_vines);
 308                 proto_tree_add_text(vip_tree, tvb, offset,      2,
 309                                     "Packet checksum: 0x%04x",
 310                                     viph.vip_chksum);
 311                 proto_tree_add_text(vip_tree, tvb, offset +  2, 2,
 312                                     "Packet length: 0x%04x (%d)",
 313                                     viph.vip_pktlen, viph.vip_pktlen);
 314                 proto_tree_add_text(vip_tree, tvb, offset +  4, 1,
 315                                     "Transport control: 0x%02x",
 316                                     viph.vip_tctl);
 317                 proto_tree_add_uint(vip_tree, hf_vines_protocol, tvb,
 318                                     offset +  5, 1,
 319                                     viph.vip_proto);
 320                 proto_tree_add_text(vip_tree, tvb, offset +  6,
 321                                     VINES_ADDR_LEN,
 322                                     "Destination: %s",
 323                                     vines_addr_to_str(dst_addr));
 324                 proto_tree_add_text(vip_tree, tvb, offset +  12,
 325                                     VINES_ADDR_LEN,
 326                                     "Source: %s",
 327                                     vines_addr_to_str(src_addr));
 328
 329         }
 330
 331         offset += 18;
 332         switch (viph.vip_proto) {
 333         case VIP_PROTO_SPP:
 334                 next_tvb = tvb_new_subset(tvb, offset, -1, -1);
 335                 dissect_vines_spp(next_tvb, pinfo, tree);
 336                 break;
 337         default:
 338                 dissect_data(tvb, offset, pinfo, tree);
 339                 break;
 340         }
 341 }
 342
 343 void
 344 proto_register_vines(void)
 345 {
 346         static gint *ett[] = {
 347                 &ett_vines,
 348         };
 349
 350         static hf_register_info hf[] = {
 351           { &hf_vines_protocol,
 352             { "Protocol",                       "vines.protocol",
 353               FT_UINT8,         BASE_HEX,       NULL,   0x0,
 354               "Vines protocol" }}
 355         };
 356
 357         proto_vines = proto_register_protocol("Banyan Vines", "Vines", "vines");
 358         proto_register_field_array(proto_vines, hf, array_length(hf));
 359         proto_register_subtree_array(ett, array_length(ett));
 360 }
 361
 362 void
 363 proto_reg_handoff_vines(void)
 364 {
 365         dissector_add("ethertype", ETHERTYPE_VINES, dissect_vines);
 366         dissector_add("ppp.protocol", PPP_VINES, dissect_vines);
 367 }
 368
 369 static void
 370 dissect_vines_spp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 371 {
 372         int          offset = 0;
 373         e_vspp       viph;
 374         proto_tree *vspp_tree;
 375         proto_item *ti;
 376
 377         CHECK_DISPLAY_AS_DATA(proto_vines_spp, tvb, pinfo, tree);
 378
 379         pinfo->current_proto = "Vines SPP";
 380
 381         if (check_col(pinfo->fd, COL_PROTOCOL))
 382                 col_set_str(pinfo->fd, COL_PROTOCOL, "VSPP");
 383         if (check_col(pinfo->fd, COL_INFO))
 384                 col_clear(pinfo->fd, COL_INFO);
 385
 386         /* To do: check for runts, errs, etc. */
 387
 388         /* Avoids alignment problems on many architectures. */
 389         tvb_memcpy(tvb, (guint8 *)&viph, offset, sizeof(e_vspp));
 390
 391         viph.vspp_sport = ntohs(viph.vspp_sport);
 392         viph.vspp_dport = ntohs(viph.vspp_dport);
 393         viph.vspp_lclid = ntohs(viph.vspp_lclid);
 394         viph.vspp_rmtid = ntohs(viph.vspp_rmtid);
 395
 396         switch (viph.vspp_pkttype) {
 397         case VSPP_PKTTYPE_DATA:
 398                 if (check_col(pinfo->fd, COL_PROTOCOL))
 399                         col_set_str(pinfo->fd, COL_PROTOCOL, "VSPP Data");
 400                 break;
 401         case VSPP_PKTTYPE_DISC:
 402                 if (check_col(pinfo->fd, COL_PROTOCOL))
 403                         col_set_str(pinfo->fd, COL_PROTOCOL, "VSPP Disconnect");
 404                 break;
 405         case VSPP_PKTTYPE_PROBE:
 406                 if (check_col(pinfo->fd, COL_PROTOCOL))
 407                         col_set_str(pinfo->fd, COL_PROTOCOL, "VSPP Probe");
 408                 break;
 409         case VSPP_PKTTYPE_ACK:
 410                 if (check_col(pinfo->fd, COL_PROTOCOL))
 411                         col_set_str(pinfo->fd, COL_PROTOCOL, "VSPP Ack");
 412                 break;
 413         default:
 414                 if (check_col(pinfo->fd, COL_PROTOCOL))
 415                         col_set_str(pinfo->fd, COL_PROTOCOL, "VSPP Unknown");
 416         }
 417
 418         if (check_col(pinfo->fd, COL_INFO))
 419                 col_add_fstr(pinfo->fd, COL_INFO,
 420                              "NS=%04x NR=%04x Window=%04x RID=%04x LID=%04x D=%04x S=%04x",
 421                              viph.vspp_seqno, viph.vspp_ack, viph.vspp_win,
 422                              viph.vspp_rmtid, viph.vspp_lclid, viph.vspp_dport,
 423                              viph.vspp_sport);
 424
 425         /*
 426         iph.ip_tos = IPTOS_TOS(iph.ip_tos);
 427         switch (iph.ip_tos) {
 428         case IPTOS_NONE:
 429                 strcpy(tos_str, "None");
 430                 break;
 431         case IPTOS_LOWDELAY:
 432                 strcpy(tos_str, "Minimize delay");
 433                 break;
 434         case IPTOS_THROUGHPUT:
 435                 strcpy(tos_str, "Maximize throughput");
 436                 break;
 437         case IPTOS_RELIABILITY:
 438                 strcpy(tos_str, "Maximize reliability");
 439                 break;
 440         case IPTOS_LOWCOST:
 441                 strcpy(tos_str, "Minimize cost");
 442                 break;
 443         default:
 444                 strcpy(tos_str, "Unknon.  Malformed?");
 445                 break;
 446         }
 447         */
 448
 449         if (tree) {
 450                 ti = proto_tree_add_item(tree, proto_vines_spp, tvb, offset,
 451                     sizeof(viph), FALSE);
 452                 vspp_tree = proto_item_add_subtree(ti, ett_vines_spp);
 453                 proto_tree_add_text(vspp_tree, tvb, offset,      2,
 454                                     "Source port: 0x%04x", viph.vspp_sport);
 455                 proto_tree_add_text(vspp_tree, tvb, offset + 2,  2,
 456                                     "Destination port: 0x%04x",
 457                                     viph.vspp_dport);
 458                 proto_tree_add_text(vspp_tree, tvb, offset + 4,  1,
 459                                     "Packet type: 0x%02x", viph.vspp_pkttype);
 460                 proto_tree_add_text(vspp_tree, tvb, offset + 5,  1,
 461                                     "Control: 0x%02x", viph.vspp_control);
 462                 proto_tree_add_text(vspp_tree, tvb, offset + 6,  2,
 463                                     "Local Connection ID: 0x%04x",
 464                                     viph.vspp_lclid);
 465                 proto_tree_add_text(vspp_tree, tvb, offset + 8,  2,
 466                                     "Remote Connection ID: 0x%04x",
 467                                     viph.vspp_rmtid);
 468                 proto_tree_add_text(vspp_tree, tvb, offset + 10, 2,
 469                                     "Sequence number: 0x%04x",
 470                                     viph.vspp_seqno);
 471                 proto_tree_add_text(vspp_tree, tvb, offset + 12, 2,
 472                                     "Ack number: 0x%04x", viph.vspp_ack);
 473                 proto_tree_add_text(vspp_tree, tvb, offset + 14, 2,
 474                                     "Window: 0x%04x", viph.vspp_win);
 475         }
 476         offset += 16; /* sizeof SPP */
 477         dissect_data(tvb, offset, pinfo, tree);
 478 }
 479
 480 void
 481 proto_register_vines_spp(void)
 482 {
 483         static gint *ett[] = {
 484                 &ett_vines_spp,
 485         };
 486
 487         proto_vines_spp = proto_register_protocol("Banyan Vines SPP",
 488             "Vines SPP", "vines_spp");
 489         proto_register_subtree_array(ett, array_length(ett));
 490 }