/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2024 Oxide Computer Company
 */

/*
 * Test SMBIOS Type 40 Additional Information. We try to cover a variety of
 * cases with and without entries, entries with and without additional data, and
 * several invalid length entries. Nothing currently checks that handles are
 * meaningful beyond that they are replicated.
 */

#include "smbios_test.h"

static const uint16_t smbios_addinfo_ent0_hdl = 0x7777;
static const uint8_t smbios_addinfo_ent0_off = 0x97;
static const char *smbios_addinfo_ent0_str = "Sephiroth";
static const uint32_t smbios_addinfo_ent0_data = 9999;
static const uint16_t smbios_addinfo_ent1_hdl = 0x1234;
static const uint8_t smbios_addinfo_ent1_off = 4;
static const char *smbios_addinfo_ent1_str = "Himmel";
static const uint16_t smbios_addinfo_ent2_hdl = 0x4321;
static const uint8_t smbios_addinfo_ent2_off = 0xfe;
static const char *smbios_addinfo_ent2_str = "Knights of the Round";
static const char *smbios_addinfo_ent2_data = "Galahad, Gawain, Lancelot";

static boolean_t
smbios_test_addinfo_verify_base(smbios_hdl_t *hdl, smbios_struct_t *sp,
    uint_t exp)
{
        uint_t nents;
        boolean_t ret = B_TRUE;
        smbios_addinfo_ent_t *ent;

        if (smbios_lookup_type(hdl, SMB_TYPE_ADDINFO, sp) == -1) {
                warnx("failed to lookup SMBIOS addinfo: %s",
                    smbios_errmsg(smbios_errno(hdl)));
                return (B_FALSE);
        }

        if (smbios_info_addinfo_nents(hdl, sp->smbstr_id, &nents) != 0) {
                warnx("failed to get additional information entry count: %s",
                    smbios_errmsg(smbios_errno(hdl)));
                return (B_FALSE);
        }

        if (nents != exp) {
                warnx("additional information entry mismatch: expected 0x%x, "
                    "found 0x%x", exp, nents);
                ret = B_FALSE;
        }

        if (smbios_info_addinfo_ent(hdl, sp->smbstr_id, exp, &ent) != -1) {
                warnx("incorrectly parsed non-existent entity");
                smbios_info_addinfo_ent_free(hdl, ent);
                ret = B_FALSE;
        } else if (smbios_errno(hdl) != ESMB_REQVAL) {
                warnx("encountered wrong error for addinfo ent, expected: "
                    "0x%x, found: 0x%x", ESMB_REQVAL, smbios_errno(hdl));
                ret = B_FALSE;
        }

        return (ret);
}

/*
 * Basic entry without valid entries. Strictly speaking this may be illegal per
 * the spec.
 */
boolean_t
smbios_test_addinfo_mktable_noent(smbios_test_table_t *table)
{
        smb_addinfo_t add;

        add.smbai_hdr.smbh_type = SMB_TYPE_ADDINFO;
        add.smbai_hdr.smbh_len = sizeof (add);
        add.smbai_nents = 0;

        (void) smbios_test_table_append(table, &add, sizeof (add));
        smbios_test_table_append_eot(table);

        return (B_TRUE);
}

boolean_t
smbios_test_addinfo_verify_noent(smbios_hdl_t *hdl)
{
        smbios_struct_t sp;

        return (smbios_test_addinfo_verify_base(hdl, &sp, 0));
}

/*
 * Complex case with three entries, each with varying data and strings.
 */
