/* packet-someip.c

 * SOME/IP dissector.

 * By Dr. Lars Voelker <lars.voelker@technica-engineering.de> / <lars.voelker@bmw.de>

 * Copyright 2012-2025 Dr. Lars Völker

 * Copyright 2019      Ana Pantar

 * Copyright 2019      Guenter Ebermann

 *

 * 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/prefs.h>

#include <epan/expert.h>

#include <epan/to_str.h>

#include <epan/uat.h>

#include "packet-tcp.h"

#include <epan/reassemble.h>

#include <epan/addr_resolv.h>

#include <epan/stats_tree.h>

#include <epan/prefs-int.h>

#include "packet-udp.h"

#include "packet-dtls.h"

#include "packet-someip.h"

#include "packet-tls.h"

/*

 * Dissector for SOME/IP, SOME/IP-TP, and SOME/IP Payloads.

 *

 * See

 *     http://www.some-ip.com

 *

 *

 * This dissector also supports the experimental WTLV or TLV extension,

 * which is not part of the original SOME/IP.

 * This add-on feature uses a so-called WireType, which is basically

 * a type of a length field and an ID to each parameter. Since the

 * WireType is not really a type, we should avoid TLV as name for this.

 * Only use this, if you know what you are doing since this changes the

 * serialization methodology of SOME/IP in a incompatible way and might

 * break the dissection of your messages.

 */

#define SOMEIP_NAME_PREFIX                      "someip.payload.data"

#define SOMEIP_NAME_LONG_MULTIPLE               "SOME/IP Protocol (Multiple Payloads)"

#define SOMEIP_NAME_LONG_BROKEN                 "SOME/IP: Incomplete headers!"

#define SOMEIP_NAME_LONG_TOO_SHORT              "SOME/IP: Incomplete SOME/IP payload!"

 /*** Configuration ***/

#define DATAFILE_SOMEIP_SERVICES                "SOMEIP_service_identifiers"

#define DATAFILE_SOMEIP_METHODS                 "SOMEIP_method_event_identifiers"

#define DATAFILE_SOMEIP_EVENTGROUPS             "SOMEIP_eventgroup_identifiers"

#define DATAFILE_SOMEIP_CLIENTS                 "SOMEIP_client_identifiers"

#define DATAFILE_SOMEIP_PARAMETERS              "SOMEIP_parameter_list"

#define DATAFILE_SOMEIP_BASE_TYPES              "SOMEIP_parameter_base_types"

#define DATAFILE_SOMEIP_STRINGS                 "SOMEIP_parameter_strings"

#define DATAFILE_SOMEIP_STRUCTS                 "SOMEIP_parameter_structs"

#define DATAFILE_SOMEIP_ARRAYS                  "SOMEIP_parameter_arrays"

#define DATAFILE_SOMEIP_UNIONS                  "SOMEIP_parameter_unions"

#define DATAFILE_SOMEIP_TYPEDEFS                "SOMEIP_parameter_typedefs"

#define DATAFILE_SOMEIP_ENUMS                   "SOMEIP_parameter_enums"

#define DATAFILE_SOMEIP_BITFIELDS               "SOMEIP_parameter_bitfields"

#define SOMEIP_PARAMETER_DATA_TYPE_MIN          1

#define SOMEIP_PARAMETER_DATA_TYPE_BASE_TYPE    1

#define SOMEIP_PARAMETER_DATA_TYPE_STRING       2

#define SOMEIP_PARAMETER_DATA_TYPE_ARRAY        3

#define SOMEIP_PARAMETER_DATA_TYPE_STRUCT       4

#define SOMEIP_PARAMETER_DATA_TYPE_UNION        5

#define SOMEIP_PARAMETER_DATA_TYPE_TYPEDEF      6

#define SOMEIP_PARAMETER_DATA_TYPE_ENUM         7

#define SOMEIP_PARAMETER_DATA_TYPE_BITFIELD     8

#define SOMEIP_PARAMETER_DATA_TYPE_MAX          8

#define SOMEIP_PARAMETER_DATA_TYPE_BITFIELD_INT 0xFE

/*** SOME/IP ***/

#define SOMEIP_HDR_LEN                          16

#define SOMEIP_HDR_PART1_LEN                    8

#define SOMEIP_HDR_PART2_LEN_INCL_TP            12

#define SOMEIP_TP_HDR_LEN                       4

#define SOMEIP_PROTOCOL_VERSION                 1

/* Message Types */

#define SOMEIP_MSGTYPE_REQUEST                  0x00

#define SOMEIP_MSGTYPE_REQUEST_NO_RESPONSE      0x01

#define SOMEIP_MSGTYPE_NOTIFICATION             0x02

#define SOMEIP_MSGTYPE_RESPONSE                 0x80

#define SOMEIP_MSGTYPE_ERROR                    0x81

#define SOMEIP_MSGTYPE_ACK_MASK                 0x40

