Add a col_get_writable in case there are any deeply embedded
[obnox/wireshark/wip.git] / 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.40 2000/08/13 14:08:31 deniel 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_add_str(pinfo->fd, COL_PROTOCOL, "NCP");
267
268         if ( pi.ptype == PT_TCP || pi.ptype == PT_UDP ) {
269                 ncpiph.signature        = tvb_get_ntohl(tvb, 0);
270                 ncpiph.length           = tvb_get_ntohl(tvb, 4);
271                 hdr_offset += 8;
272                 if ( ncpiph.signature == NCPIP_RQST ) {
273                         ncpiphrq.version        = tvb_get_ntohl(tvb, hdr_offset);
274                         hdr_offset += 4;
275                         ncpiphrq.rplybufsize    = tvb_get_ntohl(tvb, hdr_offset);
276                         hdr_offset += 4;
277                 };
278         };
279
280         /* Record the offset where the NCP common header starts */
281         commhdr = hdr_offset;
282
283         header.type             = tvb_get_ntohs(tvb, commhdr);
284         header.sequence         = tvb_get_guint8(tvb, commhdr+2);
285         header.conn_low         = tvb_get_guint8(tvb, commhdr+3);
286         header.conn_high        = tvb_get_guint8(tvb, commhdr+5);
287
288         nw_connection = (header.conn_high << 16) + header.conn_low;
289
290         if (tree) {
291                 ti = proto_tree_add_item(tree, proto_ncp, tvb, 0, tvb_length(tvb), FALSE);
292                 ncp_tree = proto_item_add_subtree(ti, ett_ncp);
293
294                 if ( pi.ptype == PT_TCP || pi.ptype == PT_UDP ) {
295                         proto_tree_add_uint(ncp_tree, hf_ncp_ip_sig, tvb, 0, 4, ncpiph.signature);
296                         proto_tree_add_uint(ncp_tree, hf_ncp_ip_length, tvb, 4, 4, ncpiph.length);
297                         if ( ncpiph.signature == NCPIP_RQST ) {
298                                 proto_tree_add_uint(ncp_tree, hf_ncp_ip_ver, tvb, 8, 4, ncpiphrq.version);
299                                 proto_tree_add_uint(ncp_tree, hf_ncp_ip_rplybufsize, tvb, 12, 4, ncpiphrq.rplybufsize);
300                         };
301                 };
302                 proto_tree_add_uint(ncp_tree, hf_ncp_type,      tvb, commhdr + 0, 2, header.type);
303                 proto_tree_add_uint(ncp_tree, hf_ncp_seq,       tvb, commhdr + 2, 1, header.sequence);
304                 proto_tree_add_uint(ncp_tree, hf_ncp_connection,tvb, commhdr + 3, 3, nw_connection);
305                 proto_tree_add_item(ncp_tree, hf_ncp_task,      tvb, commhdr + 4, 1, FALSE);
306         }
307
308
309         if (header.type == 0x1111 || header.type == 0x2222) {
310                 dissect_ncp_request(tvb, pinfo, nw_connection,
311                         header.sequence, header.type, ncp_tree, tree);
312         }
313         else if (header.type == 0x3333) {
314                 dissect_ncp_reply(tvb, pinfo, nw_connection,
315                         header.sequence, ncp_tree, tree);
316         }
317         else if (       header.type == 0x5555 ||
318                         header.type == 0x7777 ||
319                         header.type == 0x9999           ) {
320
321                 if (check_col(pinfo->fd, COL_INFO)) {
322                         col_add_fstr(pinfo->fd, COL_INFO, "Type 0x%04x", header.type);
323                 }
324
325                 if (tree) {
326                         proto_tree_add_text(ncp_tree, tvb, commhdr + 0, 2, "Type 0x%04x not supported yet", header.type);
327                 }
328
329                 return;
330         }
331         else {
332                 /* The value_string for hf_ncp_type already indicates that this type is unknown.
333                  * Just return and do no more parsing. */
334                 return;
335         }
336 }
337
338
339
340 void
341 proto_register_ncp(void)
342 {
343
344   static hf_register_info hf[] = {
345     { &hf_ncp_ip_sig,
346       { "NCP over IP signature",                "ncp.ip.signature",
347         FT_UINT32, BASE_HEX, VALS(ncp_ip_signature), 0x0,
348         "" }},
349     { &hf_ncp_ip_length,
350       { "NCP over IP length",           "ncp.ip.length",
351         FT_UINT32, BASE_HEX, NULL, 0x0,
352         "" }},
353     { &hf_ncp_ip_ver,
354       { "NCP over IP Version",          "ncp.ip.version",
355         FT_UINT32, BASE_DEC, NULL, 0x0,
356         "" }},
357     { &hf_ncp_ip_rplybufsize,
358       { "NCP over IP Reply Buffer Size",        "ncp.ip.replybufsize",
359         FT_UINT32, BASE_DEC, NULL, 0x0,
360         "" }},
361     { &hf_ncp_type,
362       { "Type",                 "ncp.type",
363         FT_UINT16, BASE_HEX, VALS(ncp_type_vals), 0x0,
364         "NCP message type" }},
365     { &hf_ncp_seq,
366       { "Sequence Number",      "ncp.seq",
367         FT_UINT8, BASE_DEC, NULL, 0x0,
368         "" }},
369     { &hf_ncp_connection,
370       { "Connection Number",    "ncp.connection",
371         FT_UINT16, BASE_DEC, NULL, 0x0,
372         "" }},
373     { &hf_ncp_task,
374       { "Task Number",          "ncp.task",
375         FT_UINT8, BASE_DEC, NULL, 0x0,
376         "" }}
377   };
378   static gint *ett[] = {
379     &ett_ncp,
380   };
381   module_t *ncp_module;
382
383   proto_ncp = proto_register_protocol("NetWare Core Protocol", "ncp");
384   proto_register_field_array(proto_ncp, hf, array_length(hf));
385   proto_register_subtree_array(ett, array_length(ett));
386   register_init_routine(&ncp_init_protocol);
387
388   /* Register a configuration option for initial size of NCP hash */
389   ncp_module = prefs_register_module("ncp", "NCP", NULL);
390   prefs_register_uint_preference(ncp_module, "initial_hash_size",
391         "Initial Hash Size",
392         "Number of entries initially allocated for NCP hash",
393         10, &ncp_packet_init_count);
394 }
395
396 void
397 proto_reg_handoff_ncp(void)
398 {
399   dissector_add("tcp.port", TCP_PORT_NCP, dissect_ncp);
400   dissector_add("udp.port", UDP_PORT_NCP, dissect_ncp);
401   dissector_add("ipx.packet_type", IPX_PACKET_TYPE_NCP, dissect_ncp);
402   dissector_add("ipx.socket", IPX_SOCKET_NCP, dissect_ncp);
403 }