/* packet-gbcs.c
 *
 * Dissector for Great Britain Companion Specification (GBCS) used in the Smart Metering Equipment Technical Specifications (SMETS)
 *
 * The Smart Metering Equipment Technical Specifications (SMETS) requires that Gas Smart Metering Equipment (GSME), and Electricity
 * Smart Metering Equipment (ESME) including variants, meet the requirements described in
 * the Great Britain Companion Specification (GBCS).
 *
 * GBCS messages are end-to-end and contains ZigBee, DLMS or ASN.1 formatted payloads. The GBCS messages are transported via IP
 * or via the ZigBee Tunneling cluster.
 *
 * https://smartenergycodecompany.co.uk/document-download-centre/download-info/gbcs-v2-1/
 *
 * Sample capture is attached in Bug 15381
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

#include "config.h"
#include <epan/packet.h>
#include <epan/expert.h>
#include <epan/reassemble.h>
#include "packet-ber.h"
#include "packet-zbee.h"
#include "packet-zbee-nwk.h"
#include "packet-zbee-zcl.h"
#include "packet-zbee-aps.h"
#include <wsutil/time_util.h>

#define gbcs_message_code_names_VALUE_STRING_LIST(XXX) \
    XXX(GBCS_MESSAGE_CCS01,      0x0001, "CCS01 Add Device to CHF device log") \
    XXX(GBCS_MESSAGE_CCS02,      0x0002, "CCS02 Remove device from CHF device log") \
    XXX(GBCS_MESSAGE_CCS03,      0x0003, "CCS03 Restore CHF Device Log") \
    XXX(GBCS_MESSAGE_CCS05CCS04, 0x0004, "CCS05/CCS04 Read CHF device log / Check HAN communications (by reading the CHF Communications Store)") \
    XXX(GBCS_MESSAGE_CS01A,      0x0007, "CS01a Apply Pre-payment Top Up to an ESME") \
    XXX(GBCS_MESSAGE_CS02A,      0x0008, "CS02a Provide Security Credentials Details") \
    XXX(GBCS_MESSAGE_CS02C,      0x000A, "CS02c Issue Security Credentials ") \
    XXX(GBCS_MESSAGE_CS02D,      0x000B, "CS02d Update Device Certificates on Device") \
    XXX(GBCS_MESSAGE_CS02E,      0x000C, "CS02e Provide Device Certificates from Device ") \
    XXX(GBCS_MESSAGE_CS03A1,     0x000D, "CS03a1 Method A Join (Meter)") \
    XXX(GBCS_MESSAGE_CS03B,      0x000E, "CS03b Method B Join") \
    XXX(GBCS_MESSAGE_CS04AC,     0x000F, "CS04ac Method A or C Unjoin") \
    XXX(GBCS_MESSAGE_CS04B,      0x0010, "CS04b Method B Unjoin") \
    XXX(GBCS_MESSAGE_CS06,       0x0012, "CS06 Activate Firmware") \
    XXX(GBCS_MESSAGE_CS07,       0x0013, "CS07 Read Device Join Details") \
    XXX(GBCS_MESSAGE_CS10A,      0x0014, "CS10a Read ZigBee Device Event Log") \
    XXX(GBCS_MESSAGE_CS11,       0x0015, "CS11 Clear ZigBee Device Event Log") \
    XXX(GBCS_MESSAGE_CS14,       0x0018, "CS14 Device Addition To / Removal From HAN Whitelist Alerts") \
    XXX(GBCS_MESSAGE_ECS01A,     0x0019, "ECS01a Set Tariff and Price on ESME") \
    XXX(GBCS_MESSAGE_ECS02,      0x001A, "ECS02 Set ESME Payment Mode to Credit") \
    XXX(GBCS_MESSAGE_ECS03,      0x001B, "ECS03 Set ESME Payment Mode to Pre-payment") \
    XXX(GBCS_MESSAGE_ECS04A,     0x001C, "ECS04a Adjust Meter Balance on the ESME") \
    XXX(GBCS_MESSAGE_ECS05,      0x001D, "ECS05 Reset Tariff Block Counter Matrix") \
    XXX(GBCS_MESSAGE_ECS07,      0x001E, "ECS07 Manage Debt on the ESME") \
    XXX(GBCS_MESSAGE_ECS08,      0x001F, "ECS08 Update Pre-payment Configuration on ESME") \
    XXX(GBCS_MESSAGE_ECS09,      0x0020, "ECS09 Activate Emergency Credit Remotely on ESME") \
    XXX(GBCS_MESSAGE_ECS10,      0x0021, "ECS10 Send Message to ESME") \
    XXX(GBCS_MESSAGE_ECS12,      0x0022, "ECS12 Set Change of Tenancy date on ESME") \
    XXX(GBCS_MESSAGE_ECS14,      0x0023, "ECS14 Disable Privacy PIN Protection on ESME") \
    XXX(GBCS_MESSAGE_ECS15A,     0x0024, "ECS15a Clear ESME Event Log") \
    XXX(GBCS_MESSAGE_ECS16,      0x0025, "ECS16 Write Supplier Contact Details on ESME") \
    XXX(GBCS_MESSAGE_ECS17A,     0x0026, "ECS17a Read ESME Energy Registers (Export Energy)") \
    XXX(GBCS_MESSAGE_ECS17B,     0x0027, "ECS17b Read ESME Energy Registers (Import Energy)") \
    XXX(GBCS_MESSAGE_ECS17C,     0x0028, "ECS17c Read ESME Energy Registers (Power)") \
    XXX(GBCS_MESSAGE_ECS17D,     0x0029, "ECS17d Read ESME Energy Register (TOU)") \
    XXX(GBCS_MESSAGE_ECS17E,     0x002A, "ECS17e Read ESME Energy Register (TOU with Blocks)") \
    XXX(GBCS_MESSAGE_ECS18A,     0x002B, "ECS18a Read Maximum Demand Registers (export)") \
    XXX(GBCS_MESSAGE_ECS18B,     0x002C, "ECS18b Read Maximum Demand Registers (import)") \
    XXX(GBCS_MESSAGE_ECS19,      0x002D, "ECS19 Read ESME Pre-payment Registers") \
    XXX(GBCS_MESSAGE_ECS20A,     0x002E, "ECS20a Read ESME Billing Data Log (payment based debt payments)") \
    XXX(GBCS_MESSAGE_ECS20B,     0x002F, "ECS20b Read ESME Billing Data Log (change of mode / tariff triggered exc export)") \
    XXX(GBCS_MESSAGE_ECS20C,     0x0030, "ECS20c Read ESME Billing Data Log (billing calendar triggered exc export)") \
    XXX(GBCS_MESSAGE_ECS21A,     0x0033, "ECS21a Read Electricity Daily Read Log (exc export)") \
    XXX(GBCS_MESSAGE_ECS21B,     0x0034, "ECS21b Read Electricity (Pre-payment) Daily Read Log") \
    XXX(GBCS_MESSAGE_ECS21C,     0x0035, "ECS21c Read Electricity Daily Read Log (export only)") \
    XXX(GBCS_MESSAGE_ECS22A,     0x0036, "ECS22a Read Electricity Half Hour Profile Data (export)") \
    XXX(GBCS_MESSAGE_ECS22B,     0x0037, "ECS22b Read Electricity Half Hour Profile Data (active import)") \
    XXX(GBCS_MESSAGE_ECS22C,     0x0038, "ECS22c Read Electricity Half Hour Profile Data (reactive import)") \
    XXX(GBCS_MESSAGE_ECS23,      0x0039, "ECS23 Read Voltage Operational Data") \
    XXX(GBCS_MESSAGE_ECS24,      0x003A, "ECS24 Read ESME Tariff Data") \
    XXX(GBCS_MESSAGE_ECS26A,     0x003B, "ECS26a Read ESME Configuration Data Pre-payment") \
    XXX(GBCS_MESSAGE_ECS26B,     0x003C, "ECS26b Read ESME Configuration Voltage Data") \
    XXX(GBCS_MESSAGE_ECS26C,     0x003D, "ECS26c Read ESME Configuration Data Device Information  (randomisation)") \
    XXX(GBCS_MESSAGE_ECS26D,     0x003E, "ECS26d Read ESME Configuration Data Device Information (Billing Calendar)") \
    XXX(GBCS_MESSAGE_ECS26E,     0x003F, "ECS26e Read ESME Configuration Data Device Information (device identity exc MPAN)") \
    XXX(GBCS_MESSAGE_ECS26F,     0x0040, "ECS26f Read ESME Configuration Data Device Information (instantaneous power thresholds)") \
    XXX(GBCS_MESSAGE_ECS27,      0x0042, "ECS27 Read ESME Load Limit Data") \
    XXX(GBCS_MESSAGE_ECS28A,     0x0043, "ECS28a Set Load Limit Configurations - General Settings") \
    XXX(GBCS_MESSAGE_ECS28B,     0x0044, "ECS28b Set Load Limit Configuration Counter Reset") \
    XXX(GBCS_MESSAGE_ECS29A,     0x0045, "ECS29a Set Voltage Configurations on ESME") \
    XXX(GBCS_MESSAGE_ECS30,      0x0046, "ECS30 Set Billing Calendar on the ESME") \
    XXX(GBCS_MESSAGE_ECS34,      0x0047, "ECS34 Set Instantaneous Power Threshold Configuration") \
    XXX(GBCS_MESSAGE_ECS35A,     0x0048, "ECS35a Read ESME Event Log") \
    XXX(GBCS_MESSAGE_ECS35B,     0x0049, "ECS35b Read ESME Security Log") \
    XXX(GBCS_MESSAGE_ECS37,      0x004A, "ECS37 Set Maximum Demand Configurable Time Period") \
    XXX(GBCS_MESSAGE_ECS38,      0x004B, "ECS38 Update Randomised Offset Limit") \
    XXX(GBCS_MESSAGE_ECS39A,     0x004C, "ECS39a Set MPAN Value on the ESME") \
    XXX(GBCS_MESSAGE_ECS39B,     0x004D, "ECS39b Set Export MPAN Value on the ESME") \
    XXX(GBCS_MESSAGE_ECS40,      0x004E, "ECS40 Read MPAN Value on the ESME") \
    XXX(GBCS_MESSAGE_ECS42,      0x004F, "ECS42 Remotely Close the Load Switch on the ESME") \
    XXX(GBCS_MESSAGE_ECS43,      0x0050, "ECS43 Remotely Open the Load Switch on the ESME") \
    XXX(GBCS_MESSAGE_ECS44,      0x0051, "ECS44 Arm Load Switch in ESME") \
    XXX(GBCS_MESSAGE_ECS45,      0x0052, "ECS45 Read Status of Load Switch in the ESME") \
    XXX(GBCS_MESSAGE_ECS46A,     0x0053, "ECS46a Set HC ALCS or ALCS Labels in ESME") \
    XXX(GBCS_MESSAGE_ECS46C,     0x0054, "ECS46c Set HC ALCS and ALCS configuration in ESME (excluding labels)") \
    XXX(GBCS_MESSAGE_ECS47,      0x0055, "ECS47 Set or Reset HC ALCS or ALCS State") \
    XXX(GBCS_MESSAGE_ECS50,      0x0058, "ECS50 Send CIN to ESME") \
    XXX(GBCS_MESSAGE_ECS52,      0x0059, "ECS52 Read ESME/Comms Hub Firmware Version") \
    XXX(GBCS_MESSAGE_ECS57,      0x005A, "ECS57 Reset ESME Maximum Demand Registers") \
    XXX(GBCS_MESSAGE_ECS61C,     0x005E, "ECS61c Read Boost Button Data from ESME") \
    XXX(GBCS_MESSAGE_ECS62,      0x005F, "ECS62 Set ALCS and Boost Button Association") \
    XXX(GBCS_MESSAGE_ECS66,      0x0060, "ECS66 Read ESME Daily Consumption Log") \
    XXX(GBCS_MESSAGE_ECS68,      0x0061, "ECS68 ESME Critical Sensitive Alert (Billing Data Log)") \
    XXX(GBCS_MESSAGE_ECS70,      0x0062, "ECS70 Set Clock on ESME") \
    XXX(GBCS_MESSAGE_ECS80,      0x0067, "ECS80 Supply Outage Restore Alert from ESME") \
    XXX(GBCS_MESSAGE_ECS81,      0x0068, "ECS81 Set Supply Tamper State on ESME") \
    XXX(GBCS_MESSAGE_ECS82,      0x0069, "ECS82 Read Meter Balance for ESME") \
    XXX(GBCS_MESSAGE_GCS01A,     0x006B, "GCS01a Set Tariff and Price on GSME") \
    XXX(GBCS_MESSAGE_GCS02,      0x006C, "GCS02 Set GSME Payment Mode to Credit") \
    XXX(GBCS_MESSAGE_GCS03,      0x006D, "GCS03 Set GSME Payment Mode to Pre-payment") \
    XXX(GBCS_MESSAGE_GCS04,      0x006E, "GCS04 Manage Debt on the GSME") \
    XXX(GBCS_MESSAGE_GCS05,      0x006F, "GCS05 Update Pre-payment Configurations on GSME") \
    XXX(GBCS_MESSAGE_GCS06,      0x0070, "GCS06 Activate Emergency Credit Remotely on GSME") \
    XXX(GBCS_MESSAGE_GCS07,      0x0071, "GCS07 Send Message to GSME") \
    XXX(GBCS_MESSAGE_GCS09,      0x0072, "GCS09 Set Change of Tenancy date on GPF") \
    XXX(GBCS_MESSAGE_GCS11,      0x0073, "GCS11 Disable Privacy PIN Protection on GSME") \
    XXX(GBCS_MESSAGE_GCS13A,     0x0074, "GCS13a Read GSME Consumption Register") \
    XXX(GBCS_MESSAGE_GCS14,      0x0075, "GCS14 Read GSME Pre-payment Register(s)") \
    XXX(GBCS_MESSAGE_GCS15C,     0x0076, "GCS15c Read GSME Billing Data Log (billing calendar triggered)") \
    XXX(GBCS_MESSAGE_GCS16A,     0x0077, "GCS16a Read GSME Daily Read log(s)") \
    XXX(GBCS_MESSAGE_GCS17,      0x0078, "GCS17 Read GSME Profile Data Log") \
    XXX(GBCS_MESSAGE_GCS18,      0x0079, "GCS18 Read Gas Network Data Log") \
    XXX(GBCS_MESSAGE_GCS21A,     0x007B, "GCS21a Read Gas Configuration Data Device Information") \
    XXX(GBCS_MESSAGE_GCS23,      0x007C, "GCS23 Set CV and Conversion Factor Value(s) on the GSME") \
    XXX(GBCS_MESSAGE_GCS24,      0x007D, "GCS24 Set Uncontrolled Gas Flow Rate and Supply Tamper State on the GSME") \
    XXX(GBCS_MESSAGE_GCS25,      0x007E, "GCS25 Set Billing Calendar on the GSME") \
    XXX(GBCS_MESSAGE_GCS28,      0x007F, "GCS28 Set Clock on GSME") \
    XXX(GBCS_MESSAGE_GCS31,      0x0080, "GCS31 Start Network Data Log on GSME") \
    XXX(GBCS_MESSAGE_GCS32,      0x0081, "GCS32 Remotely close the valve in the GSME") \
    XXX(GBCS_MESSAGE_GCS33,      0x0082, "GCS33 Read GSME Valve Status") \
    XXX(GBCS_MESSAGE_GCS36,      0x0083, "GCS36 Send CIN to GSME") \
    XXX(GBCS_MESSAGE_GCS38,      0x0084, "GCS38 Read GSME Firmware Version") \
    XXX(GBCS_MESSAGE_GCS39,      0x0085, "GCS39 Arm Valve in GSME") \
    XXX(GBCS_MESSAGE_GCS40A,     0x0086, "GCS40a Adjust Pre-payment Mode Meter Balance on the GSME") \
    XXX(GBCS_MESSAGE_GCS41,      0x0087, "GCS41 Set MPRN Value on the GSME") \
    XXX(GBCS_MESSAGE_GCS44,      0x0088, "GCS44 Write Contact Details on GSME") \
    XXX(GBCS_MESSAGE_GCS46,      0x0089, "GCS46 Read MPRN on the GSME") \
    XXX(GBCS_MESSAGE_GCS53,      0x008B, "GCS53 Push Billing Data Log as an Alert") \
    XXX(GBCS_MESSAGE_GCS59,      0x008C, "GCS59 Restore GPF Device Log") \
    XXX(GBCS_MESSAGE_GCS60,      0x008D, "GCS60 Read Meter Balance for GSME") \
    XXX(GBCS_MESSAGE_PCS02,      0x0090, "PCS02 Activate Emergency Credit on GSME from PPMID") \
    XXX(GBCS_MESSAGE_ECS26I,     0x0092, "ECS26i Read Configuration Data Device Information (CHF identity)") \
    XXX(GBCS_MESSAGE_ECS35C,     0x0093, "ECS35c Read CHF Event Log") \
    XXX(GBCS_MESSAGE_ECS35D,     0x0094, "ECS35d Read CHF Security Log") \
    XXX(GBCS_MESSAGE_GCS16B,     0x0096, "GCS16b Read GSME Daily Read log(s) (pre-payment)") \
    XXX(GBCS_MESSAGE_CS01B,      0x0097, "CS01b Apply Pre-payment Top Up to a GSME") \
    XXX(GBCS_MESSAGE_PCS01,      0x009B, "PCS01 Apply Pre-payment Top Up to a GSME using PPMID") \
    XXX(GBCS_MESSAGE_GCS21D,     0x009D, "GCS21d Read GSME Configuration Data Device Information (BillingCalendar)") \
    XXX(GBCS_MESSAGE_GCS21E,     0x009E, "GCS21e Read GSME/GPF Configuration Data Device Information (device identity)") \
    XXX(GBCS_MESSAGE_GCS21F,     0x009F, "GCS21f Read GSME Tariff Data") \
    XXX(GBCS_MESSAGE_GCS61,      0x00A0, "GCS61 Read gas Daily Consumption Log") \
    XXX(GBCS_MESSAGE_CS10B,      0x00A1, "CS10b Read ZigBee Device Security Log") \
    XXX(GBCS_MESSAGE_ECS01B,     0x00A2, "ECS01b Set Price on ESME") \
    XXX(GBCS_MESSAGE_GCS01B,     0x00A3, "GCS01b Set Price on GSME") \
    XXX(GBCS_MESSAGE_CS03A2,     0x00AB, "CS03a2 Method A Join (non Meter)") \
    XXX(GBCS_MESSAGE_ECS25A,     0x00AC, "ECS25a Set Alert Behaviours - ESME - Supplier") \
    XXX(GBCS_MESSAGE_GCS20,      0x00AD, "GCS20 Set Alert Behaviours - GSME") \
    XXX(GBCS_MESSAGE_ECS29B,     0x00AE, "ECS29b Set Voltage Configurations on ESME - 3ph") \
    XXX(GBCS_MESSAGE_CS03C,      0x00AF, "CS03c Method C Join") \
    XXX(GBCS_MESSAGE_ECS25B,     0x00B0, "ECS25b Set Alert Behaviours - ESME - Network Operator") \
    XXX(GBCS_MESSAGE_GCS62,      0x00B2, "GCS62 Backup GPF Device Log") \
    XXX(GBCS_MESSAGE_ECS04B,     0x00B3, "ECS04b Reset Meter Balance on the ESME") \
    XXX(GBCS_MESSAGE_GCS40B,     0x00B4, "GCS40b Reset Pre-payment Mode Meter Balance on the GSME") \
    XXX(GBCS_MESSAGE_GCS21B,     0x00B5, "GCS21b Read GSME Configuration Data Pre-payment") \
    XXX(GBCS_MESSAGE_GCS13C,     0x00B6, "GCS13c Read GSME Register (TOU)") \
    XXX(GBCS_MESSAGE_ECS01C,     0x00B7, "ECS01c Set Tariff and Price on ESME secondary") \
    XXX(GBCS_MESSAGE_GCS13B,     0x00B8, "GCS13b Read GSME Block Counters") \
    XXX(GBCS_MESSAGE_ECS35E,     0x00B9, "ECS35e Read ESME Power Event Log") \
    XXX(GBCS_MESSAGE_ECS35F,     0x00BA, "ECS35f Read ALCS Event Log") \
    XXX(GBCS_MESSAGE_ECS61A,     0x00BB, "ECS61a Read HC ALCS and ALCS Data from ESME") \
    XXX(GBCS_MESSAGE_ECS23B,     0x00BC, "ECS23b Read Voltage Operational Data -3 Phase") \
    XXX(GBCS_MESSAGE_ECS24B,     0x00BD, "ECS24b Read ESME Tariff Data - second element") \
    XXX(GBCS_MESSAGE_ECS26J,     0x00BE, "ECS26j Read ESME Configuration Data Device Information (Payment Mode)") \
    XXX(GBCS_MESSAGE_GCS21J,     0x00BF, "GCS21j Read GSME Configuration Data Device Information (Payment Mode)") \
    XXX(GBCS_MESSAGE_GCS40C,     0x00C0, "GCS40c Adjust Credit Mode Meter Balance on the GSME") \
    XXX(GBCS_MESSAGE_ECS15C,     0x00C1, "ECS15c Clear ALCS Event Log") \
    XXX(GBCS_MESSAGE_GCS40D,     0x00C2, "GCS40d Reset Credit Mode Meter Balance on the GSME") \
    XXX(GBCS_MESSAGE_GCS15B,     0x00C3, "GCS15b Read GSME Billing Data Log (change of mode / tariff triggered)") \
    XXX(GBCS_MESSAGE_GCS15D,     0x00C4, "GCS15d Read GSME Billing Data Log (payment-based debt payments) ") \
    XXX(GBCS_MESSAGE_GCS15E,     0x00C5, "GCS15e Read GSME Billing Data Log (pre-payment credits)") \
    XXX(GBCS_MESSAGE_ECS26K,     0x00C6, "ECS26k Read ESME Configuration Voltage Data - 3 phase") \
    XXX(GBCS_MESSAGE_ECS01D,     0x00C7, "ECS01d Set Price on ESME secondary") \
    XXX(GBCS_MESSAGE_ECS20D,     0x00C9, "ECS20d Read ESME Billing Data Log (pre-payment credits)") \
    XXX(GBCS_MESSAGE_ALERT_00CA, 0x00CA, "Futured Dated Firmware Activation Alert") \
    XXX(GBCS_MESSAGE_ALERT_00CB, 0x00CB, "Futured Dated Updated Security Credentials Alert") \
    XXX(GBCS_MESSAGE_ALERT_00CC, 0x00CC, "Future Dated Execution Of Instruction Alert (DLMS COSEM)") \
    XXX(GBCS_MESSAGE_ALERT_00CD, 0x00CD, "Future Dated Execution Of Instruction Alert (GBZ)") \
    XXX(GBCS_MESSAGE_ALERT_00CE, 0x00CE, "Firmware Distribution Receipt Alert (ESME or Comms Hub)") \
    XXX(GBCS_MESSAGE_ALERT_00CF, 0x00CF, "Firmware Distribution Receipt Alert (GSME)") \
    XXX(GBCS_MESSAGE_ECS29C,     0x00D1, "ECS29c Set Voltage Configurations on ESME without counter reset") \
    XXX(GBCS_MESSAGE_ECS29D,     0x00D2, "ECS29d Set Voltage Configurations on polyphase ESME without counter reset") \
    XXX(GBCS_MESSAGE_ECS29E,     0x00D3, "ECS29e Reset RMS Voltage Counters on ESME") \
    XXX(GBCS_MESSAGE_ECS29F,     0x00D4, "ECS29f Reset RMS Voltage Counters on polyphase ESME") \
    XXX(GBCS_MESSAGE_ALERT_00D5, 0x00D5, "Failure to Deliver Remote Party Message to ESME Alert") \
    XXX(GBCS_MESSAGE_ECS30A,     0x00D7, "ECS30a Set Billing Calendar on the ESME - all periodicities") \
    XXX(GBCS_MESSAGE_GCS25A,     0x00D8, "GCS25a Set Billing Calendar on the GSME - all periodicities") \
    XXX(GBCS_MESSAGE_ECS26L,     0x00D9, "ECS26l Read ESME Configuration Data Device Information (Billing Calendar - all periodicities)") \
    XXX(GBCS_MESSAGE_GCS21K,     0x00DA, "GCS21k Read GSME Configuration Data Device Information (BillingCalendar - all periodicities)") \
    XXX(GBCS_MESSAGE_ECS48,      0x00DB, "ECS48 Configure daily resetting of Tariff Block Counter Matrix") \
    XXX(GBCS_MESSAGE_ECS08A,     0x00DE, "ECS08a Update Pre-payment Configuration on ESME") \
    XXX(GBCS_MESSAGE_ECS25A1,    0x00EA, "ECS25a1 Set Event Behaviours - ESME to HAN Device - Supplier") \
    XXX(GBCS_MESSAGE_ECS25A2,    0x00EB, "ECS25a2 Set Event Behaviours - ESME audible alarm - Supplier") \
    XXX(GBCS_MESSAGE_ECS25A3,    0x00EC, "ECS25a3 Set Event Behaviours - ESME logging - Supplier") \
    XXX(GBCS_MESSAGE_ECS25B3,    0x00ED, "ECS25b3 Set Event Behaviours - ESME logging - Network Operator") \
    XXX(GBCS_MESSAGE_ECS25R1,    0x00EE, "ECS25r1 Read non-critical event and alert behaviours - ESME-  Supplier") \
    XXX(GBCS_MESSAGE_ECS25R2,    0x00EF, "ECS25r2 Read non-critical event and alert behaviours - ESME-  Network Operator") \
    XXX(GBCS_MESSAGE_ALERT_00F0, 0x00F0, "Meter Integrity Issue Warning Alert - ESME") \
    XXX(GBCS_MESSAGE_GCS20R,     0x00F1, "GCS20r Read non-critical event and alert behaviours - GSME-  Supplier") \
    XXX(GBCS_MESSAGE_ALERT_00F2, 0x00F2, "Meter Integrity Issue Warning Alert - GSME") \
    XXX(GBCS_MESSAGE_ECS26M,     0x00F9, "ECS26m Read ESME Configuration Data Device Information (identity, type and supply tamper state)") \
    XXX(GBCS_MESSAGE_ECS26N,     0x00FA, "ECS26n Read CHF Configuration Data Device Information (CH identity and type)") \
    XXX(GBCS_MESSAGE_GCS21M,     0x00FB, "GCS21m Read GSME Configuration Data Device Information (identity, type and supply tamper / depletion state)") \
    XXX(GBCS_USECASE_GCS24A,     0x00FC, "GCS24a Set Uncontrolled Gas Flow Rate at greater resolution and Supply Tamper State on the GSME") \
    XXX(GBCS_MESSAGE_CS02B0,     0x0100, "CS02b Update Security Credentials - rootBySupplier") \
    XXX(GBCS_MESSAGE_CS02B1,     0x0101, "CS02b Update Security Credentials - rootByWanProvider") \
    XXX(GBCS_MESSAGE_CS02B2,     0x0102, "CS02b Update Security Credentials - supplierBySupplier") \
    XXX(GBCS_MESSAGE_CS02B3,     0x0103, "CS02b Update Security Credentials - networkOperatorByNetworkOperator") \
    XXX(GBCS_MESSAGE_CS02B4,     0x0104, "CS02b Update Security Credentials - accessControlBrokerByACB") \
    XXX(GBCS_MESSAGE_CS02B5,     0x0105, "CS02b Update Security Credentials - wanProviderByWanProvider") \
    XXX(GBCS_MESSAGE_CS02B6,     0x0106, "CS02b Update Security Credentials - transCoSByTransCoS") \
    XXX(GBCS_MESSAGE_CS02B7,     0x0107, "CS02b Update Security Credentials - supplierByTransCoS") \
    XXX(GBCS_MESSAGE_CS02B8,     0x0108, "CS02b Update Security Credentials - anyExceptAbnormalRootByRecovery") \
    XXX(GBCS_MESSAGE_CS02B9,     0x0109, "CS02b Update Security Credentials - anyByContingency") \
    XXX(GBCS_MESSAGE_DBCH01,     0x010A, "DBCH01 Read CHF Sub GHz Channel") \
    XXX(GBCS_MESSAGE_DBCH02,     0x010B, "DBCH02 Read CHF Sub GHz Channel Log") \
    XXX(GBCS_MESSAGE_DBCH03,     0x010C, "DBCH03 Read CHF Sub GHz Configuration") \
    XXX(GBCS_MESSAGE_DBCH04,     0x010D, "DBCH04 Set CHF Sub GHz Configuration") \
    XXX(GBCS_MESSAGE_DBCH05,     0x010E, "DBCH05 Request CHF Sub GHz Channel Scan") \
    XXX(GBCS_MESSAGE_CCS06,      0x010F, "CCS06 Read CHF device log and check HAN communications") \
    XXX(GBCS_MESSAGE_DBCH06,     0x0110, "DBCH06 Limited Duty Cycle Action Taken Sub GHz Alert") \
    XXX(GBCS_MESSAGE_DBCH07,     0x0111, "DBCH07 Sub GHz Sub GHz Channel Changed Sub GHz Alert") \
    XXX(GBCS_MESSAGE_DBCH08,     0x0112, "DBCH08 Sub GHz Channel Scan Request Assessment Outcome Sub GHz Alert") \
    XXX(GBCS_MESSAGE_DBCH09,     0x0113, "DBCH09 Sub GHz Configuration Changed Sub GHz Alert") \
    XXX(GBCS_MESSAGE_DBCH10,     0x0114, "DBCH10 Message Discarded Due to Duty Cycle Management Sub GHz Alert") \
    XXX(GBCS_MESSAGE_DBCH11,     0x0115, "DBCH11 No More Sub GHz Device Capacity Sub GHz Alert") \
    XXX(GBCS_MESSAGE_PECS01,     0x0116, "PECS01 Apply Pre-payment Top Up to an ESME using PPMID") \
    XXX(GBCS_MESSAGE_PECS02,     0x0117, "PECS02 Activate Emergency Credit on ESME from PPMID") \
    XXX(GBCS_MESSAGE_PECS03,     0x0118, "PECS03 Request to Enable ESME Supply from PPMID") \
    XXX(GBCS_MESSAGE_HECS01,     0x0119, "HECS01 Request Control of a HAN Connected Auxiliary Load Control Switch from HCALCS") \
    XXX(GBCS_MESSAGE_ALERT_1000, 0x1000, "Generic Critical Alert") \
    XXX(GBCS_MESSAGE_ALERT_1001, 0x1001, "Generic Non Critical Alert")

VALUE_STRING_ARRAY(gbcs_message_code_names);
static value_string_ext gbcs_message_code_names_ext = VALUE_STRING_EXT_INIT(gbcs_message_code_names);

#define gbcs_message_cra_names_VALUE_STRING_LIST(XXX) \
    XXX(GBCS_MESSAGE_CRA_COMMAND,                               0x01, "Command" ) \
    XXX(GBCS_MESSAGE_CRA_RESPONSE,                              0x02, "Response" ) \
    XXX(GBCS_MESSAGE_CRA_ALERT,                                 0x03, "Alert" )

VALUE_STRING_ENUM(gbcs_message_cra_names);
VALUE_STRING_ARRAY(gbcs_message_cra_names);

static void
dlms_date_time(tvbuff_t *tvb, guint offset, nstime_t *date_time)
{
    //TODO Handle DLMS date never
    struct tm tm;

    tm.tm_wday = 0;
    tm.tm_yday = 0;
    tm.tm_isdst = -1;

    tm.tm_year = tvb_get_guint16(tvb, offset, ENC_BIG_ENDIAN) - 1900;
    offset += 2;

    tm.tm_mon = tvb_get_guint8(tvb, offset) - 1; // tm.tm_mon [0-11]
    offset += 1;

    tm.tm_mday = tvb_get_guint8(tvb, offset);
    offset += 1;

    offset += 1; //Skip week day

    tm.tm_hour = tvb_get_guint8(tvb, offset);
    offset += 1;

    tm.tm_min = tvb_get_guint8(tvb, offset);
    offset += 1;

    tm.tm_sec = tvb_get_guint8(tvb, offset);

    date_time->secs = mktime_utc(&tm);
    date_time->nsecs = 0;
}

/* ########################################################################## */
/* #### GBCS GBZ ############################################################ */
/* ########################################################################## */