#define SOMEIP_MSGTYPE_TP_MASK                  0x20

#define SOMEIP_MSGTYPE_FLAGS_MASK               0x60

#define SOMEIP_MSGTYPE_NO_FLAGS_MASK            0x9f

#define SOMEIP_MSGTYPE_TP_STRING                "SOME/IP-TP segment"

#define SOMEIP_MSGTYPE_ACK_STRING               "ACK"

/* SOME/IP-TP */

#define SOMEIP_TP_OFFSET_MASK                   0xfffffff0

#define SOMEIP_TP_OFFSET_MASK_FLAGS             0x0000000f

#define SOMEIP_TP_OFFSET_MASK_RESERVED          0x0000000e

#define SOMEIP_TP_OFFSET_MASK_MORE_SEGMENTS     0x00000001

/* Return Codes */

#define SOMEIP_RETCODE_OK                       0x00

#define SOMEIP_RETCODE_NOT_OK                   0x01

#define SOMEIP_RETCODE_UNKNOWN_SERVICE          0x02

#define SOMEIP_RETCODE_UNKNOWN_METHOD           0x03

#define SOMEIP_RETCODE_NOT_READY                0x04

#define SOMEIP_RETCODE_NOT_REACHABLE            0x05

#define SOMEIP_RETCODE_TIMEOUT                  0x06

#define SOMEIP_RETCODE_WRONG_PROTO_VER          0x07

#define SOMEIP_RETCODE_WRONG_INTERFACE_VER      0x08

#define SOMEIP_RETCODE_MALFORMED_MSG            0x09

#define SOMEIP_RETCODE_WRONG_MESSAGE_TYPE       0x0a

/* SOME/IP WTLV (experimental "WTLV" extension) */

#define SOMEIP_WTLV_MASK_RES                    0x8000

#define SOMEIP_WTLV_MASK_WIRE_TYPE              0x7000

#define SOMEIP_WTLV_MASK_DATA_ID                0x0fff

/* ID wireshark identifies the dissector by */

static int proto_someip;

static module_t *someip_module;

static dissector_handle_t someip_handle_udp;

static dissector_handle_t someip_handle_tcp;

static dissector_handle_t dtls_handle;

/* header field */

static int hf_someip_messageid;

static int hf_someip_serviceid;

static int hf_someip_servicename;

static int hf_someip_methodid;

static int hf_someip_methodname;

static int hf_someip_length;

static int hf_someip_clientid;

static int hf_someip_clientname;

static int hf_someip_sessionid;

static int hf_someip_protover;

static int hf_someip_interface_ver;

static int hf_someip_messagetype;

static int hf_someip_messagetype_ack_flag;

static int hf_someip_messagetype_tp_flag;

static int hf_someip_returncode;

static int hf_someip_tp;

static int hf_someip_tp_offset;

static int hf_someip_tp_offset_encoded;

static int hf_someip_tp_flags;

static int hf_someip_tp_reserved;

static int hf_someip_tp_more_segments;

static int hf_someip_payload;

/* protocol tree items */

static int ett_someip;

static int ett_someip_msgtype;

static int ett_someip_tp;

/* dissector handling */

static dissector_table_t someip_dissector_table;

/* message reassembly for SOME/IP-TP */

static int hf_someip_tp_fragments;

static int hf_someip_tp_fragment;

static int hf_someip_tp_fragment_overlap;

static int hf_someip_tp_fragment_overlap_conflicts;

static int hf_someip_tp_fragment_multiple_tails;

static int hf_someip_tp_fragment_too_long_fragment;

static int hf_someip_tp_fragment_error;

static int hf_someip_tp_fragment_count;

static int hf_someip_tp_reassembled_in;

static int hf_someip_tp_reassembled_length;

static int hf_someip_tp_reassembled_data;

static int hf_payload_unparsed;

static int hf_payload_length_field_8bit;

static int hf_payload_length_field_16bit;

static int hf_payload_length_field_32bit;

static int hf_payload_type_field_8bit;

static int hf_payload_type_field_16bit;

static int hf_payload_type_field_32bit;

static int hf_payload_str_base;

static int hf_payload_str_string;

static int hf_payload_str_array;

static int hf_payload_str_struct;

static int hf_payload_str_union;

static int hf_payload_str_bitfield;

static int hf_payload_bitfield_item;

static int hf_payload_wtlv_tag;

static int hf_payload_wtlv_tag_res;

static int hf_payload_wtlv_tag_wire_type;

static int hf_payload_wtlv_tag_data_id;

static hf_register_info *dynamic_hf_param;

static unsigned dynamic_hf_param_size;

static hf_register_info *dynamic_hf_array;

static unsigned dynamic_hf_array_size;

static hf_register_info *dynamic_hf_struct;

static unsigned dynamic_hf_struct_size;

static hf_register_info *dynamic_hf_union;

