/*-
 * Copyright (c) 2019-2020 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifdef _KERNEL
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: npf_params.c,v 1.6 2023/02/12 13:21:28 kardel Exp $");

#include <sys/param.h>
#include <sys/types.h>

#include <sys/kmem.h>
#include <sys/queue.h>
#include <sys/thmap.h>
#endif

#include "npf_impl.h"

typedef struct npf_paramreg {
        struct npf_paramreg *   next;
        unsigned                count;
        npf_param_t             params[];
} npf_paramreg_t;

struct npf_paraminfo {
        npf_paramreg_t *        list;
        thmap_t *               map;
};

static inline void
npf_param_general_register(npf_t *npf)
{
        npf_param_t param_map[] = {
                {
                        "ip4.reassembly",
                        &npf->ip4_reassembly,
                        .default_val = 1, // true - host requirements
                        .min = 0, .max = 1
                },
                {
                        "ip6.reassembly",
                        &npf->ip6_reassembly,
                        .default_val = 0, // false
                        .min = 0, .max = 1
                },
        };
        npf_param_register(npf, param_map, __arraycount(param_map));
}

static uintptr_t
npf_param_thmap_alloc(size_t len)
{
        return (uintptr_t)kmem_alloc(len, KM_SLEEP);
}

static void
npf_param_thmap_free(uintptr_t addr, size_t len)  
{
        kmem_free((void *)addr, len);
} 

static const thmap_ops_t npf_param_thmap_ops = {
        .alloc = npf_param_thmap_alloc,
        .free = npf_param_thmap_free
};

void
npf_param_init(npf_t *npf)
{
        npf_paraminfo_t *paraminfo;

        paraminfo = kmem_zalloc(sizeof(npf_paraminfo_t), KM_SLEEP);
        paraminfo->map = thmap_create(0, &npf_param_thmap_ops, THMAP_NOCOPY);
        npf->paraminfo = paraminfo;

        /* Register some general parameters. */
        npf_param_general_register(npf);
}

void
npf_param_fini(npf_t *npf)
{
        npf_paraminfo_t *pinfo = npf->paraminfo;
        npf_paramreg_t *paramreg = pinfo->list;

        while (paramreg) {
                npf_param_t *plist = paramreg->params;
                npf_paramreg_t *next = paramreg->next;
                size_t len;

                /* Remove the parameters from the map. */
                for (unsigned i = 0; i < paramreg->count; i++) {
                        npf_param_t *param = &plist[i];
                        const char *name = param->name;
                        void *ret __diagused;

                        ret = thmap_del(pinfo->map, name, strlen(name));
                        KASSERT(ret != NULL);
                }

                /* Destroy this registry. */
                len = offsetof(npf_paramreg_t, params[paramreg->count]);
                kmem_free(paramreg, len);

                /* Next .. */
                paramreg = next;
        }
        thmap_destroy(pinfo->map);
        kmem_free(pinfo, sizeof(npf_paraminfo_t));
}

int
npf_params_export(const npf_t *npf, nvlist_t *nv)
{
        nvlist_t *params, *dparams;

        /*
         * Export both the active and default values.  The latter are to
         * accommodate npfctl so it could distinguish what has been set.
         */
        params = nvlist_create(0);
        dparams = nvlist_create(0);
        for (npf_paramreg_t *pr = npf->paraminfo->list; pr; pr = pr->next) {
                for (unsigned i = 0; i < pr->count; i++) {
                        const npf_param_t *param = &pr->params[i];
                        const uint64_t val = *param->valp;
                        const uint64_t defval = param->default_val;

                        nvlist_add_number(params, param->name, val);
                        nvlist_add_number(dparams, param->name, defval);
                }
        }
        nvlist_add_nvlist(nv, "params", params);
        nvlist_add_nvlist(nv, "params-defaults", dparams);
        return 0;
}

void *
npf_param_allocgroup(npf_t *npf, npf_paramgroup_t group, size_t len)
{
        void *params = kmem_zalloc(len, KM_SLEEP);
        npf->params[group] = params;
        return params;
}

void
npf_param_freegroup(npf_t *npf, npf_paramgroup_t group, size_t len)
{
        kmem_free(npf->params[group], len);
        npf->params[group] = NULL; // diagnostic
}

/*
 * npf_param_register: register an array of named parameters.
 */
void
npf_param_register(npf_t *npf, npf_param_t *params, unsigned count)
{
        npf_paraminfo_t *pinfo = npf->paraminfo;
        npf_paramreg_t *paramreg;
        size_t len;

        /*
         * Copy over the parameters.
         */
        len = offsetof(npf_paramreg_t, params[count]);
        paramreg = kmem_zalloc(len, KM_SLEEP);
        memcpy(paramreg->params, params, sizeof(npf_param_t) * count);
        paramreg->count = count;
        params = NULL; // dead

        /*
         * Map the parameter names to the variables.
         * Assign the default values.
         */
        for (unsigned i = 0; i < count; i++) {
                npf_param_t *param = &paramreg->params[i];
                const char *name = param->name;
                void *ret __diagused;

                ret = thmap_put(pinfo->map, name, strlen(name), param);
                KASSERTMSG(ret == param,
                    "parameter insertion failed: ret=%p, param=%p",
                    ret, param);

                /* Assign the default value. */
                KASSERT(param->default_val >= param->min);
                KASSERT(param->default_val <= param->max);
                *param->valp = param->default_val;
        }

        /* Insert the registry of params into the list. */
        paramreg->next = pinfo->list;
        pinfo->list = paramreg;
}

/*
 * NPF param API.
 */

static npf_param_t *
npf_param_lookup(npf_t *npf, const char *name)
{
        npf_paraminfo_t *pinfo = npf->paraminfo;
        const size_t namelen = strlen(name);
        return thmap_get(pinfo->map, name, namelen);
}

int
npf_param_check(npf_t *npf, const char *name, int val)
{
        npf_param_t *param;

        if ((param = npf_param_lookup(npf, name)) == NULL) {
                return ENOENT;
        }
        if (val < param->min || val > param->max) {
                return EINVAL;
        }
        return 0;
}

__dso_public int
npfk_param_get(npf_t *npf, const char *name, int *val)
{
        npf_param_t *param;

        if ((param = npf_param_lookup(npf, name)) == NULL) {
                return ENOENT;
        }
        *val = *param->valp;
        return 0;
}

__dso_public int
npfk_param_set(npf_t *npf, const char *name, int val)
{
        npf_param_t *param;

        if ((param = npf_param_lookup(npf, name)) == NULL) {
                return ENOENT;
        }
        if (val < param->min || val > param->max) {
                return EINVAL;
        }
        *param->valp = val;
        return 0;
}