/* packet-lls.c

 * Routines for ATSC3 LLS(Low Level Signalling) dissection

 * Copyright 2023, Sergey V. Lobanov <sergey@lobanov.in>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

/*

 * ATSC3 Signaling, Delivery, Synchronization, and Error Protection (A/331)

 * https://www.atsc.org/atsc-documents/3312017-signaling-delivery-synchronization-error-protection/

 *

 * ATSC3 Security and Service Protection (A/360)

 * https://www.atsc.org/atsc-documents/3602018-atsc-3-0-security-service-protection/

 *

 * ATSC Code Point Registry

 * https://www.atsc.org/documents/code-point-registry/

 */

#include <config.h>

#include <epan/expert.h>

#include <epan/packet.h>

#include "packet-lls.h"

#define LLS_PORT 4937 // IANA Registered (atsc-mh-ssc)

void proto_reg_handoff_lls(void);

void proto_register_lls(void);

static int proto_lls;

static int ett_lls;

static int ett_lls_smt_entry;

static int ett_lls_smt_signature;

static int ett_lls_table_payload;

static int ett_lls_table_payload_xml;

static dissector_handle_t lls_handle;

static dissector_handle_t xml_handle;

static dissector_handle_t cms_handle;

static expert_field ei_lls_table_decompression_failed;

static int hf_lls_table_id;

#define LLS_TABLE_TYPE_SIGNED_MULTI_TABLE 0xFE

#define LLS_TABLE_TYPE_SLT                0x01

static const value_string hf_lls_table_type_vals[] = {

    { 0x01, "SLT (Service List Table)" },

    { 0x02, "RRT (Rating Region Table)" },

    { 0x03, "System Time" },

    { 0x04, "AEAT (Advanced Emergency Information Table)" },

    { 0x05, "On Screen Message Notification" },

    { 0x06, "CDT (Certification Data Table)" },

    { 0x07, "DRCT (Dedicated Return Channel Table)" },

    { 0x80, "VIT (Version Information Table)" },

    { 0x81, "CPT (Content Protection Table)" },

    { 0x82, "CAP (Common Alerting Protocol)" },

    { 0xFE, "Signed Multi Table" },

    { 0xFF, "User Defined" },

    { 0x00, NULL }

};

static const value_string hf_lls_table_type_short_vals[] = {

    { 0x01, "SLT" },

    { 0x02, "RRT" },

    { 0x03, "ST" },

    { 0x04, "AEAT" },

    { 0x05, "OSMN" },

    { 0x06, "CDT" },

    { 0x07, "DRCT" },

    { 0x80, "VIT" },

    { 0x81, "CPT" },

    { 0x82, "CAP" },

    { 0xFE, "SMT" },

    { 0xFF, "USD" },

    { 0x00, NULL }

};

static int hf_lls_group_id;

static int hf_lls_group_count;

static int hf_lls_table_version;

static int hf_lls_table_payload;

static int hf_lls_table_payload_uncompressed;

static int hf_lls_smt_payload_count;

static int hf_lls_smt_entry;

static int hf_lls_smt_entry_payload_length;

static int hf_lls_smt_signature_length;

static int hf_lls_smt_signature;

static void

dissect_lls_table_payload(uint8_t lls_table_id, tvbuff_t *tvb, packet_info *pinfo, int offset, int len, proto_tree *tree)

{

    proto_item *ti = proto_tree_add_item(tree, hf_lls_table_payload, tvb, offset, len, ENC_NA);

    if (lls_table_id == LLS_TABLE_TYPE_SIGNED_MULTI_TABLE) {

        /* Nested SignedMultiTable decoding is not specified in the standard */

        return;

    }

    proto_tree *uncompress_tree = proto_item_add_subtree(ti, ett_lls_table_payload);

    tvbuff_t *uncompress_tvb = tvb_uncompress_zlib(tvb, offset, len);

    proto_tree *xml_tree = NULL;

    if (uncompress_tvb) {

        const char *table_type_short = val_to_str_const(lls_table_id, hf_lls_table_type_short_vals, "Unknown");

        char *source_name = wmem_strdup_printf(pinfo->pool, "Table ID %u (%s)", lls_table_id, table_type_short);

        add_new_data_source(pinfo, uncompress_tvb, source_name);

        unsigned decomp_length = tvb_captured_length(uncompress_tvb);

        proto_item *ti_uncomp = proto_tree_add_item(uncompress_tree, hf_lls_table_payload_uncompressed, uncompress_tvb, 0, decomp_length, ENC_ASCII);

        proto_item_set_generated(ti_uncomp);

        if (xml_handle) {

            xml_tree = proto_item_add_subtree(ti_uncomp, ett_lls_table_payload_xml);

            call_dissector(xml_handle, uncompress_tvb, pinfo, xml_tree);

        }

    } else {

        expert_add_info(pinfo, ti, &ei_lls_table_decompression_failed);

    }

    if (lls_table_id == LLS_TABLE_TYPE_SLT && xml_tree != NULL) {

        lls_extract_save_slt_table(pinfo, xml_handle);

    }

}

