xref: /f-stack/lib/ff_kern_environment.c (revision 2317ada5)

/*
 * Copyright (c) 1998 Michael Smith. All rights reserved.
 * Copyright (c) 2013 Patrick Kelsey. All rights reserved.
 * Copyright (C) 2017-2021 THL A29 Limited, a Tencent company.
 * 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 COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.
 *
 * Derived from libuinet's uinet_kern_environment.c.
 */

/*
 * This is an override of ken_environment.c so that get/set/put/unsetenv()
 * from libc will be used, and the extended kernel environment API will
 * still be available.
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD: release/9.1.0/sys/kern/kern_environment.c 225617 2011-09-16 13:58:51Z kmacy $");

#include <sys/types.h>
#include <sys/param.h>
#include <sys/proc.h>
#include <sys/queue.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/mutex.h>
#include <sys/priv.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/sysent.h>
#include <sys/sysproto.h>
#include <sys/libkern.h>
#include <sys/kenv.h>
#include <sys/limits.h>

#include "ff_host_interface.h"

static MALLOC_DEFINE(M_KENV, "kenv", "kernel environment");

#define KENV_SIZE    512    /* Maximum number of environment strings */

/* pointer to the config-generated static environment */
char *kern_envp;

/* pointer to the md-static environment */
char *md_envp;

/* dynamic environment variables */
char **kenvp = &kern_envp; /* points to a pointer to NULL */
struct mtx kenv_lock;  /* does not need initialization - it will not be used as dynamic_kenv == 0 */

/*
 * No need to protect this with a mutex since SYSINITS are single threaded.
 */
bool dynamic_kenv = 0;

char *
kern_getenv(const char *name)
{
    return ff_getenv(name);
}

int
kern_setenv(const char *name, const char *value)
{
    return ff_setenv(name, value);
}

void
freeenv(char *env)
{
    ;
}


/*
 * Test if an environment variable is defined.
 */
int
testenv(const char *name)
{
    return (kern_getenv(name) != NULL);
}



/*
 * Return a string value from an environment variable.
 */
int
getenv_string(const char *name, char *data, int size)
{
    char *tmp;

    tmp = kern_getenv(name);
    if (tmp != NULL) {
        strlcpy(data, tmp, size);
        freeenv(tmp);
        return (1);
    } else
        return (0);
}

/*
 * Return an integer value from an environment variable.
 */
int
getenv_int(const char *name, int *data)
{
    quad_t tmp;
    int rval;

    rval = getenv_quad(name, &tmp);
    if (rval)
        *data = (int) tmp;
    return (rval);
}

/*
 * Return an unsigned integer value from an environment variable.
 */
int
getenv_uint(const char *name, unsigned int *data)
{
    quad_t tmp;
    int rval;

    rval = getenv_quad(name, &tmp);
    if (rval)
        *data = (unsigned int) tmp;
    return (rval);
}

/*
 * Return a long value from an environment variable.
 */
int
getenv_long(const char *name, long *data)
{
    quad_t tmp;
    int rval;

    rval = getenv_quad(name, &tmp);
    if (rval)
        *data = (long) tmp;
    return (rval);
}

/*
 * Return an unsigned long value from an environment variable.
 */
int
getenv_ulong(const char *name, unsigned long *data)
{
    quad_t tmp;
    int rval;

    rval = getenv_quad(name, &tmp);
    if (rval)
        *data = (unsigned long) tmp;
    return (rval);
}

/*
 * Return a quad_t value from an environment variable.
 */
int
getenv_quad(const char *name, quad_t *data)
{
    char *value;
    char *vtp;
    quad_t iv;

    value = kern_getenv(name);
    if (value == NULL)
        return (0);
    iv = strtoq(value, &vtp, 0);
    if (vtp == value || (vtp[0] != '\0' && vtp[1] != '\0')) {
        freeenv(value);
        return (0);
    }
    switch (vtp[0]) {
    case 't': case 'T':
        iv *= 1024;
    case 'g': case 'G':
        iv *= 1024;
    case 'm': case 'M':
        iv *= 1024;
    case 'k': case 'K':
        iv *= 1024;
    case '\0':
        break;
    default:
        freeenv(value);
        return (0);
    }
    *data = iv;
    freeenv(value);
    return (1);
}

/*
 * Internal functions for string lookup.
 */
static char *
_getenv_dynamic_locked(const char *name, int *idx)
{
	char *cp;
	int len, i;

	len = strlen(name);
	for (cp = kenvp[0], i = 0; cp != NULL; cp = kenvp[++i]) {
		if ((strncmp(cp, name, len) == 0) &&
		    (cp[len] == '=')) {
			if (idx != NULL)
				*idx = i;
			return (cp + len + 1);
		}
	}
	return (NULL);
}

static char *
_getenv_dynamic(const char *name, int *idx)
{

	mtx_assert(&kenv_lock, MA_OWNED);
	return (_getenv_dynamic_locked(name, idx));
}

/*
 * Find the next entry after the one which (cp) falls within, return a
 * pointer to its start or NULL if there are no more.
 */
static char *
kernenv_next(char *cp)
{

	if (cp != NULL) {
		while (*cp != 0)
			cp++;
		cp++;
		if (*cp == 0)
			cp = NULL;
	}
	return (cp);
}