#define GBCS_GBZ_MAX_COMPONENTS                                         31 // GCS16a
#define GBCS_GBZ_MAC_LENGTH                                             12

#define GBCS_GBZ_EXTENDED_HEADER_CONTROL_FROM_DATE_TIME_PRESENT         0x10
#define GBCS_GBZ_EXTENDED_HEADER_CONTROL_LAST_COMPONENT                 0x01
#define GBCS_GBZ_EXTENDED_HEADER_CONTROL_ENCRYPTED_COMPONENT            0x02

#define gbcs_gbz_alert_code_names_VALUE_STRING_LIST(XXX) \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_ABOVE_AVERAGE_RMS_OVER_VOL_1,0x8002, "Average RMS Voltage above Average RMS Over Voltage Threshold (current value above threshold; previous value below threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_ABOVE_AVERAGE_RMS_OVER_VOL_2,0x8003, "Average RMS Voltage above Average RMS Over Voltage Threshold  on Phase 1 (current value above threshold; previous value below threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_ABOVE_AVERAGE_RMS_OVER_VOL_3,0x8004, "Average RMS Voltage above Average RMS Over Voltage Threshold  on Phase 2 (current value above threshold; previous value below threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_ABOVE_AVERAGE_RMS_OVER_VOL_4,0x8005, "Average RMS Voltage above Average RMS Over Voltage Threshold  on Phase 3 (current value above threshold; previous value below threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_BELOW_AVERAGE_RMS_UNDER_VO_1,0x8006, "Average RMS Voltage below Average RMS Under Voltage Threshold (current value below threshold; previous value above threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_BELOW_AVERAGE_RMS_UNDER_VO_2,0x8007, "Average RMS Voltage below Average RMS Under Voltage Threshold on Phase 1 (current value below threshold; previous value above threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_BELOW_AVERAGE_RMS_UNDER_VO_3,0x8008, "Average RMS Voltage below Average RMS Under Voltage Threshold on Phase 2 (current value below threshold; previous value above threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_BELOW_AVERAGE_RMS_UNDER_VO_4,0x8009, "Average RMS Voltage below Average RMS Under Voltage Threshold on Phase 3 (current value below threshold; previous value above threshold)") \
    XXX(GBCS_GBZ_ALERT_OVER_CURRENT,                                    0x8010, "Over Current") \
    XXX(GBCS_GBZ_ALERT_OVER_CURRENT_L1,                                 0x8011, "Over Current L1") \
    XXX(GBCS_GBZ_ALERT_OVER_CURRENT_L3,                                 0x8013, "Over Current L3") \
    XXX(GBCS_GBZ_ALERT_POWER_FACTOR_THRESHOLD_BELOW,                    0x8014, "Power Factor Threshold Below") \
    XXX(GBCS_GBZ_ALERT_POWER_FACTOR_THRESHOLD_OK,                       0x8015, "Power Factor Threshold Ok") \
    XXX(GBCS_GBZ_ALERT_OVER_CURRENT_L2,                                 0x8016, "Over Current L2") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_EXTREME_OVER_VOLTAGE_THRESHO_1,0x8020, "RMS Voltage above Extreme Over Voltage Threshold (voltage rises above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_EXTREME_OVER_VOLTAGE_THRESHO_2,0x8021, "RMS Voltage above Extreme Over Voltage Threshold on Phase 1 (voltage rises above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_EXTREME_OVER_VOLTAGE_THRESHO_3,0x8022, "RMS Voltage above Extreme Over Voltage Threshold on Phase 2 (voltage rises above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_EXTREME_OVER_VOLTAGE_THRESHO_4,0x8023, "RMS Voltage above Extreme Over Voltage Threshold on Phase 3 (voltage rises above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_VOLTAGE_SWELL_THRESHOLD_VOLT_1,0x8024, "RMS Voltage above Voltage Swell Threshold (voltage rises above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_VOLTAGE_SWELL_THRESHOLD_ON_P_2,0x8025, "RMS Voltage above Voltage Swell Threshold on Phase 1 (voltage rises above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_VOLTAGE_SWELL_THRESHOLD_ON_P_3,0x8026, "RMS Voltage above Voltage Swell Threshold on Phase 2 (voltage rises above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_VOLTAGE_SWELL_THRESHOLD_ON_P_4,0x8027, "RMS Voltage above Voltage Swell Threshold on Phase 3 (voltage rises above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_EXTREME_UNDER_VOLTAGE_THRESH_1,0x8028, "RMS Voltage below Extreme Under Voltage Threshold (voltage falls below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_EXTREME_UNDER_VOLTAGE_THRESH_2,0x8029, "RMS Voltage below Extreme Under Voltage Threshold on Phase 1 (voltage falls below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_EXTREME_UNDER_VOLTAGE_THRESH_3,0x802A, "RMS Voltage below Extreme Under Voltage Threshold on Phase 2 (voltage falls below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_EXTREME_UNDER_VOLTAGE_THRESH_4,0x802B, "RMS Voltage below Extreme Under Voltage Threshold on Phase 3 (voltage falls below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_VOLTAGE_SAG_THRESHOLD_VOLTA_1, 0x802C, "RMS Voltage below Voltage Sag Threshold (voltage falls below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_VOLTAGE_SAG_THRESHOLD_ON_PHA_1,0x802D, "RMS Voltage below Voltage Sag Threshold on Phase 1 (voltage falls below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_VOLTAGE_SAG_THRESHOLD_ON_PHA_2,0x802E, "RMS Voltage below Voltage Sag Threshold on Phase 2 (voltage falls below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_VOLTAGE_SAG_THRESHOLD_ON_PHA_3,0x802F, "RMS Voltage below Voltage Sag Threshold on Phase 3 (voltage falls below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_GPF_DEVICE_LOG_CHANGED,                          0x8071, "GPF Device Log Changed") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_BELOW_AVERAGE_RMS_OVER_VOL_1,0x8085, "Average RMS Voltage below Average RMS Over Voltage Threshold (current value below threshold; previous value above threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_BELOW_AVERAGE_RMS_OVER_VOL_2,0x8086, "Average RMS Voltage below Average RMS Over Voltage Threshold on Phase 1 (current value below threshold; previous value above threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_BELOW_AVERAGE_RMS_OVER_VOL_3,0x8087, "Average RMS Voltage below Average RMS Over Voltage Threshold on Phase 2 (current value below threshold; previous value above threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_BELOW_AVERAGE_RMS_OVER_VOL_4,0x8088, "Average RMS Voltage below Average RMS Over Voltage Threshold on Phase 3 (current value below threshold; previous value above threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_ABOVE_AVERAGE_RMS_UNDER_VO_1,0x8089, "Average RMS Voltage above Average RMS Under Voltage Threshold (current value above threshold; previous value below threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_ABOVE_AVERAGE_RMS_UNDER_VO_2,0x808A, "Average RMS Voltage above Average RMS Under Voltage Threshold on Phase 1 (current value above threshold; previous value below threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_ABOVE_AVERAGE_RMS_UNDER_VO_3,0x808B, "Average RMS Voltage above Average RMS Under Voltage Threshold on Phase 2 (current value above threshold; previous value below threshold)") \
    XXX(GBCS_GBZ_ALERT_AVERAGE_RMS_VOLTAGE_ABOVE_AVERAGE_RMS_UNDER_VO_4,0x808C, "Average RMS Voltage above Average RMS Under Voltage Threshold on Phase 3 (current value above threshold; previous value below threshold)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_EXTREME_OVER_VOLTAGE_THRESHO_5,0x808D, "RMS Voltage above Extreme Over Voltage Threshold (voltage returns below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_EXTREME_OVER_VOLTAGE_THRESHO_6,0x808E, "RMS Voltage above Extreme Over Voltage Threshold on Phase 1 (voltage returns below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_EXTREME_OVER_VOLTAGE_THRESHO_7,0x808F, "RMS Voltage above Extreme Over Voltage Threshold on Phase 2 (voltage returns below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_EXTREME_OVER_VOLTAGE_THRESHO_8,0x8090, "RMS Voltage above Extreme Over Voltage Threshold on Phase 3 (voltage returns below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_VOLTAGE_SWELL_THRESHOLD_VOLT_2,0x8091, "RMS Voltage above Voltage Swell Threshold (voltage returns below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_VOLTAGE_SWELL_THRESHOLD_ON_P_1,0x8092, "RMS Voltage above Voltage Swell Threshold on Phase 1 (voltage returns below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_VOLTAGE_SWELL_THRESHOLD_ON_P_5,0x8093, "RMS Voltage above Voltage Swell Threshold on Phase 2 (voltage returns below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_ABOVE_VOLTAGE_SWELL_THRESHOLD_ON_P_6,0x8094, "RMS Voltage above Voltage Swell Threshold on Phase 3 (voltage returns below for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_EXTREME_UNDER_VOLTAGE_THRESH_5,0x8095, "RMS Voltage below Extreme Under Voltage Threshold (voltage returns above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_EXTREME_UNDER_VOLTAGE_THRESH_6,0x8096, "RMS Voltage below Extreme Under Voltage Threshold on Phase 1 (voltage returns above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_EXTREME_UNDER_VOLTAGE_THRESH_7,0x8097, "RMS Voltage below Extreme Under Voltage Threshold on Phase 2 (voltage returns above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_EXTREME_UNDER_VOLTAGE_THRESH_8,0x8098, "RMS Voltage below Extreme Under Voltage Threshold on Phase 3 (voltage returns above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_VOLTAGE_SAG_THRESHOLD_VOLTA_2, 0x8099, "RMS Voltage below Voltage Sag Threshold (voltage returns above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_VOLTAGE_SAG_THRESHOLD_ON_PHA_4,0x809A, "RMS Voltage below Voltage Sag Threshold on Phase 1 (voltage returns above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_VOLTAGE_SAG_THRESHOLD_ON_PHA_5,0x809B, "RMS Voltage below Voltage Sag Threshold on Phase 2 (voltage returns above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_RMS_VOLTAGE_BELOW_VOLTAGE_SAG_THRESHOLD_ON_PHA_6,0x809C, "RMS Voltage below Voltage Sag Threshold on Phase 3 (voltage returns above for longer than the configurable period)") \
    XXX(GBCS_GBZ_ALERT_COMBINED_CREDIT_BELOW_LOW_CREDIT_THRESHOLD_PREPA,0x810D, "Combined Credit Below Low Credit Threshold (prepayment mode)") \
    XXX(GBCS_GBZ_ALERT_CREDIT_ADDED_LOCALLY,                            0x810E, "Credit Added Locally") \
    XXX(GBCS_GBZ_ALERT_EMERGENCY_CREDIT_HAS_BECOME_AVAILABLE_PREPAYMENT,0x8119, "Emergency Credit Has Become Available (prepayment mode)") \
    XXX(GBCS_GBZ_ALERT_FAILURE_IN_CHANGING_OR_MAINTAINING_HCALCS_OR_A_1,0x811A, "Failure in changing or maintaining HCALCS or ALCS state") \
    XXX(GBCS_GBZ_ALERT_SUCCESS_IN_CHANGING_OR_MAINTAINING_HCALCS_OR_A_2,0x8131, "Success in changing or maintaining HCALCS or ALCS state") \
    XXX(GBCS_GBZ_ALERT_CLOCK_ADJUSTED_WITHIN_TOLERANCE,                 0x8145, "Clock adjusted (within tolerance)") \
    XXX(GBCS_GBZ_ALERT_IMMEDIATE_HAN_INTERFACE_COMMAND_RECEIVED_AND_SUC,0x8154, "Immediate HAN Interface Command Received and Successfully Actioned") \
    XXX(GBCS_GBZ_ALERT_IMMEDIATE_HAN_INTERFACE_COMMAND_RECEIVED_BUT_NOT,0x8155, "Immediate HAN Interface Command Received but not Successfully Actioned") \
    XXX(GBCS_GBZ_ALERT_USER_INTERFACE_COMMAND_INPUT_AND_SUCCESSFULLY_AC,0x8161, "User Interface Command Input and Successfully Actioned") \
    XXX(GBCS_GBZ_ALERT_USER_INTERFACE_COMMAND_INPUT_BUT_NOT_SUCCESSFULL,0x8162, "User Interface Command Input but not Successfully Actioned") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_DISABLED_THEN_ARMED_ACTIVATE_EMERGENCY,   0x8168, "Supply Disabled then Armed - Activate Emergency Credit triggered") \
    XXX(GBCS_GBZ_ALERT_DEVICE_JOINED_SMHAN,                             0x8183, "Device joined SMHAN") \
    XXX(GBCS_GBZ_ALERT_VALVE_TESTED,                                    0x8184, "Valve tested") \
    XXX(GBCS_GBZ_ALERT_GSME_COMMAND_NOT_RETRIEVED,                      0x819D, "GSME Command Not Retrieved") \
    XXX(GBCS_GBZ_ALERT_TAP_OFF_MESSAGE_RESPONSE_OR_ALERT_FAILURE,       0x819E, "Tap Off Message Response or Alert Failure") \
    XXX(GBCS_GBZ_ALERT_SMART_METER_INTEGRITY_ISSUE_WARNING,             0x81A0, "Smart Meter Integrity Issue Warning") \
    XXX(GBCS_GBZ_ALERT_BATTERY_COVER_CLOSED,                            0x81A1, "Battery Cover Closed") \
    XXX(GBCS_GBZ_ALERT_CH_CONNECTED_TO_ESME,                            0x81A2, "CH Connected to ESME") \
    XXX(GBCS_GBZ_ALERT_CH_DISCONNECTED_FROM_ESME,                       0x81A3, "CH Disconnected from ESME") \
    XXX(GBCS_GBZ_ALERT_CLOSE_TUNNEL_COMMAND_REJECTED,                   0x81A4, "Close Tunnel Command Rejected") \
    XXX(GBCS_GBZ_ALERT_COMMUNICATION_FROM_LOCAL_PORT_EG_OPTICAL,        0x81A5, "Communication From Local Port (e.g. Optical)") \
    XXX(GBCS_GBZ_ALERT_CUSTOMER_ACKNOWLEDGED_MESSAGE_ON_HAN_DEVICE,     0x81A6, "Customer Acknowledged Message on HAN Device") \
    XXX(GBCS_GBZ_ALERT_DEBT_COLLECTION_COMPLETED_TIME_DEBT_1,           0x81A7, "Debt Collection Completed - Time Debt 1") \
    XXX(GBCS_GBZ_ALERT_DEBT_COLLECTION_COMPLETED_TIME_DEBT_2,           0x81A8, "Debt Collection Completed - Time Debt 2") \
    XXX(GBCS_GBZ_ALERT_DEBT_COLLECTION_COMPLETED_PAYMENT_DEBT,          0x81A9, "Debt Collection Completed - Payment Debt") \
    XXX(GBCS_GBZ_ALERT_EMERGENCY_CREDIT_EXHAUSTED,                      0x81AA, "Emergency Credit Exhausted") \
    XXX(GBCS_GBZ_ALERT_EMERGENCY_CREDIT_ACTIVATED,                      0x81AB, "Emergency Credit Activated") \
    XXX(GBCS_GBZ_ALERT_ERROR_MEASUREMENT_FAULT,                         0x81AC, "Error Measurement Fault") \
    XXX(GBCS_GBZ_ALERT_ERROR_METROLOGY_FIRMWARE_VERIFICATION_FAILURE,   0x81AD, "Error Metrology Firmware Verification Failure") \
    XXX(GBCS_GBZ_ALERT_ERROR_NON_VOLATILE_MEMORY,                       0x81AE, "Error Non Volatile Memory") \
    XXX(GBCS_GBZ_ALERT_ERROR_PROGRAM_EXECUTION,                         0x81AF, "Error Program Execution") \
    XXX(GBCS_GBZ_ALERT_ERROR_PROGRAM_STORAGE,                           0x81B0, "Error Program Storage") \
    XXX(GBCS_GBZ_ALERT_ERROR_RAM,                                       0x81B1, "Error RAM") \
    XXX(GBCS_GBZ_ALERT_ERROR_UNEXPECTED_HARDWARE_RESET,                 0x81B2, "Error Unexpected Hardware Reset") \
    XXX(GBCS_GBZ_ALERT_ERROR_WATCHDOG,                                  0x81B3, "Error Watchdog ") \
    XXX(GBCS_GBZ_ALERT_EXCESS_GAS_FLOW_BEYOND_METER_CAPACITY,           0x81B4, "Excess Gas Flow Beyond Meter Capacity") \
    XXX(GBCS_GBZ_ALERT_FLOW_SENSOR_DETECTS_AIR_IN_GAS_FLOW,             0x81B5, "Flow Sensor Detects Air in Gas Flow") \
    XXX(GBCS_GBZ_ALERT_FLOW_SENSOR_DETECTS_REVERSE_FLOW_OF_GAS,         0x81B6, "Flow Sensor Detects Reverse Flow of Gas") \
    XXX(GBCS_GBZ_ALERT_INCORRECT_PHASE_SEQUENCING,                      0x81B7, "Incorrect phase sequencing") \
    XXX(GBCS_GBZ_ALERT_INCORRECT_POLARITY,                              0x81B8, "Incorrect Polarity") \
    XXX(GBCS_GBZ_ALERT_METER_COVER_CLOSED,                              0x81B9, "Meter Cover Closed") \
    XXX(GBCS_GBZ_ALERT_REQUEST_TUNNEL_COMMAND_REJECTED,                 0x81BA, "Request Tunnel Command Rejected") \
    XXX(GBCS_GBZ_ALERT_REVERSE_CURRENT,                                 0x81BB, "Reverse Current") \
    XXX(GBCS_GBZ_ALERT_STRONG_MAGNETIC_FIELD_REMOVED,                   0x81BC, "Strong Magnetic Field Removed") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_CONNECT_FAILURE_VALVE_OR_LOAD_SWITCH,     0x81BD, "Supply Connect Failure (Valve or Load Switch)") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_DISABLED_THEN_LOCKED_SUPPLY_TAMPER_STATE, 0x81BE, "Supply Disabled Then Locked - Supply Tamper State Cause") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_DISABLED_THEN_ARMED_UNCONTROLLED_GAS_FLOW,0x81BF, "Supply Disabled Then Armed - Uncontrolled Gas Flow Rate") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_DISCONNECT_FAILURE_VALVE_OR_LOAD_SWITCH,  0x81C0, "Supply Disconnect Failure (Valve or Load Switch)") \
    XXX(GBCS_GBZ_ALERT_TERMINAL_COVER_CLOSED,                           0x81C1, "Terminal Cover Closed") \
    XXX(GBCS_GBZ_ALERT_TILT_TAMPER_ENDED,                               0x81C2, "Tilt Tamper Ended") \
    XXX(GBCS_GBZ_ALERT_TILT_TAMPER,                                     0x81C3, "Tilt Tamper") \
    XXX(GBCS_GBZ_ALERT_UTRN_MANUAL_ENTRY_SUSPENDED,                     0x81C4, "UTRN Manual Entry Suspended") \
    XXX(GBCS_GBZ_ALERT_UTRN_REJECTED_AS_LOCKED_OUT,                     0x81C5, "UTRN rejected as locked out") \
    XXX(GBCS_GBZ_ALERT_CLOCK_NOT_ADJUSTED_OUTSIDE_TOLERANCE,            0x81C6, "Clock not adjusted (outside tolerance)") \
    XXX(GBCS_GBZ_ALERT_ACTIVE_POWER_IMPORT_ABOVE_LOAD_LIMIT_THRESHOLD,  0x8F01, "Active Power Import above Load Limit Threshold") \
    XXX(GBCS_GBZ_ALERT_BILLING_DATA_LOG_UPDATED,                        0x8F0A, "Billing Data Log Updated") \
    XXX(GBCS_GBZ_ALERT_CLOCK_NOT_ADJUSTED_ADJUSTMENT_GREATER_THAN_10_SE,0x8F0C, "Clock not adjusted (adjustment greater than 10 seconds)") \
    XXX(GBCS_GBZ_ALERT_CREDIT_BELOW_DISABLEMENT_THRESHOLD_PREPAYMENT_MO,0x8F0F, "Credit Below Disablement Threshold (prepayment mode)") \
    XXX(GBCS_GBZ_ALERT_CHF_DEVICE_LOG_CHANGED,                          0x8F12, "CHF Device Log Changed") \
    XXX(GBCS_GBZ_ALERT_FIRMWARE_VERIFICATION_FAILED_AT_POWER_ON,        0x8F1B, "Firmware Verification Failed At Power On") \
    XXX(GBCS_GBZ_ALERT_FIRMWARE_VERIFICATION_FAILED,                    0x8F1C, "Firmware Verification Failed") \
    XXX(GBCS_GBZ_ALERT_GSME_POWER_SUPPLY_LOSS,                          0x8F1D, "GSME Power Supply Loss") \
    XXX(GBCS_GBZ_ALERT_INTEGRITY_CHECK_OF_CONTENT_OR_FORMAT_OF_COMMAND, 0x8F1E, "Integrity check of content or format of command failed") \
    XXX(GBCS_GBZ_ALERT_LOW_BATTERY_CAPACITY,                            0x8F1F, "Low Battery Capacity") \
    XXX(GBCS_GBZ_ALERT_LIMITED_DUTY_CYCLE_ACTION_TAKEN,                 0x8F20, "Limited Duty Cycle Action Taken") \
    XXX(GBCS_GBZ_ALERT_DUTY_CYCLE_FALL_BELOW_NORMAL_LIMITED,            0x8F21, "Duty Cycle fallen below Normal-Limited Duty Cycle Threshold") \
    XXX(GBCS_GBZ_ALERT_CRITICAL_DUTY_CYCLE_ACTION_TAKEN,                0x8F22, "Critical Duty Cycle Action Taken") \
    XXX(GBCS_GBZ_ALERT_DUTY_CYCLE_FALL_BELOW_LIMITED_CRITICAL,          0x8F23, "Duty Cycle fallen below Limited-Critical Duty Cycle Threshold") \
    XXX(GBCS_GBZ_ALERT_REGULATED_DUTY_CYCLE_ACTION_TAKEN,               0x8F24, "Regulated Duty Cycle Action Taken") \
    XXX(GBCS_GBZ_ALERT_DUTY_CYCLE_FALL_BELOW_CRITICAL_REGULATED,        0x8F25, "Duty Cycle fallen below Critical-Regulated Duty Cycle Threshold") \
    XXX(GBCS_GBZ_ALERT_SUB_GHZ_CHANNEL_CHANGED,                         0x8F26, "Sub GHz Channel Changed") \
    XXX(GBCS_GBZ_ALERT_SUB_GHZ_CHANNEL_SCAN_INITIATED,                  0x8F27, "Sub GHz Channel Scan initiated") \
    XXX(GBCS_GBZ_ALERT_SUB_GHZ_CHANNEL_SCAN_REQUEST_ASSESSMENT_OUTCOME, 0x8F28, "Sub GHz Channel Scan Request Assessment Outcome") \
    XXX(GBCS_GBZ_ALERT_THREE_LOST_GSME_SEARCHES_FAILED,                 0x8F29, "Three Lost GSME Searches Failed") \
    XXX(GBCS_GBZ_ALERT_SUB_GHZ_CONFIGURATION_CHANGED,                   0x8F2A, "Sub GHz Configuration Changed") \
    XXX(GBCS_GBZ_ALERT_SUB_GHZ_CHANNEL_NOT_CHANGED_DUE_TO_FREQUENCY_AGI,0x8F2B, "Sub GHz Channel not changed due to Frequency Agility Parameters") \
    XXX(GBCS_GBZ_ALERT_MESSAGE_DISCARDED_DUE_TO_DUTY_CYCLE_MANAGEMENT,  0x8F2C, "Message Discarded Due to Duty Cycle Management") \
    XXX(GBCS_GBZ_ALERT_NO_MORE_SUB_GHZ_DEVICE_CAPACITY,                 0x8F2D, "No More Sub GHz Device Capacity") \
    XXX(GBCS_GBZ_ALERT_SOURCE_DOES_NOT_HAVE_AUTHORITY_FOR_COMMAND,      0x8F30, "Source Does not have Authority for Command") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_ARMED,                                    0x8F32, "Supply Armed") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_DISABLED_THEN_ARMED_LOAD_LIMIT_TRIGGERED, 0x8F33, "Supply Disabled then Armed - Load Limit triggered") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_ENABLED_AFTER_LOAD_LIMIT_RESTORATION_PERI,0x8F34, "Supply Enabled after Load Limit Restoration Period (Load Limit triggered)") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_OUTAGE_RESTORED,                          0x8F35, "Supply Outage Restored") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_OUTAGE_RESTORED_OUTAGE_3_MINUTES,         0x8F36, "Supply Outage Restored - Outage >= 3 minutes") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_OUTAGE_RESTORED_ON_PHASE_1,               0x8F37, "Supply Outage Restored on Phase 1") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_OUTAGE_RESTORED_ON_PHASE_1_RESTORED_OUTAG,0x8F38, "Supply Outage Restored on Phase 1 Restored - Outage >= 3 minutes") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_OUTAGE_RESTORED_ON_PHASE_2_RESTORED,      0x8F39, "Supply Outage Restored on Phase 2 Restored") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_OUTAGE_RESTORED_ON_PHASE_2_RESTORED_OUTAG,0x8F3A, "Supply Outage Restored on Phase 2 Restored - Outage >= 3 minutes") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_OUTAGE_RESTORED_ON_PHASE_3_RESTORED,      0x8F3B, "Supply Outage Restored on Phase 3 Restored") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_OUTAGE_RESTORED_ON_PHASE_3_RESTORED_OUTAG,0x8F3C, "Supply Outage Restored on Phase 3 Restored - Outage >= 3 minutes") \
    XXX(GBCS_GBZ_ALERT_TRUSTED_SOURCE_AUTHENTICATION_FAILURE,           0x8F3D, "Trusted Source Authentication Failure") \
    XXX(GBCS_GBZ_ALERT_UNAUTHORISED_COMMUNICATION_ACCESS_ATTEMPTED,     0x8F3E, "Unauthorised Communication Access attempted") \
    XXX(GBCS_GBZ_ALERT_UNAUTHORISED_PHYSICAL_ACCESS_TAMPER_DETECT,      0x8F3F, "Unauthorised Physical Access - Tamper Detect") \
    XXX(GBCS_GBZ_ALERT_CHANGE_IN_THE_EXECUTING_FIRMWARE_VERSION,        0x8F43, "Change in the executing Firmware version") \
    XXX(GBCS_GBZ_ALERT_CREDIT_WOULD_CAUSE_METER_BALANCE_TO_EXCEED_MAXIM,0x8F47, "Credit would cause Meter Balance to exceed  Maximum Meter Balance Threshold") \
    XXX(GBCS_GBZ_ALERT_DEVICE_JOINING_FAILED,                           0x8F48, "Device joining failed") \
    XXX(GBCS_GBZ_ALERT_DEVICE_JOINING_SUCCEEDED,                        0x8F49, "Device joining succeeded ") \
    XXX(GBCS_GBZ_ALERT_DEVICE_UNJOINING_FAILED,                         0x8F4A, "Device Unjoining failed ") \
    XXX(GBCS_GBZ_ALERT_DEVICE_UNJOINING_SUCCEEDED,                      0x8F4B, "Device Unjoining succeeded ") \
    XXX(GBCS_GBZ_ALERT_DEVICE_OWN_DIGITAL_SIGNING_CERT_REPLACEME_FAILED,0x8F4C, "Device's own Digital Signing Certificate replacement failed") \
    XXX(GBCS_GBZ_ALERT_DEVICE_OWN_DIGITAL_SIGNING_CERT_REPLACEME_SUCCES,0x8F4D, "Device's own Digital Signing Certificate replacement succeeded") \
    XXX(GBCS_GBZ_ALERT_DEVICE_OWN_KEY_AGREEMENT_CERTIFICATE_REP_FAILED, 0x8F4E, "Device's own Key Agreement Certificate replacement failed") \
    XXX(GBCS_GBZ_ALERT_DEVICE_OWN_KEY_AGREEMENT_CERTIFICATE_REP_SUCCEED,0x8F4F, "Device's own Key Agreement Certificate replacement succeeded") \
    XXX(GBCS_GBZ_ALERT_DUPLICATE_UTRN_ENTERED,                          0x8F51, "Duplicate UTRN entered") \
    XXX(GBCS_GBZ_ALERT_EVENT_LOG_CLEARED,                               0x8F52, "Event Log Cleared") \
    XXX(GBCS_GBZ_ALERT_FAILED_AUTHENTICATION_OR_AUTHORISATION_NOT_COVER,0x8F53, "Failed Authentication or Authorisation not covered by other codes") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_INTERRUPTED,                              0x8F57, "Supply interrupted") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_INTERRUPTED_ON_PHASE_1,                   0x8F58, "Supply interrupted on Phase 1") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_INTERRUPTED_ON_PHASE_2,                   0x8F59, "Supply interrupted on Phase 2") \
    XXX(GBCS_GBZ_ALERT_SUPPLY_INTERRUPTED_ON_PHASE_3,                   0x8F5A, "Supply interrupted on Phase 3") \
    XXX(GBCS_GBZ_ALERT_UTRN_EXCEEDS_MAXIMUM_CREDIT_THRESHOLD,           0x8F5B, "UTRN exceeds Maximum Credit Threshold") \
    XXX(GBCS_GBZ_ALERT_UNUSUAL_NUMBERS_OF_MALFORMED_OUT_OF_ORDER_OR_UNE,0x8F60, "Unusual numbers of malformed, out-of-order or unexpected Commands received") \
    XXX(GBCS_GBZ_ALERT_UTRN_NOT_AUTHENTIC,                              0x8F63, "UTRN not Authentic") \
    XXX(GBCS_GBZ_ALERT_UTRN_NOT_FOR_THIS_DEVICE,                        0x8F64, "UTRN not for this Device") \
    XXX(GBCS_GBZ_ALERT_FUTURE_DATE_HAN_INTERFACE_CMD_SUCCESS_ACTIONED,  0x8F66, "Future date HAN Interface Command Successfully Actioned") \
    XXX(GBCS_GBZ_ALERT_FUTURE_DATE_HAN_INTERFACE_CMD_NOT_SUCCESS_ACTION,0x8F67, "Future date HAN Interface Command not Successfully Actioned") \
    XXX(GBCS_GBZ_ALERT_DEVICE_COMMISSIONED,                             0x8F69, "Device commissioned") \
    XXX(GBCS_GBZ_ALERT_UPDATE_SECURITY_CREDENTIALS,                     0x8F70, "Update Security Credentials") \
    XXX(GBCS_GBZ_ALERT_FIRMWARE_VERIFICATION_SUCCESSFUL,                0x8F72, "Firmware Verification Successful") \
    XXX(GBCS_GBZ_ALERT_UNAUTHORISED_PHYSICAL_ACCESS_BATTERY_COVER_REMOV,0x8F73, "Unauthorised Physical Access - Battery Cover Removed") \
    XXX(GBCS_GBZ_ALERT_UNAUTHORISED_PHYSICAL_ACCESS_METER_COVER_REMOVED,0x8F74, "Unauthorised Physical Access - Meter Cover Removed") \
    XXX(GBCS_GBZ_ALERT_UNAUTHORISED_PHYSICAL_ACCESS_STRONG_MAGNETIC_FIE,0x8F75, "Unauthorised Physical Access - Strong Magnetic field") \
    XXX(GBCS_GBZ_ALERT_UNAUTHORISED_PHYSICAL_ACCESS_TERMINAL_COVER_REMO,0x8F76, "Unauthorised Physical Access - Terminal Cover Removed") \
    XXX(GBCS_GBZ_ALERT_UNAUTHORISED_PHYSICAL_ACCESS_SECOND_TERMINAL_COV,0x8F77, "Unauthorised Physical Access - Second Terminal Cover Removed") \
    XXX(GBCS_GBZ_ALERT_UNAUTHORISED_PHYSICAL_ACCESS_OTHER,              0x8F78, "Unauthorised Physical Access - Other") \
    XXX(GBCS_GBZ_ALERT_REMAINING_BATTERY_CAPACITY_RESET,                0x8F82, "Remaining Battery Capacity reset") \
    XXX(GBCS_GBZ_ALERT_DISABLEMENT_OF_SUPPLY_INS_CREDIT_SUSPENDED,      0x8F83, "Disablement of Supply due to insufficient credit has been suspended") \
    XXX(GBCS_GBZ_ALERT_FAILURE_TO_DELIVER_REMOTE_PARTY_MESSAGE_TO_ESME, 0x8F84, "Failure to Deliver Remote Party Message to ESME")

