231 lines
8.2 KiB
C
231 lines
8.2 KiB
C
/* packet-lls-slt.c
|
|
* Routines for ATSC3 LLS(Low Level Signalling) SLT table 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/
|
|
*/
|
|
|
|
#include <epan/packet.h>
|
|
#include <epan/proto_data.h>
|
|
|
|
#include <wsutil/inet_addr.h>
|
|
#include <wsutil/strtoi.h>
|
|
|
|
#include "packet-lls.h"
|
|
#include "packet-xml.h"
|
|
|
|
|
|
/* Saved SLT Table to use it from another protocols (e.g. ALC/LCT) */
|
|
wmem_map_t *lls_slt_table = NULL;
|
|
|
|
/* Hash functions */
|
|
static gint
|
|
lls_slt_key_equal(gconstpointer v, gconstpointer w)
|
|
{
|
|
const lls_slt_key_t *v1 = (const lls_slt_key_t *)v;
|
|
const lls_slt_key_t *v2 = (const lls_slt_key_t *)w;
|
|
gint result;
|
|
result = (v1->src_ip == v2->src_ip &&
|
|
v1->dst_ip == v2->dst_ip &&
|
|
v1->dst_port == v2->dst_port);
|
|
return result;
|
|
}
|
|
|
|
static guint
|
|
lls_slt_key_hash(gconstpointer v)
|
|
{
|
|
const lls_slt_key_t *key = (const lls_slt_key_t *)v;
|
|
guint hash_val = key->src_ip ^ key->dst_ip ^ (((guint32)(key->dst_port)) << 16);
|
|
return hash_val;
|
|
}
|
|
|
|
/* Init hash table */
|
|
static void
|
|
lls_check_init_slt_table(void) {
|
|
if(lls_slt_table == NULL) {
|
|
lls_slt_table = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), lls_slt_key_hash, lls_slt_key_equal);
|
|
}
|
|
}
|
|
|
|
static gchar *
|
|
xml_value_to_gchar(xml_frame_t *xml_frame, wmem_allocator_t *scope) {
|
|
gchar *value = NULL;
|
|
if (xml_frame->value != NULL) {
|
|
guint l = tvb_reported_length(xml_frame->value);
|
|
value = (gchar *)wmem_alloc0(scope, l + 1);
|
|
tvb_memcpy(xml_frame->value, value, 0, l);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
void
|
|
lls_extract_save_slt_table(packet_info *pinfo, dissector_handle_t xml_handle)
|
|
{
|
|
/* Extract data saved by xml */
|
|
int proto_xml = dissector_handle_get_protocol_index(xml_handle);
|
|
xml_frame_t *xml_dissector_frame = (xml_frame_t *)p_get_proto_data(pinfo->pool, pinfo, proto_xml, 0);
|
|
if (xml_dissector_frame == NULL) {
|
|
return;
|
|
}
|
|
|
|
/* Data from XML dissector */
|
|
/* Root level, find SLT tag */
|
|
xml_frame_t *xml_frame = xml_dissector_frame->first_child;
|
|
xml_frame_t *xml_frame_slt = NULL;
|
|
while (xml_frame) {
|
|
if (xml_frame->type == XML_FRAME_TAG && g_strcmp0("SLT", xml_frame->name_orig_case) == 0) {
|
|
xml_frame_slt = xml_frame;
|
|
break; /* SLT tag found */
|
|
}
|
|
xml_frame = xml_frame->next_sibling;
|
|
}
|
|
|
|
if (xml_frame_slt == NULL)
|
|
return;
|
|
|
|
/* SLT level*/
|
|
xml_frame_t *slt_entry = xml_frame_slt->first_child;
|
|
while (slt_entry) {
|
|
if (!(slt_entry->type == XML_FRAME_TAG && g_strcmp0("Service", slt_entry->name_orig_case) == 0)) {
|
|
slt_entry = slt_entry->next_sibling;
|
|
continue;
|
|
}
|
|
|
|
/* Service level */
|
|
xml_frame_t *service_entry = slt_entry->first_child;
|
|
|
|
lls_slt_key_t slt_key = {0};
|
|
lls_slt_value_t slt_val = {0};
|
|
slt_val.major_channel_num = -1;
|
|
slt_val.minor_channel_num = -1;
|
|
while (service_entry) {
|
|
gchar *value = xml_value_to_gchar(service_entry, pinfo->pool);
|
|
if (service_entry->type == XML_FRAME_ATTRIB && value != NULL) {
|
|
if(g_strcmp0("serviceId", service_entry->name_orig_case) == 0) {
|
|
ws_strtou16(value, NULL, &slt_val.service_id);
|
|
} else if(g_strcmp0("majorChannelNo", service_entry->name_orig_case) == 0) {
|
|
ws_strtoi32(value, NULL, &slt_val.major_channel_num);
|
|
} else if(g_strcmp0("minorChannelNo", service_entry->name_orig_case) == 0) {
|
|
ws_strtoi32(value, NULL, &slt_val.minor_channel_num);
|
|
}
|
|
}
|
|
wmem_free(pinfo->pool, value);
|
|
|
|
if (service_entry->type == XML_FRAME_TAG && g_strcmp0("BroadcastSvcSignaling", service_entry->name_orig_case) == 0) {
|
|
/* Broadcast svc signalling level*/
|
|
xml_frame_t *bcast_svc_entry = service_entry->first_child;
|
|
|
|
while (bcast_svc_entry) {
|
|
value = xml_value_to_gchar(bcast_svc_entry, pinfo->pool);
|
|
if (bcast_svc_entry->type == XML_FRAME_ATTRIB && value != NULL) {
|
|
if (g_strcmp0("slsProtocol", bcast_svc_entry->name_orig_case) == 0) {
|
|
ws_strtou8(value, NULL, &slt_val.sls_protocol);
|
|
} else if (g_strcmp0("slsDestinationIpAddress", bcast_svc_entry->name_orig_case) == 0) {
|
|
ws_inet_pton4(value, &slt_key.dst_ip);
|
|
} else if (g_strcmp0("slsSourceIpAddress", bcast_svc_entry->name_orig_case) == 0) {
|
|
ws_inet_pton4(value, &slt_key.src_ip);
|
|
} else if (g_strcmp0("slsDestinationUdpPort", bcast_svc_entry->name_orig_case) == 0) {
|
|
ws_strtou16(value, NULL, &slt_key.dst_port);
|
|
}
|
|
}
|
|
wmem_free(pinfo->pool, value);
|
|
bcast_svc_entry = bcast_svc_entry->next_sibling;
|
|
}
|
|
}
|
|
|
|
service_entry = service_entry->next_sibling;
|
|
}
|
|
if (slt_key.dst_ip != 0) {
|
|
/* Save found service entry to hashmap */
|
|
lls_slt_key_t *slt_key_m = wmem_new(wmem_file_scope(), lls_slt_key_t);
|
|
lls_slt_value_t *slt_val_m = wmem_new(wmem_file_scope(), lls_slt_value_t);
|
|
*slt_key_m = slt_key;
|
|
*slt_val_m = slt_val;
|
|
lls_check_init_slt_table();
|
|
wmem_map_insert(lls_slt_table, (void *)slt_key_m, (void *)slt_val_m);
|
|
}
|
|
slt_entry = slt_entry->next_sibling;
|
|
}
|
|
}
|
|
|
|
static lls_slt_value_t *
|
|
get_lls_slt_val(packet_info *pinfo) {
|
|
/* This routine is for ATSC3 ALC/LCT packets (ipv4 only protocol by design)
|
|
so ipv6 is not supported by this test */
|
|
if (!(pinfo->net_src.type == AT_IPv4)) {
|
|
return NULL;
|
|
}
|
|
|
|
/* No ability to lookup a record */
|
|
if (lls_slt_table == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
/* Prepare for lookup in LLS SLT table */
|
|
lls_slt_key_t slt_key;
|
|
slt_key.src_ip = *(guint32 *)pinfo->net_src.data;
|
|
slt_key.dst_ip = *(guint32 *)pinfo->net_dst.data;
|
|
slt_key.dst_port = (guint16)pinfo->destport;
|
|
|
|
/* Try to lookup by src_ip + dst_ip + dst_port */
|
|
lls_slt_value_t *slt_val = (lls_slt_value_t *)wmem_map_lookup(lls_slt_table, (const void *)(&slt_key));
|
|
if(slt_val == NULL) {
|
|
/* No record in SLT table. src_ip is optional according to A/331 so try to lookup by dst ip + port */
|
|
slt_key.src_ip = 0; /* LLS SLT dissector sets it to 0 if source ip is not specified */
|
|
slt_val = (lls_slt_value_t *)wmem_map_lookup(lls_slt_table, (const void *)(&slt_key));
|
|
if (slt_val == NULL) {
|
|
/* Record not found by dst ip + port */
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return slt_val;
|
|
}
|
|
|
|
/* Heuristics test. Checks if packet is ALC using LLS SLT table */
|
|
gboolean
|
|
test_alc_over_slt(packet_info *pinfo, tvbuff_t *tvb _U_, int offset _U_, void *data _U_)
|
|
{
|
|
lls_slt_value_t *slt_val = get_lls_slt_val(pinfo);
|
|
if (slt_val == NULL)
|
|
return FALSE;
|
|
|
|
if (slt_val->sls_protocol == 1) {
|
|
/* slsProtocol=1 is ALC/LCT ROUTE/DASH */
|
|
return TRUE;
|
|
} else {
|
|
/* ACL/LCT is used only for ROUTE/DASH so return false */
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/* Returns channel info or NULL if no info in SLT table*/
|
|
gchar *
|
|
get_slt_channel_info(packet_info *pinfo)
|
|
{
|
|
lls_slt_value_t *slt_val = get_lls_slt_val(pinfo);
|
|
if (slt_val == NULL)
|
|
return NULL;
|
|
|
|
gint32 major_channel_num = slt_val->major_channel_num;
|
|
gint32 minor_channel_num = slt_val->minor_channel_num;
|
|
gchar *ret;
|
|
if (major_channel_num > 0 && minor_channel_num > 0) {
|
|
ret = wmem_strdup_printf(pinfo->pool, "ServiceID: %u Channel: %d.%d", slt_val->service_id,
|
|
major_channel_num, minor_channel_num);
|
|
} else {
|
|
ret = wmem_strdup_printf(pinfo->pool, "ServiceID: %u", slt_val->service_id);
|
|
}
|
|
|
|
return ret;
|
|
}
|