static char *
_getenv_static_from(char *chkenv, const char *name)
{
	char *cp, *ep;
	int len;

	for (cp = chkenv; cp != NULL; cp = kernenv_next(cp)) {
		for (ep = cp; (*ep != '=') && (*ep != 0); ep++)
			;
		if (*ep != '=')
			continue;
		len = ep - cp;
		ep++;
		if (!strncmp(name, cp, len) && name[len] == 0)
			return (ep);
	}
	return (NULL);
}

static char *
_getenv_static(const char *name)
{
	char *val;

	val = _getenv_static_from(md_envp, name);
	if (val != NULL)
		return (val);
	val = _getenv_static_from(kern_envp, name);
	if (val != NULL)
		return (val);
	return (NULL);
}

/*
 * Return the internal kenv buffer for the variable name, if it exists.
 * If the dynamic kenv is initialized and the name is present, return
 * with kenv_lock held.
 */
static char *
kenv_acquire(const char *name)
{
	char *value;

	if (dynamic_kenv) {
		mtx_lock(&kenv_lock);
		value = _getenv_dynamic(name, NULL);
		if (value == NULL)
			mtx_unlock(&kenv_lock);
		return (value);
	} else
		return (_getenv_static(name));
}

/*
 * Undo a previous kenv_acquire() operation
 */
static void
kenv_release(const char *buf)
{
	if ((buf != NULL) && dynamic_kenv)
		mtx_unlock(&kenv_lock);
}

/*
 * Return an array of integers at the given type size and signedness.
 */
int
getenv_array(const char *name, void *pdata, int size, int *psize,
    int type_size, bool allow_signed)
{
    uint8_t shift;
    int64_t value;
    int64_t old;
    const char *buf;
    char *end;
    const char *ptr;
    int n;
    int rc;

    rc = 0;              /* assume failure */

    buf = kenv_acquire(name);
    if (buf == NULL)
        goto error;

    /* get maximum number of elements */
    size /= type_size;

    n = 0;

    for (ptr = buf; *ptr != 0; ) {
        value = strtoq(ptr, &end, 0);

        /* check if signed numbers are allowed */
        if (value < 0 && !allow_signed)
            goto error;

        /* check for invalid value */
        if (ptr == end)
            goto error;

        /* check for valid suffix */
        switch (*end) {
        case 't':
        case 'T':
            shift = 40;
            end++;
            break;
        case 'g':
        case 'G':
            shift = 30;
            end++;
            break;
        case 'm':
        case 'M':
            shift = 20;
            end++;
            break;
        case 'k':
        case 'K':
            shift = 10;
            end++;
            break;
        case ' ':
        case '\t':
        case ',':
        case 0:
            shift = 0;
            break;
        default:
            /* garbage after numeric value */
            goto error;
        }

        /* skip till next value, if any */
        while (*end == '\t' || *end == ',' || *end == ' ')
            end++;

        /* update pointer */
        ptr = end;

        /* apply shift */
        old = value;
        value <<= shift;

        /* overflow check */
        if ((value >> shift) != old)
            goto error;

        /* check for buffer overflow */
        if (n >= size)
            goto error;

        /* store value according to type size */
        switch (type_size) {
        case 1:
            if (allow_signed) {
                if (value < SCHAR_MIN || value > SCHAR_MAX)
                    goto error;
            } else {
                if (value < 0 || value > UCHAR_MAX)
                    goto error;
            }
            ((uint8_t *)pdata)[n] = (uint8_t)value;
            break;
        case 2:
            if (allow_signed) {
                if (value < SHRT_MIN || value > SHRT_MAX)
                    goto error;
            } else {
                if (value < 0 || value > USHRT_MAX)
                    goto error;
            }
            ((uint16_t *)pdata)[n] = (uint16_t)value;
            break;
        case 4:
            if (allow_signed) {
                if (value < INT_MIN || value > INT_MAX)
                    goto error;
            } else {
                if (value > UINT_MAX)
                    goto error;
            }
            ((uint32_t *)pdata)[n] = (uint32_t)value;
            break;
        case 8:
            ((uint64_t *)pdata)[n] = (uint64_t)value;
            break;
        default:
            goto error;
        }
        n++;
    }
    *psize = n * type_size;

    if (n != 0)
        rc = 1;    /* success */
error:
    kenv_release(buf);
    return (rc);
}

void
tunable_int_init(void *data)
{
    struct tunable_int *d = (struct tunable_int *)data;

    TUNABLE_INT_FETCH(d->path, d->var);
}

void
tunable_long_init(void *data)
{
    struct tunable_long *d = (struct tunable_long *)data;

    TUNABLE_LONG_FETCH(d->path, d->var);
}

void
tunable_ulong_init(void *data)
{
    struct tunable_ulong *d = (struct tunable_ulong *)data;

    TUNABLE_ULONG_FETCH(d->path, d->var);
}

void
tunable_quad_init(void *data)
{
    struct tunable_quad *d = (struct tunable_quad *)data;

    TUNABLE_QUAD_FETCH(d->path, d->var);
}

void
tunable_str_init(void *data)
{
    struct tunable_str *d = (struct tunable_str *)data;

    TUNABLE_STR_FETCH(d->path, d->var, d->size);
}