VALUE_STRING_ENUM(gbcs_gbz_alert_code_names);
VALUE_STRING_ARRAY(gbcs_gbz_alert_code_names);
static value_string_ext gbcs_gbz_alert_code_names_ext = VALUE_STRING_EXT_INIT(gbcs_gbz_alert_code_names);

#define gbcs_gbz_integrity_issue_warning_names_VALUE_STRING_LIST(XXX) \
    XXX(GBCS_GBZ_INTEGRITY_ISSUE_WARNING_OTHER,                         0x0000, "Other" ) \
    XXX(GBCS_GBZ_INTEGRITY_ISSUE_WARNING_ERROR_NON_VOLATILE_MEMORY,     0x0001, "Error Non Volatile Memory" ) \
    XXX(GBCS_GBZ_INTEGRITY_ISSUE_WARNING_ERROR_PROGRAM_EXECUTION,       0x0002, "Error Program Execution" ) \
    XXX(GBCS_GBZ_INTEGRITY_ISSUE_WARNING_ERROR_PROGRAM_STORAGE,         0x0003, "Error Program Storage" ) \
    XXX(GBCS_GBZ_INTEGRITY_ISSUE_WARNING_ERROR_RAM,                     0x0004, "Error RAM" ) \
    XXX(GBCS_GBZ_INTEGRITY_ISSUE_WARNING_ERROR_UNEXPECTED_HW_RESET,     0x0005, "Error Unexpected Hardware Reset" ) \
    XXX(GBCS_GBZ_INTEGRITY_ISSUE_WARNING_ERROR_WATCHDOG,                0x0006, "Error Watchdog" ) \
    XXX(GBCS_GBZ_INTEGRITY_ISSUE_WARNING_ERROR_MET_FW_VERIFICATION_FAIL,0x0007, "Error Metrology Firmware Verification Failure" ) \
    XXX(GBCS_GBZ_INTEGRITY_ISSUE_WARNING_ERROR_MEASUREMENT_FAULT,       0x0008, "Error Measurement Fault" ) \
    XXX(GBCS_GBZ_INTEGRITY_ISSUE_WARNING_UNSPEC_SMART_METER_OP_INT_ERR, 0x0009, "Unspecified Smart Meter Operational Integrity Error" )

