/* packet-sccp.c * Routines for Signalling Connection Control Part (SCCP) dissection * * It is hopefully compliant to: * ANSI T1.112.3-1996 * ITU-T Q.713 7/1996 * YDN 038-1997 (Chinese ITU variant) * * Copyright 2002, Jeff Morriss * * $Id: packet-sccp.c,v 1.19 2003/12/18 00:43:48 guy Exp $ * * Ethereal - Network traffic analyzer * By Gerald Combs * Copyright 1998 Gerald Combs * * Copied from packet-m2pa.c * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include #include #include #ifdef NEED_SNPRINTF_H #include "snprintf.h" #endif #include #include "packet-mtp3.h" #include "prefs.h" #define SCCP_SI 3 #define MESSAGE_TYPE_OFFSET 0 #define MESSAGE_TYPE_LENGTH 1 #define POINTER_LENGTH 1 #define POINTER_LENGTH_LONG 2 #define MESSAGE_TYPE_CR 0x01 #define MESSAGE_TYPE_CC 0x02 #define MESSAGE_TYPE_CREF 0x03 #define MESSAGE_TYPE_RLSD 0x04 #define MESSAGE_TYPE_RLC 0x05 #define MESSAGE_TYPE_DT1 0x06 #define MESSAGE_TYPE_DT2 0x07 #define MESSAGE_TYPE_AK 0x08 #define MESSAGE_TYPE_UDT 0x09 #define MESSAGE_TYPE_UDTS 0x0a #define MESSAGE_TYPE_ED 0x0b #define MESSAGE_TYPE_EA 0x0c #define MESSAGE_TYPE_RSR 0x0d #define MESSAGE_TYPE_RSC 0x0e #define MESSAGE_TYPE_ERR 0x0f #define MESSAGE_TYPE_IT 0x10 #define MESSAGE_TYPE_XUDT 0x11 #define MESSAGE_TYPE_XUDTS 0x12 /* The below 2 are ITU only */ #define MESSAGE_TYPE_LUDT 0x13 #define MESSAGE_TYPE_LUDTS 0x14 /* Same as below but with names typed out */ static const value_string sccp_message_type_values[] = { { MESSAGE_TYPE_CR, "Connection Request" }, { MESSAGE_TYPE_CC, "Connection Confirm" }, { MESSAGE_TYPE_CREF, "Connection Refused" }, { MESSAGE_TYPE_RLSD, "Released" }, { MESSAGE_TYPE_RLC, "Release Complete" }, { MESSAGE_TYPE_DT1, "Data Form 1" }, { MESSAGE_TYPE_DT2, "Data Form 2" }, { MESSAGE_TYPE_AK, "Data Acknowledgement" }, { MESSAGE_TYPE_UDT, "Unitdata" }, { MESSAGE_TYPE_UDTS, "Unitdata Service" }, { MESSAGE_TYPE_ED, "Expedited Data" }, { MESSAGE_TYPE_EA, "Expedited Data Acknowledgement" }, { MESSAGE_TYPE_RSR, "Reset Request" }, { MESSAGE_TYPE_RSC, "Reset Confirmation" }, { MESSAGE_TYPE_ERR, "Error" }, { MESSAGE_TYPE_IT, "Inactivity Timer" }, { MESSAGE_TYPE_XUDT, "Extended Unitdata" }, { MESSAGE_TYPE_XUDTS, "Extended Unitdata Service" }, { MESSAGE_TYPE_LUDT, "Long Unitdata (ITU)" }, { MESSAGE_TYPE_LUDTS, "Long Unitdata Service (ITU)" }, { 0, NULL } }; /* Same as above but in acronym form (for the Info column) */ static const value_string sccp_message_type_acro_values[] = { { MESSAGE_TYPE_CR, "CR" }, { MESSAGE_TYPE_CC, "CC" }, { MESSAGE_TYPE_CREF, "CREF" }, { MESSAGE_TYPE_RLSD, "RLSD" }, { MESSAGE_TYPE_RLC, "RLC" }, { MESSAGE_TYPE_DT1, "DT1" }, { MESSAGE_TYPE_DT2, "DT2" }, { MESSAGE_TYPE_AK, "AK" }, { MESSAGE_TYPE_UDT, "UDT" }, { MESSAGE_TYPE_UDTS, "UDTS" }, { MESSAGE_TYPE_ED, "ED" }, { MESSAGE_TYPE_EA, "EA" }, { MESSAGE_TYPE_RSR, "RSR" }, { MESSAGE_TYPE_RSC, "RSC" }, { MESSAGE_TYPE_ERR, "ERR" }, { MESSAGE_TYPE_IT, "IT" }, { MESSAGE_TYPE_XUDT, "XUDT" }, { MESSAGE_TYPE_XUDTS, "XUDTS" }, { MESSAGE_TYPE_LUDT, "LUDT" }, { MESSAGE_TYPE_LUDTS, "LUDTS" }, { 0, NULL } }; #define PARAMETER_LENGTH_LENGTH 1 #define PARAMETER_LONG_DATA_LENGTH_LENGTH 2 #define PARAMETER_TYPE_LENGTH 1 #define PARAMETER_END_OF_OPTIONAL_PARAMETERS 0x00 #define PARAMETER_DESTINATION_LOCAL_REFERENCE 0x01 #define PARAMETER_SOURCE_LOCAL_REFERENCE 0x02 #define PARAMETER_CALLED_PARTY_ADDRESS 0x03 #define PARAMETER_CALLING_PARTY_ADDRESS 0x04 #define PARAMETER_CLASS 0x05 #define PARAMETER_SEGMENTING_REASSEMBLING 0x06 #define PARAMETER_RECEIVE_SEQUENCE_NUMBER 0x07 #define PARAMETER_SEQUENCING_SEGMENTING 0x08 #define PARAMETER_CREDIT 0x09 #define PARAMETER_RELEASE_CAUSE 0x0a #define PARAMETER_RETURN_CAUSE 0x0b #define PARAMETER_RESET_CAUSE 0x0c #define PARAMETER_ERROR_CAUSE 0x0d #define PARAMETER_REFUSAL_CAUSE 0x0e #define PARAMETER_DATA 0x0f #define PARAMETER_SEGMENTATION 0x10 #define PARAMETER_HOP_COUNTER 0x11 /* The below 2 are ITU only */ #define PARAMETER_IMPORTANCE 0x12 #define PARAMETER_LONG_DATA 0x13 /* ISNI is ANSI only */ #define PARAMETER_ISNI 0xfa static const value_string sccp_parameter_values[] = { { PARAMETER_END_OF_OPTIONAL_PARAMETERS, "End of Optional Parameters" }, { PARAMETER_DESTINATION_LOCAL_REFERENCE, "Destination Local Reference" }, { PARAMETER_SOURCE_LOCAL_REFERENCE, "Source Local Reference" }, { PARAMETER_CALLED_PARTY_ADDRESS, "Called Party Address" }, { PARAMETER_CALLING_PARTY_ADDRESS, "Calling Party Address" }, { PARAMETER_CLASS, "Protocol Class" }, { PARAMETER_SEGMENTING_REASSEMBLING, "Segmenting/Reassembling" }, { PARAMETER_RECEIVE_SEQUENCE_NUMBER, "Receive Sequence Number" }, { PARAMETER_SEQUENCING_SEGMENTING, "Sequencing/Segmenting" }, { PARAMETER_CREDIT, "Credit" }, { PARAMETER_RELEASE_CAUSE, "Release Cause" }, { PARAMETER_RETURN_CAUSE, "Return Cause" }, { PARAMETER_RESET_CAUSE, "Reset Cause" }, { PARAMETER_ERROR_CAUSE, "Error Cause" }, { PARAMETER_REFUSAL_CAUSE, "Refusal Cause" }, { PARAMETER_DATA, "Data" }, { PARAMETER_SEGMENTATION, "Segmentation" }, { PARAMETER_HOP_COUNTER, "Hop Counter" }, { PARAMETER_IMPORTANCE, "Importance (ITU)" }, { PARAMETER_LONG_DATA, "Long Data (ITU)" }, { PARAMETER_ISNI, "Intermediate Signaling Network Identification (ANSI)" }, { 0, NULL } }; #define END_OF_OPTIONAL_PARAMETERS_LENGTH 1 #define DESTINATION_LOCAL_REFERENCE_LENGTH 3 #define SOURCE_LOCAL_REFERENCE_LENGTH 3 #define PROTOCOL_CLASS_LENGTH 1 #define RECEIVE_SEQUENCE_NUMBER_LENGTH 1 #define CREDIT_LENGTH 1 #define RELEASE_CAUSE_LENGTH 1 #define RETURN_CAUSE_LENGTH 1 #define RESET_CAUSE_LENGTH 1 #define ERROR_CAUSE_LENGTH 1 #define REFUSAL_CAUSE_LENGTH 1 #define HOP_COUNTER_LENGTH 1 #define IMPORTANCE_LENGTH 1 /* Parts of the Called and Calling Address parameters */ /* Address Indicator */ #define ADDRESS_INDICATOR_LENGTH 1 #define ITU_RESERVED_MASK 0x80 #define ANSI_NATIONAL_MASK 0x80 #define ROUTING_INDICATOR_MASK 0x40 #define GTI_MASK 0x3C #define GTI_SHIFT 2 #define ITU_SSN_INDICATOR_MASK 0x02 #define ITU_PC_INDICATOR_MASK 0x01 #define ANSI_PC_INDICATOR_MASK 0x02 #define ANSI_SSN_INDICATOR_MASK 0x01 static const value_string sccp_national_indicator_values[] = { { 0x0, "Address coded to International standard" }, { 0x1, "Address coded to National standard" }, { 0, NULL } }; static const value_string sccp_routing_indicator_values[] = { { 0x0, "Route on GT" }, { 0x1, "Route on SSN" }, { 0, NULL } }; #define AI_GTI_NO_GT 0x0 #define ITU_AI_GTI_NAI 0x1 #define AI_GTI_TT 0x2 #define ITU_AI_GTI_TT_NP_ES 0x3 #define ITU_AI_GTI_TT_NP_ES_NAI 0x4 static const value_string sccp_itu_global_title_indicator_values[] = { { AI_GTI_NO_GT, "No Global Title" }, { ITU_AI_GTI_NAI, "Nature of Address Indicator only" }, { AI_GTI_TT, "Translation Type only" }, { ITU_AI_GTI_TT_NP_ES, "Translation Type, Numbering Plan, and Encoding Scheme included" }, { ITU_AI_GTI_TT_NP_ES_NAI, "Translation Type, Numbering Plan, Encoding Scheme, and Nature of Address Indicator included" }, { 0, NULL } }; /* #define AI_GTI_NO_GT 0x0 */ #define ANSI_AI_GTI_TT_NP_ES 0x1 /* #define AI_GTI_TT 0x2 */ static const value_string sccp_ansi_global_title_indicator_values[] = { { AI_GTI_NO_GT, "No Global Title" }, { ANSI_AI_GTI_TT_NP_ES, "Translation Type, Numbering Plan, and Encoding Scheme included" }, { AI_GTI_TT, "Translation Type only" }, { 0, NULL } }; static const value_string sccp_ai_pci_values[] = { { 0x1, "Point Code present" }, { 0x0, "Point Code not present" }, { 0, NULL } }; static const value_string sccp_ai_ssni_values[] = { { 0x1, "SSN present" }, { 0x0, "SSN not present" }, { 0, NULL } }; #define ADDRESS_SSN_LENGTH 1 #define INVALID_SSN 0xff static const value_string sccp_ssn_values[] = { { 0x00, "SSN not known/not used" }, { 0x01, "SCCP management" }, { 0x02, "Reserved for ITU-T allocation" }, { 0x03, "ISDN User Part" }, { 0x04, "OMAP (Operation, Maintenance, and Administration Part)" }, { 0x05, "MAP (Mobile Application Part)" }, { 0x06, "HLR (Home Location Register)" }, { 0x07, "VLR (Visitor Location Register)" }, { 0x08, "MSC (Mobile Switching Center)" }, { 0x09, "EIC/EIR (Equipment Identifier Center/Equipment Identification Register)" }, { 0x0a, "AUC/AC (Authentication Center)" }, { 0x0b, "ISDN supplementary services (ITU only)" }, { 0x0c, "Reserved for international use (ITU only)" }, { 0x0d, "Broadband ISDN edge-to-edge applications (ITU only)" }, { 0x0e, "TC test responder (ITU only)" }, { 0x8e, "RANAP" }, { 0xfc, "IOS" }, { 0xfe, "BSSAP/BSAP" }, { 0, NULL } }; /* * * * * * * * * * * * * * * * * * Global Title: ITU GTI == 0001 * * * * * * * * * * * * * * * * * */ #define GT_NAI_MASK 0x7F #define GT_NAI_LENGTH 1 static const value_string sccp_nai_values[] = { { 0x00, "NAI unknown" }, { 0x01, "Subscriber Number" }, { 0x02, "Reserved for national use" }, { 0x03, "National significant number" }, { 0x04, "International number" }, { 0, NULL } }; #define GT_OE_MASK 0x80 #define GT_OE_EVEN 0 #define GT_OE_ODD 1 static const value_string sccp_oe_values[] = { { GT_OE_EVEN, "Even number of address signals" }, { GT_OE_ODD, "Odd number of address signals" }, { 0, NULL } }; #define GT_SIGNAL_LENGTH 1 #define GT_ODD_SIGNAL_MASK 0x0f #define GT_EVEN_SIGNAL_MASK 0xf0 #define GT_EVEN_SIGNAL_SHIFT 4 #define GT_MAX_SIGNALS 32 static const value_string sccp_address_signal_values[] = { { 0, "0" }, { 1, "1" }, { 2, "2" }, { 3, "3" }, { 4, "4" }, { 5, "5" }, { 6, "6" }, { 7, "7" }, { 8, "8" }, { 9, "9" }, { 10, "(spare)" }, { 11, "11" }, { 12, "12" }, { 13, "(spare)" }, { 14, "(spare)" }, { 15, "ST" }, { 0, NULL } }; /* * * * * * * * * * * * * * * * * * * * * * Global Title: ITU and ANSI GTI == 0010 * * * * * * * * * * * * * * * * * * * * * */ #define GT_TT_LENGTH 1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * Global Title: ITU GTI == 0011, ANSI GTI == 0001 * * * * * * * * * * * * * * * * * * * * * * * * * * */ #define GT_NP_MASK 0xf0 #define GT_NP_ES_LENGTH 1 static const value_string sccp_np_values[] = { { 0x0, "Unknown" }, { 0x1, "ISDN/telephony" }, { 0x2, "Generic (ITU)/Reserved (ANSI)" }, { 0x3, "Data" }, { 0x4, "Telex" }, { 0x5, "Maritime mobile" }, { 0x6, "Land mobile" }, { 0x7, "ISDN/mobile" }, { 0xe, "Private network or network-specific" }, { 0xf, "Reserved" }, { 0, NULL } }; #define GT_ES_MASK 0x0f #define GT_ES_UNKNOWN 0x0 #define GT_ES_BCD_ODD 0x1 #define GT_ES_BCD_EVEN 0x2 #define GT_ES_NATIONAL 0x3 #define GT_ES_RESERVED 0xf static const value_string sccp_es_values[] = { { GT_ES_UNKNOWN, "Unknown" }, { GT_ES_BCD_ODD, "BCD, odd number of digits" }, { GT_ES_BCD_EVEN, "BCD, even number of digits" }, { GT_ES_NATIONAL, "National specific" }, { GT_ES_RESERVED, "Reserved (ITU)/Spare (ANSI)" }, { 0, NULL } }; /* Address signals above */ /* * * * * * * * * * * * * * * * * * Global Title: ITU GTI == 0100 * * * * * * * * * * * * * * * * * */ /* NP above */ /* ES above */ /* NAI above */ /* Address signals above */ #define CLASS_CLASS_MASK 0xf #define CLASS_SPARE_HANDLING_MASK 0xf0 static const value_string sccp_class_handling_values [] = { { 0x0, "No special options" }, { 0x8, "Return message on error" }, { 0, NULL } }; #define SEGMENTING_REASSEMBLING_LENGTH 1 #define SEGMENTING_REASSEMBLING_MASK 0x01 #define NO_MORE_DATA 0 #define MORE_DATA 1 /* This is also used by sequencing-segmenting parameter */ static const value_string sccp_segmenting_reassembling_values [] = { { NO_MORE_DATA, "No more data" }, { MORE_DATA, "More data" }, { 0, NULL } }; #define RECEIVE_SEQUENCE_NUMBER_LENGTH 1 #define RSN_MASK 0xfe #define SEQUENCING_SEGMENTING_LENGTH 2 #define SEQUENCING_SEGMENTING_SSN_LENGTH 1 #define SEQUENCING_SEGMENTING_RSN_LENGTH 1 #define SEND_SEQUENCE_NUMBER_MASK 0xfe #define RECEIVE_SEQUENCE_NUMBER_MASK 0xfe #define SEQUENCING_SEGMENTING_MORE_MASK 0x01 #define CREDIT_LENGTH 1 #define RELEASE_CAUSE_LENGTH 1 static const value_string sccp_release_cause_values [] = { { 0x00, "End user originated" }, { 0x01, "End user congestion" }, { 0x02, "End user failure" }, { 0x03, "SCCP user originated" }, { 0x04, "Remote procedure error" }, { 0x05, "Inconsistent connection data" }, { 0x06, "Access failure" }, { 0x07, "Access congestion" }, { 0x08, "Subsystem failure" }, { 0x09, "Subsystem congestion" }, { 0x0a, "MTP failure" }, { 0x0b, "Netowrk congestion" }, { 0x0c, "Expiration of reset timer" }, { 0x0d, "Expiration of receive inactivity timer" }, { 0x0e, "Reserved" }, { 0x0f, "Unqualified" }, { 0x10, "SCCP failure (ITU only)" }, { 0, NULL } }; #define RETURN_CAUSE_LENGTH 1 static const value_string sccp_return_cause_values [] = { { 0x00, "No translation for an address of such nature" }, { 0x01, "No translation for this specific address" }, { 0x02, "Subsystem congestion" }, { 0x03, "Subsystem failure" }, { 0x04, "Unequipped failure" }, { 0x05, "MTP failure" }, { 0x06, "Network congestion" }, { 0x07, "Unqualified" }, { 0x08, "Error in message transport" }, { 0x09, "Error in local processing" }, { 0x0a, "Destination cannot perform reassembly" }, { 0x0b, "SCCP failure" }, { 0x0c, "Hop counter violation" }, { 0x0d, "Segmentation not supported (ITU only)" }, { 0x0e, "Segmentation failure (ITU only)" }, { 0xf9, "Invalid ISNI routing request (ANSI only)"}, { 0xfa, "Unauthorized message (ANSI only)" }, { 0xfb, "Message incompatibility (ANSI only)" }, { 0xfc, "Cannot perform ISNI constrained routing (ANSI only)" }, { 0xfd, "Unable to perform ISNI identification (ANSI only)" }, { 0, NULL } }; #define RESET_CAUSE_LENGTH 1 static const value_string sccp_reset_cause_values [] = { { 0x00, "End user originated" }, { 0x01, "SCCP user originated" }, { 0x02, "Message out of order - incorrect send sequence number" }, { 0x03, "Message out of order - incorrect receive sequence number" }, { 0x04, "Remote procedure error - message out of window" }, { 0x05, "Remote procedure error - incorrect send sequence number after (re)initialization" }, { 0x06, "Remote procedure error - general" }, { 0x07, "Remote end user operational" }, { 0x08, "Network operational" }, { 0x09, "Access operational" }, { 0x0a, "Network congestion" }, { 0x0b, "Reserved (ITU)/Not obtainable (ANSI)" }, { 0x0c, "Unqualified" }, { 0, NULL } }; #define ERROR_CAUSE_LENGTH 1 static const value_string sccp_error_cause_values [] = { { 0x00, "Local Reference Number (LRN) mismatch - unassigned destination LRN" }, { 0x01, "Local Reference Number (LRN) mismatch - inconsistent source LRN" }, { 0x02, "Point code mismatch" }, { 0x03, "Service class mismatch" }, { 0x04, "Unqualified" }, { 0, NULL } }; #define REFUSAL_CAUSE_LENGTH 1 static const value_string sccp_refusal_cause_values [] = { { 0x00, "End user originated" }, { 0x01, "End user congestion" }, { 0x02, "End user failure" }, { 0x03, "SCCP user originated" }, { 0x04, "Destination address unknown" }, { 0x05, "Destination inaccessible" }, { 0x06, "Network resource - QOS not available/non-transient" }, { 0x07, "Network resource - QOS not available/transient" }, { 0x08, "Access failure" }, { 0x09, "Access congestion" }, { 0x0a, "Subsystem failure" }, { 0x0b, "Subsystem congestion" }, { 0x0c, "Expiration of connection establishment timer" }, { 0x0d, "Incompatible user data" }, { 0x0e, "Reserved" }, { 0x0f, "Unqualified" }, { 0x10, "Hop counter violation" }, { 0x11, "SCCP failure (ITU only)" }, { 0x12, "No translation for an address of such nature" }, { 0x13, "Unequipped user" }, { 0, NULL } }; #define SEGMENTATION_LENGTH 4 #define SEGMENTATION_FIRST_SEGMENT_MASK 0x80 #define SEGMENTATION_CLASS_MASK 0x40 #define SEGMENTATION_SPARE_MASK 0x30 #define SEGMENTATION_REMAINING_MASK 0x0f static const value_string sccp_segmentation_first_segment_values [] = { { 1, "First segment" }, { 0, "Not first segment" }, { 0, NULL } }; static const value_string sccp_segmentation_class_values [] = { { 0, "Class 0 selected" }, { 1, "Class 1 selected" }, { 0, NULL } }; #define HOP_COUNTER_LENGTH 1 #define IMPORTANCE_LENGTH 1 #define IMPORTANCE_IMPORTANCE_MASK 0x7 #define ANSI_ISNI_ROUTING_CONTROL_LENGTH 1 #define ANSI_ISNI_MI_MASK 0x01 #define ANSI_ISNI_IRI_MASK 0x06 #define ANSI_ISNI_RES_MASK 0x08 #define ANSI_ISNI_TI_MASK 0x10 #define ANSI_ISNI_TI_SHIFT 4 #define ANSI_ISNI_COUNTER_MASK 0xe0 #define ANSI_ISNI_NETSPEC_MASK 0x03 static const value_string sccp_isni_mark_for_id_values [] = { { 0x0, "Do not identify networks" }, { 0x1, "Identify networks" }, { 0, NULL } }; static const value_string sccp_isni_iri_values [] = { { 0x0, "Neither constrained nor suggested ISNI routing" }, { 0x1, "Constrained ISNI routing" }, { 0x2, "Reserved for suggested ISNI routing" }, { 0x3, "Spare" }, { 0, NULL } }; #define ANSI_ISNI_TYPE_0 0x0 #define ANSI_ISNI_TYPE_1 0x1 static const value_string sccp_isni_ti_values [] = { { ANSI_ISNI_TYPE_0, "Type zero ISNI parameter format" }, { ANSI_ISNI_TYPE_1, "Type one ISNI parameter format" }, { 0, NULL } }; /* Initialize the protocol and registered fields */ static int proto_sccp = -1; static int hf_sccp_message_type = -1; static int hf_sccp_variable_pointer1 = -1; static int hf_sccp_variable_pointer2 = -1; static int hf_sccp_variable_pointer3 = -1; static int hf_sccp_optional_pointer = -1; static int hf_sccp_ssn = -1; static int hf_sccp_gt_digits = -1; /* Called Party address */ static int hf_sccp_called_national_indicator = -1; static int hf_sccp_called_routing_indicator = -1; static int hf_sccp_called_itu_global_title_indicator = -1; static int hf_sccp_called_ansi_global_title_indicator = -1; static int hf_sccp_called_itu_ssn_indicator = -1; static int hf_sccp_called_itu_point_code_indicator = -1; static int hf_sccp_called_ansi_ssn_indicator = -1; static int hf_sccp_called_ansi_point_code_indicator = -1; static int hf_sccp_called_ssn = -1; static int hf_sccp_called_pc_member = -1; static int hf_sccp_called_pc_cluster = -1; static int hf_sccp_called_pc_network = -1; static int hf_sccp_called_ansi_pc = -1; static int hf_sccp_called_chinese_pc = -1; static int hf_sccp_called_itu_pc = -1; static int hf_sccp_called_gt_nai = -1; static int hf_sccp_called_gt_oe = -1; static int hf_sccp_called_gt_tt = -1; static int hf_sccp_called_gt_np = -1; static int hf_sccp_called_gt_es = -1; static int hf_sccp_called_gt_digits = -1; /* Calling party address */ static int hf_sccp_calling_national_indicator = -1; static int hf_sccp_calling_routing_indicator = -1; static int hf_sccp_calling_itu_global_title_indicator = -1; static int hf_sccp_calling_ansi_global_title_indicator = -1; static int hf_sccp_calling_itu_ssn_indicator = -1; static int hf_sccp_calling_itu_point_code_indicator = -1; static int hf_sccp_calling_ansi_ssn_indicator = -1; static int hf_sccp_calling_ansi_point_code_indicator = -1; static int hf_sccp_calling_ssn = -1; static int hf_sccp_calling_pc_member = -1; static int hf_sccp_calling_pc_cluster = -1; static int hf_sccp_calling_pc_network = -1; static int hf_sccp_calling_ansi_pc = -1; static int hf_sccp_calling_chinese_pc = -1; static int hf_sccp_calling_itu_pc = -1; static int hf_sccp_calling_gt_nai = -1; static int hf_sccp_calling_gt_oe = -1; static int hf_sccp_calling_gt_tt = -1; static int hf_sccp_calling_gt_np = -1; static int hf_sccp_calling_gt_es = -1; static int hf_sccp_calling_gt_digits = -1; /* Other parameter values */ static int hf_sccp_dlr = -1; static int hf_sccp_slr = -1; static int hf_sccp_class = -1; static int hf_sccp_handling = -1; static int hf_sccp_more = -1; static int hf_sccp_rsn = -1; static int hf_sccp_sequencing_segmenting_ssn = -1; static int hf_sccp_sequencing_segmenting_rsn = -1; static int hf_sccp_sequencing_segmenting_more = -1; static int hf_sccp_credit = -1; static int hf_sccp_release_cause = -1; static int hf_sccp_return_cause = -1; static int hf_sccp_reset_cause = -1; static int hf_sccp_error_cause = -1; static int hf_sccp_refusal_cause = -1; static int hf_sccp_segmentation_first = -1; static int hf_sccp_segmentation_class = -1; static int hf_sccp_segmentation_remaining = -1; static int hf_sccp_segmentation_slr = -1; static int hf_sccp_hop_counter = -1; static int hf_sccp_importance = -1; static int hf_sccp_ansi_isni_mi = -1; static int hf_sccp_ansi_isni_iri = -1; static int hf_sccp_ansi_isni_ti = -1; static int hf_sccp_ansi_isni_netspec = -1; static int hf_sccp_ansi_isni_counter = -1; /* Initialize the subtree pointers */ static gint ett_sccp = -1; static gint ett_sccp_called = -1; static gint ett_sccp_called_ai = -1; static gint ett_sccp_called_pc = -1; static gint ett_sccp_called_gt = -1; static gint ett_sccp_calling = -1; static gint ett_sccp_calling_ai = -1; static gint ett_sccp_calling_pc = -1; static gint ett_sccp_calling_gt = -1; static gint ett_sccp_sequencing_segmenting = -1; static gint ett_sccp_segmentation = -1; static gint ett_sccp_ansi_isni_routing_control = -1; /* * Here are the global variables associated with * the various user definable characteristics of the dissection */ static guint32 sccp_source_pc_global = 0; static gboolean sccp_show_length = FALSE; static module_t *sccp_module; static heur_dissector_list_t heur_subdissector_list; /* Keep track of SSN value of current message so if/when we get to the data * parameter, we can call appropriate sub-dissector. TODO: can this info * be stored elsewhere? */ static guint8 called_ssn = INVALID_SSN; static guint8 calling_ssn = INVALID_SSN; static dissector_handle_t data_handle; static dissector_table_t sccp_ssn_dissector_table; static void dissect_sccp_unknown_message(tvbuff_t *message_tvb, proto_tree *sccp_tree) { guint32 message_length; message_length = tvb_length(message_tvb); proto_tree_add_text(sccp_tree, message_tvb, 0, message_length, "Unknown message (%u byte%s)", message_length, plurality(message_length, "", "s")); } static void dissect_sccp_unknown_param(tvbuff_t *tvb, proto_tree *tree, guint8 type, guint length) { proto_tree_add_text(tree, tvb, 0, length, "Unknown parameter 0x%x (%u byte%s)", type, length, plurality(length, "", "s")); } static void dissect_sccp_dlr_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint32 reference; reference = tvb_get_letoh24(tvb, 0); proto_tree_add_uint(tree, hf_sccp_dlr, tvb, 0, length, reference); } static void dissect_sccp_slr_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint32 reference; reference = tvb_get_letoh24(tvb, 0); proto_tree_add_uint(tree, hf_sccp_slr, tvb, 0, length, reference); } static void dissect_sccp_gt_address_information(tvbuff_t *tvb, proto_tree *tree, guint length, gboolean even_length, gboolean called) { guint offset = 0; guint8 odd_signal, even_signal = 0x0f; char gt_digits[GT_MAX_SIGNALS] = { 0 }; while(offset < length) { odd_signal = tvb_get_guint8(tvb, offset) & GT_ODD_SIGNAL_MASK; even_signal = tvb_get_guint8(tvb, offset) & GT_EVEN_SIGNAL_MASK; even_signal >>= GT_EVEN_SIGNAL_SHIFT; strcat(gt_digits, val_to_str(odd_signal, sccp_address_signal_values, "Unknown")); /* If the last signal is NOT filler */ if (offset != (length - 1) || even_length == TRUE) strcat(gt_digits, val_to_str(even_signal, sccp_address_signal_values, "Unknown")); offset += GT_SIGNAL_LENGTH; } proto_tree_add_string_format(tree, called ? hf_sccp_called_gt_digits : hf_sccp_calling_gt_digits, tvb, 0, length, gt_digits, "Address information (digits): %s", gt_digits); proto_tree_add_string_hidden(tree, called ? hf_sccp_gt_digits : hf_sccp_gt_digits, tvb, 0, length, gt_digits); } static void dissect_sccp_global_title(tvbuff_t *tvb, proto_tree *tree, guint length, guint8 gti, gboolean called) { proto_item *gt_item = 0; proto_tree *gt_tree = 0; tvbuff_t *signals_tvb; guint offset = 0; guint8 odd_even, nai, tt, np, es; gboolean even = TRUE; /* Shift GTI to where we can work with it */ gti >>= GTI_SHIFT; gt_item = proto_tree_add_text(tree, tvb, offset, length, "Global Title 0x%x (%u byte%s)", gti, length, plurality(length,"", "s")); gt_tree = proto_item_add_subtree(gt_item, called ? ett_sccp_called_gt : ett_sccp_calling_gt); /* Decode Transation Type (if present) */ switch (gti) { case AI_GTI_TT: /* Protocol doesn't tell us, so we ASSUME even... */ even = TRUE; /* Fall through */ case ITU_AI_GTI_TT_NP_ES: case ITU_AI_GTI_TT_NP_ES_NAI: case ANSI_AI_GTI_TT_NP_ES: tt = tvb_get_guint8(tvb, offset); proto_tree_add_uint(gt_tree, called ? hf_sccp_called_gt_tt : hf_sccp_calling_gt_tt, tvb, offset, GT_TT_LENGTH, tt); offset += GT_TT_LENGTH; } /* Decode Numbering Plan and Encoding Scheme (if present) */ switch (gti) { case ITU_AI_GTI_TT_NP_ES: case ITU_AI_GTI_TT_NP_ES_NAI: case ANSI_AI_GTI_TT_NP_ES: np = tvb_get_guint8(tvb, offset) & GT_NP_MASK; proto_tree_add_uint(gt_tree, called ? hf_sccp_called_gt_np : hf_sccp_calling_gt_np, tvb, offset, GT_NP_ES_LENGTH, np); es = tvb_get_guint8(tvb, offset) & GT_ES_MASK; proto_tree_add_uint(gt_tree, called ? hf_sccp_called_gt_es : hf_sccp_calling_gt_es, tvb, offset, GT_NP_ES_LENGTH, es); even = (es == GT_ES_BCD_EVEN) ? TRUE : FALSE; offset += GT_NP_ES_LENGTH; } /* Decode Odd/Even Indicator (if present) */ if (gti == ITU_AI_GTI_NAI) { odd_even = tvb_get_guint8(tvb, offset) & GT_OE_MASK; proto_tree_add_uint(gt_tree, called ? hf_sccp_called_gt_oe : hf_sccp_calling_gt_oe, tvb, offset, GT_NAI_LENGTH, odd_even); even = (odd_even == GT_OE_EVEN) ? TRUE : FALSE; /* offset doesn't change */ } /* Decode Nature of Address Indicator (if present) */ switch (gti) { case ITU_AI_GTI_NAI: case ITU_AI_GTI_TT_NP_ES_NAI: nai = tvb_get_guint8(tvb, offset) & GT_NAI_MASK; proto_tree_add_uint(gt_tree, called ? hf_sccp_called_gt_nai : hf_sccp_calling_gt_nai, tvb, offset, GT_NAI_LENGTH, nai); offset += GT_NAI_LENGTH; } /* Decode address signal(s) */ if (length < offset) return; signals_tvb = tvb_new_subset(tvb, offset, (length - offset), (length - offset)); dissect_sccp_gt_address_information(signals_tvb, gt_tree, (length - offset), even, called); } static int dissect_sccp_3byte_pc(tvbuff_t *tvb, proto_tree *call_tree, guint offset, gboolean called) { guint32 dpc; proto_item *call_pc_item = 0; proto_tree *call_pc_tree = 0; char pc[ANSI_PC_STRING_LENGTH]; int *hf_pc; if (mtp3_standard == ANSI_STANDARD) { if (called) hf_pc = &hf_sccp_called_ansi_pc; else hf_pc = &hf_sccp_calling_ansi_pc; } else /* CHINESE_ITU_STANDARD */ { if (called) hf_pc = &hf_sccp_called_chinese_pc; else hf_pc = &hf_sccp_calling_chinese_pc; } /* create the DPC tree; modified from that in packet-mtp3.c */ dpc = tvb_get_ntoh24(tvb, offset); snprintf(pc, sizeof(pc), "%d-%d-%d", (dpc & ANSI_NETWORK_MASK), ((dpc & ANSI_CLUSTER_MASK) >> 8), ((dpc & ANSI_MEMBER_MASK) >> 16)); call_pc_item = proto_tree_add_string_format(call_tree, *hf_pc, tvb, offset, ANSI_PC_LENGTH, pc, "PC (%s)", pc); call_pc_tree = proto_item_add_subtree(call_pc_item, called ? ett_sccp_called_pc : ett_sccp_calling_pc); proto_tree_add_uint(call_pc_tree, called ? hf_sccp_called_pc_member : hf_sccp_calling_pc_member, tvb, offset, ANSI_NCM_LENGTH, dpc); offset += ANSI_NCM_LENGTH; proto_tree_add_uint(call_pc_tree, called ? hf_sccp_called_pc_cluster : hf_sccp_calling_pc_cluster, tvb, offset, ANSI_NCM_LENGTH, dpc); offset += ANSI_NCM_LENGTH; proto_tree_add_uint(call_pc_tree, called ? hf_sccp_called_pc_network : hf_sccp_calling_pc_network, tvb, offset, ANSI_NCM_LENGTH, dpc); offset += ANSI_NCM_LENGTH; return(offset); } /* FUNCTION dissect_sccp_called_calling_param(): * Dissect the Calling or Called Party Address parameters. * * The boolean 'called' describes whether this function is decoding a * called (TRUE) or calling (FALSE) party address. There is simply too * much code in this function to have 2 copies of it (one for called, one * for calling). * * NOTE: this function is called even when (!tree) so that we can get * the SSN and subsequently call subdissectors (if and when there's a data * parameter). Realistically we should put if (!tree)'s around a lot of the * code, but I think that would make it unreadable--and the expense of not * doing so does not appear to be very high. */ static void dissect_sccp_called_calling_param(tvbuff_t *tvb, proto_tree *tree, guint length, gboolean called) { proto_item *call_item = 0, *call_ai_item = 0; proto_tree *call_tree = 0, *call_ai_tree = 0; guint offset; guint8 national = -1, routing_ind, gti, pci, ssni, ssn; guint32 dpc; tvbuff_t *gt_tvb; call_item = proto_tree_add_text(tree, tvb, 0, length, "%s Party address (%u byte%s)", called ? "Called" : "Calling", length, plurality(length, "", "s")); call_tree = proto_item_add_subtree(call_item, called ? ett_sccp_called : ett_sccp_calling); call_ai_item = proto_tree_add_text(call_tree, tvb, 0, ADDRESS_INDICATOR_LENGTH, "Address Indicator"); call_ai_tree = proto_item_add_subtree(call_ai_item, called ? ett_sccp_called_ai : ett_sccp_calling_ai); if (mtp3_standard == ANSI_STANDARD) { national = tvb_get_guint8(tvb, 0) & ANSI_NATIONAL_MASK; proto_tree_add_uint(call_ai_tree, called ? hf_sccp_called_national_indicator : hf_sccp_calling_national_indicator, tvb, 0, ADDRESS_INDICATOR_LENGTH, national); } routing_ind = tvb_get_guint8(tvb, 0) & ROUTING_INDICATOR_MASK; proto_tree_add_uint(call_ai_tree, called ? hf_sccp_called_routing_indicator : hf_sccp_calling_routing_indicator, tvb, 0, ADDRESS_INDICATOR_LENGTH, routing_ind); gti = tvb_get_guint8(tvb, 0) & GTI_MASK; if (mtp3_standard == ITU_STANDARD || mtp3_standard == CHINESE_ITU_STANDARD || national == 0) { proto_tree_add_uint(call_ai_tree, called ? hf_sccp_called_itu_global_title_indicator : hf_sccp_called_itu_global_title_indicator, tvb, 0, ADDRESS_INDICATOR_LENGTH, gti); ssni = tvb_get_guint8(tvb, 0) & ITU_SSN_INDICATOR_MASK; proto_tree_add_uint(call_ai_tree, called ? hf_sccp_called_itu_ssn_indicator : hf_sccp_calling_itu_ssn_indicator, tvb, 0, ADDRESS_INDICATOR_LENGTH, ssni); pci = tvb_get_guint8(tvb, 0) & ITU_PC_INDICATOR_MASK; proto_tree_add_uint(call_ai_tree, called ? hf_sccp_called_itu_point_code_indicator : hf_sccp_calling_itu_point_code_indicator, tvb, 0, ADDRESS_INDICATOR_LENGTH, pci); offset = ADDRESS_INDICATOR_LENGTH; /* Dissect PC (if present) */ if (pci) { if (mtp3_standard == ITU_STANDARD) { dpc = tvb_get_letohs(tvb, offset) & ITU_PC_MASK; proto_tree_add_uint(call_tree, called ? hf_sccp_called_itu_pc : hf_sccp_calling_itu_pc, tvb, offset, ITU_PC_LENGTH, dpc); offset += ITU_PC_LENGTH; } else /* CHINESE_ITU_STANDARD */ { offset = dissect_sccp_3byte_pc(tvb, call_tree, offset, called); } } /* Dissect SSN (if present) */ if (ssni) { ssn = tvb_get_guint8(tvb, offset); if (called) { called_ssn = ssn; } else { calling_ssn = ssn; } proto_tree_add_uint(call_tree, called ? hf_sccp_called_ssn : hf_sccp_calling_ssn, tvb, offset, ADDRESS_SSN_LENGTH, ssn); proto_tree_add_uint_hidden(call_tree, hf_sccp_ssn, tvb, offset, ADDRESS_SSN_LENGTH, ssn); offset += ADDRESS_SSN_LENGTH; } if (!tree) return; /* got SSN, that's all we need here... */ /* Dissect GT (if present) */ if (gti != AI_GTI_NO_GT) { if (length < offset) return; gt_tvb = tvb_new_subset(tvb, offset, (length - offset), (length - offset)); dissect_sccp_global_title(gt_tvb, call_tree, (length - offset), gti, called); } } else if (mtp3_standard == ANSI_STANDARD) { proto_tree_add_uint(call_ai_tree, called ? hf_sccp_called_ansi_global_title_indicator : hf_sccp_calling_ansi_global_title_indicator, tvb, 0, ADDRESS_INDICATOR_LENGTH, gti); pci = tvb_get_guint8(tvb, 0) & ANSI_PC_INDICATOR_MASK; proto_tree_add_uint(call_ai_tree, called ? hf_sccp_called_ansi_point_code_indicator : hf_sccp_calling_ansi_point_code_indicator, tvb, 0, ADDRESS_INDICATOR_LENGTH, pci); ssni = tvb_get_guint8(tvb, 0) & ANSI_SSN_INDICATOR_MASK; proto_tree_add_uint(call_ai_tree, called ? hf_sccp_called_ansi_ssn_indicator : hf_sccp_calling_ansi_ssn_indicator, tvb, 0, ADDRESS_INDICATOR_LENGTH, ssni); offset = ADDRESS_INDICATOR_LENGTH; /* Dissect SSN (if present) */ if (ssni) { ssn = tvb_get_guint8(tvb, offset); if (called) { called_ssn = ssn; } else { calling_ssn = ssn; } proto_tree_add_uint(call_tree, called ? hf_sccp_called_ssn : hf_sccp_calling_ssn, tvb, offset, ADDRESS_SSN_LENGTH, ssn); proto_tree_add_uint_hidden(call_tree, hf_sccp_ssn, tvb, offset, ADDRESS_SSN_LENGTH, ssn); offset += ADDRESS_SSN_LENGTH; } if (!tree) return; /* got SSN, that's all we need here... */ /* Dissect PC (if present) */ if (pci) { offset = dissect_sccp_3byte_pc(tvb, call_tree, offset, called); } /* Dissect GT (if present) */ if (gti != AI_GTI_NO_GT) { if (length < offset) return; gt_tvb = tvb_new_subset(tvb, offset, (length - offset), (length - offset)); dissect_sccp_global_title(gt_tvb, call_tree, (length - offset), gti, called); } } } static void dissect_sccp_called_param(tvbuff_t *tvb, proto_tree *tree, guint length) { dissect_sccp_called_calling_param(tvb, tree, length, TRUE); } static void dissect_sccp_calling_param(tvbuff_t *tvb, proto_tree *tree, guint length) { dissect_sccp_called_calling_param(tvb, tree, length, FALSE); } static void dissect_sccp_class_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 class, handling; class = tvb_get_guint8(tvb, 0) & CLASS_CLASS_MASK; handling = tvb_get_guint8(tvb, 0) & CLASS_SPARE_HANDLING_MASK; proto_tree_add_uint(tree, hf_sccp_class, tvb, 0, length, class); if (class == 0 || class == 1) proto_tree_add_uint(tree, hf_sccp_handling, tvb, 0, length, handling); } static void dissect_sccp_segmenting_reassembling_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 more; more = tvb_get_guint8(tvb, 0) & SEGMENTING_REASSEMBLING_MASK; proto_tree_add_uint(tree, hf_sccp_more, tvb, 0, length, more); } static void dissect_sccp_receive_sequence_number_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 rsn; rsn = tvb_get_guint8(tvb, 0) >> 1; proto_tree_add_uint(tree, hf_sccp_rsn, tvb, 0, length, rsn); } static void dissect_sccp_sequencing_segmenting_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 rsn, ssn, more; proto_item *param_item; proto_tree *param_tree; ssn = tvb_get_guint8(tvb, 0) >> 1; rsn = tvb_get_guint8(tvb, SEQUENCING_SEGMENTING_SSN_LENGTH) >> 1; more = tvb_get_guint8(tvb, SEQUENCING_SEGMENTING_SSN_LENGTH) & SEQUENCING_SEGMENTING_MORE_MASK; param_item = proto_tree_add_text(tree, tvb, 0, length, val_to_str(PARAMETER_SEQUENCING_SEGMENTING, sccp_parameter_values, "Unknown")); param_tree = proto_item_add_subtree(param_item, ett_sccp_sequencing_segmenting); proto_tree_add_uint(param_tree, hf_sccp_sequencing_segmenting_ssn, tvb, 0, SEQUENCING_SEGMENTING_SSN_LENGTH, ssn); proto_tree_add_uint(param_tree, hf_sccp_sequencing_segmenting_rsn, tvb, SEQUENCING_SEGMENTING_SSN_LENGTH, SEQUENCING_SEGMENTING_RSN_LENGTH, rsn); proto_tree_add_uint(param_tree, hf_sccp_sequencing_segmenting_more, tvb, SEQUENCING_SEGMENTING_SSN_LENGTH, SEQUENCING_SEGMENTING_RSN_LENGTH, more); } static void dissect_sccp_credit_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 credit; credit = tvb_get_guint8(tvb, 0); proto_tree_add_uint(tree, hf_sccp_credit, tvb, 0, length, credit); } static void dissect_sccp_release_cause_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 cause; cause = tvb_get_guint8(tvb, 0); proto_tree_add_uint(tree, hf_sccp_release_cause, tvb, 0, length, cause); } static void dissect_sccp_return_cause_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 cause; cause = tvb_get_guint8(tvb, 0); proto_tree_add_uint(tree, hf_sccp_return_cause, tvb, 0, length, cause); } static void dissect_sccp_reset_cause_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 cause; cause = tvb_get_guint8(tvb, 0); proto_tree_add_uint(tree, hf_sccp_reset_cause, tvb, 0, length, cause); } static void dissect_sccp_error_cause_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 cause; cause = tvb_get_guint8(tvb, 0); proto_tree_add_uint(tree, hf_sccp_error_cause, tvb, 0, length, cause); } static void dissect_sccp_refusal_cause_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 cause; cause = tvb_get_guint8(tvb, 0); proto_tree_add_uint(tree, hf_sccp_refusal_cause, tvb, 0, length, cause); } /* This function is used for both data and long data (ITU only) parameters */ static void dissect_sccp_data_param(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { /* Try subdissectors (if we found a valid SSN on the current message) */ if ((called_ssn != INVALID_SSN && dissector_try_port(sccp_ssn_dissector_table, called_ssn, tvb, pinfo, tree)) || (calling_ssn != INVALID_SSN && dissector_try_port(sccp_ssn_dissector_table, calling_ssn, tvb, pinfo, tree))) return; /* try heuristic subdissector list to see if there are any takers */ if (dissector_try_heuristic(heur_subdissector_list, tvb, pinfo, tree)) { return; } /* No sub-dissection occured, treat it as raw data */ call_dissector(data_handle, tvb, pinfo, tree); } static void dissect_sccp_segmentation_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 first, class, remaining; guint32 slr; proto_item *param_item; proto_tree *param_tree; first = tvb_get_guint8(tvb, 0) & SEGMENTATION_FIRST_SEGMENT_MASK; class = tvb_get_guint8(tvb, 0) & SEGMENTATION_CLASS_MASK; remaining = tvb_get_guint8(tvb, 0) & SEGMENTATION_REMAINING_MASK; slr = tvb_get_letoh24(tvb, 1); param_item = proto_tree_add_text(tree, tvb, 0, length, val_to_str(PARAMETER_SEGMENTATION, sccp_parameter_values, "Unknown")); param_tree = proto_item_add_subtree(param_item, ett_sccp_segmentation); proto_tree_add_uint(param_tree, hf_sccp_segmentation_first, tvb, 0, length, first); proto_tree_add_uint(param_tree, hf_sccp_segmentation_class, tvb, 0, length, class); proto_tree_add_uint(param_tree, hf_sccp_segmentation_remaining, tvb, 0, length, remaining); proto_tree_add_uint(param_tree, hf_sccp_segmentation_slr, tvb, 1, length, slr); } static void dissect_sccp_hop_counter_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 hops; hops = tvb_get_guint8(tvb, 0); proto_tree_add_uint(tree, hf_sccp_hop_counter, tvb, 0, length, hops); } static void dissect_sccp_importance_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 importance; importance = tvb_get_guint8(tvb, 0) & IMPORTANCE_IMPORTANCE_MASK; proto_tree_add_uint(tree, hf_sccp_importance, tvb, 0, length, importance); } static void dissect_sccp_isni_param(tvbuff_t *tvb, proto_tree *tree, guint length) { guint8 mi, iri, ti, network, netspec; guint offset = 0; proto_item *param_item; proto_tree *param_tree; /* Create a subtree for ISNI Routing Control */ param_item = proto_tree_add_text(tree, tvb, offset, ANSI_ISNI_ROUTING_CONTROL_LENGTH, "ISNI Routing Control"); param_tree = proto_item_add_subtree(param_item, ett_sccp_ansi_isni_routing_control); mi = tvb_get_guint8(tvb, offset) & ANSI_ISNI_MI_MASK; proto_tree_add_uint(param_tree, hf_sccp_ansi_isni_mi, tvb, offset, ANSI_ISNI_ROUTING_CONTROL_LENGTH, mi); iri = tvb_get_guint8(tvb, offset) & ANSI_ISNI_IRI_MASK; proto_tree_add_uint(param_tree, hf_sccp_ansi_isni_iri, tvb, offset, ANSI_ISNI_ROUTING_CONTROL_LENGTH, iri); ti = tvb_get_guint8(tvb, offset) & ANSI_ISNI_TI_MASK; proto_tree_add_uint(param_tree, hf_sccp_ansi_isni_ti, tvb, offset, ANSI_ISNI_ROUTING_CONTROL_LENGTH, ti); offset += ANSI_ISNI_ROUTING_CONTROL_LENGTH; if ((ti >> ANSI_ISNI_TI_SHIFT) == ANSI_ISNI_TYPE_1) { netspec = tvb_get_guint8(tvb, offset) & ANSI_ISNI_NETSPEC_MASK; proto_tree_add_uint(param_tree, hf_sccp_ansi_isni_netspec, tvb, offset, ANSI_ISNI_ROUTING_CONTROL_LENGTH, ti); offset += ANSI_ISNI_ROUTING_CONTROL_LENGTH; } while (offset < length) { network = tvb_get_guint8(tvb, offset); proto_tree_add_text(tree, tvb, offset, ANSI_NCM_LENGTH, "Network ID network: %d", network); offset++; network = tvb_get_guint8(tvb, offset); proto_tree_add_text(tree, tvb, offset, ANSI_NCM_LENGTH, "Network ID cluster: %d", network); offset++; } } /* FUNCTION dissect_sccp_parameter(): * Dissect a parameter given its type, offset into tvb, and length. */ static guint16 dissect_sccp_parameter(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sccp_tree, proto_tree *tree, guint8 parameter_type, guint16 offset, guint16 parameter_length) { tvbuff_t *parameter_tvb; switch (parameter_type) { case PARAMETER_CALLED_PARTY_ADDRESS: case PARAMETER_CALLING_PARTY_ADDRESS: case PARAMETER_DATA: case PARAMETER_LONG_DATA: /* These parameters must be dissected even if !sccp_tree (so that * subdissectors can be called). */ break; default: if (!sccp_tree) return(parameter_length); } parameter_tvb = tvb_new_subset(tvb, offset, parameter_length, parameter_length); switch (parameter_type) { case PARAMETER_END_OF_OPTIONAL_PARAMETERS: proto_tree_add_text(sccp_tree, tvb, offset, parameter_length, "End of Optional"); break; case PARAMETER_DESTINATION_LOCAL_REFERENCE: dissect_sccp_dlr_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_SOURCE_LOCAL_REFERENCE: dissect_sccp_slr_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_CALLED_PARTY_ADDRESS: dissect_sccp_called_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_CALLING_PARTY_ADDRESS: dissect_sccp_calling_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_CLASS: dissect_sccp_class_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_SEGMENTING_REASSEMBLING: dissect_sccp_segmenting_reassembling_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_RECEIVE_SEQUENCE_NUMBER: dissect_sccp_receive_sequence_number_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_SEQUENCING_SEGMENTING: dissect_sccp_sequencing_segmenting_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_CREDIT: dissect_sccp_credit_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_RELEASE_CAUSE: dissect_sccp_release_cause_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_RETURN_CAUSE: dissect_sccp_return_cause_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_RESET_CAUSE: dissect_sccp_reset_cause_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_ERROR_CAUSE: dissect_sccp_error_cause_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_REFUSAL_CAUSE: dissect_sccp_refusal_cause_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_DATA: dissect_sccp_data_param(parameter_tvb, pinfo, tree); /* TODO? Re-adjust length of SCCP item since it may be sub-dissected */ /* sccp_length = proto_item_get_len(sccp_item); * sccp_length -= parameter_length; * proto_item_set_len(sccp_item, sccp_length); */ break; case PARAMETER_SEGMENTATION: dissect_sccp_segmentation_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_HOP_COUNTER: dissect_sccp_hop_counter_param(parameter_tvb, sccp_tree, parameter_length); break; case PARAMETER_IMPORTANCE: if (mtp3_standard != ANSI_STANDARD) dissect_sccp_importance_param(parameter_tvb, sccp_tree, parameter_length); else dissect_sccp_unknown_param(parameter_tvb, sccp_tree, parameter_type, parameter_length); break; case PARAMETER_LONG_DATA: if (mtp3_standard != ANSI_STANDARD) dissect_sccp_data_param(parameter_tvb, pinfo, tree); else dissect_sccp_unknown_param(parameter_tvb, sccp_tree, parameter_type, parameter_length); break; case PARAMETER_ISNI: if (mtp3_standard != ANSI_STANDARD) dissect_sccp_unknown_param(parameter_tvb, sccp_tree, parameter_type, parameter_length); else dissect_sccp_isni_param(parameter_tvb, sccp_tree, parameter_length); break; default: dissect_sccp_unknown_param(parameter_tvb, sccp_tree, parameter_type, parameter_length); break; } return(parameter_length); } /* FUNCTION dissect_sccp_variable_parameter(): * Dissect a variable parameter given its type and offset into tvb. Length * of the parameter is gotten from tvb[0]. * Length returned is sum of (length + parameter). */ static guint16 dissect_sccp_variable_parameter(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sccp_tree, proto_tree *tree, guint8 parameter_type, guint16 offset) { guint16 parameter_length; guint8 length_length; if (parameter_type != PARAMETER_LONG_DATA) { parameter_length = tvb_get_guint8(tvb, offset); length_length = PARAMETER_LENGTH_LENGTH; } else { /* Long data parameter has 16 bit length */ parameter_length = tvb_get_letohs(tvb, offset); length_length = PARAMETER_LONG_DATA_LENGTH_LENGTH; } if (sccp_tree && sccp_show_length) { proto_tree_add_text(sccp_tree, tvb, offset, length_length, "%s length: %d", val_to_str(parameter_type, sccp_parameter_values, "Unknown"), parameter_length); } offset += length_length; dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, parameter_type, offset, parameter_length); return(parameter_length + length_length); } /* FUNCTION dissect_sccp_optional_parameters(): * Dissect all the optional parameters given the start of the optional * parameters into tvb. Parameter types and lengths are read from tvb. */ static void dissect_sccp_optional_parameters(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sccp_tree, proto_tree *tree, guint16 offset) { guint8 parameter_type; while ((parameter_type = tvb_get_guint8(tvb, offset)) != PARAMETER_END_OF_OPTIONAL_PARAMETERS) { offset += PARAMETER_TYPE_LENGTH; offset += dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, parameter_type, offset); } /* Process end of optional parameters */ dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, parameter_type, offset, END_OF_OPTIONAL_PARAMETERS_LENGTH); } static void dissect_sccp_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *sccp_tree, proto_tree *tree) { guint8 message_type; guint16 variable_pointer1 = 0, variable_pointer2 = 0, variable_pointer3 = 0; guint16 optional_pointer = 0; guint16 offset = 0; /* Macro for getting pointer to mandatory variable parameters */ #define VARIABLE_POINTER(var, hf_var, ptr_size) \ if (ptr_size == POINTER_LENGTH) \ var = tvb_get_guint8(tvb, offset); \ else \ var = tvb_get_letohs(tvb, offset); \ proto_tree_add_uint(sccp_tree, hf_var, tvb, \ offset, ptr_size, var); \ var += offset; \ offset += ptr_size; /* Macro for getting pointer to optional parameters */ #define OPTIONAL_POINTER(ptr_size) \ if (ptr_size == POINTER_LENGTH) \ optional_pointer = tvb_get_guint8(tvb, offset); \ else \ optional_pointer = tvb_get_letohs(tvb, offset); \ proto_tree_add_uint(sccp_tree, hf_sccp_optional_pointer, tvb, \ offset, ptr_size, optional_pointer); \ optional_pointer += offset; \ offset += ptr_size; /* Extract the message type; all other processing is based on this */ message_type = tvb_get_guint8(tvb, MESSAGE_TYPE_OFFSET); offset = MESSAGE_TYPE_LENGTH; if (check_col(pinfo->cinfo, COL_INFO)) col_add_fstr(pinfo->cinfo, COL_INFO, "%s ", val_to_str(message_type, sccp_message_type_acro_values, "Unknown")); if (sccp_tree) { /* add the message type to the protocol tree */ proto_tree_add_uint(sccp_tree, hf_sccp_message_type, tvb, MESSAGE_TYPE_OFFSET, MESSAGE_TYPE_LENGTH, message_type); }; /* Starting a new message dissection; clear the global SSN values */ called_ssn = INVALID_SSN; calling_ssn = INVALID_SSN; switch(message_type) { case MESSAGE_TYPE_CR: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_SOURCE_LOCAL_REFERENCE, offset, SOURCE_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CLASS, offset, PROTOCOL_CLASS_LENGTH); VARIABLE_POINTER(variable_pointer1, hf_sccp_variable_pointer1, POINTER_LENGTH) OPTIONAL_POINTER(POINTER_LENGTH) dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLED_PARTY_ADDRESS, variable_pointer1); break; case MESSAGE_TYPE_CC: /* TODO: connection has been established; theoretically we could keep * keep track of the SLR/DLR with the called/calling from the CR and * track the connection (e.g., on subsequent messages regarding this * SLR we could set the global vars "call*_ssn" so data could get * sub-dissected). */ offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_SOURCE_LOCAL_REFERENCE, offset, SOURCE_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CLASS, offset, PROTOCOL_CLASS_LENGTH); OPTIONAL_POINTER(POINTER_LENGTH) break; case MESSAGE_TYPE_CREF: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_REFUSAL_CAUSE, offset, REFUSAL_CAUSE_LENGTH); OPTIONAL_POINTER(POINTER_LENGTH) break; case MESSAGE_TYPE_RLSD: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_SOURCE_LOCAL_REFERENCE, offset, SOURCE_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_RELEASE_CAUSE, offset, RELEASE_CAUSE_LENGTH); OPTIONAL_POINTER(POINTER_LENGTH) break; case MESSAGE_TYPE_RLC: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_SOURCE_LOCAL_REFERENCE, offset, SOURCE_LOCAL_REFERENCE_LENGTH); break; case MESSAGE_TYPE_DT1: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_SEGMENTING_REASSEMBLING, offset, SEGMENTING_REASSEMBLING_LENGTH); VARIABLE_POINTER(variable_pointer1, hf_sccp_variable_pointer1, POINTER_LENGTH) dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DATA, variable_pointer1); break; case MESSAGE_TYPE_DT2: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_SEQUENCING_SEGMENTING, offset, SEQUENCING_SEGMENTING_LENGTH); break; case MESSAGE_TYPE_AK: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_RECEIVE_SEQUENCE_NUMBER, offset, RECEIVE_SEQUENCE_NUMBER_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CREDIT, offset, CREDIT_LENGTH); break; case MESSAGE_TYPE_UDT: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CLASS, offset, PROTOCOL_CLASS_LENGTH); VARIABLE_POINTER(variable_pointer1, hf_sccp_variable_pointer1, POINTER_LENGTH) VARIABLE_POINTER(variable_pointer2, hf_sccp_variable_pointer2, POINTER_LENGTH) VARIABLE_POINTER(variable_pointer3, hf_sccp_variable_pointer3, POINTER_LENGTH) dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLED_PARTY_ADDRESS, variable_pointer1); dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLING_PARTY_ADDRESS, variable_pointer2); dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DATA, variable_pointer3); break; case MESSAGE_TYPE_UDTS: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_RETURN_CAUSE, offset, RETURN_CAUSE_LENGTH); VARIABLE_POINTER(variable_pointer1, hf_sccp_variable_pointer1, POINTER_LENGTH) VARIABLE_POINTER(variable_pointer2, hf_sccp_variable_pointer2, POINTER_LENGTH) VARIABLE_POINTER(variable_pointer3, hf_sccp_variable_pointer3, POINTER_LENGTH) dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLED_PARTY_ADDRESS, variable_pointer1); dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLING_PARTY_ADDRESS, variable_pointer2); dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DATA, variable_pointer3); break; case MESSAGE_TYPE_ED: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); VARIABLE_POINTER(variable_pointer1, hf_sccp_variable_pointer1, POINTER_LENGTH) dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DATA, variable_pointer1); break; case MESSAGE_TYPE_EA: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); break; case MESSAGE_TYPE_RSR: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_SOURCE_LOCAL_REFERENCE, offset, SOURCE_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_RESET_CAUSE, offset, RESET_CAUSE_LENGTH); break; case MESSAGE_TYPE_RSC: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_SOURCE_LOCAL_REFERENCE, offset, SOURCE_LOCAL_REFERENCE_LENGTH); break; case MESSAGE_TYPE_ERR: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_ERROR_CAUSE, offset, ERROR_CAUSE_LENGTH); break; case MESSAGE_TYPE_IT: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DESTINATION_LOCAL_REFERENCE, offset, DESTINATION_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_SOURCE_LOCAL_REFERENCE, offset, SOURCE_LOCAL_REFERENCE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CLASS, offset, PROTOCOL_CLASS_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_SEQUENCING_SEGMENTING, offset, SEQUENCING_SEGMENTING_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CREDIT, offset, CREDIT_LENGTH); break; case MESSAGE_TYPE_XUDT: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CLASS, offset, PROTOCOL_CLASS_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_HOP_COUNTER, offset, HOP_COUNTER_LENGTH); VARIABLE_POINTER(variable_pointer1, hf_sccp_variable_pointer1, POINTER_LENGTH) VARIABLE_POINTER(variable_pointer2, hf_sccp_variable_pointer2, POINTER_LENGTH) VARIABLE_POINTER(variable_pointer3, hf_sccp_variable_pointer3, POINTER_LENGTH) OPTIONAL_POINTER(POINTER_LENGTH) dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLED_PARTY_ADDRESS, variable_pointer1); dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLING_PARTY_ADDRESS, variable_pointer2); dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DATA, variable_pointer3); break; case MESSAGE_TYPE_XUDTS: offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_RETURN_CAUSE, offset, RETURN_CAUSE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_HOP_COUNTER, offset, HOP_COUNTER_LENGTH); VARIABLE_POINTER(variable_pointer1, hf_sccp_variable_pointer1, POINTER_LENGTH) VARIABLE_POINTER(variable_pointer2, hf_sccp_variable_pointer2, POINTER_LENGTH) VARIABLE_POINTER(variable_pointer3, hf_sccp_variable_pointer3, POINTER_LENGTH) OPTIONAL_POINTER(POINTER_LENGTH) dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLED_PARTY_ADDRESS, variable_pointer1); dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLING_PARTY_ADDRESS, variable_pointer2); dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_DATA, variable_pointer3); break; case MESSAGE_TYPE_LUDT: if (mtp3_standard != ANSI_STANDARD) { offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CLASS, offset, PROTOCOL_CLASS_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_HOP_COUNTER, offset, HOP_COUNTER_LENGTH); VARIABLE_POINTER(variable_pointer1, hf_sccp_variable_pointer1, POINTER_LENGTH_LONG) VARIABLE_POINTER(variable_pointer2, hf_sccp_variable_pointer2, POINTER_LENGTH_LONG) VARIABLE_POINTER(variable_pointer3, hf_sccp_variable_pointer3, POINTER_LENGTH_LONG) OPTIONAL_POINTER(POINTER_LENGTH_LONG) dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLED_PARTY_ADDRESS, variable_pointer1); dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLING_PARTY_ADDRESS, variable_pointer2); dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_LONG_DATA, variable_pointer3); } else dissect_sccp_unknown_message(tvb, sccp_tree); break; case MESSAGE_TYPE_LUDTS: if (mtp3_standard != ANSI_STANDARD) { offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_RETURN_CAUSE, offset, RETURN_CAUSE_LENGTH); offset += dissect_sccp_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_HOP_COUNTER, offset, HOP_COUNTER_LENGTH); VARIABLE_POINTER(variable_pointer1, hf_sccp_variable_pointer1, POINTER_LENGTH_LONG) VARIABLE_POINTER(variable_pointer2, hf_sccp_variable_pointer2, POINTER_LENGTH_LONG) VARIABLE_POINTER(variable_pointer3, hf_sccp_variable_pointer3, POINTER_LENGTH_LONG) OPTIONAL_POINTER(POINTER_LENGTH_LONG) dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLED_PARTY_ADDRESS, variable_pointer1); dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_CALLING_PARTY_ADDRESS, variable_pointer2); dissect_sccp_variable_parameter(tvb, pinfo, sccp_tree, tree, PARAMETER_LONG_DATA, variable_pointer3); } else dissect_sccp_unknown_message(tvb, sccp_tree); break; default: dissect_sccp_unknown_message(tvb, sccp_tree); } if (optional_pointer) dissect_sccp_optional_parameters(tvb, pinfo, sccp_tree, tree, optional_pointer); } static void dissect_sccp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { proto_item *sccp_item; proto_tree *sccp_tree = NULL; const mtp3_addr_pc_t *mtp3_addr_p; /* Make entry in the Protocol column on summary display */ if (check_col(pinfo->cinfo, COL_PROTOCOL)) switch(mtp3_standard) { case ITU_STANDARD: col_set_str(pinfo->cinfo, COL_PROTOCOL, "SCCP (Int. ITU)"); break; case ANSI_STANDARD: col_set_str(pinfo->cinfo, COL_PROTOCOL, "SCCP (ANSI)"); break; case CHINESE_ITU_STANDARD: col_set_str(pinfo->cinfo, COL_PROTOCOL, "SCCP (Chin. ITU)"); break; }; /* In the interest of speed, if "tree" is NULL, don't do any work not necessary to generate protocol tree items. */ if (tree) { /* create the sccp protocol tree */ sccp_item = proto_tree_add_item(tree, proto_sccp, tvb, 0, -1, FALSE); sccp_tree = proto_item_add_subtree(sccp_item, ett_sccp); } /* Set whether message is UPLINK, DOWNLINK, or of UNKNOWN direction */ if (pinfo->net_src.type == AT_SS7PC) { /* * XXX - we assume that the "data" pointers of the source and destination * addresses are set to point to "mtp3_addr_pc_t" structures, so that * we can safely cast them. */ mtp3_addr_p = (const mtp3_addr_pc_t *)pinfo->net_src.data; if (sccp_source_pc_global == mtp3_addr_p->pc) { pinfo->p2p_dir = P2P_DIR_SENT; } else { /* assuming if net_src was SS7 PC then net_dst will be too */ mtp3_addr_p = (const mtp3_addr_pc_t *)pinfo->net_dst.data; if (sccp_source_pc_global == mtp3_addr_p->pc) { pinfo->p2p_dir = P2P_DIR_RECV; } else { pinfo->p2p_dir = P2P_DIR_UNKNOWN; } } } /* dissect the message */ dissect_sccp_message(tvb, pinfo, sccp_tree, tree); } /* Register the protocol with Ethereal */ void proto_register_sccp(void) { /* Setup list of header fields */ static hf_register_info hf[] = { { &hf_sccp_message_type, { "Message Type", "sccp.message_type", FT_UINT8, BASE_HEX, VALS(sccp_message_type_values), 0x0, "", HFILL}}, { &hf_sccp_variable_pointer1, { "Pointer to first Mandatory Variable parameter", "sccp.variable_pointer1", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL}}, { &hf_sccp_variable_pointer2, { "Pointer to second Mandatory Variable parameter", "sccp.variable_pointer2", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL}}, { &hf_sccp_variable_pointer3, { "Pointer to third Mandatory Variable parameter", "sccp.variable_pointer3", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL}}, { &hf_sccp_optional_pointer, { "Pointer to Optional parameter", "sccp.optional_pointer", FT_UINT16, BASE_DEC, NULL, 0x0, "", HFILL}}, { &hf_sccp_ssn, { "Called or Calling SubSystem Number", "sccp.ssn", FT_UINT8, BASE_DEC, VALS(sccp_ssn_values), 0x0, "", HFILL}}, { &hf_sccp_gt_digits, { "Called or Calling GT Digits", "sccp.digits", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }}, { &hf_sccp_called_national_indicator, { "National Indicator", "sccp.called.ni", FT_UINT8, BASE_HEX, VALS(sccp_national_indicator_values), ANSI_NATIONAL_MASK, "", HFILL}}, { &hf_sccp_called_routing_indicator, { "Routing Indicator", "sccp.called.ri", FT_UINT8, BASE_HEX, VALS(sccp_routing_indicator_values), ROUTING_INDICATOR_MASK, "", HFILL}}, { &hf_sccp_called_itu_global_title_indicator, { "Global Title Indicator", "sccp.called.gti", FT_UINT8, BASE_HEX, VALS(sccp_itu_global_title_indicator_values), GTI_MASK, "", HFILL}}, { &hf_sccp_called_ansi_global_title_indicator, { "Global Title Indicator", "sccp.called.gti", FT_UINT8, BASE_HEX, VALS(sccp_ansi_global_title_indicator_values), GTI_MASK, "", HFILL}}, { &hf_sccp_called_itu_ssn_indicator, { "SubSystem Number Indicator", "sccp.called.ssni", FT_UINT8, BASE_HEX, VALS(sccp_ai_ssni_values), ITU_SSN_INDICATOR_MASK, "", HFILL}}, { &hf_sccp_called_itu_point_code_indicator, { "Point Code Indicator", "sccp.called.pci", FT_UINT8, BASE_HEX, VALS(sccp_ai_pci_values), ITU_PC_INDICATOR_MASK, "", HFILL}}, { &hf_sccp_called_ansi_ssn_indicator, { "SubSystem Number Indicator", "sccp.called.ssni", FT_UINT8, BASE_HEX, VALS(sccp_ai_ssni_values), ANSI_SSN_INDICATOR_MASK, "", HFILL}}, { &hf_sccp_called_ansi_point_code_indicator, { "Point Code Indicator", "sccp.called.pci", FT_UINT8, BASE_HEX, VALS(sccp_ai_pci_values), ANSI_PC_INDICATOR_MASK, "", HFILL}}, { &hf_sccp_called_ssn, { "SubSystem Number", "sccp.called.ssn", FT_UINT8, BASE_DEC, VALS(sccp_ssn_values), 0x0, "", HFILL}}, { &hf_sccp_called_itu_pc, { "PC", "sccp.called.pc", FT_UINT16, BASE_DEC, NULL, ITU_PC_MASK, "", HFILL}}, { &hf_sccp_called_ansi_pc, { "PC", "sccp.called.ansi_pc", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL}}, { &hf_sccp_called_chinese_pc, { "PC", "sccp.called.chinese_pc", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL}}, { &hf_sccp_called_pc_network, { "PC Network", "sccp.called.network", FT_UINT24, BASE_DEC, NULL, ANSI_NETWORK_MASK, "", HFILL }}, { &hf_sccp_called_pc_cluster, { "PC Cluster", "sccp.called.cluster", FT_UINT24, BASE_DEC, NULL, ANSI_CLUSTER_MASK, "", HFILL }}, { &hf_sccp_called_pc_member, { "PC Member", "sccp.called.member", FT_UINT24, BASE_DEC, NULL, ANSI_MEMBER_MASK, "", HFILL }}, { &hf_sccp_called_gt_nai, { "Nature of Address Indicator", "sccp.called.nai", FT_UINT8, BASE_HEX, VALS(sccp_nai_values), GT_NAI_MASK, "", HFILL }}, { &hf_sccp_called_gt_oe, { "Odd/Even Indicator", "sccp.called.oe", FT_UINT8, BASE_HEX, VALS(sccp_oe_values), GT_OE_MASK, "", HFILL }}, { &hf_sccp_called_gt_tt, { "Translation Type", "sccp.called.tt", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }}, { &hf_sccp_called_gt_np, { "Numbering Plan", "sccp.called.np", FT_UINT8, BASE_HEX, VALS(sccp_np_values), GT_NP_MASK, "", HFILL }}, { &hf_sccp_called_gt_es, { "Encoding Scheme", "sccp.called.es", FT_UINT8, BASE_HEX, VALS(sccp_es_values), GT_ES_MASK, "", HFILL }}, { &hf_sccp_called_gt_digits, { "GT Digits", "sccp.called.digits", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }}, { &hf_sccp_calling_national_indicator, { "National Indicator", "sccp.calling.ni", FT_UINT8, BASE_HEX, VALS(sccp_national_indicator_values), ANSI_NATIONAL_MASK, "", HFILL}}, { &hf_sccp_calling_routing_indicator, { "Routing Indicator", "sccp.calling.ri", FT_UINT8, BASE_HEX, VALS(sccp_routing_indicator_values), ROUTING_INDICATOR_MASK, "", HFILL}}, { &hf_sccp_calling_itu_global_title_indicator, { "Global Title Indicator", "sccp.calling.gti", FT_UINT8, BASE_HEX, VALS(sccp_itu_global_title_indicator_values), GTI_MASK, "", HFILL}}, { &hf_sccp_calling_ansi_global_title_indicator, { "Global Title Indicator", "sccp.calling.gti", FT_UINT8, BASE_HEX, VALS(sccp_ansi_global_title_indicator_values), GTI_MASK, "", HFILL}}, { &hf_sccp_calling_itu_ssn_indicator, { "SubSystem Number Indicator", "sccp.calling.ssni", FT_UINT8, BASE_HEX, VALS(sccp_ai_ssni_values), ITU_SSN_INDICATOR_MASK, "", HFILL}}, { &hf_sccp_calling_itu_point_code_indicator, { "Point Code Indicator", "sccp.calling.pci", FT_UINT8, BASE_HEX, VALS(sccp_ai_pci_values), ITU_PC_INDICATOR_MASK, "", HFILL}}, { &hf_sccp_calling_ansi_ssn_indicator, { "SubSystem Number Indicator", "sccp.calling.ssni", FT_UINT8, BASE_HEX, VALS(sccp_ai_ssni_values), ANSI_SSN_INDICATOR_MASK, "", HFILL}}, { &hf_sccp_calling_ansi_point_code_indicator, { "Point Code Indicator", "sccp.calling.pci", FT_UINT8, BASE_HEX, VALS(sccp_ai_pci_values), ANSI_PC_INDICATOR_MASK, "", HFILL}}, { &hf_sccp_calling_ssn, { "SubSystem Number", "sccp.calling.ssn", FT_UINT8, BASE_DEC, VALS(sccp_ssn_values), 0x0, "", HFILL}}, { &hf_sccp_calling_itu_pc, { "PC", "sccp.calling.pc", FT_UINT16, BASE_DEC, NULL, ITU_PC_MASK, "", HFILL}}, { &hf_sccp_calling_ansi_pc, { "PC", "sccp.calling.ansi_pc", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL}}, { &hf_sccp_calling_chinese_pc, { "PC", "sccp.calling.chinese_pc", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL}}, { &hf_sccp_calling_pc_network, { "PC Network", "sccp.calling.network", FT_UINT24, BASE_DEC, NULL, ANSI_NETWORK_MASK, "", HFILL }}, { &hf_sccp_calling_pc_cluster, { "PC Cluster", "sccp.calling.cluster", FT_UINT24, BASE_DEC, NULL, ANSI_CLUSTER_MASK, "", HFILL }}, { &hf_sccp_calling_pc_member, { "PC Member", "sccp.calling.member", FT_UINT24, BASE_DEC, NULL, ANSI_MEMBER_MASK, "", HFILL }}, { &hf_sccp_calling_gt_nai, { "Nature of Address Indicator", "sccp.calling.nai", FT_UINT8, BASE_HEX, VALS(sccp_nai_values), GT_NAI_MASK, "", HFILL }}, { &hf_sccp_calling_gt_oe, { "Odd/Even Indicator", "sccp.calling.oe", FT_UINT8, BASE_HEX, VALS(sccp_oe_values), GT_OE_MASK, "", HFILL }}, { &hf_sccp_calling_gt_tt, { "Translation Type", "sccp.calling.tt", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL }}, { &hf_sccp_calling_gt_np, { "Numbering Plan", "sccp.calling.np", FT_UINT8, BASE_HEX, VALS(sccp_np_values), GT_NP_MASK, "", HFILL }}, { &hf_sccp_calling_gt_es, { "Encoding Scheme", "sccp.calling.es", FT_UINT8, BASE_HEX, VALS(sccp_es_values), GT_ES_MASK, "", HFILL }}, { &hf_sccp_calling_gt_digits, { "GT Digits", "sccp.calling.digits", FT_STRING, BASE_NONE, NULL, 0x0, "", HFILL }}, { &hf_sccp_dlr, { "Destination Local Reference", "sccp.dlr", FT_UINT24, BASE_HEX, NULL, 0x0, "", HFILL}}, { &hf_sccp_slr, { "Source Local Reference", "sccp.slr", FT_UINT24, BASE_HEX, NULL, 0x0, "", HFILL}}, { &hf_sccp_class, { "Class", "sccp.class", FT_UINT8, BASE_HEX, NULL, CLASS_CLASS_MASK, "", HFILL}}, { &hf_sccp_handling, { "Message handling", "sccp.handling", FT_UINT8, BASE_HEX, VALS(sccp_class_handling_values), CLASS_SPARE_HANDLING_MASK, "", HFILL}}, { &hf_sccp_more, { "More data", "sccp.more", FT_UINT8, BASE_HEX, VALS(sccp_segmenting_reassembling_values), SEGMENTING_REASSEMBLING_MASK, "", HFILL}}, { &hf_sccp_rsn, { "Receive Sequence Number", "sccp.rsn", FT_UINT8, BASE_HEX, NULL, RSN_MASK, "", HFILL}}, { &hf_sccp_sequencing_segmenting_ssn, { "Sequencing Segmenting: Send Sequence Number", "sccp.sequencing_segmenting.ssn", FT_UINT8, BASE_HEX, NULL, SEND_SEQUENCE_NUMBER_MASK, "", HFILL}}, { &hf_sccp_sequencing_segmenting_rsn, { "Sequencing Segmenting: Receive Sequence Number", "sccp.sequencing_segmenting.rsn", FT_UINT8, BASE_HEX, NULL, RECEIVE_SEQUENCE_NUMBER_MASK, "", HFILL}}, { &hf_sccp_sequencing_segmenting_more, { "Sequencing Segmenting: More", "sccp.sequencing_segmenting.more", FT_UINT8, BASE_HEX, VALS(sccp_segmenting_reassembling_values), SEQUENCING_SEGMENTING_MORE_MASK, "", HFILL}}, { &hf_sccp_credit, { "Credit", "sccp.credit", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL}}, { &hf_sccp_release_cause, { "Release Cause", "sccp.release_cause", FT_UINT8, BASE_HEX, VALS(sccp_release_cause_values), 0x0, "", HFILL}}, { &hf_sccp_return_cause, { "Return Cause", "sccp.return_cause", FT_UINT8, BASE_HEX, VALS(sccp_return_cause_values), 0x0, "", HFILL}}, { &hf_sccp_reset_cause, { "Reset Cause", "sccp.reset_cause", FT_UINT8, BASE_HEX, VALS(sccp_reset_cause_values), 0x0, "", HFILL}}, { &hf_sccp_error_cause, { "Error Cause", "sccp.error_cause", FT_UINT8, BASE_HEX, VALS(sccp_error_cause_values), 0x0, "", HFILL}}, { &hf_sccp_refusal_cause, { "Refusal Cause", "sccp.refusal_cause", FT_UINT8, BASE_HEX, VALS(sccp_refusal_cause_values), 0x0, "", HFILL}}, { &hf_sccp_segmentation_first, { "Segmentation: First", "sccp.segmentation.first", FT_UINT8, BASE_HEX, VALS(sccp_segmentation_first_segment_values), SEGMENTATION_FIRST_SEGMENT_MASK, "", HFILL}}, { &hf_sccp_segmentation_class, { "Segmentation: Class", "sccp.segmentation.class", FT_UINT8, BASE_HEX, VALS(sccp_segmentation_class_values), SEGMENTATION_CLASS_MASK, "", HFILL}}, { &hf_sccp_segmentation_remaining, { "Segmentation: Remaining", "sccp.segmentation.remaining", FT_UINT8, BASE_HEX, NULL, SEGMENTATION_REMAINING_MASK, "", HFILL}}, { &hf_sccp_segmentation_slr, { "Segmentation: Source Local Reference", "sccp.segmentation.slr", FT_UINT24, BASE_HEX, NULL, 0x0, "", HFILL}}, { &hf_sccp_hop_counter, { "Hop Counter", "sccp.hops", FT_UINT8, BASE_HEX, NULL, 0x0, "", HFILL}}, { &hf_sccp_importance, { "Importance", "sccp.importance", FT_UINT8, BASE_HEX, NULL, IMPORTANCE_IMPORTANCE_MASK, "", HFILL}}, /* ISNI is ANSI only */ { &hf_sccp_ansi_isni_mi, { "ISNI Mark for Identification Indicator", "sccp.isni.mi", FT_UINT8, BASE_HEX, VALS(sccp_isni_mark_for_id_values), ANSI_ISNI_MI_MASK, "", HFILL}}, { &hf_sccp_ansi_isni_iri, { "ISNI Routing Indicator", "sccp.isni.iri", FT_UINT8, BASE_HEX, VALS(sccp_isni_iri_values), ANSI_ISNI_IRI_MASK, "", HFILL}}, { &hf_sccp_ansi_isni_ti, { "ISNI Type Indicator", "sccp.isni.ti", FT_UINT8, BASE_HEX, VALS(sccp_isni_ti_values), ANSI_ISNI_TI_MASK, "", HFILL}}, { &hf_sccp_ansi_isni_netspec, { "ISNI Network Specific (Type 1)", "sccp.isni.netspec", FT_UINT8, BASE_HEX, NULL, ANSI_ISNI_NETSPEC_MASK, "", HFILL}}, { &hf_sccp_ansi_isni_counter, { "ISNI Counter", "sccp.isni.counter", FT_UINT8, BASE_HEX, NULL, ANSI_ISNI_COUNTER_MASK, "", HFILL}}, }; /* Setup protocol subtree array */ static gint *ett[] = { &ett_sccp, &ett_sccp_called, &ett_sccp_called_ai, &ett_sccp_called_pc, &ett_sccp_called_gt, &ett_sccp_calling, &ett_sccp_calling_ai, &ett_sccp_calling_pc, &ett_sccp_calling_gt, &ett_sccp_sequencing_segmenting, &ett_sccp_segmentation, &ett_sccp_ansi_isni_routing_control, }; /* Register the protocol name and description */ proto_sccp = proto_register_protocol("Signalling Connection Control Part", "SCCP", "sccp"); register_dissector("sccp", dissect_sccp, proto_sccp); /* Required function calls to register the header fields and subtrees used */ proto_register_field_array(proto_sccp, hf, array_length(hf)); proto_register_subtree_array(ett, array_length(ett)); sccp_ssn_dissector_table = register_dissector_table("sccp.ssn", "SCCP SSN", FT_UINT8, BASE_DEC); register_heur_dissector_list("sccp", &heur_subdissector_list); sccp_module = prefs_register_protocol(proto_sccp, NULL); prefs_register_uint_preference(sccp_module, "source_pc", "Source PC", "The source point code (usually MSC) (to determine whether message is uplink or downlink)", 16, &sccp_source_pc_global); prefs_register_bool_preference(sccp_module, "show_length", "Show length", "Show parameter length in the protocol tree", &sccp_show_length); } void proto_reg_handoff_sccp(void) { dissector_handle_t sccp_handle; sccp_handle = find_dissector("sccp"); dissector_add("mtp3.service_indicator", SCCP_SI, sccp_handle); dissector_add("m3ua.protocol_data_si", SCCP_SI, sccp_handle); data_handle = find_dissector("data"); }