boolean_t
smbios_test_addinfo_mktable_ents(smbios_test_table_t *table)
{
        smb_addinfo_t add;
        smb_addinfo_ent_t ent0, ent1, ent2;
        size_t slen;

        add.smbai_hdr.smbh_type = SMB_TYPE_ADDINFO;
        add.smbai_hdr.smbh_len = sizeof (add);
        add.smbai_nents = 3;

        ent0.smbaie_len = sizeof (smb_addinfo_ent_t) +
            sizeof (smbios_addinfo_ent0_data);
        ent0.smbaie_rhdl = htole16(smbios_addinfo_ent0_hdl);
        ent0.smbaie_off = smbios_addinfo_ent0_off;
        ent0.smbaie_str = 1;
        add.smbai_hdr.smbh_len += ent0.smbaie_len;

        ent1.smbaie_len = sizeof (smb_addinfo_ent_t);
        ent1.smbaie_rhdl = htole16(smbios_addinfo_ent1_hdl);
        ent1.smbaie_off = smbios_addinfo_ent1_off;
        ent1.smbaie_str = 2;
        add.smbai_hdr.smbh_len += ent1.smbaie_len;

        slen = strlen(smbios_addinfo_ent2_data) + 1;
        ent2.smbaie_len = sizeof (smb_addinfo_ent_t) + slen;
        ent2.smbaie_rhdl = htole16(smbios_addinfo_ent2_hdl);
        ent2.smbaie_off = smbios_addinfo_ent2_off;
        ent2.smbaie_str = 3;
        add.smbai_hdr.smbh_len += ent2.smbaie_len;

        (void) smbios_test_table_append(table, &add, sizeof (add));
        (void) smbios_test_table_append_raw(table, &ent0, sizeof (ent0));
        (void) smbios_test_table_append_raw(table, &smbios_addinfo_ent0_data,
            sizeof (smbios_addinfo_ent0_data));
        (void) smbios_test_table_append_raw(table, &ent1, sizeof (ent1));
        (void) smbios_test_table_append_raw(table, &ent2, sizeof (ent2));
        (void) smbios_test_table_append_raw(table, smbios_addinfo_ent2_data,
            slen);
        smbios_test_table_append_string(table, smbios_addinfo_ent0_str);
        smbios_test_table_append_string(table, smbios_addinfo_ent1_str);
        smbios_test_table_append_string(table, smbios_addinfo_ent2_str);
        smbios_test_table_str_fini(table);
        smbios_test_table_append_eot(table);

        return (B_TRUE);
}

boolean_t
smbios_test_addinfo_verify_ents(smbios_hdl_t *hdl)
{
        smbios_struct_t sp;
        boolean_t ret = B_TRUE;
        smbios_addinfo_ent_t *ent;

        if (!smbios_test_addinfo_verify_base(hdl, &sp, 3)) {
                return (B_FALSE);
        }

        if (smbios_info_addinfo_ent(hdl, sp.smbstr_id, 0, &ent) != 0) {
                warnx("failed to lookup additional entry 0: %s",
                    smbios_errmsg(smbios_errno(hdl)));
                return (B_FALSE);
        }

        if (ent->smbai_ref != smbios_addinfo_ent0_hdl) {
                warnx("entry 0 mismatch, found unexpected reference handle: "
                    "0x%" _PRIxID, ent->smbai_ref);
                ret = B_FALSE;
        }
        if (ent->smbai_ref_off != smbios_addinfo_ent0_off) {
                warnx("entry 0 mismatch, found unexpected reference offset: "
                    "0x%x", ent->smbai_ref_off);
                ret = B_FALSE;
        }
        if (ent->smbai_dlen != sizeof (smbios_addinfo_ent0_data)) {
                warnx("entry 0 mismatch, found unexpected data length: 0x%x",
                    ent->smbai_dlen);
                ret = B_FALSE;
        }
        if (memcmp(ent->smbai_data, &smbios_addinfo_ent0_data,
            ent->smbai_dlen) != 0) {
                warnx("entry 0 mismatch, additional data mismatched");
                ret = B_FALSE;
        }
        smbios_info_addinfo_ent_free(hdl, ent);

        if (smbios_info_addinfo_ent(hdl, sp.smbstr_id, 1, &ent) != 0) {
                warnx("failed to lookup additional entry 1: %s",
                    smbios_errmsg(smbios_errno(hdl)));
                return (B_FALSE);
        }

        if (ent->smbai_ref != smbios_addinfo_ent1_hdl) {
                warnx("entry 1 mismatch, found unexpected reference handle: "
                    "0x%" _PRIxID, ent->smbai_ref);
                ret = B_FALSE;
        }
        if (ent->smbai_ref_off != smbios_addinfo_ent1_off) {
                warnx("entry 1 mismatch, found unexpected reference offset: "
                    "0x%x", ent->smbai_ref_off);
                ret = B_FALSE;
        }
        if (ent->smbai_dlen != 0) {
                warnx("entry 1 mismatch, found unexpected data length: 0x%x",
                    ent->smbai_dlen);
                ret = B_FALSE;
        }
        if (ent->smbai_data != NULL) {
                warnx("entry 1 mismatch, found unexpected data pointer");
                ret = B_FALSE;
        }
        smbios_info_addinfo_ent_free(hdl, ent);

        if (smbios_info_addinfo_ent(hdl, sp.smbstr_id, 2, &ent) != 0) {
                warnx("failed to lookup additional entry 2: %s",
                    smbios_errmsg(smbios_errno(hdl)));
                return (B_FALSE);
        }

        if (ent->smbai_ref != smbios_addinfo_ent2_hdl) {
                warnx("entry 2 mismatch, found unexpected reference handle: "
                    "0x%" _PRIxID, ent->smbai_ref);
                ret = B_FALSE;
        }
        if (ent->smbai_ref_off != smbios_addinfo_ent2_off) {
                warnx("entry 2 mismatch, found unexpected reference offset: "
                    "0x%x", ent->smbai_ref_off);
                ret = B_FALSE;
        }
        if (ent->smbai_dlen != strlen(smbios_addinfo_ent2_data) + 1) {
                warnx("entry 2 mismatch, found unexpected data length: 0x%x",
                    ent->smbai_dlen);
                ret = B_FALSE;
        }
        if (memcmp(ent->smbai_data, smbios_addinfo_ent2_data,
            ent->smbai_dlen) != 0) {
                warnx("entry 2 mismatch, additional data mismatched");
                ret = B_FALSE;
        }
        smbios_info_addinfo_ent_free(hdl, ent);

        return (ret);
}