static unsigned dynamic_hf_union_size;

static hf_register_info *dynamic_hf_bitfield;

static unsigned dynamic_hf_bitfield_size;

static int ett_someip_tp_fragment;

static int ett_someip_tp_fragments;

static int ett_someip_payload;

static int ett_someip_string;

static int ett_someip_array;

static int ett_someip_array_dim;

static int ett_someip_struct;

static int ett_someip_union;

static int ett_someip_bitfield;

static int ett_someip_parameter;

static int ett_someip_wtlv_tag;

static const fragment_items someip_tp_frag_items = {

    &ett_someip_tp_fragment,

    &ett_someip_tp_fragments,

    &hf_someip_tp_fragments,

    &hf_someip_tp_fragment,

    &hf_someip_tp_fragment_overlap,

    &hf_someip_tp_fragment_overlap_conflicts,

    &hf_someip_tp_fragment_multiple_tails,

    &hf_someip_tp_fragment_too_long_fragment,

    &hf_someip_tp_fragment_error,

    &hf_someip_tp_fragment_count,

    &hf_someip_tp_reassembled_in,

    &hf_someip_tp_reassembled_length,

    &hf_someip_tp_reassembled_data,

    "SOME/IP-TP Segments"

};

static bool someip_tp_reassemble = true;

static bool someip_deserializer_activated = true;

static bool someip_deserializer_debugging_activated;

static bool someip_deserializer_wtlv_default;

static bool someip_test_tcp_for_valid_someip = true;

static bool someip_detect_dtls;

/* SOME/IP Message Types */

static const value_string someip_msg_type[] = {

    {SOMEIP_MSGTYPE_REQUEST,                                            "Request"},

    {SOMEIP_MSGTYPE_REQUEST_NO_RESPONSE,                                "Request no response"},

    {SOMEIP_MSGTYPE_NOTIFICATION,                                       "Notification"},

    {SOMEIP_MSGTYPE_RESPONSE,                                           "Response"},

    {SOMEIP_MSGTYPE_ERROR,                                              "Error"},

    {SOMEIP_MSGTYPE_REQUEST | SOMEIP_MSGTYPE_ACK_MASK,                  "Request Ack"},

    {SOMEIP_MSGTYPE_REQUEST_NO_RESPONSE | SOMEIP_MSGTYPE_ACK_MASK,      "Request no response Ack"},

    {SOMEIP_MSGTYPE_NOTIFICATION | SOMEIP_MSGTYPE_ACK_MASK,             "Notification Ack"},

    {SOMEIP_MSGTYPE_RESPONSE | SOMEIP_MSGTYPE_ACK_MASK,                 "Response Ack"},

    {SOMEIP_MSGTYPE_ERROR | SOMEIP_MSGTYPE_ACK_MASK,                    "Error Ack"},

    {0, NULL}

};

/* SOME/IP Return Code */

static const value_string someip_return_code[] = {

    {SOMEIP_RETCODE_OK,                                                 "Ok"},

    {SOMEIP_RETCODE_NOT_OK,                                             "Not Ok"},

    {SOMEIP_RETCODE_UNKNOWN_SERVICE,                                    "Unknown Service"},

    {SOMEIP_RETCODE_UNKNOWN_METHOD,                                     "Unknown Method/Event"},

    {SOMEIP_RETCODE_NOT_READY,                                          "Not Ready"},

    {SOMEIP_RETCODE_NOT_REACHABLE,                                      "Not Reachable (internal)"},

    {SOMEIP_RETCODE_TIMEOUT,                                            "Timeout (internal)"},

    {SOMEIP_RETCODE_WRONG_PROTO_VER,                                    "Wrong Protocol Version"},

    {SOMEIP_RETCODE_WRONG_INTERFACE_VER,                                "Wrong Interface Version"},

    {SOMEIP_RETCODE_MALFORMED_MSG,                                      "Malformed Message"},

    {SOMEIP_RETCODE_WRONG_MESSAGE_TYPE,                                 "Wrong Message Type"},

    {0, NULL}

};

/*** expert info items ***/

static expert_field ei_someip_unknown_version;

static expert_field ei_someip_message_truncated;

static expert_field ei_someip_incomplete_headers;

static expert_field ei_someip_payload_truncated;

static expert_field ei_someip_payload_malformed;

static expert_field ei_someip_payload_config_error;

static expert_field ei_someip_payload_alignment_error;

static expert_field ei_someip_payload_static_array_min_not_max;

static expert_field ei_someip_payload_dyn_array_not_within_limit;

static expert_field ei_someip_payload_disabled;

/*** Data Structure for mapping IDs to Names (Services, Methods, ...) ***/

static GHashTable *data_someip_services;

static GHashTable *data_someip_methods;

static GHashTable *data_someip_eventgroups;

static GHashTable *data_someip_clients;

static GHashTable *data_someip_parameter_list;

static GHashTable *data_someip_parameter_base_type_list;

