// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
/*
 * Copyright (c) 2011 Volkswagen Group Electronic Research
 * All rights reserved.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <net/if.h>
#include <linux/if.h>

#include <linux/can.h>
#include <linux/can/raw.h>

#include "kselftest_harness.h"

#define ID 0x123

char CANIF[IFNAMSIZ];

static int send_can_frames(int sock, int testcase)
{
        struct can_frame frame;

        frame.can_dlc = 1;
        frame.data[0] = testcase;

        frame.can_id = ID;
        if (write(sock, &frame, sizeof(frame)) < 0)
                goto write_err;

        frame.can_id = (ID | CAN_RTR_FLAG);
        if (write(sock, &frame, sizeof(frame)) < 0)
                goto write_err;

        frame.can_id = (ID | CAN_EFF_FLAG);
        if (write(sock, &frame, sizeof(frame)) < 0)
                goto write_err;

        frame.can_id = (ID | CAN_EFF_FLAG | CAN_RTR_FLAG);
        if (write(sock, &frame, sizeof(frame)) < 0)
                goto write_err;

        return 0;

write_err:
        perror("write");
        return 1;
}

FIXTURE(can_filters) {
        int sock;
};

FIXTURE_SETUP(can_filters)
{
        struct sockaddr_can addr;
        struct ifreq ifr;
        int recv_own_msgs = 1;
        int s, ret;

        s = socket(PF_CAN, SOCK_RAW, CAN_RAW);
        ASSERT_GE(s, 0)
                TH_LOG("failed to create CAN_RAW socket: %d", errno);

        strncpy(ifr.ifr_name, CANIF, sizeof(ifr.ifr_name));
        ret = ioctl(s, SIOCGIFINDEX, &ifr);
        ASSERT_GE(ret, 0)
                TH_LOG("failed SIOCGIFINDEX: %d", errno);

        addr.can_family = AF_CAN;
        addr.can_ifindex = ifr.ifr_ifindex;

        setsockopt(s, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS,
                   &recv_own_msgs, sizeof(recv_own_msgs));

        ret = bind(s, (struct sockaddr *)&addr, sizeof(addr));
        ASSERT_EQ(ret, 0)
                TH_LOG("failed bind socket: %d", errno);

        self->sock = s;
}

FIXTURE_TEARDOWN(can_filters)
{
        close(self->sock);
}

FIXTURE_VARIANT(can_filters) {
        int testcase;
        canid_t id;
        canid_t mask;
        int exp_num_rx;
        canid_t exp_flags[];
};

/* Receive all frames when filtering for the ID in standard frame format */
FIXTURE_VARIANT_ADD(can_filters, base) {
        .testcase = 1,
        .id = ID,
        .mask = CAN_SFF_MASK,
        .exp_num_rx = 4,
        .exp_flags = {
                0,
                CAN_RTR_FLAG,
                CAN_EFF_FLAG,
                CAN_EFF_FLAG | CAN_RTR_FLAG,
        },
};

/* Ignore EFF flag in filter ID if not covered by filter mask */
FIXTURE_VARIANT_ADD(can_filters, base_eff) {
        .testcase = 2,
        .id = ID | CAN_EFF_FLAG,
        .mask = CAN_SFF_MASK,
        .exp_num_rx = 4,
        .exp_flags = {
                0,
                CAN_RTR_FLAG,
                CAN_EFF_FLAG,
                CAN_EFF_FLAG | CAN_RTR_FLAG,
        },
};

/* Ignore RTR flag in filter ID if not covered by filter mask */
FIXTURE_VARIANT_ADD(can_filters, base_rtr) {
        .testcase = 3,
        .id = ID | CAN_RTR_FLAG,
        .mask = CAN_SFF_MASK,
        .exp_num_rx = 4,
        .exp_flags = {
                0,
                CAN_RTR_FLAG,
                CAN_EFF_FLAG,
                CAN_EFF_FLAG | CAN_RTR_FLAG,
        },
};

/* Ignore EFF and RTR flags in filter ID if not covered by filter mask */
FIXTURE_VARIANT_ADD(can_filters, base_effrtr) {
        .testcase = 4,
        .id = ID | CAN_EFF_FLAG | CAN_RTR_FLAG,
        .mask = CAN_SFF_MASK,
        .exp_num_rx = 4,
        .exp_flags = {
                0,
                CAN_RTR_FLAG,
                CAN_EFF_FLAG,
                CAN_EFF_FLAG | CAN_RTR_FLAG,
        },
};