VALUE_STRING_ENUM(gbcs_gbz_integrity_issue_warning_names);
VALUE_STRING_ARRAY(gbcs_gbz_integrity_issue_warning_names);

static dissector_handle_t zcl_handle;

static int proto_gbcs_gbz = -1;

static int hf_gbcs_gbz_profile_id = -1;
static int hf_gbcs_gbz_components = -1;
static int hf_gbcs_gbz_extended_header_control = -1;
static int hf_gbcs_gbz_extended_header_cluster = -1;
static int hf_gbcs_gbz_extended_header_length = -1;
static int hf_gbcs_gbz_alert_code = -1;
static int hf_gbcs_gbz_timestamp = -1;
static int hf_gbcs_gbz_firmware_alert_start = -1;
static int hf_gbcs_gbz_firmware_hash = -1;
static int hf_gbcs_gbz_future_alert_start = -1;
static int hf_gbcs_gbz_message_code = -1;
static int hf_gbcs_gbz_originator_counter = -1;
static int hf_gbcs_gbz_frame_control = -1;
static int hf_gbcs_gbz_command_id = -1;
static int hf_gbcs_gbz_integrity_issue_warning = -1;
static int hf_gbcs_gbz_from_date_time = -1;
static int hf_gbcs_gbz_additional_header_control = -1;
static int hf_gbcs_gbz_additional_frame_counter = -1;
static int hf_gbcs_gbz_transaction = -1;
static int hf_gbcs_gbz_length_of_ciphered_information = -1;
static int hf_gbcs_gbz_security_control = -1;
static int hf_gbcs_gbz_invocation_counter = -1;
static int hf_gbcs_gbz_encrypted_payload = -1;
static int hf_gbcs_gbz_mac = -1;