static GHashTable *data_someip_parameter_strings;

static GHashTable *data_someip_parameter_arrays;

static GHashTable *data_someip_parameter_structs;

static GHashTable *data_someip_parameter_unions;

static GHashTable *data_someip_parameter_typedefs;

static GHashTable *data_someip_parameter_enums;

static GHashTable *data_someip_parameter_bitfields;

/*** Taps ***/

static int tap_someip_messages = -1;

/*** Stats ***/

static const char *st_str_ip_src = "Source Addresses";

static const char *st_str_ip_dst = "Destination Addresses";

static int st_node_ip_src = -1;

static int st_node_ip_dst = -1;

/***********************************************

 ********* Preferences / Configuration *********

 ***********************************************/

/*** Parameter List UAT ***/

typedef struct _someip_payload_parameter_item {

    uint32_t    pos;

    char       *name;

    uint32_t    data_type;

    uint32_t    id_ref;

    int        *hf_id;

    char       *filter_string;

} someip_parameter_item_t;

#define INIT_SOMEIP_PARAMETER_ITEM(NAME) \

    (NAME)->pos = 0; \

    (NAME)->name = NULL; \

    (NAME)->data_type = 0; \

    (NAME)->id_ref = 0; \

    (NAME)->hf_id = NULL; \

    (NAME)->filter_string = NULL;

typedef struct _someip_parameter_list {

    uint32_t            service_id;

    uint32_t            method_id;

    uint32_t            version;

    uint32_t            message_type;

    bool                wtlv_encoding;

    uint32_t            num_of_items;

    someip_parameter_item_t *items;

} someip_parameter_list_t;

typedef struct _someip_parameter_list_uat {

    uint32_t            service_id;

    uint32_t            method_id;

    uint32_t            version;

    uint32_t            message_type;

    bool                wtlv_encoding;

    uint32_t            num_of_params;

    uint32_t            pos;

    char               *name;

    uint32_t            data_type;

    uint32_t            id_ref;

    char               *filter_string;

} someip_parameter_list_uat_t;

/*** Parameter Basetypes UAT (ID: 1) ***/

typedef struct _someip_parameter_base_type_list {

    uint32_t    id;

    char       *name;

    char       *data_type;

    bool        big_endian;

    uint32_t    bitlength_base_type;

    uint32_t    bitlength_encoded_type;

} someip_parameter_base_type_list_t;

#define INIT_COMMON_BASE_TYPE_LIST_ITEM(NAME) \

    (NAME)->id                      = 0; \

    (NAME)->name                    = NULL; \

    (NAME)->data_type               = NULL ; \

    (NAME)->big_endian              = true; \

    (NAME)->bitlength_base_type     = 0; \

    (NAME)->bitlength_encoded_type  = 0;

typedef someip_parameter_base_type_list_t someip_parameter_base_type_list_uat_t;

/*** Parameter Strings UAT (ID: 2) ***/

typedef struct _someip_parameter_string {

    uint32_t    id;

    char       *name;

    char       *encoding;

    bool        dynamic_length;

    uint32_t    max_length;

    uint32_t    length_of_length;   /* default: 32 */

    bool        big_endian;

    uint32_t    pad_to;

} someip_parameter_string_t;

#define INIT_SOMEIP_PARAMETER_STRING(NAME) \

    (NAME)->id                  = 0; \

    (NAME)->name                = NULL; \

    (NAME)->encoding            = NULL; \

    (NAME)->dynamic_length      = false; \

    (NAME)->max_length          = 0; \

    (NAME)->length_of_length    = 0; \

    (NAME)->big_endian          = true; \

    (NAME)->pad_to              = 0;

typedef someip_parameter_string_t someip_parameter_string_uat_t;

/*** Parameter Array UAT (ID: 3) ***/

typedef struct _someip_parameter_array_dim {

    uint32_t            num;

    uint32_t            lower_limit;

    uint32_t            upper_limit;

    uint32_t            length_of_length;

    uint32_t            pad_to;

} someip_parameter_array_dim_t;

typedef struct _someip_parameter_array {

    uint32_t            id;

    char               *name;

    uint32_t            data_type;

    uint32_t            id_ref;

    uint32_t            num_of_dims;

    int                *hf_id;

    char               *filter_string;

    someip_parameter_array_dim_t *dims;

} someip_parameter_array_t;

typedef struct _someip_parameter_array_uat {

    uint32_t            id;

    char               *name;

    uint32_t            data_type;

    uint32_t            id_ref;

    uint32_t            num_of_dims;

    char               *filter_string;

    uint32_t            num;

    uint32_t            lower_limit;

    uint32_t            upper_limit;

    uint32_t            length_of_length;

    uint32_t            pad_to;

} someip_parameter_array_uat_t;

/*** Parameter Struct UAT (ID: 4) ***/

