* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
+
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdio.h>
-#include <stdlib.h>
#include <string.h>
+#include <ctype.h>
#include <glib.h>
#include <epan/addr_resolv.h>
#include <epan/ipproto.h>
#include <epan/expert.h>
+#include <epan/filesystem.h>
+#include <epan/report_err.h>
+#include <epan/eap.h>
-/* TODO: delete?. */
-#include "packet-wimaxasncp.h"
+#include "wimaxasncp_dict.h"
-/* Forward declaration we need below */
+/* Forward declarations we need below */
+void proto_register_wimaxasncp(void);
void proto_reg_handoff_wimaxasncp(void);
/* Initialize the protocol and registered fields */
static int hf_wimaxasncp_tlv_type = -1;
static int hf_wimaxasncp_tlv_length = -1;
static int hf_wimaxasncp_tlv_value_bytes = -1;
-static int hf_wimaxasncp_tlv_value_enum8 = -1;
-static int hf_wimaxasncp_tlv_value_enum16 = -1;
-static int hf_wimaxasncp_tlv_value_enum32 = -1;
-static int hf_wimaxasncp_tlv_value_ether = -1;
-static int hf_wimaxasncp_tlv_value_string = -1;
+static int hf_wimaxasncp_tlv_value_bitflags8 = -1;
static int hf_wimaxasncp_tlv_value_bitflags16 = -1;
static int hf_wimaxasncp_tlv_value_bitflags32 = -1;
-static int hf_wimaxasncp_tlv_value_ipv4 = -1;
-static int hf_wimaxasncp_tlv_value_ipv4_address = -1;
-static int hf_wimaxasncp_tlv_value_ipv4_mask = -1;
-static int hf_wimaxasncp_tlv_value_ipv6 = -1;
-static int hf_wimaxasncp_tlv_value_ipv6_address = -1;
-static int hf_wimaxasncp_tlv_value_ipv6_mask = -1;
-static int hf_wimaxasncp_tlv_value_hex8 = -1;
-static int hf_wimaxasncp_tlv_value_hex16 = -1;
-static int hf_wimaxasncp_tlv_value_hex32 = -1;
-static int hf_wimaxasncp_tlv_value_dec8 = -1;
-static int hf_wimaxasncp_tlv_value_dec16 = -1;
-static int hf_wimaxasncp_tlv_value_dec32 = -1;
static int hf_wimaxasncp_tlv_value_protocol = -1;
static int hf_wimaxasncp_tlv_value_vendor_id = -1;
-/* preferences */
+/* Preferences */
static gboolean show_transaction_id_d_bit = FALSE;
static gboolean debug_enabled = FALSE;
+/* Default WiMAX ASN control protocol port */
+#define WIMAXASNCP_DEF_UDP_PORT 2231
+static guint global_wimaxasncp_udp_port = WIMAXASNCP_DEF_UDP_PORT;
+
+
/* Initialize the subtree pointers */
static gint ett_wimaxasncp = -1;
static gint ett_wimaxasncp_flags = -1;
static gint ett_wimaxasncp_tlv = -1;
+static gint ett_wimaxasncp_tlv_value_bitflags8 = -1;
static gint ett_wimaxasncp_tlv_value_bitflags16 = -1;
static gint ett_wimaxasncp_tlv_value_bitflags32 = -1;
static gint ett_wimaxasncp_tlv_protocol_list = -1;
static gint ett_wimaxasncp_tlv_port_range_list = -1;
static gint ett_wimaxasncp_tlv_ip_address_mask_list = -1;
static gint ett_wimaxasncp_tlv_ip_address_mask = -1;
+static gint ett_wimaxasncp_tlv_eap = -1;
static gint ett_wimaxasncp_tlv_vendor_specific_information_field = -1;
/* Header size, up to, but not including, the TLV fields. */
#define WIMAXASNCP_FLAGS_T WIMAXASNCP_BIT8(6)
#define WIMAXASNCP_FLAGS_R WIMAXASNCP_BIT8(7)
+typedef struct {
+ GArray* hf;
+ GArray* ett;
+} wimaxasncp_build_dict_t;
+
+static wimaxasncp_dict_t *wimaxasncp_dict = NULL;
-/* ------------------------------------------------------------------------- */
-/* generic
- */
+wimaxasncp_build_dict_t wimaxasncp_build_dict;
-static const value_string wimaxasncp_tlv_success_failure_vals[] =
+static wimaxasncp_dict_tlv_t wimaxasncp_tlv_not_found =
{
- { 0, "Success"},
- { 1, "Failure"},
- { 0, NULL}
+ 0, "Unknown", NULL, WIMAXASNCP_TLV_UNKNOWN, 0,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ NULL, NULL, NULL
};
+static dissector_handle_t eap_handle;
+
/* ------------------------------------------------------------------------- */
static const value_string wimaxasncp_flag_vals[] =
#define WIMAXASNCP_FT_QOS 1
#define WIMAXASNCP_FT_HO_CONTROL 2
#define WIMAXASNCP_FT_DATA_PATH_CONTROL 3
-#define WIMAXASNCP_FT_CONTEXT_DELIVERY 4
+#define WIMAXASNCP_FT_CONTEXT_TRANSFER 4
#define WIMAXASNCP_FT_R3_MOBILITY 5
#define WIMAXASNCP_FT_PAGING 6
#define WIMAXASNCP_FT_RRM 7
#define WIMAXASNCP_FT_AUTHENTICATION 8
#define WIMAXASNCP_FT_MS_STATE 9
#define WIMAXASNCP_FT_REAUTHENTICATION 10
-#define WIMAXASNCP_FT_SESSION 11 /* Nokia recommended value */
+/* since NWG R1 V1.2.0 */
+#define WIMAXASNCP_FT_IM_OPERATIONS 10
+/* since NWG R1 V1.2.1 */
+#define WIMAXASNCP_FT_ACCOUNTING 11
/* ------------------------------------------------------------------------- */
-static const value_string wimaxasncp_function_type_vals[] =
-{
- { WIMAXASNCP_FT_QOS, "QoS"},
- { WIMAXASNCP_FT_HO_CONTROL, "HO Control"},
- { WIMAXASNCP_FT_DATA_PATH_CONTROL, "Data Path Control"},
- { WIMAXASNCP_FT_CONTEXT_DELIVERY, "Context Delivery"},
- { WIMAXASNCP_FT_R3_MOBILITY, "R3 Mobility"},
- { WIMAXASNCP_FT_PAGING, "Paging"},
- { WIMAXASNCP_FT_RRM, "RRM"},
- { WIMAXASNCP_FT_AUTHENTICATION, "Authentication"},
- { WIMAXASNCP_FT_MS_STATE, "MS State"},
- { WIMAXASNCP_FT_REAUTHENTICATION, "Re-Authentication"},
- { WIMAXASNCP_FT_SESSION, "Session"},
- { 0, NULL}
+/* struct to hold a value_string tuple, per version */
+typedef struct _ver_value_string
+{
+ guint32 since;
+ value_string vs;
+} ver_value_string;
+
+static const ver_value_string wimaxasncp_function_type_vals[] =
+{
+ {0, { WIMAXASNCP_FT_QOS, "QoS"}},
+ {0, { WIMAXASNCP_FT_HO_CONTROL, "HO Control"}},
+ {0, { WIMAXASNCP_FT_DATA_PATH_CONTROL, "Data Path Control"}},
+ {0, { WIMAXASNCP_FT_CONTEXT_TRANSFER, "Context Transfer"}},
+ {0, { WIMAXASNCP_FT_R3_MOBILITY, "R3 Mobility"}},
+ {0, { WIMAXASNCP_FT_PAGING, "Paging"}},
+ {0, { WIMAXASNCP_FT_RRM, "RRM"}},
+ {0, { WIMAXASNCP_FT_AUTHENTICATION, "Authentication Relay"}},
+ {0, { WIMAXASNCP_FT_MS_STATE, "MS State"}},
+ {0, { WIMAXASNCP_FT_REAUTHENTICATION, "Re-Authentication"}},
+ {WIMAXASNCP_NWGVER_R10_V120, {WIMAXASNCP_FT_IM_OPERATIONS, "IM Operations"}},
+ {WIMAXASNCP_NWGVER_R10_V121, { WIMAXASNCP_FT_ACCOUNTING, "Accounting"}},
+ {0, { 0, NULL}}
};
/* ------------------------------------------------------------------------- */
-static const value_string wimaxasncp_qos_msg_vals[] =
+static const ver_value_string wimaxasncp_qos_msg_vals[] =
{
- { 1, "RR_Ack"},
- { 2, "RR_Req"},
- { 3, "RR_Rsp"},
- { 0, NULL}
+ {0,{ 1, "RR_Req"}},
+ {0,{ 2, "RR_Rsp"}},
+ {0,{ 3, "RR_Ack"}},
+ {0,{ 0, NULL}}
};
/* ------------------------------------------------------------------------- */
-static const value_string wimaxasncp_ho_control_msg_vals[] =
-{
- { 1, "HO_Ack"},
- { 2, "HO_Complete"},
- { 3, "HO_Cnf"},
- { 4, "HO_Req"},
- { 5, "HO_Rsp"},
- { 0, NULL}
+static const ver_value_string wimaxasncp_ho_control_msg_vals[] =
+{
+ {0, { 1, "HO_Ack"}},
+ {0, { 2, "HO_Complete"}},
+ {0, { 3, "HO_Cnf"}},
+ {0, { 4, "HO_Req"}},
+ {0, { 5, "HO_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 1, "HO_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 2, "HO_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 3, "HO_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 4, "HO_Cnf"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 5, "HO_Complete"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 6, "HO_Directive"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 7, "HO_Directive_Rsp"}},
+ {0, { 0, NULL}}
};
/* ------------------------------------------------------------------------- */
-static const value_string wimaxasncp_data_path_control_msg_vals[] =
-{
- { 1, "Path_Dereg_Ack"},
- { 2, "Path_Dereg_Req"},
- { 3, "Path_Dereg_Rsp"},
- { 4, "Path_Modification_Ack"},
- { 5, "Path_Modification_Req"},
- { 6, "Path_Modification_Rsp"},
- { 7, "Path_Prereg_Ack"},
- { 8, "Path_Prereg_Req"},
- { 9, "Path_Prereg_Rsp"},
- { 10, "Path_Reg_Ack"},
- { 11, "Path_Reg_Req"},
- { 12, "Path_Reg_Rsp"},
-
- /* see also wimaxasncp_ms_state_msg_vals[] */
- { 13, "MS_Attachment_Req (DPC)"},
- { 14, "MS_Attachment_Rsp (DPC)"},
- { 15, "MS_Attachment_Ack (DPC)"},
-
- { 16, "Key_Change_Directive"},
- { 0, NULL}
+static const ver_value_string wimaxasncp_data_path_control_msg_vals[] =
+{
+ {0, { 1, "Path_Dereg_Ack"}},
+ {0, { 2, "Path_Dereg_Req"}},
+ {0, { 3, "Path_Dereg_Rsp"}},
+ {0, { 4, "Path_Modification_Ack"}},
+ {0, { 5, "Path_Modification_Req"}},
+ {0, { 6, "Path_Modification_Rsp"}},
+ {0, { 7, "Path_Prereg_Ack"}},
+ {0, { 8, "Path_Prereg_Req"}},
+ {0, { 9, "Path_Prereg_Rsp"}},
+ {0, { 10, "Path_Reg_Ack"}},
+ {0, { 11, "Path_Reg_Req"}},
+ {0, { 12, "Path_Reg_Rsp"}},
+ {0, { 13, "MS_Attachment_Req"}},
+ {0, { 14, "MS_Attachment_Rsp"}},
+ {0, { 15, "MS_Attachment_Ack"}},
+ {0, { 16, "Key_Change_Directive"}},
+ {0, { 0, NULL}}
+};
+
+static const ver_value_string wimaxasncp_data_path_control_msg_vals_r1v120[] =
+{
+ {WIMAXASNCP_NWGVER_R10_V120, { 1, "Path_Dereg_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 2, "Path_Dereg_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 3, "Path_Dereg_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 4, "Path_Modification_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 5, "Path_Modification_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 6, "Path_Modification_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 7, "Path_Prereg_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 8, "Path_Prereg_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 9, "Path_Prereg_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 10, "Path_Reg_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 11, "Path_Reg_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 12, "Path_Reg_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 13, "Obsolete"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 14, "Obsolete"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 15, "Obsolete"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 16, "Obsolete"}},
+ {0, { 0, NULL}}
};
/* ------------------------------------------------------------------------- */
-static const value_string wimaxasncp_context_delivery_msg_vals[] =
-{
- { 1, "Context_Rpt"},
- { 2, "Context_Req"},
- { 3, "Context_Ack"},
- { 0, NULL}
+static const ver_value_string wimaxasncp_context_transfer_msg_vals[] =
+{
+ {0, { 1, "Context_Rpt"}},
+ {0, { 2, "Context_Req"}},
+ {0, { 3, "Context_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 1, "Context_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 2, "Context_Rpt"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 4, "CMAC_Key_Count_Update"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 5, "CMAC_Key_Count_Update_ACK"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 6, "CMAC_Key_Count_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 7, "CMAC_Key_Count_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 8, "Prepaid Request"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 9, "Prepaid Notify"}},
+ {WIMAXASNCP_NWGVER_R10_V121, { 6, "VOID"}},
+ {WIMAXASNCP_NWGVER_R10_V121, { 7, "VOID"}},
+ {WIMAXASNCP_NWGVER_R10_V121, { 0, NULL}}
};
/* ------------------------------------------------------------------------- */
-static const value_string wimaxasncp_r3_mobility_msg_vals[] =
-{
- { 1, "Anchor_DPF_HO_Req"},
- { 2, "Anchor_DPF_HO_Trigger"},
- { 3, "Anchor_DPF_HO_Rsp"},
- { 4, "Anchor_DPF_Relocate_Req"},
- { 5, "FA_Register_Req"},
- { 6, "FA_Register_Rsp"},
- { 7, "Anchor_DPF_Relocate_Rsp"},
- { 8, "FA_Revoke_Req"},
- { 9, "FA_Revoke_Rsp"},
- { 0, NULL}
+static const ver_value_string wimaxasncp_r3_mobility_msg_vals[] =
+{
+ {0, { 1, "Anchor_DPF_HO_Req"}},
+ {0, { 2, "Anchor_DPF_HO_Trigger"}},
+ {0, { 3, "Anchor_DPF_HO_Rsp"}},
+ {0, { 4, "Anchor_DPF_Relocate_Req"}},
+ {0, { 5, "FA_Register_Req"}},
+ {0, { 6, "FA_Register_Rsp"}},
+ {0, { 7, "Anchor_DPF_Relocate_Rsp"}},
+ {0, { 8, "FA_Revoke_Req"}},
+ {0, { 9, "FA_Revoke_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 5, "Anchor_DPF_Relocate_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 6, "FA_Register_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 7, "FA_Register_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 10, "Anchor_DPF_Release_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 11, "Relocation_Ready_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 12, "Relocation_Ready_Rsp"}},
+ {0, { 0, NULL}}
};
/* ------------------------------------------------------------------------- */
-static const value_string wimaxasncp_paging_msg_vals[] =
-{
- { 1, "Initiate_Paging_Req"},
- { 2, "Initiate_Paging_Rsp"},
- { 3, "LU_Cnf"},
- { 4, "LU_Req"},
- { 5, "LU_Rsp"},
- { 6, "Paging_Announce"},
- { 7, "CMAC_Key_Count_Req"},
- { 8, "CMAC_Key_Count_Rsp"},
- { 0, NULL}
+static const ver_value_string wimaxasncp_paging_msg_vals[] =
+{
+ {0, { 1, "Initiate_Paging_Req"}},
+ {0, { 2, "Initiate_Paging_Rsp"}},
+ {0, { 3, "LU_Cnf"}},
+ {0, { 4, "LU_Req"}},
+ {0, { 5, "LU_Rsp"}},
+ {0, { 6, "Paging_Announce"}},
+ {0, { 7, "CMAC_Key_Count_Req"}},
+ {0, { 8, "CMAC_Key_Count_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 1, "Paging_Announce"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 2, "Delete_MS_Entry_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 3, "PC_Relocation_Ind"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 4, "PC_Relocation_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 5, "Obsolete"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 6, "Obsolete"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 7, "Obsolete"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 8, "Obsolete"}},
+ {0, { 0, NULL}}
};
/* ------------------------------------------------------------------------- */
-static const value_string wimaxasncp_rrm_msg_vals[] =
-{
- { 1, "R6 PHY_Parameters_Req"},
- { 2, "R6 PHY_Parameters_Rpt"},
- { 3, "R4/R6 Spare_Capacity_Req"},
- { 4, "R4/R6 Spare_Capacity_Rpt"},
- { 5, "R6 Neighbor_BS_Resource_Status_Update"},
- { 6, "R4/R6 Radio_Config_Update_Req"},
- { 7, "R4/R6 Radio_Config_Update_Rpt"},
- { 0, NULL}
+static const ver_value_string wimaxasncp_rrm_msg_vals[] =
+{
+ {0, { 1, "R6 PHY_Parameters_Req"}},
+ {0, { 2, "R6 PHY_Parameters_Rpt"}},
+ {0, { 3, "R4/R6 Spare_Capacity_Req"}},
+ {0, { 4, "R4/R6 Spare_Capacity_Rpt"}},
+ {0, { 5, "R6 Neighbor_BS_Resource_Status_Update"}},
+ {0, { 6, "R4/R6 Radio_Config_Update_Req"}},
+ {0, { 7, "R4/R6 Radio_Config_Update_Rpt"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 8, "R4/R6 Radio_Config_Update_Ack"}},
+ {0, { 0, NULL}}
};
/* ------------------------------------------------------------------------- */
-static const value_string wimaxasncp_authentication_msg_vals[] =
-{
- { 1, "AR_Authenticated_EAP_Start"},
- { 2, "AR_Authenticated_EAP_Transfer"},
- { 3, "AR_EAP_Start"},
- { 4, "AR_EAP_Transfer"},
- { 5, "AR_EAP_Complete"},
- { 6, "CMAC_Key_Count_Update"}, /* Nokia recommended value */
- { 7, "CMAC_Key_Count_Update_Ack"}, /* Nokia recommended value */
- { 0, NULL}
+static const ver_value_string wimaxasncp_authentication_msg_vals[] =
+{
+ {0, { 1, "AR_Authenticated_Eap_Start"}},
+ {0, { 2, "AR_Authenticated_EAP_Transfer"}},
+ {0, { 3, "AR_Eap_Start"}},
+ {0, { 4, "AR_EAP_Transfer"}},
+ {0, { 5, "AR_EAP_Complete"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 1, "AR_EAP_Start"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 2, "AR_EAP_Transfer"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 3, "Bulk_Interim_Update"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 4, "Bulk_Interim_Update_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 5, "Obsolete"}},
+ {0, { 0, NULL}}
};
/* ------------------------------------------------------------------------- */
-static const value_string wimaxasncp_ms_state_msg_vals[] =
-{
- { 1, "IM_Entry_State_Change_Req"},
- { 2, "IM_Entry_State_Change_Rsp"},
- { 3, "IM_Exit_State_Change_Req"},
- { 4, "IM_Exit_State_Change_Rsp"},
- { 5, "NW_ReEntry_State_Change_Directive"},
- { 6, "MS_PreAttachment_Req"},
- { 7, "MS_PreAttachment_Rsp"},
- { 8, "MS_PreAttachment_Ack"},
- { 9, "MS_Attachment_Req"},
- { 10, "MS_Attachment_Rsp"},
- { 11, "MS_Attachment_Ack"},
- { 12, "IM_Entry_State_Change_Ack"},
- { 0, NULL}
+static const ver_value_string wimaxasncp_ms_state_msg_vals[] =
+{
+ {0, { 1, "IM_Entry_State_Change_Req"}},
+ {0, { 2, "IM_Entry_State_Change_Rsp"}},
+ {0, { 3, "IM_Exit_State_Change_Req"}},
+ {0, { 4, "IM_Exit_State_Change_Rsp"}},
+ {0, { 5, "NW_ReEntry_State_Change_Directive"}},
+ {0, { 6, "MS_PreAttachment_Req"}},
+ {0, { 7, "MS_PreAttachment_Rsp"}},
+ {0, { 8, "MS_PreAttachment_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 1, "MS_PreAttachment_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 2, "MS_PreAttachment_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 3, "MS_PreAttachment_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 4, "MS_Attachment_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 5, "MS_Attachment_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 6, "MS_Attachment_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 7, "Key_Change_Directive"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 8, "Key_Change_Cnf"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 9, "Key_Change_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 10, "Relocation_Conplete_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 11, "Relocation_Conplete_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 12, "Relocation_Conplete_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 13, "Relocation_Notify"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 14, "Relocation_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 15, "Relocation_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 16, "NetExit_MS_State_Change_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 17, "NetExit_MS_State_Change_Rsp"}},
+ {0, { 0, NULL}}
};
/* ------------------------------------------------------------------------- */
-static const value_string wimaxasncp_reauthentication_msg_vals[] =
-{
- { 1, "AR_EAP_Start"},
- { 2, "Key_Change_Directive"},
- { 3, "Key_Change_Cnf"},
- { 4, "Relocation_Cnf"},
- { 5, "Relocation_Confirm_Ack"},
- { 6, "Relocation_Notify"},
- { 7, "Relocation_Notify_Ack"},
- { 8, "Relocation_Req"},
- { 9, "Relocation_Rsp"},
- { 10, "Key_Change_Ack"},
- { 0, NULL}
+/* note - function type 10-im_operation, was once used for re-authrntication */
+static const ver_value_string wimaxasncp_im_operations_msg_vals[] =
+{
+ {0, { 1, "AR_EAP_Start"}},
+ {0, { 2, "Key_Change_Directive"}},
+ {0, { 3, "Key_Change_Cnf"}},
+ {0, { 4, "Relocation_Cnf"}},
+ {0, { 5, "Relocation_Confirm_Ack"}},
+ {0, { 6, "Relocation_Notify"}},
+ {0, { 7, "Relocation_Notify_Ack"}},
+ {0, { 8, "Relocation_Req"}},
+ {0, { 9, "Relocation_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 1, "IM_Entry_State_Change_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 2, "IM_Entry_State_Change_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 3, "IM_Entry_State_Change_Ack"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 4, "IM_Exit_State_Change_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 5, "IM_Exit_State_Change_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 6, "Initiate_Paging_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 7, "Initiate_Paging_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 8, "LU_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 9, "LU_Rsp"}},
+ {WIMAXASNCP_NWGVER_R10_V120, { 10, "LU_Cnf"}},
+ {0, { 0, NULL}}
};
/* ------------------------------------------------------------------------- */
-static const value_string wimaxasncp_session_msg_vals[] =
+static const ver_value_string wimaxasncp_accounting_msg_vals_r1v121[] =
{
- { 1, "Session_Release_Req"}, /* Nokia recommended value */
- { 2, "Session_Release_Rsp"}, /* Nokia recommended value */
- { 3, "Session_Release_Ack"}, /* Nokia recommended value */
- { 4, "Session_Failure_Rpt"}, /* Nokia recommended value */
- { 5, "Session_Failure_Rsp"}, /* Nokia recommended value */
- { 0, NULL}
+ {WIMAXASNCP_NWGVER_R10_V121, { 1, "Hot_lining_Req"}},
+ {WIMAXASNCP_NWGVER_R10_V121, { 2, "Hot_lining_Rsp"}},
+ {0, { 0, NULL}}
};
+/* ------------------------------------------------------------------------- */
+
+/* supported NWG versions */
+static const enum_val_t wimaxasncp_nwg_versions[] = {
+ { "Release 1.0, Version 1.0.0" , "R1.0 v1.0.0" , WIMAXASNCP_NWGVER_R10_V100 },
+ { "Release 1.0, Version 1.2.0" , "R1.0 v1.2.0" , WIMAXASNCP_NWGVER_R10_V120 },
+ { "Release 1.0, Version 1.2.1" , "R1.0 v1.2.1" , WIMAXASNCP_NWGVER_R10_V121 },
+ { NULL, NULL, 0 }
+};
+
+/* ------------------------------------------------------------------------- */
+
+/* NWG version */
+#define WIMAXASNCP_DEF_NWGVER WIMAXASNCP_NWGVER_R10_V121
+static guint global_wimaxasncp_nwg_ver = WIMAXASNCP_DEF_NWGVER;
+
/* ========================================================================= */
typedef struct {
guint8 function_type;
- const value_string *vals;
+ const ver_value_string *vals;
} wimaxasncp_func_msg_t;
/* ------------------------------------------------------------------------ */
{ WIMAXASNCP_FT_QOS, wimaxasncp_qos_msg_vals },
{ WIMAXASNCP_FT_HO_CONTROL, wimaxasncp_ho_control_msg_vals },
{ WIMAXASNCP_FT_DATA_PATH_CONTROL, wimaxasncp_data_path_control_msg_vals },
- { WIMAXASNCP_FT_CONTEXT_DELIVERY, wimaxasncp_context_delivery_msg_vals },
+ { WIMAXASNCP_FT_CONTEXT_TRANSFER, wimaxasncp_context_transfer_msg_vals },
{ WIMAXASNCP_FT_R3_MOBILITY, wimaxasncp_r3_mobility_msg_vals },
{ WIMAXASNCP_FT_PAGING, wimaxasncp_paging_msg_vals },
{ WIMAXASNCP_FT_RRM, wimaxasncp_rrm_msg_vals },
{ WIMAXASNCP_FT_AUTHENTICATION, wimaxasncp_authentication_msg_vals },
{ WIMAXASNCP_FT_MS_STATE, wimaxasncp_ms_state_msg_vals },
- { WIMAXASNCP_FT_REAUTHENTICATION, wimaxasncp_reauthentication_msg_vals },
- { WIMAXASNCP_FT_SESSION, wimaxasncp_session_msg_vals }
-};
-
-/* =========================================================================
- * TLV related structures.
- * Note: The value_string structures and TLV types are kept in the same
- * order as found in the spec.
- * ========================================================================= */
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_accept_reject_indicator_vals[]=
-{
- { 0x00, "accept"},
- { 0x01, "reject"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_action_code_vals[] =
-{
- { 0x0000, "Deregister MS"},
- { 0x0001, "Suspend all MS traffic"},
- { 0x0002, "Suspend user traffic"},
- { 0x0003, "Resume traffic"},
- { 0x0004, "MS terminate current normal operations with BS"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const
-value_string wimaxasncp_tlv_anchor_pc_relocation_request_response_vals[] =
-{
- { 0xff, "accept"},
- { 0x00, "refuse"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_auth_ind_vals[]=
-{
- { 0, "Initial authentication"},
- { 1, "Re-authentication"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_authorization_policy_vals[] =
-{
- { WIMAXASNCP_BIT16(0), "RSA authorization"},
- { WIMAXASNCP_BIT16(1), "EAP authorization"},
- { WIMAXASNCP_BIT16(2), "Authenticated-EAP authorization"},
- { WIMAXASNCP_BIT16(3), "HMAC supported"},
- { WIMAXASNCP_BIT16(4), "CMAC supported"},
- { WIMAXASNCP_BIT16(5), "64-bit Short-HMAC"},
- { WIMAXASNCP_BIT16(6), "80-bit Short-HMAC"},
- { WIMAXASNCP_BIT16(7), "96-bit Short-HMAC"},
- { WIMAXASNCP_BIT16(8), "Reauthentication Policy (TBD)"},
- { WIMAXASNCP_BIT16(9), "Reauthentication Policy (TBD)"},
- { WIMAXASNCP_BIT16(10), "Reauthentication Policy (TBD)"},
- { WIMAXASNCP_BIT16(11), "Reauthentication Policy (TBD)"},
- { WIMAXASNCP_BIT16(12), "Reauthentication Policy (TBD)"},
- { WIMAXASNCP_BIT16(13), "Reauthentication Policy (TBD)"},
- { WIMAXASNCP_BIT16(14), "Reauthentication Policy (TBD)"},
- { WIMAXASNCP_BIT16(15), "Reauthentication Policy (TBD)"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_classifier_action_vals[] =
-{
- { 0, "Add Classifier"},
- { 1, "Replace Classifier"},
- { 2, "Delete Classifier"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_classifier_type_vals[] =
-{
- { 1, "IP TOS/DSCP Range and Mask"},
- { 2, "Protocol"},
- { 3, "IP Source Address and Mask"},
- { 4, "IP Destination Address and Mask"},
- { 5, "Protocol Source Port Range"},
- { 6, "Protocol Destination Port Range"},
- { 7, "IEEE 802.3/Ethernet Destination MAC address"},
- { 8, "IEEE 802.3/Ethernet Source MAC address"},
- { 9, "Ethertype/IEEE 802.2 SAP"},
- { 10, "IEEE 802.1D User_Priority"},
- { 11, "IEEE 802.1Q VLAN_ID"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_combined_resources_required_vals[] =
-{
- { 0x0000, "Not combined"},
- { 0x0001, "Combined"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_context_purpose_indicator_vals[] =
-{
- { WIMAXASNCP_BIT32(0), "MS AK Context"},
- { WIMAXASNCP_BIT32(1), "MS Network Context"},
- { WIMAXASNCP_BIT32(2), "MS MAC Context"},
- { WIMAXASNCP_BIT32(3), "Service Authorization Context"},
- { WIMAXASNCP_BIT32(4), "FA Context"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_cryptographic_suite_vals[] =
-{
- { 0x000000, "No data encryption, no data authentication & 3-DES, 128"},
- { 0x010001, "CBC-Mode 56-bit DES, no data authentication & 3-DES, 128"},
- { 0x000002, "No data encryption, no data authentication & RSA, 1024"},
- { 0x010002, "CBC-Mode 56-bit DES, no data authentication & RSA, 1024"},
- { 0x020103, "CCM-Mode 128-bit AES, CCM-Mode, 128-bit, ECB mode AES"
- " with 128-bit key"},
- { 0x020104, "CCM-Mode 128bits AES, CCM-Mode, AES Key Wrap with 128-bit"
- " key"},
- { 0x030003, "CBC-Mode 128-bit AES, no data authentication, ECB mode AES"
- " with 128-bit key"},
- { 0x800003, "MBS CTR Mode 128 bits AES, no data authentication, AES ECB"
- " mode with 128-bit key"},
- { 0x800004, "MBS CTR mode 128 bits AES, no data authentication, AES Key"
- " Wrap with 128-bit key"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_cs_type_vals[]=
-{
- { 1, "Packet, IPv4"},
- { 2, "Packet, IPv6"},
- { 3, "Packet, 802.3"},
- { 4, "Packet, 802.1Q"},
- { 5, "Packet, IPv4over802.3"},
- { 6, "Packet, IPv6over802.3"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_data_integrity_vals[] =
-{
- { 0x0, "No recommendation"},
- { 0x1, "Data integrity requested"},
- { 0x2, "Data delay jitter sensitive"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_data_path_encapsulation_type_vals[] =
-{
- { 1, "GRE"},
- { 2, "IP-in-IP"},
- { 3, "VLAN"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static
-const value_string wimaxasncp_tlv_data_path_establishment_option_vals[] =
-{
- { 0, "Do not (Pre-) Establish DP"},
- { 1, "(Pre-) Establish DP"},
- { 0, NULL }
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_data_path_integrity_mechanism_vals[]=
-{
- /* No values defined yet. */
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_data_path_type_vals[]=
-{
- { 0, "Type1"},
- { 1, "Type2"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static
-const value_string wimaxasncp_tlv_device_authentication_indicator_vals[]=
-{
- { 0, "Reserved"},
- { 1, "Certificate-based device authentication has been successfully"
- " performed"},
- { 2, "Device authentication has been successfully performed."},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_direction_vals[] =
-{
- { 0x001, "For Uplink"},
- { 0x002, "For Downlink"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static
-const value_string wimaxasncp_tlv_exit_idle_mode_operation_indication_vals[]=
-{
- { 0, "No"},
- { 1, "Yes"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_failure_indication_vals[]=
-{
- { 0, "Unspecified Error"},
- { 1, "Incompatible Version Number"},
- { 2, "Invalid Function Type"},
- { 3, "Invalid Message Type"},
- { 4, "Unknown MSID"},
- { 5, "Transaction Failure"},
- { 6, "Unknown Source Identifier"},
- { 7, "Unknown Destination Identifier"},
- { 8, "Invalid Message Header"},
- { 16, "Invalid message format"},
- { 17, "Mandatory TLV missing"},
- { 18, "TLV Value Invalid"},
- { 19, "Unsupported Options"},
- { 32, "Timer expired without response"},
- { 48, "Requested Context Unavailable"},
- { 49, "Authorization Failure"},
- { 50, "Registration Failure"},
- { 51, "No Resources"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_ho_confirm_type_vals[] =
-{
- { 0, "Confirm"},
- { 1, "Unconfirm"},
- { 2, "Cancel"},
- { 3, "Reject"},
- { 0, NULL}
-};
-
-static const value_string wimaxasncp_tlv_ho_type_vals[] =
-{
- { 0, "HHO"},
- { 0, NULL }
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_location_update_status_vals[]=
-{
- { 0, "Refuse"},
- { 1, "Accept"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const
-value_string wimaxasncp_tlv_location_update_success_failure_indication_vals[]=
-{
- { 0, "Success"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_ms_mobility_mode_vals[]=
-{
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_network_exit_indicator_vals[]=
-{
- { 0x00, "MS Power Down indication"},
- { 0x01, "Radio link with MS is lost"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_paging_cause_vals[]=
-{
- { 1, "LCS"},
- { 2, "Incoming Data for Idle MS"},
- { 3, "Acknowledge Exiting Idle Mode"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_phs_rule_action_vals[]=
-{
- { 0, "Add PHS Rule"},
- { 1, "Replace PHS Rule"},
- { 2, "Delete PHS Rule"},
- { 3, "Delete All PHS Rules"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_phsv_vals[]=
-{
- { 0, "Verify"},
- { 1, "Don't verify"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_pkm_context_vals[]=
-{
- { 0, "PKM Capabilities defined in the MTG Profile."},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_pkm2_vals[]=
-{
- { 18, "EAP Transfer"},
- { 19, "Authenticated EAP Transfer"},
- { 29, "EAP Complete"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_reg_context_vals[] =
-{
- { 0, "REG handshake related capabilities defined in the MTG Profile"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_registration_type_vals[] =
-{
- { 0, "Initial Network Entry"},
- { 1, "HO"},
- { 2, "In-Service Data Path Establishment"},
- { 3, "MS Network Exit"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_reservation_action_vals[] =
-{
- { WIMAXASNCP_BIT16(15), "Create service flow"},
- { WIMAXASNCP_BIT16(14), "Admit service flow"},
- { WIMAXASNCP_BIT16(13), "Activate service flow"},
- { WIMAXASNCP_BIT16(12), "Modify service flow"},
- { WIMAXASNCP_BIT16(11), "Delete service flow"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_reservation_result_vals[] =
-{
- { 0x0000, "Successfully Created"},
- { 0x0001, "Request Denied - No resources"},
- { 0x0002, "Request Denied due to Policy"},
- { 0x0003, "Request Denied due to Requests for Other Flows Failed"},
- { 0x0004, "Request Failed (Unspecified reason)"},
- { 0x0005, "Request Denied due to MS reason"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_request_transmission_policy_vals[]=
-{
- { WIMAXASNCP_BIT32(0), "Service flow SHALL not use broadcast bandwidth"
- " request opportunities"},
- { WIMAXASNCP_BIT32(1), "Reserved"},
- { WIMAXASNCP_BIT32(2), "Service flow SHALL not piggyback requests"
- " with data"},
- { WIMAXASNCP_BIT32(3), "Service flow SHALL not fragment data"},
- { WIMAXASNCP_BIT32(4), "Service flow SHALL not suppress payload headers"},
- { WIMAXASNCP_BIT32(5), "Service flow SHALL not pack multiple SDUs"
- " (or fragments) into single MAC PDUs"},
- { WIMAXASNCP_BIT32(6), "Service flow SHALL not include CRC in the"
- " MAC PDU"},
- {0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_response_code_vals[]=
-{
- { 1, "not allowed - Paging Reference is zero"},
- { 2, "not allowed - no such SF"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_rrm_reporting_characteristics_vals[]=
-{
- { WIMAXASNCP_BIT32(0), "periodically as defined by reporting period P"},
- { WIMAXASNCP_BIT32(1), "regularly whenever resources have changed as"
- " defined by RT since the last measurement"
- " period"},
- { WIMAXASNCP_BIT32(2), "regularly whenever resources cross predefined"
- " total threshold(s) defined by reporting"
- " absolute threshold values J"},
- { WIMAXASNCP_BIT32(3), "DCD/UCD Configuration Change Count modification"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_rrm_spare_capacity_report_type_vals[]=
-{
- { 0, "Type 1: Available radio resource indicator"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_r3_operation_status_vals[]=
-{
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_r3_release_reason_vals[]=
-{
- { 0, "MS power down"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_sa_service_type_vals[]=
-{
- { 0, "Unicast Service"},
- { 1, "Group Multicast Service"},
- { 2, "MBS Service"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_sa_type_vals[]=
-{
- { 0, "Primary"},
- { 1, "Static"},
- { 2, "Dynamic"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_serving_target_indicator_vals[] =
-{
- { 0, "Serving"},
- { 1, "Target"},
- { 0, NULL}
-};
-
-/* ------------------------------------------------------------------------- */
-
-static const value_string wimaxasncp_tlv_sf_classification_vals[]=
-{
- { 0, "SF classification not supported"},
- { 1, "SF classification supported"},
- { 0, NULL}
+ { WIMAXASNCP_FT_IM_OPERATIONS, wimaxasncp_im_operations_msg_vals },
+ { WIMAXASNCP_FT_ACCOUNTING, wimaxasncp_accounting_msg_vals_r1v121 }
};
-/* -------------------------------------------------------------------------
- * decode types
- * ------------------------------------------------------------------------- */
+/* ========================================================================= */
-enum
+static const wimaxasncp_dict_tlv_t *wimaxasncp_get_tlv_info(
+ guint16 type)
{
- WIMAXASNCP_TLV_TBD,
- WIMAXASNCP_TLV_COMPOUND,
- WIMAXASNCP_TLV_BYTES,
- WIMAXASNCP_TLV_ENUM8,
- WIMAXASNCP_TLV_ENUM16,
- WIMAXASNCP_TLV_ENUM32,
- WIMAXASNCP_TLV_ETHER,
- WIMAXASNCP_TLV_ASCII_STRING,
- WIMAXASNCP_TLV_FLAG0,
- WIMAXASNCP_TLV_BITFLAGS16,
- WIMAXASNCP_TLV_BITFLAGS32,
- WIMAXASNCP_TLV_ID,
- WIMAXASNCP_TLV_HEX8,
- WIMAXASNCP_TLV_HEX16,
- WIMAXASNCP_TLV_HEX32,
- WIMAXASNCP_TLV_DEC8,
- WIMAXASNCP_TLV_DEC16,
- WIMAXASNCP_TLV_DEC32,
- WIMAXASNCP_TLV_IP_ADDRESS, /* Note: IPv4 or IPv6, determined by length */
- WIMAXASNCP_TLV_IPV4_ADDRESS,
- WIMAXASNCP_TLV_PROTOCOL_LIST,
- WIMAXASNCP_TLV_PORT_RANGE_LIST,
- WIMAXASNCP_TLV_IP_ADDRESS_MASK_LIST,
- WIMAXASNCP_TLV_VENDOR_SPECIFIC
-};
+ wimaxasncp_dict_tlv_t *res = NULL;
-/* -------------------------------------------------------------------------
- * TLV database
- * ------------------------------------------------------------------------- */
-
-typedef struct {
- guint16 type;
- const gchar *name;
- gint decode_type;
- const value_string *vals;
-} wimaxasncp_tlv_info_t;
+ if (wimaxasncp_dict)
+ {
+ wimaxasncp_dict_tlv_t *tlv;
-/* ------------------------------------------------------------------------- */
+ for (tlv = wimaxasncp_dict->tlvs; tlv; tlv = tlv->next)
+ {
+ if (tlv->type == type)
+ {
+ /* if the TLV is defined for current NWG version */
+ if (tlv->since<= global_wimaxasncp_nwg_ver)
+ {
+ /* if the current TLV is newer then last found TLV, save it */
+ if(!res || (tlv->since > res->since))
+ {
+ res = tlv;
+ }
+ }
+ }
+ }
+ }
-static const wimaxasncp_tlv_info_t wimaxasncp_tlv_db[] =
-{
- {
- 1, "Accept/Reject Indicator",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_accept_reject_indicator_vals
- },
- {
- 2, "Accounting Extension",
- WIMAXASNCP_TLV_BYTES,
- NULL
- },
- {
- 3, "Action Code",
- WIMAXASNCP_TLV_ENUM16,
- wimaxasncp_tlv_action_code_vals
- },
- {
- 4, "Action Time",
- WIMAXASNCP_TLV_DEC32,
- NULL
- },
- {
- 5, "AK",
- WIMAXASNCP_TLV_BYTES,
- NULL
- },
- {
- 6, "AK Context",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 7, "AK ID",
- WIMAXASNCP_TLV_BYTES,
- NULL
- },
- {
- 8, "AK Lifetime",
- WIMAXASNCP_TLV_DEC16,
- NULL
- },
- {
- 9, "AK SN",
- WIMAXASNCP_TLV_HEX8,
- NULL
- },
- {
- 10, "Anchor ASN GW ID / Anchor DPF Identifier",
- WIMAXASNCP_TLV_ID,
- NULL
- },
- {
- 11, "Anchor MM Context",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 12, "Anchor PCID - Anchor Paging Controller ID",
- WIMAXASNCP_TLV_ID,
- NULL
- },
- {
- 13, "Anchor PC Relocation Destination",
- WIMAXASNCP_TLV_ID,
- NULL
- },
- {
- 14, "Anchor PC Relocation Request Response",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_anchor_pc_relocation_request_response_vals
- },
- {
- 15, "Associated PHSI",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 16, "Anchor Authenticator ID",
- WIMAXASNCP_TLV_ID,
- NULL
- },
- {
- 17, "Authentication Complete",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 18, "Authentication Result",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_success_failure_vals
- },
- {
- 19, "Authenticator Identifier",
- WIMAXASNCP_TLV_ID,
- NULL
- },
- {
- 20, "Auth-IND",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_auth_ind_vals
- },
- {
- 21, "Authorization Policy",
- WIMAXASNCP_TLV_BITFLAGS16,
- wimaxasncp_tlv_authorization_policy_vals
- },
- {
- 22, "Available Radio Resource DL",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 23, "Available Radio Resource UL",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 24, "BE Data Delivery Service",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 25, "BS ID",
- WIMAXASNCP_TLV_ID,
- NULL
- },
- {
- 26, "BS Info",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 27, "BS-originated EAP-Start Flag",
- WIMAXASNCP_TLV_FLAG0,
- NULL
- },
- {
- 28, "Care-Of Address (CoA)",
- WIMAXASNCP_TLV_IPV4_ADDRESS,
- NULL
- },
- {
- 29, "CID",
- WIMAXASNCP_TLV_HEX16,
- NULL
- },
- {
- 30, "Classifier",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 31, "Classifier Action",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_classifier_action_vals
- },
- {
- 32, "Classifier Rule Priority",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 33, "Classifier Type",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_classifier_type_vals
- },
- {
- 34, "CMAC_KEY_COUNT",
- WIMAXASNCP_TLV_DEC16,
- NULL
- },
- {
- 35, "Combined Resources Required",
- WIMAXASNCP_TLV_ENUM16,
- wimaxasncp_tlv_combined_resources_required_vals
- },
- {
- 36, "Context Purpose Indicator",
- WIMAXASNCP_TLV_ENUM32,
- wimaxasncp_tlv_context_purpose_indicator_vals
- },
- {
- 37, "Correlation ID",
- WIMAXASNCP_TLV_HEX32,
- NULL
- },
- {
- 38, "Cryptographic Suite",
- WIMAXASNCP_TLV_ENUM32,
- wimaxasncp_tlv_cryptographic_suite_vals
- },
- {
- 39, "CS Type",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_cs_type_vals
- },
- {
- 40, "Data Integrity",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_data_integrity_vals
- },
- {
- 41, "Data Integrity Info",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 42, "Data Path Encapsulation Type",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_data_path_encapsulation_type_vals
- },
- {
- 43, "Data Path Establishment Option",
- WIMAXASNCP_TLV_HEX8,
- wimaxasncp_tlv_data_path_establishment_option_vals
- },
- {
- 44, "Data Path ID",
- WIMAXASNCP_TLV_HEX32,
- NULL
- },
- {
- 45, "Data Path Info",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 46, "Data Path Integrity Mechanism",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_data_path_integrity_mechanism_vals
- },
- {
- 47, "Data Path Type",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_data_path_type_vals
- },
- {
- 48, "DCD/UCD Configuration Change Count",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 49, "DCD Setting",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 50, "Device Authentication Indicator",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_device_authentication_indicator_vals
- },
- {
- 51, "DHCP Key",
- WIMAXASNCP_TLV_BYTES,
- NULL
- },
- {
- 52, "DHCP Key ID",
- WIMAXASNCP_TLV_HEX32,
- NULL
- },
- {
- 53, "DHCP Key Lifetime",
- WIMAXASNCP_TLV_DEC32,
- NULL
- },
- {
- 54, "DHCP Proxy Info",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 55, "DHCP Relay Address",
- WIMAXASNCP_TLV_IPV4_ADDRESS,
- NULL
- },
- {
- 56, "DHCP Relay Info",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 57, "DHCP Server Address",
- WIMAXASNCP_TLV_IPV4_ADDRESS,
- NULL
- },
- {
- 58, "DHCP Server List",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 59, "Direction",
- WIMAXASNCP_TLV_ENUM16,
- wimaxasncp_tlv_direction_vals
- },
- {
- 60, "DL PHY Quality Info",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 61, "DL PHY Service Level",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 62, "EAP Payload",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 63, "EIK",
- WIMAXASNCP_TLV_BYTES,
- NULL
- },
- {
- 64, "ERT-VR Data Delivery Service",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 65, "Exit IDLE Mode Operation Indication",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_exit_idle_mode_operation_indication_vals
- },
- {
- 66, "FA-HA Key",
- WIMAXASNCP_TLV_BYTES,
- NULL
- },
- {
- 67, "FA-HA Key Lifetime",
- WIMAXASNCP_TLV_DEC32,
- NULL
- },
- {
- 68, "FA-HA Key SPI",
- WIMAXASNCP_TLV_HEX32,
- NULL
- },
- {
- 69, "Failure Indication",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_failure_indication_vals
- },
- {
- 70, "FA IP Address",
- WIMAXASNCP_TLV_IPV4_ADDRESS,
- NULL
- },
- {
- 71, "FA Relocation Indication",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_success_failure_vals
- },
- {
- 72, "Full DCD Setting",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 73, "Full UCD Setting",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 74, "Global Service Class Change",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 75, "HA IP Address",
- WIMAXASNCP_TLV_IP_ADDRESS,
- NULL
- },
- {
- 76, "HO Confirm Type",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_ho_confirm_type_vals
- },
- {
- 77, "Home Address (HoA)",
- WIMAXASNCP_TLV_IPV4_ADDRESS,
- NULL
- },
- {
- 78, "HO Process Optimization",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 79, "HO Type",
- WIMAXASNCP_TLV_ENUM32,
- wimaxasncp_tlv_ho_type_vals
- },
- {
- 80, "IDLE Mode Info",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 81, "IDLE Mode Retain Info",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 82, "IP Destination Address and Mask",
- WIMAXASNCP_TLV_IP_ADDRESS_MASK_LIST,
- NULL
- },
- {
- 83, "IP Remained Time",
- WIMAXASNCP_TLV_DEC32,
- NULL
- },
- {
- 84, "IP Source Address and Mask",
- WIMAXASNCP_TLV_IP_ADDRESS_MASK_LIST,
- NULL
- },
- {
- 85, "IP TOS/DSCP Range and Mask",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 86, "Key Change Indicator",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_success_failure_vals
- },
- {
- 87, "L-BSID",
- WIMAXASNCP_TLV_ID,
- NULL
- },
- {
- 88, "Location Update Status",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_location_update_status_vals
- },
- {
- 89, "Location Update Success/Failure Indication",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_location_update_success_failure_indication_vals
- },
- {
- 90, "LU Result Indicator",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_success_failure_vals
- },
- {
- 91, "Maximum Latency",
- WIMAXASNCP_TLV_DEC32,
- NULL
- },
- {
- 92, "Maximum Sustained Traffic Rate",
- WIMAXASNCP_TLV_DEC32,
- NULL
- },
- {
- 93, "Maximum Traffic Burst",
- WIMAXASNCP_TLV_DEC32,
- NULL
- },
- {
- 94, "Media Flow Type",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 95, "Minimum Reserved Traffic Rate",
- WIMAXASNCP_TLV_DEC32,
- NULL
- },
- {
- 96, "MIP4 Info",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 97, "MIP4 Security Info",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 98, "MN-FA Key",
- WIMAXASNCP_TLV_BYTES,
- NULL
- },
+ if (debug_enabled && !res)
{
- 99, "MN-FA SPI",
- WIMAXASNCP_TLV_HEX32,
- NULL
- },
- {
- 100, "MS Authorization Context",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 101, "MS FA Context",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 102, "MS ID",
- WIMAXASNCP_TLV_ETHER,
- NULL
- },
- {
- 103, "MS Info",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 104, "MS Mobility Mode",
- WIMAXASNCP_TLV_TBD,
- wimaxasncp_tlv_ms_mobility_mode_vals
- },
- {
- 105, "MS NAI",
- WIMAXASNCP_TLV_ASCII_STRING,
- NULL
- },
- {
- 106, "MS Networking Context",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 107, "MS Security Context",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 108, "MS Security History",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 109, "Network Exit Indicator",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_network_exit_indicator_vals
- },
- {
- 110, "Newer TEK Parameters",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 111, "NRT-VR Data Delivery Service",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 112, "Older TEK Parameters",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 113, "Old Anchor PCID",
- WIMAXASNCP_TLV_ID,
- NULL
- },
- {
- 114, "Packet Classification Rule / Media Flow Description",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 115, "Paging Announce Timer",
- WIMAXASNCP_TLV_DEC16,
- NULL
- },
- {
- 116, "Paging Cause",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_paging_cause_vals
- },
- {
- 117, "Paging Controller Identifier",
- WIMAXASNCP_TLV_ID,
- NULL
- },
- {
- 118, "Paging Cycle",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 119, "Paging Information",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 120, "Paging Offset",
- WIMAXASNCP_TLV_DEC16,
- NULL
- },
- {
- 121, "Paging Start/Stop",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 122, "PC Relocation Indication",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 123, "PGID - Paging Group ID",
- WIMAXASNCP_TLV_HEX16,
- NULL
- },
- {
- 124, "PHSF",
- WIMAXASNCP_TLV_BYTES,
- NULL
- },
- {
- 125, "PHSI",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 126, "PHSM",
- WIMAXASNCP_TLV_BYTES,
- NULL
- },
- {
- 127, "PHS Rule",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 128, "PHS Rule Action",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_phs_rule_action_vals
- },
- {
- 129, "PHSS",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 130, "PHSV",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_phsv_vals
- },
- {
- 131, "PKM Context",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_pkm_context_vals
- },
- {
- 132, "PMIP4 Client Location",
- WIMAXASNCP_TLV_IPV4_ADDRESS,
- NULL
- },
- {
- 133, "PMK SN",
- WIMAXASNCP_TLV_HEX8,
- NULL
- },
- {
- 134, "PKM2",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_pkm2_vals
- },
- {
- 135, "PMK2 SN",
- WIMAXASNCP_TLV_HEX8,
- NULL
- },
- {
- 136, "PN Counter",
- WIMAXASNCP_TLV_HEX32,
- NULL
- },
- {
- 137, "Preamble Index/Sub-channel Index",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 138, "Protocol",
- WIMAXASNCP_TLV_PROTOCOL_LIST,
- NULL
- },
- {
- 139, "Protocol Destination Port Range",
- WIMAXASNCP_TLV_PORT_RANGE_LIST,
- NULL
- },
- {
- 140, "Protocol Source Port Range",
- WIMAXASNCP_TLV_PORT_RANGE_LIST,
- NULL
- },
- {
- 141, "QoS Parameters",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 142, "Radio Resource Fluctuation",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 143, "Reduced Resources Code",
- WIMAXASNCP_TLV_FLAG0,
- NULL
- },
- {
- 144, "REG Context",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_reg_context_vals
- },
- {
- 145, "Registration Type",
- WIMAXASNCP_TLV_ENUM32,
- wimaxasncp_tlv_registration_type_vals
- },
- {
- 146, "Relative Delay",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 147, "Relocation Destination ID",
- WIMAXASNCP_TLV_ID,
- NULL
- },
- {
- 148, "Relocation Response",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 149, "Relocation Success Indication",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 150, "Request/Transmission Policy",
- WIMAXASNCP_TLV_BITFLAGS32,
- wimaxasncp_tlv_request_transmission_policy_vals
- },
- {
- 151, "Reservation Action",
- WIMAXASNCP_TLV_BITFLAGS16,
- wimaxasncp_tlv_reservation_action_vals
- },
- {
- 152, "Reservation Result",
- WIMAXASNCP_TLV_ENUM16,
- wimaxasncp_tlv_reservation_result_vals
- },
- {
- 153, "Response Code",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_response_code_vals
- },
- {
- 154, "Result Code",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_success_failure_vals
- },
- {
- 155, "ROHC/ECRTP Context ID",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 156, "Round Trip Delay",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 157, "RRM Absolute Threshold Value J",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 158, "RRM Averaging Time T",
- WIMAXASNCP_TLV_DEC16,
- NULL
- },
- {
- 159, "RRM BS Info",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 160, "RRM BS-MS PHY Quality Info",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 161, "RRM Relative Threshold RT",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 162, "RRM Reporting Characteristics",
- WIMAXASNCP_TLV_BITFLAGS32,
- wimaxasncp_tlv_rrm_reporting_characteristics_vals
- },
- {
- 163, "RRM Reporting Period P",
- WIMAXASNCP_TLV_DEC16,
- NULL
- },
- {
- 164, "RRM Spare Capacity Report Type",
- WIMAXASNCP_TLV_HEX8,
- wimaxasncp_tlv_rrm_spare_capacity_report_type_vals
- },
- {
- 165, "RT-VR Data Delivery Service",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 166, "RxPN Counter",
- WIMAXASNCP_TLV_HEX32,
- NULL
- },
- {
- 167, "R3 Operation Status",
- WIMAXASNCP_TLV_TBD,
- wimaxasncp_tlv_r3_operation_status_vals
- },
- {
- 168, "R3 Release Reason",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_r3_release_reason_vals
- },
- {
- 169, "SAID",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 170, "SA Descriptor",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 171, "SA Index",
- WIMAXASNCP_TLV_HEX32,
- NULL
- },
- {
- 172, "SA Service Type",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_sa_service_type_vals
- },
- {
- 173, "SA Type",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_sa_type_vals
- },
- {
- 174, "SBC Context",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 175, "SDU BSN Map",
- WIMAXASNCP_TLV_BYTES,
- NULL
- },
- {
- 176, "SDU Info",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 177, "SDU Size",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 178, "SDU SN",
- WIMAXASNCP_TLV_DEC32,
- NULL
- },
- {
- 179, "Service Class Name",
- WIMAXASNCP_TLV_ASCII_STRING,
- NULL
- },
- {
- 180, "Service Level Prediction",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 181, "Service Authorization Code",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 182, "Serving/Target Indicator",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_serving_target_indicator_vals
- },
- {
- 183, "SF Classification",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_sf_classification_vals
- },
- {
- 184, "SFID",
- WIMAXASNCP_TLV_HEX32,
- NULL
- },
- {
- 185, "SF Info",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 186, "Spare Capacity Indicator",
- WIMAXASNCP_TLV_DEC16,
- NULL
- },
- {
- 187, "TEK",
- WIMAXASNCP_TLV_BYTES,
- NULL
- },
- {
- 188, "TEK Lifetime",
- WIMAXASNCP_TLV_DEC32,
- NULL
- },
- {
- 189, "TEK SN",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 190, "Tolerated Jitter",
- WIMAXASNCP_TLV_DEC32,
- NULL
- },
- {
- 191, "Total Slots DL",
- WIMAXASNCP_TLV_DEC16,
- NULL
- },
- {
- 192, "Total Slots UL",
- WIMAXASNCP_TLV_DEC16,
- NULL
- },
- {
- 193, "Traffic Priority/QoS Priority",
- WIMAXASNCP_TLV_DEC8,
- NULL
- },
- {
- 194, "Tunnel Endpoint",
- WIMAXASNCP_TLV_IP_ADDRESS,
- NULL
- },
- {
- 195, "UCD Setting",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 196, "UGS Data Delivery Service",
- WIMAXASNCP_TLV_COMPOUND,
- NULL
- },
- {
- 197, "UL PHY Quality Info",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 198, "UL PHY Service Level",
- WIMAXASNCP_TLV_TBD,
- NULL
- },
- {
- 199, "Unsolicited Grant Interval",
- WIMAXASNCP_TLV_DEC16,
- NULL
- },
- {
- 200, "Unsolicited Polling Interval",
- WIMAXASNCP_TLV_DEC16,
- NULL
- },
- {
- 201, "VAAA IP Address",
- WIMAXASNCP_TLV_IP_ADDRESS,
- NULL
- },
- {
- 202, "VAAA Realm",
- WIMAXASNCP_TLV_ASCII_STRING,
- NULL
- },
- {
- 1136, "Control Plane Indicator",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_success_failure_vals
- },
- {
- 1228, "IM Auth Indication",
- WIMAXASNCP_TLV_ENUM8,
- wimaxasncp_tlv_success_failure_vals
- },
- {
- 0xff01, "Source Identifier",
- WIMAXASNCP_TLV_ID,
- NULL
- },
- {
- 0xff02, "Destination Identifier",
- WIMAXASNCP_TLV_ID,
- NULL
- },
- {
- 0xffff, "Vendor Specific",
- WIMAXASNCP_TLV_VENDOR_SPECIFIC,
- NULL
+ g_print("fix-me: unknown TLV type: %u\n", type);
}
-};
+
+ return res? res:&wimaxasncp_tlv_not_found;
+}
/* ========================================================================= */
-static const wimaxasncp_tlv_info_t *wimaxasncp_get_tlv_info(
- guint16 type)
+static const gchar *wimaxasncp_get_enum_name(
+ const wimaxasncp_dict_tlv_t *tlv_info,
+ guint32 code)
{
- static wimaxasncp_tlv_info_t not_found =
- {
- 0, "Unknown",
- WIMAXASNCP_TLV_BYTES,
- NULL
- };
-
- gsize i;
- for (i = 0; i < array_length(wimaxasncp_tlv_db); ++i)
+ if (tlv_info->enum_vs)
{
- if (wimaxasncp_tlv_db[i].type == type)
- {
- return &wimaxasncp_tlv_db[i];
- }
+ return val_to_str(code, tlv_info->enum_vs, "Unknown");
}
-
- if (debug_enabled)
+ else
{
- g_print("fix-me: unknown TLV type: %u\n", type);
+ return "Unknown";
}
+}
+
+/* ========================================================================= */
- return ¬_found;
-}
+static const value_string wimaxasncp_decode_type_vals[] =
+{
+ { WIMAXASNCP_TLV_UNKNOWN, "WIMAXASNCP_TLV_UNKNOWN"},
+ { WIMAXASNCP_TLV_TBD, "WIMAXASNCP_TLV_TBD"},
+ { WIMAXASNCP_TLV_COMPOUND, "WIMAXASNCP_TLV_COMPOUND"},
+ { WIMAXASNCP_TLV_BYTES, "WIMAXASNCP_TLV_BYTES"},
+ { WIMAXASNCP_TLV_ENUM8, "WIMAXASNCP_TLV_ENUM8"},
+ { WIMAXASNCP_TLV_ENUM16, "WIMAXASNCP_TLV_ENUM16"},
+ { WIMAXASNCP_TLV_ENUM32, "WIMAXASNCP_TLV_ENUM32"},
+ { WIMAXASNCP_TLV_ETHER, "WIMAXASNCP_TLV_ETHER"},
+ { WIMAXASNCP_TLV_ASCII_STRING, "WIMAXASNCP_TLV_ASCII_STRING"},
+ { WIMAXASNCP_TLV_FLAG0, "WIMAXASNCP_TLV_FLAG0"},
+ { WIMAXASNCP_TLV_BITFLAGS8, "WIMAXASNCP_TLV_BITFLAGS8"},
+ { WIMAXASNCP_TLV_BITFLAGS16, "WIMAXASNCP_TLV_BITFLAGS16"},
+ { WIMAXASNCP_TLV_BITFLAGS32, "WIMAXASNCP_TLV_BITFLAGS32"},
+ { WIMAXASNCP_TLV_ID, "WIMAXASNCP_TLV_ID"},
+ { WIMAXASNCP_TLV_HEX8, "WIMAXASNCP_TLV_HEX8"},
+ { WIMAXASNCP_TLV_HEX16, "WIMAXASNCP_TLV_HEX16"},
+ { WIMAXASNCP_TLV_HEX32, "WIMAXASNCP_TLV_HEX32"},
+ { WIMAXASNCP_TLV_DEC8, "WIMAXASNCP_TLV_DEC8"},
+ { WIMAXASNCP_TLV_DEC16, "WIMAXASNCP_TLV_DEC16"},
+ { WIMAXASNCP_TLV_DEC32, "WIMAXASNCP_TLV_DEC32"},
+ { WIMAXASNCP_TLV_IP_ADDRESS, "WIMAXASNCP_TLV_IP_ADDRESS"},
+ { WIMAXASNCP_TLV_IPV4_ADDRESS, "WIMAXASNCP_TLV_IPV4_ADDRESS"},
+ { WIMAXASNCP_TLV_PROTOCOL_LIST, "WIMAXASNCP_TLV_PROTOCOL_LIST"},
+ { WIMAXASNCP_TLV_PORT_RANGE_LIST, "WIMAXASNCP_TLV_PORT_RANGE_LIST"},
+ { WIMAXASNCP_TLV_IP_ADDRESS_MASK_LIST,"WIMAXASNCP_TLV_IP_ADDRESS_MASK_LIST"},
+ { WIMAXASNCP_TLV_VENDOR_SPECIFIC, "WIMAXASNCP_TLV_VENDOR_SPECIFIC"},
+ { 0, NULL}
+};
/* ========================================================================= */
-static const gchar *wimaxasncp_get_enum_name(
- const wimaxasncp_tlv_info_t *tlv_info,
- guint32 value)
+static void wimaxasncp_proto_tree_add_tlv_ipv4_value(
+ tvbuff_t *tvb,
+ proto_tree *tree,
+ proto_item *tlv_item,
+ guint offset,
+ const wimaxasncp_dict_tlv_t *tlv_info)
{
+ int hf_value;
+ guint32 ip;
+ const gchar *hostname;
+ const gchar *ip_str;
- if (tlv_info->vals != NULL)
+ if (tlv_info->hf_ipv4 != -1)
{
- const gchar *name = match_strval(value, tlv_info->vals);
- if (name != NULL)
- {
- return name;
- }
+ hf_value = tlv_info->hf_ipv4;
+ }
+ else
+ {
+ hf_value = tlv_info->hf_value;
}
- return "Unknown";
+ ip = tvb_get_ipv4(tvb, offset);
+ hostname = get_hostname(ip);
+ ip_str = ip_to_str((guint8 *)&ip);
+
+ proto_tree_add_ipv4_format(
+ tree, hf_value,
+ tvb, offset, 4, ip,
+ "Value: %s (%s)", hostname, ip_str);
+
+ proto_item_append_text(
+ tlv_item, " - %s (%s)",
+ hostname, ip_str);
}
/* ========================================================================= */
-static void wimaxasncp_proto_treee_add_tlv_ipv4_value(
+static void wimaxasncp_proto_tree_add_tlv_ipv6_value(
tvbuff_t *tvb,
proto_tree *tree,
proto_item *tlv_item,
- guint offset)
+ guint offset,
+ const wimaxasncp_dict_tlv_t *tlv_info)
{
- guint32 ip;
- ip = tvb_get_ipv4(tvb, offset);
+ int hf_value;
+ struct e_in6_addr ip;
+ const gchar *hostname;
+ const gchar *ip_str;
+
+ if (tlv_info->hf_ipv4 != -1)
+ {
+ hf_value = tlv_info->hf_ipv6;
+ }
+ else
+ {
+ hf_value = tlv_info->hf_value;
+ }
- proto_tree_add_item(
- tree, hf_wimaxasncp_tlv_value_ipv4,
- tvb, offset, 4, FALSE);
+ tvb_get_ipv6(tvb, offset, &ip);
+ hostname = get_hostname6(&ip);
+ ip_str = ip6_to_str(&ip);
+
+ proto_tree_add_ipv6_format(
+ tree, hf_value,
+ tvb, offset, 16, (guint8 *)&ip,
+ "Value: %s (%s)", hostname, ip_str);
proto_item_append_text(
tlv_item, " - %s (%s)",
- get_hostname(ip), ip_to_str((guint8 *)&ip));
+ hostname, ip_str);
}
-
/* ========================================================================= */
-static void wimaxasncp_proto_treee_add_tlv_ipv6_value(
+static void wimaxasncp_proto_tree_add_ether_value(
tvbuff_t *tvb,
proto_tree *tree,
proto_item *tlv_item,
- guint offset)
+ guint offset,
+ guint length,
+ const wimaxasncp_dict_tlv_t *tlv_info)
{
- struct e_in6_addr ip;
- tvb_get_ipv6(tvb, offset, &ip);
+ int hf_value;
+ const guint8 *p;
+ const gchar *ether_name;
+ const gchar *ether_str;
+
+ if (tlv_info->hf_bsid != -1)
+ {
+ hf_value = tlv_info->hf_bsid;
+ }
+ else
+ {
+ hf_value = tlv_info->hf_value;
+ }
+
+ p = tvb_get_ptr(tvb, offset, length);
+ ether_name = get_ether_name(p);
+ ether_str = ether_to_str(p);
- proto_tree_add_item(
- tree, hf_wimaxasncp_tlv_value_ipv6,
- tvb, offset, 16, FALSE);
+ proto_tree_add_ether_format(
+ tree, hf_value,
+ tvb, offset, length, p,
+ "Value: %s (%s)",
+ ether_name, ether_str);
proto_item_append_text(
tlv_item, " - %s (%s)",
- get_hostname6(&ip), ip6_to_str(&ip));
+ ether_name, ether_str);
}
/* ========================================================================= */
packet_info *pinfo _U_,
proto_tree *tree,
proto_item *tlv_item,
- const wimaxasncp_tlv_info_t *tlv_info)
+ const wimaxasncp_dict_tlv_t *tlv_info)
{
guint offset = 0;
guint length;
- const gchar *s;
+ const guint max_show_bytes = 24; /* arbitrary */
+ const gchar *hex_note = "[hex]";
length = tvb_reported_length(tvb);
- switch(tlv_info->decode_type)
+ switch(tlv_info->decoder)
{
case WIMAXASNCP_TLV_ENUM8:
{
break;
}
- if (tlv_info->vals == NULL)
+ if (tlv_info->enums == NULL)
{
if (debug_enabled)
{
if (tree)
{
guint8 value;
+ const gchar *s;
value = tvb_get_guint8(tvb, offset);
s = wimaxasncp_get_enum_name(tlv_info, value);
proto_tree_add_uint_format(
- tree, hf_wimaxasncp_tlv_value_enum8,
+ tree, tlv_info->hf_value,
tvb, offset, length, value,
"Value: %s (%u)", s, value);
break;
}
- if (tlv_info->vals == NULL)
+ if (tlv_info->enums == NULL)
{
if (debug_enabled)
{
- g_print("fix-me: enum values missing for TLV %s (%d)\n",
+ g_print("fix-me: enum values missing for TLV %s (%u)\n",
tlv_info->name, tlv_info->type);
}
}
if (tree)
{
guint16 value;
+ const gchar *s;
value = tvb_get_ntohs(tvb, offset);
s = wimaxasncp_get_enum_name(tlv_info, value);
proto_tree_add_uint_format(
- tree, hf_wimaxasncp_tlv_value_enum16,
+ tree, tlv_info->hf_value,
tvb, offset, length, value,
"Value: %s (%u)", s, value);
break;
}
- if (tlv_info->vals == NULL)
+ if (tlv_info->enums == NULL)
{
if (debug_enabled)
{
- g_print("fix-me: enum values missing for TLV %s (%d)\n",
+ g_print("fix-me: enum values missing for TLV %s (%u)\n",
tlv_info->name, tlv_info->type);
}
}
if (tree)
{
guint32 value;
+ const gchar *s;
value = tvb_get_ntohl(tvb, offset);
s = wimaxasncp_get_enum_name(tlv_info, value);
proto_tree_add_uint_format(
- tree, hf_wimaxasncp_tlv_value_enum32,
+ tree, tlv_info->hf_value,
tvb, offset, length, value,
"Value: %s (%u)", s, value);
if (tree)
{
- const guint8 *p;
-
- p = tvb_get_ptr(tvb, offset, length);
-
- proto_tree_add_ether(
- tree, hf_wimaxasncp_tlv_value_ether,
- tvb, offset, length, p);
-
- proto_item_append_text(
- tlv_item, " - %s (%s)",
- get_ether_name(p), ether_to_str(p));
+ wimaxasncp_proto_tree_add_ether_value(
+ tvb, tree, tlv_item, offset, length, tlv_info);
}
return;
if (tree)
{
const guint8 *p;
+ const gchar *s = tvb_get_ephemeral_string(tvb, offset, length);
p = tvb_get_ptr(tvb, offset, length);
- proto_tree_add_string(
- tree, hf_wimaxasncp_tlv_value_string,
- tvb, offset, length, p);
+ proto_tree_add_string_format(
+ tree, tlv_info->hf_value,
+ tvb, offset, length, p,
+ "Value: %s", s);
proto_item_append_text(
- tlv_item, " - %s", tvb_get_string(tvb, offset, length));
+ tlv_item, " - %s", s);
}
return;
return;
}
+ case WIMAXASNCP_TLV_BITFLAGS8:
+ {
+ if (length != 1)
+ {
+ /* encoding error */
+ break;
+ }
+
+ if (tlv_info->enums == NULL)
+ {
+ /* enum values missing */
+ }
+
+ if (tree)
+ {
+ proto_tree *flags_tree;
+ proto_item *item;
+ guint8 value;
+ guint i;
+
+ value = tvb_get_guint8(tvb, offset);
+
+ item = proto_tree_add_uint_format(
+ tree, tlv_info->hf_value,
+ tvb, offset, length, value,
+ "Value: %s",
+ decode_numeric_bitfield(value, 0xff, 8, "0x%02x"));
+
+ proto_item_append_text(tlv_item, " - 0x%02x", value);
+
+ if (value != 0)
+ {
+ flags_tree = proto_item_add_subtree(
+ item, ett_wimaxasncp_tlv_value_bitflags8);
+
+ for (i = 0; i < 8; ++i)
+ {
+ guint8 mask;
+ mask = 1 << (7 - i);
+
+ if (value & mask)
+ {
+ const gchar *s;
+
+ s = wimaxasncp_get_enum_name(tlv_info, value & mask);
+
+ proto_tree_add_uint_format(
+ flags_tree, hf_wimaxasncp_tlv_value_bitflags8,
+ tvb, offset, length, value,
+ "Bit #%u is set: %s", i, s);
+ }
+ }
+ }
+ }
+
+ return;
+ }
case WIMAXASNCP_TLV_BITFLAGS16:
{
if (length != 2)
break;
}
- if (tlv_info->vals == NULL)
+ if (tlv_info->enums == NULL)
{
/* enum values missing */
}
value = tvb_get_ntohs(tvb, offset);
item = proto_tree_add_uint_format(
- tree, hf_wimaxasncp_tlv_value_bitflags16,
+ tree, tlv_info->hf_value,
tvb, offset, length, value,
"Value: %s",
decode_numeric_bitfield(value, 0xffff, 16, "0x%04x"));
if (value & mask)
{
+ const gchar *s;
+
s = wimaxasncp_get_enum_name(tlv_info, value & mask);
proto_tree_add_uint_format(
break;
}
- if (tlv_info->vals == NULL)
+ if (tlv_info->enums == NULL)
{
/* enum values missing */
}
value = tvb_get_ntohl(tvb, offset);
item = proto_tree_add_uint_format(
- tree, hf_wimaxasncp_tlv_value_bitflags32,
+ tree, tlv_info->hf_value,
tvb, offset, length, value,
"Value: %s",
decode_numeric_bitfield(value, 0xffffffff, 32, "0x%08x"));
if (value & mask)
{
+ const gchar *s;
s = wimaxasncp_get_enum_name(tlv_info, value & mask);
proto_tree_add_uint_format(
{
if (tree)
{
- wimaxasncp_proto_treee_add_tlv_ipv4_value(
- tvb, tree, tlv_item, offset);
+ wimaxasncp_proto_tree_add_tlv_ipv4_value(
+ tvb, tree, tlv_item, offset, tlv_info);
}
return;
{
if (tree)
{
- const guint8 *p;
-
- p = tvb_get_ptr(tvb, offset, length);
-
- proto_tree_add_ether(
- tree, hf_wimaxasncp_tlv_value_ether,
- tvb, offset, length, p);
-
- proto_item_append_text(
- tlv_item, " - %s (%s)",
- get_ether_name(p), ether_to_str(p));
+ wimaxasncp_proto_tree_add_ether_value(
+ tvb, tree, tlv_item, offset, length, tlv_info);
}
return;
{
if (tree)
{
- wimaxasncp_proto_treee_add_tlv_ipv6_value(
- tvb, tree, tlv_item, offset);
+ wimaxasncp_proto_tree_add_tlv_ipv6_value(
+ tvb, tree, tlv_item, offset, tlv_info);
}
return;
{
if (tree)
{
- proto_tree_add_item(
- tree, hf_wimaxasncp_tlv_value_bytes,
- tvb, offset, length, FALSE);
+ const gchar *format1;
+ const gchar *format2;
+ const guint8 *p = tvb_get_ptr(tvb, offset, length);
+ const gchar *s =
+ bytestring_to_str(p, MIN(length, max_show_bytes), 0);
- if (length <= 48) /* arbitrary */
+ if (length <= max_show_bytes)
{
- proto_item_append_text(
- tlv_item, " - %s",
- bytestring_to_str(
- tvb_get_ptr(tvb, offset, length), length, 0));
+ format1 = "Value: %s";
+ format2 = " - %s";
}
else
{
- proto_item_append_text(
- tlv_item, " - %s...",
- bytestring_to_str(
- tvb_get_ptr(tvb, offset, length), length, 0));
+ format1 = "Value: %s...";
+ format2 = " - %s...";
}
+
+ proto_tree_add_bytes_format(
+ tree, tlv_info->hf_value,
+ tvb, offset, length, p,
+ format1, s);
+
+ proto_item_append_text(
+ tlv_item, format2, s);
}
return;
value = tvb_get_guint8(tvb, offset);
- proto_tree_add_uint(
- tree, hf_wimaxasncp_tlv_value_hex8,
- tvb, offset, length, value);
+ proto_tree_add_uint_format(
+ tree, tlv_info->hf_value,
+ tvb, offset, length, value,
+ "Value: 0x%02x", value);
proto_item_append_text(tlv_item, " - 0x%02x", value);
}
value = tvb_get_ntohs(tvb, offset);
- proto_tree_add_uint(
- tree, hf_wimaxasncp_tlv_value_hex16,
- tvb, offset, length, value);
+ proto_tree_add_uint_format(
+ tree, tlv_info->hf_value,
+ tvb, offset, length, value,
+ "Value: 0x%04x", value);
proto_item_append_text(tlv_item, " - 0x%04x", value);
}
value = tvb_get_ntohl(tvb, offset);
- proto_tree_add_uint(
- tree, hf_wimaxasncp_tlv_value_hex32,
- tvb, offset, length, value);
+ proto_tree_add_uint_format(
+ tree, tlv_info->hf_value,
+ tvb, offset, length, value,
+ "Value: 0x%08x", value);
proto_item_append_text(tlv_item, " - 0x%08x", value);
}
value = tvb_get_guint8(tvb, offset);
- proto_tree_add_uint(
- tree, hf_wimaxasncp_tlv_value_dec8,
- tvb, offset, length, value);
+ proto_tree_add_uint_format(
+ tree, tlv_info->hf_value,
+ tvb, offset, length, value,
+ "Value: %u", value);
proto_item_append_text(tlv_item, " - %u", value);
}
value = tvb_get_ntohs(tvb, offset);
- proto_tree_add_uint(
- tree, hf_wimaxasncp_tlv_value_dec16,
- tvb, offset, length, value);
+ proto_tree_add_uint_format(
+ tree, tlv_info->hf_value,
+ tvb, offset, length, value,
+ "Value: %u", value);
proto_item_append_text(tlv_item, " - %u", value);
}
value = tvb_get_ntohl(tvb, offset);
- proto_tree_add_uint(
- tree, hf_wimaxasncp_tlv_value_dec32,
- tvb, offset, length, value);
+ proto_tree_add_uint_format(
+ tree, tlv_info->hf_value,
+ tvb, offset, length, value,
+ "Value: %u", value);
proto_item_append_text(tlv_item, " - %u", value);
}
if (debug_enabled)
{
g_print(
- "fix-me: TBD: TLV %s (%d)\n", tlv_info->name, tlv_info->type);
+ "fix-me: TBD: TLV %s (%u)\n", tlv_info->name, tlv_info->type);
}
if (tree)
{
+ const gchar *format;
+ const guint8 *p = tvb_get_ptr(tvb, offset, length);
+ const gchar *s =
+ bytestring_to_str(p, MIN(length, max_show_bytes), 0);
+
+ if (length <= max_show_bytes)
+ {
+ format = "Value: %s %s";
+ }
+ else
+ {
+ format = "Value: %s %s...";
+ }
+
+ proto_tree_add_bytes_format(
+ tree, tlv_info->hf_value,
+ tvb, offset, length, p,
+ format, hex_note, s);
+
proto_item_append_text(tlv_item, " - TBD");
}
- break;
+ return;
}
case WIMAXASNCP_TLV_IP_ADDRESS:
{
{
if (tree)
{
- wimaxasncp_proto_treee_add_tlv_ipv4_value(
- tvb, tree, tlv_item, offset);
+ wimaxasncp_proto_tree_add_tlv_ipv4_value(
+ tvb, tree, tlv_item, offset, tlv_info);
}
return;
{
if (tree)
{
- wimaxasncp_proto_treee_add_tlv_ipv6_value(
- tvb, tree, tlv_item, offset);
+ wimaxasncp_proto_tree_add_tlv_ipv6_value(
+ tvb, tree, tlv_item, offset, tlv_info);
}
return;
if (tree)
{
- wimaxasncp_proto_treee_add_tlv_ipv4_value(
- tvb, tree, tlv_item, offset);
+ wimaxasncp_proto_tree_add_tlv_ipv4_value(
+ tvb, tree, tlv_item, offset, tlv_info);
}
return;
protocol_list_tree = proto_item_add_subtree(
item, ett_wimaxasncp_tlv_protocol_list);
+ /* hidden item for filtering */
+ item = proto_tree_add_item(
+ protocol_list_tree, tlv_info->hf_value,
+ tvb, offset, length, FALSE);
+
+ PROTO_ITEM_SET_HIDDEN(item);
+
while (offset < tvb_length(tvb))
{
guint16 protocol;
protocol_name = ipprotostr(protocol);
proto_tree_add_uint_format(
- protocol_list_tree, hf_wimaxasncp_tlv_value_protocol,
+ protocol_list_tree, tlv_info->hf_protocol,
tvb, offset, 2, protocol,
"Protocol: %s (%u)", protocol_name, protocol);
port_range_list_tree = proto_item_add_subtree(
item, ett_wimaxasncp_tlv_port_range_list);
+ /* hidden item for filtering */
+ item = proto_tree_add_item(
+ port_range_list_tree, tlv_info->hf_value,
+ tvb, offset, length, FALSE);
+
+ PROTO_ITEM_SET_HIDDEN(item);
+
while (offset < tvb_length(tvb))
{
guint16 portLow;
proto_tree_add_text(
port_range_list_tree, tvb, offset, 4,
- "Port Range: %d-%d", portLow, portHigh);
+ "Port Range: %u-%u", portLow, portHigh);
+
+ /* hidden items are for filtering */
+
+ item = proto_tree_add_item(
+ port_range_list_tree, tlv_info->hf_port_low,
+ tvb, offset, 2, FALSE);
+
+ PROTO_ITEM_SET_HIDDEN(item);
+
+ item = proto_tree_add_item(
+ port_range_list_tree, tlv_info->hf_port_high,
+ tvb, offset + 2, 2, FALSE);
+
+ PROTO_ITEM_SET_HIDDEN(item);
if (offset == 0)
{
proto_item_append_text(
- tlv_item, " - %d-%d", portLow, portHigh);
+ tlv_item, " - %u-%u", portLow, portHigh);
}
else if (offset < 4 * max_port_ranges_in_tlv_item)
{
proto_item_append_text(
- tlv_item, ", %d-%d", portLow, portHigh);
+ tlv_item, ", %u-%u", portLow, portHigh);
}
else if (offset == 4 * max_port_ranges_in_tlv_item)
{
ip_address_mask_list_tree = proto_item_add_subtree(
item, ett_wimaxasncp_tlv_ip_address_mask_list);
+ /* hidden item for filtering */
+ item = proto_tree_add_item(
+ ip_address_mask_list_tree, tlv_info->hf_value,
+ tvb, offset, length, FALSE);
+
+ PROTO_ITEM_SET_HIDDEN(item);
+
if (length % 32 == 0)
{
/* ------------------------------------------------------------
proto_tree_add_item(
ip_address_mask_tree,
- hf_wimaxasncp_tlv_value_ipv6_address,
+ tlv_info->hf_ipv6,
tvb, offset, 16, FALSE);
/* too long to display ?
proto_tree_add_ipv6_format_value(
ip_address_mask_tree,
- hf_wimaxasncp_tlv_value_ipv6_mask,
+ tlv_info->hf_ipv6_mask,
tvb, offset, 16, (const guint8*)&ip,
"%s", s);
proto_tree_add_item(
ip_address_mask_tree,
- hf_wimaxasncp_tlv_value_ipv4_address,
+ tlv_info->hf_ipv4,
tvb, offset, 4, FALSE);
proto_item_append_text(
proto_tree_add_ipv4_format_value(
ip_address_mask_tree,
- hf_wimaxasncp_tlv_value_ipv4_mask,
+ tlv_info->hf_ipv4_mask,
tvb, offset, 4, ip,
"%s", s);
return;
}
+ case WIMAXASNCP_TLV_EAP:
+ {
+ /*
+ * EAP payload, call eap dissector to dissect eap payload
+ */
+ guint8 eap_code;
+ guint8 eap_type = 0;
+
+ /* Get code */
+ eap_code = tvb_get_guint8(tvb, offset);
+ if (eap_code == EAP_REQUEST || eap_code == EAP_RESPONSE)
+ {
+ /* Get type */
+ eap_type = tvb_get_guint8(tvb, offset + 4);
+ }
+
+ /* Add code and type to info column */
+ col_append_str(pinfo->cinfo, COL_INFO, " [");
+ col_append_str(pinfo->cinfo, COL_INFO,
+ val_to_str(eap_code, eap_code_vals, "Unknown code (0x%02X)"));
+
+ if (eap_code == EAP_REQUEST || eap_code == EAP_RESPONSE)
+ {
+ col_append_str(pinfo->cinfo, COL_INFO, ", ");
+ col_append_str(pinfo->cinfo, COL_INFO,
+ val_to_str(eap_type, eap_type_vals, "Unknown type (0x%02X)"));
+ }
+
+ col_append_str(pinfo->cinfo, COL_INFO, "]");
+
+
+ {
+ proto_tree *eap_tree;
+ proto_item *item;
+ gboolean save_writable;
+ tvbuff_t *eap_tvb;
+
+ /* Create EAP subtree */
+ item = proto_tree_add_item(tree, tlv_info->hf_value, tvb,
+ offset, length, FALSE);
+ proto_item_set_text(item, "Value");
+ eap_tree = proto_item_add_subtree(item, ett_wimaxasncp_tlv_eap);
+
+ /* Also show high-level details in this root item */
+ proto_item_append_text(item, " (%s",
+ val_to_str(eap_code, eap_code_vals,
+ "Unknown code (0x%02X)"));
+ if (eap_code == EAP_REQUEST || eap_code == EAP_RESPONSE)
+ {
+ proto_item_append_text(item, ", %s",
+ val_to_str(eap_type, eap_type_vals,
+ "Unknown type (0x%02X)"));
+ }
+ proto_item_append_text(item, ")");
+
+
+ /* Extract remaining bytes into new tvb */
+ eap_tvb = tvb_new_subset(tvb, offset, length,
+ tvb_length_remaining(tvb, offset));
+
+ /* Disable writing to info column while calling eap dissector */
+ save_writable = col_get_writable(pinfo->cinfo);
+ col_set_writable(pinfo->cinfo, FALSE);
+
+ /* Call the EAP dissector. */
+ call_dissector(eap_handle, eap_tvb, pinfo, eap_tree);
+
+ /* Restore previous writable state of info column */
+ col_set_writable(pinfo->cinfo, save_writable);
+ }
+
+ return;
+ }
+
case WIMAXASNCP_TLV_VENDOR_SPECIFIC:
{
/* --------------------------------------------------------------------
vsif_tree = proto_item_add_subtree(
item, ett_wimaxasncp_tlv_vendor_specific_information_field);
+ /* hidden item for filtering */
+ item = proto_tree_add_item(
+ vsif_tree, tlv_info->hf_value,
+ tvb, offset, length, FALSE);
+
+ PROTO_ITEM_SET_HIDDEN(item);
+
/* ----------------------------------------------------------------
* vendor ID (24-bit)
* ----------------------------------------------------------------
vendorId = tvb_get_ntoh24(tvb, offset);
- vendorName = val_to_str(vendorId, sminmpec_values, "Unknown");
+ vendorName = val_to_str_ext_const(vendorId, &sminmpec_values_ext, "Unknown");
proto_tree_add_uint_format(
- vsif_tree, hf_wimaxasncp_tlv_value_vendor_id,
+ vsif_tree, tlv_info->hf_vendor_id,
tvb, offset, 3, vendorId,
"Vendor ID: %s (%u)", vendorName, vendorId);
if (offset < tvb_length(tvb))
{
proto_tree_add_item(
- vsif_tree, hf_wimaxasncp_tlv_value_bytes,
+ vsif_tree, tlv_info->hf_vendor_rest_of_info,
tvb, offset, length - offset, FALSE);
}
}
return;
}
+ case WIMAXASNCP_TLV_UNKNOWN:
+ {
+ if (tree)
+ {
+ const gchar *format1;
+ const gchar *format2;
+ const guint8 *p = tvb_get_ptr(tvb, offset, length);
+ const gchar *s =
+ bytestring_to_str(p, MIN(length, max_show_bytes), 0);
+
+ if (length <= max_show_bytes)
+ {
+ format1 = "Value: %s %s";
+ format2 = " - %s %s";
+ }
+ else
+ {
+ format1 = "Value: %s %s...";
+ format2 = " - %s %s...";
+ }
+
+ proto_tree_add_bytes_format(
+ tree, tlv_info->hf_value,
+ tvb, offset, length, p,
+ format1, hex_note, s);
+
+ proto_item_append_text(
+ tlv_item, format2, hex_note, s);
+
+ }
+
+ return;
+ }
default:
if (debug_enabled)
{
g_print(
- "fix-me: unknown decode_type: %d\n", tlv_info->decode_type);
+ "fix-me: unknown decoder: %d\n", tlv_info->decoder);
}
break;
}
- /* default is hex dump*/
+ /* default is hex dump */
if (tree)
{
- proto_tree_add_item(
+ const gchar *format;
+ const guint8 *p = tvb_get_ptr(tvb, offset, length);
+ const gchar *s = bytestring_to_str(p, MIN(length, max_show_bytes), 0);
+
+ if (length <= max_show_bytes)
+ {
+ format = "Value: %s %s";
+ }
+ else
+ {
+ format = "Value: %s %s...";
+ }
+
+ proto_tree_add_bytes_format(
tree, hf_wimaxasncp_tlv_value_bytes,
- tvb, offset, length, FALSE);
+ tvb, offset, length, p,
+ format, hex_note, s);
}
}
{
proto_tree *tlv_tree = NULL;
proto_item *tlv_item = NULL;
- const wimaxasncp_tlv_info_t *tlv_info;
+ const wimaxasncp_dict_tlv_t *tlv_info;
guint16 type;
guint16 length;
tlv_info = wimaxasncp_get_tlv_info(type);
length = tvb_get_ntohs(tvb, offset + 2);
+ /* Commented out padding; As there is no mention of padding in
+ the Latest specification
pad = 4 - (length % 4);
if (pad == 4)
{
pad = 0;
}
-
+ */
+ pad = 0;
if (tree)
{
proto_item *type_item;
(gint)(4 + length + pad), tvb_length_remaining(tvb, offset));
tlv_item = proto_tree_add_item(
- tree, hf_wimaxasncp_tlv,
- tvb, offset, tree_length, -1);
+ tree, tlv_info->hf_root,
+ tvb, offset, tree_length, FALSE);
/* Set label for tlv item */
proto_item_set_text(tlv_item, "TLV: %s", tlv_info->name);
- /* Show code number if unknkown */
- if (strcmp(tlv_info->name, "Unknown") == 0)
+ /* Show code number if unknown */
+ if (tlv_info->decoder == WIMAXASNCP_TLV_UNKNOWN)
{
- proto_item_append_text(tlv_item, "(%u)", type);
+ proto_item_append_text(tlv_item, " (%u)", type);
}
/* Indicate if a compound tlv */
- if (tlv_info->decode_type == WIMAXASNCP_TLV_COMPOUND)
+ if (tlv_info->decoder == WIMAXASNCP_TLV_COMPOUND)
{
- proto_item_append_text(tlv_item, "[Compound]");
+ proto_item_append_text(tlv_item, " [Compound]");
}
/* Create TLV subtree */
tvb, offset, 2, type,
"Type: %s (%u)", tlv_info->name, type);
- if (strcmp(tlv_info->name, "Unknown") == 0)
+ if (tlv_info->decoder == WIMAXASNCP_TLV_UNKNOWN)
{
expert_add_info_format(pinfo, type_item,
PI_UNDECODED, PI_WARN,
* --------------------------------------------------------------------
*/
- if (tlv_info->decode_type == WIMAXASNCP_TLV_COMPOUND)
+ if (tlv_info->decoder == WIMAXASNCP_TLV_COMPOUND)
{
if (length == 0)
{
guint16 ui16;
guint32 ui32;
const guint8 *p;
+ guint8 *pmsid = NULL;
+ guint16 tid = 0;
+ gboolean dbit_show;
+
/* ------------------------------------------------------------------------
* MSID
proto_tree_add_ether(
tree, hf_wimaxasncp_msid,
tvb, offset, 6, p);
-
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_fstr(
- pinfo->cinfo, COL_INFO, " - MSID:%s", ether_to_str(p));
- }
}
+ pmsid = ether_to_str(p);
offset += 6;
* ------------------------------------------------------------------------
*/
+ dbit_show = FALSE;
ui16 = tvb_get_ntohs(tvb, offset);
- if (tree)
+ if (show_transaction_id_d_bit)
{
- if (show_transaction_id_d_bit)
- {
- const guint16 mask = 0x7fff;
+ const guint16 mask = 0x7fff;
- if (ui16 & 0x8000)
- {
- proto_tree_add_uint_format(
- tree, hf_wimaxasncp_transaction_id,
- tvb, offset, 2, ui16,
- "Transaction ID: D + 0x%04x (0x%04x)", mask & ui16, ui16);
-
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_fstr(
- pinfo->cinfo, COL_INFO, ", TID:D+0x%04x", mask & ui16);
- }
- }
- else
- {
- proto_tree_add_uint_format(
- tree, hf_wimaxasncp_transaction_id,
- tvb, offset, 2, ui16,
- "Transaction ID: 0x%04x", ui16);
+ if (ui16 & 0x8000)
+ {
+ proto_tree_add_uint_format(
+ tree, hf_wimaxasncp_transaction_id,
+ tvb, offset, 2, ui16,
+ "Transaction ID: D + 0x%04x (0x%04x)", mask & ui16, ui16);
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_fstr(
- pinfo->cinfo, COL_INFO, ", TID:0x%04x", ui16);
- }
- }
+ tid = ui16 & mask;
+ dbit_show = TRUE;
}
else
{
- proto_tree_add_uint(
+ proto_tree_add_uint_format(
tree, hf_wimaxasncp_transaction_id,
- tvb, offset, 2, ui16);
+ tvb, offset, 2, ui16,
+ "Transaction ID: 0x%04x", ui16);
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_append_fstr(
- pinfo->cinfo, COL_INFO, ", TID:0x%04x", ui16);
- }
+ tid = ui16;
}
}
+ else
+ {
+ proto_tree_add_uint(
+ tree, hf_wimaxasncp_transaction_id,
+ tvb, offset, 2, ui16);
+
+ tid = ui16;
+ }
offset += 2;
offset += dissect_wimaxasncp_tlvs(tlv_tvb, pinfo, tree);
}
+ col_append_fstr(pinfo->cinfo, COL_INFO, " - MSID:%s", pmsid);
+ if (dbit_show)
+ {
+ col_append_fstr(pinfo->cinfo, COL_INFO, ", TID:D+0x%04x", tid);
+ }
+ else
+ {
+ col_append_fstr(pinfo->cinfo, COL_INFO, ", TID:0x%04x", tid);
+ }
+
return offset;
}
/* ========================================================================= */
+
+static const gchar*
+match_ver_value_string(
+ const guint32 val,
+ const ver_value_string* const strings,
+ const guint32 max_ver)
+{
+ const ver_value_string* vvs;
+ const ver_value_string* res = NULL;
+
+ /* loop on the levels, from max to 0 */
+ for(vvs=strings; vvs->vs.strptr; vvs++)
+ {
+ if((vvs->vs.value == val) && (vvs->since <= max_ver))
+ {
+ if(!res || vvs->since > res->since)
+ {
+ res = vvs;
+ }
+ }
+ }
+
+ return res? res->vs.strptr : NULL;
+}
+
+static void register_wimaxasncp_fields(const char*);
+
+
static int
dissect_wimaxasncp(
tvbuff_t *tvb,
packet_info *pinfo,
proto_tree *tree)
{
+ const gchar *unknown = "Unknown";
+
/* Set up structures needed to add the protocol subtree and manage it */
proto_item *packet_item = NULL;
proto_item *item = NULL;
guint8 ui8;
guint8 function_type;
+ const gchar *function_type_name;
+ proto_item *function_type_item;
guint16 length;
+ const gchar *message_name;
+ const wimaxasncp_func_msg_t *p = NULL;
+ gsize i;
+
/* ------------------------------------------------------------------------
* First, we do some heuristics to check if the packet cannot be our
* protocol.
*/
/* Make entries in Protocol column and Info column on summary display */
- if (check_col(pinfo->cinfo, COL_PROTOCOL))
- {
- col_set_str(pinfo->cinfo, COL_PROTOCOL, "WiMAX");
- }
+ col_set_str(pinfo->cinfo, COL_PROTOCOL, "WiMAX");
/* We'll fill in the "Info" column after fetch data, so we clear the
column first in case calls to fetch data from the packet throw an
exception. */
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_clear(pinfo->cinfo, COL_INFO);
- }
+ col_clear(pinfo->cinfo, COL_INFO);
/* ========================================================================
* Disesction starts here
offset = 0;
+ /* Register protocol fields, etc if haven't done yet. */
+ if (wimaxasncp_dict == NULL)
+ {
+ register_wimaxasncp_fields(NULL);
+ }
+
if (tree)
{
packet_item = proto_tree_add_item(
/* ------------------------------------------------------------------------
* version
* ------------------------------------------------------------------------
- */
-
- ui8 = tvb_get_guint8(tvb, offset);
+ */
if (tree)
{
- proto_tree_add_uint(
+ proto_tree_add_item(
wimaxasncp_tree, hf_wimaxasncp_version,
- tvb, offset, 1, ui8);
+ tvb, offset, 1, FALSE);
}
offset += 1;
if (tree)
{
proto_tree *flags_tree;
- guint i;
if (ui8 == 0)
{
}
else
{
+ guint j;
item = proto_tree_add_uint_format(
wimaxasncp_tree, hf_wimaxasncp_flags,
tvb, offset, 1, ui8,
flags_tree = proto_item_add_subtree(
item, ett_wimaxasncp_flags);
- for (i = 0; i < 8; ++i)
+ for (j = 0; j < 8; ++j)
{
guint8 mask;
- mask = 1 << (7 - i);
+ mask = 1 << (7 - j);
+ /* Only add flags that are set */
if (ui8 & mask)
{
proto_tree_add_uint_format(
flags_tree, hf_wimaxasncp_flags,
tvb, offset, 1, ui8,
"Bit #%u is set: %s",
- i,
+ j,
val_to_str(
ui8 & mask, wimaxasncp_flag_vals, "Unknown"));
}
function_type = tvb_get_guint8(tvb, offset);
- if (tree)
+ function_type_name = match_ver_value_string(function_type,
+ wimaxasncp_function_type_vals,
+ global_wimaxasncp_nwg_ver);
+
+ if( function_type_name )
{
- proto_tree_add_uint(
+ /* add the item to the tree */
+ function_type_item = proto_tree_add_uint_format(
+ wimaxasncp_tree, hf_wimaxasncp_function_type,
+ tvb, offset, 1, function_type,
+ "%s (%u)", function_type_name, function_type);
+ }
+ else
+ {
+ /* if not matched, add the item and append expert item */
+ function_type_item = proto_tree_add_uint_format(
wimaxasncp_tree, hf_wimaxasncp_function_type,
- tvb, offset, 1, function_type);
+ tvb, offset, 1, function_type,
+ "Unknown (%u)", function_type);
+
+ expert_add_info_format(pinfo, function_type_item,
+ PI_UNDECODED, PI_WARN,
+ "Unknown function type (%u)",
+ function_type);
}
offset += 1;
ui8 = tvb_get_guint8(tvb, offset);
- if (tree)
- {
- const gchar *unknown = "Unknown";
- const gchar *message_name;
- const wimaxasncp_func_msg_t *p = NULL;
- gsize i;
- /* --------------------------------------------------------------------
- * OP ID
- * --------------------------------------------------------------------
- */
+ /* --------------------------------------------------------------------
+ * OP ID
+ * --------------------------------------------------------------------
+ */
- item = proto_tree_add_uint_format(
- wimaxasncp_tree, hf_wimaxasncp_op_id,
- tvb, offset, 1, ui8,
- "OP ID: %s", val_to_str(ui8 >> 5, wimaxasncp_op_id_vals, unknown));
+ item = proto_tree_add_uint_format(
+ wimaxasncp_tree, hf_wimaxasncp_op_id,
+ tvb, offset, 1, ui8,
+ "OP ID: %s", val_to_str(ui8 >> 5, wimaxasncp_op_id_vals, unknown));
- proto_item_append_text(
- item, " (%s)", decode_numeric_bitfield(ui8, 0xe0, 8, "%u"));
+ proto_item_append_text(
+ item, " (%s)", decode_numeric_bitfield(ui8, 0xe0, 8, "%u"));
- /* use the function type to find the message vals */
- for (i = 0; i < array_length(wimaxasncp_func_to_msg_vals_map); ++i)
- {
- p = &wimaxasncp_func_to_msg_vals_map[i];
+ /* use the function type to find the message vals */
+ for (i = 0; i < array_length(wimaxasncp_func_to_msg_vals_map); ++i)
+ {
+ p = &wimaxasncp_func_to_msg_vals_map[i];
- if (function_type == p->function_type)
- {
- break;
- }
+ if (function_type == p->function_type)
+ {
+ break;
}
+ }
- /* --------------------------------------------------------------------
- * message type
- * --------------------------------------------------------------------
- */
+ /* --------------------------------------------------------------------
+ * message type
+ * --------------------------------------------------------------------
+ */
- message_name = p ? val_to_str(0x1f & ui8, p->vals, unknown) : unknown;
+ message_name = p ? match_ver_value_string(0x1f & ui8, p->vals, global_wimaxasncp_nwg_ver) : unknown;
+ if(message_name == NULL)
+ {
+ message_name = unknown;
+ }
- item = proto_tree_add_uint_format(
- wimaxasncp_tree, hf_wimaxasncp_op_id,
- tvb, offset, 1, ui8,
- "Message Type: %s", message_name);
+ item = proto_tree_add_uint_format(
+ wimaxasncp_tree, hf_wimaxasncp_op_id,
+ tvb, offset, 1, ui8,
+ "Message Type: %s", message_name);
- proto_item_append_text(
- item, " (%s)", decode_numeric_bitfield(ui8, 0x1f, 8, "%u"));
+ proto_item_append_text(
+ item, " (%s)", decode_numeric_bitfield(ui8, 0x1f, 8, "%u"));
- if (check_col(pinfo->cinfo, COL_INFO))
- {
- col_add_str(pinfo->cinfo, COL_INFO, message_name);
- }
+ /* Add expert item if not matched */
+ if (strcmp(message_name, unknown) == 0)
+ {
+ expert_add_info_format(pinfo, item,
+ PI_UNDECODED, PI_WARN,
+ "Unknown message op (%u)",
+ 0x1f & ui8);
}
+ col_add_str(pinfo->cinfo, COL_INFO, message_name);
+
offset += 1;
/* ------------------------------------------------------------------------
}
/* ========================================================================= */
-/* Register the protocol with Wireshark */
+/* Modify the given string to make a suitable display filter */
+static char *alnumerize(
+ char *name)
+{
+ char *r = name; /* read pointer */
+ char *w = name; /* write pointer */
+ char c;
-/* this format is require because a script is used to build the C function
- that calls all the protocol registration.
-*/
+ for ( ; (c = *r); ++r)
+ {
+ if (isalnum((unsigned char)c) || c == '_' || c == '.')
+ {
+ /* These characters are fine - copy them */
+ *(w++) = c;
+ }
+ else if (c == ' ' || c == '-' || c == '/')
+ {
+ /* Skip these others if haven't written any characters out yet */
+ if (w == name)
+ {
+ continue;
+ }
-void
-proto_register_wimaxasncp(void)
+ /* Skip if we would produce multiple adjacent '_'s */
+ if (*(w - 1) == '_')
+ {
+ continue;
+ }
+
+ /* OK, replace with underscore */
+ *(w++) = '_';
+ }
+
+ /* Other undesirable characters are just skipped */
+ }
+
+ /* Terminate and return modified string */
+ *w = '\0';
+ return name;
+}
+
+/* ========================================================================= */
+
+static void add_reg_info(
+ int *hf_ptr,
+ const char *name,
+ const char *abbrev,
+ enum ftenum type,
+ int display,
+ const char *blurb)
{
- module_t *wimaxasncp_module;
+ hf_register_info hf = {
+ hf_ptr, { name, abbrev, type, display, NULL, 0x0, blurb, HFILL } };
- /* --------------------------------------------------------------------
- * List of header fields
- * --------------------------------------------------------------------
- */
- static hf_register_info hf[] = {
+ g_array_append_val(wimaxasncp_build_dict.hf, hf);
+}
+
+/* ========================================================================= */
+
+static void add_tlv_reg_info(
+ wimaxasncp_dict_tlv_t *tlv)
+{
+ const char *name;
+ const char *abbrev;
+ const char *blurb;
+
+ /* ------------------------------------------------------------------------
+ * add root reg info
+ * ------------------------------------------------------------------------
+ */
+
+ name = g_strdup(tlv->name);
+ abbrev = alnumerize(g_strdup_printf("wimaxasncp.tlv.%s", tlv->name));
+
+ switch (tlv->decoder)
+ {
+ case WIMAXASNCP_TLV_UNKNOWN:
+ blurb = "type=Unknown";
+ break;
+ case WIMAXASNCP_TLV_TBD:
+ blurb = g_strdup_printf("type=%u, TBD", tlv->type);
+ break;
+ case WIMAXASNCP_TLV_COMPOUND:
+ blurb = g_strdup_printf("type=%u, Compound", tlv->type);
+ break;
+ case WIMAXASNCP_TLV_FLAG0:
+ blurb = g_strdup_printf("type=%u, Value = Null", tlv->type);
+ break;
+ default:
+ blurb = g_strdup_printf("type=%u", tlv->type);
+ break;
+ }
+
+ add_reg_info(
+ &tlv->hf_root, name, abbrev, FT_BYTES, BASE_NONE, blurb);
+
+ /* ------------------------------------------------------------------------
+ * add value(s) reg info
+ * ------------------------------------------------------------------------
+ */
+
+ name = g_strdup("Value");
+ abbrev = alnumerize(g_strdup_printf("wimaxasncp.tlv.%s.value", tlv->name));
+ blurb = g_strdup_printf("value for type=%u", tlv->type);
+
+ switch (tlv->decoder)
+ {
+ case WIMAXASNCP_TLV_UNKNOWN:
+ g_free((gpointer*)blurb);
+
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_BYTES, BASE_NONE,
+ "value for unknown type");
+ break;
+
+ case WIMAXASNCP_TLV_TBD:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_BYTES, BASE_NONE, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_COMPOUND:
+ case WIMAXASNCP_TLV_FLAG0:
+ g_free((gpointer*)name);
+ g_free((gpointer*)abbrev);
+ g_free((gpointer*)blurb);
+ break;
+
+ case WIMAXASNCP_TLV_BYTES:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_BYTES, BASE_NONE, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_ENUM8:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_UINT8, BASE_DEC, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_ENUM16:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_UINT16, BASE_DEC, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_ENUM32:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_UINT32, BASE_DEC, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_ETHER:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_ETHER, BASE_NONE, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_ASCII_STRING:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_STRING, BASE_NONE, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_BITFLAGS8:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_UINT8, BASE_HEX, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_BITFLAGS16:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_UINT16, BASE_HEX, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_BITFLAGS32:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_UINT32, BASE_HEX, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_ID:
+ g_free((gpointer*)name);
+ g_free((gpointer*)abbrev);
+
+ name = "IPv4 Address";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.ipv4_value", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_ipv4, name, abbrev, FT_IPv4, BASE_NONE, blurb);
+
+ name = "IPv6 Address";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.ipv6_value", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_ipv6, name, abbrev, FT_IPv6, BASE_NONE, blurb);
+
+ name = "BS ID";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.bsid_value", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_bsid, name, abbrev, FT_ETHER, BASE_NONE, blurb);
+
+ break;
+
+ case WIMAXASNCP_TLV_HEX8:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_UINT8, BASE_HEX, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_HEX16:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_UINT16, BASE_HEX, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_HEX32:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_UINT32, BASE_HEX, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_DEC8:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_UINT8, BASE_DEC, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_DEC16:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_UINT16, BASE_DEC, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_DEC32:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_UINT32, BASE_DEC, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_IP_ADDRESS:
+ g_free((gpointer*)name);
+ g_free((gpointer*)abbrev);
+
+ name = "IPv4 Address";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.ipv4_value", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_ipv4, name, abbrev, FT_IPv4, BASE_NONE, blurb);
+
+ name = "IPv6 Address";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.ipv6_value", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_ipv6, name, abbrev, FT_IPv6, BASE_NONE, blurb);
+
+ break;
+
+ case WIMAXASNCP_TLV_IPV4_ADDRESS:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_IPv4, BASE_NONE, blurb);
+ break;
+
+ case WIMAXASNCP_TLV_PROTOCOL_LIST:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_BYTES, BASE_NONE, blurb);
+
+ blurb = g_strdup_printf("value component for type=%u", tlv->type);
+
+ name = "Protocol";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.value.protocol", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_protocol, name, abbrev, FT_UINT16, BASE_DEC, blurb);
+
+ break;
+
+ case WIMAXASNCP_TLV_PORT_RANGE_LIST:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_BYTES, BASE_NONE, blurb);
+
+ blurb = g_strdup_printf("value component for type=%u", tlv->type);
+
+ name = "Port Low";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.value.port_low", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_port_low, name, abbrev, FT_UINT16, BASE_DEC, blurb);
+
+ name = "Port High";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.value.port_high", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_port_high, name, abbrev, FT_UINT16, BASE_DEC, blurb);
+
+ break;
+
+ case WIMAXASNCP_TLV_IP_ADDRESS_MASK_LIST:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_BYTES, BASE_NONE, blurb);
+
+ blurb = g_strdup_printf("value component for type=%u", tlv->type);
+
+ name = "IPv4 Address";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.value.ipv4", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_ipv4, name, abbrev, FT_IPv4, BASE_NONE, blurb);
+
+ name = "IPv4 Mask";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.value.ipv4_mask", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_ipv4_mask, name, abbrev, FT_IPv4, BASE_NONE, blurb);
+
+ name = "IPv6 Address";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.value.ipv6", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_ipv6, name, abbrev, FT_IPv6, BASE_NONE, blurb);
+
+ name = "IPv6 Mask";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.value.ipv6_mask", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_ipv6_mask, name, abbrev, FT_IPv6, BASE_NONE, blurb);
+
+ break;
+
+ case WIMAXASNCP_TLV_VENDOR_SPECIFIC:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_BYTES, BASE_NONE, blurb);
+
+ blurb = g_strdup_printf("value component for type=%u", tlv->type);
+
+ name = "Vendor ID";
+
+ abbrev = alnumerize(
+ g_strdup_printf("wimaxasncp.tlv.%s.value.vendor_id", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_vendor_id, name, abbrev, FT_UINT24, BASE_DEC, blurb);
+
+ name = "Rest of Info";
+
+ abbrev = alnumerize(
+ g_strdup_printf(
+ "wimaxasncp.tlv.%s.value.vendor_rest_of_info", tlv->name));
+
+ add_reg_info(
+ &tlv->hf_vendor_rest_of_info, name, abbrev, FT_BYTES, BASE_NONE,
+ blurb);
+
+ break;
+
+ case WIMAXASNCP_TLV_EAP:
+ blurb = g_strdup_printf("EAP payload embedded in %s", name);
+
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_BYTES, BASE_NONE, blurb);
+ break;
+
+
+ default:
+ add_reg_info(
+ &tlv->hf_value, name, abbrev, FT_BYTES, BASE_NONE, blurb);
+
+ if (debug_enabled)
+ {
+ g_print(
+ "fix-me: unknown decoder: %d\n", tlv->decoder);
+ }
+
+ break;
+ }
+}
+
+/* ========================================================================= */
+/* Register the protocol fields and subtrees with Wireshark */
+static void
+register_wimaxasncp_fields(const char* unused _U_)
+{
+ gboolean debug_parser;
+ gboolean dump_dict;
+ gchar *dir;
+ gchar* dict_error;
+
+ /* ------------------------------------------------------------------------
+ * List of header fields
+ * ------------------------------------------------------------------------
+ */
+
+ static hf_register_info hf_base[] = {
{
&hf_wimaxasncp_version, /* ID */
{
BASE_DEC, /* FIELDBASE */
NULL, /* FIELDCONVERT */
0x0, /* BITMASK */
- "", /* FIELDDESCR */
+ NULL, /* FIELDDESCR */
HFILL /* HFILL */
}
},
BASE_HEX,
NULL,
0xff,
- "",
+ NULL,
HFILL
}
},
"wimaxasncp.function_type",
FT_UINT8,
BASE_DEC,
- VALS(wimaxasncp_function_type_vals),
+ NULL,
0x0,
- "",
+ NULL,
HFILL
}
},
BASE_HEX,
VALS(wimaxasncp_op_id_vals),
0xE0,
- "",
+ NULL,
HFILL
}
},
BASE_HEX,
NULL,
0x1F,
- "",
+ NULL,
HFILL
}
},
"wimaxasncp.qos_msg",
FT_UINT8,
BASE_HEX,
- VALS(wimaxasncp_qos_msg_vals),
+ NULL,
0x1F,
- "",
+ NULL,
HFILL
}
},
"wimaxasncp.ho_control_msg",
FT_UINT8,
BASE_HEX,
- VALS(wimaxasncp_ho_control_msg_vals),
+ NULL,
0x1F,
- "",
+ NULL,
HFILL
}
},
"wimaxasncp.data_path_control_msg",
FT_UINT8,
BASE_HEX,
- VALS(wimaxasncp_data_path_control_msg_vals),
+ NULL,
0x1F,
- "",
+ NULL,
HFILL
}
},
"wimaxasncp.context_delivery_msg",
FT_UINT8,
BASE_HEX,
- VALS(wimaxasncp_context_delivery_msg_vals),
+ NULL,
0x1F,
- "",
+ NULL,
HFILL
}
},
"wimaxasncp.r3_mobility_msg",
FT_UINT8,
BASE_HEX,
- VALS(wimaxasncp_r3_mobility_msg_vals),
+ NULL,
0x1F,
- "",
+ NULL,
HFILL
}
},
"wimaxasncp.paging_msg",
FT_UINT8,
BASE_HEX,
- VALS(wimaxasncp_paging_msg_vals),
+ NULL,
0x1F,
- "",
+ NULL,
HFILL
}
},
"wimaxasncp.rrm_msg",
FT_UINT8,
BASE_HEX,
- VALS(wimaxasncp_rrm_msg_vals),
+ NULL,
0x1F,
- "",
+ NULL,
HFILL
}
},
"wimaxasncp.authentication_msg",
FT_UINT8,
BASE_HEX,
- VALS(wimaxasncp_authentication_msg_vals),
+ NULL,
0x1F,
- "",
+ NULL,
HFILL
}
},
"wimaxasncp.ms_state_msg",
FT_UINT8,
BASE_HEX,
- VALS(wimaxasncp_ms_state_msg_vals),
+ NULL,
0x1F,
- "",
+ NULL,
HFILL
}
},
"wimaxasncp.reauthentication_msg",
FT_UINT8,
BASE_HEX,
- VALS(wimaxasncp_reauthentication_msg_vals),
+ NULL,
0x1F,
- "",
+ NULL,
HFILL
}
},
"wimaxasncp.session_msg",
FT_UINT8,
BASE_HEX,
- VALS(wimaxasncp_session_msg_vals),
+ NULL,
0x1F,
- "",
+ NULL,
HFILL
}
},
BASE_DEC,
NULL,
0x0,
- "",
+ NULL,
HFILL
}
},
BASE_NONE,
NULL,
0x0,
- "",
+ NULL,
HFILL
}
},
BASE_HEX,
NULL,
0x0,
- "",
+ NULL,
HFILL
}
},
BASE_HEX,
NULL,
0x0,
- "",
+ NULL,
HFILL
}
},
BASE_HEX,
NULL,
0x0,
- "",
+ NULL,
HFILL
}
},
"TLV",
"wimaxasncp.tlv",
FT_BYTES,
- BASE_HEX,
+ BASE_NONE,
NULL,
0x0,
- "",
+ NULL,
HFILL
}
},
&hf_wimaxasncp_tlv_type,
{
"Type",
- "wimaxasncp.tlv_type",
+ "wimaxasncp.tlv.type",
FT_UINT16,
BASE_DEC,
NULL,
0x0,
- "",
+ NULL,
HFILL
}
},
&hf_wimaxasncp_tlv_length,
{
"Length",
- "wimaxasncp.tlv_length",
+ "wimaxasncp.tlv.length",
FT_UINT16,
BASE_DEC,
NULL,
0x0,
- "",
+ NULL,
HFILL
}
},
"Value",
"wimaxasncp.tlv_value_bytes",
FT_BYTES,
- BASE_HEX,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_enum8,
- {
- "Value",
- "wimaxasncp.tlv_value_enum8",
- FT_UINT8,
- BASE_DEC,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_enum16,
- {
- "Value",
- "wimaxasncp.tlv_value_enum16",
- FT_UINT16,
- BASE_DEC,
+ BASE_NONE,
NULL,
0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_enum32,
- {
- "Value",
- "wimaxasncp.tlv_value_enum32",
- FT_UINT32,
- BASE_DEC,
NULL,
- 0x0,
- "",
HFILL
}
},
{
- &hf_wimaxasncp_tlv_value_ether,
+ &hf_wimaxasncp_tlv_value_bitflags8,
{
"Value",
- "wimaxasncp.tlv_value_ether",
- FT_ETHER,
- BASE_NONE,
+ "wimaxasncp.tlv_value_bitflags8",
+ FT_UINT8,
+ BASE_HEX,
NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_string,
- {
- "Value",
- "wimaxasncp.tlv_value_string",
- FT_STRING,
- BASE_NONE,
+ 0xff,
NULL,
- 0x0,
- "",
HFILL
}
},
BASE_HEX,
NULL,
0xffff,
- "",
+ NULL,
HFILL
}
},
BASE_HEX,
NULL,
0xffffffff,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_ipv4,
- {
- "Value",
- "wimaxasncp.tlv_value_ipv4",
- FT_IPv4,
- BASE_NONE,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_ipv4_address,
- {
- "IPv4 Address",
- "wimaxasncp.tlv_value_ipv4_address",
- FT_IPv4,
- BASE_NONE,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_ipv4_mask,
- {
- "IPv4 Mask",
- "wimaxasncp.tlv_value_ipv4_mask",
- FT_IPv4,
- BASE_NONE,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_ipv6,
- {
- "Value",
- "wimaxasncp.tlv_value_ipv6",
- FT_IPv6,
- BASE_NONE,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_ipv6_address,
- {
- "IPv6 Address",
- "wimaxasncp.tlv_value_ipv6_address",
- FT_IPv6,
- BASE_NONE,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_ipv6_mask,
- {
- "IPv6 Mask",
- "wimaxasncp.tlv_value_ipv6_mask",
- FT_IPv6,
- BASE_NONE,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_hex8,
- {
- "Value",
- "wimaxasncp.tlv_value_hex8",
- FT_UINT8,
- BASE_HEX,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_hex16,
- {
- "Value",
- "wimaxasncp.tlv_value_hex16",
- FT_UINT16,
- BASE_HEX,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_hex32,
- {
- "Value",
- "wimaxasncp.tlv_value_hex32",
- FT_UINT32,
- BASE_HEX,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_dec8,
- {
- "Value",
- "wimaxasncp.tlv_value_dec8",
- FT_UINT8,
- BASE_DEC,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_dec16,
- {
- "Value",
- "wimaxasncp.tlv_value_dec16",
- FT_UINT16,
- BASE_DEC,
- NULL,
- 0x0,
- "",
- HFILL
- }
- },
- {
- &hf_wimaxasncp_tlv_value_dec32,
- {
- "Value",
- "wimaxasncp.tlv_value_dec32",
- FT_UINT32,
- BASE_DEC,
NULL,
- 0x0,
- "",
HFILL
}
},
BASE_DEC,
NULL,
0x0,
- "",
+ NULL,
HFILL
}
},
BASE_DEC,
NULL,
0x0,
- "",
+ NULL,
HFILL
}
}
};
- /* Protocol subtree array */
- static gint *ett[] = {
+ /* ------------------------------------------------------------------------
+ * Protocol subtree array
+ * ------------------------------------------------------------------------
+ */
+
+ static gint *ett_base[] = {
&ett_wimaxasncp,
&ett_wimaxasncp_flags,
&ett_wimaxasncp_tlv,
+ &ett_wimaxasncp_tlv_value_bitflags8,
&ett_wimaxasncp_tlv_value_bitflags16,
&ett_wimaxasncp_tlv_value_bitflags32,
&ett_wimaxasncp_tlv_protocol_list,
&ett_wimaxasncp_tlv_port_range_list,
&ett_wimaxasncp_tlv_ip_address_mask_list,
&ett_wimaxasncp_tlv_ip_address_mask,
+ &ett_wimaxasncp_tlv_eap,
&ett_wimaxasncp_tlv_vendor_specific_information_field
};
+ /* ------------------------------------------------------------------------
+ * load the XML dictionary
+ * ------------------------------------------------------------------------
+ */
+
+ debug_parser = getenv("WIRESHARK_DEBUG_WIMAXASNCP_DICT_PARSER") != NULL;
+ dump_dict = getenv("WIRESHARK_DUMP_WIMAXASNCP_DICT") != NULL;
+
+ dir = ep_strdup_printf(
+ "%s" G_DIR_SEPARATOR_S "wimaxasncp",
+ get_datafile_dir());
+
+ wimaxasncp_dict =
+ wimaxasncp_dict_scan(dir, "dictionary.xml", debug_parser, &dict_error);
+
+ if (dict_error)
+ {
+ report_failure("wimaxasncp - %s", dict_error);
+ g_free(dict_error);
+ }
+
+ if (wimaxasncp_dict && dump_dict)
+ {
+ wimaxasncp_dict_print(stdout, wimaxasncp_dict);
+ }
+
+ /* ------------------------------------------------------------------------
+ * build the hf and ett dictionary entries
+ * ------------------------------------------------------------------------
+ */
+
+ wimaxasncp_build_dict.hf =
+ g_array_new(FALSE, TRUE, sizeof(hf_register_info));
+
+ g_array_append_vals(
+ wimaxasncp_build_dict.hf, hf_base, array_length(hf_base));
+
+ wimaxasncp_build_dict.ett =
+ g_array_new(FALSE, TRUE, sizeof(gint*));
+
+ g_array_append_vals(
+ wimaxasncp_build_dict.ett, ett_base, array_length(ett_base));
+
+ if (wimaxasncp_dict)
+ {
+ wimaxasncp_dict_tlv_t *tlv;
+
+ /* For each TLV found in XML file */
+ for (tlv = wimaxasncp_dict->tlvs; tlv; tlv = tlv->next)
+ {
+ if (tlv->enums)
+ {
+ /* Create array for enums */
+ wimaxasncp_dict_enum_t *e;
+ GArray* array = g_array_new(TRUE, TRUE, sizeof(value_string));
+
+ /* Copy each entry into value_string array */
+ for (e = tlv->enums; e; e = e->next)
+ {
+ value_string item = { e->code, e->name };
+ g_array_append_val(array, item);
+ }
+
+ /* Set enums to use with this TLV */
+ tlv->enum_vs = (value_string*)array->data;
+ }
+
+ add_tlv_reg_info(tlv);
+ }
+ }
+
+ /* add an entry for unknown TLVs */
+ add_tlv_reg_info(&wimaxasncp_tlv_not_found);
+
+ /* The following debug will only be printed if the debug_enabled variable
+ * is set programmatically. Setting the value via preferences will not
+ * work as it will be set too late to affect this code path.
+ */
+ if (debug_enabled)
+ {
+ if (wimaxasncp_dict)
+ {
+ wimaxasncp_dict_tlv_t *tlv;
+
+ for (tlv = wimaxasncp_dict->tlvs; tlv; tlv = tlv->next)
+ {
+ printf(
+ "%s\n"
+ " type = %d\n"
+ " description = %s\n"
+ " decoder = %s\n"
+ " hf_root = %d\n"
+ " hf_value = %d\n"
+ " hf_ipv4 = %d\n"
+ " hf_ipv6 = %d\n"
+ " hf_bsid = %d\n"
+ " hf_protocol = %d\n"
+ " hf_port_low = %d\n"
+ " hf_port_high = %d\n"
+ " hf_ipv4_mask = %d\n"
+ " hf_ipv6_mask = %d\n"
+ " hf_vendor_id = %d\n"
+ " hf_vendor_rest_of_info = %d\n",
+ tlv->name,
+ tlv->type,
+ tlv->description,
+ val_to_str(
+ tlv->decoder, wimaxasncp_decode_type_vals, "Unknown"),
+ tlv->hf_root,
+ tlv->hf_value,
+ tlv->hf_ipv4,
+ tlv->hf_ipv6,
+ tlv->hf_bsid,
+ tlv->hf_protocol,
+ tlv->hf_port_low,
+ tlv->hf_port_high,
+ tlv->hf_ipv4_mask,
+ tlv->hf_ipv6_mask,
+ tlv->hf_vendor_id,
+ tlv->hf_vendor_rest_of_info);
+ }
+ }
+ }
+
+ /* Required function calls to register the header fields and subtrees
+ * used */
+ proto_register_field_array(
+ proto_wimaxasncp,
+ (hf_register_info*)wimaxasncp_build_dict.hf->data,
+ wimaxasncp_build_dict.hf->len);
+
+ proto_register_subtree_array(
+ (gint**)wimaxasncp_build_dict.ett->data,
+ wimaxasncp_build_dict.ett->len);
+}
+
+
+
+
+/* ========================================================================= */
+/* Register the protocol with Wireshark */
+
+/* this format is require because a script is used to build the C function
+ that calls all the protocol registration.
+*/
+
+void
+proto_register_wimaxasncp(void)
+{
+ module_t *wimaxasncp_module;
+
+ /* ------------------------------------------------------------------------
+ * complete registration
+ * ------------------------------------------------------------------------
+ */
+
/* Register the protocol name and description */
proto_wimaxasncp = proto_register_protocol(
"WiMAX ASN Control Plane Protocol",
"WiMAX ASN CP",
"wimaxasncp");
- /* Required function calls to register the header fields and subtrees
- * used */
- proto_register_field_array(proto_wimaxasncp, hf, array_length(hf));
- proto_register_subtree_array(ett, array_length(ett));
/* Register this dissector by name */
new_register_dissector("wimaxasncp", dissect_wimaxasncp, proto_wimaxasncp);
"Enable debug output",
"Print debug output to the console.",
&debug_enabled);
+
+ prefs_register_uint_preference(
+ wimaxasncp_module,
+ "udp.wimax_port",
+ "UDP Port for WiMAX ASN Control Plane Protocol",
+ "Set UDP port for WiMAX ASN Control Plane Protocol",
+ 10, &global_wimaxasncp_udp_port);
+
+ prefs_register_enum_preference(
+ wimaxasncp_module,
+ "nwg_version",
+ "NWG Version",
+ "Version of the NWG that the R6 protocol complies with",
+ &global_wimaxasncp_nwg_ver,
+ wimaxasncp_nwg_versions,
+ FALSE);
+
+ proto_register_prefix("wimaxasncp", register_wimaxasncp_fields);
}
/* ========================================================================= */
proto_reg_handoff_wimaxasncp(void)
{
static gboolean inited = FALSE;
+ static dissector_handle_t wimaxasncp_handle;
+ static int currentPort = -1;
- if ( ! inited)
+ if (!inited)
{
- dissector_handle_t wimaxasncp_handle;
/* Use new_create_dissector_handle() to indicate that
* dissect_wimaxasncp() returns the number of bytes it dissected (or
dissect_wimaxasncp,
proto_wimaxasncp);
- dissector_add("udp.port", 2231, wimaxasncp_handle);
- inited = TRUE;
+ inited = TRUE;
+ }
+
+ if (currentPort != -1)
+ {
+ /* Remove any previous registered port */
+ dissector_delete("udp.port", currentPort, wimaxasncp_handle);
}
+
+ /* Add the new one from preferences */
+ currentPort = global_wimaxasncp_udp_port;
+ dissector_add("udp.port", currentPort, wimaxasncp_handle);
+
+ /* Find the EAP dissector */
+ eap_handle = find_dissector("eap");
}
+
git.samba.org / obnox / wireshark / wip.git / blobdiff