/** @file

 *

 * Common functionality for all wiretaps handling SocketCAN encapsulation

 *

 * Wiretap Library

 * Copyright (c) 1998 by Gilbert Ramirez <gram@alumni.rice.edu>

 *

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

 */

#include "config.h"

#include "socketcan.h"

#include <epan/dissectors/packet-socketcan.h>

typedef struct can_frame {

    uint32_t can_id;                       /* 32 bit CAN_ID + EFF/RTR/ERR flags */

    uint8_t can_dlc;                      /* frame payload length in byte (0 .. CAN_MAX_DLEN) */

    uint8_t __pad;                        /* padding */

    uint8_t __res0;                       /* reserved / padding */

    uint8_t __res1;                       /* reserved / padding */

    uint8_t data[CAN_MAX_DLEN];

} can_frame_t;

typedef struct canfd_frame {

    uint32_t can_id;                       /* 32 bit CAN_ID + EFF flag */

    uint8_t len;                          /* frame payload length in byte */

    uint8_t flags;                        /* additional flags for CAN FD */

    uint8_t __res0;                       /* reserved / padding */

    uint8_t __res1;                       /* reserved / padding */

    uint8_t data[CANFD_MAX_DLEN];

} canfd_frame_t;

typedef struct can_priv_data {

    GHashTable* interface_ids;  /* map name/description/link-layer type to interface ID */

    unsigned num_interface_ids; /* Number of interface IDs assigned */

    void (*tap_close)(void*);

    void* tap_priv;

} can_priv_data_t;

/*

 * Hash table to map interface name to interface ID.

 */

static gboolean

destroy_if_name(void* key, void* value _U_, void* user_data _U_)

{

    char* name = (char*)key;

    g_free(name);

    return true;

}

static void

add_new_if_name(can_priv_data_t* can_data, const char* name, void** result)

{

    char* new_name;

    new_name = g_strdup(name);

    *result = GUINT_TO_POINTER(can_data->num_interface_ids);

    g_hash_table_insert(can_data->interface_ids, (void*)new_name, *result);

    can_data->num_interface_ids++;

}

static void

wtap_socketcan_close(wtap* wth)

{

    //Clean up wiretap data

    can_priv_data_t* data = (can_priv_data_t*)wth->priv;

    if (data->tap_close != NULL)

        data->tap_close(data->tap_priv);

    //Cleanup our interface data

    g_hash_table_foreach_remove(data->interface_ids, destroy_if_name, NULL);

    g_hash_table_destroy(data->interface_ids);

    g_free(data);

    wth->priv = NULL;

}

void*

wtap_socketcan_get_private_data(wtap* wth)

{

    can_priv_data_t* socket_can_data = (can_priv_data_t*)wth->priv;

    return socket_can_data->tap_priv;

}

void

wtap_set_as_socketcan(wtap* wth, int file_type_subtype, int tsprec, void* tap_priv, void (*tap_close)(void*))

{

    //Create the private data that wraps over the wiretap's private data

    can_priv_data_t* socketcan_priv_data = g_new0(can_priv_data_t, 1);

    socketcan_priv_data->interface_ids = g_hash_table_new(g_str_hash, g_str_equal);

    socketcan_priv_data->tap_priv = tap_priv;

    socketcan_priv_data->tap_close = tap_close;

    wth->file_type_subtype = file_type_subtype;

    wth->file_encap = WTAP_ENCAP_SOCKETCAN;

    wth->file_tsprec = tsprec;

    wth->subtype_close = wtap_socketcan_close;

    wth->priv = socketcan_priv_data;

}

bool

wtap_socketcan_gen_packet(wtap* wth, wtap_rec* rec, const wtap_can_msg_t* msg, char* module_name, int* err, char** err_info)