static gint ett_gbcs_gbz = -1;
static gint ett_gbcs_gbz_components[GBCS_GBZ_MAX_COMPONENTS];

static expert_field ei_gbcs_gbz_invalid_length = EI_INIT;

void proto_register_gbcs_gbz(void);
void proto_reg_handoff_gbcs_gbz(void);

static void dissect_gbcs_gbz_component(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint *offset, guint component_index)
{
    proto_item *ti;
    proto_tree *component_tree;
    guint32 component_len;
    guint32 cluster;
    gboolean fromdatetime_present;
    gboolean encryption_present;
    guint32 extended_header_control;

    if (component_index > GBCS_GBZ_MAX_COMPONENTS - 1) {
        component_index = GBCS_GBZ_MAX_COMPONENTS - 1;
    }

    component_tree = proto_tree_add_subtree(tree, tvb, *offset, 1, ett_gbcs_gbz_components[component_index], &ti, "Use Case Component");

    proto_tree_add_item_ret_uint(component_tree, hf_gbcs_gbz_extended_header_control, tvb, *offset, 1, ENC_NA, &extended_header_control);
    fromdatetime_present = extended_header_control & GBCS_GBZ_EXTENDED_HEADER_CONTROL_FROM_DATE_TIME_PRESENT;
    encryption_present = extended_header_control & GBCS_GBZ_EXTENDED_HEADER_CONTROL_ENCRYPTED_COMPONENT;
    *offset += 1;

    proto_tree_add_item_ret_uint(component_tree, hf_gbcs_gbz_extended_header_cluster, tvb, *offset, 2, ENC_BIG_ENDIAN, &cluster);
    *offset += 2;

    proto_tree_add_item_ret_uint(component_tree, hf_gbcs_gbz_extended_header_length, tvb, *offset, 2, ENC_BIG_ENDIAN, &component_len);
    *offset += 2;

    if ((gint)component_len > tvb_reported_length_remaining(tvb, *offset)) {
        expert_add_info(pinfo, tree, &ei_gbcs_gbz_invalid_length);
    }

    if (fromdatetime_present) {
        nstime_t timestamp;

        timestamp.secs = (time_t)tvb_get_ntohl(tvb, *offset) + ZBEE_ZCL_NSTIME_UTC_OFFSET;
        timestamp.nsecs = 0;
        proto_tree_add_time(component_tree, hf_gbcs_gbz_from_date_time, tvb, *offset, 4, &timestamp);
        *offset += 4;
        component_len -= 4;
    }
    if (encryption_present) {
        proto_tree_add_item(component_tree, hf_gbcs_gbz_additional_header_control, tvb, *offset, 1, ENC_NA);
        *offset += 1;
        component_len -= 1;

        proto_tree_add_item(component_tree, hf_gbcs_gbz_additional_frame_counter, tvb, *offset, 1, ENC_NA);
        *offset += 1;
        component_len -= 1;
    }
    proto_tree_add_item(component_tree, hf_gbcs_gbz_frame_control, tvb, *offset, 1, ENC_NA);
    *offset += 1;
    component_len -= 1;

    proto_tree_add_item(component_tree, hf_gbcs_gbz_transaction, tvb, *offset, 1, ENC_NA);
    *offset += 1;
    component_len -= 1;

    proto_tree_add_item(component_tree, hf_gbcs_gbz_command_id, tvb, *offset, 1, ENC_NA);
    *offset += 1;
    component_len -= 1;

    if (encryption_present) {
        proto_tree_add_item(component_tree, hf_gbcs_gbz_length_of_ciphered_information, tvb, *offset, 2, ENC_BIG_ENDIAN);
        *offset += 2;
        component_len -= 2;

        proto_tree_add_item(component_tree, hf_gbcs_gbz_security_control, tvb, *offset, 1, ENC_NA);
        *offset += 1;
        component_len -= 1;

        proto_tree_add_item(component_tree, hf_gbcs_gbz_invocation_counter, tvb, *offset, 4, ENC_BIG_ENDIAN);
        *offset += 4;
        component_len -= 4;

        if (component_len < GBCS_GBZ_MAC_LENGTH) {
            expert_add_info(pinfo, tree, &ei_gbcs_gbz_invalid_length);
        }

        proto_tree_add_item(component_tree, hf_gbcs_gbz_encrypted_payload, tvb, *offset, component_len - GBCS_GBZ_MAC_LENGTH, ENC_NA);
        *offset += component_len - GBCS_GBZ_MAC_LENGTH;

        proto_tree_add_item(component_tree, hf_gbcs_gbz_mac, tvb, *offset, GBCS_GBZ_MAC_LENGTH, ENC_NA);
        *offset += GBCS_GBZ_MAC_LENGTH;
    }
    else if (zcl_handle) {
        zbee_nwk_packet nwk;
        tvbuff_t *payload_tvb;
        const gchar *text;
        wmem_strbuf_t *strbuf;

        text = col_get_text(pinfo->cinfo, COL_INFO);
        if (text) {
            strbuf = wmem_strbuf_new(wmem_packet_scope(), text);
        }
        nwk.cluster_id = cluster;
        payload_tvb = tvb_new_subset_length(tvb, *offset - 3, component_len + 3);
        call_dissector_with_data(zcl_handle, payload_tvb, pinfo, component_tree, &nwk);
        if (text) {
            col_add_str(pinfo->cinfo, COL_INFO, wmem_strbuf_get_str(strbuf));
        }
        *offset += component_len;
    }
    proto_item_set_end(ti, tvb, *offset);
}

static int dissect_gbcs_gbz(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
{
    proto_item *ti;
    proto_tree *gbz_tree;
    guint offset = 0;
    guint8 cra = *(guint8*)data;

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "GBCS GBZ");

    ti = proto_tree_add_item(tree, proto_gbcs_gbz, tvb, 0, -1, ENC_NA);
    gbz_tree = proto_item_add_subtree(ti, ett_gbcs_gbz);

    proto_tree_add_item(gbz_tree, hf_gbcs_gbz_profile_id, tvb, offset, 2, ENC_BIG_ENDIAN);
    offset += 2;

    proto_tree_add_item(gbz_tree, hf_gbcs_gbz_components, tvb, offset, 1, ENC_NA);
    offset += 1;

    if (cra == GBCS_MESSAGE_CRA_ALERT) {
        nstime_t timestamp;
        guint32 alert_code;

        proto_tree_add_item_ret_uint(gbz_tree, hf_gbcs_gbz_alert_code, tvb, offset, 2, ENC_BIG_ENDIAN, &alert_code);
        col_append_sep_str(pinfo->cinfo, COL_INFO, NULL, val_to_str_ext_const(alert_code, &gbcs_gbz_alert_code_names_ext, "Unknown alert"));
        offset += 2;

        timestamp.secs = (time_t)tvb_get_ntohl(tvb, offset) + ZBEE_ZCL_NSTIME_UTC_OFFSET;
        timestamp.nsecs = 0;
        proto_tree_add_time(gbz_tree, hf_gbcs_gbz_timestamp, tvb, offset, 4, &timestamp);
        offset += 4;

        switch (alert_code) {
        case GBCS_GBZ_ALERT_FIRMWARE_VERIFICATION_FAILED:
        case GBCS_GBZ_ALERT_FIRMWARE_VERIFICATION_SUCCESSFUL:
            proto_tree_add_item(gbz_tree, hf_gbcs_gbz_firmware_alert_start, tvb, offset, 2, ENC_BIG_ENDIAN);
            offset += 2;

            proto_tree_add_item(gbz_tree, hf_gbcs_gbz_firmware_hash, tvb, offset, 32, ENC_NA);
            offset += 32;
            break;
        case GBCS_GBZ_ALERT_FUTURE_DATE_HAN_INTERFACE_CMD_SUCCESS_ACTIONED:
        case GBCS_GBZ_ALERT_FUTURE_DATE_HAN_INTERFACE_CMD_NOT_SUCCESS_ACTION:
            if (tvb_get_guint8(tvb, offset) == 0x0E) {
                proto_tree_add_item(gbz_tree, hf_gbcs_gbz_future_alert_start, tvb, offset, 1, ENC_NA);
                offset += 1;

                proto_tree_add_item(gbz_tree, hf_gbcs_gbz_message_code, tvb, offset, 2, ENC_BIG_ENDIAN);
                offset += 2;

                proto_tree_add_item(gbz_tree, hf_gbcs_gbz_originator_counter, tvb, offset, 8, ENC_BIG_ENDIAN);
                offset += 8;

                proto_tree_add_item(gbz_tree, hf_gbcs_gbz_extended_header_cluster, tvb, offset, 2, ENC_BIG_ENDIAN);
                offset += 2;

                proto_tree_add_item(gbz_tree, hf_gbcs_gbz_frame_control, tvb, offset, 1, ENC_NA);
                offset += 1;

                proto_tree_add_item(gbz_tree, hf_gbcs_gbz_command_id, tvb, offset, 1, ENC_NA);
                offset += 1;
            }
            break;
        case GBCS_GBZ_ALERT_BILLING_DATA_LOG_UPDATED:
            dissect_gbcs_gbz_component(tvb, pinfo, gbz_tree, &offset, 0);
            break;
        case GBCS_GBZ_ALERT_SMART_METER_INTEGRITY_ISSUE_WARNING:
            proto_tree_add_item(gbz_tree, hf_gbcs_gbz_integrity_issue_warning, tvb, offset, 2, ENC_BIG_ENDIAN);
            offset += 2;
            break;
        default:
            break;
        }
    }
    else {
        guint component_index = 0;

        while (tvb_reported_length_remaining(tvb, offset) > 0) {
            dissect_gbcs_gbz_component(tvb, pinfo, gbz_tree, &offset, component_index++);
        }
    }

    return tvb_captured_length(tvb);
}

