Stuart Stanley's ISIS dissection support.
[obnox/wireshark/wip.git] / packet-fddi.c
1 /* packet-fddi.c
2  * Routines for FDDI packet disassembly
3  *
4  * Laurent Deniel <deniel@worldnet.fr>
5  *
6  * $Id: packet-fddi.c,v 1.25 1999/11/16 11:42:30 guy Exp $
7  *
8  * Ethereal - Network traffic analyzer
9  * By Gerald Combs <gerald@zing.org>
10  * Copyright 1998 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 #include <stdio.h>
37 #include <glib.h>
38 #include "packet.h"
39 #include "resolv.h"
40
41 static int proto_fddi = -1;
42 static int hf_fddi_fc = -1;
43 static int hf_fddi_dst = -1;
44 static int hf_fddi_src = -1;
45
46 static gint ett_fddi = -1;
47
48 /* FDDI Frame Control values */
49
50 #define FDDI_FC_VOID            0x00            /* Void frame */
51 #define FDDI_FC_NRT             0x80            /* Nonrestricted token */
52 #define FDDI_FC_RT              0xc0            /* Restricted token */
53 #define FDDI_FC_MAC             0xc0            /* MAC frame */
54 #define FDDI_FC_SMT             0x40            /* SMT frame */
55 #define FDDI_FC_SMT_INFO        0x41            /* SMT Info */
56 #define FDDI_FC_SMT_NSA         0x4F            /* SMT Next station adrs */
57 #define FDDI_FC_SMT_MIN         FDDI_FC_SMT_INFO
58 #define FDDI_FC_SMT_MAX         FDDI_FC_SMT_NSA
59 #define FDDI_FC_MAC_MIN         0xc1
60 #define FDDI_FC_MAC_BEACON      0xc2            /* MAC Beacon frame */
61 #define FDDI_FC_MAC_CLAIM       0xc3            /* MAC Claim frame */
62 #define FDDI_FC_MAC_MAX         0xcf
63 #define FDDI_FC_LLC_ASYNC       0x50            /* Async. LLC frame */
64 #define FDDI_FC_LLC_ASYNC_MIN   FDDI_FC_LLC_ASYNC
65 #define FDDI_FC_LLC_ASYNC_DEF   0x54
66 #define FDDI_FC_LLC_ASYNC_MAX   0x5f
67 #define FDDI_FC_LLC_SYNC        0xd0            /* Sync. LLC frame */
68 #define FDDI_FC_LLC_SYNC_MIN    FDDI_FC_LLC_SYNC
69 #define FDDI_FC_LLC_SYNC_MAX    0xd7
70 #define FDDI_FC_IMP_ASYNC       0x60            /* Implementor Async. */
71 #define FDDI_FC_IMP_ASYNC_MIN   FDDI_FC_IMP_ASYNC
72 #define FDDI_FC_IMP_ASYNC_MAX   0x6f
73 #define FDDI_FC_IMP_SYNC        0xe0            /* Implementor Synch. */
74
75 #define FDDI_FC_CLFF            0xF0            /* Class/Length/Format bits */
76 #define FDDI_FC_ZZZZ            0x0F            /* Control bits */
77
78 /*
79  * Async frame ZZZZ bits:
80  */
81 #define FDDI_FC_ASYNC_R         0x08            /* Reserved */
82 #define FDDI_FC_ASYNC_PRI       0x07            /* Priority */
83
84 #define FDDI_HEADER_SIZE        13
85
86 /* field positions */
87
88 #define FDDI_P_FC               0
89 #define FDDI_P_DHOST            1
90 #define FDDI_P_SHOST            7
91
92 /* "swaptab[i]" is the value of "i" with the bits reversed. */
93 static u_char swaptab[256] = {
94   0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
95   0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
96   0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
97   0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
98   0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
99   0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
100   0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
101   0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
102   0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
103   0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
104   0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
105   0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
106   0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
107   0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
108   0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
109   0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
110   0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
111   0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
112   0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
113   0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
114   0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
115   0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
116   0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
117   0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
118   0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
119   0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
120   0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
121   0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
122   0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
123   0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
124   0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
125   0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
126 };
127
128 static void
129 swap_mac_addr(u_char *swapped_addr, const u_char *orig_addr)
130 {
131         int i;
132
133         for (i = 0; i < 6; i++) {
134                 swapped_addr[i] = swaptab[orig_addr[i]];
135         }
136 }
137
138
139 void
140 capture_fddi(const u_char *pd, guint32 cap_len, packet_counts *ld) {
141   int        offset = 0, fc;
142
143   if (cap_len < FDDI_HEADER_SIZE) {
144     ld->other++;
145     return;
146   }
147   offset = FDDI_HEADER_SIZE;
148
149   fc = (int) pd[FDDI_P_FC];
150
151   switch (fc) {
152
153     /* From now, only 802.2 SNAP (Async. LCC frame) is supported */
154
155     case FDDI_FC_LLC_ASYNC + 0  :
156     case FDDI_FC_LLC_ASYNC + 1  :
157     case FDDI_FC_LLC_ASYNC + 2  :
158     case FDDI_FC_LLC_ASYNC + 3  :
159     case FDDI_FC_LLC_ASYNC + 4  :
160     case FDDI_FC_LLC_ASYNC + 5  :
161     case FDDI_FC_LLC_ASYNC + 6  :
162     case FDDI_FC_LLC_ASYNC + 7  :
163     case FDDI_FC_LLC_ASYNC + 8  :
164     case FDDI_FC_LLC_ASYNC + 9  :
165     case FDDI_FC_LLC_ASYNC + 10 :
166     case FDDI_FC_LLC_ASYNC + 11 :
167     case FDDI_FC_LLC_ASYNC + 12 :
168     case FDDI_FC_LLC_ASYNC + 13 :
169     case FDDI_FC_LLC_ASYNC + 14 :
170     case FDDI_FC_LLC_ASYNC + 15 :
171       capture_llc(pd, offset, cap_len, ld);
172       return;
173     default :
174       ld->other++;
175       return;
176
177   } /* fc */
178
179 } /* capture_fddi */
180
181 static gchar *
182 fddifc_to_str(int fc)
183 {
184   static gchar strbuf[128+1];
185
186   switch (fc) {
187
188   case FDDI_FC_VOID:                    /* Void frame */
189     return "Void frame";
190
191   case FDDI_FC_NRT:                     /* Nonrestricted token */
192     return "Nonrestricted token";
193
194   case FDDI_FC_RT:                      /* Restricted token */
195     return "Restricted token";
196
197   case FDDI_FC_SMT_INFO:                /* SMT Info */
198     return "SMT info";
199
200   case FDDI_FC_SMT_NSA:                 /* SMT Next station adrs */
201     return "SMT Next station address";
202
203   case FDDI_FC_MAC_BEACON:              /* MAC Beacon frame */
204     return "MAC beacon";
205
206   case FDDI_FC_MAC_CLAIM:               /* MAC Claim frame */
207     return "MAC claim token";
208
209   default:
210     switch (fc & FDDI_FC_CLFF) {
211
212     case FDDI_FC_MAC:
213       sprintf(strbuf, "MAC frame, control %x", fc & FDDI_FC_ZZZZ);
214       return strbuf;
215
216     case FDDI_FC_SMT:
217       sprintf(strbuf, "SMT frame, control %x", fc & FDDI_FC_ZZZZ);
218       return strbuf;
219
220     case FDDI_FC_LLC_ASYNC:
221       if (fc & FDDI_FC_ASYNC_R)
222         sprintf(strbuf, "Async LLC frame, control %x", fc & FDDI_FC_ZZZZ);
223       else
224         sprintf(strbuf, "Async LLC frame, priority %d",
225                         fc & FDDI_FC_ASYNC_PRI);
226       return strbuf;
227
228     case FDDI_FC_LLC_SYNC:
229       if (fc & FDDI_FC_ZZZZ) {
230         sprintf(strbuf, "Sync LLC frame, control %x", fc & FDDI_FC_ZZZZ);
231         return strbuf;
232       } else
233         return "Sync LLC frame";
234
235     case FDDI_FC_IMP_ASYNC:
236       sprintf(strbuf, "Implementor async frame, control %x",
237                         fc & FDDI_FC_ZZZZ);
238       return strbuf;
239
240     case FDDI_FC_IMP_SYNC:
241       sprintf(strbuf, "Implementor sync frame, control %x",
242                         fc & FDDI_FC_ZZZZ);
243       return strbuf;
244       break;
245
246     default:
247       return "Unknown frame type";
248     }
249   }
250 }
251
252 void dissect_fddi(const u_char *pd, frame_data *fd, proto_tree *tree,
253                 gboolean bitswapped)
254 {
255   int        offset = 0, fc;
256   proto_tree *fh_tree;
257   proto_item *ti;
258   gchar      *fc_str;
259   static u_char src[6], dst[6];
260   u_char     src_swapped[6], dst_swapped[6];
261
262   if (fd->cap_len < FDDI_HEADER_SIZE) {
263     dissect_data(pd, offset, fd, tree);
264     return;
265   }
266
267   /* Extract the source and destination addresses, possibly bit-swapping
268      them. */
269   if (bitswapped) {
270     swap_mac_addr(dst, (u_char *)&pd[FDDI_P_DHOST]);
271     swap_mac_addr(src, (u_char *)&pd[FDDI_P_SHOST]);
272   } else {
273     memcpy(dst, (u_char *)&pd[FDDI_P_DHOST], sizeof dst);
274     memcpy(src, (u_char *)&pd[FDDI_P_SHOST], sizeof src);
275   }
276
277   fc = (int) pd[FDDI_P_FC];
278   fc_str = fddifc_to_str(fc);
279
280   /* XXX - copy them to some buffer associated with "pi", rather than
281      just making "src" and "dst" static? */
282   SET_ADDRESS(&pi.dl_src, AT_ETHER, 6, &src[0]);
283   SET_ADDRESS(&pi.src, AT_ETHER, 6, &src[0]);
284   SET_ADDRESS(&pi.dl_dst, AT_ETHER, 6, &dst[0]);
285   SET_ADDRESS(&pi.dst, AT_ETHER, 6, &dst[0]);
286
287   if (check_col(fd, COL_PROTOCOL))
288     col_add_str(fd, COL_PROTOCOL, "FDDI");
289   if (check_col(fd, COL_INFO))
290     col_add_str(fd, COL_INFO, fc_str);
291
292   offset = FDDI_HEADER_SIZE;
293
294   if (tree) {
295         ti = proto_tree_add_item_format(tree, proto_fddi, 0, offset, NULL,
296                 "Fiber Distributed Data Interface, %s", fc_str);
297
298       swap_mac_addr(dst_swapped, (u_char*)&pd[FDDI_P_DHOST]);
299       swap_mac_addr(src_swapped, (u_char*)&pd[FDDI_P_SHOST]);
300
301       fh_tree = proto_item_add_subtree(ti, ett_fddi);
302       proto_tree_add_item(fh_tree, hf_fddi_fc, FDDI_P_FC, 1, fc);
303       proto_tree_add_item(fh_tree, hf_fddi_dst, FDDI_P_DHOST, 6, dst);
304       proto_tree_add_item(fh_tree, hf_fddi_src, FDDI_P_SHOST, 6, src);
305
306       /* hide some bit-swapped mac address fields in the proto_tree, just in case */
307       proto_tree_add_item_hidden(fh_tree, hf_fddi_dst, FDDI_P_DHOST, 6, dst_swapped);
308       proto_tree_add_item_hidden(fh_tree, hf_fddi_src, FDDI_P_SHOST, 6, src_swapped);
309
310   }
311   switch (fc) {
312
313     /* From now, only 802.2 SNAP (Async. LCC frame) is supported */
314
315     case FDDI_FC_LLC_ASYNC + 0  :
316     case FDDI_FC_LLC_ASYNC + 1  :
317     case FDDI_FC_LLC_ASYNC + 2  :
318     case FDDI_FC_LLC_ASYNC + 3  :
319     case FDDI_FC_LLC_ASYNC + 4  :
320     case FDDI_FC_LLC_ASYNC + 5  :
321     case FDDI_FC_LLC_ASYNC + 6  :
322     case FDDI_FC_LLC_ASYNC + 7  :
323     case FDDI_FC_LLC_ASYNC + 8  :
324     case FDDI_FC_LLC_ASYNC + 9  :
325     case FDDI_FC_LLC_ASYNC + 10 :
326     case FDDI_FC_LLC_ASYNC + 11 :
327     case FDDI_FC_LLC_ASYNC + 12 :
328     case FDDI_FC_LLC_ASYNC + 13 :
329     case FDDI_FC_LLC_ASYNC + 14 :
330     case FDDI_FC_LLC_ASYNC + 15 :
331       dissect_llc(pd, offset, fd, tree);
332       return;
333       
334     default :
335       dissect_data(pd, offset, fd, tree);
336       return;
337
338   } /* fc */
339 } /* dissect_fddi */
340
341 void
342 proto_register_fddi(void)
343 {
344         static hf_register_info hf[] = {
345
346                 /*
347                  * XXX - we want this guy to have his own private formatting
348                  * routine, using "fc_to_str()"; if "fc_to_str()" returns
349                  * NULL, just show the hex value, else show the string.
350                  */
351                 { &hf_fddi_fc,
352                 { "Frame Control",      "fddi.fc", FT_UINT8, BASE_HEX, NULL, 0x0,
353                         "" }},
354
355                 { &hf_fddi_dst,
356                 { "Destination",        "fddi.dst", FT_ETHER, BASE_NONE, NULL, 0x0,
357                         "Destination Hardware Address" }},
358
359                 { &hf_fddi_src,
360                 { "Source",             "fddi.src", FT_ETHER, BASE_NONE, NULL, 0x0,
361                         "" }},
362         };
363         static gint *ett[] = {
364                 &ett_fddi,
365         };
366
367         proto_fddi = proto_register_protocol ("Fiber Distributed Data Interface", "fddi" );
368         proto_register_field_array(proto_fddi, hf, array_length(hf));
369         proto_register_subtree_array(ett, array_length(ett));
370 }