/* Receive only SFF frames when expecting no EFF flag */
FIXTURE_VARIANT_ADD(can_filters, filter_eff) {
        .testcase = 5,
        .id = ID,
        .mask = CAN_SFF_MASK | CAN_EFF_FLAG,
        .exp_num_rx = 2,
        .exp_flags = {
                0,
                CAN_RTR_FLAG,
        },
};

/* Receive only EFF frames when filter id and filter mask include EFF flag */
FIXTURE_VARIANT_ADD(can_filters, filter_eff_eff) {
        .testcase = 6,
        .id = ID | CAN_EFF_FLAG,
        .mask = CAN_SFF_MASK | CAN_EFF_FLAG,
        .exp_num_rx = 2,
        .exp_flags = {
                CAN_EFF_FLAG,
                CAN_EFF_FLAG | CAN_RTR_FLAG,
        },
};

/* Receive only SFF frames when expecting no EFF flag, ignoring RTR flag */
FIXTURE_VARIANT_ADD(can_filters, filter_eff_rtr) {
        .testcase = 7,
        .id = ID | CAN_RTR_FLAG,
        .mask = CAN_SFF_MASK | CAN_EFF_FLAG,
        .exp_num_rx = 2,
        .exp_flags = {
                0,
                CAN_RTR_FLAG,
        },
};

/* Receive only EFF frames when filter id and filter mask include EFF flag,
 * ignoring RTR flag
 */
FIXTURE_VARIANT_ADD(can_filters, filter_eff_effrtr) {
        .testcase = 8,
        .id = ID | CAN_EFF_FLAG | CAN_RTR_FLAG,
        .mask = CAN_SFF_MASK | CAN_EFF_FLAG,
        .exp_num_rx = 2,
        .exp_flags = {
                CAN_EFF_FLAG,
                CAN_EFF_FLAG | CAN_RTR_FLAG,
        },
};

/* Receive no remote frames when filtering for no RTR flag */
FIXTURE_VARIANT_ADD(can_filters, filter_rtr) {
        .testcase = 9,
        .id = ID,
        .mask = CAN_SFF_MASK | CAN_RTR_FLAG,
        .exp_num_rx = 2,
        .exp_flags = {
                0,
                CAN_EFF_FLAG,
        },
};

/* Receive no remote frames when filtering for no RTR flag, ignoring EFF flag */
FIXTURE_VARIANT_ADD(can_filters, filter_rtr_eff) {
        .testcase = 10,
        .id = ID | CAN_EFF_FLAG,
        .mask = CAN_SFF_MASK | CAN_RTR_FLAG,
        .exp_num_rx = 2,
        .exp_flags = {
                0,
                CAN_EFF_FLAG,
        },
};

/* Receive only remote frames when filter includes RTR flag */
FIXTURE_VARIANT_ADD(can_filters, filter_rtr_rtr) {
        .testcase = 11,
        .id = ID | CAN_RTR_FLAG,
        .mask = CAN_SFF_MASK | CAN_RTR_FLAG,
        .exp_num_rx = 2,
        .exp_flags = {
                CAN_RTR_FLAG,
                CAN_EFF_FLAG | CAN_RTR_FLAG,
        },
};

/* Receive only remote frames when filter includes RTR flag, ignoring EFF
 * flag
 */
FIXTURE_VARIANT_ADD(can_filters, filter_rtr_effrtr) {
        .testcase = 12,
        .id = ID | CAN_EFF_FLAG | CAN_RTR_FLAG,
        .mask = CAN_SFF_MASK | CAN_RTR_FLAG,
        .exp_num_rx = 2,
        .exp_flags = {
                CAN_RTR_FLAG,
                CAN_EFF_FLAG | CAN_RTR_FLAG,
        },
};

/* Receive only SFF data frame when filtering for no flags */
FIXTURE_VARIANT_ADD(can_filters, filter_effrtr) {
        .testcase = 13,
        .id = ID,
        .mask = CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG,
        .exp_num_rx = 1,
        .exp_flags = {
                0,
        },
};

/* Receive only EFF data frame when filtering for EFF but no RTR flag */
FIXTURE_VARIANT_ADD(can_filters, filter_effrtr_eff) {
        .testcase = 14,
        .id = ID | CAN_EFF_FLAG,
        .mask = CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG,
        .exp_num_rx = 1,
        .exp_flags = {
                CAN_EFF_FLAG,
        },
};

