?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MSWSP: fix dissect_mswsp_smb()
[wireshark-wip.git] / epan / dissectors / packet-fcoib.c
blob90c9ce62eafb5e0d4c4b7a1585ae9fa386d60344
1 /*
2 * packet-fcoib.c
3 * Routines for FCoIB dissection - Fibre Channel over Infiniband
4 * Copyright (c) 2010 Mellanox Technologies Ltd. (slavak@mellanox.co.il)
5 *
6 * $Id$
7 *
8 * Wireshark - Network traffic analyzer
9 * By Gerald Combs <gerald@wireshark.org>
10 * Copyright 1998 Gerald Combs
11 *
12 * Based on packet-fcoe.c, Copyright (c) 2006 Nuova Systems, Inc. (jre@nuovasystems.com)
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
27 */
28
29 #include "config.h"
30
31 #include <stdlib.h>
32 #include <epan/packet.h>
33 #include <epan/prefs.h>
34 #include <epan/crc32-tvb.h>
35 #include <epan/etypes.h>
36 #include <epan/expert.h>
37 #include <epan/wmem/wmem.h>
38 #include <errno.h>
39 #include "packet-infiniband.h"
40
41 #ifdef HAVE_ARPA_INET_H
42 # include <arpa/inet.h>
43 #endif
44 #ifdef HAVE_SYS_SOCKET_H
45 # include <sys/socket.h> /* needed to define AF_ values on UNIX */
46 #endif
47 #ifdef HAVE_WINSOCK2_H
48 # include <winsock2.h> /* needed to define AF_ values on Windows */
49 #endif
50 #ifdef NEED_INET_V6DEFS_H
51 # include "wsutil/inet_v6defs.h"
52 #endif
53
54 #define FCOIB_HEADER_LEN 16 /* header: encap. header, SOF, and padding */
55 #define FCOIB_TRAILER_LEN 8 /* trailer: FC-CRC, EOF and padding */
56 #define FCOIB_VER_OFFSET 2 /* offset of ver field (in bytes) inside FCoIB Encap. header */
57
58 /* Forward declaration we need below (for using proto_reg_handoff as a prefs callback) */
59 void proto_reg_handoff_fcoib(void);
60
61 typedef enum {
62 FCOIB_EOFn = 0x41,
63 FCOIB_EOFt = 0x42,
64 FCOIB_EOFrt = 0x44,
65 FCOIB_EOFdt = 0x46,
66 FCOIB_EOFni = 0x49,
67 FCOIB_EOFdti = 0x4E,
68 FCOIB_EOFrti = 0x4F,
69 FCOIB_EOFa = 0x50
70 } fcoib_eof_t;
71
72 typedef enum {
73 FCOIB_SOFf = 0x28,
74 FCOIB_SOFi4 = 0x29,
75 FCOIB_SOFi2 = 0x2D,
76 FCOIB_SOFi3 = 0x2E,
77 FCOIB_SOFn4 = 0x31,
78 FCOIB_SOFn2 = 0x35,
79 FCOIB_SOFn3 = 0x36,
80 FCOIB_SOFc4 = 0x39
81 } fcoib_sof_t;
82
83 static const value_string fcoib_eof_vals[] = {
84 {FCOIB_EOFn, "EOFn" },
85 {FCOIB_EOFt, "EOFt" },
86 {FCOIB_EOFrt, "EOFrt" },
87 {FCOIB_EOFdt, "EOFdt" },
88 {FCOIB_EOFni, "EOFni" },
89 {FCOIB_EOFdti, "EOFdti" },
90 {FCOIB_EOFrti, "EOFrti" },
91 {FCOIB_EOFa, "EOFa" },
92 {0, NULL}
93 };
94
95 static const value_string fcoib_sof_vals[] = {
96 {FCOIB_SOFf, "SOFf" },
97 {FCOIB_SOFi4, "SOFi4" },
98 {FCOIB_SOFi2, "SOFi2" },
99 {FCOIB_SOFi3, "SOFi3" },
100 {FCOIB_SOFn4, "SOFn4" },
101 {FCOIB_SOFn2, "SOFn2" },
102 {FCOIB_SOFn3, "SOFn3" },
103 {FCOIB_SOFc4, "SOFc4" },
104 {0, NULL}
105 };
106
107 static int proto_fcoib = -1;
108 static int hf_fcoib_ver = -1;
109 static int hf_fcoib_sig = -1;
110 static int hf_fcoib_sof = -1;
111 static int hf_fcoib_eof = -1;
112 static int hf_fcoib_crc = -1;
113 static int hf_fcoib_crc_bad = -1;
114 static int hf_fcoib_crc_good = -1;
115
116 static int ett_fcoib = -1;
117 static int ett_fcoib_crc = -1;
118
119 static expert_field ei_fcoib_crc = EI_INIT;
120
121 static dissector_handle_t data_handle;
122 static dissector_handle_t fc_handle;
123
124 /* global preferences */
125 static gboolean gPREF_HEUR_EN = TRUE;
126 static gboolean gPREF_MAN_EN = FALSE;
127 static gint gPREF_TYPE[2] = {0};
128 static const char *gPREF_ID[2] = {NULL};
129 static guint gPREF_QP[2] = {0};
130
131 /* source/destination addresses from preferences menu (parsed from gPREF_TYPE[?], gPREF_ID[?]) */
132 static address manual_addr[2];
133 static void *manual_addr_data[2];
134
135 static const enum_val_t pref_address_types[] = {
136 {"lid", "LID", 0},
137 {"gid", "GID", 1},
138 {NULL, NULL, -1}
139 };
140
141 /* checks if a packet matches the source/destination manually-configured in preferences */
142 static gboolean
143 manual_addr_match(packet_info *pinfo) {
144 if (gPREF_MAN_EN) {
145 /* If the manual settings are enabled see if this fits - in which case we can skip
146 the following checks entirely and go straight to dissecting */
147 if ( (ADDRESSES_EQUAL(&pinfo->src, &manual_addr[0]) &&
148 ADDRESSES_EQUAL(&pinfo->dst, &manual_addr[1]) &&
149 (pinfo->srcport == 0xffffffff /* is unknown */ || pinfo->srcport == gPREF_QP[0]) &&
150 (pinfo->destport == 0xffffffff /* is unknown */ || pinfo->destport == gPREF_QP[1])) ||
151 (ADDRESSES_EQUAL(&pinfo->src, &manual_addr[1]) &&
152 ADDRESSES_EQUAL(&pinfo->dst, &manual_addr[0]) &&
153 (pinfo->srcport == 0xffffffff /* is unknown */ || pinfo->srcport == gPREF_QP[1]) &&
154 (pinfo->destport == 0xffffffff /* is unknown */ || pinfo->destport == gPREF_QP[0])) )
155 return TRUE;
156 }
157
158 return FALSE;
159 }
160
161 static gboolean
162 dissect_fcoib(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
163 {
164 gint crc_offset;
165 gint eof_offset;
166 gint sof_offset;
167 gint frame_len;
168 guint version;
169 const char *ver;
170 gint bytes_remaining;
171 guint8 sof = 0;
172 guint8 eof = 0;
173 guint8 sig = 0;
174 const char *eof_str;
175 const char *sof_str;
176 const char *crc_msg;
177 const char *len_msg;
178 proto_item *ti;
179 proto_item *item;
180 proto_tree *fcoib_tree;
181 proto_tree *crc_tree;
182 tvbuff_t *next_tvb;
183 gboolean crc_exists;
184 guint32 crc_computed = 0;
185 guint32 crc = 0;
186 gboolean packet_match_manual;
187
188 tree = proto_tree_get_root(tree); /* we don't want to add FCoIB under the Infiniband tree */
189
190 frame_len = tvb_reported_length_remaining(tvb, 0) -
191 FCOIB_HEADER_LEN - FCOIB_TRAILER_LEN;
192 crc_offset = FCOIB_HEADER_LEN + frame_len;
193 eof_offset = crc_offset + 4;
194 sof_offset = FCOIB_HEADER_LEN - 1;
195
196 if (frame_len <= 0)
197 return FALSE; /* this packet isn't even long enough to contain the header+trailer w/o FC payload! */
198
199 packet_match_manual = manual_addr_match(pinfo);
200
201 if (!packet_match_manual && !gPREF_HEUR_EN)
202 return FALSE; /* user doesn't want us trying to automatically identify FCoIB packets */
203
204 /* we start off with some basic heuristics checks to make sure this could be a FCoIB packet */
205
206 if (tvb_bytes_exist(tvb, 0, 1))
207 sig = tvb_get_guint8(tvb, 0) >> 6;
208 if (tvb_bytes_exist(tvb, eof_offset, 1))
209 eof = tvb_get_guint8(tvb, eof_offset);
210 if (tvb_bytes_exist(tvb, sof_offset, 1))
211 sof = tvb_get_guint8(tvb, sof_offset);
212
213 if (!packet_match_manual) {
214 if (sig != 1)
215 return FALSE; /* the sig field in the FCoIB Encap. header MUST be 2'b01*/
216 if (!tvb_bytes_exist(tvb, eof_offset + 1, 3) || tvb_get_ntoh24(tvb, eof_offset + 1) != 0)
217 return FALSE; /* 3 bytes of RESERVED field immediately after eEOF MUST be 0 */
218 if (!try_val_to_str(sof, fcoib_sof_vals))
219 return FALSE; /* invalid value for SOF */
220 if (!try_val_to_str(eof, fcoib_eof_vals))
221 return FALSE; /* invalid value for EOF */
222 }
223
224
225 col_set_str(pinfo->cinfo, COL_PROTOCOL, "FCoIB");
226 bytes_remaining = tvb_length_remaining(tvb, FCOIB_HEADER_LEN);
227 if (bytes_remaining > frame_len)
228 bytes_remaining = frame_len; /* backing length */
229 next_tvb = tvb_new_subset(tvb, FCOIB_HEADER_LEN, bytes_remaining, frame_len);
230
231 /*
232 * Only version 0 is defined at this point.
233 * Don't print the version in the short summary if it is zero.
234 */
235 ver = "";
236 version = tvb_get_guint8(tvb, 0 + FCOIB_VER_OFFSET) >> 4;
237 if (version != 0)
238 ver = wmem_strdup_printf(wmem_packet_scope(), ver, "ver %d ", version);
239
240 eof_str = "none";
241 if (tvb_bytes_exist(tvb, eof_offset, 1)) {
242 eof_str = val_to_str(eof, fcoib_eof_vals, "0x%x");
243 }
244
245 sof_str = "none";
246 if (tvb_bytes_exist(tvb, sof_offset, 1)) {
247 sof_str = val_to_str(sof, fcoib_sof_vals, "0x%x");
248 }
249
250 /*
251 * Check the CRC.
252 */
253 crc_msg = "";
254 crc_exists = tvb_bytes_exist(tvb, crc_offset, 4);
255 if (crc_exists) {
256 crc = tvb_get_ntohl(tvb, crc_offset);
257 crc_computed = crc32_802_tvb(next_tvb, frame_len);
258 if (crc != crc_computed) {
259 crc_msg = " [bad FC CRC]";
260 }
261 }
262 len_msg = "";
263 if ((frame_len % 4) != 0 || frame_len < 24) {
264 len_msg = " [invalid length]";
265 }
266
267 ti = proto_tree_add_protocol_format(tree, proto_fcoib, tvb, 0,
268 FCOIB_HEADER_LEN,
269 "FCoIB %s(%s/%s) %d bytes%s%s", ver,
270 sof_str, eof_str,
271 frame_len, crc_msg,
272 len_msg);
273
274 /* Dissect the FCoIB Encapsulation header */
275
276 fcoib_tree = proto_item_add_subtree(ti, ett_fcoib);
277 proto_tree_add_uint(fcoib_tree, hf_fcoib_sig, tvb, 0, 1, sig);
278 proto_tree_add_uint(fcoib_tree, hf_fcoib_ver, tvb, FCOIB_VER_OFFSET, 1, version);
279 proto_tree_add_uint(fcoib_tree, hf_fcoib_sof, tvb, sof_offset, 1, sof);
280
281 /*
282 * Create the CRC information.
283 */
284 if (crc_exists) {
285 if (crc == crc_computed) {
286 item = proto_tree_add_uint_format_value(fcoib_tree, hf_fcoib_crc, tvb,
287 crc_offset, 4, crc,
288 "%8.8x [valid]", crc);
289 } else {
290 item = proto_tree_add_uint_format_value(fcoib_tree, hf_fcoib_crc, tvb,
291 crc_offset, 4, crc,
292 "%8.8x [error: should be %8.8x]",
293 crc, crc_computed);
294 expert_add_info_format(pinfo, item, &ei_fcoib_crc,
295 "Bad FC CRC %8.8x %8.x",
296 crc, crc_computed);
297 }
298 proto_tree_set_appendix(fcoib_tree, tvb, crc_offset,
299 tvb_length_remaining (tvb, crc_offset));
300 } else {
301 item = proto_tree_add_text(fcoib_tree, tvb, crc_offset, 0,
302 "CRC: [missing]");
303 }
304 crc_tree = proto_item_add_subtree(item, ett_fcoib_crc);
305 ti = proto_tree_add_boolean(crc_tree, hf_fcoib_crc_bad, tvb,
306 crc_offset, 4,
307 crc_exists && crc != crc_computed);
308 PROTO_ITEM_SET_GENERATED(ti);
309 ti = proto_tree_add_boolean(crc_tree, hf_fcoib_crc_good, tvb,
310 crc_offset, 4,
311 crc_exists && crc == crc_computed);
312 PROTO_ITEM_SET_GENERATED(ti);
313
314 /*
315 * Interpret the EOF.
316 */
317 if (tvb_bytes_exist(tvb, eof_offset, 1)) {
318 proto_tree_add_item(fcoib_tree, hf_fcoib_eof, tvb, eof_offset, 1, ENC_BIG_ENDIAN);
319 }
320
321 /* Set the SOF/EOF flags in the packet_info header */
322 pinfo->sof_eof = 0;
323 if (sof == FCOIB_SOFi3 || sof == FCOIB_SOFi2 || sof == FCOIB_SOFi4) {
324 pinfo->sof_eof = PINFO_SOF_FIRST_FRAME;
325 } else if (sof == FCOIB_SOFf) {
326 pinfo->sof_eof = PINFO_SOF_SOFF;
327 }
328
329 if (eof != FCOIB_EOFn) {
330 pinfo->sof_eof |= PINFO_EOF_LAST_FRAME;
331 } else if (eof != FCOIB_EOFt) {
332 pinfo->sof_eof |= PINFO_EOF_INVALID;
333 }
334
335 /* Call the FC Dissector if this is carrying an FC frame */
336
337 if (fc_handle) {
338 call_dissector(fc_handle, next_tvb, pinfo, tree);
339 } else if (data_handle) {
340 call_dissector(data_handle, next_tvb, pinfo, tree);
341 }
342
343 return TRUE;
344 }
345
346 void
347 proto_register_fcoib(void)
348 {
349 module_t *fcoib_module;
350
351 /* Setup list of header fields See Section 1.6.1 for details*/
352 static hf_register_info hf[] = {
353 { &hf_fcoib_sof,
354 {"SOF", "fcoib.sof", FT_UINT8, BASE_HEX, VALS(fcoib_sof_vals), 0,
355 NULL, HFILL}},
356 { &hf_fcoib_eof,
357 {"EOF", "fcoib.eof", FT_UINT8, BASE_HEX, VALS(fcoib_eof_vals), 0,
358 NULL, HFILL}},
359 { &hf_fcoib_sig,
360 {"Signature", "fcoib.sig", FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL}},
361 { &hf_fcoib_ver,
362 {"Version", "fcoib.ver", FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL}},
363 { &hf_fcoib_crc,
364 {"CRC", "fcoib.crc", FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL}},
365 { &hf_fcoib_crc_good,
366 {"CRC good", "fcoib.crc_good", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
367 "True: CRC matches packet content; False: doesn't match or not checked.", HFILL }},
368 { &hf_fcoib_crc_bad,
369 {"CRC bad", "fcoib.crc_bad", FT_BOOLEAN, BASE_NONE, NULL, 0x0,
370 "True: CRC doesn't match packet content; False: matches or not checked.", HFILL }}
371 };
372 static gint *ett[] = {
373 &ett_fcoib,
374 &ett_fcoib_crc
375 };
376
377 static ei_register_info ei[] = {
378 { &ei_fcoib_crc, { "fcoib.crc.bad", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }},
379 };
380
381 expert_module_t* expert_fcoib;
382
383 /* Register the protocol name and description */
384 proto_fcoib = proto_register_protocol("Fibre Channel over Infiniband",
385 "FCoIB", "fcoib");
386
387 /* Required function calls to register the header fields and
388 * subtrees used */
389 proto_register_field_array(proto_fcoib, hf, array_length(hf));
390 proto_register_subtree_array(ett, array_length(ett));
391 expert_fcoib = expert_register_protocol(proto_fcoib);
392 expert_register_field_array(expert_fcoib, ei, array_length(ei));
393
394 fcoib_module = prefs_register_protocol(proto_fcoib, proto_reg_handoff_fcoib);
395
396 prefs_register_bool_preference(fcoib_module, "heur_en", "Enable heuristic identification of FCoIB packets",
397 "When this option is enabled Wireshark will attempt to identify FCoIB packets automatically "
398 "based on some common features (may generate false positives)",
399 &gPREF_HEUR_EN);
400
401 prefs_register_bool_preference(fcoib_module, "manual_en", "Enable manual settings",
402 "Enables dissecting packets between the manually configured source/destination as FCoIB traffic",
403 &gPREF_MAN_EN);
404
405 prefs_register_static_text_preference(fcoib_module, "addr_a", "Address A",
406 "Side A of the manually-configured connection");
407 prefs_register_enum_preference(fcoib_module, "addr_a_type", "Address Type",
408 "Type of address specified", &gPREF_TYPE[0], pref_address_types, FALSE);
409 prefs_register_string_preference(fcoib_module, "addr_a_id", "ID",
410 "LID/GID of address A", &gPREF_ID[0]);
411 prefs_register_uint_preference(fcoib_module, "addr_a_qp", "QP Number",
412 "QP Number for address A", 10, &gPREF_QP[0]);
413
414 prefs_register_static_text_preference(fcoib_module, "addr_b", "Address B",
415 "Side B of the manually-configured connection");
416 prefs_register_enum_preference(fcoib_module, "addr_b_type", "Address Type",
417 "Type of address specified", &gPREF_TYPE[1], pref_address_types, FALSE);
418 prefs_register_string_preference(fcoib_module, "addr_b_id", "ID",
419 "LID/GID of address B", &gPREF_ID[1]);
420 prefs_register_uint_preference(fcoib_module, "addr_b_qp", "QP Number",
421 "QP Number for address B", 10, &gPREF_QP[1]);
422 }
423
424 void
425 proto_reg_handoff_fcoib(void)
426 {
427 static gboolean initialized = FALSE;
428
429 if (!initialized) {
430 heur_dissector_add("infiniband.payload", dissect_fcoib, proto_fcoib);
431
432 data_handle = find_dissector("data");
433 fc_handle = find_dissector("fc");
434
435 initialized = TRUE;
436 }
437
438 if (gPREF_MAN_EN) {
439 /* the manual setting is enabled, so parse the settings into the address type */
440 gboolean error_occured = FALSE;
441 char *not_parsed;
442 int i;
443
444 for (i = 0; i < 2; i++) {
445 if (gPREF_TYPE[i] == 0) { /* LID */
446 errno = 0; /* reset any previous error indicators */
447 *((guint16*)manual_addr_data[i]) = (guint16)strtoul(gPREF_ID[i], &not_parsed, 0);
448 if (errno || *not_parsed != '\0') {
449 error_occured = TRUE;
450 } else {
451 SET_ADDRESS(&manual_addr[i], AT_IB, sizeof(guint16), manual_addr_data[i]);
452 }
453 } else { /* GID */
454 if (inet_pton(AF_INET6, gPREF_ID[i], manual_addr_data[i]) <= 0) {
455 error_occured = TRUE;
456 } else {
457 SET_ADDRESS(&manual_addr[i], AT_IB, GID_SIZE, manual_addr_data[i]);
458 }
459 }
460
461 if (error_occured) {
462 /* an invalid id was specified - disable manual settings until it's fixed */
463 gPREF_MAN_EN = FALSE;
464 break;
465 }
466 }
467
468 }
469 }