2 * Routines for ANSI 41 Mobile Application Part (IS41 MAP) dissection
3 * Specications from 3GPP2 (www.3gpp2.org)
5 * Copyright 2003, Michael Lum <mlum [AT] telostech.com>
6 * In association with Telos Technology Inc.
8 * Should be very close to what ANSI/TIA/EIA-41-E will be as most known
9 * changes have been added: i.e. IS-778, IS-751, IS-725, IS-841, ...
13 * Cellular Radiotelecommunications Intersystem Operations
14 * 3GPP2 N.S0005-0 ANSI/TIA/EIA-41-D
16 * Network Support for MDN-Based Message Centers
17 * 3GPP2 N.S0024-0 v1.0 IS-841
19 * Enhanced International Calling
20 * 3GPP2 N.S0027 IS-875
23 * 3GPP2 N.S0030 J-STD-036-A
24 * XXX Teleservice_Priority not implemented, no parameter ID given!
26 * ANSI-41-D Miscellaneous Enhancements Revision 0
27 * 3GPP2 N.S0015 PN-3590 (ANSI-41-E)
29 * TIA/EIA-41-D Internationalization
30 * 3GPP2 N.S0016-0 v1.0
32 * Authentication Enhancements
33 * 3GPP2 N.S0014-0 v1.0 IS-778
35 * PCS Multi-band-Based on IS-41C
36 * 3GPP2 N.S0006-0 v1.0 TIA/EIA TSB-76
38 * Roamer Database Verification Revision B
39 * 3GPP2 N.S0025-B v1.0 IS-947 (aka IS-847 ?)
40 * XXX InvokingNEType not implemented, no parameter ID given!
43 * 3GPP2 N.S0010-0 v1.0 IS-735
45 * TIA/EIA-41-D Based Network Enhancements for CDMA Packet Data Service (C-PDS), Phase 1
46 * 3GPP2 N.S0029-0 v1.0 IS-880
49 * 3GPP2 N.S0011-0 v1.0 IS-725-A
51 * Circuit Mode Services
52 * 3GPP2 N.S0008-0 v1.0 IS-737
53 * XXX SecondInterMSCCircuitID not implemented, parameter ID conflicts with ISLP Information!
56 * 3GPP2 N.S0009-0 v1.0 IS-751
59 * 3GPP2 N.S0013-0 v1.0 IS-771
62 * 3GPP2 N.S0004-0 v1.0 IS-848
64 * TIA/EIA-41-D Pre-Paid Charging
65 * 3GPP2 N.S0018-0 v1.0 IS-826
67 * User Selective Call Forwarding
68 * 3GPP2 N.S0021-0 v1.0 IS-838
71 * 3GPP2 N.S0012-0 v1.0
74 * 3GPP2 N.S0022-0 v1.0 IS-837
76 * Automatic Code Gapping
77 * 3GPP2 N.S0023-0 v1.0
82 * $Id: packet-ansi_map.c,v 1.13 2003/12/12 19:55:26 guy Exp $
84 * Ethereal - Network traffic analyzer
85 * By Gerald Combs <gerald@ethereal.com>
86 * Copyright 1998 Gerald Combs
88 * This program is free software; you can redistribute it and/or
89 * modify it under the terms of the GNU General Public License
90 * as published by the Free Software Foundation; either version 2
91 * of the License, or (at your option) any later version.
93 * This program is distributed in the hope that it will be useful,
94 * but WITHOUT ANY WARRANTY; without even the implied warranty of
95 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
96 * GNU General Public License for more details.
98 * You should have received a copy of the GNU General Public License
99 * along with this program; if not, write to the Free Software
100 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
112 #include "epan/packet.h"
116 #include "packet-ansi_a.h"
117 #include "packet-ansi_map.h"
120 /* PROTOTYPES/FORWARDS */
122 static gboolean dissect_ansi_param(ASN1_SCK *asn1, proto_tree *tree);
124 /* ANSI PARAM STRINGS */
125 static const value_string ansi_param_1_strings[] = {
126 { 0x81, "Billing ID" },
127 { 0x82, "Serving Cell ID" },
128 { 0x83, "Target Cell ID" },
130 { 0x85, "Channel Data" },
131 { 0x86, "Inter MSC Circuit ID" },
132 { 0x87, "Inter Switch Count" },
133 { 0x88, "Mobile Identification Number" },
134 { 0x89, "Electronic Serial Number" },
135 { 0x8A, "Release Reason" },
136 { 0x8B, "Signal Quality" },
137 { 0x8C, "Station Class Mark" },
138 { 0x8D, "Authorization Denied" },
139 { 0x8E, "Authorization Period" },
140 { 0x8F, "Seizure Type" },
141 { 0x90, "Trunk Status" },
142 { 0x91, "Qualification Information Code" },
143 { 0x92, "Feature Result" },
144 { 0x93, "Redirection Reason" },
145 { 0x94, "Access Denied Reason" },
147 { 0x96, "System My Type Code" },
148 { 0x97, "Origination Indicator" },
149 { 0x98, "Termination Restriction Code" },
150 { 0x99, "Calling Features Indicator" },
151 { 0x9A, "Faulty Parameter" },
152 { 0x9B, "Usage Indicator" },
153 { 0x9C, "TDMA Channel Data" },
154 { 0x9D, "TDMA Call Mode" },
155 { 0x9E, "Handoff Reason" },
159 static const value_string ansi_param_2_strings[] = {
160 { 0x9F1F, "TDMA Burst Indicator" },
161 { 0x9F20, "PC_SSN" },
162 { 0x9F21, "Location Area ID" },
163 { 0x9F22, "System Access Type" },
164 { 0x9F23, "Authentication Response" },
165 { 0x9F24, "Authentication Response Base Station" },
166 { 0x9F25, "Authentication Response Unique Challenge" },
167 { 0x9F26, "Call History Count" },
168 { 0x9F27, "Confidentiality Modes" },
169 { 0x9F28, "Random Variable" },
170 { 0x9F29, "Random Variable Base Station" },
171 { 0x9F2A, "Random Variable SSD" },
172 { 0x9F2B, "Random Variable Unique Challenge" },
173 { 0x9F2C, "Report Type" },
174 { 0x9F2D, "Signaling Message Encryption Key" },
175 { 0x9F2E, "Shared Secret Data" },
176 { 0x9F2F, "Terminal Type" },
177 { 0x9F30, "Voice Privacy Mask" },
178 { 0x9F31, "System Capabilities" },
179 { 0x9F32, "Deny Access" },
180 { 0x9F33, "Update Count" },
181 { 0x9F34, "SSD Not Shared" },
182 { 0x9F35, "Extended MSCID" },
183 { 0x9F36, "Extended System My Type Code" },
184 { 0x9F37, "Control Channel Data" },
185 { 0x9F38, "System Access Data" },
186 { 0x9F39, "Cancellation Denied" },
187 { 0x9F3A, "Border Cell Access" },
188 { 0x9F3B, "CDMA Station Class Mark" },
189 { 0x9F3C, "CDMA Serving One Way Delay" },
190 { 0x9F3D, "CDMA Target One Way Delay" },
191 { 0x9F3E, "CDMA Call Mode" },
192 { 0x9F3F, "CDMA Channel Data" },
193 { 0x9F40, "CDMA Signal Quality" },
194 { 0x9F41, "CDMA Pilot Strength" },
195 { 0x9F42, "CDMA Mobile Protocol Revision" },
196 { 0x9F43, "CDMA Private Long Code Mask" },
197 { 0x9F44, "CDMA Code Channel" },
198 { 0x9F45, "CDMA Search Window" },
199 { 0x9F46, "MS Location" },
200 { 0x9F47, "Page Indicator" },
201 { 0x9F48, "Received Signal Quality" },
202 { 0x9F49, "Deregistration Type" },
203 { 0x9F4A, "NAMPS Channel Data" },
204 { 0x9F4B, "Alert Code" },
205 { 0x9F4C, "Announcement Code" },
206 { 0x9F4D, "Authentication Algorithm Version" },
207 { 0x9F4E, "Authentication Capability" },
208 { 0x9F4F, "Call History Count Expected" },
209 { 0x9F50, "Calling Party Number Digits 1" },
210 { 0x9F51, "Calling Party Number Digits 2" },
211 { 0x9F52, "Calling Party Number String 1" },
212 { 0x9F53, "Calling Party Number String 2" },
213 { 0x9F54, "Calling Party Subaddress" },
214 { 0x9F55, "Cancellation Type" },
215 { 0x9F56, "Carrier Digits" },
216 { 0x9F57, "Destination Digits" },
217 { 0x9F58, "DMH Redirection Indicator" },
218 { 0x9F59, "Inter System Termination" },
219 { 0x9F5A, "Availability Type" },
220 { 0x9F5B, "Local Termination" },
221 { 0x9F5C, "Message Waiting Notification Count" },
222 { 0x9F5D, "Mobile Directory Number" },
223 { 0x9F5E, "MSCID Number" },
224 { 0x9F5F, "PSTN Termination" },
225 { 0x9F60, "No Answer Time" },
226 { 0x9F61, "One Time Feature Indicator" },
227 { 0x9F62, "Origination Triggers" },
229 { 0x9F64, "Redirecting Number Digits" },
230 { 0x9F65, "Redirecting Number String" },
231 { 0x9F66, "Redirecting Number Subaddress" },
232 { 0x9F67, "Sender Identification Number" },
233 { 0x9F68, "SMS Address" },
234 { 0x9F69, "SMS Bearer Data" },
235 { 0x9F6A, "SMS Charge Indicator" },
236 { 0x9F6B, "SMS Destination Address" },
237 { 0x9F6C, "SMS Message Count" },
238 { 0x9F6D, "SMS Notification Indicator" },
239 { 0x9F6E, "SMS Original Destination Address" },
240 { 0x9F6F, "SMS Original Destination Subaddress" },
241 { 0x9F70, "SMS Original Originating Address" },
242 { 0x9F71, "SMS Original Originating Subaddress" },
243 { 0x9F72, "SMS Originating Address" },
244 { 0x9F73, "SMS Originating Restrictions" },
245 { 0x9F74, "SMS Teleservice Identifier" },
246 { 0x9F75, "SMS Termination Restrictions" },
247 { 0x9F76, "SMS Message Waiting Indicator" },
248 { 0x9F77, "Termination Access Type" },
249 { 0x9F78, "Termination List" },
250 { 0x9F79, "Termination Treatment" },
251 { 0x9F7A, "Termination Triggers" },
252 { 0x9F7B, "Transaction Capability" },
253 { 0x9F7C, "Unique Challenge Report" },
257 static const value_string ansi_param_3_strings[] = {
258 { 0x9F8100, "Action Code" },
259 { 0x9F8101, "Alert Result" },
260 { 0xBF8102, "Announcement List" },
261 { 0xBF8103, "CDMA Code Channel Information" },
262 { 0xBF8104, "CDMA Code Channel List" },
263 { 0xBF8105, "CDMA Target Measurement Information" },
264 { 0xBF8106, "CDMA Target Measurement List" },
265 { 0xBF8107, "CDMA Target MAHO Information" },
266 { 0xBF8108, "CDMA Target MAHO List" },
267 { 0x9F8109, "Conference Calling Indicator" },
268 { 0x9F810A, "Count Update Report" },
269 { 0x9F810B, "Digit Collection Control" },
270 { 0x9F810C, "DMH Account Code Digits" },
271 { 0x9F810D, "DMH Alternate Billing Digits" },
272 { 0x9F810E, "DMH Billing Digits" },
273 { 0x9F810F, "Geographic Authorization" },
274 { 0x9F8110, "Leg Information" },
275 { 0x9F8111, "Message Waiting Notification Type" },
276 { 0x9F8112, "PACA Indicator" },
277 { 0x9F8113, "Preferred Language Indicator" },
278 { 0x9F8114, "Random Valid Time" },
279 { 0x9F8115, "Restriction Digits" },
280 { 0x9F8116, "Routing Digits" },
281 { 0x9F8117, "Setup Result" },
282 { 0x9F8118, "SMS Access Denied Reason" },
283 { 0x9F8119, "SMS Cause Code" },
284 { 0x9F811A, "SPINI PIN" },
285 { 0x9F811B, "SPINI Triggers" },
286 { 0x9F811C, "SSD Update Report" },
287 { 0x9F811D, "Target Measurement Information" },
288 { 0x9F811E, "Target Measurement List" },
289 { 0x9F811F, "Voice Mailbox PIN" },
290 { 0x9F8120, "Voice Mailbox Number" },
291 { 0x9F8121, "Authentication Data" },
292 { 0x9F8122, "Conditionally Denied Reason" },
293 { 0x9F8123, "Group Information" },
294 { 0x9F8124, "Handoff State" },
295 { 0x9F8125, "NAMPS Call Mode" },
296 { 0x9F8126, "CDMA Slot Cycle Index" },
297 { 0x9F8127, "Denied Authorization Period" },
298 { 0x9F8128, "Pilot Number" },
299 { 0x9F8129, "Pilot Billing ID" },
300 { 0x9F812A, "CDMA Band Class" },
301 { 0x9F8172, "International Mobile Subscriber Identity" },
302 { 0x9F8173, "Calling Party Name" },
303 { 0x9F8174, "Display Text" },
304 { 0x9F8175, "Redirecting Party Name" },
305 { 0x9F8176, "Service ID" },
306 { 0x9F8177, "All Or None" },
307 { 0x9F8178, "Change" },
308 { 0xBF8179, "Data Access Element" },
309 { 0xBF817A, "Data Access Element List" },
310 { 0xBF817E, "Data Update Result" },
311 { 0xBF817F, "Data Update Result List" },
312 { 0x9F812D, "CDMA Pilot PN" },
313 { 0x9F812E, "CDMA Service Configuration Record" },
314 { 0x9F812F, "CDMA Service Option" },
315 { 0x9F8131, "CDMA Station Class Mark 2" },
316 { 0x9F8132, "TDMA Service Code" },
317 { 0x9F8133, "TDMA Terminal Capability" },
318 { 0x9F8134, "TDMA Voice Coder" },
319 { 0x9F8135, "A-Key Protocol Version" },
320 { 0x9F8136, "Authentication Response Reauthentication" },
321 { 0x9F8137, "Base Station Partial Key" },
322 { 0x9F8138, "Mobile Station MIN" },
323 { 0x9F8139, "Mobile Station Partial Key" },
324 { 0x9F813A, "Modulus Value" },
325 { 0x9F813B, "Newly Assigned MIN" },
326 { 0x9F813D, "OTASP Result Code" },
327 { 0x9F813E, "Primitive Value" },
328 { 0x9F813F, "Random Variable Reauthentication" },
329 { 0x9F8140, "Reauthentication Report" },
330 { 0x9F8141, "Service Indicator" },
331 { 0x9F8142, "Signaling Message Encryption Report" },
332 { 0x9F8143, "Temporary Reference Number" },
333 { 0x9F8144, "Voice Privacy Report" },
334 { 0x9F8147, "Control Channel Mode" },
335 { 0x9F8152, "CDMA Connection Reference" },
336 { 0x9F8153, "CDMA Connection Reference Information" },
337 { 0x9F8154, "CDMA Connection Reference List" },
338 { 0x9F8156, "Change Service Attributes" },
339 { 0x9F8157, "Data Key" },
340 { 0x9F8158, "Data Privacy Parameters" },
341 { 0x9F8159, "ISLP Information" }, /* IS-737 *SPEC CONFLICT* */
342 { 0x9F815A, "Reason List" },
343 { 0x9F815C, "TDMA Bandwidth" },
344 { 0x9F815D, "TDMA Data Features Indicator" },
345 { 0x9F815E, "TDMA Data Mode" },
346 { 0x9F815F, "TDMA Voice Mode" },
347 { 0x9F8160, "Analog Redirect Info" },
348 { 0xBF812B, "CDMA Band Class Information" },
349 { 0xBF812C, "CDMA Band Class List" },
350 { 0xBF8130, "CDMA Service Option List" },
351 { 0xBF8153, "CDMA Connection Reference Information" },
352 { 0xBF8154, "CDMA Connection Reference List" },
353 { 0xBF8161, "Analog Redirect Record" },
354 { 0xBF8202, "Execute Script" },
355 { 0xBF8206, "Modification Request" },
356 { 0xBF8207, "Modification Request List" },
357 { 0xBF8208, "Modification Result List" },
358 { 0xBF820E, "Service Data Access Element" },
359 { 0xBF820F, "Service Data Access Element List" },
360 { 0xBF8210, "Service Data Result" },
361 { 0xBF8211, "Service Data Result List" },
362 { 0xBF8214, "Trigger Address List" },
363 { 0xBF8216, "Trigger List" },
364 { 0xBF8218, "WIN Capability" },
365 { 0xBF822F, "Call Recovery ID" },
366 { 0xBF8230, "Call Recovery ID List" },
367 { 0xBF8250, "Position Information" },
368 { 0xBF825A, "CDMA PSMM List" },
369 { 0x9F8162, "CDMA Channel Number" },
370 { 0xBF8163, "CDMA Channel Number List" },
371 { 0x9F8164, "CDMA Power Combined Indicator" },
372 { 0x9F8165, "CDMA Redirect Record" },
373 { 0x9F8166, "CDMA Search Parameters" },
374 { 0x9F8168, "CDMA Network Identification" },
375 { 0x9F8169, "Network TMSI" },
376 { 0x9F816A, "Network TMSI Expiration Time" },
377 { 0x9F816B, "New Network TMSI" },
378 { 0x9F816C, "Required Parameters Mask" },
379 { 0x9F816D, "Service Redirection Cause" },
380 { 0x9F816E, "Service Redirection Info" },
381 { 0x9F816F, "Roaming Indication" },
382 { 0x9F8170, "MSID" },
383 { 0x9F817B, "Data ID" },
384 { 0x9F817C, "Database Key" },
385 { 0x9F817D, "Data Result" },
386 { 0x9F8200, "Data Value" },
387 { 0x9F8203, "Failure Cause" },
388 { 0x9F8204, "Failure Type" },
389 { 0x9F8205, "Global Title" },
390 { 0x9F8209, "Private Specialized Resource" },
391 { 0x9F820A, "Resume PIC" },
392 { 0x9F820B, "Script Argument" },
393 { 0x9F820C, "Script Name" },
394 { 0x9F820D, "Script Result" },
395 { 0x9F8212, "Specialized Resource" },
396 { 0x9F8213, "Time Date Offset" },
397 { 0x9F8215, "Trigger Capability" },
398 { 0x9F8217, "Trigger Type" },
399 { 0x9F8219, "WIN Operations Capability" },
400 { 0x9F821B, "WIN Trigger List" },
401 { 0x9F821C, "MSC Address" },
402 { 0x9F821D, "Suspicious Access" },
403 { 0x9F821E, "Mobile Station IMSI" },
404 { 0x9F821F, "Newly Assigned IMSI" },
405 { 0x9F822A, "Command Code" },
406 { 0x9F822B, "Display Text 2" },
407 { 0x9F822C, "Page Count" },
408 { 0x9F822D, "Page Response Time" },
409 { 0x9F822E, "SMS Transaction ID" },
410 { 0x9F8231, "DMH Service ID" },
411 { 0x9F8232, "Feature Indicator" },
412 { 0x9F8233, "Control Network ID" },
413 { 0x9F8234, "Release Cause" },
414 { 0x9F8235, "Time Of Day" },
415 { 0x9F8236, "Call Status" },
416 { 0x9F8237, "DMH Charge Information" },
417 { 0x9F8238, "DMH Billing Indicator" },
418 { 0x9F8239, "MS Status" },
419 { 0x9F823B, "Position Information Code" },
420 { 0x9F8246, "Inter Message Time" },
421 { 0x9F8247, "MSID Usage" },
422 { 0x9F8248, "New MIN Extension" },
423 { 0x9F8249, "DTX Indication" },
424 { 0x9F824A, "CDMA Mobile Capabilities" },
425 { 0x9F824B, "Generalized Time" },
426 { 0x9F824C, "Generic Digits" },
427 { 0x9F824D, "Geographic Position" },
428 { 0x9F824E, "Mobile Call Status" },
429 { 0x9F824F, "Mobile Position Capability" },
430 { 0x9F8251, "Position Request Type" },
431 { 0x9F8252, "Position Result" },
432 { 0x9F8253, "Position Source" },
433 { 0x9F8254, "ACG Encountered" },
434 { 0x9F8255, "CDMA State/Control Type *" }, /* PN-3590 (ANSI-41-E)/ACG *SPEC CONFLICT* */
435 { 0x9F8256, "Gap Duration" },
436 { 0x9F8257, "SCF Overload Gap Interval" },
437 { 0x9F8258, "Service Management System Gap Interval" },
438 { 0x9F8259, "CDMA PSMM Count" },
439 { 0x9F825B, "CDMA Serving One Way Delay 2" },
440 { 0x9F825C, "QoS Priority" },
441 { 0x9F825D, "PDSN Address" },
442 { 0x9F825E, "PDSN Protocol Type" },
443 { 0x9F825F, "CDMA MS Measured Channel Identity" },
444 { 0x9F8261, "Range" },
445 { 0x9F8263, "Calling Party Category" },
446 { 0x9F8264, "cdma2000 Handoff Invoke IOS Data" },
447 { 0x9F8265, "cdma2000 Handoff Response IOS Data" },
448 { 0x9F8266, "LCS Client ID" },
449 { 0x9F8267, "TDMA MAHO Cell ID" },
450 { 0x9F8268, "TDMA MAHO Channel" },
451 { 0x9F8269, "CDMA Service Option Connection Identifier" },
452 { 0x9F826A, "TDMA Time Alignment" },
453 { 0x9F826C, "TDMA MAHO Request" },
457 /* ANSI TCAP component type */
458 #define ANSI_TC_INVOKE_L 0xe9
459 #define ANSI_TC_RRL 0xea
460 #define ANSI_TC_RE 0xeb
461 #define ANSI_TC_REJECT 0xec
462 #define ANSI_TC_INVOKE_N 0xed
463 #define ANSI_TC_RRN 0xee
465 static const value_string ansi_cmp_type_strings[] = {
466 { ANSI_TC_INVOKE_L, "Invoke(Last)" },
467 { ANSI_TC_RRL, "RetRes(Last)" },
468 { ANSI_TC_RE, "RetErr" },
469 { ANSI_TC_REJECT, "Reject" },
470 { ANSI_TC_INVOKE_N, "Invoke(Not Last)" },
471 { ANSI_TC_RRN, "RetRes(Not Last)" },
475 const value_string ansi_map_opr_code_strings[] = {
476 { 1, "Handoff Measurement Request" },
477 { 2, "Facilities Directive" },
478 { 3, "Mobile On Channel" },
479 { 4, "Handoff Back" },
480 { 5, "Facilities Release" },
481 { 6, "Qualification Request" },
482 { 7, "Qualification Directive" },
485 { 10, "Reset Circuit" },
486 { 11, "Trunk Test" },
487 { 12, "Trunk Test Disconnect" },
488 { 13, "Registration Notification" },
489 { 14, "Registration Cancellation" },
490 { 15, "Location Request" },
491 { 16, "Routing Request" },
492 { 17, "Feature Request" },
493 { 18, "Reserved 18 (Service Profile Request, IS-41-C)" },
494 { 19, "Reserved 19 (Service Profile Directive, IS-41-C)" },
495 { 20, "Unreliable Roamer Data Directive" },
496 { 21, "Reserved 21 (Call Data Request, IS-41-C)" },
497 { 22, "MS Inactive" },
498 { 23, "Transfer To Number Request" },
499 { 24, "Redirection Request" },
500 { 25, "Handoff To Third" },
501 { 26, "Flash Request" },
502 { 27, "Authentication Directive" },
503 { 28, "Authentication Request" },
504 { 29, "Base Station Challenge" },
505 { 30, "Authentication Failure Report" },
506 { 31, "Count Request" },
507 { 32, "Inter System Page" },
508 { 33, "Unsolicited Response" },
509 { 34, "Bulk Deregistration" },
510 { 35, "Handoff Measurement Request 2" },
511 { 36, "Facilities Directive 2" },
512 { 37, "Handoff Back 2" },
513 { 38, "Handoff To Third 2" },
514 { 39, "Authentication Directive Forward" },
515 { 40, "Authentication Status Report" },
516 { 41, "Reserved 41" },
517 { 42, "Information Directive" },
518 { 43, "Information Forward" },
519 { 44, "Inter System Answer" },
520 { 45, "Inter System Page 2" },
521 { 46, "Inter System Setup" },
522 { 47, "Origination Request" },
523 { 48, "Random Variable Request" },
524 { 49, "Redirection Directive" },
525 { 50, "Remote User Interaction Directive" },
526 { 51, "SMS Delivery Backward" },
527 { 52, "SMS Delivery Forward" },
528 { 53, "SMS Delivery Point to Point" },
529 { 54, "SMS Notification" },
530 { 55, "SMS Request" },
531 { 56, "OTASP Request" },
532 { 57, "Information Backward" },
533 { 58, "Change Facilities" },
534 { 59, "Change Service" },
535 { 60, "Parameter Request" },
536 { 61, "TMSI Directive" },
537 { 62, "Reserved 62" },
538 { 63, "Service Request" },
539 { 64, "Analyzed Information Request" },
540 { 65, "Connection Failure Report" },
541 { 66, "Connect Resource" },
542 { 67, "Disconnect Resource" },
543 { 68, "Facility Selected and Available" },
544 { 69, "Instruction Request" },
546 { 71, "Reset Timer" },
548 { 73, "Seize Resource" },
549 { 74, "SRF Directive" },
551 { 76, "T NoAnswer" },
553 { 78, "SMS Delivery Point to Point Ack" },
554 { 79, "Message Directive" },
555 { 80, "Bulk Disconnection" },
556 { 81, "Call Control Directive" },
558 { 83, "O Disconnect" },
559 { 84, "Call Recovery Report" },
561 { 86, "T Disconnect" },
562 { 87, "Unreliable Call Data" },
563 { 88, "O CalledPartyBusy" },
564 { 89, "O NoAnswer" },
565 { 90, "Position Request" },
566 { 91, "Position Request Forward" },
567 { 92, "Call Termination Report" },
568 { 93, "Geo Position Directive" },
569 { 94, "Geo Position Request" },
570 { 95, "Inter System Position Request" },
571 { 96, "Inter System Position Request Forward" },
572 { 97, "ACG Directive" },
573 { 98, "Roamer Database Verification Request" },
574 { 99, "Add Service" },
575 { 100, "Drop Service" },
579 static const value_string ansi_tele_strings[] = {
580 { 1, "Reserved for maintenance" },
581 { 4096, "AMPS Extended Protocol Enhanced Services" },
582 { 4097, "CDMA Cellular Paging Teleservice" },
583 { 4098, "CDMA Cellular Messaging Teleservice" },
584 { 4099, "CDMA Voice Mail Notification" },
585 { 32513, "TDMA Cellular Messaging Teleservice" },
586 { 32520, "TDMA System Assisted Mobile Positioning through Satellite (SAMPS)" },
587 { 32584, "TDMA Segmented System Assisted Mobile Positioning Service" },
591 #define NUM_BAND_CLASS_STR (sizeof(band_class_str)/sizeof(gchar *))
592 static gchar *band_class_str[] = {
593 "800 MHz Cellular System",
594 "1.850 to 1.990 GHz Broadband PCS",
595 "872 to 960 MHz TACS Band",
596 "832 to 925 MHz JTACS Band",
597 "1.750 to 1.870 GHz Korean PCS",
599 "2 GHz IMT-2000 Band",
600 "North American 700 MHz Cellular Band",
601 "1.710 to 1.880 GHz PCS",
602 "880 to 960 MHz Band",
603 "Secondary 800 MHz Band",
604 "400 MHz European PAMR Band",
605 "800 MHz European PAMR Band"
608 #define NUM_QOS_PRI_STR (sizeof(qos_pri_str)/sizeof(gchar *))
609 static gchar *qos_pri_str[] = {
610 "Priority Level 0. This is the lowest level",
624 "Reserved, treat as Priority Level 14",
625 "Reserved, treat as Priority Level 15"
629 * would prefer to have had the define set to the exact number of
630 * elements in the array but that is not without it's own problems
631 * (sizeof(ansi_a_ios401_elem_1_strings)/sizeof(value_string))
633 #define NUM_IOS401_ELEM ANSI_A_MAX_NUM_IOS401_ELEM_1_STRINGS
634 static gint ett_ansi_map_ios401_elem[NUM_IOS401_ELEM];
637 /* Initialize the protocol and registered fields */
638 static int proto_ansi_map = -1;
640 static int ansi_map_tap = -1;
642 static int hf_ansi_map_tag = -1;
643 static int hf_ansi_map_length = -1;
644 static int hf_ansi_map_id = -1;
645 static int hf_ansi_map_opr_code = -1;
646 static int hf_ansi_map_param_id = -1;
647 static int hf_ansi_map_ios401_elem_id = -1;
650 /* Initialize the subtree pointers */
651 static gint ett_ansi_map = -1;
652 static gint ett_opr_code = -1;
653 static gint ett_component = -1;
654 static gint ett_components = -1;
655 static gint ett_params = -1;
656 static gint ett_param = -1;
657 static gint ett_error = -1;
658 static gint ett_problem = -1;
659 static gint ett_natnum = -1;
660 static gint ett_call_mode = -1;
661 static gint ett_chan_data = -1;
662 static gint ett_code_chan = -1;
663 static gint ett_clr_dig_mask = -1;
664 static gint ett_ent_dig_mask = -1;
665 static gint ett_all_dig_mask = -1;
668 static char bigbuf[1024];
669 static gchar ansi_map_add_string[1024];
670 static dissector_handle_t data_handle;
671 static dissector_table_t is637_tele_id_dissector_table; /* IS-637 Teleservice ID */
672 static dissector_table_t is683_dissector_table; /* IS-683-A (OTA) */
673 static packet_info *g_pinfo;
674 static proto_tree *g_tree;
675 static gint32 ansi_map_sms_tele_id = -1;
676 static gboolean is683_ota;
677 static gboolean ansi_map_is_invoke;
680 typedef struct dgt_set_t
682 unsigned char out[15];
686 static dgt_set_t Dgt_tbcd = {
688 /* 0 1 2 3 4 5 6 7 8 9 a b c d e */
689 '0','1','2','3','4','5','6','7','8','9','?','B','C','*','#'
693 static dgt_set_t Dgt_msid = {
695 /* 0 1 2 3 4 5 6 7 8 9 a b c d e */
696 '0','1','2','3','4','5','6','7','8','9','?','?','?','?','?'
703 * Unpack BCD input pattern into output ASCII pattern
705 * Input Pattern is supplied using the same format as the digits
707 * Returns: length of unpacked pattern
711 char *out, /* ASCII pattern out */
712 guchar *in, /* packed pattern in */
713 int num_octs, /* Number of octets to unpack */
714 dgt_set_t *dgt /* Digit definitions */
723 * unpack first value in byte
726 *out++ = dgt->out[i & 0x0f];
730 * unpack second value in byte
734 if (i == 0x0f) /* odd number bytes - hit filler */
737 *out++ = dgt->out[i];
748 my_match_strval(guint32 val, const value_string *vs, gint *idx)
754 if (vs[i].value == val)
757 return(vs[i].strptr);
768 /* PARAM FUNCTIONS */
770 #define EXTRANEOUS_DATA_CHECK(edc_len, edc_max_len) \
771 if ((edc_len) > (edc_max_len)) \
773 proto_tree_add_text(tree, asn1->tvb, \
774 asn1->offset, (edc_len) - (edc_max_len), "Extraneous Data"); \
775 asn1->offset += ((edc_len) - (edc_max_len)); \
778 #define SHORT_DATA_CHECK(sdc_len, sdc_min_len) \
779 if ((sdc_len) < (sdc_min_len)) \
781 proto_tree_add_text(tree, asn1->tvb, \
782 asn1->offset, (sdc_len), "Short Data (?)"); \
783 asn1->offset += (sdc_len); \
787 #define EXACT_DATA_CHECK(edc_len, edc_eq_len) \
788 if ((edc_len) != (edc_eq_len)) \
790 proto_tree_add_text(tree, asn1->tvb, \
791 asn1->offset, (edc_len), "Unexpected Data Length"); \
792 asn1->offset += (edc_len); \
797 param_mscid(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
799 gint32 market_id, switch_num;
802 EXACT_DATA_CHECK(len, 3);
804 add_string = add_string;
805 saved_offset = asn1->offset;
807 asn1_int32_value_decode(asn1, 2, &market_id);
808 asn1_int32_value_decode(asn1, 1, &switch_num);
810 proto_tree_add_text(tree, asn1->tvb,
811 saved_offset, asn1->offset - saved_offset,
812 "Market ID %u Switch Number %u",
813 market_id, switch_num);
817 param_page_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
823 add_string = add_string;
824 saved_offset = asn1->offset;
826 asn1_int32_value_decode(asn1, 1, &value);
830 case 0: str = "Not used"; break;
831 case 1: str = "Page"; break;
832 case 2: str = "Listen only"; break;
834 if ((value >= 3) && (value <= 223)) { str = "Reserved, treat as Page"; }
835 else { str = "Reserved for protocol extension, treat as Page"; }
839 proto_tree_add_text(tree, asn1->tvb,
840 saved_offset, asn1->offset - saved_offset,
843 EXTRANEOUS_DATA_CHECK(len, 1);
847 param_srvc_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
853 EXACT_DATA_CHECK(len, 1);
855 add_string = add_string;
856 saved_offset = asn1->offset;
858 asn1_int32_value_decode(asn1, 1, &value);
862 case 0: str = "Undefined Service"; break;
863 case 1: str = "CDMA OTASP Service"; is683_ota = TRUE; break;
864 case 2: str = "TDMA OTASP Service"; break;
865 case 3: str = "CDMA OTAPA Service"; is683_ota = TRUE; break;
866 case 4: str = "CDMA Position Determination Service"; break;
867 case 5: str = "AMPS Position Determination Service"; break;
869 if ((value >= 6) && (value <= 223)) { str = "Reserved, treat as Undefined Service"; }
870 else { str = "Reserved for protocol extension, treat as Undefined Service"; }
874 proto_tree_add_text(tree, asn1->tvb,
875 saved_offset, asn1->offset - saved_offset,
882 param_sme_report(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
888 EXACT_DATA_CHECK(len, 1);
890 add_string = add_string;
891 saved_offset = asn1->offset;
893 asn1_int32_value_decode(asn1, 1, &value);
897 case 0: str = "Not used"; break;
898 case 1: str = "Signaling Message Encryption enabling not attempted"; break;
899 case 2: str = "Signaling Message Encryption enabling no response"; break;
900 case 3: str = "Signaling Message Encryption is enabled"; break;
901 case 4: str = "Signaling Message Encryption enabling failed"; break;
903 if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Signaling Message Encryption enabling not attempted"; }
904 else { str = "Reserved for protocol extension, treat as Signaling Message Encryption enabling not attempted"; }
908 proto_tree_add_text(tree, asn1->tvb,
909 saved_offset, asn1->offset - saved_offset,
916 param_alert_code(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
922 SHORT_DATA_CHECK(len, 2);
924 add_string = add_string;
925 saved_offset = asn1->offset;
927 asn1_int32_value_decode(asn1, 1, &value);
929 switch ((value & 0xc0) >> 6)
931 case 0: str = "Medium"; break;
932 case 1: str = "High"; break;
933 case 2: str = "Low"; break;
934 case 3: str = "Reserved"; break;
937 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
938 proto_tree_add_text(tree, asn1->tvb,
939 saved_offset, asn1->offset - saved_offset,
944 switch (value & 0x3f)
946 case 0: str = "NoTone"; break;
947 case 1: str = "Long"; break;
948 case 2: str = "ShortShort"; break;
949 case 3: str = "ShortShortLong"; break;
950 case 4: str = "ShortShort2"; break;
951 case 5: str = "ShortLongShort"; break;
952 case 6: str = "ShortShortShortShort"; break;
953 case 7: str = "PBXLong"; break;
954 case 8: str = "PBXShortShort"; break;
955 case 9: str = "PBXShortShortLong"; break;
956 case 10: str = "PBXShortLongShort"; break;
957 case 11: str = "PBXShortShortShortShort"; break;
958 case 12: str = "PipPipPipPip"; break;
960 str = "Reserved, treat as NoTone";
964 other_decode_bitfield_value(bigbuf, value, 0x3f, 8);
965 proto_tree_add_text(tree, asn1->tvb,
966 saved_offset, asn1->offset - saved_offset,
971 add_string = add_string;
972 saved_offset = asn1->offset;
974 asn1_int32_value_decode(asn1, 1, &value);
976 other_decode_bitfield_value(bigbuf, value, 0xf8, 8);
977 proto_tree_add_text(tree, asn1->tvb,
978 saved_offset, asn1->offset - saved_offset,
982 switch (value & 0x07)
984 case 0: str = "Alert without waiting to report"; break;
985 case 1: str = "Apply a reminder alert once"; break;
987 str = "Reserved, treat as Alert without waiting to report";
991 other_decode_bitfield_value(bigbuf, value, 0x07, 8);
992 proto_tree_add_text(tree, asn1->tvb,
993 saved_offset, asn1->offset - saved_offset,
994 "%s : Alert Action, %s",
998 EXTRANEOUS_DATA_CHECK(len, 2);
1002 param_term_acc_type(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1008 add_string = add_string;
1009 saved_offset = asn1->offset;
1011 asn1_int32_value_decode(asn1, 1, &value);
1015 case 0: str = "Not used"; break;
1016 case 252: str = "Mobile-to-Mobile Directory Number access"; break;
1017 case 253: str = "Land-to-Mobile Directory Number access"; break;
1018 case 254: str = "Land-to-Mobile Directory Number access"; break;
1019 case 255: str = "Roamer port access"; break;
1021 if ((value >= 1) && (value <= 127)) { str = "Reserved for controlling system assignment"; }
1022 else if ((value >= 128) && (value <= 160)) { str = "Reserved for protocol extension, treat as Land-to-Mobile Directory Number access"; }
1023 else { str = "Reserved"; }
1027 proto_tree_add_text(tree, asn1->tvb,
1028 saved_offset, asn1->offset - saved_offset,
1031 EXTRANEOUS_DATA_CHECK(len, 1);
1035 param_term_treat(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1041 add_string = add_string;
1042 saved_offset = asn1->offset;
1044 asn1_int32_value_decode(asn1, 1, &value);
1048 case 0: str = "Not used"; break;
1049 case 1: str = "MS Termination"; break;
1050 case 2: str = "Voice Mail Storage"; break;
1051 case 3: str = "Voice Mail Retrieval"; break;
1052 case 4: str = "Dialogue Termination"; break;
1054 if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Unrecognized parameter value"; }
1055 else { str = "Reserved for protocol extension, treat as Unrecognized parameter value"; }
1059 proto_tree_add_text(tree, asn1->tvb,
1060 saved_offset, asn1->offset - saved_offset,
1063 EXTRANEOUS_DATA_CHECK(len, 1);
1067 param_term_trig(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1073 SHORT_DATA_CHECK(len, 2);
1075 add_string = add_string;
1076 saved_offset = asn1->offset;
1078 asn1_int32_value_decode(asn1, 1, &value);
1080 switch ((value & 0xc0) >> 6)
1082 case 0: str = "No Answer Call"; break;
1083 case 1: str = "No Answer Trigger"; break;
1084 case 2: str = "No Answer Leg"; break;
1085 case 3: str = "Reserved"; break;
1088 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
1089 proto_tree_add_text(tree, asn1->tvb,
1090 saved_offset, asn1->offset - saved_offset,
1091 "%s : No Answer (NA), %s",
1095 switch ((value & 0x30) >> 4)
1097 case 0: str = "No Page Response Call"; break;
1098 case 1: str = "No Page Response Trigger"; break;
1099 case 2: str = "No Page Response Leg"; break;
1100 case 3: str = "Reserved"; break;
1103 other_decode_bitfield_value(bigbuf, value, 0x30, 8);
1104 proto_tree_add_text(tree, asn1->tvb,
1105 saved_offset, asn1->offset - saved_offset,
1106 "%s : No Page Response (NPR), %s",
1110 switch ((value & 0x0c) >> 2)
1112 case 0: str = "Failed Call"; break;
1113 case 1: str = "Routing Failure Trigger"; break;
1114 case 2: str = "Failed Leg"; break;
1115 case 3: str = "Reserved"; break;
1118 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
1119 proto_tree_add_text(tree, asn1->tvb,
1120 saved_offset, asn1->offset - saved_offset,
1121 "%s : Routing Failure (RF), %s",
1125 switch (value & 0x03)
1127 case 0: str = "Busy Call"; break;
1128 case 1: str = "Busy Trigger"; break;
1129 case 2: str = "Busy Leg"; break;
1130 case 3: str = "Reserved"; break;
1133 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
1134 proto_tree_add_text(tree, asn1->tvb,
1135 saved_offset, asn1->offset - saved_offset,
1140 add_string = add_string;
1141 saved_offset = asn1->offset;
1143 asn1_int32_value_decode(asn1, 1, &value);
1145 other_decode_bitfield_value(bigbuf, value, 0xfe, 8);
1146 proto_tree_add_text(tree, asn1->tvb,
1147 saved_offset, asn1->offset - saved_offset,
1151 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
1152 proto_tree_add_text(tree, asn1->tvb,
1153 saved_offset, asn1->offset - saved_offset,
1154 "%s : None Reachable (NR), %s",
1156 (value & 0x01) ? "Group Not Reachable" : "Member Not Reachable");
1158 EXTRANEOUS_DATA_CHECK(len, 2);
1162 param_aav(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1167 add_string = add_string;
1168 saved_offset = asn1->offset;
1170 asn1_int32_value_decode(asn1, 1, &value);
1172 proto_tree_add_text(tree, asn1->tvb,
1173 saved_offset, asn1->offset - saved_offset,
1174 "Value as used in the CAVE algorithm (%u)",
1177 EXTRANEOUS_DATA_CHECK(len, 1);
1181 param_ann_code(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1187 SHORT_DATA_CHECK(len, 3);
1189 add_string = add_string;
1190 saved_offset = asn1->offset;
1192 asn1_int32_value_decode(asn1, 1, &value);
1196 case 0: str = "Dialtone"; break;
1197 case 1: str = "Ringback or Audible Alerting"; break;
1198 case 2: str = "Intercept or Mobile Reorder"; break;
1199 case 3: str = "Congestion or Reorder"; break;
1200 case 4: str = "Busy"; break;
1201 case 5: str = "Confirmation"; break;
1202 case 6: str = "Answer"; break;
1203 case 7: str = "Call Waiting"; break;
1204 case 8: str = "Offhook"; break;
1205 case 17: str = "Recall Dial"; break;
1206 case 18: str = "Barge In"; break;
1207 case 20: str = "PPC Insufficient"; break;
1208 case 21: str = "PPC Warning 1"; break;
1209 case 22: str = "PPC Warning 2"; break;
1210 case 23: str = "PPC Warning 3"; break;
1211 case 24: str = "PPC Disconnect"; break;
1212 case 25: str = "PPC Redirect"; break;
1213 case 63: str = "Tones Off"; break;
1214 case 192: str = "Pip"; break;
1215 case 193: str = "Abbreviated Intercept"; break;
1216 case 194: str = "Abbreviated Congestion"; break;
1217 case 195: str = "Warning"; break;
1218 case 196: str = "Denial Tone Burst"; break;
1219 case 197: str = "Dial Tone Burst"; break;
1220 case 250: str = "Incoming Additional Call"; break;
1221 case 251: str = "Priority Additional Call"; break;
1223 str = "Reserved, treat as Tones Off";
1227 other_decode_bitfield_value(bigbuf, value, 0xff, 8);
1228 proto_tree_add_text(tree, asn1->tvb,
1229 saved_offset, asn1->offset - saved_offset,
1235 saved_offset = asn1->offset;
1237 asn1_int32_value_decode(asn1, 1, &value);
1239 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
1240 proto_tree_add_text(tree, asn1->tvb,
1241 saved_offset, asn1->offset - saved_offset,
1245 switch (value & 0x0f)
1247 case 0: str = "Concurrent"; break;
1248 case 1: str = "Sequential"; break;
1250 if ((value >= 2) && (value <= 7)) { str = "Reserved, treat as Concurrent"; }
1251 else { str = "Reserved, treat as Sequential"; }
1255 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
1256 proto_tree_add_text(tree, asn1->tvb,
1257 saved_offset, asn1->offset - saved_offset,
1262 saved_offset = asn1->offset;
1264 asn1_int32_value_decode(asn1, 1, &value);
1268 case 0: str = "None"; break;
1269 case 1: str = "Unauthorized User"; break;
1270 case 2: str = "Invalid ESN"; break;
1271 case 3: str = "Unauthorized Mobile"; break;
1272 case 4: str = "Suspended Origination"; break;
1273 case 5: str = "Origination Denied"; break;
1274 case 6: str = "Service Area Denial"; break;
1275 case 16: str = "Partial Dial"; break;
1276 case 17: str = "Require 1 Plus"; break;
1277 case 18: str = "Require 1 Plus NPA"; break;
1278 case 19: str = "Require 0 Plus"; break;
1279 case 20: str = "Require 0 Plus NPA"; break;
1280 case 21: str = "Deny 1 Plus"; break;
1281 case 22: str = "Unsupported 10 plus"; break;
1282 case 23: str = "Deny 10 plus"; break;
1283 case 24: str = "Unsupported 10 XXX"; break;
1284 case 25: str = "Deny 10 XXX"; break;
1285 case 26: str = "Deny 10 XXX Locally"; break;
1286 case 27: str = "Require 10 Plus"; break;
1287 case 28: str = "Require NPA"; break;
1288 case 29: str = "Deny Toll Origination"; break;
1289 case 30: str = "Deny International Origination"; break;
1290 case 31: str = "Deny 0 Minus"; break;
1291 case 48: str = "Deny Number"; break;
1292 case 49: str = "Alternate Operator Services"; break;
1293 case 64: str = "No Circuit or All Circuits Busy or FacilityProblem"; break;
1294 case 65: str = "Overload"; break;
1295 case 66: str = "Internal Office Failure"; break;
1296 case 67: str = "No Wink Received"; break;
1297 case 68: str = "Interoffice Link Failure"; break;
1298 case 69: str = "Vacant"; break;
1299 case 70: str = "Invalid Prefix or Invalid Access Code"; break;
1300 case 71: str = "Other Dialing Irregularity"; break;
1301 case 80: str = "Vacant Number or Disconnected Number"; break;
1302 case 81: str = "Deny Termination"; break;
1303 case 82: str = "Suspended Termination"; break;
1304 case 83: str = "Changed Number"; break;
1305 case 84: str = "Inaccessible Subscriber"; break;
1306 case 85: str = "Deny Incoming Toll"; break;
1307 case 86: str = "Roamer Access Screening"; break;
1308 case 87: str = "Refuse Call"; break;
1309 case 88: str = "Redirect Call"; break;
1310 case 89: str = "No Page Response"; break;
1311 case 90: str = "No Answer"; break;
1312 case 96: str = "Roamer Intercept"; break;
1313 case 97: str = "General Information"; break;
1314 case 112: str = "Unrecognized Feature Code"; break;
1315 case 113: str = "Unauthorized Feature Code"; break;
1316 case 114: str = "Restricted Feature Code"; break;
1317 case 115: str = "Invalid Modifier Digits"; break;
1318 case 116: str = "Successful Feature Registration"; break;
1319 case 117: str = "Successful Feature Deregistration"; break;
1320 case 118: str = "Successful Feature Activation"; break;
1321 case 119: str = "Successful Feature Deactivation"; break;
1322 case 120: str = "Invalid Forward To Number"; break;
1323 case 121: str = "Courtesy Call Warning"; break;
1324 case 128: str = "Enter PIN Send Prompt"; break;
1325 case 129: str = "Enter PIN Prompt"; break;
1326 case 130: str = "Reenter PIN Send Prompt"; break;
1327 case 131: str = "Reenter PIN Prompt"; break;
1328 case 132: str = "Enter Old PIN Send Prompt"; break;
1329 case 133: str = "Enter Old PIN Prompt"; break;
1330 case 134: str = "Enter New PIN Send Prompt"; break;
1331 case 135: str = "Enter New PIN Prompt"; break;
1332 case 136: str = "Reenter New PIN Send Prompt"; break;
1333 case 137: str = "Reenter New PIN Prompt"; break;
1334 case 138: str = "Enter Password Prompt"; break;
1335 case 139: str = "Enter Directory Number Prompt"; break;
1336 case 140: str = "Reenter Directory Number Prompt"; break;
1337 case 141: str = "Enter Feature Code Prompt"; break;
1338 case 142: str = "Enter Credit Card Number Prompt"; break;
1339 case 143: str = "Enter Destination Number Prompt"; break;
1340 case 152: str = "PPC Insufficient Account Balance"; break;
1341 case 153: str = "PPC Five Minute Warning"; break;
1342 case 154: str = "PPC Three Minute Warning"; break;
1343 case 155: str = "PPC Two Minute Warning"; break;
1344 case 156: str = "PPC One Minute Warning"; break;
1345 case 157: str = "PPC Disconnect"; break;
1346 case 158: str = "PPC Redirect"; break;
1348 str = "Reserved, treat as None";
1352 other_decode_bitfield_value(bigbuf, value, 0xff, 8);
1353 proto_tree_add_text(tree, asn1->tvb,
1354 saved_offset, asn1->offset - saved_offset,
1355 "%s : Standard Announcement, %s",
1359 if (len == 3) return;
1361 saved_offset = asn1->offset;
1363 asn1_int32_value_decode(asn1, 1, &value);
1365 other_decode_bitfield_value(bigbuf, value, 0xff, 8);
1366 proto_tree_add_text(tree, asn1->tvb,
1367 saved_offset, asn1->offset - saved_offset,
1368 "%s : Custom Announcement %u",
1372 EXTRANEOUS_DATA_CHECK(len, 4);
1376 param_alert_res(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1382 add_string = add_string;
1383 saved_offset = asn1->offset;
1385 asn1_int32_value_decode(asn1, 1, &value);
1389 case 0: str = "Not specified"; break;
1390 case 1: str = "Success"; break;
1391 case 2: str = "Failure"; break;
1392 case 3: str = "Denied"; break;
1393 case 4: str = "Not attempted"; break;
1394 case 5: str = "No page response"; break;
1395 case 6: str = "Busy"; break;
1397 str = "Reserved, treat as Not specified";
1401 proto_tree_add_text(tree, asn1->tvb,
1402 saved_offset, asn1->offset - saved_offset,
1405 EXTRANEOUS_DATA_CHECK(len, 1);
1409 param_conf_call_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1415 add_string = add_string;
1416 saved_offset = asn1->offset;
1418 asn1_int32_value_decode(asn1, 1, &value);
1422 case 0: str = ", Not specified"; break;
1423 case 255: str = ", Unlimited number of conferees"; break;
1429 proto_tree_add_text(tree, asn1->tvb,
1430 saved_offset, asn1->offset - saved_offset,
1431 "Maximum Number of Conferees, (%u)%s",
1435 EXTRANEOUS_DATA_CHECK(len, 1);
1439 param_count_upd_report(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1445 add_string = add_string;
1446 saved_offset = asn1->offset;
1448 asn1_int32_value_decode(asn1, 1, &value);
1452 case 0: str = "Not used"; break;
1453 case 1: str = "COUNT Update not attempted"; break;
1454 case 2: str = "COUNT Update no response"; break;
1455 case 3: str = "COUNT Update successful"; break;
1457 if ((value >= 4) && (value <= 223)) { str = "Reserved, treat as COUNT Update not attempted"; }
1458 else { str = "Reserved for protocol extension, treat as COUNT Update not attempted"; }
1462 proto_tree_add_text(tree, asn1->tvb,
1463 saved_offset, asn1->offset - saved_offset,
1466 EXTRANEOUS_DATA_CHECK(len, 1);
1470 param_ssd_upd_report(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1476 add_string = add_string;
1477 saved_offset = asn1->offset;
1479 asn1_int32_value_decode(asn1, 1, &value);
1483 case 0: str = "Not used"; break;
1484 case 1: str = "SSD Update not attempted"; break;
1485 case 2: str = "SSD Update no response"; break;
1486 case 3: str = "SSD Update successful"; break;
1487 case 4: str = "SSD Update failed"; break;
1489 if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as SSD Update not attempted"; }
1490 else { str = "Reserved for protocol extension, treat as SSD Update not attempted"; }
1494 proto_tree_add_text(tree, asn1->tvb,
1495 saved_offset, asn1->offset - saved_offset,
1498 EXTRANEOUS_DATA_CHECK(len, 1);
1502 param_cond_den_reason(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1508 EXACT_DATA_CHECK(len, 1);
1510 add_string = add_string;
1511 saved_offset = asn1->offset;
1513 asn1_int32_value_decode(asn1, 1, &value);
1517 case 0: str = "Not used"; break;
1518 case 1: str = "Waitable (i.e., Call Waiting is possible)"; break;
1520 if ((value >= 2) && (value <= 223)) { str = "Reserved, treat as Waitable"; }
1521 else { str = "Reserved for protocol extension, treat as Waitable"; }
1525 proto_tree_add_text(tree, asn1->tvb,
1526 saved_offset, asn1->offset - saved_offset,
1531 param_den_auth_per(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1537 SHORT_DATA_CHECK(len, 2);
1539 add_string = add_string;
1540 saved_offset = asn1->offset;
1542 asn1_int32_value_decode(asn1, 1, &value);
1546 case 0: str = "Not used"; break;
1547 case 1: str = "Per Call. Re-authorization should be attempted on the next call attempt"; break;
1548 case 2: str = "Hours"; break;
1549 case 3: str = "Days"; break;
1550 case 4: str = "Weeks"; break;
1551 case 5: str = "Per Agreement"; break;
1552 case 6: str = "Reserved"; break;
1553 case 7: str = "Number of calls. Re-authorization should be attempted after this number of (rejected) call attempts"; break;
1554 case 8: str = "Minutes"; break;
1556 if ((value >= 9) && (value <= 223)) { str = "Reserved, treat as Per Call"; }
1557 else { str = "Reserved for protocol extension, treat as Per Call"; }
1561 proto_tree_add_text(tree, asn1->tvb,
1562 saved_offset, asn1->offset - saved_offset,
1566 saved_offset = asn1->offset;
1568 asn1_int32_value_decode(asn1, 1, &value);
1570 proto_tree_add_text(tree, asn1->tvb,
1571 saved_offset, asn1->offset - saved_offset,
1575 EXTRANEOUS_DATA_CHECK(len, 2);
1579 param_ho_state(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1584 add_string = add_string;
1585 saved_offset = asn1->offset;
1587 asn1_int32_value_decode(asn1, 1, &value);
1589 other_decode_bitfield_value(bigbuf, value, 0xfe, 8);
1590 proto_tree_add_text(tree, asn1->tvb,
1591 saved_offset, asn1->offset - saved_offset,
1595 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
1596 proto_tree_add_text(tree, asn1->tvb,
1597 saved_offset, asn1->offset - saved_offset,
1598 "%s : Party Involved (PI), %s",
1600 (value & 0x01) ? "Terminator is handing off" : "Originator is handing off");
1602 EXTRANEOUS_DATA_CHECK(len, 1);
1606 param_geo_auth(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1612 add_string = add_string;
1613 saved_offset = asn1->offset;
1615 asn1_int32_value_decode(asn1, 1, &value);
1619 case 0: str = "Not used"; break;
1620 case 1: str = "Authorized for all Market IDs served by the VLR"; break;
1621 case 2: str = "Authorized for this Market ID only"; break;
1622 case 3: str = "Authorized for this Market ID and Switch Number only"; break;
1623 case 4: str = "Authorized for this Location Area ID within a Market ID only"; break;
1625 if ((value >= 5) && (value <= 95)) { str = "Reserved, treat as Authorized for all Market IDs served by the VLR"; }
1626 else if ((value >= 96) && (value <= 127)) { str = "Reserved for protocol extension, treat as Authorized for all Market IDs served by the VLR"; }
1627 else if ((value >= 128) && (value <= 223)) { str = "Reserved, treat as Authorized for this Location Area ID within a Market ID only"; }
1628 else { str = "Reserved for protocol extension, treat as Authorized for this Location Area ID within a Market ID only"; }
1632 proto_tree_add_text(tree, asn1->tvb,
1633 saved_offset, asn1->offset - saved_offset,
1636 EXTRANEOUS_DATA_CHECK(len, 1);
1640 param_mw_noti_type(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1646 add_string = add_string;
1647 saved_offset = asn1->offset;
1649 asn1_int32_value_decode(asn1, 1, &value);
1651 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
1652 proto_tree_add_text(tree, asn1->tvb,
1653 saved_offset, asn1->offset - saved_offset,
1657 switch ((value & 0x0c) >> 2)
1659 case 0: str = "No MWI. Notification is not authorized or notification is not required"; break;
1660 case 1: str = "Reserved"; break;
1661 case 2: str = "MWI On. Notification is required. Messages waiting"; break;
1662 case 3: str = "MWI Off. Notification is required. No messages waiting"; break;
1665 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
1666 proto_tree_add_text(tree, asn1->tvb,
1667 saved_offset, asn1->offset - saved_offset,
1668 "%s : Message Waiting Indication (MWI), %s",
1672 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
1673 proto_tree_add_text(tree, asn1->tvb,
1674 saved_offset, asn1->offset - saved_offset,
1675 "%s : Alert Pip Tone (APT), %s",
1677 (value & 0x02) ? "notification is required" : "notification is not authorized or notification is not required");
1679 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
1680 proto_tree_add_text(tree, asn1->tvb,
1681 saved_offset, asn1->offset - saved_offset,
1682 "%s : Pip Tone (PT), %s",
1684 (value & 0x01) ? "notification is required" : "notification is not authorized or notification is not required");
1686 EXTRANEOUS_DATA_CHECK(len, 1);
1690 param_paca_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1696 add_string = add_string;
1697 saved_offset = asn1->offset;
1699 asn1_int32_value_decode(asn1, 1, &value);
1701 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
1702 proto_tree_add_text(tree, asn1->tvb,
1703 saved_offset, asn1->offset - saved_offset,
1707 switch ((value & 0x1e) >> 1)
1709 case 0: str = "Not used"; break;
1710 case 1: str = "Priority Level 1"; break;
1711 case 2: str = "Priority Level 2"; break;
1712 case 3: str = "Priority Level 3"; break;
1713 case 4: str = "Priority Level 4"; break;
1714 case 5: str = "Priority Level 5"; break;
1715 case 6: str = "Priority Level 6"; break;
1716 case 7: str = "Priority Level 7"; break;
1717 case 8: str = "Priority Level 8"; break;
1718 case 9: str = "Priority Level 9"; break;
1719 case 10: str = "Priority Level 10"; break;
1720 case 11: str = "Priority Level 11"; break;
1721 case 12: str = "Priority Level 12"; break;
1722 case 13: str = "Priority Level 13"; break;
1723 case 14: str = "Priority Level 14"; break;
1724 case 15: str = "Priority Level 15"; break;
1727 other_decode_bitfield_value(bigbuf, value, 0x1e, 8);
1728 proto_tree_add_text(tree, asn1->tvb,
1729 saved_offset, asn1->offset - saved_offset,
1730 "%s : PACA Level, %s",
1734 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
1735 proto_tree_add_text(tree, asn1->tvb,
1736 saved_offset, asn1->offset - saved_offset,
1737 "%s : PACA is %spermanently activated",
1739 (value & 0x01) ? "" : "not ");
1741 EXTRANEOUS_DATA_CHECK(len, 1);
1745 param_digit_collect_ctrl(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
1750 proto_tree *subtree;
1752 add_string = add_string;
1753 saved_offset = asn1->offset;
1755 asn1_int32_value_decode(asn1, 1, &value);
1757 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
1758 proto_tree_add_text(tree, asn1->tvb,
1759 saved_offset, asn1->offset - saved_offset,
1760 "%s : Break (BRK), %s",
1762 (value & 0x80) ? "Break In (default)" : "No Break");
1764 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
1765 proto_tree_add_text(tree, asn1->tvb,
1766 saved_offset, asn1->offset - saved_offset,
1767 "%s : Type Ahead (TA), %s",
1769 (value & 0x40) ? "Buffer (default)" : "No Type Ahead");
1771 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
1772 proto_tree_add_text(tree, asn1->tvb,
1773 saved_offset, asn1->offset - saved_offset,
1777 other_decode_bitfield_value(bigbuf, value, 0x1f, 8);
1778 proto_tree_add_text(tree, asn1->tvb,
1779 saved_offset, asn1->offset - saved_offset,
1780 "%s : Maximum Collect (%u)",
1784 if (len == 1) return;
1786 saved_offset = asn1->offset;
1788 asn1_int32_value_decode(asn1, 1, &value);
1790 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
1791 proto_tree_add_text(tree, asn1->tvb,
1792 saved_offset, asn1->offset - saved_offset,
1796 other_decode_bitfield_value(bigbuf, value, 0x1f, 8);
1797 proto_tree_add_text(tree, asn1->tvb,
1798 saved_offset, asn1->offset - saved_offset,
1799 "%s : Minimum Collect (%u)",
1803 if (len == 2) return;
1805 saved_offset = asn1->offset;
1807 asn1_int32_value_decode(asn1, 1, &value);
1809 proto_tree_add_text(tree, asn1->tvb,
1810 saved_offset, asn1->offset - saved_offset,
1811 "Maximum Interaction Time (%u) seconds",
1814 if (len == 3) return;
1816 saved_offset = asn1->offset;
1818 asn1_int32_value_decode(asn1, 1, &value);
1820 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
1821 proto_tree_add_text(tree, asn1->tvb,
1822 saved_offset, asn1->offset - saved_offset,
1826 other_decode_bitfield_value(bigbuf, value, 0x1f, 8);
1827 proto_tree_add_text(tree, asn1->tvb,
1828 saved_offset, asn1->offset - saved_offset,
1829 "%s : Initial Interdigit Time (%u) seconds",
1833 if (len == 4) return;
1835 saved_offset = asn1->offset;
1837 asn1_int32_value_decode(asn1, 1, &value);
1839 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
1840 proto_tree_add_text(tree, asn1->tvb,
1841 saved_offset, asn1->offset - saved_offset,
1845 other_decode_bitfield_value(bigbuf, value, 0x1f, 8);
1846 proto_tree_add_text(tree, asn1->tvb,
1847 saved_offset, asn1->offset - saved_offset,
1848 "%s : Normal Interdigit Time (%u) seconds",
1852 if (len == 5) return;
1854 saved_offset = asn1->offset;
1857 proto_tree_add_text(tree, asn1->tvb,
1858 saved_offset, (len > 6) ? 2 : 1,
1859 "Clear Digits Digit Mask");
1861 subtree = proto_item_add_subtree(item, ett_clr_dig_mask);
1863 asn1_int32_value_decode(asn1, 1, &value);
1865 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
1866 proto_tree_add_text(subtree, asn1->tvb,
1867 saved_offset, asn1->offset - saved_offset,
1871 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
1872 proto_tree_add_text(subtree, asn1->tvb,
1873 saved_offset, asn1->offset - saved_offset,
1877 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
1878 proto_tree_add_text(subtree, asn1->tvb,
1879 saved_offset, asn1->offset - saved_offset,
1883 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
1884 proto_tree_add_text(subtree, asn1->tvb,
1885 saved_offset, asn1->offset - saved_offset,
1889 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
1890 proto_tree_add_text(subtree, asn1->tvb,
1891 saved_offset, asn1->offset - saved_offset,
1895 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
1896 proto_tree_add_text(subtree, asn1->tvb,
1897 saved_offset, asn1->offset - saved_offset,
1901 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
1902 proto_tree_add_text(subtree, asn1->tvb,
1903 saved_offset, asn1->offset - saved_offset,
1907 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
1908 proto_tree_add_text(subtree, asn1->tvb,
1909 saved_offset, asn1->offset - saved_offset,
1913 if (len == 6) return;
1915 saved_offset = asn1->offset;
1917 asn1_int32_value_decode(asn1, 1, &value);
1919 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
1920 proto_tree_add_text(subtree, asn1->tvb,
1921 saved_offset, asn1->offset - saved_offset,
1925 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
1926 proto_tree_add_text(subtree, asn1->tvb,
1927 saved_offset, asn1->offset - saved_offset,
1931 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
1932 proto_tree_add_text(subtree, asn1->tvb,
1933 saved_offset, asn1->offset - saved_offset,
1937 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
1938 proto_tree_add_text(subtree, asn1->tvb,
1939 saved_offset, asn1->offset - saved_offset,
1943 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
1944 proto_tree_add_text(subtree, asn1->tvb,
1945 saved_offset, asn1->offset - saved_offset,
1949 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
1950 proto_tree_add_text(subtree, asn1->tvb,
1951 saved_offset, asn1->offset - saved_offset,
1955 if (len == 7) return;
1957 saved_offset = asn1->offset;
1960 proto_tree_add_text(tree, asn1->tvb,
1961 saved_offset, (len > 8) ? 2 : 1,
1962 "Enter Digits Digit Mask");
1964 subtree = proto_item_add_subtree(item, ett_ent_dig_mask);
1966 asn1_int32_value_decode(asn1, 1, &value);
1968 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
1969 proto_tree_add_text(subtree, asn1->tvb,
1970 saved_offset, asn1->offset - saved_offset,
1974 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
1975 proto_tree_add_text(subtree, asn1->tvb,
1976 saved_offset, asn1->offset - saved_offset,
1980 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
1981 proto_tree_add_text(subtree, asn1->tvb,
1982 saved_offset, asn1->offset - saved_offset,
1986 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
1987 proto_tree_add_text(subtree, asn1->tvb,
1988 saved_offset, asn1->offset - saved_offset,
1992 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
1993 proto_tree_add_text(subtree, asn1->tvb,
1994 saved_offset, asn1->offset - saved_offset,
1998 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
1999 proto_tree_add_text(subtree, asn1->tvb,
2000 saved_offset, asn1->offset - saved_offset,
2004 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
2005 proto_tree_add_text(subtree, asn1->tvb,
2006 saved_offset, asn1->offset - saved_offset,
2010 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
2011 proto_tree_add_text(subtree, asn1->tvb,
2012 saved_offset, asn1->offset - saved_offset,
2016 if (len == 8) return;
2018 saved_offset = asn1->offset;
2020 asn1_int32_value_decode(asn1, 1, &value);
2022 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
2023 proto_tree_add_text(subtree, asn1->tvb,
2024 saved_offset, asn1->offset - saved_offset,
2028 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
2029 proto_tree_add_text(subtree, asn1->tvb,
2030 saved_offset, asn1->offset - saved_offset,
2034 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
2035 proto_tree_add_text(subtree, asn1->tvb,
2036 saved_offset, asn1->offset - saved_offset,
2040 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
2041 proto_tree_add_text(subtree, asn1->tvb,
2042 saved_offset, asn1->offset - saved_offset,
2046 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
2047 proto_tree_add_text(subtree, asn1->tvb,
2048 saved_offset, asn1->offset - saved_offset,
2052 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
2053 proto_tree_add_text(subtree, asn1->tvb,
2054 saved_offset, asn1->offset - saved_offset,
2058 if (len == 9) return;
2060 saved_offset = asn1->offset;
2063 proto_tree_add_text(tree, asn1->tvb,
2064 saved_offset, (len > 10) ? 2 : 1,
2065 "Allowed Digits Digit Mask");
2067 subtree = proto_item_add_subtree(item, ett_all_dig_mask);
2069 asn1_int32_value_decode(asn1, 1, &value);
2071 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
2072 proto_tree_add_text(subtree, asn1->tvb,
2073 saved_offset, asn1->offset - saved_offset,
2077 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
2078 proto_tree_add_text(subtree, asn1->tvb,
2079 saved_offset, asn1->offset - saved_offset,
2083 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
2084 proto_tree_add_text(subtree, asn1->tvb,
2085 saved_offset, asn1->offset - saved_offset,
2089 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
2090 proto_tree_add_text(subtree, asn1->tvb,
2091 saved_offset, asn1->offset - saved_offset,
2095 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
2096 proto_tree_add_text(subtree, asn1->tvb,
2097 saved_offset, asn1->offset - saved_offset,
2101 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
2102 proto_tree_add_text(subtree, asn1->tvb,
2103 saved_offset, asn1->offset - saved_offset,
2107 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
2108 proto_tree_add_text(subtree, asn1->tvb,
2109 saved_offset, asn1->offset - saved_offset,
2113 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
2114 proto_tree_add_text(subtree, asn1->tvb,
2115 saved_offset, asn1->offset - saved_offset,
2119 if (len == 10) return;
2121 saved_offset = asn1->offset;
2123 asn1_int32_value_decode(asn1, 1, &value);
2125 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
2126 proto_tree_add_text(subtree, asn1->tvb,
2127 saved_offset, asn1->offset - saved_offset,
2131 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
2132 proto_tree_add_text(subtree, asn1->tvb,
2133 saved_offset, asn1->offset - saved_offset,
2137 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
2138 proto_tree_add_text(subtree, asn1->tvb,
2139 saved_offset, asn1->offset - saved_offset,
2143 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
2144 proto_tree_add_text(subtree, asn1->tvb,
2145 saved_offset, asn1->offset - saved_offset,
2149 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
2150 proto_tree_add_text(subtree, asn1->tvb,
2151 saved_offset, asn1->offset - saved_offset,
2155 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
2156 proto_tree_add_text(subtree, asn1->tvb,
2157 saved_offset, asn1->offset - saved_offset,
2161 if (len == 11) return;
2163 saved_offset = asn1->offset;
2165 asn1_int32_value_decode(asn1, 1, &value);
2167 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
2168 proto_tree_add_text(tree, asn1->tvb,
2169 saved_offset, asn1->offset - saved_offset,
2173 other_decode_bitfield_value(bigbuf, value, 0x1f, 8);
2174 proto_tree_add_text(tree, asn1->tvb,
2175 saved_offset, asn1->offset - saved_offset,
2176 "%s : Special Interdigit Time (%u)",
2180 if (len == 12) return;
2182 saved_offset = asn1->offset;
2184 asn1_int32_value_decode(asn1, 1, &value);
2186 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
2187 proto_tree_add_text(tree, asn1->tvb,
2188 saved_offset, asn1->offset - saved_offset,
2192 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
2193 proto_tree_add_text(tree, asn1->tvb,
2194 saved_offset, asn1->offset - saved_offset,
2198 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
2199 proto_tree_add_text(tree, asn1->tvb,
2200 saved_offset, asn1->offset - saved_offset,
2204 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
2205 proto_tree_add_text(tree, asn1->tvb,
2206 saved_offset, asn1->offset - saved_offset,
2210 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
2211 proto_tree_add_text(tree, asn1->tvb,
2212 saved_offset, asn1->offset - saved_offset,
2216 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
2217 proto_tree_add_text(tree, asn1->tvb,
2218 saved_offset, asn1->offset - saved_offset,
2222 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
2223 proto_tree_add_text(tree, asn1->tvb,
2224 saved_offset, asn1->offset - saved_offset,
2228 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
2229 proto_tree_add_text(tree, asn1->tvb,
2230 saved_offset, asn1->offset - saved_offset,
2234 if (len == 13) return;
2236 saved_offset = asn1->offset;
2238 asn1_int32_value_decode(asn1, 1, &value);
2240 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
2241 proto_tree_add_text(tree, asn1->tvb,
2242 saved_offset, asn1->offset - saved_offset,
2246 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
2247 proto_tree_add_text(tree, asn1->tvb,
2248 saved_offset, asn1->offset - saved_offset,
2252 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
2253 proto_tree_add_text(tree, asn1->tvb,
2254 saved_offset, asn1->offset - saved_offset,
2258 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
2259 proto_tree_add_text(tree, asn1->tvb,
2260 saved_offset, asn1->offset - saved_offset,
2264 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
2265 proto_tree_add_text(tree, asn1->tvb,
2266 saved_offset, asn1->offset - saved_offset,
2270 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
2271 proto_tree_add_text(tree, asn1->tvb,
2272 saved_offset, asn1->offset - saved_offset,
2276 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
2277 proto_tree_add_text(tree, asn1->tvb,
2278 saved_offset, asn1->offset - saved_offset,
2282 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
2283 proto_tree_add_text(tree, asn1->tvb,
2284 saved_offset, asn1->offset - saved_offset,
2288 if (len == 14) return;
2290 saved_offset = asn1->offset;
2292 asn1_int32_value_decode(asn1, 1, &value);
2294 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
2295 proto_tree_add_text(tree, asn1->tvb,
2296 saved_offset, asn1->offset - saved_offset,
2300 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
2301 proto_tree_add_text(tree, asn1->tvb,
2302 saved_offset, asn1->offset - saved_offset,
2306 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
2307 proto_tree_add_text(tree, asn1->tvb,
2308 saved_offset, asn1->offset - saved_offset,
2312 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
2313 proto_tree_add_text(tree, asn1->tvb,
2314 saved_offset, asn1->offset - saved_offset,
2318 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
2319 proto_tree_add_text(tree, asn1->tvb,
2320 saved_offset, asn1->offset - saved_offset,
2324 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
2325 proto_tree_add_text(tree, asn1->tvb,
2326 saved_offset, asn1->offset - saved_offset,
2330 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
2331 proto_tree_add_text(tree, asn1->tvb,
2332 saved_offset, asn1->offset - saved_offset,
2336 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
2337 proto_tree_add_text(tree, asn1->tvb,
2338 saved_offset, asn1->offset - saved_offset,
2342 if (len == 15) return;
2344 saved_offset = asn1->offset;
2346 asn1_int32_value_decode(asn1, 1, &value);
2348 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
2349 proto_tree_add_text(tree, asn1->tvb,
2350 saved_offset, asn1->offset - saved_offset,
2354 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
2355 proto_tree_add_text(tree, asn1->tvb,
2356 saved_offset, asn1->offset - saved_offset,
2360 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
2361 proto_tree_add_text(tree, asn1->tvb,
2362 saved_offset, asn1->offset - saved_offset,
2366 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
2367 proto_tree_add_text(tree, asn1->tvb,
2368 saved_offset, asn1->offset - saved_offset,
2372 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
2373 proto_tree_add_text(tree, asn1->tvb,
2374 saved_offset, asn1->offset - saved_offset,
2378 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
2379 proto_tree_add_text(tree, asn1->tvb,
2380 saved_offset, asn1->offset - saved_offset,
2384 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
2385 proto_tree_add_text(tree, asn1->tvb,
2386 saved_offset, asn1->offset - saved_offset,
2390 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
2391 proto_tree_add_text(tree, asn1->tvb,
2392 saved_offset, asn1->offset - saved_offset,
2396 EXTRANEOUS_DATA_CHECK(len, 16);
2400 param_no_ans_time(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
2405 add_string = add_string;
2406 saved_offset = asn1->offset;
2408 asn1_int32_value_decode(asn1, 1, &value);
2410 proto_tree_add_text(tree, asn1->tvb,
2411 saved_offset, asn1->offset - saved_offset,
2412 "(%u) The number of seconds to wait after alerting an MS or after seizing an outgoing trunk before applying no answer trigger treatment.",
2415 EXTRANEOUS_DATA_CHECK(len, 1);
2419 param_mw_noti_count(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
2422 guint saved_offset, orig_offset;
2425 SHORT_DATA_CHECK(len, 2);
2427 add_string = add_string;
2428 orig_offset = asn1->offset;
2429 saved_offset = asn1->offset;
2433 asn1_int32_value_decode(asn1, 1, &value);
2437 case 0: str = "Voice Messages"; break;
2438 case 1: str = "Short Message Services (SMS) messages"; break;
2439 case 2: str = "Group 3 (G3) Fax messages"; break;
2440 case 255: str = "Not specified"; break;
2442 str = "Reserved, treat as Not specified";
2446 proto_tree_add_text(tree, asn1->tvb,
2447 saved_offset, asn1->offset - saved_offset,
2448 "Type of messages, %s",
2451 saved_offset = asn1->offset;
2453 asn1_int32_value_decode(asn1, 1, &value);
2457 case 0: str = "No messages are waiting"; break;
2458 case 254: str = "254 or more messages are waiting"; break;
2459 case 255: str = "An unknown number of messages are waiting (greater than zero)"; break;
2461 sprintf(bigbuf, "%u messages are waiting", value);
2466 proto_tree_add_text(tree, asn1->tvb,
2467 saved_offset, asn1->offset - saved_offset,
2470 saved_offset = asn1->offset;
2472 while ((len - (saved_offset - orig_offset)) >= 2);
2474 EXTRANEOUS_DATA_CHECK((len - (saved_offset - orig_offset)), 0);
2478 param_otfi(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
2484 add_string = add_string;
2485 saved_offset = asn1->offset;
2487 asn1_int32_value_decode(asn1, 1, &value);
2489 switch ((value & 0xc0) >> 6)
2491 case 0: str = "Ignore"; break;
2492 case 1: str = "Presentation Allowed"; break;
2493 case 2: str = "Presentation Restricted"; break;
2494 case 3: str = "Reserved"; break;
2497 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
2498 proto_tree_add_text(tree, asn1->tvb,
2499 saved_offset, asn1->offset - saved_offset,
2500 "%s : Calling Number ID Restriction, %s",
2504 switch ((value & 0x30) >> 4)
2506 case 0: str = "Ignore"; break;
2507 case 1: str = "Pip Tone Inactive"; break;
2508 case 2: str = "Pip Tone Active"; break;
2509 case 3: str = "Reserved"; break;
2512 other_decode_bitfield_value(bigbuf, value, 0x30, 8);
2513 proto_tree_add_text(tree, asn1->tvb,
2514 saved_offset, asn1->offset - saved_offset,
2515 "%s : Message Waiting Notification, %s",
2519 switch ((value & 0x0c) >> 2)
2521 case 0: str = "Ignore"; break;
2522 case 1: str = "No CW"; break;
2523 case 2: str = "Normal CW"; break;
2524 case 3: str = "Priority CW"; break;
2527 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
2528 proto_tree_add_text(tree, asn1->tvb,
2529 saved_offset, asn1->offset - saved_offset,
2530 "%s : Call Waiting for Incoming Call (CWIC), %s",
2534 switch (value & 0x03)
2536 case 0: str = "Ignore"; break;
2537 case 1: str = "No CW"; break;
2538 case 2: str = "Normal CW"; break;
2539 case 3: str = "Priority CW"; break;
2542 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
2543 proto_tree_add_text(tree, asn1->tvb,
2544 saved_offset, asn1->offset - saved_offset,
2545 "%s : Call Waiting for Future Incoming Call (CWFI), %s",
2549 if (len == 1) return;
2551 saved_offset = asn1->offset;
2553 asn1_int32_value_decode(asn1, 1, &value);
2555 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
2556 proto_tree_add_text(tree, asn1->tvb,
2557 saved_offset, asn1->offset - saved_offset,
2561 switch ((value & 0x30) >> 4)
2563 case 0: str = "Ignore"; break;
2564 case 1: str = "Presentation Allowed"; break;
2565 case 2: str = "Presentation Restricted"; break;
2566 case 3: str = "Blocking Toggle"; break;
2569 other_decode_bitfield_value(bigbuf, value, 0x30, 8);
2570 proto_tree_add_text(tree, asn1->tvb,
2571 saved_offset, asn1->offset - saved_offset,
2572 "%s : Calling Name Restriction (CNAR), %s",
2576 switch ((value & 0x0c) >> 2)
2578 case 0: str = "Ignore"; break;
2579 case 1: str = "Flash Inactive"; break;
2580 case 2: str = "Flash Active"; break;
2581 case 3: str = "Reserved"; break;
2584 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
2585 proto_tree_add_text(tree, asn1->tvb,
2586 saved_offset, asn1->offset - saved_offset,
2587 "%s : Flash Privileges (Flash), %s",
2591 switch (value & 0x03)
2593 case 0: str = "Ignore"; break;
2594 case 1: str = "PACA Demand Inactive"; break;
2595 case 2: str = "PACA Demand Actived"; break;
2596 case 3: str = "Reserved"; break;
2599 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
2600 proto_tree_add_text(tree, asn1->tvb,
2601 saved_offset, asn1->offset - saved_offset,
2602 "%s : Priority Access and Channel Assignment (PACA), %s",
2606 EXTRANEOUS_DATA_CHECK(len, 2);
2611 * Authentication Response
2612 * Authentication Response Base Station
2613 * Authentication Response Unique Challenge
2616 param_auth_resp_all(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
2621 EXACT_DATA_CHECK(len, 3);
2623 add_string = add_string;
2624 saved_offset = asn1->offset;
2626 asn1_int32_value_decode(asn1, 1, &value);
2628 other_decode_bitfield_value(bigbuf, value, 0xfc, 8);
2629 proto_tree_add_text(tree, asn1->tvb,
2630 saved_offset, asn1->offset - saved_offset,
2634 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
2635 proto_tree_add_text(tree, asn1->tvb,
2636 saved_offset, asn1->offset - saved_offset,
2637 "%s : Response (MSB)",
2640 saved_offset = asn1->offset;
2642 asn1_int32_value_decode(asn1, 1, &value);
2644 other_decode_bitfield_value(bigbuf, value, 0xff, 8);
2645 proto_tree_add_text(tree, asn1->tvb,
2646 saved_offset, asn1->offset - saved_offset,
2650 saved_offset = asn1->offset;
2652 asn1_int32_value_decode(asn1, 1, &value);
2654 other_decode_bitfield_value(bigbuf, value, 0xff, 8);
2655 proto_tree_add_text(tree, asn1->tvb,
2656 saved_offset, asn1->offset - saved_offset,
2657 "%s : Response (LSB)",
2662 param_sys_acc_data(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
2667 EXACT_DATA_CHECK(len, 5);
2669 param_mscid(asn1, tree, 3, add_string);
2671 saved_offset = asn1->offset;
2672 asn1_int32_value_decode(asn1, 2, &value);
2674 proto_tree_add_text(tree, asn1->tvb,
2675 saved_offset, asn1->offset - saved_offset,
2676 "Serving Cell ID %u",
2681 param_bill_id(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
2683 gint32 id, segcount;
2687 EXACT_DATA_CHECK(len, 7);
2689 param_mscid(asn1, tree, 3, add_string);
2691 saved_offset = asn1->offset;
2692 asn1_int32_value_decode(asn1, 3, &id);
2694 proto_tree_add_text(tree, asn1->tvb,
2695 saved_offset, asn1->offset - saved_offset,
2699 saved_offset = asn1->offset;
2700 asn1_int32_value_decode(asn1, 1, &segcount);
2702 if (segcount == 255) { str = "Unspecified"; }
2703 else if ((segcount >= 0) && (segcount <= 127)) { str = "Number of call segments"; }
2704 else if ((segcount >= 128) && (segcount < 255)) { str = "Not used in TIA/EIA-41"; }
2706 proto_tree_add_text(tree, asn1->tvb,
2707 saved_offset, asn1->offset - saved_offset,
2708 "Segment Counter %u: %s",
2713 param_cdma_so(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
2719 SHORT_DATA_CHECK(len, 2);
2721 add_string = add_string;
2722 saved_offset = asn1->offset;
2723 asn1_int32_value_decode(asn1, 2, &so);
2727 case 1: str = "Basic Variable Rate Voice Service (8 kbps)"; break;
2728 case 2: str = "Mobile Station Loopback (8 kbps)"; break;
2729 case 3: str = "Enhanced Variable Rate Voice Service (8 kbps)"; break;
2730 case 4: str = "Asynchronous Data Service (9.6 kbps)"; break;
2731 case 5: str = "Group 3 Facsimile (9.6 kbps)"; break;
2732 case 6: str = "Short Message Services (Rate Set 1)"; break;
2733 case 7: str = "Packet Data Service: Internet or ISO Protocol Stack (9.6 kbps)"; break;
2734 case 8: str = "Packet Data Service: CDPD Protocol Stack (9.6 kbps)"; break;
2735 case 9: str = "Mobile Station Loopback (13 kbps)"; break;
2736 case 10: str = "STU-III Transparent Service"; break;
2737 case 11: str = "STU-III Non-Transparent Service"; break;
2738 case 12: str = "Asynchronous Data Service (14.4 or 9.6 kbps)"; break;
2739 case 13: str = "Group 3 Facsimile (14.4 or 9.6 kbps)"; break;
2740 case 14: str = "Short Message Services (Rate Set 2)"; break;
2741 case 15: str = "Packet Data Service: Internet or ISO Protocol Stack (14.4 kbps)"; break;
2742 case 16: str = "Packet Data Service: CDPD Protocol Stack (14.4 kbps)"; break;
2743 case 17: str = "High Rate Voice Service (13 kbps)"; break;
2744 case 32768: str = "QCELP (13 kbps)"; break;
2745 case 18: str = "Over-the-Air Parameter Administration (Rate Set 1)"; break;
2746 case 19: str = "Over-the-Air Parameter Administration (Rate Set 2)"; break;
2747 case 20: str = "Group 3 Analog Facsimile (Rate Set 1)"; break;
2748 case 21: str = "Group 3 Analog Facsimile (Rate Set 2)"; break;
2749 case 22: str = "High Speed Packet Data Service: Internet or ISO Protocol Stack (RS1 forward, RS1 reverse)"; break;
2750 case 23: str = "High Speed Packet Data Service: Internet or ISO Protocol Stack (RS1 forward, RS2 reverse)"; break;
2751 case 24: str = "High Speed Packet Data Service: Internet or ISO Protocol Stack (RS2 forward, RS1 reverse)"; break;
2752 case 25: str = "High Speed Packet Data Service: Internet or ISO Protocol Stack (RS2 forward, RS2 reverse)"; break;
2753 case 26: str = "High Speed Packet Data Service: CDPD Protocol Stack (RS1 forward, RS1 reverse)"; break;
2754 case 27: str = "High Speed Packet Data Service: CDPD Protocol Stack (RS1 forward, RS2 reverse)"; break;
2755 case 28: str = "High Speed Packet Data Service: CDPD Protocol Stack (RS2 forward, RS1 reverse)"; break;
2756 case 29: str = "High Speed Packet Data Service: CDPD Protocol Stack (RS2 forward, RS2 reverse)"; break;
2757 case 30: str = "Supplemental Channel Loopback Test for Rate Set 1"; break;
2758 case 31: str = "Supplemental Channel Loopback Test for Rate Set 2"; break;
2759 case 32: str = "Test Data Service Option (TDSO)"; break;
2760 case 33: str = "cdma2000 High Speed Packet Data Service, Internet or ISO Protocol Stack"; break;
2761 case 34: str = "cdma2000 High Speed Packet Data Service, CDPD Protocol Stack"; break;
2762 case 35: str = "Location Services, Rate Set 1 (9.6 kbps)"; break;
2763 case 36: str = "Location Services, Rate Set 2 (14.4 kbps)"; break;
2764 case 37: str = "ISDN Interworking Service (64 kbps)"; break;
2765 case 38: str = "GSM Voice"; break;
2766 case 39: str = "GSM Circuit Data"; break;
2767 case 40: str = "GSM Packet Data"; break;
2768 case 41: str = "GSM Short Message Service"; break;
2769 case 42: str = "None Reserved for MC-MAP standard service options"; break;
2770 case 54: str = "Markov Service Option (MSO)"; break;
2771 case 55: str = "Loopback Service Option (LSO)"; break;
2772 case 56: str = "Selectable Mode Vocoder"; break;
2773 case 57: str = "32 kbps Circuit Video Conferencing"; break;
2774 case 58: str = "64 kbps Circuit Video Conferencing"; break;
2775 case 59: str = "HRPD Accounting Records Identifier"; break;
2776 case 60: str = "Link Layer Assisted Robust Header Compression (LLA ROHC) - Header Removal"; break;
2777 case 61: str = "Link Layer Assisted Robust Header Compression (LLA ROHC) - Header Compression"; break;
2778 case 62: str = "- 4099 None Reserved for standard service options"; break;
2779 case 4100: str = "Asynchronous Data Service, Revision 1 (9.6 or 14.4 kbps)"; break;
2780 case 4101: str = "Group 3 Facsimile, Revision 1 (9.6 or 14.4 kbps)"; break;
2781 case 4102: str = "Reserved for standard service option"; break;
2782 case 4103: str = "Packet Data Service: Internet or ISO Protocol Stack, Revision 1 (9.6 or 14.4 kbps)"; break;
2783 case 4104: str = "Packet Data Service: CDPD Protocol Stack, Revision 1 (9.6 or 14.4 kbps)"; break;
2785 if ((so >= 4105) && (so <= 32767)) { str = "Reserved for standard service options"; }
2786 else if ((so >= 32769) && (so <= 32771)) { str = "Proprietary QUALCOMM Incorporated"; }
2787 else if ((so >= 32772) && (so <= 32775)) { str = "Proprietary OKI Telecom"; }
2788 else if ((so >= 32776) && (so <= 32779)) { str = "Proprietary Lucent Technologies"; }
2789 else if ((so >= 32780) && (so <=32783)) { str = "Nokia"; }
2790 else if ((so >= 32784) && (so <=32787)) { str = "NORTEL NETWORKS"; }
2791 else if ((so >= 32788) && (so <=32791)) { str = "Sony Electronics Inc."; }
2792 else if ((so >= 32792) && (so <=32795)) { str = "Motorola"; }
2793 else if ((so >= 32796) && (so <=32799)) { str = "QUALCOMM Incorporated"; }
2794 else if ((so >= 32800) && (so <=32803)) { str = "QUALCOMM Incorporated"; }
2795 else if ((so >= 32804) && (so <=32807)) { str = "QUALCOMM Incorporated"; }
2796 else if ((so >= 32808) && (so <=32811)) { str = "QUALCOMM Incorporated"; }
2797 else if ((so >= 32812) && (so <=32815)) { str = "Lucent Technologies"; }
2798 else if ((so >= 32816) && (so <=32819)) { str = "Denso International"; }
2799 else if ((so >= 32820) && (so <=32823)) { str = "Motorola"; }
2800 else if ((so >= 32824) && (so <=32827)) { str = "Denso International"; }
2801 else if ((so >= 32828) && (so <=32831)) { str = "Denso International"; }
2802 else if ((so >= 32832) && (so <=32835)) { str = "Denso International"; }
2803 else if ((so >= 32836) && (so <=32839)) { str = "NEC America"; }
2804 else if ((so >= 32840) && (so <=32843)) { str = "Samsung Electronics"; }
2805 else if ((so >= 32844) && (so <=32847)) { str = "Texas Instruments Incorporated"; }
2806 else if ((so >= 32848) && (so <=32851)) { str = "Toshiba Corporation"; }
2807 else if ((so >= 32852) && (so <=32855)) { str = "LG Electronics Inc."; }
2808 else if ((so >= 32856) && (so <=32859)) { str = "VIA Telecom Inc."; }
2809 else { str = "Reserved"; }
2813 proto_tree_add_text(tree, asn1->tvb,
2814 saved_offset, asn1->offset - saved_offset,
2818 sprintf(add_string, " - (SO=0x%04x)", so);
2820 EXTRANEOUS_DATA_CHECK(len, 2);
2824 param_tdma_sc(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
2830 add_string = add_string;
2831 saved_offset = asn1->offset;
2833 asn1_int32_value_decode(asn1, 1, &value);
2837 case 0: str = "Analog Speech Only"; break;
2838 case 1: str = "Digital Speech Only"; break;
2839 case 2: str = "Analog or Digital Speech, Analog Preferred"; break;
2840 case 3: str = "Analog or Digital Speech, Digital Preferred"; break;
2841 case 4: str = "Asynchronous Data"; break;
2842 case 5: str = "G3 Fax"; break;
2843 case 6: str = "Not Used (Service Rejected)"; break;
2844 case 7: str = "STU III (Secure Telephone Unit)"; break;
2846 str = "Reserved, treat as Analog Speech Only";
2850 proto_tree_add_text(tree, asn1->tvb,
2851 saved_offset, asn1->offset - saved_offset,
2855 EXTRANEOUS_DATA_CHECK(len, 1);
2859 param_dmh_red_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
2865 EXACT_DATA_CHECK(len, 1);
2867 add_string = add_string;
2868 saved_offset = asn1->offset;
2870 asn1_int32_value_decode(asn1, 1, &redind);
2874 case 0: str = "Not used"; break;
2875 case 1: str = "Call Forwarding Unconditional (CFU)"; break;
2876 case 2: str = "Call Forwarding Busy (CFB)"; break;
2877 case 3: str = "Call Forwarding No Answer (CFNA)"; break;
2878 case 4: str = "Call Forwarding Other (CFO)"; break;
2879 case 5: str = "CD Unspecified"; break;
2880 case 6: str = "CD PSTN"; break;
2881 case 7: str = "CD Private"; break;
2882 case 8: str = "PSTN Tandem"; break;
2883 case 9: str = "Private Tandem"; break;
2884 case 10: str = "Busy"; break;
2885 case 11: str = "Inactive"; break;
2886 case 12: str = "Unassigned"; break;
2887 case 13: str = "Termination Denied"; break;
2888 case 14: str = "CD Failure"; break;
2889 case 15: str = "Explicit Call Transfer (ECT)"; break;
2890 case 16: str = "Mobile Access Hunting (MAH)"; break;
2891 case 17: str = "Flexible Alerting (FA)"; break;
2892 case 18: str = "Abandoned Call Leg"; break;
2893 case 19: str = "Password Call Acceptance (PCA) Call Refused"; break;
2894 case 20: str = "Selective Call Acceptance (SCA) Call Refused"; break;
2895 case 21: str = "Dialogue"; break;
2896 case 22: str = "Call Forwarding Default (CFD)"; break;
2897 case 23: str = "CD Local"; break;
2898 case 24: str = "Voice Mail Retrieval"; break;
2900 if ((redind >= 25) && (redind <= 127))
2902 str = "Reserved/Unknown";
2906 str = "Reserved for bilateral agreements";
2911 proto_tree_add_text(tree, asn1->tvb,
2912 saved_offset, asn1->offset - saved_offset,
2918 param_cic(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
2923 EXACT_DATA_CHECK(len, 2);
2925 add_string = add_string;
2926 saved_offset = asn1->offset;
2928 asn1_int32_value_decode(asn1, 1, &tg);
2929 asn1_int32_value_decode(asn1, 1, &mem);
2931 proto_tree_add_text(tree, asn1->tvb,
2933 "Trunk Group %u Member %u",
2936 sprintf(add_string, "- (%u/%u)", tg, mem);
2940 param_qic(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
2946 EXACT_DATA_CHECK(len, 1);
2948 add_string = add_string;
2949 saved_offset = asn1->offset;
2951 asn1_int32_value_decode(asn1, 1, &qic);
2955 case 0: str = "Not used"; break;
2956 case 1: str = "No information"; break;
2957 case 2: str = "Validation only"; break;
2958 case 3: str = "Validation and profile"; break;
2959 case 4: str = "Profile only"; break;
2961 if ((qic >= 5) && (qic <= 223))
2963 str = "Reserved, treat as Validation and profile";
2967 str = "Reserved for extension, treat as Validation and profile";
2972 proto_tree_add_text(tree, asn1->tvb,
2973 saved_offset, asn1->offset - saved_offset,
2978 param_feat_result(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
2984 EXACT_DATA_CHECK(len, 1);
2986 add_string = add_string;
2987 saved_offset = asn1->offset;
2989 asn1_int32_value_decode(asn1, 1, &value);
2993 case 0: str = "Not used"; break;
2994 case 1: str = "Unsuccessful"; break;
2995 case 2: str = "Successful"; break;
2997 if ((value >= 3) && (value <= 95)) { str = "Reserved, treat as Unsuccessful"; }
2998 else if ((value >= 96) && (value <= 127)) { str = "Reserved, treat as Unsuccessful"; }
2999 else if ((value >= 128) && (value <= 223)) { str = "Reserved, treat as Successful"; }
3000 else { str = "Reserved for protocol extension, treat as Successful"; }
3004 proto_tree_add_text(tree, asn1->tvb,
3005 saved_offset, asn1->offset - saved_offset,
3009 gchar *calling_feat_ind_str[] = {
3012 "Authorized but de-activated",
3013 "Authorized and activated"
3017 param_calling_feat_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3022 SHORT_DATA_CHECK(len, 2);
3024 add_string = add_string;
3025 saved_offset = asn1->offset;
3027 asn1_int32_value_decode(asn1, 1, &value);
3029 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3030 proto_tree_add_text(tree, asn1->tvb,
3031 saved_offset, asn1->offset - saved_offset,
3032 "%s : Call Waiting Feature Activity (CW-FA), %s",
3034 calling_feat_ind_str[(value & 0xc0) >> 6]);
3036 other_decode_bitfield_value(bigbuf, value, 0x30, 8);
3037 proto_tree_add_text(tree, asn1->tvb,
3038 saved_offset, asn1->offset - saved_offset,
3039 "%s : Call Forwarding No Answer Feature Activity (CFNA-FA), %s",
3041 calling_feat_ind_str[(value & 0x30) >> 4]);
3043 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
3044 proto_tree_add_text(tree, asn1->tvb,
3045 saved_offset, asn1->offset - saved_offset,
3046 "%s : Call Forwarding Busy Feature Activity (CFB-FA), %s",
3048 calling_feat_ind_str[(value & 0x0c) >> 2]);
3050 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
3051 proto_tree_add_text(tree, asn1->tvb,
3052 saved_offset, asn1->offset - saved_offset,
3053 "%s : Call Forwarding Unconditional Feature Activity (CFU-FA), %s",
3055 calling_feat_ind_str[value & 0x03]);
3057 saved_offset = asn1->offset;
3059 asn1_int32_value_decode(asn1, 1, &value);
3061 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3062 proto_tree_add_text(tree, asn1->tvb,
3063 saved_offset, asn1->offset - saved_offset,
3064 "%s : Call Transfer Feature Activity (CT-FA), %s",
3066 calling_feat_ind_str[(value & 0xc0) >> 6]);
3068 other_decode_bitfield_value(bigbuf, value, 0x30, 8);
3069 proto_tree_add_text(tree, asn1->tvb,
3070 saved_offset, asn1->offset - saved_offset,
3071 "%s : Voice Privacy Feature Activity (VP-FA), %s",
3073 calling_feat_ind_str[(value & 0x30) >> 4]);
3075 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
3076 proto_tree_add_text(tree, asn1->tvb,
3077 saved_offset, asn1->offset - saved_offset,
3078 "%s : Call Delivery Feature Activity (CD-FA), %s",
3080 calling_feat_ind_str[(value & 0x0c) >> 2]);
3082 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
3083 proto_tree_add_text(tree, asn1->tvb,
3084 saved_offset, asn1->offset - saved_offset,
3085 "%s : Three-Way Calling Feature Activity (3WC-FA), %s",
3087 calling_feat_ind_str[value & 0x03]);
3089 if (len == 2) return;
3091 saved_offset = asn1->offset;
3093 asn1_int32_value_decode(asn1, 1, &value);
3095 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3096 proto_tree_add_text(tree, asn1->tvb,
3097 saved_offset, asn1->offset - saved_offset,
3098 "%s : Calling Number ID Restriction Override Feature Activity (CNIROver-FA), %s",
3100 calling_feat_ind_str[(value & 0xc0) >> 6]);
3102 other_decode_bitfield_value(bigbuf, value, 0x30, 8);
3103 proto_tree_add_text(tree, asn1->tvb,
3104 saved_offset, asn1->offset - saved_offset,
3105 "%s : Calling Number ID Restriction Feature Activity (CNIR-FA), %s",
3107 calling_feat_ind_str[(value & 0x30) >> 4]);
3109 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
3110 proto_tree_add_text(tree, asn1->tvb,
3111 saved_offset, asn1->offset - saved_offset,
3112 "%s : Two number Calling Number ID Presentation Feature Activity (CNIP2-FA), %s",
3114 calling_feat_ind_str[(value & 0x0c) >> 2]);
3116 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
3117 proto_tree_add_text(tree, asn1->tvb,
3118 saved_offset, asn1->offset - saved_offset,
3119 "%s : One number Calling Number ID Presentation Feature Activity (CNIP1-FA), %s",
3121 calling_feat_ind_str[value & 0x03]);
3123 if (len == 3) return;
3125 saved_offset = asn1->offset;
3127 asn1_int32_value_decode(asn1, 1, &value);
3129 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3130 proto_tree_add_text(tree, asn1->tvb,
3131 saved_offset, asn1->offset - saved_offset,
3132 "%s : USCF divert to voice mail Feature Activity (USCFvm-FA), %s",
3134 calling_feat_ind_str[(value & 0xc0) >> 6]);
3136 other_decode_bitfield_value(bigbuf, value, 0x30, 8);
3137 proto_tree_add_text(tree, asn1->tvb,
3138 saved_offset, asn1->offset - saved_offset,
3139 "%s : Answer Hold Feature Activity (AH-FA), %s",
3141 calling_feat_ind_str[(value & 0x30) >> 4]);
3143 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
3144 proto_tree_add_text(tree, asn1->tvb,
3145 saved_offset, asn1->offset - saved_offset,
3146 "%s : Data Privacy Feature Activity (DP-FA), %s",
3148 calling_feat_ind_str[(value & 0x0c) >> 2]);
3150 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
3151 proto_tree_add_text(tree, asn1->tvb,
3152 saved_offset, asn1->offset - saved_offset,
3153 "%s : Priority Call Waiting Feature Activity (PCW-FA), %s",
3155 calling_feat_ind_str[value & 0x03]);
3157 if (len == 4) return;
3159 saved_offset = asn1->offset;
3161 asn1_int32_value_decode(asn1, 1, &value);
3163 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3164 proto_tree_add_text(tree, asn1->tvb,
3165 saved_offset, asn1->offset - saved_offset,
3166 "%s : CDMA-Concurrent Service Feature Activity (CCS-FA), %s",
3168 calling_feat_ind_str[(value & 0xc0) >> 6]);
3170 other_decode_bitfield_value(bigbuf, value, 0x30, 8);
3171 proto_tree_add_text(tree, asn1->tvb,
3172 saved_offset, asn1->offset - saved_offset,
3173 "%s : CDMA-Packet Data Service Feature Activity (CPDS-FA), %s",
3175 calling_feat_ind_str[(value & 0x30) >> 4]);
3177 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
3178 proto_tree_add_text(tree, asn1->tvb,
3179 saved_offset, asn1->offset - saved_offset,
3180 "%s : USCF divert to network registered DN Feature Activity (USCFnr-FA), %s",
3182 calling_feat_ind_str[(value & 0x0c) >> 2]);
3184 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
3185 proto_tree_add_text(tree, asn1->tvb,
3186 saved_offset, asn1->offset - saved_offset,
3187 "%s : USCF divert to mobile station provided DN Feature Activity (USCFms-FA), %s",
3189 calling_feat_ind_str[value & 0x03]);
3191 if (len == 5) return;
3193 saved_offset = asn1->offset;
3195 asn1_int32_value_decode(asn1, 1, &value);
3197 other_decode_bitfield_value(bigbuf, value, 0xfc, 8);
3198 proto_tree_add_text(tree, asn1->tvb,
3199 saved_offset, asn1->offset - saved_offset,
3203 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
3204 proto_tree_add_text(tree, asn1->tvb,
3205 saved_offset, asn1->offset - saved_offset,
3206 "%s : TDMA Enhanced Privacy and Encryption Feature Activity (TDMA EPE-FA), %s",
3208 calling_feat_ind_str[value & 0x03]);
3210 EXTRANEOUS_DATA_CHECK(len, 6);
3214 param_usage_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3220 EXACT_DATA_CHECK(len, 1);
3222 add_string = add_string;
3223 saved_offset = asn1->offset;
3225 asn1_int32_value_decode(asn1, 1, &value);
3229 case 0: str = "Unspecified"; break;
3230 case 1: str = "Sent-paid call"; break;
3231 case 2: str = "3rd number bill"; break;
3233 str = "Reserved, treat as Unspecified";
3237 proto_tree_add_text(tree, asn1->tvb,
3238 saved_offset, asn1->offset - saved_offset,
3244 gchar *tdma_data_feat_ind_str[] = {
3247 "Authorized but de-activated",
3248 "Authorized and activated"
3252 param_tdma_data_feat_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3257 SHORT_DATA_CHECK(len, 2);
3259 add_string = add_string;
3260 saved_offset = asn1->offset;
3262 asn1_int32_value_decode(asn1, 1, &value);
3264 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3265 proto_tree_add_text(tree, asn1->tvb,
3266 saved_offset, asn1->offset - saved_offset,
3270 other_decode_bitfield_value(bigbuf, value, 0x30, 8);
3271 proto_tree_add_text(tree, asn1->tvb,
3272 saved_offset, asn1->offset - saved_offset,
3273 "%s : STU-III Feature Activity (STUIII-FA), %s",
3275 tdma_data_feat_ind_str[(value & 0x30) >> 4]);
3277 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
3278 proto_tree_add_text(tree, asn1->tvb,
3279 saved_offset, asn1->offset - saved_offset,
3280 "%s : G3 Fax Feature Activity (G3FAX-FA), %s",
3282 tdma_data_feat_ind_str[(value & 0x0c) >> 2]);
3284 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
3285 proto_tree_add_text(tree, asn1->tvb,
3286 saved_offset, asn1->offset - saved_offset,
3287 "%s : ADS Feature Activity (ADS-FA), %s",
3289 tdma_data_feat_ind_str[value & 0x03]);
3291 saved_offset = asn1->offset;
3293 asn1_int32_value_decode(asn1, 1, &value);
3295 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3296 proto_tree_add_text(tree, asn1->tvb,
3297 saved_offset, asn1->offset - saved_offset,
3298 "%s : Triple Rate data Feature Activity (3RATE-FA), %s",
3300 tdma_data_feat_ind_str[(value & 0xc0) >> 6]);
3302 other_decode_bitfield_value(bigbuf, value, 0x30, 8);
3303 proto_tree_add_text(tree, asn1->tvb,
3304 saved_offset, asn1->offset - saved_offset,
3305 "%s : Double Rate data Feature Activity (2RATE-FA), %s",
3307 tdma_data_feat_ind_str[(value & 0x30) >> 4]);
3309 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
3310 proto_tree_add_text(tree, asn1->tvb,
3311 saved_offset, asn1->offset - saved_offset,
3312 "%s : Full Rate data Feature Activity (FRATE-FA), %s",
3314 tdma_data_feat_ind_str[(value & 0x0c) >> 2]);
3316 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
3317 proto_tree_add_text(tree, asn1->tvb,
3318 saved_offset, asn1->offset - saved_offset,
3319 "%s : Half Rate data Feature Activity (HRATE-FA), %s",
3321 tdma_data_feat_ind_str[value & 0x03]);
3323 EXTRANEOUS_DATA_CHECK(len, 2);
3327 param_faulty(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3334 add_string = add_string;
3335 saved_offset = asn1->offset;
3336 asn1_int32_value_decode(asn1, 1, &value);
3338 str = my_match_strval((guint32) value, ansi_param_1_strings, &idx);
3344 proto_tree_add_text(tree, asn1->tvb,
3346 "Unrecognized parameter ID");
3350 asn1->offset = saved_offset;
3351 asn1_uint32_value_decode(asn1, 2, &value);
3353 str = my_match_strval((guint32) value, ansi_param_2_strings, &idx);
3359 proto_tree_add_text(tree, asn1->tvb,
3361 "Unrecognized parameter ID");
3365 asn1->offset = saved_offset;
3366 asn1_int32_value_decode(asn1, 3, &value);
3368 str = my_match_strval((guint32) value, ansi_param_3_strings, &idx);
3372 if (((value >= 0x9FFF00) && (value <= 0x9FFF7F)) ||
3373 ((value >= 0xBFFF00) && (value <= 0xBFFF7F)))
3375 str = "Reserved for protocol extension";
3377 else if (((value >= 0x9FFE76) && (value <= 0x9FFE7F)) ||
3378 ((value >= 0xBFFE76) && (value <= 0xBFFE7F)))
3380 str = "Reserved for National Network Use";
3384 str = "Unrecognized parameter ID";
3390 proto_tree_add_text(tree, asn1->tvb,
3391 saved_offset, asn1->offset - saved_offset,
3394 EXTRANEOUS_DATA_CHECK(len, asn1->offset - saved_offset);
3398 param_sys_type_code(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3400 gint32 sys_type_code;
3404 EXACT_DATA_CHECK(len, 1);
3406 add_string = add_string;
3407 saved_offset = asn1->offset;
3409 asn1_int32_value_decode(asn1, 1, &sys_type_code);
3411 switch (sys_type_code)
3413 case 0: str = "Not used"; break;
3414 case 1: str = "EDS"; break;
3415 case 2: str = "Astronet"; break;
3416 case 3: str = "Lucent Technologies"; break;
3417 case 4: str = "Ericsson"; break;
3418 case 5: str = "GTE"; break;
3419 case 6: str = "Motorola"; break;
3420 case 7: str = "NEC"; break;
3421 case 8: str = "NORTEL"; break;
3422 case 9: str = "NovAtel"; break;
3423 case 10: str = "Plexsys"; break;
3424 case 11: str = "Digital Equipment Corp"; break;
3425 case 12: str = "INET"; break;
3426 case 13: str = "Bellcore"; break;
3427 case 14: str = "Alcatel SEL"; break;
3428 case 15: str = "Compaq (Tandem)"; break;
3429 case 16: str = "QUALCOMM"; break;
3430 case 17: str = "Aldiscon"; break;
3431 case 18: str = "Celcore"; break;
3432 case 19: str = "TELOS"; break;
3433 case 20: str = "ADI Limited (Stanilite)"; break;
3434 case 21: str = "Coral Systems"; break;
3435 case 22: str = "Synacom Technology"; break;
3436 case 23: str = "DSC"; break;
3437 case 24: str = "MCI"; break;
3438 case 25: str = "NewNet"; break;
3439 case 26: str = "Sema Group Telecoms"; break;
3440 case 27: str = "LG Information and Communications"; break;
3441 case 28: str = "CBIS"; break;
3442 case 29: str = "Siemens"; break;
3443 case 30: str = "Samsung Electronics"; break;
3444 case 31: str = "ReadyCom Inc."; break;
3445 case 32: str = "AG Communication Systems"; break;
3446 case 33: str = "Hughes Network Systems"; break;
3447 case 34: str = "Phoenix Wireless Group"; break;
3449 str = "Reserved/Unknown";
3453 proto_tree_add_text(tree, asn1->tvb,
3454 saved_offset, asn1->offset - saved_offset,
3455 "Vendor ID (%u) %s",
3456 sys_type_code, str);
3460 param_ext_sys_type_code(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3466 EXACT_DATA_CHECK(len, 2);
3468 add_string = add_string;
3469 saved_offset = asn1->offset;
3471 asn1_int32_value_decode(asn1, 1, &type);
3475 case 0: str = "Not specified"; break;
3476 case 1: str = "Serving MSC"; break;
3477 case 2: str = "Home MSC"; break;
3478 case 3: str = "Gateway MSC"; break;
3479 case 4: str = "HLR"; break;
3480 case 5: str = "VLR"; break;
3481 case 6: str = "EIR (reserved)"; break;
3482 case 7: str = "AC"; break;
3483 case 8: str = "Border MSC"; break;
3484 case 9: str = "Originating MSC"; break;
3486 if ((type >= 10) && (type <= 223)) { str = "Reserved, treat as Not specified"; }
3487 else { str = "Reserved for protocol extension, treat as Not specified"; }
3491 proto_tree_add_text(tree, asn1->tvb,
3492 saved_offset, asn1->offset - saved_offset,
3497 param_sys_type_code(asn1, tree, len-1, add_string);
3501 param_cdma_sea_win(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3506 EXACT_DATA_CHECK(len, 1);
3508 add_string = add_string;
3509 saved_offset = asn1->offset;
3511 asn1_int32_value_decode(asn1, 1, &value);
3513 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
3514 proto_tree_add_text(tree, asn1->tvb,
3515 saved_offset, asn1->offset - saved_offset,
3519 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
3520 proto_tree_add_text(tree, asn1->tvb,
3521 saved_offset, asn1->offset - saved_offset,
3528 param_cdma_sea_param(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3533 SHORT_DATA_CHECK(len, 4);
3535 add_string = add_string;
3536 saved_offset = asn1->offset;
3538 asn1_int32_value_decode(asn1, 1, &value);
3540 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
3541 proto_tree_add_text(tree, asn1->tvb,
3542 saved_offset, asn1->offset - saved_offset,
3546 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
3547 proto_tree_add_text(tree, asn1->tvb,
3548 saved_offset, asn1->offset - saved_offset,
3549 "%s : CDMA Search Window, %u",
3553 saved_offset = asn1->offset;
3555 asn1_int32_value_decode(asn1, 1, &value);
3557 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3558 proto_tree_add_text(tree, asn1->tvb,
3559 saved_offset, asn1->offset - saved_offset,
3563 other_decode_bitfield_value(bigbuf, value, 0x3f, 8);
3564 proto_tree_add_text(tree, asn1->tvb,
3565 saved_offset, asn1->offset - saved_offset,
3570 saved_offset = asn1->offset;
3572 asn1_int32_value_decode(asn1, 1, &value);
3574 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3575 proto_tree_add_text(tree, asn1->tvb,
3576 saved_offset, asn1->offset - saved_offset,
3580 other_decode_bitfield_value(bigbuf, value, 0x3f, 8);
3581 proto_tree_add_text(tree, asn1->tvb,
3582 saved_offset, asn1->offset - saved_offset,
3587 saved_offset = asn1->offset;
3589 asn1_int32_value_decode(asn1, 1, &value);
3591 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
3592 proto_tree_add_text(tree, asn1->tvb,
3593 saved_offset, asn1->offset - saved_offset,
3598 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
3599 proto_tree_add_text(tree, asn1->tvb,
3600 saved_offset, asn1->offset - saved_offset,
3605 EXTRANEOUS_DATA_CHECK(len, 4);
3609 param_cdma_code_chan(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3614 add_string = add_string;
3615 saved_offset = asn1->offset;
3617 asn1_int32_value_decode(asn1, 1, &value);
3619 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3620 proto_tree_add_text(tree, asn1->tvb,
3621 saved_offset, asn1->offset - saved_offset,
3625 other_decode_bitfield_value(bigbuf, value, 0x3f, 8);
3626 proto_tree_add_text(tree, asn1->tvb,
3627 saved_offset, asn1->offset - saved_offset,
3628 "%s : CDMA Code Channel %u",
3632 EXTRANEOUS_DATA_CHECK(len, 1);
3636 param_chan_data(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3642 SHORT_DATA_CHECK(len, 3);
3644 add_string = add_string;
3645 saved_offset = asn1->offset;
3647 asn1_int32_value_decode(asn1, 1, &value);
3649 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3650 proto_tree_add_text(tree, asn1->tvb,
3651 saved_offset, asn1->offset - saved_offset,
3652 "%s : SAT Color Code %u",
3654 (value & 0xc0 >> 6));
3656 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
3657 proto_tree_add_text(tree, asn1->tvb,
3658 saved_offset, asn1->offset - saved_offset,
3660 (value & 0x20) ? "Reserved" : "Analog Band Class",
3663 switch ((value & 0x18) >> 3)
3665 case 0: str = "DTX disabled (not active/acceptable)"; break;
3666 case 1: str = "Reserved, treat as DTX disabled"; break;
3667 case 2: str = "DTX-low mode (i.e., 8 dB below DTX active/acceptable)"; break;
3668 case 3: str = "DTX mode active or acceptable"; break;
3671 other_decode_bitfield_value(bigbuf, value, 0x18, 8);
3672 proto_tree_add_text(tree, asn1->tvb,
3673 saved_offset, asn1->offset - saved_offset,
3678 other_decode_bitfield_value(bigbuf, value, 0x07, 8);
3679 proto_tree_add_text(tree, asn1->tvb,
3680 saved_offset, asn1->offset - saved_offset,
3681 "%s : Voice Mobile Attenuation Code (VMAC) %u",
3685 saved_offset = asn1->offset;
3687 asn1_int32_value_decode(asn1, 2, &value);
3689 proto_tree_add_text(tree, asn1->tvb,
3690 saved_offset, asn1->offset - saved_offset,
3691 "Channel Number %u",
3694 EXTRANEOUS_DATA_CHECK(len, 3);
3698 param_cdma_plcm(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3703 EXACT_DATA_CHECK(len, 6);
3705 add_string = add_string;
3706 saved_offset = asn1->offset;
3708 asn1_int32_value_decode(asn1, 1, &value);
3710 other_decode_bitfield_value(bigbuf, value, 0xfc, 8);
3711 proto_tree_add_text(tree, asn1->tvb,
3712 saved_offset, asn1->offset - saved_offset,
3716 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
3717 proto_tree_add_text(tree, asn1->tvb,
3718 saved_offset, asn1->offset - saved_offset,
3719 "%s : CDMA Private Long Code Mask (PLCM) (MSB)",
3722 saved_offset = asn1->offset;
3724 proto_tree_add_text(tree, asn1->tvb,
3725 saved_offset, len - 1,
3726 "CDMA Private Long Code Mask (PLCM)");
3728 asn1->offset += (len - 1);
3732 param_ctrl_chan_data(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3737 EXACT_DATA_CHECK(len, 4);
3739 add_string = add_string;
3740 saved_offset = asn1->offset;
3742 asn1_int32_value_decode(asn1, 1, &value);
3744 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3745 proto_tree_add_text(tree, asn1->tvb,
3746 saved_offset, asn1->offset - saved_offset,
3747 "%s : Digital Color Code (DCC)",
3750 other_decode_bitfield_value(bigbuf, value, 0x38, 8);
3751 proto_tree_add_text(tree, asn1->tvb,
3752 saved_offset, asn1->offset - saved_offset,
3756 other_decode_bitfield_value(bigbuf, value, 0x07, 8);
3757 proto_tree_add_text(tree, asn1->tvb,
3758 saved_offset, asn1->offset - saved_offset,
3759 "%s : Control Mobile Attenuation Code (CMAC)",
3762 saved_offset = asn1->offset;
3764 asn1_int32_value_decode(asn1, 2, &value);
3766 proto_tree_add_text(tree, asn1->tvb,
3767 saved_offset, asn1->offset - saved_offset,
3768 "Channel Number (CHNO), %u",
3771 saved_offset = asn1->offset;
3773 asn1_int32_value_decode(asn1, 1, &value);
3775 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
3776 proto_tree_add_text(tree, asn1->tvb,
3777 saved_offset, asn1->offset - saved_offset,
3781 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
3782 proto_tree_add_text(tree, asn1->tvb,
3783 saved_offset, asn1->offset - saved_offset,
3784 "%s : Supplementary Digital Color Codes (SDCC1)",
3787 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
3788 proto_tree_add_text(tree, asn1->tvb,
3789 saved_offset, asn1->offset - saved_offset,
3790 "%s : Supplementary Digital Color Codes (SDCC2)",
3795 param_cdma_chan_data(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3797 gint32 value, temp_int;
3801 SHORT_DATA_CHECK(len, 8);
3803 add_string = add_string;
3804 saved_offset = asn1->offset;
3806 asn1_int32_value_decode(asn1, 2, &value);
3808 other_decode_bitfield_value(bigbuf, value >> 8, 0x80, 8);
3809 proto_tree_add_text(tree, asn1->tvb,
3814 other_decode_bitfield_value(bigbuf, value >> 8, 0x78, 8);
3815 proto_tree_add_text(tree, asn1->tvb,
3817 "%s : Frame Offset (%u), %.2f ms",
3819 (value & 0x7800) >> 11,
3820 ((value & 0x7800) >> 11) * 1.25);
3822 other_decode_bitfield_value(bigbuf, value >> 8, 0x07, 8);
3823 proto_tree_add_text(tree, asn1->tvb,
3825 "%s : CDMA Channel Number (MSB), %u",
3829 other_decode_bitfield_value(bigbuf, value & 0x00ff, 0xff, 8);
3830 proto_tree_add_text(tree, asn1->tvb,
3832 "%s : CDMA Channel Number (LSB)",
3835 saved_offset = asn1->offset;
3837 asn1_int32_value_decode(asn1, 1, &value);
3839 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
3840 proto_tree_add_text(tree, asn1->tvb,
3841 saved_offset, asn1->offset - saved_offset,
3845 temp_int = (value & 0x7c) >> 2;
3846 if ((temp_int < 0) || (temp_int >= (gint) NUM_BAND_CLASS_STR))
3852 str = band_class_str[temp_int];
3855 other_decode_bitfield_value(bigbuf, value, 0x7c, 8);
3856 proto_tree_add_text(tree, asn1->tvb,
3857 saved_offset, asn1->offset - saved_offset,
3858 "%s : Band Class, %s",
3862 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
3863 proto_tree_add_text(tree, asn1->tvb,
3864 saved_offset, asn1->offset - saved_offset,
3865 "%s : Long Code Mask (MSB)",
3868 asn1_int32_value_decode(asn1, 1, &value);
3870 other_decode_bitfield_value(bigbuf, value, 0xff, 8);
3871 proto_tree_add_text(tree, asn1->tvb,
3872 saved_offset + 1, 1,
3873 "%s : Long Code Mask",
3876 asn1_int32_value_decode(asn1, 1, &value);
3878 other_decode_bitfield_value(bigbuf, value, 0xff, 8);
3879 proto_tree_add_text(tree, asn1->tvb,
3880 saved_offset + 2, 1,
3881 "%s : Long Code Mask",
3884 asn1_int32_value_decode(asn1, 1, &value);
3886 other_decode_bitfield_value(bigbuf, value, 0xff, 8);
3887 proto_tree_add_text(tree, asn1->tvb,
3888 saved_offset + 3, 1,
3889 "%s : Long Code Mask",
3892 asn1_int32_value_decode(asn1, 1, &value);
3894 other_decode_bitfield_value(bigbuf, value, 0xff, 8);
3895 proto_tree_add_text(tree, asn1->tvb,
3896 saved_offset + 4, 1,
3897 "%s : Long Code Mask",
3900 asn1_int32_value_decode(asn1, 1, &value);
3902 other_decode_bitfield_value(bigbuf, value, 0xff, 8);
3903 proto_tree_add_text(tree, asn1->tvb,
3904 saved_offset + 5, 1,
3905 "%s : Long Code Mask (LSB)",
3908 if (len == 8) return;
3910 saved_offset = asn1->offset;
3912 asn1_int32_value_decode(asn1, 1, &value);
3914 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
3915 proto_tree_add_text(tree, asn1->tvb,
3916 saved_offset, asn1->offset - saved_offset,
3917 "%s : NP Extension",
3920 other_decode_bitfield_value(bigbuf, value, 0x78, 8);
3921 proto_tree_add_text(tree, asn1->tvb,
3922 saved_offset, asn1->offset - saved_offset,
3923 "%s : Nominal Power, %u",
3925 (value & 0x78) >> 3);
3927 other_decode_bitfield_value(bigbuf, value, 0x07, 8);
3928 proto_tree_add_text(tree, asn1->tvb,
3929 saved_offset, asn1->offset - saved_offset,
3930 "%s : Number Preamble, %u",
3934 if (len == 9) return;
3936 saved_offset = asn1->offset;
3938 asn1_int32_value_decode(asn1, 1, &value);
3940 proto_tree_add_text(tree, asn1->tvb,
3941 saved_offset, asn1->offset - saved_offset,
3942 "Base Station Protocol Revision, %u",
3945 EXTRANEOUS_DATA_CHECK(len, 10);
3949 param_namps_chan_data(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
3955 add_string = add_string;
3956 saved_offset = asn1->offset;
3958 asn1_int32_value_decode(asn1, 1, &value);
3960 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
3961 proto_tree_add_text(tree, asn1->tvb,
3962 saved_offset, asn1->offset - saved_offset,
3966 switch ((value & 0x1c) >> 2)
3968 case 0: str = "Channel Data parameter SCC field applies"; break;
3969 case 1: str = "Digital SAT Color Code 1 (ignore SCC field)"; break;
3970 case 2: str = "Digital SAT Color Code 2 (ignore SCC field)"; break;
3971 case 3: str = "Digital SAT Color Code 3 (ignore SCC field)"; break;
3972 case 4: str = "Digital SAT Color Code 4 (ignore SCC field)"; break;
3973 case 5: str = "Digital SAT Color Code 5 (ignore SCC field)"; break;
3974 case 6: str = "Digital SAT Color Code 6 (ignore SCC field)"; break;
3975 case 7: str = "Digital SAT Color Code 7 (ignore SCC field)"; break;
3978 other_decode_bitfield_value(bigbuf, value, 0x1c, 8);
3979 proto_tree_add_text(tree, asn1->tvb,
3980 saved_offset, asn1->offset - saved_offset,
3981 "%s : Color Code Indicator (CCIndicator), %s",
3985 switch (value & 0x03)
3987 case 0: str = "Wide. 30 kHz AMPS voice channel"; break;
3988 case 1: str = "Upper. 10 kHz NAMPS voice channel"; break;
3989 case 2: str = "Middle. 10 kHz NAMPS voice channel"; break;
3990 case 3: str = "Lower. 10 kHz NAMPS voice channel"; break;
3993 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
3994 proto_tree_add_text(tree, asn1->tvb,
3995 saved_offset, asn1->offset - saved_offset,
3996 "%s : Narrow Analog Voice Channel Assignment (NAVCA), %s",
4000 EXTRANEOUS_DATA_CHECK(len, 1);
4004 param_cdma_ms_meas_chan_id(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4006 gint32 value, temp_int;
4010 SHORT_DATA_CHECK(len, 2);
4012 add_string = add_string;
4013 saved_offset = asn1->offset;
4015 asn1_int32_value_decode(asn1, 2, &value);
4017 temp_int = (value & 0xf800) >> 11;
4018 if ((temp_int < 0) || (temp_int >= (gint) NUM_BAND_CLASS_STR))
4024 str = band_class_str[temp_int];
4027 other_decode_bitfield_value(bigbuf, value >> 8, 0xf8, 8);
4028 proto_tree_add_text(tree, asn1->tvb,
4030 "%s : Band Class, %s",
4034 other_decode_bitfield_value(bigbuf, value >> 8, 0x07, 8);
4035 proto_tree_add_text(tree, asn1->tvb,
4037 "%s : CDMA Channel Number (MSB), %u",
4041 other_decode_bitfield_value(bigbuf, value & 0x00ff, 0xff, 8);
4042 proto_tree_add_text(tree, asn1->tvb,
4044 "%s : CDMA Channel Number (LSB)",
4047 EXTRANEOUS_DATA_CHECK(len, 2);
4051 param_tdma_chan_data(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4057 SHORT_DATA_CHECK(len, 5);
4059 add_string = add_string;
4060 saved_offset = asn1->offset;
4062 asn1_int32_value_decode(asn1, 1, &value);
4064 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
4065 proto_tree_add_text(tree, asn1->tvb,
4066 saved_offset, asn1->offset - saved_offset,
4070 switch (value & 0x1f)
4072 case 0: str = "Analog (not used if ChannelData is present)"; break;
4073 case 1: str = "Assigned to timeslot 1, full rate"; break;
4074 case 2: str = "Assigned to timeslot 2, full rate"; break;
4075 case 3: str = "Assigned to timeslot 3, full rate"; break;
4076 case 4: str = "Assigned to timeslots 1, 4 and 2, 5 Double rate"; break;
4077 case 5: str = "Assigned to timeslots 1, 4 and 3, 6 Double rate"; break;
4078 case 6: str = "Assigned to timeslots 2, 5 and 3, 6 Double rate"; break;
4079 case 9: str = "Assigned to timeslot 1, half rate"; break;
4080 case 10: str = "Assigned to timeslot 2, half rate"; break;
4081 case 11: str = "Assigned to timeslot 3, half rate"; break;
4082 case 12: str = "Assigned to timeslot 4, half rate"; break;
4083 case 13: str = "Assigned to timeslot 5, half rate"; break;
4084 case 14: str = "Assigned to timeslot 6, half rate"; break;
4085 case 15: str = "Assigned to timeslot 1, 2, 3, 4, 5, 6 Triple rate"; break;
4087 str = "Reserved, treat as Analog";
4091 other_decode_bitfield_value(bigbuf, value, 0x1f, 8);
4092 proto_tree_add_text(tree, asn1->tvb,
4093 saved_offset, asn1->offset - saved_offset,
4094 "%s : Time Slot and Rate indicator (TSR), %s",
4098 saved_offset = asn1->offset;
4100 asn1_int32_value_decode(asn1, 1, &value);
4102 proto_tree_add_text(tree, asn1->tvb,
4103 saved_offset, asn1->offset - saved_offset,
4104 "Digital Verification Color Code (DVCC) %u",
4107 saved_offset = asn1->offset;
4109 asn1_int32_value_decode(asn1, 1, &value);
4111 switch ((value & 0xf0) >> 4)
4113 case 0: str = "800 MHz"; break;
4114 case 1: str = "1800 MHz"; break;
4116 str = "Reserved, treat as 800 MHz";
4120 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
4121 proto_tree_add_text(tree, asn1->tvb,
4122 saved_offset, asn1->offset - saved_offset,
4123 "%s : Hyper Band, %s",
4127 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
4128 proto_tree_add_text(tree, asn1->tvb,
4129 saved_offset, asn1->offset - saved_offset,
4130 "%s : Digital Mobile Attenuation Code (DMAC) %u",
4134 saved_offset = asn1->offset;
4136 asn1_int32_value_decode(asn1, 2, &value);
4138 other_decode_bitfield_value(bigbuf, value >> 8, 0xff, 8);
4139 proto_tree_add_text(tree, asn1->tvb,
4141 "%s : Channel Number (MSB), %u",
4145 other_decode_bitfield_value(bigbuf, value & 0x00ff, 0xff, 8);
4146 proto_tree_add_text(tree, asn1->tvb,
4147 saved_offset + 1, 1,
4148 "%s : Channel Number (LSB)",
4151 EXTRANEOUS_DATA_CHECK(len, 5);
4155 param_tdma_call_mode(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4160 add_string = add_string;
4161 saved_offset = asn1->offset;
4163 asn1_int32_value_decode(asn1, 1, &value);
4165 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
4166 proto_tree_add_text(tree, asn1->tvb,
4167 saved_offset, asn1->offset - saved_offset,
4171 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
4172 proto_tree_add_text(tree, asn1->tvb,
4173 saved_offset, asn1->offset - saved_offset,
4174 "%s : %sxtended modulation and framing",
4176 (value & 0x20) ? "E" : "No e");
4178 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
4179 proto_tree_add_text(tree, asn1->tvb,
4180 saved_offset, asn1->offset - saved_offset,
4181 "%s : Other voice coding %sacceptable",
4183 (value & 0x10) ? "" : "not ");
4185 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
4186 proto_tree_add_text(tree, asn1->tvb,
4187 saved_offset, asn1->offset - saved_offset,
4188 "%s : Other DQPSK channel %sacceptable",
4190 (value & 0x08) ? "" : "not ");
4192 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
4193 proto_tree_add_text(tree, asn1->tvb,
4194 saved_offset, asn1->offset - saved_offset,
4195 "%s : Half rate digital traffic channel %sacceptable",
4197 (value & 0x04) ? "" : "not ");
4199 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
4200 proto_tree_add_text(tree, asn1->tvb,
4201 saved_offset, asn1->offset - saved_offset,
4202 "%s : Full rate digital traffic channel %sacceptable",
4204 (value & 0x02) ? "" : "not ");
4206 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
4207 proto_tree_add_text(tree, asn1->tvb,
4208 saved_offset, asn1->offset - saved_offset,
4209 "%s : AMPS channel %sacceptable",
4211 (value & 0x01) ? "" : "not ");
4213 EXTRANEOUS_DATA_CHECK(len, 1);
4217 param_cdma_call_mode(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4222 add_string = add_string;
4223 saved_offset = asn1->offset;
4225 asn1_int32_value_decode(asn1, 1, &value);
4229 /* assuming older spec. no IS-880 */
4231 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
4232 proto_tree_add_text(tree, asn1->tvb,
4233 saved_offset, asn1->offset - saved_offset,
4239 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
4240 proto_tree_add_text(tree, asn1->tvb,
4241 saved_offset, asn1->offset - saved_offset,
4242 "%s : 450 MHz channel (Band Class 5) %sacceptable",
4244 (value & 0x80) ? "" : "not ");
4246 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
4247 proto_tree_add_text(tree, asn1->tvb,
4248 saved_offset, asn1->offset - saved_offset,
4249 "%s : Korean PCS channel (Band Class 4) %sacceptable",
4251 (value & 0x40) ? "" : "not ");
4253 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
4254 proto_tree_add_text(tree, asn1->tvb,
4255 saved_offset, asn1->offset - saved_offset,
4256 "%s : JTACS channel (Band Class 3) %sacceptable",
4258 (value & 0x20) ? "" : "not ");
4260 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
4261 proto_tree_add_text(tree, asn1->tvb,
4262 saved_offset, asn1->offset - saved_offset,
4263 "%s : TACS channel (Band Class 2) %sacceptable",
4265 (value & 0x10) ? "" : "not ");
4268 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
4269 proto_tree_add_text(tree, asn1->tvb,
4270 saved_offset, asn1->offset - saved_offset,
4271 "%s : CDMA 1900 MHz channel (Band Class 1) %sacceptable",
4273 (value & 0x08) ? "" : "not ");
4275 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
4276 proto_tree_add_text(tree, asn1->tvb,
4277 saved_offset, asn1->offset - saved_offset,
4278 "%s : NAMPS 800 MHz channel %sacceptable",
4280 (value & 0x04) ? "" : "not ");
4282 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
4283 proto_tree_add_text(tree, asn1->tvb,
4284 saved_offset, asn1->offset - saved_offset,
4285 "%s : AMPS 800 MHz channel %sacceptable",
4287 (value & 0x02) ? "" : "not ");
4289 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
4290 proto_tree_add_text(tree, asn1->tvb,
4291 saved_offset, asn1->offset - saved_offset,
4292 "%s : CDMA 800 MHz channel (Band Class 0) %sacceptable",
4294 (value & 0x01) ? "" : "not ");
4296 if (len == 1) return;
4298 saved_offset = asn1->offset;
4300 asn1_int32_value_decode(asn1, 1, &value);
4302 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
4303 proto_tree_add_text(tree, asn1->tvb,
4304 saved_offset, asn1->offset - saved_offset,
4308 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
4309 proto_tree_add_text(tree, asn1->tvb,
4310 saved_offset, asn1->offset - saved_offset,
4311 "%s : Secondary 800 MHz channel (Band Class 10) %sacceptable",
4313 (value & 0x10) ? "" : "not ");
4315 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
4316 proto_tree_add_text(tree, asn1->tvb,
4317 saved_offset, asn1->offset - saved_offset,
4318 "%s : 900 MHz channel (Band Class 9) %sacceptable",
4320 (value & 0x08) ? "" : "not ");
4322 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
4323 proto_tree_add_text(tree, asn1->tvb,
4324 saved_offset, asn1->offset - saved_offset,
4325 "%s : 1800 MHz channel (Band Class 8) %sacceptable",
4327 (value & 0x04) ? "" : "not ");
4329 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
4330 proto_tree_add_text(tree, asn1->tvb,
4331 saved_offset, asn1->offset - saved_offset,
4332 "%s : 700 MHz channel (Band Class 7) %sacceptable",
4334 (value & 0x02) ? "" : "not ");
4336 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
4337 proto_tree_add_text(tree, asn1->tvb,
4338 saved_offset, asn1->offset - saved_offset,
4339 "%s : 2 GHz channel (Band Class 6) %sacceptable",
4341 (value & 0x01) ? "" : "not ");
4343 EXTRANEOUS_DATA_CHECK(len, 2);
4347 param_namps_call_mode(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4352 add_string = add_string;
4353 saved_offset = asn1->offset;
4355 asn1_int32_value_decode(asn1, 1, &value);
4357 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
4358 proto_tree_add_text(tree, asn1->tvb,
4359 saved_offset, asn1->offset - saved_offset,
4363 proto_tree_add_text(tree, asn1->tvb,
4364 saved_offset, asn1->offset - saved_offset,
4365 ".... %u... : AMPS 1800 MHz channel %sacceptable",
4366 (value & 0x08) >> 3, (value & 0x08) ? "" : "not ");
4368 proto_tree_add_text(tree, asn1->tvb,
4369 saved_offset, asn1->offset - saved_offset,
4370 ".... .%u.. : NAMPS 1800 MHz channel %sacceptable",
4371 (value & 0x04) >> 2, (value & 0x04) ? "" : "not ");
4373 proto_tree_add_text(tree, asn1->tvb,
4374 saved_offset, asn1->offset - saved_offset,
4375 ".... ..%u. : AMPS 800 MHz channel %sacceptable",
4376 (value & 0x02) >> 1, (value & 0x02) ? "" : "not ");
4378 proto_tree_add_text(tree, asn1->tvb,
4379 saved_offset, asn1->offset - saved_offset,
4380 ".... ...%u : NAMPS 800 MHz channel %sacceptable",
4381 value & 0x01, (value & 0x01) ? "" : "not ");
4383 EXTRANEOUS_DATA_CHECK(len, 1);
4387 param_mob_rev(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4392 add_string = add_string;
4393 saved_offset = asn1->offset;
4395 asn1_int32_value_decode(asn1, 1, &value);
4397 proto_tree_add_text(tree, asn1->tvb,
4398 saved_offset, asn1->offset - saved_offset,
4402 EXTRANEOUS_DATA_CHECK(len, 1);
4406 param_cdma_band_class(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4408 gint32 value, temp_int;
4412 add_string = add_string;
4413 saved_offset = asn1->offset;
4415 asn1_int32_value_decode(asn1, 1, &value);
4417 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
4418 proto_tree_add_text(tree, asn1->tvb,
4419 saved_offset, asn1->offset - saved_offset,
4423 temp_int = value & 0x1f;
4424 if ((temp_int < 0) || (temp_int >= (gint) NUM_BAND_CLASS_STR))
4430 str = band_class_str[temp_int];
4433 other_decode_bitfield_value(bigbuf, value, 0x1f, 8);
4434 proto_tree_add_text(tree, asn1->tvb,
4435 saved_offset, asn1->offset - saved_offset,
4436 "%s : Band Class %s",
4440 EXTRANEOUS_DATA_CHECK(len, 1);
4444 param_calling_party_name(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4450 SHORT_DATA_CHECK(len, 1);
4452 add_string = add_string;
4453 saved_offset = asn1->offset;
4455 asn1_int32_value_decode(asn1, 1, &value);
4457 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
4458 proto_tree_add_text(tree, asn1->tvb,
4459 saved_offset, asn1->offset - saved_offset,
4460 "%s : Spec. has hardcoded as 0 0 1",
4463 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
4464 proto_tree_add_text(tree, asn1->tvb,
4465 saved_offset, asn1->offset - saved_offset,
4466 "%s : Availability, %s",
4468 (value & 0x10) ? "Name not available" : "Name available/unknown");
4470 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
4471 proto_tree_add_text(tree, asn1->tvb,
4472 saved_offset, asn1->offset - saved_offset,
4476 switch (value & 0x03)
4478 case 0: str = "Presentation allowed"; break;
4479 case 1: str = "Presentation restricted"; break;
4480 case 2: str = "Blocking toggle"; break;
4481 case 3: str = "No indication"; break;
4484 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
4485 proto_tree_add_text(tree, asn1->tvb,
4486 saved_offset, asn1->offset - saved_offset,
4487 "%s : Presentation Status, %s",
4491 if (len == 1) return;
4493 saved_offset = asn1->offset;
4495 proto_tree_add_text(tree, asn1->tvb,
4496 asn1->offset, len - 1,
4499 asn1->offset += (len - 1);
4503 param_red_party_name(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4509 SHORT_DATA_CHECK(len, 1);
4511 add_string = add_string;
4512 saved_offset = asn1->offset;
4514 asn1_int32_value_decode(asn1, 1, &value);
4516 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
4517 proto_tree_add_text(tree, asn1->tvb,
4518 saved_offset, asn1->offset - saved_offset,
4519 "%s : Spec. has hardcoded as 0 1 1",
4522 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
4523 proto_tree_add_text(tree, asn1->tvb,
4524 saved_offset, asn1->offset - saved_offset,
4525 "%s : Availability, %s",
4527 (value & 0x10) ? "Name not available" : "Name available/unknown");
4529 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
4530 proto_tree_add_text(tree, asn1->tvb,
4531 saved_offset, asn1->offset - saved_offset,
4535 switch (value & 0x03)
4537 case 0: str = "Presentation allowed"; break;
4538 case 1: str = "Presentation restricted"; break;
4539 case 2: str = "Blocking toggle"; break;
4540 case 3: str = "No indication"; break;
4543 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
4544 proto_tree_add_text(tree, asn1->tvb,
4545 saved_offset, asn1->offset - saved_offset,
4546 "%s : Presentation Status, %s",
4550 if (len == 1) return;
4552 saved_offset = asn1->offset;
4554 proto_tree_add_text(tree, asn1->tvb,
4555 asn1->offset, len - 1,
4558 asn1->offset += (len - 1);
4562 param_srvc_id(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4565 add_string = add_string;
4567 proto_tree_add_text(tree, asn1->tvb,
4569 "Service Identifier (Spec. does not define clearly)");
4571 asn1->offset += len;
4575 param_all_or_none(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4581 EXACT_DATA_CHECK(len, 1);
4583 add_string = add_string;
4584 saved_offset = asn1->offset;
4586 asn1_int32_value_decode(asn1, 1, &value);
4590 case 0: str = "Not used"; break;
4591 case 1: str = "All changes must succeed or none should be applied"; break;
4592 case 2: str = "Treat each change independently"; break;
4594 if ((value >= 3) && (value <= 223)) { str = "Reserved, treat as All changes must succeed or none should be applied"; }
4595 else { str = "Reserved for protocol extension, treat as All changes must succeed or none should be applied"; }
4599 proto_tree_add_text(tree, asn1->tvb,
4600 saved_offset, asn1->offset - saved_offset,
4605 param_change(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4611 EXACT_DATA_CHECK(len, 1);
4613 add_string = add_string;
4614 saved_offset = asn1->offset;
4616 asn1_int32_value_decode(asn1, 1, &value);
4620 case 0: str = "Not used"; break;
4621 case 1: str = "Set Data Item to Default Value"; break;
4622 case 2: str = "Add Data Item"; break;
4623 case 3: str = "Delete Data Item"; break;
4624 case 4: str = "Replace Data Item with associated DataValue"; break;
4626 if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Set Data Item to Default Value"; }
4627 else { str = "Reserved for protocol extension, treat as Set Data Item to Default Value"; }
4631 proto_tree_add_text(tree, asn1->tvb,
4632 saved_offset, asn1->offset - saved_offset,
4637 param_data_result(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4643 EXACT_DATA_CHECK(len, 1);
4645 add_string = add_string;
4646 saved_offset = asn1->offset;
4648 asn1_int32_value_decode(asn1, 1, &value);
4652 case 0: str = "Not used"; break;
4653 case 1: str = "Successful"; break;
4654 case 2: str = "Unsuccessful, unspecified"; break;
4655 case 3: str = "Unsuccessful, no default value available"; break;
4657 if ((value >= 4) && (value <= 95)) { str = "Reserved, treat as Unsuccessful"; }
4658 else if ((value >= 96) && (value <= 127)) { str = "Reserved for protocol extension, treat as Unsuccessful"; }
4659 else if ((value >= 128) && (value <= 223)) { str = "Reserved, treat as Successful"; }
4660 else { str = "Reserved for protocol extension, treat as Successful"; }
4664 proto_tree_add_text(tree, asn1->tvb,
4665 saved_offset, asn1->offset - saved_offset,
4670 param_fail_cause(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4674 SHORT_DATA_CHECK(len, 2);
4676 add_string = add_string;
4677 saved_offset = asn1->offset;
4679 proto_tree_add_text(tree, asn1->tvb,
4681 "ISUP Cause Indicator");
4683 asn1->offset += len;
4687 param_fail_type(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4693 EXACT_DATA_CHECK(len, 1);
4695 add_string = add_string;
4696 saved_offset = asn1->offset;
4698 asn1_int32_value_decode(asn1, 1, &value);
4702 case 0: str = "Not used"; break;
4703 case 1: str = "Call abandoned"; break;
4704 case 2: str = "Resource disconnect"; break;
4705 case 3: str = "Failure at MSC"; break;
4706 case 4: str = "SSFT expiration"; break;
4708 if ((value >= 5) && (value <= 223)) { str = "Reserved, ignore"; }
4709 else { str = "Reserved for protocol extension, ignore"; }
4713 proto_tree_add_text(tree, asn1->tvb,
4714 saved_offset, asn1->offset - saved_offset,
4719 param_resume_pic(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4725 EXACT_DATA_CHECK(len, 1);
4727 add_string = add_string;
4728 saved_offset = asn1->offset;
4730 asn1_int32_value_decode(asn1, 1, &value);
4734 case 0: str = "Not used"; break;
4735 case 1: str = "Continue Call Processing"; break;
4736 case 2: str = "Collect Information PIC"; break;
4737 case 3: str = "Analyze Information PIC"; break;
4738 case 4: str = "Select Route PIC"; break;
4739 case 5: str = "Authorize Origination_Attempt PIC"; break;
4740 case 6: str = "Authorize Call Setup PIC"; break;
4741 case 7: str = "Send Call PIC"; break;
4742 case 8: str = "O Alerting PIC"; break;
4743 case 9: str = "O Active PIC"; break;
4744 case 10: str = "O Suspended PIC"; break;
4745 case 11: str = "O Null PIC"; break;
4746 case 32: str = "Select Facility PIC"; break;
4747 case 33: str = "Present Call PIC"; break;
4748 case 34: str = "Authorize Termination Attempt PIC"; break;
4749 case 35: str = "T Alerting PIC"; break;
4750 case 36: str = "T Active PIC"; break;
4751 case 37: str = "T Suspended PIC"; break;
4752 case 38: str = "T Null PIC"; break;
4754 if ((value >= 12) && (value <= 31)) { str = "Reserved, treat as Not used"; }
4755 else if ((value >= 39) && (value <= 223)) { str = "Reserved, ignore"; }
4756 else { str = "Reserved for protocol extension, ignore"; }
4760 proto_tree_add_text(tree, asn1->tvb,
4761 saved_offset, asn1->offset - saved_offset,
4762 "Point in Call, %s (%u)",
4768 param_special_rsc(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4774 add_string = add_string;
4775 saved_offset = asn1->offset;
4781 asn1_int32_value_decode(asn1, 1, &value);
4785 case 0: str = "Not used"; break;
4786 case 1: str = "DTMF tone detector"; break;
4787 case 2: str = "Automatic Speech Recognition - Speaker Independent - Digits"; break;
4788 case 3: str = "Automatic Speech Recognition - Speaker Independent - Speech User Interface Version 1"; break;
4790 if ((value >= 4) && (value <= 223)) { str = "Reserved, treat as Not used"; }
4791 else { str = "Reserved for protocol extension, treat as Not used"; }
4795 proto_tree_add_text(tree, asn1->tvb,
4796 saved_offset, asn1->offset - saved_offset,
4797 "[%u] Resource Type, %s",
4801 saved_offset = asn1->offset;
4803 while ((len - i) > 0);
4807 param_time_date_offset(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4812 EXACT_DATA_CHECK(len, 2);
4814 add_string = add_string;
4815 saved_offset = asn1->offset;
4817 asn1_int32_value_decode(asn1, 2, &value);
4819 proto_tree_add_text(tree, asn1->tvb,
4820 saved_offset, asn1->offset - saved_offset,
4826 param_network_tmsi(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4828 gint32 value, addr_type, first_dig;
4833 SHORT_DATA_CHECK(len, 4);
4835 add_string = add_string;
4836 saved_offset = asn1->offset;
4838 asn1_int32_value_decode(asn1, 4, &value);
4840 proto_tree_add_text(tree, asn1->tvb,
4841 saved_offset, asn1->offset - saved_offset,
4845 if (len == 4) return;
4847 saved_offset = asn1->offset;
4849 asn1_int32_value_decode(asn1, 1, &value);
4851 first_dig = Dgt_tbcd.out[(value & 0xf0) >> 4];
4853 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
4854 proto_tree_add_text(tree, asn1->tvb,
4855 saved_offset, asn1->offset - saved_offset,
4856 "%s : First digit of TMSI Zone, %c",
4860 addr_type = value & 0x0f;
4863 case 0: str = "Not used"; break;
4864 case 1: str = "E.212 based routing"; break;
4865 case 2: str = "20-bit TDMA TMSI"; break;
4866 case 3: str = "24-bit TDMA TMSI"; break;
4868 str = "Reserved for protocol extension, treat as Not used";
4872 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
4873 proto_tree_add_text(tree, asn1->tvb,
4874 saved_offset, asn1->offset - saved_offset,
4875 "%s : Type of addressing, %s",
4879 if (len == 5) return;
4881 saved_offset = asn1->offset;
4883 asn1_string_value_decode(asn1, (len-5), &poctets);
4885 bigbuf[0] = first_dig;
4887 my_dgt_tbcd_unpack(bigbuf+1, poctets, (len-5), &Dgt_tbcd);
4890 proto_tree_add_text(tree, asn1->tvb,
4891 saved_offset - 1, (len-5)+1,
4897 param_reqd_param_mask(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4902 add_string = add_string;
4903 saved_offset = asn1->offset;
4905 asn1_int32_value_decode(asn1, 1, &value);
4907 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
4908 proto_tree_add_text(tree, asn1->tvb,
4909 saved_offset, asn1->offset - saved_offset,
4913 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
4914 proto_tree_add_text(tree, asn1->tvb,
4915 saved_offset, asn1->offset - saved_offset,
4916 "%s : Location Area ID (LOCID) %srequired",
4918 (value & 0x10) ? "" : "not ");
4920 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
4921 proto_tree_add_text(tree, asn1->tvb,
4922 saved_offset, asn1->offset - saved_offset,
4923 "%s : TMSI %srequired",
4925 (value & 0x08) ? "" : "not ");
4927 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
4928 proto_tree_add_text(tree, asn1->tvb,
4929 saved_offset, asn1->offset - saved_offset,
4930 "%s : ESN %srequired",
4932 (value & 0x04) ? "" : "not ");
4934 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
4935 proto_tree_add_text(tree, asn1->tvb,
4936 saved_offset, asn1->offset - saved_offset,
4937 "%s : MIN %srequired",
4939 (value & 0x02) ? "" : "not ");
4941 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
4942 proto_tree_add_text(tree, asn1->tvb,
4943 saved_offset, asn1->offset - saved_offset,
4944 "%s : IMSI %srequired",
4946 (value & 0x01) ? "" : "not ");
4948 EXTRANEOUS_DATA_CHECK(len, 1);
4952 param_srvc_red_cause(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4958 add_string = add_string;
4959 saved_offset = asn1->offset;
4961 asn1_int32_value_decode(asn1, 1, &value);
4965 case 0: str = "Not used"; break;
4966 case 1: str = "Normal Registration"; break;
4967 case 2: str = "System Not Found"; break;
4968 case 3: str = "Protocol Mismatch"; break;
4969 case 4: str = "Registration Rejection"; break;
4970 case 5: str = "Wrong SID"; break;
4971 case 6: str = "Wrong NID"; break;
4973 if ((value >= 7) && (value <= 223)) { str = "Reserved, treat as Normal Registration"; }
4974 else { str = "Reserved for protocol extension. If unknown, treat as Normal Registration"; }
4978 proto_tree_add_text(tree, asn1->tvb,
4979 saved_offset, asn1->offset - saved_offset,
4982 EXTRANEOUS_DATA_CHECK(len, 1);
4986 param_srvc_red_info(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
4991 add_string = add_string;
4992 saved_offset = asn1->offset;
4994 asn1_int32_value_decode(asn1, 1, &value);
4996 other_decode_bitfield_value(bigbuf, value, 0xfc, 8);
4997 proto_tree_add_text(tree, asn1->tvb,
4998 saved_offset, asn1->offset - saved_offset,
5002 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
5003 proto_tree_add_text(tree, asn1->tvb,
5004 saved_offset, asn1->offset - saved_offset,
5005 "%s : NDSS Status (NDS), %ssuppressed",
5007 (value & 0x02) ? "" : "not ");
5009 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
5010 proto_tree_add_text(tree, asn1->tvb,
5011 saved_offset, asn1->offset - saved_offset,
5012 "%s : Return If Fail (RIF), If MS fails to access the redirected system, MS shall %sreturn to the serving system",
5014 (value & 0x01) ? "" : "not ");
5016 EXTRANEOUS_DATA_CHECK(len, 1);
5020 param_roaming_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5026 add_string = add_string;
5027 saved_offset = asn1->offset;
5029 asn1_int32_value_decode(asn1, 1, &value);
5033 case 0: str = "Roaming Indicator On"; break;
5034 case 1: str = "Roaming Indicator Off"; break;
5035 case 2: str = "Roaming Indicator Flashing"; break;
5036 case 3: str = "Out of Neighborhood"; break;
5037 case 4: str = "Out of Building"; break;
5038 case 5: str = "Roaming - Preferred System"; break;
5039 case 6: str = "Roaming - Available System"; break;
5040 case 7: str = "Roaming - Alliance Partner"; break;
5041 case 8: str = "Roaming - Premium Partner"; break;
5042 case 9: str = "Roaming - Full Service Functionality"; break;
5043 case 10: str = "Roaming - Partial Service Functionality"; break;
5044 case 11: str = "Roaming Banner On"; break;
5045 case 12: str = "Roaming Banner Off"; break;
5047 if ((value >= 13) && (value <= 63)) { str = "Reserved for Standard Enhanced Roaming Indicator Numbers"; }
5048 else if ((value >= 64) && (value <= 127)) { str = "Reserved for Non-Standard Enhanced Roaming Indicator Numbers"; }
5049 else { str = "Reserved"; }
5053 proto_tree_add_text(tree, asn1->tvb,
5054 saved_offset, asn1->offset - saved_offset,
5057 EXTRANEOUS_DATA_CHECK(len, 1);
5061 param_cdma_pci(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5066 EXACT_DATA_CHECK(len, 1);
5068 add_string = add_string;
5069 saved_offset = asn1->offset;
5071 asn1_int32_value_decode(asn1, 1, &value);
5073 other_decode_bitfield_value(bigbuf, value, 0xfe, 8);
5074 proto_tree_add_text(tree, asn1->tvb,
5075 saved_offset, asn1->offset - saved_offset,
5079 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
5080 proto_tree_add_text(tree, asn1->tvb,
5081 saved_offset, asn1->offset - saved_offset,
5082 "%s : CDMA PWR_COMB_IND",
5087 param_cdma_chan_num(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5092 SHORT_DATA_CHECK(len, 2);
5094 add_string = add_string;
5095 saved_offset = asn1->offset;
5097 asn1_int32_value_decode(asn1, 2, &value);
5099 other_decode_bitfield_value(bigbuf, value >> 8, 0xf8, 8);
5100 proto_tree_add_text(tree, asn1->tvb,
5105 other_decode_bitfield_value(bigbuf, value >> 8, 0x07, 8);
5106 proto_tree_add_text(tree, asn1->tvb,
5108 "%s : CDMA Channel Number (MSB) %u",
5112 other_decode_bitfield_value(bigbuf, value & 0x00ff, 0xff, 8);
5113 proto_tree_add_text(tree, asn1->tvb,
5115 "%s : CDMA Channel Number (LSB)",
5118 EXTRANEOUS_DATA_CHECK(len, 2);
5122 param_cdma_sci(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5127 EXACT_DATA_CHECK(len, 1);
5129 add_string = add_string;
5130 saved_offset = asn1->offset;
5132 asn1_int32_value_decode(asn1, 1, &value);
5134 other_decode_bitfield_value(bigbuf, value, 0xf8, 8);
5135 proto_tree_add_text(tree, asn1->tvb,
5136 saved_offset, asn1->offset - saved_offset,
5140 other_decode_bitfield_value(bigbuf, value, 0x07, 8);
5141 proto_tree_add_text(tree, asn1->tvb,
5142 saved_offset, asn1->offset - saved_offset,
5143 "%s : Slot Cycle Index, %u",
5149 param_vp_report(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5155 EXACT_DATA_CHECK(len, 1);
5157 add_string = add_string;
5158 saved_offset = asn1->offset;
5160 asn1_int32_value_decode(asn1, 1, &value);
5164 case 0: str = "Not used"; break;
5165 case 1: str = "Voice Privacy not attempted"; break;
5166 case 2: str = "Voice Privacy no response"; break;
5167 case 3: str = "Voiec Privacy successful is active"; break;
5168 case 4: str = "Voice Privacy failed"; break;
5170 if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Voice Privacy not attempted"; }
5171 else { str = "Reserved for protocol extension, treat as Voice Privacy not attempted"; }
5175 proto_tree_add_text(tree, asn1->tvb,
5176 saved_offset, asn1->offset - saved_offset,
5183 param_cdma_scm(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5189 add_string = add_string;
5190 saved_offset = asn1->offset;
5192 asn1_int32_value_decode(asn1, 1, &value);
5194 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
5195 proto_tree_add_text(tree, asn1->tvb,
5196 saved_offset, asn1->offset - saved_offset,
5200 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
5201 proto_tree_add_text(tree, asn1->tvb,
5202 saved_offset, asn1->offset - saved_offset,
5203 "%s : Dual-mode Indicator, %s",
5205 (value & 0x40) ? "Dual mode CDMA" : "CDMA only");
5207 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
5208 proto_tree_add_text(tree, asn1->tvb,
5209 saved_offset, asn1->offset - saved_offset,
5210 "%s : Slotted mode Indicator, %s",
5212 (value & 0x20) ? "slotted capable" : "slotted incapable");
5214 other_decode_bitfield_value(bigbuf, value, 0x18, 8);
5215 proto_tree_add_text(tree, asn1->tvb,
5216 saved_offset, asn1->offset - saved_offset,
5220 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
5221 proto_tree_add_text(tree, asn1->tvb,
5222 saved_offset, asn1->offset - saved_offset,
5223 "%s : Analog Transmission, %s",
5225 (value & 0x04) ? "discontinuous" : "continuous");
5227 switch (value & 0x03)
5229 case 0: str = "Power Class I"; break;
5230 case 1: str = "Power Class II"; break;
5231 case 2: str = "Power Class III"; break;
5232 case 3: str = "Reserved"; break;
5235 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
5236 proto_tree_add_text(tree, asn1->tvb,
5237 saved_offset, asn1->offset - saved_offset,
5242 EXTRANEOUS_DATA_CHECK(len, 1);
5246 param_ota_result_code(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5252 add_string = add_string;
5253 saved_offset = asn1->offset;
5255 asn1_int32_value_decode(asn1, 1, &value);
5259 case 0: str = "Accepted - Successful"; break;
5260 case 1: str = "Rejected - Unknown cause"; break;
5261 case 2: str = "Computation Failure - E.g., unable to compute A-key"; break;
5262 case 3: str = "CSC Rejected - CSC challenge failure"; break;
5263 case 4: str = "Unrecognized OTASPCallEntry"; break;
5264 case 5: str = "Unsupported AKeyProtocolVersion(s)"; break;
5265 case 6: str = "Unable to Commit"; break;
5267 if ((value >= 7) && (value <= 223)) { str = "Reserved, treat as Rejected - Unknown cause"; }
5268 else { str = "Reserved for protocol extension, treat as Rejected - Unknown cause"; }
5272 proto_tree_add_text(tree, asn1->tvb,
5273 saved_offset, asn1->offset - saved_offset,
5278 EXTRANEOUS_DATA_CHECK(len, 1);
5282 param_cdma_scm2(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5287 add_string = add_string;
5288 saved_offset = asn1->offset;
5290 asn1_int32_value_decode(asn1, 1, &value);
5292 proto_tree_add_text(tree, asn1->tvb,
5293 saved_offset, asn1->offset - saved_offset,
5297 EXTRANEOUS_DATA_CHECK(len, 1);
5301 param_tdma_term_cap(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5307 SHORT_DATA_CHECK(len, 4);
5309 add_string = add_string;
5310 saved_offset = asn1->offset;
5312 asn1_int32_value_decode(asn1, 1, &value);
5314 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
5315 proto_tree_add_text(tree, asn1->tvb,
5316 saved_offset, asn1->offset - saved_offset,
5320 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
5321 proto_tree_add_text(tree, asn1->tvb,
5322 saved_offset, asn1->offset - saved_offset,
5323 "%s : 1800 MHz F channel %sacceptable",
5325 (value & 0x40) ? "" : "not ");
5327 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
5328 proto_tree_add_text(tree, asn1->tvb,
5329 saved_offset, asn1->offset - saved_offset,
5330 "%s : 1800 MHz E channel %sacceptable",
5332 (value & 0x20) ? "" : "not ");
5334 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
5335 proto_tree_add_text(tree, asn1->tvb,
5336 saved_offset, asn1->offset - saved_offset,
5337 "%s : 1800 MHz D channel %sacceptable",
5339 (value & 0x10) ? "" : "not ");
5341 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
5342 proto_tree_add_text(tree, asn1->tvb,
5343 saved_offset, asn1->offset - saved_offset,
5344 "%s : 1800 MHz C channel %sacceptable",
5346 (value & 0x08) ? "" : "not ");
5348 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
5349 proto_tree_add_text(tree, asn1->tvb,
5350 saved_offset, asn1->offset - saved_offset,
5351 "%s : 1800 MHz B channel %sacceptable",
5353 (value & 0x04) ? "" : "not ");
5355 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
5356 proto_tree_add_text(tree, asn1->tvb,
5357 saved_offset, asn1->offset - saved_offset,
5358 "%s : %s acceptable",
5360 (value & 0x02) ? "1800 MHz A channel" : "1800 MHz A&B Digital channel not");
5362 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
5363 proto_tree_add_text(tree, asn1->tvb,
5364 saved_offset, asn1->offset - saved_offset,
5365 "%s : 800 MHz A&B channel %sacceptable",
5367 (value & 0x01) ? "" : "not ");
5369 saved_offset = asn1->offset;
5371 asn1_int32_value_decode(asn1, 1, &value);
5373 other_decode_bitfield_value(bigbuf, value, 0xfc, 8);
5374 proto_tree_add_text(tree, asn1->tvb,
5375 saved_offset, asn1->offset - saved_offset,
5379 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
5380 proto_tree_add_text(tree, asn1->tvb,
5381 saved_offset, asn1->offset - saved_offset,
5382 "%s : IS-641 Voice Coder %sacceptable",
5384 (value & 0x02) ? "" : "not ");
5386 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
5387 proto_tree_add_text(tree, asn1->tvb,
5388 saved_offset, asn1->offset - saved_offset,
5389 "%s : VSELP Voice Coder %sacceptable",
5391 (value & 0x01) ? "" : "not ");
5393 saved_offset = asn1->offset;
5395 asn1_int32_value_decode(asn1, 1, &value);
5399 case 0: str = "EIA-553 or IS-54-A"; break;
5400 case 1: str = "TIA/EIA-627 (IS-54-B)"; break;
5401 case 2: str = "IS-136"; break;
5402 case 3: str = "Reserved (ANSI J-STD-011)"; break;
5403 case 4: str = "PV 0 as published in TIA/EIA-136-0 and IS-136-A"; break;
5404 case 5: str = "PV 1 as published in TIA/EIA-136-A"; break;
5405 case 6: str = "PV 2 as published in TIA/EIA-136-A"; break;
5406 case 7: str = "PV 3 as published in TIA/EIA-136-A"; break;
5408 str = "Reserved, treat as EIA-553 or IS-54-A";
5412 proto_tree_add_text(tree, asn1->tvb,
5414 "Protocol Version, %s",
5417 saved_offset = asn1->offset;
5419 asn1_int32_value_decode(asn1, 1, &value);
5421 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
5422 proto_tree_add_text(tree, asn1->tvb,
5423 saved_offset, asn1->offset - saved_offset,
5424 "%s : Triple Rate (3RATE) %ssupported",
5426 (value & 0x80) ? "" : "not ");
5428 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
5429 proto_tree_add_text(tree, asn1->tvb,
5430 saved_offset, asn1->offset - saved_offset,
5431 "%s : Double Rate (2RATE) %ssupported",
5433 (value & 0x40) ? "" : "not ");
5435 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
5436 proto_tree_add_text(tree, asn1->tvb,
5437 saved_offset, asn1->offset - saved_offset,
5438 "%s : Full Rate (FRATE) %ssupported",
5440 (value & 0x20) ? "" : "not ");
5442 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
5443 proto_tree_add_text(tree, asn1->tvb,
5444 saved_offset, asn1->offset - saved_offset,
5445 "%s : Half Rate (HRATE) %ssupported",
5447 (value & 0x10) ? "" : "not ");
5449 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
5450 proto_tree_add_text(tree, asn1->tvb,
5451 saved_offset, asn1->offset - saved_offset,
5452 "%s : Analog Voice (AVOX) %ssupported",
5454 (value & 0x08) ? "" : "not ");
5456 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
5457 proto_tree_add_text(tree, asn1->tvb,
5458 saved_offset, asn1->offset - saved_offset,
5459 "%s : Secure Telephone Unit III (STU3) %ssupported",
5461 (value & 0x04) ? "" : "not ");
5463 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
5464 proto_tree_add_text(tree, asn1->tvb,
5465 saved_offset, asn1->offset - saved_offset,
5466 "%s : Group 3 Fax (G3FAX) %ssupported",
5468 (value & 0x02) ? "" : "not ");
5470 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
5471 proto_tree_add_text(tree, asn1->tvb,
5472 saved_offset, asn1->offset - saved_offset,
5473 "%s : Asynchronous Data (ADS) %ssupported",
5475 (value & 0x01) ? "" : "not ");
5477 EXTRANEOUS_DATA_CHECK(len, 4);
5481 param_tdma_voice_coder(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5484 guint orig_offset, saved_offset;
5487 SHORT_DATA_CHECK(len, 2);
5489 add_string = add_string;
5490 orig_offset = asn1->offset;
5491 saved_offset = asn1->offset;
5495 asn1_int32_value_decode(asn1, 1, &value);
5497 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
5498 proto_tree_add_text(tree, asn1->tvb,
5499 saved_offset, asn1->offset - saved_offset,
5503 vc = (value & 0x0f);
5506 case 0: str = "Not used"; break;
5507 case 1: str = "VSELP Voice Coder acceptable"; break;
5508 case 2: str = "IS-641 Voice Coder acceptable"; break;
5509 case 6: str = "Reserved for SOC/BSMC Specific signaling. If unknown, use any acceptable value"; break;
5511 if ((vc >= 3) && (vc <= 5)) { str = "Reserved. Ignore on reception, use any acceptable value"; }
5512 else if ((vc >= 7) && (vc <= 12)) { str = "Reserved. Ignore on reception, use any acceptable value"; }
5513 else if ((vc >= 13) && (vc <= 15)) { str = "Reserved for protocol extension. If unknown, use any acceptable value"; }
5517 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
5518 proto_tree_add_text(tree, asn1->tvb,
5519 saved_offset, asn1->offset - saved_offset,
5520 "%s : Voice Coder, %s",
5524 saved_offset = asn1->offset;
5526 while ((len - (saved_offset - orig_offset)) > 0);
5530 param_cdma_pilot_pn(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5535 SHORT_DATA_CHECK(len, 2);
5537 add_string = add_string;
5538 saved_offset = asn1->offset;
5540 asn1_int32_value_decode(asn1, 2, &value);
5542 other_decode_bitfield_value(bigbuf, value >> 8, 0xfe, 8);
5543 proto_tree_add_text(tree, asn1->tvb,
5548 other_decode_bitfield_value(bigbuf, value >> 8, 0x01, 8);
5549 proto_tree_add_text(tree, asn1->tvb,
5551 "%s : Pilot PN (MSB), %u",
5552 bigbuf, value & 0x01ff);
5554 other_decode_bitfield_value(bigbuf, value & 0x00ff, 0xff, 8);
5555 proto_tree_add_text(tree, asn1->tvb,
5556 saved_offset + 1, 1,
5557 "%s : Pilot PN (LSB)",
5560 EXTRANEOUS_DATA_CHECK(len, 2);
5564 param_cdma_pilot_strength(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5569 EXACT_DATA_CHECK(len, 1);
5571 add_string = add_string;
5572 saved_offset = asn1->offset;
5574 asn1_int32_value_decode(asn1, 1, &value);
5576 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
5577 proto_tree_add_text(tree, asn1->tvb,
5578 saved_offset, asn1->offset - saved_offset,
5582 other_decode_bitfield_value(bigbuf, value, 0x3f, 8);
5583 proto_tree_add_text(tree, asn1->tvb,
5584 saved_offset, asn1->offset - saved_offset,
5591 param_trunk_stat(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5597 EXACT_DATA_CHECK(len, 1);
5599 add_string = add_string;
5600 saved_offset = asn1->offset;
5602 asn1_int32_value_decode(asn1, 1, &value);
5606 case 0: str = "Idle"; break;
5607 case 1: str = "Blocked"; break;
5609 if ((value >= 2) && (value <= 223)) { str = "Reserved, treat as ERROR or Blocked"; }
5610 else { str = "Reserved for protocol extension, treat as ERROR or Blocked"; }
5614 proto_tree_add_text(tree, asn1->tvb,
5615 saved_offset, asn1->offset - saved_offset,
5621 param_pref_lang_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5627 add_string = add_string;
5628 saved_offset = asn1->offset;
5630 asn1_int32_value_decode(asn1, 1, &value);
5634 case 0: str = "Unspecified"; break;
5635 case 1: str = "English"; break;
5636 case 2: str = "French"; break;
5637 case 3: str = "Spanish"; break;
5638 case 4: str = "German"; break;
5639 case 5: str = "Portuguese"; break;
5641 str = "Reserved, treat as Unspecified";
5645 proto_tree_add_text(tree, asn1->tvb,
5646 saved_offset, asn1->offset - saved_offset,
5647 "Preferred Language, %s",
5650 EXTRANEOUS_DATA_CHECK(len, 1);
5654 param_rand_valtime(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5660 add_string = add_string;
5661 saved_offset = asn1->offset;
5663 asn1_int32_value_decode(asn1, 1, &value);
5667 str = "RAND shall not be stored";
5671 sprintf(bigbuf, "RAND may be used for %u minutes", value);
5675 proto_tree_add_text(tree, asn1->tvb,
5676 saved_offset, asn1->offset - saved_offset,
5679 EXTRANEOUS_DATA_CHECK(len, 1);
5683 param_tdma_burst_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5689 EXACT_DATA_CHECK(len, 1);
5691 add_string = add_string;
5692 saved_offset = asn1->offset;
5694 asn1_int32_value_decode(asn1, 1, &value);
5696 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
5697 proto_tree_add_text(tree, asn1->tvb,
5698 saved_offset, asn1->offset - saved_offset,
5702 other_decode_bitfield_value(bigbuf, value, 0x7c, 8);
5703 proto_tree_add_text(tree, asn1->tvb,
5704 saved_offset, asn1->offset - saved_offset,
5705 "%s : Time Alignment Offset (TA), %u",
5707 (value & 0x7c) >> 2);
5709 switch (value & 0x03)
5711 case 0: str = "Transmit normal burst after cell-to-cell handoff"; break;
5712 case 1: str = "Transmit normal burst after handoff within cell"; break;
5713 case 2: str = "Transmit shortened burst after cell-to-cell handoff"; break;
5714 case 3: str = "Reserved, treat with RETURN ERROR"; break;
5717 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
5718 proto_tree_add_text(tree, asn1->tvb,
5719 saved_offset, asn1->offset - saved_offset,
5720 "%s : Burst Code, %s",
5726 param_orig_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5732 EXACT_DATA_CHECK(len, 1);
5734 add_string = add_string;
5735 saved_offset = asn1->offset;
5737 asn1_int32_value_decode(asn1, 1, &value);
5741 case 0: str = "Not used"; break;
5742 case 1: str = "Prior agreement"; break;
5743 case 2: str = "Origination denied"; break;
5744 case 3: str = "Local calls only"; break;
5745 case 4: str = "Selected leading digits of directory number or of international E.164 number, see Digits(Destination)"; break;
5746 case 5: str = "Selected leading digits of directory number or of international E.164 number and local calls only, see Digits(Destination)"; break;
5747 case 6: str = "National long distance"; break;
5748 case 7: str = "International calls"; break;
5749 case 8: str = "Single directory number or international E.164 number, see Digits(Destination)"; break;
5751 if ((value >= 9) && (value <= 223)) { str = "Reserved, treat as Local calls only"; }
5752 else { str = "Reserved for protocol extension, treat as Local calls only"; }
5756 proto_tree_add_text(tree, asn1->tvb,
5757 saved_offset, asn1->offset - saved_offset,
5758 "Allowed Call Types, %s",
5763 param_ms_loc(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5768 SHORT_DATA_CHECK(len, 7);
5770 add_string = add_string;
5771 saved_offset = asn1->offset;
5773 asn1_int32_value_decode(asn1, 3, &value);
5775 proto_tree_add_text(tree, asn1->tvb,
5776 saved_offset, asn1->offset - saved_offset,
5777 "Latitude in tenths of a second, %u",
5780 saved_offset = asn1->offset;
5782 asn1_int32_value_decode(asn1, 3, &value);
5784 proto_tree_add_text(tree, asn1->tvb,
5785 saved_offset, asn1->offset - saved_offset,
5786 "Longitude in tenths of a second, %u",
5789 saved_offset = asn1->offset;
5791 asn1_int32_value_decode(asn1, MIN(len - 6, 2), &value);
5793 proto_tree_add_text(tree, asn1->tvb,
5794 saved_offset, asn1->offset - saved_offset,
5795 "Resolution in units of 1 foot, %u",
5798 EXTRANEOUS_DATA_CHECK(len, 8);
5802 param_unique_chal_rep(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5808 add_string = add_string;
5809 saved_offset = asn1->offset;
5811 asn1_int32_value_decode(asn1, 1, &value);
5815 case 0: str = "Not used"; break;
5816 case 1: str = "Unique Challenge not attempted"; break;
5817 case 2: str = "Unique Challenge no response"; break;
5818 case 3: str = "Unique Challenge successful"; break;
5819 case 4: str = "Unique Challenge failed"; break;
5821 if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Unique Challenge not attempted"; }
5822 else { str = "Reserved for protocol extension, treat as Unique Challenge not attempted"; }
5826 proto_tree_add_text(tree, asn1->tvb,
5827 saved_offset, asn1->offset - saved_offset,
5830 EXTRANEOUS_DATA_CHECK(len, 1);
5834 param_rand_unique(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5838 EXACT_DATA_CHECK(len, 3);
5840 add_string = add_string;
5841 saved_offset = asn1->offset;
5843 proto_tree_add_text(tree, asn1->tvb,
5845 "24-bit random number used as input to the CAVE algorithm for authenticating a specific MS");
5847 asn1->offset += len;
5851 param_vpmask(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5856 EXACT_DATA_CHECK(len, 66);
5858 add_string = add_string;
5859 saved_offset = asn1->offset;
5861 asn1_int32_value_decode(asn1, 1, &value);
5863 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
5864 proto_tree_add_text(tree, asn1->tvb,
5865 saved_offset, asn1->offset - saved_offset,
5869 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
5870 proto_tree_add_text(tree, asn1->tvb,
5871 saved_offset, asn1->offset - saved_offset,
5872 "%s : Voice Privacy Mask-A (VPMASK-A) (MSB)",
5875 saved_offset = asn1->offset;
5877 proto_tree_add_text(tree, asn1->tvb,
5879 "Voice Privacy Mask-A (VPMASK-A)");
5883 saved_offset = asn1->offset;
5885 asn1_int32_value_decode(asn1, 1, &value);
5887 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
5888 proto_tree_add_text(tree, asn1->tvb,
5889 saved_offset, asn1->offset - saved_offset,
5893 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
5894 proto_tree_add_text(tree, asn1->tvb,
5895 saved_offset, asn1->offset - saved_offset,
5896 "%s : Voice Privacy Mask-B (VPMASK-B) (MSB)",
5899 saved_offset = asn1->offset;
5901 proto_tree_add_text(tree, asn1->tvb,
5903 "Voice Privacy Mask-B (VPMASK-B)");
5909 param_ssd(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5913 EXACT_DATA_CHECK(len, 16);
5915 add_string = add_string;
5916 saved_offset = asn1->offset;
5918 proto_tree_add_text(tree, asn1->tvb,
5920 "Shared Secret Data-A (SSD-A)");
5922 proto_tree_add_text(tree, asn1->tvb,
5924 "Shared Secret Data-B (SSD-B)");
5926 asn1->offset += len;
5930 param_upd_count(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5936 EXACT_DATA_CHECK(len, 1);
5938 add_string = add_string;
5939 saved_offset = asn1->offset;
5941 asn1_int32_value_decode(asn1, 1, &value);
5945 case 0: str = "Not used"; break;
5946 case 1: str = "Update COUNT"; break;
5948 if ((value >= 2) && (value <= 223)) { str = "Reserved, treat as Update COUNT"; }
5949 else { str = "Reserved for protocol extension, treat as Update COUNT"; }
5953 proto_tree_add_text(tree, asn1->tvb,
5954 saved_offset, asn1->offset - saved_offset,
5960 param_sme_key(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5964 EXACT_DATA_CHECK(len, 8);
5966 add_string = add_string;
5967 saved_offset = asn1->offset;
5969 proto_tree_add_text(tree, asn1->tvb,
5971 "Signaling Message Encryption Key (SMEKEY)");
5973 asn1->offset += len;
5977 param_rand_ssd(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
5981 EXACT_DATA_CHECK(len, 7);
5983 add_string = add_string;
5984 saved_offset = asn1->offset;
5986 proto_tree_add_text(tree, asn1->tvb,
5988 "56-bit random number used as input to the CAVE algorithm for generating Shared Secret Data");
5990 asn1->offset += len;
5994 param_setup_result(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6000 add_string = add_string;
6001 saved_offset = asn1->offset;
6003 asn1_int32_value_decode(asn1, 1, &value);
6007 case 0: str = "Not used"; break;
6008 case 1: str = "Unsuccessful"; break;
6009 case 2: str = "Successful"; break;
6011 str = "Reserved, treat as Unsuccessful";
6015 proto_tree_add_text(tree, asn1->tvb,
6016 saved_offset, asn1->offset - saved_offset,
6019 EXTRANEOUS_DATA_CHECK(len, 1);
6023 param_randc(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6027 add_string = add_string;
6028 saved_offset = asn1->offset;
6030 proto_tree_add_text(tree, asn1->tvb,
6032 "The 8 most significant bits of the 32-bit Random Variable used to compute the Authentication Response");
6036 EXTRANEOUS_DATA_CHECK(len, 1);
6040 param_ext_mscid(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6046 EXACT_DATA_CHECK(len, 4);
6048 saved_offset = asn1->offset;
6050 asn1_int32_value_decode(asn1, 1, &type);
6054 case 0: str = "Not specified"; break;
6055 case 1: str = "Serving MSC"; break;
6056 case 2: str = "Home MSC"; break;
6057 case 3: str = "Gateway MSC"; break;
6058 case 4: str = "HLR"; break;
6059 case 5: str = "VLR"; break;
6060 case 6: str = "EIR (reserved)"; break;
6061 case 7: str = "AC"; break;
6062 case 8: str = "Border MSC"; break;
6063 case 9: str = "Originating MSC"; break;
6065 if ((type >= 10) && (type <= 223)) { str = "Reserved, treat as Not specified"; }
6066 else { str = "Reserved for protocol extension, treat as Not specified"; }
6070 proto_tree_add_text(tree, asn1->tvb,
6071 saved_offset, asn1->offset - saved_offset,
6076 param_mscid(asn1, tree, len-1, add_string);
6080 param_sub_addr(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6086 add_string = add_string;
6087 saved_offset = asn1->offset;
6088 asn1_int32_value_decode(asn1, 1, &value);
6090 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
6091 proto_tree_add_text(tree, asn1->tvb,
6092 saved_offset, asn1->offset - saved_offset,
6096 switch ((value & 0x70) >> 4)
6098 case 0x00: str = "NSAP (CCITT Rec. X.213 or ISO 8348 AD2)"; break;
6099 case 0x02: str = "User specified"; break;
6105 other_decode_bitfield_value(bigbuf, value, 0x70, 8);
6106 proto_tree_add_text(tree, asn1->tvb,
6107 saved_offset, asn1->offset - saved_offset,
6108 "%s : Type of Subaddress %s",
6111 switch ((value & 0x08) >> 3)
6113 case 0x00: str = "Even number of subaddress signals follow"; break;
6114 case 0x01: str = "Odd number of subaddress signals follow"; break;
6117 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
6118 proto_tree_add_text(tree, asn1->tvb,
6119 saved_offset, asn1->offset - saved_offset,
6123 proto_tree_add_text(tree, asn1->tvb,
6124 asn1->offset, len - 1,
6127 asn1->offset += len - 1;
6131 param_digits(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6133 gint32 value, b1, b2, b3, b4, enc, plan;
6137 proto_tree *subtree;
6140 SHORT_DATA_CHECK(len, 4);
6142 add_string = add_string;
6143 saved_offset = asn1->offset;
6144 asn1_int32_value_decode(asn1, 1, &value);
6148 case 0: str = "Not used"; break;
6149 case 1: str = "Dialed Numer or Called Party Number"; break;
6150 case 2: str = "Calling Party Number"; break;
6151 case 3: str = "Caller Interaction (Not used)"; break;
6152 case 4: str = "Routing Number"; break;
6153 case 5: str = "Billing Number"; break;
6154 case 6: str = "Destination Number"; break;
6155 case 7: str = "LATA (Not used)"; break;
6156 case 8: str = "Carrier"; break;
6157 case 13: str = "ESRD"; break;
6163 proto_tree_add_text(tree, asn1->tvb,
6164 saved_offset, asn1->offset - saved_offset,
6165 "Type of Digits %u: %s",
6168 saved_offset = asn1->offset;
6169 asn1_int32_value_decode(asn1, 1, &value);
6172 proto_tree_add_text(tree, asn1->tvb,
6173 saved_offset, asn1->offset - saved_offset,
6174 "Nature of Number");
6176 subtree = proto_item_add_subtree(item, ett_natnum);
6178 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
6179 proto_tree_add_text(subtree, asn1->tvb,
6180 saved_offset, asn1->offset - saved_offset,
6184 switch ((value & 0x30) >> 4)
6186 case 0x00: str = "User provided, not screened"; break;
6187 case 0x01: str = "User provided, screening passed"; break;
6188 case 0x02: str = "User provided, screening failed"; break;
6189 case 0x03: str = "Network provided"; break;
6192 other_decode_bitfield_value(bigbuf, value, 0x30, 8);
6193 proto_tree_add_text(subtree, asn1->tvb,
6194 saved_offset, asn1->offset - saved_offset,
6198 proto_tree_add_text(subtree, asn1->tvb,
6199 saved_offset, asn1->offset - saved_offset,
6200 ".... %u... : Reserved",
6201 (value & 0x08) >> 3);
6203 proto_tree_add_text(subtree, asn1->tvb,
6204 saved_offset, asn1->offset - saved_offset,
6205 ".... .%u.. : Number is %savailable",
6206 (value & 0x04) >> 2, (value & 0x04) ? "not " : "");
6208 proto_tree_add_text(subtree, asn1->tvb,
6209 saved_offset, asn1->offset - saved_offset,
6210 ".... ..%u. : Presentation %s",
6211 (value & 0x02) >> 1, (value & 0x02) ? "Restricted" : "Allowed");
6213 proto_tree_add_text(subtree, asn1->tvb,
6214 saved_offset, asn1->offset - saved_offset,
6216 value & 0x01, (value & 0x01) ? "International" : "National");
6218 saved_offset = asn1->offset;
6219 asn1_int32_value_decode(asn1, 1, &value);
6221 plan = (value & 0xf0) >> 4;
6224 case 0x00: str = "Unknown or not applicable"; break;
6225 case 0x01: str = "ISDN Numbering (Not used)"; break;
6226 case 0x02: str = "Telephony Numbering (ITU-T Rec. E.164, E.163)"; break;
6227 case 0x03: str = "Data Numbering (ITU-T Rec. X.121)(Not used)"; break;
6228 case 0x04: str = "Telex Numbering (ITU-T Rec. F.69)(Not used)"; break;
6229 case 0x05: str = "Maritime Mobile Numbering (Not used)"; break;
6230 case 0x06: str = "Land Mobile Numbering (ITU-T Rec. E.212)"; break;
6231 case 0x07: str = "Private Numbering Plan (service provider defined)"; break;
6232 case 0x0d: str = "ANSI SS7 Point Code (PC) and Subsystem Number (SSN)"; break;
6233 case 0x0e: str = "Internet Protocol (IP) Address"; break;
6234 case 0x0f: str = "Reserved for extension"; break;
6240 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
6241 proto_tree_add_text(tree, asn1->tvb,
6242 saved_offset, asn1->offset - saved_offset,
6243 "%s : Numbering Plan: %s",
6249 case 0x00: str = "Not used"; break;
6250 case 0x01: str = "BCD"; break;
6251 case 0x02: str = "IA5"; break;
6252 case 0x03: str = "Octet String"; break;
6258 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
6259 proto_tree_add_text(tree, asn1->tvb,
6260 saved_offset, asn1->offset - saved_offset,
6261 "%s : Encoding: %s",
6264 saved_offset = asn1->offset;
6268 asn1_int32_value_decode(asn1, 1, &b1);
6269 asn1_int32_value_decode(asn1, 1, &b2);
6270 asn1_int32_value_decode(asn1, 1, &b3);
6271 asn1_int32_value_decode(asn1, 1, &b4);
6273 proto_tree_add_text(tree, asn1->tvb,
6274 saved_offset, asn1->offset - saved_offset,
6275 "Point Code %u-%u-%u SSN %u",
6278 else if (plan == 0x0e)
6280 asn1_int32_value_decode(asn1, 1, &b1);
6281 asn1_int32_value_decode(asn1, 1, &b2);
6282 asn1_int32_value_decode(asn1, 1, &b3);
6283 asn1_int32_value_decode(asn1, 1, &b4);
6285 proto_tree_add_text(tree, asn1->tvb,
6286 saved_offset, asn1->offset - saved_offset,
6287 "IP Address %u.%u.%u.%u",
6292 asn1_int32_value_decode(asn1, 1, &value);
6294 proto_tree_add_text(tree, asn1->tvb,
6295 saved_offset, asn1->offset - saved_offset,
6296 "Number of Digits: %u",
6301 proto_tree_add_text(tree, asn1->tvb,
6302 asn1->offset, value,
6305 asn1->offset += value;
6307 else if (enc == 0x01)
6309 saved_offset = asn1->offset;
6310 asn1_string_value_decode(asn1, (value+1)/2, &poctets);
6312 my_dgt_tbcd_unpack(bigbuf, poctets, (value+1)/2, &Dgt_tbcd);
6315 proto_tree_add_text(tree, asn1->tvb,
6316 saved_offset, (value+1)/2,
6324 param_esn(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6329 EXACT_DATA_CHECK(len, 4);
6331 add_string = add_string;
6332 saved_offset = asn1->offset;
6334 asn1_int32_value_decode(asn1, 4, &value);
6336 proto_tree_add_text(tree, asn1->tvb,
6337 saved_offset, asn1->offset - saved_offset,
6341 sprintf(add_string, " - 0x%04x", value);
6345 param_sms_noti(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6351 add_string = add_string;
6352 saved_offset = asn1->offset;
6354 asn1_int32_value_decode(asn1, 1, &value);
6358 case 0: str = "Not used"; break;
6359 case 1: str = "Notify when available"; break;
6360 case 2: str = "Do not notify when available"; break;
6362 if ((value >= 3) && (value <= 127)) { str = "Reserved, treat as Notify when available"; }
6363 else if ((value >= 128) && (value <= 223)) { str = "Reserved, treat as Do not notify when available"; }
6364 else { str = "Reserved for protocol extension"; }
6368 proto_tree_add_text(tree, asn1->tvb,
6369 saved_offset, asn1->offset - saved_offset,
6374 EXTRANEOUS_DATA_CHECK(len, 1);
6378 param_sms_orig_restric(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6384 add_string = add_string;
6385 saved_offset = asn1->offset;
6387 asn1_int32_value_decode(asn1, 1, &value);
6389 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
6390 proto_tree_add_text(tree, asn1->tvb,
6391 saved_offset, asn1->offset - saved_offset,
6395 switch (value & 0x08)
6397 case 0x00: str = "No effect"; break;
6399 str = "Force indirect";
6403 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
6404 proto_tree_add_text(tree, asn1->tvb,
6405 saved_offset, asn1->offset - saved_offset,
6406 "%s : Force Message Center, %s",
6409 switch (value & 0x04)
6411 case 0x00: str = "Block direct"; break;
6413 str = "Allow direct";
6417 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
6418 proto_tree_add_text(tree, asn1->tvb,
6419 saved_offset, asn1->offset - saved_offset,
6423 switch (value & 0x03)
6425 case 0x00: str = "Block all"; break;
6426 case 0x02: str = "Allow specific"; break;
6427 case 0x03: str = "Allow all"; break;
6433 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
6434 proto_tree_add_text(tree, asn1->tvb,
6435 saved_offset, asn1->offset - saved_offset,
6439 EXTRANEOUS_DATA_CHECK(len, 1);
6443 param_seizure(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6449 add_string = add_string;
6450 saved_offset = asn1->offset;
6452 asn1_int32_value_decode(asn1, 1, &value);
6456 case 0: str = "Unspecified"; break;
6457 case 1: str = "Loopback"; break;
6459 if ((value >= 2) && (value <= 223)) { str = "Reserved"; }
6460 else { str = "Reserved for protocol extension"; }
6464 proto_tree_add_text(tree, asn1->tvb,
6465 saved_offset, asn1->offset - saved_offset,
6468 EXTRANEOUS_DATA_CHECK(len, 1);
6472 param_sms_tele(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6478 ansi_map_sms_tele_id = -1;
6480 SHORT_DATA_CHECK(len, 2);
6482 add_string = add_string;
6483 saved_offset = asn1->offset;
6485 asn1_int32_value_decode(asn1, 2, &value);
6487 str = match_strval(value, ansi_tele_strings);
6492 case 0: str = "Not used"; break;
6494 if ((value >= 2) && (value <= 4095)) { str = "Reserved for assignment by TIA/EIA-41"; }
6495 else if ((value >= 4100) && (value <= 32512)) { str = "Reserved for assignment by TIA/EIA-41"; }
6496 else if ((value >= 32514) && (value <= 32639)) { str = "Reserved for assignment by this Standard for TDMA MS-based SMEs."; }
6497 else if ((value >= 32640) && (value <= 32767)) { str = "Reserved for carrier specific teleservices for TDMA MS-based SMEs."; }
6498 else if ((value >= 32768) && (value <= 49151)) { str = "Reserved for node specific teleservices."; }
6499 else if ((value >= 49152) && (value <= 65535)) { str = "Reserved for carrier specific teleservices."; }
6500 else { str = "Unknown teleservice ID"; }
6505 ansi_map_sms_tele_id = value;
6507 proto_tree_add_text(tree, asn1->tvb,
6508 saved_offset, asn1->offset - saved_offset,
6513 EXTRANEOUS_DATA_CHECK(len, 2);
6517 param_sms_term_restric(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6523 add_string = add_string;
6524 saved_offset = asn1->offset;
6526 asn1_int32_value_decode(asn1, 1, &value);
6528 other_decode_bitfield_value(bigbuf, value, 0xf8, 8);
6529 proto_tree_add_text(tree, asn1->tvb,
6530 saved_offset, asn1->offset - saved_offset,
6534 switch (value & 0x04)
6536 case 0x00: str = "Block messages charged to destination"; break;
6538 str = "Allow messages charged to destination";
6542 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
6543 proto_tree_add_text(tree, asn1->tvb,
6544 saved_offset, asn1->offset - saved_offset,
6545 "%s : Reverse Charges, %s",
6548 switch (value & 0x03)
6550 case 0x00: str = "Block all"; break;
6551 case 0x02: str = "Allow specific"; break;
6552 case 0x03: str = "Allow all"; break;
6558 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
6559 proto_tree_add_text(tree, asn1->tvb,
6560 saved_offset, asn1->offset - saved_offset,
6564 EXTRANEOUS_DATA_CHECK(len, 1);
6568 param_sms_msg_count(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6574 add_string = add_string;
6575 saved_offset = asn1->offset;
6577 asn1_int32_value_decode(asn1, 1, &value);
6581 case 0: str = "No more pending SMS messages"; break;
6583 sprintf(bigbuf, "%u pending SMS messages", value);
6588 proto_tree_add_text(tree, asn1->tvb,
6589 saved_offset, asn1->offset - saved_offset,
6592 EXTRANEOUS_DATA_CHECK(len, 1);
6596 param_qos_pri(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6598 gint32 value, temp_int;
6602 add_string = add_string;
6603 saved_offset = asn1->offset;
6605 asn1_int32_value_decode(asn1, 1, &value);
6607 temp_int = (value & 0xf0) >> 4;
6608 if ((temp_int < 0) || (temp_int >= (gint) NUM_QOS_PRI_STR))
6614 str = qos_pri_str[temp_int];
6617 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
6618 proto_tree_add_text(tree, asn1->tvb,
6619 saved_offset, asn1->offset - saved_offset,
6620 "%s : Assured Priority, %s",
6624 temp_int = value & 0x0f;
6625 if ((temp_int < 0) || (temp_int >= (gint) NUM_QOS_PRI_STR))
6631 str = qos_pri_str[temp_int];
6634 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
6635 proto_tree_add_text(tree, asn1->tvb,
6636 saved_offset, asn1->offset - saved_offset,
6637 "%s : Non-Assured Priority, %s",
6641 EXTRANEOUS_DATA_CHECK(len, 1);
6645 param_calling_party_cat(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6650 EXACT_DATA_CHECK(len, 1);
6652 add_string = add_string;
6653 saved_offset = asn1->offset;
6655 asn1_int32_value_decode(asn1, 1, &value);
6657 proto_tree_add_text(tree, asn1->tvb,
6658 saved_offset, asn1->offset - saved_offset,
6659 "Calling Party's Category, Refer to ITU-T Q.763 (Signalling System No. 7 ISDN user part formats and codes) for encoding of this parameter");
6663 * Dissect IOS data parameters expected to be in TLV format
6666 dissect_cdma2000_ios_data(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6671 guint32 orig_offset, saved_offset;
6672 proto_tree *subtree;
6678 orig_offset = saved_offset = asn1->offset;
6680 while ((saved_offset - orig_offset + 2) <= len)
6684 asn1_int32_value_decode(asn1, 1, &value);
6685 str = my_match_strval((guint32) value, ansi_a_ios401_elem_1_strings, &idx);
6687 asn1_octet_decode(asn1, &elem_len);
6690 proto_tree_add_text(tree,
6691 asn1->tvb, saved_offset, elem_len + 2,
6695 subtree = proto_item_add_subtree(item, ett_ansi_map_ios401_elem[idx]);
6697 proto_tree_add_none_format(subtree, hf_ansi_map_ios401_elem_id, asn1->tvb,
6698 saved_offset, 1, "Element ID");
6700 proto_tree_add_uint(subtree, hf_ansi_map_length, asn1->tvb,
6701 saved_offset + 1, 1, elem_len);
6705 proto_tree_add_text(subtree,
6706 asn1->tvb, saved_offset + 2, elem_len,
6709 asn1->offset += elem_len;
6712 saved_offset += elem_len + 2;
6715 sprintf(add_string, " - (%u)", num_elems);
6717 EXTRANEOUS_DATA_CHECK((len - (saved_offset - orig_offset)), 0);
6721 param_cdma2000_ho_ivk_ios(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6724 dissect_cdma2000_ios_data(asn1, tree, len, add_string);
6728 param_cdma2000_ho_rsp_ios(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6731 dissect_cdma2000_ios_data(asn1, tree, len, add_string);
6735 param_msid_usage(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6741 add_string = add_string;
6742 saved_offset = asn1->offset;
6744 asn1_int32_value_decode(asn1, 1, &value);
6746 other_decode_bitfield_value(bigbuf, value, 0xfc, 8);
6747 proto_tree_add_text(tree, asn1->tvb,
6748 saved_offset, asn1->offset - saved_offset,
6752 switch (value & 0x03)
6754 case 0: str = "Not used"; break;
6755 case 1: str = "MIN last used"; break;
6756 case 2: str = "IMSI last used"; break;
6757 case 3: str = "Reserved"; break;
6760 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
6761 proto_tree_add_text(tree, asn1->tvb,
6762 saved_offset, asn1->offset - saved_offset,
6767 EXTRANEOUS_DATA_CHECK(len, 1);
6771 param_new_min_ext(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6777 EXACT_DATA_CHECK(len, 3);
6779 add_string = add_string;
6780 saved_offset = asn1->offset;
6782 asn1_int32_value_decode(asn1, 1, &value);
6784 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
6785 proto_tree_add_text(tree, asn1->tvb,
6786 saved_offset, asn1->offset - saved_offset,
6787 "%s : MCC_M (MSB), see CDMA",
6790 other_decode_bitfield_value(bigbuf, value, 0x0e, 8);
6791 proto_tree_add_text(tree, asn1->tvb,
6792 saved_offset, asn1->offset - saved_offset,
6793 "%s : IMSI_M_ADDR_NUM, see CDMA",
6796 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
6797 proto_tree_add_text(tree, asn1->tvb,
6798 saved_offset, asn1->offset - saved_offset,
6799 "%s : IMSI_M_CLASS, see CDMA",
6802 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
6803 proto_tree_add_text(tree, asn1->tvb,
6804 saved_offset, asn1->offset - saved_offset,
6809 bigbuf[0] = Dgt_tbcd.out[(value & 0xf0) >> 4];
6811 saved_offset = asn1->offset;
6813 asn1_int32_value_decode(asn1, 1, &value);
6815 bigbuf[1] = Dgt_tbcd.out[value & 0x0f];
6816 bigbuf[2] = Dgt_tbcd.out[(value & 0xf0) >> 4];
6819 proto_tree_add_text(tree, asn1->tvb,
6820 saved_offset, asn1->offset - saved_offset,
6821 "MCC_M, %s, see CDMA",
6824 saved_offset = asn1->offset;
6826 asn1_int32_value_decode(asn1, 1, &value);
6828 bigbuf[0] = Dgt_tbcd.out[value & 0x0f];
6829 bigbuf[1] = Dgt_tbcd.out[(value & 0xf0) >> 4];
6832 proto_tree_add_text(tree, asn1->tvb,
6833 saved_offset, asn1->offset - saved_offset,
6834 "IMSI_11_12, %s, see CDMA",
6839 param_dtx_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6845 add_string = add_string;
6846 saved_offset = asn1->offset;
6848 asn1_int32_value_decode(asn1, 1, &value);
6850 other_decode_bitfield_value(bigbuf, value, 0xfe, 8);
6851 proto_tree_add_text(tree, asn1->tvb,
6852 saved_offset, asn1->offset - saved_offset,
6856 switch (value & 0x01)
6858 case 0: str = "Discontinuous Transmission mode is not active"; break;
6859 case 1: str = "Discontinuous Transmission mode is active"; break;
6862 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
6863 proto_tree_add_text(tree, asn1->tvb,
6864 saved_offset, asn1->offset - saved_offset,
6869 EXTRANEOUS_DATA_CHECK(len, 1);
6873 param_cdma_mob_cap(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6879 add_string = add_string;
6880 saved_offset = asn1->offset;
6882 asn1_int32_value_decode(asn1, 1, &value);
6884 other_decode_bitfield_value(bigbuf, value, 0xfe, 8);
6885 proto_tree_add_text(tree, asn1->tvb,
6886 saved_offset, asn1->offset - saved_offset,
6890 switch (value & 0x01)
6892 case 0: str = "No MS-initiated position determination"; break;
6893 case 1: str = "MS-initiated position determination"; break;
6896 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
6897 proto_tree_add_text(tree, asn1->tvb,
6898 saved_offset, asn1->offset - saved_offset,
6903 EXTRANEOUS_DATA_CHECK(len, 1);
6907 param_gen_time(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6913 SHORT_DATA_CHECK(len, 6);
6915 add_string = add_string;
6916 saved_offset = asn1->offset;
6918 asn1_int32_value_decode(asn1, 1, &value);
6920 proto_tree_add_text(tree, asn1->tvb,
6921 saved_offset, asn1->offset - saved_offset,
6925 saved_offset = asn1->offset;
6927 asn1_int32_value_decode(asn1, 1, &value);
6929 proto_tree_add_text(tree, asn1->tvb,
6930 saved_offset, asn1->offset - saved_offset,
6934 saved_offset = asn1->offset;
6936 asn1_int32_value_decode(asn1, 1, &value);
6938 proto_tree_add_text(tree, asn1->tvb,
6939 saved_offset, asn1->offset - saved_offset,
6943 saved_offset = asn1->offset;
6945 asn1_int32_value_decode(asn1, 3, &value);
6947 h = value / (3600 * 10);
6948 m = (value - (h * (3600 * 10))) / (60 * 10);
6949 s = (value - (h * (3600 * 10)) - (m * (60 * 10))) / 10;
6950 ts = (value - (h * (3600 * 10)) - (m * (60 * 10)) - (s * 10));
6952 proto_tree_add_text(tree, asn1->tvb,
6953 saved_offset, asn1->offset - saved_offset,
6954 "Time of day (UTC) (in tenths of seconds - 1), %u (%u:%u:%u.%u)",
6961 EXTRANEOUS_DATA_CHECK(len, 6);
6965 param_geo_pos(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6969 add_string = add_string;
6970 saved_offset = asn1->offset;
6972 proto_tree_add_text(tree, asn1->tvb,
6974 "Calling Geodetic Location (CGL), see T1.628 CallingGeodeticLocation TCAP parameter for encoding");
6978 param_mob_call_status(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
6984 add_string = add_string;
6985 saved_offset = asn1->offset;
6987 asn1_int32_value_decode(asn1, 1, &value);
6989 auth = (value & 0xf0) >> 4;
6992 case 0: str = "Authorization not performed"; break;
6993 case 1: str = "Authorization successful"; break;
6994 case 2: str = "Invalid Electronic Serial Number (ESN)"; break;
6995 case 3: str = "Unassigned Directory Number (DN)"; break;
6996 case 4: str = "Duplicate Unit"; break;
6997 case 5: str = "Delinquent Account"; break;
6998 case 6: str = "Stolen Unit"; break;
6999 case 7: str = "Not authorized for MSC"; break;
7000 case 8: str = "Unspecified"; break;
7002 str = "Reserved, treat as Authorization not performed";
7006 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
7007 proto_tree_add_text(tree, asn1->tvb,
7008 saved_offset, asn1->offset - saved_offset,
7009 "%s : Authorization, %s",
7013 auth = value & 0x0f;
7016 case 0: str = "Authentication not performed. Authentication has not yet occurred or the MS is not capable of authentication"; break;
7017 case 1: str = "Authentication successful. Authentication has successfully occurred on the MS"; break;
7018 case 2: str = "Authentication failure. An authentication failure has occurred on the MS"; break;
7020 str = "Reserved, treat as Authentication not performed";
7024 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
7025 proto_tree_add_text(tree, asn1->tvb,
7026 saved_offset, asn1->offset - saved_offset,
7027 "%s : Authentication, %s",
7031 EXTRANEOUS_DATA_CHECK(len, 1);
7035 param_pos_req_type(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7041 add_string = add_string;
7042 saved_offset = asn1->offset;
7044 asn1_int32_value_decode(asn1, 1, &value);
7048 case 0: str = "Not used"; break;
7049 case 1: str = "Initial position. Return updated position only if initial position is unavailable."; break;
7050 case 2: str = "Return the updated position"; break;
7051 case 3: str = "Return the updated or last known position"; break;
7052 case 4: str = "Reserved for LSP interface. Treat as Not used"; break;
7054 if ((value >= 5) && (value <= 95)) { str = "Reserved, treat as Initial position"; }
7055 else { str = "Reserved for protocol extension, treat as Initial position"; }
7059 proto_tree_add_text(tree, asn1->tvb,
7060 saved_offset, asn1->offset - saved_offset,
7061 "Position Request Type, %s",
7064 EXTRANEOUS_DATA_CHECK(len, 1);
7068 param_pos_result(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7074 add_string = add_string;
7075 saved_offset = asn1->offset;
7077 asn1_int32_value_decode(asn1, 1, &value);
7081 case 0: str = "Not used"; break;
7082 case 1: str = "Initial position returned"; break;
7083 case 2: str = "Updated position returned"; break;
7084 case 3: str = "Last known position returned"; break;
7085 case 4: str = "Requested position is not available"; break;
7086 case 5: str = "Caller disconnected. No call in progress for caller identified"; break;
7087 case 6: str = "Caller has handed-off. Position is unavailable due to a hand-off (e.g. handoff to a position incapable system)"; break;
7088 case 7: str = "Identified MS is inactive or has roamed to another system"; break;
7089 case 8: str = "Unresponsive"; break;
7090 case 9: str = "Identified MS is responsive, but refused position request"; break;
7091 case 10: str = "System Failure"; break;
7092 case 11: str = "MSID is not known"; break;
7093 case 12: str = "Callback number is not known"; break;
7094 case 13: str = "Improper request (e.g. invalid channel information, invalid ESN)"; break;
7095 case 14: str = "Mobile channel information returned"; break;
7096 case 15: str = "Signal not detected"; break;
7097 case 16: str = "PDE Timeout"; break;
7098 case 17: str = "Position pending"; break;
7099 case 18: str = "TDMA MAHO Information Returned"; break;
7100 case 19: str = "TDMA MAHO Information is not available"; break;
7102 if ((value >= 20) && (value <= 223)) { str = "Reserved, treat as Not used"; }
7103 else { str = "Reserved for protocol extension, treat as Not used"; }
7107 proto_tree_add_text(tree, asn1->tvb,
7108 saved_offset, asn1->offset - saved_offset,
7109 "Position Result, %s",
7112 EXTRANEOUS_DATA_CHECK(len, 1);
7116 param_pos_source(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7122 add_string = add_string;
7123 saved_offset = asn1->offset;
7125 asn1_int32_value_decode(asn1, 1, &value);
7129 case 0: str = "Not used"; break;
7130 case 1: str = "Network Unspecified"; break;
7131 case 2: str = "Network AOA (Angle of Arrival)"; break;
7132 case 3: str = "Network TOA (Time of Arrival)"; break;
7133 case 4: str = "Network TDOA (Time Difference of Arrival)"; break;
7134 case 5: str = "Network RF Fingerprinting"; break;
7135 case 6: str = "Network Cell/Sector"; break;
7136 case 7: str = "Network Cell/Sector with Timing"; break;
7137 case 16: str = "Handset Unspecified"; break;
7138 case 17: str = "Handset GPS"; break;
7139 case 18: str = "Handset AGPS (Assisted GPS)"; break;
7140 case 19: str = "Handset EOTD (Enhanced Observed Time Difference)"; break;
7141 case 20: str = "Handset AFLT (Advanced Forward Link Trilateration)"; break;
7142 case 21: str = "Handset EFLT (Enhanced Forward Link Trilateration)"; break;
7144 if ((value >= 8) && (value <= 15)) { str = "Reserved, treat as Network Unspecified"; }
7145 else if ((value >= 22) && (value <= 31)) { str = "Reserved, treat as Handset Unspecified"; }
7146 else { str = "Reserved for protocol extension, treat as Not used"; }
7150 proto_tree_add_text(tree, asn1->tvb,
7151 saved_offset, asn1->offset - saved_offset,
7152 "Position Source, %s",
7155 EXTRANEOUS_DATA_CHECK(len, 1);
7159 param_acg_encounter(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7165 EXACT_DATA_CHECK(len, 1);
7167 add_string = add_string;
7168 saved_offset = asn1->offset;
7170 asn1_int32_value_decode(asn1, 1, &value);
7172 switch ((value & 0xc0) >> 6)
7174 case 0: str = "Not used"; break;
7175 case 1: str = "Service Management System Initiated control encountered"; break;
7176 case 2: str = "SCF Overload control encountered"; break;
7177 case 3: str = "Reserved, treat as Not used"; break;
7180 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
7181 proto_tree_add_text(tree, asn1->tvb,
7182 saved_offset, asn1->offset - saved_offset,
7183 "%s : Control Type, %s",
7187 switch (value & 0x3f)
7189 case 0: str = "PC_SSN"; break;
7190 case 1: str = "1-digit control"; break;
7191 case 2: str = "2-digit control"; break;
7192 case 3: str = "3-digit control"; break;
7193 case 4: str = "4-digit control"; break;
7194 case 5: str = "5-digit control"; break;
7195 case 6: str = "6-digit control"; break;
7196 case 7: str = "7-digit control"; break;
7197 case 8: str = "8-digit control"; break;
7198 case 9: str = "9-digit control"; break;
7199 case 10: str = "10-digit control"; break;
7200 case 11: str = "11-digit control"; break;
7201 case 12: str = "12-digit control"; break;
7202 case 13: str = "13-digit control"; break;
7203 case 14: str = "14-digit control"; break;
7204 case 15: str = "15-digit control"; break;
7206 str = "Reserved, treat as 15-digit control";
7210 other_decode_bitfield_value(bigbuf, value, 0x3f, 8);
7211 proto_tree_add_text(tree, asn1->tvb,
7212 saved_offset, asn1->offset - saved_offset,
7219 param_ctrl_type(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7225 EXACT_DATA_CHECK(len, 1);
7227 add_string = add_string;
7228 saved_offset = asn1->offset;
7230 asn1_int32_value_decode(asn1, 1, &value);
7232 switch ((value & 0xc0) >> 6)
7234 case 0: str = "Not used"; break;
7235 case 1: str = "Service Management System Initiated control"; break;
7236 case 2: str = "SCF Overload control"; break;
7237 case 3: str = "Reserved, treat as Not used"; break;
7240 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
7241 proto_tree_add_text(tree, asn1->tvb,
7242 saved_offset, asn1->offset - saved_offset,
7243 "%s : Control Type, %s",
7247 switch (value & 0x3f)
7249 case 0: str = "PC_SSN"; break;
7250 case 1: str = "1-digit control"; break;
7251 case 2: str = "2-digit control"; break;
7252 case 3: str = "3-digit control"; break;
7253 case 4: str = "4-digit control"; break;
7254 case 5: str = "5-digit control"; break;
7255 case 6: str = "6-digit control"; break;
7256 case 7: str = "7-digit control"; break;
7257 case 8: str = "8-digit control"; break;
7258 case 9: str = "9-digit control"; break;
7259 case 10: str = "10-digit control"; break;
7260 case 11: str = "11-digit control"; break;
7261 case 12: str = "12-digit control"; break;
7262 case 13: str = "13-digit control"; break;
7263 case 14: str = "14-digit control"; break;
7264 case 15: str = "15-digit control"; break;
7266 str = "Reserved, treat as 15-digit control";
7270 other_decode_bitfield_value(bigbuf, value, 0x3f, 8);
7271 proto_tree_add_text(tree, asn1->tvb,
7272 saved_offset, asn1->offset - saved_offset,
7279 param_gap_duration(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7285 EXACT_DATA_CHECK(len, 1);
7287 add_string = add_string;
7288 saved_offset = asn1->offset;
7290 asn1_int32_value_decode(asn1, 1, &value);
7294 case 0: str = "Not used"; break;
7295 case 1: str = "1 second"; break;
7296 case 2: str = "2 seconds"; break;
7297 case 3: str = "4 seconds"; break;
7298 case 4: str = "8 seconds"; break;
7299 case 5: str = "16 seconds"; break;
7300 case 6: str = "32 seconds"; break;
7301 case 7: str = "64 seconds"; break;
7302 case 8: str = "128 seconds"; break;
7303 case 9: str = "256 seconds"; break;
7304 case 10: str = "512 seconds"; break;
7305 case 11: str = "1024 seconds"; break;
7306 case 12: str = "2048 seconds"; break;
7307 case 13: str = "Infinity"; break;
7309 str = "Reserved, treat as Not used";
7313 proto_tree_add_text(tree, asn1->tvb,
7314 saved_offset, asn1->offset - saved_offset,
7319 param_scf_overload_gap_int(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7325 EXACT_DATA_CHECK(len, 1);
7327 add_string = add_string;
7328 saved_offset = asn1->offset;
7330 asn1_int32_value_decode(asn1, 1, &value);
7334 case 0: str = "0 seconds"; break;
7335 case 1: str = "3 seconds"; break;
7336 case 2: str = "4 seconds"; break;
7337 case 3: str = "6 seconds"; break;
7338 case 4: str = "8 seconds"; break;
7339 case 5: str = "11 seconds"; break;
7340 case 6: str = "16 seconds"; break;
7341 case 7: str = "22 seconds"; break;
7342 case 8: str = "30 seconds"; break;
7343 case 9: str = "42 seconds"; break;
7344 case 10: str = "58 seconds"; break;
7345 case 11: str = "81 seconds"; break;
7346 case 12: str = "112 seconds"; break;
7347 case 13: str = "156 seconds"; break;
7348 case 14: str = "217 seconds"; break;
7349 case 15: str = "300 seconds"; break;
7350 case 16: str = "Remove gap control"; break;
7351 case 17: str = "0.10 seconds"; break;
7352 case 18: str = "0.25 seconds"; break;
7353 case 19: str = "0.5 seconds"; break;
7354 case 20: str = "1 second"; break;
7355 case 21: str = "2 seconds"; break;
7357 str = "Reserved, treat as 0 seconds";
7361 proto_tree_add_text(tree, asn1->tvb,
7362 saved_offset, asn1->offset - saved_offset,
7367 param_tdma_time_align(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7372 add_string = add_string;
7373 saved_offset = asn1->offset;
7375 asn1_int32_value_decode(asn1, 1, &value);
7377 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
7378 proto_tree_add_text(tree, asn1->tvb,
7379 saved_offset, asn1->offset - saved_offset,
7384 other_decode_bitfield_value(bigbuf, value, 0x1f, 8);
7385 proto_tree_add_text(tree, asn1->tvb,
7386 saved_offset, asn1->offset - saved_offset,
7387 "%s : Time Alignment Offset (TA), %u",
7391 EXTRANEOUS_DATA_CHECK(len, 1);
7395 dump_rssi(ASN1_SCK *asn1, proto_tree *tree, gchar *leader)
7401 saved_offset = asn1->offset;
7403 asn1_int32_value_decode(asn1, 1, &value);
7405 switch ((value & 0xc0) >> 6)
7407 case 0: str = "800 MHz"; break;
7408 case 1: str = "1900 MHz"; break;
7414 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
7415 proto_tree_add_text(tree, asn1->tvb,
7416 saved_offset, asn1->offset - saved_offset,
7422 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
7423 proto_tree_add_text(tree, asn1->tvb,
7424 saved_offset, asn1->offset - saved_offset,
7428 other_decode_bitfield_value(bigbuf, value, 0x1f, 8);
7429 proto_tree_add_text(tree, asn1->tvb,
7430 saved_offset, asn1->offset - saved_offset,
7438 param_tdma_maho_cell_id(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7440 gint32 value, num_rssi, num_msc;
7441 guint saved_offset, orig_offset;
7444 SHORT_DATA_CHECK(len, 3);
7446 orig_offset = asn1->offset;
7448 dump_rssi(asn1, tree, "Serving Cell ");
7450 saved_offset = asn1->offset;
7452 asn1_int32_value_decode(asn1, 1, &num_rssi);
7454 proto_tree_add_text(tree, asn1->tvb,
7455 saved_offset, asn1->offset - saved_offset,
7456 "Number of RSSI %u",
7459 for (i = 0; i < num_rssi; i++)
7461 if ((len - (asn1->offset - orig_offset)) < 3)
7463 proto_tree_add_text(tree, asn1->tvb,
7464 asn1->offset, len - (asn1->offset - orig_offset),
7467 asn1->offset += len - (asn1->offset - orig_offset);
7471 dump_rssi(asn1, tree, "");
7473 saved_offset = asn1->offset;
7475 asn1_int32_value_decode(asn1, 2, &value);
7477 proto_tree_add_text(tree, asn1->tvb,
7478 saved_offset, asn1->offset - saved_offset,
7479 "Measured Cell ID %u",
7483 saved_offset = asn1->offset;
7485 asn1_int32_value_decode(asn1, 1, &num_msc);
7487 proto_tree_add_text(tree, asn1->tvb,
7488 saved_offset, asn1->offset - saved_offset,
7492 for (i = 0; i < num_msc; i++)
7494 if ((len - (asn1->offset - orig_offset)) < 4)
7496 proto_tree_add_text(tree, asn1->tvb,
7497 asn1->offset, len - (asn1->offset - orig_offset),
7500 asn1->offset += len - (asn1->offset - orig_offset);
7504 param_mscid(asn1, tree, 3, add_string);
7506 saved_offset = asn1->offset;
7508 asn1_int32_value_decode(asn1, 1, &num_rssi);
7510 proto_tree_add_text(tree, asn1->tvb,
7511 saved_offset, asn1->offset - saved_offset,
7512 "Number of RSSI %u",
7515 for (j = 0; j < num_rssi; j++)
7517 if ((len - (asn1->offset - orig_offset)) < 3)
7519 proto_tree_add_text(tree, asn1->tvb,
7520 asn1->offset, len - (asn1->offset - orig_offset),
7523 asn1->offset += len - (asn1->offset - orig_offset);
7527 dump_rssi(asn1, tree, "");
7529 saved_offset = asn1->offset;
7531 asn1_int32_value_decode(asn1, 2, &value);
7533 proto_tree_add_text(tree, asn1->tvb,
7534 saved_offset, asn1->offset - saved_offset,
7535 "Measured Cell ID %u",
7540 EXTRANEOUS_DATA_CHECK((len - (asn1->offset - orig_offset)), 0);
7544 param_tdma_maho_chan(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7546 gint32 value, num_rssi, num_msc;
7547 guint saved_offset, orig_offset;
7550 SHORT_DATA_CHECK(len, 3);
7552 orig_offset = asn1->offset;
7554 dump_rssi(asn1, tree, "Serving Cell ");
7556 saved_offset = asn1->offset;
7558 asn1_int32_value_decode(asn1, 1, &num_rssi);
7560 proto_tree_add_text(tree, asn1->tvb,
7561 saved_offset, asn1->offset - saved_offset,
7562 "Number of RSSI %u",
7565 for (i = 0; i < num_rssi; i++)
7567 if ((len - (asn1->offset - orig_offset)) < 3)
7569 proto_tree_add_text(tree, asn1->tvb,
7570 asn1->offset, len - (asn1->offset - orig_offset),
7573 asn1->offset += len - (asn1->offset - orig_offset);
7577 dump_rssi(asn1, tree, "");
7579 saved_offset = asn1->offset;
7581 asn1_int32_value_decode(asn1, 2, &value);
7583 other_decode_bitfield_value(bigbuf, value >> 8, 0xff, 8);
7584 proto_tree_add_text(tree, asn1->tvb,
7586 "%s : Measured Channel (MSB), %u",
7588 (value & 0xffe0) >> 5);
7590 other_decode_bitfield_value(bigbuf, value & 0xff, 0xe0, 8);
7591 proto_tree_add_text(tree, asn1->tvb,
7593 "%s : Measured Channel (LSB)",
7597 saved_offset = asn1->offset;
7599 asn1_int32_value_decode(asn1, 1, &num_msc);
7601 proto_tree_add_text(tree, asn1->tvb,
7602 saved_offset, asn1->offset - saved_offset,
7606 for (i = 0; i < num_msc; i++)
7608 if ((len - (asn1->offset - orig_offset)) < 4)
7610 proto_tree_add_text(tree, asn1->tvb,
7611 asn1->offset, len - (asn1->offset - orig_offset),
7614 asn1->offset += len - (asn1->offset - orig_offset);
7618 param_mscid(asn1, tree, 3, add_string);
7620 saved_offset = asn1->offset;
7622 asn1_int32_value_decode(asn1, 1, &num_rssi);
7624 proto_tree_add_text(tree, asn1->tvb,
7625 saved_offset, asn1->offset - saved_offset,
7626 "Number of RSSI %u",
7629 for (j = 0; j < num_rssi; j++)
7631 if ((len - (asn1->offset - orig_offset)) < 3)
7633 proto_tree_add_text(tree, asn1->tvb,
7634 asn1->offset, len - (asn1->offset - orig_offset),
7637 asn1->offset += len - (asn1->offset - orig_offset);
7641 dump_rssi(asn1, tree, "");
7643 saved_offset = asn1->offset;
7645 asn1_int32_value_decode(asn1, 2, &value);
7647 other_decode_bitfield_value(bigbuf, value >> 8, 0xff, 8);
7648 proto_tree_add_text(tree, asn1->tvb,
7650 "%s : Measured Channel (MSB), %u",
7652 (value & 0xffe0) >> 5);
7654 other_decode_bitfield_value(bigbuf, value & 0xff, 0xe0, 8);
7655 proto_tree_add_text(tree, asn1->tvb,
7657 "%s : Measured Channel (LSB)",
7662 EXTRANEOUS_DATA_CHECK((len - (asn1->offset - orig_offset)), 0);
7666 param_tdma_maho_req(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7672 EXACT_DATA_CHECK(len, 1);
7674 add_string = add_string;
7675 saved_offset = asn1->offset;
7677 asn1_int32_value_decode(asn1, 1, &value);
7681 case 0: str = "No MAHO information requested"; break;
7682 case 1: str = "MAHO information requested"; break;
7684 str = "Reserved, treat as No MAHO information requested";
7688 proto_tree_add_text(tree, asn1->tvb,
7689 saved_offset, asn1->offset - saved_offset,
7694 param_sm_gap_int(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7700 EXACT_DATA_CHECK(len, 1);
7702 add_string = add_string;
7703 saved_offset = asn1->offset;
7705 asn1_int32_value_decode(asn1, 1, &value);
7709 case 0: str = "Remove gap control"; break;
7710 case 1: str = "0 seconds"; break;
7711 case 2: str = "0.10 seconds"; break;
7712 case 3: str = "0.25 seconds"; break;
7713 case 4: str = "0.50 seconds"; break;
7714 case 5: str = "1 second"; break;
7715 case 6: str = "2 seconds"; break;
7716 case 7: str = "5 seconds"; break;
7717 case 8: str = "10 seconds"; break;
7718 case 9: str = "15 seconds"; break;
7719 case 10: str = "30 seconds"; break;
7720 case 11: str = "60 seconds"; break;
7721 case 12: str = "120 seconds"; break;
7722 case 13: str = "300 seconds"; break;
7723 case 14: str = "600 seconds"; break;
7724 case 15: str = "Stop all queries"; break;
7726 str = "Reserved, treat as Remove gap control";
7730 proto_tree_add_text(tree, asn1->tvb,
7731 saved_offset, asn1->offset - saved_offset,
7736 param_mob_cap(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7739 guint saved_offset, i;
7742 add_string = add_string;
7744 for (i=0; i < len; i++)
7746 saved_offset = asn1->offset;
7748 asn1_int32_value_decode(asn1, 1, &value);
7752 case 0: str = "Undefined Mobile Position Capabilities"; break;
7753 case 1: str = "CDMA None"; break;
7754 case 2: str = "CDMA Pilot Phase + GPS - MS shall be capable of supporting A-FLT and GPS for position determination"; break;
7755 case 3: str = "CDMA Pilot Phase Only - MS shall be capable of supporting A-FLT only for position determination"; break;
7756 case 4: str = "CDMA GPS Only - MS shall be capable of supporting GPS only for position determination"; break;
7757 case 51: str = "TDMA None. See TIA/EIA-136-740"; break;
7758 case 52: str = "TDMA MS-Based with Network Assistance SAMPS Supported. See TIA/EIA-136-740"; break;
7759 case 53: str = "TDMA MS-Assisted SAMPS Supported. See TIA/EIA-136-740"; break;
7760 case 54: str = "TDMA SAMPS Time Measurement Capability Supported. See TIA/EIA-136-740"; break;
7761 case 55: str = "TDMA MS-Based Stand-alone SAMPS Supported. See TIA/EIA-136-740"; break;
7762 case 101: str = "AMPS None"; break;
7763 case 102: str = "AMPS MS-based - MS shall be capable of autonomously determining the position without assistance from the network"; break;
7764 case 103: str = "AMPS assisted GPS - MS shall be capable of utilizing network assistance in providing GPS satellite measurements for position determination in the network or of utilizing network assistance in position determination in the MS"; break;
7766 if ((value >= 5) && (value <= 50)) { str = "Reserved for CDMA, treat as CDMA None"; }
7767 else if ((value >= 56) && (value <= 100)) { str = "Reserved for TDMA, treat as TDMA None"; }
7768 else if ((value >= 104) && (value <= 150)) { str = "Reserved for AMPS, treat as AMPS None"; }
7769 else if ((value >= 151) && (value <= 223)) { str = "Reserved, treat as Undefined"; }
7770 else { str = "Reserved for protocol extension, treat as Undefined"; }
7774 proto_tree_add_text(tree, asn1->tvb,
7775 saved_offset, asn1->offset - saved_offset,
7776 "Mobile Position Capability, %s",
7782 param_cdma_psmm_count(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7787 EXACT_DATA_CHECK(len, 1);
7789 add_string = add_string;
7790 saved_offset = asn1->offset;
7792 asn1_int32_value_decode(asn1, 1, &value);
7794 proto_tree_add_text(tree, asn1->tvb,
7795 saved_offset, asn1->offset - saved_offset,
7796 "Number of CDMA Pilot Strength Measurements to return, %u",
7801 param_cdma_sowd2(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7807 SHORT_DATA_CHECK(len, 5);
7809 add_string = add_string;
7810 saved_offset = asn1->offset;
7812 asn1_int32_value_decode(asn1, 2, &value);
7814 proto_tree_add_text(tree, asn1->tvb,
7815 saved_offset, asn1->offset - saved_offset,
7816 "CDMA Serving One Way Delay, %u",
7819 saved_offset = asn1->offset;
7821 asn1_int32_value_decode(asn1, 1, &value);
7823 other_decode_bitfield_value(bigbuf, value, 0xfc, 8);
7824 proto_tree_add_text(tree, asn1->tvb,
7825 saved_offset, asn1->offset - saved_offset,
7829 switch (value & 0x03)
7831 case 0: str = "100 nsec"; break;
7832 case 1: str = "50 nsec"; break;
7833 case 2: str = "1/16 CDMA PN Chip"; break;
7834 case 3: str = "Reserved"; break;
7837 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
7838 proto_tree_add_text(tree, asn1->tvb,
7839 saved_offset, asn1->offset - saved_offset,
7840 "%s : Resolution, %s",
7844 saved_offset = asn1->offset;
7846 asn1_int32_value_decode(asn1, 2, &value);
7848 proto_tree_add_text(tree, asn1->tvb,
7849 saved_offset, asn1->offset - saved_offset,
7850 "Serving One Way Delay TimeStamp, %u",
7853 EXTRANEOUS_DATA_CHECK(len, 5);
7857 param_sms_charge_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7863 add_string = add_string;
7864 saved_offset = asn1->offset;
7866 asn1_int32_value_decode(asn1, 1, &value);
7870 case 0: str = "Not used"; break;
7871 case 1: str = "No charge"; break;
7872 case 2: str = "Charge original originator"; break;
7873 case 3: str = "Charge original destination"; break;
7879 proto_tree_add_text(tree, asn1->tvb,
7880 saved_offset, asn1->offset - saved_offset,
7885 EXTRANEOUS_DATA_CHECK(len, 1);
7889 param_auth_per(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7895 EXACT_DATA_CHECK(len, 2);
7897 add_string = add_string;
7898 saved_offset = asn1->offset;
7900 asn1_int32_value_decode(asn1, 1, &value);
7904 case 0: str = "Not used"; break;
7905 case 1: str = "Per call"; break;
7906 case 2: str = "Hours"; break;
7907 case 3: str = "Days"; break;
7908 case 4: str = "Weeks"; break;
7909 case 5: str = "Per agreement"; break;
7910 case 6: str = "Indefinite"; break;
7911 case 7: str = "Number of calls"; break;
7913 if ((value >= 8) && (value <= 223)) { str = "Reserved, treat as Per call"; }
7914 else { str = "Reserved for protocol extension, treat as Per call"; }
7918 proto_tree_add_text(tree, asn1->tvb,
7919 saved_offset, asn1->offset - saved_offset,
7924 saved_offset = asn1->offset;
7926 asn1_int32_value_decode(asn1, 1, &value);
7928 proto_tree_add_text(tree, asn1->tvb,
7929 saved_offset, asn1->offset - saved_offset,
7935 param_ctrl_chan_mode(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7941 add_string = add_string;
7942 saved_offset = asn1->offset;
7944 asn1_int32_value_decode(asn1, 1, &value);
7948 case 0: str = "Unknown"; break;
7949 case 1: str = "MS is in Analog CC Mode"; break;
7950 case 2: str = "MS is in Digital CC Mode"; break;
7951 case 3: str = "MS is in NAMPS CC Mode"; break;
7953 if ((value >= 4) && (value <= 223)) { str = "Reserved, treat as Unknown"; }
7954 else { str = "Reserved for protocol extension, treat as Unknown"; }
7958 proto_tree_add_text(tree, asn1->tvb,
7959 saved_offset, asn1->offset - saved_offset,
7962 EXTRANEOUS_DATA_CHECK(len, 1);
7966 param_tdma_data_mode(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
7972 SHORT_DATA_CHECK(len, 2);
7974 add_string = add_string;
7975 saved_offset = asn1->offset;
7977 asn1_int32_value_decode(asn1, 1, &value);
7979 switch ((value & 0xe0) >> 5)
7981 case 0: str = "As per IS-135"; break;
7982 case 1: str = "As per FSVS - 211 (STU-III)"; break;
7988 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
7989 proto_tree_add_text(tree, asn1->tvb,
7990 saved_offset, asn1->offset - saved_offset,
7991 "%s : Data Part, %s",
7995 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
7996 proto_tree_add_text(tree, asn1->tvb,
7997 saved_offset, asn1->offset - saved_offset,
8000 (value & 0x10) ? "unacknowledged data only" : "unacked data or both");
8002 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
8003 proto_tree_add_text(tree, asn1->tvb,
8004 saved_offset, asn1->offset - saved_offset,
8007 (value & 0x08) ? "SAP 0 and 1" : "SAP 0 only");
8009 switch (value & 0x07)
8011 case 0: str = "No Data Privacy"; break;
8012 case 1: str = "Data Privacy Algorithm A"; break;
8014 str = "Reserved, treat as No Data Privacy";
8018 other_decode_bitfield_value(bigbuf, value, 0x07, 8);
8019 proto_tree_add_text(tree, asn1->tvb,
8020 saved_offset, asn1->offset - saved_offset,
8021 "%s : Data Privacy Mode, %s",
8025 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
8026 proto_tree_add_text(tree, asn1->tvb,
8027 saved_offset, asn1->offset - saved_offset,
8031 switch ((value & 0x0c) >> 2)
8033 case 0: str = "RLP1"; break;
8034 case 1: str = "RLP2"; break;
8040 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
8041 proto_tree_add_text(tree, asn1->tvb,
8042 saved_offset, asn1->offset - saved_offset,
8047 switch (value & 0x03)
8049 case 0: str = "16-bit Cyclic Redundancy Check"; break;
8050 case 1: str = "24-bit Cyclic Redundancy Check"; break;
8051 case 2: str = "No Cyclic Redundancy Check"; break;
8057 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
8058 proto_tree_add_text(tree, asn1->tvb,
8059 saved_offset, asn1->offset - saved_offset,
8064 EXTRANEOUS_DATA_CHECK(len, 2);
8068 param_tdma_voice_mode(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8074 add_string = add_string;
8075 saved_offset = asn1->offset;
8077 asn1_int32_value_decode(asn1, 1, &value);
8079 switch ((value & 0xf0) >> 4)
8081 case 0: str = "No Voice Privacy"; break;
8082 case 1: str = "Voice Privacy Algorithm A"; break;
8083 case 2: str = "Reserved, treat as No Voice Privacy"; break;
8084 case 3: str = "Reserved, treat as No Voice Privacy"; break;
8085 case 4: str = "Reserved for SOC/BMSC Specific signaling"; break;
8087 str = "Reserved, treat as No Voice Privacy";
8091 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
8092 proto_tree_add_text(tree, asn1->tvb,
8093 saved_offset, asn1->offset - saved_offset,
8094 "%s : Voice Privacy Mode, %s",
8098 switch (value & 0x0f)
8100 case 0: str = "No Voice Coder"; break;
8101 case 1: str = "VSELP Voice Coder"; break;
8102 case 2: str = "IS-641 Voice Coder"; break;
8103 case 6: str = "Reserved for SOC/BMSC Specific signaling"; break;
8105 str = "Reserved, treat as No Voice Coder";
8109 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
8110 proto_tree_add_text(tree, asn1->tvb,
8111 saved_offset, asn1->offset - saved_offset,
8112 "%s : Voice Coder, %s",
8116 EXTRANEOUS_DATA_CHECK(len, 1);
8120 param_tdma_bandwidth(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8126 add_string = add_string;
8127 saved_offset = asn1->offset;
8129 asn1_int32_value_decode(asn1, 1, &value);
8131 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
8132 proto_tree_add_text(tree, asn1->tvb,
8133 saved_offset, asn1->offset - saved_offset,
8137 switch (value & 0x0f)
8139 case 0: str = "Half-Rate Digital Traffic Channel Only"; break;
8140 case 1: str = "Full-Rate Digital Traffic Channel Only"; break;
8141 case 2: str = "Half-Rate or Full-rate Digital Traffic Channel - Full-Rate Preferred"; break;
8142 case 3: str = "Half-rate or Full-rate Digital Traffic Channel - Half-rate Preferred"; break;
8143 case 4: str = "Double Full-Rate Digital Traffic Channel Only"; break;
8144 case 5: str = "Triple Full-Rate Digital Traffic Channel Only"; break;
8146 str = "Reserved, treat as Full-Rate Digital Traffic Channel Only";
8150 other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
8151 proto_tree_add_text(tree, asn1->tvb,
8152 saved_offset, asn1->offset - saved_offset,
8153 "%s : Bandwidth, %s",
8157 EXTRANEOUS_DATA_CHECK(len, 1);
8161 param_change_srvc_attr(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8167 add_string = add_string;
8168 saved_offset = asn1->offset;
8170 asn1_int32_value_decode(asn1, 1, &value);
8172 other_decode_bitfield_value(bigbuf, value, 0xf0, 8);
8173 proto_tree_add_text(tree, asn1->tvb,
8174 saved_offset, asn1->offset - saved_offset,
8178 switch ((value & 0x0c) >> 2)
8180 case 0: str = "Service Negotiation Used"; break;
8181 case 1: str = "Service Negotiation Not Used"; break;
8182 case 2: str = "Service Negotiation Required"; break;
8183 case 3: str = "Service Negotiation Not Required"; break;
8186 other_decode_bitfield_value(bigbuf, value, 0x0c, 8);
8187 proto_tree_add_text(tree, asn1->tvb,
8188 saved_offset, asn1->offset - saved_offset,
8189 "%s : Service Negotiate Flag (SRVNEG), %s",
8193 switch (value & 0x03)
8195 case 0 : str = "Change Facilities Operation Requested"; break;
8196 case 1 : str = "Change Facilities Operation Not Requested"; break;
8197 case 2 : str = "Change Facilities Operation Used"; break;
8198 case 3 : str = "Change Facilities Operation Not Used"; break;
8201 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
8202 proto_tree_add_text(tree, asn1->tvb,
8203 saved_offset, asn1->offset - saved_offset,
8204 "%s : Change Facilities Flag (CHGFAC), %s",
8208 EXTRANEOUS_DATA_CHECK(len, 1);
8212 param_dp_params(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8218 SHORT_DATA_CHECK(len, 4);
8220 add_string = add_string;
8221 saved_offset = asn1->offset;
8223 asn1_int32_value_decode(asn1, 1, &value);
8225 other_decode_bitfield_value(bigbuf, value, 0xfc, 8);
8226 proto_tree_add_text(tree, asn1->tvb,
8227 saved_offset, asn1->offset - saved_offset,
8231 switch (value & 0x03)
8233 case 0: str = "Privacy inactive or not supported"; break;
8234 case 1: str = "Privacy Requested or Acknowledged"; break;
8236 str = "Reserved, treat as Privacy inactive or not supported";
8240 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
8241 proto_tree_add_text(tree, asn1->tvb,
8242 saved_offset, asn1->offset - saved_offset,
8243 "%s : Privacy Mode, %s",
8247 saved_offset = asn1->offset;
8249 asn1_int32_value_decode(asn1, 1, &value);
8253 case 0: str = "Not used"; break;
8254 case 1: str = "Data Privacy Version 1"; break;
8256 if ((value >= 2) && (value <= 223)) { str = "Reserved, treat as Not used"; }
8257 else { str = "Reserved for protocol extension, treat as Not used"; }
8261 proto_tree_add_text(tree, asn1->tvb,
8262 saved_offset, asn1->offset - saved_offset,
8263 "Data Privacy Version, %s",
8266 saved_offset = asn1->offset;
8268 proto_tree_add_text(tree, asn1->tvb,
8269 saved_offset, len - 2,
8270 "Data Privacy data");
8272 asn1->offset += (len - 2);
8276 param_trn(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8281 add_string = add_string;
8282 saved_offset = asn1->offset;
8284 asn1_string_value_decode(asn1, len, &poctets);
8286 my_dgt_tbcd_unpack(bigbuf, poctets, len, &Dgt_msid);
8289 proto_tree_add_text(tree, asn1->tvb,
8290 saved_offset, len, "TRN %s", bigbuf);
8294 param_islp_info(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8300 add_string = add_string;
8301 saved_offset = asn1->offset;
8303 asn1_int32_value_decode(asn1, 1, &value);
8307 case 0: str = "No ISLP supported"; break;
8308 case 1: str = "ISLP supported (see ISLP)"; break;
8310 if ((value >= 2) && (value <= 112)) { str = "Reserved, treat as No ISLP supported"; }
8311 else if ((value >= 113) && (value <= 223)) { str = "Reserved, treat as ISLP supported"; }
8312 else if ((value >= 224) && (value <= 240)) { str = "Reserved for protocol extension, treat as No ISLP supported"; }
8313 else { str = "Reserved for protocol extension, treat as ISLP supported"; }
8317 proto_tree_add_text(tree, asn1->tvb,
8318 saved_offset, asn1->offset - saved_offset,
8321 EXTRANEOUS_DATA_CHECK(len, 1);
8325 param_ana_red_info(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8331 add_string = add_string;
8332 saved_offset = asn1->offset;
8334 asn1_int32_value_decode(asn1, 1, &value);
8336 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
8337 proto_tree_add_text(tree, asn1->tvb,
8338 saved_offset, asn1->offset - saved_offset,
8342 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
8343 proto_tree_add_text(tree, asn1->tvb,
8344 saved_offset, asn1->offset - saved_offset,
8345 "%s : Ignore CDMA, %s",
8347 (value & 0x20) ? "Ignore the CDMA Capability Message on the analog system to which it is being redirected" :
8348 "Don't ignore the CDMA Capability Message on the analog system to which it is being redirected");
8350 switch (value & 0x1f)
8352 case 0: str = "Attempt to obtain service on either System A or B in accordance with the custom system selection process"; break;
8353 case 1: str = "Attempt to obtain service on System A only"; break;
8354 case 2: str = "Error in IS-735, text was unspecified but not reserved"; break;
8355 case 3: str = "Attempt to obtain service on System A first. If unsuccessful, attempt to obtain service on System B"; break;
8356 case 4: str = "Attempt to obtain service on System B first. If unsuccessful, attempt to obtain service on System A"; break;
8357 case 5: str = "Attempt to obtain service on either System A or System B. If unsuccessful, attempt to obtain service on the alternate system (System A or System B)"; break;
8360 str = "Reserved for protocol extension";
8364 other_decode_bitfield_value(bigbuf, value, 0x1f, 8);
8365 proto_tree_add_text(tree, asn1->tvb,
8366 saved_offset, asn1->offset - saved_offset,
8367 "%s : Sys Ordering, %s",
8371 EXTRANEOUS_DATA_CHECK(len, 1);
8375 param_reason_list(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8382 add_string = add_string;
8383 saved_offset = asn1->offset;
8389 asn1_int32_value_decode(asn1, 1, &value);
8393 case 0: str = "Unknown"; break;
8394 case 1: str = "Unable to configure ISLP"; break;
8395 case 2: str = "ISLP failure"; break;
8396 case 3: str = "Service allowed but facilities not available"; break;
8397 case 4: str = "Service not allowed"; break;
8398 case 5: str = "No Response to TMSI assignment"; break;
8399 case 6: str = "Required parameters unavailable. (e.g., as indicated by the RequiredParametersMask parameter)"; break;
8401 if ((value >= 7) && (value <= 110)) { str = "Reserved for common CDMA and TDMA network error causes. If unknown, treat as Unknown"; }
8402 else if ((value >= 111) && (value <= 127)) { str = "Reserved for common CDMA and TDMA network error causes for protocol extension. If unknown, treat as Unknown"; }
8403 else if ((value >= 128) && (value <= 174)) { str = "CDMA Specific error causes. If unknown, treat as Unknown"; }
8404 else if ((value >= 175) && (value <= 191)) { str = "CDMA Specific error causes for protocol extension. If unknown treat as Unknown"; }
8405 else if ((value >= 192) && (value <= 237)) { str = "TDMA Specific error causes as defined by the TDMACause parameter. If unknown treat as Unknown"; }
8406 else { str = "TDMA Specific error causes for protocol extension. If unknown, treat as Unknown"; }
8410 proto_tree_add_text(tree, asn1->tvb,
8411 saved_offset, asn1->offset - saved_offset,
8416 saved_offset = asn1->offset;
8418 while ((len - i) > 0);
8422 param_imsi(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8427 add_string = add_string;
8428 saved_offset = asn1->offset;
8429 asn1_string_value_decode(asn1, len, &poctets);
8431 my_dgt_tbcd_unpack(bigbuf, poctets, len, &Dgt_msid);
8434 proto_tree_add_text(tree, asn1->tvb,
8439 sprintf(add_string, " - %s", bigbuf);
8443 param_min(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8448 EXACT_DATA_CHECK(len, 5);
8450 add_string = add_string;
8451 saved_offset = asn1->offset;
8452 asn1_string_value_decode(asn1, len, &poctets);
8454 my_dgt_tbcd_unpack(bigbuf, poctets, len, &Dgt_msid);
8457 proto_tree_add_text(tree, asn1->tvb,
8462 sprintf(add_string, " - %s", bigbuf);
8466 param_auth_cap(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8472 EXACT_DATA_CHECK(len, 1);
8474 add_string = add_string;
8475 saved_offset = asn1->offset;
8477 asn1_int32_value_decode(asn1, 1, &value);
8481 case 0: str = "Not used"; break;
8482 case 1: str = "No authentication required"; break;
8483 case 2: str = "Authentication required"; break;
8484 case 128: str = "Authentication required and UIM capable"; break;
8486 if ((value >= 3) && (value <= 95)) { str = "Reserved, treat as No authentication required"; }
8487 else if ((value >= 96) && (value <= 127)) { str = "Reserved for protocol extension, treat as No authentication required"; }
8488 else if ((value >= 129) && (value <= 223)) { str = "Reserved, treat as Authentication required"; }
8489 else { str = "Reserved for protocol extension, treat as Authentication required"; }
8493 proto_tree_add_text(tree, asn1->tvb,
8494 saved_offset, asn1->offset - saved_offset,
8499 param_sus_acc(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8505 EXACT_DATA_CHECK(len, 1);
8507 add_string = add_string;
8508 saved_offset = asn1->offset;
8510 asn1_int32_value_decode(asn1, 1, &value);
8514 case 0: str = "Not used"; break;
8515 case 1: str = "Anomalous digits"; break;
8516 case 2: str = "Unspecified"; break;
8518 if ((value >= 3) && (value <= 113)) { str = "Reserved, treat as Anomalous digits"; }
8519 else if ((value >= 114) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
8520 else { str = "Reserved for protocol extension, treat as Unspecified"; }
8524 proto_tree_add_text(tree, asn1->tvb,
8525 saved_offset, asn1->offset - saved_offset,
8531 param_dis_text(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8536 SHORT_DATA_CHECK(len, 3);
8538 add_string = add_string;
8539 saved_offset = asn1->offset;
8541 asn1_int32_value_decode(asn1, 1, &value);
8543 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
8544 proto_tree_add_text(tree, asn1->tvb,
8545 saved_offset, asn1->offset - saved_offset,
8546 "%s : Spec. has hardcoded 1",
8549 other_decode_bitfield_value(bigbuf, value, 0x7f, 8);
8550 proto_tree_add_text(tree, asn1->tvb,
8551 saved_offset, asn1->offset - saved_offset,
8552 "%s : Display type, see ANSI T1.610 for encoding",
8555 saved_offset = asn1->offset;
8557 proto_tree_add_text(tree, asn1->tvb,
8558 saved_offset, len - 1,
8561 asn1->offset += len - 1;
8565 param_dis_text2(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8568 guint orig_offset, saved_offset;
8571 SHORT_DATA_CHECK(len, 4);
8573 add_string = add_string;
8575 orig_offset = asn1->offset;
8576 saved_offset = asn1->offset;
8580 asn1_int32_value_decode(asn1, 1, &value);
8584 case 0: str = "Not used"; break;
8585 case 1: str = "ASCII"; break;
8586 case 2: str = "ITU T.50. The International Reference Alphabet as defined in ITU-R Rec. T.50"; break;
8587 case 3: str = "User Specific"; break;
8588 case 4: str = "ISO 8859-1. The 8-bit single-byte coded character set Latin 1 as defined in ISO/IEC Standard 8859-1"; break;
8589 case 5: str = "ISO 10646. The Universal Multiple-Octet Coded Character Set (USC) as defined in ISO/IEC Standard 10646"; break;
8590 case 6: str = "ISO 8859-8. The 8-bit single-byte coded character set Hebrew as defined in ISO/IEC Standard 8859-8"; break;
8591 case 7: str = "IS-91 Extended Protocol Message. The length is determined by the Message Type; see TIA/EIA/IS-90"; break;
8592 case 8: str = "Shift-JIS. Variable 1-2 byte nonmodal encoding for Kanji, Kana, and Latin character sets defined in JIS X0201 and JIS X0206"; break;
8593 case 9: str = "KC C 5601. Variable 1-2 byte Korean encoding method"; break;
8595 if ((value >= 10) && (value <= 223)) { str = "Reserved, treat as ASCII"; }
8596 else { str = "Reserved, treat as ASCII"; }
8600 proto_tree_add_text(tree, asn1->tvb,
8601 saved_offset, asn1->offset - saved_offset,
8602 "Display Character Set, %s",
8605 saved_offset = asn1->offset;
8607 asn1_int32_value_decode(asn1, 1, &value);
8609 proto_tree_add_text(tree, asn1->tvb,
8610 saved_offset, asn1->offset - saved_offset,
8611 "Display Type, %u, see ANSI T1.610",
8614 saved_offset = asn1->offset;
8616 asn1_int32_value_decode(asn1, 1, &value);
8618 proto_tree_add_text(tree, asn1->tvb,
8619 saved_offset, asn1->offset - saved_offset,
8623 saved_offset = asn1->offset;
8625 asn1_int32_value_decode(asn1, 1, &value);
8627 proto_tree_add_text(tree, asn1->tvb,
8628 saved_offset, asn1->offset - saved_offset,
8629 "Display Length, %u",
8632 saved_offset = asn1->offset;
8636 if ((guint32) value > (len - (saved_offset - orig_offset)))
8638 proto_tree_add_text(tree, asn1->tvb,
8639 saved_offset, len - (saved_offset - orig_offset),
8642 asn1->offset += len - (saved_offset - orig_offset);
8646 proto_tree_add_text(tree, asn1->tvb,
8647 saved_offset, value,
8650 asn1->offset += value;
8652 saved_offset = asn1->offset;
8655 while ((len - (saved_offset - orig_offset)) >= 4);
8657 EXTRANEOUS_DATA_CHECK((len - (saved_offset - orig_offset)), 0);
8661 param_dmh_srvc_id(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8664 guint orig_offset, saved_offset;
8666 SHORT_DATA_CHECK(len, 5);
8668 add_string = add_string;
8670 orig_offset = asn1->offset;
8671 saved_offset = asn1->offset;
8675 asn1_int32_value_decode(asn1, 2, &value);
8677 proto_tree_add_text(tree, asn1->tvb,
8678 saved_offset, asn1->offset - saved_offset,
8682 saved_offset = asn1->offset;
8684 asn1_int32_value_decode(asn1, 1, &value);
8686 proto_tree_add_text(tree, asn1->tvb,
8687 saved_offset, asn1->offset - saved_offset,
8688 "Market Segment ID %u",
8691 saved_offset = asn1->offset;
8693 asn1_int32_value_decode(asn1, 2, &value);
8695 proto_tree_add_text(tree, asn1->tvb,
8696 saved_offset, asn1->offset - saved_offset,
8697 "DMH Service ID Value %u",
8700 saved_offset = asn1->offset;
8702 while ((len - (saved_offset - orig_offset)) >= 5);
8704 EXTRANEOUS_DATA_CHECK((len - (saved_offset - orig_offset)), 0);
8708 param_feat_ind(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8711 guint orig_offset, saved_offset;
8713 SHORT_DATA_CHECK(len, 5);
8715 add_string = add_string;
8717 orig_offset = asn1->offset;
8718 saved_offset = asn1->offset;
8722 asn1_int32_value_decode(asn1, 2, &value);
8724 proto_tree_add_text(tree, asn1->tvb,
8725 saved_offset, asn1->offset - saved_offset,
8729 saved_offset = asn1->offset;
8731 asn1_int32_value_decode(asn1, 1, &value);
8733 proto_tree_add_text(tree, asn1->tvb,
8734 saved_offset, asn1->offset - saved_offset,
8735 "Market Segment ID %u",
8738 saved_offset = asn1->offset;
8740 asn1_int32_value_decode(asn1, 2, &value);
8742 proto_tree_add_text(tree, asn1->tvb,
8743 saved_offset, asn1->offset - saved_offset,
8744 "DMH Service ID Value %u",
8747 saved_offset = asn1->offset;
8749 while ((len - (saved_offset - orig_offset)) >= 5);
8751 EXTRANEOUS_DATA_CHECK((len - (saved_offset - orig_offset)), 0);
8755 param_a_key_ver(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8762 add_string = add_string;
8763 saved_offset = asn1->offset;
8769 asn1_int32_value_decode(asn1, 1, &value);
8773 case 0: str = "Not used"; break;
8774 case 1: str = "A-key Generation not supported"; break;
8775 case 2: str = "Diffie Hellman with 768-bit modulus, 160-bit primitive, and 160-bit exponents"; break;
8776 case 3: str = "Diffie Hellman with 512-bit modulus, 160-bit primitive, and 160-bit exponents"; break;
8777 case 4: str = "Diffie Hellman with 768-bit modulus, 32-bit primitive, and 160-bit exponents"; break;
8779 if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as A-key Generation not supported"; }
8780 else { str = "Reserved for protocol extension, treat as A-key Generation not supported"; }
8784 proto_tree_add_text(tree, asn1->tvb,
8785 saved_offset, asn1->offset - saved_offset,
8790 saved_offset = asn1->offset;
8792 while ((len - i) > 0);
8796 param_inter_msg_time(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8801 EXACT_DATA_CHECK(len, 1);
8803 add_string = add_string;
8804 saved_offset = asn1->offset;
8806 asn1_int32_value_decode(asn1, 1, &value);
8808 proto_tree_add_text(tree, asn1->tvb,
8809 saved_offset, asn1->offset - saved_offset,
8810 "Timer Value, %u, %u seconds",
8814 /* XXX * 10 or / 10 ? */
8818 param_rel_cause(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8824 EXACT_DATA_CHECK(len, 1);
8826 add_string = add_string;
8827 saved_offset = asn1->offset;
8829 asn1_int32_value_decode(asn1, 1, &value);
8833 case 0: str = "Unspecified"; break;
8834 case 1: str = "Calling Party"; break;
8835 case 2: str = "Called Party"; break;
8836 case 3: str = "Commanded Disconnect"; break;
8838 if ((value >= 4) && (value <= 23)) { str = "Reserved, treat as Calling Party"; }
8839 else if ((value >= 24) && (value <= 31)) { str = "Reserved for protocol extension. If unknown, treat as Calling Party"; }
8840 else if ((value >= 32) && (value <= 55)) { str = "Reserved, treat as Called Party"; }
8841 else if ((value >= 56) && (value <= 63)) { str = "Reserved for protocol extension. If unknown, treat as Called Party"; }
8842 else if ((value >= 64) && (value <= 87)) { str = "Reserved, treat as Commanded Disconnect"; }
8843 else if ((value >= 88) && (value <= 95)) { str = "Reserved for protocol extension. If unknown, treat as Commanded Disconnect"; }
8844 else if ((value >= 96) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
8845 else { str = "Reserved for protocol extension. If unknown, treat as Unspecified"; }
8849 proto_tree_add_text(tree, asn1->tvb,
8850 saved_offset, asn1->offset - saved_offset,
8855 param_time_day(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8861 EXACT_DATA_CHECK(len, 3);
8863 add_string = add_string;
8864 saved_offset = asn1->offset;
8866 asn1_int32_value_decode(asn1, 3, &value);
8868 h = value / (3600 * 10);
8869 m = (value - (h * (3600 * 10))) / (60 * 10);
8870 s = (value - (h * (3600 * 10)) - (m * (60 * 10))) / 10;
8871 ts = (value - (h * (3600 * 10)) - (m * (60 * 10)) - (s * 10));
8873 proto_tree_add_text(tree, asn1->tvb,
8874 saved_offset, asn1->offset - saved_offset,
8875 "(UTC) (in tenths of seconds - 1), %u (%u:%u:%u.%u)",
8884 param_call_status(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8890 add_string = add_string;
8894 proto_tree_add_text(tree, asn1->tvb,
8895 asn1->offset, len, "Long Data (?)");
8896 asn1->offset += len;
8900 saved_offset = asn1->offset;
8902 asn1->offset = saved_offset;
8904 asn1_int32_value_decode(asn1, len, &value);
8908 case 0: str = "Not used"; break;
8909 case 1: str = "Call Setup in Progress"; break;
8910 case 2: str = "Locally Allowed Call - No Action"; break;
8912 if (value < 0) { str = "Reserved for bilateral agreements. If unknown, treat as Not used"; }
8913 else { str = "Reserved, treat as Not used"; }
8917 proto_tree_add_text(tree, asn1->tvb,
8923 param_ms_status(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
8931 add_string = add_string;
8932 saved_offset = asn1->offset;
8934 asn1_int32_value_decode(asn1, 1, &value);
8936 extended = (value & 0x80) >> 7;
8938 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
8939 proto_tree_add_text(tree, asn1->tvb,
8940 saved_offset, asn1->offset - saved_offset,
8941 "%s : Extension (EXT), %s",
8943 extended ? "No Extension, last octet of sequence" : "Extension indicator, the octet continues through the next octet");
8945 other_decode_bitfield_value(bigbuf, value, 0x60, 8);
8946 proto_tree_add_text(tree, asn1->tvb,
8947 saved_offset, asn1->offset - saved_offset,
8951 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
8952 proto_tree_add_text(tree, asn1->tvb,
8953 saved_offset, asn1->offset - saved_offset,
8954 "%s : Location Information (LOC), %s",
8956 (value & 0x10) ? "MS location information available" : "No MS location information available");
8958 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
8959 proto_tree_add_text(tree, asn1->tvb,
8960 saved_offset, asn1->offset - saved_offset,
8963 (value & 0x08) ? "Radio Contact Established" : "No Radio Contact");
8965 has_chan = (value & 0x04) >> 2;
8967 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
8968 proto_tree_add_text(tree, asn1->tvb,
8969 saved_offset, asn1->offset - saved_offset,
8972 has_chan ? "Traffic Channel Assigned" : "No Traffic Channel");
8974 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
8975 proto_tree_add_text(tree, asn1->tvb,
8976 saved_offset, asn1->offset - saved_offset,
8979 (value & 0x02) ? "Intersystem Handoff" : "No Intersystem Handoff");
8981 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
8982 proto_tree_add_text(tree, asn1->tvb,
8983 saved_offset, asn1->offset - saved_offset,
8984 "%s : Inactive, %s",
8986 (value & 0x01) ? "MS Inactive" : "MS Active");
8988 if (len == 1) return;
8990 saved_offset = asn1->offset;
8992 asn1_int32_value_decode(asn1, 1, &value);
8996 proto_tree_add_text(tree, asn1->tvb,
8997 saved_offset, asn1->offset - saved_offset,
8998 "Octet 1a ? spec. does not provide details");
9000 saved_offset = asn1->offset;
9002 EXTRANEOUS_DATA_CHECK(len, 2);
9011 case 0: str = "Not used "; break;
9012 case 1: str = "Analog. The MS is currently assigned to an analog traffic channel"; break;
9013 case 2: str = "NAMPS. The MS is currently assigned to an NAMPS traffic channel"; break;
9014 case 3: str = "TDMA. The MS is currently assigned to a TDMA traffic channel"; break;
9015 case 4: str = "CDMA. The MS is currently assigned to a CDMA traffic channel"; break;
9017 if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Not used"; }
9018 else { str = "Reserved for protocol extension, treat as Not used"; }
9022 proto_tree_add_text(tree, asn1->tvb,
9023 saved_offset, asn1->offset - saved_offset,
9024 "Radio Channel Type, %s",
9027 saved_offset = asn1->offset;
9029 EXTRANEOUS_DATA_CHECK(len, 2);
9036 EXTRANEOUS_DATA_CHECK(len, 1);
9040 param_pos_info_code(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9045 add_string = add_string;
9046 saved_offset = asn1->offset;
9048 asn1_int32_value_decode(asn1, 1, &value);
9050 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
9051 proto_tree_add_text(tree, asn1->tvb,
9052 saved_offset, asn1->offset - saved_offset,
9056 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
9057 proto_tree_add_text(tree, asn1->tvb,
9058 saved_offset, asn1->offset - saved_offset,
9059 "%s : MS Identity (MSID), %s",
9061 (value & 0x10) ? "MS Identity Requested" : "No MS Identity Requested");
9063 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
9064 proto_tree_add_text(tree, asn1->tvb,
9065 saved_offset, asn1->offset - saved_offset,
9066 "%s : Routing Address (ROUTE), %s",
9068 (value & 0x08) ? "Routing Address Requested" : "No Routing Address Requested");
9070 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
9071 proto_tree_add_text(tree, asn1->tvb,
9072 saved_offset, asn1->offset - saved_offset,
9073 "%s : Serving Cell ID (CELLID), %s",
9075 (value & 0x04) ? "Serving Cell ID Requested" : "No Serving Cell ID Requested");
9077 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
9078 proto_tree_add_text(tree, asn1->tvb,
9079 saved_offset, asn1->offset - saved_offset,
9080 "%s : Location Area ID (LOCID), %s",
9082 (value & 0x02) ? "Location Area ID Requested" : "No Location Area ID Requested");
9084 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
9085 proto_tree_add_text(tree, asn1->tvb,
9086 saved_offset, asn1->offset - saved_offset,
9089 (value & 0x01) ? "Provide the current MS location" : "Provide the last known MS location information, if known");
9091 EXTRANEOUS_DATA_CHECK(len, 1);
9095 param_rel_reason(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9101 EXACT_DATA_CHECK(len, 1);
9103 add_string = add_string;
9104 saved_offset = asn1->offset;
9106 asn1_int32_value_decode(asn1, 1, &value);
9110 case 0: str = "Unspecified"; break;
9111 case 1: str = "Call Over Clear Forward"; break;
9112 case 2: str = "Call Over Clear Backward"; break;
9113 case 3: str = "Handoff Successful"; break;
9114 case 4: str = "Handoff Abort - call over"; break;
9115 case 5: str = "Handoff Abort - not received"; break;
9116 case 6: str = "Abnormal mobile termination"; break;
9117 case 7: str = "Abnormal switch termination"; break;
9118 case 8: str = "Special feature release"; break;
9119 case 9: str = "Session Over Clear Forward"; break;
9120 case 10: str = "Session Over Clear Backward"; break;
9121 case 11: str = "Clear All Services Forward"; break;
9122 case 12: str = "Clear All Services Backward"; break;
9123 case 13: str = "Anchor MSC was removed from the packet data session"; break;
9125 if ((value >= 14) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
9126 else { str = "Reserved for protocol extension, treat as Unspecified"; }
9130 proto_tree_add_text(tree, asn1->tvb,
9131 saved_offset, asn1->offset - saved_offset,
9137 param_ho_reason(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9143 EXACT_DATA_CHECK(len, 1);
9145 add_string = add_string;
9146 saved_offset = asn1->offset;
9148 asn1_int32_value_decode(asn1, 1, &value);
9152 case 0: str = "Not used"; break;
9153 case 1: str = "Unspecified"; break;
9154 case 2: str = "Weak signal"; break;
9155 case 3: str = "Off-loading"; break;
9156 case 4: str = "Anticipatory"; break;
9158 if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
9159 else { str = "Reserved for protocol extension, treat as Unspecified"; }
9163 proto_tree_add_text(tree, asn1->tvb,
9164 saved_offset, asn1->offset - saved_offset,
9169 param_red_reason(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9175 EXACT_DATA_CHECK(len, 1);
9177 add_string = add_string;
9178 saved_offset = asn1->offset;
9180 asn1_int32_value_decode(asn1, 1, &value);
9184 case 0: str = "Not used"; break;
9185 case 1: str = "Busy"; break;
9186 case 2: str = "No answer"; break;
9187 case 3: str = "Unconditional"; break;
9188 case 4: str = "No page response"; break;
9189 case 5: str = "Unavailable"; break;
9190 case 6: str = "Unroutable"; break;
9191 case 7: str = "Call accepted"; break;
9192 case 8: str = "Call refused"; break;
9193 case 9: str = "USCFvm, divert to voice mail"; break;
9194 case 10: str = "USCFms, divert to an MS provided DN"; break;
9195 case 11: str = "USCFnr, divert to a network registered DN"; break;
9197 if ((value >= 12) && (value <= 223)) { str = "Reserved, treat as No answer"; }
9198 else { str = "Reserved for protocol extension, treat as No answer"; }
9202 proto_tree_add_text(tree, asn1->tvb,
9203 saved_offset, asn1->offset - saved_offset,
9208 param_confid_mode(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9213 EXACT_DATA_CHECK(len, 1);
9215 add_string = add_string;
9216 saved_offset = asn1->offset;
9218 asn1_int32_value_decode(asn1, 1, &value);
9220 other_decode_bitfield_value(bigbuf, value, 0xf8, 8);
9221 proto_tree_add_text(tree, asn1->tvb,
9222 saved_offset, asn1->offset - saved_offset,
9226 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
9227 proto_tree_add_text(tree, asn1->tvb,
9228 saved_offset, asn1->offset - saved_offset,
9229 "%s : Data Privacy (DP), %s",
9231 (value & 0x04) ? "ON" : "OFF");
9233 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
9234 proto_tree_add_text(tree, asn1->tvb,
9235 saved_offset, asn1->offset - saved_offset,
9236 "%s : Signaling Message Encryption (SE), %s",
9238 (value & 0x02) ? "ON" : "OFF");
9240 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
9241 proto_tree_add_text(tree, asn1->tvb,
9242 saved_offset, asn1->offset - saved_offset,
9243 "%s : Voice Privacy (VP), %s",
9245 (value & 0x01) ? "ON" : "OFF");
9249 param_sys_acc_type(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9255 EXACT_DATA_CHECK(len, 1);
9257 add_string = add_string;
9258 saved_offset = asn1->offset;
9260 asn1_int32_value_decode(asn1, 1, &value);
9264 case 0: str = "Not used"; break;
9265 case 1: str = "Unspecified"; break;
9266 case 2: str = "Flash request"; break;
9267 case 3: str = "Autonomous registration"; break;
9268 case 4: str = "Call origination"; break;
9269 case 5: str = "Page response"; break;
9270 case 6: str = "No access"; break;
9271 case 7: str = "Power down registration"; break;
9272 case 8: str = "SMS page response"; break;
9273 case 9: str = "OTASP"; break;
9275 if ((value >= 10) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
9276 else { str = "Reserved for protocol extension, treat as Unspecified"; }
9280 proto_tree_add_text(tree, asn1->tvb,
9281 saved_offset, asn1->offset - saved_offset,
9286 param_scm(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9288 gint32 value, temp_int;
9292 EXACT_DATA_CHECK(len, 1);
9294 add_string = add_string;
9295 saved_offset = asn1->offset;
9297 asn1_int32_value_decode(asn1, 1, &value);
9299 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
9300 proto_tree_add_text(tree, asn1->tvb,
9301 saved_offset, asn1->offset - saved_offset,
9305 temp_int = ((value & 0x10) >> 2) | (value & 0x03);
9308 case 0: str = "Class I"; break;
9309 case 1: str = "Class II"; break;
9310 case 2: str = "Class III"; break;
9311 case 3: str = "Class IV"; break;
9312 case 4: str = "Class V"; break;
9313 case 5: str = "Class VI"; break;
9314 case 6: str = "Class VII"; break;
9315 case 7: str = "Class VIII"; break;
9318 other_decode_bitfield_value(bigbuf, value, 0x13, 8);
9319 proto_tree_add_text(tree, asn1->tvb,
9320 saved_offset, asn1->offset - saved_offset,
9325 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
9326 proto_tree_add_text(tree, asn1->tvb,
9327 saved_offset, asn1->offset - saved_offset,
9328 "%s : Bandwidth %s",
9330 (value & 0x08) ? "25 MHz" : "20 MHz");
9332 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
9333 proto_tree_add_text(tree, asn1->tvb,
9334 saved_offset, asn1->offset - saved_offset,
9335 "%s : Transmission, %s",
9337 (value & 0x04) ? "Discontinuous" : "Continuous");
9341 param_deny_acc(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9347 EXACT_DATA_CHECK(len, 1);
9349 add_string = add_string;
9350 saved_offset = asn1->offset;
9352 asn1_int32_value_decode(asn1, 1, &value);
9356 case 0: str = "Not used"; break;
9357 case 1: str = "Unspecified"; break;
9358 case 2: str = "SSD Update failure"; break;
9359 case 3: str = "COUNT Update failure"; break;
9360 case 4: str = "Unique Challenge failure"; break;
9361 case 5: str = "AUTHR mismatch"; break;
9362 case 6: str = "COUNT mismatch"; break;
9363 case 7: str = "Process collision"; break;
9364 case 8: str = "Missing authentication parameters"; break;
9365 case 9: str = "TerminalType mismatch"; break;
9366 case 10: str = "MIN, IMSI or ESN authorization failure"; break;
9368 if ((value >= 11) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
9369 else { str = "Reserved for protocol extension, treat as Unspecified"; }
9373 proto_tree_add_text(tree, asn1->tvb,
9374 saved_offset, asn1->offset - saved_offset,
9379 param_cdma_sig_qual(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9384 EXACT_DATA_CHECK(len, 1);
9386 add_string = add_string;
9387 saved_offset = asn1->offset;
9389 asn1_int32_value_decode(asn1, 1, &value);
9391 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
9392 proto_tree_add_text(tree, asn1->tvb,
9393 saved_offset, asn1->offset - saved_offset,
9397 other_decode_bitfield_value(bigbuf, value, 0x3f, 8);
9398 proto_tree_add_text(tree, asn1->tvb,
9399 saved_offset, asn1->offset - saved_offset,
9406 param_rec_sig_qual(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9412 EXACT_DATA_CHECK(len, 1);
9414 add_string = add_string;
9415 saved_offset = asn1->offset;
9417 asn1_int32_value_decode(asn1, 1, &value);
9421 case 0: str = "Not a usable signal"; break;
9422 case 255: str = "Interference"; break;
9424 if ((value >= 1) && (value <= 8)) { str = "Reserved, treat as Not a usable signal"; }
9425 else if ((value >= 9) && (value <= 245)) { str = "Usable signal range"; }
9426 else if ((value >= 246) && (value <= 254)) { str = "Reserved, treat as Interference"; }
9430 proto_tree_add_text(tree, asn1->tvb,
9431 saved_offset, asn1->offset - saved_offset,
9436 param_sig_qual(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9442 EXACT_DATA_CHECK(len, 1);
9444 add_string = add_string;
9445 saved_offset = asn1->offset;
9447 asn1_int32_value_decode(asn1, 1, &value);
9451 case 0: str = "Not a usable signal"; break;
9452 case 255: str = "Interference"; break;
9454 if ((value >= 1) && (value <= 8)) { str = "Reserved, treat as Not a usable signal"; }
9455 else if ((value >= 9) && (value <= 245)) { str = "Usable signal range"; }
9456 else if ((value >= 246) && (value <= 254)) { str = "Reserved, treat as Interference"; }
9460 proto_tree_add_text(tree, asn1->tvb,
9461 saved_offset, asn1->offset - saved_offset,
9466 param_ssd_no_share(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9472 EXACT_DATA_CHECK(len, 1);
9474 add_string = add_string;
9475 saved_offset = asn1->offset;
9477 asn1_int32_value_decode(asn1, 1, &value);
9481 case 0: str = "Not used"; break;
9482 case 1: str = "Discard SSD"; break;
9484 str = "Reserved, treat as Discard SSD";
9488 proto_tree_add_text(tree, asn1->tvb,
9489 saved_offset, asn1->offset - saved_offset,
9494 param_report_type(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9500 EXACT_DATA_CHECK(len, 1);
9502 add_string = add_string;
9503 saved_offset = asn1->offset;
9505 asn1_int32_value_decode(asn1, 1, &value);
9509 case 0: str = "Not used"; break;
9510 case 1: str = "Unspecified security violation"; break;
9511 case 2: str = "MSID/ESN mismatch"; break;
9512 case 3: str = "RANDC mismatch"; break;
9513 case 4: str = "Reserved (see TSB51)"; break;
9514 case 5: str = "SSD Update failed"; break;
9515 case 6: str = "Reserved (see TSB51)"; break;
9516 case 7: str = "COUNT mismatch"; break;
9517 case 8: str = "Reserved (see TSB51)"; break;
9518 case 9: str = "Unique Challenge failed"; break;
9519 case 10: str = "Unsolicited Base Station Challenge"; break;
9520 case 11: str = "SSD Update no response"; break;
9521 case 12: str = "COUNT Update no response"; break;
9522 case 13: str = "Unique Challenge no response"; break;
9523 case 14: str = "AUTHR mismatch"; break;
9524 case 15: str = "TERMTYP mismatch"; break;
9525 case 16: str = "Missing authentication parameters"; break;
9527 if ((value >= 17) && (value <= 223)) { str = "Reserved, treat as Unspecified security violation"; }
9528 else { str = "Reserved for protocol extension, treat as Unspecified security violation"; }
9532 proto_tree_add_text(tree, asn1->tvb,
9533 saved_offset, asn1->offset - saved_offset,
9538 param_term_type(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9544 EXACT_DATA_CHECK(len, 1);
9546 add_string = add_string;
9547 saved_offset = asn1->offset;
9549 asn1_int32_value_decode(asn1, 1, &value);
9553 case 0: str = "Not used"; break;
9554 case 1: str = "Not distinguished, EIA/TIA-553, IS-54-A, IS-88, IS-91, IS-94"; break;
9555 case 2: str = "IS-54-B"; break;
9556 case 3: str = "IS-136"; break;
9557 case 4: str = "J-STD-011 (rescinded 11/23/99)"; break;
9558 case 5: str = "IS-136-A or TIA/EIA-136 Revision-0"; break;
9559 case 6: str = "TIA/EIA-136-A"; break;
9560 case 7: str = "TIA/EIA-136-B"; break;
9561 case 32: str = "IS-95"; break;
9562 case 33: str = "IS-95-A"; break;
9563 case 34: str = "J-STD-008"; break;
9564 case 35: str = "IS-95-B"; break;
9565 case 36: str = "IS-2000"; break;
9566 case 64: str = "IS-88"; break;
9567 case 65: str = "IS-94"; break;
9568 case 66: str = "IS-91"; break;
9569 case 67: str = "J-STD-014"; break;
9570 case 68: str = "TIA/EIA-553-A"; break;
9571 case 69: str = "IS-91-A"; break;
9573 if ((value >= 8) && (value <= 31)) { str = "Reserved, treat as IS-54-B"; }
9574 else if ((value >= 37) && (value <= 63)) { str = "Reserved, treat as IS-95-A"; }
9575 else if ((value >= 70) && (value <= 223)) { str = "Reserved, treat as Not distinguished"; }
9576 else { str = "Reserved for protocol extension, treat as Not distinguished"; }
9580 proto_tree_add_text(tree, asn1->tvb,
9581 saved_offset, asn1->offset - saved_offset,
9586 param_term_res(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9592 EXACT_DATA_CHECK(len, 1);
9594 add_string = add_string;
9595 saved_offset = asn1->offset;
9597 asn1_int32_value_decode(asn1, 1, &value);
9601 case 0: str = "Not used"; break;
9602 case 1: str = "Termination denied"; break;
9603 case 2: str = "Unrestricted"; break;
9604 case 3: str = "Treatment for this value is not specified"; break;
9606 if ((value >= 4) && (value <= 223)) { str = "Reserved, treat as Unrestricted"; }
9607 else { str = "Reserved for protocol extension, treat as Unrestricted"; }
9611 proto_tree_add_text(tree, asn1->tvb,
9612 saved_offset, asn1->offset - saved_offset,
9617 param_dereg(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9623 EXACT_DATA_CHECK(len, 1);
9625 add_string = add_string;
9626 saved_offset = asn1->offset;
9628 asn1_int32_value_decode(asn1, 1, &value);
9632 case 0: str = "Not used"; break;
9633 case 1: str = "Deregister for an unspecified reason"; break;
9634 case 2: str = "Deregister for an adminstrative reason"; break;
9635 case 3: str = "Deregister due to MS power down"; break;
9637 if ((value >= 4) && (value <= 223)) { str = "Reserved, treat as Deregister for an unspecified reason"; }
9638 else { str = "Reserved for protocol extension, treat as Deregister for an unspecified reason"; }
9642 proto_tree_add_text(tree, asn1->tvb,
9643 saved_offset, asn1->offset - saved_offset,
9648 param_group_info(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9653 SHORT_DATA_CHECK(len, 4);
9655 add_string = add_string;
9656 saved_offset = asn1->offset;
9658 asn1_int32_value_decode(asn1, 4, &value);
9660 proto_tree_add_text(tree, asn1->tvb,
9661 saved_offset, asn1->offset - saved_offset,
9665 EXTRANEOUS_DATA_CHECK(len, 4);
9669 param_auth_den(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9675 EXACT_DATA_CHECK(len, 1);
9677 add_string = add_string;
9678 saved_offset = asn1->offset;
9680 asn1_int32_value_decode(asn1, 1, &value);
9684 case 0: str = "Not used"; break;
9685 case 1: str = "Delinquent account"; break;
9686 case 2: str = "Invalid serial number"; break;
9687 case 3: str = "Stolen unit"; break;
9688 case 4: str = "Duplicate unit"; break;
9689 case 5: str = "Unassigned directory number"; break;
9690 case 6: str = "Unspecified"; break;
9691 case 7: str = "Multiple access"; break;
9692 case 8: str = "Not Authorized for the MSC"; break;
9693 case 9: str = "Missing authentication parameters"; break;
9694 case 10: str = "Terminal Type mismatch"; break;
9696 if ((value >= 11) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
9697 else { str = "Reserved for protocol extension, treat as Unspecified"; }
9701 proto_tree_add_text(tree, asn1->tvb,
9702 saved_offset, asn1->offset - saved_offset,
9709 find_trig_type(gint32 value)
9715 case 0: str = "Unspecified"; break;
9716 case 1: str = "All Calls"; break;
9717 case 2: str = "Double Introducing Star"; break;
9718 case 3: str = "Single Introducing Star"; break;
9719 case 4: str = "Reserved [for Home System Feature Code"; break;
9720 case 5: str = "Double Introducing Pound"; break;
9721 case 6: str = "Single Introducing Pound"; break;
9722 case 7: str = "Revertive Call"; break;
9723 case 8: str = "0 Digit"; break;
9724 case 9: str = "1 Digit"; break;
9725 case 10: str = "2 Digit"; break;
9726 case 11: str = "3 Digit"; break;
9727 case 12: str = "4 Digit"; break;
9728 case 13: str = "5 Digit"; break;
9729 case 14: str = "6 Digit"; break;
9730 case 15: str = "7 Digit"; break;
9731 case 16: str = "8 Digit"; break;
9732 case 17: str = "9 Digit"; break;
9733 case 18: str = "10 Digit"; break;
9734 case 19: str = "11 Digit"; break;
9735 case 20: str = "12 Digit"; break;
9736 case 21: str = "13 Digit"; break;
9737 case 22: str = "14 Digit"; break;
9738 case 23: str = "15 Digit"; break;
9739 case 24: str = "Local Call"; break;
9740 case 25: str = "Intra-LATA Toll Call"; break;
9741 case 26: str = "Inter-LATA Toll Call"; break;
9742 case 27: str = "World Zone Call"; break;
9743 case 28: str = "International Call"; break;
9744 case 29: str = "Unrecognized Number"; break;
9745 case 30: str = "Prior Agreement"; break;
9746 case 31: str = "Specific Called Party Digit String"; break;
9747 case 32: str = "Mobile Termination"; break;
9748 case 33: str = "Advanced Termination"; break;
9749 case 34: str = "Location"; break;
9750 case 35: str = "Locally Allowed Specific Digit String"; break;
9751 case 36: str = "Origination Attempt Authorized"; break;
9752 case 37: str = "Calling Routing Address Available"; break;
9753 case 38: str = "Initial Termination"; break;
9754 case 39: str = "Called Routing Address Available"; break;
9755 case 40: str = "O Answer"; break;
9756 case 41: str = "O Disconnect"; break;
9757 case 42: str = "O Called Party Busy"; break;
9758 case 43: str = "O No Answer"; break;
9759 case 64: str = "Terminating Resource Available"; break;
9760 case 65: str = "T Busy"; break;
9761 case 66: str = "T No Answer"; break;
9762 case 67: str = "T No Page Response"; break;
9763 case 68: str = "T Unroutable"; break;
9764 case 69: str = "T Answer"; break;
9765 case 70: str = "T Disconnect"; break;
9766 case 220: str = "Reserved for TDP-R DP Type value"; break;
9767 case 221: str = "Reserved for TDP-N DP Type value"; break;
9768 case 222: str = "Reserved for EDP-R DP Type value"; break;
9769 case 223: str = "Reserved for EDP-N DP Type value"; break;
9771 if ((value >= 44) && (value <= 63)) { str = "Reserved, treat as Unspecified"; }
9772 else if ((value >= 71) && (value <= 219)) { str = "Reserved, treat as Unspecified"; }
9773 else { str = "Reserved for protocol extension, treat as Unspecified"; }
9781 param_trig_type(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9786 EXACT_DATA_CHECK(len, 1);
9788 add_string = add_string;
9789 saved_offset = asn1->offset;
9791 asn1_int32_value_decode(asn1, 1, &value);
9793 proto_tree_add_text(tree, asn1->tvb,
9794 saved_offset, asn1->offset - saved_offset,
9797 find_trig_type(value));
9801 param_win_op_cap(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9807 add_string = add_string;
9808 saved_offset = asn1->offset;
9810 asn1_int32_value_decode(asn1, 1, &value);
9812 other_decode_bitfield_value(bigbuf, value, 0xf8, 8);
9813 proto_tree_add_text(tree, asn1->tvb,
9814 saved_offset, asn1->offset - saved_offset,
9818 switch ((value & 0x04) >> 2)
9820 case 0x00: str = "Sender does not support PositionRequest OP"; break;
9822 str = "Sender supports PositionRequest OP";
9826 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
9827 proto_tree_add_text(tree, asn1->tvb,
9828 saved_offset, asn1->offset - saved_offset,
9832 switch ((value & 0x02) >> 1)
9834 case 0x00: str = "Sender does not support CallControlDirective OP"; break;
9836 str = "Sender supports CallControlDirective OP";
9840 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
9841 proto_tree_add_text(tree, asn1->tvb,
9842 saved_offset, asn1->offset - saved_offset,
9846 switch (value & 0x01)
9848 case 0x00: str = "Sender does not support ConnectResource, DisconnectResource, ConnectionFailureReport and ResetTimer (SSFT timer) OPs"; break;
9850 str = "Sender supports ConnectResource, DisconnectResource, ConnectionFailureReport and ResetTimer (SSFT timer) OPs";
9854 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
9855 proto_tree_add_text(tree, asn1->tvb,
9856 saved_offset, asn1->offset - saved_offset,
9860 EXTRANEOUS_DATA_CHECK(len, 1);
9864 param_win_trig_list(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9869 add_string = add_string;
9870 saved_offset = asn1->offset;
9877 asn1_int32_value_decode(asn1, 1, &value);
9882 proto_tree_add_text(tree, asn1->tvb,
9883 saved_offset, asn1->offset - saved_offset,
9890 proto_tree_add_text(tree, asn1->tvb,
9891 saved_offset, asn1->offset - saved_offset,
9898 proto_tree_add_text(tree, asn1->tvb,
9899 saved_offset, asn1->offset - saved_offset,
9906 proto_tree_add_text(tree, asn1->tvb,
9907 saved_offset, asn1->offset - saved_offset,
9914 proto_tree_add_text(tree, asn1->tvb,
9915 saved_offset, asn1->offset - saved_offset,
9919 find_trig_type(value));
9924 saved_offset = asn1->offset;
9927 while ((len - i) > 0);
9931 param_trans_cap(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
9938 add_string = add_string;
9939 saved_offset = asn1->offset;
9941 asn1_int32_value_decode(asn1, 1, &value);
9943 switch ((value & 0x80) >> 7)
9945 case 0x00: str = "System is not capable of supporting CNAP/CNAR (NAMI)"; break;
9947 str = "System is capable of supporting CNAP/CNAR (NAMI)";
9951 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
9952 proto_tree_add_text(tree, asn1->tvb,
9953 saved_offset, asn1->offset - saved_offset,
9957 switch ((value & 0x40) >> 6)
9959 case 0x00: str = "System is not capable of supporting NDSS"; break;
9961 str = "System is capable of supporting NDSS";
9965 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
9966 proto_tree_add_text(tree, asn1->tvb,
9967 saved_offset, asn1->offset - saved_offset,
9971 switch ((value & 0x20) >> 5)
9973 case 0x00: str = "System is not capable of supporting User Zones (UZCI)"; break;
9975 str = "System is capable of supporting User Zones (UZCI)";
9979 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
9980 proto_tree_add_text(tree, asn1->tvb,
9981 saved_offset, asn1->offset - saved_offset,
9985 switch ((value & 0x10) >> 4)
9987 case 0x00: str = "System is not capable of supporting local SPINI"; break;
9989 str = "System is capable of supporting local SPINI";
9993 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
9994 proto_tree_add_text(tree, asn1->tvb,
9995 saved_offset, asn1->offset - saved_offset,
9999 switch ((value & 0x08) >> 3)
10001 case 0x00: str = "System is not capable of interacting with the user (RUI)"; break;
10003 str = "System is capable of interacting with the user (RUI)";
10007 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
10008 proto_tree_add_text(tree, asn1->tvb,
10009 saved_offset, asn1->offset - saved_offset,
10013 switch ((value & 0x04) >> 2)
10015 case 0x00: str = "System is not capable of honoring the Announcement List parameter (ANN)"; break;
10017 str = "System is capable of honoring the Announcement List parameter (ANN)";
10021 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
10022 proto_tree_add_text(tree, asn1->tvb,
10023 saved_offset, asn1->offset - saved_offset,
10027 switch ((value & 0x02) >> 1)
10029 case 0x00: str = "System is not capable of detecting a busy condition (BUSY)"; break;
10031 str = "System is capable of detecting a busy condition (BUSY)";
10035 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
10036 proto_tree_add_text(tree, asn1->tvb,
10037 saved_offset, asn1->offset - saved_offset,
10041 switch (value & 0x01)
10043 case 0x00: str = "System is not capable of supporting the IS-41-C profile parameter (PROFILE)"; break;
10045 str = "System is capable of supporting the IS-41-C profile parameter (PROFILE)";
10049 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
10050 proto_tree_add_text(tree, asn1->tvb,
10051 saved_offset, asn1->offset - saved_offset,
10055 if (len == 1) return;
10057 saved_offset = asn1->offset;
10059 asn1_int32_value_decode(asn1, 1, &value);
10061 switch ((value & 0x80) >> 7)
10063 case 0x00: str = "System is not capable of supporting the CDMA Over the Air Parameter Administration"; break;
10065 str = "System is capable of supporting the CDMA Over the Air Parameter Administration";
10069 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
10070 proto_tree_add_text(tree, asn1->tvb,
10071 saved_offset, asn1->offset - saved_offset,
10075 switch ((value & 0x40) >> 6)
10077 case 0x00: str = "System is not capable of supporting lower layer segmentation & reassembly (S&R)"; break;
10079 str = "System is capable of supporting lower layer segmentation & reassembly (S&R)";
10083 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
10084 proto_tree_add_text(tree, asn1->tvb,
10085 saved_offset, asn1->offset - saved_offset,
10089 switch ((value & 0x20) >> 5)
10091 case 0x00: str = "System is not capable of supporting the Trigger Address List parameter (WADDR)"; break;
10093 str = "System is capable of supporting the Trigger Address List parameter (WADDR)";
10097 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
10098 proto_tree_add_text(tree, asn1->tvb,
10099 saved_offset, asn1->offset - saved_offset,
10103 switch ((value & 0x10) >> 4)
10105 case 0x00: str = "System is not capable of supporting the Termination List parameter (TL)"; break;
10107 str = "System is capable of supporting the Termination List parameter (TL)";
10111 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
10112 proto_tree_add_text(tree, asn1->tvb,
10113 saved_offset, asn1->offset - saved_offset,
10117 p = other_decode_bitfield_value(bigbuf, value, 0x0f, 8);
10118 switch (value & 0x0f)
10120 case 0x00: strcat(p, " : System cannot accept a termination at this time"); break;
10122 sprintf(p, " : System supports %u call leg(s)", value & 0x0f);
10126 proto_tree_add_text(tree, asn1->tvb,
10127 saved_offset, asn1->offset - saved_offset,
10131 if (len == 2) return;
10133 saved_offset = asn1->offset;
10135 asn1_int32_value_decode(asn1, 1, &value);
10137 other_decode_bitfield_value(bigbuf, value, 0xf8, 8);
10138 proto_tree_add_text(tree, asn1->tvb,
10139 saved_offset, asn1->offset - saved_offset,
10143 switch ((value & 0x04) >> 2)
10145 case 0x00: str = "The system is not capable of supporting external MAHO requests"; break;
10147 str = "The system is capable of supporting external MAHO requests (e.g. for positioning)";
10151 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
10152 proto_tree_add_text(tree, asn1->tvb,
10153 saved_offset, asn1->offset - saved_offset,
10157 other_decode_bitfield_value(bigbuf, value, 0x03, 8);
10158 proto_tree_add_text(tree, asn1->tvb,
10159 saved_offset, asn1->offset - saved_offset,
10163 EXTRANEOUS_DATA_CHECK(len, 3);
10167 param_spini_trig(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
10170 guint saved_offset;
10173 SHORT_DATA_CHECK(len, 4);
10175 add_string = add_string;
10176 saved_offset = asn1->offset;
10178 asn1_int32_value_decode(asn1, 1, &value);
10180 switch ((value & 0x80) >> 7)
10182 case 0x00: str = "Trigger is not active"; break;
10184 str = "Execute local SPINI procedures for any Revertive Call attempt"; break;
10188 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
10189 proto_tree_add_text(tree, asn1->tvb,
10190 saved_offset, asn1->offset - saved_offset,
10191 "%s : Revertive Call (RvtC), %s",
10194 switch ((value & 0x40) >> 6)
10196 case 0x00: str = "Trigger is not active"; break;
10198 str = "Execute local SPINI procedures for any call attempt to an unrecognized number"; break;
10202 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
10203 proto_tree_add_text(tree, asn1->tvb,
10204 saved_offset, asn1->offset - saved_offset,
10205 "%s : Unrecognized Number (Unrec), %s",
10208 switch ((value & 0x20) >> 5)
10210 case 0x00: str = "Trigger is not active"; break;
10212 str = "Execute local SPINI procedures for any call attempt outside of the current World Zone (as defined in ITU-T Rec. E.164)";
10216 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
10217 proto_tree_add_text(tree, asn1->tvb,
10218 saved_offset, asn1->offset - saved_offset,
10219 "%s : World Zone (WZ), %s",
10222 switch ((value & 0x10) >> 4)
10224 case 0x00: str = "Trigger is not active"; break;
10226 str = "Execute local SPINI procedures for any international call attempt";
10230 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
10231 proto_tree_add_text(tree, asn1->tvb,
10232 saved_offset, asn1->offset - saved_offset,
10233 "%s : International (Intl), %s",
10236 switch ((value & 0x08) >> 3)
10238 case 0x00: str = "Trigger is not active"; break;
10240 str = "Execute local SPINI procedures for any toll calls outside the local carrier's serving area";
10244 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
10245 proto_tree_add_text(tree, asn1->tvb,
10246 saved_offset, asn1->offset - saved_offset,
10247 "%s : Non-Local (Inter-LATA) Toll (NLTOLL/OLATA), %s",
10250 switch ((value & 0x04) >> 2)
10252 case 0x00: str = "Trigger is not active"; break;
10254 str = "Execute local SPINI procedures for any local toll call attempt. Refers to intra-LATA toll within the NANP";
10258 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
10259 proto_tree_add_text(tree, asn1->tvb,
10260 saved_offset, asn1->offset - saved_offset,
10261 "%s : Local (Intra-LATA) Toll (LTOLL/ILATA), %s",
10264 switch ((value & 0x02) >> 1)
10266 case 0x00: str = "Trigger is not active"; break;
10268 str = "Execute local SPINI procedures for any local call attempt";
10272 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
10273 proto_tree_add_text(tree, asn1->tvb,
10274 saved_offset, asn1->offset - saved_offset,
10278 switch (value & 0x01)
10280 case 0x00: str = "Trigger is not active"; break;
10282 str = "Execute local SPINI procedures for any call attempt. This overrides all other values.";
10286 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
10287 proto_tree_add_text(tree, asn1->tvb,
10288 saved_offset, asn1->offset - saved_offset,
10289 "%s : All Origination (All), %s",
10292 saved_offset = asn1->offset;
10294 asn1_int32_value_decode(asn1, 1, &value);
10296 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
10297 proto_tree_add_text(tree, asn1->tvb,
10298 saved_offset, asn1->offset - saved_offset,
10302 switch ((value & 0x10) >> 4)
10304 case 0x00: str = "Trigger is not active"; break;
10306 str = "Execute local SPINI procedures for any number matching a criteria of a prior agreement";
10310 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
10311 proto_tree_add_text(tree, asn1->tvb,
10312 saved_offset, asn1->offset - saved_offset,
10313 "%s : Prior Agreement (PA), %s",
10316 switch ((value & 0x08) >> 3)
10318 case 0x00: str = "Trigger is not active"; break;
10320 str = "Execute local SPINI procedures for any number beginning with two Pound ## digits";
10324 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
10325 proto_tree_add_text(tree, asn1->tvb,
10326 saved_offset, asn1->offset - saved_offset,
10327 "%s : Double Pound (DP), %s",
10330 switch ((value & 0x04) >> 2)
10332 case 0x00: str = "Trigger is not active"; break;
10334 str = "Execute local SPINI procedures for any number beginning with a Pound # digit";
10338 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
10339 proto_tree_add_text(tree, asn1->tvb,
10340 saved_offset, asn1->offset - saved_offset,
10344 switch ((value & 0x02) >> 1)
10346 case 0x00: str = "Trigger is not active"; break;
10348 str = "Execute local SPINI procedures for any number beginning with two Star ** digits";
10352 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
10353 proto_tree_add_text(tree, asn1->tvb,
10354 saved_offset, asn1->offset - saved_offset,
10355 "%s : Double Star (DS), %s",
10358 switch (value & 0x01)
10360 case 0x00: str = "Trigger is not active"; break;
10362 str = "Execute local SPINI procedures for any number beginning with a Star * digit";
10366 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
10367 proto_tree_add_text(tree, asn1->tvb,
10368 saved_offset, asn1->offset - saved_offset,
10372 saved_offset = asn1->offset;
10374 asn1_int32_value_decode(asn1, 1, &value);
10376 switch ((value & 0x80) >> 7)
10378 case 0x00: str = "Trigger is not active"; break;
10380 str = "Execute local SPINI procedures for any call attempt with 7 digits";
10384 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
10385 proto_tree_add_text(tree, asn1->tvb,
10386 saved_offset, asn1->offset - saved_offset,
10387 "%s : 7 digits, %s",
10390 switch ((value & 0x40) >> 6)
10392 case 0x00: str = "Trigger is not active"; break;
10394 str = "Execute local SPINI procedures for any call attempt with 6 digits";
10398 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
10399 proto_tree_add_text(tree, asn1->tvb,
10400 saved_offset, asn1->offset - saved_offset,
10401 "%s : 6 digits, %s",
10404 switch ((value & 0x20) >> 5)
10406 case 0x00: str = "Trigger is not active"; break;
10408 str = "Execute local SPINI procedures for any call attempt with 5 digits";
10412 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
10413 proto_tree_add_text(tree, asn1->tvb,
10414 saved_offset, asn1->offset - saved_offset,
10415 "%s : 5 digits, %s",
10418 switch ((value & 0x10) >> 4)
10420 case 0x00: str = "Trigger is not active"; break;
10422 str = "Execute local SPINI procedures for any call attempt with 4 digits";
10426 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
10427 proto_tree_add_text(tree, asn1->tvb,
10428 saved_offset, asn1->offset - saved_offset,
10429 "%s : 4 digits, %s",
10432 switch ((value & 0x08) >> 3)
10434 case 0x00: str = "Trigger is not active"; break;
10436 str = "Execute local SPINI procedures for any call attempt with 3 digits";
10440 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
10441 proto_tree_add_text(tree, asn1->tvb,
10442 saved_offset, asn1->offset - saved_offset,
10443 "%s : 3 digits, %s",
10446 switch ((value & 0x04) >> 2)
10448 case 0x00: str = "Trigger is not active"; break;
10450 str = "Execute local SPINI procedures for any call attempt with 2 digits";
10454 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
10455 proto_tree_add_text(tree, asn1->tvb,
10456 saved_offset, asn1->offset - saved_offset,
10457 "%s : 2 digits, %s",
10460 switch ((value & 0x02) >> 1)
10462 case 0x00: str = "Trigger is not active"; break;
10464 str = "Execute local SPINI procedures for any call attempt with 1 digits";
10468 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
10469 proto_tree_add_text(tree, asn1->tvb,
10470 saved_offset, asn1->offset - saved_offset,
10471 "%s : 1 digits, %s",
10474 switch (value & 0x01)
10476 case 0x00: str = "Trigger is not active"; break;
10478 str = "Execute local SPINI procedures for any call attempt with no digits";
10482 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
10483 proto_tree_add_text(tree, asn1->tvb,
10484 saved_offset, asn1->offset - saved_offset,
10485 "%s : No digits, %s",
10488 saved_offset = asn1->offset;
10490 asn1_int32_value_decode(asn1, 1, &value);
10492 switch ((value & 0x80) >> 7)
10494 case 0x00: str = "Trigger is not active"; break;
10496 str = "Execute local SPINI procedures for any call attempt with 15 or more digits";
10500 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
10501 proto_tree_add_text(tree, asn1->tvb,
10502 saved_offset, asn1->offset - saved_offset,
10503 "%s : 15 digits, %s",
10506 switch ((value & 0x40) >> 6)
10508 case 0x00: str = "Trigger is not active"; break;
10510 str = "Execute local SPINI procedures for any call attempt with 14 digits";
10514 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
10515 proto_tree_add_text(tree, asn1->tvb,
10516 saved_offset, asn1->offset - saved_offset,
10517 "%s : 14 digits, %s",
10520 switch ((value & 0x20) >> 5)
10522 case 0x00: str = "Trigger is not active"; break;
10524 str = "Execute local SPINI procedures for any call attempt with 13 digits";
10528 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
10529 proto_tree_add_text(tree, asn1->tvb,
10530 saved_offset, asn1->offset - saved_offset,
10531 "%s : 13 digits, %s",
10534 switch ((value & 0x10) >> 4)
10536 case 0x00: str = "Trigger is not active"; break;
10538 str = "Execute local SPINI procedures for any call attempt with 12 digits";
10542 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
10543 proto_tree_add_text(tree, asn1->tvb,
10544 saved_offset, asn1->offset - saved_offset,
10545 "%s : 12 digits, %s",
10548 switch ((value & 0x08) >> 3)
10550 case 0x00: str = "Trigger is not active"; break;
10552 str = "Execute local SPINI procedures for any call attempt with 11 digits";
10556 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
10557 proto_tree_add_text(tree, asn1->tvb,
10558 saved_offset, asn1->offset - saved_offset,
10559 "%s : 11 digits, %s",
10562 switch ((value & 0x04) >> 2)
10564 case 0x00: str = "Trigger is not active"; break;
10566 str = "Execute local SPINI procedures for any call attempt with 10 digits";
10570 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
10571 proto_tree_add_text(tree, asn1->tvb,
10572 saved_offset, asn1->offset - saved_offset,
10573 "%s : 10 digits, %s",
10576 switch ((value & 0x02) >> 1)
10578 case 0x00: str = "Trigger is not active"; break;
10580 str = "Execute local SPINI procedures for any call attempt with 9 digits";
10584 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
10585 proto_tree_add_text(tree, asn1->tvb,
10586 saved_offset, asn1->offset - saved_offset,
10587 "%s : 9 digits, %s",
10590 switch (value & 0x01)
10592 case 0x00: str = "Trigger is not active"; break;
10594 str = "Execute local SPINI procedures for any call attempt with 8 digits";
10598 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
10599 proto_tree_add_text(tree, asn1->tvb,
10600 saved_offset, asn1->offset - saved_offset,
10601 "%s : 8 digits, %s",
10604 EXTRANEOUS_DATA_CHECK(len, 4);
10608 param_orig_trig(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
10611 guint saved_offset;
10614 SHORT_DATA_CHECK(len, 4);
10616 add_string = add_string;
10617 saved_offset = asn1->offset;
10619 asn1_int32_value_decode(asn1, 1, &value);
10621 switch ((value & 0x80) >> 7)
10623 case 0x00: str = "Trigger is not active"; break;
10625 str = "Launch an Origination Request for any Revertive Call attempt"; break;
10629 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
10630 proto_tree_add_text(tree, asn1->tvb,
10631 saved_offset, asn1->offset - saved_offset,
10632 "%s : Revertive Call (RvtC), %s",
10635 switch ((value & 0x40) >> 6)
10637 case 0x00: str = "Trigger is not active"; break;
10639 str = "Launch an Origination Request for any call attempt to an unrecognized number"; break;
10643 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
10644 proto_tree_add_text(tree, asn1->tvb,
10645 saved_offset, asn1->offset - saved_offset,
10646 "%s : Unrecognized Number (Unrec), %s",
10649 switch ((value & 0x20) >> 5)
10651 case 0x00: str = "Trigger is not active"; break;
10653 str = "Launch an Origination Request for any call attempt outside of the current World Zone (as defined in ITU-T Rec. E.164)";
10657 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
10658 proto_tree_add_text(tree, asn1->tvb,
10659 saved_offset, asn1->offset - saved_offset,
10660 "%s : World Zone (WZ), %s",
10663 switch ((value & 0x10) >> 4)
10665 case 0x00: str = "Trigger is not active"; break;
10667 str = "Launch an Origination Request for any international call attempt";
10671 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
10672 proto_tree_add_text(tree, asn1->tvb,
10673 saved_offset, asn1->offset - saved_offset,
10674 "%s : International (Intl), %s",
10677 switch ((value & 0x08) >> 3)
10679 case 0x00: str = "Trigger is not active"; break;
10681 str = "Launch an Origination Request for any toll calls outside the local carrier's serving area";
10685 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
10686 proto_tree_add_text(tree, asn1->tvb,
10687 saved_offset, asn1->offset - saved_offset,
10688 "%s : Non-Local (Inter-LATA) Toll (NLTOLL/OLATA), %s",
10691 switch ((value & 0x04) >> 2)
10693 case 0x00: str = "Trigger is not active"; break;
10695 str = "Launch an Origination Request for any local toll call attempt. Refers to intra-LATA toll within the NANP";
10699 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
10700 proto_tree_add_text(tree, asn1->tvb,
10701 saved_offset, asn1->offset - saved_offset,
10702 "%s : Local (Intra-LATA) Toll (LTOLL/ILATA), %s",
10705 switch ((value & 0x02) >> 1)
10707 case 0x00: str = "Trigger is not active"; break;
10709 str = "Launch an Origination Request for any local call attempt";
10713 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
10714 proto_tree_add_text(tree, asn1->tvb,
10715 saved_offset, asn1->offset - saved_offset,
10719 switch (value & 0x01)
10721 case 0x00: str = "Trigger is not active"; break;
10723 str = "Launch an Origination Request for any call attempt. This overrides all other values.";
10727 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
10728 proto_tree_add_text(tree, asn1->tvb,
10729 saved_offset, asn1->offset - saved_offset,
10730 "%s : All Origination (All), %s",
10733 saved_offset = asn1->offset;
10735 asn1_int32_value_decode(asn1, 1, &value);
10737 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
10738 proto_tree_add_text(tree, asn1->tvb,
10739 saved_offset, asn1->offset - saved_offset,
10743 switch ((value & 0x10) >> 4)
10745 case 0x00: str = "Trigger is not active"; break;
10747 str = "Launch an Origination Request for any number matching a criteria of a prior agreement";
10751 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
10752 proto_tree_add_text(tree, asn1->tvb,
10753 saved_offset, asn1->offset - saved_offset,
10754 "%s : Prior Agreement (PA), %s",
10757 switch ((value & 0x08) >> 3)
10759 case 0x00: str = "Trigger is not active"; break;
10761 str = "Launch an Origination Request for any number beginning with two Pound ## digits";
10765 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
10766 proto_tree_add_text(tree, asn1->tvb,
10767 saved_offset, asn1->offset - saved_offset,
10768 "%s : Double Pound (DP), %s",
10771 switch ((value & 0x04) >> 2)
10773 case 0x00: str = "Trigger is not active"; break;
10775 str = "Launch an Origination Request for any number beginning with a Pound # digit";
10779 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
10780 proto_tree_add_text(tree, asn1->tvb,
10781 saved_offset, asn1->offset - saved_offset,
10785 switch ((value & 0x02) >> 1)
10787 case 0x00: str = "Trigger is not active"; break;
10789 str = "Launch an Origination Request for any number beginning with two Star ** digits";
10793 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
10794 proto_tree_add_text(tree, asn1->tvb,
10795 saved_offset, asn1->offset - saved_offset,
10796 "%s : Double Star (DS), %s",
10799 switch (value & 0x01)
10801 case 0x00: str = "Trigger is not active"; break;
10803 str = "Launch an Origination Request for any number beginning with a Star * digit";
10807 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
10808 proto_tree_add_text(tree, asn1->tvb,
10809 saved_offset, asn1->offset - saved_offset,
10813 saved_offset = asn1->offset;
10815 asn1_int32_value_decode(asn1, 1, &value);
10817 switch ((value & 0x80) >> 7)
10819 case 0x00: str = "Trigger is not active"; break;
10821 str = "Launch an Origination Request for any call attempt with 7 digits";
10825 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
10826 proto_tree_add_text(tree, asn1->tvb,
10827 saved_offset, asn1->offset - saved_offset,
10828 "%s : 7 digits, %s",
10831 switch ((value & 0x40) >> 6)
10833 case 0x00: str = "Trigger is not active"; break;
10835 str = "Launch an Origination Request for any call attempt with 6 digits";
10839 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
10840 proto_tree_add_text(tree, asn1->tvb,
10841 saved_offset, asn1->offset - saved_offset,
10842 "%s : 6 digits, %s",
10845 switch ((value & 0x20) >> 5)
10847 case 0x00: str = "Trigger is not active"; break;
10849 str = "Launch an Origination Request for any call attempt with 5 digits";
10853 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
10854 proto_tree_add_text(tree, asn1->tvb,
10855 saved_offset, asn1->offset - saved_offset,
10856 "%s : 5 digits, %s",
10859 switch ((value & 0x10) >> 4)
10861 case 0x00: str = "Trigger is not active"; break;
10863 str = "Launch an Origination Request for any call attempt with 4 digits";
10867 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
10868 proto_tree_add_text(tree, asn1->tvb,
10869 saved_offset, asn1->offset - saved_offset,
10870 "%s : 4 digits, %s",
10873 switch ((value & 0x08) >> 3)
10875 case 0x00: str = "Trigger is not active"; break;
10877 str = "Launch an Origination Request for any call attempt with 3 digits";
10881 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
10882 proto_tree_add_text(tree, asn1->tvb,
10883 saved_offset, asn1->offset - saved_offset,
10884 "%s : 3 digits, %s",
10887 switch ((value & 0x04) >> 2)
10889 case 0x00: str = "Trigger is not active"; break;
10891 str = "Launch an Origination Request for any call attempt with 2 digits";
10895 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
10896 proto_tree_add_text(tree, asn1->tvb,
10897 saved_offset, asn1->offset - saved_offset,
10898 "%s : 2 digits, %s",
10901 switch ((value & 0x02) >> 1)
10903 case 0x00: str = "Trigger is not active"; break;
10905 str = "Launch an Origination Request for any call attempt with 1 digits";
10909 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
10910 proto_tree_add_text(tree, asn1->tvb,
10911 saved_offset, asn1->offset - saved_offset,
10912 "%s : 1 digits, %s",
10915 switch (value & 0x01)
10917 case 0x00: str = "Trigger is not active"; break;
10919 str = "Launch an Origination Request for any call attempt with no digits";
10923 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
10924 proto_tree_add_text(tree, asn1->tvb,
10925 saved_offset, asn1->offset - saved_offset,
10926 "%s : No digits, %s",
10929 saved_offset = asn1->offset;
10931 asn1_int32_value_decode(asn1, 1, &value);
10933 switch ((value & 0x80) >> 7)
10935 case 0x00: str = "Trigger is not active"; break;
10937 str = "Launch an Origination Request for any call attempt with 15 or more digits";
10941 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
10942 proto_tree_add_text(tree, asn1->tvb,
10943 saved_offset, asn1->offset - saved_offset,
10944 "%s : 15 digits, %s",
10947 switch ((value & 0x40) >> 6)
10949 case 0x00: str = "Trigger is not active"; break;
10951 str = "Launch an Origination Request for any call attempt with 14 digits";
10955 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
10956 proto_tree_add_text(tree, asn1->tvb,
10957 saved_offset, asn1->offset - saved_offset,
10958 "%s : 14 digits, %s",
10961 switch ((value & 0x20) >> 5)
10963 case 0x00: str = "Trigger is not active"; break;
10965 str = "Launch an Origination Request for any call attempt with 13 digits";
10969 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
10970 proto_tree_add_text(tree, asn1->tvb,
10971 saved_offset, asn1->offset - saved_offset,
10972 "%s : 13 digits, %s",
10975 switch ((value & 0x10) >> 4)
10977 case 0x00: str = "Trigger is not active"; break;
10979 str = "Launch an Origination Request for any call attempt with 12 digits";
10983 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
10984 proto_tree_add_text(tree, asn1->tvb,
10985 saved_offset, asn1->offset - saved_offset,
10986 "%s : 12 digits, %s",
10989 switch ((value & 0x08) >> 3)
10991 case 0x00: str = "Trigger is not active"; break;
10993 str = "Launch an Origination Request for any call attempt with 11 digits";
10997 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
10998 proto_tree_add_text(tree, asn1->tvb,
10999 saved_offset, asn1->offset - saved_offset,
11000 "%s : 11 digits, %s",
11003 switch ((value & 0x04) >> 2)
11005 case 0x00: str = "Trigger is not active"; break;
11007 str = "Launch an Origination Request for any call attempt with 10 digits";
11011 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
11012 proto_tree_add_text(tree, asn1->tvb,
11013 saved_offset, asn1->offset - saved_offset,
11014 "%s : 10 digits, %s",
11017 switch ((value & 0x02) >> 1)
11019 case 0x00: str = "Trigger is not active"; break;
11021 str = "Launch an Origination Request for any call attempt with 9 digits";
11025 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
11026 proto_tree_add_text(tree, asn1->tvb,
11027 saved_offset, asn1->offset - saved_offset,
11028 "%s : 9 digits, %s",
11031 switch (value & 0x01)
11033 case 0x00: str = "Trigger is not active"; break;
11035 str = "Launch an Origination Request for any call attempt with 8 digits";
11039 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
11040 proto_tree_add_text(tree, asn1->tvb,
11041 saved_offset, asn1->offset - saved_offset,
11042 "%s : 8 digits, %s",
11045 EXTRANEOUS_DATA_CHECK(len, 4);
11049 param_trig_cap(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11052 guint saved_offset;
11055 add_string = add_string;
11056 saved_offset = asn1->offset;
11058 asn1_int32_value_decode(asn1, 1, &value);
11060 switch ((value & 0x80) >> 7)
11062 case 0x00: str = "O No Answer (ONA) cannot be armed"; break;
11064 str = "O No Answer (ONA) can be armed";
11068 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
11069 proto_tree_add_text(tree, asn1->tvb,
11070 saved_offset, asn1->offset - saved_offset,
11074 switch ((value & 0x40) >> 6)
11076 case 0x00: str = "O Disconnect (ODISC) cannot be armed"; break;
11078 str = "O Disconnect (ODISC) can be armed";
11082 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
11083 proto_tree_add_text(tree, asn1->tvb,
11084 saved_offset, asn1->offset - saved_offset,
11088 switch ((value & 0x20) >> 5)
11090 case 0x00: str = "O Answer (OANS) cannot be armed"; break;
11092 str = "O Answer (OANS) can be armed";
11096 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
11097 proto_tree_add_text(tree, asn1->tvb,
11098 saved_offset, asn1->offset - saved_offset,
11102 switch ((value & 0x10) >> 4)
11104 case 0x00: str = "Origination Attempt Authorized (OAA) cannot be armed"; break;
11106 str = "Origination Attempt Authorized (OAA) can be armed";
11110 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
11111 proto_tree_add_text(tree, asn1->tvb,
11112 saved_offset, asn1->offset - saved_offset,
11116 switch ((value & 0x08) >> 3)
11118 case 0x00: str = "Revertive Call trigger (RvtC) cannot be armed"; break;
11120 str = "Revertive Call trigger (RvtC) can be armed";
11124 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
11125 proto_tree_add_text(tree, asn1->tvb,
11126 saved_offset, asn1->offset - saved_offset,
11130 switch ((value & 0x04) >> 2)
11132 case 0x00: str = "All Calls trigger (All) cannot be armed"; break;
11134 str = "All Calls trigger (All) can be armed";
11138 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
11139 proto_tree_add_text(tree, asn1->tvb,
11140 saved_offset, asn1->offset - saved_offset,
11144 switch ((value & 0x02) >> 1)
11146 case 0x00: str = "K-digit triggers (K-digit) cannot be armed"; break;
11148 str = "K-digit triggers (K-digit) can be armed";
11152 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
11153 proto_tree_add_text(tree, asn1->tvb,
11154 saved_offset, asn1->offset - saved_offset,
11158 switch (value & 0x01)
11160 case 0x00: str = "Introducing Star/Pound triggers (INIT) cannot be armed"; break;
11162 str = "Introducing Star/Pound triggers (INIT) can be armed";
11166 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
11167 proto_tree_add_text(tree, asn1->tvb,
11168 saved_offset, asn1->offset - saved_offset,
11172 if (len == 1) return;
11174 saved_offset = asn1->offset;
11176 asn1_int32_value_decode(asn1, 1, &value);
11178 switch ((value & 0x80) >> 7)
11180 case 0x00: str = "O Called Party Busy (OBSY) cannot be armed"; break;
11182 str = "O Called Party Busy (OBSY) can be armed";
11186 other_decode_bitfield_value(bigbuf, value, 0x80, 8);
11187 proto_tree_add_text(tree, asn1->tvb,
11188 saved_offset, asn1->offset - saved_offset,
11192 switch ((value & 0x40) >> 6)
11194 case 0x00: str = "Called Routing Address Available (CdRAA) cannot be armed"; break;
11196 str = "Called Routing Address Available (CdRAA) can be armed";
11200 other_decode_bitfield_value(bigbuf, value, 0x40, 8);
11201 proto_tree_add_text(tree, asn1->tvb,
11202 saved_offset, asn1->offset - saved_offset,
11206 switch ((value & 0x20) >> 5)
11208 case 0x00: str = "Initial Termination (IT) cannot be armed"; break;
11210 str = "Initial Termination (IT) can be armed";
11214 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
11215 proto_tree_add_text(tree, asn1->tvb,
11216 saved_offset, asn1->offset - saved_offset,
11220 switch ((value & 0x10) >> 4)
11222 case 0x00: str = "Calling Routing Address Available (CgRAA) cannot be armed"; break;
11224 str = "Calling Routing Address Available (CgRAA) can be armed";
11228 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
11229 proto_tree_add_text(tree, asn1->tvb,
11230 saved_offset, asn1->offset - saved_offset,
11234 switch ((value & 0x08) >> 3)
11236 case 0x00: str = "Advanced Termination trigger (AT) cannot be armed"; break;
11238 str = "Advanced Termination trigger (AT) can be armed";
11242 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
11243 proto_tree_add_text(tree, asn1->tvb,
11244 saved_offset, asn1->offset - saved_offset,
11248 switch ((value & 0x04) >> 2)
11250 case 0x00: str = "Prior Agreement trigger (PA) cannot be armed"; break;
11252 str = "Prior Agreement trigger (PA) can be armed";
11256 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
11257 proto_tree_add_text(tree, asn1->tvb,
11258 saved_offset, asn1->offset - saved_offset,
11262 switch ((value & 0x02) >> 1)
11264 case 0x00: str = "Unrecognized Number trigger (Unrec) cannot be armed"; break;
11266 str = "Unrecognized Number trigger (Unrec) can be armed";
11270 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
11271 proto_tree_add_text(tree, asn1->tvb,
11272 saved_offset, asn1->offset - saved_offset,
11276 switch (value & 0x01)
11278 case 0x00: str = "Call Type triggers (CT) cannot be armed"; break;
11280 str = "Call Type triggers (CT) can be armed";
11284 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
11285 proto_tree_add_text(tree, asn1->tvb,
11286 saved_offset, asn1->offset - saved_offset,
11290 if (len == 2) return;
11292 saved_offset = asn1->offset;
11294 asn1_int32_value_decode(asn1, 1, &value);
11296 other_decode_bitfield_value(bigbuf, value, 0xe0, 8);
11297 proto_tree_add_text(tree, asn1->tvb,
11298 saved_offset, asn1->offset - saved_offset,
11302 switch ((value & 0x10) >> 4)
11304 case 0x00: str = "T Disconnect (TDISC) cannot be armed"; break;
11306 str = "T Disconnect (TDISC) can be armed";
11310 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
11311 proto_tree_add_text(tree, asn1->tvb,
11312 saved_offset, asn1->offset - saved_offset,
11316 switch ((value & 0x08) >> 3)
11318 case 0x00: str = "T Answer (TANS) cannot be armed"; break;
11320 str = "T Answer (TANS) can be armed";
11324 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
11325 proto_tree_add_text(tree, asn1->tvb,
11326 saved_offset, asn1->offset - saved_offset,
11330 switch ((value & 0x04) >> 2)
11332 case 0x00: str = "T No Answer trigger (TNA) cannot be armed"; break;
11334 str = "T No Answer trigger (TNA) can be armed";
11338 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
11339 proto_tree_add_text(tree, asn1->tvb,
11340 saved_offset, asn1->offset - saved_offset,
11344 switch ((value & 0x02) >> 1)
11346 case 0x00: str = "T Busy trigger (TBusy) cannot be armed"; break;
11348 str = "T Busy trigger (TBusy) can be armed";
11352 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
11353 proto_tree_add_text(tree, asn1->tvb,
11354 saved_offset, asn1->offset - saved_offset,
11358 switch (value & 0x01)
11360 case 0x00: str = "Terminating Resource Available triggers (TRA) cannot be armed"; break;
11362 str = "Terminating Resource Available triggers (TRA) can be armed";
11366 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
11367 proto_tree_add_text(tree, asn1->tvb,
11368 saved_offset, asn1->offset - saved_offset,
11372 EXTRANEOUS_DATA_CHECK(len, 3);
11376 param_sys_cap(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11379 guint saved_offset;
11382 EXACT_DATA_CHECK(len, 1);
11384 add_string = add_string;
11385 saved_offset = asn1->offset;
11387 asn1_int32_value_decode(asn1, 1, &value);
11389 other_decode_bitfield_value(bigbuf, value, 0xc0, 8);
11390 proto_tree_add_text(tree, asn1->tvb,
11391 saved_offset, asn1->offset - saved_offset,
11395 switch ((value & 0x20) >> 5)
11397 case 0x00: str = "DP is not supported by the system"; break;
11399 str = "DP is supported by the system";
11403 other_decode_bitfield_value(bigbuf, value, 0x20, 8);
11404 proto_tree_add_text(tree, asn1->tvb,
11405 saved_offset, asn1->offset - saved_offset,
11409 switch ((value & 0x10) >> 4)
11411 case 0x00: str = "SSD is not shared with the system for the indicated MS"; break;
11413 str = "SSD is shared with the system for the indicated MS";
11417 other_decode_bitfield_value(bigbuf, value, 0x10, 8);
11418 proto_tree_add_text(tree, asn1->tvb,
11419 saved_offset, asn1->offset - saved_offset,
11423 switch ((value & 0x08) >> 3)
11425 case 0x00: str = "System cannot execute CAVE algorithm"; break;
11427 str = "System can execute CAVE algorithm";
11431 other_decode_bitfield_value(bigbuf, value, 0x08, 8);
11432 proto_tree_add_text(tree, asn1->tvb,
11433 saved_offset, asn1->offset - saved_offset,
11437 switch ((value & 0x04) >> 2)
11439 case 0x00: str = "Voice Privacy is not supported"; break;
11441 str = "Voice Privacy is supported";
11445 other_decode_bitfield_value(bigbuf, value, 0x04, 8);
11446 proto_tree_add_text(tree, asn1->tvb,
11447 saved_offset, asn1->offset - saved_offset,
11451 switch ((value & 0x02) >> 1)
11453 case 0x00: str = "SME is not supported"; break;
11455 str = "SME is supported";
11459 other_decode_bitfield_value(bigbuf, value, 0x02, 8);
11460 proto_tree_add_text(tree, asn1->tvb,
11461 saved_offset, asn1->offset - saved_offset,
11465 switch (value & 0x01)
11467 case 0x00: str = "Authentication parameters were not requested"; break;
11469 str = "Authentication parameters were requested";
11473 other_decode_bitfield_value(bigbuf, value, 0x01, 8);
11474 proto_tree_add_text(tree, asn1->tvb,
11475 saved_offset, asn1->offset - saved_offset,
11481 param_act_code(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11484 guint saved_offset;
11487 add_string = add_string;
11488 saved_offset = asn1->offset;
11490 asn1_int32_value_decode(asn1, 1, &value);
11494 case 0: str = "Not used"; break;
11495 case 1: str = "Continue processing"; break;
11496 case 2: str = "Disconnect call"; break;
11497 case 3: str = "Disconnect call leg"; break;
11498 case 4: str = "Conference calling drop last party"; break;
11499 case 5: str = "Bridge call leg(s) to conference call"; break;
11500 case 6: str = "Drop call leg on busy or routing failure"; break;
11501 case 7: str = "Disconnect all call legs"; break;
11502 case 8: str = "Attach MSC to OTAF"; break;
11503 case 9: str = "Initiate Registration Notification"; break;
11504 case 10: str = "Generate Public Encryption values"; break;
11505 case 11: str = "Generate A-Key"; break;
11506 case 12: str = "Perform SSD Update procedure"; break;
11507 case 13: str = "Perform Re-authentication procedure"; break;
11508 case 14: str = "Release TRN"; break;
11509 case 15: str = "Commit A-key"; break;
11510 case 16: str = "Release Resources"; break;
11511 case 17: str = "Record NEWMSID"; break;
11512 case 18: str = "Allocate Resources"; break;
11513 case 19: str = "Generate Authentication Signature"; break;
11514 case 20: str = "Release leg and redirect subscriber"; break;
11515 case 21: str = "Do Not Wait For MS User Level Response"; break;
11517 if ((value >= 22) && (value <= 95)) { str = "Reserved, treat as Continue processing"; }
11518 if ((value >= 96) && (value <= 127)) { str = "Reserved for protocol extension, treat as Continue processing"; }
11519 if ((value >= 128) && (value <= 223)) { str = "Reserved, treat as Disconnect call"; }
11520 else { str = "Reserved for protocol extension, treat as Disconnect call"; }
11524 proto_tree_add_text(tree, asn1->tvb,
11525 saved_offset, asn1->offset - saved_offset,
11526 "Action Code, %s (%u)",
11530 EXTRANEOUS_DATA_CHECK(len, 1);
11534 param_border_acc(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11537 guint saved_offset;
11540 EXACT_DATA_CHECK(len, 1);
11542 add_string = add_string;
11543 saved_offset = asn1->offset;
11545 asn1_int32_value_decode(asn1, 1, &value);
11549 case 0: str = "Not used"; break;
11550 case 1: str = "Border Cell Access"; break;
11552 if ((value >= 2) && (value <= 223)) { str = "Reserved, treat as Border Cell Access"; }
11553 else { str = "Reserved for protocol extension, treat as Border Cell Access"; }
11557 proto_tree_add_text(tree, asn1->tvb,
11558 saved_offset, asn1->offset - saved_offset,
11559 "Indication, %s (%u)",
11565 param_avail_type(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11568 guint saved_offset;
11571 add_string = add_string;
11572 saved_offset = asn1->offset;
11574 asn1_int32_value_decode(asn1, 1, &value);
11578 case 0: str = "Not used"; break;
11579 case 1: str = "Unspecified MS inactivity type"; break;
11581 if ((value >= 2) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
11582 else { str = "Reserved for protocol extension, treat as Unspecified"; }
11586 proto_tree_add_text(tree, asn1->tvb,
11587 saved_offset, asn1->offset - saved_offset,
11590 EXTRANEOUS_DATA_CHECK(len, 1);
11594 param_can_type(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11597 guint saved_offset;
11600 add_string = add_string;
11601 saved_offset = asn1->offset;
11603 asn1_int32_value_decode(asn1, 1, &value);
11607 case 0: str = "Not used"; break;
11608 case 1: str = "Serving System Option. The serving system may discontinue a call or service in progress at its option."; break;
11609 case 2: str = "Report In Call. The serving system shall continue to provide service when a call or service is in progress and just report its incidence."; break;
11610 case 3: str = "Discontinue. The serving system shall discontinue any call or service in progress, regardless of the MS
\92s qualification, profile or authentication."; break;
11612 if ((value >= 4) && (value <= 223)) { str = "Reserved, treat as Serving System Option"; }
11613 else { str = "Reserved for protocol extension, treat as Serving System Option"; }
11617 proto_tree_add_text(tree, asn1->tvb,
11618 saved_offset, asn1->offset - saved_offset,
11621 EXTRANEOUS_DATA_CHECK(len, 1);
11625 param_can_den(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11628 guint saved_offset;
11631 EXACT_DATA_CHECK(len, 1);
11633 add_string = add_string;
11634 saved_offset = asn1->offset;
11636 asn1_int32_value_decode(asn1, 1, &value);
11640 case 0: str = "Not used"; break;
11641 case 1: str = "Multiple Access"; break;
11642 case 2: str = "Busy"; break;
11644 if ((value >= 3) && (value <= 223)) { str = "Reserved, treat as Multiple Access"; }
11645 else { str = "Reserved for protocol extension, treat as Multiple Access"; }
11649 proto_tree_add_text(tree, asn1->tvb,
11650 saved_offset, asn1->offset - saved_offset,
11651 "Indication, %s (%u)",
11657 param_acc_den(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11660 guint saved_offset;
11663 EXACT_DATA_CHECK(len, 1);
11665 add_string = add_string;
11666 saved_offset = asn1->offset;
11668 asn1_int32_value_decode(asn1, 1, &value);
11672 case 0: str = "Not used"; break;
11673 case 1: str = "Unassigned directory number"; break;
11674 case 2: str = "Inactive"; break;
11675 case 3: str = "Busy"; break;
11676 case 4: str = "Termination denied"; break;
11677 case 5: str = "No Page response"; break;
11678 case 6: str = "Unavailable"; break;
11679 case 7: str = "Service Rejected by MS"; break;
11680 case 8: str = "Service Rejected by the System"; break;
11681 case 9: str = "Service Type Mismatch"; break;
11682 case 10: str = "Service Denied"; break;
11683 case 11: str = "Call Rejected"; break;
11685 if ((value >= 12) && (value <= 223)) { str = "Reserved, treat as Termination denied"; }
11686 else { str = "Reserved for protocol extension, treat as Termination denied"; }
11690 proto_tree_add_text(tree, asn1->tvb,
11691 saved_offset, asn1->offset - saved_offset,
11692 "Access Denied Reason, %s (%u)",
11698 param_sms_acc_den_reason(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11701 guint saved_offset;
11704 add_string = add_string;
11705 saved_offset = asn1->offset;
11707 asn1_int32_value_decode(asn1, 1, &value);
11711 case 0: str = "Not used"; break;
11712 case 1: str = "Denied"; break;
11713 case 2: str = "Postponed"; break;
11714 case 3: str = "Unavailable"; break;
11715 case 4: str = "Invalid"; break;
11717 if ((value >= 5) && (value <= 63)) { str = "Reserved, treat as Denied"; }
11718 else if ((value >= 64) && (value <= 127)) { str = "Reserved, treat as Postponed"; }
11719 else if ((value >= 128) && (value <= 223)) { str = "Reserved, treat as Unavailable"; }
11720 else { str = "Reserved for protocol extension, treat as Unavailable"; }
11724 proto_tree_add_text(tree, asn1->tvb,
11725 saved_offset, asn1->offset - saved_offset,
11726 "Access Denied Reason, %s (%u)",
11730 EXTRANEOUS_DATA_CHECK(len, 1);
11734 param_sms_bd(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11736 tvbuff_t *next_tvb;
11738 add_string = add_string;
11740 next_tvb = tvb_new_subset(asn1->tvb, asn1->offset, len, len);
11742 if (ansi_map_sms_tele_id != -1)
11744 dissector_try_port(is637_tele_id_dissector_table, ansi_map_sms_tele_id, next_tvb, g_pinfo, g_tree);
11745 ansi_map_sms_tele_id = -1;
11747 else if (is683_ota)
11749 dissector_try_port(is683_dissector_table, ansi_map_is_invoke ? 0 : 1, next_tvb, g_pinfo, g_tree);
11752 proto_tree_add_text(tree, asn1->tvb,
11756 asn1->offset += len;
11760 param_sms_cause(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11763 guint saved_offset;
11766 add_string = add_string;
11767 saved_offset = asn1->offset;
11769 asn1_int32_value_decode(asn1, 1, &value);
11773 case 0: str = "Address vacant"; break;
11774 case 1: str = "Address translation failure"; break;
11775 case 2: str = "Network resource shortage"; break;
11776 case 3: str = "Network failure"; break;
11777 case 4: str = "Invalid Teleservice ID"; break;
11778 case 5: str = "Other network problem"; break;
11779 case 6: str = "Unsupported network interface"; break;
11780 case 32: str = "No page response"; break;
11781 case 33: str = "Destination busy"; break;
11782 case 34: str = "No acknowledgement"; break;
11783 case 35: str = "Destination resource shortage"; break;
11784 case 36: str = "SMS delivery postponed"; break;
11785 case 37: str = "Destination out of service"; break;
11786 case 38: str = "Destination no longer at this address"; break;
11787 case 39: str = "Other terminal problem"; break;
11788 case 64: str = "Radio interface resource shortage"; break;
11789 case 65: str = "Radio interface incompatibility"; break;
11790 case 66: str = "Other radio interface problem"; break;
11791 case 67: str = "Unsupported Base Station Capability"; break;
11792 case 96: str = "Encoding problem"; break;
11793 case 97: str = "Service origination denied"; break;
11794 case 98: str = "Service termination denied"; break;
11795 case 99: str = "Supplementary service not supported"; break;
11796 case 100: str = "Service not supported"; break;
11797 case 101: str = "Reserved"; break;
11798 case 102: str = "Missing expected parameter"; break;
11799 case 103: str = "Missing mandatory parameter"; break;
11800 case 104: str = "Unrecognized parameter value"; break;
11801 case 105: str = "Unexpected parameter value"; break;
11802 case 106: str = "User Data size error"; break;
11803 case 107: str = "Other general problems"; break;
11804 case 108: str = "Session not active"; break;
11806 if ((value >= 7) && (value <= 31)) { str = "Reserved, treat as Other network problem"; }
11807 else if ((value >= 40) && (value <= 47)) { str = "Reserved, treat as Other terminal problem"; }
11808 else if ((value >= 48) && (value <= 63)) { str = "Reserved, treat as SMS delivery postponed"; }
11809 else if ((value >= 68) && (value <= 95)) { str = "Reserved, treat as Other radio interface problem"; }
11810 else if ((value >= 109) && (value <= 223)) { str = "Reserved, treat as Other general problems"; }
11811 else { str = "Reserved for protocol extension, treat as Other general problems"; }
11815 proto_tree_add_text(tree, asn1->tvb,
11816 saved_offset, asn1->offset - saved_offset,
11821 EXTRANEOUS_DATA_CHECK(len, 1);
11825 param_cdma_soci(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11828 guint saved_offset;
11830 add_string = add_string;
11831 saved_offset = asn1->offset;
11833 asn1_int32_value_decode(asn1, 1, &value);
11835 proto_tree_add_text(tree, asn1->tvb,
11836 saved_offset, asn1->offset - saved_offset,
11840 EXTRANEOUS_DATA_CHECK(len, 1);
11844 param_int(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11847 guint saved_offset;
11849 add_string = add_string;
11853 proto_tree_add_text(tree, asn1->tvb,
11854 asn1->offset, len, "Long Data (?)");
11855 asn1->offset += len;
11859 saved_offset = asn1->offset;
11861 asn1_int32_value_decode(asn1, len, &value);
11863 proto_tree_add_text(tree, asn1->tvb,
11864 saved_offset, asn1->offset - saved_offset,
11870 param_pc_ssn(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11872 gint32 value, b1, b2, b3, b4;
11873 guint saved_offset;
11876 EXACT_DATA_CHECK(len, 5);
11878 add_string = add_string;
11879 saved_offset = asn1->offset;
11881 asn1_int32_value_decode(asn1, 1, &value);
11885 case 0: str = "Not specified"; break;
11886 case 1: str = "Serving MSC"; break;
11887 case 2: str = "Home MSC"; break;
11888 case 3: str = "Gateway MSC"; break;
11889 case 4: str = "HLR"; break;
11890 case 5: str = "VLR"; break;
11891 case 6: str = "EIR (reserved)"; break;
11892 case 7: str = "AC"; break;
11893 case 8: str = "Border MSC"; break;
11894 case 9: str = "Originating MSC"; break;
11896 if ((value >= 10) && (value <= 223)) { str = "Reserved, treat as Not specified"; }
11897 else { str = "Reserved for protocol extension, treat as Not specified"; }
11901 proto_tree_add_text(tree, asn1->tvb,
11902 saved_offset, asn1->offset - saved_offset,
11907 asn1_int32_value_decode(asn1, 1, &b1);
11908 asn1_int32_value_decode(asn1, 1, &b2);
11909 asn1_int32_value_decode(asn1, 1, &b3);
11910 asn1_int32_value_decode(asn1, 1, &b4);
11912 proto_tree_add_text(tree, asn1->tvb,
11913 saved_offset, asn1->offset - saved_offset,
11914 "Point Code %u-%u-%u SSN %u",
11919 param_lai(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11922 guint saved_offset;
11924 EXACT_DATA_CHECK(len, 2);
11926 add_string = add_string;
11927 saved_offset = asn1->offset;
11929 asn1_int32_value_decode(asn1, 2, &value);
11931 proto_tree_add_text(tree, asn1->tvb,
11932 saved_offset, asn1->offset - saved_offset,
11939 param_list(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string)
11941 guint saved_offset;
11944 add_string = add_string;
11946 saved_offset = asn1->offset;
11948 while (len > (asn1->offset - saved_offset))
11952 if (!dissect_ansi_param(asn1, tree))
11954 proto_tree_add_text(tree,
11955 asn1->tvb, asn1->offset, len - (asn1->offset - saved_offset),
11956 "Unknown Parameter Data");
11958 asn1->offset = saved_offset + len;
11963 sprintf(add_string, " - (%u)", num_parms);
11967 #define NUM_PARAM_1 (sizeof(ansi_param_1_strings)/sizeof(value_string))
11968 static gint ett_ansi_param_1[NUM_PARAM_1];
11969 static void (*param_1_fcn[])(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string) = {
11970 param_bill_id, /* Billing ID */
11971 param_int, /* Serving Cell ID */
11972 param_int, /* Target Cell ID */
11973 param_digits, /* Digits */
11974 param_chan_data, /* Channel Data */
11975 param_cic, /* Inter MSC Circuit ID */
11976 param_int, /* Inter Switch Count */
11977 param_min, /* Mobile Identification Number */
11978 param_esn, /* Electronic Serial Number */
11979 param_rel_reason, /* Release Reason */
11980 param_sig_qual, /* Signal Quality */
11981 param_scm, /* Station Class Mark */
11982 param_auth_den, /* Authorization Denied */
11983 param_auth_per, /* Authorization Period */
11984 param_seizure, /* Seizure Type */
11985 param_trunk_stat, /* Trunk Status */
11986 param_qic, /* Qualification Information Code */
11987 param_feat_result, /* Feature Result */
11988 param_red_reason, /* Redirection Reason */
11989 param_acc_den, /* Access Denied Reason */
11990 param_mscid, /* MSCID */
11991 param_sys_type_code, /* System My Type Code */
11992 param_orig_ind, /* Origination Indicator */
11993 param_term_res, /* Termination Restriction Code */
11994 param_calling_feat_ind, /* Calling Features Indicator */
11995 param_faulty, /* Faulty Parameter */
11996 param_usage_ind, /* Usage Indicator */
11997 param_tdma_chan_data, /* TDMA Channel Data */
11998 param_tdma_call_mode, /* TDMA Call Mode */
11999 param_ho_reason, /* Handoff Reason */
12004 #define NUM_PARAM_2 (sizeof(ansi_param_2_strings)/sizeof(value_string))
12005 static gint ett_ansi_param_2[NUM_PARAM_2];
12006 static void (*param_2_fcn[])(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string) = {
12007 param_tdma_burst_ind, /* TDMA Burst Indicator */
12008 param_pc_ssn, /* PC_SSN */
12009 param_lai, /* Location Area ID */
12010 param_sys_acc_type, /* System Access Type */
12011 param_auth_resp_all, /* Authentication Response */
12012 param_auth_resp_all, /* Authentication Response Base Station */
12013 param_auth_resp_all, /* Authentication Response Unique Challenge */
12014 param_int, /* Call History Count */
12015 param_confid_mode, /* Confidentiality Modes */
12016 param_int, /* Random Variable */
12017 param_int, /* Random Variable Base station */
12018 param_rand_ssd, /* Random Variable SSD */
12019 param_rand_unique, /* Random Variable Unique Challenge */
12020 param_report_type, /* Report Type */
12021 param_sme_key, /* Signaling Message Encryption Key */
12022 param_ssd, /* Shared Secret Data */
12023 param_term_type, /* Terminal Type */
12024 param_vpmask, /* Voice Privacy Mask */
12025 param_sys_cap, /* System Capabilities */
12026 param_deny_acc, /* Deny Access */
12027 param_upd_count, /* Update Count */
12028 param_ssd_no_share, /* SSD Not Shared */
12029 param_ext_mscid, /* Extended MSCID */
12030 param_ext_sys_type_code, /* Extended System My Type Code */
12031 param_ctrl_chan_data, /* Control Channel Data */
12032 param_sys_acc_data, /* System Access Data */
12033 param_can_den, /* Cancellation Denied */
12034 param_border_acc, /* Border Cell Access */
12035 param_cdma_scm, /* CDMA Station Class Mark */
12036 param_int, /* CDMA Serving One Way Delay */
12037 param_int, /* CDMA Target One Way Delay */
12038 param_cdma_call_mode, /* CDMA Call Mode */
12039 param_cdma_chan_data, /* CDMA Channel Data */
12040 param_cdma_sig_qual, /* CDMA Signal Quality */
12041 param_cdma_pilot_strength, /* CDMA Pilot Strength */
12042 param_mob_rev, /* CDMA Mobile Protocol Revision */
12043 param_cdma_plcm, /* CDMA Private Long Code Mask */
12044 param_cdma_code_chan, /* CDMA Code Channel */
12045 param_cdma_sea_win, /* CDMA Search Window */
12046 param_ms_loc, /* MS Location */
12047 param_page_ind, /* Page Indicator */
12048 param_rec_sig_qual, /* Received Signal Quality */
12049 param_dereg, /* Deregistration Type */
12050 param_namps_chan_data, /* NAMPS Channel Data */
12051 param_alert_code, /* Alert Code */
12052 param_ann_code, /* Announcement Code */
12053 param_aav, /* Authentication Algorithm Version */
12054 param_auth_cap, /* Authentication Capability */
12055 param_int, /* Call History Count Expected */
12056 param_digits, /* Calling Party Number Digits 1 */
12057 param_digits, /* Calling Party Number Digits 2 */
12058 param_digits, /* Calling Party Number String 1 */
12059 param_digits, /* Calling Party Number String 2 */
12060 param_sub_addr, /* Calling Party Subaddress */
12061 param_can_type, /* Cancellation Type */
12062 param_digits, /* Carrier Digits */
12063 param_digits, /* Destination Digits */
12064 param_dmh_red_ind, /* DMH Redirection Indicator */
12065 param_list, /* Inter System Termination */
12066 param_avail_type, /* Availability Type */
12067 param_list, /* Local Termination */
12068 param_mw_noti_count, /* Message Waiting Notification Count */
12069 param_digits, /* Mobile Directory Number */
12070 param_digits, /* MSCID Number */
12071 param_list, /* PSTN Termination */
12072 param_no_ans_time, /* No Answer Time */
12073 param_otfi, /* One Time Feature Indicator */
12074 param_orig_trig, /* Origination Triggers */
12075 param_randc, /* RANDC */
12076 param_digits, /* Redirecting Number Digits */
12077 param_digits, /* Redirecting Number String */
12078 param_sub_addr, /* Redirecting Number Subaddress */
12079 param_digits, /* Sender Identification Number */
12080 param_digits, /* SMS Address */
12081 param_sms_bd, /* SMS Bearer Data */
12082 param_sms_charge_ind, /* SMS Charge Indicator */
12083 param_digits, /* SMS Destination Address */
12084 param_sms_msg_count, /* SMS Message Count */
12085 param_sms_noti, /* SMS Notification Indicator */
12086 param_digits, /* SMS Original Destination Address */
12087 param_sub_addr, /* SMS Original Destination Subaddress */
12088 param_digits, /* SMS Original Originating Address */
12089 param_sub_addr, /* SMS Original Originating Subaddress */
12090 param_digits, /* SMS Originating Address */
12091 param_sms_orig_restric, /* SMS Originating Restrictions */
12092 param_sms_tele, /* SMS Teleservice Identifier */
12093 param_sms_term_restric, /* SMS Termination Restrictions */
12094 NULL/* no data */, /* SMS Message Waiting Indicator */
12095 param_term_acc_type, /* Termination Access Type */
12096 param_list, /* Termination List */
12097 param_term_treat, /* Termination Treatment */
12098 param_term_trig, /* Termination Triggers */
12099 param_trans_cap, /* Transaction Capability */
12100 param_unique_chal_rep, /* Unique Challenge Report */
12105 #define NUM_PARAM_3 (sizeof(ansi_param_3_strings)/sizeof(value_string))
12106 static gint ett_ansi_param_3[NUM_PARAM_3];
12107 static void (*param_3_fcn[])(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string) = {
12108 param_act_code, /* Action Code */
12109 param_alert_res, /* Alert Result */
12110 param_list, /* Announcement List */
12111 param_list, /* CDMA Code Channel Information */
12112 param_list, /* CDMA Code Channel List */
12113 param_list, /* CDMA Target Measurement Information */
12114 param_list, /* CDMA Target Measurement List */
12115 param_list, /* CDMA Target MAHO Information */
12116 param_list, /* CDMA Target MAHO List */
12117 param_conf_call_ind, /* Conference Calling Indicator */
12118 param_count_upd_report, /* Count Update Report */
12119 param_digit_collect_ctrl, /* Digit Collection Control */
12120 param_digits, /* DMH Account Code Digits */
12121 param_digits, /* DMH Alternate Billing Digits */
12122 param_digits, /* DMH Billing Digits */
12123 param_geo_auth, /* Geographic Authorization */
12124 param_int, /* Leg Information */
12125 param_mw_noti_type, /* Message Waiting Notification Type */
12126 param_paca_ind, /* PACA Indicator */
12127 param_pref_lang_ind, /* Preferred Language Indicator */
12128 param_rand_valtime, /* Random Valid Time */
12129 param_digits, /* Restriction Digits */
12130 param_digits, /* Routing Digits */
12131 param_setup_result, /* Setup Result */
12132 param_sms_acc_den_reason, /* SMS Access Denied Reason */
12133 param_sms_cause, /* SMS Cause Code */
12134 param_digits, /* SPINI PIN */
12135 param_spini_trig, /* SPINI Triggers */
12136 param_ssd_upd_report, /* SSD Update Report */
12137 param_list, /* Target Measurement Information */
12138 param_list, /* Target Measurement List */
12139 param_digits, /* Voice Mailbox PIN */
12140 param_digits, /* Voice Mailbox Number */
12141 NULL/* no special handling */, /* Authentication Data */
12142 param_cond_den_reason, /* Conditionally Denied Reason */
12143 param_group_info, /* Group Information */
12144 param_ho_state, /* Handoff State */
12145 param_namps_call_mode, /* NAMPS Call Mode */
12146 param_cdma_sci, /* CDMA Slot Cycle Index */
12147 param_den_auth_per, /* Denied Authorization Period */
12148 param_digits, /* Pilot Number */
12149 param_bill_id, /* Pilot Billing ID */
12150 param_cdma_band_class, /* CDMA Band Class */
12151 param_imsi, /* International Mobile Subscriber Identity */
12152 param_calling_party_name, /* Calling Party Name */
12153 param_dis_text, /* Display Text */
12154 param_red_party_name, /* Redirecting Party Name */
12155 param_srvc_id, /* Service ID */
12156 param_all_or_none, /* All Or None */
12157 param_change, /* Change */
12158 param_list, /* Data Access Element */
12159 param_list, /* Data Access Element List */
12160 param_list, /* Data Update Result */
12161 param_list, /* Data Update Result List */
12162 param_cdma_pilot_pn, /* CDMA Pilot PN */
12163 NULL/* no special handling */, /* CDMA Service Configuration Record */
12164 param_cdma_so, /* CDMA Service Option */
12165 param_cdma_scm2, /* CDMA Station Class Mark 2 */
12166 param_tdma_sc, /* TDMA Service Code */
12167 param_tdma_term_cap, /* TDMA Terminal Capability */
12168 param_tdma_voice_coder, /* TDMA Voice Coder */
12169 param_a_key_ver, /* A-Key Protocol Version */
12170 NULL/* XXX what spec ? */, /* Authentication Response Reauthentication */
12171 NULL/* no special handling */, /* Base Station Partial Key */
12172 param_min, /* Mobile Station MIN */
12173 NULL/* no special handling */, /* Mobile Station Partial Key */
12174 NULL/* no special handling */, /* Modulus Value */
12175 param_min, /* Newly Assigned MIN */
12176 param_ota_result_code, /* OTASP Result Code */
12177 NULL/* no special handling */, /* Primitive Value */
12178 NULL/* XXX what spec ? */, /* Random Variable Reauthentication */
12179 NULL/* XXX what spec ? */, /* Reauthentication Report */
12180 param_srvc_ind, /* Service Indicator */
12181 param_sme_report, /* Signaling Message Encryption Report */
12182 param_trn, /* Temporary Reference Number */
12183 param_vp_report, /* Voice Privacy Report */
12184 param_ctrl_chan_mode, /* Control Channel Mode */
12185 NULL/* no special handling */, /* CDMA Connection Reference */
12186 param_list, /* CDMA Connection Reference Information */
12187 param_list, /* CDMA Connection Reference List */
12188 param_change_srvc_attr, /* Change Service Attributes */
12189 NULL/* no special handling */, /* Data Key */
12190 param_dp_params, /* Data Privacy Parameters */
12191 param_islp_info, /* ISLP Information */
12192 param_reason_list, /* Reason List */
12193 param_tdma_bandwidth, /* TDMA Bandwidth */
12194 param_tdma_data_feat_ind, /* TDMA Data Features Indicator */
12195 param_tdma_data_mode, /* TDMA Data Mode */
12196 param_tdma_voice_mode, /* TDMA Voice Mode */
12197 param_ana_red_info, /* Analog Redirect Info */
12198 param_list, /* CDMA Band Class Information */
12199 param_list, /* CDMA Band Class List */
12200 param_list, /* CDMA Service Option List */
12201 param_list, /* CDMA Connection Reference Information */
12202 param_list, /* CDMA Connection Reference List */
12203 param_list, /* Analog Redirect Record */
12204 param_list, /* Execute Script */
12205 param_list, /* Modification Request */
12206 param_list, /* Modification Request List */
12207 param_list, /* Modification Result List */
12208 param_list, /* Service Data Access Element */
12209 param_list, /* Service Data Access Element List */
12210 param_list, /* Service Data Result */
12211 param_list, /* Service Data Result List */
12212 param_list, /* Trigger Address List */
12213 param_list, /* Trigger List */
12214 param_list, /* WIN Capability */
12215 param_list, /* Call Recovery ID */
12216 param_list, /* Call Recovery ID List */
12217 param_list, /* Position Information */
12218 param_list, /* CDMA PSMM List */
12219 param_cdma_chan_num, /* CDMA Channel Number */
12220 param_list, /* CDMA Channel Number List */
12221 param_cdma_pci, /* CDMA Power Combined Indicator */
12222 param_list, /* CDMA Redirect Record */
12223 param_cdma_sea_param, /* CDMA Search Parameters */
12224 param_int, /* CDMA Network Identification */
12225 param_network_tmsi, /* Network TMSI */
12226 param_int, /* Network TMSI Expiration Time */
12227 param_network_tmsi, /* New Network TMSI */
12228 param_reqd_param_mask, /* Required Parameters Mask */
12229 param_srvc_red_cause, /* Service Redirection Cause */
12230 param_srvc_red_info, /* Service Redirection Info */
12231 param_roaming_ind, /* Roaming Indication */
12232 NULL/* XXX what spec ? */, /* MSID */
12233 NULL/* no special handling */, /* Data ID */
12234 NULL/* no special handling */, /* Database Key */
12235 param_data_result, /* Data Result */
12236 NULL/* no special handling */, /* Data Value */
12237 param_fail_cause, /* Failure Cause */
12238 param_fail_type, /* Failure Type */
12239 NULL/* no special handling */, /* Global Title */
12240 NULL/* no special handling */, /* Private Specialized Resource */
12241 param_resume_pic, /* Resume PIC */
12242 NULL/* no special handling */, /* Script Argument */
12243 NULL/* no special handling */, /* Script Name */
12244 NULL/* no special handling */, /* Script Result */
12245 param_special_rsc, /* Specialized Resource */
12246 param_time_date_offset, /* Time Date Offset */
12247 param_trig_cap, /* Trigger Capability */
12248 param_trig_type, /* Trigger Type */
12249 param_win_op_cap, /* WIN Operations Capability */
12250 param_win_trig_list, /* WIN Trigger List */
12251 param_digits, /* MSC Address */
12252 param_sus_acc, /* Suspicious Access */
12253 param_imsi, /* Mobile Station IMSI */
12254 param_imsi, /* Newly Assigned IMSI */
12255 NULL/* XXX what spec ? */, /* Command Code */
12256 param_dis_text2, /* Display Text 2 */
12257 NULL/* XXX what spec ? */, /* Page Count */
12258 NULL/* XXX what spec ? */, /* Page Response Time */
12259 NULL/* XXX what spec ? */, /* SMS Transaction ID */
12260 param_dmh_srvc_id, /* DMH Service ID */
12261 param_feat_ind, /* Feature Indicator */
12262 param_mscid, /* Control Network ID */
12263 param_rel_cause, /* Release Cause */
12264 param_time_day, /* Time Of Day */
12265 param_call_status, /* Call Status */
12266 NULL/* no special handling */, /* DMH Charge Information */
12267 NULL/* no special handling */, /* DMH Billing Indicator */
12268 param_ms_status, /* MS Status */
12269 param_pos_info_code, /* Position Information Code */
12270 param_inter_msg_time, /* Inter Message Time */
12271 param_msid_usage, /* MSID Usage */
12272 param_new_min_ext, /* New MIN Extension */
12273 param_dtx_ind, /* DTX Indication */
12274 param_cdma_mob_cap, /* CDMA Mobile Capabilities */
12275 param_gen_time, /* Generalized Time */
12276 param_digits, /* Generic Digits */
12277 param_geo_pos, /* Geographic Position */
12278 param_mob_call_status, /* Mobile Call Status */
12279 param_mob_cap, /* Mobile Position Capability */
12280 param_pos_req_type, /* Position Request Type */
12281 param_pos_result, /* Position Result */
12282 param_pos_source, /* Position Source */
12283 param_acg_encounter, /* ACG Encountered */
12284 param_ctrl_type, /* CDMA State/Control Type */
12285 param_gap_duration, /* Gap Duration */
12286 param_scf_overload_gap_int, /* SCF Overload Gap Interval */
12287 param_sm_gap_int, /* Service Management System Gap Interval */
12288 param_cdma_psmm_count, /* CDMA PSMM Count */
12289 param_cdma_sowd2, /* CDMA Serving One Way Delay 2 */
12290 param_qos_pri, /* QoS Priority */
12291 NULL/* no special handling */, /* PDSN Address */
12292 NULL/* no special handling */, /* PDSN Protocol Type */
12293 param_cdma_ms_meas_chan_id, /* CDMA MS Measured Channel Identity */
12294 NULL/* no special handling */, /* Range */
12295 param_calling_party_cat, /* Calling Party Category */
12296 param_cdma2000_ho_ivk_ios, /* cdma2000 Handoff Invoke IOS Data */
12297 param_cdma2000_ho_rsp_ios, /* cdma2000 Handoff Response IOS Data */
12298 param_digits, /* LCS Client ID */
12299 param_tdma_maho_cell_id, /* TDMA MAHO Cell ID */
12300 param_tdma_maho_chan, /* TDMA MAHO Channel */
12301 param_cdma_soci, /* CDMA Service Option Connection Identifier */
12302 param_tdma_time_align, /* TDMA Time Alignment */
12303 param_tdma_maho_req, /* TDMA MAHO Request */
12307 /* GENERIC MAP DISSECTOR FUNCTIONS */
12310 dissect_ansi_map_len(ASN1_SCK *asn1, proto_tree *tree, gboolean *def_len, guint *len)
12312 guint saved_offset;
12316 saved_offset = asn1->offset;
12320 ret = asn1_length_decode(asn1, def_len, len);
12324 proto_tree_add_uint(tree, hf_ansi_map_length, asn1->tvb,
12325 saved_offset, asn1->offset - saved_offset,
12330 proto_tree_add_text(tree, asn1->tvb,
12331 saved_offset, asn1->offset - saved_offset,
12332 "Length: Indefinite");
12338 check_ansi_map_tag(ASN1_SCK *asn1, guint tag)
12340 guint saved_offset, real_tag;
12343 saved_offset = asn1->offset;
12345 asn1_id_decode1(asn1, &real_tag);
12347 asn1->offset = saved_offset;
12349 return(tag == real_tag);
12353 dissect_ansi_map_octet(ASN1_SCK *asn1, proto_tree *tree, guchar * str)
12355 guint saved_offset;
12359 saved_offset = asn1->offset;
12361 asn1_octet_decode(asn1, &my_oct);
12363 proto_tree_add_uint_format(tree, hf_ansi_map_id, asn1->tvb,
12364 saved_offset, asn1->offset - saved_offset, my_oct,
12369 static proto_tree *
12370 dissect_ansi_map_component(ASN1_SCK *asn1, proto_tree *tree, guint *len_p)
12372 guint saved_offset;
12375 proto_tree *subtree;
12379 saved_offset = asn1->offset;
12380 asn1_id_decode1(asn1, &tag);
12383 proto_tree_add_text(tree, asn1->tvb,
12384 saved_offset, -1, "Component ID");
12386 subtree = proto_item_add_subtree(item, ett_component);
12388 proto_tree_add_uint_format(subtree, hf_ansi_map_tag, asn1->tvb,
12389 saved_offset, asn1->offset - saved_offset, tag,
12390 "Component ID Identifier");
12392 dissect_ansi_map_len(asn1, subtree, &def_len, len_p);
12394 proto_item_set_len(item, (asn1->offset - saved_offset) + *len_p);
12400 dissect_ansi_opr_code(ASN1_SCK *asn1, packet_info *pinfo, proto_tree *tree)
12402 static ansi_map_tap_rec_t tap_rec;
12403 guint saved_offset = 0;
12410 proto_tree *subtree;
12414 #define TCAP_NAT_OPR_CODE_TAG 0xd0
12415 if (check_ansi_map_tag(asn1, TCAP_NAT_OPR_CODE_TAG))
12417 str = "National TCAP Operation Code Identifier";
12419 #define TCAP_PRIV_OPR_CODE_TAG 0xd1
12420 else if (check_ansi_map_tag(asn1, TCAP_PRIV_OPR_CODE_TAG))
12422 str = "Private TCAP Operation Code Identifier";
12430 saved_offset = asn1->offset;
12431 asn1_id_decode1(asn1, &tag);
12434 proto_tree_add_text(tree, asn1->tvb,
12435 saved_offset, -1, "Operation Code");
12437 subtree = proto_item_add_subtree(item, ett_opr_code);
12439 proto_tree_add_uint_format(subtree, hf_ansi_map_tag, asn1->tvb,
12440 saved_offset, asn1->offset - saved_offset, tag, str);
12442 dissect_ansi_map_len(asn1, subtree, &def_len, &len);
12443 proto_item_set_len(item, (asn1->offset - saved_offset) + len);
12447 saved_offset = asn1->offset;
12448 asn1_octet_decode(asn1, &my_oct);
12450 #define ANSI_MAP_OPR_FAMILY 0x09
12451 if (my_oct != ANSI_MAP_OPR_FAMILY)
12453 asn1->offset = saved_offset;
12457 proto_tree_add_text(subtree, asn1->tvb,
12458 saved_offset, 1, "Operation Code Family");
12460 saved_offset = asn1->offset;
12461 asn1_int32_value_decode(asn1, len-1, &val);
12462 proto_tree_add_int(subtree, hf_ansi_map_opr_code, asn1->tvb,
12463 saved_offset, asn1->offset - saved_offset, val);
12465 str = match_strval(val, ansi_map_opr_code_strings);
12467 if (NULL == str) return;
12469 tap_rec.message_type = val;
12471 tap_queue_packet(ansi_map_tap, pinfo, &tap_rec);
12473 if (check_col(pinfo->cinfo, COL_INFO))
12475 col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", str);
12481 dissect_ansi_problem(ASN1_SCK *asn1, proto_tree *tree)
12483 guint saved_offset = 0;
12486 proto_tree *subtree;
12487 proto_item *item = NULL;
12489 gchar *type_str = NULL;
12494 #define TCAP_PROB_CODE_TAG 0xd5
12495 if (check_ansi_map_tag(asn1, TCAP_PROB_CODE_TAG))
12497 str = "Problem Code Identifier";
12505 saved_offset = asn1->offset;
12506 asn1_id_decode1(asn1, &tag);
12509 proto_tree_add_text(tree, asn1->tvb,
12510 saved_offset, -1, "Problem Code");
12512 subtree = proto_item_add_subtree(item, ett_problem);
12514 proto_tree_add_uint_format(subtree, hf_ansi_map_tag, asn1->tvb,
12515 saved_offset, asn1->offset - saved_offset, tag, str);
12517 dissect_ansi_map_len(asn1, subtree, &def_len, &len);
12518 proto_item_set_len(item, (asn1->offset - saved_offset) + len);
12522 proto_tree_add_text(subtree, asn1->tvb,
12523 asn1->offset, len, "Unknown encoding of Problem Code");
12525 asn1->offset += len;
12529 saved_offset = asn1->offset;
12530 asn1_int32_value_decode(asn1, 1, &type);
12531 asn1_int32_value_decode(asn1, 1, &spec);
12535 case 0: type_str = "Not used"; break;
12538 type_str = "General";
12541 case 1: str = "Unrecognized Component Type"; break;
12542 case 2: str = "Incorrect Component Portion"; break;
12543 case 3: str = "Badly Structured Component Portion"; break;
12551 type_str = "Invoke";
12554 case 1: str = "Duplicate Invoke ID"; break;
12555 case 2: str = "Unrecognized Operation Code"; break;
12556 case 3: str = "Incorrect Parameter"; break;
12557 case 4: str = "Unrecognized Correlation ID"; break;
12565 type_str = "Return Result";
12568 case 1: str = "Unrecognized Correlation ID"; break;
12569 case 2: str = "Unexpected Return Result"; break;
12570 case 3: str = "Incorrect Parameter"; break;
12578 type_str = "Return Error";
12581 case 1: str = "Unrecognized Correlation ID"; break;
12582 case 2: str = "Unexpected Return Error"; break;
12583 case 3: str = "Unrecognized Error"; break;
12584 case 4: str = "Unexpected Error"; break;
12585 case 5: str = "Incorrect Parameter"; break;
12593 type_str = "Transaction Portion";
12596 case 1: str = "Unrecognized Package Type"; break;
12597 case 2: str = "Incorrect Transaction Portion"; break;
12598 case 3: str = "Badly Structured Transaction Portion"; break;
12599 case 4: str = "Unrecognized Transaction ID"; break;
12600 case 5: str = "Permission to Release"; break;
12601 case 6: str = "Resource Unavailable"; break;
12609 type_str = "Undefined";
12613 if (spec == 255) { str = "Reserved"; }
12614 else if (spec == 0) { str = "Not used"; }
12616 proto_tree_add_text(subtree, asn1->tvb,
12617 saved_offset, 1, "Problem Type %s", type_str);
12619 proto_tree_add_text(subtree, asn1->tvb,
12620 saved_offset + 1, 1, "Problem Specifier %s", str);
12624 dissect_ansi_error(ASN1_SCK *asn1, proto_tree *tree)
12626 guint saved_offset = 0;
12630 proto_tree *subtree;
12631 proto_item *item = NULL;
12636 #define TCAP_NAT_ERR_CODE_TAG 0xd3
12637 if (check_ansi_map_tag(asn1, TCAP_NAT_ERR_CODE_TAG))
12639 str = "National TCAP Error Code Identifier";
12641 #define TCAP_PRIV_ERR_CODE_TAG 0xd4
12642 else if (check_ansi_map_tag(asn1, TCAP_PRIV_ERR_CODE_TAG))
12644 str = "Private TCAP Error Code Identifier";
12652 saved_offset = asn1->offset;
12653 asn1_id_decode1(asn1, &tag);
12656 proto_tree_add_text(tree, asn1->tvb,
12657 saved_offset, -1, "TCAP Error Code");
12659 subtree = proto_item_add_subtree(item, ett_error);
12661 proto_tree_add_uint_format(subtree, hf_ansi_map_tag, asn1->tvb,
12662 saved_offset, asn1->offset - saved_offset, tag, str);
12664 dissect_ansi_map_len(asn1, subtree, &def_len, &len);
12665 proto_item_set_len(item, (asn1->offset - saved_offset) + len);
12667 if ((tag == TCAP_PRIV_ERR_CODE_TAG) &&
12670 saved_offset = asn1->offset;
12671 asn1_int32_value_decode(asn1, 1, &value);
12675 case 0x81: str = "Unrecognized MIN"; break;
12676 case 0x82: str = "Unrecognized ESN"; break;
12677 case 0x83: str = "MIN/HLR Mismatch"; break;
12678 case 0x84: str = "Operation Sequence Problem"; break;
12679 case 0x85: str = "Resource Shortage"; break;
12680 case 0x86: str = "Operation Not Supported"; break;
12681 case 0x87: str = "Trunk Unavailable"; break;
12682 case 0x88: str = "Parameter Error"; break;
12683 case 0x89: str = "System Failure"; break;
12684 case 0x8a: str = "Unrecognized Parameter Value"; break;
12685 case 0x8b: str = "Feature Inactive"; break;
12686 case 0x8c: str = "Missing Parameter"; break;
12688 if ((value >= 0xe0) && (value <= 0xff)) { str = "Reserved for protocol extension"; }
12689 else { str = "Reserved"; }
12693 proto_tree_add_text(subtree, asn1->tvb,
12694 saved_offset, 1, str);
12698 proto_tree_add_text(subtree, asn1->tvb,
12699 asn1->offset, len, "Error Code");
12701 asn1->offset += len;
12707 dissect_ansi_param(ASN1_SCK *asn1, proto_tree *tree)
12709 void (*param_fcn)(ASN1_SCK *asn1, proto_tree *tree, guint len, gchar *add_string) = NULL;
12710 guint saved_offset = 0;
12712 proto_tree *subtree;
12716 gint ett_param_idx, idx;
12720 saved_offset = asn1->offset;
12722 asn1_uint32_value_decode(asn1, 1, &val);
12723 str = my_match_strval((guint32) val, ansi_param_1_strings, &idx);
12727 asn1->offset = saved_offset;
12728 asn1_uint32_value_decode(asn1, 2, &val);
12730 str = my_match_strval((guint32) val, ansi_param_2_strings, &idx);
12734 asn1->offset = saved_offset;
12735 asn1_int32_value_decode(asn1, 3, &val);
12737 str = my_match_strval((guint32) val, ansi_param_3_strings, &idx);
12741 if (((val >= 0x9FFF00) && (val <= 0x9FFF7F)) ||
12742 ((val >= 0xBFFF00) && (val <= 0xBFFF7F)))
12744 str = "Reserved for protocol extension";
12746 else if (((val >= 0x9FFE76) && (val <= 0x9FFE7F)) ||
12747 ((val >= 0xBFFE76) && (val <= 0xBFFE7F)))
12749 str = "Reserved for National Network Use";
12753 str = "Unknown Parameter Data";
12757 ett_param_idx = ett_param;
12761 ett_param_idx = ett_ansi_param_3[idx];
12762 param_fcn = param_3_fcn[idx];
12767 ett_param_idx = ett_ansi_param_2[idx];
12768 param_fcn = param_2_fcn[idx];
12773 ett_param_idx = ett_ansi_param_1[idx];
12774 param_fcn = param_1_fcn[idx];
12778 proto_tree_add_text(tree, asn1->tvb,
12779 saved_offset, -1, str);
12781 subtree = proto_item_add_subtree(item, ett_param_idx);
12783 proto_tree_add_uint_format(subtree, hf_ansi_map_param_id, asn1->tvb,
12784 saved_offset, asn1->offset - saved_offset, val, "Parameter ID");
12786 dissect_ansi_map_len(asn1, subtree, &def_len, &len);
12788 proto_item_set_len(item, asn1->offset - saved_offset + len);
12792 if (param_fcn == NULL)
12794 proto_tree_add_text(subtree, asn1->tvb,
12795 asn1->offset, len, "Parameter Data");
12796 asn1->offset += len;
12800 ansi_map_add_string[0] = '\0';
12802 (*param_fcn)(asn1, subtree, len, ansi_map_add_string);
12804 if (ansi_map_add_string[0] != '\0')
12806 proto_item_append_text(item, ansi_map_add_string);
12807 ansi_map_add_string[0] = '\0';
12817 dissect_ansi_params(ASN1_SCK *asn1, proto_tree *tree)
12819 guint saved_offset = 0;
12822 proto_tree *subtree;
12823 proto_item *item = NULL;
12827 #define TCAP_PARAM_SET_TAG 0xf2
12828 if (check_ansi_map_tag(asn1, TCAP_PARAM_SET_TAG))
12830 str = "Parameter Set Identifier";
12832 #define TCAP_PARAM_SEQ_TAG 0x30
12833 else if (check_ansi_map_tag(asn1, TCAP_PARAM_SEQ_TAG))
12835 str = "Parameter Sequence Identifier";
12843 saved_offset = asn1->offset;
12844 asn1_id_decode1(asn1, &tag);
12847 proto_tree_add_text(tree, asn1->tvb,
12848 saved_offset, -1, "Parameters");
12850 subtree = proto_item_add_subtree(item, ett_params);
12852 proto_tree_add_uint_format(subtree, hf_ansi_map_tag, asn1->tvb,
12853 saved_offset, asn1->offset - saved_offset, tag, str);
12855 dissect_ansi_map_len(asn1, subtree, &def_len, &len);
12856 proto_item_set_len(item, (asn1->offset - saved_offset) + len);
12858 ansi_map_add_string[0] = '\0';
12860 param_list(asn1, subtree, len, ansi_map_add_string);
12862 if (ansi_map_add_string[0] != '\0')
12864 proto_item_append_text(item, ansi_map_add_string);
12865 ansi_map_add_string[0] = '\0';
12870 dissect_ansi_map_reject(ASN1_SCK *asn1, proto_tree *tree)
12873 proto_tree *subtree;
12875 #define COMPONENT_ID_TAG 0xcf
12876 if (check_ansi_map_tag(asn1, COMPONENT_ID_TAG))
12878 subtree = dissect_ansi_map_component(asn1, tree, &len);
12883 dissect_ansi_map_octet(asn1, subtree, "Correlation ID:");
12888 dissect_ansi_problem(asn1, tree);
12890 dissect_ansi_params(asn1, tree);
12894 dissect_ansi_map_re(ASN1_SCK *asn1, proto_tree *tree)
12897 proto_tree *subtree;
12899 #define COMPONENT_ID_TAG 0xcf
12900 if (check_ansi_map_tag(asn1, COMPONENT_ID_TAG))
12902 subtree = dissect_ansi_map_component(asn1, tree, &len);
12907 dissect_ansi_map_octet(asn1, subtree, "Correlation ID:");
12912 dissect_ansi_error(asn1, tree);
12914 dissect_ansi_params(asn1, tree);
12918 dissect_ansi_map_rr(ASN1_SCK *asn1, proto_tree *tree)
12921 proto_tree *subtree;
12923 #define COMPONENT_ID_TAG 0xcf
12924 if (check_ansi_map_tag(asn1, COMPONENT_ID_TAG))
12926 subtree = dissect_ansi_map_component(asn1, tree, &len);
12931 dissect_ansi_map_octet(asn1, subtree, "Correlation ID:");
12936 dissect_ansi_params(asn1, tree);
12940 dissect_ansi_map_invoke(ASN1_SCK *asn1, packet_info *pinfo, proto_tree *tree)
12943 proto_tree *subtree;
12945 #define COMPONENT_ID_TAG 0xcf
12946 if (check_ansi_map_tag(asn1, COMPONENT_ID_TAG))
12948 subtree = dissect_ansi_map_component(asn1, tree, &len);
12953 dissect_ansi_map_octet(asn1, subtree, "Invoke ID:");
12957 dissect_ansi_map_octet(asn1, subtree, "Invoke ID:");
12958 dissect_ansi_map_octet(asn1, subtree, "Correlation ID:");
12963 ansi_map_is_invoke = TRUE;
12965 dissect_ansi_opr_code(asn1, pinfo, tree);
12967 dissect_ansi_params(asn1, tree);
12971 dissect_ansi_map_message(ASN1_SCK *asn1, packet_info *pinfo, proto_tree *ansi_map_tree)
12973 guint saved_offset;
12977 proto_item *item, *tag_item;
12978 proto_tree *subtree, *tag_subtree;
12983 saved_offset = asn1->offset;
12984 asn1_id_decode1(asn1, &tag);
12986 str = match_strval(tag, ansi_cmp_type_strings);
12988 if (NULL == str) return;
12990 if (check_col(pinfo->cinfo, COL_INFO))
12994 col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", str);
12998 col_append_fstr(pinfo->cinfo, COL_INFO, "& %s ", str);
13003 proto_tree_add_text(ansi_map_tree, asn1->tvb,
13004 saved_offset, -1, "Components");
13005 subtree = proto_item_add_subtree(item, ett_components);
13008 proto_tree_add_uint_format(subtree, hf_ansi_map_tag, asn1->tvb,
13009 saved_offset, asn1->offset - saved_offset, tag, str);
13011 dissect_ansi_map_len(asn1, subtree, &def_len, &len);
13013 tag_subtree = proto_item_add_subtree(tag_item, ett_components);
13017 case ANSI_TC_INVOKE_L:
13018 dissect_ansi_map_invoke(asn1, pinfo, tag_subtree);
13022 dissect_ansi_map_rr(asn1, tag_subtree);
13026 dissect_ansi_map_re(asn1, tag_subtree);
13029 case ANSI_TC_REJECT:
13030 dissect_ansi_map_reject(asn1, tag_subtree);
13033 case ANSI_TC_INVOKE_N:
13034 dissect_ansi_map_invoke(asn1, pinfo, tag_subtree);
13038 dissect_ansi_map_rr(asn1, tag_subtree);
13045 proto_item_set_len(item, asn1->offset - saved_offset);
13049 dissect_ansi_map(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
13051 proto_item *ansi_map_item;
13052 proto_tree *ansi_map_tree = NULL;
13059 * Make entry in the Protocol column on summary display
13061 if (check_col(pinfo->cinfo, COL_PROTOCOL))
13063 col_set_str(pinfo->cinfo, COL_PROTOCOL, "ANSI MAP");
13066 /* In the interest of speed, if "tree" is NULL, don't do any work not
13067 * necessary to generate protocol tree items.
13074 * create the ansi_map protocol tree
13077 proto_tree_add_item(tree, proto_ansi_map, tvb, 0, -1, FALSE);
13080 proto_item_add_subtree(ansi_map_item, ett_ansi_map);
13082 asn1_open(&asn1, tvb, offset);
13084 ansi_map_is_invoke = FALSE;
13086 dissect_ansi_map_message(&asn1, pinfo, ansi_map_tree);
13088 asn1_close(&asn1, &offset);
13093 /* Register the protocol with Ethereal */
13095 proto_register_ansi_map(void)
13100 /* Setup list of header fields */
13101 static hf_register_info hf[] =
13103 { &hf_ansi_map_tag,
13104 { "Tag", "ansi_map.tag",
13105 FT_UINT8, BASE_HEX, NULL, 0,
13108 { &hf_ansi_map_length,
13109 { "Length", "ansi_map.len",
13110 FT_UINT8, BASE_DEC, NULL, 0,
13114 { "Value", "ansi_map.id",
13115 FT_UINT8, BASE_DEC, NULL, 0,
13118 { &hf_ansi_map_opr_code,
13119 { "Operation Code", "ansi_map.oprcode",
13120 FT_INT32, BASE_DEC, VALS(ansi_map_opr_code_strings), 0,
13123 { &hf_ansi_map_param_id,
13124 { "Param ID", "ansi_map.param_id",
13125 FT_UINT32, BASE_HEX, NULL, 0,
13128 { &hf_ansi_map_ios401_elem_id,
13129 { "IOS 4.0.1 Element ID", "ansi_map.ios401_elem_id",
13130 FT_NONE, 0, NULL, 0,
13135 /* Setup protocol subtree array */
13136 #define NUM_INDIVIDUAL_PARAMS 15
13137 gint *ett[NUM_INDIVIDUAL_PARAMS+NUM_PARAM_1+NUM_PARAM_2+NUM_PARAM_3+NUM_IOS401_ELEM];
13139 memset((void *) ett, -1, sizeof(ett));
13141 ett[0] = &ett_ansi_map;
13142 ett[1] = &ett_opr_code;
13143 ett[2] = &ett_component;
13144 ett[3] = &ett_components;
13145 ett[4] = &ett_param;
13146 ett[5] = &ett_params;
13147 ett[6] = &ett_error;
13148 ett[7] = &ett_problem;
13149 ett[8] = &ett_natnum;
13150 ett[9] = &ett_call_mode;
13151 ett[10] = &ett_chan_data;
13152 ett[11] = &ett_code_chan;
13153 ett[12] = &ett_clr_dig_mask;
13154 ett[13] = &ett_ent_dig_mask;
13155 ett[14] = &ett_all_dig_mask;
13157 last_offset = NUM_INDIVIDUAL_PARAMS;
13159 for (i=0; i < NUM_PARAM_1; i++, last_offset++)
13161 ett[last_offset] = &ett_ansi_param_1[i];
13164 for (i=0; i < NUM_PARAM_2; i++, last_offset++)
13166 ett[last_offset] = &ett_ansi_param_2[i];
13169 for (i=0; i < NUM_PARAM_3; i++, last_offset++)
13171 ett[last_offset] = &ett_ansi_param_3[i];
13174 for (i=0; i < NUM_IOS401_ELEM; i++, last_offset++)
13176 ett[last_offset] = &ett_ansi_map_ios401_elem[i];
13179 /* Register the protocol name and description */
13181 proto_register_protocol("ANSI Mobile Application Part",
13182 "ANSI MAP", "ansi_map");
13184 is637_tele_id_dissector_table =
13185 register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID",
13186 FT_UINT8, BASE_DEC);
13188 is683_dissector_table =
13189 register_dissector_table("ansi_map.ota", "IS-683-A (OTA)",
13190 FT_UINT8, BASE_DEC);
13192 /* Required function calls to register the header fields and subtrees used */
13193 proto_register_field_array(proto_ansi_map, hf, array_length(hf));
13194 proto_register_subtree_array(ett, array_length(ett));
13196 ansi_map_tap = register_tap("ansi_map");
13201 proto_reg_handoff_ansi_map(void)
13203 dissector_handle_t ansi_map_handle;
13205 ansi_map_handle = create_dissector_handle(dissect_ansi_map, proto_ansi_map);
13207 dissector_add("tcap.ansi_ssn", 5, ansi_map_handle);
13208 dissector_add("tcap.ansi_ssn", 6, ansi_map_handle);
13209 dissector_add("tcap.ansi_ssn", 7, ansi_map_handle);
13210 dissector_add("tcap.ansi_ssn", 8, ansi_map_handle);
13211 dissector_add("tcap.ansi_ssn", 9 , ansi_map_handle);
13212 dissector_add("tcap.ansi_ssn", 10 , ansi_map_handle);
13213 dissector_add("tcap.ansi_ssn", 11 , ansi_map_handle);
13214 dissector_add("tcap.ansi_ssn", 12 , ansi_map_handle);
13216 data_handle = find_dissector("data");