packet-ncp.c

   1 /* packet-ncp.c
   2  * Routines for NetWare Core Protocol
   3  * Gilbert Ramirez <gram@xiexie.org>
   4  * Modified to allow NCP over TCP/IP decodes by James Coe <jammer@cin.net>
   5  *
   6  * $Id: packet-ncp.c,v 1.44 2001/01/03 07:53:43 guy Exp $
   7  *
   8  * Ethereal - Network traffic analyzer
   9  * By Gerald Combs <gerald@zing.org>
  10  * Copyright 2000 Gerald Combs
  11  *
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #ifdef HAVE_SYS_TYPES_H
  33 # include <sys/types.h>
  34 #endif
  35
  36 #ifdef HAVE_NETINET_IN_H
  37 # include <netinet/in.h>
  38 #endif
  39
  40 #include <glib.h>
  41 #include "packet.h"
  42 #include "conversation.h"
  43 #include "prefs.h"
  44 #include "packet-ipx.h"
  45 #include "packet-ncp-int.h"
  46
  47 int proto_ncp = -1;
  48 static int hf_ncp_ip_ver = -1;
  49 static int hf_ncp_ip_length = -1;
  50 static int hf_ncp_ip_rplybufsize = -1;
  51 static int hf_ncp_ip_sig = -1;
  52 static int hf_ncp_type = -1;
  53 static int hf_ncp_seq = -1;
  54 static int hf_ncp_connection = -1;
  55 static int hf_ncp_task = -1;
  56
  57 static gint ett_ncp = -1;
  58
  59 #define TCP_PORT_NCP            524
  60 #define UDP_PORT_NCP            524
  61
  62 #define NCP_RQST_HDR_LENGTH     7
  63 #define NCP_RPLY_HDR_LENGTH     8
  64
  65 /* Hash functions */
  66 gint  ncp_equal (gconstpointer v, gconstpointer v2);
  67 guint ncp_hash  (gconstpointer v);
  68
  69 static guint ncp_packet_init_count = 200;
  70
  71 /* These are the header structures to handle NCP over IP */
  72 #define NCPIP_RQST      0x446d6454      /* "DmdT" */
  73 #define NCPIP_RPLY      0x744e6350      /* "tNcP" */
  74
  75 struct ncp_ip_header {
  76         guint32 signature;
  77         guint32 length;
  78 };
  79
  80 /* This header only appears on NCP over IP request packets */
  81 struct ncp_ip_rqhdr {
  82         guint32 version;
  83         guint32 rplybufsize;
  84 };
  85
  86 static const value_string ncp_ip_signature[] = {
  87         { NCPIP_RQST, "Demand Transport (Request)" },
  88         { NCPIP_RPLY, "Transport is NCP (Reply)" },
  89 };
  90
  91 /* The information in this module comes from:
  92         NetWare LAN Analysis, Second Edition
  93         Laura A. Chappell and Dan E. Hakes
  94         (c) 1994 Novell, Inc.
  95         Novell Press, San Jose.
  96         ISBN: 0-7821-1362-1
  97
  98   And from the ncpfs source code by Volker Lendecke
  99
 100   And:
 101         Programmer's Guide to the NetWare Core Protocol
 102         Steve Conner & Diane Conner
 103         (c) 1996 by Steve Conner & Diane Conner
 104         Published by Annabooks, San Diego, California
 105         ISBN: 0-929392-31-0
 106
 107 */
 108
 109 /* Every NCP packet has this common header */
 110 struct ncp_common_header {
 111         guint16 type;
 112         guint8  sequence;
 113         guint8  conn_low;
 114         guint8  task;
 115         guint8  conn_high; /* type=0x5555 doesn't have this */
 116 };
 117
 118
 119 static value_string ncp_type_vals[] = {
 120         { 0x1111, "Create a service connection" },
 121         { 0x2222, "Service request" },
 122         { 0x3333, "Service reply" },
 123         { 0x5555, "Destroy service connection" },
 124         { 0x7777, "Burst mode transfer" },
 125         { 0x9999, "Request being processed" },
 126         { 0x0000, NULL }
 127 };
 128
 129
 130 /* NCP packets come in request/reply pairs. The request packets tell the type
 131  * of NCP request and give a sequence ID. The response, unfortunately, only
 132  * identifies itself via the sequence ID; you have to know what type of NCP
 133  * request the request packet contained in order to successfully parse the NCP
 134  * response. A global method for doing this does not exist in ethereal yet
 135  * (NFS also requires it), so for now the NCP section will keep its own hash
 136  * table keeping track of NCP packet types.
 137  *
 138  * We construct a conversation specified by the client and server
 139  * addresses and the connection number; the key representing the unique
 140  * NCP request then is composed of the pointer to the conversation
 141  * structure, cast to a "guint" (which may throw away the upper 32
 142  * bits of the pointer on a P64 platform, but the low-order 32 bits
 143  * are more likely to differ between conversations than the upper 32 bits),
 144  * and the sequence number.
 145  *
 146  * The value stored in the hash table is the ncp_request_val pointer. This
 147  * struct tells us the NCP type and gives the ncp2222_record pointer, if
 148  * ncp_type == 0x2222.
 149  */
 150 typedef struct {
 151         conversation_t  *conversation;
 152         guint8          nw_sequence;
 153 } ncp_request_key;
 154
 155 typedef struct {
 156         guint16                 ncp_type;
 157         const ncp_record        *ncp_record;
 158 } ncp_request_val;
 159
 160
 161 static GHashTable *ncp_request_hash = NULL;
 162 static GMemChunk *ncp_request_keys = NULL;
 163 static GMemChunk *ncp_request_records = NULL;
 164
 165 /* Hash Functions */
 166 gint  ncp_equal (gconstpointer v, gconstpointer v2)
 167 {
 168         ncp_request_key *val1 = (ncp_request_key*)v;
 169         ncp_request_key *val2 = (ncp_request_key*)v2;
 170
 171         if (val1->conversation == val2->conversation &&
 172             val1->nw_sequence  == val2->nw_sequence ) {
 173                 return 1;
 174         }
 175         return 0;
 176 }
 177
 178 guint ncp_hash  (gconstpointer v)
 179 {
 180         ncp_request_key *ncp_key = (ncp_request_key*)v;
 181         return GPOINTER_TO_UINT(ncp_key->conversation) + ncp_key->nw_sequence;
 182 }
 183
 184 /* Initializes the hash table and the mem_chunk area each time a new
 185  * file is loaded or re-loaded in ethereal */
 186 static void
 187 ncp_init_protocol(void)
 188 {
 189         if (ncp_request_hash)
 190                 g_hash_table_destroy(ncp_request_hash);
 191         if (ncp_request_keys)
 192                 g_mem_chunk_destroy(ncp_request_keys);
 193         if (ncp_request_records)
 194                 g_mem_chunk_destroy(ncp_request_records);
 195
 196         ncp_request_hash = g_hash_table_new(ncp_hash, ncp_equal);
 197         ncp_request_keys = g_mem_chunk_new("ncp_request_keys",
 198                         sizeof(ncp_request_key),
 199                         ncp_packet_init_count * sizeof(ncp_request_key), G_ALLOC_AND_FREE);
 200         ncp_request_records = g_mem_chunk_new("ncp_request_records",
 201                         sizeof(ncp_request_val),
 202                         ncp_packet_init_count * sizeof(ncp_request_val), G_ALLOC_AND_FREE);
 203 }
 204
 205 void
 206 ncp_hash_insert(conversation_t *conversation, guint8 nw_sequence,
 207                 guint16 ncp_type, const ncp_record *ncp_rec)
 208 {
 209         ncp_request_val         *request_val;
 210         ncp_request_key         *request_key;
 211
 212         /* Now remember the request, so we can find it if we later
 213            a reply to it. */
 214         request_key = g_mem_chunk_alloc(ncp_request_keys);
 215         request_key->conversation = conversation;
 216         request_key->nw_sequence = nw_sequence;
 217
 218         request_val = g_mem_chunk_alloc(ncp_request_records);
 219         request_val->ncp_type = ncp_type;
 220         request_val->ncp_record = ncp_rec;
 221
 222         g_hash_table_insert(ncp_request_hash, request_key, request_val);
 223 }
 224
 225 /* Returns TRUE or FALSE. If TRUE, the record was found and
 226  * ncp_type and ncp_rec are set. */
 227 gboolean
 228 ncp_hash_lookup(conversation_t *conversation, guint8 nw_sequence,
 229                 guint16 *ncp_type, const ncp_record **ncp_rec)
 230 {
 231         ncp_request_val         *request_val;
 232         ncp_request_key         request_key;
 233
 234         request_key.conversation = conversation;
 235         request_key.nw_sequence = nw_sequence;
 236
 237         request_val = (ncp_request_val*)
 238                 g_hash_table_lookup(ncp_request_hash, &request_key);
 239
 240         if (request_val) {
 241                 *ncp_type       = request_val->ncp_type;
 242                 *ncp_rec        = request_val->ncp_record;
 243                 return TRUE;
 244         }
 245         else {
 246                 return FALSE;
 247         }
 248 }
 249
 250 static void
 251 dissect_ncp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 252 {
 253         proto_tree                      *ncp_tree = NULL;
 254         proto_item                      *ti;
 255         struct ncp_ip_header            ncpiph;
 256         struct ncp_ip_rqhdr             ncpiphrq;
 257         struct ncp_common_header        header;
 258         guint16                         nw_connection;
 259         int                             hdr_offset = 0;
 260         int                             commhdr;
 261
 262         CHECK_DISPLAY_AS_DATA(proto_ncp, tvb, pinfo, tree);
 263
 264         pinfo->current_proto = "NCP";
 265         if (check_col(pinfo->fd, COL_PROTOCOL))
 266                 col_set_str(pinfo->fd, COL_PROTOCOL, "NCP");
 267         if (check_col(pinfo->fd, COL_INFO))
 268                 col_clear(pinfo->fd, COL_INFO);
 269
 270         if ( pi.ptype == PT_TCP || pi.ptype == PT_UDP ) {
 271                 ncpiph.signature        = tvb_get_ntohl(tvb, 0);
 272                 ncpiph.length           = tvb_get_ntohl(tvb, 4);
 273                 hdr_offset += 8;
 274                 if ( ncpiph.signature == NCPIP_RQST ) {
 275                         ncpiphrq.version        = tvb_get_ntohl(tvb, hdr_offset);
 276                         hdr_offset += 4;
 277                         ncpiphrq.rplybufsize    = tvb_get_ntohl(tvb, hdr_offset);
 278                         hdr_offset += 4;
 279                 };
 280         };
 281
 282         /* Record the offset where the NCP common header starts */
 283         commhdr = hdr_offset;
 284
 285         header.type             = tvb_get_ntohs(tvb, commhdr);
 286         header.sequence         = tvb_get_guint8(tvb, commhdr+2);
 287         header.conn_low         = tvb_get_guint8(tvb, commhdr+3);
 288         header.conn_high        = tvb_get_guint8(tvb, commhdr+5);
 289
 290         nw_connection = (header.conn_high << 16) + header.conn_low;
 291
 292         if (tree) {
 293                 ti = proto_tree_add_item(tree, proto_ncp, tvb, 0, tvb_length(tvb), FALSE);
 294                 ncp_tree = proto_item_add_subtree(ti, ett_ncp);
 295
 296                 if ( pi.ptype == PT_TCP || pi.ptype == PT_UDP ) {
 297                         proto_tree_add_uint(ncp_tree, hf_ncp_ip_sig, tvb, 0, 4, ncpiph.signature);
 298                         proto_tree_add_uint(ncp_tree, hf_ncp_ip_length, tvb, 4, 4, ncpiph.length);
 299                         if ( ncpiph.signature == NCPIP_RQST ) {
 300                                 proto_tree_add_uint(ncp_tree, hf_ncp_ip_ver, tvb, 8, 4, ncpiphrq.version);
 301                                 proto_tree_add_uint(ncp_tree, hf_ncp_ip_rplybufsize, tvb, 12, 4, ncpiphrq.rplybufsize);
 302                         };
 303                 };
 304                 proto_tree_add_uint(ncp_tree, hf_ncp_type,      tvb, commhdr + 0, 2, header.type);
 305                 proto_tree_add_uint(ncp_tree, hf_ncp_seq,       tvb, commhdr + 2, 1, header.sequence);
 306                 proto_tree_add_uint(ncp_tree, hf_ncp_connection,tvb, commhdr + 3, 3, nw_connection);
 307                 proto_tree_add_item(ncp_tree, hf_ncp_task,      tvb, commhdr + 4, 1, FALSE);
 308         }
 309
 310
 311         if (header.type == 0x1111 || header.type == 0x2222) {
 312                 dissect_ncp_request(tvb, pinfo, nw_connection,
 313                         header.sequence, header.type, ncp_tree, tree);
 314         }
 315         else if (header.type == 0x3333) {
 316                 dissect_ncp_reply(tvb, pinfo, nw_connection,
 317                         header.sequence, ncp_tree, tree);
 318         }
 319         else if (       header.type == 0x5555 ||
 320                         header.type == 0x7777 ||
 321                         header.type == 0x9999           ) {
 322
 323                 if (check_col(pinfo->fd, COL_INFO)) {
 324                         col_add_fstr(pinfo->fd, COL_INFO, "Type 0x%04x", header.type);
 325                 }
 326
 327                 if (tree) {
 328                         proto_tree_add_text(ncp_tree, tvb, commhdr + 0, 2, "Type 0x%04x not supported yet", header.type);
 329                 }
 330
 331                 return;
 332         }
 333         else {
 334                 /* The value_string for hf_ncp_type already indicates that this type is unknown.
 335                  * Just return and do no more parsing. */
 336                 return;
 337         }
 338 }
 339
 340
 341
 342 void
 343 proto_register_ncp(void)
 344 {
 345
 346   static hf_register_info hf[] = {
 347     { &hf_ncp_ip_sig,
 348       { "NCP over IP signature",                "ncp.ip.signature",
 349         FT_UINT32, BASE_HEX, VALS(ncp_ip_signature), 0x0,
 350         "" }},
 351     { &hf_ncp_ip_length,
 352       { "NCP over IP length",           "ncp.ip.length",
 353         FT_UINT32, BASE_HEX, NULL, 0x0,
 354         "" }},
 355     { &hf_ncp_ip_ver,
 356       { "NCP over IP Version",          "ncp.ip.version",
 357         FT_UINT32, BASE_DEC, NULL, 0x0,
 358         "" }},
 359     { &hf_ncp_ip_rplybufsize,
 360       { "NCP over IP Reply Buffer Size",        "ncp.ip.replybufsize",
 361         FT_UINT32, BASE_DEC, NULL, 0x0,
 362         "" }},
 363     { &hf_ncp_type,
 364       { "Type",                 "ncp.type",
 365         FT_UINT16, BASE_HEX, VALS(ncp_type_vals), 0x0,
 366         "NCP message type" }},
 367     { &hf_ncp_seq,
 368       { "Sequence Number",      "ncp.seq",
 369         FT_UINT8, BASE_DEC, NULL, 0x0,
 370         "" }},
 371     { &hf_ncp_connection,
 372       { "Connection Number",    "ncp.connection",
 373         FT_UINT16, BASE_DEC, NULL, 0x0,
 374         "" }},
 375     { &hf_ncp_task,
 376       { "Task Number",          "ncp.task",
 377         FT_UINT8, BASE_DEC, NULL, 0x0,
 378         "" }}
 379   };
 380   static gint *ett[] = {
 381     &ett_ncp,
 382   };
 383   module_t *ncp_module;
 384
 385   proto_ncp = proto_register_protocol("NetWare Core Protocol", "NCP", "ncp");
 386   proto_register_field_array(proto_ncp, hf, array_length(hf));
 387   proto_register_subtree_array(ett, array_length(ett));
 388   register_init_routine(&ncp_init_protocol);
 389
 390   /* Register a configuration option for initial size of NCP hash */
 391   ncp_module = prefs_register_protocol(proto_ncp, NULL);
 392   prefs_register_uint_preference(ncp_module, "initial_hash_size",
 393         "Initial Hash Size",
 394         "Number of entries initially allocated for NCP hash",
 395         10, &ncp_packet_init_count);
 396 }
 397
 398 void
 399 proto_reg_handoff_ncp(void)
 400 {
 401   dissector_add("tcp.port", TCP_PORT_NCP, dissect_ncp);
 402   dissector_add("udp.port", UDP_PORT_NCP, dissect_ncp);
 403   dissector_add("ipx.packet_type", IPX_PACKET_TYPE_NCP, dissect_ncp);
 404   dissector_add("ipx.socket", IPX_SOCKET_NCP, dissect_ncp);
 405 }