typedef struct _someip_parameter_struct {

    uint32_t    id;

    char       *struct_name;

    uint32_t    length_of_length;   /* default: 0 */

    uint32_t    pad_to;             /* default: 0 */

    bool        wtlv_encoding;

    uint32_t    num_of_items;

    /* array of items */

    someip_parameter_item_t *items;

} someip_parameter_struct_t;

#define INIT_SOMEIP_PARAMETER_STRUCT(NAME) \

    (NAME)->id                  = 0; \

    (NAME)->struct_name         = NULL; \

    (NAME)->length_of_length    = 0; \

    (NAME)->pad_to              = 0; \

    (NAME)->wtlv_encoding       = false; \

    (NAME)->num_of_items        = 0;

typedef struct _someip_parameter_struct_uat {

    uint32_t            id;

    char               *struct_name;

    uint32_t            length_of_length;       /* default: 0 */

    uint32_t            pad_to;                 /* default: 0 */

    bool                wtlv_encoding;

    uint32_t            num_of_items;

    uint32_t            pos;

    char               *name;

    uint32_t            data_type;

    uint32_t            id_ref;

    char               *filter_string;

} someip_parameter_struct_uat_t;

/*** Parameter Union UAT (ID: 5) ***/

typedef struct _someip_parameter_union_item {

    uint32_t            id;

    char               *name;

    uint32_t            data_type;

    uint32_t            id_ref;

    int                *hf_id;

    char               *filter_string;

} someip_parameter_union_item_t;

typedef struct _someip_parameter_union {

    uint32_t            id;

    char               *name;

    uint32_t            length_of_length;       /* default: 32 */

    uint32_t            length_of_type;         /* default: 32 */

    uint32_t            pad_to;                 /* default: 0 */

    uint32_t            num_of_items;

    someip_parameter_union_item_t *items;

} someip_parameter_union_t;

typedef struct _someip_parameter_union_uat {

    uint32_t            id;

    char               *name;

    uint32_t            length_of_length;

    uint32_t            length_of_type;

    uint32_t            pad_to;

    uint32_t            num_of_items;

    uint32_t            type_id;

    char               *type_name;

    uint32_t            data_type;

    uint32_t            id_ref;

    char               *filter_string;

} someip_parameter_union_uat_t;

/*** Parameter Typedef UAT (ID: 6) ***/

typedef struct _someip_parameter_typedef {

    uint32_t   id;

    char      *name;

    uint32_t   data_type;

    uint32_t   id_ref;

} someip_parameter_typedef_t;

#define INIT_SOMEIP_PARAMETER_TYPEDEF(NAME) \

    (NAME)->id          = 0; \

    (NAME)->name        = NULL; \

    (NAME)->data_type   = 0; \

    (NAME)->id_ref      = 0;

typedef someip_parameter_typedef_t someip_parameter_typedef_uat_t;

/*** Parameter Enum UAT (ID: 7) ***/

typedef struct _someip_parameter_enum_item {

    uint64_t    value;

    char       *name;

} someip_parameter_enum_item_t;

#define INIT_SOMEIP_PARAMETER_ENUM_ITEM(NAME) \

    (NAME)->value   = 0; \

    (NAME)->name    = NULL;

typedef struct _someip_parameter_enum {

    uint32_t    id;

    char       *name;

    uint32_t    data_type;

    uint32_t    id_ref;

    uint32_t    num_of_items;

    someip_parameter_enum_item_t *items;

} someip_parameter_enum_t;

#define INIT_SOMEIP_PAYLOAD_PARAMETER_ENUM(NAME) \

    (NAME)->id              = 0; \

    (NAME)->name            = NULL; \

    (NAME)->data_type       = 0; \

    (NAME)->id_ref          = 0; \

    (NAME)->num_of_items    = 0; \

    (NAME)->items           = NULL;

typedef struct _someip_parameter_enum_uat {

    uint32_t            id;

    char               *name;

    uint32_t            data_type;

    uint32_t            id_ref;

    uint32_t            num_of_items;

    uint32_t            value;

    char               *value_name;

} someip_parameter_enum_uat_t;

/*** Parameter Bitfield UAT (ID: 8) ***/

typedef struct _someip_parameter_bitfield_item {

    uint8_t     bit_number;

    char       *bit_name;

    int        *hf_id;

    char       *filter_string;

} someip_parameter_bitfield_item_t;

#define INIT_SOMEIP_PARAMETER_BITFIELD_ITEM(NAME) \

    (NAME)->bit_number      = 0; \

    (NAME)->bit_name        = NULL; \

    (NAME)->hf_id           = NULL; \

    (NAME)->filter_string   = NULL;

typedef struct _someip_parameter_bitfield {

    uint32_t    id;

    char       *name;

    uint8_t     number_of_bits;

    uint32_t    num_of_items;

    someip_parameter_bitfield_item_t *items;

} someip_parameter_bitfield_t;