void proto_register_gbcs_gbz(void)
{
    static hf_register_info hf[] = {
        {&hf_gbcs_gbz_profile_id,
            {"Profile ID", "gbcs_gbz.profile_id",
             FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_components,
            {"Total number of GBZ Use Case Specific Component(s)", "gbcs_gbz.components",
              FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_extended_header_control,
            {"Extended Header Control Field", "gbcs_gbz.extended_header_control",
              FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_extended_header_cluster,
            {"Extended Header Cluster ID", "gbcs_gbz.extended_header_cluster",
              FT_UINT16, BASE_HEX | BASE_RANGE_STRING, RVALS(zbee_aps_cid_names), 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_extended_header_length,
            {"Extended Header Length", "gbcs_gbz.extended_header_length",
              FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_alert_code,
            {"Alert Code", "gbcs_gbz.alert_code",
              FT_UINT16, BASE_HEX | BASE_EXT_STRING, &gbcs_gbz_alert_code_names_ext, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_timestamp,
            {"Timestamp", "gbcs_gbz.timestamp",
             FT_ABSOLUTE_TIME, ABSOLUTE_TIME_UTC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_firmware_alert_start,
            {"Firmware Alert Start", "gbcs_gbz.firmware_alert_start",
             FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_firmware_hash,
            {"Calculated Manufacture Image Hash", "gbcs_gbz.firmware_hash",
             FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_future_alert_start,
            {"Future Dated Command Alert Start", "gbcs_gbz.future_alert_start",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_message_code,
            {"Message Code", "gbcs_gbz.message_code",
             FT_UINT16, BASE_HEX | BASE_EXT_STRING, &gbcs_message_code_names_ext, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_originator_counter,
            {"Originator Counter", "gbcs_gbz.originator_counter",
             FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_frame_control,
            {"Frame Control", "gbcs_gbz.frame_control",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_command_id,
            {"Command Identifier", "gbcs_gbz.command_id",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_integrity_issue_warning,
            {"Integrity Issue Warning", "gbcs_gbz.integrity_issue_warning",
             FT_UINT16, BASE_HEX, VALS(gbcs_gbz_integrity_issue_warning_names), 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_from_date_time,
            {"From Date Time", "gbcs_gbz.from_date_time",
             FT_ABSOLUTE_TIME, ABSOLUTE_TIME_UTC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_additional_header_control,
            {"Additional Header Control", "gbcs_gbz.additional_header_control",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_additional_frame_counter,
            {"Additional Header Frame Counter", "gbcs_gbz.additional_frame_counter",
             FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_transaction,
            {"Transaction Sequence Number", "gbcs_gbz.transaction",
             FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_length_of_ciphered_information,
            {"Length of Ciphered Information", "gbcs_gbz.length_of_ciphered_information",
             FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_security_control,
            {"Security Control", "gbcs_gbz.security_control",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_invocation_counter,
            {"Invocation Counter", "gbcs_gbz.invocation_counter",
             FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_encrypted_payload,
            {"Encrypted ZCL Payload", "gbcs_gbz.encrypted_payload",
             FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_gbz_mac,
            {"Encrypted ZCL MAC", "gbcs_gbz.mac",
             FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}
        }
    };

    static gint *ett[1 + GBCS_GBZ_MAX_COMPONENTS];

    gint j = 0;
    ett[j++] = &ett_gbcs_gbz;
    for (gint i = 0; i < GBCS_GBZ_MAX_COMPONENTS; i++, j++) {
        ett_gbcs_gbz_components[i] = -1;
        ett[j] = &ett_gbcs_gbz_components[i];
    }

    expert_module_t* expert_gbcs_gbz;
    static ei_register_info ei[] = {
        { &ei_gbcs_gbz_invalid_length,
            { "gbcs_gbz.invalid_length", PI_PROTOCOL, PI_WARN, "Invalid length", EXPFILL }}
    };

    proto_gbcs_gbz = proto_register_protocol("GBCS GBZ", "GBCS GBZ", "gbcs_gbz");
    register_dissector("gbcs_gbz", dissect_gbcs_gbz, proto_gbcs_gbz);
    proto_register_field_array(proto_gbcs_gbz, hf, array_length(hf));
    proto_register_subtree_array(ett, array_length(ett));

    expert_gbcs_gbz = expert_register_protocol(proto_gbcs_gbz);
    expert_register_field_array(expert_gbcs_gbz, ei, array_length(ei));
}

void proto_reg_handoff_gbcs_gbz(void)
{
    zcl_handle = find_dissector(ZBEE_PROTOABBREV_ZCL);
}

/* ########################################################################## */
/* #### GBCS Tunnel ######################################################### */
/* ########################################################################## */

#define gbcs_tunnel_command_names_VALUE_STRING_LIST(XXX) \
    XXX(GBCS_TUNNEL_COMMAND_GET,                                0x01, "GET" ) \
    XXX(GBCS_TUNNEL_COMMAND_GET_RESPONSE,                       0x02, "GET-RESPONSE" ) \
    XXX(GBCS_TUNNEL_COMMAND_PUT,                                0x03, "PUT" )

VALUE_STRING_ENUM(gbcs_tunnel_command_names);
VALUE_STRING_ARRAY(gbcs_tunnel_command_names);

static dissector_handle_t gbcs_message_handle;

static int proto_gbcs_tunnel = -1;

static int hf_gbcs_tunnel_command = -1;
static int hf_gbcs_tunnel_remaining = -1;

static gint ett_gbcs_tunnel = -1;

void proto_register_gbcs_tunnel(void);
void proto_reg_handoff_gbcs_tunnel(void);

static int dissect_gbcs_tunnel(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
{
    guint offset = 0;
    guint8 command;

    command = tvb_get_guint8(tvb, offset);
    switch (command) {
        case GBCS_TUNNEL_COMMAND_GET:
        case GBCS_TUNNEL_COMMAND_GET_RESPONSE:
        case GBCS_TUNNEL_COMMAND_PUT: {
            proto_item *ti;
            proto_tree *tunnel_tree;

            col_set_str(pinfo->cinfo, COL_PROTOCOL, "GBCS Tunnel");

            ti = proto_tree_add_item(tree, proto_gbcs_tunnel, tvb, offset, -1, ENC_NA);
            tunnel_tree = proto_item_add_subtree(ti, ett_gbcs_tunnel);

            col_set_str(pinfo->cinfo, COL_INFO, val_to_str_const(command, gbcs_tunnel_command_names, "Unknown Command"));
            proto_tree_add_item(tunnel_tree, hf_gbcs_tunnel_command, tvb, offset, 1, ENC_NA);
            offset += 1;

            if (command == GBCS_TUNNEL_COMMAND_GET_RESPONSE) {
                proto_tree_add_item(tunnel_tree, hf_gbcs_tunnel_remaining, tvb, offset, 1, ENC_NA);
                offset += 1;
            }
            break;
        }

        default:
            /* No tunnel header */
            col_clear(pinfo->cinfo, COL_INFO);
            break;
    }

    if (command != GBCS_TUNNEL_COMMAND_GET && tvb_reported_length_remaining(tvb, offset) > 0) {
        tvbuff_t *payload_tvb = tvb_new_subset_remaining(tvb, offset);

        if (gbcs_message_handle != NULL) {
            call_dissector_with_data(gbcs_message_handle, payload_tvb, pinfo, tree, NULL);
        }
        else {
            call_data_dissector(payload_tvb, pinfo, tree);
        }
    }

    return tvb_captured_length(tvb);
}

static gboolean
dissect_gbcs_tunnel_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data)
{
    switch (tvb_get_guint8(tvb, 0)) {
        case GBCS_TUNNEL_COMMAND_GET:
        case GBCS_TUNNEL_COMMAND_PUT:
        case GBCS_TUNNEL_COMMAND_GET_RESPONSE:
        case 0xDD:
        case 0xDF:
            dissect_gbcs_tunnel(tvb, pinfo, tree, data);
            return TRUE;

        default:
            return FALSE;
    }
}

void proto_register_gbcs_tunnel(void)
{
    static hf_register_info hf[] = {
        {&hf_gbcs_tunnel_command,
            {"Transfer data command", "gbcs_tunnel.command",
             FT_UINT8, BASE_HEX, VALS(gbcs_tunnel_command_names), 0x0, NULL, HFILL}
        },
        {&hf_gbcs_tunnel_remaining,
            {"Remaining messages", "gbcs_tunnel.remaining",
             FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
        }
    };

    static gint *ett[] = {
        &ett_gbcs_tunnel,
    };

    proto_gbcs_tunnel = proto_register_protocol("GBCS Tunnel", "GBCS Tunnel", "gbcs_tunnel");
    register_dissector("gbcs_tunnel", dissect_gbcs_tunnel, proto_gbcs_tunnel);
    proto_register_field_array(proto_gbcs_tunnel, hf, array_length(hf));
    proto_register_subtree_array(ett, array_length(ett));
}

void proto_reg_handoff_gbcs_tunnel(void)
{
    gbcs_message_handle = find_dissector("gbcs_message");
    heur_dissector_add("zbee_zcl_se.tun", dissect_gbcs_tunnel_heur, "GBCS over ZigBee SE Tunneling", "gbcs_zbee_zcl_se.tun", proto_gbcs_tunnel, HEURISTIC_ENABLE);
}

/* ########################################################################## */
/* #### GBCS Message ######################################################### */
/* ########################################################################## */

#define GBCS_MESSAGE_GENERAL_CIPHERING                          0xDD
#define GBCS_MESSAGE_GENERAL_SIGNING                            0xDF
#define GBCS_MESSAGE_ACCESS_REQUEST                             0xD9
#define GBCS_MESSAGE_ACCESS_RESPONSE                            0xDA
#define GBCS_MESSAGE_DATA_NOTIFICATION                          0x0F
#define GBCS_MESSAGE_GENERAL_BLOCK_TRANSFER                     0xE0

#define GBCS_MESSAGE_TRANSACTION_ID_LENGTH                      9
#define GBCS_MESSAGE_DLMS_DATE_TIME_LENGTH                      12
#define GBCS_MESSAGE_KRP_LENGTH                                 64
#define GBCS_MESSAGE_MAC_LENGTH                                 12

#define GBCS_MESSAGE_GBT_BLOCK_CONTROL_LAST_BLOCK               0x80
#define GBCS_MESSAGE_GBT_BLOCK_CONTROL_STREAMING                0x40
#define GBCS_MESSAGE_GBT_BLOCK_CONTROL_WINDOW                   0x3F

static dissector_handle_t gbcs_gbcs_handle;
static dissector_handle_t gbcs_gbz_handle;
static dissector_handle_t gbcs_ber_handle;

static int proto_gbcs_message = -1;

static int hf_gbcs_message_element_length = -1;
static int hf_gbcs_message_mac_header_general_ciphering = -1;
static int hf_gbcs_message_mac_header_cra_flag = -1;
static int hf_gbcs_message_mac_header_originator_counter = -1;
static int hf_gbcs_message_mac_header_business_originator_id = -1;
static int hf_gbcs_message_mac_header_business_target_id = -1;
static int hf_gbcs_message_mac_header_date_time = -1;
static int hf_gbcs_message_mac_header_other_info = -1;
static int hf_gbcs_message_mac_header_key_info = -1;
static int hf_gbcs_message_mac_header_security_control_byte = -1;
static int hf_gbcs_message_mac_header_invocation_counter = -1;
static int hf_gbcs_message_grouping_header_general_signing = -1;
static int hf_gbcs_message_grouping_header_cra_flag = -1;
static int hf_gbcs_message_grouping_header_originator_counter = -1;
static int hf_gbcs_message_grouping_header_business_originator_id = -1;
static int hf_gbcs_message_grouping_header_business_target_id = -1;
static int hf_gbcs_message_grouping_header_date_time = -1;
static int hf_gbcs_message_grouping_header_message_code = -1;
static int hf_gbcs_message_grouping_header_supplementary_remote_party_id = -1;
static int hf_gbcs_message_grouping_header_supplementary_remote_party_counter = -1;
static int hf_gbcs_message_grouping_header_supplementary_originator_counter = -1;
static int hf_gbcs_message_grouping_header_supplementary_remote_party_ka_certificate = -1;
static int hf_gbcs_message_krp = -1;
static int hf_gbcs_message_mac = -1;
static int hf_gbcs_message_routing_header_general_ciphering = -1;
static int hf_gbcs_message_routing_header_cra_flag = -1;
static int hf_gbcs_message_routing_header_originator_counter = -1;
static int hf_gbcs_message_routing_header_business_originator_id = -1;
static int hf_gbcs_message_routing_header_business_target_id = -1;
static int hf_gbcs_message_routing_header_date_time = -1;
static int hf_gbcs_message_routing_header_message_code = -1;
static int hf_gbcs_message_routing_header_key_info = -1;
static int hf_gbcs_message_routing_header_security_control_byte = -1;
static int hf_gbcs_message_routing_header_invocation_counter = -1;
static int hf_gbcs_message_gbt_header_general_block_transfer = -1;
static int hf_gbcs_message_gbt_header_block_control = -1;
static int hf_gbcs_message_gbt_header_block_control_last_block = -1;
static int hf_gbcs_message_gbt_header_block_control_streaming = -1;
static int hf_gbcs_message_gbt_header_block_control_window = -1;
static int hf_gbcs_message_gbt_header_block_number = -1;
static int hf_gbcs_message_gbt_header_block_number_ack = -1;
static int hf_gbcs_message_gbt_blocks = -1;
static int hf_gbcs_message_gbt_block = -1;
static int hf_gbcs_message_gbt_block_overlap = -1;
static int hf_gbcs_message_gbt_block_overlap_conflicts = -1;
static int hf_gbcs_message_gbt_block_multiple_tails = -1;
static int hf_gbcs_message_gbt_block_too_long_fragment = -1;
static int hf_gbcs_message_gbt_block_error = -1;
static int hf_gbcs_message_gbt_block_count = -1;
static int hf_gbcs_message_gbt_reassembled_in = -1;
static int hf_gbcs_message_gbt_reassembled_length = -1;

static gint ett_gbcs_message = -1;
static gint ett_gbcs_message_element = -1;
static gint ett_gbcs_message_mac_header = -1;
static gint ett_gbcs_message_grouping_header = -1;
static gint ett_gbcs_message_grouping_header_other_info = -1;
static gint ett_gbcs_message_routing_header = -1;
static gint ett_gbcs_message_routing_header_other_info = -1;
static gint ett_gbcs_message_gbt_header = -1;
static gint ett_gbcs_message_gbt_header_block_control = -1;
static gint ett_gbcs_message_gbt_fragment = -1;
static gint ett_gbcs_message_gbt_fragments = -1;
static gint ett_gbcs_message_asn1 = -1;
static gint ett_gbcs_message_dlms = -1;

static reassembly_table gbcs_message_gbt_reassembly_table;

static const fragment_items gbcs_message_gbt_frag_items = {
    /* Fragment subtrees */
    &ett_gbcs_message_gbt_fragment,
    &ett_gbcs_message_gbt_fragments,
    /* Fragment fields */
    &hf_gbcs_message_gbt_blocks,
    &hf_gbcs_message_gbt_block,
    &hf_gbcs_message_gbt_block_overlap,
    &hf_gbcs_message_gbt_block_overlap_conflicts,
    &hf_gbcs_message_gbt_block_multiple_tails,
    &hf_gbcs_message_gbt_block_too_long_fragment,
    &hf_gbcs_message_gbt_block_error,
    &hf_gbcs_message_gbt_block_count,
    /* Reassembled in field */
    &hf_gbcs_message_gbt_reassembled_in,
    /* Reassembled length field */
    &hf_gbcs_message_gbt_reassembled_length,
    /* Reassembled data field */
    NULL,
    /* Tag */
    "GBT fragments"
};

void proto_register_gbcs_message(void);
void proto_reg_handoff_gbcs_message(void);

static void
dissect_gbcs_message_element(proto_tree *tree, int hfindex, tvbuff_t *tvb, guint *offset)
{
    proto_tree *element_tree;
    proto_item *tree_ti, *value_ti;
    guint len;

    element_tree = proto_tree_add_subtree(tree, tvb, *offset, 1, ett_gbcs_message_element, &tree_ti, "");

    proto_tree_add_item_ret_uint(element_tree, hf_gbcs_message_element_length, tvb, *offset, 1, ENC_NA, &len);
    *offset += 1;

    if (len > 0) {
        value_ti = proto_tree_add_item(element_tree, hfindex, tvb, *offset, len, ENC_BIG_ENDIAN);
        if (value_ti) {
            gchar *label;

            label = (char*)wmem_alloc(wmem_packet_scope(), ITEM_LABEL_LENGTH+1);
            proto_item_fill_label(PITEM_FINFO(value_ti), label);
            proto_item_append_text(tree_ti, "%s", label);
        }
        *offset += len;
        proto_item_set_end(tree_ti, tvb, *offset);
    }
    else {
        proto_item_append_text(tree_ti, "%s: <none>", proto_registrar_get_name(hfindex));
    }
}

static void
dissect_gbcs_message_element_transaction_id(proto_tree *tree, int hfindex_cra_flag, int hfindex_originator_counter, tvbuff_t *tvb, guint *offset)
{
    proto_tree *element_tree;
    proto_item *tree_ti, *value_ti;
    guint len;

    element_tree = proto_tree_add_subtree(tree, tvb, *offset, 1, ett_gbcs_message_element, &tree_ti, "");

    proto_tree_add_item_ret_uint(element_tree, hf_gbcs_message_element_length, tvb, *offset, 1, ENC_NA, &len);
    *offset += 1;

    if (len > 0) {
        value_ti = proto_tree_add_item(element_tree, hfindex_cra_flag, tvb, *offset, 1, ENC_NA);
        if (value_ti) {
            gchar *label;

            label = (char*)wmem_alloc(wmem_packet_scope(), ITEM_LABEL_LENGTH+1);
            proto_item_fill_label(PITEM_FINFO(value_ti), label);
            label = strstr(label, ": ") + 2;
            proto_item_append_text(tree_ti, "Transaction ID: %s", label);
        }
        *offset += 1;

        value_ti = proto_tree_add_item(element_tree, hfindex_originator_counter, tvb, *offset, 8, ENC_BIG_ENDIAN);
        if (value_ti) {
            gchar *label;

            label = (char*)wmem_alloc(wmem_packet_scope(), ITEM_LABEL_LENGTH+1);
            proto_item_fill_label(PITEM_FINFO(value_ti), label);
            label = strstr(label, ": ") + 2;
            proto_item_append_text(tree_ti, ", %s", label);
        }
        *offset += 8;
        proto_item_set_end(tree_ti, tvb, *offset);
    }
    else {
        proto_item_append_text(tree_ti, "Transaction ID: <none>");
    }
}

static void
dissect_gbcs_message_element_date_time(proto_tree *tree, int hfindex, tvbuff_t *tvb, guint *offset)
{
    proto_tree *element_tree;
    proto_item *tree_ti, *value_ti;
    guint len;

    element_tree = proto_tree_add_subtree(tree, tvb, *offset, 1, ett_gbcs_message_element, &tree_ti, "");

    proto_tree_add_item_ret_uint(element_tree, hf_gbcs_message_element_length, tvb, *offset, 1, ENC_NA, &len);
    *offset += 1;

    if (len > 0) {
        nstime_t date_time;

        dlms_date_time(tvb, *offset, &date_time);
        value_ti = proto_tree_add_time(element_tree, hfindex, tvb, *offset, GBCS_MESSAGE_DLMS_DATE_TIME_LENGTH, &date_time);
        if (value_ti) {
            gchar *label;

            label = (char*)wmem_alloc(wmem_packet_scope(), ITEM_LABEL_LENGTH+1);
            proto_item_fill_label(PITEM_FINFO(value_ti), label);
            proto_item_append_text(tree_ti, "%s", label);
        }
        *offset += GBCS_MESSAGE_DLMS_DATE_TIME_LENGTH;

        proto_item_set_end(tree_ti, tvb, *offset);
    }
    else {
        proto_item_append_text(tree_ti, "%s: <none>", proto_registrar_get_name(hfindex));
    }
}

static void
dissect_gbcs_message_mac_header(tvbuff_t *tvb, proto_tree *tree, guint *offset)
{
    proto_item *ti;
    proto_tree *mac_header_tree;
    guint len, offset_start;

    mac_header_tree = proto_tree_add_subtree(tree, tvb, *offset, 1, ett_gbcs_message_mac_header, &ti, "MAC Header");

    proto_tree_add_item(mac_header_tree, hf_gbcs_message_mac_header_general_ciphering, tvb, *offset, 1, ENC_NA);
    *offset += 1;

    dissect_gbcs_message_element_transaction_id(mac_header_tree, hf_gbcs_message_mac_header_cra_flag,
                                                hf_gbcs_message_mac_header_originator_counter, tvb, offset); // transaction-id - always none
    dissect_gbcs_message_element(mac_header_tree, hf_gbcs_message_mac_header_business_originator_id, tvb, offset); // originator-system-title - always none
    dissect_gbcs_message_element(mac_header_tree, hf_gbcs_message_mac_header_business_target_id, tvb, offset); // recipient-system-title - always none
    dissect_gbcs_message_element_date_time(mac_header_tree, hf_gbcs_message_mac_header_date_time, tvb, offset); // date-time - always none
    dissect_gbcs_message_element(mac_header_tree, hf_gbcs_message_mac_header_other_info, tvb, offset); // other-information - always none
    dissect_gbcs_message_element(mac_header_tree, hf_gbcs_message_mac_header_key_info, tvb, offset); // key-info - always none

    offset_start = *offset;
    *offset = get_ber_length(tvb, *offset, &len, NULL);
    proto_tree_add_uint(mac_header_tree, hf_gbcs_message_element_length, tvb, offset_start, *offset - offset_start, len);

    proto_tree_add_item(mac_header_tree, hf_gbcs_message_mac_header_security_control_byte, tvb, *offset, 1, ENC_NA);
    *offset += 1;

    proto_tree_add_item(mac_header_tree, hf_gbcs_message_mac_header_invocation_counter, tvb, *offset, 4, ENC_BIG_ENDIAN);
    *offset += 4;

    proto_item_set_end(ti, tvb, *offset);
}

static void
dissect_gbcs_message_grouping_header(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint *offset, guint *len, guint8 *cra)
{
    proto_item *grouping_header_ti, *other_info_ti;
    proto_tree *grouping_header_tree, *other_info_tree;
    guint other_info_len;
    guint offset_start;
    guint32 message_code;

    grouping_header_tree = proto_tree_add_subtree(tree, tvb, *offset, 1, ett_gbcs_message_grouping_header, &grouping_header_ti, "Grouping Header");

    proto_tree_add_item(grouping_header_tree, hf_gbcs_message_grouping_header_general_signing, tvb, *offset, 1, ENC_NA);
    *offset += 1;

    *cra = tvb_get_guint8(tvb, *offset + 1);
    col_append_sep_str(pinfo->cinfo, COL_INFO, NULL, val_to_str_const(*cra, gbcs_message_cra_names, "Unknown CRA"));
    dissect_gbcs_message_element_transaction_id(grouping_header_tree,
            hf_gbcs_message_grouping_header_cra_flag, hf_gbcs_message_grouping_header_originator_counter, tvb, offset);

    dissect_gbcs_message_element(grouping_header_tree, hf_gbcs_message_grouping_header_business_originator_id, tvb, offset);

    dissect_gbcs_message_element(grouping_header_tree, hf_gbcs_message_grouping_header_business_target_id, tvb, offset);

    dissect_gbcs_message_element_date_time(grouping_header_tree, hf_gbcs_message_grouping_header_date_time, tvb, offset);

    other_info_tree = proto_tree_add_subtree(grouping_header_tree, tvb,
            *offset, 1, ett_gbcs_message_grouping_header_other_info, &other_info_ti, "Other Information");

    offset_start = *offset;
    *offset = get_ber_length(tvb, *offset, &other_info_len, NULL);
    proto_tree_add_uint(other_info_tree, hf_gbcs_message_element_length, tvb, offset_start, *offset - offset_start, other_info_len);

    proto_tree_add_item_ret_uint(other_info_tree, hf_gbcs_message_grouping_header_message_code,
            tvb, *offset, 2, ENC_BIG_ENDIAN, &message_code);
    col_append_sep_str(pinfo->cinfo, COL_INFO, NULL, val_to_str_ext_const(message_code, &gbcs_message_code_names_ext, "Unknown Use Case"));
    *offset += 2;
    other_info_len -= 2;

    if (other_info_len > 0) {
        proto_tree_add_item(other_info_tree, hf_gbcs_message_grouping_header_supplementary_remote_party_id,
                tvb, *offset, 8, ENC_BIG_ENDIAN);
        *offset += 8;
        other_info_len -= 8;
    }

    if (other_info_len > 0) {
        proto_tree_add_item(other_info_tree, hf_gbcs_message_grouping_header_supplementary_remote_party_counter,
                tvb, *offset, 8, ENC_BIG_ENDIAN);
        *offset += 8;
        other_info_len -= 8;
    }

    if (other_info_len > 0) {
        proto_tree_add_item(other_info_tree, hf_gbcs_message_grouping_header_supplementary_originator_counter,
                tvb, *offset, 8, ENC_BIG_ENDIAN);
        *offset += 8;
        other_info_len -= 8;
    }

    if (other_info_len > 0) {
        proto_tree_add_item(other_info_tree, hf_gbcs_message_grouping_header_supplementary_remote_party_ka_certificate,
                tvb, *offset, other_info_len, ENC_NA);
        *offset += other_info_len;
        other_info_len -= other_info_len;
    }

    proto_item_set_end(other_info_ti, tvb, *offset);

    offset_start = *offset;
    *offset = get_ber_length(tvb, *offset, len, NULL);
    proto_tree_add_uint(grouping_header_tree, hf_gbcs_message_element_length, tvb, offset_start, *offset - offset_start, *len);

    proto_item_set_end(grouping_header_ti, tvb, *offset);
}

static void
dissect_gbcs_message_routing_header(tvbuff_t *tvb, proto_tree *tree, guint *offset,
        guint64 *business_originator, guint64 *originator_counter)
{
    proto_item *routing_header_ti, *other_info_ti;
    proto_tree *routing_header_tree, *other_info_tree;
    guint other_info_len;
    guint len, offset_start;

    routing_header_tree = proto_tree_add_subtree(tree, tvb, *offset, 1, ett_gbcs_message_routing_header, &routing_header_ti, "Routing Header");

    proto_tree_add_item(routing_header_tree, hf_gbcs_message_routing_header_general_ciphering, tvb, *offset, 1, ENC_NA);
    *offset += 1;

    *originator_counter = tvb_get_guint64(tvb, *offset + 2, ENC_BIG_ENDIAN);
    dissect_gbcs_message_element_transaction_id(routing_header_tree,
            hf_gbcs_message_routing_header_cra_flag, hf_gbcs_message_routing_header_originator_counter, tvb, offset);

    *business_originator = tvb_get_guint64(tvb, *offset + 1, ENC_BIG_ENDIAN);
    dissect_gbcs_message_element(routing_header_tree, hf_gbcs_message_routing_header_business_originator_id, tvb, offset);

    dissect_gbcs_message_element(routing_header_tree, hf_gbcs_message_routing_header_business_target_id, tvb, offset);

    dissect_gbcs_message_element_date_time(routing_header_tree, hf_gbcs_message_routing_header_date_time, tvb, offset); // date-time - always none

    other_info_tree = proto_tree_add_subtree(routing_header_tree, tvb,
            *offset, 1, ett_gbcs_message_routing_header_other_info, &other_info_ti, "Other Information");

    offset_start = *offset;
    *offset = get_ber_length(tvb, *offset, &other_info_len, NULL);
    proto_tree_add_uint(other_info_tree, hf_gbcs_message_element_length, tvb, offset_start, *offset - offset_start, other_info_len);

    proto_tree_add_item(other_info_tree, hf_gbcs_message_routing_header_message_code, tvb, *offset, 2, ENC_BIG_ENDIAN);
    *offset += 2;

    dissect_gbcs_message_element(routing_header_tree, hf_gbcs_message_routing_header_key_info, tvb, offset); // key-info - always none

    offset_start = *offset;
    *offset = get_ber_length(tvb, *offset, &len, NULL);
    proto_tree_add_uint(routing_header_tree, hf_gbcs_message_element_length, tvb, offset_start, *offset - offset_start, len);

    proto_tree_add_item(routing_header_tree, hf_gbcs_message_routing_header_security_control_byte, tvb, *offset, 1, ENC_NA);
    *offset += 1;

    proto_tree_add_item(routing_header_tree, hf_gbcs_message_routing_header_invocation_counter, tvb, *offset, 4, ENC_BIG_ENDIAN);
    *offset += 4;

    proto_item_set_end(routing_header_ti, tvb, *offset);
}

static void
dissect_gbcs_message_gbt_header(tvbuff_t *tvb, proto_tree *tree, guint *offset,
        guint *len, guint16 *block_number, gboolean *last)
{
    proto_item *ti;
    proto_tree *gbt_header_tree;
    guint offset_start;

    gbt_header_tree = proto_tree_add_subtree(tree, tvb, *offset, 1, ett_gbcs_message_gbt_header, &ti, "GBT Header");

    proto_tree_add_item(gbt_header_tree, hf_gbcs_message_gbt_header_general_block_transfer, tvb, *offset, 1, ENC_NA);
    *offset += 1;

    static int* const block_control[] = {
            &hf_gbcs_message_gbt_header_block_control_last_block,
            &hf_gbcs_message_gbt_header_block_control_streaming,
            &hf_gbcs_message_gbt_header_block_control_window,
            NULL
    };

    *last = tvb_get_guint8(tvb, *offset) & GBCS_MESSAGE_GBT_BLOCK_CONTROL_LAST_BLOCK;
    proto_tree_add_bitmask(gbt_header_tree, tvb, *offset, hf_gbcs_message_gbt_header_block_control,
            ett_gbcs_message_gbt_header_block_control, block_control, ENC_BIG_ENDIAN);
    *offset += 1;

    *block_number = tvb_get_guint16(tvb, *offset, ENC_BIG_ENDIAN);
    proto_tree_add_item(gbt_header_tree, hf_gbcs_message_gbt_header_block_number, tvb, *offset, 2, ENC_BIG_ENDIAN);
    *offset += 2;

    proto_tree_add_item(gbt_header_tree, hf_gbcs_message_gbt_header_block_number_ack, tvb, *offset, 2, ENC_BIG_ENDIAN);
    *offset += 2;

    offset_start = *offset;
    *offset = get_ber_length(tvb, *offset, len, NULL);
    proto_tree_add_uint(gbt_header_tree, hf_gbcs_message_element_length, tvb, offset_start, *offset - offset_start, *len);

    proto_item_set_end(ti, tvb, *offset);
}

static void
dissect_gbcs_gbt_payload(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint *offset, guint len, guint64 business_originator,
        guint64 originator_counter, guint16 block_number, gboolean last)
{
    guint32 msg_id;
    fragment_head *frag_msg = NULL;
    tvbuff_t *new_tvb;

    pinfo->fragmented = TRUE;

    msg_id = ((guint32)business_originator << 8) | ((guint32)originator_counter & 0xFF);

    frag_msg = fragment_add_seq_check(&gbcs_message_gbt_reassembly_table,
            tvb, *offset, pinfo, msg_id, NULL, block_number - 1, len, !last);

    new_tvb = process_reassembled_data(tvb, *offset, pinfo,
            "Reassembled GBT", frag_msg, &gbcs_message_gbt_frag_items, NULL, tree);

    if (new_tvb) {
        /* The reassembly handler defragmented the message, and created a new tvbuff */
        call_dissector_with_data(gbcs_gbcs_handle, new_tvb, pinfo, proto_tree_get_parent_tree(tree), NULL);
    }
    else {
        /* The reassembly handler could not defragment the message yet */
        col_append_sep_fstr(pinfo->cinfo, COL_INFO, NULL, "GBT block %d", block_number);
        call_data_dissector(tvb_new_subset_length(tvb, *offset, len), pinfo, proto_tree_get_parent_tree(tree));
    }

    *offset += len;
}

static void
dissect_gbcs_message_payload(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint *offset, guint len, guint8 cra)
{
    tvbuff_t *payload_tvb = tvb_new_subset_length(tvb, *offset, len);

    if (gbcs_gbz_handle != NULL && tvb_get_ntohs(payload_tvb, 0) == ZBEE_PROFILE_SE) {
        // Dissect GBZ payload
        call_dissector_with_data(gbcs_gbz_handle, payload_tvb, pinfo, tree, &cra);
    }
    else if (tvb_get_guint8(payload_tvb, 0) == GBCS_MESSAGE_ACCESS_REQUEST
            || tvb_get_guint8(payload_tvb, 0) == GBCS_MESSAGE_ACCESS_RESPONSE
            || tvb_get_guint8(payload_tvb, 0) == GBCS_MESSAGE_DATA_NOTIFICATION) {
        //TODO Dissect DLMS payload
        proto_tree *dlms_tree;

        dlms_tree = proto_tree_add_subtree(tree, payload_tvb, 0, len, ett_gbcs_message_dlms, NULL, "GBCS DLMS");
        call_data_dissector(payload_tvb, pinfo, dlms_tree);
    }
    else {
        // If it isn't GBZ or DLMS, then it is ASN.1
        const gchar *text;
        wmem_strbuf_t *strbuf;
        proto_tree *asn1_tree;

        text = col_get_text(pinfo->cinfo, COL_INFO);
        if (text) {
            strbuf = wmem_strbuf_new(wmem_packet_scope(), text);
        }
        asn1_tree = proto_tree_add_subtree(tree, payload_tvb, 0, len, ett_gbcs_message_asn1, NULL, "GBCS ASN.1");
        call_dissector(gbcs_ber_handle, payload_tvb, pinfo, asn1_tree);
        if (text) {
            col_add_str(pinfo->cinfo, COL_INFO, wmem_strbuf_get_str(strbuf));
        }
    }

    *offset += len;
}

static void
dissect_gbcs_message_krp(tvbuff_t *tvb, proto_tree *tree, guint *offset)
{
    dissect_gbcs_message_element(tree, hf_gbcs_message_krp, tvb, offset);
}

static void
dissect_gbcs_message_mac(tvbuff_t *tvb, proto_tree *tree, guint *offset)
{
    proto_tree_add_item(tree, hf_gbcs_message_mac, tvb, *offset, GBCS_MESSAGE_MAC_LENGTH, ENC_NA);
    *offset += GBCS_MESSAGE_MAC_LENGTH;
}

static int
dissect_gbcs_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
{
    proto_item *ti;
    proto_tree *gbcs_message_tree;
    guint offset = 0;

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "GBCS Message");

    ti = proto_tree_add_item(tree, proto_gbcs_message, tvb, offset, -1, ENC_NA);
    gbcs_message_tree = proto_item_add_subtree(ti, ett_gbcs_message);

    if ((tvb_get_guint8(tvb, offset) == GBCS_MESSAGE_GENERAL_CIPHERING && tvb_get_guint8(tvb, offset + 1) == 0)
            || tvb_get_guint8(tvb, offset) == GBCS_MESSAGE_GENERAL_SIGNING) {
        // Normal GBCS message
        gboolean mac = tvb_get_guint8(tvb, offset) == GBCS_MESSAGE_GENERAL_CIPHERING;
        guint grouping_len;
        guint8 grouping_cra;

        if (mac) {
            dissect_gbcs_message_mac_header(tvb, gbcs_message_tree, &offset);
        }

        dissect_gbcs_message_grouping_header(tvb, pinfo, gbcs_message_tree, &offset, &grouping_len, &grouping_cra);

        dissect_gbcs_message_payload(tvb, pinfo, tree, &offset, grouping_len, grouping_cra);

        dissect_gbcs_message_krp(tvb, gbcs_message_tree, &offset);

        if (mac) {
            dissect_gbcs_message_mac(tvb, gbcs_message_tree, &offset);
        }
    }
    else if (tvb_get_guint8(tvb, offset) == GBCS_MESSAGE_GENERAL_CIPHERING && tvb_get_guint8(tvb, offset + 1) == 0x09) {
        // GBCS General Block Transfer
        guint gbt_len;
        guint64 business_originator;
        guint64 originator_counter;
        guint16 block_number;
        gboolean last;

        dissect_gbcs_message_routing_header(tvb, gbcs_message_tree, &offset, &business_originator, &originator_counter);

        dissect_gbcs_message_gbt_header(tvb, gbcs_message_tree, &offset, &gbt_len, &block_number, &last);

        if (gbt_len > 0) { // GBT Ack contains no data
            dissect_gbcs_gbt_payload(tvb, pinfo, gbcs_message_tree, &offset, gbt_len, business_originator, originator_counter, block_number, last);
        }
    }

    proto_item_set_end(ti, tvb, offset);

    return tvb_captured_length(tvb);
}

void proto_register_gbcs_message(void)
{
    static hf_register_info hf[] = {
        {&hf_gbcs_message_element_length,
            {"Length", "gbcs_message.element_length",
             FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_mac_header_general_ciphering,
            {"General Ciphering", "gbcs_message.mac_header.general_ciphering",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_mac_header_cra_flag,
            {"CRA Flag", "gbcs_message.mac_header.cra_flag",
             FT_UINT8, BASE_HEX, VALS(gbcs_message_cra_names), 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_mac_header_originator_counter,
            {"Originator Counter", "gbcs_message.mac_header.originator_counter",
             FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_mac_header_business_originator_id,
            {"Business Originator ID", "gbcs_message.mac_header.business_originator_id",
             FT_EUI64, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_mac_header_business_target_id,
            {"Business Target ID", "gbcs_message.mac_header.business_target_id",
             FT_EUI64, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_mac_header_date_time,
            {"Date Time", "gbcs_message.mac_header.date_time",
             FT_ABSOLUTE_TIME, ABSOLUTE_TIME_UTC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_mac_header_other_info,
            {"Other-Information", "gbcs_message.mac_header.other_info",
             FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_mac_header_key_info,
            {"Key-Info", "gbcs_message.mac_header.key_info",
             FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_mac_header_security_control_byte,
            {"Security Control Byte", "gbcs_message.mac_header.security_control_byte",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_mac_header_invocation_counter,
            {"Invocation Counter", "gbcs_message.mac_header.invocation_counter",
             FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_grouping_header_general_signing,
            {"General Signing", "gbcs_message.grouping_header.general_signing",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_grouping_header_cra_flag,
            {"CRA Flag", "gbcs_message.grouping_header.cra_flag",
             FT_UINT8, BASE_HEX, VALS(gbcs_message_cra_names), 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_grouping_header_originator_counter,
            {"Originator Counter", "gbcs_message.grouping_header.originator_counter",
             FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_grouping_header_business_originator_id,
            {"Business Originator ID", "gbcs_message.grouping_header.business_originator_id",
             FT_EUI64, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_grouping_header_business_target_id,
            {"Business Target ID", "gbcs_message.grouping_header.business_target_id",
             FT_EUI64, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_grouping_header_date_time,
            {"Date Time", "gbcs_message.grouping_header.date_time",
             FT_ABSOLUTE_TIME, ABSOLUTE_TIME_UTC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_grouping_header_message_code,
            {"Message Code", "gbcs_message.grouping_header.message_code",
             FT_UINT16, BASE_HEX | BASE_EXT_STRING, &gbcs_message_code_names_ext, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_grouping_header_supplementary_remote_party_id,
            {"Supplementary Remote Party ID", "gbcs_message.grouping_header.supplementary_remote_party_id",
             FT_EUI64, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_grouping_header_supplementary_remote_party_counter,
            {"Supplementary Remote Party Counter", "gbcs_message.grouping_header.supplementary_remote_party_counter",
             FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_grouping_header_supplementary_originator_counter,
            {"Supplementary Originator Counter", "gbcs_message.grouping_header.supplementary_remote_party_originator_counter",
             FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_grouping_header_supplementary_remote_party_ka_certificate,
            {"Certificate", "gbcs_message.grouping_header.supplementary_remote_party_ka_certificate",
             FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_krp,
            {"KRP", "gbcs_message.krp",
             FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_mac,
            {"MAC", "gbcs_message.mac",
             FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_routing_header_general_ciphering,
            {"General Ciphering", "gbcs_message.routing_header.general_ciphering",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_routing_header_cra_flag,
            {"CRA Flag", "gbcs_message.routing_header.cra_flag",
             FT_UINT8, BASE_HEX, VALS(gbcs_message_cra_names), 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_routing_header_originator_counter,
            {"Originator Counter", "gbcs_message.routing_header.originator_counter",
             FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_routing_header_business_originator_id,
            {"Business Originator ID", "gbcs_message.routing_header.business_originator_id",
             FT_EUI64, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_routing_header_business_target_id,
            {"Business Target ID", "gbcs_message.routing_header.business_target_id",
             FT_EUI64, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_routing_header_date_time,
            {"Date Time", "gbcs_message.routing_header.date_time",
             FT_ABSOLUTE_TIME, ABSOLUTE_TIME_UTC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_routing_header_key_info,
            {"Key-Info", "gbcs_message.routing_header.key_info",
             FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_routing_header_message_code,
            {"Message Code", "gbcs_message.routing_header.message_code",
             FT_UINT16, BASE_HEX | BASE_EXT_STRING, &gbcs_message_code_names_ext, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_routing_header_security_control_byte,
            {"Security Control Byte", "gbcs_message.routing_header.security_control_byte",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_routing_header_invocation_counter,
            {"Invocation Counter", "gbcs_message.routing_header.invocation_counter",
             FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_gbt_header_general_block_transfer,
            {"General Block Transfer", "gbcs_message.gbt_header.general_block_transfer",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_gbt_header_block_control,
            {"Block Control", "gbcs_message.gbt_header.block_control",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_gbt_header_block_control_last_block,
            {"Last Block", "gbcs_message.gbt_header.block_control.last_block",
             FT_BOOLEAN, 8, NULL, GBCS_MESSAGE_GBT_BLOCK_CONTROL_LAST_BLOCK, NULL, HFILL }
        },
        {&hf_gbcs_message_gbt_header_block_control_streaming,
            {"Streaming", "gbcs_message.gbt_header.block_control.streaming",
             FT_BOOLEAN, 8, NULL, GBCS_MESSAGE_GBT_BLOCK_CONTROL_STREAMING, NULL, HFILL }
        },
        {&hf_gbcs_message_gbt_header_block_control_window,
            {"Window", "gbcs_message.gbt_header.block_control.window",
             FT_UINT8, BASE_DEC, NULL, GBCS_MESSAGE_GBT_BLOCK_CONTROL_WINDOW, NULL, HFILL}
        },
        {&hf_gbcs_message_gbt_header_block_number,
            {"Block Number", "gbcs_message.gbt_header.block_number",
             FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        {&hf_gbcs_message_gbt_header_block_number_ack,
            {"Block Number Ack", "gbcs_message.gbt_header.block_number_ack",
             FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        { &hf_gbcs_message_gbt_blocks,
            { "Message blocks", "gbcs_message.gbt.blocks",
             FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        { &hf_gbcs_message_gbt_block,
            { "Message block", "gbcs_message.gbt.block",
             FT_FRAMENUM, BASE_NONE, NULL, 0x0,NULL, HFILL}
        },
        { &hf_gbcs_message_gbt_block_overlap,
            { "Message block overlap", "gbcs_message.gbt.block.overlap",
             FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        { &hf_gbcs_message_gbt_block_overlap_conflicts,
            { "Message block overlapping with conflicting data", "gbcs_message.gbt.block.overlap.conflicts",
             FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        { &hf_gbcs_message_gbt_block_multiple_tails,
            { "Message has multiple tail blocks", "gbcs_message.gbt.block.multiple_tails",
             FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        { &hf_gbcs_message_gbt_block_too_long_fragment,
            { "Message block too long", "gbcs_message.gbt.block.too_long_fragment",
             FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        { &hf_gbcs_message_gbt_block_error,
            { "Message defragmentation error", "gbcs_message.gbt.block.error",
             FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        { &hf_gbcs_message_gbt_block_count,
            { "Message block count", "gbcs_message.gbt.block.count",
             FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}
        },
        { &hf_gbcs_message_gbt_reassembled_in,
            { "Reassembled in", "gbcs_message.gbt.reassembled.in",
             FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL}
        },
        { &hf_gbcs_message_gbt_reassembled_length,
            { "Reassembled GBT length", "gbcs_message.gbt.reassembled.length",
             FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}
        }
    };

    static gint *ett[] = {
        &ett_gbcs_message,
        &ett_gbcs_message_element,
        &ett_gbcs_message_mac_header,
        &ett_gbcs_message_grouping_header,
        &ett_gbcs_message_grouping_header_other_info,
        &ett_gbcs_message_routing_header,
        &ett_gbcs_message_routing_header_other_info,
        &ett_gbcs_message_gbt_header,
        &ett_gbcs_message_gbt_header_block_control,
        &ett_gbcs_message_gbt_fragment,
        &ett_gbcs_message_gbt_fragments,
        &ett_gbcs_message_asn1,
        &ett_gbcs_message_dlms
    };

    proto_gbcs_message = proto_register_protocol("GBCS Message", "GBCS Message", "gbcs_message");
    gbcs_gbcs_handle = register_dissector("gbcs_message", dissect_gbcs_message, proto_gbcs_message);
    proto_register_field_array(proto_gbcs_message, hf, array_length(hf));
    proto_register_subtree_array(ett, array_length(ett));

    reassembly_table_register(&gbcs_message_gbt_reassembly_table, &addresses_reassembly_table_functions);
}

void proto_reg_handoff_gbcs_message(void)
{
    gbcs_gbz_handle = find_dissector("gbcs_gbz");
    gbcs_ber_handle = find_dissector("ber");
}

/*
 * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 *
 * Local variables:
 * c-basic-offset: 4
 * tab-width: 8
 * indent-tabs-mode: nil
 * End:
 *
 * vi: set shiftwidth=4 tabstop=8 expandtab:
 * :indentSize=4:tabSize=8:noTabs=true:
 */