static int

dissect_lls(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)

{

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "LLS");

    proto_item *ti = proto_tree_add_item(tree, proto_lls, tvb, 0, -1, ENC_NA);

    proto_tree *lls_tree = proto_item_add_subtree(ti, ett_lls);

    int offset = 0;

    uint8_t lls_table_id = tvb_get_uint8(tvb, offset);

    col_set_str(pinfo->cinfo, COL_INFO, val_to_str_const(lls_table_id, hf_lls_table_type_vals, "Unknown"));

    proto_tree_add_item(lls_tree, hf_lls_table_id, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    proto_tree_add_item(lls_tree, hf_lls_group_id, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    uint16_t lls_group_count = tvb_get_uint8(tvb, offset) + 1;

    PROTO_ITEM_SET_GENERATED(

        proto_tree_add_uint(lls_tree, hf_lls_group_count, tvb, offset, 1, lls_group_count)

    );

    offset++;

    proto_tree_add_item(lls_tree, hf_lls_table_version, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset++;

    if (lls_table_id == LLS_TABLE_TYPE_SIGNED_MULTI_TABLE) {

        uint8_t smt_payload_count = tvb_get_uint8(tvb, offset);

        proto_tree_add_item(lls_tree, hf_lls_smt_payload_count, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset++;

        for(uint8_t i = 0; i < smt_payload_count; i++) {

            uint16_t smt_entry_payload_length = tvb_get_uint16(tvb, offset + 2, ENC_BIG_ENDIAN);

            proto_item *smt_entry_item = proto_tree_add_item(lls_tree, hf_lls_smt_entry, tvb, offset, smt_entry_payload_length + 4, ENC_NA);

            proto_tree *smt_entry_tree = proto_item_add_subtree(smt_entry_item, ett_lls_smt_entry);

            uint8_t smt_entry_table_id = tvb_get_uint8(tvb, offset);

            const char *table_type_short = val_to_str_const(smt_entry_table_id, hf_lls_table_type_short_vals, "Unknown");

            proto_item_append_text(smt_entry_item, " (%u) Table ID=%u (%s)", i, smt_entry_table_id, table_type_short);

            col_append_fstr(pinfo->cinfo, COL_INFO, "/%s", table_type_short);

            proto_tree_add_item(smt_entry_tree, hf_lls_table_id, tvb, offset, 1, ENC_BIG_ENDIAN);

            offset++;

            proto_tree_add_item(smt_entry_tree, hf_lls_table_version, tvb, offset, 1, ENC_BIG_ENDIAN);

            offset++;

            proto_tree_add_item(smt_entry_tree, hf_lls_smt_entry_payload_length, tvb, offset, 2, ENC_BIG_ENDIAN);

            offset += 2;

            dissect_lls_table_payload(smt_entry_table_id, tvb, pinfo, offset, smt_entry_payload_length, smt_entry_tree);

            offset += smt_entry_payload_length;

        }

        uint16_t smt_signature_length = tvb_get_uint16(tvb, offset, ENC_BIG_ENDIAN);

        proto_tree_add_item(lls_tree, hf_lls_smt_signature_length, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        proto_item *smt_signature_item = proto_tree_add_item(lls_tree, hf_lls_smt_signature, tvb, offset, smt_signature_length, ENC_NA);

        if (cms_handle) {

            proto_tree *cms_tree = proto_item_add_subtree(smt_signature_item, ett_lls_smt_signature);

            tvbuff_t *cms_tvb = tvb_new_subset_length(tvb, offset, smt_signature_length);

            /* CMS dissector removes useful info from Protocol and Info columns so store it */

            char *col_info_text = wmem_strdup(pinfo->pool, col_get_text(pinfo->cinfo, COL_INFO));

            char *col_protocol_text = wmem_strdup(pinfo->pool, col_get_text(pinfo->cinfo, COL_PROTOCOL));

            call_dissector(cms_handle, cms_tvb, pinfo, cms_tree);

            /* Restore Protocol and Info columns */

            col_set_str(pinfo->cinfo, COL_INFO, col_info_text);

            col_set_str(pinfo->cinfo, COL_PROTOCOL, col_protocol_text);

        }

    } else {

        int table_payload_length = tvb_captured_length(tvb) - 4;

        dissect_lls_table_payload(lls_table_id, tvb, pinfo, offset, table_payload_length, lls_tree);

    }

    return tvb_captured_length(tvb);

}

void

proto_register_lls(void)

{

    static hf_register_info hf[] = {

        { &hf_lls_table_id, {

            "Table ID", "lls.table.id",

            FT_UINT8, BASE_DEC, VALS(hf_lls_table_type_vals), 0, NULL, HFILL

        } },

        { &hf_lls_group_id, {

            "Group ID", "lls.group.id",

            FT_UINT8, BASE_DEC, 0, 0, NULL, HFILL

        } },

        { &hf_lls_group_count, {

            "Group Count", "lls.group.count",

            FT_UINT16, BASE_DEC, 0, 0, NULL, HFILL

        } },

        { &hf_lls_table_version, {

            "Table Version", "lls.table.version",

            FT_UINT8, BASE_DEC, 0, 0, NULL, HFILL

        } },

        { &hf_lls_table_payload, {

            "Table Payload", "lls.table.payload",

            FT_NONE, BASE_NONE, 0, 0, NULL, HFILL

        } },

        { &hf_lls_table_payload_uncompressed, {

            "Table Payload Uncompressed", "lls.table.payload.uncompressed",

            FT_STRING, BASE_NONE, 0, 0, NULL, HFILL

        } },

        { &hf_lls_smt_payload_count, {

            "Signed Multi Table Payload Count", "lls.smt.payload_count",

            FT_UINT8, BASE_DEC, 0, 0, NULL, HFILL

        } },

        { &hf_lls_smt_entry, {

            "Signed Multi Table Entry", "lls.smt.entry",

            FT_NONE, BASE_NONE, NULL, 0, NULL, HFILL

        } },

        { &hf_lls_smt_entry_payload_length, {

            "Payload Length", "lls.smt.entry.payload_length",

            FT_UINT16, BASE_DEC, 0, 0, NULL, HFILL

        } },

        { &hf_lls_smt_signature_length, {

            "Signed Multi Table Signature Length", "lls.smt.signature_length",

            FT_UINT16, BASE_DEC, 0, 0, NULL, HFILL

        } },

        { &hf_lls_smt_signature, {

            "Signed Multi Table Signature", "lls.smt.signature",

            FT_NONE, BASE_NONE, 0, 0, NULL, HFILL

        } },

    };

    static int *ett[] = {

        &ett_lls,

        &ett_lls_smt_entry,

        &ett_lls_table_payload,

        &ett_lls_table_payload_xml,

        &ett_lls_smt_signature,

    };

    static ei_register_info ei[] = {

        { &ei_lls_table_decompression_failed,

          { "lls.table.decompression.failed", PI_MALFORMED, PI_ERROR,

            "LLS table payload decompression failed",

            EXPFILL }

        },

    };

    proto_lls = proto_register_protocol("ATSC3 Low Level Signalling", "LLS", "lls");

    expert_module_t *expert_lls = expert_register_protocol(proto_lls);

    expert_register_field_array(expert_lls, ei, array_length(ei));

    proto_register_field_array(proto_lls, hf, array_length(hf));

    proto_register_subtree_array(ett, array_length(ett));

}

void

proto_reg_handoff_lls(void)

{

    lls_handle = create_dissector_handle(dissect_lls, proto_lls);

    xml_handle = find_dissector_add_dependency("xml", proto_lls);

    cms_handle = find_dissector_add_dependency("cms", proto_lls);

    dissector_add_uint_with_preference("udp.port", LLS_PORT, lls_handle);

}

/*

 * 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:

 */