packet-rip.c

   1 /* packet-ospf.c
   2  * Routines for RIPv1 and RIPv2 packet disassembly
   3  * (c) Copyright Hannes R. Boehm <hannes@boehm.org>
   4  *
   5  * $Id: packet-rip.c,v 1.9 1999/07/07 22:51:52 gram Exp $
   6  *
   7  * Ethereal - Network traffic analyzer
   8  * By Gerald Combs <gerald@zing.org>
   9  * Copyright 1998 Gerald Combs
  10  *
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  25  */
  26
  27 #include "config.h"
  28
  29 #ifdef HAVE_SYS_TYPES_H
  30 #include <sys/types.h>
  31 #endif
  32
  33 #ifdef HAVE_NETINET_IN_H
  34 #include <netinet/in.h>
  35 #endif
  36
  37 #include <glib.h>
  38 #include "packet.h"
  39 #include "packet-rip.h"
  40
  41 static void dissect_ip_rip_vektor(guint8 version,
  42     const e_rip_vektor *rip_vektor, int offset, proto_tree *tree);
  43 static void dissect_rip_authentication(const e_rip_authentication *rip_authentication,
  44   int offset, proto_tree *tree);
  45
  46 void
  47 dissect_rip(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
  48     e_riphdr rip_header;
  49     e_rip_entry rip_entry;
  50     guint16 family;
  51     proto_tree *rip_tree = NULL;
  52         proto_item *ti;
  53
  54     /* we do the range checking of the index when checking wether or not this is a RIP packet */
  55     static char *packet_type[8] = { "never used", "Request", "Response",
  56     "Traceon", "Traceoff", "Vendor specific (Sun)" };
  57     static char *version[3] = { "RIP", "RIPv1", "RIPv2" };
  58
  59     /* avoid alignment problem */
  60     memcpy(&rip_header, &pd[offset], sizeof(rip_header));
  61
  62     /* Check if we 've realy got a RIP packet */
  63
  64     switch(rip_header.version) {
  65         case RIPv1:
  66             /* the domain field has to be set to zero for RIPv1 */
  67             if(!(rip_header.domain == 0)){
  68                 dissect_data(pd, offset, fd, tree);
  69                 return;
  70             }
  71             /* the RIPv2 checks are also made for v1 packets */
  72         case RIPv2:
  73             /* check wether or not command nr. is between 1-7
  74              * (range checking for index of char* packet_type is done at the same time)
  75              */
  76             if( !( (rip_header.command > 0) && (rip_header.command <= 7) )){
  77                 dissect_data(pd, offset, fd, tree);
  78                 return;
  79             }
  80             break;
  81         default:
  82             /* we only know RIPv1 and RIPv2 */
  83             dissect_data(pd, offset, fd, tree);
  84             return;
  85     }
  86
  87     if (check_col(fd, COL_PROTOCOL))
  88         col_add_str(fd, COL_PROTOCOL, version[rip_header.version] );
  89     if (check_col(fd, COL_INFO))
  90         col_add_str(fd, COL_INFO, packet_type[rip_header.command]);
  91
  92     if (tree) {
  93         ti = proto_tree_add_text(tree, offset, (fd->cap_len - offset), "Routing Information Protocol");
  94         rip_tree = proto_item_add_subtree(ti, ETT_RIP);
  95
  96         proto_tree_add_text(rip_tree, offset, 1, "Command: %d (%s)", rip_header.command, packet_type[rip_header.command]);
  97         proto_tree_add_text(rip_tree, offset + 1, 1, "Version: %d", rip_header.version);
  98         if(rip_header.version == RIPv2)
  99             proto_tree_add_text(rip_tree, offset + 2 , 2, "Routing Domain: %d", ntohs(rip_header.domain));
 100
 101         /* skip header */
 102         offset += RIP_HEADER_LENGTH;
 103
 104         /* zero or more entries */
 105
 106         while((fd->cap_len - offset) >= RIP_ENTRY_LENGTH){
 107             memcpy(&rip_entry, &pd[offset], sizeof(rip_entry)); /* avoid alignment problem */
 108             family = ntohs(rip_entry.vektor.family);
 109             switch (family) {
 110             case 2: /* IP */
 111                 ti = proto_tree_add_text(rip_tree, offset,
 112                                 RIP_ENTRY_LENGTH, "IP Address: %s, Metric: %ld",
 113                                 ip_to_str((guint8 *) &(rip_entry.vektor.ip)),
 114                                 (long)ntohl(rip_entry.vektor.metric));
 115                 dissect_ip_rip_vektor(rip_header.version, &rip_entry.vektor,
 116                                 offset, ti);
 117                 break;
 118             case 0xFFFF:
 119                 proto_tree_add_text(rip_tree, offset,
 120                                 RIP_ENTRY_LENGTH, "Authentication");
 121                 dissect_rip_authentication(&rip_entry.authentication,
 122                                 offset, ti);
 123                 break;
 124             default:
 125                 proto_tree_add_text(rip_tree, offset,
 126                                 RIP_ENTRY_LENGTH, "Unknown address family %u",
 127                                 family);
 128                 break;
 129             }
 130
 131             offset += RIP_ENTRY_LENGTH;
 132         }
 133     }
 134 }
 135
 136 static void
 137 dissect_ip_rip_vektor(guint8 version, const e_rip_vektor *rip_vektor,
 138   int offset, proto_tree *tree)
 139 {
 140     proto_tree *rip_vektor_tree;
 141
 142     rip_vektor_tree = proto_item_add_subtree(tree, ETT_RIP_VEC);
 143
 144     proto_tree_add_text(rip_vektor_tree, offset, 2, "Address Family ID: IP");
 145     if(version == RIPv2)
 146         proto_tree_add_text(rip_vektor_tree, offset + 2 , 2, "Route Tag: %d",
 147                                 ntohs(rip_vektor->tag));
 148     proto_tree_add_text(rip_vektor_tree, offset + 4, 4, "IP Address: %s",
 149                                 ip_to_str((guint8 *) &(rip_vektor->ip)));
 150     if(version == RIPv2) {
 151         proto_tree_add_text(rip_vektor_tree, offset + 8 , 4, "Netmask: %s",
 152                                 ip_to_str((guint8 *) &(rip_vektor->mask)));
 153         proto_tree_add_text(rip_vektor_tree, offset + 12, 4, "Next Hop: %s",
 154                                 ip_to_str((guint8 *) &(rip_vektor->next_hop)));
 155     }
 156     proto_tree_add_text(rip_vektor_tree, offset + 16, 4, "Metric: %ld",
 157                                 (long)ntohl(rip_vektor->metric));
 158 }
 159
 160 static void
 161 dissect_rip_authentication(const e_rip_authentication *rip_authentication,
 162   int offset, proto_tree *tree)
 163 {
 164     proto_tree *rip_authentication_tree;
 165     guint16 authtype;
 166
 167     rip_authentication_tree = proto_item_add_subtree(tree, ETT_RIP_VEC);
 168
 169     authtype = ntohs(rip_authentication->authtype);
 170     proto_tree_add_text(rip_authentication_tree, offset + 2, 2,
 171                                 "Authentication type: %u", authtype);
 172     if (authtype == 2)
 173         proto_tree_add_text(rip_authentication_tree, offset + 4 , 16,
 174                                 "Password: %.16s",
 175                                 rip_authentication->authentication);
 176 }
 177