/* Receive only SFF remote frame when filtering for RTR but no EFF flag */
FIXTURE_VARIANT_ADD(can_filters, filter_effrtr_rtr) {
        .testcase = 15,
        .id = ID | CAN_RTR_FLAG,
        .mask = CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG,
        .exp_num_rx = 1,
        .exp_flags = {
                CAN_RTR_FLAG,
        },
};

/* Receive only EFF remote frame when filtering for EFF and RTR flag */
FIXTURE_VARIANT_ADD(can_filters, filter_effrtr_effrtr) {
        .testcase = 16,
        .id = ID | CAN_EFF_FLAG | CAN_RTR_FLAG,
        .mask = CAN_SFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG,
        .exp_num_rx = 1,
        .exp_flags = {
                CAN_EFF_FLAG | CAN_RTR_FLAG,
        },
};

/* Receive only SFF data frame when filtering for no EFF flag and no RTR flag
 * but based on EFF mask
 */
FIXTURE_VARIANT_ADD(can_filters, eff) {
        .testcase = 17,
        .id = ID,
        .mask = CAN_EFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG,
        .exp_num_rx = 1,
        .exp_flags = {
                0,
        },
};

/* Receive only EFF data frame when filtering for EFF flag and no RTR flag but
 * based on EFF mask
 */
FIXTURE_VARIANT_ADD(can_filters, eff_eff) {
        .testcase = 18,
        .id = ID | CAN_EFF_FLAG,
        .mask = CAN_EFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG,
        .exp_num_rx = 1,
        .exp_flags = {
                CAN_EFF_FLAG,
        },
};

/* This test verifies that the raw CAN filters work, by checking if only frames
 * with the expected set of flags are received. For each test case, the given
 * filter (id and mask) is added and four CAN frames are sent with every
 * combination of set/unset EFF/RTR flags.
 */
TEST_F(can_filters, test_filter)
{
        struct can_filter rfilter;
        int ret;

        rfilter.can_id = variant->id;
        rfilter.can_mask = variant->mask;
        setsockopt(self->sock, SOL_CAN_RAW, CAN_RAW_FILTER,
                   &rfilter, sizeof(rfilter));

        TH_LOG("filters: can_id = 0x%08X can_mask = 0x%08X",
                rfilter.can_id, rfilter.can_mask);

        ret = send_can_frames(self->sock, variant->testcase);
        ASSERT_EQ(ret, 0)
                TH_LOG("failed to send CAN frames");

        for (int i = 0; i <= variant->exp_num_rx; i++) {
                struct can_frame frame;
                struct timeval tv = {
                        .tv_sec = 0,
                        .tv_usec = 50000, /* 50ms timeout */
                };
                fd_set rdfs;

                FD_ZERO(&rdfs);
                FD_SET(self->sock, &rdfs);

                ret = select(self->sock + 1, &rdfs, NULL, NULL, &tv);
                ASSERT_GE(ret, 0)
                        TH_LOG("failed select for frame %d, err: %d)", i, errno);

                ret = FD_ISSET(self->sock, &rdfs);
                if (i == variant->exp_num_rx) {
                        ASSERT_EQ(ret, 0)
                                TH_LOG("too many frames received");
                } else {
                        ASSERT_NE(ret, 0)
                                TH_LOG("too few frames received");

                        ret = read(self->sock, &frame, sizeof(frame));
                        ASSERT_GE(ret, 0)
                                TH_LOG("failed to read frame %d, err: %d", i, errno);

                        TH_LOG("rx: can_id = 0x%08X rx = %d", frame.can_id, i);

                        ASSERT_EQ(ID, frame.can_id & CAN_SFF_MASK)
                                TH_LOG("received wrong can_id");
                        ASSERT_EQ(variant->testcase, frame.data[0])
                                TH_LOG("received wrong test case");

                        ASSERT_EQ(frame.can_id & ~CAN_ERR_MASK,
                                  variant->exp_flags[i])
                                TH_LOG("received unexpected flags");
                }
        }
}

int main(int argc, char **argv)
{
        char *ifname = getenv("CANIF");

        if (!ifname) {
                printf("CANIF environment variable must contain the test interface\n");
                return KSFT_FAIL;
        }

        strncpy(CANIF, ifname, sizeof(CANIF) - 1);

        return test_harness_run(argc, argv);
}