epan/dissectors/packet-radius_packetcable.c

   1 /*
   2  * packet-radius_packetcable.c
   3  *
   4  * Routines for Packetcable's RADIUS AVPs dissection
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * SPDX-License-Identifier: GPL-2.0-or-later
  11  *
  12  */
  13
  14
  15 /*
  16  * Some of the development of the RADIUS protocol decoder was sponsored by
  17  * Cable Television Laboratories, Inc. ("CableLabs") based upon proprietary
  18  * CableLabs' specifications. Your license and use of this protocol decoder
  19  * does not mean that you are licensed to use the CableLabs'
  20  * specifications.  If you have questions about this protocol, contact
  21  * jf.mule [AT] cablelabs.com or c.stuart [AT] cablelabs.com for additional
  22  * information.
  23  */
  24
  25 /*
  26   See:
  27        PacketCable(TM) 1.5 Specification: Event Messages [PKT-SP-EM1.5-I03-070412]
  28        PacketCable(TM) Specification: Multimedia Specification [PKT-SP-MM-I04-080522]
  29 */
  30
  31 #include "config.h"
  32
  33 #include <epan/packet.h>
  34 #include <epan/sminmpec.h>
  35
  36 #include "packet-radius.h"
  37
  38 void proto_register_packetcable(void);
  39 void proto_reg_handoff_packetcable(void);
  40
  41 static int proto_packetcable;
  42
  43 static int hf_packetcable_em_header_version_id;
  44 static int hf_packetcable_bcid_timestamp;
  45 static int hf_packetcable_bcid_event_counter;
  46 static int hf_packetcable_em_header_event_message_type;
  47 static int hf_packetcable_em_header_element_type;
  48 static int hf_packetcable_em_header_sequence_number;
  49 static int hf_packetcable_em_header_status;
  50 static int hf_packetcable_em_header_status_error_indicator;
  51 static int hf_packetcable_em_header_status_event_origin;
  52 static int hf_packetcable_em_header_status_event_message_proxied;
  53 static int hf_packetcable_em_header_priority;
  54 static int hf_packetcable_em_header_attribute_count;
  55 static int hf_packetcable_em_header_event_object;
  56 static int hf_packetcable_call_termination_cause_source_document;
  57 static int hf_packetcable_call_termination_cause_code;
  58 static int hf_packetcable_trunk_group_id_trunk_type;
  59 static int hf_packetcable_trunk_group_id_trunk_number;
  60 static int hf_packetcable_qos_status;
  61 static int hf_packetcable_qos_status_indication;
  62 static int hf_packetcable_time_adjustment;
  63 static int hf_packetcable_redirected_from_info_number_of_redirections;
  64 static int hf_packetcable_electronic_surveillance_indication_df_cdc_address;
  65 static int hf_packetcable_electronic_surveillance_indication_df_ccc_address;
  66 static int hf_packetcable_electronic_surveillance_indication_cdc_port;
  67 static int hf_packetcable_electronic_surveillance_indication_ccc_port;
  68 static int hf_packetcable_terminal_display_info_terminal_display_status_bitmask;
  69 static int hf_packetcable_terminal_display_info_sbm_general_display;
  70 static int hf_packetcable_terminal_display_info_sbm_calling_number;
  71 static int hf_packetcable_terminal_display_info_sbm_calling_name;
  72 static int hf_packetcable_terminal_display_info_sbm_message_waiting;
  73 static int hf_packetcable_terminal_display_info_general_display;
  74 static int hf_packetcable_terminal_display_info_calling_number;
  75 static int hf_packetcable_terminal_display_info_calling_name;
  76 static int hf_packetcable_terminal_display_info_message_waiting;
  77 static int hf_packetcable_qos_desc_flags_sfst;
  78 static int hf_packetcable_qos_desc_flags_gi;
  79 static int hf_packetcable_qos_desc_flags_tgj;
  80 static int hf_packetcable_qos_desc_flags_gpi;
  81 static int hf_packetcable_qos_desc_flags_ugs;
  82 static int hf_packetcable_qos_desc_flags_tp;
  83 static int hf_packetcable_qos_desc_flags_msr;
  84 static int hf_packetcable_qos_desc_flags_mtb;
  85 static int hf_packetcable_qos_desc_flags_mrtr;
  86 static int hf_packetcable_qos_desc_flags_mps;
  87 static int hf_packetcable_qos_desc_flags_mcb;
  88 static int hf_packetcable_qos_desc_flags_srtp;
  89 static int hf_packetcable_qos_desc_flags_npi;
  90 static int hf_packetcable_qos_desc_flags_tpj;
  91 static int hf_packetcable_qos_desc_flags_toso;
  92 static int hf_packetcable_qos_desc_flags_mdl;
  93
  94 /* Generated from convert_proto_tree_add_text.pl */
  95 static int hf_packetcable_bcid_time_zone_offset;
  96 static int hf_packetcable_bcid_element_id;
  97 static int hf_packetcable_electronic_surveillance_indication_df_df_key;
  98 static int hf_packetcable_redirected_from_original_called_party;
  99 static int hf_packetcable_em_header_element_id;
 100 static int hf_packetcable_redirected_from_last_redirecting_party;
 101 static int hf_packetcable_bcid_time_zone_dst;
 102 static int hf_packetcable_em_header_time_zone_offset;
 103 static int hf_packetcable_qos_service_class_name;
 104 static int hf_packetcable_em_header_event_time;
 105 static int hf_packetcable_em_header_time_zone_dst;
 106
 107 /* This is slightly ugly.  */
 108 static int hf_packetcable_qos_desc_fields[16];
 109
 110 static int ett_radius_vendor_packetcable_bcid;
 111 static int ett_radius_vendor_packetcable_status;
 112 static int ett_radius_vendor_packetcable_qos_status;
 113 static int ett_packetcable_term_dsply;
 114
 115
 116 #define PACKETCABLE_QOS_STATE_INDICATION_MASK 0X0003
 117 #define PACKETCABLE_SERVICE_FLOW_SCHEDULING_TYPE_MASK  (1 << 2)
 118 #define PACKETCABLE_NOMINAL_GRANT_INTERVAL_MASK        (1 << 3)
 119 #define PACKETCABLE_TOLERATED_GRANT_JITTER_MASK        (1 << 4)
 120 #define PACKETCABLE_GRANTS_PER_INTERVAL_MASK   (1 << 5)
 121 #define PACKETCABLE_UNSOLICITED_GRANT_SIZE_MASK        (1 << 6)
 122 #define PACKETCABLE_TRAFFIC_PRIORITY_MASK      (1 << 7)
 123 #define PACKETCABLE_MAXIMUM_SUSTAINED_RATE_MASK        (1 << 8)
 124 #define PACKETCABLE_MAXIMUM_TRAFFIC_BURST_MASK (1 << 9)
 125 #define PACKETCABLE_MINIMUM_RESERVED_TRAFFIC_RATE_MASK (1 << 10)
 126 #define PACKETCABLE_MINIMUM_PACKET_SIZE_MASK   (1 << 11)
 127 #define PACKETCABLE_MAXIMUM_CONCATENATED_BURST_MASK    (1 << 12)
 128 #define PACKETCABLE_REQUEST_TRANSMISSION_POLICY_MASK   (1 << 13)
 129 #define PACKETCABLE_NOMINAL_POLLING_INTERVAL_MASK      (1 << 14)
 130 #define PACKETCABLE_TOLERATED_POLL_JITTER_MASK (1 << 15)
 131 #define PACKETCABLE_IP_TYPE_OF_SERVICE_OVERRIDE_MASK   (1 << 16)
 132 #define PACKETCABLE_MAXIMUM_DOWNSTREAM_LATENCY_MASK    (1 << 17)
 133
 134 #define PACKETCABLE_QOS_DESC_BITFIELDS 16
 135
 136 #define PACKETCABLE_EMHS_EI_MASK 0X0003
 137 #define PACKETCABLE_EMHS_EO_MASK 0X0004
 138 #define PACKETCABLE_EMHS_EMP_MASK 0X0008
 139 #define PACKETCABLE_EMHS_RESERVED_MASK 0Xfff0
 140
 141
 142 static uint32_t packetcable_qos_desc_mask[] =
 143 {
 144         PACKETCABLE_SERVICE_FLOW_SCHEDULING_TYPE_MASK,
 145         PACKETCABLE_NOMINAL_GRANT_INTERVAL_MASK,
 146         PACKETCABLE_TOLERATED_GRANT_JITTER_MASK,
 147         PACKETCABLE_GRANTS_PER_INTERVAL_MASK,
 148         PACKETCABLE_UNSOLICITED_GRANT_SIZE_MASK,
 149         PACKETCABLE_TRAFFIC_PRIORITY_MASK,
 150         PACKETCABLE_MAXIMUM_SUSTAINED_RATE_MASK,
 151         PACKETCABLE_MAXIMUM_TRAFFIC_BURST_MASK,
 152         PACKETCABLE_MINIMUM_RESERVED_TRAFFIC_RATE_MASK,
 153         PACKETCABLE_MINIMUM_PACKET_SIZE_MASK,
 154         PACKETCABLE_MAXIMUM_CONCATENATED_BURST_MASK,
 155         PACKETCABLE_REQUEST_TRANSMISSION_POLICY_MASK,
 156         PACKETCABLE_NOMINAL_POLLING_INTERVAL_MASK,
 157         PACKETCABLE_TOLERATED_POLL_JITTER_MASK,
 158         PACKETCABLE_IP_TYPE_OF_SERVICE_OVERRIDE_MASK,
 159         PACKETCABLE_MAXIMUM_DOWNSTREAM_LATENCY_MASK
 160 };
 161
 162 static const value_string radius_vendor_packetcable_event_message_vals[] =
 163 {
 164         {0,  "Reserved"},
 165         {1,  "Signaling_Start"},
 166         {2,  "Signaling_Stop"},
 167         {3,  "Database_Query"},
 168         {4,  "Intelligent_Peripheral_Usage_Start"},
 169         {5,  "Intelligent_Peripheral_Usage_Stop"},
 170         {6,  "Service_Instance"},
 171         {7,  "QoS_Reserve"},
 172         {8,  "QoS_Release"},
 173         {9,  "Service_Activation"},
 174         {10, "Service_Deactivation"},
 175         {11,  "Media_Report"},
 176         {12,  "Signal_Instance"},
 177         {13, "Interconnect_(Signaling)_Start"},
 178         {14, "Interconnect_(Signaling)_Stop"},
 179         {15, "Call_Answer"},
 180         {16, "Call_Disconnect"},
 181         {17, "Time_Change"},
 182         {19, "QoS_Commit"},
 183         {20, "Media_Alive"},
 184         {31,  "Policy_Request"},
 185         {32,  "Policy_Delete"},
 186         {33,  "Policy_Update"},
 187         {0, NULL}
 188 };
 189
 190 static const value_string packetcable_em_header_element_type_vals[] =
 191 {
 192         {0,  "Reserved"},
 193         {1,  "CMS"},
 194         {2,  "CMTS"},
 195         {3,  "Media Gateway Controller"},
 196         {4,  "Policy Server"},
 197         {0, NULL}
 198 };
 199
 200 static const value_string packetcable_em_header_status_error_indicator_vals[] =
 201 {
 202         {0,  "No Error"},
 203         {1,  "Possible Error"},
 204         {2,  "Known Error"},
 205         {3,  "Reserved"},
 206         {0, NULL}
 207 };
 208
 209 static const value_string packetcable_em_header_status_event_origin_vals[] =
 210 {
 211         {0,  "Trusted Element"},
 212         {1,  "Untrusted Element"},
 213         {0, NULL}
 214 };
 215
 216 static const value_string packetcable_em_header_status_event_message_proxied_vals[] =
 217 {
 218         {0,  "Not proxied"},
 219         {1,  "Proxied"},
 220         {0, NULL}
 221 };
 222
 223 static const value_string packetcable_call_termination_cause_vals[] =
 224 {
 225         {0,  "Reserved"},
 226         {1,  "BAF"},
 227         {2,  "Reserved"},
 228         {0, NULL}
 229 };
 230
 231 static const value_string packetcable_trunk_type_vals[] =
 232 {
 233         {1,  "Not Used"},
 234         {2,  "Not Used"},
 235         {3,  "SS7 direct trunk group member"},
 236         {4,  "SS7 from IC to AT and SS7 from AT to EO"},
 237         {5,  "Not Used"},
 238         {6,  "SS7 from IC to AT and non-SS7 from AT to EO (terminating only)"},
 239         {9,  "Signaling type not specified"},
 240         {0, NULL}
 241 };
 242
 243 static const value_string packetcable_state_indication_vals[] =
 244 {
 245         {0,  "Illegal Value"},
 246         {1,  "Resource Reserved but not Activated"},
 247         {2,  "Resource Activated"},
 248         {3,  "Resource Reserved & Activated"},
 249         { 0, NULL }
 250 };
 251
 252
 253 /* Decode a PacketCable BCID. */
 254 /* XXX - This should probably be combined with the equivalent COPS code */
 255 static void decode_packetcable_bcid (tvbuff_t *tvb, proto_tree *tree, int offset)
 256 {
 257
 258         proto_tree_add_item(tree, hf_packetcable_bcid_timestamp, tvb, offset, 4, ENC_BIG_ENDIAN);
 259         proto_tree_add_item(tree, hf_packetcable_bcid_element_id, tvb, offset + 4, 8, ENC_ASCII);
 260         proto_tree_add_item(tree, hf_packetcable_bcid_time_zone_dst, tvb, offset + 12, 1, ENC_BIG_ENDIAN);
 261         proto_tree_add_item(tree, hf_packetcable_bcid_time_zone_offset, tvb, offset + 13, 7, ENC_ASCII);
 262         proto_tree_add_item(tree, hf_packetcable_bcid_event_counter, tvb, offset + 20, 4, ENC_BIG_ENDIAN);
 263 }
 264
 265 static const char* dissect_packetcable_em_hdr(proto_tree* tree, tvbuff_t* tvb, packet_info *pinfo _U_) {
 266         proto_item *ti;
 267         proto_tree *obj_tree;
 268
 269         proto_tree_add_item(tree, hf_packetcable_em_header_version_id, tvb,  0, 2, ENC_BIG_ENDIAN);
 270         obj_tree = proto_tree_add_subtree(tree, tvb, 2, 24, ett_radius_vendor_packetcable_bcid, NULL, "BCID");
 271         decode_packetcable_bcid(tvb, obj_tree,  2);
 272
 273         proto_tree_add_item(tree, hf_packetcable_em_header_event_message_type, tvb,  26, 2, ENC_BIG_ENDIAN);
 274         proto_tree_add_item(tree, hf_packetcable_em_header_element_type, tvb,  28, 2, ENC_BIG_ENDIAN);
 275         proto_tree_add_item(tree, hf_packetcable_em_header_element_id, tvb, 30, 8, ENC_ASCII);
 276         proto_tree_add_item(tree, hf_packetcable_em_header_time_zone_dst, tvb, 38, 1, ENC_BIG_ENDIAN);
 277         proto_tree_add_item(tree, hf_packetcable_em_header_time_zone_offset, tvb, 39, 7, ENC_ASCII);
 278         proto_tree_add_item(tree, hf_packetcable_em_header_sequence_number, tvb,  46, 4, ENC_BIG_ENDIAN);
 279         proto_tree_add_item(tree, hf_packetcable_em_header_event_time, tvb, 50, 18, ENC_ASCII);
 280
 281         ti = proto_tree_add_item(tree, hf_packetcable_em_header_status, tvb,  68, 4, ENC_BIG_ENDIAN);
 282         obj_tree = proto_item_add_subtree(ti, ett_radius_vendor_packetcable_status);
 283         proto_tree_add_item(obj_tree, hf_packetcable_em_header_status_error_indicator, tvb,  68, 4, ENC_BIG_ENDIAN);
 284         proto_tree_add_item(obj_tree, hf_packetcable_em_header_status_event_origin, tvb,  68, 4, ENC_BIG_ENDIAN);
 285         proto_tree_add_item(obj_tree, hf_packetcable_em_header_status_event_message_proxied, tvb,  68, 4, ENC_BIG_ENDIAN);
 286
 287         proto_tree_add_item(tree, hf_packetcable_em_header_priority, tvb,  72, 1, ENC_BIG_ENDIAN);
 288         proto_tree_add_item(tree, hf_packetcable_em_header_attribute_count, tvb,  73, 2, ENC_BIG_ENDIAN);
 289         proto_tree_add_item(tree, hf_packetcable_em_header_event_object, tvb,  75, 1, ENC_BIG_ENDIAN);
 290         return "";
 291 }
 292
 293 static const char* dissect_packetcable_call_term_cause(proto_tree* tree, tvbuff_t* tvb, packet_info *pinfo _U_) {
 294         proto_tree_add_item(tree, hf_packetcable_call_termination_cause_source_document,
 295                                                 tvb, 0, 2, ENC_BIG_ENDIAN);
 296         proto_tree_add_item(tree, hf_packetcable_call_termination_cause_code,
 297                                                 tvb, 2, 4, ENC_BIG_ENDIAN);
 298
 299         return "";
 300 }
 301
 302 static const char* dissect_packetcable_rel_call_billing_correlation(proto_tree* tree, tvbuff_t* tvb, packet_info *pinfo _U_) {
 303         decode_packetcable_bcid(tvb, tree, 0);
 304         return "";
 305 }
 306
 307 static const char* dissect_packetcable_trunk_group_id(proto_tree* tree, tvbuff_t* tvb, packet_info *pinfo _U_) {
 308         proto_tree_add_item(tree, hf_packetcable_trunk_group_id_trunk_type,
 309                                                 tvb, 0, 2, ENC_BIG_ENDIAN);
 310         proto_tree_add_item(tree, hf_packetcable_trunk_group_id_trunk_number,
 311                                                 tvb, 2, 4, ENC_BIG_ENDIAN);
 312         return "";
 313 }
 314
 315 static const char* dissect_packetcable_qos_descriptor(proto_tree* tree, tvbuff_t* tvb, packet_info *pinfo _U_) {
 316         uint32_t intval;
 317         uint32_t packetcable_qos_flags = tvb_get_ntohl(tvb, 0);
 318         unsigned packetcable_qos_off = 20;
 319         static int * const qos_flags[] = {
 320                 &hf_packetcable_qos_status_indication,
 321                 &hf_packetcable_qos_desc_flags_sfst,
 322                 &hf_packetcable_qos_desc_flags_gi,
 323                 &hf_packetcable_qos_desc_flags_tgj,
 324                 &hf_packetcable_qos_desc_flags_gpi,
 325                 &hf_packetcable_qos_desc_flags_ugs,
 326                 &hf_packetcable_qos_desc_flags_tp,
 327                 &hf_packetcable_qos_desc_flags_msr,
 328                 &hf_packetcable_qos_desc_flags_mtb,
 329                 &hf_packetcable_qos_desc_flags_mrtr,
 330                 &hf_packetcable_qos_desc_flags_mps,
 331                 &hf_packetcable_qos_desc_flags_mcb,
 332                 &hf_packetcable_qos_desc_flags_srtp,
 333                 &hf_packetcable_qos_desc_flags_npi,
 334                 &hf_packetcable_qos_desc_flags_tpj,
 335                 &hf_packetcable_qos_desc_flags_toso,
 336                 &hf_packetcable_qos_desc_flags_mdl,
 337                 NULL
 338         };
 339
 340         proto_tree_add_bitmask(tree, tvb, 0, hf_packetcable_qos_status,
 341                                ett_radius_vendor_packetcable_qos_status, qos_flags, ENC_BIG_ENDIAN);
 342
 343         proto_tree_add_item(tree, hf_packetcable_qos_service_class_name, tvb, 4, 16, ENC_ASCII);
 344
 345         for (intval = 0; intval < PACKETCABLE_QOS_DESC_BITFIELDS; intval++) {
 346                 if (packetcable_qos_flags & packetcable_qos_desc_mask[intval]) {
 347                         proto_tree_add_item(tree, hf_packetcable_qos_desc_fields[intval],
 348                                                                 tvb, packetcable_qos_off, 4, ENC_BIG_ENDIAN);
 349                         packetcable_qos_off += 4;
 350                 }
 351         }
 352
 353         return "";
 354 }
 355
 356 static const char* dissect_packetcable_time_adjustment(proto_tree* tree, tvbuff_t* tvb, packet_info *pinfo _U_) {
 357         proto_tree_add_item(tree, hf_packetcable_time_adjustment, tvb, 0, 8, ENC_BIG_ENDIAN);
 358
 359         return "";
 360 }
 361
 362 static const char* dissect_packetcable_redirected_from_info(proto_tree* tree, tvbuff_t* tvb, packet_info *pinfo _U_) {
 363
 364         proto_tree_add_item(tree, hf_packetcable_redirected_from_last_redirecting_party, tvb, 0, 20, ENC_ASCII);
 365
 366         proto_tree_add_item(tree, hf_packetcable_redirected_from_original_called_party, tvb, 20, 20, ENC_ASCII);
 367
 368         proto_tree_add_item(tree, hf_packetcable_redirected_from_info_number_of_redirections,
 369                                                 tvb, 40, 2, ENC_BIG_ENDIAN);
 370
 371         return "";
 372 }
 373
 374 static const char* dissect_packetcable_time_electr_surv_ind(proto_tree* tree, tvbuff_t* tvb, packet_info *pinfo _U_) {
 375
 376         if (tvb_reported_length(tvb) == 0)
 377                 return "None";
 378
 379         proto_tree_add_item(tree, hf_packetcable_electronic_surveillance_indication_df_cdc_address,
 380                                                 tvb, 0, 4, ENC_BIG_ENDIAN);
 381         proto_tree_add_item(tree, hf_packetcable_electronic_surveillance_indication_df_ccc_address,
 382                                                 tvb, 4, 4, ENC_BIG_ENDIAN);
 383         proto_tree_add_item(tree, hf_packetcable_electronic_surveillance_indication_cdc_port,
 384                                                 tvb, 8, 2, ENC_BIG_ENDIAN);
 385         proto_tree_add_item(tree, hf_packetcable_electronic_surveillance_indication_ccc_port,
 386                                                 tvb, 10, 2, ENC_BIG_ENDIAN);
 387         proto_tree_add_item(tree, hf_packetcable_electronic_surveillance_indication_df_df_key, tvb, 12, -1, ENC_NA);
 388
 389         return "";
 390 }
 391
 392 static const char* dissect_packetcable_surv_df_sec(proto_tree* tree _U_, tvbuff_t* tvb _U_, packet_info *pinfo _U_) {
 393                 return "";
 394 }
 395
 396 #define PACKETCABLE_GENERAL_DISPLAY (1 << 0)
 397 #define PACKETCABLE_CALLING_NUMBER  (1 << 1)
 398 #define PACKETCABLE_CALLING_NAME    (1 << 2)
 399 #define PACKETCABLE_MESSAGE_WAITING (1 << 3)
 400
 401 static const char* dissect_packetcable_term_dsply_info(proto_tree* tree, tvbuff_t* tvb, packet_info *pinfo _U_) {
 402         /* XXX - this logic seems buggy because the offsets don't line up */
 403         uint8_t bitmask = tvb_get_uint8(tvb, 2);
 404         unsigned intval = 1;
 405         static int * const flags[] = {
 406                 &hf_packetcable_terminal_display_info_sbm_general_display,
 407                 &hf_packetcable_terminal_display_info_sbm_calling_number,
 408                 &hf_packetcable_terminal_display_info_sbm_calling_name,
 409                 &hf_packetcable_terminal_display_info_sbm_message_waiting,
 410                 NULL
 411         };
 412
 413         proto_item* ti = proto_tree_add_bitmask_with_flags(tree, tvb, 0, hf_packetcable_terminal_display_info_terminal_display_status_bitmask,
 414                                                                                 ett_packetcable_term_dsply, flags, ENC_NA, BMT_NO_APPEND|BMT_NO_FALSE);
 415
 416         proto_tree* obj_tree = proto_item_add_subtree(ti, ett_packetcable_term_dsply);
 417
 418         if (bitmask & PACKETCABLE_GENERAL_DISPLAY) {
 419                 proto_tree_add_item(obj_tree, hf_packetcable_terminal_display_info_general_display,
 420                                                         tvb, intval, 80, ENC_ASCII);
 421                 intval += 80;
 422         }
 423
 424         if (bitmask & PACKETCABLE_CALLING_NUMBER) {
 425                 proto_tree_add_item(obj_tree, hf_packetcable_terminal_display_info_calling_number,
 426                                                         tvb, intval, 40, ENC_ASCII);
 427                 intval += 40;
 428         }
 429
 430         if (bitmask & PACKETCABLE_CALLING_NAME) {
 431                 proto_tree_add_item(obj_tree, hf_packetcable_terminal_display_info_calling_name,
 432                                                         tvb, intval, 40, ENC_ASCII);
 433                 intval += 40;
 434         }
 435
 436         if (bitmask & PACKETCABLE_MESSAGE_WAITING) {
 437                 proto_tree_add_item(obj_tree, hf_packetcable_terminal_display_info_message_waiting,
 438                                                         tvb, intval, 40, ENC_ASCII);
 439         }
 440
 441         return "";
 442 }
 443
 444
 445 void proto_register_packetcable(void) {
 446
 447         static hf_register_info hf[] = {
 448                 { &hf_packetcable_em_header_version_id,
 449                 { "Event Message Version ID","packetcable_avps.emh.vid",
 450                         FT_UINT16, BASE_DEC, NULL, 0x0,
 451                         "PacketCable Event Message header version ID", HFILL }
 452                 },
 453                 { &hf_packetcable_bcid_timestamp,
 454                 { "Timestamp","packetcable_avps.bcid.ts",
 455                         FT_UINT32, BASE_DEC, NULL, 0x0,
 456                         "PacketCable Event Message BCID Timestamp", HFILL }
 457                 },
 458                 { &hf_packetcable_bcid_event_counter,
 459                 { "Event Counter","packetcable_avps.bcid.ec",
 460                         FT_UINT32, BASE_DEC, NULL, 0x0,
 461                         "PacketCable Event Message BCID Event Counter", HFILL }
 462                 },
 463                 { &hf_packetcable_em_header_event_message_type,
 464                 { "Event Message Type","packetcable_avps.emh.emt",
 465                         FT_UINT16, BASE_DEC, VALS(radius_vendor_packetcable_event_message_vals), 0x0,
 466                         "PacketCable Event Message Type", HFILL }
 467                 },
 468                 { &hf_packetcable_em_header_element_type,
 469                 { "Element Type","packetcable_avps.emh.et",
 470                         FT_UINT16, BASE_DEC, VALS(packetcable_em_header_element_type_vals), 0x0,
 471                         "PacketCable Event Message Element Type", HFILL }
 472                 },
 473                 { &hf_packetcable_em_header_sequence_number,
 474                 { "Sequence Number","packetcable_avps.emh.sn",
 475                         FT_UINT32, BASE_DEC, NULL, 0x0,
 476                         "PacketCable Event Message Sequence Number", HFILL }
 477                 },
 478                 { &hf_packetcable_em_header_status,
 479                 { "Status","packetcable_avps.emh.st",
 480                         FT_UINT32, BASE_HEX, NULL, 0x0,
 481                         "PacketCable Event Message Status", HFILL }
 482                 },
 483                 { &hf_packetcable_em_header_status_error_indicator,
 484                 { "Status","packetcable_avps.emh.st.ei",
 485                         FT_UINT32, BASE_HEX, VALS(packetcable_em_header_status_error_indicator_vals),
 486                         PACKETCABLE_EMHS_EI_MASK,
 487                         "PacketCable Event Message Status Error Indicator", HFILL }
 488                 },
 489                 { &hf_packetcable_em_header_status_event_origin,
 490                 { "Event Origin","packetcable_avps.emh.st.eo",
 491                         FT_UINT32, BASE_HEX, VALS(packetcable_em_header_status_event_origin_vals),
 492                         PACKETCABLE_EMHS_EO_MASK,
 493                         "PacketCable Event Message Status Event Origin", HFILL }
 494                 },
 495                 { &hf_packetcable_em_header_status_event_message_proxied,
 496                 { "Event Message Proxied","packetcable_avps.emh.st.emp",
 497                         FT_UINT32, BASE_HEX, VALS(packetcable_em_header_status_event_message_proxied_vals),
 498                         PACKETCABLE_EMHS_EMP_MASK,
 499                         "PacketCable Event Message Status Event Message Proxied", HFILL }
 500                 },
 501                 { &hf_packetcable_em_header_priority,
 502                 { "Priority","packetcable_avps.emh.priority",
 503                         FT_UINT8, BASE_DEC, NULL, 0x0,
 504                         "PacketCable Event Message Priority", HFILL }
 505                 },
 506                 { &hf_packetcable_em_header_attribute_count,
 507                 { "Attribute Count","packetcable_avps.emh.ac",
 508                         FT_UINT16, BASE_DEC, NULL, 0x0,
 509                         "PacketCable Event Message Attribute Count", HFILL }
 510                 },
 511                 { &hf_packetcable_em_header_event_object,
 512                 { "Event Object","packetcable_avps.emh.eo",
 513                         FT_UINT8, BASE_DEC, NULL, 0x0,
 514                         "PacketCable Event Message Event Object", HFILL }
 515                 },
 516                 { &hf_packetcable_call_termination_cause_source_document,
 517                 { "Source Document","packetcable_avps.ctc.sd",
 518                         FT_UINT16, BASE_HEX, VALS(packetcable_call_termination_cause_vals), 0x0,
 519                         "PacketCable Call Termination Cause Source Document", HFILL }
 520                 },
 521                 { &hf_packetcable_call_termination_cause_code,
 522                 { "Event Object","packetcable_avps.ctc.cc",
 523                         FT_UINT32, BASE_DEC, NULL, 0x0,
 524                         "PacketCable Call Termination Cause Code", HFILL }
 525                 },
 526                 { &hf_packetcable_trunk_group_id_trunk_type,
 527                 { "Trunk Type","packetcable_avps.tgid.tt",
 528                         FT_UINT16, BASE_HEX, VALS(packetcable_trunk_type_vals), 0x0,
 529                         "PacketCable Trunk Group ID Trunk Type", HFILL }
 530                 },
 531                 { &hf_packetcable_trunk_group_id_trunk_number,
 532                 { "Event Object","packetcable_avps.tgid.tn",
 533                         FT_UINT32, BASE_DEC, NULL, 0x0,
 534                         "PacketCable Trunk Group ID Trunk Number", HFILL }
 535                 },
 536                 { &hf_packetcable_qos_status,
 537                 { "QoS Status","packetcable_avps.qs",
 538                         FT_UINT32, BASE_HEX, NULL, 0x0,
 539                         "PacketCable QoS Descriptor Attribute QoS Status", HFILL }
 540                 },
 541                 { &hf_packetcable_qos_status_indication,
 542                 { "Status Indication","packetcable_avps.qs.si",
 543                         FT_UINT32, BASE_DEC, VALS(packetcable_state_indication_vals), PACKETCABLE_QOS_STATE_INDICATION_MASK,
 544                         "PacketCable QoS Descriptor Attribute QoS State Indication", HFILL }
 545                 },
 546                 { &hf_packetcable_qos_desc_flags_sfst,
 547                 { "Service Flow Scheduling Type","packetcable_avps.qs.flags.sfst",
 548                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_SERVICE_FLOW_SCHEDULING_TYPE_MASK,
 549                         "PacketCable QoS Descriptor Attribute Bitmask: Service Flow Scheduling Type", HFILL }
 550                 },
 551                 { &hf_packetcable_qos_desc_flags_gi,
 552                 { "Grant Interval","packetcable_avps.qs.flags.gi",
 553                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_NOMINAL_GRANT_INTERVAL_MASK,
 554                         "PacketCable QoS Descriptor Attribute Bitmask: Grant Interval", HFILL }
 555                 },
 556                 { &hf_packetcable_qos_desc_flags_tgj,
 557                 { "Tolerated Grant Jitter","packetcable_avps.qs.flags.tgj",
 558                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_TOLERATED_GRANT_JITTER_MASK,
 559                         "PacketCable QoS Descriptor Attribute Bitmask: Tolerated Grant Jitter", HFILL }
 560                 },
 561                 { &hf_packetcable_qos_desc_flags_gpi,
 562                 { "Grants Per Interval","packetcable_avps.qs.flags.gpi",
 563                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_GRANTS_PER_INTERVAL_MASK,
 564                         "PacketCable QoS Descriptor Attribute Bitmask: Grants Per Interval", HFILL }
 565                 },
 566                 { &hf_packetcable_qos_desc_flags_ugs,
 567                 { "Unsolicited Grant Size","packetcable_avps.qs.flags.ugs",
 568                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_UNSOLICITED_GRANT_SIZE_MASK,
 569                         "PacketCable QoS Descriptor Attribute Bitmask: Unsolicited Grant Size", HFILL }
 570                 },
 571                 { &hf_packetcable_qos_desc_flags_tp,
 572                 { "Traffic Priority","packetcable_avps.qs.flags.tp",
 573                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_TRAFFIC_PRIORITY_MASK,
 574                         "PacketCable QoS Descriptor Attribute Bitmask: Traffic Priority", HFILL }
 575                 },
 576                 { &hf_packetcable_qos_desc_flags_msr,
 577                 { "Maximum Sustained Rate","packetcable_avps.qs.flags.msr",
 578                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_MAXIMUM_SUSTAINED_RATE_MASK,
 579                         "PacketCable QoS Descriptor Attribute Bitmask: Maximum Sustained Rate", HFILL }
 580                 },
 581                 { &hf_packetcable_qos_desc_flags_mtb,
 582                 { "Maximum Traffic Burst","packetcable_avps.qs.flags.mtb",
 583                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_MAXIMUM_TRAFFIC_BURST_MASK,
 584                         "PacketCable QoS Descriptor Attribute Bitmask: Maximum Traffic Burst", HFILL }
 585                 },
 586                 { &hf_packetcable_qos_desc_flags_mrtr,
 587                 { "Minimum Reserved Traffic Rate","packetcable_avps.qs.flags.mrtr",
 588                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_MINIMUM_RESERVED_TRAFFIC_RATE_MASK,
 589                         "PacketCable QoS Descriptor Attribute Bitmask: Minimum Reserved Traffic Rate", HFILL }
 590                 },
 591                 { &hf_packetcable_qos_desc_flags_mps,
 592                 { "Minimum Packet Size","packetcable_avps.qs.flags.mps",
 593                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_MINIMUM_PACKET_SIZE_MASK,
 594                         "PacketCable QoS Descriptor Attribute Bitmask: Minimum Packet Size", HFILL }
 595                 },
 596                 { &hf_packetcable_qos_desc_flags_mcb,
 597                 { "Maximum Concatenated Burst","packetcable_avps.qs.flags.mcb",
 598                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_MAXIMUM_CONCATENATED_BURST_MASK,
 599                         "PacketCable QoS Descriptor Attribute Bitmask: Maximum Concatenated Burst", HFILL }
 600                 },
 601                 { &hf_packetcable_qos_desc_flags_srtp,
 602                 { "Status Request/Transmission Policy","packetcable_avps.qs.flags.srtp",
 603                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_REQUEST_TRANSMISSION_POLICY_MASK,
 604                         "PacketCable QoS Descriptor Attribute Bitmask: Status Request/Transmission Policy", HFILL }
 605                 },
 606                 { &hf_packetcable_qos_desc_flags_npi,
 607                 { "Nominal Polling Interval","packetcable_avps.qs.flags.npi",
 608                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_NOMINAL_POLLING_INTERVAL_MASK,
 609                         "PacketCable QoS Descriptor Attribute Bitmask: Nominal Polling Interval", HFILL }
 610                 },
 611                 { &hf_packetcable_qos_desc_flags_tpj,
 612                 { "Tolerated Poll Jitter","packetcable_avps.qs.flags.tpj",
 613                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_TOLERATED_POLL_JITTER_MASK,
 614                         "PacketCable QoS Descriptor Attribute Bitmask: Tolerated Poll Jitter", HFILL }
 615                 },
 616                 { &hf_packetcable_qos_desc_flags_toso,
 617                 { "Type of Service Override","packetcable_avps.qs.flags.toso",
 618                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_IP_TYPE_OF_SERVICE_OVERRIDE_MASK,
 619                         "PacketCable QoS Descriptor Attribute Bitmask: Type of Service Override", HFILL }
 620                 },
 621                 { &hf_packetcable_qos_desc_flags_mdl,
 622                 { "Maximum Downstream Latency","packetcable_avps.qs.flags.mdl",
 623                         FT_UINT32, BASE_DEC, NULL, PACKETCABLE_MAXIMUM_DOWNSTREAM_LATENCY_MASK,
 624                         "PacketCable QoS Descriptor Attribute Bitmask: Maximum Downstream Latency", HFILL }
 625                 },
 626                 { &hf_packetcable_qos_desc_fields[0],
 627                 { "Service Flow Scheduling Type","packetcable_avps.qs.sfst",
 628                         FT_UINT32, BASE_DEC, NULL, 0x0,
 629                         "PacketCable QoS Descriptor Attribute Service Flow Scheduling Type", HFILL }
 630                 },
 631                 { &hf_packetcable_qos_desc_fields[1],
 632                 { "Grant Interval","packetcable_avps.qs.gi",
 633                         FT_UINT32, BASE_DEC, NULL, 0x0,
 634                         "PacketCable QoS Descriptor Attribute Grant Interval", HFILL }
 635                 },
 636                 { &hf_packetcable_qos_desc_fields[2],
 637                 { "Tolerated Grant Jitter","packetcable_avps.qs.tgj",
 638                         FT_UINT32, BASE_DEC, NULL, 0x0,
 639                         "PacketCable QoS Descriptor Attribute Tolerated Grant Jitter", HFILL }
 640                 },
 641                 { &hf_packetcable_qos_desc_fields[3],
 642                 { "Grants Per Interval","packetcable_avps.qs.gpi",
 643                         FT_UINT32, BASE_DEC, NULL, 0x0,
 644                         "PacketCable QoS Descriptor Attribute Grants Per Interval", HFILL }
 645                 },
 646                 { &hf_packetcable_qos_desc_fields[4],
 647                 { "Unsolicited Grant Size","packetcable_avps.qs.ugs",
 648                         FT_UINT32, BASE_DEC, NULL, 0x0,
 649                         "PacketCable QoS Descriptor Attribute Unsolicited Grant Size", HFILL }
 650                 },
 651                 { &hf_packetcable_qos_desc_fields[5],
 652                 { "Traffic Priority","packetcable_avps.qs.tp",
 653                         FT_UINT32, BASE_DEC, NULL, 0x0,
 654                         "PacketCable QoS Descriptor Attribute Traffic Priority", HFILL }
 655                 },
 656                 { &hf_packetcable_qos_desc_fields[6],
 657                 { "Maximum Sustained Rate","packetcable_avps.qs.msr",
 658                         FT_UINT32, BASE_DEC, NULL, 0x0,
 659                         "PacketCable QoS Descriptor Attribute Maximum Sustained Rate", HFILL }
 660                 },
 661                 { &hf_packetcable_qos_desc_fields[7],
 662                 { "Maximum Traffic Burst","packetcable_avps.qs.mtb",
 663                         FT_UINT32, BASE_DEC, NULL, 0x0,
 664                         "PacketCable QoS Descriptor Attribute Maximum Traffic Burst", HFILL }
 665                 },
 666                 { &hf_packetcable_qos_desc_fields[8],
 667                 { "Minimum Reserved Traffic Rate","packetcable_avps.qs.mrtr",
 668                         FT_UINT32, BASE_DEC, NULL, 0x0,
 669                         "PacketCable QoS Descriptor Attribute Minimum Reserved Traffic Rate", HFILL }
 670                 },
 671                 { &hf_packetcable_qos_desc_fields[9],
 672                 { "Minimum Packet Size","packetcable_avps.qs.mps",
 673                         FT_UINT32, BASE_DEC, NULL, 0x0,
 674                         "PacketCable QoS Descriptor Attribute Minimum Packet Size", HFILL }
 675                 },
 676                 { &hf_packetcable_qos_desc_fields[10],
 677                 { "Maximum Concatenated Burst","packetcable_avps.qs.mcb",
 678                         FT_UINT32, BASE_DEC, NULL, 0x0,
 679                         "PacketCable QoS Descriptor Attribute Maximum Concatenated Burst", HFILL }
 680                 },
 681                 { &hf_packetcable_qos_desc_fields[11],
 682                 { "Status Request/Transmission Policy","packetcable_avps.qs.srtp",
 683                         FT_UINT32, BASE_DEC, NULL, 0x0,
 684                         "PacketCable QoS Descriptor Attribute Status Request/Transmission Policy", HFILL }
 685                 },
 686                 { &hf_packetcable_qos_desc_fields[12],
 687                 { "Nominal Polling Interval","packetcable_avps.qs.npi",
 688                         FT_UINT32, BASE_DEC, NULL, 0x0,
 689                         "PacketCable QoS Descriptor Attribute Nominal Polling Interval", HFILL }
 690                 },
 691                 { &hf_packetcable_qos_desc_fields[13],
 692                 { "Tolerated Poll Jitter","packetcable_avps.qs.tpj",
 693                         FT_UINT32, BASE_DEC, NULL, 0x0,
 694                         "PacketCable QoS Descriptor Attribute Tolerated Poll Jitter", HFILL }
 695                 },
 696                 { &hf_packetcable_qos_desc_fields[14],
 697                 { "Type of Service Override","packetcable_avps.qs.toso",
 698                         FT_UINT32, BASE_DEC, NULL, 0x0,
 699                         "PacketCable QoS Descriptor Attribute Type of Service Override", HFILL }
 700                 },
 701                 { &hf_packetcable_qos_desc_fields[15],
 702                 { "Maximum Downstream Latency","packetcable_avps.qs.mdl",
 703                         FT_UINT32, BASE_DEC, NULL, 0x0,
 704                         "PacketCable QoS Descriptor Attribute Maximum Downstream Latency", HFILL }
 705                 },
 706                 { &hf_packetcable_time_adjustment,
 707                 { "Time Adjustment","packetcable_avps.ti",
 708                         FT_UINT64, BASE_DEC, NULL, 0x0,
 709                         "PacketCable Time Adjustment", HFILL }
 710                 },
 711                 { &hf_packetcable_redirected_from_info_number_of_redirections,
 712                 { "Number-of-Redirections","packetcable_avps.rfi.nr",
 713                         FT_UINT16, BASE_DEC, NULL, 0x0,
 714                         "PacketCable Redirected-From-Info Number-of-Redirections", HFILL }
 715                 },
 716                 { &hf_packetcable_electronic_surveillance_indication_df_cdc_address,
 717                 { "DF_CDC_Address","packetcable_avps.esi.dfcdca",
 718                         FT_IPv4, BASE_NONE, NULL, 0x0,
 719                         "PacketCable Electronic-Surveillance-Indication DF_CDC_Address", HFILL }
 720                 },
 721                 { &hf_packetcable_electronic_surveillance_indication_df_ccc_address,
 722                 { "DF_CDC_Address","packetcable_avps.esi.dfccca",
 723                         FT_IPv4, BASE_NONE, NULL, 0x0,
 724                         "PacketCable Electronic-Surveillance-Indication DF_CCC_Address", HFILL }
 725                 },
 726                 { &hf_packetcable_electronic_surveillance_indication_cdc_port,
 727                 { "CDC-Port","packetcable_avps.esi.cdcp",
 728                         FT_UINT16, BASE_DEC, NULL, 0x0,
 729                         "PacketCable Electronic-Surveillance-Indication CDC-Port", HFILL }
 730                 },
 731                 { &hf_packetcable_electronic_surveillance_indication_ccc_port,
 732                 { "CCC-Port","packetcable_avps.esi.cccp",
 733                         FT_UINT16, BASE_DEC, NULL, 0x0,
 734                         "PacketCable Electronic-Surveillance-Indication CCC-Port", HFILL }
 735                 },
 736
 737                 { &hf_packetcable_terminal_display_info_terminal_display_status_bitmask,
 738                 { "Terminal_Display_Status_Bitmask","packetcable_avps.tdi.sbm",
 739                         FT_UINT8, BASE_HEX, NULL, 0xff,
 740                         "PacketCable Terminal_Display_Info Terminal_Display_Status_Bitmask", HFILL }
 741                 },
 742                 { &hf_packetcable_terminal_display_info_sbm_general_display,
 743                 { "General_Display","packetcable_avps.tdi.sbm.gd",
 744                         FT_BOOLEAN, 8, NULL, 0x01,
 745                         "PacketCable Terminal_Display_Info Terminal_Display_Status_Bitmask General_Display", HFILL }
 746                 },
 747                 { &hf_packetcable_terminal_display_info_sbm_calling_number,
 748                 { "Calling_Number","packetcable_avps.tdi.sbm.cnum",
 749                         FT_BOOLEAN, 8, NULL, 0x02,
 750                         "PacketCable Terminal_Display_Info Terminal_Display_Status_Bitmask Calling_Number", HFILL }
 751                 },
 752                 { &hf_packetcable_terminal_display_info_sbm_calling_name,
 753                 { "Calling_Name","packetcable_avps.tdi.sbm.cname",
 754                         FT_BOOLEAN, 8, NULL, 0x04,
 755                         "PacketCable Terminal_Display_Info Terminal_Display_Status_Bitmask Calling_Name", HFILL }
 756                 },
 757                 { &hf_packetcable_terminal_display_info_sbm_message_waiting,
 758                 { "Message_Waiting","packetcable_avps.tdi.sbm.mw",
 759                         FT_BOOLEAN, 8, NULL, 0x08,
 760                         "PacketCable Terminal_Display_Info Terminal_Display_Status_Bitmask Message_Waiting", HFILL }
 761                 },
 762                 { &hf_packetcable_terminal_display_info_general_display,
 763                 { "General_Display","packetcable_avps.tdi.gd",
 764                         FT_STRING, BASE_NONE, NULL, 0,
 765                         "PacketCable Terminal_Display_Info General_Display", HFILL }
 766                 },
 767                 { &hf_packetcable_terminal_display_info_calling_number,
 768                 { "Calling_Number","packetcable_avps.tdi.cnum",
 769                         FT_STRING, BASE_NONE, NULL, 0,
 770                         "PacketCable Terminal_Display_Info Calling_Number", HFILL }
 771                 },
 772                 { &hf_packetcable_terminal_display_info_calling_name,
 773                 { "Calling_Name","packetcable_avps.tdi.cname",
 774                         FT_STRING, BASE_NONE, NULL, 0,
 775                         "PacketCable Terminal_Display_Info Calling_Name", HFILL }
 776                 },
 777                 { &hf_packetcable_terminal_display_info_message_waiting,
 778                 { "Message_Waiting","packetcable_avps.tdi.mw",
 779                         FT_STRING, BASE_NONE, NULL, 0,
 780                         "PacketCable Terminal_Display_Info Message_Waiting", HFILL }
 781                 },
 782                 /* Generated from convert_proto_tree_add_text.pl */
 783                 { &hf_packetcable_bcid_element_id, { "Element ID", "packetcable_avps.bcid.element_id", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
 784                 { &hf_packetcable_bcid_time_zone_dst, { "Time Zone: DST", "packetcable_avps.bcid.time_zone.dst", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
 785                 { &hf_packetcable_bcid_time_zone_offset, { "Time Zone: Offset", "packetcable_avps.bcid.time_zone.offset", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
 786                 { &hf_packetcable_em_header_element_id, { "Element ID", "packetcable_avps.emh.element_id", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
 787                 { &hf_packetcable_em_header_time_zone_dst, { "Time Zone: DST", "packetcable_avps.emh.time_zone.dst", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL }},
 788                 { &hf_packetcable_em_header_time_zone_offset, { "Time Zone: Offset", "packetcable_avps.emh.time_zone.offset", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
 789                 { &hf_packetcable_em_header_event_time, { "Event Time", "packetcable_avps.emh.event_time", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
 790                 { &hf_packetcable_qos_service_class_name, { "Service Class Name", "packetcable_avps.qs.sc_name", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
 791                 { &hf_packetcable_redirected_from_last_redirecting_party, { "Last-Redirecting-Party", "packetcable_avps.rfi.last_redirecting_party", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
 792                 { &hf_packetcable_redirected_from_original_called_party, { "Original-Called-Party", "packetcable_avps.rfi.original_called_party", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL }},
 793                 { &hf_packetcable_electronic_surveillance_indication_df_df_key, { "DF-DF-Key", "packetcable_avps.esi.df_df_key", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL }},
 794         };
 795
 796         static int *ett[] = {
 797                 &ett_radius_vendor_packetcable_bcid,
 798                 &ett_radius_vendor_packetcable_status,
 799                 &ett_radius_vendor_packetcable_qos_status,
 800                 &ett_packetcable_term_dsply
 801         };
 802
 803         proto_packetcable = proto_register_protocol("PacketCable AVPs", "PACKETCABLE", "packetcable_avps");
 804
 805         proto_register_field_array(proto_packetcable, hf, array_length(hf));
 806         proto_register_subtree_array(ett, array_length(ett));
 807 }
 808
 809 void
 810 proto_reg_handoff_packetcable(void)
 811 {
 812
 813         radius_register_avp_dissector(VENDOR_CABLELABS, 1, dissect_packetcable_em_hdr);
 814         radius_register_avp_dissector(VENDOR_CABLELABS, 11, dissect_packetcable_call_term_cause);
 815         radius_register_avp_dissector(VENDOR_CABLELABS, 13, dissect_packetcable_rel_call_billing_correlation);
 816         radius_register_avp_dissector(VENDOR_CABLELABS, 24, dissect_packetcable_trunk_group_id);
 817         radius_register_avp_dissector(VENDOR_CABLELABS, 32, dissect_packetcable_qos_descriptor);
 818         radius_register_avp_dissector(VENDOR_CABLELABS, 38, dissect_packetcable_time_adjustment);
 819         radius_register_avp_dissector(VENDOR_CABLELABS, 43, dissect_packetcable_redirected_from_info);
 820         radius_register_avp_dissector(VENDOR_CABLELABS, 44, dissect_packetcable_time_electr_surv_ind);
 821         radius_register_avp_dissector(VENDOR_CABLELABS, 47, dissect_packetcable_surv_df_sec);
 822         radius_register_avp_dissector(VENDOR_CABLELABS, 54, dissect_packetcable_term_dsply_info);
 823 /*      radius_register_avp_dissector(VENDOR_CABLELABS, 90, dissect_packetcable_party_info);
 824         radius_register_avp_dissector(VENDOR_CABLELABS, 91, dissect_packetcable_party_info);
 825         radius_register_avp_dissector(VENDOR_CABLELABS, 92, dissect_packetcable_party_info); */
 826 }
 827
 828
 829 /*
 830  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 831  *
 832  * Local variables:
 833  * c-basic-offset: 8
 834  * tab-width: 8
 835  * indent-tabs-mode: t
 836  * End:
 837  *
 838  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 839  * :indentSize=8:tabSize=8:noTabs=false:
 840  */