/*
 * Generate a table that's too short to get basic info.
 */
boolean_t
smbios_test_addinfo_mktable_invlen_base(smbios_test_table_t *table)
{
        smb_header_t hdr;

        hdr.smbh_type = SMB_TYPE_ADDINFO;
        hdr.smbh_len = sizeof (hdr);

        (void) smbios_test_table_append(table, &hdr, sizeof (hdr));
        smbios_test_table_append_eot(table);

        return (B_TRUE);
}

boolean_t
smbios_test_addinfo_verify_invlen_base(smbios_hdl_t *hdl)
{
        smbios_struct_t sp;
        uint_t nents;

        if (smbios_lookup_type(hdl, SMB_TYPE_ADDINFO, &sp) == -1) {
                warnx("failed to lookup SMBIOS addinfo: %s",
                    smbios_errmsg(smbios_errno(hdl)));
                return (B_FALSE);
        }

        if (smbios_info_addinfo_nents(hdl, sp.smbstr_id, &nents) != -1) {
                warnx("accidentally parsed invalid addinfo information as "
                    "valid");
                return (B_FALSE);
        }

        if (smbios_errno(hdl) != ESMB_SHORT) {
                warnx("encountered wrong error for addinfo, expected: "
                    "0x%x, found: 0x%x", ESMB_SHORT, smbios_errno(hdl));
                return (B_FALSE);
        }

        return (B_TRUE);
}

/*
 * A table that's long enough to have valid entries, but too short for the first
 * entry.
 */
boolean_t
smbios_test_addinfo_mktable_invlen_ent(smbios_test_table_t *table)
{
        smb_addinfo_t add;
        smb_addinfo_ent_t ent = { 0 };
        size_t entoff = offsetof(smb_addinfo_ent_t, smbaie_rhdl);

        add.smbai_hdr.smbh_type = SMB_TYPE_ADDINFO;
        add.smbai_hdr.smbh_len = sizeof (add) + entoff;
        add.smbai_nents = 1;

        (void) smbios_test_table_append(table, &add, sizeof (add));
        (void) smbios_test_table_append_raw(table, &ent, entoff);
        smbios_test_table_append_eot(table);

        return (B_TRUE);
}

boolean_t
smbios_test_addinfo_verify_invlen_ent(smbios_hdl_t *hdl)
{
        smbios_struct_t sp;
        smbios_addinfo_ent_t *ent;
        boolean_t ret = B_TRUE;

        if (!smbios_test_addinfo_verify_base(hdl, &sp, 1)) {
                return (B_FALSE);
        }

        if (smbios_info_addinfo_ent(hdl, sp.smbstr_id, 0, &ent) != -1) {
                warnx("incorrectly parsed additional information entry 0: "
                    "expected bad length");
                ret = B_FALSE;
        } else if (smbios_errno(hdl) != ESMB_SHORT) {
                warnx("encountered wrong error for addinfo ent, expected: "
                    "0x%x, found: 0x%x", ESMB_SHORT, smbios_errno(hdl));
                ret = B_FALSE;
        }

        return (ret);
}

/*
 * Make sure even if we parse the first entity correctly, we fail on the second
 * one being too short.
 */
boolean_t
smbios_test_addinfo_mktable_invlen_multient(smbios_test_table_t *table)
{
        smb_addinfo_t add;
        smb_addinfo_ent_t ent0, ent1 = { 0 };
        size_t entoff = offsetof(smb_addinfo_ent_t, smbaie_rhdl);

        add.smbai_hdr.smbh_type = SMB_TYPE_ADDINFO;
        add.smbai_hdr.smbh_len = sizeof (add);
        add.smbai_nents = 2;

        ent0.smbaie_len = sizeof (smb_addinfo_ent_t) +
            sizeof (smbios_addinfo_ent0_data);
        ent0.smbaie_rhdl = htole16(smbios_addinfo_ent0_hdl);
        ent0.smbaie_off = smbios_addinfo_ent0_off;
        ent0.smbaie_str = 1;
        add.smbai_hdr.smbh_len += ent0.smbaie_len;

        ent1.smbaie_len = sizeof (smb_addinfo_ent_t);
        add.smbai_hdr.smbh_len += entoff;

        (void) smbios_test_table_append(table, &add, sizeof (add));
        (void) smbios_test_table_append_raw(table, &ent0, sizeof (ent0));
        (void) smbios_test_table_append_raw(table, &smbios_addinfo_ent0_data,
            sizeof (smbios_addinfo_ent0_data));
        (void) smbios_test_table_append_raw(table, &ent1, entoff);

        smbios_test_table_append_string(table, smbios_addinfo_ent0_str);
        smbios_test_table_str_fini(table);
        smbios_test_table_append_eot(table);


        (void) smbios_test_table_append(table, &add, sizeof (add));
        (void) smbios_test_table_append_raw(table, &ent1, entoff);
        smbios_test_table_append_eot(table);

        return (B_TRUE);
}

