From Duncan Salerno:
[obnox/wireshark/wip.git] / epan / dissectors / packet-gsm_a_dtap.c
1 /* packet-gsm_a_dtap.c
2  * Routines for GSM A Interface DTAP dissection - A.K.A. GSM layer 3
3  * NOTE: it actually includes RR messages, which are (generally) not carried
4  * over the A interface on DTAP, but are part of the same Layer 3 protocol set
5  *
6  * Copyright 2003, Michael Lum <mlum [AT] telostech.com>
7  * In association with Telos Technology Inc.
8  *
9  *
10  * Added the GPRS Mobility Managment Protocol and
11  * the GPRS Session Managment Protocol
12  *   Copyright 2004, Rene Pilz <rene.pilz [AT] ftw.com>
13  *   In association with Telecommunications Research Center
14  *   Vienna (ftw.)Betriebs-GmbH within the Project Metawin.
15  *
16  * Added Dissection of Radio Resource Management Information Elements
17  * and othere enhancements and fixes.
18  * Copyright 2005 - 2006, Anders Broman [AT] ericsson.com
19  * Small bugfixes, mainly in Qos and TFT by Nils Ljungberg and Stefan Boman [AT] ericsson.com
20  *
21  * Title                3GPP                    Other
22  *
23  *   Reference [3]
24  *   Mobile radio interface Layer 3 specification;
25  *   Core network protocols;
26  *   Stage 3
27  *   (3GPP TS 24.008 version 4.7.0 Release 4)
28  *   (ETSI TS 124 008 V6.8.0 (2005-03))
29  *
30  *   Reference [4]
31  *   Mobile radio interface layer 3 specification;
32  *   Radio Resource Control Protocol
33  *   (GSM 04.18 version 8.4.1 Release 1999)
34  *   (3GPP TS 04.18 version 8.26.0 Release 1999)
35  *
36  *   Reference [5]
37  *   Point-to-Point (PP) Short Message Service (SMS)
38  *   support on mobile radio interface
39  *   (3GPP TS 24.011 version 4.1.1 Release 4)
40  *
41  *   Reference [6]
42  *   Mobile radio Layer 3 supplementary service specification;
43  *   Formats and coding
44  *   (3GPP TS 24.080 version 4.3.0 Release 4)
45  *
46  *   Reference [7]
47  *   Mobile radio interface Layer 3 specification;
48  *   Core network protocols;
49  *   Stage 3
50  *   (3GPP TS 24.008 version 5.9.0 Release 5)
51  *
52  *   Reference [8]
53  *   Mobile radio interface Layer 3 specification;
54  *   Core network protocols;
55  *   Stage 3
56  *   (3GPP TS 24.008 version 6.7.0 Release 6)
57  *       (3GPP TS 24.008 version 6.8.0 Release 6)
58  *
59  * $Id$
60  *
61  * Wireshark - Network traffic analyzer
62  * By Gerald Combs <gerald@wireshark.org>
63  * Copyright 1998 Gerald Combs
64  *
65  * This program is free software; you can redistribute it and/or
66  * modify it under the terms of the GNU General Public License
67  * as published by the Free Software Foundation; either version 2
68  * of the License, or (at your option) any later version.
69  *
70  * This program is distributed in the hope that it will be useful,
71  * but WITHOUT ANY WARRANTY; without even the implied warranty of
72  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
73  * GNU General Public License for more details.
74  *
75  * You should have received a copy of the GNU General Public License
76  * along with this program; if not, write to the Free Software
77  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
78  */
79
80 #ifdef HAVE_CONFIG_H
81 # include "config.h"
82 #endif
83
84 #include <stdio.h>
85 #include <stdlib.h>
86
87 #include <string.h>
88
89 #include <epan/packet.h>
90 #include <epan/prefs.h>
91 #include <epan/tap.h>
92 #include <epan/emem.h>
93 #include <epan/asn1.h>
94
95 #include "packet-bssap.h"
96 #include "packet-sccp.h"
97 #include "packet-ber.h"
98 #include "packet-q931.h"
99 #include "packet-gsm_a_common.h"
100 #include "packet-ipv6.h"
101 #include "packet-e212.h"
102 #include "packet-ppp.h"
103
104 /* PROTOTYPES/FORWARDS */
105
106 const value_string gsm_a_dtap_msg_mm_strings[] = {
107         { 0x01, "IMSI Detach Indication" },
108         { 0x02, "Location Updating Accept" },
109         { 0x04, "Location Updating Reject" },
110         { 0x08, "Location Updating Request" },
111         { 0x11, "Authentication Reject" },
112         { 0x12, "Authentication Request" },
113         { 0x14, "Authentication Response" },
114         { 0x1c, "Authentication Failure" },
115         { 0x18, "Identity Request" },
116         { 0x19, "Identity Response" },
117         { 0x1a, "TMSI Reallocation Command" },
118         { 0x1b, "TMSI Reallocation Complete" },
119         { 0x21, "CM Service Accept" },
120         { 0x22, "CM Service Reject" },
121         { 0x23, "CM Service Abort" },
122         { 0x24, "CM Service Request" },
123         { 0x25, "CM Service Prompt" },
124         { 0x26, "Reserved: was allocated in earlier phases of the protocol" },
125         { 0x28, "CM Re-establishment Request" },
126         { 0x29, "Abort" },
127         { 0x30, "MM Null" },
128         { 0x31, "MM Status" },
129         { 0x32, "MM Information" },
130         { 0, NULL }
131 };
132
133 const value_string gsm_a_dtap_msg_cc_strings[] = {
134         { 0x01, "Alerting" },
135         { 0x08, "Call Confirmed" },
136         { 0x02, "Call Proceeding" },
137         { 0x07, "Connect" },
138         { 0x0f, "Connect Acknowledge" },
139         { 0x0e, "Emergency Setup" },
140         { 0x03, "Progress" },
141         { 0x04, "CC-Establishment" },
142         { 0x06, "CC-Establishment Confirmed" },
143         { 0x0b, "Recall" },
144         { 0x09, "Start CC" },
145         { 0x05, "Setup" },
146         { 0x17, "Modify" },
147         { 0x1f, "Modify Complete" },
148         { 0x13, "Modify Reject" },
149         { 0x10, "User Information" },
150         { 0x18, "Hold" },
151         { 0x19, "Hold Acknowledge" },
152         { 0x1a, "Hold Reject" },
153         { 0x1c, "Retrieve" },
154         { 0x1d, "Retrieve Acknowledge" },
155         { 0x1e, "Retrieve Reject" },
156         { 0x25, "Disconnect" },
157         { 0x2d, "Release" },
158         { 0x2a, "Release Complete" },
159         { 0x39, "Congestion Control" },
160         { 0x3e, "Notify" },
161         { 0x3d, "Status" },
162         { 0x34, "Status Enquiry" },
163         { 0x35, "Start DTMF" },
164         { 0x31, "Stop DTMF" },
165         { 0x32, "Stop DTMF Acknowledge" },
166         { 0x36, "Start DTMF Acknowledge" },
167         { 0x37, "Start DTMF Reject" },
168         { 0x3a, "Facility" },
169         { 0, NULL }
170 };
171
172 const value_string gsm_a_dtap_msg_sms_strings[] = {
173         { 0x01, "CP-DATA" },
174         { 0x04, "CP-ACK" },
175         { 0x10, "CP-ERROR" },
176         { 0, NULL }
177 };
178
179 const value_string gsm_a_dtap_msg_ss_strings[] = {
180         { 0x2a, "Release Complete" },
181         { 0x3a, "Facility" },
182         { 0x3b, "Register" },
183         { 0, NULL }
184 };
185
186 const value_string gsm_a_dtap_msg_tp_strings[] = {
187         { 0x00, "Close TCH Loop Cmd" },
188         { 0x01, "Close TCH Loop Ack" },
189         { 0x06, "Open Loop Cmd" },
190         { 0x0c, "Act EMMI Cmd" },
191         { 0x0d, "Act EMMI Ack" },
192         { 0x10, "Deact EMMI" },
193         { 0x14, "Test Interface" },
194         { 0x20, "Close Multi-slot Loop Cmd" },
195         { 0x21, "Close Multi-slot Loop Ack" },
196         { 0x22, "Open Multi-slot Loop Cmd" },
197         { 0x23, "Open Multi-slot Loop Ack" },
198         { 0x24, "GPRS Test Mode Cmd" },
199         { 0x25, "EGPRS Start Radio Block Loopback Cmd" },
200         { 0x40, "Close UE Test Loop" },
201         { 0x41, "Close UE Test Loop Complete" },
202         { 0x42, "Open UE Test Loop" },
203         { 0x43, "Open UE Test Loop Complete" },
204         { 0x44, "Activate RB Test Mode" },
205         { 0x45, "Activate RB Test Mode Complete" },
206         { 0x46, "Deactivate RB Test Mode" },
207         { 0x47, "Deactivate RB Test Mode Complete" },
208         { 0x48, "Reset UE Positioning Stored Information" },
209         { 0x49, "UE Test Loop Mode 3 RLC SDU Counter Request" },
210         { 0x4A, "UE Test Loop Mode 3 RLC SDU Counter Response" },
211         { 0, NULL }
212 };
213
214 const value_string gsm_dtap_elem_strings[] = {
215         /* Mobility Management Information Elements 10.5.3 */
216         { 0x00, "Authentication Parameter RAND" },
217         { 0x00, "Authentication Parameter AUTN (UMTS authentication challenge only)" },
218         { 0x00, "Authentication Response Parameter" },
219         { 0x00, "Authentication Response Parameter (extension) (UMTS authentication challenge only)" },
220         { 0x00, "Authentication Failure Parameter (UMTS authentication challenge only)" },
221         { 0x00, "CM Service Type" },
222         { 0x00, "Identity Type" },
223         { 0x00, "Location Updating Type" },
224         { 0x00, "Network Name" },
225         { 0x00, "Reject Cause" },
226         { 0x00, "Follow-on Proceed" },
227         { 0x00, "Time Zone" },
228         { 0x00, "Time Zone and Time" },
229         { 0x00, "CTS Permission" },
230         { 0x00, "LSA Identifier" },
231         { 0x00, "Daylight Saving Time" },
232         { 0x00, "Emergency Number List" },
233         /* Call Control Information Elements 10.5.4 */
234         { 0x00, "Auxiliary States" },                                   /* 10.5.4.4 Auxiliary states */
235         { 0x00, "Bearer Capability" },                                  /* 10.5.4.4a Backup bearer capability */
236         { 0x00, "Call Control Capabilities" },
237         { 0x00, "Call State" },
238         { 0x00, "Called Party BCD Number" },
239         { 0x00, "Called Party Subaddress" },
240         { 0x00, "Calling Party BCD Number" },
241         { 0x00, "Calling Party Subaddress" },
242         { 0x00, "Cause" },
243         { 0x00, "CLIR Suppression" },
244         { 0x00, "CLIR Invocation" },
245         { 0x00, "Congestion Level" },
246         { 0x00, "Connected Number" },
247         { 0x00, "Connected Subaddress" },
248         { 0x00, "Facility" },
249         { 0x00, "High Layer Compatibility" },
250         { 0x00, "Keypad Facility" },
251         { 0x00, "Low Layer Compatibility" },
252         { 0x00, "More Data" },
253         { 0x00, "Notification Indicator" },
254         { 0x00, "Progress Indicator" },
255         { 0x00, "Recall type $(CCBS)$" },
256         { 0x00, "Redirecting Party BCD Number" },
257         { 0x00, "Redirecting Party Subaddress" },
258         { 0x00, "Repeat Indicator" },
259         { 0x00, "Reverse Call Setup Direction" },
260         { 0x00, "SETUP Container $(CCBS)$" },
261         { 0x00, "Signal" },
262         { 0x00, "SS Version Indicator" },
263         { 0x00, "User-user" },
264         { 0x00, "Alerting Pattern $(NIA)$" },                   /* 10.5.4.26 Alerting Pattern $(NIA)$ */
265         { 0x00, "Allowed Actions $(CCBS)$" },
266         { 0x00, "Stream Identifier" },
267         { 0x00, "Network Call Control Capabilities" },
268         { 0x00, "Cause of No CLI" },
269         { 0x00, "Immediate Modification Indicator" },   /* 10.5.4.30 Cause of No CLI */
270         /* 10.5.4.31 Void */
271         { 0x00, "Supported Codec List" },                               /* 10.5.4.32 Supported codec list */
272         { 0x00, "Service Category" },                                   /* 10.5.4.33 Service category */
273         { 0x00, "Redial" },                                                             /* 10.5.4.34 Redial */
274         /* 10.5.4.35 Network-initiated Service Upgrade indicator */
275         /* Short Message Service Information Elements [5] 8.1.4 */
276         { 0x00, "CP-User Data" },
277         { 0x00, "CP-Cause" },
278         /* Short Message Service Information Elements [5] 8.2 */
279         { 0x00, "RP-Message Reference" },
280         { 0x00, "RP-Origination Address" },
281         { 0x00, "RP-Destination Address" },
282         { 0x00, "RP-User Data" },
283         { 0x00, "RP-Cause" },
284         /* Tests procedures information elements 3GPP TS 44.014 6.4.0 and 3GPP TS 34.109 6.4.0 */
285         { 0x00, "Close TCH Loop Cmd Sub-channel"},
286         { 0x00, "Open Loop Cmd Ack"},
287         { 0x00, "Close Multi-slot Loop Cmd Loop type"},
288         { 0x00, "Close Multi-slot Loop Ack Result"},
289         { 0x00, "Test Interface Tested device"},
290         { 0x00, "GPRS Test Mode Cmd PDU description"},
291         { 0x00, "GPRS Test Mode Cmd Mode flag"},
292         { 0x00, "EGPRS Start Radio Block Loopback Cmd Mode flag"},
293         { 0x00, "Close UE Test Loop Mode"},
294         { 0x00, "UE Positioning Technology"},
295         { 0x00, "RLC SDU Counter Value"},
296         { 0, NULL }
297 };
298
299 const gchar *gsm_a_pd_str[] = {
300         "Group Call Control",
301         "Broadcast Call Control",
302         "Reserved: was allocated in earlier phases of the protocol",
303         "Call Control; call related SS messages",
304         "GPRS Transparent Transport Protocol (GTTP)",
305         "Mobility Management messages",
306         "Radio Resources Management messages",
307         "Unknown",
308         "GPRS Mobility Management messages",
309         "SMS messages",
310         "GPRS Session Management messages",
311         "Non call related SS messages",
312         "Location Services",
313         "Unknown",
314         "Reserved for extension of the PD to one octet length",
315         "Special conformance testing functions"
316 };
317 /* L3 Protocol discriminator values according to TS 24 007 (6.4.0)  */
318 const value_string protocol_discriminator_vals[] = {
319         {0x0,           "Group call control"},
320         {0x1,           "Broadcast call control"},
321         {0x2,           "Reserved: was allocated in earlier phases of the protocol"},
322         {0x3,           "Call Control; call related SS messages"},
323         {0x4,           "GPRS Transparent Transport Protocol (GTTP)"},
324         {0x5,           "Mobility Management messages"},
325         {0x6,           "Radio Resources Management messages"},
326         {0x7,           "Unknown"},
327         {0x8,           "GPRS mobility management messages"},
328         {0x9,           "SMS messages"},
329         {0xa,           "GPRS session management messages"},
330         {0xb,           "Non call related SS messages"},
331         {0xc,           "Location services specified in 3GPP TS 44.071 [8a]"},
332         {0xd,           "Unknown"},
333         {0xe,           "Reserved for extension of the PD to one octet length "},
334         {0xf,           "Special conformance testing functions"},
335         { 0,    NULL }
336 };
337
338 const value_string gsm_a_pd_short_str_vals[] = {
339         {0x0,           "GCC"},                         /* Group Call Control */
340         {0x1,           "BCC"},                         /* Broadcast Call Control */
341         {0x2,           "Reserved"},            /* : was allocated in earlier phases of the protocol */
342         {0x3,           "CC"},                          /* Call Control; call related SS messages */
343         {0x4,           "GTTP"},                        /* GPRS Transparent Transport Protocol (GTTP) */
344         {0x5,           "MM"},                          /* Mobility Management messages */
345         {0x6,           "RR"},                          /* Radio Resources Management messages */
346         {0x7,           "Unknown"},
347         {0x8,           "GMM"},                         /* GPRS Mobility Management messages */
348         {0x9,           "SMS"},
349         {0xa,           "SM"},                          /* GPRS Session Management messages */
350         {0xb,           "SS"},
351         {0xc,           "LS"},                          /* Location Services */
352         {0xd,           "Unknown"},
353         {0xe,           "Reserved"},            /*  for extension of the PD to one octet length  */
354         {0xf,           "TP"},          /*  for tests procedures described in 3GPP TS 44.014 6.4.0 and 3GPP TS 34.109 6.4.0.*/
355         { 0,    NULL }
356 };
357
358
359 #define DTAP_PD_MASK            0x0f
360 #define DTAP_SKIP_MASK          0xf0
361 #define DTAP_TI_MASK            DTAP_SKIP_MASK
362 #define DTAP_TIE_PRES_MASK      0x07                    /* after TI shifted to right */
363 #define DTAP_TIE_MASK           0x7f
364
365 #define DTAP_MM_IEI_MASK        0x3f
366 #define DTAP_CC_IEI_MASK        0x3f
367 #define DTAP_SMS_IEI_MASK       0xff
368 #define DTAP_SS_IEI_MASK        0x3f
369 #define DTAP_TP_IEI_MASK  0xff
370
371 /* Initialize the protocol and registered fields */
372 static int proto_a_dtap = -1;
373
374 static int hf_gsm_a_dtap_msg_mm_type = -1;
375 static int hf_gsm_a_dtap_msg_cc_type = -1;
376 static int hf_gsm_a_seq_no = -1;
377 static int hf_gsm_a_dtap_msg_sms_type = -1;
378 static int hf_gsm_a_dtap_msg_ss_type = -1;
379 static int hf_gsm_a_dtap_msg_tp_type = -1;
380 int hf_gsm_a_dtap_elem_id = -1;
381 static int hf_gsm_a_cld_party_bcd_num = -1;
382 static int hf_gsm_a_clg_party_bcd_num = -1;
383 static int hf_gsm_a_dtap_cause = -1;
384
385 int hf_gsm_a_extension = -1;
386 static int hf_gsm_a_type_of_number = -1;
387 static int hf_gsm_a_numbering_plan_id = -1;
388
389 static int hf_gsm_a_lsa_id = -1;
390
391 /* Initialize the subtree pointers */
392 static gint ett_dtap_msg = -1;
393 static gint ett_dtap_oct_1 = -1;
394 static gint ett_cm_srvc_type = -1;
395 static gint ett_gsm_enc_info = -1;
396 static gint ett_bc_oct_3 = -1;
397 static gint ett_bc_oct_3a = -1;
398 static gint ett_bc_oct_4 = -1;
399 static gint ett_bc_oct_5 = -1;
400 static gint ett_bc_oct_5a = -1;
401 static gint ett_bc_oct_5b = -1;
402 static gint ett_bc_oct_6 = -1;
403 static gint ett_bc_oct_6a = -1;
404 static gint ett_bc_oct_6b = -1;
405 static gint ett_bc_oct_6c = -1;
406 static gint ett_bc_oct_6d = -1;
407 static gint ett_bc_oct_6e = -1;
408 static gint ett_bc_oct_6f = -1;
409 static gint ett_bc_oct_6g = -1;
410 static gint ett_bc_oct_7 = -1;
411
412 static char a_bigbuf[1024];
413
414 static dissector_handle_t data_handle;
415 static dissector_handle_t gsm_map_handle;
416 static dissector_handle_t rp_handle;
417
418 packet_info *gsm_a_dtap_pinfo;
419 static proto_tree *g_tree;
420
421 /*
422  * this should be set on a per message basis, if possible
423  */
424 static gint is_uplink;
425
426 #define NUM_GSM_DTAP_ELEM (sizeof(gsm_dtap_elem_strings)/sizeof(value_string))
427 gint ett_gsm_dtap_elem[NUM_GSM_DTAP_ELEM];
428
429 static dgt_set_t Dgt_mbcd = {
430         {
431   /*  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e */
432          '0','1','2','3','4','5','6','7','8','9','*','#','a','b','c'
433         }
434 };
435
436 /*
437  * [3] 10.5.3.1 Authentication parameter RAND
438  */
439 static guint16
440 de_auth_param_rand(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
441 {
442         guint32 curr_offset;
443
444         len = len;
445         curr_offset = offset;
446
447 /*
448  * 16 octets == 128 bits
449  */
450 #define AUTH_PARAM_RAND_LEN     16
451
452         proto_tree_add_text(tree,
453                 tvb, curr_offset, AUTH_PARAM_RAND_LEN,
454                 "RAND value: %s",
455                 tvb_bytes_to_str(tvb, curr_offset, AUTH_PARAM_RAND_LEN));
456
457         curr_offset += AUTH_PARAM_RAND_LEN;
458
459         /* no length check possible */
460
461         return(curr_offset - offset);
462 }
463
464 /*
465  * [3] 10.5.3.1.1 Authentication Parameter AUTN (UMTS authentication challenge only)
466  */
467 static guint16
468 de_auth_param_autn(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
469 {
470         guint32 curr_offset;
471
472         curr_offset = offset;
473
474         proto_tree_add_text(tree,
475                 tvb, curr_offset, len,
476                 "AUTN value: %s",
477                 tvb_bytes_to_str(tvb, curr_offset, len));
478
479         curr_offset += len;
480
481         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
482
483         return(curr_offset - offset);
484 }
485
486 /*
487  * [3] 10.5.3.2 Authentication Response parameter
488  */
489 static guint16
490 de_auth_resp_param(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
491 {
492         guint32 curr_offset;
493
494         len = len;
495         curr_offset = offset;
496
497 /*
498  * 4 octets == 32 bits
499  */
500 #define AUTH_PARAM_SRES_LEN     4
501
502         proto_tree_add_text(tree,
503                 tvb, curr_offset, AUTH_PARAM_SRES_LEN,
504                 "SRES value: %s",
505                 tvb_bytes_to_str(tvb, curr_offset, AUTH_PARAM_SRES_LEN));
506
507         curr_offset += AUTH_PARAM_SRES_LEN;
508
509         /* no length check possible */
510
511         return(curr_offset - offset);
512 }
513
514 /*
515  * [3] 10.5.3.2.1 Authentication Response Parameter (extension) (UMTS authentication challenge only)
516  */
517 static guint16
518 de_auth_resp_param_ext(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
519 {
520         guint32 curr_offset;
521
522         curr_offset = offset;
523
524         proto_tree_add_text(tree,
525                 tvb, curr_offset, len,
526                 "XRES value: %s",
527                 tvb_bytes_to_str(tvb, curr_offset, len));
528
529         curr_offset += len;
530
531         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
532
533         return(curr_offset - offset);
534 }
535
536 /*
537  * [3] 10.5.3.2.2 Authentication Failure parameter (UMTS authentication challenge only)
538  */
539 static guint16
540 de_auth_fail_param(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
541 {
542         guint32 curr_offset;
543
544         curr_offset = offset;
545
546         proto_tree_add_text(tree,
547                 tvb, curr_offset, len,
548                 "AUTS value: %s",
549                 tvb_bytes_to_str(tvb, curr_offset, len));
550
551         curr_offset += len;
552
553         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
554
555         return(curr_offset - offset);
556 }
557
558 /*
559  * 10.5.3.3 CM service type
560  *  handled inline
561  */
562 /*
563  * 10.5.3.4 Identity type
564  *  handled inline
565  */
566 /*
567  * 10.5.3.5 Location updating type
568  *  handled inline
569  */
570 /*
571  * [3] 10.5.3.5a Network Name
572  */
573 static guint16
574 de_network_name(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
575 {
576         guint8  oct;
577         guint32 curr_offset;
578         const gchar *str;
579
580         curr_offset = offset;
581
582         oct = tvb_get_guint8(tvb, curr_offset);
583
584         proto_tree_add_item(tree, hf_gsm_a_extension, tvb, curr_offset, 1, FALSE);
585
586         switch ((oct & 0x70) >> 4)
587         {
588         case 0x00: str = "Cell Broadcast data coding scheme, GSM default alphabet, language unspecified, defined in 3GPP TS 03.38"; break;
589         case 0x01: str = "UCS2 (16 bit)"; break;
590         default:
591                 str = "Reserved";
592         break;
593         }
594
595         other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
596         proto_tree_add_text(tree,
597                 tvb, curr_offset, 1,
598                 "%s :  Coding Scheme: %s",
599                 a_bigbuf,
600                 str);
601
602         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
603         proto_tree_add_text(tree,
604                 tvb, curr_offset, 1,
605                 "%s :  Add CI: The MS should %s",
606                 a_bigbuf,
607                 (oct & 0x08) ?
608                         "add the letters for the Country's Initials and a separator (e.g. a space) to the text string" :
609                         "The MS should not add the letters for the Country's Initials to the text string");
610
611         switch (oct & 0x07)
612         {
613         case 1: str = "bit 8 is spare and set to '0' in octet n"; break;
614         case 2: str = "bits 7 and 8 are spare and set to '0' in octet n"; break;
615         case 3: str = "bits 6 to 8(inclusive) are spare and set to '0' in octet n"; break;
616         case 4: str = "bits 5 to 8(inclusive) are spare and set to '0' in octet n"; break;
617         case 5: str = "bits 4 to 8(inclusive) are spare and set to '0' in octet n"; break;
618         case 6: str = "bits 3 to 8(inclusive) are spare and set to '0' in octet n"; break;
619         case 7: str = "bits 2 to 8(inclusive) are spare and set to '0' in octet n"; break;
620         default:
621                 str = "this field carries no information about the number of spare bits in octet n";
622         break;
623         }
624
625         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
626         proto_tree_add_text(tree,
627                 tvb, curr_offset, 1,
628                 "%s :  Number of spare bits in last octet: %s",
629                 a_bigbuf,
630                 str);
631
632         curr_offset++;
633
634         NO_MORE_DATA_CHECK(len);
635
636         proto_tree_add_text(tree,
637                 tvb, curr_offset, len - 1,
638                 "Text string encoded according to Coding Scheme");
639
640         curr_offset += len - 1;
641
642         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
643
644         return(curr_offset - offset);
645 }
646
647 /* 3GPP TS 24.008
648  * [3] 10.5.3.6 Reject cause
649  */
650 guint16
651 de_rej_cause(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string _U_, int string_len _U_)
652 {
653         guint8  oct;
654         guint32 curr_offset;
655         const gchar *str;
656
657         curr_offset = offset;
658
659         oct = tvb_get_guint8(tvb, curr_offset);
660
661         switch (oct)
662         {
663         case 0x02: str = "IMSI unknown in HLR"; break;
664         case 0x03: str = "Illegal MS"; break;
665         case 0x04: str = "IMSI unknown in VLR"; break;
666         case 0x05: str = "IMEI not accepted"; break;
667         case 0x06: str = "Illegal ME"; break;
668         case 0x0b: str = "PLMN not allowed"; break;
669         case 0x0c: str = "Location Area not allowed"; break;
670         case 0x0d: str = "Roaming not allowed in this location area"; break;
671         case 0x0f: str = "No Suitable Cells In Location Area"; break;
672         case 0x11: str = "Network failure"; break;
673         case 0x14: str = "MAC failure"; break;
674         case 0x15: str = "Synch failure"; break;
675         case 0x16: str = "Congestion"; break;
676         case 0x17: str = "GSM authentication unacceptable"; break;
677         case 0x20: str = "Service option not supported"; break;
678         case 0x21: str = "Requested service option not subscribed"; break;
679         case 0x22: str = "Service option temporarily out of order"; break;
680         case 0x26: str = "Call cannot be identified"; break;
681         case 0x5f: str = "Semantically incorrect message"; break;
682         case 0x60: str = "Invalid mandatory information"; break;
683         case 0x61: str = "Message type non-existent or not implemented"; break;
684         case 0x62: str = "Message type not compatible with the protocol state"; break;
685         case 0x63: str = "Information element non-existent or not implemented"; break;
686         case 0x64: str = "Conditional IE error"; break;
687         case 0x65: str = "Message not compatible with the protocol state"; break;
688         case 0x6f: str = "Protocol error, unspecified"; break;
689         default:
690                 switch (is_uplink)
691                 {
692                 case IS_UPLINK_FALSE:
693                         str = "Service option temporarily out of order";
694                         break;
695                 default:
696                         str = "Protocol error, unspecified";
697                         break;
698                 }
699                 break;
700         }
701
702         proto_tree_add_text(tree,
703                 tvb, curr_offset, 1,
704                 "Reject Cause value: 0x%02x (%u) %s",
705                 oct,
706                 oct,
707                 str);
708
709         curr_offset++;
710
711         /* no length check possible */
712
713         return(curr_offset - offset);
714 }
715 /*
716  * 10.5.3.7 Follow-on Proceed
717  *  No data
718  */
719 /*
720  * [3] 10.5.3.8 Time Zone
721  */
722 static guint16
723 de_time_zone(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string _U_, int string_len _U_)
724 {
725         guint8  oct;
726         guint32 curr_offset;
727         char sign;
728
729         curr_offset = offset;
730
731         /* 3GPP TS 23.040 version 6.6.0 Release 6
732          * 9.2.3.11 TP-Service-Centre-Time-Stamp (TP-SCTS)
733          * :
734          * The Time Zone indicates the difference, expressed in quarters of an hour,
735          * between the local time and GMT. In the first of the two semi-octets,
736          * the first bit (bit 3 of the seventh octet of the TP-Service-Centre-Time-Stamp field)
737          * represents the algebraic sign of this difference (0: positive, 1: negative).
738          */
739
740         oct = tvb_get_guint8(tvb, curr_offset);
741         sign = (oct & 0x08)?'-':'+';
742         oct = (oct >> 4) + (oct & 0x07) * 10;
743
744         proto_tree_add_text(tree,
745                 tvb, offset, 1,
746                 "Timezone: GMT %c %d hours %d minutes",
747                 sign, oct / 4, oct % 4 * 15);
748         curr_offset++;
749
750         /* no length check possible */
751
752         return(curr_offset - offset);
753 }
754
755 /*
756  * [3] 10.5.3.9 Time Zone and Time
757  */
758 static guint16
759 de_time_zone_time(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string _U_, int string_len _U_)
760 {
761         guint8  oct, oct2, oct3;
762         guint32 curr_offset;
763         char sign;
764
765         curr_offset = offset;
766
767         oct = tvb_get_guint8(tvb, curr_offset);
768         oct2 = tvb_get_guint8(tvb, curr_offset+1);
769         oct3 = tvb_get_guint8(tvb, curr_offset+2);
770
771         proto_tree_add_text(tree,
772                 tvb, curr_offset, 3,
773                 "Year %u%u, Month %u%u, Day %u%u",
774                 oct & 0x0f,
775                 (oct & 0xf0) >> 4,
776                 oct2 & 0x0f,
777                 (oct2 & 0xf0) >> 4,
778                 oct3 & 0x0f,
779                 (oct3 & 0xf0) >> 4);
780
781         curr_offset += 3;
782
783         oct = tvb_get_guint8(tvb, curr_offset);
784         oct2 = tvb_get_guint8(tvb, curr_offset+1);
785         oct3 = tvb_get_guint8(tvb, curr_offset+2);
786
787         proto_tree_add_text(tree,
788                 tvb, curr_offset, 3,
789                 "Hour %u%u, Minutes %u%u, Seconds %u%u",
790                 oct & 0x0f,
791                 (oct & 0xf0) >> 4,
792                 oct2 & 0x0f,
793                 (oct2 & 0xf0) >> 4,
794                 oct3 & 0x0f,
795                 (oct3 & 0xf0) >> 4);
796
797         curr_offset += 3;
798
799         /* 3GPP TS 23.040 version 6.6.0 Release 6
800          * 9.2.3.11 TP-Service-Centre-Time-Stamp (TP-SCTS)
801          * :
802          * The Time Zone indicates the difference, expressed in quarters of an hour,
803          * between the local time and GMT. In the first of the two semi-octets,
804          * the first bit (bit 3 of the seventh octet of the TP-Service-Centre-Time-Stamp field)
805          * represents the algebraic sign of this difference (0: positive, 1: negative).
806          */
807
808         oct = tvb_get_guint8(tvb, curr_offset);
809         sign = (oct & 0x08)?'-':'+';
810         oct = (oct >> 4) + (oct & 0x07) * 10;
811
812         proto_tree_add_text(tree,
813                 tvb, offset, 1,
814                 "Timezone: GMT %c %d hours %d minutes",
815                 sign, oct / 4, oct % 4 * 15);
816
817         curr_offset++;
818
819         /* no length check possible */
820
821         return(curr_offset - offset);
822 }
823 /*
824  * 10.5.3.10 CTS permission
825  * No data
826  */
827 /*
828  * [3] 10.5.3.11 LSA Identifier
829  * 3GPP TS 24.008 version 6.8.0 Release 6
830  */
831 static guint16
832 de_lsa_id(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
833 {
834         guint32 curr_offset;
835
836         curr_offset = offset;
837
838         if (len == 0){
839                 proto_tree_add_text(tree,tvb, curr_offset, len,"LSA ID not included");
840         }else{
841                 proto_tree_add_item(tree, hf_gsm_a_lsa_id, tvb, curr_offset, 3, FALSE);
842         }
843
844         curr_offset += len;
845
846         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
847
848         return(curr_offset - offset);
849 }
850
851 /*
852  * [3] 10.5.3.12 Daylight Saving Time
853  */
854 static guint16
855 de_day_saving_time(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
856 {
857         guint8  oct;
858         guint32 curr_offset;
859         const gchar *str;
860
861         curr_offset = offset;
862
863         oct = tvb_get_guint8(tvb, curr_offset);
864
865         other_decode_bitfield_value(a_bigbuf, oct, 0xfc, 8);
866         proto_tree_add_text(tree,
867                 tvb, curr_offset, 1,
868                 "%s :  Spare",
869                 a_bigbuf);
870
871         switch (oct & 0x03)
872         {
873         case 0: str = "No adjustment for Daylight Saving Time"; break;
874         case 1: str = "+1 hour adjustment for Daylight Saving Time"; break;
875         case 2: str = "+2 hours adjustment for Daylight Saving Time"; break;
876         default:
877                 str = "Reserved";
878                 break;
879         }
880
881         other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
882         proto_tree_add_text(tree,
883                 tvb, curr_offset, 1,
884                 "%s :  %s",
885                 a_bigbuf,
886                 str);
887
888         curr_offset++;
889
890         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
891
892         return(curr_offset - offset);
893 }
894 /*
895  * 10.5.3.13 Emergency Number List 
896  */
897 static guint16
898 de_emerg_num_list(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string _U_, int string_len _U_)
899 {
900         guint32 curr_offset;
901
902         curr_offset = offset;
903
904         proto_tree_add_text(tree, tvb, curr_offset, len, "Not decoded yet");
905
906
907         return(len);
908 }
909
910 /*
911  * [3] 10.5.4.4 Auxiliary states
912  */
913 static guint16
914 de_aux_states(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
915 {
916         guint8  oct;
917         guint32 curr_offset;
918         const gchar *str;
919
920         curr_offset = offset;
921
922         oct = tvb_get_guint8(tvb, curr_offset);
923
924         proto_tree_add_item(tree, hf_gsm_a_extension, tvb, curr_offset, 1, FALSE);
925
926         other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
927         proto_tree_add_text(tree,
928                 tvb, curr_offset, 1,
929                 "%s :  Spare",
930                 a_bigbuf);
931
932         switch ((oct & 0x0c) >> 2)
933         {
934         case 0: str = "Idle"; break;
935         case 1: str = "Hold request"; break;
936         case 2: str = "Call held"; break;
937         default:
938                 str = "Retrieve request";
939                 break;
940         }
941
942         other_decode_bitfield_value(a_bigbuf, oct, 0x0c, 8);
943         proto_tree_add_text(tree,
944                 tvb, curr_offset, 1,
945                 "%s :  Hold auxiliary state: %s",
946                 a_bigbuf,
947                 str);
948
949         switch (oct & 0x03)
950         {
951         case 0: str = "Idle"; break;
952         case 1: str = "MPTY request"; break;
953         case 2: str = "Call in MPTY"; break;
954         default:
955                 str = "Split request";
956                 break;
957         }
958
959         other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
960         proto_tree_add_text(tree,
961                 tvb, curr_offset, 1,
962                 "%s :  Multi party auxiliary state: %s",
963                 a_bigbuf,
964                 str);
965
966         curr_offset++;
967
968         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
969
970         return(curr_offset - offset);
971 }
972 /*
973  * 10.5.4.4a Backup bearer capability
974  */
975 /*
976  * [3] 10.5.4.5 Bearer capability
977  */
978 guint16
979 de_bearer_cap(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
980 {
981         guint8  oct;
982         guint8  itc;
983         gboolean        extended;
984         guint32 curr_offset;
985         guint32 saved_offset;
986         proto_tree      *subtree;
987         proto_item      *item;
988         const gchar *str;
989
990 #define DE_BC_ITC_SPEECH        0x00
991 #define DE_BC_ITC_UDI           0x01
992 #define DE_BC_ITC_EX_PLMN       0x02
993 #define DE_BC_ITC_FASC_G3       0x03
994 #define DE_BC_ITC_OTHER_ITC     0x05
995 #define DE_BC_ITC_RSVD_NET      0x07
996
997         curr_offset = offset;
998
999         oct = tvb_get_guint8(tvb, curr_offset);
1000
1001         /* octet 3 */
1002
1003         /*
1004          * warning, bearer cap uses extended values that
1005          * are reversed from other parameters!
1006          */
1007     item =
1008         proto_tree_add_text(tree,
1009             tvb, curr_offset, 1,
1010             "Octet 3");
1011     subtree = proto_item_add_subtree(item, ett_bc_oct_3);
1012
1013         extended = (oct & 0x80) ? FALSE : TRUE;
1014         itc = oct & 0x07;
1015
1016         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1017     proto_tree_add_text(subtree,
1018                 tvb, curr_offset, 1,
1019                 "%s :  Extension: %s",
1020                 a_bigbuf,
1021                 extended ? "extended" : "not extended");
1022
1023         switch (is_uplink)
1024         {
1025         case IS_UPLINK_FALSE:
1026                 str = "Spare";
1027                 break;
1028
1029         case IS_UPLINK_TRUE:
1030                 /*
1031                  * depends on Information transfer capability
1032                  */
1033                 switch (itc)
1034                 {
1035                 case DE_BC_ITC_SPEECH:
1036                         if (extended)
1037                         {
1038                                 switch ((oct & 0x60) >> 5)
1039                                 {
1040                                 case 1: str = "MS supports at least full rate speech version 1 but does not support half rate speech version 1"; break;
1041                                 case 2: str = "MS supports at least full rate speech version 1 and half rate speech version 1. MS has a greater preference for half rate speech version 1 than for full rate speech version 1"; break;
1042                                 case 3: str = "MS supports at least full rate speech version 1 and half rate speech version 1. MS has a greater preference for full rate speech version 1 than for half rate speech version 1"; break;
1043                                 default:
1044                                         str = "Reserved";
1045                                         break;
1046                                 }
1047                         }
1048                         else
1049                         {
1050                                 switch ((oct & 0x60) >> 5)
1051                                 {
1052                                 case 1: str = "Full rate support only MS/fullrate speech version 1 supported"; break;
1053                                 case 2: str = "Dual rate support MS/half rate speech version 1 preferred, full rate speech version 1 also supported"; break;
1054                                 case 3: str = "Dual rate support MS/full rate speech version 1 preferred, half rate speech version 1 also supported"; break;
1055                                 default:
1056                                         str = "Reserved";
1057                                         break;
1058                                 }
1059                         }
1060                         break;
1061
1062                 default:
1063                         switch ((oct & 0x60) >> 5)
1064                         {
1065                         case 1: str = "Full rate support only MS"; break;
1066                         case 2: str = "Dual rate support MS/half rate preferred"; break;
1067                         case 3: str = "Dual rate support MS/full rate preferred"; break;
1068                         default:
1069                                 str = "Reserved";
1070                                 break;
1071                         }
1072                         break;
1073                 }
1074                 break;
1075
1076                 default:
1077                         str = "(dissect problem)";
1078                         break;
1079                 }
1080
1081         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
1082     proto_tree_add_text(subtree,
1083         tvb, curr_offset, 1,
1084         "%s :  Radio channel requirement: %s",
1085         a_bigbuf,
1086         str);
1087
1088         other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
1089     proto_tree_add_text(subtree,
1090                 tvb, curr_offset, 1,
1091                 "%s :  Coding standard: %s",
1092                 a_bigbuf,
1093                 (oct & 0x10) ? "reserved" : "GSM standardized coding");
1094
1095         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
1096     proto_tree_add_text(subtree,
1097                 tvb, curr_offset, 1,
1098                 "%s :  Transfer mode: %s",
1099                 a_bigbuf,
1100                 (oct & 0x08) ? "packet" : "circuit");
1101
1102         switch (itc)
1103         {
1104         case DE_BC_ITC_SPEECH: str = "Speech"; break;
1105         case DE_BC_ITC_UDI: str = "Unrestricted digital information"; break;
1106         case DE_BC_ITC_EX_PLMN: str = "3.1 kHz audio, ex PLMN"; break;
1107         case DE_BC_ITC_FASC_G3: str = "Facsimile group 3"; break;
1108         case DE_BC_ITC_OTHER_ITC: str = "Other ITC (See Octet 5a)"; break;
1109         case DE_BC_ITC_RSVD_NET: str = "Reserved, to be used in the network"; break;
1110         default:
1111                 str = "Reserved";
1112                 break;
1113         }
1114
1115         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
1116     proto_tree_add_text(subtree,
1117                 tvb, curr_offset, 1,
1118                 "%s :  Information transfer capability: %s",
1119                 a_bigbuf,
1120                 str);
1121
1122         if (add_string)
1123                 g_snprintf(add_string, string_len, " - (%s)", str);
1124
1125         curr_offset++;
1126
1127         NO_MORE_DATA_CHECK(len);
1128
1129         switch (itc)
1130         {
1131         case DE_BC_ITC_SPEECH:
1132                 /* octets 3a */
1133
1134                 item =
1135                         proto_tree_add_text(tree,
1136                         tvb, curr_offset, -1,
1137                         "Octets 3a - Speech Versions");
1138
1139                 subtree = proto_item_add_subtree(item, ett_bc_oct_3a);
1140
1141                 saved_offset = curr_offset;
1142
1143                 do
1144                 {
1145                         oct = tvb_get_guint8(tvb, curr_offset);
1146
1147                         extended = (oct & 0x80) ? FALSE : TRUE;
1148
1149                         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1150                         proto_tree_add_text(subtree,
1151                                 tvb, curr_offset, 1,
1152                                 "%s :  Extension: %s",
1153                                 a_bigbuf,
1154                                 extended ? "extended" : "not extended");
1155
1156                         other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
1157                         proto_tree_add_text(subtree,
1158                                 tvb, curr_offset, 1,
1159                                 "%s :  Coding: octet used for %s",
1160                                 a_bigbuf,
1161                                 (oct & 0x40) ? "other extension of octet 3" :
1162                                 "extension of information transfer capability");
1163
1164                         other_decode_bitfield_value(a_bigbuf, oct, 0x30, 8);
1165                         proto_tree_add_text(subtree,
1166                                 tvb, curr_offset, 1,
1167                                 "%s :  Spare",
1168                                 a_bigbuf);
1169
1170                         switch (oct & 0x0f)
1171                         {
1172                         case 0: str = "GSM full rate speech version 1"; break;
1173                         case 2: str = "GSM full rate speech version 2"; break;
1174                         case 4: str = "GSM full rate speech version 3"; break;
1175                         case 1: str = "GSM half rate speech version 1"; break;
1176                         case 5: str = "GSM half rate speech version 3"; break;
1177                         default:
1178                                 str = "Speech version TBD";
1179                                 break;
1180                         }
1181
1182                         other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
1183                         proto_tree_add_text(subtree,
1184                                 tvb, curr_offset, 1,
1185                                 "%s :  Speech version indication: %s",
1186                                 a_bigbuf,
1187                                 str);
1188
1189                         curr_offset++;
1190                 }
1191                 while (extended &&
1192                         ((len - (curr_offset - offset)) > 0));
1193
1194                 proto_item_set_len(item, curr_offset - saved_offset);
1195                 break;
1196
1197                 default:
1198                 /* octet 4 */
1199
1200                 item =
1201                         proto_tree_add_text(tree,
1202                                 tvb, curr_offset, 1,
1203                                 "Octet 4");
1204
1205                 subtree = proto_item_add_subtree(item, ett_bc_oct_4);
1206
1207                 oct = tvb_get_guint8(tvb, curr_offset);
1208
1209                 extended = (oct & 0x80) ? FALSE : TRUE;
1210
1211                 other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1212                 proto_tree_add_text(subtree,
1213                         tvb, curr_offset, 1,
1214                         "%s :  Extension: %s",
1215                         a_bigbuf,
1216                         extended ? "extended" : "not extended");
1217
1218                 other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
1219                 proto_tree_add_text(subtree,
1220                         tvb, curr_offset, 1,
1221                         "%s :  Compression: data compression %s%s",
1222                         a_bigbuf,
1223                         (oct & 0x40) ? "" : "not ",
1224                         is_uplink ? "allowed" : "possible");
1225
1226                 switch ((oct & 0x30) >> 4)
1227                 {
1228                 case 0x00: str = "Service data unit integrity"; break;
1229                 case 0x03: str = "Unstructured"; break;
1230                 default:
1231                         str = "Reserved";
1232                         break;
1233                 }
1234
1235                 other_decode_bitfield_value(a_bigbuf, oct, 0x30, 8);
1236                 proto_tree_add_text(subtree,
1237                         tvb, curr_offset, 1,
1238                         "%s :  Structure: %s",
1239                         a_bigbuf,
1240                         str);
1241
1242                 other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
1243                 proto_tree_add_text(subtree,
1244                         tvb, curr_offset, 1,
1245                         "%s :  Duplex mode: %s",
1246                         a_bigbuf,
1247                         (oct & 0x08) ? "Full" : "Half");
1248
1249                 other_decode_bitfield_value(a_bigbuf, oct, 0x04, 8);
1250                 proto_tree_add_text(subtree,
1251                         tvb, curr_offset, 1,
1252                         "%s :  Configuration: %s",
1253                         a_bigbuf,
1254                         (oct & 0x04) ? "Reserved" : "Point-to-point");
1255
1256                 other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
1257                 proto_tree_add_text(subtree,
1258                         tvb, curr_offset, 1,
1259                         "%s :  NIRR: %s",
1260                         a_bigbuf,
1261                         (oct & 0x02) ?
1262                         "Data up to and including 4.8 kb/s, full rate, non-transparent, 6 kb/s radio interface rate is requested" :
1263                         "No meaning is associated with this value");
1264
1265                 other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
1266                 proto_tree_add_text(subtree,
1267                         tvb, curr_offset, 1,
1268                         "%s :  Establishment: %s",
1269                         a_bigbuf,
1270                         (oct & 0x01) ? "Reserved" : "Demand");
1271
1272                 curr_offset++;
1273
1274         NO_MORE_DATA_CHECK(len);
1275
1276         /* octet 5 */
1277
1278         item =
1279                 proto_tree_add_text(tree,
1280                 tvb, curr_offset, 1,
1281                 "Octet 5");
1282
1283         subtree = proto_item_add_subtree(item, ett_bc_oct_5);
1284
1285         oct = tvb_get_guint8(tvb, curr_offset);
1286
1287         extended = (oct & 0x80) ? FALSE : TRUE;
1288
1289         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1290         proto_tree_add_text(subtree,
1291                 tvb, curr_offset, 1,
1292                 "%s :  Extension: %s",
1293                 a_bigbuf,
1294                 extended ? "extended" : "not extended");
1295
1296         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
1297         proto_tree_add_text(subtree,
1298                 tvb, curr_offset, 1,
1299                 "%s :  Access Identity: %s",
1300                 a_bigbuf,
1301                 (oct & 0x60) ? "Reserved" : "Octet identifier");
1302
1303         switch ((oct & 0x18) >> 3)
1304         {
1305         case 0x00: str = "No rate adaption"; break;
1306         case 0x01: str = "V.110, I.460/X.30 rate adaptation"; break;
1307         case 0x02: str = "ITU-T X.31 flag stuffing"; break;
1308         default:
1309                 str = "Other rate adaption (see octet 5a)";
1310                 break;
1311         }
1312
1313         other_decode_bitfield_value(a_bigbuf, oct, 0x18, 8);
1314         proto_tree_add_text(subtree,
1315                 tvb, curr_offset, 1,
1316                 "%s :  Rate Adaption: %s",
1317                 a_bigbuf,
1318                 str);
1319
1320         switch (oct & 0x07)
1321         {
1322         case 0x01: str = "I.440/450"; break;
1323         case 0x02: str = "Reserved: was allocated in earlier phases of the protocol"; break;
1324         case 0x03: str = "Reserved: was allocated in earlier phases of the protocol"; break;
1325         case 0x04: str = "Reserved: was allocated in earlier phases of the protocol"; break;
1326         case 0x05: str = "Reserved: was allocated in earlier phases of the protocol"; break;
1327         case 0x06: str = "Reserved: was allocated in earlier phases of the protocol"; break;
1328         default:
1329                 str = "Reserved";
1330                 break;
1331         }
1332
1333         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
1334         proto_tree_add_text(subtree,
1335                 tvb, curr_offset, 1,
1336                 "%s :  Signalling Access Protocol: %s",
1337                 a_bigbuf,
1338                 str);
1339
1340         curr_offset++;
1341
1342         NO_MORE_DATA_CHECK(len);
1343
1344         if (!extended) goto bc_octet_6;
1345
1346         /* octet 5a */
1347
1348         item =
1349                 proto_tree_add_text(tree,
1350                 tvb, curr_offset, 1,
1351                 "Octet 5a");
1352
1353         subtree = proto_item_add_subtree(item, ett_bc_oct_5a);
1354
1355         oct = tvb_get_guint8(tvb, curr_offset);
1356
1357         extended = (oct & 0x80) ? FALSE : TRUE;
1358
1359         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1360         proto_tree_add_text(subtree,
1361                 tvb, curr_offset, 1,
1362                 "%s :  Extension: %s",
1363                 a_bigbuf,
1364                 extended ? "extended" : "not extended");
1365
1366         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
1367         proto_tree_add_text(subtree,
1368                 tvb, curr_offset, 1,
1369                 "%s :  Other ITC: %s",
1370                 a_bigbuf,
1371                 (oct & 0x60) ? "Reserved" : "Restricted digital information");
1372
1373         switch ((oct & 0x18) >> 3)
1374         {
1375         case 0x00: str = "V.120"; break;
1376         case 0x01: str = "H.223 & H.245"; break;
1377         case 0x02: str = "PIAFS"; break;
1378         default:
1379                 str = "Reserved";
1380                 break;
1381         }
1382
1383         other_decode_bitfield_value(a_bigbuf, oct, 0x18, 8);
1384         proto_tree_add_text(subtree,
1385                 tvb, curr_offset, 1,
1386                 "%s :  Other Rate Adaption: %s",
1387                 a_bigbuf,
1388                 str);
1389
1390         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
1391         proto_tree_add_text(subtree,
1392                 tvb, curr_offset, 1,
1393                 "%s :  Spare",
1394                 a_bigbuf);
1395
1396         curr_offset++;
1397
1398         NO_MORE_DATA_CHECK(len);
1399
1400         if (!extended) goto bc_octet_6;
1401
1402         /* octet 5b */
1403
1404         item =
1405                 proto_tree_add_text(tree,
1406                 tvb, curr_offset, 1,
1407                 "Octet 5b");
1408
1409         subtree = proto_item_add_subtree(item, ett_bc_oct_5b);
1410
1411         oct = tvb_get_guint8(tvb, curr_offset);
1412
1413         extended = (oct & 0x80) ? FALSE : TRUE;
1414
1415         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1416         proto_tree_add_text(subtree,
1417                 tvb, curr_offset, 1,
1418                 "%s :  Extension: %s",
1419                 a_bigbuf,
1420                 extended ? "extended" : "not extended");
1421
1422         other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
1423         proto_tree_add_text(subtree,
1424                 tvb, curr_offset, 1,
1425                 "%s :  Rate Adaption Header: %sincluded",
1426                 a_bigbuf,
1427                 (oct & 0x40) ? "" : "not ");
1428
1429         other_decode_bitfield_value(a_bigbuf, oct, 0x20, 8);
1430         proto_tree_add_text(subtree,
1431                 tvb, curr_offset, 1,
1432                 "%s :  Multiple frame establishment support in data link: %s",
1433                 a_bigbuf,
1434                 (oct & 0x20) ? "Supported" : "Not supported, only UI frames allowed");
1435
1436         other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
1437         proto_tree_add_text(subtree,
1438                 tvb, curr_offset, 1,
1439                 "%s :  Mode of operation: %s",
1440                 a_bigbuf,
1441                 (oct & 0x10) ? "Protocol sensitive" : "Bit transparent");
1442
1443         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
1444         proto_tree_add_text(subtree,
1445                 tvb, curr_offset, 1,
1446                 "%s :  Logical link identifier negotiation: %s",
1447                 a_bigbuf,
1448                 (oct & 0x08) ? "Full protocol negotiation" : "Default, LLI=256 only");
1449
1450         other_decode_bitfield_value(a_bigbuf, oct, 0x04, 8);
1451         proto_tree_add_text(subtree,
1452                 tvb, curr_offset, 1,
1453                 "%s :  Assignor/Assignee: Message originator is '%s'",
1454                 a_bigbuf,
1455                 (oct & 0x04) ? "assignor only" : "default assignee");
1456
1457         other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
1458         proto_tree_add_text(subtree,
1459                 tvb, curr_offset, 1,
1460                 "%s :  In band/Out of band negotiation: Negotiation is done %s",
1461                 a_bigbuf,
1462                 (oct & 0x02) ?
1463                 "with USER INFORMATION messages on a temporary signalling connection" :
1464                 "in-band using logical link zero");
1465
1466         other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
1467         proto_tree_add_text(subtree,
1468                 tvb, curr_offset, 1,
1469                 "%s :  Spare",
1470                 a_bigbuf);
1471
1472         curr_offset++;
1473
1474         NO_MORE_DATA_CHECK(len);
1475
1476 bc_octet_6:
1477
1478         /* octet 6 */
1479
1480         item =
1481                 proto_tree_add_text(tree,
1482                 tvb, curr_offset, 1,
1483                 "Octet 6");
1484
1485         subtree = proto_item_add_subtree(item, ett_bc_oct_6);
1486
1487         oct = tvb_get_guint8(tvb, curr_offset);
1488
1489         extended = (oct & 0x80) ? FALSE : TRUE;
1490
1491         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1492         proto_tree_add_text(subtree,
1493                 tvb, curr_offset, 1,
1494                 "%s :  Extension: %s",
1495                 a_bigbuf,
1496                 extended ? "extended" : "not extended");
1497
1498         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
1499         proto_tree_add_text(subtree,
1500                 tvb, curr_offset, 1,
1501                 "%s :  Layer 1 Identity: %s",
1502                 a_bigbuf,
1503                 ((oct & 0x60) == 0x20) ? "Octet identifier" : "Reserved");
1504
1505         other_decode_bitfield_value(a_bigbuf, oct, 0x1e, 8);
1506         proto_tree_add_text(subtree,
1507                 tvb, curr_offset, 1,
1508                 "%s :  User information layer 1 protocol: %s",
1509                 a_bigbuf,
1510                 (oct & 0x1e) ? "Reserved" : "Default layer 1 protocol");
1511
1512         other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
1513         proto_tree_add_text(subtree,
1514                 tvb, curr_offset, 1,
1515                 "%s :  Synchronous/asynchronous: %s",
1516                 a_bigbuf,
1517                 (oct & 0x01) ? "Asynchronous" : "Synchronous");
1518
1519         curr_offset++;
1520
1521         NO_MORE_DATA_CHECK(len);
1522
1523         if (!extended) goto bc_octet_7;
1524
1525         /* octet 6a */
1526
1527         item =
1528                 proto_tree_add_text(tree,
1529                 tvb, curr_offset, 1,
1530                 "Octet 6a");
1531
1532         subtree = proto_item_add_subtree(item, ett_bc_oct_6a);
1533
1534         oct = tvb_get_guint8(tvb, curr_offset);
1535
1536         extended = (oct & 0x80) ? FALSE : TRUE;
1537
1538         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1539         proto_tree_add_text(subtree,
1540                 tvb, curr_offset, 1,
1541                 "%s :  Extension: %s",
1542                 a_bigbuf,
1543                 extended ? "extended" : "not extended");
1544
1545         other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
1546         proto_tree_add_text(subtree,
1547                 tvb, curr_offset, 1,
1548                 "%s :  Number of Stop Bits: %s",
1549                 a_bigbuf,
1550                 (oct & 0x40) ? "2" : "1");
1551
1552         other_decode_bitfield_value(a_bigbuf, oct, 0x20, 8);
1553         proto_tree_add_text(subtree,
1554                 tvb, curr_offset, 1,
1555                 "%s :  Negotiation: %s",
1556                 a_bigbuf,
1557                 (oct & 0x20) ? "Reserved" : "In-band negotiation not possible");
1558
1559         other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
1560         proto_tree_add_text(subtree,
1561                 tvb, curr_offset, 1,
1562                 "%s :  Number of data bits excluding parity bit if present: %s",
1563                 a_bigbuf,
1564                 (oct & 0x10) ? "8" : "7");
1565
1566         switch (oct & 0x0f)
1567         {
1568         case 0x01: str = "0.3 kbit/s Recommendation X.1 and V.110"; break;
1569         case 0x02: str = "1.2 kbit/s Recommendation X.1 and V.110"; break;
1570         case 0x03: str = "2.4 kbit/s Recommendation X.1 and V.110"; break;
1571         case 0x04: str = "4.8 kbit/s Recommendation X.1 and V.110"; break;
1572         case 0x05: str = "9.6 kbit/s Recommendation X.1 and V.110"; break;
1573         case 0x06: str = "12.0 kbit/s transparent (non compliance with X.1 and V.110)"; break;
1574         case 0x07: str = "Reserved: was allocated in earlier phases of the protocol"; break;
1575         default:
1576                 str = "Reserved";
1577                 break;
1578         }
1579
1580         other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
1581         proto_tree_add_text(subtree,
1582                 tvb, curr_offset, 1,
1583                 "%s :  User rate: %s",
1584                 a_bigbuf,
1585                 str);
1586
1587         curr_offset++;
1588
1589         NO_MORE_DATA_CHECK(len);
1590
1591         if (!extended) goto bc_octet_7;
1592
1593         /* octet 6b */
1594
1595         item =
1596                 proto_tree_add_text(tree,
1597                 tvb, curr_offset, 1,
1598                 "Octet 6b");
1599
1600         subtree = proto_item_add_subtree(item, ett_bc_oct_6b);
1601
1602         oct = tvb_get_guint8(tvb, curr_offset);
1603
1604         extended = (oct & 0x80) ? FALSE : TRUE;
1605
1606         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1607         proto_tree_add_text(subtree,
1608                 tvb, curr_offset, 1,
1609                 "%s :  Extension: %s",
1610                 a_bigbuf,
1611                 extended ? "extended" : "not extended");
1612
1613         switch ((oct & 0x60) >> 5)
1614         {
1615         case 0x02: str = "8 kbit/s"; break;
1616         case 0x03: str = "16 kbit/s"; break;
1617         default:
1618                 str = "Reserved";
1619                 break;
1620         }
1621
1622         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
1623         proto_tree_add_text(subtree,
1624                 tvb, curr_offset, 1,
1625                 "%s :  V.110/X.30 rate adaptation Intermediate rate: %s",
1626                 a_bigbuf,
1627                 str);
1628
1629         other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
1630         proto_tree_add_text(subtree,
1631                 tvb, curr_offset, 1,
1632                 "%s :  Network independent clock (NIC) on transmission (Tx): %s to send data with network independent clock",
1633                 a_bigbuf,
1634                 (oct & 0x10) ? "requires" : "does not require");
1635
1636         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
1637         proto_tree_add_text(subtree,
1638                 tvb, curr_offset, 1,
1639                 "%s :  Network independent clock (NIC) on reception (Rx): %s accept data with network independent clock",
1640                 a_bigbuf,
1641                 (oct & 0x08) ? "can" : "cannot");
1642
1643         switch (oct & 0x07)
1644         {
1645         case 0x00: str = "Odd"; break;
1646         case 0x02: str = "Even"; break;
1647         case 0x03: str = "None"; break;
1648         case 0x04: str = "Forced to 0"; break;
1649         case 0x05: str = "Forced to 1"; break;
1650         default:
1651                 str = "Reserved";
1652                 break;
1653         }
1654
1655         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
1656         proto_tree_add_text(subtree,
1657                 tvb, curr_offset, 1,
1658                 "%s :  Parity information: %s",
1659                 a_bigbuf,
1660                 str);
1661
1662         curr_offset++;
1663
1664         NO_MORE_DATA_CHECK(len);
1665
1666         if (!extended) goto bc_octet_7;
1667
1668         /* octet 6c */
1669
1670         item =
1671                 proto_tree_add_text(tree,
1672                 tvb, curr_offset, 1,
1673                 "Octet 6c");
1674
1675         subtree = proto_item_add_subtree(item, ett_bc_oct_6c);
1676
1677         oct = tvb_get_guint8(tvb, curr_offset);
1678
1679         extended = (oct & 0x80) ? FALSE : TRUE;
1680
1681         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1682         proto_tree_add_text(subtree,
1683                 tvb, curr_offset, 1,
1684                 "%s :  Extension: %s",
1685                 a_bigbuf,
1686                 extended ? "extended" : "not extended");
1687
1688         switch ((oct & 0x60) >> 5)
1689         {
1690         case 0x01: str = "Non transparent (RLP)"; break;
1691         case 0x02: str = "Both, transparent preferred"; break;
1692         case 0x03: str = "Both, non transparent preferred"; break;
1693         default:
1694                 str = "Transparent";
1695                 break;
1696         }
1697
1698         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
1699         proto_tree_add_text(subtree,
1700                 tvb, curr_offset, 1,
1701                 "%s :  Connection element: %s",
1702                 a_bigbuf,
1703                 str);
1704
1705         switch (oct & 0x1f)
1706         {
1707         case 0x00: str = "None"; break;
1708         case 0x01: str = "V.21"; break;
1709         case 0x02: str = "V.22"; break;
1710         case 0x03: str = "V.22 bis"; break;
1711         case 0x04: str = "Reserved: was allocated in earlier phases of the protocol"; break;
1712         case 0x05: str = "V.26 ter"; break;
1713         case 0x06: str = "V.32"; break;
1714         case 0x07: str = "Modem for undefined interface"; break;
1715         case 0x08: str = "Autobauding type 1"; break;
1716         default:
1717                 str = "Reserved";
1718                 break;
1719         }
1720
1721         other_decode_bitfield_value(a_bigbuf, oct, 0x1f, 8);
1722         proto_tree_add_text(subtree,
1723                 tvb, curr_offset, 1,
1724                 "%s :  Modem type: %s",
1725                 a_bigbuf,
1726                 str);
1727
1728         curr_offset++;
1729
1730         NO_MORE_DATA_CHECK(len);
1731
1732         if (!extended) goto bc_octet_7;
1733
1734         /* octet 6d */
1735
1736         item =
1737                 proto_tree_add_text(tree,
1738                 tvb, curr_offset, 1,
1739                 "Octet 6d");
1740
1741         subtree = proto_item_add_subtree(item, ett_bc_oct_6d);
1742
1743         oct = tvb_get_guint8(tvb, curr_offset);
1744
1745         extended = (oct & 0x80) ? FALSE : TRUE;
1746
1747         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1748         proto_tree_add_text(subtree,
1749                 tvb, curr_offset, 1,
1750                 "%s :  Extension: %s",
1751                 a_bigbuf,
1752                 extended ? "extended" : "not extended");
1753
1754         switch ((oct & 0x60) >> 5)
1755         {
1756         case 0x00: str = "No other modem type specified in this field"; break;
1757         case 0x02: str = "V.34"; break;
1758         default:
1759                 str = "Reserved";
1760                 break;
1761         }
1762
1763         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
1764         proto_tree_add_text(subtree,
1765                 tvb, curr_offset, 1,
1766                 "%s :  Other modem type: %s",
1767                 a_bigbuf,
1768                 str);
1769
1770         switch (oct & 0x1f)
1771         {
1772         case 0x00: str = "Fixed network user rate not applicable/No meaning is associated with this value"; break;
1773         case 0x01: str = "9.6 kbit/s Recommendation X.1 and V.110"; break;
1774         case 0x02: str = "14.4 kbit/s Recommendation X.1 and V.110"; break;
1775         case 0x03: str = "19.2 kbit/s Recommendation X.1 and V.110"; break;
1776         case 0x04: str = "28.8 kbit/s Recommendation X.1 and V.110"; break;
1777         case 0x05: str = "38.4 kbit/s Recommendation X.1 and V.110"; break;
1778         case 0x06: str = "48.0 kbit/s Recommendation X.1 and V.110(synch)"; break;
1779         case 0x07: str = "56.0 kbit/s Recommendation X.1 and V.110(synch) /bit transparent"; break;
1780         case 0x08: str = "64.0 kbit/s bit transparent"; break;
1781         case 0x09: str = "33.6 kbit/s bit transparent"; break;
1782         case 0x0a: str = "32.0 kbit/s Recommendation I.460"; break;
1783         case 0x0b: str = "31.2 kbit/s Recommendation V.34"; break;
1784         default:
1785                 str = "Reserved";
1786                 break;
1787         }
1788
1789         other_decode_bitfield_value(a_bigbuf, oct, 0x1f, 8);
1790         proto_tree_add_text(subtree,
1791                 tvb, curr_offset, 1,
1792                 "%s :  Fixed network user rate: %s",
1793                 a_bigbuf,
1794                 str);
1795
1796         curr_offset++;
1797
1798         NO_MORE_DATA_CHECK(len);
1799
1800         if (!extended) goto bc_octet_7;
1801
1802         /* octet 6e */
1803
1804         item =
1805                 proto_tree_add_text(tree,
1806                 tvb, curr_offset, 1,
1807                 "Octet 6e");
1808
1809         subtree = proto_item_add_subtree(item, ett_bc_oct_6e);
1810
1811         oct = tvb_get_guint8(tvb, curr_offset);
1812
1813         extended = (oct & 0x80) ? FALSE : TRUE;
1814
1815         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1816         proto_tree_add_text(subtree,
1817                 tvb, curr_offset, 1,
1818                 "%s :  Extension: %s",
1819                 a_bigbuf,
1820                 extended ? "extended" : "not extended");
1821
1822         if (is_uplink == IS_UPLINK_TRUE)
1823         {
1824                 other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
1825                 proto_tree_add_text(subtree,
1826                 tvb, curr_offset, 1,
1827                 "%s :  Acceptable channel codings: TCH/F14.4 %sacceptable",
1828                 a_bigbuf,
1829                 (oct & 0x40) ? "" : "not ");
1830
1831                 other_decode_bitfield_value(a_bigbuf, oct, 0x20, 8);
1832                 proto_tree_add_text(subtree,
1833                 tvb, curr_offset, 1,
1834                 "%s :  Acceptable channel codings: Spare",
1835                 a_bigbuf);
1836
1837                 other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
1838                 proto_tree_add_text(subtree,
1839                 tvb, curr_offset, 1,
1840                 "%s :  Acceptable channel codings: TCH/F9.6 %sacceptable",
1841                 a_bigbuf,
1842                 (oct & 0x10) ? "" : "not ");
1843
1844                 other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
1845                 proto_tree_add_text(subtree,
1846                 tvb, curr_offset, 1,
1847                 "%s :  Acceptable channel codings: TCH/F4.8 %sacceptable",
1848                 a_bigbuf,
1849                 (oct & 0x08) ? "" : "not ");
1850
1851                 other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
1852                 proto_tree_add_text(subtree,
1853                 tvb, curr_offset, 1,
1854                 "%s :  Maximum number of traffic channels: %u TCH",
1855                 a_bigbuf,
1856                 (oct & 0x07) + 1);
1857         }
1858         else
1859         {
1860                 other_decode_bitfield_value(a_bigbuf, oct, 0x78, 8);
1861                 proto_tree_add_text(subtree,
1862                 tvb, curr_offset, 1,
1863                 "%s :  Acceptable channel codings: Spare",
1864                 a_bigbuf);
1865
1866                 other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
1867                 proto_tree_add_text(subtree,
1868                 tvb, curr_offset, 1,
1869                 "%s :  Maximum number of traffic channels: Spare",
1870                 a_bigbuf);
1871         }
1872
1873         curr_offset++;
1874
1875         NO_MORE_DATA_CHECK(len);
1876
1877         if (!extended) goto bc_octet_7;
1878
1879         /* octet 6f */
1880
1881         item =
1882                 proto_tree_add_text(tree,
1883                 tvb, curr_offset, 1,
1884                 "Octet 6f");
1885
1886         subtree = proto_item_add_subtree(item, ett_bc_oct_6f);
1887
1888         oct = tvb_get_guint8(tvb, curr_offset);
1889
1890         extended = (oct & 0x80) ? FALSE : TRUE;
1891
1892         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1893         proto_tree_add_text(subtree,
1894                 tvb, curr_offset, 1,
1895                 "%s :  Extension: %s",
1896                 a_bigbuf,
1897                 extended ? "extended" : "not extended");
1898
1899         switch ((oct & 0x70) >> 4)
1900         {
1901         case 0x00: str = "not allowed/required/applicable"; break;
1902         case 0x01: str = "up to 1 TCH/F allowed/may be requested"; break;
1903         case 0x02: str = "up to 2 TCH/F allowed/may be requested"; break;
1904         case 0x03: str = "up to 3 TCH/F allowed/may be requested"; break;
1905         case 0x04: str = "up to 4 TCH/F allowed/may be requested"; break;
1906         default:
1907                 str = "up to 4 TCH/F may be requested";
1908                 break;
1909         }
1910
1911         other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
1912         proto_tree_add_text(subtree,
1913                 tvb, curr_offset, 1,
1914                 "%s :  UIMI, User initiated modification indication: %s",
1915                 a_bigbuf,
1916                 str);
1917
1918         if (is_uplink == IS_UPLINK_TRUE)
1919         {
1920                 switch (oct & 0x0f)
1921                 {
1922                 case 0x00: str = "Air interface user rate not applicable/No meaning associated with this value"; break;
1923                 case 0x01: str = "9.6 kbit/s"; break;
1924                 case 0x02: str = "14.4 kbit/s"; break;
1925                 case 0x03: str = "19.2 kbit/s"; break;
1926                 case 0x05: str = "28.8 kbit/s"; break;
1927                 case 0x06: str = "38.4 kbit/s"; break;
1928                 case 0x07: str = "43.2 kbit/s"; break;
1929                 case 0x08: str = "57.6 kbit/s"; break;
1930                 case 0x09: str = "interpreted by the network as 38.4 kbit/s in this version of the protocol"; break;
1931                 case 0x0a: str = "interpreted by the network as 38.4 kbit/s in this version of the protocol"; break;
1932                 case 0x0b: str = "interpreted by the network as 38.4 kbit/s in this version of the protocol"; break;
1933                 case 0x0c: str = "interpreted by the network as 38.4 kbit/s in this version of the protocol"; break;
1934                 default:
1935                 str = "Reserved";
1936                 break;
1937                 }
1938
1939                 other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
1940                 proto_tree_add_text(subtree,
1941                 tvb, curr_offset, 1,
1942                 "%s :  Wanted air interface user rate: %s",
1943                 a_bigbuf,
1944                 str);
1945         }
1946         else
1947         {
1948                 other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
1949                 proto_tree_add_text(subtree,
1950                 tvb, curr_offset, 1,
1951                 "%s :  Wanted air interface user rate: Spare",
1952                 a_bigbuf);
1953         }
1954
1955         curr_offset++;
1956
1957         NO_MORE_DATA_CHECK(len);
1958
1959         if (!extended) goto bc_octet_7;
1960
1961         /* octet 6g */
1962
1963         item =
1964                 proto_tree_add_text(tree,
1965                 tvb, curr_offset, 1,
1966                 "Octet 6g");
1967
1968         subtree = proto_item_add_subtree(item, ett_bc_oct_6g);
1969
1970         oct = tvb_get_guint8(tvb, curr_offset);
1971
1972         extended = (oct & 0x80) ? FALSE : TRUE;
1973
1974         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
1975         proto_tree_add_text(subtree,
1976                 tvb, curr_offset, 1,
1977                 "%s :  Extension: %s",
1978                 a_bigbuf,
1979                 extended ? "extended" : "not extended");
1980
1981         if (is_uplink == IS_UPLINK_TRUE)
1982         {
1983                 other_decode_bitfield_value(a_bigbuf, oct, 0x40, 8);
1984                 proto_tree_add_text(subtree,
1985                 tvb, curr_offset, 1,
1986                 "%s :  Acceptable channel codings extended: TCH/F28.8 %sacceptable",
1987                 a_bigbuf,
1988                 (oct & 0x40) ? "" : "not ");
1989
1990                 other_decode_bitfield_value(a_bigbuf, oct, 0x20, 8);
1991                 proto_tree_add_text(subtree,
1992                 tvb, curr_offset, 1,
1993                 "%s :  Acceptable channel codings extended: TCH/F32.0 %sacceptable",
1994                 a_bigbuf,
1995                 (oct & 0x20) ? "" : "not ");
1996
1997                 other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
1998                 proto_tree_add_text(subtree,
1999                 tvb, curr_offset, 1,
2000                 "%s :  Acceptable channel codings extended: TCH/F43.2 %sacceptable",
2001                 a_bigbuf,
2002                 (oct & 0x10) ? "" : "not ");
2003
2004                 other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
2005                 proto_tree_add_text(subtree,
2006                 tvb, curr_offset, 1,
2007                 "%s :  Acceptable channel codings extended: TCH/F43.2 %sacceptable",
2008                 a_bigbuf,
2009                 (oct & 0x10) ? "" : "not ");
2010
2011                 switch ((oct & 0x0c) >> 2)
2012                 {
2013                 case 0: str = "Channel coding symmetry preferred"; break;
2014                 case 2: str = "Downlink biased channel coding asymmetry is preferred"; break;
2015                 case 1: str = "Uplink biased channel coding asymmetry is preferred"; break;
2016                 default:
2017                 str = "Unused, treat as Channel coding symmetry preferred";
2018                 break;
2019                 }
2020
2021                 other_decode_bitfield_value(a_bigbuf, oct, 0x0c, 8);
2022                 proto_tree_add_text(subtree,
2023                 tvb, curr_offset, 1,
2024                 "%s :  Channel Coding Asymmetry Indication: %s",
2025                 a_bigbuf,
2026                 str);
2027         }
2028         else
2029         {
2030                 other_decode_bitfield_value(a_bigbuf, oct, 0x7c, 8);
2031                 proto_tree_add_text(subtree,
2032                 tvb, curr_offset, 1,
2033                 "%s :  EDGE Channel Codings: Spare",
2034                 a_bigbuf);
2035         }
2036
2037         other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
2038         proto_tree_add_text(subtree,
2039                 tvb, curr_offset, 1,
2040                 "%s :  Spare",
2041                 a_bigbuf);
2042
2043         curr_offset++;
2044
2045         NO_MORE_DATA_CHECK(len);
2046
2047 bc_octet_7:
2048         /* octet 7 */
2049
2050         item =
2051                 proto_tree_add_text(tree,
2052                 tvb, curr_offset, 1,
2053                 "Octet 7");
2054
2055         subtree = proto_item_add_subtree(item, ett_bc_oct_7);
2056                 extended = (oct & 0x80) ? FALSE : TRUE;
2057                 oct = tvb_get_guint8(tvb, curr_offset);
2058                 other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
2059         proto_tree_add_text(subtree,
2060                 tvb, curr_offset, 1,
2061                 "%s :  Extension: %s",
2062                 a_bigbuf,
2063                 extended ? "extended" : "not extended");
2064
2065         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
2066         proto_tree_add_text(subtree,
2067                 tvb, curr_offset, 1,
2068                 "%s :  Layer 2 Identity: %s",
2069                 a_bigbuf,
2070                 ((oct & 0x60) == 0x40) ? "Octet identifier" : "Reserved");
2071
2072         switch (oct & 0x1f)
2073         {
2074         case 0x06: str = "Reserved: was allocated in earlier phases of the protocol"; break;
2075         case 0x08: str = "ISO 6429, codeset 0 (DC1/DC3)"; break;
2076         case 0x09: str = "Reserved: was allocated but never used in earlier phases of the protocol"; break;
2077         case 0x0a: str = "Videotex profile 1"; break;
2078         case 0x0c: str = "COPnoFlCt (Character oriented Protocol with no Flow Control mechanism)"; break;
2079         case 0x0d: str = "Reserved: was allocated in earlier phases of the protocol"; break;
2080         default:
2081                 str = "Reserved";
2082                 break;
2083         }
2084
2085         other_decode_bitfield_value(a_bigbuf, oct, 0x1f, 8);
2086         proto_tree_add_text(subtree,
2087                 tvb, curr_offset, 1,
2088                 "%s :  User information layer 2 protocol: %s",
2089                 a_bigbuf,
2090                 str);
2091         break;
2092         }
2093
2094         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
2095
2096         return(curr_offset - offset);
2097 }
2098
2099
2100 guint16
2101 de_bearer_cap_uplink(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
2102 {
2103         is_uplink = IS_UPLINK_TRUE;
2104         return de_bearer_cap(tvb, tree, offset, len, add_string, string_len);
2105
2106 }
2107
2108 /*
2109  * [3] 10.5.4.5a Call Control Capabilities
2110  */
2111
2112 static guint16
2113 de_cc_cap(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
2114 {
2115         guint8  oct;
2116         guint32 curr_offset;
2117
2118         curr_offset = offset;
2119
2120         oct = tvb_get_guint8(tvb, curr_offset);
2121
2122         other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
2123
2124         switch ((oct & 0xf0) >> 4)
2125         {
2126         case 0:
2127         proto_tree_add_text(tree,
2128                 tvb, curr_offset, 1,
2129                 "%s :  Maximum number of supported bearers: 1",
2130                 a_bigbuf);
2131         break;
2132
2133         default:
2134         proto_tree_add_text(tree,
2135                 tvb, curr_offset, 1,
2136                 "%s :  Maximum number of supported bearers: %u",
2137                 a_bigbuf,
2138                 (oct & 0xf0) >> 4);
2139         break;
2140         }
2141
2142         other_decode_bitfield_value(a_bigbuf, oct, 0x0c, 8);
2143         proto_tree_add_text(tree,
2144                 tvb, curr_offset, 1,
2145                 "%s :  Spare",
2146                 a_bigbuf);
2147
2148         other_decode_bitfield_value(a_bigbuf, oct, 0x02, 8);
2149                 proto_tree_add_text(tree,
2150                 tvb, curr_offset, 1,
2151                 "%s :  PCP: the mobile station %s the Prolonged Clearing Procedure",
2152                 a_bigbuf,
2153                 (oct & 0x02) ? "supports" : "does not support");
2154
2155         other_decode_bitfield_value(a_bigbuf, oct, 0x01, 8);
2156         proto_tree_add_text(tree,
2157                 tvb, curr_offset, 1,
2158                 "%s :  DTMF: %s",
2159                 a_bigbuf,
2160                 (oct & 0x01) ?
2161                         "the mobile station supports DTMF as specified in subclause 5.5.7 of TS 24.008" :
2162                         "reserved for earlier versions of the protocol");
2163
2164         curr_offset++;
2165
2166         NO_MORE_DATA_CHECK(len);
2167
2168         oct = tvb_get_guint8(tvb, curr_offset);
2169
2170         other_decode_bitfield_value(a_bigbuf, oct, 0xf0, 8);
2171         proto_tree_add_text(tree,
2172                 tvb, curr_offset, 1,
2173                 "%s :  Spare",
2174                 a_bigbuf);
2175
2176         other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
2177         proto_tree_add_text(tree,
2178                 tvb, curr_offset, 1,
2179                 "%s :  Maximum number of speech bearers: %u",
2180                 a_bigbuf,
2181                 oct & 0x0f);
2182
2183         curr_offset++;
2184
2185         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
2186
2187         return(curr_offset - offset);
2188 }
2189
2190 /*
2191  * [3] 10.5.4.6 Call state
2192  */
2193 static guint16
2194 de_call_state(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string _U_, int string_len _U_)
2195 {
2196         guint8  oct;
2197         guint32 curr_offset;
2198         proto_tree      *subtree;
2199         proto_item      *item;
2200         const gchar *str;
2201
2202         curr_offset = offset;
2203
2204         oct = tvb_get_guint8(tvb, curr_offset);
2205
2206         item =
2207         proto_tree_add_text(tree,
2208                 tvb, curr_offset, 1, "%s",
2209                 gsm_dtap_elem_strings[DE_CALL_STATE].strptr);
2210
2211         subtree = proto_item_add_subtree(item, ett_gsm_dtap_elem[DE_CALL_STATE]);
2212
2213         switch ((oct & 0xc0) >> 6)
2214         {
2215         case 0: str = "Coding as specified in ITU-T Rec. Q.931"; break;
2216         case 1: str = "Reserved for other international standards"; break;
2217         case 2: str = "National standard"; break;
2218         default:
2219                 str = "Standard defined for the GSM PLMNS";
2220                 break;
2221         }
2222
2223         other_decode_bitfield_value(a_bigbuf, oct, 0xc0, 8);
2224         proto_tree_add_text(subtree,
2225                 tvb, curr_offset, 1,
2226                 "%s :  Coding standard: %s",
2227                 a_bigbuf,
2228                 str);
2229
2230         switch (oct & 0x3f)
2231         {
2232         case 0x00: str = "UO - null                                 NO - null"; break;
2233         case 0x02: str = "U0.1- MM connection pending               N0.1- MM connection pending"; break;
2234         case 0x22: str = "U0.2- CC prompt present                   N0.2- CC connection pending"; break;
2235         case 0x23: str = "U0.3- Wait for network information        N0.3- Network answer pending"; break;
2236         case 0x24: str = "U0.4- CC-Establishment present            N0.4- CC-Establishment present"; break;
2237         case 0x25: str = "U0.5- CC-Establishment confirmed          N0.5- CC-Establishment confirmed"; break;
2238         case 0x26: str = "U0.6- Recall present                      N0.6- Recall present"; break;
2239         case 0x01: str = "U1 - call initiated                       N1 - call initiated"; break;
2240         case 0x03: str = "U3 - mobile originating call proceeding   N3 - mobile originating call proceeding"; break;
2241         case 0x04: str = "U4 - call delivered                       N4 - call delivered"; break;
2242         case 0x06: str = "U6 - call present                         N6 - call present"; break;
2243         case 0x07: str = "U7 - call received                        N7 - call received"; break;
2244         case 0x08: str = "U8 - connect request                      N8 - connect request"; break;
2245         case 0x09: str = "U9 - mobile terminating call confirmed    N9 - mobile terminating call confirmed"; break;
2246         case 0x0a: str = "U10- active                               N10- active"; break;
2247         case 0x0b: str = "U11- disconnect request"; break;
2248         case 0x0c: str = "U12- disconnect indication                N12-disconnect indication"; break;
2249         case 0x13: str = "U19- release request                      N19- release request"; break;
2250         case 0x1a: str = "U26- mobile originating modify            N26- mobile originating modify"; break;
2251         case 0x1b: str = "U27- mobile terminating modify            N27- mobile terminating modify"; break;
2252         case 0x1c: str = "                                          N28- connect indication"; break;
2253         default:
2254                 str = "Unknown";
2255                 break;
2256         }
2257
2258         other_decode_bitfield_value(a_bigbuf, oct, 0x3f, 8);
2259         proto_tree_add_text(subtree,
2260                 tvb, curr_offset, 1,
2261                 "%s :  Call state value: %s",
2262                 a_bigbuf,
2263                 str);
2264
2265         curr_offset++;
2266
2267         /* no length check possible */
2268
2269         return(curr_offset - offset);
2270 }
2271
2272 static const true_false_string gsm_a_extension_value = {
2273         "No Extension",
2274         "Extension"
2275 };
2276
2277 const value_string gsm_a_type_of_number_values[] = {
2278         { 0x00, "unknown" },
2279         { 0x01, "International Number" },
2280         { 0x02, "National number" },
2281         { 0x03, "Network Specific Number" },
2282         { 0x04, "Dedicated access, short code" },
2283         { 0x05, "Reserved" },
2284         { 0x06, "Reserved" },
2285         { 0x07, "Reserved for extension" },
2286         { 0, NULL }
2287 };
2288
2289 const value_string gsm_a_numbering_plan_id_values[] = {
2290         { 0x00, "unknown" },
2291         { 0x01, "ISDN/Telephony Numbering (Rec ITU-T E.164)" },
2292         { 0x02, "spare" },
2293         { 0x03, "Data Numbering (ITU-T Rec. X.121)" },
2294         { 0x04, "Telex Numbering (ITU-T Rec. F.69)" },
2295         { 0x08, "National Numbering" },
2296         { 0x09, "Private Numbering" },
2297         { 0x0d, "reserved for CTS (see 3GPP TS 44.056 [91])" },
2298         { 0x0f, "Reserved for extension" },
2299         { 0, NULL }
2300 };
2301
2302 /*
2303  * [3] 10.5.4.7 Called party BCD number
2304  */
2305 guint16
2306 de_cld_party_bcd_num(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
2307 {
2308         guint8  *poctets;
2309         guint32 curr_offset;
2310
2311         curr_offset = offset;
2312
2313         proto_tree_add_item(tree, hf_gsm_a_extension, tvb, curr_offset, 1, FALSE);
2314         proto_tree_add_item(tree, hf_gsm_a_type_of_number , tvb, curr_offset, 1, FALSE);
2315         proto_tree_add_item(tree, hf_gsm_a_numbering_plan_id , tvb, curr_offset, 1, FALSE);
2316
2317         curr_offset++;
2318
2319         NO_MORE_DATA_CHECK(len);
2320
2321         poctets = tvb_get_ephemeral_string(tvb, curr_offset, len - (curr_offset - offset));
2322
2323         my_dgt_tbcd_unpack(a_bigbuf, poctets, len - (curr_offset - offset),
2324                 &Dgt_mbcd);
2325
2326         proto_tree_add_string_format(tree, hf_gsm_a_cld_party_bcd_num,
2327                 tvb, curr_offset, len - (curr_offset - offset),
2328                 a_bigbuf,
2329                 "BCD Digits: %s",
2330                 a_bigbuf);
2331
2332         if (sccp_assoc && ! sccp_assoc->called_party) {
2333                 sccp_assoc->called_party = se_strdup(a_bigbuf);
2334         }
2335
2336         curr_offset += len - (curr_offset - offset);
2337
2338         if (add_string)
2339                 g_snprintf(add_string, string_len, " - (%s)", a_bigbuf);
2340
2341         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
2342
2343         return(curr_offset - offset);
2344 }
2345
2346 /*
2347  * [3] 10.5.4.8 Called party subaddress
2348  */
2349 static guint16
2350 de_cld_party_sub_addr(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
2351 {
2352         guint8  oct;
2353         guint32 curr_offset;
2354         const gchar *str;
2355
2356         curr_offset = offset;
2357
2358         oct = tvb_get_guint8(tvb, curr_offset);
2359
2360         proto_tree_add_item(tree, hf_gsm_a_extension, tvb, curr_offset, 1, FALSE);
2361
2362         switch ((oct & 0x70) >> 4)
2363         {
2364         case 0: str = "NSAP (X.213/ISO 8348 AD2)"; break;
2365         case 2: str = "User specified"; break;
2366         default:
2367                 str = "Reserved";
2368                 break;
2369         }
2370
2371         other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
2372         proto_tree_add_text(tree,
2373                 tvb, curr_offset, 1,
2374                 "%s :  Type of subaddress: %s",
2375                 a_bigbuf,
2376                 str);
2377
2378         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
2379         proto_tree_add_text(tree,
2380                 tvb, curr_offset, 1,
2381                 "%s :  Odd/Even indicator: %s",
2382                 a_bigbuf,
2383                 (oct & 0x08) ?
2384                         "odd number of address signals" : "even number of address signals");
2385
2386         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
2387         proto_tree_add_text(tree,
2388                 tvb, curr_offset, 1,
2389                 "%s :  Spare",
2390                 a_bigbuf);
2391
2392         curr_offset++;
2393
2394         NO_MORE_DATA_CHECK(len);
2395
2396         proto_tree_add_text(tree,
2397                 tvb, curr_offset, len - (curr_offset - offset),
2398                 "Subaddress information");
2399
2400         curr_offset += len - (curr_offset - offset);
2401
2402         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
2403
2404         return(curr_offset - offset);
2405 }
2406
2407 /* 3GPP TS 24.008
2408  * [3] 10.5.4.9 Calling party BCD number
2409  */
2410 static guint16
2411 de_clg_party_bcd_num(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
2412 {
2413         guint8  oct;
2414         guint8  *poctets;
2415         guint32 curr_offset;
2416         const gchar *str;
2417
2418         curr_offset = offset;
2419
2420         proto_tree_add_item(tree, hf_gsm_a_extension, tvb, curr_offset, 1, FALSE);
2421         proto_tree_add_item(tree, hf_gsm_a_type_of_number , tvb, curr_offset, 1, FALSE);
2422         proto_tree_add_item(tree, hf_gsm_a_numbering_plan_id , tvb, curr_offset, 1, FALSE);
2423
2424         curr_offset++;
2425
2426         oct = tvb_get_guint8(tvb, curr_offset);
2427
2428         proto_tree_add_item(tree, hf_gsm_a_extension, tvb, curr_offset, 1, FALSE);
2429
2430         switch ((oct & 0x60) >> 5)
2431         {
2432         case 0: str = "Presentation allowed"; break;
2433         case 1: str = "Presentation restricted"; break;
2434         case 2: str = "Number not available due to interworking"; break;
2435         default:
2436                 str = "Reserved";
2437                 break;
2438         }
2439
2440         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
2441         proto_tree_add_text(tree,
2442                 tvb, curr_offset, 1,
2443                 "%s :  Presentation indicator: %s",
2444                 a_bigbuf,
2445                 str);
2446
2447         other_decode_bitfield_value(a_bigbuf, oct, 0x1c, 8);
2448         proto_tree_add_text(tree,
2449                 tvb, curr_offset, 1,
2450                 "%s :  Spare",
2451                 a_bigbuf);
2452
2453         switch (oct & 0x03)
2454         {
2455         case 0: str = "User-provided, not screened"; break;
2456         case 1: str = "User-provided, verified and passed"; break;
2457         case 2: str = "User-provided, verified and failed"; break;
2458         default:
2459                 str = "Network provided";
2460                 break;
2461         }
2462
2463         other_decode_bitfield_value(a_bigbuf, oct, 0x03, 8);
2464         proto_tree_add_text(tree,
2465                 tvb, curr_offset, 1,
2466                 "%s :  Screening indicator: %s",
2467                 a_bigbuf,
2468                 str);
2469
2470         curr_offset++;
2471
2472         NO_MORE_DATA_CHECK(len);
2473
2474         poctets = tvb_get_ephemeral_string(tvb, curr_offset, len - (curr_offset - offset));
2475
2476         my_dgt_tbcd_unpack(a_bigbuf, poctets, len - (curr_offset - offset),
2477                 &Dgt_mbcd);
2478
2479         proto_tree_add_string_format(tree, hf_gsm_a_clg_party_bcd_num,
2480                 tvb, curr_offset, len - (curr_offset - offset),
2481                 a_bigbuf,
2482                 "BCD Digits: %s",
2483                 a_bigbuf);
2484
2485         curr_offset += len - (curr_offset - offset);
2486
2487         if (add_string)
2488         g_snprintf(add_string, string_len, " - (%s)", a_bigbuf);
2489
2490         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
2491
2492         return(curr_offset - offset);
2493 }
2494
2495 /*
2496  * [3] 10.5.4.10 Calling party subaddress
2497  */
2498 static guint16
2499 de_clg_party_sub_addr(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
2500 {
2501         guint8  oct;
2502         guint32 curr_offset;
2503         const gchar *str;
2504
2505         curr_offset = offset;
2506
2507         oct = tvb_get_guint8(tvb, curr_offset);
2508
2509         proto_tree_add_item(tree, hf_gsm_a_extension, tvb, curr_offset, 1, FALSE);
2510
2511         switch ((oct & 0x70) >> 4)
2512         {
2513         case 0: str = "NSAP (X.213/ISO 8348 AD2)"; break;
2514         case 2: str = "User specified"; break;
2515         default:
2516                 str = "Reserved";
2517                 break;
2518         }
2519
2520         other_decode_bitfield_value(a_bigbuf, oct, 0x70, 8);
2521         proto_tree_add_text(tree,
2522                 tvb, curr_offset, 1,
2523                 "%s :  Type of subaddress: %s",
2524                 a_bigbuf,
2525                 str);
2526
2527         other_decode_bitfield_value(a_bigbuf, oct, 0x08, 8);
2528         proto_tree_add_text(tree,
2529                 tvb, curr_offset, 1,
2530                 "%s :  Odd/Even indicator: %s",
2531                 a_bigbuf,
2532                 (oct & 0x08) ?
2533                         "odd number of address signals" : "even number of address signals");
2534
2535         other_decode_bitfield_value(a_bigbuf, oct, 0x07, 8);
2536         proto_tree_add_text(tree,
2537                 tvb, curr_offset, 1,
2538                 "%s :  Spare",
2539                 a_bigbuf);
2540
2541         curr_offset++;
2542
2543         NO_MORE_DATA_CHECK(len);
2544
2545         proto_tree_add_text(tree,
2546                 tvb, curr_offset, len - (curr_offset - offset),
2547                 "Subaddress information");
2548
2549         curr_offset += len - (curr_offset - offset);
2550
2551         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
2552
2553         return(curr_offset - offset);
2554 }
2555
2556 /*
2557  * [3] 10.5.4.11 Cause
2558  */
2559 static guint16
2560 de_cause(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string, int string_len)
2561 {
2562         guint8  oct;
2563         guint8  cause;
2564         guint32 curr_offset;
2565         const gchar *str;
2566
2567         curr_offset = offset;
2568
2569         oct = tvb_get_guint8(tvb, curr_offset);
2570
2571         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
2572         proto_tree_add_text(tree,
2573                 tvb, curr_offset, 1,
2574                 "%s :  Extension: %s",
2575                 a_bigbuf,
2576                 (oct & 0x80) ? "not extended" : "extended");
2577
2578         switch ((oct & 0x60) >> 5)
2579         {
2580         case 0: str = "Coding as specified in ITU-T Rec. Q.931"; break;
2581         case 1: str = "Reserved for other international standards"; break;
2582         case 2: str = "National standard"; break;
2583         default:
2584                 str = "Standard defined for the GSM PLMNS";
2585                 break;
2586         }
2587
2588         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
2589         proto_tree_add_text(tree,
2590         tvb, curr_offset, 1,
2591         "%s :  Coding standard: %s",
2592         a_bigbuf,
2593         str);
2594
2595         other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
2596         proto_tree_add_text(tree,
2597         tvb, curr_offset, 1,
2598         "%s :  Spare",
2599         a_bigbuf);
2600
2601         switch (oct & 0x0f)
2602         {
2603         case 0: str = "User"; break;
2604         case 1: str = "Private network serving the local user"; break;
2605         case 2: str = "Public network serving the local user"; break;
2606         case 3: str = "Transit network"; break;
2607         case 4: str = "Public network serving the remote user"; break;
2608         case 5: str = "Private network serving the remote user"; break;
2609         case 7: str = "International network"; break;
2610         case 10: str = "Network beyond interworking point"; break;
2611         default:
2612                 str = "Reserved";
2613                 break;
2614         }
2615
2616         other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
2617         proto_tree_add_text(tree,
2618                 tvb, curr_offset, 1,
2619                 "%s :  Location: %s",
2620                 a_bigbuf,
2621                 str);
2622
2623         curr_offset++;
2624
2625         oct = tvb_get_guint8(tvb, curr_offset);
2626
2627         if (!(oct & 0x80))
2628         {
2629         proto_tree_add_item(tree, hf_gsm_a_extension, tvb, curr_offset, 1, FALSE);
2630
2631         other_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8);
2632         proto_tree_add_text(tree,
2633                 tvb, curr_offset, 1,
2634                 "%s :  Recommendation",
2635                 a_bigbuf);
2636
2637         curr_offset++;
2638
2639         oct = tvb_get_guint8(tvb, curr_offset);
2640         }
2641
2642         proto_tree_add_item(tree, hf_gsm_a_extension, tvb, curr_offset, 1, FALSE);
2643
2644         cause = oct & 0x7f;
2645         switch (cause)
2646         {
2647         case 1: str = "Unassigned (unallocated) number"; break;
2648         case 3: str = "No route to destination"; break;
2649         case 6: str = "Channel unacceptable"; break;
2650         case 8: str = "Operator determined barring"; break;
2651         case 16: str = "Normal call clearing"; break;
2652         case 17: str = "User busy"; break;
2653         case 18: str = "No user responding"; break;
2654         case 19: str = "User alerting, no answer"; break;
2655         case 21: str = "Call rejected"; break;
2656         case 22: str = "Number changed"; break;
2657         case 25: str = "Pre-emption"; break;
2658         case 26: str = "Non selected user clearing"; break;
2659         case 27: str = "Destination out of order"; break;
2660         case 28: str = "Invalid number format (incomplete number)"; break;
2661         case 29: str = "Facility rejected"; break;
2662         case 30: str = "Response to STATUS ENQUIRY"; break;
2663         case 31: str = "Normal, unspecified"; break;
2664         case 34: str = "No circuit/channel available"; break;
2665         case 38: str = "Network out of order"; break;
2666         case 41: str = "Temporary failure"; break;
2667         case 42: str = "Switching equipment congestion"; break;
2668         case 43: str = "Access information discarded"; break;
2669         case 44: str = "requested circuit/channel not available"; break;
2670         case 47: str = "Resources unavailable, unspecified"; break;
2671         case 49: str = "Quality of service unavailable"; break;
2672         case 50: str = "Requested facility not subscribed"; break;
2673         case 55: str = "Incoming calls barred within the CUG"; break;
2674         case 57: str = "Bearer capability not authorized"; break;
2675         case 58: str = "Bearer capability not presently available"; break;
2676         case 63: str = "Service or option not available, unspecified"; break;
2677         case 65: str = "Bearer service not implemented"; break;
2678         case 68: str = "ACM equal to or greater than ACMmax"; break;
2679         case 69: str = "Requested facility not implemented"; break;
2680         case 70: str = "Only restricted digital information bearer capability is available"; break;
2681         case 79: str = "Service or option not implemented, unspecified"; break;
2682         case 81: str = "Invalid transaction identifier value"; break;
2683         case 87: str = "User not member of CUG"; break;
2684         case 88: str = "Incompatible destination"; break;
2685         case 91: str = "Invalid transit network selection"; break;
2686         case 95: str = "Semantically incorrect message"; break;
2687         case 96: str = "Invalid mandatory information"; break;
2688         case 97: str = "Message type non-existent or not implemented"; break;
2689         case 98: str = "Message type not compatible with protocol state"; break;
2690         case 99: str = "Information element non-existent or not implemented"; break;
2691         case 100: str = "Conditional IE error"; break;
2692         case 101: str = "Message not compatible with protocol state"; break;
2693         case 102: str = "Recovery on timer expiry"; break;
2694         case 111: str = "Protocol error, unspecified"; break;
2695         case 127: str = "Interworking, unspecified"; break;
2696         default:
2697                 if (cause <= 31) { str = "Treat as Normal, unspecified"; }
2698                 else if ((cause >= 32) && (cause <= 47)) { str = "Treat as Resources unavailable, unspecified"; }
2699                 else if ((cause >= 48) && (cause <= 63)) { str = "Treat as Service or option not available, unspecified"; }
2700                 else if ((cause >= 64) && (cause <= 79)) { str = "Treat as Service or option not implemented, unspecified"; }
2701                 else if ((cause >= 80) && (cause <= 95)) { str = "Treat as Semantically incorrect message"; }
2702                 else if ((cause >= 96) && (cause <= 111)) { str = "Treat as Protocol error, unspecified"; }
2703                 else if ((cause >= 112) && (cause <= 127)) { str = "Treat as Interworking, unspecified"; }
2704                 break;
2705         }
2706
2707         other_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8);
2708         proto_tree_add_uint_format(tree, hf_gsm_a_dtap_cause,
2709                 tvb, curr_offset, 1, cause,
2710                 "%s :  Cause: (%u) %s",
2711                 a_bigbuf,
2712                 cause,
2713                 str);
2714
2715         curr_offset++;
2716
2717         if (add_string)
2718                 g_snprintf(add_string, string_len, " - (%u) %s", cause, str);
2719
2720         NO_MORE_DATA_CHECK(len);
2721
2722         proto_tree_add_text(tree,
2723                 tvb, curr_offset, len - (curr_offset - offset),
2724                 "Diagnostics");
2725
2726         curr_offset += len - (curr_offset - offset);
2727
2728         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
2729
2730         return(curr_offset - offset);
2731 }
2732 /*
2733  * 10.5.4.11a CLIR suppression
2734  * No data
2735  */
2736 /*
2737  * 10.5.4.11b CLIR invocation
2738  * No data
2739  */
2740 /*
2741  * 10.5.4.12 Congestion level
2742  *  handled inline
2743  */
2744 /*
2745  * 10.5.4.13 Connected number
2746  */
2747 /*
2748  * 10.5.4.14 Connected subaddress
2749  */
2750 /*
2751  * 10.5.4.15 Facility
2752  */
2753
2754 static guint16
2755 de_facility(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint fac_len, gchar *add_string _U_, int string_len _U_)
2756 {
2757         guint   saved_offset;
2758         gint8 class;
2759         gboolean pc;
2760         gboolean ind = FALSE;
2761         guint32 component_len = 0;
2762         guint32 header_end_offset;
2763         guint32 header_len;
2764         asn1_ctx_t asn1_ctx;
2765         tvbuff_t *SS_tvb = NULL;
2766         void *save_private_data;
2767         static gint comp_type_tag;
2768
2769         asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, gsm_a_dtap_pinfo);
2770
2771         save_private_data= gsm_a_dtap_pinfo->private_data;
2772         saved_offset = offset;
2773         gsm_a_dtap_pinfo->private_data = NULL;
2774         while ( fac_len > (offset - saved_offset)){
2775
2776                 /* Get the length of the component there can be more than one component in a facility message */
2777
2778                 header_end_offset = get_ber_identifier(tvb, offset, &class, &pc, &comp_type_tag);
2779                 header_end_offset = get_ber_length(tvb, header_end_offset, &component_len, &ind);
2780                 if (ind){
2781                         proto_tree_add_text(tree, tvb, offset+1, 1,
2782                                 "Indefinte length, ignoring component");
2783                         return (fac_len);
2784                 }
2785                 header_len = header_end_offset - offset;
2786                 component_len = header_len + component_len;
2787                 /*
2788                 dissect_ROS_Component(FALSE, tvb, offset, &asn1_ctx, tree, hf_ROS_component);
2789                 TODO Call gsm map here
2790                 */
2791                 SS_tvb = tvb_new_subset(tvb, offset, component_len, component_len);
2792                 call_dissector(gsm_map_handle, SS_tvb, gsm_a_dtap_pinfo, tree);
2793                 offset = offset + component_len;
2794         }
2795         gsm_a_dtap_pinfo->private_data = save_private_data;
2796         return(fac_len);
2797 }
2798 /*
2799  * 10.5.4.16 High layer compatibility
2800  */
2801
2802 /*
2803  * [3] 10.5.4.17 Keypad facility
2804  */
2805 static guint16
2806 de_keypad_facility(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
2807 {
2808         guint8  oct;
2809         guint32 curr_offset;
2810
2811         curr_offset = offset;
2812
2813         oct = tvb_get_guint8(tvb, curr_offset);
2814
2815         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
2816         proto_tree_add_text(tree,
2817                 tvb, curr_offset, 1,
2818                 "%s :  Spare",
2819                 a_bigbuf);
2820
2821         other_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8);
2822         proto_tree_add_text(tree,
2823                 tvb, curr_offset, 1,
2824                 "%s :  Keypad information: %c",
2825                 a_bigbuf,
2826                 oct & 0x7f);
2827
2828         curr_offset++;
2829
2830         if (add_string)
2831                 g_snprintf(add_string, string_len, " - %c", oct & 0x7f);
2832
2833         /* no length check possible */
2834
2835         return(curr_offset - offset);
2836 }
2837
2838 /*
2839  * 10.5.4.18 Low layer compatibility
2840  */
2841 static guint16
2842 de_llc(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
2843 {
2844         guint32 curr_offset;
2845
2846         curr_offset = offset;
2847
2848         dissect_q931_bearer_capability_ie(tvb, offset, len, tree);
2849
2850         curr_offset = curr_offset + len;
2851         return(curr_offset - offset);
2852 }
2853
2854 /*
2855  * 10.5.4.19 More data
2856  * No data
2857  */
2858 /*
2859  * 10.5.4.20 Notification indicator
2860  */
2861
2862
2863 /*
2864  * [3] 10.5.4.21 Progress indicator
2865  */
2866 static guint16
2867 de_prog_ind(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string, int string_len)
2868 {
2869         guint8  oct;
2870         guint32 curr_offset;
2871         const gchar *str;
2872
2873         curr_offset = offset;
2874
2875         oct = tvb_get_guint8(tvb, curr_offset);
2876
2877         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
2878         proto_tree_add_text(tree,
2879                 tvb, curr_offset, 1,
2880                 "%s :  Extension: %s",
2881                 a_bigbuf,
2882                 (oct & 0x80) ? "extended" : "not extended");
2883
2884         switch ((oct & 0x60) >> 5)
2885         {
2886         case 0: str = "Coding as specified in ITU-T Rec. Q.931"; break;
2887         case 1: str = "Reserved for other international standards"; break;
2888         case 2: str = "National standard"; break;
2889         default:
2890                 str = "Standard defined for the GSM PLMNS";
2891                 break;
2892         }
2893
2894         other_decode_bitfield_value(a_bigbuf, oct, 0x60, 8);
2895         proto_tree_add_text(tree,
2896                 tvb, curr_offset, 1,
2897                 "%s :  Coding standard: %s",
2898                 a_bigbuf,
2899                 str);
2900
2901         other_decode_bitfield_value(a_bigbuf, oct, 0x10, 8);
2902         proto_tree_add_text(tree,
2903                 tvb, curr_offset, 1,
2904                 "%s :  Spare",
2905                 a_bigbuf);
2906
2907         switch (oct & 0x0f)
2908         {
2909         case 0: str = "User"; break;
2910         case 1: str = "Private network serving the local user"; break;
2911         case 2: str = "Public network serving the local user"; break;
2912         case 4: str = "Public network serving the remote user"; break;
2913         case 5: str = "Private network serving the remote user"; break;
2914         case 10: str = "Network beyond interworking point"; break;
2915         default:
2916                 str = "Reserved";
2917                 break;
2918         }
2919
2920         other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
2921         proto_tree_add_text(tree,
2922                 tvb, curr_offset, 1,
2923                 "%s :  Location: %s",
2924                 a_bigbuf,
2925                 str);
2926
2927         curr_offset++;
2928
2929         oct = tvb_get_guint8(tvb, curr_offset);
2930
2931         other_decode_bitfield_value(a_bigbuf, oct, 0x80, 8);
2932         proto_tree_add_text(tree,
2933                 tvb, curr_offset, 1,
2934                 "%s :  Extension: %s",
2935                 a_bigbuf,
2936                 (oct & 0x80) ? "extended" : "not extended");
2937
2938         switch (oct & 0x7f)
2939         {
2940         case 1: str = "Call is not end-to-end PLMN/ISDN, further call progress information may be available in-band"; break;
2941         case 2: str = "Destination address in non-PLMN/ISDN"; break;
2942         case 3: str = "Origination address in non-PLMN/ISDN"; break;
2943         case 4: str = "Call has returned to the PLMN/ISDN"; break;
2944         case 8: str = "In-band information or appropriate pattern now available"; break;
2945         case 32: str = "Call is end-to-end PLMN/ISDN"; break;
2946         case 64: str = "Queueing"; break;
2947         default:
2948                 str = "Unspecific";
2949                 break;
2950         }
2951
2952         other_decode_bitfield_value(a_bigbuf, oct, 0x7f, 8);
2953         proto_tree_add_text(tree,
2954                 tvb, curr_offset, 1,
2955                 "%s :  Progress Description: %s (%d)",
2956                 a_bigbuf,
2957                 str,
2958                 oct & 0x7f);
2959
2960         if (add_string)
2961                 g_snprintf(add_string, string_len, " - %d", oct & 0x7f);
2962
2963         curr_offset++;
2964
2965         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
2966
2967         return(curr_offset - offset);
2968 }
2969 /*
2970  * 10.5.4.21b Redirecting party BCD number
2971  */
2972 /*
2973  * 10.5.4.21c Redirecting party subaddress
2974  */
2975 /*
2976  * [3] 10.5.4.22 Repeat indicator
2977  */
2978 static guint16
2979 de_repeat_ind(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len _U_, gchar *add_string _U_, int string_len _U_)
2980 {
2981         guint8  oct;
2982         guint32 curr_offset;
2983         const gchar *str;
2984
2985         curr_offset = offset;
2986
2987         oct = tvb_get_guint8(tvb, curr_offset);
2988
2989         switch (oct & 0x0f)
2990         {
2991         case 1: str = "Circular for successive selection 'mode 1 alternate mode 2'"; break;
2992         case 2: str = "Support of fallback mode 1 preferred, mode 2 selected if setup of mode 1 fails"; break;
2993         case 3: str = "Reserved: was allocated in earlier phases of the protocol"; break;
2994         default:
2995                 str = "Reserved";
2996                 break;
2997         }
2998
2999         other_decode_bitfield_value(a_bigbuf, oct, 0x0f, 8);
3000         proto_tree_add_text(tree,
3001                 tvb, curr_offset, 1,
3002                 "%s :  %s",
3003                 a_bigbuf,
3004                 str);
3005
3006         curr_offset++;
3007
3008         /* no length check possible */
3009
3010         return(curr_offset - offset);
3011 }
3012 /*
3013  * 10.5.4.22a Reverse call setup direction
3014  * No data
3015  */
3016 /*
3017  * 10.5.4.22b SETUP Container $(CCBS)$
3018  */
3019 /*
3020  * 10.5.4.23 Signal
3021  */
3022 /*
3023  * 10.5.4.24 SS Version Indicator
3024  */
3025 static guint16
3026 de_ss_ver_ind(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint len, gchar *add_string _U_, int string_len _U_)
3027 {
3028         guint8  oct;
3029         guint32 curr_offset;
3030         const gchar *str;
3031
3032         curr_offset = offset;
3033
3034         oct = tvb_get_guint8(tvb, curr_offset);
3035
3036         switch (oct)
3037         {
3038         case 0: str = "Phase 2 service, ellipsis notation, and phase 2 error handling is supported"; break;
3039         case 1: str = "SS-Protocol version 3 is supported, and phase 2 error handling is supported"; break;
3040         default:
3041                 str = "Reserved";
3042                 break;
3043         }
3044
3045         proto_tree_add_text(tree,
3046                 tvb, curr_offset, 1,
3047                 "%s",
3048                 str);
3049
3050         curr_offset++;
3051
3052         EXTRANEOUS_DATA_CHECK(len, curr_offset - offset);
3053
3054         return(curr_offset - offset);
3055 }
3056 /*
3057  * 10.5.4.25 User-user
3058  */
3059 /*
3060 User-user protocol discriminator (octet 3)
3061 Bits
3062 8       7       6       5       4       3       2       1               
3063 0       0       0       0       0       0       0       0               User specific protocol (Note 1)
3064 0       0       0       0       0       0       0       1               OSI high layer protocols
3065 0       0       0       0       0       0       1       0               X.244 (Note 2)
3066 0       0       0       0       0       0       1       1               Reserved for system management convergence function
3067 0       0       0       0       0       1       0       0               IA5 characters (Note 3)
3068 0       0       0       0       0       1       1       1               Rec.V.120 rate adaption
3069 0       0       0       0       1       0       0       0               Q.931 (I.451) user-network call control messages
3070                                                                         
3071 0       0       0       1       0       0       0       0               Reserved for other network layer or
3072 through         layer 3 protocols
3073 0       0       1       1       1       1       1       1               
3074                                                                         
3075 0       1       0       0       0       0       0       0               
3076 through         National use
3077 0       1       0       0       1       1       1       0