sbin/sysctl/sysctl.c

   1 /*
   2  * Copyright (c) 1993
   3  *      The Regents of the University of California.  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  * 4. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #ifndef lint
  31 static const char copyright[] =
  32 "@(#) Copyright (c) 1993\n\
  33         The Regents of the University of California.  All rights reserved.\n";
  34 #endif /* not lint */
  35
  36 #ifndef lint
  37 #if 0
  38 static char sccsid[] = "@(#)from: sysctl.c      8.1 (Berkeley) 6/6/93";
  39 #endif
  40 static const char rcsid[] =
  41   "$FreeBSD$";
  42 #endif /* not lint */
  43
  44 #include <sys/param.h>
  45 #include <sys/time.h>
  46 #include <sys/resource.h>
  47 #include <sys/stat.h>
  48 #include <sys/sysctl.h>
  49 #include <sys/vmmeter.h>
  50
  51 #ifdef __amd64__
  52 #include <sys/efi.h>
  53 #include <machine/metadata.h>
  54 #endif
  55
  56 #if defined(__amd64__) || defined(__i386__)
  57 #include <machine/pc/bios.h>
  58 #endif
  59
  60 #include <ctype.h>
  61 #include <err.h>
  62 #include <errno.h>
  63 #include <inttypes.h>
  64 #include <locale.h>
  65 #include <stdio.h>
  66 #include <stdlib.h>
  67 #include <string.h>
  68 #include <sysexits.h>
  69 #include <unistd.h>
  70
  71 static const char *conffile;
  72
  73 static int      aflag, bflag, dflag, eflag, hflag, iflag;
  74 static int      Nflag, nflag, oflag, qflag, Tflag, Wflag, xflag;
  75
  76 static int      oidfmt(int *, int, char *, u_int *);
  77 static int      parsefile(const char *);
  78 static int      parse(const char *, int);
  79 static int      show_var(int *, int);
  80 static int      sysctl_all(int *oid, int len);
  81 static int      name2oid(const char *, int *);
  82
  83 static int      set_IK(const char *, int *);
  84
  85 static void
  86 usage(void)
  87 {
  88
  89         (void)fprintf(stderr, "%s\n%s\n",
  90             "usage: sysctl [-bdehiNnoqTWx] [-f filename] name[=value] ...",
  91             "       sysctl [-bdehNnoqTWx] -a");
  92         exit(1);
  93 }
  94
  95 int
  96 main(int argc, char **argv)
  97 {
  98         int ch;
  99         int warncount = 0;
 100
 101         setlocale(LC_NUMERIC, "");
 102         setbuf(stdout,0);
 103         setbuf(stderr,0);
 104
 105         while ((ch = getopt(argc, argv, "Aabdef:hiNnoqTwWxX")) != -1) {
 106                 switch (ch) {
 107                 case 'A':
 108                         /* compatibility */
 109                         aflag = oflag = 1;
 110                         break;
 111                 case 'a':
 112                         aflag = 1;
 113                         break;
 114                 case 'b':
 115                         bflag = 1;
 116                         break;
 117                 case 'd':
 118                         dflag = 1;
 119                         break;
 120                 case 'e':
 121                         eflag = 1;
 122                         break;
 123                 case 'f':
 124                         conffile = optarg;
 125                         break;
 126                 case 'h':
 127                         hflag = 1;
 128                         break;
 129                 case 'i':
 130                         iflag = 1;
 131                         break;
 132                 case 'N':
 133                         Nflag = 1;
 134                         break;
 135                 case 'n':
 136                         nflag = 1;
 137                         break;
 138                 case 'o':
 139                         oflag = 1;
 140                         break;
 141                 case 'q':
 142                         qflag = 1;
 143                         break;
 144                 case 'T':
 145                         Tflag = 1;
 146                         break;
 147                 case 'w':
 148                         /* compatibility */
 149                         /* ignored */
 150                         break;
 151                 case 'W':
 152                         Wflag = 1;
 153                         break;
 154                 case 'X':
 155                         /* compatibility */
 156                         aflag = xflag = 1;
 157                         break;
 158                 case 'x':
 159                         xflag = 1;
 160                         break;
 161                 default:
 162                         usage();
 163                 }
 164         }
 165         argc -= optind;
 166         argv += optind;
 167
 168         if (Nflag && nflag)
 169                 usage();
 170         if (aflag && argc == 0)
 171                 exit(sysctl_all(0, 0));
 172         if (argc == 0 && conffile == NULL)
 173                 usage();
 174
 175         warncount = 0;
 176         if (conffile != NULL)
 177                 warncount += parsefile(conffile);
 178
 179         while (argc-- > 0)
 180                 warncount += parse(*argv++, 0);
 181
 182         return (warncount);
 183 }
 184
 185 /*
 186  * Parse a name into a MIB entry.
 187  * Lookup and print out the MIB entry if it exists.
 188  * Set a new value if requested.
 189  */
 190 static int
 191 parse(const char *string, int lineno)
 192 {
 193         int len, i, j;
 194         void *newval = 0;
 195         int intval;
 196         unsigned int uintval;
 197         long longval;
 198         unsigned long ulongval;
 199         size_t newsize = 0;
 200         int64_t i64val;
 201         uint64_t u64val;
 202         int mib[CTL_MAXNAME];
 203         char *cp, *bufp, buf[BUFSIZ], *endptr, fmt[BUFSIZ], line[BUFSIZ];
 204         u_int kind;
 205
 206         if (lineno)
 207                 snprintf(line, sizeof(line), " at line %d", lineno);
 208         else
 209                 line[0] = '\0';
 210
 211         cp = buf;
 212         if (snprintf(buf, BUFSIZ, "%s", string) >= BUFSIZ) {
 213                 warnx("oid too long: '%s'%s", string, line);
 214                 return (1);
 215         }
 216         bufp = strsep(&cp, "=:");
 217         if (cp != NULL) {
 218                 /* Tflag just lists tunables, do not allow assignment */
 219                 if (Tflag || Wflag) {
 220                         warnx("Can't set variables when using -T or -W");
 221                         usage();
 222                 }
 223                 while (isspace(*cp))
 224                         cp++;
 225                 /* Strip a pair of " or ' if any. */
 226                 switch (*cp) {
 227                 case '\"':
 228                 case '\'':
 229                         if (cp[strlen(cp) - 1] == *cp)
 230                                 cp[strlen(cp) - 1] = '\0';
 231                         cp++;
 232                 }
 233                 newval = cp;
 234                 newsize = strlen(cp);
 235         }
 236         /* Trim spaces */
 237         cp = bufp + strlen(bufp) - 1;
 238         while (cp >= bufp && isspace((int)*cp)) {
 239                 *cp = '\0';
 240                 cp--;
 241         }
 242         len = name2oid(bufp, mib);
 243
 244         if (len < 0) {
 245                 if (iflag)
 246                         return (0);
 247                 if (qflag)
 248                         return (1);
 249                 else {
 250                         warn("unknown oid '%s'%s", bufp, line);
 251                         return (1);
 252                 }
 253         }
 254
 255         if (oidfmt(mib, len, fmt, &kind)) {
 256                 warn("couldn't find format of oid '%s'%s", bufp, line);
 257                 if (iflag)
 258                         return (1);
 259                 else
 260                         exit(1);
 261         }
 262
 263         if (newval == NULL || dflag) {
 264                 if ((kind & CTLTYPE) == CTLTYPE_NODE) {
 265                         if (dflag) {
 266                                 i = show_var(mib, len);
 267                                 if (!i && !bflag)
 268                                         putchar('\n');
 269                         }
 270                         sysctl_all(mib, len);
 271                 } else {
 272                         i = show_var(mib, len);
 273                         if (!i && !bflag)
 274                                 putchar('\n');
 275                 }
 276         } else {
 277                 if ((kind & CTLTYPE) == CTLTYPE_NODE) {
 278                         warnx("oid '%s' isn't a leaf node%s", bufp, line);
 279                         return (1);
 280                 }
 281
 282                 if (!(kind & CTLFLAG_WR)) {
 283                         if (kind & CTLFLAG_TUN) {
 284                                 warnx("oid '%s' is a read only tunable%s", bufp, line);
 285                                 warnx("Tunable values are set in /boot/loader.conf");
 286                         } else
 287                                 warnx("oid '%s' is read only%s", bufp, line);
 288                         return (1);
 289                 }
 290
 291                 if ((kind & CTLTYPE) == CTLTYPE_INT ||
 292                     (kind & CTLTYPE) == CTLTYPE_UINT ||
 293                     (kind & CTLTYPE) == CTLTYPE_LONG ||
 294                     (kind & CTLTYPE) == CTLTYPE_ULONG ||
 295                     (kind & CTLTYPE) == CTLTYPE_S64 ||
 296                     (kind & CTLTYPE) == CTLTYPE_U64) {
 297                         if (strlen(newval) == 0) {
 298                                 warnx("empty numeric value");
 299                                 return (1);
 300                         }
 301                 }
 302
 303                 switch (kind & CTLTYPE) {
 304                         case CTLTYPE_INT:
 305                                 if (strcmp(fmt, "IK") == 0) {
 306                                         if (!set_IK(newval, &intval)) {
 307                                                 warnx("invalid value '%s'%s",
 308                                                     (char *)newval, line);
 309                                                 return (1);
 310                                         }
 311                                 } else {
 312                                         intval = (int)strtol(newval, &endptr,
 313                                             0);
 314                                         if (endptr == newval || *endptr != '\0') {
 315                                                 warnx("invalid integer '%s'%s",
 316                                                     (char *)newval, line);
 317                                                 return (1);
 318                                         }
 319                                 }
 320                                 newval = &intval;
 321                                 newsize = sizeof(intval);
 322                                 break;
 323                         case CTLTYPE_UINT:
 324                                 uintval = (int) strtoul(newval, &endptr, 0);
 325                                 if (endptr == newval || *endptr != '\0') {
 326                                         warnx("invalid unsigned integer '%s'%s",
 327                                             (char *)newval, line);
 328                                         return (1);
 329                                 }
 330                                 newval = &uintval;
 331                                 newsize = sizeof(uintval);
 332                                 break;
 333                         case CTLTYPE_LONG:
 334                                 longval = strtol(newval, &endptr, 0);
 335                                 if (endptr == newval || *endptr != '\0') {
 336                                         warnx("invalid long integer '%s'%s",
 337                                             (char *)newval, line);
 338                                         return (1);
 339                                 }
 340                                 newval = &longval;
 341                                 newsize = sizeof(longval);
 342                                 break;
 343                         case CTLTYPE_ULONG:
 344                                 ulongval = strtoul(newval, &endptr, 0);
 345                                 if (endptr == newval || *endptr != '\0') {
 346                                         warnx("invalid unsigned long integer"
 347                                             " '%s'%s", (char *)newval, line);
 348                                         return (1);
 349                                 }
 350                                 newval = &ulongval;
 351                                 newsize = sizeof(ulongval);
 352                                 break;
 353                         case CTLTYPE_STRING:
 354                                 break;
 355                         case CTLTYPE_S64:
 356                                 i64val = strtoimax(newval, &endptr, 0);
 357                                 if (endptr == newval || *endptr != '\0') {
 358                                         warnx("invalid int64_t '%s'%s",
 359                                             (char *)newval, line);
 360                                         return (1);
 361                                 }
 362                                 newval = &i64val;
 363                                 newsize = sizeof(i64val);
 364                                 break;
 365                         case CTLTYPE_U64:
 366                                 u64val = strtoumax(newval, &endptr, 0);
 367                                 if (endptr == newval || *endptr != '\0') {
 368                                         warnx("invalid uint64_t '%s'%s",
 369                                             (char *)newval, line);
 370                                         return (1);
 371                                 }
 372                                 newval = &u64val;
 373                                 newsize = sizeof(u64val);
 374                                 break;
 375                         case CTLTYPE_OPAQUE:
 376                                 /* FALLTHROUGH */
 377                         default:
 378                                 warnx("oid '%s' is type %d,"
 379                                         " cannot set that%s", bufp,
 380                                         kind & CTLTYPE, line);
 381                                 return (1);
 382                 }
 383
 384                 i = show_var(mib, len);
 385                 if (sysctl(mib, len, 0, 0, newval, newsize) == -1) {
 386                         if (!i && !bflag)
 387                                 putchar('\n');
 388                         switch (errno) {
 389                         case EOPNOTSUPP:
 390                                 warnx("%s: value is not available%s",
 391                                         string, line);
 392                                 return (1);
 393                         case ENOTDIR:
 394                                 warnx("%s: specification is incomplete%s",
 395                                         string, line);
 396                                 return (1);
 397                         case ENOMEM:
 398                                 warnx("%s: type is unknown to this program%s",
 399                                         string, line);
 400                                 return (1);
 401                         default:
 402                                 warn("%s%s", string, line);
 403                                 return (1);
 404                         }
 405                 }
 406                 if (!bflag)
 407                         printf(" -> ");
 408                 i = nflag;
 409                 nflag = 1;
 410                 j = show_var(mib, len);
 411                 if (!j && !bflag)
 412                         putchar('\n');
 413                 nflag = i;
 414         }
 415
 416         return (0);
 417 }
 418
 419 static int
 420 parsefile(const char *filename)
 421 {
 422         FILE *file;
 423         char line[BUFSIZ], *p, *pq, *pdq;
 424         int warncount = 0, lineno = 0;
 425
 426         file = fopen(filename, "r");
 427         if (file == NULL)
 428                 err(EX_NOINPUT, "%s", filename);
 429         while (fgets(line, sizeof(line), file) != NULL) {
 430                 lineno++;
 431                 p = line;
 432                 pq = strchr(line, '\'');
 433                 pdq = strchr(line, '\"');
 434                 /* Replace the first # with \0. */
 435                 while((p = strchr(p, '#')) != NULL) {
 436                         if (pq != NULL && p > pq) {
 437                                 if ((p = strchr(pq+1, '\'')) != NULL)
 438                                         *(++p) = '\0';
 439                                 break;
 440                         } else if (pdq != NULL && p > pdq) {
 441                                 if ((p = strchr(pdq+1, '\"')) != NULL)
 442                                         *(++p) = '\0';
 443                                 break;
 444                         } else if (p == line || *(p-1) != '\\') {
 445                                 *p = '\0';
 446                                 break;
 447                         }
 448                         p++;
 449                 }
 450                 /* Trim spaces */
 451                 p = line + strlen(line) - 1;
 452                 while (p >= line && isspace((int)*p)) {
 453                         *p = '\0';
 454                         p--;
 455                 }
 456                 p = line;
 457                 while (isspace((int)*p))
 458                         p++;
 459                 if (*p == '\0')
 460                         continue;
 461                 else
 462                         warncount += parse(p, lineno);
 463         }
 464         fclose(file);
 465
 466         return (warncount);
 467 }
 468
 469 /* These functions will dump out various interesting structures. */
 470
 471 static int
 472 S_clockinfo(size_t l2, void *p)
 473 {
 474         struct clockinfo *ci = (struct clockinfo*)p;
 475
 476         if (l2 != sizeof(*ci)) {
 477                 warnx("S_clockinfo %zu != %zu", l2, sizeof(*ci));
 478                 return (1);
 479         }
 480         printf(hflag ? "{ hz = %'d, tick = %'d, profhz = %'d, stathz = %'d }" :
 481                 "{ hz = %d, tick = %d, profhz = %d, stathz = %d }",
 482                 ci->hz, ci->tick, ci->profhz, ci->stathz);
 483         return (0);
 484 }
 485
 486 static int
 487 S_loadavg(size_t l2, void *p)
 488 {
 489         struct loadavg *tv = (struct loadavg*)p;
 490
 491         if (l2 != sizeof(*tv)) {
 492                 warnx("S_loadavg %zu != %zu", l2, sizeof(*tv));
 493                 return (1);
 494         }
 495         printf(hflag ? "{ %'.2f %'.2f %'.2f }" : "{ %.2f %.2f %.2f }",
 496                 (double)tv->ldavg[0]/(double)tv->fscale,
 497                 (double)tv->ldavg[1]/(double)tv->fscale,
 498                 (double)tv->ldavg[2]/(double)tv->fscale);
 499         return (0);
 500 }
 501
 502 static int
 503 S_timeval(size_t l2, void *p)
 504 {
 505         struct timeval *tv = (struct timeval*)p;
 506         time_t tv_sec;
 507         char *p1, *p2;
 508
 509         if (l2 != sizeof(*tv)) {
 510                 warnx("S_timeval %zu != %zu", l2, sizeof(*tv));
 511                 return (1);
 512         }
 513         printf(hflag ? "{ sec = %'jd, usec = %'ld } " :
 514                 "{ sec = %jd, usec = %ld } ",
 515                 (intmax_t)tv->tv_sec, tv->tv_usec);
 516         tv_sec = tv->tv_sec;
 517         p1 = strdup(ctime(&tv_sec));
 518         for (p2=p1; *p2 ; p2++)
 519                 if (*p2 == '\n')
 520                         *p2 = '\0';
 521         fputs(p1, stdout);
 522         free(p1);
 523         return (0);
 524 }
 525
 526 static int
 527 S_vmtotal(size_t l2, void *p)
 528 {
 529         struct vmtotal *v = (struct vmtotal *)p;
 530         int pageKilo = getpagesize() / 1024;
 531
 532         if (l2 != sizeof(*v)) {
 533                 warnx("S_vmtotal %zu != %zu", l2, sizeof(*v));
 534                 return (1);
 535         }
 536
 537         printf(
 538             "\nSystem wide totals computed every five seconds:"
 539             " (values in kilobytes)\n");
 540         printf("===============================================\n");
 541         printf(
 542             "Processes:\t\t(RUNQ: %hd Disk Wait: %hd Page Wait: "
 543             "%hd Sleep: %hd)\n",
 544             v->t_rq, v->t_dw, v->t_pw, v->t_sl);
 545         printf(
 546             "Virtual Memory:\t\t(Total: %dK Active: %dK)\n",
 547             v->t_vm * pageKilo, v->t_avm * pageKilo);
 548         printf("Real Memory:\t\t(Total: %dK Active: %dK)\n",
 549             v->t_rm * pageKilo, v->t_arm * pageKilo);
 550         printf("Shared Virtual Memory:\t(Total: %dK Active: %dK)\n",
 551             v->t_vmshr * pageKilo, v->t_avmshr * pageKilo);
 552         printf("Shared Real Memory:\t(Total: %dK Active: %dK)\n",
 553             v->t_rmshr * pageKilo, v->t_armshr * pageKilo);
 554         printf("Free Memory:\t%dK", v->t_free * pageKilo);
 555
 556         return (0);
 557 }
 558
 559 #ifdef __amd64__
 560 #define efi_next_descriptor(ptr, size) \
 561         ((struct efi_md *)(((uint8_t *) ptr) + size))
 562
 563 static int
 564 S_efi_map(size_t l2, void *p)
 565 {
 566         struct efi_map_header *efihdr;
 567         struct efi_md *map;
 568         const char *type;
 569         size_t efisz;
 570         int ndesc, i;
 571
 572         static const char *types[] = {
 573                 "Reserved",
 574                 "LoaderCode",
 575                 "LoaderData",
 576                 "BootServicesCode",
 577                 "BootServicesData",
 578                 "RuntimeServicesCode",
 579                 "RuntimeServicesData",
 580                 "ConventionalMemory",
 581                 "UnusableMemory",
 582                 "ACPIReclaimMemory",
 583                 "ACPIMemoryNVS",
 584                 "MemoryMappedIO",
 585                 "MemoryMappedIOPortSpace",
 586                 "PalCode"
 587         };
 588
 589         /*
 590          * Memory map data provided by UEFI via the GetMemoryMap
 591          * Boot Services API.
 592          */
 593         if (l2 < sizeof(*efihdr)) {
 594                 warnx("S_efi_map length less than header");
 595                 return (1);
 596         }
 597         efihdr = p;
 598         efisz = (sizeof(struct efi_map_header) + 0xf) & ~0xf;
 599         map = (struct efi_md *)((uint8_t *)efihdr + efisz);
 600
 601         if (efihdr->descriptor_size == 0)
 602                 return (0);
 603         if (l2 != efisz + efihdr->memory_size) {
 604                 warnx("S_efi_map length mismatch %zu vs %zu", l2, efisz +
 605                     efihdr->memory_size);
 606                 return (1);
 607         }
 608         ndesc = efihdr->memory_size / efihdr->descriptor_size;
 609
 610         printf("\n%23s %12s %12s %8s %4s",
 611             "Type", "Physical", "Virtual", "#Pages", "Attr");
 612
 613         for (i = 0; i < ndesc; i++,
 614             map = efi_next_descriptor(map, efihdr->descriptor_size)) {
 615                 if (map->md_type <= EFI_MD_TYPE_PALCODE)
 616                         type = types[map->md_type];
 617                 else
 618                         type = "<INVALID>";
 619                 printf("\n%23s %012lx %12p %08lx ", type, map->md_phys,
 620                     map->md_virt, map->md_pages);
 621                 if (map->md_attr & EFI_MD_ATTR_UC)
 622                         printf("UC ");
 623                 if (map->md_attr & EFI_MD_ATTR_WC)
 624                         printf("WC ");
 625                 if (map->md_attr & EFI_MD_ATTR_WT)
 626                         printf("WT ");
 627                 if (map->md_attr & EFI_MD_ATTR_WB)
 628                         printf("WB ");
 629                 if (map->md_attr & EFI_MD_ATTR_UCE)
 630                         printf("UCE ");
 631                 if (map->md_attr & EFI_MD_ATTR_WP)
 632                         printf("WP ");
 633                 if (map->md_attr & EFI_MD_ATTR_RP)
 634                         printf("RP ");
 635                 if (map->md_attr & EFI_MD_ATTR_XP)
 636                         printf("XP ");
 637                 if (map->md_attr & EFI_MD_ATTR_RT)
 638                         printf("RUNTIME");
 639         }
 640         return (0);
 641 }
 642 #endif
 643
 644 #if defined(__amd64__) || defined(__i386__)
 645 static int
 646 S_bios_smap_xattr(size_t l2, void *p)
 647 {
 648         struct bios_smap_xattr *smap, *end;
 649
 650         if (l2 % sizeof(*smap) != 0) {
 651                 warnx("S_bios_smap_xattr %zu is not a multiple of %zu", l2,
 652                     sizeof(*smap));
 653                 return (1);
 654         }
 655
 656         end = (struct bios_smap_xattr *)((char *)p + l2);
 657         for (smap = p; smap < end; smap++)
 658                 printf("\nSMAP type=%02x, xattr=%02x, base=%016jx, len=%016jx",
 659                     smap->type, smap->xattr, (uintmax_t)smap->base,
 660                     (uintmax_t)smap->length);
 661         return (0);
 662 }
 663 #endif
 664
 665 static int
 666 set_IK(const char *str, int *val)
 667 {
 668         float temp;
 669         int len, kelv;
 670         const char *p;
 671         char *endptr;
 672
 673         if ((len = strlen(str)) == 0)
 674                 return (0);
 675         p = &str[len - 1];
 676         if (*p == 'C' || *p == 'F') {
 677                 temp = strtof(str, &endptr);
 678                 if (endptr == str || endptr != p)
 679                         return (0);
 680                 if (*p == 'F')
 681                         temp = (temp - 32) * 5 / 9;
 682                 kelv = temp * 10 + 2732;
 683         } else {
 684                 kelv = (int)strtol(str, &endptr, 10);
 685                 if (endptr == str || *endptr != '\0')
 686                         return (0);
 687         }
 688         *val = kelv;
 689         return (1);
 690 }
 691
 692 /*
 693  * These functions uses a presently undocumented interface to the kernel
 694  * to walk the tree and get the type so it can print the value.
 695  * This interface is under work and consideration, and should probably
 696  * be killed with a big axe by the first person who can find the time.
 697  * (be aware though, that the proper interface isn't as obvious as it
 698  * may seem, there are various conflicting requirements.
 699  */
 700
 701 static int
 702 name2oid(const char *name, int *oidp)
 703 {
 704         int oid[2];
 705         int i;
 706         size_t j;
 707
 708         oid[0] = 0;
 709         oid[1] = 3;
 710
 711         j = CTL_MAXNAME * sizeof(int);
 712         i = sysctl(oid, 2, oidp, &j, name, strlen(name));
 713         if (i < 0)
 714                 return (i);
 715         j /= sizeof(int);
 716         return (j);
 717 }
 718
 719 static int
 720 oidfmt(int *oid, int len, char *fmt, u_int *kind)
 721 {
 722         int qoid[CTL_MAXNAME+2];
 723         u_char buf[BUFSIZ];
 724         int i;
 725         size_t j;
 726
 727         qoid[0] = 0;
 728         qoid[1] = 4;
 729         memcpy(qoid + 2, oid, len * sizeof(int));
 730
 731         j = sizeof(buf);
 732         i = sysctl(qoid, len + 2, buf, &j, 0, 0);
 733         if (i)
 734                 err(1, "sysctl fmt %d %zu %d", i, j, errno);
 735
 736         if (kind)
 737                 *kind = *(u_int *)buf;
 738
 739         if (fmt)
 740                 strcpy(fmt, (char *)(buf + sizeof(u_int)));
 741         return (0);
 742 }
 743
 744 static int ctl_sign[CTLTYPE+1] = {
 745         [CTLTYPE_INT] = 1,
 746         [CTLTYPE_LONG] = 1,
 747         [CTLTYPE_S64] = 1,
 748 };
 749
 750 static int ctl_size[CTLTYPE+1] = {
 751         [CTLTYPE_INT] = sizeof(int),
 752         [CTLTYPE_UINT] = sizeof(u_int),
 753         [CTLTYPE_LONG] = sizeof(long),
 754         [CTLTYPE_ULONG] = sizeof(u_long),
 755         [CTLTYPE_S64] = sizeof(int64_t),
 756         [CTLTYPE_U64] = sizeof(int64_t),
 757 };
 758
 759 /*
 760  * This formats and outputs the value of one variable
 761  *
 762  * Returns zero if anything was actually output.
 763  * Returns one if didn't know what to do with this.
 764  * Return minus one if we had errors.
 765  */
 766 static int
 767 show_var(int *oid, int nlen)
 768 {
 769         u_char buf[BUFSIZ], *val, *oval, *p;
 770         char name[BUFSIZ], fmt[BUFSIZ];
 771         const char *sep, *sep1;
 772         int qoid[CTL_MAXNAME+2];
 773         uintmax_t umv;
 774         intmax_t mv;
 775         int i, hexlen, sign, ctltype;
 776         size_t intlen;
 777         size_t j, len;
 778         u_int kind;
 779         int (*func)(size_t, void *);
 780
 781         /* Silence GCC. */
 782         umv = mv = intlen = 0;
 783
 784         bzero(buf, BUFSIZ);
 785         bzero(fmt, BUFSIZ);
 786         bzero(name, BUFSIZ);
 787         qoid[0] = 0;
 788         memcpy(qoid + 2, oid, nlen * sizeof(int));
 789
 790         qoid[1] = 1;
 791         j = sizeof(name);
 792         i = sysctl(qoid, nlen + 2, name, &j, 0, 0);
 793         if (i || !j)
 794                 err(1, "sysctl name %d %zu %d", i, j, errno);
 795
 796         oidfmt(oid, nlen, fmt, &kind);
 797         /* if Wflag then only list sysctls that are writeable and not stats. */
 798         if (Wflag && ((kind & CTLFLAG_WR) == 0 || (kind & CTLFLAG_STATS) != 0))
 799                 return 1;
 800
 801         /* if Tflag then only list sysctls that are tuneables. */
 802         if (Tflag && (kind & CTLFLAG_TUN) == 0)
 803                 return 1;
 804
 805         if (Nflag) {
 806                 printf("%s", name);
 807                 return (0);
 808         }
 809
 810         if (eflag)
 811                 sep = "=";
 812         else
 813                 sep = ": ";
 814
 815         if (dflag) {    /* just print description */
 816                 qoid[1] = 5;
 817                 j = sizeof(buf);
 818                 i = sysctl(qoid, nlen + 2, buf, &j, 0, 0);
 819                 if (!nflag)
 820                         printf("%s%s", name, sep);
 821                 printf("%s", buf);
 822                 return (0);
 823         }
 824         /* find an estimate of how much we need for this var */
 825         j = 0;
 826         i = sysctl(oid, nlen, 0, &j, 0, 0);
 827         j += j; /* we want to be sure :-) */
 828
 829         val = oval = malloc(j + 1);
 830         if (val == NULL) {
 831                 warnx("malloc failed");
 832                 return (1);
 833         }
 834         ctltype = (kind & CTLTYPE);
 835         len = j;
 836         i = sysctl(oid, nlen, val, &len, 0, 0);
 837         if (i != 0 || (len == 0 && ctltype != CTLTYPE_STRING)) {
 838                 free(oval);
 839                 return (1);
 840         }
 841
 842         if (bflag) {
 843                 fwrite(val, 1, len, stdout);
 844                 free(oval);
 845                 return (0);
 846         }
 847         val[len] = '\0';
 848         p = val;
 849         sign = ctl_sign[ctltype];
 850         intlen = ctl_size[ctltype];
 851
 852         switch (ctltype) {
 853         case CTLTYPE_STRING:
 854                 if (!nflag)
 855                         printf("%s%s", name, sep);
 856                 printf("%.*s", (int)len, p);
 857                 free(oval);
 858                 return (0);
 859
 860         case CTLTYPE_INT:
 861         case CTLTYPE_UINT:
 862         case CTLTYPE_LONG:
 863         case CTLTYPE_ULONG:
 864         case CTLTYPE_S64:
 865         case CTLTYPE_U64:
 866                 if (!nflag)
 867                         printf("%s%s", name, sep);
 868                 hexlen = 2 + (intlen * CHAR_BIT + 3) / 4;
 869                 sep1 = "";
 870                 while (len >= intlen) {
 871                         switch (kind & CTLTYPE) {
 872                         case CTLTYPE_INT:
 873                         case CTLTYPE_UINT:
 874                                 umv = *(u_int *)p;
 875                                 mv = *(int *)p;
 876                                 break;
 877                         case CTLTYPE_LONG:
 878                         case CTLTYPE_ULONG:
 879                                 umv = *(u_long *)p;
 880                                 mv = *(long *)p;
 881                                 break;
 882                         case CTLTYPE_S64:
 883                         case CTLTYPE_U64:
 884                                 umv = *(uint64_t *)p;
 885                                 mv = *(int64_t *)p;
 886                                 break;
 887                         }
 888                         fputs(sep1, stdout);
 889                         if (xflag)
 890                                 printf("%#0*jx", hexlen, umv);
 891                         else if (!sign)
 892                                 printf(hflag ? "%'ju" : "%ju", umv);
 893                         else if (fmt[1] == 'K') {
 894                                 if (mv < 0)
 895                                         printf("%jd", mv);
 896                                 else
 897                                         printf("%.1fC", (mv - 2732.0) / 10);
 898                         } else
 899                                 printf(hflag ? "%'jd" : "%jd", mv);
 900                         sep1 = " ";
 901                         len -= intlen;
 902                         p += intlen;
 903                 }
 904                 free(oval);
 905                 return (0);
 906
 907         case CTLTYPE_OPAQUE:
 908                 i = 0;
 909                 if (strcmp(fmt, "S,clockinfo") == 0)
 910                         func = S_clockinfo;
 911                 else if (strcmp(fmt, "S,timeval") == 0)
 912                         func = S_timeval;
 913                 else if (strcmp(fmt, "S,loadavg") == 0)
 914                         func = S_loadavg;
 915                 else if (strcmp(fmt, "S,vmtotal") == 0)
 916                         func = S_vmtotal;
 917 #ifdef __amd64__
 918                 else if (strcmp(fmt, "S,efi_map_header") == 0)
 919                         func = S_efi_map;
 920 #endif
 921 #if defined(__amd64__) || defined(__i386__)
 922                 else if (strcmp(fmt, "S,bios_smap_xattr") == 0)
 923                         func = S_bios_smap_xattr;
 924 #endif
 925                 else
 926                         func = NULL;
 927                 if (func) {
 928                         if (!nflag)
 929                                 printf("%s%s", name, sep);
 930                         i = (*func)(len, p);
 931                         free(oval);
 932                         return (i);
 933                 }
 934                 /* FALLTHROUGH */
 935         default:
 936                 if (!oflag && !xflag) {
 937                         free(oval);
 938                         return (1);
 939                 }
 940                 if (!nflag)
 941                         printf("%s%s", name, sep);
 942                 printf("Format:%s Length:%zu Dump:0x", fmt, len);
 943                 while (len-- && (xflag || p < val + 16))
 944                         printf("%02x", *p++);
 945                 if (!xflag && len > 16)
 946                         printf("...");
 947                 free(oval);
 948                 return (0);
 949         }
 950         free(oval);
 951         return (1);
 952 }
 953
 954 static int
 955 sysctl_all(int *oid, int len)
 956 {
 957         int name1[22], name2[22];
 958         int i, j;
 959         size_t l1, l2;
 960
 961         name1[0] = 0;
 962         name1[1] = 2;
 963         l1 = 2;
 964         if (len) {
 965                 memcpy(name1+2, oid, len * sizeof(int));
 966                 l1 += len;
 967         } else {
 968                 name1[2] = 1;
 969                 l1++;
 970         }
 971         for (;;) {
 972                 l2 = sizeof(name2);
 973                 j = sysctl(name1, l1, name2, &l2, 0, 0);
 974                 if (j < 0) {
 975                         if (errno == ENOENT)
 976                                 return (0);
 977                         else
 978                                 err(1, "sysctl(getnext) %d %zu", j, l2);
 979                 }
 980
 981                 l2 /= sizeof(int);
 982
 983                 if (len < 0 || l2 < (unsigned int)len)
 984                         return (0);
 985
 986                 for (i = 0; i < len; i++)
 987                         if (name2[i] != oid[i])
 988                                 return (0);
 989
 990                 i = show_var(name2, l2);
 991                 if (!i && !bflag)
 992                         putchar('\n');
 993
 994                 memcpy(name1+2, name2, l2 * sizeof(int));
 995                 l1 = 2 + l2;
 996         }
 997 }