packet-ansi_map.c

   1 /* packet-ansi_map.c
   2  * Routines for ANSI 41 Mobile Application Part (IS41 MAP) dissection
   3  * Specications from 3GPP2 (www.3gpp2.org)
   4  *
   5  * Copyright 2003, Michael Lum <mlum [AT] telostech.com>
   6  * In association with Telos Technology Inc.
   7  *
   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, ...
  10  *
  11  * Title                3GPP2                   Other
  12  *
  13  *   Cellular Radiotelecommunications Intersystem Operations
  14  *                      3GPP2 N.S0005-0         ANSI/TIA/EIA-41-D
  15  *
  16  *   Network Support for MDN-Based Message Centers
  17  *                      3GPP2 N.S0024-0 v1.0    IS-841
  18  *
  19  *   Enhanced International Calling
  20  *                      3GPP2 N.S0027           IS-875
  21  *
  22  *   E-911 Phase 2
  23  *                      3GPP2 N.S0030           J-STD-036-A
  24  *      XXX Teleservice_Priority not implemented, no parameter ID given!
  25  *
  26  *   ANSI-41-D Miscellaneous Enhancements Revision 0
  27  *                      3GPP2 N.S0015           PN-3590 (ANSI-41-E)
  28  *
  29  *   TIA/EIA-41-D Internationalization
  30  *                      3GPP2 N.S0016-0 v1.0
  31  *
  32  *   Authentication Enhancements
  33  *                      3GPP2 N.S0014-0 v1.0    IS-778
  34  *
  35  *   PCS Multi-band-Based on IS-41C
  36  *                      3GPP2 N.S0006-0 v1.0    TIA/EIA TSB-76
  37  *
  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!
  41  *
  42  *   Features In CDMA
  43  *                      3GPP2 N.S0010-0 v1.0    IS-735
  44  *
  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
  47  *
  48  *   OTASP and OTAPA
  49  *                      3GPP2 N.S0011-0 v1.0    IS-725-A
  50  *
  51  *   Circuit Mode Services
  52  *                      3GPP2 N.S0008-0 v1.0    IS-737
  53  *      XXX SecondInterMSCCircuitID not implemented, parameter ID conflicts with ISLP Information!
  54  *
  55  *   IMSI
  56  *                      3GPP2 N.S0009-0 v1.0    IS-751
  57  *
  58  *   WIN Phase 1
  59  *                      3GPP2 N.S0013-0 v1.0    IS-771
  60  *
  61  *   WIN Phase 2
  62  *                      3GPP2 N.S0004-0 v1.0    IS-848
  63  *
  64  *   TIA/EIA-41-D Pre-Paid Charging
  65  *                      3GPP2 N.S0018-0 v1.0    IS-826
  66  *
  67  *   User Selective Call Forwarding
  68  *                      3GPP2 N.S0021-0 v1.0    IS-838
  69  *
  70  *   CNAP/CNAR
  71  *                      3GPP2 N.S0012-0 v1.0
  72  *
  73  *   Answer Hold
  74  *                      3GPP2 N.S0022-0 v1.0    IS-837
  75  *
  76  *   Automatic Code Gapping
  77  *                      3GPP2 N.S0023-0 v1.0
  78  *
  79  *   UIM
  80  *                      3GPP2 N.S0003
  81  *
  82  * $Id: packet-ansi_map.c,v 1.7 2003/10/30 19:38:57 guy Exp $
  83  *
  84  * Ethereal - Network traffic analyzer
  85  * By Gerald Combs <gerald@ethereal.com>
  86  * Copyright 1998 Gerald Combs
  87  *
  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.
  92  *
  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.
  97  *
  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.
 101  */
 102
 103 #ifdef HAVE_CONFIG_H
 104 # include "config.h"
 105 #endif
 106
 107 #include <stdio.h>
 108 #include <stdlib.h>
 109 #include <gmodule.h>
 110
 111 #ifdef HAVE_SYS_TYPES_H
 112 # include <sys/types.h>
 113 #endif
 114
 115 #ifdef HAVE_NETINET_IN_H
 116 # include <netinet/in.h>
 117 #endif
 118
 119 #include <string.h>
 120
 121 #include "epan/packet.h"
 122 #include "asn1.h"
 123
 124 /* PROTOTYPES/FORWARDS */
 125
 126 static gboolean dissect_ansi_param(ASN1_SCK *asn1, proto_tree *tree);
 127
 128 /* ANSI PARAM STRINGS */
 129 static const value_string ansi_param_1_strings[] = {
 130     { 0x81,     "Billing ID" },
 131     { 0x82,     "Serving Cell ID" },
 132     { 0x83,     "Target Cell ID" },
 133     { 0x84,     "Digits" },
 134     { 0x85,     "Channel Data" },
 135     { 0x86,     "Inter MSC Circuit ID" },
 136     { 0x87,     "Inter Switch Count" },
 137     { 0x88,     "Mobile Identification Number" },
 138     { 0x89,     "Electronic Serial Number" },
 139     { 0x8A,     "Release Reason" },
 140     { 0x8B,     "Signal Quality" },
 141     { 0x8C,     "Station Class Mark" },
 142     { 0x8D,     "Authorization Denied" },
 143     { 0x8E,     "Authorization Period" },
 144     { 0x8F,     "Seizure Type" },
 145     { 0x90,     "Trunk Status" },
 146     { 0x91,     "Qualification Information Code" },
 147     { 0x92,     "Feature Result" },
 148     { 0x93,     "Redirection Reason" },
 149     { 0x94,     "Access Denied Reason" },
 150     { 0x95,     "MSCID" },
 151     { 0x96,     "System My Type Code" },
 152     { 0x97,     "Origination Indicator" },
 153     { 0x98,     "Termination Restriction Code" },
 154     { 0x99,     "Calling Features Indicator" },
 155     { 0x9A,     "Faulty Parameter" },
 156     { 0x9B,     "Usage Indicator" },
 157     { 0x9C,     "TDMA Channel Data" },
 158     { 0x9D,     "TDMA Call Mode" },
 159     { 0x9E,     "Handoff Reason" },
 160     { 0, NULL },
 161 };
 162
 163 static const value_string ansi_param_2_strings[] = {
 164     { 0x9F1F,   "TDMA Burst Indicator" },
 165     { 0x9F20,   "PC_SSN" },
 166     { 0x9F21,   "Location Area ID" },
 167     { 0x9F22,   "System Access Type" },
 168     { 0x9F23,   "Authentication Response" },
 169     { 0x9F24,   "Authentication Response Base Station" },
 170     { 0x9F25,   "Authentication Response Unique Challenge" },
 171     { 0x9F26,   "Call History Count" },
 172     { 0x9F27,   "Confidentiality Modes" },
 173     { 0x9F28,   "Random Variable" },
 174     { 0x9F29,   "Random Variable Base Station" },
 175     { 0x9F2A,   "Random Variable SSD" },
 176     { 0x9F2B,   "Random Variable Unique Challenge" },
 177     { 0x9F2C,   "Report Type" },
 178     { 0x9F2D,   "Signaling Message Encryption Key" },
 179     { 0x9F2E,   "Shared Secret Data" },
 180     { 0x9F2F,   "Terminal Type" },
 181     { 0x9F30,   "Voice Privacy Mask" },
 182     { 0x9F31,   "System Capabilities" },
 183     { 0x9F32,   "Deny Access" },
 184     { 0x9F33,   "Update Count" },
 185     { 0x9F34,   "SSD Not Shared" },
 186     { 0x9F35,   "Extended MSCID" },
 187     { 0x9F36,   "Extended System My Type Code" },
 188     { 0x9F37,   "Control Channel Data" },
 189     { 0x9F38,   "System Access Data" },
 190     { 0x9F39,   "Cancellation Denied" },
 191     { 0x9F3A,   "Border Cell Access" },
 192     { 0x9F3B,   "CDMA Station Class Mark" },
 193     { 0x9F3C,   "CDMA Serving One Way Delay" },
 194     { 0x9F3D,   "CDMA Target One Way Delay" },
 195     { 0x9F3E,   "CDMA Call Mode" },
 196     { 0x9F3F,   "CDMA Channel Data" },
 197     { 0x9F40,   "CDMA Signal Quality" },
 198     { 0x9F41,   "CDMA Pilot Strength" },
 199     { 0x9F42,   "CDMA Mobile Protocol Revision" },
 200     { 0x9F43,   "CDMA Private Long Code Mask" },
 201     { 0x9F44,   "CDMA Code Channel" },
 202     { 0x9F45,   "CDMA Search Window" },
 203     { 0x9F46,   "MS Location" },
 204     { 0x9F47,   "Page Indicator" },
 205     { 0x9F48,   "Received Signal Quality" },
 206     { 0x9F49,   "Deregistration Type" },
 207     { 0x9F4A,   "NAMPS Channel Data" },
 208     { 0x9F4B,   "Alert Code" },
 209     { 0x9F4C,   "Announcement Code" },
 210     { 0x9F4D,   "Authentication Algorithm Version" },
 211     { 0x9F4E,   "Authentication Capability" },
 212     { 0x9F4F,   "Call History Count Expected" },
 213     { 0x9F50,   "Calling Party Number Digits 1" },
 214     { 0x9F51,   "Calling Party Number Digits 2" },
 215     { 0x9F52,   "Calling Party Number String 1" },
 216     { 0x9F53,   "Calling Party Number String 2" },
 217     { 0x9F54,   "Calling Party Subaddress" },
 218     { 0x9F55,   "Cancellation Type" },
 219     { 0x9F56,   "Carrier Digits" },
 220     { 0x9F57,   "Destination Digits" },
 221     { 0x9F58,   "DMH Redirection Indicator" },
 222     { 0x9F59,   "Inter System Termination" },
 223     { 0x9F5A,   "Availability Type" },
 224     { 0x9F5B,   "Local Termination" },
 225     { 0x9F5C,   "Message Waiting Notification Count" },
 226     { 0x9F5D,   "Mobile Directory Number" },
 227     { 0x9F5E,   "MSCID Number" },
 228     { 0x9F5F,   "PSTN Termination" },
 229     { 0x9F60,   "No Answer Time" },
 230     { 0x9F61,   "One Time Feature Indicator" },
 231     { 0x9F62,   "Origination Triggers" },
 232     { 0x9F63,   "RANDC" },
 233     { 0x9F64,   "Redirecting Number Digits" },
 234     { 0x9F65,   "Redirecting Number String" },
 235     { 0x9F66,   "Redirecting Number Subaddress" },
 236     { 0x9F67,   "Sender Identification Number" },
 237     { 0x9F68,   "SMS Address" },
 238     { 0x9F69,   "SMS Bearer Data" },
 239     { 0x9F6A,   "SMS Charge Indicator" },
 240     { 0x9F6B,   "SMS Destination Address" },
 241     { 0x9F6C,   "SMS Message Count" },
 242     { 0x9F6D,   "SMS Notification Indicator" },
 243     { 0x9F6E,   "SMS Original Destination Address" },
 244     { 0x9F6F,   "SMS Original Destination Subaddress" },
 245     { 0x9F70,   "SMS Original Originating Address" },
 246     { 0x9F71,   "SMS Original Originating Subaddress" },
 247     { 0x9F72,   "SMS Originating Address" },
 248     { 0x9F73,   "SMS Originating Restrictions" },
 249     { 0x9F74,   "SMS Teleservice Identifier" },
 250     { 0x9F75,   "SMS Termination Restrictions" },
 251     { 0x9F76,   "SMS Message Waiting Indicator" },
 252     { 0x9F77,   "Termination Access Type" },
 253     { 0x9F78,   "Termination List" },
 254     { 0x9F79,   "Termination Treatment" },
 255     { 0x9F7A,   "Termination Triggers" },
 256     { 0x9F7B,   "Transaction Capability" },
 257     { 0x9F7C,   "Unique Challenge Report" },
 258     { 0, NULL },
 259 };
 260
 261 static const value_string ansi_param_3_strings[] = {
 262     { 0x9F8100, "Action Code" },
 263     { 0x9F8101, "Alert Result" },
 264     { 0xBF8102, "Announcement List" },
 265     { 0xBF8103, "CDMA Code Channel Information" },
 266     { 0xBF8104, "CDMA Code Channel List" },
 267     { 0xBF8105, "CDMA Target Measurement Information" },
 268     { 0xBF8106, "CDMA Target Measurement List" },
 269     { 0xBF8107, "CDMA Target MAHO Information" },
 270     { 0xBF8108, "CDMA Target MAHO List" },
 271     { 0x9F8109, "Conference Calling Indicator" },
 272     { 0x9F810A, "Count Update Report" },
 273     { 0x9F810B, "Digit Collection Control" },
 274     { 0x9F810C, "DMH Account Code Digits" },
 275     { 0x9F810D, "DMH Alternate Billing Digits" },
 276     { 0x9F810E, "DMH Billing Digits" },
 277     { 0x9F810F, "Geographic Authorization" },
 278     { 0x9F8110, "Leg Information" },
 279     { 0x9F8111, "Message Waiting Notification Type" },
 280     { 0x9F8112, "PACA Indicator" },
 281     { 0x9F8113, "Preferred Language Indicator" },
 282     { 0x9F8114, "Random Valid Time" },
 283     { 0x9F8115, "Restriction Digits" },
 284     { 0x9F8116, "Routing Digits" },
 285     { 0x9F8117, "Setup Result" },
 286     { 0x9F8118, "SMS Access Denied Reason" },
 287     { 0x9F8119, "SMS Cause Code" },
 288     { 0x9F811A, "SPINI PIN" },
 289     { 0x9F811B, "SPINI Triggers" },
 290     { 0x9F811C, "SSD Update Report" },
 291     { 0x9F811D, "Target Measurement Information" },
 292     { 0x9F811E, "Target Measurement List" },
 293     { 0x9F811F, "Voice Mailbox PIN" },
 294     { 0x9F8120, "Voice Mailbox Number" },
 295     { 0x9F8121, "Authentication Data" },
 296     { 0x9F8122, "Conditionally Denied Reason" },
 297     { 0x9F8123, "Group Information" },
 298     { 0x9F8124, "Handoff State" },
 299     { 0x9F8125, "NAMPS Call Mode" },
 300     { 0x9F8126, "CDMA Slot Cycle Index" },
 301     { 0x9F8127, "Denied Authorization Period" },
 302     { 0x9F8128, "Pilot Number" },
 303     { 0x9F8129, "Pilot Billing ID" },
 304     { 0x9F812A, "CDMA Band Class" },
 305     { 0x9F8172, "International Mobile Subscriber Identity" },
 306     { 0x9F8173, "Calling Party Name" },
 307     { 0x9F8174, "Display Text" },
 308     { 0x9F8175, "Redirecting Party Name" },
 309     { 0x9F8176, "Service ID" },
 310     { 0x9F8177, "All Or None" },
 311     { 0x9F8178, "Change" },
 312     { 0xBF8179, "Data Access Element" },
 313     { 0xBF817A, "Data Access Element List" },
 314     { 0xBF817E, "Data Update Result" },
 315     { 0xBF817F, "Data Update Result List" },
 316     { 0x9F812D, "CDMA Pilot PN" },
 317     { 0x9F812E, "CDMA Service Configuration Record" },
 318     { 0x9F812F, "CDMA Service Option" },
 319     { 0x9F8131, "CDMA Station Class Mark 2" },
 320     { 0x9F8132, "TDMA Service Code" },
 321     { 0x9F8133, "TDMA Terminal Capability" },
 322     { 0x9F8134, "TDMA Voice Coder" },
 323     { 0x9F8135, "A-Key Protocol Version" },
 324     { 0x9F8136, "Authentication Response Reauthentication" },
 325     { 0x9F8137, "Base Station Partial Key" },
 326     { 0x9F8138, "Mobile Station MIN" },
 327     { 0x9F8139, "Mobile Station Partial Key" },
 328     { 0x9F813A, "Modulus Value" },
 329     { 0x9F813B, "Newly Assigned MIN" },
 330     { 0x9F813D, "OTASP Result Code" },
 331     { 0x9F813E, "Primitive Value" },
 332     { 0x9F813F, "Random Variable Reauthentication" },
 333     { 0x9F8140, "Reauthentication Report" },
 334     { 0x9F8141, "Service Indicator" },
 335     { 0x9F8142, "Signaling Message Encryption Report" },
 336     { 0x9F8143, "Temporary Reference Number" },
 337     { 0x9F8144, "Voice Privacy Report" },
 338     { 0x9F8147, "Control Channel Mode" },
 339     { 0x9F8152, "CDMA Connection Reference" },
 340     { 0x9F8153, "CDMA Connection Reference Information" },
 341     { 0x9F8154, "CDMA Connection Reference List" },
 342     { 0x9F8156, "Change Service Attributes" },
 343     { 0x9F8157, "Data Key" },
 344     { 0x9F8158, "Data Privacy Parameters" },
 345     { 0x9F8159, "ISLP Information" }, /* IS-737 *SPEC CONFLICT* */
 346     { 0x9F815A, "Reason List" },
 347     { 0x9F815C, "TDMA Bandwidth" },
 348     { 0x9F815D, "TDMA Data Features Indicator" },
 349     { 0x9F815E, "TDMA Data Mode" },
 350     { 0x9F815F, "TDMA Voice Mode" },
 351     { 0x9F8160, "Analog Redirect Info" },
 352     { 0xBF812B, "CDMA Band Class Information" },
 353     { 0xBF812C, "CDMA Band Class List" },
 354     { 0xBF8130, "CDMA Service Option List" },
 355     { 0xBF8153, "CDMA Connection Reference Information" },
 356     { 0xBF8154, "CDMA Connection Reference List" },
 357     { 0xBF8161, "Analog Redirect Record" },
 358     { 0xBF8202, "Execute Script" },
 359     { 0xBF8206, "Modification Request" },
 360     { 0xBF8207, "Modification Request List" },
 361     { 0xBF8208, "Modification Result List" },
 362     { 0xBF820E, "Service Data Access Element" },
 363     { 0xBF820F, "Service Data Access Element List" },
 364     { 0xBF8210, "Service Data Result" },
 365     { 0xBF8211, "Service Data Result List" },
 366     { 0xBF8214, "Trigger Address List" },
 367     { 0xBF8216, "Trigger List" },
 368     { 0xBF8218, "WIN Capability" },
 369     { 0xBF822F, "Call Recovery ID" },
 370     { 0xBF8230, "Call Recovery ID List" },
 371     { 0xBF8250, "Position Information" },
 372     { 0xBF825A, "CDMA PSMM List" },
 373     { 0x9F8162, "CDMA Channel Number" },
 374     { 0xBF8163, "CDMA Channel Number List" },
 375     { 0x9F8164, "CDMA Power Combined Indicator" },
 376     { 0x9F8165, "CDMA Redirect Record" },
 377     { 0x9F8166, "CDMA Search Parameters" },
 378     { 0x9F8168, "CDMA Network Identification" },
 379     { 0x9F8169, "Network TMSI" },
 380     { 0x9F816A, "Network TMSI Expiration Time" },
 381     { 0x9F816B, "New Network TMSI" },
 382     { 0x9F816C, "Required Parameters Mask" },
 383     { 0x9F816D, "Service Redirection Cause" },
 384     { 0x9F816E, "Service Redirection Info" },
 385     { 0x9F816F, "Roaming Indication" },
 386     { 0x9F8170, "MSID" },
 387     { 0x9F817B, "Data ID" },
 388     { 0x9F817C, "Database Key" },
 389     { 0x9F817D, "Data Result" },
 390     { 0x9F8200, "Data Value" },
 391     { 0x9F8203, "Failure Cause" },
 392     { 0x9F8204, "Failure Type" },
 393     { 0x9F8205, "Global Title" },
 394     { 0x9F8209, "Private Specialized Resource" },
 395     { 0x9F820A, "Resume PIC" },
 396     { 0x9F820B, "Script Argument" },
 397     { 0x9F820C, "Script Name" },
 398     { 0x9F820D, "Script Result" },
 399     { 0x9F8212, "Specialized Resource" },
 400     { 0x9F8213, "Time Date Offset" },
 401     { 0x9F8215, "Trigger Capability" },
 402     { 0x9F8217, "Trigger Type" },
 403     { 0x9F8219, "WIN Operations Capability" },
 404     { 0x9F821B, "WIN Trigger List" },
 405     { 0x9F821C, "MSC Address" },
 406     { 0x9F821D, "Suspicious Access" },
 407     { 0x9F821E, "Mobile Station IMSI" },
 408     { 0x9F821F, "Newly Assigned IMSI" },
 409     { 0x9F822A, "Command Code" },
 410     { 0x9F822B, "Display Text 2" },
 411     { 0x9F822C, "Page Count" },
 412     { 0x9F822D, "Page Response Time" },
 413     { 0x9F822E, "SMS Transaction ID" },
 414     { 0x9F8231, "DMH Service ID" },
 415     { 0x9F8232, "Feature Indicator" },
 416     { 0x9F8233, "Control Network ID" },
 417     { 0x9F8234, "Release Cause" },
 418     { 0x9F8235, "Time Of Day" },
 419     { 0x9F8236, "Call Status" },
 420     { 0x9F8237, "DMH Charge Information" },
 421     { 0x9F8238, "DMH Billing Indicator" },
 422     { 0x9F8239, "MS Status" },
 423     { 0x9F823B, "Position Information Code" },
 424     { 0x9F8246, "Inter Message Time" },
 425     { 0x9F8247, "MSID Usage" },
 426     { 0x9F8248, "New MIN Extension" },
 427     { 0x9F8249, "DTX Indication" },
 428     { 0x9F824A, "CDMA Mobile Capabilities" },
 429     { 0x9F824B, "Generalized Time" },
 430     { 0x9F824C, "Generic Digits" },
 431     { 0x9F824D, "Geographic Position" },
 432     { 0x9F824E, "Mobile Call Status" },
 433     { 0x9F824F, "Mobile Position Capability" },
 434     { 0x9F8251, "Position Request Type" },
 435     { 0x9F8252, "Position Result" },
 436     { 0x9F8253, "Position Source" },
 437     { 0x9F8254, "ACG Encountered" },
 438     { 0x9F8255, "CDMA State/Control Type *" },  /* PN-3590 (ANSI-41-E)/ACG *SPEC CONFLICT* */
 439     { 0x9F8256, "Gap Duration" },
 440     { 0x9F8257, "SCF Overload Gap Interval" },
 441     { 0x9F8258, "Service Management System Gap Interval" },
 442     { 0x9F8259, "CDMA PSMM Count" },
 443     { 0x9F825B, "CDMA Serving One Way Delay 2" },
 444     { 0x9F825C, "QoS Priority" },
 445     { 0x9F825D, "PDSN Address" },
 446     { 0x9F825E, "PDSN Protocol Type" },
 447     { 0x9F825F, "CDMA MS Measured Channel Identity" },
 448     { 0x9F8261, "Range" },
 449     { 0x9F8263, "Calling Party Category" },
 450     { 0x9F8264, "cdma2000 Handoff Invoke IOS Data" },
 451     { 0x9F8265, "cdma2000 Handoff Response IOS Data" },
 452     { 0x9F8266, "LCS Client ID" },
 453     { 0x9F8267, "TDMA MAHO Cell ID" },
 454     { 0x9F8268, "TDMA MAHO Channel" },
 455     { 0x9F8269, "CDMA Service Option Connection Identifier" },
 456     { 0x9F826A, "TDMA Time Alignment" },
 457     { 0x9F826C, "TDMA MAHO Request" },
 458     { 0, NULL },
 459 };
 460
 461 /* ANSI TCAP component type */
 462 #define ANSI_TC_INVOKE_L 0xe9
 463 #define ANSI_TC_RRL 0xea
 464 #define ANSI_TC_RE 0xeb
 465 #define ANSI_TC_REJECT 0xec
 466 #define ANSI_TC_INVOKE_N 0xed
 467 #define ANSI_TC_RRN 0xee
 468
 469 static const value_string ansi_cmp_type_strings[] = {
 470     { ANSI_TC_INVOKE_L,         "Invoke(Last)" },
 471     { ANSI_TC_RRL,              "RetRes(Last)" },
 472     { ANSI_TC_RE,               "RetErr" },
 473     { ANSI_TC_REJECT,           "Reject" },
 474     { ANSI_TC_INVOKE_N,         "Invoke(Not Last)" },
 475     { ANSI_TC_RRN,              "RetRes(Not Last)" },
 476     { 0, NULL },
 477 };
 478
 479 static const value_string ansi_opr_code_strings[] = {
 480     { 1,        "Handoff Measurement Request" },
 481     { 2,        "Facilities Directive" },
 482     { 3,        "Mobile On Channel" },
 483     { 4,        "Handoff Back" },
 484     { 5,        "Facilities Release" },
 485     { 6,        "Qualification Request" },
 486     { 7,        "Qualification Directive" },
 487     { 8,        "Blocking" },
 488     { 9,        "Unblocking" },
 489     { 10,       "Reset Circuit" },
 490     { 11,       "Trunk Test" },
 491     { 12,       "Trunk Test Disconnect" },
 492     { 13,       "Registration Notification" },
 493     { 14,       "Registration Cancellation" },
 494     { 15,       "Location Request" },
 495     { 16,       "Routing Request" },
 496     { 17,       "Feature Request" },
 497     { 18,       "Reserved 18 (Service Profile Request, IS-41-C)" },
 498     { 19,       "Reserved 19 (Service Profile Directive, IS-41-C)" },
 499     { 20,       "Unreliable Roamer Data Directive" },
 500     { 21,       "Reserved 21 (Call Data Request, IS-41-C)" },
 501     { 22,       "MS Inactive" },
 502     { 23,       "Transfer To Number Request" },
 503     { 24,       "Redirection Request" },
 504     { 25,       "Handoff To Third" },
 505     { 26,       "Flash Request" },
 506     { 27,       "Authentication Directive" },
 507     { 28,       "Authentication Request" },
 508     { 29,       "Base Station Challenge" },
 509     { 30,       "Authentication Failure Report" },
 510     { 31,       "Count Request" },
 511     { 32,       "Inter System Page" },
 512     { 33,       "Unsolicited Response" },
 513     { 34,       "Bulk Deregistration" },
 514     { 35,       "Handoff Measurement Request 2" },
 515     { 36,       "Facilities Directive 2" },
 516     { 37,       "Handoff Back 2" },
 517     { 38,       "Handoff To Third 2" },
 518     { 39,       "Authentication Directive Forward" },
 519     { 40,       "Authentication Status Report" },
 520     { 41,       "Reserved 41" },
 521     { 42,       "Information Directive" },
 522     { 43,       "Information Forward" },
 523     { 44,       "Inter System Answer" },
 524     { 45,       "Inter System Page 2" },
 525     { 46,       "Inter System Setup" },
 526     { 47,       "Origination Request" },
 527     { 48,       "Random Variable Request" },
 528     { 49,       "Redirection Directive" },
 529     { 50,       "Remote User Interaction Directive" },
 530     { 51,       "SMS Delivery Backward" },
 531     { 52,       "SMS Delivery Forward" },
 532     { 53,       "SMS Delivery Point to Point" },
 533     { 54,       "SMS Notification" },
 534     { 55,       "SMS Request" },
 535     { 56,       "OTASP Request" },
 536     { 57,       "Information Backward" },
 537     { 58,       "Change Facilities" },
 538     { 59,       "Change Service" },
 539     { 60,       "Parameter Request" },
 540     { 61,       "TMSI Directive" },
 541     { 62,       "Reserved 62" },
 542     { 63,       "Service Request" },
 543     { 64,       "Analyzed Information Request" },
 544     { 65,       "Connection Failure Report" },
 545     { 66,       "Connect Resource" },
 546     { 67,       "Disconnect Resource" },
 547     { 68,       "Facility Selected and Available" },
 548     { 69,       "Instruction Request" },
 549     { 70,       "Modify" },
 550     { 71,       "Reset Timer" },
 551     { 72,       "Search" },
 552     { 73,       "Seize Resource" },
 553     { 74,       "SRF Directive" },
 554     { 75,       "T Busy" },
 555     { 76,       "T NoAnswer" },
 556     { 77,       "Release" },
 557     { 78,       "SMS Delivery Point to Point Ack" },
 558     { 79,       "Message Directive" },
 559     { 80,       "Bulk Disconnection" },
 560     { 81,       "Call Control Directive" },
 561     { 82,       "O Answer" },
 562     { 83,       "O Disconnect" },
 563     { 84,       "Call Recovery Report" },
 564     { 85,       "T Answer" },
 565     { 86,       "T Disconnect" },
 566     { 87,       "Unreliable Call Data" },
 567     { 88,       "O CalledPartyBusy" },
 568     { 89,       "O NoAnswer" },
 569     { 90,       "Position Request" },
 570     { 91,       "Position Request Forward" },
 571     { 92,       "Call Termination Report" },
 572     { 93,       "Geo Position Directive" },
 573     { 94,       "Geo Position Request" },
 574     { 95,       "Inter System Position Request" },
 575     { 96,       "Inter System Position Request Forward" },
 576     { 97,       "ACG Directive" },
 577     { 98,       "Roamer Database Verification Request" },
 578     { 99,       "Add Service" },
 579     { 100,      "Drop Service" },
 580     { 0, NULL },
 581 };
 582
 583 static const value_string ansi_tele_strings[] = {
 584     { 1,        "Reserved for maintenance" },
 585     { 4096,     "AMPS Extended Protocol Enhanced Services" },
 586     { 4097,     "CDMA Cellular Paging Teleservice" },
 587     { 4098,     "CDMA Cellular Messaging Teleservice" },
 588     { 4099,     "CDMA Voice Mail Notification" },
 589     { 32513,    "TDMA Cellular Messaging Teleservice" },
 590     { 32520,    "TDMA System Assisted Mobile Positioning through Satellite (SAMPS)" },
 591     { 32584,    "TDMA Segmented System Assisted Mobile Positioning Service" },
 592     { 0, NULL },
 593 };
 594
 595 #define NUM_BAND_CLASS_STR      (sizeof(band_class_str)/sizeof(gchar *))
 596 static gchar *band_class_str[] = {
 597     "800 MHz Cellular System",
 598     "1.850 to 1.990 GHz Broadband PCS",
 599     "872 to 960 MHz TACS Band",
 600     "832 to 925 MHz JTACS Band",
 601     "1.750 to 1.870 GHz Korean PCS",
 602     "450 MHz NMT",
 603     "2 GHz IMT-2000 Band",
 604     "North American 700 MHz Cellular Band",
 605     "1.710 to 1.880 GHz PCS",
 606     "880 to 960 MHz Band",
 607     "Secondary 800 MHz Band",
 608     "400 MHz European PAMR Band",
 609     "800 MHz European PAMR Band"
 610 };
 611
 612 #define NUM_QOS_PRI_STR         (sizeof(qos_pri_str)/sizeof(gchar *))
 613 static gchar *qos_pri_str[] = {
 614     "Priority Level 0.  This is the lowest level",
 615     "Priority Level 1",
 616     "Priority Level 2",
 617     "Priority Level 3",
 618     "Priority Level 4",
 619     "Priority Level 5",
 620     "Priority Level 6",
 621     "Priority Level 7",
 622     "Priority Level 8",
 623     "Priority Level 9",
 624     "Priority Level 10",
 625     "Priority Level 11",
 626     "Priority Level 12",
 627     "Priority Level 13",
 628     "Reserved, treat as Priority Level 14",
 629     "Reserved, treat as Priority Level 15"
 630 };
 631
 632 /* Initialize the protocol and registered fields */
 633 static int proto_ansi_map = -1;
 634 static int hf_ansi_map_none = -1;
 635 static int hf_ansi_map_tag = -1;
 636 static int hf_ansi_map_length = -1;
 637 static int hf_ansi_map_id = -1;
 638 static int hf_ansi_map_opr_code = -1;
 639 static int hf_ansi_map_param_id = -1;
 640
 641
 642 /* Initialize the subtree pointers */
 643 static gint ett_ansi_map = -1;
 644 static gint ett_opr_code = -1;
 645 static gint ett_component = -1;
 646 static gint ett_components = -1;
 647 static gint ett_params = -1;
 648 static gint ett_param = -1;
 649 static gint ett_error = -1;
 650 static gint ett_problem = -1;
 651 static gint ett_natnum = -1;
 652 static gint ett_call_mode = -1;
 653 static gint ett_chan_data = -1;
 654 static gint ett_code_chan = -1;
 655 static gint ett_clr_dig_mask = -1;
 656 static gint ett_ent_dig_mask = -1;
 657 static gint ett_all_dig_mask = -1;
 658
 659
 660 static char bigbuf[1024];
 661 static dissector_handle_t data_handle;
 662 static dissector_table_t is637_tele_id_dissector_table; /* IS-637 Teleservice ID */
 663 static dissector_table_t is683_dissector_table; /* IS-683-A (OTA) */
 664 static packet_info *g_pinfo;
 665 static proto_tree *g_tree;
 666 static gint32 ansi_map_sms_tele_id = -1;
 667 static gboolean is683_ota;
 668 static gboolean ansi_map_is_invoke;
 669
 670
 671 typedef struct dgt_set_t
 672 {
 673     unsigned char out[15];
 674 }
 675 dgt_set_t;
 676
 677 static dgt_set_t Dgt_tbcd = {
 678     {
 679   /*  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e */
 680      '0','1','2','3','4','5','6','7','8','9','?','B','C','*','#'
 681     }
 682 };
 683
 684 static dgt_set_t Dgt_msid = {
 685     {
 686   /*  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e */
 687      '0','1','2','3','4','5','6','7','8','9','?','?','?','?','?'
 688     }
 689 };
 690
 691 /* FUNCTIONS */
 692
 693 /*
 694  * Unpack BCD input pattern into output ASCII pattern
 695  *
 696  * Input Pattern is supplied using the same format as the digits
 697  *
 698  * Returns: length of unpacked pattern
 699  */
 700 static int
 701 my_dgt_tbcd_unpack(
 702     char        *out,           /* ASCII pattern out */
 703     guchar      *in,            /* packed pattern in */
 704     int         num_octs,       /* Number of octets to unpack */
 705     dgt_set_t   *dgt            /* Digit definitions */
 706     )
 707 {
 708     int cnt = 0;
 709     unsigned char i;
 710
 711     while (num_octs)
 712     {
 713         /*
 714          * unpack first value in byte
 715          */
 716         i = *in++;
 717         *out++ = dgt->out[i & 0x0f];
 718         cnt++;
 719
 720         /*
 721          * unpack second value in byte
 722          */
 723         i >>= 4;
 724
 725         if (i == 0x0f)  /* odd number bytes - hit filler */
 726             break;
 727
 728         *out++ = dgt->out[i];
 729         cnt++;
 730         num_octs--;
 731     }
 732
 733     *out = '\0';
 734
 735     return(cnt);
 736 }
 737
 738 /* Generate, into "buf", a string showing the bits of a bitfield.
 739  * Return a pointer to the character after that string.
 740  */
 741 static char *
 742 my_decode_bitfield_value(char *buf, guint32 val, guint32 mask, int width)
 743 {
 744     int         i;
 745     guint32     bit;
 746     char        *p;
 747
 748     i = 0;
 749     p = buf;
 750     bit = 1 << (width - 1);
 751
 752     for (;;)
 753     {
 754         if (mask & bit)
 755         {
 756             /* This bit is part of the field.  Show its value. */
 757             if (val & bit)
 758             {
 759                 *p++ = '1';
 760             }
 761             else
 762             {
 763                 *p++ = '0';
 764             }
 765         }
 766         else
 767         {
 768             /* This bit is not part of the field. */
 769             *p++ = '.';
 770         }
 771
 772         bit >>= 1;
 773         i++;
 774
 775         if (i >= width) break;
 776
 777         if (i % 4 == 0) *p++ = ' ';
 778     }
 779
 780     *p = '\0';
 781
 782     return(p);
 783 }
 784
 785 static gchar *
 786 my_match_strval(guint32 val, const value_string *vs, gint *idx)
 787 {
 788     gint i = 0;
 789
 790     while (vs[i].strptr)
 791     {
 792         if (vs[i].value == val)
 793         {
 794             *idx = i;
 795             return(vs[i].strptr);
 796         }
 797
 798         i++;
 799     }
 800
 801     *idx = -1;
 802     return(NULL);
 803 }
 804
 805
 806 /* PARAM FUNCTIONS */
 807
 808 #define EXTRANEOUS_DATA_CHECK(edc_len, edc_max_len) \
 809     if ((edc_len) > (edc_max_len)) \
 810     { \
 811         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb, \
 812             asn1->offset, (edc_len) - (edc_max_len), "Extraneous Data"); \
 813         asn1->offset += ((edc_len) - (edc_max_len)); \
 814     }
 815
 816 #define SHORT_DATA_CHECK(sdc_len, sdc_min_len) \
 817     if ((sdc_len) < (sdc_min_len)) \
 818     { \
 819         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb, \
 820             asn1->offset, (sdc_len), "Short Data (?)"); \
 821         asn1->offset += (sdc_len); \
 822         return; \
 823     }
 824
 825 #define EXACT_DATA_CHECK(edc_len, edc_eq_len) \
 826     if ((edc_len) != (edc_eq_len)) \
 827     { \
 828         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb, \
 829             asn1->offset, (edc_len), "Unexpected Data Length"); \
 830         asn1->offset += (edc_len); \
 831         return; \
 832     }
 833
 834 static void
 835 param_mscid(ASN1_SCK *asn1, proto_tree *tree, guint len)
 836 {
 837     gint32 market_id, switch_num;
 838     guint saved_offset;
 839
 840     EXACT_DATA_CHECK(len, 3);
 841
 842     saved_offset = asn1->offset;
 843
 844     asn1_int32_value_decode(asn1, 2, &market_id);
 845     asn1_int32_value_decode(asn1, 1, &switch_num);
 846
 847     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
 848         saved_offset, asn1->offset - saved_offset,
 849         "Market ID %d  Switch Number %d",
 850         market_id, switch_num);
 851 }
 852
 853 static void
 854 param_page_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
 855 {
 856     gint32 value;
 857     guint saved_offset;
 858     gchar *str = NULL;
 859
 860     saved_offset = asn1->offset;
 861
 862     asn1_int32_value_decode(asn1, 1, &value);
 863
 864     switch (value)
 865     {
 866     case 0: str = "Not used"; break;
 867     case 1: str = "Page"; break;
 868     case 2: str = "Listen only"; break;
 869     default:
 870         if ((value >= 3) && (value <= 223)) { str = "Reserved, treat as Page"; }
 871         else { str = "Reserved for protocol extension, treat as Page"; }
 872         break;
 873     }
 874
 875     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
 876         saved_offset, asn1->offset - saved_offset,
 877         str);
 878
 879     EXTRANEOUS_DATA_CHECK(len, 1);
 880 }
 881
 882 static void
 883 param_srvc_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
 884 {
 885     gint32 value;
 886     guint saved_offset;
 887     gchar *str = NULL;
 888
 889     EXACT_DATA_CHECK(len, 1);
 890
 891     saved_offset = asn1->offset;
 892
 893     asn1_int32_value_decode(asn1, 1, &value);
 894
 895     switch (value)
 896     {
 897     case 0: str = "Undefined Service"; break;
 898     case 1: str = "CDMA OTASP Service"; is683_ota = TRUE; break;
 899     case 2: str = "TDMA OTASP Service"; break;
 900     case 3: str = "CDMA OTAPA Service"; is683_ota = TRUE; break;
 901     case 4: str = "CDMA Position Determination Service"; break;
 902     case 5: str = "AMPS Position Determination Service"; break;
 903     default:
 904         if ((value >= 6) && (value <= 223)) { str = "Reserved, treat as Undefined Service"; }
 905         else { str = "Reserved for protocol extension, treat as Undefined Service"; }
 906         break;
 907     }
 908
 909     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
 910         saved_offset, asn1->offset - saved_offset,
 911         "%s (%d)",
 912         str,
 913         value);
 914 }
 915
 916 static void
 917 param_sme_report(ASN1_SCK *asn1, proto_tree *tree, guint len)
 918 {
 919     gint32 value;
 920     guint saved_offset;
 921     gchar *str = NULL;
 922
 923     EXACT_DATA_CHECK(len, 1);
 924
 925     saved_offset = asn1->offset;
 926
 927     asn1_int32_value_decode(asn1, 1, &value);
 928
 929     switch (value)
 930     {
 931     case 0: str = "Not used"; break;
 932     case 1: str = "Signaling Message Encryption enabling not attempted"; break;
 933     case 2: str = "Signaling Message Encryption enabling no response"; break;
 934     case 3: str = "Signaling Message Encryption is enabled"; break;
 935     case 4: str = "Signaling Message Encryption enabling failed"; break;
 936     default:
 937         if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Signaling Message Encryption enabling not attempted"; }
 938         else { str = "Reserved for protocol extension, treat as Signaling Message Encryption enabling not attempted"; }
 939         break;
 940     }
 941
 942     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
 943         saved_offset, asn1->offset - saved_offset,
 944         "%s (%d)",
 945         str,
 946         value);
 947 }
 948
 949 static void
 950 param_alert_code(ASN1_SCK *asn1, proto_tree *tree, guint len)
 951 {
 952     gint32 value;
 953     guint saved_offset;
 954     gchar *str = NULL;
 955
 956     SHORT_DATA_CHECK(len, 2);
 957
 958     saved_offset = asn1->offset;
 959
 960     asn1_int32_value_decode(asn1, 1, &value);
 961
 962     switch ((value & 0xc0) >> 6)
 963     {
 964     case 0: str = "Medium"; break;
 965     case 1: str = "High"; break;
 966     case 2: str = "Low"; break;
 967     case 3: str = "Reserved"; break;
 968     }
 969
 970     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
 971     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
 972         saved_offset, asn1->offset - saved_offset,
 973         "%s :  Pitch, %s",
 974         bigbuf,
 975         str);
 976
 977     switch (value & 0x3f)
 978     {
 979     case 0: str = "NoTone"; break;
 980     case 1: str = "Long"; break;
 981     case 2: str = "ShortShort"; break;
 982     case 3: str = "ShortShortLong"; break;
 983     case 4: str = "ShortShort2"; break;
 984     case 5: str = "ShortLongShort"; break;
 985     case 6: str = "ShortShortShortShort"; break;
 986     case 7: str = "PBXLong"; break;
 987     case 8: str = "PBXShortShort"; break;
 988     case 9: str = "PBXShortShortLong"; break;
 989     case 10: str = "PBXShortLongShort"; break;
 990     case 11: str = "PBXShortShortShortShort"; break;
 991     case 12: str = "PipPipPipPip"; break;
 992     default:
 993         str = "Reserved, treat as NoTone";
 994         break;
 995     }
 996
 997     my_decode_bitfield_value(bigbuf, value, 0x3f, 8);
 998     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
 999         saved_offset, asn1->offset - saved_offset,
1000         "%s :  Cadence, %s",
1001         bigbuf,
1002         str);
1003
1004     saved_offset = asn1->offset;
1005
1006     asn1_int32_value_decode(asn1, 1, &value);
1007
1008     my_decode_bitfield_value(bigbuf, value, 0xf8, 8);
1009     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1010         saved_offset, asn1->offset - saved_offset,
1011         "%s :  Reserved",
1012         bigbuf);
1013
1014     switch (value & 0x07)
1015     {
1016     case 0: str = "Alert without waiting to report"; break;
1017     case 1: str = "Apply a reminder alert once"; break;
1018     default:
1019         str = "Reserved, treat as Alert without waiting to report";
1020         break;
1021     }
1022
1023     my_decode_bitfield_value(bigbuf, value, 0x07, 8);
1024     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1025         saved_offset, asn1->offset - saved_offset,
1026         "%s :  Alert Action, %s",
1027         bigbuf,
1028         str);
1029
1030     EXTRANEOUS_DATA_CHECK(len, 2);
1031 }
1032
1033 static void
1034 param_term_acc_type(ASN1_SCK *asn1, proto_tree *tree, guint len)
1035 {
1036     gint32 value;
1037     guint saved_offset;
1038     gchar *str = NULL;
1039
1040     saved_offset = asn1->offset;
1041
1042     asn1_int32_value_decode(asn1, 1, &value);
1043
1044     switch (value)
1045     {
1046     case 0: str = "Not used"; break;
1047     case 252: str = "Mobile-to-Mobile Directory Number access"; break;
1048     case 253: str = "Land-to-Mobile Directory Number access"; break;
1049     case 254: str = "Land-to-Mobile Directory Number access"; break;
1050     case 255: str = "Roamer port access"; break;
1051     default:
1052         if ((value >= 1) && (value <= 127)) { str = "Reserved for controlling system assignment"; }
1053         else if ((value >= 128) && (value <= 160)) { str = "Reserved for protocol extension, treat as Land-to-Mobile Directory Number access"; }
1054         else { str = "Reserved"; }
1055         break;
1056     }
1057
1058     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1059         saved_offset, asn1->offset - saved_offset,
1060         str);
1061
1062     EXTRANEOUS_DATA_CHECK(len, 1);
1063 }
1064
1065 static void
1066 param_term_treat(ASN1_SCK *asn1, proto_tree *tree, guint len)
1067 {
1068     gint32 value;
1069     guint saved_offset;
1070     gchar *str = NULL;
1071
1072     saved_offset = asn1->offset;
1073
1074     asn1_int32_value_decode(asn1, 1, &value);
1075
1076     switch (value)
1077     {
1078     case 0: str = "Not used"; break;
1079     case 1: str = "MS Termination"; break;
1080     case 2: str = "Voice Mail Storage"; break;
1081     case 3: str = "Voice Mail Retrieval"; break;
1082     case 4: str = "Dialogue Termination"; break;
1083     default:
1084         if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Unrecognized parameter value"; }
1085         else { str = "Reserved for protocol extension, treat as Unrecognized parameter value"; }
1086         break;
1087     }
1088
1089     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1090         saved_offset, asn1->offset - saved_offset,
1091         str);
1092
1093     EXTRANEOUS_DATA_CHECK(len, 1);
1094 }
1095
1096 static void
1097 param_term_trig(ASN1_SCK *asn1, proto_tree *tree, guint len)
1098 {
1099     gint32 value;
1100     guint saved_offset;
1101     gchar *str = NULL;
1102
1103     SHORT_DATA_CHECK(len, 2);
1104
1105     saved_offset = asn1->offset;
1106
1107     asn1_int32_value_decode(asn1, 1, &value);
1108
1109     switch ((value & 0xc0) >> 6)
1110     {
1111     case 0: str = "No Answer Call"; break;
1112     case 1: str = "No Answer Trigger"; break;
1113     case 2: str = "No Answer Leg"; break;
1114     case 3: str = "Reserved"; break;
1115     }
1116
1117     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
1118     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1119         saved_offset, asn1->offset - saved_offset,
1120         "%s :  No Answer (NA), %s",
1121         bigbuf,
1122         str);
1123
1124     switch ((value & 0x30) >> 4)
1125     {
1126     case 0: str = "No Page Response Call"; break;
1127     case 1: str = "No Page Response Trigger"; break;
1128     case 2: str = "No Page Response Leg"; break;
1129     case 3: str = "Reserved"; break;
1130     }
1131
1132     my_decode_bitfield_value(bigbuf, value, 0x30, 8);
1133     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1134         saved_offset, asn1->offset - saved_offset,
1135         "%s :  No Page Response (NPR), %s",
1136         bigbuf,
1137         str);
1138
1139     switch ((value & 0x0c) >> 2)
1140     {
1141     case 0: str = "Failed Call"; break;
1142     case 1: str = "Routing Failure Trigger"; break;
1143     case 2: str = "Failed Leg"; break;
1144     case 3: str = "Reserved"; break;
1145     }
1146
1147     my_decode_bitfield_value(bigbuf, value, 0x0c, 8);
1148     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1149         saved_offset, asn1->offset - saved_offset,
1150         "%s :  Routing Failure (RF), %s",
1151         bigbuf,
1152         str);
1153
1154     switch (value & 0x03)
1155     {
1156     case 0: str = "Busy Call"; break;
1157     case 1: str = "Busy Trigger"; break;
1158     case 2: str = "Busy Leg"; break;
1159     case 3: str = "Reserved"; break;
1160     }
1161
1162     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
1163     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1164         saved_offset, asn1->offset - saved_offset,
1165         "%s :  Busy, %s",
1166         bigbuf,
1167         str);
1168
1169     saved_offset = asn1->offset;
1170
1171     asn1_int32_value_decode(asn1, 1, &value);
1172
1173     my_decode_bitfield_value(bigbuf, value, 0xfe, 8);
1174     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1175         saved_offset, asn1->offset - saved_offset,
1176         "%s :  Reserved",
1177         bigbuf);
1178
1179     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
1180     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1181         saved_offset, asn1->offset - saved_offset,
1182         "%s :  None Reachable (NR), %s",
1183         bigbuf,
1184         (value & 0x01) ? "Group Not Reachable" : "Member Not Reachable");
1185
1186     EXTRANEOUS_DATA_CHECK(len, 2);
1187 }
1188
1189 static void
1190 param_aav(ASN1_SCK *asn1, proto_tree *tree, guint len)
1191 {
1192     gint32 value;
1193     guint saved_offset;
1194
1195     saved_offset = asn1->offset;
1196
1197     asn1_int32_value_decode(asn1, 1, &value);
1198
1199     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1200         saved_offset, asn1->offset - saved_offset,
1201         "Value as used in the CAVE algorithm (%d)",
1202         value);
1203
1204     EXTRANEOUS_DATA_CHECK(len, 1);
1205 }
1206
1207 static void
1208 param_ann_code(ASN1_SCK *asn1, proto_tree *tree, guint len)
1209 {
1210     gint32 value;
1211     guint saved_offset;
1212     gchar *str = NULL;
1213
1214     SHORT_DATA_CHECK(len, 3);
1215
1216     saved_offset = asn1->offset;
1217
1218     asn1_int32_value_decode(asn1, 1, &value);
1219
1220     switch (value)
1221     {
1222     case 0: str = "Dialtone"; break;
1223     case 1: str = "Ringback or Audible Alerting"; break;
1224     case 2: str = "Intercept or Mobile Reorder"; break;
1225     case 3: str = "Congestion or Reorder"; break;
1226     case 4: str = "Busy"; break;
1227     case 5: str = "Confirmation"; break;
1228     case 6: str = "Answer"; break;
1229     case 7: str = "Call Waiting"; break;
1230     case 8: str = "Offhook"; break;
1231     case 17: str = "Recall Dial"; break;
1232     case 18: str = "Barge In"; break;
1233     case 20: str = "PPC Insufficient"; break;
1234     case 21: str = "PPC Warning 1"; break;
1235     case 22: str = "PPC Warning 2"; break;
1236     case 23: str = "PPC Warning 3"; break;
1237     case 24: str = "PPC Disconnect"; break;
1238     case 25: str = "PPC Redirect"; break;
1239     case 63: str = "Tones Off"; break;
1240     case 192: str = "Pip"; break;
1241     case 193: str = "Abbreviated Intercept"; break;
1242     case 194: str = "Abbreviated Congestion"; break;
1243     case 195: str = "Warning"; break;
1244     case 196: str = "Denial Tone Burst"; break;
1245     case 197: str = "Dial Tone Burst"; break;
1246     case 250: str = "Incoming Additional Call"; break;
1247     case 251: str = "Priority Additional Call"; break;
1248     default:
1249         str = "Reserved, treat as Tones Off";
1250         break;
1251     }
1252
1253     my_decode_bitfield_value(bigbuf, value, 0xff, 8);
1254     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1255         saved_offset, asn1->offset - saved_offset,
1256         "%s :  Tone %d, %s",
1257         bigbuf,
1258         value,
1259         str);
1260
1261     saved_offset = asn1->offset;
1262
1263     asn1_int32_value_decode(asn1, 1, &value);
1264
1265     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
1266     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1267         saved_offset, asn1->offset - saved_offset,
1268         "%s :  Reserved",
1269         bigbuf);
1270
1271     switch (value & 0x0f)
1272     {
1273     case 0: str = "Concurrent"; break;
1274     case 1: str = "Sequential"; break;
1275     default:
1276         if ((value >= 2) && (value <= 7)) { str = "Reserved, treat as Concurrent"; }
1277         else { str = "Reserved, treat as Sequential"; }
1278         break;
1279     }
1280
1281     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
1282     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1283         saved_offset, asn1->offset - saved_offset,
1284         "%s :  Class %s",
1285         bigbuf,
1286         str);
1287
1288     saved_offset = asn1->offset;
1289
1290     asn1_int32_value_decode(asn1, 1, &value);
1291
1292     switch (value)
1293     {
1294     case 0: str = "None"; break;
1295     case 1: str = "Unauthorized User"; break;
1296     case 2: str = "Invalid ESN"; break;
1297     case 3: str = "Unauthorized Mobile"; break;
1298     case 4: str = "Suspended Origination"; break;
1299     case 5: str = "Origination Denied"; break;
1300     case 6: str = "Service Area Denial"; break;
1301     case 16: str = "Partial Dial"; break;
1302     case 17: str = "Require 1 Plus"; break;
1303     case 18: str = "Require 1 Plus NPA"; break;
1304     case 19: str = "Require 0 Plus"; break;
1305     case 20: str = "Require 0 Plus NPA"; break;
1306     case 21: str = "Deny 1 Plus"; break;
1307     case 22: str = "Unsupported 10 plus"; break;
1308     case 23: str = "Deny 10 plus"; break;
1309     case 24: str = "Unsupported 10 XXX"; break;
1310     case 25: str = "Deny 10 XXX"; break;
1311     case 26: str = "Deny 10 XXX Locally"; break;
1312     case 27: str = "Require 10 Plus"; break;
1313     case 28: str = "Require NPA"; break;
1314     case 29: str = "Deny Toll Origination"; break;
1315     case 30: str = "Deny International Origination"; break;
1316     case 31: str = "Deny 0 Minus"; break;
1317     case 48: str = "Deny Number"; break;
1318     case 49: str = "Alternate Operator Services"; break;
1319     case 64: str = "No Circuit or All Circuits Busy or FacilityProblem"; break;
1320     case 65: str = "Overload"; break;
1321     case 66: str = "Internal Office Failure"; break;
1322     case 67: str = "No Wink Received"; break;
1323     case 68: str = "Interoffice Link Failure"; break;
1324     case 69: str = "Vacant"; break;
1325     case 70: str = "Invalid Prefix or Invalid Access Code"; break;
1326     case 71: str = "Other Dialing Irregularity"; break;
1327     case 80: str = "Vacant Number or Disconnected Number"; break;
1328     case 81: str = "Deny Termination"; break;
1329     case 82: str = "Suspended Termination"; break;
1330     case 83: str = "Changed Number"; break;
1331     case 84: str = "Inaccessible Subscriber"; break;
1332     case 85: str = "Deny Incoming Toll"; break;
1333     case 86: str = "Roamer Access Screening"; break;
1334     case 87: str = "Refuse Call"; break;
1335     case 88: str = "Redirect Call"; break;
1336     case 89: str = "No Page Response"; break;
1337     case 90: str = "No Answer"; break;
1338     case 96: str = "Roamer Intercept"; break;
1339     case 97: str = "General Information"; break;
1340     case 112: str = "Unrecognized Feature Code"; break;
1341     case 113: str = "Unauthorized Feature Code"; break;
1342     case 114: str = "Restricted Feature Code"; break;
1343     case 115: str = "Invalid Modifier Digits"; break;
1344     case 116: str = "Successful Feature Registration"; break;
1345     case 117: str = "Successful Feature Deregistration"; break;
1346     case 118: str = "Successful Feature Activation"; break;
1347     case 119: str = "Successful Feature Deactivation"; break;
1348     case 120: str = "Invalid Forward To Number"; break;
1349     case 121: str = "Courtesy Call Warning"; break;
1350     case 128: str = "Enter PIN Send Prompt"; break;
1351     case 129: str = "Enter PIN Prompt"; break;
1352     case 130: str = "Reenter PIN Send Prompt"; break;
1353     case 131: str = "Reenter PIN Prompt"; break;
1354     case 132: str = "Enter Old PIN Send Prompt"; break;
1355     case 133: str = "Enter Old PIN Prompt"; break;
1356     case 134: str = "Enter New PIN Send Prompt"; break;
1357     case 135: str = "Enter New PIN Prompt"; break;
1358     case 136: str = "Reenter New PIN Send Prompt"; break;
1359     case 137: str = "Reenter New PIN Prompt"; break;
1360     case 138: str = "Enter Password Prompt"; break;
1361     case 139: str = "Enter Directory Number Prompt"; break;
1362     case 140: str = "Reenter Directory Number Prompt"; break;
1363     case 141: str = "Enter Feature Code Prompt"; break;
1364     case 142: str = "Enter Credit Card Number Prompt"; break;
1365     case 143: str = "Enter Destination Number Prompt"; break;
1366     case 152: str = "PPC Insufficient Account Balance"; break;
1367     case 153: str = "PPC Five Minute Warning"; break;
1368     case 154: str = "PPC Three Minute Warning"; break;
1369     case 155: str = "PPC Two Minute Warning"; break;
1370     case 156: str = "PPC One Minute Warning"; break;
1371     case 157: str = "PPC Disconnect"; break;
1372     case 158: str = "PPC Redirect"; break;
1373     default:
1374         str = "Reserved, treat as None";
1375         break;
1376     }
1377
1378     my_decode_bitfield_value(bigbuf, value, 0xff, 8);
1379     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1380         saved_offset, asn1->offset - saved_offset,
1381         "%s :  Standard Announcement, %s",
1382         bigbuf,
1383         str);
1384
1385     if (len == 3) return;
1386
1387     saved_offset = asn1->offset;
1388
1389     asn1_int32_value_decode(asn1, 1, &value);
1390
1391     my_decode_bitfield_value(bigbuf, value, 0xff, 8);
1392     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1393         saved_offset, asn1->offset - saved_offset,
1394         "%s :  Custom Announcement %d",
1395         bigbuf,
1396         value);
1397
1398     EXTRANEOUS_DATA_CHECK(len, 4);
1399 }
1400
1401 static void
1402 param_alert_res(ASN1_SCK *asn1, proto_tree *tree, guint len)
1403 {
1404     gint32 value;
1405     guint saved_offset;
1406     gchar *str = NULL;
1407
1408     saved_offset = asn1->offset;
1409
1410     asn1_int32_value_decode(asn1, 1, &value);
1411
1412     switch (value)
1413     {
1414     case 0: str = "Not specified"; break;
1415     case 1: str = "Success"; break;
1416     case 2: str = "Failure"; break;
1417     case 3: str = "Denied"; break;
1418     case 4: str = "Not attempted"; break;
1419     case 5: str = "No page response"; break;
1420     case 6: str = "Busy"; break;
1421     default:
1422         str = "Reserved, treat as Not specified";
1423         break;
1424     }
1425
1426     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1427         saved_offset, asn1->offset - saved_offset,
1428         str);
1429
1430     EXTRANEOUS_DATA_CHECK(len, 1);
1431 }
1432
1433 static void
1434 param_conf_call_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
1435 {
1436     gint32 value;
1437     guint saved_offset;
1438     gchar *str = NULL;
1439
1440     saved_offset = asn1->offset;
1441
1442     asn1_int32_value_decode(asn1, 1, &value);
1443
1444     switch (value)
1445     {
1446     case 0: str = ", Not specified"; break;
1447     case 255: str = ", Unlimited number of conferees"; break;
1448     default:
1449         str = "";
1450         break;
1451     }
1452
1453     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1454         saved_offset, asn1->offset - saved_offset,
1455         "Maximum Number of Conferees, (%d)%s",
1456         value,
1457         str);
1458
1459     EXTRANEOUS_DATA_CHECK(len, 1);
1460 }
1461
1462 static void
1463 param_count_upd_report(ASN1_SCK *asn1, proto_tree *tree, guint len)
1464 {
1465     gint32 value;
1466     guint saved_offset;
1467     gchar *str = NULL;
1468
1469     saved_offset = asn1->offset;
1470
1471     asn1_int32_value_decode(asn1, 1, &value);
1472
1473     switch (value)
1474     {
1475     case 0: str = "Not used"; break;
1476     case 1: str = "COUNT Update not attempted"; break;
1477     case 2: str = "COUNT Update no response"; break;
1478     case 3: str = "COUNT Update successful"; break;
1479     default:
1480         if ((value >= 4) && (value <= 223)) { str = "Reserved, treat as COUNT Update not attempted"; }
1481         else { str = "Reserved for protocol extension, treat as COUNT Update not attempted"; }
1482         break;
1483     }
1484
1485     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1486         saved_offset, asn1->offset - saved_offset,
1487         str);
1488
1489     EXTRANEOUS_DATA_CHECK(len, 1);
1490 }
1491
1492 static void
1493 param_ssd_upd_report(ASN1_SCK *asn1, proto_tree *tree, guint len)
1494 {
1495     gint32 value;
1496     guint saved_offset;
1497     gchar *str = NULL;
1498
1499     saved_offset = asn1->offset;
1500
1501     asn1_int32_value_decode(asn1, 1, &value);
1502
1503     switch (value)
1504     {
1505     case 0: str = "Not used"; break;
1506     case 1: str = "SSD Update not attempted"; break;
1507     case 2: str = "SSD Update no response"; break;
1508     case 3: str = "SSD Update successful"; break;
1509     case 4: str = "SSD Update failed"; break;
1510     default:
1511         if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as SSD Update not attempted"; }
1512         else { str = "Reserved for protocol extension, treat as SSD Update not attempted"; }
1513         break;
1514     }
1515
1516     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1517         saved_offset, asn1->offset - saved_offset,
1518         str);
1519
1520     EXTRANEOUS_DATA_CHECK(len, 1);
1521 }
1522
1523 static void
1524 param_cond_den_reason(ASN1_SCK *asn1, proto_tree *tree, guint len)
1525 {
1526     gint32 value;
1527     guint saved_offset;
1528     gchar *str = NULL;
1529
1530     EXACT_DATA_CHECK(len, 1);
1531
1532     saved_offset = asn1->offset;
1533
1534     asn1_int32_value_decode(asn1, 1, &value);
1535
1536     switch (value)
1537     {
1538     case 0: str = "Not used"; break;
1539     case 1: str = "Waitable (i.e., Call Waiting is possible)"; break;
1540     default:
1541         if ((value >= 2) && (value <= 223)) { str = "Reserved, treat as Waitable"; }
1542         else { str = "Reserved for protocol extension, treat as Waitable"; }
1543         break;
1544     }
1545
1546     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1547         saved_offset, asn1->offset - saved_offset,
1548         str);
1549 }
1550
1551 static void
1552 param_den_auth_per(ASN1_SCK *asn1, proto_tree *tree, guint len)
1553 {
1554     gint32 value;
1555     guint saved_offset;
1556     gchar *str = NULL;
1557
1558     SHORT_DATA_CHECK(len, 2);
1559
1560     saved_offset = asn1->offset;
1561
1562     asn1_int32_value_decode(asn1, 1, &value);
1563
1564     switch (value)
1565     {
1566     case 0: str = "Not used"; break;
1567     case 1: str = "Per Call. Re-authorization should be attempted on the next call attempt"; break;
1568     case 2: str = "Hours"; break;
1569     case 3: str = "Days"; break;
1570     case 4: str = "Weeks"; break;
1571     case 5: str = "Per Agreement"; break;
1572     case 6: str = "Reserved"; break;
1573     case 7: str = "Number of calls. Re-authorization should be attempted after this number of (rejected) call attempts"; break;
1574     case 8: str = "Minutes"; break;
1575     default:
1576         if ((value >= 9) && (value <= 223)) { str = "Reserved, treat as Per Call"; }
1577         else { str = "Reserved for protocol extension, treat as Per Call"; }
1578         break;
1579     }
1580
1581     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1582         saved_offset, asn1->offset - saved_offset,
1583         "Period, %s",
1584         str);
1585
1586     saved_offset = asn1->offset;
1587
1588     asn1_int32_value_decode(asn1, 1, &value);
1589
1590     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1591         saved_offset, asn1->offset - saved_offset,
1592         "Value %d",
1593         value);
1594
1595     EXTRANEOUS_DATA_CHECK(len, 2);
1596 }
1597
1598 static void
1599 param_ho_state(ASN1_SCK *asn1, proto_tree *tree, guint len)
1600 {
1601     gint32 value;
1602     guint saved_offset;
1603
1604     saved_offset = asn1->offset;
1605
1606     asn1_int32_value_decode(asn1, 1, &value);
1607
1608     my_decode_bitfield_value(bigbuf, value, 0xfe, 8);
1609     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1610         saved_offset, asn1->offset - saved_offset,
1611         "%s :  Reserved",
1612         bigbuf);
1613
1614     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
1615     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1616         saved_offset, asn1->offset - saved_offset,
1617         "%s :  Party Involved (PI), %s",
1618         bigbuf,
1619         (value & 0x01) ? "Terminator is handing off" : "Originator is handing off");
1620
1621     EXTRANEOUS_DATA_CHECK(len, 1);
1622 }
1623
1624 static void
1625 param_geo_auth(ASN1_SCK *asn1, proto_tree *tree, guint len)
1626 {
1627     gint32 value;
1628     guint saved_offset;
1629     gchar *str = NULL;
1630
1631     saved_offset = asn1->offset;
1632
1633     asn1_int32_value_decode(asn1, 1, &value);
1634
1635     switch (value)
1636     {
1637     case 0: str = "Not used"; break;
1638     case 1: str = "Authorized for all Market IDs served by the VLR"; break;
1639     case 2: str = "Authorized for this Market ID only"; break;
1640     case 3: str = "Authorized for this Market ID and Switch Number only"; break;
1641     case 4: str = "Authorized for this Location Area ID within a Market ID only"; break;
1642     default:
1643         if ((value >= 5) && (value <= 95)) { str = "Reserved, treat as Authorized for all Market IDs served by the VLR"; }
1644         else if ((value >= 96) && (value <= 127)) { str = "Reserved for protocol extension, treat as Authorized for all Market IDs served by the VLR"; }
1645         else if ((value >= 128) && (value <= 223)) { str = "Reserved, treat as Authorized for this Location Area ID within a Market ID only"; }
1646         else { str = "Reserved for protocol extension, treat as Authorized for this Location Area ID within a Market ID only"; }
1647         break;
1648     }
1649
1650     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1651         saved_offset, asn1->offset - saved_offset,
1652         str);
1653
1654     EXTRANEOUS_DATA_CHECK(len, 1);
1655 }
1656
1657 static void
1658 param_mw_noti_type(ASN1_SCK *asn1, proto_tree *tree, guint len)
1659 {
1660     gint32 value;
1661     guint saved_offset;
1662     gchar *str = NULL;
1663
1664     saved_offset = asn1->offset;
1665
1666     asn1_int32_value_decode(asn1, 1, &value);
1667
1668     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
1669     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1670         saved_offset, asn1->offset - saved_offset,
1671         "%s :  Reserved",
1672         bigbuf);
1673
1674     switch ((value & 0x0c) >> 2)
1675     {
1676     case 0: str = "No MWI. Notification is not authorized or notification is not required"; break;
1677     case 1: str = "Reserved"; break;
1678     case 2: str = "MWI On. Notification is required. Messages waiting"; break;
1679     case 3: str = "MWI Off. Notification is required. No messages waiting"; break;
1680     }
1681
1682     my_decode_bitfield_value(bigbuf, value, 0x0c, 8);
1683     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1684         saved_offset, asn1->offset - saved_offset,
1685         "%s :  Message Waiting Indication (MWI), %s",
1686         bigbuf,
1687         str);
1688
1689     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
1690     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1691         saved_offset, asn1->offset - saved_offset,
1692         "%s :  Alert Pip Tone (APT), %s",
1693         bigbuf,
1694         (value & 0x02) ? "notification is required" : "notification is not authorized or notification is not required");
1695
1696     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
1697     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1698         saved_offset, asn1->offset - saved_offset,
1699         "%s :  Pip Tone (PT), %s",
1700         bigbuf,
1701         (value & 0x01) ? "notification is required" : "notification is not authorized or notification is not required");
1702
1703     EXTRANEOUS_DATA_CHECK(len, 1);
1704 }
1705
1706 static void
1707 param_paca_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
1708 {
1709     gint32 value;
1710     guint saved_offset;
1711     gchar *str = NULL;
1712
1713     saved_offset = asn1->offset;
1714
1715     asn1_int32_value_decode(asn1, 1, &value);
1716
1717     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
1718     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1719         saved_offset, asn1->offset - saved_offset,
1720         "%s :  Reserved",
1721         bigbuf);
1722
1723     switch ((value & 0x1e) >> 1)
1724     {
1725     case 0: str = "Not used"; break;
1726     case 1: str = "Priority Level 1"; break;
1727     case 2: str = "Priority Level 2"; break;
1728     case 3: str = "Priority Level 3"; break;
1729     case 4: str = "Priority Level 4"; break;
1730     case 5: str = "Priority Level 5"; break;
1731     case 6: str = "Priority Level 6"; break;
1732     case 7: str = "Priority Level 7"; break;
1733     case 8: str = "Priority Level 8"; break;
1734     case 9: str = "Priority Level 9"; break;
1735     case 10: str = "Priority Level 10"; break;
1736     case 11: str = "Priority Level 11"; break;
1737     case 12: str = "Priority Level 12"; break;
1738     case 13: str = "Priority Level 13"; break;
1739     case 14: str = "Priority Level 14"; break;
1740     case 15: str = "Priority Level 15"; break;
1741     }
1742
1743     my_decode_bitfield_value(bigbuf, value, 0x1e, 8);
1744     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1745         saved_offset, asn1->offset - saved_offset,
1746         "%s :  PACA Level, %s",
1747         bigbuf,
1748         str);
1749
1750     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
1751     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1752         saved_offset, asn1->offset - saved_offset,
1753         "%s :  PACA is %spermanently activated",
1754         bigbuf,
1755         (value & 0x01) ? "" : "not ");
1756
1757     EXTRANEOUS_DATA_CHECK(len, 1);
1758 }
1759
1760 static void
1761 param_digit_collect_ctrl(ASN1_SCK *asn1, proto_tree *tree, guint len)
1762 {
1763     gint32 value;
1764     guint saved_offset;
1765     proto_item *item;
1766     proto_tree *subtree;
1767
1768     saved_offset = asn1->offset;
1769
1770     asn1_int32_value_decode(asn1, 1, &value);
1771
1772     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
1773     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1774         saved_offset, asn1->offset - saved_offset,
1775         "%s :  Break (BRK), %s",
1776         bigbuf,
1777         (value & 0x80) ? "Break In (default)" : "No Break");
1778
1779     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
1780     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1781         saved_offset, asn1->offset - saved_offset,
1782         "%s :  Type Ahead (TA), %s",
1783         bigbuf,
1784         (value & 0x40) ? "Buffer (default)" : "No Type Ahead");
1785
1786     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
1787     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1788         saved_offset, asn1->offset - saved_offset,
1789         "%s :  Reserved",
1790         bigbuf);
1791
1792     my_decode_bitfield_value(bigbuf, value, 0x1f, 8);
1793     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1794         saved_offset, asn1->offset - saved_offset,
1795         "%s :  Maximum Collect (%d)",
1796         bigbuf,
1797         (value & 0x1f));
1798
1799     if (len == 1) return;
1800
1801     saved_offset = asn1->offset;
1802
1803     asn1_int32_value_decode(asn1, 1, &value);
1804
1805     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
1806     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1807         saved_offset, asn1->offset - saved_offset,
1808         "%s :  Reserved",
1809         bigbuf);
1810
1811     my_decode_bitfield_value(bigbuf, value, 0x1f, 8);
1812     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1813         saved_offset, asn1->offset - saved_offset,
1814         "%s :  Minimum Collect (%d)",
1815         bigbuf,
1816         (value & 0x1f));
1817
1818     if (len == 2) return;
1819
1820     saved_offset = asn1->offset;
1821
1822     asn1_int32_value_decode(asn1, 1, &value);
1823
1824     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1825         saved_offset, asn1->offset - saved_offset,
1826         "Maximum Interaction Time (%d) seconds",
1827         value);
1828
1829     if (len == 3) return;
1830
1831     saved_offset = asn1->offset;
1832
1833     asn1_int32_value_decode(asn1, 1, &value);
1834
1835     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
1836     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1837         saved_offset, asn1->offset - saved_offset,
1838         "%s :  Reserved",
1839         bigbuf);
1840
1841     my_decode_bitfield_value(bigbuf, value, 0x1f, 8);
1842     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1843         saved_offset, asn1->offset - saved_offset,
1844         "%s :  Initial Interdigit Time (%d) seconds",
1845         bigbuf,
1846         (value & 0x1f));
1847
1848     if (len == 4) return;
1849
1850     saved_offset = asn1->offset;
1851
1852     asn1_int32_value_decode(asn1, 1, &value);
1853
1854     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
1855     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1856         saved_offset, asn1->offset - saved_offset,
1857         "%s :  Reserved",
1858         bigbuf);
1859
1860     my_decode_bitfield_value(bigbuf, value, 0x1f, 8);
1861     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
1862         saved_offset, asn1->offset - saved_offset,
1863         "%s :  Normal Interdigit Time (%d) seconds",
1864         bigbuf,
1865         (value & 0x1f));
1866
1867     if (len == 5) return;
1868
1869     saved_offset = asn1->offset;
1870
1871     item =
1872         proto_tree_add_text(tree, asn1->tvb,
1873             saved_offset, (len > 6) ? 2 : 1,
1874             "Clear Digits Digit Mask");
1875
1876     subtree = proto_item_add_subtree(item, ett_clr_dig_mask);
1877
1878     asn1_int32_value_decode(asn1, 1, &value);
1879
1880     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
1881     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1882         saved_offset, asn1->offset - saved_offset,
1883         "%s :  7 Digit",
1884         bigbuf);
1885
1886     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
1887     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1888         saved_offset, asn1->offset - saved_offset,
1889         "%s :  6 Digit",
1890         bigbuf);
1891
1892     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
1893     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1894         saved_offset, asn1->offset - saved_offset,
1895         "%s :  5 Digit",
1896         bigbuf);
1897
1898     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
1899     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1900         saved_offset, asn1->offset - saved_offset,
1901         "%s :  4 Digit",
1902         bigbuf);
1903
1904     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
1905     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1906         saved_offset, asn1->offset - saved_offset,
1907         "%s :  3 Digit",
1908         bigbuf);
1909
1910     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
1911     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1912         saved_offset, asn1->offset - saved_offset,
1913         "%s :  2 Digit",
1914         bigbuf);
1915
1916     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
1917     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1918         saved_offset, asn1->offset - saved_offset,
1919         "%s :  1 Digit",
1920         bigbuf);
1921
1922     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
1923     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1924         saved_offset, asn1->offset - saved_offset,
1925         "%s :  0 Digit",
1926         bigbuf);
1927
1928     if (len == 6) return;
1929
1930     saved_offset = asn1->offset;
1931
1932     asn1_int32_value_decode(asn1, 1, &value);
1933
1934     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
1935     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1936         saved_offset, asn1->offset - saved_offset,
1937         "%s :  Reserved",
1938         bigbuf);
1939
1940     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
1941     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1942         saved_offset, asn1->offset - saved_offset,
1943         "%s :  # Digit",
1944         bigbuf);
1945
1946     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
1947     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1948         saved_offset, asn1->offset - saved_offset,
1949         "%s :  * Digit",
1950         bigbuf);
1951
1952     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
1953     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1954         saved_offset, asn1->offset - saved_offset,
1955         "%s :  Reserved",
1956         bigbuf);
1957
1958     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
1959     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1960         saved_offset, asn1->offset - saved_offset,
1961         "%s :  9 Digit",
1962         bigbuf);
1963
1964     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
1965     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1966         saved_offset, asn1->offset - saved_offset,
1967         "%s :  8 Digit",
1968         bigbuf);
1969
1970     if (len == 7) return;
1971
1972     saved_offset = asn1->offset;
1973
1974     item =
1975         proto_tree_add_text(tree, asn1->tvb,
1976             saved_offset, (len > 8) ? 2 : 1,
1977             "Enter Digits Digit Mask");
1978
1979     subtree = proto_item_add_subtree(item, ett_ent_dig_mask);
1980
1981     asn1_int32_value_decode(asn1, 1, &value);
1982
1983     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
1984     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1985         saved_offset, asn1->offset - saved_offset,
1986         "%s :  7 Digit",
1987         bigbuf);
1988
1989     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
1990     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1991         saved_offset, asn1->offset - saved_offset,
1992         "%s :  6 Digit",
1993         bigbuf);
1994
1995     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
1996     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
1997         saved_offset, asn1->offset - saved_offset,
1998         "%s :  5 Digit",
1999         bigbuf);
2000
2001     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
2002     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2003         saved_offset, asn1->offset - saved_offset,
2004         "%s :  4 Digit",
2005         bigbuf);
2006
2007     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
2008     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2009         saved_offset, asn1->offset - saved_offset,
2010         "%s :  3 Digit",
2011         bigbuf);
2012
2013     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
2014     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2015         saved_offset, asn1->offset - saved_offset,
2016         "%s :  2 Digit",
2017         bigbuf);
2018
2019     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
2020     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2021         saved_offset, asn1->offset - saved_offset,
2022         "%s :  1 Digit",
2023         bigbuf);
2024
2025     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
2026     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2027         saved_offset, asn1->offset - saved_offset,
2028         "%s :  0 Digit",
2029         bigbuf);
2030
2031     if (len == 8) return;
2032
2033     saved_offset = asn1->offset;
2034
2035     asn1_int32_value_decode(asn1, 1, &value);
2036
2037     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
2038     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2039         saved_offset, asn1->offset - saved_offset,
2040         "%s :  Reserved",
2041         bigbuf);
2042
2043     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
2044     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2045         saved_offset, asn1->offset - saved_offset,
2046         "%s :  # Digit",
2047         bigbuf);
2048
2049     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
2050     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2051         saved_offset, asn1->offset - saved_offset,
2052         "%s :  * Digit",
2053         bigbuf);
2054
2055     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
2056     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2057         saved_offset, asn1->offset - saved_offset,
2058         "%s :  Reserved",
2059         bigbuf);
2060
2061     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
2062     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2063         saved_offset, asn1->offset - saved_offset,
2064         "%s :  9 Digit",
2065         bigbuf);
2066
2067     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
2068     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2069         saved_offset, asn1->offset - saved_offset,
2070         "%s :  8 Digit",
2071         bigbuf);
2072
2073     if (len == 9) return;
2074
2075     saved_offset = asn1->offset;
2076
2077     item =
2078         proto_tree_add_text(tree, asn1->tvb,
2079             saved_offset, (len > 10) ? 2 : 1,
2080             "Allowed Digits Digit Mask");
2081
2082     subtree = proto_item_add_subtree(item, ett_all_dig_mask);
2083
2084     asn1_int32_value_decode(asn1, 1, &value);
2085
2086     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
2087     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2088         saved_offset, asn1->offset - saved_offset,
2089         "%s :  7 Digit",
2090         bigbuf);
2091
2092     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
2093     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2094         saved_offset, asn1->offset - saved_offset,
2095         "%s :  6 Digit",
2096         bigbuf);
2097
2098     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
2099     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2100         saved_offset, asn1->offset - saved_offset,
2101         "%s :  5 Digit",
2102         bigbuf);
2103
2104     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
2105     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2106         saved_offset, asn1->offset - saved_offset,
2107         "%s :  4 Digit",
2108         bigbuf);
2109
2110     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
2111     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2112         saved_offset, asn1->offset - saved_offset,
2113         "%s :  3 Digit",
2114         bigbuf);
2115
2116     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
2117     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2118         saved_offset, asn1->offset - saved_offset,
2119         "%s :  2 Digit",
2120         bigbuf);
2121
2122     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
2123     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2124         saved_offset, asn1->offset - saved_offset,
2125         "%s :  1 Digit",
2126         bigbuf);
2127
2128     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
2129     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2130         saved_offset, asn1->offset - saved_offset,
2131         "%s :  0 Digit",
2132         bigbuf);
2133
2134     if (len == 10) return;
2135
2136     saved_offset = asn1->offset;
2137
2138     asn1_int32_value_decode(asn1, 1, &value);
2139
2140     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
2141     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2142         saved_offset, asn1->offset - saved_offset,
2143         "%s :  Reserved",
2144         bigbuf);
2145
2146     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
2147     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2148         saved_offset, asn1->offset - saved_offset,
2149         "%s :  # Digit",
2150         bigbuf);
2151
2152     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
2153     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2154         saved_offset, asn1->offset - saved_offset,
2155         "%s :  * Digit",
2156         bigbuf);
2157
2158     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
2159     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2160         saved_offset, asn1->offset - saved_offset,
2161         "%s :  Reserved",
2162         bigbuf);
2163
2164     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
2165     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2166         saved_offset, asn1->offset - saved_offset,
2167         "%s :  9 Digit",
2168         bigbuf);
2169
2170     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
2171     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
2172         saved_offset, asn1->offset - saved_offset,
2173         "%s :  8 Digit",
2174         bigbuf);
2175
2176     if (len == 11) return;
2177
2178     saved_offset = asn1->offset;
2179
2180     asn1_int32_value_decode(asn1, 1, &value);
2181
2182     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
2183     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2184         saved_offset, asn1->offset - saved_offset,
2185         "%s :  Reserved",
2186         bigbuf);
2187
2188     my_decode_bitfield_value(bigbuf, value, 0x1f, 8);
2189     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2190         saved_offset, asn1->offset - saved_offset,
2191         "%s :  Special Interdigit Time (%d)",
2192         bigbuf,
2193         value & 0x1f);
2194
2195     if (len == 12) return;
2196
2197     saved_offset = asn1->offset;
2198
2199     asn1_int32_value_decode(asn1, 1, &value);
2200
2201     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
2202     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2203         saved_offset, asn1->offset - saved_offset,
2204         "%s :  SIT 8",
2205         bigbuf);
2206
2207     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
2208     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2209         saved_offset, asn1->offset - saved_offset,
2210         "%s :  SIT 7",
2211         bigbuf);
2212
2213     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
2214     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2215         saved_offset, asn1->offset - saved_offset,
2216         "%s :  SIT 6",
2217         bigbuf);
2218
2219     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
2220     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2221         saved_offset, asn1->offset - saved_offset,
2222         "%s :  SIT 5",
2223         bigbuf);
2224
2225     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
2226     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2227         saved_offset, asn1->offset - saved_offset,
2228         "%s :  SIT 4",
2229         bigbuf);
2230
2231     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
2232     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2233         saved_offset, asn1->offset - saved_offset,
2234         "%s :  SIT 3",
2235         bigbuf);
2236
2237     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
2238     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2239         saved_offset, asn1->offset - saved_offset,
2240         "%s :  SIT 2",
2241         bigbuf);
2242
2243     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
2244     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2245         saved_offset, asn1->offset - saved_offset,
2246         "%s :  SIT 1",
2247         bigbuf);
2248
2249     if (len == 13) return;
2250
2251     saved_offset = asn1->offset;
2252
2253     asn1_int32_value_decode(asn1, 1, &value);
2254
2255     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
2256     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2257         saved_offset, asn1->offset - saved_offset,
2258         "%s :  SIT 16",
2259         bigbuf);
2260
2261     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
2262     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2263         saved_offset, asn1->offset - saved_offset,
2264         "%s :  SIT 15",
2265         bigbuf);
2266
2267     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
2268     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2269         saved_offset, asn1->offset - saved_offset,
2270         "%s :  SIT 14",
2271         bigbuf);
2272
2273     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
2274     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2275         saved_offset, asn1->offset - saved_offset,
2276         "%s :  SIT 13",
2277         bigbuf);
2278
2279     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
2280     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2281         saved_offset, asn1->offset - saved_offset,
2282         "%s :  SIT 12",
2283         bigbuf);
2284
2285     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
2286     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2287         saved_offset, asn1->offset - saved_offset,
2288         "%s :  SIT 11",
2289         bigbuf);
2290
2291     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
2292     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2293         saved_offset, asn1->offset - saved_offset,
2294         "%s :  SIT 10",
2295         bigbuf);
2296
2297     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
2298     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2299         saved_offset, asn1->offset - saved_offset,
2300         "%s :  SIT 9",
2301         bigbuf);
2302
2303     if (len == 14) return;
2304
2305     saved_offset = asn1->offset;
2306
2307     asn1_int32_value_decode(asn1, 1, &value);
2308
2309     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
2310     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2311         saved_offset, asn1->offset - saved_offset,
2312         "%s :  SIT 24",
2313         bigbuf);
2314
2315     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
2316     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2317         saved_offset, asn1->offset - saved_offset,
2318         "%s :  SIT 23",
2319         bigbuf);
2320
2321     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
2322     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2323         saved_offset, asn1->offset - saved_offset,
2324         "%s :  SIT 22",
2325         bigbuf);
2326
2327     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
2328     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2329         saved_offset, asn1->offset - saved_offset,
2330         "%s :  SIT 21",
2331         bigbuf);
2332
2333     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
2334     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2335         saved_offset, asn1->offset - saved_offset,
2336         "%s :  SIT 20",
2337         bigbuf);
2338
2339     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
2340     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2341         saved_offset, asn1->offset - saved_offset,
2342         "%s :  SIT 19",
2343         bigbuf);
2344
2345     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
2346     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2347         saved_offset, asn1->offset - saved_offset,
2348         "%s :  SIT 18",
2349         bigbuf);
2350
2351     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
2352     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2353         saved_offset, asn1->offset - saved_offset,
2354         "%s :  SIT 17",
2355         bigbuf);
2356
2357     if (len == 15) return;
2358
2359     saved_offset = asn1->offset;
2360
2361     asn1_int32_value_decode(asn1, 1, &value);
2362
2363     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
2364     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2365         saved_offset, asn1->offset - saved_offset,
2366         "%s :  Reserved",
2367         bigbuf);
2368
2369     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
2370     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2371         saved_offset, asn1->offset - saved_offset,
2372         "%s :  SIT 31",
2373         bigbuf);
2374
2375     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
2376     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2377         saved_offset, asn1->offset - saved_offset,
2378         "%s :  SIT 30",
2379         bigbuf);
2380
2381     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
2382     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2383         saved_offset, asn1->offset - saved_offset,
2384         "%s :  SIT 29",
2385         bigbuf);
2386
2387     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
2388     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2389         saved_offset, asn1->offset - saved_offset,
2390         "%s :  SIT 28",
2391         bigbuf);
2392
2393     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
2394     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2395         saved_offset, asn1->offset - saved_offset,
2396         "%s :  SIT 27",
2397         bigbuf);
2398
2399     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
2400     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2401         saved_offset, asn1->offset - saved_offset,
2402         "%s :  SIT 26",
2403         bigbuf);
2404
2405     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
2406     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2407         saved_offset, asn1->offset - saved_offset,
2408         "%s :  SIT 25",
2409         bigbuf);
2410
2411     EXTRANEOUS_DATA_CHECK(len, 16);
2412 }
2413
2414 static void
2415 param_no_ans_time(ASN1_SCK *asn1, proto_tree *tree, guint len)
2416 {
2417     gint32 value;
2418     guint saved_offset;
2419
2420     saved_offset = asn1->offset;
2421
2422     asn1_int32_value_decode(asn1, 1, &value);
2423
2424     proto_tree_add_text(tree, asn1->tvb,
2425         saved_offset, asn1->offset - saved_offset,
2426         "(%d) The number of seconds to wait after alerting an MS or after seizing an outgoing trunk before applying no answer trigger treatment.",
2427         value);
2428
2429     EXTRANEOUS_DATA_CHECK(len, 1);
2430 }
2431
2432 static void
2433 param_mw_noti_count(ASN1_SCK *asn1, proto_tree *tree, guint len)
2434 {
2435     gint32 value;
2436     guint saved_offset, orig_offset;
2437     gchar *str = NULL;
2438
2439     SHORT_DATA_CHECK(len, 2);
2440
2441     orig_offset = asn1->offset;
2442     saved_offset = asn1->offset;
2443
2444     do
2445     {
2446         asn1_int32_value_decode(asn1, 1, &value);
2447
2448         switch (value)
2449         {
2450         case 0: str = "Voice Messages"; break;
2451         case 1: str = "Short Message Services (SMS) messages"; break;
2452         case 2: str = "Group 3 (G3) Fax messages"; break;
2453         case 255: str = "Not specified"; break;
2454         default:
2455             str = "Reserved, treat as Not specified";
2456             break;
2457         }
2458
2459         proto_tree_add_text(tree, asn1->tvb,
2460             saved_offset, asn1->offset - saved_offset,
2461             "Type of messages, %s",
2462             str);
2463
2464         saved_offset = asn1->offset;
2465
2466         asn1_int32_value_decode(asn1, 1, &value);
2467
2468         switch (value)
2469         {
2470         case 0: str = "No messages are waiting"; break;
2471         case 254: str = "254 or more messages are waiting"; break;
2472         case 255: str = "An unknown number of messages are waiting (greater than zero)"; break;
2473         default:
2474             sprintf(bigbuf, "%d messages are waiting", value);
2475             str = bigbuf;
2476             break;
2477         }
2478
2479         proto_tree_add_text(tree, asn1->tvb,
2480             saved_offset, asn1->offset - saved_offset,
2481             str);
2482
2483         saved_offset = asn1->offset;
2484     }
2485     while ((len - (saved_offset - orig_offset)) >= 2);
2486
2487     EXTRANEOUS_DATA_CHECK((len - (saved_offset - orig_offset)), 0);
2488 }
2489
2490 static void
2491 param_otfi(ASN1_SCK *asn1, proto_tree *tree, guint len)
2492 {
2493     gint32 value;
2494     guint saved_offset;
2495     gchar *str = NULL;
2496
2497     saved_offset = asn1->offset;
2498
2499     asn1_int32_value_decode(asn1, 1, &value);
2500
2501     switch ((value & 0xc0) >> 6)
2502     {
2503     case 0: str = "Ignore"; break;
2504     case 1: str = "Presentation Allowed"; break;
2505     case 2: str = "Presentation Restricted"; break;
2506     case 3: str = "Reserved"; break;
2507     }
2508
2509     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
2510     proto_tree_add_text(tree, asn1->tvb,
2511         saved_offset, asn1->offset - saved_offset,
2512         "%s :  Calling Number ID Restriction, %s",
2513         bigbuf,
2514         str);
2515
2516     switch ((value & 0x30) >> 4)
2517     {
2518     case 0: str = "Ignore"; break;
2519     case 1: str = "Pip Tone Inactive"; break;
2520     case 2: str = "Pip Tone Active"; break;
2521     case 3: str = "Reserved"; break;
2522     }
2523
2524     my_decode_bitfield_value(bigbuf, value, 0x30, 8);
2525     proto_tree_add_text(tree, asn1->tvb,
2526         saved_offset, asn1->offset - saved_offset,
2527         "%s :  Message Waiting Notification, %s",
2528         bigbuf,
2529         str);
2530
2531     switch ((value & 0x0c) >> 2)
2532     {
2533     case 0: str = "Ignore"; break;
2534     case 1: str = "No CW"; break;
2535     case 2: str = "Normal CW"; break;
2536     case 3: str = "Priority CW"; break;
2537     }
2538
2539     my_decode_bitfield_value(bigbuf, value, 0x0c, 8);
2540     proto_tree_add_text(tree, asn1->tvb,
2541         saved_offset, asn1->offset - saved_offset,
2542         "%s :  Call Waiting for Incoming Call (CWIC), %s",
2543         bigbuf,
2544         str);
2545
2546     switch (value & 0x03)
2547     {
2548     case 0: str = "Ignore"; break;
2549     case 1: str = "No CW"; break;
2550     case 2: str = "Normal CW"; break;
2551     case 3: str = "Priority CW"; break;
2552     }
2553
2554     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
2555     proto_tree_add_text(tree, asn1->tvb,
2556         saved_offset, asn1->offset - saved_offset,
2557         "%s :  Call Waiting for Future Incoming Call (CWFI), %s",
2558         bigbuf,
2559         str);
2560
2561     if (len == 1) return;
2562
2563     saved_offset = asn1->offset;
2564
2565     asn1_int32_value_decode(asn1, 1, &value);
2566
2567     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
2568     proto_tree_add_text(tree, asn1->tvb,
2569         saved_offset, asn1->offset - saved_offset,
2570         "%s :  Reserved",
2571         bigbuf);
2572
2573     switch ((value & 0x30) >> 4)
2574     {
2575     case 0: str = "Ignore"; break;
2576     case 1: str = "Presentation Allowed"; break;
2577     case 2: str = "Presentation Restricted"; break;
2578     case 3: str = "Blocking Toggle"; break;
2579     }
2580
2581     my_decode_bitfield_value(bigbuf, value, 0x30, 8);
2582     proto_tree_add_text(tree, asn1->tvb,
2583         saved_offset, asn1->offset - saved_offset,
2584         "%s :  Calling Name Restriction (CNAR), %s",
2585         bigbuf,
2586         str);
2587
2588     switch ((value & 0x0c) >> 2)
2589     {
2590     case 0: str = "Ignore"; break;
2591     case 1: str = "Flash Inactive"; break;
2592     case 2: str = "Flash Active"; break;
2593     case 3: str = "Reserved"; break;
2594     }
2595
2596     my_decode_bitfield_value(bigbuf, value, 0x0c, 8);
2597     proto_tree_add_text(tree, asn1->tvb,
2598         saved_offset, asn1->offset - saved_offset,
2599         "%s :  Flash Privileges (Flash), %s",
2600         bigbuf,
2601         str);
2602
2603     switch (value & 0x03)
2604     {
2605     case 0: str = "Ignore"; break;
2606     case 1: str = "PACA Demand Inactive"; break;
2607     case 2: str = "PACA Demand Actived"; break;
2608     case 3: str = "Reserved"; break;
2609     }
2610
2611     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
2612     proto_tree_add_text(tree, asn1->tvb,
2613         saved_offset, asn1->offset - saved_offset,
2614         "%s :  Priority Access and Channel Assignment (PACA), %s",
2615         bigbuf,
2616         str);
2617
2618     EXTRANEOUS_DATA_CHECK(len, 2);
2619 }
2620
2621 /*
2622  * For:
2623  *      Authentication Response
2624  *      Authentication Response Base Station
2625  *      Authentication Response Unique Challenge
2626  */
2627 static void
2628 param_auth_resp_all(ASN1_SCK *asn1, proto_tree *tree, guint len)
2629 {
2630     gint32 value;
2631     guint saved_offset;
2632
2633     EXACT_DATA_CHECK(len, 3);
2634
2635     saved_offset = asn1->offset;
2636
2637     asn1_int32_value_decode(asn1, 1, &value);
2638
2639     my_decode_bitfield_value(bigbuf, value, 0xfc, 8);
2640     proto_tree_add_text(tree, asn1->tvb,
2641         saved_offset, asn1->offset - saved_offset,
2642         "%s :  Reserved",
2643         bigbuf);
2644
2645     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
2646     proto_tree_add_text(tree, asn1->tvb,
2647         saved_offset, asn1->offset - saved_offset,
2648         "%s :  Response (MSB)",
2649         bigbuf);
2650
2651     saved_offset = asn1->offset;
2652
2653     asn1_int32_value_decode(asn1, 1, &value);
2654
2655     my_decode_bitfield_value(bigbuf, value, 0xff, 8);
2656     proto_tree_add_text(tree, asn1->tvb,
2657         saved_offset, asn1->offset - saved_offset,
2658         "%s :  Response",
2659         bigbuf);
2660
2661     saved_offset = asn1->offset;
2662
2663     asn1_int32_value_decode(asn1, 1, &value);
2664
2665     my_decode_bitfield_value(bigbuf, value, 0xff, 8);
2666     proto_tree_add_text(tree, asn1->tvb,
2667         saved_offset, asn1->offset - saved_offset,
2668         "%s :  Response (LSB)",
2669         bigbuf);
2670 }
2671
2672 static void
2673 param_sys_acc_data(ASN1_SCK *asn1, proto_tree *tree, guint len)
2674 {
2675     gint32 value;
2676     guint saved_offset;
2677
2678     EXACT_DATA_CHECK(len, 5);
2679
2680     param_mscid(asn1, tree, 3);
2681
2682     saved_offset = asn1->offset;
2683     asn1_int32_value_decode(asn1, 2, &value);
2684
2685     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2686         saved_offset, asn1->offset - saved_offset,
2687         "Serving Cell ID %d",
2688         value);
2689 }
2690
2691 static void
2692 param_bill_id(ASN1_SCK *asn1, proto_tree *tree, guint len)
2693 {
2694     gint32 id, segcount;
2695     guint saved_offset;
2696     gchar *str = NULL;
2697
2698     EXACT_DATA_CHECK(len, 7);
2699
2700     param_mscid(asn1, tree, 3);
2701
2702     saved_offset = asn1->offset;
2703     asn1_int32_value_decode(asn1, 3, &id);
2704
2705     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2706         saved_offset, asn1->offset - saved_offset,
2707         "ID Number %d",
2708         id);
2709
2710     saved_offset = asn1->offset;
2711     asn1_int32_value_decode(asn1, 1, &segcount);
2712
2713     if (segcount == 255) { str = "Unspecified"; }
2714     else if ((segcount >= 0) && (segcount <= 127)) { str = "Number of call segments"; }
2715     else if ((segcount >= 128) && (segcount < 255)) { str = "Not used in TIA/EIA-41"; }
2716
2717     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2718         saved_offset, asn1->offset - saved_offset,
2719         "Segment Counter %d:  %s",
2720         segcount, str);
2721 }
2722
2723 static void
2724 param_cdma_so(ASN1_SCK *asn1, proto_tree *tree, guint len)
2725 {
2726     gint32 so;
2727     guint saved_offset;
2728     gchar *str = NULL;
2729
2730     SHORT_DATA_CHECK(len, 2);
2731
2732     saved_offset = asn1->offset;
2733     asn1_int32_value_decode(asn1, 2, &so);
2734
2735     switch (so)
2736     {
2737     case 1: str = "Basic Variable Rate Voice Service (8 kbps)"; break;
2738     case 2: str = "Mobile Station Loopback (8 kbps)"; break;
2739     case 3: str = "Enhanced Variable Rate Voice Service (8 kbps)"; break;
2740     case 4: str = "Asynchronous Data Service (9.6 kbps)"; break;
2741     case 5: str = "Group 3 Facsimile (9.6 kbps)"; break;
2742     case 6: str = "Short Message Services (Rate Set 1)"; break;
2743     case 7: str = "Packet Data Service: Internet or ISO Protocol Stack (9.6 kbps)"; break;
2744     case 8: str = "Packet Data Service: CDPD Protocol Stack (9.6 kbps)"; break;
2745     case 9: str = "Mobile Station Loopback (13 kbps)"; break;
2746     case 10: str = "STU-III Transparent Service"; break;
2747     case 11: str = "STU-III Non-Transparent Service"; break;
2748     case 12: str = "Asynchronous Data Service (14.4 or 9.6 kbps)"; break;
2749     case 13: str = "Group 3 Facsimile (14.4 or 9.6 kbps)"; break;
2750     case 14: str = "Short Message Services (Rate Set 2)"; break;
2751     case 15: str = "Packet Data Service: Internet or ISO Protocol Stack (14.4 kbps)"; break;
2752     case 16: str = "Packet Data Service: CDPD Protocol Stack (14.4 kbps)"; break;
2753     case 17: str = "High Rate Voice Service (13 kbps)"; break;
2754     case 32768: str = "QCELP (13 kbps)"; break;
2755     case 18: str = "Over-the-Air Parameter Administration (Rate Set 1)"; break;
2756     case 19: str = "Over-the-Air Parameter Administration (Rate Set 2)"; break;
2757     case 20: str = "Group 3 Analog Facsimile (Rate Set 1)"; break;
2758     case 21: str = "Group 3 Analog Facsimile (Rate Set 2)"; break;
2759     case 22: str = "High Speed Packet Data Service: Internet or ISO Protocol Stack (RS1 forward, RS1 reverse)"; break;
2760     case 23: str = "High Speed Packet Data Service: Internet or ISO Protocol Stack (RS1 forward, RS2 reverse)"; break;
2761     case 24: str = "High Speed Packet Data Service: Internet or ISO Protocol Stack (RS2 forward, RS1 reverse)"; break;
2762     case 25: str = "High Speed Packet Data Service: Internet or ISO Protocol Stack (RS2 forward, RS2 reverse)"; break;
2763     case 26: str = "High Speed Packet Data Service: CDPD Protocol Stack (RS1 forward, RS1 reverse)"; break;
2764     case 27: str = "High Speed Packet Data Service: CDPD Protocol Stack (RS1 forward, RS2 reverse)"; break;
2765     case 28: str = "High Speed Packet Data Service: CDPD Protocol Stack (RS2 forward, RS1 reverse)"; break;
2766     case 29: str = "High Speed Packet Data Service: CDPD Protocol Stack (RS2 forward, RS2 reverse)"; break;
2767     case 30: str = "Supplemental Channel Loopback Test for Rate Set 1"; break;
2768     case 31: str = "Supplemental Channel Loopback Test for Rate Set 2"; break;
2769     case 32: str = "Test Data Service Option (TDSO)"; break;
2770     case 33: str = "cdma2000 High Speed Packet Data Service, Internet or ISO Protocol Stack"; break;
2771     case 34: str = "cdma2000 High Speed Packet Data Service, CDPD Protocol Stack"; break;
2772     case 35: str = "Location Services, Rate Set 1 (9.6 kbps)"; break;
2773     case 36: str = "Location Services, Rate Set 2 (14.4 kbps)"; break;
2774     case 37: str = "ISDN Interworking Service (64 kbps)"; break;
2775     case 38: str = "GSM Voice"; break;
2776     case 39: str = "GSM Circuit Data"; break;
2777     case 40: str = "GSM Packet Data"; break;
2778     case 41: str = "GSM Short Message Service"; break;
2779     case 42: str = "None Reserved for MC-MAP standard service options"; break;
2780     case 54: str = "Markov Service Option (MSO)"; break;
2781     case 55: str = "Loopback Service Option (LSO)"; break;
2782     case 56: str = "Selectable Mode Vocoder"; break;
2783     case 57: str = "32 kbps Circuit Video Conferencing"; break;
2784     case 58: str = "64 kbps Circuit Video Conferencing"; break;
2785     case 59: str = "HRPD Accounting Records Identifier"; break;
2786     case 60: str = "Link Layer Assisted Robust Header Compression (LLA ROHC) - Header Removal"; break;
2787     case 61: str = "Link Layer Assisted Robust Header Compression (LLA ROHC) - Header Compression"; break;
2788     case 62: str = "- 4099 None Reserved for standard service options"; break;
2789     case 4100: str = "Asynchronous Data Service, Revision 1 (9.6 or 14.4 kbps)"; break;
2790     case 4101: str = "Group 3 Facsimile, Revision 1 (9.6 or 14.4 kbps)"; break;
2791     case 4102: str = "Reserved for standard service option"; break;
2792     case 4103: str = "Packet Data Service: Internet or ISO Protocol Stack, Revision 1 (9.6 or 14.4 kbps)"; break;
2793     case 4104: str = "Packet Data Service: CDPD Protocol Stack, Revision 1 (9.6 or 14.4 kbps)"; break;
2794     default:
2795         if ((so >= 4105) && (so <= 32767)) { str = "Reserved for standard service options"; }
2796         else if ((so >= 32769) && (so <= 32771)) { str = "Proprietary QUALCOMM Incorporated"; }
2797         else if ((so >= 32772) && (so <= 32775)) { str = "Proprietary OKI Telecom"; }
2798         else if ((so >= 32776) && (so <= 32779)) { str = "Proprietary Lucent Technologies"; }
2799         else if ((so >= 32780) && (so <=32783)) { str = "Nokia"; }
2800         else if ((so >= 32784) && (so <=32787)) { str = "NORTEL NETWORKS"; }
2801         else if ((so >= 32788) && (so <=32791)) { str = "Sony Electronics Inc."; }
2802         else if ((so >= 32792) && (so <=32795)) { str = "Motorola"; }
2803         else if ((so >= 32796) && (so <=32799)) { str = "QUALCOMM Incorporated"; }
2804         else if ((so >= 32800) && (so <=32803)) { str = "QUALCOMM Incorporated"; }
2805         else if ((so >= 32804) && (so <=32807)) { str = "QUALCOMM Incorporated"; }
2806         else if ((so >= 32808) && (so <=32811)) { str = "QUALCOMM Incorporated"; }
2807         else if ((so >= 32812) && (so <=32815)) { str = "Lucent Technologies"; }
2808         else if ((so >= 32816) && (so <=32819)) { str = "Denso International"; }
2809         else if ((so >= 32820) && (so <=32823)) { str = "Motorola"; }
2810         else if ((so >= 32824) && (so <=32827)) { str = "Denso International"; }
2811         else if ((so >= 32828) && (so <=32831)) { str = "Denso International"; }
2812         else if ((so >= 32832) && (so <=32835)) { str = "Denso International"; }
2813         else if ((so >= 32836) && (so <=32839)) { str = "NEC America"; }
2814         else if ((so >= 32840) && (so <=32843)) { str = "Samsung Electronics"; }
2815         else if ((so >= 32844) && (so <=32847)) { str = "Texas Instruments Incorporated"; }
2816         else if ((so >= 32848) && (so <=32851)) { str = "Toshiba Corporation"; }
2817         else if ((so >= 32852) && (so <=32855)) { str = "LG Electronics Inc."; }
2818         else if ((so >= 32856) && (so <=32859)) { str = "VIA Telecom Inc."; }
2819         else { str = "Reserved"; }
2820         break;
2821     }
2822
2823     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2824         saved_offset, asn1->offset - saved_offset,
2825         "%s %d/0x%04x",
2826         str, so, so);
2827
2828     EXTRANEOUS_DATA_CHECK(len, 2);
2829 }
2830
2831 static void
2832 param_tdma_sc(ASN1_SCK *asn1, proto_tree *tree, guint len)
2833 {
2834     gint32 value;
2835     guint saved_offset;
2836     gchar *str = NULL;
2837
2838     saved_offset = asn1->offset;
2839
2840     asn1_int32_value_decode(asn1, 1, &value);
2841
2842     switch (value)
2843     {
2844     case 0: str = "Analog Speech Only"; break;
2845     case 1: str = "Digital Speech Only"; break;
2846     case 2: str = "Analog or Digital Speech, Analog Preferred"; break;
2847     case 3: str = "Analog or Digital Speech, Digital Preferred"; break;
2848     case 4: str = "Asynchronous Data"; break;
2849     case 5: str = "G3 Fax"; break;
2850     case 6: str = "Not Used (Service Rejected)"; break;
2851     case 7: str = "STU III (Secure Telephone Unit)"; break;
2852     default:
2853         str = "Reserved, treat as Analog Speech Only";
2854         break;
2855     }
2856
2857     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2858         saved_offset, asn1->offset - saved_offset,
2859         "%s %d",
2860         str, value);
2861
2862     EXTRANEOUS_DATA_CHECK(len, 1);
2863 }
2864
2865 static void
2866 param_dmh_red_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
2867 {
2868     gint32 redind;
2869     guint saved_offset;
2870     gchar *str = NULL;
2871
2872     EXACT_DATA_CHECK(len, 1);
2873
2874     saved_offset = asn1->offset;
2875
2876     asn1_int32_value_decode(asn1, 1, &redind);
2877
2878     switch (redind)
2879     {
2880     case 0: str = "Not used"; break;
2881     case 1: str = "Call Forwarding Unconditional (CFU)"; break;
2882     case 2: str = "Call Forwarding Busy (CFB)"; break;
2883     case 3: str = "Call Forwarding No Answer (CFNA)"; break;
2884     case 4: str = "Call Forwarding Other (CFO)"; break;
2885     case 5: str = "CD Unspecified"; break;
2886     case 6: str = "CD PSTN"; break;
2887     case 7: str = "CD Private"; break;
2888     case 8: str = "PSTN Tandem"; break;
2889     case 9: str = "Private Tandem"; break;
2890     case 10: str = "Busy"; break;
2891     case 11: str = "Inactive"; break;
2892     case 12: str = "Unassigned"; break;
2893     case 13: str = "Termination Denied"; break;
2894     case 14: str = "CD Failure"; break;
2895     case 15: str = "Explicit Call Transfer (ECT)"; break;
2896     case 16: str = "Mobile Access Hunting (MAH)"; break;
2897     case 17: str = "Flexible Alerting (FA)"; break;
2898     case 18: str = "Abandoned Call Leg"; break;
2899     case 19: str = "Password Call Acceptance (PCA) Call Refused"; break;
2900     case 20: str = "Selective Call Acceptance (SCA) Call Refused"; break;
2901     case 21: str = "Dialogue"; break;
2902     case 22: str = "Call Forwarding Default (CFD)"; break;
2903     case 23: str = "CD Local"; break;
2904     case 24: str = "Voice Mail Retrieval"; break;
2905     default:
2906         if ((redind >= 25) && (redind <= 127))
2907         {
2908             str = "Reserved/Unknown";
2909         }
2910         else
2911         {
2912             str = "Reserved for bilateral agreements";
2913         }
2914         break;
2915     }
2916
2917     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2918         saved_offset, asn1->offset - saved_offset,
2919         "%s (%d)",
2920         str, redind);
2921 }
2922
2923 static void
2924 param_cic(ASN1_SCK *asn1, proto_tree *tree, guint len)
2925 {
2926     gint32 tg, mem;
2927     guint saved_offset;
2928
2929     EXACT_DATA_CHECK(len, 2);
2930
2931     saved_offset = asn1->offset;
2932
2933     asn1_int32_value_decode(asn1, 1, &tg);
2934     asn1_int32_value_decode(asn1, 1, &mem);
2935
2936     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2937         saved_offset, len,
2938         "Trunk Group %d  Member %d",
2939         tg, mem);
2940 }
2941
2942 static void
2943 param_qic(ASN1_SCK *asn1, proto_tree *tree, guint len)
2944 {
2945     gint32 qic;
2946     guint saved_offset;
2947     gchar *str = NULL;
2948
2949     EXACT_DATA_CHECK(len, 1);
2950
2951     saved_offset = asn1->offset;
2952
2953     asn1_int32_value_decode(asn1, 1, &qic);
2954
2955     switch (qic)
2956     {
2957     case 0: str = "Not used"; break;
2958     case 1: str = "No information"; break;
2959     case 2: str = "Validation only"; break;
2960     case 3: str = "Validation and profile"; break;
2961     case 4: str = "Profile only"; break;
2962     default:
2963         if ((qic >= 5) && (qic <= 223))
2964         {
2965             str = "Reserved, treat as Validation and profile";
2966         }
2967         else
2968         {
2969             str = "Reserved for extension, treat as Validation and profile";
2970         }
2971         break;
2972     }
2973
2974     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
2975         saved_offset, asn1->offset - saved_offset,
2976         str);
2977 }
2978
2979 static void
2980 param_feat_result(ASN1_SCK *asn1, proto_tree *tree, guint len)
2981 {
2982     gint32 value;
2983     guint saved_offset;
2984     gchar *str = NULL;
2985
2986     EXACT_DATA_CHECK(len, 1);
2987
2988     saved_offset = asn1->offset;
2989
2990     asn1_int32_value_decode(asn1, 1, &value);
2991
2992     switch (value)
2993     {
2994     case 0: str = "Not used"; break;
2995     case 1: str = "Unsuccessful"; break;
2996     case 2: str = "Successful"; break;
2997     default:
2998         if ((value >= 3) && (value <= 95)) { str = "Reserved, treat as Unsuccessful"; }
2999         else if ((value >= 96) && (value <= 127)) { str = "Reserved, treat as Unsuccessful"; }
3000         else if ((value >= 128) && (value <= 223)) { str = "Reserved, treat as Successful"; }
3001         else { str = "Reserved for protocol extension, treat as Successful"; }
3002         break;
3003     }
3004
3005     proto_tree_add_text(tree, asn1->tvb,
3006         saved_offset, asn1->offset - saved_offset,
3007         str);
3008 }
3009
3010 gchar *calling_feat_ind_str[] = {
3011     "Not used",
3012     "Not authorized",
3013     "Authorized but de-activated",
3014     "Authorized and activated"
3015 };
3016
3017 static void
3018 param_calling_feat_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
3019 {
3020     gint32 value;
3021     guint saved_offset;
3022
3023     SHORT_DATA_CHECK(len, 2);
3024
3025     saved_offset = asn1->offset;
3026
3027     asn1_int32_value_decode(asn1, 1, &value);
3028
3029     my_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",
3033         bigbuf,
3034         calling_feat_ind_str[(value & 0xc0) >> 6]);
3035
3036     my_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",
3040         bigbuf,
3041         calling_feat_ind_str[(value & 0x30) >> 4]);
3042
3043     my_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",
3047         bigbuf,
3048         calling_feat_ind_str[(value & 0x0c) >> 2]);
3049
3050     my_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",
3054         bigbuf,
3055         calling_feat_ind_str[value & 0x03]);
3056
3057     saved_offset = asn1->offset;
3058
3059     asn1_int32_value_decode(asn1, 1, &value);
3060
3061     my_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",
3065         bigbuf,
3066         calling_feat_ind_str[(value & 0xc0) >> 6]);
3067
3068     my_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",
3072         bigbuf,
3073         calling_feat_ind_str[(value & 0x30) >> 4]);
3074
3075     my_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",
3079         bigbuf,
3080         calling_feat_ind_str[(value & 0x0c) >> 2]);
3081
3082     my_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",
3086         bigbuf,
3087         calling_feat_ind_str[value & 0x03]);
3088
3089     if (len == 2) return;
3090
3091     saved_offset = asn1->offset;
3092
3093     asn1_int32_value_decode(asn1, 1, &value);
3094
3095     my_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",
3099         bigbuf,
3100         calling_feat_ind_str[(value & 0xc0) >> 6]);
3101
3102     my_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",
3106         bigbuf,
3107         calling_feat_ind_str[(value & 0x30) >> 4]);
3108
3109     my_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",
3113         bigbuf,
3114         calling_feat_ind_str[(value & 0x0c) >> 2]);
3115
3116     my_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",
3120         bigbuf,
3121         calling_feat_ind_str[value & 0x03]);
3122
3123     if (len == 3) return;
3124
3125     saved_offset = asn1->offset;
3126
3127     asn1_int32_value_decode(asn1, 1, &value);
3128
3129     my_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",
3133         bigbuf,
3134         calling_feat_ind_str[(value & 0xc0) >> 6]);
3135
3136     my_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",
3140         bigbuf,
3141         calling_feat_ind_str[(value & 0x30) >> 4]);
3142
3143     my_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",
3147         bigbuf,
3148         calling_feat_ind_str[(value & 0x0c) >> 2]);
3149
3150     my_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",
3154         bigbuf,
3155         calling_feat_ind_str[value & 0x03]);
3156
3157     if (len == 4) return;
3158
3159     saved_offset = asn1->offset;
3160
3161     asn1_int32_value_decode(asn1, 1, &value);
3162
3163     my_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",
3167         bigbuf,
3168         calling_feat_ind_str[(value & 0xc0) >> 6]);
3169
3170     my_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",
3174         bigbuf,
3175         calling_feat_ind_str[(value & 0x30) >> 4]);
3176
3177     my_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",
3181         bigbuf,
3182         calling_feat_ind_str[(value & 0x0c) >> 2]);
3183
3184     my_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",
3188         bigbuf,
3189         calling_feat_ind_str[value & 0x03]);
3190
3191     if (len == 5) return;
3192
3193     saved_offset = asn1->offset;
3194
3195     asn1_int32_value_decode(asn1, 1, &value);
3196
3197     my_decode_bitfield_value(bigbuf, value, 0xfc, 8);
3198     proto_tree_add_text(tree, asn1->tvb,
3199         saved_offset, asn1->offset - saved_offset,
3200         "%s :  Reserved",
3201         bigbuf);
3202
3203     my_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",
3207         bigbuf,
3208         calling_feat_ind_str[value & 0x03]);
3209
3210     EXTRANEOUS_DATA_CHECK(len, 6);
3211 }
3212
3213 static void
3214 param_usage_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
3215 {
3216     gint32 value;
3217     guint saved_offset;
3218     gchar *str = NULL;
3219
3220     EXACT_DATA_CHECK(len, 1);
3221
3222     saved_offset = asn1->offset;
3223
3224     asn1_int32_value_decode(asn1, 1, &value);
3225
3226     switch (value)
3227     {
3228     case 0: str = "Unspecified"; break;
3229     case 1: str = "Sent-paid call"; break;
3230     case 2: str = "3rd number bill"; break;
3231     default:
3232         str = "Reserved, treat as Unspecified";
3233         break;
3234     }
3235
3236     proto_tree_add_text(tree, asn1->tvb,
3237         saved_offset, asn1->offset - saved_offset,
3238         "%s (%d)",
3239         str,
3240         value);
3241 }
3242
3243 gchar *tdma_data_feat_ind_str[] = {
3244     "Not used",
3245     "Not authorized",
3246     "Authorized but de-activated",
3247     "Authorized and activated"
3248 };
3249
3250 static void
3251 param_tdma_data_feat_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
3252 {
3253     gint32 value;
3254     guint saved_offset;
3255
3256     SHORT_DATA_CHECK(len, 2);
3257
3258     saved_offset = asn1->offset;
3259
3260     asn1_int32_value_decode(asn1, 1, &value);
3261
3262     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3263     proto_tree_add_text(tree, asn1->tvb,
3264         saved_offset, asn1->offset - saved_offset,
3265         "%s :  Reserved",
3266         bigbuf);
3267
3268     my_decode_bitfield_value(bigbuf, value, 0x30, 8);
3269     proto_tree_add_text(tree, asn1->tvb,
3270         saved_offset, asn1->offset - saved_offset,
3271         "%s :  STU-III Feature Activity (STUIII-FA), %s",
3272         bigbuf,
3273         tdma_data_feat_ind_str[(value & 0x30) >> 4]);
3274
3275     my_decode_bitfield_value(bigbuf, value, 0x0c, 8);
3276     proto_tree_add_text(tree, asn1->tvb,
3277         saved_offset, asn1->offset - saved_offset,
3278         "%s :  G3 Fax Feature Activity (G3FAX-FA), %s",
3279         bigbuf,
3280         tdma_data_feat_ind_str[(value & 0x0c) >> 2]);
3281
3282     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
3283     proto_tree_add_text(tree, asn1->tvb,
3284         saved_offset, asn1->offset - saved_offset,
3285         "%s :  ADS Feature Activity (ADS-FA), %s",
3286         bigbuf,
3287         tdma_data_feat_ind_str[value & 0x03]);
3288
3289     saved_offset = asn1->offset;
3290
3291     asn1_int32_value_decode(asn1, 1, &value);
3292
3293     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3294     proto_tree_add_text(tree, asn1->tvb,
3295         saved_offset, asn1->offset - saved_offset,
3296         "%s :  Triple Rate data Feature Activity (3RATE-FA), %s",
3297         bigbuf,
3298         tdma_data_feat_ind_str[(value & 0xc0) >> 6]);
3299
3300     my_decode_bitfield_value(bigbuf, value, 0x30, 8);
3301     proto_tree_add_text(tree, asn1->tvb,
3302         saved_offset, asn1->offset - saved_offset,
3303         "%s :  Double Rate data Feature Activity (2RATE-FA), %s",
3304         bigbuf,
3305         tdma_data_feat_ind_str[(value & 0x30) >> 4]);
3306
3307     my_decode_bitfield_value(bigbuf, value, 0x0c, 8);
3308     proto_tree_add_text(tree, asn1->tvb,
3309         saved_offset, asn1->offset - saved_offset,
3310         "%s :  Full Rate data Feature Activity (FRATE-FA), %s",
3311         bigbuf,
3312         tdma_data_feat_ind_str[(value & 0x0c) >> 2]);
3313
3314     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
3315     proto_tree_add_text(tree, asn1->tvb,
3316         saved_offset, asn1->offset - saved_offset,
3317         "%s :  Half Rate data Feature Activity (HRATE-FA), %s",
3318         bigbuf,
3319         tdma_data_feat_ind_str[value & 0x03]);
3320
3321     EXTRANEOUS_DATA_CHECK(len, 2);
3322 }
3323
3324 static void
3325 param_faulty(ASN1_SCK *asn1, proto_tree *tree, guint len)
3326 {
3327     gint32 value;
3328     guint saved_offset;
3329     gchar *str = NULL;
3330     gint idx;
3331
3332     saved_offset = asn1->offset;
3333     asn1_int32_value_decode(asn1, 1, &value);
3334
3335     str = my_match_strval((guint32) value, ansi_param_1_strings, &idx);
3336
3337     if (NULL == str)
3338     {
3339         if (len < 2)
3340         {
3341             proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
3342                 saved_offset, len,
3343                 "Unrecognized parameter ID");
3344             return;
3345         }
3346
3347         asn1->offset = saved_offset;
3348         asn1_uint32_value_decode(asn1, 2, &value);
3349
3350         str = my_match_strval((guint32) value, ansi_param_2_strings, &idx);
3351
3352         if (NULL == str)
3353         {
3354             if (len < 3)
3355             {
3356                 proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
3357                     saved_offset, len,
3358                     "Unrecognized parameter ID");
3359                 return;
3360             }
3361
3362             asn1->offset = saved_offset;
3363             asn1_int32_value_decode(asn1, 3, &value);
3364
3365             str = my_match_strval((guint32) value, ansi_param_3_strings, &idx);
3366
3367             if (NULL == str)
3368             {
3369                 if (((value >= 0x9FFF00) && (value <= 0x9FFF7F)) ||
3370                     ((value >= 0xBFFF00) && (value <= 0xBFFF7F)))
3371                 {
3372                     str = "Reserved for protocol extension";
3373                 }
3374                 else if (((value >= 0x9FFE76) && (value <= 0x9FFE7F)) ||
3375                     ((value >= 0xBFFE76) && (value <= 0xBFFE7F)))
3376                 {
3377                     str = "Reserved for National Network Use";
3378                 }
3379                 else
3380                 {
3381                     str = "Unrecognized parameter ID";
3382                 }
3383             }
3384         }
3385     }
3386
3387     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
3388         saved_offset, asn1->offset - saved_offset,
3389         str);
3390
3391     EXTRANEOUS_DATA_CHECK(len, asn1->offset - saved_offset);
3392 }
3393
3394 static void
3395 param_sys_type_code(ASN1_SCK *asn1, proto_tree *tree, guint len)
3396 {
3397     gint32 sys_type_code;
3398     guint saved_offset;
3399     gchar *str = NULL;
3400
3401     EXACT_DATA_CHECK(len, 1);
3402
3403     saved_offset = asn1->offset;
3404
3405     asn1_int32_value_decode(asn1, 1, &sys_type_code);
3406
3407     switch (sys_type_code)
3408     {
3409     case 0: str = "Not used"; break;
3410     case 1: str = "EDS"; break;
3411     case 2: str = "Astronet"; break;
3412     case 3: str = "Lucent Technologies"; break;
3413     case 4: str = "Ericsson"; break;
3414     case 5: str = "GTE"; break;
3415     case 6: str = "Motorola"; break;
3416     case 7: str = "NEC"; break;
3417     case 8: str = "NORTEL"; break;
3418     case 9: str = "NovAtel"; break;
3419     case 10: str = "Plexsys"; break;
3420     case 11: str = "Digital Equipment Corp"; break;
3421     case 12: str = "INET"; break;
3422     case 13: str = "Bellcore"; break;
3423     case 14: str = "Alcatel SEL"; break;
3424     case 15: str = "Compaq (Tandem)"; break;
3425     case 16: str = "QUALCOMM"; break;
3426     case 17: str = "Aldiscon"; break;
3427     case 18: str = "Celcore"; break;
3428     case 19: str = "TELOS"; break;
3429     case 20: str = "ADI Limited (Stanilite)"; break;
3430     case 21: str = "Coral Systems"; break;
3431     case 22: str = "Synacom Technology"; break;
3432     case 23: str = "DSC"; break;
3433     case 24: str = "MCI"; break;
3434     case 25: str = "NewNet"; break;
3435     case 26: str = "Sema Group Telecoms"; break;
3436     case 27: str = "LG Information and Communications"; break;
3437     case 28: str = "CBIS"; break;
3438     case 29: str = "Siemens"; break;
3439     case 30: str = "Samsung Electronics"; break;
3440     case 31: str = "ReadyCom Inc."; break;
3441     case 32: str = "AG Communication Systems"; break;
3442     case 33: str = "Hughes Network Systems"; break;
3443     case 34: str = "Phoenix Wireless Group"; break;
3444     default:
3445         str = "Reserved/Unknown";
3446         break;
3447     }
3448
3449     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
3450         saved_offset, asn1->offset - saved_offset,
3451         "Vendor ID (%d) %s",
3452         sys_type_code, str);
3453 }
3454
3455 static void
3456 param_ext_sys_type_code(ASN1_SCK *asn1, proto_tree *tree, guint len)
3457 {
3458     gint32 type;
3459     guint saved_offset;
3460     gchar *str = NULL;
3461
3462     EXACT_DATA_CHECK(len, 2);
3463
3464     saved_offset = asn1->offset;
3465
3466     asn1_int32_value_decode(asn1, 1, &type);
3467
3468     switch (type)
3469     {
3470     case 0: str = "Not specified"; break;
3471     case 1: str = "Serving MSC"; break;
3472     case 2: str = "Home MSC"; break;
3473     case 3: str = "Gateway MSC"; break;
3474     case 4: str = "HLR"; break;
3475     case 5: str = "VLR"; break;
3476     case 6: str = "EIR (reserved)"; break;
3477     case 7: str = "AC"; break;
3478     case 8: str = "Border MSC"; break;
3479     case 9: str = "Originating MSC"; break;
3480     default:
3481         if ((type >= 10) && (type <= 223)) { str = "Reserved, treat as Not specified"; }
3482         else { str = "Reserved for protocol extension, treat as Not specified"; }
3483         break;
3484     }
3485
3486     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
3487         saved_offset, asn1->offset - saved_offset,
3488         "Type (%d) %s",
3489         type,
3490         str);
3491
3492     param_sys_type_code(asn1, tree, len-1);
3493 }
3494
3495 static void
3496 param_cdma_sea_win(ASN1_SCK *asn1, proto_tree *tree, guint len)
3497 {
3498     gint32 value;
3499     guint saved_offset;
3500
3501     EXACT_DATA_CHECK(len, 1);
3502
3503     saved_offset = asn1->offset;
3504
3505     asn1_int32_value_decode(asn1, 1, &value);
3506
3507     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
3508     proto_tree_add_text(tree, asn1->tvb,
3509         saved_offset, asn1->offset - saved_offset,
3510         "%s :  Reserved",
3511         bigbuf);
3512
3513     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
3514     proto_tree_add_text(tree, asn1->tvb,
3515         saved_offset, asn1->offset - saved_offset,
3516         "%s :  Value %d",
3517         bigbuf,
3518         value & 0x0f);
3519 }
3520
3521 static void
3522 param_cdma_sea_param(ASN1_SCK *asn1, proto_tree *tree, guint len)
3523 {
3524     gint32 value;
3525     guint saved_offset;
3526
3527     SHORT_DATA_CHECK(len, 4);
3528
3529     saved_offset = asn1->offset;
3530
3531     asn1_int32_value_decode(asn1, 1, &value);
3532
3533     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
3534     proto_tree_add_text(tree, asn1->tvb,
3535         saved_offset, asn1->offset - saved_offset,
3536         "%s :  Reserved",
3537         bigbuf);
3538
3539     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
3540     proto_tree_add_text(tree, asn1->tvb,
3541         saved_offset, asn1->offset - saved_offset,
3542         "%s :  CDMA Search Window, %d",
3543         bigbuf,
3544         value & 0x0f);
3545
3546     saved_offset = asn1->offset;
3547
3548     asn1_int32_value_decode(asn1, 1, &value);
3549
3550     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3551     proto_tree_add_text(tree, asn1->tvb,
3552         saved_offset, asn1->offset - saved_offset,
3553         "%s :  Reserved",
3554         bigbuf);
3555
3556     my_decode_bitfield_value(bigbuf, value, 0x3f, 8);
3557     proto_tree_add_text(tree, asn1->tvb,
3558         saved_offset, asn1->offset - saved_offset,
3559         "%s :  T_ADD, %d",
3560         bigbuf,
3561         value & 0x3f);
3562
3563     saved_offset = asn1->offset;
3564
3565     asn1_int32_value_decode(asn1, 1, &value);
3566
3567     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3568     proto_tree_add_text(tree, asn1->tvb,
3569         saved_offset, asn1->offset - saved_offset,
3570         "%s :  Reserved",
3571         bigbuf);
3572
3573     my_decode_bitfield_value(bigbuf, value, 0x3f, 8);
3574     proto_tree_add_text(tree, asn1->tvb,
3575         saved_offset, asn1->offset - saved_offset,
3576         "%s :  T_DROP, %d",
3577         bigbuf,
3578         value & 0x3f);
3579
3580     saved_offset = asn1->offset;
3581
3582     asn1_int32_value_decode(asn1, 1, &value);
3583
3584     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
3585     proto_tree_add_text(tree, asn1->tvb,
3586         saved_offset, asn1->offset - saved_offset,
3587         "%s :  T_TDROP, %d",
3588         bigbuf,
3589         value & 0xf0);
3590
3591     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
3592     proto_tree_add_text(tree, asn1->tvb,
3593         saved_offset, asn1->offset - saved_offset,
3594         "%s :  T_COMP, %d",
3595         bigbuf,
3596         value & 0x0f);
3597
3598     EXTRANEOUS_DATA_CHECK(len, 4);
3599 }
3600
3601 static void
3602 param_cdma_code_chan(ASN1_SCK *asn1, proto_tree *tree, guint len)
3603 {
3604     gint32 value;
3605     guint saved_offset;
3606
3607     saved_offset = asn1->offset;
3608
3609     asn1_int32_value_decode(asn1, 1, &value);
3610
3611     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3612     proto_tree_add_text(tree, asn1->tvb,
3613         saved_offset, asn1->offset - saved_offset,
3614         "%s :  Reserved",
3615         bigbuf);
3616
3617     my_decode_bitfield_value(bigbuf, value, 0x3f, 8);
3618     proto_tree_add_text(tree, asn1->tvb,
3619         saved_offset, asn1->offset - saved_offset,
3620         "%s :  CDMA Code Channel %d",
3621         bigbuf,
3622         value & 0x3f);
3623
3624     EXTRANEOUS_DATA_CHECK(len, 1);
3625 }
3626
3627 static void
3628 param_chan_data(ASN1_SCK *asn1, proto_tree *tree, guint len)
3629 {
3630     gint32 value;
3631     guint saved_offset;
3632     gchar *str = NULL;
3633
3634     SHORT_DATA_CHECK(len, 3);
3635
3636     saved_offset = asn1->offset;
3637
3638     asn1_int32_value_decode(asn1, 1, &value);
3639
3640     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3641     proto_tree_add_text(tree, asn1->tvb,
3642         saved_offset, asn1->offset - saved_offset,
3643         "%s :  SAT Color Code %d",
3644         bigbuf,
3645         (value & 0xc0 >> 6));
3646
3647     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
3648     proto_tree_add_text(tree, asn1->tvb,
3649         saved_offset, asn1->offset - saved_offset,
3650         "%s :  %s",
3651         (value & 0x20) ? "Reserved" : "Analog Band Class",
3652         bigbuf);
3653
3654     switch ((value & 0x18) >> 3)
3655     {
3656     case 0: str = "DTX disabled (not active/acceptable)"; break;
3657     case 1: str = "Reserved, treat as DTX disabled"; break;
3658     case 2: str = "DTX-low mode (i.e., 8 dB below DTX active/acceptable)"; break;
3659     case 3: str = "DTX mode active or acceptable"; break;
3660     }
3661
3662     my_decode_bitfield_value(bigbuf, value, 0x18, 8);
3663     proto_tree_add_text(tree, asn1->tvb,
3664         saved_offset, asn1->offset - saved_offset,
3665         "%s :  %s",
3666         bigbuf,
3667         str);
3668
3669     my_decode_bitfield_value(bigbuf, value, 0x07, 8);
3670     proto_tree_add_text(tree, asn1->tvb,
3671         saved_offset, asn1->offset - saved_offset,
3672         "%s :  Voice Mobile Attenuation Code (VMAC) %d",
3673         bigbuf,
3674         value & 0x07);
3675
3676     saved_offset = asn1->offset;
3677
3678     asn1_int32_value_decode(asn1, 2, &value);
3679
3680     proto_tree_add_text(tree, asn1->tvb,
3681         saved_offset, asn1->offset - saved_offset,
3682         "Channel Number %d",
3683         value);
3684
3685     EXTRANEOUS_DATA_CHECK(len, 3);
3686 }
3687
3688 static void
3689 param_cdma_plcm(ASN1_SCK *asn1, proto_tree *tree, guint len)
3690 {
3691     gint32 value;
3692     guint saved_offset;
3693
3694     EXACT_DATA_CHECK(len, 6);
3695
3696     saved_offset = asn1->offset;
3697
3698     asn1_int32_value_decode(asn1, 1, &value);
3699
3700     my_decode_bitfield_value(bigbuf, value, 0xfc, 8);
3701     proto_tree_add_text(tree, asn1->tvb,
3702         saved_offset, asn1->offset - saved_offset,
3703         "%s :  Reserved",
3704         bigbuf);
3705
3706     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
3707     proto_tree_add_text(tree, asn1->tvb,
3708         saved_offset, asn1->offset - saved_offset,
3709         "%s :  CDMA Private Long Code Mask (PLCM) (MSB)",
3710         bigbuf);
3711
3712     saved_offset = asn1->offset;
3713
3714     proto_tree_add_text(tree, asn1->tvb,
3715         saved_offset, len - 1,
3716         "CDMA Private Long Code Mask (PLCM)");
3717
3718     asn1->offset += (len - 1);
3719 }
3720
3721 static void
3722 param_ctrl_chan_data(ASN1_SCK *asn1, proto_tree *tree, guint len)
3723 {
3724     gint32 value;
3725     guint saved_offset;
3726
3727     EXACT_DATA_CHECK(len, 4);
3728
3729     saved_offset = asn1->offset;
3730
3731     asn1_int32_value_decode(asn1, 1, &value);
3732
3733     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
3734     proto_tree_add_text(tree, asn1->tvb,
3735         saved_offset, asn1->offset - saved_offset,
3736         "%s :  Digital Color Code (DCC)",
3737         bigbuf);
3738
3739     my_decode_bitfield_value(bigbuf, value, 0x38, 8);
3740     proto_tree_add_text(tree, asn1->tvb,
3741         saved_offset, asn1->offset - saved_offset,
3742         "%s :  Reserved",
3743         bigbuf);
3744
3745     my_decode_bitfield_value(bigbuf, value, 0x07, 8);
3746     proto_tree_add_text(tree, asn1->tvb,
3747         saved_offset, asn1->offset - saved_offset,
3748         "%s :  Control Mobile Attenuation Code (CMAC)",
3749         bigbuf);
3750
3751     saved_offset = asn1->offset;
3752
3753     asn1_int32_value_decode(asn1, 2, &value);
3754
3755     proto_tree_add_text(tree, asn1->tvb,
3756         saved_offset, asn1->offset - saved_offset,
3757         "Channel Number (CHNO), %d",
3758         value);
3759
3760     saved_offset = asn1->offset;
3761
3762     asn1_int32_value_decode(asn1, 1, &value);
3763
3764     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
3765     proto_tree_add_text(tree, asn1->tvb,
3766         saved_offset, asn1->offset - saved_offset,
3767         "%s :  Reserved",
3768         bigbuf);
3769
3770     my_decode_bitfield_value(bigbuf, value, 0x0c, 8);
3771     proto_tree_add_text(tree, asn1->tvb,
3772         saved_offset, asn1->offset - saved_offset,
3773         "%s :  Supplementary Digital Color Codes (SDCC1)",
3774         bigbuf);
3775
3776     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
3777     proto_tree_add_text(tree, asn1->tvb,
3778         saved_offset, asn1->offset - saved_offset,
3779         "%s :  Supplementary Digital Color Codes (SDCC2)",
3780         bigbuf);
3781 }
3782
3783 static void
3784 param_cdma_chan_data(ASN1_SCK *asn1, proto_tree *tree, guint len)
3785 {
3786     gint32 value, temp_int;
3787     guint saved_offset;
3788     gchar *str = NULL;
3789
3790     SHORT_DATA_CHECK(len, 8);
3791
3792     saved_offset = asn1->offset;
3793
3794     asn1_int32_value_decode(asn1, 2, &value);
3795
3796     my_decode_bitfield_value(bigbuf, value >> 8, 0x80, 8);
3797     proto_tree_add_text(tree, asn1->tvb,
3798         saved_offset, 1,
3799         "%s :  Reserved",
3800         bigbuf);
3801
3802     my_decode_bitfield_value(bigbuf, value >> 8, 0x78, 8);
3803     proto_tree_add_text(tree, asn1->tvb,
3804         saved_offset, 1,
3805         "%s :  Frame Offset (%d), %.2f ms",
3806         bigbuf,
3807         (value & 0x7800) >> 11,
3808         ((value & 0x7800) >> 11) * 1.25);
3809
3810     my_decode_bitfield_value(bigbuf, value >> 8, 0x07, 8);
3811     proto_tree_add_text(tree, asn1->tvb,
3812         saved_offset, 1,
3813         "%s :  CDMA Channel Number (MSB), %d",
3814         bigbuf,
3815         value & 0x07ff);
3816
3817     my_decode_bitfield_value(bigbuf, value & 0x00ff, 0xff, 8);
3818     proto_tree_add_text(tree, asn1->tvb,
3819         saved_offset+1, 1,
3820         "%s :  CDMA Channel Number (LSB)",
3821         bigbuf);
3822
3823     saved_offset = asn1->offset;
3824
3825     asn1_int32_value_decode(asn1, 1, &value);
3826
3827     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
3828     proto_tree_add_text(tree, asn1->tvb,
3829         saved_offset, asn1->offset - saved_offset,
3830         "%s :  Reserved",
3831         bigbuf);
3832
3833     temp_int = (value & 0x7c) >> 2;
3834     if ((temp_int < 0) || (temp_int >= (gint) NUM_BAND_CLASS_STR))
3835     {
3836         str = "Reserved";
3837     }
3838     else
3839     {
3840         str = band_class_str[temp_int];
3841     }
3842
3843     my_decode_bitfield_value(bigbuf, value, 0x7c, 8);
3844     proto_tree_add_text(tree, asn1->tvb,
3845         saved_offset, asn1->offset - saved_offset,
3846         "%s :  Band Class, %s",
3847         bigbuf,
3848         str);
3849
3850     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
3851     proto_tree_add_text(tree, asn1->tvb,
3852         saved_offset, asn1->offset - saved_offset,
3853         "%s :  Long Code Mask (MSB)",
3854         bigbuf);
3855
3856     asn1_int32_value_decode(asn1, 1, &value);
3857
3858     my_decode_bitfield_value(bigbuf, value, 0xff, 8);
3859     proto_tree_add_text(tree, asn1->tvb,
3860         saved_offset + 1, 1,
3861         "%s :  Long Code Mask",
3862         bigbuf);
3863
3864     asn1_int32_value_decode(asn1, 1, &value);
3865
3866     my_decode_bitfield_value(bigbuf, value, 0xff, 8);
3867     proto_tree_add_text(tree, asn1->tvb,
3868         saved_offset + 2, 1,
3869         "%s :  Long Code Mask",
3870         bigbuf);
3871
3872     asn1_int32_value_decode(asn1, 1, &value);
3873
3874     my_decode_bitfield_value(bigbuf, value, 0xff, 8);
3875     proto_tree_add_text(tree, asn1->tvb,
3876         saved_offset + 3, 1,
3877         "%s :  Long Code Mask",
3878         bigbuf);
3879
3880     asn1_int32_value_decode(asn1, 1, &value);
3881
3882     my_decode_bitfield_value(bigbuf, value, 0xff, 8);
3883     proto_tree_add_text(tree, asn1->tvb,
3884         saved_offset + 4, 1,
3885         "%s :  Long Code Mask",
3886         bigbuf);
3887
3888     asn1_int32_value_decode(asn1, 1, &value);
3889
3890     my_decode_bitfield_value(bigbuf, value, 0xff, 8);
3891     proto_tree_add_text(tree, asn1->tvb,
3892         saved_offset + 5, 1,
3893         "%s :  Long Code Mask (LSB)",
3894         bigbuf);
3895
3896     if (len == 8) return;
3897
3898     saved_offset = asn1->offset;
3899
3900     asn1_int32_value_decode(asn1, 1, &value);
3901
3902     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
3903     proto_tree_add_text(tree, asn1->tvb,
3904         saved_offset, asn1->offset - saved_offset,
3905         "%s :  NP Extension",
3906         bigbuf);
3907
3908     my_decode_bitfield_value(bigbuf, value, 0x78, 8);
3909     proto_tree_add_text(tree, asn1->tvb,
3910         saved_offset, asn1->offset - saved_offset,
3911         "%s :  Nominal Power, %d",
3912         bigbuf,
3913         (value & 0x78) >> 3);
3914
3915     my_decode_bitfield_value(bigbuf, value, 0x07, 8);
3916     proto_tree_add_text(tree, asn1->tvb,
3917         saved_offset, asn1->offset - saved_offset,
3918         "%s :  Number Preamble, %d",
3919         bigbuf,
3920         value & 0x07);
3921
3922     if (len == 9) return;
3923
3924     saved_offset = asn1->offset;
3925
3926     asn1_int32_value_decode(asn1, 1, &value);
3927
3928     proto_tree_add_text(tree, asn1->tvb,
3929         saved_offset, asn1->offset - saved_offset,
3930         "Base Station Protocol Revision, %d",
3931         value);
3932
3933     EXTRANEOUS_DATA_CHECK(len, 10);
3934 }
3935
3936 static void
3937 param_namps_chan_data(ASN1_SCK *asn1, proto_tree *tree, guint len)
3938 {
3939     gint32 value;
3940     guint saved_offset;
3941     gchar *str = NULL;
3942
3943     saved_offset = asn1->offset;
3944
3945     asn1_int32_value_decode(asn1, 1, &value);
3946
3947     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
3948     proto_tree_add_text(tree, asn1->tvb,
3949         saved_offset, asn1->offset - saved_offset,
3950         "%s :  Reserved",
3951         bigbuf);
3952
3953     switch ((value & 0x1c) >> 2)
3954     {
3955     case 0: str = "Channel Data parameter SCC field applies"; break;
3956     case 1: str = "Digital SAT Color Code 1 (ignore SCC field)"; break;
3957     case 2: str = "Digital SAT Color Code 2 (ignore SCC field)"; break;
3958     case 3: str = "Digital SAT Color Code 3 (ignore SCC field)"; break;
3959     case 4: str = "Digital SAT Color Code 4 (ignore SCC field)"; break;
3960     case 5: str = "Digital SAT Color Code 5 (ignore SCC field)"; break;
3961     case 6: str = "Digital SAT Color Code 6 (ignore SCC field)"; break;
3962     case 7: str = "Digital SAT Color Code 7 (ignore SCC field)"; break;
3963     }
3964
3965     my_decode_bitfield_value(bigbuf, value, 0x1c, 8);
3966     proto_tree_add_text(tree, asn1->tvb,
3967         saved_offset, asn1->offset - saved_offset,
3968         "%s :  Color Code Indicator (CCIndicator), %s",
3969         bigbuf,
3970         str);
3971
3972     switch (value & 0x03)
3973     {
3974     case 0: str = "Wide. 30 kHz AMPS voice channel"; break;
3975     case 1: str = "Upper. 10 kHz NAMPS voice channel"; break;
3976     case 2: str = "Middle. 10 kHz NAMPS voice channel"; break;
3977     case 3: str = "Lower. 10 kHz NAMPS voice channel"; break;
3978     }
3979
3980     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
3981     proto_tree_add_text(tree, asn1->tvb,
3982         saved_offset, asn1->offset - saved_offset,
3983         "%s :  Narrow Analog Voice Channel Assignment (NAVCA), %s",
3984         bigbuf,
3985         str);
3986
3987     EXTRANEOUS_DATA_CHECK(len, 1);
3988 }
3989
3990 static void
3991 param_cdma_ms_meas_chan_id(ASN1_SCK *asn1, proto_tree *tree, guint len)
3992 {
3993     gint32 value, temp_int;
3994     guint saved_offset;
3995     gchar *str = NULL;
3996
3997     SHORT_DATA_CHECK(len, 2);
3998
3999     saved_offset = asn1->offset;
4000
4001     asn1_int32_value_decode(asn1, 2, &value);
4002
4003     temp_int = (value & 0xf800) >> 11;
4004     if ((temp_int < 0) || (temp_int >= (gint) NUM_BAND_CLASS_STR))
4005     {
4006         str = "Reserved";
4007     }
4008     else
4009     {
4010         str = band_class_str[temp_int];
4011     }
4012
4013     my_decode_bitfield_value(bigbuf, value >> 8, 0xf8, 8);
4014     proto_tree_add_text(tree, asn1->tvb,
4015         saved_offset, 1,
4016         "%s :  Band Class, %s",
4017         bigbuf,
4018         str);
4019
4020     my_decode_bitfield_value(bigbuf, value >> 8, 0x07, 8);
4021     proto_tree_add_text(tree, asn1->tvb,
4022         saved_offset, 1,
4023         "%s :  CDMA Channel Number (MSB), %d",
4024         bigbuf,
4025         value & 0x07ff);
4026
4027     my_decode_bitfield_value(bigbuf, value & 0x00ff, 0xff, 8);
4028     proto_tree_add_text(tree, asn1->tvb,
4029         saved_offset+1, 1,
4030         "%s :  CDMA Channel Number (LSB)",
4031         bigbuf);
4032
4033     EXTRANEOUS_DATA_CHECK(len, 2);
4034 }
4035
4036 static void
4037 param_tdma_chan_data(ASN1_SCK *asn1, proto_tree *tree, guint len)
4038 {
4039     gint32 value;
4040     guint saved_offset;
4041     gchar *str = NULL;
4042
4043     SHORT_DATA_CHECK(len, 5);
4044
4045     saved_offset = asn1->offset;
4046
4047     asn1_int32_value_decode(asn1, 1, &value);
4048
4049     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
4050     proto_tree_add_text(tree, asn1->tvb,
4051         saved_offset, asn1->offset - saved_offset,
4052         "%s :  Reserved",
4053         bigbuf);
4054
4055     switch (value & 0x1f)
4056     {
4057     case 0: str = "Analog (not used if ChannelData is present)"; break;
4058     case 1: str = "Assigned to timeslot 1, full rate"; break;
4059     case 2: str = "Assigned to timeslot 2, full rate"; break;
4060     case 3: str = "Assigned to timeslot 3, full rate"; break;
4061     case 4: str = "Assigned to timeslots 1, 4 and 2, 5 Double rate"; break;
4062     case 5: str = "Assigned to timeslots 1, 4 and 3, 6 Double rate"; break;
4063     case 6: str = "Assigned to timeslots 2, 5 and 3, 6 Double rate"; break;
4064     case 9: str = "Assigned to timeslot 1, half rate"; break;
4065     case 10: str = "Assigned to timeslot 2, half rate"; break;
4066     case 11: str = "Assigned to timeslot 3, half rate"; break;
4067     case 12: str = "Assigned to timeslot 4, half rate"; break;
4068     case 13: str = "Assigned to timeslot 5, half rate"; break;
4069     case 14: str = "Assigned to timeslot 6, half rate"; break;
4070     case 15: str = "Assigned to timeslot 1, 2, 3, 4, 5, 6 Triple rate"; break;
4071     default:
4072         str = "Reserved, treat as Analog";
4073         break;
4074     }
4075
4076     my_decode_bitfield_value(bigbuf, value, 0x1f, 8);
4077     proto_tree_add_text(tree, asn1->tvb,
4078         saved_offset, asn1->offset - saved_offset,
4079         "%s :  Time Slot and Rate indicator (TSR), %s",
4080         bigbuf,
4081         str);
4082
4083     saved_offset = asn1->offset;
4084
4085     asn1_int32_value_decode(asn1, 1, &value);
4086
4087     proto_tree_add_text(tree, asn1->tvb,
4088         saved_offset, asn1->offset - saved_offset,
4089         "Digital Verification Color Code (DVCC) %d",
4090         value);
4091
4092     saved_offset = asn1->offset;
4093
4094     asn1_int32_value_decode(asn1, 1, &value);
4095
4096     switch ((value & 0xf0) >> 4)
4097     {
4098     case 0: str = "800 MHz"; break;
4099     case 1: str = "1800 MHz"; break;
4100     default:
4101         str = "Reserved, treat as 800 MHz";
4102         break;
4103     }
4104
4105     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
4106     proto_tree_add_text(tree, asn1->tvb,
4107         saved_offset, asn1->offset - saved_offset,
4108         "%s :  Hyper Band, %s",
4109         bigbuf,
4110         str);
4111
4112     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
4113     proto_tree_add_text(tree, asn1->tvb,
4114         saved_offset, asn1->offset - saved_offset,
4115         "%s :  Digital Mobile Attenuation Code (DMAC) %d",
4116         bigbuf,
4117         value & 0x0f);
4118
4119     saved_offset = asn1->offset;
4120
4121     asn1_int32_value_decode(asn1, 2, &value);
4122
4123     my_decode_bitfield_value(bigbuf, value >> 8, 0xff, 8);
4124     proto_tree_add_text(tree, asn1->tvb,
4125         saved_offset, 1,
4126         "%s :  Channel Number (MSB), %d",
4127         bigbuf,
4128         value);
4129
4130     my_decode_bitfield_value(bigbuf, value & 0x00ff, 0xff, 8);
4131     proto_tree_add_text(tree, asn1->tvb,
4132         saved_offset + 1, 1,
4133         "%s :  Channel Number (LSB)",
4134         bigbuf);
4135
4136     EXTRANEOUS_DATA_CHECK(len, 5);
4137 }
4138
4139 static void
4140 param_tdma_call_mode(ASN1_SCK *asn1, proto_tree *tree, guint len)
4141 {
4142     gint32 value;
4143     guint saved_offset;
4144
4145     saved_offset = asn1->offset;
4146
4147     asn1_int32_value_decode(asn1, 1, &value);
4148
4149     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
4150     proto_tree_add_text(tree, asn1->tvb,
4151         saved_offset, asn1->offset - saved_offset,
4152         "%s :  Reserved",
4153         bigbuf);
4154
4155     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
4156     proto_tree_add_text(tree, asn1->tvb,
4157         saved_offset, asn1->offset - saved_offset,
4158         "%s :  %sxtended modulation and framing",
4159         bigbuf,
4160         (value & 0x20) ? "E" : "No e");
4161
4162     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
4163     proto_tree_add_text(tree, asn1->tvb,
4164         saved_offset, asn1->offset - saved_offset,
4165         "%s :  Other voice coding %sacceptable",
4166         bigbuf,
4167         (value & 0x10) ? "" : "not ");
4168
4169     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
4170     proto_tree_add_text(tree, asn1->tvb,
4171         saved_offset, asn1->offset - saved_offset,
4172         "%s :  Other DQPSK channel %sacceptable",
4173         bigbuf,
4174         (value & 0x08) ? "" : "not ");
4175
4176     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
4177     proto_tree_add_text(tree, asn1->tvb,
4178         saved_offset, asn1->offset - saved_offset,
4179         "%s :  Half rate digital traffic channel %sacceptable",
4180         bigbuf,
4181         (value & 0x04) ? "" : "not ");
4182
4183     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
4184     proto_tree_add_text(tree, asn1->tvb,
4185         saved_offset, asn1->offset - saved_offset,
4186         "%s :  Full rate digital traffic channel %sacceptable",
4187         bigbuf,
4188         (value & 0x02) ? "" : "not ");
4189
4190     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
4191     proto_tree_add_text(tree, asn1->tvb,
4192         saved_offset, asn1->offset - saved_offset,
4193         "%s :  AMPS channel %sacceptable",
4194         bigbuf,
4195         (value & 0x01) ? "" : "not ");
4196
4197     EXTRANEOUS_DATA_CHECK(len, 1);
4198 }
4199
4200 static void
4201 param_cdma_call_mode(ASN1_SCK *asn1, proto_tree *tree, guint len)
4202 {
4203     gint32 value;
4204     guint saved_offset;
4205
4206     saved_offset = asn1->offset;
4207
4208     asn1_int32_value_decode(asn1, 1, &value);
4209
4210     if (len == 1)
4211     {
4212         /* assuming older spec. no IS-880 */
4213
4214         my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
4215         proto_tree_add_text(tree, asn1->tvb,
4216             saved_offset, asn1->offset - saved_offset,
4217             "%s :  Reserved",
4218             bigbuf);
4219     }
4220     else
4221     {
4222         my_decode_bitfield_value(bigbuf, value, 0x80, 8);
4223         proto_tree_add_text(tree, asn1->tvb,
4224             saved_offset, asn1->offset - saved_offset,
4225             "%s :  450 MHz channel (Band Class 5) %sacceptable",
4226             bigbuf,
4227             (value & 0x80) ? "" : "not ");
4228
4229         my_decode_bitfield_value(bigbuf, value, 0x40, 8);
4230         proto_tree_add_text(tree, asn1->tvb,
4231             saved_offset, asn1->offset - saved_offset,
4232             "%s :  Korean PCS channel (Band Class 4) %sacceptable",
4233             bigbuf,
4234             (value & 0x40) ? "" : "not ");
4235
4236         my_decode_bitfield_value(bigbuf, value, 0x20, 8);
4237         proto_tree_add_text(tree, asn1->tvb,
4238             saved_offset, asn1->offset - saved_offset,
4239             "%s :  JTACS channel (Band Class 3) %sacceptable",
4240             bigbuf,
4241             (value & 0x20) ? "" : "not ");
4242
4243         my_decode_bitfield_value(bigbuf, value, 0x10, 8);
4244         proto_tree_add_text(tree, asn1->tvb,
4245             saved_offset, asn1->offset - saved_offset,
4246             "%s :  TACS channel (Band Class 2) %sacceptable",
4247             bigbuf,
4248             (value & 0x10) ? "" : "not ");
4249     }
4250
4251     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
4252     proto_tree_add_text(tree, asn1->tvb,
4253         saved_offset, asn1->offset - saved_offset,
4254         "%s :  CDMA 1900 MHz channel (Band Class 1) %sacceptable",
4255         bigbuf,
4256         (value & 0x08) ? "" : "not ");
4257
4258     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
4259     proto_tree_add_text(tree, asn1->tvb,
4260         saved_offset, asn1->offset - saved_offset,
4261         "%s :  NAMPS 800 MHz channel %sacceptable",
4262         bigbuf,
4263         (value & 0x04) ? "" : "not ");
4264
4265     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
4266     proto_tree_add_text(tree, asn1->tvb,
4267         saved_offset, asn1->offset - saved_offset,
4268         "%s :  AMPS 800 MHz channel %sacceptable",
4269         bigbuf,
4270         (value & 0x02) ? "" : "not ");
4271
4272     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
4273     proto_tree_add_text(tree, asn1->tvb,
4274         saved_offset, asn1->offset - saved_offset,
4275         "%s :  CDMA 800 MHz channel (Band Class 0) %sacceptable",
4276         bigbuf,
4277         (value & 0x01) ? "" : "not ");
4278
4279     if (len == 1) return;
4280
4281     saved_offset = asn1->offset;
4282
4283     asn1_int32_value_decode(asn1, 1, &value);
4284
4285     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
4286     proto_tree_add_text(tree, asn1->tvb,
4287         saved_offset, asn1->offset - saved_offset,
4288         "%s :  Reserved",
4289         bigbuf);
4290
4291     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
4292     proto_tree_add_text(tree, asn1->tvb,
4293         saved_offset, asn1->offset - saved_offset,
4294         "%s :  Secondary 800 MHz channel (Band Class 10) %sacceptable",
4295         bigbuf,
4296         (value & 0x10) ? "" : "not ");
4297
4298     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
4299     proto_tree_add_text(tree, asn1->tvb,
4300         saved_offset, asn1->offset - saved_offset,
4301         "%s :  900 MHz channel (Band Class 9) %sacceptable",
4302         bigbuf,
4303         (value & 0x08) ? "" : "not ");
4304
4305     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
4306     proto_tree_add_text(tree, asn1->tvb,
4307         saved_offset, asn1->offset - saved_offset,
4308         "%s :  1800 MHz channel (Band Class 8) %sacceptable",
4309         bigbuf,
4310         (value & 0x04) ? "" : "not ");
4311
4312     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
4313     proto_tree_add_text(tree, asn1->tvb,
4314         saved_offset, asn1->offset - saved_offset,
4315         "%s :  700 MHz channel (Band Class 7) %sacceptable",
4316         bigbuf,
4317         (value & 0x02) ? "" : "not ");
4318
4319     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
4320     proto_tree_add_text(tree, asn1->tvb,
4321         saved_offset, asn1->offset - saved_offset,
4322         "%s :  2 GHz channel (Band Class 6) %sacceptable",
4323         bigbuf,
4324         (value & 0x01) ? "" : "not ");
4325
4326     EXTRANEOUS_DATA_CHECK(len, 2);
4327 }
4328
4329 static void
4330 param_namps_call_mode(ASN1_SCK *asn1, proto_tree *tree, guint len)
4331 {
4332     gint32 value;
4333     guint saved_offset;
4334
4335     saved_offset = asn1->offset;
4336
4337     asn1_int32_value_decode(asn1, 1, &value);
4338
4339     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
4340     proto_tree_add_text(tree, asn1->tvb,
4341         saved_offset, asn1->offset - saved_offset,
4342         "%s :  Reserved",
4343         bigbuf);
4344
4345     proto_tree_add_text(tree, asn1->tvb,
4346         saved_offset, asn1->offset - saved_offset,
4347         ".... %d... :  AMPS 1800 MHz channel %sacceptable",
4348         (value & 0x08) >> 3, (value & 0x08) ? "" : "not ");
4349
4350     proto_tree_add_text(tree, asn1->tvb,
4351         saved_offset, asn1->offset - saved_offset,
4352         ".... .%d.. :  NAMPS 1800 MHz channel %sacceptable",
4353         (value & 0x04) >> 2, (value & 0x04) ? "" : "not ");
4354
4355     proto_tree_add_text(tree, asn1->tvb,
4356         saved_offset, asn1->offset - saved_offset,
4357         ".... ..%d. :  AMPS 800 MHz channel %sacceptable",
4358         (value & 0x02) >> 1, (value & 0x02) ? "" : "not ");
4359
4360     proto_tree_add_text(tree, asn1->tvb,
4361         saved_offset, asn1->offset - saved_offset,
4362         ".... ...%d :  NAMPS 800 MHz channel %sacceptable",
4363         value & 0x01, (value & 0x01) ? "" : "not ");
4364
4365     EXTRANEOUS_DATA_CHECK(len, 1);
4366 }
4367
4368 static void
4369 param_mob_rev(ASN1_SCK *asn1, proto_tree *tree, guint len)
4370 {
4371     gint32 value;
4372     guint saved_offset;
4373
4374     saved_offset = asn1->offset;
4375
4376     asn1_int32_value_decode(asn1, 1, &value);
4377
4378     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
4379         saved_offset, asn1->offset - saved_offset,
4380         "Revision %d",
4381         value);
4382
4383     EXTRANEOUS_DATA_CHECK(len, 1);
4384 }
4385
4386 static void
4387 param_cdma_band_class(ASN1_SCK *asn1, proto_tree *tree, guint len)
4388 {
4389     gint32 value, temp_int;
4390     guint saved_offset;
4391     gchar *str = NULL;
4392
4393     saved_offset = asn1->offset;
4394
4395     asn1_int32_value_decode(asn1, 1, &value);
4396
4397     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
4398     proto_tree_add_text(tree, asn1->tvb,
4399         saved_offset, asn1->offset - saved_offset,
4400         "%s :  Reserved",
4401         bigbuf);
4402
4403     temp_int = value & 0x1f;
4404     if ((temp_int < 0) || (temp_int >= (gint) NUM_BAND_CLASS_STR))
4405     {
4406         str = "Reserved";
4407     }
4408     else
4409     {
4410         str = band_class_str[temp_int];
4411     }
4412
4413     my_decode_bitfield_value(bigbuf, value, 0x1f, 8);
4414     proto_tree_add_text(tree, asn1->tvb,
4415         saved_offset, asn1->offset - saved_offset,
4416         "%s :  Band Class %s",
4417         bigbuf,
4418         str);
4419
4420     EXTRANEOUS_DATA_CHECK(len, 1);
4421 }
4422
4423 static void
4424 param_calling_party_name(ASN1_SCK *asn1, proto_tree *tree, guint len)
4425 {
4426     gint32 value;
4427     guint saved_offset;
4428     gchar *str = NULL;
4429
4430     SHORT_DATA_CHECK(len, 1);
4431
4432     saved_offset = asn1->offset;
4433
4434     asn1_int32_value_decode(asn1, 1, &value);
4435
4436     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
4437     proto_tree_add_text(tree, asn1->tvb,
4438         saved_offset, asn1->offset - saved_offset,
4439         "%s :  Spec. has hardcoded as 0 0 1",
4440         bigbuf);
4441
4442     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
4443     proto_tree_add_text(tree, asn1->tvb,
4444         saved_offset, asn1->offset - saved_offset,
4445         "%s :  Availability, %s",
4446         bigbuf,
4447         (value & 0x10) ?  "Name not available" : "Name available/unknown");
4448
4449     my_decode_bitfield_value(bigbuf, value, 0x0c, 8);
4450     proto_tree_add_text(tree, asn1->tvb,
4451         saved_offset, asn1->offset - saved_offset,
4452         "%s :  Reserved",
4453         bigbuf);
4454
4455     switch (value & 0x03)
4456     {
4457     case 0: str = "Presentation allowed"; break;
4458     case 1: str = "Presentation restricted"; break;
4459     case 2: str = "Blocking toggle"; break;
4460     case 3: str = "No indication"; break;
4461     }
4462
4463     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
4464     proto_tree_add_text(tree, asn1->tvb,
4465         saved_offset, asn1->offset - saved_offset,
4466         "%s :  Presentation Status, %s",
4467         bigbuf,
4468         str);
4469
4470     if (len == 1) return;
4471
4472     saved_offset = asn1->offset;
4473
4474     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
4475         asn1->offset, len - 1,
4476         "IA5 Digits");
4477
4478     asn1->offset += (len - 1);
4479 }
4480
4481 static void
4482 param_red_party_name(ASN1_SCK *asn1, proto_tree *tree, guint len)
4483 {
4484     gint32 value;
4485     guint saved_offset;
4486     gchar *str = NULL;
4487
4488     SHORT_DATA_CHECK(len, 1);
4489
4490     saved_offset = asn1->offset;
4491
4492     asn1_int32_value_decode(asn1, 1, &value);
4493
4494     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
4495     proto_tree_add_text(tree, asn1->tvb,
4496         saved_offset, asn1->offset - saved_offset,
4497         "%s :  Spec. has hardcoded as 0 1 1",
4498         bigbuf);
4499
4500     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
4501     proto_tree_add_text(tree, asn1->tvb,
4502         saved_offset, asn1->offset - saved_offset,
4503         "%s :  Availability, %s",
4504         bigbuf,
4505         (value & 0x10) ?  "Name not available" : "Name available/unknown");
4506
4507     my_decode_bitfield_value(bigbuf, value, 0x0c, 8);
4508     proto_tree_add_text(tree, asn1->tvb,
4509         saved_offset, asn1->offset - saved_offset,
4510         "%s :  Reserved",
4511         bigbuf);
4512
4513     switch (value & 0x03)
4514     {
4515     case 0: str = "Presentation allowed"; break;
4516     case 1: str = "Presentation restricted"; break;
4517     case 2: str = "Blocking toggle"; break;
4518     case 3: str = "No indication"; break;
4519     }
4520
4521     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
4522     proto_tree_add_text(tree, asn1->tvb,
4523         saved_offset, asn1->offset - saved_offset,
4524         "%s :  Presentation Status, %s",
4525         bigbuf,
4526         str);
4527
4528     if (len == 1) return;
4529
4530     saved_offset = asn1->offset;
4531
4532     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
4533         asn1->offset, len - 1,
4534         "IA5 Digits");
4535
4536     asn1->offset += (len - 1);
4537 }
4538
4539 static void
4540 param_srvc_id(ASN1_SCK *asn1, proto_tree *tree, guint len)
4541 {
4542
4543     proto_tree_add_text(tree, asn1->tvb,
4544         asn1->offset, len,
4545         "Service Identifier (Spec. does not define clearly)");
4546
4547     asn1->offset += len;
4548 }
4549
4550 static void
4551 param_all_or_none(ASN1_SCK *asn1, proto_tree *tree, guint len)
4552 {
4553     gint32 value;
4554     guint saved_offset;
4555     gchar *str = NULL;
4556
4557     EXACT_DATA_CHECK(len, 1);
4558
4559     saved_offset = asn1->offset;
4560
4561     asn1_int32_value_decode(asn1, 1, &value);
4562
4563     switch (value)
4564     {
4565     case 0: str = "Not used"; break;
4566     case 1: str = "All changes must succeed or none should be applied"; break;
4567     case 2: str = "Treat each change independently"; break;
4568     default:
4569         if ((value >= 3) && (value <= 223)) { str = "Reserved, treat as All changes must succeed or none should be applied"; }
4570         else { str = "Reserved for protocol extension, treat as All changes must succeed or none should be applied"; }
4571         break;
4572     }
4573
4574     proto_tree_add_text(tree, asn1->tvb,
4575         saved_offset, asn1->offset - saved_offset,
4576         str);
4577 }
4578
4579 static void
4580 param_change(ASN1_SCK *asn1, proto_tree *tree, guint len)
4581 {
4582     gint32 value;
4583     guint saved_offset;
4584     gchar *str = NULL;
4585
4586     EXACT_DATA_CHECK(len, 1);
4587
4588     saved_offset = asn1->offset;
4589
4590     asn1_int32_value_decode(asn1, 1, &value);
4591
4592     switch (value)
4593     {
4594     case 0: str = "Not used"; break;
4595     case 1: str = "Set Data Item to Default Value"; break;
4596     case 2: str = "Add Data Item"; break;
4597     case 3: str = "Delete Data Item"; break;
4598     case 4: str = "Replace Data Item with associated DataValue"; break;
4599     default:
4600         if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Set Data Item to Default Value"; }
4601         else { str = "Reserved for protocol extension, treat as Set Data Item to Default Value"; }
4602         break;
4603     }
4604
4605     proto_tree_add_text(tree, asn1->tvb,
4606         saved_offset, asn1->offset - saved_offset,
4607         str);
4608 }
4609
4610 static void
4611 param_data_result(ASN1_SCK *asn1, proto_tree *tree, guint len)
4612 {
4613     gint32 value;
4614     guint saved_offset;
4615     gchar *str = NULL;
4616
4617     EXACT_DATA_CHECK(len, 1);
4618
4619     saved_offset = asn1->offset;
4620
4621     asn1_int32_value_decode(asn1, 1, &value);
4622
4623     switch (value)
4624     {
4625     case 0: str = "Not used"; break;
4626     case 1: str = "Successful"; break;
4627     case 2: str = "Unsuccessful, unspecified"; break;
4628     case 3: str = "Unsuccessful, no default value available"; break;
4629     default:
4630         if ((value >= 4) && (value <= 95)) { str = "Reserved, treat as Unsuccessful"; }
4631         else if ((value >= 96) && (value <= 127)) { str = "Reserved for protocol extension, treat as Unsuccessful"; }
4632         else if ((value >= 128) && (value <= 223)) { str = "Reserved, treat as Successful"; }
4633         else { str = "Reserved for protocol extension, treat as Successful"; }
4634         break;
4635     }
4636
4637     proto_tree_add_text(tree, asn1->tvb,
4638         saved_offset, asn1->offset - saved_offset,
4639         str);
4640 }
4641
4642 static void
4643 param_fail_cause(ASN1_SCK *asn1, proto_tree *tree, guint len)
4644 {
4645     guint saved_offset;
4646
4647     SHORT_DATA_CHECK(len, 2);
4648
4649     saved_offset = asn1->offset;
4650
4651     proto_tree_add_text(tree, asn1->tvb,
4652         saved_offset, len,
4653         "ISUP Cause Indicator");
4654
4655     asn1->offset += len;
4656 }
4657
4658 static void
4659 param_fail_type(ASN1_SCK *asn1, proto_tree *tree, guint len)
4660 {
4661     gint32 value;
4662     guint saved_offset;
4663     gchar *str = NULL;
4664
4665     EXACT_DATA_CHECK(len, 1);
4666
4667     saved_offset = asn1->offset;
4668
4669     asn1_int32_value_decode(asn1, 1, &value);
4670
4671     switch (value)
4672     {
4673     case 0: str = "Not used"; break;
4674     case 1: str = "Call abandoned"; break;
4675     case 2: str = "Resource disconnect"; break;
4676     case 3: str = "Failure at MSC"; break;
4677     case 4: str = "SSFT expiration"; break;
4678     default:
4679         if ((value >= 5) && (value <= 223)) { str = "Reserved, ignore"; }
4680         else { str = "Reserved for protocol extension, ignore"; }
4681         break;
4682     }
4683
4684     proto_tree_add_text(tree, asn1->tvb,
4685         saved_offset, asn1->offset - saved_offset,
4686         str);
4687 }
4688
4689 static void
4690 param_resume_pic(ASN1_SCK *asn1, proto_tree *tree, guint len)
4691 {
4692     gint32 value;
4693     guint saved_offset;
4694     gchar *str = NULL;
4695
4696     EXACT_DATA_CHECK(len, 1);
4697
4698     saved_offset = asn1->offset;
4699
4700     asn1_int32_value_decode(asn1, 1, &value);
4701
4702     switch (value)
4703     {
4704     case 0: str = "Not used"; break;
4705     case 1: str = "Continue Call Processing"; break;
4706     case 2: str = "Collect Information PIC"; break;
4707     case 3: str = "Analyze Information PIC"; break;
4708     case 4: str = "Select Route PIC"; break;
4709     case 5: str = "Authorize Origination_Attempt PIC"; break;
4710     case 6: str = "Authorize Call Setup PIC"; break;
4711     case 7: str = "Send Call PIC"; break;
4712     case 8: str = "O Alerting PIC"; break;
4713     case 9: str = "O Active PIC"; break;
4714     case 10: str = "O Suspended PIC"; break;
4715     case 11: str = "O Null PIC"; break;
4716     case 32: str = "Select Facility PIC"; break;
4717     case 33: str = "Present Call PIC"; break;
4718     case 34: str = "Authorize Termination Attempt PIC"; break;
4719     case 35: str = "T Alerting PIC"; break;
4720     case 36: str = "T Active PIC"; break;
4721     case 37: str = "T Suspended PIC"; break;
4722     case 38: str = "T Null PIC"; break;
4723     default:
4724         if ((value >= 12) && (value <= 31)) { str = "Reserved, treat as Not used"; }
4725         else if ((value >= 39) && (value <= 223)) { str = "Reserved, ignore"; }
4726         else { str = "Reserved for protocol extension, ignore"; }
4727         break;
4728     }
4729
4730     proto_tree_add_text(tree, asn1->tvb,
4731         saved_offset, asn1->offset - saved_offset,
4732         "Point in Call, %s (%d)",
4733         str,
4734         value);
4735 }
4736
4737 static void
4738 param_special_rsc(ASN1_SCK *asn1, proto_tree *tree, guint len)
4739 {
4740     gint32 value, i;
4741     guint saved_offset;
4742     gchar *str = NULL;
4743
4744     saved_offset = asn1->offset;
4745
4746     i = 0;
4747
4748     do
4749     {
4750         asn1_int32_value_decode(asn1, 1, &value);
4751
4752         switch (value)
4753         {
4754         case 0: str = "Not used"; break;
4755         case 1: str = "DTMF tone detector"; break;
4756         case 2: str = "Automatic Speech Recognition - Speaker Independent - Digits"; break;
4757         case 3: str = "Automatic Speech Recognition - Speaker Independent - Speech User Interface Version 1"; break;
4758         default:
4759             if ((value >= 4) && (value <= 223)) { str = "Reserved, treat as Not used"; }
4760             else { str = "Reserved for protocol extension, treat as Not used"; }
4761             break;
4762         }
4763
4764         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
4765             saved_offset, asn1->offset - saved_offset,
4766             "[%d] Resource Type, %s",
4767             i++,
4768             str);
4769
4770         saved_offset = asn1->offset;
4771     }
4772     while ((len - i) > 0);
4773 }
4774
4775 static void
4776 param_time_date_offset(ASN1_SCK *asn1, proto_tree *tree, guint len)
4777 {
4778     gint32 value;
4779     guint saved_offset;
4780
4781     EXACT_DATA_CHECK(len, 2);
4782
4783     saved_offset = asn1->offset;
4784
4785     asn1_int32_value_decode(asn1, 2, &value);
4786
4787     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
4788         saved_offset, asn1->offset - saved_offset,
4789         "In minutes (%d)",
4790         value);
4791 }
4792
4793 static void
4794 param_network_tmsi(ASN1_SCK *asn1, proto_tree *tree, guint len)
4795 {
4796     gint32 value, addr_type, first_dig;
4797     guint saved_offset;
4798     gchar *str = NULL;
4799     guchar *poctets;
4800
4801     SHORT_DATA_CHECK(len, 4);
4802
4803     saved_offset = asn1->offset;
4804
4805     asn1_int32_value_decode(asn1, 4, &value);
4806
4807     proto_tree_add_text(tree, asn1->tvb,
4808         saved_offset, asn1->offset - saved_offset,
4809         "TMSI Code, %d",
4810         value);
4811
4812     if (len == 4) return;
4813
4814     saved_offset = asn1->offset;
4815
4816     asn1_int32_value_decode(asn1, 1, &value);
4817
4818     first_dig = Dgt_tbcd.out[(value & 0xf0) >> 4];
4819
4820     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
4821     proto_tree_add_text(tree, asn1->tvb,
4822         saved_offset, asn1->offset - saved_offset,
4823         "%s :  First digit of TMSI Zone, %c",
4824         bigbuf,
4825         first_dig);
4826
4827     addr_type = value & 0x0f;
4828     switch (addr_type)
4829     {
4830     case 0: str = "Not used"; break;
4831     case 1: str = "E.212 based routing"; break;
4832     case 2: str = "20-bit TDMA TMSI"; break;
4833     case 3: str = "24-bit TDMA TMSI"; break;
4834     default:
4835         str = "Reserved for protocol extension, treat as Not used";
4836         break;
4837     }
4838
4839     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
4840     proto_tree_add_text(tree, asn1->tvb,
4841         saved_offset, asn1->offset - saved_offset,
4842         "%s :  Type of addressing, %s",
4843         bigbuf,
4844         str);
4845
4846     if (len == 5) return;
4847
4848     saved_offset = asn1->offset;
4849
4850     asn1_string_value_decode(asn1, (len-5), &poctets);
4851
4852     bigbuf[0] = first_dig;
4853
4854     my_dgt_tbcd_unpack(bigbuf+1, poctets, (len-5), &Dgt_tbcd);
4855     g_free(poctets);
4856
4857     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
4858         saved_offset - 1, (len-5)+1,
4859         "TMSI Zone, %s",
4860         bigbuf);
4861 }
4862
4863 static void
4864 param_reqd_param_mask(ASN1_SCK *asn1, proto_tree *tree, guint len)
4865 {
4866     gint32 value;
4867     guint saved_offset;
4868
4869     saved_offset = asn1->offset;
4870
4871     asn1_int32_value_decode(asn1, 1, &value);
4872
4873     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
4874     proto_tree_add_text(tree, asn1->tvb,
4875         saved_offset, asn1->offset - saved_offset,
4876         "%s :  Reserved",
4877         bigbuf);
4878
4879     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
4880     proto_tree_add_text(tree, asn1->tvb,
4881         saved_offset, asn1->offset - saved_offset,
4882         "%s :  Location Area ID (LOCID) %srequired",
4883         bigbuf,
4884         (value & 0x10) ? "" : "not ");
4885
4886     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
4887     proto_tree_add_text(tree, asn1->tvb,
4888         saved_offset, asn1->offset - saved_offset,
4889         "%s :  TMSI %srequired",
4890         bigbuf,
4891         (value & 0x08) ? "" : "not ");
4892
4893     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
4894     proto_tree_add_text(tree, asn1->tvb,
4895         saved_offset, asn1->offset - saved_offset,
4896         "%s :  ESN %srequired",
4897         bigbuf,
4898         (value & 0x04) ? "" : "not ");
4899
4900     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
4901     proto_tree_add_text(tree, asn1->tvb,
4902         saved_offset, asn1->offset - saved_offset,
4903         "%s :  MIN %srequired",
4904         bigbuf,
4905         (value & 0x02) ? "" : "not ");
4906
4907     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
4908     proto_tree_add_text(tree, asn1->tvb,
4909         saved_offset, asn1->offset - saved_offset,
4910         "%s :  IMSI %srequired",
4911         bigbuf,
4912         (value & 0x01) ? "" : "not ");
4913
4914     EXTRANEOUS_DATA_CHECK(len, 1);
4915 }
4916
4917 static void
4918 param_srvc_red_cause(ASN1_SCK *asn1, proto_tree *tree, guint len)
4919 {
4920     gint32 value;
4921     guint saved_offset;
4922     gchar *str = NULL;
4923
4924     saved_offset = asn1->offset;
4925
4926     asn1_int32_value_decode(asn1, 1, &value);
4927
4928     switch (value)
4929     {
4930     case 0: str = "Not used"; break;
4931     case 1: str = "Normal Registration"; break;
4932     case 2: str = "System Not Found"; break;
4933     case 3: str = "Protocol Mismatch"; break;
4934     case 4: str = "Registration Rejection"; break;
4935     case 5: str = "Wrong SID"; break;
4936     case 6: str = "Wrong NID"; break;
4937     default:
4938         if ((value >= 7) && (value <= 223)) { str = "Reserved, treat as Normal Registration"; }
4939         else { str = "Reserved for protocol extension. If unknown, treat as Normal Registration"; }
4940         break;
4941     }
4942
4943     proto_tree_add_text(tree, asn1->tvb,
4944         saved_offset, asn1->offset - saved_offset,
4945         str);
4946
4947     EXTRANEOUS_DATA_CHECK(len, 1);
4948 }
4949
4950 static void
4951 param_srvc_red_info(ASN1_SCK *asn1, proto_tree *tree, guint len)
4952 {
4953     gint32 value;
4954     guint saved_offset;
4955
4956     saved_offset = asn1->offset;
4957
4958     asn1_int32_value_decode(asn1, 1, &value);
4959
4960     my_decode_bitfield_value(bigbuf, value, 0xfc, 8);
4961     proto_tree_add_text(tree, asn1->tvb,
4962         saved_offset, asn1->offset - saved_offset,
4963         "%s :  Reserved",
4964         bigbuf);
4965
4966     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
4967     proto_tree_add_text(tree, asn1->tvb,
4968         saved_offset, asn1->offset - saved_offset,
4969         "%s :  NDSS Status (NDS), %ssuppressed",
4970         bigbuf,
4971         (value & 0x02) ? "" : "not ");
4972
4973     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
4974     proto_tree_add_text(tree, asn1->tvb,
4975         saved_offset, asn1->offset - saved_offset,
4976         "%s :  Return If Fail (RIF), If MS fails to access the redirected system, MS shall %sreturn to the serving system",
4977         bigbuf,
4978         (value & 0x01) ? "" : "not ");
4979
4980     EXTRANEOUS_DATA_CHECK(len, 1);
4981 }
4982
4983 static void
4984 param_roaming_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
4985 {
4986     gint32 value;
4987     guint saved_offset;
4988     gchar *str = NULL;
4989
4990     saved_offset = asn1->offset;
4991
4992     asn1_int32_value_decode(asn1, 1, &value);
4993
4994     switch (value)
4995     {
4996     case 0: str = "Roaming Indicator On"; break;
4997     case 1: str = "Roaming Indicator Off"; break;
4998     case 2: str = "Roaming Indicator Flashing"; break;
4999     case 3: str = "Out of Neighborhood"; break;
5000     case 4: str = "Out of Building"; break;
5001     case 5: str = "Roaming - Preferred System"; break;
5002     case 6: str = "Roaming - Available System"; break;
5003     case 7: str = "Roaming - Alliance Partner"; break;
5004     case 8: str = "Roaming - Premium Partner"; break;
5005     case 9: str = "Roaming - Full Service Functionality"; break;
5006     case 10: str = "Roaming - Partial Service Functionality"; break;
5007     case 11: str = "Roaming Banner On"; break;
5008     case 12: str = "Roaming Banner Off"; break;
5009     default:
5010         if ((value >= 13) && (value <= 63)) { str = "Reserved for Standard Enhanced Roaming Indicator Numbers"; }
5011         else if ((value >= 64) && (value <= 127)) { str = "Reserved for Non-Standard Enhanced Roaming Indicator Numbers"; }
5012         else { str = "Reserved"; }
5013         break;
5014     }
5015
5016     proto_tree_add_text(tree, asn1->tvb,
5017         saved_offset, asn1->offset - saved_offset,
5018         str);
5019
5020     EXTRANEOUS_DATA_CHECK(len, 1);
5021 }
5022
5023 static void
5024 param_cdma_pci(ASN1_SCK *asn1, proto_tree *tree, guint len)
5025 {
5026     gint32 value;
5027     guint saved_offset;
5028
5029     EXACT_DATA_CHECK(len, 1);
5030
5031     saved_offset = asn1->offset;
5032
5033     asn1_int32_value_decode(asn1, 1, &value);
5034
5035     my_decode_bitfield_value(bigbuf, value, 0xfe, 8);
5036     proto_tree_add_text(tree, asn1->tvb,
5037         saved_offset, asn1->offset - saved_offset,
5038         "%s :  Reserved",
5039         bigbuf);
5040
5041     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
5042     proto_tree_add_text(tree, asn1->tvb,
5043         saved_offset, asn1->offset - saved_offset,
5044         "%s :  CDMA PWR_COMB_IND",
5045         bigbuf);
5046 }
5047
5048 static void
5049 param_cdma_chan_num(ASN1_SCK *asn1, proto_tree *tree, guint len)
5050 {
5051     gint32 value;
5052     guint saved_offset;
5053
5054     SHORT_DATA_CHECK(len, 2);
5055
5056     saved_offset = asn1->offset;
5057
5058     asn1_int32_value_decode(asn1, 2, &value);
5059
5060     my_decode_bitfield_value(bigbuf, value >> 8, 0xf8, 8);
5061     proto_tree_add_text(tree, asn1->tvb,
5062         saved_offset, 1,
5063         "%s :  Reserved",
5064         bigbuf);
5065
5066     my_decode_bitfield_value(bigbuf, value >> 8, 0x07, 8);
5067     proto_tree_add_text(tree, asn1->tvb,
5068         saved_offset, 1,
5069         "%s :  CDMA Channel Number (MSB) %d",
5070         bigbuf,
5071         value & 0x07ff);
5072
5073     my_decode_bitfield_value(bigbuf, value & 0x00ff, 0xff, 8);
5074     proto_tree_add_text(tree, asn1->tvb,
5075         saved_offset+1, 1,
5076         "%s :  CDMA Channel Number (LSB)",
5077         bigbuf);
5078
5079     EXTRANEOUS_DATA_CHECK(len, 2);
5080 }
5081
5082 static void
5083 param_cdma_sci(ASN1_SCK *asn1, proto_tree *tree, guint len)
5084 {
5085     gint32 value;
5086     guint saved_offset;
5087
5088     EXACT_DATA_CHECK(len, 1);
5089
5090     saved_offset = asn1->offset;
5091
5092     asn1_int32_value_decode(asn1, 1, &value);
5093
5094     my_decode_bitfield_value(bigbuf, value, 0xf8, 8);
5095     proto_tree_add_text(tree, asn1->tvb,
5096         saved_offset, asn1->offset - saved_offset,
5097         "%s :  Reserved",
5098         bigbuf);
5099
5100     my_decode_bitfield_value(bigbuf, value, 0x07, 8);
5101     proto_tree_add_text(tree, asn1->tvb,
5102         saved_offset, asn1->offset - saved_offset,
5103         "%s :  Slot Cycle Index, %d",
5104         bigbuf,
5105         (value & 0x07));
5106 }
5107
5108 static void
5109 param_vp_report(ASN1_SCK *asn1, proto_tree *tree, guint len)
5110 {
5111     gint32 value;
5112     guint saved_offset;
5113     gchar *str = NULL;
5114
5115     EXACT_DATA_CHECK(len, 1);
5116
5117     saved_offset = asn1->offset;
5118
5119     asn1_int32_value_decode(asn1, 1, &value);
5120
5121     switch (value)
5122     {
5123     case 0: str = "Not used"; break;
5124     case 1: str = "Voice Privacy not attempted"; break;
5125     case 2: str = "Voice Privacy no response"; break;
5126     case 3: str = "Voiec Privacy successful is active"; break;
5127     case 4: str = "Voice Privacy failed"; break;
5128     default:
5129         if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Voice Privacy not attempted"; }
5130         else { str = "Reserved for protocol extension, treat as Voice Privacy not attempted"; }
5131         break;
5132     }
5133
5134     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5135         saved_offset, asn1->offset - saved_offset,
5136         "%s (%d)",
5137         str,
5138         value);
5139 }
5140
5141 static void
5142 param_cdma_scm(ASN1_SCK *asn1, proto_tree *tree, guint len)
5143 {
5144     gint32 value;
5145     guint saved_offset;
5146     gchar *str = NULL;
5147
5148     saved_offset = asn1->offset;
5149
5150     asn1_int32_value_decode(asn1, 1, &value);
5151
5152     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
5153     proto_tree_add_text(tree, asn1->tvb,
5154         saved_offset, asn1->offset - saved_offset,
5155         "%s :  Reserved",
5156         bigbuf);
5157
5158     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
5159     proto_tree_add_text(tree, asn1->tvb,
5160         saved_offset, asn1->offset - saved_offset,
5161         "%s :  Dual-mode Indicator, %s",
5162         bigbuf,
5163         (value & 0x40) ? "Dual mode CDMA" : "CDMA only");
5164
5165     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
5166     proto_tree_add_text(tree, asn1->tvb,
5167         saved_offset, asn1->offset - saved_offset,
5168         "%s :  Slotted mode Indicator, %s",
5169         bigbuf,
5170         (value & 0x20) ? "slotted capable" : "slotted incapable");
5171
5172     my_decode_bitfield_value(bigbuf, value, 0x18, 8);
5173     proto_tree_add_text(tree, asn1->tvb,
5174         saved_offset, asn1->offset - saved_offset,
5175         "%s :  Reserved",
5176         bigbuf);
5177
5178     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
5179     proto_tree_add_text(tree, asn1->tvb,
5180         saved_offset, asn1->offset - saved_offset,
5181         "%s :  Analog Transmission, %s",
5182         bigbuf,
5183         (value & 0x04) ? "discontinuous" : "continuous");
5184
5185     switch (value & 0x03)
5186     {
5187     case 0: str = "Power Class I"; break;
5188     case 1: str = "Power Class II"; break;
5189     case 2: str = "Power Class III"; break;
5190     case 3: str = "Reserved"; break;
5191     }
5192
5193     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
5194     proto_tree_add_text(tree, asn1->tvb,
5195         saved_offset, asn1->offset - saved_offset,
5196         "%s :  %s",
5197         bigbuf,
5198         str);
5199
5200     EXTRANEOUS_DATA_CHECK(len, 1);
5201 }
5202
5203 static void
5204 param_ota_result_code(ASN1_SCK *asn1, proto_tree *tree, guint len)
5205 {
5206     gint32 value;
5207     guint saved_offset;
5208     gchar *str = NULL;
5209
5210     saved_offset = asn1->offset;
5211
5212     asn1_int32_value_decode(asn1, 1, &value);
5213
5214     switch (value)
5215     {
5216     case 0: str = "Accepted - Successful"; break;
5217     case 1: str = "Rejected - Unknown cause"; break;
5218     case 2: str = "Computation Failure - E.g., unable to compute A-key"; break;
5219     case 3: str = "CSC Rejected - CSC challenge failure"; break;
5220     case 4: str = "Unrecognized OTASPCallEntry"; break;
5221     case 5: str = "Unsupported AKeyProtocolVersion(s)"; break;
5222     case 6: str = "Unable to Commit"; break;
5223     default:
5224         if ((value >= 7) && (value <= 223)) { str = "Reserved, treat as Rejected - Unknown cause"; }
5225         else { str = "Reserved for protocol extension, treat as Rejected - Unknown cause"; }
5226         break;
5227     }
5228
5229     proto_tree_add_text(tree, asn1->tvb,
5230         saved_offset, asn1->offset - saved_offset,
5231         "%s (%d)",
5232         str,
5233         value);
5234
5235     EXTRANEOUS_DATA_CHECK(len, 1);
5236 }
5237
5238 static void
5239 param_cdma_scm2(ASN1_SCK *asn1, proto_tree *tree, guint len)
5240 {
5241     gint32 value;
5242     guint saved_offset;
5243
5244     saved_offset = asn1->offset;
5245
5246     asn1_int32_value_decode(asn1, 1, &value);
5247
5248     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5249         saved_offset, asn1->offset - saved_offset,
5250         "Value %d",
5251         value);
5252
5253     EXTRANEOUS_DATA_CHECK(len, 1);
5254 }
5255
5256 static void
5257 param_tdma_term_cap(ASN1_SCK *asn1, proto_tree *tree, guint len)
5258 {
5259     gint32 value;
5260     guint saved_offset;
5261     gchar *str = NULL;
5262
5263     SHORT_DATA_CHECK(len, 4);
5264
5265     saved_offset = asn1->offset;
5266
5267     asn1_int32_value_decode(asn1, 1, &value);
5268
5269     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
5270     proto_tree_add_text(tree, asn1->tvb,
5271         saved_offset, asn1->offset - saved_offset,
5272         "%s :  Reserved",
5273         bigbuf);
5274
5275     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
5276     proto_tree_add_text(tree, asn1->tvb,
5277         saved_offset, asn1->offset - saved_offset,
5278         "%s :  1800 MHz F channel %sacceptable",
5279         bigbuf,
5280         (value & 0x40) ? "" : "not ");
5281
5282     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
5283     proto_tree_add_text(tree, asn1->tvb,
5284         saved_offset, asn1->offset - saved_offset,
5285         "%s :  1800 MHz E channel %sacceptable",
5286         bigbuf,
5287         (value & 0x20) ? "" : "not ");
5288
5289     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
5290     proto_tree_add_text(tree, asn1->tvb,
5291         saved_offset, asn1->offset - saved_offset,
5292         "%s :  1800 MHz D channel %sacceptable",
5293         bigbuf,
5294         (value & 0x10) ? "" : "not ");
5295
5296     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
5297     proto_tree_add_text(tree, asn1->tvb,
5298         saved_offset, asn1->offset - saved_offset,
5299         "%s :  1800 MHz C channel %sacceptable",
5300         bigbuf,
5301         (value & 0x08) ? "" : "not ");
5302
5303     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
5304     proto_tree_add_text(tree, asn1->tvb,
5305         saved_offset, asn1->offset - saved_offset,
5306         "%s :  1800 MHz B channel %sacceptable",
5307         bigbuf,
5308         (value & 0x04) ? "" : "not ");
5309
5310     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
5311     proto_tree_add_text(tree, asn1->tvb,
5312         saved_offset, asn1->offset - saved_offset,
5313         "%s :  %s acceptable",
5314         bigbuf,
5315         (value & 0x02) ? "1800 MHz A channel" : "1800 MHz A&B Digital channel not");
5316
5317     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
5318     proto_tree_add_text(tree, asn1->tvb,
5319         saved_offset, asn1->offset - saved_offset,
5320         "%s :  800 MHz A&B channel %sacceptable",
5321         bigbuf,
5322         (value & 0x01) ? "" : "not ");
5323
5324     saved_offset = asn1->offset;
5325
5326     asn1_int32_value_decode(asn1, 1, &value);
5327
5328     my_decode_bitfield_value(bigbuf, value, 0xfc, 8);
5329     proto_tree_add_text(tree, asn1->tvb,
5330         saved_offset, asn1->offset - saved_offset,
5331         "%s :  Reserved",
5332         bigbuf);
5333
5334     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
5335     proto_tree_add_text(tree, asn1->tvb,
5336         saved_offset, asn1->offset - saved_offset,
5337         "%s :  IS-641 Voice Coder %sacceptable",
5338         bigbuf,
5339         (value & 0x02) ? "" : "not ");
5340
5341     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
5342     proto_tree_add_text(tree, asn1->tvb,
5343         saved_offset, asn1->offset - saved_offset,
5344         "%s :  VSELP Voice Coder %sacceptable",
5345         bigbuf,
5346         (value & 0x01) ? "" : "not ");
5347
5348     saved_offset = asn1->offset;
5349
5350     asn1_int32_value_decode(asn1, 1, &value);
5351
5352     switch (value)
5353     {
5354     case 0: str = "EIA-553 or IS-54-A"; break;
5355     case 1: str = "TIA/EIA-627 (IS-54-B)"; break;
5356     case 2: str = "IS-136"; break;
5357     case 3: str = "Reserved (ANSI J-STD-011)"; break;
5358     case 4: str = "PV 0 as published in TIA/EIA-136-0 and IS-136-A"; break;
5359     case 5: str = "PV 1 as published in TIA/EIA-136-A"; break;
5360     case 6: str = "PV 2 as published in TIA/EIA-136-A"; break;
5361     case 7: str = "PV 3 as published in TIA/EIA-136-A"; break;
5362     default:
5363         str = "Reserved, treat as EIA-553 or IS-54-A";
5364         break;
5365     }
5366
5367     proto_tree_add_text(tree, asn1->tvb,
5368         saved_offset, 1,
5369         "Protocol Version, %s",
5370         str);
5371
5372     saved_offset = asn1->offset;
5373
5374     asn1_int32_value_decode(asn1, 1, &value);
5375
5376     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
5377     proto_tree_add_text(tree, asn1->tvb,
5378         saved_offset, asn1->offset - saved_offset,
5379         "%s :  Triple Rate (3RATE) %ssupported",
5380         bigbuf,
5381         (value & 0x80) ? "" : "not ");
5382
5383     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
5384     proto_tree_add_text(tree, asn1->tvb,
5385         saved_offset, asn1->offset - saved_offset,
5386         "%s :  Double Rate (2RATE) %ssupported",
5387         bigbuf,
5388         (value & 0x40) ? "" : "not ");
5389
5390     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
5391     proto_tree_add_text(tree, asn1->tvb,
5392         saved_offset, asn1->offset - saved_offset,
5393         "%s :  Full Rate (FRATE) %ssupported",
5394         bigbuf,
5395         (value & 0x20) ? "" : "not ");
5396
5397     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
5398     proto_tree_add_text(tree, asn1->tvb,
5399         saved_offset, asn1->offset - saved_offset,
5400         "%s :  Half Rate (HRATE) %ssupported",
5401         bigbuf,
5402         (value & 0x10) ? "" : "not ");
5403
5404     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
5405     proto_tree_add_text(tree, asn1->tvb,
5406         saved_offset, asn1->offset - saved_offset,
5407         "%s :  Analog Voice (AVOX) %ssupported",
5408         bigbuf,
5409         (value & 0x08) ? "" : "not ");
5410
5411     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
5412     proto_tree_add_text(tree, asn1->tvb,
5413         saved_offset, asn1->offset - saved_offset,
5414         "%s :  Secure Telephone Unit III (STU3) %ssupported",
5415         bigbuf,
5416         (value & 0x04) ? "" : "not ");
5417
5418     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
5419     proto_tree_add_text(tree, asn1->tvb,
5420         saved_offset, asn1->offset - saved_offset,
5421         "%s :  Group 3 Fax (G3FAX) %ssupported",
5422         bigbuf,
5423         (value & 0x02) ? "" : "not ");
5424
5425     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
5426     proto_tree_add_text(tree, asn1->tvb,
5427         saved_offset, asn1->offset - saved_offset,
5428         "%s :  Asynchronous Data (ADS) %ssupported",
5429         bigbuf,
5430         (value & 0x01) ? "" : "not ");
5431
5432     EXTRANEOUS_DATA_CHECK(len, 4);
5433 }
5434
5435 static void
5436 param_tdma_voice_coder(ASN1_SCK *asn1, proto_tree *tree, guint len)
5437 {
5438     gint32 value, vc;
5439     guint orig_offset, saved_offset;
5440     gchar *str = NULL;
5441
5442     SHORT_DATA_CHECK(len, 2);
5443
5444     orig_offset = asn1->offset;
5445     saved_offset = asn1->offset;
5446
5447     do
5448     {
5449         asn1_int32_value_decode(asn1, 1, &value);
5450
5451         my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
5452         proto_tree_add_text(tree, asn1->tvb,
5453             saved_offset, asn1->offset - saved_offset,
5454             "%s :  Reserved",
5455             bigbuf);
5456
5457         vc = (value & 0x0f);
5458         switch (vc)
5459         {
5460         case 0: str = "Not used"; break;
5461         case 1: str = "VSELP Voice Coder acceptable"; break;
5462         case 2: str = "IS-641 Voice Coder acceptable"; break;
5463         case 6: str = "Reserved for SOC/BSMC Specific signaling. If unknown, use any acceptable value"; break;
5464         default:
5465             if ((vc >= 3) && (vc <= 5)) { str = "Reserved. Ignore on reception, use any acceptable value"; }
5466             else if ((vc >= 7) && (vc <= 12)) { str = "Reserved. Ignore on reception, use any acceptable value"; }
5467             else if ((vc >= 13) && (vc <= 15)) { str = "Reserved for protocol extension. If unknown, use any acceptable value"; }
5468             break;
5469         }
5470
5471         my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
5472         proto_tree_add_text(tree, asn1->tvb,
5473             saved_offset, asn1->offset - saved_offset,
5474             "%s :  Voice Coder, %s",
5475             bigbuf,
5476             str);
5477
5478         saved_offset = asn1->offset;
5479     }
5480     while ((len - (saved_offset - orig_offset)) > 0);
5481 }
5482
5483 static void
5484 param_cdma_pilot_pn(ASN1_SCK *asn1, proto_tree *tree, guint len)
5485 {
5486     gint32 value;
5487     guint saved_offset;
5488
5489     SHORT_DATA_CHECK(len, 2);
5490
5491     saved_offset = asn1->offset;
5492
5493     asn1_int32_value_decode(asn1, 2, &value);
5494
5495     my_decode_bitfield_value(bigbuf, value >> 8, 0xfe, 8);
5496     proto_tree_add_text(tree, asn1->tvb,
5497         saved_offset, 1,
5498         "%s :  Reserved",
5499         bigbuf);
5500
5501     my_decode_bitfield_value(bigbuf, value >> 8, 0x01, 8);
5502     proto_tree_add_text(tree, asn1->tvb,
5503         saved_offset, 1,
5504         "%s :  Pilot PN (MSB), %d",
5505         bigbuf, value & 0x01ff);
5506
5507     my_decode_bitfield_value(bigbuf, value & 0x00ff, 0xff, 8);
5508     proto_tree_add_text(tree, asn1->tvb,
5509         saved_offset + 1, 1,
5510         "%s :  Pilot PN (LSB)",
5511         bigbuf);
5512
5513     EXTRANEOUS_DATA_CHECK(len, 2);
5514 }
5515
5516 static void
5517 param_cdma_pilot_strength(ASN1_SCK *asn1, proto_tree *tree, guint len)
5518 {
5519     gint32 value;
5520     guint saved_offset;
5521
5522     EXACT_DATA_CHECK(len, 1);
5523
5524     saved_offset = asn1->offset;
5525
5526     asn1_int32_value_decode(asn1, 1, &value);
5527
5528     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
5529     proto_tree_add_text(tree, asn1->tvb,
5530         saved_offset, asn1->offset - saved_offset,
5531         "%s :  Reserved",
5532         bigbuf);
5533
5534     my_decode_bitfield_value(bigbuf, value, 0x3f, 8);
5535     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5536         saved_offset, asn1->offset - saved_offset,
5537         "%s :  Value %d",
5538         bigbuf,
5539         value & 0x3f);
5540 }
5541
5542 static void
5543 param_trunk_stat(ASN1_SCK *asn1, proto_tree *tree, guint len)
5544 {
5545     gint32 value;
5546     guint saved_offset;
5547     gchar *str = NULL;
5548
5549     EXACT_DATA_CHECK(len, 1);
5550
5551     saved_offset = asn1->offset;
5552
5553     asn1_int32_value_decode(asn1, 1, &value);
5554
5555     switch (value)
5556     {
5557     case 0: str = "Idle"; break;
5558     case 1: str = "Blocked"; break;
5559     default:
5560         if ((value >= 2) && (value <= 223)) { str = "Reserved, treat as ERROR or Blocked"; }
5561         else { str = "Reserved for protocol extension, treat as ERROR or Blocked"; }
5562         break;
5563     }
5564
5565     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5566         saved_offset, asn1->offset - saved_offset,
5567         "Trunk Status, %s",
5568         str);
5569 }
5570
5571 static void
5572 param_pref_lang_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
5573 {
5574     gint32 value;
5575     guint saved_offset;
5576     gchar *str = NULL;
5577
5578     saved_offset = asn1->offset;
5579
5580     asn1_int32_value_decode(asn1, 1, &value);
5581
5582     switch (value)
5583     {
5584     case 0: str = "Unspecified"; break;
5585     case 1: str = "English"; break;
5586     case 2: str = "French"; break;
5587     case 3: str = "Spanish"; break;
5588     case 4: str = "German"; break;
5589     case 5: str = "Portuguese"; break;
5590     default:
5591         str = "Reserved, treat as Unspecified";
5592         break;
5593     }
5594
5595     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5596         saved_offset, asn1->offset - saved_offset,
5597         "Preferred Language, %s",
5598         str);
5599
5600     EXTRANEOUS_DATA_CHECK(len, 1);
5601 }
5602
5603 static void
5604 param_rand_valtime(ASN1_SCK *asn1, proto_tree *tree, guint len)
5605 {
5606     gint32 value;
5607     guint saved_offset;
5608     gchar *str = NULL;
5609
5610     saved_offset = asn1->offset;
5611
5612     asn1_int32_value_decode(asn1, 1, &value);
5613
5614     if (value == 0)
5615     {
5616         str = "RAND shall not be stored";
5617     }
5618     else
5619     {
5620         sprintf(bigbuf, "RAND may be used for %d minutes", value);
5621         str = bigbuf;
5622     }
5623
5624     proto_tree_add_text(tree, asn1->tvb,
5625         saved_offset, asn1->offset - saved_offset,
5626         str);
5627
5628     EXTRANEOUS_DATA_CHECK(len, 1);
5629 }
5630
5631 static void
5632 param_tdma_burst_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
5633 {
5634     gint32 value;
5635     guint saved_offset;
5636     gchar *str = NULL;
5637
5638     EXACT_DATA_CHECK(len, 1);
5639
5640     saved_offset = asn1->offset;
5641
5642     asn1_int32_value_decode(asn1, 1, &value);
5643
5644     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
5645     proto_tree_add_text(tree, asn1->tvb,
5646         saved_offset, asn1->offset - saved_offset,
5647         "%s :  Reserved",
5648         bigbuf);
5649
5650     my_decode_bitfield_value(bigbuf, value, 0x7c, 8);
5651     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5652         saved_offset, asn1->offset - saved_offset,
5653         "%s :  Time Alignment Offset (TA), %d",
5654         bigbuf,
5655         (value & 0x7c) >> 2);
5656
5657     switch (value & 0x03)
5658     {
5659     case 0: str = "Transmit normal burst after cell-to-cell handoff"; break;
5660     case 1: str = "Transmit normal burst after handoff within cell"; break;
5661     case 2: str = "Transmit shortened burst after cell-to-cell handoff"; break;
5662     case 3: str = "Reserved, treat with RETURN ERROR"; break;
5663     }
5664
5665     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
5666     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5667         saved_offset, asn1->offset - saved_offset,
5668         "%s :  Burst Code, %s",
5669         bigbuf,
5670         str);
5671 }
5672
5673 static void
5674 param_orig_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
5675 {
5676     gint32 value;
5677     guint saved_offset;
5678     gchar *str = NULL;
5679
5680     EXACT_DATA_CHECK(len, 1);
5681
5682     saved_offset = asn1->offset;
5683
5684     asn1_int32_value_decode(asn1, 1, &value);
5685
5686     switch (value)
5687     {
5688     case 0: str = "Not used"; break;
5689     case 1: str = "Prior agreement"; break;
5690     case 2: str = "Origination denied"; break;
5691     case 3: str = "Local calls only"; break;
5692     case 4: str = "Selected leading digits of directory number or of international E.164 number, see Digits(Destination)"; break;
5693     case 5: str = "Selected leading digits of directory number or of international E.164 number and local calls only, see Digits(Destination)"; break;
5694     case 6: str = "National long distance"; break;
5695     case 7: str = "International calls"; break;
5696     case 8: str = "Single directory number or international E.164 number, see Digits(Destination)"; break;
5697     default:
5698         if ((value >= 9) && (value <= 223)) { str = "Reserved, treat as Local calls only"; }
5699         else { str = "Reserved for protocol extension, treat as Local calls only"; }
5700         break;
5701     }
5702
5703     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5704         saved_offset, asn1->offset - saved_offset,
5705         "Allowed Call Types, %s",
5706         str);
5707 }
5708
5709 static void
5710 param_ms_loc(ASN1_SCK *asn1, proto_tree *tree, guint len)
5711 {
5712     gint32 value;
5713     guint saved_offset;
5714
5715     SHORT_DATA_CHECK(len, 7);
5716
5717     saved_offset = asn1->offset;
5718
5719     asn1_int32_value_decode(asn1, 3, &value);
5720
5721     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5722         saved_offset, asn1->offset - saved_offset,
5723         "Latitude in tenths of a second, %d",
5724         value);
5725
5726     saved_offset = asn1->offset;
5727
5728     asn1_int32_value_decode(asn1, 3, &value);
5729
5730     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5731         saved_offset, asn1->offset - saved_offset,
5732         "Longitude in tenths of a second, %d",
5733         value);
5734
5735     saved_offset = asn1->offset;
5736
5737     asn1_int32_value_decode(asn1, MIN(len - 6, 2), &value);
5738
5739     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5740         saved_offset, asn1->offset - saved_offset,
5741         "Resolution in units of 1 foot, %d",
5742         value);
5743
5744     EXTRANEOUS_DATA_CHECK(len, 8);
5745 }
5746
5747 static void
5748 param_unique_chal_rep(ASN1_SCK *asn1, proto_tree *tree, guint len)
5749 {
5750     gint32 value;
5751     guint saved_offset;
5752     gchar *str = NULL;
5753
5754     saved_offset = asn1->offset;
5755
5756     asn1_int32_value_decode(asn1, 1, &value);
5757
5758     switch (value)
5759     {
5760     case 0: str = "Not used"; break;
5761     case 1: str = "Unique Challenge not attempted"; break;
5762     case 2: str = "Unique Challenge no response"; break;
5763     case 3: str = "Unique Challenge successful"; break;
5764     case 4: str = "Unique Challenge failed"; break;
5765     default:
5766         if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Unique Challenge not attempted"; }
5767         else { str = "Reserved for protocol extension, treat as Unique Challenge not attempted"; }
5768         break;
5769     }
5770
5771     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5772         saved_offset, asn1->offset - saved_offset,
5773         str);
5774
5775     EXTRANEOUS_DATA_CHECK(len, 1);
5776 }
5777
5778 static void
5779 param_rand_unique(ASN1_SCK *asn1, proto_tree *tree, guint len)
5780 {
5781     guint saved_offset;
5782
5783     EXACT_DATA_CHECK(len, 3);
5784
5785     saved_offset = asn1->offset;
5786
5787     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5788         saved_offset, len,
5789         "24-bit random number used as input to the CAVE algorithm for authenticating a specific MS");
5790
5791     asn1->offset += len;
5792 }
5793
5794 static void
5795 param_vpmask(ASN1_SCK *asn1, proto_tree *tree, guint len)
5796 {
5797     gint32 value;
5798     guint saved_offset;
5799
5800     EXACT_DATA_CHECK(len, 66);
5801
5802     saved_offset = asn1->offset;
5803
5804     asn1_int32_value_decode(asn1, 1, &value);
5805
5806     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
5807     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5808         saved_offset, asn1->offset - saved_offset,
5809         "%s :  Reserved",
5810         bigbuf);
5811
5812     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
5813     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5814         saved_offset, asn1->offset - saved_offset,
5815         "%s :  Voice Privacy Mask-A (VPMASK-A) (MSB)",
5816         bigbuf);
5817
5818     saved_offset = asn1->offset;
5819
5820     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5821         saved_offset, 32,
5822         "Voice Privacy Mask-A (VPMASK-A)");
5823
5824     asn1->offset += 32;
5825
5826     saved_offset = asn1->offset;
5827
5828     asn1_int32_value_decode(asn1, 1, &value);
5829
5830     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
5831     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5832         saved_offset, asn1->offset - saved_offset,
5833         "%s :  Reserved",
5834         bigbuf);
5835
5836     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
5837     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5838         saved_offset, asn1->offset - saved_offset,
5839         "%s :  Voice Privacy Mask-B (VPMASK-B) (MSB)",
5840         bigbuf);
5841
5842     saved_offset = asn1->offset;
5843
5844     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5845         saved_offset, 32,
5846         "Voice Privacy Mask-B (VPMASK-B)");
5847
5848     asn1->offset += 32;
5849 }
5850
5851 static void
5852 param_ssd(ASN1_SCK *asn1, proto_tree *tree, guint len)
5853 {
5854     guint saved_offset;
5855
5856     EXACT_DATA_CHECK(len, 16);
5857
5858     saved_offset = asn1->offset;
5859
5860     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5861         saved_offset, 8,
5862         "Shared Secret Data-A (SSD-A)");
5863
5864     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5865         saved_offset+8, 8,
5866         "Shared Secret Data-B (SSD-B)");
5867
5868     asn1->offset += len;
5869 }
5870
5871 static void
5872 param_upd_count(ASN1_SCK *asn1, proto_tree *tree, guint len)
5873 {
5874     gint32 value;
5875     guint saved_offset;
5876     gchar *str = NULL;
5877
5878     EXACT_DATA_CHECK(len, 1);
5879
5880     saved_offset = asn1->offset;
5881
5882     asn1_int32_value_decode(asn1, 1, &value);
5883
5884     switch (value)
5885     {
5886     case 0: str = "Not used"; break;
5887     case 1: str = "Update COUNT"; break;
5888     default:
5889         if ((value >= 2) && (value <= 223)) { str = "Reserved, treat as Update COUNT"; }
5890         else { str = "Reserved for protocol extension, treat as Update COUNT"; }
5891         break;
5892     }
5893
5894     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5895         saved_offset, asn1->offset - saved_offset,
5896         "%s",
5897         str);
5898 }
5899
5900 static void
5901 param_sme_key(ASN1_SCK *asn1, proto_tree *tree, guint len)
5902 {
5903     guint saved_offset;
5904
5905     EXACT_DATA_CHECK(len, 8);
5906
5907     saved_offset = asn1->offset;
5908
5909     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5910         saved_offset, len,
5911         "Signaling Message Encryption Key (SMEKEY)");
5912
5913     asn1->offset += len;
5914 }
5915
5916 static void
5917 param_rand_ssd(ASN1_SCK *asn1, proto_tree *tree, guint len)
5918 {
5919     guint saved_offset;
5920
5921     EXACT_DATA_CHECK(len, 7);
5922
5923     saved_offset = asn1->offset;
5924
5925     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5926         saved_offset, len,
5927         "56-bit random number used as input to the CAVE algorithm for generating Shared Secret Data");
5928
5929     asn1->offset += len;
5930 }
5931
5932 static void
5933 param_setup_result(ASN1_SCK *asn1, proto_tree *tree, guint len)
5934 {
5935     gint32 value;
5936     guint saved_offset;
5937     gchar *str = NULL;
5938
5939     saved_offset = asn1->offset;
5940
5941     asn1_int32_value_decode(asn1, 1, &value);
5942
5943     switch (value)
5944     {
5945     case 0: str = "Not used"; break;
5946     case 1: str = "Unsuccessful"; break;
5947     case 2: str = "Successful"; break;
5948     default:
5949         str = "Reserved, treat as Unsuccessful";
5950         break;
5951     }
5952
5953     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5954         saved_offset, asn1->offset - saved_offset,
5955         str);
5956
5957     EXTRANEOUS_DATA_CHECK(len, 1);
5958 }
5959
5960 static void
5961 param_randc(ASN1_SCK *asn1, proto_tree *tree, guint len)
5962 {
5963     guint saved_offset;
5964
5965     saved_offset = asn1->offset;
5966
5967     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
5968         saved_offset, 1,
5969         "The 8 most significant bits of the 32-bit Random Variable used to compute the Authentication Response");
5970
5971     asn1->offset += 1;
5972
5973     EXTRANEOUS_DATA_CHECK(len, 1);
5974 }
5975
5976 static void
5977 param_ext_mscid(ASN1_SCK *asn1, proto_tree *tree, guint len)
5978 {
5979     gint32 type;
5980     guint saved_offset;
5981     gchar *str = NULL;
5982
5983     EXACT_DATA_CHECK(len, 4);
5984
5985     saved_offset = asn1->offset;
5986
5987     asn1_int32_value_decode(asn1, 1, &type);
5988
5989     switch (type)
5990     {
5991     case 0: str = "Not specified"; break;
5992     case 1: str = "Serving MSC"; break;
5993     case 2: str = "Home MSC"; break;
5994     case 3: str = "Gateway MSC"; break;
5995     case 4: str = "HLR"; break;
5996     case 5: str = "VLR"; break;
5997     case 6: str = "EIR (reserved)"; break;
5998     case 7: str = "AC"; break;
5999     case 8: str = "Border MSC"; break;
6000     case 9: str = "Originating MSC"; break;
6001     default:
6002         if ((type >= 10) && (type <= 223)) { str = "Reserved, treat as Not specified"; }
6003         else { str = "Reserved for protocol extension, treat as Not specified"; }
6004         break;
6005     }
6006
6007     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6008         saved_offset, asn1->offset - saved_offset,
6009         "Type (%d), %s",
6010         type,
6011         str);
6012
6013     param_mscid(asn1, tree, len-1);
6014 }
6015
6016 static void
6017 param_sub_addr(ASN1_SCK *asn1, proto_tree *tree, guint len)
6018 {
6019     gint32 value;
6020     guint saved_offset;
6021     gchar *str = NULL;
6022
6023     saved_offset = asn1->offset;
6024     asn1_int32_value_decode(asn1, 1, &value);
6025
6026     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
6027     proto_tree_add_text(tree, asn1->tvb,
6028         saved_offset, asn1->offset - saved_offset,
6029         "%s :  Should be 1",
6030         bigbuf);
6031
6032     switch ((value & 0x70) >> 4)
6033     {
6034     case 0x00: str = "NSAP (CCITT Rec. X.213 or ISO 8348 AD2)"; break;
6035     case 0x02: str = "User specified"; break;
6036     default:
6037         str = "Reserved";
6038         break;
6039     }
6040
6041     my_decode_bitfield_value(bigbuf, value, 0x70, 8);
6042     proto_tree_add_text(tree, asn1->tvb,
6043         saved_offset, asn1->offset - saved_offset,
6044         "%s :  Type of Subaddress %s",
6045         bigbuf, str);
6046
6047     switch ((value & 0x08) >> 3)
6048     {
6049     case 0x00: str = "Even number of subaddress signals follow"; break;
6050     case 0x01: str = "Odd number of subaddress signals follow"; break;
6051     }
6052
6053     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
6054     proto_tree_add_text(tree, asn1->tvb,
6055         saved_offset, asn1->offset - saved_offset,
6056         "%s :  %s",
6057         bigbuf, str);
6058
6059     proto_tree_add_text(tree, asn1->tvb,
6060         asn1->offset, len - 1,
6061         "Subaddress");
6062
6063     asn1->offset += len - 1;
6064 }
6065
6066 static void
6067 param_digits(ASN1_SCK *asn1, proto_tree *tree, guint len)
6068 {
6069     gint32 value, b1, b2, b3, b4, enc, plan;
6070     guint saved_offset;
6071     gchar *str = NULL;
6072     proto_item *item;
6073     proto_tree *subtree;
6074     guchar *poctets;
6075
6076     SHORT_DATA_CHECK(len, 4);
6077
6078     saved_offset = asn1->offset;
6079     asn1_int32_value_decode(asn1, 1, &value);
6080
6081     switch (value)
6082     {
6083     case 0: str = "Not used"; break;
6084     case 1: str = "Dialed Numer or Called Party Number"; break;
6085     case 2: str = "Calling Party Number"; break;
6086     case 3: str = "Caller Interaction (Not used)"; break;
6087     case 4: str = "Routing Number"; break;
6088     case 5: str = "Billing Number"; break;
6089     case 6: str = "Destination Number"; break;
6090     case 7: str = "LATA (Not used)"; break;
6091     case 8: str = "Carrier"; break;
6092     case 13: str = "ESRD"; break;
6093     default:
6094         str = "Reserved";
6095         break;
6096     }
6097
6098     item =
6099         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6100             saved_offset, asn1->offset - saved_offset,
6101             "Type of Digits %d: %s",
6102             value, str);
6103
6104     subtree = proto_item_add_subtree(item, ett_natnum);
6105
6106     saved_offset = asn1->offset;
6107     asn1_int32_value_decode(asn1, 1, &value);
6108
6109     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
6110     proto_tree_add_text(subtree, asn1->tvb,
6111         saved_offset, asn1->offset - saved_offset,
6112         "%s :  Reserved",
6113         bigbuf);
6114
6115     switch ((value & 0x30) >> 4)
6116     {
6117     case 0x00: str = "User provided, not screened"; break;
6118     case 0x01: str = "User provided, screening passed"; break;
6119     case 0x02: str = "User provided, screening failed"; break;
6120     case 0x03: str = "Network provided"; break;
6121     }
6122
6123     my_decode_bitfield_value(bigbuf, value, 0x30, 8);
6124     proto_tree_add_text(subtree, asn1->tvb,
6125         saved_offset, asn1->offset - saved_offset,
6126         "%s :  %s",
6127         bigbuf, str);
6128
6129     proto_tree_add_text(subtree, asn1->tvb,
6130         saved_offset, asn1->offset - saved_offset,
6131         ".... %d... :  Reserved",
6132         (value & 0x08) >> 3);
6133
6134     proto_tree_add_text(subtree, asn1->tvb,
6135         saved_offset, asn1->offset - saved_offset,
6136         ".... .%d.. :  Number is %savailable",
6137         (value & 0x04) >> 2, (value & 0x04) ? "not " : "");
6138
6139     proto_tree_add_text(subtree, asn1->tvb,
6140         saved_offset, asn1->offset - saved_offset,
6141         ".... ..%d. :  Presentation %s",
6142         (value & 0x02) >> 1, (value & 0x02) ? "Restricted" : "Allowed");
6143
6144     proto_tree_add_text(subtree, asn1->tvb,
6145         saved_offset, asn1->offset - saved_offset,
6146         ".... ...%d :  %s",
6147         value & 0x01, (value & 0x01) ? "International" : "National");
6148
6149     saved_offset = asn1->offset;
6150     asn1_int32_value_decode(asn1, 1, &value);
6151
6152     plan = (value & 0xf0) >> 4;
6153     switch (plan)
6154     {
6155     case 0x00: str = "Unknown or not applicable"; break;
6156     case 0x01: str = "ISDN Numbering (Not used)"; break;
6157     case 0x02: str = "Telephony Numbering (ITU-T Rec. E.164, E.163)"; break;
6158     case 0x03: str = "Data Numbering (ITU-T Rec. X.121)(Not used)"; break;
6159     case 0x04: str = "Telex Numbering (ITU-T Rec. F.69)(Not used)"; break;
6160     case 0x05: str = "Maritime Mobile Numbering (Not used)"; break;
6161     case 0x06: str = "Land Mobile Numbering (ITU-T Rec. E.212)"; break;
6162     case 0x07: str = "Private Numbering Plan (service provider defined)"; break;
6163     case 0x0d: str = "ANSI SS7 Point Code (PC) and Subsystem Number (SSN)"; break;
6164     case 0x0e: str = "Internet Protocol (IP) Address"; break;
6165     case 0x0f: str = "Reserved for extension"; break;
6166     default:
6167         str = "Reserved";
6168         break;
6169     }
6170
6171     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
6172     proto_tree_add_text(tree, asn1->tvb,
6173         saved_offset, asn1->offset - saved_offset,
6174         "%s :  Numbering Plan, %s",
6175         bigbuf, str);
6176
6177     enc = value & 0x0f;
6178     switch (enc)
6179     {
6180     case 0x00: str = "Not used"; break;
6181     case 0x01: str = "BCD"; break;
6182     case 0x02: str = "IA5"; break;
6183     case 0x03: str = "Octet String"; break;
6184     default:
6185         str = "Reserved";
6186         break;
6187     }
6188
6189     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
6190     proto_tree_add_text(tree, asn1->tvb,
6191         saved_offset, asn1->offset - saved_offset,
6192         "%s :  Encoding, %s",
6193         bigbuf, str);
6194
6195     saved_offset = asn1->offset;
6196
6197     if (plan == 0x0d)
6198     {
6199         asn1_int32_value_decode(asn1, 1, &b1);
6200         asn1_int32_value_decode(asn1, 1, &b2);
6201         asn1_int32_value_decode(asn1, 1, &b3);
6202         asn1_int32_value_decode(asn1, 1, &b4);
6203
6204         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6205             saved_offset, asn1->offset - saved_offset,
6206             "Point Code %d-%d-%d  SSN %d",
6207             b1, b2, b3, b4);
6208     }
6209     else if (plan == 0x0e)
6210     {
6211         asn1_int32_value_decode(asn1, 1, &b1);
6212         asn1_int32_value_decode(asn1, 1, &b2);
6213         asn1_int32_value_decode(asn1, 1, &b3);
6214         asn1_int32_value_decode(asn1, 1, &b4);
6215
6216         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6217             saved_offset, asn1->offset - saved_offset,
6218             "IP Address %d.%d.%d.%d",
6219             b1, b2, b3, b4);
6220     }
6221     else
6222     {
6223         asn1_int32_value_decode(asn1, 1, &value);
6224
6225         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6226             saved_offset, asn1->offset - saved_offset,
6227             "Number of Digits, %d",
6228             value);
6229
6230         if (enc == 0x02)
6231         {
6232             proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6233                 asn1->offset, value,
6234                 "IA5 Digits");
6235
6236             asn1->offset += value;
6237         }
6238         else if (enc == 0x01)
6239         {
6240             saved_offset = asn1->offset;
6241             asn1_string_value_decode(asn1, (value+1)/2, &poctets);
6242
6243             my_dgt_tbcd_unpack(bigbuf, poctets, (value+1)/2, &Dgt_tbcd);
6244             g_free(poctets);
6245
6246             proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6247                 saved_offset, (value+1)/2,
6248                 "BCD Digits, %s",
6249                 bigbuf);
6250         }
6251     }
6252 }
6253
6254 static void
6255 param_esn(ASN1_SCK *asn1, proto_tree *tree, guint len)
6256 {
6257     gint32 value;
6258     guint saved_offset;
6259
6260     EXACT_DATA_CHECK(len, 4);
6261
6262     saved_offset = asn1->offset;
6263
6264     asn1_int32_value_decode(asn1, 4, &value);
6265
6266     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6267         saved_offset, asn1->offset - saved_offset,
6268         "ESN 0x%x",
6269         value);
6270 }
6271
6272 static void
6273 param_sms_noti(ASN1_SCK *asn1, proto_tree *tree, guint len)
6274 {
6275     gint32 value;
6276     guint saved_offset;
6277     gchar *str = NULL;
6278
6279     saved_offset = asn1->offset;
6280
6281     asn1_int32_value_decode(asn1, 1, &value);
6282
6283     switch (value)
6284     {
6285     case 0: str = "Not used"; break;
6286     case 1: str = "Notify when available"; break;
6287     case 2: str = "Do not notify when available"; break;
6288     default:
6289         if ((value >= 3) && (value <= 127)) { str = "Reserved, treat as Notify when available"; }
6290         else if ((value >= 128) && (value <= 223)) { str = "Reserved, treat as Do not notify when available"; }
6291         else { str = "Reserved for protocol extension"; }
6292         break;
6293     }
6294
6295     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6296         saved_offset, asn1->offset - saved_offset,
6297         "%s (%d)",
6298         str,
6299         value);
6300
6301     EXTRANEOUS_DATA_CHECK(len, 1);
6302 }
6303
6304 static void
6305 param_sms_orig_restric(ASN1_SCK *asn1, proto_tree *tree, guint len)
6306 {
6307     gint32 value;
6308     guint saved_offset;
6309     gchar *str = NULL;
6310
6311     saved_offset = asn1->offset;
6312
6313     asn1_int32_value_decode(asn1, 1, &value);
6314
6315     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
6316     proto_tree_add_text(tree, asn1->tvb,
6317         saved_offset, asn1->offset - saved_offset,
6318         "%s :  Reserved",
6319         bigbuf);
6320
6321     switch (value & 0x08)
6322     {
6323     case 0x00: str = "No effect"; break;
6324     default:
6325         str = "Force indirect";
6326         break;
6327     }
6328
6329     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
6330     proto_tree_add_text(tree, asn1->tvb,
6331         saved_offset, asn1->offset - saved_offset,
6332         "%s :  Force Message Center, %s",
6333         bigbuf, str);
6334
6335     switch (value & 0x04)
6336     {
6337     case 0x00: str = "Block direct"; break;
6338     default:
6339         str = "Allow direct";
6340         break;
6341     }
6342
6343     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
6344     proto_tree_add_text(tree, asn1->tvb,
6345         saved_offset, asn1->offset - saved_offset,
6346         "%s :  DIRECT, %s",
6347         bigbuf, str);
6348
6349     switch (value & 0x03)
6350     {
6351     case 0x00: str = "Block all"; break;
6352     case 0x02: str = "Allow specific"; break;
6353     case 0x03: str = "Allow all"; break;
6354     default:
6355         str = "Reserved";
6356         break;
6357     }
6358
6359     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
6360     proto_tree_add_text(tree, asn1->tvb,
6361         saved_offset, asn1->offset - saved_offset,
6362         "%s :  DEFAULT, %s",
6363         bigbuf, str);
6364
6365     EXTRANEOUS_DATA_CHECK(len, 1);
6366 }
6367
6368 static void
6369 param_seizure(ASN1_SCK *asn1, proto_tree *tree, guint len)
6370 {
6371     gint32 value;
6372     guint saved_offset;
6373     gchar *str = NULL;
6374
6375     saved_offset = asn1->offset;
6376
6377     asn1_int32_value_decode(asn1, 1, &value);
6378
6379     switch (value)
6380     {
6381     case 0: str = "Unspecified"; break;
6382     case 1: str = "Loopback"; break;
6383     default:
6384         if ((value >= 2) && (value <= 223)) { str = "Reserved"; }
6385         else { str = "Reserved for protocol extension"; }
6386         break;
6387     }
6388
6389     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6390         saved_offset, asn1->offset - saved_offset,
6391         str);
6392
6393     EXTRANEOUS_DATA_CHECK(len, 1);
6394 }
6395
6396 static void
6397 param_sms_tele(ASN1_SCK *asn1, proto_tree *tree, guint len)
6398 {
6399     gint32 value;
6400     guint saved_offset;
6401     gchar *str = NULL;
6402
6403     ansi_map_sms_tele_id = -1;
6404
6405     SHORT_DATA_CHECK(len, 2);
6406
6407     saved_offset = asn1->offset;
6408
6409     asn1_int32_value_decode(asn1, 2, &value);
6410
6411     str = match_strval(value, ansi_tele_strings);
6412     if (str == NULL)
6413     {
6414         switch (value)
6415         {
6416         case 0: str = "Not used"; break;
6417         default:
6418             if ((value >= 2) && (value <= 4095)) { str = "Reserved for assignment by TIA/EIA-41"; }
6419             else if ((value >= 4100) && (value <= 32512)) { str = "Reserved for assignment by TIA/EIA-41"; }
6420             else if ((value >= 32514) && (value <= 32639)) { str = "Reserved for assignment by this Standard for TDMA MS-based SMEs."; }
6421             else if ((value >= 32640) && (value <= 32767)) { str = "Reserved for carrier specific teleservices for TDMA MS-based SMEs."; }
6422             else if ((value >= 32768) && (value <= 49151)) { str = "Reserved for node specific teleservices."; }
6423             else if ((value >= 49152) && (value <= 65535)) { str = "Reserved for carrier specific teleservices."; }
6424             else { str = "Unknown teleservice ID"; }
6425             break;
6426         }
6427     }
6428
6429     ansi_map_sms_tele_id = value;
6430
6431     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6432         saved_offset, asn1->offset - saved_offset,
6433         "%s (%d)",
6434         str,
6435         value);
6436
6437     EXTRANEOUS_DATA_CHECK(len, 2);
6438 }
6439
6440 static void
6441 param_sms_term_restric(ASN1_SCK *asn1, proto_tree *tree, guint len)
6442 {
6443     gint32 value;
6444     guint saved_offset;
6445     gchar *str = NULL;
6446
6447     saved_offset = asn1->offset;
6448
6449     asn1_int32_value_decode(asn1, 1, &value);
6450
6451     my_decode_bitfield_value(bigbuf, value, 0xf8, 8);
6452     proto_tree_add_text(tree, asn1->tvb,
6453         saved_offset, asn1->offset - saved_offset,
6454         "%s :  Reserved",
6455         bigbuf);
6456
6457     switch (value & 0x04)
6458     {
6459     case 0x00: str = "Block messages charged to destination"; break;
6460     default:
6461         str = "Allow messages charged to destination";
6462         break;
6463     }
6464
6465     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
6466     proto_tree_add_text(tree, asn1->tvb,
6467         saved_offset, asn1->offset - saved_offset,
6468         "%s :  Reverse Charges, %s",
6469         bigbuf, str);
6470
6471     switch (value & 0x03)
6472     {
6473     case 0x00: str = "Block all"; break;
6474     case 0x02: str = "Allow specific"; break;
6475     case 0x03: str = "Allow all"; break;
6476     default:
6477         str = "Reserved";
6478         break;
6479     }
6480
6481     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
6482     proto_tree_add_text(tree, asn1->tvb,
6483         saved_offset, asn1->offset - saved_offset,
6484         "%s :  DEFAULT, %s",
6485         bigbuf, str);
6486
6487     EXTRANEOUS_DATA_CHECK(len, 1);
6488 }
6489
6490 static void
6491 param_sms_msg_count(ASN1_SCK *asn1, proto_tree *tree, guint len)
6492 {
6493     gint32 value;
6494     guint saved_offset;
6495     gchar *str = NULL;
6496
6497     saved_offset = asn1->offset;
6498
6499     asn1_int32_value_decode(asn1, 1, &value);
6500
6501     switch (value)
6502     {
6503     case 0: str = "No more pending SMS messages"; break;
6504     default:
6505         sprintf(bigbuf, "%d pending SMS messages", value);
6506         str = bigbuf;
6507         break;
6508     }
6509
6510     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6511         saved_offset, asn1->offset - saved_offset,
6512         str);
6513
6514     EXTRANEOUS_DATA_CHECK(len, 1);
6515 }
6516
6517 static void
6518 param_qos_pri(ASN1_SCK *asn1, proto_tree *tree, guint len)
6519 {
6520     gint32 value, temp_int;
6521     guint saved_offset;
6522     gchar *str = NULL;
6523
6524     saved_offset = asn1->offset;
6525
6526     asn1_int32_value_decode(asn1, 1, &value);
6527
6528     temp_int = (value & 0xf0) >> 4;
6529     if ((temp_int < 0) || (temp_int >= (gint) NUM_QOS_PRI_STR))
6530     {
6531         str = "Reserved";
6532     }
6533     else
6534     {
6535         str = qos_pri_str[temp_int];
6536     }
6537
6538     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
6539     proto_tree_add_text(tree, asn1->tvb,
6540         saved_offset, asn1->offset - saved_offset,
6541         "%s :  Assured Priority, %s",
6542         bigbuf,
6543         str);
6544
6545     temp_int = value & 0x0f;
6546     if ((temp_int < 0) || (temp_int >= (gint) NUM_QOS_PRI_STR))
6547     {
6548         str = "Reserved";
6549     }
6550     else
6551     {
6552         str = qos_pri_str[temp_int];
6553     }
6554
6555     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
6556     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6557         saved_offset, asn1->offset - saved_offset,
6558         "%s :  Non-Assured Priority, %s",
6559         bigbuf,
6560         str);
6561
6562     EXTRANEOUS_DATA_CHECK(len, 1);
6563 }
6564
6565 static void
6566 param_calling_party_cat(ASN1_SCK *asn1, proto_tree *tree, guint len)
6567 {
6568     gint32 value;
6569     guint saved_offset;
6570
6571     EXACT_DATA_CHECK(len, 1);
6572
6573     saved_offset = asn1->offset;
6574
6575     asn1_int32_value_decode(asn1, 1, &value);
6576
6577     proto_tree_add_text(tree, asn1->tvb,
6578         saved_offset, asn1->offset - saved_offset,
6579         "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");
6580 }
6581
6582 static void
6583 param_cdma2000_ho_ivk_ios(ASN1_SCK *asn1, proto_tree *tree, guint len)
6584 {
6585
6586     proto_tree_add_text(tree, asn1->tvb,
6587         asn1->offset, len,
6588         "IOS A1 Element Handoff Invoke Information");
6589
6590     asn1->offset += len;
6591 }
6592
6593 static void
6594 param_cdma2000_ho_rsp_ios(ASN1_SCK *asn1, proto_tree *tree, guint len)
6595 {
6596
6597     proto_tree_add_text(tree, asn1->tvb,
6598         asn1->offset, len,
6599         "IOS A1 Element Handoff Response Information");
6600
6601     asn1->offset += len;
6602 }
6603
6604 static void
6605 param_msid_usage(ASN1_SCK *asn1, proto_tree *tree, guint len)
6606 {
6607     gint32 value;
6608     guint saved_offset;
6609     gchar *str = NULL;
6610
6611     saved_offset = asn1->offset;
6612
6613     asn1_int32_value_decode(asn1, 1, &value);
6614
6615     my_decode_bitfield_value(bigbuf, value, 0xfc, 8);
6616     proto_tree_add_text(tree, asn1->tvb,
6617         saved_offset, asn1->offset - saved_offset,
6618         "%s :  Reserved",
6619         bigbuf);
6620
6621     switch (value & 0x03)
6622     {
6623     case 0: str = "Not used"; break;
6624     case 1: str = "MIN last used"; break;
6625     case 2: str = "IMSI last used"; break;
6626     case 3: str = "Reserved"; break;
6627     }
6628
6629     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
6630     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6631         saved_offset, asn1->offset - saved_offset,
6632         "%s :  %s",
6633         bigbuf,
6634         str);
6635
6636     EXTRANEOUS_DATA_CHECK(len, 1);
6637 }
6638
6639 static void
6640 param_new_min_ext(ASN1_SCK *asn1, proto_tree *tree, guint len)
6641 {
6642     gint32 value;
6643     guint saved_offset;
6644     gchar *str = NULL;
6645
6646     EXACT_DATA_CHECK(len, 3);
6647
6648     saved_offset = asn1->offset;
6649
6650     asn1_int32_value_decode(asn1, 1, &value);
6651
6652     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
6653     proto_tree_add_text(tree, asn1->tvb,
6654         saved_offset, asn1->offset - saved_offset,
6655         "%s :  MCC_M (MSB), see CDMA",
6656         bigbuf);
6657
6658     my_decode_bitfield_value(bigbuf, value, 0x0e, 8);
6659     proto_tree_add_text(tree, asn1->tvb,
6660         saved_offset, asn1->offset - saved_offset,
6661         "%s :  IMSI_M_ADDR_NUM, see CDMA",
6662         bigbuf);
6663
6664     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
6665     proto_tree_add_text(tree, asn1->tvb,
6666         saved_offset, asn1->offset - saved_offset,
6667         "%s :  IMSI_M_CLASS, see CDMA",
6668         bigbuf);
6669
6670     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
6671     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6672         saved_offset, asn1->offset - saved_offset,
6673         "%s :  %s",
6674         bigbuf,
6675         str);
6676
6677     bigbuf[0] = Dgt_tbcd.out[(value & 0xf0) >> 4];
6678
6679     saved_offset = asn1->offset;
6680
6681     asn1_int32_value_decode(asn1, 1, &value);
6682
6683     bigbuf[1] = Dgt_tbcd.out[value & 0x0f];
6684     bigbuf[2] = Dgt_tbcd.out[(value & 0xf0) >> 4];
6685     bigbuf[3] = '\0';
6686
6687     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6688         saved_offset, asn1->offset - saved_offset,
6689         "MCC_M, %s, see CDMA",
6690         bigbuf);
6691
6692     saved_offset = asn1->offset;
6693
6694     asn1_int32_value_decode(asn1, 1, &value);
6695
6696     bigbuf[0] = Dgt_tbcd.out[value & 0x0f];
6697     bigbuf[1] = Dgt_tbcd.out[(value & 0xf0) >> 4];
6698     bigbuf[2] = '\0';
6699
6700     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6701         saved_offset, asn1->offset - saved_offset,
6702         "IMSI_11_12, %s, see CDMA",
6703         bigbuf);
6704 }
6705
6706 static void
6707 param_dtx_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
6708 {
6709     gint32 value;
6710     guint saved_offset;
6711     gchar *str = NULL;
6712
6713     saved_offset = asn1->offset;
6714
6715     asn1_int32_value_decode(asn1, 1, &value);
6716
6717     my_decode_bitfield_value(bigbuf, value, 0xfe, 8);
6718     proto_tree_add_text(tree, asn1->tvb,
6719         saved_offset, asn1->offset - saved_offset,
6720         "%s :  Reserved",
6721         bigbuf);
6722
6723     switch (value & 0x01)
6724     {
6725     case 0: str = "Discontinuous Transmission mode is not active"; break;
6726     case 1: str = "Discontinuous Transmission mode is active"; break;
6727     }
6728
6729     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
6730     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6731         saved_offset, asn1->offset - saved_offset,
6732         "%s :  %s",
6733         bigbuf,
6734         str);
6735
6736     EXTRANEOUS_DATA_CHECK(len, 1);
6737 }
6738
6739 static void
6740 param_cdma_mob_cap(ASN1_SCK *asn1, proto_tree *tree, guint len)
6741 {
6742     gint32 value;
6743     guint saved_offset;
6744     gchar *str = NULL;
6745
6746     saved_offset = asn1->offset;
6747
6748     asn1_int32_value_decode(asn1, 1, &value);
6749
6750     my_decode_bitfield_value(bigbuf, value, 0xfe, 8);
6751     proto_tree_add_text(tree, asn1->tvb,
6752         saved_offset, asn1->offset - saved_offset,
6753         "%s :  Reserved",
6754         bigbuf);
6755
6756     switch (value & 0x01)
6757     {
6758     case 0: str = "No MS-initiated position determination"; break;
6759     case 1: str = "MS-initiated position determination"; break;
6760     }
6761
6762     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
6763     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6764         saved_offset, asn1->offset - saved_offset,
6765         "%s :  %s",
6766         bigbuf,
6767         str);
6768
6769     EXTRANEOUS_DATA_CHECK(len, 1);
6770 }
6771
6772 static void
6773 param_gen_time(ASN1_SCK *asn1, proto_tree *tree, guint len)
6774 {
6775     gint32 value;
6776     gint32 h, m, s, ts;
6777     guint saved_offset;
6778
6779     SHORT_DATA_CHECK(len, 6);
6780
6781     saved_offset = asn1->offset;
6782
6783     asn1_int32_value_decode(asn1, 1, &value);
6784
6785     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6786         saved_offset, asn1->offset - saved_offset,
6787         "Year-2000, %d",
6788         value);
6789
6790     saved_offset = asn1->offset;
6791
6792     asn1_int32_value_decode(asn1, 1, &value);
6793
6794     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6795         saved_offset, asn1->offset - saved_offset,
6796         "Month, %d",
6797         value);
6798
6799     saved_offset = asn1->offset;
6800
6801     asn1_int32_value_decode(asn1, 1, &value);
6802
6803     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6804         saved_offset, asn1->offset - saved_offset,
6805         "Day of month, %d",
6806         value);
6807
6808     saved_offset = asn1->offset;
6809
6810     asn1_int32_value_decode(asn1, 3, &value);
6811
6812     h = value / (3600 * 10);
6813     m = (value - (h * (3600 * 10))) / (60 * 10);
6814     s = (value - (h * (3600 * 10)) - (m * (60 * 10))) / 10;
6815     ts = (value - (h * (3600 * 10)) - (m * (60 * 10)) - (s * 10));
6816
6817     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6818         saved_offset, asn1->offset - saved_offset,
6819         "Time of day (UTC) (in tenths of seconds - 1), %d (%d:%d:%d.%d)",
6820         value,
6821         h,
6822         m,
6823         s,
6824         ts);
6825
6826     EXTRANEOUS_DATA_CHECK(len, 6);
6827 }
6828
6829 static void
6830 param_geo_pos(ASN1_SCK *asn1, proto_tree *tree, guint len)
6831 {
6832     guint saved_offset;
6833
6834     saved_offset = asn1->offset;
6835
6836     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6837         saved_offset, len,
6838         "Calling Geodetic Location (CGL), see T1.628 CallingGeodeticLocation TCAP parameter for encoding");
6839 }
6840
6841 static void
6842 param_mob_call_status(ASN1_SCK *asn1, proto_tree *tree, guint len)
6843 {
6844     gint32 value, auth;
6845     guint saved_offset;
6846     gchar *str = NULL;
6847
6848     saved_offset = asn1->offset;
6849
6850     asn1_int32_value_decode(asn1, 1, &value);
6851
6852     auth = (value & 0xf0) >> 4;
6853     switch (auth)
6854     {
6855     case 0: str = "Authorization not performed"; break;
6856     case 1: str = "Authorization successful"; break;
6857     case 2: str = "Invalid Electronic Serial Number (ESN)"; break;
6858     case 3: str = "Unassigned Directory Number (DN)"; break;
6859     case 4: str = "Duplicate Unit"; break;
6860     case 5: str = "Delinquent Account"; break;
6861     case 6: str = "Stolen Unit"; break;
6862     case 7: str = "Not authorized for MSC"; break;
6863     case 8: str = "Unspecified"; break;
6864     default:
6865         str = "Reserved, treat as Authorization not performed";
6866         break;
6867     }
6868
6869     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
6870     proto_tree_add_text(tree, asn1->tvb,
6871         saved_offset, asn1->offset - saved_offset,
6872         "%s :  Authorization, %s",
6873         bigbuf,
6874         str);
6875
6876     auth = value & 0x0f;
6877     switch (auth)
6878     {
6879     case 0: str = "Authentication not performed. Authentication has not yet occurred or the MS is not capable of authentication"; break;
6880     case 1: str = "Authentication successful. Authentication has successfully occurred on the MS"; break;
6881     case 2: str = "Authentication failure. An authentication failure has occurred on the MS"; break;
6882     default:
6883         str = "Reserved, treat as Authentication not performed";
6884         break;
6885     }
6886
6887     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
6888     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
6889         saved_offset, asn1->offset - saved_offset,
6890         "%s :  Authentication, %s",
6891         bigbuf,
6892         str);
6893
6894     EXTRANEOUS_DATA_CHECK(len, 1);
6895 }
6896
6897 static void
6898 param_pos_req_type(ASN1_SCK *asn1, proto_tree *tree, guint len)
6899 {
6900     gint32 value;
6901     guint saved_offset;
6902     gchar *str = NULL;
6903
6904     saved_offset = asn1->offset;
6905
6906     asn1_int32_value_decode(asn1, 1, &value);
6907
6908     switch (value)
6909     {
6910     case 0: str = "Not used"; break;
6911     case 1: str = "Initial position. Return updated position only if initial position is unavailable."; break;
6912     case 2: str = "Return the updated position"; break;
6913     case 3: str = "Return the updated or last known position"; break;
6914     case 4: str = "Reserved for LSP interface. Treat as Not used"; break;
6915     default:
6916         if ((value >= 5) && (value <= 95)) { str = "Reserved, treat as Initial position"; }
6917         else { str = "Reserved for protocol extension, treat as Initial position"; }
6918         break;
6919     }
6920
6921     proto_tree_add_text(tree, asn1->tvb,
6922         saved_offset, asn1->offset - saved_offset,
6923         "Position Request Type, %s",
6924         str);
6925
6926     EXTRANEOUS_DATA_CHECK(len, 1);
6927 }
6928
6929 static void
6930 param_pos_result(ASN1_SCK *asn1, proto_tree *tree, guint len)
6931 {
6932     gint32 value;
6933     guint saved_offset;
6934     gchar *str = NULL;
6935
6936     saved_offset = asn1->offset;
6937
6938     asn1_int32_value_decode(asn1, 1, &value);
6939
6940     switch (value)
6941     {
6942     case 0: str = "Not used"; break;
6943     case 1: str = "Initial position returned"; break;
6944     case 2: str = "Updated position returned"; break;
6945     case 3: str = "Last known position returned"; break;
6946     case 4: str = "Requested position is not available"; break;
6947     case 5: str = "Caller disconnected. No call in progress for caller identified"; break;
6948     case 6: str = "Caller has handed-off. Position is unavailable due to a hand-off (e.g. handoff to a position incapable system)"; break;
6949     case 7: str = "Identified MS is inactive or has roamed to another system"; break;
6950     case 8: str = "Unresponsive"; break;
6951     case 9: str = "Identified MS is responsive, but refused position request"; break;
6952     case 10: str = "System Failure"; break;
6953     case 11: str = "MSID is not known"; break;
6954     case 12: str = "Callback number is not known"; break;
6955     case 13: str = "Improper request (e.g. invalid channel information, invalid ESN)"; break;
6956     case 14: str = "Mobile channel information returned"; break;
6957     case 15: str = "Signal not detected"; break;
6958     case 16: str = "PDE Timeout"; break;
6959     case 17: str = "Position pending"; break;
6960     case 18: str = "TDMA MAHO Information Returned"; break;
6961     case 19: str = "TDMA MAHO Information is not available"; break;
6962     default:
6963         if ((value >= 20) && (value <= 223)) { str = "Reserved, treat as Not used"; }
6964         else { str = "Reserved for protocol extension, treat as Not used"; }
6965         break;
6966     }
6967
6968     proto_tree_add_text(tree, asn1->tvb,
6969         saved_offset, asn1->offset - saved_offset,
6970         "Position Result, %s",
6971         str);
6972
6973     EXTRANEOUS_DATA_CHECK(len, 1);
6974 }
6975
6976 static void
6977 param_pos_source(ASN1_SCK *asn1, proto_tree *tree, guint len)
6978 {
6979     gint32 value;
6980     guint saved_offset;
6981     gchar *str = NULL;
6982
6983     saved_offset = asn1->offset;
6984
6985     asn1_int32_value_decode(asn1, 1, &value);
6986
6987     switch (value)
6988     {
6989     case 0: str = "Not used"; break;
6990     case 1: str = "Network Unspecified"; break;
6991     case 2: str = "Network AOA (Angle of Arrival)"; break;
6992     case 3: str = "Network TOA (Time of Arrival)"; break;
6993     case 4: str = "Network TDOA (Time Difference of Arrival)"; break;
6994     case 5: str = "Network RF Fingerprinting"; break;
6995     case 6: str = "Network Cell/Sector"; break;
6996     case 7: str = "Network Cell/Sector with Timing"; break;
6997     case 16: str = "Handset Unspecified"; break;
6998     case 17: str = "Handset GPS"; break;
6999     case 18: str = "Handset AGPS (Assisted GPS)"; break;
7000     case 19: str = "Handset EOTD (Enhanced Observed Time Difference)"; break;
7001     case 20: str = "Handset AFLT (Advanced Forward Link Trilateration)"; break;
7002     case 21: str = "Handset EFLT (Enhanced Forward Link Trilateration)"; break;
7003     default:
7004         if ((value >= 8) && (value <= 15)) { str = "Reserved, treat as Network Unspecified"; }
7005         else if ((value >= 22) && (value <= 31)) { str = "Reserved, treat as Handset Unspecified"; }
7006         else { str = "Reserved for protocol extension, treat as Not used"; }
7007         break;
7008     }
7009
7010     proto_tree_add_text(tree, asn1->tvb,
7011         saved_offset, asn1->offset - saved_offset,
7012         "Position Source, %s",
7013         str);
7014
7015     EXTRANEOUS_DATA_CHECK(len, 1);
7016 }
7017
7018 static void
7019 param_acg_encounter(ASN1_SCK *asn1, proto_tree *tree, guint len)
7020 {
7021     gint32 value;
7022     guint saved_offset;
7023     gchar *str = NULL;
7024
7025     EXACT_DATA_CHECK(len, 1);
7026
7027     saved_offset = asn1->offset;
7028
7029     asn1_int32_value_decode(asn1, 1, &value);
7030
7031     switch ((value & 0xc0) >> 6)
7032     {
7033     case 0: str = "Not used"; break;
7034     case 1: str = "Service Management System Initiated control encountered"; break;
7035     case 2: str = "SCF Overload control encountered"; break;
7036     case 3: str = "Reserved, treat as Not used"; break;
7037     }
7038
7039     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
7040     proto_tree_add_text(tree, asn1->tvb,
7041         saved_offset, asn1->offset - saved_offset,
7042         "%s :  Control Type, %s",
7043         bigbuf,
7044         str);
7045
7046     switch (value & 0x3f)
7047     {
7048     case 0: str = "PC_SSN"; break;
7049     case 1: str = "1-digit control"; break;
7050     case 2: str = "2-digit control"; break;
7051     case 3: str = "3-digit control"; break;
7052     case 4: str = "4-digit control"; break;
7053     case 5: str = "5-digit control"; break;
7054     case 6: str = "6-digit control"; break;
7055     case 7: str = "7-digit control"; break;
7056     case 8: str = "8-digit control"; break;
7057     case 9: str = "9-digit control"; break;
7058     case 10: str = "10-digit control"; break;
7059     case 11: str = "11-digit control"; break;
7060     case 12: str = "12-digit control"; break;
7061     case 13: str = "13-digit control"; break;
7062     case 14: str = "14-digit control"; break;
7063     case 15: str = "15-digit control"; break;
7064     default:
7065         str = "Reserved, treat as 15-digit control";
7066         break;
7067     }
7068
7069     my_decode_bitfield_value(bigbuf, value, 0x3f, 8);
7070     proto_tree_add_text(tree, asn1->tvb,
7071         saved_offset, asn1->offset - saved_offset,
7072         "%s :  %s",
7073         bigbuf,
7074         str);
7075 }
7076
7077 static void
7078 param_ctrl_type(ASN1_SCK *asn1, proto_tree *tree, guint len)
7079 {
7080     gint32 value;
7081     guint saved_offset;
7082     gchar *str = NULL;
7083
7084     EXACT_DATA_CHECK(len, 1);
7085
7086     saved_offset = asn1->offset;
7087
7088     asn1_int32_value_decode(asn1, 1, &value);
7089
7090     switch ((value & 0xc0) >> 6)
7091     {
7092     case 0: str = "Not used"; break;
7093     case 1: str = "Service Management System Initiated control"; break;
7094     case 2: str = "SCF Overload control"; break;
7095     case 3: str = "Reserved, treat as Not used"; break;
7096     }
7097
7098     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
7099     proto_tree_add_text(tree, asn1->tvb,
7100         saved_offset, asn1->offset - saved_offset,
7101         "%s :  Control Type, %s",
7102         bigbuf,
7103         str);
7104
7105     switch (value & 0x3f)
7106     {
7107     case 0: str = "PC_SSN"; break;
7108     case 1: str = "1-digit control"; break;
7109     case 2: str = "2-digit control"; break;
7110     case 3: str = "3-digit control"; break;
7111     case 4: str = "4-digit control"; break;
7112     case 5: str = "5-digit control"; break;
7113     case 6: str = "6-digit control"; break;
7114     case 7: str = "7-digit control"; break;
7115     case 8: str = "8-digit control"; break;
7116     case 9: str = "9-digit control"; break;
7117     case 10: str = "10-digit control"; break;
7118     case 11: str = "11-digit control"; break;
7119     case 12: str = "12-digit control"; break;
7120     case 13: str = "13-digit control"; break;
7121     case 14: str = "14-digit control"; break;
7122     case 15: str = "15-digit control"; break;
7123     default:
7124         str = "Reserved, treat as 15-digit control";
7125         break;
7126     }
7127
7128     my_decode_bitfield_value(bigbuf, value, 0x3f, 8);
7129     proto_tree_add_text(tree, asn1->tvb,
7130         saved_offset, asn1->offset - saved_offset,
7131         "%s :  %s",
7132         bigbuf,
7133         str);
7134 }
7135
7136 static void
7137 param_gap_duration(ASN1_SCK *asn1, proto_tree *tree, guint len)
7138 {
7139     gint32 value;
7140     guint saved_offset;
7141     gchar *str = NULL;
7142
7143     EXACT_DATA_CHECK(len, 1);
7144
7145     saved_offset = asn1->offset;
7146
7147     asn1_int32_value_decode(asn1, 1, &value);
7148
7149     switch (value)
7150     {
7151     case 0: str = "Not used"; break;
7152     case 1: str = "1 second"; break;
7153     case 2: str = "2 seconds"; break;
7154     case 3: str = "4 seconds"; break;
7155     case 4: str = "8 seconds"; break;
7156     case 5: str = "16 seconds"; break;
7157     case 6: str = "32 seconds"; break;
7158     case 7: str = "64 seconds"; break;
7159     case 8: str = "128 seconds"; break;
7160     case 9: str = "256 seconds"; break;
7161     case 10: str = "512 seconds"; break;
7162     case 11: str = "1024 seconds"; break;
7163     case 12: str = "2048 seconds"; break;
7164     case 13: str = "Infinity"; break;
7165     default:
7166         str = "Reserved, treat as Not used";
7167         break;
7168     }
7169
7170     proto_tree_add_text(tree, asn1->tvb,
7171         saved_offset, asn1->offset - saved_offset,
7172         str);
7173 }
7174
7175 static void
7176 param_scf_overload_gap_int(ASN1_SCK *asn1, proto_tree *tree, guint len)
7177 {
7178     gint32 value;
7179     guint saved_offset;
7180     gchar *str = NULL;
7181
7182     EXACT_DATA_CHECK(len, 1);
7183
7184     saved_offset = asn1->offset;
7185
7186     asn1_int32_value_decode(asn1, 1, &value);
7187
7188     switch (value)
7189     {
7190     case 0: str = "0 seconds"; break;
7191     case 1: str = "3 seconds"; break;
7192     case 2: str = "4 seconds"; break;
7193     case 3: str = "6 seconds"; break;
7194     case 4: str = "8 seconds"; break;
7195     case 5: str = "11 seconds"; break;
7196     case 6: str = "16 seconds"; break;
7197     case 7: str = "22 seconds"; break;
7198     case 8: str = "30 seconds"; break;
7199     case 9: str = "42 seconds"; break;
7200     case 10: str = "58 seconds"; break;
7201     case 11: str = "81 seconds"; break;
7202     case 12: str = "112 seconds"; break;
7203     case 13: str = "156 seconds"; break;
7204     case 14: str = "217 seconds"; break;
7205     case 15: str = "300 seconds"; break;
7206     case 16: str = "Remove gap control"; break;
7207     case 17: str = "0.10 seconds"; break;
7208     case 18: str = "0.25 seconds"; break;
7209     case 19: str = "0.5 seconds"; break;
7210     case 20: str = "1 second"; break;
7211     case 21: str = "2 seconds"; break;
7212     default:
7213         str = "Reserved, treat as 0 seconds";
7214         break;
7215     }
7216
7217     proto_tree_add_text(tree, asn1->tvb,
7218         saved_offset, asn1->offset - saved_offset,
7219         str);
7220 }
7221
7222 static void
7223 param_tdma_time_align(ASN1_SCK *asn1, proto_tree *tree, guint len)
7224 {
7225     gint32 value;
7226     guint saved_offset;
7227
7228     saved_offset = asn1->offset;
7229
7230     asn1_int32_value_decode(asn1, 1, &value);
7231
7232     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
7233     proto_tree_add_text(tree, asn1->tvb,
7234         saved_offset, asn1->offset - saved_offset,
7235         "%s :  Reserved",
7236         bigbuf);
7237
7238
7239     my_decode_bitfield_value(bigbuf, value, 0x1f, 8);
7240     proto_tree_add_text(tree, asn1->tvb,
7241         saved_offset, asn1->offset - saved_offset,
7242         "%s :  Time Alignment Offset (TA), %d",
7243         bigbuf,
7244         value & 0x1f);
7245
7246     EXTRANEOUS_DATA_CHECK(len, 1);
7247 }
7248
7249 static void
7250 dump_rssi(ASN1_SCK *asn1, proto_tree *tree, gchar *leader)
7251 {
7252     gint32 value;
7253     guint saved_offset;
7254     gchar *str = NULL;
7255
7256     saved_offset = asn1->offset;
7257
7258     asn1_int32_value_decode(asn1, 1, &value);
7259
7260     switch ((value & 0xc0) >> 6)
7261     {
7262     case 0: str = "800 MHz"; break;
7263     case 1: str = "1900 MHz"; break;
7264     default:
7265         str = "Reserved";
7266         break;
7267     }
7268
7269     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
7270     proto_tree_add_text(tree, asn1->tvb,
7271         saved_offset, asn1->offset - saved_offset,
7272         "%s :  %sHyper, %s",
7273         bigbuf,
7274         leader,
7275         str);
7276
7277     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
7278     proto_tree_add_text(tree, asn1->tvb,
7279         saved_offset, asn1->offset - saved_offset,
7280         "%s :  Reserved",
7281         bigbuf);
7282
7283     my_decode_bitfield_value(bigbuf, value, 0x1f, 8);
7284     proto_tree_add_text(tree, asn1->tvb,
7285         saved_offset, asn1->offset - saved_offset,
7286         "%s :  %sRSSI, %d",
7287         bigbuf,
7288         leader,
7289         value & 0x1f);
7290 }
7291
7292 static void
7293 param_tdma_maho_cell_id(ASN1_SCK *asn1, proto_tree *tree, guint len)
7294 {
7295     gint32 value, num_rssi, num_msc;
7296     guint saved_offset, orig_offset;
7297     gint32 i, j;
7298
7299     SHORT_DATA_CHECK(len, 3);
7300
7301     orig_offset = asn1->offset;
7302
7303     dump_rssi(asn1, tree, "Serving Cell ");
7304
7305     saved_offset = asn1->offset;
7306
7307     asn1_int32_value_decode(asn1, 1, &num_rssi);
7308
7309     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7310         saved_offset, asn1->offset - saved_offset,
7311         "Number of RSSI %d",
7312         num_rssi);
7313
7314     for (i = 0; i < num_rssi; i++)
7315     {
7316         if ((len - (asn1->offset - orig_offset)) < 3)
7317         {
7318             proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7319                 asn1->offset, len - (asn1->offset - orig_offset),
7320                 "Short Data (?)");
7321
7322             asn1->offset += len - (asn1->offset - orig_offset);
7323             return;
7324         }
7325
7326         dump_rssi(asn1, tree, "");
7327
7328         saved_offset = asn1->offset;
7329
7330         asn1_int32_value_decode(asn1, 2, &value);
7331
7332         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7333             saved_offset, asn1->offset - saved_offset,
7334             "Measured Cell ID %d",
7335             value);
7336     }
7337
7338     saved_offset = asn1->offset;
7339
7340     asn1_int32_value_decode(asn1, 1, &num_msc);
7341
7342     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7343         saved_offset, asn1->offset - saved_offset,
7344         "Number of MSC %d",
7345         num_msc);
7346
7347     for (i = 0; i < num_msc; i++)
7348     {
7349         if ((len - (asn1->offset - orig_offset)) < 4)
7350         {
7351             proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7352                 asn1->offset, len - (asn1->offset - orig_offset),
7353                 "Short Data (?)");
7354
7355             asn1->offset += len - (asn1->offset - orig_offset);
7356             return;
7357         }
7358
7359         param_mscid(asn1, tree, 3);
7360
7361         saved_offset = asn1->offset;
7362
7363         asn1_int32_value_decode(asn1, 1, &num_rssi);
7364
7365         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7366             saved_offset, asn1->offset - saved_offset,
7367             "Number of RSSI %d",
7368             num_rssi);
7369
7370         for (j = 0; j < num_rssi; j++)
7371         {
7372             if ((len - (asn1->offset - orig_offset)) < 3)
7373             {
7374                 proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7375                     asn1->offset, len - (asn1->offset - orig_offset),
7376                     "Short Data (?)");
7377
7378                 asn1->offset += len - (asn1->offset - orig_offset);
7379                 return;
7380             }
7381
7382             dump_rssi(asn1, tree, "");
7383
7384             saved_offset = asn1->offset;
7385
7386             asn1_int32_value_decode(asn1, 2, &value);
7387
7388             proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7389                 saved_offset, asn1->offset - saved_offset,
7390                 "Measured Cell ID %d",
7391                 value);
7392         }
7393     }
7394
7395     EXTRANEOUS_DATA_CHECK((len - (asn1->offset - orig_offset)), 0);
7396 }
7397
7398 static void
7399 param_tdma_maho_chan(ASN1_SCK *asn1, proto_tree *tree, guint len)
7400 {
7401     gint32 value, num_rssi, num_msc;
7402     guint saved_offset, orig_offset;
7403     gint32 i, j;
7404
7405     SHORT_DATA_CHECK(len, 3);
7406
7407     orig_offset = asn1->offset;
7408
7409     dump_rssi(asn1, tree, "Serving Cell ");
7410
7411     saved_offset = asn1->offset;
7412
7413     asn1_int32_value_decode(asn1, 1, &num_rssi);
7414
7415     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7416         saved_offset, asn1->offset - saved_offset,
7417         "Number of RSSI %d",
7418         num_rssi);
7419
7420     for (i = 0; i < num_rssi; i++)
7421     {
7422         if ((len - (asn1->offset - orig_offset)) < 3)
7423         {
7424             proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7425                 asn1->offset, len - (asn1->offset - orig_offset),
7426                 "Short Data (?)");
7427
7428             asn1->offset += len - (asn1->offset - orig_offset);
7429             return;
7430         }
7431
7432         dump_rssi(asn1, tree, "");
7433
7434         saved_offset = asn1->offset;
7435
7436         asn1_int32_value_decode(asn1, 2, &value);
7437
7438         my_decode_bitfield_value(bigbuf, value >> 8, 0xff, 8);
7439         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7440             saved_offset, 1,
7441             "%s :  Measured Channel (MSB), %d",
7442             bigbuf,
7443             (value & 0xffe0) >> 5);
7444
7445         my_decode_bitfield_value(bigbuf, value & 0xff, 0xe0, 8);
7446         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7447             saved_offset+1, 1,
7448             "%s :  Measured Channel (LSB)",
7449             bigbuf);
7450     }
7451
7452     saved_offset = asn1->offset;
7453
7454     asn1_int32_value_decode(asn1, 1, &num_msc);
7455
7456     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7457         saved_offset, asn1->offset - saved_offset,
7458         "Number of MSC %d",
7459         num_msc);
7460
7461     for (i = 0; i < num_msc; i++)
7462     {
7463         if ((len - (asn1->offset - orig_offset)) < 4)
7464         {
7465             proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7466                 asn1->offset, len - (asn1->offset - orig_offset),
7467                 "Short Data (?)");
7468
7469             asn1->offset += len - (asn1->offset - orig_offset);
7470             return;
7471         }
7472
7473         param_mscid(asn1, tree, 3);
7474
7475         saved_offset = asn1->offset;
7476
7477         asn1_int32_value_decode(asn1, 1, &num_rssi);
7478
7479         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7480             saved_offset, asn1->offset - saved_offset,
7481             "Number of RSSI %d",
7482             num_rssi);
7483
7484         for (j = 0; j < num_rssi; j++)
7485         {
7486             if ((len - (asn1->offset - orig_offset)) < 3)
7487             {
7488                 proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7489                     asn1->offset, len - (asn1->offset - orig_offset),
7490                     "Short Data (?)");
7491
7492                 asn1->offset += len - (asn1->offset - orig_offset);
7493                 return;
7494             }
7495
7496             dump_rssi(asn1, tree, "");
7497
7498             saved_offset = asn1->offset;
7499
7500             asn1_int32_value_decode(asn1, 2, &value);
7501
7502             my_decode_bitfield_value(bigbuf, value >> 8, 0xff, 8);
7503             proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7504                 saved_offset, 1,
7505                 "%s :  Measured Channel (MSB), %d",
7506                 bigbuf,
7507                 (value & 0xffe0) >> 5);
7508
7509             my_decode_bitfield_value(bigbuf, value & 0xff, 0xe0, 8);
7510             proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7511                 saved_offset+1, 1,
7512                 "%s :  Measured Channel (LSB)",
7513                 bigbuf);
7514         }
7515     }
7516
7517     EXTRANEOUS_DATA_CHECK((len - (asn1->offset - orig_offset)), 0);
7518 }
7519
7520 static void
7521 param_tdma_maho_req(ASN1_SCK *asn1, proto_tree *tree, guint len)
7522 {
7523     gint32 value;
7524     guint saved_offset;
7525     gchar *str = NULL;
7526
7527     EXACT_DATA_CHECK(len, 1);
7528
7529     saved_offset = asn1->offset;
7530
7531     asn1_int32_value_decode(asn1, 1, &value);
7532
7533     switch (value)
7534     {
7535     case 0: str = "No MAHO information requested"; break;
7536     case 1: str = "MAHO information requested"; break;
7537     default:
7538         str = "Reserved, treat as No MAHO information requested";
7539         break;
7540     }
7541
7542     proto_tree_add_text(tree, asn1->tvb,
7543         saved_offset, asn1->offset - saved_offset,
7544         str);
7545 }
7546
7547 static void
7548 param_sm_gap_int(ASN1_SCK *asn1, proto_tree *tree, guint len)
7549 {
7550     gint32 value;
7551     guint saved_offset;
7552     gchar *str = NULL;
7553
7554     EXACT_DATA_CHECK(len, 1);
7555
7556     saved_offset = asn1->offset;
7557
7558     asn1_int32_value_decode(asn1, 1, &value);
7559
7560     switch (value)
7561     {
7562     case 0: str = "Remove gap control"; break;
7563     case 1: str = "0 seconds"; break;
7564     case 2: str = "0.10 seconds"; break;
7565     case 3: str = "0.25 seconds"; break;
7566     case 4: str = "0.50 seconds"; break;
7567     case 5: str = "1 second"; break;
7568     case 6: str = "2 seconds"; break;
7569     case 7: str = "5 seconds"; break;
7570     case 8: str = "10 seconds"; break;
7571     case 9: str = "15 seconds"; break;
7572     case 10: str = "30 seconds"; break;
7573     case 11: str = "60 seconds"; break;
7574     case 12: str = "120 seconds"; break;
7575     case 13: str = "300 seconds"; break;
7576     case 14: str = "600 seconds"; break;
7577     case 15: str = "Stop all queries"; break;
7578     default:
7579         str = "Reserved, treat as Remove gap control";
7580         break;
7581     }
7582
7583     proto_tree_add_text(tree, asn1->tvb,
7584         saved_offset, asn1->offset - saved_offset,
7585         str);
7586 }
7587
7588 static void
7589 param_mob_cap(ASN1_SCK *asn1, proto_tree *tree, guint len)
7590 {
7591     gint32 value;
7592     guint saved_offset, i;
7593     gchar *str = NULL;
7594
7595     for (i=0; i < len; i++)
7596     {
7597         saved_offset = asn1->offset;
7598
7599         asn1_int32_value_decode(asn1, 1, &value);
7600
7601         switch (value)
7602         {
7603         case 0: str = "Undefined Mobile Position Capabilities"; break;
7604         case 1: str = "CDMA None"; break;
7605         case 2: str = "CDMA Pilot Phase + GPS - MS shall be capable of supporting A-FLT and GPS for position determination"; break;
7606         case 3: str = "CDMA Pilot Phase Only - MS shall be capable of supporting A-FLT only for position determination"; break;
7607         case 4: str = "CDMA GPS Only - MS shall be capable of supporting GPS only for position determination"; break;
7608         case 51: str = "TDMA None. See TIA/EIA-136-740"; break;
7609         case 52: str = "TDMA MS-Based with Network Assistance SAMPS Supported. See TIA/EIA-136-740"; break;
7610         case 53: str = "TDMA MS-Assisted SAMPS Supported. See TIA/EIA-136-740"; break;
7611         case 54: str = "TDMA SAMPS Time Measurement Capability Supported. See TIA/EIA-136-740"; break;
7612         case 55: str = "TDMA MS-Based Stand-alone SAMPS Supported. See TIA/EIA-136-740"; break;
7613         case 101: str = "AMPS None"; break;
7614         case 102: str = "AMPS MS-based - MS shall be capable of autonomously determining the position without assistance from the network"; break;
7615         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;
7616         default:
7617             if ((value >= 5) && (value <= 50)) { str = "Reserved for CDMA, treat as CDMA None"; }
7618             else if ((value >= 56) && (value <= 100)) { str = "Reserved for TDMA, treat as TDMA None"; }
7619             else if ((value >= 104) && (value <= 150)) { str = "Reserved for AMPS, treat as AMPS None"; }
7620             else if ((value >= 151) && (value <= 223)) { str = "Reserved, treat as Undefined"; }
7621             else { str = "Reserved for protocol extension, treat as Undefined"; }
7622             break;
7623         }
7624
7625         proto_tree_add_text(tree, asn1->tvb,
7626             saved_offset, asn1->offset - saved_offset,
7627             "Mobile Position Capability, %s",
7628             str);
7629     }
7630 }
7631
7632 static void
7633 param_cdma_psmm_count(ASN1_SCK *asn1, proto_tree *tree, guint len)
7634 {
7635     gint32 value;
7636     guint saved_offset;
7637
7638     EXACT_DATA_CHECK(len, 1);
7639
7640     saved_offset = asn1->offset;
7641
7642     asn1_int32_value_decode(asn1, 1, &value);
7643
7644     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7645         saved_offset, asn1->offset - saved_offset,
7646         "Number of CDMA Pilot Strength Measurements to return, %d",
7647         value);
7648 }
7649
7650 static void
7651 param_cdma_sowd2(ASN1_SCK *asn1, proto_tree *tree, guint len)
7652 {
7653     gint32 value;
7654     guint saved_offset;
7655     gchar *str = NULL;
7656
7657     SHORT_DATA_CHECK(len, 5);
7658
7659     saved_offset = asn1->offset;
7660
7661     asn1_int32_value_decode(asn1, 2, &value);
7662
7663     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7664         saved_offset, asn1->offset - saved_offset,
7665         "CDMA Serving One Way Delay, %d",
7666         value);
7667
7668     saved_offset = asn1->offset;
7669
7670     asn1_int32_value_decode(asn1, 1, &value);
7671
7672     my_decode_bitfield_value(bigbuf, value, 0xfc, 8);
7673     proto_tree_add_text(tree, asn1->tvb,
7674         saved_offset, asn1->offset - saved_offset,
7675         "%s :  Reserved",
7676         bigbuf);
7677
7678     switch (value & 0x03)
7679     {
7680     case 0: str = "100 nsec"; break;
7681     case 1: str = "50 nsec"; break;
7682     case 2: str = "1/16 CDMA PN Chip"; break;
7683     case 3: str = "Reserved"; break;
7684     }
7685
7686     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
7687     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7688         saved_offset, asn1->offset - saved_offset,
7689         "%s :  Resolution, %s",
7690         bigbuf,
7691         str);
7692
7693     saved_offset = asn1->offset;
7694
7695     asn1_int32_value_decode(asn1, 2, &value);
7696
7697     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7698         saved_offset, asn1->offset - saved_offset,
7699         "Serving One Way Delay TimeStamp, %d",
7700         value);
7701
7702     EXTRANEOUS_DATA_CHECK(len, 5);
7703 }
7704
7705 static void
7706 param_sms_charge_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
7707 {
7708     gint32 value;
7709     guint saved_offset;
7710     gchar *str = NULL;
7711
7712     saved_offset = asn1->offset;
7713
7714     asn1_int32_value_decode(asn1, 1, &value);
7715
7716     switch (value)
7717     {
7718     case 0: str = "Not used"; break;
7719     case 1: str = "No charge"; break;
7720     case 2: str = "Charge original originator"; break;
7721     case 3: str = "Charge original destination"; break;
7722     default:
7723         str = "Reserved";
7724         break;
7725     }
7726
7727     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7728         saved_offset, asn1->offset - saved_offset,
7729         "Charge %d, %s",
7730         value,
7731         str);
7732
7733     EXTRANEOUS_DATA_CHECK(len, 1);
7734 }
7735
7736 static void
7737 param_auth_per(ASN1_SCK *asn1, proto_tree *tree, guint len)
7738 {
7739     gint32 value;
7740     guint saved_offset;
7741     gchar *str = NULL;
7742
7743     EXACT_DATA_CHECK(len, 2);
7744
7745     saved_offset = asn1->offset;
7746
7747     asn1_int32_value_decode(asn1, 1, &value);
7748
7749     switch (value)
7750     {
7751     case 0: str = "Not used"; break;
7752     case 1: str = "Per call"; break;
7753     case 2: str = "Hours"; break;
7754     case 3: str = "Days"; break;
7755     case 4: str = "Weeks"; break;
7756     case 5: str = "Per agreement"; break;
7757     case 6: str = "Indefinite"; break;
7758     case 7: str = "Number of calls"; break;
7759     default:
7760         if ((value >= 8) && (value <= 223)) { str = "Reserved, treat as Per call"; }
7761         else { str = "Reserved for protocol extension, treat as Per call"; }
7762         break;
7763     }
7764
7765     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7766         saved_offset, asn1->offset - saved_offset,
7767         "Period (%d) %s",
7768         value,
7769         str);
7770
7771     saved_offset = asn1->offset;
7772
7773     asn1_int32_value_decode(asn1, 1, &value);
7774
7775     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7776         saved_offset, asn1->offset - saved_offset,
7777         "Value %d",
7778         value);
7779 }
7780
7781 static void
7782 param_ctrl_chan_mode(ASN1_SCK *asn1, proto_tree *tree, guint len)
7783 {
7784     gint32 value;
7785     guint saved_offset;
7786     gchar *str = NULL;
7787
7788     saved_offset = asn1->offset;
7789
7790     asn1_int32_value_decode(asn1, 1, &value);
7791
7792     switch (value)
7793     {
7794     case 0: str = "Unknown"; break;
7795     case 1: str = "MS is in Analog CC Mode"; break;
7796     case 2: str = "MS is in Digital CC Mode"; break;
7797     case 3: str = "MS is in NAMPS CC Mode"; break;
7798     default:
7799         if ((value >= 4) && (value <= 223)) { str = "Reserved, treat as Unknown"; }
7800         else { str = "Reserved for protocol extension, treat as Unknown"; }
7801         break;
7802     }
7803
7804     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7805         saved_offset, asn1->offset - saved_offset,
7806         str);
7807
7808     EXTRANEOUS_DATA_CHECK(len, 1);
7809 }
7810
7811 static void
7812 param_tdma_data_mode(ASN1_SCK *asn1, proto_tree *tree, guint len)
7813 {
7814     gint32 value;
7815     guint saved_offset;
7816     gchar *str = NULL;
7817
7818     SHORT_DATA_CHECK(len, 2);
7819
7820     saved_offset = asn1->offset;
7821
7822     asn1_int32_value_decode(asn1, 1, &value);
7823
7824     switch ((value & 0xe0) >> 5)
7825     {
7826     case 0: str = "As per IS-135"; break;
7827     case 1: str = "As per FSVS - 211 (STU-III)"; break;
7828     default:
7829         str = "Reserved";
7830         break;
7831     }
7832
7833     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
7834     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7835         saved_offset, asn1->offset - saved_offset,
7836         "%s :  Data Part, %s",
7837         bigbuf,
7838         str);
7839
7840     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
7841     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7842         saved_offset, asn1->offset - saved_offset,
7843         "%s :  AD, %s",
7844         bigbuf,
7845         (value & 0x10) ? "unacknowledged data only" : "unacked data or both");
7846
7847     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
7848     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7849         saved_offset, asn1->offset - saved_offset,
7850         "%s :  %s",
7851         bigbuf,
7852         (value & 0x08) ? "SAP 0 and 1" : "SAP 0 only");
7853
7854     switch (value & 0x07)
7855     {
7856     case 0: str = "No Data Privacy"; break;
7857     case 1: str = "Data Privacy Algorithm A"; break;
7858     default:
7859         str = "Reserved, treat as No Data Privacy";
7860         break;
7861     }
7862
7863     my_decode_bitfield_value(bigbuf, value, 0x07, 8);
7864     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7865         saved_offset, asn1->offset - saved_offset,
7866         "%s :  Data Privacy Mode, %s",
7867         bigbuf,
7868         str);
7869
7870     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
7871     proto_tree_add_text(tree, asn1->tvb,
7872         saved_offset, asn1->offset - saved_offset,
7873         "%s :  Reserved",
7874         bigbuf);
7875
7876     switch ((value & 0x0c) >> 2)
7877     {
7878     case 0: str = "RLP1"; break;
7879     case 1: str = "RLP2"; break;
7880     default:
7881         str = "Reserved";
7882         break;
7883     }
7884
7885     my_decode_bitfield_value(bigbuf, value, 0x0c, 8);
7886     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7887         saved_offset, asn1->offset - saved_offset,
7888         "%s :  %s",
7889         bigbuf,
7890         str);
7891
7892     switch (value & 0x03)
7893     {
7894     case 0: str = "16-bit Cyclic Redundancy Check"; break;
7895     case 1: str = "24-bit Cyclic Redundancy Check"; break;
7896     case 2: str = "No Cyclic Redundancy Check"; break;
7897     default:
7898         str = "Reserved";
7899         break;
7900     }
7901
7902     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
7903     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7904         saved_offset, asn1->offset - saved_offset,
7905         "%s :  %s",
7906         bigbuf,
7907         str);
7908
7909     EXTRANEOUS_DATA_CHECK(len, 2);
7910 }
7911
7912 static void
7913 param_tdma_voice_mode(ASN1_SCK *asn1, proto_tree *tree, guint len)
7914 {
7915     gint32 value;
7916     guint saved_offset;
7917     gchar *str = NULL;
7918
7919     saved_offset = asn1->offset;
7920
7921     asn1_int32_value_decode(asn1, 1, &value);
7922
7923     switch ((value & 0xf0) >> 4)
7924     {
7925     case 0: str = "No Voice Privacy"; break;
7926     case 1: str = "Voice Privacy Algorithm A"; break;
7927     case 2: str = "Reserved, treat as No Voice Privacy"; break;
7928     case 3: str = "Reserved, treat as No Voice Privacy"; break;
7929     case 4: str = "Reserved for SOC/BMSC Specific signaling"; break;
7930     default:
7931         str = "Reserved, treat as No Voice Privacy";
7932         break;
7933     }
7934
7935     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
7936     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7937         saved_offset, asn1->offset - saved_offset,
7938         "%s :  Voice Privacy Mode, %s",
7939         bigbuf,
7940         str);
7941
7942     switch (value & 0x0f)
7943     {
7944     case 0: str = "No Voice Coder"; break;
7945     case 1: str = "VSELP Voice Coder"; break;
7946     case 2: str = "IS-641 Voice Coder"; break;
7947     case 6: str = "Reserved for SOC/BMSC Specific signaling"; break;
7948     default:
7949         str = "Reserved, treat as No Voice Coder";
7950         break;
7951     }
7952
7953     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
7954     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7955         saved_offset, asn1->offset - saved_offset,
7956         "%s :  Voice Coder, %s",
7957         bigbuf,
7958         str);
7959
7960     EXTRANEOUS_DATA_CHECK(len, 1);
7961 }
7962
7963 static void
7964 param_tdma_bandwidth(ASN1_SCK *asn1, proto_tree *tree, guint len)
7965 {
7966     gint32 value;
7967     guint saved_offset;
7968     gchar *str = NULL;
7969
7970     saved_offset = asn1->offset;
7971
7972     asn1_int32_value_decode(asn1, 1, &value);
7973
7974     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
7975     proto_tree_add_text(tree, asn1->tvb,
7976         saved_offset, asn1->offset - saved_offset,
7977         "%s :  Reserved",
7978         bigbuf);
7979
7980     switch (value & 0x0f)
7981     {
7982     case 0: str = "Half-Rate Digital Traffic Channel Only"; break;
7983     case 1: str = "Full-Rate Digital Traffic Channel Only"; break;
7984     case 2: str = "Half-Rate or Full-rate Digital Traffic Channel - Full-Rate Preferred"; break;
7985     case 3: str = "Half-rate or Full-rate Digital Traffic Channel - Half-rate Preferred"; break;
7986     case 4: str = "Double Full-Rate Digital Traffic Channel Only"; break;
7987     case 5: str = "Triple Full-Rate Digital Traffic Channel Only"; break;
7988     default:
7989         str = "Reserved, treat as Full-Rate Digital Traffic Channel Only";
7990         break;
7991     }
7992
7993     my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
7994     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
7995         saved_offset, asn1->offset - saved_offset,
7996         "%s :  Bandwidth, %s",
7997         bigbuf,
7998         str);
7999
8000     EXTRANEOUS_DATA_CHECK(len, 1);
8001 }
8002
8003 static void
8004 param_change_srvc_attr(ASN1_SCK *asn1, proto_tree *tree, guint len)
8005 {
8006     gint32 value;
8007     guint saved_offset;
8008     gchar *str = NULL;
8009
8010     saved_offset = asn1->offset;
8011
8012     asn1_int32_value_decode(asn1, 1, &value);
8013
8014     my_decode_bitfield_value(bigbuf, value, 0xf0, 8);
8015     proto_tree_add_text(tree, asn1->tvb,
8016         saved_offset, asn1->offset - saved_offset,
8017         "%s :  Reserved",
8018         bigbuf);
8019
8020     switch ((value & 0x0c) >> 2)
8021     {
8022     case 0: str = "Service Negotiation Used"; break;
8023     case 1: str = "Service Negotiation Not Used"; break;
8024     case 2: str = "Service Negotiation Required"; break;
8025     case 3: str = "Service Negotiation Not Required"; break;
8026     }
8027
8028     my_decode_bitfield_value(bigbuf, value, 0x0c, 8);
8029     proto_tree_add_text(tree, asn1->tvb,
8030         saved_offset, asn1->offset - saved_offset,
8031         "%s :  Service Negotiate Flag (SRVNEG), %s",
8032         bigbuf,
8033         str);
8034
8035     switch (value & 0x03)
8036     {
8037     case 0 : str = "Change Facilities Operation Requested"; break;
8038     case 1 : str = "Change Facilities Operation Not Requested"; break;
8039     case 2 : str = "Change Facilities Operation Used"; break;
8040     case 3 : str = "Change Facilities Operation Not Used"; break;
8041     }
8042
8043     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
8044     proto_tree_add_text(tree, asn1->tvb,
8045         saved_offset, asn1->offset - saved_offset,
8046         "%s :  Change Facilities Flag (CHGFAC), %s",
8047         bigbuf,
8048         str);
8049
8050     EXTRANEOUS_DATA_CHECK(len, 1);
8051 }
8052
8053 static void
8054 param_dp_params(ASN1_SCK *asn1, proto_tree *tree, guint len)
8055 {
8056     gint32 value;
8057     guint saved_offset;
8058     gchar *str = NULL;
8059
8060     SHORT_DATA_CHECK(len, 4);
8061
8062     saved_offset = asn1->offset;
8063
8064     asn1_int32_value_decode(asn1, 1, &value);
8065
8066     my_decode_bitfield_value(bigbuf, value, 0xfc, 8);
8067     proto_tree_add_text(tree, asn1->tvb,
8068         saved_offset, asn1->offset - saved_offset,
8069         "%s :  Reserved",
8070         bigbuf);
8071
8072     switch (value & 0x03)
8073     {
8074     case 0: str = "Privacy inactive or not supported"; break;
8075     case 1: str = "Privacy Requested or Acknowledged"; break;
8076     default:
8077         str = "Reserved, treat as Privacy inactive or not supported";
8078         break;
8079     }
8080
8081     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
8082     proto_tree_add_text(tree, asn1->tvb,
8083         saved_offset, asn1->offset - saved_offset,
8084         "%s :  Privacy Mode, %s",
8085         bigbuf,
8086         str);
8087
8088     saved_offset = asn1->offset;
8089
8090     asn1_int32_value_decode(asn1, 1, &value);
8091
8092     switch (value)
8093     {
8094     case 0: str = "Not used"; break;
8095     case 1: str = "Data Privacy Version 1"; break;
8096     default:
8097         if ((value >= 2) && (value <= 223)) { str = "Reserved, treat as Not used"; }
8098         else { str = "Reserved for protocol extension, treat as Not used"; }
8099         break;
8100     }
8101
8102     proto_tree_add_text(tree, asn1->tvb,
8103         saved_offset, asn1->offset - saved_offset,
8104         "Data Privacy Version, %s",
8105         str);
8106
8107     saved_offset = asn1->offset;
8108
8109     proto_tree_add_text(tree, asn1->tvb,
8110         saved_offset, len - 2,
8111         "Data Privacy data");
8112
8113     asn1->offset += (len - 2);
8114 }
8115
8116 static void
8117 param_trn(ASN1_SCK *asn1, proto_tree *tree, guint len)
8118 {
8119     guint saved_offset;
8120     guchar *poctets;
8121
8122     saved_offset = asn1->offset;
8123
8124     asn1_string_value_decode(asn1, len, &poctets);
8125
8126     my_dgt_tbcd_unpack(bigbuf, poctets, len, &Dgt_msid);
8127     g_free(poctets);
8128
8129     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8130         saved_offset, len, "TRN %s", bigbuf);
8131 }
8132
8133 static void
8134 param_islp_info(ASN1_SCK *asn1, proto_tree *tree, guint len)
8135 {
8136     gint32 value;
8137     guint saved_offset;
8138     gchar *str = NULL;
8139
8140     saved_offset = asn1->offset;
8141
8142     asn1_int32_value_decode(asn1, 1, &value);
8143
8144     switch (value)
8145     {
8146     case 0: str = "No ISLP supported"; break;
8147     case 1: str = "ISLP supported (see ISLP)"; break;
8148     default:
8149         if ((value >= 2) && (value <= 112)) { str = "Reserved, treat as No ISLP supported"; }
8150         else if ((value >= 113) && (value <= 223)) { str = "Reserved, treat as ISLP supported"; }
8151         else if ((value >= 224) && (value <= 240)) { str = "Reserved for protocol extension, treat as No ISLP supported"; }
8152         else { str = "Reserved for protocol extension, treat as ISLP supported"; }
8153         break;
8154     }
8155
8156     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8157         saved_offset, asn1->offset - saved_offset,
8158         str);
8159
8160     EXTRANEOUS_DATA_CHECK(len, 1);
8161 }
8162
8163 static void
8164 param_ana_red_info(ASN1_SCK *asn1, proto_tree *tree, guint len)
8165 {
8166     gint32 value;
8167     guint saved_offset;
8168     gchar *str = NULL;
8169
8170     saved_offset = asn1->offset;
8171
8172     asn1_int32_value_decode(asn1, 1, &value);
8173
8174     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
8175     proto_tree_add_text(tree, asn1->tvb,
8176         saved_offset, asn1->offset - saved_offset,
8177         "%s :  Reserved",
8178         bigbuf);
8179
8180     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
8181     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8182         saved_offset, asn1->offset - saved_offset,
8183         "%s :  Ignore CDMA, %s",
8184         bigbuf,
8185         (value & 0x20) ?  "Ignore the CDMA Capability Message on the analog system to which it is being redirected" :
8186             "Don't ignore the CDMA Capability Message on the analog system to which it is being redirected");
8187
8188     switch (value & 0x1f)
8189     {
8190     case 0: str = "Attempt to obtain service on either System A or B in accordance with the custom system selection process"; break;
8191     case 1: str = "Attempt to obtain service on System A only"; break;
8192     case 2: str = "Error in IS-735, text was unspecified but not reserved"; break;
8193     case 3: str = "Attempt to obtain service on System A first.  If unsuccessful, attempt to obtain service on System B"; break;
8194     case 4: str = "Attempt to obtain service on System B first.  If unsuccessful, attempt to obtain service on System A"; break;
8195     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;
8196
8197     default:
8198         str = "Reserved for protocol extension";
8199         break;
8200     }
8201
8202     my_decode_bitfield_value(bigbuf, value, 0x1f, 8);
8203     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8204         saved_offset, asn1->offset - saved_offset,
8205         "%s :  Sys Ordering, %s",
8206         bigbuf,
8207         str);
8208
8209     EXTRANEOUS_DATA_CHECK(len, 1);
8210 }
8211
8212 static void
8213 param_reason_list(ASN1_SCK *asn1, proto_tree *tree, guint len)
8214 {
8215     gint32 value;
8216     gint i;
8217     guint saved_offset;
8218     gchar *str = NULL;
8219
8220     saved_offset = asn1->offset;
8221
8222     i = 0;
8223
8224     do
8225     {
8226         asn1_int32_value_decode(asn1, 1, &value);
8227
8228         switch (value)
8229         {
8230         case 0: str = "Unknown"; break;
8231         case 1: str = "Unable to configure ISLP"; break;
8232         case 2: str = "ISLP failure"; break;
8233         case 3: str = "Service allowed but facilities not available"; break;
8234         case 4: str = "Service not allowed"; break;
8235         case 5: str = "No Response to TMSI assignment"; break;
8236         case 6: str = "Required parameters unavailable. (e.g., as indicated by the RequiredParametersMask parameter)"; break;
8237         default:
8238             if ((value >= 7) && (value <= 110)) { str = "Reserved for common CDMA and TDMA network error causes. If unknown, treat as Unknown"; }
8239             else if ((value >= 111) && (value <= 127)) { str = "Reserved for common CDMA and TDMA network error causes for protocol extension. If unknown, treat as Unknown"; }
8240             else if ((value >= 128) && (value <= 174)) { str = "CDMA Specific error causes. If unknown, treat as Unknown"; }
8241             else if ((value >= 175) && (value <= 191)) { str = "CDMA Specific error causes for protocol extension. If unknown treat as Unknown"; }
8242             else if ((value >= 192) && (value <= 237)) { str = "TDMA Specific error causes as defined by the TDMACause parameter. If unknown treat as Unknown"; }
8243             else { str = "TDMA Specific error causes for protocol extension. If unknown, treat as Unknown"; }
8244             break;
8245         }
8246
8247         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8248             saved_offset, asn1->offset - saved_offset,
8249             "[%d] %s",
8250             i++,
8251             str);
8252
8253         saved_offset = asn1->offset;
8254     }
8255     while ((len - i) > 0);
8256 }
8257
8258 static void
8259 param_imsi(ASN1_SCK *asn1, proto_tree *tree, guint len)
8260 {
8261     guint saved_offset;
8262     guchar *poctets;
8263
8264     saved_offset = asn1->offset;
8265     asn1_string_value_decode(asn1, len, &poctets);
8266
8267     my_dgt_tbcd_unpack(bigbuf, poctets, len, &Dgt_msid);
8268     g_free(poctets);
8269
8270     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8271         saved_offset, len,
8272         "IMSI %s",
8273         bigbuf);
8274 }
8275
8276 static void
8277 param_min(ASN1_SCK *asn1, proto_tree *tree, guint len)
8278 {
8279     guint saved_offset;
8280     guchar *poctets;
8281
8282     EXACT_DATA_CHECK(len, 5);
8283
8284     saved_offset = asn1->offset;
8285     asn1_string_value_decode(asn1, len, &poctets);
8286
8287     my_dgt_tbcd_unpack(bigbuf, poctets, len, &Dgt_msid);
8288     g_free(poctets);
8289
8290     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8291         saved_offset, len,
8292         "MIN %s",
8293         bigbuf);
8294 }
8295
8296 static void
8297 param_auth_cap(ASN1_SCK *asn1, proto_tree *tree, guint len)
8298 {
8299     gint32 value;
8300     guint saved_offset;
8301     gchar *str = NULL;
8302
8303     EXACT_DATA_CHECK(len, 1);
8304
8305     saved_offset = asn1->offset;
8306
8307     asn1_int32_value_decode(asn1, 1, &value);
8308
8309     switch (value)
8310     {
8311     case 0: str = "Not used"; break;
8312     case 1: str = "No authentication required"; break;
8313     case 2: str = "Authentication required"; break;
8314     case 128: str = "Authentication required and UIM capable"; break;
8315     default:
8316         if ((value >= 3) && (value <= 95)) { str = "Reserved, treat as No authentication required"; }
8317         else if ((value >= 96) && (value <= 127)) { str = "Reserved for protocol extension, treat as No authentication required"; }
8318         else if ((value >= 129) && (value <= 223)) { str = "Reserved, treat as Authentication required"; }
8319         else { str = "Reserved for protocol extension, treat as Authentication required"; }
8320         break;
8321     }
8322
8323     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8324         saved_offset, asn1->offset - saved_offset,
8325         str);
8326 }
8327
8328 static void
8329 param_sus_acc(ASN1_SCK *asn1, proto_tree *tree, guint len)
8330 {
8331     gint32 value;
8332     guint saved_offset;
8333     gchar *str = NULL;
8334
8335     EXACT_DATA_CHECK(len, 1);
8336
8337     saved_offset = asn1->offset;
8338
8339     asn1_int32_value_decode(asn1, 1, &value);
8340
8341     switch (value)
8342     {
8343     case 0: str = "Not used"; break;
8344     case 1: str = "Anomalous digits"; break;
8345     case 2: str = "Unspecified"; break;
8346     default:
8347         if ((value >= 3) && (value <= 113)) { str = "Reserved, treat as Anomalous digits"; }
8348         else if ((value >= 114) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
8349         else { str = "Reserved for protocol extension, treat as Unspecified"; }
8350         break;
8351     }
8352
8353     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8354         saved_offset, asn1->offset - saved_offset,
8355         "Reason, %s",
8356         str);
8357 }
8358
8359 static void
8360 param_dis_text(ASN1_SCK *asn1, proto_tree *tree, guint len)
8361 {
8362     gint32 value;
8363     guint saved_offset;
8364
8365     SHORT_DATA_CHECK(len, 3);
8366
8367     saved_offset = asn1->offset;
8368
8369     asn1_int32_value_decode(asn1, 1, &value);
8370
8371     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
8372     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8373         saved_offset, asn1->offset - saved_offset,
8374         "%s :  Spec. has hardcoded 1",
8375         bigbuf);
8376
8377     my_decode_bitfield_value(bigbuf, value, 0x7f, 8);
8378     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8379         saved_offset, asn1->offset - saved_offset,
8380         "%s :  Display type, see ANSI T1.610 for encoding",
8381         bigbuf);
8382
8383     saved_offset = asn1->offset;
8384
8385     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8386         saved_offset, len - 1,
8387         "Display data");
8388
8389     asn1->offset += len - 1;
8390 }
8391
8392 static void
8393 param_dis_text2(ASN1_SCK *asn1, proto_tree *tree, guint len)
8394 {
8395     gint32 value;
8396     guint orig_offset, saved_offset;
8397     gchar *str = NULL;
8398
8399     SHORT_DATA_CHECK(len, 4);
8400
8401     orig_offset = asn1->offset;
8402     saved_offset = asn1->offset;
8403
8404     do
8405     {
8406         asn1_int32_value_decode(asn1, 1, &value);
8407
8408         switch (value)
8409         {
8410         case 0: str = "Not used"; break;
8411         case 1: str = "ASCII"; break;
8412         case 2: str = "ITU T.50. The International Reference Alphabet as defined in ITU-R Rec. T.50"; break;
8413         case 3: str = "User Specific"; break;
8414         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;
8415         case 5: str = "ISO 10646. The Universal Multiple-Octet Coded Character Set (USC) as defined in ISO/IEC Standard 10646"; break;
8416         case 6: str = "ISO 8859-8. The 8-bit single-byte coded character set Hebrew as defined in ISO/IEC Standard 8859-8"; break;
8417         case 7: str = "IS-91 Extended Protocol Message. The length is determined by the Message Type; see TIA/EIA/IS-90"; break;
8418         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;
8419         case 9: str = "KC C 5601. Variable 1-2 byte Korean encoding method"; break;
8420         default:
8421             if ((value >= 10) && (value <= 223)) { str = "Reserved, treat as ASCII"; }
8422             else { str = "Reserved, treat as ASCII"; }
8423             break;
8424         }
8425
8426         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8427             saved_offset, asn1->offset - saved_offset,
8428             "Display Character Set, %s",
8429             str);
8430
8431         saved_offset = asn1->offset;
8432
8433         asn1_int32_value_decode(asn1, 1, &value);
8434
8435         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8436             saved_offset, asn1->offset - saved_offset,
8437             "Display Type, %d, see ANSI T1.610",
8438             value);
8439
8440         saved_offset = asn1->offset;
8441
8442         asn1_int32_value_decode(asn1, 1, &value);
8443
8444         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8445             saved_offset, asn1->offset - saved_offset,
8446             "Display Tag, %d",
8447             value);
8448
8449         saved_offset = asn1->offset;
8450
8451         asn1_int32_value_decode(asn1, 1, &value);
8452
8453         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8454             saved_offset, asn1->offset - saved_offset,
8455             "Display Length, %d",
8456             value);
8457
8458         saved_offset = asn1->offset;
8459
8460         if (value > 0)
8461         {
8462             if ((guint32) value > (len - (saved_offset - orig_offset)))
8463             {
8464                 proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8465                     saved_offset, len - (saved_offset - orig_offset),
8466                     "Short Data (?)");
8467
8468                 asn1->offset += len - (saved_offset - orig_offset);
8469                 return;
8470             }
8471
8472             proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8473                 saved_offset, value,
8474                 "Display data");
8475
8476             asn1->offset += value;
8477
8478             saved_offset = asn1->offset;
8479         }
8480     }
8481     while ((len - (saved_offset - orig_offset)) >= 4);
8482
8483     EXTRANEOUS_DATA_CHECK((len - (saved_offset - orig_offset)), 0);
8484 }
8485
8486 static void
8487 param_dmh_srvc_id(ASN1_SCK *asn1, proto_tree *tree, guint len)
8488 {
8489     gint32 value;
8490     guint orig_offset, saved_offset;
8491
8492     SHORT_DATA_CHECK(len, 5);
8493
8494     orig_offset = asn1->offset;
8495     saved_offset = asn1->offset;
8496
8497     do
8498     {
8499         asn1_int32_value_decode(asn1, 2, &value);
8500
8501         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8502             saved_offset, asn1->offset - saved_offset,
8503             "Market ID %d",
8504             value);
8505
8506         saved_offset = asn1->offset;
8507
8508         asn1_int32_value_decode(asn1, 1, &value);
8509
8510         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8511             saved_offset, asn1->offset - saved_offset,
8512             "Market Segment ID %d",
8513             value);
8514
8515         saved_offset = asn1->offset;
8516
8517         asn1_int32_value_decode(asn1, 2, &value);
8518
8519         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8520             saved_offset, asn1->offset - saved_offset,
8521             "DMH Service ID Value %d",
8522             value);
8523
8524         saved_offset = asn1->offset;
8525     }
8526     while ((len - (saved_offset - orig_offset)) >= 5);
8527
8528     EXTRANEOUS_DATA_CHECK((len - (saved_offset - orig_offset)), 0);
8529 }
8530
8531 static void
8532 param_feat_ind(ASN1_SCK *asn1, proto_tree *tree, guint len)
8533 {
8534     gint32 value;
8535     guint orig_offset, saved_offset;
8536
8537     SHORT_DATA_CHECK(len, 5);
8538
8539     orig_offset = asn1->offset;
8540     saved_offset = asn1->offset;
8541
8542     do
8543     {
8544         asn1_int32_value_decode(asn1, 2, &value);
8545
8546         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8547             saved_offset, asn1->offset - saved_offset,
8548             "Market ID %d",
8549             value);
8550
8551         saved_offset = asn1->offset;
8552
8553         asn1_int32_value_decode(asn1, 1, &value);
8554
8555         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8556             saved_offset, asn1->offset - saved_offset,
8557             "Market Segment ID %d",
8558             value);
8559
8560         saved_offset = asn1->offset;
8561
8562         asn1_int32_value_decode(asn1, 2, &value);
8563
8564         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8565             saved_offset, asn1->offset - saved_offset,
8566             "DMH Service ID Value %d",
8567             value);
8568
8569         saved_offset = asn1->offset;
8570     }
8571     while ((len - (saved_offset - orig_offset)) >= 5);
8572
8573     EXTRANEOUS_DATA_CHECK((len - (saved_offset - orig_offset)), 0);
8574 }
8575
8576 static void
8577 param_a_key_ver(ASN1_SCK *asn1, proto_tree *tree, guint len)
8578 {
8579     gint32 value;
8580     gint i;
8581     guint saved_offset;
8582     gchar *str = NULL;
8583
8584     saved_offset = asn1->offset;
8585
8586     i = 0;
8587
8588     do
8589     {
8590         asn1_int32_value_decode(asn1, 1, &value);
8591
8592         switch (value)
8593         {
8594         case 0: str = "Not used"; break;
8595         case 1: str = "A-key Generation not supported"; break;
8596         case 2: str = "Diffie Hellman with 768-bit modulus, 160-bit primitive, and 160-bit exponents"; break;
8597         case 3: str = "Diffie Hellman with 512-bit modulus, 160-bit primitive, and 160-bit exponents"; break;
8598         case 4: str = "Diffie Hellman with 768-bit modulus, 32-bit primitive, and 160-bit exponents"; break;
8599         default:
8600             if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as A-key Generation not supported"; }
8601             else { str = "Reserved for protocol extension, treat as A-key Generation not supported"; }
8602             break;
8603         }
8604
8605         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8606             saved_offset, asn1->offset - saved_offset,
8607             "[%d] %s",
8608             i++,
8609             str);
8610
8611         saved_offset = asn1->offset;
8612     }
8613     while ((len - i) > 0);
8614 }
8615
8616 static void
8617 param_inter_msg_time(ASN1_SCK *asn1, proto_tree *tree, guint len)
8618 {
8619     gint32 value;
8620     guint saved_offset;
8621
8622     EXACT_DATA_CHECK(len, 1);
8623
8624     saved_offset = asn1->offset;
8625
8626     asn1_int32_value_decode(asn1, 1, &value);
8627
8628     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8629         saved_offset, asn1->offset - saved_offset,
8630         "Timer Value, %d, %d seconds",
8631         value,
8632         value * 10);
8633
8634         /* XXX * 10 or / 10 ? */
8635 }
8636
8637 static void
8638 param_rel_cause(ASN1_SCK *asn1, proto_tree *tree, guint len)
8639 {
8640     gint32 value;
8641     guint saved_offset;
8642     gchar *str = NULL;
8643
8644     EXACT_DATA_CHECK(len, 1);
8645
8646     saved_offset = asn1->offset;
8647
8648     asn1_int32_value_decode(asn1, 1, &value);
8649
8650     switch (value)
8651     {
8652     case 0: str = "Unspecified"; break;
8653     case 1: str = "Calling Party"; break;
8654     case 2: str = "Called Party"; break;
8655     case 3: str = "Commanded Disconnect"; break;
8656     default:
8657         if ((value >= 4) && (value <= 23)) { str = "Reserved, treat as Calling Party"; }
8658         else if ((value >= 24) && (value <= 31)) { str = "Reserved for protocol extension. If unknown, treat as Calling Party"; }
8659         else if ((value >= 32) && (value <= 55)) { str = "Reserved, treat as Called Party"; }
8660         else if ((value >= 56) && (value <= 63)) { str = "Reserved for protocol extension. If unknown, treat as Called Party"; }
8661         else if ((value >= 64) && (value <= 87)) { str = "Reserved, treat as Commanded Disconnect"; }
8662         else if ((value >= 88) && (value <= 95)) { str = "Reserved for protocol extension. If unknown, treat as Commanded Disconnect"; }
8663         else if ((value >= 96) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
8664         else { str = "Reserved for protocol extension. If unknown, treat as Unspecified"; }
8665         break;
8666     }
8667
8668     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8669         saved_offset, asn1->offset - saved_offset,
8670         str);
8671 }
8672
8673 static void
8674 param_time_day(ASN1_SCK *asn1, proto_tree *tree, guint len)
8675 {
8676     gint32 value;
8677     gint32 h, m, s, ts;
8678     guint saved_offset;
8679
8680     EXACT_DATA_CHECK(len, 3);
8681
8682     saved_offset = asn1->offset;
8683
8684     asn1_int32_value_decode(asn1, 3, &value);
8685
8686     h = value / (3600 * 10);
8687     m = (value - (h * (3600 * 10))) / (60 * 10);
8688     s = (value - (h * (3600 * 10)) - (m * (60 * 10))) / 10;
8689     ts = (value - (h * (3600 * 10)) - (m * (60 * 10)) - (s * 10));
8690
8691     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8692         saved_offset, asn1->offset - saved_offset,
8693         "(UTC) (in tenths of seconds - 1), %d (%d:%d:%d.%d)",
8694         value,
8695         h,
8696         m,
8697         s,
8698         ts);
8699 }
8700
8701 static void
8702 param_call_status(ASN1_SCK *asn1, proto_tree *tree, guint len)
8703 {
8704     gint32 value;
8705     guint saved_offset;
8706     gchar *str = NULL;
8707
8708     if (len > 4)
8709     {
8710         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8711             asn1->offset, len, "Long Data (?)");
8712         asn1->offset += len;
8713         return;
8714     }
8715
8716     saved_offset = asn1->offset;
8717
8718     asn1->offset = saved_offset;
8719
8720     asn1_int32_value_decode(asn1, len, &value);
8721
8722     switch (value)
8723     {
8724     case 0: str = "Not used"; break;
8725     case 1: str = "Call Setup in Progress"; break;
8726     case 2: str = "Locally Allowed Call - No Action"; break;
8727     default:
8728         if (value < 0) { str = "Reserved for bilateral agreements. If unknown, treat as Not used"; }
8729         else { str = "Reserved, treat as Not used"; }
8730         break;
8731     }
8732
8733     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8734         saved_offset, len,
8735         str);
8736 }
8737
8738 static void
8739 param_ms_status(ASN1_SCK *asn1, proto_tree *tree, guint len)
8740 {
8741     gint32 value;
8742     guint saved_offset;
8743     gchar *str = NULL;
8744     gboolean has_chan;
8745     gboolean extended;
8746
8747     saved_offset = asn1->offset;
8748
8749     asn1_int32_value_decode(asn1, 1, &value);
8750
8751     extended = (value & 0x80) >> 7;
8752
8753     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
8754     proto_tree_add_text(tree, asn1->tvb,
8755         saved_offset, asn1->offset - saved_offset,
8756         "%s :  Extension (EXT), %s",
8757         bigbuf,
8758         extended ? "No Extension, last octet of sequence" : "Extension indicator, the octet continues through the next octet");
8759
8760     my_decode_bitfield_value(bigbuf, value, 0x60, 8);
8761     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8762         saved_offset, asn1->offset - saved_offset,
8763         "%s :  Reserved",
8764         bigbuf);
8765
8766     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
8767     proto_tree_add_text(tree, asn1->tvb,
8768         saved_offset, asn1->offset - saved_offset,
8769         "%s :  Location Information (LOC), %s",
8770         bigbuf,
8771         (value & 0x10) ? "MS location information available" : "No MS location information available");
8772
8773     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
8774     proto_tree_add_text(tree, asn1->tvb,
8775         saved_offset, asn1->offset - saved_offset,
8776         "%s :  Contact, %s",
8777         bigbuf,
8778         (value & 0x08) ? "Radio Contact Established" : "No Radio Contact");
8779
8780     has_chan = (value & 0x04) >> 2;
8781
8782     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
8783     proto_tree_add_text(tree, asn1->tvb,
8784         saved_offset, asn1->offset - saved_offset,
8785         "%s :  Channel, %s",
8786         bigbuf,
8787         has_chan ? "Traffic Channel Assigned" : "No Traffic Channel");
8788
8789     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
8790     proto_tree_add_text(tree, asn1->tvb,
8791         saved_offset, asn1->offset - saved_offset,
8792         "%s :  Handoff, %s",
8793         bigbuf,
8794         (value & 0x02) ? "Intersystem Handoff" : "No Intersystem Handoff");
8795
8796     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
8797     proto_tree_add_text(tree, asn1->tvb,
8798         saved_offset, asn1->offset - saved_offset,
8799         "%s :  Inactive, %s",
8800         bigbuf,
8801         (value & 0x01) ? "MS Inactive" : "MS Active");
8802
8803     if (len == 1) return;
8804
8805     saved_offset = asn1->offset;
8806
8807     asn1_int32_value_decode(asn1, 1, &value);
8808
8809     if (extended)
8810     {
8811         proto_tree_add_text(tree, asn1->tvb,
8812             saved_offset, asn1->offset - saved_offset,
8813             "Octet 1a ? spec. does not provide details");
8814
8815         saved_offset = asn1->offset;
8816
8817         EXTRANEOUS_DATA_CHECK(len, 2);
8818
8819         return;
8820     }
8821
8822     if (has_chan)
8823     {
8824         switch (value)
8825         {
8826         case 0: str = "Not used "; break;
8827         case 1: str = "Analog. The MS is currently assigned to an analog traffic channel"; break;
8828         case 2: str = "NAMPS. The MS is currently assigned to an NAMPS traffic channel"; break;
8829         case 3: str = "TDMA. The MS is currently assigned to a TDMA traffic channel"; break;
8830         case 4: str = "CDMA. The MS is currently assigned to a CDMA traffic channel"; break;
8831         default:
8832             if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Not used"; }
8833             else { str = "Reserved for protocol extension, treat as Not used"; }
8834             break;
8835         }
8836
8837         proto_tree_add_text(tree, asn1->tvb,
8838             saved_offset, asn1->offset - saved_offset,
8839             "Radio Channel Type, %s",
8840             str);
8841
8842         saved_offset = asn1->offset;
8843
8844         EXTRANEOUS_DATA_CHECK(len, 2);
8845
8846         return;
8847     }
8848
8849     asn1->offset -= 1;
8850
8851     EXTRANEOUS_DATA_CHECK(len, 1);
8852 }
8853
8854 static void
8855 param_pos_info_code(ASN1_SCK *asn1, proto_tree *tree, guint len)
8856 {
8857     gint32 value;
8858     guint saved_offset;
8859
8860     saved_offset = asn1->offset;
8861
8862     asn1_int32_value_decode(asn1, 1, &value);
8863
8864     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
8865     proto_tree_add_text(tree, asn1->tvb,
8866         saved_offset, asn1->offset - saved_offset,
8867         "%s :  Reserved",
8868         bigbuf);
8869
8870     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
8871     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8872         saved_offset, asn1->offset - saved_offset,
8873         "%s :  MS Identity (MSID), %s",
8874         bigbuf,
8875         (value & 0x10) ? "MS Identity Requested" : "No MS Identity Requested");
8876
8877     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
8878     proto_tree_add_text(tree, asn1->tvb,
8879         saved_offset, asn1->offset - saved_offset,
8880         "%s :  Routing Address (ROUTE), %s",
8881         bigbuf,
8882         (value & 0x08) ? "Routing Address Requested" : "No Routing Address Requested");
8883
8884     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
8885     proto_tree_add_text(tree, asn1->tvb,
8886         saved_offset, asn1->offset - saved_offset,
8887         "%s :  Serving Cell ID (CELLID), %s",
8888         bigbuf,
8889         (value & 0x04) ? "Serving Cell ID Requested" : "No Serving Cell ID Requested");
8890
8891     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
8892     proto_tree_add_text(tree, asn1->tvb,
8893         saved_offset, asn1->offset - saved_offset,
8894         "%s :  Location Area ID (LOCID), %s",
8895         bigbuf,
8896         (value & 0x02) ?  "Location Area ID Requested" : "No Location Area ID Requested");
8897
8898     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
8899     proto_tree_add_text(tree, asn1->tvb,
8900         saved_offset, asn1->offset - saved_offset,
8901         "%s :  Current, %s",
8902         bigbuf,
8903         (value & 0x01) ? "Provide the current MS location" : "Provide the last known MS location information, if known");
8904
8905     EXTRANEOUS_DATA_CHECK(len, 1);
8906 }
8907
8908 static void
8909 param_rel_reason(ASN1_SCK *asn1, proto_tree *tree, guint len)
8910 {
8911     gint32 value;
8912     guint saved_offset;
8913     gchar *str = NULL;
8914
8915     EXACT_DATA_CHECK(len, 1);
8916
8917     saved_offset = asn1->offset;
8918
8919     asn1_int32_value_decode(asn1, 1, &value);
8920
8921     switch (value)
8922     {
8923     case 0: str = "Unspecified"; break;
8924     case 1: str = "Call Over Clear Forward"; break;
8925     case 2: str = "Call Over Clear Backward"; break;
8926     case 3: str = "Handoff Successful"; break;
8927     case 4: str = "Handoff Abort - call over"; break;
8928     case 5: str = "Handoff Abort - not received"; break;
8929     case 6: str = "Abnormal mobile termination"; break;
8930     case 7: str = "Abnormal switch termination"; break;
8931     case 8: str = "Special feature release"; break;
8932     case 9: str = "Session Over Clear Forward"; break;
8933     case 10: str = "Session Over Clear Backward"; break;
8934     case 11: str = "Clear All Services Forward"; break;
8935     case 12: str = "Clear All Services Backward"; break;
8936     case 13: str = "Anchor MSC was removed from the packet data session"; break;
8937     default:
8938         if ((value >= 14) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
8939         else { str = "Reserved for protocol extension, treat as Unspecified"; }
8940         break;
8941     }
8942
8943     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8944         saved_offset, asn1->offset - saved_offset,
8945         "Reason, %s",
8946         str);
8947 }
8948
8949 static void
8950 param_ho_reason(ASN1_SCK *asn1, proto_tree *tree, guint len)
8951 {
8952     gint32 value;
8953     guint saved_offset;
8954     gchar *str = NULL;
8955
8956     EXACT_DATA_CHECK(len, 1);
8957
8958     saved_offset = asn1->offset;
8959
8960     asn1_int32_value_decode(asn1, 1, &value);
8961
8962     switch (value)
8963     {
8964     case 0: str = "Not used"; break;
8965     case 1: str = "Unspecified"; break;
8966     case 2: str = "Weak signal"; break;
8967     case 3: str = "Off-loading"; break;
8968     case 4: str = "Anticipatory"; break;
8969     default:
8970         if ((value >= 5) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
8971         else { str = "Reserved for protocol extension, treat as Unspecified"; }
8972         break;
8973     }
8974
8975     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
8976         saved_offset, asn1->offset - saved_offset,
8977         str);
8978 }
8979
8980 static void
8981 param_red_reason(ASN1_SCK *asn1, proto_tree *tree, guint len)
8982 {
8983     gint32 value;
8984     guint saved_offset;
8985     gchar *str = NULL;
8986
8987     EXACT_DATA_CHECK(len, 1);
8988
8989     saved_offset = asn1->offset;
8990
8991     asn1_int32_value_decode(asn1, 1, &value);
8992
8993     switch (value)
8994     {
8995     case 0: str = "Not used"; break;
8996     case 1: str = "Busy"; break;
8997     case 2: str = "No answer"; break;
8998     case 3: str = "Unconditional"; break;
8999     case 4: str = "No page response"; break;
9000     case 5: str = "Unavailable"; break;
9001     case 6: str = "Unroutable"; break;
9002     case 7: str = "Call accepted"; break;
9003     case 8: str = "Call refused"; break;
9004     case 9: str = "USCFvm, divert to voice mail"; break;
9005     case 10: str = "USCFms, divert to an MS provided DN"; break;
9006     case 11: str = "USCFnr, divert to a network registered DN"; break;
9007     default:
9008         if ((value >= 12) && (value <= 223)) { str = "Reserved, treat as No answer"; }
9009         else { str = "Reserved for protocol extension, treat as No answer"; }
9010         break;
9011     }
9012
9013     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9014         saved_offset, asn1->offset - saved_offset,
9015         str);
9016 }
9017
9018 static void
9019 param_confid_mode(ASN1_SCK *asn1, proto_tree *tree, guint len)
9020 {
9021     gint32 value;
9022     guint saved_offset;
9023
9024     EXACT_DATA_CHECK(len, 1);
9025
9026     saved_offset = asn1->offset;
9027
9028     asn1_int32_value_decode(asn1, 1, &value);
9029
9030     my_decode_bitfield_value(bigbuf, value, 0xf8, 8);
9031     proto_tree_add_text(tree, asn1->tvb,
9032         saved_offset, asn1->offset - saved_offset,
9033         "%s :  Reserved",
9034         bigbuf);
9035
9036     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
9037     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9038         saved_offset, asn1->offset - saved_offset,
9039         "%s :  Data Privacy (DP), %s",
9040         bigbuf,
9041         (value & 0x04) ? "ON" : "OFF");
9042
9043     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
9044     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9045         saved_offset, asn1->offset - saved_offset,
9046         "%s :  Signaling Message Encryption (SE), %s",
9047         bigbuf,
9048         (value & 0x02) ? "ON" : "OFF");
9049
9050     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
9051     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9052         saved_offset, asn1->offset - saved_offset,
9053         "%s :  Voice Privacy (VP), %s",
9054         bigbuf,
9055         (value & 0x01) ? "ON" : "OFF");
9056 }
9057
9058 static void
9059 param_sys_acc_type(ASN1_SCK *asn1, proto_tree *tree, guint len)
9060 {
9061     gint32 value;
9062     guint saved_offset;
9063     gchar *str = NULL;
9064
9065     EXACT_DATA_CHECK(len, 1);
9066
9067     saved_offset = asn1->offset;
9068
9069     asn1_int32_value_decode(asn1, 1, &value);
9070
9071     switch (value)
9072     {
9073     case 0: str = "Not used"; break;
9074     case 1: str = "Unspecified"; break;
9075     case 2: str = "Flash request"; break;
9076     case 3: str = "Autonomous registration"; break;
9077     case 4: str = "Call origination"; break;
9078     case 5: str = "Page response"; break;
9079     case 6: str = "No access"; break;
9080     case 7: str = "Power down registration"; break;
9081     case 8: str = "SMS page response"; break;
9082     case 9: str = "OTASP"; break;
9083     default:
9084         if ((value >= 10) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
9085         else { str = "Reserved for protocol extension, treat as Unspecified"; }
9086         break;
9087     }
9088
9089     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9090         saved_offset, asn1->offset - saved_offset,
9091         str);
9092 }
9093
9094 static void
9095 param_scm(ASN1_SCK *asn1, proto_tree *tree, guint len)
9096 {
9097     gint32 value, temp_int;
9098     guint saved_offset;
9099     gchar *str = NULL;
9100
9101     EXACT_DATA_CHECK(len, 1);
9102
9103     saved_offset = asn1->offset;
9104
9105     asn1_int32_value_decode(asn1, 1, &value);
9106
9107     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
9108     proto_tree_add_text(tree, asn1->tvb,
9109         saved_offset, asn1->offset - saved_offset,
9110         "%s :  Reserved",
9111         bigbuf);
9112
9113     temp_int = ((value & 0x10) >> 2) | (value & 0x03);
9114     switch (temp_int)
9115     {
9116     case 0: str = "Class I"; break;
9117     case 1: str = "Class II"; break;
9118     case 2: str = "Class III"; break;
9119     case 3: str = "Class IV"; break;
9120     case 4: str = "Class V"; break;
9121     case 5: str = "Class VI"; break;
9122     case 6: str = "Class VII"; break;
9123     case 7: str = "Class VIII"; break;
9124     }
9125
9126     my_decode_bitfield_value(bigbuf, value, 0x13, 8);
9127     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9128         saved_offset, asn1->offset - saved_offset,
9129         "%s :  Power %s",
9130         bigbuf,
9131         str);
9132
9133     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
9134     proto_tree_add_text(tree, asn1->tvb,
9135         saved_offset, asn1->offset - saved_offset,
9136         "%s :  Bandwidth %s",
9137         bigbuf,
9138         (value & 0x08) ? "25 MHz" : "20 MHz");
9139
9140     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
9141     proto_tree_add_text(tree, asn1->tvb,
9142         saved_offset, asn1->offset - saved_offset,
9143         "%s :  Transmission, %s",
9144         bigbuf,
9145         (value & 0x04) ? "Discontinuous" : "Continuous");
9146 }
9147
9148 static void
9149 param_deny_acc(ASN1_SCK *asn1, proto_tree *tree, guint len)
9150 {
9151     gint32 value;
9152     guint saved_offset;
9153     gchar *str = NULL;
9154
9155     EXACT_DATA_CHECK(len, 1);
9156
9157     saved_offset = asn1->offset;
9158
9159     asn1_int32_value_decode(asn1, 1, &value);
9160
9161     switch (value)
9162     {
9163     case 0: str = "Not used"; break;
9164     case 1: str = "Unspecified"; break;
9165     case 2: str = "SSD Update failure"; break;
9166     case 3: str = "COUNT Update failure"; break;
9167     case 4: str = "Unique Challenge failure"; break;
9168     case 5: str = "AUTHR mismatch"; break;
9169     case 6: str = "COUNT mismatch"; break;
9170     case 7: str = "Process collision"; break;
9171     case 8: str = "Missing authentication parameters"; break;
9172     case 9: str = "TerminalType mismatch"; break;
9173     case 10: str = "MIN, IMSI or ESN authorization failure"; break;
9174     default:
9175         if ((value >= 11) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
9176         else { str = "Reserved for protocol extension, treat as Unspecified"; }
9177         break;
9178     }
9179
9180     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9181         saved_offset, asn1->offset - saved_offset,
9182         str);
9183 }
9184
9185 static void
9186 param_cdma_sig_qual(ASN1_SCK *asn1, proto_tree *tree, guint len)
9187 {
9188     gint32 value;
9189     guint saved_offset;
9190
9191     EXACT_DATA_CHECK(len, 1);
9192
9193     saved_offset = asn1->offset;
9194
9195     asn1_int32_value_decode(asn1, 1, &value);
9196
9197     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
9198     proto_tree_add_text(tree, asn1->tvb,
9199         saved_offset, asn1->offset - saved_offset,
9200         "%s :  Reserved",
9201         bigbuf);
9202
9203     my_decode_bitfield_value(bigbuf, value, 0x3f, 8);
9204     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9205         saved_offset, asn1->offset - saved_offset,
9206         "%s :  Value %d",
9207         bigbuf,
9208         value & 0x3f);
9209 }
9210
9211 static void
9212 param_rec_sig_qual(ASN1_SCK *asn1, proto_tree *tree, guint len)
9213 {
9214     gint32 value;
9215     guint saved_offset;
9216     gchar *str = NULL;
9217
9218     EXACT_DATA_CHECK(len, 1);
9219
9220     saved_offset = asn1->offset;
9221
9222     asn1_int32_value_decode(asn1, 1, &value);
9223
9224     switch (value)
9225     {
9226     case 0: str = "Not a usable signal"; break;
9227     case 255: str = "Interference"; break;
9228     default:
9229         if ((value >= 1) && (value <= 8)) { str = "Reserved, treat as Not a usable signal"; }
9230         else if ((value >= 9) && (value <= 245)) { str = "Usable signal range"; }
9231         else if ((value >= 246) && (value <= 254)) { str = "Reserved, treat as Interference"; }
9232         break;
9233     }
9234
9235     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9236         saved_offset, asn1->offset - saved_offset,
9237         str);
9238 }
9239
9240 static void
9241 param_sig_qual(ASN1_SCK *asn1, proto_tree *tree, guint len)
9242 {
9243     gint32 value;
9244     guint saved_offset;
9245     gchar *str = NULL;
9246
9247     EXACT_DATA_CHECK(len, 1);
9248
9249     saved_offset = asn1->offset;
9250
9251     asn1_int32_value_decode(asn1, 1, &value);
9252
9253     switch (value)
9254     {
9255     case 0: str = "Not a usable signal"; break;
9256     case 255: str = "Interference"; break;
9257     default:
9258         if ((value >= 1) && (value <= 8)) { str = "Reserved, treat as Not a usable signal"; }
9259         else if ((value >= 9) && (value <= 245)) { str = "Usable signal range"; }
9260         else if ((value >= 246) && (value <= 254)) { str = "Reserved, treat as Interference"; }
9261         break;
9262     }
9263
9264     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9265         saved_offset, asn1->offset - saved_offset,
9266         str);
9267 }
9268
9269 static void
9270 param_ssd_no_share(ASN1_SCK *asn1, proto_tree *tree, guint len)
9271 {
9272     gint32 value;
9273     guint saved_offset;
9274     gchar *str = NULL;
9275
9276     EXACT_DATA_CHECK(len, 1);
9277
9278     saved_offset = asn1->offset;
9279
9280     asn1_int32_value_decode(asn1, 1, &value);
9281
9282     switch (value)
9283     {
9284     case 0: str = "Not used"; break;
9285     case 1: str = "Discard SSD"; break;
9286     default:
9287         str = "Reserved, treat as Discard SSD";
9288         break;
9289     }
9290
9291     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9292         saved_offset, asn1->offset - saved_offset,
9293         str);
9294 }
9295
9296 static void
9297 param_report_type(ASN1_SCK *asn1, proto_tree *tree, guint len)
9298 {
9299     gint32 value;
9300     guint saved_offset;
9301     gchar *str = NULL;
9302
9303     EXACT_DATA_CHECK(len, 1);
9304
9305     saved_offset = asn1->offset;
9306
9307     asn1_int32_value_decode(asn1, 1, &value);
9308
9309     switch (value)
9310     {
9311     case 0: str = "Not used"; break;
9312     case 1: str = "Unspecified security violation"; break;
9313     case 2: str = "MSID/ESN mismatch"; break;
9314     case 3: str = "RANDC mismatch"; break;
9315     case 4: str = "Reserved (see TSB51)"; break;
9316     case 5: str = "SSD Update failed"; break;
9317     case 6: str = "Reserved (see TSB51)"; break;
9318     case 7: str = "COUNT mismatch"; break;
9319     case 8: str = "Reserved (see TSB51)"; break;
9320     case 9: str = "Unique Challenge failed"; break;
9321     case 10: str = "Unsolicited Base Station Challenge"; break;
9322     case 11: str = "SSD Update no response"; break;
9323     case 12: str = "COUNT Update no response"; break;
9324     case 13: str = "Unique Challenge no response"; break;
9325     case 14: str = "AUTHR mismatch"; break;
9326     case 15: str = "TERMTYP mismatch"; break;
9327     case 16: str = "Missing authentication parameters"; break;
9328     default:
9329         if ((value >= 17) && (value <= 223)) { str = "Reserved, treat as Unspecified security violation"; }
9330         else { str = "Reserved for protocol extension, treat as Unspecified security violation"; }
9331         break;
9332     }
9333
9334     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9335         saved_offset, asn1->offset - saved_offset,
9336         str);
9337 }
9338
9339 static void
9340 param_term_type(ASN1_SCK *asn1, proto_tree *tree, guint len)
9341 {
9342     gint32 value;
9343     guint saved_offset;
9344     gchar *str = NULL;
9345
9346     EXACT_DATA_CHECK(len, 1);
9347
9348     saved_offset = asn1->offset;
9349
9350     asn1_int32_value_decode(asn1, 1, &value);
9351
9352     switch (value)
9353     {
9354     case 0: str = "Not used"; break;
9355     case 1: str = "Not distinguished, EIA/TIA-553, IS-54-A, IS-88, IS-91, IS-94"; break;
9356     case 2: str = "IS-54-B"; break;
9357     case 3: str = "IS-136"; break;
9358     case 4: str = "J-STD-011 (rescinded 11/23/99)"; break;
9359     case 5: str = "IS-136-A or TIA/EIA-136 Revision-0"; break;
9360     case 6: str = "TIA/EIA-136-A"; break;
9361     case 7: str = "TIA/EIA-136-B"; break;
9362     case 32: str = "IS-95"; break;
9363     case 33: str = "IS-95-A"; break;
9364     case 34: str = "J-STD-008"; break;
9365     case 35: str = "IS-95-B"; break;
9366     case 36: str = "IS-2000"; break;
9367     case 64: str = "IS-88"; break;
9368     case 65: str = "IS-94"; break;
9369     case 66: str = "IS-91"; break;
9370     case 67: str = "J-STD-014"; break;
9371     case 68: str = "TIA/EIA-553-A"; break;
9372     case 69: str = "IS-91-A"; break;
9373     default:
9374         if ((value >= 8) && (value <= 31)) { str = "Reserved, treat as IS-54-B"; }
9375         else if ((value >= 37) && (value <= 63)) { str = "Reserved, treat as IS-95-A"; }
9376         else if ((value >= 70) && (value <= 223)) { str = "Reserved, treat as Not distinguished"; }
9377         else { str = "Reserved for protocol extension, treat as Not distinguished"; }
9378         break;
9379     }
9380
9381     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9382         saved_offset, asn1->offset - saved_offset,
9383         str);
9384 }
9385
9386 static void
9387 param_term_res(ASN1_SCK *asn1, proto_tree *tree, guint len)
9388 {
9389     gint32 value;
9390     guint saved_offset;
9391     gchar *str = NULL;
9392
9393     EXACT_DATA_CHECK(len, 1);
9394
9395     saved_offset = asn1->offset;
9396
9397     asn1_int32_value_decode(asn1, 1, &value);
9398
9399     switch (value)
9400     {
9401     case 0: str = "Not used"; break;
9402     case 1: str = "Termination denied"; break;
9403     case 2: str = "Unrestricted"; break;
9404     case 3: str = "Treatment for this value is not specified"; break;
9405     default:
9406         if ((value >= 4) && (value <= 223)) { str = "Reserved, treat as Unrestricted"; }
9407         else { str = "Reserved for protocol extension, treat as Unrestricted"; }
9408         break;
9409     }
9410
9411     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9412         saved_offset, asn1->offset - saved_offset,
9413         str);
9414 }
9415
9416 static void
9417 param_dereg(ASN1_SCK *asn1, proto_tree *tree, guint len)
9418 {
9419     gint32 value;
9420     guint saved_offset;
9421     gchar *str = NULL;
9422
9423     EXACT_DATA_CHECK(len, 1);
9424
9425     saved_offset = asn1->offset;
9426
9427     asn1_int32_value_decode(asn1, 1, &value);
9428
9429     switch (value)
9430     {
9431     case 0: str = "Not used"; break;
9432     case 1: str = "Deregister for an unspecified reason"; break;
9433     case 2: str = "Deregister for an adminstrative reason"; break;
9434     case 3: str = "Deregister due to MS power down"; break;
9435     default:
9436         if ((value >= 4) && (value <= 223)) { str = "Reserved, treat as Deregister for an unspecified reason"; }
9437         else { str = "Reserved for protocol extension, treat as Deregister for an unspecified reason"; }
9438         break;
9439     }
9440
9441     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9442         saved_offset, asn1->offset - saved_offset,
9443         str);
9444 }
9445
9446 static void
9447 param_group_info(ASN1_SCK *asn1, proto_tree *tree, guint len)
9448 {
9449     gint32 value;
9450     guint saved_offset;
9451
9452     SHORT_DATA_CHECK(len, 4);
9453
9454     saved_offset = asn1->offset;
9455
9456     asn1_int32_value_decode(asn1, 4, &value);
9457
9458     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9459         saved_offset, asn1->offset - saved_offset,
9460         "Value %d",
9461         value);
9462
9463     EXTRANEOUS_DATA_CHECK(len, 4);
9464 }
9465
9466 static void
9467 param_auth_den(ASN1_SCK *asn1, proto_tree *tree, guint len)
9468 {
9469     gint32 value;
9470     guint saved_offset;
9471     gchar *str = NULL;
9472
9473     EXACT_DATA_CHECK(len, 1);
9474
9475     saved_offset = asn1->offset;
9476
9477     asn1_int32_value_decode(asn1, 1, &value);
9478
9479     switch (value)
9480     {
9481     case 0: str = "Not used"; break;
9482     case 1: str = "Delinquent account"; break;
9483     case 2: str = "Invalid serial number"; break;
9484     case 3: str = "Stolen unit"; break;
9485     case 4: str = "Duplicate unit"; break;
9486     case 5: str = "Unassigned directory number"; break;
9487     case 6: str = "Unspecified"; break;
9488     case 7: str = "Multiple access"; break;
9489     case 8: str = "Not Authorized for the MSC"; break;
9490     case 9: str = "Missing authentication parameters"; break;
9491     case 10: str = "Terminal Type mismatch"; break;
9492     default:
9493         if ((value >= 11) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
9494         else { str = "Reserved for protocol extension, treat as Unspecified"; }
9495         break;
9496     }
9497
9498     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9499         saved_offset, asn1->offset - saved_offset,
9500         "Reason, %s (%d)",
9501         str,
9502         value);
9503 }
9504
9505 static gchar *
9506 find_trig_type(gint32 value)
9507 {
9508     gchar *str = NULL;
9509
9510     switch (value)
9511     {
9512     case 0: str = "Unspecified"; break;
9513     case 1: str = "All Calls"; break;
9514     case 2: str = "Double Introducing Star"; break;
9515     case 3: str = "Single Introducing Star"; break;
9516     case 4: str = "Reserved [for Home System Feature Code"; break;
9517     case 5: str = "Double Introducing Pound"; break;
9518     case 6: str = "Single Introducing Pound"; break;
9519     case 7: str = "Revertive Call"; break;
9520     case 8: str = "0 Digit"; break;
9521     case 9: str = "1 Digit"; break;
9522     case 10: str = "2 Digit"; break;
9523     case 11: str = "3 Digit"; break;
9524     case 12: str = "4 Digit"; break;
9525     case 13: str = "5 Digit"; break;
9526     case 14: str = "6 Digit"; break;
9527     case 15: str = "7 Digit"; break;
9528     case 16: str = "8 Digit"; break;
9529     case 17: str = "9 Digit"; break;
9530     case 18: str = "10 Digit"; break;
9531     case 19: str = "11 Digit"; break;
9532     case 20: str = "12 Digit"; break;
9533     case 21: str = "13 Digit"; break;
9534     case 22: str = "14 Digit"; break;
9535     case 23: str = "15 Digit"; break;
9536     case 24: str = "Local Call"; break;
9537     case 25: str = "Intra-LATA Toll Call"; break;
9538     case 26: str = "Inter-LATA Toll Call"; break;
9539     case 27: str = "World Zone Call"; break;
9540     case 28: str = "International Call"; break;
9541     case 29: str = "Unrecognized Number"; break;
9542     case 30: str = "Prior Agreement"; break;
9543     case 31: str = "Specific Called Party Digit String"; break;
9544     case 32: str = "Mobile Termination"; break;
9545     case 33: str = "Advanced Termination"; break;
9546     case 34: str = "Location"; break;
9547     case 35: str = "Locally Allowed Specific Digit String"; break;
9548     case 36: str = "Origination Attempt Authorized"; break;
9549     case 37: str = "Calling Routing Address Available"; break;
9550     case 38: str = "Initial Termination"; break;
9551     case 39: str = "Called Routing Address Available"; break;
9552     case 40: str = "O Answer"; break;
9553     case 41: str = "O Disconnect"; break;
9554     case 42: str = "O Called Party Busy"; break;
9555     case 43: str = "O No Answer"; break;
9556     case 64: str = "Terminating Resource Available"; break;
9557     case 65: str = "T Busy"; break;
9558     case 66: str = "T No Answer"; break;
9559     case 67: str = "T No Page Response"; break;
9560     case 68: str = "T Unroutable"; break;
9561     case 69: str = "T Answer"; break;
9562     case 70: str = "T Disconnect"; break;
9563     case 220: str = "Reserved for TDP-R DP Type value"; break;
9564     case 221: str = "Reserved for TDP-N DP Type value"; break;
9565     case 222: str = "Reserved for EDP-R DP Type value"; break;
9566     case 223: str = "Reserved for EDP-N DP Type value"; break;
9567     default:
9568         if ((value >= 44) && (value <= 63)) { str = "Reserved, treat as Unspecified"; }
9569         else if ((value >= 71) && (value <= 219)) { str = "Reserved, treat as Unspecified"; }
9570         else { str = "Reserved for protocol extension, treat as Unspecified"; }
9571         break;
9572     }
9573
9574     return(str);
9575 }
9576
9577 static void
9578 param_trig_type(ASN1_SCK *asn1, proto_tree *tree, guint len)
9579 {
9580     gint32 value;
9581     guint saved_offset;
9582
9583     EXACT_DATA_CHECK(len, 1);
9584
9585     saved_offset = asn1->offset;
9586
9587     asn1_int32_value_decode(asn1, 1, &value);
9588
9589     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9590         saved_offset, asn1->offset - saved_offset,
9591         "Trigger (%d) %s",
9592         value,
9593         find_trig_type(value));
9594 }
9595
9596 static void
9597 param_win_op_cap(ASN1_SCK *asn1, proto_tree *tree, guint len)
9598 {
9599     gint32 value;
9600     guint saved_offset;
9601     gchar *str = NULL;
9602
9603     saved_offset = asn1->offset;
9604
9605     asn1_int32_value_decode(asn1, 1, &value);
9606
9607     my_decode_bitfield_value(bigbuf, value, 0xf8, 8);
9608     proto_tree_add_text(tree, asn1->tvb,
9609         saved_offset, asn1->offset - saved_offset,
9610         "%s :  Reserved",
9611         bigbuf);
9612
9613     switch ((value & 0x04) >> 2)
9614     {
9615     case 0x00: str = "Sender does not support PositionRequest OP"; break;
9616     default:
9617         str = "Sender supports PositionRequest OP";
9618         break;
9619     }
9620
9621     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
9622     proto_tree_add_text(tree, asn1->tvb,
9623         saved_offset, asn1->offset - saved_offset,
9624         "%s :  %s",
9625         bigbuf, str);
9626
9627     switch ((value & 0x02) >> 1)
9628     {
9629     case 0x00: str = "Sender does not support CallControlDirective OP"; break;
9630     default:
9631         str = "Sender supports CallControlDirective OP";
9632         break;
9633     }
9634
9635     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
9636     proto_tree_add_text(tree, asn1->tvb,
9637         saved_offset, asn1->offset - saved_offset,
9638         "%s :  %s",
9639         bigbuf, str);
9640
9641     switch (value & 0x01)
9642     {
9643     case 0x00: str = "Sender does not support ConnectResource, DisconnectResource, ConnectionFailureReport and ResetTimer (SSFT timer) OPs"; break;
9644     default:
9645         str = "Sender supports ConnectResource, DisconnectResource, ConnectionFailureReport and ResetTimer (SSFT timer) OPs";
9646         break;
9647     }
9648
9649     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
9650     proto_tree_add_text(tree, asn1->tvb,
9651         saved_offset, asn1->offset - saved_offset,
9652         "%s :  %s",
9653         bigbuf, str);
9654
9655     EXTRANEOUS_DATA_CHECK(len, 1);
9656 }
9657
9658 static void
9659 param_win_trig_list(ASN1_SCK *asn1, proto_tree *tree, guint len)
9660 {
9661     gint32 value, i, j;
9662     guint saved_offset;
9663
9664     saved_offset = asn1->offset;
9665
9666     j = 0;
9667     i = 0;
9668
9669     do
9670     {
9671         asn1_int32_value_decode(asn1, 1, &value);
9672
9673         switch (value)
9674         {
9675         case 0xdc:
9676             proto_tree_add_text(tree, asn1->tvb,
9677                 saved_offset, asn1->offset - saved_offset,
9678                 "TDP-R's armed");
9679
9680             j = 0;
9681             break;
9682
9683         case 0xdd:
9684             proto_tree_add_text(tree, asn1->tvb,
9685                 saved_offset, asn1->offset - saved_offset,
9686                 "TDP-N's armed");
9687
9688             j = 0;
9689             break;
9690
9691         case 0xde:
9692             proto_tree_add_text(tree, asn1->tvb,
9693                 saved_offset, asn1->offset - saved_offset,
9694                 "EDP-R's armed");
9695
9696             j = 0;
9697             break;
9698
9699         case 0xdf:
9700             proto_tree_add_text(tree, asn1->tvb,
9701                 saved_offset, asn1->offset - saved_offset,
9702                 "EDP-N's armed");
9703
9704             j = 0;
9705             break;
9706
9707         default:
9708             proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
9709                 saved_offset, asn1->offset - saved_offset,
9710                 "[%d] (%d) %s",
9711                 j,
9712                 value,
9713                 find_trig_type(value));
9714             j++;
9715             break;
9716         }
9717
9718         saved_offset = asn1->offset;
9719         i++;
9720     }
9721     while ((len - i) > 0);
9722 }
9723
9724 static void
9725 param_trans_cap(ASN1_SCK *asn1, proto_tree *tree, guint len)
9726 {
9727     gint32 value;
9728     guint saved_offset;
9729     gchar *str = NULL;
9730     char *p;
9731
9732     saved_offset = asn1->offset;
9733
9734     asn1_int32_value_decode(asn1, 1, &value);
9735
9736     switch ((value & 0x80) >> 7)
9737     {
9738     case 0x00: str = "System is not capable of supporting CNAP/CNAR (NAMI)"; break;
9739     default:
9740         str = "System is capable of supporting CNAP/CNAR (NAMI)";
9741         break;
9742     }
9743
9744     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
9745     proto_tree_add_text(tree, asn1->tvb,
9746         saved_offset, asn1->offset - saved_offset,
9747         "%s :  %s",
9748         bigbuf, str);
9749
9750     switch ((value & 0x40) >> 6)
9751     {
9752     case 0x00: str = "System is not capable of supporting NDSS"; break;
9753     default:
9754         str = "System is capable of supporting NDSS";
9755         break;
9756     }
9757
9758     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
9759     proto_tree_add_text(tree, asn1->tvb,
9760         saved_offset, asn1->offset - saved_offset,
9761         "%s :  %s",
9762         bigbuf, str);
9763
9764     switch ((value & 0x20) >> 5)
9765     {
9766     case 0x00: str = "System is not capable of supporting User Zones (UZCI)"; break;
9767     default:
9768         str = "System is capable of supporting User Zones (UZCI)";
9769         break;
9770     }
9771
9772     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
9773     proto_tree_add_text(tree, asn1->tvb,
9774         saved_offset, asn1->offset - saved_offset,
9775         "%s :  %s",
9776         bigbuf, str);
9777
9778     switch ((value & 0x10) >> 4)
9779     {
9780     case 0x00: str = "System is not capable of supporting local SPINI"; break;
9781     default:
9782         str = "System is capable of supporting local SPINI";
9783         break;
9784     }
9785
9786     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
9787     proto_tree_add_text(tree, asn1->tvb,
9788         saved_offset, asn1->offset - saved_offset,
9789         "%s :  %s",
9790         bigbuf, str);
9791
9792     switch ((value & 0x08) >> 3)
9793     {
9794     case 0x00: str = "System is not capable of interacting with the user (RUI)"; break;
9795     default:
9796         str = "System is capable of interacting with the user (RUI)";
9797         break;
9798     }
9799
9800     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
9801     proto_tree_add_text(tree, asn1->tvb,
9802         saved_offset, asn1->offset - saved_offset,
9803         "%s :  %s",
9804         bigbuf, str);
9805
9806     switch ((value & 0x04) >> 2)
9807     {
9808     case 0x00: str = "System is not capable of honoring the Announcement List parameter (ANN)"; break;
9809     default:
9810         str = "System is capable of honoring the Announcement List parameter (ANN)";
9811         break;
9812     }
9813
9814     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
9815     proto_tree_add_text(tree, asn1->tvb,
9816         saved_offset, asn1->offset - saved_offset,
9817         "%s :  %s",
9818         bigbuf, str);
9819
9820     switch ((value & 0x02) >> 1)
9821     {
9822     case 0x00: str = "System is not capable of detecting a busy condition (BUSY)"; break;
9823     default:
9824         str = "System is capable of detecting a busy condition (BUSY)";
9825         break;
9826     }
9827
9828     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
9829     proto_tree_add_text(tree, asn1->tvb,
9830         saved_offset, asn1->offset - saved_offset,
9831         "%s :  %s",
9832         bigbuf, str);
9833
9834     switch (value & 0x01)
9835     {
9836     case 0x00: str = "System is not capable of supporting the IS-41-C profile parameter (PROFILE)"; break;
9837     default:
9838         str = "System is capable of supporting the IS-41-C profile parameter (PROFILE)";
9839         break;
9840     }
9841
9842     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
9843     proto_tree_add_text(tree, asn1->tvb,
9844         saved_offset, asn1->offset - saved_offset,
9845         "%s :  %s",
9846         bigbuf, str);
9847
9848     if (len == 1) return;
9849
9850     saved_offset = asn1->offset;
9851
9852     asn1_int32_value_decode(asn1, 1, &value);
9853
9854     switch ((value & 0x80) >> 7)
9855     {
9856     case 0x00: str = "System is not capable of supporting the CDMA Over the Air Parameter Administration"; break;
9857     default:
9858         str = "System is capable of supporting the CDMA Over the Air Parameter Administration";
9859         break;
9860     }
9861
9862     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
9863     proto_tree_add_text(tree, asn1->tvb,
9864         saved_offset, asn1->offset - saved_offset,
9865         "%s :  %s",
9866         bigbuf, str);
9867
9868     switch ((value & 0x40) >> 6)
9869     {
9870     case 0x00: str = "System is not capable of supporting lower layer segmentation & reassembly (S&R)"; break;
9871     default:
9872         str = "System is capable of supporting lower layer segmentation & reassembly (S&R)";
9873         break;
9874     }
9875
9876     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
9877     proto_tree_add_text(tree, asn1->tvb,
9878         saved_offset, asn1->offset - saved_offset,
9879         "%s :  %s",
9880         bigbuf, str);
9881
9882     switch ((value & 0x20) >> 5)
9883     {
9884     case 0x00: str = "System is not capable of supporting the Trigger Address List parameter (WADDR)"; break;
9885     default:
9886         str = "System is capable of supporting the Trigger Address List parameter (WADDR)";
9887         break;
9888     }
9889
9890     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
9891     proto_tree_add_text(tree, asn1->tvb,
9892         saved_offset, asn1->offset - saved_offset,
9893         "%s :  %s",
9894         bigbuf, str);
9895
9896     switch ((value & 0x10) >> 4)
9897     {
9898     case 0x00: str = "System is not capable of supporting the Termination List parameter (TL)"; break;
9899     default:
9900         str = "System is capable of supporting the Termination List parameter (TL)";
9901         break;
9902     }
9903
9904     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
9905     proto_tree_add_text(tree, asn1->tvb,
9906         saved_offset, asn1->offset - saved_offset,
9907         "%s :  %s",
9908         bigbuf, str);
9909
9910     p = my_decode_bitfield_value(bigbuf, value, 0x0f, 8);
9911     switch (value & 0x0f)
9912     {
9913     case 0x00: strcat(p, " :  System cannot accept a termination at this time"); break;
9914     default:
9915         sprintf(p, " :  System supports %d call leg(s)", value & 0x0f);
9916         break;
9917     }
9918
9919     proto_tree_add_text(tree, asn1->tvb,
9920         saved_offset, asn1->offset - saved_offset,
9921         "%s",
9922         bigbuf);
9923
9924     if (len == 2) return;
9925
9926     saved_offset = asn1->offset;
9927
9928     asn1_int32_value_decode(asn1, 1, &value);
9929
9930     my_decode_bitfield_value(bigbuf, value, 0xf8, 8);
9931     proto_tree_add_text(tree, asn1->tvb,
9932         saved_offset, asn1->offset - saved_offset,
9933         "%s :  Reserved",
9934         bigbuf);
9935
9936     switch ((value & 0x04) >> 2)
9937     {
9938     case 0x00: str = "The system is not capable of supporting external MAHO requests"; break;
9939     default:
9940         str = "The system is capable of supporting external MAHO requests (e.g. for positioning)";
9941         break;
9942     }
9943
9944     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
9945     proto_tree_add_text(tree, asn1->tvb,
9946         saved_offset, asn1->offset - saved_offset,
9947         "%s :  %s",
9948         bigbuf, str);
9949
9950     my_decode_bitfield_value(bigbuf, value, 0x03, 8);
9951     proto_tree_add_text(tree, asn1->tvb,
9952         saved_offset, asn1->offset - saved_offset,
9953         "%s :  Reserved",
9954         bigbuf);
9955
9956     EXTRANEOUS_DATA_CHECK(len, 3);
9957 }
9958
9959 static void
9960 param_spini_trig(ASN1_SCK *asn1, proto_tree *tree, guint len)
9961 {
9962     gint32 value;
9963     guint saved_offset;
9964     gchar *str = NULL;
9965
9966     SHORT_DATA_CHECK(len, 4);
9967
9968     saved_offset = asn1->offset;
9969
9970     asn1_int32_value_decode(asn1, 1, &value);
9971
9972     switch ((value & 0x80) >> 7)
9973     {
9974     case 0x00: str = "Trigger is not active"; break;
9975     default:
9976         str = "Execute local SPINI procedures for any Revertive Call attempt"; break;
9977         break;
9978     }
9979
9980     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
9981     proto_tree_add_text(tree, asn1->tvb,
9982         saved_offset, asn1->offset - saved_offset,
9983         "%s :  Revertive Call (RvtC), %s",
9984         bigbuf, str);
9985
9986     switch ((value & 0x40) >> 6)
9987     {
9988     case 0x00: str = "Trigger is not active"; break;
9989     default:
9990         str = "Execute local SPINI procedures for any call attempt to an unrecognized number"; break;
9991         break;
9992     }
9993
9994     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
9995     proto_tree_add_text(tree, asn1->tvb,
9996         saved_offset, asn1->offset - saved_offset,
9997         "%s :  Unrecognized Number (Unrec), %s",
9998         bigbuf, str);
9999
10000     switch ((value & 0x20) >> 5)
10001     {
10002     case 0x00: str = "Trigger is not active"; break;
10003     default:
10004         str = "Execute local SPINI procedures for any call attempt outside of the current World Zone (as defined in ITU-T Rec. E.164)";
10005         break;
10006     }
10007
10008     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
10009     proto_tree_add_text(tree, asn1->tvb,
10010         saved_offset, asn1->offset - saved_offset,
10011         "%s :  World Zone (WZ), %s",
10012         bigbuf, str);
10013
10014     switch ((value & 0x10) >> 4)
10015     {
10016     case 0x00: str = "Trigger is not active"; break;
10017     default:
10018         str = "Execute local SPINI procedures for any international call attempt";
10019         break;
10020     }
10021
10022     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
10023     proto_tree_add_text(tree, asn1->tvb,
10024         saved_offset, asn1->offset - saved_offset,
10025         "%s :  International (Intl), %s",
10026         bigbuf, str);
10027
10028     switch ((value & 0x08) >> 3)
10029     {
10030     case 0x00: str = "Trigger is not active"; break;
10031     default:
10032         str = "Execute local SPINI procedures for any toll calls outside the local carrier's serving area";
10033         break;
10034     }
10035
10036     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
10037     proto_tree_add_text(tree, asn1->tvb,
10038         saved_offset, asn1->offset - saved_offset,
10039         "%s :  Non-Local (Inter-LATA) Toll (NLTOLL/OLATA), %s",
10040         bigbuf, str);
10041
10042     switch ((value & 0x04) >> 2)
10043     {
10044     case 0x00: str = "Trigger is not active"; break;
10045     default:
10046         str = "Execute local SPINI procedures for any local toll call attempt.  Refers to intra-LATA toll within the NANP";
10047         break;
10048     }
10049
10050     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
10051     proto_tree_add_text(tree, asn1->tvb,
10052         saved_offset, asn1->offset - saved_offset,
10053         "%s :  Local (Intra-LATA) Toll (LTOLL/ILATA), %s",
10054         bigbuf, str);
10055
10056     switch ((value & 0x02) >> 1)
10057     {
10058     case 0x00: str = "Trigger is not active"; break;
10059     default:
10060         str = "Execute local SPINI procedures for any local call attempt";
10061         break;
10062     }
10063
10064     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
10065     proto_tree_add_text(tree, asn1->tvb,
10066         saved_offset, asn1->offset - saved_offset,
10067         "%s :  Local, %s",
10068         bigbuf, str);
10069
10070     switch (value & 0x01)
10071     {
10072     case 0x00: str = "Trigger is not active"; break;
10073     default:
10074         str = "Execute local SPINI procedures for any call attempt. This overrides all other values.";
10075         break;
10076     }
10077
10078     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
10079     proto_tree_add_text(tree, asn1->tvb,
10080         saved_offset, asn1->offset - saved_offset,
10081         "%s :  All Origination (All), %s",
10082         bigbuf, str);
10083
10084     saved_offset = asn1->offset;
10085
10086     asn1_int32_value_decode(asn1, 1, &value);
10087
10088     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
10089     proto_tree_add_text(tree, asn1->tvb,
10090         saved_offset, asn1->offset - saved_offset,
10091         "%s :  Reserved",
10092         bigbuf);
10093
10094     switch ((value & 0x10) >> 4)
10095     {
10096     case 0x00: str = "Trigger is not active"; break;
10097     default:
10098         str = "Execute local SPINI procedures for any number matching a criteria of a prior agreement";
10099         break;
10100     }
10101
10102     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
10103     proto_tree_add_text(tree, asn1->tvb,
10104         saved_offset, asn1->offset - saved_offset,
10105         "%s :  Prior Agreement (PA), %s",
10106         bigbuf, str);
10107
10108     switch ((value & 0x08) >> 3)
10109     {
10110     case 0x00: str = "Trigger is not active"; break;
10111     default:
10112         str = "Execute local SPINI procedures for any number beginning with two Pound ## digits";
10113         break;
10114     }
10115
10116     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
10117     proto_tree_add_text(tree, asn1->tvb,
10118         saved_offset, asn1->offset - saved_offset,
10119         "%s :  Double Pound (DP), %s",
10120         bigbuf, str);
10121
10122     switch ((value & 0x04) >> 2)
10123     {
10124     case 0x00: str = "Trigger is not active"; break;
10125     default:
10126         str = "Execute local SPINI procedures for any number beginning with a Pound # digit";
10127         break;
10128     }
10129
10130     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
10131     proto_tree_add_text(tree, asn1->tvb,
10132         saved_offset, asn1->offset - saved_offset,
10133         "%s :  Pound, %s",
10134         bigbuf, str);
10135
10136     switch ((value & 0x02) >> 1)
10137     {
10138     case 0x00: str = "Trigger is not active"; break;
10139     default:
10140         str = "Execute local SPINI procedures for any number beginning with two Star ** digits";
10141         break;
10142     }
10143
10144     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
10145     proto_tree_add_text(tree, asn1->tvb,
10146         saved_offset, asn1->offset - saved_offset,
10147         "%s :  Double Star (DS), %s",
10148         bigbuf, str);
10149
10150     switch (value & 0x01)
10151     {
10152     case 0x00: str = "Trigger is not active"; break;
10153     default:
10154         str = "Execute local SPINI procedures for any number beginning with a Star * digit";
10155         break;
10156     }
10157
10158     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
10159     proto_tree_add_text(tree, asn1->tvb,
10160         saved_offset, asn1->offset - saved_offset,
10161         "%s :  Star, %s",
10162         bigbuf, str);
10163
10164     saved_offset = asn1->offset;
10165
10166     asn1_int32_value_decode(asn1, 1, &value);
10167
10168     switch ((value & 0x80) >> 7)
10169     {
10170     case 0x00: str = "Trigger is not active"; break;
10171     default:
10172         str = "Execute local SPINI procedures for any call attempt with 7 digits";
10173         break;
10174     }
10175
10176     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
10177     proto_tree_add_text(tree, asn1->tvb,
10178         saved_offset, asn1->offset - saved_offset,
10179         "%s :  7 digits, %s",
10180         bigbuf, str);
10181
10182     switch ((value & 0x40) >> 6)
10183     {
10184     case 0x00: str = "Trigger is not active"; break;
10185     default:
10186         str = "Execute local SPINI procedures for any call attempt with 6 digits";
10187         break;
10188     }
10189
10190     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
10191     proto_tree_add_text(tree, asn1->tvb,
10192         saved_offset, asn1->offset - saved_offset,
10193         "%s :  6 digits, %s",
10194         bigbuf, str);
10195
10196     switch ((value & 0x20) >> 5)
10197     {
10198     case 0x00: str = "Trigger is not active"; break;
10199     default:
10200         str = "Execute local SPINI procedures for any call attempt with 5 digits";
10201         break;
10202     }
10203
10204     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
10205     proto_tree_add_text(tree, asn1->tvb,
10206         saved_offset, asn1->offset - saved_offset,
10207         "%s :  5 digits, %s",
10208         bigbuf, str);
10209
10210     switch ((value & 0x10) >> 4)
10211     {
10212     case 0x00: str = "Trigger is not active"; break;
10213     default:
10214         str = "Execute local SPINI procedures for any call attempt with 4 digits";
10215         break;
10216     }
10217
10218     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
10219     proto_tree_add_text(tree, asn1->tvb,
10220         saved_offset, asn1->offset - saved_offset,
10221         "%s :  4 digits, %s",
10222         bigbuf, str);
10223
10224     switch ((value & 0x08) >> 3)
10225     {
10226     case 0x00: str = "Trigger is not active"; break;
10227     default:
10228         str = "Execute local SPINI procedures for any call attempt with 3 digits";
10229         break;
10230     }
10231
10232     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
10233     proto_tree_add_text(tree, asn1->tvb,
10234         saved_offset, asn1->offset - saved_offset,
10235         "%s :  3 digits, %s",
10236         bigbuf, str);
10237
10238     switch ((value & 0x04) >> 2)
10239     {
10240     case 0x00: str = "Trigger is not active"; break;
10241     default:
10242         str = "Execute local SPINI procedures for any call attempt with 2 digits";
10243         break;
10244     }
10245
10246     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
10247     proto_tree_add_text(tree, asn1->tvb,
10248         saved_offset, asn1->offset - saved_offset,
10249         "%s :  2 digits, %s",
10250         bigbuf, str);
10251
10252     switch ((value & 0x02) >> 1)
10253     {
10254     case 0x00: str = "Trigger is not active"; break;
10255     default:
10256         str = "Execute local SPINI procedures for any call attempt with 1 digits";
10257         break;
10258     }
10259
10260     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
10261     proto_tree_add_text(tree, asn1->tvb,
10262         saved_offset, asn1->offset - saved_offset,
10263         "%s :  1 digits, %s",
10264         bigbuf, str);
10265
10266     switch (value & 0x01)
10267     {
10268     case 0x00: str = "Trigger is not active"; break;
10269     default:
10270         str = "Execute local SPINI procedures for any call attempt with no digits";
10271         break;
10272     }
10273
10274     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
10275     proto_tree_add_text(tree, asn1->tvb,
10276         saved_offset, asn1->offset - saved_offset,
10277         "%s :  No digits, %s",
10278         bigbuf, str);
10279
10280     saved_offset = asn1->offset;
10281
10282     asn1_int32_value_decode(asn1, 1, &value);
10283
10284     switch ((value & 0x80) >> 7)
10285     {
10286     case 0x00: str = "Trigger is not active"; break;
10287     default:
10288         str = "Execute local SPINI procedures for any call attempt with 15 or more digits";
10289         break;
10290     }
10291
10292     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
10293     proto_tree_add_text(tree, asn1->tvb,
10294         saved_offset, asn1->offset - saved_offset,
10295         "%s :  15 digits, %s",
10296         bigbuf, str);
10297
10298     switch ((value & 0x40) >> 6)
10299     {
10300     case 0x00: str = "Trigger is not active"; break;
10301     default:
10302         str = "Execute local SPINI procedures for any call attempt with 14 digits";
10303         break;
10304     }
10305
10306     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
10307     proto_tree_add_text(tree, asn1->tvb,
10308         saved_offset, asn1->offset - saved_offset,
10309         "%s :  14 digits, %s",
10310         bigbuf, str);
10311
10312     switch ((value & 0x20) >> 5)
10313     {
10314     case 0x00: str = "Trigger is not active"; break;
10315     default:
10316         str = "Execute local SPINI procedures for any call attempt with 13 digits";
10317         break;
10318     }
10319
10320     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
10321     proto_tree_add_text(tree, asn1->tvb,
10322         saved_offset, asn1->offset - saved_offset,
10323         "%s :  13 digits, %s",
10324         bigbuf, str);
10325
10326     switch ((value & 0x10) >> 4)
10327     {
10328     case 0x00: str = "Trigger is not active"; break;
10329     default:
10330         str = "Execute local SPINI procedures for any call attempt with 12 digits";
10331         break;
10332     }
10333
10334     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
10335     proto_tree_add_text(tree, asn1->tvb,
10336         saved_offset, asn1->offset - saved_offset,
10337         "%s :  12 digits, %s",
10338         bigbuf, str);
10339
10340     switch ((value & 0x08) >> 3)
10341     {
10342     case 0x00: str = "Trigger is not active"; break;
10343     default:
10344         str = "Execute local SPINI procedures for any call attempt with 11 digits";
10345         break;
10346     }
10347
10348     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
10349     proto_tree_add_text(tree, asn1->tvb,
10350         saved_offset, asn1->offset - saved_offset,
10351         "%s :  11 digits, %s",
10352         bigbuf, str);
10353
10354     switch ((value & 0x04) >> 2)
10355     {
10356     case 0x00: str = "Trigger is not active"; break;
10357     default:
10358         str = "Execute local SPINI procedures for any call attempt with 10 digits";
10359         break;
10360     }
10361
10362     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
10363     proto_tree_add_text(tree, asn1->tvb,
10364         saved_offset, asn1->offset - saved_offset,
10365         "%s :  10 digits, %s",
10366         bigbuf, str);
10367
10368     switch ((value & 0x02) >> 1)
10369     {
10370     case 0x00: str = "Trigger is not active"; break;
10371     default:
10372         str = "Execute local SPINI procedures for any call attempt with 9 digits";
10373         break;
10374     }
10375
10376     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
10377     proto_tree_add_text(tree, asn1->tvb,
10378         saved_offset, asn1->offset - saved_offset,
10379         "%s :  9 digits, %s",
10380         bigbuf, str);
10381
10382     switch (value & 0x01)
10383     {
10384     case 0x00: str = "Trigger is not active"; break;
10385     default:
10386         str = "Execute local SPINI procedures for any call attempt with 8 digits";
10387         break;
10388     }
10389
10390     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
10391     proto_tree_add_text(tree, asn1->tvb,
10392         saved_offset, asn1->offset - saved_offset,
10393         "%s :  8 digits, %s",
10394         bigbuf, str);
10395
10396     EXTRANEOUS_DATA_CHECK(len, 4);
10397 }
10398
10399 static void
10400 param_orig_trig(ASN1_SCK *asn1, proto_tree *tree, guint len)
10401 {
10402     gint32 value;
10403     guint saved_offset;
10404     gchar *str = NULL;
10405
10406     SHORT_DATA_CHECK(len, 4);
10407
10408     saved_offset = asn1->offset;
10409
10410     asn1_int32_value_decode(asn1, 1, &value);
10411
10412     switch ((value & 0x80) >> 7)
10413     {
10414     case 0x00: str = "Trigger is not active"; break;
10415     default:
10416         str = "Launch an Origination Request for any Revertive Call attempt"; break;
10417         break;
10418     }
10419
10420     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
10421     proto_tree_add_text(tree, asn1->tvb,
10422         saved_offset, asn1->offset - saved_offset,
10423         "%s :  Revertive Call (RvtC), %s",
10424         bigbuf, str);
10425
10426     switch ((value & 0x40) >> 6)
10427     {
10428     case 0x00: str = "Trigger is not active"; break;
10429     default:
10430         str = "Launch an Origination Request for any call attempt to an unrecognized number"; break;
10431         break;
10432     }
10433
10434     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
10435     proto_tree_add_text(tree, asn1->tvb,
10436         saved_offset, asn1->offset - saved_offset,
10437         "%s :  Unrecognized Number (Unrec), %s",
10438         bigbuf, str);
10439
10440     switch ((value & 0x20) >> 5)
10441     {
10442     case 0x00: str = "Trigger is not active"; break;
10443     default:
10444         str = "Launch an Origination Request for any call attempt outside of the current World Zone (as defined in ITU-T Rec. E.164)";
10445         break;
10446     }
10447
10448     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
10449     proto_tree_add_text(tree, asn1->tvb,
10450         saved_offset, asn1->offset - saved_offset,
10451         "%s :  World Zone (WZ), %s",
10452         bigbuf, str);
10453
10454     switch ((value & 0x10) >> 4)
10455     {
10456     case 0x00: str = "Trigger is not active"; break;
10457     default:
10458         str = "Launch an Origination Request for any international call attempt";
10459         break;
10460     }
10461
10462     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
10463     proto_tree_add_text(tree, asn1->tvb,
10464         saved_offset, asn1->offset - saved_offset,
10465         "%s :  International (Intl), %s",
10466         bigbuf, str);
10467
10468     switch ((value & 0x08) >> 3)
10469     {
10470     case 0x00: str = "Trigger is not active"; break;
10471     default:
10472         str = "Launch an Origination Request for any toll calls outside the local carrier's serving area";
10473         break;
10474     }
10475
10476     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
10477     proto_tree_add_text(tree, asn1->tvb,
10478         saved_offset, asn1->offset - saved_offset,
10479         "%s :  Non-Local (Inter-LATA) Toll (NLTOLL/OLATA), %s",
10480         bigbuf, str);
10481
10482     switch ((value & 0x04) >> 2)
10483     {
10484     case 0x00: str = "Trigger is not active"; break;
10485     default:
10486         str = "Launch an Origination Request for any local toll call attempt.  Refers to intra-LATA toll within the NANP";
10487         break;
10488     }
10489
10490     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
10491     proto_tree_add_text(tree, asn1->tvb,
10492         saved_offset, asn1->offset - saved_offset,
10493         "%s :  Local (Intra-LATA) Toll (LTOLL/ILATA), %s",
10494         bigbuf, str);
10495
10496     switch ((value & 0x02) >> 1)
10497     {
10498     case 0x00: str = "Trigger is not active"; break;
10499     default:
10500         str = "Launch an Origination Request for any local call attempt";
10501         break;
10502     }
10503
10504     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
10505     proto_tree_add_text(tree, asn1->tvb,
10506         saved_offset, asn1->offset - saved_offset,
10507         "%s :  Local, %s",
10508         bigbuf, str);
10509
10510     switch (value & 0x01)
10511     {
10512     case 0x00: str = "Trigger is not active"; break;
10513     default:
10514         str = "Launch an Origination Request for any call attempt. This overrides all other values.";
10515         break;
10516     }
10517
10518     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
10519     proto_tree_add_text(tree, asn1->tvb,
10520         saved_offset, asn1->offset - saved_offset,
10521         "%s :  All Origination (All), %s",
10522         bigbuf, str);
10523
10524     saved_offset = asn1->offset;
10525
10526     asn1_int32_value_decode(asn1, 1, &value);
10527
10528     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
10529     proto_tree_add_text(tree, asn1->tvb,
10530         saved_offset, asn1->offset - saved_offset,
10531         "%s :  Reserved",
10532         bigbuf);
10533
10534     switch ((value & 0x10) >> 4)
10535     {
10536     case 0x00: str = "Trigger is not active"; break;
10537     default:
10538         str = "Launch an Origination Request for any number matching a criteria of a prior agreement";
10539         break;
10540     }
10541
10542     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
10543     proto_tree_add_text(tree, asn1->tvb,
10544         saved_offset, asn1->offset - saved_offset,
10545         "%s :  Prior Agreement (PA), %s",
10546         bigbuf, str);
10547
10548     switch ((value & 0x08) >> 3)
10549     {
10550     case 0x00: str = "Trigger is not active"; break;
10551     default:
10552         str = "Launch an Origination Request for any number beginning with two Pound ## digits";
10553         break;
10554     }
10555
10556     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
10557     proto_tree_add_text(tree, asn1->tvb,
10558         saved_offset, asn1->offset - saved_offset,
10559         "%s :  Double Pound (DP), %s",
10560         bigbuf, str);
10561
10562     switch ((value & 0x04) >> 2)
10563     {
10564     case 0x00: str = "Trigger is not active"; break;
10565     default:
10566         str = "Launch an Origination Request for any number beginning with a Pound # digit";
10567         break;
10568     }
10569
10570     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
10571     proto_tree_add_text(tree, asn1->tvb,
10572         saved_offset, asn1->offset - saved_offset,
10573         "%s :  Pound, %s",
10574         bigbuf, str);
10575
10576     switch ((value & 0x02) >> 1)
10577     {
10578     case 0x00: str = "Trigger is not active"; break;
10579     default:
10580         str = "Launch an Origination Request for any number beginning with two Star ** digits";
10581         break;
10582     }
10583
10584     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
10585     proto_tree_add_text(tree, asn1->tvb,
10586         saved_offset, asn1->offset - saved_offset,
10587         "%s :  Double Star (DS), %s",
10588         bigbuf, str);
10589
10590     switch (value & 0x01)
10591     {
10592     case 0x00: str = "Trigger is not active"; break;
10593     default:
10594         str = "Launch an Origination Request for any number beginning with a Star * digit";
10595         break;
10596     }
10597
10598     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
10599     proto_tree_add_text(tree, asn1->tvb,
10600         saved_offset, asn1->offset - saved_offset,
10601         "%s :  Star, %s",
10602         bigbuf, str);
10603
10604     saved_offset = asn1->offset;
10605
10606     asn1_int32_value_decode(asn1, 1, &value);
10607
10608     switch ((value & 0x80) >> 7)
10609     {
10610     case 0x00: str = "Trigger is not active"; break;
10611     default:
10612         str = "Launch an Origination Request for any call attempt with 7 digits";
10613         break;
10614     }
10615
10616     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
10617     proto_tree_add_text(tree, asn1->tvb,
10618         saved_offset, asn1->offset - saved_offset,
10619         "%s :  7 digits, %s",
10620         bigbuf, str);
10621
10622     switch ((value & 0x40) >> 6)
10623     {
10624     case 0x00: str = "Trigger is not active"; break;
10625     default:
10626         str = "Launch an Origination Request for any call attempt with 6 digits";
10627         break;
10628     }
10629
10630     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
10631     proto_tree_add_text(tree, asn1->tvb,
10632         saved_offset, asn1->offset - saved_offset,
10633         "%s :  6 digits, %s",
10634         bigbuf, str);
10635
10636     switch ((value & 0x20) >> 5)
10637     {
10638     case 0x00: str = "Trigger is not active"; break;
10639     default:
10640         str = "Launch an Origination Request for any call attempt with 5 digits";
10641         break;
10642     }
10643
10644     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
10645     proto_tree_add_text(tree, asn1->tvb,
10646         saved_offset, asn1->offset - saved_offset,
10647         "%s :  5 digits, %s",
10648         bigbuf, str);
10649
10650     switch ((value & 0x10) >> 4)
10651     {
10652     case 0x00: str = "Trigger is not active"; break;
10653     default:
10654         str = "Launch an Origination Request for any call attempt with 4 digits";
10655         break;
10656     }
10657
10658     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
10659     proto_tree_add_text(tree, asn1->tvb,
10660         saved_offset, asn1->offset - saved_offset,
10661         "%s :  4 digits, %s",
10662         bigbuf, str);
10663
10664     switch ((value & 0x08) >> 3)
10665     {
10666     case 0x00: str = "Trigger is not active"; break;
10667     default:
10668         str = "Launch an Origination Request for any call attempt with 3 digits";
10669         break;
10670     }
10671
10672     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
10673     proto_tree_add_text(tree, asn1->tvb,
10674         saved_offset, asn1->offset - saved_offset,
10675         "%s :  3 digits, %s",
10676         bigbuf, str);
10677
10678     switch ((value & 0x04) >> 2)
10679     {
10680     case 0x00: str = "Trigger is not active"; break;
10681     default:
10682         str = "Launch an Origination Request for any call attempt with 2 digits";
10683         break;
10684     }
10685
10686     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
10687     proto_tree_add_text(tree, asn1->tvb,
10688         saved_offset, asn1->offset - saved_offset,
10689         "%s :  2 digits, %s",
10690         bigbuf, str);
10691
10692     switch ((value & 0x02) >> 1)
10693     {
10694     case 0x00: str = "Trigger is not active"; break;
10695     default:
10696         str = "Launch an Origination Request for any call attempt with 1 digits";
10697         break;
10698     }
10699
10700     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
10701     proto_tree_add_text(tree, asn1->tvb,
10702         saved_offset, asn1->offset - saved_offset,
10703         "%s :  1 digits, %s",
10704         bigbuf, str);
10705
10706     switch (value & 0x01)
10707     {
10708     case 0x00: str = "Trigger is not active"; break;
10709     default:
10710         str = "Launch an Origination Request for any call attempt with no digits";
10711         break;
10712     }
10713
10714     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
10715     proto_tree_add_text(tree, asn1->tvb,
10716         saved_offset, asn1->offset - saved_offset,
10717         "%s :  No digits, %s",
10718         bigbuf, str);
10719
10720     saved_offset = asn1->offset;
10721
10722     asn1_int32_value_decode(asn1, 1, &value);
10723
10724     switch ((value & 0x80) >> 7)
10725     {
10726     case 0x00: str = "Trigger is not active"; break;
10727     default:
10728         str = "Launch an Origination Request for any call attempt with 15 or more digits";
10729         break;
10730     }
10731
10732     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
10733     proto_tree_add_text(tree, asn1->tvb,
10734         saved_offset, asn1->offset - saved_offset,
10735         "%s :  15 digits, %s",
10736         bigbuf, str);
10737
10738     switch ((value & 0x40) >> 6)
10739     {
10740     case 0x00: str = "Trigger is not active"; break;
10741     default:
10742         str = "Launch an Origination Request for any call attempt with 14 digits";
10743         break;
10744     }
10745
10746     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
10747     proto_tree_add_text(tree, asn1->tvb,
10748         saved_offset, asn1->offset - saved_offset,
10749         "%s :  14 digits, %s",
10750         bigbuf, str);
10751
10752     switch ((value & 0x20) >> 5)
10753     {
10754     case 0x00: str = "Trigger is not active"; break;
10755     default:
10756         str = "Launch an Origination Request for any call attempt with 13 digits";
10757         break;
10758     }
10759
10760     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
10761     proto_tree_add_text(tree, asn1->tvb,
10762         saved_offset, asn1->offset - saved_offset,
10763         "%s :  13 digits, %s",
10764         bigbuf, str);
10765
10766     switch ((value & 0x10) >> 4)
10767     {
10768     case 0x00: str = "Trigger is not active"; break;
10769     default:
10770         str = "Launch an Origination Request for any call attempt with 12 digits";
10771         break;
10772     }
10773
10774     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
10775     proto_tree_add_text(tree, asn1->tvb,
10776         saved_offset, asn1->offset - saved_offset,
10777         "%s :  12 digits, %s",
10778         bigbuf, str);
10779
10780     switch ((value & 0x08) >> 3)
10781     {
10782     case 0x00: str = "Trigger is not active"; break;
10783     default:
10784         str = "Launch an Origination Request for any call attempt with 11 digits";
10785         break;
10786     }
10787
10788     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
10789     proto_tree_add_text(tree, asn1->tvb,
10790         saved_offset, asn1->offset - saved_offset,
10791         "%s :  11 digits, %s",
10792         bigbuf, str);
10793
10794     switch ((value & 0x04) >> 2)
10795     {
10796     case 0x00: str = "Trigger is not active"; break;
10797     default:
10798         str = "Launch an Origination Request for any call attempt with 10 digits";
10799         break;
10800     }
10801
10802     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
10803     proto_tree_add_text(tree, asn1->tvb,
10804         saved_offset, asn1->offset - saved_offset,
10805         "%s :  10 digits, %s",
10806         bigbuf, str);
10807
10808     switch ((value & 0x02) >> 1)
10809     {
10810     case 0x00: str = "Trigger is not active"; break;
10811     default:
10812         str = "Launch an Origination Request for any call attempt with 9 digits";
10813         break;
10814     }
10815
10816     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
10817     proto_tree_add_text(tree, asn1->tvb,
10818         saved_offset, asn1->offset - saved_offset,
10819         "%s :  9 digits, %s",
10820         bigbuf, str);
10821
10822     switch (value & 0x01)
10823     {
10824     case 0x00: str = "Trigger is not active"; break;
10825     default:
10826         str = "Launch an Origination Request for any call attempt with 8 digits";
10827         break;
10828     }
10829
10830     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
10831     proto_tree_add_text(tree, asn1->tvb,
10832         saved_offset, asn1->offset - saved_offset,
10833         "%s :  8 digits, %s",
10834         bigbuf, str);
10835
10836     EXTRANEOUS_DATA_CHECK(len, 4);
10837 }
10838
10839 static void
10840 param_trig_cap(ASN1_SCK *asn1, proto_tree *tree, guint len)
10841 {
10842     gint32 value;
10843     guint saved_offset;
10844     gchar *str = NULL;
10845
10846     saved_offset = asn1->offset;
10847
10848     asn1_int32_value_decode(asn1, 1, &value);
10849
10850     switch ((value & 0x80) >> 7)
10851     {
10852     case 0x00: str = "O No Answer (ONA) cannot be armed"; break;
10853     default:
10854         str = "O No Answer (ONA) can be armed";
10855         break;
10856     }
10857
10858     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
10859     proto_tree_add_text(tree, asn1->tvb,
10860         saved_offset, asn1->offset - saved_offset,
10861         "%s :  %s",
10862         bigbuf, str);
10863
10864     switch ((value & 0x40) >> 6)
10865     {
10866     case 0x00: str = "O Disconnect (ODISC) cannot be armed"; break;
10867     default:
10868         str = "O Disconnect (ODISC) can be armed";
10869         break;
10870     }
10871
10872     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
10873     proto_tree_add_text(tree, asn1->tvb,
10874         saved_offset, asn1->offset - saved_offset,
10875         "%s :  %s",
10876         bigbuf, str);
10877
10878     switch ((value & 0x20) >> 5)
10879     {
10880     case 0x00: str = "O Answer (OANS) cannot be armed"; break;
10881     default:
10882         str = "O Answer (OANS) can be armed";
10883         break;
10884     }
10885
10886     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
10887     proto_tree_add_text(tree, asn1->tvb,
10888         saved_offset, asn1->offset - saved_offset,
10889         "%s :  %s",
10890         bigbuf, str);
10891
10892     switch ((value & 0x10) >> 4)
10893     {
10894     case 0x00: str = "Origination Attempt Authorized (OAA) cannot be armed"; break;
10895     default:
10896         str = "Origination Attempt Authorized (OAA) can be armed";
10897         break;
10898     }
10899
10900     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
10901     proto_tree_add_text(tree, asn1->tvb,
10902         saved_offset, asn1->offset - saved_offset,
10903         "%s :  %s",
10904         bigbuf, str);
10905
10906     switch ((value & 0x08) >> 3)
10907     {
10908     case 0x00: str = "Revertive Call trigger (RvtC) cannot be armed"; break;
10909     default:
10910         str = "Revertive Call trigger (RvtC) can be armed";
10911         break;
10912     }
10913
10914     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
10915     proto_tree_add_text(tree, asn1->tvb,
10916         saved_offset, asn1->offset - saved_offset,
10917         "%s :  %s",
10918         bigbuf, str);
10919
10920     switch ((value & 0x04) >> 2)
10921     {
10922     case 0x00: str = "All Calls trigger (All) cannot be armed"; break;
10923     default:
10924         str = "All Calls trigger (All) can be armed";
10925         break;
10926     }
10927
10928     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
10929     proto_tree_add_text(tree, asn1->tvb,
10930         saved_offset, asn1->offset - saved_offset,
10931         "%s :  %s",
10932         bigbuf, str);
10933
10934     switch ((value & 0x02) >> 1)
10935     {
10936     case 0x00: str = "K-digit triggers (K-digit) cannot be armed"; break;
10937     default:
10938         str = "K-digit triggers (K-digit) can be armed";
10939         break;
10940     }
10941
10942     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
10943     proto_tree_add_text(tree, asn1->tvb,
10944         saved_offset, asn1->offset - saved_offset,
10945         "%s :  %s",
10946         bigbuf, str);
10947
10948     switch (value & 0x01)
10949     {
10950     case 0x00: str = "Introducing Star/Pound triggers (INIT) cannot be armed"; break;
10951     default:
10952         str = "Introducing Star/Pound triggers (INIT) can be armed";
10953         break;
10954     }
10955
10956     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
10957     proto_tree_add_text(tree, asn1->tvb,
10958         saved_offset, asn1->offset - saved_offset,
10959         "%s :  %s",
10960         bigbuf, str);
10961
10962     if (len == 1) return;
10963
10964     saved_offset = asn1->offset;
10965
10966     asn1_int32_value_decode(asn1, 1, &value);
10967
10968     switch ((value & 0x80) >> 7)
10969     {
10970     case 0x00: str = "O Called Party Busy (OBSY) cannot be armed"; break;
10971     default:
10972         str = "O Called Party Busy (OBSY) can be armed";
10973         break;
10974     }
10975
10976     my_decode_bitfield_value(bigbuf, value, 0x80, 8);
10977     proto_tree_add_text(tree, asn1->tvb,
10978         saved_offset, asn1->offset - saved_offset,
10979         "%s :  %s",
10980         bigbuf, str);
10981
10982     switch ((value & 0x40) >> 6)
10983     {
10984     case 0x00: str = "Called Routing Address Available (CdRAA) cannot be armed"; break;
10985     default:
10986         str = "Called Routing Address Available (CdRAA) can be armed";
10987         break;
10988     }
10989
10990     my_decode_bitfield_value(bigbuf, value, 0x40, 8);
10991     proto_tree_add_text(tree, asn1->tvb,
10992         saved_offset, asn1->offset - saved_offset,
10993         "%s :  %s",
10994         bigbuf, str);
10995
10996     switch ((value & 0x20) >> 5)
10997     {
10998     case 0x00: str = "Initial Termination (IT) cannot be armed"; break;
10999     default:
11000         str = "Initial Termination (IT) can be armed";
11001         break;
11002     }
11003
11004     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
11005     proto_tree_add_text(tree, asn1->tvb,
11006         saved_offset, asn1->offset - saved_offset,
11007         "%s :  %s",
11008         bigbuf, str);
11009
11010     switch ((value & 0x10) >> 4)
11011     {
11012     case 0x00: str = "Calling Routing Address Available (CgRAA) cannot be armed"; break;
11013     default:
11014         str = "Calling Routing Address Available (CgRAA) can be armed";
11015         break;
11016     }
11017
11018     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
11019     proto_tree_add_text(tree, asn1->tvb,
11020         saved_offset, asn1->offset - saved_offset,
11021         "%s :  %s",
11022         bigbuf, str);
11023
11024     switch ((value & 0x08) >> 3)
11025     {
11026     case 0x00: str = "Advanced Termination trigger (AT) cannot be armed"; break;
11027     default:
11028         str = "Advanced Termination trigger (AT) can be armed";
11029         break;
11030     }
11031
11032     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
11033     proto_tree_add_text(tree, asn1->tvb,
11034         saved_offset, asn1->offset - saved_offset,
11035         "%s :  %s",
11036         bigbuf, str);
11037
11038     switch ((value & 0x04) >> 2)
11039     {
11040     case 0x00: str = "Prior Agreement trigger (PA) cannot be armed"; break;
11041     default:
11042         str = "Prior Agreement trigger (PA) can be armed";
11043         break;
11044     }
11045
11046     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
11047     proto_tree_add_text(tree, asn1->tvb,
11048         saved_offset, asn1->offset - saved_offset,
11049         "%s :  %s",
11050         bigbuf, str);
11051
11052     switch ((value & 0x02) >> 1)
11053     {
11054     case 0x00: str = "Unrecognized Number trigger (Unrec) cannot be armed"; break;
11055     default:
11056         str = "Unrecognized Number trigger (Unrec) can be armed";
11057         break;
11058     }
11059
11060     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
11061     proto_tree_add_text(tree, asn1->tvb,
11062         saved_offset, asn1->offset - saved_offset,
11063         "%s :  %s",
11064         bigbuf, str);
11065
11066     switch (value & 0x01)
11067     {
11068     case 0x00: str = "Call Type triggers (CT) cannot be armed"; break;
11069     default:
11070         str = "Call Type triggers (CT) can be armed";
11071         break;
11072     }
11073
11074     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
11075     proto_tree_add_text(tree, asn1->tvb,
11076         saved_offset, asn1->offset - saved_offset,
11077         "%s :  %s",
11078         bigbuf, str);
11079
11080     if (len == 2) return;
11081
11082     saved_offset = asn1->offset;
11083
11084     asn1_int32_value_decode(asn1, 1, &value);
11085
11086     my_decode_bitfield_value(bigbuf, value, 0xe0, 8);
11087     proto_tree_add_text(tree, asn1->tvb,
11088         saved_offset, asn1->offset - saved_offset,
11089         "%s :  Reserved",
11090         bigbuf);
11091
11092     switch ((value & 0x10) >> 4)
11093     {
11094     case 0x00: str = "T Disconnect (TDISC) cannot be armed"; break;
11095     default:
11096         str = "T Disconnect (TDISC) can be armed";
11097         break;
11098     }
11099
11100     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
11101     proto_tree_add_text(tree, asn1->tvb,
11102         saved_offset, asn1->offset - saved_offset,
11103         "%s :  %s",
11104         bigbuf, str);
11105
11106     switch ((value & 0x08) >> 3)
11107     {
11108     case 0x00: str = "T Answer (TANS) cannot be armed"; break;
11109     default:
11110         str = "T Answer (TANS) can be armed";
11111         break;
11112     }
11113
11114     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
11115     proto_tree_add_text(tree, asn1->tvb,
11116         saved_offset, asn1->offset - saved_offset,
11117         "%s :  %s",
11118         bigbuf, str);
11119
11120     switch ((value & 0x04) >> 2)
11121     {
11122     case 0x00: str = "T No Answer trigger (TNA) cannot be armed"; break;
11123     default:
11124         str = "T No Answer trigger (TNA) can be armed";
11125         break;
11126     }
11127
11128     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
11129     proto_tree_add_text(tree, asn1->tvb,
11130         saved_offset, asn1->offset - saved_offset,
11131         "%s :  %s",
11132         bigbuf, str);
11133
11134     switch ((value & 0x02) >> 1)
11135     {
11136     case 0x00: str = "T Busy trigger (TBusy) cannot be armed"; break;
11137     default:
11138         str = "T Busy trigger (TBusy) can be armed";
11139         break;
11140     }
11141
11142     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
11143     proto_tree_add_text(tree, asn1->tvb,
11144         saved_offset, asn1->offset - saved_offset,
11145         "%s :  %s",
11146         bigbuf, str);
11147
11148     switch (value & 0x01)
11149     {
11150     case 0x00: str = "Terminating Resource Available triggers (TRA) cannot be armed"; break;
11151     default:
11152         str = "Terminating Resource Available triggers (TRA) can be armed";
11153         break;
11154     }
11155
11156     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
11157     proto_tree_add_text(tree, asn1->tvb,
11158         saved_offset, asn1->offset - saved_offset,
11159         "%s :  %s",
11160         bigbuf, str);
11161
11162     EXTRANEOUS_DATA_CHECK(len, 3);
11163 }
11164
11165 static void
11166 param_sys_cap(ASN1_SCK *asn1, proto_tree *tree, guint len)
11167 {
11168     gint32 value;
11169     guint saved_offset;
11170     gchar *str = NULL;
11171
11172     EXACT_DATA_CHECK(len, 1);
11173
11174     saved_offset = asn1->offset;
11175
11176     asn1_int32_value_decode(asn1, 1, &value);
11177
11178     my_decode_bitfield_value(bigbuf, value, 0xc0, 8);
11179     proto_tree_add_text(tree, asn1->tvb,
11180         saved_offset, asn1->offset - saved_offset,
11181         "%s :  Reserved",
11182         bigbuf);
11183
11184     switch ((value & 0x20) >> 5)
11185     {
11186     case 0x00: str = "DP is not supported by the system"; break;
11187     default:
11188         str = "DP is supported by the system";
11189         break;
11190     }
11191
11192     my_decode_bitfield_value(bigbuf, value, 0x20, 8);
11193     proto_tree_add_text(tree, asn1->tvb,
11194         saved_offset, asn1->offset - saved_offset,
11195         "%s :  %s",
11196         bigbuf, str);
11197
11198     switch ((value & 0x10) >> 4)
11199     {
11200     case 0x00: str = "SSD is not shared with the system for the indicated MS"; break;
11201     default:
11202         str = "SSD is shared with the system for the indicated MS";
11203         break;
11204     }
11205
11206     my_decode_bitfield_value(bigbuf, value, 0x10, 8);
11207     proto_tree_add_text(tree, asn1->tvb,
11208         saved_offset, asn1->offset - saved_offset,
11209         "%s :  %s",
11210         bigbuf, str);
11211
11212     switch ((value & 0x08) >> 3)
11213     {
11214     case 0x00: str = "System cannot execute CAVE algorithm"; break;
11215     default:
11216         str = "System can execute CAVE algorithm";
11217         break;
11218     }
11219
11220     my_decode_bitfield_value(bigbuf, value, 0x08, 8);
11221     proto_tree_add_text(tree, asn1->tvb,
11222         saved_offset, asn1->offset - saved_offset,
11223         "%s :  %s",
11224         bigbuf, str);
11225
11226     switch ((value & 0x04) >> 2)
11227     {
11228     case 0x00: str = "Voice Privacy is not supported"; break;
11229     default:
11230         str = "Voice Privacy is supported";
11231         break;
11232     }
11233
11234     my_decode_bitfield_value(bigbuf, value, 0x04, 8);
11235     proto_tree_add_text(tree, asn1->tvb,
11236         saved_offset, asn1->offset - saved_offset,
11237         "%s :  %s",
11238         bigbuf, str);
11239
11240     switch ((value & 0x02) >> 1)
11241     {
11242     case 0x00: str = "SME is not supported"; break;
11243     default:
11244         str = "SME is supported";
11245         break;
11246     }
11247
11248     my_decode_bitfield_value(bigbuf, value, 0x02, 8);
11249     proto_tree_add_text(tree, asn1->tvb,
11250         saved_offset, asn1->offset - saved_offset,
11251         "%s :  %s",
11252         bigbuf, str);
11253
11254     switch (value & 0x01)
11255     {
11256     case 0x00: str = "Authentication parameters were not requested"; break;
11257     default:
11258         str = "Authentication parameters were requested";
11259         break;
11260     }
11261
11262     my_decode_bitfield_value(bigbuf, value, 0x01, 8);
11263     proto_tree_add_text(tree, asn1->tvb,
11264         saved_offset, asn1->offset - saved_offset,
11265         "%s :  %s",
11266         bigbuf, str);
11267 }
11268
11269 static void
11270 param_act_code(ASN1_SCK *asn1, proto_tree *tree, guint len)
11271 {
11272     gint32 value;
11273     guint saved_offset;
11274     gchar *str = NULL;
11275
11276     saved_offset = asn1->offset;
11277
11278     asn1_int32_value_decode(asn1, 1, &value);
11279
11280     switch (value)
11281     {
11282     case 0: str = "Not used"; break;
11283     case 1: str = "Continue processing"; break;
11284     case 2: str = "Disconnect call"; break;
11285     case 3: str = "Disconnect call leg"; break;
11286     case 4: str = "Conference calling drop last party"; break;
11287     case 5: str = "Bridge call leg(s) to conference call"; break;
11288     case 6: str = "Drop call leg on busy or routing failure"; break;
11289     case 7: str = "Disconnect all call legs"; break;
11290     case 8: str = "Attach MSC to OTAF"; break;
11291     case 9: str = "Initiate Registration Notification"; break;
11292     case 10: str = "Generate Public Encryption values"; break;
11293     case 11: str = "Generate A-Key"; break;
11294     case 12: str = "Perform SSD Update procedure"; break;
11295     case 13: str = "Perform Re-authentication procedure"; break;
11296     case 14: str = "Release TRN"; break;
11297     case 15: str = "Commit A-key"; break;
11298     case 16: str = "Release Resources"; break;
11299     case 17: str = "Record NEWMSID"; break;
11300     case 18: str = "Allocate Resources"; break;
11301     case 19: str = "Generate Authentication Signature"; break;
11302     case 20: str = "Release leg and redirect subscriber"; break;
11303     case 21: str = "Do Not Wait For MS User Level Response"; break;
11304     default:
11305         if ((value >= 22) && (value <= 95)) { str = "Reserved, treat as Continue processing"; }
11306         if ((value >= 96) && (value <= 127)) { str = "Reserved for protocol extension, treat as Continue processing"; }
11307         if ((value >= 128) && (value <= 223)) { str = "Reserved, treat as Disconnect call"; }
11308         else { str = "Reserved for protocol extension, treat as Disconnect call"; }
11309         break;
11310     }
11311
11312     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11313         saved_offset, asn1->offset - saved_offset,
11314         "Action Code, %s (%d)",
11315         str,
11316         value);
11317
11318     EXTRANEOUS_DATA_CHECK(len, 1);
11319 }
11320
11321 static void
11322 param_border_acc(ASN1_SCK *asn1, proto_tree *tree, guint len)
11323 {
11324     gint32 value;
11325     guint saved_offset;
11326     gchar *str = NULL;
11327
11328     EXACT_DATA_CHECK(len, 1);
11329
11330     saved_offset = asn1->offset;
11331
11332     asn1_int32_value_decode(asn1, 1, &value);
11333
11334     switch (value)
11335     {
11336     case 0: str = "Not used"; break;
11337     case 1: str = "Border Cell Access"; break;
11338     default:
11339         if ((value >= 2) && (value <= 223)) { str = "Reserved, treat as Border Cell Access"; }
11340         else { str = "Reserved for protocol extension, treat as Border Cell Access"; }
11341         break;
11342     }
11343
11344     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11345         saved_offset, asn1->offset - saved_offset,
11346         "Indication, %s (%d)",
11347         str,
11348         value);
11349 }
11350
11351 static void
11352 param_avail_type(ASN1_SCK *asn1, proto_tree *tree, guint len)
11353 {
11354     gint32 value;
11355     guint saved_offset;
11356     gchar *str = NULL;
11357
11358     saved_offset = asn1->offset;
11359
11360     asn1_int32_value_decode(asn1, 1, &value);
11361
11362     switch (value)
11363     {
11364     case 0: str = "Not used"; break;
11365     case 1: str = "Unspecified MS inactivity type"; break;
11366     default:
11367         if ((value >= 2) && (value <= 223)) { str = "Reserved, treat as Unspecified"; }
11368         else { str = "Reserved for protocol extension, treat as Unspecified"; }
11369         break;
11370     }
11371
11372     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11373         saved_offset, asn1->offset - saved_offset,
11374         str);
11375
11376     EXTRANEOUS_DATA_CHECK(len, 1);
11377 }
11378
11379 static void
11380 param_can_type(ASN1_SCK *asn1, proto_tree *tree, guint len)
11381 {
11382     gint32 value;
11383     guint saved_offset;
11384     gchar *str = NULL;
11385
11386     saved_offset = asn1->offset;
11387
11388     asn1_int32_value_decode(asn1, 1, &value);
11389
11390     switch (value)
11391     {
11392     case 0: str = "Not used"; break;
11393     case 1: str = "Serving System Option.  The serving system may discontinue a call or service in progress at its option."; break;
11394     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;
11395     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;
11396     default:
11397         if ((value >= 4) && (value <= 223)) { str = "Reserved, treat as Serving System Option"; }
11398         else { str = "Reserved for protocol extension, treat as Serving System Option"; }
11399         break;
11400     }
11401
11402     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11403         saved_offset, asn1->offset - saved_offset,
11404         str);
11405
11406     EXTRANEOUS_DATA_CHECK(len, 1);
11407 }
11408
11409 static void
11410 param_can_den(ASN1_SCK *asn1, proto_tree *tree, guint len)
11411 {
11412     gint32 value;
11413     guint saved_offset;
11414     gchar *str = NULL;
11415
11416     EXACT_DATA_CHECK(len, 1);
11417
11418     saved_offset = asn1->offset;
11419
11420     asn1_int32_value_decode(asn1, 1, &value);
11421
11422     switch (value)
11423     {
11424     case 0: str = "Not used"; break;
11425     case 1: str = "Multiple Access"; break;
11426     case 2: str = "Busy"; break;
11427     default:
11428         if ((value >= 3) && (value <= 223)) { str = "Reserved, treat as Multiple Access"; }
11429         else { str = "Reserved for protocol extension, treat as Multiple Access"; }
11430         break;
11431     }
11432
11433     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11434         saved_offset, asn1->offset - saved_offset,
11435         "Indication, %s (%d)",
11436         str,
11437         value);
11438 }
11439
11440 static void
11441 param_acc_den(ASN1_SCK *asn1, proto_tree *tree, guint len)
11442 {
11443     gint32 value;
11444     guint saved_offset;
11445     gchar *str = NULL;
11446
11447     EXACT_DATA_CHECK(len, 1);
11448
11449     saved_offset = asn1->offset;
11450
11451     asn1_int32_value_decode(asn1, 1, &value);
11452
11453     switch (value)
11454     {
11455     case 0: str = "Not used"; break;
11456     case 1: str = "Unassigned directory number"; break;
11457     case 2: str = "Inactive"; break;
11458     case 3: str = "Busy"; break;
11459     case 4: str = "Termination denied"; break;
11460     case 5: str = "No Page response"; break;
11461     case 6: str = "Unavailable"; break;
11462     case 7: str = "Service Rejected by MS"; break;
11463     case 8: str = "Service Rejected by the System"; break;
11464     case 9: str = "Service Type Mismatch"; break;
11465     case 10: str = "Service Denied"; break;
11466     case 11: str = "Call Rejected"; break;
11467     default:
11468         if ((value >= 12) && (value <= 223)) { str = "Reserved, treat as Termination denied"; }
11469         else { str = "Reserved for protocol extension, treat as Termination denied"; }
11470         break;
11471     }
11472
11473     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11474         saved_offset, asn1->offset - saved_offset,
11475         "Access Denied Reason, %s (%d)",
11476         str,
11477         value);
11478 }
11479
11480 static void
11481 param_sms_acc_den_reason(ASN1_SCK *asn1, proto_tree *tree, guint len)
11482 {
11483     gint32 value;
11484     guint saved_offset;
11485     gchar *str = NULL;
11486
11487     saved_offset = asn1->offset;
11488
11489     asn1_int32_value_decode(asn1, 1, &value);
11490
11491     switch (value)
11492     {
11493     case 0: str = "Not used"; break;
11494     case 1: str = "Denied"; break;
11495     case 2: str = "Postponed"; break;
11496     case 3: str = "Unavailable"; break;
11497     case 4: str = "Invalid"; break;
11498     default:
11499         if ((value >= 5) && (value <= 63)) { str = "Reserved, treat as Denied"; }
11500         else if ((value >= 64) && (value <= 127)) { str = "Reserved, treat as Postponed"; }
11501         else if ((value >= 128) && (value <= 223)) { str = "Reserved, treat as Unavailable"; }
11502         else { str = "Reserved for protocol extension, treat as Unavailable"; }
11503         break;
11504     }
11505
11506     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11507         saved_offset, asn1->offset - saved_offset,
11508         "Access Denied Reason, %s (%d)",
11509         str,
11510         value);
11511
11512     EXTRANEOUS_DATA_CHECK(len, 1);
11513 }
11514
11515 static void
11516 param_sms_bd(ASN1_SCK *asn1, proto_tree *tree, guint len)
11517 {
11518     tvbuff_t *next_tvb;
11519
11520
11521     next_tvb = tvb_new_subset(asn1->tvb, asn1->offset, len, len);
11522
11523     if (ansi_map_sms_tele_id != -1)
11524     {
11525         dissector_try_port(is637_tele_id_dissector_table, ansi_map_sms_tele_id, next_tvb, g_pinfo, g_tree);
11526         ansi_map_sms_tele_id = -1;
11527     }
11528     else if (is683_ota)
11529     {
11530         dissector_try_port(is683_dissector_table, ansi_map_is_invoke ? 0 : 1, next_tvb, g_pinfo, g_tree);
11531     }
11532
11533     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11534         asn1->offset, len,
11535         "Parameter Data");
11536
11537     asn1->offset += len;
11538 }
11539
11540 static void
11541 param_sms_cause(ASN1_SCK *asn1, proto_tree *tree, guint len)
11542 {
11543     gint32 value;
11544     guint saved_offset;
11545     gchar *str = NULL;
11546
11547     saved_offset = asn1->offset;
11548
11549     asn1_int32_value_decode(asn1, 1, &value);
11550
11551     switch (value)
11552     {
11553     case 0: str = "Address vacant"; break;
11554     case 1: str = "Address translation failure"; break;
11555     case 2: str = "Network resource shortage"; break;
11556     case 3: str = "Network failure"; break;
11557     case 4: str = "Invalid Teleservice ID"; break;
11558     case 5: str = "Other network problem"; break;
11559     case 6: str = "Unsupported network interface"; break;
11560     case 32: str = "No page response"; break;
11561     case 33: str = "Destination busy"; break;
11562     case 34: str = "No acknowledgement"; break;
11563     case 35: str = "Destination resource shortage"; break;
11564     case 36: str = "SMS delivery postponed"; break;
11565     case 37: str = "Destination out of service"; break;
11566     case 38: str = "Destination no longer at this address"; break;
11567     case 39: str = "Other terminal problem"; break;
11568     case 64: str = "Radio interface resource shortage"; break;
11569     case 65: str = "Radio interface incompatibility"; break;
11570     case 66: str = "Other radio interface problem"; break;
11571     case 67: str = "Unsupported Base Station Capability"; break;
11572     case 96: str = "Encoding problem"; break;
11573     case 97: str = "Service origination denied"; break;
11574     case 98: str = "Service termination denied"; break;
11575     case 99: str = "Supplementary service not supported"; break;
11576     case 100: str = "Service not supported"; break;
11577     case 101: str = "Reserved"; break;
11578     case 102: str = "Missing expected parameter"; break;
11579     case 103: str = "Missing mandatory parameter"; break;
11580     case 104: str = "Unrecognized parameter value"; break;
11581     case 105: str = "Unexpected parameter value"; break;
11582     case 106: str = "User Data size error"; break;
11583     case 107: str = "Other general problems"; break;
11584     case 108: str = "Session not active"; break;
11585     default:
11586         if ((value >= 7) && (value <= 31)) { str = "Reserved, treat as Other network problem"; }
11587         else if ((value >= 40) && (value <= 47)) { str = "Reserved, treat as Other terminal problem"; }
11588         else if ((value >= 48) && (value <= 63)) { str = "Reserved, treat as SMS delivery postponed"; }
11589         else if ((value >= 68) && (value <= 95)) { str = "Reserved, treat as Other radio interface problem"; }
11590         else if ((value >= 109) && (value <= 223)) { str = "Reserved, treat as Other general problems"; }
11591         else { str = "Reserved for protocol extension, treat as Other general problems"; }
11592         break;
11593     }
11594
11595     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11596         saved_offset, asn1->offset - saved_offset,
11597         "%s (%d)",
11598         str,
11599         value);
11600
11601     EXTRANEOUS_DATA_CHECK(len, 1);
11602 }
11603
11604 static void
11605 param_cdma_soci(ASN1_SCK *asn1, proto_tree *tree, guint len)
11606 {
11607     gint32 value;
11608     guint saved_offset;
11609
11610     saved_offset = asn1->offset;
11611
11612     asn1_int32_value_decode(asn1, 1, &value);
11613
11614     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11615         saved_offset, asn1->offset - saved_offset,
11616         "Value %d",
11617         value);
11618
11619     EXTRANEOUS_DATA_CHECK(len, 1);
11620 }
11621
11622 static void
11623 param_int(ASN1_SCK *asn1, proto_tree *tree, guint len)
11624 {
11625     gint32 value;
11626     guint saved_offset;
11627
11628     if (len > 4)
11629     {
11630         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11631             asn1->offset, len, "Long Data (?)");
11632         asn1->offset += len;
11633         return;
11634     }
11635
11636     saved_offset = asn1->offset;
11637
11638     asn1_int32_value_decode(asn1, len, &value);
11639
11640     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11641         saved_offset, asn1->offset - saved_offset,
11642         "Value %d",
11643         value);
11644 }
11645
11646 static void
11647 param_pc_ssn(ASN1_SCK *asn1, proto_tree *tree, guint len)
11648 {
11649     gint32 value, b1, b2, b3, b4;
11650     guint saved_offset;
11651     gchar *str = NULL;
11652
11653     EXACT_DATA_CHECK(len, 5);
11654
11655     saved_offset = asn1->offset;
11656
11657     asn1_int32_value_decode(asn1, 1, &value);
11658
11659     switch (value)
11660     {
11661     case 0: str = "Not specified"; break;
11662     case 1: str = "Serving MSC"; break;
11663     case 2: str = "Home MSC"; break;
11664     case 3: str = "Gateway MSC"; break;
11665     case 4: str = "HLR"; break;
11666     case 5: str = "VLR"; break;
11667     case 6: str = "EIR (reserved)"; break;
11668     case 7: str = "AC"; break;
11669     case 8: str = "Border MSC"; break;
11670     case 9: str = "Originating MSC"; break;
11671     default:
11672         if ((value >= 10) && (value <= 223)) { str = "Reserved, treat as Not specified"; }
11673         else { str = "Reserved for protocol extension, treat as Not specified"; }
11674         break;
11675     }
11676
11677     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11678         saved_offset, asn1->offset - saved_offset,
11679         "Type (%d) %s",
11680         value,
11681         str);
11682
11683     asn1_int32_value_decode(asn1, 1, &b1);
11684     asn1_int32_value_decode(asn1, 1, &b2);
11685     asn1_int32_value_decode(asn1, 1, &b3);
11686     asn1_int32_value_decode(asn1, 1, &b4);
11687
11688     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11689         saved_offset, asn1->offset - saved_offset,
11690         "Point Code %d-%d-%d  SSN %d",
11691         b1, b2, b3, b4);
11692 }
11693
11694 static void
11695 param_lai(ASN1_SCK *asn1, proto_tree *tree, guint len)
11696 {
11697     gint32 value;
11698     guint saved_offset;
11699
11700     EXACT_DATA_CHECK(len, 2);
11701
11702     saved_offset = asn1->offset;
11703
11704     asn1_int32_value_decode(asn1, 2, &value);
11705
11706     proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
11707         saved_offset, asn1->offset - saved_offset,
11708         "LAI %d (0x%04x)",
11709         value,
11710         value);
11711 }
11712
11713 static void
11714 param_list(ASN1_SCK *asn1, proto_tree *tree, guint len)
11715 {
11716     guint saved_offset;
11717
11718     saved_offset = asn1->offset;
11719
11720     while (len > (asn1->offset - saved_offset))
11721     {
11722         if (!dissect_ansi_param(asn1, tree))
11723         {
11724             proto_tree_add_text(tree,
11725                 asn1->tvb, asn1->offset, len - (asn1->offset - saved_offset),
11726                 "Unknown Parameter Data");
11727
11728             asn1->offset = saved_offset + len;
11729             break;
11730         }
11731     }
11732 }
11733
11734
11735 #define NUM_PARAM_1 (sizeof(ansi_param_1_strings)/sizeof(value_string))
11736 static gint ett_ansi_param_1[NUM_PARAM_1];
11737 static void (*param_1_fcn[])(ASN1_SCK *asn1, proto_tree *tree, guint len) = {
11738     param_bill_id,      /* Billing ID */
11739     param_int,  /* Serving Cell ID */
11740     param_int,  /* Target Cell ID */
11741     param_digits,       /* Digits */
11742     param_chan_data,    /* Channel Data */
11743     param_cic,  /* Inter MSC Circuit ID */
11744     param_int,  /* Inter Switch Count */
11745     param_min,  /* Mobile Identification Number */
11746     param_esn,  /* Electronic Serial Number */
11747     param_rel_reason,   /* Release Reason */
11748     param_sig_qual,     /* Signal Quality */
11749     param_scm,  /* Station Class Mark */
11750     param_auth_den,     /* Authorization Denied */
11751     param_auth_per,     /* Authorization Period */
11752     param_seizure,      /* Seizure Type */
11753     param_trunk_stat,   /* Trunk Status */
11754     param_qic,  /* Qualification Information Code */
11755     param_feat_result,  /* Feature Result */
11756     param_red_reason,   /* Redirection Reason */
11757     param_acc_den,      /* Access Denied Reason */
11758     param_mscid,        /* MSCID */
11759     param_sys_type_code,        /* System My Type Code */
11760     param_orig_ind,     /* Origination Indicator */
11761     param_term_res,     /* Termination Restriction Code */
11762     param_calling_feat_ind,     /* Calling Features Indicator */
11763     param_faulty,       /* Faulty Parameter */
11764     param_usage_ind,    /* Usage Indicator */
11765     param_tdma_chan_data,       /* TDMA Channel Data */
11766     param_tdma_call_mode,       /* TDMA Call Mode */
11767     param_ho_reason,    /* Handoff Reason */
11768     NULL,       /* NONE */
11769 };
11770
11771
11772 #define NUM_PARAM_2 (sizeof(ansi_param_2_strings)/sizeof(value_string))
11773 static gint ett_ansi_param_2[NUM_PARAM_2];
11774 static void (*param_2_fcn[])(ASN1_SCK *asn1, proto_tree *tree, guint len) = {
11775     param_tdma_burst_ind,       /* TDMA Burst Indicator */
11776     param_pc_ssn,       /* PC_SSN */
11777     param_lai,  /* Location Area ID */
11778     param_sys_acc_type, /* System Access Type */
11779     param_auth_resp_all,        /* Authentication Response */
11780     param_auth_resp_all,        /* Authentication Response Base Station */
11781     param_auth_resp_all,        /* Authentication Response Unique Challenge */
11782     param_int,  /* Call History Count */
11783     param_confid_mode,  /* Confidentiality Modes */
11784     param_int,  /* Random Variable */
11785     param_int,  /* Random Variable Base station */
11786     param_rand_ssd,     /* Random Variable SSD */
11787     param_rand_unique,  /* Random Variable Unique Challenge */
11788     param_report_type,  /* Report Type */
11789     param_sme_key,      /* Signaling Message Encryption Key */
11790     param_ssd,  /* Shared Secret Data */
11791     param_term_type,    /* Terminal Type */
11792     param_vpmask,       /* Voice Privacy Mask */
11793     param_sys_cap,      /* System Capabilities */
11794     param_deny_acc,     /* Deny Access */
11795     param_upd_count,    /* Update Count */
11796     param_ssd_no_share, /* SSD Not Shared */
11797     param_ext_mscid,    /* Extended MSCID */
11798     param_ext_sys_type_code,    /* Extended System My Type Code */
11799     param_ctrl_chan_data,       /* Control Channel Data */
11800     param_sys_acc_data, /* System Access Data */
11801     param_can_den,      /* Cancellation Denied */
11802     param_border_acc,   /* Border Cell Access */
11803     param_cdma_scm,     /* CDMA Station Class Mark */
11804     param_int,  /* CDMA Serving One Way Delay */
11805     param_int,  /* CDMA Target One Way Delay */
11806     param_cdma_call_mode,       /* CDMA Call Mode */
11807     param_cdma_chan_data,       /* CDMA Channel Data */
11808     param_cdma_sig_qual,        /* CDMA Signal Quality */
11809     param_cdma_pilot_strength,  /* CDMA Pilot Strength */
11810     param_mob_rev,      /* CDMA Mobile Protocol Revision */
11811     param_cdma_plcm,    /* CDMA Private Long Code Mask */
11812     param_cdma_code_chan,       /* CDMA Code Channel */
11813     param_cdma_sea_win, /* CDMA Search Window */
11814     param_ms_loc,       /* MS Location */
11815     param_page_ind,     /* Page Indicator */
11816     param_rec_sig_qual, /* Received Signal Quality */
11817     param_dereg,        /* Deregistration Type */
11818     param_namps_chan_data,      /* NAMPS Channel Data */
11819     param_alert_code,   /* Alert Code */
11820     param_ann_code,     /* Announcement Code */
11821     param_aav,  /* Authentication Algorithm Version */
11822     param_auth_cap,     /* Authentication Capability */
11823     param_int,  /* Call History Count Expected */
11824     param_digits,       /* Calling Party Number Digits 1 */
11825     param_digits,       /* Calling Party Number Digits 2 */
11826     param_digits,       /* Calling Party Number String 1 */
11827     param_digits,       /* Calling Party Number String 2 */
11828     param_sub_addr,     /* Calling Party Subaddress */
11829     param_can_type,     /* Cancellation Type */
11830     param_digits,       /* Carrier Digits */
11831     param_digits,       /* Destination Digits */
11832     param_dmh_red_ind,  /* DMH Redirection Indicator */
11833     param_list, /* Inter System Termination */
11834     param_avail_type,   /* Availability Type */
11835     param_list, /* Local Termination */
11836     param_mw_noti_count,        /* Message Waiting Notification Count */
11837     param_digits,       /* Mobile Directory Number */
11838     param_digits,       /* MSCID Number */
11839     param_list, /* PSTN Termination */
11840     param_no_ans_time,  /* No Answer Time */
11841     param_otfi, /* One Time Feature Indicator */
11842     param_orig_trig,    /* Origination Triggers */
11843     param_randc,        /* RANDC */
11844     param_digits,       /* Redirecting Number Digits */
11845     param_digits,       /* Redirecting Number String */
11846     param_sub_addr,     /* Redirecting Number Subaddress */
11847     param_digits,       /* Sender Identification Number */
11848     param_digits,       /* SMS Address */
11849     param_sms_bd,       /* SMS Bearer Data */
11850     param_sms_charge_ind,       /* SMS Charge Indicator */
11851     param_digits,       /* SMS Destination Address */
11852     param_sms_msg_count,        /* SMS Message Count */
11853     param_sms_noti,     /* SMS Notification Indicator */
11854     param_digits,       /* SMS Original Destination Address */
11855     param_sub_addr,     /* SMS Original Destination Subaddress */
11856     param_digits,       /* SMS Original Originating Address */
11857     param_sub_addr,     /* SMS Original Originating Subaddress */
11858     param_digits,       /* SMS Originating Address */
11859     param_sms_orig_restric,     /* SMS Originating Restrictions */
11860     param_sms_tele,     /* SMS Teleservice Identifier */
11861     param_sms_term_restric,     /* SMS Termination Restrictions */
11862     NULL/* no data */,  /* SMS Message Waiting Indicator */
11863     param_term_acc_type,        /* Termination Access Type */
11864     param_list, /* Termination List */
11865     param_term_treat,   /* Termination Treatment */
11866     param_term_trig,    /* Termination Triggers */
11867     param_trans_cap,    /* Transaction Capability */
11868     param_unique_chal_rep,      /* Unique Challenge Report */
11869     NULL,       /* NONE */
11870 };
11871
11872
11873 #define NUM_PARAM_3 (sizeof(ansi_param_3_strings)/sizeof(value_string))
11874 static gint ett_ansi_param_3[NUM_PARAM_3];
11875 static void (*param_3_fcn[])(ASN1_SCK *asn1, proto_tree *tree, guint len) = {
11876     param_act_code,     /* Action Code */
11877     param_alert_res,    /* Alert Result */
11878     param_list, /* Announcement List */
11879     param_list, /* CDMA Code Channel Information */
11880     param_list, /* CDMA Code Channel List */
11881     param_list, /* CDMA Target Measurement Information */
11882     param_list, /* CDMA Target Measurement List */
11883     param_list, /* CDMA Target MAHO Information */
11884     param_list, /* CDMA Target MAHO List */
11885     param_conf_call_ind,        /* Conference Calling Indicator */
11886     param_count_upd_report,     /* Count Update Report */
11887     param_digit_collect_ctrl,   /* Digit Collection Control */
11888     param_digits,       /* DMH Account Code Digits */
11889     param_digits,       /* DMH Alternate Billing Digits */
11890     param_digits,       /* DMH Billing Digits */
11891     param_geo_auth,     /* Geographic Authorization */
11892     param_int,  /* Leg Information */
11893     param_mw_noti_type, /* Message Waiting Notification Type */
11894     param_paca_ind,     /* PACA Indicator */
11895     param_pref_lang_ind,        /* Preferred Language Indicator */
11896     param_rand_valtime, /* Random Valid Time */
11897     param_digits,       /* Restriction Digits */
11898     param_digits,       /* Routing Digits */
11899     param_setup_result, /* Setup Result */
11900     param_sms_acc_den_reason,   /* SMS Access Denied Reason */
11901     param_sms_cause,    /* SMS Cause Code */
11902     param_digits,       /* SPINI PIN */
11903     param_spini_trig,   /* SPINI Triggers */
11904     param_ssd_upd_report,       /* SSD Update Report */
11905     param_list, /* Target Measurement Information */
11906     param_list, /* Target Measurement List */
11907     param_digits,       /* Voice Mailbox PIN */
11908     param_digits,       /* Voice Mailbox Number */
11909     NULL/* no special handling */,      /* Authentication Data */
11910     param_cond_den_reason,      /* Conditionally Denied Reason */
11911     param_group_info,   /* Group Information */
11912     param_ho_state,     /* Handoff State */
11913     param_namps_call_mode,      /* NAMPS Call Mode */
11914     param_cdma_sci,     /* CDMA Slot Cycle Index */
11915     param_den_auth_per, /* Denied Authorization Period */
11916     param_digits,       /* Pilot Number */
11917     param_bill_id,      /* Pilot Billing ID */
11918     param_cdma_band_class,      /* CDMA Band Class */
11919     param_imsi, /* International Mobile Subscriber Identity */
11920     param_calling_party_name,   /* Calling Party Name */
11921     param_dis_text,     /* Display Text */
11922     param_red_party_name,       /* Redirecting Party Name */
11923     param_srvc_id,      /* Service ID */
11924     param_all_or_none,  /* All Or None */
11925     param_change,       /* Change */
11926     param_list, /* Data Access Element */
11927     param_list, /* Data Access Element List */
11928     param_list, /* Data Update Result */
11929     param_list, /* Data Update Result List */
11930     param_cdma_pilot_pn,        /* CDMA Pilot PN */
11931     NULL/* no special handling */,      /* CDMA Service Configuration Record */
11932     param_cdma_so,      /* CDMA Service Option */
11933     param_cdma_scm2,    /* CDMA Station Class Mark 2 */
11934     param_tdma_sc,      /* TDMA Service Code */
11935     param_tdma_term_cap,        /* TDMA Terminal Capability */
11936     param_tdma_voice_coder,     /* TDMA Voice Coder */
11937     param_a_key_ver,    /* A-Key Protocol Version */
11938     NULL/* XXX what spec ? */,  /* Authentication Response Reauthentication */
11939     NULL/* no special handling */,      /* Base Station Partial Key */
11940     param_min,  /* Mobile Station MIN */
11941     NULL/* no special handling */,      /* Mobile Station Partial Key */
11942     NULL/* no special handling */,      /* Modulus Value */
11943     param_min,  /* Newly Assigned MIN */
11944     param_ota_result_code,      /* OTASP Result Code */
11945     NULL/* no special handling */,      /* Primitive Value */
11946     NULL/* XXX what spec ? */,  /* Random Variable Reauthentication */
11947     NULL/* XXX what spec ? */,  /* Reauthentication Report */
11948     param_srvc_ind,     /* Service Indicator */
11949     param_sme_report,   /* Signaling Message Encryption Report */
11950     param_trn,  /* Temporary Reference Number */
11951     param_vp_report,    /* Voice Privacy Report */
11952     param_ctrl_chan_mode,       /* Control Channel Mode */
11953     NULL/* no special handling */,      /* CDMA Connection Reference */
11954     param_list, /* CDMA Connection Reference Information */
11955     param_list, /* CDMA Connection Reference List */
11956     param_change_srvc_attr,     /* Change Service Attributes */
11957     NULL/* no special handling */,      /* Data Key */
11958     param_dp_params,    /* Data Privacy Parameters */
11959     param_islp_info,    /* ISLP Information */
11960     param_reason_list,  /* Reason List */
11961     param_tdma_bandwidth,       /* TDMA Bandwidth */
11962     param_tdma_data_feat_ind,   /* TDMA Data Features Indicator */
11963     param_tdma_data_mode,       /* TDMA Data Mode */
11964     param_tdma_voice_mode,      /* TDMA Voice Mode */
11965     param_ana_red_info, /* Analog Redirect Info */
11966     param_list, /* CDMA Band Class Information */
11967     param_list, /* CDMA Band Class List */
11968     param_list, /* CDMA Service Option List */
11969     param_list, /* CDMA Connection Reference Information */
11970     param_list, /* CDMA Connection Reference List */
11971     param_list, /* Analog Redirect Record */
11972     param_list, /* Execute Script */
11973     param_list, /* Modification Request */
11974     param_list, /* Modification Request List */
11975     param_list, /* Modification Result List */
11976     param_list, /* Service Data Access Element */
11977     param_list, /* Service Data Access Element List */
11978     param_list, /* Service Data Result */
11979     param_list, /* Service Data Result List */
11980     param_list, /* Trigger Address List */
11981     param_list, /* Trigger List */
11982     param_list, /* WIN Capability */
11983     param_list, /* Call Recovery ID */
11984     param_list, /* Call Recovery ID List */
11985     param_list, /* Position Information */
11986     param_list, /* CDMA PSMM List */
11987     param_cdma_chan_num,        /* CDMA Channel Number */
11988     param_list, /* CDMA Channel Number List */
11989     param_cdma_pci,     /* CDMA Power Combined Indicator */
11990     param_list, /* CDMA Redirect Record */
11991     param_cdma_sea_param,       /* CDMA Search Parameters */
11992     param_int,  /* CDMA Network Identification */
11993     param_network_tmsi, /* Network TMSI */
11994     param_int,  /* Network TMSI Expiration Time */
11995     param_network_tmsi, /* New Network TMSI */
11996     param_reqd_param_mask,      /* Required Parameters Mask */
11997     param_srvc_red_cause,       /* Service Redirection Cause */
11998     param_srvc_red_info,        /* Service Redirection Info */
11999     param_roaming_ind,  /* Roaming Indication */
12000     NULL/* XXX what spec ? */,  /* MSID */
12001     NULL/* no special handling */,      /* Data ID */
12002     NULL/* no special handling */,      /* Database Key */
12003     param_data_result,  /* Data Result */
12004     NULL/* no special handling */,      /* Data Value */
12005     param_fail_cause,   /* Failure Cause */
12006     param_fail_type,    /* Failure Type */
12007     NULL/* no special handling */,      /* Global Title */
12008     NULL/* no special handling */,      /* Private Specialized Resource */
12009     param_resume_pic,   /* Resume PIC */
12010     NULL/* no special handling */,      /* Script Argument */
12011     NULL/* no special handling */,      /* Script Name */
12012     NULL/* no special handling */,      /* Script Result */
12013     param_special_rsc,  /* Specialized Resource */
12014     param_time_date_offset,     /* Time Date Offset */
12015     param_trig_cap,     /* Trigger Capability */
12016     param_trig_type,    /* Trigger Type */
12017     param_win_op_cap,   /* WIN Operations Capability */
12018     param_win_trig_list,        /* WIN Trigger List */
12019     param_digits,       /* MSC Address */
12020     param_sus_acc,      /* Suspicious Access */
12021     param_imsi, /* Mobile Station IMSI */
12022     param_imsi, /* Newly Assigned IMSI */
12023     NULL/* XXX what spec ? */,  /* Command Code */
12024     param_dis_text2,    /* Display Text 2 */
12025     NULL/* XXX what spec ? */,  /* Page Count */
12026     NULL/* XXX what spec ? */,  /* Page Response Time */
12027     NULL/* XXX what spec ? */,  /* SMS Transaction ID */
12028     param_dmh_srvc_id,  /* DMH Service ID */
12029     param_feat_ind,     /* Feature Indicator */
12030     param_mscid,        /* Control Network ID */
12031     param_rel_cause,    /* Release Cause */
12032     param_time_day,     /* Time Of Day */
12033     param_call_status,  /* Call Status */
12034     NULL/* no special handling */,      /* DMH Charge Information */
12035     NULL/* no special handling */,      /* DMH Billing Indicator */
12036     param_ms_status,    /* MS Status */
12037     param_pos_info_code,        /* Position Information Code */
12038     param_inter_msg_time,       /* Inter Message Time */
12039     param_msid_usage,   /* MSID Usage */
12040     param_new_min_ext,  /* New MIN Extension */
12041     param_dtx_ind,      /* DTX Indication */
12042     param_cdma_mob_cap, /* CDMA Mobile Capabilities */
12043     param_gen_time,     /* Generalized Time */
12044     param_digits,       /* Generic Digits */
12045     param_geo_pos,      /* Geographic Position */
12046     param_mob_call_status,      /* Mobile Call Status */
12047     param_mob_cap,      /* Mobile Position Capability */
12048     param_pos_req_type, /* Position Request Type */
12049     param_pos_result,   /* Position Result */
12050     param_pos_source,   /* Position Source */
12051     param_acg_encounter,        /* ACG Encountered */
12052     param_ctrl_type,    /* CDMA State/Control Type */
12053     param_gap_duration, /* Gap Duration */
12054     param_scf_overload_gap_int, /* SCF Overload Gap Interval */
12055     param_sm_gap_int,   /* Service Management System Gap Interval */
12056     param_cdma_psmm_count,      /* CDMA PSMM Count */
12057     param_cdma_sowd2,   /* CDMA Serving One Way Delay 2 */
12058     param_qos_pri,      /* QoS Priority */
12059     NULL/* no special handling */,      /* PDSN Address */
12060     NULL/* no special handling */,      /* PDSN Protocol Type */
12061     param_cdma_ms_meas_chan_id, /* CDMA MS Measured Channel Identity */
12062     NULL/* no special handling */,      /* Range */
12063     param_calling_party_cat,    /* Calling Party Category */
12064     param_cdma2000_ho_ivk_ios,  /* cdma2000 Handoff Invoke IOS Data */
12065     param_cdma2000_ho_rsp_ios,  /* cdma2000 Handoff Response IOS Data */
12066     param_digits,       /* LCS Client ID */
12067     param_tdma_maho_cell_id,    /* TDMA MAHO Cell ID */
12068     param_tdma_maho_chan,       /* TDMA MAHO Channel */
12069     param_cdma_soci,    /* CDMA Service Option Connection Identifier */
12070     param_tdma_time_align,      /* TDMA Time Alignment */
12071     param_tdma_maho_req,        /* TDMA MAHO Request */
12072     NULL,       /* NONE */
12073 };
12074
12075 /* GENERIC MAP DISSECTOR FUNCTIONS */
12076
12077 static void
12078 dissect_ansi_map_len(ASN1_SCK *asn1, proto_tree *tree, gboolean *def_len, guint *len)
12079 {
12080     guint       saved_offset;
12081     int         ret;
12082
12083
12084     saved_offset = asn1->offset;
12085     *def_len = FALSE;
12086     *len = 0;
12087
12088     ret = asn1_length_decode(asn1, def_len, len);
12089
12090     if (*def_len)
12091     {
12092         proto_tree_add_uint(tree, hf_ansi_map_length, asn1->tvb,
12093             saved_offset, asn1->offset - saved_offset,
12094             *len);
12095     }
12096     else
12097     {
12098         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
12099             saved_offset, asn1->offset - saved_offset,
12100             "Length: Indefinite");
12101     }
12102
12103 }
12104
12105 static gboolean
12106 check_ansi_map_tag(ASN1_SCK *asn1, guint tag)
12107 {
12108     guint saved_offset, real_tag;
12109
12110
12111     saved_offset = asn1->offset;
12112
12113     asn1_id_decode1(asn1, &real_tag);
12114
12115     asn1->offset = saved_offset;
12116
12117     return(tag == real_tag);
12118 }
12119
12120 static void
12121 dissect_ansi_map_octet(ASN1_SCK *asn1, proto_tree *tree, guchar * str)
12122 {
12123     guint saved_offset;
12124     guchar my_oct;
12125
12126
12127     saved_offset = asn1->offset;
12128
12129     asn1_octet_decode(asn1, &my_oct);
12130
12131     proto_tree_add_uint_format(tree, hf_ansi_map_id, asn1->tvb,
12132         saved_offset, asn1->offset - saved_offset, my_oct,
12133         "%s %d",
12134         str, my_oct);
12135 }
12136
12137 static proto_tree *
12138 dissect_ansi_map_component(ASN1_SCK *asn1, proto_tree *tree, guint *len_p)
12139 {
12140     guint saved_offset;
12141     guint tag;
12142     proto_item *item;
12143     proto_tree *subtree;
12144     gboolean def_len;
12145
12146
12147     saved_offset = asn1->offset;
12148     asn1_id_decode1(asn1, &tag);
12149
12150     item =
12151         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
12152             saved_offset, -1, "Component ID");
12153
12154     subtree = proto_item_add_subtree(item, ett_component);
12155
12156     proto_tree_add_uint_format(subtree, hf_ansi_map_tag, asn1->tvb,
12157         saved_offset, asn1->offset - saved_offset, tag,
12158         "Component ID Identifier");
12159
12160     dissect_ansi_map_len(asn1, subtree, &def_len, len_p);
12161
12162     proto_item_set_len(item, (asn1->offset - saved_offset) + *len_p);
12163
12164     return(subtree);
12165 }
12166
12167 static void
12168 dissect_ansi_opr_code(ASN1_SCK *asn1, packet_info *pinfo, proto_tree *tree)
12169 {
12170     guint saved_offset = 0;
12171     guint len;
12172     guint tag;
12173     gint32 val;
12174     gchar *str = NULL;
12175     guchar my_oct;
12176     proto_item *item;
12177     proto_tree *subtree;
12178     gboolean def_len;
12179
12180
12181 #define TCAP_NAT_OPR_CODE_TAG 0xd0
12182     if (check_ansi_map_tag(asn1, TCAP_NAT_OPR_CODE_TAG))
12183     {
12184         str = "National TCAP Operation Code Identifier";
12185     }
12186 #define TCAP_PRIV_OPR_CODE_TAG 0xd1
12187     else if (check_ansi_map_tag(asn1, TCAP_PRIV_OPR_CODE_TAG))
12188     {
12189         str = "Private TCAP Operation Code Identifier";
12190     }
12191     else
12192     {
12193         /* XXX */
12194         return;
12195     }
12196
12197     saved_offset = asn1->offset;
12198     asn1_id_decode1(asn1, &tag);
12199
12200     item =
12201         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
12202             saved_offset, -1, "Operation Code");
12203
12204     subtree = proto_item_add_subtree(item, ett_opr_code);
12205
12206     proto_tree_add_uint_format(subtree, hf_ansi_map_tag, asn1->tvb,
12207         saved_offset, asn1->offset - saved_offset, tag, str);
12208
12209     dissect_ansi_map_len(asn1, subtree, &def_len, &len);
12210     proto_item_set_len(item, (asn1->offset - saved_offset) + len);
12211
12212     if (len > 0)
12213     {
12214         saved_offset = asn1->offset;
12215         asn1_octet_decode(asn1, &my_oct);
12216
12217 #define ANSI_MAP_OPR_FAMILY 0x09
12218         if (my_oct != ANSI_MAP_OPR_FAMILY)
12219         {
12220             asn1->offset = saved_offset;
12221             return;
12222         }
12223
12224         proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
12225             saved_offset, 1, "Operation Code Family");
12226
12227         saved_offset = asn1->offset;
12228         asn1_int32_value_decode(asn1, len-1, &val);
12229         proto_tree_add_int(subtree, hf_ansi_map_opr_code, asn1->tvb,
12230             saved_offset, asn1->offset - saved_offset, val);
12231
12232         str = match_strval(val, ansi_opr_code_strings);
12233
12234         if (NULL == str) return;
12235
12236         if (check_col(pinfo->cinfo, COL_INFO))
12237         {
12238             col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", str);
12239         }
12240     }
12241 }
12242
12243 static void
12244 dissect_ansi_problem(ASN1_SCK *asn1, proto_tree *tree)
12245 {
12246     guint saved_offset = 0;
12247     guint len;
12248     guint tag;
12249     proto_tree *subtree;
12250     proto_item *item = NULL;
12251     gchar *str = NULL;
12252     gchar *type_str = NULL;
12253     gint32 type, spec;
12254     gboolean def_len;
12255
12256
12257 #define TCAP_PROB_CODE_TAG 0xd5
12258     if (check_ansi_map_tag(asn1, TCAP_PROB_CODE_TAG))
12259     {
12260         str = "Problem Code Identifier";
12261     }
12262     else
12263     {
12264         /* XXX */
12265         return;
12266     }
12267
12268     saved_offset = asn1->offset;
12269     asn1_id_decode1(asn1, &tag);
12270
12271     item =
12272         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
12273             saved_offset, -1, "Problem Code");
12274
12275     subtree = proto_item_add_subtree(item, ett_problem);
12276
12277     proto_tree_add_uint_format(subtree, hf_ansi_map_tag, asn1->tvb,
12278         saved_offset, asn1->offset - saved_offset, tag, str);
12279
12280     dissect_ansi_map_len(asn1, subtree, &def_len, &len);
12281     proto_item_set_len(item, (asn1->offset - saved_offset) + len);
12282
12283     if (len != 2)
12284     {
12285         proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
12286             asn1->offset, len, "Unknown encoding of Problem Code");
12287
12288         asn1->offset += len;
12289         return;
12290     }
12291
12292     saved_offset = asn1->offset;
12293     asn1_int32_value_decode(asn1, 1, &type);
12294     asn1_int32_value_decode(asn1, 1, &spec);
12295
12296     switch (type)
12297     {
12298     case 0: type_str = "Not used"; break;
12299
12300     case 1:
12301         type_str = "General";
12302         switch (spec)
12303         {
12304         case 1: str = "Unrecognized Component Type"; break;
12305         case 2: str = "Incorrect Component Portion"; break;
12306         case 3: str = "Badly Structured Component Portion"; break;
12307         default:
12308             str = "Undefined";
12309             break;
12310         }
12311         break;
12312
12313     case 2:
12314         type_str = "Invoke";
12315         switch (spec)
12316         {
12317         case 1: str = "Duplicate Invoke ID"; break;
12318         case 2: str = "Unrecognized Operation Code"; break;
12319         case 3: str = "Incorrect Parameter"; break;
12320         case 4: str = "Unrecognized Correlation ID"; break;
12321         default:
12322             str = "Undefined";
12323             break;
12324         }
12325         break;
12326
12327     case 3:
12328         type_str = "Return Result";
12329         switch (spec)
12330         {
12331         case 1: str = "Unrecognized Correlation ID"; break;
12332         case 2: str = "Unexpected Return Result"; break;
12333         case 3: str = "Incorrect Parameter"; break;
12334         default:
12335             str = "Undefined";
12336             break;
12337         }
12338         break;
12339
12340     case 4:
12341         type_str = "Return Error";
12342         switch (spec)
12343         {
12344         case 1: str = "Unrecognized Correlation ID"; break;
12345         case 2: str = "Unexpected Return Error"; break;
12346         case 3: str = "Unrecognized Error"; break;
12347         case 4: str = "Unexpected Error"; break;
12348         case 5: str = "Incorrect Parameter"; break;
12349         default:
12350             str = "Undefined";
12351             break;
12352         }
12353         break;
12354
12355     case 5:
12356         type_str = "Transaction Portion";
12357         switch (spec)
12358         {
12359         case 1: str = "Unrecognized Package Type"; break;
12360         case 2: str = "Incorrect Transaction Portion"; break;
12361         case 3: str = "Badly Structured Transaction Portion"; break;
12362         case 4: str = "Unrecognized Transaction ID"; break;
12363         case 5: str = "Permission to Release"; break;
12364         case 6: str = "Resource Unavailable"; break;
12365         default:
12366             str = "Undefined";
12367             break;
12368         }
12369         break;
12370
12371     default:
12372         type_str = "Undefined";
12373         break;
12374     }
12375
12376     if (spec == 255) { str = "Reserved"; }
12377     else if (spec == 0) { str = "Not used"; }
12378
12379     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
12380         saved_offset, 1, "Problem Type %s", type_str);
12381
12382     proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
12383         saved_offset + 1, 1, "Problem Specifier %s", str);
12384 }
12385
12386 static void
12387 dissect_ansi_error(ASN1_SCK *asn1, proto_tree *tree)
12388 {
12389     guint saved_offset = 0;
12390     guint len;
12391     guint tag;
12392     gint32 value;
12393     proto_tree *subtree;
12394     proto_item *item = NULL;
12395     gchar *str = NULL;
12396     gboolean def_len;
12397
12398
12399 #define TCAP_NAT_ERR_CODE_TAG 0xd3
12400     if (check_ansi_map_tag(asn1, TCAP_NAT_ERR_CODE_TAG))
12401     {
12402         str = "National TCAP Error Code Identifier";
12403     }
12404 #define TCAP_PRIV_ERR_CODE_TAG 0xd4
12405     else if (check_ansi_map_tag(asn1, TCAP_PRIV_ERR_CODE_TAG))
12406     {
12407         str = "Private TCAP Error Code Identifier";
12408     }
12409     else
12410     {
12411         /* XXX */
12412         return;
12413     }
12414
12415     saved_offset = asn1->offset;
12416     asn1_id_decode1(asn1, &tag);
12417
12418     item =
12419         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
12420             saved_offset, -1, "TCAP Error Code");
12421
12422     subtree = proto_item_add_subtree(item, ett_error);
12423
12424     proto_tree_add_uint_format(subtree, hf_ansi_map_tag, asn1->tvb,
12425         saved_offset, asn1->offset - saved_offset, tag, str);
12426
12427     dissect_ansi_map_len(asn1, subtree, &def_len, &len);
12428     proto_item_set_len(item, (asn1->offset - saved_offset) + len);
12429
12430     if ((tag == TCAP_PRIV_ERR_CODE_TAG) &&
12431         (len == 1))
12432     {
12433         saved_offset = asn1->offset;
12434         asn1_int32_value_decode(asn1, 1, &value);
12435
12436         switch (value)
12437         {
12438         case 0x81: str = "Unrecognized MIN"; break;
12439         case 0x82: str = "Unrecognized ESN"; break;
12440         case 0x83: str = "MIN/HLR Mismatch"; break;
12441         case 0x84: str = "Operation Sequence Problem"; break;
12442         case 0x85: str = "Resource Shortage"; break;
12443         case 0x86: str = "Operation Not Supported"; break;
12444         case 0x87: str = "Trunk Unavailable"; break;
12445         case 0x88: str = "Parameter Error"; break;
12446         case 0x89: str = "System Failure"; break;
12447         case 0x8a: str = "Unrecognized Parameter Value"; break;
12448         case 0x8b: str = "Feature Inactive"; break;
12449         case 0x8c: str = "Missing Parameter"; break;
12450         default:
12451             if ((value >= 0xe0) && (value <= 0xff)) { str = "Reserved for protocol extension"; }
12452             else { str = "Reserved"; }
12453             break;
12454         }
12455
12456         proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
12457             saved_offset, 1, str);
12458     }
12459     else
12460     {
12461         proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
12462             asn1->offset, len, "Error Code");
12463
12464         asn1->offset += len;
12465     }
12466 }
12467
12468
12469 static gboolean
12470 dissect_ansi_param(ASN1_SCK *asn1, proto_tree *tree)
12471 {
12472     void (*param_fcn)(ASN1_SCK *asn1, proto_tree *tree, guint len) = NULL;
12473     guint saved_offset = 0;
12474     guint len;
12475     proto_tree *subtree;
12476     proto_item *item;
12477     guint val;
12478     gchar *str = NULL;
12479     gint ett_param_idx, idx;
12480     gboolean def_len;
12481
12482
12483     saved_offset = asn1->offset;
12484
12485     asn1_uint32_value_decode(asn1, 1, &val);
12486     str = my_match_strval((guint32) val, ansi_param_1_strings, &idx);
12487
12488     if (NULL == str)
12489     {
12490         asn1->offset = saved_offset;
12491         asn1_uint32_value_decode(asn1, 2, &val);
12492
12493         str = my_match_strval((guint32) val, ansi_param_2_strings, &idx);
12494
12495         if (NULL == str)
12496         {
12497             asn1->offset = saved_offset;
12498             asn1_int32_value_decode(asn1, 3, &val);
12499
12500             str = my_match_strval((guint32) val, ansi_param_3_strings, &idx);
12501
12502             if (NULL == str)
12503             {
12504                 if (((val >= 0x9FFF00) && (val <= 0x9FFF7F)) ||
12505                     ((val >= 0xBFFF00) && (val <= 0xBFFF7F)))
12506                 {
12507                     str = "Reserved for protocol extension";
12508                 }
12509                 else if (((val >= 0x9FFE76) && (val <= 0x9FFE7F)) ||
12510                     ((val >= 0xBFFE76) && (val <= 0xBFFE7F)))
12511                 {
12512                     str = "Reserved for National Network Use";
12513                 }
12514                 else
12515                 {
12516                     str = "Unknown Parameter Data";
12517                     param_fcn = NULL;
12518                 }
12519
12520                 ett_param_idx = ett_param;
12521             }
12522             else
12523             {
12524                 ett_param_idx = ett_ansi_param_3[idx];
12525                 param_fcn = param_3_fcn[idx];
12526             }
12527         }
12528         else
12529         {
12530             ett_param_idx = ett_ansi_param_2[idx];
12531             param_fcn = param_2_fcn[idx];
12532         }
12533     }
12534     else
12535     {
12536         ett_param_idx = ett_ansi_param_1[idx];
12537         param_fcn = param_1_fcn[idx];
12538     }
12539
12540     item =
12541         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
12542             saved_offset, -1, str);
12543
12544     subtree = proto_item_add_subtree(item, ett_param_idx);
12545
12546     proto_tree_add_none_format(subtree, hf_ansi_map_param_id, asn1->tvb,
12547         saved_offset, asn1->offset - saved_offset, "Parameter ID");
12548
12549     dissect_ansi_map_len(asn1, subtree, &def_len, &len);
12550
12551     proto_item_set_len(item, asn1->offset - saved_offset + len);
12552
12553     if (len > 0)
12554     {
12555         if (param_fcn == NULL)
12556         {
12557             proto_tree_add_none_format(subtree, hf_ansi_map_none, asn1->tvb,
12558                 asn1->offset, len, "Parameter Data");
12559             asn1->offset += len;
12560         }
12561         else
12562         {
12563             (*param_fcn)(asn1, subtree, len);
12564         }
12565     }
12566
12567     return(TRUE);
12568 }
12569
12570
12571 static void
12572 dissect_ansi_params(ASN1_SCK *asn1, proto_tree *tree)
12573 {
12574     guint saved_offset = 0;
12575     guint len;
12576     guint tag;
12577     proto_tree *subtree;
12578     proto_item *item = NULL;
12579     gchar *str = NULL;
12580     gboolean def_len;
12581
12582 #define TCAP_PARAM_SET_TAG 0xf2
12583     if (check_ansi_map_tag(asn1, TCAP_PARAM_SET_TAG))
12584     {
12585         str = "Parameter Set Identifier";
12586     }
12587 #define TCAP_PARAM_SEQ_TAG 0x30
12588     else if (check_ansi_map_tag(asn1, TCAP_PARAM_SEQ_TAG))
12589     {
12590         str = "Parameter Sequence Identifier";
12591     }
12592     else
12593     {
12594         /* XXX */
12595         return;
12596     }
12597
12598     saved_offset = asn1->offset;
12599     asn1_id_decode1(asn1, &tag);
12600
12601     item =
12602         proto_tree_add_none_format(tree, hf_ansi_map_none, asn1->tvb,
12603             saved_offset, -1, "Parameters");
12604
12605     subtree = proto_item_add_subtree(item, ett_params);
12606
12607     proto_tree_add_uint_format(subtree, hf_ansi_map_tag, asn1->tvb,
12608         saved_offset, asn1->offset - saved_offset, tag, str);
12609
12610     dissect_ansi_map_len(asn1, subtree, &def_len, &len);
12611     proto_item_set_len(item, (asn1->offset - saved_offset) + len);
12612
12613     param_list(asn1, subtree, len);
12614 }
12615
12616 static void
12617 dissect_ansi_map_reject(ASN1_SCK *asn1, proto_tree *tree)
12618 {
12619     guint len;
12620     proto_tree *subtree;
12621
12622 #define COMPONENT_ID_TAG 0xcf
12623     if (check_ansi_map_tag(asn1, COMPONENT_ID_TAG))
12624     {
12625         subtree = dissect_ansi_map_component(asn1, tree, &len);
12626
12627         switch (len)
12628         {
12629         case 1:
12630             dissect_ansi_map_octet(asn1, subtree, "Correlation ID:");
12631             break;
12632         }
12633     }
12634
12635     dissect_ansi_problem(asn1, tree);
12636
12637     dissect_ansi_params(asn1, tree);
12638 }
12639
12640 static void
12641 dissect_ansi_map_re(ASN1_SCK *asn1, proto_tree *tree)
12642 {
12643     guint len;
12644     proto_tree *subtree;
12645
12646 #define COMPONENT_ID_TAG 0xcf
12647     if (check_ansi_map_tag(asn1, COMPONENT_ID_TAG))
12648     {
12649         subtree = dissect_ansi_map_component(asn1, tree, &len);
12650
12651         switch (len)
12652         {
12653         case 1:
12654             dissect_ansi_map_octet(asn1, subtree, "Correlation ID:");
12655             break;
12656         }
12657     }
12658
12659     dissect_ansi_error(asn1, tree);
12660
12661     dissect_ansi_params(asn1, tree);
12662 }
12663
12664 static void
12665 dissect_ansi_map_rr(ASN1_SCK *asn1, proto_tree *tree)
12666 {
12667     guint len;
12668     proto_tree *subtree;
12669
12670 #define COMPONENT_ID_TAG 0xcf
12671     if (check_ansi_map_tag(asn1, COMPONENT_ID_TAG))
12672     {
12673         subtree = dissect_ansi_map_component(asn1, tree, &len);
12674
12675         switch (len)
12676         {
12677         case 1:
12678             dissect_ansi_map_octet(asn1, subtree, "Correlation ID:");
12679             break;
12680         }
12681     }
12682
12683     dissect_ansi_params(asn1, tree);
12684 }
12685
12686 static void
12687 dissect_ansi_map_invoke(ASN1_SCK *asn1, packet_info *pinfo, proto_tree *tree)
12688 {
12689     guint len;
12690     proto_tree *subtree;
12691
12692 #define COMPONENT_ID_TAG 0xcf
12693     if (check_ansi_map_tag(asn1, COMPONENT_ID_TAG))
12694     {
12695         subtree = dissect_ansi_map_component(asn1, tree, &len);
12696
12697         switch (len)
12698         {
12699         case 1:
12700             dissect_ansi_map_octet(asn1, subtree, "Invoke ID:");
12701             break;
12702
12703         case 2:
12704             dissect_ansi_map_octet(asn1, subtree, "Invoke ID:");
12705             dissect_ansi_map_octet(asn1, subtree, "Correlation ID:");
12706             break;
12707         }
12708     }
12709
12710     ansi_map_is_invoke = TRUE;
12711
12712     dissect_ansi_opr_code(asn1, pinfo, tree);
12713
12714     dissect_ansi_params(asn1, tree);
12715 }
12716
12717 static void
12718 dissect_ansi_map_message(ASN1_SCK *asn1, packet_info *pinfo, proto_tree *ansi_map_tree)
12719 {
12720     guint       saved_offset;
12721     guint       tag;
12722     guint       len;
12723     gchar       *str = NULL;
12724     proto_item *item, *tag_item;
12725     proto_tree *subtree, *tag_subtree;
12726     gboolean def_len;
12727     static int  i = 0;
12728
12729
12730     saved_offset = asn1->offset;
12731     asn1_id_decode1(asn1, &tag);
12732
12733     str = match_strval(tag, ansi_cmp_type_strings);
12734
12735     if (NULL == str) return;
12736
12737     if (check_col(pinfo->cinfo, COL_INFO))
12738     {
12739         if (0 == i)
12740         {
12741             col_append_fstr(pinfo->cinfo, COL_INFO,  "%s ", str);
12742         }
12743         else
12744         {
12745             col_append_fstr(pinfo->cinfo, COL_INFO,  "& %s ", str);
12746         }
12747     }
12748
12749     item =
12750         proto_tree_add_none_format(ansi_map_tree, hf_ansi_map_none, asn1->tvb,
12751             saved_offset, -1, "Components");
12752     subtree = proto_item_add_subtree(item, ett_components);
12753
12754     tag_item =
12755         proto_tree_add_uint_format(subtree, hf_ansi_map_tag, asn1->tvb,
12756             saved_offset, asn1->offset - saved_offset, tag, str);
12757
12758     dissect_ansi_map_len(asn1, subtree, &def_len, &len);
12759
12760     tag_subtree = proto_item_add_subtree(tag_item, ett_components);
12761
12762     switch (tag)
12763     {
12764     case ANSI_TC_INVOKE_L:
12765         dissect_ansi_map_invoke(asn1, pinfo, tag_subtree);
12766         break;
12767
12768     case ANSI_TC_RRL:
12769         dissect_ansi_map_rr(asn1, tag_subtree);
12770         break;
12771
12772     case ANSI_TC_RE:
12773         dissect_ansi_map_re(asn1, tag_subtree);
12774         break;
12775
12776     case ANSI_TC_REJECT:
12777         dissect_ansi_map_reject(asn1, tag_subtree);
12778         break;
12779
12780     case ANSI_TC_INVOKE_N:
12781         dissect_ansi_map_invoke(asn1, pinfo, tag_subtree);
12782         break;
12783
12784     case ANSI_TC_RRN:
12785         dissect_ansi_map_rr(asn1, tag_subtree);
12786         break;
12787
12788     default:
12789         break;
12790     }
12791
12792     proto_item_set_len(item, asn1->offset - saved_offset);
12793 }
12794
12795 static void
12796 dissect_ansi_map(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
12797 {
12798     proto_item *ansi_map_item;
12799     proto_tree *ansi_map_tree = NULL;
12800     ASN1_SCK   asn1;
12801     int        offset = 0;
12802
12803     if (!proto_is_protocol_enabled(proto_ansi_map))
12804     {
12805         call_dissector(data_handle, tvb, pinfo, tree);
12806         return;
12807     }
12808
12809     g_pinfo = pinfo;
12810
12811     /*
12812      * Make entry in the Protocol column on summary display
12813      */
12814     if (check_col(pinfo->cinfo, COL_PROTOCOL))
12815     {
12816         col_set_str(pinfo->cinfo, COL_PROTOCOL, "ANSI MAP");
12817     }
12818
12819     /* In the interest of speed, if "tree" is NULL, don't do any work not
12820      * necessary to generate protocol tree items.
12821      */
12822     if (tree)
12823     {
12824         g_tree = tree;
12825
12826         /*
12827          * create the ansi_map protocol tree
12828          */
12829         ansi_map_item =
12830             proto_tree_add_item(tree, proto_ansi_map, tvb, 0, -1, FALSE);
12831
12832         ansi_map_tree =
12833             proto_item_add_subtree(ansi_map_item, ett_ansi_map);
12834
12835         asn1_open(&asn1, tvb, offset);
12836
12837         ansi_map_is_invoke = FALSE;
12838         is683_ota = FALSE;
12839         dissect_ansi_map_message(&asn1, pinfo, ansi_map_tree);
12840
12841         asn1_close(&asn1, &offset);
12842     }
12843 }
12844
12845
12846 /* Register the protocol with Ethereal */
12847 void
12848 proto_register_ansi_map(void)
12849 {
12850     guint               i;
12851
12852     /* Setup list of header fields */
12853     static hf_register_info hf[] =
12854     {
12855         { &hf_ansi_map_tag,
12856             { "Tag",            "ansi_map.tag",
12857             FT_UINT8, BASE_HEX, NULL, 0,
12858             "", HFILL }
12859         },
12860         { &hf_ansi_map_length,
12861             { "Length",         "ansi_map.len",
12862             FT_UINT8, BASE_DEC, NULL, 0,
12863             "", HFILL }
12864         },
12865         { &hf_ansi_map_id,
12866             { "Value",          "ansi_map.id",
12867             FT_UINT8, BASE_DEC, NULL, 0,
12868             "", HFILL }
12869         },
12870         { &hf_ansi_map_none,
12871             { "Sub tree",       "ansi_map.none",
12872             FT_NONE, 0, 0, 0,
12873             "", HFILL }
12874         },
12875         { &hf_ansi_map_opr_code,
12876             { "Operation Code", "ansi_map.oprcode",
12877             FT_INT32, BASE_DEC, VALS(ansi_opr_code_strings), 0,
12878             "", HFILL }
12879         },
12880         { &hf_ansi_map_param_id,
12881             { "Param ID",       "ansi_map.param_id",
12882             FT_NONE, 0, 0, 0,
12883             "", HFILL }
12884         },
12885     };
12886
12887     /* Setup protocol subtree array */
12888 #define NUM_INDIVIDUAL_PARAMS   15
12889     static gint *ett[NUM_INDIVIDUAL_PARAMS+NUM_PARAM_1+NUM_PARAM_2+NUM_PARAM_3];
12890
12891     memset((void *) ett, 0, sizeof(ett));
12892
12893     ett[0] = &ett_ansi_map;
12894     ett[1] = &ett_opr_code;
12895     ett[2] = &ett_component;
12896     ett[3] = &ett_components;
12897     ett[4] = &ett_param;
12898     ett[5] = &ett_params;
12899     ett[6] = &ett_error;
12900     ett[7] = &ett_problem;
12901     ett[8] = &ett_natnum;
12902     ett[9] = &ett_call_mode;
12903     ett[10] = &ett_chan_data;
12904     ett[11] = &ett_code_chan;
12905     ett[12] = &ett_clr_dig_mask;
12906     ett[13] = &ett_ent_dig_mask;
12907     ett[14] = &ett_all_dig_mask;
12908
12909     for (i=0; i < NUM_PARAM_1; i++)
12910     {
12911         ett_ansi_param_1[i] = -1;
12912         ett[NUM_INDIVIDUAL_PARAMS+i] = &ett_ansi_param_1[i];
12913     }
12914
12915     for (i=0; i < NUM_PARAM_2; i++)
12916     {
12917         ett_ansi_param_2[i] = -1;
12918         ett[NUM_INDIVIDUAL_PARAMS+NUM_PARAM_1+i] = &ett_ansi_param_2[i];
12919     }
12920
12921     for (i=0; i < NUM_PARAM_3; i++)
12922     {
12923         ett_ansi_param_3[i] = -1;
12924         ett[NUM_INDIVIDUAL_PARAMS+NUM_PARAM_1+NUM_PARAM_2+i] = &ett_ansi_param_3[i];
12925     }
12926
12927     /* Register the protocol name and description */
12928     proto_ansi_map =
12929         proto_register_protocol("ANSI Mobile Application Part",
12930             "ANSI MAP", "ansi_map");
12931
12932     is637_tele_id_dissector_table =
12933         register_dissector_table("ansi_map.tele_id", "IS-637 Teleservice ID",
12934             FT_UINT8, BASE_DEC);
12935
12936     is683_dissector_table =
12937         register_dissector_table("ansi_map.ota", "IS-683-A (OTA)",
12938             FT_UINT8, BASE_DEC);
12939
12940     /* Required function calls to register the header fields and subtrees used */
12941     proto_register_field_array(proto_ansi_map, hf, array_length(hf));
12942     proto_register_subtree_array(ett, array_length(ett));
12943 }
12944
12945
12946 void
12947 proto_reg_handoff_ansi_map(void)
12948 {
12949     dissector_handle_t ansi_map_handle;
12950
12951     ansi_map_handle = create_dissector_handle(dissect_ansi_map, proto_ansi_map);
12952
12953     dissector_add("tcap.ansi_ssn", 5, ansi_map_handle);
12954     dissector_add("tcap.ansi_ssn", 6, ansi_map_handle);
12955     dissector_add("tcap.ansi_ssn", 7, ansi_map_handle);
12956     dissector_add("tcap.ansi_ssn", 8, ansi_map_handle);
12957     dissector_add("tcap.ansi_ssn", 9 , ansi_map_handle);
12958     dissector_add("tcap.ansi_ssn", 10 , ansi_map_handle);
12959     dissector_add("tcap.ansi_ssn", 11 , ansi_map_handle);
12960     dissector_add("tcap.ansi_ssn", 12 , ansi_map_handle);
12961
12962     data_handle = find_dissector("data");
12963 }