#define INIT_SOMEIP_PARAMETER_BITFIELD(NAME) \

    (NAME)->id              = 0; \

    (NAME)->name            = NULL; \

    (NAME)->number_of_bits  = 0; \

    (NAME)->num_of_items    = 0; \

    (NAME)->items           = NULL;

typedef struct _someip_parameter_bitfield_uat {

    uint32_t            id;

    char               *name;

    uint32_t            number_of_bits;

    uint32_t            num_of_items;

    uint32_t            bit_number;

    char               *bit_name;

    char               *filter_string;

} someip_parameter_bitfield_uat_t;

typedef struct _generic_one_id_string {

    unsigned   id;

    char   *name;

} generic_one_id_string_t;

typedef struct _generic_two_id_string {

    unsigned   id;

    unsigned   id2;

    char   *name;

} generic_two_id_string_t;

static generic_one_id_string_t *someip_service_ident;

static unsigned someip_service_ident_num;

static generic_two_id_string_t *someip_method_ident;

static unsigned someip_method_ident_num;

static generic_two_id_string_t *someip_eventgroup_ident;

static unsigned someip_eventgroup_ident_num;

static generic_two_id_string_t *someip_client_ident;

static unsigned someip_client_ident_num;

static someip_parameter_list_uat_t *someip_parameter_list;

static unsigned someip_parameter_list_num;

static someip_parameter_base_type_list_uat_t *someip_parameter_base_type_list;

static unsigned someip_parameter_base_type_list_num;

static someip_parameter_string_uat_t *someip_parameter_strings;

static unsigned someip_parameter_strings_num;

static someip_parameter_array_uat_t *someip_parameter_arrays;

static unsigned someip_parameter_arrays_num;

static someip_parameter_struct_uat_t *someip_parameter_structs;

static unsigned someip_parameter_structs_num;

static someip_parameter_union_uat_t *someip_parameter_unions;

static unsigned someip_parameter_unions_num;

static someip_parameter_typedef_uat_t *someip_parameter_typedefs;

static unsigned someip_parameter_typedefs_num;

static someip_parameter_enum_uat_t *someip_parameter_enums;

static unsigned someip_parameter_enums_num;

static someip_parameter_bitfield_uat_t *someip_parameter_bitfields;

static unsigned someip_parameter_bitfields_num;

void proto_register_someip(void);

void proto_reg_handoff_someip(void);

/* Segmentation support

 * https://gitlab.com/wireshark/wireshark/-/issues/18880

 */

typedef struct _someip_segment_key {

    address src_addr;

    address dst_addr;

    uint32_t src_port;

    uint32_t dst_port;

    someip_info_t info;

} someip_segment_key;

static unsigned

someip_segment_hash(const void *k)

{

    const someip_segment_key *key = (const someip_segment_key *)k;

    unsigned hash_val;

    hash_val = (key->info.service_id << 16 | key->info.method_id) ^

               (key->info.client_id << 16 | key->info.session_id);

    return hash_val;

}

static int

someip_segment_equal(const void *k1, const void *k2)

{

    const someip_segment_key *key1 = (someip_segment_key *)k1;

    const someip_segment_key *key2 = (someip_segment_key *)k2;

    return (key1->info.session_id == key2->info.session_id) &&

        (key1->info.service_id == key2->info.service_id) &&

        (key1->info.client_id == key2->info.client_id) &&

        (key1->info.method_id == key2->info.method_id) &&

        (key1->info.message_type == key2->info.message_type) &&

        (key1->info.major_version == key2->info.major_version) &&

        (addresses_equal(&key1->src_addr, &key2->src_addr)) &&

        (addresses_equal(&key1->dst_addr, &key2->dst_addr)) &&

        (key1->src_port == key2->src_port) &&

        (key1->dst_port == key2->dst_port);

}

/*

 * Create a fragment key for temporary use; it can point to non-

 * persistent data, and so must only be used to look up and

 * delete entries, not to add them.

 */

static void *

someip_segment_temporary_key(const packet_info *pinfo, const uint32_t id _U_,

                          const void *data)

{

    const someip_info_t *info = (const someip_info_t *)data;

    someip_segment_key *key = g_slice_new(someip_segment_key);

    /* Do a shallow copy of the addresses. */

    copy_address_shallow(&key->src_addr, &pinfo->src);

    copy_address_shallow(&key->dst_addr, &pinfo->dst);

    key->src_port = pinfo->srcport;

    key->dst_port = pinfo->destport;

    memcpy(&key->info, info, sizeof(someip_info_t));

    return (void *)key;

}

/*

 * Create a fragment key for permanent use; it must point to persistent

 * data, so that it can be used to add entries.

 */

static void *

someip_segment_persistent_key(const packet_info *pinfo,

                              const uint32_t id _U_, const void *data)