{

    bool is_fd = false,

         is_eff = false,

         is_rtr = false,

         is_err = false;

    switch (msg->type)

    {

    case MSG_TYPE_STD:

        //No flags

        break;

    case MSG_TYPE_EXT:

        is_eff = true;

        break;

    case MSG_TYPE_STD_RTR:

        is_rtr = true;

        break;

    case MSG_TYPE_EXT_RTR:

        is_rtr = is_eff = true;

        break;

    case MSG_TYPE_STD_FD:

        is_fd = true;

        break;

    case MSG_TYPE_EXT_FD:

        is_fd = is_eff = true;

        break;

    case MSG_TYPE_ERR:

        is_err = true;

        break;

    }

    /* Generate Exported PDU tags for the packet info */

    ws_buffer_clean(&rec->data);

    if (is_fd)

    {

        canfd_frame_t canfd_frame = { 0 };

        /*

         * There's a maximum of CANFD_MAX_DLEN bytes in a CAN-FD frame.

         */

        if (msg->data.length > CANFD_MAX_DLEN) {

            *err = WTAP_ERR_BAD_FILE;

            if (err_info != NULL) {

                *err_info = ws_strdup_printf("%s: File has %u-byte CAN FD packet, bigger than maximum of %u",

                    module_name, msg->data.length, CANFD_MAX_DLEN);

            }

            return false;

        }

        canfd_frame.can_id = g_htonl((msg->id & (is_eff ? CAN_EFF_MASK : CAN_SFF_MASK)) |

            (is_eff ? CAN_EFF_FLAG : 0) |

            (is_err ? CAN_ERR_FLAG : 0));

        canfd_frame.flags = msg->flags | CANFD_FDF;

        canfd_frame.len = msg->data.length;

        memcpy(canfd_frame.data, msg->data.data, msg->data.length);

        ws_buffer_append(&rec->data, (uint8_t*)&canfd_frame, sizeof(canfd_frame));

    }

    else

    {

        can_frame_t can_frame = { 0 };

        /*

         * There's a maximum of CAN_MAX_DLEN bytes in a CAN frame.

         */

        if (msg->data.length > CAN_MAX_DLEN) {

            *err = WTAP_ERR_BAD_FILE;

            if (err_info != NULL) {

                *err_info = ws_strdup_printf("%s: File has %u-byte CAN packet, bigger than maximum of %u",

                    module_name, msg->data.length, CAN_MAX_DLEN);

            }

            return false;

        }

        can_frame.can_id = g_htonl((msg->id & (is_eff ? CAN_EFF_MASK : CAN_SFF_MASK)) |

            (is_rtr ? CAN_RTR_FLAG : 0) |

            (is_eff ? CAN_EFF_FLAG : 0) |

            (is_err ? CAN_ERR_FLAG : 0));

        can_frame.can_dlc = msg->data.length;

        memcpy(can_frame.data, msg->data.data, msg->data.length);

        ws_buffer_append(&rec->data, (uint8_t*)&can_frame, sizeof(can_frame));

    }

    wtap_setup_packet_rec(rec, wth->file_encap);

    rec->block = wtap_block_create(WTAP_BLOCK_PACKET);

    rec->presence_flags = WTAP_HAS_TS;

    rec->ts = msg->ts;

    rec->tsprec = wth->file_tsprec;

    rec->rec_header.packet_header.caplen = (uint32_t)ws_buffer_length(&rec->data);

    rec->rec_header.packet_header.len = (uint32_t)ws_buffer_length(&rec->data);

    if (msg->interface_id != 0xFFFFFFFF) {

        rec->presence_flags |= WTAP_HAS_INTERFACE_ID;

        rec->rec_header.packet_header.interface_id = msg->interface_id;

    }

    return true;

}

uint32_t

wtap_socketcan_find_or_create_new_interface(wtap* wth, const char* name)

{

    void* result = NULL;

    can_priv_data_t* can_data = (can_priv_data_t*)wth->priv;

    if (!g_hash_table_lookup_extended(can_data->interface_ids, name, NULL, &result))

    {

        wtap_block_t int_data;

        wtapng_if_descr_mandatory_t* int_data_mand;

        /*

         * Not found; make a new entry.

         */

        add_new_if_name(can_data, name, &result);

        /*

         * Now make a new IDB and add it.

         */

        int_data = wtap_block_create(WTAP_BLOCK_IF_ID_AND_INFO);

        int_data_mand = (wtapng_if_descr_mandatory_t*)wtap_block_get_mandatory_data(int_data);

        int_data_mand->wtap_encap = WTAP_ENCAP_SOCKETCAN;

        int_data_mand->tsprecision = WTAP_TSPREC_USEC;

        int_data_mand->time_units_per_second = 1000000; /* Microsecond resolution */

        int_data_mand->snap_len = WTAP_MAX_PACKET_SIZE_STANDARD; /* XXX - not known */

        wtap_block_add_uint8_option(int_data, OPT_IDB_TSRESOL, 0x06); /* microsecond resolution */

        /* Interface statistics */

        int_data_mand->num_stat_entries = 0;

        int_data_mand->interface_statistics = NULL;

        wtap_block_set_string_option_value(int_data, OPT_IDB_NAME, name, strlen(name));

        wtap_add_idb(wth, int_data);

    }

    return GPOINTER_TO_UINT(result);

}