boolean_t
smbios_test_addinfo_verify_invlen_multient(smbios_hdl_t *hdl)
{
        smbios_struct_t sp;
        smbios_addinfo_ent_t *ent;
        boolean_t ret = B_TRUE;

        if (!smbios_test_addinfo_verify_base(hdl, &sp, 2)) {
                return (B_FALSE);
        }

        if (smbios_info_addinfo_ent(hdl, sp.smbstr_id, 1, &ent) != -1) {
                warnx("incorrectly parsed additional information entry 1: "
                    "expected bad length");
                ret = B_FALSE;
        } else if (smbios_errno(hdl) != ESMB_SHORT) {
                warnx("encountered wrong error for addinfo ent, expected: "
                    "0x%x, found: 0x%x", ESMB_SHORT, smbios_errno(hdl));
                ret = B_FALSE;
        }

        if (smbios_info_addinfo_ent(hdl, sp.smbstr_id, 0, &ent) != 0) {
                warnx("failed to lookup additional entry 0: %s",
                    smbios_errmsg(smbios_errno(hdl)));
                return (B_FALSE);
        }

        if (ent->smbai_ref != smbios_addinfo_ent0_hdl) {
                warnx("entry 0 mismatch, found unexpected reference handle: "
                    "0x%" _PRIxID, ent->smbai_ref);
                ret = B_FALSE;
        }
        if (ent->smbai_ref_off != smbios_addinfo_ent0_off) {
                warnx("entry 0 mismatch, found unexpected reference offset: "
                    "0x%x", ent->smbai_ref_off);
                ret = B_FALSE;
        }
        if (ent->smbai_dlen != sizeof (smbios_addinfo_ent0_data)) {
                warnx("entry 0 mismatch, found unexpected data length: 0x%x",
                    ent->smbai_dlen);
                ret = B_FALSE;
        }
        if (memcmp(ent->smbai_data, &smbios_addinfo_ent0_data,
            ent->smbai_dlen) != 0) {
                warnx("entry 0 mismatch, additional data mismatched");
                ret = B_FALSE;
        }
        smbios_info_addinfo_ent_free(hdl, ent);

        return (ret);
}

/*
 * Make sure we get the case where the length of the entity is longer than the
 * table.
 */
boolean_t
smbios_test_addinfo_mktable_invlen_entdata(smbios_test_table_t *table)
{
        smb_addinfo_t add;
        smb_addinfo_ent_t ent;

        add.smbai_hdr.smbh_type = SMB_TYPE_ADDINFO;
        add.smbai_hdr.smbh_len = sizeof (add) + sizeof (ent);
        add.smbai_nents = 1;

        (void) memset(&ent, 0, sizeof (ent));
        ent.smbaie_len = sizeof (ent) + 3;

        (void) smbios_test_table_append(table, &add, sizeof (add));
        (void) smbios_test_table_append_raw(table, &ent, sizeof (ent));
        smbios_test_table_append_eot(table);

        return (B_TRUE);
}

boolean_t
smbios_test_addinfo_verify_invlen_entdata(smbios_hdl_t *hdl)
{
        smbios_struct_t sp;
        smbios_addinfo_ent_t *ent;
        boolean_t ret = B_TRUE;

        if (!smbios_test_addinfo_verify_base(hdl, &sp, 1)) {
                return (B_FALSE);
        }

        if (smbios_info_addinfo_ent(hdl, sp.smbstr_id, 0, &ent) != -1) {
                warnx("incorrectly parsed additional information entry 0: "
                    "expected bad length");
                ret = B_FALSE;
        } else if (smbios_errno(hdl) != ESMB_CORRUPT) {
                warnx("encountered wrong error for addinfo ent, expected: "
                    "0x%x, found: 0x%x", ESMB_CORRUPT, smbios_errno(hdl));
                ret = B_FALSE;
        }

        return (ret);
}