{

    const someip_info_t *info = (const someip_info_t *)data;

    someip_segment_key *key = g_slice_new(someip_segment_key);

    /* Do a deep copy of the addresses. */

    copy_address(&key->src_addr, &pinfo->src);

    copy_address(&key->dst_addr, &pinfo->dst);

    key->src_port = pinfo->srcport;

    key->dst_port = pinfo->destport;

    memcpy(&key->info, info, sizeof(someip_info_t));

    return (void *)key;

}

static void

someip_segment_free_temporary_key(void *ptr)

{

    someip_segment_key *key = (someip_segment_key *)ptr;

    if (key) {

        g_slice_free(someip_segment_key, key);

    }

}

static void

someip_segment_free_persistent_key(void *ptr)

{

    someip_segment_key *key = (someip_segment_key *)ptr;

    if (key) {

        /* Free up the copies of the addresses from the old key. */

        free_address(&key->src_addr);

        free_address(&key->dst_addr);

        g_slice_free(someip_segment_key, key);

    }

}

static const reassembly_table_functions

someip_reassembly_table_functions = {

    someip_segment_hash,

    someip_segment_equal,

    someip_segment_temporary_key,

    someip_segment_persistent_key,

    someip_segment_free_temporary_key,

    someip_segment_free_persistent_key

};

static reassembly_table someip_tp_reassembly_table;

/* register a UDP SOME/IP port */

void

register_someip_port_udp(uint32_t portnumber) {

    dissector_add_uint("udp.port", portnumber, someip_handle_udp);

}

/* register a TCP SOME/IP port */

void

register_someip_port_tcp(uint32_t portnumber) {

    dissector_add_uint("tcp.port", portnumber, someip_handle_tcp);

}

/*** UAT Callbacks and Helpers ***/

static void

set_prefs_changed(void) {

    /* This ensures that proto_reg_handoff_someip is called, even if SOME/IP is not bound to any port yet. */

    if (someip_module) {

        someip_module->prefs_changed_flags |= (PREF_EFFECT_DISSECTION|PREF_EFFECT_FIELDS);

    }

}

static char*

check_filter_string(char *filter_string, uint32_t id) {

    char   *err = NULL;

    unsigned char  c;

    c = proto_check_field_name(filter_string);

    if (c) {

        if (c == '.') {

            err = ws_strdup_printf("Filter String contains illegal chars '.' (ID: %i )", id);

        } else if (g_ascii_isprint(c)) {

            err = ws_strdup_printf("Filter String contains illegal chars '%c' (ID: %i)", c, id);

        } else {

            err = ws_strdup_printf("Filter String contains invalid byte \\%03o (ID: %i)", c, id);

        }

    }

    return err;

}

/* ID -> Name */

static void *

copy_generic_one_id_string_cb(void *n, const void *o, size_t size _U_) {

    generic_one_id_string_t        *new_rec = (generic_one_id_string_t *)n;

    const generic_one_id_string_t  *old_rec = (const generic_one_id_string_t *)o;

    new_rec->name = g_strdup(old_rec->name);

    new_rec->id   = old_rec->id;

    return new_rec;

}

static bool

update_serviceid(void *r, char **err) {

    generic_one_id_string_t *rec = (generic_one_id_string_t *)r;

    if (rec->id == 0xffff) {

        *err = ws_strdup_printf("Service-ID 0xffff is reserved and cannot be used (ID: %i  Name: %s)", rec->id, rec->name);

        return false;

    }

    if (rec->id > 0xffff) {

        *err = ws_strdup_printf("Service-IDs have to be 16bit (ID: %i  Name: %s)", rec->id, rec->name);

        return false;

    }

    if (rec->name == NULL || rec->name[0] == 0) {

        *err = g_strdup("Name cannot be empty");

        return false;

    }

    return true;

}

static void

free_generic_one_id_string_cb(void *r) {

    generic_one_id_string_t *rec = (generic_one_id_string_t *)r;

    /* freeing result of g_strdup */

    g_free(rec->name);

    rec->name = NULL;

}

/* ID/ID2 -> Name */

static void *

copy_generic_two_id_string_cb(void *n, const void *o, size_t size _U_) {

    generic_two_id_string_t        *new_rec = (generic_two_id_string_t *)n;

    const generic_two_id_string_t  *old_rec = (const generic_two_id_string_t *)o;

    new_rec->name = g_strdup(old_rec->name);

    new_rec->id   = old_rec->id;

    new_rec->id2  = old_rec->id2;

    return new_rec;

}

static bool

