/*
 * 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 2026 Oxide Computer Company
 */

/*
 * Test a few aspects of inet6_opt(3C), particularly around error cases.
 */

#include <stdlib.h>
#include <err.h>
#include <netinet/in.h>
#include <netinet/ip6.h>
#include <sys/sysmacros.h>

typedef struct {
        const char *i6a_desc;
        int i6a_ret;
        int i6a_off;
        uint8_t i6a_type;
        socklen_t i6a_len;
        uint_t i6a_align;
} inet6_append_t;

static const inet6_append_t inet6_append_tests[] = {
        { "no offset, 1-byte align", 6, 0, IP6OPT_JUMBO, 4, 1 },
        { "no offset, 2-byte align", 6, 0, IP6OPT_JUMBO, 4, 2 },
        { "no offset, 2-byte align (2)", 8, 0, IP6OPT_JUMBO, 5, 2 },
        { "no offset, 4-byte align (1)", 8, 0, IP6OPT_JUMBO, 4, 4 },
        { "no offset, 4-byte align (2)", 8, 0, IP6OPT_JUMBO, 6, 4 },
        { "no offset, 8-byte align (1)", 16, 0, IP6OPT_JUMBO, 8, 8 },
        { "no offset, 8-byte align (2)", 24, 0, IP6OPT_JUMBO, 22, 8 },
        { "offset, 1-byte align (1)", 23, 20, IP6OPT_JUMBO, 1, 1 },
        { "offset, 2-byte align (1)", 14, 8, IP6OPT_JUMBO, 3, 2 },
        { "offset, 2-byte align (2)", 14, 8, IP6OPT_JUMBO, 4, 2 },
        { "offset, 4-byte align (1)", 20, 10, IP6OPT_JUMBO, 7, 4 },
        { "offset, 4-byte align (2)", 20, 10, IP6OPT_JUMBO, 8, 4 },
        { "offset, 4-byte align (3)", 24, 10, IP6OPT_JUMBO, 9, 4 },
        { "invalid align (1)", -1, 0, IP6OPT_JUMBO, 4, 3 },
        { "invalid align (2)", -1, 0, IP6OPT_JUMBO, 22, 5 },
        { "invalid align (3)", -1, 0, IP6OPT_JUMBO, 22, 7 },
        { "invalid align (4)", -1, 0, IP6OPT_JUMBO, 22, 10 },
        { "align > len (1)", -1, 0, IP6OPT_JUMBO, 2, 4 },
        { "align > len (2)", -1, 0, IP6OPT_JUMBO, 7, 8 },
        { "invalid type (1)", -1, 0, IP6OPT_PAD1, 4, 1 },
        { "invalid type (2)", -1, 0, IP6OPT_PADN, 4, 1 },
        { "invalid length (1)", -1, 0, IP6OPT_PADN, 256, 1 },
        { "invalid length (2)", -1, 0, IP6OPT_PADN, 7777, 1 }
};

int
main(void)
{
        uint8_t buf[128];
        int ret = EXIT_SUCCESS;

        /*
         * First verify several invalid sizes for the buffer allocation. We use
         * a token buffer for this.
         */
        const socklen_t inv_lens[] = { 0, 1, 7, 23, 169, UINT32_MAX };
        for (size_t i = 0; i < ARRAY_SIZE(inv_lens); i++) {
                if (inet6_opt_init(buf, inv_lens[i]) != -1) {
                        warnx("TEST FAILED: inet6_opt_init passed with invalid "
                            "length 0x%x", inv_lens[i]);
                        ret = EXIT_FAILURE;
                } else {
                        (void) printf("TEST PASSED: inet6_opt_init rejected "
                            "invalid length 0x%x\n", inv_lens[i]);
                }
        }

        /*
         * Next, valid and invalid append operations without data.
         */
        for (size_t i = 0; i < ARRAY_SIZE(inet6_append_tests); i++) {
                const inet6_append_t *t = &inet6_append_tests[i];
                int rval = inet6_opt_append(NULL, 0, t->i6a_off, t->i6a_type,
                    t->i6a_len, t->i6a_align, NULL);
                if (rval != t->i6a_ret) {
                        warnx("TEST FAILED: %s: inet6_opt_append returned %d, "
                            "but expected %d\n", t->i6a_desc, rval, t->i6a_ret);
                        ret = EXIT_FAILURE;
                } else {
                        (void) printf("TEST PASSED: %s: inet6_opt_append "
                            "returned %d\n", t->i6a_desc, t->i6a_ret);
                }
        }

        /*
         * Now go through and test a few cases that would cause us to exceed the
         * buffer capacity and make sure that we always catch those.
         */
        if (inet6_opt_append(buf, sizeof (buf), 120, IP6OPT_NSAP_ADDR, 10, 1,
            NULL) != -1) {
                warnx("TEST FAILED: didn't fail inet6_opt_append overflow");
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: caught inet6_opt_append "
                    "overflow\n");
        }

        buf[0] = 2;
        if (inet6_opt_finish(buf, 2, 24) != -1) {
                warnx("TEST FAILED: didn't fail inet6_opt_finish overflow");
                ret = EXIT_FAILURE;
        } else {
                (void) printf("TEST PASSED: caught inet6_opt_finish "
                    "overflow\n");
        }

        if (ret == EXIT_SUCCESS) {
                (void) printf("All tests passed successfully\n");
        }
        return (ret);
}