Removed trailing whitespaces from .h and .c files using the
[obnox/wireshark/wip.git] / xdlc.c
1 /* xdlc.c
2  * Routines for use by various SDLC-derived protocols, such as HDLC
3  * and its derivatives LAPB, IEEE 802.2 LLC, etc..
4  *
5  * $Id: xdlc.c,v 1.19 2002/08/02 23:36:07 jmayer Exp $
6  *
7  * Ethereal - Network traffic analyzer
8  * By Gerald Combs <gerald@ethereal.com>
9  * Copyright 1998 Gerald Combs
10  * 
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  * 
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  * 
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  */
25
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #include <stdio.h>
31 #include <string.h>
32
33 #include <glib.h>
34 #include <epan/packet.h>
35 #include "xdlc.h"
36         
37 /*
38  * N(S) and N(R) fields, in basic and extended operation.
39  */
40 #define XDLC_N_R_MASK           0xE0    /* basic */
41 #define XDLC_N_R_SHIFT          5
42 #define XDLC_N_R_EXT_MASK       0xFE00  /* extended */
43 #define XDLC_N_R_EXT_SHIFT      9
44 #define XDLC_N_S_MASK           0x0E    /* basic */
45 #define XDLC_N_S_SHIFT          1
46 #define XDLC_N_S_EXT_MASK       0x00FE  /* extended */
47 #define XDLC_N_S_EXT_SHIFT      1
48
49 /*
50  * Poll/Final bit, in basic and extended operation.
51  */
52 #define XDLC_P_F        0x10    /* basic */
53 #define XDLC_P_F_EXT    0x0100  /* extended */
54
55 /*
56  * S-format frame types.
57  */
58 #define XDLC_S_FTYPE_MASK       0x0C
59 #define XDLC_RR                 0x00    /* Receiver ready */
60 #define XDLC_RNR                0x04    /* Receiver not ready */
61 #define XDLC_REJ                0x08    /* Reject */
62 #define XDLC_SREJ               0x0C    /* Selective reject */
63
64 static const value_string stype_vals[] = {
65     { XDLC_RR,   "Receiver ready" },
66     { XDLC_RNR,  "Receiver not ready" },
67     { XDLC_REJ,  "Reject" },
68     { XDLC_SREJ, "Selective reject" },
69     { 0,         NULL }
70 };
71
72 static const value_string modifier_short_vals_cmd[] = {
73     { XDLC_UI,    "UI" },
74     { XDLC_UP,    "UP" },
75     { XDLC_DISC,  "DISC" },
76     { XDLC_UA,    "UA" },
77     { XDLC_SNRM,  "SNRM" },
78     { XDLC_SNRME, "SNRME" },
79     { XDLC_TEST,  "TEST" },
80     { XDLC_SIM,   "SIM" },
81     { XDLC_FRMR,  "FRMR" },
82     { XDLC_CFGR,  "CFGR" },
83     { XDLC_SARM,  "SARM" },
84     { XDLC_SABM,  "SABM" },
85     { XDLC_SARME, "SARME" },
86     { XDLC_SABME, "SABME" },
87     { XDLC_RESET, "RESET" },
88     { XDLC_XID,   "XID" },
89     { XDLC_SNRME, "SNRME" },
90     { XDLC_BCN,   "BCN" },
91     { 0,          NULL }
92 };
93
94 static const value_string modifier_vals_cmd[] = {
95     { XDLC_UI,    "Unnumbered Information" },
96     { XDLC_UP,    "Unnumbered Poll" },
97     { XDLC_DISC,  "Disconnect" },
98     { XDLC_UA,    "Unnumbered Acknowledge" },
99     { XDLC_SNRM,  "Set Normal Response Mode" },
100     { XDLC_TEST,  "Test" },
101     { XDLC_SIM,   "Set Initialization Mode" },
102     { XDLC_FRMR,  "Frame reject" },
103     { XDLC_CFGR,  "Configure" },
104     { XDLC_SARM,  "Set Asynchronous Response Mode" },
105     { XDLC_SABM,  "Set Asynchronous Balanced Mode" },
106     { XDLC_SARME, "Set Asynchronous Response Mode Extended" },
107     { XDLC_SABME, "Set Asynchronous Balanced Mode Extended" },
108     { XDLC_RESET, "Reset" },
109     { XDLC_XID,   "Exchange identification" },
110     { XDLC_SNRME, "Set Normal Response Mode Extended" },
111     { XDLC_BCN,   "Beacon" },
112     { 0,          NULL }
113 };
114
115 static const value_string modifier_short_vals_resp[] = {
116     { XDLC_UI,    "UI" },
117     { XDLC_UP,    "UP" },
118     { XDLC_RD,    "RD" },
119     { XDLC_UA,    "UA" },
120     { XDLC_SNRM,  "SNRM" },
121     { XDLC_TEST,  "TEST" },
122     { XDLC_RIM,   "RIM" },
123     { XDLC_FRMR,  "FRMR" },
124     { XDLC_CFGR,  "CFGR" },
125     { XDLC_DM,    "DM" },
126     { XDLC_SABM,  "SABM" },
127     { XDLC_SARME, "SARME" },
128     { XDLC_SABME, "SABME" },
129     { XDLC_RESET, "RESET" },
130     { XDLC_XID,   "XID" },
131     { XDLC_SNRME, "SNRME" },
132     { XDLC_BCN,   "BCN" },
133     { 0,          NULL }
134 };
135
136 static const value_string modifier_vals_resp[] = {
137     { XDLC_UI,    "Unnumbered Information" },
138     { XDLC_UP,    "Unnumbered Poll" },
139     { XDLC_RD,    "Request Disconnect" },
140     { XDLC_UA,    "Unnumbered Acknowledge" },
141     { XDLC_SNRM,  "Set Normal Response Mode" },
142     { XDLC_TEST,  "Test" },
143     { XDLC_RIM,   "Request Initialization Mode" },
144     { XDLC_FRMR,  "Frame reject" },
145     { XDLC_CFGR,  "Configure" },
146     { XDLC_DM,    "Disconnected mode" },
147     { XDLC_SABM,  "Set Asynchronous Balanced Mode" },
148     { XDLC_SARME, "Set Asynchronous Response Mode Extended" },
149     { XDLC_SABME, "Set Asynchronous Balanced Mode Extended" },
150     { XDLC_RESET, "Reset" },
151     { XDLC_XID,   "Exchange identification" },
152     { XDLC_SNRME, "Set Normal Response Mode Extended" },
153     { XDLC_BCN,   "Beacon" },
154     { 0,          NULL }
155 };
156
157 int
158 get_xdlc_control(const guchar *pd, int offset, int is_extended)
159 {
160     guint16 control;
161
162     switch (pd[offset] & 0x03) {
163
164     case XDLC_S:
165     default:
166         /*
167          * Supervisory or Information frame.
168          */
169         if (is_extended)
170                 control = pletohs(&pd[offset]);
171         else
172                 control = pd[offset];
173         break;
174
175     case XDLC_U:
176         /*
177          * Unnumbered frame.
178          *
179          * XXX - is this two octets, with a P/F bit, in HDLC extended
180          * operation?  It's one octet in LLC, even though the control
181          * field of I and S frames is a 2-byte extended-operation field
182          * in LLC.  Given that there are no sequence numbers in the
183          * control field of a U frame, there doesn't appear to be any
184          * need for it to be 2 bytes in extended operation.
185          */
186         control = pd[offset];
187         break;
188     }
189     return control;
190 }
191
192 int
193 dissect_xdlc_control(tvbuff_t *tvb, int offset, packet_info *pinfo,
194   proto_tree *xdlc_tree, int hf_xdlc_control, gint ett_xdlc_control,
195   int is_response, int is_extended)
196 {
197     guint16 control;
198     char info[80];
199     proto_tree *tc, *control_tree;
200     gchar *frame_type = NULL;
201     gchar *modifier;
202
203     switch (tvb_get_guint8(tvb, offset) & 0x03) {
204
205     case XDLC_S:
206         /*
207          * Supervisory frame.
208          */
209         if (is_extended)
210                 control = tvb_get_letohs(tvb, offset);
211         else
212                 control = tvb_get_guint8(tvb, offset);
213         switch (control & XDLC_S_FTYPE_MASK) {
214         case XDLC_RR:
215             frame_type = "RR";
216             break;
217
218         case XDLC_RNR:
219             frame_type = "RNR";
220             break;
221
222         case XDLC_REJ:
223             frame_type = "REJ";
224             break;
225
226         case XDLC_SREJ:
227             frame_type = "SREJ";
228             break;
229         }
230         if (is_extended) {
231             sprintf(info, "S%s, %sN(R) = %u", frame_type,
232                         ((control & XDLC_P_F_EXT) ?
233                             (is_response ? "func = F, " : "func = P, ") :
234                             ""),
235                         (control & XDLC_N_R_EXT_MASK) >> XDLC_N_R_EXT_SHIFT);
236         } else {
237             sprintf(info, "S%s, %sN(R) = %u", frame_type,
238                         ((control & XDLC_P_F) ?
239                             (is_response ? "func = F, " : "func = P, ") :
240                             ""),
241                         (control & XDLC_N_R_MASK) >> XDLC_N_R_SHIFT);
242         }
243         if (check_col(pinfo->cinfo, COL_INFO))
244             col_add_str(pinfo->cinfo, COL_INFO, info);
245         if (xdlc_tree) {
246             if (is_extended) {
247                 tc = proto_tree_add_uint_format(xdlc_tree, hf_xdlc_control, tvb,
248                         offset, 2,
249                         control,
250                         "Control field: %s (0x%04X)", info, control);
251                 control_tree = proto_item_add_subtree(tc, ett_xdlc_control);
252                 proto_tree_add_text(control_tree, tvb, offset, 2,
253                     decode_numeric_bitfield(control, XDLC_N_R_EXT_MASK, 2*8,
254                         "N(R) = %u"));
255                 if (control & XDLC_P_F_EXT) {
256                     proto_tree_add_text(control_tree, tvb, offset, 2,
257                         decode_boolean_bitfield(control, XDLC_P_F_EXT, 2*8,
258                             (is_response ? "Final" : "Poll"), NULL));
259                 }
260                 proto_tree_add_text(control_tree, tvb, offset, 2,
261                     decode_enumerated_bitfield(control, XDLC_S_FTYPE_MASK, 2*8,
262                         stype_vals, "Supervisory frame - %s"));
263                 /* This will always say it's a supervisory frame */
264                 proto_tree_add_text(control_tree, tvb, offset, 2,
265                     decode_boolean_bitfield(control, 0x03, 2*8,
266                         "Supervisory frame", NULL));
267             } else {
268                 tc = proto_tree_add_uint_format(xdlc_tree, hf_xdlc_control, tvb,
269                         offset, 1,
270                         control,
271                         "Control field: %s (0x%02X)", info, control);
272                 control_tree = proto_item_add_subtree(tc, ett_xdlc_control);
273                 proto_tree_add_text(control_tree, tvb, offset, 1,
274                     decode_numeric_bitfield(control, XDLC_N_R_MASK, 1*8,
275                         "N(R) = %u"));
276                 if (control & XDLC_P_F) {
277                     proto_tree_add_text(control_tree, tvb, offset, 1,
278                         decode_boolean_bitfield(control, XDLC_P_F, 1*8,
279                             (is_response ? "Final" : "Poll"), NULL));
280                 }
281                 proto_tree_add_text(control_tree, tvb, offset, 1,
282                     decode_enumerated_bitfield(control, XDLC_S_FTYPE_MASK, 1*8,
283                         stype_vals, "%s"));
284                 /* This will always say it's a supervisory frame */
285                 proto_tree_add_text(control_tree, tvb, offset, 1,
286                     decode_boolean_bitfield(control, 0x03, 1*8,
287                         "Supervisory frame", NULL));
288             }
289         }
290         break;
291
292     case XDLC_U:
293         /*
294          * Unnumbered frame.
295          *
296          * XXX - is this two octets, with a P/F bit, in HDLC extended
297          * operation?  It's one octet in LLC, even though the control
298          * field of I and S frames is a 2-byte extended-operation field
299          * in LLC.  Given that there are no sequence numbers in the
300          * control field of a U frame, there doesn't appear to be any
301          * need for it to be 2 bytes in extended operation.
302          */
303         control = tvb_get_guint8(tvb, offset);
304         if (is_response) {
305                 modifier = match_strval(control & XDLC_U_MODIFIER_MASK,
306                         modifier_short_vals_resp);
307         } else {
308                 modifier = match_strval(control & XDLC_U_MODIFIER_MASK,
309                         modifier_short_vals_cmd);
310         }
311         if (modifier == NULL)
312                 modifier = "Unknown";
313         sprintf(info, "U%s, func = %s",
314                 ((control & XDLC_P_F) ?
315                     (is_response ? " F" : " P") :
316                     ""),
317                 modifier);
318         if (check_col(pinfo->cinfo, COL_INFO))
319             col_add_str(pinfo->cinfo, COL_INFO, info);
320         if (xdlc_tree) {
321             tc = proto_tree_add_uint_format(xdlc_tree, hf_xdlc_control, tvb,
322                         offset, 1,
323                         control,
324                         "Control field: %s (0x%02X)", info, control);
325             control_tree = proto_item_add_subtree(tc, ett_xdlc_control);
326             if (control & XDLC_P_F) {
327                 proto_tree_add_text(control_tree, tvb, offset, 2,
328                     decode_boolean_bitfield(control, XDLC_P_F, 1*8,
329                         (is_response ? "Final" : "Poll"), NULL));
330             }
331             proto_tree_add_text(control_tree, tvb, offset, 1,
332                 decode_enumerated_bitfield(control, XDLC_U_MODIFIER_MASK, 1*8,
333                     (is_response ? modifier_vals_resp : modifier_vals_cmd),
334                     "%s"));
335             /* This will always say it's an unnumbered frame */
336             proto_tree_add_text(control_tree, tvb, offset, 1,
337                 decode_boolean_bitfield(control, 0x03, 1*8,
338                     "Unnumbered frame", NULL));
339         }
340         break;
341
342     default:
343         /*
344          * Information frame.
345          */
346         if (is_extended)
347                 control = tvb_get_letohs(tvb, offset);
348         else
349                 control = tvb_get_guint8(tvb, offset);
350         if (is_extended) {
351             sprintf(info, "I%s, N(R) = %u, N(S) = %u",
352                         ((control & XDLC_P_F_EXT) ? " P" : ""),
353                         (control & XDLC_N_R_EXT_MASK) >> XDLC_N_R_EXT_SHIFT,
354                         (control & XDLC_N_S_EXT_MASK) >> XDLC_N_S_EXT_SHIFT);
355         } else {
356             sprintf(info, "I%s, N(R) = %u, N(S) = %u",
357                         ((control & XDLC_P_F) ? " P" : ""),
358                         (control & XDLC_N_R_MASK) >> XDLC_N_R_SHIFT,
359                         (control & XDLC_N_S_MASK) >> XDLC_N_S_SHIFT);
360         }
361         if (check_col(pinfo->cinfo, COL_INFO))
362             col_add_str(pinfo->cinfo, COL_INFO, info);
363         if (xdlc_tree) {
364             tc = proto_tree_add_uint_format(xdlc_tree, hf_xdlc_control, tvb,
365                         offset, (is_extended) ? 2 : 1,
366                         control,
367                         (is_extended) ? "Control field: %s (0x%04X)"
368                                       : "Control field: %s (0x%02X)",
369                         info, control);
370             control_tree = proto_item_add_subtree(tc, ett_xdlc_control);
371             if (is_extended) {
372                 proto_tree_add_text(control_tree, tvb, offset, 2,
373                     decode_numeric_bitfield(control, XDLC_N_R_EXT_MASK, 2*8,
374                                 "N(R) = %u"));
375                 proto_tree_add_text(control_tree, tvb, offset, 2,
376                     decode_numeric_bitfield(control, XDLC_N_S_EXT_MASK, 2*8,
377                                 "N(S) = %u"));
378                 if (control & XDLC_P_F_EXT) {
379                     proto_tree_add_text(control_tree, tvb, offset, 2,
380                         decode_boolean_bitfield(control, XDLC_P_F_EXT, 2*8,
381                                 "Poll", NULL));
382                 }
383                 /* This will always say it's an information frame */
384                 proto_tree_add_text(control_tree, tvb, offset, 2,
385                     decode_boolean_bitfield(control, 0x01, 2*8,
386                         NULL, "Information frame"));
387             } else {
388                 proto_tree_add_text(control_tree, tvb, offset, 1,
389                     decode_numeric_bitfield(control, XDLC_N_R_MASK, 1*8,
390                                 "N(R) = %u"));
391                 proto_tree_add_text(control_tree, tvb, offset, 1,
392                     decode_numeric_bitfield(control, XDLC_N_S_MASK, 1*8,
393                                 "N(S) = %u"));
394                 if (control & XDLC_P_F) {
395                     proto_tree_add_text(control_tree, tvb, offset, 1,
396                         decode_boolean_bitfield(control, XDLC_P_F, 1*8,
397                                 "Poll", NULL));
398                 }
399                 /* This will always say it's an information frame */
400                 proto_tree_add_text(control_tree, tvb, offset, 1,
401                     decode_boolean_bitfield(control, 0x01, 1*8,
402                         NULL, "Information frame"));
403             }
404         }
405     }
406     return control;
407 }