update_two_identifier_16bit_check_both(void *r, char **err) {

    generic_two_id_string_t *rec = (generic_two_id_string_t *)r;

    if (rec->id == 0xffff) {

        *err = ws_strdup_printf("Service-ID 0xffff is reserved and cannot be used (ID: %i  Name: %s)", rec->id, rec->name);

        return false;

    }

    if (rec->id > 0xffff) {

        *err = ws_strdup_printf("Service-IDs have to be 16bit (ID: %i  Name: %s)", rec->id, rec->name);

        return false;

    }

    if (rec->id2 == 0xffff) {

        *err = ws_strdup_printf("0xffff is reserved and cannot be used (ID: %i  ID2: %i  Name: %s)", rec->id, rec->id2, rec->name);

        return false;

    }

    if (rec->id2 > 0xffff) {

        *err = ws_strdup_printf("We currently only support 16 bit identifiers (ID: %i  ID2: %i  Name: %s)", rec->id, rec->id2, rec->name);

        return false;

    }

    if (rec->name == NULL || rec->name[0] == 0) {

        *err = g_strdup("Name cannot be empty");

        return false;

    }

    return true;

}

static bool

update_generic_two_identifier_16bit(void *r, char **err) {

    generic_two_id_string_t *rec = (generic_two_id_string_t *)r;

    if (rec->id > 0xffff) {

        *err = ws_strdup_printf("We currently only support 16 bit identifiers (ID: %i  Name: %s)", rec->id, rec->name);

        return false;

    }

    if (rec->id2 > 0xffff) {

        *err = ws_strdup_printf("We currently only support 16 bit identifiers (ID: %i  ID2: %i  Name: %s)", rec->id, rec->id2, rec->name);

        return false;

    }

    if (rec->name == NULL || rec->name[0] == 0) {

        *err = g_strdup("Name cannot be empty");

        return false;

    }

    return true;

}

static void

free_generic_two_id_string_cb(void *r) {

    generic_two_id_string_t *rec = (generic_two_id_string_t *)r;

    /* freeing result of g_strdup */

    g_free(rec->name);

    rec->name = NULL;

}

char *

someip_lookup_service_name(uint16_t serviceid) {

    if (data_someip_services == NULL) {

        return NULL;

    }

    return g_hash_table_lookup(data_someip_services, GUINT_TO_POINTER(serviceid));

}

static char *

someip_lookup_method_name(uint16_t serviceid, uint16_t methodid) {

    if (data_someip_methods == NULL) {

        return NULL;

    }

    return (char *)g_hash_table_lookup(data_someip_methods, GUINT_TO_POINTER(((uint32_t)serviceid << 16) | (uint32_t)methodid));

}

char *

someip_lookup_eventgroup_name(uint16_t serviceid, uint16_t eventgroupid) {

    if (data_someip_eventgroups == NULL) {

        return NULL;

    }

    return g_hash_table_lookup(data_someip_eventgroups, GUINT_TO_POINTER(((uint32_t)serviceid << 16) | (uint32_t)eventgroupid));

}

static char *

someip_lookup_client_name(uint16_t serviceid, uint16_t clientid) {

    if (data_someip_clients == NULL) {

        return NULL;

    }

    return (char *)g_hash_table_lookup(data_someip_clients, GUINT_TO_POINTER(((uint32_t)serviceid << 16) | (uint32_t)clientid));

}

/*** SOME/IP Services ***/

UAT_HEX_CB_DEF        (someip_service_ident, id,    generic_one_id_string_t)

Unexecuted instantiation: packet-someip.c:someip_service_ident_id_set_cb

Unexecuted instantiation: packet-someip.c:someip_service_ident_id_tostr_cb

UAT_CSTRING_CB_DEF    (someip_service_ident, name,  generic_one_id_string_t)

static void

reset_someip_service_cb(void) {

    /* destroy old hash table, if it exists */

    if (data_someip_services) {

        g_hash_table_destroy(data_someip_services);

        data_someip_services = NULL;

    }

}

static void

post_update_someip_service_cb(void) {

    reset_someip_service_cb();

    /* create new hash table */

    data_someip_services = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, NULL);

    for (unsigned i = 0; i < someip_service_ident_num; i++) {

        g_hash_table_insert(data_someip_services, GUINT_TO_POINTER(someip_service_ident[i].id), someip_service_ident[i].name);

    }

}

/*** SOME/IP Methods/Events/Fields ***/

UAT_HEX_CB_DEF      (someip_method_ident, id,   generic_two_id_string_t)

Unexecuted instantiation: packet-someip.c:someip_method_ident_id_set_cb

Unexecuted instantiation: packet-someip.c:someip_method_ident_id_tostr_cb

UAT_HEX_CB_DEF      (someip_method_ident, id2,  generic_two_id_string_t)

Unexecuted instantiation: packet-someip.c:someip_method_ident_id2_set_cb

Unexecuted instantiation: packet-someip.c:someip_method_ident_id2_tostr_cb

UAT_CSTRING_CB_DEF  (someip_method_ident, name, generic_two_id_string_t)

static void

reset_someip_method_cb(void) {

    /* destroy old hash table, if it exists */

    if (data_someip_methods) {

        g_hash_table_destroy(data_someip_methods);

        data_someip_methods = NULL;

    }

}

static void

post_update_someip_method_cb(void) {