sys/kern/kern_environment.c

   1 /*-
   2  * Copyright (c) 1998 Michael Smith
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * The unified bootloader passes us a pointer to a preserved copy of
  29  * bootstrap/kernel environment variables.  We convert them to a
  30  * dynamic array of strings later when the VM subsystem is up.
  31  *
  32  * We make these available through the kenv(2) syscall for userland
  33  * and through kern_getenv()/freeenv() kern_setenv() kern_unsetenv() testenv() for
  34  * the kernel.
  35  */
  36
  37 #include <sys/cdefs.h>
  38 __FBSDID("$FreeBSD$");
  39
  40 #include <sys/param.h>
  41 #include <sys/proc.h>
  42 #include <sys/queue.h>
  43 #include <sys/lock.h>
  44 #include <sys/malloc.h>
  45 #include <sys/mutex.h>
  46 #include <sys/priv.h>
  47 #include <sys/kernel.h>
  48 #include <sys/systm.h>
  49 #include <sys/sysent.h>
  50 #include <sys/sysproto.h>
  51 #include <sys/libkern.h>
  52 #include <sys/kenv.h>
  53 #include <sys/limits.h>
  54
  55 #include <security/mac/mac_framework.h>
  56
  57 static char *_getenv_dynamic_locked(const char *name, int *idx);
  58 static char *_getenv_dynamic(const char *name, int *idx);
  59
  60 static MALLOC_DEFINE(M_KENV, "kenv", "kernel environment");
  61
  62 #define KENV_SIZE       512     /* Maximum number of environment strings */
  63
  64 /* pointer to the config-generated static environment */
  65 char            *kern_envp;
  66
  67 /* pointer to the md-static environment */
  68 char            *md_envp;
  69 static int      md_env_len;
  70 static int      md_env_pos;
  71
  72 static char     *kernenv_next(char *);
  73
  74 /* dynamic environment variables */
  75 char            **kenvp;
  76 struct mtx      kenv_lock;
  77
  78 /*
  79  * No need to protect this with a mutex since SYSINITS are single threaded.
  80  */
  81 bool    dynamic_kenv;
  82
  83 #define KENV_CHECK      if (!dynamic_kenv) \
  84                             panic("%s: called before SI_SUB_KMEM", __func__)
  85
  86 int
  87 sys_kenv(td, uap)
  88         struct thread *td;
  89         struct kenv_args /* {
  90                 int what;
  91                 const char *name;
  92                 char *value;
  93                 int len;
  94         } */ *uap;
  95 {
  96         char *name, *value, *buffer = NULL;
  97         size_t len, done, needed, buflen;
  98         int error, i;
  99
 100         KASSERT(dynamic_kenv, ("kenv: dynamic_kenv = false"));
 101
 102         error = 0;
 103         if (uap->what == KENV_DUMP) {
 104 #ifdef MAC
 105                 error = mac_kenv_check_dump(td->td_ucred);
 106                 if (error)
 107                         return (error);
 108 #endif
 109                 done = needed = 0;
 110                 buflen = uap->len;
 111                 if (buflen > KENV_SIZE * (KENV_MNAMELEN + KENV_MVALLEN + 2))
 112                         buflen = KENV_SIZE * (KENV_MNAMELEN +
 113                             KENV_MVALLEN + 2);
 114                 if (uap->len > 0 && uap->value != NULL)
 115                         buffer = malloc(buflen, M_TEMP, M_WAITOK|M_ZERO);
 116                 mtx_lock(&kenv_lock);
 117                 for (i = 0; kenvp[i] != NULL; i++) {
 118                         len = strlen(kenvp[i]) + 1;
 119                         needed += len;
 120                         len = min(len, buflen - done);
 121                         /*
 122                          * If called with a NULL or insufficiently large
 123                          * buffer, just keep computing the required size.
 124                          */
 125                         if (uap->value != NULL && buffer != NULL && len > 0) {
 126                                 bcopy(kenvp[i], buffer + done, len);
 127                                 done += len;
 128                         }
 129                 }
 130                 mtx_unlock(&kenv_lock);
 131                 if (buffer != NULL) {
 132                         error = copyout(buffer, uap->value, done);
 133                         free(buffer, M_TEMP);
 134                 }
 135                 td->td_retval[0] = ((done == needed) ? 0 : needed);
 136                 return (error);
 137         }
 138
 139         switch (uap->what) {
 140         case KENV_SET:
 141                 error = priv_check(td, PRIV_KENV_SET);
 142                 if (error)
 143                         return (error);
 144                 break;
 145
 146         case KENV_UNSET:
 147                 error = priv_check(td, PRIV_KENV_UNSET);
 148                 if (error)
 149                         return (error);
 150                 break;
 151         }
 152
 153         name = malloc(KENV_MNAMELEN + 1, M_TEMP, M_WAITOK);
 154
 155         error = copyinstr(uap->name, name, KENV_MNAMELEN + 1, NULL);
 156         if (error)
 157                 goto done;
 158
 159         switch (uap->what) {
 160         case KENV_GET:
 161 #ifdef MAC
 162                 error = mac_kenv_check_get(td->td_ucred, name);
 163                 if (error)
 164                         goto done;
 165 #endif
 166                 value = kern_getenv(name);
 167                 if (value == NULL) {
 168                         error = ENOENT;
 169                         goto done;
 170                 }
 171                 len = strlen(value) + 1;
 172                 if (len > uap->len)
 173                         len = uap->len;
 174                 error = copyout(value, uap->value, len);
 175                 freeenv(value);
 176                 if (error)
 177                         goto done;
 178                 td->td_retval[0] = len;
 179                 break;
 180         case KENV_SET:
 181                 len = uap->len;
 182                 if (len < 1) {
 183                         error = EINVAL;
 184                         goto done;
 185                 }
 186                 if (len > KENV_MVALLEN + 1)
 187                         len = KENV_MVALLEN + 1;
 188                 value = malloc(len, M_TEMP, M_WAITOK);
 189                 error = copyinstr(uap->value, value, len, NULL);
 190                 if (error) {
 191                         free(value, M_TEMP);
 192                         goto done;
 193                 }
 194 #ifdef MAC
 195                 error = mac_kenv_check_set(td->td_ucred, name, value);
 196                 if (error == 0)
 197 #endif
 198                         kern_setenv(name, value);
 199                 free(value, M_TEMP);
 200                 break;
 201         case KENV_UNSET:
 202 #ifdef MAC
 203                 error = mac_kenv_check_unset(td->td_ucred, name);
 204                 if (error)
 205                         goto done;
 206 #endif
 207                 error = kern_unsetenv(name);
 208                 if (error)
 209                         error = ENOENT;
 210                 break;
 211         default:
 212                 error = EINVAL;
 213                 break;
 214         }
 215 done:
 216         free(name, M_TEMP);
 217         return (error);
 218 }
 219
 220 /*
 221  * Populate the initial kernel environment.
 222  *
 223  * This is called very early in MD startup, either to provide a copy of the
 224  * environment obtained from a boot loader, or to provide an empty buffer into
 225  * which MD code can store an initial environment using kern_setenv() calls.
 226  *
 227  * kern_envp is set to the static_env generated by config(8).  This implements
 228  * the env keyword described in config(5).
 229  *
 230  * If len is non-zero, the caller is providing an empty buffer.  The caller will
 231  * subsequently use kern_setenv() to add up to len bytes of initial environment
 232  * before the dynamic environment is available.
 233  *
 234  * If len is zero, the caller is providing a pre-loaded buffer containing
 235  * environment strings.  Additional strings cannot be added until the dynamic
 236  * environment is available.  The memory pointed to must remain stable at least
 237  * until sysinit runs init_dynamic_kenv() and preferably until after SI_SUB_KMEM
 238  * is finished so that subr_hints routines may continue to use it until the
 239  * environments have been fully merged at the end of the pass.  If no initial
 240  * environment is available from the boot loader, passing a NULL pointer allows
 241  * the static_env to be installed if it is configured.  In this case, any call
 242  * to kern_setenv() prior to the setup of the dynamic environment will result in
 243  * a panic.
 244  */
 245 void
 246 init_static_kenv(char *buf, size_t len)
 247 {
 248         char *eval, *loader_eval;
 249
 250         KASSERT(!dynamic_kenv, ("kenv: dynamic_kenv already initialized"));
 251         /*
 252          * Give the static environment a chance to disable the loader(8)
 253          * environment first.  This is done with loader_env.disabled=1.
 254          *
 255          * static_env and static_hints may both be disabled, but in slightly
 256          * different ways.  For static_env, we just don't setup kern_envp and
 257          * it's as if a static env wasn't even provided.  For static_hints,
 258          * we effectively zero out the buffer to stop the rest of the kernel
 259          * from being able to use it.
 260          *
 261          * We're intentionally setting this up so that static_hints.disabled may
 262          * be specified in either the MD env or the static env. This keeps us
 263          * consistent in our new world view.
 264          *
 265          * As a warning, the static environment may not be disabled in any way
 266          * if the static environment has disabled the loader environment.
 267          *
 268          * We're setting up the static environment early here because it will
 269          * either be used or empty.
 270          */
 271         kern_envp = static_env;
 272         loader_eval = kern_getenv("loader_env.disabled");
 273         if (loader_eval != NULL && strcmp(loader_eval, "1") == 0)
 274                 /* Bail out early, the loader environment is disabled. */
 275                 return;
 276
 277         /*
 278          * Next, the loader env is checked for the status of the static env.  We
 279          * are allowing static_env and static_hints to disable themselves here for
 280          * the sake of simplicity.
 281          */
 282         md_envp = buf;
 283         md_env_len = len;
 284         md_env_pos = 0;
 285
 286         eval = kern_getenv("static_env.disabled");
 287         if (eval != NULL && strcmp(eval, "1") == 0)
 288                 *static_env = '\0';
 289
 290         eval = kern_getenv("static_hints.disabled");
 291         if (eval != NULL && strcmp(eval, "1") == 0)
 292                 *static_hints = '\0';
 293
 294         /*
 295          * Now we see if we need to tear the loader environment back down due
 296          * to the presence of a non-empty static environment and lack of request
 297          * to keep it enabled.
 298          */
 299         if (*static_env != '\0' &&
 300             (loader_eval == NULL || strcmp(loader_eval, "0") != 0)) {
 301                 md_envp = NULL;
 302                 md_env_len = 0;
 303         }
 304 }
 305
 306 static void
 307 init_dynamic_kenv_from(char *init_env, int *curpos)
 308 {
 309         char *cp, *cpnext, *eqpos, *found;
 310         size_t len;
 311         int i;
 312
 313         if (init_env && *init_env != '\0') {
 314                 found = NULL;
 315                 i = *curpos;
 316                 for (cp = init_env; cp != NULL; cp = cpnext) {
 317                         cpnext = kernenv_next(cp);
 318                         len = strlen(cp) + 1;
 319                         if (len > KENV_MNAMELEN + 1 + KENV_MVALLEN + 1) {
 320                                 printf(
 321                                 "WARNING: too long kenv string, ignoring %s\n",
 322                                     cp);
 323                                 goto sanitize;
 324                         }
 325                         eqpos = strchr(cp, '=');
 326                         if (eqpos == NULL) {
 327                                 printf(
 328                                 "WARNING: malformed static env value, ignoring %s\n",
 329                                     cp);
 330                                 goto sanitize;
 331                         }
 332                         *eqpos = 0;
 333                         /*
 334                          * De-dupe the environment as we go.  We don't add the
 335                          * duplicated assignments because config(8) will flip
 336                          * the order of the static environment around to make
 337                          * kernel processing match the order of specification
 338                          * in the kernel config.
 339                          */
 340                         found = _getenv_dynamic_locked(cp, NULL);
 341                         *eqpos = '=';
 342                         if (found != NULL)
 343                                 goto sanitize;
 344                         if (i > KENV_SIZE) {
 345                                 printf(
 346                                 "WARNING: too many kenv strings, ignoring %s\n",
 347                                     cp);
 348                                 goto sanitize;
 349                         }
 350
 351                         kenvp[i] = malloc(len, M_KENV, M_WAITOK);
 352                         strcpy(kenvp[i++], cp);
 353 sanitize:
 354                         explicit_bzero(cp, len - 1);
 355                 }
 356                 *curpos = i;
 357         }
 358 }
 359
 360 /*
 361  * Setup the dynamic kernel environment.
 362  */
 363 static void
 364 init_dynamic_kenv(void *data __unused)
 365 {
 366         int dynamic_envpos;
 367
 368         kenvp = malloc((KENV_SIZE + 1) * sizeof(char *), M_KENV,
 369                 M_WAITOK | M_ZERO);
 370
 371         dynamic_envpos = 0;
 372         init_dynamic_kenv_from(md_envp, &dynamic_envpos);
 373         init_dynamic_kenv_from(kern_envp, &dynamic_envpos);
 374         kenvp[dynamic_envpos] = NULL;
 375
 376         mtx_init(&kenv_lock, "kernel environment", NULL, MTX_DEF);
 377         dynamic_kenv = true;
 378 }
 379 SYSINIT(kenv, SI_SUB_KMEM + 1, SI_ORDER_FIRST, init_dynamic_kenv, NULL);
 380
 381 void
 382 freeenv(char *env)
 383 {
 384
 385         if (dynamic_kenv && env != NULL) {
 386                 explicit_bzero(env, strlen(env));
 387                 free(env, M_KENV);
 388         }
 389 }
 390
 391 /*
 392  * Internal functions for string lookup.
 393  */
 394 static char *
 395 _getenv_dynamic_locked(const char *name, int *idx)
 396 {
 397         char *cp;
 398         int len, i;
 399
 400         len = strlen(name);
 401         for (cp = kenvp[0], i = 0; cp != NULL; cp = kenvp[++i]) {
 402                 if ((strncmp(cp, name, len) == 0) &&
 403                     (cp[len] == '=')) {
 404                         if (idx != NULL)
 405                                 *idx = i;
 406                         return (cp + len + 1);
 407                 }
 408         }
 409         return (NULL);
 410 }
 411
 412 static char *
 413 _getenv_dynamic(const char *name, int *idx)
 414 {
 415
 416         mtx_assert(&kenv_lock, MA_OWNED);
 417         return (_getenv_dynamic_locked(name, idx));
 418 }
 419
 420 static char *
 421 _getenv_static_from(char *chkenv, const char *name)
 422 {
 423         char *cp, *ep;
 424         int len;
 425
 426         for (cp = chkenv; cp != NULL; cp = kernenv_next(cp)) {
 427                 for (ep = cp; (*ep != '=') && (*ep != 0); ep++)
 428                         ;
 429                 if (*ep != '=')
 430                         continue;
 431                 len = ep - cp;
 432                 ep++;
 433                 if (!strncmp(name, cp, len) && name[len] == 0)
 434                         return (ep);
 435         }
 436         return (NULL);
 437 }
 438
 439 static char *
 440 _getenv_static(const char *name)
 441 {
 442         char *val;
 443
 444         val = _getenv_static_from(md_envp, name);
 445         if (val != NULL)
 446                 return (val);
 447         val = _getenv_static_from(kern_envp, name);
 448         if (val != NULL)
 449                 return (val);
 450         return (NULL);
 451 }
 452
 453 /*
 454  * Look up an environment variable by name.
 455  * Return a pointer to the string if found.
 456  * The pointer has to be freed with freeenv()
 457  * after use.
 458  */
 459 char *
 460 kern_getenv(const char *name)
 461 {
 462         char buf[KENV_MNAMELEN + 1 + KENV_MVALLEN + 1];
 463         char *ret;
 464
 465         if (dynamic_kenv) {
 466                 if (getenv_string(name, buf, sizeof(buf))) {
 467                         ret = strdup(buf, M_KENV);
 468                 } else {
 469                         ret = NULL;
 470                         WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
 471                             "getenv");
 472                 }
 473         } else
 474                 ret = _getenv_static(name);
 475         return (ret);
 476 }
 477
 478 /*
 479  * Test if an environment variable is defined.
 480  */
 481 int
 482 testenv(const char *name)
 483 {
 484         char *cp;
 485
 486         if (dynamic_kenv) {
 487                 mtx_lock(&kenv_lock);
 488                 cp = _getenv_dynamic(name, NULL);
 489                 mtx_unlock(&kenv_lock);
 490         } else
 491                 cp = _getenv_static(name);
 492         if (cp != NULL)
 493                 return (1);
 494         return (0);
 495 }
 496
 497 /*
 498  * Set an environment variable in the MD-static environment.  This cannot
 499  * feasibly be done on config(8)-generated static environments as they don't
 500  * generally include space for extra variables.
 501  */
 502 static int
 503 setenv_static(const char *name, const char *value)
 504 {
 505         int len;
 506
 507         if (md_env_pos >= md_env_len)
 508                 return (-1);
 509
 510         /* Check space for x=y and two nuls */
 511         len = strlen(name) + strlen(value);
 512         if (len + 3 < md_env_len - md_env_pos) {
 513                 len = sprintf(&md_envp[md_env_pos], "%s=%s", name, value);
 514                 md_env_pos += len+1;
 515                 md_envp[md_env_pos] = '\0';
 516                 return (0);
 517         } else
 518                 return (-1);
 519
 520 }
 521
 522 /*
 523  * Set an environment variable by name.
 524  */
 525 int
 526 kern_setenv(const char *name, const char *value)
 527 {
 528         char *buf, *cp, *oldenv;
 529         int namelen, vallen, i;
 530
 531         if (!dynamic_kenv && md_env_len > 0)
 532                 return (setenv_static(name, value));
 533
 534         KENV_CHECK;
 535
 536         namelen = strlen(name) + 1;
 537         if (namelen > KENV_MNAMELEN + 1)
 538                 return (-1);
 539         vallen = strlen(value) + 1;
 540         if (vallen > KENV_MVALLEN + 1)
 541                 return (-1);
 542         buf = malloc(namelen + vallen, M_KENV, M_WAITOK);
 543         sprintf(buf, "%s=%s", name, value);
 544
 545         mtx_lock(&kenv_lock);
 546         cp = _getenv_dynamic(name, &i);
 547         if (cp != NULL) {
 548                 oldenv = kenvp[i];
 549                 kenvp[i] = buf;
 550                 mtx_unlock(&kenv_lock);
 551                 free(oldenv, M_KENV);
 552         } else {
 553                 /* We add the option if it wasn't found */
 554                 for (i = 0; (cp = kenvp[i]) != NULL; i++)
 555                         ;
 556
 557                 /* Bounds checking */
 558                 if (i < 0 || i >= KENV_SIZE) {
 559                         free(buf, M_KENV);
 560                         mtx_unlock(&kenv_lock);
 561                         return (-1);
 562                 }
 563
 564                 kenvp[i] = buf;
 565                 kenvp[i + 1] = NULL;
 566                 mtx_unlock(&kenv_lock);
 567         }
 568         return (0);
 569 }
 570
 571 /*
 572  * Unset an environment variable string.
 573  */
 574 int
 575 kern_unsetenv(const char *name)
 576 {
 577         char *cp, *oldenv;
 578         int i, j;
 579
 580         KENV_CHECK;
 581
 582         mtx_lock(&kenv_lock);
 583         cp = _getenv_dynamic(name, &i);
 584         if (cp != NULL) {
 585                 oldenv = kenvp[i];
 586                 for (j = i + 1; kenvp[j] != NULL; j++)
 587                         kenvp[i++] = kenvp[j];
 588                 kenvp[i] = NULL;
 589                 mtx_unlock(&kenv_lock);
 590                 explicit_bzero(oldenv, strlen(oldenv));
 591                 free(oldenv, M_KENV);
 592                 return (0);
 593         }
 594         mtx_unlock(&kenv_lock);
 595         return (-1);
 596 }
 597
 598 /*
 599  * Return a string value from an environment variable.
 600  */
 601 int
 602 getenv_string(const char *name, char *data, int size)
 603 {
 604         char *cp;
 605
 606         if (dynamic_kenv) {
 607                 mtx_lock(&kenv_lock);
 608                 cp = _getenv_dynamic(name, NULL);
 609                 if (cp != NULL)
 610                         strlcpy(data, cp, size);
 611                 mtx_unlock(&kenv_lock);
 612         } else {
 613                 cp = _getenv_static(name);
 614                 if (cp != NULL)
 615                         strlcpy(data, cp, size);
 616         }
 617         return (cp != NULL);
 618 }
 619
 620 /*
 621  * Return an array of integers at the given type size and signedness.
 622  */
 623 int
 624 getenv_array(const char *name, void *pdata, int size, int *psize,
 625     int type_size, bool allow_signed)
 626 {
 627         char buf[KENV_MNAMELEN + 1 + KENV_MVALLEN + 1];
 628         uint8_t shift;
 629         int64_t value;
 630         int64_t old;
 631         char *end;
 632         char *ptr;
 633         int n;
 634
 635         if (getenv_string(name, buf, sizeof(buf)) == 0)
 636                 return (0);
 637
 638         /* get maximum number of elements */
 639         size /= type_size;
 640
 641         n = 0;
 642
 643         for (ptr = buf; *ptr != 0; ) {
 644
 645                 value = strtoq(ptr, &end, 0);
 646
 647                 /* check if signed numbers are allowed */
 648                 if (value < 0 && !allow_signed)
 649                         goto error;
 650
 651                 /* check for invalid value */
 652                 if (ptr == end)
 653                         goto error;
 654
 655                 /* check for valid suffix */
 656                 switch (*end) {
 657                 case 't':
 658                 case 'T':
 659                         shift = 40;
 660                         end++;
 661                         break;
 662                 case 'g':
 663                 case 'G':
 664                         shift = 30;
 665                         end++;
 666                         break;
 667                 case 'm':
 668                 case 'M':
 669                         shift = 20;
 670                         end++;
 671                         break;
 672                 case 'k':
 673                 case 'K':
 674                         shift = 10;
 675                         end++;
 676                         break;
 677                 case ' ':
 678                 case '\t':
 679                 case ',':
 680                 case 0:
 681                         shift = 0;
 682                         break;
 683                 default:
 684                         /* garbage after numeric value */
 685                         goto error;
 686                 }
 687
 688                 /* skip till next value, if any */
 689                 while (*end == '\t' || *end == ',' || *end == ' ')
 690                         end++;
 691
 692                 /* update pointer */
 693                 ptr = end;
 694
 695                 /* apply shift */
 696                 old = value;
 697                 value <<= shift;
 698
 699                 /* overflow check */
 700                 if ((value >> shift) != old)
 701                         goto error;
 702
 703                 /* check for buffer overflow */
 704                 if (n >= size)
 705                         goto error;
 706
 707                 /* store value according to type size */
 708                 switch (type_size) {
 709                 case 1:
 710                         if (allow_signed) {
 711                                 if (value < SCHAR_MIN || value > SCHAR_MAX)
 712                                         goto error;
 713                         } else {
 714                                 if (value < 0 || value > UCHAR_MAX)
 715                                         goto error;
 716                         }
 717                         ((uint8_t *)pdata)[n] = (uint8_t)value;
 718                         break;
 719                 case 2:
 720                         if (allow_signed) {
 721                                 if (value < SHRT_MIN || value > SHRT_MAX)
 722                                         goto error;
 723                         } else {
 724                                 if (value < 0 || value > USHRT_MAX)
 725                                         goto error;
 726                         }
 727                         ((uint16_t *)pdata)[n] = (uint16_t)value;
 728                         break;
 729                 case 4:
 730                         if (allow_signed) {
 731                                 if (value < INT_MIN || value > INT_MAX)
 732                                         goto error;
 733                         } else {
 734                                 if (value > UINT_MAX)
 735                                         goto error;
 736                         }
 737                         ((uint32_t *)pdata)[n] = (uint32_t)value;
 738                         break;
 739                 case 8:
 740                         ((uint64_t *)pdata)[n] = (uint64_t)value;
 741                         break;
 742                 default:
 743                         goto error;
 744                 }
 745                 n++;
 746         }
 747         *psize = n * type_size;
 748
 749         if (n != 0)
 750                 return (1);     /* success */
 751 error:
 752         return (0);     /* failure */
 753 }
 754
 755 /*
 756  * Return an integer value from an environment variable.
 757  */
 758 int
 759 getenv_int(const char *name, int *data)
 760 {
 761         quad_t tmp;
 762         int rval;
 763
 764         rval = getenv_quad(name, &tmp);
 765         if (rval)
 766                 *data = (int) tmp;
 767         return (rval);
 768 }
 769
 770 /*
 771  * Return an unsigned integer value from an environment variable.
 772  */
 773 int
 774 getenv_uint(const char *name, unsigned int *data)
 775 {
 776         quad_t tmp;
 777         int rval;
 778
 779         rval = getenv_quad(name, &tmp);
 780         if (rval)
 781                 *data = (unsigned int) tmp;
 782         return (rval);
 783 }
 784
 785 /*
 786  * Return an int64_t value from an environment variable.
 787  */
 788 int
 789 getenv_int64(const char *name, int64_t *data)
 790 {
 791         quad_t tmp;
 792         int64_t rval;
 793
 794         rval = getenv_quad(name, &tmp);
 795         if (rval)
 796                 *data = (int64_t) tmp;
 797         return (rval);
 798 }
 799
 800 /*
 801  * Return an uint64_t value from an environment variable.
 802  */
 803 int
 804 getenv_uint64(const char *name, uint64_t *data)
 805 {
 806         quad_t tmp;
 807         uint64_t rval;
 808
 809         rval = getenv_quad(name, &tmp);
 810         if (rval)
 811                 *data = (uint64_t) tmp;
 812         return (rval);
 813 }
 814
 815 /*
 816  * Return a long value from an environment variable.
 817  */
 818 int
 819 getenv_long(const char *name, long *data)
 820 {
 821         quad_t tmp;
 822         int rval;
 823
 824         rval = getenv_quad(name, &tmp);
 825         if (rval)
 826                 *data = (long) tmp;
 827         return (rval);
 828 }
 829
 830 /*
 831  * Return an unsigned long value from an environment variable.
 832  */
 833 int
 834 getenv_ulong(const char *name, unsigned long *data)
 835 {
 836         quad_t tmp;
 837         int rval;
 838
 839         rval = getenv_quad(name, &tmp);
 840         if (rval)
 841                 *data = (unsigned long) tmp;
 842         return (rval);
 843 }
 844
 845 /*
 846  * Return a quad_t value from an environment variable.
 847  */
 848 int
 849 getenv_quad(const char *name, quad_t *data)
 850 {
 851         char    value[KENV_MNAMELEN + 1 + KENV_MVALLEN + 1];
 852         char    *vtp;
 853         quad_t  iv;
 854
 855         if (!getenv_string(name, value, sizeof(value)))
 856                 return (0);
 857         iv = strtoq(value, &vtp, 0);
 858         if (vtp == value || (vtp[0] != '\0' && vtp[1] != '\0'))
 859                 return (0);
 860         switch (vtp[0]) {
 861         case 't': case 'T':
 862                 iv *= 1024;
 863         case 'g': case 'G':
 864                 iv *= 1024;
 865         case 'm': case 'M':
 866                 iv *= 1024;
 867         case 'k': case 'K':
 868                 iv *= 1024;
 869         case '\0':
 870                 break;
 871         default:
 872                 return (0);
 873         }
 874         *data = iv;
 875         return (1);
 876 }
 877
 878 /*
 879  * Find the next entry after the one which (cp) falls within, return a
 880  * pointer to its start or NULL if there are no more.
 881  */
 882 static char *
 883 kernenv_next(char *cp)
 884 {
 885
 886         if (cp != NULL) {
 887                 while (*cp != 0)
 888                         cp++;
 889                 cp++;
 890                 if (*cp == 0)
 891                         cp = NULL;
 892         }
 893         return (cp);
 894 }
 895
 896 void
 897 tunable_int_init(void *data)
 898 {
 899         struct tunable_int *d = (struct tunable_int *)data;
 900
 901         TUNABLE_INT_FETCH(d->path, d->var);
 902 }
 903
 904 void
 905 tunable_long_init(void *data)
 906 {
 907         struct tunable_long *d = (struct tunable_long *)data;
 908
 909         TUNABLE_LONG_FETCH(d->path, d->var);
 910 }
 911
 912 void
 913 tunable_ulong_init(void *data)
 914 {
 915         struct tunable_ulong *d = (struct tunable_ulong *)data;
 916
 917         TUNABLE_ULONG_FETCH(d->path, d->var);
 918 }
 919
 920 void
 921 tunable_int64_init(void *data)
 922 {
 923         struct tunable_int64 *d = (struct tunable_int64 *)data;
 924
 925         TUNABLE_INT64_FETCH(d->path, d->var);
 926 }
 927
 928 void
 929 tunable_uint64_init(void *data)
 930 {
 931         struct tunable_uint64 *d = (struct tunable_uint64 *)data;
 932
 933         TUNABLE_UINT64_FETCH(d->path, d->var);
 934 }
 935
 936 void
 937 tunable_quad_init(void *data)
 938 {
 939         struct tunable_quad *d = (struct tunable_quad *)data;
 940
 941         TUNABLE_QUAD_FETCH(d->path, d->var);
 942 }
 943
 944 void
 945 tunable_str_init(void *data)
 946 {
 947         struct tunable_str *d = (struct tunable_str *)data;
 948
 949         TUNABLE_STR_FETCH(d->path, d->var, d->size);
 950 }